void ptlrpc_ni_fini(void)
{
wait_queue_head_t waitq;
struct l_wait_info lwi;
int rc;
int retries;
/* Wait for the event queue to become idle since there may still be
* messages in flight with pending events (i.e. the fire-and-forget
* messages == client requests and "non-difficult" server
* replies */
for (retries = 0;; retries++) {
rc = LNetEQFree(ptlrpc_eq_h);
switch (rc) {
default:
LBUG();
case 0:
LNetNIFini();
return;
case -EBUSY:
if (retries != 0)
CWARN("Event queue still busy\n");
/* Wait for a bit */
init_waitqueue_head(&waitq);
lwi = LWI_TIMEOUT(cfs_time_seconds(2), NULL, NULL);
l_wait_event(waitq, 0, &lwi);
break;
}
}
/* notreached */
}
static int osd_scrub_next(const struct lu_env *env, struct osd_device *dev,
struct lu_fid *fid, uint64_t *oid)
{
struct l_wait_info lwi = { 0 };
struct lustre_scrub *scrub = &dev->od_scrub;
struct ptlrpc_thread *thread = &scrub->os_thread;
struct osd_otable_it *it = dev->od_otable_it;
struct lustre_mdt_attrs *lma = NULL;
nvlist_t *nvbuf = NULL;
int size = 0;
int rc = 0;
ENTRY;
if (OBD_FAIL_CHECK(OBD_FAIL_OSD_SCRUB_DELAY) && cfs_fail_val > 0) {
lwi = LWI_TIMEOUT(cfs_time_seconds(cfs_fail_val), NULL, NULL);
if (likely(lwi.lwi_timeout > 0)) {
l_wait_event(thread->t_ctl_waitq,
!list_empty(&scrub->os_inconsistent_items) ||
!thread_is_running(thread),
&lwi);
if (unlikely(!thread_is_running(thread)))
RETURN(SCRUB_NEXT_EXIT);
}
}
if (OBD_FAIL_CHECK(OBD_FAIL_OSD_SCRUB_CRASH)) {
spin_lock(&scrub->os_lock);
thread_set_flags(thread, SVC_STOPPING);
spin_unlock(&scrub->os_lock);
RETURN(SCRUB_NEXT_CRASH);
}
if (OBD_FAIL_CHECK(OBD_FAIL_OSD_SCRUB_FATAL))
RETURN(SCRUB_NEXT_FATAL);
again:
if (nvbuf) {
nvlist_free(nvbuf);
nvbuf = NULL;
lma = NULL;
}
if (!list_empty(&scrub->os_inconsistent_items)) {
spin_lock(&scrub->os_lock);
if (likely(!list_empty(&scrub->os_inconsistent_items))) {
struct osd_inconsistent_item *oii;
oii = list_entry(scrub->os_inconsistent_items.next,
struct osd_inconsistent_item, oii_list);
*fid = oii->oii_cache.oic_fid;
*oid = oii->oii_cache.oic_dnode;
scrub->os_in_prior = 1;
spin_unlock(&scrub->os_lock);
GOTO(out, rc = 0);
}
spin_unlock(&scrub->os_lock);
}
int
main(void)
{
struct l_wait_info lwi;
struct psc_waitq wq;
int rc;
psc_waitq_init(&wq);
lwi = LWI_TIMEOUT(1, NULL, NULL);
rc = psc_svr_wait_event(&wq, 0, &lwi, NULL);
printf("rc=%d [ETIMEDOUT=%d, EINVAL=%d, EPERM=%d]\n%s\n",
rc, ETIMEDOUT, EINVAL, EPERM, strerror(-rc));
return 0;
}
/* Request sequence-controller node to allocate new meta-sequence. */
static int seq_client_alloc_meta(const struct lu_env *env,
struct lu_client_seq *seq)
{
int rc;
ENTRY;
if (seq->lcs_srv) {
#ifdef HAVE_SEQ_SERVER
LASSERT(env != NULL);
rc = seq_server_alloc_meta(seq->lcs_srv, &seq->lcs_space, env);
#else
rc = 0;
#endif
} else {
do {
/* If meta server return -EINPROGRESS or EAGAIN,
* it means meta server might not be ready to
* allocate super sequence from sequence controller
* (MDT0)yet */
rc = seq_client_rpc(seq, &seq->lcs_space,
SEQ_ALLOC_META, "meta");
if (rc == -EINPROGRESS || rc == -EAGAIN) {
wait_queue_head_t waitq;
struct l_wait_info lwi;
/* MDT0 is not ready, let's wait for 2
* seconds and retry. */
init_waitqueue_head(&waitq);
lwi = LWI_TIMEOUT(cfs_time_seconds(2), NULL,
NULL);
l_wait_event(waitq, 0, &lwi);
}
} while (rc == -EINPROGRESS || rc == -EAGAIN);
}
RETURN(rc);
}
/*
* called to reserve object in the pool
* return codes:
* ENOSPC - no space on corresponded OST
* EAGAIN - precreation is in progress, try later
* EIO - no access to OST
*/
int osp_precreate_reserve(const struct lu_env *env, struct osp_device *d)
{
struct l_wait_info lwi;
cfs_time_t expire = cfs_time_shift(obd_timeout);
int precreated, rc;
ENTRY;
LASSERTF(osp_objs_precreated(env, d) >= 0, "Last created FID "DFID
"Next FID "DFID"\n", PFID(&d->opd_pre_last_created_fid),
PFID(&d->opd_pre_used_fid));
/*
* wait till:
* - preallocation is done
* - no free space expected soon
* - can't connect to OST for too long (obd_timeout)
* - OST can allocate fid sequence.
*/
while ((rc = d->opd_pre_status) == 0 || rc == -ENOSPC ||
rc == -ENODEV || rc == -EAGAIN || rc == -ENOTCONN) {
/*
* increase number of precreations
*/
precreated = osp_objs_precreated(env, d);
if (d->opd_pre_grow_count < d->opd_pre_max_grow_count &&
d->opd_pre_grow_slow == 0 &&
precreated <= (d->opd_pre_grow_count / 4 + 1)) {
spin_lock(&d->opd_pre_lock);
d->opd_pre_grow_slow = 1;
d->opd_pre_grow_count *= 2;
spin_unlock(&d->opd_pre_lock);
}
spin_lock(&d->opd_pre_lock);
precreated = osp_objs_precreated(env, d);
if (precreated > d->opd_pre_reserved &&
!d->opd_pre_recovering) {
d->opd_pre_reserved++;
spin_unlock(&d->opd_pre_lock);
rc = 0;
/* XXX: don't wake up if precreation is in progress */
if (osp_precreate_near_empty_nolock(env, d) &&
!osp_precreate_end_seq_nolock(env, d))
wake_up(&d->opd_pre_waitq);
break;
}
spin_unlock(&d->opd_pre_lock);
/*
* all precreated objects have been used and no-space
* status leave us no chance to succeed very soon
* but if there is destroy in progress, then we should
* wait till that is done - some space might be released
*/
if (unlikely(rc == -ENOSPC)) {
if (d->opd_syn_changes) {
/* force local commit to release space */
dt_commit_async(env, d->opd_storage);
}
if (d->opd_syn_rpc_in_progress) {
/* just wait till destroys are done */
/* see l_wait_even() few lines below */
}
if (d->opd_syn_changes +
d->opd_syn_rpc_in_progress == 0) {
/* no hope for free space */
break;
}
}
/* XXX: don't wake up if precreation is in progress */
wake_up(&d->opd_pre_waitq);
lwi = LWI_TIMEOUT(expire - cfs_time_current(),
osp_precreate_timeout_condition, d);
if (cfs_time_aftereq(cfs_time_current(), expire)) {
rc = -ETIMEDOUT;
break;
}
l_wait_event(d->opd_pre_user_waitq,
osp_precreate_ready_condition(env, d), &lwi);
}
RETURN(rc);
}
static int quota_chk_acq_common(struct obd_device *obd, struct obd_export *exp,
const unsigned int id[], int pending[],
int count, quota_acquire acquire,
struct obd_trans_info *oti, int isblk,
struct inode *inode, int frags)
{
struct lustre_quota_ctxt *qctxt = &obd->u.obt.obt_qctxt;
struct timeval work_start;
struct timeval work_end;
long timediff;
struct l_wait_info lwi = { 0 };
int rc = 0, cycle = 0, count_err = 1;
ENTRY;
if (!quota_is_set(obd, id, isblk ? QB_SET : QI_SET))
RETURN(0);
if (isblk && (exp->exp_failed || exp->exp_abort_active_req))
/* If the client has been evicted or if it
* timed out and tried to reconnect already,
* abort the request immediately */
RETURN(-ENOTCONN);
CDEBUG(D_QUOTA, "check quota for %s\n", obd->obd_name);
pending[USRQUOTA] = pending[GRPQUOTA] = 0;
/* Unfortunately, if quota master is too busy to handle the
* pre-dqacq in time and quota hash on ost is used up, we
* have to wait for the completion of in flight dqacq/dqrel,
* in order to get enough quota for write b=12588 */
cfs_gettimeofday(&work_start);
while ((rc = quota_check_common(obd, id, pending, count, cycle, isblk,
inode, frags)) &
QUOTA_RET_ACQUOTA) {
cfs_spin_lock(&qctxt->lqc_lock);
if (!qctxt->lqc_import && oti) {
cfs_spin_unlock(&qctxt->lqc_lock);
LASSERT(oti && oti->oti_thread &&
oti->oti_thread->t_watchdog);
lc_watchdog_disable(oti->oti_thread->t_watchdog);
CDEBUG(D_QUOTA, "sleep for quota master\n");
l_wait_event(qctxt->lqc_wait_for_qmaster, check_qm(qctxt),
&lwi);
CDEBUG(D_QUOTA, "wake up when quota master is back\n");
lc_watchdog_touch(oti->oti_thread->t_watchdog,
CFS_GET_TIMEOUT(oti->oti_thread->t_svc));
} else {
cfs_spin_unlock(&qctxt->lqc_lock);
}
cycle++;
if (isblk)
OBD_FAIL_TIMEOUT(OBD_FAIL_OST_HOLD_WRITE_RPC, 90);
/* after acquire(), we should run quota_check_common again
* so that we confirm there are enough quota to finish write */
rc = acquire(obd, id, oti, isblk);
/* please reference to dqacq_completion for the below */
/* a new request is finished, try again */
if (rc == QUOTA_REQ_RETURNED) {
CDEBUG(D_QUOTA, "finish a quota req, try again\n");
continue;
}
/* it is out of quota already */
if (rc == -EDQUOT) {
CDEBUG(D_QUOTA, "out of quota, return -EDQUOT\n");
break;
}
/* Related quota has been disabled by master, but enabled by
* slave, do not try again. */
if (unlikely(rc == -ESRCH)) {
CERROR("mismatched quota configuration, stop try.\n");
break;
}
if (isblk && (exp->exp_failed || exp->exp_abort_active_req))
/* The client has been evicted or tried to
* to reconnect already, abort the request */
RETURN(-ENOTCONN);
/* -EBUSY and others, wait a second and try again */
if (rc < 0) {
cfs_waitq_t waitq;
struct l_wait_info lwi;
if (oti && oti->oti_thread && oti->oti_thread->t_watchdog)
lc_watchdog_touch(oti->oti_thread->t_watchdog,
CFS_GET_TIMEOUT(oti->oti_thread->t_svc));
CDEBUG(D_QUOTA, "rc: %d, count_err: %d\n", rc,
count_err++);
cfs_waitq_init(&waitq);
lwi = LWI_TIMEOUT(cfs_time_seconds(min(cycle, 10)), NULL,
NULL);
l_wait_event(waitq, 0, &lwi);
}
if (rc < 0 || cycle % 10 == 0) {
cfs_spin_lock(&last_print_lock);
if (last_print == 0 ||
cfs_time_before((last_print + cfs_time_seconds(30)),
cfs_time_current())) {
last_print = cfs_time_current();
cfs_spin_unlock(&last_print_lock);
CWARN("still haven't managed to acquire quota "
"space from the quota master after %d "
"retries (err=%d, rc=%d)\n",
cycle, count_err - 1, rc);
} else {
cfs_spin_unlock(&last_print_lock);
}
}
CDEBUG(D_QUOTA, "recheck quota with rc: %d, cycle: %d\n", rc,
cycle);
}
cfs_gettimeofday(&work_end);
timediff = cfs_timeval_sub(&work_end, &work_start, NULL);
lprocfs_counter_add(qctxt->lqc_stats,
isblk ? LQUOTA_WAIT_FOR_CHK_BLK :
LQUOTA_WAIT_FOR_CHK_INO,
timediff);
if (rc > 0)
rc = 0;
RETURN(rc);
}
static int lfsck_master_oit_engine(const struct lu_env *env,
struct lfsck_instance *lfsck)
{
struct lfsck_thread_info *info = lfsck_env_info(env);
const struct dt_it_ops *iops =
&lfsck->li_obj_oit->do_index_ops->dio_it;
struct dt_it *di = lfsck->li_di_oit;
struct lu_fid *fid = &info->lti_fid;
struct lfsck_bookmark *bk = &lfsck->li_bookmark_ram;
struct ptlrpc_thread *thread = &lfsck->li_thread;
__u32 idx =
lfsck_dev_idx(lfsck->li_bottom);
int rc;
ENTRY;
do {
struct dt_object *target;
bool update_lma = false;
if (lfsck->li_di_dir != NULL) {
rc = lfsck_master_dir_engine(env, lfsck);
if (rc <= 0)
RETURN(rc);
}
if (unlikely(lfsck->li_oit_over))
RETURN(1);
if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_DELAY1) &&
cfs_fail_val > 0) {
struct l_wait_info lwi;
lwi = LWI_TIMEOUT(cfs_time_seconds(cfs_fail_val),
NULL, NULL);
l_wait_event(thread->t_ctl_waitq,
!thread_is_running(thread),
&lwi);
}
if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_CRASH))
RETURN(0);
lfsck->li_current_oit_processed = 1;
lfsck->li_new_scanned++;
rc = iops->rec(env, di, (struct dt_rec *)fid, 0);
if (rc != 0) {
lfsck_fail(env, lfsck, true);
if (rc < 0 && bk->lb_param & LPF_FAILOUT)
RETURN(rc);
else
goto checkpoint;
}
if (fid_is_idif(fid)) {
__u32 idx1 = fid_idif_ost_idx(fid);
LASSERT(!lfsck->li_master);
/* It is an old format device, update the LMA. */
if (idx != idx1) {
struct ost_id *oi = &info->lti_oi;
fid_to_ostid(fid, oi);
ostid_to_fid(fid, oi, idx);
update_lma = true;
}
} else if (!fid_is_norm(fid) && !fid_is_igif(fid) &&
!fid_is_last_id(fid) && !fid_is_root(fid) &&
!fid_seq_is_dot(fid_seq(fid))) {
/* If the FID/object is only used locally and invisible
* to external nodes, then LFSCK will not handle it. */
goto checkpoint;
}
target = lfsck_object_find(env, lfsck, fid);
if (target == NULL) {
goto checkpoint;
} else if (IS_ERR(target)) {
lfsck_fail(env, lfsck, true);
if (bk->lb_param & LPF_FAILOUT)
RETURN(PTR_ERR(target));
else
goto checkpoint;
}
/* XXX: Currently, skip remote object, the consistency for
* remote object will be processed in LFSCK phase III. */
if (dt_object_exists(target) && !dt_object_remote(target)) {
if (update_lma)
rc = lfsck_update_lma(env, lfsck, target);
if (rc == 0)
rc = lfsck_exec_oit(env, lfsck, target);
}
lfsck_object_put(env, target);
if (rc != 0 && bk->lb_param & LPF_FAILOUT)
RETURN(rc);
checkpoint:
rc = lfsck_checkpoint(env, lfsck);
if (rc != 0 && bk->lb_param & LPF_FAILOUT)
RETURN(rc);
/* Rate control. */
lfsck_control_speed(lfsck);
if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_FATAL1)) {
spin_lock(&lfsck->li_lock);
thread_set_flags(thread, SVC_STOPPING);
spin_unlock(&lfsck->li_lock);
RETURN(-EINVAL);
}
rc = iops->next(env, di);
if (unlikely(rc > 0))
lfsck->li_oit_over = 1;
else if (likely(rc == 0))
lfsck->li_current_oit_processed = 0;
if (unlikely(!thread_is_running(thread)))
RETURN(0);
} while (rc == 0 || lfsck->li_di_dir != NULL);
RETURN(rc);
}
static int lfsck_master_dir_engine(const struct lu_env *env,
struct lfsck_instance *lfsck)
{
struct lfsck_thread_info *info = lfsck_env_info(env);
const struct dt_it_ops *iops =
&lfsck->li_obj_dir->do_index_ops->dio_it;
struct dt_it *di = lfsck->li_di_dir;
struct lu_dirent *ent = &info->lti_ent;
struct lu_fid *fid = &info->lti_fid;
struct lfsck_bookmark *bk = &lfsck->li_bookmark_ram;
struct ptlrpc_thread *thread = &lfsck->li_thread;
int rc;
ENTRY;
do {
struct dt_object *child;
if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_DELAY2) &&
cfs_fail_val > 0) {
struct l_wait_info lwi;
lwi = LWI_TIMEOUT(cfs_time_seconds(cfs_fail_val),
NULL, NULL);
l_wait_event(thread->t_ctl_waitq,
!thread_is_running(thread),
&lwi);
}
lfsck->li_new_scanned++;
rc = iops->rec(env, di, (struct dt_rec *)ent,
lfsck->li_args_dir);
lfsck_unpack_ent(ent, &lfsck->li_cookie_dir);
if (rc != 0) {
lfsck_fail(env, lfsck, true);
if (bk->lb_param & LPF_FAILOUT)
RETURN(rc);
else
goto checkpoint;
}
if (ent->lde_attrs & LUDA_IGNORE)
goto checkpoint;
*fid = ent->lde_fid;
child = lfsck_object_find(env, lfsck, fid);
if (child == NULL) {
goto checkpoint;
} else if (IS_ERR(child)) {
lfsck_fail(env, lfsck, true);
if (bk->lb_param & LPF_FAILOUT)
RETURN(PTR_ERR(child));
else
goto checkpoint;
}
/* XXX: Currently, skip remote object, the consistency for
* remote object will be processed in LFSCK phase III. */
if (dt_object_exists(child) && !dt_object_remote(child))
rc = lfsck_exec_dir(env, lfsck, child, ent);
lfsck_object_put(env, child);
if (rc != 0 && bk->lb_param & LPF_FAILOUT)
RETURN(rc);
checkpoint:
rc = lfsck_checkpoint(env, lfsck);
if (rc != 0 && bk->lb_param & LPF_FAILOUT)
RETURN(rc);
/* Rate control. */
lfsck_control_speed(lfsck);
if (unlikely(!thread_is_running(thread)))
RETURN(0);
if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_FATAL2)) {
spin_lock(&lfsck->li_lock);
thread_set_flags(thread, SVC_STOPPING);
spin_unlock(&lfsck->li_lock);
RETURN(-EINVAL);
}
rc = iops->next(env, di);
} while (rc == 0);
if (rc > 0 && !lfsck->li_oit_over)
lfsck_close_dir(env, lfsck);
RETURN(rc);
}
/**
* Quota enforcement handler. If local quota can satisfy this operation,
* return success, otherwise, acquire more quota from master.
* (for write operation, if master isn't available at this moment, return
* -EINPROGRESS to inform client to retry the write)
*
* \param env - the environment passed by the caller
* \param qsd - is the qsd instance associated with the device in charge
* of the operation.
* \param qid - is the qid information attached in the transaction handle
* \param space - is the space required by the operation
* \param flags - if the operation is write, return caller no user/group
* and sync commit flags
*
* \retval 0 - success
* \retval -EDQUOT - out of quota
* \retval -EINPROGRESS - inform client to retry write
* \retval -ve - other appropriate errors
*/
static int qsd_op_begin0(const struct lu_env *env, struct qsd_qtype_info *qqi,
struct lquota_id_info *qid, long long space,
int *flags)
{
struct lquota_entry *lqe;
int rc, ret = -EINPROGRESS;
struct l_wait_info lwi;
ENTRY;
if (qid->lqi_qentry != NULL) {
/* we already had to deal with this id for this transaction */
lqe = qid->lqi_qentry;
if (!lqe->lqe_enforced)
RETURN(0);
} else {
/* look up lquota entry associated with qid */
lqe = lqe_locate(env, qqi->qqi_site, &qid->lqi_id);
if (IS_ERR(lqe))
RETURN(PTR_ERR(lqe));
if (!lqe->lqe_enforced) {
lqe_putref(lqe);
RETURN(0);
}
qid->lqi_qentry = lqe;
/* lqe will be released in qsd_op_end() */
}
if (space <= 0) {
/* when space is negative or null, we don't need to consume
* quota space. That said, we still want to perform space
* adjustments in qsd_op_end, so we return here, but with
* a reference on the lqe */
if (flags != NULL) {
rc = qsd_refresh_usage(env, lqe);
GOTO(out_flags, rc);
}
RETURN(0);
}
LQUOTA_DEBUG(lqe, "op_begin space:"LPD64, space);
lqe_write_lock(lqe);
lqe->lqe_waiting_write += space;
lqe_write_unlock(lqe);
/* acquire quota space for the operation, cap overall wait time to
* prevent a service thread from being stuck for too long */
lwi = LWI_TIMEOUT(cfs_time_seconds(qsd_wait_timeout(qqi->qqi_qsd)),
NULL, NULL);
rc = l_wait_event(lqe->lqe_waiters, qsd_acquire(env, lqe, space, &ret),
&lwi);
if (rc == 0 && ret == 0) {
qid->lqi_space += space;
} else {
if (rc == 0)
rc = ret;
LQUOTA_DEBUG(lqe, "acquire quota failed:%d", rc);
lqe_write_lock(lqe);
lqe->lqe_waiting_write -= space;
if (flags && lqe->lqe_pending_write != 0)
/* Inform OSD layer that there are pending writes.
* It might want to retry after a sync if appropriate */
*flags |= QUOTA_FL_SYNC;
lqe_write_unlock(lqe);
/* convert recoverable error into -EINPROGRESS, client will
* retry */
if (rc == -ETIMEDOUT || rc == -ENOTCONN || rc == -ENOLCK ||
rc == -EAGAIN || rc == -EINTR) {
rc = -EINPROGRESS;
} else if (rc == -ESRCH) {
rc = 0;
LQUOTA_ERROR(lqe, "ID isn't enforced on master, it "
"probably due to a legeal race, if this "
"message is showing up constantly, there "
"could be some inconsistence between "
"master & slave, and quota reintegration "
"needs be re-triggered.");
}
}
if (flags != NULL) {
out_flags:
LASSERT(qid->lqi_is_blk);
if (rc != 0) {
*flags |= LQUOTA_OVER_FL(qqi->qqi_qtype);
} else {
__u64 usage;
lqe_read_lock(lqe);
usage = lqe->lqe_usage;
usage += lqe->lqe_pending_write;
usage += lqe->lqe_waiting_write;
usage += qqi->qqi_qsd->qsd_sync_threshold;
/* if we should notify client to start sync write */
if (usage >= lqe->lqe_granted - lqe->lqe_pending_rel)
*flags |= LQUOTA_OVER_FL(qqi->qqi_qtype);
else
*flags &= ~LQUOTA_OVER_FL(qqi->qqi_qtype);
lqe_read_unlock(lqe);
}
}
RETURN(rc);
}
static int lfsck_namespace_double_scan_main(void *args)
{
struct lfsck_thread_args *lta = args;
const struct lu_env *env = <a->lta_env;
struct lfsck_component *com = lta->lta_com;
struct lfsck_instance *lfsck = com->lc_lfsck;
struct ptlrpc_thread *thread = &lfsck->li_thread;
struct lfsck_bookmark *bk = &lfsck->li_bookmark_ram;
struct lfsck_namespace *ns = com->lc_file_ram;
struct dt_object *obj = com->lc_obj;
const struct dt_it_ops *iops = &obj->do_index_ops->dio_it;
struct dt_object *target;
struct dt_it *di;
struct dt_key *key;
struct lu_fid fid;
int rc;
__u8 flags = 0;
ENTRY;
com->lc_new_checked = 0;
com->lc_new_scanned = 0;
com->lc_time_last_checkpoint = cfs_time_current();
com->lc_time_next_checkpoint = com->lc_time_last_checkpoint +
cfs_time_seconds(LFSCK_CHECKPOINT_INTERVAL);
di = iops->init(env, obj, 0, BYPASS_CAPA);
if (IS_ERR(di))
GOTO(out, rc = PTR_ERR(di));
fid_cpu_to_be(&fid, &ns->ln_fid_latest_scanned_phase2);
rc = iops->get(env, di, (const struct dt_key *)&fid);
if (rc < 0)
GOTO(fini, rc);
/* Skip the start one, which either has been processed or non-exist. */
rc = iops->next(env, di);
if (rc != 0)
GOTO(put, rc);
if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_NO_DOUBLESCAN))
GOTO(put, rc = 0);
do {
if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_DELAY3) &&
cfs_fail_val > 0) {
struct l_wait_info lwi;
lwi = LWI_TIMEOUT(cfs_time_seconds(cfs_fail_val),
NULL, NULL);
l_wait_event(thread->t_ctl_waitq,
!thread_is_running(thread),
&lwi);
}
key = iops->key(env, di);
fid_be_to_cpu(&fid, (const struct lu_fid *)key);
target = lfsck_object_find(env, lfsck, &fid);
down_write(&com->lc_sem);
if (target == NULL) {
rc = 0;
goto checkpoint;
} else if (IS_ERR(target)) {
rc = PTR_ERR(target);
goto checkpoint;
}
/* XXX: Currently, skip remote object, the consistency for
* remote object will be processed in LFSCK phase III. */
if (dt_object_exists(target) && !dt_object_remote(target)) {
rc = iops->rec(env, di, (struct dt_rec *)&flags, 0);
if (rc == 0)
rc = lfsck_namespace_double_scan_one(env, com,
target, flags);
}
lfsck_object_put(env, target);
checkpoint:
com->lc_new_checked++;
com->lc_new_scanned++;
ns->ln_fid_latest_scanned_phase2 = fid;
if (rc > 0)
ns->ln_objs_repaired_phase2++;
else if (rc < 0)
ns->ln_objs_failed_phase2++;
up_write(&com->lc_sem);
if ((rc == 0) || ((rc > 0) && !(bk->lb_param & LPF_DRYRUN))) {
lfsck_namespace_delete(env, com, &fid);
} else if (rc < 0) {
flags |= LLF_REPAIR_FAILED;
lfsck_namespace_update(env, com, &fid, flags, true);
}
if (rc < 0 && bk->lb_param & LPF_FAILOUT)
GOTO(put, rc);
if (unlikely(cfs_time_beforeq(com->lc_time_next_checkpoint,
cfs_time_current())) &&
com->lc_new_checked != 0) {
down_write(&com->lc_sem);
ns->ln_run_time_phase2 +=
cfs_duration_sec(cfs_time_current() +
HALF_SEC - com->lc_time_last_checkpoint);
ns->ln_time_last_checkpoint = cfs_time_current_sec();
ns->ln_objs_checked_phase2 += com->lc_new_checked;
com->lc_new_checked = 0;
rc = lfsck_namespace_store(env, com, false);
up_write(&com->lc_sem);
if (rc != 0)
GOTO(put, rc);
com->lc_time_last_checkpoint = cfs_time_current();
com->lc_time_next_checkpoint =
com->lc_time_last_checkpoint +
cfs_time_seconds(LFSCK_CHECKPOINT_INTERVAL);
}
lfsck_control_speed_by_self(com);
if (unlikely(!thread_is_running(thread)))
GOTO(put, rc = 0);
rc = iops->next(env, di);
} while (rc == 0);
GOTO(put, rc);
put:
iops->put(env, di);
fini:
iops->fini(env, di);
out:
down_write(&com->lc_sem);
ns->ln_run_time_phase2 += cfs_duration_sec(cfs_time_current() +
HALF_SEC - lfsck->li_time_last_checkpoint);
ns->ln_time_last_checkpoint = cfs_time_current_sec();
ns->ln_objs_checked_phase2 += com->lc_new_checked;
com->lc_new_checked = 0;
if (rc > 0) {
com->lc_journal = 0;
ns->ln_status = LS_COMPLETED;
if (!(bk->lb_param & LPF_DRYRUN))
ns->ln_flags &= ~(LF_SCANNED_ONCE | LF_INCONSISTENT);
ns->ln_time_last_complete = ns->ln_time_last_checkpoint;
ns->ln_success_count++;
} else if (rc == 0) {
ns->ln_status = lfsck->li_status;
if (ns->ln_status == 0)
ns->ln_status = LS_STOPPED;
} else {
ns->ln_status = LS_FAILED;
}
if (ns->ln_status != LS_PAUSED) {
spin_lock(&lfsck->li_lock);
cfs_list_del_init(&com->lc_link);
cfs_list_add_tail(&com->lc_link, &lfsck->li_list_idle);
spin_unlock(&lfsck->li_lock);
}
rc = lfsck_namespace_store(env, com, false);
up_write(&com->lc_sem);
if (atomic_dec_and_test(&lfsck->li_double_scan_count))
wake_up_all(&thread->t_ctl_waitq);
lfsck_thread_args_fini(lta);
return rc;
}
