LU-4788 lfsck: replace cfs_list_t with list_head

Do not use cfs_list_xxx any more in LFSCK.

Signed-off-by: Fan Yong <fan.yong@intel.com>
Change-Id: I74bd14fe37274b06762ce5f01aec6e1288837000
Reviewed-on: http://review.whamcloud.com/10602
Tested-by: Jenkins
Reviewed-by: Lai Siyao <lai.siyao@intel.com>
Reviewed-by: James Simmons <uja.ornl@gmail.com>
Reviewed-by: Andreas Dilger <andreas.dilger@intel.com>
Tested-by: Andreas Dilger <andreas.dilger@intel.com>
Reviewed-by: Alex Zhuravlev <alexey.zhuravlev@intel.com>
Tested-by: Maloo <hpdd-maloo@intel.com>

diff --git a/lustre/lfsck/lfsck_engine.c b/lustre/lfsck/lfsck_engine.c
index 325a7a1..5faba39 100644 (file)
--- a/lustre/lfsck/lfsck_engine.c
+++ b/lustre/lfsck/lfsck_engine.c
@@ -448,8 +448,8 @@ int lfsck_master_engine(void *args)
        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))
+       if (!list_empty(&lfsck->li_list_scan) ||
+           list_empty(&lfsck->li_list_double_scan))
                rc = lfsck_master_oit_engine(env, lfsck);
        else
                rc = 1;
@@ -472,7 +472,7 @@ 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))
+               if (!list_empty(&lfsck->li_list_double_scan))
                        rc = lfsck_double_scan(env, lfsck);
                else
                        rc = 0;

