From 902773e514f21d3f51a03982fb80a5548d2a8661 Mon Sep 17 00:00:00 2001 From: Neil Brown Date: Mon, 22 Sep 2003 05:22:47 -0700 Subject: [PATCH] [PATCH] knfsd: nfsdv4 byte range locking - prepatation From: "William A.(Andy) Adamson" This renames some structures and functions that can be used for byte-range locking as well as for the exiting open share locks, and does some cleanup. --- fs/nfsd/nfs4proc.c | 16 +++---- fs/nfsd/nfs4state.c | 94 +++++++++++++++++++------------------- include/linux/nfsd/state.h | 16 +++---- 3 files changed, 63 insertions(+), 63 deletions(-) diff --git a/fs/nfsd/nfs4proc.c b/fs/nfsd/nfs4proc.c index 7d70b85b7f7f8..2ce48deceb2c0 100644 --- a/fs/nfsd/nfs4proc.c +++ b/fs/nfsd/nfs4proc.c @@ -355,7 +355,7 @@ nfsd4_read(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_read if (read->rd_offset >= OFFSET_MAX) return nfserr_inval; - nfsd4_lock_state(); + nfs4_lock_state(); status = nfs_ok; /* For stateid -1, we don't check share reservations. */ if (ONE_STATEID(&read->rd_stateid)) { @@ -388,7 +388,7 @@ nfsd4_read(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_read } status = nfs_ok; out: - nfsd4_unlock_state(); + nfs4_unlock_state(); read->rd_rqstp = rqstp; read->rd_fhp = current_fh; return status; @@ -464,7 +464,7 @@ nfsd4_setattr(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_se return status; } - nfsd4_lock_state(); + nfs4_lock_state(); if ((status = nfs4_preprocess_stateid_op(current_fh, &setattr->sa_stateid, CHECK_FH, &stp))) { @@ -476,11 +476,11 @@ nfsd4_setattr(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_se dprintk("NFSD: nfsd4_setattr: not opened for write!\n"); goto out; } - nfsd4_unlock_state(); + nfs4_unlock_state(); } return (nfsd_setattr(rqstp, current_fh, &setattr->sa_iattr, 0, (time_t)0)); out: - nfsd4_unlock_state(); + nfs4_unlock_state(); return status; } @@ -497,7 +497,7 @@ nfsd4_write(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_writ if (write->wr_offset >= OFFSET_MAX) return nfserr_inval; - nfsd4_lock_state(); + nfs4_lock_state(); if (ZERO_STATEID(stateid) || ONE_STATEID(stateid)) { dprintk("NFSD: nfsd4_write: zero stateid...\n"); if ((status = nfs4_share_conflict(current_fh, NFS4_SHARE_DENY_WRITE))) { @@ -519,7 +519,7 @@ nfsd4_write(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_writ } zero_stateid: - nfsd4_unlock_state(); + nfs4_unlock_state(); write->wr_bytes_written = write->wr_buflen; write->wr_how_written = write->wr_stable_how; p = (u32 *)write->wr_verifier; @@ -530,7 +530,7 @@ zero_stateid: write->wr_vec, write->wr_vlen, write->wr_buflen, &write->wr_how_written)); out: - nfsd4_unlock_state(); + nfs4_unlock_state(); return status; } diff --git a/fs/nfsd/nfs4state.c b/fs/nfsd/nfs4state.c index f1b5f1a334661..bbdb08bc30b95 100644 --- a/fs/nfsd/nfs4state.c +++ b/fs/nfsd/nfs4state.c @@ -80,13 +80,13 @@ u32 vfsclose = 0; static struct semaphore client_sema; void -nfsd4_lock_state(void) +nfs4_lock_state(void) { down(&client_sema); } void -nfsd4_unlock_state(void) +nfs4_unlock_state(void) { up(&client_sema); } @@ -386,7 +386,7 @@ nfsd4_setclientid(struct svc_rqst *rqstp, struct nfsd4_setclientid *setclid) strhashval = clientstr_hashval(clname.data, clname.len); conf = NULL; - down(&client_sema); + nfs4_lock_state(); list_for_each_safe(pos, next, &conf_str_hashtbl[strhashval]) { clp = list_entry(pos, struct nfs4_client, cl_strhash); if (!cmp_name(&clp->cl_name, &clname)) @@ -525,7 +525,7 @@ nfsd4_setclientid(struct svc_rqst *rqstp, struct nfsd4_setclientid *setclid) printk(KERN_INFO "NFSD: this client will not receive delegations\n"); status = nfs_ok; out: - up(&client_sema); + nfs4_unlock_state(); return status; } @@ -557,7 +557,7 @@ nfsd4_setclientid_confirm(struct svc_rqst *rqstp, struct nfsd4_setclientid_confi */ idhashval = clientid_hashval(clid->cl_id); - down(&client_sema); + nfs4_lock_state(); list_for_each_safe(pos, next, &conf_id_hashtbl[idhashval]) { clp = list_entry(pos, struct nfs4_client, cl_idhash); if (!cmp_clid(&clp->cl_clientid, clid)) @@ -657,7 +657,7 @@ nfsd4_setclientid_confirm(struct svc_rqst *rqstp, struct nfsd4_setclientid_confi goto out; out: /* XXX if status == nfs_ok, probe callback path */ - up(&client_sema); + nfs4_unlock_state(); return status; } @@ -683,17 +683,17 @@ static struct list_head ownerstr_hashtbl[OWNER_HASH_SIZE]; #define FILE_HASH_SIZE (1 << FILE_HASH_BITS) #define FILE_HASH_MASK (FILE_HASH_SIZE - 1) /* hash table for (open)nfs4_stateid */ -#define OPENSTATEID_HASH_BITS 10 -#define OPENSTATEID_HASH_SIZE (1 << OPENSTATEID_HASH_BITS) -#define OPENSTATEID_HASH_MASK (OPENSTATEID_HASH_SIZE - 1) +#define STATEID_HASH_BITS 10 +#define STATEID_HASH_SIZE (1 << STATEID_HASH_BITS) +#define STATEID_HASH_MASK (STATEID_HASH_SIZE - 1) #define file_hashval(x) \ hash_ptr(x, FILE_HASH_BITS) -#define openstateid_hashval(owner_id, file_id) \ - (((owner_id) + (file_id)) & OPENSTATEID_HASH_MASK) +#define stateid_hashval(owner_id, file_id) \ + (((owner_id) + (file_id)) & STATEID_HASH_MASK) static struct list_head file_hashtbl[FILE_HASH_SIZE]; -static struct list_head openstateid_hashtbl[OPENSTATEID_HASH_SIZE]; +static struct list_head stateid_hashtbl[STATEID_HASH_SIZE]; /* OPEN Share state helper functions */ static inline struct nfs4_file * @@ -768,7 +768,7 @@ alloc_init_stateowner(unsigned int strhashval, struct nfs4_client *clp, struct n INIT_LIST_HEAD(&sop->so_idhash); INIT_LIST_HEAD(&sop->so_strhash); INIT_LIST_HEAD(&sop->so_perclient); - INIT_LIST_HEAD(&sop->so_peropenstate); + INIT_LIST_HEAD(&sop->so_perfilestate); list_add(&sop->so_idhash, &ownerid_hashtbl[idhashval]); list_add(&sop->so_strhash, &ownerstr_hashtbl[strhashval]); list_add(&sop->so_perclient, &clp->cl_perclient); @@ -794,9 +794,9 @@ release_stateowner(struct nfs4_stateowner *sop) list_del_init(&sop->so_strhash); list_del_init(&sop->so_perclient); del_perclient++; - while (!list_empty(&sop->so_peropenstate)) { - stp = list_entry(sop->so_peropenstate.next, - struct nfs4_stateid, st_peropenstate); + while (!list_empty(&sop->so_perfilestate)) { + stp = list_entry(sop->so_perfilestate.next, + struct nfs4_stateid, st_perfilestate); release_stateid(stp); } free_stateowner(sop); @@ -804,13 +804,13 @@ release_stateowner(struct nfs4_stateowner *sop) static inline void init_stateid(struct nfs4_stateid *stp, struct nfs4_file *fp, struct nfs4_stateowner *sop, struct nfsd4_open *open) { - unsigned int hashval = openstateid_hashval(sop->so_id, fp->fi_id); + unsigned int hashval = stateid_hashval(sop->so_id, fp->fi_id); INIT_LIST_HEAD(&stp->st_hash); - INIT_LIST_HEAD(&stp->st_peropenstate); + INIT_LIST_HEAD(&stp->st_perfilestate); INIT_LIST_HEAD(&stp->st_perfile); - list_add(&stp->st_hash, &openstateid_hashtbl[hashval]); - list_add(&stp->st_peropenstate, &sop->so_peropenstate); + list_add(&stp->st_hash, &stateid_hashtbl[hashval]); + list_add(&stp->st_perfilestate, &sop->so_perfilestate); list_add_perfile++; list_add(&stp->st_perfile, &fp->fi_perfile); stp->st_stateowner = sop; @@ -829,7 +829,7 @@ release_stateid(struct nfs4_stateid *stp) { list_del_init(&stp->st_hash); list_del_perfile++; list_del_init(&stp->st_perfile); - list_del_init(&stp->st_peropenstate); + list_del_init(&stp->st_perfilestate); if(stp->st_vfs_set) { nfsd_close(&stp->st_vfs_file); vfsclose++; @@ -864,7 +864,7 @@ release_open_state(struct nfs4_stateid *stp, struct nfsd4_close *cl) * released by the laundromat service after the lease period * to enable us to handle CLOSE replay */ - if (sop->so_confirmed && list_empty(&sop->so_peropenstate)) { + if (sop->so_confirmed && list_empty(&sop->so_perfilestate)) { release_stateowner(sop); cl->cl_stateowner = NULL; } @@ -883,7 +883,7 @@ cmp_owner_str(struct nfs4_stateowner *sop, struct nfsd4_open *open) { /* search ownerstr_hashtbl[] for owner */ static int -find_stateowner_str(unsigned int hashval, struct nfsd4_open *open, struct nfs4_stateowner **op) { +find_openstateowner_str(unsigned int hashval, struct nfsd4_open *open, struct nfs4_stateowner **op) { struct list_head *pos, *next; struct nfs4_stateowner *local = NULL; @@ -1020,9 +1020,9 @@ nfsd4_process_open1(struct nfsd4_open *open) if (STALE_CLIENTID(&open->op_clientid)) goto out; - down(&client_sema); /* XXX need finer grained locking */ + nfs4_lock_state(); strhashval = ownerstr_hashval(clientid->cl_id, open->op_owner); - if (find_stateowner_str(strhashval, open, &sop)) { + if (find_openstateowner_str(strhashval, open, &sop)) { open->op_stateowner = sop; /* check for replay */ if (open->op_seqid == sop->so_seqid){ @@ -1078,7 +1078,7 @@ instantiate_new_owner: renew: renew_client(sop->so_client); out: - up(&client_sema); /*XXX need finer grained locking */ + nfs4_unlock_state(); return status; } @@ -1100,7 +1100,7 @@ nfsd4_process_open2(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nf ino = current_fh->fh_dentry->d_inode; - down(&client_sema); /*XXX need finer grained locking */ + nfs4_lock_state(); fi_hashval = file_hashval(ino); if (find_file(fi_hashval, ino, &fp)) { /* Search for conflicting share reservations */ @@ -1186,7 +1186,7 @@ out: if (!open->op_stateowner->so_confirmed) open->op_rflags |= NFS4_OPEN_RESULT_CONFIRM; - up(&client_sema); /*XXX need finer grained locking */ + nfs4_unlock_state(); return status; out_free: kfree(stp); @@ -1204,7 +1204,7 @@ nfsd4_renew(clientid_t *clid) unsigned int idhashval; int status; - down(&client_sema); + nfs4_lock_state(); printk("process_renew(%08x/%08x): starting\n", clid->cl_boot, clid->cl_id); status = nfserr_stale_clientid; @@ -1234,7 +1234,7 @@ nfsd4_renew(clientid_t *clid) printk("nfsd4_renew: clientid not found!\n"); status = nfserr_expired; out: - up(&client_sema); + nfs4_unlock_state(); return status; } @@ -1246,7 +1246,7 @@ nfs4_laundromat(void) time_t cutoff = get_seconds() - NFSD_LEASE_TIME; time_t t, return_val = NFSD_LEASE_TIME; - down(&client_sema); + nfs4_lock_state(); dprintk("NFSD: laundromat service - starting, examining clients\n"); list_for_each_safe(pos, next, &client_lru) { @@ -1263,7 +1263,7 @@ nfs4_laundromat(void) } if (return_val < NFSD_LAUNDROMAT_MINTIMEOUT) return_val = NFSD_LAUNDROMAT_MINTIMEOUT; - up(&client_sema); + nfs4_unlock_state(); return return_val; } @@ -1277,7 +1277,7 @@ laundromat_main(void *not_used) schedule_delayed_work(&laundromat_work, t*HZ); } -/* search openstateid_hashtbl[] for stateid */ +/* search stateid_hashtbl[] for stateid */ struct nfs4_stateid * find_stateid(stateid_t *stid) { @@ -1285,9 +1285,9 @@ find_stateid(stateid_t *stid) struct nfs4_stateid *local = NULL; u32 st_id = stid->si_stateownerid; u32 f_id = stid->si_fileid; - unsigned int hashval = openstateid_hashval(st_id, f_id); + unsigned int hashval = stateid_hashval(st_id, f_id); - list_for_each_safe(pos, next, &openstateid_hashtbl[hashval]) { + list_for_each_safe(pos, next, &stateid_hashtbl[hashval]) { local = list_entry(pos, struct nfs4_stateid, st_hash); if((local->st_stateid.si_stateownerid == st_id) && (local->st_stateid.si_fileid == f_id)) @@ -1298,7 +1298,7 @@ find_stateid(stateid_t *stid) /* search ownerid_hashtbl[] for stateid owner (stateid->si_stateownerid) */ struct nfs4_stateowner * -find_stateowner_id(u32 st_id) { +find_openstateowner_id(u32 st_id) { struct list_head *pos, *next; struct nfs4_stateowner *local = NULL; unsigned int hashval = ownerid_hashval(st_id); @@ -1474,7 +1474,7 @@ no_nfs4_stateid: * starting by trying to look up the stateowner. * If stateowner is not found - stateid is bad. */ - if (!(sop = find_stateowner_id(stateid->si_stateownerid))) { + if (!(sop = find_openstateowner_id(stateid->si_stateownerid))) { printk("NFSD: preprocess_seqid_op: no stateowner or nfs4_stateid!\n"); status = nfserr_bad_stateid; goto out; @@ -1503,7 +1503,7 @@ nfsd4_open_confirm(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfs (int)current_fh->fh_dentry->d_name.len, current_fh->fh_dentry->d_name.name); oc->oc_stateowner = NULL; - down(&client_sema); /* XXX need finer grained locking */ + nfs4_lock_state(); if ((status = nfs4_preprocess_seqid_op(current_fh, oc->oc_seqid, &oc->oc_req_stateid, @@ -1523,7 +1523,7 @@ nfsd4_open_confirm(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfs stp->st_stateid.si_generation); status = nfs_ok; out: - up(&client_sema); + nfs4_unlock_state(); return status; } int @@ -1536,7 +1536,7 @@ nfsd4_open_downgrade(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct n (int)current_fh->fh_dentry->d_name.len, current_fh->fh_dentry->d_name.name); - down(&client_sema); /* XXX need finer grained locking */ + nfs4_lock_state(); if ((status = nfs4_preprocess_seqid_op(current_fh, od->od_seqid, &od->od_stateid, CHECK_FH, &od->od_stateowner, &stp))) @@ -1561,7 +1561,7 @@ nfsd4_open_downgrade(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct n memcpy(&od->od_stateid, &stp->st_stateid, sizeof(stateid_t)); status = nfs_ok; out: - up(&client_sema); + nfs4_unlock_state(); return status; } @@ -1575,7 +1575,7 @@ nfsd4_close(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_clos (int)current_fh->fh_dentry->d_name.len, current_fh->fh_dentry->d_name.name); - down(&client_sema); /* XXX need finer grained locking */ + nfs4_lock_state(); if ((status = nfs4_preprocess_seqid_op(current_fh, close->cl_seqid, &close->cl_stateid, CHECK_FH, @@ -1591,7 +1591,7 @@ nfsd4_close(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_clos /* release_open_state() calls nfsd_close() if needed */ release_open_state(stp,close); out: - up(&client_sema); + nfs4_unlock_state(); return status; } @@ -1615,8 +1615,8 @@ nfs4_state_init(void) INIT_LIST_HEAD(&ownerstr_hashtbl[i]); INIT_LIST_HEAD(&ownerid_hashtbl[i]); } - for (i = 0; i < OPENSTATEID_HASH_SIZE; i++) { - INIT_LIST_HEAD(&openstateid_hashtbl[i]); + for (i = 0; i < STATEID_HASH_SIZE; i++) { + INIT_LIST_HEAD(&stateid_hashtbl[i]); } memset(&zerostateid, 0, sizeof(stateid_t)); memset(&onestateid, ~0, sizeof(stateid_t)); @@ -1665,7 +1665,7 @@ __nfs4_state_shutdown(void) void nfs4_state_shutdown(void) { - down(&client_sema); + nfs4_lock_state(); __nfs4_state_shutdown(); - up(&client_sema); + nfs4_unlock_state(); } diff --git a/include/linux/nfsd/state.h b/include/linux/nfsd/state.h index b4d10b7dcc168..c0975c670e421 100644 --- a/include/linux/nfsd/state.h +++ b/include/linux/nfsd/state.h @@ -119,14 +119,14 @@ struct nfs4_replay { /* * nfs4_stateowner can either be an open_owner, or (eventually) a lock_owner * -* o so_peropenstate list is used to ensure no dangling nfs4_stateid +* o so_perfilestate list is used to ensure no dangling nfs4_stateid * reverences when we release a stateowner. */ struct nfs4_stateowner { struct list_head so_idhash; /* hash by so_id */ struct list_head so_strhash; /* hash by op_name */ struct list_head so_perclient; /* nfs4_client->cl_perclient */ - struct list_head so_peropenstate; /* list: nfs4_stateid */ + struct list_head so_perfilestate; /* list: nfs4_stateid */ u32 so_id; struct nfs4_client * so_client; u32 so_seqid; @@ -145,7 +145,7 @@ struct nfs4_file { struct list_head fi_perfile; /* list: nfs4_stateid */ struct inode *fi_inode; u32 fi_id; /* used with stateowner->so_id - * for openstateid_hashtbl hash */ + * for stateid_hashtbl hash */ }; /* @@ -155,9 +155,9 @@ struct nfs4_file { */ struct nfs4_stateid { - struct list_head st_hash; /* openstateid_hashtbl[]*/ - struct list_head st_perfile; /* file_hashtbl[]*/ - struct list_head st_peropenstate; /* nfs4_stateowner->so_peropenstate */ + struct list_head st_hash; + struct list_head st_perfile; + struct list_head st_perfilestate; struct nfs4_stateowner * st_stateowner; struct nfs4_file * st_file; stateid_t st_stateid; @@ -183,6 +183,6 @@ extern int nfs4_preprocess_stateid_op(struct svc_fh *current_fh, stateid_t *stateid, int flags, struct nfs4_stateid **stpp); extern int nfs4_share_conflict(struct svc_fh *current_fh, unsigned int deny_type); -extern void nfsd4_lock_state(void); -extern void nfsd4_unlock_state(void); +extern void nfs4_lock_state(void); +extern void nfs4_unlock_state(void); #endif /* NFSD4_STATE_H */ -- 2.53.0