LU-1267 lfsck: framework (1) for MDT-OST consistency

[fs/lustre-release.git] / lustre / lfsck / lfsck_lib.c

diff --git a/lustre/lfsck/lfsck_lib.c b/lustre/lfsck/lfsck_lib.c
index a4c963c..37efbcc 100644 (file)
--- a/lustre/lfsck/lfsck_lib.c
+++ b/lustre/lfsck/lfsck_lib.c
@@ -60,48 +60,39 @@ LU_KEY_INIT_GENERIC(lfsck);
 static CFS_LIST_HEAD(lfsck_instance_list);
 static DEFINE_SPINLOCK(lfsck_instance_lock);
 
 static CFS_LIST_HEAD(lfsck_instance_list);
 static DEFINE_SPINLOCK(lfsck_instance_lock);
 

-const char *lfsck_status_names[] = {
-       "init",
-       "scanning-phase1",
-       "scanning-phase2",
-       "completed",
-       "failed",
-       "stopped",
-       "paused",
-       "crashed",
-       NULL
+static const char *lfsck_status_names[] = {
+       [LS_INIT]               = "init",
+       [LS_SCANNING_PHASE1]    = "scanning-phase1",
+       [LS_SCANNING_PHASE2]    = "scanning-phase2",
+       [LS_COMPLETED]          = "completed",
+       [LS_FAILED]             = "failed",
+       [LS_STOPPED]            = "stopped",
+       [LS_PAUSED]             = "paused",
+       [LS_CRASHED]            = "crashed",
+       [LS_PARTIAL]            = "partial"

 };
 
 const char *lfsck_flags_names[] = {
        "scanned-once",
        "inconsistent",
        "upgrade",
 };
 
 const char *lfsck_flags_names[] = {
        "scanned-once",
        "inconsistent",
        "upgrade",

+       "incomplete",

        NULL
 };
 
 const char *lfsck_param_names[] = {
        NULL
 };
 
 const char *lfsck_param_names[] = {

+       NULL,

        "failout",
        "dryrun",
        NULL
 };
 
        "failout",
        "dryrun",
        NULL
 };
 

-static inline void lfsck_component_get(struct lfsck_component *com)
+const char *lfsck_status2names(enum lfsck_status status)

 {
 {

-       atomic_inc(&com->lc_ref);
-}
+       if (unlikely(status < 0 || status >= LS_MAX))
+               return "unknown";

 
 

-static inline void lfsck_component_put(const struct lu_env *env,
-                                      struct lfsck_component *com)
-{
-       if (atomic_dec_and_test(&com->lc_ref)) {
-               if (com->lc_obj != NULL)
-                       lu_object_put_nocache(env, &com->lc_obj->do_lu);
-               if (com->lc_file_ram != NULL)
-                       OBD_FREE(com->lc_file_ram, com->lc_file_size);
-               if (com->lc_file_disk != NULL)
-                       OBD_FREE(com->lc_file_disk, com->lc_file_size);
-               OBD_FREE_PTR(com);
-       }
+       return lfsck_status_names[status];

 }
 
 static inline struct lfsck_component *
 }
 
 static inline struct lfsck_component *


@@ -151,8 +142,8 @@ void lfsck_component_cleanup(const struct lu_env *env,
        lfsck_component_put(env, com);
 }
 
        lfsck_component_put(env, com);
 }
 

