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 */ 357e06b7f9SNeilBrown #include <linux/file.h> 36b0cb9085SAnna Schumaker #include <linux/falloc.h> 375a0e3ad6STejun Heo #include <linux/slab.h> 381da177e4SLinus Torvalds 3958e7b33aSMi Jinlong #include "idmap.h" 409a74af21SBoaz Harrosh #include "cache.h" 419a74af21SBoaz Harrosh #include "xdr4.h" 420a3adadeSJ. Bruce Fields #include "vfs.h" 438b70484cSTigran Mkrtchyan #include "current_stateid.h" 443320fef1SStanislav Kinsbursky #include "netns.h" 454ac7249eSChristoph Hellwig #include "acl.h" 469cf514ccSChristoph Hellwig #include "pnfs.h" 4731ef83dcSChristoph Hellwig #include "trace.h" 481da177e4SLinus Torvalds 4918032ca0SDavid Quigley #ifdef CONFIG_NFSD_V4_SECURITY_LABEL 5018032ca0SDavid Quigley #include <linux/security.h> 5118032ca0SDavid Quigley 5218032ca0SDavid Quigley static inline void 5318032ca0SDavid Quigley nfsd4_security_inode_setsecctx(struct svc_fh *resfh, struct xdr_netobj *label, u32 *bmval) 5418032ca0SDavid Quigley { 552b0143b5SDavid Howells struct inode *inode = d_inode(resfh->fh_dentry); 5618032ca0SDavid Quigley int status; 5718032ca0SDavid Quigley 585955102cSAl Viro inode_lock(inode); 5918032ca0SDavid Quigley status = security_inode_setsecctx(resfh->fh_dentry, 6018032ca0SDavid Quigley label->data, label->len); 615955102cSAl Viro inode_unlock(inode); 6218032ca0SDavid Quigley 6318032ca0SDavid Quigley if (status) 6418032ca0SDavid Quigley /* 6518032ca0SDavid Quigley * XXX: We should really fail the whole open, but we may 6618032ca0SDavid Quigley * already have created a new file, so it may be too 6718032ca0SDavid Quigley * late. For now this seems the least of evils: 6818032ca0SDavid Quigley */ 6918032ca0SDavid Quigley bmval[2] &= ~FATTR4_WORD2_SECURITY_LABEL; 7018032ca0SDavid Quigley 7118032ca0SDavid Quigley return; 7218032ca0SDavid Quigley } 7318032ca0SDavid Quigley #else 7418032ca0SDavid Quigley static inline void 7518032ca0SDavid Quigley nfsd4_security_inode_setsecctx(struct svc_fh *resfh, struct xdr_netobj *label, u32 *bmval) 7618032ca0SDavid Quigley { } 7718032ca0SDavid Quigley #endif 7818032ca0SDavid Quigley 791da177e4SLinus Torvalds #define NFSDDBG_FACILITY NFSDDBG_PROC 801da177e4SLinus Torvalds 813c8e0316SYu Zhiguo static u32 nfsd_attrmask[] = { 823c8e0316SYu Zhiguo NFSD_WRITEABLE_ATTRS_WORD0, 833c8e0316SYu Zhiguo NFSD_WRITEABLE_ATTRS_WORD1, 843c8e0316SYu Zhiguo NFSD_WRITEABLE_ATTRS_WORD2 853c8e0316SYu Zhiguo }; 863c8e0316SYu Zhiguo 873c8e0316SYu Zhiguo static u32 nfsd41_ex_attrmask[] = { 883c8e0316SYu Zhiguo NFSD_SUPPATTR_EXCLCREAT_WORD0, 893c8e0316SYu Zhiguo NFSD_SUPPATTR_EXCLCREAT_WORD1, 903c8e0316SYu Zhiguo NFSD_SUPPATTR_EXCLCREAT_WORD2 913c8e0316SYu Zhiguo }; 923c8e0316SYu Zhiguo 933c8e0316SYu Zhiguo static __be32 943c8e0316SYu Zhiguo check_attr_support(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 953c8e0316SYu Zhiguo u32 *bmval, u32 *writable) 963c8e0316SYu Zhiguo { 973c8e0316SYu Zhiguo struct dentry *dentry = cstate->current_fh.fh_dentry; 983c8e0316SYu Zhiguo 99916d2d84SJ. Bruce Fields if (!nfsd_attrs_supported(cstate->minorversion, bmval)) 1003c8e0316SYu Zhiguo return nfserr_attrnotsupp; 101916d2d84SJ. Bruce Fields if ((bmval[0] & FATTR4_WORD0_ACL) && !IS_POSIXACL(d_inode(dentry))) 1023c8e0316SYu Zhiguo return nfserr_attrnotsupp; 103916d2d84SJ. Bruce Fields if (writable && !bmval_is_subset(bmval, writable)) 1043c8e0316SYu Zhiguo return nfserr_inval; 10547057abdSAndreas Gruenbacher if (writable && (bmval[2] & FATTR4_WORD2_MODE_UMASK) && 10647057abdSAndreas Gruenbacher (bmval[1] & FATTR4_WORD1_MODE)) 10747057abdSAndreas Gruenbacher return nfserr_inval; 1083c8e0316SYu Zhiguo return nfs_ok; 1093c8e0316SYu Zhiguo } 1103c8e0316SYu Zhiguo 1113c8e0316SYu Zhiguo static __be32 1123c8e0316SYu Zhiguo nfsd4_check_open_attributes(struct svc_rqst *rqstp, 1133c8e0316SYu Zhiguo struct nfsd4_compound_state *cstate, struct nfsd4_open *open) 1143c8e0316SYu Zhiguo { 1153c8e0316SYu Zhiguo __be32 status = nfs_ok; 1163c8e0316SYu Zhiguo 1173c8e0316SYu Zhiguo if (open->op_create == NFS4_OPEN_CREATE) { 1183c8e0316SYu Zhiguo if (open->op_createmode == NFS4_CREATE_UNCHECKED 1193c8e0316SYu Zhiguo || open->op_createmode == NFS4_CREATE_GUARDED) 1203c8e0316SYu Zhiguo status = check_attr_support(rqstp, cstate, 1213c8e0316SYu Zhiguo open->op_bmval, nfsd_attrmask); 1223c8e0316SYu Zhiguo else if (open->op_createmode == NFS4_CREATE_EXCLUSIVE4_1) 1233c8e0316SYu Zhiguo status = check_attr_support(rqstp, cstate, 1243c8e0316SYu Zhiguo open->op_bmval, nfsd41_ex_attrmask); 1253c8e0316SYu Zhiguo } 1263c8e0316SYu Zhiguo 1273c8e0316SYu Zhiguo return status; 1283c8e0316SYu Zhiguo } 1293c8e0316SYu Zhiguo 1309208faf2SYu Zhiguo static int 1319208faf2SYu Zhiguo is_create_with_attrs(struct nfsd4_open *open) 1329208faf2SYu Zhiguo { 1339208faf2SYu Zhiguo return open->op_create == NFS4_OPEN_CREATE 1349208faf2SYu Zhiguo && (open->op_createmode == NFS4_CREATE_UNCHECKED 1359208faf2SYu Zhiguo || open->op_createmode == NFS4_CREATE_GUARDED 1369208faf2SYu Zhiguo || open->op_createmode == NFS4_CREATE_EXCLUSIVE4_1); 1379208faf2SYu Zhiguo } 1389208faf2SYu Zhiguo 1399208faf2SYu Zhiguo /* 1409208faf2SYu Zhiguo * if error occurs when setting the acl, just clear the acl bit 1419208faf2SYu Zhiguo * in the returned attr bitmap. 1429208faf2SYu Zhiguo */ 1439208faf2SYu Zhiguo static void 1449208faf2SYu Zhiguo do_set_nfs4_acl(struct svc_rqst *rqstp, struct svc_fh *fhp, 1459208faf2SYu Zhiguo struct nfs4_acl *acl, u32 *bmval) 1469208faf2SYu Zhiguo { 1479208faf2SYu Zhiguo __be32 status; 1489208faf2SYu Zhiguo 1499208faf2SYu Zhiguo status = nfsd4_set_nfs4_acl(rqstp, fhp, acl); 1509208faf2SYu Zhiguo if (status) 1519208faf2SYu Zhiguo /* 1529208faf2SYu Zhiguo * We should probably fail the whole open at this point, 1539208faf2SYu Zhiguo * but we've already created the file, so it's too late; 1549208faf2SYu Zhiguo * So this seems the least of evils: 1559208faf2SYu Zhiguo */ 1569208faf2SYu Zhiguo bmval[0] &= ~FATTR4_WORD0_ACL; 1579208faf2SYu Zhiguo } 1589208faf2SYu Zhiguo 1591da177e4SLinus Torvalds static inline void 1601da177e4SLinus Torvalds fh_dup2(struct svc_fh *dst, struct svc_fh *src) 1611da177e4SLinus Torvalds { 1621da177e4SLinus Torvalds fh_put(dst); 1631da177e4SLinus Torvalds dget(src->fh_dentry); 1641da177e4SLinus Torvalds if (src->fh_export) 165bf18f163SKinglong Mee exp_get(src->fh_export); 1661da177e4SLinus Torvalds *dst = *src; 1671da177e4SLinus Torvalds } 1681da177e4SLinus Torvalds 169b37ad28bSAl Viro static __be32 170dc730e17SJ. Bruce Fields do_open_permission(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open, int accmode) 1711da177e4SLinus Torvalds { 172b37ad28bSAl Viro __be32 status; 1731da177e4SLinus Torvalds 1741da177e4SLinus Torvalds if (open->op_truncate && 1751da177e4SLinus Torvalds !(open->op_share_access & NFS4_SHARE_ACCESS_WRITE)) 1761da177e4SLinus Torvalds return nfserr_inval; 1771da177e4SLinus Torvalds 178a043226bSJ. Bruce Fields accmode |= NFSD_MAY_READ_IF_EXEC; 179a043226bSJ. Bruce Fields 1801da177e4SLinus Torvalds if (open->op_share_access & NFS4_SHARE_ACCESS_READ) 1818837abcaSMiklos Szeredi accmode |= NFSD_MAY_READ; 1829801d8a3SJ. Bruce Fields if (open->op_share_access & NFS4_SHARE_ACCESS_WRITE) 1838837abcaSMiklos Szeredi accmode |= (NFSD_MAY_WRITE | NFSD_MAY_TRUNC); 18457ecb34fSJ. Bruce Fields if (open->op_share_deny & NFS4_SHARE_DENY_READ) 1858837abcaSMiklos Szeredi accmode |= NFSD_MAY_WRITE; 1861da177e4SLinus Torvalds 1871da177e4SLinus Torvalds status = fh_verify(rqstp, current_fh, S_IFREG, accmode); 1881da177e4SLinus Torvalds 1891da177e4SLinus Torvalds return status; 1901da177e4SLinus Torvalds } 1911da177e4SLinus Torvalds 192aadab6c6SJ. Bruce Fields static __be32 nfsd_check_obj_isreg(struct svc_fh *fh) 193aadab6c6SJ. Bruce Fields { 1942b0143b5SDavid Howells umode_t mode = d_inode(fh->fh_dentry)->i_mode; 195aadab6c6SJ. Bruce Fields 196aadab6c6SJ. Bruce Fields if (S_ISREG(mode)) 197aadab6c6SJ. Bruce Fields return nfs_ok; 198aadab6c6SJ. Bruce Fields if (S_ISDIR(mode)) 199aadab6c6SJ. Bruce Fields return nfserr_isdir; 200aadab6c6SJ. Bruce Fields /* 201aadab6c6SJ. Bruce Fields * Using err_symlink as our catch-all case may look odd; but 202aadab6c6SJ. Bruce Fields * there's no other obvious error for this case in 4.0, and we 203aadab6c6SJ. Bruce Fields * happen to know that it will cause the linux v4 client to do 204aadab6c6SJ. Bruce Fields * the right thing on attempts to open something other than a 205aadab6c6SJ. Bruce Fields * regular file. 206aadab6c6SJ. Bruce Fields */ 207aadab6c6SJ. Bruce Fields return nfserr_symlink; 208aadab6c6SJ. Bruce Fields } 209aadab6c6SJ. Bruce Fields 210bbc9c36cSJ. Bruce Fields static void nfsd4_set_open_owner_reply_cache(struct nfsd4_compound_state *cstate, struct nfsd4_open *open, struct svc_fh *resfh) 2111da177e4SLinus Torvalds { 212bbc9c36cSJ. Bruce Fields if (nfsd4_has_session(cstate)) 213bbc9c36cSJ. Bruce Fields return; 214bbc9c36cSJ. Bruce Fields fh_copy_shallow(&open->op_openowner->oo_owner.so_replay.rp_openfh, 215bbc9c36cSJ. Bruce Fields &resfh->fh_handle); 216bbc9c36cSJ. Bruce Fields } 217bbc9c36cSJ. Bruce Fields 218bbc9c36cSJ. Bruce Fields static __be32 219c0e6bee4SJ. Bruce Fields do_open_lookup(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_open *open, struct svc_fh **resfh) 220bbc9c36cSJ. Bruce Fields { 221bbc9c36cSJ. Bruce Fields struct svc_fh *current_fh = &cstate->current_fh; 2227007c90fSNeil Brown int accmode; 223b37ad28bSAl Viro __be32 status; 2241da177e4SLinus Torvalds 225c0e6bee4SJ. Bruce Fields *resfh = kmalloc(sizeof(struct svc_fh), GFP_KERNEL); 226c0e6bee4SJ. Bruce Fields if (!*resfh) 22759deeb9eSJ. Bruce Fields return nfserr_jukebox; 228c0e6bee4SJ. Bruce Fields fh_init(*resfh, NFS4_FHSIZE); 2291da177e4SLinus Torvalds open->op_truncate = 0; 2301da177e4SLinus Torvalds 2311da177e4SLinus Torvalds if (open->op_create) { 23279fb54abSBenny Halevy /* FIXME: check session persistence and pnfs flags. 23379fb54abSBenny Halevy * The nfsv4.1 spec requires the following semantics: 23479fb54abSBenny Halevy * 23579fb54abSBenny Halevy * Persistent | pNFS | Server REQUIRED | Client Allowed 23679fb54abSBenny Halevy * Reply Cache | server | | 23779fb54abSBenny Halevy * -------------+--------+-----------------+-------------------- 23879fb54abSBenny Halevy * no | no | EXCLUSIVE4_1 | EXCLUSIVE4_1 23979fb54abSBenny Halevy * | | | (SHOULD) 24079fb54abSBenny Halevy * | | and EXCLUSIVE4 | or EXCLUSIVE4 24179fb54abSBenny Halevy * | | | (SHOULD NOT) 24279fb54abSBenny Halevy * no | yes | EXCLUSIVE4_1 | EXCLUSIVE4_1 24379fb54abSBenny Halevy * yes | no | GUARDED4 | GUARDED4 24479fb54abSBenny Halevy * yes | yes | GUARDED4 | GUARDED4 24579fb54abSBenny Halevy */ 24679fb54abSBenny Halevy 2471da177e4SLinus Torvalds /* 2481da177e4SLinus Torvalds * Note: create modes (UNCHECKED,GUARDED...) are the same 249ac6721a1SMi Jinlong * in NFSv4 as in v3 except EXCLUSIVE4_1. 2501da177e4SLinus Torvalds */ 251ac6721a1SMi Jinlong status = do_nfsd_create(rqstp, current_fh, open->op_fname.data, 2521da177e4SLinus Torvalds open->op_fname.len, &open->op_iattr, 253c0e6bee4SJ. Bruce Fields *resfh, open->op_createmode, 254749997e5SJeff Layton (u32 *)open->op_verf.data, 255856121b2SJ. Bruce Fields &open->op_truncate, &open->op_created); 256749997e5SJeff Layton 25718032ca0SDavid Quigley if (!status && open->op_label.len) 258c0e6bee4SJ. Bruce Fields nfsd4_security_inode_setsecctx(*resfh, &open->op_label, open->op_bmval); 25918032ca0SDavid Quigley 26099f88726SJ. Bruce Fields /* 261ead8fb8cSKinglong Mee * Following rfc 3530 14.2.16, and rfc 5661 18.16.4 262ead8fb8cSKinglong Mee * use the returned bitmask to indicate which attributes 263ead8fb8cSKinglong Mee * we used to store the verifier: 264749997e5SJeff Layton */ 265ead8fb8cSKinglong Mee if (nfsd_create_is_exclusive(open->op_createmode) && status == 0) 266ead8fb8cSKinglong Mee open->op_bmval[1] |= (FATTR4_WORD1_TIME_ACCESS | 267749997e5SJeff Layton FATTR4_WORD1_TIME_MODIFY); 2684335723eSJ. Bruce Fields } else 2694335723eSJ. Bruce Fields /* 2704335723eSJ. Bruce Fields * Note this may exit with the parent still locked. 2714335723eSJ. Bruce Fields * We will hold the lock until nfsd4_open's final 2724335723eSJ. Bruce Fields * lookup, to prevent renames or unlinks until we've had 2734335723eSJ. Bruce Fields * a chance to an acquire a delegation if appropriate. 2744335723eSJ. Bruce Fields */ 2751da177e4SLinus Torvalds status = nfsd_lookup(rqstp, current_fh, 276c0e6bee4SJ. Bruce Fields open->op_fname.data, open->op_fname.len, *resfh); 277aadab6c6SJ. Bruce Fields if (status) 278aadab6c6SJ. Bruce Fields goto out; 279c0e6bee4SJ. Bruce Fields status = nfsd_check_obj_isreg(*resfh); 280af85852dSJ. Bruce Fields if (status) 281af85852dSJ. Bruce Fields goto out; 2821da177e4SLinus Torvalds 2839208faf2SYu Zhiguo if (is_create_with_attrs(open) && open->op_acl != NULL) 284c0e6bee4SJ. Bruce Fields do_set_nfs4_acl(rqstp, *resfh, open->op_acl, open->op_bmval); 2859208faf2SYu Zhiguo 286c0e6bee4SJ. Bruce Fields nfsd4_set_open_owner_reply_cache(cstate, open, *resfh); 2877007c90fSNeil Brown accmode = NFSD_MAY_NOP; 28889f6c336SJ. Bruce Fields if (open->op_created || 28989f6c336SJ. Bruce Fields open->op_claim_type == NFS4_OPEN_CLAIM_DELEGATE_CUR) 2907007c90fSNeil Brown accmode |= NFSD_MAY_OWNER_OVERRIDE; 291c0e6bee4SJ. Bruce Fields status = do_open_permission(rqstp, *resfh, open, accmode); 29241fd1e42SJ. Bruce Fields set_change_info(&open->op_cinfo, current_fh); 293af85852dSJ. Bruce Fields out: 2941da177e4SLinus Torvalds return status; 2951da177e4SLinus Torvalds } 2961da177e4SLinus Torvalds 297b37ad28bSAl Viro static __be32 298bbc9c36cSJ. Bruce Fields do_open_fhandle(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_open *open) 2991da177e4SLinus Torvalds { 300bbc9c36cSJ. Bruce Fields struct svc_fh *current_fh = &cstate->current_fh; 301b37ad28bSAl Viro __be32 status; 3029f415eb2SJ. Bruce Fields int accmode = 0; 3031da177e4SLinus Torvalds 3041da177e4SLinus Torvalds /* We don't know the target directory, and therefore can not 3051da177e4SLinus Torvalds * set the change info 3061da177e4SLinus Torvalds */ 3071da177e4SLinus Torvalds 3081da177e4SLinus Torvalds memset(&open->op_cinfo, 0, sizeof(struct nfsd4_change_info)); 3091da177e4SLinus Torvalds 310bbc9c36cSJ. Bruce Fields nfsd4_set_open_owner_reply_cache(cstate, open, current_fh); 3111da177e4SLinus Torvalds 3121da177e4SLinus Torvalds open->op_truncate = (open->op_iattr.ia_valid & ATTR_SIZE) && 3131da177e4SLinus Torvalds (open->op_iattr.ia_size == 0); 3149f415eb2SJ. Bruce Fields /* 3159f415eb2SJ. Bruce Fields * In the delegation case, the client is telling us about an 3169f415eb2SJ. Bruce Fields * open that it *already* performed locally, some time ago. We 3179f415eb2SJ. Bruce Fields * should let it succeed now if possible. 3189f415eb2SJ. Bruce Fields * 3199f415eb2SJ. Bruce Fields * In the case of a CLAIM_FH open, on the other hand, the client 3209f415eb2SJ. Bruce Fields * may be counting on us to enforce permissions (the Linux 4.1 3219f415eb2SJ. Bruce Fields * client uses this for normal opens, for example). 3229f415eb2SJ. Bruce Fields */ 3239f415eb2SJ. Bruce Fields if (open->op_claim_type == NFS4_OPEN_CLAIM_DELEG_CUR_FH) 3249f415eb2SJ. Bruce Fields accmode = NFSD_MAY_OWNER_OVERRIDE; 3251da177e4SLinus Torvalds 3269f415eb2SJ. Bruce Fields status = do_open_permission(rqstp, current_fh, open, accmode); 3271da177e4SLinus Torvalds 3281da177e4SLinus Torvalds return status; 3291da177e4SLinus Torvalds } 3301da177e4SLinus Torvalds 33160adfc50SAndy Adamson static void 33260adfc50SAndy Adamson copy_clientid(clientid_t *clid, struct nfsd4_session *session) 33360adfc50SAndy Adamson { 33460adfc50SAndy Adamson struct nfsd4_sessionid *sid = 33560adfc50SAndy Adamson (struct nfsd4_sessionid *)session->se_sessionid.data; 33660adfc50SAndy Adamson 33760adfc50SAndy Adamson clid->cl_boot = sid->clientid.cl_boot; 33860adfc50SAndy Adamson clid->cl_id = sid->clientid.cl_id; 33960adfc50SAndy Adamson } 3401da177e4SLinus Torvalds 3417191155bSJ.Bruce Fields static __be32 342ca364317SJ.Bruce Fields nfsd4_open(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 343a4f1706aSJ.Bruce Fields struct nfsd4_open *open) 3441da177e4SLinus Torvalds { 345b37ad28bSAl Viro __be32 status; 346c0e6bee4SJ. Bruce Fields struct svc_fh *resfh = NULL; 3473320fef1SStanislav Kinsbursky struct net *net = SVC_NET(rqstp); 3483320fef1SStanislav Kinsbursky struct nfsd_net *nn = net_generic(net, nfsd_net_id); 3496668958fSAndy Adamson 350fe0750e5SJ. Bruce Fields dprintk("NFSD: nfsd4_open filename %.*s op_openowner %p\n", 3511da177e4SLinus Torvalds (int)open->op_fname.len, open->op_fname.data, 352fe0750e5SJ. Bruce Fields open->op_openowner); 3531da177e4SLinus Torvalds 3541da177e4SLinus Torvalds /* This check required by spec. */ 3551da177e4SLinus Torvalds if (open->op_create && open->op_claim_type != NFS4_OPEN_CLAIM_NULL) 3561da177e4SLinus Torvalds return nfserr_inval; 3571da177e4SLinus Torvalds 358856121b2SJ. Bruce Fields open->op_created = 0; 359ab1350b2SMi Jinlong /* 360ab1350b2SMi Jinlong * RFC5661 18.51.3 361ab1350b2SMi Jinlong * Before RECLAIM_COMPLETE done, server should deny new lock 362ab1350b2SMi Jinlong */ 363ab1350b2SMi Jinlong if (nfsd4_has_session(cstate) && 364a52d726bSJeff Layton !test_bit(NFSD4_CLIENT_RECLAIM_COMPLETE, 365a52d726bSJeff Layton &cstate->session->se_client->cl_flags) && 366ab1350b2SMi Jinlong open->op_claim_type != NFS4_OPEN_CLAIM_PREVIOUS) 367ab1350b2SMi Jinlong return nfserr_grace; 368ab1350b2SMi Jinlong 36960adfc50SAndy Adamson if (nfsd4_has_session(cstate)) 37060adfc50SAndy Adamson copy_clientid(&open->op_clientid, cstate->session); 37160adfc50SAndy Adamson 3721da177e4SLinus Torvalds /* check seqid for replay. set nfs4_owner */ 3736cd22668SKinglong Mee status = nfsd4_process_open1(cstate, open, nn); 374a90b061cSAl Viro if (status == nfserr_replay_me) { 375fe0750e5SJ. Bruce Fields struct nfs4_replay *rp = &open->op_openowner->oo_owner.so_replay; 376ca364317SJ.Bruce Fields fh_put(&cstate->current_fh); 377a4773c08SJ. Bruce Fields fh_copy_shallow(&cstate->current_fh.fh_handle, 378a4773c08SJ. Bruce Fields &rp->rp_openfh); 3798837abcaSMiklos Szeredi status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP); 3801da177e4SLinus Torvalds if (status) 3811da177e4SLinus Torvalds dprintk("nfsd4_open: replay failed" 3821da177e4SLinus Torvalds " restoring previous filehandle\n"); 3831da177e4SLinus Torvalds else 384a90b061cSAl Viro status = nfserr_replay_me; 3851da177e4SLinus Torvalds } 3861da177e4SLinus Torvalds if (status) 3871da177e4SLinus Torvalds goto out; 3889d313b17SJ. Bruce Fields if (open->op_xdr_error) { 3899d313b17SJ. Bruce Fields status = open->op_xdr_error; 3909d313b17SJ. Bruce Fields goto out; 3919d313b17SJ. Bruce Fields } 392fb553c0fSJ. Bruce Fields 3933c8e0316SYu Zhiguo status = nfsd4_check_open_attributes(rqstp, cstate, open); 3943c8e0316SYu Zhiguo if (status) 3953c8e0316SYu Zhiguo goto out; 3963c8e0316SYu Zhiguo 397fb553c0fSJ. Bruce Fields /* Openowner is now set, so sequence id will get bumped. Now we need 398fb553c0fSJ. Bruce Fields * these checks before we do any creates: */ 399cbd0d51aSJ. Bruce Fields status = nfserr_grace; 400c87fb4a3SJ. Bruce Fields if (opens_in_grace(net) && open->op_claim_type != NFS4_OPEN_CLAIM_PREVIOUS) 401cbd0d51aSJ. Bruce Fields goto out; 402cbd0d51aSJ. Bruce Fields status = nfserr_no_grace; 403c87fb4a3SJ. Bruce Fields if (!opens_in_grace(net) && open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS) 404cbd0d51aSJ. Bruce Fields goto out; 405fb553c0fSJ. Bruce Fields 4061da177e4SLinus Torvalds switch (open->op_claim_type) { 4070dd3c192SNeilBrown case NFS4_OPEN_CLAIM_DELEGATE_CUR: 4081da177e4SLinus Torvalds case NFS4_OPEN_CLAIM_NULL: 409c0e6bee4SJ. Bruce Fields status = do_open_lookup(rqstp, cstate, open, &resfh); 4101da177e4SLinus Torvalds if (status) 4111da177e4SLinus Torvalds goto out; 4121da177e4SLinus Torvalds break; 4131da177e4SLinus Torvalds case NFS4_OPEN_CLAIM_PREVIOUS: 4143320fef1SStanislav Kinsbursky status = nfs4_check_open_reclaim(&open->op_clientid, 4150fe492dbSTrond Myklebust cstate, nn); 4160cf99b91SMi Jinlong if (status) 4170cf99b91SMi Jinlong goto out; 418ba5378b6SJeff Layton open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED; 4198b289b2cSJ. Bruce Fields case NFS4_OPEN_CLAIM_FH: 4208b289b2cSJ. Bruce Fields case NFS4_OPEN_CLAIM_DELEG_CUR_FH: 421bbc9c36cSJ. Bruce Fields status = do_open_fhandle(rqstp, cstate, open); 4221da177e4SLinus Torvalds if (status) 4231da177e4SLinus Torvalds goto out; 424c0e6bee4SJ. Bruce Fields resfh = &cstate->current_fh; 4251da177e4SLinus Torvalds break; 4268b289b2cSJ. Bruce Fields case NFS4_OPEN_CLAIM_DELEG_PREV_FH: 4271da177e4SLinus Torvalds case NFS4_OPEN_CLAIM_DELEGATE_PREV: 4282fdada03SJ. Bruce Fields dprintk("NFSD: unsupported OPEN claim type %d\n", 4291da177e4SLinus Torvalds open->op_claim_type); 4301da177e4SLinus Torvalds status = nfserr_notsupp; 4311da177e4SLinus Torvalds goto out; 4321da177e4SLinus Torvalds default: 4332fdada03SJ. Bruce Fields dprintk("NFSD: Invalid OPEN claim type %d\n", 4341da177e4SLinus Torvalds open->op_claim_type); 4351da177e4SLinus Torvalds status = nfserr_inval; 4361da177e4SLinus Torvalds goto out; 4371da177e4SLinus Torvalds } 4381da177e4SLinus Torvalds /* 4391da177e4SLinus Torvalds * nfsd4_process_open2() does the actual opening of the file. If 4401da177e4SLinus Torvalds * successful, it (1) truncates the file if open->op_truncate was 4411da177e4SLinus Torvalds * set, (2) sets open->op_stateid, (3) sets open->op_delegation. 4421da177e4SLinus Torvalds */ 443c0e6bee4SJ. Bruce Fields status = nfsd4_process_open2(rqstp, resfh, open); 444b3fbfe0eSJeff Layton WARN(status && open->op_created, 445b3fbfe0eSJeff Layton "nfsd4_process_open2 failed to open newly-created file! status=%u\n", 446b3fbfe0eSJeff Layton be32_to_cpu(status)); 4471da177e4SLinus Torvalds out: 448c0e6bee4SJ. Bruce Fields if (resfh && resfh != &cstate->current_fh) { 449c0e6bee4SJ. Bruce Fields fh_dup2(&cstate->current_fh, resfh); 450c0e6bee4SJ. Bruce Fields fh_put(resfh); 451c0e6bee4SJ. Bruce Fields kfree(resfh); 452c0e6bee4SJ. Bruce Fields } 45342297899SJeff Layton nfsd4_cleanup_open_state(cstate, open); 4549411b1d4SJ. Bruce Fields nfsd4_bump_seqid(cstate, status); 4551da177e4SLinus Torvalds return status; 4561da177e4SLinus Torvalds } 4571da177e4SLinus Torvalds 4581da177e4SLinus Torvalds /* 4599d313b17SJ. Bruce Fields * OPEN is the only seqid-mutating operation whose decoding can fail 4609d313b17SJ. Bruce Fields * with a seqid-mutating error (specifically, decoding of user names in 4619d313b17SJ. Bruce Fields * the attributes). Therefore we have to do some processing to look up 4629d313b17SJ. Bruce Fields * the stateowner so that we can bump the seqid. 4639d313b17SJ. Bruce Fields */ 4649d313b17SJ. Bruce Fields static __be32 nfsd4_open_omfg(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_op *op) 4659d313b17SJ. Bruce Fields { 4669d313b17SJ. Bruce Fields struct nfsd4_open *open = (struct nfsd4_open *)&op->u; 4679d313b17SJ. Bruce Fields 4689d313b17SJ. Bruce Fields if (!seqid_mutating_err(ntohl(op->status))) 4699d313b17SJ. Bruce Fields return op->status; 4709d313b17SJ. Bruce Fields if (nfsd4_has_session(cstate)) 4719d313b17SJ. Bruce Fields return op->status; 4729d313b17SJ. Bruce Fields open->op_xdr_error = op->status; 4739d313b17SJ. Bruce Fields return nfsd4_open(rqstp, cstate, open); 4749d313b17SJ. Bruce Fields } 4759d313b17SJ. Bruce Fields 4769d313b17SJ. Bruce Fields /* 4771da177e4SLinus Torvalds * filehandle-manipulating ops. 4781da177e4SLinus Torvalds */ 4797191155bSJ.Bruce Fields static __be32 480b591480bSJ.Bruce Fields nfsd4_getfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 481b591480bSJ.Bruce Fields struct svc_fh **getfh) 4821da177e4SLinus Torvalds { 483ca364317SJ.Bruce Fields if (!cstate->current_fh.fh_dentry) 4841da177e4SLinus Torvalds return nfserr_nofilehandle; 4851da177e4SLinus Torvalds 486ca364317SJ.Bruce Fields *getfh = &cstate->current_fh; 4871da177e4SLinus Torvalds return nfs_ok; 4881da177e4SLinus Torvalds } 4891da177e4SLinus Torvalds 4907191155bSJ.Bruce Fields static __be32 491ca364317SJ.Bruce Fields nfsd4_putfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 492ca364317SJ.Bruce Fields struct nfsd4_putfh *putfh) 4931da177e4SLinus Torvalds { 494ca364317SJ.Bruce Fields fh_put(&cstate->current_fh); 495ca364317SJ.Bruce Fields cstate->current_fh.fh_handle.fh_size = putfh->pf_fhlen; 496ca364317SJ.Bruce Fields memcpy(&cstate->current_fh.fh_handle.fh_base, putfh->pf_fhval, 497ca364317SJ.Bruce Fields putfh->pf_fhlen); 49868d93184SJ. Bruce Fields return fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_BYPASS_GSS); 4991da177e4SLinus Torvalds } 5001da177e4SLinus Torvalds 5017191155bSJ.Bruce Fields static __be32 502b591480bSJ.Bruce Fields nfsd4_putrootfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 503b591480bSJ.Bruce Fields void *arg) 5041da177e4SLinus Torvalds { 505b37ad28bSAl Viro __be32 status; 5061da177e4SLinus Torvalds 507ca364317SJ.Bruce Fields fh_put(&cstate->current_fh); 508df547efbSJ. Bruce Fields status = exp_pseudoroot(rqstp, &cstate->current_fh); 5091da177e4SLinus Torvalds return status; 5101da177e4SLinus Torvalds } 5111da177e4SLinus Torvalds 5127191155bSJ.Bruce Fields static __be32 513b591480bSJ.Bruce Fields nfsd4_restorefh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 514b591480bSJ.Bruce Fields void *arg) 5151da177e4SLinus Torvalds { 516ca364317SJ.Bruce Fields if (!cstate->save_fh.fh_dentry) 5171da177e4SLinus Torvalds return nfserr_restorefh; 5181da177e4SLinus Torvalds 519ca364317SJ.Bruce Fields fh_dup2(&cstate->current_fh, &cstate->save_fh); 52037c593c5STigran Mkrtchyan if (HAS_STATE_ID(cstate, SAVED_STATE_ID_FLAG)) { 52137c593c5STigran Mkrtchyan memcpy(&cstate->current_stateid, &cstate->save_stateid, sizeof(stateid_t)); 52237c593c5STigran Mkrtchyan SET_STATE_ID(cstate, CURRENT_STATE_ID_FLAG); 52337c593c5STigran Mkrtchyan } 5241da177e4SLinus Torvalds return nfs_ok; 5251da177e4SLinus Torvalds } 5261da177e4SLinus Torvalds 5277191155bSJ.Bruce Fields static __be32 528b591480bSJ.Bruce Fields nfsd4_savefh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 529b591480bSJ.Bruce Fields void *arg) 5301da177e4SLinus Torvalds { 531ca364317SJ.Bruce Fields if (!cstate->current_fh.fh_dentry) 5321da177e4SLinus Torvalds return nfserr_nofilehandle; 5331da177e4SLinus Torvalds 534ca364317SJ.Bruce Fields fh_dup2(&cstate->save_fh, &cstate->current_fh); 53537c593c5STigran Mkrtchyan if (HAS_STATE_ID(cstate, CURRENT_STATE_ID_FLAG)) { 53637c593c5STigran Mkrtchyan memcpy(&cstate->save_stateid, &cstate->current_stateid, sizeof(stateid_t)); 53737c593c5STigran Mkrtchyan SET_STATE_ID(cstate, SAVED_STATE_ID_FLAG); 53837c593c5STigran Mkrtchyan } 5391da177e4SLinus Torvalds return nfs_ok; 5401da177e4SLinus Torvalds } 5411da177e4SLinus Torvalds 5421da177e4SLinus Torvalds /* 5431da177e4SLinus Torvalds * misc nfsv4 ops 5441da177e4SLinus Torvalds */ 5457191155bSJ.Bruce Fields static __be32 546ca364317SJ.Bruce Fields nfsd4_access(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 547ca364317SJ.Bruce Fields struct nfsd4_access *access) 5481da177e4SLinus Torvalds { 5491da177e4SLinus Torvalds if (access->ac_req_access & ~NFS3_ACCESS_FULL) 5501da177e4SLinus Torvalds return nfserr_inval; 5511da177e4SLinus Torvalds 5521da177e4SLinus Torvalds access->ac_resp_access = access->ac_req_access; 553ca364317SJ.Bruce Fields return nfsd_access(rqstp, &cstate->current_fh, &access->ac_resp_access, 554ca364317SJ.Bruce Fields &access->ac_supported); 5551da177e4SLinus Torvalds } 5561da177e4SLinus Torvalds 557b9c0ef85SStanislav Kinsbursky static void gen_boot_verifier(nfs4_verifier *verifier, struct net *net) 558ab4684d1SChuck Lever { 559ab4684d1SChuck Lever __be32 verf[2]; 560b9c0ef85SStanislav Kinsbursky struct nfsd_net *nn = net_generic(net, nfsd_net_id); 561ab4684d1SChuck Lever 562f419992cSJeff Layton /* 563f419992cSJeff Layton * This is opaque to client, so no need to byte-swap. Use 564f419992cSJeff Layton * __force to keep sparse happy 565f419992cSJeff Layton */ 566f419992cSJeff Layton verf[0] = (__force __be32)nn->nfssvc_boot.tv_sec; 567f419992cSJeff Layton verf[1] = (__force __be32)nn->nfssvc_boot.tv_usec; 568ab4684d1SChuck Lever memcpy(verifier->data, verf, sizeof(verifier->data)); 569ab4684d1SChuck Lever } 570ab4684d1SChuck Lever 5717191155bSJ.Bruce Fields static __be32 572ca364317SJ.Bruce Fields nfsd4_commit(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 573ca364317SJ.Bruce Fields struct nfsd4_commit *commit) 5741da177e4SLinus Torvalds { 575b9c0ef85SStanislav Kinsbursky gen_boot_verifier(&commit->co_verf, SVC_NET(rqstp)); 57675c096f7SJ. Bruce Fields return nfsd_commit(rqstp, &cstate->current_fh, commit->co_offset, 577ca364317SJ.Bruce Fields commit->co_count); 5781da177e4SLinus Torvalds } 5791da177e4SLinus Torvalds 580b37ad28bSAl Viro static __be32 581ca364317SJ.Bruce Fields nfsd4_create(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 582ca364317SJ.Bruce Fields struct nfsd4_create *create) 5831da177e4SLinus Torvalds { 5841da177e4SLinus Torvalds struct svc_fh resfh; 585b37ad28bSAl Viro __be32 status; 5861da177e4SLinus Torvalds dev_t rdev; 5871da177e4SLinus Torvalds 5881da177e4SLinus Torvalds fh_init(&resfh, NFS4_FHSIZE); 5891da177e4SLinus Torvalds 590fa08139dSJ. Bruce Fields status = fh_verify(rqstp, &cstate->current_fh, S_IFDIR, NFSD_MAY_NOP); 5911da177e4SLinus Torvalds if (status) 5921da177e4SLinus Torvalds return status; 5931da177e4SLinus Torvalds 5943c8e0316SYu Zhiguo status = check_attr_support(rqstp, cstate, create->cr_bmval, 5953c8e0316SYu Zhiguo nfsd_attrmask); 5963c8e0316SYu Zhiguo if (status) 5973c8e0316SYu Zhiguo return status; 5983c8e0316SYu Zhiguo 5991da177e4SLinus Torvalds switch (create->cr_type) { 6001da177e4SLinus Torvalds case NF4LNK: 601ca364317SJ.Bruce Fields status = nfsd_symlink(rqstp, &cstate->current_fh, 602ca364317SJ.Bruce Fields create->cr_name, create->cr_namelen, 6031e444f5bSKinglong Mee create->cr_data, &resfh); 6041da177e4SLinus Torvalds break; 6051da177e4SLinus Torvalds 6061da177e4SLinus Torvalds case NF4BLK: 6071da177e4SLinus Torvalds rdev = MKDEV(create->cr_specdata1, create->cr_specdata2); 6081da177e4SLinus Torvalds if (MAJOR(rdev) != create->cr_specdata1 || 6091da177e4SLinus Torvalds MINOR(rdev) != create->cr_specdata2) 6101da177e4SLinus Torvalds return nfserr_inval; 611ca364317SJ.Bruce Fields status = nfsd_create(rqstp, &cstate->current_fh, 612ca364317SJ.Bruce Fields create->cr_name, create->cr_namelen, 613ca364317SJ.Bruce Fields &create->cr_iattr, S_IFBLK, rdev, &resfh); 6141da177e4SLinus Torvalds break; 6151da177e4SLinus Torvalds 6161da177e4SLinus Torvalds case NF4CHR: 6171da177e4SLinus Torvalds rdev = MKDEV(create->cr_specdata1, create->cr_specdata2); 6181da177e4SLinus Torvalds if (MAJOR(rdev) != create->cr_specdata1 || 6191da177e4SLinus Torvalds MINOR(rdev) != create->cr_specdata2) 6201da177e4SLinus Torvalds return nfserr_inval; 621ca364317SJ.Bruce Fields status = nfsd_create(rqstp, &cstate->current_fh, 622ca364317SJ.Bruce Fields create->cr_name, create->cr_namelen, 623ca364317SJ.Bruce Fields &create->cr_iattr,S_IFCHR, rdev, &resfh); 6241da177e4SLinus Torvalds break; 6251da177e4SLinus Torvalds 6261da177e4SLinus Torvalds case NF4SOCK: 627ca364317SJ.Bruce Fields status = nfsd_create(rqstp, &cstate->current_fh, 628ca364317SJ.Bruce Fields create->cr_name, create->cr_namelen, 629ca364317SJ.Bruce Fields &create->cr_iattr, S_IFSOCK, 0, &resfh); 6301da177e4SLinus Torvalds break; 6311da177e4SLinus Torvalds 6321da177e4SLinus Torvalds case NF4FIFO: 633ca364317SJ.Bruce Fields status = nfsd_create(rqstp, &cstate->current_fh, 634ca364317SJ.Bruce Fields create->cr_name, create->cr_namelen, 635ca364317SJ.Bruce Fields &create->cr_iattr, S_IFIFO, 0, &resfh); 6361da177e4SLinus Torvalds break; 6371da177e4SLinus Torvalds 6381da177e4SLinus Torvalds case NF4DIR: 6391da177e4SLinus Torvalds create->cr_iattr.ia_valid &= ~ATTR_SIZE; 640ca364317SJ.Bruce Fields status = nfsd_create(rqstp, &cstate->current_fh, 641ca364317SJ.Bruce Fields create->cr_name, create->cr_namelen, 642ca364317SJ.Bruce Fields &create->cr_iattr, S_IFDIR, 0, &resfh); 6431da177e4SLinus Torvalds break; 6441da177e4SLinus Torvalds 6451da177e4SLinus Torvalds default: 6461da177e4SLinus Torvalds status = nfserr_badtype; 6471da177e4SLinus Torvalds } 6481da177e4SLinus Torvalds 6499208faf2SYu Zhiguo if (status) 6509208faf2SYu Zhiguo goto out; 6519208faf2SYu Zhiguo 65218032ca0SDavid Quigley if (create->cr_label.len) 65318032ca0SDavid Quigley nfsd4_security_inode_setsecctx(&resfh, &create->cr_label, create->cr_bmval); 65418032ca0SDavid Quigley 6559208faf2SYu Zhiguo if (create->cr_acl != NULL) 6569208faf2SYu Zhiguo do_set_nfs4_acl(rqstp, &resfh, create->cr_acl, 6579208faf2SYu Zhiguo create->cr_bmval); 6589208faf2SYu Zhiguo 659ca364317SJ.Bruce Fields fh_unlock(&cstate->current_fh); 660ca364317SJ.Bruce Fields set_change_info(&create->cr_cinfo, &cstate->current_fh); 661ca364317SJ.Bruce Fields fh_dup2(&cstate->current_fh, &resfh); 6629208faf2SYu Zhiguo out: 6631da177e4SLinus Torvalds fh_put(&resfh); 6641da177e4SLinus Torvalds return status; 6651da177e4SLinus Torvalds } 6661da177e4SLinus Torvalds 6677191155bSJ.Bruce Fields static __be32 668ca364317SJ.Bruce Fields nfsd4_getattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 669ca364317SJ.Bruce Fields struct nfsd4_getattr *getattr) 6701da177e4SLinus Torvalds { 671b37ad28bSAl Viro __be32 status; 6721da177e4SLinus Torvalds 6738837abcaSMiklos Szeredi status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP); 6741da177e4SLinus Torvalds if (status) 6751da177e4SLinus Torvalds return status; 6761da177e4SLinus Torvalds 6771da177e4SLinus Torvalds if (getattr->ga_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1) 6781da177e4SLinus Torvalds return nfserr_inval; 6791da177e4SLinus Torvalds 680916d2d84SJ. Bruce Fields getattr->ga_bmval[0] &= nfsd_suppattrs[cstate->minorversion][0]; 681916d2d84SJ. Bruce Fields getattr->ga_bmval[1] &= nfsd_suppattrs[cstate->minorversion][1]; 682916d2d84SJ. Bruce Fields getattr->ga_bmval[2] &= nfsd_suppattrs[cstate->minorversion][2]; 6831da177e4SLinus Torvalds 684ca364317SJ.Bruce Fields getattr->ga_fhp = &cstate->current_fh; 6851da177e4SLinus Torvalds return nfs_ok; 6861da177e4SLinus Torvalds } 6871da177e4SLinus Torvalds 6887191155bSJ.Bruce Fields static __be32 689ca364317SJ.Bruce Fields nfsd4_link(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 690ca364317SJ.Bruce Fields struct nfsd4_link *link) 6911da177e4SLinus Torvalds { 692b37ad28bSAl Viro __be32 status = nfserr_nofilehandle; 6931da177e4SLinus Torvalds 694ca364317SJ.Bruce Fields if (!cstate->save_fh.fh_dentry) 6951da177e4SLinus Torvalds return status; 696ca364317SJ.Bruce Fields status = nfsd_link(rqstp, &cstate->current_fh, 697ca364317SJ.Bruce Fields link->li_name, link->li_namelen, &cstate->save_fh); 6981da177e4SLinus Torvalds if (!status) 699ca364317SJ.Bruce Fields set_change_info(&link->li_cinfo, &cstate->current_fh); 7001da177e4SLinus Torvalds return status; 7011da177e4SLinus Torvalds } 7021da177e4SLinus Torvalds 7030ff7ab46SJ. Bruce Fields static __be32 nfsd4_do_lookupp(struct svc_rqst *rqstp, struct svc_fh *fh) 7041da177e4SLinus Torvalds { 7051da177e4SLinus Torvalds struct svc_fh tmp_fh; 706b37ad28bSAl Viro __be32 ret; 7071da177e4SLinus Torvalds 7081da177e4SLinus Torvalds fh_init(&tmp_fh, NFS4_FHSIZE); 709df547efbSJ. Bruce Fields ret = exp_pseudoroot(rqstp, &tmp_fh); 710df547efbSJ. Bruce Fields if (ret) 7111da177e4SLinus Torvalds return ret; 7120ff7ab46SJ. Bruce Fields if (tmp_fh.fh_dentry == fh->fh_dentry) { 7131da177e4SLinus Torvalds fh_put(&tmp_fh); 7141da177e4SLinus Torvalds return nfserr_noent; 7151da177e4SLinus Torvalds } 7161da177e4SLinus Torvalds fh_put(&tmp_fh); 7170ff7ab46SJ. Bruce Fields return nfsd_lookup(rqstp, fh, "..", 2, fh); 7180ff7ab46SJ. Bruce Fields } 7190ff7ab46SJ. Bruce Fields 7200ff7ab46SJ. Bruce Fields static __be32 7210ff7ab46SJ. Bruce Fields nfsd4_lookupp(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 7220ff7ab46SJ. Bruce Fields void *arg) 7230ff7ab46SJ. Bruce Fields { 7240ff7ab46SJ. Bruce Fields return nfsd4_do_lookupp(rqstp, &cstate->current_fh); 7251da177e4SLinus Torvalds } 7261da177e4SLinus Torvalds 7277191155bSJ.Bruce Fields static __be32 728ca364317SJ.Bruce Fields nfsd4_lookup(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 729ca364317SJ.Bruce Fields struct nfsd4_lookup *lookup) 7301da177e4SLinus Torvalds { 731ca364317SJ.Bruce Fields return nfsd_lookup(rqstp, &cstate->current_fh, 732ca364317SJ.Bruce Fields lookup->lo_name, lookup->lo_len, 733ca364317SJ.Bruce Fields &cstate->current_fh); 7341da177e4SLinus Torvalds } 7351da177e4SLinus Torvalds 7367191155bSJ.Bruce Fields static __be32 737ca364317SJ.Bruce Fields nfsd4_read(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 738ca364317SJ.Bruce Fields struct nfsd4_read *read) 7391da177e4SLinus Torvalds { 740b37ad28bSAl Viro __be32 status; 7411da177e4SLinus Torvalds 7427e06b7f9SNeilBrown read->rd_filp = NULL; 7431da177e4SLinus Torvalds if (read->rd_offset >= OFFSET_MAX) 7441da177e4SLinus Torvalds return nfserr_inval; 7451da177e4SLinus Torvalds 7469b3234b9SJ. Bruce Fields /* 7479b3234b9SJ. Bruce Fields * If we do a zero copy read, then a client will see read data 7489b3234b9SJ. Bruce Fields * that reflects the state of the file *after* performing the 7499b3234b9SJ. Bruce Fields * following compound. 7509b3234b9SJ. Bruce Fields * 7519b3234b9SJ. Bruce Fields * To ensure proper ordering, we therefore turn off zero copy if 7529b3234b9SJ. Bruce Fields * the client wants us to do more in this compound: 7539b3234b9SJ. Bruce Fields */ 7549b3234b9SJ. Bruce Fields if (!nfsd4_last_compound_op(rqstp)) 755779fb0f3SJeff Layton clear_bit(RQ_SPLICE_OK, &rqstp->rq_flags); 7569b3234b9SJ. Bruce Fields 7571da177e4SLinus Torvalds /* check stateid */ 758aa0d6aedSAnna Schumaker status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh, 759aa0d6aedSAnna Schumaker &read->rd_stateid, RD_STATE, 760aa0d6aedSAnna Schumaker &read->rd_filp, &read->rd_tmp_file); 761af90f707SChristoph Hellwig if (status) { 7621da177e4SLinus Torvalds dprintk("NFSD: nfsd4_read: couldn't process stateid!\n"); 7631da177e4SLinus Torvalds goto out; 7641da177e4SLinus Torvalds } 7651da177e4SLinus Torvalds status = nfs_ok; 7661da177e4SLinus Torvalds out: 7671da177e4SLinus Torvalds read->rd_rqstp = rqstp; 768ca364317SJ.Bruce Fields read->rd_fhp = &cstate->current_fh; 7691da177e4SLinus Torvalds return status; 7701da177e4SLinus Torvalds } 7711da177e4SLinus Torvalds 7727191155bSJ.Bruce Fields static __be32 773ca364317SJ.Bruce Fields nfsd4_readdir(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 774ca364317SJ.Bruce Fields struct nfsd4_readdir *readdir) 7751da177e4SLinus Torvalds { 7761da177e4SLinus Torvalds u64 cookie = readdir->rd_cookie; 7771da177e4SLinus Torvalds static const nfs4_verifier zeroverf; 7781da177e4SLinus Torvalds 7791da177e4SLinus Torvalds /* no need to check permission - this will be done in nfsd_readdir() */ 7801da177e4SLinus Torvalds 7811da177e4SLinus Torvalds if (readdir->rd_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1) 7821da177e4SLinus Torvalds return nfserr_inval; 7831da177e4SLinus Torvalds 784916d2d84SJ. Bruce Fields readdir->rd_bmval[0] &= nfsd_suppattrs[cstate->minorversion][0]; 785916d2d84SJ. Bruce Fields readdir->rd_bmval[1] &= nfsd_suppattrs[cstate->minorversion][1]; 786916d2d84SJ. Bruce Fields readdir->rd_bmval[2] &= nfsd_suppattrs[cstate->minorversion][2]; 7871da177e4SLinus Torvalds 788832023bfSBernd Schubert if ((cookie == 1) || (cookie == 2) || 7891da177e4SLinus Torvalds (cookie == 0 && memcmp(readdir->rd_verf.data, zeroverf.data, NFS4_VERIFIER_SIZE))) 7901da177e4SLinus Torvalds return nfserr_bad_cookie; 7911da177e4SLinus Torvalds 7921da177e4SLinus Torvalds readdir->rd_rqstp = rqstp; 793ca364317SJ.Bruce Fields readdir->rd_fhp = &cstate->current_fh; 7941da177e4SLinus Torvalds return nfs_ok; 7951da177e4SLinus Torvalds } 7961da177e4SLinus Torvalds 7977191155bSJ.Bruce Fields static __be32 798ca364317SJ.Bruce Fields nfsd4_readlink(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 799ca364317SJ.Bruce Fields struct nfsd4_readlink *readlink) 8001da177e4SLinus Torvalds { 8011da177e4SLinus Torvalds readlink->rl_rqstp = rqstp; 802ca364317SJ.Bruce Fields readlink->rl_fhp = &cstate->current_fh; 8031da177e4SLinus Torvalds return nfs_ok; 8041da177e4SLinus Torvalds } 8051da177e4SLinus Torvalds 8067191155bSJ.Bruce Fields static __be32 807ca364317SJ.Bruce Fields nfsd4_remove(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 808ca364317SJ.Bruce Fields struct nfsd4_remove *remove) 8091da177e4SLinus Torvalds { 810b37ad28bSAl Viro __be32 status; 8111da177e4SLinus Torvalds 812c87fb4a3SJ. Bruce Fields if (opens_in_grace(SVC_NET(rqstp))) 813c815afc7SNeilBrown return nfserr_grace; 814ca364317SJ.Bruce Fields status = nfsd_unlink(rqstp, &cstate->current_fh, 0, 815ca364317SJ.Bruce Fields remove->rm_name, remove->rm_namelen); 8161da177e4SLinus Torvalds if (!status) { 817ca364317SJ.Bruce Fields fh_unlock(&cstate->current_fh); 818ca364317SJ.Bruce Fields set_change_info(&remove->rm_cinfo, &cstate->current_fh); 8191da177e4SLinus Torvalds } 8201da177e4SLinus Torvalds return status; 8211da177e4SLinus Torvalds } 8221da177e4SLinus Torvalds 8237191155bSJ.Bruce Fields static __be32 824ca364317SJ.Bruce Fields nfsd4_rename(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 825ca364317SJ.Bruce Fields struct nfsd4_rename *rename) 8261da177e4SLinus Torvalds { 827b37ad28bSAl Viro __be32 status = nfserr_nofilehandle; 8281da177e4SLinus Torvalds 829ca364317SJ.Bruce Fields if (!cstate->save_fh.fh_dentry) 8301da177e4SLinus Torvalds return status; 831c87fb4a3SJ. Bruce Fields if (opens_in_grace(SVC_NET(rqstp)) && 8325ccb0066SStanislav Kinsbursky !(cstate->save_fh.fh_export->ex_flags & NFSEXP_NOSUBTREECHECK)) 833c815afc7SNeilBrown return nfserr_grace; 834ca364317SJ.Bruce Fields status = nfsd_rename(rqstp, &cstate->save_fh, rename->rn_sname, 835ca364317SJ.Bruce Fields rename->rn_snamelen, &cstate->current_fh, 8361da177e4SLinus Torvalds rename->rn_tname, rename->rn_tnamelen); 8372a6cf944SJ. Bruce Fields if (status) 8382a6cf944SJ. Bruce Fields return status; 839ca364317SJ.Bruce Fields set_change_info(&rename->rn_sinfo, &cstate->current_fh); 840ca364317SJ.Bruce Fields set_change_info(&rename->rn_tinfo, &cstate->save_fh); 8412a6cf944SJ. Bruce Fields return nfs_ok; 8421da177e4SLinus Torvalds } 8431da177e4SLinus Torvalds 8447191155bSJ.Bruce Fields static __be32 845dcb488a3SAndy Adamson nfsd4_secinfo(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 846dcb488a3SAndy Adamson struct nfsd4_secinfo *secinfo) 847dcb488a3SAndy Adamson { 848dcb488a3SAndy Adamson struct svc_export *exp; 849dcb488a3SAndy Adamson struct dentry *dentry; 850dcb488a3SAndy Adamson __be32 err; 851dcb488a3SAndy Adamson 85229a78a3eSJ. Bruce Fields err = fh_verify(rqstp, &cstate->current_fh, S_IFDIR, NFSD_MAY_EXEC); 85329a78a3eSJ. Bruce Fields if (err) 85429a78a3eSJ. Bruce Fields return err; 855dcb488a3SAndy Adamson err = nfsd_lookup_dentry(rqstp, &cstate->current_fh, 856dcb488a3SAndy Adamson secinfo->si_name, secinfo->si_namelen, 857dcb488a3SAndy Adamson &exp, &dentry); 858dcb488a3SAndy Adamson if (err) 859dcb488a3SAndy Adamson return err; 8602f6fc056SJ. Bruce Fields fh_unlock(&cstate->current_fh); 8612b0143b5SDavid Howells if (d_really_is_negative(dentry)) { 862dcb488a3SAndy Adamson exp_put(exp); 863dcb488a3SAndy Adamson err = nfserr_noent; 864dcb488a3SAndy Adamson } else 865dcb488a3SAndy Adamson secinfo->si_exp = exp; 866dcb488a3SAndy Adamson dput(dentry); 86756560b9aSJ. Bruce Fields if (cstate->minorversion) 86856560b9aSJ. Bruce Fields /* See rfc 5661 section 2.6.3.1.1.8 */ 86956560b9aSJ. Bruce Fields fh_put(&cstate->current_fh); 870dcb488a3SAndy Adamson return err; 871dcb488a3SAndy Adamson } 872dcb488a3SAndy Adamson 873dcb488a3SAndy Adamson static __be32 87404f4ad16SJ. Bruce Fields nfsd4_secinfo_no_name(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 87504f4ad16SJ. Bruce Fields struct nfsd4_secinfo_no_name *sin) 87604f4ad16SJ. Bruce Fields { 87704f4ad16SJ. Bruce Fields __be32 err; 87804f4ad16SJ. Bruce Fields 87904f4ad16SJ. Bruce Fields switch (sin->sin_style) { 88004f4ad16SJ. Bruce Fields case NFS4_SECINFO_STYLE4_CURRENT_FH: 88104f4ad16SJ. Bruce Fields break; 88204f4ad16SJ. Bruce Fields case NFS4_SECINFO_STYLE4_PARENT: 88304f4ad16SJ. Bruce Fields err = nfsd4_do_lookupp(rqstp, &cstate->current_fh); 88404f4ad16SJ. Bruce Fields if (err) 88504f4ad16SJ. Bruce Fields return err; 88604f4ad16SJ. Bruce Fields break; 88704f4ad16SJ. Bruce Fields default: 88804f4ad16SJ. Bruce Fields return nfserr_inval; 88904f4ad16SJ. Bruce Fields } 890bf18f163SKinglong Mee 891bf18f163SKinglong Mee sin->sin_exp = exp_get(cstate->current_fh.fh_export); 89204f4ad16SJ. Bruce Fields fh_put(&cstate->current_fh); 89304f4ad16SJ. Bruce Fields return nfs_ok; 89404f4ad16SJ. Bruce Fields } 89504f4ad16SJ. Bruce Fields 89604f4ad16SJ. Bruce Fields static __be32 897ca364317SJ.Bruce Fields nfsd4_setattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 898ca364317SJ.Bruce Fields struct nfsd4_setattr *setattr) 8991da177e4SLinus Torvalds { 900b37ad28bSAl Viro __be32 status = nfs_ok; 90196f6f985SAl Viro int err; 9021da177e4SLinus Torvalds 9031da177e4SLinus Torvalds if (setattr->sa_iattr.ia_valid & ATTR_SIZE) { 904af90f707SChristoph Hellwig status = nfs4_preprocess_stateid_op(rqstp, cstate, 905aa0d6aedSAnna Schumaker &cstate->current_fh, &setattr->sa_stateid, 906aa0d6aedSAnna Schumaker WR_STATE, NULL, NULL); 907375c5547SJ. Bruce Fields if (status) { 9083e3b4800SGreg Banks dprintk("NFSD: nfsd4_setattr: couldn't process stateid!\n"); 909375c5547SJ. Bruce Fields return status; 910375c5547SJ. Bruce Fields } 9111da177e4SLinus Torvalds } 91296f6f985SAl Viro err = fh_want_write(&cstate->current_fh); 91396f6f985SAl Viro if (err) 91496f6f985SAl Viro return nfserrno(err); 9151da177e4SLinus Torvalds status = nfs_ok; 9163c8e0316SYu Zhiguo 9173c8e0316SYu Zhiguo status = check_attr_support(rqstp, cstate, setattr->sa_bmval, 9183c8e0316SYu Zhiguo nfsd_attrmask); 9193c8e0316SYu Zhiguo if (status) 9203c8e0316SYu Zhiguo goto out; 9213c8e0316SYu Zhiguo 9221da177e4SLinus Torvalds if (setattr->sa_acl != NULL) 923ca364317SJ.Bruce Fields status = nfsd4_set_nfs4_acl(rqstp, &cstate->current_fh, 924ca364317SJ.Bruce Fields setattr->sa_acl); 9251da177e4SLinus Torvalds if (status) 92618f335afSDave Hansen goto out; 92718032ca0SDavid Quigley if (setattr->sa_label.len) 92818032ca0SDavid Quigley status = nfsd4_set_nfs4_label(rqstp, &cstate->current_fh, 92918032ca0SDavid Quigley &setattr->sa_label); 93018032ca0SDavid Quigley if (status) 93118032ca0SDavid Quigley goto out; 932ca364317SJ.Bruce Fields status = nfsd_setattr(rqstp, &cstate->current_fh, &setattr->sa_iattr, 9331da177e4SLinus Torvalds 0, (time_t)0); 93418f335afSDave Hansen out: 935bad0dcffSAl Viro fh_drop_write(&cstate->current_fh); 9361da177e4SLinus Torvalds return status; 9371da177e4SLinus Torvalds } 9381da177e4SLinus Torvalds 939ffe1137bSJ. Bruce Fields static int fill_in_write_vector(struct kvec *vec, struct nfsd4_write *write) 940ffe1137bSJ. Bruce Fields { 941ffe1137bSJ. Bruce Fields int i = 1; 942ffe1137bSJ. Bruce Fields int buflen = write->wr_buflen; 943ffe1137bSJ. Bruce Fields 944ffe1137bSJ. Bruce Fields vec[0].iov_base = write->wr_head.iov_base; 945ffe1137bSJ. Bruce Fields vec[0].iov_len = min_t(int, buflen, write->wr_head.iov_len); 946ffe1137bSJ. Bruce Fields buflen -= vec[0].iov_len; 947ffe1137bSJ. Bruce Fields 948ffe1137bSJ. Bruce Fields while (buflen) { 949ffe1137bSJ. Bruce Fields vec[i].iov_base = page_address(write->wr_pagelist[i - 1]); 950ffe1137bSJ. Bruce Fields vec[i].iov_len = min_t(int, PAGE_SIZE, buflen); 951ffe1137bSJ. Bruce Fields buflen -= vec[i].iov_len; 952ffe1137bSJ. Bruce Fields i++; 953ffe1137bSJ. Bruce Fields } 954ffe1137bSJ. Bruce Fields return i; 955ffe1137bSJ. Bruce Fields } 956ffe1137bSJ. Bruce Fields 9577191155bSJ.Bruce Fields static __be32 958ca364317SJ.Bruce Fields nfsd4_write(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 959ca364317SJ.Bruce Fields struct nfsd4_write *write) 9601da177e4SLinus Torvalds { 9611da177e4SLinus Torvalds stateid_t *stateid = &write->wr_stateid; 9621da177e4SLinus Torvalds struct file *filp = NULL; 963b37ad28bSAl Viro __be32 status = nfs_ok; 96431dec253SDavid Shaw unsigned long cnt; 965ffe1137bSJ. Bruce Fields int nvecs; 9661da177e4SLinus Torvalds 9671da177e4SLinus Torvalds if (write->wr_offset >= OFFSET_MAX) 9681da177e4SLinus Torvalds return nfserr_inval; 9691da177e4SLinus Torvalds 970aa0d6aedSAnna Schumaker status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh, 971aa0d6aedSAnna Schumaker stateid, WR_STATE, &filp, NULL); 972375c5547SJ. Bruce Fields if (status) { 973375c5547SJ. Bruce Fields dprintk("NFSD: nfsd4_write: couldn't process stateid!\n"); 974375c5547SJ. Bruce Fields return status; 975375c5547SJ. Bruce Fields } 976375c5547SJ. Bruce Fields 97731dec253SDavid Shaw cnt = write->wr_buflen; 9781da177e4SLinus Torvalds write->wr_how_written = write->wr_stable_how; 979b9c0ef85SStanislav Kinsbursky gen_boot_verifier(&write->wr_verifier, SVC_NET(rqstp)); 9801da177e4SLinus Torvalds 981ffe1137bSJ. Bruce Fields nvecs = fill_in_write_vector(rqstp->rq_vec, write); 982ffe1137bSJ. Bruce Fields WARN_ON_ONCE(nvecs > ARRAY_SIZE(rqstp->rq_vec)); 983ffe1137bSJ. Bruce Fields 984af90f707SChristoph Hellwig status = nfsd_vfs_write(rqstp, &cstate->current_fh, filp, 985af90f707SChristoph Hellwig write->wr_offset, rqstp->rq_vec, nvecs, &cnt, 98654bbb7d2SKinglong Mee write->wr_how_written); 9877e06b7f9SNeilBrown fput(filp); 9881da177e4SLinus Torvalds 98931dec253SDavid Shaw write->wr_bytes_written = cnt; 99031dec253SDavid Shaw 9911da177e4SLinus Torvalds return status; 9921da177e4SLinus Torvalds } 9931da177e4SLinus Torvalds 99424bab491SAnna Schumaker static __be32 99529ae7f9dSAnna Schumaker nfsd4_verify_copy(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 99629ae7f9dSAnna Schumaker stateid_t *src_stateid, struct file **src, 99729ae7f9dSAnna Schumaker stateid_t *dst_stateid, struct file **dst) 998ffa0160aSChristoph Hellwig { 999ffa0160aSChristoph Hellwig __be32 status; 1000ffa0160aSChristoph Hellwig 1001ffa0160aSChristoph Hellwig status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->save_fh, 100229ae7f9dSAnna Schumaker src_stateid, RD_STATE, src, NULL); 1003ffa0160aSChristoph Hellwig if (status) { 1004ffa0160aSChristoph Hellwig dprintk("NFSD: %s: couldn't process src stateid!\n", __func__); 1005ffa0160aSChristoph Hellwig goto out; 1006ffa0160aSChristoph Hellwig } 1007ffa0160aSChristoph Hellwig 1008ffa0160aSChristoph Hellwig status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh, 100929ae7f9dSAnna Schumaker dst_stateid, WR_STATE, dst, NULL); 1010ffa0160aSChristoph Hellwig if (status) { 1011ffa0160aSChristoph Hellwig dprintk("NFSD: %s: couldn't process dst stateid!\n", __func__); 1012ffa0160aSChristoph Hellwig goto out_put_src; 1013ffa0160aSChristoph Hellwig } 1014ffa0160aSChristoph Hellwig 1015ffa0160aSChristoph Hellwig /* fix up for NFS-specific error code */ 101629ae7f9dSAnna Schumaker if (!S_ISREG(file_inode(*src)->i_mode) || 101729ae7f9dSAnna Schumaker !S_ISREG(file_inode(*dst)->i_mode)) { 1018ffa0160aSChristoph Hellwig status = nfserr_wrong_type; 1019ffa0160aSChristoph Hellwig goto out_put_dst; 1020ffa0160aSChristoph Hellwig } 1021ffa0160aSChristoph Hellwig 102229ae7f9dSAnna Schumaker out: 102329ae7f9dSAnna Schumaker return status; 102429ae7f9dSAnna Schumaker out_put_dst: 102529ae7f9dSAnna Schumaker fput(*dst); 102629ae7f9dSAnna Schumaker out_put_src: 102729ae7f9dSAnna Schumaker fput(*src); 102829ae7f9dSAnna Schumaker goto out; 102929ae7f9dSAnna Schumaker } 103029ae7f9dSAnna Schumaker 103129ae7f9dSAnna Schumaker static __be32 103229ae7f9dSAnna Schumaker nfsd4_clone(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 103329ae7f9dSAnna Schumaker struct nfsd4_clone *clone) 103429ae7f9dSAnna Schumaker { 103529ae7f9dSAnna Schumaker struct file *src, *dst; 103629ae7f9dSAnna Schumaker __be32 status; 103729ae7f9dSAnna Schumaker 103829ae7f9dSAnna Schumaker status = nfsd4_verify_copy(rqstp, cstate, &clone->cl_src_stateid, &src, 103929ae7f9dSAnna Schumaker &clone->cl_dst_stateid, &dst); 104029ae7f9dSAnna Schumaker if (status) 104129ae7f9dSAnna Schumaker goto out; 104229ae7f9dSAnna Schumaker 1043ffa0160aSChristoph Hellwig status = nfsd4_clone_file_range(src, clone->cl_src_pos, 1044ffa0160aSChristoph Hellwig dst, clone->cl_dst_pos, clone->cl_count); 1045ffa0160aSChristoph Hellwig 1046ffa0160aSChristoph Hellwig fput(dst); 1047ffa0160aSChristoph Hellwig fput(src); 1048ffa0160aSChristoph Hellwig out: 1049ffa0160aSChristoph Hellwig return status; 1050ffa0160aSChristoph Hellwig } 1051ffa0160aSChristoph Hellwig 1052ffa0160aSChristoph Hellwig static __be32 105329ae7f9dSAnna Schumaker nfsd4_copy(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 105429ae7f9dSAnna Schumaker struct nfsd4_copy *copy) 105529ae7f9dSAnna Schumaker { 105629ae7f9dSAnna Schumaker struct file *src, *dst; 105729ae7f9dSAnna Schumaker __be32 status; 105829ae7f9dSAnna Schumaker ssize_t bytes; 105929ae7f9dSAnna Schumaker 106029ae7f9dSAnna Schumaker status = nfsd4_verify_copy(rqstp, cstate, ©->cp_src_stateid, &src, 106129ae7f9dSAnna Schumaker ©->cp_dst_stateid, &dst); 106229ae7f9dSAnna Schumaker if (status) 106329ae7f9dSAnna Schumaker goto out; 106429ae7f9dSAnna Schumaker 106529ae7f9dSAnna Schumaker bytes = nfsd_copy_file_range(src, copy->cp_src_pos, 106629ae7f9dSAnna Schumaker dst, copy->cp_dst_pos, copy->cp_count); 106729ae7f9dSAnna Schumaker 106829ae7f9dSAnna Schumaker if (bytes < 0) 106929ae7f9dSAnna Schumaker status = nfserrno(bytes); 107029ae7f9dSAnna Schumaker else { 107129ae7f9dSAnna Schumaker copy->cp_res.wr_bytes_written = bytes; 107229ae7f9dSAnna Schumaker copy->cp_res.wr_stable_how = NFS_UNSTABLE; 107329ae7f9dSAnna Schumaker copy->cp_consecutive = 1; 107429ae7f9dSAnna Schumaker copy->cp_synchronous = 1; 107529ae7f9dSAnna Schumaker gen_boot_verifier(©->cp_res.wr_verifier, SVC_NET(rqstp)); 107629ae7f9dSAnna Schumaker status = nfs_ok; 107729ae7f9dSAnna Schumaker } 107829ae7f9dSAnna Schumaker 107929ae7f9dSAnna Schumaker fput(src); 108029ae7f9dSAnna Schumaker fput(dst); 108129ae7f9dSAnna Schumaker out: 108229ae7f9dSAnna Schumaker return status; 108329ae7f9dSAnna Schumaker } 108429ae7f9dSAnna Schumaker 108529ae7f9dSAnna Schumaker static __be32 108695d871f0SAnna Schumaker nfsd4_fallocate(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 108795d871f0SAnna Schumaker struct nfsd4_fallocate *fallocate, int flags) 108895d871f0SAnna Schumaker { 108995d871f0SAnna Schumaker __be32 status = nfserr_notsupp; 109095d871f0SAnna Schumaker struct file *file; 109195d871f0SAnna Schumaker 1092aa0d6aedSAnna Schumaker status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh, 109395d871f0SAnna Schumaker &fallocate->falloc_stateid, 1094af90f707SChristoph Hellwig WR_STATE, &file, NULL); 109595d871f0SAnna Schumaker if (status != nfs_ok) { 109695d871f0SAnna Schumaker dprintk("NFSD: nfsd4_fallocate: couldn't process stateid!\n"); 109795d871f0SAnna Schumaker return status; 109895d871f0SAnna Schumaker } 109995d871f0SAnna Schumaker 110095d871f0SAnna Schumaker status = nfsd4_vfs_fallocate(rqstp, &cstate->current_fh, file, 110195d871f0SAnna Schumaker fallocate->falloc_offset, 110295d871f0SAnna Schumaker fallocate->falloc_length, 110395d871f0SAnna Schumaker flags); 110495d871f0SAnna Schumaker fput(file); 110595d871f0SAnna Schumaker return status; 110695d871f0SAnna Schumaker } 110795d871f0SAnna Schumaker 110895d871f0SAnna Schumaker static __be32 110995d871f0SAnna Schumaker nfsd4_allocate(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 111095d871f0SAnna Schumaker struct nfsd4_fallocate *fallocate) 111195d871f0SAnna Schumaker { 111295d871f0SAnna Schumaker return nfsd4_fallocate(rqstp, cstate, fallocate, 0); 111395d871f0SAnna Schumaker } 111495d871f0SAnna Schumaker 111595d871f0SAnna Schumaker static __be32 1116b0cb9085SAnna Schumaker nfsd4_deallocate(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 1117b0cb9085SAnna Schumaker struct nfsd4_fallocate *fallocate) 1118b0cb9085SAnna Schumaker { 1119b0cb9085SAnna Schumaker return nfsd4_fallocate(rqstp, cstate, fallocate, 1120b0cb9085SAnna Schumaker FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE); 1121b0cb9085SAnna Schumaker } 1122b0cb9085SAnna Schumaker 1123b0cb9085SAnna Schumaker static __be32 112424bab491SAnna Schumaker nfsd4_seek(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 112524bab491SAnna Schumaker struct nfsd4_seek *seek) 112624bab491SAnna Schumaker { 112724bab491SAnna Schumaker int whence; 112824bab491SAnna Schumaker __be32 status; 112924bab491SAnna Schumaker struct file *file; 113024bab491SAnna Schumaker 1131aa0d6aedSAnna Schumaker status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh, 113224bab491SAnna Schumaker &seek->seek_stateid, 1133af90f707SChristoph Hellwig RD_STATE, &file, NULL); 113424bab491SAnna Schumaker if (status) { 113524bab491SAnna Schumaker dprintk("NFSD: nfsd4_seek: couldn't process stateid!\n"); 113624bab491SAnna Schumaker return status; 113724bab491SAnna Schumaker } 113824bab491SAnna Schumaker 113924bab491SAnna Schumaker switch (seek->seek_whence) { 114024bab491SAnna Schumaker case NFS4_CONTENT_DATA: 114124bab491SAnna Schumaker whence = SEEK_DATA; 114224bab491SAnna Schumaker break; 114324bab491SAnna Schumaker case NFS4_CONTENT_HOLE: 114424bab491SAnna Schumaker whence = SEEK_HOLE; 114524bab491SAnna Schumaker break; 114624bab491SAnna Schumaker default: 114724bab491SAnna Schumaker status = nfserr_union_notsupp; 114824bab491SAnna Schumaker goto out; 114924bab491SAnna Schumaker } 115024bab491SAnna Schumaker 115124bab491SAnna Schumaker /* 115224bab491SAnna Schumaker * Note: This call does change file->f_pos, but nothing in NFSD 115324bab491SAnna Schumaker * should ever file->f_pos. 115424bab491SAnna Schumaker */ 115524bab491SAnna Schumaker seek->seek_pos = vfs_llseek(file, seek->seek_offset, whence); 115624bab491SAnna Schumaker if (seek->seek_pos < 0) 115724bab491SAnna Schumaker status = nfserrno(seek->seek_pos); 115824bab491SAnna Schumaker else if (seek->seek_pos >= i_size_read(file_inode(file))) 115924bab491SAnna Schumaker seek->seek_eof = true; 116024bab491SAnna Schumaker 116124bab491SAnna Schumaker out: 116224bab491SAnna Schumaker fput(file); 116324bab491SAnna Schumaker return status; 116424bab491SAnna Schumaker } 116524bab491SAnna Schumaker 11661da177e4SLinus Torvalds /* This routine never returns NFS_OK! If there are no other errors, it 11671da177e4SLinus Torvalds * will return NFSERR_SAME or NFSERR_NOT_SAME depending on whether the 11681da177e4SLinus Torvalds * attributes matched. VERIFY is implemented by mapping NFSERR_SAME 11691da177e4SLinus Torvalds * to NFS_OK after the call; NVERIFY by mapping NFSERR_NOT_SAME to NFS_OK. 11701da177e4SLinus Torvalds */ 1171b37ad28bSAl Viro static __be32 1172c954e2a5SJ.Bruce Fields _nfsd4_verify(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 1173ca364317SJ.Bruce Fields struct nfsd4_verify *verify) 11741da177e4SLinus Torvalds { 11752ebbc012SAl Viro __be32 *buf, *p; 11761da177e4SLinus Torvalds int count; 1177b37ad28bSAl Viro __be32 status; 11781da177e4SLinus Torvalds 11798837abcaSMiklos Szeredi status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP); 11801da177e4SLinus Torvalds if (status) 11811da177e4SLinus Torvalds return status; 11821da177e4SLinus Torvalds 11833c8e0316SYu Zhiguo status = check_attr_support(rqstp, cstate, verify->ve_bmval, NULL); 11843c8e0316SYu Zhiguo if (status) 11853c8e0316SYu Zhiguo return status; 11863c8e0316SYu Zhiguo 11871da177e4SLinus Torvalds if ((verify->ve_bmval[0] & FATTR4_WORD0_RDATTR_ERROR) 11881da177e4SLinus Torvalds || (verify->ve_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1)) 11891da177e4SLinus Torvalds return nfserr_inval; 11901da177e4SLinus Torvalds if (verify->ve_attrlen & 3) 11911da177e4SLinus Torvalds return nfserr_inval; 11921da177e4SLinus Torvalds 11931da177e4SLinus Torvalds /* count in words: 11941da177e4SLinus Torvalds * bitmap_len(1) + bitmap(2) + attr_len(1) = 4 11951da177e4SLinus Torvalds */ 11961da177e4SLinus Torvalds count = 4 + (verify->ve_attrlen >> 2); 11971da177e4SLinus Torvalds buf = kmalloc(count << 2, GFP_KERNEL); 11981da177e4SLinus Torvalds if (!buf) 11993e772463SJ. Bruce Fields return nfserr_jukebox; 12001da177e4SLinus Torvalds 120184822d0bSJ. Bruce Fields p = buf; 1202d5184658SJ. Bruce Fields status = nfsd4_encode_fattr_to_buf(&p, count, &cstate->current_fh, 1203ca364317SJ.Bruce Fields cstate->current_fh.fh_export, 1204d5184658SJ. Bruce Fields cstate->current_fh.fh_dentry, 1205d5184658SJ. Bruce Fields verify->ve_bmval, 1206406a7ea9SFrank Filz rqstp, 0); 120741ae6e71SJ. Bruce Fields /* 120841ae6e71SJ. Bruce Fields * If nfsd4_encode_fattr() ran out of space, assume that's because 120941ae6e71SJ. Bruce Fields * the attributes are longer (hence different) than those given: 121041ae6e71SJ. Bruce Fields */ 121184822d0bSJ. Bruce Fields if (status == nfserr_resource) 12121da177e4SLinus Torvalds status = nfserr_not_same; 12131da177e4SLinus Torvalds if (status) 12141da177e4SLinus Torvalds goto out_kfree; 12151da177e4SLinus Torvalds 121695ec28cdSBenny Halevy /* skip bitmap */ 121795ec28cdSBenny Halevy p = buf + 1 + ntohl(buf[0]); 12181da177e4SLinus Torvalds status = nfserr_not_same; 12191da177e4SLinus Torvalds if (ntohl(*p++) != verify->ve_attrlen) 12201da177e4SLinus Torvalds goto out_kfree; 12211da177e4SLinus Torvalds if (!memcmp(p, verify->ve_attrval, verify->ve_attrlen)) 12221da177e4SLinus Torvalds status = nfserr_same; 12231da177e4SLinus Torvalds 12241da177e4SLinus Torvalds out_kfree: 12251da177e4SLinus Torvalds kfree(buf); 12261da177e4SLinus Torvalds return status; 12271da177e4SLinus Torvalds } 12281da177e4SLinus Torvalds 1229c954e2a5SJ.Bruce Fields static __be32 1230c954e2a5SJ.Bruce Fields nfsd4_nverify(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 1231c954e2a5SJ.Bruce Fields struct nfsd4_verify *verify) 1232c954e2a5SJ.Bruce Fields { 1233c954e2a5SJ.Bruce Fields __be32 status; 1234c954e2a5SJ.Bruce Fields 1235c954e2a5SJ.Bruce Fields status = _nfsd4_verify(rqstp, cstate, verify); 1236c954e2a5SJ.Bruce Fields return status == nfserr_not_same ? nfs_ok : status; 1237c954e2a5SJ.Bruce Fields } 1238c954e2a5SJ.Bruce Fields 1239c954e2a5SJ.Bruce Fields static __be32 1240c954e2a5SJ.Bruce Fields nfsd4_verify(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 1241c954e2a5SJ.Bruce Fields struct nfsd4_verify *verify) 1242c954e2a5SJ.Bruce Fields { 1243c954e2a5SJ.Bruce Fields __be32 status; 1244c954e2a5SJ.Bruce Fields 1245c954e2a5SJ.Bruce Fields status = _nfsd4_verify(rqstp, cstate, verify); 1246c954e2a5SJ.Bruce Fields return status == nfserr_same ? nfs_ok : status; 1247c954e2a5SJ.Bruce Fields } 1248c954e2a5SJ.Bruce Fields 12499cf514ccSChristoph Hellwig #ifdef CONFIG_NFSD_PNFS 12509cf514ccSChristoph Hellwig static const struct nfsd4_layout_ops * 12519cf514ccSChristoph Hellwig nfsd4_layout_verify(struct svc_export *exp, unsigned int layout_type) 12529cf514ccSChristoph Hellwig { 12538a4c3926SJeff Layton if (!exp->ex_layout_types) { 12549cf514ccSChristoph Hellwig dprintk("%s: export does not support pNFS\n", __func__); 12559cf514ccSChristoph Hellwig return NULL; 12569cf514ccSChristoph Hellwig } 12579cf514ccSChristoph Hellwig 12588a4c3926SJeff Layton if (!(exp->ex_layout_types & (1 << layout_type))) { 12599cf514ccSChristoph Hellwig dprintk("%s: layout type %d not supported\n", 12609cf514ccSChristoph Hellwig __func__, layout_type); 12619cf514ccSChristoph Hellwig return NULL; 12629cf514ccSChristoph Hellwig } 12639cf514ccSChristoph Hellwig 12649cf514ccSChristoph Hellwig return nfsd4_layout_ops[layout_type]; 12659cf514ccSChristoph Hellwig } 12669cf514ccSChristoph Hellwig 12679cf514ccSChristoph Hellwig static __be32 12689cf514ccSChristoph Hellwig nfsd4_getdeviceinfo(struct svc_rqst *rqstp, 12699cf514ccSChristoph Hellwig struct nfsd4_compound_state *cstate, 12709cf514ccSChristoph Hellwig struct nfsd4_getdeviceinfo *gdp) 12719cf514ccSChristoph Hellwig { 12729cf514ccSChristoph Hellwig const struct nfsd4_layout_ops *ops; 12739cf514ccSChristoph Hellwig struct nfsd4_deviceid_map *map; 12749cf514ccSChristoph Hellwig struct svc_export *exp; 12759cf514ccSChristoph Hellwig __be32 nfserr; 12769cf514ccSChristoph Hellwig 12779cf514ccSChristoph Hellwig dprintk("%s: layout_type %u dev_id [0x%llx:0x%x] maxcnt %u\n", 12789cf514ccSChristoph Hellwig __func__, 12799cf514ccSChristoph Hellwig gdp->gd_layout_type, 12809cf514ccSChristoph Hellwig gdp->gd_devid.fsid_idx, gdp->gd_devid.generation, 12819cf514ccSChristoph Hellwig gdp->gd_maxcount); 12829cf514ccSChristoph Hellwig 12839cf514ccSChristoph Hellwig map = nfsd4_find_devid_map(gdp->gd_devid.fsid_idx); 12849cf514ccSChristoph Hellwig if (!map) { 12859cf514ccSChristoph Hellwig dprintk("%s: couldn't find device ID to export mapping!\n", 12869cf514ccSChristoph Hellwig __func__); 12879cf514ccSChristoph Hellwig return nfserr_noent; 12889cf514ccSChristoph Hellwig } 12899cf514ccSChristoph Hellwig 12909cf514ccSChristoph Hellwig exp = rqst_exp_find(rqstp, map->fsid_type, map->fsid); 12919cf514ccSChristoph Hellwig if (IS_ERR(exp)) { 12929cf514ccSChristoph Hellwig dprintk("%s: could not find device id\n", __func__); 12939cf514ccSChristoph Hellwig return nfserr_noent; 12949cf514ccSChristoph Hellwig } 12959cf514ccSChristoph Hellwig 12969cf514ccSChristoph Hellwig nfserr = nfserr_layoutunavailable; 12979cf514ccSChristoph Hellwig ops = nfsd4_layout_verify(exp, gdp->gd_layout_type); 12989cf514ccSChristoph Hellwig if (!ops) 12999cf514ccSChristoph Hellwig goto out; 13009cf514ccSChristoph Hellwig 13019cf514ccSChristoph Hellwig nfserr = nfs_ok; 1302f99d4fbdSChristoph Hellwig if (gdp->gd_maxcount != 0) { 1303f99d4fbdSChristoph Hellwig nfserr = ops->proc_getdeviceinfo(exp->ex_path.mnt->mnt_sb, 1304d7c920d1STom Haynes rqstp, cstate->session->se_client, gdp); 1305f99d4fbdSChristoph Hellwig } 13069cf514ccSChristoph Hellwig 13079cf514ccSChristoph Hellwig gdp->gd_notify_types &= ops->notify_types; 13089cf514ccSChristoph Hellwig out: 1309a1420384SKinglong Mee exp_put(exp); 13109cf514ccSChristoph Hellwig return nfserr; 13119cf514ccSChristoph Hellwig } 13129cf514ccSChristoph Hellwig 13139cf514ccSChristoph Hellwig static __be32 13149cf514ccSChristoph Hellwig nfsd4_layoutget(struct svc_rqst *rqstp, 13159cf514ccSChristoph Hellwig struct nfsd4_compound_state *cstate, 13169cf514ccSChristoph Hellwig struct nfsd4_layoutget *lgp) 13179cf514ccSChristoph Hellwig { 13189cf514ccSChristoph Hellwig struct svc_fh *current_fh = &cstate->current_fh; 13199cf514ccSChristoph Hellwig const struct nfsd4_layout_ops *ops; 13209cf514ccSChristoph Hellwig struct nfs4_layout_stateid *ls; 13219cf514ccSChristoph Hellwig __be32 nfserr; 13229cf514ccSChristoph Hellwig int accmode; 13239cf514ccSChristoph Hellwig 13249cf514ccSChristoph Hellwig switch (lgp->lg_seg.iomode) { 13259cf514ccSChristoph Hellwig case IOMODE_READ: 13269cf514ccSChristoph Hellwig accmode = NFSD_MAY_READ; 13279cf514ccSChristoph Hellwig break; 13289cf514ccSChristoph Hellwig case IOMODE_RW: 13299cf514ccSChristoph Hellwig accmode = NFSD_MAY_READ | NFSD_MAY_WRITE; 13309cf514ccSChristoph Hellwig break; 13319cf514ccSChristoph Hellwig default: 13329cf514ccSChristoph Hellwig dprintk("%s: invalid iomode %d\n", 13339cf514ccSChristoph Hellwig __func__, lgp->lg_seg.iomode); 13349cf514ccSChristoph Hellwig nfserr = nfserr_badiomode; 13359cf514ccSChristoph Hellwig goto out; 13369cf514ccSChristoph Hellwig } 13379cf514ccSChristoph Hellwig 13389cf514ccSChristoph Hellwig nfserr = fh_verify(rqstp, current_fh, 0, accmode); 13399cf514ccSChristoph Hellwig if (nfserr) 13409cf514ccSChristoph Hellwig goto out; 13419cf514ccSChristoph Hellwig 13429cf514ccSChristoph Hellwig nfserr = nfserr_layoutunavailable; 13439cf514ccSChristoph Hellwig ops = nfsd4_layout_verify(current_fh->fh_export, lgp->lg_layout_type); 13449cf514ccSChristoph Hellwig if (!ops) 13459cf514ccSChristoph Hellwig goto out; 13469cf514ccSChristoph Hellwig 13479cf514ccSChristoph Hellwig /* 13489cf514ccSChristoph Hellwig * Verify minlength and range as per RFC5661: 13499cf514ccSChristoph Hellwig * o If loga_length is less than loga_minlength, 13509cf514ccSChristoph Hellwig * the metadata server MUST return NFS4ERR_INVAL. 13519cf514ccSChristoph Hellwig * o If the sum of loga_offset and loga_minlength exceeds 13529cf514ccSChristoph Hellwig * NFS4_UINT64_MAX, and loga_minlength is not 13539cf514ccSChristoph Hellwig * NFS4_UINT64_MAX, the error NFS4ERR_INVAL MUST result. 13549cf514ccSChristoph Hellwig * o If the sum of loga_offset and loga_length exceeds 13559cf514ccSChristoph Hellwig * NFS4_UINT64_MAX, and loga_length is not NFS4_UINT64_MAX, 13569cf514ccSChristoph Hellwig * the error NFS4ERR_INVAL MUST result. 13579cf514ccSChristoph Hellwig */ 13589cf514ccSChristoph Hellwig nfserr = nfserr_inval; 13599cf514ccSChristoph Hellwig if (lgp->lg_seg.length < lgp->lg_minlength || 13609cf514ccSChristoph Hellwig (lgp->lg_minlength != NFS4_MAX_UINT64 && 13619cf514ccSChristoph Hellwig lgp->lg_minlength > NFS4_MAX_UINT64 - lgp->lg_seg.offset) || 13629cf514ccSChristoph Hellwig (lgp->lg_seg.length != NFS4_MAX_UINT64 && 13639cf514ccSChristoph Hellwig lgp->lg_seg.length > NFS4_MAX_UINT64 - lgp->lg_seg.offset)) 13649cf514ccSChristoph Hellwig goto out; 13659cf514ccSChristoph Hellwig if (lgp->lg_seg.length == 0) 13669cf514ccSChristoph Hellwig goto out; 13679cf514ccSChristoph Hellwig 13689cf514ccSChristoph Hellwig nfserr = nfsd4_preprocess_layout_stateid(rqstp, cstate, &lgp->lg_sid, 13699cf514ccSChristoph Hellwig true, lgp->lg_layout_type, &ls); 137031ef83dcSChristoph Hellwig if (nfserr) { 137131ef83dcSChristoph Hellwig trace_layout_get_lookup_fail(&lgp->lg_sid); 13729cf514ccSChristoph Hellwig goto out; 137331ef83dcSChristoph Hellwig } 13749cf514ccSChristoph Hellwig 1375c5c707f9SChristoph Hellwig nfserr = nfserr_recallconflict; 1376c5c707f9SChristoph Hellwig if (atomic_read(&ls->ls_stid.sc_file->fi_lo_recalls)) 1377c5c707f9SChristoph Hellwig goto out_put_stid; 1378c5c707f9SChristoph Hellwig 13792b0143b5SDavid Howells nfserr = ops->proc_layoutget(d_inode(current_fh->fh_dentry), 13809cf514ccSChristoph Hellwig current_fh, lgp); 13819cf514ccSChristoph Hellwig if (nfserr) 13829cf514ccSChristoph Hellwig goto out_put_stid; 13839cf514ccSChristoph Hellwig 13849cf514ccSChristoph Hellwig nfserr = nfsd4_insert_layout(lgp, ls); 13859cf514ccSChristoph Hellwig 13869cf514ccSChristoph Hellwig out_put_stid: 1387cc8a5532SJeff Layton mutex_unlock(&ls->ls_mutex); 13889cf514ccSChristoph Hellwig nfs4_put_stid(&ls->ls_stid); 13899cf514ccSChristoph Hellwig out: 13909cf514ccSChristoph Hellwig return nfserr; 13919cf514ccSChristoph Hellwig } 13929cf514ccSChristoph Hellwig 13939cf514ccSChristoph Hellwig static __be32 13949cf514ccSChristoph Hellwig nfsd4_layoutcommit(struct svc_rqst *rqstp, 13959cf514ccSChristoph Hellwig struct nfsd4_compound_state *cstate, 13969cf514ccSChristoph Hellwig struct nfsd4_layoutcommit *lcp) 13979cf514ccSChristoph Hellwig { 13989cf514ccSChristoph Hellwig const struct nfsd4_layout_seg *seg = &lcp->lc_seg; 13999cf514ccSChristoph Hellwig struct svc_fh *current_fh = &cstate->current_fh; 14009cf514ccSChristoph Hellwig const struct nfsd4_layout_ops *ops; 14019cf514ccSChristoph Hellwig loff_t new_size = lcp->lc_last_wr + 1; 14029cf514ccSChristoph Hellwig struct inode *inode; 14039cf514ccSChristoph Hellwig struct nfs4_layout_stateid *ls; 14049cf514ccSChristoph Hellwig __be32 nfserr; 14059cf514ccSChristoph Hellwig 14069cf514ccSChristoph Hellwig nfserr = fh_verify(rqstp, current_fh, 0, NFSD_MAY_WRITE); 14079cf514ccSChristoph Hellwig if (nfserr) 14089cf514ccSChristoph Hellwig goto out; 14099cf514ccSChristoph Hellwig 14109cf514ccSChristoph Hellwig nfserr = nfserr_layoutunavailable; 14119cf514ccSChristoph Hellwig ops = nfsd4_layout_verify(current_fh->fh_export, lcp->lc_layout_type); 14129cf514ccSChristoph Hellwig if (!ops) 14139cf514ccSChristoph Hellwig goto out; 14142b0143b5SDavid Howells inode = d_inode(current_fh->fh_dentry); 14159cf514ccSChristoph Hellwig 14169cf514ccSChristoph Hellwig nfserr = nfserr_inval; 14179cf514ccSChristoph Hellwig if (new_size <= seg->offset) { 14189cf514ccSChristoph Hellwig dprintk("pnfsd: last write before layout segment\n"); 14199cf514ccSChristoph Hellwig goto out; 14209cf514ccSChristoph Hellwig } 14219cf514ccSChristoph Hellwig if (new_size > seg->offset + seg->length) { 14229cf514ccSChristoph Hellwig dprintk("pnfsd: last write beyond layout segment\n"); 14239cf514ccSChristoph Hellwig goto out; 14249cf514ccSChristoph Hellwig } 14259cf514ccSChristoph Hellwig if (!lcp->lc_newoffset && new_size > i_size_read(inode)) { 14269cf514ccSChristoph Hellwig dprintk("pnfsd: layoutcommit beyond EOF\n"); 14279cf514ccSChristoph Hellwig goto out; 14289cf514ccSChristoph Hellwig } 14299cf514ccSChristoph Hellwig 14309cf514ccSChristoph Hellwig nfserr = nfsd4_preprocess_layout_stateid(rqstp, cstate, &lcp->lc_sid, 14319cf514ccSChristoph Hellwig false, lcp->lc_layout_type, 14329cf514ccSChristoph Hellwig &ls); 14339cf514ccSChristoph Hellwig if (nfserr) { 143431ef83dcSChristoph Hellwig trace_layout_commit_lookup_fail(&lcp->lc_sid); 14359cf514ccSChristoph Hellwig /* fixup error code as per RFC5661 */ 14369cf514ccSChristoph Hellwig if (nfserr == nfserr_bad_stateid) 14379cf514ccSChristoph Hellwig nfserr = nfserr_badlayout; 14389cf514ccSChristoph Hellwig goto out; 14399cf514ccSChristoph Hellwig } 14409cf514ccSChristoph Hellwig 1441cc8a5532SJeff Layton /* LAYOUTCOMMIT does not require any serialization */ 1442cc8a5532SJeff Layton mutex_unlock(&ls->ls_mutex); 1443cc8a5532SJeff Layton 14449cf514ccSChristoph Hellwig if (new_size > i_size_read(inode)) { 14459cf514ccSChristoph Hellwig lcp->lc_size_chg = 1; 14469cf514ccSChristoph Hellwig lcp->lc_newsize = new_size; 14479cf514ccSChristoph Hellwig } else { 14489cf514ccSChristoph Hellwig lcp->lc_size_chg = 0; 14499cf514ccSChristoph Hellwig } 14509cf514ccSChristoph Hellwig 1451d8398fc1SKinglong Mee nfserr = ops->proc_layoutcommit(inode, lcp); 14529cf514ccSChristoph Hellwig nfs4_put_stid(&ls->ls_stid); 14539cf514ccSChristoph Hellwig out: 14549cf514ccSChristoph Hellwig return nfserr; 14559cf514ccSChristoph Hellwig } 14569cf514ccSChristoph Hellwig 14579cf514ccSChristoph Hellwig static __be32 14589cf514ccSChristoph Hellwig nfsd4_layoutreturn(struct svc_rqst *rqstp, 14599cf514ccSChristoph Hellwig struct nfsd4_compound_state *cstate, 14609cf514ccSChristoph Hellwig struct nfsd4_layoutreturn *lrp) 14619cf514ccSChristoph Hellwig { 14629cf514ccSChristoph Hellwig struct svc_fh *current_fh = &cstate->current_fh; 14639cf514ccSChristoph Hellwig __be32 nfserr; 14649cf514ccSChristoph Hellwig 14659cf514ccSChristoph Hellwig nfserr = fh_verify(rqstp, current_fh, 0, NFSD_MAY_NOP); 14669cf514ccSChristoph Hellwig if (nfserr) 14679cf514ccSChristoph Hellwig goto out; 14689cf514ccSChristoph Hellwig 14699cf514ccSChristoph Hellwig nfserr = nfserr_layoutunavailable; 14709cf514ccSChristoph Hellwig if (!nfsd4_layout_verify(current_fh->fh_export, lrp->lr_layout_type)) 14719cf514ccSChristoph Hellwig goto out; 14729cf514ccSChristoph Hellwig 14739cf514ccSChristoph Hellwig switch (lrp->lr_seg.iomode) { 14749cf514ccSChristoph Hellwig case IOMODE_READ: 14759cf514ccSChristoph Hellwig case IOMODE_RW: 14769cf514ccSChristoph Hellwig case IOMODE_ANY: 14779cf514ccSChristoph Hellwig break; 14789cf514ccSChristoph Hellwig default: 14799cf514ccSChristoph Hellwig dprintk("%s: invalid iomode %d\n", __func__, 14809cf514ccSChristoph Hellwig lrp->lr_seg.iomode); 14819cf514ccSChristoph Hellwig nfserr = nfserr_inval; 14829cf514ccSChristoph Hellwig goto out; 14839cf514ccSChristoph Hellwig } 14849cf514ccSChristoph Hellwig 14859cf514ccSChristoph Hellwig switch (lrp->lr_return_type) { 14869cf514ccSChristoph Hellwig case RETURN_FILE: 14879cf514ccSChristoph Hellwig nfserr = nfsd4_return_file_layouts(rqstp, cstate, lrp); 14889cf514ccSChristoph Hellwig break; 14899cf514ccSChristoph Hellwig case RETURN_FSID: 14909cf514ccSChristoph Hellwig case RETURN_ALL: 14919cf514ccSChristoph Hellwig nfserr = nfsd4_return_client_layouts(rqstp, cstate, lrp); 14929cf514ccSChristoph Hellwig break; 14939cf514ccSChristoph Hellwig default: 14949cf514ccSChristoph Hellwig dprintk("%s: invalid return_type %d\n", __func__, 14959cf514ccSChristoph Hellwig lrp->lr_return_type); 14969cf514ccSChristoph Hellwig nfserr = nfserr_inval; 14979cf514ccSChristoph Hellwig break; 14989cf514ccSChristoph Hellwig } 14999cf514ccSChristoph Hellwig out: 15009cf514ccSChristoph Hellwig return nfserr; 15019cf514ccSChristoph Hellwig } 15029cf514ccSChristoph Hellwig #endif /* CONFIG_NFSD_PNFS */ 15039cf514ccSChristoph Hellwig 15041da177e4SLinus Torvalds /* 15051da177e4SLinus Torvalds * NULL call. 15061da177e4SLinus Torvalds */ 15077111c66eSAl Viro static __be32 15081da177e4SLinus Torvalds nfsd4_proc_null(struct svc_rqst *rqstp, void *argp, void *resp) 15091da177e4SLinus Torvalds { 15101da177e4SLinus Torvalds return nfs_ok; 15111da177e4SLinus Torvalds } 15121da177e4SLinus Torvalds 1513e2b20950SShankar Anand static inline void nfsd4_increment_op_stats(u32 opnum) 1514e2b20950SShankar Anand { 1515e2b20950SShankar Anand if (opnum >= FIRST_NFS4_OP && opnum <= LAST_NFS4_OP) 1516e2b20950SShankar Anand nfsdstats.nfs4_opcount[opnum]++; 1517e2b20950SShankar Anand } 1518e2b20950SShankar Anand 1519b591480bSJ.Bruce Fields typedef __be32(*nfsd4op_func)(struct svc_rqst *, struct nfsd4_compound_state *, 1520b591480bSJ.Bruce Fields void *); 152158e7b33aSMi Jinlong typedef u32(*nfsd4op_rsize)(struct svc_rqst *, struct nfsd4_op *op); 15228b70484cSTigran Mkrtchyan typedef void(*stateid_setter)(struct nfsd4_compound_state *, void *); 15238b70484cSTigran Mkrtchyan typedef void(*stateid_getter)(struct nfsd4_compound_state *, void *); 152458e7b33aSMi Jinlong 1525f9bb94c4SAndy Adamson enum nfsd4_op_flags { 1526f9bb94c4SAndy Adamson ALLOWED_WITHOUT_FH = 1 << 0, /* No current filehandle required */ 15275ece3cafSMi Jinlong ALLOWED_ON_ABSENT_FS = 1 << 1, /* ops processed on absent fs */ 15285ece3cafSMi Jinlong ALLOWED_AS_FIRST_OP = 1 << 2, /* ops reqired first in compound */ 152968d93184SJ. Bruce Fields /* For rfc 5661 section 2.6.3.1.1: */ 153068d93184SJ. Bruce Fields OP_HANDLES_WRONGSEC = 1 << 3, 153168d93184SJ. Bruce Fields OP_IS_PUTFH_LIKE = 1 << 4, 15321091006cSJ. Bruce Fields /* 1533c856694eSJ. Bruce Fields * These are the ops whose result size we estimate before 1534c856694eSJ. Bruce Fields * encoding, to avoid performing an op then not being able to 1535c856694eSJ. Bruce Fields * respond or cache a response. This includes writes and setattrs 1536c856694eSJ. Bruce Fields * as well as the operations usually called "nonidempotent": 1537c856694eSJ. Bruce Fields */ 1538c856694eSJ. Bruce Fields OP_MODIFIES_SOMETHING = 1 << 5, 1539c856694eSJ. Bruce Fields /* 1540c856694eSJ. Bruce Fields * Cache compounds containing these ops in the xid-based drc: 15411091006cSJ. Bruce Fields * We use the DRC for compounds containing non-idempotent 15421091006cSJ. Bruce Fields * operations, *except* those that are 4.1-specific (since 15431091006cSJ. Bruce Fields * sessions provide their own EOS), and except for stateful 15441091006cSJ. Bruce Fields * operations other than setclientid and setclientid_confirm 15451091006cSJ. Bruce Fields * (since sequence numbers provide EOS for open, lock, etc in 15461091006cSJ. Bruce Fields * the v4.0 case). 15471091006cSJ. Bruce Fields */ 1548c856694eSJ. Bruce Fields OP_CACHEME = 1 << 6, 15498b70484cSTigran Mkrtchyan /* 15508b70484cSTigran Mkrtchyan * These are ops which clear current state id. 15518b70484cSTigran Mkrtchyan */ 15528b70484cSTigran Mkrtchyan OP_CLEAR_STATEID = 1 << 7, 1553c856694eSJ. Bruce Fields }; 1554c856694eSJ. Bruce Fields 1555c856694eSJ. Bruce Fields struct nfsd4_operation { 1556c856694eSJ. Bruce Fields nfsd4op_func op_func; 1557c856694eSJ. Bruce Fields u32 op_flags; 1558c856694eSJ. Bruce Fields char *op_name; 155958e7b33aSMi Jinlong /* Try to get response size before operation */ 156058e7b33aSMi Jinlong nfsd4op_rsize op_rsize_bop; 156124ff99c6SBryan Schumaker stateid_getter op_get_currentstateid; 156224ff99c6SBryan Schumaker stateid_setter op_set_currentstateid; 1563b591480bSJ.Bruce Fields }; 1564b591480bSJ.Bruce Fields 1565b591480bSJ.Bruce Fields static struct nfsd4_operation nfsd4_ops[]; 1566b591480bSJ.Bruce Fields 1567f1c7f79bSAdrian Bunk static const char *nfsd4_op_name(unsigned opnum); 1568b001a1b6SBenny Halevy 15691da177e4SLinus Torvalds /* 157057716355SJ. Bruce Fields * Enforce NFSv4.1 COMPOUND ordering rules: 1571f9bb94c4SAndy Adamson * 157257716355SJ. Bruce Fields * Also note, enforced elsewhere: 157357716355SJ. Bruce Fields * - SEQUENCE other than as first op results in 157457716355SJ. Bruce Fields * NFS4ERR_SEQUENCE_POS. (Enforced in nfsd4_sequence().) 15751d1bc8f2SJ. Bruce Fields * - BIND_CONN_TO_SESSION must be the only op in its compound. 15761d1bc8f2SJ. Bruce Fields * (Enforced in nfsd4_bind_conn_to_session().) 157757716355SJ. Bruce Fields * - DESTROY_SESSION must be the final operation in a compound, if 157857716355SJ. Bruce Fields * sessionid's in SEQUENCE and DESTROY_SESSION are the same. 157957716355SJ. Bruce Fields * (Enforced in nfsd4_destroy_session().) 1580f9bb94c4SAndy Adamson */ 158157716355SJ. Bruce Fields static __be32 nfs41_check_op_ordering(struct nfsd4_compoundargs *args) 1582f9bb94c4SAndy Adamson { 1583f9bb94c4SAndy Adamson struct nfsd4_op *op = &args->ops[0]; 158457716355SJ. Bruce Fields 158557716355SJ. Bruce Fields /* These ordering requirements don't apply to NFSv4.0: */ 158657716355SJ. Bruce Fields if (args->minorversion == 0) 158757716355SJ. Bruce Fields return nfs_ok; 158857716355SJ. Bruce Fields /* This is weird, but OK, not our problem: */ 158957716355SJ. Bruce Fields if (args->opcnt == 0) 159057716355SJ. Bruce Fields return nfs_ok; 159157716355SJ. Bruce Fields if (op->status == nfserr_op_illegal) 159257716355SJ. Bruce Fields return nfs_ok; 159357716355SJ. Bruce Fields if (!(nfsd4_ops[op->opnum].op_flags & ALLOWED_AS_FIRST_OP)) 159457716355SJ. Bruce Fields return nfserr_op_not_in_session; 159557716355SJ. Bruce Fields if (op->opnum == OP_SEQUENCE) 159657716355SJ. Bruce Fields return nfs_ok; 159757716355SJ. Bruce Fields if (args->opcnt != 1) 159857716355SJ. Bruce Fields return nfserr_not_only_op; 159957716355SJ. Bruce Fields return nfs_ok; 1600f9bb94c4SAndy Adamson } 1601f9bb94c4SAndy Adamson 160222b03214SJ. Bruce Fields static inline struct nfsd4_operation *OPDESC(struct nfsd4_op *op) 160322b03214SJ. Bruce Fields { 160422b03214SJ. Bruce Fields return &nfsd4_ops[op->opnum]; 160522b03214SJ. Bruce Fields } 160622b03214SJ. Bruce Fields 16071091006cSJ. Bruce Fields bool nfsd4_cache_this_op(struct nfsd4_op *op) 16081091006cSJ. Bruce Fields { 1609e372ba60SJ. Bruce Fields if (op->opnum == OP_ILLEGAL) 1610e372ba60SJ. Bruce Fields return false; 1611c856694eSJ. Bruce Fields return OPDESC(op)->op_flags & OP_CACHEME; 16121091006cSJ. Bruce Fields } 16131091006cSJ. Bruce Fields 161468d93184SJ. Bruce Fields static bool need_wrongsec_check(struct svc_rqst *rqstp) 161568d93184SJ. Bruce Fields { 161668d93184SJ. Bruce Fields struct nfsd4_compoundres *resp = rqstp->rq_resp; 161768d93184SJ. Bruce Fields struct nfsd4_compoundargs *argp = rqstp->rq_argp; 161868d93184SJ. Bruce Fields struct nfsd4_op *this = &argp->ops[resp->opcnt - 1]; 161968d93184SJ. Bruce Fields struct nfsd4_op *next = &argp->ops[resp->opcnt]; 162068d93184SJ. Bruce Fields struct nfsd4_operation *thisd; 162168d93184SJ. Bruce Fields struct nfsd4_operation *nextd; 162268d93184SJ. Bruce Fields 162368d93184SJ. Bruce Fields thisd = OPDESC(this); 162468d93184SJ. Bruce Fields /* 162568d93184SJ. Bruce Fields * Most ops check wronsec on our own; only the putfh-like ops 162668d93184SJ. Bruce Fields * have special rules. 162768d93184SJ. Bruce Fields */ 162868d93184SJ. Bruce Fields if (!(thisd->op_flags & OP_IS_PUTFH_LIKE)) 162968d93184SJ. Bruce Fields return false; 163068d93184SJ. Bruce Fields /* 163168d93184SJ. Bruce Fields * rfc 5661 2.6.3.1.1.6: don't bother erroring out a 163268d93184SJ. Bruce Fields * put-filehandle operation if we're not going to use the 163368d93184SJ. Bruce Fields * result: 163468d93184SJ. Bruce Fields */ 163568d93184SJ. Bruce Fields if (argp->opcnt == resp->opcnt) 163668d93184SJ. Bruce Fields return false; 163751904b08SJ. Bruce Fields if (next->opnum == OP_ILLEGAL) 163851904b08SJ. Bruce Fields return false; 163968d93184SJ. Bruce Fields nextd = OPDESC(next); 164068d93184SJ. Bruce Fields /* 164168d93184SJ. Bruce Fields * Rest of 2.6.3.1.1: certain operations will return WRONGSEC 164268d93184SJ. Bruce Fields * errors themselves as necessary; others should check for them 164368d93184SJ. Bruce Fields * now: 164468d93184SJ. Bruce Fields */ 164568d93184SJ. Bruce Fields return !(nextd->op_flags & OP_HANDLES_WRONGSEC); 164668d93184SJ. Bruce Fields } 164768d93184SJ. Bruce Fields 16482d124dfaSJ. Bruce Fields static void svcxdr_init_encode(struct svc_rqst *rqstp, 16492d124dfaSJ. Bruce Fields struct nfsd4_compoundres *resp) 16502d124dfaSJ. Bruce Fields { 16512d124dfaSJ. Bruce Fields struct xdr_stream *xdr = &resp->xdr; 16522d124dfaSJ. Bruce Fields struct xdr_buf *buf = &rqstp->rq_res; 16532d124dfaSJ. Bruce Fields struct kvec *head = buf->head; 16542d124dfaSJ. Bruce Fields 16552d124dfaSJ. Bruce Fields xdr->buf = buf; 1656ddd1ea56SJ. Bruce Fields xdr->iov = head; 16572d124dfaSJ. Bruce Fields xdr->p = head->iov_base + head->iov_len; 1658a5cddc88SJ. Bruce Fields xdr->end = head->iov_base + PAGE_SIZE - rqstp->rq_auth_slack; 16596ac90391SJ. Bruce Fields /* Tail and page_len should be zero at this point: */ 16606ac90391SJ. Bruce Fields buf->len = buf->head[0].iov_len; 16612825a7f9SJ. Bruce Fields xdr->scratch.iov_len = 0; 166205638dc7SJ. Bruce Fields xdr->page_ptr = buf->pages - 1; 16632825a7f9SJ. Bruce Fields buf->buflen = PAGE_SIZE * (1 + rqstp->rq_page_end - buf->pages) 1664a5cddc88SJ. Bruce Fields - rqstp->rq_auth_slack; 16652d124dfaSJ. Bruce Fields } 16662d124dfaSJ. Bruce Fields 1667f9bb94c4SAndy Adamson /* 16681da177e4SLinus Torvalds * COMPOUND call. 16691da177e4SLinus Torvalds */ 16707111c66eSAl Viro static __be32 16711da177e4SLinus Torvalds nfsd4_proc_compound(struct svc_rqst *rqstp, 16721da177e4SLinus Torvalds struct nfsd4_compoundargs *args, 16731da177e4SLinus Torvalds struct nfsd4_compoundres *resp) 16741da177e4SLinus Torvalds { 16751da177e4SLinus Torvalds struct nfsd4_op *op; 1676b591480bSJ.Bruce Fields struct nfsd4_operation *opdesc; 1677e354d571SAndy Adamson struct nfsd4_compound_state *cstate = &resp->cstate; 16784daeed25SKinglong Mee struct svc_fh *current_fh = &cstate->current_fh; 16794daeed25SKinglong Mee struct svc_fh *save_fh = &cstate->save_fh; 1680b37ad28bSAl Viro __be32 status; 16811da177e4SLinus Torvalds 16822d124dfaSJ. Bruce Fields svcxdr_init_encode(rqstp, resp); 16834aea24b2SJ. Bruce Fields resp->tagp = resp->xdr.p; 16841da177e4SLinus Torvalds /* reserve space for: taglen, tag, and opcnt */ 1685d3f627c8SJ. Bruce Fields xdr_reserve_space(&resp->xdr, 8 + args->taglen); 16861da177e4SLinus Torvalds resp->taglen = args->taglen; 16871da177e4SLinus Torvalds resp->tag = args->tag; 16881da177e4SLinus Torvalds resp->rqstp = rqstp; 16894daeed25SKinglong Mee cstate->minorversion = args->minorversion; 16904daeed25SKinglong Mee fh_init(current_fh, NFS4_FHSIZE); 16914daeed25SKinglong Mee fh_init(save_fh, NFS4_FHSIZE); 16928ff30fa4SNeilBrown /* 16938ff30fa4SNeilBrown * Don't use the deferral mechanism for NFSv4; compounds make it 16948ff30fa4SNeilBrown * too hard to avoid non-idempotency problems. 16958ff30fa4SNeilBrown */ 169630660e04SJeff Layton clear_bit(RQ_USEDEFERRAL, &rqstp->rq_flags); 16971da177e4SLinus Torvalds 16981da177e4SLinus Torvalds /* 16991da177e4SLinus Torvalds * According to RFC3010, this takes precedence over all other errors. 17001da177e4SLinus Torvalds */ 17011da177e4SLinus Torvalds status = nfserr_minor_vers_mismatch; 170235f7a14fSJ. Bruce Fields if (nfsd_minorversion(args->minorversion, NFSD_TEST) <= 0) 17031da177e4SLinus Torvalds goto out; 17041da177e4SLinus Torvalds 170557716355SJ. Bruce Fields status = nfs41_check_op_ordering(args); 170657716355SJ. Bruce Fields if (status) { 1707f9bb94c4SAndy Adamson op = &args->ops[0]; 170857716355SJ. Bruce Fields op->status = status; 1709f9bb94c4SAndy Adamson goto encode_op; 1710f9bb94c4SAndy Adamson } 1711f9bb94c4SAndy Adamson 17121da177e4SLinus Torvalds while (!status && resp->opcnt < args->opcnt) { 17131da177e4SLinus Torvalds op = &args->ops[resp->opcnt++]; 17141da177e4SLinus Torvalds 1715b001a1b6SBenny Halevy dprintk("nfsv4 compound op #%d/%d: %d (%s)\n", 1716b001a1b6SBenny Halevy resp->opcnt, args->opcnt, op->opnum, 1717b001a1b6SBenny Halevy nfsd4_op_name(op->opnum)); 17181da177e4SLinus Torvalds /* 17191da177e4SLinus Torvalds * The XDR decode routines may have pre-set op->status; 17201da177e4SLinus Torvalds * for example, if there is a miscellaneous XDR error 17211da177e4SLinus Torvalds * it will be set to nfserr_bad_xdr. 17221da177e4SLinus Torvalds */ 17239d313b17SJ. Bruce Fields if (op->status) { 17249d313b17SJ. Bruce Fields if (op->opnum == OP_OPEN) 17259d313b17SJ. Bruce Fields op->status = nfsd4_open_omfg(rqstp, cstate, op); 17261da177e4SLinus Torvalds goto encode_op; 17279d313b17SJ. Bruce Fields } 17281da177e4SLinus Torvalds 172922b03214SJ. Bruce Fields opdesc = OPDESC(op); 1730b591480bSJ.Bruce Fields 17314daeed25SKinglong Mee if (!current_fh->fh_dentry) { 173227d630ecSJ.Bruce Fields if (!(opdesc->op_flags & ALLOWED_WITHOUT_FH)) { 17331da177e4SLinus Torvalds op->status = nfserr_nofilehandle; 17341da177e4SLinus Torvalds goto encode_op; 17351da177e4SLinus Torvalds } 17364daeed25SKinglong Mee } else if (current_fh->fh_export->ex_fslocs.migrated && 1737eeac294eSJ.Bruce Fields !(opdesc->op_flags & ALLOWED_ON_ABSENT_FS)) { 173842ca0993SJ.Bruce Fields op->status = nfserr_moved; 173942ca0993SJ.Bruce Fields goto encode_op; 174042ca0993SJ.Bruce Fields } 1741b591480bSJ.Bruce Fields 17422336745eSKinglong Mee fh_clear_wcc(current_fh); 17432336745eSKinglong Mee 174458e7b33aSMi Jinlong /* If op is non-idempotent */ 174558e7b33aSMi Jinlong if (opdesc->op_flags & OP_MODIFIES_SOMETHING) { 17464c69d585SJ. Bruce Fields /* 1747a8095f7eSJ. Bruce Fields * Don't execute this op if we couldn't encode a 1748a8095f7eSJ. Bruce Fields * succesful reply: 1749a8095f7eSJ. Bruce Fields */ 1750a8095f7eSJ. Bruce Fields u32 plen = opdesc->op_rsize_bop(rqstp, op); 1751a8095f7eSJ. Bruce Fields /* 1752a8095f7eSJ. Bruce Fields * Plus if there's another operation, make sure 17534c69d585SJ. Bruce Fields * we'll have space to at least encode an error: 17544c69d585SJ. Bruce Fields */ 17554c69d585SJ. Bruce Fields if (resp->opcnt < args->opcnt) 17564c69d585SJ. Bruce Fields plen += COMPOUND_ERR_SLACK_SPACE; 175758e7b33aSMi Jinlong op->status = nfsd4_check_resp_size(resp, plen); 175858e7b33aSMi Jinlong } 175958e7b33aSMi Jinlong 176058e7b33aSMi Jinlong if (op->status) 176158e7b33aSMi Jinlong goto encode_op; 176258e7b33aSMi Jinlong 17638b70484cSTigran Mkrtchyan if (opdesc->op_get_currentstateid) 17648b70484cSTigran Mkrtchyan opdesc->op_get_currentstateid(cstate, &op->u); 1765b591480bSJ.Bruce Fields op->status = opdesc->op_func(rqstp, cstate, &op->u); 17661da177e4SLinus Torvalds 17678b70484cSTigran Mkrtchyan if (!op->status) { 17688b70484cSTigran Mkrtchyan if (opdesc->op_set_currentstateid) 17698b70484cSTigran Mkrtchyan opdesc->op_set_currentstateid(cstate, &op->u); 17708b70484cSTigran Mkrtchyan 17718b70484cSTigran Mkrtchyan if (opdesc->op_flags & OP_CLEAR_STATEID) 177237c593c5STigran Mkrtchyan clear_current_stateid(cstate); 17738b70484cSTigran Mkrtchyan 17748b70484cSTigran Mkrtchyan if (need_wrongsec_check(rqstp)) 17754daeed25SKinglong Mee op->status = check_nfsd_access(current_fh->fh_export, rqstp); 17768b70484cSTigran Mkrtchyan } 177768d93184SJ. Bruce Fields 17781da177e4SLinus Torvalds encode_op: 177949557cc7SAndy Adamson /* Only from SEQUENCE */ 17804daeed25SKinglong Mee if (cstate->status == nfserr_replay_cache) { 1781da3846a2SAndy Adamson dprintk("%s NFS4.1 replay from cache\n", __func__); 1782da3846a2SAndy Adamson status = op->status; 1783da3846a2SAndy Adamson goto out; 1784da3846a2SAndy Adamson } 1785a90b061cSAl Viro if (op->status == nfserr_replay_me) { 1786a4f1706aSJ.Bruce Fields op->replay = &cstate->replay_owner->so_replay; 1787d0a381ddSJ. Bruce Fields nfsd4_encode_replay(&resp->xdr, op); 17881da177e4SLinus Torvalds status = op->status = op->replay->rp_status; 17891da177e4SLinus Torvalds } else { 17901da177e4SLinus Torvalds nfsd4_encode_operation(resp, op); 17911da177e4SLinus Torvalds status = op->status; 17921da177e4SLinus Torvalds } 17930407717dSBenny Halevy 17940407717dSBenny Halevy dprintk("nfsv4 compound op %p opcnt %d #%d: %d: status %d\n", 17950407717dSBenny Halevy args->ops, args->opcnt, resp->opcnt, op->opnum, 17960407717dSBenny Halevy be32_to_cpu(status)); 17970407717dSBenny Halevy 179858fb12e6SJeff Layton nfsd4_cstate_clear_replay(cstate); 1799e2b20950SShankar Anand nfsd4_increment_op_stats(op->opnum); 18001da177e4SLinus Torvalds } 18011da177e4SLinus Torvalds 18024daeed25SKinglong Mee cstate->status = status; 18034daeed25SKinglong Mee fh_put(current_fh); 18044daeed25SKinglong Mee fh_put(save_fh); 18054daeed25SKinglong Mee BUG_ON(cstate->replay_owner); 18061da177e4SLinus Torvalds out: 18072f425878SAndy Adamson /* Reset deferral mechanism for RPC deferrals */ 180830660e04SJeff Layton set_bit(RQ_USEDEFERRAL, &rqstp->rq_flags); 18093b12cd98SJ. Bruce Fields dprintk("nfsv4 compound returned %d\n", ntohl(status)); 18101da177e4SLinus Torvalds return status; 18111da177e4SLinus Torvalds } 18121da177e4SLinus Torvalds 181358e7b33aSMi Jinlong #define op_encode_hdr_size (2) 181458e7b33aSMi Jinlong #define op_encode_stateid_maxsz (XDR_QUADLEN(NFS4_STATEID_SIZE)) 181558e7b33aSMi Jinlong #define op_encode_verifier_maxsz (XDR_QUADLEN(NFS4_VERIFIER_SIZE)) 181658e7b33aSMi Jinlong #define op_encode_change_info_maxsz (5) 181758e7b33aSMi Jinlong #define nfs4_fattr_bitmap_maxsz (4) 181858e7b33aSMi Jinlong 18198c7424cfSJ. Bruce Fields /* We'll fall back on returning no lockowner if run out of space: */ 18208c7424cfSJ. Bruce Fields #define op_encode_lockowner_maxsz (0) 182158e7b33aSMi Jinlong #define op_encode_lock_denied_maxsz (8 + op_encode_lockowner_maxsz) 182258e7b33aSMi Jinlong 182358e7b33aSMi Jinlong #define nfs4_owner_maxsz (1 + XDR_QUADLEN(IDMAP_NAMESZ)) 182458e7b33aSMi Jinlong 182558e7b33aSMi Jinlong #define op_encode_ace_maxsz (3 + nfs4_owner_maxsz) 182658e7b33aSMi Jinlong #define op_encode_delegation_maxsz (1 + op_encode_stateid_maxsz + 1 + \ 182758e7b33aSMi Jinlong op_encode_ace_maxsz) 182858e7b33aSMi Jinlong 182958e7b33aSMi Jinlong #define op_encode_channel_attrs_maxsz (6 + 1 + 1) 183058e7b33aSMi Jinlong 183158e7b33aSMi Jinlong static inline u32 nfsd4_only_status_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 183258e7b33aSMi Jinlong { 183358e7b33aSMi Jinlong return (op_encode_hdr_size) * sizeof(__be32); 183458e7b33aSMi Jinlong } 183558e7b33aSMi Jinlong 183658e7b33aSMi Jinlong static inline u32 nfsd4_status_stateid_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 183758e7b33aSMi Jinlong { 183858e7b33aSMi Jinlong return (op_encode_hdr_size + op_encode_stateid_maxsz)* sizeof(__be32); 183958e7b33aSMi Jinlong } 184058e7b33aSMi Jinlong 184158e7b33aSMi Jinlong static inline u32 nfsd4_commit_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 184258e7b33aSMi Jinlong { 184358e7b33aSMi Jinlong return (op_encode_hdr_size + op_encode_verifier_maxsz) * sizeof(__be32); 184458e7b33aSMi Jinlong } 184558e7b33aSMi Jinlong 184658e7b33aSMi Jinlong static inline u32 nfsd4_create_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 184758e7b33aSMi Jinlong { 184858e7b33aSMi Jinlong return (op_encode_hdr_size + op_encode_change_info_maxsz 184958e7b33aSMi Jinlong + nfs4_fattr_bitmap_maxsz) * sizeof(__be32); 185058e7b33aSMi Jinlong } 185158e7b33aSMi Jinlong 1852b86cef60SJ. Bruce Fields /* 1853b86cef60SJ. Bruce Fields * Note since this is an idempotent operation we won't insist on failing 1854b86cef60SJ. Bruce Fields * the op prematurely if the estimate is too large. We may turn off splice 1855b86cef60SJ. Bruce Fields * reads unnecessarily. 1856b86cef60SJ. Bruce Fields */ 1857b86cef60SJ. Bruce Fields static inline u32 nfsd4_getattr_rsize(struct svc_rqst *rqstp, 1858b86cef60SJ. Bruce Fields struct nfsd4_op *op) 1859b86cef60SJ. Bruce Fields { 1860b86cef60SJ. Bruce Fields u32 *bmap = op->u.getattr.ga_bmval; 1861b86cef60SJ. Bruce Fields u32 bmap0 = bmap[0], bmap1 = bmap[1], bmap2 = bmap[2]; 1862b86cef60SJ. Bruce Fields u32 ret = 0; 1863b86cef60SJ. Bruce Fields 1864b86cef60SJ. Bruce Fields if (bmap0 & FATTR4_WORD0_ACL) 1865b86cef60SJ. Bruce Fields return svc_max_payload(rqstp); 1866b86cef60SJ. Bruce Fields if (bmap0 & FATTR4_WORD0_FS_LOCATIONS) 1867b86cef60SJ. Bruce Fields return svc_max_payload(rqstp); 1868b86cef60SJ. Bruce Fields 1869b86cef60SJ. Bruce Fields if (bmap1 & FATTR4_WORD1_OWNER) { 1870b86cef60SJ. Bruce Fields ret += IDMAP_NAMESZ + 4; 1871b86cef60SJ. Bruce Fields bmap1 &= ~FATTR4_WORD1_OWNER; 1872b86cef60SJ. Bruce Fields } 1873b86cef60SJ. Bruce Fields if (bmap1 & FATTR4_WORD1_OWNER_GROUP) { 1874b86cef60SJ. Bruce Fields ret += IDMAP_NAMESZ + 4; 1875b86cef60SJ. Bruce Fields bmap1 &= ~FATTR4_WORD1_OWNER_GROUP; 1876b86cef60SJ. Bruce Fields } 1877b86cef60SJ. Bruce Fields if (bmap0 & FATTR4_WORD0_FILEHANDLE) { 1878b86cef60SJ. Bruce Fields ret += NFS4_FHSIZE + 4; 1879b86cef60SJ. Bruce Fields bmap0 &= ~FATTR4_WORD0_FILEHANDLE; 1880b86cef60SJ. Bruce Fields } 1881b86cef60SJ. Bruce Fields if (bmap2 & FATTR4_WORD2_SECURITY_LABEL) { 18821ec8c0c4SKinglong Mee ret += NFS4_MAXLABELLEN + 12; 1883b86cef60SJ. Bruce Fields bmap2 &= ~FATTR4_WORD2_SECURITY_LABEL; 1884b86cef60SJ. Bruce Fields } 1885b86cef60SJ. Bruce Fields /* 1886b86cef60SJ. Bruce Fields * Largest of remaining attributes are 16 bytes (e.g., 1887b86cef60SJ. Bruce Fields * supported_attributes) 1888b86cef60SJ. Bruce Fields */ 1889b86cef60SJ. Bruce Fields ret += 16 * (hweight32(bmap0) + hweight32(bmap1) + hweight32(bmap2)); 1890b86cef60SJ. Bruce Fields /* bitmask, length */ 1891b86cef60SJ. Bruce Fields ret += 20; 1892b86cef60SJ. Bruce Fields return ret; 1893b86cef60SJ. Bruce Fields } 1894b86cef60SJ. Bruce Fields 189558e7b33aSMi Jinlong static inline u32 nfsd4_link_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 189658e7b33aSMi Jinlong { 189758e7b33aSMi Jinlong return (op_encode_hdr_size + op_encode_change_info_maxsz) 189858e7b33aSMi Jinlong * sizeof(__be32); 189958e7b33aSMi Jinlong } 190058e7b33aSMi Jinlong 190158e7b33aSMi Jinlong static inline u32 nfsd4_lock_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 190258e7b33aSMi Jinlong { 190358e7b33aSMi Jinlong return (op_encode_hdr_size + op_encode_lock_denied_maxsz) 190458e7b33aSMi Jinlong * sizeof(__be32); 190558e7b33aSMi Jinlong } 190658e7b33aSMi Jinlong 190758e7b33aSMi Jinlong static inline u32 nfsd4_open_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 190858e7b33aSMi Jinlong { 190958e7b33aSMi Jinlong return (op_encode_hdr_size + op_encode_stateid_maxsz 191058e7b33aSMi Jinlong + op_encode_change_info_maxsz + 1 191158e7b33aSMi Jinlong + nfs4_fattr_bitmap_maxsz 191258e7b33aSMi Jinlong + op_encode_delegation_maxsz) * sizeof(__be32); 191358e7b33aSMi Jinlong } 191458e7b33aSMi Jinlong 191558e7b33aSMi Jinlong static inline u32 nfsd4_read_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 191658e7b33aSMi Jinlong { 191758e7b33aSMi Jinlong u32 maxcount = 0, rlen = 0; 191858e7b33aSMi Jinlong 191958e7b33aSMi Jinlong maxcount = svc_max_payload(rqstp); 19203c7aa15dSKinglong Mee rlen = min(op->u.read.rd_length, maxcount); 192158e7b33aSMi Jinlong 1922622f560eSJ. Bruce Fields return (op_encode_hdr_size + 2 + XDR_QUADLEN(rlen)) * sizeof(__be32); 192358e7b33aSMi Jinlong } 192458e7b33aSMi Jinlong 192558e7b33aSMi Jinlong static inline u32 nfsd4_readdir_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 192658e7b33aSMi Jinlong { 19273c7aa15dSKinglong Mee u32 maxcount = 0, rlen = 0; 192858e7b33aSMi Jinlong 19293c7aa15dSKinglong Mee maxcount = svc_max_payload(rqstp); 19303c7aa15dSKinglong Mee rlen = min(op->u.readdir.rd_maxcount, maxcount); 193158e7b33aSMi Jinlong 1932561f0ed4SJ. Bruce Fields return (op_encode_hdr_size + op_encode_verifier_maxsz + 1933561f0ed4SJ. Bruce Fields XDR_QUADLEN(rlen)) * sizeof(__be32); 193458e7b33aSMi Jinlong } 193558e7b33aSMi Jinlong 193658e7b33aSMi Jinlong static inline u32 nfsd4_remove_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 193758e7b33aSMi Jinlong { 193858e7b33aSMi Jinlong return (op_encode_hdr_size + op_encode_change_info_maxsz) 193958e7b33aSMi Jinlong * sizeof(__be32); 194058e7b33aSMi Jinlong } 194158e7b33aSMi Jinlong 194258e7b33aSMi Jinlong static inline u32 nfsd4_rename_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 194358e7b33aSMi Jinlong { 194458e7b33aSMi Jinlong return (op_encode_hdr_size + op_encode_change_info_maxsz 194558e7b33aSMi Jinlong + op_encode_change_info_maxsz) * sizeof(__be32); 194658e7b33aSMi Jinlong } 194758e7b33aSMi Jinlong 1948ccae70a9SJ. Bruce Fields static inline u32 nfsd4_sequence_rsize(struct svc_rqst *rqstp, 1949ccae70a9SJ. Bruce Fields struct nfsd4_op *op) 1950ccae70a9SJ. Bruce Fields { 1951d1d84c96SJ. Bruce Fields return (op_encode_hdr_size 1952d1d84c96SJ. Bruce Fields + XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + 5) * sizeof(__be32); 1953ccae70a9SJ. Bruce Fields } 1954ccae70a9SJ. Bruce Fields 195558e7b33aSMi Jinlong static inline u32 nfsd4_setattr_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 195658e7b33aSMi Jinlong { 195758e7b33aSMi Jinlong return (op_encode_hdr_size + nfs4_fattr_bitmap_maxsz) * sizeof(__be32); 195858e7b33aSMi Jinlong } 195958e7b33aSMi Jinlong 196058e7b33aSMi Jinlong static inline u32 nfsd4_setclientid_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 196158e7b33aSMi Jinlong { 1962480efaeeSJ. Bruce Fields return (op_encode_hdr_size + 2 + XDR_QUADLEN(NFS4_VERIFIER_SIZE)) * 1963480efaeeSJ. Bruce Fields sizeof(__be32); 196458e7b33aSMi Jinlong } 196558e7b33aSMi Jinlong 196658e7b33aSMi Jinlong static inline u32 nfsd4_write_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 196758e7b33aSMi Jinlong { 1968f34e432bSJ. Bruce Fields return (op_encode_hdr_size + 2 + op_encode_verifier_maxsz) * sizeof(__be32); 196958e7b33aSMi Jinlong } 197058e7b33aSMi Jinlong 197158e7b33aSMi Jinlong static inline u32 nfsd4_exchange_id_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 197258e7b33aSMi Jinlong { 197358e7b33aSMi Jinlong return (op_encode_hdr_size + 2 + 1 + /* eir_clientid, eir_sequenceid */\ 1974a8bb84bcSKinglong Mee 1 + 1 + /* eir_flags, spr_how */\ 1975a8bb84bcSKinglong Mee 4 + /* spo_must_enforce & _allow with bitmap */\ 197658e7b33aSMi Jinlong 2 + /*eir_server_owner.so_minor_id */\ 197758e7b33aSMi Jinlong /* eir_server_owner.so_major_id<> */\ 197858e7b33aSMi Jinlong XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + 1 +\ 197958e7b33aSMi Jinlong /* eir_server_scope<> */\ 198058e7b33aSMi Jinlong XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + 1 +\ 198158e7b33aSMi Jinlong 1 + /* eir_server_impl_id array length */\ 198258e7b33aSMi Jinlong 0 /* ignored eir_server_impl_id contents */) * sizeof(__be32); 198358e7b33aSMi Jinlong } 198458e7b33aSMi Jinlong 198558e7b33aSMi Jinlong static inline u32 nfsd4_bind_conn_to_session_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 198658e7b33aSMi Jinlong { 198758e7b33aSMi Jinlong return (op_encode_hdr_size + \ 198858e7b33aSMi Jinlong XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + /* bctsr_sessid */\ 198958e7b33aSMi Jinlong 2 /* bctsr_dir, use_conn_in_rdma_mode */) * sizeof(__be32); 199058e7b33aSMi Jinlong } 199158e7b33aSMi Jinlong 199258e7b33aSMi Jinlong static inline u32 nfsd4_create_session_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 199358e7b33aSMi Jinlong { 199458e7b33aSMi Jinlong return (op_encode_hdr_size + \ 199558e7b33aSMi Jinlong XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + /* sessionid */\ 199658e7b33aSMi Jinlong 2 + /* csr_sequence, csr_flags */\ 199758e7b33aSMi Jinlong op_encode_channel_attrs_maxsz + \ 199858e7b33aSMi Jinlong op_encode_channel_attrs_maxsz) * sizeof(__be32); 199958e7b33aSMi Jinlong } 200058e7b33aSMi Jinlong 200129ae7f9dSAnna Schumaker static inline u32 nfsd4_copy_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 200229ae7f9dSAnna Schumaker { 200329ae7f9dSAnna Schumaker return (op_encode_hdr_size + 200429ae7f9dSAnna Schumaker 1 /* wr_callback */ + 200529ae7f9dSAnna Schumaker op_encode_stateid_maxsz /* wr_callback */ + 200629ae7f9dSAnna Schumaker 2 /* wr_count */ + 200729ae7f9dSAnna Schumaker 1 /* wr_committed */ + 200829ae7f9dSAnna Schumaker op_encode_verifier_maxsz + 200929ae7f9dSAnna Schumaker 1 /* cr_consecutive */ + 201029ae7f9dSAnna Schumaker 1 /* cr_synchronous */) * sizeof(__be32); 201129ae7f9dSAnna Schumaker } 201229ae7f9dSAnna Schumaker 20139cf514ccSChristoph Hellwig #ifdef CONFIG_NFSD_PNFS 20149cf514ccSChristoph Hellwig /* 20159cf514ccSChristoph Hellwig * At this stage we don't really know what layout driver will handle the request, 20169cf514ccSChristoph Hellwig * so we need to define an arbitrary upper bound here. 20179cf514ccSChristoph Hellwig */ 20189cf514ccSChristoph Hellwig #define MAX_LAYOUT_SIZE 128 20199cf514ccSChristoph Hellwig static inline u32 nfsd4_layoutget_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 20209cf514ccSChristoph Hellwig { 20219cf514ccSChristoph Hellwig return (op_encode_hdr_size + 20229cf514ccSChristoph Hellwig 1 /* logr_return_on_close */ + 20239cf514ccSChristoph Hellwig op_encode_stateid_maxsz + 20249cf514ccSChristoph Hellwig 1 /* nr of layouts */ + 20259cf514ccSChristoph Hellwig MAX_LAYOUT_SIZE) * sizeof(__be32); 20269cf514ccSChristoph Hellwig } 20279cf514ccSChristoph Hellwig 20289cf514ccSChristoph Hellwig static inline u32 nfsd4_layoutcommit_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 20299cf514ccSChristoph Hellwig { 20309cf514ccSChristoph Hellwig return (op_encode_hdr_size + 20319cf514ccSChristoph Hellwig 1 /* locr_newsize */ + 20329cf514ccSChristoph Hellwig 2 /* ns_size */) * sizeof(__be32); 20339cf514ccSChristoph Hellwig } 20349cf514ccSChristoph Hellwig 20359cf514ccSChristoph Hellwig static inline u32 nfsd4_layoutreturn_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 20369cf514ccSChristoph Hellwig { 20379cf514ccSChristoph Hellwig return (op_encode_hdr_size + 20389cf514ccSChristoph Hellwig 1 /* lrs_stateid */ + 20399cf514ccSChristoph Hellwig op_encode_stateid_maxsz) * sizeof(__be32); 20409cf514ccSChristoph Hellwig } 20419cf514ccSChristoph Hellwig #endif /* CONFIG_NFSD_PNFS */ 20429cf514ccSChristoph Hellwig 204320766016SBenny Halevy static struct nfsd4_operation nfsd4_ops[] = { 2044b591480bSJ.Bruce Fields [OP_ACCESS] = { 2045b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_access, 2046b001a1b6SBenny Halevy .op_name = "OP_ACCESS", 2047b591480bSJ.Bruce Fields }, 2048b591480bSJ.Bruce Fields [OP_CLOSE] = { 2049b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_close, 205058e7b33aSMi Jinlong .op_flags = OP_MODIFIES_SOMETHING, 2051b001a1b6SBenny Halevy .op_name = "OP_CLOSE", 205258e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_status_stateid_rsize, 20538b70484cSTigran Mkrtchyan .op_get_currentstateid = (stateid_getter)nfsd4_get_closestateid, 20548b70484cSTigran Mkrtchyan .op_set_currentstateid = (stateid_setter)nfsd4_set_closestateid, 2055b591480bSJ.Bruce Fields }, 2056b591480bSJ.Bruce Fields [OP_COMMIT] = { 2057b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_commit, 205858e7b33aSMi Jinlong .op_flags = OP_MODIFIES_SOMETHING, 2059b001a1b6SBenny Halevy .op_name = "OP_COMMIT", 206058e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_commit_rsize, 2061b591480bSJ.Bruce Fields }, 2062b591480bSJ.Bruce Fields [OP_CREATE] = { 2063b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_create, 2064d1471053STigran Mkrtchyan .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME | OP_CLEAR_STATEID, 2065b001a1b6SBenny Halevy .op_name = "OP_CREATE", 206658e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_create_rsize, 2067b591480bSJ.Bruce Fields }, 2068b591480bSJ.Bruce Fields [OP_DELEGRETURN] = { 2069b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_delegreturn, 207058e7b33aSMi Jinlong .op_flags = OP_MODIFIES_SOMETHING, 2071b001a1b6SBenny Halevy .op_name = "OP_DELEGRETURN", 207258e7b33aSMi Jinlong .op_rsize_bop = nfsd4_only_status_rsize, 20739428fe1aSTigran Mkrtchyan .op_get_currentstateid = (stateid_getter)nfsd4_get_delegreturnstateid, 2074b591480bSJ.Bruce Fields }, 2075b591480bSJ.Bruce Fields [OP_GETATTR] = { 2076b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_getattr, 2077eeac294eSJ.Bruce Fields .op_flags = ALLOWED_ON_ABSENT_FS, 2078b86cef60SJ. Bruce Fields .op_rsize_bop = nfsd4_getattr_rsize, 2079b001a1b6SBenny Halevy .op_name = "OP_GETATTR", 2080b591480bSJ.Bruce Fields }, 2081b591480bSJ.Bruce Fields [OP_GETFH] = { 2082b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_getfh, 2083b001a1b6SBenny Halevy .op_name = "OP_GETFH", 2084b591480bSJ.Bruce Fields }, 2085b591480bSJ.Bruce Fields [OP_LINK] = { 2086b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_link, 2087c856694eSJ. Bruce Fields .op_flags = ALLOWED_ON_ABSENT_FS | OP_MODIFIES_SOMETHING 2088c856694eSJ. Bruce Fields | OP_CACHEME, 2089b001a1b6SBenny Halevy .op_name = "OP_LINK", 209058e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_link_rsize, 2091b591480bSJ.Bruce Fields }, 2092b591480bSJ.Bruce Fields [OP_LOCK] = { 2093b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_lock, 209458e7b33aSMi Jinlong .op_flags = OP_MODIFIES_SOMETHING, 2095b001a1b6SBenny Halevy .op_name = "OP_LOCK", 209658e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_lock_rsize, 209762cd4a59STigran Mkrtchyan .op_set_currentstateid = (stateid_setter)nfsd4_set_lockstateid, 2098b591480bSJ.Bruce Fields }, 2099b591480bSJ.Bruce Fields [OP_LOCKT] = { 2100b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_lockt, 2101b001a1b6SBenny Halevy .op_name = "OP_LOCKT", 2102b591480bSJ.Bruce Fields }, 2103b591480bSJ.Bruce Fields [OP_LOCKU] = { 2104b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_locku, 210558e7b33aSMi Jinlong .op_flags = OP_MODIFIES_SOMETHING, 2106b001a1b6SBenny Halevy .op_name = "OP_LOCKU", 210758e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_status_stateid_rsize, 210862cd4a59STigran Mkrtchyan .op_get_currentstateid = (stateid_getter)nfsd4_get_lockustateid, 2109b591480bSJ.Bruce Fields }, 2110b591480bSJ.Bruce Fields [OP_LOOKUP] = { 2111b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_lookup, 2112d1471053STigran Mkrtchyan .op_flags = OP_HANDLES_WRONGSEC | OP_CLEAR_STATEID, 2113b001a1b6SBenny Halevy .op_name = "OP_LOOKUP", 2114b591480bSJ.Bruce Fields }, 2115b591480bSJ.Bruce Fields [OP_LOOKUPP] = { 2116b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_lookupp, 2117d1471053STigran Mkrtchyan .op_flags = OP_HANDLES_WRONGSEC | OP_CLEAR_STATEID, 2118b001a1b6SBenny Halevy .op_name = "OP_LOOKUPP", 2119b591480bSJ.Bruce Fields }, 2120b591480bSJ.Bruce Fields [OP_NVERIFY] = { 2121b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_nverify, 2122b001a1b6SBenny Halevy .op_name = "OP_NVERIFY", 2123b591480bSJ.Bruce Fields }, 2124b591480bSJ.Bruce Fields [OP_OPEN] = { 2125b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_open, 212658e7b33aSMi Jinlong .op_flags = OP_HANDLES_WRONGSEC | OP_MODIFIES_SOMETHING, 2127b001a1b6SBenny Halevy .op_name = "OP_OPEN", 212858e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_open_rsize, 21298b70484cSTigran Mkrtchyan .op_set_currentstateid = (stateid_setter)nfsd4_set_openstateid, 2130b591480bSJ.Bruce Fields }, 2131b591480bSJ.Bruce Fields [OP_OPEN_CONFIRM] = { 2132b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_open_confirm, 213358e7b33aSMi Jinlong .op_flags = OP_MODIFIES_SOMETHING, 2134b001a1b6SBenny Halevy .op_name = "OP_OPEN_CONFIRM", 213558e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_status_stateid_rsize, 2136b591480bSJ.Bruce Fields }, 2137b591480bSJ.Bruce Fields [OP_OPEN_DOWNGRADE] = { 2138b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_open_downgrade, 213958e7b33aSMi Jinlong .op_flags = OP_MODIFIES_SOMETHING, 2140b001a1b6SBenny Halevy .op_name = "OP_OPEN_DOWNGRADE", 214158e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_status_stateid_rsize, 21429428fe1aSTigran Mkrtchyan .op_get_currentstateid = (stateid_getter)nfsd4_get_opendowngradestateid, 21439428fe1aSTigran Mkrtchyan .op_set_currentstateid = (stateid_setter)nfsd4_set_opendowngradestateid, 2144b591480bSJ.Bruce Fields }, 2145b591480bSJ.Bruce Fields [OP_PUTFH] = { 2146b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_putfh, 214768d93184SJ. Bruce Fields .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS 21485b648699SJ. Bruce Fields | OP_IS_PUTFH_LIKE | OP_CLEAR_STATEID, 2149b001a1b6SBenny Halevy .op_name = "OP_PUTFH", 215058e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize, 2151b591480bSJ.Bruce Fields }, 2152eeac294eSJ.Bruce Fields [OP_PUTPUBFH] = { 2153a1c8c4d1SJ. Bruce Fields .op_func = (nfsd4op_func)nfsd4_putrootfh, 215468d93184SJ. Bruce Fields .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS 21555b648699SJ. Bruce Fields | OP_IS_PUTFH_LIKE | OP_CLEAR_STATEID, 2156b001a1b6SBenny Halevy .op_name = "OP_PUTPUBFH", 215758e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize, 2158eeac294eSJ.Bruce Fields }, 2159b591480bSJ.Bruce Fields [OP_PUTROOTFH] = { 2160b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_putrootfh, 216168d93184SJ. Bruce Fields .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS 21625b648699SJ. Bruce Fields | OP_IS_PUTFH_LIKE | OP_CLEAR_STATEID, 2163b001a1b6SBenny Halevy .op_name = "OP_PUTROOTFH", 216458e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize, 2165b591480bSJ.Bruce Fields }, 2166b591480bSJ.Bruce Fields [OP_READ] = { 2167b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_read, 2168b001a1b6SBenny Halevy .op_name = "OP_READ", 216958e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_read_rsize, 217030813e27STigran Mkrtchyan .op_get_currentstateid = (stateid_getter)nfsd4_get_readstateid, 2171b591480bSJ.Bruce Fields }, 2172b591480bSJ.Bruce Fields [OP_READDIR] = { 2173b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_readdir, 2174b001a1b6SBenny Halevy .op_name = "OP_READDIR", 217558e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_readdir_rsize, 2176b591480bSJ.Bruce Fields }, 2177b591480bSJ.Bruce Fields [OP_READLINK] = { 2178b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_readlink, 2179b001a1b6SBenny Halevy .op_name = "OP_READLINK", 2180b591480bSJ.Bruce Fields }, 2181b591480bSJ.Bruce Fields [OP_REMOVE] = { 2182b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_remove, 2183c856694eSJ. Bruce Fields .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME, 2184b001a1b6SBenny Halevy .op_name = "OP_REMOVE", 218558e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_remove_rsize, 2186b591480bSJ.Bruce Fields }, 2187b591480bSJ.Bruce Fields [OP_RENAME] = { 2188b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_rename, 2189c856694eSJ. Bruce Fields .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME, 219058e7b33aSMi Jinlong .op_name = "OP_RENAME", 219158e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_rename_rsize, 2192b591480bSJ.Bruce Fields }, 2193b591480bSJ.Bruce Fields [OP_RENEW] = { 2194b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_renew, 219558e7b33aSMi Jinlong .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS 219658e7b33aSMi Jinlong | OP_MODIFIES_SOMETHING, 2197b001a1b6SBenny Halevy .op_name = "OP_RENEW", 219858e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize, 219958e7b33aSMi Jinlong 2200b591480bSJ.Bruce Fields }, 2201b591480bSJ.Bruce Fields [OP_RESTOREFH] = { 2202b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_restorefh, 220368d93184SJ. Bruce Fields .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS 220458e7b33aSMi Jinlong | OP_IS_PUTFH_LIKE | OP_MODIFIES_SOMETHING, 2205b001a1b6SBenny Halevy .op_name = "OP_RESTOREFH", 220658e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize, 2207b591480bSJ.Bruce Fields }, 2208b591480bSJ.Bruce Fields [OP_SAVEFH] = { 2209b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_savefh, 221058e7b33aSMi Jinlong .op_flags = OP_HANDLES_WRONGSEC | OP_MODIFIES_SOMETHING, 2211b001a1b6SBenny Halevy .op_name = "OP_SAVEFH", 221258e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize, 2213b591480bSJ.Bruce Fields }, 2214dcb488a3SAndy Adamson [OP_SECINFO] = { 2215dcb488a3SAndy Adamson .op_func = (nfsd4op_func)nfsd4_secinfo, 221668d93184SJ. Bruce Fields .op_flags = OP_HANDLES_WRONGSEC, 2217b001a1b6SBenny Halevy .op_name = "OP_SECINFO", 2218dcb488a3SAndy Adamson }, 2219b591480bSJ.Bruce Fields [OP_SETATTR] = { 2220b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_setattr, 2221b001a1b6SBenny Halevy .op_name = "OP_SETATTR", 2222c856694eSJ. Bruce Fields .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME, 222358e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_setattr_rsize, 22241e97b519STigran Mkrtchyan .op_get_currentstateid = (stateid_getter)nfsd4_get_setattrstateid, 2225b591480bSJ.Bruce Fields }, 2226b591480bSJ.Bruce Fields [OP_SETCLIENTID] = { 2227b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_setclientid, 222858e7b33aSMi Jinlong .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS 2229c856694eSJ. Bruce Fields | OP_MODIFIES_SOMETHING | OP_CACHEME, 2230b001a1b6SBenny Halevy .op_name = "OP_SETCLIENTID", 223158e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_setclientid_rsize, 2232b591480bSJ.Bruce Fields }, 2233b591480bSJ.Bruce Fields [OP_SETCLIENTID_CONFIRM] = { 2234b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_setclientid_confirm, 223558e7b33aSMi Jinlong .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS 2236c856694eSJ. Bruce Fields | OP_MODIFIES_SOMETHING | OP_CACHEME, 2237b001a1b6SBenny Halevy .op_name = "OP_SETCLIENTID_CONFIRM", 223858e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize, 2239b591480bSJ.Bruce Fields }, 2240b591480bSJ.Bruce Fields [OP_VERIFY] = { 2241b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_verify, 2242b001a1b6SBenny Halevy .op_name = "OP_VERIFY", 2243b591480bSJ.Bruce Fields }, 2244b591480bSJ.Bruce Fields [OP_WRITE] = { 2245b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_write, 2246c856694eSJ. Bruce Fields .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME, 2247b001a1b6SBenny Halevy .op_name = "OP_WRITE", 224858e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_write_rsize, 224930813e27STigran Mkrtchyan .op_get_currentstateid = (stateid_getter)nfsd4_get_writestateid, 2250b591480bSJ.Bruce Fields }, 2251b591480bSJ.Bruce Fields [OP_RELEASE_LOCKOWNER] = { 2252b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_release_lockowner, 225358e7b33aSMi Jinlong .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS 225458e7b33aSMi Jinlong | OP_MODIFIES_SOMETHING, 2255b001a1b6SBenny Halevy .op_name = "OP_RELEASE_LOCKOWNER", 225658e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize, 2257b591480bSJ.Bruce Fields }, 2258069b6ad4SAndy Adamson 2259069b6ad4SAndy Adamson /* NFSv4.1 operations */ 2260069b6ad4SAndy Adamson [OP_EXCHANGE_ID] = { 2261069b6ad4SAndy Adamson .op_func = (nfsd4op_func)nfsd4_exchange_id, 226258e7b33aSMi Jinlong .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP 226358e7b33aSMi Jinlong | OP_MODIFIES_SOMETHING, 2264069b6ad4SAndy Adamson .op_name = "OP_EXCHANGE_ID", 226558e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_exchange_id_rsize, 2266069b6ad4SAndy Adamson }, 2267cb73a9f4SJ. Bruce Fields [OP_BACKCHANNEL_CTL] = { 2268cb73a9f4SJ. Bruce Fields .op_func = (nfsd4op_func)nfsd4_backchannel_ctl, 2269cb73a9f4SJ. Bruce Fields .op_flags = ALLOWED_WITHOUT_FH | OP_MODIFIES_SOMETHING, 2270cb73a9f4SJ. Bruce Fields .op_name = "OP_BACKCHANNEL_CTL", 2271cb73a9f4SJ. Bruce Fields .op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize, 2272cb73a9f4SJ. Bruce Fields }, 22731d1bc8f2SJ. Bruce Fields [OP_BIND_CONN_TO_SESSION] = { 22741d1bc8f2SJ. Bruce Fields .op_func = (nfsd4op_func)nfsd4_bind_conn_to_session, 227558e7b33aSMi Jinlong .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP 227658e7b33aSMi Jinlong | OP_MODIFIES_SOMETHING, 22771d1bc8f2SJ. Bruce Fields .op_name = "OP_BIND_CONN_TO_SESSION", 227858e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_bind_conn_to_session_rsize, 22791d1bc8f2SJ. Bruce Fields }, 2280069b6ad4SAndy Adamson [OP_CREATE_SESSION] = { 2281069b6ad4SAndy Adamson .op_func = (nfsd4op_func)nfsd4_create_session, 228258e7b33aSMi Jinlong .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP 228358e7b33aSMi Jinlong | OP_MODIFIES_SOMETHING, 2284069b6ad4SAndy Adamson .op_name = "OP_CREATE_SESSION", 228558e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_create_session_rsize, 2286069b6ad4SAndy Adamson }, 2287069b6ad4SAndy Adamson [OP_DESTROY_SESSION] = { 2288069b6ad4SAndy Adamson .op_func = (nfsd4op_func)nfsd4_destroy_session, 228958e7b33aSMi Jinlong .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP 229058e7b33aSMi Jinlong | OP_MODIFIES_SOMETHING, 2291069b6ad4SAndy Adamson .op_name = "OP_DESTROY_SESSION", 229258e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize, 2293069b6ad4SAndy Adamson }, 2294069b6ad4SAndy Adamson [OP_SEQUENCE] = { 2295069b6ad4SAndy Adamson .op_func = (nfsd4op_func)nfsd4_sequence, 2296f9bb94c4SAndy Adamson .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP, 2297069b6ad4SAndy Adamson .op_name = "OP_SEQUENCE", 2298d1d84c96SJ. Bruce Fields .op_rsize_bop = (nfsd4op_rsize)nfsd4_sequence_rsize, 2299069b6ad4SAndy Adamson }, 2300094b5d74SBenny Halevy [OP_DESTROY_CLIENTID] = { 2301345c2842SMi Jinlong .op_func = (nfsd4op_func)nfsd4_destroy_clientid, 230258e7b33aSMi Jinlong .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP 230358e7b33aSMi Jinlong | OP_MODIFIES_SOMETHING, 2304094b5d74SBenny Halevy .op_name = "OP_DESTROY_CLIENTID", 230558e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize, 2306094b5d74SBenny Halevy }, 23074dc6ec00SJ. Bruce Fields [OP_RECLAIM_COMPLETE] = { 23084dc6ec00SJ. Bruce Fields .op_func = (nfsd4op_func)nfsd4_reclaim_complete, 230958e7b33aSMi Jinlong .op_flags = ALLOWED_WITHOUT_FH | OP_MODIFIES_SOMETHING, 23104dc6ec00SJ. Bruce Fields .op_name = "OP_RECLAIM_COMPLETE", 231158e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize, 23124dc6ec00SJ. Bruce Fields }, 231304f4ad16SJ. Bruce Fields [OP_SECINFO_NO_NAME] = { 231404f4ad16SJ. Bruce Fields .op_func = (nfsd4op_func)nfsd4_secinfo_no_name, 231568d93184SJ. Bruce Fields .op_flags = OP_HANDLES_WRONGSEC, 231604f4ad16SJ. Bruce Fields .op_name = "OP_SECINFO_NO_NAME", 231704f4ad16SJ. Bruce Fields }, 231817456804SBryan Schumaker [OP_TEST_STATEID] = { 231917456804SBryan Schumaker .op_func = (nfsd4op_func)nfsd4_test_stateid, 232017456804SBryan Schumaker .op_flags = ALLOWED_WITHOUT_FH, 232117456804SBryan Schumaker .op_name = "OP_TEST_STATEID", 232217456804SBryan Schumaker }, 2323e1ca12dfSBryan Schumaker [OP_FREE_STATEID] = { 2324e1ca12dfSBryan Schumaker .op_func = (nfsd4op_func)nfsd4_free_stateid, 232558e7b33aSMi Jinlong .op_flags = ALLOWED_WITHOUT_FH | OP_MODIFIES_SOMETHING, 2326e1ca12dfSBryan Schumaker .op_name = "OP_FREE_STATEID", 2327a1dc6955SJ. Bruce Fields .op_get_currentstateid = (stateid_getter)nfsd4_get_freestateid, 232858e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize, 2329e1ca12dfSBryan Schumaker }, 23309cf514ccSChristoph Hellwig #ifdef CONFIG_NFSD_PNFS 23319cf514ccSChristoph Hellwig [OP_GETDEVICEINFO] = { 23329cf514ccSChristoph Hellwig .op_func = (nfsd4op_func)nfsd4_getdeviceinfo, 23339cf514ccSChristoph Hellwig .op_flags = ALLOWED_WITHOUT_FH, 23349cf514ccSChristoph Hellwig .op_name = "OP_GETDEVICEINFO", 23359cf514ccSChristoph Hellwig }, 23369cf514ccSChristoph Hellwig [OP_LAYOUTGET] = { 23379cf514ccSChristoph Hellwig .op_func = (nfsd4op_func)nfsd4_layoutget, 23389cf514ccSChristoph Hellwig .op_flags = OP_MODIFIES_SOMETHING, 23399cf514ccSChristoph Hellwig .op_name = "OP_LAYOUTGET", 23409cf514ccSChristoph Hellwig .op_rsize_bop = (nfsd4op_rsize)nfsd4_layoutget_rsize, 23419cf514ccSChristoph Hellwig }, 23429cf514ccSChristoph Hellwig [OP_LAYOUTCOMMIT] = { 23439cf514ccSChristoph Hellwig .op_func = (nfsd4op_func)nfsd4_layoutcommit, 23449cf514ccSChristoph Hellwig .op_flags = OP_MODIFIES_SOMETHING, 23459cf514ccSChristoph Hellwig .op_name = "OP_LAYOUTCOMMIT", 23469cf514ccSChristoph Hellwig .op_rsize_bop = (nfsd4op_rsize)nfsd4_layoutcommit_rsize, 23479cf514ccSChristoph Hellwig }, 23489cf514ccSChristoph Hellwig [OP_LAYOUTRETURN] = { 23499cf514ccSChristoph Hellwig .op_func = (nfsd4op_func)nfsd4_layoutreturn, 23509cf514ccSChristoph Hellwig .op_flags = OP_MODIFIES_SOMETHING, 23519cf514ccSChristoph Hellwig .op_name = "OP_LAYOUTRETURN", 23529cf514ccSChristoph Hellwig .op_rsize_bop = (nfsd4op_rsize)nfsd4_layoutreturn_rsize, 23539cf514ccSChristoph Hellwig }, 23549cf514ccSChristoph Hellwig #endif /* CONFIG_NFSD_PNFS */ 235524bab491SAnna Schumaker 235624bab491SAnna Schumaker /* NFSv4.2 operations */ 235795d871f0SAnna Schumaker [OP_ALLOCATE] = { 235895d871f0SAnna Schumaker .op_func = (nfsd4op_func)nfsd4_allocate, 235995d871f0SAnna Schumaker .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME, 236095d871f0SAnna Schumaker .op_name = "OP_ALLOCATE", 2361beaca234SKinglong Mee .op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize, 236295d871f0SAnna Schumaker }, 2363b0cb9085SAnna Schumaker [OP_DEALLOCATE] = { 2364b0cb9085SAnna Schumaker .op_func = (nfsd4op_func)nfsd4_deallocate, 2365b0cb9085SAnna Schumaker .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME, 2366b0cb9085SAnna Schumaker .op_name = "OP_DEALLOCATE", 2367beaca234SKinglong Mee .op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize, 2368b0cb9085SAnna Schumaker }, 2369ffa0160aSChristoph Hellwig [OP_CLONE] = { 2370ffa0160aSChristoph Hellwig .op_func = (nfsd4op_func)nfsd4_clone, 2371ffa0160aSChristoph Hellwig .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME, 2372ffa0160aSChristoph Hellwig .op_name = "OP_CLONE", 2373ffa0160aSChristoph Hellwig .op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize, 2374ffa0160aSChristoph Hellwig }, 237529ae7f9dSAnna Schumaker [OP_COPY] = { 237629ae7f9dSAnna Schumaker .op_func = (nfsd4op_func)nfsd4_copy, 237729ae7f9dSAnna Schumaker .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME, 237829ae7f9dSAnna Schumaker .op_name = "OP_COPY", 237929ae7f9dSAnna Schumaker .op_rsize_bop = (nfsd4op_rsize)nfsd4_copy_rsize, 238029ae7f9dSAnna Schumaker }, 238124bab491SAnna Schumaker [OP_SEEK] = { 238224bab491SAnna Schumaker .op_func = (nfsd4op_func)nfsd4_seek, 238324bab491SAnna Schumaker .op_name = "OP_SEEK", 238424bab491SAnna Schumaker }, 2385b591480bSJ.Bruce Fields }; 2386b591480bSJ.Bruce Fields 2387ed941643SAndrew Elble /** 2388ed941643SAndrew Elble * nfsd4_spo_must_allow - Determine if the compound op contains an 2389ed941643SAndrew Elble * operation that is allowed to be sent with machine credentials 2390ed941643SAndrew Elble * 2391ed941643SAndrew Elble * @rqstp: a pointer to the struct svc_rqst 2392ed941643SAndrew Elble * 2393ed941643SAndrew Elble * Checks to see if the compound contains a spo_must_allow op 2394ed941643SAndrew Elble * and confirms that it was sent with the proper machine creds. 2395ed941643SAndrew Elble */ 2396ed941643SAndrew Elble 2397ed941643SAndrew Elble bool nfsd4_spo_must_allow(struct svc_rqst *rqstp) 2398ed941643SAndrew Elble { 2399ed941643SAndrew Elble struct nfsd4_compoundres *resp = rqstp->rq_resp; 2400ed941643SAndrew Elble struct nfsd4_compoundargs *argp = rqstp->rq_argp; 2401ed941643SAndrew Elble struct nfsd4_op *this = &argp->ops[resp->opcnt - 1]; 2402ed941643SAndrew Elble struct nfsd4_compound_state *cstate = &resp->cstate; 2403ed941643SAndrew Elble struct nfs4_op_map *allow = &cstate->clp->cl_spo_must_allow; 2404ed941643SAndrew Elble u32 opiter; 2405ed941643SAndrew Elble 2406ed941643SAndrew Elble if (!cstate->minorversion) 2407ed941643SAndrew Elble return false; 2408ed941643SAndrew Elble 2409ed941643SAndrew Elble if (cstate->spo_must_allowed == true) 2410ed941643SAndrew Elble return true; 2411ed941643SAndrew Elble 2412ed941643SAndrew Elble opiter = resp->opcnt; 2413ed941643SAndrew Elble while (opiter < argp->opcnt) { 2414ed941643SAndrew Elble this = &argp->ops[opiter++]; 2415ed941643SAndrew Elble if (test_bit(this->opnum, allow->u.longs) && 2416ed941643SAndrew Elble cstate->clp->cl_mach_cred && 2417ed941643SAndrew Elble nfsd4_mach_creds_match(cstate->clp, rqstp)) { 2418ed941643SAndrew Elble cstate->spo_must_allowed = true; 2419ed941643SAndrew Elble return true; 2420ed941643SAndrew Elble } 2421ed941643SAndrew Elble } 2422ed941643SAndrew Elble cstate->spo_must_allowed = false; 2423ed941643SAndrew Elble return false; 2424ed941643SAndrew Elble } 2425ed941643SAndrew Elble 24264f0cefbfSJ. Bruce Fields int nfsd4_max_reply(struct svc_rqst *rqstp, struct nfsd4_op *op) 24274f0cefbfSJ. Bruce Fields { 24284f0cefbfSJ. Bruce Fields struct nfsd4_operation *opdesc; 24294f0cefbfSJ. Bruce Fields nfsd4op_rsize estimator; 24304f0cefbfSJ. Bruce Fields 24314f0cefbfSJ. Bruce Fields if (op->opnum == OP_ILLEGAL) 24324f0cefbfSJ. Bruce Fields return op_encode_hdr_size * sizeof(__be32); 24334f0cefbfSJ. Bruce Fields opdesc = OPDESC(op); 24344f0cefbfSJ. Bruce Fields estimator = opdesc->op_rsize_bop; 24354f0cefbfSJ. Bruce Fields return estimator ? estimator(rqstp, op) : PAGE_SIZE; 24364f0cefbfSJ. Bruce Fields } 24374f0cefbfSJ. Bruce Fields 243807d1f802SJ. Bruce Fields void warn_on_nonidempotent_op(struct nfsd4_op *op) 243907d1f802SJ. Bruce Fields { 244007d1f802SJ. Bruce Fields if (OPDESC(op)->op_flags & OP_MODIFIES_SOMETHING) { 244107d1f802SJ. Bruce Fields pr_err("unable to encode reply to nonidempotent op %d (%s)\n", 244207d1f802SJ. Bruce Fields op->opnum, nfsd4_op_name(op->opnum)); 244307d1f802SJ. Bruce Fields WARN_ON_ONCE(1); 244407d1f802SJ. Bruce Fields } 244507d1f802SJ. Bruce Fields } 244607d1f802SJ. Bruce Fields 2447f1c7f79bSAdrian Bunk static const char *nfsd4_op_name(unsigned opnum) 2448b001a1b6SBenny Halevy { 2449b001a1b6SBenny Halevy if (opnum < ARRAY_SIZE(nfsd4_ops)) 2450b001a1b6SBenny Halevy return nfsd4_ops[opnum].op_name; 2451b001a1b6SBenny Halevy return "unknown_operation"; 2452b001a1b6SBenny Halevy } 2453b001a1b6SBenny Halevy 24541da177e4SLinus Torvalds #define nfsd4_voidres nfsd4_voidargs 24551da177e4SLinus Torvalds struct nfsd4_voidargs { int dummy; }; 24561da177e4SLinus Torvalds 24571da177e4SLinus Torvalds static struct svc_procedure nfsd_procedures4[2] = { 24580a93a47fSYu Zhiguo [NFSPROC4_NULL] = { 24590a93a47fSYu Zhiguo .pc_func = (svc_procfunc) nfsd4_proc_null, 24600a93a47fSYu Zhiguo .pc_encode = (kxdrproc_t) nfs4svc_encode_voidres, 24610a93a47fSYu Zhiguo .pc_argsize = sizeof(struct nfsd4_voidargs), 24620a93a47fSYu Zhiguo .pc_ressize = sizeof(struct nfsd4_voidres), 24630a93a47fSYu Zhiguo .pc_cachetype = RC_NOCACHE, 24640a93a47fSYu Zhiguo .pc_xdrressize = 1, 24650a93a47fSYu Zhiguo }, 24660a93a47fSYu Zhiguo [NFSPROC4_COMPOUND] = { 24670a93a47fSYu Zhiguo .pc_func = (svc_procfunc) nfsd4_proc_compound, 24680a93a47fSYu Zhiguo .pc_decode = (kxdrproc_t) nfs4svc_decode_compoundargs, 24690a93a47fSYu Zhiguo .pc_encode = (kxdrproc_t) nfs4svc_encode_compoundres, 24700a93a47fSYu Zhiguo .pc_argsize = sizeof(struct nfsd4_compoundargs), 24710a93a47fSYu Zhiguo .pc_ressize = sizeof(struct nfsd4_compoundres), 24723e98abffSJ. Bruce Fields .pc_release = nfsd4_release_compoundargs, 24730a93a47fSYu Zhiguo .pc_cachetype = RC_NOCACHE, 24740a93a47fSYu Zhiguo .pc_xdrressize = NFSD_BUFSIZE/4, 24750a93a47fSYu Zhiguo }, 24761da177e4SLinus Torvalds }; 24771da177e4SLinus Torvalds 24781da177e4SLinus Torvalds struct svc_version nfsd_version4 = { 24791da177e4SLinus Torvalds .vs_vers = 4, 24801da177e4SLinus Torvalds .vs_nproc = 2, 24811da177e4SLinus Torvalds .vs_proc = nfsd_procedures4, 24821da177e4SLinus Torvalds .vs_dispatch = nfsd_dispatch, 24831da177e4SLinus Torvalds .vs_xdrsize = NFS4_SVC_XDRSIZE, 24847e55b59bSKinglong Mee .vs_rpcb_optnl = 1, 24851da177e4SLinus Torvalds }; 24861da177e4SLinus Torvalds 24871da177e4SLinus Torvalds /* 24881da177e4SLinus Torvalds * Local variables: 24891da177e4SLinus Torvalds * c-basic-offset: 8 24901da177e4SLinus Torvalds * End: 24911da177e4SLinus Torvalds */ 2492