UbiquitousOS
/
OpenCloudOS-Kernel
mirror of https://gitee.com/OpenCloudOS/OpenCloudOS-Kernel.git
11
0
Fork 0
Code Issues Projects Releases Wiki Activity

NFSv4: Clean up the asynchronous delegation return 

Reuse the state management thread in order to return delegations when we
get a callback.

Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
This commit is contained in:
Trond Myklebust 2008-12-23 15:21:51 -05:00
parent b0d3ded1a2
commit 6411bd4a47
1 changed files with 19 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

73
fs/nfs/delegation.c
View File

@ -321,6 +321,12 @@ int nfs_inode_return_delegation(struct inode *inode)
return err; return err;
} }
static void nfs_mark_return_delegation(struct nfs_client *clp, struct nfs_delegation *delegation)
{
set_bit(NFS_DELEGATION_RETURN, &delegation->flags);
set_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state);
}
/* /*
* Return all delegations associated to a super block * Return all delegations associated to a super block
*/ */
@ -376,66 +382,25 @@ void nfs_handle_cb_pathdown(struct nfs_client *clp)
nfs_client_mark_return_all_delegations(clp); nfs_client_mark_return_all_delegations(clp);
} }
struct recall_threadargs {
struct inode *inode;
struct nfs_client *clp;
const nfs4_stateid *stateid;
struct completion started;
int result;
};
static int recall_thread(void *data)
{
struct recall_threadargs *args = (struct recall_threadargs *)data;
struct inode *inode = igrab(args->inode);
struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
struct nfs_inode *nfsi = NFS_I(inode);
struct nfs_delegation *delegation;
daemonize("nfsv4-delegreturn");
nfs_msync_inode(inode);
down_write(&nfsi->rwsem);
spin_lock(&clp->cl_lock);
delegation = nfs_detach_delegation_locked(nfsi, args->stateid);
if (delegation != NULL)
args->result = 0;
else
args->result = -ENOENT;
spin_unlock(&clp->cl_lock);
complete(&args->started);
nfs_delegation_claim_opens(inode, args->stateid);
up_write(&nfsi->rwsem);
nfs_msync_inode(inode);
if (delegation != NULL)
nfs_do_return_delegation(inode, delegation, 1);
iput(inode);
module_put_and_exit(0);
}
/* /*
* Asynchronous delegation recall! * Asynchronous delegation recall!
*/ */
int nfs_async_inode_return_delegation(struct inode *inode, const nfs4_stateid *stateid) int nfs_async_inode_return_delegation(struct inode *inode, const nfs4_stateid *stateid)
{ {
struct recall_threadargs data = { struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
.inode = inode, struct nfs_delegation *delegation;
.stateid = stateid,
};
int status;
init_completion(&data.started); rcu_read_lock();
__module_get(THIS_MODULE); delegation = rcu_dereference(NFS_I(inode)->delegation);
status = kernel_thread(recall_thread, &data, CLONE_KERNEL); if (delegation == NULL || memcmp(delegation->stateid.data, stateid->data,
if (status < 0) sizeof(delegation->stateid.data)) != 0) {
goto out_module_put; rcu_read_unlock();
wait_for_completion(&data.started); return -ENOENT;
return data.result; }
out_module_put: nfs_mark_return_delegation(clp, delegation);
module_put(THIS_MODULE); rcu_read_unlock();
return status; nfs_delegation_run_state_manager(clp);
return 0;
} }
/* /*