LU-12610 ptlrpc: replace OBD_ -> CFS_ macros

Replace OBD macros that are simply redefinitions
of CFS macros.

Signed-off-by: Timothy Day <timday@amazon.com>
Signed-off-by: Ben Evans <beevans@whamcloud.com>
Change-Id: I634f364d33ac56de678d273d87c9ac54d1f8c1ef
Reviewed-on: https://review.whamcloud.com/c/fs/lustre-release/+/50684
Reviewed-by: Andreas Dilger <adilger@whamcloud.com>
Reviewed-by: Arshad Hussain <arshad.hussain@aeoncomputing.com>
Reviewed-by: Neil Brown <neilb@suse.de>
Reviewed-by: James Simmons <jsimmons@infradead.org>
Reviewed-by: Oleg Drokin <green@whamcloud.com>
Tested-by: jenkins <devops@whamcloud.com>
Tested-by: Maloo <maloo@whamcloud.com>

diff --git a/lustre/ptlrpc/client.c b/lustre/ptlrpc/client.c
index 657aa63..9bbc8d2 100644 (file)
--- a/lustre/ptlrpc/client.c
+++ b/lustre/ptlrpc/client.c
@@ -1878,13 +1878,13 @@ int ptlrpc_check_set(const struct lu_env *env, struct ptlrpc_request_set *set)
                        LASSERT(req->rq_next_phase != RQ_PHASE_UNDEFINED);
 
                        if (req->rq_req_deadline &&
-                           !OBD_FAIL_CHECK(OBD_FAIL_PTLRPC_LONG_REQ_UNLINK))
+                           !CFS_FAIL_CHECK(OBD_FAIL_PTLRPC_LONG_REQ_UNLINK))
                                req->rq_req_deadline = 0;
                        if (req->rq_reply_deadline &&
-                           !OBD_FAIL_CHECK(OBD_FAIL_PTLRPC_LONG_REPL_UNLINK))
+                           !CFS_FAIL_CHECK(OBD_FAIL_PTLRPC_LONG_REPL_UNLINK))
                                req->rq_reply_deadline = 0;
                        if (req->rq_bulk_deadline &&
-                           !OBD_FAIL_CHECK(OBD_FAIL_PTLRPC_LONG_BULK_UNLINK))
+                           !CFS_FAIL_CHECK(OBD_FAIL_PTLRPC_LONG_BULK_UNLINK))
                                req->rq_bulk_deadline = 0;
 
                        /*
@@ -1905,13 +1905,13 @@ int ptlrpc_check_set(const struct lu_env *env, struct ptlrpc_request_set *set)
                         * Turn fail_loc off to prevent it from looping
                         * forever.
                         */
