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> 365a0e3ad6STejun Heo #include <linux/slab.h> 371da177e4SLinus Torvalds 3858e7b33aSMi Jinlong #include "idmap.h" 399a74af21SBoaz Harrosh #include "cache.h" 409a74af21SBoaz Harrosh #include "xdr4.h" 410a3adadeSJ. Bruce Fields #include "vfs.h" 421da177e4SLinus Torvalds 431da177e4SLinus Torvalds #define NFSDDBG_FACILITY NFSDDBG_PROC 441da177e4SLinus Torvalds 453c8e0316SYu Zhiguo static u32 nfsd_attrmask[] = { 463c8e0316SYu Zhiguo NFSD_WRITEABLE_ATTRS_WORD0, 473c8e0316SYu Zhiguo NFSD_WRITEABLE_ATTRS_WORD1, 483c8e0316SYu Zhiguo NFSD_WRITEABLE_ATTRS_WORD2 493c8e0316SYu Zhiguo }; 503c8e0316SYu Zhiguo 513c8e0316SYu Zhiguo static u32 nfsd41_ex_attrmask[] = { 523c8e0316SYu Zhiguo NFSD_SUPPATTR_EXCLCREAT_WORD0, 533c8e0316SYu Zhiguo NFSD_SUPPATTR_EXCLCREAT_WORD1, 543c8e0316SYu Zhiguo NFSD_SUPPATTR_EXCLCREAT_WORD2 553c8e0316SYu Zhiguo }; 563c8e0316SYu Zhiguo 573c8e0316SYu Zhiguo static __be32 583c8e0316SYu Zhiguo check_attr_support(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 593c8e0316SYu Zhiguo u32 *bmval, u32 *writable) 603c8e0316SYu Zhiguo { 613c8e0316SYu Zhiguo struct dentry *dentry = cstate->current_fh.fh_dentry; 623c8e0316SYu Zhiguo 633c8e0316SYu Zhiguo /* 643c8e0316SYu Zhiguo * Check about attributes are supported by the NFSv4 server or not. 653c8e0316SYu Zhiguo * According to spec, unsupported attributes return ERR_ATTRNOTSUPP. 663c8e0316SYu Zhiguo */ 673c8e0316SYu Zhiguo if ((bmval[0] & ~nfsd_suppattrs0(cstate->minorversion)) || 683c8e0316SYu Zhiguo (bmval[1] & ~nfsd_suppattrs1(cstate->minorversion)) || 693c8e0316SYu Zhiguo (bmval[2] & ~nfsd_suppattrs2(cstate->minorversion))) 703c8e0316SYu Zhiguo return nfserr_attrnotsupp; 713c8e0316SYu Zhiguo 723c8e0316SYu Zhiguo /* 73a06b1261STrond Myklebust * Check FATTR4_WORD0_ACL can be supported 743c8e0316SYu Zhiguo * in current environment or not. 753c8e0316SYu Zhiguo */ 763c8e0316SYu Zhiguo if (bmval[0] & FATTR4_WORD0_ACL) { 773c8e0316SYu Zhiguo if (!IS_POSIXACL(dentry->d_inode)) 783c8e0316SYu Zhiguo return nfserr_attrnotsupp; 793c8e0316SYu Zhiguo } 803c8e0316SYu Zhiguo 813c8e0316SYu Zhiguo /* 823c8e0316SYu Zhiguo * According to spec, read-only attributes return ERR_INVAL. 833c8e0316SYu Zhiguo */ 843c8e0316SYu Zhiguo if (writable) { 853c8e0316SYu Zhiguo if ((bmval[0] & ~writable[0]) || (bmval[1] & ~writable[1]) || 863c8e0316SYu Zhiguo (bmval[2] & ~writable[2])) 873c8e0316SYu Zhiguo return nfserr_inval; 883c8e0316SYu Zhiguo } 893c8e0316SYu Zhiguo 903c8e0316SYu Zhiguo return nfs_ok; 913c8e0316SYu Zhiguo } 923c8e0316SYu Zhiguo 933c8e0316SYu Zhiguo static __be32 943c8e0316SYu Zhiguo nfsd4_check_open_attributes(struct svc_rqst *rqstp, 953c8e0316SYu Zhiguo struct nfsd4_compound_state *cstate, struct nfsd4_open *open) 963c8e0316SYu Zhiguo { 973c8e0316SYu Zhiguo __be32 status = nfs_ok; 983c8e0316SYu Zhiguo 993c8e0316SYu Zhiguo if (open->op_create == NFS4_OPEN_CREATE) { 1003c8e0316SYu Zhiguo if (open->op_createmode == NFS4_CREATE_UNCHECKED 1013c8e0316SYu Zhiguo || open->op_createmode == NFS4_CREATE_GUARDED) 1023c8e0316SYu Zhiguo status = check_attr_support(rqstp, cstate, 1033c8e0316SYu Zhiguo open->op_bmval, nfsd_attrmask); 1043c8e0316SYu Zhiguo else if (open->op_createmode == NFS4_CREATE_EXCLUSIVE4_1) 1053c8e0316SYu Zhiguo status = check_attr_support(rqstp, cstate, 1063c8e0316SYu Zhiguo open->op_bmval, nfsd41_ex_attrmask); 1073c8e0316SYu Zhiguo } 1083c8e0316SYu Zhiguo 1093c8e0316SYu Zhiguo return status; 1103c8e0316SYu Zhiguo } 1113c8e0316SYu Zhiguo 1129208faf2SYu Zhiguo static int 1139208faf2SYu Zhiguo is_create_with_attrs(struct nfsd4_open *open) 1149208faf2SYu Zhiguo { 1159208faf2SYu Zhiguo return open->op_create == NFS4_OPEN_CREATE 1169208faf2SYu Zhiguo && (open->op_createmode == NFS4_CREATE_UNCHECKED 1179208faf2SYu Zhiguo || open->op_createmode == NFS4_CREATE_GUARDED 1189208faf2SYu Zhiguo || open->op_createmode == NFS4_CREATE_EXCLUSIVE4_1); 1199208faf2SYu Zhiguo } 1209208faf2SYu Zhiguo 1219208faf2SYu Zhiguo /* 1229208faf2SYu Zhiguo * if error occurs when setting the acl, just clear the acl bit 1239208faf2SYu Zhiguo * in the returned attr bitmap. 1249208faf2SYu Zhiguo */ 1259208faf2SYu Zhiguo static void 1269208faf2SYu Zhiguo do_set_nfs4_acl(struct svc_rqst *rqstp, struct svc_fh *fhp, 1279208faf2SYu Zhiguo struct nfs4_acl *acl, u32 *bmval) 1289208faf2SYu Zhiguo { 1299208faf2SYu Zhiguo __be32 status; 1309208faf2SYu Zhiguo 1319208faf2SYu Zhiguo status = nfsd4_set_nfs4_acl(rqstp, fhp, acl); 1329208faf2SYu Zhiguo if (status) 1339208faf2SYu Zhiguo /* 1349208faf2SYu Zhiguo * We should probably fail the whole open at this point, 1359208faf2SYu Zhiguo * but we've already created the file, so it's too late; 1369208faf2SYu Zhiguo * So this seems the least of evils: 1379208faf2SYu Zhiguo */ 1389208faf2SYu Zhiguo bmval[0] &= ~FATTR4_WORD0_ACL; 1399208faf2SYu Zhiguo } 1409208faf2SYu Zhiguo 1411da177e4SLinus Torvalds static inline void 1421da177e4SLinus Torvalds fh_dup2(struct svc_fh *dst, struct svc_fh *src) 1431da177e4SLinus Torvalds { 1441da177e4SLinus Torvalds fh_put(dst); 1451da177e4SLinus Torvalds dget(src->fh_dentry); 1461da177e4SLinus Torvalds if (src->fh_export) 1471da177e4SLinus Torvalds cache_get(&src->fh_export->h); 1481da177e4SLinus Torvalds *dst = *src; 1491da177e4SLinus Torvalds } 1501da177e4SLinus Torvalds 151b37ad28bSAl Viro static __be32 152dc730e17SJ. Bruce Fields do_open_permission(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open, int accmode) 1531da177e4SLinus Torvalds { 154b37ad28bSAl Viro __be32 status; 1551da177e4SLinus Torvalds 1561da177e4SLinus Torvalds if (open->op_truncate && 1571da177e4SLinus Torvalds !(open->op_share_access & NFS4_SHARE_ACCESS_WRITE)) 1581da177e4SLinus Torvalds return nfserr_inval; 1591da177e4SLinus Torvalds 160a043226bSJ. Bruce Fields accmode |= NFSD_MAY_READ_IF_EXEC; 161a043226bSJ. Bruce Fields 1621da177e4SLinus Torvalds if (open->op_share_access & NFS4_SHARE_ACCESS_READ) 1638837abcaSMiklos Szeredi accmode |= NFSD_MAY_READ; 1649801d8a3SJ. Bruce Fields if (open->op_share_access & NFS4_SHARE_ACCESS_WRITE) 1658837abcaSMiklos Szeredi accmode |= (NFSD_MAY_WRITE | NFSD_MAY_TRUNC); 16657ecb34fSJ. Bruce Fields if (open->op_share_deny & NFS4_SHARE_DENY_READ) 1678837abcaSMiklos Szeredi accmode |= NFSD_MAY_WRITE; 1681da177e4SLinus Torvalds 1691da177e4SLinus Torvalds status = fh_verify(rqstp, current_fh, S_IFREG, accmode); 1701da177e4SLinus Torvalds 1711da177e4SLinus Torvalds return status; 1721da177e4SLinus Torvalds } 1731da177e4SLinus Torvalds 174aadab6c6SJ. Bruce Fields static __be32 nfsd_check_obj_isreg(struct svc_fh *fh) 175aadab6c6SJ. Bruce Fields { 176aadab6c6SJ. Bruce Fields umode_t mode = fh->fh_dentry->d_inode->i_mode; 177aadab6c6SJ. Bruce Fields 178aadab6c6SJ. Bruce Fields if (S_ISREG(mode)) 179aadab6c6SJ. Bruce Fields return nfs_ok; 180aadab6c6SJ. Bruce Fields if (S_ISDIR(mode)) 181aadab6c6SJ. Bruce Fields return nfserr_isdir; 182aadab6c6SJ. Bruce Fields /* 183aadab6c6SJ. Bruce Fields * Using err_symlink as our catch-all case may look odd; but 184aadab6c6SJ. Bruce Fields * there's no other obvious error for this case in 4.0, and we 185aadab6c6SJ. Bruce Fields * happen to know that it will cause the linux v4 client to do 186aadab6c6SJ. Bruce Fields * the right thing on attempts to open something other than a 187aadab6c6SJ. Bruce Fields * regular file. 188aadab6c6SJ. Bruce Fields */ 189aadab6c6SJ. Bruce Fields return nfserr_symlink; 190aadab6c6SJ. Bruce Fields } 191aadab6c6SJ. Bruce Fields 192b37ad28bSAl Viro static __be32 1931da177e4SLinus Torvalds do_open_lookup(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open) 1941da177e4SLinus Torvalds { 1951da177e4SLinus Torvalds struct svc_fh resfh; 196b37ad28bSAl Viro __be32 status; 19781ac95c5SJ. Bruce Fields int created = 0; 1981da177e4SLinus Torvalds 1991da177e4SLinus Torvalds fh_init(&resfh, NFS4_FHSIZE); 2001da177e4SLinus Torvalds open->op_truncate = 0; 2011da177e4SLinus Torvalds 2021da177e4SLinus Torvalds if (open->op_create) { 20379fb54abSBenny Halevy /* FIXME: check session persistence and pnfs flags. 20479fb54abSBenny Halevy * The nfsv4.1 spec requires the following semantics: 20579fb54abSBenny Halevy * 20679fb54abSBenny Halevy * Persistent | pNFS | Server REQUIRED | Client Allowed 20779fb54abSBenny Halevy * Reply Cache | server | | 20879fb54abSBenny Halevy * -------------+--------+-----------------+-------------------- 20979fb54abSBenny Halevy * no | no | EXCLUSIVE4_1 | EXCLUSIVE4_1 21079fb54abSBenny Halevy * | | | (SHOULD) 21179fb54abSBenny Halevy * | | and EXCLUSIVE4 | or EXCLUSIVE4 21279fb54abSBenny Halevy * | | | (SHOULD NOT) 21379fb54abSBenny Halevy * no | yes | EXCLUSIVE4_1 | EXCLUSIVE4_1 21479fb54abSBenny Halevy * yes | no | GUARDED4 | GUARDED4 21579fb54abSBenny Halevy * yes | yes | GUARDED4 | GUARDED4 21679fb54abSBenny Halevy */ 21779fb54abSBenny Halevy 2181da177e4SLinus Torvalds /* 2191da177e4SLinus Torvalds * Note: create modes (UNCHECKED,GUARDED...) are the same 220ac6721a1SMi Jinlong * in NFSv4 as in v3 except EXCLUSIVE4_1. 2211da177e4SLinus Torvalds */ 222ac6721a1SMi Jinlong status = do_nfsd_create(rqstp, current_fh, open->op_fname.data, 2231da177e4SLinus Torvalds open->op_fname.len, &open->op_iattr, 2241da177e4SLinus Torvalds &resfh, open->op_createmode, 225749997e5SJeff Layton (u32 *)open->op_verf.data, 226749997e5SJeff Layton &open->op_truncate, &created); 227749997e5SJeff Layton 22899f88726SJ. Bruce Fields /* 22999f88726SJ. Bruce Fields * Following rfc 3530 14.2.16, use the returned bitmask 23099f88726SJ. Bruce Fields * to indicate which attributes we used to store the 23199f88726SJ. Bruce Fields * verifier: 232749997e5SJeff Layton */ 233749997e5SJeff Layton if (open->op_createmode == NFS4_CREATE_EXCLUSIVE && status == 0) 23499f88726SJ. Bruce Fields open->op_bmval[1] = (FATTR4_WORD1_TIME_ACCESS | 235749997e5SJeff Layton FATTR4_WORD1_TIME_MODIFY); 236af85852dSJ. Bruce Fields } else { 2371da177e4SLinus Torvalds status = nfsd_lookup(rqstp, current_fh, 2381da177e4SLinus Torvalds open->op_fname.data, open->op_fname.len, &resfh); 2391da177e4SLinus Torvalds fh_unlock(current_fh); 240aadab6c6SJ. Bruce Fields if (status) 241aadab6c6SJ. Bruce Fields goto out; 242aadab6c6SJ. Bruce Fields status = nfsd_check_obj_isreg(&resfh); 2431da177e4SLinus Torvalds } 244af85852dSJ. Bruce Fields if (status) 245af85852dSJ. Bruce Fields goto out; 2461da177e4SLinus Torvalds 2479208faf2SYu Zhiguo if (is_create_with_attrs(open) && open->op_acl != NULL) 2489208faf2SYu Zhiguo do_set_nfs4_acl(rqstp, &resfh, open->op_acl, open->op_bmval); 2499208faf2SYu Zhiguo 2501da177e4SLinus Torvalds set_change_info(&open->op_cinfo, current_fh); 25113024b7bSJ. Bruce Fields fh_dup2(current_fh, &resfh); 2521da177e4SLinus Torvalds 2531da177e4SLinus Torvalds /* set reply cache */ 254fe0750e5SJ. Bruce Fields fh_copy_shallow(&open->op_openowner->oo_owner.so_replay.rp_openfh, 255a4773c08SJ. Bruce Fields &resfh.fh_handle); 25681ac95c5SJ. Bruce Fields if (!created) 2578837abcaSMiklos Szeredi status = do_open_permission(rqstp, current_fh, open, 2588837abcaSMiklos Szeredi NFSD_MAY_NOP); 2591da177e4SLinus Torvalds 260af85852dSJ. Bruce Fields out: 2611da177e4SLinus Torvalds fh_put(&resfh); 2621da177e4SLinus Torvalds return status; 2631da177e4SLinus Torvalds } 2641da177e4SLinus Torvalds 265b37ad28bSAl Viro static __be32 2661da177e4SLinus Torvalds do_open_fhandle(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open) 2671da177e4SLinus Torvalds { 268b37ad28bSAl Viro __be32 status; 2691da177e4SLinus Torvalds 2701da177e4SLinus Torvalds /* Only reclaims from previously confirmed clients are valid */ 2711da177e4SLinus Torvalds if ((status = nfs4_check_open_reclaim(&open->op_clientid))) 2721da177e4SLinus Torvalds return status; 2731da177e4SLinus Torvalds 2741da177e4SLinus Torvalds /* We don't know the target directory, and therefore can not 2751da177e4SLinus Torvalds * set the change info 2761da177e4SLinus Torvalds */ 2771da177e4SLinus Torvalds 2781da177e4SLinus Torvalds memset(&open->op_cinfo, 0, sizeof(struct nfsd4_change_info)); 2791da177e4SLinus Torvalds 2801da177e4SLinus Torvalds /* set replay cache */ 281fe0750e5SJ. Bruce Fields fh_copy_shallow(&open->op_openowner->oo_owner.so_replay.rp_openfh, 282a4773c08SJ. Bruce Fields ¤t_fh->fh_handle); 2831da177e4SLinus Torvalds 2841da177e4SLinus Torvalds open->op_truncate = (open->op_iattr.ia_valid & ATTR_SIZE) && 2851da177e4SLinus Torvalds (open->op_iattr.ia_size == 0); 2861da177e4SLinus Torvalds 2878837abcaSMiklos Szeredi status = do_open_permission(rqstp, current_fh, open, 2888837abcaSMiklos Szeredi NFSD_MAY_OWNER_OVERRIDE); 2891da177e4SLinus Torvalds 2901da177e4SLinus Torvalds return status; 2911da177e4SLinus Torvalds } 2921da177e4SLinus Torvalds 29360adfc50SAndy Adamson static void 29460adfc50SAndy Adamson copy_clientid(clientid_t *clid, struct nfsd4_session *session) 29560adfc50SAndy Adamson { 29660adfc50SAndy Adamson struct nfsd4_sessionid *sid = 29760adfc50SAndy Adamson (struct nfsd4_sessionid *)session->se_sessionid.data; 29860adfc50SAndy Adamson 29960adfc50SAndy Adamson clid->cl_boot = sid->clientid.cl_boot; 30060adfc50SAndy Adamson clid->cl_id = sid->clientid.cl_id; 30160adfc50SAndy Adamson } 3021da177e4SLinus Torvalds 3037191155bSJ.Bruce Fields static __be32 304ca364317SJ.Bruce Fields nfsd4_open(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 305a4f1706aSJ.Bruce Fields struct nfsd4_open *open) 3061da177e4SLinus Torvalds { 307b37ad28bSAl Viro __be32 status; 3086668958fSAndy Adamson struct nfsd4_compoundres *resp; 3096668958fSAndy Adamson 310fe0750e5SJ. Bruce Fields dprintk("NFSD: nfsd4_open filename %.*s op_openowner %p\n", 3111da177e4SLinus Torvalds (int)open->op_fname.len, open->op_fname.data, 312fe0750e5SJ. Bruce Fields open->op_openowner); 3131da177e4SLinus Torvalds 3141da177e4SLinus Torvalds /* This check required by spec. */ 3151da177e4SLinus Torvalds if (open->op_create && open->op_claim_type != NFS4_OPEN_CLAIM_NULL) 3161da177e4SLinus Torvalds return nfserr_inval; 3171da177e4SLinus Torvalds 318b6d2f1caSJ. Bruce Fields /* We don't yet support WANT bits: */ 319b6d2f1caSJ. Bruce Fields open->op_share_access &= NFS4_SHARE_ACCESS_MASK; 320b6d2f1caSJ. Bruce Fields 321ab1350b2SMi Jinlong /* 322ab1350b2SMi Jinlong * RFC5661 18.51.3 323ab1350b2SMi Jinlong * Before RECLAIM_COMPLETE done, server should deny new lock 324ab1350b2SMi Jinlong */ 325ab1350b2SMi Jinlong if (nfsd4_has_session(cstate) && 326ab1350b2SMi Jinlong !cstate->session->se_client->cl_firststate && 327ab1350b2SMi Jinlong open->op_claim_type != NFS4_OPEN_CLAIM_PREVIOUS) 328ab1350b2SMi Jinlong return nfserr_grace; 329ab1350b2SMi Jinlong 33060adfc50SAndy Adamson if (nfsd4_has_session(cstate)) 33160adfc50SAndy Adamson copy_clientid(&open->op_clientid, cstate->session); 33260adfc50SAndy Adamson 3331da177e4SLinus Torvalds nfs4_lock_state(); 3341da177e4SLinus Torvalds 3351da177e4SLinus Torvalds /* check seqid for replay. set nfs4_owner */ 3366668958fSAndy Adamson resp = rqstp->rq_resp; 3376668958fSAndy Adamson status = nfsd4_process_open1(&resp->cstate, open); 338a90b061cSAl Viro if (status == nfserr_replay_me) { 339fe0750e5SJ. Bruce Fields struct nfs4_replay *rp = &open->op_openowner->oo_owner.so_replay; 340ca364317SJ.Bruce Fields fh_put(&cstate->current_fh); 341a4773c08SJ. Bruce Fields fh_copy_shallow(&cstate->current_fh.fh_handle, 342a4773c08SJ. Bruce Fields &rp->rp_openfh); 3438837abcaSMiklos Szeredi status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP); 3441da177e4SLinus Torvalds if (status) 3451da177e4SLinus Torvalds dprintk("nfsd4_open: replay failed" 3461da177e4SLinus Torvalds " restoring previous filehandle\n"); 3471da177e4SLinus Torvalds else 348a90b061cSAl Viro status = nfserr_replay_me; 3491da177e4SLinus Torvalds } 3501da177e4SLinus Torvalds if (status) 3511da177e4SLinus Torvalds goto out; 352fb553c0fSJ. Bruce Fields 3533c8e0316SYu Zhiguo status = nfsd4_check_open_attributes(rqstp, cstate, open); 3543c8e0316SYu Zhiguo if (status) 3553c8e0316SYu Zhiguo goto out; 3563c8e0316SYu Zhiguo 357fb553c0fSJ. Bruce Fields /* Openowner is now set, so sequence id will get bumped. Now we need 358fb553c0fSJ. Bruce Fields * these checks before we do any creates: */ 359cbd0d51aSJ. Bruce Fields status = nfserr_grace; 360af558e33SJ. Bruce Fields if (locks_in_grace() && open->op_claim_type != NFS4_OPEN_CLAIM_PREVIOUS) 361cbd0d51aSJ. Bruce Fields goto out; 362cbd0d51aSJ. Bruce Fields status = nfserr_no_grace; 363af558e33SJ. Bruce Fields if (!locks_in_grace() && open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS) 364cbd0d51aSJ. Bruce Fields goto out; 365fb553c0fSJ. Bruce Fields 3661da177e4SLinus Torvalds switch (open->op_claim_type) { 3670dd3c192SNeilBrown case NFS4_OPEN_CLAIM_DELEGATE_CUR: 3681da177e4SLinus Torvalds case NFS4_OPEN_CLAIM_NULL: 3691da177e4SLinus Torvalds /* 3701da177e4SLinus Torvalds * (1) set CURRENT_FH to the file being opened, 3711da177e4SLinus Torvalds * creating it if necessary, (2) set open->op_cinfo, 3721da177e4SLinus Torvalds * (3) set open->op_truncate if the file is to be 3731da177e4SLinus Torvalds * truncated after opening, (4) do permission checking. 3741da177e4SLinus Torvalds */ 375ca364317SJ.Bruce Fields status = do_open_lookup(rqstp, &cstate->current_fh, 376ca364317SJ.Bruce Fields open); 3771da177e4SLinus Torvalds if (status) 3781da177e4SLinus Torvalds goto out; 3791da177e4SLinus Torvalds break; 3801da177e4SLinus Torvalds case NFS4_OPEN_CLAIM_PREVIOUS: 381dad1c067SJ. Bruce Fields open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED; 3821da177e4SLinus Torvalds /* 3831da177e4SLinus Torvalds * The CURRENT_FH is already set to the file being 3841da177e4SLinus Torvalds * opened. (1) set open->op_cinfo, (2) set 3851da177e4SLinus Torvalds * open->op_truncate if the file is to be truncated 3861da177e4SLinus Torvalds * after opening, (3) do permission checking. 3871da177e4SLinus Torvalds */ 388ca364317SJ.Bruce Fields status = do_open_fhandle(rqstp, &cstate->current_fh, 389ca364317SJ.Bruce Fields open); 3901da177e4SLinus Torvalds if (status) 3911da177e4SLinus Torvalds goto out; 3921da177e4SLinus Torvalds break; 3931da177e4SLinus Torvalds case NFS4_OPEN_CLAIM_DELEGATE_PREV: 394dad1c067SJ. Bruce Fields open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED; 3952fdada03SJ. Bruce Fields dprintk("NFSD: unsupported OPEN claim type %d\n", 3961da177e4SLinus Torvalds open->op_claim_type); 3971da177e4SLinus Torvalds status = nfserr_notsupp; 3981da177e4SLinus Torvalds goto out; 3991da177e4SLinus Torvalds default: 4002fdada03SJ. Bruce Fields dprintk("NFSD: Invalid OPEN claim type %d\n", 4011da177e4SLinus Torvalds open->op_claim_type); 4021da177e4SLinus Torvalds status = nfserr_inval; 4031da177e4SLinus Torvalds goto out; 4041da177e4SLinus Torvalds } 4051da177e4SLinus Torvalds /* 4061da177e4SLinus Torvalds * nfsd4_process_open2() does the actual opening of the file. If 4071da177e4SLinus Torvalds * successful, it (1) truncates the file if open->op_truncate was 4081da177e4SLinus Torvalds * set, (2) sets open->op_stateid, (3) sets open->op_delegation. 4091da177e4SLinus Torvalds */ 410ca364317SJ.Bruce Fields status = nfsd4_process_open2(rqstp, &cstate->current_fh, open); 4111da177e4SLinus Torvalds out: 412fe0750e5SJ. Bruce Fields if (open->op_openowner) 413fe0750e5SJ. Bruce Fields cstate->replay_owner = &open->op_openowner->oo_owner; 4147c13f344SJ. Bruce Fields else 4151da177e4SLinus Torvalds nfs4_unlock_state(); 4161da177e4SLinus Torvalds return status; 4171da177e4SLinus Torvalds } 4181da177e4SLinus Torvalds 4191da177e4SLinus Torvalds /* 4201da177e4SLinus Torvalds * filehandle-manipulating ops. 4211da177e4SLinus Torvalds */ 4227191155bSJ.Bruce Fields static __be32 423b591480bSJ.Bruce Fields nfsd4_getfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 424b591480bSJ.Bruce Fields struct svc_fh **getfh) 4251da177e4SLinus Torvalds { 426ca364317SJ.Bruce Fields if (!cstate->current_fh.fh_dentry) 4271da177e4SLinus Torvalds return nfserr_nofilehandle; 4281da177e4SLinus Torvalds 429ca364317SJ.Bruce Fields *getfh = &cstate->current_fh; 4301da177e4SLinus Torvalds return nfs_ok; 4311da177e4SLinus Torvalds } 4321da177e4SLinus Torvalds 4337191155bSJ.Bruce Fields static __be32 434ca364317SJ.Bruce Fields nfsd4_putfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 435ca364317SJ.Bruce Fields struct nfsd4_putfh *putfh) 4361da177e4SLinus Torvalds { 437ca364317SJ.Bruce Fields fh_put(&cstate->current_fh); 438ca364317SJ.Bruce Fields cstate->current_fh.fh_handle.fh_size = putfh->pf_fhlen; 439ca364317SJ.Bruce Fields memcpy(&cstate->current_fh.fh_handle.fh_base, putfh->pf_fhval, 440ca364317SJ.Bruce Fields putfh->pf_fhlen); 44168d93184SJ. Bruce Fields return fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_BYPASS_GSS); 4421da177e4SLinus Torvalds } 4431da177e4SLinus Torvalds 4447191155bSJ.Bruce Fields static __be32 445b591480bSJ.Bruce Fields nfsd4_putrootfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 446b591480bSJ.Bruce Fields void *arg) 4471da177e4SLinus Torvalds { 448b37ad28bSAl Viro __be32 status; 4491da177e4SLinus Torvalds 450ca364317SJ.Bruce Fields fh_put(&cstate->current_fh); 451df547efbSJ. Bruce Fields status = exp_pseudoroot(rqstp, &cstate->current_fh); 4521da177e4SLinus Torvalds return status; 4531da177e4SLinus Torvalds } 4541da177e4SLinus Torvalds 4557191155bSJ.Bruce Fields static __be32 456b591480bSJ.Bruce Fields nfsd4_restorefh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 457b591480bSJ.Bruce Fields void *arg) 4581da177e4SLinus Torvalds { 459ca364317SJ.Bruce Fields if (!cstate->save_fh.fh_dentry) 4601da177e4SLinus Torvalds return nfserr_restorefh; 4611da177e4SLinus Torvalds 462ca364317SJ.Bruce Fields fh_dup2(&cstate->current_fh, &cstate->save_fh); 4631da177e4SLinus Torvalds return nfs_ok; 4641da177e4SLinus Torvalds } 4651da177e4SLinus Torvalds 4667191155bSJ.Bruce Fields static __be32 467b591480bSJ.Bruce Fields nfsd4_savefh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 468b591480bSJ.Bruce Fields void *arg) 4691da177e4SLinus Torvalds { 470ca364317SJ.Bruce Fields if (!cstate->current_fh.fh_dentry) 4711da177e4SLinus Torvalds return nfserr_nofilehandle; 4721da177e4SLinus Torvalds 473ca364317SJ.Bruce Fields fh_dup2(&cstate->save_fh, &cstate->current_fh); 4741da177e4SLinus Torvalds return nfs_ok; 4751da177e4SLinus Torvalds } 4761da177e4SLinus Torvalds 4771da177e4SLinus Torvalds /* 4781da177e4SLinus Torvalds * misc nfsv4 ops 4791da177e4SLinus Torvalds */ 4807191155bSJ.Bruce Fields static __be32 481ca364317SJ.Bruce Fields nfsd4_access(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 482ca364317SJ.Bruce Fields struct nfsd4_access *access) 4831da177e4SLinus Torvalds { 4841da177e4SLinus Torvalds if (access->ac_req_access & ~NFS3_ACCESS_FULL) 4851da177e4SLinus Torvalds return nfserr_inval; 4861da177e4SLinus Torvalds 4871da177e4SLinus Torvalds access->ac_resp_access = access->ac_req_access; 488ca364317SJ.Bruce Fields return nfsd_access(rqstp, &cstate->current_fh, &access->ac_resp_access, 489ca364317SJ.Bruce Fields &access->ac_supported); 4901da177e4SLinus Torvalds } 4911da177e4SLinus Torvalds 4927191155bSJ.Bruce Fields static __be32 493ca364317SJ.Bruce Fields nfsd4_commit(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 494ca364317SJ.Bruce Fields struct nfsd4_commit *commit) 4951da177e4SLinus Torvalds { 4961da177e4SLinus Torvalds u32 *p = (u32 *)commit->co_verf.data; 4971da177e4SLinus Torvalds *p++ = nfssvc_boot.tv_sec; 4981da177e4SLinus Torvalds *p++ = nfssvc_boot.tv_usec; 4991da177e4SLinus Torvalds 50075c096f7SJ. Bruce Fields return nfsd_commit(rqstp, &cstate->current_fh, commit->co_offset, 501ca364317SJ.Bruce Fields commit->co_count); 5021da177e4SLinus Torvalds } 5031da177e4SLinus Torvalds 504b37ad28bSAl Viro static __be32 505ca364317SJ.Bruce Fields nfsd4_create(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 506ca364317SJ.Bruce Fields struct nfsd4_create *create) 5071da177e4SLinus Torvalds { 5081da177e4SLinus Torvalds struct svc_fh resfh; 509b37ad28bSAl Viro __be32 status; 5101da177e4SLinus Torvalds dev_t rdev; 5111da177e4SLinus Torvalds 5121da177e4SLinus Torvalds fh_init(&resfh, NFS4_FHSIZE); 5131da177e4SLinus Torvalds 5148837abcaSMiklos Szeredi status = fh_verify(rqstp, &cstate->current_fh, S_IFDIR, 5158837abcaSMiklos Szeredi NFSD_MAY_CREATE); 5161da177e4SLinus Torvalds if (status) 5171da177e4SLinus Torvalds return status; 5181da177e4SLinus Torvalds 5193c8e0316SYu Zhiguo status = check_attr_support(rqstp, cstate, create->cr_bmval, 5203c8e0316SYu Zhiguo nfsd_attrmask); 5213c8e0316SYu Zhiguo if (status) 5223c8e0316SYu Zhiguo return status; 5233c8e0316SYu Zhiguo 5241da177e4SLinus Torvalds switch (create->cr_type) { 5251da177e4SLinus Torvalds case NF4LNK: 5261da177e4SLinus Torvalds /* ugh! we have to null-terminate the linktext, or 5271da177e4SLinus Torvalds * vfs_symlink() will choke. it is always safe to 5281da177e4SLinus Torvalds * null-terminate by brute force, since at worst we 5291da177e4SLinus Torvalds * will overwrite the first byte of the create namelen 5301da177e4SLinus Torvalds * in the XDR buffer, which has already been extracted 5311da177e4SLinus Torvalds * during XDR decode. 5321da177e4SLinus Torvalds */ 5331da177e4SLinus Torvalds create->cr_linkname[create->cr_linklen] = 0; 5341da177e4SLinus Torvalds 535ca364317SJ.Bruce Fields status = nfsd_symlink(rqstp, &cstate->current_fh, 536ca364317SJ.Bruce Fields create->cr_name, create->cr_namelen, 537ca364317SJ.Bruce Fields create->cr_linkname, create->cr_linklen, 538ca364317SJ.Bruce Fields &resfh, &create->cr_iattr); 5391da177e4SLinus Torvalds break; 5401da177e4SLinus Torvalds 5411da177e4SLinus Torvalds case NF4BLK: 5421da177e4SLinus Torvalds rdev = MKDEV(create->cr_specdata1, create->cr_specdata2); 5431da177e4SLinus Torvalds if (MAJOR(rdev) != create->cr_specdata1 || 5441da177e4SLinus Torvalds MINOR(rdev) != create->cr_specdata2) 5451da177e4SLinus Torvalds return nfserr_inval; 546ca364317SJ.Bruce Fields status = nfsd_create(rqstp, &cstate->current_fh, 547ca364317SJ.Bruce Fields create->cr_name, create->cr_namelen, 548ca364317SJ.Bruce Fields &create->cr_iattr, S_IFBLK, rdev, &resfh); 5491da177e4SLinus Torvalds break; 5501da177e4SLinus Torvalds 5511da177e4SLinus Torvalds case NF4CHR: 5521da177e4SLinus Torvalds rdev = MKDEV(create->cr_specdata1, create->cr_specdata2); 5531da177e4SLinus Torvalds if (MAJOR(rdev) != create->cr_specdata1 || 5541da177e4SLinus Torvalds MINOR(rdev) != create->cr_specdata2) 5551da177e4SLinus Torvalds return nfserr_inval; 556ca364317SJ.Bruce Fields status = nfsd_create(rqstp, &cstate->current_fh, 557ca364317SJ.Bruce Fields create->cr_name, create->cr_namelen, 558ca364317SJ.Bruce Fields &create->cr_iattr,S_IFCHR, rdev, &resfh); 5591da177e4SLinus Torvalds break; 5601da177e4SLinus Torvalds 5611da177e4SLinus Torvalds case NF4SOCK: 562ca364317SJ.Bruce Fields status = nfsd_create(rqstp, &cstate->current_fh, 563ca364317SJ.Bruce Fields create->cr_name, create->cr_namelen, 564ca364317SJ.Bruce Fields &create->cr_iattr, S_IFSOCK, 0, &resfh); 5651da177e4SLinus Torvalds break; 5661da177e4SLinus Torvalds 5671da177e4SLinus Torvalds case NF4FIFO: 568ca364317SJ.Bruce Fields status = nfsd_create(rqstp, &cstate->current_fh, 569ca364317SJ.Bruce Fields create->cr_name, create->cr_namelen, 570ca364317SJ.Bruce Fields &create->cr_iattr, S_IFIFO, 0, &resfh); 5711da177e4SLinus Torvalds break; 5721da177e4SLinus Torvalds 5731da177e4SLinus Torvalds case NF4DIR: 5741da177e4SLinus Torvalds create->cr_iattr.ia_valid &= ~ATTR_SIZE; 575ca364317SJ.Bruce Fields status = nfsd_create(rqstp, &cstate->current_fh, 576ca364317SJ.Bruce Fields create->cr_name, create->cr_namelen, 577ca364317SJ.Bruce Fields &create->cr_iattr, S_IFDIR, 0, &resfh); 5781da177e4SLinus Torvalds break; 5791da177e4SLinus Torvalds 5801da177e4SLinus Torvalds default: 5811da177e4SLinus Torvalds status = nfserr_badtype; 5821da177e4SLinus Torvalds } 5831da177e4SLinus Torvalds 5849208faf2SYu Zhiguo if (status) 5859208faf2SYu Zhiguo goto out; 5869208faf2SYu Zhiguo 5879208faf2SYu Zhiguo if (create->cr_acl != NULL) 5889208faf2SYu Zhiguo do_set_nfs4_acl(rqstp, &resfh, create->cr_acl, 5899208faf2SYu Zhiguo create->cr_bmval); 5909208faf2SYu Zhiguo 591ca364317SJ.Bruce Fields fh_unlock(&cstate->current_fh); 592ca364317SJ.Bruce Fields set_change_info(&create->cr_cinfo, &cstate->current_fh); 593ca364317SJ.Bruce Fields fh_dup2(&cstate->current_fh, &resfh); 5949208faf2SYu Zhiguo out: 5951da177e4SLinus Torvalds fh_put(&resfh); 5961da177e4SLinus Torvalds return status; 5971da177e4SLinus Torvalds } 5981da177e4SLinus Torvalds 5997191155bSJ.Bruce Fields static __be32 600ca364317SJ.Bruce Fields nfsd4_getattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 601ca364317SJ.Bruce Fields struct nfsd4_getattr *getattr) 6021da177e4SLinus Torvalds { 603b37ad28bSAl Viro __be32 status; 6041da177e4SLinus Torvalds 6058837abcaSMiklos Szeredi status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP); 6061da177e4SLinus Torvalds if (status) 6071da177e4SLinus Torvalds return status; 6081da177e4SLinus Torvalds 6091da177e4SLinus Torvalds if (getattr->ga_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1) 6101da177e4SLinus Torvalds return nfserr_inval; 6111da177e4SLinus Torvalds 6127e705706SAndy Adamson getattr->ga_bmval[0] &= nfsd_suppattrs0(cstate->minorversion); 6137e705706SAndy Adamson getattr->ga_bmval[1] &= nfsd_suppattrs1(cstate->minorversion); 6147e705706SAndy Adamson getattr->ga_bmval[2] &= nfsd_suppattrs2(cstate->minorversion); 6151da177e4SLinus Torvalds 616ca364317SJ.Bruce Fields getattr->ga_fhp = &cstate->current_fh; 6171da177e4SLinus Torvalds return nfs_ok; 6181da177e4SLinus Torvalds } 6191da177e4SLinus Torvalds 6207191155bSJ.Bruce Fields static __be32 621ca364317SJ.Bruce Fields nfsd4_link(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 622ca364317SJ.Bruce Fields struct nfsd4_link *link) 6231da177e4SLinus Torvalds { 624b37ad28bSAl Viro __be32 status = nfserr_nofilehandle; 6251da177e4SLinus Torvalds 626ca364317SJ.Bruce Fields if (!cstate->save_fh.fh_dentry) 6271da177e4SLinus Torvalds return status; 628ca364317SJ.Bruce Fields status = nfsd_link(rqstp, &cstate->current_fh, 629ca364317SJ.Bruce Fields link->li_name, link->li_namelen, &cstate->save_fh); 6301da177e4SLinus Torvalds if (!status) 631ca364317SJ.Bruce Fields set_change_info(&link->li_cinfo, &cstate->current_fh); 6321da177e4SLinus Torvalds return status; 6331da177e4SLinus Torvalds } 6341da177e4SLinus Torvalds 6350ff7ab46SJ. Bruce Fields static __be32 nfsd4_do_lookupp(struct svc_rqst *rqstp, struct svc_fh *fh) 6361da177e4SLinus Torvalds { 6371da177e4SLinus Torvalds struct svc_fh tmp_fh; 638b37ad28bSAl Viro __be32 ret; 6391da177e4SLinus Torvalds 6401da177e4SLinus Torvalds fh_init(&tmp_fh, NFS4_FHSIZE); 641df547efbSJ. Bruce Fields ret = exp_pseudoroot(rqstp, &tmp_fh); 642df547efbSJ. Bruce Fields if (ret) 6431da177e4SLinus Torvalds return ret; 6440ff7ab46SJ. Bruce Fields if (tmp_fh.fh_dentry == fh->fh_dentry) { 6451da177e4SLinus Torvalds fh_put(&tmp_fh); 6461da177e4SLinus Torvalds return nfserr_noent; 6471da177e4SLinus Torvalds } 6481da177e4SLinus Torvalds fh_put(&tmp_fh); 6490ff7ab46SJ. Bruce Fields return nfsd_lookup(rqstp, fh, "..", 2, fh); 6500ff7ab46SJ. Bruce Fields } 6510ff7ab46SJ. Bruce Fields 6520ff7ab46SJ. Bruce Fields static __be32 6530ff7ab46SJ. Bruce Fields nfsd4_lookupp(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 6540ff7ab46SJ. Bruce Fields void *arg) 6550ff7ab46SJ. Bruce Fields { 6560ff7ab46SJ. Bruce Fields return nfsd4_do_lookupp(rqstp, &cstate->current_fh); 6571da177e4SLinus Torvalds } 6581da177e4SLinus Torvalds 6597191155bSJ.Bruce Fields static __be32 660ca364317SJ.Bruce Fields nfsd4_lookup(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 661ca364317SJ.Bruce Fields struct nfsd4_lookup *lookup) 6621da177e4SLinus Torvalds { 663ca364317SJ.Bruce Fields return nfsd_lookup(rqstp, &cstate->current_fh, 664ca364317SJ.Bruce Fields lookup->lo_name, lookup->lo_len, 665ca364317SJ.Bruce Fields &cstate->current_fh); 6661da177e4SLinus Torvalds } 6671da177e4SLinus Torvalds 6687191155bSJ.Bruce Fields static __be32 669ca364317SJ.Bruce Fields nfsd4_read(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 670ca364317SJ.Bruce Fields struct nfsd4_read *read) 6711da177e4SLinus Torvalds { 672b37ad28bSAl Viro __be32 status; 6731da177e4SLinus Torvalds 6741da177e4SLinus Torvalds /* no need to check permission - this will be done in nfsd_read() */ 6751da177e4SLinus Torvalds 6767e06b7f9SNeilBrown read->rd_filp = NULL; 6771da177e4SLinus Torvalds if (read->rd_offset >= OFFSET_MAX) 6781da177e4SLinus Torvalds return nfserr_inval; 6791da177e4SLinus Torvalds 6801da177e4SLinus Torvalds nfs4_lock_state(); 6811da177e4SLinus Torvalds /* check stateid */ 682dd453dfdSBenny Halevy if ((status = nfs4_preprocess_stateid_op(cstate, &read->rd_stateid, 6836150ef0dSJ. Bruce Fields RD_STATE, &read->rd_filp))) { 6841da177e4SLinus Torvalds dprintk("NFSD: nfsd4_read: couldn't process stateid!\n"); 6851da177e4SLinus Torvalds goto out; 6861da177e4SLinus Torvalds } 6877e06b7f9SNeilBrown if (read->rd_filp) 6887e06b7f9SNeilBrown get_file(read->rd_filp); 6891da177e4SLinus Torvalds status = nfs_ok; 6901da177e4SLinus Torvalds out: 6911da177e4SLinus Torvalds nfs4_unlock_state(); 6921da177e4SLinus Torvalds read->rd_rqstp = rqstp; 693ca364317SJ.Bruce Fields read->rd_fhp = &cstate->current_fh; 6941da177e4SLinus Torvalds return status; 6951da177e4SLinus Torvalds } 6961da177e4SLinus Torvalds 6977191155bSJ.Bruce Fields static __be32 698ca364317SJ.Bruce Fields nfsd4_readdir(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 699ca364317SJ.Bruce Fields struct nfsd4_readdir *readdir) 7001da177e4SLinus Torvalds { 7011da177e4SLinus Torvalds u64 cookie = readdir->rd_cookie; 7021da177e4SLinus Torvalds static const nfs4_verifier zeroverf; 7031da177e4SLinus Torvalds 7041da177e4SLinus Torvalds /* no need to check permission - this will be done in nfsd_readdir() */ 7051da177e4SLinus Torvalds 7061da177e4SLinus Torvalds if (readdir->rd_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1) 7071da177e4SLinus Torvalds return nfserr_inval; 7081da177e4SLinus Torvalds 7097e705706SAndy Adamson readdir->rd_bmval[0] &= nfsd_suppattrs0(cstate->minorversion); 7107e705706SAndy Adamson readdir->rd_bmval[1] &= nfsd_suppattrs1(cstate->minorversion); 7117e705706SAndy Adamson readdir->rd_bmval[2] &= nfsd_suppattrs2(cstate->minorversion); 7121da177e4SLinus Torvalds 713832023bfSBernd Schubert if ((cookie == 1) || (cookie == 2) || 7141da177e4SLinus Torvalds (cookie == 0 && memcmp(readdir->rd_verf.data, zeroverf.data, NFS4_VERIFIER_SIZE))) 7151da177e4SLinus Torvalds return nfserr_bad_cookie; 7161da177e4SLinus Torvalds 7171da177e4SLinus Torvalds readdir->rd_rqstp = rqstp; 718ca364317SJ.Bruce Fields readdir->rd_fhp = &cstate->current_fh; 7191da177e4SLinus Torvalds return nfs_ok; 7201da177e4SLinus Torvalds } 7211da177e4SLinus Torvalds 7227191155bSJ.Bruce Fields static __be32 723ca364317SJ.Bruce Fields nfsd4_readlink(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 724ca364317SJ.Bruce Fields struct nfsd4_readlink *readlink) 7251da177e4SLinus Torvalds { 7261da177e4SLinus Torvalds readlink->rl_rqstp = rqstp; 727ca364317SJ.Bruce Fields readlink->rl_fhp = &cstate->current_fh; 7281da177e4SLinus Torvalds return nfs_ok; 7291da177e4SLinus Torvalds } 7301da177e4SLinus Torvalds 7317191155bSJ.Bruce Fields static __be32 732ca364317SJ.Bruce Fields nfsd4_remove(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 733ca364317SJ.Bruce Fields struct nfsd4_remove *remove) 7341da177e4SLinus Torvalds { 735b37ad28bSAl Viro __be32 status; 7361da177e4SLinus Torvalds 737af558e33SJ. Bruce Fields if (locks_in_grace()) 738c815afc7SNeilBrown return nfserr_grace; 739ca364317SJ.Bruce Fields status = nfsd_unlink(rqstp, &cstate->current_fh, 0, 740ca364317SJ.Bruce Fields remove->rm_name, remove->rm_namelen); 7411da177e4SLinus Torvalds if (!status) { 742ca364317SJ.Bruce Fields fh_unlock(&cstate->current_fh); 743ca364317SJ.Bruce Fields set_change_info(&remove->rm_cinfo, &cstate->current_fh); 7441da177e4SLinus Torvalds } 7451da177e4SLinus Torvalds return status; 7461da177e4SLinus Torvalds } 7471da177e4SLinus Torvalds 7487191155bSJ.Bruce Fields static __be32 749ca364317SJ.Bruce Fields nfsd4_rename(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 750ca364317SJ.Bruce Fields struct nfsd4_rename *rename) 7511da177e4SLinus Torvalds { 752b37ad28bSAl Viro __be32 status = nfserr_nofilehandle; 7531da177e4SLinus Torvalds 754ca364317SJ.Bruce Fields if (!cstate->save_fh.fh_dentry) 7551da177e4SLinus Torvalds return status; 756af558e33SJ. Bruce Fields if (locks_in_grace() && !(cstate->save_fh.fh_export->ex_flags 757c815afc7SNeilBrown & NFSEXP_NOSUBTREECHECK)) 758c815afc7SNeilBrown return nfserr_grace; 759ca364317SJ.Bruce Fields status = nfsd_rename(rqstp, &cstate->save_fh, rename->rn_sname, 760ca364317SJ.Bruce Fields rename->rn_snamelen, &cstate->current_fh, 7611da177e4SLinus Torvalds rename->rn_tname, rename->rn_tnamelen); 7621da177e4SLinus Torvalds 7631da177e4SLinus Torvalds /* the underlying filesystem returns different error's than required 7641da177e4SLinus Torvalds * by NFSv4. both save_fh and current_fh have been verified.. */ 7651da177e4SLinus Torvalds if (status == nfserr_isdir) 7661da177e4SLinus Torvalds status = nfserr_exist; 7671da177e4SLinus Torvalds else if ((status == nfserr_notdir) && 768ca364317SJ.Bruce Fields (S_ISDIR(cstate->save_fh.fh_dentry->d_inode->i_mode) && 769ca364317SJ.Bruce Fields S_ISDIR(cstate->current_fh.fh_dentry->d_inode->i_mode))) 7701da177e4SLinus Torvalds status = nfserr_exist; 7711da177e4SLinus Torvalds 7721da177e4SLinus Torvalds if (!status) { 773ca364317SJ.Bruce Fields set_change_info(&rename->rn_sinfo, &cstate->current_fh); 774ca364317SJ.Bruce Fields set_change_info(&rename->rn_tinfo, &cstate->save_fh); 7751da177e4SLinus Torvalds } 7761da177e4SLinus Torvalds return status; 7771da177e4SLinus Torvalds } 7781da177e4SLinus Torvalds 7797191155bSJ.Bruce Fields static __be32 780dcb488a3SAndy Adamson nfsd4_secinfo(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 781dcb488a3SAndy Adamson struct nfsd4_secinfo *secinfo) 782dcb488a3SAndy Adamson { 783dcb488a3SAndy Adamson struct svc_fh resfh; 784dcb488a3SAndy Adamson struct svc_export *exp; 785dcb488a3SAndy Adamson struct dentry *dentry; 786dcb488a3SAndy Adamson __be32 err; 787dcb488a3SAndy Adamson 788dcb488a3SAndy Adamson fh_init(&resfh, NFS4_FHSIZE); 78929a78a3eSJ. Bruce Fields err = fh_verify(rqstp, &cstate->current_fh, S_IFDIR, NFSD_MAY_EXEC); 79029a78a3eSJ. Bruce Fields if (err) 79129a78a3eSJ. Bruce Fields return err; 792dcb488a3SAndy Adamson err = nfsd_lookup_dentry(rqstp, &cstate->current_fh, 793dcb488a3SAndy Adamson secinfo->si_name, secinfo->si_namelen, 794dcb488a3SAndy Adamson &exp, &dentry); 795dcb488a3SAndy Adamson if (err) 796dcb488a3SAndy Adamson return err; 797dcb488a3SAndy Adamson if (dentry->d_inode == NULL) { 798dcb488a3SAndy Adamson exp_put(exp); 799dcb488a3SAndy Adamson err = nfserr_noent; 800dcb488a3SAndy Adamson } else 801dcb488a3SAndy Adamson secinfo->si_exp = exp; 802dcb488a3SAndy Adamson dput(dentry); 80356560b9aSJ. Bruce Fields if (cstate->minorversion) 80456560b9aSJ. Bruce Fields /* See rfc 5661 section 2.6.3.1.1.8 */ 80556560b9aSJ. Bruce Fields fh_put(&cstate->current_fh); 806dcb488a3SAndy Adamson return err; 807dcb488a3SAndy Adamson } 808dcb488a3SAndy Adamson 809dcb488a3SAndy Adamson static __be32 81004f4ad16SJ. Bruce Fields nfsd4_secinfo_no_name(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 81104f4ad16SJ. Bruce Fields struct nfsd4_secinfo_no_name *sin) 81204f4ad16SJ. Bruce Fields { 81304f4ad16SJ. Bruce Fields __be32 err; 81404f4ad16SJ. Bruce Fields 81504f4ad16SJ. Bruce Fields switch (sin->sin_style) { 81604f4ad16SJ. Bruce Fields case NFS4_SECINFO_STYLE4_CURRENT_FH: 81704f4ad16SJ. Bruce Fields break; 81804f4ad16SJ. Bruce Fields case NFS4_SECINFO_STYLE4_PARENT: 81904f4ad16SJ. Bruce Fields err = nfsd4_do_lookupp(rqstp, &cstate->current_fh); 82004f4ad16SJ. Bruce Fields if (err) 82104f4ad16SJ. Bruce Fields return err; 82204f4ad16SJ. Bruce Fields break; 82304f4ad16SJ. Bruce Fields default: 82404f4ad16SJ. Bruce Fields return nfserr_inval; 82504f4ad16SJ. Bruce Fields } 82604f4ad16SJ. Bruce Fields exp_get(cstate->current_fh.fh_export); 82704f4ad16SJ. Bruce Fields sin->sin_exp = cstate->current_fh.fh_export; 82804f4ad16SJ. Bruce Fields fh_put(&cstate->current_fh); 82904f4ad16SJ. Bruce Fields return nfs_ok; 83004f4ad16SJ. Bruce Fields } 83104f4ad16SJ. Bruce Fields 83204f4ad16SJ. Bruce Fields static __be32 833ca364317SJ.Bruce Fields nfsd4_setattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 834ca364317SJ.Bruce Fields struct nfsd4_setattr *setattr) 8351da177e4SLinus Torvalds { 836b37ad28bSAl Viro __be32 status = nfs_ok; 8371da177e4SLinus Torvalds 8381da177e4SLinus Torvalds if (setattr->sa_iattr.ia_valid & ATTR_SIZE) { 8391da177e4SLinus Torvalds nfs4_lock_state(); 840dd453dfdSBenny Halevy status = nfs4_preprocess_stateid_op(cstate, 8416150ef0dSJ. Bruce Fields &setattr->sa_stateid, WR_STATE, NULL); 8421da177e4SLinus Torvalds nfs4_unlock_state(); 843375c5547SJ. Bruce Fields if (status) { 8443e3b4800SGreg Banks dprintk("NFSD: nfsd4_setattr: couldn't process stateid!\n"); 845375c5547SJ. Bruce Fields return status; 846375c5547SJ. Bruce Fields } 8471da177e4SLinus Torvalds } 84818f335afSDave Hansen status = mnt_want_write(cstate->current_fh.fh_export->ex_path.mnt); 84918f335afSDave Hansen if (status) 85018f335afSDave Hansen return status; 8511da177e4SLinus Torvalds status = nfs_ok; 8523c8e0316SYu Zhiguo 8533c8e0316SYu Zhiguo status = check_attr_support(rqstp, cstate, setattr->sa_bmval, 8543c8e0316SYu Zhiguo nfsd_attrmask); 8553c8e0316SYu Zhiguo if (status) 8563c8e0316SYu Zhiguo goto out; 8573c8e0316SYu Zhiguo 8581da177e4SLinus Torvalds if (setattr->sa_acl != NULL) 859ca364317SJ.Bruce Fields status = nfsd4_set_nfs4_acl(rqstp, &cstate->current_fh, 860ca364317SJ.Bruce Fields setattr->sa_acl); 8611da177e4SLinus Torvalds if (status) 86218f335afSDave Hansen goto out; 863ca364317SJ.Bruce Fields status = nfsd_setattr(rqstp, &cstate->current_fh, &setattr->sa_iattr, 8641da177e4SLinus Torvalds 0, (time_t)0); 86518f335afSDave Hansen out: 86618f335afSDave Hansen mnt_drop_write(cstate->current_fh.fh_export->ex_path.mnt); 8671da177e4SLinus Torvalds return status; 8681da177e4SLinus Torvalds } 8691da177e4SLinus Torvalds 8707191155bSJ.Bruce Fields static __be32 871ca364317SJ.Bruce Fields nfsd4_write(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 872ca364317SJ.Bruce Fields struct nfsd4_write *write) 8731da177e4SLinus Torvalds { 8741da177e4SLinus Torvalds stateid_t *stateid = &write->wr_stateid; 8751da177e4SLinus Torvalds struct file *filp = NULL; 8761da177e4SLinus Torvalds u32 *p; 877b37ad28bSAl Viro __be32 status = nfs_ok; 87831dec253SDavid Shaw unsigned long cnt; 8791da177e4SLinus Torvalds 8801da177e4SLinus Torvalds /* no need to check permission - this will be done in nfsd_write() */ 8811da177e4SLinus Torvalds 8821da177e4SLinus Torvalds if (write->wr_offset >= OFFSET_MAX) 8831da177e4SLinus Torvalds return nfserr_inval; 8841da177e4SLinus Torvalds 8851da177e4SLinus Torvalds nfs4_lock_state(); 886dd453dfdSBenny Halevy status = nfs4_preprocess_stateid_op(cstate, stateid, WR_STATE, &filp); 8877e06b7f9SNeilBrown if (filp) 8887e06b7f9SNeilBrown get_file(filp); 8891da177e4SLinus Torvalds nfs4_unlock_state(); 8901da177e4SLinus Torvalds 891375c5547SJ. Bruce Fields if (status) { 892375c5547SJ. Bruce Fields dprintk("NFSD: nfsd4_write: couldn't process stateid!\n"); 893375c5547SJ. Bruce Fields return status; 894375c5547SJ. Bruce Fields } 895375c5547SJ. Bruce Fields 89631dec253SDavid Shaw cnt = write->wr_buflen; 8971da177e4SLinus Torvalds write->wr_how_written = write->wr_stable_how; 8981da177e4SLinus Torvalds p = (u32 *)write->wr_verifier.data; 8991da177e4SLinus Torvalds *p++ = nfssvc_boot.tv_sec; 9001da177e4SLinus Torvalds *p++ = nfssvc_boot.tv_usec; 9011da177e4SLinus Torvalds 902ca364317SJ.Bruce Fields status = nfsd_write(rqstp, &cstate->current_fh, filp, 903ca364317SJ.Bruce Fields write->wr_offset, rqstp->rq_vec, write->wr_vlen, 90431dec253SDavid Shaw &cnt, &write->wr_how_written); 9057e06b7f9SNeilBrown if (filp) 9067e06b7f9SNeilBrown fput(filp); 9071da177e4SLinus Torvalds 90831dec253SDavid Shaw write->wr_bytes_written = cnt; 90931dec253SDavid Shaw 9101da177e4SLinus Torvalds return status; 9111da177e4SLinus Torvalds } 9121da177e4SLinus Torvalds 9131da177e4SLinus Torvalds /* This routine never returns NFS_OK! If there are no other errors, it 9141da177e4SLinus Torvalds * will return NFSERR_SAME or NFSERR_NOT_SAME depending on whether the 9151da177e4SLinus Torvalds * attributes matched. VERIFY is implemented by mapping NFSERR_SAME 9161da177e4SLinus Torvalds * to NFS_OK after the call; NVERIFY by mapping NFSERR_NOT_SAME to NFS_OK. 9171da177e4SLinus Torvalds */ 918b37ad28bSAl Viro static __be32 919c954e2a5SJ.Bruce Fields _nfsd4_verify(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 920ca364317SJ.Bruce Fields struct nfsd4_verify *verify) 9211da177e4SLinus Torvalds { 9222ebbc012SAl Viro __be32 *buf, *p; 9231da177e4SLinus Torvalds int count; 924b37ad28bSAl Viro __be32 status; 9251da177e4SLinus Torvalds 9268837abcaSMiklos Szeredi status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP); 9271da177e4SLinus Torvalds if (status) 9281da177e4SLinus Torvalds return status; 9291da177e4SLinus Torvalds 9303c8e0316SYu Zhiguo status = check_attr_support(rqstp, cstate, verify->ve_bmval, NULL); 9313c8e0316SYu Zhiguo if (status) 9323c8e0316SYu Zhiguo return status; 9333c8e0316SYu Zhiguo 9341da177e4SLinus Torvalds if ((verify->ve_bmval[0] & FATTR4_WORD0_RDATTR_ERROR) 9351da177e4SLinus Torvalds || (verify->ve_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1)) 9361da177e4SLinus Torvalds return nfserr_inval; 9371da177e4SLinus Torvalds if (verify->ve_attrlen & 3) 9381da177e4SLinus Torvalds return nfserr_inval; 9391da177e4SLinus Torvalds 9401da177e4SLinus Torvalds /* count in words: 9411da177e4SLinus Torvalds * bitmap_len(1) + bitmap(2) + attr_len(1) = 4 9421da177e4SLinus Torvalds */ 9431da177e4SLinus Torvalds count = 4 + (verify->ve_attrlen >> 2); 9441da177e4SLinus Torvalds buf = kmalloc(count << 2, GFP_KERNEL); 9451da177e4SLinus Torvalds if (!buf) 9463e772463SJ. Bruce Fields return nfserr_jukebox; 9471da177e4SLinus Torvalds 948ca364317SJ.Bruce Fields status = nfsd4_encode_fattr(&cstate->current_fh, 949ca364317SJ.Bruce Fields cstate->current_fh.fh_export, 950ca364317SJ.Bruce Fields cstate->current_fh.fh_dentry, buf, 9511da177e4SLinus Torvalds &count, verify->ve_bmval, 952406a7ea9SFrank Filz rqstp, 0); 9531da177e4SLinus Torvalds 9541da177e4SLinus Torvalds /* this means that nfsd4_encode_fattr() ran out of space */ 9551da177e4SLinus Torvalds if (status == nfserr_resource && count == 0) 9561da177e4SLinus Torvalds status = nfserr_not_same; 9571da177e4SLinus Torvalds if (status) 9581da177e4SLinus Torvalds goto out_kfree; 9591da177e4SLinus Torvalds 96095ec28cdSBenny Halevy /* skip bitmap */ 96195ec28cdSBenny Halevy p = buf + 1 + ntohl(buf[0]); 9621da177e4SLinus Torvalds status = nfserr_not_same; 9631da177e4SLinus Torvalds if (ntohl(*p++) != verify->ve_attrlen) 9641da177e4SLinus Torvalds goto out_kfree; 9651da177e4SLinus Torvalds if (!memcmp(p, verify->ve_attrval, verify->ve_attrlen)) 9661da177e4SLinus Torvalds status = nfserr_same; 9671da177e4SLinus Torvalds 9681da177e4SLinus Torvalds out_kfree: 9691da177e4SLinus Torvalds kfree(buf); 9701da177e4SLinus Torvalds return status; 9711da177e4SLinus Torvalds } 9721da177e4SLinus Torvalds 973c954e2a5SJ.Bruce Fields static __be32 974c954e2a5SJ.Bruce Fields nfsd4_nverify(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 975c954e2a5SJ.Bruce Fields struct nfsd4_verify *verify) 976c954e2a5SJ.Bruce Fields { 977c954e2a5SJ.Bruce Fields __be32 status; 978c954e2a5SJ.Bruce Fields 979c954e2a5SJ.Bruce Fields status = _nfsd4_verify(rqstp, cstate, verify); 980c954e2a5SJ.Bruce Fields return status == nfserr_not_same ? nfs_ok : status; 981c954e2a5SJ.Bruce Fields } 982c954e2a5SJ.Bruce Fields 983c954e2a5SJ.Bruce Fields static __be32 984c954e2a5SJ.Bruce Fields nfsd4_verify(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 985c954e2a5SJ.Bruce Fields struct nfsd4_verify *verify) 986c954e2a5SJ.Bruce Fields { 987c954e2a5SJ.Bruce Fields __be32 status; 988c954e2a5SJ.Bruce Fields 989c954e2a5SJ.Bruce Fields status = _nfsd4_verify(rqstp, cstate, verify); 990c954e2a5SJ.Bruce Fields return status == nfserr_same ? nfs_ok : status; 991c954e2a5SJ.Bruce Fields } 992c954e2a5SJ.Bruce Fields 9931da177e4SLinus Torvalds /* 9941da177e4SLinus Torvalds * NULL call. 9951da177e4SLinus Torvalds */ 9967111c66eSAl Viro static __be32 9971da177e4SLinus Torvalds nfsd4_proc_null(struct svc_rqst *rqstp, void *argp, void *resp) 9981da177e4SLinus Torvalds { 9991da177e4SLinus Torvalds return nfs_ok; 10001da177e4SLinus Torvalds } 10011da177e4SLinus Torvalds 1002e2b20950SShankar Anand static inline void nfsd4_increment_op_stats(u32 opnum) 1003e2b20950SShankar Anand { 1004e2b20950SShankar Anand if (opnum >= FIRST_NFS4_OP && opnum <= LAST_NFS4_OP) 1005e2b20950SShankar Anand nfsdstats.nfs4_opcount[opnum]++; 1006e2b20950SShankar Anand } 1007e2b20950SShankar Anand 1008b591480bSJ.Bruce Fields typedef __be32(*nfsd4op_func)(struct svc_rqst *, struct nfsd4_compound_state *, 1009b591480bSJ.Bruce Fields void *); 101058e7b33aSMi Jinlong typedef u32(*nfsd4op_rsize)(struct svc_rqst *, struct nfsd4_op *op); 101158e7b33aSMi Jinlong 1012f9bb94c4SAndy Adamson enum nfsd4_op_flags { 1013f9bb94c4SAndy Adamson ALLOWED_WITHOUT_FH = 1 << 0, /* No current filehandle required */ 10145ece3cafSMi Jinlong ALLOWED_ON_ABSENT_FS = 1 << 1, /* ops processed on absent fs */ 10155ece3cafSMi Jinlong ALLOWED_AS_FIRST_OP = 1 << 2, /* ops reqired first in compound */ 101668d93184SJ. Bruce Fields /* For rfc 5661 section 2.6.3.1.1: */ 101768d93184SJ. Bruce Fields OP_HANDLES_WRONGSEC = 1 << 3, 101868d93184SJ. Bruce Fields OP_IS_PUTFH_LIKE = 1 << 4, 10191091006cSJ. Bruce Fields /* 1020c856694eSJ. Bruce Fields * These are the ops whose result size we estimate before 1021c856694eSJ. Bruce Fields * encoding, to avoid performing an op then not being able to 1022c856694eSJ. Bruce Fields * respond or cache a response. This includes writes and setattrs 1023c856694eSJ. Bruce Fields * as well as the operations usually called "nonidempotent": 1024c856694eSJ. Bruce Fields */ 1025c856694eSJ. Bruce Fields OP_MODIFIES_SOMETHING = 1 << 5, 1026c856694eSJ. Bruce Fields /* 1027c856694eSJ. Bruce Fields * Cache compounds containing these ops in the xid-based drc: 10281091006cSJ. Bruce Fields * We use the DRC for compounds containing non-idempotent 10291091006cSJ. Bruce Fields * operations, *except* those that are 4.1-specific (since 10301091006cSJ. Bruce Fields * sessions provide their own EOS), and except for stateful 10311091006cSJ. Bruce Fields * operations other than setclientid and setclientid_confirm 10321091006cSJ. Bruce Fields * (since sequence numbers provide EOS for open, lock, etc in 10331091006cSJ. Bruce Fields * the v4.0 case). 10341091006cSJ. Bruce Fields */ 1035c856694eSJ. Bruce Fields OP_CACHEME = 1 << 6, 1036c856694eSJ. Bruce Fields }; 1037c856694eSJ. Bruce Fields 1038c856694eSJ. Bruce Fields struct nfsd4_operation { 1039c856694eSJ. Bruce Fields nfsd4op_func op_func; 1040c856694eSJ. Bruce Fields u32 op_flags; 1041c856694eSJ. Bruce Fields char *op_name; 104258e7b33aSMi Jinlong /* Try to get response size before operation */ 104358e7b33aSMi Jinlong nfsd4op_rsize op_rsize_bop; 1044b591480bSJ.Bruce Fields }; 1045b591480bSJ.Bruce Fields 1046b591480bSJ.Bruce Fields static struct nfsd4_operation nfsd4_ops[]; 1047b591480bSJ.Bruce Fields 1048f1c7f79bSAdrian Bunk static const char *nfsd4_op_name(unsigned opnum); 1049b001a1b6SBenny Halevy 10501da177e4SLinus Torvalds /* 105157716355SJ. Bruce Fields * Enforce NFSv4.1 COMPOUND ordering rules: 1052f9bb94c4SAndy Adamson * 105357716355SJ. Bruce Fields * Also note, enforced elsewhere: 105457716355SJ. Bruce Fields * - SEQUENCE other than as first op results in 105557716355SJ. Bruce Fields * NFS4ERR_SEQUENCE_POS. (Enforced in nfsd4_sequence().) 10561d1bc8f2SJ. Bruce Fields * - BIND_CONN_TO_SESSION must be the only op in its compound. 10571d1bc8f2SJ. Bruce Fields * (Enforced in nfsd4_bind_conn_to_session().) 105857716355SJ. Bruce Fields * - DESTROY_SESSION must be the final operation in a compound, if 105957716355SJ. Bruce Fields * sessionid's in SEQUENCE and DESTROY_SESSION are the same. 106057716355SJ. Bruce Fields * (Enforced in nfsd4_destroy_session().) 1061f9bb94c4SAndy Adamson */ 106257716355SJ. Bruce Fields static __be32 nfs41_check_op_ordering(struct nfsd4_compoundargs *args) 1063f9bb94c4SAndy Adamson { 1064f9bb94c4SAndy Adamson struct nfsd4_op *op = &args->ops[0]; 106557716355SJ. Bruce Fields 106657716355SJ. Bruce Fields /* These ordering requirements don't apply to NFSv4.0: */ 106757716355SJ. Bruce Fields if (args->minorversion == 0) 106857716355SJ. Bruce Fields return nfs_ok; 106957716355SJ. Bruce Fields /* This is weird, but OK, not our problem: */ 107057716355SJ. Bruce Fields if (args->opcnt == 0) 107157716355SJ. Bruce Fields return nfs_ok; 107257716355SJ. Bruce Fields if (op->status == nfserr_op_illegal) 107357716355SJ. Bruce Fields return nfs_ok; 107457716355SJ. Bruce Fields if (!(nfsd4_ops[op->opnum].op_flags & ALLOWED_AS_FIRST_OP)) 107557716355SJ. Bruce Fields return nfserr_op_not_in_session; 107657716355SJ. Bruce Fields if (op->opnum == OP_SEQUENCE) 107757716355SJ. Bruce Fields return nfs_ok; 107857716355SJ. Bruce Fields if (args->opcnt != 1) 107957716355SJ. Bruce Fields return nfserr_not_only_op; 108057716355SJ. Bruce Fields return nfs_ok; 1081f9bb94c4SAndy Adamson } 1082f9bb94c4SAndy Adamson 108322b03214SJ. Bruce Fields static inline struct nfsd4_operation *OPDESC(struct nfsd4_op *op) 108422b03214SJ. Bruce Fields { 108522b03214SJ. Bruce Fields return &nfsd4_ops[op->opnum]; 108622b03214SJ. Bruce Fields } 108722b03214SJ. Bruce Fields 10881091006cSJ. Bruce Fields bool nfsd4_cache_this_op(struct nfsd4_op *op) 10891091006cSJ. Bruce Fields { 1090c856694eSJ. Bruce Fields return OPDESC(op)->op_flags & OP_CACHEME; 10911091006cSJ. Bruce Fields } 10921091006cSJ. Bruce Fields 109368d93184SJ. Bruce Fields static bool need_wrongsec_check(struct svc_rqst *rqstp) 109468d93184SJ. Bruce Fields { 109568d93184SJ. Bruce Fields struct nfsd4_compoundres *resp = rqstp->rq_resp; 109668d93184SJ. Bruce Fields struct nfsd4_compoundargs *argp = rqstp->rq_argp; 109768d93184SJ. Bruce Fields struct nfsd4_op *this = &argp->ops[resp->opcnt - 1]; 109868d93184SJ. Bruce Fields struct nfsd4_op *next = &argp->ops[resp->opcnt]; 109968d93184SJ. Bruce Fields struct nfsd4_operation *thisd; 110068d93184SJ. Bruce Fields struct nfsd4_operation *nextd; 110168d93184SJ. Bruce Fields 110268d93184SJ. Bruce Fields thisd = OPDESC(this); 110368d93184SJ. Bruce Fields /* 110468d93184SJ. Bruce Fields * Most ops check wronsec on our own; only the putfh-like ops 110568d93184SJ. Bruce Fields * have special rules. 110668d93184SJ. Bruce Fields */ 110768d93184SJ. Bruce Fields if (!(thisd->op_flags & OP_IS_PUTFH_LIKE)) 110868d93184SJ. Bruce Fields return false; 110968d93184SJ. Bruce Fields /* 111068d93184SJ. Bruce Fields * rfc 5661 2.6.3.1.1.6: don't bother erroring out a 111168d93184SJ. Bruce Fields * put-filehandle operation if we're not going to use the 111268d93184SJ. Bruce Fields * result: 111368d93184SJ. Bruce Fields */ 111468d93184SJ. Bruce Fields if (argp->opcnt == resp->opcnt) 111568d93184SJ. Bruce Fields return false; 111668d93184SJ. Bruce Fields 111768d93184SJ. Bruce Fields nextd = OPDESC(next); 111868d93184SJ. Bruce Fields /* 111968d93184SJ. Bruce Fields * Rest of 2.6.3.1.1: certain operations will return WRONGSEC 112068d93184SJ. Bruce Fields * errors themselves as necessary; others should check for them 112168d93184SJ. Bruce Fields * now: 112268d93184SJ. Bruce Fields */ 112368d93184SJ. Bruce Fields return !(nextd->op_flags & OP_HANDLES_WRONGSEC); 112468d93184SJ. Bruce Fields } 112568d93184SJ. Bruce Fields 1126f9bb94c4SAndy Adamson /* 11271da177e4SLinus Torvalds * COMPOUND call. 11281da177e4SLinus Torvalds */ 11297111c66eSAl Viro static __be32 11301da177e4SLinus Torvalds nfsd4_proc_compound(struct svc_rqst *rqstp, 11311da177e4SLinus Torvalds struct nfsd4_compoundargs *args, 11321da177e4SLinus Torvalds struct nfsd4_compoundres *resp) 11331da177e4SLinus Torvalds { 11341da177e4SLinus Torvalds struct nfsd4_op *op; 1135b591480bSJ.Bruce Fields struct nfsd4_operation *opdesc; 1136e354d571SAndy Adamson struct nfsd4_compound_state *cstate = &resp->cstate; 1137e5710199SJ.Bruce Fields int slack_bytes; 113858e7b33aSMi Jinlong u32 plen = 0; 1139b37ad28bSAl Viro __be32 status; 11401da177e4SLinus Torvalds 11411da177e4SLinus Torvalds resp->xbuf = &rqstp->rq_res; 1142e354d571SAndy Adamson resp->p = rqstp->rq_res.head[0].iov_base + 1143e354d571SAndy Adamson rqstp->rq_res.head[0].iov_len; 11441da177e4SLinus Torvalds resp->tagp = resp->p; 11451da177e4SLinus Torvalds /* reserve space for: taglen, tag, and opcnt */ 11461da177e4SLinus Torvalds resp->p += 2 + XDR_QUADLEN(args->taglen); 11471da177e4SLinus Torvalds resp->end = rqstp->rq_res.head[0].iov_base + PAGE_SIZE; 11481da177e4SLinus Torvalds resp->taglen = args->taglen; 11491da177e4SLinus Torvalds resp->tag = args->tag; 11501da177e4SLinus Torvalds resp->opcnt = 0; 11511da177e4SLinus Torvalds resp->rqstp = rqstp; 1152d87a8adeSAndy Adamson resp->cstate.minorversion = args->minorversion; 1153e354d571SAndy Adamson resp->cstate.replay_owner = NULL; 115426c0c75eSJ. Bruce Fields resp->cstate.session = NULL; 1155e354d571SAndy Adamson fh_init(&resp->cstate.current_fh, NFS4_FHSIZE); 1156e354d571SAndy Adamson fh_init(&resp->cstate.save_fh, NFS4_FHSIZE); 11578ff30fa4SNeilBrown /* 11588ff30fa4SNeilBrown * Don't use the deferral mechanism for NFSv4; compounds make it 11598ff30fa4SNeilBrown * too hard to avoid non-idempotency problems. 11608ff30fa4SNeilBrown */ 11618ff30fa4SNeilBrown rqstp->rq_usedeferral = 0; 11621da177e4SLinus Torvalds 11631da177e4SLinus Torvalds /* 11641da177e4SLinus Torvalds * According to RFC3010, this takes precedence over all other errors. 11651da177e4SLinus Torvalds */ 11661da177e4SLinus Torvalds status = nfserr_minor_vers_mismatch; 11678daf220aSBenny Halevy if (args->minorversion > nfsd_supported_minorversion) 11681da177e4SLinus Torvalds goto out; 11691da177e4SLinus Torvalds 117057716355SJ. Bruce Fields status = nfs41_check_op_ordering(args); 117157716355SJ. Bruce Fields if (status) { 1172f9bb94c4SAndy Adamson op = &args->ops[0]; 117357716355SJ. Bruce Fields op->status = status; 1174f9bb94c4SAndy Adamson goto encode_op; 1175f9bb94c4SAndy Adamson } 1176f9bb94c4SAndy Adamson 11771da177e4SLinus Torvalds while (!status && resp->opcnt < args->opcnt) { 11781da177e4SLinus Torvalds op = &args->ops[resp->opcnt++]; 11791da177e4SLinus Torvalds 1180b001a1b6SBenny Halevy dprintk("nfsv4 compound op #%d/%d: %d (%s)\n", 1181b001a1b6SBenny Halevy resp->opcnt, args->opcnt, op->opnum, 1182b001a1b6SBenny Halevy nfsd4_op_name(op->opnum)); 11831da177e4SLinus Torvalds /* 11841da177e4SLinus Torvalds * The XDR decode routines may have pre-set op->status; 11851da177e4SLinus Torvalds * for example, if there is a miscellaneous XDR error 11861da177e4SLinus Torvalds * it will be set to nfserr_bad_xdr. 11871da177e4SLinus Torvalds */ 11881da177e4SLinus Torvalds if (op->status) 11891da177e4SLinus Torvalds goto encode_op; 11901da177e4SLinus Torvalds 11911da177e4SLinus Torvalds /* We must be able to encode a successful response to 11921da177e4SLinus Torvalds * this operation, with enough room left over to encode a 11931da177e4SLinus Torvalds * failed response to the next operation. If we don't 11941da177e4SLinus Torvalds * have enough room, fail with ERR_RESOURCE. 11951da177e4SLinus Torvalds */ 1196e5710199SJ.Bruce Fields slack_bytes = (char *)resp->end - (char *)resp->p; 1197e5710199SJ.Bruce Fields if (slack_bytes < COMPOUND_SLACK_SPACE 1198e5710199SJ.Bruce Fields + COMPOUND_ERR_SLACK_SPACE) { 1199e5710199SJ.Bruce Fields BUG_ON(slack_bytes < COMPOUND_ERR_SLACK_SPACE); 12001da177e4SLinus Torvalds op->status = nfserr_resource; 12011da177e4SLinus Torvalds goto encode_op; 12021da177e4SLinus Torvalds } 12031da177e4SLinus Torvalds 120422b03214SJ. Bruce Fields opdesc = OPDESC(op); 1205b591480bSJ.Bruce Fields 1206ca364317SJ.Bruce Fields if (!cstate->current_fh.fh_dentry) { 120727d630ecSJ.Bruce Fields if (!(opdesc->op_flags & ALLOWED_WITHOUT_FH)) { 12081da177e4SLinus Torvalds op->status = nfserr_nofilehandle; 12091da177e4SLinus Torvalds goto encode_op; 12101da177e4SLinus Torvalds } 1211eeac294eSJ.Bruce Fields } else if (cstate->current_fh.fh_export->ex_fslocs.migrated && 1212eeac294eSJ.Bruce Fields !(opdesc->op_flags & ALLOWED_ON_ABSENT_FS)) { 121342ca0993SJ.Bruce Fields op->status = nfserr_moved; 121442ca0993SJ.Bruce Fields goto encode_op; 121542ca0993SJ.Bruce Fields } 1216b591480bSJ.Bruce Fields 121758e7b33aSMi Jinlong /* If op is non-idempotent */ 121858e7b33aSMi Jinlong if (opdesc->op_flags & OP_MODIFIES_SOMETHING) { 121958e7b33aSMi Jinlong plen = opdesc->op_rsize_bop(rqstp, op); 122058e7b33aSMi Jinlong op->status = nfsd4_check_resp_size(resp, plen); 122158e7b33aSMi Jinlong } 122258e7b33aSMi Jinlong 122358e7b33aSMi Jinlong if (op->status) 122458e7b33aSMi Jinlong goto encode_op; 122558e7b33aSMi Jinlong 1226b591480bSJ.Bruce Fields if (opdesc->op_func) 1227b591480bSJ.Bruce Fields op->status = opdesc->op_func(rqstp, cstate, &op->u); 1228b591480bSJ.Bruce Fields else 12291da177e4SLinus Torvalds BUG_ON(op->status == nfs_ok); 12301da177e4SLinus Torvalds 123168d93184SJ. Bruce Fields if (!op->status && need_wrongsec_check(rqstp)) 123268d93184SJ. Bruce Fields op->status = check_nfsd_access(cstate->current_fh.fh_export, rqstp); 123368d93184SJ. Bruce Fields 12341da177e4SLinus Torvalds encode_op: 123549557cc7SAndy Adamson /* Only from SEQUENCE */ 1236da3846a2SAndy Adamson if (resp->cstate.status == nfserr_replay_cache) { 1237da3846a2SAndy Adamson dprintk("%s NFS4.1 replay from cache\n", __func__); 1238da3846a2SAndy Adamson status = op->status; 1239da3846a2SAndy Adamson goto out; 1240da3846a2SAndy Adamson } 1241a90b061cSAl Viro if (op->status == nfserr_replay_me) { 1242a4f1706aSJ.Bruce Fields op->replay = &cstate->replay_owner->so_replay; 12431da177e4SLinus Torvalds nfsd4_encode_replay(resp, op); 12441da177e4SLinus Torvalds status = op->status = op->replay->rp_status; 12451da177e4SLinus Torvalds } else { 12461da177e4SLinus Torvalds nfsd4_encode_operation(resp, op); 12471da177e4SLinus Torvalds status = op->status; 12481da177e4SLinus Torvalds } 12490407717dSBenny Halevy 12500407717dSBenny Halevy dprintk("nfsv4 compound op %p opcnt %d #%d: %d: status %d\n", 12510407717dSBenny Halevy args->ops, args->opcnt, resp->opcnt, op->opnum, 12520407717dSBenny Halevy be32_to_cpu(status)); 12530407717dSBenny Halevy 1254a4f1706aSJ.Bruce Fields if (cstate->replay_owner) { 12555ec094c1SJ. Bruce Fields nfs4_unlock_state(); 1256a4f1706aSJ.Bruce Fields cstate->replay_owner = NULL; 12571da177e4SLinus Torvalds } 12587e06b7f9SNeilBrown /* XXX Ugh, we need to get rid of this kind of special case: */ 12597e06b7f9SNeilBrown if (op->opnum == OP_READ && op->u.read.rd_filp) 12607e06b7f9SNeilBrown fput(op->u.read.rd_filp); 1261e2b20950SShankar Anand 1262e2b20950SShankar Anand nfsd4_increment_op_stats(op->opnum); 12631da177e4SLinus Torvalds } 12641da177e4SLinus Torvalds 1265da3846a2SAndy Adamson resp->cstate.status = status; 1266e354d571SAndy Adamson fh_put(&resp->cstate.current_fh); 1267e354d571SAndy Adamson fh_put(&resp->cstate.save_fh); 1268e354d571SAndy Adamson BUG_ON(resp->cstate.replay_owner); 12691da177e4SLinus Torvalds out: 12702f425878SAndy Adamson /* Reset deferral mechanism for RPC deferrals */ 12712f425878SAndy Adamson rqstp->rq_usedeferral = 1; 12723b12cd98SJ. Bruce Fields dprintk("nfsv4 compound returned %d\n", ntohl(status)); 12731da177e4SLinus Torvalds return status; 12741da177e4SLinus Torvalds } 12751da177e4SLinus Torvalds 127658e7b33aSMi Jinlong #define op_encode_hdr_size (2) 127758e7b33aSMi Jinlong #define op_encode_stateid_maxsz (XDR_QUADLEN(NFS4_STATEID_SIZE)) 127858e7b33aSMi Jinlong #define op_encode_verifier_maxsz (XDR_QUADLEN(NFS4_VERIFIER_SIZE)) 127958e7b33aSMi Jinlong #define op_encode_change_info_maxsz (5) 128058e7b33aSMi Jinlong #define nfs4_fattr_bitmap_maxsz (4) 128158e7b33aSMi Jinlong 128258e7b33aSMi Jinlong #define op_encode_lockowner_maxsz (1 + XDR_QUADLEN(IDMAP_NAMESZ)) 128358e7b33aSMi Jinlong #define op_encode_lock_denied_maxsz (8 + op_encode_lockowner_maxsz) 128458e7b33aSMi Jinlong 128558e7b33aSMi Jinlong #define nfs4_owner_maxsz (1 + XDR_QUADLEN(IDMAP_NAMESZ)) 128658e7b33aSMi Jinlong 128758e7b33aSMi Jinlong #define op_encode_ace_maxsz (3 + nfs4_owner_maxsz) 128858e7b33aSMi Jinlong #define op_encode_delegation_maxsz (1 + op_encode_stateid_maxsz + 1 + \ 128958e7b33aSMi Jinlong op_encode_ace_maxsz) 129058e7b33aSMi Jinlong 129158e7b33aSMi Jinlong #define op_encode_channel_attrs_maxsz (6 + 1 + 1) 129258e7b33aSMi Jinlong 129358e7b33aSMi Jinlong static inline u32 nfsd4_only_status_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 129458e7b33aSMi Jinlong { 129558e7b33aSMi Jinlong return (op_encode_hdr_size) * sizeof(__be32); 129658e7b33aSMi Jinlong } 129758e7b33aSMi Jinlong 129858e7b33aSMi Jinlong static inline u32 nfsd4_status_stateid_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 129958e7b33aSMi Jinlong { 130058e7b33aSMi Jinlong return (op_encode_hdr_size + op_encode_stateid_maxsz)* sizeof(__be32); 130158e7b33aSMi Jinlong } 130258e7b33aSMi Jinlong 130358e7b33aSMi Jinlong static inline u32 nfsd4_commit_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 130458e7b33aSMi Jinlong { 130558e7b33aSMi Jinlong return (op_encode_hdr_size + op_encode_verifier_maxsz) * sizeof(__be32); 130658e7b33aSMi Jinlong } 130758e7b33aSMi Jinlong 130858e7b33aSMi Jinlong static inline u32 nfsd4_create_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 130958e7b33aSMi Jinlong { 131058e7b33aSMi Jinlong return (op_encode_hdr_size + op_encode_change_info_maxsz 131158e7b33aSMi Jinlong + nfs4_fattr_bitmap_maxsz) * sizeof(__be32); 131258e7b33aSMi Jinlong } 131358e7b33aSMi Jinlong 131458e7b33aSMi Jinlong static inline u32 nfsd4_link_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 131558e7b33aSMi Jinlong { 131658e7b33aSMi Jinlong return (op_encode_hdr_size + op_encode_change_info_maxsz) 131758e7b33aSMi Jinlong * sizeof(__be32); 131858e7b33aSMi Jinlong } 131958e7b33aSMi Jinlong 132058e7b33aSMi Jinlong static inline u32 nfsd4_lock_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 132158e7b33aSMi Jinlong { 132258e7b33aSMi Jinlong return (op_encode_hdr_size + op_encode_lock_denied_maxsz) 132358e7b33aSMi Jinlong * sizeof(__be32); 132458e7b33aSMi Jinlong } 132558e7b33aSMi Jinlong 132658e7b33aSMi Jinlong static inline u32 nfsd4_open_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 132758e7b33aSMi Jinlong { 132858e7b33aSMi Jinlong return (op_encode_hdr_size + op_encode_stateid_maxsz 132958e7b33aSMi Jinlong + op_encode_change_info_maxsz + 1 133058e7b33aSMi Jinlong + nfs4_fattr_bitmap_maxsz 133158e7b33aSMi Jinlong + op_encode_delegation_maxsz) * sizeof(__be32); 133258e7b33aSMi Jinlong } 133358e7b33aSMi Jinlong 133458e7b33aSMi Jinlong static inline u32 nfsd4_read_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 133558e7b33aSMi Jinlong { 133658e7b33aSMi Jinlong u32 maxcount = 0, rlen = 0; 133758e7b33aSMi Jinlong 133858e7b33aSMi Jinlong maxcount = svc_max_payload(rqstp); 133958e7b33aSMi Jinlong rlen = op->u.read.rd_length; 134058e7b33aSMi Jinlong 134158e7b33aSMi Jinlong if (rlen > maxcount) 134258e7b33aSMi Jinlong rlen = maxcount; 134358e7b33aSMi Jinlong 134458e7b33aSMi Jinlong return (op_encode_hdr_size + 2) * sizeof(__be32) + rlen; 134558e7b33aSMi Jinlong } 134658e7b33aSMi Jinlong 134758e7b33aSMi Jinlong static inline u32 nfsd4_readdir_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 134858e7b33aSMi Jinlong { 134958e7b33aSMi Jinlong u32 rlen = op->u.readdir.rd_maxcount; 135058e7b33aSMi Jinlong 135158e7b33aSMi Jinlong if (rlen > PAGE_SIZE) 135258e7b33aSMi Jinlong rlen = PAGE_SIZE; 135358e7b33aSMi Jinlong 135458e7b33aSMi Jinlong return (op_encode_hdr_size + op_encode_verifier_maxsz) 135558e7b33aSMi Jinlong * sizeof(__be32) + rlen; 135658e7b33aSMi Jinlong } 135758e7b33aSMi Jinlong 135858e7b33aSMi Jinlong static inline u32 nfsd4_remove_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 135958e7b33aSMi Jinlong { 136058e7b33aSMi Jinlong return (op_encode_hdr_size + op_encode_change_info_maxsz) 136158e7b33aSMi Jinlong * sizeof(__be32); 136258e7b33aSMi Jinlong } 136358e7b33aSMi Jinlong 136458e7b33aSMi Jinlong static inline u32 nfsd4_rename_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 136558e7b33aSMi Jinlong { 136658e7b33aSMi Jinlong return (op_encode_hdr_size + op_encode_change_info_maxsz 136758e7b33aSMi Jinlong + op_encode_change_info_maxsz) * sizeof(__be32); 136858e7b33aSMi Jinlong } 136958e7b33aSMi Jinlong 137058e7b33aSMi Jinlong static inline u32 nfsd4_setattr_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 137158e7b33aSMi Jinlong { 137258e7b33aSMi Jinlong return (op_encode_hdr_size + nfs4_fattr_bitmap_maxsz) * sizeof(__be32); 137358e7b33aSMi Jinlong } 137458e7b33aSMi Jinlong 137558e7b33aSMi Jinlong static inline u32 nfsd4_setclientid_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 137658e7b33aSMi Jinlong { 137758e7b33aSMi Jinlong return (op_encode_hdr_size + 2 + 1024) * sizeof(__be32); 137858e7b33aSMi Jinlong } 137958e7b33aSMi Jinlong 138058e7b33aSMi Jinlong static inline u32 nfsd4_write_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 138158e7b33aSMi Jinlong { 138258e7b33aSMi Jinlong return (op_encode_hdr_size + op_encode_verifier_maxsz) * sizeof(__be32); 138358e7b33aSMi Jinlong } 138458e7b33aSMi Jinlong 138558e7b33aSMi Jinlong static inline u32 nfsd4_exchange_id_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 138658e7b33aSMi Jinlong { 138758e7b33aSMi Jinlong return (op_encode_hdr_size + 2 + 1 + /* eir_clientid, eir_sequenceid */\ 138858e7b33aSMi Jinlong 1 + 1 + 0 + /* eir_flags, spr_how, SP4_NONE (for now) */\ 138958e7b33aSMi Jinlong 2 + /*eir_server_owner.so_minor_id */\ 139058e7b33aSMi Jinlong /* eir_server_owner.so_major_id<> */\ 139158e7b33aSMi Jinlong XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + 1 +\ 139258e7b33aSMi Jinlong /* eir_server_scope<> */\ 139358e7b33aSMi Jinlong XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + 1 +\ 139458e7b33aSMi Jinlong 1 + /* eir_server_impl_id array length */\ 139558e7b33aSMi Jinlong 0 /* ignored eir_server_impl_id contents */) * sizeof(__be32); 139658e7b33aSMi Jinlong } 139758e7b33aSMi Jinlong 139858e7b33aSMi Jinlong static inline u32 nfsd4_bind_conn_to_session_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 139958e7b33aSMi Jinlong { 140058e7b33aSMi Jinlong return (op_encode_hdr_size + \ 140158e7b33aSMi Jinlong XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + /* bctsr_sessid */\ 140258e7b33aSMi Jinlong 2 /* bctsr_dir, use_conn_in_rdma_mode */) * sizeof(__be32); 140358e7b33aSMi Jinlong } 140458e7b33aSMi Jinlong 140558e7b33aSMi Jinlong static inline u32 nfsd4_create_session_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 140658e7b33aSMi Jinlong { 140758e7b33aSMi Jinlong return (op_encode_hdr_size + \ 140858e7b33aSMi Jinlong XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + /* sessionid */\ 140958e7b33aSMi Jinlong 2 + /* csr_sequence, csr_flags */\ 141058e7b33aSMi Jinlong op_encode_channel_attrs_maxsz + \ 141158e7b33aSMi Jinlong op_encode_channel_attrs_maxsz) * sizeof(__be32); 141258e7b33aSMi Jinlong } 141358e7b33aSMi Jinlong 141420766016SBenny Halevy static struct nfsd4_operation nfsd4_ops[] = { 1415b591480bSJ.Bruce Fields [OP_ACCESS] = { 1416b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_access, 1417b001a1b6SBenny Halevy .op_name = "OP_ACCESS", 1418b591480bSJ.Bruce Fields }, 1419b591480bSJ.Bruce Fields [OP_CLOSE] = { 1420b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_close, 142158e7b33aSMi Jinlong .op_flags = OP_MODIFIES_SOMETHING, 1422b001a1b6SBenny Halevy .op_name = "OP_CLOSE", 142358e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_status_stateid_rsize, 1424b591480bSJ.Bruce Fields }, 1425b591480bSJ.Bruce Fields [OP_COMMIT] = { 1426b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_commit, 142758e7b33aSMi Jinlong .op_flags = OP_MODIFIES_SOMETHING, 1428b001a1b6SBenny Halevy .op_name = "OP_COMMIT", 142958e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_commit_rsize, 1430b591480bSJ.Bruce Fields }, 1431b591480bSJ.Bruce Fields [OP_CREATE] = { 1432b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_create, 1433c856694eSJ. Bruce Fields .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME, 1434b001a1b6SBenny Halevy .op_name = "OP_CREATE", 143558e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_create_rsize, 1436b591480bSJ.Bruce Fields }, 1437b591480bSJ.Bruce Fields [OP_DELEGRETURN] = { 1438b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_delegreturn, 143958e7b33aSMi Jinlong .op_flags = OP_MODIFIES_SOMETHING, 1440b001a1b6SBenny Halevy .op_name = "OP_DELEGRETURN", 144158e7b33aSMi Jinlong .op_rsize_bop = nfsd4_only_status_rsize, 1442b591480bSJ.Bruce Fields }, 1443b591480bSJ.Bruce Fields [OP_GETATTR] = { 1444b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_getattr, 1445eeac294eSJ.Bruce Fields .op_flags = ALLOWED_ON_ABSENT_FS, 1446b001a1b6SBenny Halevy .op_name = "OP_GETATTR", 1447b591480bSJ.Bruce Fields }, 1448b591480bSJ.Bruce Fields [OP_GETFH] = { 1449b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_getfh, 1450b001a1b6SBenny Halevy .op_name = "OP_GETFH", 1451b591480bSJ.Bruce Fields }, 1452b591480bSJ.Bruce Fields [OP_LINK] = { 1453b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_link, 1454c856694eSJ. Bruce Fields .op_flags = ALLOWED_ON_ABSENT_FS | OP_MODIFIES_SOMETHING 1455c856694eSJ. Bruce Fields | OP_CACHEME, 1456b001a1b6SBenny Halevy .op_name = "OP_LINK", 145758e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_link_rsize, 1458b591480bSJ.Bruce Fields }, 1459b591480bSJ.Bruce Fields [OP_LOCK] = { 1460b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_lock, 146158e7b33aSMi Jinlong .op_flags = OP_MODIFIES_SOMETHING, 1462b001a1b6SBenny Halevy .op_name = "OP_LOCK", 146358e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_lock_rsize, 1464b591480bSJ.Bruce Fields }, 1465b591480bSJ.Bruce Fields [OP_LOCKT] = { 1466b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_lockt, 1467b001a1b6SBenny Halevy .op_name = "OP_LOCKT", 1468b591480bSJ.Bruce Fields }, 1469b591480bSJ.Bruce Fields [OP_LOCKU] = { 1470b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_locku, 147158e7b33aSMi Jinlong .op_flags = OP_MODIFIES_SOMETHING, 1472b001a1b6SBenny Halevy .op_name = "OP_LOCKU", 147358e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_status_stateid_rsize, 1474b591480bSJ.Bruce Fields }, 1475b591480bSJ.Bruce Fields [OP_LOOKUP] = { 1476b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_lookup, 147768d93184SJ. Bruce Fields .op_flags = OP_HANDLES_WRONGSEC, 1478b001a1b6SBenny Halevy .op_name = "OP_LOOKUP", 1479b591480bSJ.Bruce Fields }, 1480b591480bSJ.Bruce Fields [OP_LOOKUPP] = { 1481b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_lookupp, 148268d93184SJ. Bruce Fields .op_flags = OP_HANDLES_WRONGSEC, 1483b001a1b6SBenny Halevy .op_name = "OP_LOOKUPP", 1484b591480bSJ.Bruce Fields }, 1485b591480bSJ.Bruce Fields [OP_NVERIFY] = { 1486b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_nverify, 1487b001a1b6SBenny Halevy .op_name = "OP_NVERIFY", 1488b591480bSJ.Bruce Fields }, 1489b591480bSJ.Bruce Fields [OP_OPEN] = { 1490b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_open, 149158e7b33aSMi Jinlong .op_flags = OP_HANDLES_WRONGSEC | OP_MODIFIES_SOMETHING, 1492b001a1b6SBenny Halevy .op_name = "OP_OPEN", 149358e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_open_rsize, 1494b591480bSJ.Bruce Fields }, 1495b591480bSJ.Bruce Fields [OP_OPEN_CONFIRM] = { 1496b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_open_confirm, 149758e7b33aSMi Jinlong .op_flags = OP_MODIFIES_SOMETHING, 1498b001a1b6SBenny Halevy .op_name = "OP_OPEN_CONFIRM", 149958e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_status_stateid_rsize, 1500b591480bSJ.Bruce Fields }, 1501b591480bSJ.Bruce Fields [OP_OPEN_DOWNGRADE] = { 1502b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_open_downgrade, 150358e7b33aSMi Jinlong .op_flags = OP_MODIFIES_SOMETHING, 1504b001a1b6SBenny Halevy .op_name = "OP_OPEN_DOWNGRADE", 150558e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_status_stateid_rsize, 1506b591480bSJ.Bruce Fields }, 1507b591480bSJ.Bruce Fields [OP_PUTFH] = { 1508b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_putfh, 150968d93184SJ. Bruce Fields .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS 151058e7b33aSMi Jinlong | OP_IS_PUTFH_LIKE | OP_MODIFIES_SOMETHING, 1511b001a1b6SBenny Halevy .op_name = "OP_PUTFH", 151258e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize, 1513b591480bSJ.Bruce Fields }, 1514eeac294eSJ.Bruce Fields [OP_PUTPUBFH] = { 1515a1c8c4d1SJ. Bruce Fields .op_func = (nfsd4op_func)nfsd4_putrootfh, 151668d93184SJ. Bruce Fields .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS 151758e7b33aSMi Jinlong | OP_IS_PUTFH_LIKE | OP_MODIFIES_SOMETHING, 1518b001a1b6SBenny Halevy .op_name = "OP_PUTPUBFH", 151958e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize, 1520eeac294eSJ.Bruce Fields }, 1521b591480bSJ.Bruce Fields [OP_PUTROOTFH] = { 1522b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_putrootfh, 152368d93184SJ. Bruce Fields .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS 152458e7b33aSMi Jinlong | OP_IS_PUTFH_LIKE | OP_MODIFIES_SOMETHING, 1525b001a1b6SBenny Halevy .op_name = "OP_PUTROOTFH", 152658e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize, 1527b591480bSJ.Bruce Fields }, 1528b591480bSJ.Bruce Fields [OP_READ] = { 1529b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_read, 153058e7b33aSMi Jinlong .op_flags = OP_MODIFIES_SOMETHING, 1531b001a1b6SBenny Halevy .op_name = "OP_READ", 153258e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_read_rsize, 1533b591480bSJ.Bruce Fields }, 1534b591480bSJ.Bruce Fields [OP_READDIR] = { 1535b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_readdir, 153658e7b33aSMi Jinlong .op_flags = OP_MODIFIES_SOMETHING, 1537b001a1b6SBenny Halevy .op_name = "OP_READDIR", 153858e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_readdir_rsize, 1539b591480bSJ.Bruce Fields }, 1540b591480bSJ.Bruce Fields [OP_READLINK] = { 1541b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_readlink, 1542b001a1b6SBenny Halevy .op_name = "OP_READLINK", 1543b591480bSJ.Bruce Fields }, 1544b591480bSJ.Bruce Fields [OP_REMOVE] = { 1545b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_remove, 1546c856694eSJ. Bruce Fields .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME, 1547b001a1b6SBenny Halevy .op_name = "OP_REMOVE", 154858e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_remove_rsize, 1549b591480bSJ.Bruce Fields }, 1550b591480bSJ.Bruce Fields [OP_RENAME] = { 1551b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_rename, 1552c856694eSJ. Bruce Fields .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME, 155358e7b33aSMi Jinlong .op_name = "OP_RENAME", 155458e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_rename_rsize, 1555b591480bSJ.Bruce Fields }, 1556b591480bSJ.Bruce Fields [OP_RENEW] = { 1557b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_renew, 155858e7b33aSMi Jinlong .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS 155958e7b33aSMi Jinlong | OP_MODIFIES_SOMETHING, 1560b001a1b6SBenny Halevy .op_name = "OP_RENEW", 156158e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize, 156258e7b33aSMi Jinlong 1563b591480bSJ.Bruce Fields }, 1564b591480bSJ.Bruce Fields [OP_RESTOREFH] = { 1565b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_restorefh, 156668d93184SJ. Bruce Fields .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS 156758e7b33aSMi Jinlong | OP_IS_PUTFH_LIKE | OP_MODIFIES_SOMETHING, 1568b001a1b6SBenny Halevy .op_name = "OP_RESTOREFH", 156958e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize, 1570b591480bSJ.Bruce Fields }, 1571b591480bSJ.Bruce Fields [OP_SAVEFH] = { 1572b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_savefh, 157358e7b33aSMi Jinlong .op_flags = OP_HANDLES_WRONGSEC | OP_MODIFIES_SOMETHING, 1574b001a1b6SBenny Halevy .op_name = "OP_SAVEFH", 157558e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize, 1576b591480bSJ.Bruce Fields }, 1577dcb488a3SAndy Adamson [OP_SECINFO] = { 1578dcb488a3SAndy Adamson .op_func = (nfsd4op_func)nfsd4_secinfo, 157968d93184SJ. Bruce Fields .op_flags = OP_HANDLES_WRONGSEC, 1580b001a1b6SBenny Halevy .op_name = "OP_SECINFO", 1581dcb488a3SAndy Adamson }, 1582b591480bSJ.Bruce Fields [OP_SETATTR] = { 1583b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_setattr, 1584b001a1b6SBenny Halevy .op_name = "OP_SETATTR", 1585c856694eSJ. Bruce Fields .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME, 158658e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_setattr_rsize, 1587b591480bSJ.Bruce Fields }, 1588b591480bSJ.Bruce Fields [OP_SETCLIENTID] = { 1589b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_setclientid, 159058e7b33aSMi Jinlong .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS 1591c856694eSJ. Bruce Fields | OP_MODIFIES_SOMETHING | OP_CACHEME, 1592b001a1b6SBenny Halevy .op_name = "OP_SETCLIENTID", 159358e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_setclientid_rsize, 1594b591480bSJ.Bruce Fields }, 1595b591480bSJ.Bruce Fields [OP_SETCLIENTID_CONFIRM] = { 1596b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_setclientid_confirm, 159758e7b33aSMi Jinlong .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS 1598c856694eSJ. Bruce Fields | OP_MODIFIES_SOMETHING | OP_CACHEME, 1599b001a1b6SBenny Halevy .op_name = "OP_SETCLIENTID_CONFIRM", 160058e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize, 1601b591480bSJ.Bruce Fields }, 1602b591480bSJ.Bruce Fields [OP_VERIFY] = { 1603b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_verify, 1604b001a1b6SBenny Halevy .op_name = "OP_VERIFY", 1605b591480bSJ.Bruce Fields }, 1606b591480bSJ.Bruce Fields [OP_WRITE] = { 1607b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_write, 1608c856694eSJ. Bruce Fields .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME, 1609b001a1b6SBenny Halevy .op_name = "OP_WRITE", 161058e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_write_rsize, 1611b591480bSJ.Bruce Fields }, 1612b591480bSJ.Bruce Fields [OP_RELEASE_LOCKOWNER] = { 1613b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_release_lockowner, 161458e7b33aSMi Jinlong .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS 161558e7b33aSMi Jinlong | OP_MODIFIES_SOMETHING, 1616b001a1b6SBenny Halevy .op_name = "OP_RELEASE_LOCKOWNER", 161758e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize, 1618b591480bSJ.Bruce Fields }, 1619069b6ad4SAndy Adamson 1620069b6ad4SAndy Adamson /* NFSv4.1 operations */ 1621069b6ad4SAndy Adamson [OP_EXCHANGE_ID] = { 1622069b6ad4SAndy Adamson .op_func = (nfsd4op_func)nfsd4_exchange_id, 162358e7b33aSMi Jinlong .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP 162458e7b33aSMi Jinlong | OP_MODIFIES_SOMETHING, 1625069b6ad4SAndy Adamson .op_name = "OP_EXCHANGE_ID", 162658e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_exchange_id_rsize, 1627069b6ad4SAndy Adamson }, 16281d1bc8f2SJ. Bruce Fields [OP_BIND_CONN_TO_SESSION] = { 16291d1bc8f2SJ. Bruce Fields .op_func = (nfsd4op_func)nfsd4_bind_conn_to_session, 163058e7b33aSMi Jinlong .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP 163158e7b33aSMi Jinlong | OP_MODIFIES_SOMETHING, 16321d1bc8f2SJ. Bruce Fields .op_name = "OP_BIND_CONN_TO_SESSION", 163358e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_bind_conn_to_session_rsize, 16341d1bc8f2SJ. Bruce Fields }, 1635069b6ad4SAndy Adamson [OP_CREATE_SESSION] = { 1636069b6ad4SAndy Adamson .op_func = (nfsd4op_func)nfsd4_create_session, 163758e7b33aSMi Jinlong .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP 163858e7b33aSMi Jinlong | OP_MODIFIES_SOMETHING, 1639069b6ad4SAndy Adamson .op_name = "OP_CREATE_SESSION", 164058e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_create_session_rsize, 1641069b6ad4SAndy Adamson }, 1642069b6ad4SAndy Adamson [OP_DESTROY_SESSION] = { 1643069b6ad4SAndy Adamson .op_func = (nfsd4op_func)nfsd4_destroy_session, 164458e7b33aSMi Jinlong .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP 164558e7b33aSMi Jinlong | OP_MODIFIES_SOMETHING, 1646069b6ad4SAndy Adamson .op_name = "OP_DESTROY_SESSION", 164758e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize, 1648069b6ad4SAndy Adamson }, 1649069b6ad4SAndy Adamson [OP_SEQUENCE] = { 1650069b6ad4SAndy Adamson .op_func = (nfsd4op_func)nfsd4_sequence, 1651f9bb94c4SAndy Adamson .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP, 1652069b6ad4SAndy Adamson .op_name = "OP_SEQUENCE", 1653069b6ad4SAndy Adamson }, 1654094b5d74SBenny Halevy [OP_DESTROY_CLIENTID] = { 1655094b5d74SBenny Halevy .op_func = NULL, 165658e7b33aSMi Jinlong .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP 165758e7b33aSMi Jinlong | OP_MODIFIES_SOMETHING, 1658094b5d74SBenny Halevy .op_name = "OP_DESTROY_CLIENTID", 165958e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize, 1660094b5d74SBenny Halevy }, 16614dc6ec00SJ. Bruce Fields [OP_RECLAIM_COMPLETE] = { 16624dc6ec00SJ. Bruce Fields .op_func = (nfsd4op_func)nfsd4_reclaim_complete, 166358e7b33aSMi Jinlong .op_flags = ALLOWED_WITHOUT_FH | OP_MODIFIES_SOMETHING, 16644dc6ec00SJ. Bruce Fields .op_name = "OP_RECLAIM_COMPLETE", 166558e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize, 16664dc6ec00SJ. Bruce Fields }, 166704f4ad16SJ. Bruce Fields [OP_SECINFO_NO_NAME] = { 166804f4ad16SJ. Bruce Fields .op_func = (nfsd4op_func)nfsd4_secinfo_no_name, 166968d93184SJ. Bruce Fields .op_flags = OP_HANDLES_WRONGSEC, 167004f4ad16SJ. Bruce Fields .op_name = "OP_SECINFO_NO_NAME", 167104f4ad16SJ. Bruce Fields }, 167217456804SBryan Schumaker [OP_TEST_STATEID] = { 167317456804SBryan Schumaker .op_func = (nfsd4op_func)nfsd4_test_stateid, 167417456804SBryan Schumaker .op_flags = ALLOWED_WITHOUT_FH, 167517456804SBryan Schumaker .op_name = "OP_TEST_STATEID", 167617456804SBryan Schumaker }, 1677e1ca12dfSBryan Schumaker [OP_FREE_STATEID] = { 1678e1ca12dfSBryan Schumaker .op_func = (nfsd4op_func)nfsd4_free_stateid, 167958e7b33aSMi Jinlong .op_flags = ALLOWED_WITHOUT_FH | OP_MODIFIES_SOMETHING, 1680e1ca12dfSBryan Schumaker .op_name = "OP_FREE_STATEID", 168158e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize, 1682e1ca12dfSBryan Schumaker }, 1683b591480bSJ.Bruce Fields }; 1684b591480bSJ.Bruce Fields 1685f1c7f79bSAdrian Bunk static const char *nfsd4_op_name(unsigned opnum) 1686b001a1b6SBenny Halevy { 1687b001a1b6SBenny Halevy if (opnum < ARRAY_SIZE(nfsd4_ops)) 1688b001a1b6SBenny Halevy return nfsd4_ops[opnum].op_name; 1689b001a1b6SBenny Halevy return "unknown_operation"; 1690b001a1b6SBenny Halevy } 1691b001a1b6SBenny Halevy 16921da177e4SLinus Torvalds #define nfsd4_voidres nfsd4_voidargs 16931da177e4SLinus Torvalds struct nfsd4_voidargs { int dummy; }; 16941da177e4SLinus Torvalds 16951da177e4SLinus Torvalds static struct svc_procedure nfsd_procedures4[2] = { 16960a93a47fSYu Zhiguo [NFSPROC4_NULL] = { 16970a93a47fSYu Zhiguo .pc_func = (svc_procfunc) nfsd4_proc_null, 16980a93a47fSYu Zhiguo .pc_encode = (kxdrproc_t) nfs4svc_encode_voidres, 16990a93a47fSYu Zhiguo .pc_argsize = sizeof(struct nfsd4_voidargs), 17000a93a47fSYu Zhiguo .pc_ressize = sizeof(struct nfsd4_voidres), 17010a93a47fSYu Zhiguo .pc_cachetype = RC_NOCACHE, 17020a93a47fSYu Zhiguo .pc_xdrressize = 1, 17030a93a47fSYu Zhiguo }, 17040a93a47fSYu Zhiguo [NFSPROC4_COMPOUND] = { 17050a93a47fSYu Zhiguo .pc_func = (svc_procfunc) nfsd4_proc_compound, 17060a93a47fSYu Zhiguo .pc_decode = (kxdrproc_t) nfs4svc_decode_compoundargs, 17070a93a47fSYu Zhiguo .pc_encode = (kxdrproc_t) nfs4svc_encode_compoundres, 17080a93a47fSYu Zhiguo .pc_argsize = sizeof(struct nfsd4_compoundargs), 17090a93a47fSYu Zhiguo .pc_ressize = sizeof(struct nfsd4_compoundres), 17103e98abffSJ. Bruce Fields .pc_release = nfsd4_release_compoundargs, 17110a93a47fSYu Zhiguo .pc_cachetype = RC_NOCACHE, 17120a93a47fSYu Zhiguo .pc_xdrressize = NFSD_BUFSIZE/4, 17130a93a47fSYu Zhiguo }, 17141da177e4SLinus Torvalds }; 17151da177e4SLinus Torvalds 17161da177e4SLinus Torvalds struct svc_version nfsd_version4 = { 17171da177e4SLinus Torvalds .vs_vers = 4, 17181da177e4SLinus Torvalds .vs_nproc = 2, 17191da177e4SLinus Torvalds .vs_proc = nfsd_procedures4, 17201da177e4SLinus Torvalds .vs_dispatch = nfsd_dispatch, 17211da177e4SLinus Torvalds .vs_xdrsize = NFS4_SVC_XDRSIZE, 17221da177e4SLinus Torvalds }; 17231da177e4SLinus Torvalds 17241da177e4SLinus Torvalds /* 17251da177e4SLinus Torvalds * Local variables: 17261da177e4SLinus Torvalds * c-basic-offset: 8 17271da177e4SLinus Torvalds * End: 17281da177e4SLinus Torvalds */ 1729