#include <lu_object.h>
#include <dt_object.h>
#include <md_object.h>
-#include <lustre_linkea.h>
#include <lustre_fid.h>
#include <lustre_lib.h>
#include <lustre_net.h>
#define LFSCK_NAMESPACE_MAGIC 0xA0629D03
+enum lfsck_nameentry_check {
+ LFSCK_NAMEENTRY_DEAD = 1, /* The object has been unlinked. */
+ LFSCK_NAMEENTRY_REMOVED = 2, /* The entry has been removed. */
+ LFSCK_NAMEENTRY_RECREATED = 3, /* The entry has been recreated. */
+};
+
static const char lfsck_namespace_name[] = "lfsck_namespace";
-static void lfsck_namespace_le_to_cpu(struct lfsck_namespace *des,
+struct lfsck_namespace_req {
+ struct lfsck_assistant_req lnr_lar;
+ struct dt_object *lnr_obj;
+ struct lu_fid lnr_fid;
+ __u64 lnr_oit_cookie;
+ __u64 lnr_dir_cookie;
+ __u32 lnr_attr;
+ __u32 lnr_size;
+ __u16 lnr_type;
+ __u16 lnr_namelen;
+ char lnr_name[0];
+};
+
+static struct lfsck_namespace_req *
+lfsck_namespace_assistant_req_init(struct lfsck_instance *lfsck,
+ struct lu_dirent *ent, __u16 type)
+{
+ struct lfsck_namespace_req *lnr;
+ int size;
+
+ size = sizeof(*lnr) + (ent->lde_namelen & ~3) + 4;
+ OBD_ALLOC(lnr, size);
+ if (lnr == NULL)
+ return ERR_PTR(-ENOMEM);
+
+ INIT_LIST_HEAD(&lnr->lnr_lar.lar_list);
+ lu_object_get(&lfsck->li_obj_dir->do_lu);
+ lnr->lnr_obj = lfsck->li_obj_dir;
+ lnr->lnr_fid = ent->lde_fid;
+ lnr->lnr_oit_cookie = lfsck->li_pos_current.lp_oit_cookie;
+ lnr->lnr_dir_cookie = ent->lde_hash;
+ lnr->lnr_attr = ent->lde_attrs;
+ lnr->lnr_size = size;
+ lnr->lnr_type = type;
+ lnr->lnr_namelen = ent->lde_namelen;
+ memcpy(lnr->lnr_name, ent->lde_name, ent->lde_namelen);
+
+ return lnr;
+}
+
+static void lfsck_namespace_assistant_req_fini(const struct lu_env *env,
+ struct lfsck_assistant_req *lar)
+{
+ struct lfsck_namespace_req *lnr =
+ container_of0(lar, struct lfsck_namespace_req, lnr_lar);
+
+ lu_object_put(env, &lnr->lnr_obj->do_lu);
+ OBD_FREE(lnr, lnr->lnr_size);
+}
+
+static void lfsck_namespace_le_to_cpu(struct lfsck_namespace *dst,
struct lfsck_namespace *src)
{
- des->ln_magic = le32_to_cpu(src->ln_magic);
- des->ln_status = le32_to_cpu(src->ln_status);
- des->ln_flags = le32_to_cpu(src->ln_flags);
- des->ln_success_count = le32_to_cpu(src->ln_success_count);
- des->ln_run_time_phase1 = le32_to_cpu(src->ln_run_time_phase1);
- des->ln_run_time_phase2 = le32_to_cpu(src->ln_run_time_phase2);
- des->ln_time_last_complete = le64_to_cpu(src->ln_time_last_complete);
- des->ln_time_latest_start = le64_to_cpu(src->ln_time_latest_start);
- des->ln_time_last_checkpoint =
+ dst->ln_magic = le32_to_cpu(src->ln_magic);
+ dst->ln_status = le32_to_cpu(src->ln_status);
+ dst->ln_flags = le32_to_cpu(src->ln_flags);
+ dst->ln_success_count = le32_to_cpu(src->ln_success_count);
+ dst->ln_run_time_phase1 = le32_to_cpu(src->ln_run_time_phase1);
+ dst->ln_run_time_phase2 = le32_to_cpu(src->ln_run_time_phase2);
+ dst->ln_time_last_complete = le64_to_cpu(src->ln_time_last_complete);
+ dst->ln_time_latest_start = le64_to_cpu(src->ln_time_latest_start);
+ dst->ln_time_last_checkpoint =
le64_to_cpu(src->ln_time_last_checkpoint);
- lfsck_position_le_to_cpu(&des->ln_pos_latest_start,
+ lfsck_position_le_to_cpu(&dst->ln_pos_latest_start,
&src->ln_pos_latest_start);
- lfsck_position_le_to_cpu(&des->ln_pos_last_checkpoint,
+ lfsck_position_le_to_cpu(&dst->ln_pos_last_checkpoint,
&src->ln_pos_last_checkpoint);
- lfsck_position_le_to_cpu(&des->ln_pos_first_inconsistent,
+ lfsck_position_le_to_cpu(&dst->ln_pos_first_inconsistent,
&src->ln_pos_first_inconsistent);
- des->ln_items_checked = le64_to_cpu(src->ln_items_checked);
- des->ln_items_repaired = le64_to_cpu(src->ln_items_repaired);
- des->ln_items_failed = le64_to_cpu(src->ln_items_failed);
- des->ln_dirs_checked = le64_to_cpu(src->ln_dirs_checked);
- des->ln_mlinked_checked = le64_to_cpu(src->ln_mlinked_checked);
- des->ln_objs_checked_phase2 = le64_to_cpu(src->ln_objs_checked_phase2);
- des->ln_objs_repaired_phase2 =
+ dst->ln_items_checked = le64_to_cpu(src->ln_items_checked);
+ dst->ln_items_repaired = le64_to_cpu(src->ln_items_repaired);
+ dst->ln_items_failed = le64_to_cpu(src->ln_items_failed);
+ dst->ln_dirs_checked = le64_to_cpu(src->ln_dirs_checked);
+ dst->ln_mlinked_checked = le64_to_cpu(src->ln_mlinked_checked);
+ dst->ln_objs_checked_phase2 = le64_to_cpu(src->ln_objs_checked_phase2);
+ dst->ln_objs_repaired_phase2 =
le64_to_cpu(src->ln_objs_repaired_phase2);
- des->ln_objs_failed_phase2 = le64_to_cpu(src->ln_objs_failed_phase2);
- des->ln_objs_nlink_repaired = le64_to_cpu(src->ln_objs_nlink_repaired);
- des->ln_objs_lost_found = le64_to_cpu(src->ln_objs_lost_found);
- fid_le_to_cpu(&des->ln_fid_latest_scanned_phase2,
+ dst->ln_objs_failed_phase2 = le64_to_cpu(src->ln_objs_failed_phase2);
+ dst->ln_objs_nlink_repaired = le64_to_cpu(src->ln_objs_nlink_repaired);
+ dst->ln_objs_lost_found = le64_to_cpu(src->ln_objs_lost_found);
+ fid_le_to_cpu(&dst->ln_fid_latest_scanned_phase2,
&src->ln_fid_latest_scanned_phase2);
+ dst->ln_dirent_repaired = le64_to_cpu(src->ln_dirent_repaired);
+ dst->ln_linkea_repaired = le64_to_cpu(src->ln_linkea_repaired);
}
-static void lfsck_namespace_cpu_to_le(struct lfsck_namespace *des,
+static void lfsck_namespace_cpu_to_le(struct lfsck_namespace *dst,
struct lfsck_namespace *src)
{
- des->ln_magic = cpu_to_le32(src->ln_magic);
- des->ln_status = cpu_to_le32(src->ln_status);
- des->ln_flags = cpu_to_le32(src->ln_flags);
- des->ln_success_count = cpu_to_le32(src->ln_success_count);
- des->ln_run_time_phase1 = cpu_to_le32(src->ln_run_time_phase1);
- des->ln_run_time_phase2 = cpu_to_le32(src->ln_run_time_phase2);
- des->ln_time_last_complete = cpu_to_le64(src->ln_time_last_complete);
- des->ln_time_latest_start = cpu_to_le64(src->ln_time_latest_start);
- des->ln_time_last_checkpoint =
+ dst->ln_magic = cpu_to_le32(src->ln_magic);
+ dst->ln_status = cpu_to_le32(src->ln_status);
+ dst->ln_flags = cpu_to_le32(src->ln_flags);
+ dst->ln_success_count = cpu_to_le32(src->ln_success_count);
+ dst->ln_run_time_phase1 = cpu_to_le32(src->ln_run_time_phase1);
+ dst->ln_run_time_phase2 = cpu_to_le32(src->ln_run_time_phase2);
+ dst->ln_time_last_complete = cpu_to_le64(src->ln_time_last_complete);
+ dst->ln_time_latest_start = cpu_to_le64(src->ln_time_latest_start);
+ dst->ln_time_last_checkpoint =
cpu_to_le64(src->ln_time_last_checkpoint);
- lfsck_position_cpu_to_le(&des->ln_pos_latest_start,
+ lfsck_position_cpu_to_le(&dst->ln_pos_latest_start,
&src->ln_pos_latest_start);
- lfsck_position_cpu_to_le(&des->ln_pos_last_checkpoint,
+ lfsck_position_cpu_to_le(&dst->ln_pos_last_checkpoint,
&src->ln_pos_last_checkpoint);
- lfsck_position_cpu_to_le(&des->ln_pos_first_inconsistent,
+ lfsck_position_cpu_to_le(&dst->ln_pos_first_inconsistent,
&src->ln_pos_first_inconsistent);
- des->ln_items_checked = cpu_to_le64(src->ln_items_checked);
- des->ln_items_repaired = cpu_to_le64(src->ln_items_repaired);
- des->ln_items_failed = cpu_to_le64(src->ln_items_failed);
- des->ln_dirs_checked = cpu_to_le64(src->ln_dirs_checked);
- des->ln_mlinked_checked = cpu_to_le64(src->ln_mlinked_checked);
- des->ln_objs_checked_phase2 = cpu_to_le64(src->ln_objs_checked_phase2);
- des->ln_objs_repaired_phase2 =
+ dst->ln_items_checked = cpu_to_le64(src->ln_items_checked);
+ dst->ln_items_repaired = cpu_to_le64(src->ln_items_repaired);
+ dst->ln_items_failed = cpu_to_le64(src->ln_items_failed);
+ dst->ln_dirs_checked = cpu_to_le64(src->ln_dirs_checked);
+ dst->ln_mlinked_checked = cpu_to_le64(src->ln_mlinked_checked);
+ dst->ln_objs_checked_phase2 = cpu_to_le64(src->ln_objs_checked_phase2);
+ dst->ln_objs_repaired_phase2 =
cpu_to_le64(src->ln_objs_repaired_phase2);
- des->ln_objs_failed_phase2 = cpu_to_le64(src->ln_objs_failed_phase2);
- des->ln_objs_nlink_repaired = cpu_to_le64(src->ln_objs_nlink_repaired);
- des->ln_objs_lost_found = cpu_to_le64(src->ln_objs_lost_found);
- fid_cpu_to_le(&des->ln_fid_latest_scanned_phase2,
+ dst->ln_objs_failed_phase2 = cpu_to_le64(src->ln_objs_failed_phase2);
+ dst->ln_objs_nlink_repaired = cpu_to_le64(src->ln_objs_nlink_repaired);
+ dst->ln_objs_lost_found = cpu_to_le64(src->ln_objs_lost_found);
+ fid_cpu_to_le(&dst->ln_fid_latest_scanned_phase2,
&src->ln_fid_latest_scanned_phase2);
+ dst->ln_dirent_repaired = cpu_to_le64(src->ln_dirent_repaired);
+ dst->ln_linkea_repaired = cpu_to_le64(src->ln_linkea_repaired);
+}
+
+static void lfsck_namespace_record_failure(const struct lu_env *env,
+ struct lfsck_instance *lfsck,
+ struct lfsck_namespace *ns)
+{
+ struct lfsck_position pos;
+
+ ns->ln_items_failed++;
+ lfsck_pos_fill(env, lfsck, &pos, false);
+ if (lfsck_pos_is_zero(&ns->ln_pos_first_inconsistent) ||
+ lfsck_pos_is_eq(&pos, &ns->ln_pos_first_inconsistent) < 0) {
+ ns->ln_pos_first_inconsistent = pos;
+
+ CDEBUG(D_LFSCK, "%s: namespace LFSCK hit first non-repaired "
+ "inconsistency at the pos ["LPU64", "DFID", "LPX64"]\n",
+ lfsck_lfsck2name(lfsck),
+ ns->ln_pos_first_inconsistent.lp_oit_cookie,
+ PFID(&ns->ln_pos_first_inconsistent.lp_dir_parent),
+ ns->ln_pos_first_inconsistent.lp_dir_cookie);
+ }
}
/**
lfsck_namespace_le_to_cpu(ns,
(struct lfsck_namespace *)com->lc_file_disk);
if (ns->ln_magic != LFSCK_NAMESPACE_MAGIC) {
- CWARN("%s: invalid lfsck_namespace magic %#x != %#x\n",
- lfsck_lfsck2name(com->lc_lfsck), ns->ln_magic,
- LFSCK_NAMESPACE_MAGIC);
+ CDEBUG(D_LFSCK, "%s: invalid lfsck_namespace magic "
+ "%#x != %#x\n", lfsck_lfsck2name(com->lc_lfsck),
+ ns->ln_magic, LFSCK_NAMESPACE_MAGIC);
rc = 1;
} else {
rc = 0;
}
} else if (rc != -ENODATA) {
- CERROR("%s: fail to load lfsck_namespace: expected = %d, "
- "rc = %d\n", lfsck_lfsck2name(com->lc_lfsck), len, rc);
+ CDEBUG(D_LFSCK, "%s: fail to load lfsck_namespace, "
+ "expected = %d: rc = %d\n",
+ lfsck_lfsck2name(com->lc_lfsck), len, rc);
if (rc >= 0)
rc = 1;
}
lfsck_namespace_cpu_to_le((struct lfsck_namespace *)com->lc_file_disk,
(struct lfsck_namespace *)com->lc_file_ram);
handle = dt_trans_create(env, lfsck->li_bottom);
- if (IS_ERR(handle)) {
- rc = PTR_ERR(handle);
- CERROR("%s: fail to create trans for storing lfsck_namespace: "
- "rc = %d\n", lfsck_lfsck2name(lfsck), rc);
- RETURN(rc);
- }
+ if (IS_ERR(handle))
+ GOTO(log, rc = PTR_ERR(handle));
rc = dt_declare_xattr_set(env, obj,
lfsck_buf_get(env, com->lc_file_disk, len),
XATTR_NAME_LFSCK_NAMESPACE, 0, handle);
- if (rc != 0) {
- CERROR("%s: fail to declare trans for storing lfsck_namespace: "
- "rc = %d\n", lfsck_lfsck2name(lfsck), rc);
+ if (rc != 0)
GOTO(out, rc);
- }
rc = dt_trans_start_local(env, lfsck->li_bottom, handle);
- if (rc != 0) {
- CERROR("%s: fail to start trans for storing lfsck_namespace: "
- "rc = %d\n", lfsck_lfsck2name(lfsck), rc);
+ if (rc != 0)
GOTO(out, rc);
- }
rc = dt_xattr_set(env, obj,
lfsck_buf_get(env, com->lc_file_disk, len),
XATTR_NAME_LFSCK_NAMESPACE,
init ? LU_XATTR_CREATE : LU_XATTR_REPLACE,
handle, BYPASS_CAPA);
- if (rc != 0)
- CERROR("%s: fail to store lfsck_namespace: len = %d, "
- "rc = %d\n", lfsck_lfsck2name(lfsck), len, rc);
GOTO(out, rc);
out:
dt_trans_stop(env, lfsck->li_bottom, handle);
+
+log:
+ if (rc != 0)
+ CDEBUG(D_LFSCK, "%s: fail to store lfsck_namespace: rc = %d\n",
+ lfsck_lfsck2name(lfsck), rc);
return rc;
}
if (exist) {
rc = dt_delete(env, obj, (const struct dt_key *)key, handle,
BYPASS_CAPA);
- if (rc != 0) {
- CERROR("%s: fail to insert "DFID": rc = %d\n",
- lfsck_lfsck2name(com->lc_lfsck), PFID(fid), rc);
+ if (rc != 0)
GOTO(out, rc);
- }
}
rc = dt_insert(env, obj, (const struct dt_rec *)&flags,
}
static int lfsck_namespace_check_exist(const struct lu_env *env,
- struct lfsck_instance *lfsck,
+ struct dt_object *dir,
struct dt_object *obj, const char *name)
{
- struct dt_object *dir = lfsck->li_obj_dir;
struct lu_fid *fid = &lfsck_env_info(env)->lti_fid;
int rc;
ENTRY;
goto shrink;
parent = lfsck_object_find(env, lfsck, pfid);
- if (parent == NULL)
- goto shrink;
- else if (IS_ERR(parent))
+ if (IS_ERR(parent))
GOTO(stop, rc = PTR_ERR(parent));
if (!dt_object_exists(parent))
if (bk->lb_param & LPF_DRYRUN)
RETURN(1);
- CDEBUG(D_LFSCK, "Remove linkEA: "DFID"[%.*s], "DFID"\n",
- PFID(lfsck_dto2fid(child)), cname->ln_namelen, cname->ln_name,
- PFID(pfid));
+ CDEBUG(D_LFSCK, "%s: namespace LFSCK remove invalid linkEA "
+ "for the object: "DFID", parent "DFID", name %.*s\n",
+ lfsck_lfsck2name(lfsck), PFID(lfsck_dto2fid(child)),
+ PFID(pfid), cname->ln_namelen, cname->ln_name);
+
linkea_del_buf(&ldata, cname);
update = true;
}
if (rc == 0 && !lfsck_is_dead_obj(child) &&
ldata.ld_leh != NULL &&
ldata.ld_leh->leh_reccount != la->la_nlink)
- CWARN("%s: the object "DFID" linkEA entry count %u "
- "may not match its hardlink count %u\n",
- lfsck_lfsck2name(lfsck), PFID(cfid),
- ldata.ld_leh->leh_reccount, la->la_nlink);
+ CDEBUG(D_LFSCK, "%s: the object "DFID" linkEA entry "
+ "count %u may not match its hardlink count %u\n",
+ lfsck_lfsck2name(lfsck), PFID(cfid),
+ ldata.ld_leh->leh_reccount, la->la_nlink);
dt_write_unlock(env, child);
}
root = dt_locate(env, lfsck->li_bottom, &lfsck->li_local_root_fid);
if (IS_ERR(root))
- RETURN(PTR_ERR(root));
+ GOTO(log, rc = PTR_ERR(root));
- if (unlikely(!dt_try_as_dir(env, root))) {
- lu_object_put(env, &root->do_lu);
- RETURN(-ENOTDIR);
- }
+ if (unlikely(!dt_try_as_dir(env, root)))
+ GOTO(put, rc = -ENOTDIR);
down_write(&com->lc_sem);
if (init) {
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;
}
down_write(&com->lc_sem);
if (new_checked)
com->lc_new_checked++;
- ns->ln_items_failed++;
- if (lfsck_pos_is_zero(&ns->ln_pos_first_inconsistent))
- lfsck_pos_fill(env, com->lc_lfsck,
- &ns->ln_pos_first_inconsistent, false);
+ lfsck_namespace_record_failure(env, com->lc_lfsck, ns);
up_write(&com->lc_sem);
}
struct lfsck_namespace *ns = com->lc_file_ram;
int rc;
- if (com->lc_new_checked == 0 && !init)
- return 0;
+ 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_current;
+ ns->ln_pos_latest_start = lfsck->li_pos_checkpoint;
} else {
- ns->ln_pos_last_checkpoint = lfsck->li_pos_current;
+ 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();
}
rc = lfsck_namespace_store(env, com, false);
-
up_write(&com->lc_sem);
- return rc;
+
+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_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;
if (ns->ln_status == LS_COMPLETED) {
- int rc;
-
rc = lfsck_namespace_reset(env, com, false);
- if (rc != 0)
+ 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;
- cfs_list_del_init(&com->lc_link);
- cfs_list_add_tail(&com->lc_link,
- &lfsck->li_list_double_scan);
- if (!cfs_list_empty(&com->lc_link_dir))
- cfs_list_del_init(&com->lc_link_dir);
+ 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_objs_nlink_repaired = 0;
ns->ln_objs_lost_found = 0;
fid_zero(&ns->ln_fid_latest_scanned_phase2);
- if (cfs_list_empty(&com->lc_link_dir))
- cfs_list_add_tail(&com->lc_link_dir,
- &lfsck->li_list_dir);
+ 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 (cfs_list_empty(&com->lc_link_dir))
- cfs_list_add_tail(&com->lc_link_dir,
- &lfsck->li_list_dir);
+ 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 = ns->ln_pos_first_inconsistent;
}
}
- spin_unlock(&lfsck->li_lock);
+ spin_unlock(&lfsck->li_lock);
up_write(&com->lc_sem);
- return 0;
+
+ 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,
static int lfsck_namespace_exec_dir(const struct lu_env *env,
struct lfsck_component *com,
- struct dt_object *obj,
- struct lu_dirent *ent)
+ struct lu_dirent *ent, __u16 type)
{
- struct lfsck_thread_info *info = lfsck_env_info(env);
- struct lu_attr *la = &info->lti_la;
- struct lfsck_instance *lfsck = com->lc_lfsck;
- struct lfsck_bookmark *bk = &lfsck->li_bookmark_ram;
- struct lfsck_namespace *ns = com->lc_file_ram;
- struct linkea_data ldata = { 0 };
- const struct lu_fid *pfid = lfsck_dto2fid(lfsck->li_obj_dir);
- const struct lu_fid *cfid = lfsck_dto2fid(obj);
- const struct lu_name *cname;
- struct thandle *handle = NULL;
- bool repaired = false;
- bool locked = false;
- bool remove;
- bool newdata;
- int count = 0;
- int rc;
- ENTRY;
-
- cname = lfsck_name_get_const(env, ent->lde_name, ent->lde_namelen);
- down_write(&com->lc_sem);
- com->lc_new_checked++;
-
- if (ent->lde_attrs & LUDA_UPGRADE) {
- ns->ln_flags |= LF_UPGRADE;
- repaired = true;
- } else if (ent->lde_attrs & LUDA_REPAIR) {
- ns->ln_flags |= LF_INCONSISTENT;
- repaired = true;
- }
-
- if (ent->lde_name[0] == '.' &&
- (ent->lde_namelen == 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) &&
- (com->lc_journal || repaired)) {
-
-again:
- LASSERT(!locked);
-
- com->lc_journal = 1;
- handle = dt_trans_create(env, lfsck->li_next);
- if (IS_ERR(handle))
- GOTO(out, rc = PTR_ERR(handle));
-
- rc = lfsck_declare_namespace_exec_dir(env, obj, handle);
- if (rc != 0)
- GOTO(stop, rc);
-
- rc = dt_trans_start(env, lfsck->li_next, handle);
- if (rc != 0)
- GOTO(stop, rc);
-
- dt_write_lock(env, obj, MOR_TGT_CHILD);
- locked = true;
- }
-
- rc = lfsck_namespace_check_exist(env, lfsck, obj, ent->lde_name);
- if (rc != 0)
- GOTO(stop, rc);
-
- rc = lfsck_links_read(env, obj, &ldata);
- if (rc == 0) {
- count = ldata.ld_leh->leh_reccount;
- rc = linkea_links_find(&ldata, cname, pfid);
- if ((rc == 0) &&
- (count == 1 || !S_ISDIR(lfsck_object_type(obj))))
- goto record;
+ struct lfsck_assistant_data *lad = com->lc_data;
+ struct lfsck_namespace_req *lnr;
+ bool wakeup = false;
- ns->ln_flags |= LF_INCONSISTENT;
- /* For dir, if there are more than one linkea entries, or the
- * linkea entry does not match the name entry, then remove all
- * and add the correct one. */
- if (S_ISDIR(lfsck_object_type(obj))) {
- remove = true;
- newdata = true;
- } else {
- remove = false;
- newdata = false;
- }
- goto nodata;
- } else if (unlikely(rc == -EINVAL)) {
- count = 1;
- ns->ln_flags |= LF_INCONSISTENT;
- /* The magic crashed, we are not sure whether there are more
- * corrupt data in the linkea, so remove all linkea entries. */
- remove = true;
- newdata = true;
- goto nodata;
- } else if (rc == -ENODATA) {
- count = 1;
- ns->ln_flags |= LF_UPGRADE;
- remove = false;
- newdata = true;
-
-nodata:
- if (bk->lb_param & LPF_DRYRUN) {
- repaired = true;
- goto record;
- }
-
- if (!com->lc_journal)
- goto again;
-
- if (remove) {
- LASSERT(newdata);
-
- rc = dt_xattr_del(env, obj, XATTR_NAME_LINK, handle,
- BYPASS_CAPA);
- if (rc != 0)
- GOTO(stop, rc);
- }
-
- if (newdata) {
- rc = linkea_data_new(&ldata,
- &lfsck_env_info(env)->lti_linkea_buf);
- if (rc != 0)
- GOTO(stop, rc);
- }
-
- rc = linkea_add_buf(&ldata, cname, pfid);
- if (rc != 0)
- GOTO(stop, rc);
-
- rc = lfsck_links_write(env, obj, &ldata, handle);
- if (rc != 0)
- GOTO(stop, rc);
+ lnr = lfsck_namespace_assistant_req_init(com->lc_lfsck, ent, type);
+ if (IS_ERR(lnr)) {
+ struct lfsck_namespace *ns = com->lc_file_ram;
- count = ldata.ld_leh->leh_reccount;
- repaired = true;
- } else {
- GOTO(stop, rc);
+ lfsck_namespace_record_failure(env, com->lc_lfsck, ns);
+ return PTR_ERR(lnr);
}
-record:
- LASSERT(count > 0);
-
- rc = dt_attr_get(env, obj, la, BYPASS_CAPA);
- if (rc != 0)
- GOTO(stop, rc);
-
- if ((count == 1) &&
- (la->la_nlink == 1 || S_ISDIR(lfsck_object_type(obj))))
- /* Usually, it is for single linked object or dir, do nothing.*/
- GOTO(stop, rc);
-
- /* Following modification will be in another transaction. */
- if (handle != NULL) {
- LASSERT(dt_write_locked(env, obj));
-
- dt_write_unlock(env, obj);
- locked = false;
-
- dt_trans_stop(env, lfsck->li_next, handle);
- handle = NULL;
+ 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;
}
- ns->ln_mlinked_checked++;
- rc = lfsck_namespace_update(env, com, cfid,
- count != la->la_nlink ? LLF_UNMATCH_NLINKS : 0, false);
-
- GOTO(out, rc);
-
-stop:
- if (locked)
- dt_write_unlock(env, obj);
+ list_add_tail(&lnr->lnr_lar.lar_list, &lad->lad_req_list);
+ if (lad->lad_prefetched == 0)
+ wakeup = true;
- if (handle != NULL)
- dt_trans_stop(env, lfsck->li_next, handle);
+ lad->lad_prefetched++;
+ spin_unlock(&lad->lad_lock);
+ if (wakeup)
+ wake_up_all(&lad->lad_thread.t_ctl_waitq);
-out:
- if (rc < 0) {
- ns->ln_items_failed++;
- if (lfsck_pos_is_zero(&ns->ln_pos_first_inconsistent))
- lfsck_pos_fill(env, lfsck,
- &ns->ln_pos_first_inconsistent, false);
- if (!(bk->lb_param & LPF_FAILOUT))
- rc = 0;
- } else {
- if (repaired) {
- ns->ln_items_repaired++;
- if (bk->lb_param & LPF_DRYRUN &&
- lfsck_pos_is_zero(&ns->ln_pos_first_inconsistent))
- lfsck_pos_fill(env, lfsck,
- &ns->ln_pos_first_inconsistent,
- false);
- } else {
- com->lc_journal = 0;
- }
- rc = 0;
- }
+ down_write(&com->lc_sem);
+ com->lc_new_checked++;
up_write(&com->lc_sem);
- return rc;
+
+ return 0;
}
static int lfsck_namespace_post(const struct lu_env *env,
struct lfsck_instance *lfsck = com->lc_lfsck;
struct lfsck_namespace *ns = com->lc_file_ram;
int rc;
+ ENTRY;
- down_write(&com->lc_sem);
+ lfsck_post_generic(env, com, &result);
+ down_write(&com->lc_sem);
spin_lock(&lfsck->li_lock);
if (!init)
- ns->ln_pos_last_checkpoint = lfsck->li_pos_current;
+ 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;
- cfs_list_del_init(&com->lc_link);
- cfs_list_del_init(&com->lc_link_dir);
- cfs_list_add_tail(&com->lc_link, &lfsck->li_list_double_scan);
+ list_del_init(&com->lc_link_dir);
+ list_move_tail(&com->lc_link, &lfsck->li_list_double_scan);
} else if (result == 0) {
ns->ln_status = lfsck->li_status;
if (ns->ln_status == 0)
ns->ln_status = LS_STOPPED;
if (ns->ln_status != LS_PAUSED) {
- cfs_list_del_init(&com->lc_link);
- cfs_list_del_init(&com->lc_link_dir);
- cfs_list_add_tail(&com->lc_link, &lfsck->li_list_idle);
+ list_del_init(&com->lc_link_dir);
+ list_move_tail(&com->lc_link, &lfsck->li_list_idle);
}
} else {
ns->ln_status = LS_FAILED;
- cfs_list_del_init(&com->lc_link);
- cfs_list_del_init(&com->lc_link_dir);
- cfs_list_add_tail(&com->lc_link, &lfsck->li_list_idle);
+ list_del_init(&com->lc_link_dir);
+ list_move_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);
- return rc;
+
+ 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,
- char *buf, int len)
+ 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 save = len;
- int ret = -ENOSPC;
int rc;
down_read(&com->lc_sem);
- rc = snprintf(buf, len,
- "name: lfsck_namespace\n"
- "magic: %#x\n"
- "version: %d\n"
- "status: %s\n",
- ns->ln_magic,
- bk->lb_version,
- lfsck_status2names(ns->ln_status));
- if (rc <= 0)
- goto out;
-
- buf += rc;
- len -= rc;
- rc = lfsck_bits_dump(&buf, &len, ns->ln_flags, lfsck_flags_names,
- "flags");
+ 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(&buf, &len, bk->lb_param, lfsck_param_names,
- "param");
+ rc = lfsck_bits_dump(m, bk->lb_param, lfsck_param_names, "param");
if (rc < 0)
goto out;
- rc = lfsck_time_dump(&buf, &len, ns->ln_time_last_complete,
+ rc = lfsck_time_dump(m, ns->ln_time_last_complete,
"time_since_last_completed");
if (rc < 0)
goto out;
- rc = lfsck_time_dump(&buf, &len, ns->ln_time_latest_start,
+ rc = lfsck_time_dump(m, ns->ln_time_latest_start,
"time_since_latest_start");
if (rc < 0)
goto out;
- rc = lfsck_time_dump(&buf, &len, ns->ln_time_last_checkpoint,
+ rc = lfsck_time_dump(m, ns->ln_time_last_checkpoint,
"time_since_last_checkpoint");
if (rc < 0)
goto out;
- rc = lfsck_pos_dump(&buf, &len, &ns->ln_pos_latest_start,
+ rc = lfsck_pos_dump(m, &ns->ln_pos_latest_start,
"latest_start_position");
if (rc < 0)
goto out;
- rc = lfsck_pos_dump(&buf, &len, &ns->ln_pos_last_checkpoint,
+ rc = lfsck_pos_dump(m, &ns->ln_pos_last_checkpoint,
"last_checkpoint_position");
if (rc < 0)
goto out;
- rc = lfsck_pos_dump(&buf, &len, &ns->ln_pos_first_inconsistent,
+ rc = lfsck_pos_dump(m, &ns->ln_pos_first_inconsistent,
"first_failure_position");
if (rc < 0)
goto out;
do_div(new_checked, duration);
if (rtime != 0)
do_div(speed, rtime);
- rc = snprintf(buf, len,
- "checked_phase1: "LPU64"\n"
+ 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"
- "dirs: "LPU64"\n"
- "M-linked: "LPU64"\n"
+ "directories: "LPU64"\n"
+ "multi_linked_files: "LPU64"\n"
+ "dirent_repaired: "LPU64"\n"
+ "linkea_repaired: "LPU64"\n"
"nlinks_repaired: "LPU64"\n"
"lost_found: "LPU64"\n"
"success_count: %u\n"
"run_time_phase2: %u seconds\n"
"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",
+ "real_time_speed_phase1: "LPU64" items/sec\n"
+ "real_time_speed_phase2: N/A\n",
checked,
ns->ln_objs_checked_phase2,
ns->ln_items_repaired,
ns->ln_objs_failed_phase2,
ns->ln_dirs_checked,
ns->ln_mlinked_checked,
+ ns->ln_dirent_repaired,
+ ns->ln_linkea_repaired,
ns->ln_objs_nlink_repaired,
ns->ln_objs_lost_found,
ns->ln_success_count,
ns->ln_run_time_phase2,
speed,
new_checked);
- if (rc <= 0)
- goto out;
-
- buf += rc;
- len -= rc;
LASSERT(lfsck->li_di_oit != NULL);
pos.lp_dir_cookie = 0;
}
spin_unlock(&lfsck->li_lock);
- rc = lfsck_pos_dump(&buf, &len, &pos, "current_position");
- if (rc <= 0)
- goto out;
+ 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;
do_div(speed1, ns->ln_run_time_phase1);
if (rtime != 0)
do_div(speed2, rtime);
- rc = snprintf(buf, len,
- "checked_phase1: "LPU64"\n"
+ 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"
- "dirs: "LPU64"\n"
- "M-linked: "LPU64"\n"
+ "directories: "LPU64"\n"
+ "multi_linked_files: "LPU64"\n"
+ "dirent_repaired: "LPU64"\n"
+ "linkea_repaired: "LPU64"\n"
"nlinks_repaired: "LPU64"\n"
"lost_found: "LPU64"\n"
"success_count: %u\n"
"run_time_phase2: %u seconds\n"
"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"
+ "real_time_speed_phase1: N/A\n"
+ "real_time_speed_phase2: "LPU64" objs/sec\n"
"current_position: "DFID"\n",
ns->ln_items_checked,
checked,
ns->ln_objs_failed_phase2,
ns->ln_dirs_checked,
ns->ln_mlinked_checked,
+ ns->ln_dirent_repaired,
+ ns->ln_linkea_repaired,
ns->ln_objs_nlink_repaired,
ns->ln_objs_lost_found,
ns->ln_success_count,
speed2,
new_checked,
PFID(&ns->ln_fid_latest_scanned_phase2));
- if (rc <= 0)
- goto out;
-
- buf += rc;
- len -= rc;
} else {
__u64 speed1 = ns->ln_items_checked;
__u64 speed2 = ns->ln_objs_checked_phase2;
do_div(speed1, ns->ln_run_time_phase1);
if (ns->ln_run_time_phase2 != 0)
do_div(speed2, ns->ln_run_time_phase2);
- rc = snprintf(buf, len,
- "checked_phase1: "LPU64"\n"
+ 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"
- "dirs: "LPU64"\n"
- "M-linked: "LPU64"\n"
+ "directories: "LPU64"\n"
+ "multi_linked_files: "LPU64"\n"
+ "dirent_repaired: "LPU64"\n"
+ "linkea_repaired: "LPU64"\n"
"nlinks_repaired: "LPU64"\n"
"lost_found: "LPU64"\n"
"success_count: %u\n"
"run_time_phase2: %u seconds\n"
"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"
+ "real_time_speed_phase1: N/A\n"
+ "real_time_speed_phase2: N/A\n"
"current_position: N/A\n",
ns->ln_items_checked,
ns->ln_objs_checked_phase2,
ns->ln_objs_failed_phase2,
ns->ln_dirs_checked,
ns->ln_mlinked_checked,
+ ns->ln_dirent_repaired,
+ ns->ln_linkea_repaired,
ns->ln_objs_nlink_repaired,
ns->ln_objs_lost_found,
ns->ln_success_count,
ns->ln_run_time_phase2,
speed1,
speed2);
- if (rc <= 0)
- goto out;
+ }
+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;
+
+ return lfsck_double_scan_generic(env, com, ns->ln_status);
+}
+
+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;
+
+ 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);
+
+ CFS_FREE_BITMAP(lad->lad_bitmap);
+
+ OBD_FREE_PTR(lad);
+}
+
+static int lfsck_namespace_in_notify(const struct lu_env *env,
+ struct lfsck_component *com,
+ struct lfsck_request *lr)
+{
+ 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;
+ bool fail = false;
+ ENTRY;
+
+ if (lr->lr_event != LE_PHASE1_DONE &&
+ lr->lr_event != LE_PHASE2_DONE &&
+ lr->lr_event != LE_PEER_EXIT)
+ RETURN(-EINVAL);
+
+ CDEBUG(D_LFSCK, "%s: namespace LFSCK handles notify %u from MDT %x, "
+ "status %d\n", lfsck_lfsck2name(lfsck), lr->lr_event,
+ lr->lr_index, lr->lr_status);
+
+ 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 (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_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_quit_generic,
+ .lfsck_in_notify = lfsck_namespace_in_notify,
+ .lfsck_query = lfsck_namespace_query,
+};
+
+static int lfsck_namespace_assistant_handler_p1(const struct lu_env *env,
+ struct lfsck_component *com,
+ struct lfsck_assistant_req *lar)
+{
+ struct lfsck_thread_info *info = lfsck_env_info(env);
+ struct lu_attr *la = &info->lti_la;
+ struct lfsck_instance *lfsck = com->lc_lfsck;
+ struct lfsck_bookmark *bk = &lfsck->li_bookmark_ram;
+ struct lfsck_namespace *ns = com->lc_file_ram;
+ struct linkea_data ldata = { 0 };
+ const struct lu_name *cname;
+ struct thandle *handle = NULL;
+ struct lfsck_namespace_req *lnr =
+ container_of0(lar, struct lfsck_namespace_req, lnr_lar);
+ struct dt_object *dir = lnr->lnr_obj;
+ struct dt_object *obj = NULL;
+ const struct lu_fid *pfid = lfsck_dto2fid(dir);
+ bool repaired = false;
+ bool locked = false;
+ bool remove;
+ bool newdata;
+ bool log = false;
+ int count = 0;
+ int rc;
+ ENTRY;
+
+ if (lnr->lnr_attr & LUDA_UPGRADE) {
+ ns->ln_flags |= LF_UPGRADE;
+ ns->ln_dirent_repaired++;
+ repaired = true;
+ } else if (lnr->lnr_attr & LUDA_REPAIR) {
+ ns->ln_flags |= LF_INCONSISTENT;
+ ns->ln_dirent_repaired++;
+ repaired = true;
+ }
+
+ if (lnr->lnr_name[0] == '.' &&
+ (lnr->lnr_namelen == 1 ||
+ (lnr->lnr_namelen == 2 && lnr->lnr_name[1] == '.') ||
+ fid_seq_is_dot(fid_seq(&lnr->lnr_fid))))
+ GOTO(out, rc = 0);
+
+ obj = lfsck_object_find(env, lfsck, &lnr->lnr_fid);
+ if (IS_ERR(obj))
+ GOTO(out, rc = PTR_ERR(obj));
+
+ if (dt_object_exists(obj) == 0) {
+ rc = lfsck_namespace_check_exist(env, dir, obj, lnr->lnr_name);
+ if (rc != 0)
+ GOTO(out, rc);
+
+ /* XXX: dangling name entry, will handle it in other patch. */
+ GOTO(out, rc);
+ }
+
+ cname = lfsck_name_get_const(env, lnr->lnr_name, lnr->lnr_namelen);
+ if (!(bk->lb_param & LPF_DRYRUN) &&
+ (com->lc_journal || repaired)) {
+
+again:
+ LASSERT(!locked);
+
+ com->lc_journal = 1;
+ handle = dt_trans_create(env, lfsck->li_next);
+ if (IS_ERR(handle))
+ GOTO(out, rc = PTR_ERR(handle));
+
+ rc = lfsck_declare_namespace_exec_dir(env, obj, handle);
+ if (rc != 0)
+ GOTO(stop, rc);
+
+ rc = dt_trans_start(env, lfsck->li_next, handle);
+ if (rc != 0)
+ GOTO(stop, rc);
+
+ dt_write_lock(env, obj, MOR_TGT_CHILD);
+ locked = true;
+ }
+
+ rc = lfsck_namespace_check_exist(env, dir, obj, lnr->lnr_name);
+ if (rc != 0)
+ GOTO(stop, rc);
+
+ rc = lfsck_links_read(env, obj, &ldata);
+ if (rc == 0) {
+ count = ldata.ld_leh->leh_reccount;
+ rc = linkea_links_find(&ldata, cname, pfid);
+ if ((rc == 0) &&
+ (count == 1 || !S_ISDIR(lfsck_object_type(obj))))
+ goto record;
+
+ ns->ln_flags |= LF_INCONSISTENT;
+ /* For dir, if there are more than one linkea entries, or the
+ * linkea entry does not match the name entry, then remove all
+ * and add the correct one. */
+ if (S_ISDIR(lfsck_object_type(obj))) {
+ remove = true;
+ newdata = true;
+ } else {
+ remove = false;
+ newdata = false;
+ }
+ goto nodata;
+ } else if (unlikely(rc == -EINVAL)) {
+ count = 1;
+ ns->ln_flags |= LF_INCONSISTENT;
+ /* The magic crashed, we are not sure whether there are more
+ * corrupt data in the linkea, so remove all linkea entries. */
+ remove = true;
+ newdata = true;
+ goto nodata;
+ } else if (rc == -ENODATA) {
+ count = 1;
+ ns->ln_flags |= LF_UPGRADE;
+ remove = false;
+ newdata = true;
+
+nodata:
+ if (bk->lb_param & LPF_DRYRUN) {
+ ns->ln_linkea_repaired++;
+ repaired = true;
+ log = true;
+ goto record;
+ }
+
+ if (!com->lc_journal)
+ goto again;
+
+ if (remove) {
+ LASSERT(newdata);
+
+ rc = dt_xattr_del(env, obj, XATTR_NAME_LINK, handle,
+ BYPASS_CAPA);
+ if (rc != 0)
+ GOTO(stop, rc);
+ }
+
+ if (newdata) {
+ rc = linkea_data_new(&ldata,
+ &lfsck_env_info(env)->lti_linkea_buf);
+ if (rc != 0)
+ GOTO(stop, rc);
+ }
+
+ rc = linkea_add_buf(&ldata, cname, pfid);
+ if (rc != 0)
+ GOTO(stop, rc);
+
+ rc = lfsck_links_write(env, obj, &ldata, handle);
+ if (rc != 0)
+ GOTO(stop, rc);
+
+ count = ldata.ld_leh->leh_reccount;
+ ns->ln_linkea_repaired++;
+ repaired = true;
+ log = true;
+ } else {
+ GOTO(stop, rc);
+ }
+
+record:
+ LASSERT(count > 0);
+
+ rc = dt_attr_get(env, obj, la, BYPASS_CAPA);
+ if (rc != 0)
+ GOTO(stop, rc);
+
+ if ((count == 1) &&
+ (la->la_nlink == 1 || S_ISDIR(lfsck_object_type(obj))))
+ /* Usually, it is for single linked object or dir, do nothing.*/
+ GOTO(stop, rc);
+
+ /* Following modification will be in another transaction. */
+ if (handle != NULL) {
+ LASSERT(dt_write_locked(env, obj));
+
+ dt_write_unlock(env, obj);
+ locked = false;
- buf += rc;
- len -= rc;
+ dt_trans_stop(env, lfsck->li_next, handle);
+ handle = NULL;
}
- ret = save - len;
+
+ ns->ln_mlinked_checked++;
+ rc = lfsck_namespace_update(env, com, &lnr->lnr_fid,
+ count != la->la_nlink ? LLF_UNMATCH_NLINKS : 0, false);
+
+ GOTO(out, rc);
+
+stop:
+ if (locked)
+ dt_write_unlock(env, obj);
+
+ if (handle != NULL)
+ dt_trans_stop(env, lfsck->li_next, handle);
out:
- up_read(&com->lc_sem);
- return ret;
+ down_write(&com->lc_sem);
+ if (rc < 0) {
+ CDEBUG(D_LFSCK, "%s: namespace LFSCK assistant fail to handle "
+ "the entry: "DFID", parent "DFID", name %.*s: rc = %d\n",
+ lfsck_lfsck2name(lfsck), PFID(&lnr->lnr_fid),
+ PFID(lfsck_dto2fid(lnr->lnr_obj)),
+ lnr->lnr_namelen, lnr->lnr_name, rc);
+
+ lfsck_namespace_record_failure(env, lfsck, ns);
+ if (!(bk->lb_param & LPF_FAILOUT))
+ rc = 0;
+ } else {
+ if (log)
+ CDEBUG(D_LFSCK, "%s: namespace LFSCK assistant "
+ "repaired the entry: "DFID", parent "DFID
+ ", name %.*s\n", lfsck_lfsck2name(lfsck),
+ PFID(&lnr->lnr_fid),
+ PFID(lfsck_dto2fid(lnr->lnr_obj)),
+ lnr->lnr_namelen, lnr->lnr_name);
+
+ if (repaired) {
+ ns->ln_items_repaired++;
+ if (bk->lb_param & LPF_DRYRUN &&
+ lfsck_pos_is_zero(&ns->ln_pos_first_inconsistent))
+ lfsck_pos_fill(env, lfsck,
+ &ns->ln_pos_first_inconsistent,
+ false);
+ } else {
+ com->lc_journal = 0;
+ }
+ rc = 0;
+ }
+ up_write(&com->lc_sem);
+
+ if (obj != NULL && !IS_ERR(obj))
+ lfsck_object_put(env, obj);
+ return rc;
}
-static int lfsck_namespace_double_scan_main(void *args)
+static int lfsck_namespace_assistant_handler_p2(const struct lu_env *env,
+ struct lfsck_component *com)
{
- 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;
__u8 flags = 0;
ENTRY;
+ CDEBUG(D_LFSCK, "%s: namespace LFSCK phase2 scan start\n",
+ lfsck_lfsck2name(lfsck));
+
com->lc_new_checked = 0;
com->lc_new_scanned = 0;
com->lc_time_last_checkpoint = cfs_time_current();
di = iops->init(env, obj, 0, BYPASS_CAPA);
if (IS_ERR(di))
- GOTO(out, rc = PTR_ERR(di));
+ RETURN(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(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) {
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)) {
+ if (IS_ERR(target)) {
rc = PTR_ERR(target);
goto checkpoint;
}
fini:
iops->fini(env, di);
+ return rc;
+}
-out:
- down_write(&com->lc_sem);
+static void lfsck_namespace_assistant_fill_pos(const struct lu_env *env,
+ struct lfsck_component *com,
+ struct lfsck_position *pos)
+{
+ struct lfsck_assistant_data *lad = com->lc_data;
+ struct lfsck_namespace_req *lnr;
+
+ if (list_empty(&lad->lad_req_list))
+ return;
+
+ lnr = list_entry(lad->lad_req_list.next,
+ struct lfsck_namespace_req,
+ lnr_lar.lar_list);
+ pos->lp_oit_cookie = lnr->lnr_oit_cookie;
+ pos->lp_dir_cookie = lnr->lnr_dir_cookie - 1;
+ pos->lp_dir_parent = *lfsck_dto2fid(lnr->lnr_obj);
+}
+
+static int lfsck_namespace_double_scan_result(const struct lu_env *env,
+ struct lfsck_component *com,
+ int rc)
+{
+ struct lfsck_instance *lfsck = com->lc_lfsck;
+ struct lfsck_namespace *ns = com->lc_file_ram;
+ 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();
if (rc > 0) {
com->lc_journal = 0;
- ns->ln_status = LS_COMPLETED;
- if (!(bk->lb_param & LPF_DRYRUN))
+ if (ns->ln_flags & LF_INCOMPLETE)
+ ns->ln_status = LS_PARTIAL;
+ else
+ ns->ln_status = LS_COMPLETED;
+ if (!(lfsck->li_bookmark_ram.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++;
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;
}
-static int lfsck_namespace_double_scan(const struct lu_env *env,
- struct lfsck_component *com)
+static void lfsck_namespace_assistant_sync_failures(const struct lu_env *env,
+ struct lfsck_component *com,
+ struct lfsck_request *lr)
{
- struct lfsck_instance *lfsck = com->lc_lfsck;
- struct lfsck_namespace *ns = com->lc_file_ram;
- struct lfsck_thread_args *lta;
- long rc;
- ENTRY;
+ /* XXX: TBD */
+}
+
+struct lfsck_assistant_operations lfsck_namespace_assistant_ops = {
+ .la_handler_p1 = lfsck_namespace_assistant_handler_p1,
+ .la_handler_p2 = lfsck_namespace_assistant_handler_p2,
+ .la_fill_pos = lfsck_namespace_assistant_fill_pos,
+ .la_double_scan_result = lfsck_namespace_double_scan_result,
+ .la_req_fini = lfsck_namespace_assistant_req_fini,
+ .la_sync_failures = lfsck_namespace_assistant_sync_failures,
+};
- if (unlikely(ns->ln_status != LS_SCANNING_PHASE2))
- RETURN(0);
+/**
+ * Verify the specified linkEA entry for the given directory object.
+ * If the object has no such linkEA entry or it has more other linkEA
+ * entries, then re-generate the linkEA with the given information.
+ *
+ * \param[in] env pointer to the thread context
+ * \param[in] dev pointer to the dt_device
+ * \param[in] obj pointer to the dt_object to be handled
+ * \param[in] cname the name for the child in the parent directory
+ * \param[in] pfid the parent directory's FID for the linkEA
+ *
+ * \retval 0 for success
+ * \retval negative error number on failure
+ */
+int lfsck_verify_linkea(const struct lu_env *env, struct dt_device *dev,
+ struct dt_object *obj, const struct lu_name *cname,
+ const struct lu_fid *pfid)
+{
+ struct linkea_data ldata = { 0 };
+ struct lu_buf linkea_buf;
+ struct thandle *th;
+ int rc;
+ int fl = LU_XATTR_CREATE;
+ bool dirty = false;
+ ENTRY;
- lta = lfsck_thread_args_init(lfsck, com);
- if (IS_ERR(lta))
- RETURN(PTR_ERR(lta));
+ LASSERT(S_ISDIR(lfsck_object_type(obj)));
- atomic_inc(&lfsck->li_double_scan_count);
- rc = PTR_ERR(kthread_run(lfsck_namespace_double_scan_main, lta,
- "lfsck_namespace"));
- if (IS_ERR_VALUE(rc)) {
- CERROR("%s: cannot start LFSCK namespace thread: rc = %ld\n",
- lfsck_lfsck2name(lfsck), rc);
- atomic_dec(&lfsck->li_double_scan_count);
- lfsck_thread_args_fini(lta);
- } else {
- rc = 0;
+ rc = lfsck_links_read(env, obj, &ldata);
+ if (rc == -ENODATA) {
+ dirty = true;
+ } else if (rc == 0) {
+ fl = LU_XATTR_REPLACE;
+ if (ldata.ld_leh->leh_reccount != 1) {
+ dirty = true;
+ } else {
+ rc = linkea_links_find(&ldata, cname, pfid);
+ if (rc != 0)
+ dirty = true;
+ }
}
- RETURN(rc);
+ if (!dirty)
+ RETURN(rc);
+
+ rc = linkea_data_new(&ldata, &lfsck_env_info(env)->lti_linkea_buf);
+ if (rc != 0)
+ RETURN(rc);
+
+ rc = linkea_add_buf(&ldata, cname, pfid);
+ if (rc != 0)
+ RETURN(rc);
+
+ lfsck_buf_init(&linkea_buf, ldata.ld_buf->lb_buf,
+ ldata.ld_leh->leh_len);
+ th = dt_trans_create(env, dev);
+ if (IS_ERR(th))
+ RETURN(PTR_ERR(th));
+
+ rc = dt_declare_xattr_set(env, obj, &linkea_buf,
+ XATTR_NAME_LINK, fl, th);
+ if (rc != 0)
+ GOTO(stop, rc = PTR_ERR(th));
+
+ rc = dt_trans_start_local(env, dev, th);
+ if (rc != 0)
+ GOTO(stop, rc);
+
+ dt_write_lock(env, obj, 0);
+ rc = dt_xattr_set(env, obj, &linkea_buf,
+ XATTR_NAME_LINK, fl, th, BYPASS_CAPA);
+ dt_write_unlock(env, obj);
+
+ GOTO(stop, rc);
+
+stop:
+ dt_trans_stop(env, dev, th);
+ return rc;
}
-static int lfsck_namespace_in_notify(const struct lu_env *env,
- struct lfsck_component *com,
- struct lfsck_request *lr)
+/**
+ * Get the name and parent directory's FID from the first linkEA entry.
+ *
+ * \param[in] env pointer to the thread context
+ * \param[in] obj pointer to the object which get linkEA from
+ * \param[out] name pointer to the buffer to hold the name
+ * in the first linkEA entry
+ * \param[out] pfid pointer to the buffer to hold the parent
+ * directory's FID in the first linkEA entry
+ *
+ * \retval 0 for success
+ * \retval negative error number on failure
+ */
+int lfsck_links_get_first(const struct lu_env *env, struct dt_object *obj,
+ char *name, struct lu_fid *pfid)
{
+ struct lu_name *cname = &lfsck_env_info(env)->lti_name;
+ struct linkea_data ldata = { 0 };
+ int rc;
+
+ rc = lfsck_links_read(env, obj, &ldata);
+ if (rc != 0)
+ return rc;
+
+ linkea_first_entry(&ldata);
+ if (ldata.ld_lee == NULL)
+ return -ENODATA;
+
+ linkea_entry_unpack(ldata.ld_lee, &ldata.ld_reclen, cname, pfid);
+ /* To guarantee the 'name' is terminated with '0'. */
+ memcpy(name, cname->ln_name, cname->ln_namelen);
+ name[cname->ln_namelen] = 0;
+
return 0;
}
-static int lfsck_namespace_query(const struct lu_env *env,
- struct lfsck_component *com)
+/**
+ * Remove the name entry from the parent directory.
+ *
+ * No need to care about the object referenced by the name entry,
+ * either the name entry is invalid or redundant, or the referenced
+ * object has been processed has been or will be handled by others.
+ *
+ * \param[in] env pointer to the thread context
+ * \param[in] lfsck pointer to the lfsck instance
+ * \param[in] parent pointer to the lost+found object
+ * \param[in] name the name for the name entry to be removed
+ * \param[in] type the type for the name entry to be removed
+ *
+ * \retval 0 for success
+ * \retval negative error number on failure
+ */
+int lfsck_remove_name_entry(const struct lu_env *env,
+ struct lfsck_instance *lfsck,
+ struct dt_object *parent,
+ const char *name, __u32 type)
{
- struct lfsck_namespace *ns = com->lc_file_ram;
+ struct dt_device *dev = lfsck->li_next;
+ struct thandle *th;
+ struct lustre_handle lh = { 0 };
+ int rc;
+ ENTRY;
- return ns->ln_status;
+ rc = lfsck_ibits_lock(env, lfsck, parent, &lh,
+ MDS_INODELOCK_UPDATE, LCK_EX);
+ if (rc != 0)
+ RETURN(rc);
+
+ th = dt_trans_create(env, dev);
+ if (IS_ERR(th))
+ GOTO(unlock, rc = PTR_ERR(th));
+
+ rc = dt_declare_delete(env, parent, (const struct dt_key *)name, th);
+ if (rc != 0)
+ GOTO(stop, rc);
+
+ if (S_ISDIR(type)) {
+ rc = dt_declare_ref_del(env, parent, th);
+ if (rc != 0)
+ GOTO(stop, rc);
+ }
+
+ rc = dt_trans_start(env, dev, th);
+ if (rc != 0)
+ GOTO(stop, rc);
+
+ rc = dt_delete(env, parent, (const struct dt_key *)name, th,
+ BYPASS_CAPA);
+ if (rc != 0)
+ GOTO(stop, rc);
+
+ if (S_ISDIR(type)) {
+ dt_write_lock(env, parent, 0);
+ rc = dt_ref_del(env, parent, th);
+ dt_write_unlock(env, parent);
+ }
+
+ GOTO(stop, rc);
+
+stop:
+ dt_trans_stop(env, dev, th);
+
+unlock:
+ lfsck_ibits_unlock(&lh, LCK_EX);
+
+ CDEBUG(D_LFSCK, "%s: remove name entry "DFID"/%s "
+ "with type %o: rc = %d\n", lfsck_lfsck2name(lfsck),
+ PFID(lfsck_dto2fid(parent)), name, type, rc);
+
+ return rc;
}
-static struct lfsck_operations lfsck_namespace_ops = {
- .lfsck_reset = lfsck_namespace_reset,
- .lfsck_fail = lfsck_namespace_fail,
- .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_in_notify = lfsck_namespace_in_notify,
- .lfsck_query = lfsck_namespace_query,
-};
+/**
+ * Update the object's name entry with the given FID.
+ *
+ * \param[in] env pointer to the thread context
+ * \param[in] lfsck pointer to the lfsck instance
+ * \param[in] parent pointer to the parent directory that holds
+ * the name entry
+ * \param[in] name the name for the entry to be updated
+ * \param[in] pfid the new PFID for the name entry
+ * \param[in] type the type for the name entry to be updated
+ *
+ * \retval 0 for success
+ * \retval negative error number on failure
+ */
+int lfsck_update_name_entry(const struct lu_env *env,
+ struct lfsck_instance *lfsck,
+ struct dt_object *parent, const char *name,
+ const struct lu_fid *pfid, __u32 type)
+{
+ struct dt_insert_rec *rec = &lfsck_env_info(env)->lti_dt_rec;
+ struct dt_device *dev = lfsck->li_next;
+ struct lustre_handle lh = { 0 };
+ struct thandle *th;
+ int rc;
+ bool exists = true;
+ ENTRY;
+
+ rc = lfsck_ibits_lock(env, lfsck, parent, &lh,
+ MDS_INODELOCK_UPDATE, LCK_EX);
+ if (rc != 0)
+ RETURN(rc);
+
+ th = dt_trans_create(env, dev);
+ if (IS_ERR(th))
+ GOTO(unlock, rc = PTR_ERR(th));
+
+ rc = dt_declare_delete(env, parent, (const struct dt_key *)name, th);
+ if (rc != 0)
+ GOTO(stop, rc);
+
+ rec->rec_type = type;
+ rec->rec_fid = pfid;
+ rc = dt_declare_insert(env, parent, (const struct dt_rec *)rec,
+ (const struct dt_key *)name, th);
+ if (rc != 0)
+ GOTO(stop, rc);
+
+ rc = dt_declare_ref_add(env, parent, th);
+ if (rc != 0)
+ GOTO(stop, rc);
+
+ rc = dt_trans_start(env, dev, th);
+ if (rc != 0)
+ GOTO(stop, rc);
+
+ rc = dt_delete(env, parent, (const struct dt_key *)name, th,
+ BYPASS_CAPA);
+ if (rc == -ENOENT) {
+ exists = false;
+ rc = 0;
+ }
+
+ if (rc != 0)
+ GOTO(stop, rc);
+
+ rc = dt_insert(env, parent, (const struct dt_rec *)rec,
+ (const struct dt_key *)name, th, BYPASS_CAPA, 1);
+ if (rc == 0 && S_ISDIR(type) && !exists) {
+ dt_write_lock(env, parent, 0);
+ rc = dt_ref_add(env, parent, th);
+ dt_write_unlock(env, parent);
+ }
+
+ GOTO(stop, rc);
+
+stop:
+ dt_trans_stop(env, dev, th);
+
+unlock:
+ lfsck_ibits_unlock(&lh, LCK_EX);
+
+ CDEBUG(D_LFSCK, "%s: update name entry "DFID"/%s with the FID "DFID
+ " and the type %o: rc = %d\n", lfsck_lfsck2name(lfsck),
+ PFID(lfsck_dto2fid(parent)), name, PFID(pfid), type, rc);
+
+ return rc;
+}
int lfsck_namespace_setup(const struct lu_env *env,
struct lfsck_instance *lfsck)
if (com == NULL)
RETURN(-ENOMEM);
- CFS_INIT_LIST_HEAD(&com->lc_link);
- CFS_INIT_LIST_HEAD(&com->lc_link_dir);
+ INIT_LIST_HEAD(&com->lc_link);
+ INIT_LIST_HEAD(&com->lc_link_dir);
init_rwsem(&com->lc_sem);
atomic_set(&com->lc_ref, 1);
com->lc_lfsck = lfsck;
- com->lc_type = LT_NAMESPACE;
+ com->lc_type = LFSCK_TYPE_NAMESPACE;
com->lc_ops = &lfsck_namespace_ops;
+ com->lc_data = lfsck_assistant_data_init(
+ &lfsck_namespace_assistant_ops,
+ "lfsck_namespace");
+ if (com->lc_data == NULL)
+ GOTO(out, rc = -ENOMEM);
+
com->lc_file_size = sizeof(struct lfsck_namespace);
OBD_ALLOC(com->lc_file_ram, com->lc_file_size);
if (com->lc_file_ram == NULL)
case LS_FAILED:
case LS_STOPPED:
spin_lock(&lfsck->li_lock);
- cfs_list_add_tail(&com->lc_link, &lfsck->li_list_idle);
+ list_add_tail(&com->lc_link, &lfsck->li_list_idle);
spin_unlock(&lfsck->li_lock);
break;
default:
- CERROR("%s: unknown lfsck_namespace status: rc = %u\n",
+ CERROR("%s: unknown lfsck_namespace status %d\n",
lfsck_lfsck2name(lfsck), ns->ln_status);
/* fall through */
case LS_SCANNING_PHASE1:
case LS_PAUSED:
case LS_CRASHED:
spin_lock(&lfsck->li_lock);
- cfs_list_add_tail(&com->lc_link, &lfsck->li_list_scan);
- cfs_list_add_tail(&com->lc_link_dir, &lfsck->li_list_dir);
+ list_add_tail(&com->lc_link, &lfsck->li_list_scan);
+ list_add_tail(&com->lc_link_dir, &lfsck->li_list_dir);
spin_unlock(&lfsck->li_lock);
break;
}
out:
if (root != NULL && !IS_ERR(root))
lu_object_put(env, &root->do_lu);
- if (rc != 0)
+ if (rc != 0) {
lfsck_component_cleanup(env, com);
+ CERROR("%s: fail to init namespace LFSCK component: rc = %d\n",
+ lfsck_lfsck2name(lfsck), rc);
+ }
return rc;
}
git://git.whamcloud.com / fs / lustre-release.git / blobdiff