-static void lfsck_instance_cleanup(const struct lu_env *env,
-                                  struct lfsck_instance *lfsck)
+void lfsck_instance_cleanup(const struct lu_env *env,
+                           struct lfsck_instance *lfsck)

 {
        struct ptlrpc_thread    *thread = &lfsck->li_thread;
        struct lfsck_component  *com;
 {
        struct ptlrpc_thread    *thread = &lfsck->li_thread;
        struct lfsck_component  *com;


@@ -204,18 +195,6 @@ static void lfsck_instance_cleanup(const struct lu_env *env,
        OBD_FREE_PTR(lfsck);
 }
 
        OBD_FREE_PTR(lfsck);
 }
 

-static inline void lfsck_instance_get(struct lfsck_instance *lfsck)
-{
-       atomic_inc(&lfsck->li_ref);
-}
-
-static inline void lfsck_instance_put(const struct lu_env *env,
-                                     struct lfsck_instance *lfsck)
-{
-       if (atomic_dec_and_test(&lfsck->li_ref))
-               lfsck_instance_cleanup(env, lfsck);
-}
-

 static inline struct lfsck_instance *lfsck_instance_find(struct dt_device *key,
                                                         bool ref, bool unlink)
 {
 static inline struct lfsck_instance *lfsck_instance_find(struct dt_device *key,
                                                         bool ref, bool unlink)
 {


@@ -270,13 +249,15 @@ int lfsck_bits_dump(char **buf, int *len, int bits, const char *names[],
        for (i = 0, flag = 1; bits != 0; i++, flag = 1 << i) {
                if (flag & bits) {
                        bits &= ~flag;
        for (i = 0, flag = 1; bits != 0; i++, flag = 1 << i) {
                if (flag & bits) {
                        bits &= ~flag;

-                       rc = snprintf(*buf, *len, "%s%c", names[i],
-                                     bits != 0 ? ',' : '\n');
-                       if (rc <= 0)
-                               return -ENOSPC;
-
-                       *buf += rc;
-                       *len -= rc;
+                       if (names[i] != NULL) {
+                               rc = snprintf(*buf, *len, "%s%c", names[i],
+                                             bits != 0 ? ',' : '\n');
+                               if (rc <= 0)
+                                       return -ENOSPC;
+
+                               *buf += rc;
+                               *len -= rc;
+                       }

                }
        }
        return save - *len;
                }
        }
        return save - *len;


@@ -350,7 +331,7 @@ void lfsck_pos_fill(const struct lu_env *env, struct lfsck_instance *lfsck,
                        fid_zero(&pos->lp_dir_parent);
                        pos->lp_dir_cookie = 0;
                } else {
                        fid_zero(&pos->lp_dir_parent);
                        pos->lp_dir_cookie = 0;
                } else {

-                       pos->lp_dir_parent = *lu_object_fid(&dto->do_lu);
+                       pos->lp_dir_parent = *lfsck_dto2fid(dto);

                }
        } else {
                fid_zero(&pos->lp_dir_parent);
                }
        } else {
                fid_zero(&pos->lp_dir_parent);


@@ -382,20 +363,31 @@ void lfsck_control_speed(struct lfsck_instance *lfsck)
 
        if (lfsck->li_sleep_jif > 0 &&
            lfsck->li_new_scanned >= lfsck->li_sleep_rate) {
 
        if (lfsck->li_sleep_jif > 0 &&
            lfsck->li_new_scanned >= lfsck->li_sleep_rate) {

-               spin_lock(&lfsck->li_lock);
-               if (likely(lfsck->li_sleep_jif > 0 &&
-                          lfsck->li_new_scanned >= lfsck->li_sleep_rate)) {
-                       lwi = LWI_TIMEOUT_INTR(lfsck->li_sleep_jif, NULL,
-                                              LWI_ON_SIGNAL_NOOP, NULL);
-                       spin_unlock(&lfsck->li_lock);
-
-                       l_wait_event(thread->t_ctl_waitq,
-                                    !thread_is_running(thread),
-                                    &lwi);
-                       lfsck->li_new_scanned = 0;
-               } else {
-                       spin_unlock(&lfsck->li_lock);
-               }
+               lwi = LWI_TIMEOUT_INTR(lfsck->li_sleep_jif, NULL,
+                                      LWI_ON_SIGNAL_NOOP, NULL);
+
+               l_wait_event(thread->t_ctl_waitq,
+                            !thread_is_running(thread),
+                            &lwi);
+               lfsck->li_new_scanned = 0;
+       }
+}
+
+void lfsck_control_speed_by_self(struct lfsck_component *com)
+{
+       struct lfsck_instance   *lfsck  = com->lc_lfsck;
+       struct ptlrpc_thread    *thread = &lfsck->li_thread;
+       struct l_wait_info       lwi;
+
+       if (lfsck->li_sleep_jif > 0 &&
+           com->lc_new_scanned >= lfsck->li_sleep_rate) {
+               lwi = LWI_TIMEOUT_INTR(lfsck->li_sleep_jif, NULL,
+                                      LWI_ON_SIGNAL_NOOP, NULL);
+
+               l_wait_event(thread->t_ctl_waitq,
+                            !thread_is_running(thread),
+                            &lwi);
+               com->lc_new_scanned = 0;

        }
 }
 
        }
 }
 


@@ -496,6 +488,38 @@ static int lfsck_needs_scan_dir(const struct lu_env *env,
        return 0;
 }
 
        return 0;
 }
 

