LU-4788 lfsck: replace cfs_list_t with list_head

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

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) {