}
struct tgt_handler seq_handlers[] = {
-TGT_SEQ_HDL(HABEO_REFERO, SEQ_QUERY, seq_handler),
+TGT_SEQ_HDL(HAS_REPLY, SEQ_QUERY, seq_handler),
};
EXPORT_SYMBOL(seq_handlers);
/*
* struct *_body is passed in the incoming message, and object
* identified by this fid exists on disk.
- * *
- * "habeo corpus" == "I have a body"
*/
- HABEO_CORPUS = (1 << 0),
+ HAS_BODY = (1 << 0),
/*
* struct ldlm_request is passed in the incoming message.
- *
- * "habeo clavis" == "I have a key"
- * */
- HABEO_CLAVIS = (1 << 1),
+ */
+ HAS_KEY = (1 << 1),
/*
* this request has fixed reply format, so that reply message can be
* packed by generic code.
- *
- * "habeo refero" == "I have a reply"
*/
- HABEO_REFERO = (1 << 2),
+ HAS_REPLY = (1 << 2),
/*
* this request will modify something, so check whether the file system
* is readonly or not, then return -EROFS to client asap if necessary.
- *
- * "mutabor" == "I shall modify"
*/
- MUTABOR = (1 << 3)
+ IS_MUTABLE = (1 << 3)
};
struct tgt_handler {
* - create lu_object, corresponding to the fid in mdt_body, and save it in
* @info;
*
- * - if HABEO_CORPUS flag is set for this request type check whether object
+ * - if HAS_BODY flag is set for this request type check whether object
* actually exists on storage (lu_object_exists()).
*
*/
obj = mdt_object_find(env, info->mti_mdt, &body->mbo_fid1);
if (!IS_ERR(obj)) {
- if ((flags & HABEO_CORPUS) && !mdt_object_exists(obj)) {
+ if ((flags & HAS_BODY) && !mdt_object_exists(obj)) {
mdt_object_put(env, obj);
rc = -ENOENT;
} else {
static int mdt_unpack_req_pack_rep(struct mdt_thread_info *info,
enum tgt_handler_flags flags)
{
- struct req_capsule *pill = info->mti_pill;
- int rc;
- ENTRY;
+ struct req_capsule *pill = info->mti_pill;
+ int rc;
- if (req_capsule_has_field(pill, &RMF_MDT_BODY, RCL_CLIENT))
- rc = mdt_body_unpack(info, flags);
- else
- rc = 0;
+ ENTRY;
- if (rc == 0 && (flags & HABEO_REFERO)) {
- /* Pack reply. */
- if (req_capsule_has_field(pill, &RMF_MDT_MD, RCL_SERVER))
- req_capsule_set_size(pill, &RMF_MDT_MD, RCL_SERVER,
+ if (req_capsule_has_field(pill, &RMF_MDT_BODY, RCL_CLIENT))
+ rc = mdt_body_unpack(info, flags);
+ else
+ rc = 0;
+
+ if (rc == 0 && (flags & HAS_REPLY)) {
+ /* Pack reply. */
+ if (req_capsule_has_field(pill, &RMF_MDT_MD, RCL_SERVER))
+ req_capsule_set_size(pill, &RMF_MDT_MD, RCL_SERVER,
DEF_REP_MD_SIZE);
- if (req_capsule_has_field(pill, &RMF_LOGCOOKIES, RCL_SERVER))
+ if (req_capsule_has_field(pill, &RMF_LOGCOOKIES, RCL_SERVER))
req_capsule_set_size(pill, &RMF_LOGCOOKIES,
RCL_SERVER, 0);
req_capsule_set_size(pill, &RMF_ACL, RCL_SERVER,
LUSTRE_POSIX_ACL_MAX_SIZE_OLD);
- rc = req_capsule_server_pack(pill);
- }
- RETURN(rc);
+ rc = req_capsule_server_pack(pill);
+ }
+ RETURN(rc);
}
void mdt_lock_handle_init(struct mdt_lock_handle *lh)
case IT_OPEN:
case IT_OPEN|IT_CREAT:
/*
- * OCREAT is not a MUTABOR request since the file may
+ * OCREAT is not a IS_MUTABLE request since the file may
* already exist. We do the extra check of
* OBD_CONNECT_RDONLY in mdt_reint_open() when we
* really need to create the object.
case IT_LOOKUP:
it_format = &RQF_LDLM_INTENT_GETATTR;
it_handler = &mdt_intent_getattr;
- it_handler_flags = HABEO_REFERO;
+ it_handler_flags = HAS_REPLY;
break;
case IT_GETXATTR:
it_format = &RQF_LDLM_INTENT_GETXATTR;
it_handler = &mdt_intent_getxattr;
- it_handler_flags = HABEO_CORPUS;
+ it_handler_flags = HAS_BODY;
break;
case IT_LAYOUT:
it_format = &RQF_LDLM_INTENT_LAYOUT;
if (rc < 0)
RETURN(rc);
- if (it_handler_flags & MUTABOR && mdt_rdonly(req->rq_export))
+ if (it_handler_flags & IS_MUTABLE && mdt_rdonly(req->rq_export))
RETURN(-EROFS);
OBD_FAIL_TIMEOUT(OBD_FAIL_MDS_INTENT_DELAY, 10);
0, MDS_DISCONNECT, tgt_disconnect,
&RQF_MDS_DISCONNECT, LUSTRE_OBD_VERSION),
TGT_RPC_HANDLER(MDS_FIRST_OPC,
- HABEO_REFERO, MDS_SET_INFO, mdt_set_info,
+ HAS_REPLY, MDS_SET_INFO, mdt_set_info,
&RQF_OBD_SET_INFO, LUSTRE_MDS_VERSION),
TGT_MDT_HDL(0, MDS_GET_INFO, mdt_get_info),
-TGT_MDT_HDL(0 | HABEO_REFERO, MDS_GET_ROOT, mdt_get_root),
-TGT_MDT_HDL(HABEO_CORPUS, MDS_GETATTR, mdt_getattr),
-TGT_MDT_HDL(HABEO_CORPUS| HABEO_REFERO, MDS_GETATTR_NAME,
+TGT_MDT_HDL(HAS_REPLY, MDS_GET_ROOT, mdt_get_root),
+TGT_MDT_HDL(HAS_BODY, MDS_GETATTR, mdt_getattr),
+TGT_MDT_HDL(HAS_BODY | HAS_REPLY, MDS_GETATTR_NAME,
mdt_getattr_name),
-TGT_MDT_HDL(HABEO_CORPUS, MDS_GETXATTR, mdt_tgt_getxattr),
-TGT_MDT_HDL(0 | HABEO_REFERO, MDS_STATFS, mdt_statfs),
-TGT_MDT_HDL(0 | MUTABOR, MDS_REINT, mdt_reint),
-TGT_MDT_HDL(HABEO_CORPUS, MDS_CLOSE, mdt_close),
-TGT_MDT_HDL(HABEO_CORPUS| HABEO_REFERO, MDS_READPAGE, mdt_readpage),
-TGT_MDT_HDL(HABEO_CORPUS| HABEO_REFERO, MDS_SYNC, mdt_sync),
+TGT_MDT_HDL(HAS_BODY, MDS_GETXATTR, mdt_tgt_getxattr),
+TGT_MDT_HDL(HAS_REPLY, MDS_STATFS, mdt_statfs),
+TGT_MDT_HDL(IS_MUTABLE, MDS_REINT, mdt_reint),
+TGT_MDT_HDL(HAS_BODY, MDS_CLOSE, mdt_close),
+TGT_MDT_HDL(HAS_BODY | HAS_REPLY, MDS_READPAGE, mdt_readpage),
+TGT_MDT_HDL(HAS_BODY | HAS_REPLY, MDS_SYNC, mdt_sync),
TGT_MDT_HDL(0, MDS_QUOTACTL, mdt_quotactl),
-TGT_MDT_HDL(HABEO_CORPUS| HABEO_REFERO | MUTABOR, MDS_HSM_PROGRESS,
+TGT_MDT_HDL(HAS_BODY | HAS_REPLY | IS_MUTABLE, MDS_HSM_PROGRESS,
mdt_hsm_progress),
-TGT_MDT_HDL(HABEO_CORPUS| HABEO_REFERO | MUTABOR, MDS_HSM_CT_REGISTER,
+TGT_MDT_HDL(HAS_BODY | HAS_REPLY | IS_MUTABLE, MDS_HSM_CT_REGISTER,
mdt_hsm_ct_register),
-TGT_MDT_HDL(HABEO_CORPUS| HABEO_REFERO | MUTABOR, MDS_HSM_CT_UNREGISTER,
+TGT_MDT_HDL(HAS_BODY | HAS_REPLY | IS_MUTABLE, MDS_HSM_CT_UNREGISTER,
mdt_hsm_ct_unregister),
-TGT_MDT_HDL(HABEO_CORPUS| HABEO_REFERO, MDS_HSM_STATE_GET,
+TGT_MDT_HDL(HAS_BODY | HAS_REPLY, MDS_HSM_STATE_GET,
mdt_hsm_state_get),
-TGT_MDT_HDL(HABEO_CORPUS| HABEO_REFERO | MUTABOR, MDS_HSM_STATE_SET,
+TGT_MDT_HDL(HAS_BODY | HAS_REPLY | IS_MUTABLE, MDS_HSM_STATE_SET,
mdt_hsm_state_set),
-TGT_MDT_HDL(HABEO_CORPUS| HABEO_REFERO, MDS_HSM_ACTION, mdt_hsm_action),
-TGT_MDT_HDL(HABEO_CORPUS| HABEO_REFERO, MDS_HSM_REQUEST,
+TGT_MDT_HDL(HAS_BODY | HAS_REPLY, MDS_HSM_ACTION, mdt_hsm_action),
+TGT_MDT_HDL(HAS_BODY | HAS_REPLY, MDS_HSM_REQUEST,
mdt_hsm_request),
-TGT_MDT_HDL(HABEO_CLAVIS | HABEO_CORPUS | HABEO_REFERO | MUTABOR,
+TGT_MDT_HDL(HAS_KEY | HAS_BODY | HAS_REPLY | IS_MUTABLE,
MDS_SWAP_LAYOUTS,
mdt_swap_layouts),
};
static struct tgt_handler mdt_io_ops[] = {
-TGT_OST_HDL_HP(HABEO_CORPUS | HABEO_REFERO, OST_BRW_READ, tgt_brw_read,
+TGT_OST_HDL_HP(HAS_BODY | HAS_REPLY, OST_BRW_READ, tgt_brw_read,
mdt_hp_brw),
-TGT_OST_HDL_HP(HABEO_CORPUS | MUTABOR, OST_BRW_WRITE, tgt_brw_write,
+TGT_OST_HDL_HP(HAS_BODY | IS_MUTABLE, OST_BRW_WRITE, tgt_brw_write,
mdt_hp_brw),
-TGT_OST_HDL_HP(HABEO_CORPUS | HABEO_REFERO | MUTABOR,
+TGT_OST_HDL_HP(HAS_BODY | HAS_REPLY | IS_MUTABLE,
OST_PUNCH, mdt_punch_hdl,
mdt_hp_punch),
-TGT_OST_HDL(HABEO_CORPUS | HABEO_REFERO, OST_SYNC, mdt_data_sync),
+TGT_OST_HDL(HAS_BODY | HAS_REPLY, OST_SYNC, mdt_data_sync),
};
static struct tgt_handler mdt_sec_ctx_ops[] = {
};
static struct tgt_handler mdt_quota_ops[] = {
-TGT_QUOTA_HDL(HABEO_REFERO, QUOTA_DQACQ, mdt_quota_dqacq),
+TGT_QUOTA_HDL(HAS_REPLY, QUOTA_DQACQ, mdt_quota_dqacq),
};
static struct tgt_opc_slice mdt_common_slice[] = {
&RQF_MDS_DISCONNECT, LUSTRE_OBD_VERSION),
TGT_MGS_HDL_VAR(0, MGS_EXCEPTION, mgs_exception),
#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 13, 53, 0)
-TGT_MGS_HDL (HABEO_REFERO | MUTABOR, MGS_SET_INFO, mgs_set_info),
+TGT_MGS_HDL(HAS_REPLY | IS_MUTABLE, MGS_SET_INFO, mgs_set_info),
#endif
-TGT_MGS_HDL (HABEO_REFERO | MUTABOR, MGS_TARGET_REG, mgs_target_reg),
+TGT_MGS_HDL(HAS_REPLY | IS_MUTABLE, MGS_TARGET_REG, mgs_target_reg),
TGT_MGS_HDL_VAR(0, MGS_TARGET_DEL, mgs_target_del),
-TGT_MGS_HDL (HABEO_REFERO, MGS_CONFIG_READ, mgs_config_read),
+TGT_MGS_HDL(HAS_REPLY, MGS_CONFIG_READ, mgs_config_read),
};
static struct tgt_handler mgs_obd_handlers[] = {
* * instead of common OBD_FAIL_LDLM_ENQUEUE_NET */
.th_fail_id = 0,
.th_opc = LDLM_ENQUEUE,
- .th_flags = HABEO_CLAVIS,
+ .th_flags = HAS_KEY,
.th_act = tgt_enqueue,
.th_fmt = &RQF_LDLM_ENQUEUE,
.th_version = LUSTRE_DLM_VERSION,
&RQF_CONNECT, LUSTRE_OBD_VERSION),
TGT_RPC_HANDLER(OST_FIRST_OPC, 0, OST_DISCONNECT, tgt_disconnect,
&RQF_OST_DISCONNECT, LUSTRE_OBD_VERSION),
-TGT_OST_HDL(HABEO_CORPUS | HABEO_REFERO, OST_GETATTR, esd_getattr_hdl),
-TGT_OST_HDL(HABEO_CORPUS | HABEO_REFERO | MUTABOR, OST_SETATTR,
+TGT_OST_HDL(HAS_BODY | HAS_REPLY, OST_GETATTR, esd_getattr_hdl),
+TGT_OST_HDL(HAS_BODY | HAS_REPLY | IS_MUTABLE, OST_SETATTR,
esd_setattr_hdl),
-TGT_OST_HDL(HABEO_REFERO | MUTABOR, OST_CREATE, esd_create_hdl),
-TGT_OST_HDL(HABEO_REFERO | MUTABOR, OST_DESTROY, esd_destroy_hdl),
-TGT_OST_HDL(HABEO_CORPUS | HABEO_REFERO, OST_BRW_READ, tgt_brw_read),
-TGT_OST_HDL(HABEO_CORPUS | MUTABOR, OST_BRW_WRITE, tgt_brw_write),
+TGT_OST_HDL(HAS_REPLY | IS_MUTABLE, OST_CREATE, esd_create_hdl),
+TGT_OST_HDL(HAS_REPLY | IS_MUTABLE, OST_DESTROY, esd_destroy_hdl),
+TGT_OST_HDL(HAS_BODY | HAS_REPLY, OST_BRW_READ, tgt_brw_read),
+TGT_OST_HDL(HAS_BODY | IS_MUTABLE, OST_BRW_WRITE, tgt_brw_write),
};
static struct tgt_opc_slice esd_common_slice[] = {
0, OST_SET_INFO, ofd_set_info_hdl,
&RQF_OBD_SET_INFO, LUSTRE_OST_VERSION),
TGT_OST_HDL(0, OST_GET_INFO, ofd_get_info_hdl),
-TGT_OST_HDL(HABEO_CORPUS| HABEO_REFERO, OST_GETATTR, ofd_getattr_hdl),
-TGT_OST_HDL(HABEO_CORPUS| HABEO_REFERO | MUTABOR,
+TGT_OST_HDL(HAS_BODY | HAS_REPLY, OST_GETATTR, ofd_getattr_hdl),
+TGT_OST_HDL(HAS_BODY | HAS_REPLY | IS_MUTABLE,
OST_SETATTR, ofd_setattr_hdl),
-TGT_OST_HDL(0 | HABEO_REFERO | MUTABOR,
+TGT_OST_HDL(HAS_REPLY | IS_MUTABLE,
OST_CREATE, ofd_create_hdl),
-TGT_OST_HDL(0 | HABEO_REFERO | MUTABOR,
+TGT_OST_HDL(HAS_REPLY | IS_MUTABLE,
OST_DESTROY, ofd_destroy_hdl),
-TGT_OST_HDL(0 | HABEO_REFERO, OST_STATFS, ofd_statfs_hdl),
-TGT_OST_HDL_HP(HABEO_CORPUS| HABEO_REFERO,
- OST_BRW_READ, tgt_brw_read,
+TGT_OST_HDL(HAS_REPLY, OST_STATFS, ofd_statfs_hdl),
+TGT_OST_HDL_HP(HAS_BODY | HAS_REPLY, OST_BRW_READ, tgt_brw_read,
ofd_hp_brw),
/* don't set CORPUS flag for brw_write because -ENOENT may be valid case */
-TGT_OST_HDL_HP(HABEO_CORPUS| MUTABOR, OST_BRW_WRITE, tgt_brw_write,
+TGT_OST_HDL_HP(HAS_BODY | IS_MUTABLE, OST_BRW_WRITE, tgt_brw_write,
ofd_hp_brw),
-TGT_OST_HDL_HP(HABEO_CORPUS| HABEO_REFERO | MUTABOR,
+TGT_OST_HDL_HP(HAS_BODY | HAS_REPLY | IS_MUTABLE,
OST_PUNCH, ofd_punch_hdl,
ofd_hp_punch),
-TGT_OST_HDL(HABEO_CORPUS| HABEO_REFERO, OST_SYNC, ofd_sync_hdl),
-TGT_OST_HDL(0 | HABEO_REFERO, OST_QUOTACTL, ofd_quotactl),
-TGT_OST_HDL(HABEO_CORPUS | HABEO_REFERO, OST_LADVISE, ofd_ladvise_hdl),
+TGT_OST_HDL(HAS_BODY | HAS_REPLY, OST_SYNC, ofd_sync_hdl),
+TGT_OST_HDL(HAS_REPLY, OST_QUOTACTL, ofd_quotactl),
+TGT_OST_HDL(HAS_BODY | HAS_REPLY, OST_LADVISE, ofd_ladvise_hdl),
};
static struct tgt_opc_slice ofd_common_slice[] = {
}
static struct tgt_handler out_update_ops[] = {
- DEF_OUT_HNDL(OUT_CREATE, "out_create", MUTABOR | HABEO_REFERO,
+ DEF_OUT_HNDL(OUT_CREATE, "out_create", IS_MUTABLE | HAS_REPLY,
out_create),
- DEF_OUT_HNDL(OUT_DESTROY, "out_create", MUTABOR | HABEO_REFERO,
+ DEF_OUT_HNDL(OUT_DESTROY, "out_create", IS_MUTABLE | HAS_REPLY,
out_destroy),
- DEF_OUT_HNDL(OUT_REF_ADD, "out_ref_add", MUTABOR | HABEO_REFERO,
+ DEF_OUT_HNDL(OUT_REF_ADD, "out_ref_add", IS_MUTABLE | HAS_REPLY,
out_ref_add),
- DEF_OUT_HNDL(OUT_REF_DEL, "out_ref_del", MUTABOR | HABEO_REFERO,
+ DEF_OUT_HNDL(OUT_REF_DEL, "out_ref_del", IS_MUTABLE | HAS_REPLY,
out_ref_del),
- DEF_OUT_HNDL(OUT_ATTR_SET, "out_attr_set", MUTABOR | HABEO_REFERO,
+ DEF_OUT_HNDL(OUT_ATTR_SET, "out_attr_set", IS_MUTABLE | HAS_REPLY,
out_attr_set),
- DEF_OUT_HNDL(OUT_ATTR_GET, "out_attr_get", HABEO_REFERO,
+ DEF_OUT_HNDL(OUT_ATTR_GET, "out_attr_get", HAS_REPLY,
out_attr_get),
- DEF_OUT_HNDL(OUT_XATTR_SET, "out_xattr_set", MUTABOR | HABEO_REFERO,
+ DEF_OUT_HNDL(OUT_XATTR_SET, "out_xattr_set", IS_MUTABLE | HAS_REPLY,
out_xattr_set),
- DEF_OUT_HNDL(OUT_XATTR_DEL, "out_xattr_del", MUTABOR | HABEO_REFERO,
+ DEF_OUT_HNDL(OUT_XATTR_DEL, "out_xattr_del", IS_MUTABLE | HAS_REPLY,
out_xattr_del),
- DEF_OUT_HNDL(OUT_XATTR_GET, "out_xattr_get", HABEO_REFERO,
+ DEF_OUT_HNDL(OUT_XATTR_GET, "out_xattr_get", HAS_REPLY,
out_xattr_get),
- DEF_OUT_HNDL(OUT_INDEX_LOOKUP, "out_index_lookup", HABEO_REFERO,
+ DEF_OUT_HNDL(OUT_INDEX_LOOKUP, "out_index_lookup", HAS_REPLY,
out_index_lookup),
DEF_OUT_HNDL(OUT_INDEX_INSERT, "out_index_insert",
- MUTABOR | HABEO_REFERO, out_index_insert),
+ IS_MUTABLE | HAS_REPLY, out_index_insert),
DEF_OUT_HNDL(OUT_INDEX_DELETE, "out_index_delete",
- MUTABOR | HABEO_REFERO, out_index_delete),
- DEF_OUT_HNDL(OUT_WRITE, "out_write", MUTABOR | HABEO_REFERO, out_write),
- DEF_OUT_HNDL(OUT_READ, "out_read", HABEO_REFERO, out_read),
- DEF_OUT_HNDL(OUT_NOOP, "out_noop", HABEO_REFERO, out_noop),
- DEF_OUT_HNDL(OUT_XATTR_LIST, "out_xattr_list", HABEO_REFERO,
+ IS_MUTABLE | HAS_REPLY, out_index_delete),
+ DEF_OUT_HNDL(OUT_WRITE, "out_write", IS_MUTABLE | HAS_REPLY, out_write),
+ DEF_OUT_HNDL(OUT_READ, "out_read", HAS_REPLY, out_read),
+ DEF_OUT_HNDL(OUT_NOOP, "out_noop", HAS_REPLY, out_noop),
+ DEF_OUT_HNDL(OUT_XATTR_LIST, "out_xattr_list", HAS_REPLY,
out_xattr_list),
};
}
/* Check resend case only for modifying RPC */
- if (h->th_flags & MUTABOR) {
+ if (h->th_flags & IS_MUTABLE) {
struct ptlrpc_request *req = tgt_ses_req(tsi);
if (out_check_resent(env, dt, dt_obj, req,
}
/* start transaction for modification RPC only */
- if (h->th_flags & MUTABOR && current_batchid == -1) {
+ if (h->th_flags & IS_MUTABLE && current_batchid == -1) {
current_batchid = update->ou_batchid;
rc = out_tx_start(env, dt, ta, tsi->tsi_exp);
if (rc != 0)
/* 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)) &&
+ !(h->th_flags & IS_MUTABLE)) &&
ta->ta_handle != NULL) {
rc = out_tx_end(env, ta, rc);
current_batchid = -1;
GOTO(next, rc);
/* start a new transaction if needed */
- if (h->th_flags & MUTABOR) {
+ if (h->th_flags & IS_MUTABLE) {
rc = out_tx_start(env, dt, ta,
tsi->tsi_exp);
if (rc != 0)
}
struct tgt_handler tgt_out_handlers[] = {
-TGT_UPDATE_HDL(MUTABOR, OUT_UPDATE, out_handle),
+TGT_UPDATE_HDL(IS_MUTABLE, OUT_UPDATE, out_handle),
};
EXPORT_SYMBOL(tgt_out_handlers);
* - create lu_object, corresponding to the fid in mdt_body, and save it in
* @tsi;
*
- * - if HABEO_CORPUS flag is set for this request type check whether object
+ * - if HAS_BODY flag is set for this request type check whether object
* actually exists on storage (lu_object_exists()).
*
*/
&tsi->tsi_tgt->lut_bottom->dd_lu_dev,
&body->mbo_fid1, NULL);
if (!IS_ERR(obj)) {
- if ((flags & HABEO_CORPUS) && !lu_object_exists(obj)) {
+ if ((flags & HAS_BODY) && !lu_object_exists(obj)) {
lu_object_put(tsi->tsi_env, obj);
rc = -ENOENT;
} else {
}
if (!(body->oa.o_valid & OBD_MD_FLID)) {
- if (flags & HABEO_CORPUS) {
- CERROR("%s: OBD_MD_FLID flag is not set in ost_body "
- "but OID/FID is mandatory with HABEO_CORPUS\n",
+ if (flags & HAS_BODY) {
+ CERROR("%s: OBD_MD_FLID flag is not set in ost_body but OID/FID is mandatory with HAS_BODY\n",
tgt_name(tsi->tsi_tgt));
RETURN(-EPROTO);
} else {
LASSERT(h->th_opc == lustre_msg_get_opc(req->rq_reqmsg));
LASSERT(current->journal_info == NULL);
- LASSERT(ergo(flags & (HABEO_CORPUS | HABEO_REFERO),
+ LASSERT(ergo(flags & (HAS_BODY | HAS_REPLY),
h->th_fmt != NULL));
if (h->th_fmt != NULL) {
req_capsule_set(pill, h->th_fmt);
}
}
- if (flags & MUTABOR && tgt_conn_flags(tsi) & OBD_CONNECT_RDONLY)
+ if (flags & IS_MUTABLE && tgt_conn_flags(tsi) & OBD_CONNECT_RDONLY)
RETURN(-EROFS);
- if (flags & HABEO_CLAVIS) {
+ if (flags & HAS_KEY) {
struct ldlm_request *dlm_req;
LASSERT(h->th_fmt != NULL);
rc = tgt_request_preprocess(tsi, h, req);
/* pack reply if reply format is fixed */
- if (rc == 0 && h->th_flags & HABEO_REFERO) {
+ if (rc == 0 && h->th_flags & HAS_REPLY) {
/* Pack reply */
if (req_capsule_has_field(tsi->tsi_pill, &RMF_MDT_MD,
RCL_SERVER))
/* generic LDLM target handler */
struct tgt_handler tgt_dlm_handlers[] = {
-TGT_DLM_HDL (HABEO_CLAVIS, LDLM_ENQUEUE, tgt_enqueue),
-TGT_DLM_HDL (HABEO_CLAVIS, LDLM_CONVERT, tgt_convert),
-TGT_DLM_HDL_VAR(0, LDLM_BL_CALLBACK, tgt_bl_callback),
-TGT_DLM_HDL_VAR(0, LDLM_CP_CALLBACK, tgt_cp_callback)
+TGT_DLM_HDL(HAS_KEY, LDLM_ENQUEUE, tgt_enqueue),
+TGT_DLM_HDL(HAS_KEY, LDLM_CONVERT, tgt_convert),
+TGT_DLM_HDL_VAR(0, LDLM_BL_CALLBACK, tgt_bl_callback),
+TGT_DLM_HDL_VAR(0, LDLM_CP_CALLBACK, tgt_cp_callback)
};
EXPORT_SYMBOL(tgt_dlm_handlers);
}
struct tgt_handler tgt_lfsck_handlers[] = {
-TGT_LFSCK_HDL(HABEO_REFERO, LFSCK_NOTIFY, tgt_handle_lfsck_notify),
-TGT_LFSCK_HDL(HABEO_REFERO, LFSCK_QUERY, tgt_handle_lfsck_query),
+TGT_LFSCK_HDL(HAS_REPLY, LFSCK_NOTIFY, tgt_handle_lfsck_notify),
+TGT_LFSCK_HDL(HAS_REPLY, LFSCK_QUERY, tgt_handle_lfsck_query),
};
EXPORT_SYMBOL(tgt_lfsck_handlers);
git://git.whamcloud.com / fs / lustre-release.git / commitdiff