diff --git a/lustre/lfsck/lfsck_internal.h b/lustre/lfsck/lfsck_internal.h
index 5fdb7a4..430641c 100644 (file)
--- a/lustre/lfsck/lfsck_internal.h
+++ b/lustre/lfsck/lfsck_internal.h
@@ -383,10 +383,10 @@ struct lfsck_tgt_descs {
 
 struct lfsck_component {
        /* into lfsck_instance::li_list_(scan,double_scan,idle} */
-       cfs_list_t               lc_link;
+       struct list_head         lc_link;
 
        /* into lfsck_instance::li_list_dir */
-       cfs_list_t               lc_link_dir;
+       struct list_head         lc_link_dir;
 
        struct rw_semaphore      lc_sem;
        atomic_t                 lc_ref;
@@ -423,21 +423,21 @@ struct lfsck_instance {
        spinlock_t                li_lock;
 
        /* Link into the lfsck_instance_list. */
-       cfs_list_t                li_link;
+       struct list_head          li_link;
 
        /* For the components in (first) scanning via otable-based iteration. */
-       cfs_list_t                li_list_scan;
+       struct list_head          li_list_scan;
 
        /* For the components in scanning via directory traversal. Because
         * directory traversal cannot guarantee all the object be scanned,
         * so the component in the li_list_dir must be in li_list_scan. */
-       cfs_list_t                li_list_dir;
+       struct list_head          li_list_dir;
 
        /* For the components in double scanning. */
-       cfs_list_t                li_list_double_scan;
+       struct list_head          li_list_double_scan;
 
        /* For the components those are not scanning now. */
-       cfs_list_t                li_list_idle;
+       struct list_head          li_list_idle;
 
        atomic_t                  li_ref;
        atomic_t                  li_double_scan_count;

diff --git a/lustre/lfsck/lfsck_layout.c b/lustre/lfsck/lfsck_layout.c
index 87acec9..88ec0e6 100644 (file)
--- a/lustre/lfsck/lfsck_layout.c
+++ b/lustre/lfsck/lfsck_layout.c
@@ -1358,8 +1358,7 @@ again:
                        break;
 
                ltd->ltd_layout_gen = llmd->llmd_touch_gen;
-               list_del(&ltd->ltd_layout_phase_list);
-               list_add_tail(&ltd->ltd_layout_phase_list, head);
+               list_move_tail(&ltd->ltd_layout_phase_list, head);
                atomic_inc(&ltd->ltd_ref);
                laia->laia_ltd = ltd;
                spin_unlock(&ltds->ltd_lock);
@@ -1567,9 +1566,8 @@ again:
                                break;
 
                        ltd->ltd_layout_gen = llmd->llmd_touch_gen;
-                       list_del_init(&ltd->ltd_layout_phase_list);
-                       list_add_tail(&ltd->ltd_layout_phase_list,
-                                     &llmd->llmd_mdt_phase1_list);
+                       list_move_tail(&ltd->ltd_layout_phase_list,
+                                      &llmd->llmd_mdt_phase1_list);
                        atomic_inc(&ltd->ltd_ref);
                        laia->laia_ltd = ltd;
                        spin_unlock(&ltds->ltd_lock);
@@ -3976,9 +3974,8 @@ lfsck_layout_slave_query_master(const struct lu_env *env,
                        break;
 
                llst->llst_gen = llsd->llsd_touch_gen;
-               list_del(&llst->llst_list);
-               list_add_tail(&llst->llst_list,
-                             &llsd->llsd_master_list);
+               list_move_tail(&llst->llst_list,
+                              &llsd->llsd_master_list);
                atomic_inc(&llst->llst_ref);
                spin_unlock(&llsd->llsd_lock);
 
@@ -4055,9 +4052,8 @@ lfsck_layout_slave_notify_master(const struct lu_env *env,
                        break;
 
                llst->llst_gen = llsd->llsd_touch_gen;
-               list_del(&llst->llst_list);
-               list_add_tail(&llst->llst_list,
-                             &llsd->llsd_master_list);
+               list_move_tail(&llst->llst_list,
+                              &llsd->llsd_master_list);
                atomic_inc(&llst->llst_ref);
                spin_unlock(&llsd->llsd_lock);
 
@@ -4455,9 +4451,8 @@ static int lfsck_layout_prep(const struct lu_env *env,
                if (!lfsck->li_drop_dryrun ||
                    lo->ll_pos_first_inconsistent == 0) {
                        lo->ll_status = LS_SCANNING_PHASE2;
-                       list_del_init(&com->lc_link);
-                       list_add_tail(&com->lc_link,
-                                     &lfsck->li_list_double_scan);
+                       list_move_tail(&com->lc_link,
+                                      &lfsck->li_list_double_scan);
                        pos->lp_oit_cookie = 0;
                } else {
                        int i;
@@ -5023,20 +5018,17 @@ static int lfsck_layout_master_post(const struct lu_env *env,
                lo->ll_status = LS_SCANNING_PHASE2;
                lo->ll_flags |= LF_SCANNED_ONCE;
                lo->ll_flags &= ~LF_UPGRADE;
-               list_del_init(&com->lc_link);
-               list_add_tail(&com->lc_link, &lfsck->li_list_double_scan);
+               list_move_tail(&com->lc_link, &lfsck->li_list_double_scan);
        } else if (result == 0) {
                lo->ll_status = lfsck->li_status;
                if (lo->ll_status == 0)
                        lo->ll_status = LS_STOPPED;
                if (lo->ll_status != LS_PAUSED) {
-                       list_del_init(&com->lc_link);
-                       list_add_tail(&com->lc_link, &lfsck->li_list_idle);
+                       list_move_tail(&com->lc_link, &lfsck->li_list_idle);
                }
        } else {
                lo->ll_status = LS_FAILED;
-               list_del_init(&com->lc_link);
-               list_add_tail(&com->lc_link, &lfsck->li_list_idle);
+               list_move_tail(&com->lc_link, &lfsck->li_list_idle);
        }
        spin_unlock(&lfsck->li_lock);
 
@@ -5085,20 +5077,16 @@ static int lfsck_layout_slave_post(const struct lu_env *env,
                        lo->ll_flags &= ~LF_CRASHED_LASTID;
                }
                lo->ll_flags &= ~LF_UPGRADE;
-               list_del_init(&com->lc_link);
-               list_add_tail(&com->lc_link, &lfsck->li_list_double_scan);
+               list_move_tail(&com->lc_link, &lfsck->li_list_double_scan);
        } else if (result == 0) {
                lo->ll_status = lfsck->li_status;
                if (lo->ll_status == 0)
                        lo->ll_status = LS_STOPPED;
-               if (lo->ll_status != LS_PAUSED) {
-                       list_del_init(&com->lc_link);
-                       list_add_tail(&com->lc_link, &lfsck->li_list_idle);
-               }
+               if (lo->ll_status != LS_PAUSED)
+                       list_move_tail(&com->lc_link, &lfsck->li_list_idle);
        } else {
                lo->ll_status = LS_FAILED;
-               list_del_init(&com->lc_link);
-               list_add_tail(&com->lc_link, &lfsck->li_list_idle);
+               list_move_tail(&com->lc_link, &lfsck->li_list_idle);
        }
        spin_unlock(&lfsck->li_lock);
 

diff --git a/lustre/lfsck/lfsck_lib.c b/lustre/lfsck/lfsck_lib.c
index 46f75a4..566a99e 100644 (file)
--- a/lustre/lfsck/lfsck_lib.c
+++ b/lustre/lfsck/lfsck_lib.c
@@ -58,7 +58,7 @@ static void lfsck_key_fini(const struct lu_context *ctx,
 LU_CONTEXT_KEY_DEFINE(lfsck, LCT_MD_THREAD | LCT_DT_THREAD);
 LU_KEY_INIT_GENERIC(lfsck);
 
-static CFS_LIST_HEAD(lfsck_instance_list);
+static struct list_head lfsck_instance_list;
 static struct list_head lfsck_ost_orphan_list;
 static struct list_head lfsck_mdt_orphan_list;
 static DEFINE_SPINLOCK(lfsck_instance_lock);
@@ -244,11 +244,9 @@ static int lfsck_add_target_from_orphan(const struct lu_env *env,
 again:
        spin_lock(&lfsck_instance_lock);
        list_for_each_entry_safe(ltd, next, head, ltd_orphan_list) {
-               if (ltd->ltd_key == lfsck->li_bottom) {
-                       list_del_init(&ltd->ltd_orphan_list);
-                       list_add_tail(&ltd->ltd_orphan_list,
-                                     &ltds->ltd_orphan);
-               }
+               if (ltd->ltd_key == lfsck->li_bottom)
+                       list_move_tail(&ltd->ltd_orphan_list,
+                                      &ltds->ltd_orphan);
        }
        spin_unlock(&lfsck_instance_lock);
 
@@ -279,11 +277,12 @@ again:
 }
 
 static inline struct lfsck_component *
-__lfsck_component_find(struct lfsck_instance *lfsck, __u16 type, cfs_list_t *list)
+__lfsck_component_find(struct lfsck_instance *lfsck, __u16 type,
+                      struct list_head *list)
 {
        struct lfsck_component *com;
 
-       cfs_list_for_each_entry(com, list, lc_link) {
+       list_for_each_entry(com, list, lc_link) {
                if (com->lc_type == type)
                        return com;
        }
@@ -317,10 +316,10 @@ unlock:
 void lfsck_component_cleanup(const struct lu_env *env,
                             struct lfsck_component *com)
 {
-       if (!cfs_list_empty(&com->lc_link))
-               cfs_list_del_init(&com->lc_link);
-       if (!cfs_list_empty(&com->lc_link_dir))
-               cfs_list_del_init(&com->lc_link_dir);
+       if (!list_empty(&com->lc_link))
+               list_del_init(&com->lc_link);
+       if (!list_empty(&com->lc_link_dir))
+               list_del_init(&com->lc_link_dir);
 
        lfsck_component_put(env, com);
 }
@@ -847,6 +846,7 @@ void lfsck_instance_cleanup(const struct lu_env *env,
 {
        struct ptlrpc_thread    *thread = &lfsck->li_thread;
        struct lfsck_component  *com;
+       struct lfsck_component  *next;
        ENTRY;
 
        LASSERT(list_empty(&lfsck->li_link));
@@ -859,26 +859,18 @@ void lfsck_instance_cleanup(const struct lu_env *env,
 
        LASSERT(lfsck->li_obj_dir == NULL);
 
-       while (!cfs_list_empty(&lfsck->li_list_scan)) {
-               com = cfs_list_entry(lfsck->li_list_scan.next,
-                                    struct lfsck_component,
-                                    lc_link);
+       list_for_each_entry_safe(com, next, &lfsck->li_list_scan, lc_link) {
                lfsck_component_cleanup(env, com);
        }
 
-       LASSERT(cfs_list_empty(&lfsck->li_list_dir));
+       LASSERT(list_empty(&lfsck->li_list_dir));
 
-       while (!cfs_list_empty(&lfsck->li_list_double_scan)) {
-               com = cfs_list_entry(lfsck->li_list_double_scan.next,
-                                    struct lfsck_component,
-                                    lc_link);
+       list_for_each_entry_safe(com, next, &lfsck->li_list_double_scan,
+                                lc_link) {
                lfsck_component_cleanup(env, com);
        }
 
-       while (!cfs_list_empty(&lfsck->li_list_idle)) {
-               com = cfs_list_entry(lfsck->li_list_idle.next,
-                                    struct lfsck_component,
-                                    lc_link);
+       list_for_each_entry_safe(com, next, &lfsck->li_list_idle, lc_link) {
                lfsck_component_cleanup(env, com);
        }
 
@@ -910,7 +902,7 @@ __lfsck_instance_find(struct dt_device *key, bool ref, bool unlink)
 {
        struct lfsck_instance *lfsck;
 
-       cfs_list_for_each_entry(lfsck, &lfsck_instance_list, li_link) {
+       list_for_each_entry(lfsck, &lfsck_instance_list, li_link) {
                if (lfsck->li_bottom == key) {
                        if (ref)
                                lfsck_instance_get(lfsck);
@@ -941,14 +933,14 @@ static inline int lfsck_instance_add(struct lfsck_instance *lfsck)
        struct lfsck_instance *tmp;
 
        spin_lock(&lfsck_instance_lock);
-       cfs_list_for_each_entry(tmp, &lfsck_instance_list, li_link) {
+       list_for_each_entry(tmp, &lfsck_instance_list, li_link) {
                if (lfsck->li_bottom == tmp->li_bottom) {
                        spin_unlock(&lfsck_instance_lock);
                        return -EEXIST;
                }
        }
 
-       cfs_list_add_tail(&lfsck->li_link, &lfsck_instance_list);
+       list_add_tail(&lfsck->li_link, &lfsck_instance_list);
        spin_unlock(&lfsck_instance_lock);
        return 0;
 }
@@ -1122,7 +1114,7 @@ static int lfsck_needs_scan_dir(const struct lu_env *env,
        int            rc;
 
        if (!lfsck->li_master || !S_ISDIR(lfsck_object_type(obj)) ||
-           cfs_list_empty(&lfsck->li_list_dir))
+           list_empty(&lfsck->li_list_dir))
               RETURN(0);
 
        while (1) {
@@ -1247,7 +1239,7 @@ void lfsck_fail(const struct lu_env *env, struct lfsck_instance *lfsck,
 {
        struct lfsck_component *com;
 
-       cfs_list_for_each_entry(com, &lfsck->li_list_scan, lc_link) {
+       list_for_each_entry(com, &lfsck->li_list_scan, lc_link) {
                com->lc_ops->lfsck_fail(env, com, new_checked);
        }
 }
@@ -1263,7 +1255,7 @@ int lfsck_checkpoint(const struct lu_env *env, struct lfsck_instance *lfsck)
                return 0;
 
        lfsck_pos_fill(env, lfsck, &lfsck->li_pos_current, false);
-       cfs_list_for_each_entry(com, &lfsck->li_list_scan, lc_link) {
+       list_for_each_entry(com, &lfsck->li_list_scan, lc_link) {
                rc = com->lc_ops->lfsck_checkpoint(env, com, false);
                if (rc != 0)
                        rc1 = rc;
@@ -1292,7 +1284,7 @@ int lfsck_prep(const struct lu_env *env, struct lfsck_instance *lfsck,
        LASSERT(lfsck->li_di_dir == NULL);
 
        lfsck->li_current_oit_processed = 0;
-       cfs_list_for_each_entry_safe(com, next, &lfsck->li_list_scan, lc_link) {
+       list_for_each_entry_safe(com, next, &lfsck->li_list_scan, lc_link) {
                com->lc_new_checked = 0;
                if (lfsck->li_bookmark_ram.lb_param & LPF_DRYRUN)
                        com->lc_journal = 0;
@@ -1376,8 +1368,8 @@ out:
                lfsck_object_put(env, obj);
 
        if (rc < 0) {
-               cfs_list_for_each_entry_safe(com, next, &lfsck->li_list_scan,
-                                            lc_link)
+               list_for_each_entry_safe(com, next, &lfsck->li_list_scan,
+                                        lc_link)
                        com->lc_ops->lfsck_post(env, com, rc, true);
 
                return rc;
@@ -1385,7 +1377,7 @@ out:
 
        rc = 0;
        lfsck_pos_fill(env, lfsck, &lfsck->li_pos_current, true);
-       cfs_list_for_each_entry(com, &lfsck->li_list_scan, lc_link) {
+       list_for_each_entry(com, &lfsck->li_list_scan, lc_link) {
                rc = com->lc_ops->lfsck_checkpoint(env, com, true);
                if (rc != 0)
                        break;
@@ -1408,7 +1400,7 @@ int lfsck_exec_oit(const struct lu_env *env, struct lfsck_instance *lfsck,
 
        LASSERT(lfsck->li_obj_dir == NULL);
 
-       cfs_list_for_each_entry(com, &lfsck->li_list_scan, lc_link) {
+       list_for_each_entry(com, &lfsck->li_list_scan, lc_link) {
                rc = com->lc_ops->lfsck_exec_oit(env, com, obj);
                if (rc != 0)
                        RETURN(rc);
@@ -1458,7 +1450,7 @@ int lfsck_exec_dir(const struct lu_env *env, struct lfsck_instance *lfsck,
        struct lfsck_component *com;
        int                     rc;
 
-       cfs_list_for_each_entry(com, &lfsck->li_list_scan, lc_link) {
+       list_for_each_entry(com, &lfsck->li_list_scan, lc_link) {
                rc = com->lc_ops->lfsck_exec_dir(env, com, obj, ent);
                if (rc != 0)
                        return rc;
@@ -1475,7 +1467,7 @@ int lfsck_post(const struct lu_env *env, struct lfsck_instance *lfsck,
        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) {
+       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)
                        rc1 = rc;
@@ -1542,8 +1534,7 @@ int lfsck_double_scan(const struct lu_env *env, struct lfsck_instance *lfsck)
                list_for_each_entry_safe(com, next, &lfsck->li_list_double_scan,
                                         lc_link) {
                        spin_lock(&lfsck->li_lock);
-                       list_del_init(&com->lc_link);
-                       list_add_tail(&com->lc_link, &lfsck->li_list_idle);
+                       list_move_tail(&com->lc_link, &lfsck->li_list_idle);
                        spin_unlock(&lfsck->li_lock);
                }
        }
@@ -1604,9 +1595,8 @@ void lfsck_quit(const struct lu_env *env, struct lfsck_instance *lfsck)
                        com->lc_ops->lfsck_quit(env, com);
 
                spin_lock(&lfsck->li_lock);
-               list_del_init(&com->lc_link);
                list_del_init(&com->lc_link_dir);
-               list_add_tail(&com->lc_link, &lfsck->li_list_idle);
+               list_move_tail(&com->lc_link, &lfsck->li_list_idle);
                spin_unlock(&lfsck->li_lock);
        }
 
@@ -1616,8 +1606,7 @@ void lfsck_quit(const struct lu_env *env, struct lfsck_instance *lfsck)
                        com->lc_ops->lfsck_quit(env, com);
 
                spin_lock(&lfsck->li_lock);
-               list_del_init(&com->lc_link);
-               list_add_tail(&com->lc_link, &lfsck->li_list_idle);
+               list_move_tail(&com->lc_link, &lfsck->li_list_idle);
                spin_unlock(&lfsck->li_lock);
        }
 }
@@ -2025,7 +2014,7 @@ int lfsck_start(const struct lu_env *env, struct dt_device *key,
 
        /* start == NULL means auto trigger paused LFSCK. */
        if ((start == NULL) &&
-           (cfs_list_empty(&lfsck->li_list_scan) ||
+           (list_empty(&lfsck->li_list_scan) ||
             OBD_FAIL_CHECK(OBD_FAIL_LFSCK_NO_AUTO)))
                GOTO(put, rc = 0);
 
@@ -2113,14 +2102,12 @@ int lfsck_start(const struct lu_env *env, struct dt_device *key,
                        if (type & start->ls_active) {
                                com = __lfsck_component_find(lfsck, type,
                                                        &lfsck->li_list_idle);
-                               if (com != NULL) {
+                               if (com != NULL)
                                        /* The component status will be updated
                                         * when its prep() is called later by
                                         * the LFSCK main engine. */
-                                       list_del_init(&com->lc_link);
-                                       list_add_tail(&com->lc_link,
-                                                     &lfsck->li_list_scan);
-                               }
+                                       list_move_tail(&com->lc_link,
+                                                      &lfsck->li_list_scan);
                                start->ls_active &= ~type;
                        }
                        type <<= 1;
@@ -2430,11 +2417,11 @@ int lfsck_register(const struct lu_env *env, struct dt_device *key,
 
        mutex_init(&lfsck->li_mutex);
        spin_lock_init(&lfsck->li_lock);
-       CFS_INIT_LIST_HEAD(&lfsck->li_link);
-       CFS_INIT_LIST_HEAD(&lfsck->li_list_scan);
-       CFS_INIT_LIST_HEAD(&lfsck->li_list_dir);
-       CFS_INIT_LIST_HEAD(&lfsck->li_list_double_scan);
-       CFS_INIT_LIST_HEAD(&lfsck->li_list_idle);
+       INIT_LIST_HEAD(&lfsck->li_link);
+       INIT_LIST_HEAD(&lfsck->li_list_scan);
+       INIT_LIST_HEAD(&lfsck->li_list_dir);
+       INIT_LIST_HEAD(&lfsck->li_list_double_scan);
+       INIT_LIST_HEAD(&lfsck->li_list_idle);
        atomic_set(&lfsck->li_ref, 1);
        atomic_set(&lfsck->li_double_scan_count, 0);
        init_waitqueue_head(&lfsck->li_thread.t_ctl_waitq);
@@ -2714,6 +2701,7 @@ static int __init lfsck_init(void)
 {
        int rc;
 
+       INIT_LIST_HEAD(&lfsck_instance_list);
        INIT_LIST_HEAD(&lfsck_ost_orphan_list);
        INIT_LIST_HEAD(&lfsck_mdt_orphan_list);
        lfsck_key_init_generic(&lfsck_thread_key, NULL);
@@ -2731,7 +2719,7 @@ static void __exit lfsck_exit(void)
        struct lfsck_tgt_desc *ltd;
        struct lfsck_tgt_desc *next;
 
-       LASSERT(cfs_list_empty(&lfsck_instance_list));
+       LASSERT(list_empty(&lfsck_instance_list));
 
        list_for_each_entry_safe(ltd, next, &lfsck_ost_orphan_list,
                                 ltd_orphan_list) {

diff --git a/lustre/lfsck/lfsck_namespace.c b/lustre/lfsck/lfsck_namespace.c
index a2c07aa..2c8918e 100644 (file)
--- a/lustre/lfsck/lfsck_namespace.c
+++ b/lustre/lfsck/lfsck_namespace.c
@@ -793,11 +793,10 @@ static int lfsck_namespace_prep(const struct lu_env *env,
                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;
@@ -814,16 +813,16 @@ static int lfsck_namespace_prep(const struct lu_env *env,
                        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;
@@ -1091,23 +1090,20 @@ static int lfsck_namespace_post(const struct lu_env *env,
                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);
 
@@ -1702,8 +1698,8 @@ int lfsck_namespace_setup(const struct lu_env *env,
        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;
@@ -1752,7 +1748,7 @@ int lfsck_namespace_setup(const struct lu_env *env,
        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:
@@ -1769,8 +1765,8 @@ int lfsck_namespace_setup(const struct lu_env *env,
        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;
        }