struct lfsck_layout_slave_target *llsaa_llst;
};
-static inline bool lfsck_comp_extent_aligned(__u64 size)
+static inline bool lfsck_comp_extent_aligned(__u64 border, __u32 size)
{
- return (size & (LOV_MIN_STRIPE_SIZE - 1)) == 0;
+ return (border & (size - 1)) == 0;
}
static inline void
static int lfsck_layout_verify_header_v1v3(struct dt_object *obj,
struct lov_mds_md_v1 *lmm,
- __u64 start, __u32 comp_id)
+ __u64 start, __u64 end,
+ __u32 comp_id,
+ bool ext, bool *dom)
{
__u32 magic;
__u32 pattern;
+ __u32 size;
magic = le32_to_cpu(lmm->lmm_magic);
/* If magic crashed, keep it there. Sometime later, during OST-object
else
rc = -EINVAL;
- CDEBUG(D_LFSCK, "%s LOV EA magic %u for the file "DFID"\n",
+ CDEBUG(D_LFSCK, "%s LOV EA magic 0x%X for the file "DFID"\n",
rc == -EINVAL ? "Unknown" : "Unsupported",
magic, PFID(lfsck_dto2fid(obj)));
}
pattern = le32_to_cpu(lmm->lmm_pattern);
+ *dom = !!(lov_pattern(pattern) == LOV_PATTERN_MDT);
-#if 0
/* XXX: DoM file verification will be supportted via LU-11081. */
if (lov_pattern(pattern) == LOV_PATTERN_MDT) {
+#if 0
if (start != 0) {
CDEBUG(D_LFSCK, "The DoM entry for "DFID" is not "
"the first component in the mirror %x/%llu\n",
return -EINVAL;
}
- }
#endif
-
- if (!lov_pattern_supported_normal_comp(lov_pattern(pattern))) {
+ } else if (!lov_pattern_supported_normal_comp(lov_pattern(pattern))) {
CDEBUG(D_LFSCK, "Unsupported LOV EA pattern %u for the file "
DFID" in the component %x\n",
pattern, PFID(lfsck_dto2fid(obj)), comp_id);
return -EOPNOTSUPP;
}
+ size = le32_to_cpu(lmm->lmm_stripe_size);
+ if (!ext && end != LUSTRE_EOF && start != end &&
+ !lfsck_comp_extent_aligned(end, size)){
+ CDEBUG(D_LFSCK, "not aligned border in PFL extent range "
+ "[%llu - %llu) stripesize %u for the file "DFID
+ " at idx %d\n", start, end, size,
+ PFID(lfsck_dto2fid(obj)), comp_id);
+
+ return -EINVAL;
+ }
+
return 0;
}
static int lfsck_layout_verify_header(struct dt_object *obj,
struct lov_mds_md_v1 *lmm, size_t len)
{
+ bool p_dom = false;
int rc = 0;
- if (le32_to_cpu(lmm->lmm_magic) == LOV_MAGIC_COMP_V1) {
+ if (le32_to_cpu(lmm->lmm_magic) == LOV_MAGIC_COMP_V1 ||
+ le32_to_cpu(lmm->lmm_magic) == LOV_MAGIC_SEL) {
struct lov_comp_md_v1 *lcm = (struct lov_comp_md_v1 *)lmm;
+ bool p_zero = false;
int i;
__u16 count = le16_to_cpu(lcm->lcm_entry_count);
__u64 start = le64_to_cpu(lcme->lcme_extent.e_start);
__u64 end = le64_to_cpu(lcme->lcme_extent.e_end);
__u32 comp_id = le32_to_cpu(lcme->lcme_id);
+ bool ext, inited, zero;
+ __u32 flags;
if (unlikely(comp_id == LCME_ID_INVAL ||
comp_id > LCME_ID_MAX)) {
- CDEBUG(D_LFSCK, "found invalid FPL ID %u "
+ CDEBUG(D_LFSCK, "found invalid PFL ID %u "
"for the file "DFID" at idx %d\n",
comp_id, PFID(lfsck_dto2fid(obj)), i);
return -EINVAL;
}
- if (unlikely(start >= end ||
- !lfsck_comp_extent_aligned(start) ||
- (!lfsck_comp_extent_aligned(end) &&
- end != LUSTRE_EOF))) {
- CDEBUG(D_LFSCK, "found invalid FPL extent "
- "range [%llu - %llu) for the file "
- DFID" at idx %d\n",
- start, end, PFID(lfsck_dto2fid(obj)), i);
+ flags = le32_to_cpu(lcme->lcme_flags);
+ ext = flags & LCME_FL_EXTENSION;
+ inited = flags & LCME_FL_INIT;
+ zero = !!(start == end);
+
+ if ((i == 0) && zero) {
+ CDEBUG(D_LFSCK, "invalid PFL comp %d: [%llu "
+ "- %llu) for "DFID"\n", i, start, end,
+ PFID(lfsck_dto2fid(obj)));
+ return -EINVAL;
+ }
+
+ if ((zero && (inited || (i + 1 == count))) ||
+ (start > end)) {
+ CDEBUG(D_LFSCK, "invalid PFL comp %d/%d: "
+ "[%llu, %llu) for "DFID", %sinited\n",
+ i, count, start, end,
+ PFID(lfsck_dto2fid(obj)),
+ inited ? "" : "NOT ");
+ return -EINVAL;
+ }
+
+ if (!ext && p_zero) {
+ CDEBUG(D_LFSCK, "invalid PFL comp %d: [%llu, "
+ "%llu) for "DFID": NOT extension "
+ "after 0-length component\n", i,
+ start, end, PFID(lfsck_dto2fid(obj)));
+ return -EINVAL;
+ }
+ if (ext && (inited || p_dom || zero)) {
+ CDEBUG(D_LFSCK, "invalid PFL comp %d: [%llu, "
+ "%llu) for "DFID": %s\n", i,
+ start, end, PFID(lfsck_dto2fid(obj)),
+ inited ? "inited extension" :
+ p_dom ? "extension follows DOM" :
+ zero ? "zero length extension" : "");
return -EINVAL;
}
rc = lfsck_layout_verify_header_v1v3(obj,
(struct lov_mds_md_v1 *)((char *)lmm +
le32_to_cpu(lcme->lcme_offset)), start,
- comp_id);
+ end, comp_id, ext, &p_dom);
+
+ p_zero = zero;
}
} else if (le32_to_cpu(lmm->lmm_magic) == LOV_MAGIC_FOREIGN) {
rc = lfsck_layout_verify_header_foreign(obj,
(struct lov_foreign_md *)lmm,
len);
} else {
- rc = lfsck_layout_verify_header_v1v3(obj, lmm, 1, 0);
+ rc = lfsck_layout_verify_header_v1v3(obj, lmm, 0, LUSTRE_EOF,
+ 0, false, &p_dom);
}
return rc;
memset(dof, 0, sizeof(*dof));
dof->dof_type = dt_mode_to_dft(S_IFREG);
- th = dt_trans_create(env, dt);
+ th = lfsck_trans_create(env, dt, lfsck);
if (IS_ERR(th))
GOTO(log, rc = PTR_ERR(th));
continue;
}
- th = dt_trans_create(env, dt);
+ th = lfsck_trans_create(env, dt, lfsck);
if (IS_ERR(th)) {
rc1 = PTR_ERR(th);
CDEBUG(D_LFSCK, "%s: layout LFSCK failed to store "
mutex_lock(&com->lc_sub_trace_objs[idx].lsto_mutex);
- th = dt_trans_create(env, dev);
+ th = lfsck_trans_create(env, dev, com->lc_lfsck);
if (IS_ERR(th))
GOTO(unlock, rc = PTR_ERR(th));
mutex_lock(&com->lc_sub_trace_objs[idx].lsto_mutex);
- th = dt_trans_create(env, dev);
+ th = lfsck_trans_create(env, dev, com->lc_lfsck);
if (IS_ERR(th))
GOTO(unlock, rc = PTR_ERR(th));
}
static int __lfsck_layout_update_pfid(const struct lu_env *env,
+ struct lfsck_component *com,
struct dt_object *child,
const struct lu_fid *pfid,
const struct ost_layout *ol, __u32 offset,
ff->ff_range = cpu_to_le32(range);
lfsck_buf_init(&buf, ff, sizeof(*ff));
- handle = dt_trans_create(env, dev);
+ handle = lfsck_trans_create(env, dev, com->lc_lfsck);
if (IS_ERR(handle))
RETURN(PTR_ERR(handle));
if (IS_ERR(child))
RETURN(PTR_ERR(child));
- rc = __lfsck_layout_update_pfid(env, child,
+ rc = __lfsck_layout_update_pfid(env, com, child,
lu_object_fid(&parent->do_lu),
&rec->lor_layout, ea_off,
rec->lor_layout_version,
do {
snprintf(name, NAME_MAX, DFID"%s-%s-%d", PFID(pfid), infix,
type, idx++);
- rc = dt_lookup(env, lfsck->li_lpf_obj, (struct dt_rec *)tfid,
- (const struct dt_key *)name);
+ rc = dt_lookup_dir(env, lfsck->li_lpf_obj, name, tfid);
if (rc != 0 && rc != -ENOENT)
GOTO(log, rc);
} while (rc == 0);
/* Re-check whether the name conflict with othrs after taken
* the ldlm lock. */
- rc = dt_lookup(env, lfsck->li_lpf_obj, (struct dt_rec *)tfid,
- (const struct dt_key *)name);
+ rc = dt_lookup_dir(env, lfsck->li_lpf_obj, name, tfid);
if (unlikely(rc == 0)) {
lfsck_unlock(llh);
goto again;
GOTO(unlock, rc);
/* The 1st transaction. */
- th = dt_trans_create(env, dev);
+ th = lfsck_trans_create(env, dev, lfsck);
if (IS_ERR(th))
GOTO(unlock, rc = PTR_ERR(th));
th = NULL;
/* The 2nd transaction. */
- rc = __lfsck_layout_update_pfid(env, cobj, pfid,
+ rc = __lfsck_layout_update_pfid(env, com, cobj, pfid,
&rec->lor_layout, ea_off,
rec->lor_layout_version,
rec->lor_range);
if (la->la_ctime != 0)
GOTO(unlock, rc = -ETXTBSY);
- th = dt_trans_create(env, dev);
+ th = lfsck_trans_create(env, dev, lfsck);
if (IS_ERR(th))
GOTO(unlock, rc = PTR_ERR(th));
if (lfsck_is_dryrun(com->lc_lfsck))
GOTO(unlock, rc = 0);
- th = dt_trans_create(env, dev);
+ th = lfsck_trans_create(env, dev, com->lc_lfsck);
if (IS_ERR(th))
GOTO(unlock, rc = PTR_ERR(th));
}
if (!(bk->lb_param & LPF_DRYRUN)) {
- handle = dt_trans_create(env, dt);
+ handle = lfsck_trans_create(env, dt, lfsck);
if (IS_ERR(handle))
GOTO(unlock_layout, rc = PTR_ERR(handle));
GOTO(unlock_parent, rc = rc1);
magic = le32_to_cpu(lmm->lmm_magic);
- if (magic == LOV_MAGIC_COMP_V1) {
+ if (magic == LOV_MAGIC_COMP_V1 || magic == LOV_MAGIC_SEL) {
__u64 start;
__u64 end;
__u16 mirror_id0 = mirror_id_of(ol->ol_comp_id);
ol->ol_comp_id = 0;
ff->ff_layout_version = 0;
ff->ff_range = 0;
- } else if (magic == LOV_MAGIC_COMP_V1) {
+ } else if (magic == LOV_MAGIC_COMP_V1 || magic == LOV_MAGIC_SEL) {
struct lov_comp_md_v1 *lcm = (struct lov_comp_md_v1 *)lmm;
struct lov_comp_md_entry_v1 *lcme = NULL;
__u16 count = le16_to_cpu(lcm->lcm_entry_count);
GOTO(unlock1, rc);
buf = lfsck_buf_get(env, ff, sizeof(struct filter_fid));
- handle = dt_trans_create(env, dev);
+ handle = lfsck_trans_create(env, dev, lfsck);
if (IS_ERR(handle))
GOTO(unlock1, rc = PTR_ERR(handle));
lmm = lovea->lb_buf;
magic = le32_to_cpu(lmm->lmm_magic);
- if (magic == LOV_MAGIC_COMP_V1) {
+ if (magic == LOV_MAGIC_COMP_V1 || magic == LOV_MAGIC_SEL) {
struct lov_comp_md_v1 *lcm = buf->lb_buf;
struct lov_comp_md_entry_v1 *lcme;
__u16 count = le16_to_cpu(lcm->lcm_entry_count);
buf = lfsck_buf_get(env, ff, sizeof(*ff));
- handle = dt_trans_create(env, dev);
+ handle = lfsck_trans_create(env, dev, com->lc_lfsck);
if (IS_ERR(handle))
GOTO(unlock1, rc = PTR_ERR(handle));
memset(dof, 0, sizeof(*dof));
dev = lfsck_obj2dev(child);
- handle = dt_trans_create(env, dev);
+ handle = lfsck_trans_create(env, dev, lfsck);
if (IS_ERR(handle))
GOTO(log, rc = PTR_ERR(handle));
if (IS_ERR(parent))
GOTO(log, rc = PTR_ERR(parent));
- handle = dt_trans_create(env, dev);
+ handle = lfsck_trans_create(env, dev, lfsck);
if (IS_ERR(handle))
GOTO(log, rc = PTR_ERR(handle));
lmm = buf->lb_buf;
magic = le32_to_cpu(lmm->lmm_magic);
- if (magic == LOV_MAGIC_COMP_V1) {
+ if (magic == LOV_MAGIC_COMP_V1 || magic == LOV_MAGIC_SEL) {
struct lov_comp_md_v1 *lcm = buf->lb_buf;
struct lov_comp_md_entry_v1 *lcme;
__u16 count = le16_to_cpu(lcm->lcm_entry_count);
tla->la_uid = pla->la_uid;
tla->la_gid = pla->la_gid;
tla->la_valid = LA_UID | LA_GID;
- handle = dt_trans_create(env, dev);
+ handle = lfsck_trans_create(env, dev, com->lc_lfsck);
if (IS_ERR(handle))
GOTO(log, rc = PTR_ERR(handle));
lmm = buf->lb_buf;
magic = le32_to_cpu(lmm->lmm_magic);
- if (magic == LOV_MAGIC_COMP_V1) {
+ if (magic == LOV_MAGIC_COMP_V1 || magic == LOV_MAGIC_SEL) {
struct lov_comp_md_v1 *lcm = buf->lb_buf;
struct lov_comp_md_entry_v1 *lcme;
lmm = buf->lb_buf;
magic = le32_to_cpu(lmm->lmm_magic);
- if (magic == LOV_MAGIC_COMP_V1) {
+ if (magic == LOV_MAGIC_COMP_V1 || magic == LOV_MAGIC_SEL) {
struct lov_comp_md_v1 *lcm = buf->lb_buf;
struct lov_comp_md_entry_v1 *lcme;
lfsck_is_dead_obj(obj)))
GOTO(unlock, rc = 0);
- rc = __lfsck_layout_update_pfid(env, obj, &lrl->lrl_ff_client.ff_parent,
+ rc = __lfsck_layout_update_pfid(env, com, obj,
+ &lrl->lrl_ff_client.ff_parent,
&lrl->lrl_ff_client.ff_layout,
lrl->lrl_ff_client.ff_layout_version,
lrl->lrl_ff_client.ff_range,
lad->lad_prefetched++;
spin_unlock(&lad->lad_lock);
if (wakeup)
- wake_up_all(&athread->t_ctl_waitq);
+ wake_up(&athread->t_ctl_waitq);
next:
down_write(&com->lc_sem);
size = rc;
lmm = buf->lb_buf;
magic = le32_to_cpu(lmm->lmm_magic);
- if (magic == LOV_MAGIC_COMP_V1) {
+ if (magic == LOV_MAGIC_COMP_V1 || magic == LOV_MAGIC_SEL) {
struct lov_mds_md_v1 *v1;
int i;
if (rc != 0)
GOTO(out, rc);
- handle = dt_trans_create(env, dev);
+ handle = lfsck_trans_create(env, dev, lfsck);
if (IS_ERR(handle))
GOTO(out, rc = PTR_ERR(handle));
goto again;
}
- if (magic == LOV_MAGIC_COMP_V1) {
+ if (magic == LOV_MAGIC_COMP_V1 || magic == LOV_MAGIC_SEL) {
struct lov_mds_md_v1 *v1;
int i;
PFID(lfsck_dto2fid(obj)), rc);
if (stripe) {
- if (magic == LOV_MAGIC_COMP_V1) {
+ if (magic == LOV_MAGIC_COMP_V1 || magic == LOV_MAGIC_SEL) {
int i;
for (i = 0; i < count; i++) {
(rc > 0 && lo->ll_flags & LF_INCOMPLETE) ? 0 : rc);
lfsck_layout_slave_quit(env, com);
if (atomic_dec_and_test(&lfsck->li_double_scan_count))
- wake_up_all(&lfsck->li_thread.t_ctl_waitq);
+ wake_up(&lfsck->li_thread.t_ctl_waitq);
CDEBUG(D_LFSCK, "%s: layout LFSCK slave phase2 scan finished, "
"status %d: rc = %d\n",
stop->ls_flags = lr->lr_param & ~LPF_BROADCAST;
lfsck_stop(env, lfsck->li_bottom, stop);
} else if (lfsck_phase2_next_ready(lad)) {
- wake_up_all(&lad->lad_thread.t_ctl_waitq);
+ wake_up(&lad->lad_thread.t_ctl_waitq);
}
RETURN(0);
true);
if (llst != NULL) {
lfsck_layout_llst_put(llst);
- wake_up_all(&lfsck->li_thread.t_ctl_waitq);
+ wake_up(&lfsck->li_thread.t_ctl_waitq);
}
}
lfsck_layout_llst_put(llst);
if (list_empty(&llsd->llsd_master_list))
- wake_up_all(&lfsck->li_thread.t_ctl_waitq);
+ wake_up(&lfsck->li_thread.t_ctl_waitq);
if (lr->lr_event == LE_PEER_EXIT &&
(lfsck->li_bookmark_ram.lb_param & LPF_FAILOUT ||
RETURN(rc);
}
-static struct lfsck_operations lfsck_layout_master_ops = {
+static const struct lfsck_operations lfsck_layout_master_ops = {
.lfsck_reset = lfsck_layout_reset,
.lfsck_fail = lfsck_layout_fail,
.lfsck_checkpoint = lfsck_layout_master_checkpoint,
.lfsck_query = lfsck_layout_query,
};
-static struct lfsck_operations lfsck_layout_slave_ops = {
+static const struct lfsck_operations lfsck_layout_slave_ops = {
.lfsck_reset = lfsck_layout_reset,
.lfsck_fail = lfsck_layout_fail,
.lfsck_checkpoint = lfsck_layout_slave_checkpoint,
pos->lp_oit_cookie = llr->llr_lar.lar_parent->lso_oit_cookie - 1;
}
-struct lfsck_assistant_operations lfsck_layout_assistant_ops = {
+const struct lfsck_assistant_operations lfsck_layout_assistant_ops = {
.la_handler_p1 = lfsck_layout_assistant_handler_p1,
.la_handler_p2 = lfsck_layout_assistant_handler_p2,
.la_fill_pos = lfsck_layout_assistant_fill_pos,
}
static void lfsck_layout_destroy_orphan(const struct lu_env *env,
+ struct lfsck_instance *lfsck,
struct dt_object *obj)
{
struct dt_device *dev = lfsck_obj2dev(obj);
int rc;
ENTRY;
- handle = dt_trans_create(env, dev);
+ handle = lfsck_trans_create(env, dev, lfsck);
if (IS_ERR(handle))
RETURN_EXIT;
* OST-object there. Destroy it now! */
if (unlikely(!(la->la_mode & S_ISUID))) {
dt_read_unlock(env, obj);
- lfsck_layout_destroy_orphan(env, obj);
+ lfsck_layout_destroy_orphan(env, lfsck, obj);
lfsck_object_put(env, obj);
pos++;
goto again1;
git://git.whamcloud.com / fs / lustre-release.git / blobdiff