11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * Copyright (c) 2001 The Regents of the University of Michigan. 31da177e4SLinus Torvalds * All rights reserved. 41da177e4SLinus Torvalds * 51da177e4SLinus Torvalds * Kendrick Smith <kmsmith@umich.edu> 61da177e4SLinus Torvalds * Andy Adamson <kandros@umich.edu> 71da177e4SLinus Torvalds * 81da177e4SLinus Torvalds * Redistribution and use in source and binary forms, with or without 91da177e4SLinus Torvalds * modification, are permitted provided that the following conditions 101da177e4SLinus Torvalds * are met: 111da177e4SLinus Torvalds * 121da177e4SLinus Torvalds * 1. Redistributions of source code must retain the above copyright 131da177e4SLinus Torvalds * notice, this list of conditions and the following disclaimer. 141da177e4SLinus Torvalds * 2. Redistributions in binary form must reproduce the above copyright 151da177e4SLinus Torvalds * notice, this list of conditions and the following disclaimer in the 161da177e4SLinus Torvalds * documentation and/or other materials provided with the distribution. 171da177e4SLinus Torvalds * 3. Neither the name of the University nor the names of its 181da177e4SLinus Torvalds * contributors may be used to endorse or promote products derived 191da177e4SLinus Torvalds * from this software without specific prior written permission. 201da177e4SLinus Torvalds * 211da177e4SLinus Torvalds * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED 221da177e4SLinus Torvalds * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 231da177e4SLinus Torvalds * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 241da177e4SLinus Torvalds * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 251da177e4SLinus Torvalds * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 261da177e4SLinus Torvalds * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 271da177e4SLinus Torvalds * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR 281da177e4SLinus Torvalds * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 291da177e4SLinus Torvalds * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 301da177e4SLinus Torvalds * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 311da177e4SLinus Torvalds * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 321da177e4SLinus Torvalds * 331da177e4SLinus Torvalds */ 341da177e4SLinus Torvalds 35aceaf78dSDave Hansen #include <linux/file.h> 36b89f4321SArnd Bergmann #include <linux/fs.h> 375a0e3ad6STejun Heo #include <linux/slab.h> 380964a3d3SNeilBrown #include <linux/namei.h> 39c2f1a551SMeelap Shah #include <linux/swap.h> 4017456804SBryan Schumaker #include <linux/pagemap.h> 4168e76ad0SOlga Kornievskaia #include <linux/sunrpc/svcauth_gss.h> 42363168b4SJeff Layton #include <linux/sunrpc/clnt.h> 439a74af21SBoaz Harrosh #include "xdr4.h" 440a3adadeSJ. Bruce Fields #include "vfs.h" 451da177e4SLinus Torvalds 461da177e4SLinus Torvalds #define NFSDDBG_FACILITY NFSDDBG_PROC 471da177e4SLinus Torvalds 481da177e4SLinus Torvalds /* Globals */ 49cf07d2eaSJ. Bruce Fields time_t nfsd4_lease = 90; /* default lease time */ 50efc4bb4fSJ. Bruce Fields time_t nfsd4_grace = 90; 51fd39ca9aSNeilBrown static time_t boot_time; 521da177e4SLinus Torvalds static u32 current_ownerid = 1; 531da177e4SLinus Torvalds static u32 current_fileid = 1; 541da177e4SLinus Torvalds static u32 current_delegid = 1; 55fd39ca9aSNeilBrown static stateid_t zerostateid; /* bits all 0 */ 56fd39ca9aSNeilBrown static stateid_t onestateid; /* bits all 1 */ 57ec6b5d7bSAndy Adamson static u64 current_sessionid = 1; 58fd39ca9aSNeilBrown 59fd39ca9aSNeilBrown #define ZERO_STATEID(stateid) (!memcmp((stateid), &zerostateid, sizeof(stateid_t))) 60fd39ca9aSNeilBrown #define ONE_STATEID(stateid) (!memcmp((stateid), &onestateid, sizeof(stateid_t))) 611da177e4SLinus Torvalds 621da177e4SLinus Torvalds /* forward declarations */ 63fe0750e5SJ. Bruce Fields static int check_for_locks(struct nfs4_file *filp, struct nfs4_lockowner *lowner); 641da177e4SLinus Torvalds 658b671b80SJ. Bruce Fields /* Locking: */ 668b671b80SJ. Bruce Fields 678b671b80SJ. Bruce Fields /* Currently used for almost all code touching nfsv4 state: */ 68353ab6e9SIngo Molnar static DEFINE_MUTEX(client_mutex); 691da177e4SLinus Torvalds 708b671b80SJ. Bruce Fields /* 718b671b80SJ. Bruce Fields * Currently used for the del_recall_lru and file hash table. In an 728b671b80SJ. Bruce Fields * effort to decrease the scope of the client_mutex, this spinlock may 738b671b80SJ. Bruce Fields * eventually cover more: 748b671b80SJ. Bruce Fields */ 758b671b80SJ. Bruce Fields static DEFINE_SPINLOCK(recall_lock); 768b671b80SJ. Bruce Fields 77fe0750e5SJ. Bruce Fields static struct kmem_cache *openowner_slab = NULL; 78fe0750e5SJ. Bruce Fields static struct kmem_cache *lockowner_slab = NULL; 79e18b890bSChristoph Lameter static struct kmem_cache *file_slab = NULL; 80e18b890bSChristoph Lameter static struct kmem_cache *stateid_slab = NULL; 81e18b890bSChristoph Lameter static struct kmem_cache *deleg_slab = NULL; 82e60d4398SNeilBrown 831da177e4SLinus Torvalds void 841da177e4SLinus Torvalds nfs4_lock_state(void) 851da177e4SLinus Torvalds { 86353ab6e9SIngo Molnar mutex_lock(&client_mutex); 871da177e4SLinus Torvalds } 881da177e4SLinus Torvalds 891da177e4SLinus Torvalds void 901da177e4SLinus Torvalds nfs4_unlock_state(void) 911da177e4SLinus Torvalds { 92353ab6e9SIngo Molnar mutex_unlock(&client_mutex); 931da177e4SLinus Torvalds } 941da177e4SLinus Torvalds 951da177e4SLinus Torvalds static inline u32 961da177e4SLinus Torvalds opaque_hashval(const void *ptr, int nbytes) 971da177e4SLinus Torvalds { 981da177e4SLinus Torvalds unsigned char *cptr = (unsigned char *) ptr; 991da177e4SLinus Torvalds 1001da177e4SLinus Torvalds u32 x = 0; 1011da177e4SLinus Torvalds while (nbytes--) { 1021da177e4SLinus Torvalds x *= 37; 1031da177e4SLinus Torvalds x += *cptr++; 1041da177e4SLinus Torvalds } 1051da177e4SLinus Torvalds return x; 1061da177e4SLinus Torvalds } 1071da177e4SLinus Torvalds 1081da177e4SLinus Torvalds static struct list_head del_recall_lru; 1091da177e4SLinus Torvalds 11013cd2184SNeilBrown static inline void 11113cd2184SNeilBrown put_nfs4_file(struct nfs4_file *fi) 11213cd2184SNeilBrown { 1138b671b80SJ. Bruce Fields if (atomic_dec_and_lock(&fi->fi_ref, &recall_lock)) { 1148b671b80SJ. Bruce Fields list_del(&fi->fi_hash); 1158b671b80SJ. Bruce Fields spin_unlock(&recall_lock); 1168b671b80SJ. Bruce Fields iput(fi->fi_inode); 1178b671b80SJ. Bruce Fields kmem_cache_free(file_slab, fi); 1188b671b80SJ. Bruce Fields } 11913cd2184SNeilBrown } 12013cd2184SNeilBrown 12113cd2184SNeilBrown static inline void 12213cd2184SNeilBrown get_nfs4_file(struct nfs4_file *fi) 12313cd2184SNeilBrown { 1248b671b80SJ. Bruce Fields atomic_inc(&fi->fi_ref); 12513cd2184SNeilBrown } 12613cd2184SNeilBrown 127ef0f3390SNeilBrown static int num_delegations; 128c2f1a551SMeelap Shah unsigned int max_delegations; 129ef0f3390SNeilBrown 130ef0f3390SNeilBrown /* 131ef0f3390SNeilBrown * Open owner state (share locks) 132ef0f3390SNeilBrown */ 133ef0f3390SNeilBrown 134506f275fSJ. Bruce Fields /* hash tables for open owners */ 135506f275fSJ. Bruce Fields #define OPEN_OWNER_HASH_BITS 8 136506f275fSJ. Bruce Fields #define OPEN_OWNER_HASH_SIZE (1 << OPEN_OWNER_HASH_BITS) 137506f275fSJ. Bruce Fields #define OPEN_OWNER_HASH_MASK (OPEN_OWNER_HASH_SIZE - 1) 138ef0f3390SNeilBrown 139506f275fSJ. Bruce Fields static unsigned int open_ownerid_hashval(const u32 id) 140ddc04c41SJ. Bruce Fields { 141506f275fSJ. Bruce Fields return id & OPEN_OWNER_HASH_MASK; 142ddc04c41SJ. Bruce Fields } 143ddc04c41SJ. Bruce Fields 144506f275fSJ. Bruce Fields static unsigned int open_ownerstr_hashval(u32 clientid, struct xdr_netobj *ownername) 145ddc04c41SJ. Bruce Fields { 146ddc04c41SJ. Bruce Fields unsigned int ret; 147ddc04c41SJ. Bruce Fields 148ddc04c41SJ. Bruce Fields ret = opaque_hashval(ownername->data, ownername->len); 149ddc04c41SJ. Bruce Fields ret += clientid; 150506f275fSJ. Bruce Fields return ret & OPEN_OWNER_HASH_MASK; 151ddc04c41SJ. Bruce Fields } 152ef0f3390SNeilBrown 153506f275fSJ. Bruce Fields static struct list_head open_ownerid_hashtbl[OPEN_OWNER_HASH_SIZE]; 154506f275fSJ. Bruce Fields static struct list_head open_ownerstr_hashtbl[OPEN_OWNER_HASH_SIZE]; 155ef0f3390SNeilBrown 156ef0f3390SNeilBrown /* hash table for nfs4_file */ 157ef0f3390SNeilBrown #define FILE_HASH_BITS 8 158ef0f3390SNeilBrown #define FILE_HASH_SIZE (1 << FILE_HASH_BITS) 15935079582SShan Wei 160dcef0413SJ. Bruce Fields /* hash table for (open)nfs4_ol_stateid */ 161ef0f3390SNeilBrown #define STATEID_HASH_BITS 10 162ef0f3390SNeilBrown #define STATEID_HASH_SIZE (1 << STATEID_HASH_BITS) 163ef0f3390SNeilBrown #define STATEID_HASH_MASK (STATEID_HASH_SIZE - 1) 164ef0f3390SNeilBrown 165ddc04c41SJ. Bruce Fields static unsigned int file_hashval(struct inode *ino) 166ddc04c41SJ. Bruce Fields { 167ddc04c41SJ. Bruce Fields /* XXX: why are we hashing on inode pointer, anyway? */ 168ddc04c41SJ. Bruce Fields return hash_ptr(ino, FILE_HASH_BITS); 169ddc04c41SJ. Bruce Fields } 170ddc04c41SJ. Bruce Fields 171ddc04c41SJ. Bruce Fields static unsigned int stateid_hashval(u32 owner_id, u32 file_id) 172ddc04c41SJ. Bruce Fields { 173ddc04c41SJ. Bruce Fields return (owner_id + file_id) & STATEID_HASH_MASK; 174ddc04c41SJ. Bruce Fields } 175ef0f3390SNeilBrown 176ef0f3390SNeilBrown static struct list_head file_hashtbl[FILE_HASH_SIZE]; 177ef0f3390SNeilBrown static struct list_head stateid_hashtbl[STATEID_HASH_SIZE]; 178ef0f3390SNeilBrown 179998db52cSJ. Bruce Fields static void __nfs4_file_get_access(struct nfs4_file *fp, int oflag) 180f9d7562fSJ. Bruce Fields { 181f9d7562fSJ. Bruce Fields BUG_ON(!(fp->fi_fds[oflag] || fp->fi_fds[O_RDWR])); 182f9d7562fSJ. Bruce Fields atomic_inc(&fp->fi_access[oflag]); 183f9d7562fSJ. Bruce Fields } 184f9d7562fSJ. Bruce Fields 185998db52cSJ. Bruce Fields static void nfs4_file_get_access(struct nfs4_file *fp, int oflag) 186998db52cSJ. Bruce Fields { 187998db52cSJ. Bruce Fields if (oflag == O_RDWR) { 188998db52cSJ. Bruce Fields __nfs4_file_get_access(fp, O_RDONLY); 189998db52cSJ. Bruce Fields __nfs4_file_get_access(fp, O_WRONLY); 190998db52cSJ. Bruce Fields } else 191998db52cSJ. Bruce Fields __nfs4_file_get_access(fp, oflag); 192998db52cSJ. Bruce Fields } 193998db52cSJ. Bruce Fields 194998db52cSJ. Bruce Fields static void nfs4_file_put_fd(struct nfs4_file *fp, int oflag) 195f9d7562fSJ. Bruce Fields { 196f9d7562fSJ. Bruce Fields if (fp->fi_fds[oflag]) { 197f9d7562fSJ. Bruce Fields fput(fp->fi_fds[oflag]); 198f9d7562fSJ. Bruce Fields fp->fi_fds[oflag] = NULL; 199f9d7562fSJ. Bruce Fields } 200f9d7562fSJ. Bruce Fields } 201f9d7562fSJ. Bruce Fields 202998db52cSJ. Bruce Fields static void __nfs4_file_put_access(struct nfs4_file *fp, int oflag) 203f9d7562fSJ. Bruce Fields { 204f9d7562fSJ. Bruce Fields if (atomic_dec_and_test(&fp->fi_access[oflag])) { 205f9d7562fSJ. Bruce Fields nfs4_file_put_fd(fp, O_RDWR); 206f9d7562fSJ. Bruce Fields nfs4_file_put_fd(fp, oflag); 207f9d7562fSJ. Bruce Fields } 208f9d7562fSJ. Bruce Fields } 209f9d7562fSJ. Bruce Fields 210998db52cSJ. Bruce Fields static void nfs4_file_put_access(struct nfs4_file *fp, int oflag) 211998db52cSJ. Bruce Fields { 212998db52cSJ. Bruce Fields if (oflag == O_RDWR) { 213998db52cSJ. Bruce Fields __nfs4_file_put_access(fp, O_RDONLY); 214998db52cSJ. Bruce Fields __nfs4_file_put_access(fp, O_WRONLY); 215998db52cSJ. Bruce Fields } else 216998db52cSJ. Bruce Fields __nfs4_file_put_access(fp, oflag); 217998db52cSJ. Bruce Fields } 218998db52cSJ. Bruce Fields 21936d44c60SJ. Bruce Fields static inline void hash_stid(struct nfs4_stid *stid) 22036d44c60SJ. Bruce Fields { 22136d44c60SJ. Bruce Fields stateid_t *s = &stid->sc_stateid; 22236d44c60SJ. Bruce Fields unsigned int hashval; 22336d44c60SJ. Bruce Fields 22436d44c60SJ. Bruce Fields hashval = stateid_hashval(s->si_stateownerid, s->si_fileid); 22536d44c60SJ. Bruce Fields list_add(&stid->sc_hash, &stateid_hashtbl[hashval]); 22636d44c60SJ. Bruce Fields } 22736d44c60SJ. Bruce Fields 2281da177e4SLinus Torvalds static struct nfs4_delegation * 229dcef0413SJ. Bruce Fields alloc_init_deleg(struct nfs4_client *clp, struct nfs4_ol_stateid *stp, struct svc_fh *current_fh, u32 type) 2301da177e4SLinus Torvalds { 2311da177e4SLinus Torvalds struct nfs4_delegation *dp; 2321da177e4SLinus Torvalds struct nfs4_file *fp = stp->st_file; 2331da177e4SLinus Torvalds 2341da177e4SLinus Torvalds dprintk("NFSD alloc_init_deleg\n"); 235c3e48080SJ. Bruce Fields /* 236c3e48080SJ. Bruce Fields * Major work on the lease subsystem (for example, to support 237c3e48080SJ. Bruce Fields * calbacks on stat) will be required before we can support 238c3e48080SJ. Bruce Fields * write delegations properly. 239c3e48080SJ. Bruce Fields */ 240c3e48080SJ. Bruce Fields if (type != NFS4_OPEN_DELEGATE_READ) 241c3e48080SJ. Bruce Fields return NULL; 24247f9940cSMeelap Shah if (fp->fi_had_conflict) 24347f9940cSMeelap Shah return NULL; 244c2f1a551SMeelap Shah if (num_delegations > max_delegations) 245ef0f3390SNeilBrown return NULL; 2465b2d21c1SNeilBrown dp = kmem_cache_alloc(deleg_slab, GFP_KERNEL); 2475b2d21c1SNeilBrown if (dp == NULL) 2481da177e4SLinus Torvalds return dp; 249ef0f3390SNeilBrown num_delegations++; 250ea1da636SNeilBrown INIT_LIST_HEAD(&dp->dl_perfile); 251ea1da636SNeilBrown INIT_LIST_HEAD(&dp->dl_perclnt); 2521da177e4SLinus Torvalds INIT_LIST_HEAD(&dp->dl_recall_lru); 2531da177e4SLinus Torvalds dp->dl_client = clp; 25413cd2184SNeilBrown get_nfs4_file(fp); 2551da177e4SLinus Torvalds dp->dl_file = fp; 2561da177e4SLinus Torvalds dp->dl_type = type; 257f459e453SJ. Bruce Fields dp->dl_stid.sc_type = NFS4_DELEG_STID; 258d5477a8dSJ. Bruce Fields dp->dl_stid.sc_stateid.si_boot = boot_time; 259d5477a8dSJ. Bruce Fields dp->dl_stid.sc_stateid.si_stateownerid = current_delegid++; 260d5477a8dSJ. Bruce Fields dp->dl_stid.sc_stateid.si_fileid = 0; 261d5477a8dSJ. Bruce Fields dp->dl_stid.sc_stateid.si_generation = 1; 262f459e453SJ. Bruce Fields hash_stid(&dp->dl_stid); 2636c02eaa1SJ. Bruce Fields fh_copy_shallow(&dp->dl_fh, ¤t_fh->fh_handle); 2641da177e4SLinus Torvalds dp->dl_time = 0; 2651da177e4SLinus Torvalds atomic_set(&dp->dl_count, 1); 266b5a1a81eSJ. Bruce Fields INIT_WORK(&dp->dl_recall.cb_work, nfsd4_do_callback_rpc); 2671da177e4SLinus Torvalds return dp; 2681da177e4SLinus Torvalds } 2691da177e4SLinus Torvalds 2701da177e4SLinus Torvalds void 2711da177e4SLinus Torvalds nfs4_put_delegation(struct nfs4_delegation *dp) 2721da177e4SLinus Torvalds { 2731da177e4SLinus Torvalds if (atomic_dec_and_test(&dp->dl_count)) { 2741da177e4SLinus Torvalds dprintk("NFSD: freeing dp %p\n",dp); 27513cd2184SNeilBrown put_nfs4_file(dp->dl_file); 2765b2d21c1SNeilBrown kmem_cache_free(deleg_slab, dp); 277ef0f3390SNeilBrown num_delegations--; 2781da177e4SLinus Torvalds } 2791da177e4SLinus Torvalds } 2801da177e4SLinus Torvalds 281acfdf5c3SJ. Bruce Fields static void nfs4_put_deleg_lease(struct nfs4_file *fp) 2821da177e4SLinus Torvalds { 283acfdf5c3SJ. Bruce Fields if (atomic_dec_and_test(&fp->fi_delegees)) { 284acfdf5c3SJ. Bruce Fields vfs_setlease(fp->fi_deleg_file, F_UNLCK, &fp->fi_lease); 285acfdf5c3SJ. Bruce Fields fp->fi_lease = NULL; 2864ee63624SJ. Bruce Fields fput(fp->fi_deleg_file); 287acfdf5c3SJ. Bruce Fields fp->fi_deleg_file = NULL; 288acfdf5c3SJ. Bruce Fields } 2891da177e4SLinus Torvalds } 2901da177e4SLinus Torvalds 2911da177e4SLinus Torvalds /* Called under the state lock. */ 2921da177e4SLinus Torvalds static void 2931da177e4SLinus Torvalds unhash_delegation(struct nfs4_delegation *dp) 2941da177e4SLinus Torvalds { 295f459e453SJ. Bruce Fields list_del_init(&dp->dl_stid.sc_hash); 296ea1da636SNeilBrown list_del_init(&dp->dl_perclnt); 2971da177e4SLinus Torvalds spin_lock(&recall_lock); 2985d926e8cSJ. Bruce Fields list_del_init(&dp->dl_perfile); 2991da177e4SLinus Torvalds list_del_init(&dp->dl_recall_lru); 3001da177e4SLinus Torvalds spin_unlock(&recall_lock); 301acfdf5c3SJ. Bruce Fields nfs4_put_deleg_lease(dp->dl_file); 3021da177e4SLinus Torvalds nfs4_put_delegation(dp); 3031da177e4SLinus Torvalds } 3041da177e4SLinus Torvalds 3051da177e4SLinus Torvalds /* 3061da177e4SLinus Torvalds * SETCLIENTID state 3071da177e4SLinus Torvalds */ 3081da177e4SLinus Torvalds 30936acb66bSBenny Halevy /* client_lock protects the client lru list and session hash table */ 3109089f1b4SBenny Halevy static DEFINE_SPINLOCK(client_lock); 3119089f1b4SBenny Halevy 3121da177e4SLinus Torvalds /* Hash tables for nfs4_clientid state */ 3131da177e4SLinus Torvalds #define CLIENT_HASH_BITS 4 3141da177e4SLinus Torvalds #define CLIENT_HASH_SIZE (1 << CLIENT_HASH_BITS) 3151da177e4SLinus Torvalds #define CLIENT_HASH_MASK (CLIENT_HASH_SIZE - 1) 3161da177e4SLinus Torvalds 317ddc04c41SJ. Bruce Fields static unsigned int clientid_hashval(u32 id) 318ddc04c41SJ. Bruce Fields { 319ddc04c41SJ. Bruce Fields return id & CLIENT_HASH_MASK; 320ddc04c41SJ. Bruce Fields } 321ddc04c41SJ. Bruce Fields 322ddc04c41SJ. Bruce Fields static unsigned int clientstr_hashval(const char *name) 323ddc04c41SJ. Bruce Fields { 324ddc04c41SJ. Bruce Fields return opaque_hashval(name, 8) & CLIENT_HASH_MASK; 325ddc04c41SJ. Bruce Fields } 326ddc04c41SJ. Bruce Fields 3271da177e4SLinus Torvalds /* 3281da177e4SLinus Torvalds * reclaim_str_hashtbl[] holds known client info from previous reset/reboot 3291da177e4SLinus Torvalds * used in reboot/reset lease grace period processing 3301da177e4SLinus Torvalds * 3311da177e4SLinus Torvalds * conf_id_hashtbl[], and conf_str_hashtbl[] hold confirmed 3321da177e4SLinus Torvalds * setclientid_confirmed info. 3331da177e4SLinus Torvalds * 3341da177e4SLinus Torvalds * unconf_str_hastbl[] and unconf_id_hashtbl[] hold unconfirmed 3351da177e4SLinus Torvalds * setclientid info. 3361da177e4SLinus Torvalds * 3371da177e4SLinus Torvalds * client_lru holds client queue ordered by nfs4_client.cl_time 3381da177e4SLinus Torvalds * for lease renewal. 3391da177e4SLinus Torvalds * 3401da177e4SLinus Torvalds * close_lru holds (open) stateowner queue ordered by nfs4_stateowner.so_time 3411da177e4SLinus Torvalds * for last close replay. 3421da177e4SLinus Torvalds */ 3431da177e4SLinus Torvalds static struct list_head reclaim_str_hashtbl[CLIENT_HASH_SIZE]; 3441da177e4SLinus Torvalds static int reclaim_str_hashtbl_size = 0; 3451da177e4SLinus Torvalds static struct list_head conf_id_hashtbl[CLIENT_HASH_SIZE]; 3461da177e4SLinus Torvalds static struct list_head conf_str_hashtbl[CLIENT_HASH_SIZE]; 3471da177e4SLinus Torvalds static struct list_head unconf_str_hashtbl[CLIENT_HASH_SIZE]; 3481da177e4SLinus Torvalds static struct list_head unconf_id_hashtbl[CLIENT_HASH_SIZE]; 3491da177e4SLinus Torvalds static struct list_head client_lru; 3501da177e4SLinus Torvalds static struct list_head close_lru; 3511da177e4SLinus Torvalds 352f9d7562fSJ. Bruce Fields /* 353f9d7562fSJ. Bruce Fields * We store the NONE, READ, WRITE, and BOTH bits separately in the 354f9d7562fSJ. Bruce Fields * st_{access,deny}_bmap field of the stateid, in order to track not 355f9d7562fSJ. Bruce Fields * only what share bits are currently in force, but also what 356f9d7562fSJ. Bruce Fields * combinations of share bits previous opens have used. This allows us 357f9d7562fSJ. Bruce Fields * to enforce the recommendation of rfc 3530 14.2.19 that the server 358f9d7562fSJ. Bruce Fields * return an error if the client attempt to downgrade to a combination 359f9d7562fSJ. Bruce Fields * of share bits not explicable by closing some of its previous opens. 360f9d7562fSJ. Bruce Fields * 361f9d7562fSJ. Bruce Fields * XXX: This enforcement is actually incomplete, since we don't keep 362f9d7562fSJ. Bruce Fields * track of access/deny bit combinations; so, e.g., we allow: 363f9d7562fSJ. Bruce Fields * 364f9d7562fSJ. Bruce Fields * OPEN allow read, deny write 365f9d7562fSJ. Bruce Fields * OPEN allow both, deny none 366f9d7562fSJ. Bruce Fields * DOWNGRADE allow read, deny none 367f9d7562fSJ. Bruce Fields * 368f9d7562fSJ. Bruce Fields * which we should reject. 369f9d7562fSJ. Bruce Fields */ 370f9d7562fSJ. Bruce Fields static void 371f9d7562fSJ. Bruce Fields set_access(unsigned int *access, unsigned long bmap) { 372f9d7562fSJ. Bruce Fields int i; 373f9d7562fSJ. Bruce Fields 374f9d7562fSJ. Bruce Fields *access = 0; 375f9d7562fSJ. Bruce Fields for (i = 1; i < 4; i++) { 376f9d7562fSJ. Bruce Fields if (test_bit(i, &bmap)) 377f9d7562fSJ. Bruce Fields *access |= i; 378f9d7562fSJ. Bruce Fields } 379f9d7562fSJ. Bruce Fields } 380f9d7562fSJ. Bruce Fields 381f9d7562fSJ. Bruce Fields static void 382f9d7562fSJ. Bruce Fields set_deny(unsigned int *deny, unsigned long bmap) { 383f9d7562fSJ. Bruce Fields int i; 384f9d7562fSJ. Bruce Fields 385f9d7562fSJ. Bruce Fields *deny = 0; 386f9d7562fSJ. Bruce Fields for (i = 0; i < 4; i++) { 387f9d7562fSJ. Bruce Fields if (test_bit(i, &bmap)) 388f9d7562fSJ. Bruce Fields *deny |= i ; 389f9d7562fSJ. Bruce Fields } 390f9d7562fSJ. Bruce Fields } 391f9d7562fSJ. Bruce Fields 392f9d7562fSJ. Bruce Fields static int 393dcef0413SJ. Bruce Fields test_share(struct nfs4_ol_stateid *stp, struct nfsd4_open *open) { 394f9d7562fSJ. Bruce Fields unsigned int access, deny; 395f9d7562fSJ. Bruce Fields 396f9d7562fSJ. Bruce Fields set_access(&access, stp->st_access_bmap); 397f9d7562fSJ. Bruce Fields set_deny(&deny, stp->st_deny_bmap); 398f9d7562fSJ. Bruce Fields if ((access & open->op_share_deny) || (deny & open->op_share_access)) 399f9d7562fSJ. Bruce Fields return 0; 400f9d7562fSJ. Bruce Fields return 1; 401f9d7562fSJ. Bruce Fields } 402f9d7562fSJ. Bruce Fields 403f9d7562fSJ. Bruce Fields static int nfs4_access_to_omode(u32 access) 404f9d7562fSJ. Bruce Fields { 4058f34a430SJ. Bruce Fields switch (access & NFS4_SHARE_ACCESS_BOTH) { 406f9d7562fSJ. Bruce Fields case NFS4_SHARE_ACCESS_READ: 407f9d7562fSJ. Bruce Fields return O_RDONLY; 408f9d7562fSJ. Bruce Fields case NFS4_SHARE_ACCESS_WRITE: 409f9d7562fSJ. Bruce Fields return O_WRONLY; 410f9d7562fSJ. Bruce Fields case NFS4_SHARE_ACCESS_BOTH: 411f9d7562fSJ. Bruce Fields return O_RDWR; 412f9d7562fSJ. Bruce Fields } 413f9d7562fSJ. Bruce Fields BUG(); 414f9d7562fSJ. Bruce Fields } 415f9d7562fSJ. Bruce Fields 416dcef0413SJ. Bruce Fields static void unhash_generic_stateid(struct nfs4_ol_stateid *stp) 417529d7b2aSJ. Bruce Fields { 418dcef0413SJ. Bruce Fields list_del(&stp->st_stid.sc_hash); 419529d7b2aSJ. Bruce Fields list_del(&stp->st_perfile); 420529d7b2aSJ. Bruce Fields list_del(&stp->st_perstateowner); 421529d7b2aSJ. Bruce Fields } 422529d7b2aSJ. Bruce Fields 423dcef0413SJ. Bruce Fields static void close_generic_stateid(struct nfs4_ol_stateid *stp) 424529d7b2aSJ. Bruce Fields { 425499f3edcSJ. Bruce Fields int i; 4260997b173SJ. Bruce Fields 42723fcf2ecSJ. Bruce Fields if (stp->st_access_bmap) { 428499f3edcSJ. Bruce Fields for (i = 1; i < 4; i++) { 429499f3edcSJ. Bruce Fields if (test_bit(i, &stp->st_access_bmap)) 430499f3edcSJ. Bruce Fields nfs4_file_put_access(stp->st_file, 431499f3edcSJ. Bruce Fields nfs4_access_to_omode(i)); 4324665e2baSJ. Bruce Fields __clear_bit(i, &stp->st_access_bmap); 433499f3edcSJ. Bruce Fields } 43423fcf2ecSJ. Bruce Fields } 435a96e5b90SOGAWA Hirofumi put_nfs4_file(stp->st_file); 4364665e2baSJ. Bruce Fields stp->st_file = NULL; 4374665e2baSJ. Bruce Fields } 4384665e2baSJ. Bruce Fields 439dcef0413SJ. Bruce Fields static void free_generic_stateid(struct nfs4_ol_stateid *stp) 4404665e2baSJ. Bruce Fields { 4414665e2baSJ. Bruce Fields close_generic_stateid(stp); 442529d7b2aSJ. Bruce Fields kmem_cache_free(stateid_slab, stp); 443529d7b2aSJ. Bruce Fields } 444529d7b2aSJ. Bruce Fields 445dcef0413SJ. Bruce Fields static void release_lock_stateid(struct nfs4_ol_stateid *stp) 446529d7b2aSJ. Bruce Fields { 447529d7b2aSJ. Bruce Fields struct file *file; 448529d7b2aSJ. Bruce Fields 449529d7b2aSJ. Bruce Fields unhash_generic_stateid(stp); 450529d7b2aSJ. Bruce Fields file = find_any_file(stp->st_file); 451529d7b2aSJ. Bruce Fields if (file) 452fe0750e5SJ. Bruce Fields locks_remove_posix(file, (fl_owner_t)lockowner(stp->st_stateowner)); 453529d7b2aSJ. Bruce Fields free_generic_stateid(stp); 454529d7b2aSJ. Bruce Fields } 455529d7b2aSJ. Bruce Fields 456fe0750e5SJ. Bruce Fields static void unhash_lockowner(struct nfs4_lockowner *lo) 457529d7b2aSJ. Bruce Fields { 458dcef0413SJ. Bruce Fields struct nfs4_ol_stateid *stp; 459529d7b2aSJ. Bruce Fields 460fe0750e5SJ. Bruce Fields list_del(&lo->lo_owner.so_idhash); 461fe0750e5SJ. Bruce Fields list_del(&lo->lo_owner.so_strhash); 462fe0750e5SJ. Bruce Fields list_del(&lo->lo_perstateid); 463fe0750e5SJ. Bruce Fields while (!list_empty(&lo->lo_owner.so_stateids)) { 464fe0750e5SJ. Bruce Fields stp = list_first_entry(&lo->lo_owner.so_stateids, 465dcef0413SJ. Bruce Fields struct nfs4_ol_stateid, st_perstateowner); 466529d7b2aSJ. Bruce Fields release_lock_stateid(stp); 467529d7b2aSJ. Bruce Fields } 468529d7b2aSJ. Bruce Fields } 469529d7b2aSJ. Bruce Fields 470fe0750e5SJ. Bruce Fields static void release_lockowner(struct nfs4_lockowner *lo) 471529d7b2aSJ. Bruce Fields { 472fe0750e5SJ. Bruce Fields unhash_lockowner(lo); 473fe0750e5SJ. Bruce Fields nfs4_free_lockowner(lo); 474529d7b2aSJ. Bruce Fields } 475529d7b2aSJ. Bruce Fields 476529d7b2aSJ. Bruce Fields static void 477dcef0413SJ. Bruce Fields release_stateid_lockowners(struct nfs4_ol_stateid *open_stp) 478529d7b2aSJ. Bruce Fields { 479fe0750e5SJ. Bruce Fields struct nfs4_lockowner *lo; 480529d7b2aSJ. Bruce Fields 481529d7b2aSJ. Bruce Fields while (!list_empty(&open_stp->st_lockowners)) { 482fe0750e5SJ. Bruce Fields lo = list_entry(open_stp->st_lockowners.next, 483fe0750e5SJ. Bruce Fields struct nfs4_lockowner, lo_perstateid); 484fe0750e5SJ. Bruce Fields release_lockowner(lo); 485529d7b2aSJ. Bruce Fields } 486529d7b2aSJ. Bruce Fields } 487529d7b2aSJ. Bruce Fields 488dcef0413SJ. Bruce Fields static void release_open_stateid(struct nfs4_ol_stateid *stp) 4892283963fSJ. Bruce Fields { 4902283963fSJ. Bruce Fields unhash_generic_stateid(stp); 4912283963fSJ. Bruce Fields release_stateid_lockowners(stp); 4922283963fSJ. Bruce Fields free_generic_stateid(stp); 4932283963fSJ. Bruce Fields } 4942283963fSJ. Bruce Fields 495fe0750e5SJ. Bruce Fields static void unhash_openowner(struct nfs4_openowner *oo) 496f1d110caSJ. Bruce Fields { 497dcef0413SJ. Bruce Fields struct nfs4_ol_stateid *stp; 498f1d110caSJ. Bruce Fields 499fe0750e5SJ. Bruce Fields list_del(&oo->oo_owner.so_idhash); 500fe0750e5SJ. Bruce Fields list_del(&oo->oo_owner.so_strhash); 501fe0750e5SJ. Bruce Fields list_del(&oo->oo_perclient); 502fe0750e5SJ. Bruce Fields while (!list_empty(&oo->oo_owner.so_stateids)) { 503fe0750e5SJ. Bruce Fields stp = list_first_entry(&oo->oo_owner.so_stateids, 504dcef0413SJ. Bruce Fields struct nfs4_ol_stateid, st_perstateowner); 505f1d110caSJ. Bruce Fields release_open_stateid(stp); 506f1d110caSJ. Bruce Fields } 507f1d110caSJ. Bruce Fields } 508f1d110caSJ. Bruce Fields 509fe0750e5SJ. Bruce Fields static void release_openowner(struct nfs4_openowner *oo) 510f1d110caSJ. Bruce Fields { 511fe0750e5SJ. Bruce Fields unhash_openowner(oo); 512fe0750e5SJ. Bruce Fields list_del(&oo->oo_close_lru); 513fe0750e5SJ. Bruce Fields nfs4_free_openowner(oo); 514f1d110caSJ. Bruce Fields } 515f1d110caSJ. Bruce Fields 5165282fd72SMarc Eshel #define SESSION_HASH_SIZE 512 5175282fd72SMarc Eshel static struct list_head sessionid_hashtbl[SESSION_HASH_SIZE]; 5185282fd72SMarc Eshel 5195282fd72SMarc Eshel static inline int 5205282fd72SMarc Eshel hash_sessionid(struct nfs4_sessionid *sessionid) 5215282fd72SMarc Eshel { 5225282fd72SMarc Eshel struct nfsd4_sessionid *sid = (struct nfsd4_sessionid *)sessionid; 5235282fd72SMarc Eshel 5245282fd72SMarc Eshel return sid->sequence % SESSION_HASH_SIZE; 5255282fd72SMarc Eshel } 5265282fd72SMarc Eshel 5275282fd72SMarc Eshel static inline void 5285282fd72SMarc Eshel dump_sessionid(const char *fn, struct nfs4_sessionid *sessionid) 5295282fd72SMarc Eshel { 5305282fd72SMarc Eshel u32 *ptr = (u32 *)(&sessionid->data[0]); 5315282fd72SMarc Eshel dprintk("%s: %u:%u:%u:%u\n", fn, ptr[0], ptr[1], ptr[2], ptr[3]); 5325282fd72SMarc Eshel } 5335282fd72SMarc Eshel 534ec6b5d7bSAndy Adamson static void 535ec6b5d7bSAndy Adamson gen_sessionid(struct nfsd4_session *ses) 536ec6b5d7bSAndy Adamson { 537ec6b5d7bSAndy Adamson struct nfs4_client *clp = ses->se_client; 538ec6b5d7bSAndy Adamson struct nfsd4_sessionid *sid; 539ec6b5d7bSAndy Adamson 540ec6b5d7bSAndy Adamson sid = (struct nfsd4_sessionid *)ses->se_sessionid.data; 541ec6b5d7bSAndy Adamson sid->clientid = clp->cl_clientid; 542ec6b5d7bSAndy Adamson sid->sequence = current_sessionid++; 543ec6b5d7bSAndy Adamson sid->reserved = 0; 544ec6b5d7bSAndy Adamson } 545ec6b5d7bSAndy Adamson 546ec6b5d7bSAndy Adamson /* 547a649637cSAndy Adamson * The protocol defines ca_maxresponssize_cached to include the size of 548a649637cSAndy Adamson * the rpc header, but all we need to cache is the data starting after 549a649637cSAndy Adamson * the end of the initial SEQUENCE operation--the rest we regenerate 550a649637cSAndy Adamson * each time. Therefore we can advertise a ca_maxresponssize_cached 551a649637cSAndy Adamson * value that is the number of bytes in our cache plus a few additional 552a649637cSAndy Adamson * bytes. In order to stay on the safe side, and not promise more than 553a649637cSAndy Adamson * we can cache, those additional bytes must be the minimum possible: 24 554a649637cSAndy Adamson * bytes of rpc header (xid through accept state, with AUTH_NULL 555a649637cSAndy Adamson * verifier), 12 for the compound header (with zero-length tag), and 44 556a649637cSAndy Adamson * for the SEQUENCE op response: 557ec6b5d7bSAndy Adamson */ 558a649637cSAndy Adamson #define NFSD_MIN_HDR_SEQ_SZ (24 + 12 + 44) 559a649637cSAndy Adamson 560557ce264SAndy Adamson static void 561557ce264SAndy Adamson free_session_slots(struct nfsd4_session *ses) 562557ce264SAndy Adamson { 563557ce264SAndy Adamson int i; 564557ce264SAndy Adamson 565557ce264SAndy Adamson for (i = 0; i < ses->se_fchannel.maxreqs; i++) 566557ce264SAndy Adamson kfree(ses->se_slots[i]); 567557ce264SAndy Adamson } 568557ce264SAndy Adamson 569efe0cb6dSJ. Bruce Fields /* 570efe0cb6dSJ. Bruce Fields * We don't actually need to cache the rpc and session headers, so we 571efe0cb6dSJ. Bruce Fields * can allocate a little less for each slot: 572efe0cb6dSJ. Bruce Fields */ 573efe0cb6dSJ. Bruce Fields static inline int slot_bytes(struct nfsd4_channel_attrs *ca) 574efe0cb6dSJ. Bruce Fields { 575efe0cb6dSJ. Bruce Fields return ca->maxresp_cached - NFSD_MIN_HDR_SEQ_SZ; 576efe0cb6dSJ. Bruce Fields } 577efe0cb6dSJ. Bruce Fields 5785b6feee9SJ. Bruce Fields static int nfsd4_sanitize_slot_size(u32 size) 579ec6b5d7bSAndy Adamson { 5805b6feee9SJ. Bruce Fields size -= NFSD_MIN_HDR_SEQ_SZ; /* We don't cache the rpc header */ 5815b6feee9SJ. Bruce Fields size = min_t(u32, size, NFSD_SLOT_CACHE_SIZE); 582ec6b5d7bSAndy Adamson 5835b6feee9SJ. Bruce Fields return size; 584557ce264SAndy Adamson } 585557ce264SAndy Adamson 5865b6feee9SJ. Bruce Fields /* 5875b6feee9SJ. Bruce Fields * XXX: If we run out of reserved DRC memory we could (up to a point) 5885b6feee9SJ. Bruce Fields * re-negotiate active sessions and reduce their slot usage to make 5895b6feee9SJ. Bruce Fields * rooom for new connections. For now we just fail the create session. 5905b6feee9SJ. Bruce Fields */ 5915b6feee9SJ. Bruce Fields static int nfsd4_get_drc_mem(int slotsize, u32 num) 5925b6feee9SJ. Bruce Fields { 5935b6feee9SJ. Bruce Fields int avail; 5945b6feee9SJ. Bruce Fields 5955b6feee9SJ. Bruce Fields num = min_t(u32, num, NFSD_MAX_SLOTS_PER_SESSION); 5965b6feee9SJ. Bruce Fields 5975b6feee9SJ. Bruce Fields spin_lock(&nfsd_drc_lock); 5985b6feee9SJ. Bruce Fields avail = min_t(int, NFSD_MAX_MEM_PER_SESSION, 5995b6feee9SJ. Bruce Fields nfsd_drc_max_mem - nfsd_drc_mem_used); 6005b6feee9SJ. Bruce Fields num = min_t(int, num, avail / slotsize); 6015b6feee9SJ. Bruce Fields nfsd_drc_mem_used += num * slotsize; 6025b6feee9SJ. Bruce Fields spin_unlock(&nfsd_drc_lock); 6035b6feee9SJ. Bruce Fields 6045b6feee9SJ. Bruce Fields return num; 6055b6feee9SJ. Bruce Fields } 6065b6feee9SJ. Bruce Fields 6075b6feee9SJ. Bruce Fields static void nfsd4_put_drc_mem(int slotsize, int num) 6085b6feee9SJ. Bruce Fields { 6095b6feee9SJ. Bruce Fields spin_lock(&nfsd_drc_lock); 6105b6feee9SJ. Bruce Fields nfsd_drc_mem_used -= slotsize * num; 6115b6feee9SJ. Bruce Fields spin_unlock(&nfsd_drc_lock); 6125b6feee9SJ. Bruce Fields } 6135b6feee9SJ. Bruce Fields 6145b6feee9SJ. Bruce Fields static struct nfsd4_session *alloc_session(int slotsize, int numslots) 6155b6feee9SJ. Bruce Fields { 6165b6feee9SJ. Bruce Fields struct nfsd4_session *new; 6175b6feee9SJ. Bruce Fields int mem, i; 618ec6b5d7bSAndy Adamson 619c23753daSJ. Bruce Fields BUILD_BUG_ON(NFSD_MAX_SLOTS_PER_SESSION * sizeof(struct nfsd4_slot *) 620ec6b5d7bSAndy Adamson + sizeof(struct nfsd4_session) > PAGE_SIZE); 6215b6feee9SJ. Bruce Fields mem = numslots * sizeof(struct nfsd4_slot *); 622ec6b5d7bSAndy Adamson 6235b6feee9SJ. Bruce Fields new = kzalloc(sizeof(*new) + mem, GFP_KERNEL); 6246c18ba9fSAlexandros Batsakis if (!new) 6255b6feee9SJ. Bruce Fields return NULL; 626ec6b5d7bSAndy Adamson /* allocate each struct nfsd4_slot and data cache in one piece */ 6275b6feee9SJ. Bruce Fields for (i = 0; i < numslots; i++) { 6285b6feee9SJ. Bruce Fields mem = sizeof(struct nfsd4_slot) + slotsize; 6295b6feee9SJ. Bruce Fields new->se_slots[i] = kzalloc(mem, GFP_KERNEL); 6305b6feee9SJ. Bruce Fields if (!new->se_slots[i]) 631ec6b5d7bSAndy Adamson goto out_free; 632ec6b5d7bSAndy Adamson } 6335b6feee9SJ. Bruce Fields return new; 6345b6feee9SJ. Bruce Fields out_free: 6355b6feee9SJ. Bruce Fields while (i--) 6365b6feee9SJ. Bruce Fields kfree(new->se_slots[i]); 6375b6feee9SJ. Bruce Fields kfree(new); 6385b6feee9SJ. Bruce Fields return NULL; 6395b6feee9SJ. Bruce Fields } 6405b6feee9SJ. Bruce Fields 6415b6feee9SJ. Bruce Fields static void init_forechannel_attrs(struct nfsd4_channel_attrs *new, struct nfsd4_channel_attrs *req, int numslots, int slotsize) 6425b6feee9SJ. Bruce Fields { 6435b6feee9SJ. Bruce Fields u32 maxrpc = nfsd_serv->sv_max_mesg; 6445b6feee9SJ. Bruce Fields 6455b6feee9SJ. Bruce Fields new->maxreqs = numslots; 646d2b21743SMi Jinlong new->maxresp_cached = min_t(u32, req->maxresp_cached, 647d2b21743SMi Jinlong slotsize + NFSD_MIN_HDR_SEQ_SZ); 6485b6feee9SJ. Bruce Fields new->maxreq_sz = min_t(u32, req->maxreq_sz, maxrpc); 6495b6feee9SJ. Bruce Fields new->maxresp_sz = min_t(u32, req->maxresp_sz, maxrpc); 6505b6feee9SJ. Bruce Fields new->maxops = min_t(u32, req->maxops, NFSD_MAX_OPS_PER_COMPOUND); 6515b6feee9SJ. Bruce Fields } 6525b6feee9SJ. Bruce Fields 65319cf5c02SJ. Bruce Fields static void free_conn(struct nfsd4_conn *c) 65419cf5c02SJ. Bruce Fields { 65519cf5c02SJ. Bruce Fields svc_xprt_put(c->cn_xprt); 65619cf5c02SJ. Bruce Fields kfree(c); 65719cf5c02SJ. Bruce Fields } 65819cf5c02SJ. Bruce Fields 65919cf5c02SJ. Bruce Fields static void nfsd4_conn_lost(struct svc_xpt_user *u) 66019cf5c02SJ. Bruce Fields { 66119cf5c02SJ. Bruce Fields struct nfsd4_conn *c = container_of(u, struct nfsd4_conn, cn_xpt_user); 66219cf5c02SJ. Bruce Fields struct nfs4_client *clp = c->cn_session->se_client; 66319cf5c02SJ. Bruce Fields 66419cf5c02SJ. Bruce Fields spin_lock(&clp->cl_lock); 66519cf5c02SJ. Bruce Fields if (!list_empty(&c->cn_persession)) { 66619cf5c02SJ. Bruce Fields list_del(&c->cn_persession); 66719cf5c02SJ. Bruce Fields free_conn(c); 66819cf5c02SJ. Bruce Fields } 66919cf5c02SJ. Bruce Fields spin_unlock(&clp->cl_lock); 670eea49806SJ. Bruce Fields nfsd4_probe_callback(clp); 67119cf5c02SJ. Bruce Fields } 67219cf5c02SJ. Bruce Fields 673d29c374cSJ. Bruce Fields static struct nfsd4_conn *alloc_conn(struct svc_rqst *rqstp, u32 flags) 674c7662518SJ. Bruce Fields { 675c7662518SJ. Bruce Fields struct nfsd4_conn *conn; 676c7662518SJ. Bruce Fields 677c7662518SJ. Bruce Fields conn = kmalloc(sizeof(struct nfsd4_conn), GFP_KERNEL); 678c7662518SJ. Bruce Fields if (!conn) 679db90681dSJ. Bruce Fields return NULL; 680c7662518SJ. Bruce Fields svc_xprt_get(rqstp->rq_xprt); 681c7662518SJ. Bruce Fields conn->cn_xprt = rqstp->rq_xprt; 682d29c374cSJ. Bruce Fields conn->cn_flags = flags; 683db90681dSJ. Bruce Fields INIT_LIST_HEAD(&conn->cn_xpt_user.list); 684db90681dSJ. Bruce Fields return conn; 685db90681dSJ. Bruce Fields } 686db90681dSJ. Bruce Fields 687328ead28SJ. Bruce Fields static void __nfsd4_hash_conn(struct nfsd4_conn *conn, struct nfsd4_session *ses) 688328ead28SJ. Bruce Fields { 689328ead28SJ. Bruce Fields conn->cn_session = ses; 690328ead28SJ. Bruce Fields list_add(&conn->cn_persession, &ses->se_conns); 691328ead28SJ. Bruce Fields } 692328ead28SJ. Bruce Fields 693db90681dSJ. Bruce Fields static void nfsd4_hash_conn(struct nfsd4_conn *conn, struct nfsd4_session *ses) 694db90681dSJ. Bruce Fields { 695db90681dSJ. Bruce Fields struct nfs4_client *clp = ses->se_client; 696c7662518SJ. Bruce Fields 697c7662518SJ. Bruce Fields spin_lock(&clp->cl_lock); 698328ead28SJ. Bruce Fields __nfsd4_hash_conn(conn, ses); 699c7662518SJ. Bruce Fields spin_unlock(&clp->cl_lock); 700db90681dSJ. Bruce Fields } 701c7662518SJ. Bruce Fields 70221b75b01SJ. Bruce Fields static int nfsd4_register_conn(struct nfsd4_conn *conn) 703db90681dSJ. Bruce Fields { 70419cf5c02SJ. Bruce Fields conn->cn_xpt_user.callback = nfsd4_conn_lost; 70521b75b01SJ. Bruce Fields return register_xpt_user(conn->cn_xprt, &conn->cn_xpt_user); 706db90681dSJ. Bruce Fields } 707db90681dSJ. Bruce Fields 7081d1bc8f2SJ. Bruce Fields static __be32 nfsd4_new_conn(struct svc_rqst *rqstp, struct nfsd4_session *ses, u32 dir) 709db90681dSJ. Bruce Fields { 710db90681dSJ. Bruce Fields struct nfsd4_conn *conn; 71121b75b01SJ. Bruce Fields int ret; 712db90681dSJ. Bruce Fields 7131d1bc8f2SJ. Bruce Fields conn = alloc_conn(rqstp, dir); 714db90681dSJ. Bruce Fields if (!conn) 715db90681dSJ. Bruce Fields return nfserr_jukebox; 716db90681dSJ. Bruce Fields nfsd4_hash_conn(conn, ses); 71721b75b01SJ. Bruce Fields ret = nfsd4_register_conn(conn); 71821b75b01SJ. Bruce Fields if (ret) 71921b75b01SJ. Bruce Fields /* oops; xprt is already down: */ 72021b75b01SJ. Bruce Fields nfsd4_conn_lost(&conn->cn_xpt_user); 721c7662518SJ. Bruce Fields return nfs_ok; 722c7662518SJ. Bruce Fields } 723c7662518SJ. Bruce Fields 7241d1bc8f2SJ. Bruce Fields static __be32 nfsd4_new_conn_from_crses(struct svc_rqst *rqstp, struct nfsd4_session *ses) 7251d1bc8f2SJ. Bruce Fields { 7261d1bc8f2SJ. Bruce Fields u32 dir = NFS4_CDFC4_FORE; 7271d1bc8f2SJ. Bruce Fields 7281d1bc8f2SJ. Bruce Fields if (ses->se_flags & SESSION4_BACK_CHAN) 7291d1bc8f2SJ. Bruce Fields dir |= NFS4_CDFC4_BACK; 7301d1bc8f2SJ. Bruce Fields 7311d1bc8f2SJ. Bruce Fields return nfsd4_new_conn(rqstp, ses, dir); 7321d1bc8f2SJ. Bruce Fields } 7331d1bc8f2SJ. Bruce Fields 7341d1bc8f2SJ. Bruce Fields /* must be called under client_lock */ 73519cf5c02SJ. Bruce Fields static void nfsd4_del_conns(struct nfsd4_session *s) 736c7662518SJ. Bruce Fields { 73719cf5c02SJ. Bruce Fields struct nfs4_client *clp = s->se_client; 73819cf5c02SJ. Bruce Fields struct nfsd4_conn *c; 73919cf5c02SJ. Bruce Fields 74019cf5c02SJ. Bruce Fields spin_lock(&clp->cl_lock); 74119cf5c02SJ. Bruce Fields while (!list_empty(&s->se_conns)) { 74219cf5c02SJ. Bruce Fields c = list_first_entry(&s->se_conns, struct nfsd4_conn, cn_persession); 74319cf5c02SJ. Bruce Fields list_del_init(&c->cn_persession); 74419cf5c02SJ. Bruce Fields spin_unlock(&clp->cl_lock); 74519cf5c02SJ. Bruce Fields 74619cf5c02SJ. Bruce Fields unregister_xpt_user(c->cn_xprt, &c->cn_xpt_user); 74719cf5c02SJ. Bruce Fields free_conn(c); 74819cf5c02SJ. Bruce Fields 74919cf5c02SJ. Bruce Fields spin_lock(&clp->cl_lock); 75019cf5c02SJ. Bruce Fields } 75119cf5c02SJ. Bruce Fields spin_unlock(&clp->cl_lock); 752c7662518SJ. Bruce Fields } 753c7662518SJ. Bruce Fields 754c7662518SJ. Bruce Fields void free_session(struct kref *kref) 755c7662518SJ. Bruce Fields { 756c7662518SJ. Bruce Fields struct nfsd4_session *ses; 757c7662518SJ. Bruce Fields int mem; 758c7662518SJ. Bruce Fields 759c7662518SJ. Bruce Fields ses = container_of(kref, struct nfsd4_session, se_ref); 76019cf5c02SJ. Bruce Fields nfsd4_del_conns(ses); 761c7662518SJ. Bruce Fields spin_lock(&nfsd_drc_lock); 762c7662518SJ. Bruce Fields mem = ses->se_fchannel.maxreqs * slot_bytes(&ses->se_fchannel); 763c7662518SJ. Bruce Fields nfsd_drc_mem_used -= mem; 764c7662518SJ. Bruce Fields spin_unlock(&nfsd_drc_lock); 765c7662518SJ. Bruce Fields free_session_slots(ses); 766c7662518SJ. Bruce Fields kfree(ses); 767c7662518SJ. Bruce Fields } 768c7662518SJ. Bruce Fields 769ac7c46f2SJ. Bruce Fields static struct nfsd4_session *alloc_init_session(struct svc_rqst *rqstp, struct nfs4_client *clp, struct nfsd4_create_session *cses) 7705b6feee9SJ. Bruce Fields { 7715b6feee9SJ. Bruce Fields struct nfsd4_session *new; 7725b6feee9SJ. Bruce Fields struct nfsd4_channel_attrs *fchan = &cses->fore_channel; 7735b6feee9SJ. Bruce Fields int numslots, slotsize; 774c7662518SJ. Bruce Fields int status; 7755b6feee9SJ. Bruce Fields int idx; 7765b6feee9SJ. Bruce Fields 7775b6feee9SJ. Bruce Fields /* 7785b6feee9SJ. Bruce Fields * Note decreasing slot size below client's request may 7795b6feee9SJ. Bruce Fields * make it difficult for client to function correctly, whereas 7805b6feee9SJ. Bruce Fields * decreasing the number of slots will (just?) affect 7815b6feee9SJ. Bruce Fields * performance. When short on memory we therefore prefer to 7825b6feee9SJ. Bruce Fields * decrease number of slots instead of their size. 7835b6feee9SJ. Bruce Fields */ 7845b6feee9SJ. Bruce Fields slotsize = nfsd4_sanitize_slot_size(fchan->maxresp_cached); 7855b6feee9SJ. Bruce Fields numslots = nfsd4_get_drc_mem(slotsize, fchan->maxreqs); 786ced6dfe9SMi Jinlong if (numslots < 1) 787ced6dfe9SMi Jinlong return NULL; 7885b6feee9SJ. Bruce Fields 7895b6feee9SJ. Bruce Fields new = alloc_session(slotsize, numslots); 7905b6feee9SJ. Bruce Fields if (!new) { 7915b6feee9SJ. Bruce Fields nfsd4_put_drc_mem(slotsize, fchan->maxreqs); 792ac7c46f2SJ. Bruce Fields return NULL; 7935b6feee9SJ. Bruce Fields } 7945b6feee9SJ. Bruce Fields init_forechannel_attrs(&new->se_fchannel, fchan, numslots, slotsize); 795ec6b5d7bSAndy Adamson 796ec6b5d7bSAndy Adamson new->se_client = clp; 797ec6b5d7bSAndy Adamson gen_sessionid(new); 798ec6b5d7bSAndy Adamson 799c7662518SJ. Bruce Fields INIT_LIST_HEAD(&new->se_conns); 800c7662518SJ. Bruce Fields 801ac7c46f2SJ. Bruce Fields new->se_cb_seq_nr = 1; 802ec6b5d7bSAndy Adamson new->se_flags = cses->flags; 8038b5ce5cdSJ. Bruce Fields new->se_cb_prog = cses->callback_prog; 804ec6b5d7bSAndy Adamson kref_init(&new->se_ref); 8055b6feee9SJ. Bruce Fields idx = hash_sessionid(&new->se_sessionid); 8069089f1b4SBenny Halevy spin_lock(&client_lock); 807ec6b5d7bSAndy Adamson list_add(&new->se_hash, &sessionid_hashtbl[idx]); 8084c649378SJ. Bruce Fields spin_lock(&clp->cl_lock); 809ec6b5d7bSAndy Adamson list_add(&new->se_perclnt, &clp->cl_sessions); 8104c649378SJ. Bruce Fields spin_unlock(&clp->cl_lock); 8119089f1b4SBenny Halevy spin_unlock(&client_lock); 812ec6b5d7bSAndy Adamson 8131d1bc8f2SJ. Bruce Fields status = nfsd4_new_conn_from_crses(rqstp, new); 814ac7c46f2SJ. Bruce Fields /* whoops: benny points out, status is ignored! (err, or bogus) */ 815c7662518SJ. Bruce Fields if (status) { 816c7662518SJ. Bruce Fields free_session(&new->se_ref); 817ac7c46f2SJ. Bruce Fields return NULL; 818c7662518SJ. Bruce Fields } 819dcbeaa68SJ. Bruce Fields if (cses->flags & SESSION4_BACK_CHAN) { 820edd76786SJ. Bruce Fields struct sockaddr *sa = svc_addr(rqstp); 821dcbeaa68SJ. Bruce Fields /* 822dcbeaa68SJ. Bruce Fields * This is a little silly; with sessions there's no real 823dcbeaa68SJ. Bruce Fields * use for the callback address. Use the peer address 824dcbeaa68SJ. Bruce Fields * as a reasonable default for now, but consider fixing 825dcbeaa68SJ. Bruce Fields * the rpc client not to require an address in the 826dcbeaa68SJ. Bruce Fields * future: 827dcbeaa68SJ. Bruce Fields */ 828edd76786SJ. Bruce Fields rpc_copy_addr((struct sockaddr *)&clp->cl_cb_conn.cb_addr, sa); 829edd76786SJ. Bruce Fields clp->cl_cb_conn.cb_addrlen = svc_addr_len(sa); 830edd76786SJ. Bruce Fields } 831dcbeaa68SJ. Bruce Fields nfsd4_probe_callback(clp); 832ac7c46f2SJ. Bruce Fields return new; 833ec6b5d7bSAndy Adamson } 834ec6b5d7bSAndy Adamson 8359089f1b4SBenny Halevy /* caller must hold client_lock */ 8365282fd72SMarc Eshel static struct nfsd4_session * 8375282fd72SMarc Eshel find_in_sessionid_hashtbl(struct nfs4_sessionid *sessionid) 8385282fd72SMarc Eshel { 8395282fd72SMarc Eshel struct nfsd4_session *elem; 8405282fd72SMarc Eshel int idx; 8415282fd72SMarc Eshel 8425282fd72SMarc Eshel dump_sessionid(__func__, sessionid); 8435282fd72SMarc Eshel idx = hash_sessionid(sessionid); 8445282fd72SMarc Eshel /* Search in the appropriate list */ 8455282fd72SMarc Eshel list_for_each_entry(elem, &sessionid_hashtbl[idx], se_hash) { 8465282fd72SMarc Eshel if (!memcmp(elem->se_sessionid.data, sessionid->data, 8475282fd72SMarc Eshel NFS4_MAX_SESSIONID_LEN)) { 8485282fd72SMarc Eshel return elem; 8495282fd72SMarc Eshel } 8505282fd72SMarc Eshel } 8515282fd72SMarc Eshel 8525282fd72SMarc Eshel dprintk("%s: session not found\n", __func__); 8535282fd72SMarc Eshel return NULL; 8545282fd72SMarc Eshel } 8555282fd72SMarc Eshel 8569089f1b4SBenny Halevy /* caller must hold client_lock */ 8577116ed6bSAndy Adamson static void 8585282fd72SMarc Eshel unhash_session(struct nfsd4_session *ses) 8597116ed6bSAndy Adamson { 8607116ed6bSAndy Adamson list_del(&ses->se_hash); 8614c649378SJ. Bruce Fields spin_lock(&ses->se_client->cl_lock); 8627116ed6bSAndy Adamson list_del(&ses->se_perclnt); 8634c649378SJ. Bruce Fields spin_unlock(&ses->se_client->cl_lock); 8645282fd72SMarc Eshel } 8655282fd72SMarc Eshel 86636acb66bSBenny Halevy /* must be called under the client_lock */ 8671da177e4SLinus Torvalds static inline void 86836acb66bSBenny Halevy renew_client_locked(struct nfs4_client *clp) 8691da177e4SLinus Torvalds { 87007cd4909SBenny Halevy if (is_client_expired(clp)) { 87107cd4909SBenny Halevy dprintk("%s: client (clientid %08x/%08x) already expired\n", 87207cd4909SBenny Halevy __func__, 87307cd4909SBenny Halevy clp->cl_clientid.cl_boot, 87407cd4909SBenny Halevy clp->cl_clientid.cl_id); 87507cd4909SBenny Halevy return; 87607cd4909SBenny Halevy } 87707cd4909SBenny Halevy 8781da177e4SLinus Torvalds /* 8791da177e4SLinus Torvalds * Move client to the end to the LRU list. 8801da177e4SLinus Torvalds */ 8811da177e4SLinus Torvalds dprintk("renewing client (clientid %08x/%08x)\n", 8821da177e4SLinus Torvalds clp->cl_clientid.cl_boot, 8831da177e4SLinus Torvalds clp->cl_clientid.cl_id); 8841da177e4SLinus Torvalds list_move_tail(&clp->cl_lru, &client_lru); 8851da177e4SLinus Torvalds clp->cl_time = get_seconds(); 8861da177e4SLinus Torvalds } 8871da177e4SLinus Torvalds 88836acb66bSBenny Halevy static inline void 88936acb66bSBenny Halevy renew_client(struct nfs4_client *clp) 89036acb66bSBenny Halevy { 89136acb66bSBenny Halevy spin_lock(&client_lock); 89236acb66bSBenny Halevy renew_client_locked(clp); 89336acb66bSBenny Halevy spin_unlock(&client_lock); 89436acb66bSBenny Halevy } 89536acb66bSBenny Halevy 8961da177e4SLinus Torvalds /* SETCLIENTID and SETCLIENTID_CONFIRM Helper functions */ 8971da177e4SLinus Torvalds static int 8981da177e4SLinus Torvalds STALE_CLIENTID(clientid_t *clid) 8991da177e4SLinus Torvalds { 9001da177e4SLinus Torvalds if (clid->cl_boot == boot_time) 9011da177e4SLinus Torvalds return 0; 90260adfc50SAndy Adamson dprintk("NFSD stale clientid (%08x/%08x) boot_time %08lx\n", 90360adfc50SAndy Adamson clid->cl_boot, clid->cl_id, boot_time); 9041da177e4SLinus Torvalds return 1; 9051da177e4SLinus Torvalds } 9061da177e4SLinus Torvalds 9071da177e4SLinus Torvalds /* 9081da177e4SLinus Torvalds * XXX Should we use a slab cache ? 9091da177e4SLinus Torvalds * This type of memory management is somewhat inefficient, but we use it 9101da177e4SLinus Torvalds * anyway since SETCLIENTID is not a common operation. 9111da177e4SLinus Torvalds */ 91235bba9a3SJ. Bruce Fields static struct nfs4_client *alloc_client(struct xdr_netobj name) 9131da177e4SLinus Torvalds { 9141da177e4SLinus Torvalds struct nfs4_client *clp; 9151da177e4SLinus Torvalds 91635bba9a3SJ. Bruce Fields clp = kzalloc(sizeof(struct nfs4_client), GFP_KERNEL); 91735bba9a3SJ. Bruce Fields if (clp == NULL) 91835bba9a3SJ. Bruce Fields return NULL; 91935bba9a3SJ. Bruce Fields clp->cl_name.data = kmalloc(name.len, GFP_KERNEL); 92035bba9a3SJ. Bruce Fields if (clp->cl_name.data == NULL) { 92135bba9a3SJ. Bruce Fields kfree(clp); 92235bba9a3SJ. Bruce Fields return NULL; 92335bba9a3SJ. Bruce Fields } 9241da177e4SLinus Torvalds memcpy(clp->cl_name.data, name.data, name.len); 9251da177e4SLinus Torvalds clp->cl_name.len = name.len; 9261da177e4SLinus Torvalds return clp; 9271da177e4SLinus Torvalds } 9281da177e4SLinus Torvalds 9291da177e4SLinus Torvalds static inline void 9301da177e4SLinus Torvalds free_client(struct nfs4_client *clp) 9311da177e4SLinus Torvalds { 932792c95ddSJ. Bruce Fields while (!list_empty(&clp->cl_sessions)) { 933792c95ddSJ. Bruce Fields struct nfsd4_session *ses; 934792c95ddSJ. Bruce Fields ses = list_entry(clp->cl_sessions.next, struct nfsd4_session, 935792c95ddSJ. Bruce Fields se_perclnt); 936792c95ddSJ. Bruce Fields list_del(&ses->se_perclnt); 937792c95ddSJ. Bruce Fields nfsd4_put_session(ses); 938792c95ddSJ. Bruce Fields } 9391da177e4SLinus Torvalds if (clp->cl_cred.cr_group_info) 9401da177e4SLinus Torvalds put_group_info(clp->cl_cred.cr_group_info); 94168e76ad0SOlga Kornievskaia kfree(clp->cl_principal); 9421da177e4SLinus Torvalds kfree(clp->cl_name.data); 9431da177e4SLinus Torvalds kfree(clp); 9441da177e4SLinus Torvalds } 9451da177e4SLinus Torvalds 946d7682988SBenny Halevy void 947d7682988SBenny Halevy release_session_client(struct nfsd4_session *session) 948d7682988SBenny Halevy { 949d7682988SBenny Halevy struct nfs4_client *clp = session->se_client; 950d7682988SBenny Halevy 951d7682988SBenny Halevy if (!atomic_dec_and_lock(&clp->cl_refcount, &client_lock)) 952d7682988SBenny Halevy return; 953d7682988SBenny Halevy if (is_client_expired(clp)) { 954d7682988SBenny Halevy free_client(clp); 955d7682988SBenny Halevy session->se_client = NULL; 956d7682988SBenny Halevy } else 957d7682988SBenny Halevy renew_client_locked(clp); 958d7682988SBenny Halevy spin_unlock(&client_lock); 959d7682988SBenny Halevy } 960d7682988SBenny Halevy 96184d38ac9SBenny Halevy /* must be called under the client_lock */ 96284d38ac9SBenny Halevy static inline void 96384d38ac9SBenny Halevy unhash_client_locked(struct nfs4_client *clp) 96484d38ac9SBenny Halevy { 965792c95ddSJ. Bruce Fields struct nfsd4_session *ses; 966792c95ddSJ. Bruce Fields 96707cd4909SBenny Halevy mark_client_expired(clp); 96884d38ac9SBenny Halevy list_del(&clp->cl_lru); 9694c649378SJ. Bruce Fields spin_lock(&clp->cl_lock); 970792c95ddSJ. Bruce Fields list_for_each_entry(ses, &clp->cl_sessions, se_perclnt) 971792c95ddSJ. Bruce Fields list_del_init(&ses->se_hash); 9724c649378SJ. Bruce Fields spin_unlock(&clp->cl_lock); 97384d38ac9SBenny Halevy } 97484d38ac9SBenny Halevy 9751da177e4SLinus Torvalds static void 9761da177e4SLinus Torvalds expire_client(struct nfs4_client *clp) 9771da177e4SLinus Torvalds { 978fe0750e5SJ. Bruce Fields struct nfs4_openowner *oo; 9791da177e4SLinus Torvalds struct nfs4_delegation *dp; 9801da177e4SLinus Torvalds struct list_head reaplist; 9811da177e4SLinus Torvalds 9821da177e4SLinus Torvalds INIT_LIST_HEAD(&reaplist); 9831da177e4SLinus Torvalds spin_lock(&recall_lock); 984ea1da636SNeilBrown while (!list_empty(&clp->cl_delegations)) { 985ea1da636SNeilBrown dp = list_entry(clp->cl_delegations.next, struct nfs4_delegation, dl_perclnt); 986ea1da636SNeilBrown list_del_init(&dp->dl_perclnt); 9871da177e4SLinus Torvalds list_move(&dp->dl_recall_lru, &reaplist); 9881da177e4SLinus Torvalds } 9891da177e4SLinus Torvalds spin_unlock(&recall_lock); 9901da177e4SLinus Torvalds while (!list_empty(&reaplist)) { 9911da177e4SLinus Torvalds dp = list_entry(reaplist.next, struct nfs4_delegation, dl_recall_lru); 9921da177e4SLinus Torvalds list_del_init(&dp->dl_recall_lru); 9931da177e4SLinus Torvalds unhash_delegation(dp); 9941da177e4SLinus Torvalds } 995ea1da636SNeilBrown while (!list_empty(&clp->cl_openowners)) { 996fe0750e5SJ. Bruce Fields oo = list_entry(clp->cl_openowners.next, struct nfs4_openowner, oo_perclient); 997fe0750e5SJ. Bruce Fields release_openowner(oo); 9981da177e4SLinus Torvalds } 9996ff8da08SJ. Bruce Fields nfsd4_shutdown_callback(clp); 10002bf23875SJ. Bruce Fields if (clp->cl_cb_conn.cb_xprt) 10012bf23875SJ. Bruce Fields svc_xprt_put(clp->cl_cb_conn.cb_xprt); 100284d38ac9SBenny Halevy list_del(&clp->cl_idhash); 100384d38ac9SBenny Halevy list_del(&clp->cl_strhash); 100484d38ac9SBenny Halevy spin_lock(&client_lock); 100584d38ac9SBenny Halevy unhash_client_locked(clp); 100646583e25SBenny Halevy if (atomic_read(&clp->cl_refcount) == 0) 1007b12a05cbSJ. Bruce Fields free_client(clp); 100846583e25SBenny Halevy spin_unlock(&client_lock); 10091da177e4SLinus Torvalds } 10101da177e4SLinus Torvalds 101135bba9a3SJ. Bruce Fields static void copy_verf(struct nfs4_client *target, nfs4_verifier *source) 101235bba9a3SJ. Bruce Fields { 101335bba9a3SJ. Bruce Fields memcpy(target->cl_verifier.data, source->data, 101435bba9a3SJ. Bruce Fields sizeof(target->cl_verifier.data)); 10151da177e4SLinus Torvalds } 10161da177e4SLinus Torvalds 101735bba9a3SJ. Bruce Fields static void copy_clid(struct nfs4_client *target, struct nfs4_client *source) 101835bba9a3SJ. Bruce Fields { 10191da177e4SLinus Torvalds target->cl_clientid.cl_boot = source->cl_clientid.cl_boot; 10201da177e4SLinus Torvalds target->cl_clientid.cl_id = source->cl_clientid.cl_id; 10211da177e4SLinus Torvalds } 10221da177e4SLinus Torvalds 102335bba9a3SJ. Bruce Fields static void copy_cred(struct svc_cred *target, struct svc_cred *source) 102435bba9a3SJ. Bruce Fields { 10251da177e4SLinus Torvalds target->cr_uid = source->cr_uid; 10261da177e4SLinus Torvalds target->cr_gid = source->cr_gid; 10271da177e4SLinus Torvalds target->cr_group_info = source->cr_group_info; 10281da177e4SLinus Torvalds get_group_info(target->cr_group_info); 10291da177e4SLinus Torvalds } 10301da177e4SLinus Torvalds 103135bba9a3SJ. Bruce Fields static int same_name(const char *n1, const char *n2) 1032599e0a22SJ. Bruce Fields { 1033a55370a3SNeilBrown return 0 == memcmp(n1, n2, HEXDIR_LEN); 10341da177e4SLinus Torvalds } 10351da177e4SLinus Torvalds 10361da177e4SLinus Torvalds static int 1037599e0a22SJ. Bruce Fields same_verf(nfs4_verifier *v1, nfs4_verifier *v2) 1038599e0a22SJ. Bruce Fields { 1039599e0a22SJ. Bruce Fields return 0 == memcmp(v1->data, v2->data, sizeof(v1->data)); 10401da177e4SLinus Torvalds } 10411da177e4SLinus Torvalds 10421da177e4SLinus Torvalds static int 1043599e0a22SJ. Bruce Fields same_clid(clientid_t *cl1, clientid_t *cl2) 1044599e0a22SJ. Bruce Fields { 1045599e0a22SJ. Bruce Fields return (cl1->cl_boot == cl2->cl_boot) && (cl1->cl_id == cl2->cl_id); 10461da177e4SLinus Torvalds } 10471da177e4SLinus Torvalds 10481da177e4SLinus Torvalds /* XXX what about NGROUP */ 10491da177e4SLinus Torvalds static int 1050599e0a22SJ. Bruce Fields same_creds(struct svc_cred *cr1, struct svc_cred *cr2) 1051599e0a22SJ. Bruce Fields { 1052599e0a22SJ. Bruce Fields return cr1->cr_uid == cr2->cr_uid; 10531da177e4SLinus Torvalds } 10541da177e4SLinus Torvalds 10555ec7b46cSJ. Bruce Fields static void gen_clid(struct nfs4_client *clp) 10565ec7b46cSJ. Bruce Fields { 10575ec7b46cSJ. Bruce Fields static u32 current_clientid = 1; 10585ec7b46cSJ. Bruce Fields 10591da177e4SLinus Torvalds clp->cl_clientid.cl_boot = boot_time; 10601da177e4SLinus Torvalds clp->cl_clientid.cl_id = current_clientid++; 10611da177e4SLinus Torvalds } 10621da177e4SLinus Torvalds 1063deda2faaSJ. Bruce Fields static void gen_confirm(struct nfs4_client *clp) 1064deda2faaSJ. Bruce Fields { 1065deda2faaSJ. Bruce Fields static u32 i; 10661da177e4SLinus Torvalds u32 *p; 10671da177e4SLinus Torvalds 10681da177e4SLinus Torvalds p = (u32 *)clp->cl_confirm.data; 1069deda2faaSJ. Bruce Fields *p++ = get_seconds(); 1070deda2faaSJ. Bruce Fields *p++ = i++; 10711da177e4SLinus Torvalds } 10721da177e4SLinus Torvalds 10734581d140SJ. Bruce Fields static int 10744581d140SJ. Bruce Fields same_stateid(stateid_t *id_one, stateid_t *id_two) 10754581d140SJ. Bruce Fields { 10764581d140SJ. Bruce Fields if (id_one->si_stateownerid != id_two->si_stateownerid) 10774581d140SJ. Bruce Fields return 0; 10784581d140SJ. Bruce Fields return id_one->si_fileid == id_two->si_fileid; 10794581d140SJ. Bruce Fields } 10804581d140SJ. Bruce Fields 1081f459e453SJ. Bruce Fields static struct nfs4_stid *find_stateid(stateid_t *t) 10824581d140SJ. Bruce Fields { 1083dcef0413SJ. Bruce Fields struct nfs4_stid *s; 10844581d140SJ. Bruce Fields unsigned int hashval; 10854581d140SJ. Bruce Fields 10864581d140SJ. Bruce Fields hashval = stateid_hashval(t->si_stateownerid, t->si_fileid); 1087dcef0413SJ. Bruce Fields list_for_each_entry(s, &stateid_hashtbl[hashval], sc_hash) 1088dcef0413SJ. Bruce Fields if (same_stateid(&s->sc_stateid, t)) 1089f459e453SJ. Bruce Fields return s; 10904d71ab87SJ. Bruce Fields return NULL; 10914581d140SJ. Bruce Fields } 10924d71ab87SJ. Bruce Fields 1093f459e453SJ. Bruce Fields static struct nfs4_ol_stateid *find_ol_stateid(stateid_t *t) 10944d71ab87SJ. Bruce Fields { 1095f459e453SJ. Bruce Fields struct nfs4_stid *s; 10964d71ab87SJ. Bruce Fields 10974d71ab87SJ. Bruce Fields s = find_stateid(t); 10984d71ab87SJ. Bruce Fields if (!s) 10994d71ab87SJ. Bruce Fields return NULL; 1100f459e453SJ. Bruce Fields return openlockstateid(s); 1101f459e453SJ. Bruce Fields } 1102f459e453SJ. Bruce Fields 1103f459e453SJ. Bruce Fields static struct nfs4_stid *find_stateid_by_type(stateid_t *t, char typemask) 1104f459e453SJ. Bruce Fields { 1105f459e453SJ. Bruce Fields struct nfs4_stid *s; 1106f459e453SJ. Bruce Fields 1107f459e453SJ. Bruce Fields s = find_stateid(t); 1108f459e453SJ. Bruce Fields if (!s) 1109f459e453SJ. Bruce Fields return NULL; 1110f459e453SJ. Bruce Fields if (typemask & s->sc_type) 11114d71ab87SJ. Bruce Fields return s; 11124581d140SJ. Bruce Fields return NULL; 11134581d140SJ. Bruce Fields } 11144581d140SJ. Bruce Fields 1115f459e453SJ. Bruce Fields static struct nfs4_ol_stateid *find_ol_stateid_by_type(stateid_t *t, char typemask) 1116f459e453SJ. Bruce Fields { 1117f459e453SJ. Bruce Fields struct nfs4_stid *s; 1118f459e453SJ. Bruce Fields 1119f459e453SJ. Bruce Fields s = find_stateid_by_type(t, typemask); 1120f459e453SJ. Bruce Fields if (!s) 1121f459e453SJ. Bruce Fields return NULL; 1122f459e453SJ. Bruce Fields return openlockstateid(s); 1123f459e453SJ. Bruce Fields } 1124f459e453SJ. Bruce Fields 1125b09333c4SRicardo Labiaga static struct nfs4_client *create_client(struct xdr_netobj name, char *recdir, 1126b09333c4SRicardo Labiaga struct svc_rqst *rqstp, nfs4_verifier *verf) 1127b09333c4SRicardo Labiaga { 1128b09333c4SRicardo Labiaga struct nfs4_client *clp; 1129b09333c4SRicardo Labiaga struct sockaddr *sa = svc_addr(rqstp); 1130b09333c4SRicardo Labiaga char *princ; 1131b09333c4SRicardo Labiaga 1132b09333c4SRicardo Labiaga clp = alloc_client(name); 1133b09333c4SRicardo Labiaga if (clp == NULL) 1134b09333c4SRicardo Labiaga return NULL; 1135b09333c4SRicardo Labiaga 1136792c95ddSJ. Bruce Fields INIT_LIST_HEAD(&clp->cl_sessions); 1137792c95ddSJ. Bruce Fields 1138b09333c4SRicardo Labiaga princ = svc_gss_principal(rqstp); 1139b09333c4SRicardo Labiaga if (princ) { 1140b09333c4SRicardo Labiaga clp->cl_principal = kstrdup(princ, GFP_KERNEL); 1141b09333c4SRicardo Labiaga if (clp->cl_principal == NULL) { 1142b09333c4SRicardo Labiaga free_client(clp); 1143b09333c4SRicardo Labiaga return NULL; 1144b09333c4SRicardo Labiaga } 1145b09333c4SRicardo Labiaga } 1146b09333c4SRicardo Labiaga 1147b09333c4SRicardo Labiaga memcpy(clp->cl_recdir, recdir, HEXDIR_LEN); 114846583e25SBenny Halevy atomic_set(&clp->cl_refcount, 0); 114977a3569dSJ. Bruce Fields clp->cl_cb_state = NFSD4_CB_UNKNOWN; 1150b09333c4SRicardo Labiaga INIT_LIST_HEAD(&clp->cl_idhash); 1151b09333c4SRicardo Labiaga INIT_LIST_HEAD(&clp->cl_strhash); 1152b09333c4SRicardo Labiaga INIT_LIST_HEAD(&clp->cl_openowners); 1153b09333c4SRicardo Labiaga INIT_LIST_HEAD(&clp->cl_delegations); 1154b09333c4SRicardo Labiaga INIT_LIST_HEAD(&clp->cl_lru); 11555ce8ba25SJ. Bruce Fields INIT_LIST_HEAD(&clp->cl_callbacks); 11566ff8da08SJ. Bruce Fields spin_lock_init(&clp->cl_lock); 1157cee277d9SJ. Bruce Fields INIT_WORK(&clp->cl_cb_null.cb_work, nfsd4_do_callback_rpc); 115807cd4909SBenny Halevy clp->cl_time = get_seconds(); 1159b09333c4SRicardo Labiaga clear_bit(0, &clp->cl_cb_slot_busy); 1160b09333c4SRicardo Labiaga rpc_init_wait_queue(&clp->cl_cb_waitq, "Backchannel slot table"); 1161b09333c4SRicardo Labiaga copy_verf(clp, verf); 1162b09333c4SRicardo Labiaga rpc_copy_addr((struct sockaddr *) &clp->cl_addr, sa); 1163b09333c4SRicardo Labiaga clp->cl_flavor = rqstp->rq_flavor; 1164b09333c4SRicardo Labiaga copy_cred(&clp->cl_cred, &rqstp->rq_cred); 1165b09333c4SRicardo Labiaga gen_confirm(clp); 1166edd76786SJ. Bruce Fields clp->cl_cb_session = NULL; 1167b09333c4SRicardo Labiaga return clp; 1168b09333c4SRicardo Labiaga } 1169b09333c4SRicardo Labiaga 117035bba9a3SJ. Bruce Fields static int check_name(struct xdr_netobj name) 117135bba9a3SJ. Bruce Fields { 11721da177e4SLinus Torvalds if (name.len == 0) 11731da177e4SLinus Torvalds return 0; 11741da177e4SLinus Torvalds if (name.len > NFS4_OPAQUE_LIMIT) { 11752fdada03SJ. Bruce Fields dprintk("NFSD: check_name: name too long(%d)!\n", name.len); 11761da177e4SLinus Torvalds return 0; 11771da177e4SLinus Torvalds } 11781da177e4SLinus Torvalds return 1; 11791da177e4SLinus Torvalds } 11801da177e4SLinus Torvalds 1181fd39ca9aSNeilBrown static void 11821da177e4SLinus Torvalds add_to_unconfirmed(struct nfs4_client *clp, unsigned int strhashval) 11831da177e4SLinus Torvalds { 11841da177e4SLinus Torvalds unsigned int idhashval; 11851da177e4SLinus Torvalds 11861da177e4SLinus Torvalds list_add(&clp->cl_strhash, &unconf_str_hashtbl[strhashval]); 11871da177e4SLinus Torvalds idhashval = clientid_hashval(clp->cl_clientid.cl_id); 11881da177e4SLinus Torvalds list_add(&clp->cl_idhash, &unconf_id_hashtbl[idhashval]); 118936acb66bSBenny Halevy renew_client(clp); 11901da177e4SLinus Torvalds } 11911da177e4SLinus Torvalds 1192fd39ca9aSNeilBrown static void 11931da177e4SLinus Torvalds move_to_confirmed(struct nfs4_client *clp) 11941da177e4SLinus Torvalds { 11951da177e4SLinus Torvalds unsigned int idhashval = clientid_hashval(clp->cl_clientid.cl_id); 11961da177e4SLinus Torvalds unsigned int strhashval; 11971da177e4SLinus Torvalds 11981da177e4SLinus Torvalds dprintk("NFSD: move_to_confirm nfs4_client %p\n", clp); 1199f116629dSAkinobu Mita list_move(&clp->cl_idhash, &conf_id_hashtbl[idhashval]); 1200a55370a3SNeilBrown strhashval = clientstr_hashval(clp->cl_recdir); 1201328efbabSBenny Halevy list_move(&clp->cl_strhash, &conf_str_hashtbl[strhashval]); 12021da177e4SLinus Torvalds renew_client(clp); 12031da177e4SLinus Torvalds } 12041da177e4SLinus Torvalds 12051da177e4SLinus Torvalds static struct nfs4_client * 12061da177e4SLinus Torvalds find_confirmed_client(clientid_t *clid) 12071da177e4SLinus Torvalds { 12081da177e4SLinus Torvalds struct nfs4_client *clp; 12091da177e4SLinus Torvalds unsigned int idhashval = clientid_hashval(clid->cl_id); 12101da177e4SLinus Torvalds 12111da177e4SLinus Torvalds list_for_each_entry(clp, &conf_id_hashtbl[idhashval], cl_idhash) { 1212599e0a22SJ. Bruce Fields if (same_clid(&clp->cl_clientid, clid)) 12131da177e4SLinus Torvalds return clp; 12141da177e4SLinus Torvalds } 12151da177e4SLinus Torvalds return NULL; 12161da177e4SLinus Torvalds } 12171da177e4SLinus Torvalds 12181da177e4SLinus Torvalds static struct nfs4_client * 12191da177e4SLinus Torvalds find_unconfirmed_client(clientid_t *clid) 12201da177e4SLinus Torvalds { 12211da177e4SLinus Torvalds struct nfs4_client *clp; 12221da177e4SLinus Torvalds unsigned int idhashval = clientid_hashval(clid->cl_id); 12231da177e4SLinus Torvalds 12241da177e4SLinus Torvalds list_for_each_entry(clp, &unconf_id_hashtbl[idhashval], cl_idhash) { 1225599e0a22SJ. Bruce Fields if (same_clid(&clp->cl_clientid, clid)) 12261da177e4SLinus Torvalds return clp; 12271da177e4SLinus Torvalds } 12281da177e4SLinus Torvalds return NULL; 12291da177e4SLinus Torvalds } 12301da177e4SLinus Torvalds 12316e5f15c9SJ. Bruce Fields static bool clp_used_exchangeid(struct nfs4_client *clp) 1232a1bcecd2SAndy Adamson { 12336e5f15c9SJ. Bruce Fields return clp->cl_exchange_flags != 0; 1234a1bcecd2SAndy Adamson } 1235a1bcecd2SAndy Adamson 123628ce6054SNeilBrown static struct nfs4_client * 1237e203d506SJ. Bruce Fields find_confirmed_client_by_str(const char *dname, unsigned int hashval) 123828ce6054SNeilBrown { 123928ce6054SNeilBrown struct nfs4_client *clp; 124028ce6054SNeilBrown 124128ce6054SNeilBrown list_for_each_entry(clp, &conf_str_hashtbl[hashval], cl_strhash) { 1242e203d506SJ. Bruce Fields if (same_name(clp->cl_recdir, dname)) 124328ce6054SNeilBrown return clp; 124428ce6054SNeilBrown } 124528ce6054SNeilBrown return NULL; 124628ce6054SNeilBrown } 124728ce6054SNeilBrown 124828ce6054SNeilBrown static struct nfs4_client * 1249e203d506SJ. Bruce Fields find_unconfirmed_client_by_str(const char *dname, unsigned int hashval) 125028ce6054SNeilBrown { 125128ce6054SNeilBrown struct nfs4_client *clp; 125228ce6054SNeilBrown 125328ce6054SNeilBrown list_for_each_entry(clp, &unconf_str_hashtbl[hashval], cl_strhash) { 1254e203d506SJ. Bruce Fields if (same_name(clp->cl_recdir, dname)) 125528ce6054SNeilBrown return clp; 125628ce6054SNeilBrown } 125728ce6054SNeilBrown return NULL; 125828ce6054SNeilBrown } 125928ce6054SNeilBrown 12606f3d772fSTakuma Umeya static void rpc_svcaddr2sockaddr(struct sockaddr *sa, unsigned short family, union svc_addr_u *svcaddr) 12616f3d772fSTakuma Umeya { 12626f3d772fSTakuma Umeya switch (family) { 12636f3d772fSTakuma Umeya case AF_INET: 12646f3d772fSTakuma Umeya ((struct sockaddr_in *)sa)->sin_family = AF_INET; 12656f3d772fSTakuma Umeya ((struct sockaddr_in *)sa)->sin_addr = svcaddr->addr; 12666f3d772fSTakuma Umeya return; 12676f3d772fSTakuma Umeya case AF_INET6: 12686f3d772fSTakuma Umeya ((struct sockaddr_in6 *)sa)->sin6_family = AF_INET6; 12696f3d772fSTakuma Umeya ((struct sockaddr_in6 *)sa)->sin6_addr = svcaddr->addr6; 12706f3d772fSTakuma Umeya return; 12716f3d772fSTakuma Umeya } 12726f3d772fSTakuma Umeya } 12736f3d772fSTakuma Umeya 1274fd39ca9aSNeilBrown static void 12756f3d772fSTakuma Umeya gen_callback(struct nfs4_client *clp, struct nfsd4_setclientid *se, struct svc_rqst *rqstp) 12761da177e4SLinus Torvalds { 127707263f1eSJ. Bruce Fields struct nfs4_cb_conn *conn = &clp->cl_cb_conn; 12786f3d772fSTakuma Umeya struct sockaddr *sa = svc_addr(rqstp); 12796f3d772fSTakuma Umeya u32 scopeid = rpc_get_scope_id(sa); 12807077ecbaSJeff Layton unsigned short expected_family; 12811da177e4SLinus Torvalds 12827077ecbaSJeff Layton /* Currently, we only support tcp and tcp6 for the callback channel */ 12837077ecbaSJeff Layton if (se->se_callback_netid_len == 3 && 12847077ecbaSJeff Layton !memcmp(se->se_callback_netid_val, "tcp", 3)) 12857077ecbaSJeff Layton expected_family = AF_INET; 12867077ecbaSJeff Layton else if (se->se_callback_netid_len == 4 && 12877077ecbaSJeff Layton !memcmp(se->se_callback_netid_val, "tcp6", 4)) 12887077ecbaSJeff Layton expected_family = AF_INET6; 12897077ecbaSJeff Layton else 12901da177e4SLinus Torvalds goto out_err; 12911da177e4SLinus Torvalds 129207263f1eSJ. Bruce Fields conn->cb_addrlen = rpc_uaddr2sockaddr(se->se_callback_addr_val, 1293aa9a4ec7SJeff Layton se->se_callback_addr_len, 129407263f1eSJ. Bruce Fields (struct sockaddr *)&conn->cb_addr, 129507263f1eSJ. Bruce Fields sizeof(conn->cb_addr)); 1296aa9a4ec7SJeff Layton 129707263f1eSJ. Bruce Fields if (!conn->cb_addrlen || conn->cb_addr.ss_family != expected_family) 12981da177e4SLinus Torvalds goto out_err; 1299aa9a4ec7SJeff Layton 130007263f1eSJ. Bruce Fields if (conn->cb_addr.ss_family == AF_INET6) 130107263f1eSJ. Bruce Fields ((struct sockaddr_in6 *)&conn->cb_addr)->sin6_scope_id = scopeid; 1302fbf4665fSJeff Layton 130307263f1eSJ. Bruce Fields conn->cb_prog = se->se_callback_prog; 130407263f1eSJ. Bruce Fields conn->cb_ident = se->se_callback_ident; 13056f3d772fSTakuma Umeya rpc_svcaddr2sockaddr((struct sockaddr *)&conn->cb_saddr, expected_family, &rqstp->rq_daddr); 13061da177e4SLinus Torvalds return; 13071da177e4SLinus Torvalds out_err: 130807263f1eSJ. Bruce Fields conn->cb_addr.ss_family = AF_UNSPEC; 130907263f1eSJ. Bruce Fields conn->cb_addrlen = 0; 1310849823c5SNeil Brown dprintk(KERN_INFO "NFSD: this client (clientid %08x/%08x) " 13111da177e4SLinus Torvalds "will not receive delegations\n", 13121da177e4SLinus Torvalds clp->cl_clientid.cl_boot, clp->cl_clientid.cl_id); 13131da177e4SLinus Torvalds 13141da177e4SLinus Torvalds return; 13151da177e4SLinus Torvalds } 13161da177e4SLinus Torvalds 1317074fe897SAndy Adamson /* 1318557ce264SAndy Adamson * Cache a reply. nfsd4_check_drc_limit() has bounded the cache size. 1319074fe897SAndy Adamson */ 1320074fe897SAndy Adamson void 1321074fe897SAndy Adamson nfsd4_store_cache_entry(struct nfsd4_compoundres *resp) 1322074fe897SAndy Adamson { 1323557ce264SAndy Adamson struct nfsd4_slot *slot = resp->cstate.slot; 1324557ce264SAndy Adamson unsigned int base; 1325074fe897SAndy Adamson 1326557ce264SAndy Adamson dprintk("--> %s slot %p\n", __func__, slot); 1327074fe897SAndy Adamson 1328557ce264SAndy Adamson slot->sl_opcnt = resp->opcnt; 1329557ce264SAndy Adamson slot->sl_status = resp->cstate.status; 1330bf864a31SAndy Adamson 1331bf864a31SAndy Adamson if (nfsd4_not_cached(resp)) { 1332557ce264SAndy Adamson slot->sl_datalen = 0; 1333bf864a31SAndy Adamson return; 1334bf864a31SAndy Adamson } 1335557ce264SAndy Adamson slot->sl_datalen = (char *)resp->p - (char *)resp->cstate.datap; 1336557ce264SAndy Adamson base = (char *)resp->cstate.datap - 1337557ce264SAndy Adamson (char *)resp->xbuf->head[0].iov_base; 1338557ce264SAndy Adamson if (read_bytes_from_xdr_buf(resp->xbuf, base, slot->sl_data, 1339557ce264SAndy Adamson slot->sl_datalen)) 1340557ce264SAndy Adamson WARN("%s: sessions DRC could not cache compound\n", __func__); 1341557ce264SAndy Adamson return; 1342074fe897SAndy Adamson } 1343074fe897SAndy Adamson 1344074fe897SAndy Adamson /* 1345abfabf8cSAndy Adamson * Encode the replay sequence operation from the slot values. 1346abfabf8cSAndy Adamson * If cachethis is FALSE encode the uncached rep error on the next 1347abfabf8cSAndy Adamson * operation which sets resp->p and increments resp->opcnt for 1348abfabf8cSAndy Adamson * nfs4svc_encode_compoundres. 1349abfabf8cSAndy Adamson * 1350074fe897SAndy Adamson */ 1351abfabf8cSAndy Adamson static __be32 1352abfabf8cSAndy Adamson nfsd4_enc_sequence_replay(struct nfsd4_compoundargs *args, 1353abfabf8cSAndy Adamson struct nfsd4_compoundres *resp) 1354074fe897SAndy Adamson { 1355abfabf8cSAndy Adamson struct nfsd4_op *op; 1356abfabf8cSAndy Adamson struct nfsd4_slot *slot = resp->cstate.slot; 1357074fe897SAndy Adamson 1358abfabf8cSAndy Adamson dprintk("--> %s resp->opcnt %d cachethis %u \n", __func__, 1359557ce264SAndy Adamson resp->opcnt, resp->cstate.slot->sl_cachethis); 1360abfabf8cSAndy Adamson 1361abfabf8cSAndy Adamson /* Encode the replayed sequence operation */ 1362abfabf8cSAndy Adamson op = &args->ops[resp->opcnt - 1]; 1363abfabf8cSAndy Adamson nfsd4_encode_operation(resp, op); 1364abfabf8cSAndy Adamson 1365abfabf8cSAndy Adamson /* Return nfserr_retry_uncached_rep in next operation. */ 1366557ce264SAndy Adamson if (args->opcnt > 1 && slot->sl_cachethis == 0) { 1367abfabf8cSAndy Adamson op = &args->ops[resp->opcnt++]; 1368abfabf8cSAndy Adamson op->status = nfserr_retry_uncached_rep; 1369abfabf8cSAndy Adamson nfsd4_encode_operation(resp, op); 1370074fe897SAndy Adamson } 1371abfabf8cSAndy Adamson return op->status; 1372074fe897SAndy Adamson } 1373074fe897SAndy Adamson 1374074fe897SAndy Adamson /* 1375557ce264SAndy Adamson * The sequence operation is not cached because we can use the slot and 1376557ce264SAndy Adamson * session values. 1377074fe897SAndy Adamson */ 1378074fe897SAndy Adamson __be32 1379bf864a31SAndy Adamson nfsd4_replay_cache_entry(struct nfsd4_compoundres *resp, 1380bf864a31SAndy Adamson struct nfsd4_sequence *seq) 1381074fe897SAndy Adamson { 1382557ce264SAndy Adamson struct nfsd4_slot *slot = resp->cstate.slot; 1383074fe897SAndy Adamson __be32 status; 1384074fe897SAndy Adamson 1385557ce264SAndy Adamson dprintk("--> %s slot %p\n", __func__, slot); 1386074fe897SAndy Adamson 1387abfabf8cSAndy Adamson /* Either returns 0 or nfserr_retry_uncached */ 1388abfabf8cSAndy Adamson status = nfsd4_enc_sequence_replay(resp->rqstp->rq_argp, resp); 1389abfabf8cSAndy Adamson if (status == nfserr_retry_uncached_rep) 1390abfabf8cSAndy Adamson return status; 1391074fe897SAndy Adamson 1392557ce264SAndy Adamson /* The sequence operation has been encoded, cstate->datap set. */ 1393557ce264SAndy Adamson memcpy(resp->cstate.datap, slot->sl_data, slot->sl_datalen); 1394074fe897SAndy Adamson 1395557ce264SAndy Adamson resp->opcnt = slot->sl_opcnt; 1396557ce264SAndy Adamson resp->p = resp->cstate.datap + XDR_QUADLEN(slot->sl_datalen); 1397557ce264SAndy Adamson status = slot->sl_status; 1398074fe897SAndy Adamson 1399074fe897SAndy Adamson return status; 1400074fe897SAndy Adamson } 1401074fe897SAndy Adamson 14020733d213SAndy Adamson /* 14030733d213SAndy Adamson * Set the exchange_id flags returned by the server. 14040733d213SAndy Adamson */ 14050733d213SAndy Adamson static void 14060733d213SAndy Adamson nfsd4_set_ex_flags(struct nfs4_client *new, struct nfsd4_exchange_id *clid) 14070733d213SAndy Adamson { 14080733d213SAndy Adamson /* pNFS is not supported */ 14090733d213SAndy Adamson new->cl_exchange_flags |= EXCHGID4_FLAG_USE_NON_PNFS; 14100733d213SAndy Adamson 14110733d213SAndy Adamson /* Referrals are supported, Migration is not. */ 14120733d213SAndy Adamson new->cl_exchange_flags |= EXCHGID4_FLAG_SUPP_MOVED_REFER; 14130733d213SAndy Adamson 14140733d213SAndy Adamson /* set the wire flags to return to client. */ 14150733d213SAndy Adamson clid->flags = new->cl_exchange_flags; 14160733d213SAndy Adamson } 14170733d213SAndy Adamson 1418b37ad28bSAl Viro __be32 1419069b6ad4SAndy Adamson nfsd4_exchange_id(struct svc_rqst *rqstp, 1420069b6ad4SAndy Adamson struct nfsd4_compound_state *cstate, 1421069b6ad4SAndy Adamson struct nfsd4_exchange_id *exid) 1422069b6ad4SAndy Adamson { 14230733d213SAndy Adamson struct nfs4_client *unconf, *conf, *new; 14240733d213SAndy Adamson int status; 14250733d213SAndy Adamson unsigned int strhashval; 14260733d213SAndy Adamson char dname[HEXDIR_LEN]; 1427363168b4SJeff Layton char addr_str[INET6_ADDRSTRLEN]; 14280733d213SAndy Adamson nfs4_verifier verf = exid->verifier; 1429363168b4SJeff Layton struct sockaddr *sa = svc_addr(rqstp); 14300733d213SAndy Adamson 1431363168b4SJeff Layton rpc_ntop(sa, addr_str, sizeof(addr_str)); 14320733d213SAndy Adamson dprintk("%s rqstp=%p exid=%p clname.len=%u clname.data=%p " 1433363168b4SJeff Layton "ip_addr=%s flags %x, spa_how %d\n", 14340733d213SAndy Adamson __func__, rqstp, exid, exid->clname.len, exid->clname.data, 1435363168b4SJeff Layton addr_str, exid->flags, exid->spa_how); 14360733d213SAndy Adamson 14370733d213SAndy Adamson if (!check_name(exid->clname) || (exid->flags & ~EXCHGID4_FLAG_MASK_A)) 14380733d213SAndy Adamson return nfserr_inval; 14390733d213SAndy Adamson 14400733d213SAndy Adamson /* Currently only support SP4_NONE */ 14410733d213SAndy Adamson switch (exid->spa_how) { 14420733d213SAndy Adamson case SP4_NONE: 14430733d213SAndy Adamson break; 14440733d213SAndy Adamson case SP4_SSV: 1445044bc1d4SJ. Bruce Fields return nfserr_serverfault; 14460733d213SAndy Adamson default: 14470733d213SAndy Adamson BUG(); /* checked by xdr code */ 14480733d213SAndy Adamson case SP4_MACH_CRED: 14490733d213SAndy Adamson return nfserr_serverfault; /* no excuse :-/ */ 14500733d213SAndy Adamson } 14510733d213SAndy Adamson 14520733d213SAndy Adamson status = nfs4_make_rec_clidname(dname, &exid->clname); 14530733d213SAndy Adamson 14540733d213SAndy Adamson if (status) 14550733d213SAndy Adamson goto error; 14560733d213SAndy Adamson 14570733d213SAndy Adamson strhashval = clientstr_hashval(dname); 14580733d213SAndy Adamson 14590733d213SAndy Adamson nfs4_lock_state(); 14600733d213SAndy Adamson status = nfs_ok; 14610733d213SAndy Adamson 1462e203d506SJ. Bruce Fields conf = find_confirmed_client_by_str(dname, strhashval); 14630733d213SAndy Adamson if (conf) { 1464e203d506SJ. Bruce Fields if (!clp_used_exchangeid(conf)) { 1465e203d506SJ. Bruce Fields status = nfserr_clid_inuse; /* XXX: ? */ 1466e203d506SJ. Bruce Fields goto out; 1467e203d506SJ. Bruce Fields } 14680733d213SAndy Adamson if (!same_verf(&verf, &conf->cl_verifier)) { 14690733d213SAndy Adamson /* 18.35.4 case 8 */ 14700733d213SAndy Adamson if (exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A) { 14710733d213SAndy Adamson status = nfserr_not_same; 14720733d213SAndy Adamson goto out; 14730733d213SAndy Adamson } 14740733d213SAndy Adamson /* Client reboot: destroy old state */ 14750733d213SAndy Adamson expire_client(conf); 14760733d213SAndy Adamson goto out_new; 14770733d213SAndy Adamson } 14780733d213SAndy Adamson if (!same_creds(&conf->cl_cred, &rqstp->rq_cred)) { 14790733d213SAndy Adamson /* 18.35.4 case 9 */ 14800733d213SAndy Adamson if (exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A) { 14810733d213SAndy Adamson status = nfserr_perm; 14820733d213SAndy Adamson goto out; 14830733d213SAndy Adamson } 14840733d213SAndy Adamson expire_client(conf); 14850733d213SAndy Adamson goto out_new; 14860733d213SAndy Adamson } 14870733d213SAndy Adamson /* 14880733d213SAndy Adamson * Set bit when the owner id and verifier map to an already 14890733d213SAndy Adamson * confirmed client id (18.35.3). 14900733d213SAndy Adamson */ 14910733d213SAndy Adamson exid->flags |= EXCHGID4_FLAG_CONFIRMED_R; 14920733d213SAndy Adamson 14930733d213SAndy Adamson /* 14940733d213SAndy Adamson * Falling into 18.35.4 case 2, possible router replay. 14950733d213SAndy Adamson * Leave confirmed record intact and return same result. 14960733d213SAndy Adamson */ 14970733d213SAndy Adamson copy_verf(conf, &verf); 14980733d213SAndy Adamson new = conf; 14990733d213SAndy Adamson goto out_copy; 15006ddbbbfeSMike Sager } 15016ddbbbfeSMike Sager 15020733d213SAndy Adamson /* 18.35.4 case 7 */ 15030733d213SAndy Adamson if (exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A) { 15040733d213SAndy Adamson status = nfserr_noent; 15050733d213SAndy Adamson goto out; 15060733d213SAndy Adamson } 15070733d213SAndy Adamson 1508e203d506SJ. Bruce Fields unconf = find_unconfirmed_client_by_str(dname, strhashval); 15090733d213SAndy Adamson if (unconf) { 15100733d213SAndy Adamson /* 15110733d213SAndy Adamson * Possible retry or client restart. Per 18.35.4 case 4, 15120733d213SAndy Adamson * a new unconfirmed record should be generated regardless 15130733d213SAndy Adamson * of whether any properties have changed. 15140733d213SAndy Adamson */ 15150733d213SAndy Adamson expire_client(unconf); 15160733d213SAndy Adamson } 15170733d213SAndy Adamson 15180733d213SAndy Adamson out_new: 15190733d213SAndy Adamson /* Normal case */ 1520b09333c4SRicardo Labiaga new = create_client(exid->clname, dname, rqstp, &verf); 15210733d213SAndy Adamson if (new == NULL) { 15224731030dSJ. Bruce Fields status = nfserr_jukebox; 15230733d213SAndy Adamson goto out; 15240733d213SAndy Adamson } 15250733d213SAndy Adamson 15260733d213SAndy Adamson gen_clid(new); 15270733d213SAndy Adamson add_to_unconfirmed(new, strhashval); 15280733d213SAndy Adamson out_copy: 15290733d213SAndy Adamson exid->clientid.cl_boot = new->cl_clientid.cl_boot; 15300733d213SAndy Adamson exid->clientid.cl_id = new->cl_clientid.cl_id; 15310733d213SAndy Adamson 153238eb76a5SAndy Adamson exid->seqid = 1; 15330733d213SAndy Adamson nfsd4_set_ex_flags(new, exid); 15340733d213SAndy Adamson 15350733d213SAndy Adamson dprintk("nfsd4_exchange_id seqid %d flags %x\n", 153649557cc7SAndy Adamson new->cl_cs_slot.sl_seqid, new->cl_exchange_flags); 15370733d213SAndy Adamson status = nfs_ok; 15380733d213SAndy Adamson 15390733d213SAndy Adamson out: 15400733d213SAndy Adamson nfs4_unlock_state(); 15410733d213SAndy Adamson error: 15420733d213SAndy Adamson dprintk("nfsd4_exchange_id returns %d\n", ntohl(status)); 15430733d213SAndy Adamson return status; 1544069b6ad4SAndy Adamson } 1545069b6ad4SAndy Adamson 1546b85d4c01SBenny Halevy static int 154788e588d5SAndy Adamson check_slot_seqid(u32 seqid, u32 slot_seqid, int slot_inuse) 1548b85d4c01SBenny Halevy { 154988e588d5SAndy Adamson dprintk("%s enter. seqid %d slot_seqid %d\n", __func__, seqid, 155088e588d5SAndy Adamson slot_seqid); 1551b85d4c01SBenny Halevy 1552b85d4c01SBenny Halevy /* The slot is in use, and no response has been sent. */ 155388e588d5SAndy Adamson if (slot_inuse) { 155488e588d5SAndy Adamson if (seqid == slot_seqid) 1555b85d4c01SBenny Halevy return nfserr_jukebox; 1556b85d4c01SBenny Halevy else 1557b85d4c01SBenny Halevy return nfserr_seq_misordered; 1558b85d4c01SBenny Halevy } 1559b85d4c01SBenny Halevy /* Normal */ 156088e588d5SAndy Adamson if (likely(seqid == slot_seqid + 1)) 1561b85d4c01SBenny Halevy return nfs_ok; 1562b85d4c01SBenny Halevy /* Replay */ 156388e588d5SAndy Adamson if (seqid == slot_seqid) 1564b85d4c01SBenny Halevy return nfserr_replay_cache; 1565b85d4c01SBenny Halevy /* Wraparound */ 156688e588d5SAndy Adamson if (seqid == 1 && (slot_seqid + 1) == 0) 1567b85d4c01SBenny Halevy return nfs_ok; 1568b85d4c01SBenny Halevy /* Misordered replay or misordered new request */ 1569b85d4c01SBenny Halevy return nfserr_seq_misordered; 1570b85d4c01SBenny Halevy } 1571b85d4c01SBenny Halevy 157249557cc7SAndy Adamson /* 157349557cc7SAndy Adamson * Cache the create session result into the create session single DRC 157449557cc7SAndy Adamson * slot cache by saving the xdr structure. sl_seqid has been set. 157549557cc7SAndy Adamson * Do this for solo or embedded create session operations. 157649557cc7SAndy Adamson */ 157749557cc7SAndy Adamson static void 157849557cc7SAndy Adamson nfsd4_cache_create_session(struct nfsd4_create_session *cr_ses, 157949557cc7SAndy Adamson struct nfsd4_clid_slot *slot, int nfserr) 158049557cc7SAndy Adamson { 158149557cc7SAndy Adamson slot->sl_status = nfserr; 158249557cc7SAndy Adamson memcpy(&slot->sl_cr_ses, cr_ses, sizeof(*cr_ses)); 158349557cc7SAndy Adamson } 158449557cc7SAndy Adamson 158549557cc7SAndy Adamson static __be32 158649557cc7SAndy Adamson nfsd4_replay_create_session(struct nfsd4_create_session *cr_ses, 158749557cc7SAndy Adamson struct nfsd4_clid_slot *slot) 158849557cc7SAndy Adamson { 158949557cc7SAndy Adamson memcpy(cr_ses, &slot->sl_cr_ses, sizeof(*cr_ses)); 159049557cc7SAndy Adamson return slot->sl_status; 159149557cc7SAndy Adamson } 159249557cc7SAndy Adamson 15931b74c25bSMi Jinlong #define NFSD_MIN_REQ_HDR_SEQ_SZ ((\ 15941b74c25bSMi Jinlong 2 * 2 + /* credential,verifier: AUTH_NULL, length 0 */ \ 15951b74c25bSMi Jinlong 1 + /* MIN tag is length with zero, only length */ \ 15961b74c25bSMi Jinlong 3 + /* version, opcount, opcode */ \ 15971b74c25bSMi Jinlong XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \ 15981b74c25bSMi Jinlong /* seqid, slotID, slotID, cache */ \ 15991b74c25bSMi Jinlong 4 ) * sizeof(__be32)) 16001b74c25bSMi Jinlong 16011b74c25bSMi Jinlong #define NFSD_MIN_RESP_HDR_SEQ_SZ ((\ 16021b74c25bSMi Jinlong 2 + /* verifier: AUTH_NULL, length 0 */\ 16031b74c25bSMi Jinlong 1 + /* status */ \ 16041b74c25bSMi Jinlong 1 + /* MIN tag is length with zero, only length */ \ 16051b74c25bSMi Jinlong 3 + /* opcount, opcode, opstatus*/ \ 16061b74c25bSMi Jinlong XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \ 16071b74c25bSMi Jinlong /* seqid, slotID, slotID, slotID, status */ \ 16081b74c25bSMi Jinlong 5 ) * sizeof(__be32)) 16091b74c25bSMi Jinlong 16101b74c25bSMi Jinlong static __be32 check_forechannel_attrs(struct nfsd4_channel_attrs fchannel) 16111b74c25bSMi Jinlong { 16121b74c25bSMi Jinlong return fchannel.maxreq_sz < NFSD_MIN_REQ_HDR_SEQ_SZ 16131b74c25bSMi Jinlong || fchannel.maxresp_sz < NFSD_MIN_RESP_HDR_SEQ_SZ; 16141b74c25bSMi Jinlong } 16151b74c25bSMi Jinlong 1616069b6ad4SAndy Adamson __be32 1617069b6ad4SAndy Adamson nfsd4_create_session(struct svc_rqst *rqstp, 1618069b6ad4SAndy Adamson struct nfsd4_compound_state *cstate, 1619069b6ad4SAndy Adamson struct nfsd4_create_session *cr_ses) 1620069b6ad4SAndy Adamson { 1621363168b4SJeff Layton struct sockaddr *sa = svc_addr(rqstp); 1622ec6b5d7bSAndy Adamson struct nfs4_client *conf, *unconf; 1623ac7c46f2SJ. Bruce Fields struct nfsd4_session *new; 162449557cc7SAndy Adamson struct nfsd4_clid_slot *cs_slot = NULL; 162586c3e16cSJ. Bruce Fields bool confirm_me = false; 1626ec6b5d7bSAndy Adamson int status = 0; 1627ec6b5d7bSAndy Adamson 1628a62573dcSMi Jinlong if (cr_ses->flags & ~SESSION4_FLAG_MASK_A) 1629a62573dcSMi Jinlong return nfserr_inval; 1630a62573dcSMi Jinlong 1631ec6b5d7bSAndy Adamson nfs4_lock_state(); 1632ec6b5d7bSAndy Adamson unconf = find_unconfirmed_client(&cr_ses->clientid); 1633ec6b5d7bSAndy Adamson conf = find_confirmed_client(&cr_ses->clientid); 1634ec6b5d7bSAndy Adamson 1635ec6b5d7bSAndy Adamson if (conf) { 163649557cc7SAndy Adamson cs_slot = &conf->cl_cs_slot; 163749557cc7SAndy Adamson status = check_slot_seqid(cr_ses->seqid, cs_slot->sl_seqid, 0); 163838eb76a5SAndy Adamson if (status == nfserr_replay_cache) { 1639ec6b5d7bSAndy Adamson dprintk("Got a create_session replay! seqid= %d\n", 164049557cc7SAndy Adamson cs_slot->sl_seqid); 164138eb76a5SAndy Adamson /* Return the cached reply status */ 164249557cc7SAndy Adamson status = nfsd4_replay_create_session(cr_ses, cs_slot); 164338eb76a5SAndy Adamson goto out; 164449557cc7SAndy Adamson } else if (cr_ses->seqid != cs_slot->sl_seqid + 1) { 1645ec6b5d7bSAndy Adamson status = nfserr_seq_misordered; 1646ec6b5d7bSAndy Adamson dprintk("Sequence misordered!\n"); 1647ec6b5d7bSAndy Adamson dprintk("Expected seqid= %d but got seqid= %d\n", 164849557cc7SAndy Adamson cs_slot->sl_seqid, cr_ses->seqid); 1649ec6b5d7bSAndy Adamson goto out; 1650ec6b5d7bSAndy Adamson } 1651ec6b5d7bSAndy Adamson } else if (unconf) { 1652ec6b5d7bSAndy Adamson if (!same_creds(&unconf->cl_cred, &rqstp->rq_cred) || 1653363168b4SJeff Layton !rpc_cmp_addr(sa, (struct sockaddr *) &unconf->cl_addr)) { 1654ec6b5d7bSAndy Adamson status = nfserr_clid_inuse; 1655ec6b5d7bSAndy Adamson goto out; 1656ec6b5d7bSAndy Adamson } 1657ec6b5d7bSAndy Adamson 165849557cc7SAndy Adamson cs_slot = &unconf->cl_cs_slot; 165949557cc7SAndy Adamson status = check_slot_seqid(cr_ses->seqid, cs_slot->sl_seqid, 0); 166038eb76a5SAndy Adamson if (status) { 166138eb76a5SAndy Adamson /* an unconfirmed replay returns misordered */ 1662ec6b5d7bSAndy Adamson status = nfserr_seq_misordered; 1663cd5b8144SJ. Bruce Fields goto out; 1664ec6b5d7bSAndy Adamson } 1665ec6b5d7bSAndy Adamson 166686c3e16cSJ. Bruce Fields confirm_me = true; 1667ec6b5d7bSAndy Adamson conf = unconf; 1668ec6b5d7bSAndy Adamson } else { 1669ec6b5d7bSAndy Adamson status = nfserr_stale_clientid; 1670ec6b5d7bSAndy Adamson goto out; 1671ec6b5d7bSAndy Adamson } 1672ec6b5d7bSAndy Adamson 1673408b79bcSJ. Bruce Fields /* 16748323c3b2SJ. Bruce Fields * XXX: we should probably set this at creation time, and check 16758323c3b2SJ. Bruce Fields * for consistent minorversion use throughout: 16768323c3b2SJ. Bruce Fields */ 16778323c3b2SJ. Bruce Fields conf->cl_minorversion = 1; 16788323c3b2SJ. Bruce Fields /* 1679408b79bcSJ. Bruce Fields * We do not support RDMA or persistent sessions 1680408b79bcSJ. Bruce Fields */ 1681408b79bcSJ. Bruce Fields cr_ses->flags &= ~SESSION4_PERSIST; 1682408b79bcSJ. Bruce Fields cr_ses->flags &= ~SESSION4_RDMA; 1683408b79bcSJ. Bruce Fields 16841b74c25bSMi Jinlong status = nfserr_toosmall; 16851b74c25bSMi Jinlong if (check_forechannel_attrs(cr_ses->fore_channel)) 16861b74c25bSMi Jinlong goto out; 16871b74c25bSMi Jinlong 1688ac7c46f2SJ. Bruce Fields status = nfserr_jukebox; 1689ac7c46f2SJ. Bruce Fields new = alloc_init_session(rqstp, conf, cr_ses); 1690ac7c46f2SJ. Bruce Fields if (!new) 1691ec6b5d7bSAndy Adamson goto out; 1692ac7c46f2SJ. Bruce Fields status = nfs_ok; 1693ac7c46f2SJ. Bruce Fields memcpy(cr_ses->sessionid.data, new->se_sessionid.data, 1694ec6b5d7bSAndy Adamson NFS4_MAX_SESSIONID_LEN); 169512050657SMi Jinlong memcpy(&cr_ses->fore_channel, &new->se_fchannel, 169612050657SMi Jinlong sizeof(struct nfsd4_channel_attrs)); 169786c3e16cSJ. Bruce Fields cs_slot->sl_seqid++; 169849557cc7SAndy Adamson cr_ses->seqid = cs_slot->sl_seqid; 1699ec6b5d7bSAndy Adamson 170049557cc7SAndy Adamson /* cache solo and embedded create sessions under the state lock */ 170149557cc7SAndy Adamson nfsd4_cache_create_session(cr_ses, cs_slot, status); 170286c3e16cSJ. Bruce Fields if (confirm_me) 170386c3e16cSJ. Bruce Fields move_to_confirmed(conf); 1704ec6b5d7bSAndy Adamson out: 1705ec6b5d7bSAndy Adamson nfs4_unlock_state(); 1706ec6b5d7bSAndy Adamson dprintk("%s returns %d\n", __func__, ntohl(status)); 1707ec6b5d7bSAndy Adamson return status; 1708069b6ad4SAndy Adamson } 1709069b6ad4SAndy Adamson 171057716355SJ. Bruce Fields static bool nfsd4_last_compound_op(struct svc_rqst *rqstp) 171157716355SJ. Bruce Fields { 171257716355SJ. Bruce Fields struct nfsd4_compoundres *resp = rqstp->rq_resp; 171357716355SJ. Bruce Fields struct nfsd4_compoundargs *argp = rqstp->rq_argp; 171457716355SJ. Bruce Fields 171557716355SJ. Bruce Fields return argp->opcnt == resp->opcnt; 171657716355SJ. Bruce Fields } 171757716355SJ. Bruce Fields 17181d1bc8f2SJ. Bruce Fields static __be32 nfsd4_map_bcts_dir(u32 *dir) 17191d1bc8f2SJ. Bruce Fields { 17201d1bc8f2SJ. Bruce Fields switch (*dir) { 17211d1bc8f2SJ. Bruce Fields case NFS4_CDFC4_FORE: 17221d1bc8f2SJ. Bruce Fields case NFS4_CDFC4_BACK: 17231d1bc8f2SJ. Bruce Fields return nfs_ok; 17241d1bc8f2SJ. Bruce Fields case NFS4_CDFC4_FORE_OR_BOTH: 17251d1bc8f2SJ. Bruce Fields case NFS4_CDFC4_BACK_OR_BOTH: 17261d1bc8f2SJ. Bruce Fields *dir = NFS4_CDFC4_BOTH; 17271d1bc8f2SJ. Bruce Fields return nfs_ok; 17281d1bc8f2SJ. Bruce Fields }; 17291d1bc8f2SJ. Bruce Fields return nfserr_inval; 17301d1bc8f2SJ. Bruce Fields } 17311d1bc8f2SJ. Bruce Fields 17321d1bc8f2SJ. Bruce Fields __be32 nfsd4_bind_conn_to_session(struct svc_rqst *rqstp, 17331d1bc8f2SJ. Bruce Fields struct nfsd4_compound_state *cstate, 17341d1bc8f2SJ. Bruce Fields struct nfsd4_bind_conn_to_session *bcts) 17351d1bc8f2SJ. Bruce Fields { 17361d1bc8f2SJ. Bruce Fields __be32 status; 17371d1bc8f2SJ. Bruce Fields 17381d1bc8f2SJ. Bruce Fields if (!nfsd4_last_compound_op(rqstp)) 17391d1bc8f2SJ. Bruce Fields return nfserr_not_only_op; 17401d1bc8f2SJ. Bruce Fields spin_lock(&client_lock); 17411d1bc8f2SJ. Bruce Fields cstate->session = find_in_sessionid_hashtbl(&bcts->sessionid); 17421d1bc8f2SJ. Bruce Fields /* Sorta weird: we only need the refcnt'ing because new_conn acquires 17431d1bc8f2SJ. Bruce Fields * client_lock iself: */ 17441d1bc8f2SJ. Bruce Fields if (cstate->session) { 17451d1bc8f2SJ. Bruce Fields nfsd4_get_session(cstate->session); 17461d1bc8f2SJ. Bruce Fields atomic_inc(&cstate->session->se_client->cl_refcount); 17471d1bc8f2SJ. Bruce Fields } 17481d1bc8f2SJ. Bruce Fields spin_unlock(&client_lock); 17491d1bc8f2SJ. Bruce Fields if (!cstate->session) 17501d1bc8f2SJ. Bruce Fields return nfserr_badsession; 17511d1bc8f2SJ. Bruce Fields 17521d1bc8f2SJ. Bruce Fields status = nfsd4_map_bcts_dir(&bcts->dir); 17531db2b9ddSBryan Schumaker if (!status) 17541d1bc8f2SJ. Bruce Fields nfsd4_new_conn(rqstp, cstate->session, bcts->dir); 17551db2b9ddSBryan Schumaker return status; 17561d1bc8f2SJ. Bruce Fields } 17571d1bc8f2SJ. Bruce Fields 17585d4cec2fSJ. Bruce Fields static bool nfsd4_compound_in_session(struct nfsd4_session *session, struct nfs4_sessionid *sid) 17595d4cec2fSJ. Bruce Fields { 17605d4cec2fSJ. Bruce Fields if (!session) 17615d4cec2fSJ. Bruce Fields return 0; 17625d4cec2fSJ. Bruce Fields return !memcmp(sid, &session->se_sessionid, sizeof(*sid)); 17635d4cec2fSJ. Bruce Fields } 17645d4cec2fSJ. Bruce Fields 1765069b6ad4SAndy Adamson __be32 1766069b6ad4SAndy Adamson nfsd4_destroy_session(struct svc_rqst *r, 1767069b6ad4SAndy Adamson struct nfsd4_compound_state *cstate, 1768069b6ad4SAndy Adamson struct nfsd4_destroy_session *sessionid) 1769069b6ad4SAndy Adamson { 1770e10e0cfcSBenny Halevy struct nfsd4_session *ses; 1771e10e0cfcSBenny Halevy u32 status = nfserr_badsession; 1772e10e0cfcSBenny Halevy 1773e10e0cfcSBenny Halevy /* Notes: 1774e10e0cfcSBenny Halevy * - The confirmed nfs4_client->cl_sessionid holds destroyed sessinid 1775e10e0cfcSBenny Halevy * - Should we return nfserr_back_chan_busy if waiting for 1776e10e0cfcSBenny Halevy * callbacks on to-be-destroyed session? 1777e10e0cfcSBenny Halevy * - Do we need to clear any callback info from previous session? 1778e10e0cfcSBenny Halevy */ 1779e10e0cfcSBenny Halevy 17805d4cec2fSJ. Bruce Fields if (nfsd4_compound_in_session(cstate->session, &sessionid->sessionid)) { 178157716355SJ. Bruce Fields if (!nfsd4_last_compound_op(r)) 178257716355SJ. Bruce Fields return nfserr_not_only_op; 178357716355SJ. Bruce Fields } 1784e10e0cfcSBenny Halevy dump_sessionid(__func__, &sessionid->sessionid); 17859089f1b4SBenny Halevy spin_lock(&client_lock); 1786e10e0cfcSBenny Halevy ses = find_in_sessionid_hashtbl(&sessionid->sessionid); 1787e10e0cfcSBenny Halevy if (!ses) { 17889089f1b4SBenny Halevy spin_unlock(&client_lock); 1789e10e0cfcSBenny Halevy goto out; 1790e10e0cfcSBenny Halevy } 1791e10e0cfcSBenny Halevy 1792e10e0cfcSBenny Halevy unhash_session(ses); 17939089f1b4SBenny Halevy spin_unlock(&client_lock); 1794e10e0cfcSBenny Halevy 1795ab707e15SBenny Halevy nfs4_lock_state(); 179684f5f7ccSJ. Bruce Fields nfsd4_probe_callback_sync(ses->se_client); 1797ab707e15SBenny Halevy nfs4_unlock_state(); 179819cf5c02SJ. Bruce Fields 179919cf5c02SJ. Bruce Fields nfsd4_del_conns(ses); 180019cf5c02SJ. Bruce Fields 1801e10e0cfcSBenny Halevy nfsd4_put_session(ses); 1802e10e0cfcSBenny Halevy status = nfs_ok; 1803e10e0cfcSBenny Halevy out: 1804e10e0cfcSBenny Halevy dprintk("%s returns %d\n", __func__, ntohl(status)); 1805e10e0cfcSBenny Halevy return status; 1806069b6ad4SAndy Adamson } 1807069b6ad4SAndy Adamson 1808a663bdd8SJ. Bruce Fields static struct nfsd4_conn *__nfsd4_find_conn(struct svc_xprt *xpt, struct nfsd4_session *s) 1809328ead28SJ. Bruce Fields { 1810328ead28SJ. Bruce Fields struct nfsd4_conn *c; 1811328ead28SJ. Bruce Fields 1812328ead28SJ. Bruce Fields list_for_each_entry(c, &s->se_conns, cn_persession) { 1813a663bdd8SJ. Bruce Fields if (c->cn_xprt == xpt) { 1814328ead28SJ. Bruce Fields return c; 1815328ead28SJ. Bruce Fields } 1816328ead28SJ. Bruce Fields } 1817328ead28SJ. Bruce Fields return NULL; 1818328ead28SJ. Bruce Fields } 1819328ead28SJ. Bruce Fields 1820a663bdd8SJ. Bruce Fields static void nfsd4_sequence_check_conn(struct nfsd4_conn *new, struct nfsd4_session *ses) 1821328ead28SJ. Bruce Fields { 1822328ead28SJ. Bruce Fields struct nfs4_client *clp = ses->se_client; 1823a663bdd8SJ. Bruce Fields struct nfsd4_conn *c; 182421b75b01SJ. Bruce Fields int ret; 1825328ead28SJ. Bruce Fields 1826328ead28SJ. Bruce Fields spin_lock(&clp->cl_lock); 1827a663bdd8SJ. Bruce Fields c = __nfsd4_find_conn(new->cn_xprt, ses); 1828328ead28SJ. Bruce Fields if (c) { 1829328ead28SJ. Bruce Fields spin_unlock(&clp->cl_lock); 1830328ead28SJ. Bruce Fields free_conn(new); 1831328ead28SJ. Bruce Fields return; 1832328ead28SJ. Bruce Fields } 1833328ead28SJ. Bruce Fields __nfsd4_hash_conn(new, ses); 1834328ead28SJ. Bruce Fields spin_unlock(&clp->cl_lock); 183521b75b01SJ. Bruce Fields ret = nfsd4_register_conn(new); 183621b75b01SJ. Bruce Fields if (ret) 183721b75b01SJ. Bruce Fields /* oops; xprt is already down: */ 183821b75b01SJ. Bruce Fields nfsd4_conn_lost(&new->cn_xpt_user); 1839328ead28SJ. Bruce Fields return; 1840328ead28SJ. Bruce Fields } 1841328ead28SJ. Bruce Fields 1842868b89c3SMi Jinlong static bool nfsd4_session_too_many_ops(struct svc_rqst *rqstp, struct nfsd4_session *session) 1843868b89c3SMi Jinlong { 1844868b89c3SMi Jinlong struct nfsd4_compoundargs *args = rqstp->rq_argp; 1845868b89c3SMi Jinlong 1846868b89c3SMi Jinlong return args->opcnt > session->se_fchannel.maxops; 1847868b89c3SMi Jinlong } 1848868b89c3SMi Jinlong 1849ae82a8d0SMi Jinlong static bool nfsd4_request_too_big(struct svc_rqst *rqstp, 1850ae82a8d0SMi Jinlong struct nfsd4_session *session) 1851ae82a8d0SMi Jinlong { 1852ae82a8d0SMi Jinlong struct xdr_buf *xb = &rqstp->rq_arg; 1853ae82a8d0SMi Jinlong 1854ae82a8d0SMi Jinlong return xb->len > session->se_fchannel.maxreq_sz; 1855ae82a8d0SMi Jinlong } 1856ae82a8d0SMi Jinlong 1857069b6ad4SAndy Adamson __be32 1858b85d4c01SBenny Halevy nfsd4_sequence(struct svc_rqst *rqstp, 1859069b6ad4SAndy Adamson struct nfsd4_compound_state *cstate, 1860069b6ad4SAndy Adamson struct nfsd4_sequence *seq) 1861069b6ad4SAndy Adamson { 1862f9bb94c4SAndy Adamson struct nfsd4_compoundres *resp = rqstp->rq_resp; 1863b85d4c01SBenny Halevy struct nfsd4_session *session; 1864b85d4c01SBenny Halevy struct nfsd4_slot *slot; 1865a663bdd8SJ. Bruce Fields struct nfsd4_conn *conn; 1866b85d4c01SBenny Halevy int status; 1867b85d4c01SBenny Halevy 1868f9bb94c4SAndy Adamson if (resp->opcnt != 1) 1869f9bb94c4SAndy Adamson return nfserr_sequence_pos; 1870f9bb94c4SAndy Adamson 1871a663bdd8SJ. Bruce Fields /* 1872a663bdd8SJ. Bruce Fields * Will be either used or freed by nfsd4_sequence_check_conn 1873a663bdd8SJ. Bruce Fields * below. 1874a663bdd8SJ. Bruce Fields */ 1875a663bdd8SJ. Bruce Fields conn = alloc_conn(rqstp, NFS4_CDFC4_FORE); 1876a663bdd8SJ. Bruce Fields if (!conn) 1877a663bdd8SJ. Bruce Fields return nfserr_jukebox; 1878a663bdd8SJ. Bruce Fields 18799089f1b4SBenny Halevy spin_lock(&client_lock); 1880b85d4c01SBenny Halevy status = nfserr_badsession; 1881b85d4c01SBenny Halevy session = find_in_sessionid_hashtbl(&seq->sessionid); 1882b85d4c01SBenny Halevy if (!session) 1883b85d4c01SBenny Halevy goto out; 1884b85d4c01SBenny Halevy 1885868b89c3SMi Jinlong status = nfserr_too_many_ops; 1886868b89c3SMi Jinlong if (nfsd4_session_too_many_ops(rqstp, session)) 1887868b89c3SMi Jinlong goto out; 1888868b89c3SMi Jinlong 1889ae82a8d0SMi Jinlong status = nfserr_req_too_big; 1890ae82a8d0SMi Jinlong if (nfsd4_request_too_big(rqstp, session)) 1891ae82a8d0SMi Jinlong goto out; 1892ae82a8d0SMi Jinlong 1893b85d4c01SBenny Halevy status = nfserr_badslot; 18946c18ba9fSAlexandros Batsakis if (seq->slotid >= session->se_fchannel.maxreqs) 1895b85d4c01SBenny Halevy goto out; 1896b85d4c01SBenny Halevy 1897557ce264SAndy Adamson slot = session->se_slots[seq->slotid]; 1898b85d4c01SBenny Halevy dprintk("%s: slotid %d\n", __func__, seq->slotid); 1899b85d4c01SBenny Halevy 1900a8dfdaebSAndy Adamson /* We do not negotiate the number of slots yet, so set the 1901a8dfdaebSAndy Adamson * maxslots to the session maxreqs which is used to encode 1902a8dfdaebSAndy Adamson * sr_highest_slotid and the sr_target_slot id to maxslots */ 1903a8dfdaebSAndy Adamson seq->maxslots = session->se_fchannel.maxreqs; 1904a8dfdaebSAndy Adamson 190588e588d5SAndy Adamson status = check_slot_seqid(seq->seqid, slot->sl_seqid, slot->sl_inuse); 1906b85d4c01SBenny Halevy if (status == nfserr_replay_cache) { 1907b85d4c01SBenny Halevy cstate->slot = slot; 1908b85d4c01SBenny Halevy cstate->session = session; 1909da3846a2SAndy Adamson /* Return the cached reply status and set cstate->status 1910557ce264SAndy Adamson * for nfsd4_proc_compound processing */ 1911bf864a31SAndy Adamson status = nfsd4_replay_cache_entry(resp, seq); 1912da3846a2SAndy Adamson cstate->status = nfserr_replay_cache; 1913aaf84eb9SBenny Halevy goto out; 1914b85d4c01SBenny Halevy } 1915b85d4c01SBenny Halevy if (status) 1916b85d4c01SBenny Halevy goto out; 1917b85d4c01SBenny Halevy 1918a663bdd8SJ. Bruce Fields nfsd4_sequence_check_conn(conn, session); 1919a663bdd8SJ. Bruce Fields conn = NULL; 1920328ead28SJ. Bruce Fields 1921b85d4c01SBenny Halevy /* Success! bump slot seqid */ 1922b85d4c01SBenny Halevy slot->sl_inuse = true; 1923b85d4c01SBenny Halevy slot->sl_seqid = seq->seqid; 1924557ce264SAndy Adamson slot->sl_cachethis = seq->cachethis; 1925b85d4c01SBenny Halevy 1926b85d4c01SBenny Halevy cstate->slot = slot; 1927b85d4c01SBenny Halevy cstate->session = session; 1928b85d4c01SBenny Halevy 1929b85d4c01SBenny Halevy out: 193026c0c75eSJ. Bruce Fields /* Hold a session reference until done processing the compound. */ 1931aaf84eb9SBenny Halevy if (cstate->session) { 19320d7bb719SJ. Bruce Fields struct nfs4_client *clp = session->se_client; 19330d7bb719SJ. Bruce Fields 193436acb66bSBenny Halevy nfsd4_get_session(cstate->session); 19350d7bb719SJ. Bruce Fields atomic_inc(&clp->cl_refcount); 19360d7bb719SJ. Bruce Fields if (clp->cl_cb_state == NFSD4_CB_DOWN) 19370d7bb719SJ. Bruce Fields seq->status_flags |= SEQ4_STATUS_CB_PATH_DOWN; 1938aaf84eb9SBenny Halevy } 1939a663bdd8SJ. Bruce Fields kfree(conn); 194036acb66bSBenny Halevy spin_unlock(&client_lock); 1941b85d4c01SBenny Halevy dprintk("%s: return %d\n", __func__, ntohl(status)); 1942b85d4c01SBenny Halevy return status; 1943069b6ad4SAndy Adamson } 1944069b6ad4SAndy Adamson 1945069b6ad4SAndy Adamson __be32 19464dc6ec00SJ. Bruce Fields nfsd4_reclaim_complete(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_reclaim_complete *rc) 19474dc6ec00SJ. Bruce Fields { 1948bcecf1ccSMi Jinlong int status = 0; 1949bcecf1ccSMi Jinlong 19504dc6ec00SJ. Bruce Fields if (rc->rca_one_fs) { 19514dc6ec00SJ. Bruce Fields if (!cstate->current_fh.fh_dentry) 19524dc6ec00SJ. Bruce Fields return nfserr_nofilehandle; 19534dc6ec00SJ. Bruce Fields /* 19544dc6ec00SJ. Bruce Fields * We don't take advantage of the rca_one_fs case. 19554dc6ec00SJ. Bruce Fields * That's OK, it's optional, we can safely ignore it. 19564dc6ec00SJ. Bruce Fields */ 19574dc6ec00SJ. Bruce Fields return nfs_ok; 19584dc6ec00SJ. Bruce Fields } 1959bcecf1ccSMi Jinlong 19604dc6ec00SJ. Bruce Fields nfs4_lock_state(); 1961bcecf1ccSMi Jinlong status = nfserr_complete_already; 1962bcecf1ccSMi Jinlong if (cstate->session->se_client->cl_firststate) 1963bcecf1ccSMi Jinlong goto out; 1964bcecf1ccSMi Jinlong 1965bcecf1ccSMi Jinlong status = nfserr_stale_clientid; 1966bcecf1ccSMi Jinlong if (is_client_expired(cstate->session->se_client)) 19674dc6ec00SJ. Bruce Fields /* 19684dc6ec00SJ. Bruce Fields * The following error isn't really legal. 19694dc6ec00SJ. Bruce Fields * But we only get here if the client just explicitly 19704dc6ec00SJ. Bruce Fields * destroyed the client. Surely it no longer cares what 19714dc6ec00SJ. Bruce Fields * error it gets back on an operation for the dead 19724dc6ec00SJ. Bruce Fields * client. 19734dc6ec00SJ. Bruce Fields */ 1974bcecf1ccSMi Jinlong goto out; 1975bcecf1ccSMi Jinlong 1976bcecf1ccSMi Jinlong status = nfs_ok; 19774dc6ec00SJ. Bruce Fields nfsd4_create_clid_dir(cstate->session->se_client); 1978bcecf1ccSMi Jinlong out: 19794dc6ec00SJ. Bruce Fields nfs4_unlock_state(); 1980bcecf1ccSMi Jinlong return status; 19814dc6ec00SJ. Bruce Fields } 19824dc6ec00SJ. Bruce Fields 19834dc6ec00SJ. Bruce Fields __be32 1984b591480bSJ.Bruce Fields nfsd4_setclientid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 1985b591480bSJ.Bruce Fields struct nfsd4_setclientid *setclid) 19861da177e4SLinus Torvalds { 19871da177e4SLinus Torvalds struct xdr_netobj clname = { 19881da177e4SLinus Torvalds .len = setclid->se_namelen, 19891da177e4SLinus Torvalds .data = setclid->se_name, 19901da177e4SLinus Torvalds }; 19911da177e4SLinus Torvalds nfs4_verifier clverifier = setclid->se_verf; 19921da177e4SLinus Torvalds unsigned int strhashval; 199328ce6054SNeilBrown struct nfs4_client *conf, *unconf, *new; 1994b37ad28bSAl Viro __be32 status; 1995a55370a3SNeilBrown char dname[HEXDIR_LEN]; 19961da177e4SLinus Torvalds 19971da177e4SLinus Torvalds if (!check_name(clname)) 199873aea4ecSNeil Brown return nfserr_inval; 19991da177e4SLinus Torvalds 2000a55370a3SNeilBrown status = nfs4_make_rec_clidname(dname, &clname); 2001a55370a3SNeilBrown if (status) 200273aea4ecSNeil Brown return status; 2003a55370a3SNeilBrown 20041da177e4SLinus Torvalds /* 20051da177e4SLinus Torvalds * XXX The Duplicate Request Cache (DRC) has been checked (??) 20061da177e4SLinus Torvalds * We get here on a DRC miss. 20071da177e4SLinus Torvalds */ 20081da177e4SLinus Torvalds 2009a55370a3SNeilBrown strhashval = clientstr_hashval(dname); 20101da177e4SLinus Torvalds 20111da177e4SLinus Torvalds nfs4_lock_state(); 2012e203d506SJ. Bruce Fields conf = find_confirmed_client_by_str(dname, strhashval); 201328ce6054SNeilBrown if (conf) { 2014a186e767SJ. Bruce Fields /* RFC 3530 14.2.33 CASE 0: */ 20151da177e4SLinus Torvalds status = nfserr_clid_inuse; 2016e203d506SJ. Bruce Fields if (clp_used_exchangeid(conf)) 2017e203d506SJ. Bruce Fields goto out; 2018026722c2SJ. Bruce Fields if (!same_creds(&conf->cl_cred, &rqstp->rq_cred)) { 2019363168b4SJeff Layton char addr_str[INET6_ADDRSTRLEN]; 2020363168b4SJeff Layton rpc_ntop((struct sockaddr *) &conf->cl_addr, addr_str, 2021363168b4SJeff Layton sizeof(addr_str)); 2022026722c2SJ. Bruce Fields dprintk("NFSD: setclientid: string in use by client " 2023363168b4SJeff Layton "at %s\n", addr_str); 20241da177e4SLinus Torvalds goto out; 20251da177e4SLinus Torvalds } 20261da177e4SLinus Torvalds } 2027a186e767SJ. Bruce Fields /* 2028a186e767SJ. Bruce Fields * section 14.2.33 of RFC 3530 (under the heading "IMPLEMENTATION") 2029a186e767SJ. Bruce Fields * has a description of SETCLIENTID request processing consisting 2030a186e767SJ. Bruce Fields * of 5 bullet points, labeled as CASE0 - CASE4 below. 2031a186e767SJ. Bruce Fields */ 2032e203d506SJ. Bruce Fields unconf = find_unconfirmed_client_by_str(dname, strhashval); 20333e772463SJ. Bruce Fields status = nfserr_jukebox; 20341da177e4SLinus Torvalds if (!conf) { 20351da177e4SLinus Torvalds /* 2036a186e767SJ. Bruce Fields * RFC 3530 14.2.33 CASE 4: 2037a186e767SJ. Bruce Fields * placed first, because it is the normal case 20381da177e4SLinus Torvalds */ 20391da177e4SLinus Torvalds if (unconf) 20401da177e4SLinus Torvalds expire_client(unconf); 2041b09333c4SRicardo Labiaga new = create_client(clname, dname, rqstp, &clverifier); 2042a55370a3SNeilBrown if (new == NULL) 20431da177e4SLinus Torvalds goto out; 20441da177e4SLinus Torvalds gen_clid(new); 2045599e0a22SJ. Bruce Fields } else if (same_verf(&conf->cl_verifier, &clverifier)) { 20461da177e4SLinus Torvalds /* 2047a186e767SJ. Bruce Fields * RFC 3530 14.2.33 CASE 1: 2048a186e767SJ. Bruce Fields * probable callback update 20491da177e4SLinus Torvalds */ 205031f4a6c1SNeilBrown if (unconf) { 205131f4a6c1SNeilBrown /* Note this is removing unconfirmed {*x***}, 205231f4a6c1SNeilBrown * which is stronger than RFC recommended {vxc**}. 205331f4a6c1SNeilBrown * This has the advantage that there is at most 205431f4a6c1SNeilBrown * one {*x***} in either list at any time. 205531f4a6c1SNeilBrown */ 20561da177e4SLinus Torvalds expire_client(unconf); 20571da177e4SLinus Torvalds } 2058b09333c4SRicardo Labiaga new = create_client(clname, dname, rqstp, &clverifier); 2059a55370a3SNeilBrown if (new == NULL) 20601da177e4SLinus Torvalds goto out; 20611da177e4SLinus Torvalds copy_clid(new, conf); 20621da177e4SLinus Torvalds } else if (!unconf) { 20631da177e4SLinus Torvalds /* 2064a186e767SJ. Bruce Fields * RFC 3530 14.2.33 CASE 2: 2065a186e767SJ. Bruce Fields * probable client reboot; state will be removed if 2066a186e767SJ. Bruce Fields * confirmed. 20671da177e4SLinus Torvalds */ 2068b09333c4SRicardo Labiaga new = create_client(clname, dname, rqstp, &clverifier); 2069a55370a3SNeilBrown if (new == NULL) 20701da177e4SLinus Torvalds goto out; 20711da177e4SLinus Torvalds gen_clid(new); 207249ba8781SJ. Bruce Fields } else { 20731da177e4SLinus Torvalds /* 2074a186e767SJ. Bruce Fields * RFC 3530 14.2.33 CASE 3: 2075a186e767SJ. Bruce Fields * probable client reboot; state will be removed if 2076a186e767SJ. Bruce Fields * confirmed. 20771da177e4SLinus Torvalds */ 20781da177e4SLinus Torvalds expire_client(unconf); 2079b09333c4SRicardo Labiaga new = create_client(clname, dname, rqstp, &clverifier); 2080a55370a3SNeilBrown if (new == NULL) 20811da177e4SLinus Torvalds goto out; 20821da177e4SLinus Torvalds gen_clid(new); 20831da177e4SLinus Torvalds } 20848323c3b2SJ. Bruce Fields /* 20858323c3b2SJ. Bruce Fields * XXX: we should probably set this at creation time, and check 20868323c3b2SJ. Bruce Fields * for consistent minorversion use throughout: 20878323c3b2SJ. Bruce Fields */ 20888323c3b2SJ. Bruce Fields new->cl_minorversion = 0; 20896f3d772fSTakuma Umeya gen_callback(new, setclid, rqstp); 2090c175b83cSJ. Bruce Fields add_to_unconfirmed(new, strhashval); 20911da177e4SLinus Torvalds setclid->se_clientid.cl_boot = new->cl_clientid.cl_boot; 20921da177e4SLinus Torvalds setclid->se_clientid.cl_id = new->cl_clientid.cl_id; 20931da177e4SLinus Torvalds memcpy(setclid->se_confirm.data, new->cl_confirm.data, sizeof(setclid->se_confirm.data)); 20941da177e4SLinus Torvalds status = nfs_ok; 20951da177e4SLinus Torvalds out: 20961da177e4SLinus Torvalds nfs4_unlock_state(); 20971da177e4SLinus Torvalds return status; 20981da177e4SLinus Torvalds } 20991da177e4SLinus Torvalds 21001da177e4SLinus Torvalds 21011da177e4SLinus Torvalds /* 2102a186e767SJ. Bruce Fields * Section 14.2.34 of RFC 3530 (under the heading "IMPLEMENTATION") has 2103a186e767SJ. Bruce Fields * a description of SETCLIENTID_CONFIRM request processing consisting of 4 2104a186e767SJ. Bruce Fields * bullets, labeled as CASE1 - CASE4 below. 21051da177e4SLinus Torvalds */ 2106b37ad28bSAl Viro __be32 2107b591480bSJ.Bruce Fields nfsd4_setclientid_confirm(struct svc_rqst *rqstp, 2108b591480bSJ.Bruce Fields struct nfsd4_compound_state *cstate, 2109b591480bSJ.Bruce Fields struct nfsd4_setclientid_confirm *setclientid_confirm) 21101da177e4SLinus Torvalds { 2111363168b4SJeff Layton struct sockaddr *sa = svc_addr(rqstp); 211221ab45a4SNeilBrown struct nfs4_client *conf, *unconf; 21131da177e4SLinus Torvalds nfs4_verifier confirm = setclientid_confirm->sc_confirm; 21141da177e4SLinus Torvalds clientid_t * clid = &setclientid_confirm->sc_clientid; 2115b37ad28bSAl Viro __be32 status; 21161da177e4SLinus Torvalds 21171da177e4SLinus Torvalds if (STALE_CLIENTID(clid)) 21181da177e4SLinus Torvalds return nfserr_stale_clientid; 21191da177e4SLinus Torvalds /* 21201da177e4SLinus Torvalds * XXX The Duplicate Request Cache (DRC) has been checked (??) 21211da177e4SLinus Torvalds * We get here on a DRC miss. 21221da177e4SLinus Torvalds */ 21231da177e4SLinus Torvalds 21241da177e4SLinus Torvalds nfs4_lock_state(); 212521ab45a4SNeilBrown 212621ab45a4SNeilBrown conf = find_confirmed_client(clid); 212721ab45a4SNeilBrown unconf = find_unconfirmed_client(clid); 212821ab45a4SNeilBrown 212922de4d83SNeilBrown status = nfserr_clid_inuse; 2130363168b4SJeff Layton if (conf && !rpc_cmp_addr((struct sockaddr *) &conf->cl_addr, sa)) 21311da177e4SLinus Torvalds goto out; 2132363168b4SJeff Layton if (unconf && !rpc_cmp_addr((struct sockaddr *) &unconf->cl_addr, sa)) 21331da177e4SLinus Torvalds goto out; 213421ab45a4SNeilBrown 2135a186e767SJ. Bruce Fields /* 2136a186e767SJ. Bruce Fields * section 14.2.34 of RFC 3530 has a description of 2137a186e767SJ. Bruce Fields * SETCLIENTID_CONFIRM request processing consisting 2138a186e767SJ. Bruce Fields * of 4 bullet points, labeled as CASE1 - CASE4 below. 2139a186e767SJ. Bruce Fields */ 2140366e0c1dSJ. Bruce Fields if (conf && unconf && same_verf(&confirm, &unconf->cl_confirm)) { 2141a186e767SJ. Bruce Fields /* 2142a186e767SJ. Bruce Fields * RFC 3530 14.2.34 CASE 1: 2143a186e767SJ. Bruce Fields * callback update 21447c79f737SNeilBrown */ 2145599e0a22SJ. Bruce Fields if (!same_creds(&conf->cl_cred, &unconf->cl_cred)) 21461da177e4SLinus Torvalds status = nfserr_clid_inuse; 21471da177e4SLinus Torvalds else { 21485a3c9d71SJ. Bruce Fields nfsd4_change_callback(conf, &unconf->cl_cb_conn); 21495a3c9d71SJ. Bruce Fields nfsd4_probe_callback(conf); 21501a69c179SNeilBrown expire_client(unconf); 21511da177e4SLinus Torvalds status = nfs_ok; 21521a69c179SNeilBrown 21531da177e4SLinus Torvalds } 2154f3aba4e5SJ. Bruce Fields } else if (conf && !unconf) { 2155a186e767SJ. Bruce Fields /* 2156a186e767SJ. Bruce Fields * RFC 3530 14.2.34 CASE 2: 2157a186e767SJ. Bruce Fields * probable retransmitted request; play it safe and 2158a186e767SJ. Bruce Fields * do nothing. 21597c79f737SNeilBrown */ 2160599e0a22SJ. Bruce Fields if (!same_creds(&conf->cl_cred, &rqstp->rq_cred)) 21611da177e4SLinus Torvalds status = nfserr_clid_inuse; 216221ab45a4SNeilBrown else 21631da177e4SLinus Torvalds status = nfs_ok; 21647c79f737SNeilBrown } else if (!conf && unconf 2165599e0a22SJ. Bruce Fields && same_verf(&unconf->cl_confirm, &confirm)) { 2166a186e767SJ. Bruce Fields /* 2167a186e767SJ. Bruce Fields * RFC 3530 14.2.34 CASE 3: 2168a186e767SJ. Bruce Fields * Normal case; new or rebooted client: 21691da177e4SLinus Torvalds */ 2170599e0a22SJ. Bruce Fields if (!same_creds(&unconf->cl_cred, &rqstp->rq_cred)) { 21711da177e4SLinus Torvalds status = nfserr_clid_inuse; 21721da177e4SLinus Torvalds } else { 21731a69c179SNeilBrown unsigned int hash = 21741a69c179SNeilBrown clientstr_hashval(unconf->cl_recdir); 21751a69c179SNeilBrown conf = find_confirmed_client_by_str(unconf->cl_recdir, 2176e203d506SJ. Bruce Fields hash); 21771a69c179SNeilBrown if (conf) { 2178c7b9a459SNeilBrown nfsd4_remove_clid_dir(conf); 21791a69c179SNeilBrown expire_client(conf); 21801a69c179SNeilBrown } 21811da177e4SLinus Torvalds move_to_confirmed(unconf); 218221ab45a4SNeilBrown conf = unconf; 21835a3c9d71SJ. Bruce Fields nfsd4_probe_callback(conf); 21841a69c179SNeilBrown status = nfs_ok; 21851da177e4SLinus Torvalds } 2186599e0a22SJ. Bruce Fields } else if ((!conf || (conf && !same_verf(&conf->cl_confirm, &confirm))) 2187599e0a22SJ. Bruce Fields && (!unconf || (unconf && !same_verf(&unconf->cl_confirm, 21887c79f737SNeilBrown &confirm)))) { 2189a186e767SJ. Bruce Fields /* 2190a186e767SJ. Bruce Fields * RFC 3530 14.2.34 CASE 4: 2191a186e767SJ. Bruce Fields * Client probably hasn't noticed that we rebooted yet. 21921da177e4SLinus Torvalds */ 21931da177e4SLinus Torvalds status = nfserr_stale_clientid; 21947c79f737SNeilBrown } else { 21951da177e4SLinus Torvalds /* check that we have hit one of the cases...*/ 219622de4d83SNeilBrown status = nfserr_clid_inuse; 219708e8987cSNeilBrown } 21981da177e4SLinus Torvalds out: 21991da177e4SLinus Torvalds nfs4_unlock_state(); 22001da177e4SLinus Torvalds return status; 22011da177e4SLinus Torvalds } 22021da177e4SLinus Torvalds 22031da177e4SLinus Torvalds /* OPEN Share state helper functions */ 22041da177e4SLinus Torvalds static inline struct nfs4_file * 22051da177e4SLinus Torvalds alloc_init_file(struct inode *ino) 22061da177e4SLinus Torvalds { 22071da177e4SLinus Torvalds struct nfs4_file *fp; 22081da177e4SLinus Torvalds unsigned int hashval = file_hashval(ino); 22091da177e4SLinus Torvalds 2210e60d4398SNeilBrown fp = kmem_cache_alloc(file_slab, GFP_KERNEL); 2211e60d4398SNeilBrown if (fp) { 22128b671b80SJ. Bruce Fields atomic_set(&fp->fi_ref, 1); 22131da177e4SLinus Torvalds INIT_LIST_HEAD(&fp->fi_hash); 22148beefa24SNeilBrown INIT_LIST_HEAD(&fp->fi_stateids); 22158beefa24SNeilBrown INIT_LIST_HEAD(&fp->fi_delegations); 22161da177e4SLinus Torvalds fp->fi_inode = igrab(ino); 22171da177e4SLinus Torvalds fp->fi_id = current_fileid++; 221847f9940cSMeelap Shah fp->fi_had_conflict = false; 2219acfdf5c3SJ. Bruce Fields fp->fi_lease = NULL; 2220f9d7562fSJ. Bruce Fields memset(fp->fi_fds, 0, sizeof(fp->fi_fds)); 2221f9d7562fSJ. Bruce Fields memset(fp->fi_access, 0, sizeof(fp->fi_access)); 222247cee541SPavel Emelyanov spin_lock(&recall_lock); 222347cee541SPavel Emelyanov list_add(&fp->fi_hash, &file_hashtbl[hashval]); 222447cee541SPavel Emelyanov spin_unlock(&recall_lock); 22251da177e4SLinus Torvalds return fp; 22261da177e4SLinus Torvalds } 22271da177e4SLinus Torvalds return NULL; 22281da177e4SLinus Torvalds } 22291da177e4SLinus Torvalds 22301da177e4SLinus Torvalds static void 2231e18b890bSChristoph Lameter nfsd4_free_slab(struct kmem_cache **slab) 2232e60d4398SNeilBrown { 2233e60d4398SNeilBrown if (*slab == NULL) 2234e60d4398SNeilBrown return; 22351a1d92c1SAlexey Dobriyan kmem_cache_destroy(*slab); 2236e60d4398SNeilBrown *slab = NULL; 2237e60d4398SNeilBrown } 2238e60d4398SNeilBrown 2239e8ff2a84SJ. Bruce Fields void 2240e60d4398SNeilBrown nfsd4_free_slabs(void) 2241e60d4398SNeilBrown { 2242fe0750e5SJ. Bruce Fields nfsd4_free_slab(&openowner_slab); 2243fe0750e5SJ. Bruce Fields nfsd4_free_slab(&lockowner_slab); 2244e60d4398SNeilBrown nfsd4_free_slab(&file_slab); 22455ac049acSNeilBrown nfsd4_free_slab(&stateid_slab); 22465b2d21c1SNeilBrown nfsd4_free_slab(&deleg_slab); 2247e60d4398SNeilBrown } 22481da177e4SLinus Torvalds 22491da177e4SLinus Torvalds static int 22501da177e4SLinus Torvalds nfsd4_init_slabs(void) 22511da177e4SLinus Torvalds { 2252fe0750e5SJ. Bruce Fields openowner_slab = kmem_cache_create("nfsd4_openowners", 2253fe0750e5SJ. Bruce Fields sizeof(struct nfs4_openowner), 0, 0, NULL); 2254fe0750e5SJ. Bruce Fields if (openowner_slab == NULL) 2255fe0750e5SJ. Bruce Fields goto out_nomem; 2256fe0750e5SJ. Bruce Fields lockowner_slab = kmem_cache_create("nfsd4_lockowners", 2257fe0750e5SJ. Bruce Fields sizeof(struct nfs4_openowner), 0, 0, NULL); 2258fe0750e5SJ. Bruce Fields if (lockowner_slab == NULL) 2259e60d4398SNeilBrown goto out_nomem; 2260e60d4398SNeilBrown file_slab = kmem_cache_create("nfsd4_files", 226120c2df83SPaul Mundt sizeof(struct nfs4_file), 0, 0, NULL); 2262e60d4398SNeilBrown if (file_slab == NULL) 2263e60d4398SNeilBrown goto out_nomem; 22645ac049acSNeilBrown stateid_slab = kmem_cache_create("nfsd4_stateids", 2265dcef0413SJ. Bruce Fields sizeof(struct nfs4_ol_stateid), 0, 0, NULL); 22665ac049acSNeilBrown if (stateid_slab == NULL) 22675ac049acSNeilBrown goto out_nomem; 22685b2d21c1SNeilBrown deleg_slab = kmem_cache_create("nfsd4_delegations", 226920c2df83SPaul Mundt sizeof(struct nfs4_delegation), 0, 0, NULL); 22705b2d21c1SNeilBrown if (deleg_slab == NULL) 22715b2d21c1SNeilBrown goto out_nomem; 2272e60d4398SNeilBrown return 0; 2273e60d4398SNeilBrown out_nomem: 2274e60d4398SNeilBrown nfsd4_free_slabs(); 22751da177e4SLinus Torvalds dprintk("nfsd4: out of memory while initializing nfsv4\n"); 22761da177e4SLinus Torvalds return -ENOMEM; 22771da177e4SLinus Torvalds } 22781da177e4SLinus Torvalds 2279fe0750e5SJ. Bruce Fields void nfs4_free_openowner(struct nfs4_openowner *oo) 22801da177e4SLinus Torvalds { 2281fe0750e5SJ. Bruce Fields kfree(oo->oo_owner.so_owner.data); 2282fe0750e5SJ. Bruce Fields kmem_cache_free(openowner_slab, oo); 2283fe0750e5SJ. Bruce Fields } 2284fe0750e5SJ. Bruce Fields 2285fe0750e5SJ. Bruce Fields void nfs4_free_lockowner(struct nfs4_lockowner *lo) 2286fe0750e5SJ. Bruce Fields { 2287fe0750e5SJ. Bruce Fields kfree(lo->lo_owner.so_owner.data); 2288fe0750e5SJ. Bruce Fields kmem_cache_free(lockowner_slab, lo); 22891da177e4SLinus Torvalds } 22901da177e4SLinus Torvalds 2291ff194bd9SJ. Bruce Fields static void init_nfs4_replay(struct nfs4_replay *rp) 2292ff194bd9SJ. Bruce Fields { 2293ff194bd9SJ. Bruce Fields rp->rp_status = nfserr_serverfault; 2294ff194bd9SJ. Bruce Fields rp->rp_buflen = 0; 2295ff194bd9SJ. Bruce Fields rp->rp_buf = rp->rp_ibuf; 2296ff194bd9SJ. Bruce Fields } 2297ff194bd9SJ. Bruce Fields 2298fe0750e5SJ. Bruce Fields static inline void *alloc_stateowner(struct kmem_cache *slab, struct xdr_netobj *owner, struct nfs4_client *clp) 22991da177e4SLinus Torvalds { 23001da177e4SLinus Torvalds struct nfs4_stateowner *sop; 23011da177e4SLinus Torvalds 2302fe0750e5SJ. Bruce Fields sop = kmem_cache_alloc(slab, GFP_KERNEL); 2303ff194bd9SJ. Bruce Fields if (!sop) 2304ff194bd9SJ. Bruce Fields return NULL; 2305ff194bd9SJ. Bruce Fields 2306ff194bd9SJ. Bruce Fields sop->so_owner.data = kmemdup(owner->data, owner->len, GFP_KERNEL); 2307ff194bd9SJ. Bruce Fields if (!sop->so_owner.data) { 2308fe0750e5SJ. Bruce Fields kmem_cache_free(slab, sop); 2309ff194bd9SJ. Bruce Fields return NULL; 2310ff194bd9SJ. Bruce Fields } 23111da177e4SLinus Torvalds sop->so_owner.len = owner->len; 2312ff194bd9SJ. Bruce Fields 2313ff194bd9SJ. Bruce Fields INIT_LIST_HEAD(&sop->so_stateids); 2314ff194bd9SJ. Bruce Fields sop->so_id = current_ownerid++; 2315ff194bd9SJ. Bruce Fields sop->so_client = clp; 2316ff194bd9SJ. Bruce Fields init_nfs4_replay(&sop->so_replay); 23171da177e4SLinus Torvalds return sop; 23181da177e4SLinus Torvalds } 2319ff194bd9SJ. Bruce Fields 2320fe0750e5SJ. Bruce Fields static void hash_openowner(struct nfs4_openowner *oo, struct nfs4_client *clp, unsigned int strhashval) 2321ff194bd9SJ. Bruce Fields { 2322ff194bd9SJ. Bruce Fields unsigned int idhashval; 2323ff194bd9SJ. Bruce Fields 2324fe0750e5SJ. Bruce Fields idhashval = open_ownerid_hashval(oo->oo_owner.so_id); 2325fe0750e5SJ. Bruce Fields list_add(&oo->oo_owner.so_idhash, &open_ownerid_hashtbl[idhashval]); 2326fe0750e5SJ. Bruce Fields list_add(&oo->oo_owner.so_strhash, &open_ownerstr_hashtbl[strhashval]); 2327fe0750e5SJ. Bruce Fields list_add(&oo->oo_perclient, &clp->cl_openowners); 23281da177e4SLinus Torvalds } 23291da177e4SLinus Torvalds 2330fe0750e5SJ. Bruce Fields static struct nfs4_openowner * 23311da177e4SLinus Torvalds alloc_init_open_stateowner(unsigned int strhashval, struct nfs4_client *clp, struct nfsd4_open *open) { 2332fe0750e5SJ. Bruce Fields struct nfs4_openowner *oo; 23331da177e4SLinus Torvalds 2334fe0750e5SJ. Bruce Fields oo = alloc_stateowner(openowner_slab, &open->op_owner, clp); 2335fe0750e5SJ. Bruce Fields if (!oo) 23361da177e4SLinus Torvalds return NULL; 2337fe0750e5SJ. Bruce Fields oo->oo_owner.so_is_open_owner = 1; 2338fe0750e5SJ. Bruce Fields oo->oo_owner.so_seqid = open->op_seqid; 2339fe0750e5SJ. Bruce Fields oo->oo_confirmed = 0; 2340fe0750e5SJ. Bruce Fields oo->oo_time = 0; 2341fe0750e5SJ. Bruce Fields INIT_LIST_HEAD(&oo->oo_close_lru); 2342fe0750e5SJ. Bruce Fields hash_openowner(oo, clp, strhashval); 2343fe0750e5SJ. Bruce Fields return oo; 23441da177e4SLinus Torvalds } 23451da177e4SLinus Torvalds 23461da177e4SLinus Torvalds static inline void 2347dcef0413SJ. Bruce Fields init_open_stateid(struct nfs4_ol_stateid *stp, struct nfs4_file *fp, struct nfsd4_open *open) { 2348fe0750e5SJ. Bruce Fields struct nfs4_openowner *oo = open->op_openowner; 23491da177e4SLinus Torvalds 2350ea1da636SNeilBrown INIT_LIST_HEAD(&stp->st_lockowners); 2351fe0750e5SJ. Bruce Fields list_add(&stp->st_perstateowner, &oo->oo_owner.so_stateids); 23528beefa24SNeilBrown list_add(&stp->st_perfile, &fp->fi_stateids); 2353dcef0413SJ. Bruce Fields stp->st_stid.sc_type = NFS4_OPEN_STID; 2354fe0750e5SJ. Bruce Fields stp->st_stateowner = &oo->oo_owner; 235513cd2184SNeilBrown get_nfs4_file(fp); 23561da177e4SLinus Torvalds stp->st_file = fp; 2357dcef0413SJ. Bruce Fields stp->st_stid.sc_stateid.si_boot = boot_time; 2358dcef0413SJ. Bruce Fields stp->st_stid.sc_stateid.si_stateownerid = oo->oo_owner.so_id; 2359dcef0413SJ. Bruce Fields stp->st_stid.sc_stateid.si_fileid = fp->fi_id; 236073997dc4SJ. Bruce Fields /* note will be incremented before first return to client: */ 2361dcef0413SJ. Bruce Fields stp->st_stid.sc_stateid.si_generation = 0; 236236d44c60SJ. Bruce Fields hash_stid(&stp->st_stid); 23631da177e4SLinus Torvalds stp->st_access_bmap = 0; 23641da177e4SLinus Torvalds stp->st_deny_bmap = 0; 236584459a11SAndy Adamson __set_bit(open->op_share_access & ~NFS4_SHARE_WANT_MASK, 236684459a11SAndy Adamson &stp->st_access_bmap); 23671da177e4SLinus Torvalds __set_bit(open->op_share_deny, &stp->st_deny_bmap); 23684c4cd222SNeilBrown stp->st_openstp = NULL; 23691da177e4SLinus Torvalds } 23701da177e4SLinus Torvalds 23711da177e4SLinus Torvalds static void 2372fe0750e5SJ. Bruce Fields move_to_close_lru(struct nfs4_openowner *oo) 23731da177e4SLinus Torvalds { 2374fe0750e5SJ. Bruce Fields dprintk("NFSD: move_to_close_lru nfs4_openowner %p\n", oo); 23751da177e4SLinus Torvalds 2376fe0750e5SJ. Bruce Fields list_move_tail(&oo->oo_close_lru, &close_lru); 2377fe0750e5SJ. Bruce Fields oo->oo_time = get_seconds(); 23781da177e4SLinus Torvalds } 23791da177e4SLinus Torvalds 23801da177e4SLinus Torvalds static int 2381599e0a22SJ. Bruce Fields same_owner_str(struct nfs4_stateowner *sop, struct xdr_netobj *owner, 2382599e0a22SJ. Bruce Fields clientid_t *clid) 2383599e0a22SJ. Bruce Fields { 2384599e0a22SJ. Bruce Fields return (sop->so_owner.len == owner->len) && 2385599e0a22SJ. Bruce Fields 0 == memcmp(sop->so_owner.data, owner->data, owner->len) && 2386599e0a22SJ. Bruce Fields (sop->so_client->cl_clientid.cl_id == clid->cl_id); 23871da177e4SLinus Torvalds } 23881da177e4SLinus Torvalds 2389fe0750e5SJ. Bruce Fields static struct nfs4_openowner * 23901da177e4SLinus Torvalds find_openstateowner_str(unsigned int hashval, struct nfsd4_open *open) 23911da177e4SLinus Torvalds { 23921da177e4SLinus Torvalds struct nfs4_stateowner *so = NULL; 23931da177e4SLinus Torvalds 2394506f275fSJ. Bruce Fields list_for_each_entry(so, &open_ownerstr_hashtbl[hashval], so_strhash) { 2395599e0a22SJ. Bruce Fields if (same_owner_str(so, &open->op_owner, &open->op_clientid)) 2396fe0750e5SJ. Bruce Fields return container_of(so, struct nfs4_openowner, oo_owner); 23971da177e4SLinus Torvalds } 23981da177e4SLinus Torvalds return NULL; 23991da177e4SLinus Torvalds } 24001da177e4SLinus Torvalds 24011da177e4SLinus Torvalds /* search file_hashtbl[] for file */ 24021da177e4SLinus Torvalds static struct nfs4_file * 24031da177e4SLinus Torvalds find_file(struct inode *ino) 24041da177e4SLinus Torvalds { 24051da177e4SLinus Torvalds unsigned int hashval = file_hashval(ino); 24061da177e4SLinus Torvalds struct nfs4_file *fp; 24071da177e4SLinus Torvalds 24088b671b80SJ. Bruce Fields spin_lock(&recall_lock); 24091da177e4SLinus Torvalds list_for_each_entry(fp, &file_hashtbl[hashval], fi_hash) { 241013cd2184SNeilBrown if (fp->fi_inode == ino) { 241113cd2184SNeilBrown get_nfs4_file(fp); 24128b671b80SJ. Bruce Fields spin_unlock(&recall_lock); 24131da177e4SLinus Torvalds return fp; 24141da177e4SLinus Torvalds } 241513cd2184SNeilBrown } 24168b671b80SJ. Bruce Fields spin_unlock(&recall_lock); 24171da177e4SLinus Torvalds return NULL; 24181da177e4SLinus Torvalds } 24191da177e4SLinus Torvalds 2420d87a8adeSAndy Adamson static inline int access_valid(u32 x, u32 minorversion) 2421ba5a6a19SJ. Bruce Fields { 2422d87a8adeSAndy Adamson if ((x & NFS4_SHARE_ACCESS_MASK) < NFS4_SHARE_ACCESS_READ) 24238838dc43SJ. Bruce Fields return 0; 2424d87a8adeSAndy Adamson if ((x & NFS4_SHARE_ACCESS_MASK) > NFS4_SHARE_ACCESS_BOTH) 2425d87a8adeSAndy Adamson return 0; 2426d87a8adeSAndy Adamson x &= ~NFS4_SHARE_ACCESS_MASK; 2427d87a8adeSAndy Adamson if (minorversion && x) { 2428d87a8adeSAndy Adamson if ((x & NFS4_SHARE_WANT_MASK) > NFS4_SHARE_WANT_CANCEL) 2429d87a8adeSAndy Adamson return 0; 2430d87a8adeSAndy Adamson if ((x & NFS4_SHARE_WHEN_MASK) > NFS4_SHARE_PUSH_DELEG_WHEN_UNCONTENDED) 2431d87a8adeSAndy Adamson return 0; 2432d87a8adeSAndy Adamson x &= ~(NFS4_SHARE_WANT_MASK | NFS4_SHARE_WHEN_MASK); 2433d87a8adeSAndy Adamson } 2434d87a8adeSAndy Adamson if (x) 24358838dc43SJ. Bruce Fields return 0; 24368838dc43SJ. Bruce Fields return 1; 2437ba5a6a19SJ. Bruce Fields } 2438ba5a6a19SJ. Bruce Fields 24398838dc43SJ. Bruce Fields static inline int deny_valid(u32 x) 2440ba5a6a19SJ. Bruce Fields { 24418838dc43SJ. Bruce Fields /* Note: unlike access bits, deny bits may be zero. */ 24428838dc43SJ. Bruce Fields return x <= NFS4_SHARE_DENY_BOTH; 2443ba5a6a19SJ. Bruce Fields } 24441da177e4SLinus Torvalds 24454f83aa30SJ. Bruce Fields /* 24461da177e4SLinus Torvalds * Called to check deny when READ with all zero stateid or 24471da177e4SLinus Torvalds * WRITE with all zero or all one stateid 24481da177e4SLinus Torvalds */ 2449b37ad28bSAl Viro static __be32 24501da177e4SLinus Torvalds nfs4_share_conflict(struct svc_fh *current_fh, unsigned int deny_type) 24511da177e4SLinus Torvalds { 24521da177e4SLinus Torvalds struct inode *ino = current_fh->fh_dentry->d_inode; 24531da177e4SLinus Torvalds struct nfs4_file *fp; 2454dcef0413SJ. Bruce Fields struct nfs4_ol_stateid *stp; 2455b37ad28bSAl Viro __be32 ret; 24561da177e4SLinus Torvalds 24571da177e4SLinus Torvalds dprintk("NFSD: nfs4_share_conflict\n"); 24581da177e4SLinus Torvalds 24591da177e4SLinus Torvalds fp = find_file(ino); 246013cd2184SNeilBrown if (!fp) 246113cd2184SNeilBrown return nfs_ok; 2462b700949bSNeilBrown ret = nfserr_locked; 24631da177e4SLinus Torvalds /* Search for conflicting share reservations */ 24648beefa24SNeilBrown list_for_each_entry(stp, &fp->fi_stateids, st_perfile) { 24651da177e4SLinus Torvalds if (test_bit(deny_type, &stp->st_deny_bmap) || 24661da177e4SLinus Torvalds test_bit(NFS4_SHARE_DENY_BOTH, &stp->st_deny_bmap)) 246713cd2184SNeilBrown goto out; 24681da177e4SLinus Torvalds } 246913cd2184SNeilBrown ret = nfs_ok; 247013cd2184SNeilBrown out: 247113cd2184SNeilBrown put_nfs4_file(fp); 247213cd2184SNeilBrown return ret; 24731da177e4SLinus Torvalds } 24741da177e4SLinus Torvalds 24756b57d9c8SJ. Bruce Fields static void nfsd_break_one_deleg(struct nfs4_delegation *dp) 24761da177e4SLinus Torvalds { 24771da177e4SLinus Torvalds /* We're assuming the state code never drops its reference 24781da177e4SLinus Torvalds * without first removing the lease. Since we're in this lease 24791da177e4SLinus Torvalds * callback (and since the lease code is serialized by the kernel 24801da177e4SLinus Torvalds * lock) we know the server hasn't removed the lease yet, we know 24811da177e4SLinus Torvalds * it's safe to take a reference: */ 24821da177e4SLinus Torvalds atomic_inc(&dp->dl_count); 24831da177e4SLinus Torvalds 24841da177e4SLinus Torvalds list_add_tail(&dp->dl_recall_lru, &del_recall_lru); 24851da177e4SLinus Torvalds 2486460781b5SArnd Bergmann /* only place dl_time is set. protected by lock_flocks*/ 24871da177e4SLinus Torvalds dp->dl_time = get_seconds(); 24881da177e4SLinus Torvalds 24896b57d9c8SJ. Bruce Fields nfsd4_cb_recall(dp); 24906b57d9c8SJ. Bruce Fields } 24916b57d9c8SJ. Bruce Fields 2492acfdf5c3SJ. Bruce Fields /* Called from break_lease() with lock_flocks() held. */ 24936b57d9c8SJ. Bruce Fields static void nfsd_break_deleg_cb(struct file_lock *fl) 24946b57d9c8SJ. Bruce Fields { 2495acfdf5c3SJ. Bruce Fields struct nfs4_file *fp = (struct nfs4_file *)fl->fl_owner; 2496acfdf5c3SJ. Bruce Fields struct nfs4_delegation *dp; 24976b57d9c8SJ. Bruce Fields 2498acfdf5c3SJ. Bruce Fields BUG_ON(!fp); 2499acfdf5c3SJ. Bruce Fields /* We assume break_lease is only called once per lease: */ 2500acfdf5c3SJ. Bruce Fields BUG_ON(fp->fi_had_conflict); 25010272e1fdSJ. Bruce Fields /* 25020272e1fdSJ. Bruce Fields * We don't want the locks code to timeout the lease for us; 2503acfdf5c3SJ. Bruce Fields * we'll remove it ourself if a delegation isn't returned 25046b57d9c8SJ. Bruce Fields * in time: 25050272e1fdSJ. Bruce Fields */ 25060272e1fdSJ. Bruce Fields fl->fl_break_time = 0; 25071da177e4SLinus Torvalds 25085d926e8cSJ. Bruce Fields spin_lock(&recall_lock); 2509acfdf5c3SJ. Bruce Fields fp->fi_had_conflict = true; 2510acfdf5c3SJ. Bruce Fields list_for_each_entry(dp, &fp->fi_delegations, dl_perfile) 25115d926e8cSJ. Bruce Fields nfsd_break_one_deleg(dp); 25125d926e8cSJ. Bruce Fields spin_unlock(&recall_lock); 25131da177e4SLinus Torvalds } 25141da177e4SLinus Torvalds 25151da177e4SLinus Torvalds static 25161da177e4SLinus Torvalds int nfsd_change_deleg_cb(struct file_lock **onlist, int arg) 25171da177e4SLinus Torvalds { 25181da177e4SLinus Torvalds if (arg & F_UNLCK) 25191da177e4SLinus Torvalds return lease_modify(onlist, arg); 25201da177e4SLinus Torvalds else 25211da177e4SLinus Torvalds return -EAGAIN; 25221da177e4SLinus Torvalds } 25231da177e4SLinus Torvalds 25247b021967SAlexey Dobriyan static const struct lock_manager_operations nfsd_lease_mng_ops = { 25258fb47a4fSJ. Bruce Fields .lm_break = nfsd_break_deleg_cb, 25268fb47a4fSJ. Bruce Fields .lm_change = nfsd_change_deleg_cb, 25271da177e4SLinus Torvalds }; 25281da177e4SLinus Torvalds 25297a8711c9SJ. Bruce Fields static __be32 nfsd4_check_seqid(struct nfsd4_compound_state *cstate, struct nfs4_stateowner *so, u32 seqid) 25307a8711c9SJ. Bruce Fields { 25317a8711c9SJ. Bruce Fields if (nfsd4_has_session(cstate)) 25327a8711c9SJ. Bruce Fields return nfs_ok; 25337a8711c9SJ. Bruce Fields if (seqid == so->so_seqid - 1) 25347a8711c9SJ. Bruce Fields return nfserr_replay_me; 25357a8711c9SJ. Bruce Fields if (seqid == so->so_seqid) 25367a8711c9SJ. Bruce Fields return nfs_ok; 25377a8711c9SJ. Bruce Fields return nfserr_bad_seqid; 25387a8711c9SJ. Bruce Fields } 25391da177e4SLinus Torvalds 2540b37ad28bSAl Viro __be32 25416668958fSAndy Adamson nfsd4_process_open1(struct nfsd4_compound_state *cstate, 25426668958fSAndy Adamson struct nfsd4_open *open) 25431da177e4SLinus Torvalds { 25441da177e4SLinus Torvalds clientid_t *clientid = &open->op_clientid; 25451da177e4SLinus Torvalds struct nfs4_client *clp = NULL; 25461da177e4SLinus Torvalds unsigned int strhashval; 2547fe0750e5SJ. Bruce Fields struct nfs4_openowner *oo = NULL; 25487a8711c9SJ. Bruce Fields __be32 status; 25491da177e4SLinus Torvalds 25501da177e4SLinus Torvalds if (!check_name(open->op_owner)) 25510f442aa2SJ. Bruce Fields return nfserr_inval; 25521da177e4SLinus Torvalds 25531da177e4SLinus Torvalds if (STALE_CLIENTID(&open->op_clientid)) 25541da177e4SLinus Torvalds return nfserr_stale_clientid; 25551da177e4SLinus Torvalds 2556506f275fSJ. Bruce Fields strhashval = open_ownerstr_hashval(clientid->cl_id, &open->op_owner); 2557fe0750e5SJ. Bruce Fields oo = find_openstateowner_str(strhashval, open); 2558fe0750e5SJ. Bruce Fields open->op_openowner = oo; 2559fe0750e5SJ. Bruce Fields if (!oo) { 25600f442aa2SJ. Bruce Fields /* Make sure the client's lease hasn't expired. */ 25610f442aa2SJ. Bruce Fields clp = find_confirmed_client(clientid); 25620f442aa2SJ. Bruce Fields if (clp == NULL) 25630f442aa2SJ. Bruce Fields return nfserr_expired; 25640f442aa2SJ. Bruce Fields goto renew; 25650f442aa2SJ. Bruce Fields } 2566fe0750e5SJ. Bruce Fields if (!oo->oo_confirmed) { 25670f442aa2SJ. Bruce Fields /* Replace unconfirmed owners without checking for replay. */ 2568fe0750e5SJ. Bruce Fields clp = oo->oo_owner.so_client; 2569fe0750e5SJ. Bruce Fields release_openowner(oo); 2570fe0750e5SJ. Bruce Fields open->op_openowner = NULL; 2571ae8b6253SJ. Bruce Fields goto renew; 25720f442aa2SJ. Bruce Fields } 2573fe0750e5SJ. Bruce Fields status = nfsd4_check_seqid(cstate, &oo->oo_owner, open->op_seqid); 25747a8711c9SJ. Bruce Fields if (status) 25757a8711c9SJ. Bruce Fields return status; 25760f442aa2SJ. Bruce Fields renew: 2577fe0750e5SJ. Bruce Fields if (open->op_openowner == NULL) { 2578fe0750e5SJ. Bruce Fields oo = alloc_init_open_stateowner(strhashval, clp, open); 2579fe0750e5SJ. Bruce Fields if (oo == NULL) 25803e772463SJ. Bruce Fields return nfserr_jukebox; 2581fe0750e5SJ. Bruce Fields open->op_openowner = oo; 25820f442aa2SJ. Bruce Fields } 2583fe0750e5SJ. Bruce Fields list_del_init(&oo->oo_close_lru); 2584fe0750e5SJ. Bruce Fields renew_client(oo->oo_owner.so_client); 25850f442aa2SJ. Bruce Fields return nfs_ok; 25861da177e4SLinus Torvalds } 25871da177e4SLinus Torvalds 2588b37ad28bSAl Viro static inline __be32 25894a6e43e6SNeilBrown nfs4_check_delegmode(struct nfs4_delegation *dp, int flags) 25904a6e43e6SNeilBrown { 25914a6e43e6SNeilBrown if ((flags & WR_STATE) && (dp->dl_type == NFS4_OPEN_DELEGATE_READ)) 25924a6e43e6SNeilBrown return nfserr_openmode; 25934a6e43e6SNeilBrown else 25944a6e43e6SNeilBrown return nfs_ok; 25954a6e43e6SNeilBrown } 25964a6e43e6SNeilBrown 2597c47d832bSDaniel Mack static int share_access_to_flags(u32 share_access) 259824a0111eSJ. Bruce Fields { 259924a0111eSJ. Bruce Fields share_access &= ~NFS4_SHARE_WANT_MASK; 260024a0111eSJ. Bruce Fields 260124a0111eSJ. Bruce Fields return share_access == NFS4_SHARE_ACCESS_READ ? RD_STATE : WR_STATE; 260224a0111eSJ. Bruce Fields } 260324a0111eSJ. Bruce Fields 2604f459e453SJ. Bruce Fields static struct nfs4_delegation *find_deleg_stateid(stateid_t *s) 2605f459e453SJ. Bruce Fields { 2606f459e453SJ. Bruce Fields struct nfs4_stid *ret; 2607f459e453SJ. Bruce Fields 2608f459e453SJ. Bruce Fields ret = find_stateid_by_type(s, NFS4_DELEG_STID); 2609f459e453SJ. Bruce Fields if (!ret) 2610f459e453SJ. Bruce Fields return NULL; 2611f459e453SJ. Bruce Fields return delegstateid(ret); 2612f459e453SJ. Bruce Fields } 2613f459e453SJ. Bruce Fields 2614b37ad28bSAl Viro static __be32 2615567d9829SNeilBrown nfs4_check_deleg(struct nfs4_file *fp, struct nfsd4_open *open, 2616567d9829SNeilBrown struct nfs4_delegation **dp) 2617567d9829SNeilBrown { 2618567d9829SNeilBrown int flags; 2619b37ad28bSAl Viro __be32 status = nfserr_bad_stateid; 2620567d9829SNeilBrown 2621f459e453SJ. Bruce Fields *dp = find_deleg_stateid(&open->op_delegate_stateid); 2622567d9829SNeilBrown if (*dp == NULL) 2623c44c5eebSNeilBrown goto out; 262424a0111eSJ. Bruce Fields flags = share_access_to_flags(open->op_share_access); 2625567d9829SNeilBrown status = nfs4_check_delegmode(*dp, flags); 2626567d9829SNeilBrown if (status) 2627567d9829SNeilBrown *dp = NULL; 2628c44c5eebSNeilBrown out: 2629c44c5eebSNeilBrown if (open->op_claim_type != NFS4_OPEN_CLAIM_DELEGATE_CUR) 2630c44c5eebSNeilBrown return nfs_ok; 2631c44c5eebSNeilBrown if (status) 2632c44c5eebSNeilBrown return status; 2633fe0750e5SJ. Bruce Fields open->op_openowner->oo_confirmed = 1; 2634c44c5eebSNeilBrown return nfs_ok; 2635567d9829SNeilBrown } 2636567d9829SNeilBrown 2637b37ad28bSAl Viro static __be32 2638dcef0413SJ. Bruce Fields nfs4_check_open(struct nfs4_file *fp, struct nfsd4_open *open, struct nfs4_ol_stateid **stpp) 26391da177e4SLinus Torvalds { 2640dcef0413SJ. Bruce Fields struct nfs4_ol_stateid *local; 2641fe0750e5SJ. Bruce Fields struct nfs4_openowner *oo = open->op_openowner; 26421da177e4SLinus Torvalds 26438beefa24SNeilBrown list_for_each_entry(local, &fp->fi_stateids, st_perfile) { 26441da177e4SLinus Torvalds /* ignore lock owners */ 26451da177e4SLinus Torvalds if (local->st_stateowner->so_is_open_owner == 0) 26461da177e4SLinus Torvalds continue; 26471da177e4SLinus Torvalds /* remember if we have seen this open owner */ 2648fe0750e5SJ. Bruce Fields if (local->st_stateowner == &oo->oo_owner) 26491da177e4SLinus Torvalds *stpp = local; 26501da177e4SLinus Torvalds /* check for conflicting share reservations */ 26511da177e4SLinus Torvalds if (!test_share(local, open)) 265277eaae8dSJ. Bruce Fields return nfserr_share_denied; 26531da177e4SLinus Torvalds } 265477eaae8dSJ. Bruce Fields return nfs_ok; 26551da177e4SLinus Torvalds } 26561da177e4SLinus Torvalds 2657dcef0413SJ. Bruce Fields static inline struct nfs4_ol_stateid * 26585ac049acSNeilBrown nfs4_alloc_stateid(void) 26595ac049acSNeilBrown { 26605ac049acSNeilBrown return kmem_cache_alloc(stateid_slab, GFP_KERNEL); 26615ac049acSNeilBrown } 26625ac049acSNeilBrown 266321fb4016SJ. Bruce Fields static inline int nfs4_access_to_access(u32 nfs4_access) 266421fb4016SJ. Bruce Fields { 266521fb4016SJ. Bruce Fields int flags = 0; 266621fb4016SJ. Bruce Fields 266721fb4016SJ. Bruce Fields if (nfs4_access & NFS4_SHARE_ACCESS_READ) 266821fb4016SJ. Bruce Fields flags |= NFSD_MAY_READ; 266921fb4016SJ. Bruce Fields if (nfs4_access & NFS4_SHARE_ACCESS_WRITE) 267021fb4016SJ. Bruce Fields flags |= NFSD_MAY_WRITE; 267121fb4016SJ. Bruce Fields return flags; 267221fb4016SJ. Bruce Fields } 267321fb4016SJ. Bruce Fields 26740c12eaffSCasey Bodley static __be32 nfs4_get_vfs_file(struct svc_rqst *rqstp, struct nfs4_file *fp, 26750c12eaffSCasey Bodley struct svc_fh *cur_fh, struct nfsd4_open *open) 2676f9d7562fSJ. Bruce Fields { 2677f9d7562fSJ. Bruce Fields __be32 status; 26780c12eaffSCasey Bodley int oflag = nfs4_access_to_omode(open->op_share_access); 26790c12eaffSCasey Bodley int access = nfs4_access_to_access(open->op_share_access); 26800c12eaffSCasey Bodley 26810c12eaffSCasey Bodley /* CLAIM_DELEGATE_CUR is used in response to a broken lease; 26820c12eaffSCasey Bodley * allowing it to break the lease and return EAGAIN leaves the 26830c12eaffSCasey Bodley * client unable to make progress in returning the delegation */ 26840c12eaffSCasey Bodley if (open->op_claim_type == NFS4_OPEN_CLAIM_DELEGATE_CUR) 26850c12eaffSCasey Bodley access |= NFSD_MAY_NOT_BREAK_LEASE; 2686f9d7562fSJ. Bruce Fields 2687f9d7562fSJ. Bruce Fields if (!fp->fi_fds[oflag]) { 2688f9d7562fSJ. Bruce Fields status = nfsd_open(rqstp, cur_fh, S_IFREG, access, 2689f9d7562fSJ. Bruce Fields &fp->fi_fds[oflag]); 2690f9d7562fSJ. Bruce Fields if (status) 2691f9d7562fSJ. Bruce Fields return status; 2692f9d7562fSJ. Bruce Fields } 2693f9d7562fSJ. Bruce Fields nfs4_file_get_access(fp, oflag); 2694f9d7562fSJ. Bruce Fields 2695f9d7562fSJ. Bruce Fields return nfs_ok; 2696f9d7562fSJ. Bruce Fields } 2697f9d7562fSJ. Bruce Fields 2698b37ad28bSAl Viro static __be32 2699dcef0413SJ. Bruce Fields nfs4_new_open(struct svc_rqst *rqstp, struct nfs4_ol_stateid **stpp, 2700f9d7562fSJ. Bruce Fields struct nfs4_file *fp, struct svc_fh *cur_fh, 2701f9d7562fSJ. Bruce Fields struct nfsd4_open *open) 27021da177e4SLinus Torvalds { 2703dcef0413SJ. Bruce Fields struct nfs4_ol_stateid *stp; 2704f9d7562fSJ. Bruce Fields __be32 status; 27051da177e4SLinus Torvalds 27065ac049acSNeilBrown stp = nfs4_alloc_stateid(); 27071da177e4SLinus Torvalds if (stp == NULL) 27083e772463SJ. Bruce Fields return nfserr_jukebox; 27091da177e4SLinus Torvalds 27100c12eaffSCasey Bodley status = nfs4_get_vfs_file(rqstp, fp, cur_fh, open); 27111da177e4SLinus Torvalds if (status) { 27125ac049acSNeilBrown kmem_cache_free(stateid_slab, stp); 27131da177e4SLinus Torvalds return status; 27141da177e4SLinus Torvalds } 27151da177e4SLinus Torvalds *stpp = stp; 27161da177e4SLinus Torvalds return 0; 27171da177e4SLinus Torvalds } 27181da177e4SLinus Torvalds 2719b37ad28bSAl Viro static inline __be32 27201da177e4SLinus Torvalds nfsd4_truncate(struct svc_rqst *rqstp, struct svc_fh *fh, 27211da177e4SLinus Torvalds struct nfsd4_open *open) 27221da177e4SLinus Torvalds { 27231da177e4SLinus Torvalds struct iattr iattr = { 27241da177e4SLinus Torvalds .ia_valid = ATTR_SIZE, 27251da177e4SLinus Torvalds .ia_size = 0, 27261da177e4SLinus Torvalds }; 27271da177e4SLinus Torvalds if (!open->op_truncate) 27281da177e4SLinus Torvalds return 0; 27291da177e4SLinus Torvalds if (!(open->op_share_access & NFS4_SHARE_ACCESS_WRITE)) 27309246585aSAl Viro return nfserr_inval; 27311da177e4SLinus Torvalds return nfsd_setattr(rqstp, fh, &iattr, 0, (time_t)0); 27321da177e4SLinus Torvalds } 27331da177e4SLinus Torvalds 2734b37ad28bSAl Viro static __be32 2735dcef0413SJ. Bruce Fields nfs4_upgrade_open(struct svc_rqst *rqstp, struct nfs4_file *fp, struct svc_fh *cur_fh, struct nfs4_ol_stateid *stp, struct nfsd4_open *open) 27361da177e4SLinus Torvalds { 27377d947842SJ. Bruce Fields u32 op_share_access = open->op_share_access & ~NFS4_SHARE_WANT_MASK; 27387d947842SJ. Bruce Fields bool new_access; 2739b37ad28bSAl Viro __be32 status; 27401da177e4SLinus Torvalds 27417d947842SJ. Bruce Fields new_access = !test_bit(op_share_access, &stp->st_access_bmap); 2742f9d7562fSJ. Bruce Fields if (new_access) { 27430c12eaffSCasey Bodley status = nfs4_get_vfs_file(rqstp, fp, cur_fh, open); 2744f9d7562fSJ. Bruce Fields if (status) 2745f9d7562fSJ. Bruce Fields return status; 27466c26d08fSJ. Bruce Fields } 27471da177e4SLinus Torvalds status = nfsd4_truncate(rqstp, cur_fh, open); 27481da177e4SLinus Torvalds if (status) { 2749f9d7562fSJ. Bruce Fields if (new_access) { 2750f197c271SJ. Bruce Fields int oflag = nfs4_access_to_omode(op_share_access); 2751f9d7562fSJ. Bruce Fields nfs4_file_put_access(fp, oflag); 2752f9d7562fSJ. Bruce Fields } 27531da177e4SLinus Torvalds return status; 27541da177e4SLinus Torvalds } 27551da177e4SLinus Torvalds /* remember the open */ 275624a0111eSJ. Bruce Fields __set_bit(op_share_access, &stp->st_access_bmap); 2757b55e0ba1SJ. Bruce Fields __set_bit(open->op_share_deny, &stp->st_deny_bmap); 27581da177e4SLinus Torvalds 27591da177e4SLinus Torvalds return nfs_ok; 27601da177e4SLinus Torvalds } 27611da177e4SLinus Torvalds 27621da177e4SLinus Torvalds 27631da177e4SLinus Torvalds static void 276437515177SNeilBrown nfs4_set_claim_prev(struct nfsd4_open *open) 27651da177e4SLinus Torvalds { 2766fe0750e5SJ. Bruce Fields open->op_openowner->oo_confirmed = 1; 2767fe0750e5SJ. Bruce Fields open->op_openowner->oo_owner.so_client->cl_firststate = 1; 27681da177e4SLinus Torvalds } 27691da177e4SLinus Torvalds 277014a24e99SJ. Bruce Fields /* Should we give out recallable state?: */ 277114a24e99SJ. Bruce Fields static bool nfsd4_cb_channel_good(struct nfs4_client *clp) 277214a24e99SJ. Bruce Fields { 277314a24e99SJ. Bruce Fields if (clp->cl_cb_state == NFSD4_CB_UP) 277414a24e99SJ. Bruce Fields return true; 277514a24e99SJ. Bruce Fields /* 277614a24e99SJ. Bruce Fields * In the sessions case, since we don't have to establish a 277714a24e99SJ. Bruce Fields * separate connection for callbacks, we assume it's OK 277814a24e99SJ. Bruce Fields * until we hear otherwise: 277914a24e99SJ. Bruce Fields */ 278014a24e99SJ. Bruce Fields return clp->cl_minorversion && clp->cl_cb_state == NFSD4_CB_UNKNOWN; 278114a24e99SJ. Bruce Fields } 278214a24e99SJ. Bruce Fields 278322d38c4cSJ. Bruce Fields static struct file_lock *nfs4_alloc_init_lease(struct nfs4_delegation *dp, int flag) 278422d38c4cSJ. Bruce Fields { 278522d38c4cSJ. Bruce Fields struct file_lock *fl; 278622d38c4cSJ. Bruce Fields 278722d38c4cSJ. Bruce Fields fl = locks_alloc_lock(); 278822d38c4cSJ. Bruce Fields if (!fl) 278922d38c4cSJ. Bruce Fields return NULL; 279022d38c4cSJ. Bruce Fields locks_init_lock(fl); 279122d38c4cSJ. Bruce Fields fl->fl_lmops = &nfsd_lease_mng_ops; 279222d38c4cSJ. Bruce Fields fl->fl_flags = FL_LEASE; 279322d38c4cSJ. Bruce Fields fl->fl_type = flag == NFS4_OPEN_DELEGATE_READ? F_RDLCK: F_WRLCK; 279422d38c4cSJ. Bruce Fields fl->fl_end = OFFSET_MAX; 2795acfdf5c3SJ. Bruce Fields fl->fl_owner = (fl_owner_t)(dp->dl_file); 279622d38c4cSJ. Bruce Fields fl->fl_pid = current->tgid; 279722d38c4cSJ. Bruce Fields return fl; 279822d38c4cSJ. Bruce Fields } 279922d38c4cSJ. Bruce Fields 2800edab9782SJ. Bruce Fields static int nfs4_setlease(struct nfs4_delegation *dp, int flag) 2801edab9782SJ. Bruce Fields { 2802acfdf5c3SJ. Bruce Fields struct nfs4_file *fp = dp->dl_file; 2803edab9782SJ. Bruce Fields struct file_lock *fl; 2804edab9782SJ. Bruce Fields int status; 2805edab9782SJ. Bruce Fields 2806edab9782SJ. Bruce Fields fl = nfs4_alloc_init_lease(dp, flag); 2807edab9782SJ. Bruce Fields if (!fl) 2808edab9782SJ. Bruce Fields return -ENOMEM; 2809acfdf5c3SJ. Bruce Fields fl->fl_file = find_readable_file(fp); 2810acfdf5c3SJ. Bruce Fields list_add(&dp->dl_perclnt, &dp->dl_client->cl_delegations); 2811acfdf5c3SJ. Bruce Fields status = vfs_setlease(fl->fl_file, fl->fl_type, &fl); 2812edab9782SJ. Bruce Fields if (status) { 2813acfdf5c3SJ. Bruce Fields list_del_init(&dp->dl_perclnt); 2814edab9782SJ. Bruce Fields locks_free_lock(fl); 2815edab9782SJ. Bruce Fields return -ENOMEM; 2816edab9782SJ. Bruce Fields } 2817acfdf5c3SJ. Bruce Fields fp->fi_lease = fl; 2818acfdf5c3SJ. Bruce Fields fp->fi_deleg_file = fl->fl_file; 2819acfdf5c3SJ. Bruce Fields get_file(fp->fi_deleg_file); 2820acfdf5c3SJ. Bruce Fields atomic_set(&fp->fi_delegees, 1); 2821acfdf5c3SJ. Bruce Fields list_add(&dp->dl_perfile, &fp->fi_delegations); 2822acfdf5c3SJ. Bruce Fields return 0; 2823acfdf5c3SJ. Bruce Fields } 2824acfdf5c3SJ. Bruce Fields 2825acfdf5c3SJ. Bruce Fields static int nfs4_set_delegation(struct nfs4_delegation *dp, int flag) 2826acfdf5c3SJ. Bruce Fields { 2827acfdf5c3SJ. Bruce Fields struct nfs4_file *fp = dp->dl_file; 2828acfdf5c3SJ. Bruce Fields 2829acfdf5c3SJ. Bruce Fields if (!fp->fi_lease) 2830acfdf5c3SJ. Bruce Fields return nfs4_setlease(dp, flag); 2831acfdf5c3SJ. Bruce Fields spin_lock(&recall_lock); 2832acfdf5c3SJ. Bruce Fields if (fp->fi_had_conflict) { 2833acfdf5c3SJ. Bruce Fields spin_unlock(&recall_lock); 2834acfdf5c3SJ. Bruce Fields return -EAGAIN; 2835acfdf5c3SJ. Bruce Fields } 2836acfdf5c3SJ. Bruce Fields atomic_inc(&fp->fi_delegees); 2837acfdf5c3SJ. Bruce Fields list_add(&dp->dl_perfile, &fp->fi_delegations); 2838acfdf5c3SJ. Bruce Fields spin_unlock(&recall_lock); 2839acfdf5c3SJ. Bruce Fields list_add(&dp->dl_perclnt, &dp->dl_client->cl_delegations); 2840edab9782SJ. Bruce Fields return 0; 2841edab9782SJ. Bruce Fields } 2842edab9782SJ. Bruce Fields 28431da177e4SLinus Torvalds /* 28441da177e4SLinus Torvalds * Attempt to hand out a delegation. 28451da177e4SLinus Torvalds */ 28461da177e4SLinus Torvalds static void 2847dcef0413SJ. Bruce Fields nfs4_open_delegation(struct svc_fh *fh, struct nfsd4_open *open, struct nfs4_ol_stateid *stp) 28481da177e4SLinus Torvalds { 28491da177e4SLinus Torvalds struct nfs4_delegation *dp; 2850fe0750e5SJ. Bruce Fields struct nfs4_openowner *oo = container_of(stp->st_stateowner, struct nfs4_openowner, oo_owner); 285114a24e99SJ. Bruce Fields int cb_up; 28521da177e4SLinus Torvalds int status, flag = 0; 28531da177e4SLinus Torvalds 2854fe0750e5SJ. Bruce Fields cb_up = nfsd4_cb_channel_good(oo->oo_owner.so_client); 28551da177e4SLinus Torvalds flag = NFS4_OPEN_DELEGATE_NONE; 28567b190fecSNeilBrown open->op_recall = 0; 28577b190fecSNeilBrown switch (open->op_claim_type) { 28587b190fecSNeilBrown case NFS4_OPEN_CLAIM_PREVIOUS: 28592bf23875SJ. Bruce Fields if (!cb_up) 28607b190fecSNeilBrown open->op_recall = 1; 28617b190fecSNeilBrown flag = open->op_delegate_type; 28627b190fecSNeilBrown if (flag == NFS4_OPEN_DELEGATE_NONE) 28631da177e4SLinus Torvalds goto out; 28647b190fecSNeilBrown break; 28657b190fecSNeilBrown case NFS4_OPEN_CLAIM_NULL: 28667b190fecSNeilBrown /* Let's not give out any delegations till everyone's 28677b190fecSNeilBrown * had the chance to reclaim theirs.... */ 2868af558e33SJ. Bruce Fields if (locks_in_grace()) 28697b190fecSNeilBrown goto out; 2870fe0750e5SJ. Bruce Fields if (!cb_up || !oo->oo_confirmed) 28717b190fecSNeilBrown goto out; 28721da177e4SLinus Torvalds if (open->op_share_access & NFS4_SHARE_ACCESS_WRITE) 28731da177e4SLinus Torvalds flag = NFS4_OPEN_DELEGATE_WRITE; 28741da177e4SLinus Torvalds else 28751da177e4SLinus Torvalds flag = NFS4_OPEN_DELEGATE_READ; 28767b190fecSNeilBrown break; 28777b190fecSNeilBrown default: 28787b190fecSNeilBrown goto out; 28797b190fecSNeilBrown } 28801da177e4SLinus Torvalds 2881fe0750e5SJ. Bruce Fields dp = alloc_init_deleg(oo->oo_owner.so_client, stp, fh, flag); 2882dd239cc0SJ. Bruce Fields if (dp == NULL) 2883dd239cc0SJ. Bruce Fields goto out_no_deleg; 2884acfdf5c3SJ. Bruce Fields status = nfs4_set_delegation(dp, flag); 2885edab9782SJ. Bruce Fields if (status) 2886dd239cc0SJ. Bruce Fields goto out_free; 28871da177e4SLinus Torvalds 2888d5477a8dSJ. Bruce Fields memcpy(&open->op_delegate_stateid, &dp->dl_stid.sc_stateid, sizeof(dp->dl_stid.sc_stateid)); 28891da177e4SLinus Torvalds 28908c10cbdbSBenny Halevy dprintk("NFSD: delegation stateid=" STATEID_FMT "\n", 2891d5477a8dSJ. Bruce Fields STATEID_VAL(&dp->dl_stid.sc_stateid)); 28921da177e4SLinus Torvalds out: 28937b190fecSNeilBrown if (open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS 28947b190fecSNeilBrown && flag == NFS4_OPEN_DELEGATE_NONE 28957b190fecSNeilBrown && open->op_delegate_type != NFS4_OPEN_DELEGATE_NONE) 28962fdada03SJ. Bruce Fields dprintk("NFSD: WARNING: refusing delegation reclaim\n"); 28971da177e4SLinus Torvalds open->op_delegate_type = flag; 2898dd239cc0SJ. Bruce Fields return; 2899dd239cc0SJ. Bruce Fields out_free: 2900acfdf5c3SJ. Bruce Fields nfs4_put_delegation(dp); 2901dd239cc0SJ. Bruce Fields out_no_deleg: 2902dd239cc0SJ. Bruce Fields flag = NFS4_OPEN_DELEGATE_NONE; 2903dd239cc0SJ. Bruce Fields goto out; 29041da177e4SLinus Torvalds } 29051da177e4SLinus Torvalds 29061da177e4SLinus Torvalds /* 29071da177e4SLinus Torvalds * called with nfs4_lock_state() held. 29081da177e4SLinus Torvalds */ 2909b37ad28bSAl Viro __be32 29101da177e4SLinus Torvalds nfsd4_process_open2(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open) 29111da177e4SLinus Torvalds { 29126668958fSAndy Adamson struct nfsd4_compoundres *resp = rqstp->rq_resp; 29131da177e4SLinus Torvalds struct nfs4_file *fp = NULL; 29141da177e4SLinus Torvalds struct inode *ino = current_fh->fh_dentry->d_inode; 2915dcef0413SJ. Bruce Fields struct nfs4_ol_stateid *stp = NULL; 2916567d9829SNeilBrown struct nfs4_delegation *dp = NULL; 2917b37ad28bSAl Viro __be32 status; 29181da177e4SLinus Torvalds 29191da177e4SLinus Torvalds status = nfserr_inval; 2920d87a8adeSAndy Adamson if (!access_valid(open->op_share_access, resp->cstate.minorversion) 2921ba5a6a19SJ. Bruce Fields || !deny_valid(open->op_share_deny)) 29221da177e4SLinus Torvalds goto out; 29231da177e4SLinus Torvalds /* 29241da177e4SLinus Torvalds * Lookup file; if found, lookup stateid and check open request, 29251da177e4SLinus Torvalds * and check for delegations in the process of being recalled. 29261da177e4SLinus Torvalds * If not found, create the nfs4_file struct 29271da177e4SLinus Torvalds */ 29281da177e4SLinus Torvalds fp = find_file(ino); 29291da177e4SLinus Torvalds if (fp) { 29301da177e4SLinus Torvalds if ((status = nfs4_check_open(fp, open, &stp))) 29311da177e4SLinus Torvalds goto out; 2932c44c5eebSNeilBrown status = nfs4_check_deleg(fp, open, &dp); 2933c44c5eebSNeilBrown if (status) 2934c44c5eebSNeilBrown goto out; 29351da177e4SLinus Torvalds } else { 2936c44c5eebSNeilBrown status = nfserr_bad_stateid; 2937c44c5eebSNeilBrown if (open->op_claim_type == NFS4_OPEN_CLAIM_DELEGATE_CUR) 2938c44c5eebSNeilBrown goto out; 29393e772463SJ. Bruce Fields status = nfserr_jukebox; 29401da177e4SLinus Torvalds fp = alloc_init_file(ino); 29411da177e4SLinus Torvalds if (fp == NULL) 29421da177e4SLinus Torvalds goto out; 29431da177e4SLinus Torvalds } 29441da177e4SLinus Torvalds 29451da177e4SLinus Torvalds /* 29461da177e4SLinus Torvalds * OPEN the file, or upgrade an existing OPEN. 29471da177e4SLinus Torvalds * If truncate fails, the OPEN fails. 29481da177e4SLinus Torvalds */ 29491da177e4SLinus Torvalds if (stp) { 29501da177e4SLinus Torvalds /* Stateid was found, this is an OPEN upgrade */ 2951f9d7562fSJ. Bruce Fields status = nfs4_upgrade_open(rqstp, fp, current_fh, stp, open); 29521da177e4SLinus Torvalds if (status) 29531da177e4SLinus Torvalds goto out; 29541da177e4SLinus Torvalds } else { 2955f9d7562fSJ. Bruce Fields status = nfs4_new_open(rqstp, &stp, fp, current_fh, open); 2956567d9829SNeilBrown if (status) 29571da177e4SLinus Torvalds goto out; 2958881ea2b1SJ. Bruce Fields init_open_stateid(stp, fp, open); 29591da177e4SLinus Torvalds status = nfsd4_truncate(rqstp, current_fh, open); 29601da177e4SLinus Torvalds if (status) { 29612283963fSJ. Bruce Fields release_open_stateid(stp); 29621da177e4SLinus Torvalds goto out; 29631da177e4SLinus Torvalds } 29641da177e4SLinus Torvalds } 2965dcef0413SJ. Bruce Fields update_stateid(&stp->st_stid.sc_stateid); 2966dcef0413SJ. Bruce Fields memcpy(&open->op_stateid, &stp->st_stid.sc_stateid, sizeof(stateid_t)); 29671da177e4SLinus Torvalds 29684dc6ec00SJ. Bruce Fields if (nfsd4_has_session(&resp->cstate)) 2969fe0750e5SJ. Bruce Fields open->op_openowner->oo_confirmed = 1; 29706668958fSAndy Adamson 29711da177e4SLinus Torvalds /* 29721da177e4SLinus Torvalds * Attempt to hand out a delegation. No error return, because the 29731da177e4SLinus Torvalds * OPEN succeeds even if we fail. 29741da177e4SLinus Torvalds */ 29751da177e4SLinus Torvalds nfs4_open_delegation(current_fh, open, stp); 29761da177e4SLinus Torvalds 29771da177e4SLinus Torvalds status = nfs_ok; 29781da177e4SLinus Torvalds 29798c10cbdbSBenny Halevy dprintk("%s: stateid=" STATEID_FMT "\n", __func__, 2980dcef0413SJ. Bruce Fields STATEID_VAL(&stp->st_stid.sc_stateid)); 29811da177e4SLinus Torvalds out: 298213cd2184SNeilBrown if (fp) 298313cd2184SNeilBrown put_nfs4_file(fp); 298437515177SNeilBrown if (status == 0 && open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS) 298537515177SNeilBrown nfs4_set_claim_prev(open); 29861da177e4SLinus Torvalds /* 29871da177e4SLinus Torvalds * To finish the open response, we just need to set the rflags. 29881da177e4SLinus Torvalds */ 29891da177e4SLinus Torvalds open->op_rflags = NFS4_OPEN_RESULT_LOCKTYPE_POSIX; 2990fe0750e5SJ. Bruce Fields if (!open->op_openowner->oo_confirmed && 29916668958fSAndy Adamson !nfsd4_has_session(&resp->cstate)) 29921da177e4SLinus Torvalds open->op_rflags |= NFS4_OPEN_RESULT_CONFIRM; 29931da177e4SLinus Torvalds 29941da177e4SLinus Torvalds return status; 29951da177e4SLinus Torvalds } 29961da177e4SLinus Torvalds 2997b37ad28bSAl Viro __be32 2998b591480bSJ.Bruce Fields nfsd4_renew(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 2999b591480bSJ.Bruce Fields clientid_t *clid) 30001da177e4SLinus Torvalds { 30011da177e4SLinus Torvalds struct nfs4_client *clp; 3002b37ad28bSAl Viro __be32 status; 30031da177e4SLinus Torvalds 30041da177e4SLinus Torvalds nfs4_lock_state(); 30051da177e4SLinus Torvalds dprintk("process_renew(%08x/%08x): starting\n", 30061da177e4SLinus Torvalds clid->cl_boot, clid->cl_id); 30071da177e4SLinus Torvalds status = nfserr_stale_clientid; 30081da177e4SLinus Torvalds if (STALE_CLIENTID(clid)) 30091da177e4SLinus Torvalds goto out; 30101da177e4SLinus Torvalds clp = find_confirmed_client(clid); 30111da177e4SLinus Torvalds status = nfserr_expired; 30121da177e4SLinus Torvalds if (clp == NULL) { 30131da177e4SLinus Torvalds /* We assume the client took too long to RENEW. */ 30141da177e4SLinus Torvalds dprintk("nfsd4_renew: clientid not found!\n"); 30151da177e4SLinus Torvalds goto out; 30161da177e4SLinus Torvalds } 30171da177e4SLinus Torvalds renew_client(clp); 30181da177e4SLinus Torvalds status = nfserr_cb_path_down; 3019ea1da636SNeilBrown if (!list_empty(&clp->cl_delegations) 302077a3569dSJ. Bruce Fields && clp->cl_cb_state != NFSD4_CB_UP) 30211da177e4SLinus Torvalds goto out; 30221da177e4SLinus Torvalds status = nfs_ok; 30231da177e4SLinus Torvalds out: 30241da177e4SLinus Torvalds nfs4_unlock_state(); 30251da177e4SLinus Torvalds return status; 30261da177e4SLinus Torvalds } 30271da177e4SLinus Torvalds 3028c47d832bSDaniel Mack static struct lock_manager nfsd4_manager = { 3029af558e33SJ. Bruce Fields }; 3030af558e33SJ. Bruce Fields 3031a76b4319SNeilBrown static void 3032af558e33SJ. Bruce Fields nfsd4_end_grace(void) 3033a76b4319SNeilBrown { 3034a76b4319SNeilBrown dprintk("NFSD: end of grace period\n"); 3035c7b9a459SNeilBrown nfsd4_recdir_purge_old(); 3036af558e33SJ. Bruce Fields locks_end_grace(&nfsd4_manager); 3037e46b498cSJ. Bruce Fields /* 3038e46b498cSJ. Bruce Fields * Now that every NFSv4 client has had the chance to recover and 3039e46b498cSJ. Bruce Fields * to see the (possibly new, possibly shorter) lease time, we 3040e46b498cSJ. Bruce Fields * can safely set the next grace time to the current lease time: 3041e46b498cSJ. Bruce Fields */ 3042e46b498cSJ. Bruce Fields nfsd4_grace = nfsd4_lease; 3043a76b4319SNeilBrown } 3044a76b4319SNeilBrown 3045fd39ca9aSNeilBrown static time_t 30461da177e4SLinus Torvalds nfs4_laundromat(void) 30471da177e4SLinus Torvalds { 30481da177e4SLinus Torvalds struct nfs4_client *clp; 3049fe0750e5SJ. Bruce Fields struct nfs4_openowner *oo; 30501da177e4SLinus Torvalds struct nfs4_delegation *dp; 30511da177e4SLinus Torvalds struct list_head *pos, *next, reaplist; 3052cf07d2eaSJ. Bruce Fields time_t cutoff = get_seconds() - nfsd4_lease; 3053cf07d2eaSJ. Bruce Fields time_t t, clientid_val = nfsd4_lease; 3054cf07d2eaSJ. Bruce Fields time_t u, test_val = nfsd4_lease; 30551da177e4SLinus Torvalds 30561da177e4SLinus Torvalds nfs4_lock_state(); 30571da177e4SLinus Torvalds 30581da177e4SLinus Torvalds dprintk("NFSD: laundromat service - starting\n"); 3059af558e33SJ. Bruce Fields if (locks_in_grace()) 3060af558e33SJ. Bruce Fields nfsd4_end_grace(); 306136acb66bSBenny Halevy INIT_LIST_HEAD(&reaplist); 306236acb66bSBenny Halevy spin_lock(&client_lock); 30631da177e4SLinus Torvalds list_for_each_safe(pos, next, &client_lru) { 30641da177e4SLinus Torvalds clp = list_entry(pos, struct nfs4_client, cl_lru); 30651da177e4SLinus Torvalds if (time_after((unsigned long)clp->cl_time, (unsigned long)cutoff)) { 30661da177e4SLinus Torvalds t = clp->cl_time - cutoff; 30671da177e4SLinus Torvalds if (clientid_val > t) 30681da177e4SLinus Torvalds clientid_val = t; 30691da177e4SLinus Torvalds break; 30701da177e4SLinus Torvalds } 3071d7682988SBenny Halevy if (atomic_read(&clp->cl_refcount)) { 3072d7682988SBenny Halevy dprintk("NFSD: client in use (clientid %08x)\n", 3073d7682988SBenny Halevy clp->cl_clientid.cl_id); 3074d7682988SBenny Halevy continue; 3075d7682988SBenny Halevy } 3076d7682988SBenny Halevy unhash_client_locked(clp); 3077d7682988SBenny Halevy list_add(&clp->cl_lru, &reaplist); 307836acb66bSBenny Halevy } 307936acb66bSBenny Halevy spin_unlock(&client_lock); 308036acb66bSBenny Halevy list_for_each_safe(pos, next, &reaplist) { 308136acb66bSBenny Halevy clp = list_entry(pos, struct nfs4_client, cl_lru); 30821da177e4SLinus Torvalds dprintk("NFSD: purging unused client (clientid %08x)\n", 30831da177e4SLinus Torvalds clp->cl_clientid.cl_id); 3084c7b9a459SNeilBrown nfsd4_remove_clid_dir(clp); 30851da177e4SLinus Torvalds expire_client(clp); 30861da177e4SLinus Torvalds } 30871da177e4SLinus Torvalds spin_lock(&recall_lock); 30881da177e4SLinus Torvalds list_for_each_safe(pos, next, &del_recall_lru) { 30891da177e4SLinus Torvalds dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru); 30901da177e4SLinus Torvalds if (time_after((unsigned long)dp->dl_time, (unsigned long)cutoff)) { 30911da177e4SLinus Torvalds u = dp->dl_time - cutoff; 30921da177e4SLinus Torvalds if (test_val > u) 30931da177e4SLinus Torvalds test_val = u; 30941da177e4SLinus Torvalds break; 30951da177e4SLinus Torvalds } 30961da177e4SLinus Torvalds list_move(&dp->dl_recall_lru, &reaplist); 30971da177e4SLinus Torvalds } 30981da177e4SLinus Torvalds spin_unlock(&recall_lock); 30991da177e4SLinus Torvalds list_for_each_safe(pos, next, &reaplist) { 31001da177e4SLinus Torvalds dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru); 31011da177e4SLinus Torvalds list_del_init(&dp->dl_recall_lru); 31021da177e4SLinus Torvalds unhash_delegation(dp); 31031da177e4SLinus Torvalds } 3104cf07d2eaSJ. Bruce Fields test_val = nfsd4_lease; 31051da177e4SLinus Torvalds list_for_each_safe(pos, next, &close_lru) { 3106fe0750e5SJ. Bruce Fields oo = container_of(pos, struct nfs4_openowner, oo_close_lru); 3107fe0750e5SJ. Bruce Fields if (time_after((unsigned long)oo->oo_time, (unsigned long)cutoff)) { 3108fe0750e5SJ. Bruce Fields u = oo->oo_time - cutoff; 31091da177e4SLinus Torvalds if (test_val > u) 31101da177e4SLinus Torvalds test_val = u; 31111da177e4SLinus Torvalds break; 31121da177e4SLinus Torvalds } 31131da177e4SLinus Torvalds dprintk("NFSD: purging unused open stateowner (so_id %d)\n", 3114fe0750e5SJ. Bruce Fields oo->oo_owner.so_id); 3115fe0750e5SJ. Bruce Fields release_openowner(oo); 31161da177e4SLinus Torvalds } 31171da177e4SLinus Torvalds if (clientid_val < NFSD_LAUNDROMAT_MINTIMEOUT) 31181da177e4SLinus Torvalds clientid_val = NFSD_LAUNDROMAT_MINTIMEOUT; 31191da177e4SLinus Torvalds nfs4_unlock_state(); 31201da177e4SLinus Torvalds return clientid_val; 31211da177e4SLinus Torvalds } 31221da177e4SLinus Torvalds 3123a254b246SHarvey Harrison static struct workqueue_struct *laundry_wq; 3124a254b246SHarvey Harrison static void laundromat_main(struct work_struct *); 3125a254b246SHarvey Harrison static DECLARE_DELAYED_WORK(laundromat_work, laundromat_main); 3126a254b246SHarvey Harrison 3127a254b246SHarvey Harrison static void 3128c4028958SDavid Howells laundromat_main(struct work_struct *not_used) 31291da177e4SLinus Torvalds { 31301da177e4SLinus Torvalds time_t t; 31311da177e4SLinus Torvalds 31321da177e4SLinus Torvalds t = nfs4_laundromat(); 31331da177e4SLinus Torvalds dprintk("NFSD: laundromat_main - sleeping for %ld seconds\n", t); 313458da282bSNeilBrown queue_delayed_work(laundry_wq, &laundromat_work, t*HZ); 31351da177e4SLinus Torvalds } 31361da177e4SLinus Torvalds 3137fe0750e5SJ. Bruce Fields static struct nfs4_openowner * search_close_lru(u32 st_id) 3138f8816512SNeilBrown { 3139fe0750e5SJ. Bruce Fields struct nfs4_openowner *local; 31401da177e4SLinus Torvalds 3141fe0750e5SJ. Bruce Fields list_for_each_entry(local, &close_lru, oo_close_lru) { 3142fe0750e5SJ. Bruce Fields if (local->oo_owner.so_id == st_id) 31431da177e4SLinus Torvalds return local; 31441da177e4SLinus Torvalds } 31451da177e4SLinus Torvalds return NULL; 31461da177e4SLinus Torvalds } 31471da177e4SLinus Torvalds 31481da177e4SLinus Torvalds static inline int 3149dcef0413SJ. Bruce Fields nfs4_check_fh(struct svc_fh *fhp, struct nfs4_ol_stateid *stp) 31501da177e4SLinus Torvalds { 3151f9d7562fSJ. Bruce Fields return fhp->fh_dentry->d_inode != stp->st_file->fi_inode; 31521da177e4SLinus Torvalds } 31531da177e4SLinus Torvalds 31541da177e4SLinus Torvalds static int 31551da177e4SLinus Torvalds STALE_STATEID(stateid_t *stateid) 31561da177e4SLinus Torvalds { 3157e4e83ea4SJ. Bruce Fields if (stateid->si_boot == boot_time) 3158e4e83ea4SJ. Bruce Fields return 0; 31598c10cbdbSBenny Halevy dprintk("NFSD: stale stateid " STATEID_FMT "!\n", 31608c10cbdbSBenny Halevy STATEID_VAL(stateid)); 31611da177e4SLinus Torvalds return 1; 31621da177e4SLinus Torvalds } 31631da177e4SLinus Torvalds 31641da177e4SLinus Torvalds static inline int 31651da177e4SLinus Torvalds access_permit_read(unsigned long access_bmap) 31661da177e4SLinus Torvalds { 31671da177e4SLinus Torvalds return test_bit(NFS4_SHARE_ACCESS_READ, &access_bmap) || 31681da177e4SLinus Torvalds test_bit(NFS4_SHARE_ACCESS_BOTH, &access_bmap) || 31691da177e4SLinus Torvalds test_bit(NFS4_SHARE_ACCESS_WRITE, &access_bmap); 31701da177e4SLinus Torvalds } 31711da177e4SLinus Torvalds 31721da177e4SLinus Torvalds static inline int 31731da177e4SLinus Torvalds access_permit_write(unsigned long access_bmap) 31741da177e4SLinus Torvalds { 31751da177e4SLinus Torvalds return test_bit(NFS4_SHARE_ACCESS_WRITE, &access_bmap) || 31761da177e4SLinus Torvalds test_bit(NFS4_SHARE_ACCESS_BOTH, &access_bmap); 31771da177e4SLinus Torvalds } 31781da177e4SLinus Torvalds 31791da177e4SLinus Torvalds static 3180dcef0413SJ. Bruce Fields __be32 nfs4_check_openmode(struct nfs4_ol_stateid *stp, int flags) 31811da177e4SLinus Torvalds { 3182b37ad28bSAl Viro __be32 status = nfserr_openmode; 31831da177e4SLinus Torvalds 318402921914SJ. Bruce Fields /* For lock stateid's, we test the parent open, not the lock: */ 318502921914SJ. Bruce Fields if (stp->st_openstp) 318602921914SJ. Bruce Fields stp = stp->st_openstp; 31871da177e4SLinus Torvalds if ((flags & WR_STATE) && (!access_permit_write(stp->st_access_bmap))) 31881da177e4SLinus Torvalds goto out; 31891da177e4SLinus Torvalds if ((flags & RD_STATE) && (!access_permit_read(stp->st_access_bmap))) 31901da177e4SLinus Torvalds goto out; 31911da177e4SLinus Torvalds status = nfs_ok; 31921da177e4SLinus Torvalds out: 31931da177e4SLinus Torvalds return status; 31941da177e4SLinus Torvalds } 31951da177e4SLinus Torvalds 3196b37ad28bSAl Viro static inline __be32 31971da177e4SLinus Torvalds check_special_stateids(svc_fh *current_fh, stateid_t *stateid, int flags) 31981da177e4SLinus Torvalds { 3199203a8c8eSJ. Bruce Fields if (ONE_STATEID(stateid) && (flags & RD_STATE)) 32001da177e4SLinus Torvalds return nfs_ok; 3201af558e33SJ. Bruce Fields else if (locks_in_grace()) { 320225985edcSLucas De Marchi /* Answer in remaining cases depends on existence of 32031da177e4SLinus Torvalds * conflicting state; so we must wait out the grace period. */ 32041da177e4SLinus Torvalds return nfserr_grace; 32051da177e4SLinus Torvalds } else if (flags & WR_STATE) 32061da177e4SLinus Torvalds return nfs4_share_conflict(current_fh, 32071da177e4SLinus Torvalds NFS4_SHARE_DENY_WRITE); 32081da177e4SLinus Torvalds else /* (flags & RD_STATE) && ZERO_STATEID(stateid) */ 32091da177e4SLinus Torvalds return nfs4_share_conflict(current_fh, 32101da177e4SLinus Torvalds NFS4_SHARE_DENY_READ); 32111da177e4SLinus Torvalds } 32121da177e4SLinus Torvalds 32131da177e4SLinus Torvalds /* 32141da177e4SLinus Torvalds * Allow READ/WRITE during grace period on recovered state only for files 32151da177e4SLinus Torvalds * that are not able to provide mandatory locking. 32161da177e4SLinus Torvalds */ 32171da177e4SLinus Torvalds static inline int 321818f82731SJ. Bruce Fields grace_disallows_io(struct inode *inode) 32191da177e4SLinus Torvalds { 3220203a8c8eSJ. Bruce Fields return locks_in_grace() && mandatory_lock(inode); 32211da177e4SLinus Torvalds } 32221da177e4SLinus Torvalds 322381b82965SJ. Bruce Fields /* Returns true iff a is later than b: */ 322481b82965SJ. Bruce Fields static bool stateid_generation_after(stateid_t *a, stateid_t *b) 322581b82965SJ. Bruce Fields { 322681b82965SJ. Bruce Fields return (s32)a->si_generation - (s32)b->si_generation > 0; 322781b82965SJ. Bruce Fields } 322881b82965SJ. Bruce Fields 322928dde241SJ. Bruce Fields static int check_stateid_generation(stateid_t *in, stateid_t *ref, bool has_session) 32300836f587SJ. Bruce Fields { 32316668958fSAndy Adamson /* 32326668958fSAndy Adamson * When sessions are used the stateid generation number is ignored 32336668958fSAndy Adamson * when it is zero. 32346668958fSAndy Adamson */ 323528dde241SJ. Bruce Fields if (has_session && in->si_generation == 0) 323681b82965SJ. Bruce Fields return nfs_ok; 323781b82965SJ. Bruce Fields 323881b82965SJ. Bruce Fields if (in->si_generation == ref->si_generation) 323981b82965SJ. Bruce Fields return nfs_ok; 32406668958fSAndy Adamson 32410836f587SJ. Bruce Fields /* If the client sends us a stateid from the future, it's buggy: */ 324281b82965SJ. Bruce Fields if (stateid_generation_after(in, ref)) 32430836f587SJ. Bruce Fields return nfserr_bad_stateid; 32440836f587SJ. Bruce Fields /* 324581b82965SJ. Bruce Fields * However, we could see a stateid from the past, even from a 324681b82965SJ. Bruce Fields * non-buggy client. For example, if the client sends a lock 324781b82965SJ. Bruce Fields * while some IO is outstanding, the lock may bump si_generation 324881b82965SJ. Bruce Fields * while the IO is still in flight. The client could avoid that 324981b82965SJ. Bruce Fields * situation by waiting for responses on all the IO requests, 325081b82965SJ. Bruce Fields * but better performance may result in retrying IO that 325181b82965SJ. Bruce Fields * receives an old_stateid error if requests are rarely 325281b82965SJ. Bruce Fields * reordered in flight: 32530836f587SJ. Bruce Fields */ 32540836f587SJ. Bruce Fields return nfserr_old_stateid; 32550836f587SJ. Bruce Fields } 32560836f587SJ. Bruce Fields 32573e633079SJ. Bruce Fields static int is_delegation_stateid(stateid_t *stateid) 32583e633079SJ. Bruce Fields { 32593e633079SJ. Bruce Fields return stateid->si_fileid == 0; 32603e633079SJ. Bruce Fields } 32613e633079SJ. Bruce Fields 326228dde241SJ. Bruce Fields __be32 nfs4_validate_stateid(stateid_t *stateid, bool has_session) 326317456804SBryan Schumaker { 326497b7e3b6SJ. Bruce Fields struct nfs4_stid *s; 326597b7e3b6SJ. Bruce Fields struct nfs4_ol_stateid *ols; 326697b7e3b6SJ. Bruce Fields __be32 status; 326717456804SBryan Schumaker 326817456804SBryan Schumaker if (STALE_STATEID(stateid)) 326997b7e3b6SJ. Bruce Fields return nfserr_stale_stateid; 327017456804SBryan Schumaker 327197b7e3b6SJ. Bruce Fields s = find_stateid(stateid); 327297b7e3b6SJ. Bruce Fields if (!s) 327397b7e3b6SJ. Bruce Fields return nfserr_stale_stateid; 327497b7e3b6SJ. Bruce Fields status = check_stateid_generation(stateid, &s->sc_stateid, has_session); 327517456804SBryan Schumaker if (status) 327617456804SBryan Schumaker return status; 327797b7e3b6SJ. Bruce Fields if (!(s->sc_type & (NFS4_OPEN_STID | NFS4_LOCK_STID))) 327897b7e3b6SJ. Bruce Fields return nfs_ok; 327997b7e3b6SJ. Bruce Fields ols = openlockstateid(s); 328097b7e3b6SJ. Bruce Fields if (ols->st_stateowner->so_is_open_owner 328197b7e3b6SJ. Bruce Fields && !openowner(ols->st_stateowner)->oo_confirmed) 328297b7e3b6SJ. Bruce Fields return nfserr_bad_stateid; 328397b7e3b6SJ. Bruce Fields return nfs_ok; 328417456804SBryan Schumaker } 328517456804SBryan Schumaker 32861da177e4SLinus Torvalds /* 32871da177e4SLinus Torvalds * Checks for stateid operations 32881da177e4SLinus Torvalds */ 3289b37ad28bSAl Viro __be32 3290dd453dfdSBenny Halevy nfs4_preprocess_stateid_op(struct nfsd4_compound_state *cstate, 3291dd453dfdSBenny Halevy stateid_t *stateid, int flags, struct file **filpp) 32921da177e4SLinus Torvalds { 329369064a27SJ. Bruce Fields struct nfs4_stid *s; 3294dcef0413SJ. Bruce Fields struct nfs4_ol_stateid *stp = NULL; 32951da177e4SLinus Torvalds struct nfs4_delegation *dp = NULL; 3296dd453dfdSBenny Halevy struct svc_fh *current_fh = &cstate->current_fh; 32971da177e4SLinus Torvalds struct inode *ino = current_fh->fh_dentry->d_inode; 3298b37ad28bSAl Viro __be32 status; 32991da177e4SLinus Torvalds 33001da177e4SLinus Torvalds if (filpp) 33011da177e4SLinus Torvalds *filpp = NULL; 33021da177e4SLinus Torvalds 330318f82731SJ. Bruce Fields if (grace_disallows_io(ino)) 33041da177e4SLinus Torvalds return nfserr_grace; 33051da177e4SLinus Torvalds 33061da177e4SLinus Torvalds if (ZERO_STATEID(stateid) || ONE_STATEID(stateid)) 33071da177e4SLinus Torvalds return check_special_stateids(current_fh, stateid, flags); 33081da177e4SLinus Torvalds 33091da177e4SLinus Torvalds status = nfserr_stale_stateid; 33101da177e4SLinus Torvalds if (STALE_STATEID(stateid)) 33111da177e4SLinus Torvalds goto out; 33121da177e4SLinus Torvalds 331333515142SJ. Bruce Fields /* 331433515142SJ. Bruce Fields * We assume that any stateid that has the current boot time, 331533515142SJ. Bruce Fields * but that we can't find, is expired: 331633515142SJ. Bruce Fields */ 331733515142SJ. Bruce Fields status = nfserr_expired; 331869064a27SJ. Bruce Fields s = find_stateid(stateid); 331969064a27SJ. Bruce Fields if (!s) 33201da177e4SLinus Torvalds goto out; 332169064a27SJ. Bruce Fields status = check_stateid_generation(stateid, &s->sc_stateid, nfsd4_has_session(cstate)); 33220c2a498fSJ. Bruce Fields if (status) 33230c2a498fSJ. Bruce Fields goto out; 332469064a27SJ. Bruce Fields if (s->sc_type == NFS4_DELEG_STID) { 332569064a27SJ. Bruce Fields dp = delegstateid(s); 3326dc9bf700SJ. Bruce Fields status = nfs4_check_delegmode(dp, flags); 3327dc9bf700SJ. Bruce Fields if (status) 3328dc9bf700SJ. Bruce Fields goto out; 3329dc9bf700SJ. Bruce Fields renew_client(dp->dl_client); 333043b0178eSDan Carpenter if (filpp) { 3331acfdf5c3SJ. Bruce Fields *filpp = dp->dl_file->fi_deleg_file; 3332f9d7562fSJ. Bruce Fields BUG_ON(!*filpp); 333343b0178eSDan Carpenter } 33341da177e4SLinus Torvalds } else { /* open or lock stateid */ 333569064a27SJ. Bruce Fields stp = openlockstateid(s); 333633515142SJ. Bruce Fields status = nfserr_bad_stateid; 33376150ef0dSJ. Bruce Fields if (nfs4_check_fh(current_fh, stp)) 33381da177e4SLinus Torvalds goto out; 3339fe0750e5SJ. Bruce Fields if (stp->st_stateowner->so_is_open_owner 3340fe0750e5SJ. Bruce Fields && !openowner(stp->st_stateowner)->oo_confirmed) 33411da177e4SLinus Torvalds goto out; 3342a4455be0SJ. Bruce Fields status = nfs4_check_openmode(stp, flags); 3343a4455be0SJ. Bruce Fields if (status) 33441da177e4SLinus Torvalds goto out; 33451da177e4SLinus Torvalds renew_client(stp->st_stateowner->so_client); 3346f9d7562fSJ. Bruce Fields if (filpp) { 3347f9d7562fSJ. Bruce Fields if (flags & RD_STATE) 3348f9d7562fSJ. Bruce Fields *filpp = find_readable_file(stp->st_file); 3349f9d7562fSJ. Bruce Fields else 3350f9d7562fSJ. Bruce Fields *filpp = find_writeable_file(stp->st_file); 3351f9d7562fSJ. Bruce Fields } 33521da177e4SLinus Torvalds } 33531da177e4SLinus Torvalds status = nfs_ok; 33541da177e4SLinus Torvalds out: 33551da177e4SLinus Torvalds return status; 33561da177e4SLinus Torvalds } 33571da177e4SLinus Torvalds 3358e1ca12dfSBryan Schumaker static __be32 3359e1ca12dfSBryan Schumaker nfsd4_free_delegation_stateid(stateid_t *stateid) 3360e1ca12dfSBryan Schumaker { 3361f459e453SJ. Bruce Fields struct nfs4_delegation *dp = find_deleg_stateid(stateid); 3362e1ca12dfSBryan Schumaker if (dp) 3363e1ca12dfSBryan Schumaker return nfserr_locks_held; 3364f459e453SJ. Bruce Fields 3365e1ca12dfSBryan Schumaker return nfserr_bad_stateid; 3366e1ca12dfSBryan Schumaker } 3367e1ca12dfSBryan Schumaker 3368e1ca12dfSBryan Schumaker static __be32 3369dcef0413SJ. Bruce Fields nfsd4_free_lock_stateid(struct nfs4_ol_stateid *stp) 3370e1ca12dfSBryan Schumaker { 3371fe0750e5SJ. Bruce Fields if (check_for_locks(stp->st_file, lockowner(stp->st_stateowner))) 3372e1ca12dfSBryan Schumaker return nfserr_locks_held; 3373e1ca12dfSBryan Schumaker release_lock_stateid(stp); 3374e1ca12dfSBryan Schumaker return nfs_ok; 3375e1ca12dfSBryan Schumaker } 3376e1ca12dfSBryan Schumaker 3377e1ca12dfSBryan Schumaker /* 337817456804SBryan Schumaker * Test if the stateid is valid 337917456804SBryan Schumaker */ 338017456804SBryan Schumaker __be32 338117456804SBryan Schumaker nfsd4_test_stateid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 338217456804SBryan Schumaker struct nfsd4_test_stateid *test_stateid) 338317456804SBryan Schumaker { 338417456804SBryan Schumaker test_stateid->ts_has_session = nfsd4_has_session(cstate); 338517456804SBryan Schumaker return nfs_ok; 338617456804SBryan Schumaker } 338717456804SBryan Schumaker 338817456804SBryan Schumaker /* 3389e1ca12dfSBryan Schumaker * Free a state id 3390e1ca12dfSBryan Schumaker */ 3391e1ca12dfSBryan Schumaker __be32 3392e1ca12dfSBryan Schumaker nfsd4_free_stateid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 3393e1ca12dfSBryan Schumaker struct nfsd4_free_stateid *free_stateid) 3394e1ca12dfSBryan Schumaker { 3395e1ca12dfSBryan Schumaker stateid_t *stateid = &free_stateid->fr_stateid; 3396dcef0413SJ. Bruce Fields struct nfs4_ol_stateid *stp; 3397e1ca12dfSBryan Schumaker __be32 ret; 3398e1ca12dfSBryan Schumaker 3399e1ca12dfSBryan Schumaker nfs4_lock_state(); 3400e1ca12dfSBryan Schumaker if (is_delegation_stateid(stateid)) { 3401e1ca12dfSBryan Schumaker ret = nfsd4_free_delegation_stateid(stateid); 3402e1ca12dfSBryan Schumaker goto out; 3403e1ca12dfSBryan Schumaker } 3404e1ca12dfSBryan Schumaker 3405f459e453SJ. Bruce Fields stp = find_ol_stateid(stateid); 3406e1ca12dfSBryan Schumaker if (!stp) { 3407e1ca12dfSBryan Schumaker ret = nfserr_bad_stateid; 3408e1ca12dfSBryan Schumaker goto out; 3409e1ca12dfSBryan Schumaker } 3410dcef0413SJ. Bruce Fields ret = check_stateid_generation(stateid, &stp->st_stid.sc_stateid, 1); 341181b82965SJ. Bruce Fields if (ret) 3412e1ca12dfSBryan Schumaker goto out; 3413e1ca12dfSBryan Schumaker 3414dcef0413SJ. Bruce Fields if (stp->st_stid.sc_type == NFS4_OPEN_STID) { 3415e1ca12dfSBryan Schumaker ret = nfserr_locks_held; 3416e1ca12dfSBryan Schumaker goto out; 3417e1ca12dfSBryan Schumaker } else { 3418e1ca12dfSBryan Schumaker ret = nfsd4_free_lock_stateid(stp); 3419e1ca12dfSBryan Schumaker goto out; 3420e1ca12dfSBryan Schumaker } 3421e1ca12dfSBryan Schumaker 3422e1ca12dfSBryan Schumaker out: 3423e1ca12dfSBryan Schumaker nfs4_unlock_state(); 3424e1ca12dfSBryan Schumaker return ret; 3425e1ca12dfSBryan Schumaker } 3426e1ca12dfSBryan Schumaker 34274c4cd222SNeilBrown static inline int 34284c4cd222SNeilBrown setlkflg (int type) 34294c4cd222SNeilBrown { 34304c4cd222SNeilBrown return (type == NFS4_READW_LT || type == NFS4_READ_LT) ? 34314c4cd222SNeilBrown RD_STATE : WR_STATE; 34324c4cd222SNeilBrown } 34331da177e4SLinus Torvalds 3434c0a5d93eSJ. Bruce Fields static __be32 nfs4_nospecial_stateid_checks(stateid_t *stateid) 3435c0a5d93eSJ. Bruce Fields { 3436c0a5d93eSJ. Bruce Fields if (ZERO_STATEID(stateid) || ONE_STATEID(stateid)) 3437c0a5d93eSJ. Bruce Fields return nfserr_bad_stateid; 3438c0a5d93eSJ. Bruce Fields if (STALE_STATEID(stateid)) 3439c0a5d93eSJ. Bruce Fields return nfserr_stale_stateid; 3440c0a5d93eSJ. Bruce Fields return nfs_ok; 3441c0a5d93eSJ. Bruce Fields } 3442c0a5d93eSJ. Bruce Fields 3443dcef0413SJ. Bruce Fields static __be32 nfs4_seqid_op_checks(struct nfsd4_compound_state *cstate, stateid_t *stateid, u32 seqid, struct nfs4_ol_stateid *stp) 3444c0a5d93eSJ. Bruce Fields { 3445c0a5d93eSJ. Bruce Fields struct svc_fh *current_fh = &cstate->current_fh; 3446c0a5d93eSJ. Bruce Fields struct nfs4_stateowner *sop = stp->st_stateowner; 3447c0a5d93eSJ. Bruce Fields __be32 status; 3448c0a5d93eSJ. Bruce Fields 3449c0a5d93eSJ. Bruce Fields if (nfs4_check_fh(current_fh, stp)) 3450c0a5d93eSJ. Bruce Fields return nfserr_bad_stateid; 3451c0a5d93eSJ. Bruce Fields status = nfsd4_check_seqid(cstate, sop, seqid); 3452c0a5d93eSJ. Bruce Fields if (status) 3453c0a5d93eSJ. Bruce Fields return status; 3454dcef0413SJ. Bruce Fields return check_stateid_generation(stateid, &stp->st_stid.sc_stateid, nfsd4_has_session(cstate)); 3455c0a5d93eSJ. Bruce Fields } 3456c0a5d93eSJ. Bruce Fields 34571da177e4SLinus Torvalds /* 34581da177e4SLinus Torvalds * Checks for sequence id mutating operations. 34591da177e4SLinus Torvalds */ 3460b37ad28bSAl Viro static __be32 3461dd453dfdSBenny Halevy nfs4_preprocess_seqid_op(struct nfsd4_compound_state *cstate, u32 seqid, 34622288d0e3SJ. Bruce Fields stateid_t *stateid, char typemask, 3463dcef0413SJ. Bruce Fields struct nfs4_ol_stateid **stpp) 34641da177e4SLinus Torvalds { 34650836f587SJ. Bruce Fields __be32 status; 34661da177e4SLinus Torvalds 34678c10cbdbSBenny Halevy dprintk("NFSD: %s: seqid=%d stateid = " STATEID_FMT "\n", __func__, 34688c10cbdbSBenny Halevy seqid, STATEID_VAL(stateid)); 34691da177e4SLinus Torvalds 34701da177e4SLinus Torvalds *stpp = NULL; 3471c0a5d93eSJ. Bruce Fields status = nfs4_nospecial_stateid_checks(stateid); 3472c0a5d93eSJ. Bruce Fields if (status) 3473c0a5d93eSJ. Bruce Fields return status; 3474f459e453SJ. Bruce Fields *stpp = find_ol_stateid_by_type(stateid, typemask); 3475f4dee24cSJ. Bruce Fields if (*stpp == NULL) 347633515142SJ. Bruce Fields return nfserr_expired; 3477c0a5d93eSJ. Bruce Fields cstate->replay_owner = (*stpp)->st_stateowner; 3478c0a5d93eSJ. Bruce Fields renew_client((*stpp)->st_stateowner->so_client); 34791da177e4SLinus Torvalds 3480c0a5d93eSJ. Bruce Fields return nfs4_seqid_op_checks(cstate, stateid, seqid, *stpp); 34811da177e4SLinus Torvalds } 34821da177e4SLinus Torvalds 3483dcef0413SJ. Bruce Fields static __be32 nfs4_preprocess_confirmed_seqid_op(struct nfsd4_compound_state *cstate, u32 seqid, stateid_t *stateid, struct nfs4_ol_stateid **stpp) 3484c0a5d93eSJ. Bruce Fields { 3485c0a5d93eSJ. Bruce Fields __be32 status; 3486c0a5d93eSJ. Bruce Fields struct nfs4_openowner *oo; 34871da177e4SLinus Torvalds 3488c0a5d93eSJ. Bruce Fields status = nfs4_preprocess_seqid_op(cstate, seqid, stateid, 34892288d0e3SJ. Bruce Fields NFS4_OPEN_STID, stpp); 34900836f587SJ. Bruce Fields if (status) 34910836f587SJ. Bruce Fields return status; 3492c0a5d93eSJ. Bruce Fields oo = openowner((*stpp)->st_stateowner); 3493c0a5d93eSJ. Bruce Fields if (!oo->oo_confirmed) 3494c0a5d93eSJ. Bruce Fields return nfserr_bad_stateid; 34953a4f98bbSNeilBrown return nfs_ok; 34961da177e4SLinus Torvalds } 34971da177e4SLinus Torvalds 3498b37ad28bSAl Viro __be32 3499ca364317SJ.Bruce Fields nfsd4_open_confirm(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 3500a4f1706aSJ.Bruce Fields struct nfsd4_open_confirm *oc) 35011da177e4SLinus Torvalds { 3502b37ad28bSAl Viro __be32 status; 3503fe0750e5SJ. Bruce Fields struct nfs4_openowner *oo; 3504dcef0413SJ. Bruce Fields struct nfs4_ol_stateid *stp; 35051da177e4SLinus Torvalds 35061da177e4SLinus Torvalds dprintk("NFSD: nfsd4_open_confirm on file %.*s\n", 3507ca364317SJ.Bruce Fields (int)cstate->current_fh.fh_dentry->d_name.len, 3508ca364317SJ.Bruce Fields cstate->current_fh.fh_dentry->d_name.name); 35091da177e4SLinus Torvalds 3510ca364317SJ.Bruce Fields status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0); 3511a8cddc5dSJ. Bruce Fields if (status) 3512a8cddc5dSJ. Bruce Fields return status; 35131da177e4SLinus Torvalds 35141da177e4SLinus Torvalds nfs4_lock_state(); 35151da177e4SLinus Torvalds 35169072d5c6SJ. Bruce Fields status = nfs4_preprocess_seqid_op(cstate, 3517ca364317SJ.Bruce Fields oc->oc_seqid, &oc->oc_req_stateid, 35182288d0e3SJ. Bruce Fields NFS4_OPEN_STID, &stp); 35199072d5c6SJ. Bruce Fields if (status) 35201da177e4SLinus Torvalds goto out; 3521fe0750e5SJ. Bruce Fields oo = openowner(stp->st_stateowner); 352268b66e82SJ. Bruce Fields status = nfserr_bad_stateid; 3523fe0750e5SJ. Bruce Fields if (oo->oo_confirmed) 352468b66e82SJ. Bruce Fields goto out; 3525fe0750e5SJ. Bruce Fields oo->oo_confirmed = 1; 3526dcef0413SJ. Bruce Fields update_stateid(&stp->st_stid.sc_stateid); 3527dcef0413SJ. Bruce Fields memcpy(&oc->oc_resp_stateid, &stp->st_stid.sc_stateid, sizeof(stateid_t)); 35288c10cbdbSBenny Halevy dprintk("NFSD: %s: success, seqid=%d stateid=" STATEID_FMT "\n", 3529dcef0413SJ. Bruce Fields __func__, oc->oc_seqid, STATEID_VAL(&stp->st_stid.sc_stateid)); 3530c7b9a459SNeilBrown 3531fe0750e5SJ. Bruce Fields nfsd4_create_clid_dir(oo->oo_owner.so_client); 353268b66e82SJ. Bruce Fields status = nfs_ok; 35331da177e4SLinus Torvalds out: 35345ec094c1SJ. Bruce Fields if (!cstate->replay_owner) 35351da177e4SLinus Torvalds nfs4_unlock_state(); 35361da177e4SLinus Torvalds return status; 35371da177e4SLinus Torvalds } 35381da177e4SLinus Torvalds 3539dcef0413SJ. Bruce Fields static inline void nfs4_file_downgrade(struct nfs4_ol_stateid *stp, unsigned int to_access) 35401da177e4SLinus Torvalds { 35411da177e4SLinus Torvalds int i; 3542f197c271SJ. Bruce Fields 35431da177e4SLinus Torvalds for (i = 1; i < 4; i++) { 3544f197c271SJ. Bruce Fields if (test_bit(i, &stp->st_access_bmap) && !(i & to_access)) { 3545f197c271SJ. Bruce Fields nfs4_file_put_access(stp->st_file, i); 3546f197c271SJ. Bruce Fields __clear_bit(i, &stp->st_access_bmap); 3547f197c271SJ. Bruce Fields } 35481da177e4SLinus Torvalds } 35491da177e4SLinus Torvalds } 35501da177e4SLinus Torvalds 35511da177e4SLinus Torvalds static void 35521da177e4SLinus Torvalds reset_union_bmap_deny(unsigned long deny, unsigned long *bmap) 35531da177e4SLinus Torvalds { 35541da177e4SLinus Torvalds int i; 35551da177e4SLinus Torvalds for (i = 0; i < 4; i++) { 35561da177e4SLinus Torvalds if ((i & deny) != i) 35571da177e4SLinus Torvalds __clear_bit(i, bmap); 35581da177e4SLinus Torvalds } 35591da177e4SLinus Torvalds } 35601da177e4SLinus Torvalds 3561b37ad28bSAl Viro __be32 3562ca364317SJ.Bruce Fields nfsd4_open_downgrade(struct svc_rqst *rqstp, 3563ca364317SJ.Bruce Fields struct nfsd4_compound_state *cstate, 3564a4f1706aSJ.Bruce Fields struct nfsd4_open_downgrade *od) 35651da177e4SLinus Torvalds { 3566b37ad28bSAl Viro __be32 status; 3567dcef0413SJ. Bruce Fields struct nfs4_ol_stateid *stp; 35681da177e4SLinus Torvalds 35691da177e4SLinus Torvalds dprintk("NFSD: nfsd4_open_downgrade on file %.*s\n", 3570ca364317SJ.Bruce Fields (int)cstate->current_fh.fh_dentry->d_name.len, 3571ca364317SJ.Bruce Fields cstate->current_fh.fh_dentry->d_name.name); 35721da177e4SLinus Torvalds 3573d87a8adeSAndy Adamson if (!access_valid(od->od_share_access, cstate->minorversion) 3574ba5a6a19SJ. Bruce Fields || !deny_valid(od->od_share_deny)) 35751da177e4SLinus Torvalds return nfserr_inval; 35761da177e4SLinus Torvalds 35771da177e4SLinus Torvalds nfs4_lock_state(); 3578c0a5d93eSJ. Bruce Fields status = nfs4_preprocess_confirmed_seqid_op(cstate, od->od_seqid, 3579c0a5d93eSJ. Bruce Fields &od->od_stateid, &stp); 35809072d5c6SJ. Bruce Fields if (status) 35811da177e4SLinus Torvalds goto out; 35821da177e4SLinus Torvalds status = nfserr_inval; 35831da177e4SLinus Torvalds if (!test_bit(od->od_share_access, &stp->st_access_bmap)) { 35841da177e4SLinus Torvalds dprintk("NFSD:access not a subset current bitmap: 0x%lx, input access=%08x\n", 35851da177e4SLinus Torvalds stp->st_access_bmap, od->od_share_access); 35861da177e4SLinus Torvalds goto out; 35871da177e4SLinus Torvalds } 35881da177e4SLinus Torvalds if (!test_bit(od->od_share_deny, &stp->st_deny_bmap)) { 35891da177e4SLinus Torvalds dprintk("NFSD:deny not a subset current bitmap: 0x%lx, input deny=%08x\n", 35901da177e4SLinus Torvalds stp->st_deny_bmap, od->od_share_deny); 35911da177e4SLinus Torvalds goto out; 35921da177e4SLinus Torvalds } 3593f197c271SJ. Bruce Fields nfs4_file_downgrade(stp, od->od_share_access); 35941da177e4SLinus Torvalds 35951da177e4SLinus Torvalds reset_union_bmap_deny(od->od_share_deny, &stp->st_deny_bmap); 35961da177e4SLinus Torvalds 3597dcef0413SJ. Bruce Fields update_stateid(&stp->st_stid.sc_stateid); 3598dcef0413SJ. Bruce Fields memcpy(&od->od_stateid, &stp->st_stid.sc_stateid, sizeof(stateid_t)); 35991da177e4SLinus Torvalds status = nfs_ok; 36001da177e4SLinus Torvalds out: 36015ec094c1SJ. Bruce Fields if (!cstate->replay_owner) 36021da177e4SLinus Torvalds nfs4_unlock_state(); 36031da177e4SLinus Torvalds return status; 36041da177e4SLinus Torvalds } 36051da177e4SLinus Torvalds 36061da177e4SLinus Torvalds /* 36071da177e4SLinus Torvalds * nfs4_unlock_state() called after encode 36081da177e4SLinus Torvalds */ 3609b37ad28bSAl Viro __be32 3610ca364317SJ.Bruce Fields nfsd4_close(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 3611a4f1706aSJ.Bruce Fields struct nfsd4_close *close) 36121da177e4SLinus Torvalds { 3613b37ad28bSAl Viro __be32 status; 3614fe0750e5SJ. Bruce Fields struct nfs4_openowner *oo; 3615dcef0413SJ. Bruce Fields struct nfs4_ol_stateid *stp; 36161da177e4SLinus Torvalds 36171da177e4SLinus Torvalds dprintk("NFSD: nfsd4_close on file %.*s\n", 3618ca364317SJ.Bruce Fields (int)cstate->current_fh.fh_dentry->d_name.len, 3619ca364317SJ.Bruce Fields cstate->current_fh.fh_dentry->d_name.name); 36201da177e4SLinus Torvalds 36211da177e4SLinus Torvalds nfs4_lock_state(); 36221da177e4SLinus Torvalds /* check close_lru for replay */ 3623c0a5d93eSJ. Bruce Fields status = nfs4_preprocess_confirmed_seqid_op(cstate, close->cl_seqid, 3624c0a5d93eSJ. Bruce Fields &close->cl_stateid, &stp); 3625f4dee24cSJ. Bruce Fields if (stp == NULL && status == nfserr_expired) { 3626f4dee24cSJ. Bruce Fields /* 3627f4dee24cSJ. Bruce Fields * Also, we should make sure this isn't just the result of 3628f4dee24cSJ. Bruce Fields * a replayed close: 3629f4dee24cSJ. Bruce Fields */ 3630fe0750e5SJ. Bruce Fields oo = search_close_lru(close->cl_stateid.si_stateownerid); 3631f4dee24cSJ. Bruce Fields /* It's not stale; let's assume it's expired: */ 3632fe0750e5SJ. Bruce Fields if (oo == NULL) 3633f4dee24cSJ. Bruce Fields goto out; 3634fe0750e5SJ. Bruce Fields cstate->replay_owner = &oo->oo_owner; 3635fe0750e5SJ. Bruce Fields status = nfsd4_check_seqid(cstate, &oo->oo_owner, close->cl_seqid); 3636f4dee24cSJ. Bruce Fields if (status) 3637f4dee24cSJ. Bruce Fields goto out; 3638f4dee24cSJ. Bruce Fields status = nfserr_bad_seqid; 3639f4dee24cSJ. Bruce Fields } 36409072d5c6SJ. Bruce Fields if (status) 36411da177e4SLinus Torvalds goto out; 3642fe0750e5SJ. Bruce Fields oo = openowner(stp->st_stateowner); 36431da177e4SLinus Torvalds status = nfs_ok; 3644dcef0413SJ. Bruce Fields update_stateid(&stp->st_stid.sc_stateid); 3645dcef0413SJ. Bruce Fields memcpy(&close->cl_stateid, &stp->st_stid.sc_stateid, sizeof(stateid_t)); 36461da177e4SLinus Torvalds 364704ef5954SJ. Bruce Fields /* release_stateid() calls nfsd_close() if needed */ 36482283963fSJ. Bruce Fields release_open_stateid(stp); 364904ef5954SJ. Bruce Fields 365004ef5954SJ. Bruce Fields /* place unused nfs4_stateowners on so_close_lru list to be 365104ef5954SJ. Bruce Fields * released by the laundromat service after the lease period 365204ef5954SJ. Bruce Fields * to enable us to handle CLOSE replay 365304ef5954SJ. Bruce Fields */ 3654fe0750e5SJ. Bruce Fields if (list_empty(&oo->oo_owner.so_stateids)) 3655fe0750e5SJ. Bruce Fields move_to_close_lru(oo); 36561da177e4SLinus Torvalds out: 36575ec094c1SJ. Bruce Fields if (!cstate->replay_owner) 36581da177e4SLinus Torvalds nfs4_unlock_state(); 36591da177e4SLinus Torvalds return status; 36601da177e4SLinus Torvalds } 36611da177e4SLinus Torvalds 3662b37ad28bSAl Viro __be32 3663ca364317SJ.Bruce Fields nfsd4_delegreturn(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 3664ca364317SJ.Bruce Fields struct nfsd4_delegreturn *dr) 36651da177e4SLinus Torvalds { 3666203a8c8eSJ. Bruce Fields struct nfs4_delegation *dp; 3667203a8c8eSJ. Bruce Fields stateid_t *stateid = &dr->dr_stateid; 3668203a8c8eSJ. Bruce Fields struct inode *inode; 3669b37ad28bSAl Viro __be32 status; 36701da177e4SLinus Torvalds 3671ca364317SJ.Bruce Fields if ((status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0))) 3672203a8c8eSJ. Bruce Fields return status; 3673203a8c8eSJ. Bruce Fields inode = cstate->current_fh.fh_dentry->d_inode; 36741da177e4SLinus Torvalds 36751da177e4SLinus Torvalds nfs4_lock_state(); 3676203a8c8eSJ. Bruce Fields status = nfserr_bad_stateid; 3677203a8c8eSJ. Bruce Fields if (ZERO_STATEID(stateid) || ONE_STATEID(stateid)) 3678203a8c8eSJ. Bruce Fields goto out; 3679203a8c8eSJ. Bruce Fields status = nfserr_stale_stateid; 3680203a8c8eSJ. Bruce Fields if (STALE_STATEID(stateid)) 3681203a8c8eSJ. Bruce Fields goto out; 36827e0f7cf5SJ. Bruce Fields status = nfserr_bad_stateid; 3683203a8c8eSJ. Bruce Fields if (!is_delegation_stateid(stateid)) 3684203a8c8eSJ. Bruce Fields goto out; 368533515142SJ. Bruce Fields status = nfserr_expired; 3686f459e453SJ. Bruce Fields dp = find_deleg_stateid(stateid); 3687e4e83ea4SJ. Bruce Fields if (!dp) 3688203a8c8eSJ. Bruce Fields goto out; 3689d5477a8dSJ. Bruce Fields status = check_stateid_generation(stateid, &dp->dl_stid.sc_stateid, nfsd4_has_session(cstate)); 3690203a8c8eSJ. Bruce Fields if (status) 3691203a8c8eSJ. Bruce Fields goto out; 3692203a8c8eSJ. Bruce Fields renew_client(dp->dl_client); 3693203a8c8eSJ. Bruce Fields 3694203a8c8eSJ. Bruce Fields unhash_delegation(dp); 36951da177e4SLinus Torvalds out: 3696203a8c8eSJ. Bruce Fields nfs4_unlock_state(); 3697203a8c8eSJ. Bruce Fields 36981da177e4SLinus Torvalds return status; 36991da177e4SLinus Torvalds } 37001da177e4SLinus Torvalds 37011da177e4SLinus Torvalds 37021da177e4SLinus Torvalds /* 37031da177e4SLinus Torvalds * Lock owner state (byte-range locks) 37041da177e4SLinus Torvalds */ 37051da177e4SLinus Torvalds #define LOFF_OVERFLOW(start, len) ((u64)(len) > ~(u64)(start)) 37061da177e4SLinus Torvalds #define LOCK_HASH_BITS 8 37071da177e4SLinus Torvalds #define LOCK_HASH_SIZE (1 << LOCK_HASH_BITS) 37081da177e4SLinus Torvalds #define LOCK_HASH_MASK (LOCK_HASH_SIZE - 1) 37091da177e4SLinus Torvalds 371087df4de8SBenny Halevy static inline u64 371187df4de8SBenny Halevy end_offset(u64 start, u64 len) 371287df4de8SBenny Halevy { 371387df4de8SBenny Halevy u64 end; 371487df4de8SBenny Halevy 371587df4de8SBenny Halevy end = start + len; 371687df4de8SBenny Halevy return end >= start ? end: NFS4_MAX_UINT64; 371787df4de8SBenny Halevy } 371887df4de8SBenny Halevy 371987df4de8SBenny Halevy /* last octet in a range */ 372087df4de8SBenny Halevy static inline u64 372187df4de8SBenny Halevy last_byte_offset(u64 start, u64 len) 372287df4de8SBenny Halevy { 372387df4de8SBenny Halevy u64 end; 372487df4de8SBenny Halevy 372587df4de8SBenny Halevy BUG_ON(!len); 372687df4de8SBenny Halevy end = start + len; 372787df4de8SBenny Halevy return end > start ? end - 1: NFS4_MAX_UINT64; 372887df4de8SBenny Halevy } 372987df4de8SBenny Halevy 3730ddc04c41SJ. Bruce Fields static unsigned int lockownerid_hashval(u32 id) 3731ddc04c41SJ. Bruce Fields { 3732ddc04c41SJ. Bruce Fields return id & LOCK_HASH_MASK; 3733ddc04c41SJ. Bruce Fields } 37341da177e4SLinus Torvalds 37351da177e4SLinus Torvalds static inline unsigned int 37361da177e4SLinus Torvalds lock_ownerstr_hashval(struct inode *inode, u32 cl_id, 37371da177e4SLinus Torvalds struct xdr_netobj *ownername) 37381da177e4SLinus Torvalds { 37391da177e4SLinus Torvalds return (file_hashval(inode) + cl_id 37401da177e4SLinus Torvalds + opaque_hashval(ownername->data, ownername->len)) 37411da177e4SLinus Torvalds & LOCK_HASH_MASK; 37421da177e4SLinus Torvalds } 37431da177e4SLinus Torvalds 37441da177e4SLinus Torvalds static struct list_head lock_ownerid_hashtbl[LOCK_HASH_SIZE]; 37451da177e4SLinus Torvalds static struct list_head lock_ownerstr_hashtbl[LOCK_HASH_SIZE]; 37461da177e4SLinus Torvalds 37471da177e4SLinus Torvalds /* 37481da177e4SLinus Torvalds * TODO: Linux file offsets are _signed_ 64-bit quantities, which means that 37491da177e4SLinus Torvalds * we can't properly handle lock requests that go beyond the (2^63 - 1)-th 37501da177e4SLinus Torvalds * byte, because of sign extension problems. Since NFSv4 calls for 64-bit 37511da177e4SLinus Torvalds * locking, this prevents us from being completely protocol-compliant. The 37521da177e4SLinus Torvalds * real solution to this problem is to start using unsigned file offsets in 37531da177e4SLinus Torvalds * the VFS, but this is a very deep change! 37541da177e4SLinus Torvalds */ 37551da177e4SLinus Torvalds static inline void 37561da177e4SLinus Torvalds nfs4_transform_lock_offset(struct file_lock *lock) 37571da177e4SLinus Torvalds { 37581da177e4SLinus Torvalds if (lock->fl_start < 0) 37591da177e4SLinus Torvalds lock->fl_start = OFFSET_MAX; 37601da177e4SLinus Torvalds if (lock->fl_end < 0) 37611da177e4SLinus Torvalds lock->fl_end = OFFSET_MAX; 37621da177e4SLinus Torvalds } 37631da177e4SLinus Torvalds 3764d5b9026aSNeilBrown /* Hack!: For now, we're defining this just so we can use a pointer to it 3765d5b9026aSNeilBrown * as a unique cookie to identify our (NFSv4's) posix locks. */ 37667b021967SAlexey Dobriyan static const struct lock_manager_operations nfsd_posix_mng_ops = { 3767d5b9026aSNeilBrown }; 37681da177e4SLinus Torvalds 37691da177e4SLinus Torvalds static inline void 37701da177e4SLinus Torvalds nfs4_set_lock_denied(struct file_lock *fl, struct nfsd4_lock_denied *deny) 37711da177e4SLinus Torvalds { 3772fe0750e5SJ. Bruce Fields struct nfs4_lockowner *lo; 37731da177e4SLinus Torvalds 3774d5b9026aSNeilBrown if (fl->fl_lmops == &nfsd_posix_mng_ops) { 3775fe0750e5SJ. Bruce Fields lo = (struct nfs4_lockowner *) fl->fl_owner; 3776fe0750e5SJ. Bruce Fields deny->ld_owner.data = kmemdup(lo->lo_owner.so_owner.data, 3777fe0750e5SJ. Bruce Fields lo->lo_owner.so_owner.len, GFP_KERNEL); 37787c13f344SJ. Bruce Fields if (!deny->ld_owner.data) 37797c13f344SJ. Bruce Fields /* We just don't care that much */ 37807c13f344SJ. Bruce Fields goto nevermind; 3781fe0750e5SJ. Bruce Fields deny->ld_owner.len = lo->lo_owner.so_owner.len; 3782fe0750e5SJ. Bruce Fields deny->ld_clientid = lo->lo_owner.so_client->cl_clientid; 3783d5b9026aSNeilBrown } else { 37847c13f344SJ. Bruce Fields nevermind: 37857c13f344SJ. Bruce Fields deny->ld_owner.len = 0; 37867c13f344SJ. Bruce Fields deny->ld_owner.data = NULL; 3787d5b9026aSNeilBrown deny->ld_clientid.cl_boot = 0; 3788d5b9026aSNeilBrown deny->ld_clientid.cl_id = 0; 37891da177e4SLinus Torvalds } 37901da177e4SLinus Torvalds deny->ld_start = fl->fl_start; 379187df4de8SBenny Halevy deny->ld_length = NFS4_MAX_UINT64; 379287df4de8SBenny Halevy if (fl->fl_end != NFS4_MAX_UINT64) 37931da177e4SLinus Torvalds deny->ld_length = fl->fl_end - fl->fl_start + 1; 37941da177e4SLinus Torvalds deny->ld_type = NFS4_READ_LT; 37951da177e4SLinus Torvalds if (fl->fl_type != F_RDLCK) 37961da177e4SLinus Torvalds deny->ld_type = NFS4_WRITE_LT; 37971da177e4SLinus Torvalds } 37981da177e4SLinus Torvalds 3799fe0750e5SJ. Bruce Fields static struct nfs4_lockowner * 3800fe0750e5SJ. Bruce Fields find_lockowner_str(struct inode *inode, clientid_t *clid, 38011da177e4SLinus Torvalds struct xdr_netobj *owner) 38021da177e4SLinus Torvalds { 38031da177e4SLinus Torvalds unsigned int hashval = lock_ownerstr_hashval(inode, clid->cl_id, owner); 38041da177e4SLinus Torvalds struct nfs4_stateowner *op; 38051da177e4SLinus Torvalds 38061da177e4SLinus Torvalds list_for_each_entry(op, &lock_ownerstr_hashtbl[hashval], so_strhash) { 3807599e0a22SJ. Bruce Fields if (same_owner_str(op, owner, clid)) 3808fe0750e5SJ. Bruce Fields return lockowner(op); 38091da177e4SLinus Torvalds } 38101da177e4SLinus Torvalds return NULL; 38111da177e4SLinus Torvalds } 38121da177e4SLinus Torvalds 3813dcef0413SJ. Bruce Fields static void hash_lockowner(struct nfs4_lockowner *lo, unsigned int strhashval, struct nfs4_client *clp, struct nfs4_ol_stateid *open_stp) 3814ff194bd9SJ. Bruce Fields { 3815ff194bd9SJ. Bruce Fields unsigned int idhashval; 3816ff194bd9SJ. Bruce Fields 3817fe0750e5SJ. Bruce Fields idhashval = lockownerid_hashval(lo->lo_owner.so_id); 3818fe0750e5SJ. Bruce Fields list_add(&lo->lo_owner.so_idhash, &lock_ownerid_hashtbl[idhashval]); 3819fe0750e5SJ. Bruce Fields list_add(&lo->lo_owner.so_strhash, &lock_ownerstr_hashtbl[strhashval]); 3820fe0750e5SJ. Bruce Fields list_add(&lo->lo_perstateid, &open_stp->st_lockowners); 3821ff194bd9SJ. Bruce Fields } 3822ff194bd9SJ. Bruce Fields 38231da177e4SLinus Torvalds /* 38241da177e4SLinus Torvalds * Alloc a lock owner structure. 38251da177e4SLinus Torvalds * Called in nfsd4_lock - therefore, OPEN and OPEN_CONFIRM (if needed) has 382625985edcSLucas De Marchi * occurred. 38271da177e4SLinus Torvalds * 38281da177e4SLinus Torvalds * strhashval = lock_ownerstr_hashval 38291da177e4SLinus Torvalds */ 38301da177e4SLinus Torvalds 3831fe0750e5SJ. Bruce Fields static struct nfs4_lockowner * 3832dcef0413SJ. Bruce Fields alloc_init_lock_stateowner(unsigned int strhashval, struct nfs4_client *clp, struct nfs4_ol_stateid *open_stp, struct nfsd4_lock *lock) { 3833fe0750e5SJ. Bruce Fields struct nfs4_lockowner *lo; 38341da177e4SLinus Torvalds 3835fe0750e5SJ. Bruce Fields lo = alloc_stateowner(lockowner_slab, &lock->lk_new_owner, clp); 3836fe0750e5SJ. Bruce Fields if (!lo) 38371da177e4SLinus Torvalds return NULL; 3838fe0750e5SJ. Bruce Fields INIT_LIST_HEAD(&lo->lo_owner.so_stateids); 3839fe0750e5SJ. Bruce Fields lo->lo_owner.so_is_open_owner = 0; 3840b59e3c0eSNeil Brown /* It is the openowner seqid that will be incremented in encode in the 3841b59e3c0eSNeil Brown * case of new lockowners; so increment the lock seqid manually: */ 3842fe0750e5SJ. Bruce Fields lo->lo_owner.so_seqid = lock->lk_new_lock_seqid + 1; 3843fe0750e5SJ. Bruce Fields hash_lockowner(lo, strhashval, clp, open_stp); 3844fe0750e5SJ. Bruce Fields return lo; 38451da177e4SLinus Torvalds } 38461da177e4SLinus Torvalds 3847dcef0413SJ. Bruce Fields static struct nfs4_ol_stateid * 3848dcef0413SJ. Bruce Fields alloc_init_lock_stateid(struct nfs4_lockowner *lo, struct nfs4_file *fp, struct nfs4_ol_stateid *open_stp) 38491da177e4SLinus Torvalds { 3850dcef0413SJ. Bruce Fields struct nfs4_ol_stateid *stp; 38511da177e4SLinus Torvalds 38525ac049acSNeilBrown stp = nfs4_alloc_stateid(); 38535ac049acSNeilBrown if (stp == NULL) 38541da177e4SLinus Torvalds goto out; 38558beefa24SNeilBrown list_add(&stp->st_perfile, &fp->fi_stateids); 3856fe0750e5SJ. Bruce Fields list_add(&stp->st_perstateowner, &lo->lo_owner.so_stateids); 3857fe0750e5SJ. Bruce Fields stp->st_stateowner = &lo->lo_owner; 3858dcef0413SJ. Bruce Fields stp->st_stid.sc_type = NFS4_LOCK_STID; 385913cd2184SNeilBrown get_nfs4_file(fp); 38601da177e4SLinus Torvalds stp->st_file = fp; 3861dcef0413SJ. Bruce Fields stp->st_stid.sc_stateid.si_boot = boot_time; 3862dcef0413SJ. Bruce Fields stp->st_stid.sc_stateid.si_stateownerid = lo->lo_owner.so_id; 3863dcef0413SJ. Bruce Fields stp->st_stid.sc_stateid.si_fileid = fp->fi_id; 386473997dc4SJ. Bruce Fields /* note will be incremented before first return to client: */ 3865dcef0413SJ. Bruce Fields stp->st_stid.sc_stateid.si_generation = 0; 386636d44c60SJ. Bruce Fields hash_stid(&stp->st_stid); 38670997b173SJ. Bruce Fields stp->st_access_bmap = 0; 38681da177e4SLinus Torvalds stp->st_deny_bmap = open_stp->st_deny_bmap; 38694c4cd222SNeilBrown stp->st_openstp = open_stp; 38701da177e4SLinus Torvalds 38711da177e4SLinus Torvalds out: 38721da177e4SLinus Torvalds return stp; 38731da177e4SLinus Torvalds } 38741da177e4SLinus Torvalds 3875fd39ca9aSNeilBrown static int 38761da177e4SLinus Torvalds check_lock_length(u64 offset, u64 length) 38771da177e4SLinus Torvalds { 387887df4de8SBenny Halevy return ((length == 0) || ((length != NFS4_MAX_UINT64) && 38791da177e4SLinus Torvalds LOFF_OVERFLOW(offset, length))); 38801da177e4SLinus Torvalds } 38811da177e4SLinus Torvalds 3882dcef0413SJ. Bruce Fields static void get_lock_access(struct nfs4_ol_stateid *lock_stp, u32 access) 38830997b173SJ. Bruce Fields { 38840997b173SJ. Bruce Fields struct nfs4_file *fp = lock_stp->st_file; 38850997b173SJ. Bruce Fields int oflag = nfs4_access_to_omode(access); 38860997b173SJ. Bruce Fields 38870997b173SJ. Bruce Fields if (test_bit(access, &lock_stp->st_access_bmap)) 38880997b173SJ. Bruce Fields return; 38890997b173SJ. Bruce Fields nfs4_file_get_access(fp, oflag); 38900997b173SJ. Bruce Fields __set_bit(access, &lock_stp->st_access_bmap); 38910997b173SJ. Bruce Fields } 38920997b173SJ. Bruce Fields 38931da177e4SLinus Torvalds /* 38941da177e4SLinus Torvalds * LOCK operation 38951da177e4SLinus Torvalds */ 3896b37ad28bSAl Viro __be32 3897ca364317SJ.Bruce Fields nfsd4_lock(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 3898a4f1706aSJ.Bruce Fields struct nfsd4_lock *lock) 38991da177e4SLinus Torvalds { 3900fe0750e5SJ. Bruce Fields struct nfs4_openowner *open_sop = NULL; 3901fe0750e5SJ. Bruce Fields struct nfs4_lockowner *lock_sop = NULL; 3902dcef0413SJ. Bruce Fields struct nfs4_ol_stateid *lock_stp; 39037d947842SJ. Bruce Fields struct nfs4_file *fp; 39047d947842SJ. Bruce Fields struct file *filp = NULL; 39051da177e4SLinus Torvalds struct file_lock file_lock; 39068dc7c311SAndy Adamson struct file_lock conflock; 3907b37ad28bSAl Viro __be32 status = 0; 39081da177e4SLinus Torvalds unsigned int strhashval; 3909b34f27aaSJ. Bruce Fields int lkflg; 3910b8dd7b9aSAl Viro int err; 39111da177e4SLinus Torvalds 39121da177e4SLinus Torvalds dprintk("NFSD: nfsd4_lock: start=%Ld length=%Ld\n", 39131da177e4SLinus Torvalds (long long) lock->lk_offset, 39141da177e4SLinus Torvalds (long long) lock->lk_length); 39151da177e4SLinus Torvalds 39161da177e4SLinus Torvalds if (check_lock_length(lock->lk_offset, lock->lk_length)) 39171da177e4SLinus Torvalds return nfserr_inval; 39181da177e4SLinus Torvalds 3919ca364317SJ.Bruce Fields if ((status = fh_verify(rqstp, &cstate->current_fh, 39208837abcaSMiklos Szeredi S_IFREG, NFSD_MAY_LOCK))) { 3921a6f6ef2fSAndy Adamson dprintk("NFSD: nfsd4_lock: permission denied!\n"); 3922a6f6ef2fSAndy Adamson return status; 3923a6f6ef2fSAndy Adamson } 3924a6f6ef2fSAndy Adamson 39251da177e4SLinus Torvalds nfs4_lock_state(); 39261da177e4SLinus Torvalds 39271da177e4SLinus Torvalds if (lock->lk_is_new) { 39281da177e4SLinus Torvalds /* 39291da177e4SLinus Torvalds * Client indicates that this is a new lockowner. 3930893f8770SNeilBrown * Use open owner and open stateid to create lock owner and 3931893f8770SNeilBrown * lock stateid. 39321da177e4SLinus Torvalds */ 3933dcef0413SJ. Bruce Fields struct nfs4_ol_stateid *open_stp = NULL; 39341da177e4SLinus Torvalds 39351da177e4SLinus Torvalds status = nfserr_stale_clientid; 393660adfc50SAndy Adamson if (!nfsd4_has_session(cstate) && 393760adfc50SAndy Adamson STALE_CLIENTID(&lock->lk_new_clientid)) 39381da177e4SLinus Torvalds goto out; 39391da177e4SLinus Torvalds 39401da177e4SLinus Torvalds /* validate and update open stateid and open seqid */ 3941c0a5d93eSJ. Bruce Fields status = nfs4_preprocess_confirmed_seqid_op(cstate, 39421da177e4SLinus Torvalds lock->lk_new_open_seqid, 39431da177e4SLinus Torvalds &lock->lk_new_open_stateid, 3944c0a5d93eSJ. Bruce Fields &open_stp); 394537515177SNeilBrown if (status) 39461da177e4SLinus Torvalds goto out; 3947fe0750e5SJ. Bruce Fields open_sop = openowner(open_stp->st_stateowner); 3948b34f27aaSJ. Bruce Fields status = nfserr_bad_stateid; 3949b34f27aaSJ. Bruce Fields if (!nfsd4_has_session(cstate) && 3950fe0750e5SJ. Bruce Fields !same_clid(&open_sop->oo_owner.so_client->cl_clientid, 3951b34f27aaSJ. Bruce Fields &lock->v.new.clientid)) 3952b34f27aaSJ. Bruce Fields goto out; 39531da177e4SLinus Torvalds /* create lockowner and lock stateid */ 39541da177e4SLinus Torvalds fp = open_stp->st_file; 39551da177e4SLinus Torvalds strhashval = lock_ownerstr_hashval(fp->fi_inode, 3956fe0750e5SJ. Bruce Fields open_sop->oo_owner.so_client->cl_clientid.cl_id, 39571da177e4SLinus Torvalds &lock->v.new.owner); 39583e9e3dbeSNeilBrown /* XXX: Do we need to check for duplicate stateowners on 39593e9e3dbeSNeilBrown * the same file, or should they just be allowed (and 39603e9e3dbeSNeilBrown * create new stateids)? */ 39613e772463SJ. Bruce Fields status = nfserr_jukebox; 3962b59e3c0eSNeil Brown lock_sop = alloc_init_lock_stateowner(strhashval, 3963fe0750e5SJ. Bruce Fields open_sop->oo_owner.so_client, open_stp, lock); 3964b59e3c0eSNeil Brown if (lock_sop == NULL) 39651da177e4SLinus Torvalds goto out; 3966b59e3c0eSNeil Brown lock_stp = alloc_init_lock_stateid(lock_sop, fp, open_stp); 39678a280510SJ. Bruce Fields if (lock_stp == NULL) 39681da177e4SLinus Torvalds goto out; 39691da177e4SLinus Torvalds } else { 39701da177e4SLinus Torvalds /* lock (lock owner + lock stateid) already exists */ 3971dd453dfdSBenny Halevy status = nfs4_preprocess_seqid_op(cstate, 39721da177e4SLinus Torvalds lock->lk_old_lock_seqid, 39731da177e4SLinus Torvalds &lock->lk_old_lock_stateid, 39742288d0e3SJ. Bruce Fields NFS4_LOCK_STID, &lock_stp); 39751da177e4SLinus Torvalds if (status) 39761da177e4SLinus Torvalds goto out; 3977fe0750e5SJ. Bruce Fields lock_sop = lockowner(lock_stp->st_stateowner); 39787d947842SJ. Bruce Fields fp = lock_stp->st_file; 39791da177e4SLinus Torvalds } 39809072d5c6SJ. Bruce Fields /* lock_sop and lock_stp have been created or found */ 39811da177e4SLinus Torvalds 3982b34f27aaSJ. Bruce Fields lkflg = setlkflg(lock->lk_type); 3983b34f27aaSJ. Bruce Fields status = nfs4_check_openmode(lock_stp, lkflg); 3984b34f27aaSJ. Bruce Fields if (status) 3985b34f27aaSJ. Bruce Fields goto out; 3986b34f27aaSJ. Bruce Fields 39870dd395dcSNeilBrown status = nfserr_grace; 3988af558e33SJ. Bruce Fields if (locks_in_grace() && !lock->lk_reclaim) 39890dd395dcSNeilBrown goto out; 39900dd395dcSNeilBrown status = nfserr_no_grace; 3991af558e33SJ. Bruce Fields if (!locks_in_grace() && lock->lk_reclaim) 39920dd395dcSNeilBrown goto out; 39930dd395dcSNeilBrown 39941da177e4SLinus Torvalds locks_init_lock(&file_lock); 39951da177e4SLinus Torvalds switch (lock->lk_type) { 39961da177e4SLinus Torvalds case NFS4_READ_LT: 39971da177e4SLinus Torvalds case NFS4_READW_LT: 3998f9d7562fSJ. Bruce Fields filp = find_readable_file(lock_stp->st_file); 39990997b173SJ. Bruce Fields if (filp) 40000997b173SJ. Bruce Fields get_lock_access(lock_stp, NFS4_SHARE_ACCESS_READ); 40011da177e4SLinus Torvalds file_lock.fl_type = F_RDLCK; 40021da177e4SLinus Torvalds break; 40031da177e4SLinus Torvalds case NFS4_WRITE_LT: 40041da177e4SLinus Torvalds case NFS4_WRITEW_LT: 4005f9d7562fSJ. Bruce Fields filp = find_writeable_file(lock_stp->st_file); 40060997b173SJ. Bruce Fields if (filp) 40070997b173SJ. Bruce Fields get_lock_access(lock_stp, NFS4_SHARE_ACCESS_WRITE); 40081da177e4SLinus Torvalds file_lock.fl_type = F_WRLCK; 40091da177e4SLinus Torvalds break; 40101da177e4SLinus Torvalds default: 40111da177e4SLinus Torvalds status = nfserr_inval; 40121da177e4SLinus Torvalds goto out; 40131da177e4SLinus Torvalds } 4014f9d7562fSJ. Bruce Fields if (!filp) { 4015f9d7562fSJ. Bruce Fields status = nfserr_openmode; 4016f9d7562fSJ. Bruce Fields goto out; 4017f9d7562fSJ. Bruce Fields } 4018b59e3c0eSNeil Brown file_lock.fl_owner = (fl_owner_t)lock_sop; 40191da177e4SLinus Torvalds file_lock.fl_pid = current->tgid; 40201da177e4SLinus Torvalds file_lock.fl_file = filp; 40211da177e4SLinus Torvalds file_lock.fl_flags = FL_POSIX; 4022d5b9026aSNeilBrown file_lock.fl_lmops = &nfsd_posix_mng_ops; 40231da177e4SLinus Torvalds 40241da177e4SLinus Torvalds file_lock.fl_start = lock->lk_offset; 402587df4de8SBenny Halevy file_lock.fl_end = last_byte_offset(lock->lk_offset, lock->lk_length); 40261da177e4SLinus Torvalds nfs4_transform_lock_offset(&file_lock); 40271da177e4SLinus Torvalds 40281da177e4SLinus Torvalds /* 40291da177e4SLinus Torvalds * Try to lock the file in the VFS. 40301da177e4SLinus Torvalds * Note: locks.c uses the BKL to protect the inode's lock list. 40311da177e4SLinus Torvalds */ 40321da177e4SLinus Torvalds 4033529d7b2aSJ. Bruce Fields err = vfs_lock_file(filp, F_SETLK, &file_lock, &conflock); 4034b8dd7b9aSAl Viro switch (-err) { 40351da177e4SLinus Torvalds case 0: /* success! */ 4036dcef0413SJ. Bruce Fields update_stateid(&lock_stp->st_stid.sc_stateid); 4037dcef0413SJ. Bruce Fields memcpy(&lock->lk_resp_stateid, &lock_stp->st_stid.sc_stateid, 40381da177e4SLinus Torvalds sizeof(stateid_t)); 4039b8dd7b9aSAl Viro status = 0; 4040eb76b3fdSAndy Adamson break; 4041eb76b3fdSAndy Adamson case (EAGAIN): /* conflock holds conflicting lock */ 4042eb76b3fdSAndy Adamson status = nfserr_denied; 4043eb76b3fdSAndy Adamson dprintk("NFSD: nfsd4_lock: conflicting lock found!\n"); 4044eb76b3fdSAndy Adamson nfs4_set_lock_denied(&conflock, &lock->lk_denied); 4045eb76b3fdSAndy Adamson break; 40461da177e4SLinus Torvalds case (EDEADLK): 40471da177e4SLinus Torvalds status = nfserr_deadlock; 4048eb76b3fdSAndy Adamson break; 40491da177e4SLinus Torvalds default: 4050fd85b817SMarc Eshel dprintk("NFSD: nfsd4_lock: vfs_lock_file() failed! status %d\n",err); 40513e772463SJ. Bruce Fields status = nfserrno(err); 4052eb76b3fdSAndy Adamson break; 40531da177e4SLinus Torvalds } 40541da177e4SLinus Torvalds out: 40558a280510SJ. Bruce Fields if (status && lock->lk_is_new && lock_sop) 4056f044ff83SJ. Bruce Fields release_lockowner(lock_sop); 40575ec094c1SJ. Bruce Fields if (!cstate->replay_owner) 40581da177e4SLinus Torvalds nfs4_unlock_state(); 40591da177e4SLinus Torvalds return status; 40601da177e4SLinus Torvalds } 40611da177e4SLinus Torvalds 40621da177e4SLinus Torvalds /* 406355ef1274SJ. Bruce Fields * The NFSv4 spec allows a client to do a LOCKT without holding an OPEN, 406455ef1274SJ. Bruce Fields * so we do a temporary open here just to get an open file to pass to 406555ef1274SJ. Bruce Fields * vfs_test_lock. (Arguably perhaps test_lock should be done with an 406655ef1274SJ. Bruce Fields * inode operation.) 406755ef1274SJ. Bruce Fields */ 406855ef1274SJ. Bruce Fields static int nfsd_test_lock(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file_lock *lock) 406955ef1274SJ. Bruce Fields { 407055ef1274SJ. Bruce Fields struct file *file; 407155ef1274SJ. Bruce Fields int err; 407255ef1274SJ. Bruce Fields 407355ef1274SJ. Bruce Fields err = nfsd_open(rqstp, fhp, S_IFREG, NFSD_MAY_READ, &file); 407455ef1274SJ. Bruce Fields if (err) 407555ef1274SJ. Bruce Fields return err; 407655ef1274SJ. Bruce Fields err = vfs_test_lock(file, lock); 407755ef1274SJ. Bruce Fields nfsd_close(file); 407855ef1274SJ. Bruce Fields return err; 407955ef1274SJ. Bruce Fields } 408055ef1274SJ. Bruce Fields 408155ef1274SJ. Bruce Fields /* 40821da177e4SLinus Torvalds * LOCKT operation 40831da177e4SLinus Torvalds */ 4084b37ad28bSAl Viro __be32 4085ca364317SJ.Bruce Fields nfsd4_lockt(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 4086ca364317SJ.Bruce Fields struct nfsd4_lockt *lockt) 40871da177e4SLinus Torvalds { 40881da177e4SLinus Torvalds struct inode *inode; 40891da177e4SLinus Torvalds struct file_lock file_lock; 4090fe0750e5SJ. Bruce Fields struct nfs4_lockowner *lo; 4091fd85b817SMarc Eshel int error; 4092b37ad28bSAl Viro __be32 status; 40931da177e4SLinus Torvalds 4094af558e33SJ. Bruce Fields if (locks_in_grace()) 40951da177e4SLinus Torvalds return nfserr_grace; 40961da177e4SLinus Torvalds 40971da177e4SLinus Torvalds if (check_lock_length(lockt->lt_offset, lockt->lt_length)) 40981da177e4SLinus Torvalds return nfserr_inval; 40991da177e4SLinus Torvalds 41001da177e4SLinus Torvalds nfs4_lock_state(); 41011da177e4SLinus Torvalds 41021da177e4SLinus Torvalds status = nfserr_stale_clientid; 410360adfc50SAndy Adamson if (!nfsd4_has_session(cstate) && STALE_CLIENTID(&lockt->lt_clientid)) 41041da177e4SLinus Torvalds goto out; 41051da177e4SLinus Torvalds 410675c096f7SJ. Bruce Fields if ((status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0))) 41071da177e4SLinus Torvalds goto out; 41081da177e4SLinus Torvalds 4109ca364317SJ.Bruce Fields inode = cstate->current_fh.fh_dentry->d_inode; 41101da177e4SLinus Torvalds locks_init_lock(&file_lock); 41111da177e4SLinus Torvalds switch (lockt->lt_type) { 41121da177e4SLinus Torvalds case NFS4_READ_LT: 41131da177e4SLinus Torvalds case NFS4_READW_LT: 41141da177e4SLinus Torvalds file_lock.fl_type = F_RDLCK; 41151da177e4SLinus Torvalds break; 41161da177e4SLinus Torvalds case NFS4_WRITE_LT: 41171da177e4SLinus Torvalds case NFS4_WRITEW_LT: 41181da177e4SLinus Torvalds file_lock.fl_type = F_WRLCK; 41191da177e4SLinus Torvalds break; 41201da177e4SLinus Torvalds default: 41212fdada03SJ. Bruce Fields dprintk("NFSD: nfs4_lockt: bad lock type!\n"); 41221da177e4SLinus Torvalds status = nfserr_inval; 41231da177e4SLinus Torvalds goto out; 41241da177e4SLinus Torvalds } 41251da177e4SLinus Torvalds 4126fe0750e5SJ. Bruce Fields lo = find_lockowner_str(inode, &lockt->lt_clientid, &lockt->lt_owner); 4127fe0750e5SJ. Bruce Fields if (lo) 4128fe0750e5SJ. Bruce Fields file_lock.fl_owner = (fl_owner_t)lo; 41291da177e4SLinus Torvalds file_lock.fl_pid = current->tgid; 41301da177e4SLinus Torvalds file_lock.fl_flags = FL_POSIX; 41311da177e4SLinus Torvalds 41321da177e4SLinus Torvalds file_lock.fl_start = lockt->lt_offset; 413387df4de8SBenny Halevy file_lock.fl_end = last_byte_offset(lockt->lt_offset, lockt->lt_length); 41341da177e4SLinus Torvalds 41351da177e4SLinus Torvalds nfs4_transform_lock_offset(&file_lock); 41361da177e4SLinus Torvalds 41371da177e4SLinus Torvalds status = nfs_ok; 413855ef1274SJ. Bruce Fields error = nfsd_test_lock(rqstp, &cstate->current_fh, &file_lock); 4139fd85b817SMarc Eshel if (error) { 4140fd85b817SMarc Eshel status = nfserrno(error); 4141fd85b817SMarc Eshel goto out; 4142fd85b817SMarc Eshel } 41439d6a8c5cSMarc Eshel if (file_lock.fl_type != F_UNLCK) { 41441da177e4SLinus Torvalds status = nfserr_denied; 41459d6a8c5cSMarc Eshel nfs4_set_lock_denied(&file_lock, &lockt->lt_denied); 41461da177e4SLinus Torvalds } 41471da177e4SLinus Torvalds out: 41481da177e4SLinus Torvalds nfs4_unlock_state(); 41491da177e4SLinus Torvalds return status; 41501da177e4SLinus Torvalds } 41511da177e4SLinus Torvalds 4152b37ad28bSAl Viro __be32 4153ca364317SJ.Bruce Fields nfsd4_locku(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 4154a4f1706aSJ.Bruce Fields struct nfsd4_locku *locku) 41551da177e4SLinus Torvalds { 4156dcef0413SJ. Bruce Fields struct nfs4_ol_stateid *stp; 41571da177e4SLinus Torvalds struct file *filp = NULL; 41581da177e4SLinus Torvalds struct file_lock file_lock; 4159b37ad28bSAl Viro __be32 status; 4160b8dd7b9aSAl Viro int err; 41611da177e4SLinus Torvalds 41621da177e4SLinus Torvalds dprintk("NFSD: nfsd4_locku: start=%Ld length=%Ld\n", 41631da177e4SLinus Torvalds (long long) locku->lu_offset, 41641da177e4SLinus Torvalds (long long) locku->lu_length); 41651da177e4SLinus Torvalds 41661da177e4SLinus Torvalds if (check_lock_length(locku->lu_offset, locku->lu_length)) 41671da177e4SLinus Torvalds return nfserr_inval; 41681da177e4SLinus Torvalds 41691da177e4SLinus Torvalds nfs4_lock_state(); 41701da177e4SLinus Torvalds 41719072d5c6SJ. Bruce Fields status = nfs4_preprocess_seqid_op(cstate, locku->lu_seqid, 41722288d0e3SJ. Bruce Fields &locku->lu_stateid, NFS4_LOCK_STID, &stp); 41739072d5c6SJ. Bruce Fields if (status) 41741da177e4SLinus Torvalds goto out; 4175f9d7562fSJ. Bruce Fields filp = find_any_file(stp->st_file); 4176f9d7562fSJ. Bruce Fields if (!filp) { 4177f9d7562fSJ. Bruce Fields status = nfserr_lock_range; 4178f9d7562fSJ. Bruce Fields goto out; 4179f9d7562fSJ. Bruce Fields } 41801da177e4SLinus Torvalds BUG_ON(!filp); 41811da177e4SLinus Torvalds locks_init_lock(&file_lock); 41821da177e4SLinus Torvalds file_lock.fl_type = F_UNLCK; 4183fe0750e5SJ. Bruce Fields file_lock.fl_owner = (fl_owner_t)lockowner(stp->st_stateowner); 41841da177e4SLinus Torvalds file_lock.fl_pid = current->tgid; 41851da177e4SLinus Torvalds file_lock.fl_file = filp; 41861da177e4SLinus Torvalds file_lock.fl_flags = FL_POSIX; 4187d5b9026aSNeilBrown file_lock.fl_lmops = &nfsd_posix_mng_ops; 41881da177e4SLinus Torvalds file_lock.fl_start = locku->lu_offset; 41891da177e4SLinus Torvalds 419087df4de8SBenny Halevy file_lock.fl_end = last_byte_offset(locku->lu_offset, locku->lu_length); 41911da177e4SLinus Torvalds nfs4_transform_lock_offset(&file_lock); 41921da177e4SLinus Torvalds 41931da177e4SLinus Torvalds /* 41941da177e4SLinus Torvalds * Try to unlock the file in the VFS. 41951da177e4SLinus Torvalds */ 4196fd85b817SMarc Eshel err = vfs_lock_file(filp, F_SETLK, &file_lock, NULL); 4197b8dd7b9aSAl Viro if (err) { 4198fd85b817SMarc Eshel dprintk("NFSD: nfs4_locku: vfs_lock_file failed!\n"); 41991da177e4SLinus Torvalds goto out_nfserr; 42001da177e4SLinus Torvalds } 42011da177e4SLinus Torvalds /* 42021da177e4SLinus Torvalds * OK, unlock succeeded; the only thing left to do is update the stateid. 42031da177e4SLinus Torvalds */ 4204dcef0413SJ. Bruce Fields update_stateid(&stp->st_stid.sc_stateid); 4205dcef0413SJ. Bruce Fields memcpy(&locku->lu_stateid, &stp->st_stid.sc_stateid, sizeof(stateid_t)); 42061da177e4SLinus Torvalds 42071da177e4SLinus Torvalds out: 42081da177e4SLinus Torvalds nfs4_unlock_state(); 42091da177e4SLinus Torvalds return status; 42101da177e4SLinus Torvalds 42111da177e4SLinus Torvalds out_nfserr: 4212b8dd7b9aSAl Viro status = nfserrno(err); 42131da177e4SLinus Torvalds goto out; 42141da177e4SLinus Torvalds } 42151da177e4SLinus Torvalds 42161da177e4SLinus Torvalds /* 42171da177e4SLinus Torvalds * returns 42181da177e4SLinus Torvalds * 1: locks held by lockowner 42191da177e4SLinus Torvalds * 0: no locks held by lockowner 42201da177e4SLinus Torvalds */ 42211da177e4SLinus Torvalds static int 4222fe0750e5SJ. Bruce Fields check_for_locks(struct nfs4_file *filp, struct nfs4_lockowner *lowner) 42231da177e4SLinus Torvalds { 42241da177e4SLinus Torvalds struct file_lock **flpp; 4225f9d7562fSJ. Bruce Fields struct inode *inode = filp->fi_inode; 42261da177e4SLinus Torvalds int status = 0; 42271da177e4SLinus Torvalds 4228b89f4321SArnd Bergmann lock_flocks(); 42291da177e4SLinus Torvalds for (flpp = &inode->i_flock; *flpp != NULL; flpp = &(*flpp)->fl_next) { 4230796dadfdSJ. Bruce Fields if ((*flpp)->fl_owner == (fl_owner_t)lowner) { 42311da177e4SLinus Torvalds status = 1; 42321da177e4SLinus Torvalds goto out; 42331da177e4SLinus Torvalds } 4234796dadfdSJ. Bruce Fields } 42351da177e4SLinus Torvalds out: 4236b89f4321SArnd Bergmann unlock_flocks(); 42371da177e4SLinus Torvalds return status; 42381da177e4SLinus Torvalds } 42391da177e4SLinus Torvalds 4240b37ad28bSAl Viro __be32 4241b591480bSJ.Bruce Fields nfsd4_release_lockowner(struct svc_rqst *rqstp, 4242b591480bSJ.Bruce Fields struct nfsd4_compound_state *cstate, 4243b591480bSJ.Bruce Fields struct nfsd4_release_lockowner *rlockowner) 42441da177e4SLinus Torvalds { 42451da177e4SLinus Torvalds clientid_t *clid = &rlockowner->rl_clientid; 42463e9e3dbeSNeilBrown struct nfs4_stateowner *sop; 4247fe0750e5SJ. Bruce Fields struct nfs4_lockowner *lo; 4248dcef0413SJ. Bruce Fields struct nfs4_ol_stateid *stp; 42491da177e4SLinus Torvalds struct xdr_netobj *owner = &rlockowner->rl_owner; 42503e9e3dbeSNeilBrown struct list_head matches; 42513e9e3dbeSNeilBrown int i; 4252b37ad28bSAl Viro __be32 status; 42531da177e4SLinus Torvalds 42541da177e4SLinus Torvalds dprintk("nfsd4_release_lockowner clientid: (%08x/%08x):\n", 42551da177e4SLinus Torvalds clid->cl_boot, clid->cl_id); 42561da177e4SLinus Torvalds 42571da177e4SLinus Torvalds /* XXX check for lease expiration */ 42581da177e4SLinus Torvalds 42591da177e4SLinus Torvalds status = nfserr_stale_clientid; 4260849823c5SNeil Brown if (STALE_CLIENTID(clid)) 42611da177e4SLinus Torvalds return status; 42621da177e4SLinus Torvalds 42631da177e4SLinus Torvalds nfs4_lock_state(); 42641da177e4SLinus Torvalds 42651da177e4SLinus Torvalds status = nfserr_locks_held; 42663e9e3dbeSNeilBrown /* XXX: we're doing a linear search through all the lockowners. 42673e9e3dbeSNeilBrown * Yipes! For now we'll just hope clients aren't really using 42683e9e3dbeSNeilBrown * release_lockowner much, but eventually we have to fix these 42693e9e3dbeSNeilBrown * data structures. */ 42703e9e3dbeSNeilBrown INIT_LIST_HEAD(&matches); 42713e9e3dbeSNeilBrown for (i = 0; i < LOCK_HASH_SIZE; i++) { 42723e9e3dbeSNeilBrown list_for_each_entry(sop, &lock_ownerid_hashtbl[i], so_idhash) { 4273599e0a22SJ. Bruce Fields if (!same_owner_str(sop, owner, clid)) 42743e9e3dbeSNeilBrown continue; 42753e9e3dbeSNeilBrown list_for_each_entry(stp, &sop->so_stateids, 4276ea1da636SNeilBrown st_perstateowner) { 4277fe0750e5SJ. Bruce Fields lo = lockowner(sop); 4278fe0750e5SJ. Bruce Fields if (check_for_locks(stp->st_file, lo)) 42791da177e4SLinus Torvalds goto out; 4280fe0750e5SJ. Bruce Fields list_add(&lo->lo_list, &matches); 42811da177e4SLinus Torvalds } 42823e9e3dbeSNeilBrown } 42833e9e3dbeSNeilBrown } 42843e9e3dbeSNeilBrown /* Clients probably won't expect us to return with some (but not all) 42853e9e3dbeSNeilBrown * of the lockowner state released; so don't release any until all 42863e9e3dbeSNeilBrown * have been checked. */ 42871da177e4SLinus Torvalds status = nfs_ok; 42880fa822e4SNeilBrown while (!list_empty(&matches)) { 4289fe0750e5SJ. Bruce Fields lo = list_entry(matches.next, struct nfs4_lockowner, 4290fe0750e5SJ. Bruce Fields lo_list); 42910fa822e4SNeilBrown /* unhash_stateowner deletes so_perclient only 42920fa822e4SNeilBrown * for openowners. */ 4293fe0750e5SJ. Bruce Fields list_del(&lo->lo_list); 4294fe0750e5SJ. Bruce Fields release_lockowner(lo); 42951da177e4SLinus Torvalds } 42961da177e4SLinus Torvalds out: 42971da177e4SLinus Torvalds nfs4_unlock_state(); 42981da177e4SLinus Torvalds return status; 42991da177e4SLinus Torvalds } 43001da177e4SLinus Torvalds 43011da177e4SLinus Torvalds static inline struct nfs4_client_reclaim * 4302a55370a3SNeilBrown alloc_reclaim(void) 43031da177e4SLinus Torvalds { 4304a55370a3SNeilBrown return kmalloc(sizeof(struct nfs4_client_reclaim), GFP_KERNEL); 43051da177e4SLinus Torvalds } 43061da177e4SLinus Torvalds 4307c7b9a459SNeilBrown int 4308a1bcecd2SAndy Adamson nfs4_has_reclaimed_state(const char *name, bool use_exchange_id) 4309c7b9a459SNeilBrown { 4310c7b9a459SNeilBrown unsigned int strhashval = clientstr_hashval(name); 4311c7b9a459SNeilBrown struct nfs4_client *clp; 4312c7b9a459SNeilBrown 4313e203d506SJ. Bruce Fields clp = find_confirmed_client_by_str(name, strhashval); 4314c7b9a459SNeilBrown return clp ? 1 : 0; 4315c7b9a459SNeilBrown } 4316c7b9a459SNeilBrown 43171da177e4SLinus Torvalds /* 43181da177e4SLinus Torvalds * failure => all reset bets are off, nfserr_no_grace... 43191da177e4SLinus Torvalds */ 4320190e4fbfSNeilBrown int 4321190e4fbfSNeilBrown nfs4_client_to_reclaim(const char *name) 43221da177e4SLinus Torvalds { 43231da177e4SLinus Torvalds unsigned int strhashval; 43241da177e4SLinus Torvalds struct nfs4_client_reclaim *crp = NULL; 43251da177e4SLinus Torvalds 4326a55370a3SNeilBrown dprintk("NFSD nfs4_client_to_reclaim NAME: %.*s\n", HEXDIR_LEN, name); 4327a55370a3SNeilBrown crp = alloc_reclaim(); 43281da177e4SLinus Torvalds if (!crp) 43291da177e4SLinus Torvalds return 0; 4330a55370a3SNeilBrown strhashval = clientstr_hashval(name); 43311da177e4SLinus Torvalds INIT_LIST_HEAD(&crp->cr_strhash); 43321da177e4SLinus Torvalds list_add(&crp->cr_strhash, &reclaim_str_hashtbl[strhashval]); 4333a55370a3SNeilBrown memcpy(crp->cr_recdir, name, HEXDIR_LEN); 43341da177e4SLinus Torvalds reclaim_str_hashtbl_size++; 43351da177e4SLinus Torvalds return 1; 43361da177e4SLinus Torvalds } 43371da177e4SLinus Torvalds 43381da177e4SLinus Torvalds static void 43391da177e4SLinus Torvalds nfs4_release_reclaim(void) 43401da177e4SLinus Torvalds { 43411da177e4SLinus Torvalds struct nfs4_client_reclaim *crp = NULL; 43421da177e4SLinus Torvalds int i; 43431da177e4SLinus Torvalds 43441da177e4SLinus Torvalds for (i = 0; i < CLIENT_HASH_SIZE; i++) { 43451da177e4SLinus Torvalds while (!list_empty(&reclaim_str_hashtbl[i])) { 43461da177e4SLinus Torvalds crp = list_entry(reclaim_str_hashtbl[i].next, 43471da177e4SLinus Torvalds struct nfs4_client_reclaim, cr_strhash); 43481da177e4SLinus Torvalds list_del(&crp->cr_strhash); 43491da177e4SLinus Torvalds kfree(crp); 43501da177e4SLinus Torvalds reclaim_str_hashtbl_size--; 43511da177e4SLinus Torvalds } 43521da177e4SLinus Torvalds } 43531da177e4SLinus Torvalds BUG_ON(reclaim_str_hashtbl_size); 43541da177e4SLinus Torvalds } 43551da177e4SLinus Torvalds 43561da177e4SLinus Torvalds /* 43571da177e4SLinus Torvalds * called from OPEN, CLAIM_PREVIOUS with a new clientid. */ 4358fd39ca9aSNeilBrown static struct nfs4_client_reclaim * 43591da177e4SLinus Torvalds nfs4_find_reclaim_client(clientid_t *clid) 43601da177e4SLinus Torvalds { 43611da177e4SLinus Torvalds unsigned int strhashval; 43621da177e4SLinus Torvalds struct nfs4_client *clp; 43631da177e4SLinus Torvalds struct nfs4_client_reclaim *crp = NULL; 43641da177e4SLinus Torvalds 43651da177e4SLinus Torvalds 43661da177e4SLinus Torvalds /* find clientid in conf_id_hashtbl */ 43671da177e4SLinus Torvalds clp = find_confirmed_client(clid); 43681da177e4SLinus Torvalds if (clp == NULL) 43691da177e4SLinus Torvalds return NULL; 43701da177e4SLinus Torvalds 4371a55370a3SNeilBrown dprintk("NFSD: nfs4_find_reclaim_client for %.*s with recdir %s\n", 4372a55370a3SNeilBrown clp->cl_name.len, clp->cl_name.data, 4373a55370a3SNeilBrown clp->cl_recdir); 43741da177e4SLinus Torvalds 43751da177e4SLinus Torvalds /* find clp->cl_name in reclaim_str_hashtbl */ 4376a55370a3SNeilBrown strhashval = clientstr_hashval(clp->cl_recdir); 43771da177e4SLinus Torvalds list_for_each_entry(crp, &reclaim_str_hashtbl[strhashval], cr_strhash) { 4378a55370a3SNeilBrown if (same_name(crp->cr_recdir, clp->cl_recdir)) { 43791da177e4SLinus Torvalds return crp; 43801da177e4SLinus Torvalds } 43811da177e4SLinus Torvalds } 43821da177e4SLinus Torvalds return NULL; 43831da177e4SLinus Torvalds } 43841da177e4SLinus Torvalds 43851da177e4SLinus Torvalds /* 43861da177e4SLinus Torvalds * Called from OPEN. Look for clientid in reclaim list. 43871da177e4SLinus Torvalds */ 4388b37ad28bSAl Viro __be32 43891da177e4SLinus Torvalds nfs4_check_open_reclaim(clientid_t *clid) 43901da177e4SLinus Torvalds { 4391dfc83565SNeilBrown return nfs4_find_reclaim_client(clid) ? nfs_ok : nfserr_reclaim_bad; 43921da177e4SLinus Torvalds } 43931da177e4SLinus Torvalds 4394ac4d8ff2SNeilBrown /* initialization to perform at module load time: */ 43951da177e4SLinus Torvalds 4396e8ff2a84SJ. Bruce Fields int 4397ac4d8ff2SNeilBrown nfs4_state_init(void) 43981da177e4SLinus Torvalds { 4399e8ff2a84SJ. Bruce Fields int i, status; 44001da177e4SLinus Torvalds 4401e8ff2a84SJ. Bruce Fields status = nfsd4_init_slabs(); 4402e8ff2a84SJ. Bruce Fields if (status) 4403e8ff2a84SJ. Bruce Fields return status; 44041da177e4SLinus Torvalds for (i = 0; i < CLIENT_HASH_SIZE; i++) { 44051da177e4SLinus Torvalds INIT_LIST_HEAD(&conf_id_hashtbl[i]); 44061da177e4SLinus Torvalds INIT_LIST_HEAD(&conf_str_hashtbl[i]); 44071da177e4SLinus Torvalds INIT_LIST_HEAD(&unconf_str_hashtbl[i]); 44081da177e4SLinus Torvalds INIT_LIST_HEAD(&unconf_id_hashtbl[i]); 440902cb2858SWang Chen INIT_LIST_HEAD(&reclaim_str_hashtbl[i]); 44101da177e4SLinus Torvalds } 44115282fd72SMarc Eshel for (i = 0; i < SESSION_HASH_SIZE; i++) 44125282fd72SMarc Eshel INIT_LIST_HEAD(&sessionid_hashtbl[i]); 44131da177e4SLinus Torvalds for (i = 0; i < FILE_HASH_SIZE; i++) { 44141da177e4SLinus Torvalds INIT_LIST_HEAD(&file_hashtbl[i]); 44151da177e4SLinus Torvalds } 4416506f275fSJ. Bruce Fields for (i = 0; i < OPEN_OWNER_HASH_SIZE; i++) { 4417506f275fSJ. Bruce Fields INIT_LIST_HEAD(&open_ownerstr_hashtbl[i]); 4418506f275fSJ. Bruce Fields INIT_LIST_HEAD(&open_ownerid_hashtbl[i]); 44191da177e4SLinus Torvalds } 4420b79abaddSJ. Bruce Fields for (i = 0; i < STATEID_HASH_SIZE; i++) 44211da177e4SLinus Torvalds INIT_LIST_HEAD(&stateid_hashtbl[i]); 44221da177e4SLinus Torvalds for (i = 0; i < LOCK_HASH_SIZE; i++) { 44231da177e4SLinus Torvalds INIT_LIST_HEAD(&lock_ownerid_hashtbl[i]); 44241da177e4SLinus Torvalds INIT_LIST_HEAD(&lock_ownerstr_hashtbl[i]); 44251da177e4SLinus Torvalds } 44261da177e4SLinus Torvalds memset(&onestateid, ~0, sizeof(stateid_t)); 44271da177e4SLinus Torvalds INIT_LIST_HEAD(&close_lru); 44281da177e4SLinus Torvalds INIT_LIST_HEAD(&client_lru); 44291da177e4SLinus Torvalds INIT_LIST_HEAD(&del_recall_lru); 4430ac4d8ff2SNeilBrown reclaim_str_hashtbl_size = 0; 4431e8ff2a84SJ. Bruce Fields return 0; 4432ac4d8ff2SNeilBrown } 4433ac4d8ff2SNeilBrown 4434190e4fbfSNeilBrown static void 4435190e4fbfSNeilBrown nfsd4_load_reboot_recovery_data(void) 4436190e4fbfSNeilBrown { 4437190e4fbfSNeilBrown int status; 4438190e4fbfSNeilBrown 44390964a3d3SNeilBrown nfs4_lock_state(); 444048483bf2SJ. Bruce Fields nfsd4_init_recdir(); 4441190e4fbfSNeilBrown status = nfsd4_recdir_load(); 44420964a3d3SNeilBrown nfs4_unlock_state(); 4443190e4fbfSNeilBrown if (status) 4444190e4fbfSNeilBrown printk("NFSD: Failure reading reboot recovery data\n"); 4445190e4fbfSNeilBrown } 4446190e4fbfSNeilBrown 4447c2f1a551SMeelap Shah /* 4448c2f1a551SMeelap Shah * Since the lifetime of a delegation isn't limited to that of an open, a 4449c2f1a551SMeelap Shah * client may quite reasonably hang on to a delegation as long as it has 4450c2f1a551SMeelap Shah * the inode cached. This becomes an obvious problem the first time a 4451c2f1a551SMeelap Shah * client's inode cache approaches the size of the server's total memory. 4452c2f1a551SMeelap Shah * 4453c2f1a551SMeelap Shah * For now we avoid this problem by imposing a hard limit on the number 4454c2f1a551SMeelap Shah * of delegations, which varies according to the server's memory size. 4455c2f1a551SMeelap Shah */ 4456c2f1a551SMeelap Shah static void 4457c2f1a551SMeelap Shah set_max_delegations(void) 4458c2f1a551SMeelap Shah { 4459c2f1a551SMeelap Shah /* 4460c2f1a551SMeelap Shah * Allow at most 4 delegations per megabyte of RAM. Quick 4461c2f1a551SMeelap Shah * estimates suggest that in the worst case (where every delegation 4462c2f1a551SMeelap Shah * is for a different inode), a delegation could take about 1.5K, 4463c2f1a551SMeelap Shah * giving a worst case usage of about 6% of memory. 4464c2f1a551SMeelap Shah */ 4465c2f1a551SMeelap Shah max_delegations = nr_free_buffer_pages() >> (20 - 2 - PAGE_SHIFT); 4466c2f1a551SMeelap Shah } 4467c2f1a551SMeelap Shah 4468ac4d8ff2SNeilBrown /* initialization to perform when the nfsd service is started: */ 4469ac4d8ff2SNeilBrown 447029ab23ccSJ. Bruce Fields static int 4471ac4d8ff2SNeilBrown __nfs4_state_start(void) 4472ac4d8ff2SNeilBrown { 4473b5a1a81eSJ. Bruce Fields int ret; 4474b5a1a81eSJ. Bruce Fields 44751da177e4SLinus Torvalds boot_time = get_seconds(); 4476af558e33SJ. Bruce Fields locks_start_grace(&nfsd4_manager); 44779a8db97eSMarc Eshel printk(KERN_INFO "NFSD: starting %ld-second grace period\n", 4478e46b498cSJ. Bruce Fields nfsd4_grace); 4479b5a1a81eSJ. Bruce Fields ret = set_callback_cred(); 4480b5a1a81eSJ. Bruce Fields if (ret) 4481b5a1a81eSJ. Bruce Fields return -ENOMEM; 448258da282bSNeilBrown laundry_wq = create_singlethread_workqueue("nfsd4"); 448329ab23ccSJ. Bruce Fields if (laundry_wq == NULL) 448429ab23ccSJ. Bruce Fields return -ENOMEM; 4485b5a1a81eSJ. Bruce Fields ret = nfsd4_create_callback_queue(); 4486b5a1a81eSJ. Bruce Fields if (ret) 4487b5a1a81eSJ. Bruce Fields goto out_free_laundry; 4488e46b498cSJ. Bruce Fields queue_delayed_work(laundry_wq, &laundromat_work, nfsd4_grace * HZ); 4489c2f1a551SMeelap Shah set_max_delegations(); 4490b5a1a81eSJ. Bruce Fields return 0; 4491b5a1a81eSJ. Bruce Fields out_free_laundry: 4492b5a1a81eSJ. Bruce Fields destroy_workqueue(laundry_wq); 4493b5a1a81eSJ. Bruce Fields return ret; 44941da177e4SLinus Torvalds } 44951da177e4SLinus Torvalds 449629ab23ccSJ. Bruce Fields int 449776a3550eSNeilBrown nfs4_state_start(void) 44981da177e4SLinus Torvalds { 4499190e4fbfSNeilBrown nfsd4_load_reboot_recovery_data(); 45004ad9a344SJeff Layton return __nfs4_state_start(); 45011da177e4SLinus Torvalds } 45021da177e4SLinus Torvalds 45031da177e4SLinus Torvalds static void 45041da177e4SLinus Torvalds __nfs4_state_shutdown(void) 45051da177e4SLinus Torvalds { 45061da177e4SLinus Torvalds int i; 45071da177e4SLinus Torvalds struct nfs4_client *clp = NULL; 45081da177e4SLinus Torvalds struct nfs4_delegation *dp = NULL; 45091da177e4SLinus Torvalds struct list_head *pos, *next, reaplist; 45101da177e4SLinus Torvalds 45111da177e4SLinus Torvalds for (i = 0; i < CLIENT_HASH_SIZE; i++) { 45121da177e4SLinus Torvalds while (!list_empty(&conf_id_hashtbl[i])) { 45131da177e4SLinus Torvalds clp = list_entry(conf_id_hashtbl[i].next, struct nfs4_client, cl_idhash); 45141da177e4SLinus Torvalds expire_client(clp); 45151da177e4SLinus Torvalds } 45161da177e4SLinus Torvalds while (!list_empty(&unconf_str_hashtbl[i])) { 45171da177e4SLinus Torvalds clp = list_entry(unconf_str_hashtbl[i].next, struct nfs4_client, cl_strhash); 45181da177e4SLinus Torvalds expire_client(clp); 45191da177e4SLinus Torvalds } 45201da177e4SLinus Torvalds } 45211da177e4SLinus Torvalds INIT_LIST_HEAD(&reaplist); 45221da177e4SLinus Torvalds spin_lock(&recall_lock); 45231da177e4SLinus Torvalds list_for_each_safe(pos, next, &del_recall_lru) { 45241da177e4SLinus Torvalds dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru); 45251da177e4SLinus Torvalds list_move(&dp->dl_recall_lru, &reaplist); 45261da177e4SLinus Torvalds } 45271da177e4SLinus Torvalds spin_unlock(&recall_lock); 45281da177e4SLinus Torvalds list_for_each_safe(pos, next, &reaplist) { 45291da177e4SLinus Torvalds dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru); 45301da177e4SLinus Torvalds list_del_init(&dp->dl_recall_lru); 45311da177e4SLinus Torvalds unhash_delegation(dp); 45321da177e4SLinus Torvalds } 45331da177e4SLinus Torvalds 4534190e4fbfSNeilBrown nfsd4_shutdown_recdir(); 45351da177e4SLinus Torvalds } 45361da177e4SLinus Torvalds 45371da177e4SLinus Torvalds void 45381da177e4SLinus Torvalds nfs4_state_shutdown(void) 45391da177e4SLinus Torvalds { 4540afe2c511STejun Heo cancel_delayed_work_sync(&laundromat_work); 45415e8d5c29SNeilBrown destroy_workqueue(laundry_wq); 45422c5e7615SJ. Bruce Fields locks_end_grace(&nfsd4_manager); 45431da177e4SLinus Torvalds nfs4_lock_state(); 45441da177e4SLinus Torvalds nfs4_release_reclaim(); 45451da177e4SLinus Torvalds __nfs4_state_shutdown(); 45461da177e4SLinus Torvalds nfs4_unlock_state(); 4547c3935e30SJ. Bruce Fields nfsd4_destroy_callback_queue(); 45481da177e4SLinus Torvalds } 4549