From 881149a66825caa4f9b0ef003b663278d202fbab Mon Sep 17 00:00:00 2001 From: Ben Evans Date: Tue, 5 Mar 2019 17:28:11 -0500 Subject: [PATCH] LU-12044 ptlrpc: Translate HABEO_ macros HABEO_CORPUS -> HAS_BODY HABEO_CLAVIS -> HAS_KEY HABEO_REFERO -> HAS_REPLY MUTABOR -> IS_MUTABLE Signed-off-by: Ben Evans Change-Id: I341cb899aeebd9cccf6ee8111112016c5e6dee53 Reviewed-on: https://review.whamcloud.com/34375 Reviewed-by: Ann Koehler Reviewed-by: Patrick Farrell Tested-by: Jenkins Reviewed-by: James Simmons Tested-by: Maloo Reviewed-by: Oleg Drokin --- lustre/fid/fid_handler.c | 2 +- lustre/include/lu_target.h | 18 +++------ lustre/mdt/mdt_handler.c | 89 +++++++++++++++++++++++---------------------- lustre/mgs/mgs_handler.c | 8 ++-- lustre/obdecho/echo.c | 12 +++--- lustre/ofd/ofd_dev.c | 23 ++++++------ lustre/target/out_handler.c | 42 ++++++++++----------- lustre/target/tgt_handler.c | 29 +++++++-------- 8 files changed, 107 insertions(+), 116 deletions(-) diff --git a/lustre/fid/fid_handler.c b/lustre/fid/fid_handler.c index 8676ec2..34d0157 100644 --- a/lustre/fid/fid_handler.c +++ b/lustre/fid/fid_handler.c @@ -446,7 +446,7 @@ static int seq_handler(struct tgt_session_info *tsi) } 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); diff --git a/lustre/include/lu_target.h b/lustre/include/lu_target.h index 4ba3fe1..eb48682 100644 --- a/lustre/include/lu_target.h +++ b/lustre/include/lu_target.h @@ -330,30 +330,22 @@ enum tgt_handler_flags { /* * 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 { diff --git a/lustre/mdt/mdt_handler.c b/lustre/mdt/mdt_handler.c index c2bb878..c4dd912 100644 --- a/lustre/mdt/mdt_handler.c +++ b/lustre/mdt/mdt_handler.c @@ -3291,7 +3291,7 @@ void mdt_object_unlock_put(struct mdt_thread_info * info, * - 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()). * */ @@ -3322,7 +3322,7 @@ static int mdt_body_unpack(struct mdt_thread_info *info, 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 { @@ -3338,21 +3338,22 @@ static int mdt_body_unpack(struct mdt_thread_info *info, 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); @@ -3363,9 +3364,9 @@ static int mdt_unpack_req_pack_rep(struct mdt_thread_info *info, 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) @@ -3994,7 +3995,7 @@ static int mdt_intent_opc(enum ldlm_intent_flags it_opc, 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. @@ -4006,12 +4007,12 @@ static int mdt_intent_opc(enum ldlm_intent_flags it_opc, 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; @@ -4054,7 +4055,7 @@ static int mdt_intent_opc(enum ldlm_intent_flags it_opc, 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); @@ -4832,47 +4833,47 @@ TGT_RPC_HANDLER(MDS_FIRST_OPC, 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[] = { @@ -4882,7 +4883,7 @@ TGT_SEC_HDL_VAR(0, SEC_CTX_FINI, mdt_sec_ctx_handle) }; 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[] = { diff --git a/lustre/mgs/mgs_handler.c b/lustre/mgs/mgs_handler.c index 096c27e..926b30f 100644 --- a/lustre/mgs/mgs_handler.c +++ b/lustre/mgs/mgs_handler.c @@ -1203,11 +1203,11 @@ TGT_RPC_HANDLER(MGS_FIRST_OPC, &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[] = { @@ -1224,7 +1224,7 @@ static struct tgt_handler mgs_dlm_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, diff --git a/lustre/obdecho/echo.c b/lustre/obdecho/echo.c index 0f97a83..c5d987a 100644 --- a/lustre/obdecho/echo.c +++ b/lustre/obdecho/echo.c @@ -666,13 +666,13 @@ TGT_RPC_HANDLER(OST_FIRST_OPC, 0, OST_CONNECT, tgt_connect, &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[] = { diff --git a/lustre/ofd/ofd_dev.c b/lustre/ofd/ofd_dev.c index 8eead96..61033a4 100644 --- a/lustre/ofd/ofd_dev.c +++ b/lustre/ofd/ofd_dev.c @@ -2715,26 +2715,25 @@ TGT_RPC_HANDLER(OST_FIRST_OPC, 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[] = { diff --git a/lustre/target/out_handler.c b/lustre/target/out_handler.c index 7dc9d42..a3b7c36 100644 --- a/lustre/target/out_handler.c +++ b/lustre/target/out_handler.c @@ -784,34 +784,34 @@ static int out_noop(struct tgt_session_info *tsi) } 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), }; @@ -1154,7 +1154,7 @@ int out_handle(struct tgt_session_info *tsi) } /* 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, @@ -1167,7 +1167,7 @@ int out_handle(struct tgt_session_info *tsi) } /* 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) @@ -1180,7 +1180,7 @@ int out_handle(struct tgt_session_info *tsi) /* 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; @@ -1188,7 +1188,7 @@ int out_handle(struct tgt_session_info *tsi) 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) @@ -1234,7 +1234,7 @@ out_free: } 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); diff --git a/lustre/target/tgt_handler.c b/lustre/target/tgt_handler.c index 0330be3..c6c7e54 100644 --- a/lustre/target/tgt_handler.c +++ b/lustre/target/tgt_handler.c @@ -63,7 +63,7 @@ EXPORT_SYMBOL(tgt_name); * - 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()). * */ @@ -100,7 +100,7 @@ static int tgt_mdt_body_unpack(struct tgt_session_info *tsi, __u32 flags) &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 { @@ -277,9 +277,8 @@ static int tgt_ost_body_unpack(struct tgt_session_info *tsi, __u32 flags) } 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 { @@ -317,7 +316,7 @@ static int tgt_request_preprocess(struct tgt_session_info *tsi, 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); @@ -333,10 +332,10 @@ static int tgt_request_preprocess(struct tgt_session_info *tsi, } } - 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); @@ -418,7 +417,7 @@ static int tgt_handle_request0(struct tgt_session_info *tsi, 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)) @@ -1375,10 +1374,10 @@ int tgt_cp_callback(struct tgt_session_info *tsi) /* 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); @@ -1540,8 +1539,8 @@ static int tgt_handle_lfsck_query(struct tgt_session_info *tsi) } 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); -- 1.8.3.1