LU_KEY_INIT_GENERIC(lfsck);
static CFS_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);
-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",
+ [LS_CO_FAILED] = "co-failed",
+ [LS_CO_STOPPED] = "co-stopped",
+ [LS_CO_PAUSED] = "co-paused"
};
const char *lfsck_flags_names[] = {
"scanned-once",
"inconsistent",
"upgrade",
+ "incomplete",
+ "crashed_lastid",
NULL
};
const char *lfsck_param_names[] = {
+ NULL,
"failout",
"dryrun",
NULL
};
-static inline mdsno_t lfsck_dev_idx(struct dt_device *dev)
+const char *lfsck_status2names(enum lfsck_status status)
{
- return dev->dd_lu_dev.ld_site->ld_seq_site->ss_node_id;
+ if (unlikely(status < 0 || status >= LS_MAX))
+ return "unknown";
+
+ return lfsck_status_names[status];
}
-static inline void lfsck_component_get(struct lfsck_component *com)
+static int lfsck_tgt_descs_init(struct lfsck_tgt_descs *ltds)
{
- atomic_inc(&com->lc_ref);
+ spin_lock_init(<ds->ltd_lock);
+ init_rwsem(<ds->ltd_rw_sem);
+ INIT_LIST_HEAD(<ds->ltd_orphan);
+ ltds->ltd_tgts_bitmap = CFS_ALLOCATE_BITMAP(BITS_PER_LONG);
+ if (ltds->ltd_tgts_bitmap == NULL)
+ return -ENOMEM;
+
+ return 0;
}
-static inline void lfsck_component_put(const struct lu_env *env,
- struct lfsck_component *com)
+static void lfsck_tgt_descs_fini(struct lfsck_tgt_descs *ltds)
{
- if (atomic_dec_and_test(&com->lc_ref)) {
- if (com->lc_obj != NULL)
- lu_object_put(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);
+ struct lfsck_tgt_desc *ltd;
+ struct lfsck_tgt_desc *next;
+ int idx;
+
+ down_write(<ds->ltd_rw_sem);
+
+ list_for_each_entry_safe(ltd, next, <ds->ltd_orphan,
+ ltd_orphan_list) {
+ list_del_init(<d->ltd_orphan_list);
+ lfsck_tgt_put(ltd);
+ }
+
+ if (unlikely(ltds->ltd_tgts_bitmap == NULL)) {
+ up_write(<ds->ltd_rw_sem);
+
+ return;
}
+
+ cfs_foreach_bit(ltds->ltd_tgts_bitmap, idx) {
+ ltd = LTD_TGT(ltds, idx);
+ if (likely(ltd != NULL)) {
+ LASSERT(list_empty(<d->ltd_layout_list));
+
+ ltds->ltd_tgtnr--;
+ cfs_bitmap_clear(ltds->ltd_tgts_bitmap, idx);
+ LTD_TGT(ltds, idx) = NULL;
+ lfsck_tgt_put(ltd);
+ }
+ }
+
+ LASSERTF(ltds->ltd_tgtnr == 0, "tgt count unmatched: %d\n",
+ ltds->ltd_tgtnr);
+
+ for (idx = 0; idx < TGT_PTRS; idx++) {
+ if (ltds->ltd_tgts_idx[idx] != NULL) {
+ OBD_FREE_PTR(ltds->ltd_tgts_idx[idx]);
+ ltds->ltd_tgts_idx[idx] = NULL;
+ }
+ }
+
+ CFS_FREE_BITMAP(ltds->ltd_tgts_bitmap);
+ ltds->ltd_tgts_bitmap = NULL;
+ up_write(<ds->ltd_rw_sem);
+}
+
+static int __lfsck_add_target(const struct lu_env *env,
+ struct lfsck_instance *lfsck,
+ struct lfsck_tgt_desc *ltd,
+ bool for_ost, bool locked)
+{
+ struct lfsck_tgt_descs *ltds;
+ __u32 index = ltd->ltd_index;
+ int rc = 0;
+ ENTRY;
+
+ if (for_ost)
+ ltds = &lfsck->li_ost_descs;
+ else
+ ltds = &lfsck->li_mdt_descs;
+
+ if (!locked)
+ down_write(<ds->ltd_rw_sem);
+
+ LASSERT(ltds->ltd_tgts_bitmap != NULL);
+
+ if (index >= ltds->ltd_tgts_bitmap->size) {
+ __u32 newsize = max((__u32)ltds->ltd_tgts_bitmap->size,
+ (__u32)BITS_PER_LONG);
+ cfs_bitmap_t *old_bitmap = ltds->ltd_tgts_bitmap;
+ cfs_bitmap_t *new_bitmap;
+
+ while (newsize < index + 1)
+ newsize <<= 1;
+
+ new_bitmap = CFS_ALLOCATE_BITMAP(newsize);
+ if (new_bitmap == NULL)
+ GOTO(unlock, rc = -ENOMEM);
+
+ if (ltds->ltd_tgtnr > 0)
+ cfs_bitmap_copy(new_bitmap, old_bitmap);
+ ltds->ltd_tgts_bitmap = new_bitmap;
+ CFS_FREE_BITMAP(old_bitmap);
+ }
+
+ if (cfs_bitmap_check(ltds->ltd_tgts_bitmap, index)) {
+ CERROR("%s: the device %s (%u) is registered already\n",
+ lfsck_lfsck2name(lfsck),
+ ltd->ltd_tgt->dd_lu_dev.ld_obd->obd_name, index);
+ GOTO(unlock, rc = -EEXIST);
+ }
+
+ if (ltds->ltd_tgts_idx[index / TGT_PTRS_PER_BLOCK] == NULL) {
+ OBD_ALLOC_PTR(ltds->ltd_tgts_idx[index / TGT_PTRS_PER_BLOCK]);
+ if (ltds->ltd_tgts_idx[index / TGT_PTRS_PER_BLOCK] == NULL)
+ GOTO(unlock, rc = -ENOMEM);
+ }
+
+ LTD_TGT(ltds, index) = ltd;
+ cfs_bitmap_set(ltds->ltd_tgts_bitmap, index);
+ ltds->ltd_tgtnr++;
+
+ GOTO(unlock, rc = 0);
+
+unlock:
+ if (!locked)
+ up_write(<ds->ltd_rw_sem);
+
+ return rc;
+}
+
+static int lfsck_add_target_from_orphan(const struct lu_env *env,
+ struct lfsck_instance *lfsck)
+{
+ struct lfsck_tgt_descs *ltds = &lfsck->li_ost_descs;
+ struct lfsck_tgt_desc *ltd;
+ struct lfsck_tgt_desc *next;
+ struct list_head *head = &lfsck_ost_orphan_list;
+ int rc;
+ bool for_ost = true;
+
+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);
+ }
+ }
+ spin_unlock(&lfsck_instance_lock);
+
+ down_write(<ds->ltd_rw_sem);
+ while (!list_empty(<ds->ltd_orphan)) {
+ ltd = list_entry(ltds->ltd_orphan.next,
+ struct lfsck_tgt_desc,
+ ltd_orphan_list);
+ list_del_init(<d->ltd_orphan_list);
+ rc = __lfsck_add_target(env, lfsck, ltd, for_ost, true);
+ /* Do not hold the semaphore for too long time. */
+ up_write(<ds->ltd_rw_sem);
+ if (rc != 0)
+ return rc;
+
+ down_write(<ds->ltd_rw_sem);
+ }
+ up_write(<ds->ltd_rw_sem);
+
+ if (for_ost) {
+ ltds = &lfsck->li_mdt_descs;
+ head = &lfsck_mdt_orphan_list;
+ for_ost = false;
+ goto again;
+ }
+
+ return 0;
}
static inline struct lfsck_component *
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;
LASSERT(list_empty(&lfsck->li_link));
LASSERT(thread_is_init(thread) || thread_is_stopped(thread));
+ lfsck_tgt_descs_fini(&lfsck->li_ost_descs);
+ lfsck_tgt_descs_fini(&lfsck->li_mdt_descs);
+
if (lfsck->li_obj_oit != NULL) {
- lu_object_put(env, &lfsck->li_obj_oit->do_lu);
+ lu_object_put_nocache(env, &lfsck->li_obj_oit->do_lu);
lfsck->li_obj_oit = NULL;
}
}
if (lfsck->li_bookmark_obj != NULL) {
- lu_object_put(env, &lfsck->li_bookmark_obj->do_lu);
+ lu_object_put_nocache(env, &lfsck->li_bookmark_obj->do_lu);
lfsck->li_bookmark_obj = NULL;
}
lfsck->li_los = NULL;
}
- if (lfsck->li_local_root != NULL) {
- lu_object_put(env, &lfsck->li_local_root->do_lu);
- lfsck->li_local_root = NULL;
- }
-
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)
{
struct lfsck_instance *lfsck;
- spin_lock(&lfsck_instance_lock);
cfs_list_for_each_entry(lfsck, &lfsck_instance_list, li_link) {
if (lfsck->li_bottom == key) {
if (ref)
lfsck_instance_get(lfsck);
if (unlink)
list_del_init(&lfsck->li_link);
- spin_unlock(&lfsck_instance_lock);
+
return lfsck;
}
}
- spin_unlock(&lfsck_instance_lock);
+
return NULL;
}
+static inline struct lfsck_instance *lfsck_instance_find(struct dt_device *key,
+ bool ref, bool unlink)
+{
+ struct lfsck_instance *lfsck;
+
+ spin_lock(&lfsck_instance_lock);
+ lfsck = __lfsck_instance_find(key, ref, unlink);
+ spin_unlock(&lfsck_instance_lock);
+
+ return lfsck;
+}
+
static inline int lfsck_instance_add(struct lfsck_instance *lfsck)
{
struct lfsck_instance *tmp;
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;
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);
{
lfsck->li_bookmark_ram.lb_speed_limit = limit;
if (limit != LFSCK_SPEED_NO_LIMIT) {
- if (limit > CFS_HZ) {
- lfsck->li_sleep_rate = limit / CFS_HZ;
+ if (limit > HZ) {
+ lfsck->li_sleep_rate = limit / HZ;
lfsck->li_sleep_jif = 1;
} else {
lfsck->li_sleep_rate = 1;
- lfsck->li_sleep_jif = CFS_HZ / limit;
+ lfsck->li_sleep_jif = HZ / limit;
}
} else {
lfsck->li_sleep_jif = 0;
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;
}
}
if (rc != 0)
return rc;
- if (unlikely(lu_fid_eq(fid,
- lfsck_dto2fid(lfsck->li_local_root))))
+ if (unlikely(lu_fid_eq(fid, &lfsck->li_local_root_fid)))
return 0;
obj = lfsck_object_find(env, lfsck, fid);
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(<a->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(<a->lta_env, lta->lta_com);
+ lfsck_instance_put(<a->lta_env, lta->lta_lfsck);
+ lu_env_fini(<a->lta_env);
+ OBD_FREE_PTR(lta);
+}
+
/* LFSCK wrap functions */
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 rc;
+ int rc = 0;
+ int rc1 = 0;
if (likely(cfs_time_beforeq(cfs_time_current(),
lfsck->li_time_next_checkpoint)))
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);
- return 0;
+ return rc1 != 0 ? rc1 : rc;
}
int lfsck_prep(const struct lu_env *env, struct lfsck_instance *lfsck)
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) &&
{
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)
- 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);
+
+ /* Ignore some component post failure to make other can go ahead. */
return result;
}
{
struct lfsck_component *com;
struct lfsck_component *next;
- int rc;
+ struct l_wait_info lwi = { 0 };
+ int rc = 0;
+ int rc1 = 0;
cfs_list_for_each_entry_safe(com, next, &lfsck->li_list_double_scan,
lc_link) {
rc = com->lc_ops->lfsck_double_scan(env, com);
if (rc != 0)
- return rc;
+ rc1 = rc;
+ }
+
+ l_wait_event(lfsck->li_thread.t_ctl_waitq,
+ atomic_read(&lfsck->li_double_scan_count) == 0,
+ &lwi);
+
+ return (rc1 != 0 ? rc1 : rc);
+}
+
+void lfsck_quit(const struct lu_env *env, struct lfsck_instance *lfsck)
+{
+ struct lfsck_component *com;
+ struct lfsck_component *next;
+
+ list_for_each_entry_safe(com, next, &lfsck->li_list_scan,
+ lc_link) {
+ if (com->lc_ops->lfsck_quit != NULL)
+ com->lc_ops->lfsck_quit(env, com);
+ }
+
+ list_for_each_entry_safe(com, next, &lfsck->li_list_double_scan,
+ lc_link) {
+ if (com->lc_ops->lfsck_quit != NULL)
+ com->lc_ops->lfsck_quit(env, com);
}
- return 0;
}
/* external interfaces */
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)
- 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);
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)
- 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);
-int lfsck_dump(struct dt_device *key, void *buf, int len, __u16 type)
+int lfsck_get_windows(struct dt_device *key, void *buf, int len)
{
struct lu_env env;
struct lfsck_instance *lfsck;
- struct lfsck_component *com = NULL;
int rc;
ENTRY;
+ rc = lu_env_init(&env, LCT_MD_THREAD | LCT_DT_THREAD);
+ if (rc != 0)
+ RETURN(rc);
+
lfsck = lfsck_instance_find(key, true, false);
- if (unlikely(lfsck == NULL))
- RETURN(-ENODEV);
+ if (likely(lfsck != NULL)) {
+ rc = snprintf(buf, len, "%u\n",
+ lfsck->li_bookmark_ram.lb_async_windows);
+ lfsck_instance_put(&env, lfsck);
+ } else {
+ rc = -ENODEV;
+ }
- com = lfsck_component_find(lfsck, type);
- if (com == NULL)
- GOTO(out, rc = -ENOTSUPP);
+ lu_env_fini(&env);
+
+ RETURN(rc);
+}
+EXPORT_SYMBOL(lfsck_get_windows);
+
+int lfsck_set_windows(struct dt_device *key, int val)
+{
+ struct lu_env env;
+ struct lfsck_instance *lfsck;
+ int rc;
+ ENTRY;
rc = lu_env_init(&env, LCT_MD_THREAD | LCT_DT_THREAD);
if (rc != 0)
- GOTO(out, rc);
+ RETURN(rc);
+
+ lfsck = lfsck_instance_find(key, true, false);
+ if (likely(lfsck != NULL)) {
+ if (val > LFSCK_ASYNC_WIN_MAX) {
+ CERROR("%s: Too large async windows size, which "
+ "may cause memory issues. The valid range "
+ "is [0 - %u]. If you do not want to restrict "
+ "the windows size for async requests pipeline, "
+ "just set it as 0.\n",
+ lfsck_lfsck2name(lfsck), LFSCK_ASYNC_WIN_MAX);
+ rc = -EINVAL;
+ } else if (lfsck->li_bookmark_ram.lb_async_windows != val) {
+ mutex_lock(&lfsck->li_mutex);
+ lfsck->li_bookmark_ram.lb_async_windows = val;
+ rc = lfsck_bookmark_store(&env, lfsck);
+ mutex_unlock(&lfsck->li_mutex);
+ }
+ lfsck_instance_put(&env, lfsck);
+ } else {
+ rc = -ENODEV;
+ }
- rc = com->lc_ops->lfsck_dump(&env, com, buf, len);
lu_env_fini(&env);
- GOTO(out, rc);
+ RETURN(rc);
+}
+EXPORT_SYMBOL(lfsck_set_windows);
-out:
- if (com != NULL)
- lfsck_component_put(&env, com);
- lfsck_instance_put(&env, lfsck);
- return rc;
+int lfsck_dump(struct dt_device *key, void *buf, int len, enum lfsck_type type)
+{
+ struct lu_env env;
+ struct lfsck_instance *lfsck;
+ struct lfsck_component *com;
+ int rc;
+ ENTRY;
+
+ rc = lu_env_init(&env, LCT_MD_THREAD | LCT_DT_THREAD);
+ if (rc != 0)
+ RETURN(rc);
+
+ 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;
+ }
+
+ lfsck_instance_put(&env, lfsck);
+ } else {
+ rc = -ENODEV;
+ }
+
+ 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)
{
- 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);
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);
- GOTO(out, rc = -EALREADY);
+ GOTO(out, rc);
}
-
spin_unlock(&lfsck->li_lock);
lfsck->li_namespace = lsp->lsp_namespace;
dirty = true;
}
+ if (start->ls_valid & LSV_ASYNC_WINDOWS &&
+ bk->lb_async_windows != start->ls_async_windows) {
+ bk->lb_async_windows = start->ls_async_windows;
+ dirty = true;
+ }
+
if (start->ls_valid & LSV_ERROR_HANDLE) {
valid |= DOIV_ERROR_HANDLE;
if (start->ls_flags & LPF_FAILOUT)
}
if (start->ls_valid & LSV_DRYRUN) {
+ valid |= DOIV_DRYRUN;
+ if (start->ls_flags & LPF_DRYRUN)
+ flags |= DOIF_DRYRUN;
+
if ((start->ls_flags & LPF_DRYRUN) &&
!(bk->lb_param & LPF_DRYRUN)) {
bk->lb_param |= LPF_DRYRUN;
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;
trigger:
lfsck->li_args_dir = LUDA_64BITHASH | LUDA_VERIFY;
- if (bk->lb_param & LPF_DRYRUN)
+ if (bk->lb_param & LPF_DRYRUN) {
lfsck->li_args_dir |= LUDA_VERIFY_DRYRUN;
+ valid |= DOIV_DRYRUN;
+ flags |= DOIF_DRYRUN;
+ }
if (bk->lb_param & LPF_FAILOUT) {
valid |= DOIV_ERROR_HANDLE;
lfsck->li_args_oit = (flags << DT_OTABLE_IT_FLAGS_SHIFT) | valid;
thread_set_flags(thread, 0);
- if (lfsck->li_master)
- 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)) {
- CERROR("%s: cannot start LFSCK thread, rc = %ld\n",
+ CERROR("%s: cannot start LFSCK thread: rc = %ld\n",
lfsck_lfsck2name(lfsck), rc);
+ lfsck_thread_args_fini(lta);
} else {
rc = 0;
l_wait_event(thread->t_ctl_waitq,
thread_set_flags(thread, SVC_STOPPING);
spin_unlock(&lfsck->li_lock);
- cfs_waitq_broadcast(&thread->t_ctl_waitq);
+ wake_up_all(&thread->t_ctl_waitq);
l_wait_event(thread->t_ctl_waitq,
thread_is_stopped(thread),
&lwi);
EXPORT_SYMBOL(lfsck_stop);
int lfsck_register(const struct lu_env *env, struct dt_device *key,
- struct dt_device *next, bool master)
+ struct dt_device *next, lfsck_out_notify notify,
+ void *notify_data, bool master)
{
struct lfsck_instance *lfsck;
- struct dt_object *root;
+ struct dt_object *root = NULL;
struct dt_object *obj;
struct lu_fid *fid = &lfsck_env_info(env)->lti_fid;
int rc;
CFS_INIT_LIST_HEAD(&lfsck->li_list_double_scan);
CFS_INIT_LIST_HEAD(&lfsck->li_list_idle);
atomic_set(&lfsck->li_ref, 1);
- cfs_waitq_init(&lfsck->li_thread.t_ctl_waitq);
+ atomic_set(&lfsck->li_double_scan_count, 0);
+ init_waitqueue_head(&lfsck->li_thread.t_ctl_waitq);
+ lfsck->li_out_notify = notify;
+ lfsck->li_out_notify_data = notify_data;
lfsck->li_next = next;
lfsck->li_bottom = key;
+ rc = lfsck_tgt_descs_init(&lfsck->li_ost_descs);
+ if (rc != 0)
+ GOTO(out, rc);
+
+ rc = lfsck_tgt_descs_init(&lfsck->li_mdt_descs);
+ if (rc != 0)
+ GOTO(out, rc);
+
fid->f_seq = FID_SEQ_LOCAL_NAME;
fid->f_oid = 1;
fid->f_ver = 0;
if (IS_ERR(root))
GOTO(out, rc = PTR_ERR(root));
- lfsck->li_local_root = root;
- dt_try_as_dir(env, root);
+ if (unlikely(!dt_try_as_dir(env, root)))
+ GOTO(out, rc = -ENOTDIR);
+
+ lfsck->li_local_root_fid = *fid;
if (master) {
lfsck->li_master = 1;
if (lfsck_dev_idx(lfsck->li_bottom) == 0) {
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:
rc = lfsck_instance_add(lfsck);
+ if (rc == 0)
+ rc = lfsck_add_target_from_orphan(env, lfsck);
out:
+ if (root != NULL && !IS_ERR(root))
+ lu_object_put(env, &root->do_lu);
if (rc != 0)
lfsck_instance_cleanup(env, lfsck);
return rc;
}
EXPORT_SYMBOL(lfsck_degister);
+int lfsck_add_target(const struct lu_env *env, struct dt_device *key,
+ struct dt_device *tgt, struct obd_export *exp,
+ __u32 index, bool for_ost)
+{
+ struct lfsck_instance *lfsck;
+ struct lfsck_tgt_desc *ltd;
+ int rc;
+ ENTRY;
+
+ OBD_ALLOC_PTR(ltd);
+ if (ltd == NULL)
+ RETURN(-ENOMEM);
+
+ ltd->ltd_tgt = tgt;
+ ltd->ltd_key = key;
+ ltd->ltd_exp = exp;
+ INIT_LIST_HEAD(<d->ltd_orphan_list);
+ INIT_LIST_HEAD(<d->ltd_layout_list);
+ atomic_set(<d->ltd_ref, 1);
+ ltd->ltd_index = index;
+
+ spin_lock(&lfsck_instance_lock);
+ lfsck = __lfsck_instance_find(key, true, false);
+ if (lfsck == NULL) {
+ if (for_ost)
+ list_add_tail(<d->ltd_orphan_list,
+ &lfsck_ost_orphan_list);
+ else
+ list_add_tail(<d->ltd_orphan_list,
+ &lfsck_mdt_orphan_list);
+ spin_unlock(&lfsck_instance_lock);
+
+ RETURN(0);
+ }
+ spin_unlock(&lfsck_instance_lock);
+
+ rc = __lfsck_add_target(env, lfsck, ltd, for_ost, false);
+ if (rc != 0)
+ lfsck_tgt_put(ltd);
+
+ lfsck_instance_put(env, lfsck);
+
+ RETURN(rc);
+}
+EXPORT_SYMBOL(lfsck_add_target);
+
+void lfsck_del_target(const struct lu_env *env, struct dt_device *key,
+ struct dt_device *tgt, __u32 index, bool for_ost)
+{
+ struct lfsck_instance *lfsck;
+ struct lfsck_tgt_descs *ltds;
+ struct lfsck_tgt_desc *ltd;
+ struct list_head *head;
+ bool found = false;
+
+ if (for_ost)
+ head = &lfsck_ost_orphan_list;
+ else
+ head = &lfsck_mdt_orphan_list;
+
+ spin_lock(&lfsck_instance_lock);
+ list_for_each_entry(ltd, head, ltd_orphan_list) {
+ if (ltd->ltd_tgt == tgt) {
+ list_del_init(<d->ltd_orphan_list);
+ spin_unlock(&lfsck_instance_lock);
+ lfsck_tgt_put(ltd);
+
+ return;
+ }
+ }
+
+ lfsck = __lfsck_instance_find(key, true, false);
+ spin_unlock(&lfsck_instance_lock);
+ if (unlikely(lfsck == NULL))
+ return;
+
+ if (for_ost)
+ ltds = &lfsck->li_ost_descs;
+ else
+ ltds = &lfsck->li_mdt_descs;
+
+ down_write(<ds->ltd_rw_sem);
+
+ LASSERT(ltds->ltd_tgts_bitmap != NULL);
+
+ if (unlikely(index >= ltds->ltd_tgts_bitmap->size))
+ goto unlock;
+
+ ltd = LTD_TGT(ltds, index);
+ if (unlikely(ltd == NULL))
+ goto unlock;
+
+ found = true;
+ if (!list_empty(<d->ltd_layout_list)) {
+ spin_lock(<ds->ltd_lock);
+ list_del_init(<d->ltd_layout_list);
+ spin_unlock(<ds->ltd_lock);
+ }
+
+ LASSERT(ltds->ltd_tgtnr > 0);
+
+ ltds->ltd_tgtnr--;
+ cfs_bitmap_clear(ltds->ltd_tgts_bitmap, index);
+ LTD_TGT(ltds, index) = NULL;
+ lfsck_tgt_put(ltd);
+
+unlock:
+ if (!found) {
+ if (for_ost)
+ head = &lfsck->li_ost_descs.ltd_orphan;
+ else
+ head = &lfsck->li_ost_descs.ltd_orphan;
+
+ list_for_each_entry(ltd, head, ltd_orphan_list) {
+ if (ltd->ltd_tgt == tgt) {
+ list_del_init(<d->ltd_orphan_list);
+ lfsck_tgt_put(ltd);
+ break;
+ }
+ }
+ }
+
+ up_write(<ds->ltd_rw_sem);
+ lfsck_instance_put(env, lfsck);
+}
+EXPORT_SYMBOL(lfsck_del_target);
+
static int __init lfsck_init(void)
{
int rc;
+ INIT_LIST_HEAD(&lfsck_ost_orphan_list);
+ INIT_LIST_HEAD(&lfsck_mdt_orphan_list);
lfsck_key_init_generic(&lfsck_thread_key, NULL);
rc = lu_context_key_register(&lfsck_thread_key);
+
return rc;
}
static void __exit lfsck_exit(void)
{
+ struct lfsck_tgt_desc *ltd;
+ struct lfsck_tgt_desc *next;
+
LASSERT(cfs_list_empty(&lfsck_instance_list));
+ list_for_each_entry_safe(ltd, next, &lfsck_ost_orphan_list,
+ ltd_orphan_list) {
+ list_del_init(<d->ltd_orphan_list);
+ lfsck_tgt_put(ltd);
+ }
+
+ list_for_each_entry_safe(ltd, next, &lfsck_mdt_orphan_list,
+ ltd_orphan_list) {
+ list_del_init(<d->ltd_orphan_list);
+ lfsck_tgt_put(ltd);
+ }
+
lu_context_key_degister(&lfsck_thread_key);
}
git://git.whamcloud.com / fs / lustre-release.git / blobdiff