struct list_head *queue,
struct list_head *work_list,
enum ldlm_process_intention intention,
- struct ldlm_lock *hint);
+ __u64 hint);
/**
* Return values for lock iterators.
__u64 *bits);
void ldlm_lock_mode_downgrade(struct ldlm_lock *lock, enum ldlm_mode new_mode);
void ldlm_lock_cancel(struct ldlm_lock *lock);
-void ldlm_reprocess_all(struct ldlm_resource *res, struct ldlm_lock *hint);
+void ldlm_reprocess_all(struct ldlm_resource *res, __u64 hint);
void ldlm_reprocess_recovery_done(struct ldlm_namespace *ns);
void ldlm_lock_dump_handle(int level, const struct lustre_handle *lockh);
void ldlm_unlink_lock_skiplist(struct ldlm_lock *req);
restart:
ldlm_reprocess_queue(res, &res->lr_waiting,
&rpc_list,
- LDLM_PROCESS_RESCAN, NULL);
+ LDLM_PROCESS_RESCAN, 0);
unlock_res_and_lock(req);
rc = ldlm_run_ast_work(ns, &rpc_list,
struct list_head *queue,
struct list_head *work_list,
enum ldlm_process_intention intention,
- struct ldlm_lock *hint)
+ __u64 mask)
{
__u64 flags;
int rc = LDLM_ITER_CONTINUE;
if (intention == LDLM_PROCESS_RECOVERY)
return ldlm_reprocess_queue(res, queue, work_list, intention,
- NULL);
+ 0);
restart:
CDEBUG(D_DLMTRACE, "--- Reprocess resource "DLDLMRES" (%p)\n",
PLDLMRES(res), res);
+ if (mask)
+ CDEBUG(D_DLMTRACE, "Hint %llx\n", mask);
+ else
+ mask = MDS_INODELOCK_FULL;
for (i = 0; i < MDS_INODELOCK_NUMBITS; i++) {
LIST_HEAD(rpc_list);
struct ldlm_lock *pending;
struct ldlm_ibits_node *node;
- if (list_empty(head))
- continue;
- if (hint && !(hint->l_policy_data.l_inodebits.bits & BIT(i)))
+ if (list_empty(head) || !(mask & (1 << i)))
continue;
node = list_entry(head->next, struct ldlm_ibits_node,
&err, &rpc_list);
if (ldlm_is_granted(pending)) {
list_splice(&rpc_list, work_list);
- /* Try to grant more locks from current queue */
- i--;
+ mask |= pending->l_policy_data.l_inodebits.bits;
+ i = ffs(pending->l_policy_data.l_inodebits.bits) - 2;
} else {
list_splice(&rpc_list, &bl_ast_list);
}
LDLM_WORK_BL_AST);
lock_res(res);
- if (rc == -ERESTART)
+ if (rc == -ERESTART) {
+ mask = 0;
GOTO(restart, rc);
+ }
}
if (!list_empty(&bl_ast_list))
#ifdef HAVE_SERVER_SUPPORT
int ldlm_reprocess_queue(struct ldlm_resource *res, struct list_head *queue,
struct list_head *work_list,
- enum ldlm_process_intention intention,
- struct ldlm_lock *hint);
+ enum ldlm_process_intention intention, __u64 hint);
int ldlm_handle_conflict_lock(struct ldlm_lock *lock, __u64 *flags,
struct list_head *rpc_list);
void ldlm_discard_bl_list(struct list_head *bl_list);
struct list_head *queue,
struct list_head *work_list,
enum ldlm_process_intention intention,
- struct ldlm_lock *hint);
+ __u64 hint);
/* ldlm_extent.c */
int ldlm_process_extent_lock(struct ldlm_lock *lock, __u64 *flags,
enum ldlm_process_intention intention,
*/
int ldlm_reprocess_queue(struct ldlm_resource *res, struct list_head *queue,
struct list_head *work_list,
- enum ldlm_process_intention intention,
- struct ldlm_lock *hint)
+ enum ldlm_process_intention intention, __u64 hint)
{
struct list_head *tmp, *pos;
ldlm_processing_policy policy;
class_fail_export(lock->l_export);
if (rc == -ERESTART)
- ldlm_reprocess_all(res, NULL);
+ ldlm_reprocess_all(res, 0);
lock_res(res);
if (rc == -ERESTART) {
*/
static void __ldlm_reprocess_all(struct ldlm_resource *res,
enum ldlm_process_intention intention,
- struct ldlm_lock *hint)
+ __u64 hint)
{
LIST_HEAD(rpc_list);
#ifdef HAVE_SERVER_SUPPORT
LDLM_WORK_CP_AST);
if (rc == -ERESTART) {
LASSERT(list_empty(&rpc_list));
+ hint = 0;
goto restart;
}
#else
EXIT;
}
-void ldlm_reprocess_all(struct ldlm_resource *res, struct ldlm_lock *hint)
+void ldlm_reprocess_all(struct ldlm_resource *res, __u64 hint)
{
__ldlm_reprocess_all(res, LDLM_PROCESS_RESCAN, hint);
}
struct ldlm_resource *res = cfs_hash_object(hs, hnode);
/* This is only called once after recovery done. LU-8306. */
- __ldlm_reprocess_all(res, LDLM_PROCESS_RECOVERY, NULL);
+ __ldlm_reprocess_all(res, LDLM_PROCESS_RECOVERY, 0);
return 0;
}
ldlm_lvbo_update(res, lock, NULL, 1);
ldlm_lock_cancel(lock);
if (!exp->exp_obd->obd_stopping)
- ldlm_reprocess_all(res, lock);
+ ldlm_reprocess_all(res, lock->l_policy_data.l_inodebits.bits);
ldlm_resource_putref(res);
ecl->ecl_loop++;
ldlm_grant_lock(lock, NULL);
unlock_res_and_lock(lock);
- ldlm_reprocess_all(lock->l_resource, lock);
+ ldlm_reprocess_all(lock->l_resource,
+ lock->l_policy_data.l_inodebits.bits);
EXIT;
#endif
rc = ldlm_run_ast_work(ldlm_res_to_ns(res), gl_work_list,
LDLM_WORK_GL_AST);
if (rc == -ERESTART)
- ldlm_reprocess_all(res, NULL);
+ ldlm_reprocess_all(res, 0);
RETURN(rc);
}
ldlm_lock_destroy_nolock(lock);
unlock_res_and_lock(lock);
}
- ldlm_reprocess_all(lock->l_resource, lock);
+ ldlm_reprocess_all(lock->l_resource, lock->l_policy_data.l_inodebits.bits);
}
if (!err && !ldlm_is_cbpending(lock) &&
dlm_req->lock_desc.l_resource.lr_type != LDLM_FLOCK)
- ldlm_reprocess_all(lock->l_resource, lock);
+ ldlm_reprocess_all(lock->l_resource,
+ lock->l_policy_data.l_inodebits.bits);
LDLM_LOCK_RELEASE(lock);
}
ldlm_clear_blocking_data(lock);
unlock_res_and_lock(lock);
- ldlm_reprocess_all(lock->l_resource, NULL);
+ /* All old bits should be reprocessed to send new BL AST if
+ * it wasn't sent earlier due to LDLM_FL_AST_SENT bit set.
+ * */
+ ldlm_reprocess_all(lock->l_resource, bits);
}
dlm_rep->lock_handle = lock->l_remote_handle;
*/
if (res != pres) {
if (pres != NULL) {
- ldlm_reprocess_all(pres, NULL);
+ ldlm_reprocess_all(pres, 0);
LDLM_RESOURCE_DELREF(pres);
ldlm_resource_putref(pres);
}
LDLM_LOCK_PUT(lock);
}
if (pres != NULL) {
- ldlm_reprocess_all(pres, NULL);
+ ldlm_reprocess_all(pres, 0);
LDLM_RESOURCE_DELREF(pres);
ldlm_resource_putref(pres);
}
void ldlm_revoke_export_locks(struct obd_export *exp)
{
+ int rc;
LIST_HEAD(rpc_list);
-
ENTRY;
cfs_hash_for_each_nolock(exp->exp_lock_hash,
ldlm_revoke_lock_cb, &rpc_list, 0);
- ldlm_run_ast_work(exp->exp_obd->obd_namespace, &rpc_list,
+ rc = ldlm_run_ast_work(exp->exp_obd->obd_namespace, &rpc_list,
LDLM_WORK_REVOKE_AST);
+ if (rc == -ERESTART)
+ ldlm_reprocess_recovery_done(exp->exp_obd->obd_namespace);
+
EXIT;
}
EXPORT_SYMBOL(ldlm_revoke_export_locks);
{
struct ldlm_reclaim_cb_data data;
int idx, type, start;
+ int rc;
ENTRY;
LASSERT(*count != 0);
LASSERTF(*count >= data.rcd_added, "count:%d, added:%d\n", *count,
data.rcd_added);
- ldlm_run_ast_work(ns, &data.rcd_rpc_list, LDLM_WORK_REVOKE_AST);
+ rc = ldlm_run_ast_work(ns, &data.rcd_rpc_list, LDLM_WORK_REVOKE_AST);
+ if (rc == -ERESTART)
+ ldlm_reprocess_recovery_done(ns);
+
*count -= data.rcd_added;
EXIT;
}
RETURN(ldlm_completion_tail(lock, data));
}
- LDLM_DEBUG(lock,
- "client-side enqueue returned a blocked lock, going forward");
- ldlm_reprocess_all(lock->l_resource, NULL);
+ LDLM_DEBUG(lock, "client-side enqueue returned a blocked lock, going forward");
+ ldlm_reprocess_all(lock->l_resource, 0);
RETURN(0);
}
EXPORT_SYMBOL(ldlm_completion_ast_async);
}
LDLM_DEBUG(lock, "server-side local cancel");
ldlm_lock_cancel(lock);
- ldlm_reprocess_all(lock->l_resource, lock);
+ ldlm_reprocess_all(lock->l_resource,
+ lock->l_policy_data.l_inodebits.bits);
}
RETURN(rc);
}
out_reprocess:
- ldlm_reprocess_all(lease->l_resource, lease);
+ ldlm_reprocess_all(lease->l_resource,
+ lease->l_policy_data.l_inodebits.bits);
LDLM_LOCK_PUT(lease);
ma->ma_valid = 0;
/* the 2nd object has been used, and not swapped */
mdt_object_put(info->mti_env, o2);
- ldlm_reprocess_all(lease->l_resource, lease);
+ ldlm_reprocess_all(lease->l_resource,
+ lease->l_policy_data.l_inodebits.bits);
out_lease:
LDLM_LOCK_PUT(lease);
OBD_FREE_PTR_ARRAY(resync_ids, resync_count);
out_reprocess:
- ldlm_reprocess_all(lease->l_resource, lease);
+ ldlm_reprocess_all(lease->l_resource,
+ lease->l_policy_data.l_inodebits.bits);
LDLM_LOCK_PUT(lease);
ma->ma_valid = 0;
* cancelled, it's okay to cancel it now as we've held mot_open_sem.
*/
ldlm_lock_cancel(lease);
- ldlm_reprocess_all(lease->l_resource, lease);
+ ldlm_reprocess_all(lease->l_resource,
+ lease->l_policy_data.l_inodebits.bits);
LDLM_LOCK_PUT(lease);
close: