static int lfsck_bookmark_load(const struct lu_env *env,
struct lfsck_instance *lfsck)
{
loff_t pos = 0;
int len = sizeof(struct lfsck_bookmark);
int rc;
rc = dt_record_read(env, lfsck->li_bookmark_obj,
lfsck_buf_get(env, &lfsck->li_bookmark_disk, len),
&pos);
if (rc == 0) {
struct lfsck_bookmark *bm = &lfsck->li_bookmark_ram;
lfsck_bookmark_le_to_cpu(bm, &lfsck->li_bookmark_disk);
if (bm->lb_magic != LFSCK_BOOKMARK_MAGIC) {
CWARN("%.16s: invalid lfsck_bookmark magic "
"0x%x != 0x%x\n", lfsck_lfsck2name(lfsck),
bm->lb_magic, LFSCK_BOOKMARK_MAGIC);
/* Process it as new lfsck_bookmark. */
rc = -ENODATA;
}
} else {
if (rc == -EFAULT && pos == 0)
/* return -ENODATA for empty lfsck_bookmark. */
rc = -ENODATA;
else
CERROR("%.16s: fail to load lfsck_bookmark, "
"expected = %d, rc = %d\n",
lfsck_lfsck2name(lfsck), len, rc);
}
return rc;
}
/**
* \retval +ve: the lfsck_namespace is broken, the caller should reset it.
* \retval 0: succeed.
* \retval -ve: failed cases.
*/
static int lfsck_namespace_load(const struct lu_env *env,
struct lfsck_component *com)
{
int len = com->lc_file_size;
int rc;
rc = dt_xattr_get(env, com->lc_obj,
lfsck_buf_get(env, com->lc_file_disk, len),
XATTR_NAME_LFSCK_NAMESPACE, BYPASS_CAPA);
if (rc == len) {
struct lfsck_namespace *ns = com->lc_file_ram;
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);
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);
if (rc >= 0)
rc = 1;
}
return rc;
}
static int lfsck_namespace_store(const struct lu_env *env,
struct lfsck_component *com, bool init)
{
struct dt_object *obj = com->lc_obj;
struct lfsck_instance *lfsck = com->lc_lfsck;
struct thandle *handle;
int len = com->lc_file_size;
int rc;
ENTRY;
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);
}
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);
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);
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);
return rc;
}
int lfsck_bookmark_store(const struct lu_env *env, struct lfsck_instance *lfsck)
{
struct thandle *handle;
struct dt_object *obj = lfsck->li_bookmark_obj;
loff_t pos = 0;
int len = sizeof(struct lfsck_bookmark);
int rc;
ENTRY;
lfsck_bookmark_cpu_to_le(&lfsck->li_bookmark_disk,
&lfsck->li_bookmark_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_bookmark: "
"rc = %d\n", lfsck_lfsck2name(lfsck), rc);
RETURN(rc);
}
rc = dt_declare_record_write(env, obj,
lfsck_buf_get(env,
&lfsck->li_bookmark_disk, len),
0, handle);
if (rc != 0) {
CERROR("%s: fail to declare trans for storing lfsck_bookmark: "
"rc = %d\n", lfsck_lfsck2name(lfsck), rc);
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_bookmark: "
"rc = %d\n", lfsck_lfsck2name(lfsck), rc);
GOTO(out, rc);
}
rc = dt_record_write(env, obj,
lfsck_buf_get(env, &lfsck->li_bookmark_disk, len),
&pos, handle);
if (rc != 0)
CERROR("%s: fail to store lfsck_bookmark: expected = %d, "
"rc = %d\n", lfsck_lfsck2name(lfsck), len, rc);
GOTO(out, rc);
out:
dt_trans_stop(env, lfsck->li_bottom, handle);
return rc;
}
static int lfsck_namespace_double_scan(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_thread_args *lta;
long rc;
ENTRY;
if (unlikely(ns->ln_status != LS_SCANNING_PHASE2))
RETURN(0);
lta = lfsck_thread_args_init(lfsck, com, NULL);
if (IS_ERR(lta))
RETURN(PTR_ERR(lta));
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;
}
RETURN(rc);
}
int lfsck_bookmark_store(const struct lu_env *env, struct lfsck_instance *lfsck)
{
struct thandle *handle;
struct dt_object *obj = lfsck->li_bookmark_obj;
struct dt_device *dev = lfsck_obj2dev(obj);
loff_t pos = 0;
int len = sizeof(struct lfsck_bookmark);
int rc;
ENTRY;
lfsck_bookmark_cpu_to_le(&lfsck->li_bookmark_disk,
&lfsck->li_bookmark_ram);
handle = dt_trans_create(env, dev);
if (IS_ERR(handle))
GOTO(log, rc = PTR_ERR(handle));
rc = dt_declare_record_write(env, obj,
lfsck_buf_get(env,
&lfsck->li_bookmark_disk, len),
0, handle);
if (rc != 0)
GOTO(out, rc);
rc = dt_trans_start_local(env, dev, handle);
if (rc != 0)
GOTO(out, rc);
rc = dt_record_write(env, obj,
lfsck_buf_get(env, &lfsck->li_bookmark_disk, len),
&pos, handle);
GOTO(out, rc);
out:
dt_trans_stop(env, dev, handle);
log:
if (rc != 0)
CDEBUG(D_LFSCK, "%s: fail to store lfsck_bookmark: rc = %d\n",
lfsck_lfsck2name(lfsck), rc);
return rc;
}
int lfsck_master_engine(void *args)
{
struct lfsck_thread_args *lta = args;
struct lu_env *env = <a->lta_env;
struct lfsck_instance *lfsck = lta->lta_lfsck;
struct ptlrpc_thread *thread = &lfsck->li_thread;
struct dt_object *oit_obj = lfsck->li_obj_oit;
const struct dt_it_ops *oit_iops = &oit_obj->do_index_ops->dio_it;
struct dt_it *oit_di;
struct l_wait_info lwi = { 0 };
int rc;
ENTRY;
oit_di = oit_iops->init(env, oit_obj, lfsck->li_args_oit, BYPASS_CAPA);
if (IS_ERR(oit_di)) {
rc = PTR_ERR(oit_di);
CERROR("%s: LFSCK, fail to init iteration: rc = %d\n",
lfsck_lfsck2name(lfsck), rc);
GOTO(fini_args, rc);
}
spin_lock(&lfsck->li_lock);
lfsck->li_di_oit = oit_di;
spin_unlock(&lfsck->li_lock);
rc = lfsck_prep(env, lfsck, lta->lta_lsp);
if (rc != 0)
GOTO(fini_oit, rc);
CDEBUG(D_LFSCK, "LFSCK entry: oit_flags = %#x, dir_flags = %#x, "
"oit_cookie = "LPU64", dir_cookie = "LPU64", parent = "DFID
", pid = %d\n", lfsck->li_args_oit, lfsck->li_args_dir,
lfsck->li_pos_current.lp_oit_cookie,
lfsck->li_pos_current.lp_dir_cookie,
PFID(&lfsck->li_pos_current.lp_dir_parent),
current_pid());
spin_lock(&lfsck->li_lock);
thread_set_flags(thread, SVC_RUNNING);
spin_unlock(&lfsck->li_lock);
wake_up_all(&thread->t_ctl_waitq);
l_wait_event(thread->t_ctl_waitq,
lfsck->li_start_unplug ||
!thread_is_running(thread),
&lwi);
if (!thread_is_running(thread))
GOTO(fini_oit, rc = 0);
if (!cfs_list_empty(&lfsck->li_list_scan) ||
cfs_list_empty(&lfsck->li_list_double_scan))
rc = lfsck_master_oit_engine(env, lfsck);
else
rc = 1;
CDEBUG(D_LFSCK, "LFSCK exit: oit_flags = %#x, dir_flags = %#x, "
"oit_cookie = "LPU64", dir_cookie = "LPU64", parent = "DFID
", pid = %d, rc = %d\n", lfsck->li_args_oit, lfsck->li_args_dir,
lfsck->li_pos_current.lp_oit_cookie,
lfsck->li_pos_current.lp_dir_cookie,
PFID(&lfsck->li_pos_current.lp_dir_parent),
current_pid(), rc);
if (!OBD_FAIL_CHECK(OBD_FAIL_LFSCK_CRASH))
rc = lfsck_post(env, lfsck, rc);
if (lfsck->li_di_dir != NULL)
lfsck_close_dir(env, lfsck);
fini_oit:
lfsck_di_oit_put(env, lfsck);
oit_iops->fini(env, oit_di);
if (rc == 1) {
if (!cfs_list_empty(&lfsck->li_list_double_scan))
rc = lfsck_double_scan(env, lfsck);
else
rc = 0;
} else {
lfsck_quit(env, lfsck);
}
/* XXX: Purge the pinned objects in the future. */
fini_args:
spin_lock(&lfsck->li_lock);
thread_set_flags(thread, SVC_STOPPED);
spin_unlock(&lfsck->li_lock);
wake_up_all(&thread->t_ctl_waitq);
lfsck_thread_args_fini(lta);
return rc;
}
/**
* \retval +ve repaired
* \retval 0 no need to repair
* \retval -ve error cases
*/
static int lfsck_namespace_double_scan_one(const struct lu_env *env,
struct lfsck_component *com,
struct dt_object *child, __u8 flags)
{
struct lfsck_thread_info *info = lfsck_env_info(env);
struct lu_attr *la = &info->lti_la;
struct lu_name *cname = &info->lti_name;
struct lu_fid *pfid = &info->lti_fid;
struct lu_fid *cfid = &info->lti_fid2;
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 };
struct thandle *handle = NULL;
bool locked = false;
bool update = false;
int rc;
ENTRY;
if (com->lc_journal) {
again:
LASSERT(!locked);
update = false;
com->lc_journal = 1;
handle = dt_trans_create(env, lfsck->li_next);
if (IS_ERR(handle))
RETURN(rc = PTR_ERR(handle));
rc = dt_declare_xattr_set(env, child,
lfsck_buf_get_const(env, NULL, DEFAULT_LINKEA_SIZE),
XATTR_NAME_LINK, 0, 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, child, MOR_TGT_CHILD);
locked = true;
}
if (unlikely(lfsck_is_dead_obj(child)))
GOTO(stop, rc = 0);
rc = dt_attr_get(env, child, la, BYPASS_CAPA);
if (rc == 0)
rc = lfsck_links_read(env, child, &ldata);
if (rc != 0) {
if ((bk->lb_param & LPF_DRYRUN) &&
(rc == -EINVAL || rc == -ENODATA))
rc = 1;
GOTO(stop, rc);
}
linkea_first_entry(&ldata);
while (ldata.ld_lee != NULL) {
struct dt_object *parent = NULL;
rc = lfsck_linkea_entry_unpack(lfsck, &ldata, cname, pfid);
if (rc > 0)
update = true;
if (!fid_is_sane(pfid))
goto shrink;
parent = lfsck_object_find(env, lfsck, pfid);
if (parent == NULL)
goto shrink;
else if (IS_ERR(parent))
GOTO(stop, rc = PTR_ERR(parent));
if (!dt_object_exists(parent))
goto shrink;
/* XXX: Currently, skip remote object, the consistency for
* remote object will be processed in LFSCK phase III. */
if (dt_object_remote(parent)) {
lfsck_object_put(env, parent);
linkea_next_entry(&ldata);
continue;
}
if (unlikely(!dt_try_as_dir(env, parent)))
goto shrink;
/* To guarantee the 'name' is terminated with '0'. */
memcpy(info->lti_key, cname->ln_name, cname->ln_namelen);
info->lti_key[cname->ln_namelen] = 0;
cname->ln_name = info->lti_key;
rc = dt_lookup(env, parent, (struct dt_rec *)cfid,
(const struct dt_key *)cname->ln_name,
BYPASS_CAPA);
if (rc != 0 && rc != -ENOENT) {
lfsck_object_put(env, parent);
GOTO(stop, rc);
}
if (rc == 0) {
if (lu_fid_eq(cfid, lfsck_dto2fid(child))) {
lfsck_object_put(env, parent);
linkea_next_entry(&ldata);
continue;
}
goto shrink;
}
/* If there is no name entry in the parent dir and the object
* link count is less than the linkea entries count, then the
* linkea entry should be removed. */
if (ldata.ld_leh->leh_reccount > la->la_nlink)
goto shrink;
/* XXX: For the case of there is a linkea entry, but without
* name entry pointing to the object and its hard links
* count is not less than the object name entries count,
* then seems we should add the 'missed' name entry back
* to namespace, but before LFSCK phase III finished, we
* do not know whether the object has some inconsistency
* on other MDTs. So now, do NOT add the name entry back
* to the namespace, but keep the linkEA entry. LU-2914 */
lfsck_object_put(env, parent);
linkea_next_entry(&ldata);
continue;
shrink:
if (parent != NULL)
lfsck_object_put(env, 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));
linkea_del_buf(&ldata, cname);
update = true;
}
if (update) {
if (!com->lc_journal) {
com->lc_journal = 1;
goto again;
}
rc = lfsck_links_write(env, child, &ldata, handle);
}
GOTO(stop, rc);
stop:
if (locked) {
/* XXX: For the case linkea entries count does not match the object hard
* links count, we cannot update the later one simply. Before LFSCK
* phase III finished, we cannot know whether there are some remote
* name entries to be repaired or not. LU-2914 */
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);
dt_write_unlock(env, child);
}
if (handle != NULL)
dt_trans_stop(env, lfsck->li_next, handle);
if (rc == 0 && update) {
ns->ln_objs_nlink_repaired++;
rc = 1;
}
return rc;
}
static int lfsck_namespace_update(const struct lu_env *env,
struct lfsck_component *com,
const struct lu_fid *fid,
__u8 flags, bool force)
{
struct lfsck_instance *lfsck = com->lc_lfsck;
struct lu_fid *key = &lfsck_env_info(env)->lti_fid;
struct thandle *handle;
struct dt_object *obj = com->lc_obj;
int rc;
bool exist = false;
__u8 tf;
ENTRY;
rc = lfsck_namespace_lookup(env, com, fid, &tf);
if (rc != 0 && rc != -ENOENT)
RETURN(rc);
if (rc == 0) {
if (!force || flags == tf)
RETURN(0);
exist = true;
handle = dt_trans_create(env, lfsck->li_bottom);
if (IS_ERR(handle))
RETURN(PTR_ERR(handle));
rc = dt_declare_delete(env, obj, (const struct dt_key *)fid,
handle);
if (rc != 0)
GOTO(out, rc);
} else {
handle = dt_trans_create(env, lfsck->li_bottom);
if (IS_ERR(handle))
RETURN(PTR_ERR(handle));
}
rc = dt_declare_insert(env, obj, (const struct dt_rec *)&flags,
(const struct dt_key *)fid, handle);
if (rc != 0)
GOTO(out, rc);
rc = dt_trans_start_local(env, lfsck->li_bottom, handle);
if (rc != 0)
GOTO(out, rc);
fid_cpu_to_be(key, fid);
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);
GOTO(out, rc);
}
}
rc = dt_insert(env, obj, (const struct dt_rec *)&flags,
(const struct dt_key *)key, handle, BYPASS_CAPA, 1);
GOTO(out, rc);
out:
dt_trans_stop(env, lfsck->li_bottom, handle);
return rc;
}
int lfsck_namespace_setup(const struct lu_env *env,
struct lfsck_instance *lfsck)
{
struct lfsck_component *com;
struct lfsck_namespace *ns;
struct dt_object *root = NULL;
struct dt_object *obj;
int rc;
ENTRY;
LASSERT(lfsck->li_master);
OBD_ALLOC_PTR(com);
if (com == NULL)
RETURN(-ENOMEM);
CFS_INIT_LIST_HEAD(&com->lc_link);
CFS_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_ops = &lfsck_namespace_ops;
com->lc_file_size = sizeof(struct lfsck_namespace);
OBD_ALLOC(com->lc_file_ram, com->lc_file_size);
if (com->lc_file_ram == NULL)
GOTO(out, rc = -ENOMEM);
OBD_ALLOC(com->lc_file_disk, com->lc_file_size);
if (com->lc_file_disk == NULL)
GOTO(out, rc = -ENOMEM);
root = dt_locate(env, lfsck->li_bottom, &lfsck->li_local_root_fid);
if (IS_ERR(root))
GOTO(out, rc = PTR_ERR(root));
if (unlikely(!dt_try_as_dir(env, root)))
GOTO(out, rc = -ENOTDIR);
obj = 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(obj))
GOTO(out, rc = PTR_ERR(obj));
com->lc_obj = obj;
rc = obj->do_ops->do_index_try(env, obj, &dt_lfsck_features);
if (rc != 0)
GOTO(out, rc);
rc = lfsck_namespace_load(env, com);
if (rc > 0)
rc = lfsck_namespace_reset(env, com, true);
else if (rc == -ENODATA)
rc = lfsck_namespace_init(env, com);
if (rc != 0)
GOTO(out, rc);
ns = com->lc_file_ram;
switch (ns->ln_status) {
case LS_INIT:
case LS_COMPLETED:
case LS_FAILED:
case LS_STOPPED:
spin_lock(&lfsck->li_lock);
cfs_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",
lfsck_lfsck2name(lfsck), ns->ln_status);
/* fall through */
case LS_SCANNING_PHASE1:
case LS_SCANNING_PHASE2:
/* No need to store the status to disk right now.
* If the system crashed before the status stored,
* it will be loaded back when next time. */
ns->ln_status = LS_CRASHED;
/* fall through */
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);
spin_unlock(&lfsck->li_lock);
break;
}
GOTO(out, rc = 0);
out:
if (root != NULL && !IS_ERR(root))
lu_object_put(env, &root->do_lu);
if (rc != 0)
lfsck_component_cleanup(env, com);
return rc;
}
