ldlm_lock_addref(lockh, mode);
/* Let cl_lock_state_wait fail with -ERESTARTSYS to unuse sublocks. */
- OBD_FAIL_TIMEOUT(OBD_FAIL_LDLM_ENQUEUE_HANG, 2);
+ CFS_FAIL_TIMEOUT(OBD_FAIL_LDLM_ENQUEUE_HANG, 2);
/* Let CP AST to grant the lock first. */
- OBD_FAIL_TIMEOUT(OBD_FAIL_OSC_CP_ENQ_RACE, 1);
+ CFS_FAIL_TIMEOUT(OBD_FAIL_OSC_CP_ENQ_RACE, 1);
/* Complete obtaining the lock procedure. */
rc = ldlm_cli_enqueue_fini(aa->oa_exp, &req->rq_pill, &einfo, 1,
rc = mdc_enqueue_fini(aa->oa_exp, req, aa->oa_upcall, aa->oa_cookie,
lockh, mode, aa->oa_flags, rc);
- OBD_FAIL_TIMEOUT(OBD_FAIL_OSC_CP_CANCEL_RACE, 10);
+ CFS_FAIL_TIMEOUT(OBD_FAIL_OSC_CP_CANCEL_RACE, 10);
ldlm_lock_decref(lockh, mode);
LDLM_LOCK_PUT(lock);
matched = ldlm_handle2lock(&lockh);
- if (OBD_FAIL_CHECK(OBD_FAIL_MDC_GLIMPSE_DDOS))
+ if (CFS_FAIL_CHECK(OBD_FAIL_MDC_GLIMPSE_DDOS))
ldlm_set_kms_ignore(matched);
if (mdc_set_dom_lock_data(matched, einfo->ei_cbdata)) {
/* balanced in ll_file_open */
ptlrpc_request_addref(request);
/* eviction in middle of open RPC processing b=11546 */
- OBD_FAIL_TIMEOUT(OBD_FAIL_MDC_ENQUEUE_PAUSE,
+ CFS_FAIL_TIMEOUT(OBD_FAIL_MDC_ENQUEUE_PAUSE,
obd_timeout);
}
__u64 flags = LDLM_FL_HAS_INTENT;
ENTRY;
- if (OBD_FAIL_CHECK(OBD_FAIL_MDC_GETATTR_ENQUEUE))
+ if (CFS_FAIL_CHECK(OBD_FAIL_MDC_GETATTR_ENQUEUE))
rc = -ETIMEDOUT;
rc = ldlm_cli_enqueue_fini(exp, pill, einfo, 1, &flags, NULL, 0,
}
*request = NULL;
- if (OBD_FAIL_CHECK(OBD_FAIL_MDC_CLOSE))
+ if (CFS_FAIL_CHECK(OBD_FAIL_MDC_CLOSE))
req = NULL;
else
req = ptlrpc_request_alloc(class_exp2cliimp(exp), req_fmt);
/* records are in order, so we're done */
RETURN(LLOG_PROC_BREAK);
- if (unlikely(OBD_FAIL_PRECHECK(OBD_FAIL_MDS_CHANGELOG_RACE))) {
+ if (unlikely(CFS_FAIL_PRECHECK(OBD_FAIL_MDS_CHANGELOG_RACE))) {
if (cfs_fail_val == 0)
cfs_fail_val = hdr->lrh_index;
if (cfs_fail_val == hdr->lrh_index)
- OBD_RACE(OBD_FAIL_MDS_CHANGELOG_RACE);
+ CFS_RACE(OBD_FAIL_MDS_CHANGELOG_RACE);
}
/* Records folow one by one, cr_index++. We could calculate the
cl_cookie->endrec)) {
int rc;
- if (unlikely(OBD_FAIL_PRECHECK(OBD_FAIL_MDS_CHANGELOG_DEL))) {
+ if (unlikely(CFS_FAIL_PRECHECK(OBD_FAIL_MDS_CHANGELOG_DEL))) {
if (cfs_fail_val == 0) {
cfs_fail_val = (unsigned long)llh & 0xFFFFFFFF;
- OBD_RACE(OBD_FAIL_MDS_CHANGELOG_DEL);
+ CFS_RACE(OBD_FAIL_MDS_CHANGELOG_DEL);
}
}
rc = llog_destroy(env, llh);
ENTRY;
/* LU-2844 mdd setup failure should not cause umount oops */
- if (OBD_FAIL_CHECK(OBD_FAIL_MDS_CHANGELOG_INIT))
+ if (CFS_FAIL_CHECK(OBD_FAIL_MDS_CHANGELOG_INIT))
RETURN(-EIO);
OBD_SET_CTXT_MAGIC(&obd->obd_lvfs_ctxt);
spin_unlock(&mdd->mdd_cl.mc_user_lock);
rec->cur_time = (__u32)ktime_get_real_seconds();
- if (OBD_FAIL_PRECHECK(OBD_FAIL_TIME_IN_CHLOG_USER)) {
+ if (CFS_FAIL_PRECHECK(OBD_FAIL_TIME_IN_CHLOG_USER)) {
rec->cur_time -= min(cfs_fail_val, rec->cur_time);
spin_lock(&mdd->mdd_cl.mc_user_lock);
mdd->mdd_cl.mc_mintime = rec->cur_time;
GOTO(out, rc);
}
- OBD_FAIL_TIMEOUT(OBD_FAIL_LLOG_PURGE_DELAY, cfs_fail_val);
+ CFS_FAIL_TIMEOUT(OBD_FAIL_LLOG_PURGE_DELAY, cfs_fail_val);
if (mcup.mcup_usercount == 0) {
spin_lock(&mdd->mdd_cl.mc_user_lock);
if (mdd->mdd_cl.mc_users == 0) {
* if changelog consumes more than 1/4 of available space then start
* emergency cleanup.
*/
- if (OBD_FAIL_CHECK(OBD_FAIL_MDS_CHANGELOG_ENOSPC))
+ if (CFS_FAIL_CHECK(OBD_FAIL_MDS_CHANGELOG_ENOSPC))
free_space_limit = cfs_fail_val;
else
free_space_limit = (sfs.os_bfree * sfs.os_bsize) >> 2;
return mdd_changelog_emrg_cleanup(env, mdd, lgh) ||
mdd_changelog_is_too_idle(mdd, mc->mc_minrec, mc->mc_mintime) ||
- OBD_FAIL_CHECK(OBD_FAIL_FORCE_GC_THREAD);
+ CFS_FAIL_CHECK(OBD_FAIL_FORCE_GC_THREAD);
}
/** Add a changelog entry \a rec to the changelog llog
if (IS_ERR(llog_th))
GOTO(out_put, rc = PTR_ERR(llog_th));
- OBD_FAIL_TIMEOUT(OBD_FAIL_MDS_CHANGELOG_REORDER, cfs_fail_val);
+ CFS_FAIL_TIMEOUT(OBD_FAIL_MDS_CHANGELOG_REORDER, cfs_fail_val);
/* nested journal transaction */
rc = llog_add(env, ctxt->loc_handle, &rec->cr_hdr, NULL, llog_th);
/* save a spin_lock trip */
goto out_put;
- if (OBD_FAIL_PRECHECK(OBD_FAIL_MDS_CHANGELOG_IDX_PUMP)) {
+ if (CFS_FAIL_PRECHECK(OBD_FAIL_MDS_CHANGELOG_IDX_PUMP)) {
spin_lock(&mdd->mdd_cl.mc_lock);
mdd->mdd_cl.mc_index += cfs_fail_val;
spin_unlock(&mdd->mdd_cl.mc_lock);
if (unlikely(need_gc)) {
CWARN("%s:%s starting changelog garbage collection\n",
obd->obd_name,
- OBD_FAIL_CHECK(OBD_FAIL_FORCE_GC_THREAD) ?
+ CFS_FAIL_CHECK(OBD_FAIL_FORCE_GC_THREAD) ?
" simulate" : "");
/* indicate further kthread run will occur outside
* right after current journal transaction filling has
return -EEXIST;
}
- if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_LINKEA_MORE)) {
+ if (CFS_FAIL_CHECK(OBD_FAIL_LFSCK_LINKEA_MORE)) {
struct lu_fid *tfid = &mdd_env_info(env)->mdi_fid2;
*tfid = *pfid;
linkea_add_buf(ldata, lname, tfid, false);
}
- if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_LINKEA_MORE2))
+ if (CFS_FAIL_CHECK(OBD_FAIL_LFSCK_LINKEA_MORE2))
linkea_add_buf(ldata, lname, pfid, false);
/* For encrypted file, we want to limit number of hard links to what
int rc = 0;
ENTRY;
- if (OBD_FAIL_CHECK(OBD_FAIL_FID_IGIF))
+ if (CFS_FAIL_CHECK(OBD_FAIL_FID_IGIF))
RETURN(0);
LASSERT(oldpfid != NULL || newpfid != NULL);
ldata->ld_leh == NULL)
return 0;
- if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_NO_LINKEA))
+ if (CFS_FAIL_CHECK(OBD_FAIL_LFSCK_NO_LINKEA))
return 0;
again:
struct lu_fid tfid = *mdd_object_fid(c);
int rc;
- if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_DANGLING3))
+ if (CFS_FAIL_CHECK(OBD_FAIL_LFSCK_DANGLING3))
tfid.f_oid = cfs_fail_val;
rc = mdo_declare_index_insert(env, p, &tfid, mdd_object_type(c),
if (rc)
GOTO(out_unlock, rc);
- if (!OBD_FAIL_CHECK(OBD_FAIL_LFSCK_LESS_NLINK)) {
+ if (!CFS_FAIL_CHECK(OBD_FAIL_LFSCK_LESS_NLINK)) {
rc = mdo_ref_add(env, mdd_sobj, handle);
if (rc != 0)
GOTO(out_unlock, rc);
}
*tfid = *mdd_object_fid(mdd_sobj);
- if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_DANGLING3))
+ if (CFS_FAIL_CHECK(OBD_FAIL_LFSCK_DANGLING3))
tfid->f_oid = cfs_fail_val;
rc = __mdd_index_insert_only(env, mdd_tobj, tfid,
struct lu_attr *la = &mdd_env_info(env)->mdi_la_for_fix;
int rc;
- if (!OBD_FAIL_CHECK(OBD_FAIL_LFSCK_DANGLING2)) {
+ if (!CFS_FAIL_CHECK(OBD_FAIL_LFSCK_DANGLING2)) {
if (likely(no_name == 0)) {
rc = mdo_declare_index_delete(env, p, name->ln_name,
handle);
name[lname->ln_namelen] = '\0';
}
- if (likely(no_name == 0) && !OBD_FAIL_CHECK(OBD_FAIL_LFSCK_DANGLING2)) {
+ if (likely(no_name == 0) && !CFS_FAIL_CHECK(OBD_FAIL_LFSCK_DANGLING2)) {
rc = __mdd_index_delete(env, mdd_pobj, name, is_dir, handle);
if (rc)
GOTO(cleanup, rc);
}
- if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_MUL_REF) ||
- OBD_FAIL_CHECK(OBD_FAIL_LFSCK_NO_NAMEENTRY))
+ if (CFS_FAIL_CHECK(OBD_FAIL_LFSCK_MUL_REF) ||
+ CFS_FAIL_CHECK(OBD_FAIL_LFSCK_NO_NAMEENTRY))
GOTO(cleanup, rc = 0);
if (likely(mdd_cobj != NULL)) {
if (rc)
RETURN(rc);
- if (OBD_FAIL_CHECK(OBD_FAIL_MDS_DQACQ_NET))
+ if (CFS_FAIL_CHECK(OBD_FAIL_MDS_DQACQ_NET))
GOTO(out_free, rc = -EINPROGRESS);
handle = mdd_trans_create(env, mdd);
mdd_object_make_hint(env, mdd_pobj, son, attr, spec, hint);
memset(ldata, 0, sizeof(*ldata));
- if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_BAD_PARENT)) {
+ if (CFS_FAIL_CHECK(OBD_FAIL_LFSCK_BAD_PARENT)) {
struct lu_fid tfid = *mdd_object_fid(mdd_pobj);
tfid.f_oid--;
if (rc != 0)
GOTO(unlock, rc);
- if (unlikely(OBD_FAIL_CHECK(OBD_FAIL_MDS_HSM_SWAP_LAYOUTS))) {
+ if (unlikely(CFS_FAIL_CHECK(OBD_FAIL_MDS_HSM_SWAP_LAYOUTS))) {
rc = -EOPNOTSUPP;
} else {
if (fst_buf->lb_buf != NULL)
recsize = lu_dirent_calc_size(len, attr);
if (bytes >= recsize &&
- !OBD_FAIL_CHECK(OBD_FAIL_MDS_DIR_PAGE_WALK)) {
+ !CFS_FAIL_CHECK(OBD_FAIL_MDS_DIR_PAGE_WALK)) {
result = iops->rec(env, it, (struct dt_rec *)ent, attr);
if (result == -ESTALE)
GOTO(next, result);
key = mdd_orphan_key_fill(env, mdd_object_fid(obj));
dt_write_lock(env, mdd->mdd_orphans, DT_TGT_ORPHAN);
- if (OBD_FAIL_CHECK(OBD_FAIL_MDS_ORPHAN_DELETE))
+ if (CFS_FAIL_CHECK(OBD_FAIL_MDS_ORPHAN_DELETE))
goto ref_del;
rc = dt_delete(env, mdd->mdd_orphans, key, th);
if (rc)
GOTO(out, rc = err_serious(rc));
- if (OBD_FAIL_CHECK(OBD_FAIL_MDS_GET_ROOT_PACK))
+ if (CFS_FAIL_CHECK(OBD_FAIL_MDS_GET_ROOT_PACK))
GOTO(out, rc = err_serious(-ENOMEM));
repbody = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY);
svcpt = req->rq_rqbd->rqbd_svcpt;
/* This will trigger a watchdog timeout */
- OBD_FAIL_TIMEOUT(OBD_FAIL_MDS_STATFS_LCW_SLEEP,
+ CFS_FAIL_TIMEOUT(OBD_FAIL_MDS_STATFS_LCW_SLEEP,
(MDT_SERVICE_WATCHDOG_FACTOR *
at_get(&svcpt->scp_at_estimate)) + 1);
if (rc)
GOTO(out, rc = err_serious(rc));
- if (OBD_FAIL_CHECK(OBD_FAIL_MDS_STATFS_PACK))
+ if (CFS_FAIL_CHECK(OBD_FAIL_MDS_STATFS_PACK))
GOTO(out, rc = err_serious(-ENOMEM));
osfs = req_capsule_server_get(info->mti_pill, &RMF_OBD_STATFS);
ENTRY;
- if (OBD_FAIL_CHECK(OBD_FAIL_MDS_GETATTR_PACK))
+ if (CFS_FAIL_CHECK(OBD_FAIL_MDS_GETATTR_PACK))
RETURN(err_serious(-ENOMEM));
repbody = req_capsule_server_get(pill, &RMF_MDT_BODY);
} else {
int print_limit = min_t(int, PAGE_SIZE - 128, rc);
- if (OBD_FAIL_CHECK(OBD_FAIL_MDS_READLINK_EPROTO))
+ if (CFS_FAIL_CHECK(OBD_FAIL_MDS_READLINK_EPROTO))
rc -= 2;
repbody->mbo_valid |= OBD_MD_LINKNAME;
/* we need to report back size with NULL-terminator
}
}
- OBD_FAIL_TIMEOUT(OBD_FAIL_MDS_RESEND, obd_timeout * 2);
+ CFS_FAIL_TIMEOUT(OBD_FAIL_MDS_RESEND, obd_timeout * 2);
if (!mdt_object_exists(child)) {
LU_OBJECT_DEBUG(D_INODE, info->mti_env,
&child->mot_obj,
LASSERT(!(child_bits & MDS_INODELOCK_LAYOUT));
if (S_ISREG(lu_object_attr(&child->mot_obj)) &&
!mdt_object_remote(child) && ldlm_rep != NULL) {
- if (!OBD_FAIL_CHECK(OBD_FAIL_MDS_NO_LL_GETATTR) &&
+ if (!CFS_FAIL_CHECK(OBD_FAIL_MDS_NO_LL_GETATTR) &&
exp_connect_layout(info->mti_exp)) {
/* try to grant layout lock for regular file. */
try_bits = MDS_INODELOCK_LAYOUT;
PLDLMRES(lock->l_resource),
PFID(mdt_object_fid(child)));
- if (unlikely(OBD_FAIL_PRECHECK(OBD_FAIL_PTLRPC_ENQ_RESEND))) {
+ if (unlikely(CFS_FAIL_PRECHECK(OBD_FAIL_PTLRPC_ENQ_RESEND))) {
if (!(lustre_msg_get_flags(req->rq_reqmsg) & MSG_RESENT))
- OBD_FAIL_TIMEOUT(OBD_FAIL_PTLRPC_ENQ_RESEND,
+ CFS_FAIL_TIMEOUT(OBD_FAIL_PTLRPC_ENQ_RESEND,
req->rq_deadline -
req->rq_arrival_time.tv_sec +
cfs_fail_val ?: 3);
ENTRY;
- if (OBD_FAIL_CHECK(OBD_FAIL_MDS_READPAGE_PACK))
+ if (CFS_FAIL_CHECK(OBD_FAIL_MDS_READPAGE_PACK))
RETURN(err_serious(-ENOMEM));
repbody = req_capsule_server_get(tsi->tsi_pill, &RMF_MDT_BODY);
__free_page(rdpg->rp_pages[i]);
OBD_FREE_PTR_ARRAY_LARGE(rdpg->rp_pages, rdpg->rp_npages);
- if (OBD_FAIL_CHECK(OBD_FAIL_MDS_SENDPAGE))
+ if (CFS_FAIL_CHECK(OBD_FAIL_MDS_SENDPAGE))
RETURN(0);
return rc;
repbody->mbo_aclsize = 0;
}
- OBD_FAIL_TIMEOUT(OBD_FAIL_MDS_REINT_DELAY, 10);
+ CFS_FAIL_TIMEOUT(OBD_FAIL_MDS_REINT_DELAY, 10);
/* for replay no cookkie / lmm need, because client have this already */
if (info->mti_spec.no_create)
ENTRY;
- if (OBD_FAIL_CHECK(OBD_FAIL_MDS_SYNC_PACK))
+ if (CFS_FAIL_CHECK(OBD_FAIL_MDS_SYNC_PACK))
RETURN(err_serious(-ENOMEM));
if (fid_seq(&tsi->tsi_mdt_body->mbo_fid1) == 0) {
policy, res_id, dlmflags, cookie);
if (rc)
mdt_object_unlock(info, obj, lh, 1);
- else if (OBD_FAIL_PRECHECK(OBD_FAIL_MDS_PDO_LOCK) &&
+ else if (CFS_FAIL_PRECHECK(OBD_FAIL_MDS_PDO_LOCK) &&
lh->mlh_pdo_hash != 0 &&
(lh->mlh_reg_mode == LCK_PW || lh->mlh_reg_mode == LCK_EX))
- OBD_FAIL_TIMEOUT(OBD_FAIL_MDS_PDO_LOCK, 15);
+ CFS_FAIL_TIMEOUT(OBD_FAIL_MDS_PDO_LOCK, 15);
return rc;
}
static int mdt_tgt_connect(struct tgt_session_info *tsi)
{
- if (OBD_FAIL_CHECK(OBD_FAIL_TGT_DELAY_CONDITIONAL) &&
+ if (CFS_FAIL_CHECK(OBD_FAIL_TGT_DELAY_CONDITIONAL) &&
cfs_fail_val ==
tsi2mdt_info(tsi)->mti_mdt->mdt_seq_site.ss_node_id)
schedule_timeout_uninterruptible(cfs_time_seconds(3));
ldlm_rep = req_capsule_server_get(info->mti_pill, &RMF_DLM_REP);
if (ldlm_rep == NULL ||
- OBD_FAIL_CHECK(OBD_FAIL_MDS_XATTR_REP)) {
+ CFS_FAIL_CHECK(OBD_FAIL_MDS_XATTR_REP)) {
mdt_object_unlock(info, info->mti_object, lhc, 1);
if (is_serious(rc))
RETURN(rc);
if (it_handler_flags & IS_MUTABLE && mdt_rdonly(req->rq_export))
RETURN(-EROFS);
- OBD_FAIL_TIMEOUT(OBD_FAIL_MDS_INTENT_DELAY, 10);
+ CFS_FAIL_TIMEOUT(OBD_FAIL_MDS_INTENT_DELAY, 10);
/* execute policy */
rc = (*it_handler)(it_opc, info, lockp, flags);
mdt->mdt_qmt_dev = obd->obd_lu_dev;
/* configure local quota objects */
- if (OBD_FAIL_CHECK(OBD_FAIL_QUOTA_INIT))
+ if (CFS_FAIL_CHECK(OBD_FAIL_QUOTA_INIT))
rc = -EBADF;
else
rc = mdt->mdt_qmt_dev->ld_ops->ldo_prepare(env,
else
m->mdt_brw_size = ONE_MB_BRW_SIZE;
- if (OBD_FAIL_CHECK(OBD_FAIL_MDS_FS_SETUP))
+ if (CFS_FAIL_CHECK(OBD_FAIL_MDS_FS_SETUP))
GOTO(err_tgt, rc = -ENOENT);
fid.f_seq = FID_SEQ_LOCAL_NAME;
GOTO(out, rc = -EPROTO);
/* LU-15132 */
- OBD_RACE(OBD_FAIL_MDS_HSM_RESTORE_RACE);
+ CFS_RACE(OBD_FAIL_MDS_HSM_RESTORE_RACE);
rc = cdt_restore_handle_add(mti, cdt, &hai->hai_fid,
&hai->hai_extent);
* ldlm_resource_clean and protections may not work.
* See LU-9266 and sanity-hsm_407 for details.
*/
- OBD_FAIL_TIMEOUT(OBD_FAIL_MDS_HSM_CDT_DELAY, cfs_fail_val);
+ CFS_FAIL_TIMEOUT(OBD_FAIL_MDS_HSM_CDT_DELAY, cfs_fail_val);
/* record request */
rc = mdt_agent_record_add(mti->mti_env, mdt, archive_id, flags,
hai);
static inline int mdt_fail_write(const struct lu_env *env,
struct dt_device *dd, int id)
{
- if (OBD_FAIL_CHECK_ORSET(id, OBD_FAIL_ONCE)) {
+ if (CFS_FAIL_CHECK_ORSET(id, CFS_FAIL_ONCE)) {
CERROR(LUSTRE_MDT_NAME": cfs_fail_loc=%x, fail write ops\n",
id);
return dt_ro(env, dd);
}
}
- if (OBD_FAIL_CHECK(OBD_FAIL_OST_DQACQ_NET))
+ if (CFS_FAIL_CHECK(OBD_FAIL_OST_DQACQ_NET))
GOTO(out_stop, rc = -EINPROGRESS);
rc = dt_declare_write_commit(env, dob, lnb, niocount, th);
* pre-2.4 servers where a very strange reply is sent on error
* that looks like it was actually almost successful and a
* failure at the same time.) */
- if (OBD_FAIL_CHECK(OBD_FAIL_MDS_NEGATIVE_POSITIVE)) {
+ if (CFS_FAIL_CHECK(OBD_FAIL_MDS_NEGATIVE_POSITIVE)) {
mdt_set_disposition(info, rep, DISP_OPEN_OPEN |
DISP_LOOKUP_NEG |
DISP_LOOKUP_POS);
} else if (open_flags & MDS_OPEN_DIRECTORY)
RETURN(-ENOTDIR);
- if (OBD_FAIL_CHECK_RESET(OBD_FAIL_MDS_OPEN_CREATE,
- OBD_FAIL_MDS_LDLM_REPLY_NET | OBD_FAIL_ONCE))
+ if (CFS_FAIL_CHECK_RESET(OBD_FAIL_MDS_OPEN_CREATE,
+ OBD_FAIL_MDS_LDLM_REPLY_NET | CFS_FAIL_ONCE))
RETURN(-EAGAIN);
mfd = NULL;
* there should not be any downsides from doing it for normal
* operations now.
*/
- if (!OBD_FAIL_CHECK(OBD_FAIL_MDS_NO_LL_OPEN) && try_layout) {
+ if (!CFS_FAIL_CHECK(OBD_FAIL_MDS_NO_LL_OPEN) && try_layout) {
if (!(*ibits & MDS_INODELOCK_LOOKUP))
trybits |= MDS_INODELOCK_LOOKUP;
trybits |= MDS_INODELOCK_LAYOUT;
rc = mdt_object_lock(info, obj, ll, MDS_INODELOCK_LAYOUT,
LCK_EX, false);
- OBD_FAIL_TIMEOUT(OBD_FAIL_MDS_LL_BLOCK, 2);
+ CFS_FAIL_TIMEOUT(OBD_FAIL_MDS_LL_BLOCK, 2);
}
/* Check if there is any other open handles after acquiring
ktime_t kstart = ktime_get();
ENTRY;
- OBD_FAIL_TIMEOUT_ORSET(OBD_FAIL_MDS_PAUSE_OPEN, OBD_FAIL_ONCE,
+ CFS_FAIL_TIMEOUT_ORSET(OBD_FAIL_MDS_PAUSE_OPEN, CFS_FAIL_ONCE,
(obd_timeout + 1) / 4);
repbody = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY);
GOTO(out, result);
}
- if (OBD_FAIL_CHECK(OBD_FAIL_MDS_OPEN_PACK))
+ if (CFS_FAIL_CHECK(OBD_FAIL_MDS_OPEN_PACK))
GOTO(out, result = err_serious(-ENOMEM));
mdt_set_disposition(info, ldlm_rep,
result = -ENOENT;
lock_mode = mdt_open_lock_mode(info, parent, &rr->rr_name, open_flags);
- OBD_RACE(OBD_FAIL_MDS_REINT_OPEN);
+ CFS_RACE(OBD_FAIL_MDS_REINT_OPEN);
again_pw:
if (lock_mode != LCK_NL) {
lh = &info->mti_lh[MDT_LH_PARENT];
if (result != 0 && result != -ENOENT)
GOTO(out_parent_unlock, result);
- OBD_RACE(OBD_FAIL_MDS_REINT_OPEN2);
+ CFS_RACE(OBD_FAIL_MDS_REINT_OPEN2);
if (result == -ENOENT) {
mdt_set_disposition(info, ldlm_rep, DISP_LOOKUP_NEG);
}
mdt_exit_ucred(info);
- if (OBD_FAIL_CHECK(OBD_FAIL_MDS_CLOSE_PACK))
+ if (CFS_FAIL_CHECK(OBD_FAIL_MDS_CLOSE_PACK))
GOTO(out, rc = err_serious(-ENOMEM));
- if (OBD_FAIL_CHECK_RESET(OBD_FAIL_MDS_CLOSE_NET_REP,
+ if (CFS_FAIL_CHECK_RESET(OBD_FAIL_MDS_CLOSE_NET_REP,
OBD_FAIL_MDS_CLOSE_NET_REP))
tsi->tsi_reply_fail_id = OBD_FAIL_MDS_CLOSE_NET_REP;
out:
/* save version of file name for replay, it must be ENOENT here */
mdt_enoent_version_save(info, 1);
- OBD_RACE(OBD_FAIL_MDS_CREATE_RACE);
+ CFS_RACE(OBD_FAIL_MDS_CREATE_RACE);
lh = &info->mti_lh[MDT_LH_PARENT];
rc = mdt_parent_lock(info, parent, lh, &rr->rr_name, LCK_PW, false);
if (info->mti_dlm_req)
ldlm_request_cancel(req, info->mti_dlm_req, 0, LATF_SKIP);
- OBD_RACE(OBD_FAIL_PTLRPC_RESEND_RACE);
+ CFS_RACE(OBD_FAIL_PTLRPC_RESEND_RACE);
repbody = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY);
mo = mdt_object_find(info->mti_env, mdt, rr->rr_fid1);
int rc;
ENTRY;
- if (OBD_FAIL_CHECK(OBD_FAIL_MDS_REINT_CREATE))
+ if (CFS_FAIL_CHECK(OBD_FAIL_MDS_REINT_CREATE))
RETURN(err_serious(-ESTALE));
if (info->mti_dlm_req)
if (info->mti_dlm_req)
ldlm_request_cancel(req, info->mti_dlm_req, 0, LATF_SKIP);
- if (OBD_FAIL_CHECK(OBD_FAIL_MDS_REINT_UNLINK))
+ if (CFS_FAIL_CHECK(OBD_FAIL_MDS_REINT_UNLINK))
RETURN(err_serious(-ENOENT));
if (!fid_is_md_operative(rr->rr_fid1))
mp->mot_obj.lo_header->loh_attr & LOHA_FSCRYPT_MD)
GOTO(put_parent, rc = -EPERM);
- OBD_RACE(OBD_FAIL_MDS_REINT_OPEN);
- OBD_RACE(OBD_FAIL_MDS_REINT_OPEN2);
+ CFS_RACE(OBD_FAIL_MDS_REINT_OPEN);
+ CFS_RACE(OBD_FAIL_MDS_REINT_OPEN2);
relock:
parent_lh = &info->mti_lh[MDT_LH_PARENT];
rc = mdt_parent_lock(info, mp, parent_lh, &rr->rr_name, LCK_PW,
DEBUG_REQ(D_INODE, req, "link "DFID" to "DFID"/"DNAME,
PFID(rr->rr_fid1), PFID(rr->rr_fid2), PNAME(&rr->rr_name));
- if (OBD_FAIL_CHECK(OBD_FAIL_MDS_REINT_LINK))
+ if (CFS_FAIL_CHECK(OBD_FAIL_MDS_REINT_LINK))
RETURN(err_serious(-ENOENT));
- if (OBD_FAIL_PRECHECK(OBD_FAIL_PTLRPC_RESEND_RACE) ||
- OBD_FAIL_PRECHECK(OBD_FAIL_PTLRPC_ENQ_RESEND)) {
+ if (CFS_FAIL_PRECHECK(OBD_FAIL_PTLRPC_RESEND_RACE) ||
+ CFS_FAIL_PRECHECK(OBD_FAIL_PTLRPC_ENQ_RESEND)) {
req->rq_no_reply = 1;
RETURN(err_serious(-ENOENT));
}
cos_incompat = (mdt_object_remote(mp) || mdt_object_remote(ms));
- OBD_RACE(OBD_FAIL_MDS_LINK_RENAME_RACE);
+ CFS_RACE(OBD_FAIL_MDS_LINK_RENAME_RACE);
lhp = &info->mti_lh[MDT_LH_PARENT];
rc = mdt_parent_lock(info, mp, lhp, &rr->rr_name, LCK_PW, cos_incompat);
if (rc != 0)
GOTO(put_source, rc);
- OBD_FAIL_TIMEOUT(OBD_FAIL_MDS_RENAME3, 5);
+ CFS_FAIL_TIMEOUT(OBD_FAIL_MDS_RENAME3, 5);
lhs = &info->mti_lh[MDT_LH_CHILD];
rc = mdt_object_lock(info, ms, lhs,
return rc;
mdt_version_get_save(info, mfirstdir, 0);
- OBD_FAIL_TIMEOUT(OBD_FAIL_MDS_RENAME, 5);
+ CFS_FAIL_TIMEOUT(OBD_FAIL_MDS_RENAME, 5);
if (mfirstdir != mseconddir) {
rc = mdt_parent_lock(info, mseconddir, lh_seconddirp,
rc = mdt_object_pdo_lock(info, mseconddir,
lh_seconddirp, secondname,
LCK_PW, false, cos_incompat);
- OBD_FAIL_TIMEOUT(OBD_FAIL_MDS_PDO_LOCK2, 10);
+ CFS_FAIL_TIMEOUT(OBD_FAIL_MDS_PDO_LOCK2, 10);
}
}
mdt_version_get_save(info, mseconddir, 1);
if (rc)
GOTO(out_put_srcdir, rc);
- OBD_FAIL_TIMEOUT(OBD_FAIL_MDS_RENAME3, 5);
+ CFS_FAIL_TIMEOUT(OBD_FAIL_MDS_RENAME3, 5);
if (lu_fid_eq(rr->rr_fid1, rr->rr_fid2)) {
mtgtdir = msrcdir;
cos_incompat = (mdt_object_remote(msrcdir) ||
mdt_object_remote(mtgtdir));
- OBD_FAIL_TIMEOUT(OBD_FAIL_MDS_RENAME4, 5);
+ CFS_FAIL_TIMEOUT(OBD_FAIL_MDS_RENAME4, 5);
/* lock parents in the proper order. */
lh_srcdirp = &info->mti_lh[MDT_LH_PARENT];
lh_tgtdirp = &info->mti_lh[MDT_LH_CHILD];
- OBD_RACE(OBD_FAIL_MDS_REINT_OPEN);
- OBD_RACE(OBD_FAIL_MDS_REINT_OPEN2);
+ CFS_RACE(OBD_FAIL_MDS_REINT_OPEN);
+ CFS_RACE(OBD_FAIL_MDS_REINT_OPEN2);
relock:
mdt_lock_pdo_init(lh_srcdirp, LCK_PW, &rr->rr_name);
mdt_lock_pdo_init(lh_tgtdirp, LCK_PW, &rr->rr_tgt_name);
*/
if (!mdt_object_remote(mtgtdir) && mtgtdir == msrcdir)
reverse = lh_srcdirp->mlh_pdo_hash > lh_tgtdirp->mlh_pdo_hash;
- if (unlikely(OBD_FAIL_PRECHECK(OBD_FAIL_MDS_PDO_LOCK)))
+ if (unlikely(CFS_FAIL_PRECHECK(OBD_FAIL_MDS_PDO_LOCK)))
reverse = 0;
if (reverse)
if (rc != 0)
GOTO(out_unlock_rename, rc);
- OBD_FAIL_TIMEOUT(OBD_FAIL_MDS_RENAME4, 5);
- OBD_FAIL_TIMEOUT(OBD_FAIL_MDS_RENAME2, 5);
+ CFS_FAIL_TIMEOUT(OBD_FAIL_MDS_RENAME4, 5);
+ CFS_FAIL_TIMEOUT(OBD_FAIL_MDS_RENAME2, 5);
/* find mold object. */
fid_zero(old_fid);
mdt_dom_discard_data(info, mnew);
mdt_object_put(info->mti_env, mnew);
}
- OBD_RACE(OBD_FAIL_MDS_LINK_RENAME_RACE);
+ CFS_RACE(OBD_FAIL_MDS_LINK_RENAME_RACE);
return rc;
}
if (rc2 < 0)
RETURN(rc2);
- if (OBD_FAIL_CHECK(OBD_FAIL_MDS_GETXATTR_PACK))
+ if (CFS_FAIL_CHECK(OBD_FAIL_MDS_GETXATTR_PACK))
RETURN(-ENOMEM);
RETURN(rc < 0 ? rc : size);
if (info->mti_dlm_req)
ldlm_request_cancel(req, info->mti_dlm_req, 0, LATF_SKIP);
- if (OBD_FAIL_CHECK(OBD_FAIL_MDS_SETXATTR))
+ if (CFS_FAIL_CHECK(OBD_FAIL_MDS_SETXATTR))
RETURN(err_serious(-ENOMEM));
rc = mdt_init_ucred_reint(info);
RETURN(0);
}
- OBD_FAIL_TIMEOUT(OBD_FAIL_MGC_PAUSE_PROCESS_LOG, 20);
+ CFS_FAIL_TIMEOUT(OBD_FAIL_MGC_PAUSE_PROCESS_LOG, 20);
CDEBUG(D_MGC, "Process log %s-%016lx from %d\n", cld->cld_logname,
cld->cld_cfg.cfg_instance, cld->cld_cfg.cfg_last_idx + 1);
GOTO(out_norevoke, rc);
}
- OBD_FAIL_TIMEOUT(OBD_FAIL_MGS_PAUSE_TARGET_REG, 10);
+ CFS_FAIL_TIMEOUT(OBD_FAIL_MGS_PAUSE_TARGET_REG, 10);
if (mti->mti_flags & LDD_F_WRITECONF) {
if (mti->mti_flags & LDD_F_SV_TYPE_MDT &&
rc = 0;
}
- OBD_FAIL_TIMEOUT(OBD_FAIL_MGS_WRITE_TARGET_DELAY, cfs_fail_val > 0 ?
+ CFS_FAIL_TIMEOUT(OBD_FAIL_MGS_WRITE_TARGET_DELAY, cfs_fail_val > 0 ?
cfs_fail_val : 10);
mutex_lock(&fsdb->fsdb_mutex);
out = data->ioc_bulk;
remains = data->ioc_inllen1;
/* OBD_FAIL: fetch the config_log records from the specified one */
- if (OBD_FAIL_CHECK(OBD_FAIL_CATLIST))
+ if (CFS_FAIL_CHECK(OBD_FAIL_CATLIST))
data->ioc_count = cfs_fail_val;
list_for_each_entry_safe(dirent, n, &log_list, mde_list) {
git://git.whamcloud.com / fs / lustre-release.git / commitdiff