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

staging/lustre/ldlm: Remove unused ldlm_blocking_ast/_nocheck() 

All users are gone, and they were used on the server anyway.

Signed-off-by: Oleg Drokin <green@linuxhacker.ru>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
This commit is contained in:
Oleg Drokin 2015-10-01 00:12:35 -04:00 committed by Greg Kroah-Hartman
parent b8d84a762f
commit f954e778dc
2 changed files with 0 additions and 73 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
drivers/staging/lustre/lustre/include/lustre_dlm.h
View File

@ -1264,9 +1264,6 @@ int ldlm_expired_completion_wait(void *data);
* also used by client-side lock handlers to perform minimum level base
* processing.
* @{ */
int ldlm_blocking_ast_nocheck(struct ldlm_lock *lock);
int ldlm_blocking_ast(struct ldlm_lock *lock, struct ldlm_lock_desc *desc,
void *data, int flag);
int ldlm_completion_ast_async(struct ldlm_lock *lock, __u64 flags, void *data);
int ldlm_completion_ast(struct ldlm_lock *lock, __u64 flags, void *data);
/** @} ldlm_local_ast */

70
drivers/staging/lustre/lustre/ldlm/ldlm_request.c
View File

@ -287,76 +287,6 @@ noreproc:
}
EXPORT_SYMBOL(ldlm_completion_ast);
/**
* A helper to build a blocking AST function
*
* Perform a common operation for blocking ASTs:
* deferred lock cancellation.
*
* \param lock the lock blocking or canceling AST was called on
* \retval 0
* \see mdt_blocking_ast
* \see ldlm_blocking_ast
*/
int ldlm_blocking_ast_nocheck(struct ldlm_lock *lock)
{
int do_ast;
lock->l_flags |= LDLM_FL_CBPENDING;
do_ast = !lock->l_readers && !lock->l_writers;
unlock_res_and_lock(lock);
if (do_ast) {
struct lustre_handle lockh;
int rc;
LDLM_DEBUG(lock, "already unused, calling ldlm_cli_cancel");
ldlm_lock2handle(lock, &lockh);
rc = ldlm_cli_cancel(&lockh, LCF_ASYNC);
if (rc < 0)
CERROR("ldlm_cli_cancel: %d\n", rc);
} else {
LDLM_DEBUG(lock, "Lock still has references, will be cancelled later");
}
return 0;
}
EXPORT_SYMBOL(ldlm_blocking_ast_nocheck);
/**
* Server blocking AST
*
* ->l_blocking_ast() callback for LDLM locks acquired by server-side
* OBDs.
*
* \param lock the lock which blocks a request or cancelling lock
* \param desc unused
* \param data unused
* \param flag indicates whether this cancelling or blocking callback
* \retval 0
* \see ldlm_blocking_ast_nocheck
*/
int ldlm_blocking_ast(struct ldlm_lock *lock, struct ldlm_lock_desc *desc,
void *data, int flag)
{
if (flag == LDLM_CB_CANCELING) {
/* Don't need to do anything here. */
return 0;
}
lock_res_and_lock(lock);
/* Get this: if ldlm_blocking_ast is racing with intent_policy, such
* that ldlm_blocking_ast is called just before intent_policy method
* takes the lr_lock, then by the time we get the lock, we might not
* be the correct blocking function anymore. So check, and return
* early, if so. */
if (lock->l_blocking_ast != ldlm_blocking_ast) {
unlock_res_and_lock(lock);
return 0;
}
return ldlm_blocking_ast_nocheck(lock);
}
EXPORT_SYMBOL(ldlm_blocking_ast);
static void failed_lock_cleanup(struct ldlm_namespace *ns,
struct ldlm_lock *lock, int mode)
{