11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * Server-side procedures for NFSv4. 31da177e4SLinus Torvalds * 41da177e4SLinus Torvalds * Copyright (c) 2002 The Regents of the University of Michigan. 51da177e4SLinus Torvalds * All rights reserved. 61da177e4SLinus Torvalds * 71da177e4SLinus Torvalds * Kendrick Smith <kmsmith@umich.edu> 81da177e4SLinus Torvalds * Andy Adamson <andros@umich.edu> 91da177e4SLinus Torvalds * 101da177e4SLinus Torvalds * Redistribution and use in source and binary forms, with or without 111da177e4SLinus Torvalds * modification, are permitted provided that the following conditions 121da177e4SLinus Torvalds * are met: 131da177e4SLinus Torvalds * 141da177e4SLinus Torvalds * 1. Redistributions of source code must retain the above copyright 151da177e4SLinus Torvalds * notice, this list of conditions and the following disclaimer. 161da177e4SLinus Torvalds * 2. Redistributions in binary form must reproduce the above copyright 171da177e4SLinus Torvalds * notice, this list of conditions and the following disclaimer in the 181da177e4SLinus Torvalds * documentation and/or other materials provided with the distribution. 191da177e4SLinus Torvalds * 3. Neither the name of the University nor the names of its 201da177e4SLinus Torvalds * contributors may be used to endorse or promote products derived 211da177e4SLinus Torvalds * from this software without specific prior written permission. 221da177e4SLinus Torvalds * 231da177e4SLinus Torvalds * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED 241da177e4SLinus Torvalds * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 251da177e4SLinus Torvalds * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 261da177e4SLinus Torvalds * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 271da177e4SLinus Torvalds * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 281da177e4SLinus Torvalds * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 291da177e4SLinus Torvalds * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR 301da177e4SLinus Torvalds * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 311da177e4SLinus Torvalds * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 321da177e4SLinus Torvalds * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 331da177e4SLinus Torvalds * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 341da177e4SLinus Torvalds */ 35880a3a53SJ. Bruce Fields #include <linux/fs_struct.h> 367e06b7f9SNeilBrown #include <linux/file.h> 37b0cb9085SAnna Schumaker #include <linux/falloc.h> 385a0e3ad6STejun Heo #include <linux/slab.h> 39e0639dc5SOlga Kornievskaia #include <linux/kthread.h> 40*254454a5SChuck Lever #include <linux/namei.h> 41*254454a5SChuck Lever 42624322f1SOlga Kornievskaia #include <linux/sunrpc/addr.h> 430cfcd405SDai Ngo #include <linux/nfs_ssc.h> 441da177e4SLinus Torvalds 4558e7b33aSMi Jinlong #include "idmap.h" 469a74af21SBoaz Harrosh #include "cache.h" 479a74af21SBoaz Harrosh #include "xdr4.h" 480a3adadeSJ. Bruce Fields #include "vfs.h" 498b70484cSTigran Mkrtchyan #include "current_stateid.h" 503320fef1SStanislav Kinsbursky #include "netns.h" 514ac7249eSChristoph Hellwig #include "acl.h" 529cf514ccSChristoph Hellwig #include "pnfs.h" 5331ef83dcSChristoph Hellwig #include "trace.h" 541da177e4SLinus Torvalds 55d6c9e436SChuck Lever static bool inter_copy_offload_enable; 56d6c9e436SChuck Lever module_param(inter_copy_offload_enable, bool, 0644); 57d6c9e436SChuck Lever MODULE_PARM_DESC(inter_copy_offload_enable, 58d6c9e436SChuck Lever "Enable inter server to server copy offload. Default: false"); 59d6c9e436SChuck Lever 60f4e44b39SDai Ngo #ifdef CONFIG_NFSD_V4_2_INTER_SSC 61f4e44b39SDai Ngo static int nfsd4_ssc_umount_timeout = 900000; /* default to 15 mins */ 62f4e44b39SDai Ngo module_param(nfsd4_ssc_umount_timeout, int, 0644); 63f4e44b39SDai Ngo MODULE_PARM_DESC(nfsd4_ssc_umount_timeout, 64f4e44b39SDai Ngo "idle msecs before unmount export from source server"); 65f4e44b39SDai Ngo #endif 66f4e44b39SDai Ngo 6718032ca0SDavid Quigley #ifdef CONFIG_NFSD_V4_SECURITY_LABEL 6818032ca0SDavid Quigley #include <linux/security.h> 6918032ca0SDavid Quigley 7018032ca0SDavid Quigley static inline void 7118032ca0SDavid Quigley nfsd4_security_inode_setsecctx(struct svc_fh *resfh, struct xdr_netobj *label, u32 *bmval) 7218032ca0SDavid Quigley { 732b0143b5SDavid Howells struct inode *inode = d_inode(resfh->fh_dentry); 7418032ca0SDavid Quigley int status; 7518032ca0SDavid Quigley 765955102cSAl Viro inode_lock(inode); 7718032ca0SDavid Quigley status = security_inode_setsecctx(resfh->fh_dentry, 7818032ca0SDavid Quigley label->data, label->len); 795955102cSAl Viro inode_unlock(inode); 8018032ca0SDavid Quigley 8118032ca0SDavid Quigley if (status) 8218032ca0SDavid Quigley /* 8318032ca0SDavid Quigley * XXX: We should really fail the whole open, but we may 8418032ca0SDavid Quigley * already have created a new file, so it may be too 8518032ca0SDavid Quigley * late. For now this seems the least of evils: 8618032ca0SDavid Quigley */ 8718032ca0SDavid Quigley bmval[2] &= ~FATTR4_WORD2_SECURITY_LABEL; 8818032ca0SDavid Quigley 8918032ca0SDavid Quigley return; 9018032ca0SDavid Quigley } 9118032ca0SDavid Quigley #else 9218032ca0SDavid Quigley static inline void 9318032ca0SDavid Quigley nfsd4_security_inode_setsecctx(struct svc_fh *resfh, struct xdr_netobj *label, u32 *bmval) 9418032ca0SDavid Quigley { } 9518032ca0SDavid Quigley #endif 9618032ca0SDavid Quigley 971da177e4SLinus Torvalds #define NFSDDBG_FACILITY NFSDDBG_PROC 981da177e4SLinus Torvalds 993c8e0316SYu Zhiguo static u32 nfsd_attrmask[] = { 1003c8e0316SYu Zhiguo NFSD_WRITEABLE_ATTRS_WORD0, 1013c8e0316SYu Zhiguo NFSD_WRITEABLE_ATTRS_WORD1, 1023c8e0316SYu Zhiguo NFSD_WRITEABLE_ATTRS_WORD2 1033c8e0316SYu Zhiguo }; 1043c8e0316SYu Zhiguo 1053c8e0316SYu Zhiguo static u32 nfsd41_ex_attrmask[] = { 1063c8e0316SYu Zhiguo NFSD_SUPPATTR_EXCLCREAT_WORD0, 1073c8e0316SYu Zhiguo NFSD_SUPPATTR_EXCLCREAT_WORD1, 1083c8e0316SYu Zhiguo NFSD_SUPPATTR_EXCLCREAT_WORD2 1093c8e0316SYu Zhiguo }; 1103c8e0316SYu Zhiguo 1113c8e0316SYu Zhiguo static __be32 1123c8e0316SYu Zhiguo check_attr_support(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 1133c8e0316SYu Zhiguo u32 *bmval, u32 *writable) 1143c8e0316SYu Zhiguo { 1153c8e0316SYu Zhiguo struct dentry *dentry = cstate->current_fh.fh_dentry; 11632ddd944SJ. Bruce Fields struct svc_export *exp = cstate->current_fh.fh_export; 1173c8e0316SYu Zhiguo 118916d2d84SJ. Bruce Fields if (!nfsd_attrs_supported(cstate->minorversion, bmval)) 1193c8e0316SYu Zhiguo return nfserr_attrnotsupp; 120916d2d84SJ. Bruce Fields if ((bmval[0] & FATTR4_WORD0_ACL) && !IS_POSIXACL(d_inode(dentry))) 1213c8e0316SYu Zhiguo return nfserr_attrnotsupp; 12232ddd944SJ. Bruce Fields if ((bmval[2] & FATTR4_WORD2_SECURITY_LABEL) && 12332ddd944SJ. Bruce Fields !(exp->ex_flags & NFSEXP_SECURITY_LABEL)) 12432ddd944SJ. Bruce Fields return nfserr_attrnotsupp; 125916d2d84SJ. Bruce Fields if (writable && !bmval_is_subset(bmval, writable)) 1263c8e0316SYu Zhiguo return nfserr_inval; 12747057abdSAndreas Gruenbacher if (writable && (bmval[2] & FATTR4_WORD2_MODE_UMASK) && 12847057abdSAndreas Gruenbacher (bmval[1] & FATTR4_WORD1_MODE)) 12947057abdSAndreas Gruenbacher return nfserr_inval; 1303c8e0316SYu Zhiguo return nfs_ok; 1313c8e0316SYu Zhiguo } 1323c8e0316SYu Zhiguo 1333c8e0316SYu Zhiguo static __be32 1343c8e0316SYu Zhiguo nfsd4_check_open_attributes(struct svc_rqst *rqstp, 1353c8e0316SYu Zhiguo struct nfsd4_compound_state *cstate, struct nfsd4_open *open) 1363c8e0316SYu Zhiguo { 1373c8e0316SYu Zhiguo __be32 status = nfs_ok; 1383c8e0316SYu Zhiguo 1393c8e0316SYu Zhiguo if (open->op_create == NFS4_OPEN_CREATE) { 1403c8e0316SYu Zhiguo if (open->op_createmode == NFS4_CREATE_UNCHECKED 1413c8e0316SYu Zhiguo || open->op_createmode == NFS4_CREATE_GUARDED) 1423c8e0316SYu Zhiguo status = check_attr_support(rqstp, cstate, 1433c8e0316SYu Zhiguo open->op_bmval, nfsd_attrmask); 1443c8e0316SYu Zhiguo else if (open->op_createmode == NFS4_CREATE_EXCLUSIVE4_1) 1453c8e0316SYu Zhiguo status = check_attr_support(rqstp, cstate, 1463c8e0316SYu Zhiguo open->op_bmval, nfsd41_ex_attrmask); 1473c8e0316SYu Zhiguo } 1483c8e0316SYu Zhiguo 1493c8e0316SYu Zhiguo return status; 1503c8e0316SYu Zhiguo } 1513c8e0316SYu Zhiguo 1529208faf2SYu Zhiguo static int 1539208faf2SYu Zhiguo is_create_with_attrs(struct nfsd4_open *open) 1549208faf2SYu Zhiguo { 1559208faf2SYu Zhiguo return open->op_create == NFS4_OPEN_CREATE 1569208faf2SYu Zhiguo && (open->op_createmode == NFS4_CREATE_UNCHECKED 1579208faf2SYu Zhiguo || open->op_createmode == NFS4_CREATE_GUARDED 1589208faf2SYu Zhiguo || open->op_createmode == NFS4_CREATE_EXCLUSIVE4_1); 1599208faf2SYu Zhiguo } 1609208faf2SYu Zhiguo 1619208faf2SYu Zhiguo /* 1629208faf2SYu Zhiguo * if error occurs when setting the acl, just clear the acl bit 1639208faf2SYu Zhiguo * in the returned attr bitmap. 1649208faf2SYu Zhiguo */ 1659208faf2SYu Zhiguo static void 1669208faf2SYu Zhiguo do_set_nfs4_acl(struct svc_rqst *rqstp, struct svc_fh *fhp, 1679208faf2SYu Zhiguo struct nfs4_acl *acl, u32 *bmval) 1689208faf2SYu Zhiguo { 1699208faf2SYu Zhiguo __be32 status; 1709208faf2SYu Zhiguo 1719208faf2SYu Zhiguo status = nfsd4_set_nfs4_acl(rqstp, fhp, acl); 1729208faf2SYu Zhiguo if (status) 1739208faf2SYu Zhiguo /* 1749208faf2SYu Zhiguo * We should probably fail the whole open at this point, 1759208faf2SYu Zhiguo * but we've already created the file, so it's too late; 1769208faf2SYu Zhiguo * So this seems the least of evils: 1779208faf2SYu Zhiguo */ 1789208faf2SYu Zhiguo bmval[0] &= ~FATTR4_WORD0_ACL; 1799208faf2SYu Zhiguo } 1809208faf2SYu Zhiguo 1811da177e4SLinus Torvalds static inline void 1821da177e4SLinus Torvalds fh_dup2(struct svc_fh *dst, struct svc_fh *src) 1831da177e4SLinus Torvalds { 1841da177e4SLinus Torvalds fh_put(dst); 1851da177e4SLinus Torvalds dget(src->fh_dentry); 1861da177e4SLinus Torvalds if (src->fh_export) 187bf18f163SKinglong Mee exp_get(src->fh_export); 1881da177e4SLinus Torvalds *dst = *src; 1891da177e4SLinus Torvalds } 1901da177e4SLinus Torvalds 191b37ad28bSAl Viro static __be32 192dc730e17SJ. Bruce Fields do_open_permission(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open, int accmode) 1931da177e4SLinus Torvalds { 194b37ad28bSAl Viro __be32 status; 1951da177e4SLinus Torvalds 1961da177e4SLinus Torvalds if (open->op_truncate && 1971da177e4SLinus Torvalds !(open->op_share_access & NFS4_SHARE_ACCESS_WRITE)) 1981da177e4SLinus Torvalds return nfserr_inval; 1991da177e4SLinus Torvalds 200a043226bSJ. Bruce Fields accmode |= NFSD_MAY_READ_IF_EXEC; 201a043226bSJ. Bruce Fields 2021da177e4SLinus Torvalds if (open->op_share_access & NFS4_SHARE_ACCESS_READ) 2038837abcaSMiklos Szeredi accmode |= NFSD_MAY_READ; 2049801d8a3SJ. Bruce Fields if (open->op_share_access & NFS4_SHARE_ACCESS_WRITE) 2058837abcaSMiklos Szeredi accmode |= (NFSD_MAY_WRITE | NFSD_MAY_TRUNC); 20657ecb34fSJ. Bruce Fields if (open->op_share_deny & NFS4_SHARE_DENY_READ) 2078837abcaSMiklos Szeredi accmode |= NFSD_MAY_WRITE; 2081da177e4SLinus Torvalds 2091da177e4SLinus Torvalds status = fh_verify(rqstp, current_fh, S_IFREG, accmode); 2101da177e4SLinus Torvalds 2111da177e4SLinus Torvalds return status; 2121da177e4SLinus Torvalds } 2131da177e4SLinus Torvalds 214aadab6c6SJ. Bruce Fields static __be32 nfsd_check_obj_isreg(struct svc_fh *fh) 215aadab6c6SJ. Bruce Fields { 2162b0143b5SDavid Howells umode_t mode = d_inode(fh->fh_dentry)->i_mode; 217aadab6c6SJ. Bruce Fields 218aadab6c6SJ. Bruce Fields if (S_ISREG(mode)) 219aadab6c6SJ. Bruce Fields return nfs_ok; 220aadab6c6SJ. Bruce Fields if (S_ISDIR(mode)) 221aadab6c6SJ. Bruce Fields return nfserr_isdir; 222aadab6c6SJ. Bruce Fields /* 223aadab6c6SJ. Bruce Fields * Using err_symlink as our catch-all case may look odd; but 224aadab6c6SJ. Bruce Fields * there's no other obvious error for this case in 4.0, and we 225aadab6c6SJ. Bruce Fields * happen to know that it will cause the linux v4 client to do 226aadab6c6SJ. Bruce Fields * the right thing on attempts to open something other than a 227aadab6c6SJ. Bruce Fields * regular file. 228aadab6c6SJ. Bruce Fields */ 229aadab6c6SJ. Bruce Fields return nfserr_symlink; 230aadab6c6SJ. Bruce Fields } 231aadab6c6SJ. Bruce Fields 232bbc9c36cSJ. Bruce Fields static void nfsd4_set_open_owner_reply_cache(struct nfsd4_compound_state *cstate, struct nfsd4_open *open, struct svc_fh *resfh) 2331da177e4SLinus Torvalds { 234bbc9c36cSJ. Bruce Fields if (nfsd4_has_session(cstate)) 235bbc9c36cSJ. Bruce Fields return; 236bbc9c36cSJ. Bruce Fields fh_copy_shallow(&open->op_openowner->oo_owner.so_replay.rp_openfh, 237bbc9c36cSJ. Bruce Fields &resfh->fh_handle); 238bbc9c36cSJ. Bruce Fields } 239bbc9c36cSJ. Bruce Fields 240*254454a5SChuck Lever static inline bool nfsd4_create_is_exclusive(int createmode) 241*254454a5SChuck Lever { 242*254454a5SChuck Lever return createmode == NFS4_CREATE_EXCLUSIVE || 243*254454a5SChuck Lever createmode == NFS4_CREATE_EXCLUSIVE4_1; 244*254454a5SChuck Lever } 245*254454a5SChuck Lever 246*254454a5SChuck Lever /* 247*254454a5SChuck Lever * Implement NFSv4's unchecked, guarded, and exclusive create 248*254454a5SChuck Lever * semantics for regular files. Open state for this new file is 249*254454a5SChuck Lever * subsequently fabricated in nfsd4_process_open2(). 250*254454a5SChuck Lever * 251*254454a5SChuck Lever * Upon return, caller must release @fhp and @resfhp. 252*254454a5SChuck Lever */ 253*254454a5SChuck Lever static __be32 254*254454a5SChuck Lever nfsd4_create_file(struct svc_rqst *rqstp, struct svc_fh *fhp, 255*254454a5SChuck Lever struct svc_fh *resfhp, struct nfsd4_open *open) 256*254454a5SChuck Lever { 257*254454a5SChuck Lever struct iattr *iap = &open->op_iattr; 258*254454a5SChuck Lever struct dentry *parent, *child; 259*254454a5SChuck Lever __u32 v_mtime, v_atime; 260*254454a5SChuck Lever struct inode *inode; 261*254454a5SChuck Lever __be32 status; 262*254454a5SChuck Lever int host_err; 263*254454a5SChuck Lever 264*254454a5SChuck Lever if (isdotent(open->op_fname, open->op_fnamelen)) 265*254454a5SChuck Lever return nfserr_exist; 266*254454a5SChuck Lever if (!(iap->ia_valid & ATTR_MODE)) 267*254454a5SChuck Lever iap->ia_mode = 0; 268*254454a5SChuck Lever 269*254454a5SChuck Lever status = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_EXEC); 270*254454a5SChuck Lever if (status != nfs_ok) 271*254454a5SChuck Lever return status; 272*254454a5SChuck Lever parent = fhp->fh_dentry; 273*254454a5SChuck Lever inode = d_inode(parent); 274*254454a5SChuck Lever 275*254454a5SChuck Lever host_err = fh_want_write(fhp); 276*254454a5SChuck Lever if (host_err) 277*254454a5SChuck Lever return nfserrno(host_err); 278*254454a5SChuck Lever 279*254454a5SChuck Lever fh_lock_nested(fhp, I_MUTEX_PARENT); 280*254454a5SChuck Lever 281*254454a5SChuck Lever child = lookup_one_len(open->op_fname, parent, open->op_fnamelen); 282*254454a5SChuck Lever if (IS_ERR(child)) { 283*254454a5SChuck Lever status = nfserrno(PTR_ERR(child)); 284*254454a5SChuck Lever goto out; 285*254454a5SChuck Lever } 286*254454a5SChuck Lever 287*254454a5SChuck Lever if (d_really_is_negative(child)) { 288*254454a5SChuck Lever status = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_CREATE); 289*254454a5SChuck Lever if (status != nfs_ok) 290*254454a5SChuck Lever goto out; 291*254454a5SChuck Lever } 292*254454a5SChuck Lever 293*254454a5SChuck Lever status = fh_compose(resfhp, fhp->fh_export, child, fhp); 294*254454a5SChuck Lever if (status != nfs_ok) 295*254454a5SChuck Lever goto out; 296*254454a5SChuck Lever 297*254454a5SChuck Lever v_mtime = 0; 298*254454a5SChuck Lever v_atime = 0; 299*254454a5SChuck Lever if (nfsd4_create_is_exclusive(open->op_createmode)) { 300*254454a5SChuck Lever u32 *verifier = (u32 *)open->op_verf.data; 301*254454a5SChuck Lever 302*254454a5SChuck Lever /* 303*254454a5SChuck Lever * Solaris 7 gets confused (bugid 4218508) if these have 304*254454a5SChuck Lever * the high bit set, as do xfs filesystems without the 305*254454a5SChuck Lever * "bigtime" feature. So just clear the high bits. If this 306*254454a5SChuck Lever * is ever changed to use different attrs for storing the 307*254454a5SChuck Lever * verifier, then do_open_lookup() will also need to be 308*254454a5SChuck Lever * fixed accordingly. 309*254454a5SChuck Lever */ 310*254454a5SChuck Lever v_mtime = verifier[0] & 0x7fffffff; 311*254454a5SChuck Lever v_atime = verifier[1] & 0x7fffffff; 312*254454a5SChuck Lever } 313*254454a5SChuck Lever 314*254454a5SChuck Lever if (d_really_is_positive(child)) { 315*254454a5SChuck Lever status = nfs_ok; 316*254454a5SChuck Lever 317*254454a5SChuck Lever switch (open->op_createmode) { 318*254454a5SChuck Lever case NFS4_CREATE_UNCHECKED: 319*254454a5SChuck Lever if (!d_is_reg(child)) 320*254454a5SChuck Lever break; 321*254454a5SChuck Lever 322*254454a5SChuck Lever /* 323*254454a5SChuck Lever * In NFSv4, we don't want to truncate the file 324*254454a5SChuck Lever * now. This would be wrong if the OPEN fails for 325*254454a5SChuck Lever * some other reason. Furthermore, if the size is 326*254454a5SChuck Lever * nonzero, we should ignore it according to spec! 327*254454a5SChuck Lever */ 328*254454a5SChuck Lever open->op_truncate = (iap->ia_valid & ATTR_SIZE) && 329*254454a5SChuck Lever !iap->ia_size; 330*254454a5SChuck Lever break; 331*254454a5SChuck Lever case NFS4_CREATE_GUARDED: 332*254454a5SChuck Lever status = nfserr_exist; 333*254454a5SChuck Lever break; 334*254454a5SChuck Lever case NFS4_CREATE_EXCLUSIVE: 335*254454a5SChuck Lever if (d_inode(child)->i_mtime.tv_sec == v_mtime && 336*254454a5SChuck Lever d_inode(child)->i_atime.tv_sec == v_atime && 337*254454a5SChuck Lever d_inode(child)->i_size == 0) { 338*254454a5SChuck Lever open->op_created = true; 339*254454a5SChuck Lever break; /* subtle */ 340*254454a5SChuck Lever } 341*254454a5SChuck Lever status = nfserr_exist; 342*254454a5SChuck Lever break; 343*254454a5SChuck Lever case NFS4_CREATE_EXCLUSIVE4_1: 344*254454a5SChuck Lever if (d_inode(child)->i_mtime.tv_sec == v_mtime && 345*254454a5SChuck Lever d_inode(child)->i_atime.tv_sec == v_atime && 346*254454a5SChuck Lever d_inode(child)->i_size == 0) { 347*254454a5SChuck Lever open->op_created = true; 348*254454a5SChuck Lever goto set_attr; /* subtle */ 349*254454a5SChuck Lever } 350*254454a5SChuck Lever status = nfserr_exist; 351*254454a5SChuck Lever } 352*254454a5SChuck Lever goto out; 353*254454a5SChuck Lever } 354*254454a5SChuck Lever 355*254454a5SChuck Lever if (!IS_POSIXACL(inode)) 356*254454a5SChuck Lever iap->ia_mode &= ~current_umask(); 357*254454a5SChuck Lever 358*254454a5SChuck Lever host_err = vfs_create(&init_user_ns, inode, child, iap->ia_mode, true); 359*254454a5SChuck Lever if (host_err < 0) { 360*254454a5SChuck Lever status = nfserrno(host_err); 361*254454a5SChuck Lever goto out; 362*254454a5SChuck Lever } 363*254454a5SChuck Lever open->op_created = true; 364*254454a5SChuck Lever 365*254454a5SChuck Lever /* A newly created file already has a file size of zero. */ 366*254454a5SChuck Lever if ((iap->ia_valid & ATTR_SIZE) && (iap->ia_size == 0)) 367*254454a5SChuck Lever iap->ia_valid &= ~ATTR_SIZE; 368*254454a5SChuck Lever if (nfsd4_create_is_exclusive(open->op_createmode)) { 369*254454a5SChuck Lever iap->ia_valid = ATTR_MTIME | ATTR_ATIME | 370*254454a5SChuck Lever ATTR_MTIME_SET|ATTR_ATIME_SET; 371*254454a5SChuck Lever iap->ia_mtime.tv_sec = v_mtime; 372*254454a5SChuck Lever iap->ia_atime.tv_sec = v_atime; 373*254454a5SChuck Lever iap->ia_mtime.tv_nsec = 0; 374*254454a5SChuck Lever iap->ia_atime.tv_nsec = 0; 375*254454a5SChuck Lever } 376*254454a5SChuck Lever 377*254454a5SChuck Lever set_attr: 378*254454a5SChuck Lever status = nfsd_create_setattr(rqstp, fhp, resfhp, iap); 379*254454a5SChuck Lever 380*254454a5SChuck Lever out: 381*254454a5SChuck Lever fh_unlock(fhp); 382*254454a5SChuck Lever if (child && !IS_ERR(child)) 383*254454a5SChuck Lever dput(child); 384*254454a5SChuck Lever fh_drop_write(fhp); 385*254454a5SChuck Lever return status; 386*254454a5SChuck Lever } 387*254454a5SChuck Lever 388bbc9c36cSJ. Bruce Fields static __be32 389c0e6bee4SJ. Bruce Fields do_open_lookup(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_open *open, struct svc_fh **resfh) 390bbc9c36cSJ. Bruce Fields { 391bbc9c36cSJ. Bruce Fields struct svc_fh *current_fh = &cstate->current_fh; 3927007c90fSNeil Brown int accmode; 393b37ad28bSAl Viro __be32 status; 3941da177e4SLinus Torvalds 395c0e6bee4SJ. Bruce Fields *resfh = kmalloc(sizeof(struct svc_fh), GFP_KERNEL); 396c0e6bee4SJ. Bruce Fields if (!*resfh) 39759deeb9eSJ. Bruce Fields return nfserr_jukebox; 398c0e6bee4SJ. Bruce Fields fh_init(*resfh, NFS4_FHSIZE); 399500c2481Szhengbin open->op_truncate = false; 4001da177e4SLinus Torvalds 4011da177e4SLinus Torvalds if (open->op_create) { 40279fb54abSBenny Halevy /* FIXME: check session persistence and pnfs flags. 40379fb54abSBenny Halevy * The nfsv4.1 spec requires the following semantics: 40479fb54abSBenny Halevy * 40579fb54abSBenny Halevy * Persistent | pNFS | Server REQUIRED | Client Allowed 40679fb54abSBenny Halevy * Reply Cache | server | | 40779fb54abSBenny Halevy * -------------+--------+-----------------+-------------------- 40879fb54abSBenny Halevy * no | no | EXCLUSIVE4_1 | EXCLUSIVE4_1 40979fb54abSBenny Halevy * | | | (SHOULD) 41079fb54abSBenny Halevy * | | and EXCLUSIVE4 | or EXCLUSIVE4 41179fb54abSBenny Halevy * | | | (SHOULD NOT) 41279fb54abSBenny Halevy * no | yes | EXCLUSIVE4_1 | EXCLUSIVE4_1 41379fb54abSBenny Halevy * yes | no | GUARDED4 | GUARDED4 41479fb54abSBenny Halevy * yes | yes | GUARDED4 | GUARDED4 41579fb54abSBenny Halevy */ 41679fb54abSBenny Halevy 417880a3a53SJ. Bruce Fields current->fs->umask = open->op_umask; 418*254454a5SChuck Lever status = nfsd4_create_file(rqstp, current_fh, *resfh, open); 419880a3a53SJ. Bruce Fields current->fs->umask = 0; 420749997e5SJeff Layton 42118032ca0SDavid Quigley if (!status && open->op_label.len) 422c0e6bee4SJ. Bruce Fields nfsd4_security_inode_setsecctx(*resfh, &open->op_label, open->op_bmval); 42318032ca0SDavid Quigley 42499f88726SJ. Bruce Fields /* 425ead8fb8cSKinglong Mee * Following rfc 3530 14.2.16, and rfc 5661 18.16.4 426ead8fb8cSKinglong Mee * use the returned bitmask to indicate which attributes 427ead8fb8cSKinglong Mee * we used to store the verifier: 428749997e5SJeff Layton */ 429*254454a5SChuck Lever if (nfsd4_create_is_exclusive(open->op_createmode) && status == 0) 430ead8fb8cSKinglong Mee open->op_bmval[1] |= (FATTR4_WORD1_TIME_ACCESS | 431749997e5SJeff Layton FATTR4_WORD1_TIME_MODIFY); 4324335723eSJ. Bruce Fields } else 4334335723eSJ. Bruce Fields /* 4344335723eSJ. Bruce Fields * Note this may exit with the parent still locked. 4354335723eSJ. Bruce Fields * We will hold the lock until nfsd4_open's final 4364335723eSJ. Bruce Fields * lookup, to prevent renames or unlinks until we've had 4374335723eSJ. Bruce Fields * a chance to an acquire a delegation if appropriate. 4384335723eSJ. Bruce Fields */ 4391da177e4SLinus Torvalds status = nfsd_lookup(rqstp, current_fh, 4401708e50bSChuck Lever open->op_fname, open->op_fnamelen, *resfh); 441aadab6c6SJ. Bruce Fields if (status) 442aadab6c6SJ. Bruce Fields goto out; 443c0e6bee4SJ. Bruce Fields status = nfsd_check_obj_isreg(*resfh); 444af85852dSJ. Bruce Fields if (status) 445af85852dSJ. Bruce Fields goto out; 4461da177e4SLinus Torvalds 4479208faf2SYu Zhiguo if (is_create_with_attrs(open) && open->op_acl != NULL) 448c0e6bee4SJ. Bruce Fields do_set_nfs4_acl(rqstp, *resfh, open->op_acl, open->op_bmval); 4499208faf2SYu Zhiguo 450c0e6bee4SJ. Bruce Fields nfsd4_set_open_owner_reply_cache(cstate, open, *resfh); 4517007c90fSNeil Brown accmode = NFSD_MAY_NOP; 45289f6c336SJ. Bruce Fields if (open->op_created || 45389f6c336SJ. Bruce Fields open->op_claim_type == NFS4_OPEN_CLAIM_DELEGATE_CUR) 4547007c90fSNeil Brown accmode |= NFSD_MAY_OWNER_OVERRIDE; 455c0e6bee4SJ. Bruce Fields status = do_open_permission(rqstp, *resfh, open, accmode); 45641fd1e42SJ. Bruce Fields set_change_info(&open->op_cinfo, current_fh); 457af85852dSJ. Bruce Fields out: 4581da177e4SLinus Torvalds return status; 4591da177e4SLinus Torvalds } 4601da177e4SLinus Torvalds 461b37ad28bSAl Viro static __be32 462bbc9c36cSJ. Bruce Fields do_open_fhandle(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_open *open) 4631da177e4SLinus Torvalds { 464bbc9c36cSJ. Bruce Fields struct svc_fh *current_fh = &cstate->current_fh; 465b37ad28bSAl Viro __be32 status; 4669f415eb2SJ. Bruce Fields int accmode = 0; 4671da177e4SLinus Torvalds 4681da177e4SLinus Torvalds /* We don't know the target directory, and therefore can not 4691da177e4SLinus Torvalds * set the change info 4701da177e4SLinus Torvalds */ 4711da177e4SLinus Torvalds 4721da177e4SLinus Torvalds memset(&open->op_cinfo, 0, sizeof(struct nfsd4_change_info)); 4731da177e4SLinus Torvalds 474bbc9c36cSJ. Bruce Fields nfsd4_set_open_owner_reply_cache(cstate, open, current_fh); 4751da177e4SLinus Torvalds 4761da177e4SLinus Torvalds open->op_truncate = (open->op_iattr.ia_valid & ATTR_SIZE) && 4771da177e4SLinus Torvalds (open->op_iattr.ia_size == 0); 4789f415eb2SJ. Bruce Fields /* 4799f415eb2SJ. Bruce Fields * In the delegation case, the client is telling us about an 4809f415eb2SJ. Bruce Fields * open that it *already* performed locally, some time ago. We 4819f415eb2SJ. Bruce Fields * should let it succeed now if possible. 4829f415eb2SJ. Bruce Fields * 4839f415eb2SJ. Bruce Fields * In the case of a CLAIM_FH open, on the other hand, the client 4849f415eb2SJ. Bruce Fields * may be counting on us to enforce permissions (the Linux 4.1 4859f415eb2SJ. Bruce Fields * client uses this for normal opens, for example). 4869f415eb2SJ. Bruce Fields */ 4879f415eb2SJ. Bruce Fields if (open->op_claim_type == NFS4_OPEN_CLAIM_DELEG_CUR_FH) 4889f415eb2SJ. Bruce Fields accmode = NFSD_MAY_OWNER_OVERRIDE; 4891da177e4SLinus Torvalds 4909f415eb2SJ. Bruce Fields status = do_open_permission(rqstp, current_fh, open, accmode); 4911da177e4SLinus Torvalds 4921da177e4SLinus Torvalds return status; 4931da177e4SLinus Torvalds } 4941da177e4SLinus Torvalds 49560adfc50SAndy Adamson static void 49660adfc50SAndy Adamson copy_clientid(clientid_t *clid, struct nfsd4_session *session) 49760adfc50SAndy Adamson { 49860adfc50SAndy Adamson struct nfsd4_sessionid *sid = 49960adfc50SAndy Adamson (struct nfsd4_sessionid *)session->se_sessionid.data; 50060adfc50SAndy Adamson 50160adfc50SAndy Adamson clid->cl_boot = sid->clientid.cl_boot; 50260adfc50SAndy Adamson clid->cl_id = sid->clientid.cl_id; 50360adfc50SAndy Adamson } 5041da177e4SLinus Torvalds 5057191155bSJ.Bruce Fields static __be32 506ca364317SJ.Bruce Fields nfsd4_open(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 507eb69853dSChristoph Hellwig union nfsd4_op_u *u) 5081da177e4SLinus Torvalds { 509eb69853dSChristoph Hellwig struct nfsd4_open *open = &u->open; 510b37ad28bSAl Viro __be32 status; 511c0e6bee4SJ. Bruce Fields struct svc_fh *resfh = NULL; 5123320fef1SStanislav Kinsbursky struct net *net = SVC_NET(rqstp); 5133320fef1SStanislav Kinsbursky struct nfsd_net *nn = net_generic(net, nfsd_net_id); 51403f318caSJ. Bruce Fields bool reclaim = false; 5156668958fSAndy Adamson 516fe0750e5SJ. Bruce Fields dprintk("NFSD: nfsd4_open filename %.*s op_openowner %p\n", 5171708e50bSChuck Lever (int)open->op_fnamelen, open->op_fname, 518fe0750e5SJ. Bruce Fields open->op_openowner); 5191da177e4SLinus Torvalds 5201da177e4SLinus Torvalds /* This check required by spec. */ 5211da177e4SLinus Torvalds if (open->op_create && open->op_claim_type != NFS4_OPEN_CLAIM_NULL) 5221da177e4SLinus Torvalds return nfserr_inval; 5231da177e4SLinus Torvalds 524500c2481Szhengbin open->op_created = false; 525ab1350b2SMi Jinlong /* 526ab1350b2SMi Jinlong * RFC5661 18.51.3 527ab1350b2SMi Jinlong * Before RECLAIM_COMPLETE done, server should deny new lock 528ab1350b2SMi Jinlong */ 529ab1350b2SMi Jinlong if (nfsd4_has_session(cstate) && 530ec59659bSJ. Bruce Fields !test_bit(NFSD4_CLIENT_RECLAIM_COMPLETE, &cstate->clp->cl_flags) && 531ab1350b2SMi Jinlong open->op_claim_type != NFS4_OPEN_CLAIM_PREVIOUS) 532ab1350b2SMi Jinlong return nfserr_grace; 533ab1350b2SMi Jinlong 53460adfc50SAndy Adamson if (nfsd4_has_session(cstate)) 53560adfc50SAndy Adamson copy_clientid(&open->op_clientid, cstate->session); 53660adfc50SAndy Adamson 5371da177e4SLinus Torvalds /* check seqid for replay. set nfs4_owner */ 5386cd22668SKinglong Mee status = nfsd4_process_open1(cstate, open, nn); 539a90b061cSAl Viro if (status == nfserr_replay_me) { 540fe0750e5SJ. Bruce Fields struct nfs4_replay *rp = &open->op_openowner->oo_owner.so_replay; 541ca364317SJ.Bruce Fields fh_put(&cstate->current_fh); 542a4773c08SJ. Bruce Fields fh_copy_shallow(&cstate->current_fh.fh_handle, 543a4773c08SJ. Bruce Fields &rp->rp_openfh); 5448837abcaSMiklos Szeredi status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP); 5451da177e4SLinus Torvalds if (status) 5461da177e4SLinus Torvalds dprintk("nfsd4_open: replay failed" 5471da177e4SLinus Torvalds " restoring previous filehandle\n"); 5481da177e4SLinus Torvalds else 549a90b061cSAl Viro status = nfserr_replay_me; 5501da177e4SLinus Torvalds } 5511da177e4SLinus Torvalds if (status) 5521da177e4SLinus Torvalds goto out; 5539d313b17SJ. Bruce Fields if (open->op_xdr_error) { 5549d313b17SJ. Bruce Fields status = open->op_xdr_error; 5559d313b17SJ. Bruce Fields goto out; 5569d313b17SJ. Bruce Fields } 557fb553c0fSJ. Bruce Fields 5583c8e0316SYu Zhiguo status = nfsd4_check_open_attributes(rqstp, cstate, open); 5593c8e0316SYu Zhiguo if (status) 5603c8e0316SYu Zhiguo goto out; 5613c8e0316SYu Zhiguo 562fb553c0fSJ. Bruce Fields /* Openowner is now set, so sequence id will get bumped. Now we need 563fb553c0fSJ. Bruce Fields * these checks before we do any creates: */ 564cbd0d51aSJ. Bruce Fields status = nfserr_grace; 565c87fb4a3SJ. Bruce Fields if (opens_in_grace(net) && open->op_claim_type != NFS4_OPEN_CLAIM_PREVIOUS) 566cbd0d51aSJ. Bruce Fields goto out; 567cbd0d51aSJ. Bruce Fields status = nfserr_no_grace; 568c87fb4a3SJ. Bruce Fields if (!opens_in_grace(net) && open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS) 569cbd0d51aSJ. Bruce Fields goto out; 570fb553c0fSJ. Bruce Fields 5711da177e4SLinus Torvalds switch (open->op_claim_type) { 5720dd3c192SNeilBrown case NFS4_OPEN_CLAIM_DELEGATE_CUR: 5731da177e4SLinus Torvalds case NFS4_OPEN_CLAIM_NULL: 574c0e6bee4SJ. Bruce Fields status = do_open_lookup(rqstp, cstate, open, &resfh); 5751da177e4SLinus Torvalds if (status) 5761da177e4SLinus Torvalds goto out; 5771da177e4SLinus Torvalds break; 5781da177e4SLinus Torvalds case NFS4_OPEN_CLAIM_PREVIOUS: 5791722b046SJ. Bruce Fields status = nfs4_check_open_reclaim(cstate->clp); 5800cf99b91SMi Jinlong if (status) 5810cf99b91SMi Jinlong goto out; 582ba5378b6SJeff Layton open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED; 58303f318caSJ. Bruce Fields reclaim = true; 584df561f66SGustavo A. R. Silva fallthrough; 5858b289b2cSJ. Bruce Fields case NFS4_OPEN_CLAIM_FH: 5868b289b2cSJ. Bruce Fields case NFS4_OPEN_CLAIM_DELEG_CUR_FH: 587bbc9c36cSJ. Bruce Fields status = do_open_fhandle(rqstp, cstate, open); 5881da177e4SLinus Torvalds if (status) 5891da177e4SLinus Torvalds goto out; 590c0e6bee4SJ. Bruce Fields resfh = &cstate->current_fh; 5911da177e4SLinus Torvalds break; 5928b289b2cSJ. Bruce Fields case NFS4_OPEN_CLAIM_DELEG_PREV_FH: 5931da177e4SLinus Torvalds case NFS4_OPEN_CLAIM_DELEGATE_PREV: 5942fdada03SJ. Bruce Fields dprintk("NFSD: unsupported OPEN claim type %d\n", 5951da177e4SLinus Torvalds open->op_claim_type); 5961da177e4SLinus Torvalds status = nfserr_notsupp; 5971da177e4SLinus Torvalds goto out; 5981da177e4SLinus Torvalds default: 5992fdada03SJ. Bruce Fields dprintk("NFSD: Invalid OPEN claim type %d\n", 6001da177e4SLinus Torvalds open->op_claim_type); 6011da177e4SLinus Torvalds status = nfserr_inval; 6021da177e4SLinus Torvalds goto out; 6031da177e4SLinus Torvalds } 6041da177e4SLinus Torvalds /* 6051da177e4SLinus Torvalds * nfsd4_process_open2() does the actual opening of the file. If 6061da177e4SLinus Torvalds * successful, it (1) truncates the file if open->op_truncate was 6071da177e4SLinus Torvalds * set, (2) sets open->op_stateid, (3) sets open->op_delegation. 6081da177e4SLinus Torvalds */ 609c0e6bee4SJ. Bruce Fields status = nfsd4_process_open2(rqstp, resfh, open); 610b3fbfe0eSJeff Layton WARN(status && open->op_created, 611b3fbfe0eSJeff Layton "nfsd4_process_open2 failed to open newly-created file! status=%u\n", 612b3fbfe0eSJeff Layton be32_to_cpu(status)); 61303f318caSJ. Bruce Fields if (reclaim && !status) 61403f318caSJ. Bruce Fields nn->somebody_reclaimed = true; 6151da177e4SLinus Torvalds out: 616c0e6bee4SJ. Bruce Fields if (resfh && resfh != &cstate->current_fh) { 617c0e6bee4SJ. Bruce Fields fh_dup2(&cstate->current_fh, resfh); 618c0e6bee4SJ. Bruce Fields fh_put(resfh); 619c0e6bee4SJ. Bruce Fields kfree(resfh); 620c0e6bee4SJ. Bruce Fields } 62142297899SJeff Layton nfsd4_cleanup_open_state(cstate, open); 6229411b1d4SJ. Bruce Fields nfsd4_bump_seqid(cstate, status); 6231da177e4SLinus Torvalds return status; 6241da177e4SLinus Torvalds } 6251da177e4SLinus Torvalds 6261da177e4SLinus Torvalds /* 6279d313b17SJ. Bruce Fields * OPEN is the only seqid-mutating operation whose decoding can fail 6289d313b17SJ. Bruce Fields * with a seqid-mutating error (specifically, decoding of user names in 6299d313b17SJ. Bruce Fields * the attributes). Therefore we have to do some processing to look up 6309d313b17SJ. Bruce Fields * the stateowner so that we can bump the seqid. 6319d313b17SJ. Bruce Fields */ 6329d313b17SJ. Bruce Fields static __be32 nfsd4_open_omfg(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_op *op) 6339d313b17SJ. Bruce Fields { 634eb69853dSChristoph Hellwig struct nfsd4_open *open = &op->u.open; 6359d313b17SJ. Bruce Fields 6369d313b17SJ. Bruce Fields if (!seqid_mutating_err(ntohl(op->status))) 6379d313b17SJ. Bruce Fields return op->status; 6389d313b17SJ. Bruce Fields if (nfsd4_has_session(cstate)) 6399d313b17SJ. Bruce Fields return op->status; 6409d313b17SJ. Bruce Fields open->op_xdr_error = op->status; 641eb69853dSChristoph Hellwig return nfsd4_open(rqstp, cstate, &op->u); 6429d313b17SJ. Bruce Fields } 6439d313b17SJ. Bruce Fields 6449d313b17SJ. Bruce Fields /* 6451da177e4SLinus Torvalds * filehandle-manipulating ops. 6461da177e4SLinus Torvalds */ 6477191155bSJ.Bruce Fields static __be32 648b591480bSJ.Bruce Fields nfsd4_getfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 649eb69853dSChristoph Hellwig union nfsd4_op_u *u) 6501da177e4SLinus Torvalds { 651eb69853dSChristoph Hellwig u->getfh = &cstate->current_fh; 6521da177e4SLinus Torvalds return nfs_ok; 6531da177e4SLinus Torvalds } 6541da177e4SLinus Torvalds 6557191155bSJ.Bruce Fields static __be32 656ca364317SJ.Bruce Fields nfsd4_putfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 657eb69853dSChristoph Hellwig union nfsd4_op_u *u) 6581da177e4SLinus Torvalds { 659eb69853dSChristoph Hellwig struct nfsd4_putfh *putfh = &u->putfh; 660b9e8638eSOlga Kornievskaia __be32 ret; 661eb69853dSChristoph Hellwig 662ca364317SJ.Bruce Fields fh_put(&cstate->current_fh); 663ca364317SJ.Bruce Fields cstate->current_fh.fh_handle.fh_size = putfh->pf_fhlen; 664d8b26071SNeilBrown memcpy(&cstate->current_fh.fh_handle.fh_raw, putfh->pf_fhval, 665ca364317SJ.Bruce Fields putfh->pf_fhlen); 666b9e8638eSOlga Kornievskaia ret = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_BYPASS_GSS); 667b9e8638eSOlga Kornievskaia #ifdef CONFIG_NFSD_V4_2_INTER_SSC 668b9e8638eSOlga Kornievskaia if (ret == nfserr_stale && putfh->no_verify) { 669b9e8638eSOlga Kornievskaia SET_FH_FLAG(&cstate->current_fh, NFSD4_FH_FOREIGN); 670b9e8638eSOlga Kornievskaia ret = 0; 671b9e8638eSOlga Kornievskaia } 672b9e8638eSOlga Kornievskaia #endif 673b9e8638eSOlga Kornievskaia return ret; 6741da177e4SLinus Torvalds } 6751da177e4SLinus Torvalds 6767191155bSJ.Bruce Fields static __be32 677b591480bSJ.Bruce Fields nfsd4_putrootfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 678eb69853dSChristoph Hellwig union nfsd4_op_u *u) 6791da177e4SLinus Torvalds { 680b37ad28bSAl Viro __be32 status; 6811da177e4SLinus Torvalds 682ca364317SJ.Bruce Fields fh_put(&cstate->current_fh); 683df547efbSJ. Bruce Fields status = exp_pseudoroot(rqstp, &cstate->current_fh); 6841da177e4SLinus Torvalds return status; 6851da177e4SLinus Torvalds } 6861da177e4SLinus Torvalds 6877191155bSJ.Bruce Fields static __be32 688b591480bSJ.Bruce Fields nfsd4_restorefh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 689eb69853dSChristoph Hellwig union nfsd4_op_u *u) 6901da177e4SLinus Torvalds { 691ca364317SJ.Bruce Fields if (!cstate->save_fh.fh_dentry) 6921da177e4SLinus Torvalds return nfserr_restorefh; 6931da177e4SLinus Torvalds 694ca364317SJ.Bruce Fields fh_dup2(&cstate->current_fh, &cstate->save_fh); 69551100d2bSOlga Kornievskaia if (HAS_CSTATE_FLAG(cstate, SAVED_STATE_ID_FLAG)) { 69637c593c5STigran Mkrtchyan memcpy(&cstate->current_stateid, &cstate->save_stateid, sizeof(stateid_t)); 69751100d2bSOlga Kornievskaia SET_CSTATE_FLAG(cstate, CURRENT_STATE_ID_FLAG); 69837c593c5STigran Mkrtchyan } 6991da177e4SLinus Torvalds return nfs_ok; 7001da177e4SLinus Torvalds } 7011da177e4SLinus Torvalds 7027191155bSJ.Bruce Fields static __be32 703b591480bSJ.Bruce Fields nfsd4_savefh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 704eb69853dSChristoph Hellwig union nfsd4_op_u *u) 7051da177e4SLinus Torvalds { 706ca364317SJ.Bruce Fields fh_dup2(&cstate->save_fh, &cstate->current_fh); 70751100d2bSOlga Kornievskaia if (HAS_CSTATE_FLAG(cstate, CURRENT_STATE_ID_FLAG)) { 70837c593c5STigran Mkrtchyan memcpy(&cstate->save_stateid, &cstate->current_stateid, sizeof(stateid_t)); 70951100d2bSOlga Kornievskaia SET_CSTATE_FLAG(cstate, SAVED_STATE_ID_FLAG); 71037c593c5STigran Mkrtchyan } 7111da177e4SLinus Torvalds return nfs_ok; 7121da177e4SLinus Torvalds } 7131da177e4SLinus Torvalds 7141da177e4SLinus Torvalds /* 7151da177e4SLinus Torvalds * misc nfsv4 ops 7161da177e4SLinus Torvalds */ 7177191155bSJ.Bruce Fields static __be32 718ca364317SJ.Bruce Fields nfsd4_access(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 719eb69853dSChristoph Hellwig union nfsd4_op_u *u) 7201da177e4SLinus Torvalds { 721eb69853dSChristoph Hellwig struct nfsd4_access *access = &u->access; 722c11d7fd1SFrank van der Linden u32 access_full; 723eb69853dSChristoph Hellwig 724c11d7fd1SFrank van der Linden access_full = NFS3_ACCESS_FULL; 725c11d7fd1SFrank van der Linden if (cstate->minorversion >= 2) 726c11d7fd1SFrank van der Linden access_full |= NFS4_ACCESS_XALIST | NFS4_ACCESS_XAREAD | 727c11d7fd1SFrank van der Linden NFS4_ACCESS_XAWRITE; 728c11d7fd1SFrank van der Linden 729c11d7fd1SFrank van der Linden if (access->ac_req_access & ~access_full) 7301da177e4SLinus Torvalds return nfserr_inval; 7311da177e4SLinus Torvalds 7321da177e4SLinus Torvalds access->ac_resp_access = access->ac_req_access; 733ca364317SJ.Bruce Fields return nfsd_access(rqstp, &cstate->current_fh, &access->ac_resp_access, 734ca364317SJ.Bruce Fields &access->ac_supported); 7351da177e4SLinus Torvalds } 7361da177e4SLinus Torvalds 737b9c0ef85SStanislav Kinsbursky static void gen_boot_verifier(nfs4_verifier *verifier, struct net *net) 738ab4684d1SChuck Lever { 73927c438f5STrond Myklebust __be32 *verf = (__be32 *)verifier->data; 740ab4684d1SChuck Lever 74127c438f5STrond Myklebust BUILD_BUG_ON(2*sizeof(*verf) != sizeof(verifier->data)); 74227c438f5STrond Myklebust 7433988a578SChuck Lever nfsd_copy_write_verifier(verf, net_generic(net, nfsd_net_id)); 744ab4684d1SChuck Lever } 745ab4684d1SChuck Lever 7467191155bSJ.Bruce Fields static __be32 747ca364317SJ.Bruce Fields nfsd4_commit(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 748eb69853dSChristoph Hellwig union nfsd4_op_u *u) 7491da177e4SLinus Torvalds { 750eb69853dSChristoph Hellwig struct nfsd4_commit *commit = &u->commit; 751eb69853dSChristoph Hellwig 75275c096f7SJ. Bruce Fields return nfsd_commit(rqstp, &cstate->current_fh, commit->co_offset, 753524ff1afSTrond Myklebust commit->co_count, 754524ff1afSTrond Myklebust (__be32 *)commit->co_verf.data); 7551da177e4SLinus Torvalds } 7561da177e4SLinus Torvalds 757b37ad28bSAl Viro static __be32 758ca364317SJ.Bruce Fields nfsd4_create(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 759eb69853dSChristoph Hellwig union nfsd4_op_u *u) 7601da177e4SLinus Torvalds { 761eb69853dSChristoph Hellwig struct nfsd4_create *create = &u->create; 7621da177e4SLinus Torvalds struct svc_fh resfh; 763b37ad28bSAl Viro __be32 status; 7641da177e4SLinus Torvalds dev_t rdev; 7651da177e4SLinus Torvalds 7661da177e4SLinus Torvalds fh_init(&resfh, NFS4_FHSIZE); 7671da177e4SLinus Torvalds 768fa08139dSJ. Bruce Fields status = fh_verify(rqstp, &cstate->current_fh, S_IFDIR, NFSD_MAY_NOP); 7691da177e4SLinus Torvalds if (status) 7701da177e4SLinus Torvalds return status; 7711da177e4SLinus Torvalds 7723c8e0316SYu Zhiguo status = check_attr_support(rqstp, cstate, create->cr_bmval, 7733c8e0316SYu Zhiguo nfsd_attrmask); 7743c8e0316SYu Zhiguo if (status) 7753c8e0316SYu Zhiguo return status; 7763c8e0316SYu Zhiguo 777880a3a53SJ. Bruce Fields current->fs->umask = create->cr_umask; 7781da177e4SLinus Torvalds switch (create->cr_type) { 7791da177e4SLinus Torvalds case NF4LNK: 780ca364317SJ.Bruce Fields status = nfsd_symlink(rqstp, &cstate->current_fh, 781ca364317SJ.Bruce Fields create->cr_name, create->cr_namelen, 7821e444f5bSKinglong Mee create->cr_data, &resfh); 7831da177e4SLinus Torvalds break; 7841da177e4SLinus Torvalds 7851da177e4SLinus Torvalds case NF4BLK: 786880a3a53SJ. Bruce Fields status = nfserr_inval; 7871da177e4SLinus Torvalds rdev = MKDEV(create->cr_specdata1, create->cr_specdata2); 7881da177e4SLinus Torvalds if (MAJOR(rdev) != create->cr_specdata1 || 7891da177e4SLinus Torvalds MINOR(rdev) != create->cr_specdata2) 790880a3a53SJ. Bruce Fields goto out_umask; 791ca364317SJ.Bruce Fields status = nfsd_create(rqstp, &cstate->current_fh, 792ca364317SJ.Bruce Fields create->cr_name, create->cr_namelen, 793ca364317SJ.Bruce Fields &create->cr_iattr, S_IFBLK, rdev, &resfh); 7941da177e4SLinus Torvalds break; 7951da177e4SLinus Torvalds 7961da177e4SLinus Torvalds case NF4CHR: 797880a3a53SJ. Bruce Fields status = nfserr_inval; 7981da177e4SLinus Torvalds rdev = MKDEV(create->cr_specdata1, create->cr_specdata2); 7991da177e4SLinus Torvalds if (MAJOR(rdev) != create->cr_specdata1 || 8001da177e4SLinus Torvalds MINOR(rdev) != create->cr_specdata2) 801880a3a53SJ. Bruce Fields goto out_umask; 802ca364317SJ.Bruce Fields status = nfsd_create(rqstp, &cstate->current_fh, 803ca364317SJ.Bruce Fields create->cr_name, create->cr_namelen, 804ca364317SJ.Bruce Fields &create->cr_iattr,S_IFCHR, rdev, &resfh); 8051da177e4SLinus Torvalds break; 8061da177e4SLinus Torvalds 8071da177e4SLinus Torvalds case NF4SOCK: 808ca364317SJ.Bruce Fields status = nfsd_create(rqstp, &cstate->current_fh, 809ca364317SJ.Bruce Fields create->cr_name, create->cr_namelen, 810ca364317SJ.Bruce Fields &create->cr_iattr, S_IFSOCK, 0, &resfh); 8111da177e4SLinus Torvalds break; 8121da177e4SLinus Torvalds 8131da177e4SLinus Torvalds case NF4FIFO: 814ca364317SJ.Bruce Fields status = nfsd_create(rqstp, &cstate->current_fh, 815ca364317SJ.Bruce Fields create->cr_name, create->cr_namelen, 816ca364317SJ.Bruce Fields &create->cr_iattr, S_IFIFO, 0, &resfh); 8171da177e4SLinus Torvalds break; 8181da177e4SLinus Torvalds 8191da177e4SLinus Torvalds case NF4DIR: 8201da177e4SLinus Torvalds create->cr_iattr.ia_valid &= ~ATTR_SIZE; 821ca364317SJ.Bruce Fields status = nfsd_create(rqstp, &cstate->current_fh, 822ca364317SJ.Bruce Fields create->cr_name, create->cr_namelen, 823ca364317SJ.Bruce Fields &create->cr_iattr, S_IFDIR, 0, &resfh); 8241da177e4SLinus Torvalds break; 8251da177e4SLinus Torvalds 8261da177e4SLinus Torvalds default: 8271da177e4SLinus Torvalds status = nfserr_badtype; 8281da177e4SLinus Torvalds } 8291da177e4SLinus Torvalds 8309208faf2SYu Zhiguo if (status) 8319208faf2SYu Zhiguo goto out; 8329208faf2SYu Zhiguo 83318032ca0SDavid Quigley if (create->cr_label.len) 83418032ca0SDavid Quigley nfsd4_security_inode_setsecctx(&resfh, &create->cr_label, create->cr_bmval); 83518032ca0SDavid Quigley 8369208faf2SYu Zhiguo if (create->cr_acl != NULL) 8379208faf2SYu Zhiguo do_set_nfs4_acl(rqstp, &resfh, create->cr_acl, 8389208faf2SYu Zhiguo create->cr_bmval); 8399208faf2SYu Zhiguo 840ca364317SJ.Bruce Fields fh_unlock(&cstate->current_fh); 841ca364317SJ.Bruce Fields set_change_info(&create->cr_cinfo, &cstate->current_fh); 842ca364317SJ.Bruce Fields fh_dup2(&cstate->current_fh, &resfh); 8439208faf2SYu Zhiguo out: 8441da177e4SLinus Torvalds fh_put(&resfh); 845880a3a53SJ. Bruce Fields out_umask: 846880a3a53SJ. Bruce Fields current->fs->umask = 0; 8471da177e4SLinus Torvalds return status; 8481da177e4SLinus Torvalds } 8491da177e4SLinus Torvalds 8507191155bSJ.Bruce Fields static __be32 851ca364317SJ.Bruce Fields nfsd4_getattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 852eb69853dSChristoph Hellwig union nfsd4_op_u *u) 8531da177e4SLinus Torvalds { 854eb69853dSChristoph Hellwig struct nfsd4_getattr *getattr = &u->getattr; 855b37ad28bSAl Viro __be32 status; 8561da177e4SLinus Torvalds 8578837abcaSMiklos Szeredi status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP); 8581da177e4SLinus Torvalds if (status) 8591da177e4SLinus Torvalds return status; 8601da177e4SLinus Torvalds 8611da177e4SLinus Torvalds if (getattr->ga_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1) 8621da177e4SLinus Torvalds return nfserr_inval; 8631da177e4SLinus Torvalds 864916d2d84SJ. Bruce Fields getattr->ga_bmval[0] &= nfsd_suppattrs[cstate->minorversion][0]; 865916d2d84SJ. Bruce Fields getattr->ga_bmval[1] &= nfsd_suppattrs[cstate->minorversion][1]; 866916d2d84SJ. Bruce Fields getattr->ga_bmval[2] &= nfsd_suppattrs[cstate->minorversion][2]; 8671da177e4SLinus Torvalds 868ca364317SJ.Bruce Fields getattr->ga_fhp = &cstate->current_fh; 8691da177e4SLinus Torvalds return nfs_ok; 8701da177e4SLinus Torvalds } 8711da177e4SLinus Torvalds 8727191155bSJ.Bruce Fields static __be32 873ca364317SJ.Bruce Fields nfsd4_link(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 874eb69853dSChristoph Hellwig union nfsd4_op_u *u) 8751da177e4SLinus Torvalds { 876eb69853dSChristoph Hellwig struct nfsd4_link *link = &u->link; 87795424460SJ. Bruce Fields __be32 status; 8781da177e4SLinus Torvalds 879ca364317SJ.Bruce Fields status = nfsd_link(rqstp, &cstate->current_fh, 880ca364317SJ.Bruce Fields link->li_name, link->li_namelen, &cstate->save_fh); 8811da177e4SLinus Torvalds if (!status) 882ca364317SJ.Bruce Fields set_change_info(&link->li_cinfo, &cstate->current_fh); 8831da177e4SLinus Torvalds return status; 8841da177e4SLinus Torvalds } 8851da177e4SLinus Torvalds 8860ff7ab46SJ. Bruce Fields static __be32 nfsd4_do_lookupp(struct svc_rqst *rqstp, struct svc_fh *fh) 8871da177e4SLinus Torvalds { 8881da177e4SLinus Torvalds struct svc_fh tmp_fh; 889b37ad28bSAl Viro __be32 ret; 8901da177e4SLinus Torvalds 8911da177e4SLinus Torvalds fh_init(&tmp_fh, NFS4_FHSIZE); 892df547efbSJ. Bruce Fields ret = exp_pseudoroot(rqstp, &tmp_fh); 893df547efbSJ. Bruce Fields if (ret) 8941da177e4SLinus Torvalds return ret; 8950ff7ab46SJ. Bruce Fields if (tmp_fh.fh_dentry == fh->fh_dentry) { 8961da177e4SLinus Torvalds fh_put(&tmp_fh); 8971da177e4SLinus Torvalds return nfserr_noent; 8981da177e4SLinus Torvalds } 8991da177e4SLinus Torvalds fh_put(&tmp_fh); 9000ff7ab46SJ. Bruce Fields return nfsd_lookup(rqstp, fh, "..", 2, fh); 9010ff7ab46SJ. Bruce Fields } 9020ff7ab46SJ. Bruce Fields 9030ff7ab46SJ. Bruce Fields static __be32 9040ff7ab46SJ. Bruce Fields nfsd4_lookupp(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 905eb69853dSChristoph Hellwig union nfsd4_op_u *u) 9060ff7ab46SJ. Bruce Fields { 9070ff7ab46SJ. Bruce Fields return nfsd4_do_lookupp(rqstp, &cstate->current_fh); 9081da177e4SLinus Torvalds } 9091da177e4SLinus Torvalds 9107191155bSJ.Bruce Fields static __be32 911ca364317SJ.Bruce Fields nfsd4_lookup(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 912eb69853dSChristoph Hellwig union nfsd4_op_u *u) 9131da177e4SLinus Torvalds { 914ca364317SJ.Bruce Fields return nfsd_lookup(rqstp, &cstate->current_fh, 915eb69853dSChristoph Hellwig u->lookup.lo_name, u->lookup.lo_len, 916ca364317SJ.Bruce Fields &cstate->current_fh); 9171da177e4SLinus Torvalds } 9181da177e4SLinus Torvalds 9197191155bSJ.Bruce Fields static __be32 920ca364317SJ.Bruce Fields nfsd4_read(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 921eb69853dSChristoph Hellwig union nfsd4_op_u *u) 9221da177e4SLinus Torvalds { 923eb69853dSChristoph Hellwig struct nfsd4_read *read = &u->read; 924b37ad28bSAl Viro __be32 status; 9251da177e4SLinus Torvalds 9265c4583b2SJeff Layton read->rd_nf = NULL; 9271da177e4SLinus Torvalds 92887c5942eSChuck Lever trace_nfsd_read_start(rqstp, &cstate->current_fh, 92987c5942eSChuck Lever read->rd_offset, read->rd_length); 93087c5942eSChuck Lever 9310cb4d23aSChuck Lever read->rd_length = min_t(u32, read->rd_length, svc_max_payload(rqstp)); 9320cb4d23aSChuck Lever if (read->rd_offset > (u64)OFFSET_MAX) 9330cb4d23aSChuck Lever read->rd_offset = (u64)OFFSET_MAX; 9340cb4d23aSChuck Lever if (read->rd_offset + read->rd_length > (u64)OFFSET_MAX) 9350cb4d23aSChuck Lever read->rd_length = (u64)OFFSET_MAX - read->rd_offset; 9360cb4d23aSChuck Lever 9379b3234b9SJ. Bruce Fields /* 9389b3234b9SJ. Bruce Fields * If we do a zero copy read, then a client will see read data 9399b3234b9SJ. Bruce Fields * that reflects the state of the file *after* performing the 9409b3234b9SJ. Bruce Fields * following compound. 9419b3234b9SJ. Bruce Fields * 9429b3234b9SJ. Bruce Fields * To ensure proper ordering, we therefore turn off zero copy if 9439b3234b9SJ. Bruce Fields * the client wants us to do more in this compound: 9449b3234b9SJ. Bruce Fields */ 9459b3234b9SJ. Bruce Fields if (!nfsd4_last_compound_op(rqstp)) 946779fb0f3SJeff Layton clear_bit(RQ_SPLICE_OK, &rqstp->rq_flags); 9479b3234b9SJ. Bruce Fields 9481da177e4SLinus Torvalds /* check stateid */ 949aa0d6aedSAnna Schumaker status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh, 950aa0d6aedSAnna Schumaker &read->rd_stateid, RD_STATE, 951624322f1SOlga Kornievskaia &read->rd_nf, NULL); 952af90f707SChristoph Hellwig if (status) { 9531da177e4SLinus Torvalds dprintk("NFSD: nfsd4_read: couldn't process stateid!\n"); 9541da177e4SLinus Torvalds goto out; 9551da177e4SLinus Torvalds } 9561da177e4SLinus Torvalds status = nfs_ok; 9571da177e4SLinus Torvalds out: 9581da177e4SLinus Torvalds read->rd_rqstp = rqstp; 959ca364317SJ.Bruce Fields read->rd_fhp = &cstate->current_fh; 9601da177e4SLinus Torvalds return status; 9611da177e4SLinus Torvalds } 9621da177e4SLinus Torvalds 96334b1744cSJ. Bruce Fields 96434b1744cSJ. Bruce Fields static void 96534b1744cSJ. Bruce Fields nfsd4_read_release(union nfsd4_op_u *u) 96634b1744cSJ. Bruce Fields { 9675c4583b2SJeff Layton if (u->read.rd_nf) 9685c4583b2SJeff Layton nfsd_file_put(u->read.rd_nf); 96987c5942eSChuck Lever trace_nfsd_read_done(u->read.rd_rqstp, u->read.rd_fhp, 97087c5942eSChuck Lever u->read.rd_offset, u->read.rd_length); 97134b1744cSJ. Bruce Fields } 97234b1744cSJ. Bruce Fields 9737191155bSJ.Bruce Fields static __be32 974ca364317SJ.Bruce Fields nfsd4_readdir(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 975eb69853dSChristoph Hellwig union nfsd4_op_u *u) 9761da177e4SLinus Torvalds { 977eb69853dSChristoph Hellwig struct nfsd4_readdir *readdir = &u->readdir; 9781da177e4SLinus Torvalds u64 cookie = readdir->rd_cookie; 9791da177e4SLinus Torvalds static const nfs4_verifier zeroverf; 9801da177e4SLinus Torvalds 9811da177e4SLinus Torvalds /* no need to check permission - this will be done in nfsd_readdir() */ 9821da177e4SLinus Torvalds 9831da177e4SLinus Torvalds if (readdir->rd_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1) 9841da177e4SLinus Torvalds return nfserr_inval; 9851da177e4SLinus Torvalds 986916d2d84SJ. Bruce Fields readdir->rd_bmval[0] &= nfsd_suppattrs[cstate->minorversion][0]; 987916d2d84SJ. Bruce Fields readdir->rd_bmval[1] &= nfsd_suppattrs[cstate->minorversion][1]; 988916d2d84SJ. Bruce Fields readdir->rd_bmval[2] &= nfsd_suppattrs[cstate->minorversion][2]; 9891da177e4SLinus Torvalds 990832023bfSBernd Schubert if ((cookie == 1) || (cookie == 2) || 9911da177e4SLinus Torvalds (cookie == 0 && memcmp(readdir->rd_verf.data, zeroverf.data, NFS4_VERIFIER_SIZE))) 9921da177e4SLinus Torvalds return nfserr_bad_cookie; 9931da177e4SLinus Torvalds 9941da177e4SLinus Torvalds readdir->rd_rqstp = rqstp; 995ca364317SJ.Bruce Fields readdir->rd_fhp = &cstate->current_fh; 9961da177e4SLinus Torvalds return nfs_ok; 9971da177e4SLinus Torvalds } 9981da177e4SLinus Torvalds 9997191155bSJ.Bruce Fields static __be32 1000ca364317SJ.Bruce Fields nfsd4_readlink(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 1001eb69853dSChristoph Hellwig union nfsd4_op_u *u) 10021da177e4SLinus Torvalds { 1003eb69853dSChristoph Hellwig u->readlink.rl_rqstp = rqstp; 1004eb69853dSChristoph Hellwig u->readlink.rl_fhp = &cstate->current_fh; 10051da177e4SLinus Torvalds return nfs_ok; 10061da177e4SLinus Torvalds } 10071da177e4SLinus Torvalds 10087191155bSJ.Bruce Fields static __be32 1009ca364317SJ.Bruce Fields nfsd4_remove(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 1010eb69853dSChristoph Hellwig union nfsd4_op_u *u) 10111da177e4SLinus Torvalds { 1012eb69853dSChristoph Hellwig struct nfsd4_remove *remove = &u->remove; 1013b37ad28bSAl Viro __be32 status; 10141da177e4SLinus Torvalds 1015c87fb4a3SJ. Bruce Fields if (opens_in_grace(SVC_NET(rqstp))) 1016c815afc7SNeilBrown return nfserr_grace; 1017ca364317SJ.Bruce Fields status = nfsd_unlink(rqstp, &cstate->current_fh, 0, 1018ca364317SJ.Bruce Fields remove->rm_name, remove->rm_namelen); 10191da177e4SLinus Torvalds if (!status) { 1020ca364317SJ.Bruce Fields fh_unlock(&cstate->current_fh); 1021ca364317SJ.Bruce Fields set_change_info(&remove->rm_cinfo, &cstate->current_fh); 10221da177e4SLinus Torvalds } 10231da177e4SLinus Torvalds return status; 10241da177e4SLinus Torvalds } 10251da177e4SLinus Torvalds 10267191155bSJ.Bruce Fields static __be32 1027ca364317SJ.Bruce Fields nfsd4_rename(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 1028eb69853dSChristoph Hellwig union nfsd4_op_u *u) 10291da177e4SLinus Torvalds { 1030eb69853dSChristoph Hellwig struct nfsd4_rename *rename = &u->rename; 103195424460SJ. Bruce Fields __be32 status; 10321da177e4SLinus Torvalds 1033f8f71d00SJ. Bruce Fields if (opens_in_grace(SVC_NET(rqstp))) 1034c815afc7SNeilBrown return nfserr_grace; 1035ca364317SJ.Bruce Fields status = nfsd_rename(rqstp, &cstate->save_fh, rename->rn_sname, 1036ca364317SJ.Bruce Fields rename->rn_snamelen, &cstate->current_fh, 10371da177e4SLinus Torvalds rename->rn_tname, rename->rn_tnamelen); 10382a6cf944SJ. Bruce Fields if (status) 10392a6cf944SJ. Bruce Fields return status; 1040ca364317SJ.Bruce Fields set_change_info(&rename->rn_sinfo, &cstate->current_fh); 1041ca364317SJ.Bruce Fields set_change_info(&rename->rn_tinfo, &cstate->save_fh); 10422a6cf944SJ. Bruce Fields return nfs_ok; 10431da177e4SLinus Torvalds } 10441da177e4SLinus Torvalds 10457191155bSJ.Bruce Fields static __be32 1046dcb488a3SAndy Adamson nfsd4_secinfo(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 1047eb69853dSChristoph Hellwig union nfsd4_op_u *u) 1048dcb488a3SAndy Adamson { 1049eb69853dSChristoph Hellwig struct nfsd4_secinfo *secinfo = &u->secinfo; 1050dcb488a3SAndy Adamson struct svc_export *exp; 1051dcb488a3SAndy Adamson struct dentry *dentry; 1052dcb488a3SAndy Adamson __be32 err; 1053dcb488a3SAndy Adamson 105429a78a3eSJ. Bruce Fields err = fh_verify(rqstp, &cstate->current_fh, S_IFDIR, NFSD_MAY_EXEC); 105529a78a3eSJ. Bruce Fields if (err) 105629a78a3eSJ. Bruce Fields return err; 1057dcb488a3SAndy Adamson err = nfsd_lookup_dentry(rqstp, &cstate->current_fh, 1058dcb488a3SAndy Adamson secinfo->si_name, secinfo->si_namelen, 1059dcb488a3SAndy Adamson &exp, &dentry); 1060dcb488a3SAndy Adamson if (err) 1061dcb488a3SAndy Adamson return err; 10622f6fc056SJ. Bruce Fields fh_unlock(&cstate->current_fh); 10632b0143b5SDavid Howells if (d_really_is_negative(dentry)) { 1064dcb488a3SAndy Adamson exp_put(exp); 1065dcb488a3SAndy Adamson err = nfserr_noent; 1066dcb488a3SAndy Adamson } else 1067dcb488a3SAndy Adamson secinfo->si_exp = exp; 1068dcb488a3SAndy Adamson dput(dentry); 106956560b9aSJ. Bruce Fields if (cstate->minorversion) 107056560b9aSJ. Bruce Fields /* See rfc 5661 section 2.6.3.1.1.8 */ 107156560b9aSJ. Bruce Fields fh_put(&cstate->current_fh); 1072dcb488a3SAndy Adamson return err; 1073dcb488a3SAndy Adamson } 1074dcb488a3SAndy Adamson 1075dcb488a3SAndy Adamson static __be32 107604f4ad16SJ. Bruce Fields nfsd4_secinfo_no_name(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 1077eb69853dSChristoph Hellwig union nfsd4_op_u *u) 107804f4ad16SJ. Bruce Fields { 107904f4ad16SJ. Bruce Fields __be32 err; 108004f4ad16SJ. Bruce Fields 1081eb69853dSChristoph Hellwig switch (u->secinfo_no_name.sin_style) { 108204f4ad16SJ. Bruce Fields case NFS4_SECINFO_STYLE4_CURRENT_FH: 108304f4ad16SJ. Bruce Fields break; 108404f4ad16SJ. Bruce Fields case NFS4_SECINFO_STYLE4_PARENT: 108504f4ad16SJ. Bruce Fields err = nfsd4_do_lookupp(rqstp, &cstate->current_fh); 108604f4ad16SJ. Bruce Fields if (err) 108704f4ad16SJ. Bruce Fields return err; 108804f4ad16SJ. Bruce Fields break; 108904f4ad16SJ. Bruce Fields default: 109004f4ad16SJ. Bruce Fields return nfserr_inval; 109104f4ad16SJ. Bruce Fields } 1092bf18f163SKinglong Mee 1093eb69853dSChristoph Hellwig u->secinfo_no_name.sin_exp = exp_get(cstate->current_fh.fh_export); 109404f4ad16SJ. Bruce Fields fh_put(&cstate->current_fh); 109504f4ad16SJ. Bruce Fields return nfs_ok; 109604f4ad16SJ. Bruce Fields } 109704f4ad16SJ. Bruce Fields 109834b1744cSJ. Bruce Fields static void 109934b1744cSJ. Bruce Fields nfsd4_secinfo_release(union nfsd4_op_u *u) 110034b1744cSJ. Bruce Fields { 110134b1744cSJ. Bruce Fields if (u->secinfo.si_exp) 110234b1744cSJ. Bruce Fields exp_put(u->secinfo.si_exp); 110334b1744cSJ. Bruce Fields } 110434b1744cSJ. Bruce Fields 1105ec572b9eSEryu Guan static void 1106ec572b9eSEryu Guan nfsd4_secinfo_no_name_release(union nfsd4_op_u *u) 1107ec572b9eSEryu Guan { 1108ec572b9eSEryu Guan if (u->secinfo_no_name.sin_exp) 1109ec572b9eSEryu Guan exp_put(u->secinfo_no_name.sin_exp); 1110ec572b9eSEryu Guan } 1111ec572b9eSEryu Guan 111204f4ad16SJ. Bruce Fields static __be32 1113ca364317SJ.Bruce Fields nfsd4_setattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 1114eb69853dSChristoph Hellwig union nfsd4_op_u *u) 11151da177e4SLinus Torvalds { 1116eb69853dSChristoph Hellwig struct nfsd4_setattr *setattr = &u->setattr; 1117b37ad28bSAl Viro __be32 status = nfs_ok; 111896f6f985SAl Viro int err; 11191da177e4SLinus Torvalds 11201da177e4SLinus Torvalds if (setattr->sa_iattr.ia_valid & ATTR_SIZE) { 1121af90f707SChristoph Hellwig status = nfs4_preprocess_stateid_op(rqstp, cstate, 1122aa0d6aedSAnna Schumaker &cstate->current_fh, &setattr->sa_stateid, 1123624322f1SOlga Kornievskaia WR_STATE, NULL, NULL); 1124375c5547SJ. Bruce Fields if (status) { 11253e3b4800SGreg Banks dprintk("NFSD: nfsd4_setattr: couldn't process stateid!\n"); 1126375c5547SJ. Bruce Fields return status; 1127375c5547SJ. Bruce Fields } 11281da177e4SLinus Torvalds } 112996f6f985SAl Viro err = fh_want_write(&cstate->current_fh); 113096f6f985SAl Viro if (err) 113196f6f985SAl Viro return nfserrno(err); 11321da177e4SLinus Torvalds status = nfs_ok; 11333c8e0316SYu Zhiguo 11343c8e0316SYu Zhiguo status = check_attr_support(rqstp, cstate, setattr->sa_bmval, 11353c8e0316SYu Zhiguo nfsd_attrmask); 11363c8e0316SYu Zhiguo if (status) 11373c8e0316SYu Zhiguo goto out; 11383c8e0316SYu Zhiguo 11391da177e4SLinus Torvalds if (setattr->sa_acl != NULL) 1140ca364317SJ.Bruce Fields status = nfsd4_set_nfs4_acl(rqstp, &cstate->current_fh, 1141ca364317SJ.Bruce Fields setattr->sa_acl); 11421da177e4SLinus Torvalds if (status) 114318f335afSDave Hansen goto out; 114418032ca0SDavid Quigley if (setattr->sa_label.len) 114518032ca0SDavid Quigley status = nfsd4_set_nfs4_label(rqstp, &cstate->current_fh, 114618032ca0SDavid Quigley &setattr->sa_label); 114718032ca0SDavid Quigley if (status) 114818032ca0SDavid Quigley goto out; 1149ca364317SJ.Bruce Fields status = nfsd_setattr(rqstp, &cstate->current_fh, &setattr->sa_iattr, 11502a1aa489SArnd Bergmann 0, (time64_t)0); 115118f335afSDave Hansen out: 1152bad0dcffSAl Viro fh_drop_write(&cstate->current_fh); 11531da177e4SLinus Torvalds return status; 11541da177e4SLinus Torvalds } 11551da177e4SLinus Torvalds 11567191155bSJ.Bruce Fields static __be32 1157ca364317SJ.Bruce Fields nfsd4_write(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 1158eb69853dSChristoph Hellwig union nfsd4_op_u *u) 11591da177e4SLinus Torvalds { 1160eb69853dSChristoph Hellwig struct nfsd4_write *write = &u->write; 11611da177e4SLinus Torvalds stateid_t *stateid = &write->wr_stateid; 11625c4583b2SJeff Layton struct nfsd_file *nf = NULL; 1163b37ad28bSAl Viro __be32 status = nfs_ok; 116431dec253SDavid Shaw unsigned long cnt; 1165ffe1137bSJ. Bruce Fields int nvecs; 11661da177e4SLinus Torvalds 11676260d9a5SChuck Lever if (write->wr_offset > (u64)OFFSET_MAX || 11686260d9a5SChuck Lever write->wr_offset + write->wr_buflen > (u64)OFFSET_MAX) 11696260d9a5SChuck Lever return nfserr_fbig; 11701da177e4SLinus Torvalds 1171d890be15SChuck Lever cnt = write->wr_buflen; 1172d890be15SChuck Lever trace_nfsd_write_start(rqstp, &cstate->current_fh, 1173d890be15SChuck Lever write->wr_offset, cnt); 1174aa0d6aedSAnna Schumaker status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh, 1175624322f1SOlga Kornievskaia stateid, WR_STATE, &nf, NULL); 1176375c5547SJ. Bruce Fields if (status) { 1177375c5547SJ. Bruce Fields dprintk("NFSD: nfsd4_write: couldn't process stateid!\n"); 1178375c5547SJ. Bruce Fields return status; 1179375c5547SJ. Bruce Fields } 1180375c5547SJ. Bruce Fields 11811da177e4SLinus Torvalds write->wr_how_written = write->wr_stable_how; 11821da177e4SLinus Torvalds 1183dae9a6caSChuck Lever nvecs = svc_fill_write_vector(rqstp, &write->wr_payload); 1184ffe1137bSJ. Bruce Fields WARN_ON_ONCE(nvecs > ARRAY_SIZE(rqstp->rq_vec)); 1185ffe1137bSJ. Bruce Fields 118616f8f894STrond Myklebust status = nfsd_vfs_write(rqstp, &cstate->current_fh, nf, 1187af90f707SChristoph Hellwig write->wr_offset, rqstp->rq_vec, nvecs, &cnt, 118819e0663fSTrond Myklebust write->wr_how_written, 118919e0663fSTrond Myklebust (__be32 *)write->wr_verifier.data); 11905c4583b2SJeff Layton nfsd_file_put(nf); 11911da177e4SLinus Torvalds 119231dec253SDavid Shaw write->wr_bytes_written = cnt; 1193d890be15SChuck Lever trace_nfsd_write_done(rqstp, &cstate->current_fh, 1194d890be15SChuck Lever write->wr_offset, cnt); 11951da177e4SLinus Torvalds return status; 11961da177e4SLinus Torvalds } 11971da177e4SLinus Torvalds 119824bab491SAnna Schumaker static __be32 119929ae7f9dSAnna Schumaker nfsd4_verify_copy(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 12005c4583b2SJeff Layton stateid_t *src_stateid, struct nfsd_file **src, 12015c4583b2SJeff Layton stateid_t *dst_stateid, struct nfsd_file **dst) 1202ffa0160aSChristoph Hellwig { 1203ffa0160aSChristoph Hellwig __be32 status; 1204ffa0160aSChristoph Hellwig 120501310bb7SScott Mayhew if (!cstate->save_fh.fh_dentry) 120601310bb7SScott Mayhew return nfserr_nofilehandle; 120701310bb7SScott Mayhew 1208ffa0160aSChristoph Hellwig status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->save_fh, 1209624322f1SOlga Kornievskaia src_stateid, RD_STATE, src, NULL); 1210ffa0160aSChristoph Hellwig if (status) { 1211ffa0160aSChristoph Hellwig dprintk("NFSD: %s: couldn't process src stateid!\n", __func__); 1212ffa0160aSChristoph Hellwig goto out; 1213ffa0160aSChristoph Hellwig } 1214ffa0160aSChristoph Hellwig 1215ffa0160aSChristoph Hellwig status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh, 1216624322f1SOlga Kornievskaia dst_stateid, WR_STATE, dst, NULL); 1217ffa0160aSChristoph Hellwig if (status) { 1218ffa0160aSChristoph Hellwig dprintk("NFSD: %s: couldn't process dst stateid!\n", __func__); 1219ffa0160aSChristoph Hellwig goto out_put_src; 1220ffa0160aSChristoph Hellwig } 1221ffa0160aSChristoph Hellwig 1222ffa0160aSChristoph Hellwig /* fix up for NFS-specific error code */ 12235c4583b2SJeff Layton if (!S_ISREG(file_inode((*src)->nf_file)->i_mode) || 12245c4583b2SJeff Layton !S_ISREG(file_inode((*dst)->nf_file)->i_mode)) { 1225ffa0160aSChristoph Hellwig status = nfserr_wrong_type; 1226ffa0160aSChristoph Hellwig goto out_put_dst; 1227ffa0160aSChristoph Hellwig } 1228ffa0160aSChristoph Hellwig 122929ae7f9dSAnna Schumaker out: 123029ae7f9dSAnna Schumaker return status; 123129ae7f9dSAnna Schumaker out_put_dst: 12325c4583b2SJeff Layton nfsd_file_put(*dst); 123329ae7f9dSAnna Schumaker out_put_src: 12345c4583b2SJeff Layton nfsd_file_put(*src); 123529ae7f9dSAnna Schumaker goto out; 123629ae7f9dSAnna Schumaker } 123729ae7f9dSAnna Schumaker 123829ae7f9dSAnna Schumaker static __be32 123929ae7f9dSAnna Schumaker nfsd4_clone(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 1240eb69853dSChristoph Hellwig union nfsd4_op_u *u) 124129ae7f9dSAnna Schumaker { 1242eb69853dSChristoph Hellwig struct nfsd4_clone *clone = &u->clone; 12435c4583b2SJeff Layton struct nfsd_file *src, *dst; 124429ae7f9dSAnna Schumaker __be32 status; 124529ae7f9dSAnna Schumaker 124629ae7f9dSAnna Schumaker status = nfsd4_verify_copy(rqstp, cstate, &clone->cl_src_stateid, &src, 124729ae7f9dSAnna Schumaker &clone->cl_dst_stateid, &dst); 124829ae7f9dSAnna Schumaker if (status) 124929ae7f9dSAnna Schumaker goto out; 125029ae7f9dSAnna Schumaker 1251a2f4c3faSTrond Myklebust status = nfsd4_clone_file_range(rqstp, src, clone->cl_src_pos, 1252b66ae6ddSTrond Myklebust dst, clone->cl_dst_pos, clone->cl_count, 1253a25e3726STrond Myklebust EX_ISSYNC(cstate->current_fh.fh_export)); 1254ffa0160aSChristoph Hellwig 12555c4583b2SJeff Layton nfsd_file_put(dst); 12565c4583b2SJeff Layton nfsd_file_put(src); 1257ffa0160aSChristoph Hellwig out: 1258ffa0160aSChristoph Hellwig return status; 1259ffa0160aSChristoph Hellwig } 1260ffa0160aSChristoph Hellwig 1261e0639dc5SOlga Kornievskaia void nfs4_put_copy(struct nfsd4_copy *copy) 1262e0639dc5SOlga Kornievskaia { 1263e0639dc5SOlga Kornievskaia if (!refcount_dec_and_test(©->refcount)) 1264e0639dc5SOlga Kornievskaia return; 1265e0639dc5SOlga Kornievskaia kfree(copy); 1266e0639dc5SOlga Kornievskaia } 1267e0639dc5SOlga Kornievskaia 1268e0639dc5SOlga Kornievskaia static bool 1269e0639dc5SOlga Kornievskaia check_and_set_stop_copy(struct nfsd4_copy *copy) 1270e0639dc5SOlga Kornievskaia { 1271e0639dc5SOlga Kornievskaia bool value; 1272e0639dc5SOlga Kornievskaia 1273e0639dc5SOlga Kornievskaia spin_lock(©->cp_clp->async_lock); 1274e0639dc5SOlga Kornievskaia value = copy->stopped; 1275e0639dc5SOlga Kornievskaia if (!copy->stopped) 1276e0639dc5SOlga Kornievskaia copy->stopped = true; 1277e0639dc5SOlga Kornievskaia spin_unlock(©->cp_clp->async_lock); 1278e0639dc5SOlga Kornievskaia return value; 1279e0639dc5SOlga Kornievskaia } 1280e0639dc5SOlga Kornievskaia 1281e0639dc5SOlga Kornievskaia static void nfsd4_stop_copy(struct nfsd4_copy *copy) 1282e0639dc5SOlga Kornievskaia { 1283e0639dc5SOlga Kornievskaia /* only 1 thread should stop the copy */ 1284e0639dc5SOlga Kornievskaia if (!check_and_set_stop_copy(copy)) 1285e0639dc5SOlga Kornievskaia kthread_stop(copy->copy_task); 1286e0639dc5SOlga Kornievskaia nfs4_put_copy(copy); 1287e0639dc5SOlga Kornievskaia } 1288e0639dc5SOlga Kornievskaia 1289e0639dc5SOlga Kornievskaia static struct nfsd4_copy *nfsd4_get_copy(struct nfs4_client *clp) 1290e0639dc5SOlga Kornievskaia { 1291e0639dc5SOlga Kornievskaia struct nfsd4_copy *copy = NULL; 1292e0639dc5SOlga Kornievskaia 1293e0639dc5SOlga Kornievskaia spin_lock(&clp->async_lock); 1294e0639dc5SOlga Kornievskaia if (!list_empty(&clp->async_copies)) { 1295e0639dc5SOlga Kornievskaia copy = list_first_entry(&clp->async_copies, struct nfsd4_copy, 1296e0639dc5SOlga Kornievskaia copies); 1297e0639dc5SOlga Kornievskaia refcount_inc(©->refcount); 1298e0639dc5SOlga Kornievskaia } 1299e0639dc5SOlga Kornievskaia spin_unlock(&clp->async_lock); 1300e0639dc5SOlga Kornievskaia return copy; 1301e0639dc5SOlga Kornievskaia } 1302e0639dc5SOlga Kornievskaia 1303e0639dc5SOlga Kornievskaia void nfsd4_shutdown_copy(struct nfs4_client *clp) 1304e0639dc5SOlga Kornievskaia { 1305e0639dc5SOlga Kornievskaia struct nfsd4_copy *copy; 1306e0639dc5SOlga Kornievskaia 1307e0639dc5SOlga Kornievskaia while ((copy = nfsd4_get_copy(clp)) != NULL) 1308e0639dc5SOlga Kornievskaia nfsd4_stop_copy(copy); 1309e0639dc5SOlga Kornievskaia } 1310ce0887acSOlga Kornievskaia #ifdef CONFIG_NFSD_V4_2_INTER_SSC 1311ce0887acSOlga Kornievskaia 1312ce0887acSOlga Kornievskaia extern struct file *nfs42_ssc_open(struct vfsmount *ss_mnt, 1313ce0887acSOlga Kornievskaia struct nfs_fh *src_fh, 1314ce0887acSOlga Kornievskaia nfs4_stateid *stateid); 1315ce0887acSOlga Kornievskaia extern void nfs42_ssc_close(struct file *filep); 1316ce0887acSOlga Kornievskaia 1317ce0887acSOlga Kornievskaia extern void nfs_sb_deactive(struct super_block *sb); 1318ce0887acSOlga Kornievskaia 1319ce0887acSOlga Kornievskaia #define NFSD42_INTERSSC_MOUNTOPS "vers=4.2,addr=%s,sec=sys" 1320ce0887acSOlga Kornievskaia 1321f2453978SChuck Lever /* 1322f4e44b39SDai Ngo * setup a work entry in the ssc delayed unmount list. 1323f4e44b39SDai Ngo */ 1324f47dc2d3SDai Ngo static __be32 nfsd4_ssc_setup_dul(struct nfsd_net *nn, char *ipaddr, 1325f4e44b39SDai Ngo struct nfsd4_ssc_umount_item **retwork, struct vfsmount **ss_mnt) 1326f4e44b39SDai Ngo { 13278e70bf27SColin Ian King struct nfsd4_ssc_umount_item *ni = NULL; 1328f4e44b39SDai Ngo struct nfsd4_ssc_umount_item *work = NULL; 1329f4e44b39SDai Ngo struct nfsd4_ssc_umount_item *tmp; 1330f4e44b39SDai Ngo DEFINE_WAIT(wait); 1331f4e44b39SDai Ngo 1332f4e44b39SDai Ngo *ss_mnt = NULL; 1333f4e44b39SDai Ngo *retwork = NULL; 1334f4e44b39SDai Ngo work = kzalloc(sizeof(*work), GFP_KERNEL); 1335f4e44b39SDai Ngo try_again: 1336f4e44b39SDai Ngo spin_lock(&nn->nfsd_ssc_lock); 1337f4e44b39SDai Ngo list_for_each_entry_safe(ni, tmp, &nn->nfsd_ssc_mount_list, nsui_list) { 1338f4e44b39SDai Ngo if (strncmp(ni->nsui_ipaddr, ipaddr, sizeof(ni->nsui_ipaddr))) 1339f4e44b39SDai Ngo continue; 1340f4e44b39SDai Ngo /* found a match */ 1341f4e44b39SDai Ngo if (ni->nsui_busy) { 1342f4e44b39SDai Ngo /* wait - and try again */ 1343f4e44b39SDai Ngo prepare_to_wait(&nn->nfsd_ssc_waitq, &wait, 1344f4e44b39SDai Ngo TASK_INTERRUPTIBLE); 1345f4e44b39SDai Ngo spin_unlock(&nn->nfsd_ssc_lock); 1346f4e44b39SDai Ngo 1347f4e44b39SDai Ngo /* allow 20secs for mount/unmount for now - revisit */ 1348f4e44b39SDai Ngo if (signal_pending(current) || 1349f4e44b39SDai Ngo (schedule_timeout(20*HZ) == 0)) { 1350f4e44b39SDai Ngo kfree(work); 1351f4e44b39SDai Ngo return nfserr_eagain; 1352f4e44b39SDai Ngo } 1353f4e44b39SDai Ngo finish_wait(&nn->nfsd_ssc_waitq, &wait); 1354f4e44b39SDai Ngo goto try_again; 1355f4e44b39SDai Ngo } 1356f4e44b39SDai Ngo *ss_mnt = ni->nsui_vfsmount; 1357f4e44b39SDai Ngo refcount_inc(&ni->nsui_refcnt); 1358f4e44b39SDai Ngo spin_unlock(&nn->nfsd_ssc_lock); 1359f4e44b39SDai Ngo kfree(work); 1360f4e44b39SDai Ngo 1361f4e44b39SDai Ngo /* return vfsmount in ss_mnt */ 1362f4e44b39SDai Ngo return 0; 1363f4e44b39SDai Ngo } 1364f4e44b39SDai Ngo if (work) { 1365f4e44b39SDai Ngo strncpy(work->nsui_ipaddr, ipaddr, sizeof(work->nsui_ipaddr)); 1366f4e44b39SDai Ngo refcount_set(&work->nsui_refcnt, 2); 1367f4e44b39SDai Ngo work->nsui_busy = true; 1368f4e44b39SDai Ngo list_add_tail(&work->nsui_list, &nn->nfsd_ssc_mount_list); 1369f4e44b39SDai Ngo *retwork = work; 1370f4e44b39SDai Ngo } 1371f4e44b39SDai Ngo spin_unlock(&nn->nfsd_ssc_lock); 1372f4e44b39SDai Ngo return 0; 1373f4e44b39SDai Ngo } 1374f4e44b39SDai Ngo 1375f4e44b39SDai Ngo static void nfsd4_ssc_update_dul_work(struct nfsd_net *nn, 1376f4e44b39SDai Ngo struct nfsd4_ssc_umount_item *work, struct vfsmount *ss_mnt) 1377f4e44b39SDai Ngo { 1378f4e44b39SDai Ngo /* set nsui_vfsmount, clear busy flag and wakeup waiters */ 1379f4e44b39SDai Ngo spin_lock(&nn->nfsd_ssc_lock); 1380f4e44b39SDai Ngo work->nsui_vfsmount = ss_mnt; 1381f4e44b39SDai Ngo work->nsui_busy = false; 1382f4e44b39SDai Ngo wake_up_all(&nn->nfsd_ssc_waitq); 1383f4e44b39SDai Ngo spin_unlock(&nn->nfsd_ssc_lock); 1384f4e44b39SDai Ngo } 1385f4e44b39SDai Ngo 1386f4e44b39SDai Ngo static void nfsd4_ssc_cancel_dul_work(struct nfsd_net *nn, 1387f4e44b39SDai Ngo struct nfsd4_ssc_umount_item *work) 1388f4e44b39SDai Ngo { 1389f4e44b39SDai Ngo spin_lock(&nn->nfsd_ssc_lock); 1390f4e44b39SDai Ngo list_del(&work->nsui_list); 1391f4e44b39SDai Ngo wake_up_all(&nn->nfsd_ssc_waitq); 1392f4e44b39SDai Ngo spin_unlock(&nn->nfsd_ssc_lock); 1393f4e44b39SDai Ngo kfree(work); 1394f4e44b39SDai Ngo } 1395f4e44b39SDai Ngo 1396f4e44b39SDai Ngo /* 1397ce0887acSOlga Kornievskaia * Support one copy source server for now. 1398ce0887acSOlga Kornievskaia */ 1399ce0887acSOlga Kornievskaia static __be32 1400ce0887acSOlga Kornievskaia nfsd4_interssc_connect(struct nl4_server *nss, struct svc_rqst *rqstp, 1401ce0887acSOlga Kornievskaia struct vfsmount **mount) 1402ce0887acSOlga Kornievskaia { 1403ce0887acSOlga Kornievskaia struct file_system_type *type; 1404ce0887acSOlga Kornievskaia struct vfsmount *ss_mnt; 1405ce0887acSOlga Kornievskaia struct nfs42_netaddr *naddr; 1406ce0887acSOlga Kornievskaia struct sockaddr_storage tmp_addr; 1407ce0887acSOlga Kornievskaia size_t tmp_addrlen, match_netid_len = 3; 1408ce0887acSOlga Kornievskaia char *startsep = "", *endsep = "", *match_netid = "tcp"; 1409ce0887acSOlga Kornievskaia char *ipaddr, *dev_name, *raw_data; 1410b8290ca2SOlga Kornievskaia int len, raw_len; 1411b8290ca2SOlga Kornievskaia __be32 status = nfserr_inval; 1412f4e44b39SDai Ngo struct nfsd4_ssc_umount_item *work = NULL; 1413f4e44b39SDai Ngo struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); 1414ce0887acSOlga Kornievskaia 1415ce0887acSOlga Kornievskaia naddr = &nss->u.nl4_addr; 1416ce0887acSOlga Kornievskaia tmp_addrlen = rpc_uaddr2sockaddr(SVC_NET(rqstp), naddr->addr, 1417ce0887acSOlga Kornievskaia naddr->addr_len, 1418ce0887acSOlga Kornievskaia (struct sockaddr *)&tmp_addr, 1419ce0887acSOlga Kornievskaia sizeof(tmp_addr)); 1420ce0887acSOlga Kornievskaia if (tmp_addrlen == 0) 1421ce0887acSOlga Kornievskaia goto out_err; 1422ce0887acSOlga Kornievskaia 1423ce0887acSOlga Kornievskaia if (tmp_addr.ss_family == AF_INET6) { 1424ce0887acSOlga Kornievskaia startsep = "["; 1425ce0887acSOlga Kornievskaia endsep = "]"; 1426ce0887acSOlga Kornievskaia match_netid = "tcp6"; 1427ce0887acSOlga Kornievskaia match_netid_len = 4; 1428ce0887acSOlga Kornievskaia } 1429ce0887acSOlga Kornievskaia 1430ce0887acSOlga Kornievskaia if (naddr->netid_len != match_netid_len || 1431ce0887acSOlga Kornievskaia strncmp(naddr->netid, match_netid, naddr->netid_len)) 1432ce0887acSOlga Kornievskaia goto out_err; 1433ce0887acSOlga Kornievskaia 1434ce0887acSOlga Kornievskaia /* Construct the raw data for the vfs_kern_mount call */ 1435ce0887acSOlga Kornievskaia len = RPC_MAX_ADDRBUFLEN + 1; 1436ce0887acSOlga Kornievskaia ipaddr = kzalloc(len, GFP_KERNEL); 1437ce0887acSOlga Kornievskaia if (!ipaddr) 1438ce0887acSOlga Kornievskaia goto out_err; 1439ce0887acSOlga Kornievskaia 1440ce0887acSOlga Kornievskaia rpc_ntop((struct sockaddr *)&tmp_addr, ipaddr, len); 1441ce0887acSOlga Kornievskaia 1442ce0887acSOlga Kornievskaia /* 2 for ipv6 endsep and startsep. 3 for ":/" and trailing '/0'*/ 1443ce0887acSOlga Kornievskaia 1444ce0887acSOlga Kornievskaia raw_len = strlen(NFSD42_INTERSSC_MOUNTOPS) + strlen(ipaddr); 1445ce0887acSOlga Kornievskaia raw_data = kzalloc(raw_len, GFP_KERNEL); 1446ce0887acSOlga Kornievskaia if (!raw_data) 1447ce0887acSOlga Kornievskaia goto out_free_ipaddr; 1448ce0887acSOlga Kornievskaia 1449ce0887acSOlga Kornievskaia snprintf(raw_data, raw_len, NFSD42_INTERSSC_MOUNTOPS, ipaddr); 1450ce0887acSOlga Kornievskaia 1451b8290ca2SOlga Kornievskaia status = nfserr_nodev; 1452ce0887acSOlga Kornievskaia type = get_fs_type("nfs"); 1453ce0887acSOlga Kornievskaia if (!type) 1454ce0887acSOlga Kornievskaia goto out_free_rawdata; 1455ce0887acSOlga Kornievskaia 1456ce0887acSOlga Kornievskaia /* Set the server:<export> for the vfs_kern_mount call */ 1457ce0887acSOlga Kornievskaia dev_name = kzalloc(len + 5, GFP_KERNEL); 1458ce0887acSOlga Kornievskaia if (!dev_name) 1459ce0887acSOlga Kornievskaia goto out_free_rawdata; 1460ce0887acSOlga Kornievskaia snprintf(dev_name, len + 5, "%s%s%s:/", startsep, ipaddr, endsep); 1461ce0887acSOlga Kornievskaia 1462f4e44b39SDai Ngo status = nfsd4_ssc_setup_dul(nn, ipaddr, &work, &ss_mnt); 1463f4e44b39SDai Ngo if (status) 1464f4e44b39SDai Ngo goto out_free_devname; 1465f4e44b39SDai Ngo if (ss_mnt) 1466f4e44b39SDai Ngo goto out_done; 1467f4e44b39SDai Ngo 1468ce0887acSOlga Kornievskaia /* Use an 'internal' mount: SB_KERNMOUNT -> MNT_INTERNAL */ 1469ce0887acSOlga Kornievskaia ss_mnt = vfs_kern_mount(type, SB_KERNMOUNT, dev_name, raw_data); 1470ce0887acSOlga Kornievskaia module_put(type->owner); 1471f4e44b39SDai Ngo if (IS_ERR(ss_mnt)) { 147254185267SWei Yongjun status = nfserr_nodev; 1473f4e44b39SDai Ngo if (work) 1474f4e44b39SDai Ngo nfsd4_ssc_cancel_dul_work(nn, work); 1475ce0887acSOlga Kornievskaia goto out_free_devname; 1476f4e44b39SDai Ngo } 1477f4e44b39SDai Ngo if (work) 1478f4e44b39SDai Ngo nfsd4_ssc_update_dul_work(nn, work, ss_mnt); 1479f4e44b39SDai Ngo out_done: 1480ce0887acSOlga Kornievskaia status = 0; 1481ce0887acSOlga Kornievskaia *mount = ss_mnt; 1482ce0887acSOlga Kornievskaia 1483ce0887acSOlga Kornievskaia out_free_devname: 1484ce0887acSOlga Kornievskaia kfree(dev_name); 1485ce0887acSOlga Kornievskaia out_free_rawdata: 1486ce0887acSOlga Kornievskaia kfree(raw_data); 1487ce0887acSOlga Kornievskaia out_free_ipaddr: 1488ce0887acSOlga Kornievskaia kfree(ipaddr); 1489ce0887acSOlga Kornievskaia out_err: 1490ce0887acSOlga Kornievskaia return status; 1491ce0887acSOlga Kornievskaia } 1492ce0887acSOlga Kornievskaia 1493ce0887acSOlga Kornievskaia static void 1494ce0887acSOlga Kornievskaia nfsd4_interssc_disconnect(struct vfsmount *ss_mnt) 1495ce0887acSOlga Kornievskaia { 14960cfcd405SDai Ngo nfs_do_sb_deactive(ss_mnt->mnt_sb); 1497ce0887acSOlga Kornievskaia mntput(ss_mnt); 1498ce0887acSOlga Kornievskaia } 1499ce0887acSOlga Kornievskaia 1500f2453978SChuck Lever /* 1501ce0887acSOlga Kornievskaia * Verify COPY destination stateid. 1502f2453978SChuck Lever * 1503ce0887acSOlga Kornievskaia * Connect to the source server with NFSv4.1. 1504ce0887acSOlga Kornievskaia * Create the source struct file for nfsd_copy_range. 1505ce0887acSOlga Kornievskaia * Called with COPY cstate: 1506ce0887acSOlga Kornievskaia * SAVED_FH: source filehandle 1507ce0887acSOlga Kornievskaia * CURRENT_FH: destination filehandle 1508ce0887acSOlga Kornievskaia */ 1509ce0887acSOlga Kornievskaia static __be32 1510ce0887acSOlga Kornievskaia nfsd4_setup_inter_ssc(struct svc_rqst *rqstp, 1511ce0887acSOlga Kornievskaia struct nfsd4_compound_state *cstate, 1512ce0887acSOlga Kornievskaia struct nfsd4_copy *copy, struct vfsmount **mount) 1513ce0887acSOlga Kornievskaia { 1514ce0887acSOlga Kornievskaia struct svc_fh *s_fh = NULL; 1515ce0887acSOlga Kornievskaia stateid_t *s_stid = ©->cp_src_stateid; 1516b8290ca2SOlga Kornievskaia __be32 status = nfserr_inval; 1517ce0887acSOlga Kornievskaia 1518ce0887acSOlga Kornievskaia /* Verify the destination stateid and set dst struct file*/ 1519ce0887acSOlga Kornievskaia status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh, 1520ce0887acSOlga Kornievskaia ©->cp_dst_stateid, 1521ce0887acSOlga Kornievskaia WR_STATE, ©->nf_dst, NULL); 1522ce0887acSOlga Kornievskaia if (status) 1523ce0887acSOlga Kornievskaia goto out; 1524ce0887acSOlga Kornievskaia 1525ce0887acSOlga Kornievskaia status = nfsd4_interssc_connect(©->cp_src, rqstp, mount); 1526ce0887acSOlga Kornievskaia if (status) 1527ce0887acSOlga Kornievskaia goto out; 1528ce0887acSOlga Kornievskaia 1529ce0887acSOlga Kornievskaia s_fh = &cstate->save_fh; 1530ce0887acSOlga Kornievskaia 1531ce0887acSOlga Kornievskaia copy->c_fh.size = s_fh->fh_handle.fh_size; 1532d8b26071SNeilBrown memcpy(copy->c_fh.data, &s_fh->fh_handle.fh_raw, copy->c_fh.size); 15333f9544caSOlga Kornievskaia copy->stateid.seqid = cpu_to_be32(s_stid->si_generation); 1534ce0887acSOlga Kornievskaia memcpy(copy->stateid.other, (void *)&s_stid->si_opaque, 1535ce0887acSOlga Kornievskaia sizeof(stateid_opaque_t)); 1536ce0887acSOlga Kornievskaia 1537ce0887acSOlga Kornievskaia status = 0; 1538ce0887acSOlga Kornievskaia out: 1539ce0887acSOlga Kornievskaia return status; 1540ce0887acSOlga Kornievskaia } 1541ce0887acSOlga Kornievskaia 1542ce0887acSOlga Kornievskaia static void 1543ce0887acSOlga Kornievskaia nfsd4_cleanup_inter_ssc(struct vfsmount *ss_mnt, struct nfsd_file *src, 1544ce0887acSOlga Kornievskaia struct nfsd_file *dst) 1545ce0887acSOlga Kornievskaia { 1546f4e44b39SDai Ngo bool found = false; 1547f4e44b39SDai Ngo long timeout; 1548f4e44b39SDai Ngo struct nfsd4_ssc_umount_item *tmp; 1549f47dc2d3SDai Ngo struct nfsd4_ssc_umount_item *ni = NULL; 1550f4e44b39SDai Ngo struct nfsd_net *nn = net_generic(dst->nf_net, nfsd_net_id); 1551f4e44b39SDai Ngo 1552ce0887acSOlga Kornievskaia nfs42_ssc_close(src->nf_file); 1553ce0887acSOlga Kornievskaia nfsd_file_put(dst); 1554f4e44b39SDai Ngo fput(src->nf_file); 1555f4e44b39SDai Ngo 1556f4e44b39SDai Ngo if (!nn) { 1557ce0887acSOlga Kornievskaia mntput(ss_mnt); 1558f4e44b39SDai Ngo return; 1559f4e44b39SDai Ngo } 1560f4e44b39SDai Ngo spin_lock(&nn->nfsd_ssc_lock); 1561f4e44b39SDai Ngo timeout = msecs_to_jiffies(nfsd4_ssc_umount_timeout); 1562f4e44b39SDai Ngo list_for_each_entry_safe(ni, tmp, &nn->nfsd_ssc_mount_list, nsui_list) { 1563f4e44b39SDai Ngo if (ni->nsui_vfsmount->mnt_sb == ss_mnt->mnt_sb) { 1564f4e44b39SDai Ngo list_del(&ni->nsui_list); 1565f4e44b39SDai Ngo /* 1566f4e44b39SDai Ngo * vfsmount can be shared by multiple exports, 1567f4e44b39SDai Ngo * decrement refcnt. If the count drops to 1 it 1568f4e44b39SDai Ngo * will be unmounted when nsui_expire expires. 1569f4e44b39SDai Ngo */ 1570f4e44b39SDai Ngo refcount_dec(&ni->nsui_refcnt); 1571f4e44b39SDai Ngo ni->nsui_expire = jiffies + timeout; 1572f4e44b39SDai Ngo list_add_tail(&ni->nsui_list, &nn->nfsd_ssc_mount_list); 1573f4e44b39SDai Ngo found = true; 1574f4e44b39SDai Ngo break; 1575f4e44b39SDai Ngo } 1576f4e44b39SDai Ngo } 1577f4e44b39SDai Ngo spin_unlock(&nn->nfsd_ssc_lock); 1578f4e44b39SDai Ngo if (!found) { 1579f4e44b39SDai Ngo mntput(ss_mnt); 1580f4e44b39SDai Ngo return; 1581f4e44b39SDai Ngo } 1582ce0887acSOlga Kornievskaia } 1583ce0887acSOlga Kornievskaia 1584ce0887acSOlga Kornievskaia #else /* CONFIG_NFSD_V4_2_INTER_SSC */ 1585ce0887acSOlga Kornievskaia 1586ce0887acSOlga Kornievskaia static __be32 1587ce0887acSOlga Kornievskaia nfsd4_setup_inter_ssc(struct svc_rqst *rqstp, 1588ce0887acSOlga Kornievskaia struct nfsd4_compound_state *cstate, 1589ce0887acSOlga Kornievskaia struct nfsd4_copy *copy, 1590ce0887acSOlga Kornievskaia struct vfsmount **mount) 1591ce0887acSOlga Kornievskaia { 1592ce0887acSOlga Kornievskaia *mount = NULL; 1593b8290ca2SOlga Kornievskaia return nfserr_inval; 1594ce0887acSOlga Kornievskaia } 1595ce0887acSOlga Kornievskaia 1596ce0887acSOlga Kornievskaia static void 1597ce0887acSOlga Kornievskaia nfsd4_cleanup_inter_ssc(struct vfsmount *ss_mnt, struct nfsd_file *src, 1598ce0887acSOlga Kornievskaia struct nfsd_file *dst) 1599ce0887acSOlga Kornievskaia { 1600ce0887acSOlga Kornievskaia } 1601ce0887acSOlga Kornievskaia 1602ce0887acSOlga Kornievskaia static void 1603ce0887acSOlga Kornievskaia nfsd4_interssc_disconnect(struct vfsmount *ss_mnt) 1604ce0887acSOlga Kornievskaia { 1605ce0887acSOlga Kornievskaia } 1606ce0887acSOlga Kornievskaia 1607ce0887acSOlga Kornievskaia static struct file *nfs42_ssc_open(struct vfsmount *ss_mnt, 1608ce0887acSOlga Kornievskaia struct nfs_fh *src_fh, 1609ce0887acSOlga Kornievskaia nfs4_stateid *stateid) 1610ce0887acSOlga Kornievskaia { 1611ce0887acSOlga Kornievskaia return NULL; 1612ce0887acSOlga Kornievskaia } 1613ce0887acSOlga Kornievskaia #endif /* CONFIG_NFSD_V4_2_INTER_SSC */ 1614ce0887acSOlga Kornievskaia 1615ce0887acSOlga Kornievskaia static __be32 1616ce0887acSOlga Kornievskaia nfsd4_setup_intra_ssc(struct svc_rqst *rqstp, 1617ce0887acSOlga Kornievskaia struct nfsd4_compound_state *cstate, 1618ce0887acSOlga Kornievskaia struct nfsd4_copy *copy) 1619ce0887acSOlga Kornievskaia { 1620ce0887acSOlga Kornievskaia return nfsd4_verify_copy(rqstp, cstate, ©->cp_src_stateid, 1621ce0887acSOlga Kornievskaia ©->nf_src, ©->cp_dst_stateid, 1622ce0887acSOlga Kornievskaia ©->nf_dst); 1623ce0887acSOlga Kornievskaia } 1624ce0887acSOlga Kornievskaia 1625ce0887acSOlga Kornievskaia static void 1626ce0887acSOlga Kornievskaia nfsd4_cleanup_intra_ssc(struct nfsd_file *src, struct nfsd_file *dst) 1627ce0887acSOlga Kornievskaia { 1628ce0887acSOlga Kornievskaia nfsd_file_put(src); 1629ce0887acSOlga Kornievskaia nfsd_file_put(dst); 1630ce0887acSOlga Kornievskaia } 1631e0639dc5SOlga Kornievskaia 1632e0639dc5SOlga Kornievskaia static void nfsd4_cb_offload_release(struct nfsd4_callback *cb) 1633e0639dc5SOlga Kornievskaia { 1634e0639dc5SOlga Kornievskaia struct nfsd4_copy *copy = container_of(cb, struct nfsd4_copy, cp_cb); 1635e0639dc5SOlga Kornievskaia 1636e0639dc5SOlga Kornievskaia nfs4_put_copy(copy); 1637e0639dc5SOlga Kornievskaia } 1638e0639dc5SOlga Kornievskaia 1639e0639dc5SOlga Kornievskaia static int nfsd4_cb_offload_done(struct nfsd4_callback *cb, 1640e0639dc5SOlga Kornievskaia struct rpc_task *task) 1641e0639dc5SOlga Kornievskaia { 1642e0639dc5SOlga Kornievskaia return 1; 1643e0639dc5SOlga Kornievskaia } 1644e0639dc5SOlga Kornievskaia 1645e0639dc5SOlga Kornievskaia static const struct nfsd4_callback_ops nfsd4_cb_offload_ops = { 1646e0639dc5SOlga Kornievskaia .release = nfsd4_cb_offload_release, 1647e0639dc5SOlga Kornievskaia .done = nfsd4_cb_offload_done 1648e0639dc5SOlga Kornievskaia }; 1649e0639dc5SOlga Kornievskaia 1650e0639dc5SOlga Kornievskaia static void nfsd4_init_copy_res(struct nfsd4_copy *copy, bool sync) 1651e0639dc5SOlga Kornievskaia { 1652eac0b17aSOlga Kornievskaia copy->cp_res.wr_stable_how = 1653eac0b17aSOlga Kornievskaia copy->committed ? NFS_FILE_SYNC : NFS_UNSTABLE; 1654e0639dc5SOlga Kornievskaia copy->cp_synchronous = sync; 1655e0639dc5SOlga Kornievskaia gen_boot_verifier(©->cp_res.wr_verifier, copy->cp_clp->net); 1656e0639dc5SOlga Kornievskaia } 1657e0639dc5SOlga Kornievskaia 1658e0639dc5SOlga Kornievskaia static ssize_t _nfsd_copy_file_range(struct nfsd4_copy *copy) 1659e0639dc5SOlga Kornievskaia { 1660555dbf1aSTrond Myklebust struct file *dst = copy->nf_dst->nf_file; 1661555dbf1aSTrond Myklebust struct file *src = copy->nf_src->nf_file; 1662555dbf1aSTrond Myklebust errseq_t since; 1663e0639dc5SOlga Kornievskaia ssize_t bytes_copied = 0; 1664e7a833e9SJ. Bruce Fields u64 bytes_total = copy->cp_count; 1665e0639dc5SOlga Kornievskaia u64 src_pos = copy->cp_src_pos; 1666e0639dc5SOlga Kornievskaia u64 dst_pos = copy->cp_dst_pos; 1667c2f1c4bdSChuck Lever int status; 1668e0639dc5SOlga Kornievskaia 1669792a5112SJ. Bruce Fields /* See RFC 7862 p.67: */ 1670792a5112SJ. Bruce Fields if (bytes_total == 0) 1671792a5112SJ. Bruce Fields bytes_total = ULLONG_MAX; 1672e0639dc5SOlga Kornievskaia do { 1673e0639dc5SOlga Kornievskaia if (kthread_should_stop()) 1674e0639dc5SOlga Kornievskaia break; 1675555dbf1aSTrond Myklebust bytes_copied = nfsd_copy_file_range(src, src_pos, dst, dst_pos, 16765c4583b2SJeff Layton bytes_total); 1677e0639dc5SOlga Kornievskaia if (bytes_copied <= 0) 1678e0639dc5SOlga Kornievskaia break; 1679e0639dc5SOlga Kornievskaia bytes_total -= bytes_copied; 1680e0639dc5SOlga Kornievskaia copy->cp_res.wr_bytes_written += bytes_copied; 1681e0639dc5SOlga Kornievskaia src_pos += bytes_copied; 1682e0639dc5SOlga Kornievskaia dst_pos += bytes_copied; 1683e0639dc5SOlga Kornievskaia } while (bytes_total > 0 && !copy->cp_synchronous); 1684eac0b17aSOlga Kornievskaia /* for a non-zero asynchronous copy do a commit of data */ 1685eac0b17aSOlga Kornievskaia if (!copy->cp_synchronous && copy->cp_res.wr_bytes_written > 0) { 1686555dbf1aSTrond Myklebust since = READ_ONCE(dst->f_wb_err); 1687555dbf1aSTrond Myklebust status = vfs_fsync_range(dst, copy->cp_dst_pos, 1688eac0b17aSOlga Kornievskaia copy->cp_res.wr_bytes_written, 0); 1689555dbf1aSTrond Myklebust if (!status) 1690555dbf1aSTrond Myklebust status = filemap_check_wb_err(dst->f_mapping, since); 1691eac0b17aSOlga Kornievskaia if (!status) 1692eac0b17aSOlga Kornievskaia copy->committed = true; 1693eac0b17aSOlga Kornievskaia } 1694e0639dc5SOlga Kornievskaia return bytes_copied; 1695e0639dc5SOlga Kornievskaia } 1696e0639dc5SOlga Kornievskaia 1697e0639dc5SOlga Kornievskaia static __be32 nfsd4_do_copy(struct nfsd4_copy *copy, bool sync) 1698e0639dc5SOlga Kornievskaia { 1699e0639dc5SOlga Kornievskaia __be32 status; 1700e0639dc5SOlga Kornievskaia ssize_t bytes; 1701e0639dc5SOlga Kornievskaia 1702e0639dc5SOlga Kornievskaia bytes = _nfsd_copy_file_range(copy); 1703e0639dc5SOlga Kornievskaia /* for async copy, we ignore the error, client can always retry 1704e0639dc5SOlga Kornievskaia * to get the error 1705e0639dc5SOlga Kornievskaia */ 1706e0639dc5SOlga Kornievskaia if (bytes < 0 && !copy->cp_res.wr_bytes_written) 1707e0639dc5SOlga Kornievskaia status = nfserrno(bytes); 1708e0639dc5SOlga Kornievskaia else { 1709e0639dc5SOlga Kornievskaia nfsd4_init_copy_res(copy, sync); 1710e0639dc5SOlga Kornievskaia status = nfs_ok; 1711e0639dc5SOlga Kornievskaia } 1712e0639dc5SOlga Kornievskaia 1713ce0887acSOlga Kornievskaia if (!copy->cp_intra) /* Inter server SSC */ 1714ce0887acSOlga Kornievskaia nfsd4_cleanup_inter_ssc(copy->ss_mnt, copy->nf_src, 1715ce0887acSOlga Kornievskaia copy->nf_dst); 1716ce0887acSOlga Kornievskaia else 1717ce0887acSOlga Kornievskaia nfsd4_cleanup_intra_ssc(copy->nf_src, copy->nf_dst); 1718ce0887acSOlga Kornievskaia 1719e0639dc5SOlga Kornievskaia return status; 1720e0639dc5SOlga Kornievskaia } 1721e0639dc5SOlga Kornievskaia 1722eb162e17SChuck Lever static void dup_copy_fields(struct nfsd4_copy *src, struct nfsd4_copy *dst) 1723e0639dc5SOlga Kornievskaia { 1724e0639dc5SOlga Kornievskaia dst->cp_src_pos = src->cp_src_pos; 1725e0639dc5SOlga Kornievskaia dst->cp_dst_pos = src->cp_dst_pos; 1726e0639dc5SOlga Kornievskaia dst->cp_count = src->cp_count; 1727e0639dc5SOlga Kornievskaia dst->cp_synchronous = src->cp_synchronous; 1728e0639dc5SOlga Kornievskaia memcpy(&dst->cp_res, &src->cp_res, sizeof(src->cp_res)); 1729e0639dc5SOlga Kornievskaia memcpy(&dst->fh, &src->fh, sizeof(src->fh)); 1730e0639dc5SOlga Kornievskaia dst->cp_clp = src->cp_clp; 17315c4583b2SJeff Layton dst->nf_dst = nfsd_file_get(src->nf_dst); 1732ce0887acSOlga Kornievskaia dst->cp_intra = src->cp_intra; 1733ce0887acSOlga Kornievskaia if (src->cp_intra) /* for inter, file_src doesn't exist yet */ 17345c4583b2SJeff Layton dst->nf_src = nfsd_file_get(src->nf_src); 1735ce0887acSOlga Kornievskaia 1736e0639dc5SOlga Kornievskaia memcpy(&dst->cp_stateid, &src->cp_stateid, sizeof(src->cp_stateid)); 1737ce0887acSOlga Kornievskaia memcpy(&dst->cp_src, &src->cp_src, sizeof(struct nl4_server)); 1738ce0887acSOlga Kornievskaia memcpy(&dst->stateid, &src->stateid, sizeof(src->stateid)); 1739ce0887acSOlga Kornievskaia memcpy(&dst->c_fh, &src->c_fh, sizeof(src->c_fh)); 1740ce0887acSOlga Kornievskaia dst->ss_mnt = src->ss_mnt; 1741e0639dc5SOlga Kornievskaia } 1742e0639dc5SOlga Kornievskaia 1743e0639dc5SOlga Kornievskaia static void cleanup_async_copy(struct nfsd4_copy *copy) 1744e0639dc5SOlga Kornievskaia { 1745624322f1SOlga Kornievskaia nfs4_free_copy_state(copy); 17465c4583b2SJeff Layton nfsd_file_put(copy->nf_dst); 17472e577f0fSOlga Kornievskaia if (copy->cp_intra) 17485c4583b2SJeff Layton nfsd_file_put(copy->nf_src); 1749e0639dc5SOlga Kornievskaia spin_lock(©->cp_clp->async_lock); 1750e0639dc5SOlga Kornievskaia list_del(©->copies); 1751e0639dc5SOlga Kornievskaia spin_unlock(©->cp_clp->async_lock); 1752e0639dc5SOlga Kornievskaia nfs4_put_copy(copy); 1753e0639dc5SOlga Kornievskaia } 1754e0639dc5SOlga Kornievskaia 1755e0639dc5SOlga Kornievskaia static int nfsd4_do_async_copy(void *data) 1756e0639dc5SOlga Kornievskaia { 1757e0639dc5SOlga Kornievskaia struct nfsd4_copy *copy = (struct nfsd4_copy *)data; 1758e0639dc5SOlga Kornievskaia struct nfsd4_copy *cb_copy; 1759e0639dc5SOlga Kornievskaia 1760ce0887acSOlga Kornievskaia if (!copy->cp_intra) { /* Inter server SSC */ 1761ce0887acSOlga Kornievskaia copy->nf_src = kzalloc(sizeof(struct nfsd_file), GFP_KERNEL); 1762ce0887acSOlga Kornievskaia if (!copy->nf_src) { 1763ce0887acSOlga Kornievskaia copy->nfserr = nfserr_serverfault; 1764ce0887acSOlga Kornievskaia nfsd4_interssc_disconnect(copy->ss_mnt); 1765ce0887acSOlga Kornievskaia goto do_callback; 1766ce0887acSOlga Kornievskaia } 1767ce0887acSOlga Kornievskaia copy->nf_src->nf_file = nfs42_ssc_open(copy->ss_mnt, ©->c_fh, 1768ce0887acSOlga Kornievskaia ©->stateid); 1769ce0887acSOlga Kornievskaia if (IS_ERR(copy->nf_src->nf_file)) { 1770ce0887acSOlga Kornievskaia copy->nfserr = nfserr_offload_denied; 1771ce0887acSOlga Kornievskaia nfsd4_interssc_disconnect(copy->ss_mnt); 1772ce0887acSOlga Kornievskaia goto do_callback; 1773ce0887acSOlga Kornievskaia } 1774ce0887acSOlga Kornievskaia } 1775ce0887acSOlga Kornievskaia 1776e0639dc5SOlga Kornievskaia copy->nfserr = nfsd4_do_copy(copy, 0); 1777ce0887acSOlga Kornievskaia do_callback: 1778e0639dc5SOlga Kornievskaia cb_copy = kzalloc(sizeof(struct nfsd4_copy), GFP_KERNEL); 1779e0639dc5SOlga Kornievskaia if (!cb_copy) 1780e0639dc5SOlga Kornievskaia goto out; 178149a36132SDai Ngo refcount_set(&cb_copy->refcount, 1); 1782e0639dc5SOlga Kornievskaia memcpy(&cb_copy->cp_res, ©->cp_res, sizeof(copy->cp_res)); 1783e0639dc5SOlga Kornievskaia cb_copy->cp_clp = copy->cp_clp; 1784e0639dc5SOlga Kornievskaia cb_copy->nfserr = copy->nfserr; 1785e0639dc5SOlga Kornievskaia memcpy(&cb_copy->fh, ©->fh, sizeof(copy->fh)); 1786e0639dc5SOlga Kornievskaia nfsd4_init_cb(&cb_copy->cp_cb, cb_copy->cp_clp, 1787e0639dc5SOlga Kornievskaia &nfsd4_cb_offload_ops, NFSPROC4_CLNT_CB_OFFLOAD); 178887512386SChuck Lever trace_nfsd_cb_offload(copy->cp_clp, ©->cp_res.cb_stateid, 178987512386SChuck Lever ©->fh, copy->cp_count, copy->nfserr); 1790e0639dc5SOlga Kornievskaia nfsd4_run_cb(&cb_copy->cp_cb); 1791e0639dc5SOlga Kornievskaia out: 1792ce0887acSOlga Kornievskaia if (!copy->cp_intra) 1793ce0887acSOlga Kornievskaia kfree(copy->nf_src); 1794e0639dc5SOlga Kornievskaia cleanup_async_copy(copy); 1795e0639dc5SOlga Kornievskaia return 0; 1796e0639dc5SOlga Kornievskaia } 1797e0639dc5SOlga Kornievskaia 1798ffa0160aSChristoph Hellwig static __be32 179929ae7f9dSAnna Schumaker nfsd4_copy(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 1800eb69853dSChristoph Hellwig union nfsd4_op_u *u) 180129ae7f9dSAnna Schumaker { 1802eb69853dSChristoph Hellwig struct nfsd4_copy *copy = &u->copy; 180329ae7f9dSAnna Schumaker __be32 status; 1804e0639dc5SOlga Kornievskaia struct nfsd4_copy *async_copy = NULL; 180529ae7f9dSAnna Schumaker 1806ce0887acSOlga Kornievskaia if (!copy->cp_intra) { /* Inter server SSC */ 1807ce0887acSOlga Kornievskaia if (!inter_copy_offload_enable || copy->cp_synchronous) { 1808ce0887acSOlga Kornievskaia status = nfserr_notsupp; 180929ae7f9dSAnna Schumaker goto out; 1810ce0887acSOlga Kornievskaia } 1811ce0887acSOlga Kornievskaia status = nfsd4_setup_inter_ssc(rqstp, cstate, copy, 1812ce0887acSOlga Kornievskaia ©->ss_mnt); 1813ce0887acSOlga Kornievskaia if (status) 1814ce0887acSOlga Kornievskaia return nfserr_offload_denied; 1815ce0887acSOlga Kornievskaia } else { 1816ce0887acSOlga Kornievskaia status = nfsd4_setup_intra_ssc(rqstp, cstate, copy); 1817ce0887acSOlga Kornievskaia if (status) 1818ce0887acSOlga Kornievskaia return status; 1819ce0887acSOlga Kornievskaia } 182029ae7f9dSAnna Schumaker 1821e0639dc5SOlga Kornievskaia copy->cp_clp = cstate->clp; 1822e0639dc5SOlga Kornievskaia memcpy(©->fh, &cstate->current_fh.fh_handle, 1823e0639dc5SOlga Kornievskaia sizeof(struct knfsd_fh)); 1824e0639dc5SOlga Kornievskaia if (!copy->cp_synchronous) { 1825e0639dc5SOlga Kornievskaia struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); 182629ae7f9dSAnna Schumaker 1827e0639dc5SOlga Kornievskaia status = nfserrno(-ENOMEM); 1828e0639dc5SOlga Kornievskaia async_copy = kzalloc(sizeof(struct nfsd4_copy), GFP_KERNEL); 1829e0639dc5SOlga Kornievskaia if (!async_copy) 1830ce0887acSOlga Kornievskaia goto out_err; 1831ce0887acSOlga Kornievskaia if (!nfs4_init_copy_state(nn, copy)) 1832ce0887acSOlga Kornievskaia goto out_err; 1833e0639dc5SOlga Kornievskaia refcount_set(&async_copy->refcount, 1); 1834e739b120SOlga Kornievskaia memcpy(©->cp_res.cb_stateid, ©->cp_stateid.stid, 1835e739b120SOlga Kornievskaia sizeof(copy->cp_res.cb_stateid)); 1836eb162e17SChuck Lever dup_copy_fields(copy, async_copy); 1837e0639dc5SOlga Kornievskaia async_copy->copy_task = kthread_create(nfsd4_do_async_copy, 1838e0639dc5SOlga Kornievskaia async_copy, "%s", "copy thread"); 1839e0639dc5SOlga Kornievskaia if (IS_ERR(async_copy->copy_task)) 1840e0639dc5SOlga Kornievskaia goto out_err; 1841e0639dc5SOlga Kornievskaia spin_lock(&async_copy->cp_clp->async_lock); 1842e0639dc5SOlga Kornievskaia list_add(&async_copy->copies, 1843e0639dc5SOlga Kornievskaia &async_copy->cp_clp->async_copies); 1844e0639dc5SOlga Kornievskaia spin_unlock(&async_copy->cp_clp->async_lock); 1845e0639dc5SOlga Kornievskaia wake_up_process(async_copy->copy_task); 1846e0639dc5SOlga Kornievskaia status = nfs_ok; 1847ce0887acSOlga Kornievskaia } else { 1848e0639dc5SOlga Kornievskaia status = nfsd4_do_copy(copy, 1); 1849ce0887acSOlga Kornievskaia } 185029ae7f9dSAnna Schumaker out: 185129ae7f9dSAnna Schumaker return status; 1852e0639dc5SOlga Kornievskaia out_err: 185318f428d4SOlga Kornievskaia if (async_copy) 1854e0639dc5SOlga Kornievskaia cleanup_async_copy(async_copy); 1855ce0887acSOlga Kornievskaia status = nfserrno(-ENOMEM); 1856ce0887acSOlga Kornievskaia if (!copy->cp_intra) 1857ce0887acSOlga Kornievskaia nfsd4_interssc_disconnect(copy->ss_mnt); 1858e0639dc5SOlga Kornievskaia goto out; 1859e0639dc5SOlga Kornievskaia } 1860e0639dc5SOlga Kornievskaia 1861e0639dc5SOlga Kornievskaia struct nfsd4_copy * 1862e0639dc5SOlga Kornievskaia find_async_copy(struct nfs4_client *clp, stateid_t *stateid) 1863e0639dc5SOlga Kornievskaia { 1864e0639dc5SOlga Kornievskaia struct nfsd4_copy *copy; 1865e0639dc5SOlga Kornievskaia 1866e0639dc5SOlga Kornievskaia spin_lock(&clp->async_lock); 1867e0639dc5SOlga Kornievskaia list_for_each_entry(copy, &clp->async_copies, copies) { 1868ce0887acSOlga Kornievskaia if (memcmp(©->cp_stateid.stid, stateid, NFS4_STATEID_SIZE)) 1869e0639dc5SOlga Kornievskaia continue; 1870e0639dc5SOlga Kornievskaia refcount_inc(©->refcount); 1871e0639dc5SOlga Kornievskaia spin_unlock(&clp->async_lock); 1872e0639dc5SOlga Kornievskaia return copy; 1873e0639dc5SOlga Kornievskaia } 1874e0639dc5SOlga Kornievskaia spin_unlock(&clp->async_lock); 1875e0639dc5SOlga Kornievskaia return NULL; 187629ae7f9dSAnna Schumaker } 187729ae7f9dSAnna Schumaker 187829ae7f9dSAnna Schumaker static __be32 1879885e2bf3SOlga Kornievskaia nfsd4_offload_cancel(struct svc_rqst *rqstp, 1880885e2bf3SOlga Kornievskaia struct nfsd4_compound_state *cstate, 1881885e2bf3SOlga Kornievskaia union nfsd4_op_u *u) 1882885e2bf3SOlga Kornievskaia { 1883e0639dc5SOlga Kornievskaia struct nfsd4_offload_status *os = &u->offload_status; 1884e0639dc5SOlga Kornievskaia struct nfsd4_copy *copy; 1885e0639dc5SOlga Kornievskaia struct nfs4_client *clp = cstate->clp; 1886e0639dc5SOlga Kornievskaia 1887e0639dc5SOlga Kornievskaia copy = find_async_copy(clp, &os->stateid); 1888ce0887acSOlga Kornievskaia if (!copy) { 1889ce0887acSOlga Kornievskaia struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); 1890e0639dc5SOlga Kornievskaia 1891ce0887acSOlga Kornievskaia return manage_cpntf_state(nn, &os->stateid, clp, NULL); 1892ce0887acSOlga Kornievskaia } else 1893ce0887acSOlga Kornievskaia nfsd4_stop_copy(copy); 1894ce0887acSOlga Kornievskaia 1895ce0887acSOlga Kornievskaia return nfs_ok; 1896885e2bf3SOlga Kornievskaia } 1897885e2bf3SOlga Kornievskaia 1898885e2bf3SOlga Kornievskaia static __be32 189951911868SOlga Kornievskaia nfsd4_copy_notify(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 190051911868SOlga Kornievskaia union nfsd4_op_u *u) 190151911868SOlga Kornievskaia { 1902624322f1SOlga Kornievskaia struct nfsd4_copy_notify *cn = &u->copy_notify; 1903624322f1SOlga Kornievskaia __be32 status; 1904624322f1SOlga Kornievskaia struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); 1905624322f1SOlga Kornievskaia struct nfs4_stid *stid; 1906624322f1SOlga Kornievskaia struct nfs4_cpntf_state *cps; 1907624322f1SOlga Kornievskaia struct nfs4_client *clp = cstate->clp; 1908624322f1SOlga Kornievskaia 1909624322f1SOlga Kornievskaia status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh, 1910624322f1SOlga Kornievskaia &cn->cpn_src_stateid, RD_STATE, NULL, 1911624322f1SOlga Kornievskaia &stid); 1912624322f1SOlga Kornievskaia if (status) 1913624322f1SOlga Kornievskaia return status; 1914624322f1SOlga Kornievskaia 1915624322f1SOlga Kornievskaia cn->cpn_sec = nn->nfsd4_lease; 1916624322f1SOlga Kornievskaia cn->cpn_nsec = 0; 1917624322f1SOlga Kornievskaia 1918624322f1SOlga Kornievskaia status = nfserrno(-ENOMEM); 1919624322f1SOlga Kornievskaia cps = nfs4_alloc_init_cpntf_state(nn, stid); 1920624322f1SOlga Kornievskaia if (!cps) 1921624322f1SOlga Kornievskaia goto out; 1922624322f1SOlga Kornievskaia memcpy(&cn->cpn_cnr_stateid, &cps->cp_stateid.stid, sizeof(stateid_t)); 1923624322f1SOlga Kornievskaia memcpy(&cps->cp_p_stateid, &stid->sc_stateid, sizeof(stateid_t)); 1924624322f1SOlga Kornievskaia memcpy(&cps->cp_p_clid, &clp->cl_clientid, sizeof(clientid_t)); 1925624322f1SOlga Kornievskaia 1926624322f1SOlga Kornievskaia /* For now, only return one server address in cpn_src, the 1927624322f1SOlga Kornievskaia * address used by the client to connect to this server. 1928624322f1SOlga Kornievskaia */ 1929624322f1SOlga Kornievskaia cn->cpn_src.nl4_type = NL4_NETADDR; 1930624322f1SOlga Kornievskaia status = nfsd4_set_netaddr((struct sockaddr *)&rqstp->rq_daddr, 1931624322f1SOlga Kornievskaia &cn->cpn_src.u.nl4_addr); 1932624322f1SOlga Kornievskaia WARN_ON_ONCE(status); 1933624322f1SOlga Kornievskaia if (status) { 1934624322f1SOlga Kornievskaia nfs4_put_cpntf_state(nn, cps); 1935624322f1SOlga Kornievskaia goto out; 1936624322f1SOlga Kornievskaia } 1937624322f1SOlga Kornievskaia out: 1938624322f1SOlga Kornievskaia nfs4_put_stid(stid); 1939624322f1SOlga Kornievskaia return status; 194051911868SOlga Kornievskaia } 194151911868SOlga Kornievskaia 194251911868SOlga Kornievskaia static __be32 194395d871f0SAnna Schumaker nfsd4_fallocate(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 194495d871f0SAnna Schumaker struct nfsd4_fallocate *fallocate, int flags) 194595d871f0SAnna Schumaker { 19460d4d6720SJ. Bruce Fields __be32 status; 19475c4583b2SJeff Layton struct nfsd_file *nf; 194895d871f0SAnna Schumaker 1949aa0d6aedSAnna Schumaker status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh, 195095d871f0SAnna Schumaker &fallocate->falloc_stateid, 1951624322f1SOlga Kornievskaia WR_STATE, &nf, NULL); 195295d871f0SAnna Schumaker if (status != nfs_ok) { 195395d871f0SAnna Schumaker dprintk("NFSD: nfsd4_fallocate: couldn't process stateid!\n"); 195495d871f0SAnna Schumaker return status; 195595d871f0SAnna Schumaker } 195695d871f0SAnna Schumaker 19575c4583b2SJeff Layton status = nfsd4_vfs_fallocate(rqstp, &cstate->current_fh, nf->nf_file, 195895d871f0SAnna Schumaker fallocate->falloc_offset, 195995d871f0SAnna Schumaker fallocate->falloc_length, 196095d871f0SAnna Schumaker flags); 19615c4583b2SJeff Layton nfsd_file_put(nf); 196295d871f0SAnna Schumaker return status; 196395d871f0SAnna Schumaker } 19646308bc98SOlga Kornievskaia static __be32 19656308bc98SOlga Kornievskaia nfsd4_offload_status(struct svc_rqst *rqstp, 19666308bc98SOlga Kornievskaia struct nfsd4_compound_state *cstate, 19676308bc98SOlga Kornievskaia union nfsd4_op_u *u) 19686308bc98SOlga Kornievskaia { 1969e0639dc5SOlga Kornievskaia struct nfsd4_offload_status *os = &u->offload_status; 1970e0639dc5SOlga Kornievskaia __be32 status = 0; 1971e0639dc5SOlga Kornievskaia struct nfsd4_copy *copy; 1972e0639dc5SOlga Kornievskaia struct nfs4_client *clp = cstate->clp; 1973e0639dc5SOlga Kornievskaia 1974e0639dc5SOlga Kornievskaia copy = find_async_copy(clp, &os->stateid); 1975e0639dc5SOlga Kornievskaia if (copy) { 1976e0639dc5SOlga Kornievskaia os->count = copy->cp_res.wr_bytes_written; 1977e0639dc5SOlga Kornievskaia nfs4_put_copy(copy); 1978e0639dc5SOlga Kornievskaia } else 1979e0639dc5SOlga Kornievskaia status = nfserr_bad_stateid; 1980e0639dc5SOlga Kornievskaia 1981e0639dc5SOlga Kornievskaia return status; 19826308bc98SOlga Kornievskaia } 198395d871f0SAnna Schumaker 198495d871f0SAnna Schumaker static __be32 198595d871f0SAnna Schumaker nfsd4_allocate(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 1986eb69853dSChristoph Hellwig union nfsd4_op_u *u) 198795d871f0SAnna Schumaker { 1988eb69853dSChristoph Hellwig return nfsd4_fallocate(rqstp, cstate, &u->allocate, 0); 198995d871f0SAnna Schumaker } 199095d871f0SAnna Schumaker 199195d871f0SAnna Schumaker static __be32 1992b0cb9085SAnna Schumaker nfsd4_deallocate(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 1993eb69853dSChristoph Hellwig union nfsd4_op_u *u) 1994b0cb9085SAnna Schumaker { 1995eb69853dSChristoph Hellwig return nfsd4_fallocate(rqstp, cstate, &u->deallocate, 1996b0cb9085SAnna Schumaker FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE); 1997b0cb9085SAnna Schumaker } 1998b0cb9085SAnna Schumaker 1999b0cb9085SAnna Schumaker static __be32 200024bab491SAnna Schumaker nfsd4_seek(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 2001eb69853dSChristoph Hellwig union nfsd4_op_u *u) 200224bab491SAnna Schumaker { 2003eb69853dSChristoph Hellwig struct nfsd4_seek *seek = &u->seek; 200424bab491SAnna Schumaker int whence; 200524bab491SAnna Schumaker __be32 status; 20065c4583b2SJeff Layton struct nfsd_file *nf; 200724bab491SAnna Schumaker 2008aa0d6aedSAnna Schumaker status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh, 200924bab491SAnna Schumaker &seek->seek_stateid, 2010624322f1SOlga Kornievskaia RD_STATE, &nf, NULL); 201124bab491SAnna Schumaker if (status) { 201224bab491SAnna Schumaker dprintk("NFSD: nfsd4_seek: couldn't process stateid!\n"); 201324bab491SAnna Schumaker return status; 201424bab491SAnna Schumaker } 201524bab491SAnna Schumaker 201624bab491SAnna Schumaker switch (seek->seek_whence) { 201724bab491SAnna Schumaker case NFS4_CONTENT_DATA: 201824bab491SAnna Schumaker whence = SEEK_DATA; 201924bab491SAnna Schumaker break; 202024bab491SAnna Schumaker case NFS4_CONTENT_HOLE: 202124bab491SAnna Schumaker whence = SEEK_HOLE; 202224bab491SAnna Schumaker break; 202324bab491SAnna Schumaker default: 202424bab491SAnna Schumaker status = nfserr_union_notsupp; 202524bab491SAnna Schumaker goto out; 202624bab491SAnna Schumaker } 202724bab491SAnna Schumaker 202824bab491SAnna Schumaker /* 202924bab491SAnna Schumaker * Note: This call does change file->f_pos, but nothing in NFSD 203024bab491SAnna Schumaker * should ever file->f_pos. 203124bab491SAnna Schumaker */ 20325c4583b2SJeff Layton seek->seek_pos = vfs_llseek(nf->nf_file, seek->seek_offset, whence); 203324bab491SAnna Schumaker if (seek->seek_pos < 0) 203424bab491SAnna Schumaker status = nfserrno(seek->seek_pos); 20355c4583b2SJeff Layton else if (seek->seek_pos >= i_size_read(file_inode(nf->nf_file))) 203624bab491SAnna Schumaker seek->seek_eof = true; 203724bab491SAnna Schumaker 203824bab491SAnna Schumaker out: 20395c4583b2SJeff Layton nfsd_file_put(nf); 204024bab491SAnna Schumaker return status; 204124bab491SAnna Schumaker } 204224bab491SAnna Schumaker 20431da177e4SLinus Torvalds /* This routine never returns NFS_OK! If there are no other errors, it 20441da177e4SLinus Torvalds * will return NFSERR_SAME or NFSERR_NOT_SAME depending on whether the 20451da177e4SLinus Torvalds * attributes matched. VERIFY is implemented by mapping NFSERR_SAME 20461da177e4SLinus Torvalds * to NFS_OK after the call; NVERIFY by mapping NFSERR_NOT_SAME to NFS_OK. 20471da177e4SLinus Torvalds */ 2048b37ad28bSAl Viro static __be32 2049c954e2a5SJ.Bruce Fields _nfsd4_verify(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 2050ca364317SJ.Bruce Fields struct nfsd4_verify *verify) 20511da177e4SLinus Torvalds { 20522ebbc012SAl Viro __be32 *buf, *p; 20531da177e4SLinus Torvalds int count; 2054b37ad28bSAl Viro __be32 status; 20551da177e4SLinus Torvalds 20568837abcaSMiklos Szeredi status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP); 20571da177e4SLinus Torvalds if (status) 20581da177e4SLinus Torvalds return status; 20591da177e4SLinus Torvalds 20603c8e0316SYu Zhiguo status = check_attr_support(rqstp, cstate, verify->ve_bmval, NULL); 20613c8e0316SYu Zhiguo if (status) 20623c8e0316SYu Zhiguo return status; 20633c8e0316SYu Zhiguo 20641da177e4SLinus Torvalds if ((verify->ve_bmval[0] & FATTR4_WORD0_RDATTR_ERROR) 20651da177e4SLinus Torvalds || (verify->ve_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1)) 20661da177e4SLinus Torvalds return nfserr_inval; 20671da177e4SLinus Torvalds if (verify->ve_attrlen & 3) 20681da177e4SLinus Torvalds return nfserr_inval; 20691da177e4SLinus Torvalds 20701da177e4SLinus Torvalds /* count in words: 20711da177e4SLinus Torvalds * bitmap_len(1) + bitmap(2) + attr_len(1) = 4 20721da177e4SLinus Torvalds */ 20731da177e4SLinus Torvalds count = 4 + (verify->ve_attrlen >> 2); 20741da177e4SLinus Torvalds buf = kmalloc(count << 2, GFP_KERNEL); 20751da177e4SLinus Torvalds if (!buf) 20763e772463SJ. Bruce Fields return nfserr_jukebox; 20771da177e4SLinus Torvalds 207884822d0bSJ. Bruce Fields p = buf; 2079d5184658SJ. Bruce Fields status = nfsd4_encode_fattr_to_buf(&p, count, &cstate->current_fh, 2080ca364317SJ.Bruce Fields cstate->current_fh.fh_export, 2081d5184658SJ. Bruce Fields cstate->current_fh.fh_dentry, 2082d5184658SJ. Bruce Fields verify->ve_bmval, 2083406a7ea9SFrank Filz rqstp, 0); 208441ae6e71SJ. Bruce Fields /* 208541ae6e71SJ. Bruce Fields * If nfsd4_encode_fattr() ran out of space, assume that's because 208641ae6e71SJ. Bruce Fields * the attributes are longer (hence different) than those given: 208741ae6e71SJ. Bruce Fields */ 208884822d0bSJ. Bruce Fields if (status == nfserr_resource) 20891da177e4SLinus Torvalds status = nfserr_not_same; 20901da177e4SLinus Torvalds if (status) 20911da177e4SLinus Torvalds goto out_kfree; 20921da177e4SLinus Torvalds 209395ec28cdSBenny Halevy /* skip bitmap */ 209495ec28cdSBenny Halevy p = buf + 1 + ntohl(buf[0]); 20951da177e4SLinus Torvalds status = nfserr_not_same; 20961da177e4SLinus Torvalds if (ntohl(*p++) != verify->ve_attrlen) 20971da177e4SLinus Torvalds goto out_kfree; 20981da177e4SLinus Torvalds if (!memcmp(p, verify->ve_attrval, verify->ve_attrlen)) 20991da177e4SLinus Torvalds status = nfserr_same; 21001da177e4SLinus Torvalds 21011da177e4SLinus Torvalds out_kfree: 21021da177e4SLinus Torvalds kfree(buf); 21031da177e4SLinus Torvalds return status; 21041da177e4SLinus Torvalds } 21051da177e4SLinus Torvalds 2106c954e2a5SJ.Bruce Fields static __be32 2107c954e2a5SJ.Bruce Fields nfsd4_nverify(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 2108eb69853dSChristoph Hellwig union nfsd4_op_u *u) 2109c954e2a5SJ.Bruce Fields { 2110c954e2a5SJ.Bruce Fields __be32 status; 2111c954e2a5SJ.Bruce Fields 2112eb69853dSChristoph Hellwig status = _nfsd4_verify(rqstp, cstate, &u->verify); 2113c954e2a5SJ.Bruce Fields return status == nfserr_not_same ? nfs_ok : status; 2114c954e2a5SJ.Bruce Fields } 2115c954e2a5SJ.Bruce Fields 2116c954e2a5SJ.Bruce Fields static __be32 2117c954e2a5SJ.Bruce Fields nfsd4_verify(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 2118eb69853dSChristoph Hellwig union nfsd4_op_u *u) 2119c954e2a5SJ.Bruce Fields { 2120c954e2a5SJ.Bruce Fields __be32 status; 2121c954e2a5SJ.Bruce Fields 2122eb69853dSChristoph Hellwig status = _nfsd4_verify(rqstp, cstate, &u->nverify); 2123c954e2a5SJ.Bruce Fields return status == nfserr_same ? nfs_ok : status; 2124c954e2a5SJ.Bruce Fields } 2125c954e2a5SJ.Bruce Fields 21269cf514ccSChristoph Hellwig #ifdef CONFIG_NFSD_PNFS 21279cf514ccSChristoph Hellwig static const struct nfsd4_layout_ops * 21289cf514ccSChristoph Hellwig nfsd4_layout_verify(struct svc_export *exp, unsigned int layout_type) 21299cf514ccSChristoph Hellwig { 21308a4c3926SJeff Layton if (!exp->ex_layout_types) { 21319cf514ccSChristoph Hellwig dprintk("%s: export does not support pNFS\n", __func__); 21329cf514ccSChristoph Hellwig return NULL; 21339cf514ccSChristoph Hellwig } 21349cf514ccSChristoph Hellwig 2135b550a32eSAri Kauppi if (layout_type >= LAYOUT_TYPE_MAX || 2136b550a32eSAri Kauppi !(exp->ex_layout_types & (1 << layout_type))) { 21379cf514ccSChristoph Hellwig dprintk("%s: layout type %d not supported\n", 21389cf514ccSChristoph Hellwig __func__, layout_type); 21399cf514ccSChristoph Hellwig return NULL; 21409cf514ccSChristoph Hellwig } 21419cf514ccSChristoph Hellwig 21429cf514ccSChristoph Hellwig return nfsd4_layout_ops[layout_type]; 21439cf514ccSChristoph Hellwig } 21449cf514ccSChristoph Hellwig 21459cf514ccSChristoph Hellwig static __be32 21469cf514ccSChristoph Hellwig nfsd4_getdeviceinfo(struct svc_rqst *rqstp, 2147eb69853dSChristoph Hellwig struct nfsd4_compound_state *cstate, union nfsd4_op_u *u) 21489cf514ccSChristoph Hellwig { 2149eb69853dSChristoph Hellwig struct nfsd4_getdeviceinfo *gdp = &u->getdeviceinfo; 21509cf514ccSChristoph Hellwig const struct nfsd4_layout_ops *ops; 21519cf514ccSChristoph Hellwig struct nfsd4_deviceid_map *map; 21529cf514ccSChristoph Hellwig struct svc_export *exp; 21539cf514ccSChristoph Hellwig __be32 nfserr; 21549cf514ccSChristoph Hellwig 21559cf514ccSChristoph Hellwig dprintk("%s: layout_type %u dev_id [0x%llx:0x%x] maxcnt %u\n", 21569cf514ccSChristoph Hellwig __func__, 21579cf514ccSChristoph Hellwig gdp->gd_layout_type, 21589cf514ccSChristoph Hellwig gdp->gd_devid.fsid_idx, gdp->gd_devid.generation, 21599cf514ccSChristoph Hellwig gdp->gd_maxcount); 21609cf514ccSChristoph Hellwig 21619cf514ccSChristoph Hellwig map = nfsd4_find_devid_map(gdp->gd_devid.fsid_idx); 21629cf514ccSChristoph Hellwig if (!map) { 21639cf514ccSChristoph Hellwig dprintk("%s: couldn't find device ID to export mapping!\n", 21649cf514ccSChristoph Hellwig __func__); 21659cf514ccSChristoph Hellwig return nfserr_noent; 21669cf514ccSChristoph Hellwig } 21679cf514ccSChristoph Hellwig 21689cf514ccSChristoph Hellwig exp = rqst_exp_find(rqstp, map->fsid_type, map->fsid); 21699cf514ccSChristoph Hellwig if (IS_ERR(exp)) { 21709cf514ccSChristoph Hellwig dprintk("%s: could not find device id\n", __func__); 21719cf514ccSChristoph Hellwig return nfserr_noent; 21729cf514ccSChristoph Hellwig } 21739cf514ccSChristoph Hellwig 21749cf514ccSChristoph Hellwig nfserr = nfserr_layoutunavailable; 21759cf514ccSChristoph Hellwig ops = nfsd4_layout_verify(exp, gdp->gd_layout_type); 21769cf514ccSChristoph Hellwig if (!ops) 21779cf514ccSChristoph Hellwig goto out; 21789cf514ccSChristoph Hellwig 21799cf514ccSChristoph Hellwig nfserr = nfs_ok; 2180f99d4fbdSChristoph Hellwig if (gdp->gd_maxcount != 0) { 2181f99d4fbdSChristoph Hellwig nfserr = ops->proc_getdeviceinfo(exp->ex_path.mnt->mnt_sb, 2182ec59659bSJ. Bruce Fields rqstp, cstate->clp, gdp); 2183f99d4fbdSChristoph Hellwig } 21849cf514ccSChristoph Hellwig 21859cf514ccSChristoph Hellwig gdp->gd_notify_types &= ops->notify_types; 21869cf514ccSChristoph Hellwig out: 2187a1420384SKinglong Mee exp_put(exp); 21889cf514ccSChristoph Hellwig return nfserr; 21899cf514ccSChristoph Hellwig } 21909cf514ccSChristoph Hellwig 219134b1744cSJ. Bruce Fields static void 219234b1744cSJ. Bruce Fields nfsd4_getdeviceinfo_release(union nfsd4_op_u *u) 219334b1744cSJ. Bruce Fields { 219434b1744cSJ. Bruce Fields kfree(u->getdeviceinfo.gd_device); 219534b1744cSJ. Bruce Fields } 219634b1744cSJ. Bruce Fields 21979cf514ccSChristoph Hellwig static __be32 21989cf514ccSChristoph Hellwig nfsd4_layoutget(struct svc_rqst *rqstp, 2199eb69853dSChristoph Hellwig struct nfsd4_compound_state *cstate, union nfsd4_op_u *u) 22009cf514ccSChristoph Hellwig { 2201eb69853dSChristoph Hellwig struct nfsd4_layoutget *lgp = &u->layoutget; 22029cf514ccSChristoph Hellwig struct svc_fh *current_fh = &cstate->current_fh; 22039cf514ccSChristoph Hellwig const struct nfsd4_layout_ops *ops; 22049cf514ccSChristoph Hellwig struct nfs4_layout_stateid *ls; 22059cf514ccSChristoph Hellwig __be32 nfserr; 220666282ec1SBenjamin Coddington int accmode = NFSD_MAY_READ_IF_EXEC; 22079cf514ccSChristoph Hellwig 22089cf514ccSChristoph Hellwig switch (lgp->lg_seg.iomode) { 22099cf514ccSChristoph Hellwig case IOMODE_READ: 221066282ec1SBenjamin Coddington accmode |= NFSD_MAY_READ; 22119cf514ccSChristoph Hellwig break; 22129cf514ccSChristoph Hellwig case IOMODE_RW: 221366282ec1SBenjamin Coddington accmode |= NFSD_MAY_READ | NFSD_MAY_WRITE; 22149cf514ccSChristoph Hellwig break; 22159cf514ccSChristoph Hellwig default: 22169cf514ccSChristoph Hellwig dprintk("%s: invalid iomode %d\n", 22179cf514ccSChristoph Hellwig __func__, lgp->lg_seg.iomode); 22189cf514ccSChristoph Hellwig nfserr = nfserr_badiomode; 22199cf514ccSChristoph Hellwig goto out; 22209cf514ccSChristoph Hellwig } 22219cf514ccSChristoph Hellwig 22229cf514ccSChristoph Hellwig nfserr = fh_verify(rqstp, current_fh, 0, accmode); 22239cf514ccSChristoph Hellwig if (nfserr) 22249cf514ccSChristoph Hellwig goto out; 22259cf514ccSChristoph Hellwig 22269cf514ccSChristoph Hellwig nfserr = nfserr_layoutunavailable; 22279cf514ccSChristoph Hellwig ops = nfsd4_layout_verify(current_fh->fh_export, lgp->lg_layout_type); 22289cf514ccSChristoph Hellwig if (!ops) 22299cf514ccSChristoph Hellwig goto out; 22309cf514ccSChristoph Hellwig 22319cf514ccSChristoph Hellwig /* 22329cf514ccSChristoph Hellwig * Verify minlength and range as per RFC5661: 22339cf514ccSChristoph Hellwig * o If loga_length is less than loga_minlength, 22349cf514ccSChristoph Hellwig * the metadata server MUST return NFS4ERR_INVAL. 22359cf514ccSChristoph Hellwig * o If the sum of loga_offset and loga_minlength exceeds 22369cf514ccSChristoph Hellwig * NFS4_UINT64_MAX, and loga_minlength is not 22379cf514ccSChristoph Hellwig * NFS4_UINT64_MAX, the error NFS4ERR_INVAL MUST result. 22389cf514ccSChristoph Hellwig * o If the sum of loga_offset and loga_length exceeds 22399cf514ccSChristoph Hellwig * NFS4_UINT64_MAX, and loga_length is not NFS4_UINT64_MAX, 22409cf514ccSChristoph Hellwig * the error NFS4ERR_INVAL MUST result. 22419cf514ccSChristoph Hellwig */ 22429cf514ccSChristoph Hellwig nfserr = nfserr_inval; 22439cf514ccSChristoph Hellwig if (lgp->lg_seg.length < lgp->lg_minlength || 22449cf514ccSChristoph Hellwig (lgp->lg_minlength != NFS4_MAX_UINT64 && 22459cf514ccSChristoph Hellwig lgp->lg_minlength > NFS4_MAX_UINT64 - lgp->lg_seg.offset) || 22469cf514ccSChristoph Hellwig (lgp->lg_seg.length != NFS4_MAX_UINT64 && 22479cf514ccSChristoph Hellwig lgp->lg_seg.length > NFS4_MAX_UINT64 - lgp->lg_seg.offset)) 22489cf514ccSChristoph Hellwig goto out; 22499cf514ccSChristoph Hellwig if (lgp->lg_seg.length == 0) 22509cf514ccSChristoph Hellwig goto out; 22519cf514ccSChristoph Hellwig 22529cf514ccSChristoph Hellwig nfserr = nfsd4_preprocess_layout_stateid(rqstp, cstate, &lgp->lg_sid, 22539cf514ccSChristoph Hellwig true, lgp->lg_layout_type, &ls); 225431ef83dcSChristoph Hellwig if (nfserr) { 2255f394b62bSChuck Lever trace_nfsd_layout_get_lookup_fail(&lgp->lg_sid); 22569cf514ccSChristoph Hellwig goto out; 225731ef83dcSChristoph Hellwig } 22589cf514ccSChristoph Hellwig 2259c5c707f9SChristoph Hellwig nfserr = nfserr_recallconflict; 2260c5c707f9SChristoph Hellwig if (atomic_read(&ls->ls_stid.sc_file->fi_lo_recalls)) 2261c5c707f9SChristoph Hellwig goto out_put_stid; 2262c5c707f9SChristoph Hellwig 22632b0143b5SDavid Howells nfserr = ops->proc_layoutget(d_inode(current_fh->fh_dentry), 22649cf514ccSChristoph Hellwig current_fh, lgp); 22659cf514ccSChristoph Hellwig if (nfserr) 22669cf514ccSChristoph Hellwig goto out_put_stid; 22679cf514ccSChristoph Hellwig 22689cf514ccSChristoph Hellwig nfserr = nfsd4_insert_layout(lgp, ls); 22699cf514ccSChristoph Hellwig 22709cf514ccSChristoph Hellwig out_put_stid: 2271cc8a5532SJeff Layton mutex_unlock(&ls->ls_mutex); 22729cf514ccSChristoph Hellwig nfs4_put_stid(&ls->ls_stid); 22739cf514ccSChristoph Hellwig out: 22749cf514ccSChristoph Hellwig return nfserr; 22759cf514ccSChristoph Hellwig } 22769cf514ccSChristoph Hellwig 227734b1744cSJ. Bruce Fields static void 227834b1744cSJ. Bruce Fields nfsd4_layoutget_release(union nfsd4_op_u *u) 227934b1744cSJ. Bruce Fields { 228034b1744cSJ. Bruce Fields kfree(u->layoutget.lg_content); 228134b1744cSJ. Bruce Fields } 228234b1744cSJ. Bruce Fields 22839cf514ccSChristoph Hellwig static __be32 22849cf514ccSChristoph Hellwig nfsd4_layoutcommit(struct svc_rqst *rqstp, 2285eb69853dSChristoph Hellwig struct nfsd4_compound_state *cstate, union nfsd4_op_u *u) 22869cf514ccSChristoph Hellwig { 2287eb69853dSChristoph Hellwig struct nfsd4_layoutcommit *lcp = &u->layoutcommit; 22889cf514ccSChristoph Hellwig const struct nfsd4_layout_seg *seg = &lcp->lc_seg; 22899cf514ccSChristoph Hellwig struct svc_fh *current_fh = &cstate->current_fh; 22909cf514ccSChristoph Hellwig const struct nfsd4_layout_ops *ops; 22919cf514ccSChristoph Hellwig loff_t new_size = lcp->lc_last_wr + 1; 22929cf514ccSChristoph Hellwig struct inode *inode; 22939cf514ccSChristoph Hellwig struct nfs4_layout_stateid *ls; 22949cf514ccSChristoph Hellwig __be32 nfserr; 22959cf514ccSChristoph Hellwig 22969cf514ccSChristoph Hellwig nfserr = fh_verify(rqstp, current_fh, 0, NFSD_MAY_WRITE); 22979cf514ccSChristoph Hellwig if (nfserr) 22989cf514ccSChristoph Hellwig goto out; 22999cf514ccSChristoph Hellwig 23009cf514ccSChristoph Hellwig nfserr = nfserr_layoutunavailable; 23019cf514ccSChristoph Hellwig ops = nfsd4_layout_verify(current_fh->fh_export, lcp->lc_layout_type); 23029cf514ccSChristoph Hellwig if (!ops) 23039cf514ccSChristoph Hellwig goto out; 23042b0143b5SDavid Howells inode = d_inode(current_fh->fh_dentry); 23059cf514ccSChristoph Hellwig 23069cf514ccSChristoph Hellwig nfserr = nfserr_inval; 23079cf514ccSChristoph Hellwig if (new_size <= seg->offset) { 23089cf514ccSChristoph Hellwig dprintk("pnfsd: last write before layout segment\n"); 23099cf514ccSChristoph Hellwig goto out; 23109cf514ccSChristoph Hellwig } 23119cf514ccSChristoph Hellwig if (new_size > seg->offset + seg->length) { 23129cf514ccSChristoph Hellwig dprintk("pnfsd: last write beyond layout segment\n"); 23139cf514ccSChristoph Hellwig goto out; 23149cf514ccSChristoph Hellwig } 23159cf514ccSChristoph Hellwig if (!lcp->lc_newoffset && new_size > i_size_read(inode)) { 23169cf514ccSChristoph Hellwig dprintk("pnfsd: layoutcommit beyond EOF\n"); 23179cf514ccSChristoph Hellwig goto out; 23189cf514ccSChristoph Hellwig } 23199cf514ccSChristoph Hellwig 23209cf514ccSChristoph Hellwig nfserr = nfsd4_preprocess_layout_stateid(rqstp, cstate, &lcp->lc_sid, 23219cf514ccSChristoph Hellwig false, lcp->lc_layout_type, 23229cf514ccSChristoph Hellwig &ls); 23239cf514ccSChristoph Hellwig if (nfserr) { 2324f394b62bSChuck Lever trace_nfsd_layout_commit_lookup_fail(&lcp->lc_sid); 23259cf514ccSChristoph Hellwig /* fixup error code as per RFC5661 */ 23269cf514ccSChristoph Hellwig if (nfserr == nfserr_bad_stateid) 23279cf514ccSChristoph Hellwig nfserr = nfserr_badlayout; 23289cf514ccSChristoph Hellwig goto out; 23299cf514ccSChristoph Hellwig } 23309cf514ccSChristoph Hellwig 2331cc8a5532SJeff Layton /* LAYOUTCOMMIT does not require any serialization */ 2332cc8a5532SJeff Layton mutex_unlock(&ls->ls_mutex); 2333cc8a5532SJeff Layton 23349cf514ccSChristoph Hellwig if (new_size > i_size_read(inode)) { 23359cf514ccSChristoph Hellwig lcp->lc_size_chg = 1; 23369cf514ccSChristoph Hellwig lcp->lc_newsize = new_size; 23379cf514ccSChristoph Hellwig } else { 23389cf514ccSChristoph Hellwig lcp->lc_size_chg = 0; 23399cf514ccSChristoph Hellwig } 23409cf514ccSChristoph Hellwig 2341d8398fc1SKinglong Mee nfserr = ops->proc_layoutcommit(inode, lcp); 23429cf514ccSChristoph Hellwig nfs4_put_stid(&ls->ls_stid); 23439cf514ccSChristoph Hellwig out: 23449cf514ccSChristoph Hellwig return nfserr; 23459cf514ccSChristoph Hellwig } 23469cf514ccSChristoph Hellwig 23479cf514ccSChristoph Hellwig static __be32 23489cf514ccSChristoph Hellwig nfsd4_layoutreturn(struct svc_rqst *rqstp, 2349eb69853dSChristoph Hellwig struct nfsd4_compound_state *cstate, union nfsd4_op_u *u) 23509cf514ccSChristoph Hellwig { 2351eb69853dSChristoph Hellwig struct nfsd4_layoutreturn *lrp = &u->layoutreturn; 23529cf514ccSChristoph Hellwig struct svc_fh *current_fh = &cstate->current_fh; 23539cf514ccSChristoph Hellwig __be32 nfserr; 23549cf514ccSChristoph Hellwig 23559cf514ccSChristoph Hellwig nfserr = fh_verify(rqstp, current_fh, 0, NFSD_MAY_NOP); 23569cf514ccSChristoph Hellwig if (nfserr) 23579cf514ccSChristoph Hellwig goto out; 23589cf514ccSChristoph Hellwig 23599cf514ccSChristoph Hellwig nfserr = nfserr_layoutunavailable; 23609cf514ccSChristoph Hellwig if (!nfsd4_layout_verify(current_fh->fh_export, lrp->lr_layout_type)) 23619cf514ccSChristoph Hellwig goto out; 23629cf514ccSChristoph Hellwig 23639cf514ccSChristoph Hellwig switch (lrp->lr_seg.iomode) { 23649cf514ccSChristoph Hellwig case IOMODE_READ: 23659cf514ccSChristoph Hellwig case IOMODE_RW: 23669cf514ccSChristoph Hellwig case IOMODE_ANY: 23679cf514ccSChristoph Hellwig break; 23689cf514ccSChristoph Hellwig default: 23699cf514ccSChristoph Hellwig dprintk("%s: invalid iomode %d\n", __func__, 23709cf514ccSChristoph Hellwig lrp->lr_seg.iomode); 23719cf514ccSChristoph Hellwig nfserr = nfserr_inval; 23729cf514ccSChristoph Hellwig goto out; 23739cf514ccSChristoph Hellwig } 23749cf514ccSChristoph Hellwig 23759cf514ccSChristoph Hellwig switch (lrp->lr_return_type) { 23769cf514ccSChristoph Hellwig case RETURN_FILE: 23779cf514ccSChristoph Hellwig nfserr = nfsd4_return_file_layouts(rqstp, cstate, lrp); 23789cf514ccSChristoph Hellwig break; 23799cf514ccSChristoph Hellwig case RETURN_FSID: 23809cf514ccSChristoph Hellwig case RETURN_ALL: 23819cf514ccSChristoph Hellwig nfserr = nfsd4_return_client_layouts(rqstp, cstate, lrp); 23829cf514ccSChristoph Hellwig break; 23839cf514ccSChristoph Hellwig default: 23849cf514ccSChristoph Hellwig dprintk("%s: invalid return_type %d\n", __func__, 23859cf514ccSChristoph Hellwig lrp->lr_return_type); 23869cf514ccSChristoph Hellwig nfserr = nfserr_inval; 23879cf514ccSChristoph Hellwig break; 23889cf514ccSChristoph Hellwig } 23899cf514ccSChristoph Hellwig out: 23909cf514ccSChristoph Hellwig return nfserr; 23919cf514ccSChristoph Hellwig } 23929cf514ccSChristoph Hellwig #endif /* CONFIG_NFSD_PNFS */ 23939cf514ccSChristoph Hellwig 239423e50fe3SFrank van der Linden static __be32 239523e50fe3SFrank van der Linden nfsd4_getxattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 239623e50fe3SFrank van der Linden union nfsd4_op_u *u) 239723e50fe3SFrank van der Linden { 239823e50fe3SFrank van der Linden struct nfsd4_getxattr *getxattr = &u->getxattr; 239923e50fe3SFrank van der Linden 240023e50fe3SFrank van der Linden return nfsd_getxattr(rqstp, &cstate->current_fh, 240123e50fe3SFrank van der Linden getxattr->getxa_name, &getxattr->getxa_buf, 240223e50fe3SFrank van der Linden &getxattr->getxa_len); 240323e50fe3SFrank van der Linden } 240423e50fe3SFrank van der Linden 240523e50fe3SFrank van der Linden static __be32 240623e50fe3SFrank van der Linden nfsd4_setxattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 240723e50fe3SFrank van der Linden union nfsd4_op_u *u) 240823e50fe3SFrank van der Linden { 240923e50fe3SFrank van der Linden struct nfsd4_setxattr *setxattr = &u->setxattr; 241023e50fe3SFrank van der Linden __be32 ret; 241123e50fe3SFrank van der Linden 241223e50fe3SFrank van der Linden if (opens_in_grace(SVC_NET(rqstp))) 241323e50fe3SFrank van der Linden return nfserr_grace; 241423e50fe3SFrank van der Linden 241523e50fe3SFrank van der Linden ret = nfsd_setxattr(rqstp, &cstate->current_fh, setxattr->setxa_name, 241623e50fe3SFrank van der Linden setxattr->setxa_buf, setxattr->setxa_len, 241723e50fe3SFrank van der Linden setxattr->setxa_flags); 241823e50fe3SFrank van der Linden 241923e50fe3SFrank van der Linden if (!ret) 242023e50fe3SFrank van der Linden set_change_info(&setxattr->setxa_cinfo, &cstate->current_fh); 242123e50fe3SFrank van der Linden 242223e50fe3SFrank van der Linden return ret; 242323e50fe3SFrank van der Linden } 242423e50fe3SFrank van der Linden 242523e50fe3SFrank van der Linden static __be32 242623e50fe3SFrank van der Linden nfsd4_listxattrs(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 242723e50fe3SFrank van der Linden union nfsd4_op_u *u) 242823e50fe3SFrank van der Linden { 242923e50fe3SFrank van der Linden /* 243023e50fe3SFrank van der Linden * Get the entire list, then copy out only the user attributes 243123e50fe3SFrank van der Linden * in the encode function. 243223e50fe3SFrank van der Linden */ 243323e50fe3SFrank van der Linden return nfsd_listxattr(rqstp, &cstate->current_fh, 243423e50fe3SFrank van der Linden &u->listxattrs.lsxa_buf, &u->listxattrs.lsxa_len); 243523e50fe3SFrank van der Linden } 243623e50fe3SFrank van der Linden 243723e50fe3SFrank van der Linden static __be32 243823e50fe3SFrank van der Linden nfsd4_removexattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 243923e50fe3SFrank van der Linden union nfsd4_op_u *u) 244023e50fe3SFrank van der Linden { 244123e50fe3SFrank van der Linden struct nfsd4_removexattr *removexattr = &u->removexattr; 244223e50fe3SFrank van der Linden __be32 ret; 244323e50fe3SFrank van der Linden 244423e50fe3SFrank van der Linden if (opens_in_grace(SVC_NET(rqstp))) 244523e50fe3SFrank van der Linden return nfserr_grace; 244623e50fe3SFrank van der Linden 244723e50fe3SFrank van der Linden ret = nfsd_removexattr(rqstp, &cstate->current_fh, 244823e50fe3SFrank van der Linden removexattr->rmxa_name); 244923e50fe3SFrank van der Linden 245023e50fe3SFrank van der Linden if (!ret) 245123e50fe3SFrank van der Linden set_change_info(&removexattr->rmxa_cinfo, &cstate->current_fh); 245223e50fe3SFrank van der Linden 245323e50fe3SFrank van der Linden return ret; 245423e50fe3SFrank van der Linden } 245523e50fe3SFrank van der Linden 24561da177e4SLinus Torvalds /* 24571da177e4SLinus Torvalds * NULL call. 24581da177e4SLinus Torvalds */ 24597111c66eSAl Viro static __be32 2460a6beb732SChristoph Hellwig nfsd4_proc_null(struct svc_rqst *rqstp) 24611da177e4SLinus Torvalds { 2462cc028a10SChuck Lever return rpc_success; 24631da177e4SLinus Torvalds } 24641da177e4SLinus Torvalds 2465e2b20950SShankar Anand static inline void nfsd4_increment_op_stats(u32 opnum) 2466e2b20950SShankar Anand { 2467e2b20950SShankar Anand if (opnum >= FIRST_NFS4_OP && opnum <= LAST_NFS4_OP) 2468e567b98cSAmir Goldstein percpu_counter_inc(&nfsdstats.counter[NFSD_STATS_NFS4_OP(opnum)]); 2469e2b20950SShankar Anand } 2470e2b20950SShankar Anand 2471bb2a8b0cSChristoph Hellwig static const struct nfsd4_operation nfsd4_ops[]; 2472b591480bSJ.Bruce Fields 2473f1c7f79bSAdrian Bunk static const char *nfsd4_op_name(unsigned opnum); 2474b001a1b6SBenny Halevy 24751da177e4SLinus Torvalds /* 247657716355SJ. Bruce Fields * Enforce NFSv4.1 COMPOUND ordering rules: 2477f9bb94c4SAndy Adamson * 247857716355SJ. Bruce Fields * Also note, enforced elsewhere: 247957716355SJ. Bruce Fields * - SEQUENCE other than as first op results in 248057716355SJ. Bruce Fields * NFS4ERR_SEQUENCE_POS. (Enforced in nfsd4_sequence().) 24811d1bc8f2SJ. Bruce Fields * - BIND_CONN_TO_SESSION must be the only op in its compound. 24821d1bc8f2SJ. Bruce Fields * (Enforced in nfsd4_bind_conn_to_session().) 248357716355SJ. Bruce Fields * - DESTROY_SESSION must be the final operation in a compound, if 248457716355SJ. Bruce Fields * sessionid's in SEQUENCE and DESTROY_SESSION are the same. 248557716355SJ. Bruce Fields * (Enforced in nfsd4_destroy_session().) 2486f9bb94c4SAndy Adamson */ 248757716355SJ. Bruce Fields static __be32 nfs41_check_op_ordering(struct nfsd4_compoundargs *args) 2488f9bb94c4SAndy Adamson { 24897a04cfdaSJ. Bruce Fields struct nfsd4_op *first_op = &args->ops[0]; 249057716355SJ. Bruce Fields 249157716355SJ. Bruce Fields /* These ordering requirements don't apply to NFSv4.0: */ 249257716355SJ. Bruce Fields if (args->minorversion == 0) 249357716355SJ. Bruce Fields return nfs_ok; 249457716355SJ. Bruce Fields /* This is weird, but OK, not our problem: */ 249557716355SJ. Bruce Fields if (args->opcnt == 0) 249657716355SJ. Bruce Fields return nfs_ok; 24977a04cfdaSJ. Bruce Fields if (first_op->status == nfserr_op_illegal) 249857716355SJ. Bruce Fields return nfs_ok; 24997a04cfdaSJ. Bruce Fields if (!(nfsd4_ops[first_op->opnum].op_flags & ALLOWED_AS_FIRST_OP)) 250057716355SJ. Bruce Fields return nfserr_op_not_in_session; 25017a04cfdaSJ. Bruce Fields if (first_op->opnum == OP_SEQUENCE) 250257716355SJ. Bruce Fields return nfs_ok; 25037a04cfdaSJ. Bruce Fields /* 25047a04cfdaSJ. Bruce Fields * So first_op is something allowed outside a session, like 25057a04cfdaSJ. Bruce Fields * EXCHANGE_ID; but then it has to be the only op in the 25067a04cfdaSJ. Bruce Fields * compound: 25077a04cfdaSJ. Bruce Fields */ 250857716355SJ. Bruce Fields if (args->opcnt != 1) 250957716355SJ. Bruce Fields return nfserr_not_only_op; 251057716355SJ. Bruce Fields return nfs_ok; 2511f9bb94c4SAndy Adamson } 2512f9bb94c4SAndy Adamson 2513f4f9ef4aSJ. Bruce Fields const struct nfsd4_operation *OPDESC(struct nfsd4_op *op) 251422b03214SJ. Bruce Fields { 251522b03214SJ. Bruce Fields return &nfsd4_ops[op->opnum]; 251622b03214SJ. Bruce Fields } 251722b03214SJ. Bruce Fields 25181091006cSJ. Bruce Fields bool nfsd4_cache_this_op(struct nfsd4_op *op) 25191091006cSJ. Bruce Fields { 2520e372ba60SJ. Bruce Fields if (op->opnum == OP_ILLEGAL) 2521e372ba60SJ. Bruce Fields return false; 2522c856694eSJ. Bruce Fields return OPDESC(op)->op_flags & OP_CACHEME; 25231091006cSJ. Bruce Fields } 25241091006cSJ. Bruce Fields 252568d93184SJ. Bruce Fields static bool need_wrongsec_check(struct svc_rqst *rqstp) 252668d93184SJ. Bruce Fields { 252768d93184SJ. Bruce Fields struct nfsd4_compoundres *resp = rqstp->rq_resp; 252868d93184SJ. Bruce Fields struct nfsd4_compoundargs *argp = rqstp->rq_argp; 252968d93184SJ. Bruce Fields struct nfsd4_op *this = &argp->ops[resp->opcnt - 1]; 253068d93184SJ. Bruce Fields struct nfsd4_op *next = &argp->ops[resp->opcnt]; 2531bb2a8b0cSChristoph Hellwig const struct nfsd4_operation *thisd = OPDESC(this); 2532bb2a8b0cSChristoph Hellwig const struct nfsd4_operation *nextd; 253368d93184SJ. Bruce Fields 253468d93184SJ. Bruce Fields /* 253568d93184SJ. Bruce Fields * Most ops check wronsec on our own; only the putfh-like ops 253668d93184SJ. Bruce Fields * have special rules. 253768d93184SJ. Bruce Fields */ 253868d93184SJ. Bruce Fields if (!(thisd->op_flags & OP_IS_PUTFH_LIKE)) 253968d93184SJ. Bruce Fields return false; 254068d93184SJ. Bruce Fields /* 254168d93184SJ. Bruce Fields * rfc 5661 2.6.3.1.1.6: don't bother erroring out a 254268d93184SJ. Bruce Fields * put-filehandle operation if we're not going to use the 254368d93184SJ. Bruce Fields * result: 254468d93184SJ. Bruce Fields */ 254568d93184SJ. Bruce Fields if (argp->opcnt == resp->opcnt) 254668d93184SJ. Bruce Fields return false; 254751904b08SJ. Bruce Fields if (next->opnum == OP_ILLEGAL) 254851904b08SJ. Bruce Fields return false; 254968d93184SJ. Bruce Fields nextd = OPDESC(next); 255068d93184SJ. Bruce Fields /* 255168d93184SJ. Bruce Fields * Rest of 2.6.3.1.1: certain operations will return WRONGSEC 255268d93184SJ. Bruce Fields * errors themselves as necessary; others should check for them 255368d93184SJ. Bruce Fields * now: 255468d93184SJ. Bruce Fields */ 255568d93184SJ. Bruce Fields return !(nextd->op_flags & OP_HANDLES_WRONGSEC); 255668d93184SJ. Bruce Fields } 255768d93184SJ. Bruce Fields 2558b9e8638eSOlga Kornievskaia #ifdef CONFIG_NFSD_V4_2_INTER_SSC 2559b9e8638eSOlga Kornievskaia static void 2560b9e8638eSOlga Kornievskaia check_if_stalefh_allowed(struct nfsd4_compoundargs *args) 2561b9e8638eSOlga Kornievskaia { 2562b9e8638eSOlga Kornievskaia struct nfsd4_op *op, *current_op = NULL, *saved_op = NULL; 2563b9e8638eSOlga Kornievskaia struct nfsd4_copy *copy; 2564b9e8638eSOlga Kornievskaia struct nfsd4_putfh *putfh; 2565b9e8638eSOlga Kornievskaia int i; 2566b9e8638eSOlga Kornievskaia 2567b9e8638eSOlga Kornievskaia /* traverse all operation and if it's a COPY compound, mark the 2568b9e8638eSOlga Kornievskaia * source filehandle to skip verification 2569b9e8638eSOlga Kornievskaia */ 2570b9e8638eSOlga Kornievskaia for (i = 0; i < args->opcnt; i++) { 2571b9e8638eSOlga Kornievskaia op = &args->ops[i]; 2572b9e8638eSOlga Kornievskaia if (op->opnum == OP_PUTFH) 2573b9e8638eSOlga Kornievskaia current_op = op; 2574b9e8638eSOlga Kornievskaia else if (op->opnum == OP_SAVEFH) 2575b9e8638eSOlga Kornievskaia saved_op = current_op; 2576b9e8638eSOlga Kornievskaia else if (op->opnum == OP_RESTOREFH) 2577b9e8638eSOlga Kornievskaia current_op = saved_op; 2578b9e8638eSOlga Kornievskaia else if (op->opnum == OP_COPY) { 2579b9e8638eSOlga Kornievskaia copy = (struct nfsd4_copy *)&op->u; 2580b9e8638eSOlga Kornievskaia if (!saved_op) { 2581b9e8638eSOlga Kornievskaia op->status = nfserr_nofilehandle; 2582b9e8638eSOlga Kornievskaia return; 2583b9e8638eSOlga Kornievskaia } 2584b9e8638eSOlga Kornievskaia putfh = (struct nfsd4_putfh *)&saved_op->u; 2585b9e8638eSOlga Kornievskaia if (!copy->cp_intra) 2586b9e8638eSOlga Kornievskaia putfh->no_verify = true; 2587b9e8638eSOlga Kornievskaia } 2588b9e8638eSOlga Kornievskaia } 2589b9e8638eSOlga Kornievskaia } 2590b9e8638eSOlga Kornievskaia #else 2591b9e8638eSOlga Kornievskaia static void 2592b9e8638eSOlga Kornievskaia check_if_stalefh_allowed(struct nfsd4_compoundargs *args) 2593b9e8638eSOlga Kornievskaia { 2594b9e8638eSOlga Kornievskaia } 2595b9e8638eSOlga Kornievskaia #endif 2596b9e8638eSOlga Kornievskaia 2597f9bb94c4SAndy Adamson /* 25981da177e4SLinus Torvalds * COMPOUND call. 25991da177e4SLinus Torvalds */ 26007111c66eSAl Viro static __be32 2601a6beb732SChristoph Hellwig nfsd4_proc_compound(struct svc_rqst *rqstp) 26021da177e4SLinus Torvalds { 2603a6beb732SChristoph Hellwig struct nfsd4_compoundargs *args = rqstp->rq_argp; 2604a6beb732SChristoph Hellwig struct nfsd4_compoundres *resp = rqstp->rq_resp; 26051da177e4SLinus Torvalds struct nfsd4_op *op; 2606e354d571SAndy Adamson struct nfsd4_compound_state *cstate = &resp->cstate; 26074daeed25SKinglong Mee struct svc_fh *current_fh = &cstate->current_fh; 26084daeed25SKinglong Mee struct svc_fh *save_fh = &cstate->save_fh; 2609e333f3bbSTrond Myklebust struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); 2610b37ad28bSAl Viro __be32 status; 26111da177e4SLinus Torvalds 2612bddfdbcdSChuck Lever resp->xdr = &rqstp->rq_res_stream; 26133b0ebb25SChuck Lever resp->statusp = resp->xdr->p; 2614bddfdbcdSChuck Lever 2615bddfdbcdSChuck Lever /* reserve space for: NFS status code */ 2616bddfdbcdSChuck Lever xdr_reserve_space(resp->xdr, XDR_UNIT); 2617bddfdbcdSChuck Lever 26181da177e4SLinus Torvalds /* reserve space for: taglen, tag, and opcnt */ 2619bddfdbcdSChuck Lever xdr_reserve_space(resp->xdr, XDR_UNIT * 2 + args->taglen); 26201da177e4SLinus Torvalds resp->taglen = args->taglen; 26211da177e4SLinus Torvalds resp->tag = args->tag; 26221da177e4SLinus Torvalds resp->rqstp = rqstp; 26234daeed25SKinglong Mee cstate->minorversion = args->minorversion; 26244daeed25SKinglong Mee fh_init(current_fh, NFS4_FHSIZE); 26254daeed25SKinglong Mee fh_init(save_fh, NFS4_FHSIZE); 26268ff30fa4SNeilBrown /* 26278ff30fa4SNeilBrown * Don't use the deferral mechanism for NFSv4; compounds make it 26288ff30fa4SNeilBrown * too hard to avoid non-idempotency problems. 26298ff30fa4SNeilBrown */ 263030660e04SJeff Layton clear_bit(RQ_USEDEFERRAL, &rqstp->rq_flags); 26311da177e4SLinus Torvalds 26321da177e4SLinus Torvalds /* 26331da177e4SLinus Torvalds * According to RFC3010, this takes precedence over all other errors. 26341da177e4SLinus Torvalds */ 26351da177e4SLinus Torvalds status = nfserr_minor_vers_mismatch; 2636e333f3bbSTrond Myklebust if (nfsd_minorversion(nn, args->minorversion, NFSD_TEST) <= 0) 26371da177e4SLinus Torvalds goto out; 26380078117cSJ. Bruce Fields status = nfserr_resource; 26390078117cSJ. Bruce Fields if (args->opcnt > NFSD_MAX_OPS_PER_COMPOUND) 26400078117cSJ. Bruce Fields goto out; 26411da177e4SLinus Torvalds 264257716355SJ. Bruce Fields status = nfs41_check_op_ordering(args); 264357716355SJ. Bruce Fields if (status) { 2644f9bb94c4SAndy Adamson op = &args->ops[0]; 264557716355SJ. Bruce Fields op->status = status; 26465b7b15aeSJ. Bruce Fields resp->opcnt = 1; 2647f9bb94c4SAndy Adamson goto encode_op; 2648f9bb94c4SAndy Adamson } 2649b9e8638eSOlga Kornievskaia check_if_stalefh_allowed(args); 2650f9bb94c4SAndy Adamson 265128df3d15SJ. Bruce Fields rqstp->rq_lease_breaker = (void **)&cstate->clp; 265228df3d15SJ. Bruce Fields 2653fff4080bSChuck Lever trace_nfsd_compound(rqstp, args->opcnt); 26541da177e4SLinus Torvalds while (!status && resp->opcnt < args->opcnt) { 26551da177e4SLinus Torvalds op = &args->ops[resp->opcnt++]; 26561da177e4SLinus Torvalds 26571da177e4SLinus Torvalds /* 26581da177e4SLinus Torvalds * The XDR decode routines may have pre-set op->status; 26591da177e4SLinus Torvalds * for example, if there is a miscellaneous XDR error 26601da177e4SLinus Torvalds * it will be set to nfserr_bad_xdr. 26611da177e4SLinus Torvalds */ 26629d313b17SJ. Bruce Fields if (op->status) { 26639d313b17SJ. Bruce Fields if (op->opnum == OP_OPEN) 26649d313b17SJ. Bruce Fields op->status = nfsd4_open_omfg(rqstp, cstate, op); 26651da177e4SLinus Torvalds goto encode_op; 26669d313b17SJ. Bruce Fields } 2667b9e8638eSOlga Kornievskaia if (!current_fh->fh_dentry && 2668b9e8638eSOlga Kornievskaia !HAS_FH_FLAG(current_fh, NFSD4_FH_FOREIGN)) { 2669f4f9ef4aSJ. Bruce Fields if (!(op->opdesc->op_flags & ALLOWED_WITHOUT_FH)) { 26701da177e4SLinus Torvalds op->status = nfserr_nofilehandle; 26711da177e4SLinus Torvalds goto encode_op; 26721da177e4SLinus Torvalds } 2673b9e8638eSOlga Kornievskaia } else if (current_fh->fh_export && 2674b9e8638eSOlga Kornievskaia current_fh->fh_export->ex_fslocs.migrated && 2675f4f9ef4aSJ. Bruce Fields !(op->opdesc->op_flags & ALLOWED_ON_ABSENT_FS)) { 267642ca0993SJ.Bruce Fields op->status = nfserr_moved; 267742ca0993SJ.Bruce Fields goto encode_op; 267842ca0993SJ.Bruce Fields } 2679b591480bSJ.Bruce Fields 2680fcb5e3faSChuck Lever fh_clear_pre_post_attrs(current_fh); 26812336745eSKinglong Mee 268258e7b33aSMi Jinlong /* If op is non-idempotent */ 2683f4f9ef4aSJ. Bruce Fields if (op->opdesc->op_flags & OP_MODIFIES_SOMETHING) { 26844c69d585SJ. Bruce Fields /* 2685a8095f7eSJ. Bruce Fields * Don't execute this op if we couldn't encode a 2686a8095f7eSJ. Bruce Fields * succesful reply: 2687a8095f7eSJ. Bruce Fields */ 2688f4f9ef4aSJ. Bruce Fields u32 plen = op->opdesc->op_rsize_bop(rqstp, op); 2689a8095f7eSJ. Bruce Fields /* 2690a8095f7eSJ. Bruce Fields * Plus if there's another operation, make sure 26914c69d585SJ. Bruce Fields * we'll have space to at least encode an error: 26924c69d585SJ. Bruce Fields */ 26934c69d585SJ. Bruce Fields if (resp->opcnt < args->opcnt) 26944c69d585SJ. Bruce Fields plen += COMPOUND_ERR_SLACK_SPACE; 269558e7b33aSMi Jinlong op->status = nfsd4_check_resp_size(resp, plen); 269658e7b33aSMi Jinlong } 269758e7b33aSMi Jinlong 269858e7b33aSMi Jinlong if (op->status) 269958e7b33aSMi Jinlong goto encode_op; 270058e7b33aSMi Jinlong 2701f4f9ef4aSJ. Bruce Fields if (op->opdesc->op_get_currentstateid) 2702f4f9ef4aSJ. Bruce Fields op->opdesc->op_get_currentstateid(cstate, &op->u); 2703f4f9ef4aSJ. Bruce Fields op->status = op->opdesc->op_func(rqstp, cstate, &op->u); 27041da177e4SLinus Torvalds 27059a307403SJ. Bruce Fields /* Only from SEQUENCE */ 27069a307403SJ. Bruce Fields if (cstate->status == nfserr_replay_cache) { 27079a307403SJ. Bruce Fields dprintk("%s NFS4.1 replay from cache\n", __func__); 27089a307403SJ. Bruce Fields status = op->status; 27099a307403SJ. Bruce Fields goto out; 27109a307403SJ. Bruce Fields } 27118b70484cSTigran Mkrtchyan if (!op->status) { 2712f4f9ef4aSJ. Bruce Fields if (op->opdesc->op_set_currentstateid) 2713f4f9ef4aSJ. Bruce Fields op->opdesc->op_set_currentstateid(cstate, &op->u); 27148b70484cSTigran Mkrtchyan 2715f4f9ef4aSJ. Bruce Fields if (op->opdesc->op_flags & OP_CLEAR_STATEID) 271637c593c5STigran Mkrtchyan clear_current_stateid(cstate); 27178b70484cSTigran Mkrtchyan 2718d781e3dfSJ. Bruce Fields if (current_fh->fh_export && 2719d781e3dfSJ. Bruce Fields need_wrongsec_check(rqstp)) 27204daeed25SKinglong Mee op->status = check_nfsd_access(current_fh->fh_export, rqstp); 27218b70484cSTigran Mkrtchyan } 27221da177e4SLinus Torvalds encode_op: 2723a90b061cSAl Viro if (op->status == nfserr_replay_me) { 2724a4f1706aSJ.Bruce Fields op->replay = &cstate->replay_owner->so_replay; 2725bddfdbcdSChuck Lever nfsd4_encode_replay(resp->xdr, op); 27261da177e4SLinus Torvalds status = op->status = op->replay->rp_status; 27271da177e4SLinus Torvalds } else { 27281da177e4SLinus Torvalds nfsd4_encode_operation(resp, op); 27291da177e4SLinus Torvalds status = op->status; 27301da177e4SLinus Torvalds } 27310407717dSBenny Halevy 2732fff4080bSChuck Lever trace_nfsd_compound_status(args->opcnt, resp->opcnt, status, 2733fff4080bSChuck Lever nfsd4_op_name(op->opnum)); 27340407717dSBenny Halevy 273558fb12e6SJeff Layton nfsd4_cstate_clear_replay(cstate); 2736e2b20950SShankar Anand nfsd4_increment_op_stats(op->opnum); 27371da177e4SLinus Torvalds } 27381da177e4SLinus Torvalds 27394daeed25SKinglong Mee fh_put(current_fh); 27404daeed25SKinglong Mee fh_put(save_fh); 27414daeed25SKinglong Mee BUG_ON(cstate->replay_owner); 27421da177e4SLinus Torvalds out: 2743cc028a10SChuck Lever cstate->status = status; 27442f425878SAndy Adamson /* Reset deferral mechanism for RPC deferrals */ 274530660e04SJeff Layton set_bit(RQ_USEDEFERRAL, &rqstp->rq_flags); 2746cc028a10SChuck Lever return rpc_success; 27471da177e4SLinus Torvalds } 27481da177e4SLinus Torvalds 274958e7b33aSMi Jinlong #define op_encode_hdr_size (2) 275058e7b33aSMi Jinlong #define op_encode_stateid_maxsz (XDR_QUADLEN(NFS4_STATEID_SIZE)) 275158e7b33aSMi Jinlong #define op_encode_verifier_maxsz (XDR_QUADLEN(NFS4_VERIFIER_SIZE)) 275258e7b33aSMi Jinlong #define op_encode_change_info_maxsz (5) 275358e7b33aSMi Jinlong #define nfs4_fattr_bitmap_maxsz (4) 275458e7b33aSMi Jinlong 27558c7424cfSJ. Bruce Fields /* We'll fall back on returning no lockowner if run out of space: */ 27568c7424cfSJ. Bruce Fields #define op_encode_lockowner_maxsz (0) 275758e7b33aSMi Jinlong #define op_encode_lock_denied_maxsz (8 + op_encode_lockowner_maxsz) 275858e7b33aSMi Jinlong 275958e7b33aSMi Jinlong #define nfs4_owner_maxsz (1 + XDR_QUADLEN(IDMAP_NAMESZ)) 276058e7b33aSMi Jinlong 276158e7b33aSMi Jinlong #define op_encode_ace_maxsz (3 + nfs4_owner_maxsz) 276258e7b33aSMi Jinlong #define op_encode_delegation_maxsz (1 + op_encode_stateid_maxsz + 1 + \ 276358e7b33aSMi Jinlong op_encode_ace_maxsz) 276458e7b33aSMi Jinlong 276558e7b33aSMi Jinlong #define op_encode_channel_attrs_maxsz (6 + 1 + 1) 276658e7b33aSMi Jinlong 276758e7b33aSMi Jinlong static inline u32 nfsd4_only_status_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 276858e7b33aSMi Jinlong { 276958e7b33aSMi Jinlong return (op_encode_hdr_size) * sizeof(__be32); 277058e7b33aSMi Jinlong } 277158e7b33aSMi Jinlong 277258e7b33aSMi Jinlong static inline u32 nfsd4_status_stateid_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 277358e7b33aSMi Jinlong { 277458e7b33aSMi Jinlong return (op_encode_hdr_size + op_encode_stateid_maxsz)* sizeof(__be32); 277558e7b33aSMi Jinlong } 277658e7b33aSMi Jinlong 27772282cd2cSKinglong Mee static inline u32 nfsd4_access_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 27782282cd2cSKinglong Mee { 27792282cd2cSKinglong Mee /* ac_supported, ac_resp_access */ 27802282cd2cSKinglong Mee return (op_encode_hdr_size + 2)* sizeof(__be32); 27812282cd2cSKinglong Mee } 27822282cd2cSKinglong Mee 278358e7b33aSMi Jinlong static inline u32 nfsd4_commit_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 278458e7b33aSMi Jinlong { 278558e7b33aSMi Jinlong return (op_encode_hdr_size + op_encode_verifier_maxsz) * sizeof(__be32); 278658e7b33aSMi Jinlong } 278758e7b33aSMi Jinlong 278858e7b33aSMi Jinlong static inline u32 nfsd4_create_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 278958e7b33aSMi Jinlong { 279058e7b33aSMi Jinlong return (op_encode_hdr_size + op_encode_change_info_maxsz 279158e7b33aSMi Jinlong + nfs4_fattr_bitmap_maxsz) * sizeof(__be32); 279258e7b33aSMi Jinlong } 279358e7b33aSMi Jinlong 2794b86cef60SJ. Bruce Fields /* 2795b86cef60SJ. Bruce Fields * Note since this is an idempotent operation we won't insist on failing 2796b86cef60SJ. Bruce Fields * the op prematurely if the estimate is too large. We may turn off splice 2797b86cef60SJ. Bruce Fields * reads unnecessarily. 2798b86cef60SJ. Bruce Fields */ 2799b86cef60SJ. Bruce Fields static inline u32 nfsd4_getattr_rsize(struct svc_rqst *rqstp, 2800b86cef60SJ. Bruce Fields struct nfsd4_op *op) 2801b86cef60SJ. Bruce Fields { 2802b86cef60SJ. Bruce Fields u32 *bmap = op->u.getattr.ga_bmval; 2803b86cef60SJ. Bruce Fields u32 bmap0 = bmap[0], bmap1 = bmap[1], bmap2 = bmap[2]; 2804b86cef60SJ. Bruce Fields u32 ret = 0; 2805b86cef60SJ. Bruce Fields 2806b86cef60SJ. Bruce Fields if (bmap0 & FATTR4_WORD0_ACL) 2807b86cef60SJ. Bruce Fields return svc_max_payload(rqstp); 2808b86cef60SJ. Bruce Fields if (bmap0 & FATTR4_WORD0_FS_LOCATIONS) 2809b86cef60SJ. Bruce Fields return svc_max_payload(rqstp); 2810b86cef60SJ. Bruce Fields 2811b86cef60SJ. Bruce Fields if (bmap1 & FATTR4_WORD1_OWNER) { 2812b86cef60SJ. Bruce Fields ret += IDMAP_NAMESZ + 4; 2813b86cef60SJ. Bruce Fields bmap1 &= ~FATTR4_WORD1_OWNER; 2814b86cef60SJ. Bruce Fields } 2815b86cef60SJ. Bruce Fields if (bmap1 & FATTR4_WORD1_OWNER_GROUP) { 2816b86cef60SJ. Bruce Fields ret += IDMAP_NAMESZ + 4; 2817b86cef60SJ. Bruce Fields bmap1 &= ~FATTR4_WORD1_OWNER_GROUP; 2818b86cef60SJ. Bruce Fields } 2819b86cef60SJ. Bruce Fields if (bmap0 & FATTR4_WORD0_FILEHANDLE) { 2820b86cef60SJ. Bruce Fields ret += NFS4_FHSIZE + 4; 2821b86cef60SJ. Bruce Fields bmap0 &= ~FATTR4_WORD0_FILEHANDLE; 2822b86cef60SJ. Bruce Fields } 2823b86cef60SJ. Bruce Fields if (bmap2 & FATTR4_WORD2_SECURITY_LABEL) { 28241ec8c0c4SKinglong Mee ret += NFS4_MAXLABELLEN + 12; 2825b86cef60SJ. Bruce Fields bmap2 &= ~FATTR4_WORD2_SECURITY_LABEL; 2826b86cef60SJ. Bruce Fields } 2827b86cef60SJ. Bruce Fields /* 2828b86cef60SJ. Bruce Fields * Largest of remaining attributes are 16 bytes (e.g., 2829b86cef60SJ. Bruce Fields * supported_attributes) 2830b86cef60SJ. Bruce Fields */ 2831b86cef60SJ. Bruce Fields ret += 16 * (hweight32(bmap0) + hweight32(bmap1) + hweight32(bmap2)); 2832b86cef60SJ. Bruce Fields /* bitmask, length */ 2833b86cef60SJ. Bruce Fields ret += 20; 2834b86cef60SJ. Bruce Fields return ret; 2835b86cef60SJ. Bruce Fields } 2836b86cef60SJ. Bruce Fields 28372282cd2cSKinglong Mee static inline u32 nfsd4_getfh_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 28382282cd2cSKinglong Mee { 28392282cd2cSKinglong Mee return (op_encode_hdr_size + 1) * sizeof(__be32) + NFS4_FHSIZE; 28402282cd2cSKinglong Mee } 28412282cd2cSKinglong Mee 284258e7b33aSMi Jinlong static inline u32 nfsd4_link_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 284358e7b33aSMi Jinlong { 284458e7b33aSMi Jinlong return (op_encode_hdr_size + op_encode_change_info_maxsz) 284558e7b33aSMi Jinlong * sizeof(__be32); 284658e7b33aSMi Jinlong } 284758e7b33aSMi Jinlong 284858e7b33aSMi Jinlong static inline u32 nfsd4_lock_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 284958e7b33aSMi Jinlong { 285058e7b33aSMi Jinlong return (op_encode_hdr_size + op_encode_lock_denied_maxsz) 285158e7b33aSMi Jinlong * sizeof(__be32); 285258e7b33aSMi Jinlong } 285358e7b33aSMi Jinlong 285458e7b33aSMi Jinlong static inline u32 nfsd4_open_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 285558e7b33aSMi Jinlong { 285658e7b33aSMi Jinlong return (op_encode_hdr_size + op_encode_stateid_maxsz 285758e7b33aSMi Jinlong + op_encode_change_info_maxsz + 1 285858e7b33aSMi Jinlong + nfs4_fattr_bitmap_maxsz 285958e7b33aSMi Jinlong + op_encode_delegation_maxsz) * sizeof(__be32); 286058e7b33aSMi Jinlong } 286158e7b33aSMi Jinlong 286258e7b33aSMi Jinlong static inline u32 nfsd4_read_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 286358e7b33aSMi Jinlong { 286458e7b33aSMi Jinlong u32 maxcount = 0, rlen = 0; 286558e7b33aSMi Jinlong 286658e7b33aSMi Jinlong maxcount = svc_max_payload(rqstp); 28673c7aa15dSKinglong Mee rlen = min(op->u.read.rd_length, maxcount); 286858e7b33aSMi Jinlong 2869622f560eSJ. Bruce Fields return (op_encode_hdr_size + 2 + XDR_QUADLEN(rlen)) * sizeof(__be32); 287058e7b33aSMi Jinlong } 287158e7b33aSMi Jinlong 2872528b8493SAnna Schumaker static inline u32 nfsd4_read_plus_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 2873528b8493SAnna Schumaker { 2874528b8493SAnna Schumaker u32 maxcount = svc_max_payload(rqstp); 2875528b8493SAnna Schumaker u32 rlen = min(op->u.read.rd_length, maxcount); 2876528b8493SAnna Schumaker /* 2877528b8493SAnna Schumaker * If we detect that the file changed during hole encoding, then we 2878528b8493SAnna Schumaker * recover by encoding the remaining reply as data. This means we need 2879528b8493SAnna Schumaker * to set aside enough room to encode two data segments. 2880528b8493SAnna Schumaker */ 2881528b8493SAnna Schumaker u32 seg_len = 2 * (1 + 2 + 1); 2882528b8493SAnna Schumaker 2883528b8493SAnna Schumaker return (op_encode_hdr_size + 2 + seg_len + XDR_QUADLEN(rlen)) * sizeof(__be32); 2884528b8493SAnna Schumaker } 2885528b8493SAnna Schumaker 288658e7b33aSMi Jinlong static inline u32 nfsd4_readdir_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 288758e7b33aSMi Jinlong { 28883c7aa15dSKinglong Mee u32 maxcount = 0, rlen = 0; 288958e7b33aSMi Jinlong 28903c7aa15dSKinglong Mee maxcount = svc_max_payload(rqstp); 28913c7aa15dSKinglong Mee rlen = min(op->u.readdir.rd_maxcount, maxcount); 289258e7b33aSMi Jinlong 2893561f0ed4SJ. Bruce Fields return (op_encode_hdr_size + op_encode_verifier_maxsz + 2894561f0ed4SJ. Bruce Fields XDR_QUADLEN(rlen)) * sizeof(__be32); 289558e7b33aSMi Jinlong } 289658e7b33aSMi Jinlong 28972282cd2cSKinglong Mee static inline u32 nfsd4_readlink_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 28982282cd2cSKinglong Mee { 28992282cd2cSKinglong Mee return (op_encode_hdr_size + 1) * sizeof(__be32) + PAGE_SIZE; 29002282cd2cSKinglong Mee } 29012282cd2cSKinglong Mee 290258e7b33aSMi Jinlong static inline u32 nfsd4_remove_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 290358e7b33aSMi Jinlong { 290458e7b33aSMi Jinlong return (op_encode_hdr_size + op_encode_change_info_maxsz) 290558e7b33aSMi Jinlong * sizeof(__be32); 290658e7b33aSMi Jinlong } 290758e7b33aSMi Jinlong 290858e7b33aSMi Jinlong static inline u32 nfsd4_rename_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 290958e7b33aSMi Jinlong { 291058e7b33aSMi Jinlong return (op_encode_hdr_size + op_encode_change_info_maxsz 291158e7b33aSMi Jinlong + op_encode_change_info_maxsz) * sizeof(__be32); 291258e7b33aSMi Jinlong } 291358e7b33aSMi Jinlong 2914ccae70a9SJ. Bruce Fields static inline u32 nfsd4_sequence_rsize(struct svc_rqst *rqstp, 2915ccae70a9SJ. Bruce Fields struct nfsd4_op *op) 2916ccae70a9SJ. Bruce Fields { 2917d1d84c96SJ. Bruce Fields return (op_encode_hdr_size 2918d1d84c96SJ. Bruce Fields + XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + 5) * sizeof(__be32); 2919ccae70a9SJ. Bruce Fields } 2920ccae70a9SJ. Bruce Fields 29212282cd2cSKinglong Mee static inline u32 nfsd4_test_stateid_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 29222282cd2cSKinglong Mee { 29232282cd2cSKinglong Mee return (op_encode_hdr_size + 1 + op->u.test_stateid.ts_num_ids) 29242282cd2cSKinglong Mee * sizeof(__be32); 29252282cd2cSKinglong Mee } 29262282cd2cSKinglong Mee 292758e7b33aSMi Jinlong static inline u32 nfsd4_setattr_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 292858e7b33aSMi Jinlong { 292958e7b33aSMi Jinlong return (op_encode_hdr_size + nfs4_fattr_bitmap_maxsz) * sizeof(__be32); 293058e7b33aSMi Jinlong } 293158e7b33aSMi Jinlong 29322282cd2cSKinglong Mee static inline u32 nfsd4_secinfo_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 29332282cd2cSKinglong Mee { 29342282cd2cSKinglong Mee return (op_encode_hdr_size + RPC_AUTH_MAXFLAVOR * 29352282cd2cSKinglong Mee (4 + XDR_QUADLEN(GSS_OID_MAX_LEN))) * sizeof(__be32); 29362282cd2cSKinglong Mee } 29372282cd2cSKinglong Mee 293858e7b33aSMi Jinlong static inline u32 nfsd4_setclientid_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 293958e7b33aSMi Jinlong { 2940480efaeeSJ. Bruce Fields return (op_encode_hdr_size + 2 + XDR_QUADLEN(NFS4_VERIFIER_SIZE)) * 2941480efaeeSJ. Bruce Fields sizeof(__be32); 294258e7b33aSMi Jinlong } 294358e7b33aSMi Jinlong 294458e7b33aSMi Jinlong static inline u32 nfsd4_write_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 294558e7b33aSMi Jinlong { 2946f34e432bSJ. Bruce Fields return (op_encode_hdr_size + 2 + op_encode_verifier_maxsz) * sizeof(__be32); 294758e7b33aSMi Jinlong } 294858e7b33aSMi Jinlong 294958e7b33aSMi Jinlong static inline u32 nfsd4_exchange_id_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 295058e7b33aSMi Jinlong { 295158e7b33aSMi Jinlong return (op_encode_hdr_size + 2 + 1 + /* eir_clientid, eir_sequenceid */\ 2952a8bb84bcSKinglong Mee 1 + 1 + /* eir_flags, spr_how */\ 2953a8bb84bcSKinglong Mee 4 + /* spo_must_enforce & _allow with bitmap */\ 295458e7b33aSMi Jinlong 2 + /*eir_server_owner.so_minor_id */\ 295558e7b33aSMi Jinlong /* eir_server_owner.so_major_id<> */\ 295658e7b33aSMi Jinlong XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + 1 +\ 295758e7b33aSMi Jinlong /* eir_server_scope<> */\ 295858e7b33aSMi Jinlong XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + 1 +\ 295958e7b33aSMi Jinlong 1 + /* eir_server_impl_id array length */\ 296058e7b33aSMi Jinlong 0 /* ignored eir_server_impl_id contents */) * sizeof(__be32); 296158e7b33aSMi Jinlong } 296258e7b33aSMi Jinlong 296358e7b33aSMi Jinlong static inline u32 nfsd4_bind_conn_to_session_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 296458e7b33aSMi Jinlong { 296558e7b33aSMi Jinlong return (op_encode_hdr_size + \ 296658e7b33aSMi Jinlong XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + /* bctsr_sessid */\ 296758e7b33aSMi Jinlong 2 /* bctsr_dir, use_conn_in_rdma_mode */) * sizeof(__be32); 296858e7b33aSMi Jinlong } 296958e7b33aSMi Jinlong 297058e7b33aSMi Jinlong static inline u32 nfsd4_create_session_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 297158e7b33aSMi Jinlong { 297258e7b33aSMi Jinlong return (op_encode_hdr_size + \ 297358e7b33aSMi Jinlong XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + /* sessionid */\ 297458e7b33aSMi Jinlong 2 + /* csr_sequence, csr_flags */\ 297558e7b33aSMi Jinlong op_encode_channel_attrs_maxsz + \ 297658e7b33aSMi Jinlong op_encode_channel_attrs_maxsz) * sizeof(__be32); 297758e7b33aSMi Jinlong } 297858e7b33aSMi Jinlong 297929ae7f9dSAnna Schumaker static inline u32 nfsd4_copy_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 298029ae7f9dSAnna Schumaker { 298129ae7f9dSAnna Schumaker return (op_encode_hdr_size + 298229ae7f9dSAnna Schumaker 1 /* wr_callback */ + 298329ae7f9dSAnna Schumaker op_encode_stateid_maxsz /* wr_callback */ + 298429ae7f9dSAnna Schumaker 2 /* wr_count */ + 298529ae7f9dSAnna Schumaker 1 /* wr_committed */ + 298629ae7f9dSAnna Schumaker op_encode_verifier_maxsz + 298729ae7f9dSAnna Schumaker 1 /* cr_consecutive */ + 298829ae7f9dSAnna Schumaker 1 /* cr_synchronous */) * sizeof(__be32); 298929ae7f9dSAnna Schumaker } 299029ae7f9dSAnna Schumaker 29916308bc98SOlga Kornievskaia static inline u32 nfsd4_offload_status_rsize(struct svc_rqst *rqstp, 29926308bc98SOlga Kornievskaia struct nfsd4_op *op) 29936308bc98SOlga Kornievskaia { 29946308bc98SOlga Kornievskaia return (op_encode_hdr_size + 29956308bc98SOlga Kornievskaia 2 /* osr_count */ + 29966308bc98SOlga Kornievskaia 1 /* osr_complete<1> optional 0 for now */) * sizeof(__be32); 29976308bc98SOlga Kornievskaia } 29986308bc98SOlga Kornievskaia 299951911868SOlga Kornievskaia static inline u32 nfsd4_copy_notify_rsize(struct svc_rqst *rqstp, 300051911868SOlga Kornievskaia struct nfsd4_op *op) 300151911868SOlga Kornievskaia { 300251911868SOlga Kornievskaia return (op_encode_hdr_size + 300351911868SOlga Kornievskaia 3 /* cnr_lease_time */ + 300451911868SOlga Kornievskaia 1 /* We support one cnr_source_server */ + 300551911868SOlga Kornievskaia 1 /* cnr_stateid seq */ + 300651911868SOlga Kornievskaia op_encode_stateid_maxsz /* cnr_stateid */ + 300751911868SOlga Kornievskaia 1 /* num cnr_source_server*/ + 300851911868SOlga Kornievskaia 1 /* nl4_type */ + 300951911868SOlga Kornievskaia 1 /* nl4 size */ + 301051911868SOlga Kornievskaia XDR_QUADLEN(NFS4_OPAQUE_LIMIT) /*nl4_loc + nl4_loc_sz */) 301151911868SOlga Kornievskaia * sizeof(__be32); 301251911868SOlga Kornievskaia } 301351911868SOlga Kornievskaia 30149cf514ccSChristoph Hellwig #ifdef CONFIG_NFSD_PNFS 30152282cd2cSKinglong Mee static inline u32 nfsd4_getdeviceinfo_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 30162282cd2cSKinglong Mee { 30172282cd2cSKinglong Mee u32 maxcount = 0, rlen = 0; 30182282cd2cSKinglong Mee 30192282cd2cSKinglong Mee maxcount = svc_max_payload(rqstp); 30202282cd2cSKinglong Mee rlen = min(op->u.getdeviceinfo.gd_maxcount, maxcount); 30212282cd2cSKinglong Mee 30222282cd2cSKinglong Mee return (op_encode_hdr_size + 30232282cd2cSKinglong Mee 1 /* gd_layout_type*/ + 30242282cd2cSKinglong Mee XDR_QUADLEN(rlen) + 30252282cd2cSKinglong Mee 2 /* gd_notify_types */) * sizeof(__be32); 30262282cd2cSKinglong Mee } 30272282cd2cSKinglong Mee 30289cf514ccSChristoph Hellwig /* 30299cf514ccSChristoph Hellwig * At this stage we don't really know what layout driver will handle the request, 30309cf514ccSChristoph Hellwig * so we need to define an arbitrary upper bound here. 30319cf514ccSChristoph Hellwig */ 30329cf514ccSChristoph Hellwig #define MAX_LAYOUT_SIZE 128 30339cf514ccSChristoph Hellwig static inline u32 nfsd4_layoutget_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 30349cf514ccSChristoph Hellwig { 30359cf514ccSChristoph Hellwig return (op_encode_hdr_size + 30369cf514ccSChristoph Hellwig 1 /* logr_return_on_close */ + 30379cf514ccSChristoph Hellwig op_encode_stateid_maxsz + 30389cf514ccSChristoph Hellwig 1 /* nr of layouts */ + 30399cf514ccSChristoph Hellwig MAX_LAYOUT_SIZE) * sizeof(__be32); 30409cf514ccSChristoph Hellwig } 30419cf514ccSChristoph Hellwig 30429cf514ccSChristoph Hellwig static inline u32 nfsd4_layoutcommit_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 30439cf514ccSChristoph Hellwig { 30449cf514ccSChristoph Hellwig return (op_encode_hdr_size + 30459cf514ccSChristoph Hellwig 1 /* locr_newsize */ + 30469cf514ccSChristoph Hellwig 2 /* ns_size */) * sizeof(__be32); 30479cf514ccSChristoph Hellwig } 30489cf514ccSChristoph Hellwig 30499cf514ccSChristoph Hellwig static inline u32 nfsd4_layoutreturn_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 30509cf514ccSChristoph Hellwig { 30519cf514ccSChristoph Hellwig return (op_encode_hdr_size + 30529cf514ccSChristoph Hellwig 1 /* lrs_stateid */ + 30539cf514ccSChristoph Hellwig op_encode_stateid_maxsz) * sizeof(__be32); 30549cf514ccSChristoph Hellwig } 30559cf514ccSChristoph Hellwig #endif /* CONFIG_NFSD_PNFS */ 30569cf514ccSChristoph Hellwig 30572282cd2cSKinglong Mee 30582282cd2cSKinglong Mee static inline u32 nfsd4_seek_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 30592282cd2cSKinglong Mee { 30602282cd2cSKinglong Mee return (op_encode_hdr_size + 3) * sizeof(__be32); 30612282cd2cSKinglong Mee } 30622282cd2cSKinglong Mee 306323e50fe3SFrank van der Linden static inline u32 nfsd4_getxattr_rsize(struct svc_rqst *rqstp, 306423e50fe3SFrank van der Linden struct nfsd4_op *op) 306523e50fe3SFrank van der Linden { 306623e50fe3SFrank van der Linden u32 maxcount, rlen; 306723e50fe3SFrank van der Linden 306823e50fe3SFrank van der Linden maxcount = svc_max_payload(rqstp); 306923e50fe3SFrank van der Linden rlen = min_t(u32, XATTR_SIZE_MAX, maxcount); 307023e50fe3SFrank van der Linden 307123e50fe3SFrank van der Linden return (op_encode_hdr_size + 1 + XDR_QUADLEN(rlen)) * sizeof(__be32); 307223e50fe3SFrank van der Linden } 307323e50fe3SFrank van der Linden 307423e50fe3SFrank van der Linden static inline u32 nfsd4_setxattr_rsize(struct svc_rqst *rqstp, 307523e50fe3SFrank van der Linden struct nfsd4_op *op) 307623e50fe3SFrank van der Linden { 307723e50fe3SFrank van der Linden return (op_encode_hdr_size + op_encode_change_info_maxsz) 307823e50fe3SFrank van der Linden * sizeof(__be32); 307923e50fe3SFrank van der Linden } 308023e50fe3SFrank van der Linden static inline u32 nfsd4_listxattrs_rsize(struct svc_rqst *rqstp, 308123e50fe3SFrank van der Linden struct nfsd4_op *op) 308223e50fe3SFrank van der Linden { 308323e50fe3SFrank van der Linden u32 maxcount, rlen; 308423e50fe3SFrank van der Linden 308523e50fe3SFrank van der Linden maxcount = svc_max_payload(rqstp); 308623e50fe3SFrank van der Linden rlen = min(op->u.listxattrs.lsxa_maxcount, maxcount); 308723e50fe3SFrank van der Linden 308823e50fe3SFrank van der Linden return (op_encode_hdr_size + 4 + XDR_QUADLEN(rlen)) * sizeof(__be32); 308923e50fe3SFrank van der Linden } 309023e50fe3SFrank van der Linden 309123e50fe3SFrank van der Linden static inline u32 nfsd4_removexattr_rsize(struct svc_rqst *rqstp, 309223e50fe3SFrank van der Linden struct nfsd4_op *op) 309323e50fe3SFrank van der Linden { 309423e50fe3SFrank van der Linden return (op_encode_hdr_size + op_encode_change_info_maxsz) 309523e50fe3SFrank van der Linden * sizeof(__be32); 309623e50fe3SFrank van der Linden } 309723e50fe3SFrank van der Linden 309823e50fe3SFrank van der Linden 3099bb2a8b0cSChristoph Hellwig static const struct nfsd4_operation nfsd4_ops[] = { 3100b591480bSJ.Bruce Fields [OP_ACCESS] = { 3101eb69853dSChristoph Hellwig .op_func = nfsd4_access, 3102b001a1b6SBenny Halevy .op_name = "OP_ACCESS", 31031c122638SChristoph Hellwig .op_rsize_bop = nfsd4_access_rsize, 3104b591480bSJ.Bruce Fields }, 3105b591480bSJ.Bruce Fields [OP_CLOSE] = { 3106eb69853dSChristoph Hellwig .op_func = nfsd4_close, 310758e7b33aSMi Jinlong .op_flags = OP_MODIFIES_SOMETHING, 3108b001a1b6SBenny Halevy .op_name = "OP_CLOSE", 31091c122638SChristoph Hellwig .op_rsize_bop = nfsd4_status_stateid_rsize, 311057832e7bSChristoph Hellwig .op_get_currentstateid = nfsd4_get_closestateid, 3111b60e9859SChristoph Hellwig .op_set_currentstateid = nfsd4_set_closestateid, 3112b591480bSJ.Bruce Fields }, 3113b591480bSJ.Bruce Fields [OP_COMMIT] = { 3114eb69853dSChristoph Hellwig .op_func = nfsd4_commit, 311558e7b33aSMi Jinlong .op_flags = OP_MODIFIES_SOMETHING, 3116b001a1b6SBenny Halevy .op_name = "OP_COMMIT", 31171c122638SChristoph Hellwig .op_rsize_bop = nfsd4_commit_rsize, 3118b591480bSJ.Bruce Fields }, 3119b591480bSJ.Bruce Fields [OP_CREATE] = { 3120eb69853dSChristoph Hellwig .op_func = nfsd4_create, 3121d1471053STigran Mkrtchyan .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME | OP_CLEAR_STATEID, 3122b001a1b6SBenny Halevy .op_name = "OP_CREATE", 31231c122638SChristoph Hellwig .op_rsize_bop = nfsd4_create_rsize, 3124b591480bSJ.Bruce Fields }, 3125b591480bSJ.Bruce Fields [OP_DELEGRETURN] = { 3126eb69853dSChristoph Hellwig .op_func = nfsd4_delegreturn, 312758e7b33aSMi Jinlong .op_flags = OP_MODIFIES_SOMETHING, 3128b001a1b6SBenny Halevy .op_name = "OP_DELEGRETURN", 312958e7b33aSMi Jinlong .op_rsize_bop = nfsd4_only_status_rsize, 313057832e7bSChristoph Hellwig .op_get_currentstateid = nfsd4_get_delegreturnstateid, 3131b591480bSJ.Bruce Fields }, 3132b591480bSJ.Bruce Fields [OP_GETATTR] = { 3133eb69853dSChristoph Hellwig .op_func = nfsd4_getattr, 3134eeac294eSJ.Bruce Fields .op_flags = ALLOWED_ON_ABSENT_FS, 3135b86cef60SJ. Bruce Fields .op_rsize_bop = nfsd4_getattr_rsize, 3136b001a1b6SBenny Halevy .op_name = "OP_GETATTR", 3137b591480bSJ.Bruce Fields }, 3138b591480bSJ.Bruce Fields [OP_GETFH] = { 3139eb69853dSChristoph Hellwig .op_func = nfsd4_getfh, 3140b001a1b6SBenny Halevy .op_name = "OP_GETFH", 31411c122638SChristoph Hellwig .op_rsize_bop = nfsd4_getfh_rsize, 3142b591480bSJ.Bruce Fields }, 3143b591480bSJ.Bruce Fields [OP_LINK] = { 3144eb69853dSChristoph Hellwig .op_func = nfsd4_link, 3145c856694eSJ. Bruce Fields .op_flags = ALLOWED_ON_ABSENT_FS | OP_MODIFIES_SOMETHING 3146c856694eSJ. Bruce Fields | OP_CACHEME, 3147b001a1b6SBenny Halevy .op_name = "OP_LINK", 31481c122638SChristoph Hellwig .op_rsize_bop = nfsd4_link_rsize, 3149b591480bSJ.Bruce Fields }, 3150b591480bSJ.Bruce Fields [OP_LOCK] = { 3151eb69853dSChristoph Hellwig .op_func = nfsd4_lock, 3152b7571e4cSJ. Bruce Fields .op_flags = OP_MODIFIES_SOMETHING | 3153b7571e4cSJ. Bruce Fields OP_NONTRIVIAL_ERROR_ENCODE, 3154b001a1b6SBenny Halevy .op_name = "OP_LOCK", 31551c122638SChristoph Hellwig .op_rsize_bop = nfsd4_lock_rsize, 3156b60e9859SChristoph Hellwig .op_set_currentstateid = nfsd4_set_lockstateid, 3157b591480bSJ.Bruce Fields }, 3158b591480bSJ.Bruce Fields [OP_LOCKT] = { 3159eb69853dSChristoph Hellwig .op_func = nfsd4_lockt, 3160b7571e4cSJ. Bruce Fields .op_flags = OP_NONTRIVIAL_ERROR_ENCODE, 3161b001a1b6SBenny Halevy .op_name = "OP_LOCKT", 31621c122638SChristoph Hellwig .op_rsize_bop = nfsd4_lock_rsize, 3163b591480bSJ.Bruce Fields }, 3164b591480bSJ.Bruce Fields [OP_LOCKU] = { 3165eb69853dSChristoph Hellwig .op_func = nfsd4_locku, 316658e7b33aSMi Jinlong .op_flags = OP_MODIFIES_SOMETHING, 3167b001a1b6SBenny Halevy .op_name = "OP_LOCKU", 31681c122638SChristoph Hellwig .op_rsize_bop = nfsd4_status_stateid_rsize, 316957832e7bSChristoph Hellwig .op_get_currentstateid = nfsd4_get_lockustateid, 3170b591480bSJ.Bruce Fields }, 3171b591480bSJ.Bruce Fields [OP_LOOKUP] = { 3172eb69853dSChristoph Hellwig .op_func = nfsd4_lookup, 3173d1471053STigran Mkrtchyan .op_flags = OP_HANDLES_WRONGSEC | OP_CLEAR_STATEID, 3174b001a1b6SBenny Halevy .op_name = "OP_LOOKUP", 31751c122638SChristoph Hellwig .op_rsize_bop = nfsd4_only_status_rsize, 3176b591480bSJ.Bruce Fields }, 3177b591480bSJ.Bruce Fields [OP_LOOKUPP] = { 3178eb69853dSChristoph Hellwig .op_func = nfsd4_lookupp, 3179d1471053STigran Mkrtchyan .op_flags = OP_HANDLES_WRONGSEC | OP_CLEAR_STATEID, 3180b001a1b6SBenny Halevy .op_name = "OP_LOOKUPP", 31811c122638SChristoph Hellwig .op_rsize_bop = nfsd4_only_status_rsize, 3182b591480bSJ.Bruce Fields }, 3183b591480bSJ.Bruce Fields [OP_NVERIFY] = { 3184eb69853dSChristoph Hellwig .op_func = nfsd4_nverify, 3185b001a1b6SBenny Halevy .op_name = "OP_NVERIFY", 31861c122638SChristoph Hellwig .op_rsize_bop = nfsd4_only_status_rsize, 3187b591480bSJ.Bruce Fields }, 3188b591480bSJ.Bruce Fields [OP_OPEN] = { 3189eb69853dSChristoph Hellwig .op_func = nfsd4_open, 319058e7b33aSMi Jinlong .op_flags = OP_HANDLES_WRONGSEC | OP_MODIFIES_SOMETHING, 3191b001a1b6SBenny Halevy .op_name = "OP_OPEN", 31921c122638SChristoph Hellwig .op_rsize_bop = nfsd4_open_rsize, 3193b60e9859SChristoph Hellwig .op_set_currentstateid = nfsd4_set_openstateid, 3194b591480bSJ.Bruce Fields }, 3195b591480bSJ.Bruce Fields [OP_OPEN_CONFIRM] = { 3196eb69853dSChristoph Hellwig .op_func = nfsd4_open_confirm, 319758e7b33aSMi Jinlong .op_flags = OP_MODIFIES_SOMETHING, 3198b001a1b6SBenny Halevy .op_name = "OP_OPEN_CONFIRM", 31991c122638SChristoph Hellwig .op_rsize_bop = nfsd4_status_stateid_rsize, 3200b591480bSJ.Bruce Fields }, 3201b591480bSJ.Bruce Fields [OP_OPEN_DOWNGRADE] = { 3202eb69853dSChristoph Hellwig .op_func = nfsd4_open_downgrade, 320358e7b33aSMi Jinlong .op_flags = OP_MODIFIES_SOMETHING, 3204b001a1b6SBenny Halevy .op_name = "OP_OPEN_DOWNGRADE", 32051c122638SChristoph Hellwig .op_rsize_bop = nfsd4_status_stateid_rsize, 320657832e7bSChristoph Hellwig .op_get_currentstateid = nfsd4_get_opendowngradestateid, 3207b60e9859SChristoph Hellwig .op_set_currentstateid = nfsd4_set_opendowngradestateid, 3208b591480bSJ.Bruce Fields }, 3209b591480bSJ.Bruce Fields [OP_PUTFH] = { 3210eb69853dSChristoph Hellwig .op_func = nfsd4_putfh, 321168d93184SJ. Bruce Fields .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS 32125b648699SJ. Bruce Fields | OP_IS_PUTFH_LIKE | OP_CLEAR_STATEID, 3213b001a1b6SBenny Halevy .op_name = "OP_PUTFH", 32141c122638SChristoph Hellwig .op_rsize_bop = nfsd4_only_status_rsize, 3215b591480bSJ.Bruce Fields }, 3216eeac294eSJ.Bruce Fields [OP_PUTPUBFH] = { 3217eb69853dSChristoph Hellwig .op_func = nfsd4_putrootfh, 321868d93184SJ. Bruce Fields .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS 32195b648699SJ. Bruce Fields | OP_IS_PUTFH_LIKE | OP_CLEAR_STATEID, 3220b001a1b6SBenny Halevy .op_name = "OP_PUTPUBFH", 32211c122638SChristoph Hellwig .op_rsize_bop = nfsd4_only_status_rsize, 3222eeac294eSJ.Bruce Fields }, 3223b591480bSJ.Bruce Fields [OP_PUTROOTFH] = { 3224eb69853dSChristoph Hellwig .op_func = nfsd4_putrootfh, 322568d93184SJ. Bruce Fields .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS 32265b648699SJ. Bruce Fields | OP_IS_PUTFH_LIKE | OP_CLEAR_STATEID, 3227b001a1b6SBenny Halevy .op_name = "OP_PUTROOTFH", 32281c122638SChristoph Hellwig .op_rsize_bop = nfsd4_only_status_rsize, 3229b591480bSJ.Bruce Fields }, 3230b591480bSJ.Bruce Fields [OP_READ] = { 3231eb69853dSChristoph Hellwig .op_func = nfsd4_read, 323234b1744cSJ. Bruce Fields .op_release = nfsd4_read_release, 3233b001a1b6SBenny Halevy .op_name = "OP_READ", 32341c122638SChristoph Hellwig .op_rsize_bop = nfsd4_read_rsize, 323557832e7bSChristoph Hellwig .op_get_currentstateid = nfsd4_get_readstateid, 3236b591480bSJ.Bruce Fields }, 3237b591480bSJ.Bruce Fields [OP_READDIR] = { 3238eb69853dSChristoph Hellwig .op_func = nfsd4_readdir, 3239b001a1b6SBenny Halevy .op_name = "OP_READDIR", 32401c122638SChristoph Hellwig .op_rsize_bop = nfsd4_readdir_rsize, 3241b591480bSJ.Bruce Fields }, 3242b591480bSJ.Bruce Fields [OP_READLINK] = { 3243eb69853dSChristoph Hellwig .op_func = nfsd4_readlink, 3244b001a1b6SBenny Halevy .op_name = "OP_READLINK", 32451c122638SChristoph Hellwig .op_rsize_bop = nfsd4_readlink_rsize, 3246b591480bSJ.Bruce Fields }, 3247b591480bSJ.Bruce Fields [OP_REMOVE] = { 3248eb69853dSChristoph Hellwig .op_func = nfsd4_remove, 3249c856694eSJ. Bruce Fields .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME, 3250b001a1b6SBenny Halevy .op_name = "OP_REMOVE", 32511c122638SChristoph Hellwig .op_rsize_bop = nfsd4_remove_rsize, 3252b591480bSJ.Bruce Fields }, 3253b591480bSJ.Bruce Fields [OP_RENAME] = { 3254eb69853dSChristoph Hellwig .op_func = nfsd4_rename, 3255c856694eSJ. Bruce Fields .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME, 325658e7b33aSMi Jinlong .op_name = "OP_RENAME", 32571c122638SChristoph Hellwig .op_rsize_bop = nfsd4_rename_rsize, 3258b591480bSJ.Bruce Fields }, 3259b591480bSJ.Bruce Fields [OP_RENEW] = { 3260eb69853dSChristoph Hellwig .op_func = nfsd4_renew, 326158e7b33aSMi Jinlong .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS 326258e7b33aSMi Jinlong | OP_MODIFIES_SOMETHING, 3263b001a1b6SBenny Halevy .op_name = "OP_RENEW", 32641c122638SChristoph Hellwig .op_rsize_bop = nfsd4_only_status_rsize, 326558e7b33aSMi Jinlong 3266b591480bSJ.Bruce Fields }, 3267b591480bSJ.Bruce Fields [OP_RESTOREFH] = { 3268eb69853dSChristoph Hellwig .op_func = nfsd4_restorefh, 326968d93184SJ. Bruce Fields .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS 327058e7b33aSMi Jinlong | OP_IS_PUTFH_LIKE | OP_MODIFIES_SOMETHING, 3271b001a1b6SBenny Halevy .op_name = "OP_RESTOREFH", 32721c122638SChristoph Hellwig .op_rsize_bop = nfsd4_only_status_rsize, 3273b591480bSJ.Bruce Fields }, 3274b591480bSJ.Bruce Fields [OP_SAVEFH] = { 3275eb69853dSChristoph Hellwig .op_func = nfsd4_savefh, 327658e7b33aSMi Jinlong .op_flags = OP_HANDLES_WRONGSEC | OP_MODIFIES_SOMETHING, 3277b001a1b6SBenny Halevy .op_name = "OP_SAVEFH", 32781c122638SChristoph Hellwig .op_rsize_bop = nfsd4_only_status_rsize, 3279b591480bSJ.Bruce Fields }, 3280dcb488a3SAndy Adamson [OP_SECINFO] = { 3281eb69853dSChristoph Hellwig .op_func = nfsd4_secinfo, 328234b1744cSJ. Bruce Fields .op_release = nfsd4_secinfo_release, 328368d93184SJ. Bruce Fields .op_flags = OP_HANDLES_WRONGSEC, 3284b001a1b6SBenny Halevy .op_name = "OP_SECINFO", 32851c122638SChristoph Hellwig .op_rsize_bop = nfsd4_secinfo_rsize, 3286dcb488a3SAndy Adamson }, 3287b591480bSJ.Bruce Fields [OP_SETATTR] = { 3288eb69853dSChristoph Hellwig .op_func = nfsd4_setattr, 3289b001a1b6SBenny Halevy .op_name = "OP_SETATTR", 3290b7571e4cSJ. Bruce Fields .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME 3291b7571e4cSJ. Bruce Fields | OP_NONTRIVIAL_ERROR_ENCODE, 32921c122638SChristoph Hellwig .op_rsize_bop = nfsd4_setattr_rsize, 329357832e7bSChristoph Hellwig .op_get_currentstateid = nfsd4_get_setattrstateid, 3294b591480bSJ.Bruce Fields }, 3295b591480bSJ.Bruce Fields [OP_SETCLIENTID] = { 3296eb69853dSChristoph Hellwig .op_func = nfsd4_setclientid, 329758e7b33aSMi Jinlong .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS 3298b7571e4cSJ. Bruce Fields | OP_MODIFIES_SOMETHING | OP_CACHEME 3299b7571e4cSJ. Bruce Fields | OP_NONTRIVIAL_ERROR_ENCODE, 3300b001a1b6SBenny Halevy .op_name = "OP_SETCLIENTID", 33011c122638SChristoph Hellwig .op_rsize_bop = nfsd4_setclientid_rsize, 3302b591480bSJ.Bruce Fields }, 3303b591480bSJ.Bruce Fields [OP_SETCLIENTID_CONFIRM] = { 3304eb69853dSChristoph Hellwig .op_func = nfsd4_setclientid_confirm, 330558e7b33aSMi Jinlong .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS 3306c856694eSJ. Bruce Fields | OP_MODIFIES_SOMETHING | OP_CACHEME, 3307b001a1b6SBenny Halevy .op_name = "OP_SETCLIENTID_CONFIRM", 33081c122638SChristoph Hellwig .op_rsize_bop = nfsd4_only_status_rsize, 3309b591480bSJ.Bruce Fields }, 3310b591480bSJ.Bruce Fields [OP_VERIFY] = { 3311eb69853dSChristoph Hellwig .op_func = nfsd4_verify, 3312b001a1b6SBenny Halevy .op_name = "OP_VERIFY", 33131c122638SChristoph Hellwig .op_rsize_bop = nfsd4_only_status_rsize, 3314b591480bSJ.Bruce Fields }, 3315b591480bSJ.Bruce Fields [OP_WRITE] = { 3316eb69853dSChristoph Hellwig .op_func = nfsd4_write, 3317c856694eSJ. Bruce Fields .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME, 3318b001a1b6SBenny Halevy .op_name = "OP_WRITE", 33191c122638SChristoph Hellwig .op_rsize_bop = nfsd4_write_rsize, 332057832e7bSChristoph Hellwig .op_get_currentstateid = nfsd4_get_writestateid, 3321b591480bSJ.Bruce Fields }, 3322b591480bSJ.Bruce Fields [OP_RELEASE_LOCKOWNER] = { 3323eb69853dSChristoph Hellwig .op_func = nfsd4_release_lockowner, 332458e7b33aSMi Jinlong .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS 332558e7b33aSMi Jinlong | OP_MODIFIES_SOMETHING, 3326b001a1b6SBenny Halevy .op_name = "OP_RELEASE_LOCKOWNER", 33271c122638SChristoph Hellwig .op_rsize_bop = nfsd4_only_status_rsize, 3328b591480bSJ.Bruce Fields }, 3329069b6ad4SAndy Adamson 3330069b6ad4SAndy Adamson /* NFSv4.1 operations */ 3331069b6ad4SAndy Adamson [OP_EXCHANGE_ID] = { 3332eb69853dSChristoph Hellwig .op_func = nfsd4_exchange_id, 333358e7b33aSMi Jinlong .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP 333458e7b33aSMi Jinlong | OP_MODIFIES_SOMETHING, 3335069b6ad4SAndy Adamson .op_name = "OP_EXCHANGE_ID", 33361c122638SChristoph Hellwig .op_rsize_bop = nfsd4_exchange_id_rsize, 3337069b6ad4SAndy Adamson }, 3338cb73a9f4SJ. Bruce Fields [OP_BACKCHANNEL_CTL] = { 3339eb69853dSChristoph Hellwig .op_func = nfsd4_backchannel_ctl, 3340cb73a9f4SJ. Bruce Fields .op_flags = ALLOWED_WITHOUT_FH | OP_MODIFIES_SOMETHING, 3341cb73a9f4SJ. Bruce Fields .op_name = "OP_BACKCHANNEL_CTL", 33421c122638SChristoph Hellwig .op_rsize_bop = nfsd4_only_status_rsize, 3343cb73a9f4SJ. Bruce Fields }, 33441d1bc8f2SJ. Bruce Fields [OP_BIND_CONN_TO_SESSION] = { 3345eb69853dSChristoph Hellwig .op_func = nfsd4_bind_conn_to_session, 334658e7b33aSMi Jinlong .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP 334758e7b33aSMi Jinlong | OP_MODIFIES_SOMETHING, 33481d1bc8f2SJ. Bruce Fields .op_name = "OP_BIND_CONN_TO_SESSION", 33491c122638SChristoph Hellwig .op_rsize_bop = nfsd4_bind_conn_to_session_rsize, 33501d1bc8f2SJ. Bruce Fields }, 3351069b6ad4SAndy Adamson [OP_CREATE_SESSION] = { 3352eb69853dSChristoph Hellwig .op_func = nfsd4_create_session, 335358e7b33aSMi Jinlong .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP 335458e7b33aSMi Jinlong | OP_MODIFIES_SOMETHING, 3355069b6ad4SAndy Adamson .op_name = "OP_CREATE_SESSION", 33561c122638SChristoph Hellwig .op_rsize_bop = nfsd4_create_session_rsize, 3357069b6ad4SAndy Adamson }, 3358069b6ad4SAndy Adamson [OP_DESTROY_SESSION] = { 3359eb69853dSChristoph Hellwig .op_func = nfsd4_destroy_session, 336058e7b33aSMi Jinlong .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP 336158e7b33aSMi Jinlong | OP_MODIFIES_SOMETHING, 3362069b6ad4SAndy Adamson .op_name = "OP_DESTROY_SESSION", 33631c122638SChristoph Hellwig .op_rsize_bop = nfsd4_only_status_rsize, 3364069b6ad4SAndy Adamson }, 3365069b6ad4SAndy Adamson [OP_SEQUENCE] = { 3366eb69853dSChristoph Hellwig .op_func = nfsd4_sequence, 3367f9bb94c4SAndy Adamson .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP, 3368069b6ad4SAndy Adamson .op_name = "OP_SEQUENCE", 33691c122638SChristoph Hellwig .op_rsize_bop = nfsd4_sequence_rsize, 3370069b6ad4SAndy Adamson }, 3371094b5d74SBenny Halevy [OP_DESTROY_CLIENTID] = { 3372eb69853dSChristoph Hellwig .op_func = nfsd4_destroy_clientid, 337358e7b33aSMi Jinlong .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP 337458e7b33aSMi Jinlong | OP_MODIFIES_SOMETHING, 3375094b5d74SBenny Halevy .op_name = "OP_DESTROY_CLIENTID", 33761c122638SChristoph Hellwig .op_rsize_bop = nfsd4_only_status_rsize, 3377094b5d74SBenny Halevy }, 33784dc6ec00SJ. Bruce Fields [OP_RECLAIM_COMPLETE] = { 3379eb69853dSChristoph Hellwig .op_func = nfsd4_reclaim_complete, 338058e7b33aSMi Jinlong .op_flags = ALLOWED_WITHOUT_FH | OP_MODIFIES_SOMETHING, 33814dc6ec00SJ. Bruce Fields .op_name = "OP_RECLAIM_COMPLETE", 33821c122638SChristoph Hellwig .op_rsize_bop = nfsd4_only_status_rsize, 33834dc6ec00SJ. Bruce Fields }, 338404f4ad16SJ. Bruce Fields [OP_SECINFO_NO_NAME] = { 3385eb69853dSChristoph Hellwig .op_func = nfsd4_secinfo_no_name, 3386ec572b9eSEryu Guan .op_release = nfsd4_secinfo_no_name_release, 338768d93184SJ. Bruce Fields .op_flags = OP_HANDLES_WRONGSEC, 338804f4ad16SJ. Bruce Fields .op_name = "OP_SECINFO_NO_NAME", 33891c122638SChristoph Hellwig .op_rsize_bop = nfsd4_secinfo_rsize, 339004f4ad16SJ. Bruce Fields }, 339117456804SBryan Schumaker [OP_TEST_STATEID] = { 3392eb69853dSChristoph Hellwig .op_func = nfsd4_test_stateid, 339317456804SBryan Schumaker .op_flags = ALLOWED_WITHOUT_FH, 339417456804SBryan Schumaker .op_name = "OP_TEST_STATEID", 33951c122638SChristoph Hellwig .op_rsize_bop = nfsd4_test_stateid_rsize, 339617456804SBryan Schumaker }, 3397e1ca12dfSBryan Schumaker [OP_FREE_STATEID] = { 3398eb69853dSChristoph Hellwig .op_func = nfsd4_free_stateid, 339958e7b33aSMi Jinlong .op_flags = ALLOWED_WITHOUT_FH | OP_MODIFIES_SOMETHING, 3400e1ca12dfSBryan Schumaker .op_name = "OP_FREE_STATEID", 340157832e7bSChristoph Hellwig .op_get_currentstateid = nfsd4_get_freestateid, 34021c122638SChristoph Hellwig .op_rsize_bop = nfsd4_only_status_rsize, 3403e1ca12dfSBryan Schumaker }, 34049cf514ccSChristoph Hellwig #ifdef CONFIG_NFSD_PNFS 34059cf514ccSChristoph Hellwig [OP_GETDEVICEINFO] = { 3406eb69853dSChristoph Hellwig .op_func = nfsd4_getdeviceinfo, 340734b1744cSJ. Bruce Fields .op_release = nfsd4_getdeviceinfo_release, 34089cf514ccSChristoph Hellwig .op_flags = ALLOWED_WITHOUT_FH, 34099cf514ccSChristoph Hellwig .op_name = "OP_GETDEVICEINFO", 34101c122638SChristoph Hellwig .op_rsize_bop = nfsd4_getdeviceinfo_rsize, 34119cf514ccSChristoph Hellwig }, 34129cf514ccSChristoph Hellwig [OP_LAYOUTGET] = { 3413eb69853dSChristoph Hellwig .op_func = nfsd4_layoutget, 341434b1744cSJ. Bruce Fields .op_release = nfsd4_layoutget_release, 34159cf514ccSChristoph Hellwig .op_flags = OP_MODIFIES_SOMETHING, 34169cf514ccSChristoph Hellwig .op_name = "OP_LAYOUTGET", 34171c122638SChristoph Hellwig .op_rsize_bop = nfsd4_layoutget_rsize, 34189cf514ccSChristoph Hellwig }, 34199cf514ccSChristoph Hellwig [OP_LAYOUTCOMMIT] = { 3420eb69853dSChristoph Hellwig .op_func = nfsd4_layoutcommit, 34219cf514ccSChristoph Hellwig .op_flags = OP_MODIFIES_SOMETHING, 34229cf514ccSChristoph Hellwig .op_name = "OP_LAYOUTCOMMIT", 34231c122638SChristoph Hellwig .op_rsize_bop = nfsd4_layoutcommit_rsize, 34249cf514ccSChristoph Hellwig }, 34259cf514ccSChristoph Hellwig [OP_LAYOUTRETURN] = { 3426eb69853dSChristoph Hellwig .op_func = nfsd4_layoutreturn, 34279cf514ccSChristoph Hellwig .op_flags = OP_MODIFIES_SOMETHING, 34289cf514ccSChristoph Hellwig .op_name = "OP_LAYOUTRETURN", 34291c122638SChristoph Hellwig .op_rsize_bop = nfsd4_layoutreturn_rsize, 34309cf514ccSChristoph Hellwig }, 34319cf514ccSChristoph Hellwig #endif /* CONFIG_NFSD_PNFS */ 343224bab491SAnna Schumaker 343324bab491SAnna Schumaker /* NFSv4.2 operations */ 343495d871f0SAnna Schumaker [OP_ALLOCATE] = { 3435eb69853dSChristoph Hellwig .op_func = nfsd4_allocate, 343603b31f48SOlga Kornievskaia .op_flags = OP_MODIFIES_SOMETHING, 343795d871f0SAnna Schumaker .op_name = "OP_ALLOCATE", 34381c122638SChristoph Hellwig .op_rsize_bop = nfsd4_only_status_rsize, 343995d871f0SAnna Schumaker }, 3440b0cb9085SAnna Schumaker [OP_DEALLOCATE] = { 3441eb69853dSChristoph Hellwig .op_func = nfsd4_deallocate, 344203b31f48SOlga Kornievskaia .op_flags = OP_MODIFIES_SOMETHING, 3443b0cb9085SAnna Schumaker .op_name = "OP_DEALLOCATE", 34441c122638SChristoph Hellwig .op_rsize_bop = nfsd4_only_status_rsize, 3445b0cb9085SAnna Schumaker }, 3446ffa0160aSChristoph Hellwig [OP_CLONE] = { 3447eb69853dSChristoph Hellwig .op_func = nfsd4_clone, 344803b31f48SOlga Kornievskaia .op_flags = OP_MODIFIES_SOMETHING, 3449ffa0160aSChristoph Hellwig .op_name = "OP_CLONE", 34501c122638SChristoph Hellwig .op_rsize_bop = nfsd4_only_status_rsize, 3451ffa0160aSChristoph Hellwig }, 345229ae7f9dSAnna Schumaker [OP_COPY] = { 3453eb69853dSChristoph Hellwig .op_func = nfsd4_copy, 345403b31f48SOlga Kornievskaia .op_flags = OP_MODIFIES_SOMETHING, 345529ae7f9dSAnna Schumaker .op_name = "OP_COPY", 34561c122638SChristoph Hellwig .op_rsize_bop = nfsd4_copy_rsize, 345729ae7f9dSAnna Schumaker }, 3458528b8493SAnna Schumaker [OP_READ_PLUS] = { 3459528b8493SAnna Schumaker .op_func = nfsd4_read, 3460528b8493SAnna Schumaker .op_release = nfsd4_read_release, 3461528b8493SAnna Schumaker .op_name = "OP_READ_PLUS", 3462528b8493SAnna Schumaker .op_rsize_bop = nfsd4_read_plus_rsize, 3463528b8493SAnna Schumaker .op_get_currentstateid = nfsd4_get_readstateid, 3464528b8493SAnna Schumaker }, 346524bab491SAnna Schumaker [OP_SEEK] = { 3466eb69853dSChristoph Hellwig .op_func = nfsd4_seek, 346724bab491SAnna Schumaker .op_name = "OP_SEEK", 34681c122638SChristoph Hellwig .op_rsize_bop = nfsd4_seek_rsize, 346924bab491SAnna Schumaker }, 34706308bc98SOlga Kornievskaia [OP_OFFLOAD_STATUS] = { 34716308bc98SOlga Kornievskaia .op_func = nfsd4_offload_status, 34726308bc98SOlga Kornievskaia .op_name = "OP_OFFLOAD_STATUS", 34736308bc98SOlga Kornievskaia .op_rsize_bop = nfsd4_offload_status_rsize, 34746308bc98SOlga Kornievskaia }, 3475885e2bf3SOlga Kornievskaia [OP_OFFLOAD_CANCEL] = { 3476885e2bf3SOlga Kornievskaia .op_func = nfsd4_offload_cancel, 3477885e2bf3SOlga Kornievskaia .op_flags = OP_MODIFIES_SOMETHING, 3478885e2bf3SOlga Kornievskaia .op_name = "OP_OFFLOAD_CANCEL", 3479885e2bf3SOlga Kornievskaia .op_rsize_bop = nfsd4_only_status_rsize, 3480885e2bf3SOlga Kornievskaia }, 348151911868SOlga Kornievskaia [OP_COPY_NOTIFY] = { 348251911868SOlga Kornievskaia .op_func = nfsd4_copy_notify, 348351911868SOlga Kornievskaia .op_flags = OP_MODIFIES_SOMETHING, 348451911868SOlga Kornievskaia .op_name = "OP_COPY_NOTIFY", 348551911868SOlga Kornievskaia .op_rsize_bop = nfsd4_copy_notify_rsize, 348651911868SOlga Kornievskaia }, 348723e50fe3SFrank van der Linden [OP_GETXATTR] = { 348823e50fe3SFrank van der Linden .op_func = nfsd4_getxattr, 348923e50fe3SFrank van der Linden .op_name = "OP_GETXATTR", 349023e50fe3SFrank van der Linden .op_rsize_bop = nfsd4_getxattr_rsize, 349123e50fe3SFrank van der Linden }, 349223e50fe3SFrank van der Linden [OP_SETXATTR] = { 349323e50fe3SFrank van der Linden .op_func = nfsd4_setxattr, 349423e50fe3SFrank van der Linden .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME, 349523e50fe3SFrank van der Linden .op_name = "OP_SETXATTR", 349623e50fe3SFrank van der Linden .op_rsize_bop = nfsd4_setxattr_rsize, 349723e50fe3SFrank van der Linden }, 349823e50fe3SFrank van der Linden [OP_LISTXATTRS] = { 349923e50fe3SFrank van der Linden .op_func = nfsd4_listxattrs, 350023e50fe3SFrank van der Linden .op_name = "OP_LISTXATTRS", 350123e50fe3SFrank van der Linden .op_rsize_bop = nfsd4_listxattrs_rsize, 350223e50fe3SFrank van der Linden }, 350323e50fe3SFrank van der Linden [OP_REMOVEXATTR] = { 350423e50fe3SFrank van der Linden .op_func = nfsd4_removexattr, 350523e50fe3SFrank van der Linden .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME, 350623e50fe3SFrank van der Linden .op_name = "OP_REMOVEXATTR", 350723e50fe3SFrank van der Linden .op_rsize_bop = nfsd4_removexattr_rsize, 350823e50fe3SFrank van der Linden }, 3509b591480bSJ.Bruce Fields }; 3510b591480bSJ.Bruce Fields 3511ed941643SAndrew Elble /** 3512ed941643SAndrew Elble * nfsd4_spo_must_allow - Determine if the compound op contains an 3513ed941643SAndrew Elble * operation that is allowed to be sent with machine credentials 3514ed941643SAndrew Elble * 3515ed941643SAndrew Elble * @rqstp: a pointer to the struct svc_rqst 3516ed941643SAndrew Elble * 3517ed941643SAndrew Elble * Checks to see if the compound contains a spo_must_allow op 3518ed941643SAndrew Elble * and confirms that it was sent with the proper machine creds. 3519ed941643SAndrew Elble */ 3520ed941643SAndrew Elble 3521ed941643SAndrew Elble bool nfsd4_spo_must_allow(struct svc_rqst *rqstp) 3522ed941643SAndrew Elble { 3523ed941643SAndrew Elble struct nfsd4_compoundres *resp = rqstp->rq_resp; 3524ed941643SAndrew Elble struct nfsd4_compoundargs *argp = rqstp->rq_argp; 3525e34c0ce9SColin Ian King struct nfsd4_op *this; 3526ed941643SAndrew Elble struct nfsd4_compound_state *cstate = &resp->cstate; 3527ed941643SAndrew Elble struct nfs4_op_map *allow = &cstate->clp->cl_spo_must_allow; 3528ed941643SAndrew Elble u32 opiter; 3529ed941643SAndrew Elble 3530ed941643SAndrew Elble if (!cstate->minorversion) 3531ed941643SAndrew Elble return false; 3532ed941643SAndrew Elble 353344b49aa6SZheng Bin if (cstate->spo_must_allowed) 3534ed941643SAndrew Elble return true; 3535ed941643SAndrew Elble 3536ed941643SAndrew Elble opiter = resp->opcnt; 3537ed941643SAndrew Elble while (opiter < argp->opcnt) { 3538ed941643SAndrew Elble this = &argp->ops[opiter++]; 3539ed941643SAndrew Elble if (test_bit(this->opnum, allow->u.longs) && 3540ed941643SAndrew Elble cstate->clp->cl_mach_cred && 3541ed941643SAndrew Elble nfsd4_mach_creds_match(cstate->clp, rqstp)) { 3542ed941643SAndrew Elble cstate->spo_must_allowed = true; 3543ed941643SAndrew Elble return true; 3544ed941643SAndrew Elble } 3545ed941643SAndrew Elble } 3546ed941643SAndrew Elble cstate->spo_must_allowed = false; 3547ed941643SAndrew Elble return false; 3548ed941643SAndrew Elble } 3549ed941643SAndrew Elble 35504f0cefbfSJ. Bruce Fields int nfsd4_max_reply(struct svc_rqst *rqstp, struct nfsd4_op *op) 35514f0cefbfSJ. Bruce Fields { 355205b7278dSOlga Kornievskaia if (op->opnum == OP_ILLEGAL || op->status == nfserr_notsupp) 35534f0cefbfSJ. Bruce Fields return op_encode_hdr_size * sizeof(__be32); 35542282cd2cSKinglong Mee 35552282cd2cSKinglong Mee BUG_ON(OPDESC(op)->op_rsize_bop == NULL); 35562282cd2cSKinglong Mee return OPDESC(op)->op_rsize_bop(rqstp, op); 35574f0cefbfSJ. Bruce Fields } 35584f0cefbfSJ. Bruce Fields 355907d1f802SJ. Bruce Fields void warn_on_nonidempotent_op(struct nfsd4_op *op) 356007d1f802SJ. Bruce Fields { 356107d1f802SJ. Bruce Fields if (OPDESC(op)->op_flags & OP_MODIFIES_SOMETHING) { 35623a237b4aSChuck Lever pr_err("unable to encode reply to nonidempotent op %u (%s)\n", 356307d1f802SJ. Bruce Fields op->opnum, nfsd4_op_name(op->opnum)); 356407d1f802SJ. Bruce Fields WARN_ON_ONCE(1); 356507d1f802SJ. Bruce Fields } 356607d1f802SJ. Bruce Fields } 356707d1f802SJ. Bruce Fields 3568f1c7f79bSAdrian Bunk static const char *nfsd4_op_name(unsigned opnum) 3569b001a1b6SBenny Halevy { 3570b001a1b6SBenny Halevy if (opnum < ARRAY_SIZE(nfsd4_ops)) 3571b001a1b6SBenny Halevy return nfsd4_ops[opnum].op_name; 3572b001a1b6SBenny Halevy return "unknown_operation"; 3573b001a1b6SBenny Halevy } 3574b001a1b6SBenny Halevy 3575860bda29SChristoph Hellwig static const struct svc_procedure nfsd_procedures4[2] = { 35760a93a47fSYu Zhiguo [NFSPROC4_NULL] = { 3577f7235b6bSChristoph Hellwig .pc_func = nfsd4_proc_null, 3578788f7183SChuck Lever .pc_decode = nfssvc_decode_voidarg, 3579788f7183SChuck Lever .pc_encode = nfssvc_encode_voidres, 3580788f7183SChuck Lever .pc_argsize = sizeof(struct nfsd_voidargs), 3581788f7183SChuck Lever .pc_ressize = sizeof(struct nfsd_voidres), 35820a93a47fSYu Zhiguo .pc_cachetype = RC_NOCACHE, 35830a93a47fSYu Zhiguo .pc_xdrressize = 1, 35842289e87bSChuck Lever .pc_name = "NULL", 35850a93a47fSYu Zhiguo }, 35860a93a47fSYu Zhiguo [NFSPROC4_COMPOUND] = { 3587f7235b6bSChristoph Hellwig .pc_func = nfsd4_proc_compound, 3588026fec7eSChristoph Hellwig .pc_decode = nfs4svc_decode_compoundargs, 358963f8de37SChristoph Hellwig .pc_encode = nfs4svc_encode_compoundres, 35900a93a47fSYu Zhiguo .pc_argsize = sizeof(struct nfsd4_compoundargs), 35910a93a47fSYu Zhiguo .pc_ressize = sizeof(struct nfsd4_compoundres), 35923e98abffSJ. Bruce Fields .pc_release = nfsd4_release_compoundargs, 35930a93a47fSYu Zhiguo .pc_cachetype = RC_NOCACHE, 35940a93a47fSYu Zhiguo .pc_xdrressize = NFSD_BUFSIZE/4, 35952289e87bSChuck Lever .pc_name = "COMPOUND", 35960a93a47fSYu Zhiguo }, 35971da177e4SLinus Torvalds }; 35981da177e4SLinus Torvalds 35997fd38af9SChristoph Hellwig static unsigned int nfsd_count3[ARRAY_SIZE(nfsd_procedures4)]; 3600e9679189SChristoph Hellwig const struct svc_version nfsd_version4 = { 36011da177e4SLinus Torvalds .vs_vers = 4, 36021da177e4SLinus Torvalds .vs_nproc = 2, 36031da177e4SLinus Torvalds .vs_proc = nfsd_procedures4, 36047fd38af9SChristoph Hellwig .vs_count = nfsd_count3, 36051da177e4SLinus Torvalds .vs_dispatch = nfsd_dispatch, 36061da177e4SLinus Torvalds .vs_xdrsize = NFS4_SVC_XDRSIZE, 360705a45a2dSJeff Layton .vs_rpcb_optnl = true, 36085283b03eSJeff Layton .vs_need_cong_ctrl = true, 36091da177e4SLinus Torvalds }; 3610