/**
* Process a granting attempt for plain lock.
* Must be called with ns lock held.
*
* This function looks for any conflicts for \a lock in the granted or
* waiting queues. The lock is granted if no conflicts are found in
* either queue.
*
* If \a first_enq is 0 (ie, called from ldlm_reprocess_queue):
* - blocking ASTs have already been sent
*
* If \a first_enq is 1 (ie, called from ldlm_lock_enqueue):
* - blocking ASTs have not been sent yet, so list of conflicting locks
* would be collected and ASTs sent.
*/
int ldlm_process_plain_lock(struct ldlm_lock *lock, __u64 *flags,
int first_enq, ldlm_error_t *err,
struct list_head *work_list)
{
struct ldlm_resource *res = lock->l_resource;
struct list_head rpc_list;
int rc;
ENTRY;
LASSERT(lock->l_granted_mode != lock->l_req_mode);
check_res_locked(res);
LASSERT(list_empty(&res->lr_converting));
INIT_LIST_HEAD(&rpc_list);
if (!first_enq) {
LASSERT(work_list != NULL);
rc = ldlm_plain_compat_queue(&res->lr_granted, lock, NULL);
if (!rc)
RETURN(LDLM_ITER_STOP);
rc = ldlm_plain_compat_queue(&res->lr_waiting, lock, NULL);
if (!rc)
RETURN(LDLM_ITER_STOP);
ldlm_resource_unlink_lock(lock);
ldlm_grant_lock(lock, work_list);
RETURN(LDLM_ITER_CONTINUE);
}
restart:
rc = ldlm_plain_compat_queue(&res->lr_granted, lock, &rpc_list);
rc += ldlm_plain_compat_queue(&res->lr_waiting, lock, &rpc_list);
if (rc != 2) {
/* If either of the compat_queue()s returned 0, then we
* have ASTs to send and must go onto the waiting list.
*
* bug 2322: we used to unlink and re-add here, which was a
* terrible folly -- if we goto restart, we could get
* re-ordered! Causes deadlock, because ASTs aren't sent! */
if (list_empty(&lock->l_res_link))
ldlm_resource_add_lock(res, &res->lr_waiting, lock);
unlock_res(res);
rc = ldlm_run_ast_work(ldlm_res_to_ns(res), &rpc_list,
LDLM_WORK_BL_AST);
lock_res(res);
if (rc == -ERESTART)
GOTO(restart, rc);
*flags |= LDLM_FL_BLOCK_GRANTED;
} else {
ldlm_resource_unlink_lock(lock);
ldlm_grant_lock(lock, NULL);
}
RETURN(0);
}
/**
* Updates object attributes from a lock value block (lvb) received together
* with the DLM lock reply from the server. Copy of osc_update_enqueue()
* logic.
*
* This can be optimized to not update attributes when lock is a result of a
* local match.
*
* Called under lock and resource spin-locks.
*/
static void osc_lock_lvb_update(const struct lu_env *env,
struct osc_object *osc,
struct ldlm_lock *dlmlock,
struct ost_lvb *lvb)
{
struct cl_object *obj = osc2cl(osc);
struct lov_oinfo *oinfo = osc->oo_oinfo;
struct cl_attr *attr = &osc_env_info(env)->oti_attr;
unsigned valid;
ENTRY;
valid = CAT_BLOCKS | CAT_ATIME | CAT_CTIME | CAT_MTIME | CAT_SIZE;
if (lvb == NULL) {
LASSERT(dlmlock != NULL);
lvb = dlmlock->l_lvb_data;
}
cl_lvb2attr(attr, lvb);
cl_object_attr_lock(obj);
if (dlmlock != NULL) {
__u64 size;
check_res_locked(dlmlock->l_resource);
LASSERT(lvb == dlmlock->l_lvb_data);
size = lvb->lvb_size;
/* Extend KMS up to the end of this lock and no further
* A lock on [x,y] means a KMS of up to y + 1 bytes! */
if (size > dlmlock->l_policy_data.l_extent.end)
size = dlmlock->l_policy_data.l_extent.end + 1;
if (size >= oinfo->loi_kms) {
LDLM_DEBUG(dlmlock, "lock acquired, setting rss=%llu"
", kms=%llu", lvb->lvb_size, size);
valid |= CAT_KMS;
attr->cat_kms = size;
} else {
LDLM_DEBUG(dlmlock, "lock acquired, setting rss="
"%llu; leaving kms=%llu, end=%llu",
lvb->lvb_size, oinfo->loi_kms,
dlmlock->l_policy_data.l_extent.end);
}
ldlm_lock_allow_match_locked(dlmlock);
}
cl_object_attr_update(env, obj, attr, valid);
cl_object_attr_unlock(obj);
EXIT;
}
