From 5770020076b339f82d8663f53a4312cba47b08d9 Mon Sep 17 00:00:00 2001 From: Timothy Day Date: Wed, 19 Apr 2023 01:55:47 +0000 Subject: [PATCH] LU-12610 ldlm: replace OBD_ -> CFS_ macros Replace OBD macros that are simply redefinitions of CFS macros. Test-Parameters: trivial Signed-off-by: Timothy Day Signed-off-by: Ben Evans Change-Id: I4d903f286f138152cff22df5cba411d2c9fcb4a8 Reviewed-on: https://review.whamcloud.com/c/fs/lustre-release/+/50685 Reviewed-by: Andreas Dilger Reviewed-by: Patrick Farrell Reviewed-by: James Simmons Reviewed-by: Arshad Hussain Reviewed-by: Oleg Drokin Tested-by: jenkins Tested-by: Maloo --- lustre/ldlm/ldlm_extent.c | 8 ++++---- lustre/ldlm/ldlm_flock.c | 16 ++++++++-------- lustre/ldlm/ldlm_lib.c | 26 +++++++++++++------------- lustre/ldlm/ldlm_lock.c | 8 ++++---- lustre/ldlm/ldlm_lockd.c | 38 +++++++++++++++++++------------------- lustre/ldlm/ldlm_reclaim.c | 6 +++--- lustre/ldlm/ldlm_request.c | 10 +++++----- lustre/ldlm/ldlm_resource.c | 2 +- 8 files changed, 57 insertions(+), 57 deletions(-) diff --git a/lustre/ldlm/ldlm_extent.c b/lustre/ldlm/ldlm_extent.c index 544bfaf..4cbf502 100644 --- a/lustre/ldlm/ldlm_extent.c +++ b/lustre/ldlm/ldlm_extent.c @@ -323,7 +323,7 @@ static bool ldlm_check_contention(struct ldlm_lock *lock, int contended_locks) struct ldlm_resource *res = lock->l_resource; time64_t now = ktime_get_seconds(); - if (OBD_FAIL_CHECK(OBD_FAIL_LDLM_SET_CONTENTION)) + if (CFS_FAIL_CHECK(OBD_FAIL_LDLM_SET_CONTENTION)) return true; CDEBUG(D_DLMTRACE, "contended locks = %d\n", contended_locks); @@ -670,7 +670,7 @@ void ldlm_lock_prolong_one(struct ldlm_lock *lock, { timeout_t timeout; - OBD_FAIL_TIMEOUT(OBD_FAIL_LDLM_PROLONG_PAUSE, 3); + CFS_FAIL_TIMEOUT(OBD_FAIL_LDLM_PROLONG_PAUSE, 3); if (arg->lpa_export != lock->l_export || lock->l_flags & LDLM_FL_DESTROYED) @@ -803,7 +803,7 @@ int ldlm_process_extent_lock(struct ldlm_lock *lock, __u64 *flags, ldlm_resource_unlink_lock(lock); - if (!OBD_FAIL_CHECK(OBD_FAIL_LDLM_CANCEL_EVICT_RACE)) + if (!CFS_FAIL_CHECK(OBD_FAIL_LDLM_CANCEL_EVICT_RACE)) ldlm_extent_policy(res, lock, flags); ldlm_grant_lock(lock, grant_work); RETURN(LDLM_ITER_CONTINUE); @@ -1062,7 +1062,7 @@ void ldlm_extent_add_lock(struct ldlm_resource *res, * add the locks into grant list, for debug purpose, .. */ ldlm_resource_add_lock(res, &res->lr_granted, lock); - if (OBD_FAIL_CHECK(OBD_FAIL_LDLM_GRANT_CHECK)) { + if (CFS_FAIL_CHECK(OBD_FAIL_LDLM_GRANT_CHECK)) { struct ldlm_lock *lck; list_for_each_entry_reverse(lck, &res->lr_granted, diff --git a/lustre/ldlm/ldlm_flock.c b/lustre/ldlm/ldlm_flock.c index d7572a2..978981b 100644 --- a/lustre/ldlm/ldlm_flock.c +++ b/lustre/ldlm/ldlm_flock.c @@ -659,12 +659,12 @@ ldlm_flock_completion_ast(struct ldlm_lock *lock, __u64 flags, void *data) int rc = 0; ENTRY; - OBD_FAIL_TIMEOUT(OBD_FAIL_LDLM_CP_CB_WAIT2, 4); - if (OBD_FAIL_PRECHECK(OBD_FAIL_LDLM_CP_CB_WAIT3)) { + CFS_FAIL_TIMEOUT(OBD_FAIL_LDLM_CP_CB_WAIT2, 4); + if (CFS_FAIL_PRECHECK(OBD_FAIL_LDLM_CP_CB_WAIT3)) { lock_res_and_lock(lock); lock->l_flags |= LDLM_FL_FAIL_LOC; unlock_res_and_lock(lock); - OBD_FAIL_TIMEOUT(OBD_FAIL_LDLM_CP_CB_WAIT3, 4); + CFS_FAIL_TIMEOUT(OBD_FAIL_LDLM_CP_CB_WAIT3, 4); } CDEBUG(D_DLMTRACE, "flags: %#llx data: %p getlk: %p\n", flags, data, getlk); @@ -707,22 +707,22 @@ ldlm_flock_completion_ast(struct ldlm_lock *lock, __u64 flags, void *data) } granted: - OBD_FAIL_TIMEOUT(OBD_FAIL_LDLM_CP_CB_WAIT, 10); + CFS_FAIL_TIMEOUT(OBD_FAIL_LDLM_CP_CB_WAIT, 10); - if (OBD_FAIL_PRECHECK(OBD_FAIL_LDLM_CP_CB_WAIT4)) { + if (CFS_FAIL_PRECHECK(OBD_FAIL_LDLM_CP_CB_WAIT4)) { lock_res_and_lock(lock); /* DEADLOCK is always set with CBPENDING */ lock->l_flags |= LDLM_FL_FLOCK_DEADLOCK | LDLM_FL_CBPENDING; unlock_res_and_lock(lock); - OBD_FAIL_TIMEOUT(OBD_FAIL_LDLM_CP_CB_WAIT4, 4); + CFS_FAIL_TIMEOUT(OBD_FAIL_LDLM_CP_CB_WAIT4, 4); } - if (OBD_FAIL_PRECHECK(OBD_FAIL_LDLM_CP_CB_WAIT5)) { + if (CFS_FAIL_PRECHECK(OBD_FAIL_LDLM_CP_CB_WAIT5)) { lock_res_and_lock(lock); /* DEADLOCK is always set with CBPENDING */ lock->l_flags |= (LDLM_FL_FAIL_LOC | LDLM_FL_FLOCK_DEADLOCK | LDLM_FL_CBPENDING); unlock_res_and_lock(lock); - OBD_FAIL_TIMEOUT(OBD_FAIL_LDLM_CP_CB_WAIT5, 4); + CFS_FAIL_TIMEOUT(OBD_FAIL_LDLM_CP_CB_WAIT5, 4); } lock_res_and_lock(lock); diff --git a/lustre/ldlm/ldlm_lib.c b/lustre/ldlm/ldlm_lib.c index b98a38b..40b5a3f 100644 --- a/lustre/ldlm/ldlm_lib.c +++ b/lustre/ldlm/ldlm_lib.c @@ -1098,7 +1098,7 @@ int target_handle_connect(struct ptlrpc_request *req) ENTRY; - OBD_RACE(OBD_FAIL_TGT_CONN_RACE); + CFS_RACE(OBD_FAIL_TGT_CONN_RACE); str = req_capsule_client_get(&req->rq_pill, &RMF_TGTUUID); if (str == NULL) { @@ -1327,7 +1327,7 @@ int target_handle_connect(struct ptlrpc_request *req) rc = -EALREADY; class_export_put(export); export = NULL; - } else if (OBD_FAIL_PRECHECK(OBD_FAIL_TGT_RECOVERY_CONNECT) && + } else if (CFS_FAIL_PRECHECK(OBD_FAIL_TGT_RECOVERY_CONNECT) && !lw_client) { spin_unlock(&export->exp_lock); rc = -EAGAIN; @@ -1342,7 +1342,7 @@ int target_handle_connect(struct ptlrpc_request *req) /* If we found an export, we already unlocked. */ if (!export) { no_export: - OBD_FAIL_TIMEOUT(OBD_FAIL_TGT_DELAY_CONNECT, 2 * obd_timeout); + CFS_FAIL_TIMEOUT(OBD_FAIL_TGT_DELAY_CONNECT, 2 * obd_timeout); } else if (req->rq_export == NULL && atomic_read(&export->exp_rpc_count) > 0) { LCONSOLE_WARN("%s: Client %s (at %s) refused connection, still busy with %d references\n", @@ -1358,7 +1358,7 @@ no_export: libcfs_nidstr(&req->rq_peer.nid)); GOTO(out, rc = -EALREADY); } else { - OBD_FAIL_TIMEOUT(OBD_FAIL_TGT_DELAY_RECONNECT, 2 * obd_timeout); + CFS_FAIL_TIMEOUT(OBD_FAIL_TGT_DELAY_RECONNECT, 2 * obd_timeout); } if (rc < 0) @@ -1437,7 +1437,7 @@ dont_check_exports: rc = obd_connect(req->rq_svc_thread->t_env, &export, target, &cluuid, data, &req->rq_peer.nid); - if (mds_conn && OBD_FAIL_CHECK(OBD_FAIL_TGT_RCVG_FLAG)) + if (mds_conn && CFS_FAIL_CHECK(OBD_FAIL_TGT_RCVG_FLAG)) lustre_msg_add_op_flags(req->rq_repmsg, MSG_CONNECT_RECOVERING); if (rc == 0) { @@ -2044,7 +2044,7 @@ check_and_start_recovery_timer(struct obd_device *obd, */ service_timeout = at_est2timeout(service_timeout); - if (OBD_FAIL_CHECK(OBD_FAIL_TGT_SLUGGISH_NET) && + if (CFS_FAIL_CHECK(OBD_FAIL_TGT_SLUGGISH_NET) && service_timeout < at_extra) service_timeout = at_extra; @@ -2171,7 +2171,7 @@ static int check_for_next_transno(struct lu_target *lut) } else if (atomic_read(&obd->obd_req_replay_clients) == 0) { CDEBUG(D_HA, "waking for completed recovery\n"); wake_up = 1; - } else if (OBD_FAIL_CHECK(OBD_FAIL_MDS_RECOVERY_ACCEPTS_GAPS)) { + } else if (CFS_FAIL_CHECK(OBD_FAIL_MDS_RECOVERY_ACCEPTS_GAPS)) { CDEBUG(D_HA, "accepting transno gaps is explicitly allowed by fail_lock, waking up (%lld)\n", next_transno); @@ -2813,7 +2813,7 @@ static int target_recovery_thread(void *arg) LASSERT(trd->trd_processing_task == current->pid); DEBUG_REQ(D_HA, req, "processing lock from %s:", libcfs_nidstr(&req->rq_peer.nid)); - if (OBD_FAIL_CHECK(OBD_FAIL_LDLM_LOCK_REPLAY)) { + if (CFS_FAIL_CHECK(OBD_FAIL_LDLM_LOCK_REPLAY)) { req->rq_status = -ENODEV; target_request_copy_put(req); continue; @@ -3043,7 +3043,7 @@ int target_queue_recovery_request(struct ptlrpc_request *req, target_process_req_flags(obd, req); if (lustre_msg_get_flags(req->rq_reqmsg) & MSG_LOCK_REPLAY_DONE) { - if (unlikely(OBD_FAIL_CHECK(OBD_FAIL_TGT_RECOVERY_REQ_RACE))) { + if (unlikely(CFS_FAIL_CHECK(OBD_FAIL_TGT_RECOVERY_REQ_RACE))) { if (cfs_fail_val == 1) { cfs_race_state = 1; cfs_fail_val = 0; @@ -3167,7 +3167,7 @@ int target_queue_recovery_request(struct ptlrpc_request *req, } spin_unlock(&obd->obd_recovery_task_lock); - if (OBD_FAIL_CHECK(OBD_FAIL_TGT_REPLAY_DROP)) + if (CFS_FAIL_CHECK(OBD_FAIL_TGT_REPLAY_DROP)) RETURN(0); target_request_copy_get(req); @@ -3266,7 +3266,7 @@ int target_pack_pool_reply(struct ptlrpc_request *req) static int target_send_reply_msg(struct ptlrpc_request *req, int rc, int fail_id) { - if (OBD_FAIL_CHECK_ORSET(fail_id & ~OBD_FAIL_ONCE, OBD_FAIL_ONCE)) { + if (CFS_FAIL_CHECK_ORSET(fail_id & ~CFS_FAIL_ONCE, CFS_FAIL_ONCE)) { DEBUG_REQ(D_ERROR, req, "dropping reply"); return -ECOMM; } @@ -3276,7 +3276,7 @@ static int target_send_reply_msg(struct ptlrpc_request *req, */ if (req->rq_reqmsg && unlikely(lustre_msg_get_opc(req->rq_reqmsg) == MDS_REINT && - OBD_FAIL_CHECK(OBD_FAIL_MDS_REINT_MULTI_NET_REP))) + CFS_FAIL_CHECK(OBD_FAIL_MDS_REINT_MULTI_NET_REP))) return -ECOMM; if (unlikely(rc)) { @@ -3540,7 +3540,7 @@ int target_bulk_io(struct obd_export *exp, struct ptlrpc_bulk_desc *desc) RETURN(rc); } - if (OBD_FAIL_CHECK(OBD_FAIL_MDS_SENDPAGE)) { + if (CFS_FAIL_CHECK(OBD_FAIL_MDS_SENDPAGE)) { ptlrpc_abort_bulk(desc); RETURN(0); } diff --git a/lustre/ldlm/ldlm_lock.c b/lustre/ldlm/ldlm_lock.c index f1d2868..2c9bad9 100644 --- a/lustre/ldlm/ldlm_lock.c +++ b/lustre/ldlm/ldlm_lock.c @@ -884,7 +884,7 @@ void ldlm_lock_decref_internal(struct ldlm_lock *lock, enum ldlm_mode mode) unlock_res_and_lock(lock); if (ldlm_is_fail_loc(lock)) - OBD_RACE(OBD_FAIL_LDLM_CP_BL_RACE); + CFS_RACE(OBD_FAIL_LDLM_CP_BL_RACE); if (ldlm_is_atomic_cb(lock) || ldlm_bl_to_thread_lock(ns, NULL, lock) != 0) @@ -903,7 +903,7 @@ void ldlm_lock_decref_internal(struct ldlm_lock *lock, enum ldlm_mode mode) LDLM_DEBUG(lock, "add lock into lru list"); if (ldlm_is_fail_loc(lock)) - OBD_RACE(OBD_FAIL_LDLM_CP_BL_RACE); + CFS_RACE(OBD_FAIL_LDLM_CP_BL_RACE); ldlm_pool_recalc(&ns->ns_pool, true); } else { @@ -1726,7 +1726,7 @@ struct ldlm_lock *ldlm_lock_create(struct ldlm_namespace *ns, } lock->l_lvb_type = lvb_type; - if (OBD_FAIL_CHECK(OBD_FAIL_LDLM_NEW_LOCK)) + if (CFS_FAIL_CHECK(OBD_FAIL_LDLM_NEW_LOCK)) GOTO(out, rc = -ENOENT); RETURN(lock); @@ -2070,7 +2070,7 @@ int ldlm_handle_conflict_lock(struct ldlm_lock *lock, __u64 *flags, rc = ldlm_run_ast_work(ldlm_res_to_ns(res), rpc_list, LDLM_WORK_BL_AST); - if (OBD_FAIL_CHECK(OBD_FAIL_LDLM_OST_FAIL_RACE) && + if (CFS_FAIL_CHECK(OBD_FAIL_LDLM_OST_FAIL_RACE) && !ns_is_client(ldlm_res_to_ns(res))) class_fail_export(lock->l_export); diff --git a/lustre/ldlm/ldlm_lockd.c b/lustre/ldlm/ldlm_lockd.c index ddf11e5..3c164f0 100644 --- a/lustre/ldlm/ldlm_lockd.c +++ b/lustre/ldlm/ldlm_lockd.c @@ -241,7 +241,7 @@ static int expired_lock_main(void *arg) spin_unlock_bh(&waiting_locks_spinlock); /* Check if we need to prolong timeout */ - if (!OBD_FAIL_CHECK(OBD_FAIL_PTLRPC_HPREQ_TIMEOUT) && + if (!CFS_FAIL_CHECK(OBD_FAIL_PTLRPC_HPREQ_TIMEOUT) && lock->l_callback_timestamp != 0 && /* not AST error */ ldlm_lock_busy(lock)) { LDLM_DEBUG(lock, "prolong the busy lock"); @@ -386,8 +386,8 @@ static int __ldlm_add_waiting_lock(struct ldlm_lock *lock, timeout_t delay) if (!list_empty(&lock->l_pending_chain)) return 0; - if (OBD_FAIL_CHECK(OBD_FAIL_PTLRPC_HPREQ_NOTIMEOUT) || - OBD_FAIL_CHECK(OBD_FAIL_PTLRPC_HPREQ_TIMEOUT)) + if (CFS_FAIL_CHECK(OBD_FAIL_PTLRPC_HPREQ_NOTIMEOUT) || + CFS_FAIL_CHECK(OBD_FAIL_PTLRPC_HPREQ_TIMEOUT)) delay = 1; deadline = lock->l_blast_sent + delay; @@ -943,7 +943,7 @@ int ldlm_server_blocking_ast(struct ldlm_lock *lock, /* Don't need to do anything here. */ RETURN(0); - if (OBD_FAIL_PRECHECK(OBD_FAIL_LDLM_SRV_BL_AST)) { + if (CFS_FAIL_PRECHECK(OBD_FAIL_LDLM_SRV_BL_AST)) { LDLM_DEBUG(lock, "dropping BL AST"); RETURN(0); } @@ -1054,7 +1054,7 @@ int ldlm_server_completion_ast(struct ldlm_lock *lock, __u64 flags, void *data) LASSERT(lock != NULL); LASSERT(data != NULL); - if (OBD_FAIL_PRECHECK(OBD_FAIL_LDLM_SRV_CP_AST)) { + if (CFS_FAIL_PRECHECK(OBD_FAIL_LDLM_SRV_CP_AST)) { LDLM_DEBUG(lock, "dropping CP AST"); RETURN(0); } @@ -1386,7 +1386,7 @@ int ldlm_handle_enqueue(struct ldlm_namespace *ns, } } - OBD_FAIL_TIMEOUT(OBD_FAIL_LDLM_ENQUEUE_BLOCKED, obd_timeout * 2); + CFS_FAIL_TIMEOUT(OBD_FAIL_LDLM_ENQUEUE_BLOCKED, obd_timeout * 2); /* * Don't enqueue a lock onto the export if it is been disonnected * due to eviction (b=3822) or server umount (b=24324). @@ -1434,7 +1434,7 @@ existing_lock: req_capsule_set_size(pill, &RMF_DLM_LVB, RCL_SERVER, ldlm_lvbo_size(lock)); - if (OBD_FAIL_CHECK(OBD_FAIL_LDLM_ENQUEUE_EXTENT_ERR)) + if (CFS_FAIL_CHECK(OBD_FAIL_LDLM_ENQUEUE_EXTENT_ERR)) GOTO(out, rc = -ENOMEM); rc = req_capsule_server_pack(pill); @@ -1455,7 +1455,7 @@ existing_lock: ldlm_lock2handle(lock, &dlm_rep->lock_handle); if (lock->l_resource->lr_type == LDLM_EXTENT) - OBD_FAIL_TIMEOUT(OBD_FAIL_LDLM_BL_EVICT, 6); + CFS_FAIL_TIMEOUT(OBD_FAIL_LDLM_BL_EVICT, 6); /* * We never send a blocking AST until the lock is granted, but @@ -1476,7 +1476,7 @@ existing_lock: * Cancel it now instead. */ if (unlikely(req->rq_export->exp_disconnected || - OBD_FAIL_CHECK(OBD_FAIL_LDLM_ENQUEUE_OLD_EXPORT))) { + CFS_FAIL_CHECK(OBD_FAIL_LDLM_ENQUEUE_OLD_EXPORT))) { LDLM_ERROR(lock, "lock on destroyed export %p", req->rq_export); rc = -ENOTCONN; } else if (ldlm_is_ast_sent(lock)) { @@ -1984,7 +1984,7 @@ static int ldlm_handle_cp_callback(struct ptlrpc_request *req, LDLM_DEBUG(lock, "client completion callback handler START"); - if (OBD_FAIL_CHECK(OBD_FAIL_LDLM_CANCEL_BL_CB_RACE)) { + if (CFS_FAIL_CHECK(OBD_FAIL_LDLM_CANCEL_BL_CB_RACE)) { long to = cfs_time_seconds(1); ldlm_callback_reply(req, 0); @@ -2093,7 +2093,7 @@ static int ldlm_handle_cp_callback(struct ptlrpc_request *req, * Let Enqueue to call osc_lock_upcall() and initialize * l_ast_data */ - OBD_FAIL_TIMEOUT(OBD_FAIL_OSC_CP_ENQ_RACE, 2); + CFS_FAIL_TIMEOUT(OBD_FAIL_OSC_CP_ENQ_RACE, 2); ldlm_run_ast_work(ns, &ast_list, LDLM_WORK_CP_AST); @@ -2401,18 +2401,18 @@ static int ldlm_callback_handler(struct ptlrpc_request *req) switch (lustre_msg_get_opc(req->rq_reqmsg)) { case LDLM_BL_CALLBACK: - if (OBD_FAIL_CHECK(OBD_FAIL_LDLM_BL_CALLBACK_NET)) { + if (CFS_FAIL_CHECK(OBD_FAIL_LDLM_BL_CALLBACK_NET)) { if (cfs_fail_err) ldlm_callback_reply(req, -(int)cfs_fail_err); RETURN(0); } break; case LDLM_CP_CALLBACK: - if (OBD_FAIL_CHECK(OBD_FAIL_LDLM_CP_CALLBACK_NET)) + if (CFS_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)) + if (CFS_FAIL_CHECK(OBD_FAIL_LDLM_GL_CALLBACK_NET)) RETURN(0); break; case LDLM_SET_INFO: @@ -2443,7 +2443,7 @@ static int ldlm_callback_handler(struct ptlrpc_request *req) * 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) && + if (CFS_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) @@ -2463,7 +2463,7 @@ static int ldlm_callback_handler(struct ptlrpc_request *req) if (ldlm_is_fail_loc(lock) && lustre_msg_get_opc(req->rq_reqmsg) == LDLM_BL_CALLBACK) - OBD_RACE(OBD_FAIL_LDLM_CP_BL_RACE); + CFS_RACE(OBD_FAIL_LDLM_CP_BL_RACE); /* Copy hints/flags (e.g. LDLM_FL_DISCARD_DATA) from AST. */ lock_res_and_lock(lock); @@ -2527,7 +2527,7 @@ static int ldlm_callback_handler(struct ptlrpc_request *req) LDLM_DEBUG(lock, "completion ast\n"); req_capsule_extend(&req->rq_pill, &RQF_LDLM_CP_CALLBACK); rc = ldlm_handle_cp_callback(req, ns, dlm_req, lock); - if (!OBD_FAIL_CHECK(OBD_FAIL_LDLM_CANCEL_BL_CB_RACE)) + if (!CFS_FAIL_CHECK(OBD_FAIL_LDLM_CANCEL_BL_CB_RACE)) ldlm_callback_reply(req, rc); break; case LDLM_GL_CALLBACK: @@ -2922,7 +2922,7 @@ static int ldlm_bl_thread_blwi(struct ldlm_bl_pool *blp, if (blwi->blwi_mem_pressure) mpflags = memalloc_noreclaim_save(); - OBD_FAIL_TIMEOUT(OBD_FAIL_LDLM_PAUSE_CANCEL2, 4); + CFS_FAIL_TIMEOUT(OBD_FAIL_LDLM_PAUSE_CANCEL2, 4); if (blwi->blwi_count) { int count; @@ -2972,7 +2972,7 @@ static int ldlm_bl_thread_exports(struct ldlm_bl_pool *blp, ENTRY; - OBD_FAIL_TIMEOUT(OBD_FAIL_LDLM_BL_EVICT, 4); + CFS_FAIL_TIMEOUT(OBD_FAIL_LDLM_BL_EVICT, 4); num = ldlm_export_cancel_blocked_locks(exp); if (num == 0) diff --git a/lustre/ldlm/ldlm_reclaim.c b/lustre/ldlm/ldlm_reclaim.c index d371dc2..cc3750f 100644 --- a/lustre/ldlm/ldlm_reclaim.c +++ b/lustre/ldlm/ldlm_reclaim.c @@ -142,7 +142,7 @@ static int ldlm_reclaim_lock_cb(struct cfs_hash *hs, struct cfs_hash_bd *bd, if (!ldlm_lock_reclaimable(lock)) continue; - if (!OBD_FAIL_CHECK(OBD_FAIL_LDLM_WATERMARK_LOW) && + if (!CFS_FAIL_CHECK(OBD_FAIL_LDLM_WATERMARK_LOW) && ktime_before(ktime_get(), ktime_add_ns(lock->l_last_used, data->rcd_age_ns))) @@ -329,14 +329,14 @@ bool ldlm_reclaim_full(void) __u64 high = ldlm_lock_limit; __u64 low = ldlm_reclaim_threshold; - if (low != 0 && OBD_FAIL_CHECK(OBD_FAIL_LDLM_WATERMARK_LOW)) + if (low != 0 && CFS_FAIL_CHECK(OBD_FAIL_LDLM_WATERMARK_LOW)) low = cfs_fail_val; if (low != 0 && percpu_counter_sum_positive(&ldlm_granted_total) > low) ldlm_reclaim_ns(); - if (high != 0 && OBD_FAIL_CHECK(OBD_FAIL_LDLM_WATERMARK_HIGH)) + if (high != 0 && CFS_FAIL_CHECK(OBD_FAIL_LDLM_WATERMARK_HIGH)) high = cfs_fail_val; if (high != 0 && diff --git a/lustre/ldlm/ldlm_request.c b/lustre/ldlm/ldlm_request.c index 64408cc..f986c95 100644 --- a/lustre/ldlm/ldlm_request.c +++ b/lustre/ldlm/ldlm_request.c @@ -305,8 +305,8 @@ noreproc: } if (ns_is_client(ldlm_lock_to_ns(lock)) && - OBD_FAIL_CHECK_RESET(OBD_FAIL_LDLM_INTR_CP_AST, - OBD_FAIL_LDLM_CP_BL_RACE | OBD_FAIL_ONCE)) { + CFS_FAIL_CHECK_RESET(OBD_FAIL_LDLM_INTR_CP_AST, + OBD_FAIL_LDLM_CP_BL_RACE | CFS_FAIL_ONCE)) { ldlm_set_fail_loc(lock); rc = -EINTR; } else { @@ -1292,7 +1292,7 @@ static __u64 ldlm_cli_cancel_local(struct ldlm_lock *lock) bool local_only; LDLM_DEBUG(lock, "client-side cancel"); - OBD_FAIL_TIMEOUT(OBD_FAIL_LDLM_PAUSE_CANCEL_LOCAL, + CFS_FAIL_TIMEOUT(OBD_FAIL_LDLM_PAUSE_CANCEL_LOCAL, cfs_fail_val); /* Set this flag to prevent others from getting new references*/ @@ -1656,7 +1656,7 @@ int ldlm_cli_cancel(const struct lustre_handle *lockh, unlock_res_and_lock(lock); if (flags & LCF_LOCAL) - OBD_FAIL_TIMEOUT(OBD_FAIL_LDLM_LOCAL_CANCEL_PAUSE, + CFS_FAIL_TIMEOUT(OBD_FAIL_LDLM_LOCAL_CANCEL_PAUSE, cfs_fail_val); rc = ldlm_cli_cancel_local(lock); @@ -2636,7 +2636,7 @@ static void ldlm_cancel_unused_locks_for_replay(struct ldlm_namespace *ns) "Dropping as many unused locks as possible before replay for namespace %s (%d)\n", ldlm_ns_name(ns), ns->ns_nr_unused); - OBD_FAIL_TIMEOUT(OBD_FAIL_LDLM_REPLAY_PAUSE, cfs_fail_val); + CFS_FAIL_TIMEOUT(OBD_FAIL_LDLM_REPLAY_PAUSE, cfs_fail_val); /* * We don't need to care whether or not LRU resize is enabled diff --git a/lustre/ldlm/ldlm_resource.c b/lustre/ldlm/ldlm_resource.c index 47b40d1..e22bcb0 100644 --- a/lustre/ldlm/ldlm_resource.c +++ b/lustre/ldlm/ldlm_resource.c @@ -1552,7 +1552,7 @@ found: cfs_hash_bd_unlock(ns->ns_rs_hash, &bd, 1); - OBD_FAIL_TIMEOUT(OBD_FAIL_LDLM_CREATE_RESOURCE, 2); + CFS_FAIL_TIMEOUT(OBD_FAIL_LDLM_CREATE_RESOURCE, 2); /* Let's see if we happened to be the very first resource in this * namespace. If so, and this is a client namespace, we need to move -- 1.8.3.1