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);
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);
}
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;
}
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);
}
{
struct ptlrpc_thread *thread = &lfsck->li_thread;
struct lfsck_component *com;
+ struct lfsck_component *next;
ENTRY;
LASSERT(list_empty(&lfsck->li_link));
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);
}
{
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);
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;
}
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) {
{
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);
}
}
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;
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;
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;
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;
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);
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;
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;
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);
}
}
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);
}
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);
}
}
/* 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);
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;
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);
{
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);
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) {