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 <timday@amazon.com>
Signed-off-by: Ben Evans <beevans@whamcloud.com>
Change-Id: I4d903f286f138152cff22df5cba411d2c9fcb4a8
Reviewed-on: https://review.whamcloud.com/c/fs/lustre-release/+/50685
Reviewed-by: Andreas Dilger <adilger@whamcloud.com>
Reviewed-by: Patrick Farrell <pfarrell@whamcloud.com>
Reviewed-by: James Simmons <jsimmons@infradead.org>
Reviewed-by: Arshad Hussain <arshad.hussain@aeoncomputing.com>
Reviewed-by: Oleg Drokin <green@whamcloud.com>
Tested-by: jenkins <devops@whamcloud.com>
Tested-by: Maloo <maloo@whamcloud.com>

diff --git a/lustre/ldlm/ldlm_extent.c b/lustre/ldlm/ldlm_extent.c
index 544bfaf..4cbf502 100644 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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