static int lfsck_layout_verify_header(struct lov_mds_md_v1 *lmm)
{
__u32 magic;
- __u32 patten;
+ __u32 pattern;
magic = le32_to_cpu(lmm->lmm_magic);
/* If magic crashed, keep it there. Sometime later, during OST-object
* orphan handling, if some OST-object(s) back-point to it, it can be
* verified and repaired. */
- if (magic != LOV_MAGIC_V1 && magic != LOV_MAGIC_V3)
- return -EINVAL;
+ if (magic != LOV_MAGIC_V1 && magic != LOV_MAGIC_V3) {
+ struct ost_id oi;
+ int rc;
+
+ lmm_oi_cpu_to_le(&oi, &lmm->lmm_oi);
+ if ((magic & LOV_MAGIC_MASK) == LOV_MAGIC_MAGIC)
+ rc = -EOPNOTSUPP;
+ else
+ rc = -EINVAL;
+
+ CDEBUG(D_LFSCK, "%s LOV EA magic %u on "DOSTID"\n",
+ rc == -EINVAL ? "Unknown" : "Unsupported",
+ magic, POSTID(&oi));
+
+ return rc;
+ }
- patten = le32_to_cpu(lmm->lmm_pattern);
+ pattern = le32_to_cpu(lmm->lmm_pattern);
/* XXX: currently, we only support LOV_PATTERN_RAID0. */
- if (patten != LOV_PATTERN_RAID0)
+ if (lov_pattern(pattern) != LOV_PATTERN_RAID0) {
+ struct ost_id oi;
+
+ lmm_oi_cpu_to_le(&oi, &lmm->lmm_oi);
+ CDEBUG(D_LFSCK, "Unsupported LOV EA pattern %u on "DOSTID"\n",
+ pattern, POSTID(&oi));
+
return -EOPNOTSUPP;
+ }
return 0;
}
#define LFSCK_RBTREE_BITMAP_SIZE PAGE_CACHE_SIZE
#define LFSCK_RBTREE_BITMAP_WIDTH (LFSCK_RBTREE_BITMAP_SIZE << 3)
-#define LFSCK_RBTREE_BITMAP_MASK (LFSCK_RBTREE_BITMAP_SIZE - 1)
+#define LFSCK_RBTREE_BITMAP_MASK (LFSCK_RBTREE_BITMAP_WIDTH - 1)
struct lfsck_rbtree_node {
struct rb_node lrn_node;
if (oid < lrn->lrn_first_oid)
return -1;
- if (oid >= lrn->lrn_first_oid + LFSCK_RBTREE_BITMAP_WIDTH)
+ if (oid - lrn->lrn_first_oid >= LFSCK_RBTREE_BITMAP_WIDTH)
return 1;
return 0;
lfsck_rbtree_insert(struct lfsck_layout_slave_data *llsd,
struct lfsck_rbtree_node *lrn)
{
- struct rb_node **pos = &(llsd->llsd_rb_root.rb_node);
+ struct rb_node **pos = &llsd->llsd_rb_root.rb_node;
struct rb_node *parent = NULL;
struct lfsck_rbtree_node *tmp;
int rc;
- while (*pos) {
+ while (*pos != NULL) {
parent = *pos;
- tmp = rb_entry(*pos, struct lfsck_rbtree_node, lrn_node);
+ tmp = rb_entry(parent, struct lfsck_rbtree_node, lrn_node);
rc = lfsck_rbtree_cmp(tmp, lrn->lrn_seq, lrn->lrn_first_oid);
if (rc < 0)
- pos = &((*pos)->rb_left);
+ pos = &(*pos)->rb_left;
else if (rc > 0)
- pos = &((*pos)->rb_right);
+ pos = &(*pos)->rb_right;
else
return tmp;
}
return rc;
}
+static void lfsck_layout_record_failure(const struct lu_env *env,
+ struct lfsck_instance *lfsck,
+ struct lfsck_layout *lo)
+{
+ lo->ll_objs_failed_phase1++;
+ if (unlikely(lo->ll_pos_first_inconsistent == 0))
+ lo->ll_pos_first_inconsistent =
+ lfsck->li_obj_oit->do_index_ops->dio_it.store(env,
+ lfsck->li_di_oit);
+}
+
static int lfsck_layout_master_async_interpret(const struct lu_env *env,
struct ptlrpc_request *req,
void *args, int rc)
struct dt_object *parent,
struct lu_fid *cfid,
struct lu_buf *buf, int fl,
- __u32 ost_idx, __u32 ea_off)
+ __u32 ost_idx, __u32 ea_off, bool reset)
{
struct lov_mds_md_v1 *lmm = buf->lb_buf;
struct lov_ost_data_v1 *objs;
int rc;
ENTRY;
- if (fl == LU_XATTR_CREATE) {
+ if (fl == LU_XATTR_CREATE || reset) {
LASSERT(buf->lb_len == lov_mds_md_size(ea_off + 1,
LOV_MAGIC_V1));
/* 3b. Add layout EA for the MDT-object. */
rc = lfsck_layout_extend_lovea(env, th, pobj, cfid, ea_buf,
LU_XATTR_CREATE, ltd->ltd_index,
- ea_off);
+ ea_off, false);
dt_write_unlock(env, pobj);
if (rc < 0)
GOTO(stop, rc);
buf->lb_len = rc;
rc = lfsck_layout_extend_lovea(env, handle, parent, cfid, buf,
- fl, ost_idx, ea_off);
+ fl, ost_idx, ea_off, false);
GOTO(unlock_parent, rc);
}
lmm = buf->lb_buf;
rc1 = lfsck_layout_verify_header(lmm);
+
+ /* If the LOV EA crashed, the rebuild it. */
+ if (rc1 == -EINVAL) {
+ if (bk->lb_param & LPF_DRYRUN)
+ GOTO(unlock_parent, rc = 1);
+
+ LASSERT(buf->lb_len >= rc);
+
+ buf->lb_len = rc;
+ memset(lmm, 0, buf->lb_len);
+ rc = lfsck_layout_extend_lovea(env, handle, parent, cfid, buf,
+ fl, ost_idx, ea_off, true);
+
+ GOTO(unlock_parent, rc);
+ }
+
+ /* For other unknown magic/pattern, keep the current LOV EA. */
if (rc1 != 0)
GOTO(unlock_parent, rc = rc1);
buf->lb_len = rc;
rc = lfsck_layout_extend_lovea(env, handle, parent, cfid, buf,
- fl, ost_idx, ea_off);
+ fl, ost_idx, ea_off, false);
GOTO(unlock_parent, rc);
}
return rc > 0 ? 0 : rc;
}
-/* For the MDT-object with dangling reference, we need to re-create
- * the missed OST-object with the known FID/owner information. */
-static int lfsck_layout_recreate_ostobj(const struct lu_env *env,
+/* For the MDT-object with dangling reference, we need to repare the
+ * inconsistency according to the LFSCK sponsor's requirement:
+ *
+ * 1) Keep the inconsistency there and report the inconsistency case,
+ * then give the chance to the application to find related issues,
+ * and the users can make the decision about how to handle it with
+ * more human knownledge. (by default)
+ *
+ * 2) Re-create the missed OST-object with the FID/owner information. */
+static int lfsck_layout_repair_dangling(const struct lu_env *env,
struct lfsck_component *com,
struct lfsck_layout_req *llr,
- struct lu_attr *la)
+ const struct lu_attr *pla)
{
struct lfsck_thread_info *info = lfsck_env_info(env);
struct filter_fid *pfid = &info->lti_new_pfid;
struct dt_allocation_hint *hint = &info->lti_hint;
+ struct lu_attr *cla = &info->lti_la2;
struct dt_object *parent = llr->llr_parent->llo_obj;
struct dt_object *child = llr->llr_child;
struct dt_device *dev = lfsck_obj2dt_dev(child);
struct lu_buf *buf;
struct lustre_handle lh = { 0 };
int rc;
+ bool create;
ENTRY;
- CDEBUG(D_LFSCK, "Repair dangling reference for: parent "DFID
- ", child "DFID", OST-index %u, stripe-index %u, owner %u:%u\n",
+ if (com->lc_lfsck->li_bookmark_ram.lb_param & LPF_CREATE_OSTOBJ)
+ create = true;
+ else
+ create = false;
+
+ CDEBUG(D_LFSCK, "Found dangling reference for: parent "DFID
+ ", child "DFID", OST-index %u, stripe-index %u, owner %u:%u. %s",
PFID(lfsck_dto2fid(parent)), PFID(lfsck_dto2fid(child)),
- llr->llr_ost_idx, llr->llr_lov_idx, la->la_uid, la->la_gid);
+ llr->llr_ost_idx, llr->llr_lov_idx, pla->la_uid, pla->la_gid,
+ create ? "Create the lost OST-object as required.\n" :
+ "Keep the MDT-object there by default.\n");
+
+ if (!create)
+ RETURN(1);
+
+ memset(cla, 0, sizeof(*cla));
+ cla->la_uid = pla->la_uid;
+ cla->la_gid = pla->la_gid;
+ cla->la_mode = S_IFREG | 0666;
+ cla->la_valid = LA_TYPE | LA_MODE | LA_UID | LA_GID |
+ LA_ATIME | LA_MTIME | LA_CTIME;
rc = lfsck_layout_lock(env, com, parent, &lh,
MDS_INODELOCK_LAYOUT | MDS_INODELOCK_XATTR);
pfid->ff_parent.f_stripe_idx = cpu_to_le32(llr->llr_lov_idx);
buf = lfsck_buf_get(env, pfid, sizeof(struct filter_fid));
- rc = dt_declare_create(env, child, la, hint, NULL, handle);
+ rc = dt_declare_create(env, child, cla, hint, NULL, handle);
if (rc != 0)
GOTO(stop, rc);
if (unlikely(lu_object_is_dying(parent->do_lu.lo_header)))
GOTO(unlock2, rc = 1);
- rc = dt_create(env, child, la, hint, NULL, handle);
+ rc = dt_create(env, child, cla, hint, NULL, handle);
if (rc != 0)
GOTO(unlock2, rc);
GOTO(unlock2, rc = 0);
lmm = buf->lb_buf;
- rc = lfsck_layout_verify_header(lmm);
- if (rc != 0)
- GOTO(unlock2, rc);
-
/* Someone change layout during the LFSCK, no need to repair then. */
if (le16_to_cpu(lmm->lmm_layout_gen) != llr->llr_parent->llo_gen)
GOTO(unlock2, rc = 0);
GOTO(out, rc);
lmm = buf->lb_buf;
- rc = lfsck_layout_verify_header(lmm);
- if (rc != 0)
- GOTO(out, rc);
-
- /* Currently, we only support LOV_MAGIC_V1/LOV_MAGIC_V3 which has
- * been verified in lfsck_layout_verify_header() already. If some
- * new magic introduced in the future, then layout LFSCK needs to
- * be updated also. */
magic = le32_to_cpu(lmm->lmm_magic);
if (magic == LOV_MAGIC_V1) {
objs = &(lmm->lmm_objects[0]);
switch (type) {
case LLIT_DANGLING:
- memset(cla, 0, sizeof(*cla));
- cla->la_uid = pla->la_uid;
- cla->la_gid = pla->la_gid;
- cla->la_mode = S_IFREG | 0666;
- cla->la_valid = LA_TYPE | LA_MODE | LA_UID | LA_GID |
- LA_ATIME | LA_MTIME | LA_CTIME;
- rc = lfsck_layout_recreate_ostobj(env, com, llr, cla);
+ rc = lfsck_layout_repair_dangling(env, com, llr, pla);
break;
case LLIT_UNMATCHED_PAIR:
rc = lfsck_layout_repair_unmatched_pair(env, com, llr, pla);
lo->ll_objs_skipped++;
rc = 0;
} else {
- lo->ll_objs_failed_phase1++;
+ lfsck_layout_record_failure(env, lfsck, lo);
}
} else if (rc > 0) {
LASSERTF(type > LLIT_NONE && type <= LLIT_MAX,
"unknown type = %d\n", type);
lo->ll_objs_repaired[type - 1]++;
+ if (bk->lb_param & LPF_DRYRUN &&
+ unlikely(lo->ll_pos_first_inconsistent == 0))
+ lo->ll_pos_first_inconsistent =
+ lfsck->li_obj_oit->do_index_ops->dio_it.store(env,
+ lfsck->li_di_oit);
}
up_write(&com->lc_sem);
memset(lr, 0, sizeof(*lr));
lr->lr_event = LE_START;
lr->lr_valid = LSV_SPEED_LIMIT | LSV_ERROR_HANDLE | LSV_DRYRUN |
- LSV_ASYNC_WINDOWS;
+ LSV_ASYNC_WINDOWS | LSV_CREATE_OSTOBJ;
lr->lr_speed = bk->lb_speed_limit;
lr->lr_version = bk->lb_version;
lr->lr_param = bk->lb_param;
down_write(&com->lc_sem);
if (new_checked)
com->lc_new_checked++;
- lo->ll_objs_failed_phase1++;
- if (lo->ll_pos_first_inconsistent == 0) {
- struct lfsck_instance *lfsck = com->lc_lfsck;
-
- lo->ll_pos_first_inconsistent =
- lfsck->li_obj_oit->do_index_ops->dio_it.store(env,
- lfsck->li_di_oit);
- }
+ lfsck_layout_record_failure(env, com->lc_lfsck, lo);
up_write(&com->lc_sem);
}
int rc;
rc = lfsck_layout_reset(env, com, false);
+ if (rc == 0)
+ rc = lfsck_set_param(env, lfsck, start, true);
+
if (rc != 0)
return rc;
}
down_write(&com->lc_sem);
com->lc_new_checked++;
if (rc < 0)
- lo->ll_objs_failed_phase1++;
+ lfsck_layout_record_failure(env, lfsck, lo);
up_write(&com->lc_sem);
if (cobj != NULL && !IS_ERR(cobj))
buf->lb_len = rc;
lmm = buf->lb_buf;
rc = lfsck_layout_verify_header(lmm);
+ /* If the LOV EA crashed, then it is possible to be rebuilt later
+ * when handle orphan OST-objects. */
if (rc != 0)
GOTO(out, rc);
down_write(&com->lc_sem);
com->lc_new_checked++;
if (rc < 0)
- lo->ll_objs_failed_phase1++;
+ lfsck_layout_record_failure(env, lfsck, lo);
up_write(&com->lc_sem);
}
buf->lb_len = buflen;
const struct dt_it_ops *iops;
cfs_duration_t duration = cfs_time_current() -
lfsck->li_time_last_checkpoint;
- __u64 checked = lo->ll_objs_checked_phase1 + com->lc_new_checked;
+ __u64 checked = lo->ll_objs_checked_phase1 +
+ com->lc_new_checked;
__u64 speed = checked;
__u64 new_checked = com->lc_new_checked * HZ;
__u32 rtime = lo->ll_run_time_phase1 +
} else if (lo->ll_status == LS_SCANNING_PHASE2) {
cfs_duration_t duration = cfs_time_current() -
lfsck->li_time_last_checkpoint;
- __u64 checked = lo->ll_objs_checked_phase1 + com->lc_new_checked;
- __u64 speed = checked;
+ __u64 checked = lo->ll_objs_checked_phase2 +
+ com->lc_new_checked;
+ __u64 speed1 = lo->ll_objs_checked_phase1;
+ __u64 speed2 = checked;
__u64 new_checked = com->lc_new_checked * HZ;
- __u32 rtime = lo->ll_run_time_phase1 +
+ __u32 rtime = lo->ll_run_time_phase2 +
cfs_duration_sec(duration + HALF_SEC);
if (duration != 0)
do_div(new_checked, duration);
+ if (lo->ll_run_time_phase1 != 0)
+ do_div(speed1, lo->ll_run_time_phase1);
if (rtime != 0)
- do_div(speed, rtime);
+ do_div(speed2, rtime);
rc = snprintf(buf, len,
"checked_phase1: "LPU64"\n"
"checked_phase2: "LPU64"\n"
"run_time_phase1: %u seconds\n"
"run_time_phase2: %u seconds\n"
"average_speed_phase1: "LPU64" items/sec\n"
- "average_speed_phase2: N/A\n"
- "real-time_speed_phase1: "LPU64" items/sec\n"
- "real-time_speed_phase2: N/A\n"
+ "average_speed_phase2: "LPU64" items/sec\n"
+ "real-time_speed_phase1: N/A\n"
+ "real-time_speed_phase2: "LPU64" items/sec\n"
"current_position: "DFID"\n",
+ lo->ll_objs_checked_phase1,
checked,
- lo->ll_objs_checked_phase2,
+ lo->ll_run_time_phase1,
rtime,
- lo->ll_run_time_phase2,
- speed,
+ speed1,
+ speed2,
new_checked,
PFID(&com->lc_fid_latest_scanned_phase2));
if (rc <= 0)
git://git.whamcloud.com / fs / lustre-release.git / blobdiff