+static void lfsck_namespace_dump_statistics(struct seq_file *m,
+ struct lfsck_namespace *ns,
+ __u64 checked_phase1,
+ __u64 checked_phase2,
+ __u32 time_phase1,
+ __u32 time_phase2)
+{
+ seq_printf(m, "checked_phase1: "LPU64"\n"
+ "checked_phase2: "LPU64"\n"
+ "updated_phase1: "LPU64"\n"
+ "updated_phase2: "LPU64"\n"
+ "failed_phase1: "LPU64"\n"
+ "failed_phase2: "LPU64"\n"
+ "directories: "LPU64"\n"
+ "dirent_repaired: "LPU64"\n"
+ "linkea_repaired: "LPU64"\n"
+ "nlinks_repaired: "LPU64"\n"
+ "multiple_linked_checked: "LPU64"\n"
+ "multiple_linked_repaired: "LPU64"\n"
+ "unknown_inconsistency: "LPU64"\n"
+ "unmatched_pairs_repaired: "LPU64"\n"
+ "dangling_repaired: "LPU64"\n"
+ "multiple_referenced_repaired: "LPU64"\n"
+ "bad_file_type_repaired: "LPU64"\n"
+ "lost_dirent_repaired: "LPU64"\n"
+ "local_lost_found_scanned: "LPU64"\n"
+ "local_lost_found_moved: "LPU64"\n"
+ "local_lost_found_skipped: "LPU64"\n"
+ "local_lost_found_failed: "LPU64"\n"
+ "striped_dirs_scanned: "LPU64"\n"
+ "striped_dirs_repaired: "LPU64"\n"
+ "striped_dirs_failed: "LPU64"\n"
+ "striped_dirs_disabled: "LPU64"\n"
+ "striped_dirs_skipped: "LPU64"\n"
+ "striped_shards_scanned: "LPU64"\n"
+ "striped_shards_repaired: "LPU64"\n"
+ "striped_shards_failed: "LPU64"\n"
+ "striped_shards_skipped: "LPU64"\n"
+ "name_hash_repaired: "LPU64"\n"
+ "success_count: %u\n"
+ "run_time_phase1: %u seconds\n"
+ "run_time_phase2: %u seconds\n",
+ checked_phase1,
+ checked_phase2,
+ ns->ln_items_repaired,
+ ns->ln_objs_repaired_phase2,
+ ns->ln_items_failed,
+ ns->ln_objs_failed_phase2,
+ ns->ln_dirs_checked,
+ ns->ln_dirent_repaired,
+ ns->ln_linkea_repaired,
+ ns->ln_objs_nlink_repaired,
+ ns->ln_mul_linked_checked,
+ ns->ln_mul_linked_repaired,
+ ns->ln_unknown_inconsistency,
+ ns->ln_unmatched_pairs_repaired,
+ ns->ln_dangling_repaired,
+ ns->ln_mul_ref_repaired,
+ ns->ln_bad_type_repaired,
+ ns->ln_lost_dirent_repaired,
+ ns->ln_local_lpf_scanned,
+ ns->ln_local_lpf_moved,
+ ns->ln_local_lpf_skipped,
+ ns->ln_local_lpf_failed,
+ ns->ln_striped_dirs_scanned,
+ ns->ln_striped_dirs_repaired,
+ ns->ln_striped_dirs_failed,
+ ns->ln_striped_dirs_disabled,
+ ns->ln_striped_dirs_skipped,
+ ns->ln_striped_shards_scanned,
+ ns->ln_striped_shards_repaired,
+ ns->ln_striped_shards_failed,
+ ns->ln_striped_shards_skipped,
+ ns->ln_name_hash_repaired,
+ ns->ln_success_count,
+ time_phase1,
+ time_phase2);
+}
+
+static void lfsck_namespace_release_lmv(const struct lu_env *env,
+ struct lfsck_component *com)
+{
+ struct lfsck_instance *lfsck = com->lc_lfsck;
+ struct lfsck_namespace *ns = com->lc_file_ram;
+
+ while (!list_empty(&lfsck->li_list_lmv)) {
+ struct lfsck_lmv_unit *llu;
+ struct lfsck_lmv *llmv;
+
+ llu = list_entry(lfsck->li_list_lmv.next,
+ struct lfsck_lmv_unit, llu_link);
+ llmv = &llu->llu_lmv;
+
+ LASSERTF(atomic_read(&llmv->ll_ref) == 1,
+ "still in using: %u\n",
+ atomic_read(&llmv->ll_ref));
+
+ ns->ln_striped_dirs_skipped++;
+ lfsck_lmv_put(env, llmv);
+ }
+}
+
+/* namespace APIs */
+
+static int lfsck_namespace_reset(const struct lu_env *env,
+ struct lfsck_component *com, bool init)
+{
+ struct lfsck_instance *lfsck = com->lc_lfsck;
+ struct lfsck_namespace *ns = com->lc_file_ram;
+ struct lfsck_assistant_data *lad = com->lc_data;
+ struct dt_object *root;
+ struct dt_object *dto;
+ int rc;
+ ENTRY;
+
+ root = dt_locate(env, lfsck->li_bottom, &lfsck->li_local_root_fid);
+ if (IS_ERR(root))
+ GOTO(log, rc = PTR_ERR(root));
+
+ if (unlikely(!dt_try_as_dir(env, root)))
+ GOTO(put, rc = -ENOTDIR);
+
+ down_write(&com->lc_sem);
+ if (init) {
+ memset(ns, 0, sizeof(*ns));
+ } else {
+ __u32 count = ns->ln_success_count;
+ __u64 last_time = ns->ln_time_last_complete;
+
+ memset(ns, 0, sizeof(*ns));
+ ns->ln_success_count = count;
+ ns->ln_time_last_complete = last_time;
+ }
+ ns->ln_magic = LFSCK_NAMESPACE_MAGIC;
+ ns->ln_status = LS_INIT;
+
+ rc = local_object_unlink(env, lfsck->li_bottom, root,
+ lfsck_namespace_name);
+ if (rc != 0)
+ GOTO(out, rc);
+
+ lfsck_object_put(env, com->lc_obj);
+ com->lc_obj = NULL;
+ dto = local_index_find_or_create(env, lfsck->li_los, root,
+ lfsck_namespace_name,
+ S_IFREG | S_IRUGO | S_IWUSR,
+ &dt_lfsck_features);
+ if (IS_ERR(dto))
+ GOTO(out, rc = PTR_ERR(dto));
+
+ com->lc_obj = dto;
+ rc = dto->do_ops->do_index_try(env, dto, &dt_lfsck_features);
+ if (rc != 0)
+ GOTO(out, rc);
+
+ lad->lad_incomplete = 0;
+ CFS_RESET_BITMAP(lad->lad_bitmap);
+
+ rc = lfsck_namespace_store(env, com, true);
+
+ GOTO(out, rc);
+
+out:
+ up_write(&com->lc_sem);
+
+put:
+ lu_object_put(env, &root->do_lu);
+log:
+ CDEBUG(D_LFSCK, "%s: namespace LFSCK reset: rc = %d\n",
+ lfsck_lfsck2name(lfsck), rc);
+ return rc;
+}
+
+static void
+lfsck_namespace_fail(const struct lu_env *env, struct lfsck_component *com,
+ bool new_checked)
+{
+ struct lfsck_namespace *ns = com->lc_file_ram;
+
+ down_write(&com->lc_sem);
+ if (new_checked)
+ com->lc_new_checked++;
+ lfsck_namespace_record_failure(env, com->lc_lfsck, ns);
+ up_write(&com->lc_sem);
+}
+
+static void lfsck_namespace_close_dir(const struct lu_env *env,
+ struct lfsck_component *com)
+{
+ struct lfsck_namespace *ns = com->lc_file_ram;
+ struct lfsck_assistant_data *lad = com->lc_data;
+ struct lfsck_instance *lfsck = com->lc_lfsck;
+ struct lfsck_lmv *llmv = lfsck->li_lmv;
+ struct lfsck_namespace_req *lnr;
+ __u32 size =
+ sizeof(*lnr) + LFSCK_TMPBUF_LEN;
+ bool wakeup = false;
+ ENTRY;
+
+ if (llmv == NULL)
+ RETURN_EXIT;
+
+ OBD_ALLOC(lnr, size);
+ if (lnr == NULL) {
+ ns->ln_striped_dirs_skipped++;
+
+ RETURN_EXIT;
+ }
+
+ /* Generate a dummy request to indicate that all shards' name entry
+ * in this striped directory has been scanned for the first time. */
+ INIT_LIST_HEAD(&lnr->lnr_lar.lar_list);
+ lnr->lnr_obj = lfsck_object_get(lfsck->li_obj_dir);
+ lnr->lnr_lmv = lfsck_lmv_get(llmv);
+ lnr->lnr_fid = *lfsck_dto2fid(lfsck->li_obj_dir);
+ lnr->lnr_oit_cookie = lfsck->li_pos_current.lp_oit_cookie;
+ lnr->lnr_dir_cookie = MDS_DIR_END_OFF;
+ lnr->lnr_size = size;
+
+ spin_lock(&lad->lad_lock);
+ if (lad->lad_assistant_status < 0) {
+ spin_unlock(&lad->lad_lock);
+ lfsck_namespace_assistant_req_fini(env, &lnr->lnr_lar);
+ ns->ln_striped_dirs_skipped++;
+
+ RETURN_EXIT;
+ }
+
+ list_add_tail(&lnr->lnr_lar.lar_list, &lad->lad_req_list);
+ if (lad->lad_prefetched == 0)
+ wakeup = true;
+
+ lad->lad_prefetched++;
+ spin_unlock(&lad->lad_lock);
+ if (wakeup)
+ wake_up_all(&lad->lad_thread.t_ctl_waitq);
+
+ EXIT;
+}
+
+static int lfsck_namespace_open_dir(const struct lu_env *env,
+ struct lfsck_component *com)
+{
+ struct lfsck_instance *lfsck = com->lc_lfsck;
+ struct lfsck_namespace *ns = com->lc_file_ram;
+ struct lfsck_lmv *llmv = lfsck->li_lmv;
+ int rc = 0;
+ ENTRY;
+
+ if (llmv == NULL)
+ RETURN(0);
+
+ if (llmv->ll_lmv_master) {
+ struct lmv_mds_md_v1 *lmv = &llmv->ll_lmv;
+
+ if (lmv->lmv_master_mdt_index !=
+ lfsck_dev_idx(lfsck->li_bottom)) {
+ lmv->lmv_master_mdt_index =
+ lfsck_dev_idx(lfsck->li_bottom);
+ ns->ln_flags |= LF_INCONSISTENT;
+ llmv->ll_lmv_updated = 1;
+ }
+ } else {
+ rc = lfsck_namespace_verify_stripe_slave(env, com,
+ lfsck->li_obj_dir, llmv);
+ }
+
+ RETURN(rc > 0 ? 0 : rc);
+}
+
+static int lfsck_namespace_checkpoint(const struct lu_env *env,
+ struct lfsck_component *com, bool init)
+{
+ struct lfsck_instance *lfsck = com->lc_lfsck;
+ struct lfsck_namespace *ns = com->lc_file_ram;
+ int rc;
+
+ if (!init) {
+ rc = lfsck_checkpoint_generic(env, com);
+ if (rc != 0)
+ goto log;
+ }
+
+ down_write(&com->lc_sem);
+ if (init) {
+ ns->ln_pos_latest_start = lfsck->li_pos_checkpoint;
+ } else {
+ ns->ln_pos_last_checkpoint = lfsck->li_pos_checkpoint;
+ ns->ln_run_time_phase1 += cfs_duration_sec(cfs_time_current() +
+ HALF_SEC - lfsck->li_time_last_checkpoint);
+ ns->ln_time_last_checkpoint = cfs_time_current_sec();
+ ns->ln_items_checked += com->lc_new_checked;
+ com->lc_new_checked = 0;
+ }
+
+ rc = lfsck_namespace_store(env, com, false);
+ up_write(&com->lc_sem);
+
+log:
+ CDEBUG(D_LFSCK, "%s: namespace LFSCK checkpoint at the pos ["LPU64
+ ", "DFID", "LPX64"]: rc = %d\n", lfsck_lfsck2name(lfsck),
+ lfsck->li_pos_current.lp_oit_cookie,
+ PFID(&lfsck->li_pos_current.lp_dir_parent),
+ lfsck->li_pos_current.lp_dir_cookie, rc);
+
+ return rc > 0 ? 0 : rc;
+}
+
+static int lfsck_namespace_prep(const struct lu_env *env,
+ struct lfsck_component *com,
+ struct lfsck_start_param *lsp)
+{
+ struct lfsck_instance *lfsck = com->lc_lfsck;
+ struct lfsck_namespace *ns = com->lc_file_ram;
+ struct lfsck_position *pos = &com->lc_pos_start;
+ int rc;
+
+ rc = lfsck_namespace_load_bitmap(env, com);
+ if (rc != 0 || ns->ln_status == LS_COMPLETED) {
+ rc = lfsck_namespace_reset(env, com, false);
+ if (rc == 0)
+ rc = lfsck_set_param(env, lfsck, lsp->lsp_start, true);
+
+ if (rc != 0) {
+ CDEBUG(D_LFSCK, "%s: namespace LFSCK prep failed: "
+ "rc = %d\n", lfsck_lfsck2name(lfsck), rc);
+
+ return rc;
+ }
+ }
+
+ down_write(&com->lc_sem);
+ ns->ln_time_latest_start = cfs_time_current_sec();
+ spin_lock(&lfsck->li_lock);
+
+ if (ns->ln_flags & LF_SCANNED_ONCE) {
+ if (!lfsck->li_drop_dryrun ||
+ lfsck_pos_is_zero(&ns->ln_pos_first_inconsistent)) {
+ ns->ln_status = LS_SCANNING_PHASE2;
+ list_move_tail(&com->lc_link,
+ &lfsck->li_list_double_scan);
+ if (!list_empty(&com->lc_link_dir))
+ list_del_init(&com->lc_link_dir);
+ lfsck_pos_set_zero(pos);
+ } else {
+ ns->ln_status = LS_SCANNING_PHASE1;
+ ns->ln_run_time_phase1 = 0;
+ ns->ln_run_time_phase2 = 0;
+ ns->ln_items_checked = 0;
+ ns->ln_items_repaired = 0;
+ ns->ln_items_failed = 0;
+ ns->ln_dirs_checked = 0;
+ ns->ln_objs_checked_phase2 = 0;
+ ns->ln_objs_repaired_phase2 = 0;
+ ns->ln_objs_failed_phase2 = 0;
+ ns->ln_objs_nlink_repaired = 0;
+ ns->ln_dirent_repaired = 0;
+ ns->ln_linkea_repaired = 0;
+ ns->ln_mul_linked_checked = 0;
+ ns->ln_mul_linked_repaired = 0;
+ ns->ln_unknown_inconsistency = 0;
+ ns->ln_unmatched_pairs_repaired = 0;
+ ns->ln_dangling_repaired = 0;
+ ns->ln_mul_ref_repaired = 0;
+ ns->ln_bad_type_repaired = 0;
+ ns->ln_lost_dirent_repaired = 0;
+ ns->ln_striped_dirs_scanned = 0;
+ ns->ln_striped_dirs_repaired = 0;
+ ns->ln_striped_dirs_failed = 0;
+ ns->ln_striped_dirs_disabled = 0;
+ ns->ln_striped_dirs_skipped = 0;
+ ns->ln_striped_shards_scanned = 0;
+ ns->ln_striped_shards_repaired = 0;
+ ns->ln_striped_shards_failed = 0;
+ ns->ln_striped_shards_skipped = 0;
+ ns->ln_name_hash_repaired = 0;
+ fid_zero(&ns->ln_fid_latest_scanned_phase2);
+ if (list_empty(&com->lc_link_dir))
+ list_add_tail(&com->lc_link_dir,
+ &lfsck->li_list_dir);
+ *pos = ns->ln_pos_first_inconsistent;
+ }
+ } else {
+ ns->ln_status = LS_SCANNING_PHASE1;
+ if (list_empty(&com->lc_link_dir))
+ list_add_tail(&com->lc_link_dir,
+ &lfsck->li_list_dir);
+ if (!lfsck->li_drop_dryrun ||
+ lfsck_pos_is_zero(&ns->ln_pos_first_inconsistent)) {
+ *pos = ns->ln_pos_last_checkpoint;
+ pos->lp_oit_cookie++;
+ } else {
+ *pos = ns->ln_pos_first_inconsistent;
+ }
+ }
+
+ spin_unlock(&lfsck->li_lock);
+ up_write(&com->lc_sem);
+
+ rc = lfsck_start_assistant(env, com, lsp);
+
+ CDEBUG(D_LFSCK, "%s: namespace LFSCK prep done, start pos ["LPU64", "
+ DFID", "LPX64"]: rc = %d\n",
+ lfsck_lfsck2name(lfsck), pos->lp_oit_cookie,
+ PFID(&pos->lp_dir_parent), pos->lp_dir_cookie, rc);
+
+ return rc;
+}
+
+static int lfsck_namespace_exec_oit(const struct lu_env *env,
+ struct lfsck_component *com,
+ struct dt_object *obj)
+{
+ struct lfsck_thread_info *info = lfsck_env_info(env);
+ struct lfsck_namespace *ns = com->lc_file_ram;
+ struct lfsck_instance *lfsck = com->lc_lfsck;
+ const struct lu_fid *fid = lfsck_dto2fid(obj);
+ struct lu_attr *la = &info->lti_la;
+ struct lu_fid *pfid = &info->lti_fid2;
+ struct lu_name *cname = &info->lti_name;
+ struct lu_seq_range *range = &info->lti_range;
+ struct dt_device *dev = lfsck->li_bottom;
+ struct seq_server_site *ss =
+ lu_site2seq(dev->dd_lu_dev.ld_site);
+ struct linkea_data ldata = { 0 };
+ __u32 idx = lfsck_dev_idx(dev);
+ int rc;
+ ENTRY;
+
+ rc = lfsck_links_read(env, obj, &ldata);
+ if (rc == -ENOENT)
+ GOTO(out, rc = 0);
+
+ /* -EINVAL means crashed linkEA, should be verified. */
+ if (rc == -EINVAL) {
+ rc = lfsck_namespace_trace_update(env, com, fid,
+ LNTF_CHECK_LINKEA, true);
+ if (rc == 0) {
+ struct lustre_handle lh = { 0 };
+
+ rc = lfsck_ibits_lock(env, lfsck, obj, &lh,
+ MDS_INODELOCK_UPDATE |
+ MDS_INODELOCK_XATTR, LCK_EX);
+ if (rc == 0) {
+ rc = lfsck_namespace_links_remove(env, com,
+ obj);
+ lfsck_ibits_unlock(&lh, LCK_EX);
+ }
+ }
+
+ GOTO(out, rc = (rc == -ENOENT ? 0 : rc));
+ }
+
+ /* zero-linkEA object may be orphan, but it also maybe because
+ * of upgrading. Currently, we cannot record it for double scan.
+ * Because it may cause the LFSCK trace file to be too large. */
+ if (rc == -ENODATA) {
+ if (S_ISDIR(lfsck_object_type(obj)))
+ GOTO(out, rc = 0);
+
+ rc = dt_attr_get(env, obj, la, BYPASS_CAPA);
+ if (rc != 0)
+ GOTO(out, rc);
+
+ /* "la_ctime" == 1 means that it has ever been removed from
+ * backend /lost+found directory but not been added back to
+ * the normal namespace yet. */
+ if (la->la_nlink > 1 || unlikely(la->la_ctime == 1))
+ rc = lfsck_namespace_trace_update(env, com, fid,
+ LNTF_CHECK_LINKEA, true);
+
+ GOTO(out, rc);
+ }
+
+ if (rc != 0)
+ GOTO(out, rc);
+
+ /* Record multiple-linked object. */
+ if (ldata.ld_leh->leh_reccount > 1) {
+ rc = lfsck_namespace_trace_update(env, com, fid,
+ LNTF_CHECK_LINKEA, true);
+
+ GOTO(out, rc);
+ }
+
+ linkea_first_entry(&ldata);
+ linkea_entry_unpack(ldata.ld_lee, &ldata.ld_reclen, cname, pfid);
+ if (!fid_is_sane(pfid)) {
+ rc = lfsck_namespace_trace_update(env, com, fid,
+ LNTF_CHECK_PARENT, true);
+ } else {
+ fld_range_set_mdt(range);
+ rc = fld_local_lookup(env, ss->ss_server_fld,
+ fid_seq(pfid), range);
+ if ((rc == -ENOENT) ||
+ (rc == 0 && range->lsr_index != idx)) {
+ rc = lfsck_namespace_trace_update(env, com, fid,
+ LNTF_CHECK_LINKEA, true);
+ } else {
+ if (S_ISDIR(lfsck_object_type(obj)))
+ GOTO(out, rc = 0);
+
+ rc = dt_attr_get(env, obj, la, BYPASS_CAPA);
+ if (rc != 0)
+ GOTO(out, rc);
+
+ /* "la_ctime" == 1 means that it has ever been
+ * removed from backend /lost+found directory but
+ * not been added back to the normal namespace yet. */
+ if (la->la_nlink > 1 || unlikely(la->la_ctime == 1))
+ rc = lfsck_namespace_trace_update(env, com,
+ fid, LNTF_CHECK_LINKEA, true);
+ }
+ }
+
+ GOTO(out, rc);
+
+out:
+ down_write(&com->lc_sem);
+ com->lc_new_checked++;
+ if (S_ISDIR(lfsck_object_type(obj)))
+ ns->ln_dirs_checked++;
+ if (rc != 0)
+ lfsck_namespace_record_failure(env, com->lc_lfsck, ns);
+ up_write(&com->lc_sem);
+
+ return rc;
+}
+
+static int lfsck_namespace_exec_dir(const struct lu_env *env,
+ struct lfsck_component *com,
+ struct lu_dirent *ent, __u16 type)
+{
+ struct lfsck_assistant_data *lad = com->lc_data;
+ struct lfsck_namespace_req *lnr;
+ bool wakeup = false;
+
+ lnr = lfsck_namespace_assistant_req_init(com->lc_lfsck, ent, type);
+ if (IS_ERR(lnr)) {
+ struct lfsck_namespace *ns = com->lc_file_ram;
+
+ lfsck_namespace_record_failure(env, com->lc_lfsck, ns);
+ return PTR_ERR(lnr);
+ }
+
+ spin_lock(&lad->lad_lock);
+ if (lad->lad_assistant_status < 0) {
+ spin_unlock(&lad->lad_lock);
+ lfsck_namespace_assistant_req_fini(env, &lnr->lnr_lar);
+ return lad->lad_assistant_status;
+ }
+
+ list_add_tail(&lnr->lnr_lar.lar_list, &lad->lad_req_list);
+ if (lad->lad_prefetched == 0)
+ wakeup = true;
+
+ lad->lad_prefetched++;
+ spin_unlock(&lad->lad_lock);
+ if (wakeup)
+ wake_up_all(&lad->lad_thread.t_ctl_waitq);
+
+ down_write(&com->lc_sem);
+ com->lc_new_checked++;
+ up_write(&com->lc_sem);
+
+ return 0;
+}
+
+static int lfsck_namespace_post(const struct lu_env *env,
+ struct lfsck_component *com,
+ int result, bool init)
+{
+ struct lfsck_instance *lfsck = com->lc_lfsck;
+ struct lfsck_namespace *ns = com->lc_file_ram;
+ int rc;
+ ENTRY;
+
+ lfsck_post_generic(env, com, &result);
+
+ down_write(&com->lc_sem);
+ lfsck_namespace_release_lmv(env, com);
+
+ spin_lock(&lfsck->li_lock);
+ if (!init)
+ ns->ln_pos_last_checkpoint = lfsck->li_pos_checkpoint;
+ if (result > 0) {
+ ns->ln_status = LS_SCANNING_PHASE2;
+ ns->ln_flags |= LF_SCANNED_ONCE;
+ ns->ln_flags &= ~LF_UPGRADE;
+ list_del_init(&com->lc_link_dir);
+ list_move_tail(&com->lc_link, &lfsck->li_list_double_scan);
+ } else if (result == 0) {
+ if (lfsck->li_status != 0)
+ ns->ln_status = lfsck->li_status;
+ else
+ ns->ln_status = LS_STOPPED;
+ if (ns->ln_status != LS_PAUSED) {
+ list_del_init(&com->lc_link_dir);
+ list_move_tail(&com->lc_link, &lfsck->li_list_idle);
+ }
+ } else {
+ ns->ln_status = LS_FAILED;
+ list_del_init(&com->lc_link_dir);
+ list_move_tail(&com->lc_link, &lfsck->li_list_idle);
+ }
+ spin_unlock(&lfsck->li_lock);
+
+ if (!init) {
+ ns->ln_run_time_phase1 += cfs_duration_sec(cfs_time_current() +
+ HALF_SEC - lfsck->li_time_last_checkpoint);
+ ns->ln_time_last_checkpoint = cfs_time_current_sec();
+ ns->ln_items_checked += com->lc_new_checked;
+ com->lc_new_checked = 0;
+ }
+
+ rc = lfsck_namespace_store(env, com, false);
+ up_write(&com->lc_sem);
+
+ CDEBUG(D_LFSCK, "%s: namespace LFSCK post done: rc = %d\n",
+ lfsck_lfsck2name(lfsck), rc);
+
+ RETURN(rc);
+}
+
+static int
+lfsck_namespace_dump(const struct lu_env *env, struct lfsck_component *com,
+ struct seq_file *m)
+{
+ struct lfsck_instance *lfsck = com->lc_lfsck;
+ struct lfsck_bookmark *bk = &lfsck->li_bookmark_ram;
+ struct lfsck_namespace *ns = com->lc_file_ram;
+ int rc;
+
+ down_read(&com->lc_sem);
+ seq_printf(m, "name: lfsck_namespace\n"
+ "magic: %#x\n"
+ "version: %d\n"
+ "status: %s\n",
+ ns->ln_magic,
+ bk->lb_version,
+ lfsck_status2names(ns->ln_status));
+
+ rc = lfsck_bits_dump(m, ns->ln_flags, lfsck_flags_names, "flags");
+ if (rc < 0)
+ goto out;
+
+ rc = lfsck_bits_dump(m, bk->lb_param, lfsck_param_names, "param");
+ if (rc < 0)
+ goto out;
+
+ rc = lfsck_time_dump(m, ns->ln_time_last_complete,
+ "time_since_last_completed");
+ if (rc < 0)
+ goto out;
+
+ rc = lfsck_time_dump(m, ns->ln_time_latest_start,
+ "time_since_latest_start");
+ if (rc < 0)
+ goto out;
+
+ rc = lfsck_time_dump(m, ns->ln_time_last_checkpoint,
+ "time_since_last_checkpoint");
+ if (rc < 0)
+ goto out;
+
+ rc = lfsck_pos_dump(m, &ns->ln_pos_latest_start,
+ "latest_start_position");
+ if (rc < 0)
+ goto out;
+
+ rc = lfsck_pos_dump(m, &ns->ln_pos_last_checkpoint,
+ "last_checkpoint_position");
+ if (rc < 0)
+ goto out;
+
+ rc = lfsck_pos_dump(m, &ns->ln_pos_first_inconsistent,
+ "first_failure_position");
+ if (rc < 0)
+ goto out;
+
+ if (ns->ln_status == LS_SCANNING_PHASE1) {
+ struct lfsck_position pos;
+ const struct dt_it_ops *iops;
+ cfs_duration_t duration = cfs_time_current() -
+ lfsck->li_time_last_checkpoint;
+ __u64 checked = ns->ln_items_checked + com->lc_new_checked;
+ __u64 speed = checked;
+ __u64 new_checked = msecs_to_jiffies(com->lc_new_checked *
+ MSEC_PER_SEC);
+ __u32 rtime = ns->ln_run_time_phase1 +
+ cfs_duration_sec(duration + HALF_SEC);
+
+ if (duration != 0)
+ do_div(new_checked, duration);
+ if (rtime != 0)
+ do_div(speed, rtime);
+ lfsck_namespace_dump_statistics(m, ns, checked,
+ ns->ln_objs_checked_phase2,
+ rtime, ns->ln_run_time_phase2);
+
+ seq_printf(m, "average_speed_phase1: "LPU64" items/sec\n"
+ "average_speed_phase2: N/A\n"
+ "real_time_speed_phase1: "LPU64" items/sec\n"
+ "real_time_speed_phase2: N/A\n",
+ speed,
+ new_checked);
+
+ LASSERT(lfsck->li_di_oit != NULL);
+
+ iops = &lfsck->li_obj_oit->do_index_ops->dio_it;
+
+ /* The low layer otable-based iteration position may NOT
+ * exactly match the namespace-based directory traversal
+ * cookie. Generally, it is not a serious issue. But the
+ * caller should NOT make assumption on that. */
+ pos.lp_oit_cookie = iops->store(env, lfsck->li_di_oit);
+ if (!lfsck->li_current_oit_processed)
+ pos.lp_oit_cookie--;
+
+ spin_lock(&lfsck->li_lock);
+ if (lfsck->li_di_dir != NULL) {
+ pos.lp_dir_cookie = lfsck->li_cookie_dir;
+ if (pos.lp_dir_cookie >= MDS_DIR_END_OFF) {
+ fid_zero(&pos.lp_dir_parent);
+ pos.lp_dir_cookie = 0;
+ } else {
+ pos.lp_dir_parent =
+ *lfsck_dto2fid(lfsck->li_obj_dir);
+ }
+ } else {
+ fid_zero(&pos.lp_dir_parent);
+ pos.lp_dir_cookie = 0;
+ }
+ spin_unlock(&lfsck->li_lock);
+ lfsck_pos_dump(m, &pos, "current_position");
+ } else if (ns->ln_status == LS_SCANNING_PHASE2) {
+ cfs_duration_t duration = cfs_time_current() -
+ lfsck->li_time_last_checkpoint;
+ __u64 checked = ns->ln_objs_checked_phase2 +
+ com->lc_new_checked;
+ __u64 speed1 = ns->ln_items_checked;
+ __u64 speed2 = checked;
+ __u64 new_checked = msecs_to_jiffies(com->lc_new_checked *
+ MSEC_PER_SEC);
+ __u32 rtime = ns->ln_run_time_phase2 +
+ cfs_duration_sec(duration + HALF_SEC);
+
+ if (duration != 0)
+ do_div(new_checked, duration);
+ if (ns->ln_run_time_phase1 != 0)
+ do_div(speed1, ns->ln_run_time_phase1);
+ if (rtime != 0)
+ do_div(speed2, rtime);
+ lfsck_namespace_dump_statistics(m, ns, ns->ln_items_checked,
+ checked,
+ ns->ln_run_time_phase1, rtime);
+
+ seq_printf(m, "average_speed_phase1: "LPU64" items/sec\n"
+ "average_speed_phase2: "LPU64" objs/sec\n"
+ "real_time_speed_phase1: N/A\n"
+ "real_time_speed_phase2: "LPU64" objs/sec\n"
+ "current_position: "DFID"\n",
+ speed1,
+ speed2,
+ new_checked,
+ PFID(&ns->ln_fid_latest_scanned_phase2));
+ } else {
+ __u64 speed1 = ns->ln_items_checked;
+ __u64 speed2 = ns->ln_objs_checked_phase2;
+
+ if (ns->ln_run_time_phase1 != 0)
+ do_div(speed1, ns->ln_run_time_phase1);
+ if (ns->ln_run_time_phase2 != 0)
+ do_div(speed2, ns->ln_run_time_phase2);
+ lfsck_namespace_dump_statistics(m, ns, ns->ln_items_checked,
+ ns->ln_objs_checked_phase2,
+ ns->ln_run_time_phase1,
+ ns->ln_run_time_phase2);
+
+ seq_printf(m, "average_speed_phase1: "LPU64" items/sec\n"
+ "average_speed_phase2: "LPU64" objs/sec\n"
+ "real_time_speed_phase1: N/A\n"
+ "real_time_speed_phase2: N/A\n"
+ "current_position: N/A\n",
+ speed1,
+ speed2);
+ }
+out:
+ up_read(&com->lc_sem);
+ return 0;
+}
+
+static int lfsck_namespace_double_scan(const struct lu_env *env,
+ struct lfsck_component *com)
+{
+ struct lfsck_namespace *ns = com->lc_file_ram;
+ struct lfsck_assistant_data *lad = com->lc_data;
+ struct lfsck_tgt_descs *ltds = &com->lc_lfsck->li_mdt_descs;
+ struct lfsck_tgt_desc *ltd;
+ struct lfsck_tgt_desc *next;
+ int rc;
+
+ rc = lfsck_double_scan_generic(env, com, ns->ln_status);
+ if (thread_is_stopped(&lad->lad_thread)) {
+ LASSERT(list_empty(&lad->lad_req_list));
+ LASSERT(list_empty(&lad->lad_mdt_phase1_list));
+
+ spin_lock(<ds->ltd_lock);
+ list_for_each_entry_safe(ltd, next, &lad->lad_mdt_phase2_list,
+ ltd_namespace_phase_list) {
+ list_del_init(<d->ltd_namespace_phase_list);
+ }
+ spin_unlock(<ds->ltd_lock);
+ }
+
+ return rc;
+}
+
+static void lfsck_namespace_data_release(const struct lu_env *env,
+ struct lfsck_component *com)
+{
+ struct lfsck_assistant_data *lad = com->lc_data;
+ struct lfsck_tgt_descs *ltds = &com->lc_lfsck->li_mdt_descs;
+ struct lfsck_tgt_desc *ltd;
+ struct lfsck_tgt_desc *next;
+
+ LASSERT(lad != NULL);
+ LASSERT(thread_is_init(&lad->lad_thread) ||
+ thread_is_stopped(&lad->lad_thread));
+ LASSERT(list_empty(&lad->lad_req_list));
+
+ com->lc_data = NULL;
+ lfsck_namespace_release_lmv(env, com);
+
+ spin_lock(<ds->ltd_lock);
+ list_for_each_entry_safe(ltd, next, &lad->lad_mdt_phase1_list,
+ ltd_namespace_phase_list) {
+ list_del_init(<d->ltd_namespace_phase_list);
+ }
+ list_for_each_entry_safe(ltd, next, &lad->lad_mdt_phase2_list,
+ ltd_namespace_phase_list) {
+ list_del_init(<d->ltd_namespace_phase_list);
+ }
+ list_for_each_entry_safe(ltd, next, &lad->lad_mdt_list,
+ ltd_namespace_list) {
+ list_del_init(<d->ltd_namespace_list);
+ }
+ spin_unlock(<ds->ltd_lock);
+
+ if (likely(lad->lad_bitmap != NULL))
+ CFS_FREE_BITMAP(lad->lad_bitmap);
+
+ OBD_FREE_PTR(lad);
+}
+
+static void lfsck_namespace_quit(const struct lu_env *env,
+ struct lfsck_component *com)
+{
+ struct lfsck_assistant_data *lad = com->lc_data;
+ struct lfsck_tgt_descs *ltds = &com->lc_lfsck->li_mdt_descs;
+ struct lfsck_tgt_desc *ltd;
+ struct lfsck_tgt_desc *next;
+
+ LASSERT(lad != NULL);
+
+ lfsck_quit_generic(env, com);
+
+ LASSERT(thread_is_init(&lad->lad_thread) ||
+ thread_is_stopped(&lad->lad_thread));
+ LASSERT(list_empty(&lad->lad_req_list));
+
+ lfsck_namespace_release_lmv(env, com);
+
+ spin_lock(<ds->ltd_lock);
+ list_for_each_entry_safe(ltd, next, &lad->lad_mdt_phase1_list,
+ ltd_namespace_phase_list) {
+ list_del_init(<d->ltd_namespace_phase_list);
+ }
+ list_for_each_entry_safe(ltd, next, &lad->lad_mdt_phase2_list,
+ ltd_namespace_phase_list) {
+ list_del_init(<d->ltd_namespace_phase_list);
+ }
+ spin_unlock(<ds->ltd_lock);
+}
+
+static int lfsck_namespace_in_notify(const struct lu_env *env,
+ struct lfsck_component *com,
+ struct lfsck_request *lr,
+ struct thandle *th)
+{
+ struct lfsck_instance *lfsck = com->lc_lfsck;
+ struct lfsck_namespace *ns = com->lc_file_ram;
+ struct lfsck_assistant_data *lad = com->lc_data;
+ struct lfsck_tgt_descs *ltds = &lfsck->li_mdt_descs;
+ struct lfsck_tgt_desc *ltd;
+ int rc;
+ bool fail = false;
+ ENTRY;
+
+ switch (lr->lr_event) {
+ case LE_CREATE_ORPHAN: {
+ struct dt_object *orphan = NULL;
+ struct lmv_mds_md_v1 *lmv;
+
+ CDEBUG(D_LFSCK, "%s: namespace LFSCK handling notify from "
+ "MDT %x to create orphan"DFID" with type %o\n",
+ lfsck_lfsck2name(lfsck), lr->lr_index,
+ PFID(&lr->lr_fid), lr->lr_type);
+
+ orphan = lfsck_object_find(env, lfsck, &lr->lr_fid);
+ if (IS_ERR(orphan))
+ GOTO(out_create, rc = PTR_ERR(orphan));
+
+ if (dt_object_exists(orphan))
+ GOTO(out_create, rc = -EEXIST);
+
+ if (lr->lr_stripe_count > 0) {
+ lmv = &lfsck_env_info(env)->lti_lmv;
+ memset(lmv, 0, sizeof(*lmv));
+ lmv->lmv_hash_type = lr->lr_hash_type;
+ lmv->lmv_stripe_count = lr->lr_stripe_count;
+ lmv->lmv_layout_version = lr->lr_layout_version;
+ memcpy(lmv->lmv_pool_name, lr->lr_pool_name,
+ sizeof(lmv->lmv_pool_name));
+ } else {
+ lmv = NULL;
+ }
+
+ rc = lfsck_namespace_create_orphan_local(env, com, orphan,
+ lr->lr_type, lmv);
+
+ GOTO(out_create, rc = (rc == 1) ? 0 : rc);
+
+out_create:
+ CDEBUG(D_LFSCK, "%s: namespace LFSCK handled notify from "
+ "MDT %x to create orphan"DFID" with type %o: rc = %d\n",
+ lfsck_lfsck2name(lfsck), lr->lr_index,
+ PFID(&lr->lr_fid), lr->lr_type, rc);
+
+ if (orphan != NULL && !IS_ERR(orphan))
+ lfsck_object_put(env, orphan);
+
+ return rc;
+ }
+ case LE_SKIP_NLINK_DECLARE: {
+ struct dt_object *obj = com->lc_obj;
+ struct lu_fid *key = &lfsck_env_info(env)->lti_fid3;
+ __u8 flags = 0;
+
+ LASSERT(th != NULL);
+
+ rc = dt_declare_delete(env, obj,
+ (const struct dt_key *)key, th);
+ if (rc == 0)
+ rc = dt_declare_insert(env, obj,
+ (const struct dt_rec *)&flags,
+ (const struct dt_key *)key, th);
+
+ RETURN(rc);
+ }
+ case LE_SKIP_NLINK: {
+ struct dt_object *obj = com->lc_obj;
+ struct lu_fid *key = &lfsck_env_info(env)->lti_fid3;
+ __u8 flags = 0;
+ bool exist = false;
+ ENTRY;
+
+ LASSERT(th != NULL);
+
+ fid_cpu_to_be(key, &lr->lr_fid);
+ rc = dt_lookup(env, obj, (struct dt_rec *)&flags,
+ (const struct dt_key *)key, BYPASS_CAPA);
+ if (rc == 0) {
+ if (flags & LNTF_SKIP_NLINK)
+ RETURN(0);
+
+ exist = true;
+ } else if (rc != -ENOENT) {
+ GOTO(log, rc);
+ }
+
+ flags |= LNTF_SKIP_NLINK;
+ if (exist) {
+ rc = dt_delete(env, obj, (const struct dt_key *)key,
+ th, BYPASS_CAPA);
+ if (rc != 0)
+ GOTO(log, rc);
+ }
+
+ rc = dt_insert(env, obj, (const struct dt_rec *)&flags,
+ (const struct dt_key *)key, th, BYPASS_CAPA, 1);
+
+ GOTO(log, rc);
+
+log:
+ CDEBUG(D_LFSCK, "%s: RPC service thread mark the "DFID
+ " to be skipped for namespace double scan: rc = %d\n",
+ lfsck_lfsck2name(com->lc_lfsck), PFID(&lr->lr_fid), rc);
+
+ if (rc != 0)
+ /* If we cannot record this object in the LFSCK tracing,
+ * we have to mark the LFSC as LF_INCOMPLETE, then the
+ * LFSCK will skip nlink attribute verification for
+ * all objects. */
+ ns->ln_flags |= LF_INCOMPLETE;
+
+ return 0;
+ }
+ case LE_SET_LMV_MASTER: {
+ struct dt_object *obj;
+
+ obj = lfsck_object_find_by_dev(env, lfsck->li_bottom,
+ &lr->lr_fid);
+ if (IS_ERR(obj))
+ RETURN(PTR_ERR(obj));
+
+ rc = lfsck_namespace_notify_lmv_master_local(env, com, obj);
+ lfsck_object_put(env, obj);
+
+ RETURN(rc > 0 ? 0 : rc);
+ }
+ case LE_SET_LMV_SLAVE: {
+ if (!(lr->lr_flags & LEF_RECHECK_NAME_HASH))
+ ns->ln_striped_shards_repaired++;
+
+ rc = lfsck_namespace_trace_update(env, com, &lr->lr_fid,
+ LNTF_RECHECK_NAME_HASH, true);
+
+ RETURN(rc > 0 ? 0 : rc);
+ }
+ case LE_PHASE1_DONE:
+ case LE_PHASE2_DONE:
+ case LE_PEER_EXIT:
+ break;
+ default:
+ RETURN(-EINVAL);
+ }
+
+ CDEBUG(D_LFSCK, "%s: namespace LFSCK handles notify %u from MDT %x, "
+ "status %d, flags %x\n", lfsck_lfsck2name(lfsck), lr->lr_event,
+ lr->lr_index, lr->lr_status, lr->lr_flags2);
+
+ spin_lock(<ds->ltd_lock);
+ ltd = LTD_TGT(ltds, lr->lr_index);
+ if (ltd == NULL) {
+ spin_unlock(<ds->ltd_lock);
+
+ RETURN(-ENXIO);
+ }
+
+ list_del_init(<d->ltd_namespace_phase_list);
+ switch (lr->lr_event) {
+ case LE_PHASE1_DONE:
+ if (lr->lr_status <= 0) {
+ ltd->ltd_namespace_done = 1;
+ list_del_init(<d->ltd_namespace_list);
+ CDEBUG(D_LFSCK, "%s: MDT %x failed/stopped at "
+ "phase1 for namespace LFSCK: rc = %d.\n",
+ lfsck_lfsck2name(lfsck),
+ ltd->ltd_index, lr->lr_status);
+ ns->ln_flags |= LF_INCOMPLETE;
+ fail = true;
+ break;
+ }
+
+ if (lr->lr_flags2 & LF_INCOMPLETE)
+ ns->ln_flags |= LF_INCOMPLETE;
+
+ if (list_empty(<d->ltd_namespace_list))
+ list_add_tail(<d->ltd_namespace_list,
+ &lad->lad_mdt_list);
+ list_add_tail(<d->ltd_namespace_phase_list,
+ &lad->lad_mdt_phase2_list);
+ break;
+ case LE_PHASE2_DONE:
+ ltd->ltd_namespace_done = 1;
+ list_del_init(<d->ltd_namespace_list);
+ break;
+ case LE_PEER_EXIT:
+ fail = true;
+ ltd->ltd_namespace_done = 1;
+ list_del_init(<d->ltd_namespace_list);
+ if (!(lfsck->li_bookmark_ram.lb_param & LPF_FAILOUT)) {
+ CDEBUG(D_LFSCK,
+ "%s: the peer MDT %x exit namespace LFSCK\n",
+ lfsck_lfsck2name(lfsck), ltd->ltd_index);
+ ns->ln_flags |= LF_INCOMPLETE;
+ }
+ break;
+ default:
+ break;
+ }
+ spin_unlock(<ds->ltd_lock);
+
+ if (fail && lfsck->li_bookmark_ram.lb_param & LPF_FAILOUT) {
+ struct lfsck_stop *stop = &lfsck_env_info(env)->lti_stop;
+
+ memset(stop, 0, sizeof(*stop));
+ stop->ls_status = lr->lr_status;
+ stop->ls_flags = lr->lr_param & ~LPF_BROADCAST;
+ lfsck_stop(env, lfsck->li_bottom, stop);
+ } else if (lfsck_phase2_next_ready(lad)) {
+ wake_up_all(&lad->lad_thread.t_ctl_waitq);
+ }
+
+ RETURN(0);
+}
+
+static int lfsck_namespace_query(const struct lu_env *env,
+ struct lfsck_component *com)
+{
+ struct lfsck_namespace *ns = com->lc_file_ram;
+
+ return ns->ln_status;
+}
+
+static struct lfsck_operations lfsck_namespace_ops = {
+ .lfsck_reset = lfsck_namespace_reset,
+ .lfsck_fail = lfsck_namespace_fail,
+ .lfsck_close_dir = lfsck_namespace_close_dir,
+ .lfsck_open_dir = lfsck_namespace_open_dir,
+ .lfsck_checkpoint = lfsck_namespace_checkpoint,
+ .lfsck_prep = lfsck_namespace_prep,
+ .lfsck_exec_oit = lfsck_namespace_exec_oit,
+ .lfsck_exec_dir = lfsck_namespace_exec_dir,
+ .lfsck_post = lfsck_namespace_post,
+ .lfsck_dump = lfsck_namespace_dump,
+ .lfsck_double_scan = lfsck_namespace_double_scan,
+ .lfsck_data_release = lfsck_namespace_data_release,
+ .lfsck_quit = lfsck_namespace_quit,
+ .lfsck_in_notify = lfsck_namespace_in_notify,
+ .lfsck_query = lfsck_namespace_query,
+};
+
+/**
+ * Repair dangling name entry.
+ *
+ * For the name entry with dangling reference, we need to repare the
+ * inconsistency according to the LFSCK sponsor's requirement:
+ *
+ * 1) Keep the inconsistency there and report the inconsistency case,
+ * then give the chance to the application to find related issues,
+ * and the users can make the decision about how to handle it with
+ * more human knownledge. (by default)
+ *
+ * 2) Re-create the missing MDT-object with the FID information.
+ *
+ * \param[in] env pointer to the thread context
+ * \param[in] com pointer to the lfsck component
+ * \param[in] child pointer to the object corresponding to the dangling
+ * name entry
+ * \param[in] lnr pointer to the namespace request that contains the
+ * name's name, parent object, parent's LMV, and ect.
+ *