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; 1971da177e4SLinus Torvalds 1981da177e4SLinus Torvalds fh_init(&resfh, NFS4_FHSIZE); 1991da177e4SLinus Torvalds open->op_truncate = 0; 2001da177e4SLinus Torvalds 2011da177e4SLinus Torvalds if (open->op_create) { 20279fb54abSBenny Halevy /* FIXME: check session persistence and pnfs flags. 20379fb54abSBenny Halevy * The nfsv4.1 spec requires the following semantics: 20479fb54abSBenny Halevy * 20579fb54abSBenny Halevy * Persistent | pNFS | Server REQUIRED | Client Allowed 20679fb54abSBenny Halevy * Reply Cache | server | | 20779fb54abSBenny Halevy * -------------+--------+-----------------+-------------------- 20879fb54abSBenny Halevy * no | no | EXCLUSIVE4_1 | EXCLUSIVE4_1 20979fb54abSBenny Halevy * | | | (SHOULD) 21079fb54abSBenny Halevy * | | and EXCLUSIVE4 | or EXCLUSIVE4 21179fb54abSBenny Halevy * | | | (SHOULD NOT) 21279fb54abSBenny Halevy * no | yes | EXCLUSIVE4_1 | EXCLUSIVE4_1 21379fb54abSBenny Halevy * yes | no | GUARDED4 | GUARDED4 21479fb54abSBenny Halevy * yes | yes | GUARDED4 | GUARDED4 21579fb54abSBenny Halevy */ 21679fb54abSBenny Halevy 2171da177e4SLinus Torvalds /* 2181da177e4SLinus Torvalds * Note: create modes (UNCHECKED,GUARDED...) are the same 219ac6721a1SMi Jinlong * in NFSv4 as in v3 except EXCLUSIVE4_1. 2201da177e4SLinus Torvalds */ 221ac6721a1SMi Jinlong status = do_nfsd_create(rqstp, current_fh, open->op_fname.data, 2221da177e4SLinus Torvalds open->op_fname.len, &open->op_iattr, 2231da177e4SLinus Torvalds &resfh, open->op_createmode, 224749997e5SJeff Layton (u32 *)open->op_verf.data, 225856121b2SJ. Bruce Fields &open->op_truncate, &open->op_created); 226749997e5SJeff Layton 22799f88726SJ. Bruce Fields /* 22899f88726SJ. Bruce Fields * Following rfc 3530 14.2.16, use the returned bitmask 22999f88726SJ. Bruce Fields * to indicate which attributes we used to store the 23099f88726SJ. Bruce Fields * verifier: 231749997e5SJeff Layton */ 232749997e5SJeff Layton if (open->op_createmode == NFS4_CREATE_EXCLUSIVE && status == 0) 23399f88726SJ. Bruce Fields open->op_bmval[1] = (FATTR4_WORD1_TIME_ACCESS | 234749997e5SJeff Layton FATTR4_WORD1_TIME_MODIFY); 235af85852dSJ. Bruce Fields } else { 2361da177e4SLinus Torvalds status = nfsd_lookup(rqstp, current_fh, 2371da177e4SLinus Torvalds open->op_fname.data, open->op_fname.len, &resfh); 2381da177e4SLinus Torvalds fh_unlock(current_fh); 239aadab6c6SJ. Bruce Fields if (status) 240aadab6c6SJ. Bruce Fields goto out; 241aadab6c6SJ. Bruce Fields status = nfsd_check_obj_isreg(&resfh); 2421da177e4SLinus Torvalds } 243af85852dSJ. Bruce Fields if (status) 244af85852dSJ. Bruce Fields goto out; 2451da177e4SLinus Torvalds 2469208faf2SYu Zhiguo if (is_create_with_attrs(open) && open->op_acl != NULL) 2479208faf2SYu Zhiguo do_set_nfs4_acl(rqstp, &resfh, open->op_acl, open->op_bmval); 2489208faf2SYu Zhiguo 2491da177e4SLinus Torvalds set_change_info(&open->op_cinfo, current_fh); 25013024b7bSJ. Bruce Fields fh_dup2(current_fh, &resfh); 2511da177e4SLinus Torvalds 2521da177e4SLinus Torvalds /* set reply cache */ 253fe0750e5SJ. Bruce Fields fh_copy_shallow(&open->op_openowner->oo_owner.so_replay.rp_openfh, 254a4773c08SJ. Bruce Fields &resfh.fh_handle); 255856121b2SJ. Bruce Fields if (!open->op_created) 2568837abcaSMiklos Szeredi status = do_open_permission(rqstp, current_fh, open, 2578837abcaSMiklos Szeredi NFSD_MAY_NOP); 2581da177e4SLinus Torvalds 259af85852dSJ. Bruce Fields out: 2601da177e4SLinus Torvalds fh_put(&resfh); 2611da177e4SLinus Torvalds return status; 2621da177e4SLinus Torvalds } 2631da177e4SLinus Torvalds 264b37ad28bSAl Viro static __be32 2651da177e4SLinus Torvalds do_open_fhandle(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open) 2661da177e4SLinus Torvalds { 267b37ad28bSAl Viro __be32 status; 2681da177e4SLinus Torvalds 2691da177e4SLinus Torvalds /* Only reclaims from previously confirmed clients are valid */ 2701da177e4SLinus Torvalds if ((status = nfs4_check_open_reclaim(&open->op_clientid))) 2711da177e4SLinus Torvalds return status; 2721da177e4SLinus Torvalds 2731da177e4SLinus Torvalds /* We don't know the target directory, and therefore can not 2741da177e4SLinus Torvalds * set the change info 2751da177e4SLinus Torvalds */ 2761da177e4SLinus Torvalds 2771da177e4SLinus Torvalds memset(&open->op_cinfo, 0, sizeof(struct nfsd4_change_info)); 2781da177e4SLinus Torvalds 2791da177e4SLinus Torvalds /* set replay cache */ 280fe0750e5SJ. Bruce Fields fh_copy_shallow(&open->op_openowner->oo_owner.so_replay.rp_openfh, 281a4773c08SJ. Bruce Fields ¤t_fh->fh_handle); 2821da177e4SLinus Torvalds 2831da177e4SLinus Torvalds open->op_truncate = (open->op_iattr.ia_valid & ATTR_SIZE) && 2841da177e4SLinus Torvalds (open->op_iattr.ia_size == 0); 2851da177e4SLinus Torvalds 2868837abcaSMiklos Szeredi status = do_open_permission(rqstp, current_fh, open, 2878837abcaSMiklos Szeredi NFSD_MAY_OWNER_OVERRIDE); 2881da177e4SLinus Torvalds 2891da177e4SLinus Torvalds return status; 2901da177e4SLinus Torvalds } 2911da177e4SLinus Torvalds 29260adfc50SAndy Adamson static void 29360adfc50SAndy Adamson copy_clientid(clientid_t *clid, struct nfsd4_session *session) 29460adfc50SAndy Adamson { 29560adfc50SAndy Adamson struct nfsd4_sessionid *sid = 29660adfc50SAndy Adamson (struct nfsd4_sessionid *)session->se_sessionid.data; 29760adfc50SAndy Adamson 29860adfc50SAndy Adamson clid->cl_boot = sid->clientid.cl_boot; 29960adfc50SAndy Adamson clid->cl_id = sid->clientid.cl_id; 30060adfc50SAndy Adamson } 3011da177e4SLinus Torvalds 3027191155bSJ.Bruce Fields static __be32 303ca364317SJ.Bruce Fields nfsd4_open(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 304a4f1706aSJ.Bruce Fields struct nfsd4_open *open) 3051da177e4SLinus Torvalds { 306b37ad28bSAl Viro __be32 status; 3076668958fSAndy Adamson struct nfsd4_compoundres *resp; 3086668958fSAndy Adamson 309fe0750e5SJ. Bruce Fields dprintk("NFSD: nfsd4_open filename %.*s op_openowner %p\n", 3101da177e4SLinus Torvalds (int)open->op_fname.len, open->op_fname.data, 311fe0750e5SJ. Bruce Fields open->op_openowner); 3121da177e4SLinus Torvalds 3131da177e4SLinus Torvalds /* This check required by spec. */ 3141da177e4SLinus Torvalds if (open->op_create && open->op_claim_type != NFS4_OPEN_CLAIM_NULL) 3151da177e4SLinus Torvalds return nfserr_inval; 3161da177e4SLinus Torvalds 317b6d2f1caSJ. Bruce Fields /* We don't yet support WANT bits: */ 318b6d2f1caSJ. Bruce Fields open->op_share_access &= NFS4_SHARE_ACCESS_MASK; 319b6d2f1caSJ. Bruce Fields 320856121b2SJ. Bruce Fields open->op_created = 0; 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); 411856121b2SJ. Bruce Fields WARN_ON(status && open->op_created); 4121da177e4SLinus Torvalds out: 413d29b20cdSJ. Bruce Fields nfsd4_cleanup_open_state(open, status); 414fe0750e5SJ. Bruce Fields if (open->op_openowner) 415fe0750e5SJ. Bruce Fields cstate->replay_owner = &open->op_openowner->oo_owner; 4167c13f344SJ. Bruce Fields else 4171da177e4SLinus Torvalds nfs4_unlock_state(); 4181da177e4SLinus Torvalds return status; 4191da177e4SLinus Torvalds } 4201da177e4SLinus Torvalds 4211da177e4SLinus Torvalds /* 4221da177e4SLinus Torvalds * filehandle-manipulating ops. 4231da177e4SLinus Torvalds */ 4247191155bSJ.Bruce Fields static __be32 425b591480bSJ.Bruce Fields nfsd4_getfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 426b591480bSJ.Bruce Fields struct svc_fh **getfh) 4271da177e4SLinus Torvalds { 428ca364317SJ.Bruce Fields if (!cstate->current_fh.fh_dentry) 4291da177e4SLinus Torvalds return nfserr_nofilehandle; 4301da177e4SLinus Torvalds 431ca364317SJ.Bruce Fields *getfh = &cstate->current_fh; 4321da177e4SLinus Torvalds return nfs_ok; 4331da177e4SLinus Torvalds } 4341da177e4SLinus Torvalds 4357191155bSJ.Bruce Fields static __be32 436ca364317SJ.Bruce Fields nfsd4_putfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 437ca364317SJ.Bruce Fields struct nfsd4_putfh *putfh) 4381da177e4SLinus Torvalds { 439ca364317SJ.Bruce Fields fh_put(&cstate->current_fh); 440ca364317SJ.Bruce Fields cstate->current_fh.fh_handle.fh_size = putfh->pf_fhlen; 441ca364317SJ.Bruce Fields memcpy(&cstate->current_fh.fh_handle.fh_base, putfh->pf_fhval, 442ca364317SJ.Bruce Fields putfh->pf_fhlen); 44368d93184SJ. Bruce Fields return fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_BYPASS_GSS); 4441da177e4SLinus Torvalds } 4451da177e4SLinus Torvalds 4467191155bSJ.Bruce Fields static __be32 447b591480bSJ.Bruce Fields nfsd4_putrootfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 448b591480bSJ.Bruce Fields void *arg) 4491da177e4SLinus Torvalds { 450b37ad28bSAl Viro __be32 status; 4511da177e4SLinus Torvalds 452ca364317SJ.Bruce Fields fh_put(&cstate->current_fh); 453df547efbSJ. Bruce Fields status = exp_pseudoroot(rqstp, &cstate->current_fh); 4541da177e4SLinus Torvalds return status; 4551da177e4SLinus Torvalds } 4561da177e4SLinus Torvalds 4577191155bSJ.Bruce Fields static __be32 458b591480bSJ.Bruce Fields nfsd4_restorefh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 459b591480bSJ.Bruce Fields void *arg) 4601da177e4SLinus Torvalds { 461ca364317SJ.Bruce Fields if (!cstate->save_fh.fh_dentry) 4621da177e4SLinus Torvalds return nfserr_restorefh; 4631da177e4SLinus Torvalds 464ca364317SJ.Bruce Fields fh_dup2(&cstate->current_fh, &cstate->save_fh); 4651da177e4SLinus Torvalds return nfs_ok; 4661da177e4SLinus Torvalds } 4671da177e4SLinus Torvalds 4687191155bSJ.Bruce Fields static __be32 469b591480bSJ.Bruce Fields nfsd4_savefh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 470b591480bSJ.Bruce Fields void *arg) 4711da177e4SLinus Torvalds { 472ca364317SJ.Bruce Fields if (!cstate->current_fh.fh_dentry) 4731da177e4SLinus Torvalds return nfserr_nofilehandle; 4741da177e4SLinus Torvalds 475ca364317SJ.Bruce Fields fh_dup2(&cstate->save_fh, &cstate->current_fh); 4761da177e4SLinus Torvalds return nfs_ok; 4771da177e4SLinus Torvalds } 4781da177e4SLinus Torvalds 4791da177e4SLinus Torvalds /* 4801da177e4SLinus Torvalds * misc nfsv4 ops 4811da177e4SLinus Torvalds */ 4827191155bSJ.Bruce Fields static __be32 483ca364317SJ.Bruce Fields nfsd4_access(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 484ca364317SJ.Bruce Fields struct nfsd4_access *access) 4851da177e4SLinus Torvalds { 4861da177e4SLinus Torvalds if (access->ac_req_access & ~NFS3_ACCESS_FULL) 4871da177e4SLinus Torvalds return nfserr_inval; 4881da177e4SLinus Torvalds 4891da177e4SLinus Torvalds access->ac_resp_access = access->ac_req_access; 490ca364317SJ.Bruce Fields return nfsd_access(rqstp, &cstate->current_fh, &access->ac_resp_access, 491ca364317SJ.Bruce Fields &access->ac_supported); 4921da177e4SLinus Torvalds } 4931da177e4SLinus Torvalds 4947191155bSJ.Bruce Fields static __be32 495ca364317SJ.Bruce Fields nfsd4_commit(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 496ca364317SJ.Bruce Fields struct nfsd4_commit *commit) 4971da177e4SLinus Torvalds { 4981da177e4SLinus Torvalds u32 *p = (u32 *)commit->co_verf.data; 4991da177e4SLinus Torvalds *p++ = nfssvc_boot.tv_sec; 5001da177e4SLinus Torvalds *p++ = nfssvc_boot.tv_usec; 5011da177e4SLinus Torvalds 50275c096f7SJ. Bruce Fields return nfsd_commit(rqstp, &cstate->current_fh, commit->co_offset, 503ca364317SJ.Bruce Fields commit->co_count); 5041da177e4SLinus Torvalds } 5051da177e4SLinus Torvalds 506b37ad28bSAl Viro static __be32 507ca364317SJ.Bruce Fields nfsd4_create(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 508ca364317SJ.Bruce Fields struct nfsd4_create *create) 5091da177e4SLinus Torvalds { 5101da177e4SLinus Torvalds struct svc_fh resfh; 511b37ad28bSAl Viro __be32 status; 5121da177e4SLinus Torvalds dev_t rdev; 5131da177e4SLinus Torvalds 5141da177e4SLinus Torvalds fh_init(&resfh, NFS4_FHSIZE); 5151da177e4SLinus Torvalds 5168837abcaSMiklos Szeredi status = fh_verify(rqstp, &cstate->current_fh, S_IFDIR, 5178837abcaSMiklos Szeredi NFSD_MAY_CREATE); 5181da177e4SLinus Torvalds if (status) 5191da177e4SLinus Torvalds return status; 5201da177e4SLinus Torvalds 5213c8e0316SYu Zhiguo status = check_attr_support(rqstp, cstate, create->cr_bmval, 5223c8e0316SYu Zhiguo nfsd_attrmask); 5233c8e0316SYu Zhiguo if (status) 5243c8e0316SYu Zhiguo return status; 5253c8e0316SYu Zhiguo 5261da177e4SLinus Torvalds switch (create->cr_type) { 5271da177e4SLinus Torvalds case NF4LNK: 5281da177e4SLinus Torvalds /* ugh! we have to null-terminate the linktext, or 5291da177e4SLinus Torvalds * vfs_symlink() will choke. it is always safe to 5301da177e4SLinus Torvalds * null-terminate by brute force, since at worst we 5311da177e4SLinus Torvalds * will overwrite the first byte of the create namelen 5321da177e4SLinus Torvalds * in the XDR buffer, which has already been extracted 5331da177e4SLinus Torvalds * during XDR decode. 5341da177e4SLinus Torvalds */ 5351da177e4SLinus Torvalds create->cr_linkname[create->cr_linklen] = 0; 5361da177e4SLinus Torvalds 537ca364317SJ.Bruce Fields status = nfsd_symlink(rqstp, &cstate->current_fh, 538ca364317SJ.Bruce Fields create->cr_name, create->cr_namelen, 539ca364317SJ.Bruce Fields create->cr_linkname, create->cr_linklen, 540ca364317SJ.Bruce Fields &resfh, &create->cr_iattr); 5411da177e4SLinus Torvalds break; 5421da177e4SLinus Torvalds 5431da177e4SLinus Torvalds case NF4BLK: 5441da177e4SLinus Torvalds rdev = MKDEV(create->cr_specdata1, create->cr_specdata2); 5451da177e4SLinus Torvalds if (MAJOR(rdev) != create->cr_specdata1 || 5461da177e4SLinus Torvalds MINOR(rdev) != create->cr_specdata2) 5471da177e4SLinus Torvalds return nfserr_inval; 548ca364317SJ.Bruce Fields status = nfsd_create(rqstp, &cstate->current_fh, 549ca364317SJ.Bruce Fields create->cr_name, create->cr_namelen, 550ca364317SJ.Bruce Fields &create->cr_iattr, S_IFBLK, rdev, &resfh); 5511da177e4SLinus Torvalds break; 5521da177e4SLinus Torvalds 5531da177e4SLinus Torvalds case NF4CHR: 5541da177e4SLinus Torvalds rdev = MKDEV(create->cr_specdata1, create->cr_specdata2); 5551da177e4SLinus Torvalds if (MAJOR(rdev) != create->cr_specdata1 || 5561da177e4SLinus Torvalds MINOR(rdev) != create->cr_specdata2) 5571da177e4SLinus Torvalds return nfserr_inval; 558ca364317SJ.Bruce Fields status = nfsd_create(rqstp, &cstate->current_fh, 559ca364317SJ.Bruce Fields create->cr_name, create->cr_namelen, 560ca364317SJ.Bruce Fields &create->cr_iattr,S_IFCHR, rdev, &resfh); 5611da177e4SLinus Torvalds break; 5621da177e4SLinus Torvalds 5631da177e4SLinus Torvalds case NF4SOCK: 564ca364317SJ.Bruce Fields status = nfsd_create(rqstp, &cstate->current_fh, 565ca364317SJ.Bruce Fields create->cr_name, create->cr_namelen, 566ca364317SJ.Bruce Fields &create->cr_iattr, S_IFSOCK, 0, &resfh); 5671da177e4SLinus Torvalds break; 5681da177e4SLinus Torvalds 5691da177e4SLinus Torvalds case NF4FIFO: 570ca364317SJ.Bruce Fields status = nfsd_create(rqstp, &cstate->current_fh, 571ca364317SJ.Bruce Fields create->cr_name, create->cr_namelen, 572ca364317SJ.Bruce Fields &create->cr_iattr, S_IFIFO, 0, &resfh); 5731da177e4SLinus Torvalds break; 5741da177e4SLinus Torvalds 5751da177e4SLinus Torvalds case NF4DIR: 5761da177e4SLinus Torvalds create->cr_iattr.ia_valid &= ~ATTR_SIZE; 577ca364317SJ.Bruce Fields status = nfsd_create(rqstp, &cstate->current_fh, 578ca364317SJ.Bruce Fields create->cr_name, create->cr_namelen, 579ca364317SJ.Bruce Fields &create->cr_iattr, S_IFDIR, 0, &resfh); 5801da177e4SLinus Torvalds break; 5811da177e4SLinus Torvalds 5821da177e4SLinus Torvalds default: 5831da177e4SLinus Torvalds status = nfserr_badtype; 5841da177e4SLinus Torvalds } 5851da177e4SLinus Torvalds 5869208faf2SYu Zhiguo if (status) 5879208faf2SYu Zhiguo goto out; 5889208faf2SYu Zhiguo 5899208faf2SYu Zhiguo if (create->cr_acl != NULL) 5909208faf2SYu Zhiguo do_set_nfs4_acl(rqstp, &resfh, create->cr_acl, 5919208faf2SYu Zhiguo create->cr_bmval); 5929208faf2SYu Zhiguo 593ca364317SJ.Bruce Fields fh_unlock(&cstate->current_fh); 594ca364317SJ.Bruce Fields set_change_info(&create->cr_cinfo, &cstate->current_fh); 595ca364317SJ.Bruce Fields fh_dup2(&cstate->current_fh, &resfh); 5969208faf2SYu Zhiguo out: 5971da177e4SLinus Torvalds fh_put(&resfh); 5981da177e4SLinus Torvalds return status; 5991da177e4SLinus Torvalds } 6001da177e4SLinus Torvalds 6017191155bSJ.Bruce Fields static __be32 602ca364317SJ.Bruce Fields nfsd4_getattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 603ca364317SJ.Bruce Fields struct nfsd4_getattr *getattr) 6041da177e4SLinus Torvalds { 605b37ad28bSAl Viro __be32 status; 6061da177e4SLinus Torvalds 6078837abcaSMiklos Szeredi status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP); 6081da177e4SLinus Torvalds if (status) 6091da177e4SLinus Torvalds return status; 6101da177e4SLinus Torvalds 6111da177e4SLinus Torvalds if (getattr->ga_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1) 6121da177e4SLinus Torvalds return nfserr_inval; 6131da177e4SLinus Torvalds 6147e705706SAndy Adamson getattr->ga_bmval[0] &= nfsd_suppattrs0(cstate->minorversion); 6157e705706SAndy Adamson getattr->ga_bmval[1] &= nfsd_suppattrs1(cstate->minorversion); 6167e705706SAndy Adamson getattr->ga_bmval[2] &= nfsd_suppattrs2(cstate->minorversion); 6171da177e4SLinus Torvalds 618ca364317SJ.Bruce Fields getattr->ga_fhp = &cstate->current_fh; 6191da177e4SLinus Torvalds return nfs_ok; 6201da177e4SLinus Torvalds } 6211da177e4SLinus Torvalds 6227191155bSJ.Bruce Fields static __be32 623ca364317SJ.Bruce Fields nfsd4_link(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 624ca364317SJ.Bruce Fields struct nfsd4_link *link) 6251da177e4SLinus Torvalds { 626b37ad28bSAl Viro __be32 status = nfserr_nofilehandle; 6271da177e4SLinus Torvalds 628ca364317SJ.Bruce Fields if (!cstate->save_fh.fh_dentry) 6291da177e4SLinus Torvalds return status; 630ca364317SJ.Bruce Fields status = nfsd_link(rqstp, &cstate->current_fh, 631ca364317SJ.Bruce Fields link->li_name, link->li_namelen, &cstate->save_fh); 6321da177e4SLinus Torvalds if (!status) 633ca364317SJ.Bruce Fields set_change_info(&link->li_cinfo, &cstate->current_fh); 6341da177e4SLinus Torvalds return status; 6351da177e4SLinus Torvalds } 6361da177e4SLinus Torvalds 6370ff7ab46SJ. Bruce Fields static __be32 nfsd4_do_lookupp(struct svc_rqst *rqstp, struct svc_fh *fh) 6381da177e4SLinus Torvalds { 6391da177e4SLinus Torvalds struct svc_fh tmp_fh; 640b37ad28bSAl Viro __be32 ret; 6411da177e4SLinus Torvalds 6421da177e4SLinus Torvalds fh_init(&tmp_fh, NFS4_FHSIZE); 643df547efbSJ. Bruce Fields ret = exp_pseudoroot(rqstp, &tmp_fh); 644df547efbSJ. Bruce Fields if (ret) 6451da177e4SLinus Torvalds return ret; 6460ff7ab46SJ. Bruce Fields if (tmp_fh.fh_dentry == fh->fh_dentry) { 6471da177e4SLinus Torvalds fh_put(&tmp_fh); 6481da177e4SLinus Torvalds return nfserr_noent; 6491da177e4SLinus Torvalds } 6501da177e4SLinus Torvalds fh_put(&tmp_fh); 6510ff7ab46SJ. Bruce Fields return nfsd_lookup(rqstp, fh, "..", 2, fh); 6520ff7ab46SJ. Bruce Fields } 6530ff7ab46SJ. Bruce Fields 6540ff7ab46SJ. Bruce Fields static __be32 6550ff7ab46SJ. Bruce Fields nfsd4_lookupp(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 6560ff7ab46SJ. Bruce Fields void *arg) 6570ff7ab46SJ. Bruce Fields { 6580ff7ab46SJ. Bruce Fields return nfsd4_do_lookupp(rqstp, &cstate->current_fh); 6591da177e4SLinus Torvalds } 6601da177e4SLinus Torvalds 6617191155bSJ.Bruce Fields static __be32 662ca364317SJ.Bruce Fields nfsd4_lookup(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 663ca364317SJ.Bruce Fields struct nfsd4_lookup *lookup) 6641da177e4SLinus Torvalds { 665ca364317SJ.Bruce Fields return nfsd_lookup(rqstp, &cstate->current_fh, 666ca364317SJ.Bruce Fields lookup->lo_name, lookup->lo_len, 667ca364317SJ.Bruce Fields &cstate->current_fh); 6681da177e4SLinus Torvalds } 6691da177e4SLinus Torvalds 6707191155bSJ.Bruce Fields static __be32 671ca364317SJ.Bruce Fields nfsd4_read(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 672ca364317SJ.Bruce Fields struct nfsd4_read *read) 6731da177e4SLinus Torvalds { 674b37ad28bSAl Viro __be32 status; 6751da177e4SLinus Torvalds 6761da177e4SLinus Torvalds /* no need to check permission - this will be done in nfsd_read() */ 6771da177e4SLinus Torvalds 6787e06b7f9SNeilBrown read->rd_filp = NULL; 6791da177e4SLinus Torvalds if (read->rd_offset >= OFFSET_MAX) 6801da177e4SLinus Torvalds return nfserr_inval; 6811da177e4SLinus Torvalds 6821da177e4SLinus Torvalds nfs4_lock_state(); 6831da177e4SLinus Torvalds /* check stateid */ 684dd453dfdSBenny Halevy if ((status = nfs4_preprocess_stateid_op(cstate, &read->rd_stateid, 6856150ef0dSJ. Bruce Fields RD_STATE, &read->rd_filp))) { 6861da177e4SLinus Torvalds dprintk("NFSD: nfsd4_read: couldn't process stateid!\n"); 6871da177e4SLinus Torvalds goto out; 6881da177e4SLinus Torvalds } 6897e06b7f9SNeilBrown if (read->rd_filp) 6907e06b7f9SNeilBrown get_file(read->rd_filp); 6911da177e4SLinus Torvalds status = nfs_ok; 6921da177e4SLinus Torvalds out: 6931da177e4SLinus Torvalds nfs4_unlock_state(); 6941da177e4SLinus Torvalds read->rd_rqstp = rqstp; 695ca364317SJ.Bruce Fields read->rd_fhp = &cstate->current_fh; 6961da177e4SLinus Torvalds return status; 6971da177e4SLinus Torvalds } 6981da177e4SLinus Torvalds 6997191155bSJ.Bruce Fields static __be32 700ca364317SJ.Bruce Fields nfsd4_readdir(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 701ca364317SJ.Bruce Fields struct nfsd4_readdir *readdir) 7021da177e4SLinus Torvalds { 7031da177e4SLinus Torvalds u64 cookie = readdir->rd_cookie; 7041da177e4SLinus Torvalds static const nfs4_verifier zeroverf; 7051da177e4SLinus Torvalds 7061da177e4SLinus Torvalds /* no need to check permission - this will be done in nfsd_readdir() */ 7071da177e4SLinus Torvalds 7081da177e4SLinus Torvalds if (readdir->rd_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1) 7091da177e4SLinus Torvalds return nfserr_inval; 7101da177e4SLinus Torvalds 7117e705706SAndy Adamson readdir->rd_bmval[0] &= nfsd_suppattrs0(cstate->minorversion); 7127e705706SAndy Adamson readdir->rd_bmval[1] &= nfsd_suppattrs1(cstate->minorversion); 7137e705706SAndy Adamson readdir->rd_bmval[2] &= nfsd_suppattrs2(cstate->minorversion); 7141da177e4SLinus Torvalds 715832023bfSBernd Schubert if ((cookie == 1) || (cookie == 2) || 7161da177e4SLinus Torvalds (cookie == 0 && memcmp(readdir->rd_verf.data, zeroverf.data, NFS4_VERIFIER_SIZE))) 7171da177e4SLinus Torvalds return nfserr_bad_cookie; 7181da177e4SLinus Torvalds 7191da177e4SLinus Torvalds readdir->rd_rqstp = rqstp; 720ca364317SJ.Bruce Fields readdir->rd_fhp = &cstate->current_fh; 7211da177e4SLinus Torvalds return nfs_ok; 7221da177e4SLinus Torvalds } 7231da177e4SLinus Torvalds 7247191155bSJ.Bruce Fields static __be32 725ca364317SJ.Bruce Fields nfsd4_readlink(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 726ca364317SJ.Bruce Fields struct nfsd4_readlink *readlink) 7271da177e4SLinus Torvalds { 7281da177e4SLinus Torvalds readlink->rl_rqstp = rqstp; 729ca364317SJ.Bruce Fields readlink->rl_fhp = &cstate->current_fh; 7301da177e4SLinus Torvalds return nfs_ok; 7311da177e4SLinus Torvalds } 7321da177e4SLinus Torvalds 7337191155bSJ.Bruce Fields static __be32 734ca364317SJ.Bruce Fields nfsd4_remove(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 735ca364317SJ.Bruce Fields struct nfsd4_remove *remove) 7361da177e4SLinus Torvalds { 737b37ad28bSAl Viro __be32 status; 7381da177e4SLinus Torvalds 739af558e33SJ. Bruce Fields if (locks_in_grace()) 740c815afc7SNeilBrown return nfserr_grace; 741ca364317SJ.Bruce Fields status = nfsd_unlink(rqstp, &cstate->current_fh, 0, 742ca364317SJ.Bruce Fields remove->rm_name, remove->rm_namelen); 7431da177e4SLinus Torvalds if (!status) { 744ca364317SJ.Bruce Fields fh_unlock(&cstate->current_fh); 745ca364317SJ.Bruce Fields set_change_info(&remove->rm_cinfo, &cstate->current_fh); 7461da177e4SLinus Torvalds } 7471da177e4SLinus Torvalds return status; 7481da177e4SLinus Torvalds } 7491da177e4SLinus Torvalds 7507191155bSJ.Bruce Fields static __be32 751ca364317SJ.Bruce Fields nfsd4_rename(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 752ca364317SJ.Bruce Fields struct nfsd4_rename *rename) 7531da177e4SLinus Torvalds { 754b37ad28bSAl Viro __be32 status = nfserr_nofilehandle; 7551da177e4SLinus Torvalds 756ca364317SJ.Bruce Fields if (!cstate->save_fh.fh_dentry) 7571da177e4SLinus Torvalds return status; 758af558e33SJ. Bruce Fields if (locks_in_grace() && !(cstate->save_fh.fh_export->ex_flags 759c815afc7SNeilBrown & NFSEXP_NOSUBTREECHECK)) 760c815afc7SNeilBrown return nfserr_grace; 761ca364317SJ.Bruce Fields status = nfsd_rename(rqstp, &cstate->save_fh, rename->rn_sname, 762ca364317SJ.Bruce Fields rename->rn_snamelen, &cstate->current_fh, 7631da177e4SLinus Torvalds rename->rn_tname, rename->rn_tnamelen); 7641da177e4SLinus Torvalds 7651da177e4SLinus Torvalds /* the underlying filesystem returns different error's than required 7661da177e4SLinus Torvalds * by NFSv4. both save_fh and current_fh have been verified.. */ 7671da177e4SLinus Torvalds if (status == nfserr_isdir) 7681da177e4SLinus Torvalds status = nfserr_exist; 7691da177e4SLinus Torvalds else if ((status == nfserr_notdir) && 770ca364317SJ.Bruce Fields (S_ISDIR(cstate->save_fh.fh_dentry->d_inode->i_mode) && 771ca364317SJ.Bruce Fields S_ISDIR(cstate->current_fh.fh_dentry->d_inode->i_mode))) 7721da177e4SLinus Torvalds status = nfserr_exist; 7731da177e4SLinus Torvalds 7741da177e4SLinus Torvalds if (!status) { 775ca364317SJ.Bruce Fields set_change_info(&rename->rn_sinfo, &cstate->current_fh); 776ca364317SJ.Bruce Fields set_change_info(&rename->rn_tinfo, &cstate->save_fh); 7771da177e4SLinus Torvalds } 7781da177e4SLinus Torvalds return status; 7791da177e4SLinus Torvalds } 7801da177e4SLinus Torvalds 7817191155bSJ.Bruce Fields static __be32 782dcb488a3SAndy Adamson nfsd4_secinfo(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 783dcb488a3SAndy Adamson struct nfsd4_secinfo *secinfo) 784dcb488a3SAndy Adamson { 785dcb488a3SAndy Adamson struct svc_fh resfh; 786dcb488a3SAndy Adamson struct svc_export *exp; 787dcb488a3SAndy Adamson struct dentry *dentry; 788dcb488a3SAndy Adamson __be32 err; 789dcb488a3SAndy Adamson 790dcb488a3SAndy Adamson fh_init(&resfh, NFS4_FHSIZE); 79129a78a3eSJ. Bruce Fields err = fh_verify(rqstp, &cstate->current_fh, S_IFDIR, NFSD_MAY_EXEC); 79229a78a3eSJ. Bruce Fields if (err) 79329a78a3eSJ. Bruce Fields return err; 794dcb488a3SAndy Adamson err = nfsd_lookup_dentry(rqstp, &cstate->current_fh, 795dcb488a3SAndy Adamson secinfo->si_name, secinfo->si_namelen, 796dcb488a3SAndy Adamson &exp, &dentry); 797dcb488a3SAndy Adamson if (err) 798dcb488a3SAndy Adamson return err; 799dcb488a3SAndy Adamson if (dentry->d_inode == NULL) { 800dcb488a3SAndy Adamson exp_put(exp); 801dcb488a3SAndy Adamson err = nfserr_noent; 802dcb488a3SAndy Adamson } else 803dcb488a3SAndy Adamson secinfo->si_exp = exp; 804dcb488a3SAndy Adamson dput(dentry); 80556560b9aSJ. Bruce Fields if (cstate->minorversion) 80656560b9aSJ. Bruce Fields /* See rfc 5661 section 2.6.3.1.1.8 */ 80756560b9aSJ. Bruce Fields fh_put(&cstate->current_fh); 808dcb488a3SAndy Adamson return err; 809dcb488a3SAndy Adamson } 810dcb488a3SAndy Adamson 811dcb488a3SAndy Adamson static __be32 81204f4ad16SJ. Bruce Fields nfsd4_secinfo_no_name(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 81304f4ad16SJ. Bruce Fields struct nfsd4_secinfo_no_name *sin) 81404f4ad16SJ. Bruce Fields { 81504f4ad16SJ. Bruce Fields __be32 err; 81604f4ad16SJ. Bruce Fields 81704f4ad16SJ. Bruce Fields switch (sin->sin_style) { 81804f4ad16SJ. Bruce Fields case NFS4_SECINFO_STYLE4_CURRENT_FH: 81904f4ad16SJ. Bruce Fields break; 82004f4ad16SJ. Bruce Fields case NFS4_SECINFO_STYLE4_PARENT: 82104f4ad16SJ. Bruce Fields err = nfsd4_do_lookupp(rqstp, &cstate->current_fh); 82204f4ad16SJ. Bruce Fields if (err) 82304f4ad16SJ. Bruce Fields return err; 82404f4ad16SJ. Bruce Fields break; 82504f4ad16SJ. Bruce Fields default: 82604f4ad16SJ. Bruce Fields return nfserr_inval; 82704f4ad16SJ. Bruce Fields } 82804f4ad16SJ. Bruce Fields exp_get(cstate->current_fh.fh_export); 82904f4ad16SJ. Bruce Fields sin->sin_exp = cstate->current_fh.fh_export; 83004f4ad16SJ. Bruce Fields fh_put(&cstate->current_fh); 83104f4ad16SJ. Bruce Fields return nfs_ok; 83204f4ad16SJ. Bruce Fields } 83304f4ad16SJ. Bruce Fields 83404f4ad16SJ. Bruce Fields static __be32 835ca364317SJ.Bruce Fields nfsd4_setattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 836ca364317SJ.Bruce Fields struct nfsd4_setattr *setattr) 8371da177e4SLinus Torvalds { 838b37ad28bSAl Viro __be32 status = nfs_ok; 8391da177e4SLinus Torvalds 8401da177e4SLinus Torvalds if (setattr->sa_iattr.ia_valid & ATTR_SIZE) { 8411da177e4SLinus Torvalds nfs4_lock_state(); 842dd453dfdSBenny Halevy status = nfs4_preprocess_stateid_op(cstate, 8436150ef0dSJ. Bruce Fields &setattr->sa_stateid, WR_STATE, NULL); 8441da177e4SLinus Torvalds nfs4_unlock_state(); 845375c5547SJ. Bruce Fields if (status) { 8463e3b4800SGreg Banks dprintk("NFSD: nfsd4_setattr: couldn't process stateid!\n"); 847375c5547SJ. Bruce Fields return status; 848375c5547SJ. Bruce Fields } 8491da177e4SLinus Torvalds } 85018f335afSDave Hansen status = mnt_want_write(cstate->current_fh.fh_export->ex_path.mnt); 85118f335afSDave Hansen if (status) 85218f335afSDave Hansen return status; 8531da177e4SLinus Torvalds status = nfs_ok; 8543c8e0316SYu Zhiguo 8553c8e0316SYu Zhiguo status = check_attr_support(rqstp, cstate, setattr->sa_bmval, 8563c8e0316SYu Zhiguo nfsd_attrmask); 8573c8e0316SYu Zhiguo if (status) 8583c8e0316SYu Zhiguo goto out; 8593c8e0316SYu Zhiguo 8601da177e4SLinus Torvalds if (setattr->sa_acl != NULL) 861ca364317SJ.Bruce Fields status = nfsd4_set_nfs4_acl(rqstp, &cstate->current_fh, 862ca364317SJ.Bruce Fields setattr->sa_acl); 8631da177e4SLinus Torvalds if (status) 86418f335afSDave Hansen goto out; 865ca364317SJ.Bruce Fields status = nfsd_setattr(rqstp, &cstate->current_fh, &setattr->sa_iattr, 8661da177e4SLinus Torvalds 0, (time_t)0); 86718f335afSDave Hansen out: 86818f335afSDave Hansen mnt_drop_write(cstate->current_fh.fh_export->ex_path.mnt); 8691da177e4SLinus Torvalds return status; 8701da177e4SLinus Torvalds } 8711da177e4SLinus Torvalds 8727191155bSJ.Bruce Fields static __be32 873ca364317SJ.Bruce Fields nfsd4_write(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 874ca364317SJ.Bruce Fields struct nfsd4_write *write) 8751da177e4SLinus Torvalds { 8761da177e4SLinus Torvalds stateid_t *stateid = &write->wr_stateid; 8771da177e4SLinus Torvalds struct file *filp = NULL; 8781da177e4SLinus Torvalds u32 *p; 879b37ad28bSAl Viro __be32 status = nfs_ok; 88031dec253SDavid Shaw unsigned long cnt; 8811da177e4SLinus Torvalds 8821da177e4SLinus Torvalds /* no need to check permission - this will be done in nfsd_write() */ 8831da177e4SLinus Torvalds 8841da177e4SLinus Torvalds if (write->wr_offset >= OFFSET_MAX) 8851da177e4SLinus Torvalds return nfserr_inval; 8861da177e4SLinus Torvalds 8871da177e4SLinus Torvalds nfs4_lock_state(); 888dd453dfdSBenny Halevy status = nfs4_preprocess_stateid_op(cstate, stateid, WR_STATE, &filp); 8897e06b7f9SNeilBrown if (filp) 8907e06b7f9SNeilBrown get_file(filp); 8911da177e4SLinus Torvalds nfs4_unlock_state(); 8921da177e4SLinus Torvalds 893375c5547SJ. Bruce Fields if (status) { 894375c5547SJ. Bruce Fields dprintk("NFSD: nfsd4_write: couldn't process stateid!\n"); 895375c5547SJ. Bruce Fields return status; 896375c5547SJ. Bruce Fields } 897375c5547SJ. Bruce Fields 89831dec253SDavid Shaw cnt = write->wr_buflen; 8991da177e4SLinus Torvalds write->wr_how_written = write->wr_stable_how; 9001da177e4SLinus Torvalds p = (u32 *)write->wr_verifier.data; 9011da177e4SLinus Torvalds *p++ = nfssvc_boot.tv_sec; 9021da177e4SLinus Torvalds *p++ = nfssvc_boot.tv_usec; 9031da177e4SLinus Torvalds 904ca364317SJ.Bruce Fields status = nfsd_write(rqstp, &cstate->current_fh, filp, 905ca364317SJ.Bruce Fields write->wr_offset, rqstp->rq_vec, write->wr_vlen, 90631dec253SDavid Shaw &cnt, &write->wr_how_written); 9077e06b7f9SNeilBrown if (filp) 9087e06b7f9SNeilBrown fput(filp); 9091da177e4SLinus Torvalds 91031dec253SDavid Shaw write->wr_bytes_written = cnt; 91131dec253SDavid Shaw 9121da177e4SLinus Torvalds return status; 9131da177e4SLinus Torvalds } 9141da177e4SLinus Torvalds 9151da177e4SLinus Torvalds /* This routine never returns NFS_OK! If there are no other errors, it 9161da177e4SLinus Torvalds * will return NFSERR_SAME or NFSERR_NOT_SAME depending on whether the 9171da177e4SLinus Torvalds * attributes matched. VERIFY is implemented by mapping NFSERR_SAME 9181da177e4SLinus Torvalds * to NFS_OK after the call; NVERIFY by mapping NFSERR_NOT_SAME to NFS_OK. 9191da177e4SLinus Torvalds */ 920b37ad28bSAl Viro static __be32 921c954e2a5SJ.Bruce Fields _nfsd4_verify(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 922ca364317SJ.Bruce Fields struct nfsd4_verify *verify) 9231da177e4SLinus Torvalds { 9242ebbc012SAl Viro __be32 *buf, *p; 9251da177e4SLinus Torvalds int count; 926b37ad28bSAl Viro __be32 status; 9271da177e4SLinus Torvalds 9288837abcaSMiklos Szeredi status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP); 9291da177e4SLinus Torvalds if (status) 9301da177e4SLinus Torvalds return status; 9311da177e4SLinus Torvalds 9323c8e0316SYu Zhiguo status = check_attr_support(rqstp, cstate, verify->ve_bmval, NULL); 9333c8e0316SYu Zhiguo if (status) 9343c8e0316SYu Zhiguo return status; 9353c8e0316SYu Zhiguo 9361da177e4SLinus Torvalds if ((verify->ve_bmval[0] & FATTR4_WORD0_RDATTR_ERROR) 9371da177e4SLinus Torvalds || (verify->ve_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1)) 9381da177e4SLinus Torvalds return nfserr_inval; 9391da177e4SLinus Torvalds if (verify->ve_attrlen & 3) 9401da177e4SLinus Torvalds return nfserr_inval; 9411da177e4SLinus Torvalds 9421da177e4SLinus Torvalds /* count in words: 9431da177e4SLinus Torvalds * bitmap_len(1) + bitmap(2) + attr_len(1) = 4 9441da177e4SLinus Torvalds */ 9451da177e4SLinus Torvalds count = 4 + (verify->ve_attrlen >> 2); 9461da177e4SLinus Torvalds buf = kmalloc(count << 2, GFP_KERNEL); 9471da177e4SLinus Torvalds if (!buf) 9483e772463SJ. Bruce Fields return nfserr_jukebox; 9491da177e4SLinus Torvalds 950ca364317SJ.Bruce Fields status = nfsd4_encode_fattr(&cstate->current_fh, 951ca364317SJ.Bruce Fields cstate->current_fh.fh_export, 952ca364317SJ.Bruce Fields cstate->current_fh.fh_dentry, buf, 9531da177e4SLinus Torvalds &count, verify->ve_bmval, 954406a7ea9SFrank Filz rqstp, 0); 9551da177e4SLinus Torvalds 9561da177e4SLinus Torvalds /* this means that nfsd4_encode_fattr() ran out of space */ 9571da177e4SLinus Torvalds if (status == nfserr_resource && count == 0) 9581da177e4SLinus Torvalds status = nfserr_not_same; 9591da177e4SLinus Torvalds if (status) 9601da177e4SLinus Torvalds goto out_kfree; 9611da177e4SLinus Torvalds 96295ec28cdSBenny Halevy /* skip bitmap */ 96395ec28cdSBenny Halevy p = buf + 1 + ntohl(buf[0]); 9641da177e4SLinus Torvalds status = nfserr_not_same; 9651da177e4SLinus Torvalds if (ntohl(*p++) != verify->ve_attrlen) 9661da177e4SLinus Torvalds goto out_kfree; 9671da177e4SLinus Torvalds if (!memcmp(p, verify->ve_attrval, verify->ve_attrlen)) 9681da177e4SLinus Torvalds status = nfserr_same; 9691da177e4SLinus Torvalds 9701da177e4SLinus Torvalds out_kfree: 9711da177e4SLinus Torvalds kfree(buf); 9721da177e4SLinus Torvalds return status; 9731da177e4SLinus Torvalds } 9741da177e4SLinus Torvalds 975c954e2a5SJ.Bruce Fields static __be32 976c954e2a5SJ.Bruce Fields nfsd4_nverify(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 977c954e2a5SJ.Bruce Fields struct nfsd4_verify *verify) 978c954e2a5SJ.Bruce Fields { 979c954e2a5SJ.Bruce Fields __be32 status; 980c954e2a5SJ.Bruce Fields 981c954e2a5SJ.Bruce Fields status = _nfsd4_verify(rqstp, cstate, verify); 982c954e2a5SJ.Bruce Fields return status == nfserr_not_same ? nfs_ok : status; 983c954e2a5SJ.Bruce Fields } 984c954e2a5SJ.Bruce Fields 985c954e2a5SJ.Bruce Fields static __be32 986c954e2a5SJ.Bruce Fields nfsd4_verify(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 987c954e2a5SJ.Bruce Fields struct nfsd4_verify *verify) 988c954e2a5SJ.Bruce Fields { 989c954e2a5SJ.Bruce Fields __be32 status; 990c954e2a5SJ.Bruce Fields 991c954e2a5SJ.Bruce Fields status = _nfsd4_verify(rqstp, cstate, verify); 992c954e2a5SJ.Bruce Fields return status == nfserr_same ? nfs_ok : status; 993c954e2a5SJ.Bruce Fields } 994c954e2a5SJ.Bruce Fields 9951da177e4SLinus Torvalds /* 9961da177e4SLinus Torvalds * NULL call. 9971da177e4SLinus Torvalds */ 9987111c66eSAl Viro static __be32 9991da177e4SLinus Torvalds nfsd4_proc_null(struct svc_rqst *rqstp, void *argp, void *resp) 10001da177e4SLinus Torvalds { 10011da177e4SLinus Torvalds return nfs_ok; 10021da177e4SLinus Torvalds } 10031da177e4SLinus Torvalds 1004e2b20950SShankar Anand static inline void nfsd4_increment_op_stats(u32 opnum) 1005e2b20950SShankar Anand { 1006e2b20950SShankar Anand if (opnum >= FIRST_NFS4_OP && opnum <= LAST_NFS4_OP) 1007e2b20950SShankar Anand nfsdstats.nfs4_opcount[opnum]++; 1008e2b20950SShankar Anand } 1009e2b20950SShankar Anand 1010b591480bSJ.Bruce Fields typedef __be32(*nfsd4op_func)(struct svc_rqst *, struct nfsd4_compound_state *, 1011b591480bSJ.Bruce Fields void *); 101258e7b33aSMi Jinlong typedef u32(*nfsd4op_rsize)(struct svc_rqst *, struct nfsd4_op *op); 101358e7b33aSMi Jinlong 1014f9bb94c4SAndy Adamson enum nfsd4_op_flags { 1015f9bb94c4SAndy Adamson ALLOWED_WITHOUT_FH = 1 << 0, /* No current filehandle required */ 10165ece3cafSMi Jinlong ALLOWED_ON_ABSENT_FS = 1 << 1, /* ops processed on absent fs */ 10175ece3cafSMi Jinlong ALLOWED_AS_FIRST_OP = 1 << 2, /* ops reqired first in compound */ 101868d93184SJ. Bruce Fields /* For rfc 5661 section 2.6.3.1.1: */ 101968d93184SJ. Bruce Fields OP_HANDLES_WRONGSEC = 1 << 3, 102068d93184SJ. Bruce Fields OP_IS_PUTFH_LIKE = 1 << 4, 10211091006cSJ. Bruce Fields /* 1022c856694eSJ. Bruce Fields * These are the ops whose result size we estimate before 1023c856694eSJ. Bruce Fields * encoding, to avoid performing an op then not being able to 1024c856694eSJ. Bruce Fields * respond or cache a response. This includes writes and setattrs 1025c856694eSJ. Bruce Fields * as well as the operations usually called "nonidempotent": 1026c856694eSJ. Bruce Fields */ 1027c856694eSJ. Bruce Fields OP_MODIFIES_SOMETHING = 1 << 5, 1028c856694eSJ. Bruce Fields /* 1029c856694eSJ. Bruce Fields * Cache compounds containing these ops in the xid-based drc: 10301091006cSJ. Bruce Fields * We use the DRC for compounds containing non-idempotent 10311091006cSJ. Bruce Fields * operations, *except* those that are 4.1-specific (since 10321091006cSJ. Bruce Fields * sessions provide their own EOS), and except for stateful 10331091006cSJ. Bruce Fields * operations other than setclientid and setclientid_confirm 10341091006cSJ. Bruce Fields * (since sequence numbers provide EOS for open, lock, etc in 10351091006cSJ. Bruce Fields * the v4.0 case). 10361091006cSJ. Bruce Fields */ 1037c856694eSJ. Bruce Fields OP_CACHEME = 1 << 6, 1038c856694eSJ. Bruce Fields }; 1039c856694eSJ. Bruce Fields 1040c856694eSJ. Bruce Fields struct nfsd4_operation { 1041c856694eSJ. Bruce Fields nfsd4op_func op_func; 1042c856694eSJ. Bruce Fields u32 op_flags; 1043c856694eSJ. Bruce Fields char *op_name; 104458e7b33aSMi Jinlong /* Try to get response size before operation */ 104558e7b33aSMi Jinlong nfsd4op_rsize op_rsize_bop; 1046b591480bSJ.Bruce Fields }; 1047b591480bSJ.Bruce Fields 1048b591480bSJ.Bruce Fields static struct nfsd4_operation nfsd4_ops[]; 1049b591480bSJ.Bruce Fields 1050f1c7f79bSAdrian Bunk static const char *nfsd4_op_name(unsigned opnum); 1051b001a1b6SBenny Halevy 10521da177e4SLinus Torvalds /* 105357716355SJ. Bruce Fields * Enforce NFSv4.1 COMPOUND ordering rules: 1054f9bb94c4SAndy Adamson * 105557716355SJ. Bruce Fields * Also note, enforced elsewhere: 105657716355SJ. Bruce Fields * - SEQUENCE other than as first op results in 105757716355SJ. Bruce Fields * NFS4ERR_SEQUENCE_POS. (Enforced in nfsd4_sequence().) 10581d1bc8f2SJ. Bruce Fields * - BIND_CONN_TO_SESSION must be the only op in its compound. 10591d1bc8f2SJ. Bruce Fields * (Enforced in nfsd4_bind_conn_to_session().) 106057716355SJ. Bruce Fields * - DESTROY_SESSION must be the final operation in a compound, if 106157716355SJ. Bruce Fields * sessionid's in SEQUENCE and DESTROY_SESSION are the same. 106257716355SJ. Bruce Fields * (Enforced in nfsd4_destroy_session().) 1063f9bb94c4SAndy Adamson */ 106457716355SJ. Bruce Fields static __be32 nfs41_check_op_ordering(struct nfsd4_compoundargs *args) 1065f9bb94c4SAndy Adamson { 1066f9bb94c4SAndy Adamson struct nfsd4_op *op = &args->ops[0]; 106757716355SJ. Bruce Fields 106857716355SJ. Bruce Fields /* These ordering requirements don't apply to NFSv4.0: */ 106957716355SJ. Bruce Fields if (args->minorversion == 0) 107057716355SJ. Bruce Fields return nfs_ok; 107157716355SJ. Bruce Fields /* This is weird, but OK, not our problem: */ 107257716355SJ. Bruce Fields if (args->opcnt == 0) 107357716355SJ. Bruce Fields return nfs_ok; 107457716355SJ. Bruce Fields if (op->status == nfserr_op_illegal) 107557716355SJ. Bruce Fields return nfs_ok; 107657716355SJ. Bruce Fields if (!(nfsd4_ops[op->opnum].op_flags & ALLOWED_AS_FIRST_OP)) 107757716355SJ. Bruce Fields return nfserr_op_not_in_session; 107857716355SJ. Bruce Fields if (op->opnum == OP_SEQUENCE) 107957716355SJ. Bruce Fields return nfs_ok; 108057716355SJ. Bruce Fields if (args->opcnt != 1) 108157716355SJ. Bruce Fields return nfserr_not_only_op; 108257716355SJ. Bruce Fields return nfs_ok; 1083f9bb94c4SAndy Adamson } 1084f9bb94c4SAndy Adamson 108522b03214SJ. Bruce Fields static inline struct nfsd4_operation *OPDESC(struct nfsd4_op *op) 108622b03214SJ. Bruce Fields { 108722b03214SJ. Bruce Fields return &nfsd4_ops[op->opnum]; 108822b03214SJ. Bruce Fields } 108922b03214SJ. Bruce Fields 10901091006cSJ. Bruce Fields bool nfsd4_cache_this_op(struct nfsd4_op *op) 10911091006cSJ. Bruce Fields { 1092c856694eSJ. Bruce Fields return OPDESC(op)->op_flags & OP_CACHEME; 10931091006cSJ. Bruce Fields } 10941091006cSJ. Bruce Fields 109568d93184SJ. Bruce Fields static bool need_wrongsec_check(struct svc_rqst *rqstp) 109668d93184SJ. Bruce Fields { 109768d93184SJ. Bruce Fields struct nfsd4_compoundres *resp = rqstp->rq_resp; 109868d93184SJ. Bruce Fields struct nfsd4_compoundargs *argp = rqstp->rq_argp; 109968d93184SJ. Bruce Fields struct nfsd4_op *this = &argp->ops[resp->opcnt - 1]; 110068d93184SJ. Bruce Fields struct nfsd4_op *next = &argp->ops[resp->opcnt]; 110168d93184SJ. Bruce Fields struct nfsd4_operation *thisd; 110268d93184SJ. Bruce Fields struct nfsd4_operation *nextd; 110368d93184SJ. Bruce Fields 110468d93184SJ. Bruce Fields thisd = OPDESC(this); 110568d93184SJ. Bruce Fields /* 110668d93184SJ. Bruce Fields * Most ops check wronsec on our own; only the putfh-like ops 110768d93184SJ. Bruce Fields * have special rules. 110868d93184SJ. Bruce Fields */ 110968d93184SJ. Bruce Fields if (!(thisd->op_flags & OP_IS_PUTFH_LIKE)) 111068d93184SJ. Bruce Fields return false; 111168d93184SJ. Bruce Fields /* 111268d93184SJ. Bruce Fields * rfc 5661 2.6.3.1.1.6: don't bother erroring out a 111368d93184SJ. Bruce Fields * put-filehandle operation if we're not going to use the 111468d93184SJ. Bruce Fields * result: 111568d93184SJ. Bruce Fields */ 111668d93184SJ. Bruce Fields if (argp->opcnt == resp->opcnt) 111768d93184SJ. Bruce Fields return false; 111868d93184SJ. Bruce Fields 111968d93184SJ. Bruce Fields nextd = OPDESC(next); 112068d93184SJ. Bruce Fields /* 112168d93184SJ. Bruce Fields * Rest of 2.6.3.1.1: certain operations will return WRONGSEC 112268d93184SJ. Bruce Fields * errors themselves as necessary; others should check for them 112368d93184SJ. Bruce Fields * now: 112468d93184SJ. Bruce Fields */ 112568d93184SJ. Bruce Fields return !(nextd->op_flags & OP_HANDLES_WRONGSEC); 112668d93184SJ. Bruce Fields } 112768d93184SJ. Bruce Fields 1128f9bb94c4SAndy Adamson /* 11291da177e4SLinus Torvalds * COMPOUND call. 11301da177e4SLinus Torvalds */ 11317111c66eSAl Viro static __be32 11321da177e4SLinus Torvalds nfsd4_proc_compound(struct svc_rqst *rqstp, 11331da177e4SLinus Torvalds struct nfsd4_compoundargs *args, 11341da177e4SLinus Torvalds struct nfsd4_compoundres *resp) 11351da177e4SLinus Torvalds { 11361da177e4SLinus Torvalds struct nfsd4_op *op; 1137b591480bSJ.Bruce Fields struct nfsd4_operation *opdesc; 1138e354d571SAndy Adamson struct nfsd4_compound_state *cstate = &resp->cstate; 1139e5710199SJ.Bruce Fields int slack_bytes; 114058e7b33aSMi Jinlong u32 plen = 0; 1141b37ad28bSAl Viro __be32 status; 11421da177e4SLinus Torvalds 11431da177e4SLinus Torvalds resp->xbuf = &rqstp->rq_res; 1144e354d571SAndy Adamson resp->p = rqstp->rq_res.head[0].iov_base + 1145e354d571SAndy Adamson rqstp->rq_res.head[0].iov_len; 11461da177e4SLinus Torvalds resp->tagp = resp->p; 11471da177e4SLinus Torvalds /* reserve space for: taglen, tag, and opcnt */ 11481da177e4SLinus Torvalds resp->p += 2 + XDR_QUADLEN(args->taglen); 11491da177e4SLinus Torvalds resp->end = rqstp->rq_res.head[0].iov_base + PAGE_SIZE; 11501da177e4SLinus Torvalds resp->taglen = args->taglen; 11511da177e4SLinus Torvalds resp->tag = args->tag; 11521da177e4SLinus Torvalds resp->opcnt = 0; 11531da177e4SLinus Torvalds resp->rqstp = rqstp; 1154d87a8adeSAndy Adamson resp->cstate.minorversion = args->minorversion; 1155e354d571SAndy Adamson resp->cstate.replay_owner = NULL; 115626c0c75eSJ. Bruce Fields resp->cstate.session = NULL; 1157e354d571SAndy Adamson fh_init(&resp->cstate.current_fh, NFS4_FHSIZE); 1158e354d571SAndy Adamson fh_init(&resp->cstate.save_fh, NFS4_FHSIZE); 11598ff30fa4SNeilBrown /* 11608ff30fa4SNeilBrown * Don't use the deferral mechanism for NFSv4; compounds make it 11618ff30fa4SNeilBrown * too hard to avoid non-idempotency problems. 11628ff30fa4SNeilBrown */ 11638ff30fa4SNeilBrown rqstp->rq_usedeferral = 0; 11641da177e4SLinus Torvalds 11651da177e4SLinus Torvalds /* 11661da177e4SLinus Torvalds * According to RFC3010, this takes precedence over all other errors. 11671da177e4SLinus Torvalds */ 11681da177e4SLinus Torvalds status = nfserr_minor_vers_mismatch; 11698daf220aSBenny Halevy if (args->minorversion > nfsd_supported_minorversion) 11701da177e4SLinus Torvalds goto out; 11711da177e4SLinus Torvalds 117257716355SJ. Bruce Fields status = nfs41_check_op_ordering(args); 117357716355SJ. Bruce Fields if (status) { 1174f9bb94c4SAndy Adamson op = &args->ops[0]; 117557716355SJ. Bruce Fields op->status = status; 1176f9bb94c4SAndy Adamson goto encode_op; 1177f9bb94c4SAndy Adamson } 1178f9bb94c4SAndy Adamson 11791da177e4SLinus Torvalds while (!status && resp->opcnt < args->opcnt) { 11801da177e4SLinus Torvalds op = &args->ops[resp->opcnt++]; 11811da177e4SLinus Torvalds 1182b001a1b6SBenny Halevy dprintk("nfsv4 compound op #%d/%d: %d (%s)\n", 1183b001a1b6SBenny Halevy resp->opcnt, args->opcnt, op->opnum, 1184b001a1b6SBenny Halevy nfsd4_op_name(op->opnum)); 11851da177e4SLinus Torvalds /* 11861da177e4SLinus Torvalds * The XDR decode routines may have pre-set op->status; 11871da177e4SLinus Torvalds * for example, if there is a miscellaneous XDR error 11881da177e4SLinus Torvalds * it will be set to nfserr_bad_xdr. 11891da177e4SLinus Torvalds */ 11901da177e4SLinus Torvalds if (op->status) 11911da177e4SLinus Torvalds goto encode_op; 11921da177e4SLinus Torvalds 11931da177e4SLinus Torvalds /* We must be able to encode a successful response to 11941da177e4SLinus Torvalds * this operation, with enough room left over to encode a 11951da177e4SLinus Torvalds * failed response to the next operation. If we don't 11961da177e4SLinus Torvalds * have enough room, fail with ERR_RESOURCE. 11971da177e4SLinus Torvalds */ 1198e5710199SJ.Bruce Fields slack_bytes = (char *)resp->end - (char *)resp->p; 1199e5710199SJ.Bruce Fields if (slack_bytes < COMPOUND_SLACK_SPACE 1200e5710199SJ.Bruce Fields + COMPOUND_ERR_SLACK_SPACE) { 1201e5710199SJ.Bruce Fields BUG_ON(slack_bytes < COMPOUND_ERR_SLACK_SPACE); 12021da177e4SLinus Torvalds op->status = nfserr_resource; 12031da177e4SLinus Torvalds goto encode_op; 12041da177e4SLinus Torvalds } 12051da177e4SLinus Torvalds 120622b03214SJ. Bruce Fields opdesc = OPDESC(op); 1207b591480bSJ.Bruce Fields 1208ca364317SJ.Bruce Fields if (!cstate->current_fh.fh_dentry) { 120927d630ecSJ.Bruce Fields if (!(opdesc->op_flags & ALLOWED_WITHOUT_FH)) { 12101da177e4SLinus Torvalds op->status = nfserr_nofilehandle; 12111da177e4SLinus Torvalds goto encode_op; 12121da177e4SLinus Torvalds } 1213eeac294eSJ.Bruce Fields } else if (cstate->current_fh.fh_export->ex_fslocs.migrated && 1214eeac294eSJ.Bruce Fields !(opdesc->op_flags & ALLOWED_ON_ABSENT_FS)) { 121542ca0993SJ.Bruce Fields op->status = nfserr_moved; 121642ca0993SJ.Bruce Fields goto encode_op; 121742ca0993SJ.Bruce Fields } 1218b591480bSJ.Bruce Fields 121958e7b33aSMi Jinlong /* If op is non-idempotent */ 122058e7b33aSMi Jinlong if (opdesc->op_flags & OP_MODIFIES_SOMETHING) { 122158e7b33aSMi Jinlong plen = opdesc->op_rsize_bop(rqstp, op); 122258e7b33aSMi Jinlong op->status = nfsd4_check_resp_size(resp, plen); 122358e7b33aSMi Jinlong } 122458e7b33aSMi Jinlong 122558e7b33aSMi Jinlong if (op->status) 122658e7b33aSMi Jinlong goto encode_op; 122758e7b33aSMi Jinlong 1228b591480bSJ.Bruce Fields if (opdesc->op_func) 1229b591480bSJ.Bruce Fields op->status = opdesc->op_func(rqstp, cstate, &op->u); 1230b591480bSJ.Bruce Fields else 12311da177e4SLinus Torvalds BUG_ON(op->status == nfs_ok); 12321da177e4SLinus Torvalds 123368d93184SJ. Bruce Fields if (!op->status && need_wrongsec_check(rqstp)) 123468d93184SJ. Bruce Fields op->status = check_nfsd_access(cstate->current_fh.fh_export, rqstp); 123568d93184SJ. Bruce Fields 12361da177e4SLinus Torvalds encode_op: 123749557cc7SAndy Adamson /* Only from SEQUENCE */ 1238da3846a2SAndy Adamson if (resp->cstate.status == nfserr_replay_cache) { 1239da3846a2SAndy Adamson dprintk("%s NFS4.1 replay from cache\n", __func__); 1240da3846a2SAndy Adamson status = op->status; 1241da3846a2SAndy Adamson goto out; 1242da3846a2SAndy Adamson } 1243a90b061cSAl Viro if (op->status == nfserr_replay_me) { 1244a4f1706aSJ.Bruce Fields op->replay = &cstate->replay_owner->so_replay; 12451da177e4SLinus Torvalds nfsd4_encode_replay(resp, op); 12461da177e4SLinus Torvalds status = op->status = op->replay->rp_status; 12471da177e4SLinus Torvalds } else { 12481da177e4SLinus Torvalds nfsd4_encode_operation(resp, op); 12491da177e4SLinus Torvalds status = op->status; 12501da177e4SLinus Torvalds } 12510407717dSBenny Halevy 12520407717dSBenny Halevy dprintk("nfsv4 compound op %p opcnt %d #%d: %d: status %d\n", 12530407717dSBenny Halevy args->ops, args->opcnt, resp->opcnt, op->opnum, 12540407717dSBenny Halevy be32_to_cpu(status)); 12550407717dSBenny Halevy 1256a4f1706aSJ.Bruce Fields if (cstate->replay_owner) { 12575ec094c1SJ. Bruce Fields nfs4_unlock_state(); 1258a4f1706aSJ.Bruce Fields cstate->replay_owner = NULL; 12591da177e4SLinus Torvalds } 12607e06b7f9SNeilBrown /* XXX Ugh, we need to get rid of this kind of special case: */ 12617e06b7f9SNeilBrown if (op->opnum == OP_READ && op->u.read.rd_filp) 12627e06b7f9SNeilBrown fput(op->u.read.rd_filp); 1263e2b20950SShankar Anand 1264e2b20950SShankar Anand nfsd4_increment_op_stats(op->opnum); 12651da177e4SLinus Torvalds } 12661da177e4SLinus Torvalds 1267da3846a2SAndy Adamson resp->cstate.status = status; 1268e354d571SAndy Adamson fh_put(&resp->cstate.current_fh); 1269e354d571SAndy Adamson fh_put(&resp->cstate.save_fh); 1270e354d571SAndy Adamson BUG_ON(resp->cstate.replay_owner); 12711da177e4SLinus Torvalds out: 12722f425878SAndy Adamson /* Reset deferral mechanism for RPC deferrals */ 12732f425878SAndy Adamson rqstp->rq_usedeferral = 1; 12743b12cd98SJ. Bruce Fields dprintk("nfsv4 compound returned %d\n", ntohl(status)); 12751da177e4SLinus Torvalds return status; 12761da177e4SLinus Torvalds } 12771da177e4SLinus Torvalds 127858e7b33aSMi Jinlong #define op_encode_hdr_size (2) 127958e7b33aSMi Jinlong #define op_encode_stateid_maxsz (XDR_QUADLEN(NFS4_STATEID_SIZE)) 128058e7b33aSMi Jinlong #define op_encode_verifier_maxsz (XDR_QUADLEN(NFS4_VERIFIER_SIZE)) 128158e7b33aSMi Jinlong #define op_encode_change_info_maxsz (5) 128258e7b33aSMi Jinlong #define nfs4_fattr_bitmap_maxsz (4) 128358e7b33aSMi Jinlong 128458e7b33aSMi Jinlong #define op_encode_lockowner_maxsz (1 + XDR_QUADLEN(IDMAP_NAMESZ)) 128558e7b33aSMi Jinlong #define op_encode_lock_denied_maxsz (8 + op_encode_lockowner_maxsz) 128658e7b33aSMi Jinlong 128758e7b33aSMi Jinlong #define nfs4_owner_maxsz (1 + XDR_QUADLEN(IDMAP_NAMESZ)) 128858e7b33aSMi Jinlong 128958e7b33aSMi Jinlong #define op_encode_ace_maxsz (3 + nfs4_owner_maxsz) 129058e7b33aSMi Jinlong #define op_encode_delegation_maxsz (1 + op_encode_stateid_maxsz + 1 + \ 129158e7b33aSMi Jinlong op_encode_ace_maxsz) 129258e7b33aSMi Jinlong 129358e7b33aSMi Jinlong #define op_encode_channel_attrs_maxsz (6 + 1 + 1) 129458e7b33aSMi Jinlong 129558e7b33aSMi Jinlong static inline u32 nfsd4_only_status_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 129658e7b33aSMi Jinlong { 129758e7b33aSMi Jinlong return (op_encode_hdr_size) * sizeof(__be32); 129858e7b33aSMi Jinlong } 129958e7b33aSMi Jinlong 130058e7b33aSMi Jinlong static inline u32 nfsd4_status_stateid_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 130158e7b33aSMi Jinlong { 130258e7b33aSMi Jinlong return (op_encode_hdr_size + op_encode_stateid_maxsz)* sizeof(__be32); 130358e7b33aSMi Jinlong } 130458e7b33aSMi Jinlong 130558e7b33aSMi Jinlong static inline u32 nfsd4_commit_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 130658e7b33aSMi Jinlong { 130758e7b33aSMi Jinlong return (op_encode_hdr_size + op_encode_verifier_maxsz) * sizeof(__be32); 130858e7b33aSMi Jinlong } 130958e7b33aSMi Jinlong 131058e7b33aSMi Jinlong static inline u32 nfsd4_create_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 131158e7b33aSMi Jinlong { 131258e7b33aSMi Jinlong return (op_encode_hdr_size + op_encode_change_info_maxsz 131358e7b33aSMi Jinlong + nfs4_fattr_bitmap_maxsz) * sizeof(__be32); 131458e7b33aSMi Jinlong } 131558e7b33aSMi Jinlong 131658e7b33aSMi Jinlong static inline u32 nfsd4_link_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 131758e7b33aSMi Jinlong { 131858e7b33aSMi Jinlong return (op_encode_hdr_size + op_encode_change_info_maxsz) 131958e7b33aSMi Jinlong * sizeof(__be32); 132058e7b33aSMi Jinlong } 132158e7b33aSMi Jinlong 132258e7b33aSMi Jinlong static inline u32 nfsd4_lock_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 132358e7b33aSMi Jinlong { 132458e7b33aSMi Jinlong return (op_encode_hdr_size + op_encode_lock_denied_maxsz) 132558e7b33aSMi Jinlong * sizeof(__be32); 132658e7b33aSMi Jinlong } 132758e7b33aSMi Jinlong 132858e7b33aSMi Jinlong static inline u32 nfsd4_open_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 132958e7b33aSMi Jinlong { 133058e7b33aSMi Jinlong return (op_encode_hdr_size + op_encode_stateid_maxsz 133158e7b33aSMi Jinlong + op_encode_change_info_maxsz + 1 133258e7b33aSMi Jinlong + nfs4_fattr_bitmap_maxsz 133358e7b33aSMi Jinlong + op_encode_delegation_maxsz) * sizeof(__be32); 133458e7b33aSMi Jinlong } 133558e7b33aSMi Jinlong 133658e7b33aSMi Jinlong static inline u32 nfsd4_read_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 133758e7b33aSMi Jinlong { 133858e7b33aSMi Jinlong u32 maxcount = 0, rlen = 0; 133958e7b33aSMi Jinlong 134058e7b33aSMi Jinlong maxcount = svc_max_payload(rqstp); 134158e7b33aSMi Jinlong rlen = op->u.read.rd_length; 134258e7b33aSMi Jinlong 134358e7b33aSMi Jinlong if (rlen > maxcount) 134458e7b33aSMi Jinlong rlen = maxcount; 134558e7b33aSMi Jinlong 134658e7b33aSMi Jinlong return (op_encode_hdr_size + 2) * sizeof(__be32) + rlen; 134758e7b33aSMi Jinlong } 134858e7b33aSMi Jinlong 134958e7b33aSMi Jinlong static inline u32 nfsd4_readdir_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 135058e7b33aSMi Jinlong { 135158e7b33aSMi Jinlong u32 rlen = op->u.readdir.rd_maxcount; 135258e7b33aSMi Jinlong 135358e7b33aSMi Jinlong if (rlen > PAGE_SIZE) 135458e7b33aSMi Jinlong rlen = PAGE_SIZE; 135558e7b33aSMi Jinlong 135658e7b33aSMi Jinlong return (op_encode_hdr_size + op_encode_verifier_maxsz) 135758e7b33aSMi Jinlong * sizeof(__be32) + rlen; 135858e7b33aSMi Jinlong } 135958e7b33aSMi Jinlong 136058e7b33aSMi Jinlong static inline u32 nfsd4_remove_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 136158e7b33aSMi Jinlong { 136258e7b33aSMi Jinlong return (op_encode_hdr_size + op_encode_change_info_maxsz) 136358e7b33aSMi Jinlong * sizeof(__be32); 136458e7b33aSMi Jinlong } 136558e7b33aSMi Jinlong 136658e7b33aSMi Jinlong static inline u32 nfsd4_rename_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 136758e7b33aSMi Jinlong { 136858e7b33aSMi Jinlong return (op_encode_hdr_size + op_encode_change_info_maxsz 136958e7b33aSMi Jinlong + op_encode_change_info_maxsz) * sizeof(__be32); 137058e7b33aSMi Jinlong } 137158e7b33aSMi Jinlong 137258e7b33aSMi Jinlong static inline u32 nfsd4_setattr_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 137358e7b33aSMi Jinlong { 137458e7b33aSMi Jinlong return (op_encode_hdr_size + nfs4_fattr_bitmap_maxsz) * sizeof(__be32); 137558e7b33aSMi Jinlong } 137658e7b33aSMi Jinlong 137758e7b33aSMi Jinlong static inline u32 nfsd4_setclientid_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 137858e7b33aSMi Jinlong { 137958e7b33aSMi Jinlong return (op_encode_hdr_size + 2 + 1024) * sizeof(__be32); 138058e7b33aSMi Jinlong } 138158e7b33aSMi Jinlong 138258e7b33aSMi Jinlong static inline u32 nfsd4_write_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 138358e7b33aSMi Jinlong { 138458e7b33aSMi Jinlong return (op_encode_hdr_size + op_encode_verifier_maxsz) * sizeof(__be32); 138558e7b33aSMi Jinlong } 138658e7b33aSMi Jinlong 138758e7b33aSMi Jinlong static inline u32 nfsd4_exchange_id_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 138858e7b33aSMi Jinlong { 138958e7b33aSMi Jinlong return (op_encode_hdr_size + 2 + 1 + /* eir_clientid, eir_sequenceid */\ 139058e7b33aSMi Jinlong 1 + 1 + 0 + /* eir_flags, spr_how, SP4_NONE (for now) */\ 139158e7b33aSMi Jinlong 2 + /*eir_server_owner.so_minor_id */\ 139258e7b33aSMi Jinlong /* eir_server_owner.so_major_id<> */\ 139358e7b33aSMi Jinlong XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + 1 +\ 139458e7b33aSMi Jinlong /* eir_server_scope<> */\ 139558e7b33aSMi Jinlong XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + 1 +\ 139658e7b33aSMi Jinlong 1 + /* eir_server_impl_id array length */\ 139758e7b33aSMi Jinlong 0 /* ignored eir_server_impl_id contents */) * sizeof(__be32); 139858e7b33aSMi Jinlong } 139958e7b33aSMi Jinlong 140058e7b33aSMi Jinlong static inline u32 nfsd4_bind_conn_to_session_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 140158e7b33aSMi Jinlong { 140258e7b33aSMi Jinlong return (op_encode_hdr_size + \ 140358e7b33aSMi Jinlong XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + /* bctsr_sessid */\ 140458e7b33aSMi Jinlong 2 /* bctsr_dir, use_conn_in_rdma_mode */) * sizeof(__be32); 140558e7b33aSMi Jinlong } 140658e7b33aSMi Jinlong 140758e7b33aSMi Jinlong static inline u32 nfsd4_create_session_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op) 140858e7b33aSMi Jinlong { 140958e7b33aSMi Jinlong return (op_encode_hdr_size + \ 141058e7b33aSMi Jinlong XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + /* sessionid */\ 141158e7b33aSMi Jinlong 2 + /* csr_sequence, csr_flags */\ 141258e7b33aSMi Jinlong op_encode_channel_attrs_maxsz + \ 141358e7b33aSMi Jinlong op_encode_channel_attrs_maxsz) * sizeof(__be32); 141458e7b33aSMi Jinlong } 141558e7b33aSMi Jinlong 141620766016SBenny Halevy static struct nfsd4_operation nfsd4_ops[] = { 1417b591480bSJ.Bruce Fields [OP_ACCESS] = { 1418b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_access, 1419b001a1b6SBenny Halevy .op_name = "OP_ACCESS", 1420b591480bSJ.Bruce Fields }, 1421b591480bSJ.Bruce Fields [OP_CLOSE] = { 1422b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_close, 142358e7b33aSMi Jinlong .op_flags = OP_MODIFIES_SOMETHING, 1424b001a1b6SBenny Halevy .op_name = "OP_CLOSE", 142558e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_status_stateid_rsize, 1426b591480bSJ.Bruce Fields }, 1427b591480bSJ.Bruce Fields [OP_COMMIT] = { 1428b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_commit, 142958e7b33aSMi Jinlong .op_flags = OP_MODIFIES_SOMETHING, 1430b001a1b6SBenny Halevy .op_name = "OP_COMMIT", 143158e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_commit_rsize, 1432b591480bSJ.Bruce Fields }, 1433b591480bSJ.Bruce Fields [OP_CREATE] = { 1434b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_create, 1435c856694eSJ. Bruce Fields .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME, 1436b001a1b6SBenny Halevy .op_name = "OP_CREATE", 143758e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_create_rsize, 1438b591480bSJ.Bruce Fields }, 1439b591480bSJ.Bruce Fields [OP_DELEGRETURN] = { 1440b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_delegreturn, 144158e7b33aSMi Jinlong .op_flags = OP_MODIFIES_SOMETHING, 1442b001a1b6SBenny Halevy .op_name = "OP_DELEGRETURN", 144358e7b33aSMi Jinlong .op_rsize_bop = nfsd4_only_status_rsize, 1444b591480bSJ.Bruce Fields }, 1445b591480bSJ.Bruce Fields [OP_GETATTR] = { 1446b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_getattr, 1447eeac294eSJ.Bruce Fields .op_flags = ALLOWED_ON_ABSENT_FS, 1448b001a1b6SBenny Halevy .op_name = "OP_GETATTR", 1449b591480bSJ.Bruce Fields }, 1450b591480bSJ.Bruce Fields [OP_GETFH] = { 1451b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_getfh, 1452b001a1b6SBenny Halevy .op_name = "OP_GETFH", 1453b591480bSJ.Bruce Fields }, 1454b591480bSJ.Bruce Fields [OP_LINK] = { 1455b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_link, 1456c856694eSJ. Bruce Fields .op_flags = ALLOWED_ON_ABSENT_FS | OP_MODIFIES_SOMETHING 1457c856694eSJ. Bruce Fields | OP_CACHEME, 1458b001a1b6SBenny Halevy .op_name = "OP_LINK", 145958e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_link_rsize, 1460b591480bSJ.Bruce Fields }, 1461b591480bSJ.Bruce Fields [OP_LOCK] = { 1462b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_lock, 146358e7b33aSMi Jinlong .op_flags = OP_MODIFIES_SOMETHING, 1464b001a1b6SBenny Halevy .op_name = "OP_LOCK", 146558e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_lock_rsize, 1466b591480bSJ.Bruce Fields }, 1467b591480bSJ.Bruce Fields [OP_LOCKT] = { 1468b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_lockt, 1469b001a1b6SBenny Halevy .op_name = "OP_LOCKT", 1470b591480bSJ.Bruce Fields }, 1471b591480bSJ.Bruce Fields [OP_LOCKU] = { 1472b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_locku, 147358e7b33aSMi Jinlong .op_flags = OP_MODIFIES_SOMETHING, 1474b001a1b6SBenny Halevy .op_name = "OP_LOCKU", 147558e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_status_stateid_rsize, 1476b591480bSJ.Bruce Fields }, 1477b591480bSJ.Bruce Fields [OP_LOOKUP] = { 1478b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_lookup, 147968d93184SJ. Bruce Fields .op_flags = OP_HANDLES_WRONGSEC, 1480b001a1b6SBenny Halevy .op_name = "OP_LOOKUP", 1481b591480bSJ.Bruce Fields }, 1482b591480bSJ.Bruce Fields [OP_LOOKUPP] = { 1483b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_lookupp, 148468d93184SJ. Bruce Fields .op_flags = OP_HANDLES_WRONGSEC, 1485b001a1b6SBenny Halevy .op_name = "OP_LOOKUPP", 1486b591480bSJ.Bruce Fields }, 1487b591480bSJ.Bruce Fields [OP_NVERIFY] = { 1488b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_nverify, 1489b001a1b6SBenny Halevy .op_name = "OP_NVERIFY", 1490b591480bSJ.Bruce Fields }, 1491b591480bSJ.Bruce Fields [OP_OPEN] = { 1492b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_open, 149358e7b33aSMi Jinlong .op_flags = OP_HANDLES_WRONGSEC | OP_MODIFIES_SOMETHING, 1494b001a1b6SBenny Halevy .op_name = "OP_OPEN", 149558e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_open_rsize, 1496b591480bSJ.Bruce Fields }, 1497b591480bSJ.Bruce Fields [OP_OPEN_CONFIRM] = { 1498b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_open_confirm, 149958e7b33aSMi Jinlong .op_flags = OP_MODIFIES_SOMETHING, 1500b001a1b6SBenny Halevy .op_name = "OP_OPEN_CONFIRM", 150158e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_status_stateid_rsize, 1502b591480bSJ.Bruce Fields }, 1503b591480bSJ.Bruce Fields [OP_OPEN_DOWNGRADE] = { 1504b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_open_downgrade, 150558e7b33aSMi Jinlong .op_flags = OP_MODIFIES_SOMETHING, 1506b001a1b6SBenny Halevy .op_name = "OP_OPEN_DOWNGRADE", 150758e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_status_stateid_rsize, 1508b591480bSJ.Bruce Fields }, 1509b591480bSJ.Bruce Fields [OP_PUTFH] = { 1510b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_putfh, 151168d93184SJ. Bruce Fields .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS 151258e7b33aSMi Jinlong | OP_IS_PUTFH_LIKE | OP_MODIFIES_SOMETHING, 1513b001a1b6SBenny Halevy .op_name = "OP_PUTFH", 151458e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize, 1515b591480bSJ.Bruce Fields }, 1516eeac294eSJ.Bruce Fields [OP_PUTPUBFH] = { 1517a1c8c4d1SJ. Bruce Fields .op_func = (nfsd4op_func)nfsd4_putrootfh, 151868d93184SJ. Bruce Fields .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS 151958e7b33aSMi Jinlong | OP_IS_PUTFH_LIKE | OP_MODIFIES_SOMETHING, 1520b001a1b6SBenny Halevy .op_name = "OP_PUTPUBFH", 152158e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize, 1522eeac294eSJ.Bruce Fields }, 1523b591480bSJ.Bruce Fields [OP_PUTROOTFH] = { 1524b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_putrootfh, 152568d93184SJ. Bruce Fields .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS 152658e7b33aSMi Jinlong | OP_IS_PUTFH_LIKE | OP_MODIFIES_SOMETHING, 1527b001a1b6SBenny Halevy .op_name = "OP_PUTROOTFH", 152858e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize, 1529b591480bSJ.Bruce Fields }, 1530b591480bSJ.Bruce Fields [OP_READ] = { 1531b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_read, 153258e7b33aSMi Jinlong .op_flags = OP_MODIFIES_SOMETHING, 1533b001a1b6SBenny Halevy .op_name = "OP_READ", 153458e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_read_rsize, 1535b591480bSJ.Bruce Fields }, 1536b591480bSJ.Bruce Fields [OP_READDIR] = { 1537b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_readdir, 153858e7b33aSMi Jinlong .op_flags = OP_MODIFIES_SOMETHING, 1539b001a1b6SBenny Halevy .op_name = "OP_READDIR", 154058e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_readdir_rsize, 1541b591480bSJ.Bruce Fields }, 1542b591480bSJ.Bruce Fields [OP_READLINK] = { 1543b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_readlink, 1544b001a1b6SBenny Halevy .op_name = "OP_READLINK", 1545b591480bSJ.Bruce Fields }, 1546b591480bSJ.Bruce Fields [OP_REMOVE] = { 1547b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_remove, 1548c856694eSJ. Bruce Fields .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME, 1549b001a1b6SBenny Halevy .op_name = "OP_REMOVE", 155058e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_remove_rsize, 1551b591480bSJ.Bruce Fields }, 1552b591480bSJ.Bruce Fields [OP_RENAME] = { 1553b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_rename, 1554c856694eSJ. Bruce Fields .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME, 155558e7b33aSMi Jinlong .op_name = "OP_RENAME", 155658e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_rename_rsize, 1557b591480bSJ.Bruce Fields }, 1558b591480bSJ.Bruce Fields [OP_RENEW] = { 1559b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_renew, 156058e7b33aSMi Jinlong .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS 156158e7b33aSMi Jinlong | OP_MODIFIES_SOMETHING, 1562b001a1b6SBenny Halevy .op_name = "OP_RENEW", 156358e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize, 156458e7b33aSMi Jinlong 1565b591480bSJ.Bruce Fields }, 1566b591480bSJ.Bruce Fields [OP_RESTOREFH] = { 1567b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_restorefh, 156868d93184SJ. Bruce Fields .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS 156958e7b33aSMi Jinlong | OP_IS_PUTFH_LIKE | OP_MODIFIES_SOMETHING, 1570b001a1b6SBenny Halevy .op_name = "OP_RESTOREFH", 157158e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize, 1572b591480bSJ.Bruce Fields }, 1573b591480bSJ.Bruce Fields [OP_SAVEFH] = { 1574b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_savefh, 157558e7b33aSMi Jinlong .op_flags = OP_HANDLES_WRONGSEC | OP_MODIFIES_SOMETHING, 1576b001a1b6SBenny Halevy .op_name = "OP_SAVEFH", 157758e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize, 1578b591480bSJ.Bruce Fields }, 1579dcb488a3SAndy Adamson [OP_SECINFO] = { 1580dcb488a3SAndy Adamson .op_func = (nfsd4op_func)nfsd4_secinfo, 158168d93184SJ. Bruce Fields .op_flags = OP_HANDLES_WRONGSEC, 1582b001a1b6SBenny Halevy .op_name = "OP_SECINFO", 1583dcb488a3SAndy Adamson }, 1584b591480bSJ.Bruce Fields [OP_SETATTR] = { 1585b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_setattr, 1586b001a1b6SBenny Halevy .op_name = "OP_SETATTR", 1587c856694eSJ. Bruce Fields .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME, 158858e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_setattr_rsize, 1589b591480bSJ.Bruce Fields }, 1590b591480bSJ.Bruce Fields [OP_SETCLIENTID] = { 1591b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_setclientid, 159258e7b33aSMi Jinlong .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS 1593c856694eSJ. Bruce Fields | OP_MODIFIES_SOMETHING | OP_CACHEME, 1594b001a1b6SBenny Halevy .op_name = "OP_SETCLIENTID", 159558e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_setclientid_rsize, 1596b591480bSJ.Bruce Fields }, 1597b591480bSJ.Bruce Fields [OP_SETCLIENTID_CONFIRM] = { 1598b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_setclientid_confirm, 159958e7b33aSMi Jinlong .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS 1600c856694eSJ. Bruce Fields | OP_MODIFIES_SOMETHING | OP_CACHEME, 1601b001a1b6SBenny Halevy .op_name = "OP_SETCLIENTID_CONFIRM", 160258e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize, 1603b591480bSJ.Bruce Fields }, 1604b591480bSJ.Bruce Fields [OP_VERIFY] = { 1605b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_verify, 1606b001a1b6SBenny Halevy .op_name = "OP_VERIFY", 1607b591480bSJ.Bruce Fields }, 1608b591480bSJ.Bruce Fields [OP_WRITE] = { 1609b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_write, 1610c856694eSJ. Bruce Fields .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME, 1611b001a1b6SBenny Halevy .op_name = "OP_WRITE", 161258e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_write_rsize, 1613b591480bSJ.Bruce Fields }, 1614b591480bSJ.Bruce Fields [OP_RELEASE_LOCKOWNER] = { 1615b591480bSJ.Bruce Fields .op_func = (nfsd4op_func)nfsd4_release_lockowner, 161658e7b33aSMi Jinlong .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS 161758e7b33aSMi Jinlong | OP_MODIFIES_SOMETHING, 1618b001a1b6SBenny Halevy .op_name = "OP_RELEASE_LOCKOWNER", 161958e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize, 1620b591480bSJ.Bruce Fields }, 1621069b6ad4SAndy Adamson 1622069b6ad4SAndy Adamson /* NFSv4.1 operations */ 1623069b6ad4SAndy Adamson [OP_EXCHANGE_ID] = { 1624069b6ad4SAndy Adamson .op_func = (nfsd4op_func)nfsd4_exchange_id, 162558e7b33aSMi Jinlong .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP 162658e7b33aSMi Jinlong | OP_MODIFIES_SOMETHING, 1627069b6ad4SAndy Adamson .op_name = "OP_EXCHANGE_ID", 162858e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_exchange_id_rsize, 1629069b6ad4SAndy Adamson }, 16301d1bc8f2SJ. Bruce Fields [OP_BIND_CONN_TO_SESSION] = { 16311d1bc8f2SJ. Bruce Fields .op_func = (nfsd4op_func)nfsd4_bind_conn_to_session, 163258e7b33aSMi Jinlong .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP 163358e7b33aSMi Jinlong | OP_MODIFIES_SOMETHING, 16341d1bc8f2SJ. Bruce Fields .op_name = "OP_BIND_CONN_TO_SESSION", 163558e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_bind_conn_to_session_rsize, 16361d1bc8f2SJ. Bruce Fields }, 1637069b6ad4SAndy Adamson [OP_CREATE_SESSION] = { 1638069b6ad4SAndy Adamson .op_func = (nfsd4op_func)nfsd4_create_session, 163958e7b33aSMi Jinlong .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP 164058e7b33aSMi Jinlong | OP_MODIFIES_SOMETHING, 1641069b6ad4SAndy Adamson .op_name = "OP_CREATE_SESSION", 164258e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_create_session_rsize, 1643069b6ad4SAndy Adamson }, 1644069b6ad4SAndy Adamson [OP_DESTROY_SESSION] = { 1645069b6ad4SAndy Adamson .op_func = (nfsd4op_func)nfsd4_destroy_session, 164658e7b33aSMi Jinlong .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP 164758e7b33aSMi Jinlong | OP_MODIFIES_SOMETHING, 1648069b6ad4SAndy Adamson .op_name = "OP_DESTROY_SESSION", 164958e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize, 1650069b6ad4SAndy Adamson }, 1651069b6ad4SAndy Adamson [OP_SEQUENCE] = { 1652069b6ad4SAndy Adamson .op_func = (nfsd4op_func)nfsd4_sequence, 1653f9bb94c4SAndy Adamson .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP, 1654069b6ad4SAndy Adamson .op_name = "OP_SEQUENCE", 1655069b6ad4SAndy Adamson }, 1656094b5d74SBenny Halevy [OP_DESTROY_CLIENTID] = { 1657094b5d74SBenny Halevy .op_func = NULL, 165858e7b33aSMi Jinlong .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP 165958e7b33aSMi Jinlong | OP_MODIFIES_SOMETHING, 1660094b5d74SBenny Halevy .op_name = "OP_DESTROY_CLIENTID", 166158e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize, 1662094b5d74SBenny Halevy }, 16634dc6ec00SJ. Bruce Fields [OP_RECLAIM_COMPLETE] = { 16644dc6ec00SJ. Bruce Fields .op_func = (nfsd4op_func)nfsd4_reclaim_complete, 166558e7b33aSMi Jinlong .op_flags = ALLOWED_WITHOUT_FH | OP_MODIFIES_SOMETHING, 16664dc6ec00SJ. Bruce Fields .op_name = "OP_RECLAIM_COMPLETE", 166758e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize, 16684dc6ec00SJ. Bruce Fields }, 166904f4ad16SJ. Bruce Fields [OP_SECINFO_NO_NAME] = { 167004f4ad16SJ. Bruce Fields .op_func = (nfsd4op_func)nfsd4_secinfo_no_name, 167168d93184SJ. Bruce Fields .op_flags = OP_HANDLES_WRONGSEC, 167204f4ad16SJ. Bruce Fields .op_name = "OP_SECINFO_NO_NAME", 167304f4ad16SJ. Bruce Fields }, 167417456804SBryan Schumaker [OP_TEST_STATEID] = { 167517456804SBryan Schumaker .op_func = (nfsd4op_func)nfsd4_test_stateid, 167617456804SBryan Schumaker .op_flags = ALLOWED_WITHOUT_FH, 167717456804SBryan Schumaker .op_name = "OP_TEST_STATEID", 167817456804SBryan Schumaker }, 1679e1ca12dfSBryan Schumaker [OP_FREE_STATEID] = { 1680e1ca12dfSBryan Schumaker .op_func = (nfsd4op_func)nfsd4_free_stateid, 168158e7b33aSMi Jinlong .op_flags = ALLOWED_WITHOUT_FH | OP_MODIFIES_SOMETHING, 1682e1ca12dfSBryan Schumaker .op_name = "OP_FREE_STATEID", 168358e7b33aSMi Jinlong .op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize, 1684e1ca12dfSBryan Schumaker }, 1685b591480bSJ.Bruce Fields }; 1686b591480bSJ.Bruce Fields 1687f1c7f79bSAdrian Bunk static const char *nfsd4_op_name(unsigned opnum) 1688b001a1b6SBenny Halevy { 1689b001a1b6SBenny Halevy if (opnum < ARRAY_SIZE(nfsd4_ops)) 1690b001a1b6SBenny Halevy return nfsd4_ops[opnum].op_name; 1691b001a1b6SBenny Halevy return "unknown_operation"; 1692b001a1b6SBenny Halevy } 1693b001a1b6SBenny Halevy 16941da177e4SLinus Torvalds #define nfsd4_voidres nfsd4_voidargs 16951da177e4SLinus Torvalds struct nfsd4_voidargs { int dummy; }; 16961da177e4SLinus Torvalds 16971da177e4SLinus Torvalds static struct svc_procedure nfsd_procedures4[2] = { 16980a93a47fSYu Zhiguo [NFSPROC4_NULL] = { 16990a93a47fSYu Zhiguo .pc_func = (svc_procfunc) nfsd4_proc_null, 17000a93a47fSYu Zhiguo .pc_encode = (kxdrproc_t) nfs4svc_encode_voidres, 17010a93a47fSYu Zhiguo .pc_argsize = sizeof(struct nfsd4_voidargs), 17020a93a47fSYu Zhiguo .pc_ressize = sizeof(struct nfsd4_voidres), 17030a93a47fSYu Zhiguo .pc_cachetype = RC_NOCACHE, 17040a93a47fSYu Zhiguo .pc_xdrressize = 1, 17050a93a47fSYu Zhiguo }, 17060a93a47fSYu Zhiguo [NFSPROC4_COMPOUND] = { 17070a93a47fSYu Zhiguo .pc_func = (svc_procfunc) nfsd4_proc_compound, 17080a93a47fSYu Zhiguo .pc_decode = (kxdrproc_t) nfs4svc_decode_compoundargs, 17090a93a47fSYu Zhiguo .pc_encode = (kxdrproc_t) nfs4svc_encode_compoundres, 17100a93a47fSYu Zhiguo .pc_argsize = sizeof(struct nfsd4_compoundargs), 17110a93a47fSYu Zhiguo .pc_ressize = sizeof(struct nfsd4_compoundres), 17123e98abffSJ. Bruce Fields .pc_release = nfsd4_release_compoundargs, 17130a93a47fSYu Zhiguo .pc_cachetype = RC_NOCACHE, 17140a93a47fSYu Zhiguo .pc_xdrressize = NFSD_BUFSIZE/4, 17150a93a47fSYu Zhiguo }, 17161da177e4SLinus Torvalds }; 17171da177e4SLinus Torvalds 17181da177e4SLinus Torvalds struct svc_version nfsd_version4 = { 17191da177e4SLinus Torvalds .vs_vers = 4, 17201da177e4SLinus Torvalds .vs_nproc = 2, 17211da177e4SLinus Torvalds .vs_proc = nfsd_procedures4, 17221da177e4SLinus Torvalds .vs_dispatch = nfsd_dispatch, 17231da177e4SLinus Torvalds .vs_xdrsize = NFS4_SVC_XDRSIZE, 17241da177e4SLinus Torvalds }; 17251da177e4SLinus Torvalds 17261da177e4SLinus Torvalds /* 17271da177e4SLinus Torvalds * Local variables: 17281da177e4SLinus Torvalds * c-basic-offset: 8 17291da177e4SLinus Torvalds * End: 17301da177e4SLinus Torvalds */ 1731