X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Flfsck%2Flfsck_engine.c;h=f9c65b8c08cba037e19d5dcaeedc7b1782aadc45;hp=97d0427635bce876f0d8e7cae1696b4e9dfb23e1;hb=d525ad4bd0d5d851405e4249859a1c77378f0ee3;hpb=520631764c0e9d1bf5c70f8d060b81a2f322d5dc diff --git a/lustre/lfsck/lfsck_engine.c b/lustre/lfsck/lfsck_engine.c index 97d0427..f9c65b8 100644 --- a/lustre/lfsck/lfsck_engine.c +++ b/lustre/lfsck/lfsck_engine.c @@ -20,7 +20,7 @@ * GPL HEADER END */ /* - * Copyright (c) 2013, 2015, Intel Corporation. + * Copyright (c) 2013, 2016, Intel Corporation. */ /* * lustre/lfsck/lfsck_engine.c @@ -93,17 +93,6 @@ static void lfsck_di_dir_put(const struct lu_env *env, struct lfsck_instance *lf iops->put(env, di); } -static int lfsck_parent_fid(const struct lu_env *env, struct dt_object *obj, - struct lu_fid *fid) -{ - if (unlikely(!S_ISDIR(lfsck_object_type(obj)) || - !dt_try_as_dir(env, obj))) - return -ENOTDIR; - - return dt_lookup(env, obj, (struct dt_rec *)fid, - (const struct dt_key *)".."); -} - /** * Check whether needs to scan the directory or not. * @@ -136,6 +125,7 @@ static int lfsck_needs_scan_dir(const struct lu_env *env, struct lfsck_thread_info *info = lfsck_env_info(env); struct lu_fid *fid = &info->lti_fid; struct lu_seq_range *range = &info->lti_range; + struct lu_attr *la = &info->lti_la; struct seq_server_site *ss = lfsck_dev_site(lfsck); __u32 idx = lfsck_dev_idx(lfsck); int depth = 0; @@ -144,9 +134,21 @@ static int lfsck_needs_scan_dir(const struct lu_env *env, if (list_empty(&lfsck->li_list_dir) || !S_ISDIR(lfsck_object_type(obj))) return 0; + *fid = *lfsck_dto2fid(obj); + rc = dt_attr_get(env, obj, la); + if (unlikely(rc || (la->la_valid & LA_FLAGS && + la->la_flags & LUSTRE_ORPHAN_FL))) { + /* Orphan directory is empty, does not need scan. */ + CDEBUG(D_INFO, + "%s: skip orphan dir "DFID", %llx/%x: rc = %d\n", + lfsck_lfsck2name(lfsck), PFID(fid), + la->la_valid, la->la_flags, rc); + + return rc; + } + LASSERT(ss != NULL); - *fid = *lfsck_dto2fid(obj); while (1) { /* Global /ROOT is visible. */ if (unlikely(lu_fid_eq(fid, &lfsck->li_global_root_fid))) @@ -177,6 +179,7 @@ static int lfsck_needs_scan_dir(const struct lu_env *env, if (fid_is_norm(fid)) return 1; + /* Only true after "obj = NULL" set below */ if (obj == NULL) { obj = lfsck_object_find_bottom(env, lfsck, fid); if (IS_ERR(obj)) @@ -187,7 +190,7 @@ static int lfsck_needs_scan_dir(const struct lu_env *env, GOTO(out, rc = 0); } - dt_read_lock(env, obj, MOR_TGT_CHILD); + dt_read_lock(env, obj, DT_TGT_CHILD); if (unlikely(lfsck_is_dead_obj(obj))) { dt_read_unlock(env, obj); @@ -203,7 +206,7 @@ static int lfsck_needs_scan_dir(const struct lu_env *env, if (rc < 0 && rc != -ENODATA) GOTO(out, rc); - rc = lfsck_parent_fid(env, obj, fid); + rc = dt_lookup_dir(env, obj, dotdot, fid); if (depth > 0) lfsck_object_put(env, obj); @@ -234,7 +237,7 @@ static int lfsck_load_stripe_lmv(const struct lu_env *env, LASSERT(lfsck->li_obj_dir == NULL); LASSERT(lfsck->li_lmv == NULL); - rc = lfsck_read_stripe_lmv(env, obj, lmv); + rc = lfsck_read_stripe_lmv(env, lfsck, obj, lmv); if (rc == -ENODATA) { lfsck->li_obj_dir = lfsck_object_get(obj); @@ -260,7 +263,7 @@ static int lfsck_load_stripe_lmv(const struct lu_env *env, else stripes = lmv->lmv_stripe_count; - OBD_ALLOC_LARGE(lslr, sizeof(*lslr) * stripes); + OBD_ALLOC_PTR_ARRAY_LARGE(lslr, stripes); if (lslr == NULL) { OBD_FREE_PTR(llmv); @@ -362,7 +365,9 @@ int lfsck_open_dir(const struct lu_env *env, GOTO(out, rc = PTR_ERR(di)); rc = iops->load(env, di, cookie); - if (rc == 0 || (rc > 0 && cookie > 0)) + if (rc == -ENODATA) + rc = 1; + else if (rc == 0 || (rc > 0 && cookie > 0)) rc = iops->next(env, di); else if (rc > 0) rc = 0; @@ -393,8 +398,7 @@ static int lfsck_checkpoint(const struct lu_env *env, int rc = 0; int rc1 = 0; - if (likely(cfs_time_beforeq(cfs_time_current(), - lfsck->li_time_next_checkpoint))) + if (likely(ktime_get_seconds() <= lfsck->li_time_next_checkpoint)) return 0; lfsck_pos_fill(env, lfsck, &lfsck->li_pos_checkpoint, false); @@ -404,9 +408,9 @@ static int lfsck_checkpoint(const struct lu_env *env, rc1 = rc; } - lfsck->li_time_last_checkpoint = cfs_time_current(); + lfsck->li_time_last_checkpoint = ktime_get_seconds(); lfsck->li_time_next_checkpoint = lfsck->li_time_last_checkpoint + - cfs_time_seconds(LFSCK_CHECKPOINT_INTERVAL); + LFSCK_CHECKPOINT_INTERVAL; return rc1 != 0 ? rc1 : rc; } @@ -441,7 +445,7 @@ static int lfsck_prep(const struct lu_env *env, struct lfsck_instance *lfsck, /* Init otable-based iterator. */ if (pos == NULL) { rc = iops->load(env, lfsck->li_di_oit, 0); - if (rc > 0) { + if (rc > 0 || unlikely(rc == -ENODATA)) { lfsck->li_oit_over = 1; rc = 0; } @@ -450,10 +454,10 @@ static int lfsck_prep(const struct lu_env *env, struct lfsck_instance *lfsck, } rc = iops->load(env, lfsck->li_di_oit, pos->lp_oit_cookie); - if (rc < 0) - GOTO(out, rc); - else if (rc > 0) + if (rc > 0 || unlikely(rc == -ENODATA)) lfsck->li_oit_over = 1; + else if (rc < 0) + GOTO(out, rc); if (!lfsck->li_master || fid_is_zero(&pos->lp_dir_parent)) GOTO(out, rc = 0); @@ -507,9 +511,9 @@ out: break; } - lfsck->li_time_last_checkpoint = cfs_time_current(); + lfsck->li_time_last_checkpoint = ktime_get_seconds(); lfsck->li_time_next_checkpoint = lfsck->li_time_last_checkpoint + - cfs_time_seconds(LFSCK_CHECKPOINT_INTERVAL); + LFSCK_CHECKPOINT_INTERVAL; return rc; } @@ -606,9 +610,9 @@ static int lfsck_post(const struct lu_env *env, struct lfsck_instance *lfsck, (__u32)com->lc_type, rc); } - lfsck->li_time_last_checkpoint = cfs_time_current(); + lfsck->li_time_last_checkpoint = ktime_get_seconds(); lfsck->li_time_next_checkpoint = lfsck->li_time_last_checkpoint + - cfs_time_seconds(LFSCK_CHECKPOINT_INTERVAL); + LFSCK_CHECKPOINT_INTERVAL; /* Ignore some component post failure to make other can go ahead. */ return result; @@ -619,7 +623,6 @@ static int lfsck_double_scan(const struct lu_env *env, { struct lfsck_component *com; struct lfsck_component *next; - struct l_wait_info lwi = { 0 }; int rc = 0; int rc1 = 0; @@ -629,9 +632,8 @@ static int lfsck_double_scan(const struct lu_env *env, rc1 = rc; } - l_wait_event(lfsck->li_thread.t_ctl_waitq, - atomic_read(&lfsck->li_double_scan_count) == 0, - &lwi); + wait_event_idle(lfsck->li_thread.t_ctl_waitq, + atomic_read(&lfsck->li_double_scan_count) == 0); if (lfsck->li_status != LS_PAUSED && lfsck->li_status != LS_CO_PAUSED) { @@ -1011,10 +1013,13 @@ int lfsck_master_engine(void *args) struct dt_object *oit_obj = lfsck->li_obj_oit; const struct dt_it_ops *oit_iops = &oit_obj->do_index_ops->dio_it; struct dt_it *oit_di; - struct l_wait_info lwi = { 0 }; int rc; ENTRY; + spin_lock(&lfsck->li_lock); + lfsck->li_task = current; + spin_unlock(&lfsck->li_lock); + /* There will be some objects verification during the LFSCK start, * such as the subsequent lfsck_verify_lpf(). Trigger low layer OI * OI scrub before that to handle the potential inconsistence. */ @@ -1055,17 +1060,21 @@ int lfsck_master_engine(void *args) lfsck->li_pos_checkpoint.lp_oit_cookie, lfsck->li_pos_checkpoint.lp_dir_cookie, PFID(&lfsck->li_pos_checkpoint.lp_dir_parent), - current_pid()); + current->pid); spin_lock(&lfsck->li_lock); + if (unlikely(!thread_is_starting(thread))) { + spin_unlock(&lfsck->li_lock); + GOTO(fini_oit, rc = 0); + } + thread_set_flags(thread, SVC_RUNNING); spin_unlock(&lfsck->li_lock); wake_up_all(&thread->t_ctl_waitq); - l_wait_event(thread->t_ctl_waitq, - lfsck->li_start_unplug || - !thread_is_running(thread), - &lwi); + wait_event_idle(thread->t_ctl_waitq, + lfsck->li_start_unplug || + !thread_is_running(thread)); if (!thread_is_running(thread)) GOTO(fini_oit, rc = 0); @@ -1082,7 +1091,7 @@ int lfsck_master_engine(void *args) lfsck->li_pos_checkpoint.lp_oit_cookie, lfsck->li_pos_checkpoint.lp_dir_cookie, PFID(&lfsck->li_pos_checkpoint.lp_dir_parent), - current_pid(), rc); + current->pid, rc); if (!OBD_FAIL_CHECK(OBD_FAIL_LFSCK_CRASH)) rc = lfsck_post(env, lfsck, rc); @@ -1106,6 +1115,7 @@ fini_oit: fini_args: spin_lock(&lfsck->li_lock); thread_set_flags(thread, SVC_STOPPED); + lfsck->li_task = NULL; spin_unlock(&lfsck->li_lock); wake_up_all(&thread->t_ctl_waitq); lfsck_thread_args_fini(lta); @@ -1224,7 +1234,7 @@ again: } spin_unlock(<ds->ltd_lock); - rc = ptlrpc_set_wait(set); + rc = ptlrpc_set_wait(env, set); if (rc < 0) { ptlrpc_set_destroy(set); RETURN(rc); @@ -1319,7 +1329,7 @@ static int lfsck_assistant_notify_others(const struct lu_env *env, up_read(<ds->ltd_rw_sem); /* Sync up */ - rc = ptlrpc_set_wait(set); + rc = ptlrpc_set_wait(env, set); if (rc < 0) { ptlrpc_set_destroy(set); RETURN(rc); @@ -1451,7 +1461,7 @@ again: } spin_unlock(<ds->ltd_lock); - rc = ptlrpc_set_wait(set); + rc = ptlrpc_set_wait(env, set); if (rc < 0) { ptlrpc_set_destroy(set); RETURN(rc); @@ -1525,7 +1535,7 @@ again: break; } - rc1 = ptlrpc_set_wait(set); + rc1 = ptlrpc_set_wait(env, set); ptlrpc_set_destroy(set); RETURN(rc != 0 ? rc : rc1); @@ -1562,9 +1572,8 @@ int lfsck_assistant_engine(void *args) struct lfsck_assistant_data *lad = com->lc_data; struct ptlrpc_thread *mthread = &lfsck->li_thread; struct ptlrpc_thread *athread = &lad->lad_thread; - struct lfsck_assistant_operations *lao = lad->lad_ops; + const struct lfsck_assistant_operations *lao = lad->lad_ops; struct lfsck_assistant_req *lar; - struct l_wait_info lwi = { 0 }; int rc = 0; int rc1 = 0; int rc2; @@ -1595,9 +1604,9 @@ int lfsck_assistant_engine(void *args) while (!list_empty(&lad->lad_req_list)) { bool wakeup = false; - if (unlikely(lad->lad_exit || + if (unlikely(test_bit(LAD_EXIT, &lad->lad_flags) || !thread_is_running(mthread))) - GOTO(cleanup1, rc = lad->lad_post_result); + GOTO(cleanup, rc = lad->lad_post_result); lar = list_entry(lad->lad_req_list.next, struct lfsck_assistant_req, @@ -1622,30 +1631,29 @@ int lfsck_assistant_engine(void *args) lao->la_req_fini(env, lar); if (rc < 0 && bk->lb_param & LPF_FAILOUT) - GOTO(cleanup1, rc); + GOTO(cleanup, rc); } - l_wait_event(athread->t_ctl_waitq, - !lfsck_assistant_req_empty(lad) || - lad->lad_exit || - lad->lad_to_post || - lad->lad_to_double_scan, - &lwi); + wait_event_idle(athread->t_ctl_waitq, + !lfsck_assistant_req_empty(lad) || + test_bit(LAD_EXIT, &lad->lad_flags) || + test_bit(LAD_TO_POST, &lad->lad_flags) || + test_bit(LAD_TO_DOUBLE_SCAN, &lad->lad_flags)); - if (unlikely(lad->lad_exit)) - GOTO(cleanup1, rc = lad->lad_post_result); + if (unlikely(test_bit(LAD_EXIT, &lad->lad_flags))) + GOTO(cleanup, rc = lad->lad_post_result); if (!list_empty(&lad->lad_req_list)) continue; - if (lad->lad_to_post) { + if (test_bit(LAD_TO_POST, &lad->lad_flags)) { CDEBUG(D_LFSCK, "%s: %s LFSCK assistant thread post\n", lfsck_lfsck2name(lfsck), lad->lad_name); - if (unlikely(lad->lad_exit)) - GOTO(cleanup1, rc = lad->lad_post_result); + if (unlikely(test_bit(LAD_EXIT, &lad->lad_flags))) + GOTO(cleanup, rc = lad->lad_post_result); - lad->lad_to_post = 0; + clear_bit(LAD_TO_POST, &lad->lad_flags); LASSERT(lad->lad_post_result > 0); /* Wakeup the master engine to go ahead. */ @@ -1662,18 +1670,18 @@ int lfsck_assistant_engine(void *args) lad->lad_name, rc); } - if (lad->lad_to_double_scan) { - lad->lad_to_double_scan = 0; + if (test_bit(LAD_TO_DOUBLE_SCAN, &lad->lad_flags)) { + clear_bit(LAD_TO_DOUBLE_SCAN, &lad->lad_flags); atomic_inc(&lfsck->li_double_scan_count); - lad->lad_in_double_scan = 1; + set_bit(LAD_IN_DOUBLE_SCAN, &lad->lad_flags); wake_up_all(&mthread->t_ctl_waitq); com->lc_new_checked = 0; com->lc_new_scanned = 0; - com->lc_time_last_checkpoint = cfs_time_current(); + com->lc_time_last_checkpoint = ktime_get_seconds(); com->lc_time_next_checkpoint = com->lc_time_last_checkpoint + - cfs_time_seconds(LFSCK_CHECKPOINT_INTERVAL); + LFSCK_CHECKPOINT_INTERVAL; CDEBUG(D_LFSCK, "%s: LFSCK assistant sync before " "the second-stage scaning\n", @@ -1687,58 +1695,61 @@ int lfsck_assistant_engine(void *args) lfsck_lfsck2name(lfsck), rc2); if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_NO_DOUBLESCAN)) - GOTO(cleanup2, rc = 0); + GOTO(cleanup, rc = 0); + + while (test_bit(LAD_IN_DOUBLE_SCAN, &lad->lad_flags)) { + int seconds = 30; - while (lad->lad_in_double_scan) { rc = lfsck_assistant_query_others(env, com); if (lfsck_phase2_next_ready(lad)) goto p2_next; if (rc < 0) - GOTO(cleanup2, rc); + GOTO(cleanup, rc); /* Pull LFSCK status on related targets once * per 30 seconds if we are not notified. */ - lwi = LWI_TIMEOUT_INTERVAL(cfs_time_seconds(30), - cfs_time_seconds(1), - NULL, NULL); - rc = l_wait_event(athread->t_ctl_waitq, - lfsck_phase2_next_ready(lad) || - lad->lad_exit || - !thread_is_running(mthread), - &lwi); - - if (unlikely(lad->lad_exit || - !thread_is_running(mthread))) - GOTO(cleanup2, rc = 0); - - if (rc == -ETIMEDOUT) + while (seconds > 0 && + wait_event_idle_timeout( + athread->t_ctl_waitq, + lfsck_phase2_next_ready(lad) || + test_bit(LAD_EXIT, + &lad->lad_flags) || + !thread_is_running(mthread), + cfs_time_seconds(1)) == 0) + seconds -= 1; + + if (unlikely( + test_bit(LAD_EXIT, &lad->lad_flags) || + !thread_is_running(mthread))) + GOTO(cleanup, rc = 0); + + if (seconds == 0) continue; - if (rc < 0) - GOTO(cleanup2, rc); - p2_next: rc = lao->la_handler_p2(env, com); if (rc != 0) - GOTO(cleanup2, rc); + GOTO(cleanup, rc); - if (unlikely(lad->lad_exit || - !thread_is_running(mthread))) - GOTO(cleanup2, rc = 0); + if (unlikely( + test_bit(LAD_EXIT, &lad->lad_flags) || + !thread_is_running(mthread))) + GOTO(cleanup, rc = 0); } } } -cleanup1: +cleanup: /* Cleanup the unfinished requests. */ spin_lock(&lad->lad_lock); if (rc < 0) lad->lad_assistant_status = rc; - if (lad->lad_exit && lad->lad_post_result <= 0) + if (test_bit(LAD_EXIT, &lad->lad_flags) && lad->lad_post_result <= 0) lao->la_fill_pos(env, com, &lfsck->li_pos_checkpoint); + thread_set_flags(athread, SVC_STOPPING); while (!list_empty(&lad->lad_req_list)) { lar = list_entry(lad->lad_req_list.next, struct lfsck_assistant_req, @@ -1751,10 +1762,6 @@ cleanup1: } spin_unlock(&lad->lad_lock); - LASSERTF(lad->lad_prefetched == 0, "unmatched prefeteched objs %d\n", - lad->lad_prefetched); - -cleanup2: memset(lr, 0, sizeof(*lr)); if (rc > 0) { lr->lr_event = LE_PHASE2_DONE; @@ -1813,8 +1820,8 @@ cleanup2: /* Under force exit case, some requests may be just freed without * verification, those objects should be re-handled when next run. * So not update the on-disk trace file under such case. */ - if (lad->lad_in_double_scan) { - if (!lad->lad_exit) + if (test_bit(LAD_IN_DOUBLE_SCAN, &lad->lad_flags)) { + if (!test_bit(LAD_EXIT, &lad->lad_flags)) rc1 = lao->la_double_scan_result(env, com, rc); CDEBUG(D_LFSCK, "%s: LFSCK assistant phase2 scan " @@ -1823,13 +1830,12 @@ cleanup2: } fini: - if (lad->lad_in_double_scan) + if (test_bit(LAD_IN_DOUBLE_SCAN, &lad->lad_flags)) atomic_dec(&lfsck->li_double_scan_count); spin_lock(&lad->lad_lock); lad->lad_assistant_status = (rc1 != 0 ? rc1 : rc); thread_set_flags(athread, SVC_STOPPED); - wake_up_all(&mthread->t_ctl_waitq); lad->lad_task = NULL; spin_unlock(&lad->lad_lock); @@ -1838,6 +1844,7 @@ fini: lad->lad_assistant_status); lfsck_thread_args_fini(lta); + wake_up_all(&mthread->t_ctl_waitq); return rc; }