-                       if (OBD_FAIL_CHECK(OBD_FAIL_PTLRPC_LONG_REPL_UNLINK)) {
-                               OBD_FAIL_CHECK_ORSET(OBD_FAIL_PTLRPC_LONG_REPL_UNLINK,
-                                                    OBD_FAIL_ONCE);
+                       if (CFS_FAIL_CHECK(OBD_FAIL_PTLRPC_LONG_REPL_UNLINK)) {
+                               CFS_FAIL_CHECK_ORSET(OBD_FAIL_PTLRPC_LONG_REPL_UNLINK,
+                                                    CFS_FAIL_ONCE);
                        }
-                       if (OBD_FAIL_CHECK(OBD_FAIL_PTLRPC_LONG_BULK_UNLINK)) {
-                               OBD_FAIL_CHECK_ORSET(OBD_FAIL_PTLRPC_LONG_BULK_UNLINK,
-                                                    OBD_FAIL_ONCE);
+                       if (CFS_FAIL_CHECK(OBD_FAIL_PTLRPC_LONG_BULK_UNLINK)) {
+                               CFS_FAIL_CHECK_ORSET(OBD_FAIL_PTLRPC_LONG_BULK_UNLINK,
+                                                    CFS_FAIL_ONCE);
                        }
 
                        /*
@@ -2778,7 +2778,7 @@ static int ptlrpc_unregister_reply(struct ptlrpc_request *request, int async)
        LASSERT(!in_interrupt());
 
        /* Let's setup deadline for reply unlink. */
-       if (OBD_FAIL_CHECK(OBD_FAIL_PTLRPC_LONG_REPL_UNLINK) &&
+       if (CFS_FAIL_CHECK(OBD_FAIL_PTLRPC_LONG_REPL_UNLINK) &&
            async && request->rq_reply_deadline == 0 && cfs_fail_val == 0)
                request->rq_reply_deadline = ktime_get_real_seconds() +
                                             PTLRPC_REQ_LONG_UNLINK;

diff --git a/lustre/ptlrpc/gss/sec_gss.c b/lustre/ptlrpc/gss/sec_gss.c
index 8f84531..1ced073 100644 (file)
--- a/lustre/ptlrpc/gss/sec_gss.c
+++ b/lustre/ptlrpc/gss/sec_gss.c
@@ -1936,9 +1936,6 @@ int gss_pack_err_notify(struct ptlrpc_request *req, __u32 major, __u32 minor)
         int                        rc;
         ENTRY;
 
-        //if (OBD_FAIL_CHECK_ORSET(OBD_FAIL_SVCGSS_ERR_NOTIFY, OBD_FAIL_ONCE))
-        //      RETURN(-EINVAL);
-
         grctx->src_err_notify = 1;
         grctx->src_reserve_len = 0;
 

diff --git a/lustre/ptlrpc/import.c b/lustre/ptlrpc/import.c
index 82dd394..f327708 100644 (file)
--- a/lustre/ptlrpc/import.c
+++ b/lustre/ptlrpc/import.c
@@ -305,8 +305,8 @@ void ptlrpc_invalidate_import(struct obd_import *imp)
        if (!imp->imp_invalid || imp->imp_obd->obd_no_recov)
                ptlrpc_deactivate_import(imp);
 
-       if (OBD_FAIL_PRECHECK(OBD_FAIL_PTLRPC_CONNECT_RACE)) {
-               OBD_RACE(OBD_FAIL_PTLRPC_CONNECT_RACE);
+       if (CFS_FAIL_PRECHECK(OBD_FAIL_PTLRPC_CONNECT_RACE)) {
+               CFS_RACE(OBD_FAIL_PTLRPC_CONNECT_RACE);
                msleep(10 * MSEC_PER_SEC);
        }
        CFS_FAIL_TIMEOUT(OBD_FAIL_MGS_CONNECT_NET, 3 * cfs_fail_val / 2);
@@ -324,7 +324,7 @@ void ptlrpc_invalidate_import(struct obd_import *imp)
                 * out. Use obd_timeout if calculated value is smaller
                 * than it.
                 */
-               if (!OBD_FAIL_CHECK(OBD_FAIL_PTLRPC_LONG_REPL_UNLINK)) {
+               if (!CFS_FAIL_CHECK(OBD_FAIL_PTLRPC_LONG_REPL_UNLINK)) {
                        timeout = ptlrpc_inflight_timeout(imp);
                        timeout += div_u64(timeout, 3);
 
@@ -1474,7 +1474,7 @@ static int signal_completed_replay(struct obd_import *imp)
        struct ptlrpc_request *req;
        ENTRY;
 
-       if (unlikely(OBD_FAIL_CHECK(OBD_FAIL_PTLRPC_FINISH_REPLAY)))
+       if (unlikely(CFS_FAIL_CHECK(OBD_FAIL_PTLRPC_FINISH_REPLAY)))
                RETURN(0);
 
        if (!atomic_add_unless(&imp->imp_replay_inflight, 1, 1))
@@ -1876,12 +1876,12 @@ int ptlrpc_disconnect_and_idle_import(struct obd_import *imp)
 
        req->rq_interpret_reply = ptlrpc_disconnect_idle_interpret;
 
-       if (OBD_FAIL_PRECHECK(OBD_FAIL_PTLRPC_IDLE_RACE)) {
+       if (CFS_FAIL_PRECHECK(OBD_FAIL_PTLRPC_IDLE_RACE)) {
                __u32 idx;
 
                server_name2index(imp->imp_obd->obd_name, &idx, NULL);
                if (idx == 0)
-                       OBD_RACE(OBD_FAIL_PTLRPC_IDLE_RACE);
+                       CFS_RACE(OBD_FAIL_PTLRPC_IDLE_RACE);
        }
 
        spin_lock(&imp->imp_lock);

diff --git a/lustre/ptlrpc/llog_server.c b/lustre/ptlrpc/llog_server.c
index d19ea86..9b705a5 100644 (file)
--- a/lustre/ptlrpc/llog_server.c
+++ b/lustre/ptlrpc/llog_server.c
@@ -141,7 +141,7 @@ int llog_origin_handle_next_block(struct ptlrpc_request *req)
        ctxt = llog_get_context(req->rq_export->exp_obd, body->lgd_ctxt_idx);
        if (ctxt == NULL)
                RETURN(-ENODEV);
-       if (OBD_FAIL_PRECHECK(OBD_FAIL_MDS_LLOG_UMOUNT_RACE))
+       if (CFS_FAIL_PRECHECK(OBD_FAIL_MDS_LLOG_UMOUNT_RACE))
                cfs_fail_val = 1;
 
        rc = llog_open(req->rq_svc_thread->t_env, ctxt, &loghandle,

diff --git a/lustre/ptlrpc/niobuf.c b/lustre/ptlrpc/niobuf.c
index d1c3b1c..77c5c5c 100644 (file)
--- a/lustre/ptlrpc/niobuf.c
+++ b/lustre/ptlrpc/niobuf.c
@@ -69,8 +69,8 @@ static int ptl_send_buf(struct lnet_handle_md *mdh, void *base, int len,
                md.options |= LNET_MD_BULK_HANDLE;
        }
 
-       if (unlikely(ack == LNET_ACK_REQ &&
-                    OBD_FAIL_CHECK_ORSET(OBD_FAIL_PTLRPC_ACK, OBD_FAIL_ONCE))){
+       if (CFS_FAIL_CHECK_ORSET(OBD_FAIL_PTLRPC_ACK, CFS_FAIL_ONCE) &&
+           ack == LNET_ACK_REQ) {
                /* don't ask for the ack to simulate failing client */
                ack = LNET_NOACK_REQ;
        }
@@ -169,7 +169,7 @@ int ptlrpc_start_bulk_transfer(struct ptlrpc_bulk_desc *desc)
        struct lnet_md           md;
        ENTRY;
 
-       if (OBD_FAIL_CHECK(OBD_FAIL_PTLRPC_BULK_PUT_NET))
+       if (CFS_FAIL_CHECK(OBD_FAIL_PTLRPC_BULK_PUT_NET))
                RETURN(0);
 
        /* NB no locking required until desc is on the network */
@@ -223,7 +223,7 @@ int ptlrpc_start_bulk_transfer(struct ptlrpc_bulk_desc *desc)
 
                /* sanity.sh 224c: lets skip last md */
                if (posted_md == desc->bd_md_max_brw - 1)
-                       OBD_FAIL_CHECK_RESET(OBD_FAIL_PTLRPC_CLIENT_BULK_CB3,
+                       CFS_FAIL_CHECK_RESET(OBD_FAIL_PTLRPC_CLIENT_BULK_CB3,
                                             CFS_FAIL_PTLRPC_OST_BULK_CB2);
 
                /* Network is about to get at the memory */
@@ -324,8 +324,8 @@ int ptlrpc_register_bulk(struct ptlrpc_request *req)
        struct lnet_md md;
        ENTRY;
 
-        if (OBD_FAIL_CHECK(OBD_FAIL_PTLRPC_BULK_GET_NET))
-                RETURN(0);
+       if (CFS_FAIL_CHECK(OBD_FAIL_PTLRPC_BULK_GET_NET))
+               RETURN(0);
 
        /* NB no locking required until desc is on the network */
        LASSERT(desc->bd_nob > 0);
@@ -378,7 +378,7 @@ int ptlrpc_register_bulk(struct ptlrpc_request *req)
                ptlrpc_fill_bulk_md(&md, desc, posted_md);
 
                if (posted_md > 0 && posted_md + 1 == desc->bd_md_count &&
-                   OBD_FAIL_CHECK(OBD_FAIL_PTLRPC_BULK_ATTACH)) {
+                   CFS_FAIL_CHECK(OBD_FAIL_PTLRPC_BULK_ATTACH)) {
                        rc = -ENOMEM;
                } else {
                        me = LNetMEAttach(desc->bd_portal, &peer, mbits, 0,
@@ -451,7 +451,7 @@ int ptlrpc_unregister_bulk(struct ptlrpc_request *req, int async)
                desc->bd_registered = 0;
 
        /* Let's setup deadline for reply unlink. */
-       if (OBD_FAIL_CHECK(OBD_FAIL_PTLRPC_LONG_BULK_UNLINK) &&
+       if (CFS_FAIL_CHECK(OBD_FAIL_PTLRPC_LONG_BULK_UNLINK) &&
            async && req->rq_bulk_deadline == 0 && cfs_fail_val == 0)
                req->rq_bulk_deadline = ktime_get_real_seconds() +
                                        PTLRPC_REQ_LONG_UNLINK;
@@ -720,10 +720,10 @@ int ptl_send_rpc(struct ptlrpc_request *request, int noreply)
 
        LNetInvalidateMDHandle(&bulk_cookie);
 
-       if (OBD_FAIL_CHECK(OBD_FAIL_PTLRPC_DROP_RPC))
+       if (CFS_FAIL_CHECK(OBD_FAIL_PTLRPC_DROP_RPC))
                RETURN(0);
 
-       if (unlikely(OBD_FAIL_CHECK(OBD_FAIL_PTLRPC_DELAY_RECOV) &&
+       if (unlikely(CFS_FAIL_CHECK(OBD_FAIL_PTLRPC_DELAY_RECOV) &&
                     lustre_msg_get_opc(request->rq_reqmsg) == MDS_CONNECT &&
                     strcmp(obd->obd_type->typ_name, LUSTRE_OSP_NAME) == 0)) {
                RETURN(0);
@@ -860,7 +860,7 @@ int ptl_send_rpc(struct ptlrpc_request *request, int noreply)
 
                peer = connection->c_peer;
                if (request->rq_bulk &&
-                   OBD_FAIL_CHECK(OBD_FAIL_PTLRPC_BULK_REPLY_ATTACH)) {
+                   CFS_FAIL_CHECK(OBD_FAIL_PTLRPC_BULK_REPLY_ATTACH)) {
                        reply_me = ERR_PTR(-ENOMEM);
                } else {
                        reply_me = LNetMEAttach(request->rq_reply_portal,
@@ -932,7 +932,7 @@ int ptl_send_rpc(struct ptlrpc_request *request, int noreply)
                lprocfs_counter_add(obd->obd_svc_stats, PTLRPC_REQACTIVE_CNTR,
                                    atomic_read(&imp->imp_inflight));
 
-       OBD_FAIL_TIMEOUT(OBD_FAIL_PTLRPC_DELAY_SEND, request->rq_timeout + 5);
+       CFS_FAIL_TIMEOUT(OBD_FAIL_PTLRPC_DELAY_SEND, request->rq_timeout + 5);
 
        request->rq_sent_ns = ktime_get_real();
        request->rq_sent = ktime_get_real_seconds();
@@ -943,7 +943,7 @@ int ptl_send_rpc(struct ptlrpc_request *request, int noreply)
                ptlrpc_at_get_net_latency(request);
 
        if (unlikely(opc == OBD_PING &&
-           OBD_FAIL_TIMEOUT(OBD_FAIL_PTLRPC_DELAY_SEND_FAIL, cfs_fail_val)))
+           CFS_FAIL_TIMEOUT(OBD_FAIL_PTLRPC_DELAY_SEND_FAIL, cfs_fail_val)))
                GOTO(skip_send, rc);
 
        DEBUG_REQ(D_INFO, request, "send flags=%x",
@@ -1004,7 +1004,7 @@ int ptlrpc_register_rqbd(struct ptlrpc_request_buffer_desc *rqbd)
        CDEBUG(D_NET, "%s: registering portal %d\n", service->srv_name,
               service->srv_req_portal);
 
-       if (OBD_FAIL_CHECK(OBD_FAIL_PTLRPC_RQBD))
+       if (CFS_FAIL_CHECK(OBD_FAIL_PTLRPC_RQBD))
                return -ENOMEM;
 
        /* NB: CPT affinity service should use new LNet flag LNET_INS_LOCAL,

diff --git a/lustre/ptlrpc/nodemap_storage.c b/lustre/ptlrpc/nodemap_storage.c
index 48f305f..f06ee82 100644 (file)
--- a/lustre/ptlrpc/nodemap_storage.c
+++ b/lustre/ptlrpc/nodemap_storage.c
@@ -1504,7 +1504,7 @@ static int nodemap_page_build(const struct lu_env *env, struct dt_object *obj,
                hash = iops->store(env, it);
                ii->ii_hash_end = hash;
 
-               if (OBD_FAIL_CHECK(OBD_FAIL_OBD_IDX_READ_BREAK)) {
+               if (CFS_FAIL_CHECK(OBD_FAIL_OBD_IDX_READ_BREAK)) {
                        if (lip->lip_nr != 0)
                                GOTO(out, rc = 0);
                }

diff --git a/lustre/ptlrpc/pinger.c b/lustre/ptlrpc/pinger.c
index 72825b2..861b65c 100644 (file)
--- a/lustre/ptlrpc/pinger.c
+++ b/lustre/ptlrpc/pinger.c
@@ -168,7 +168,7 @@ void ptlrpc_ping_import_soon(struct obd_import *imp)
 static inline int imp_is_deactive(struct obd_import *imp)
 {
        return imp->imp_deactive ||
-              OBD_FAIL_CHECK(OBD_FAIL_PTLRPC_IMP_DEACTIVE);
+              CFS_FAIL_CHECK(OBD_FAIL_PTLRPC_IMP_DEACTIVE);
 }
 
 static inline time64_t ptlrpc_next_reconnect(struct obd_import *imp)

diff --git a/lustre/ptlrpc/ptlrpcd.c b/lustre/ptlrpc/ptlrpcd.c
index 35f7e08..3b90bce 100644 (file)
--- a/lustre/ptlrpc/ptlrpcd.c
+++ b/lustre/ptlrpc/ptlrpcd.c
@@ -57,7 +57,7 @@
 #include <lustre_lib.h>
 #include <lustre_ha.h>
 #include <obd_class.h>   /* for obd_zombie */
-#include <obd_support.h> /* for OBD_FAIL_CHECK */
+#include <obd_support.h>
 #include <cl_object.h> /* cl_env_{get,put}() */
 #include <lprocfs_status.h>
 

diff --git a/lustre/ptlrpc/recover.c b/lustre/ptlrpc/recover.c
index c44b56c..d9ab8fc 100644 (file)
--- a/lustre/ptlrpc/recover.c
+++ b/lustre/ptlrpc/recover.c
@@ -201,7 +201,7 @@ int ptlrpc_resend(struct obd_import *imp)
        }
        spin_unlock(&imp->imp_lock);
 
-       OBD_FAIL_TIMEOUT(OBD_FAIL_LDLM_ENQUEUE_OLD_EXPORT, 2);
+       CFS_FAIL_TIMEOUT(OBD_FAIL_LDLM_ENQUEUE_OLD_EXPORT, 2);
        RETURN(0);
 }
 
@@ -333,7 +333,7 @@ int ptlrpc_recover_import(struct obd_import *imp, char *new_uuid, int async)
        if (rc)
                GOTO(out, rc);
 
-       OBD_RACE(OBD_FAIL_PTLRPC_CONNECT_RACE);
+       CFS_RACE(OBD_FAIL_PTLRPC_CONNECT_RACE);
 
        rc = ptlrpc_connect_import(imp);
        if (rc)

diff --git a/lustre/ptlrpc/sec_plain.c b/lustre/ptlrpc/sec_plain.c
index 7cf3a2c..8b7dc45 100644 (file)
--- a/lustre/ptlrpc/sec_plain.c
+++ b/lustre/ptlrpc/sec_plain.c
@@ -316,7 +316,7 @@ int plain_cli_wrap_bulk(struct ptlrpc_cli_ctx *ctx,
                 * for sending we only compute the wrong checksum instead
                 * of corrupting the data so it is still correct on a redo
                 */
-               if (OBD_FAIL_CHECK(OBD_FAIL_OSC_CHECKSUM_SEND) &&
+               if (CFS_FAIL_CHECK(OBD_FAIL_OSC_CHECKSUM_SEND) &&
                    req->rq_flvr.u_bulk.hash.hash_alg != BULK_HASH_ALG_NULL)
                        token->pbt_hash[0] ^= 0x1;
        }
@@ -960,7 +960,7 @@ int plain_svc_wrap_bulk(struct ptlrpc_request *req,
                CERROR("bulk read: server failed to compute checksum: %d\n",
                       rc);
        } else {
-               if (OBD_FAIL_CHECK(OBD_FAIL_OSC_CHECKSUM_RECEIVE))
+               if (CFS_FAIL_CHECK(OBD_FAIL_OSC_CHECKSUM_RECEIVE))
                        corrupt_bulk_data(desc);
        }
 

diff --git a/lustre/ptlrpc/service.c b/lustre/ptlrpc/service.c
index b0a6471..50a356e 100644 (file)
--- a/lustre/ptlrpc/service.c
+++ b/lustre/ptlrpc/service.c
@@ -1842,10 +1842,10 @@ static int ptlrpc_server_request_add(struct ptlrpc_service_part *svcpt,
                ptlrpc_server_mark_in_progress_obsolete(req);
 #endif
                orig = ptlrpc_server_check_resend_in_progress(req);
-               if (orig && OBD_FAIL_PRECHECK(OBD_FAIL_PTLRPC_RESEND_RACE)) {
+               if (orig && CFS_FAIL_PRECHECK(OBD_FAIL_PTLRPC_RESEND_RACE)) {
                        spin_unlock_bh(&exp->exp_rpc_lock);
 
-                       OBD_RACE(OBD_FAIL_PTLRPC_RESEND_RACE);
+                       CFS_RACE(OBD_FAIL_PTLRPC_RESEND_RACE);
                        msleep(4 * MSEC_PER_SEC);
                        continue;
                }
@@ -2120,7 +2120,7 @@ static int ptlrpc_server_handle_req_in(struct ptlrpc_service_part *svcpt,
        }
 
        opc = lustre_msg_get_opc(req->rq_reqmsg);
-       if (OBD_FAIL_CHECK(OBD_FAIL_PTLRPC_DROP_REQ_OPC) &&
+       if (CFS_FAIL_CHECK(OBD_FAIL_PTLRPC_DROP_REQ_OPC) &&
            opc == cfs_fail_val) {
                CERROR("drop incoming rpc opc %u, x%llu\n",
                       cfs_fail_val, req->rq_xid);
@@ -2185,7 +2185,7 @@ static int ptlrpc_server_handle_req_in(struct ptlrpc_service_part *svcpt,
        }
 
        /* Skip early reply */
-       if (OBD_FAIL_PRECHECK(OBD_FAIL_MDS_RESEND))
+       if (CFS_FAIL_PRECHECK(OBD_FAIL_MDS_RESEND))
                req->rq_deadline += obd_timeout;
 
        req->rq_svc_thread = thread;
@@ -2207,10 +2207,10 @@ static int ptlrpc_server_handle_req_in(struct ptlrpc_service_part *svcpt,
        }
 
 
-       if (unlikely(OBD_FAIL_PRECHECK(OBD_FAIL_PTLRPC_ENQ_RESEND) &&
+       if (unlikely(CFS_FAIL_PRECHECK(OBD_FAIL_PTLRPC_ENQ_RESEND) &&
                     (opc == LDLM_ENQUEUE) &&
                     (lustre_msg_get_flags(req->rq_reqmsg) & MSG_RESENT)))
-               OBD_FAIL_TIMEOUT(OBD_FAIL_PTLRPC_ENQ_RESEND, 6);
+               CFS_FAIL_TIMEOUT(OBD_FAIL_PTLRPC_ENQ_RESEND, 6);
 
        ptlrpc_at_add_timed(req);
 
@@ -2256,19 +2256,19 @@ static int ptlrpc_server_handle_request(struct ptlrpc_service_part *svcpt,
        if (request == NULL)
                RETURN(0);
 
-       if (OBD_FAIL_CHECK(OBD_FAIL_PTLRPC_HPREQ_NOTIMEOUT))
+       if (CFS_FAIL_CHECK(OBD_FAIL_PTLRPC_HPREQ_NOTIMEOUT))
                fail_opc = OBD_FAIL_PTLRPC_HPREQ_NOTIMEOUT;
-       else if (OBD_FAIL_CHECK(OBD_FAIL_PTLRPC_HPREQ_TIMEOUT))
+       else if (CFS_FAIL_CHECK(OBD_FAIL_PTLRPC_HPREQ_TIMEOUT))
                fail_opc = OBD_FAIL_PTLRPC_HPREQ_TIMEOUT;
 
        if (unlikely(fail_opc)) {
                if (request->rq_export && request->rq_ops)
-                       OBD_FAIL_TIMEOUT(fail_opc, 4);
+                       CFS_FAIL_TIMEOUT(fail_opc, 4);
        }
 
        ptlrpc_rqphase_move(request, RQ_PHASE_INTERPRET);
 
-       if (OBD_FAIL_CHECK(OBD_FAIL_PTLRPC_DUMP_LOG))
+       if (CFS_FAIL_CHECK(OBD_FAIL_PTLRPC_DUMP_LOG))
                libcfs_debug_dumplog();
 
        work_start = ktime_get_real();
@@ -3212,7 +3212,7 @@ static int ptlrpc_start_thread(struct ptlrpc_service_part *svcpt, int wait)
                RETURN(-ESRCH);
 
        if (!ptlrpc_threads_increasable(svcpt) ||
-           (OBD_FAIL_CHECK(OBD_FAIL_TGT_TOOMANY_THREADS) &&
+           (CFS_FAIL_CHECK(OBD_FAIL_TGT_TOOMANY_THREADS) &&
             svcpt->scp_nthrs_running == svc->srv_nthrs_cpt_init - 1))
                RETURN(-EMFILE);