int mdc_dom_lock_match(const struct lu_env *env, struct obd_export *exp,
struct ldlm_res_id *res_id,
enum ldlm_type type, union ldlm_policy_data *policy,
enum ldlm_mode mode, __u64 *flags, void *data,
struct lustre_handle *lockh, int unref)
{
struct obd_device *obd = exp->exp_obd;
__u64 lflags = *flags;
enum ldlm_mode rc;
ENTRY;
rc = ldlm_lock_match(obd->obd_namespace, lflags,
res_id, type, policy, mode, lockh, unref);
if (rc == 0 || lflags & LDLM_FL_TEST_LOCK)
RETURN(rc);
if (data != NULL) {
struct ldlm_lock *lock = ldlm_handle2lock(lockh);
LASSERT(lock != NULL);
if (!mdc_set_dom_lock_data(env, lock, data)) {
ldlm_lock_decref(lockh, rc);
rc = 0;
}
LDLM_LOCK_PUT(lock);
}
RETURN(rc);
}
/**
* Implementation of dt_object_operations::do_object_lock
*
* Enqueue a lock (by ldlm_cli_enqueue()) of remote object on the remote MDT,
* which will lock the object in the global namespace. And because the
* cross-MDT locks are relatively rare compared with normal local MDT operation,
* let's release it right away, instead of putting it into the LRU list.
*
* \param[in] env execution environment
* \param[in] dt object to be locked
* \param[out] lh lock handle
* \param[in] einfo enqueue information
* \param[in] policy lock policy
*
* \retval ELDLM_OK if locking the object succeeds.
* \retval negative errno if locking fails.
*/
static int osp_md_object_lock(const struct lu_env *env,
struct dt_object *dt,
struct lustre_handle *lh,
struct ldlm_enqueue_info *einfo,
union ldlm_policy_data *policy)
{
struct ldlm_res_id *res_id;
struct dt_device *dt_dev = lu2dt_dev(dt->do_lu.lo_dev);
struct osp_device *osp = dt2osp_dev(dt_dev);
struct ptlrpc_request *req;
int rc = 0;
__u64 flags = 0;
enum ldlm_mode mode;
res_id = einfo->ei_res_id;
LASSERT(res_id != NULL);
mode = ldlm_lock_match(osp->opd_obd->obd_namespace,
LDLM_FL_BLOCK_GRANTED, res_id,
einfo->ei_type, policy,
einfo->ei_mode, lh, 0);
if (mode > 0)
return ELDLM_OK;
if (einfo->ei_nonblock)
flags |= LDLM_FL_BLOCK_NOWAIT;
req = ldlm_enqueue_pack(osp->opd_exp, 0);
if (IS_ERR(req))
RETURN(PTR_ERR(req));
rc = ldlm_cli_enqueue(osp->opd_exp, &req, einfo, res_id,
(const union ldlm_policy_data *)policy,
&flags, NULL, 0, LVB_T_NONE, lh, 0);
ptlrpc_req_finished(req);
if (rc == ELDLM_OK) {
struct ldlm_lock *lock;
lock = __ldlm_handle2lock(lh, 0);
ldlm_set_cbpending(lock);
LDLM_LOCK_PUT(lock);
}
return rc == ELDLM_OK ? 0 : -EIO;
}
static int osc_object_fiemap(const struct lu_env *env, struct cl_object *obj,
struct ll_fiemap_info_key *fmkey,
struct fiemap *fiemap, size_t *buflen)
{
struct obd_export *exp = osc_export(cl2osc(obj));
struct ldlm_res_id resid;
union ldlm_policy_data policy;
struct lustre_handle lockh;
enum ldlm_mode mode = LCK_MINMODE;
struct ptlrpc_request *req;
struct fiemap *reply;
char *tmp;
int rc;
ENTRY;
fmkey->lfik_oa.o_oi = cl2osc(obj)->oo_oinfo->loi_oi;
if (!(fmkey->lfik_fiemap.fm_flags & FIEMAP_FLAG_SYNC))
goto skip_locking;
policy.l_extent.start = fmkey->lfik_fiemap.fm_start & PAGE_MASK;
if (OBD_OBJECT_EOF - fmkey->lfik_fiemap.fm_length <=
fmkey->lfik_fiemap.fm_start + PAGE_SIZE - 1)
policy.l_extent.end = OBD_OBJECT_EOF;
else
policy.l_extent.end = (fmkey->lfik_fiemap.fm_start +
fmkey->lfik_fiemap.fm_length +
PAGE_SIZE - 1) & PAGE_MASK;
ostid_build_res_name(&fmkey->lfik_oa.o_oi, &resid);
mode = ldlm_lock_match(exp->exp_obd->obd_namespace,
LDLM_FL_BLOCK_GRANTED | LDLM_FL_LVB_READY,
&resid, LDLM_EXTENT, &policy,
LCK_PR | LCK_PW, &lockh, 0);
if (mode) { /* lock is cached on client */
if (mode != LCK_PR) {
ldlm_lock_addref(&lockh, LCK_PR);
ldlm_lock_decref(&lockh, LCK_PW);
}
} else { /* no cached lock, needs acquire lock on server side */
fmkey->lfik_oa.o_valid |= OBD_MD_FLFLAGS;
fmkey->lfik_oa.o_flags |= OBD_FL_SRVLOCK;
}
skip_locking:
req = ptlrpc_request_alloc(class_exp2cliimp(exp),
&RQF_OST_GET_INFO_FIEMAP);
if (req == NULL)
GOTO(drop_lock, rc = -ENOMEM);
req_capsule_set_size(&req->rq_pill, &RMF_FIEMAP_KEY, RCL_CLIENT,
sizeof(*fmkey));
req_capsule_set_size(&req->rq_pill, &RMF_FIEMAP_VAL, RCL_CLIENT,
*buflen);
req_capsule_set_size(&req->rq_pill, &RMF_FIEMAP_VAL, RCL_SERVER,
*buflen);
rc = ptlrpc_request_pack(req, LUSTRE_OST_VERSION, OST_GET_INFO);
if (rc != 0) {
ptlrpc_request_free(req);
GOTO(drop_lock, rc);
}
tmp = req_capsule_client_get(&req->rq_pill, &RMF_FIEMAP_KEY);
memcpy(tmp, fmkey, sizeof(*fmkey));
tmp = req_capsule_client_get(&req->rq_pill, &RMF_FIEMAP_VAL);
memcpy(tmp, fiemap, *buflen);
ptlrpc_request_set_replen(req);
rc = ptlrpc_queue_wait(req);
if (rc != 0)
GOTO(fini_req, rc);
reply = req_capsule_server_get(&req->rq_pill, &RMF_FIEMAP_VAL);
if (reply == NULL)
GOTO(fini_req, rc = -EPROTO);
memcpy(fiemap, reply, *buflen);
fini_req:
ptlrpc_req_finished(req);
drop_lock:
if (mode)
ldlm_lock_decref(&lockh, LCK_PR);
RETURN(rc);
}