+struct lfsck_thread_args *lfsck_thread_args_init(struct lfsck_instance *lfsck,
+                                                struct lfsck_component *com)
+{
+       struct lfsck_thread_args *lta;
+       int                       rc;
+
+       OBD_ALLOC_PTR(lta);
+       if (lta == NULL)
+               return ERR_PTR(-ENOMEM);
+
+       rc = lu_env_init(&lta->lta_env, LCT_MD_THREAD | LCT_DT_THREAD);
+       if (rc != 0) {
+               OBD_FREE_PTR(lta);
+               return ERR_PTR(rc);
+       }
+
+       lta->lta_lfsck = lfsck_instance_get(lfsck);
+       if (com != NULL)
+               lta->lta_com = lfsck_component_get(com);
+
+       return lta;
+}
+
+void lfsck_thread_args_fini(struct lfsck_thread_args *lta)
+{
+       if (lta->lta_com != NULL)
+               lfsck_component_put(&lta->lta_env, lta->lta_com);
+       lfsck_instance_put(&lta->lta_env, lta->lta_lfsck);
+       lu_env_fini(&lta->lta_env);
+       OBD_FREE_PTR(lta);
+}
+

 /* LFSCK wrap functions */
 
 void lfsck_fail(const struct lu_env *env, struct lfsck_instance *lfsck,
 /* LFSCK wrap functions */
 
 void lfsck_fail(const struct lu_env *env, struct lfsck_instance *lfsck,


@@ -511,7 +535,8 @@ void lfsck_fail(const struct lu_env *env, struct lfsck_instance *lfsck,
 int lfsck_checkpoint(const struct lu_env *env, struct lfsck_instance *lfsck)
 {
        struct lfsck_component *com;
 int lfsck_checkpoint(const struct lu_env *env, struct lfsck_instance *lfsck)
 {
        struct lfsck_component *com;

-       int                     rc;
+       int                     rc  = 0;
+       int                     rc1 = 0;

 
        if (likely(cfs_time_beforeq(cfs_time_current(),
                                    lfsck->li_time_next_checkpoint)))
 
        if (likely(cfs_time_beforeq(cfs_time_current(),
                                    lfsck->li_time_next_checkpoint)))


@@ -521,13 +546,13 @@ int lfsck_checkpoint(const struct lu_env *env, struct lfsck_instance *lfsck)
        cfs_list_for_each_entry(com, &lfsck->li_list_scan, lc_link) {
                rc = com->lc_ops->lfsck_checkpoint(env, com, false);
                if (rc != 0)
        cfs_list_for_each_entry(com, &lfsck->li_list_scan, lc_link) {
                rc = com->lc_ops->lfsck_checkpoint(env, com, false);
                if (rc != 0)

-                       return rc;;
+                       rc1 = rc;

        }
 
        lfsck->li_time_last_checkpoint = cfs_time_current();
        lfsck->li_time_next_checkpoint = lfsck->li_time_last_checkpoint +
                                cfs_time_seconds(LFSCK_CHECKPOINT_INTERVAL);
        }
 
        lfsck->li_time_last_checkpoint = cfs_time_current();
        lfsck->li_time_next_checkpoint = lfsck->li_time_last_checkpoint +
                                cfs_time_seconds(LFSCK_CHECKPOINT_INTERVAL);

-       return 0;
+       return rc1 != 0 ? rc1 : rc;

 }
 
 int lfsck_prep(const struct lu_env *env, struct lfsck_instance *lfsck)
 }
 
 int lfsck_prep(const struct lu_env *env, struct lfsck_instance *lfsck)


@@ -553,7 +578,7 @@ int lfsck_prep(const struct lu_env *env, struct lfsck_instance *lfsck)
 
                rc = com->lc_ops->lfsck_prep(env, com);
                if (rc != 0)
 
                rc = com->lc_ops->lfsck_prep(env, com);
                if (rc != 0)

-                       RETURN(rc);
+                       GOTO(out, rc);

 
                if ((pos == NULL) ||
                    (!lfsck_pos_is_zero(&com->lc_pos_start) &&
 
                if ((pos == NULL) ||
                    (!lfsck_pos_is_zero(&com->lc_pos_start) &&


@@ -725,18 +750,21 @@ int lfsck_post(const struct lu_env *env, struct lfsck_instance *lfsck,
 {
        struct lfsck_component *com;
        struct lfsck_component *next;
 {
        struct lfsck_component *com;
        struct lfsck_component *next;

-       int                     rc;
+       int                     rc  = 0;
+       int                     rc1 = 0;

 
        lfsck_pos_fill(env, lfsck, &lfsck->li_pos_current, false);
        cfs_list_for_each_entry_safe(com, next, &lfsck->li_list_scan, lc_link) {
                rc = com->lc_ops->lfsck_post(env, com, result, false);
                if (rc != 0)
 
        lfsck_pos_fill(env, lfsck, &lfsck->li_pos_current, false);
        cfs_list_for_each_entry_safe(com, next, &lfsck->li_list_scan, lc_link) {
                rc = com->lc_ops->lfsck_post(env, com, result, false);
                if (rc != 0)

-                       return rc;
+                       rc1 = rc;

        }
 
        lfsck->li_time_last_checkpoint = cfs_time_current();
        lfsck->li_time_next_checkpoint = lfsck->li_time_last_checkpoint +
                                cfs_time_seconds(LFSCK_CHECKPOINT_INTERVAL);
        }
 
        lfsck->li_time_last_checkpoint = cfs_time_current();
        lfsck->li_time_next_checkpoint = lfsck->li_time_last_checkpoint +
                                cfs_time_seconds(LFSCK_CHECKPOINT_INTERVAL);

+
+       /* Ignore some component post failure to make other can go ahead. */

        return result;
 }
 
        return result;
 }
 


@@ -767,22 +795,22 @@ int lfsck_get_speed(struct dt_device *key, void *buf, int len)
        int                     rc;
        ENTRY;
 
        int                     rc;
        ENTRY;
 

-       lfsck = lfsck_instance_find(key, true, false);
-       if (unlikely(lfsck == NULL))
-               RETURN(-ENODEV);
-

        rc = lu_env_init(&env, LCT_MD_THREAD | LCT_DT_THREAD);
        if (rc != 0)
        rc = lu_env_init(&env, LCT_MD_THREAD | LCT_DT_THREAD);
        if (rc != 0)

-               GOTO(out, rc);
+               RETURN(rc);

 
 

-       rc = snprintf(buf, len, "%u\n", lfsck->li_bookmark_ram.lb_speed_limit);
-       lu_env_fini(&env);
+       lfsck = lfsck_instance_find(key, true, false);
+       if (likely(lfsck != NULL)) {
+               rc = snprintf(buf, len, "%u\n",
+                             lfsck->li_bookmark_ram.lb_speed_limit);
+               lfsck_instance_put(&env, lfsck);
+       } else {
+               rc = -ENODEV;
+       }

 
 

-       GOTO(out, rc);
+       lu_env_fini(&env);

 
 

-out:
-       lfsck_instance_put(&env, lfsck);
-       return rc;
+       RETURN(rc);

 }
 EXPORT_SYMBOL(lfsck_get_speed);
 
 }
 EXPORT_SYMBOL(lfsck_get_speed);
 


@@ -793,74 +821,75 @@ int lfsck_set_speed(struct dt_device *key, int val)
        int                     rc;
        ENTRY;
 
        int                     rc;
        ENTRY;
 

-       lfsck = lfsck_instance_find(key, true, false);
-       if (unlikely(lfsck == NULL))
-               RETURN(-ENODEV);
-

        rc = lu_env_init(&env, LCT_MD_THREAD | LCT_DT_THREAD);
        if (rc != 0)
        rc = lu_env_init(&env, LCT_MD_THREAD | LCT_DT_THREAD);
        if (rc != 0)

-               GOTO(out, rc);
+               RETURN(rc);

 
 

-       mutex_lock(&lfsck->li_mutex);
-       __lfsck_set_speed(lfsck, val);
-       rc = lfsck_bookmark_store(&env, lfsck);
-       mutex_unlock(&lfsck->li_mutex);
-       lu_env_fini(&env);
+       lfsck = lfsck_instance_find(key, true, false);
+       if (likely(lfsck != NULL)) {
+               mutex_lock(&lfsck->li_mutex);
+               __lfsck_set_speed(lfsck, val);
+               rc = lfsck_bookmark_store(&env, lfsck);
+               mutex_unlock(&lfsck->li_mutex);
+               lfsck_instance_put(&env, lfsck);
+       } else {
+               rc = -ENODEV;
+       }

 
 

-       GOTO(out, rc);
+       lu_env_fini(&env);

 
 

-out:
-       lfsck_instance_put(&env, lfsck);
-       return rc;
+       RETURN(rc);

 }
 EXPORT_SYMBOL(lfsck_set_speed);
 
 }
 EXPORT_SYMBOL(lfsck_set_speed);
 

-int lfsck_dump(struct dt_device *key, void *buf, int len, __u16 type)
+int lfsck_dump(struct dt_device *key, void *buf, int len, enum lfsck_type type)

 {
        struct lu_env           env;
        struct lfsck_instance  *lfsck;
 {
        struct lu_env           env;
        struct lfsck_instance  *lfsck;

-       struct lfsck_component *com   = NULL;
+       struct lfsck_component *com;

        int                     rc;
        ENTRY;
 
        int                     rc;
        ENTRY;
 

-       lfsck = lfsck_instance_find(key, true, false);
-       if (unlikely(lfsck == NULL))
-               RETURN(-ENODEV);
-
-       com = lfsck_component_find(lfsck, type);
-       if (com == NULL)
-               GOTO(out, rc = -ENOTSUPP);
-

        rc = lu_env_init(&env, LCT_MD_THREAD | LCT_DT_THREAD);
        if (rc != 0)
        rc = lu_env_init(&env, LCT_MD_THREAD | LCT_DT_THREAD);
        if (rc != 0)

-               GOTO(out, rc);
+               RETURN(rc);

 
 

-       rc = com->lc_ops->lfsck_dump(&env, com, buf, len);
-       lu_env_fini(&env);
+       lfsck = lfsck_instance_find(key, true, false);
+       if (likely(lfsck != NULL)) {
+               com = lfsck_component_find(lfsck, type);
+               if (likely(com != NULL)) {
+                       rc = com->lc_ops->lfsck_dump(&env, com, buf, len);
+                       lfsck_component_put(&env, com);
+               } else {
+                       rc = -ENOTSUPP;
+               }

 
 

-       GOTO(out, rc);
+               lfsck_instance_put(&env, lfsck);
+       } else {
+               rc = -ENODEV;
+       }

 
 

-out:
-       if (com != NULL)
-               lfsck_component_put(&env, com);
-       lfsck_instance_put(&env, lfsck);
-       return rc;
+       lu_env_fini(&env);
+
+       RETURN(rc);

 }
 EXPORT_SYMBOL(lfsck_dump);
 
 int lfsck_start(const struct lu_env *env, struct dt_device *key,
                struct lfsck_start_param *lsp)
 {
 }
 EXPORT_SYMBOL(lfsck_dump);
 
 int lfsck_start(const struct lu_env *env, struct dt_device *key,
                struct lfsck_start_param *lsp)
 {

-       struct lfsck_start     *start  = lsp->lsp_start;
-       struct lfsck_instance  *lfsck;
-       struct lfsck_bookmark  *bk;
-       struct ptlrpc_thread   *thread;
-       struct lfsck_component *com;
-       struct l_wait_info      lwi    = { 0 };
-       bool                    dirty  = false;
-       long                    rc     = 0;
-       __u16                   valid  = 0;
-       __u16                   flags  = 0;
+       struct lfsck_start              *start  = lsp->lsp_start;
+       struct lfsck_instance           *lfsck;
+       struct lfsck_bookmark           *bk;
+       struct ptlrpc_thread            *thread;
+       struct lfsck_component          *com;
+       struct l_wait_info               lwi    = { 0 };
+       struct lfsck_thread_args        *lta;
+       bool                             dirty  = false;
+       long                             rc     = 0;
+       __u16                            valid  = 0;
+       __u16                            flags  = 0;
+       __u16                            type   = 1;

        ENTRY;
 
        lfsck = lfsck_instance_find(key, true, false);
        ENTRY;
 
        lfsck = lfsck_instance_find(key, true, false);


@@ -878,10 +907,27 @@ int lfsck_start(const struct lu_env *env, struct dt_device *key,
        mutex_lock(&lfsck->li_mutex);
        spin_lock(&lfsck->li_lock);
        if (!thread_is_init(thread) && !thread_is_stopped(thread)) {
        mutex_lock(&lfsck->li_mutex);
        spin_lock(&lfsck->li_lock);
        if (!thread_is_init(thread) && !thread_is_stopped(thread)) {

+               rc = -EALREADY;
+               while (start->ls_active != 0) {
+                       if (type & start->ls_active) {
+                               com = __lfsck_component_find(lfsck, type,
+                                                       &lfsck->li_list_scan);
+                               if (com == NULL)
+                                       com = __lfsck_component_find(lfsck,
+                                               type,
+                                               &lfsck->li_list_double_scan);
+                               if (com == NULL) {
+                                       rc = -EBUSY;
+                                       break;
+                               } else {
+                                       start->ls_active &= ~type;
+                               }
+                       }
+                       type <<= 1;
+               }

                spin_unlock(&lfsck->li_lock);
                spin_unlock(&lfsck->li_lock);

-               GOTO(out, rc = -EALREADY);
+               GOTO(out, rc);

        }
        }

-

        spin_unlock(&lfsck->li_lock);
 
        lfsck->li_namespace = lsp->lsp_namespace;
        spin_unlock(&lfsck->li_lock);
 
        lfsck->li_namespace = lsp->lsp_namespace;


@@ -944,7 +990,6 @@ int lfsck_start(const struct lu_env *env, struct dt_device *key,
 
        if (start->ls_active != 0) {
                struct lfsck_component *next;
 
        if (start->ls_active != 0) {
                struct lfsck_component *next;

-               __u16 type = 1;

 
                if (start->ls_active == LFSCK_TYPES_ALL)
                        start->ls_active = LFSCK_TYPES_SUPPORTED;
 
                if (start->ls_active == LFSCK_TYPES_ALL)
                        start->ls_active = LFSCK_TYPES_SUPPORTED;


@@ -1009,10 +1054,15 @@ trigger:
 
        lfsck->li_args_oit = (flags << DT_OTABLE_IT_FLAGS_SHIFT) | valid;
        thread_set_flags(thread, 0);
 
        lfsck->li_args_oit = (flags << DT_OTABLE_IT_FLAGS_SHIFT) | valid;
        thread_set_flags(thread, 0);

-       rc = PTR_ERR(kthread_run(lfsck_master_engine, lfsck, "lfsck"));
+       lta = lfsck_thread_args_init(lfsck, NULL);
+       if (IS_ERR(lta))
+               GOTO(out, rc = PTR_ERR(lta));
+
+       rc = PTR_ERR(kthread_run(lfsck_master_engine, lta, "lfsck"));

        if (IS_ERR_VALUE(rc)) {
        if (IS_ERR_VALUE(rc)) {

-               CERROR("%s: cannot start LFSCK thread, rc = %ld\n",
+               CERROR("%s: cannot start LFSCK thread: rc = %ld\n",

                       lfsck_lfsck2name(lfsck), rc);
                       lfsck_lfsck2name(lfsck), rc);

+               lfsck_thread_args_fini(lta);

        } else {
                rc = 0;
                l_wait_event(thread->t_ctl_waitq,
        } else {
                rc = 0;
                l_wait_event(thread->t_ctl_waitq,


@@ -1113,8 +1163,10 @@ int lfsck_register(const struct lu_env *env, struct dt_device *key,
        if (IS_ERR(root))
                GOTO(out, rc = PTR_ERR(root));
 
        if (IS_ERR(root))
                GOTO(out, rc = PTR_ERR(root));
 

+       if (unlikely(!dt_try_as_dir(env, root)))
+               GOTO(out, rc = -ENOTDIR);
+

        lfsck->li_local_root_fid = *fid;
        lfsck->li_local_root_fid = *fid;

-        dt_try_as_dir(env, root);

        if (master) {
                lfsck->li_master = 1;
                if (lfsck_dev_idx(lfsck->li_bottom) == 0) {
        if (master) {
                lfsck->li_master = 1;
                if (lfsck_dev_idx(lfsck->li_bottom) == 0) {


@@ -1152,6 +1204,10 @@ int lfsck_register(const struct lu_env *env, struct dt_device *key,
                        GOTO(out, rc);
        }
 
                        GOTO(out, rc);
        }
 

+       rc = lfsck_layout_setup(env, lfsck);
+       if (rc < 0)
+               GOTO(out, rc);
+

        /* XXX: more LFSCK components initialization to be added here. */
 
 add:
        /* XXX: more LFSCK components initialization to be added here. */
 
 add: