}
static inline void lod_adjust_stripe_info(struct lod_layout_component *comp,
- struct lov_desc *desc)
+ struct lov_desc *desc,
+ int append_stripes)
{
if (comp->llc_pattern != LOV_PATTERN_MDT) {
- if (!comp->llc_stripe_count)
+ if (append_stripes) {
+ comp->llc_stripe_count = append_stripes;
+ } else if (!comp->llc_stripe_count) {
comp->llc_stripe_count =
desc->ld_default_stripe_count;
+ }
}
if (comp->llc_stripe_size <= 0)
comp->llc_stripe_size = desc->ld_default_stripe_size;
buf->lb_len = info->lti_ea_store_size;
lmm = info->lti_ea_store;
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 =
&lcm->lcm_entries[0];
buf->lb_buf = info->lti_ea_store;
buf->lb_len = info->lti_ea_store_size;
lcm = buf->lb_buf;
- if (le32_to_cpu(lcm->lcm_magic) != LOV_MAGIC_COMP_V1)
+ if (le32_to_cpu(lcm->lcm_magic) != LOV_MAGIC_COMP_V1 &&
+ le32_to_cpu(lcm->lcm_magic) != LOV_MAGIC_SEL)
RETURN(-EINVAL);
le32_add_cpu(&lcm->lcm_layout_gen, 1);
RETURN(rc = rc1 != 0 ? rc1 : rc);
}
+ if ((rc > 0) && buf->lb_buf && strcmp(name, XATTR_NAME_LOV) == 0) {
+ struct lov_comp_md_v1 *lcm = buf->lb_buf;
+
+ if (lcm->lcm_magic == cpu_to_le32(LOV_MAGIC_SEL))
+ lcm->lcm_magic = cpu_to_le32(LOV_MAGIC_COMP_V1);
+ }
+
if (rc != -ENODATA || !S_ISDIR(dt->do_lu.lo_header->loh_attr & S_IFMT))
RETURN(rc);
if (is_root && strcmp(XATTR_NAME_LOV, name) == 0) {
struct lov_user_md *lum = buf->lb_buf;
- struct lov_desc *desc = &dev->lod_desc;
+ struct lov_desc *desc = &dev->lod_ost_descs.ltd_lov_desc;
if (buf->lb_buf == NULL) {
rc = sizeof(*lum);
continue;
tgt_dt = tgt->ltd_tgt;
- rc = dt_statfs(env, tgt_dt, &info->lti_osfs, NULL);
+ rc = dt_statfs(env, tgt_dt, &info->lti_osfs);
if (rc) {
/* this OSP doesn't feel well */
rc = 0;
else if (lod_comp_inited(entry))
return entry->llc_stripe_count;
else if ((__u16)-1 == entry->llc_stripe_count)
- return lod->lod_desc.ld_tgt_count;
+ return lod->lod_ost_count;
else
return lod_get_stripe_count(lod, lo,
entry->llc_stripe_count, false);
{
struct lod_thread_info *info = lod_env_info(env);
struct lod_layout_component *comp_array, *lod_comp, *old_array;
- struct lod_device *d = lu2lod_dev(dt->do_lu.lo_dev);
+ struct lod_device *d = lu2lod_dev(dt->do_lu.lo_dev);
struct dt_object *next = dt_object_child(dt);
- struct lov_desc *desc = &d->lod_desc;
- struct lod_object *lo = lod_dt_obj(dt);
- struct lov_user_md_v3 *v3;
- struct lov_comp_md_v1 *comp_v1 = buf->lb_buf;
- __u32 magic;
- int i, rc, array_cnt, old_array_cnt;
+ struct lov_desc *desc = &d->lod_ost_descs.ltd_lov_desc;
+ struct lod_object *lo = lod_dt_obj(dt);
+ struct lov_user_md_v3 *v3;
+ struct lov_comp_md_v1 *comp_v1 = buf->lb_buf;
+ __u32 magic;
+ int i, rc, array_cnt, old_array_cnt;
ENTRY;
LASSERT(lo->ldo_is_composite);
lod_comp->llc_stripe_count = v1->lmm_stripe_count;
lod_comp->llc_stripe_size = v1->lmm_stripe_size;
- lod_adjust_stripe_info(lod_comp, desc);
+ lod_adjust_stripe_info(lod_comp, desc, 0);
if (v1->lmm_magic == LOV_USER_MAGIC_V3) {
v3 = (struct lov_user_md_v3 *) v1;
}
/**
+ * lod_last_non_stale_mirror() - Check if a mirror is the last non-stale mirror.
+ * @mirror_id: Mirror id to be checked.
+ * @lo: LOD object.
+ *
+ * This function checks if a mirror with specified @mirror_id is the last
+ * non-stale mirror of a LOD object @lo.
+ *
+ * Return: true or false.
+ */
+static inline
+bool lod_last_non_stale_mirror(__u16 mirror_id, struct lod_object *lo)
+{
+ struct lod_layout_component *lod_comp;
+ bool has_stale_flag;
+ int i;
+
+ for (i = 0; i < lo->ldo_mirror_count; i++) {
+ if (lo->ldo_mirrors[i].lme_id == mirror_id ||
+ lo->ldo_mirrors[i].lme_stale)
+ continue;
+
+ has_stale_flag = false;
+ lod_foreach_mirror_comp(lod_comp, lo, i) {
+ if (lod_comp->llc_flags & LCME_FL_STALE) {
+ has_stale_flag = true;
+ break;
+ }
+ }
+ if (!has_stale_flag)
+ return false;
+ }
+
+ return true;
+}
+
+/**
* Declare component set. The xattr is name XATTR_LUSTRE_LOV.set.$field,
* the '$field' can only be 'flags' now. The xattr value is binary
* lov_comp_md_v1 which contains the component ID(s) and the value of
__u32 id = comp_v1->lcm_entries[i].lcme_id;
__u32 flags = comp_v1->lcm_entries[i].lcme_flags;
__u32 mirror_flag = flags & LCME_MIRROR_FLAGS;
+ __u16 mirror_id = mirror_id_of(id);
bool neg = flags & LCME_FL_NEG;
if (flags & LCME_FL_INIT) {
/* lfs only put one flag in each entry */
if ((flags && id != lod_comp->llc_id) ||
- (mirror_flag && mirror_id_of(id) !=
+ (mirror_flag && mirror_id !=
mirror_id_of(lod_comp->llc_id)))
continue;
if (mirror_flag)
lod_comp->llc_flags &= ~mirror_flag;
} else {
- if (flags)
+ if (flags) {
+ if ((flags & LCME_FL_STALE) &&
+ lod_last_non_stale_mirror(mirror_id,
+ lo))
+ RETURN(-EUCLEAN);
lod_comp->llc_flags |= flags;
+ }
if (mirror_flag) {
lod_comp->llc_flags |= mirror_flag;
if (mirror_flag & LCME_FL_NOSYNC)
struct lov_comp_md_v1 *cur_lcm;
struct lov_comp_md_v1 *merge_lcm;
struct lov_comp_md_entry_v1 *lcme;
+ struct lov_mds_md_v1 *lmm;
size_t size = 0;
size_t offset;
__u16 cur_entry_count;
__u16 mirror_id = 0;
__u32 mirror_count;
int rc, i;
+ bool merge_has_dom;
+
ENTRY;
merge_lcm = mbuf->lb_buf;
rc = lod_layout_convert(info);
break;
case LOV_MAGIC_COMP_V1:
+ case LOV_MAGIC_SEL:
rc = 0;
break;
default:
}
mirror_id = mirror_id_of(id) + 1;
+
+ /* check if first entry in new layout is DOM */
+ lmm = (struct lov_mds_md_v1 *)((char *)merge_lcm +
+ merge_lcm->lcm_entries[0].lcme_offset);
+ merge_has_dom = lov_pattern(le32_to_cpu(lmm->lmm_pattern)) ==
+ LOV_PATTERN_MDT;
+
for (i = 0; i < merge_entry_count; i++) {
struct lov_comp_md_entry_v1 *merge_lcme;
*lcme = *merge_lcme;
lcme->lcme_offset = cpu_to_le32(offset);
+ if (merge_has_dom && i == 0)
+ lcme->lcme_flags |= cpu_to_le32(LCME_FL_STALE);
id = pflr_id(mirror_id, i + 1);
lcme->lcme_id = cpu_to_le32(id);
pool_name);
break;
case LOV_USER_MAGIC_COMP_V1:
+ {
+ struct lov_comp_md_v1 *lcm = (struct lov_comp_md_v1 *)lum;
+ struct lov_comp_md_entry_v1 *lcme;
+ int i, comp_cnt;
+
+ comp_cnt = le16_to_cpu(lcm->lcm_entry_count);
+ for (i = 0; i < comp_cnt; i++) {
+ lcme = &lcm->lcm_entries[i];
+ if (lcme->lcme_flags & cpu_to_le32(LCME_FL_EXTENSION)) {
+ lcm->lcm_magic = cpu_to_le32(LOV_MAGIC_SEL);
+ break;
+ }
+ }
+
is_del = false;
break;
+ }
default:
CERROR("Invalid magic %x\n", lum->lmm_magic);
RETURN(-EINVAL);
/* if it's source stripe of migrating directory, don't create */
if (!((lo->ldo_dir_hash_type & LMV_HASH_FLAG_MIGRATION) &&
i >= lo->ldo_dir_migrate_offset)) {
- dt_write_lock(env, dto, MOR_TGT_CHILD);
+ dt_write_lock(env, dto, DT_TGT_CHILD);
rc = lod_sub_create(env, dto, attr, NULL, dof, th);
if (rc != 0) {
dt_write_unlock(env, dto);
RETURN(rc);
}
+static __u32 lod_gen_component_id(struct lod_object *lo,
+ int mirror_id, int comp_idx);
+
+/**
+ * Repeat an existing component
+ *
+ * Creates a new layout by replicating an existing component. Uses striping
+ * policy from previous component as a template for the striping for the new
+ * new component.
+ *
+ * New component starts with zero length, will be extended (or removed) before
+ * returning layout to client.
+ *
+ * NB: Reallocates layout components array (lo->ldo_comp_entries), invalidating
+ * any pre-existing pointers to components. Handle with care.
+ *
+ * \param[in] env execution environment for this thread
+ * \param[in,out] lo object to update the layout of
+ * \param[in] index index of component to copy
+ *
+ * \retval 0 on success
+ * \retval negative errno on error
+ */
+static int lod_layout_repeat_comp(const struct lu_env *env,
+ struct lod_object *lo, int index)
+{
+ struct lod_layout_component *lod_comp;
+ struct lod_layout_component *new_comp = NULL;
+ struct lod_layout_component *comp_array;
+ int rc = 0, i, new_cnt = lo->ldo_comp_cnt + 1;
+ __u16 mirror_id;
+ int offset = 0;
+ ENTRY;
+
+ lod_comp = &lo->ldo_comp_entries[index];
+ LASSERT(lod_comp_inited(lod_comp) && lod_comp->llc_id != LCME_ID_INVAL);
+
+ CDEBUG(D_LAYOUT, "repeating component %d\n", index);
+
+ OBD_ALLOC(comp_array, sizeof(*comp_array) * new_cnt);
+ if (comp_array == NULL)
+ GOTO(out, rc = -ENOMEM);
+
+ for (i = 0; i < lo->ldo_comp_cnt; i++) {
+ memcpy(&comp_array[i + offset], &lo->ldo_comp_entries[i],
+ sizeof(*comp_array));
+
+ /* Duplicate this component in to the next slot */
+ if (i == index) {
+ new_comp = &comp_array[i + 1];
+ memcpy(&comp_array[i + 1], &lo->ldo_comp_entries[i],
+ sizeof(*comp_array));
+ /* We must now skip this new component when copying */
+ offset = 1;
+ }
+ }
+
+ /* Set up copied component */
+ new_comp->llc_flags &= ~LCME_FL_INIT;
+ new_comp->llc_stripe = NULL;
+ new_comp->llc_stripes_allocated = 0;
+ new_comp->llc_stripe_offset = LOV_OFFSET_DEFAULT;
+ /* for uninstantiated components, layout gen stores default stripe
+ * offset */
+ new_comp->llc_layout_gen = lod_comp->llc_stripe_offset;
+ /* This makes the repeated component zero-length, placed at the end of
+ * the preceding component */
+ new_comp->llc_extent.e_start = new_comp->llc_extent.e_end;
+ new_comp->llc_timestamp = lod_comp->llc_timestamp;
+ new_comp->llc_pool = NULL;
+
+ rc = lod_set_pool(&new_comp->llc_pool, lod_comp->llc_pool);
+ if (rc)
+ GOTO(out, rc);
+
+ if (new_comp->llc_ostlist.op_array) {
+ __u32 *op_array = NULL;
+
+ OBD_ALLOC(op_array, new_comp->llc_ostlist.op_size);
+ if (!op_array)
+ GOTO(out, rc = -ENOMEM);
+ memcpy(op_array, &new_comp->llc_ostlist.op_array,
+ new_comp->llc_ostlist.op_size);
+ new_comp->llc_ostlist.op_array = op_array;
+ }
+
+ OBD_FREE(lo->ldo_comp_entries,
+ sizeof(*comp_array) * lo->ldo_comp_cnt);
+ lo->ldo_comp_entries = comp_array;
+ lo->ldo_comp_cnt = new_cnt;
+
+ /* Generate an id for the new component */
+ mirror_id = mirror_id_of(new_comp->llc_id);
+ new_comp->llc_id = LCME_ID_INVAL;
+ new_comp->llc_id = lod_gen_component_id(lo, mirror_id, index + 1);
+ if (new_comp->llc_id == LCME_ID_INVAL)
+ GOTO(out, rc = -ERANGE);
+
+ EXIT;
+out:
+ if (rc)
+ OBD_FREE(comp_array, sizeof(*comp_array) * new_cnt);
+
+ return rc;
+}
+
static int lod_layout_data_init(struct lod_thread_info *info, __u32 comp_cnt)
{
ENTRY;
ENTRY;
+ LASSERT(lo->ldo_is_composite);
+ LASSERT(lo->ldo_comp_cnt > 0 && lo->ldo_comp_entries != NULL);
+
rc = lod_layout_data_init(info, lo->ldo_comp_cnt);
if (rc)
RETURN(rc);
struct lu_attr *attr = &lod_env_info(env)->lti_attr;
int rc;
- LASSERT(lo->ldo_is_composite);
LASSERT(lo->ldo_mirror_count == 1);
- LASSERT(lo->ldo_comp_cnt > 0 && lo->ldo_comp_entries != NULL);
rc = lod_layout_del_prep_layout(env, lo, th);
if (rc < 0)
static int lod_get_default_lov_striping(const struct lu_env *env,
struct lod_object *lo,
- struct lod_default_striping *lds);
+ struct lod_default_striping *lds,
+ struct dt_allocation_hint *ah);
/**
* Implementation of dt_object_operations::do_xattr_set.
*
bool is_del;
/* get existing striping config */
- rc = lod_get_default_lov_striping(env, lod_dt_obj(dt), lds);
+ rc = lod_get_default_lov_striping(env, lod_dt_obj(dt), lds,
+ NULL);
if (rc)
RETURN(rc);
if (!S_ISDIR(dt->do_lu.lo_header->loh_attr))
RETURN(0);
- /* set xattr to each stripes, if needed */
+ /* NB: don't delete stripe LMV, because when we do this, normally we
+ * will remove stripes, besides, if directory LMV is corrupt, this will
+ * prevent deleting its LMV and fixing it (via LFSCK).
+ */
+ if (!strcmp(name, XATTR_NAME_LMV))
+ RETURN(0);
+
rc = lod_striping_load(env, lo);
if (rc != 0)
RETURN(rc);
if (rc != 0 || !S_ISDIR(dt->do_lu.lo_header->loh_attr))
RETURN(rc);
+ if (!strcmp(name, XATTR_NAME_LMV))
+ RETURN(0);
+
if (lo->ldo_dir_stripe_count == 0)
RETURN(0);
*/
static int lod_get_default_lov_striping(const struct lu_env *env,
struct lod_object *lo,
- struct lod_default_striping *lds)
+ struct lod_default_striping *lds,
+ struct dt_allocation_hint *ah)
{
struct lod_thread_info *info = lod_env_info(env);
struct lov_user_md_v1 *v1 = NULL;
lustre_swab_lov_user_md_v3(v3);
lustre_swab_lov_user_md_objects(v3->lmm_objects,
v3->lmm_stripe_count);
- } else if (v1->lmm_magic == __swab32(LOV_USER_MAGIC_COMP_V1)) {
+ } else if (v1->lmm_magic == __swab32(LOV_USER_MAGIC_COMP_V1) ||
+ v1->lmm_magic == __swab32(LOV_USER_MAGIC_SEL)) {
comp_v1 = (struct lov_comp_md_v1 *)v1;
lustre_swab_lov_comp_md_v1(comp_v1);
}
if (v1->lmm_magic != LOV_MAGIC_V3 && v1->lmm_magic != LOV_MAGIC_V1 &&
v1->lmm_magic != LOV_MAGIC_COMP_V1 &&
+ v1->lmm_magic != LOV_MAGIC_SEL &&
v1->lmm_magic != LOV_USER_MAGIC_SPECIFIC)
RETURN(-ENOTSUPP);
- if (v1->lmm_magic == LOV_MAGIC_COMP_V1) {
+ if ((v1->lmm_magic == LOV_MAGIC_COMP_V1 ||
+ v1->lmm_magic == LOV_MAGIC_SEL) &&
+ !(ah && ah->dah_append_stripes)) {
comp_v1 = (struct lov_comp_md_v1 *)v1;
comp_cnt = comp_v1->lcm_entry_count;
if (comp_cnt == 0)
RETURN(-EINVAL);
}
- CDEBUG(D_LAYOUT, DFID" stripe_count=%d stripe_size=%d "
- "stripe_offset=%d\n",
+ CDEBUG(D_LAYOUT, DFID" stripe_count=%d stripe_size=%d stripe_offset=%d append_stripes=%d\n",
PFID(lu_object_fid(&lo->ldo_obj.do_lu)),
(int)v1->lmm_stripe_count, (int)v1->lmm_stripe_size,
- (int)v1->lmm_stripe_offset);
+ (int)v1->lmm_stripe_offset,
+ ah ? ah->dah_append_stripes : 0);
- lod_comp->llc_stripe_count = v1->lmm_stripe_count;
+ if (ah && ah->dah_append_stripes)
+ lod_comp->llc_stripe_count = ah->dah_append_stripes;
+ else
+ lod_comp->llc_stripe_count = v1->lmm_stripe_count;
lod_comp->llc_stripe_size = v1->lmm_stripe_size;
lod_comp->llc_stripe_offset = v1->lmm_stripe_offset;
lod_comp->llc_pattern = v1->lmm_pattern;
pool = NULL;
- if (v1->lmm_magic == LOV_USER_MAGIC_V3) {
+ if (ah && ah->dah_append_pool && ah->dah_append_pool[0]) {
+ pool = ah->dah_append_pool;
+ } else if (v1->lmm_magic == LOV_USER_MAGIC_V3) {
/* XXX: sanity check here */
v3 = (struct lov_user_md_v3 *) v1;
if (v3->lmm_pool_name[0] != '\0')
{
int rc, rc1;
- rc = lod_get_default_lov_striping(env, lo, lds);
+ rc = lod_get_default_lov_striping(env, lo, lds, NULL);
rc1 = lod_get_default_lmv_striping(env, lo, lds);
if (rc == 0 && rc1 < 0)
rc = rc1;
umode_t mode)
{
struct lod_device *d = lu2lod_dev(lo->ldo_obj.do_lu.lo_dev);
- struct lov_desc *desc = &d->lod_desc;
int i, rc;
if (lds->lds_def_striping_set && S_ISREG(mode)) {
+ struct lov_desc *desc = &d->lod_ost_descs.ltd_lov_desc;
+
rc = lod_alloc_comp_entries(lo, lds->lds_def_mirror_cnt,
lds->lds_def_comp_cnt);
if (rc != 0)
if (!lo->ldo_is_composite)
continue;
- lod_adjust_stripe_info(obj_comp, desc);
+ lod_adjust_stripe_info(obj_comp, desc, 0);
}
} else if (lds->lds_dir_def_striping_set && S_ISDIR(mode)) {
if (lo->ldo_dir_stripe_count == 0)
}
}
-static inline bool lod_need_inherit_more(struct lod_object *lo, bool from_root)
+static inline bool lod_need_inherit_more(struct lod_object *lo, bool from_root,
+ char *append_pool)
{
struct lod_layout_component *lod_comp;
lod_comp->llc_stripe_offset == LOV_OFFSET_DEFAULT))
return true;
+ if (append_pool && append_pool[0])
+ return true;
+
return false;
}
LASSERT(child);
+ if (ah->dah_append_stripes == -1)
+ ah->dah_append_stripes =
+ d->lod_ost_descs.ltd_lov_desc.ld_tgt_count;
+
if (likely(parent)) {
nextp = dt_object_child(parent);
lp = lod_dt_obj(parent);
* If parent object is not root directory,
* then get default striping from parent object.
*/
- if (likely(lp != NULL) && !fid_is_root(lod_object_fid(lp)))
+ if (likely(lp != NULL)) {
lod_get_default_striping(env, lp, lds);
- /* set child default striping info, default value is NULL */
- if (lds->lds_def_striping_set || lds->lds_dir_def_striping_set)
- lc->ldo_def_striping = lds;
+ /* inherit default striping except ROOT */
+ if ((lds->lds_def_striping_set ||
+ lds->lds_dir_def_striping_set) &&
+ !fid_is_root(lod_object_fid(lp)))
+ lc->ldo_def_striping = lds;
+ }
/* It should always honour the specified stripes */
/* Note: old client (< 2.7)might also do lfs mkdir, whose EA
* Try from the parent first.
*/
if (likely(lp != NULL)) {
- rc = lod_get_default_lov_striping(env, lp, lds);
+ rc = lod_get_default_lov_striping(env, lp, lds, ah);
if (rc == 0)
lod_striping_from_default(lc, lds, child_mode);
}
* - parent has plain(v1/v3) default layout, and some attributes
* are not specified in the default layout;
*/
- if (d->lod_md_root != NULL && lod_need_inherit_more(lc, true)) {
- rc = lod_get_default_lov_striping(env, d->lod_md_root, lds);
+ if (d->lod_md_root != NULL &&
+ lod_need_inherit_more(lc, true, ah->dah_append_pool)) {
+ rc = lod_get_default_lov_striping(env, d->lod_md_root, lds,
+ ah);
if (rc)
goto out;
if (lc->ldo_comp_cnt == 0) {
* fs default striping may not be explicitly set, or historically set
* in config log, use them.
*/
- if (lod_need_inherit_more(lc, false)) {
+ if (lod_need_inherit_more(lc, false, ah->dah_append_pool)) {
if (lc->ldo_comp_cnt == 0) {
rc = lod_alloc_comp_entries(lc, 0, 1);
if (rc)
}
LASSERT(!lc->ldo_is_composite);
lod_comp = &lc->ldo_comp_entries[0];
- desc = &d->lod_desc;
- lod_adjust_stripe_info(lod_comp, desc);
+ desc = &d->lod_ost_descs.ltd_lov_desc;
+ lod_adjust_stripe_info(lod_comp, desc, ah->dah_append_stripes);
+ if (ah->dah_append_pool && ah->dah_append_pool[0])
+ lod_obj_set_pool(lc, 0, ah->dah_append_pool);
}
EXIT;
} else if (lo->ldo_dir_stripe_offset !=
ss->ss_node_id) {
struct lod_device *lod;
- struct lod_tgt_descs *ltd;
- struct lod_tgt_desc *tgt = NULL;
+ struct lu_tgt_desc *mdt = NULL;
bool found_mdt = false;
- int i;
lod = lu2lod_dev(lo->ldo_obj.do_lu.lo_dev);
- ltd = &lod->lod_mdt_descs;
- cfs_foreach_bit(ltd->ltd_tgt_bitmap, i) {
- tgt = LTD_TGT(ltd, i);
- if (tgt->ltd_index ==
+ lod_foreach_mdt(lod, mdt) {
+ if (mdt->ltd_index ==
lo->ldo_dir_stripe_offset) {
found_mdt = true;
break;
if (!OBD_FAIL_CHECK(OBD_FAIL_LFSCK_LOST_SPEOBJ) ||
i == cfs_fail_val) {
- dt_write_lock(env, stripe, MOR_TGT_CHILD);
+ dt_write_lock(env, stripe, DT_TGT_CHILD);
rc = lod_sub_ref_del(env, stripe, th);
dt_write_unlock(env, stripe);
if (rc != 0)
break;
}
- rc = dt_statfs(env, ost->ltd_ost, sfs, &info);
+ rc = dt_statfs_info(env, ost->ltd_tgt, sfs, &info);
if (rc) {
CDEBUG(D_LAYOUT, "statfs failed for ost %d, error %d\n",
index, rc);
return new_end;
}
+/* As lod_sel_handler() could be re-entered for the same component several
+ * times, this is the data for the next call. Fields could be changed to
+ * component indexes when needed, (e.g. if there is no need to instantiate
+ * all the previous components up to the current position) to tell the caller
+ * where to start over from. */
+struct sel_data {
+ int sd_force;
+ int sd_repeat;
+};
+
/**
* Process extent updates for a particular layout component
*
* extension space component, move the start of the next component down
* accordingly, then notify the caller to restart processing w/the new
* layout.
- * b. If there is no following component, we extend the current component
- * regardless.
+ * b. If there is no following component, we try repeating the current
+ * component, creating a new component using the current one as a
+ * template (keeping its stripe properties but not specific striping),
+ * and try assigning striping for this component. If there is sufficient
+ * free space on the OSTs chosen for this component, it is instantiated
+ * and i/o continues there.
+ *
+ * If there is not sufficient space on the new OSTs, we remove this new
+ * component & extend the current component.
*
* Note further that uninited components followed by extension space can be zero
* length meaning that we will try to extend them before initializing them, and
struct lod_object *lo,
struct lu_extent *extent,
struct thandle *th, int *max_comp,
- int index, int write, int *force)
+ int index, int write,
+ struct sel_data *sd)
{
struct lod_device *d = lu2lod_dev(lo->ldo_obj.do_lu.lo_dev);
struct lod_thread_info *info = lod_env_info(env);
struct lod_layout_component *next = NULL;
__u64 extension_size;
__u64 new_end = 0;
+ bool repeated;
int change = 0;
int rc = 0;
ENTRY;
info->lti_count = 1;
info->lti_comp_idx[0] = index - 1;
rc = lod_declare_instantiate_components(env, lo, th);
- /* ENOSPC tells us we can't use this component, so it's the
- * same as if check_extension failed. But if there is no next,
- * we have no fall back if we failed to stripe this, and we
- * should return the error. */
- if (rc == -ENOSPC && next)
+ /* ENOSPC tells us we can't use this component. If there is
+ * a next or we are repeating, we either spill over (next) or
+ * extend the original comp (repeat). Otherwise, return the
+ * error to the user. */
+ if (rc == -ENOSPC && (next || sd->sd_repeat))
rc = 1;
if (rc < 0)
RETURN(rc);
}
- if (*force == 0 && rc == 0)
+ if (sd->sd_force == 0 && rc == 0)
rc = !lod_sel_osts_allowed(env, lo, index - 1,
extension_size, extent,
&lod_comp->llc_extent, write);
- *force = 0;
+
+ repeated = !!(sd->sd_repeat);
+ sd->sd_repeat = 0;
+ sd->sd_force = 0;
/* Extend previous component */
if (rc == 0) {
change--;
}
lod_sel_adjust_extents(env, lo, *max_comp, index);
+ } else if (lod_comp_inited(prev)) {
+ /* If there is no next, and the previous component is
+ * INIT'ed, try repeating the previous component. */
+ LASSERT(repeated == 0);
+ rc = lod_layout_repeat_comp(env, lo, index - 1);
+ if (rc < 0)
+ RETURN(rc);
+ change++;
+ /* The previous component is a repeated component.
+ * Record this so we don't keep trying to repeat it. */
+ sd->sd_repeat = 1;
} else {
- *force = 1;
+ /* If the previous component is not INIT'ed, this may
+ * be a component we have just instantiated but failed
+ * to extend. Or even a repeated component we failed
+ * to prepare a striping for. Do not repeat but instead
+ * remove the repeated component & force the extention
+ * of the original one */
+ sd->sd_force = 1;
+ if (repeated) {
+ prev->llc_id = LCME_ID_INVAL;
+ change--;
+ }
}
}
struct lod_thread_info *info = lod_env_info(env);
struct lod_layout_component *lod_comp;
bool layout_changed = false;
+ struct sel_data sd = { 0 };
int start_index;
int i = 0;
int max_comp = 0;
int rc = 0, rc2;
int change = 0;
- int force = 0;
ENTRY;
/* This makes us work on the components of the chosen mirror */
if (lod_comp->llc_flags & LCME_FL_EXTENSION) {
layout_changed = true;
rc = lod_sel_handler(env, lo, extent, th, &max_comp,
- i, write, &force);
+ i, write, &sd);
if (rc < 0)
GOTO(out, rc);
}
}
- /* We may have removed components. If so, we must update the start &
- * ends of all the mirrors after the current one, and the end of the
- * current mirror.
- */
+ /* We may have added or removed components. If so, we must update the
+ * start & ends of all the mirrors after the current one, and the end
+ * of the current mirror. */
change = max_comp - 1 - lo->ldo_mirrors[pick].lme_end;
if (change) {
lo->ldo_mirrors[pick].lme_end += change;
ENTRY;
rc = lod_fld_lookup(env, lod, lu_object_fid(lo), &idx, &type);
- if (rc != 0) {
- /* Note: Sometimes, it will Return EAGAIN here, see
- * ptrlpc_import_delay_req(), which might confuse
- * lu_object_find_at() and make it wait there incorrectly.
- * so we convert it to EIO here.*/
- if (rc == -EAGAIN)
- rc = -EIO;
-
+ if (rc != 0)
RETURN(rc);
- }
if (type == LU_SEQ_RANGE_MDT &&
idx == lu_site2seq(lo->lo_dev->ld_site)->ss_node_id) {