From 9c6c262ffd6ba46e666586cd492749ec9c063a71 Mon Sep 17 00:00:00 2001 From: Andreas Dilger Date: Thu, 11 Oct 2012 20:02:48 -0600 Subject: [PATCH] LU-1972 mdt: declare RPC handlers in a sane way Declare the MDT RPC handlers in a way that they can be found when searching for them, otherwise the code is completely opaque when looking for the handler for an RPC (e.g. MDS_CLOSE or LDLM_ENQUEUE). While it might make sense to have macros replace a lot of repetetive code blocks, it doesn't make sense to chop up the RPC names so badly that they can never be found through normal searching. Rename the RPC handler definition macros to have more meaningful names, and remove unused macros and special cases where not strictly necessary. Rename a few OBD_FAIL_LDLM_ error injection hooks instead of making the macros more complex for a small number of use cases. These names are only used internally, even if the values are used in the tests. Signed-off-by: Andreas Dilger Change-Id: I8d4dc0709faeae4458c3563864268a00f8500c1e Reviewed-on: http://review.whamcloud.com/4260 Tested-by: Hudson Reviewed-by: Alex Zhuravlev Tested-by: Maloo Reviewed-by: Mike Pershin Reviewed-by: Oleg Drokin --- lustre/include/obd_support.h | 14 +-- lustre/ldlm/ldlm_lockd.c | 30 +++---- lustre/mdc/mdc_reint.c | 34 ++++---- lustre/mdt/mdt_handler.c | 194 +++++++++++++++++++---------------------- lustre/ost/ost_handler.c | 48 +++++----- lustre/tests/conf-sanity.sh | 2 +- lustre/tests/replay-dual.sh | 4 +- lustre/tests/replay-single.sh | 2 +- lustre/tests/test-framework.sh | 4 +- 9 files changed, 160 insertions(+), 172 deletions(-) diff --git a/lustre/include/obd_support.h b/lustre/include/obd_support.h index 73a1145..480d1b2 100644 --- a/lustre/include/obd_support.h +++ b/lustre/include/obd_support.h @@ -295,12 +295,12 @@ int obd_alloc_fail(const void *ptr, const char *name, const char *type, #define OBD_FAIL_LDLM 0x300 #define OBD_FAIL_LDLM_NAMESPACE_NEW 0x301 -#define OBD_FAIL_LDLM_ENQUEUE 0x302 -#define OBD_FAIL_LDLM_CONVERT 0x303 -#define OBD_FAIL_LDLM_CANCEL 0x304 -#define OBD_FAIL_LDLM_BL_CALLBACK 0x305 -#define OBD_FAIL_LDLM_CP_CALLBACK 0x306 -#define OBD_FAIL_LDLM_GL_CALLBACK 0x307 +#define OBD_FAIL_LDLM_ENQUEUE_NET 0x302 +#define OBD_FAIL_LDLM_CONVERT_NET 0x303 +#define OBD_FAIL_LDLM_CANCEL_NET 0x304 +#define OBD_FAIL_LDLM_BL_CALLBACK_NET 0x305 +#define OBD_FAIL_LDLM_CP_CALLBACK_NET 0x306 +#define OBD_FAIL_LDLM_GL_CALLBACK_NET 0x307 #define OBD_FAIL_LDLM_ENQUEUE_EXTENT_ERR 0x308 #define OBD_FAIL_LDLM_ENQUEUE_INTENT_ERR 0x309 #define OBD_FAIL_LDLM_CREATE_RESOURCE 0x30a @@ -404,7 +404,7 @@ int obd_alloc_fail(const void *ptr, const char *name, const char *type, #define OBD_FAIL_MGS_PAUSE_REQ 0x904 #define OBD_FAIL_MGS_PAUSE_TARGET_REG 0x905 -#define OBD_FAIL_QUOTA_DQACQ 0xA01 +#define OBD_FAIL_QUOTA_DQACQ_NET 0xA01 #define OBD_FAIL_QUOTA_EDQUOT 0xA02 #define OBD_FAIL_QUOTA_DELAY_REINT 0xA03 #define OBD_FAIL_QUOTA_RECOVERABLE_ERR 0xA04 diff --git a/lustre/ldlm/ldlm_lockd.c b/lustre/ldlm/ldlm_lockd.c index e960325..b38d854 100644 --- a/lustre/ldlm/ldlm_lockd.c +++ b/lustre/ldlm/ldlm_lockd.c @@ -1983,19 +1983,19 @@ static int ldlm_callback_handler(struct ptlrpc_request *req) 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)) - RETURN(0); - break; - case LDLM_CP_CALLBACK: - if (OBD_FAIL_CHECK(OBD_FAIL_LDLM_CP_CALLBACK)) - RETURN(0); - break; - case LDLM_GL_CALLBACK: - if (OBD_FAIL_CHECK(OBD_FAIL_LDLM_GL_CALLBACK)) - RETURN(0); - break; + 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); @@ -2191,8 +2191,8 @@ static int ldlm_cancel_handler(struct ptlrpc_request *req) case LDLM_CANCEL: req_capsule_set(&req->rq_pill, &RQF_LDLM_CANCEL); CDEBUG(D_INODE, "cancel\n"); - if (OBD_FAIL_CHECK(OBD_FAIL_LDLM_CANCEL)) - RETURN(0); + if (OBD_FAIL_CHECK(OBD_FAIL_LDLM_CANCEL_NET)) + RETURN(0); rc = ldlm_handle_cancel(req); if (rc) break; diff --git a/lustre/mdc/mdc_reint.c b/lustre/mdc/mdc_reint.c index 6922c57..3d3c450 100644 --- a/lustre/mdc/mdc_reint.c +++ b/lustre/mdc/mdc_reint.c @@ -119,11 +119,11 @@ int mdc_setattr(struct obd_export *exp, struct md_op_data *op_data, bits = MDS_INODELOCK_UPDATE; if (op_data->op_attr.ia_valid & (ATTR_MODE|ATTR_UID|ATTR_GID)) bits |= MDS_INODELOCK_LOOKUP; - if ((op_data->op_flags & MF_MDC_CANCEL_FID1) && - (fid_is_sane(&op_data->op_fid1)) && - !OBD_FAIL_CHECK(OBD_FAIL_LDLM_BL_CALLBACK)) - count = mdc_resource_get_unused(exp, &op_data->op_fid1, - &cancels, LCK_EX, bits); + if ((op_data->op_flags & MF_MDC_CANCEL_FID1) && + (fid_is_sane(&op_data->op_fid1)) && + !OBD_FAIL_CHECK(OBD_FAIL_LDLM_BL_CALLBACK_NET)) + count = mdc_resource_get_unused(exp, &op_data->op_fid1, + &cancels, LCK_EX, bits); req = ptlrpc_request_alloc(class_exp2cliimp(exp), &RQF_MDS_REINT_SETATTR); if (req == NULL) { @@ -326,18 +326,18 @@ int mdc_unlink(struct obd_export *exp, struct md_op_data *op_data, LASSERT(req == NULL); - if ((op_data->op_flags & MF_MDC_CANCEL_FID1) && - (fid_is_sane(&op_data->op_fid1)) && - !OBD_FAIL_CHECK(OBD_FAIL_LDLM_BL_CALLBACK)) - count = mdc_resource_get_unused(exp, &op_data->op_fid1, - &cancels, LCK_EX, - MDS_INODELOCK_UPDATE); - if ((op_data->op_flags & MF_MDC_CANCEL_FID3) && - (fid_is_sane(&op_data->op_fid3)) && - !OBD_FAIL_CHECK(OBD_FAIL_LDLM_BL_CALLBACK)) - count += mdc_resource_get_unused(exp, &op_data->op_fid3, - &cancels, LCK_EX, - MDS_INODELOCK_FULL); + if ((op_data->op_flags & MF_MDC_CANCEL_FID1) && + (fid_is_sane(&op_data->op_fid1)) && + !OBD_FAIL_CHECK(OBD_FAIL_LDLM_BL_CALLBACK_NET)) + count = mdc_resource_get_unused(exp, &op_data->op_fid1, + &cancels, LCK_EX, + MDS_INODELOCK_UPDATE); + if ((op_data->op_flags & MF_MDC_CANCEL_FID3) && + (fid_is_sane(&op_data->op_fid3)) && + !OBD_FAIL_CHECK(OBD_FAIL_LDLM_BL_CALLBACK_NET)) + count += mdc_resource_get_unused(exp, &op_data->op_fid3, + &cancels, LCK_EX, + MDS_INODELOCK_FULL); req = ptlrpc_request_alloc(class_exp2cliimp(exp), &RQF_MDS_REINT_UNLINK); if (req == NULL) { diff --git a/lustre/mdt/mdt_handler.c b/lustre/mdt/mdt_handler.c index 62da03a..b5aaad8 100644 --- a/lustre/mdt/mdt_handler.c +++ b/lustre/mdt/mdt_handler.c @@ -6426,115 +6426,99 @@ static void __exit mdt_mod_exit(void) lu_kmem_fini(mdt_caches); } - -#define DEF_HNDL(prefix, base, suffix, flags, opc, fn, fmt) \ -[prefix ## _ ## opc - prefix ## _ ## base] = { \ - .mh_name = #opc, \ - .mh_fail_id = OBD_FAIL_ ## prefix ## _ ## opc ## suffix, \ - .mh_opc = prefix ## _ ## opc, \ - .mh_flags = flags, \ - .mh_act = fn, \ - .mh_fmt = fmt \ +#define DEFINE_RPC_HANDLER(base, flags, opc, fn, fmt) \ +[opc - base] = { \ + .mh_name = #opc, \ + .mh_fail_id = OBD_FAIL_ ## opc ## _NET, \ + .mh_opc = opc, \ + .mh_flags = flags, \ + .mh_act = fn, \ + .mh_fmt = fmt \ } -#define DEF_MDT_HNDL(flags, name, fn, fmt) \ - DEF_HNDL(MDS, GETATTR, _NET, flags, name, fn, fmt) - -#define DEF_SEQ_HNDL(flags, name, fn, fmt) \ - DEF_HNDL(SEQ, QUERY, _NET, flags, name, fn, fmt) - -#define DEF_FLD_HNDL(flags, name, fn, fmt) \ - DEF_HNDL(FLD, QUERY, _NET, flags, name, fn, fmt) -/* - * Request with a format known in advance - */ -#define DEF_MDT_HNDL_F(flags, name, fn) \ - DEF_HNDL(MDS, GETATTR, _NET, flags, name, fn, &RQF_MDS_ ## name) +/* Request with a format known in advance */ +#define DEF_MDT_HDL(flags, name, fn) \ + DEFINE_RPC_HANDLER(MDS_GETATTR, flags, name, fn, &RQF_ ## name) -#define DEF_SEQ_HNDL_F(flags, name, fn) \ - DEF_HNDL(SEQ, QUERY, _NET, flags, name, fn, &RQF_SEQ_ ## name) +/* Request with a format we do not yet know */ +#define DEF_MDT_HDL_VAR(flags, name, fn) \ + DEFINE_RPC_HANDLER(MDS_GETATTR, flags, name, fn, NULL) -#define DEF_FLD_HNDL_F(flags, name, fn) \ - DEF_HNDL(FLD, QUERY, _NET, flags, name, fn, &RQF_FLD_ ## name) -/* - * Request with a format we do not yet know - */ -#define DEF_MDT_HNDL_0(flags, name, fn) \ - DEF_HNDL(MDS, GETATTR, _NET, flags, name, fn, NULL) +/* Map one non-standard request format handler. This should probably get + * a common OBD_SET_INFO RPC opcode instead of this mismatch. */ +#define RQF_MDS_SET_INFO RQF_OBD_SET_INFO static struct mdt_handler mdt_mds_ops[] = { -DEF_MDT_HNDL_F(0, CONNECT, mdt_connect), -DEF_MDT_HNDL_F(0, DISCONNECT, mdt_disconnect), -DEF_MDT_HNDL (0, SET_INFO, mdt_set_info, - &RQF_OBD_SET_INFO), -DEF_MDT_HNDL_F(0, GET_INFO, mdt_get_info), -DEF_MDT_HNDL_F(0 |HABEO_REFERO, GETSTATUS, mdt_getstatus), -DEF_MDT_HNDL_F(HABEO_CORPUS, GETATTR, mdt_getattr), -DEF_MDT_HNDL_F(HABEO_CORPUS|HABEO_REFERO, GETATTR_NAME, mdt_getattr_name), -DEF_MDT_HNDL_F(HABEO_CORPUS, GETXATTR, mdt_getxattr), -DEF_MDT_HNDL_F(0 |HABEO_REFERO, STATFS, mdt_statfs), -DEF_MDT_HNDL_F(0 |MUTABOR, REINT, mdt_reint), -DEF_MDT_HNDL_F(HABEO_CORPUS, CLOSE, mdt_close), -DEF_MDT_HNDL_F(HABEO_CORPUS, DONE_WRITING, mdt_done_writing), -DEF_MDT_HNDL_F(0 |HABEO_REFERO, PIN, mdt_pin), -DEF_MDT_HNDL_0(0, SYNC, mdt_sync), -DEF_MDT_HNDL_F(HABEO_CORPUS|HABEO_REFERO, IS_SUBDIR, mdt_is_subdir), -DEF_MDT_HNDL_F(0, QUOTACHECK, mdt_quotacheck), -DEF_MDT_HNDL_F(0, QUOTACTL, mdt_quotactl) +DEF_MDT_HDL(0, MDS_CONNECT, mdt_connect), +DEF_MDT_HDL(0, MDS_DISCONNECT, mdt_disconnect), +DEF_MDT_HDL(0, MDS_SET_INFO, mdt_set_info), +DEF_MDT_HDL(0, MDS_GET_INFO, mdt_get_info), +DEF_MDT_HDL(0 | HABEO_REFERO, MDS_GETSTATUS, mdt_getstatus), +DEF_MDT_HDL(HABEO_CORPUS, MDS_GETATTR, mdt_getattr), +DEF_MDT_HDL(HABEO_CORPUS| HABEO_REFERO, MDS_GETATTR_NAME, mdt_getattr_name), +DEF_MDT_HDL(HABEO_CORPUS, MDS_GETXATTR, mdt_getxattr), +DEF_MDT_HDL(0 | HABEO_REFERO, MDS_STATFS, mdt_statfs), +DEF_MDT_HDL(0 | MUTABOR, MDS_REINT, mdt_reint), +DEF_MDT_HDL(HABEO_CORPUS, MDS_CLOSE, mdt_close), +DEF_MDT_HDL(HABEO_CORPUS, MDS_DONE_WRITING, mdt_done_writing), +DEF_MDT_HDL(0 | HABEO_REFERO, MDS_PIN, mdt_pin), +DEF_MDT_HDL_VAR(0, MDS_SYNC, mdt_sync), +DEF_MDT_HDL(HABEO_CORPUS| HABEO_REFERO, MDS_IS_SUBDIR, mdt_is_subdir), +DEF_MDT_HDL(0, MDS_QUOTACHECK, mdt_quotacheck), +DEF_MDT_HDL(0, MDS_QUOTACTL, mdt_quotactl) }; -#define DEF_OBD_HNDL(flags, name, fn) \ - DEF_HNDL(OBD, PING, _NET, flags, name, fn, NULL) - +#define DEF_OBD_HDL(flags, name, fn) \ + DEFINE_RPC_HANDLER(OBD_PING, flags, name, fn, NULL) static struct mdt_handler mdt_obd_ops[] = { - DEF_OBD_HNDL(0, PING, mdt_obd_ping), - DEF_OBD_HNDL(0, LOG_CANCEL, mdt_obd_log_cancel), - DEF_OBD_HNDL(0, QC_CALLBACK, mdt_obd_qc_callback), - DEF_OBD_HNDL(0, IDX_READ, mdt_obd_idx_read) +DEF_OBD_HDL(0, OBD_PING, mdt_obd_ping), +DEF_OBD_HDL(0, OBD_LOG_CANCEL, mdt_obd_log_cancel), +DEF_OBD_HDL(0, OBD_QC_CALLBACK, mdt_obd_qc_callback), +DEF_OBD_HDL(0, OBD_IDX_READ, mdt_obd_idx_read) }; -#define DEF_DLM_HNDL_0(flags, name, fn) \ - DEF_HNDL(LDLM, ENQUEUE, , flags, name, fn, NULL) -#define DEF_DLM_HNDL_F(flags, name, fn) \ - DEF_HNDL(LDLM, ENQUEUE, , flags, name, fn, &RQF_LDLM_ ## name) +#define DEF_DLM_HDL_VAR(flags, name, fn) \ + DEFINE_RPC_HANDLER(LDLM_ENQUEUE, flags, name, fn, NULL) +#define DEF_DLM_HDL(flags, name, fn) \ + DEFINE_RPC_HANDLER(LDLM_ENQUEUE, flags, name, fn, &RQF_ ## name) static struct mdt_handler mdt_dlm_ops[] = { - DEF_DLM_HNDL_F(HABEO_CLAVIS, ENQUEUE, mdt_enqueue), - DEF_DLM_HNDL_0(HABEO_CLAVIS, CONVERT, mdt_convert), - DEF_DLM_HNDL_0(0, BL_CALLBACK, mdt_bl_callback), - DEF_DLM_HNDL_0(0, CP_CALLBACK, mdt_cp_callback) +DEF_DLM_HDL (HABEO_CLAVIS, LDLM_ENQUEUE, mdt_enqueue), +DEF_DLM_HDL_VAR(HABEO_CLAVIS, LDLM_CONVERT, mdt_convert), +DEF_DLM_HDL_VAR(0, LDLM_BL_CALLBACK, mdt_bl_callback), +DEF_DLM_HDL_VAR(0, LDLM_CP_CALLBACK, mdt_cp_callback) }; -#define DEF_LLOG_HNDL(flags, name, fn) \ - DEF_HNDL(LLOG, ORIGIN_HANDLE_CREATE, _NET, flags, name, fn, NULL) +#define DEF_LLOG_HDL(flags, name, fn) \ + DEFINE_RPC_HANDLER(LLOG_ORIGIN_HANDLE_CREATE, flags, name, fn, NULL) static struct mdt_handler mdt_llog_ops[] = { - DEF_LLOG_HNDL(0, ORIGIN_HANDLE_CREATE, mdt_llog_create), - DEF_LLOG_HNDL(0, ORIGIN_HANDLE_NEXT_BLOCK, mdt_llog_next_block), - DEF_LLOG_HNDL(0, ORIGIN_HANDLE_READ_HEADER, mdt_llog_read_header), - DEF_LLOG_HNDL(0, ORIGIN_HANDLE_WRITE_REC, NULL), - DEF_LLOG_HNDL(0, ORIGIN_HANDLE_CLOSE, NULL), - DEF_LLOG_HNDL(0, ORIGIN_CONNECT, NULL), - DEF_LLOG_HNDL(0, CATINFO, NULL), - DEF_LLOG_HNDL(0, ORIGIN_HANDLE_PREV_BLOCK, mdt_llog_prev_block), - DEF_LLOG_HNDL(0, ORIGIN_HANDLE_DESTROY, mdt_llog_destroy), +DEF_LLOG_HDL(0, LLOG_ORIGIN_HANDLE_CREATE, mdt_llog_create), +DEF_LLOG_HDL(0, LLOG_ORIGIN_HANDLE_NEXT_BLOCK, mdt_llog_next_block), +DEF_LLOG_HDL(0, LLOG_ORIGIN_HANDLE_READ_HEADER, mdt_llog_read_header), +DEF_LLOG_HDL(0, LLOG_ORIGIN_HANDLE_WRITE_REC, NULL), +DEF_LLOG_HDL(0, LLOG_ORIGIN_HANDLE_CLOSE, NULL), +DEF_LLOG_HDL(0, LLOG_ORIGIN_CONNECT, NULL), +DEF_LLOG_HDL(0, LLOG_CATINFO, NULL), +DEF_LLOG_HDL(0, LLOG_ORIGIN_HANDLE_PREV_BLOCK, mdt_llog_prev_block), +DEF_LLOG_HDL(0, LLOG_ORIGIN_HANDLE_DESTROY, mdt_llog_destroy), }; -#define DEF_SEC_CTX_HNDL(name, fn) \ - DEF_HNDL(SEC_CTX, INIT, _NET, 0, name, fn, NULL) +#define DEF_SEC_HDL(flags, name, fn) \ + DEFINE_RPC_HANDLER(SEC_CTX_INIT, flags, name, fn, NULL) static struct mdt_handler mdt_sec_ctx_ops[] = { - DEF_SEC_CTX_HNDL(INIT, mdt_sec_ctx_handle), - DEF_SEC_CTX_HNDL(INIT_CONT, mdt_sec_ctx_handle), - DEF_SEC_CTX_HNDL(FINI, mdt_sec_ctx_handle) +DEF_SEC_HDL(0, SEC_CTX_INIT, mdt_sec_ctx_handle), +DEF_SEC_HDL(0, SEC_CTX_INIT_CONT,mdt_sec_ctx_handle), +DEF_SEC_HDL(0, SEC_CTX_FINI, mdt_sec_ctx_handle) }; -#define DEF_QUOTA_HNDLF(flags, name, fn) \ - DEF_HNDL(QUOTA, DQACQ, , flags, name, fn, &RQF_QUOTA_ ## name) +#define DEF_QUOTA_HDL(flags, name, fn) \ + DEFINE_RPC_HANDLER(QUOTA_DQACQ, flags, name, fn, &RQF_ ## name) static struct mdt_handler mdt_quota_ops[] = { - DEF_QUOTA_HNDLF(HABEO_REFERO, DQACQ, mdt_quota_dqacq), +DEF_QUOTA_HDL(HABEO_REFERO, QUOTA_DQACQ, mdt_quota_dqacq), }; static struct mdt_opc_slice mdt_regular_handlers[] = { @@ -6573,19 +6557,14 @@ static struct mdt_opc_slice mdt_regular_handlers[] = { } }; +/* Readpage/readdir handlers */ static struct mdt_handler mdt_readpage_ops[] = { - DEF_MDT_HNDL_F(0, CONNECT, mdt_connect), - DEF_MDT_HNDL_F(HABEO_CORPUS|HABEO_REFERO, READPAGE, mdt_readpage), -#ifdef HAVE_SPLIT_SUPPORT - DEF_MDT_HNDL_F(HABEO_CORPUS|HABEO_REFERO, WRITEPAGE, mdt_writepage), -#endif - - /* - * XXX: this is ugly and should be fixed one day, see mdc_close() for - * detailed comments. --umka - */ - DEF_MDT_HNDL_F(HABEO_CORPUS, CLOSE, mdt_close), - DEF_MDT_HNDL_F(HABEO_CORPUS, DONE_WRITING, mdt_done_writing), +DEF_MDT_HDL(0, MDS_CONNECT, mdt_connect), +DEF_MDT_HDL(HABEO_CORPUS | HABEO_REFERO, MDS_READPAGE, mdt_readpage), +/* XXX: this is ugly and should be fixed one day, see mdc_close() for + * detailed comments. --umka */ +DEF_MDT_HDL(HABEO_CORPUS, MDS_CLOSE, mdt_close), +DEF_MDT_HDL(HABEO_CORPUS, MDS_DONE_WRITING, mdt_done_writing), }; static struct mdt_opc_slice mdt_readpage_handlers[] = { @@ -6604,11 +6583,12 @@ static struct mdt_opc_slice mdt_readpage_handlers[] = { } }; +/* Cross MDT operation handlers for DNE */ static struct mdt_handler mdt_xmds_ops[] = { - DEF_MDT_HNDL_F(0, CONNECT, mdt_connect), - DEF_MDT_HNDL_F(HABEO_CORPUS , GETATTR, mdt_getattr), - DEF_MDT_HNDL_F(0 | MUTABOR , REINT, mdt_reint), - DEF_MDT_HNDL_F(HABEO_CORPUS|HABEO_REFERO, IS_SUBDIR, mdt_is_subdir), +DEF_MDT_HDL(0, MDS_CONNECT, mdt_connect), +DEF_MDT_HDL(HABEO_CORPUS, MDS_GETATTR, mdt_getattr), +DEF_MDT_HDL(0 | MUTABOR, MDS_REINT, mdt_reint), +DEF_MDT_HDL(HABEO_CORPUS| HABEO_REFERO, MDS_IS_SUBDIR, mdt_is_subdir), }; static struct mdt_opc_slice mdt_xmds_handlers[] = { @@ -6632,8 +6612,12 @@ static struct mdt_opc_slice mdt_xmds_handlers[] = { } }; +/* Sequence service handlers */ +#define DEF_SEQ_HDL(flags, name, fn) \ + DEFINE_RPC_HANDLER(SEQ_QUERY, flags, name, fn, &RQF_ ## name) + static struct mdt_handler mdt_seq_ops[] = { - DEF_SEQ_HNDL_F(0, QUERY, (int (*)(struct mdt_thread_info *))seq_query) +DEF_SEQ_HDL(0, SEQ_QUERY, (void *)seq_query), }; static struct mdt_opc_slice mdt_seq_handlers[] = { @@ -6647,8 +6631,12 @@ static struct mdt_opc_slice mdt_seq_handlers[] = { } }; +/* FID Location Database handlers */ +#define DEF_FLD_HDL(flags, name, fn) \ + DEFINE_RPC_HANDLER(FLD_QUERY, flags, name, fn, &RQF_ ## name) + static struct mdt_handler mdt_fld_ops[] = { - DEF_FLD_HNDL_F(0, QUERY, (int (*)(struct mdt_thread_info *))fld_query) +DEF_FLD_HDL(0, FLD_QUERY, (void *)fld_query), }; static struct mdt_opc_slice mdt_fld_handlers[] = { @@ -6663,7 +6651,7 @@ static struct mdt_opc_slice mdt_fld_handlers[] = { }; MODULE_AUTHOR("Sun Microsystems, Inc. "); -MODULE_DESCRIPTION("Lustre Meta-data Target ("LUSTRE_MDT_NAME")"); +MODULE_DESCRIPTION("Lustre Metadata Target ("LUSTRE_MDT_NAME")"); MODULE_LICENSE("GPL"); -cfs_module(mdt, "0.2.0", mdt_mod_init, mdt_mod_exit); +cfs_module(mdt, LUSTRE_VERSION_STRING, mdt_mod_init, mdt_mod_exit); diff --git a/lustre/ost/ost_handler.c b/lustre/ost/ost_handler.c index a2f4de9..1e0d8b7 100644 --- a/lustre/ost/ost_handler.c +++ b/lustre/ost/ost_handler.c @@ -2334,30 +2334,30 @@ int ost_handle(struct ptlrpc_request *req) if (rc) RETURN(rc); RETURN(ptlrpc_reply(req)); - case LDLM_ENQUEUE: - CDEBUG(D_INODE, "enqueue\n"); - req_capsule_set(&req->rq_pill, &RQF_LDLM_ENQUEUE); - if (OBD_FAIL_CHECK(OBD_FAIL_LDLM_ENQUEUE)) - RETURN(0); - rc = ldlm_handle_enqueue(req, ldlm_server_completion_ast, - ost_blocking_ast, - ldlm_server_glimpse_ast); - fail = OBD_FAIL_OST_LDLM_REPLY_NET; - break; - case LDLM_CONVERT: - CDEBUG(D_INODE, "convert\n"); - req_capsule_set(&req->rq_pill, &RQF_LDLM_CONVERT); - if (OBD_FAIL_CHECK(OBD_FAIL_LDLM_CONVERT)) - RETURN(0); - rc = ldlm_handle_convert(req); - break; - case LDLM_CANCEL: - CDEBUG(D_INODE, "cancel\n"); - req_capsule_set(&req->rq_pill, &RQF_LDLM_CANCEL); - if (OBD_FAIL_CHECK(OBD_FAIL_LDLM_CANCEL)) - RETURN(0); - rc = ldlm_handle_cancel(req); - break; + case LDLM_ENQUEUE: + CDEBUG(D_INODE, "enqueue\n"); + req_capsule_set(&req->rq_pill, &RQF_LDLM_ENQUEUE); + if (OBD_FAIL_CHECK(OBD_FAIL_LDLM_ENQUEUE_NET)) + RETURN(0); + rc = ldlm_handle_enqueue(req, ldlm_server_completion_ast, + ost_blocking_ast, + ldlm_server_glimpse_ast); + fail = OBD_FAIL_OST_LDLM_REPLY_NET; + break; + case LDLM_CONVERT: + CDEBUG(D_INODE, "convert\n"); + req_capsule_set(&req->rq_pill, &RQF_LDLM_CONVERT); + if (OBD_FAIL_CHECK(OBD_FAIL_LDLM_CONVERT_NET)) + RETURN(0); + rc = ldlm_handle_convert(req); + break; + case LDLM_CANCEL: + CDEBUG(D_INODE, "cancel\n"); + req_capsule_set(&req->rq_pill, &RQF_LDLM_CANCEL); + if (OBD_FAIL_CHECK(OBD_FAIL_LDLM_CANCEL_NET)) + RETURN(0); + rc = ldlm_handle_cancel(req); + break; case LDLM_BL_CALLBACK: case LDLM_CP_CALLBACK: CDEBUG(D_INODE, "callback\n"); diff --git a/lustre/tests/conf-sanity.sh b/lustre/tests/conf-sanity.sh index 1e2e598..c5fc54b 100644 --- a/lustre/tests/conf-sanity.sh +++ b/lustre/tests/conf-sanity.sh @@ -1642,7 +1642,7 @@ test_33b() { # was test_34 do_facet client dd if=/dev/zero of=$MOUNT/24 bs=1024k count=1 # Drop lock cancelation reply during umount - #define OBD_FAIL_LDLM_CANCEL 0x304 + #define OBD_FAIL_LDLM_CANCEL_NET 0x304 do_facet client lctl set_param fail_loc=0x80000304 #lctl set_param debug=-1 umount_client $MOUNT diff --git a/lustre/tests/replay-dual.sh b/lustre/tests/replay-dual.sh index 0468b78..639cb85 100755 --- a/lustre/tests/replay-dual.sh +++ b/lustre/tests/replay-dual.sh @@ -267,7 +267,7 @@ test_12() { multiop_bg_pause $DIR/$tfile mo_c || return 1 MULTIPID=$! -#define OBD_FAIL_LDLM_ENQUEUE 0x302 +#define OBD_FAIL_LDLM_ENQUEUE_NET 0x302 do_facet $SINGLEMDS lctl set_param fail_loc=0x80000302 facet_failover $SINGLEMDS do_facet $SINGLEMDS lctl set_param fail_loc=0 @@ -426,7 +426,7 @@ test_18() { # bug 3822 - evicting client with enqueued lock NOW=`date +%s` do_facet $SINGLEMDS lctl set_param fail_loc=0x8000030b # hold enqueue sleep 1 -#define OBD_FAIL_LDLM_BL_CALLBACK 0x305 +#define OBD_FAIL_LDLM_BL_CALLBACK_NET 0x305 do_facet client lctl set_param fail_loc=0x80000305 # drop cb, evict cancel_lru_locks mdc usleep 500 # wait to ensure first client is one that will be evicted diff --git a/lustre/tests/replay-single.sh b/lustre/tests/replay-single.sh index 175a9ad..dd5bdd9 100755 --- a/lustre/tests/replay-single.sh +++ b/lustre/tests/replay-single.sh @@ -1915,7 +1915,7 @@ test_73a() { rm -f $DIR/$tfile replay_barrier $SINGLEMDS -#define OBD_FAIL_LDLM_ENQUEUE 0x302 +#define OBD_FAIL_LDLM_ENQUEUE_NET 0x302 do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000302" fail $SINGLEMDS kill -USR1 $pid diff --git a/lustre/tests/test-framework.sh b/lustre/tests/test-framework.sh index b662da5..9a1bcbd 100644 --- a/lustre/tests/test-framework.sh +++ b/lustre/tests/test-framework.sh @@ -3725,7 +3725,7 @@ pause_bulk() { } drop_ldlm_cancel() { -#define OBD_FAIL_LDLM_CANCEL 0x304 +#define OBD_FAIL_LDLM_CANCEL_NET 0x304 local RC=0 local list=$(comma_list $(mdts_nodes) $(osts_nodes)) do_nodes $list lctl set_param fail_loc=0x304 @@ -3737,7 +3737,7 @@ drop_ldlm_cancel() { } drop_bl_callback() { -#define OBD_FAIL_LDLM_BL_CALLBACK 0x305 +#define OBD_FAIL_LDLM_BL_CALLBACK_NET 0x305 RC=0 do_facet client lctl set_param fail_loc=0x305 do_facet client "$@" || RC=$? -- 1.8.3.1