static int fld_handle_read(struct tgt_session_info *tsi)
{
struct obd_export *exp = tsi->tsi_exp;
struct lu_site *site = exp->exp_obd->obd_lu_dev->ld_site;
struct lu_seq_range *in;
void *data;
int rc;
ENTRY;
req_capsule_set(tsi->tsi_pill, &RQF_FLD_READ);
in = req_capsule_client_get(tsi->tsi_pill, &RMF_FLD_MDFLD);
if (in == NULL)
RETURN(err_serious(-EPROTO));
req_capsule_set_size(tsi->tsi_pill, &RMF_GENERIC_DATA, RCL_SERVER,
PAGE_CACHE_SIZE);
rc = req_capsule_server_pack(tsi->tsi_pill);
if (unlikely(rc != 0))
RETURN(err_serious(rc));
data = req_capsule_server_get(tsi->tsi_pill, &RMF_GENERIC_DATA);
rc = fld_server_read(tsi->tsi_env, lu_site2seq(site)->ss_server_fld,
in, data, PAGE_CACHE_SIZE);
RETURN(rc);
}
static inline void mdt_reint_init_ma(struct mdt_thread_info *info,
struct md_attr *ma)
{
ma->ma_lmm = req_capsule_server_get(info->mti_pill, &RMF_MDT_MD);
ma->ma_lmm_size = req_capsule_get_size(info->mti_pill,
&RMF_MDT_MD, RCL_SERVER);
ma->ma_cookie = req_capsule_server_get(info->mti_pill,
&RMF_LOGCOOKIES);
ma->ma_cookie_size = req_capsule_get_size(info->mti_pill,
&RMF_LOGCOOKIES,
RCL_SERVER);
ma->ma_need = MA_INODE | MA_LOV | MA_COOKIE;
ma->ma_valid = 0;
}
/*
* intent quota request interpret callback.
*
* \param env - the environment passed by the caller
* \param req - the intent quota request
* \param arg - qsd_async_args
* \param rc - request status
*
* \retval 0 - success
* \retval -ve - appropriate errors
*/
static int qsd_intent_interpret(const struct lu_env *env,
struct ptlrpc_request *req, void *arg, int rc)
{
struct lustre_handle *lockh;
struct quota_body *rep_qbody = NULL, *req_qbody;
struct ldlm_intent *lit;
struct qsd_async_args *aa = (struct qsd_async_args *)arg;
__u64 flags = LDLM_FL_HAS_INTENT;
ENTRY;
LASSERT(aa->aa_exp);
lockh = &aa->aa_lockh;
req_qbody = req_capsule_client_get(&req->rq_pill, &RMF_QUOTA_BODY);
lit = req_capsule_client_get(&req->rq_pill, &RMF_LDLM_INTENT);
rc = ldlm_cli_enqueue_fini(aa->aa_exp, req, LDLM_PLAIN, 0, LCK_CR,
&flags, (void *)aa->aa_lvb,
sizeof(struct lquota_lvb), lockh, rc);
if (rc < 0)
/* the lock has been destroyed, forget about the lock handle */
memset(lockh, 0, sizeof(*lockh));
if (rc == 0 || rc == -EDQUOT || rc == -EINPROGRESS)
rep_qbody = req_capsule_server_get(&req->rq_pill,
&RMF_QUOTA_BODY);
aa->aa_completion(env, aa->aa_qqi, req_qbody, rep_qbody, lockh,
aa->aa_lvb, aa->aa_arg, rc);
RETURN(rc);
}
static int mdt_create_pack_capa(struct mdt_thread_info *info, int rc,
struct mdt_object *object,
struct mdt_body *repbody)
{
ENTRY;
/* for cross-ref mkdir, mds capa has been fetched from remote obj, then
* we won't go to below*/
if (repbody->valid & OBD_MD_FLMDSCAPA)
RETURN(rc);
if (rc == 0 && info->mti_mdt->mdt_lut.lut_mds_capa &&
exp_connect_flags(info->mti_exp) & OBD_CONNECT_MDS_CAPA) {
struct lustre_capa *capa;
capa = req_capsule_server_get(info->mti_pill, &RMF_CAPA1);
LASSERT(capa);
capa->lc_opc = CAPA_OPC_MDS_DEFAULT;
rc = mo_capa_get(info->mti_env, mdt_object_child(object), capa,
0);
if (rc == 0)
repbody->valid |= OBD_MD_FLMDSCAPA;
}
RETURN(rc);
}
/**
* All MDT server handle fld lookup operation. But only MDT0 has fld index.
* if entry is not found in cache we need to forward lookup request to MDT0
*/
static int fld_handle_lookup(struct tgt_session_info *tsi)
{
struct obd_export *exp = tsi->tsi_exp;
struct lu_site *site = exp->exp_obd->obd_lu_dev->ld_site;
struct lu_server_fld *fld;
struct lu_seq_range *in;
struct lu_seq_range *out;
int rc;
ENTRY;
in = req_capsule_client_get(tsi->tsi_pill, &RMF_FLD_MDFLD);
if (in == NULL)
RETURN(err_serious(-EPROTO));
rc = req_capsule_server_pack(tsi->tsi_pill);
if (unlikely(rc != 0))
RETURN(err_serious(rc));
out = req_capsule_server_get(tsi->tsi_pill, &RMF_FLD_MDFLD);
if (out == NULL)
RETURN(err_serious(-EPROTO));
*out = *in;
fld = lu_site2seq(site)->ss_server_fld;
rc = fld_server_lookup(tsi->tsi_env, fld, in->lsr_start, out);
CDEBUG(D_INFO, "%s: FLD req handle: error %d (range: "DRANGE")\n",
fld->lsf_name, rc, PRANGE(out));
RETURN(rc);
}
static int llog_client_prev_block(const struct lu_env *env,
struct llog_handle *loghandle,
int prev_idx, void *buf, int len)
{
struct obd_import *imp;
struct ptlrpc_request *req = NULL;
struct llogd_body *body;
void *ptr;
int rc;
LLOG_CLIENT_ENTRY(loghandle->lgh_ctxt, imp);
req = ptlrpc_request_alloc_pack(imp, &RQF_LLOG_ORIGIN_HANDLE_PREV_BLOCK,
LUSTRE_LOG_VERSION,
LLOG_ORIGIN_HANDLE_PREV_BLOCK);
if (req == NULL)
GOTO(err_exit, rc = -ENOMEM);
body = req_capsule_client_get(&req->rq_pill, &RMF_LLOGD_BODY);
body->lgd_logid = loghandle->lgh_id;
body->lgd_ctxt_idx = loghandle->lgh_ctxt->loc_idx - 1;
body->lgd_llh_flags = loghandle->lgh_hdr->llh_flags;
body->lgd_index = prev_idx;
body->lgd_len = len;
req_capsule_set_size(&req->rq_pill, &RMF_EADATA, RCL_SERVER, len);
ptlrpc_request_set_replen(req);
rc = ptlrpc_queue_wait(req);
if (rc)
GOTO(out, rc);
body = req_capsule_server_get(&req->rq_pill, &RMF_LLOGD_BODY);
if (body == NULL)
GOTO(out, rc =-EFAULT);
ptr = req_capsule_server_get(&req->rq_pill, &RMF_EADATA);
if (ptr == NULL)
GOTO(out, rc =-EFAULT);
memcpy(buf, ptr, len);
out:
ptlrpc_req_finished(req);
err_exit:
LLOG_CLIENT_EXIT(loghandle->lgh_ctxt, imp);
return rc;
}
/* Only open is supported, no new llog can be created remotely */
int llog_origin_handle_open(struct ptlrpc_request *req)
{
struct obd_export *exp = req->rq_export;
struct obd_device *obd = exp->exp_obd;
struct llog_handle *loghandle;
struct llogd_body *body;
struct llog_logid *logid = NULL;
struct llog_ctxt *ctxt;
char *name = NULL;
int rc;
ENTRY;
body = req_capsule_client_get(&req->rq_pill, &RMF_LLOGD_BODY);
if (body == NULL)
RETURN(err_serious(-EFAULT));
rc = req_capsule_server_pack(&req->rq_pill);
if (rc)
RETURN(err_serious(-ENOMEM));
if (ostid_id(&body->lgd_logid.lgl_oi) > 0)
logid = &body->lgd_logid;
if (req_capsule_field_present(&req->rq_pill, &RMF_NAME, RCL_CLIENT)) {
name = req_capsule_client_get(&req->rq_pill, &RMF_NAME);
if (name == NULL)
RETURN(-EFAULT);
CDEBUG(D_INFO, "%s: opening log %s\n", obd->obd_name, name);
}
if (body->lgd_ctxt_idx >= LLOG_MAX_CTXTS) {
CDEBUG(D_WARNING, "%s: bad ctxt ID: idx=%d name=%s\n",
obd->obd_name, body->lgd_ctxt_idx, name);
RETURN(-EPROTO);
}
ctxt = llog_get_context(obd, body->lgd_ctxt_idx);
if (ctxt == NULL) {
CDEBUG(D_WARNING, "%s: no ctxt. group=%p idx=%d name=%s\n",
obd->obd_name, &obd->obd_olg, body->lgd_ctxt_idx, name);
RETURN(-ENODEV);
}
rc = llog_open(req->rq_svc_thread->t_env, ctxt, &loghandle, logid,
name, LLOG_OPEN_EXISTS);
if (rc)
GOTO(out_ctxt, rc);
body = req_capsule_server_get(&req->rq_pill, &RMF_LLOGD_BODY);
body->lgd_logid = loghandle->lgh_id;
llog_origin_close(req->rq_svc_thread->t_env, loghandle);
EXIT;
out_ctxt:
llog_ctxt_put(ctxt);
return rc;
}
int llog_origin_handle_create(struct ptlrpc_request *req)
{
struct obd_export *exp = req->rq_export;
struct obd_device *obd = exp->exp_obd;
struct obd_device *disk_obd;
struct llog_handle *loghandle;
struct llogd_body *body;
struct lvfs_run_ctxt saved;
struct llog_logid *logid = NULL;
struct llog_ctxt *ctxt;
char *name = NULL;
int rc, rc2;
ENTRY;
body = req_capsule_client_get(&req->rq_pill, &RMF_LLOGD_BODY);
if (body == NULL)
RETURN(-EFAULT);
if (body->lgd_logid.lgl_oid > 0)
logid = &body->lgd_logid;
if (req_capsule_field_present(&req->rq_pill, &RMF_NAME, RCL_CLIENT)) {
name = req_capsule_client_get(&req->rq_pill, &RMF_NAME);
if (name == NULL)
RETURN(-EFAULT);
CDEBUG(D_INFO, "%s: opening log %s\n", obd->obd_name, name);
}
ctxt = llog_get_context(obd, body->lgd_ctxt_idx);
if (ctxt == NULL) {
CDEBUG(D_WARNING, "%s: no ctxt. group=%p idx=%d name=%s\n",
obd->obd_name, &obd->obd_olg, body->lgd_ctxt_idx, name);
RETURN(-ENODEV);
}
disk_obd = ctxt->loc_exp->exp_obd;
push_ctxt(&saved, &disk_obd->obd_lvfs_ctxt, NULL);
rc = llog_create(ctxt, &loghandle, logid, name);
if (rc)
GOTO(out_pop, rc);
rc = req_capsule_server_pack(&req->rq_pill);
if (rc)
GOTO(out_close, rc = -ENOMEM);
body = req_capsule_server_get(&req->rq_pill, &RMF_LLOGD_BODY);
body->lgd_logid = loghandle->lgh_id;
GOTO(out_close, rc);
out_close:
rc2 = llog_close(loghandle);
if (!rc)
rc = rc2;
out_pop:
pop_ctxt(&saved, &disk_obd->obd_lvfs_ctxt, NULL);
llog_ctxt_put(ctxt);
return rc;
}
static int llu_dir_do_readpage(struct inode *inode, struct page *page)
{
struct llu_inode_info *lli = llu_i2info(inode);
struct intnl_stat *st = llu_i2stat(inode);
struct llu_sb_info *sbi = llu_i2sbi(inode);
struct ptlrpc_request *request;
struct lustre_handle lockh;
struct mdt_body *body;
struct lookup_intent it = { .it_op = IT_READDIR };
struct md_op_data op_data = {{ 0 }};
ldlm_policy_data_t policy = { .l_inodebits = { MDS_INODELOCK_UPDATE } };
int rc = 0;
ENTRY;
llu_prep_md_op_data(&op_data, inode, NULL, NULL, 0, 0, LUSTRE_OPC_ANY);
rc = md_lock_match(sbi->ll_md_exp, LDLM_FL_BLOCK_GRANTED,
&lli->lli_fid, LDLM_IBITS, &policy, LCK_CR, &lockh);
if (!rc) {
struct ldlm_enqueue_info einfo = {
.ei_type = LDLM_IBITS,
.ei_mode = LCK_CR,
.ei_cb_bl = llu_md_blocking_ast,
.ei_cb_cp = ldlm_completion_ast,
.ei_cbdata = inode,
};
rc = md_enqueue(sbi->ll_md_exp, &einfo, &it,
&op_data, &lockh, NULL, 0, NULL,
LDLM_FL_CANCEL_ON_BLOCK);
request = (struct ptlrpc_request *)it.d.lustre.it_data;
if (request)
ptlrpc_req_finished(request);
if (rc < 0) {
CERROR("lock enqueue: err: %d\n", rc);
RETURN(rc);
}
}
ldlm_lock_dump_handle(D_OTHER, &lockh);
op_data.op_offset = (__u64)hash_x_index(page->index, 0);
op_data.op_npages = 1;
rc = md_readpage(sbi->ll_md_exp, &op_data, &page, &request);
if (!rc) {
body = req_capsule_server_get(&request->rq_pill, &RMF_MDT_BODY);
LASSERT(body != NULL); /* checked by md_readpage() */
if (body->valid & OBD_MD_FLSIZE)
st->st_size = body->size;
} else {
CERROR("read_dir_page(%ld) error %d\n", page->index, rc);
}
ptlrpc_req_finished(request);
EXIT;
ldlm_lock_decref(&lockh, LCK_CR);
return rc;
}
static int llog_client_read_header(const struct lu_env *env,
struct llog_handle *handle)
{
struct obd_import *imp;
struct ptlrpc_request *req = NULL;
struct llogd_body *body;
struct llog_log_hdr *hdr;
struct llog_rec_hdr *llh_hdr;
int rc;
LLOG_CLIENT_ENTRY(handle->lgh_ctxt, imp);
req = ptlrpc_request_alloc_pack(imp, &RQF_LLOG_ORIGIN_HANDLE_READ_HEADER,
LUSTRE_LOG_VERSION,
LLOG_ORIGIN_HANDLE_READ_HEADER);
if (req == NULL) {
rc = -ENOMEM;
goto err_exit;
}
body = req_capsule_client_get(&req->rq_pill, &RMF_LLOGD_BODY);
body->lgd_logid = handle->lgh_id;
body->lgd_ctxt_idx = handle->lgh_ctxt->loc_idx - 1;
body->lgd_llh_flags = handle->lgh_hdr->llh_flags;
ptlrpc_request_set_replen(req);
rc = ptlrpc_queue_wait(req);
if (rc)
goto out;
hdr = req_capsule_server_get(&req->rq_pill, &RMF_LLOG_LOG_HDR);
if (hdr == NULL) {
rc = -EFAULT;
goto out;
}
memcpy(handle->lgh_hdr, hdr, sizeof(*hdr));
handle->lgh_last_idx = handle->lgh_hdr->llh_tail.lrt_index;
/* sanity checks */
llh_hdr = &handle->lgh_hdr->llh_hdr;
if (llh_hdr->lrh_type != LLOG_HDR_MAGIC) {
CERROR("bad log header magic: %#x (expecting %#x)\n",
llh_hdr->lrh_type, LLOG_HDR_MAGIC);
rc = -EIO;
} else if (llh_hdr->lrh_len != LLOG_CHUNK_SIZE) {
CERROR("incorrectly sized log header: %#x "
"(expecting %#x)\n",
llh_hdr->lrh_len, LLOG_CHUNK_SIZE);
CERROR("you may need to re-run lconf --write_conf.\n");
rc = -EIO;
}
out:
ptlrpc_req_finished(req);
err_exit:
LLOG_CLIENT_EXIT(handle->lgh_ctxt, imp);
return rc;
}
/* if object is dying, pack the lov/llog data,
* parameter info->mti_attr should be valid at this point! */
int mdt_handle_last_unlink(struct mdt_thread_info *info, struct mdt_object *mo,
const struct md_attr *ma)
{
struct mdt_body *repbody;
const struct lu_attr *la = &ma->ma_attr;
int rc;
ENTRY;
repbody = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY);
LASSERT(repbody != NULL);
if (ma->ma_valid & MA_INODE)
mdt_pack_attr2body(info, repbody, la, mdt_object_fid(mo));
if (ma->ma_valid & MA_LOV) {
CERROR("No need in LOV EA upon unlink\n");
dump_stack();
}
repbody->eadatasize = 0;
if (ma->ma_cookie_size && (ma->ma_valid & MA_COOKIE)) {
repbody->aclsize = ma->ma_cookie_size;
repbody->valid |= OBD_MD_FLCOOKIE;
}
if (info->mti_mdt->mdt_opts.mo_oss_capa &&
exp_connect_flags(info->mti_exp) & OBD_CONNECT_OSS_CAPA &&
repbody->valid & OBD_MD_FLEASIZE) {
struct lustre_capa *capa;
capa = req_capsule_server_get(info->mti_pill, &RMF_CAPA2);
LASSERT(capa);
capa->lc_opc = CAPA_OPC_OSS_DESTROY;
rc = mo_capa_get(info->mti_env, mdt_object_child(mo), capa, 0);
if (rc)
RETURN(rc);
repbody->valid |= OBD_MD_FLOSSCAPA;
}
RETURN(0);
}
int llog_origin_handle_read_header(struct ptlrpc_request *req)
{
struct obd_export *exp = req->rq_export;
struct obd_device *obd = exp->exp_obd;
struct obd_device *disk_obd;
struct llog_handle *loghandle;
struct llogd_body *body;
struct llog_log_hdr *hdr;
struct lvfs_run_ctxt saved;
struct llog_ctxt *ctxt;
__u32 flags;
int rc, rc2;
ENTRY;
body = req_capsule_client_get(&req->rq_pill, &RMF_LLOGD_BODY);
if (body == NULL)
RETURN(-EFAULT);
ctxt = llog_get_context(obd, body->lgd_ctxt_idx);
if (ctxt == NULL)
RETURN(-ENODEV);
disk_obd = ctxt->loc_exp->exp_obd;
push_ctxt(&saved, &disk_obd->obd_lvfs_ctxt, NULL);
rc = llog_create(ctxt, &loghandle, &body->lgd_logid, NULL);
if (rc)
GOTO(out_pop, rc);
/*
* llog_init_handle() reads the llog header
*/
flags = body->lgd_llh_flags;
rc = llog_init_handle(loghandle, flags, NULL);
if (rc)
GOTO(out_close, rc);
rc = req_capsule_server_pack(&req->rq_pill);
if (rc)
GOTO(out_close, rc = -ENOMEM);
hdr = req_capsule_server_get(&req->rq_pill, &RMF_LLOG_LOG_HDR);
*hdr = *loghandle->lgh_hdr;
GOTO(out_close, rc);
out_close:
rc2 = llog_close(loghandle);
if (!rc)
rc = rc2;
out_pop:
pop_ctxt(&saved, &disk_obd->obd_lvfs_ctxt, NULL);
llog_ctxt_put(ctxt);
return rc;
}
int llog_origin_handle_destroy(struct ptlrpc_request *req)
{
struct obd_export *exp = req->rq_export;
struct obd_device *obd = exp->exp_obd;
struct obd_device *disk_obd;
struct llog_handle *loghandle;
struct llogd_body *body;
struct lvfs_run_ctxt saved;
struct llog_logid *logid = NULL;
struct llog_ctxt *ctxt;
int rc;
ENTRY;
body = req_capsule_client_get(&req->rq_pill, &RMF_LLOGD_BODY);
if (body == NULL)
RETURN(-EFAULT);
if (body->lgd_logid.lgl_oid > 0)
logid = &body->lgd_logid;
ctxt = llog_get_context(obd, body->lgd_ctxt_idx);
if (ctxt == NULL)
RETURN(-ENODEV);
disk_obd = ctxt->loc_exp->exp_obd;
push_ctxt(&saved, &disk_obd->obd_lvfs_ctxt, NULL);
rc = llog_create(ctxt, &loghandle, logid, NULL);
if (rc)
GOTO(out_pop, rc);
rc = req_capsule_server_pack(&req->rq_pill);
if (rc)
GOTO(out_close, rc = -ENOMEM);
body = req_capsule_server_get(&req->rq_pill, &RMF_LLOGD_BODY);
body->lgd_logid = loghandle->lgh_id;
rc = llog_init_handle(loghandle, LLOG_F_IS_PLAIN, NULL);
if (rc)
GOTO(out_close, rc);
rc = llog_destroy(loghandle);
if (rc)
GOTO(out_close, rc);
llog_free_handle(loghandle);
GOTO(out_close, rc);
out_close:
if (rc)
llog_close(loghandle);
out_pop:
pop_ctxt(&saved, &disk_obd->obd_lvfs_ctxt, NULL);
llog_ctxt_put(ctxt);
return rc;
}
int llog_origin_handle_read_header(struct ptlrpc_request *req)
{
struct llog_handle *loghandle;
struct llogd_body *body;
struct llog_log_hdr *hdr;
struct llog_ctxt *ctxt;
__u32 flags;
int rc;
ENTRY;
body = req_capsule_client_get(&req->rq_pill, &RMF_LLOGD_BODY);
if (body == NULL)
RETURN(err_serious(-EFAULT));
rc = req_capsule_server_pack(&req->rq_pill);
if (rc)
RETURN(err_serious(-ENOMEM));
if (body->lgd_ctxt_idx >= LLOG_MAX_CTXTS) {
CDEBUG(D_WARNING, "%s: bad ctxt ID: idx=%d\n",
req->rq_export->exp_obd->obd_name, body->lgd_ctxt_idx);
RETURN(-EPROTO);
}
ctxt = llog_get_context(req->rq_export->exp_obd, body->lgd_ctxt_idx);
if (ctxt == NULL)
RETURN(-ENODEV);
rc = llog_open(req->rq_svc_thread->t_env, ctxt, &loghandle,
&body->lgd_logid, NULL, LLOG_OPEN_EXISTS);
if (rc)
GOTO(out_ctxt, rc);
/*
* llog_init_handle() reads the llog header
*/
flags = body->lgd_llh_flags;
rc = llog_init_handle(req->rq_svc_thread->t_env, loghandle, flags,
NULL);
if (rc)
GOTO(out_close, rc);
flags = loghandle->lgh_hdr->llh_flags;
hdr = req_capsule_server_get(&req->rq_pill, &RMF_LLOG_LOG_HDR);
*hdr = *loghandle->lgh_hdr;
EXIT;
out_close:
llog_origin_close(req->rq_svc_thread->t_env, loghandle);
out_ctxt:
llog_ctxt_put(ctxt);
return rc;
}
/*
* Handler for: getattr, lookup and revalidate cases.
*/
int lmv_intent_lookup(struct obd_export *exp, struct md_op_data *op_data,
void *lmm, int lmmsize, struct lookup_intent *it,
int flags, struct ptlrpc_request **reqp,
ldlm_blocking_callback cb_blocking,
__u64 extra_lock_flags)
{
struct obd_device *obd = exp->exp_obd;
struct lmv_obd *lmv = &obd->u.lmv;
struct lmv_tgt_desc *tgt = NULL;
struct mdt_body *body;
int rc = 0;
tgt = lmv_locate_mds(lmv, op_data, &op_data->op_fid1);
if (IS_ERR(tgt))
return PTR_ERR(tgt);
if (!fid_is_sane(&op_data->op_fid2))
fid_zero(&op_data->op_fid2);
CDEBUG(D_INODE, "LOOKUP_INTENT with fid1="DFID", fid2="DFID
", name='%s' -> mds #%d\n", PFID(&op_data->op_fid1),
PFID(&op_data->op_fid2),
op_data->op_name ? op_data->op_name : "<NULL>",
tgt->ltd_idx);
op_data->op_bias &= ~MDS_CROSS_REF;
rc = md_intent_lock(tgt->ltd_exp, op_data, lmm, lmmsize, it,
flags, reqp, cb_blocking, extra_lock_flags);
if (rc < 0 || *reqp == NULL)
return rc;
/*
* MDS has returned success. Probably name has been resolved in
* remote inode. Let's check this.
*/
body = req_capsule_server_get(&(*reqp)->rq_pill, &RMF_MDT_BODY);
if (body == NULL)
return -EPROTO;
/* Not cross-ref case, just get out of here. */
if (likely(!(body->valid & OBD_MD_MDS)))
return 0;
rc = lmv_intent_remote(exp, lmm, lmmsize, it, NULL, flags, reqp,
cb_blocking, extra_lock_flags);
return rc;
}
/* Partial request to create object only */
static int mdt_md_mkobj(struct mdt_thread_info *info)
{
struct mdt_device *mdt = info->mti_mdt;
struct mdt_object *o;
struct mdt_body *repbody;
struct md_attr *ma = &info->mti_attr;
int rc;
ENTRY;
DEBUG_REQ(D_INODE, mdt_info_req(info), "Partial create "DFID"",
PFID(info->mti_rr.rr_fid2));
repbody = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY);
o = mdt_object_find(info->mti_env, mdt, info->mti_rr.rr_fid2,
MDT_OBJ_MAY_NOT_EXIST);
if (!IS_ERR(o)) {
struct md_object *next = mdt_object_child(o);
ma->ma_need = MA_INODE;
ma->ma_valid = 0;
/*
* Cross-ref create can encounter already created obj in case of
* recovery, just get attr in that case.
*/
if (mdt_object_exists(o) == 1) {
rc = mo_attr_get(info->mti_env, next, ma);
} else {
/*
* Here, NO permission check for object_create,
* such check has been done on the original MDS.
*/
rc = mo_object_create(info->mti_env, next,
&info->mti_spec, ma);
}
if (rc == 0) {
/* Return fid & attr to client. */
if (ma->ma_valid & MA_INODE)
mdt_pack_attr2body(info, repbody, &ma->ma_attr,
mdt_object_fid(o));
}
mdt_object_put(info->mti_env, o);
} else
rc = PTR_ERR(o);
mdt_create_pack_capa(info, rc, o, repbody);
RETURN(rc);
}
/*
* non-intent quota request interpret callback.
*
* \param env - the environment passed by the caller
* \param req - the non-intent quota request
* \param arg - qsd_async_args
* \param rc - request status
*
* \retval 0 - success
* \retval -ve - appropriate errors
*/
static int qsd_dqacq_interpret(const struct lu_env *env,
struct ptlrpc_request *req, void *arg, int rc)
{
struct quota_body *rep_qbody = NULL, *req_qbody;
struct qsd_async_args *aa = (struct qsd_async_args *)arg;
ENTRY;
req_qbody = req_capsule_client_get(&req->rq_pill, &RMF_QUOTA_BODY);
if (rc == 0 || rc == -EDQUOT || rc == -EINPROGRESS)
rep_qbody = req_capsule_server_get(&req->rq_pill,
&RMF_QUOTA_BODY);
aa->aa_completion(env, aa->aa_qqi, req_qbody, rep_qbody, &aa->aa_lockh,
NULL, aa->aa_arg, rc);
RETURN(rc);
}
/* mdc_setattr does its own semaphore handling */
static int mdc_reint(struct ptlrpc_request *request, int level)
{
int rc;
request->rq_send_state = level;
mdc_get_mod_rpc_slot(request, NULL);
rc = ptlrpc_queue_wait(request);
mdc_put_mod_rpc_slot(request, NULL);
if (rc)
CDEBUG(D_INFO, "error in handling %d\n", rc);
else if (!req_capsule_server_get(&request->rq_pill, &RMF_MDT_BODY)) {
rc = -EPROTO;
}
return rc;
}
/**
* Retrieve the current HSM flags, archive id and undergoing HSM requests for
* the fid provided in RPC body.
*
* Current requests are read from coordinator states.
*
* This is MDS_HSM_STATE_GET RPC handler.
*/
int mdt_hsm_state_get(struct tgt_session_info *tsi)
{
struct mdt_thread_info *info = tsi2mdt_info(tsi);
struct mdt_object *obj = info->mti_object;
struct md_attr *ma = &info->mti_attr;
struct hsm_user_state *hus;
struct mdt_lock_handle *lh;
int rc;
ENTRY;
if (info->mti_body == NULL || obj == NULL)
GOTO(out, rc = -EPROTO);
/* Only valid if client is remote */
rc = mdt_init_ucred(info, (struct mdt_body *)info->mti_body);
if (rc < 0)
GOTO(out, rc = err_serious(rc));
lh = &info->mti_lh[MDT_LH_CHILD];
mdt_lock_reg_init(lh, LCK_PR);
rc = mdt_object_lock(info, obj, lh, MDS_INODELOCK_LOOKUP);
if (rc < 0)
GOTO(out_ucred, rc);
ma->ma_valid = 0;
ma->ma_need = MA_HSM;
rc = mdt_attr_get_complex(info, obj, ma);
if (rc)
GOTO(out_unlock, rc);
hus = req_capsule_server_get(tsi->tsi_pill, &RMF_HSM_USER_STATE);
if (hus == NULL)
GOTO(out_unlock, rc = -EPROTO);
/* Current HSM flags */
hus->hus_states = ma->ma_hsm.mh_flags;
hus->hus_archive_id = ma->ma_hsm.mh_arch_id;
EXIT;
out_unlock:
mdt_object_unlock(info, obj, lh, 1);
out_ucred:
mdt_exit_ucred(info);
out:
mdt_thread_info_fini(info);
return rc;
}
int llog_catinfo(struct ptlrpc_request *req)
{
struct obd_export *exp = req->rq_export;
struct obd_device *obd = exp->exp_obd;
char *keyword;
char *buf, *reply;
int rc;
ENTRY;
OBD_ALLOC(buf, LLOG_CHUNK_SIZE);
if (buf == NULL)
RETURN(-ENOMEM);
memset(buf, 0, LLOG_CHUNK_SIZE);
keyword = req_capsule_client_get(&req->rq_pill, &RMF_NAME);
LASSERT(keyword);
if (strcmp(keyword, "config") == 0) {
char *client = req_capsule_client_get(&req->rq_pill,
&RMF_STRING);
LASSERT(client);
rc = llog_catinfo_config(obd, buf, LLOG_CHUNK_SIZE, client);
} else if (strcmp(keyword, "deletions") == 0) {
rc = llog_catinfo_deletions(obd, buf, LLOG_CHUNK_SIZE);
} else {
rc = -EOPNOTSUPP;
}
req_capsule_set_size(&req->rq_pill, &RMF_STRING, RCL_SERVER,
LLOG_CHUNK_SIZE);
rc = req_capsule_server_pack(&req->rq_pill);
if (rc)
GOTO(out_free, rc = -ENOMEM);
reply = req_capsule_server_get(&req->rq_pill, &RMF_STRING);
if (strlen(buf) == 0)
sprintf(buf, "%s", "No log informations\n");
memcpy(reply, buf, LLOG_CHUNK_SIZE);
EXIT;
out_free:
OBD_FREE(buf, LLOG_CHUNK_SIZE);
return rc;
}
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 seq_req_handle(struct ptlrpc_request *req,
const struct lu_env *env,
struct seq_thread_info *info)
{
struct lu_seq_range *out, *tmp;
struct lu_site *site;
int rc = -EPROTO;
__u32 *opc;
ENTRY;
LASSERT(!(lustre_msg_get_flags(req->rq_reqmsg) & MSG_REPLAY));
site = req->rq_export->exp_obd->obd_lu_dev->ld_site;
LASSERT(site != NULL);
rc = req_capsule_server_pack(info->sti_pill);
if (rc)
RETURN(err_serious(rc));
opc = req_capsule_client_get(info->sti_pill, &RMF_SEQ_OPC);
if (opc != NULL) {
out = req_capsule_server_get(info->sti_pill, &RMF_SEQ_RANGE);
if (out == NULL)
RETURN(err_serious(-EPROTO));
tmp = req_capsule_client_get(info->sti_pill, &RMF_SEQ_RANGE);
/* seq client passed mdt id, we need to pass that using out
* range parameter */
out->lsr_index = tmp->lsr_index;
out->lsr_flags = tmp->lsr_flags;
rc = seq_server_handle(site, env, *opc, out);
} else
rc = err_serious(-EPROTO);
RETURN(rc);
}
int osc_quotactl(struct obd_device *unused, struct obd_export *exp,
struct obd_quotactl *oqctl)
{
struct ptlrpc_request *req;
struct obd_quotactl *oqc;
int rc;
ENTRY;
req = ptlrpc_request_alloc_pack(class_exp2cliimp(exp),
&RQF_OST_QUOTACTL, LUSTRE_OST_VERSION,
OST_QUOTACTL);
if (req == NULL)
RETURN(-ENOMEM);
oqc = req_capsule_client_get(&req->rq_pill, &RMF_OBD_QUOTACTL);
*oqc = *oqctl;
ptlrpc_request_set_replen(req);
ptlrpc_at_set_req_timeout(req);
req->rq_no_resend = 1;
rc = ptlrpc_queue_wait(req);
if (rc)
CERROR("ptlrpc_queue_wait failed, rc: %d\n", rc);
if (req->rq_repmsg &&
(oqc = req_capsule_server_get(&req->rq_pill, &RMF_OBD_QUOTACTL))) {
*oqctl = *oqc;
} else if (!rc) {
CERROR ("Can't unpack obd_quotactl\n");
rc = -EPROTO;
}
ptlrpc_req_finished(req);
RETURN(rc);
}
int mdt_getxattr(struct mdt_thread_info *info)
{
struct ptlrpc_request *req = mdt_info_req(info);
struct mdt_export_data *med = mdt_req2med(req);
struct md_ucred *uc = mdt_ucred(info);
struct mdt_body *reqbody;
struct mdt_body *repbody = NULL;
struct md_object *next;
struct lu_buf *buf;
__u32 remote = exp_connect_rmtclient(info->mti_exp);
__u32 perm;
int easize, rc;
ENTRY;
LASSERT(info->mti_object != NULL);
LASSERT(lu_object_assert_exists(&info->mti_object->mot_obj.mo_lu));
CDEBUG(D_INODE, "getxattr "DFID"\n", PFID(&info->mti_body->fid1));
reqbody = req_capsule_client_get(info->mti_pill, &RMF_MDT_BODY);
if (reqbody == NULL)
RETURN(err_serious(-EFAULT));
rc = mdt_init_ucred(info, reqbody);
if (rc)
RETURN(err_serious(rc));
next = mdt_object_child(info->mti_object);
if (info->mti_body->valid & OBD_MD_FLRMTRGETFACL) {
if (unlikely(!remote))
GOTO(out, rc = err_serious(-EINVAL));
perm = mdt_identity_get_perm(uc->mu_identity, remote,
req->rq_peer.nid);
if (!(perm & CFS_RMTACL_PERM))
GOTO(out, rc = err_serious(-EPERM));
rc = mo_permission(info->mti_env, NULL, next, NULL,
MAY_RGETFACL);
if (rc)
GOTO(out, rc = err_serious(rc));
}
easize = mdt_getxattr_pack_reply(info);
if (easize < 0)
GOTO(out, rc = err_serious(easize));
repbody = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY);
LASSERT(repbody != NULL);
/* No need further getxattr. */
if (easize == 0 || reqbody->eadatasize == 0)
GOTO(out, rc = easize);
buf = &info->mti_buf;
buf->lb_buf = req_capsule_server_get(info->mti_pill, &RMF_EADATA);
buf->lb_len = easize;
if (info->mti_body->valid & OBD_MD_FLXATTR) {
int flags = CFS_IC_NOTHING;
char *xattr_name = req_capsule_client_get(info->mti_pill,
&RMF_NAME);
CDEBUG(D_INODE, "getxattr %s\n", xattr_name);
rc = mo_xattr_get(info->mti_env, next, buf, xattr_name);
if (rc < 0) {
CERROR("getxattr failed: %d\n", rc);
GOTO(out, rc);
}
if (info->mti_body->valid &
(OBD_MD_FLRMTLSETFACL | OBD_MD_FLRMTLGETFACL))
flags = CFS_IC_ALL;
else if (info->mti_body->valid & OBD_MD_FLRMTRGETFACL)
flags = CFS_IC_MAPPED;
if (rc > 0 && flags != CFS_IC_NOTHING) {
int rc1;
if (unlikely(!remote))
GOTO(out, rc = -EINVAL);
rc1 = lustre_posix_acl_xattr_id2client(uc,
med->med_idmap,
(posix_acl_xattr_header *)(buf->lb_buf),
rc, flags);
if (unlikely(rc1 < 0))
rc = rc1;
}
} else if (info->mti_body->valid & OBD_MD_FLXATTRLS) {
CDEBUG(D_INODE, "listxattr\n");
rc = mo_xattr_list(info->mti_env, next, buf);
if (rc < 0)
CDEBUG(D_INFO, "listxattr failed: %d\n", rc);
} else
LBUG();
EXIT;
out:
if (rc >= 0) {
mdt_counter_incr(req->rq_export, LPROC_MDT_GETXATTR);
repbody->eadatasize = rc;
rc = 0;
}
mdt_exit_ucred(info);
return rc;
}
int mdt_getxattr(struct mdt_thread_info *info)
{
struct ptlrpc_request *req = mdt_info_req(info);
struct mdt_export_data *med = mdt_req2med(req);
struct lu_ucred *uc = lu_ucred(info->mti_env);
struct mdt_body *reqbody;
struct mdt_body *repbody = NULL;
struct md_object *next;
struct lu_buf *buf;
__u32 remote = exp_connect_rmtclient(info->mti_exp);
__u32 perm;
int easize, rc;
obd_valid valid;
ENTRY;
LASSERT(info->mti_object != NULL);
LASSERT(lu_object_assert_exists(&info->mti_object->mot_obj));
CDEBUG(D_INODE, "getxattr "DFID"\n", PFID(&info->mti_body->fid1));
reqbody = req_capsule_client_get(info->mti_pill, &RMF_MDT_BODY);
if (reqbody == NULL)
RETURN(err_serious(-EFAULT));
rc = mdt_init_ucred(info, reqbody);
if (rc)
RETURN(err_serious(rc));
next = mdt_object_child(info->mti_object);
if (info->mti_body->valid & OBD_MD_FLRMTRGETFACL) {
if (unlikely(!remote))
GOTO(out, rc = err_serious(-EINVAL));
perm = mdt_identity_get_perm(uc->uc_identity, remote,
req->rq_peer.nid);
if (!(perm & CFS_RMTACL_PERM))
GOTO(out, rc = err_serious(-EPERM));
rc = mo_permission(info->mti_env, NULL, next, NULL,
MAY_RGETFACL);
if (rc)
GOTO(out, rc = err_serious(rc));
}
easize = mdt_getxattr_pack_reply(info);
if (easize < 0)
GOTO(out, rc = err_serious(easize));
repbody = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY);
LASSERT(repbody != NULL);
/* No need further getxattr. */
if (easize == 0 || reqbody->eadatasize == 0)
GOTO(out, rc = easize);
buf = &info->mti_buf;
buf->lb_buf = req_capsule_server_get(info->mti_pill, &RMF_EADATA);
buf->lb_len = easize;
valid = info->mti_body->valid & (OBD_MD_FLXATTR | OBD_MD_FLXATTRLS);
if (valid == OBD_MD_FLXATTR) {
char *xattr_name = req_capsule_client_get(info->mti_pill,
&RMF_NAME);
rc = mdt_getxattr_one(info, xattr_name, next, buf, med, uc);
} else if (valid == OBD_MD_FLXATTRLS) {
CDEBUG(D_INODE, "listxattr\n");
rc = mo_xattr_list(info->mti_env, next, buf);
if (rc < 0)
CDEBUG(D_INFO, "listxattr failed: %d\n", rc);
} else if (valid == OBD_MD_FLXATTRALL) {
rc = mdt_getxattr_all(info, reqbody, repbody,
buf, next);
} else
LBUG();
EXIT;
out:
if (rc >= 0) {
mdt_counter_incr(req, LPROC_MDT_GETXATTR);
repbody->eadatasize = rc;
rc = 0;
}
mdt_exit_ucred(info);
return rc;
}
static int seq_client_rpc(struct lu_client_seq *seq,
struct lu_seq_range *output, __u32 opc,
const char *opcname)
{
struct obd_export *exp = seq->lcs_exp;
struct ptlrpc_request *req;
struct lu_seq_range *out, *in;
__u32 *op;
unsigned int debug_mask;
int rc;
ENTRY;
LASSERT(exp != NULL && !IS_ERR(exp));
req = ptlrpc_request_alloc_pack(class_exp2cliimp(exp), &RQF_SEQ_QUERY,
LUSTRE_MDS_VERSION, SEQ_QUERY);
if (req == NULL)
RETURN(-ENOMEM);
/* Init operation code */
op = req_capsule_client_get(&req->rq_pill, &RMF_SEQ_OPC);
*op = opc;
/* Zero out input range, this is not recovery yet. */
in = req_capsule_client_get(&req->rq_pill, &RMF_SEQ_RANGE);
lu_seq_range_init(in);
ptlrpc_request_set_replen(req);
in->lsr_index = seq->lcs_space.lsr_index;
if (seq->lcs_type == LUSTRE_SEQ_METADATA)
fld_range_set_mdt(in);
else
fld_range_set_ost(in);
if (opc == SEQ_ALLOC_SUPER) {
req->rq_request_portal = SEQ_CONTROLLER_PORTAL;
req->rq_reply_portal = MDC_REPLY_PORTAL;
/* During allocating super sequence for data object,
* the current thread might hold the export of MDT0(MDT0
* precreating objects on this OST), and it will send the
* request to MDT0 here, so we can not keep resending the
* request here, otherwise if MDT0 is failed(umounted),
* it can not release the export of MDT0 */
if (seq->lcs_type == LUSTRE_SEQ_DATA)
req->rq_no_delay = req->rq_no_resend = 1;
debug_mask = D_CONSOLE;
} else {
if (seq->lcs_type == LUSTRE_SEQ_METADATA) {
req->rq_reply_portal = MDC_REPLY_PORTAL;
req->rq_request_portal = SEQ_METADATA_PORTAL;
} else {
req->rq_reply_portal = OSC_REPLY_PORTAL;
req->rq_request_portal = SEQ_DATA_PORTAL;
}
debug_mask = D_INFO;
}
/* Allow seq client RPC during recovery time. */
req->rq_allow_replay = 1;
ptlrpc_at_set_req_timeout(req);
rc = ptlrpc_queue_wait(req);
if (rc)
GOTO(out_req, rc);
out = req_capsule_server_get(&req->rq_pill, &RMF_SEQ_RANGE);
*output = *out;
if (!lu_seq_range_is_sane(output)) {
CERROR("%s: Invalid range received from server: "
DRANGE"\n", seq->lcs_name, PRANGE(output));
GOTO(out_req, rc = -EINVAL);
}
if (lu_seq_range_is_exhausted(output)) {
CERROR("%s: Range received from server is exhausted: "
DRANGE"]\n", seq->lcs_name, PRANGE(output));
GOTO(out_req, rc = -EINVAL);
}
CDEBUG_LIMIT(debug_mask, "%s: Allocated %s-sequence "DRANGE"]\n",
seq->lcs_name, opcname, PRANGE(output));
EXIT;
out_req:
ptlrpc_req_finished(req);
return rc;
}
static
int ll_getxattr_common(struct inode *inode, const char *name,
void *buffer, size_t size, __u64 valid)
{
struct ll_sb_info *sbi = ll_i2sbi(inode);
struct ptlrpc_request *req = NULL;
struct mdt_body *body;
int xattr_type, rc;
void *xdata;
struct obd_capa *oc;
struct rmtacl_ctl_entry *rce = NULL;
CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p)\n",
inode->i_ino, inode->i_generation, inode);
/* listxattr have slightly different behavior from of ext3:
* without 'user_xattr' ext3 will list all xattr names but
* filtered out "^user..*"; we list them all for simplicity.
*/
if (!name) {
xattr_type = XATTR_OTHER_T;
goto do_getxattr;
}
xattr_type = get_xattr_type(name);
rc = xattr_type_filter(sbi, xattr_type);
if (rc)
return rc;
/* b15587: ignore security.capability xattr for now */
if ((xattr_type == XATTR_SECURITY_T &&
strcmp(name, "security.capability") == 0))
return -ENODATA;
/* LU-549: Disable security.selinux when selinux is disabled */
if (xattr_type == XATTR_SECURITY_T && !selinux_is_enabled() &&
strcmp(name, "security.selinux") == 0)
return -EOPNOTSUPP;
#ifdef CONFIG_FS_POSIX_ACL
if (sbi->ll_flags & LL_SBI_RMT_CLIENT &&
(xattr_type == XATTR_ACL_ACCESS_T ||
xattr_type == XATTR_ACL_DEFAULT_T)) {
rce = rct_search(&sbi->ll_rct, current_pid());
if (rce == NULL ||
(rce->rce_ops != RMT_LSETFACL &&
rce->rce_ops != RMT_LGETFACL &&
rce->rce_ops != RMT_RSETFACL &&
rce->rce_ops != RMT_RGETFACL))
return -EOPNOTSUPP;
}
/* posix acl is under protection of LOOKUP lock. when calling to this,
* we just have path resolution to the target inode, so we have great
* chance that cached ACL is uptodate.
*/
if (xattr_type == XATTR_ACL_ACCESS_T &&
!(sbi->ll_flags & LL_SBI_RMT_CLIENT)) {
struct ll_inode_info *lli = ll_i2info(inode);
struct posix_acl *acl;
spin_lock(&lli->lli_lock);
acl = posix_acl_dup(lli->lli_posix_acl);
spin_unlock(&lli->lli_lock);
if (!acl)
return -ENODATA;
rc = posix_acl_to_xattr(&init_user_ns, acl, buffer, size);
posix_acl_release(acl);
return rc;
}
if (xattr_type == XATTR_ACL_DEFAULT_T && !S_ISDIR(inode->i_mode))
return -ENODATA;
#endif
do_getxattr:
if (sbi->ll_xattr_cache_enabled && (rce == NULL ||
rce->rce_ops == RMT_LGETFACL ||
rce->rce_ops == RMT_LSETFACL)) {
rc = ll_xattr_cache_get(inode, name, buffer, size, valid);
if (rc < 0)
GOTO(out_xattr, rc);
} else {
oc = ll_mdscapa_get(inode);
rc = md_getxattr(sbi->ll_md_exp, ll_inode2fid(inode), oc,
valid | (rce ? rce_ops2valid(rce->rce_ops) : 0),
name, NULL, 0, size, 0, &req);
capa_put(oc);
if (rc < 0)
GOTO(out_xattr, rc);
body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
LASSERT(body);
/* only detect the xattr size */
if (size == 0)
GOTO(out, rc = body->eadatasize);
if (size < body->eadatasize) {
CERROR("server bug: replied size %u > %u\n",
body->eadatasize, (int)size);
GOTO(out, rc = -ERANGE);
}
if (body->eadatasize == 0)
GOTO(out, rc = -ENODATA);
/* do not need swab xattr data */
xdata = req_capsule_server_sized_get(&req->rq_pill, &RMF_EADATA,
body->eadatasize);
if (!xdata)
GOTO(out, rc = -EFAULT);
memcpy(buffer, xdata, body->eadatasize);
rc = body->eadatasize;
}
#ifdef CONFIG_FS_POSIX_ACL
if (rce && rce->rce_ops == RMT_LSETFACL) {
ext_acl_xattr_header *acl;
acl = lustre_posix_acl_xattr_2ext(
(posix_acl_xattr_header *)buffer, rc);
if (IS_ERR(acl))
GOTO(out, rc = PTR_ERR(acl));
rc = ee_add(&sbi->ll_et, current_pid(), ll_inode2fid(inode),
xattr_type, acl);
if (unlikely(rc < 0)) {
lustre_ext_acl_xattr_free(acl);
GOTO(out, rc);
}
}
#endif
out_xattr:
if (rc == -EOPNOTSUPP && xattr_type == XATTR_USER_T) {
LCONSOLE_INFO(
"%s: disabling user_xattr feature because it is not supported on the server: rc = %d\n",
ll_get_fsname(inode->i_sb, NULL, 0), rc);
sbi->ll_flags &= ~LL_SBI_USER_XATTR;
}
out:
ptlrpc_req_finished(req);
return rc;
}
int ll_revalidate_it(struct dentry *de, int lookup_flags,
struct lookup_intent *it)
{
struct md_op_data *op_data;
struct ptlrpc_request *req = NULL;
struct lookup_intent lookup_it = { .it_op = IT_LOOKUP };
struct obd_export *exp;
struct inode *parent = de->d_parent->d_inode;
int rc, first = 0;
ENTRY;
CDEBUG(D_VFSTRACE, "VFS Op:name=%s,intent=%s\n", de->d_name.name,
LL_IT2STR(it));
if (de->d_inode == NULL) {
/* We can only use negative dentries if this is stat or lookup,
for opens and stuff we do need to query server. */
/* If there is IT_CREAT in intent op set, then we must throw
away this negative dentry and actually do the request to
kernel to create whatever needs to be created (if possible)*/
if (it && (it->it_op & IT_CREAT))
RETURN(0);
if (de->d_flags & DCACHE_LUSTRE_INVALID)
RETURN(0);
rc = ll_have_md_lock(parent, MDS_INODELOCK_UPDATE, LCK_MINMODE);
GOTO(out_sa, rc);
}
/* Never execute intents for mount points.
* Attributes will be fixed up in ll_inode_revalidate_it */
if (d_mountpoint(de))
GOTO(out_sa, rc = 1);
/* need to get attributes in case root got changed from other client */
if (de == de->d_sb->s_root) {
rc = __ll_inode_revalidate_it(de, it, MDS_INODELOCK_LOOKUP);
if (rc == 0)
rc = 1;
GOTO(out_sa, rc);
}
exp = ll_i2mdexp(de->d_inode);
OBD_FAIL_TIMEOUT(OBD_FAIL_MDC_REVALIDATE_PAUSE, 5);
ll_frob_intent(&it, &lookup_it);
LASSERT(it);
if (it->it_op == IT_LOOKUP && !(de->d_flags & DCACHE_LUSTRE_INVALID))
GOTO(out_sa, rc = 1);
op_data = ll_prep_md_op_data(NULL, parent, de->d_inode,
de->d_name.name, de->d_name.len,
0, LUSTRE_OPC_ANY, NULL);
if (IS_ERR(op_data))
RETURN(PTR_ERR(op_data));
if ((it->it_op == IT_OPEN) && de->d_inode) {
struct inode *inode = de->d_inode;
struct ll_inode_info *lli = ll_i2info(inode);
struct obd_client_handle **och_p;
__u64 *och_usecount;
/*
* We used to check for MDS_INODELOCK_OPEN here, but in fact
* just having LOOKUP lock is enough to justify inode is the
* same. And if inode is the same and we have suitable
* openhandle, then there is no point in doing another OPEN RPC
* just to throw away newly received openhandle. There are no
* security implications too, if file owner or access mode is
* change, LOOKUP lock is revoked.
*/
if (it->it_flags & FMODE_WRITE) {
och_p = &lli->lli_mds_write_och;
och_usecount = &lli->lli_open_fd_write_count;
} else if (it->it_flags & FMODE_EXEC) {
och_p = &lli->lli_mds_exec_och;
och_usecount = &lli->lli_open_fd_exec_count;
} else {
och_p = &lli->lli_mds_read_och;
och_usecount = &lli->lli_open_fd_read_count;
}
/* Check for the proper lock. */
if (!ll_have_md_lock(inode, MDS_INODELOCK_LOOKUP, LCK_MINMODE))
goto do_lock;
cfs_down(&lli->lli_och_sem);
if (*och_p) { /* Everything is open already, do nothing */
/*(*och_usecount)++; Do not let them steal our open
handle from under us */
/* XXX The code above was my original idea, but in case
we have the handle, but we cannot use it due to later
checks (e.g. O_CREAT|O_EXCL flags set), nobody
would decrement counter increased here. So we just
hope the lock won't be invalidated in between. But
if it would be, we'll reopen the open request to
MDS later during file open path */
cfs_up(&lli->lli_och_sem);
ll_finish_md_op_data(op_data);
RETURN(1);
} else {
cfs_up(&lli->lli_och_sem);
}
}
if (it->it_op == IT_GETATTR) {
first = ll_statahead_enter(parent, &de, 0);
if (first == 1) {
ll_statahead_exit(parent, de, 1);
ll_finish_md_op_data(op_data);
GOTO(out, rc = 1);
}
}
do_lock:
it->it_create_mode &= ~current->fs->umask;
it->it_create_mode |= M_CHECK_STALE;
rc = md_intent_lock(exp, op_data, NULL, 0, it,
lookup_flags,
&req, ll_md_blocking_ast, 0);
it->it_create_mode &= ~M_CHECK_STALE;
ll_finish_md_op_data(op_data);
if (it->it_op == IT_GETATTR && !first)
/* If there are too many locks on client-side, then some
* locks taken by statahead maybe dropped automatically
* before the real "revalidate" using them. */
ll_statahead_exit(parent, de, req == NULL ? rc : 0);
else if (first == -EEXIST)
ll_statahead_mark(parent, de);
/* If req is NULL, then md_intent_lock only tried to do a lock match;
* if all was well, it will return 1 if it found locks, 0 otherwise. */
if (req == NULL && rc >= 0) {
if (!rc)
goto do_lookup;
GOTO(out, rc);
}
if (rc < 0) {
if (rc != -ESTALE) {
CDEBUG(D_INFO, "ll_intent_lock: rc %d : it->it_status "
"%d\n", rc, it->d.lustre.it_status);
}
GOTO(out, rc = 0);
}
revalidate_finish:
rc = ll_revalidate_it_finish(req, it, de);
if (rc != 0) {
if (rc != -ESTALE && rc != -ENOENT)
ll_intent_release(it);
GOTO(out, rc = 0);
}
if ((it->it_op & IT_OPEN) && de->d_inode &&
!S_ISREG(de->d_inode->i_mode) &&
!S_ISDIR(de->d_inode->i_mode)) {
ll_release_openhandle(de, it);
}
rc = 1;
/* unfortunately ll_intent_lock may cause a callback and revoke our
* dentry */
cfs_spin_lock(&ll_lookup_lock);
spin_lock(&dcache_lock);
lock_dentry(de);
__d_drop(de);
unlock_dentry(de);
d_rehash_cond(de, 0);
spin_unlock(&dcache_lock);
cfs_spin_unlock(&ll_lookup_lock);
out:
/* We do not free request as it may be reused during following lookup
* (see comment in mdc/mdc_locks.c::mdc_intent_lock()), request will
* be freed in ll_lookup_it or in ll_intent_release. But if
* request was not completed, we need to free it. (bug 5154, 9903) */
if (req != NULL && !it_disposition(it, DISP_ENQ_COMPLETE))
ptlrpc_req_finished(req);
if (rc == 0) {
ll_unhash_aliases(de->d_inode);
/* done in ll_unhash_aliases()
dentry->d_flags |= DCACHE_LUSTRE_INVALID; */
} else {
CDEBUG(D_DENTRY, "revalidated dentry %.*s (%p) parent %p "
"inode %p refc %d\n", de->d_name.len,
de->d_name.name, de, de->d_parent, de->d_inode,
atomic_read(&de->d_count));
if (first != 1) {
if (de->d_flags & DCACHE_LUSTRE_INVALID) {
lock_dentry(de);
de->d_flags &= ~DCACHE_LUSTRE_INVALID;
unlock_dentry(de);
}
ll_lookup_finish_locks(it, de);
}
}
RETURN(rc);
/*
* This part is here to combat evil-evil race in real_lookup on 2.6
* kernels. The race details are: We enter do_lookup() looking for some
* name, there is nothing in dcache for this name yet and d_lookup()
* returns NULL. We proceed to real_lookup(), and while we do this,
* another process does open on the same file we looking up (most simple
* reproducer), open succeeds and the dentry is added. Now back to
* us. In real_lookup() we do d_lookup() again and suddenly find the
* dentry, so we call d_revalidate on it, but there is no lock, so
* without this code we would return 0, but unpatched real_lookup just
* returns -ENOENT in such a case instead of retrying the lookup. Once
* this is dealt with in real_lookup(), all of this ugly mess can go and
* we can just check locks in ->d_revalidate without doing any RPCs
* ever.
*/
do_lookup:
if (it != &lookup_it) {
/* MDS_INODELOCK_UPDATE needed for IT_GETATTR case. */
if (it->it_op == IT_GETATTR)
lookup_it.it_op = IT_GETATTR;
ll_lookup_finish_locks(it, de);
it = &lookup_it;
}
/* Do real lookup here. */
op_data = ll_prep_md_op_data(NULL, parent, NULL, de->d_name.name,
de->d_name.len, 0, (it->it_op & IT_CREAT ?
LUSTRE_OPC_CREATE :
LUSTRE_OPC_ANY), NULL);
if (IS_ERR(op_data))
RETURN(PTR_ERR(op_data));
rc = md_intent_lock(exp, op_data, NULL, 0, it, 0, &req,
ll_md_blocking_ast, 0);
if (rc >= 0) {
struct mdt_body *mdt_body;
struct lu_fid fid = {.f_seq = 0, .f_oid = 0, .f_ver = 0};
mdt_body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
if (de->d_inode)
fid = *ll_inode2fid(de->d_inode);
/* see if we got same inode, if not - return error */
if (lu_fid_eq(&fid, &mdt_body->fid1)) {
ll_finish_md_op_data(op_data);
op_data = NULL;
goto revalidate_finish;
}
ll_intent_release(it);
}
ll_finish_md_op_data(op_data);
GOTO(out, rc = 0);
out_sa:
/*
* For rc == 1 case, should not return directly to prevent losing
* statahead windows; for rc == 0 case, the "lookup" will be done later.
*/
if (it && it->it_op == IT_GETATTR && rc == 1) {
first = ll_statahead_enter(parent, &de, 0);
if (first >= 0)
ll_statahead_exit(parent, de, 1);
else if (first == -EEXIST)
ll_statahead_mark(parent, de);
}
return rc;
}
#if 0
static void ll_pin(struct dentry *de, struct vfsmount *mnt, int flag)
{
struct inode *inode= de->d_inode;
struct ll_sb_info *sbi = ll_i2sbi(inode);
struct ll_dentry_data *ldd = ll_d2d(de);
struct obd_client_handle *handle;
struct obd_capa *oc;
int rc = 0;
ENTRY;
LASSERT(ldd);
cfs_lock_kernel();
/* Strictly speaking this introduces an additional race: the
* increments should wait until the rpc has returned.
* However, given that at present the function is void, this
* issue is moot. */
if (flag == 1 && (++ldd->lld_mnt_count) > 1) {
cfs_unlock_kernel();
EXIT;
return;
}
if (flag == 0 && (++ldd->lld_cwd_count) > 1) {
cfs_unlock_kernel();
EXIT;
return;
}
cfs_unlock_kernel();
handle = (flag) ? &ldd->lld_mnt_och : &ldd->lld_cwd_och;
oc = ll_mdscapa_get(inode);
rc = obd_pin(sbi->ll_md_exp, ll_inode2fid(inode), oc, handle, flag);
capa_put(oc);
if (rc) {
cfs_lock_kernel();
memset(handle, 0, sizeof(*handle));
if (flag == 0)
ldd->lld_cwd_count--;
else
ldd->lld_mnt_count--;
cfs_unlock_kernel();
}
EXIT;
return;
}
static void ll_unpin(struct dentry *de, struct vfsmount *mnt, int flag)
{
struct ll_sb_info *sbi = ll_i2sbi(de->d_inode);
struct ll_dentry_data *ldd = ll_d2d(de);
struct obd_client_handle handle;
int count, rc = 0;
ENTRY;
LASSERT(ldd);
cfs_lock_kernel();
/* Strictly speaking this introduces an additional race: the
* increments should wait until the rpc has returned.
* However, given that at present the function is void, this
* issue is moot. */
handle = (flag) ? ldd->lld_mnt_och : ldd->lld_cwd_och;
if (handle.och_magic != OBD_CLIENT_HANDLE_MAGIC) {
/* the "pin" failed */
cfs_unlock_kernel();
EXIT;
return;
}
if (flag)
count = --ldd->lld_mnt_count;
else
count = --ldd->lld_cwd_count;
cfs_unlock_kernel();
if (count != 0) {
EXIT;
return;
}
rc = obd_unpin(sbi->ll_md_exp, &handle, flag);
EXIT;
return;
}
#endif
#ifdef HAVE_VFS_INTENT_PATCHES
int ll_revalidate_nd(struct dentry *dentry, struct nameidata *nd)
{
int rc;
ENTRY;
if (nd && nd->flags & LOOKUP_LAST && !(nd->flags & LOOKUP_LINK_NOTLAST))
rc = ll_revalidate_it(dentry, nd->flags, &nd->intent);
else
rc = ll_revalidate_it(dentry, 0, NULL);
RETURN(rc);
}
/**
* asks OST to clean precreate orphans
* and gets next id for new objects
*/
static int osp_precreate_cleanup_orphans(struct lu_env *env,
struct osp_device *d)
{
struct osp_thread_info *osi = osp_env_info(env);
struct lu_fid *last_fid = &osi->osi_fid;
struct ptlrpc_request *req = NULL;
struct obd_import *imp;
struct ost_body *body;
struct l_wait_info lwi = { 0 };
int update_status = 0;
int rc;
int diff;
ENTRY;
/*
* wait for local recovery to finish, so we can cleanup orphans
* orphans are all objects since "last used" (assigned), but
* there might be objects reserved and in some cases they won't
* be used. we can't cleanup them till we're sure they won't be
* used. also can't we allow new reservations because they may
* end up getting orphans being cleaned up below. so we block
* new reservations and wait till all reserved objects either
* user or released.
*/
spin_lock(&d->opd_pre_lock);
d->opd_pre_recovering = 1;
spin_unlock(&d->opd_pre_lock);
/*
* The locking above makes sure the opd_pre_reserved check below will
* catch all osp_precreate_reserve() calls who find
* "!opd_pre_recovering".
*/
l_wait_event(d->opd_pre_waitq,
(!d->opd_pre_reserved && d->opd_recovery_completed) ||
!osp_precreate_running(d) || d->opd_got_disconnected,
&lwi);
if (!osp_precreate_running(d) || d->opd_got_disconnected)
GOTO(out, rc = -EAGAIN);
CDEBUG(D_HA, "%s: going to cleanup orphans since "DFID"\n",
d->opd_obd->obd_name, PFID(&d->opd_last_used_fid));
*last_fid = d->opd_last_used_fid;
/* The OSP should already get the valid seq now */
LASSERT(!fid_is_zero(last_fid));
if (fid_oid(&d->opd_last_used_fid) < 2) {
/* lastfid looks strange... ask OST */
rc = osp_get_lastfid_from_ost(env, d);
if (rc)
GOTO(out, rc);
}
imp = d->opd_obd->u.cli.cl_import;
LASSERT(imp);
req = ptlrpc_request_alloc(imp, &RQF_OST_CREATE);
if (req == NULL)
GOTO(out, rc = -ENOMEM);
rc = ptlrpc_request_pack(req, LUSTRE_OST_VERSION, OST_CREATE);
if (rc) {
ptlrpc_request_free(req);
req = NULL;
GOTO(out, rc);
}
body = req_capsule_client_get(&req->rq_pill, &RMF_OST_BODY);
if (body == NULL)
GOTO(out, rc = -EPROTO);
body->oa.o_flags = OBD_FL_DELORPHAN;
body->oa.o_valid = OBD_MD_FLFLAGS | OBD_MD_FLGROUP;
fid_to_ostid(&d->opd_last_used_fid, &body->oa.o_oi);
ptlrpc_request_set_replen(req);
/* Don't resend the delorphan req */
req->rq_no_resend = req->rq_no_delay = 1;
rc = ptlrpc_queue_wait(req);
if (rc) {
update_status = 1;
GOTO(out, rc);
}
body = req_capsule_server_get(&req->rq_pill, &RMF_OST_BODY);
if (body == NULL)
GOTO(out, rc = -EPROTO);
/*
* OST provides us with id new pool starts from in body->oa.o_id
*/
ostid_to_fid(last_fid, &body->oa.o_oi, d->opd_index);
spin_lock(&d->opd_pre_lock);
diff = lu_fid_diff(&d->opd_last_used_fid, last_fid);
if (diff > 0) {
d->opd_pre_grow_count = OST_MIN_PRECREATE + diff;
d->opd_pre_last_created_fid = d->opd_last_used_fid;
} else {
d->opd_pre_grow_count = OST_MIN_PRECREATE;
d->opd_pre_last_created_fid = *last_fid;
}
/*
* This empties the pre-creation pool and effectively blocks any new
* reservations.
*/
LASSERT(fid_oid(&d->opd_pre_last_created_fid) <=
LUSTRE_DATA_SEQ_MAX_WIDTH);
d->opd_pre_used_fid = d->opd_pre_last_created_fid;
d->opd_pre_grow_slow = 0;
spin_unlock(&d->opd_pre_lock);
CDEBUG(D_HA, "%s: Got last_id "DFID" from OST, last_created "DFID
"last_used is "DFID"\n", d->opd_obd->obd_name, PFID(last_fid),
PFID(&d->opd_pre_last_created_fid), PFID(&d->opd_last_used_fid));
out:
if (req)
ptlrpc_req_finished(req);
spin_lock(&d->opd_pre_lock);
d->opd_pre_recovering = 0;
spin_unlock(&d->opd_pre_lock);
/*
* If rc is zero, the pre-creation window should have been emptied.
* Since waking up the herd would be useless without pre-created
* objects, we defer the signal to osp_precreate_send() in that case.
*/
if (rc != 0) {
if (update_status) {
CERROR("%s: cannot cleanup orphans: rc = %d\n",
d->opd_obd->obd_name, rc);
/* we can't proceed from here, OST seem to
* be in a bad shape, better to wait for
* a new instance of the server and repeat
* from the beginning. notify possible waiters
* this OSP isn't quite functional yet */
osp_pre_update_status(d, rc);
} else {
wake_up(&d->opd_pre_user_waitq);
}
}
RETURN(rc);
}
static int osp_get_lastfid_from_ost(const struct lu_env *env,
struct osp_device *d)
{
struct ptlrpc_request *req = NULL;
struct obd_import *imp;
struct lu_fid *last_fid;
char *tmp;
int rc;
ENTRY;
imp = d->opd_obd->u.cli.cl_import;
LASSERT(imp);
req = ptlrpc_request_alloc(imp, &RQF_OST_GET_INFO_LAST_FID);
if (req == NULL)
RETURN(-ENOMEM);
req_capsule_set_size(&req->rq_pill, &RMF_GETINFO_KEY, RCL_CLIENT,
sizeof(KEY_LAST_FID));
rc = ptlrpc_request_pack(req, LUSTRE_OST_VERSION, OST_GET_INFO);
if (rc) {
ptlrpc_request_free(req);
RETURN(rc);
}
tmp = req_capsule_client_get(&req->rq_pill, &RMF_GETINFO_KEY);
memcpy(tmp, KEY_LAST_FID, sizeof(KEY_LAST_FID));
req->rq_no_delay = req->rq_no_resend = 1;
last_fid = req_capsule_client_get(&req->rq_pill, &RMF_FID);
fid_cpu_to_le(last_fid, &d->opd_last_used_fid);
ptlrpc_request_set_replen(req);
rc = ptlrpc_queue_wait(req);
if (rc) {
/* bad-bad OST.. let sysadm sort this out */
if (rc == -ENOTSUPP) {
CERROR("%s: server does not support FID: rc = %d\n",
d->opd_obd->obd_name, -ENOTSUPP);
}
ptlrpc_set_import_active(imp, 0);
GOTO(out, rc);
}
last_fid = req_capsule_server_get(&req->rq_pill, &RMF_FID);
if (last_fid == NULL) {
CERROR("%s: Got last_fid failed.\n", d->opd_obd->obd_name);
GOTO(out, rc = -EPROTO);
}
if (!fid_is_sane(last_fid)) {
CERROR("%s: Got insane last_fid "DFID"\n",
d->opd_obd->obd_name, PFID(last_fid));
GOTO(out, rc = -EPROTO);
}
/* Only update the last used fid, if the OST has objects for
* this sequence, i.e. fid_oid > 0 */
if (fid_oid(last_fid) > 0)
d->opd_last_used_fid = *last_fid;
CDEBUG(D_HA, "%s: Got last_fid "DFID"\n", d->opd_obd->obd_name,
PFID(last_fid));
out:
ptlrpc_req_finished(req);
RETURN(rc);
}