/*
* 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);
}
static int mdt_hsm_release_unpack(struct mdt_thread_info *info)
{
struct md_attr *ma = &info->mti_attr;
struct req_capsule *pill = info->mti_pill;
ENTRY;
if (!(ma->ma_attr_flags & MDS_HSM_RELEASE))
RETURN(0);
req_capsule_extend(pill, &RQF_MDS_RELEASE_CLOSE);
if (!(req_capsule_has_field(pill, &RMF_CLOSE_DATA, RCL_CLIENT) &&
req_capsule_field_present(pill, &RMF_CLOSE_DATA, RCL_CLIENT)))
RETURN(-EFAULT);
RETURN(0);
}
/* TODO: handle requests in a similar way as MDT: see mdt_handle_common() */
static int ldlm_callback_handler(struct ptlrpc_request *req)
{
struct ldlm_namespace *ns;
struct ldlm_request *dlm_req;
struct ldlm_lock *lock;
int rc;
/* Requests arrive in sender's byte order. The ptlrpc service
* handler has already checked and, if necessary, byte-swapped the
* incoming request message body, but I am responsible for the
* message buffers. */
/* do nothing for sec context finalize */
if (lustre_msg_get_opc(req->rq_reqmsg) == SEC_CTX_FINI)
return 0;
req_capsule_init(&req->rq_pill, req, RCL_SERVER);
if (req->rq_export == NULL) {
rc = ldlm_callback_reply(req, -ENOTCONN);
ldlm_callback_errmsg(req, "Operate on unconnected server",
rc, NULL);
return 0;
}
LASSERT(req->rq_export != NULL);
LASSERT(req->rq_export->exp_obd != NULL);
switch (lustre_msg_get_opc(req->rq_reqmsg)) {
case LDLM_BL_CALLBACK:
if (OBD_FAIL_CHECK(OBD_FAIL_LDLM_BL_CALLBACK_NET))
return 0;
break;
case LDLM_CP_CALLBACK:
if (OBD_FAIL_CHECK(OBD_FAIL_LDLM_CP_CALLBACK_NET))
return 0;
break;
case LDLM_GL_CALLBACK:
if (OBD_FAIL_CHECK(OBD_FAIL_LDLM_GL_CALLBACK_NET))
return 0;
break;
case LDLM_SET_INFO:
rc = ldlm_handle_setinfo(req);
ldlm_callback_reply(req, rc);
return 0;
case OBD_LOG_CANCEL: /* remove this eventually - for 1.4.0 compat */
CERROR("shouldn't be handling OBD_LOG_CANCEL on DLM thread\n");
req_capsule_set(&req->rq_pill, &RQF_LOG_CANCEL);
if (OBD_FAIL_CHECK(OBD_FAIL_OBD_LOG_CANCEL_NET))
return 0;
rc = llog_origin_handle_cancel(req);
if (OBD_FAIL_CHECK(OBD_FAIL_OBD_LOG_CANCEL_REP))
return 0;
ldlm_callback_reply(req, rc);
return 0;
case LLOG_ORIGIN_HANDLE_CREATE:
req_capsule_set(&req->rq_pill, &RQF_LLOG_ORIGIN_HANDLE_CREATE);
if (OBD_FAIL_CHECK(OBD_FAIL_OBD_LOGD_NET))
return 0;
rc = llog_origin_handle_open(req);
ldlm_callback_reply(req, rc);
return 0;
case LLOG_ORIGIN_HANDLE_NEXT_BLOCK:
req_capsule_set(&req->rq_pill,
&RQF_LLOG_ORIGIN_HANDLE_NEXT_BLOCK);
if (OBD_FAIL_CHECK(OBD_FAIL_OBD_LOGD_NET))
return 0;
rc = llog_origin_handle_next_block(req);
ldlm_callback_reply(req, rc);
return 0;
case LLOG_ORIGIN_HANDLE_READ_HEADER:
req_capsule_set(&req->rq_pill,
&RQF_LLOG_ORIGIN_HANDLE_READ_HEADER);
if (OBD_FAIL_CHECK(OBD_FAIL_OBD_LOGD_NET))
return 0;
rc = llog_origin_handle_read_header(req);
ldlm_callback_reply(req, rc);
return 0;
case LLOG_ORIGIN_HANDLE_CLOSE:
if (OBD_FAIL_CHECK(OBD_FAIL_OBD_LOGD_NET))
return 0;
rc = llog_origin_handle_close(req);
ldlm_callback_reply(req, rc);
return 0;
case OBD_QC_CALLBACK:
req_capsule_set(&req->rq_pill, &RQF_QC_CALLBACK);
if (OBD_FAIL_CHECK(OBD_FAIL_OBD_QC_CALLBACK_NET))
return 0;
rc = ldlm_handle_qc_callback(req);
ldlm_callback_reply(req, rc);
return 0;
default:
CERROR("unknown opcode %u\n",
lustre_msg_get_opc(req->rq_reqmsg));
ldlm_callback_reply(req, -EPROTO);
return 0;
}
ns = req->rq_export->exp_obd->obd_namespace;
LASSERT(ns != NULL);
req_capsule_set(&req->rq_pill, &RQF_LDLM_CALLBACK);
dlm_req = req_capsule_client_get(&req->rq_pill, &RMF_DLM_REQ);
if (dlm_req == NULL) {
rc = ldlm_callback_reply(req, -EPROTO);
ldlm_callback_errmsg(req, "Operate without parameter", rc,
NULL);
return 0;
}
/* Force a known safe race, send a cancel to the server for a lock
* which the server has already started a blocking callback on. */
if (OBD_FAIL_CHECK(OBD_FAIL_LDLM_CANCEL_BL_CB_RACE) &&
lustre_msg_get_opc(req->rq_reqmsg) == LDLM_BL_CALLBACK) {
rc = ldlm_cli_cancel(&dlm_req->lock_handle[0], 0);
if (rc < 0)
CERROR("ldlm_cli_cancel: %d\n", rc);
}
lock = ldlm_handle2lock_long(&dlm_req->lock_handle[0], 0);
if (!lock) {
CDEBUG(D_DLMTRACE, "callback on lock "LPX64" - lock "
"disappeared\n", dlm_req->lock_handle[0].cookie);
rc = ldlm_callback_reply(req, -EINVAL);
ldlm_callback_errmsg(req, "Operate with invalid parameter", rc,
&dlm_req->lock_handle[0]);
return 0;
}
if ((lock->l_flags & LDLM_FL_FAIL_LOC) &&
lustre_msg_get_opc(req->rq_reqmsg) == LDLM_BL_CALLBACK)
OBD_RACE(OBD_FAIL_LDLM_CP_BL_RACE);
/* Copy hints/flags (e.g. LDLM_FL_DISCARD_DATA) from AST. */
lock_res_and_lock(lock);
lock->l_flags |= ldlm_flags_from_wire(dlm_req->lock_flags &
LDLM_AST_FLAGS);
if (lustre_msg_get_opc(req->rq_reqmsg) == LDLM_BL_CALLBACK) {
/* If somebody cancels lock and cache is already dropped,
* or lock is failed before cp_ast received on client,
* we can tell the server we have no lock. Otherwise, we
* should send cancel after dropping the cache. */
if (((lock->l_flags & LDLM_FL_CANCELING) &&
(lock->l_flags & LDLM_FL_BL_DONE)) ||
(lock->l_flags & LDLM_FL_FAILED)) {
LDLM_DEBUG(lock, "callback on lock "
LPX64" - lock disappeared\n",
dlm_req->lock_handle[0].cookie);
unlock_res_and_lock(lock);
LDLM_LOCK_RELEASE(lock);
rc = ldlm_callback_reply(req, -EINVAL);
ldlm_callback_errmsg(req, "Operate on stale lock", rc,
&dlm_req->lock_handle[0]);
return 0;
}
/* BL_AST locks are not needed in LRU.
* Let ldlm_cancel_lru() be fast. */
ldlm_lock_remove_from_lru(lock);
lock->l_flags |= LDLM_FL_BL_AST;
}
unlock_res_and_lock(lock);
/* We want the ost thread to get this reply so that it can respond
* to ost requests (write cache writeback) that might be triggered
* in the callback.
*
* But we'd also like to be able to indicate in the reply that we're
* cancelling right now, because it's unused, or have an intent result
* in the reply, so we might have to push the responsibility for sending
* the reply down into the AST handlers, alas. */
switch (lustre_msg_get_opc(req->rq_reqmsg)) {
case LDLM_BL_CALLBACK:
CDEBUG(D_INODE, "blocking ast\n");
req_capsule_extend(&req->rq_pill, &RQF_LDLM_BL_CALLBACK);
if (!(lock->l_flags & LDLM_FL_CANCEL_ON_BLOCK)) {
rc = ldlm_callback_reply(req, 0);
if (req->rq_no_reply || rc)
ldlm_callback_errmsg(req, "Normal process", rc,
&dlm_req->lock_handle[0]);
}
if (ldlm_bl_to_thread_lock(ns, &dlm_req->lock_desc, lock))
ldlm_handle_bl_callback(ns, &dlm_req->lock_desc, lock);
break;
case LDLM_CP_CALLBACK:
CDEBUG(D_INODE, "completion ast\n");
req_capsule_extend(&req->rq_pill, &RQF_LDLM_CP_CALLBACK);
ldlm_callback_reply(req, 0);
ldlm_handle_cp_callback(req, ns, dlm_req, lock);
break;
case LDLM_GL_CALLBACK:
CDEBUG(D_INODE, "glimpse ast\n");
req_capsule_extend(&req->rq_pill, &RQF_LDLM_GL_CALLBACK);
ldlm_handle_gl_callback(req, ns, dlm_req, lock);
break;
default:
LBUG(); /* checked above */
}
return 0;
}
static int mdt_create_unpack(struct mdt_thread_info *info)
{
struct md_ucred *uc = mdt_ucred(info);
struct mdt_rec_create *rec;
struct lu_attr *attr = &info->mti_attr.ma_attr;
struct mdt_reint_record *rr = &info->mti_rr;
struct req_capsule *pill = info->mti_pill;
struct md_op_spec *sp = &info->mti_spec;
int rc;
ENTRY;
CLASSERT(sizeof(struct mdt_rec_create) == sizeof(struct mdt_rec_reint));
rec = req_capsule_client_get(pill, &RMF_REC_REINT);
if (rec == NULL)
RETURN(-EFAULT);
uc->mu_fsuid = rec->cr_fsuid;
uc->mu_fsgid = rec->cr_fsgid;
uc->mu_cap = rec->cr_cap;
uc->mu_suppgids[0] = rec->cr_suppgid1;
uc->mu_suppgids[1] = -1;
rr->rr_fid1 = &rec->cr_fid1;
rr->rr_fid2 = &rec->cr_fid2;
attr->la_mode = rec->cr_mode;
attr->la_rdev = rec->cr_rdev;
attr->la_uid = rec->cr_fsuid;
attr->la_gid = rec->cr_fsgid;
attr->la_ctime = rec->cr_time;
attr->la_mtime = rec->cr_time;
attr->la_atime = rec->cr_time;
attr->la_valid = LA_MODE | LA_RDEV | LA_UID | LA_GID |
LA_CTIME | LA_MTIME | LA_ATIME;
memset(&sp->u, 0, sizeof(sp->u));
sp->sp_cr_flags = get_mrc_cr_flags(rec);
sp->sp_ck_split = !!(rec->cr_bias & MDS_CHECK_SPLIT);
info->mti_cross_ref = !!(rec->cr_bias & MDS_CROSS_REF);
if (req_capsule_get_size(pill, &RMF_CAPA1, RCL_CLIENT))
mdt_set_capainfo(info, 0, rr->rr_fid1,
req_capsule_client_get(pill, &RMF_CAPA1));
mdt_set_capainfo(info, 1, rr->rr_fid2, BYPASS_CAPA);
if (!info->mti_cross_ref) {
rr->rr_name = req_capsule_client_get(pill, &RMF_NAME);
rr->rr_namelen = req_capsule_get_size(pill, &RMF_NAME,
RCL_CLIENT) - 1;
LASSERT(rr->rr_name && rr->rr_namelen > 0);
} else {
rr->rr_name = NULL;
rr->rr_namelen = 0;
}
#ifdef CONFIG_FS_POSIX_ACL
if (sp->sp_cr_flags & MDS_CREATE_RMT_ACL) {
if (S_ISDIR(attr->la_mode))
sp->u.sp_pfid = rr->rr_fid1;
req_capsule_extend(pill, &RQF_MDS_REINT_CREATE_RMT_ACL);
LASSERT(req_capsule_field_present(pill, &RMF_EADATA,
RCL_CLIENT));
sp->u.sp_ea.eadata = req_capsule_client_get(pill, &RMF_EADATA);
sp->u.sp_ea.eadatalen = req_capsule_get_size(pill, &RMF_EADATA,
RCL_CLIENT);
sp->u.sp_ea.fid = rr->rr_fid1;
RETURN(0);
}
#endif
if (S_ISDIR(attr->la_mode)) {
/* pass parent fid for cross-ref cases */
sp->u.sp_pfid = rr->rr_fid1;
if (sp->sp_cr_flags & MDS_CREATE_SLAVE_OBJ) {
/* create salve object req, need
* unpack split ea here
*/
req_capsule_extend(pill, &RQF_MDS_REINT_CREATE_SLAVE);
LASSERT(req_capsule_field_present(pill, &RMF_EADATA,
RCL_CLIENT));
sp->u.sp_ea.eadata = req_capsule_client_get(pill,
&RMF_EADATA);
sp->u.sp_ea.eadatalen = req_capsule_get_size(pill,
&RMF_EADATA,
RCL_CLIENT);
sp->u.sp_ea.fid = rr->rr_fid1;
RETURN(0);
}
req_capsule_extend(pill, &RQF_MDS_REINT_CREATE_RMT_ACL);
} else if (S_ISLNK(attr->la_mode)) {
const char *tgt = NULL;
req_capsule_extend(pill, &RQF_MDS_REINT_CREATE_SYM);
if (req_capsule_get_size(pill, &RMF_SYMTGT, RCL_CLIENT)) {
tgt = req_capsule_client_get(pill, &RMF_SYMTGT);
sp->u.sp_symname = tgt;
}
if (tgt == NULL)
RETURN(-EFAULT);
} else {
req_capsule_extend(pill, &RQF_MDS_REINT_CREATE_RMT_ACL);
}
rc = mdt_dlmreq_unpack(info);
RETURN(rc);
}
static int mdt_create_unpack(struct mdt_thread_info *info)
{
struct lu_ucred *uc = mdt_ucred(info);
struct mdt_rec_create *rec;
struct lu_attr *attr = &info->mti_attr.ma_attr;
struct mdt_reint_record *rr = &info->mti_rr;
struct req_capsule *pill = info->mti_pill;
struct md_op_spec *sp = &info->mti_spec;
int rc;
ENTRY;
CLASSERT(sizeof(struct mdt_rec_create) == sizeof(struct mdt_rec_reint));
rec = req_capsule_client_get(pill, &RMF_REC_REINT);
if (rec == NULL)
RETURN(-EFAULT);
/* This prior initialization is needed for old_init_ucred_reint() */
uc->uc_fsuid = rec->cr_fsuid;
uc->uc_fsgid = rec->cr_fsgid;
uc->uc_cap = rec->cr_cap;
uc->uc_suppgids[0] = rec->cr_suppgid1;
uc->uc_suppgids[1] = -1;
uc->uc_umask = rec->cr_umask;
rr->rr_fid1 = &rec->cr_fid1;
rr->rr_fid2 = &rec->cr_fid2;
attr->la_mode = rec->cr_mode;
attr->la_rdev = rec->cr_rdev;
attr->la_uid = rec->cr_fsuid;
attr->la_gid = rec->cr_fsgid;
attr->la_ctime = rec->cr_time;
attr->la_mtime = rec->cr_time;
attr->la_atime = rec->cr_time;
attr->la_valid = LA_MODE | LA_RDEV | LA_UID | LA_GID | LA_TYPE |
LA_CTIME | LA_MTIME | LA_ATIME;
memset(&sp->u, 0, sizeof(sp->u));
sp->sp_cr_flags = get_mrc_cr_flags(rec);
if (req_capsule_get_size(pill, &RMF_CAPA1, RCL_CLIENT))
mdt_set_capainfo(info, 0, rr->rr_fid1,
req_capsule_client_get(pill, &RMF_CAPA1));
mdt_set_capainfo(info, 1, rr->rr_fid2, BYPASS_CAPA);
rc = mdt_name_unpack(pill, &RMF_NAME, &rr->rr_name, 0);
if (rc < 0)
RETURN(rc);
if (S_ISLNK(attr->la_mode)) {
const char *tgt = NULL;
req_capsule_extend(pill, &RQF_MDS_REINT_CREATE_SYM);
if (req_capsule_get_size(pill, &RMF_SYMTGT, RCL_CLIENT)) {
tgt = req_capsule_client_get(pill, &RMF_SYMTGT);
sp->u.sp_symname = tgt;
}
if (tgt == NULL)
RETURN(-EFAULT);
} else {
req_capsule_extend(pill, &RQF_MDS_REINT_CREATE_RMT_ACL);
if (S_ISDIR(attr->la_mode) &&
req_capsule_get_size(pill, &RMF_EADATA, RCL_CLIENT) > 0) {
sp->u.sp_ea.eadata =
req_capsule_client_get(pill, &RMF_EADATA);
sp->u.sp_ea.eadatalen =
req_capsule_get_size(pill, &RMF_EADATA,
RCL_CLIENT);
sp->sp_cr_flags |= MDS_OPEN_HAS_EA;
}
}
rc = mdt_dlmreq_unpack(info);
RETURN(rc);
}
