/*
* Send non-intent quota request to master.
*
* \param env - the environment passed by the caller
* \param exp - is the export to use to send the acquire RPC
* \param qbody - quota body to be packed in request
* \param sync - synchronous or asynchronous
* \param completion - completion callback
* \param qqi - is the qsd_qtype_info structure to pass to the completion
* function
* \param lqe - is the qid entry to be processed
*
* \retval 0 - success
* \retval -ve - appropriate errors
*/
int qsd_send_dqacq(const struct lu_env *env, struct obd_export *exp,
struct quota_body *qbody, bool sync,
qsd_req_completion_t completion, struct qsd_qtype_info *qqi,
struct lustre_handle *lockh, struct lquota_entry *lqe)
{
struct ptlrpc_request *req;
struct quota_body *req_qbody;
struct qsd_async_args *aa;
int rc;
ENTRY;
LASSERT(exp);
req = ptlrpc_request_alloc(class_exp2cliimp(exp), &RQF_QUOTA_DQACQ);
if (req == NULL)
GOTO(out, rc = -ENOMEM);
req->rq_no_resend = req->rq_no_delay = 1;
req->rq_no_retry_einprogress = 1;
rc = ptlrpc_request_pack(req, LUSTRE_MDS_VERSION, QUOTA_DQACQ);
if (rc) {
ptlrpc_request_free(req);
GOTO(out, rc);
}
req->rq_request_portal = MDS_READPAGE_PORTAL;
req_qbody = req_capsule_client_get(&req->rq_pill, &RMF_QUOTA_BODY);
*req_qbody = *qbody;
ptlrpc_request_set_replen(req);
CLASSERT(sizeof(*aa) <= sizeof(req->rq_async_args));
aa = ptlrpc_req_async_args(req);
aa->aa_exp = exp;
aa->aa_qqi = qqi;
aa->aa_arg = (void *)lqe;
aa->aa_completion = completion;
lustre_handle_copy(&aa->aa_lockh, lockh);
if (sync) {
rc = ptlrpc_queue_wait(req);
rc = qsd_dqacq_interpret(env, req, aa, rc);
ptlrpc_req_finished(req);
} else {
req->rq_interpret_reply = qsd_dqacq_interpret;
ptlrpcd_add_req(req);
}
RETURN(rc);
out:
completion(env, qqi, qbody, NULL, lockh, NULL, lqe, rc);
return rc;
}
static int osc_io_data_version_start(const struct lu_env *env,
const struct cl_io_slice *slice)
{
struct cl_data_version_io *dv = &slice->cis_io->u.ci_data_version;
struct osc_io *oio = cl2osc_io(env, slice);
struct obdo *oa = &oio->oi_oa;
struct osc_async_cbargs *cbargs = &oio->oi_cbarg;
struct osc_object *obj = cl2osc(slice->cis_obj);
struct lov_oinfo *loi = obj->oo_oinfo;
struct obd_export *exp = osc_export(obj);
struct ptlrpc_request *req;
struct ost_body *body;
struct osc_data_version_args *dva;
int rc;
ENTRY;
memset(oa, 0, sizeof(*oa));
oa->o_oi = loi->loi_oi;
oa->o_valid = OBD_MD_FLID | OBD_MD_FLGROUP;
if (dv->dv_flags & (LL_DV_RD_FLUSH | LL_DV_WR_FLUSH)) {
oa->o_valid |= OBD_MD_FLFLAGS;
oa->o_flags |= OBD_FL_SRVLOCK;
if (dv->dv_flags & LL_DV_WR_FLUSH)
oa->o_flags |= OBD_FL_FLUSH;
}
init_completion(&cbargs->opc_sync);
req = ptlrpc_request_alloc(class_exp2cliimp(exp), &RQF_OST_GETATTR);
if (req == NULL)
RETURN(-ENOMEM);
rc = ptlrpc_request_pack(req, LUSTRE_OST_VERSION, OST_GETATTR);
if (rc < 0) {
ptlrpc_request_free(req);
RETURN(rc);
}
body = req_capsule_client_get(&req->rq_pill, &RMF_OST_BODY);
lustre_set_wire_obdo(&req->rq_import->imp_connect_data, &body->oa, oa);
ptlrpc_request_set_replen(req);
req->rq_interpret_reply = osc_data_version_interpret;
CLASSERT(sizeof(*dva) <= sizeof(req->rq_async_args));
dva = ptlrpc_req_async_args(req);
dva->dva_oio = oio;
ptlrpcd_add_req(req);
RETURN(0);
}
static int osp_statfs_interpret(const struct lu_env *env,
struct ptlrpc_request *req,
union ptlrpc_async_args *aa, int rc)
{
struct obd_import *imp = req->rq_import;
struct obd_statfs *msfs;
struct osp_device *d;
ENTRY;
aa = ptlrpc_req_async_args(req);
d = aa->pointer_arg[0];
LASSERT(d);
if (rc != 0)
GOTO(out, rc);
msfs = req_capsule_server_get(&req->rq_pill, &RMF_OBD_STATFS);
if (msfs == NULL)
GOTO(out, rc = -EPROTO);
d->opd_statfs = *msfs;
osp_pre_update_status(d, rc);
/* schedule next update */
d->opd_statfs_fresh_till = cfs_time_shift(d->opd_statfs_maxage);
cfs_timer_arm(&d->opd_statfs_timer, d->opd_statfs_fresh_till);
d->opd_statfs_update_in_progress = 0;
CDEBUG(D_CACHE, "updated statfs %p\n", d);
RETURN(0);
out:
/* couldn't update statfs, try again as soon as possible */
if (d->opd_pre != NULL && osp_precreate_running(d))
wake_up(&d->opd_pre_waitq);
if (req->rq_import_generation == imp->imp_generation)
CDEBUG(D_CACHE, "%s: couldn't update statfs: rc = %d\n",
d->opd_obd->obd_name, rc);
RETURN(rc);
}
static int osp_statfs_update(struct osp_device *d)
{
struct ptlrpc_request *req;
struct obd_import *imp;
union ptlrpc_async_args *aa;
int rc;
ENTRY;
CDEBUG(D_CACHE, "going to update statfs\n");
imp = d->opd_obd->u.cli.cl_import;
LASSERT(imp);
req = ptlrpc_request_alloc(imp, &RQF_OST_STATFS);
if (req == NULL)
RETURN(-ENOMEM);
rc = ptlrpc_request_pack(req, LUSTRE_OST_VERSION, OST_STATFS);
if (rc) {
ptlrpc_request_free(req);
RETURN(rc);
}
ptlrpc_request_set_replen(req);
req->rq_request_portal = OST_CREATE_PORTAL;
ptlrpc_at_set_req_timeout(req);
req->rq_interpret_reply = (ptlrpc_interpterer_t)osp_statfs_interpret;
aa = ptlrpc_req_async_args(req);
aa->pointer_arg[0] = d;
/*
* no updates till reply
*/
cfs_timer_disarm(&d->opd_statfs_timer);
d->opd_statfs_fresh_till = cfs_time_shift(obd_timeout * 1000);
d->opd_statfs_update_in_progress = 1;
ptlrpcd_add_req(req, PDL_POLICY_ROUND, -1);
RETURN(0);
}
/*
* Get intent per-ID lock or global-index lock from master.
*
* \param env - the environment passed by the caller
* \param exp - is the export to use to send the intent RPC
* \param qbody - quota body to be packed in request
* \param sync - synchronous or asynchronous (pre-acquire)
* \param it_op - IT_QUOTA_DQACQ or IT_QUOTA_CONN
* \param completion - completion callback
* \param qqi - is the qsd_qtype_info structure to pass to the completion
* function
* \param lvb - is the lvb associated with the lock and returned by the
* server
* \param arg - is an opaq argument passed to the completion callback
*
* \retval 0 - success
* \retval -ve - appropriate errors
*/
int qsd_intent_lock(const struct lu_env *env, struct obd_export *exp,
struct quota_body *qbody, bool sync, int it_op,
qsd_req_completion_t completion, struct qsd_qtype_info *qqi,
struct lquota_lvb *lvb, void *arg)
{
struct qsd_thread_info *qti = qsd_info(env);
struct ptlrpc_request *req;
struct qsd_async_args *aa = NULL;
struct ldlm_intent *lit;
struct quota_body *req_qbody;
__u64 flags = LDLM_FL_HAS_INTENT;
int rc;
ENTRY;
LASSERT(exp != NULL);
LASSERT(!lustre_handle_is_used(&qbody->qb_lockh));
memset(&qti->qti_lockh, 0, sizeof(qti->qti_lockh));
req = ptlrpc_request_alloc(class_exp2cliimp(exp),
&RQF_LDLM_INTENT_QUOTA);
if (req == NULL)
GOTO(out, rc = -ENOMEM);
req->rq_no_retry_einprogress = 1;
rc = ldlm_prep_enqueue_req(exp, req, NULL, 0);
if (rc) {
ptlrpc_request_free(req);
GOTO(out, rc);
}
lit = req_capsule_client_get(&req->rq_pill, &RMF_LDLM_INTENT);
lit->opc = (__u64)it_op;
req_qbody = req_capsule_client_get(&req->rq_pill, &RMF_QUOTA_BODY);
*req_qbody = *qbody;
req_capsule_set_size(&req->rq_pill, &RMF_DLM_LVB, RCL_SERVER,
sizeof(*lvb));
ptlrpc_request_set_replen(req);
switch(it_op) {
case IT_QUOTA_CONN:
/* build resource name associated with global index */
fid_build_reg_res_name(&qbody->qb_fid, &qti->qti_resid);
/* copy einfo template and fill ei_cbdata with qqi pointer */
memcpy(&qti->qti_einfo, &qsd_glb_einfo, sizeof(qti->qti_einfo));
qti->qti_einfo.ei_cbdata = qqi;
/* don't cancel global lock on memory pressure */
flags |= LDLM_FL_NO_LRU;
break;
case IT_QUOTA_DQACQ:
/* build resource name associated for per-ID quota lock */
fid_build_quota_res_name(&qbody->qb_fid, &qbody->qb_id,
&qti->qti_resid);
/* copy einfo template and fill ei_cbdata with lqe pointer */
memcpy(&qti->qti_einfo, &qsd_id_einfo, sizeof(qti->qti_einfo));
qti->qti_einfo.ei_cbdata = arg;
break;
default:
LASSERTF(0, "invalid it_op %d", it_op);
}
/* build lock enqueue request */
rc = ldlm_cli_enqueue(exp, &req, &qti->qti_einfo, &qti->qti_resid, NULL,
&flags, (void *)lvb, sizeof(*lvb), LVB_T_LQUOTA,
&qti->qti_lockh, 1);
if (rc < 0) {
ptlrpc_req_finished(req);
GOTO(out, rc);
}
/* grab reference on backend structure for the new lock */
switch(it_op) {
case IT_QUOTA_CONN:
/* grab reference on qqi for new lock */
#ifdef USE_LU_REF
{
struct ldlm_lock *lock;
lock = ldlm_handle2lock(&qti->qti_lockh);
if (lock == NULL) {
ptlrpc_req_finished(req);
GOTO(out, rc = -ENOLCK);
}
lu_ref_add(&qqi->qqi_reference, "glb_lock", lock);
LDLM_LOCK_PUT(lock);
}
#endif
qqi_getref(qqi);
break;
case IT_QUOTA_DQACQ:
/* grab reference on lqe for new lock */
lqe_getref((struct lquota_entry *)arg);
/* all acquire/release request are sent with no_resend and
* no_delay flag */
req->rq_no_resend = req->rq_no_delay = 1;
break;
default:
break;
}
CLASSERT(sizeof(*aa) <= sizeof(req->rq_async_args));
aa = ptlrpc_req_async_args(req);
aa->aa_exp = exp;
aa->aa_qqi = qqi;
aa->aa_arg = arg;
aa->aa_lvb = lvb;
aa->aa_completion = completion;
lustre_handle_copy(&aa->aa_lockh, &qti->qti_lockh);
if (sync) {
/* send lock enqueue request and wait for completion */
rc = ptlrpc_queue_wait(req);
rc = qsd_intent_interpret(env, req, aa, rc);
ptlrpc_req_finished(req);
} else {
/* queue lock request and return */
req->rq_interpret_reply = qsd_intent_interpret;
ptlrpcd_add_req(req, PDL_POLICY_LOCAL, -1);
}
RETURN(rc);
out:
completion(env, qqi, qbody, NULL, &qti->qti_lockh, lvb, arg, rc);
return rc;
}
