* GPL HEADER END
*/
/*
- * Copyright (c) 2012, Intel Corporation.
+ * Copyright (c) 2012, 2013, Intel Corporation.
*/
/*
* lustre/mdd/mdd_lfsck.c
#define HALF_SEC (CFS_HZ >> 1)
#define LFSCK_CHECKPOINT_INTERVAL 60
-#define MDS_DIR_DUMMY_START 0xffffffffffffffffULL
#define LFSCK_NAMEENTRY_DEAD 1 /* The object has been unlinked. */
#define LFSCK_NAMEENTRY_REMOVED 2 /* The entry has been removed. */
}
static void mdd_lfsck_pos_fill(const struct lu_env *env, struct md_lfsck *lfsck,
- struct lfsck_position *pos, bool oit_processed,
- bool dir_processed)
+ struct lfsck_position *pos, bool init)
{
const struct dt_it_ops *iops = &lfsck->ml_obj_oit->do_index_ops->dio_it;
}
pos->lp_oit_cookie = iops->store(env, lfsck->ml_di_oit);
+ if (!lfsck->ml_current_oit_processed && !init)
+ pos->lp_oit_cookie--;
LASSERT(pos->lp_oit_cookie > 0);
- if (!oit_processed)
- pos->lp_oit_cookie--;
-
if (lfsck->ml_di_dir != NULL) {
struct dt_object *dto = lfsck->ml_obj_dir;
- pos->lp_dir_parent = *lu_object_fid(&dto->do_lu);
pos->lp_dir_cookie = dto->do_index_ops->dio_it.store(env,
lfsck->ml_di_dir);
- LASSERT(pos->lp_dir_cookie != MDS_DIR_DUMMY_START);
-
- if (pos->lp_dir_cookie == MDS_DIR_END_OFF)
- LASSERT(dir_processed);
-
- /* For the dir which just to be processed,
- * lp_dir_cookie will become MDS_DIR_DUMMY_START,
- * which can be correctly handled by mdd_lfsck_prep. */
- if (!dir_processed)
- pos->lp_dir_cookie--;
+ 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 = *lu_object_fid(&dto->do_lu);
+ }
} else {
fid_zero(&pos->lp_dir_parent);
pos->lp_dir_cookie = 0;
struct lfsck_bookmark *mb = &lfsck->ml_bookmark_ram;
int rc;
- memset(mb, 0, sizeof(mb));
+ memset(mb, 0, sizeof(*mb));
mb->lb_magic = LFSCK_BOOKMARK_MAGIC;
mb->lb_version = LFSCK_VERSION_V2;
mutex_lock(&lfsck->ml_mutex);
return rc;
}
-static int mdd_declare_lfsck_namespace_unlink(const struct lu_env *env,
- struct mdd_device *mdd,
- struct dt_object *p,
- struct dt_object *c,
- const char *name,
- struct thandle *handle)
-{
- int rc;
-
- rc = dt_declare_delete(env, p, (const struct dt_key *)name, handle);
- if (rc != 0)
- return rc;
-
- rc = dt_declare_ref_del(env, c, handle);
- if (rc != 0)
- return rc;
-
- rc = dt_declare_destroy(env, c, handle);
- return rc;
-}
-
-static int mdd_lfsck_namespace_unlink(const struct lu_env *env,
- struct mdd_device *mdd,
- struct lfsck_component *com)
-{
- struct mdd_thread_info *info = mdd_env_info(env);
- struct lu_fid *fid = &info->mti_fid;
- struct dt_object *child = com->lc_obj;
- struct dt_object *parent;
- struct thandle *handle;
- bool locked = false;
- int rc;
- ENTRY;
-
- parent = dt_store_resolve(env, mdd->mdd_bottom, "", fid);
- if (IS_ERR(parent))
- RETURN(rc = PTR_ERR(parent));
-
- if (!dt_try_as_dir(env, parent))
- GOTO(out, rc = -ENOTDIR);
-
- handle = dt_trans_create(env, mdd->mdd_bottom);
- if (IS_ERR(handle))
- GOTO(out, rc = PTR_ERR(handle));
-
- rc = mdd_declare_lfsck_namespace_unlink(env, mdd, parent, child,
- lfsck_namespace_name, handle);
- if (rc != 0)
- GOTO(stop, rc);
-
- rc = dt_trans_start_local(env, mdd->mdd_bottom, handle);
- if (rc != 0)
- GOTO(stop, rc);
-
- dt_write_lock(env, child, MOR_TGT_CHILD);
- locked = true;
- rc = dt_delete(env, parent, (struct dt_key *)lfsck_namespace_name,
- handle, BYPASS_CAPA);
- if (rc != 0)
- GOTO(stop, rc);
-
- rc = child->do_ops->do_ref_del(env, child, handle);
- if (rc != 0) {
- lu_local_obj_fid(fid, LFSCK_NAMESPACE_OID);
- rc = dt_insert(env, parent,
- (const struct dt_rec*)fid,
- (const struct dt_key *)lfsck_namespace_name,
- handle, BYPASS_CAPA, 1);
-
- GOTO(stop, rc);
- }
-
-
- rc = dt_destroy(env, child, handle);
-
- GOTO(stop, rc);
-
-stop:
- if (locked)
- dt_write_unlock(env, child);
-
- if (rc == 0) {
- lu_object_put(env, &child->do_lu);
- com->lc_obj = NULL;
- }
-
- dt_trans_stop(env, mdd->mdd_bottom, handle);
-
-out:
- lu_object_put(env, &parent->do_lu);
- return rc;
-}
-
static int mdd_lfsck_namespace_lookup(const struct lu_env *env,
struct lfsck_component *com,
const struct lu_fid *fid,
struct lfsck_bookmark *bk = &lfsck->ml_bookmark_ram;
struct lfsck_namespace *ns =
(struct lfsck_namespace *)com->lc_file_ram;
- struct mdd_link_data ldata = { 0 };
+ struct linkea_data ldata = { 0 };
struct thandle *handle = NULL;
bool locked = false;
bool update = false;
if (IS_ERR(handle))
RETURN(rc = PTR_ERR(handle));
- rc = mdd_declare_links_add(env, child, handle);;
+ rc = mdd_declare_links_add(env, child, handle, NULL);
if (rc != 0)
GOTO(stop, rc);
if (rc != 0)
GOTO(stop, rc);
- ldata.ml_lee = (struct link_ea_entry *)(ldata.ml_leh + 1);
- count = ldata.ml_leh->leh_reccount;
+ ldata.ld_lee = LINKEA_FIRST_ENTRY(ldata);
+ count = ldata.ld_leh->leh_reccount;
while (count-- > 0) {
struct mdd_object *parent = NULL;
struct dt_object *dir;
- mdd_lee_unpack(ldata.ml_lee, &ldata.ml_reclen, cname, pfid);
+ linkea_entry_unpack(ldata.ld_lee, &ldata.ld_reclen, cname,
+ pfid);
if (!fid_is_sane(pfid))
goto shrink;
if (!mdd_object_exists(parent))
goto shrink;
- /* XXX: need more processing for remote object in the future. */
+ /* XXX: Currently, skip remote object, the consistency for
+ * remote object will be processed in LFSCK phase III. */
if (mdd_object_remote(parent)) {
mdd_object_put(env, parent);
- ldata.ml_lee = (struct link_ea_entry *)
- ((char *)ldata.ml_lee + ldata.ml_reclen);
+ ldata.ld_lee = LINKEA_NEXT_ENTRY(ldata);
continue;
}
if (rc == 0) {
if (lu_fid_eq(cfid, mdo2fid(child))) {
mdd_object_put(env, parent);
- ldata.ml_lee = (struct link_ea_entry *)
- ((char *)ldata.ml_lee + ldata.ml_reclen);
+ ldata.ld_lee = LINKEA_NEXT_ENTRY(ldata);
continue;
}
goto shrink;
}
- if (ldata.ml_leh->leh_reccount > la->la_nlink)
+ if (ldata.ld_leh->leh_reccount > la->la_nlink)
goto shrink;
/* XXX: For the case of there is linkea entry, but without name
* It is out of LFSCK 1.5 scope, will implement it in the
* future. Keep the linkEA entry. */
mdd_object_put(env, parent);
- ldata.ml_lee = (struct link_ea_entry *)
- ((char *)ldata.ml_lee + ldata.ml_reclen);
+ ldata.ld_lee = LINKEA_NEXT_ENTRY(ldata);
continue;
shrink:
CDEBUG(D_LFSCK, "Remove linkEA: "DFID"[%.*s], "DFID"\n",
PFID(mdo2fid(child)), cname->ln_namelen, cname->ln_name,
PFID(pfid));
- mdd_links_del_buf(env, &ldata, cname);
+ linkea_del_buf(&ldata, cname);
update = true;
}
static int mdd_lfsck_namespace_reset(const struct lu_env *env,
struct lfsck_component *com, bool init)
{
- struct mdd_thread_info *info = mdd_env_info(env);
- struct lu_fid *fid = &info->mti_fid;
struct lfsck_namespace *ns = (struct lfsck_namespace *)com->lc_file_ram;
struct mdd_device *mdd = mdd_lfsck2mdd(com->lc_lfsck);
- struct md_object *mdo;
- struct dt_object *dto;
+ struct dt_object *dto, *root;
int rc;
ENTRY;
ns->ln_magic = LFSCK_NAMESPACE_MAGIC;
ns->ln_status = LS_INIT;
- rc = mdd_lfsck_namespace_unlink(env, mdd, com);
+ root = dt_locate(env, mdd->mdd_bottom, &mdd->mdd_local_root_fid);
+ if (unlikely(IS_ERR(root)))
+ GOTO(out, rc = PTR_ERR(root));
+
+ rc = local_object_unlink(env, mdd->mdd_bottom, root,
+ lfsck_namespace_name);
if (rc != 0)
GOTO(out, rc);
- lu_local_obj_fid(fid, LFSCK_NAMESPACE_OID);
- mdo = llo_store_create_index(env, &mdd->mdd_md_dev, mdd->mdd_bottom, "",
- lfsck_namespace_name, fid,
- &dt_lfsck_features);
- if (IS_ERR(mdo))
- GOTO(out, rc = PTR_ERR(mdo));
-
- lu_object_put(env, &mdo->mo_lu);
- dto = dt_store_open(env, mdd->mdd_bottom, "", lfsck_namespace_name, fid);
+ dto = local_index_find_or_create(env, mdd->mdd_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);
+ com->lc_obj = dto;
rc = mdd_lfsck_namespace_store(env, com, true);
GOTO(out, rc);
-
out:
+ lu_object_put(env, &root->do_lu);
up_write(&com->lc_sem);
return rc;
}
static void
mdd_lfsck_namespace_fail(const struct lu_env *env, struct lfsck_component *com,
- bool oit, bool new_checked)
+ bool new_checked)
{
struct lfsck_namespace *ns = (struct lfsck_namespace *)com->lc_file_ram;
ns->ln_items_failed++;
if (mdd_lfsck_pos_is_zero(&ns->ln_pos_first_inconsistent))
mdd_lfsck_pos_fill(env, com->lc_lfsck,
- &ns->ln_pos_first_inconsistent, oit, !oit);
+ &ns->ln_pos_first_inconsistent, false);
up_write(&com->lc_sem);
}
down_write(&com->lc_sem);
- ns->ln_pos_last_checkpoint = lfsck->ml_pos_current;
if (init) {
- ns->ln_time_last_checkpoint = ns->ln_time_latest_start;
ns->ln_pos_latest_start = lfsck->ml_pos_current;
} else {
+ ns->ln_pos_last_checkpoint = lfsck->ml_pos_current;
ns->ln_run_time_phase1 += cfs_duration_sec(cfs_time_current() +
HALF_SEC - lfsck->ml_time_last_checkpoint);
ns->ln_time_last_checkpoint = cfs_time_current_sec();
mdd_lfsck_pos_is_zero(&ns->ln_pos_first_inconsistent)) {
*pos = ns->ln_pos_last_checkpoint;
pos->lp_oit_cookie++;
- if (!fid_is_zero(&pos->lp_dir_parent)) {
- if (pos->lp_dir_cookie == MDS_DIR_END_OFF) {
- fid_zero(&pos->lp_dir_parent);
- } else {
- pos->lp_dir_cookie++;
- }
- }
} else {
*pos = ns->ln_pos_first_inconsistent;
}
return rc;
/* For insert new linkEA entry. */
- rc = mdd_declare_links_add(env, obj, handle);
+ rc = mdd_declare_links_add(env, obj, handle, NULL);
return rc;
}
struct lfsck_namespace *ns =
(struct lfsck_namespace *)com->lc_file_ram;
struct mdd_device *mdd = mdd_lfsck2mdd(lfsck);
- struct mdd_link_data ldata = { 0 };
+ struct linkea_data ldata = { 0 };
const struct lu_fid *pfid =
lu_object_fid(&lfsck->ml_obj_dir->do_lu);
const struct lu_fid *cfid = mdo2fid(obj);
if (ent->lde_name[0] == '.' &&
(ent->lde_namelen == 1 ||
- (ent->lde_namelen == 2 && ent->lde_name[1] == '.')))
+ (ent->lde_namelen == 2 && ent->lde_name[1] == '.') ||
+ fid_is_dot_lustre(&ent->lde_fid)))
GOTO(out, rc = 0);
if (!(bk->lb_param & LPF_DRYRUN) &&
rc = mdd_links_read(env, obj, &ldata);
if (rc == 0) {
- count = ldata.ml_leh->leh_reccount;
- rc = mdd_links_find(env, obj, &ldata, cname, pfid);
+ count = ldata.ld_leh->leh_reccount;
+ rc = linkea_links_find(&ldata, cname, pfid);
if (rc == 0) {
/* For dir, if there are more than one linkea entries,
* then remove all the other redundant linkea entries.*/
}
nodata:
- rc = mdd_links_new(env, &ldata);
+ rc = linkea_data_new(&ldata, &mdd_env_info(env)->mti_link_buf);
if (rc != 0)
GOTO(stop, rc);
if (!com->lc_journal)
goto again;
- rc = mdd_links_add_buf(env, &ldata, cname, pfid);
+ rc = linkea_add_buf(&ldata, cname, pfid);
if (rc != 0)
GOTO(stop, rc);
if (rc != 0)
GOTO(stop, rc);
- count = ldata.ml_leh->leh_reccount;
+ count = ldata.ld_leh->leh_reccount;
repaired = true;
} else {
GOTO(stop, rc);
if (mdd_lfsck_pos_is_zero(&ns->ln_pos_first_inconsistent))
mdd_lfsck_pos_fill(env, lfsck,
&ns->ln_pos_first_inconsistent,
- true, false);
+ false);
if (!(bk->lb_param & LPF_FAILOUT))
rc = 0;
} else {
static int mdd_lfsck_namespace_post(const struct lu_env *env,
struct lfsck_component *com,
- int result)
+ int result, bool init)
{
struct md_lfsck *lfsck = com->lc_lfsck;
struct lfsck_namespace *ns =
down_write(&com->lc_sem);
spin_lock(&lfsck->ml_lock);
+ if (!init)
+ ns->ln_pos_last_checkpoint = lfsck->ml_pos_current;
if (result > 0) {
ns->ln_status = LS_SCANNING_PHASE2;
ns->ln_flags |= LF_SCANNED_ONCE;
}
spin_unlock(&lfsck->ml_lock);
- ns->ln_run_time_phase1 += cfs_duration_sec(cfs_time_current() +
+ if (!init) {
+ ns->ln_run_time_phase1 += cfs_duration_sec(cfs_time_current() +
HALF_SEC - lfsck->ml_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;
+ ns->ln_time_last_checkpoint = cfs_time_current_sec();
+ ns->ln_items_checked += com->lc_new_checked;
+ com->lc_new_checked = 0;
+ }
rc = mdd_lfsck_namespace_store(env, com, false);
buf += rc;
len -= rc;
- mdd_lfsck_pos_fill(env, lfsck, &pos, true, true);
+ mdd_lfsck_pos_fill(env, lfsck, &pos, false);
rc = lfsck_pos_dump(&buf, &len, &pos, "current_position");
if (rc <= 0)
goto out;
goto checkpoint;
}
- /* XXX: need more processing for remote object in the future. */
+ /* XXX: Currently, skip remote object, the consistency for
+ * remote object will be processed in LFSCK phase III. */
if (!mdd_object_exists(target) || mdd_object_remote(target))
goto obj_put;
static int mdd_lfsck_namespace_setup(const struct lu_env *env,
struct md_lfsck *lfsck)
{
- struct mdd_device *mdd = mdd_lfsck2mdd(lfsck);
- struct lfsck_component *com;
- struct lfsck_namespace *ns;
- struct dt_object *obj;
- int rc;
+ struct mdd_device *mdd = mdd_lfsck2mdd(lfsck);
+ struct lfsck_component *com;
+ struct lfsck_namespace *ns;
+ struct dt_object *obj, *root;
+ int rc;
ENTRY;
OBD_ALLOC_PTR(com);
if (com->lc_file_disk == NULL)
GOTO(out, rc = -ENOMEM);
- obj = dt_store_open(env, mdd->mdd_bottom, "", lfsck_namespace_name,
- &mdd_env_info(env)->mti_fid);
+ root = dt_locate(env, mdd->mdd_bottom, &mdd->mdd_local_root_fid);
+ if (unlikely(IS_ERR(root)))
+ GOTO(out, rc = PTR_ERR(root));
+
+ obj = local_index_find_or_create(env, mdd->mdd_los, root,
+ lfsck_namespace_name,
+ S_IFREG | S_IRUGO | S_IWUSR,
+ &dt_lfsck_features);
+ lu_object_put(env, &root->do_lu);
if (IS_ERR(obj))
GOTO(out, rc = PTR_ERR(obj));
/* helper functions for framework */
-static int object_is_client_visible(const struct lu_env *env,
- struct mdd_device *mdd,
- struct mdd_object *obj)
+static int object_needs_lfsck(const struct lu_env *env, struct mdd_device *mdd,
+ struct mdd_object *obj)
{
struct lu_fid *fid = &mdd_env_info(env)->mti_fid;
int depth = 0;
return 1;
}
+ /* .lustre doesn't contain "real" user objects, no need lfsck */
+ if (fid_is_dot_lustre(mdo2fid(obj))) {
+ if (depth > 0)
+ mdd_object_put(env, obj);
+ return 0;
+ }
+
mdd_read_lock(env, obj, MOR_TGT_CHILD);
if (unlikely(mdd_is_dead_obj(obj))) {
mdd_read_unlock(env, obj);
else if (IS_ERR(obj))
return PTR_ERR(obj);
- /* XXX: need more processing for remote object in the future. */
- if (!mdd_object_exists(obj) || mdd_object_remote(obj)) {
+ if (!mdd_object_exists(obj)) {
mdd_object_put(env, obj);
return 0;
}
+ /* Currently, only client visible directory can be remote. */
+ if (mdd_object_remote(obj)) {
+ mdd_object_put(env, obj);
+ return 1;
+ }
+
depth++;
}
return 0;
/* LFSCK wrap functions */
static void mdd_lfsck_fail(const struct lu_env *env, struct md_lfsck *lfsck,
- bool oit, bool new_checked)
+ bool new_checked)
{
struct lfsck_component *com;
cfs_list_for_each_entry(com, &lfsck->ml_list_scan, lc_link) {
- com->lc_ops->lfsck_fail(env, com, oit, new_checked);
+ com->lc_ops->lfsck_fail(env, com, new_checked);
}
}
static int mdd_lfsck_checkpoint(const struct lu_env *env,
- struct md_lfsck *lfsck, bool oit)
+ struct md_lfsck *lfsck)
{
struct lfsck_component *com;
int rc;
lfsck->ml_time_next_checkpoint)))
return 0;
- mdd_lfsck_pos_fill(env, lfsck, &lfsck->ml_pos_current, oit, !oit);
+ mdd_lfsck_pos_fill(env, lfsck, &lfsck->ml_pos_current, false);
cfs_list_for_each_entry(com, &lfsck->ml_list_scan, lc_link) {
rc = com->lc_ops->lfsck_checkpoint(env, com, false);
if (rc != 0)
LASSERT(lfsck->ml_obj_dir == NULL);
LASSERT(lfsck->ml_di_dir == NULL);
+ lfsck->ml_current_oit_processed = 0;
cfs_list_for_each_entry_safe(com, next, &lfsck->ml_list_scan, lc_link) {
com->lc_new_checked = 0;
if (lfsck->ml_bookmark_ram.lb_param & LPF_DRYRUN)
/* Init otable-based iterator. */
if (pos == NULL) {
rc = iops->load(env, lfsck->ml_di_oit, 0);
- GOTO(out, rc = (rc >= 0 ? 0 : rc));
+ if (rc > 0) {
+ lfsck->ml_oit_over = 1;
+ rc = 0;
+ }
+
+ GOTO(out, rc);
}
rc = iops->load(env, lfsck->ml_di_oit, pos->lp_oit_cookie);
if (rc < 0)
GOTO(out, rc);
+ else if (rc > 0)
+ lfsck->ml_oit_over = 1;
if (fid_is_zero(&pos->lp_dir_parent))
GOTO(out, rc = 0);
else if (IS_ERR(obj))
RETURN(PTR_ERR(obj));
- /* XXX: need more processing for remote object in the future. */
+ /* XXX: Currently, skip remote object, the consistency for
+ * remote object will be processed in LFSCK phase III. */
if (!mdd_object_exists(obj) || mdd_object_remote(obj) ||
unlikely(!S_ISDIR(mdd_object_type(obj))))
GOTO(out, rc = 0);
if (IS_ERR(di))
GOTO(out, rc = PTR_ERR(di));
+ LASSERT(pos->lp_dir_cookie < MDS_DIR_END_OFF);
+
rc = iops->load(env, di, pos->lp_dir_cookie);
- if (rc == 0)
+ if ((rc == 0) || (rc > 0 && pos->lp_dir_cookie > 0))
rc = iops->next(env, di);
else if (rc > 0)
rc = 0;
if (obj != NULL)
mdd_object_put(env, obj);
- if (rc != 0)
- return (rc > 0 ? 0 : rc);
+ if (rc < 0) {
+ cfs_list_for_each_entry_safe(com, next, &lfsck->ml_list_scan,
+ lc_link)
+ com->lc_ops->lfsck_post(env, com, rc, true);
- mdd_lfsck_pos_fill(env, lfsck, &lfsck->ml_pos_current, false, false);
+ return rc;
+ }
+
+ rc = 0;
+ mdd_lfsck_pos_fill(env, lfsck, &lfsck->ml_pos_current, true);
cfs_list_for_each_entry(com, &lfsck->ml_list_scan, lc_link) {
rc = com->lc_ops->lfsck_checkpoint(env, com, true);
if (rc != 0)
cfs_list_empty(&lfsck->ml_list_dir))
RETURN(0);
- rc = object_is_client_visible(env, mdd_lfsck2mdd(lfsck), obj);
+ rc = object_needs_lfsck(env, mdd_lfsck2mdd(lfsck), obj);
if (rc <= 0)
GOTO(out, rc);
out:
if (rc < 0)
- mdd_lfsck_fail(env, lfsck, false, false);
+ mdd_lfsck_fail(env, lfsck, false);
return (rc > 0 ? 0 : rc);
}
struct lfsck_component *next;
int rc;
- mdd_lfsck_pos_fill(env, lfsck, &lfsck->ml_pos_current, true, true);
+ mdd_lfsck_pos_fill(env, lfsck, &lfsck->ml_pos_current, false);
cfs_list_for_each_entry_safe(com, next, &lfsck->ml_list_scan, lc_link) {
- rc = com->lc_ops->lfsck_post(env, com, result);
+ rc = com->lc_ops->lfsck_post(env, com, result, false);
if (rc != 0)
return rc;
}
rc = iops->rec(env, di, (struct dt_rec *)ent,
lfsck->ml_args_dir);
if (rc != 0) {
- mdd_lfsck_fail(env, lfsck, false, true);
+ mdd_lfsck_fail(env, lfsck, true);
if (bk->lb_param & LPF_FAILOUT)
RETURN(rc);
else
if (child == NULL) {
goto checkpoint;
} else if (IS_ERR(child)) {
- mdd_lfsck_fail(env, lfsck, false, true);
+ mdd_lfsck_fail(env, lfsck, true);
if (bk->lb_param & LPF_FAILOUT)
RETURN(PTR_ERR(child));
else
goto checkpoint;
}
- /* XXX: need more processing for remote object in the future. */
+ /* XXX: Currently, skip remote object, the consistency for
+ * remote object will be processed in LFSCK phase III. */
if (mdd_object_exists(child) && !mdd_object_remote(child))
rc = mdd_lfsck_exec_dir(env, lfsck, child, ent);
mdd_object_put(env, child);
RETURN(rc);
checkpoint:
- rc = mdd_lfsck_checkpoint(env, lfsck, false);
+ rc = mdd_lfsck_checkpoint(env, lfsck);
if (rc != 0 && bk->lb_param & LPF_FAILOUT)
RETURN(rc);
if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_CRASH))
RETURN(0);
+ lfsck->ml_current_oit_processed = 1;
lfsck->ml_new_scanned++;
rc = iops->rec(env, di, (struct dt_rec *)fid, 0);
if (rc != 0) {
- mdd_lfsck_fail(env, lfsck, true, true);
+ mdd_lfsck_fail(env, lfsck, true);
if (bk->lb_param & LPF_FAILOUT)
RETURN(rc);
else
if (target == NULL) {
goto checkpoint;
} else if (IS_ERR(target)) {
- mdd_lfsck_fail(env, lfsck, true, true);
+ mdd_lfsck_fail(env, lfsck, true);
if (bk->lb_param & LPF_FAILOUT)
RETURN(PTR_ERR(target));
else
goto checkpoint;
}
- /* XXX: In fact, low layer otable-based iteration should not
- * return agent object. But before LU-2646 resolved, we
- * need more processing for agent object. */
+ /* XXX: Currently, skip remote object, the consistency for
+ * remote object will be processed in LFSCK phase III. */
if (mdd_object_exists(target) && !mdd_object_remote(target))
rc = mdd_lfsck_exec_oit(env, lfsck, target);
mdd_object_put(env, target);
RETURN(rc);
checkpoint:
- rc = mdd_lfsck_checkpoint(env, lfsck, true);
+ rc = mdd_lfsck_checkpoint(env, lfsck);
if (rc != 0 && bk->lb_param & LPF_FAILOUT)
RETURN(rc);
}
rc = iops->next(env, di);
- if (rc > 0)
+ if (unlikely(rc > 0))
lfsck->ml_oit_over = 1;
+ else if (likely(rc == 0))
+ lfsck->ml_current_oit_processed = 0;
if (unlikely(!thread_is_running(thread)))
RETURN(0);
cfs_list_for_each_entry_safe(com, next,
&lfsck->ml_list_scan, lc_link) {
if (!(com->lc_type & start->ls_active)) {
- rc = com->lc_ops->lfsck_post(env, com, 0);
+ rc = com->lc_ops->lfsck_post(env, com, 0,
+ false);
if (rc != 0)
GOTO(out, rc);
}
int mdd_lfsck_setup(const struct lu_env *env, struct mdd_device *mdd)
{
- struct md_lfsck *lfsck = &mdd->mdd_lfsck;
- struct dt_object *obj;
- int rc;
+ struct md_lfsck *lfsck = &mdd->mdd_lfsck;
+ struct dt_object *obj;
+ struct lu_fid fid;
+ int rc;
+
ENTRY;
LASSERT(!lfsck->ml_initialized);
rc = obj->do_ops->do_index_try(env, obj, &dt_otable_features);
if (rc != 0) {
if (rc == -ENOTSUPP)
- rc = 0;
-
- RETURN(rc);
+ RETURN(0);
+ GOTO(out, rc);
}
- obj = dt_store_open(env, mdd->mdd_bottom, "", lfsck_bookmark_name,
- &mdd_env_info(env)->mti_fid);
+ /* LFSCK bookmark */
+ fid_zero(&fid);
+ rc = mdd_local_file_create(env, mdd, &mdd->mdd_local_root_fid,
+ lfsck_bookmark_name,
+ S_IFREG | S_IRUGO | S_IWUSR, &fid);
+ if (rc < 0)
+ GOTO(out, rc);
+
+ obj = dt_locate(env, mdd->mdd_bottom, &fid);
if (IS_ERR(obj))
- RETURN(PTR_ERR(obj));
+ GOTO(out, rc = PTR_ERR(obj));
+ LASSERT(lu_object_exists(&obj->do_lu));
lfsck->ml_bookmark_obj = obj;
+
rc = mdd_lfsck_bookmark_load(env, lfsck);
if (rc == -ENODATA)
rc = mdd_lfsck_bookmark_init(env, lfsck);
if (rc != 0)
- RETURN(rc);
+ GOTO(out, rc);
rc = mdd_lfsck_namespace_setup(env, lfsck);
+ if (rc < 0)
+ GOTO(out, rc);
/* XXX: LFSCK components initialization to be added here. */
-
- RETURN(rc);
+ RETURN(0);
+out:
+ lu_object_put(env, &lfsck->ml_obj_oit->do_lu);
+ lfsck->ml_obj_oit = NULL;
+ return 0;
}
void mdd_lfsck_cleanup(const struct lu_env *env, struct mdd_device *mdd)
git://git.whamcloud.com / fs / lustre-release.git / blobdiff