From 39b7bcc51e40d95636973375b061c3e5c7556267 Mon Sep 17 00:00:00 2001 From: Trond Myklebust Date: Tue, 7 Oct 2003 07:46:31 -0400 Subject: [PATCH] Rename the struct "nfs4_shareowner". The name was confusing and didn't really relate to any of the RFCs. Replace with the more descriptive "nfs4_state_owner". --- fs/nfs/inode.c | 6 +++--- fs/nfs/nfs4proc.c | 32 ++++++++++++++++---------------- fs/nfs/nfs4state.c | 26 +++++++++++++------------- include/linux/nfs_fs.h | 26 +++++++++++++------------- 4 files changed, 45 insertions(+), 45 deletions(-) diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c index 2607af8c6f1eb..ec54a826cd177 100644 --- a/fs/nfs/inode.c +++ b/fs/nfs/inode.c @@ -152,9 +152,9 @@ nfs_clear_inode(struct inode *inode) if (cred) put_rpccred(cred); /* Clean up the V4 state */ - nfs4_put_shareowner(inode, nfsi->wo_owner); - nfs4_put_shareowner(inode, nfsi->ro_owner); - nfs4_put_shareowner(inode, nfsi->rw_owner); + nfs4_put_state_owner(inode, nfsi->wo_owner); + nfs4_put_state_owner(inode, nfsi->ro_owner); + nfs4_put_state_owner(inode, nfsi->rw_owner); } void diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c index c778e648b7f3c..31bb4b9650d4a 100644 --- a/fs/nfs/nfs4proc.c +++ b/fs/nfs/nfs4proc.c @@ -556,9 +556,9 @@ process_cinfo(struct nfs4_change_info *info, struct nfs_fattr *fattr) int nfs4_do_open(struct inode *dir, struct qstr *name, int flags, struct iattr *sattr, struct nfs_fattr *fattr, - struct nfs_fh *fhandle, struct nfs4_shareowner **spp) + struct nfs_fh *fhandle, struct nfs4_state_owner **spp) { - struct nfs4_shareowner *sp; + struct nfs4_state_owner *sp; struct nfs_server *server = NFS_SERVER(dir); struct nfs4_change_info d_cinfo; int status; @@ -600,8 +600,8 @@ nfs4_do_open(struct inode *dir, struct qstr *name, int flags, }; status = -ENOMEM; - if (!(sp = nfs4_get_shareowner(dir))) { - dprintk("nfs4_do_open: nfs4_get_shareowner failed!\n"); + if (!(sp = nfs4_get_state_owner(dir))) { + dprintk("nfs4_do_open: nfs4_get_state_owner failed!\n"); goto out; } if (o_arg.createmode & NFS4_CREATE_EXCLUSIVE){ @@ -664,7 +664,7 @@ out: int nfs4_do_setattr(struct nfs_server *server, struct nfs_fattr *fattr, struct nfs_fh *fhandle, struct iattr *sattr, - struct nfs4_shareowner *sp) + struct nfs4_state_owner *sp) { struct nfs4_getattr getattr = { .gt_bmval = nfs4_fattr_bitmap, @@ -706,7 +706,7 @@ nfs4_do_setattr(struct nfs_server *server, struct nfs_fattr *fattr, * stateid's in the inode. */ int -nfs4_do_close(struct inode *inode, struct nfs4_shareowner *sp) +nfs4_do_close(struct inode *inode, struct nfs4_state_owner *sp) { int status = 0; struct nfs_closeargs arg = { @@ -728,7 +728,7 @@ nfs4_do_close(struct inode *inode, struct nfs4_shareowner *sp) status = rpc_call_sync(NFS_SERVER(inode)->client, &msg, 0); /* hmm. we are done with the inode, and in the process of freeing - * the shareowner. we keep this around to process errors + * the state_owner. we keep this around to process errors */ nfs4_increment_seqid(status, sp); up(&sp->so_sema); @@ -855,7 +855,7 @@ nfs4_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr, { struct inode * inode = dentry->d_inode; int size_change = sattr->ia_valid & ATTR_SIZE; - struct nfs4_shareowner *sp = NULL; + struct nfs4_state_owner *sp = NULL; int status; fattr->valid = 0; @@ -1000,7 +1000,7 @@ nfs4_proc_read(struct inode *inode, struct rpc_cred *cred, struct page *page, int *eofp) { struct nfs_server *server = NFS_SERVER(inode); - struct nfs4_shareowner *sp; + struct nfs4_state_owner *sp; uint64_t offset = page_offset(page) + base; struct nfs_readargs arg = { .fh = NFS_FH(inode), @@ -1054,7 +1054,7 @@ nfs4_proc_write(struct inode *inode, struct rpc_cred *cred, struct page *page, struct nfs_writeverf *verf) { struct nfs_server *server = NFS_SERVER(inode); - struct nfs4_shareowner *sp; + struct nfs4_state_owner *sp; uint64_t offset = page_offset(page) + base; struct nfs_writeargs arg = { .fh = NFS_FH(inode), @@ -1115,7 +1115,7 @@ nfs4_proc_create(struct inode *dir, struct qstr *name, struct iattr *sattr, int flags, struct nfs_fh *fhandle, struct nfs_fattr *fattr) { int oflags; - struct nfs4_shareowner *sp = NULL; + struct nfs4_state_owner *sp = NULL; int status; oflags = O_RDONLY | O_CREAT | (flags & O_EXCL); @@ -1444,7 +1444,7 @@ nfs4_proc_read_setup(struct nfs_read_data *data, unsigned int count) }; struct inode *inode = data->inode; struct nfs_page *req = nfs_list_entry(data->pages.next); - struct nfs4_shareowner *sp; + struct nfs4_state_owner *sp; int flags; data->args.fh = NFS_FH(inode); @@ -1522,7 +1522,7 @@ nfs4_proc_write_setup(struct nfs_write_data *data, unsigned int count, int how) }; struct inode *inode = data->inode; struct nfs_page *req = nfs_list_entry(data->pages.next); - struct nfs4_shareowner *sp; + struct nfs4_state_owner *sp; int stable; int flags; @@ -1699,14 +1699,14 @@ nfs4_proc_file_open(struct inode *inode, struct file *filp) * This ugliness will go away with lookup-intent... */ while (!nfs4_get_inode_share(inode, flags)) { - struct nfs4_shareowner *sp = NULL; + struct nfs4_state_owner *sp = NULL; status = nfs4_do_open(dir, &dentry->d_name, flags, NULL, NULL, NULL, &sp); if (status) { - nfs4_put_shareowner(inode,sp); + nfs4_put_state_owner(inode,sp); break; } if (nfs4_set_inode_share(inode, sp, flags)) - nfs4_put_shareowner(inode,sp); + nfs4_put_state_owner(inode,sp); } out: unlock_kernel(); diff --git a/fs/nfs/nfs4state.c b/fs/nfs/nfs4state.c index e8a1c2070876c..6249f8f010ee4 100644 --- a/fs/nfs/nfs4state.c +++ b/fs/nfs/nfs4state.c @@ -88,10 +88,10 @@ nfs4_alloc_lockowner_id(struct nfs4_client *clp) } /* - * nfs4_get_shareowner(): this is called on the OPEN or CREATE path to - * obtain a new shareowner. + * nfs4_get_state_owner(): this is called on the OPEN or CREATE path to + * obtain a new state_owner. * - * There are three shareowners (open_owner4 in rfc3010) per inode, + * There are three state_owners (open_owner4 in rfc3010) per inode, * one for each possible combination of share lock access. Since * Linux does not support the deny access type, there are * three (not 9) referenced by the nfs_inode: @@ -100,16 +100,16 @@ nfs4_alloc_lockowner_id(struct nfs4_client *clp) * O_RDONLY: inode->ro_owner * O_RDWR: inode->rw_owner * - * We create a new shareowner the first time a file is OPENed with + * We create a new state_owner the first time a file is OPENed with * one of the above shares. All other OPENs with a similar * share use the single stateid associated with the inode. * */ -struct nfs4_shareowner * -nfs4_get_shareowner(struct inode *dir) +struct nfs4_state_owner * +nfs4_get_state_owner(struct inode *dir) { struct nfs4_client *clp; - struct nfs4_shareowner *sp; + struct nfs4_state_owner *sp; sp = kmalloc(sizeof(*sp),GFP_KERNEL); if (!sp) @@ -124,11 +124,11 @@ nfs4_get_shareowner(struct inode *dir) } /* - * Called for each non-null inode shareowner in nfs_clear_inode, + * Called for each non-null inode state_owner in nfs_clear_inode, * or if nfs4_do_open fails. */ void -nfs4_put_shareowner(struct inode *inode, struct nfs4_shareowner *sp) +nfs4_put_state_owner(struct inode *inode, struct nfs4_state_owner *sp) { if (!sp) return; @@ -145,7 +145,7 @@ nfs4_put_shareowner(struct inode *inode, struct nfs4_shareowner *sp) * see comments nfs_fs.h:seqid_mutating_error() */ void -nfs4_increment_seqid(u32 status, struct nfs4_shareowner *sp) +nfs4_increment_seqid(u32 status, struct nfs4_state_owner *sp) { if (status == NFS_OK || seqid_mutating_err(status)) sp->so_seqid++; @@ -155,7 +155,7 @@ nfs4_increment_seqid(u32 status, struct nfs4_shareowner *sp) * Called by nfs4_proc_open to set the appropriate stateid */ int -nfs4_set_inode_share(struct inode * inode, struct nfs4_shareowner *sp, unsigned int open_flags) +nfs4_set_inode_share(struct inode * inode, struct nfs4_state_owner *sp, unsigned int open_flags) { struct nfs_inode *nfsi = NFS_I(inode); @@ -187,7 +187,7 @@ nfs4_set_inode_share(struct inode * inode, struct nfs4_shareowner *sp, unsigned * Called by nfs4_proc_open. */ int -nfs4_test_shareowner(struct inode *inode, unsigned int open_flags) +nfs4_test_state_owner(struct inode *inode, unsigned int open_flags) { struct nfs_inode *nfsi = NFS_I(inode); @@ -207,7 +207,7 @@ nfs4_test_shareowner(struct inode *inode, unsigned int open_flags) return 1; } -struct nfs4_shareowner * +struct nfs4_state_owner * nfs4_get_inode_share(struct inode * inode, unsigned int open_flags) { struct nfs_inode *nfsi = NFS_I(inode); diff --git a/include/linux/nfs_fs.h b/include/linux/nfs_fs.h index 7a87a46878a3d..e7aa4552b0a6b 100644 --- a/include/linux/nfs_fs.h +++ b/include/linux/nfs_fs.h @@ -157,9 +157,9 @@ struct nfs_inode { #ifdef CONFIG_NFS_V4 /* NFSv4 state */ - struct nfs4_shareowner *ro_owner; - struct nfs4_shareowner *wo_owner; - struct nfs4_shareowner *rw_owner; + struct nfs4_state_owner *ro_owner; + struct nfs4_state_owner *wo_owner; + struct nfs4_state_owner *rw_owner; #endif /* CONFIG_NFS_V4*/ struct inode vfs_inode; @@ -477,12 +477,12 @@ struct nfs4_client { }; /* -* The ->so_sema is held during all shareowner seqid-mutating operations: +* The ->so_sema is held during all state_owner seqid-mutating operations: * OPEN, OPEN_DOWNGRADE, and CLOSE. * Its purpose is to properly serialize so_seqid, as mandated by * the protocol. */ -struct nfs4_shareowner { +struct nfs4_state_owner { u32 so_id; /* 32-bit identifier, unique */ struct semaphore so_sema; u32 so_seqid; /* protected by so_sema */ @@ -493,7 +493,7 @@ struct nfs4_shareowner { /* nfs4proc.c */ extern int nfs4_proc_renew(struct nfs_server *server); -extern int nfs4_do_close(struct inode *inode, struct nfs4_shareowner *sp); +extern int nfs4_do_close(struct inode *inode, struct nfs4_state_owner *sp); /* nfs4renewd.c */ extern int nfs4_init_renewd(struct nfs_server *server); @@ -501,13 +501,13 @@ extern int nfs4_init_renewd(struct nfs_server *server); /* nfs4state.c */ extern struct nfs4_client *nfs4_get_client(void); extern void nfs4_put_client(struct nfs4_client *clp); -extern struct nfs4_shareowner * nfs4_get_shareowner(struct inode *inode); -void nfs4_put_shareowner(struct inode *inode, struct nfs4_shareowner *sp); +extern struct nfs4_state_owner * nfs4_get_state_owner(struct inode *inode); +void nfs4_put_state_owner(struct inode *inode, struct nfs4_state_owner *sp); extern int nfs4_set_inode_share(struct inode * inode, - struct nfs4_shareowner *sp, unsigned int flags); -extern void nfs4_increment_seqid(u32 status, struct nfs4_shareowner *sp); -extern int nfs4_test_shareowner(struct inode *inode, unsigned int open_flags); -struct nfs4_shareowner * nfs4_get_inode_share(struct inode * inode, unsigned int open_flags); + struct nfs4_state_owner *sp, unsigned int flags); +extern void nfs4_increment_seqid(u32 status, struct nfs4_state_owner *sp); +extern int nfs4_test_state_owner(struct inode *inode, unsigned int open_flags); +struct nfs4_state_owner * nfs4_get_inode_share(struct inode * inode, unsigned int open_flags); @@ -537,7 +537,7 @@ destroy_nfsv4_state(struct nfs_server *server) #else #define create_nfsv4_state(server, data) 0 #define destroy_nfsv4_state(server) do { } while (0) -#define nfs4_put_shareowner(inode, owner) do { } while (0) +#define nfs4_put_state_owner(inode, owner) do { } while (0) #endif #endif /* __KERNEL__ */ -- 2.53.0