lock->l_granted_mode);
ldlm_flock_add_lock(res, &res->lr_granted, new2);
- LDLM_LOCK_RELEASE(new2);
+ ldlm_lock_put(new2);
break;
}
struct ldlm_flock *flock;
lock = hlist_entry(hnode, struct ldlm_lock, l_exp_flock_hash);
- LDLM_LOCK_GET(lock);
+ ldlm_lock_get(lock);
flock = &lock->l_policy_data.l_flock;
LASSERT(flock->blocking_export != NULL);
flock->blocking_owner = 0;
flock->blocking_export = NULL;
}
- LDLM_LOCK_RELEASE(lock);
+ ldlm_lock_put(lock);
}
static struct cfs_hash_ops ldlm_export_flock_ops = {
/* drop reference from hashtable only for first destroy */
if (first) {
- LDLM_LOCK_RELEASE(lock);
+ ldlm_lock_put(lock);
}
EXIT;
}
first = ldlm_lock_destroy_internal(lock);
/* drop reference from hashtable only for first destroy */
if (first) {
- LDLM_LOCK_RELEASE(lock);
+ ldlm_lock_put(lock);
}
EXIT;
}
if (!rc)
return lock;
ldlm_lock_destroy(lock);
- LDLM_LOCK_RELEASE(lock);
+ ldlm_lock_put(lock);
return NULL;
}
EXPORT_SYMBOL(ldlm_lock_new_testing);
if (lock->l_export != NULL && lock->l_export->exp_failed) {
CDEBUG(D_INFO, "lock export failed: lock %p, exp %p\n",
lock, lock->l_export);
- LDLM_LOCK_PUT(lock);
+ ldlm_lock_put(lock);
RETURN(NULL);
}
if (unlikely(ldlm_is_destroyed(lock))) {
unlock_res_and_lock(lock);
CDEBUG(D_INFO, "lock already destroyed: lock %p\n", lock);
- LDLM_LOCK_PUT(lock);
+ ldlm_lock_put(lock);
RETURN(NULL);
}
if (flags != 0) {
if ((lock->l_flags & flags) != 0) {
unlock_res_and_lock(lock);
- LDLM_LOCK_PUT(lock);
+ ldlm_lock_put(lock);
RETURN(NULL);
}
*/
if (list_empty(&lock->l_bl_ast)) {
list_add(&lock->l_bl_ast, work_list);
- LDLM_LOCK_GET(lock);
+ ldlm_lock_get(lock);
}
LASSERT(lock->l_blocking_lock == NULL);
- lock->l_blocking_lock = LDLM_LOCK_GET(new);
+ lock->l_blocking_lock = ldlm_lock_get(new);
}
}
LDLM_DEBUG(lock, "lock granted; sending completion AST.");
LASSERT(list_empty(&lock->l_cp_ast));
list_add(&lock->l_cp_ast, work_list);
- LDLM_LOCK_GET(lock);
+ ldlm_lock_get(lock);
}
}
lock = ldlm_handle2lock(lockh);
LASSERTF(lock != NULL, "Non-existing lock: %#llx\n", lockh->cookie);
ldlm_lock_addref_internal(lock, mode);
- LDLM_LOCK_PUT(lock);
+ ldlm_lock_put(lock);
}
EXPORT_SYMBOL(ldlm_lock_addref);
if (mode & (LCK_EX | LCK_CW | LCK_PW | LCK_GROUP | LCK_COS | LCK_TXN)) {
lock->l_writers++;
}
- LDLM_LOCK_GET(lock);
+ ldlm_lock_get(lock);
LDLM_DEBUG(lock, "ldlm_lock_addref(%s)", ldlm_lockname[mode]);
}
result = 0;
}
unlock_res_and_lock(lock);
- LDLM_LOCK_PUT(lock);
+ ldlm_lock_put(lock);
}
return result;
}
lock->l_writers--;
}
- LDLM_LOCK_RELEASE(lock); /* matches the LDLM_LOCK_GET() in addref */
+ ldlm_lock_put(lock); /* matches the LDLM_LOCK_GET() in addref */
}
/**
"final decref done on %sCBPENDING lock",
mask & D_WARNING ? "non-local " : "");
- LDLM_LOCK_GET(lock); /* dropped by bl thread */
+ ldlm_lock_get(lock); /* dropped by bl thread */
ldlm_lock_remove_from_lru(lock);
unlock_res_and_lock(lock);
LASSERTF(lock != NULL, "Non-existing lock: %#llx\n", lockh->cookie);
ldlm_lock_decref_internal(lock, mode);
- LDLM_LOCK_PUT(lock);
+ ldlm_lock_put(lock);
}
EXPORT_SYMBOL(ldlm_lock_decref);
ldlm_set_cbpending(lock);
unlock_res_and_lock(lock);
ldlm_lock_decref_internal(lock, mode);
- LDLM_LOCK_PUT(lock);
+ ldlm_lock_put(lock);
}
EXPORT_SYMBOL(ldlm_lock_decref_and_cancel);
*/
if ((data->lmd_flags & LDLM_FL_TEST_LOCK) ||
(ldlm_is_cbpending(lock) && (data->lmd_match & LDLM_MATCH_GROUP))) {
- LDLM_LOCK_GET(lock);
+ ldlm_lock_get(lock);
ldlm_lock_touch_in_lru(lock);
} else {
ldlm_lock_addref_internal_nolock(lock, match);
if (group_lock) {
l_wait_event_abortable(group_lock->l_waitq,
ldlm_is_destroyed(lock));
- LDLM_LOCK_RELEASE(lock);
+ ldlm_lock_put(lock);
goto repeat;
}
ldlm_resource_putref(res);
out_fail_match:
if (flags & LDLM_FL_TEST_LOCK)
- LDLM_LOCK_RELEASE(lock);
+ ldlm_lock_put(lock);
else if (!matched)
ldlm_lock_decref_internal(lock, mode);
}
res_id->name[3] : policy->l_extent.end);
}
if (data.lmd_old != NULL)
- LDLM_LOCK_PUT(data.lmd_old);
+ ldlm_lock_put(data.lmd_old);
return matched;
}
out:
if (lock != NULL) {
unlock_res_and_lock(lock);
- LDLM_LOCK_PUT(lock);
+ ldlm_lock_put(lock);
}
return mode;
}
out:
ldlm_lock_destroy(lock);
- LDLM_LOCK_RELEASE(lock);
+ ldlm_lock_put(lock);
RETURN(ERR_PTR(rc));
}
*/
if (lock != *lockp) {
ldlm_lock_destroy(lock);
- LDLM_LOCK_RELEASE(lock);
+ ldlm_lock_put(lock);
}
*flags |= LDLM_FL_LOCK_CHANGED;
RETURN(0);
ldlm_clear_ast_sent(lock);
LASSERT(lock->l_bl_ast_run == 0);
ldlm_clear_blocking_lock(lock);
- LDLM_LOCK_RELEASE(lock);
+ ldlm_lock_put(lock);
}
EXIT;
}
*/
if (!ldlm_is_ast_sent(lock)) {
unlock_res_and_lock(lock);
- LDLM_LOCK_RELEASE(lock);
+ ldlm_lock_put(lock);
RETURN(0);
}
rc = lock->l_blocking_ast(lock, &d, (void *)arg, LDLM_CB_BLOCKING);
- LDLM_LOCK_RELEASE(lock);
+ ldlm_lock_put(lock);
RETURN(rc);
}
desc.l_granted_mode = 0;
rc = lock->l_blocking_ast(lock, &desc, (void *)arg, LDLM_CB_BLOCKING);
- LDLM_LOCK_RELEASE(lock);
+ ldlm_lock_put(lock);
RETURN(rc);
}
else if (rc == -ELDLM_NO_LOCK_DATA)
ldlm_lvbo_update(lock->l_resource, lock, NULL, 1);
- LDLM_LOCK_RELEASE(lock);
+ ldlm_lock_put(lock);
if (gl_work->gl_flags & LDLM_GL_WORK_SLAB_ALLOCATED)
OBD_SLAB_FREE_PTR(gl_work, ldlm_glimpse_work_kmem);
else
if (completion_callback != NULL)
rc = completion_callback(lock, 0, (void *)arg);
- LDLM_LOCK_RELEASE(lock);
+ ldlm_lock_put(lock);
RETURN(rc);
}
lock->l_ast_data = data;
if (lock->l_ast_data == data)
rc = 0;
- LDLM_LOCK_PUT(lock);
+ ldlm_lock_put(lock);
}
RETURN(rc);
}
struct obd_export *exp = ecl->ecl_exp;
struct ldlm_lock *lock = cfs_hash_object(hs, hnode);
- LDLM_LOCK_GET(lock);
+ ldlm_lock_get(lock);
ldlm_cancel_lock_for_export(exp, lock, ecl);
- LDLM_LOCK_RELEASE(lock);
+ ldlm_lock_put(lock);
return 0;
}
if (!list_empty(&exp->exp_bl_list)) {
lock = list_first_entry(&exp->exp_bl_list,
struct ldlm_lock, l_exp_list);
- LDLM_LOCK_GET(lock);
+ ldlm_lock_get(lock);
list_del_init(&lock->l_exp_list);
} else {
lock = NULL;
break;
ldlm_cancel_lock_for_export(exp, lock, &ecl);
- LDLM_LOCK_RELEASE(lock);
+ ldlm_lock_put(lock);
}
lu_env_fini(&env);
LDLM_DEBUG_LIMIT(level, lock, "###");
- LDLM_LOCK_PUT(lock);
+ ldlm_lock_put(lock);
}
EXPORT_SYMBOL(ldlm_lock_dump_handle);
* ldlm_add_waiting_lock() or
* ldlm_failed_ast()
*/
- LDLM_LOCK_RELEASE(lock);
+ ldlm_lock_put(lock);
continue;
}
* release the lock refcount where
* waiting_locks_callback() founds
*/
- LDLM_LOCK_RELEASE(lock);
+ ldlm_lock_put(lock);
continue;
}
export = class_export_lock_get(lock->l_export, lock);
* release extra ref grabbed by ldlm_add_waiting_lock()
* or ldlm_failed_ast()
*/
- LDLM_LOCK_RELEASE(lock);
+ ldlm_lock_put(lock);
spin_lock_bh(&waiting_locks_spinlock);
}
* grab ref on the lock if it has been added to the
* waiting list
*/
- LDLM_LOCK_GET(lock);
+ ldlm_lock_get(lock);
}
spin_unlock_bh(&waiting_locks_spinlock);
* release lock ref if it has indeed been removed
* from a list
*/
- LDLM_LOCK_RELEASE(lock);
+ ldlm_lock_put(lock);
}
LDLM_DEBUG(lock, "%s", ret == 0 ? "wasn't waiting" : "removed");
* the lock was not in any list, grab an extra ref before adding
* the lock to the expired list
*/
- LDLM_LOCK_GET(lock);
+ ldlm_lock_get(lock);
/* differentiate it from expired locks */
lock->l_callback_timestamp = 0;
list_add(&lock->l_pending_chain, &expired_lock_list);
}
/* release extra reference taken in ldlm_ast_fini() */
- LDLM_LOCK_RELEASE(lock);
+ ldlm_lock_put(lock);
if (rc == -ERESTART)
atomic_inc(&arg->restart);
if (rc == 0)
atomic_inc(&arg->restart);
} else {
- LDLM_LOCK_GET(lock);
+ ldlm_lock_get(lock);
ptlrpc_set_add_req(arg->set, req);
}
ldlm_reprocess_all(lock->l_resource,
lock->l_policy_data.l_inodebits.bits);
- LDLM_LOCK_RELEASE(lock);
+ ldlm_lock_put(lock);
}
LDLM_DEBUG_NOLOCK("server-side enqueue handler END (lock %p, rc %d)",
void ldlm_clear_blocking_lock(struct ldlm_lock *lock)
{
if (lock->l_blocking_lock) {
- LDLM_LOCK_RELEASE(lock->l_blocking_lock);
+ ldlm_lock_put(lock->l_blocking_lock);
lock->l_blocking_lock = NULL;
}
}
EXIT;
out_put:
LDLM_DEBUG(lock, "server-side convert handler END, rc = %d", rc);
- LDLM_LOCK_PUT(lock);
+ ldlm_lock_put(lock);
req->rq_status = rc;
return 0;
}
delay);
}
ldlm_lock_cancel(lock);
- LDLM_LOCK_PUT(lock);
+ ldlm_lock_put(lock);
}
if (pres != NULL) {
ldlm_reprocess_all(pres, 0);
}
LDLM_DEBUG(lock, "client blocking callback handler END");
- LDLM_LOCK_RELEASE(lock);
+ ldlm_lock_put(lock);
EXIT;
}
if (ldlm_is_failed(lock)) {
unlock_res_and_lock(lock);
- LDLM_LOCK_RELEASE(lock);
+ ldlm_lock_put(lock);
RETURN(-EINVAL);
}
unlock_res_and_lock(lock);
wake_up(&lock->l_waitq);
}
- LDLM_LOCK_RELEASE(lock);
+ ldlm_lock_put(lock);
return 0;
}
return;
}
unlock_res_and_lock(lock);
- LDLM_LOCK_RELEASE(lock);
+ ldlm_lock_put(lock);
EXIT;
}
"callback on lock %llx - lock disappeared",
dlm_req->lock_handle[0].cookie);
unlock_res_and_lock(lock);
- LDLM_LOCK_RELEASE(lock);
+ ldlm_lock_put(lock);
rc = ldlm_callback_reply(req, -EINVAL);
ldlm_callback_errmsg(req, "Operate on stale lock", rc,
&dlm_req->lock_handle[0]);
rc = ldlm_is_ast_sent(lock) ? 1 : 0;
if (rc)
LDLM_DEBUG(lock, "hpreq cancel/convert lock");
- LDLM_LOCK_PUT(lock);
+ ldlm_lock_put(lock);
if (rc)
break;
}
list_add_tail(&lock->l_rk_ast, rpc_list);
- LDLM_LOCK_GET(lock);
+ ldlm_lock_get(lock);
unlock_res_and_lock(lock);
return 0;
struct ldlm_lock *lock;
lock = hlist_entry(hnode, struct ldlm_lock, l_exp_hash);
- LDLM_LOCK_GET(lock);
+ ldlm_lock_get(lock);
}
static void
struct ldlm_lock *lock;
lock = hlist_entry(hnode, struct ldlm_lock, l_exp_hash);
- LDLM_LOCK_RELEASE(lock);
+ ldlm_lock_put(lock);
}
static struct cfs_hash_ops ldlm_export_lock_ops = {
ldlm_set_ast_sent(lock);
LASSERT(list_empty(&lock->l_rk_ast));
list_add(&lock->l_rk_ast, &data->rcd_rpc_list);
- LDLM_LOCK_GET(lock);
+ ldlm_lock_get(lock);
if (++data->rcd_added == data->rcd_total) {
rc = 1; /* stop the iteration */
break;
LDLM_DEBUG(lock, "client-side local enqueue handler, new lock created");
EXIT;
out:
- LDLM_LOCK_RELEASE(lock);
+ ldlm_lock_put(lock);
out_nolock:
return err;
}
if (cleanup_phase == 1 && rc)
failed_lock_cleanup(ns, lock, einfo->ei_mode);
/* Put lock 2 times, the second reference is held by ldlm_cli_enqueue */
- LDLM_LOCK_PUT(lock);
- LDLM_LOCK_RELEASE(lock);
+ ldlm_lock_put(lock);
+ ldlm_lock_put(lock);
return rc;
}
EXPORT_SYMBOL(ldlm_cli_enqueue_fini);
req = ldlm_enqueue_pack(exp, lvb_len);
if (IS_ERR(req)) {
failed_lock_cleanup(ns, lock, einfo->ei_mode);
- LDLM_LOCK_RELEASE(lock);
+ ldlm_lock_put(lock);
RETURN(PTR_ERR(req));
}
if (einfo->ei_mod_slot)
ptlrpc_put_mod_rpc_slot(req);
failed_lock_cleanup(ns, lock, einfo->ei_mode);
- LDLM_LOCK_RELEASE(lock);
+ ldlm_lock_put(lock);
if (!req_passed_in)
ptlrpc_req_put(req);
GOTO(out, rc);
* one reference that we took
*/
if (err == -ENOLCK)
- LDLM_LOCK_RELEASE(lock);
+ ldlm_lock_put(lock);
else
rc = err;
if (ldlm_is_bl_ast(lock)) {
if (ldlm_is_ast_sent(lock)) {
unlock_res_and_lock(lock);
- LDLM_LOCK_RELEASE(lock);
+ ldlm_lock_put(lock);
RETURN(0);
}
if (ldlm_is_canceling(lock))
unlock_res_and_lock(lock);
wait_event_idle(lock->l_waitq, is_bl_done(lock));
}
- LDLM_LOCK_RELEASE(lock);
+ ldlm_lock_put(lock);
RETURN(0);
}
rc = ldlm_cli_cancel_local(lock);
if (rc == LDLM_FL_LOCAL_ONLY || flags & LCF_LOCAL) {
- LDLM_LOCK_RELEASE(lock);
+ ldlm_lock_put(lock);
RETURN(0);
} else if (rc == LDLM_FL_BL_AST) {
/* BL_AST lock must not wait. */
* waiting for the batch to be handled. */
if (separate) {
ldlm_cli_cancel_req(exp, lock, NULL, 1, flags);
- LDLM_LOCK_RELEASE(lock);
+ ldlm_lock_put(lock);
RETURN(0);
}
if (rc == LDLM_FL_LOCAL_ONLY) {
/* CANCEL RPC should not be sent to server. */
list_del_init(&lock->l_bl_ast);
- LDLM_LOCK_RELEASE(lock);
+ ldlm_lock_put(lock);
count--;
}
}
last_use = lock->l_last_used;
- LDLM_LOCK_GET(lock);
+ ldlm_lock_get(lock);
spin_unlock(&ns->ns_lock);
/*
*/
result = pf(ns, lock, added, min);
if (result == LDLM_POLICY_KEEP_LOCK) {
- LDLM_LOCK_RELEASE(lock);
+ ldlm_lock_put(lock);
break;
}
spin_unlock(&ns->ns_lock);
}
- LDLM_LOCK_RELEASE(lock);
+ ldlm_lock_put(lock);
continue;
}
* pages could be put under it.
*/
unlock_res_and_lock(lock);
- LDLM_LOCK_RELEASE(lock);
+ ldlm_lock_put(lock);
continue;
}
LASSERT(!lock->l_readers && !lock->l_writers);
lock_flags;
LASSERT(list_empty(&lock->l_bl_ast));
list_add(&lock->l_bl_ast, cancels);
- LDLM_LOCK_GET(lock);
+ ldlm_lock_get(lock);
count++;
}
unlock_res(res);
*/
if (!(lock->l_flags & (LDLM_FL_FAILED|LDLM_FL_BL_DONE))) {
list_add(&lock->l_pending_chain, list);
- LDLM_LOCK_GET(lock);
+ ldlm_lock_get(lock);
}
return LDLM_ITER_CONTINUE;
LDLM_DEBUG(lock, "replayed lock:");
ptlrpc_import_recovery_state_machine(req->rq_import);
- LDLM_LOCK_PUT(lock);
+ ldlm_lock_put(lock);
out:
if (rc != ELDLM_OK)
ptlrpc_connect_import(req->rq_import);
/* If we disconnected in the middle - cleanup and let
* reconnection to happen again. LU-14027 */
if (rc || (imp->imp_state != LUSTRE_IMP_REPLAY_LOCKS)) {
- LDLM_LOCK_RELEASE(lock);
+ ldlm_lock_put(lock);
continue;
}
rc = replay_one_lock(imp, lock);
- LDLM_LOCK_RELEASE(lock);
+ ldlm_lock_put(lock);
if (rate_limit)
wait_event_idle_exclusive(imp->imp_replay_waitq,
continue;
lock = tmp;
- LDLM_LOCK_GET(lock);
+ ldlm_lock_get(lock);
ldlm_set_cleaned(lock);
break;
}
if (lock->l_completion_ast)
lock->l_completion_ast(lock,
LDLM_FL_FAILED, NULL);
- LDLM_LOCK_RELEASE(lock);
+ ldlm_lock_put(lock);
continue;
}
"Freeing a lock still held by a client node");
ldlm_lock_cancel(lock);
}
- LDLM_LOCK_RELEASE(lock);
+ ldlm_lock_put(lock);
} while (1);
}
git://git.whamcloud.com / fs / lustre-release.git / commitdiff