/*
* Glimpse callback handler for all quota locks. This function extracts
* information from the glimpse request.
*
* \param lock - is the lock targeted by the glimpse
* \param data - is a pointer to the glimpse ptlrpc request
* \param req - is the glimpse request
* \param desc - is the glimpse descriptor describing the purpose of the glimpse
* request.
* \param lvb - is the pointer to the lvb in the reply buffer
*
* \retval 0 on success and \desc, \lvb & \arg point to a valid structures,
* appropriate error on failure
*/
static int qsd_common_glimpse_ast(struct ptlrpc_request *req,
struct ldlm_gl_lquota_desc **desc, void **lvb)
{
int rc;
ENTRY;
LASSERT(lustre_msg_get_opc(req->rq_reqmsg) == LDLM_GL_CALLBACK);
/* glimpse on quota locks always packs a glimpse descriptor */
req_capsule_extend(&req->rq_pill, &RQF_LDLM_GL_DESC_CALLBACK);
/* extract glimpse descriptor */
*desc = req_capsule_client_get(&req->rq_pill, &RMF_DLM_GL_DESC);
if (*desc == NULL)
RETURN(-EFAULT);
/* prepare reply */
req_capsule_set_size(&req->rq_pill, &RMF_DLM_LVB, RCL_SERVER,
sizeof(struct lquota_lvb));
rc = req_capsule_server_pack(&req->rq_pill);
if (rc != 0) {
CERROR("Can't pack response, rc %d\n", rc);
RETURN(rc);
}
/* extract lvb */
*lvb = req_capsule_server_get(&req->rq_pill, &RMF_DLM_LVB);
RETURN(0);
}
int llog_origin_handle_next_block(struct ptlrpc_request *req)
{
struct llog_handle *loghandle;
struct llogd_body *body;
struct llogd_body *repbody;
struct llog_ctxt *ctxt;
__u32 flags;
void *ptr;
int rc;
ENTRY;
body = req_capsule_client_get(&req->rq_pill, &RMF_LLOGD_BODY);
if (body == NULL)
RETURN(err_serious(-EFAULT));
req_capsule_set_size(&req->rq_pill, &RMF_EADATA, RCL_SERVER,
LLOG_MIN_CHUNK_SIZE);
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);
flags = body->lgd_llh_flags;
rc = llog_init_handle(req->rq_svc_thread->t_env, loghandle, flags,
NULL);
if (rc)
GOTO(out_close, rc);
repbody = req_capsule_server_get(&req->rq_pill, &RMF_LLOGD_BODY);
*repbody = *body;
ptr = req_capsule_server_get(&req->rq_pill, &RMF_EADATA);
rc = llog_next_block(req->rq_svc_thread->t_env, loghandle,
&repbody->lgd_saved_index, repbody->lgd_index,
&repbody->lgd_cur_offset, ptr,
LLOG_MIN_CHUNK_SIZE);
if (rc)
GOTO(out_close, rc);
EXIT;
out_close:
llog_origin_close(req->rq_svc_thread->t_env, loghandle);
out_ctxt:
llog_ctxt_put(ctxt);
return rc;
}
int llog_origin_handle_destroy(struct ptlrpc_request *req)
{
struct llogd_body *body;
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(err_serious(-EFAULT));
rc = req_capsule_server_pack(&req->rq_pill);
if (rc < 0)
RETURN(err_serious(-ENOMEM));
if (ostid_id(&body->lgd_logid.lgl_oi) > 0)
logid = &body->lgd_logid;
if (!(body->lgd_llh_flags & LLOG_F_IS_PLAIN))
CERROR("%s: wrong llog flags %x\n",
req->rq_export->exp_obd->obd_name, body->lgd_llh_flags);
ctxt = llog_get_context(req->rq_export->exp_obd, body->lgd_ctxt_idx);
if (ctxt == NULL)
RETURN(-ENODEV);
rc = llog_erase(req->rq_svc_thread->t_env, ctxt, logid, NULL);
llog_ctxt_put(ctxt);
RETURN(rc);
}
static int mgs_set_info_rpc(struct ptlrpc_request *req)
{
struct obd_device *obd = req->rq_export->exp_obd;
struct mgs_send_param *msp, *rep_msp;
int rc;
struct lustre_cfg_bufs bufs;
struct lustre_cfg *lcfg;
char fsname[MTI_NAME_MAXLEN];
ENTRY;
msp = req_capsule_client_get(&req->rq_pill, &RMF_MGS_SEND_PARAM);
LASSERT(msp);
/* Construct lustre_cfg structure to pass to function mgs_setparam */
lustre_cfg_bufs_reset(&bufs, NULL);
lustre_cfg_bufs_set_string(&bufs, 1, msp->mgs_param);
lcfg = lustre_cfg_new(LCFG_PARAM, &bufs);
rc = mgs_setparam(obd, lcfg, fsname);
if (rc) {
CERROR("Error %d in setting the parameter %s for fs %s\n",
rc, msp->mgs_param, fsname);
RETURN(rc);
}
lustre_cfg_free(lcfg);
rc = req_capsule_server_pack(&req->rq_pill);
if (rc == 0) {
rep_msp = req_capsule_server_get(&req->rq_pill, &RMF_MGS_SEND_PARAM);
rep_msp = msp;
}
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 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);
}
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;
}
/* 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;
}
/* return EADATA length to the caller. negative value means error */
static int mdt_getxattr_pack_reply(struct mdt_thread_info * info)
{
struct req_capsule *pill = info->mti_pill ;
struct ptlrpc_request *req = mdt_info_req(info);
char *xattr_name;
__u64 valid = info->mti_body->valid;
static const char user_string[] = "user.";
int size, rc;
ENTRY;
if (OBD_FAIL_CHECK(OBD_FAIL_MDS_GETXATTR_PACK))
RETURN(-ENOMEM);
/* Determine how many bytes we need */
if (valid & OBD_MD_FLXATTR) {
xattr_name = req_capsule_client_get(pill, &RMF_NAME);
if (!xattr_name)
RETURN(-EFAULT);
if (!(req->rq_export->exp_connect_flags & OBD_CONNECT_XATTR) &&
!strncmp(xattr_name, user_string, sizeof(user_string) - 1))
RETURN(-EOPNOTSUPP);
size = mo_xattr_get(info->mti_env,
mdt_object_child(info->mti_object),
&LU_BUF_NULL, xattr_name);
} else if (valid & OBD_MD_FLXATTRLS) {
size = mo_xattr_list(info->mti_env,
mdt_object_child(info->mti_object),
&LU_BUF_NULL);
} else {
CDEBUG(D_INFO, "Valid bits: "LPX64"\n", info->mti_body->valid);
RETURN(-EINVAL);
}
if (size == -ENODATA) {
size = 0;
} else if (size < 0) {
CERROR("Error geting EA size: %d\n", size);
RETURN(size);
}
if (info->mti_body->eadatasize != 0 &&
info->mti_body->eadatasize < size)
RETURN(-ERANGE);
req_capsule_set_size(pill, &RMF_EADATA, RCL_SERVER,
info->mti_body->eadatasize == 0 ? 0 : size);
rc = req_capsule_server_pack(pill);
if (rc) {
LASSERT(rc < 0);
RETURN(rc);
}
RETURN(size);
}
int llog_origin_handle_close(struct ptlrpc_request *req)
{
int rc;
ENTRY;
rc = req_capsule_server_pack(&req->rq_pill);
if (rc)
RETURN(err_serious(-ENOMEM));
RETURN(0);
}
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 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_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;
}
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 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);
}
/* Called whenever a target starts up. Flags indicate first connect, etc. */
static int mgs_handle_target_reg(struct ptlrpc_request *req)
{
struct obd_device *obd = req->rq_export->exp_obd;
struct mgs_target_info *mti, *rep_mti;
struct fs_db *fsdb;
int opc;
int rc = 0;
ENTRY;
mgs_counter_incr(req->rq_export, LPROC_MGS_TARGET_REG);
mti = req_capsule_client_get(&req->rq_pill, &RMF_MGS_TARGET_INFO);
opc = mti->mti_flags & LDD_F_OPC_MASK;
if (opc == LDD_F_OPC_READY) {
CDEBUG(D_MGS, "fs: %s index: %d is ready to reconnect.\n",
mti->mti_fsname, mti->mti_stripe_index);
rc = mgs_ir_update(obd, mti);
if (rc) {
LASSERT(!(mti->mti_flags & LDD_F_IR_CAPABLE));
CERROR("Update IR return with %d(ignore and IR "
"disabled)\n", rc);
}
GOTO(out_nolock, rc);
}
/* Do not support unregistering right now. */
if (opc != LDD_F_OPC_REG)
GOTO(out_nolock, rc = -EINVAL);
CDEBUG(D_MGS, "fs: %s index: %d is registered to MGS.\n",
mti->mti_fsname, mti->mti_stripe_index);
if (mti->mti_flags & LDD_F_NEED_INDEX)
mti->mti_flags |= LDD_F_WRITECONF;
if (!(mti->mti_flags & (LDD_F_WRITECONF | LDD_F_UPGRADE14 |
LDD_F_UPDATE))) {
/* We're just here as a startup ping. */
CDEBUG(D_MGS, "Server %s is running on %s\n",
mti->mti_svname, obd_export_nid2str(req->rq_export));
rc = mgs_check_target(obd, mti);
/* above will set appropriate mti flags */
if (rc <= 0)
/* Nothing wrong, or fatal error */
GOTO(out_nolock, rc);
} else {
if (!(mti->mti_flags & LDD_F_NO_PRIMNODE)
&& (rc = mgs_check_failover_reg(mti)))
GOTO(out_nolock, rc);
}
OBD_FAIL_TIMEOUT(OBD_FAIL_MGS_PAUSE_TARGET_REG, 10);
if (mti->mti_flags & LDD_F_WRITECONF) {
if (mti->mti_flags & LDD_F_SV_TYPE_MDT &&
mti->mti_stripe_index == 0) {
rc = mgs_erase_logs(obd, mti->mti_fsname);
LCONSOLE_WARN("%s: Logs for fs %s were removed by user "
"request. All servers must be restarted "
"in order to regenerate the logs."
"\n", obd->obd_name, mti->mti_fsname);
} else if (mti->mti_flags &
(LDD_F_SV_TYPE_OST | LDD_F_SV_TYPE_MDT)) {
rc = mgs_erase_log(obd, mti->mti_svname);
LCONSOLE_WARN("%s: Regenerating %s log by user "
"request.\n",
obd->obd_name, mti->mti_svname);
}
mti->mti_flags |= LDD_F_UPDATE;
/* Erased logs means start from scratch. */
mti->mti_flags &= ~LDD_F_UPGRADE14;
}
rc = mgs_find_or_make_fsdb(obd, mti->mti_fsname, &fsdb);
if (rc) {
CERROR("Can't get db for %s: %d\n", mti->mti_fsname, rc);
GOTO(out_nolock, rc);
}
/*
* Log writing contention is handled by the fsdb_mutex.
*
* It should be alright if someone was reading while we were
* updating the logs - if we revoke at the end they will just update
* from where they left off.
*/
/* COMPAT_146 */
if (mti->mti_flags & LDD_F_UPGRADE14) {
rc = mgs_upgrade_sv_14(obd, mti, fsdb);
if (rc) {
CERROR("Can't upgrade from 1.4 (%d)\n", rc);
GOTO(out, rc);
}
/* We're good to go */
mti->mti_flags |= LDD_F_UPDATE;
}
/* end COMPAT_146 */
if (mti->mti_flags & LDD_F_UPDATE) {
CDEBUG(D_MGS, "updating %s, index=%d\n", mti->mti_svname,
mti->mti_stripe_index);
/* create or update the target log
and update the client/mdt logs */
rc = mgs_write_log_target(obd, mti, fsdb);
if (rc) {
CERROR("Failed to write %s log (%d)\n",
mti->mti_svname, rc);
GOTO(out, rc);
}
mti->mti_flags &= ~(LDD_F_VIRGIN | LDD_F_UPDATE |
LDD_F_NEED_INDEX | LDD_F_WRITECONF |
LDD_F_UPGRADE14);
mti->mti_flags |= LDD_F_REWRITE_LDD;
}
out:
mgs_revoke_lock(obd, fsdb, CONFIG_T_CONFIG);
out_nolock:
CDEBUG(D_MGS, "replying with %s, index=%d, rc=%d\n", mti->mti_svname,
mti->mti_stripe_index, rc);
req->rq_status = rc;
if (rc)
/* we need an error flag to tell the target what's going on,
* instead of just doing it by error code only. */
mti->mti_flags |= LDD_F_ERROR;
rc = req_capsule_server_pack(&req->rq_pill);
if (rc)
RETURN(rc);
/* send back the whole mti in the reply */
rep_mti = req_capsule_server_get(&req->rq_pill, &RMF_MGS_TARGET_INFO);
*rep_mti = *mti;
/* Flush logs to disk */
fsfilt_sync(obd, obd->u.mgs.mgs_sb);
RETURN(rc);
}
/* return EADATA length to the caller. negative value means error */
static int mdt_getxattr_pack_reply(struct mdt_thread_info * info)
{
struct req_capsule *pill = info->mti_pill ;
struct ptlrpc_request *req = mdt_info_req(info);
char *xattr_name;
__u64 valid;
static const char user_string[] = "user.";
int size, rc;
ENTRY;
if (OBD_FAIL_CHECK(OBD_FAIL_MDS_GETXATTR_PACK))
RETURN(-ENOMEM);
valid = info->mti_body->valid & (OBD_MD_FLXATTR | OBD_MD_FLXATTRLS);
/* Determine how many bytes we need */
if (valid == OBD_MD_FLXATTR) {
xattr_name = req_capsule_client_get(pill, &RMF_NAME);
if (!xattr_name)
RETURN(-EFAULT);
if (!(exp_connect_flags(req->rq_export) & OBD_CONNECT_XATTR) &&
!strncmp(xattr_name, user_string, sizeof(user_string) - 1))
RETURN(-EOPNOTSUPP);
size = mo_xattr_get(info->mti_env,
mdt_object_child(info->mti_object),
&LU_BUF_NULL, xattr_name);
} else if (valid == OBD_MD_FLXATTRLS) {
size = mo_xattr_list(info->mti_env,
mdt_object_child(info->mti_object),
&LU_BUF_NULL);
} else if (valid == OBD_MD_FLXATTRALL) {
/* N.B. eadatasize = 0 is not valid for FLXATTRALL */
/* We could calculate accurate sizes, but this would
* introduce a lot of overhead, let's do it later... */
size = info->mti_body->eadatasize;
req_capsule_set_size(pill, &RMF_EAVALS, RCL_SERVER, size);
req_capsule_set_size(pill, &RMF_EAVALS_LENS, RCL_SERVER, size);
} else {
CDEBUG(D_INFO, "Valid bits: "LPX64"\n", info->mti_body->valid);
RETURN(-EINVAL);
}
if (size == -ENODATA) {
size = 0;
} else if (size < 0) {
CERROR("Error geting EA size: %d\n", size);
RETURN(size);
}
req_capsule_set_size(pill, &RMF_EADATA, RCL_SERVER,
info->mti_body->eadatasize == 0 ? 0 : size);
rc = req_capsule_server_pack(pill);
if (rc) {
LASSERT(rc < 0);
RETURN(rc);
}
RETURN(size);
}
/**
* Object updates between Targets. Because all the updates has been
* dis-assemblied into object updates at sender side, so OUT will
* call OSD API directly to execute these updates.
*
* In DNE phase I all of the updates in the request need to be executed
* in one transaction, and the transaction has to be synchronously.
*
* Please refer to lustre/include/lustre/lustre_idl.h for req/reply
* format.
*/
int out_handle(struct tgt_session_info *tsi)
{
const struct lu_env *env = tsi->tsi_env;
struct tgt_thread_info *tti = tgt_th_info(env);
struct thandle_exec_args *ta = &tti->tti_tea;
struct req_capsule *pill = tsi->tsi_pill;
struct dt_device *dt = tsi->tsi_tgt->lut_bottom;
struct update_buf *ubuf;
struct update *update;
struct update_reply *update_reply;
int bufsize;
int count;
int old_batchid = -1;
unsigned off;
int i;
int rc = 0;
int rc1 = 0;
ENTRY;
req_capsule_set(pill, &RQF_UPDATE_OBJ);
bufsize = req_capsule_get_size(pill, &RMF_UPDATE, RCL_CLIENT);
if (bufsize != UPDATE_BUFFER_SIZE) {
CERROR("%s: invalid bufsize %d: rc = %d\n",
tgt_name(tsi->tsi_tgt), bufsize, -EPROTO);
RETURN(err_serious(-EPROTO));
}
ubuf = req_capsule_client_get(pill, &RMF_UPDATE);
if (ubuf == NULL) {
CERROR("%s: No buf!: rc = %d\n", tgt_name(tsi->tsi_tgt),
-EPROTO);
RETURN(err_serious(-EPROTO));
}
if (le32_to_cpu(ubuf->ub_magic) != UPDATE_BUFFER_MAGIC) {
CERROR("%s: invalid magic %x expect %x: rc = %d\n",
tgt_name(tsi->tsi_tgt), le32_to_cpu(ubuf->ub_magic),
UPDATE_BUFFER_MAGIC, -EPROTO);
RETURN(err_serious(-EPROTO));
}
count = le32_to_cpu(ubuf->ub_count);
if (count <= 0) {
CERROR("%s: No update!: rc = %d\n",
tgt_name(tsi->tsi_tgt), -EPROTO);
RETURN(err_serious(-EPROTO));
}
req_capsule_set_size(pill, &RMF_UPDATE_REPLY, RCL_SERVER,
UPDATE_BUFFER_SIZE);
rc = req_capsule_server_pack(pill);
if (rc != 0) {
CERROR("%s: Can't pack response: rc = %d\n",
tgt_name(tsi->tsi_tgt), rc);
RETURN(rc);
}
/* Prepare the update reply buffer */
update_reply = req_capsule_server_get(pill, &RMF_UPDATE_REPLY);
if (update_reply == NULL)
RETURN(err_serious(-EPROTO));
update_init_reply_buf(update_reply, count);
tti->tti_u.update.tti_update_reply = update_reply;
rc = out_tx_start(env, dt, ta);
if (rc != 0)
RETURN(rc);
tti->tti_mult_trans = !req_is_replay(tgt_ses_req(tsi));
/* Walk through updates in the request to execute them synchronously */
off = cfs_size_round(offsetof(struct update_buf, ub_bufs[0]));
for (i = 0; i < count; i++) {
struct tgt_handler *h;
struct dt_object *dt_obj;
update = (struct update *)((char *)ubuf + off);
if (old_batchid == -1) {
old_batchid = update->u_batchid;
} else if (old_batchid != update->u_batchid) {
/* Stop the current update transaction,
* create a new one */
rc = out_tx_end(env, ta);
if (rc != 0)
RETURN(rc);
rc = out_tx_start(env, dt, ta);
if (rc != 0)
RETURN(rc);
old_batchid = update->u_batchid;
}
fid_le_to_cpu(&update->u_fid, &update->u_fid);
if (!fid_is_sane(&update->u_fid)) {
CERROR("%s: invalid FID "DFID": rc = %d\n",
tgt_name(tsi->tsi_tgt), PFID(&update->u_fid),
-EPROTO);
GOTO(out, rc = err_serious(-EPROTO));
}
dt_obj = dt_locate(env, dt, &update->u_fid);
if (IS_ERR(dt_obj))
GOTO(out, rc = PTR_ERR(dt_obj));
tti->tti_u.update.tti_dt_object = dt_obj;
tti->tti_u.update.tti_update = update;
tti->tti_u.update.tti_update_reply_index = i;
h = out_handler_find(update->u_type);
if (likely(h != NULL)) {
/* For real modification RPC, check if the update
* has been executed */
if (h->th_flags & MUTABOR) {
struct ptlrpc_request *req = tgt_ses_req(tsi);
if (out_check_resent(env, dt, dt_obj, req,
out_reconstruct,
update_reply, i))
GOTO(next, rc);
}
rc = h->th_act(tsi);
} else {
CERROR("%s: The unsupported opc: 0x%x\n",
tgt_name(tsi->tsi_tgt), update->u_type);
lu_object_put(env, &dt_obj->do_lu);
GOTO(out, rc = -ENOTSUPP);
}
next:
lu_object_put(env, &dt_obj->do_lu);
if (rc < 0)
GOTO(out, rc);
off += cfs_size_round(update_size(update));
}
out:
rc1 = out_tx_end(env, ta);
if (rc == 0)
rc = rc1;
RETURN(rc);
}
/**
* Object updates between Targets. Because all the updates has been
* dis-assemblied into object updates at sender side, so OUT will
* call OSD API directly to execute these updates.
*
* In DNE phase I all of the updates in the request need to be executed
* in one transaction, and the transaction has to be synchronously.
*
* Please refer to lustre/include/lustre/lustre_idl.h for req/reply
* format.
*/
int out_handle(struct tgt_session_info *tsi)
{
const struct lu_env *env = tsi->tsi_env;
struct tgt_thread_info *tti = tgt_th_info(env);
struct thandle_exec_args *ta = &tti->tti_tea;
struct req_capsule *pill = tsi->tsi_pill;
struct dt_device *dt = tsi->tsi_tgt->lut_bottom;
struct out_update_header *ouh;
struct out_update_buffer *oub = NULL;
struct object_update *update;
struct object_update_reply *reply;
struct ptlrpc_bulk_desc *desc = NULL;
struct l_wait_info lwi;
void **update_bufs;
int current_batchid = -1;
__u32 update_buf_count;
unsigned int i;
unsigned int reply_index = 0;
int rc = 0;
int rc1 = 0;
int ouh_size, reply_size;
int updates;
ENTRY;
req_capsule_set(pill, &RQF_OUT_UPDATE);
ouh_size = req_capsule_get_size(pill, &RMF_OUT_UPDATE_HEADER,
RCL_CLIENT);
if (ouh_size <= 0)
RETURN(err_serious(-EPROTO));
ouh = req_capsule_client_get(pill, &RMF_OUT_UPDATE_HEADER);
if (ouh == NULL)
RETURN(err_serious(-EPROTO));
if (ouh->ouh_magic != OUT_UPDATE_HEADER_MAGIC) {
CERROR("%s: invalid update buffer magic %x expect %x: "
"rc = %d\n", tgt_name(tsi->tsi_tgt), ouh->ouh_magic,
UPDATE_REQUEST_MAGIC, -EPROTO);
RETURN(err_serious(-EPROTO));
}
update_buf_count = ouh->ouh_count;
if (update_buf_count == 0)
RETURN(err_serious(-EPROTO));
OBD_ALLOC(update_bufs, sizeof(*update_bufs) * update_buf_count);
if (update_bufs == NULL)
RETURN(err_serious(-ENOMEM));
if (ouh->ouh_inline_length > 0) {
update_bufs[0] = ouh->ouh_inline_data;
} else {
struct out_update_buffer *tmp;
oub = req_capsule_client_get(pill, &RMF_OUT_UPDATE_BUF);
if (oub == NULL)
GOTO(out_free, rc = err_serious(-EPROTO));
desc = ptlrpc_prep_bulk_exp(pill->rc_req, update_buf_count,
PTLRPC_BULK_OPS_COUNT,
PTLRPC_BULK_GET_SINK |
PTLRPC_BULK_BUF_KVEC,
MDS_BULK_PORTAL,
&ptlrpc_bulk_kvec_ops);
if (desc == NULL)
GOTO(out_free, rc = err_serious(-ENOMEM));
tmp = oub;
for (i = 0; i < update_buf_count; i++, tmp++) {
if (tmp->oub_size >= OUT_MAXREQSIZE)
GOTO(out_free, rc = err_serious(-EPROTO));
OBD_ALLOC(update_bufs[i], tmp->oub_size);
if (update_bufs[i] == NULL)
GOTO(out_free, rc = err_serious(-ENOMEM));
desc->bd_frag_ops->add_iov_frag(desc, update_bufs[i],
tmp->oub_size);
}
pill->rc_req->rq_bulk_write = 1;
rc = sptlrpc_svc_prep_bulk(pill->rc_req, desc);
if (rc != 0)
GOTO(out_free, rc = err_serious(rc));
rc = target_bulk_io(pill->rc_req->rq_export, desc, &lwi);
if (rc < 0)
GOTO(out_free, rc = err_serious(rc));
}
/* validate the request and calculate the total update count and
* set it to reply */
reply_size = 0;
updates = 0;
for (i = 0; i < update_buf_count; i++) {
struct object_update_request *our;
int j;
our = update_bufs[i];
if (ptlrpc_req_need_swab(pill->rc_req))
lustre_swab_object_update_request(our);
if (our->ourq_magic != UPDATE_REQUEST_MAGIC) {
CERROR("%s: invalid update buffer magic %x"
" expect %x: rc = %d\n",
tgt_name(tsi->tsi_tgt), our->ourq_magic,
UPDATE_REQUEST_MAGIC, -EPROTO);
GOTO(out_free, rc = err_serious(-EPROTO));
}
updates += our->ourq_count;
/* need to calculate reply size */
for (j = 0; j < our->ourq_count; j++) {
update = object_update_request_get(our, j, NULL);
if (update == NULL)
GOTO(out, rc = err_serious(-EPROTO));
if (ptlrpc_req_need_swab(pill->rc_req))
lustre_swab_object_update(update);
if (!fid_is_sane(&update->ou_fid)) {
CERROR("%s: invalid FID "DFID": rc = %d\n",
tgt_name(tsi->tsi_tgt),
PFID(&update->ou_fid), -EPROTO);
GOTO(out, rc = err_serious(-EPROTO));
}
/* XXX: what ou_result_size can be considered safe? */
reply_size += sizeof(reply->ourp_lens[0]);
reply_size += sizeof(struct object_update_result);
reply_size += update->ou_result_size;
}
}
reply_size += sizeof(*reply);
if (unlikely(reply_size > ouh->ouh_reply_size)) {
CERROR("%s: too small reply buf %u for %u, need %u at least\n",
tgt_name(tsi->tsi_tgt), ouh->ouh_reply_size,
updates, reply_size);
GOTO(out_free, rc = err_serious(-EPROTO));
}
req_capsule_set_size(pill, &RMF_OUT_UPDATE_REPLY, RCL_SERVER,
ouh->ouh_reply_size);
rc = req_capsule_server_pack(pill);
if (rc != 0) {
CERROR("%s: Can't pack response: rc = %d\n",
tgt_name(tsi->tsi_tgt), rc);
GOTO(out_free, rc = err_serious(-EPROTO));
}
/* Prepare the update reply buffer */
reply = req_capsule_server_get(pill, &RMF_OUT_UPDATE_REPLY);
if (reply == NULL)
GOTO(out_free, rc = -EPROTO);
reply->ourp_magic = UPDATE_REPLY_MAGIC;
reply->ourp_count = updates;
tti->tti_u.update.tti_update_reply = reply;
tti->tti_mult_trans = !req_is_replay(tgt_ses_req(tsi));
/* Walk through updates in the request to execute them */
for (i = 0; i < update_buf_count; i++) {
struct tgt_handler *h;
struct dt_object *dt_obj;
int update_count;
struct object_update_request *our;
int j;
our = update_bufs[i];
update_count = our->ourq_count;
for (j = 0; j < update_count; j++) {
update = object_update_request_get(our, j, NULL);
dt_obj = dt_locate(env, dt, &update->ou_fid);
if (IS_ERR(dt_obj))
GOTO(out, rc = PTR_ERR(dt_obj));
if (dt->dd_record_fid_accessed) {
lfsck_pack_rfa(&tti->tti_lr,
lu_object_fid(&dt_obj->do_lu),
LE_FID_ACCESSED,
LFSCK_TYPE_LAYOUT);
tgt_lfsck_in_notify(env, dt, &tti->tti_lr,
NULL);
}
tti->tti_u.update.tti_dt_object = dt_obj;
tti->tti_u.update.tti_update = update;
tti->tti_u.update.tti_update_reply_index = reply_index;
h = out_handler_find(update->ou_type);
if (unlikely(h == NULL)) {
CERROR("%s: unsupported opc: 0x%x\n",
tgt_name(tsi->tsi_tgt), update->ou_type);
GOTO(next, rc = -ENOTSUPP);
}
/* Check resend case only for modifying RPC */
if (h->th_flags & MUTABOR) {
struct ptlrpc_request *req = tgt_ses_req(tsi);
if (out_check_resent(env, dt, dt_obj, req,
out_reconstruct, reply,
reply_index))
GOTO(next, rc = 0);
}
/* start transaction for modification RPC only */
if (h->th_flags & MUTABOR && current_batchid == -1) {
current_batchid = update->ou_batchid;
rc = out_tx_start(env, dt, ta, tsi->tsi_exp);
if (rc != 0)
GOTO(next, rc);
if (update->ou_flags & UPDATE_FL_SYNC)
ta->ta_handle->th_sync = 1;
}
/* Stop the current update transaction, if the update
* has different batchid, or read-only update */
if (((current_batchid != update->ou_batchid) ||
!(h->th_flags & MUTABOR)) &&
ta->ta_handle != NULL) {
rc = out_tx_end(env, ta, rc);
current_batchid = -1;
if (rc != 0)
GOTO(next, rc);
/* start a new transaction if needed */
if (h->th_flags & MUTABOR) {
rc = out_tx_start(env, dt, ta,
tsi->tsi_exp);
if (rc != 0)
GOTO(next, rc);
if (update->ou_flags & UPDATE_FL_SYNC)
ta->ta_handle->th_sync = 1;
current_batchid = update->ou_batchid;
}
}
rc = h->th_act(tsi);
next:
reply_index++;
lu_object_put(env, &dt_obj->do_lu);
if (rc < 0)
GOTO(out, rc);
}
}
out:
if (current_batchid != -1) {
rc1 = out_tx_end(env, ta, rc);
if (rc == 0)
rc = rc1;
}
out_free:
if (update_bufs != NULL) {
if (oub != NULL) {
for (i = 0; i < update_buf_count; i++, oub++) {
if (update_bufs[i] != NULL)
OBD_FREE(update_bufs[i], oub->oub_size);
}
}
OBD_FREE(update_bufs, sizeof(*update_bufs) * update_buf_count);
}
if (desc != NULL)
ptlrpc_free_bulk(desc);
RETURN(rc);
}
/* return EADATA length to the caller. negative value means error */
static int mdt_getxattr_pack_reply(struct mdt_thread_info * info)
{
struct req_capsule *pill = info->mti_pill;
struct ptlrpc_request *req = mdt_info_req(info);
const char *xattr_name;
u64 valid;
static const char user_string[] = "user.";
int size;
int rc = 0;
int rc2;
ENTRY;
valid = info->mti_body->mbo_valid & (OBD_MD_FLXATTR | OBD_MD_FLXATTRLS);
/* Determine how many bytes we need */
if (valid == OBD_MD_FLXATTR) {
xattr_name = req_capsule_client_get(pill, &RMF_NAME);
if (!xattr_name)
RETURN(-EFAULT);
if (!(exp_connect_flags(req->rq_export) & OBD_CONNECT_XATTR) &&
!strncmp(xattr_name, user_string, sizeof(user_string) - 1))
RETURN(-EOPNOTSUPP);
size = mo_xattr_get(info->mti_env,
mdt_object_child(info->mti_object),
&LU_BUF_NULL, xattr_name);
if (size == -ENODATA) {
/* XXX: Some client code will not handle -ENODATA
* for XATTR_NAME_LOV (trusted.lov) properly. */
if (strcmp(xattr_name, XATTR_NAME_LOV) == 0)
rc = 0;
else
rc = -ENODATA;
size = 0;
}
} else if (valid == OBD_MD_FLXATTRLS) {
xattr_name = "list";
size = mo_xattr_list(info->mti_env,
mdt_object_child(info->mti_object),
&LU_BUF_NULL);
} else if (valid == OBD_MD_FLXATTRALL) {
xattr_name = "all";
/* N.B. eadatasize = 0 is not valid for FLXATTRALL */
/* We could calculate accurate sizes, but this would
* introduce a lot of overhead, let's do it later... */
size = info->mti_body->mbo_eadatasize;
req_capsule_set_size(pill, &RMF_EAVALS, RCL_SERVER, size);
req_capsule_set_size(pill, &RMF_EAVALS_LENS, RCL_SERVER, size);
} else {
CDEBUG(D_INFO, "Valid bits: %#llx\n",
info->mti_body->mbo_valid);
RETURN(-EINVAL);
}
if (size < 0) {
if (size != -EOPNOTSUPP && size != -ENOENT)
CERROR("%s: error geting EA size for '%s': rc = %d\n",
mdt_obd_name(info->mti_mdt), xattr_name, size);
RETURN(size);
}
if (req_capsule_has_field(pill, &RMF_ACL, RCL_SERVER))
req_capsule_set_size(pill, &RMF_ACL, RCL_SERVER,
LUSTRE_POSIX_ACL_MAX_SIZE_OLD);
req_capsule_set_size(pill, &RMF_EADATA, RCL_SERVER,
info->mti_body->mbo_eadatasize == 0 ? 0 : size);
rc2 = req_capsule_server_pack(pill);
if (rc2 < 0)
RETURN(rc2);
if (OBD_FAIL_CHECK(OBD_FAIL_MDS_GETXATTR_PACK))
RETURN(-ENOMEM);
RETURN(rc < 0 ? rc : size);
}
/**
* Object updates between Targets. Because all the updates has been
* dis-assemblied into object updates at sender side, so OUT will
* call OSD API directly to execute these updates.
*
* In DNE phase I all of the updates in the request need to be executed
* in one transaction, and the transaction has to be synchronously.
*
* Please refer to lustre/include/lustre/lustre_idl.h for req/reply
* format.
*/
int out_handle(struct tgt_session_info *tsi)
{
const struct lu_env *env = tsi->tsi_env;
struct tgt_thread_info *tti = tgt_th_info(env);
struct thandle_exec_args *ta = &tti->tti_tea;
struct req_capsule *pill = tsi->tsi_pill;
struct dt_device *dt = tsi->tsi_tgt->lut_bottom;
struct object_update_request *ureq;
struct object_update *update;
struct object_update_reply *reply;
int bufsize;
int count;
int old_batchid = -1;
int i;
int rc = 0;
int rc1 = 0;
ENTRY;
req_capsule_set(pill, &RQF_OUT_UPDATE);
ureq = req_capsule_client_get(pill, &RMF_OUT_UPDATE);
if (ureq == NULL) {
CERROR("%s: No buf!: rc = %d\n", tgt_name(tsi->tsi_tgt),
-EPROTO);
RETURN(err_serious(-EPROTO));
}
bufsize = req_capsule_get_size(pill, &RMF_OUT_UPDATE, RCL_CLIENT);
if (bufsize != object_update_request_size(ureq)) {
CERROR("%s: invalid bufsize %d: rc = %d\n",
tgt_name(tsi->tsi_tgt), bufsize, -EPROTO);
RETURN(err_serious(-EPROTO));
}
if (ureq->ourq_magic != UPDATE_REQUEST_MAGIC) {
CERROR("%s: invalid update buffer magic %x expect %x: "
"rc = %d\n", tgt_name(tsi->tsi_tgt), ureq->ourq_magic,
UPDATE_REQUEST_MAGIC, -EPROTO);
RETURN(err_serious(-EPROTO));
}
count = ureq->ourq_count;
if (count <= 0) {
CERROR("%s: empty update: rc = %d\n", tgt_name(tsi->tsi_tgt),
-EPROTO);
RETURN(err_serious(-EPROTO));
}
req_capsule_set_size(pill, &RMF_OUT_UPDATE_REPLY, RCL_SERVER,
OUT_UPDATE_REPLY_SIZE);
rc = req_capsule_server_pack(pill);
if (rc != 0) {
CERROR("%s: Can't pack response: rc = %d\n",
tgt_name(tsi->tsi_tgt), rc);
RETURN(rc);
}
/* Prepare the update reply buffer */
reply = req_capsule_server_get(pill, &RMF_OUT_UPDATE_REPLY);
if (reply == NULL)
RETURN(err_serious(-EPROTO));
object_update_reply_init(reply, count);
tti->tti_u.update.tti_update_reply = reply;
rc = out_tx_start(env, dt, ta, tsi->tsi_exp);
if (rc != 0)
RETURN(rc);
tti->tti_mult_trans = !req_is_replay(tgt_ses_req(tsi));
/* Walk through updates in the request to execute them synchronously */
for (i = 0; i < count; i++) {
struct tgt_handler *h;
struct dt_object *dt_obj;
update = object_update_request_get(ureq, i, NULL);
if (update == NULL)
GOTO(out, rc = -EPROTO);
if (ptlrpc_req_need_swab(pill->rc_req))
lustre_swab_object_update(update);
if (old_batchid == -1) {
old_batchid = update->ou_batchid;
} else if (old_batchid != update->ou_batchid) {
/* Stop the current update transaction,
* create a new one */
rc = out_tx_end(env, ta);
if (rc < 0)
RETURN(rc);
rc = out_tx_start(env, dt, ta, tsi->tsi_exp);
if (rc != 0)
RETURN(rc);
old_batchid = update->ou_batchid;
}
if (!fid_is_sane(&update->ou_fid)) {
CERROR("%s: invalid FID "DFID": rc = %d\n",
tgt_name(tsi->tsi_tgt), PFID(&update->ou_fid),
-EPROTO);
GOTO(out, rc = err_serious(-EPROTO));
}
dt_obj = dt_locate(env, dt, &update->ou_fid);
if (IS_ERR(dt_obj))
GOTO(out, rc = PTR_ERR(dt_obj));
if (dt->dd_record_fid_accessed) {
lfsck_pack_rfa(&tti->tti_lr,
lu_object_fid(&dt_obj->do_lu));
tgt_lfsck_in_notify(env, dt, &tti->tti_lr);
}
tti->tti_u.update.tti_dt_object = dt_obj;
tti->tti_u.update.tti_update = update;
tti->tti_u.update.tti_update_reply_index = i;
h = out_handler_find(update->ou_type);
if (likely(h != NULL)) {
/* For real modification RPC, check if the update
* has been executed */
if (h->th_flags & MUTABOR) {
struct ptlrpc_request *req = tgt_ses_req(tsi);
if (out_check_resent(env, dt, dt_obj, req,
out_reconstruct, reply, i))
GOTO(next, rc);
}
rc = h->th_act(tsi);
} else {
CERROR("%s: The unsupported opc: 0x%x\n",
tgt_name(tsi->tsi_tgt), update->ou_type);
lu_object_put(env, &dt_obj->do_lu);
GOTO(out, rc = -ENOTSUPP);
}
next:
lu_object_put(env, &dt_obj->do_lu);
if (rc < 0)
GOTO(out, rc);
}
out:
rc1 = out_tx_end(env, ta);
if (rc == 0)
rc = rc1;
RETURN(rc);
}
int llog_origin_handle_prev_block(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 llogd_body *repbody;
struct obd_device *disk_obd;
struct lvfs_run_ctxt saved;
struct llog_ctxt *ctxt;
__u32 flags;
__u8 *buf;
void *ptr;
int rc, rc2;
ENTRY;
body = req_capsule_client_get(&req->rq_pill, &RMF_LLOGD_BODY);
if (body == NULL)
RETURN(-EFAULT);
OBD_ALLOC(buf, LLOG_CHUNK_SIZE);
if (!buf)
RETURN(-ENOMEM);
ctxt = llog_get_context(obd, body->lgd_ctxt_idx);
if (ctxt == NULL)
GOTO(out_free, rc = -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);
flags = body->lgd_llh_flags;
rc = llog_init_handle(loghandle, flags, NULL);
if (rc)
GOTO(out_close, rc);
memset(buf, 0, LLOG_CHUNK_SIZE);
rc = llog_prev_block(loghandle, body->lgd_index,
buf, LLOG_CHUNK_SIZE);
if (rc)
GOTO(out_close, rc);
req_capsule_set_size(&req->rq_pill, &RMF_EADATA, RCL_SERVER,
LLOG_CHUNK_SIZE);
rc = req_capsule_server_pack(&req->rq_pill);
if (rc)
GOTO(out_close, rc = -ENOMEM);
repbody = req_capsule_server_get(&req->rq_pill, &RMF_LLOGD_BODY);
*repbody = *body;
ptr = req_capsule_server_get(&req->rq_pill, &RMF_EADATA);
memcpy(ptr, buf, LLOG_CHUNK_SIZE);
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);
out_free:
OBD_FREE(buf, LLOG_CHUNK_SIZE);
return rc;
}
/**
* Object updates between Targets. Because all the updates has been
* dis-assemblied into object updates in master MDD layer, so out
* will skip MDD layer, and call OSD API directly to execute these
* updates.
*
* In phase I, all of the updates in the request need to be executed
* in one transaction, and the transaction has to be synchronously.
*
* Please refer to lustre/include/lustre/lustre_idl.h for req/reply
* format.
*/
int out_handle(struct mdt_thread_info *info)
{
struct req_capsule *pill = info->mti_pill;
struct update_buf *ubuf;
struct update *update;
struct thandle_exec_args *th = &info->mti_handle;
int bufsize;
int count;
unsigned off;
int i;
int rc = 0;
int rc1 = 0;
ENTRY;
req_capsule_set(pill, &RQF_UPDATE_OBJ);
bufsize = req_capsule_get_size(pill, &RMF_UPDATE, RCL_CLIENT);
if (bufsize != UPDATE_BUFFER_SIZE) {
CERROR("%s: invalid bufsize %d: rc = %d\n",
mdt_obd_name(info->mti_mdt), bufsize, -EPROTO);
RETURN(err_serious(-EPROTO));
}
ubuf = req_capsule_client_get(pill, &RMF_UPDATE);
if (ubuf == NULL) {
CERROR("%s: No buf!: rc = %d\n", mdt_obd_name(info->mti_mdt),
-EPROTO);
RETURN(err_serious(-EPROTO));
}
if (le32_to_cpu(ubuf->ub_magic) != UPDATE_BUFFER_MAGIC) {
CERROR("%s: invalid magic %x expect %x: rc = %d\n",
mdt_obd_name(info->mti_mdt), le32_to_cpu(ubuf->ub_magic),
UPDATE_BUFFER_MAGIC, -EPROTO);
RETURN(err_serious(-EPROTO));
}
count = le32_to_cpu(ubuf->ub_count);
if (count <= 0) {
CERROR("%s: No update!: rc = %d\n",
mdt_obd_name(info->mti_mdt), -EPROTO);
RETURN(err_serious(-EPROTO));
}
req_capsule_set_size(pill, &RMF_UPDATE_REPLY, RCL_SERVER,
UPDATE_BUFFER_SIZE);
rc = req_capsule_server_pack(pill);
if (rc != 0) {
CERROR("%s: Can't pack response: rc = %d\n",
mdt_obd_name(info->mti_mdt), rc);
RETURN(rc);
}
/* Prepare the update reply buffer */
info->mti_u.update.mti_update_reply =
req_capsule_server_get(pill, &RMF_UPDATE_REPLY);
update_init_reply_buf(info->mti_u.update.mti_update_reply, count);
rc = out_tx_start(info->mti_env, info->mti_mdt, th);
if (rc != 0)
RETURN(rc);
/* Walk through updates in the request to execute them synchronously */
off = cfs_size_round(offsetof(struct update_buf, ub_bufs[0]));
for (i = 0; i < count; i++) {
struct out_handler *h;
struct dt_object *dt_obj;
update = (struct update *)((char *)ubuf + off);
fid_le_to_cpu(&update->u_fid, &update->u_fid);
if (!fid_is_sane(&update->u_fid)) {
CERROR("%s: invalid FID "DFID": rc = %d\n",
mdt_obd_name(info->mti_mdt),
PFID(&update->u_fid), -EPROTO);
GOTO(out, rc = err_serious(-EPROTO));
}
dt_obj = out_object_find(info, &update->u_fid);
if (IS_ERR(dt_obj))
GOTO(out, rc = PTR_ERR(dt_obj));
info->mti_u.update.mti_dt_object = dt_obj;
info->mti_u.update.mti_update = update;
info->mti_u.update.mti_update_reply_index = i;
h = mdt_handler_find(update->u_type, out_handlers);
if (likely(h != NULL)) {
rc = h->mh_act(info);
} else {
CERROR("%s: The unsupported opc: 0x%x\n",
mdt_obd_name(info->mti_mdt), update->u_type);
lu_object_put(info->mti_env, &dt_obj->do_lu);
GOTO(out, rc = -ENOTSUPP);
}
lu_object_put(info->mti_env, &dt_obj->do_lu);
if (rc < 0)
GOTO(out, rc);
off += cfs_size_round(update_size(update));
}
out:
rc1 = out_tx_end(info, th);
rc = rc == 0 ? rc1 : rc;
info->mti_fail_id = OBD_FAIL_UPDATE_OBJ_NET;
RETURN(rc);
}