#define ldlm_is_ndelay(_l) LDLM_TEST_FLAG((_l), 1ULL << 58)
#define ldlm_set_ndelay(_l) LDLM_SET_FLAG((_l), 1ULL << 58)
+/**
+ * LVB from this lock is cached in osc object
+ */
+#define LDLM_FL_LVB_CACHED 0x0800000000000000ULL /* bit 59 */
+#define ldlm_is_lvb_cached(_l) LDLM_TEST_FLAG((_l), 1ULL << 59)
+#define ldlm_set_lvb_cached(_l) LDLM_SET_FLAG((_l), 1ULL << 59)
+#define ldlm_clear_lvb_cached(_l) LDLM_CLEAR_FLAG((_l), 1ULL << 59)
+
/** l_flags bits marked as "ast" bits */
#define LDLM_FL_AST_MASK (LDLM_FL_FLOCK_DEADLOCK |\
LDLM_FL_DISCARD_DATA)
CDEBUG(D_INODE, "cannot flush DoM data "
DFID": rc = %d\n",
PFID(ll_inode2fid(inode)), rc);
- lock_res_and_lock(lock);
- ldlm_set_kms_ignore(lock);
- unlock_res_and_lock(lock);
}
if (bits & MDS_INODELOCK_LAYOUT) {
dlmlock->l_ast_data = NULL;
cl_object_get(obj);
}
- ldlm_set_kms_ignore(dlmlock);
unlock_res_and_lock(dlmlock);
/* if l_ast_data is NULL, the dlmlock was enqueued by AGL or
}
static void mdc_lock_granted(const struct lu_env *env, struct osc_lock *oscl,
- struct lustre_handle *lockh, bool lvb_update)
+ struct lustre_handle *lockh)
{
struct ldlm_lock *dlmlock;
descr->cld_end = CL_PAGE_EOF;
/* no lvb update for matched lock */
- if (lvb_update) {
+ if (!ldlm_is_lvb_cached(dlmlock)) {
LASSERT(oscl->ols_flags & LDLM_FL_LVB_READY);
mdc_lock_lvb_update(env, cl2osc(oscl->ols_cl.cls_obj),
dlmlock, NULL);
+ ldlm_set_lvb_cached(dlmlock);
}
}
unlock_res_and_lock(dlmlock);
CDEBUG(D_INODE, "rc %d, err %d\n", rc, errcode);
if (rc == 0)
- mdc_lock_granted(env, oscl, lockh, errcode == ELDLM_OK);
+ mdc_lock_granted(env, oscl, lockh);
/* Error handling, some errors are tolerable. */
if (oscl->ols_locklessable && rc == -EUSERS) {
* LVB information, e.g. canceled locks or locks of just pruned object,
* such locks should be skipped.
*/
- mode = ldlm_lock_match_with_skip(obd->obd_namespace, match_flags,
- LDLM_FL_KMS_IGNORE, res_id,
- einfo->ei_type, policy, mode,
- &lockh, 0);
+ mode = ldlm_lock_match(obd->obd_namespace, match_flags, res_id,
+ einfo->ei_type, policy, mode, &lockh, 0);
if (mode) {
struct ldlm_lock *matched;
RETURN(ELDLM_OK);
matched = ldlm_handle2lock(&lockh);
- /* this shouldn't happen but this check is kept to make
- * related test fail if problem occurs
- */
- if (unlikely(ldlm_is_kms_ignore(matched))) {
- LDLM_ERROR(matched, "matched lock has KMS ignore flag");
- goto no_match;
- }
if (OBD_FAIL_CHECK(OBD_FAIL_MDC_GLIMPSE_DDOS))
ldlm_set_kms_ignore(matched);
LDLM_LOCK_PUT(matched);
RETURN(ELDLM_OK);
}
-no_match:
ldlm_lock_decref(&lockh, mode);
LDLM_LOCK_PUT(matched);
}
static int mdc_object_ast_clear(struct ldlm_lock *lock, void *data)
{
+ struct osc_object *osc = (struct osc_object *)data;
+ struct ost_lvb *lvb = &lock->l_ost_lvb;
+ struct lov_oinfo *oinfo;
ENTRY;
- if (lock->l_ast_data == data)
+ if (lock->l_ast_data == data) {
lock->l_ast_data = NULL;
- ldlm_set_kms_ignore(lock);
+
+ LASSERT(osc != NULL);
+ LASSERT(osc->oo_oinfo != NULL);
+ LASSERT(lvb != NULL);
+
+ /* Updates lvb in lock by the cached oinfo */
+ oinfo = osc->oo_oinfo;
+ cl_object_attr_lock(&osc->oo_cl);
+ memcpy(lvb, &oinfo->loi_lvb, sizeof(oinfo->loi_lvb));
+ cl_object_attr_unlock(&osc->oo_cl);
+
+ LDLM_DEBUG(lock, "update lvb size %llu blocks %llu [cma]time: "
+ "%llu %llu %llu", lvb->lvb_size, lvb->lvb_blocks,
+ lvb->lvb_ctime, lvb->lvb_mtime, lvb->lvb_atime);
+
+ ldlm_clear_lvb_cached(lock);
+ }
RETURN(LDLM_ITER_CONTINUE);
}
int osc_enqueue_base(struct obd_export *exp, struct ldlm_res_id *res_id,
__u64 *flags, union ldlm_policy_data *policy,
- struct ost_lvb *lvb, int kms_valid,
- osc_enqueue_upcall_f upcall,
+ struct ost_lvb *lvb, osc_enqueue_upcall_f upcall,
void *cookie, struct ldlm_enqueue_info *einfo,
struct ptlrpc_request_set *rqset, int async,
bool speculative);
* 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,
}
static void osc_lock_granted(const struct lu_env *env, struct osc_lock *oscl,
- struct lustre_handle *lockh, bool lvb_update)
+ struct lustre_handle *lockh)
{
struct ldlm_lock *dlmlock;
descr->cld_gid = ext->gid;
/* no lvb update for matched lock */
- if (lvb_update) {
+ if (!ldlm_is_lvb_cached(dlmlock)) {
LASSERT(oscl->ols_flags & LDLM_FL_LVB_READY);
osc_lock_lvb_update(env, cl2osc(oscl->ols_cl.cls_obj),
dlmlock, NULL);
+ ldlm_set_lvb_cached(dlmlock);
}
LINVRNT(osc_lock_invariant(oscl));
}
}
if (rc == 0)
- osc_lock_granted(env, oscl, lockh, errcode == ELDLM_OK);
+ osc_lock_granted(env, oscl, lockh);
/* Error handling, some errors are tolerable. */
if (oscl->ols_locklessable && rc == -EUSERS) {
lock_res_and_lock(dlmlock);
LASSERT(ldlm_is_granted(dlmlock));
- /* there is no osc_lock associated with speculative locks */
+ /* there is no osc_lock associated with speculative locks
+ * thus no need to set LDLM_FL_LVB_CACHED */
osc_lock_lvb_update(env, osc, dlmlock, NULL);
unlock_res_and_lock(dlmlock);
}
result = osc_enqueue_base(exp, resname, &oscl->ols_flags,
policy, &oscl->ols_lvb,
- osc->oo_oinfo->loi_kms_valid,
upcall, cookie,
&oscl->ols_einfo, PTLRPCD_SET, async,
oscl->ols_speculative);
static int osc_object_ast_clear(struct ldlm_lock *lock, void *data)
{
+ struct osc_object *osc = (struct osc_object *)data;
+ struct ost_lvb *lvb = lock->l_lvb_data;
+ struct lov_oinfo *oinfo;
ENTRY;
- if (lock->l_ast_data == data)
+ if (lock->l_ast_data == data) {
lock->l_ast_data = NULL;
+
+ LASSERT(osc != NULL);
+ LASSERT(osc->oo_oinfo != NULL);
+ LASSERT(lvb != NULL);
+
+ /* Updates lvb in lock by the cached oinfo */
+ oinfo = osc->oo_oinfo;
+ cl_object_attr_lock(&osc->oo_cl);
+ memcpy(lvb, &oinfo->loi_lvb, sizeof(oinfo->loi_lvb));
+ cl_object_attr_unlock(&osc->oo_cl);
+
+ LDLM_DEBUG(lock, "update lvb size %llu blocks %llu [cma]time: "
+ "%llu %llu %llu", lvb->lvb_size, lvb->lvb_blocks,
+ lvb->lvb_ctime, lvb->lvb_mtime, lvb->lvb_atime);
+
+ ldlm_clear_lvb_cached(lock);
+ }
RETURN(LDLM_ITER_CONTINUE);
}
* release locks just after they are obtained. */
int osc_enqueue_base(struct obd_export *exp, struct ldlm_res_id *res_id,
__u64 *flags, union ldlm_policy_data *policy,
- struct ost_lvb *lvb, int kms_valid,
- osc_enqueue_upcall_f upcall, void *cookie,
- struct ldlm_enqueue_info *einfo,
+ struct ost_lvb *lvb, osc_enqueue_upcall_f upcall,
+ void *cookie, struct ldlm_enqueue_info *einfo,
struct ptlrpc_request_set *rqset, int async,
bool speculative)
{
policy->l_extent.start -= policy->l_extent.start & ~PAGE_MASK;
policy->l_extent.end |= ~PAGE_MASK;
- /*
- * kms is not valid when either object is completely fresh (so that no
- * locks are cached), or object was evicted. In the latter case cached
- * lock cannot be used, because it would prime inode state with
- * potentially stale LVB.
- */
- if (!kms_valid)
- goto no_match;
-
/* Next, search for already existing extent locks that will cover us */
/* If we're trying to read, we also search for an existing PW lock. The
* VFS and page cache already protect us locally, so lots of readers/
}
}
-no_match:
if (*flags & (LDLM_FL_TEST_LOCK | LDLM_FL_MATCH_LOCK))
RETURN(-ENOLCK);