From: Fan Yong Date: Sun, 13 Jul 2014 11:11:11 +0000 (+0800) Subject: LU-4788 lfsck: replace cfs_list_t with list_head X-Git-Tag: 2.6.53~96 X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=commitdiff_plain;h=12e311012ae337276dc3e7da3e7ad8d85d11e764;hp=219f7f582b387e9b303684381817be441bc12006 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 Change-Id: I74bd14fe37274b06762ce5f01aec6e1288837000 Reviewed-on: http://review.whamcloud.com/10602 Tested-by: Jenkins Reviewed-by: Lai Siyao Reviewed-by: James Simmons Reviewed-by: Andreas Dilger Tested-by: Andreas Dilger Reviewed-by: Alex Zhuravlev Tested-by: Maloo --- diff --git a/lustre/lfsck/lfsck_engine.c b/lustre/lfsck/lfsck_engine.c index 325a7a1..5faba39 100644 --- 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 --- 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 --- 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(<d->ltd_layout_phase_list); - list_add_tail(<d->ltd_layout_phase_list, head); + list_move_tail(<d->ltd_layout_phase_list, head); atomic_inc(<d->ltd_ref); laia->laia_ltd = ltd; spin_unlock(<ds->ltd_lock); @@ -1567,9 +1566,8 @@ again: break; ltd->ltd_layout_gen = llmd->llmd_touch_gen; - list_del_init(<d->ltd_layout_phase_list); - list_add_tail(<d->ltd_layout_phase_list, - &llmd->llmd_mdt_phase1_list); + list_move_tail(<d->ltd_layout_phase_list, + &llmd->llmd_mdt_phase1_list); atomic_inc(<d->ltd_ref); laia->laia_ltd = ltd; spin_unlock(<ds->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 --- 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(<d->ltd_orphan_list); - list_add_tail(<d->ltd_orphan_list, - <ds->ltd_orphan); - } + if (ltd->ltd_key == lfsck->li_bottom) + list_move_tail(<d->ltd_orphan_list, + <ds->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 --- 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; }