LU_CONTEXT_KEY_DEFINE(lfsck, LCT_MD_THREAD | LCT_DT_THREAD);
LU_KEY_INIT_GENERIC(lfsck);
-static struct list_head lfsck_instance_list;
-static struct list_head lfsck_ost_orphan_list;
-static struct list_head lfsck_mdt_orphan_list;
+static LIST_HEAD(lfsck_instance_list);
+static LIST_HEAD(lfsck_ost_orphan_list);
+static LIST_HEAD(lfsck_mdt_orphan_list);
static DEFINE_SPINLOCK(lfsck_instance_lock);
-const char *lfsck_flags_names[] = {
+const char *const lfsck_flags_names[] = {
"scanned-once",
"inconsistent",
"upgrade",
NULL
};
-const char *lfsck_param_names[] = {
+const char *const lfsck_param_names[] = {
NULL,
"failout",
"dryrun",
LASSERTF(ltds->ltd_tgtnr == 0, "tgt count unmatched: %d\n",
ltds->ltd_tgtnr);
- for (idx = 0; idx < TGT_PTRS; idx++) {
+ for (idx = 0; idx < ARRAY_SIZE(ltds->ltd_tgts_idx); idx++) {
if (ltds->ltd_tgts_idx[idx] != NULL) {
OBD_FREE_PTR(ltds->ltd_tgts_idx[idx]);
ltds->ltd_tgts_idx[idx] = NULL;
einfo->ei_cb_bl = ldlm_blocking_ast;
einfo->ei_cb_cp = ldlm_completion_ast;
einfo->ei_res_id = resid;
+ einfo->ei_req_slot = 1;
rc = dt_object_lock(env, obj, lh, einfo, policy);
/* for regular checks LFSCK doesn't use LDLM locking,
if (rc != 0)
RETURN(rc);
- th = dt_trans_create(env, dev);
+ th = lfsck_trans_create(env, dev, lfsck);
if (IS_ERR(th))
GOTO(unlock, rc = PTR_ERR(th));
if (rc != 0)
RETURN(rc);
- th = dt_trans_create(env, dev);
+ th = lfsck_trans_create(env, dev, lfsck);
if (IS_ERR(th))
RETURN(PTR_ERR(th));
/* Transaction I: locally */
dev = lfsck_obj2dev(child);
- th = dt_trans_create(env, dev);
+ th = lfsck_trans_create(env, dev, lfsck);
if (IS_ERR(th))
RETURN(PTR_ERR(th));
/* Transaction II: remotely */
dev = lfsck_obj2dev(parent);
- th = dt_trans_create(env, dev);
+ th = lfsck_trans_create(env, dev, lfsck);
if (IS_ERR(th))
RETURN(PTR_ERR(th));
* created the .lustre/lost+found/MDTxxxx but failed to update
* the lfsck_bookmark::lb_lpf_fid successfully. So need lookup
* it from MDT0 firstly. */
- rc = dt_lookup(env, parent, (struct dt_rec *)cfid,
- (const struct dt_key *)name);
+ rc = dt_lookup_dir(env, parent, name, cfid);
if (rc != 0 && rc != -ENOENT)
GOTO(unlock, rc);
la->la_atime = la->la_mtime = la->la_ctime = ktime_get_real_seconds();
la->la_mode = S_IFDIR | S_IRWXU;
la->la_valid = LA_ATIME | LA_MTIME | LA_CTIME | LA_MODE |
- LA_UID | LA_GID;
+ LA_UID | LA_GID | LA_TYPE;
memset(dof, 0, sizeof(*dof));
dof->dof_type = dt_mode_to_dft(S_IFDIR);
ENTRY;
fid_zero(fid);
- rc = dt_lookup(env, child, (struct dt_rec *)fid,
- (const struct dt_key *)dotdot);
+ rc = dt_lookup_dir(env, child, dotdot, fid);
if (rc != 0)
GOTO(linkea, rc);
}
cname = lfsck_name_get_const(env, name, strlen(name));
- rc = lfsck_verify_linkea(env, child, cname, &LU_LPF_FID);
+ rc = lfsck_verify_linkea(env, lfsck, child, cname, &LU_LPF_FID);
if (rc == 0)
rc = lfsck_update_lpf_entry(env, lfsck, parent, child,
name, type);
GOTO(out_done, rc = 1);
}
- rc = dt_lookup(env, parent2, (struct dt_rec *)fid,
- (const struct dt_key *)name2);
+ rc = dt_lookup_dir(env, parent2, name2, fid);
dt_read_unlock(env, child);
lfsck_ibits_unlock(&lh, LCK_PR);
if (rc != 0 && rc != -ENOENT)
LASSERT(lfsck->li_master);
+ if (lfsck_is_dryrun(lfsck))
+ RETURN(0);
+
if (lfsck->li_lpf_root_obj != NULL)
RETURN(0);
/* child2 */
snprintf(name, 8, "MDT%04x", node);
- rc = dt_lookup(env, parent, (struct dt_rec *)cfid,
- (const struct dt_key *)name);
+ rc = dt_lookup_dir(env, parent, name, cfid);
if (rc == -ENOENT) {
rc = 0;
goto find_child1;
goto find_child1;
}
- if (unlikely(!dt_try_as_dir(env, child2))) {
- lfsck_object_put(env, child2);
- child2 = NULL;
- rc = -ENOTDIR;
- }
+ if (unlikely(!dt_try_as_dir(env, child2)))
+ GOTO(put, rc = -ENOTDIR);
find_child1:
if (fid_is_zero(&bk->lb_lpf_fid))
}
cname = lfsck_name_get_const(env, name, strlen(name));
- rc = lfsck_verify_linkea(env, child2, cname, &LU_LPF_FID);
+ rc = lfsck_verify_linkea(env, lfsck, child2, cname,
+ &LU_LPF_FID);
GOTO(put, rc);
}
GOTO(out, rc = -ENOMEM);
snprintf(prefix, MAX_OBD_NAME + 7, "lfsck-%s", lfsck_lfsck2name(lfsck));
- rc = seq_client_init(lfsck->li_seq, NULL, LUSTRE_SEQ_METADATA, prefix,
+ seq_client_init(lfsck->li_seq, NULL, LUSTRE_SEQ_METADATA, prefix,
ss->ss_server_seq);
OBD_FREE(prefix, MAX_OBD_NAME + 7);
- if (rc != 0)
- GOTO(out, rc);
if (fid_is_sane(&bk->lb_last_fid))
lfsck->li_seq->lcs_fid = bk->lb_last_fid;
lfsck->li_obj_oit = NULL;
}
- LASSERT(lfsck->li_obj_dir == NULL);
- LASSERT(lfsck->li_lmv == NULL);
-
list_for_each_entry_safe(llu, llu_next, &lfsck->li_list_lmv, llu_link) {
llmv = &llu->llu_lmv;
return 0;
}
-void lfsck_bits_dump(struct seq_file *m, int bits, const char *names[],
+void lfsck_bits_dump(struct seq_file *m, int bits, const char *const names[],
const char *prefix)
{
int flag;
seq_printf(m, "%s:%c", prefix, bits != 0 ? ' ' : '\n');
- for (i = 0, flag = 1; bits != 0; i++, flag = 1 << i) {
+ for (i = 0, flag = 1; bits != 0; i++, flag = BIT(i)) {
if (flag & bits) {
bits &= ~flag;
if (names[i] != NULL) {
if (unlikely(pos->lp_oit_cookie == 0))
pos->lp_oit_cookie = 1;
+ spin_lock(&lfsck->li_lock);
if (lfsck->li_di_dir != NULL) {
struct dt_object *dto = lfsck->li_obj_dir;
fid_zero(&pos->lp_dir_parent);
pos->lp_dir_cookie = 0;
}
+ spin_unlock(&lfsck->li_lock);
}
bool __lfsck_set_speed(struct lfsck_instance *lfsck, __u32 limit)
void lfsck_control_speed(struct lfsck_instance *lfsck)
{
struct ptlrpc_thread *thread = &lfsck->li_thread;
- struct l_wait_info lwi;
if (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);
-
- l_wait_event(thread->t_ctl_waitq,
- !thread_is_running(thread),
- &lwi);
+ wait_event_idle_timeout(thread->t_ctl_waitq,
+ !thread_is_running(thread),
+ lfsck->li_sleep_jif);
lfsck->li_new_scanned = 0;
}
}
{
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);
+ wait_event_idle_timeout(thread->t_ctl_waitq,
+ !thread_is_running(thread),
+ lfsck->li_sleep_jif);
com->lc_new_scanned = 0;
}
}
}
struct lfsck_assistant_data *
-lfsck_assistant_data_init(struct lfsck_assistant_operations *lao,
+lfsck_assistant_data_init(const struct lfsck_assistant_operations *lao,
const char *name)
{
struct lfsck_assistant_data *lad;
struct lfsck_async_interpret_args *laia = args;
struct lfsck_instance *lfsck;
- lfsck = container_of0(laia->laia_ltds, struct lfsck_instance,
- li_mdt_descs);
+ lfsck = container_of(laia->laia_ltds, struct lfsck_instance,
+ li_mdt_descs);
lfsck_interpret(env, lfsck, req, laia, rc);
lfsck_tgt_put(laia->laia_ltd);
if (rc != 0 && laia->laia_result != -EALREADY)
CDEBUG(D_LFSCK, "%s: waiting for assistant to do %s post, rc = %d\n",
lfsck_lfsck2name(com->lc_lfsck), lad->lad_name, *result);
- wake_up_all(&athread->t_ctl_waitq);
+ wake_up(&athread->t_ctl_waitq);
wait_event_idle(mthread->t_ctl_waitq,
(*result > 0 && list_empty(&lad->lad_req_list)) ||
thread_is_stopped(athread));
"status %d\n",
lfsck_lfsck2name(com->lc_lfsck), lad->lad_name, status);
- wake_up_all(&athread->t_ctl_waitq);
+ wake_up(&athread->t_ctl_waitq);
wait_event_idle(mthread->t_ctl_waitq,
test_bit(LAD_IN_DOUBLE_SCAN, &lad->lad_flags) ||
thread_is_stopped(athread));
struct ptlrpc_thread *athread = &lad->lad_thread;
set_bit(LAD_EXIT, &lad->lad_flags);
- wake_up_all(&athread->t_ctl_waitq);
+ wake_up(&athread->t_ctl_waitq);
wait_event_idle(mthread->t_ctl_waitq,
thread_is_init(athread) ||
thread_is_stopped(athread));
if (unlikely(rc == -EINPROGRESS)) {
retry = true;
- set_current_state(TASK_INTERRUPTIBLE);
- schedule_timeout(cfs_time_seconds(1));
+ schedule_timeout_interruptible(cfs_time_seconds(1));
set_current_state(TASK_RUNNING);
if (!signal_pending(current) &&
thread_is_running(&lfsck->li_thread))
thread_is_stopped(thread));
if (start == NULL || !(start->ls_flags & LPF_BROADCAST)) {
lfsck->li_start_unplug = 1;
- wake_up_all(&thread->t_ctl_waitq);
+ wake_up(&thread->t_ctl_waitq);
GOTO(out, rc = 0);
}
spin_unlock(&lfsck->li_lock);
lfsck->li_start_unplug = 1;
- wake_up_all(&thread->t_ctl_waitq);
+ wake_up(&thread->t_ctl_waitq);
wait_event_idle(thread->t_ctl_waitq,
thread_is_stopped(thread));
}
} else {
lfsck->li_start_unplug = 1;
- wake_up_all(&thread->t_ctl_waitq);
+ wake_up(&thread->t_ctl_waitq);
}
GOTO(put, rc);
thread_set_flags(thread, SVC_STOPPING);
LASSERT(lfsck->li_task != NULL);
- force_sig(SIGINT, lfsck->li_task);
+ cfs_force_sig(SIGINT, lfsck->li_task);
if (lfsck->li_master) {
struct lfsck_component *com;
lad = com->lc_data;
spin_lock(&lad->lad_lock);
if (lad->lad_task != NULL)
- force_sig(SIGINT, lad->lad_task);
+ cfs_force_sig(SIGINT, lad->lad_task);
spin_unlock(&lad->lad_lock);
}
lad = com->lc_data;
spin_lock(&lad->lad_lock);
if (lad->lad_task != NULL)
- force_sig(SIGINT, lad->lad_task);
+ cfs_force_sig(SIGINT, lad->lad_task);
spin_unlock(&lad->lad_lock);
}
}
- wake_up_all(&thread->t_ctl_waitq);
+ wake_up(&thread->t_ctl_waitq);
spin_unlock(&lfsck->li_lock);
if (stop && stop->ls_flags & LPF_BROADCAST)
rc1 = lfsck_stop_all(env, lfsck, stop);
GOTO(out, rc = -ENOTSUPP);
}
- for (i = 0, type = 1 << i; i < LFSCK_TYPE_BITS;
- i++, type = 1 << i) {
+ for (i = 0, type = BIT(i); i < LFSCK_TYPE_BITS;
+ i++, type = BIT(i)) {
if (!(que->lu_types & type))
continue;
if (!(que->lu_flags & LPF_WAIT))
GOTO(out, rc);
- for (i = 0, type = 1 << i; i < LFSCK_TYPE_BITS;
- i++, type = 1 << i) {
+ for (i = 0, type = BIT(i); i < LFSCK_TYPE_BITS;
+ i++, type = BIT(i)) {
if (!(que->lu_types & type))
continue;
if (IS_ERR(root))
GOTO(out, rc = PTR_ERR(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;
struct lu_fid *pfid = &lfsck_env_info(env)->lti_fid2;
const struct lu_name *cname;
- rc = dt_lookup(env, root,
- (struct dt_rec *)(&lfsck->li_global_root_fid),
- (const struct dt_key *)"ROOT");
+ rc = dt_lookup_dir(env, root, "ROOT",
+ &lfsck->li_global_root_fid);
if (rc != 0)
GOTO(out, rc);
if (IS_ERR(obj))
GOTO(out, rc = PTR_ERR(obj));
- if (unlikely(!dt_try_as_dir(env, obj)))
- GOTO(out, rc = -ENOTDIR);
-
- rc = dt_lookup(env, obj, (struct dt_rec *)fid,
- (const struct dt_key *)dotlustre);
+ rc = dt_lookup_dir(env, obj, dotlustre, fid);
if (rc != 0)
GOTO(out, rc);
cname = lfsck_name_get_const(env, dotlustre,
strlen(dotlustre));
- rc = lfsck_verify_linkea(env, obj, cname,
+ rc = lfsck_verify_linkea(env, lfsck, obj, cname,
&lfsck->li_global_root_fid);
if (rc != 0)
GOTO(out, rc);
GOTO(out, rc = -ENOTDIR);
*pfid = *fid;
- rc = dt_lookup(env, obj, (struct dt_rec *)fid,
- (const struct dt_key *)lostfound);
+ rc = dt_lookup_dir(env, obj, lostfound, fid);
if (rc != 0)
GOTO(out, rc);
cname = lfsck_name_get_const(env, lostfound,
strlen(lostfound));
- rc = lfsck_verify_linkea(env, obj, cname, pfid);
+ rc = lfsck_verify_linkea(env, lfsck, obj, cname, pfid);
if (rc != 0)
GOTO(out, rc);
{
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);
rc = lu_context_key_register(&lfsck_thread_key);
if (!rc) {
git://git.whamcloud.com / fs / lustre-release.git / blobdiff