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);
rc = lod_layout_convert(info);
break;
case LOV_MAGIC_COMP_V1:
+ case LOV_MAGIC_SEL:
rc = 0;
break;
default:
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 (LMVEA_DELETE_VALUES((le32_to_cpu(lum->lum_stripe_count)),
le32_to_cpu(lum->lum_stripe_offset)) &&
le32_to_cpu(lum->lum_magic) == LMV_USER_MAGIC &&
- le32_to_cpu(lum->lum_hash_type) != LMV_HASH_TYPE_SPACE) {
+ !(le32_to_cpu(lum->lum_hash_type) & LMV_HASH_FLAG_SPACE)) {
rc = lod_xattr_del_internal(env, dt, name, th);
if (rc == -ENODATA)
rc = 0;
/* 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);
+
/**
- * Delete layout component(s)
+ * 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] dt object
- * \param[in] th transaction handle
+ * \param[in,out] lo object to update the layout of
+ * \param[in] index index of component to copy
*
* \retval 0 on success
- * \retval negative error number on failure
+ * \retval negative errno on error
*/
-static int lod_layout_del(const struct lu_env *env, struct dt_object *dt,
- struct thandle *th)
+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_object *lo = lod_dt_obj(dt);
- struct dt_object *next = dt_object_child(dt);
- struct lu_attr *attr = &lod_env_info(env)->lti_attr;
- int rc, i, j, left;
+ 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;
+
+ /* clear memory region that will be used for layout change */
+ memset(&info->lti_layout_attr, 0, sizeof(struct lu_attr));
+ info->lti_count = 0;
+
+ if (info->lti_comp_size >= comp_cnt)
+ RETURN(0);
+
+ if (info->lti_comp_size > 0) {
+ OBD_FREE(info->lti_comp_idx,
+ info->lti_comp_size * sizeof(__u32));
+ info->lti_comp_size = 0;
+ }
+
+ OBD_ALLOC(info->lti_comp_idx, comp_cnt * sizeof(__u32));
+ if (!info->lti_comp_idx)
+ RETURN(-ENOMEM);
+
+ info->lti_comp_size = comp_cnt;
+ RETURN(0);
+}
+
+/**
+ * Prepare new layout minus deleted components
+ *
+ * Removes components marked for deletion (LCME_ID_INVAL) by copying to a new
+ * layout and skipping those components. Removes stripe objects if any exist.
+ *
+ * NB:
+ * Reallocates layout components array (lo->ldo_comp_entries), invalidating
+ * any pre-existing pointers to components.
+ *
+ * Caller is responsible for updating mirror end (ldo_mirror[].lme_end).
+ *
+ * \param[in] env execution environment for this thread
+ * \param[in,out] lo object to update the layout of
+ * \param[in] th transaction handle for this operation
+ *
+ * \retval # of components deleted
+ * \retval negative errno on error
+ */
+static int lod_layout_del_prep_layout(const struct lu_env *env,
+ struct lod_object *lo,
+ struct thandle *th)
+{
+ struct lod_layout_component *lod_comp;
+ struct lod_thread_info *info = lod_env_info(env);
+ int rc = 0, i, j, deleted = 0;
+
+ ENTRY;
LASSERT(lo->ldo_is_composite);
LASSERT(lo->ldo_comp_cnt > 0 && lo->ldo_comp_entries != NULL);
- left = lo->ldo_comp_cnt;
- for (i = (lo->ldo_comp_cnt - 1); i >= 0; i--) {
+ rc = lod_layout_data_init(info, lo->ldo_comp_cnt);
+ if (rc)
+ RETURN(rc);
+
+ for (i = 0; i < lo->ldo_comp_cnt; i++) {
lod_comp = &lo->ldo_comp_entries[i];
- if (lod_comp->llc_id != LCME_ID_INVAL)
- break;
- left--;
+ if (lod_comp->llc_id != LCME_ID_INVAL) {
+ /* Build array of things to keep */
+ info->lti_comp_idx[info->lti_count++] = i;
+ continue;
+ }
- /* Not instantiated component */
+ lod_obj_set_pool(lo, i, NULL);
+ if (lod_comp->llc_ostlist.op_array) {
+ OBD_FREE(lod_comp->llc_ostlist.op_array,
+ lod_comp->llc_ostlist.op_size);
+ lod_comp->llc_ostlist.op_array = NULL;
+ lod_comp->llc_ostlist.op_size = 0;
+ }
+
+ deleted++;
+ CDEBUG(D_LAYOUT, "deleting comp %d, left %d\n", i,
+ lo->ldo_comp_cnt - deleted);
+
+ /* No striping info for this component */
if (lod_comp->llc_stripe == NULL)
continue;
if (obj == NULL)
continue;
- rc = lod_sub_destroy(env, obj, th);
- if (rc)
- GOTO(out, rc);
+
+ /* components which are not init have no sub objects
+ * to destroy */
+ if (lod_comp_inited(lod_comp)) {
+ rc = lod_sub_destroy(env, obj, th);
+ if (rc)
+ GOTO(out, rc);
+ }
lu_object_put(env, &obj->do_lu);
lod_comp->llc_stripe[j] = NULL;
sizeof(__u32) * lod_comp->llc_stripes_allocated);
lod_comp->llc_ost_indices = NULL;
lod_comp->llc_stripes_allocated = 0;
- lod_obj_set_pool(lo, i, NULL);
- if (lod_comp->llc_ostlist.op_array) {
- OBD_FREE(lod_comp->llc_ostlist.op_array,
- lod_comp->llc_ostlist.op_size);
- lod_comp->llc_ostlist.op_array = NULL;
- lod_comp->llc_ostlist.op_size = 0;
- }
}
- LASSERTF(left >= 0 && left < lo->ldo_comp_cnt, "left = %d\n", left);
- if (left > 0) {
- struct lod_layout_component *comp_array;
+ /* info->lti_count has the amount of left components */
+ LASSERTF(info->lti_count >= 0 && info->lti_count < lo->ldo_comp_cnt,
+ "left = %d, lo->ldo_comp_cnt %d\n", (int)info->lti_count,
+ (int)lo->ldo_comp_cnt);
+
+ if (info->lti_count > 0) {
+ struct lod_layout_component *comp_array;
- OBD_ALLOC(comp_array, sizeof(*comp_array) * left);
+ OBD_ALLOC(comp_array, sizeof(*comp_array) * info->lti_count);
if (comp_array == NULL)
GOTO(out, rc = -ENOMEM);
- memcpy(&comp_array[0], &lo->ldo_comp_entries[0],
- sizeof(*comp_array) * left);
+ for (i = 0; i < info->lti_count; i++) {
+ memcpy(&comp_array[i],
+ &lo->ldo_comp_entries[info->lti_comp_idx[i]],
+ sizeof(*comp_array));
+ }
OBD_FREE(lo->ldo_comp_entries,
sizeof(*comp_array) * lo->ldo_comp_cnt);
lo->ldo_comp_entries = comp_array;
- lo->ldo_comp_cnt = left;
-
- LASSERT(lo->ldo_mirror_count == 1);
- lo->ldo_mirrors[0].lme_end = left - 1;
- lod_obj_inc_layout_gen(lo);
+ lo->ldo_comp_cnt = info->lti_count;
} else {
lod_free_comp_entries(lo);
}
+ EXIT;
+out:
+ return rc ? rc : deleted;
+}
+
+/**
+ * Delete layout component(s)
+ *
+ * This function sets up the layout data in the env and does the setattrs
+ * required to write out the new layout. The layout itself is modified in
+ * lod_layout_del_prep_layout.
+ *
+ * \param[in] env execution environment for this thread
+ * \param[in] dt object
+ * \param[in] th transaction handle
+ *
+ * \retval 0 on success
+ * \retval negative error number on failure
+ */
+static int lod_layout_del(const struct lu_env *env, struct dt_object *dt,
+ struct thandle *th)
+{
+ struct lod_object *lo = lod_dt_obj(dt);
+ struct dt_object *next = dt_object_child(dt);
+ struct lu_attr *attr = &lod_env_info(env)->lti_attr;
+ int rc;
+
+ LASSERT(lo->ldo_mirror_count == 1);
+
+ rc = lod_layout_del_prep_layout(env, lo, th);
+ if (rc < 0)
+ GOTO(out, rc);
+
+ /* Only do this if we didn't delete all components */
+ if (lo->ldo_comp_cnt > 0) {
+ lo->ldo_mirrors[0].lme_end = lo->ldo_comp_cnt - 1;
+ lod_obj_inc_layout_gen(lo);
+ }
+
LASSERT(dt_object_exists(dt));
rc = dt_attr_get(env, next, attr);
if (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);
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) {
comp_v1 = (struct lov_comp_md_v1 *)v1;
comp_cnt = comp_v1->lcm_entry_count;
if (comp_cnt == 0)
lo->ldo_dir_stripe_offset =
lds->lds_dir_def_stripe_offset;
if (lo->ldo_dir_hash_type == 0)
- lo->ldo_dir_hash_type = lds->lds_dir_def_hash_type;
-
- /*
- * "space" hash type can only be set in default LMV, child use
- * FNV_1A_64 in case it's striped.
- */
- if (lo->ldo_dir_hash_type == LMV_HASH_TYPE_SPACE)
- lo->ldo_dir_hash_type = LMV_HASH_TYPE_FNV_1A_64;
+ lo->ldo_dir_hash_type = lds->lds_dir_def_hash_type &
+ ~LMV_HASH_FLAG_SPACE;
CDEBUG(D_LAYOUT, "striping from default dir: count:%hu, "
"offset:%u, hash_type:%u\n",
RETURN(rc);
}
-static inline int dt_object_space_hashed(const struct lu_env *env,
- struct lu_device *dev,
- struct dt_object *dt)
+/*
+ * Whether subdirectories under \a dt should be created on MDTs by space QoS
+ *
+ * If LMV_HASH_FLAG_SPACE is set on directory default layout, its subdirectories
+ * should be created on MDT by space QoS.
+ *
+ * \param[in] env execution environment
+ * \param[in] dev lu device
+ * \param[in] dt object
+ *
+ * \retval 1 if directory should create subdir by space usage
+ * \retval 0 if not
+ * \retval -ev if failed
+ */
+static inline int dt_object_qos_mkdir(const struct lu_env *env,
+ struct lu_device *dev,
+ struct dt_object *dt)
{
+ struct lod_thread_info *info = lod_env_info(env);
struct lu_object *obj;
struct lod_object *lo;
struct lmv_user_md *lmu;
- int rc = 0;
+ int rc;
obj = lu_object_find_slice(env, dev, lu_object_fid(&dt->do_lu), NULL);
if (IS_ERR(obj))
lo = lu2lod_obj(obj);
rc = lod_get_default_lmv_ea(env, lo);
- if (rc < 0)
+ dt_object_put(env, dt);
+ if (rc <= 0)
return rc;
- if (rc >= (int)sizeof(*lmu)) {
- struct lod_thread_info *info = lod_env_info(env);
-
- lmu = info->lti_ea_store;
- rc = le32_to_cpu(lmu->lum_hash_type) == LMV_HASH_TYPE_SPACE;
- }
- dt_object_put(env, dt);
+ if (rc < (int)sizeof(*lmu))
+ return -EINVAL;
- return rc;
+ lmu = info->lti_ea_store;
+ return !!(le32_to_cpu(lmu->lum_hash_type) & LMV_HASH_FLAG_SPACE);
}
/**
*/
if (hint->dah_parent &&
dt_object_remote(hint->dah_parent)) {
- rc = dt_object_space_hashed(env,
+ rc = dt_object_qos_mkdir(env,
lo->ldo_obj.do_lu.lo_dev,
hint->dah_parent);
if (rc <= 0)
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)
return dt_invalidate(env, dt_object_child(dt));
}
-static int lod_layout_data_init(struct lod_thread_info *info, __u32 comp_cnt)
-{
- ENTRY;
-
- /* clear memory region that will be used for layout change */
- memset(&info->lti_layout_attr, 0, sizeof(struct lu_attr));
- info->lti_count = 0;
-
- if (info->lti_comp_size >= comp_cnt)
- RETURN(0);
-
- if (info->lti_comp_size > 0) {
- OBD_FREE(info->lti_comp_idx,
- info->lti_comp_size * sizeof(__u32));
- info->lti_comp_size = 0;
- }
-
- OBD_ALLOC(info->lti_comp_idx, comp_cnt * sizeof(__u32));
- if (!info->lti_comp_idx)
- RETURN(-ENOMEM);
-
- info->lti_comp_size = comp_cnt;
- RETURN(0);
-}
-
static int lod_declare_instantiate_components(const struct lu_env *env,
struct lod_object *lo, struct thandle *th)
{
RETURN(rc);
}
+/**
+ * Check OSTs for an existing component for further extension
+ *
+ * Checks if OSTs are still healthy and not out of space. Gets free space
+ * on OSTs (relative to allocation watermark rmb_low) and compares to
+ * the proposed new_end for this component.
+ *
+ * Decides whether or not to extend a component on its current OSTs.
+ *
+ * \param[in] env execution environment for this thread
+ * \param[in] lo object we're checking
+ * \param[in] index index of this component
+ * \param[in] extension_size extension size for this component
+ * \param[in] extent layout extent for requested operation
+ * \param[in] comp_extent extension component extent
+ * \param[in] write if this is write operation
+ *
+ * \retval true - OK to extend on current OSTs
+ * \retval false - do not extend on current OSTs
+ */
+static bool lod_sel_osts_allowed(const struct lu_env *env,
+ struct lod_object *lo,
+ int index, __u64 extension_size,
+ struct lu_extent *extent,
+ struct lu_extent *comp_extent, int write)
+{
+ struct lod_layout_component *lod_comp = &lo->ldo_comp_entries[index];
+ struct lod_device *lod = lu2lod_dev(lo->ldo_obj.do_lu.lo_dev);
+ struct obd_statfs *sfs = &lod_env_info(env)->lti_osfs;
+ __u64 available = 0;
+ __u64 size;
+ bool ret = true;
+ int i, rc;
+
+ ENTRY;
+
+ LASSERT(lod_comp->llc_stripe_count != 0);
+
+ if (write == 0 ||
+ (extent->e_start == 0 && extent->e_end == OBD_OBJECT_EOF)) {
+ /* truncate or append */
+ size = extension_size;
+ } else {
+ /* In case of write op, check the real write extent,
+ * it may be larger than the extension_size */
+ size = roundup(min(extent->e_end, comp_extent->e_end) -
+ max(extent->e_start, comp_extent->e_start),
+ extension_size);
+ }
+ /* extension_size is file level, so we must divide by stripe count to
+ * compare it to available space on a single OST */
+ size /= lod_comp->llc_stripe_count;
+
+ lod_getref(&lod->lod_ost_descs);
+ for (i = 0; i < lod_comp->llc_stripe_count; i++) {
+ int index = lod_comp->llc_ost_indices[i];
+ struct lod_tgt_desc *ost = OST_TGT(lod, index);
+ struct obd_statfs_info info = { 0 };
+ int j, repeated = 0;
+
+ LASSERT(ost);
+
+ /* Get the number of times this OST repeats in this component.
+ * Note: inter-component repeats are not counted as this is
+ * considered as a rare case: we try to not repeat OST in other
+ * components if possible. */
+ for (j = 0; j < lod_comp->llc_stripe_count; j++) {
+ if (index != lod_comp->llc_ost_indices[j])
+ continue;
+
+ /* already handled */
+ if (j < i)
+ break;
+
+ repeated++;
+ }
+ if (j < lod_comp->llc_stripe_count)
+ continue;
+
+ if (!cfs_bitmap_check(lod->lod_ost_bitmap, index)) {
+ CDEBUG(D_LAYOUT, "ost %d no longer present\n", index);
+ ret = false;
+ break;
+ }
+
+ rc = dt_statfs_info(env, ost->ltd_ost, sfs, &info);
+ if (rc) {
+ CDEBUG(D_LAYOUT, "statfs failed for ost %d, error %d\n",
+ index, rc);
+ ret = false;
+ break;
+ }
+
+ if (sfs->os_state & OS_STATE_ENOSPC ||
+ sfs->os_state & OS_STATE_READONLY ||
+ sfs->os_state & OS_STATE_DEGRADED) {
+ CDEBUG(D_LAYOUT, "ost %d is not availble for SEL "
+ "extension, state %u\n", index, sfs->os_state);
+ ret = false;
+ break;
+ }
+
+ /* In bytes */
+ available = sfs->os_bavail * sfs->os_bsize;
+ /* 'available' is relative to the allocation threshold */
+ available -= (__u64) info.os_reserved_mb_low << 20;
+
+ CDEBUG(D_LAYOUT, "ost %d lowwm: %d highwm: %d, "
+ "%llu %% blocks available, %llu %% blocks free\n",
+ index, info.os_reserved_mb_low, info.os_reserved_mb_high,
+ (100ull * sfs->os_bavail) / sfs->os_blocks,
+ (100ull * sfs->os_bfree) / sfs->os_blocks);
+
+ if (size * repeated > available) {
+ ret = false;
+ CDEBUG(D_LAYOUT, "low space on ost %d, available %llu "
+ "< extension size %llu\n", index, available,
+ extension_size);
+ break;
+ }
+ }
+ lod_putref(lod, &lod->lod_ost_descs);
+
+ RETURN(ret);
+}
+
+/**
+ * Adjust extents after component removal
+ *
+ * When we remove an extension component, we move the start of the next
+ * component to match the start of the extension component, so no space is left
+ * without layout.
+ *
+ * \param[in] env execution environment for this thread
+ * \param[in] lo object
+ * \param[in] max_comp layout component
+ * \param[in] index index of this component
+ *
+ * \retval 0 on success
+ * \retval negative errno on error
+ */
+static void lod_sel_adjust_extents(const struct lu_env *env,
+ struct lod_object *lo,
+ int max_comp, int index)
+{
+ struct lod_layout_component *lod_comp = NULL;
+ struct lod_layout_component *next = NULL;
+ struct lod_layout_component *prev = NULL;
+ __u64 new_start = 0;
+ __u64 start;
+ int i;
+
+ /* Extension space component */
+ lod_comp = &lo->ldo_comp_entries[index];
+ next = &lo->ldo_comp_entries[index + 1];
+ prev = &lo->ldo_comp_entries[index - 1];
+
+ LASSERT(lod_comp != NULL && prev != NULL && next != NULL);
+ LASSERT(lod_comp->llc_flags & LCME_FL_EXTENSION);
+
+ /* Previous is being removed */
+ if (prev && prev->llc_id == LCME_ID_INVAL)
+ new_start = prev->llc_extent.e_start;
+ else
+ new_start = lod_comp->llc_extent.e_start;
+
+ for (i = index + 1; i < max_comp; i++) {
+ lod_comp = &lo->ldo_comp_entries[i];
+
+ start = lod_comp->llc_extent.e_start;
+ lod_comp->llc_extent.e_start = new_start;
+
+ /* We only move zero length extendable components */
+ if (!(start == lod_comp->llc_extent.e_end))
+ break;
+
+ LASSERT(!(lod_comp->llc_flags & LCME_FL_INIT));
+
+ lod_comp->llc_extent.e_end = new_start;
+ }
+}
+
+/* Calculate the proposed 'new end' for a component we're extending */
+static __u64 lod_extension_new_end(__u64 extension_size, __u64 extent_end,
+ __u32 stripe_size, __u64 component_end,
+ __u64 extension_end)
+{
+ __u64 new_end;
+
+ LASSERT(extension_size != 0 && stripe_size != 0);
+
+ /* Round up to extension size */
+ if (extent_end == OBD_OBJECT_EOF) {
+ new_end = OBD_OBJECT_EOF;
+ } else {
+ /* Add at least extension_size to the previous component_end,
+ * covering the req layout extent */
+ new_end = max(extent_end - component_end, extension_size);
+ new_end = roundup(new_end, extension_size);
+ new_end += component_end;
+
+ /* Component end must be min stripe size aligned */
+ if (new_end % stripe_size) {
+ CDEBUG(D_LAYOUT, "new component end is not aligned "
+ "by the stripe size %u: [%llu, %llu) ext size "
+ "%llu new end %llu, aligning\n",
+ stripe_size, component_end, extent_end,
+ extension_size, new_end);
+ new_end = roundup(new_end, stripe_size);
+ }
+
+ /* Overflow */
+ if (new_end < extent_end)
+ new_end = OBD_OBJECT_EOF;
+ }
+
+ /* Don't extend past the end of the extension component */
+ if (new_end > extension_end)
+ new_end = extension_end;
+
+ 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
+ *
+ * Handle layout updates for a particular extension space component touched by
+ * a layout update operation. Core function of self-extending PFL feature.
+ *
+ * In general, this function processes exactly *one* stage of an extension
+ * operation, modifying the layout accordingly, then returns to the caller.
+ * The caller is responsible for restarting processing with the new layout,
+ * which may repeatedly return to this function until the extension updates
+ * are complete.
+ *
+ * This function does one of a few things to the layout:
+ * 1. Extends the component before the current extension space component to
+ * allow it to accomodate the requested operation (if space/policy permit that
+ * component to continue on its current OSTs)
+ *
+ * 2. If extension of the existing component fails, we do one of two things:
+ * a. If there is a component after the extension space, we remove the
+ * 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 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
+ * if that fails, they will be removed without initialization.
+ *
+ * 3. If we extend to/beyond the end of an extension space component, that
+ * component is exhausted (all of its range has been given to real components),
+ * so we remove it and restart processing.
+ *
+ * \param[in] env execution environment for this thread
+ * \param[in,out] lo object to update the layout of
+ * \param[in] extent layout extent for requested operation, update
+ * layout to fit this operation
+ * \param[in] th transaction handle for this operation
+ * \param[in,out] max_comp the highest comp for the portion of the layout
+ * we are operating on (For FLR, the chosen
+ * replica). Updated because we may remove
+ * components.
+ * \param[in] index index of the extension space component we're
+ * working on
+ * \param[in] write if this is write op
+ * \param[in,out] force if the extension is to be forced; set here
+ to force it on the 2nd call for the same
+ extension component
+ *
+ * \retval 0 on success
+ * \retval negative errno on error
+ */
+static int lod_sel_handler(const struct lu_env *env,
+ struct lod_object *lo,
+ struct lu_extent *extent,
+ struct thandle *th, int *max_comp,
+ 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 *lod_comp;
+ struct lod_layout_component *prev;
+ struct lod_layout_component *next = NULL;
+ __u64 extension_size;
+ __u64 new_end = 0;
+ bool repeated;
+ int change = 0;
+ int rc = 0;
+ ENTRY;
+
+ /* First component cannot be extension space */
+ if (index == 0) {
+ CERROR("%s: "DFID" first component cannot be extension space\n",
+ lod2obd(d)->obd_name, PFID(lod_object_fid(lo)));
+ RETURN(-EINVAL);
+ }
+
+ lod_comp = &lo->ldo_comp_entries[index];
+ prev = &lo->ldo_comp_entries[index - 1];
+ if ((index + 1) < *max_comp)
+ next = &lo->ldo_comp_entries[index + 1];
+
+ /* extension size uses the stripe size field as KiB */
+ extension_size = lod_comp->llc_stripe_size * SEL_UNIT_SIZE;
+
+ CDEBUG(D_LAYOUT, "prev start %llu, extension start %llu, extension end"
+ " %llu, extension size %llu\n", prev->llc_extent.e_start,
+ lod_comp->llc_extent.e_start, lod_comp->llc_extent.e_end,
+ extension_size);
+
+ /* Two extension space components cannot be adjacent & extension space
+ * components cannot be init */
+ if ((prev->llc_flags & LCME_FL_EXTENSION) ||
+ !(ergo(next, !(next->llc_flags & LCME_FL_EXTENSION))) ||
+ lod_comp_inited(lod_comp)) {
+ CERROR("%s: "DFID" invalid extension space components\n",
+ lod2obd(d)->obd_name, PFID(lod_object_fid(lo)));
+ RETURN(-EINVAL);
+ }
+
+ if (!prev->llc_stripe) {
+ CDEBUG(D_LAYOUT, "Previous component not inited\n");
+ 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. 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 (sd->sd_force == 0 && rc == 0)
+ rc = !lod_sel_osts_allowed(env, lo, index - 1,
+ extension_size, extent,
+ &lod_comp->llc_extent, write);
+
+ repeated = !!(sd->sd_repeat);
+ sd->sd_repeat = 0;
+ sd->sd_force = 0;
+
+ /* Extend previous component */
+ if (rc == 0) {
+ new_end = lod_extension_new_end(extension_size, extent->e_end,
+ prev->llc_stripe_size,
+ prev->llc_extent.e_end,
+ lod_comp->llc_extent.e_end);
+
+ CDEBUG(D_LAYOUT, "new end %llu\n", new_end);
+ lod_comp->llc_extent.e_start = new_end;
+ prev->llc_extent.e_end = new_end;
+
+ if (prev->llc_extent.e_end == lod_comp->llc_extent.e_end) {
+ CDEBUG(D_LAYOUT, "Extension component exhausted\n");
+ lod_comp->llc_id = LCME_ID_INVAL;
+ change--;
+ }
+ } else {
+ /* rc == 1, failed to extend current component */
+ LASSERT(rc == 1);
+ if (next) {
+ /* Normal 'spillover' case - Remove the extension
+ * space component & bring down the start of the next
+ * component. */
+ lod_comp->llc_id = LCME_ID_INVAL;
+ change--;
+ if (!(prev->llc_flags & LCME_FL_INIT)) {
+ prev->llc_id = LCME_ID_INVAL;
+ 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 {
+ /* 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--;
+ }
+ }
+ }
+
+ if (change < 0) {
+ rc = lod_layout_del_prep_layout(env, lo, NULL);
+ if (rc < 0)
+ RETURN(rc);
+ LASSERTF(-rc == change,
+ "number deleted %d != requested %d\n", -rc,
+ change);
+ }
+ *max_comp = *max_comp + change;
+
+ /* lod_del_prep_layout reallocates ldo_comp_entries, so we must
+ * refresh these pointers before using them */
+ lod_comp = &lo->ldo_comp_entries[index];
+ prev = &lo->ldo_comp_entries[index - 1];
+ CDEBUG(D_LAYOUT, "After extent updates: prev start %llu, current start "
+ "%llu, current end %llu max_comp %d ldo_comp_cnt %d\n",
+ prev->llc_extent.e_start, lod_comp->llc_extent.e_start,
+ lod_comp->llc_extent.e_end, *max_comp, lo->ldo_comp_cnt);
+
+ /* Layout changed successfully */
+ RETURN(0);
+}
+
+/**
+ * Declare layout extent updates
+ *
+ * Handles extensions. Identifies extension components touched by current
+ * operation and passes them to processing function.
+ *
+ * Restarts with updated layouts from the processing function until the current
+ * operation no longer touches an extension space component.
+ *
+ * \param[in] env execution environment for this thread
+ * \param[in,out] lo object to update the layout of
+ * \param[in] extent layout extent for requested operation, update layout to
+ * fit this operation
+ * \param[in] th transaction handle for this operation
+ * \param[in] pick identifies chosen mirror for FLR layouts
+ * \param[in] write if this is write op
+ *
+ * \retval 1 on layout changed, 0 on no change
+ * \retval negative errno on error
+ */
+static int lod_declare_update_extents(const struct lu_env *env,
+ struct lod_object *lo, struct lu_extent *extent,
+ struct thandle *th, int pick, int write)
+{
+ 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;
+ ENTRY;
+
+ /* This makes us work on the components of the chosen mirror */
+ start_index = lo->ldo_mirrors[pick].lme_start;
+ max_comp = lo->ldo_mirrors[pick].lme_end + 1;
+ if (lo->ldo_flr_state == LCM_FL_NONE)
+ LASSERT(start_index == 0 && max_comp == lo->ldo_comp_cnt);
+
+ CDEBUG(D_LAYOUT, "extent->e_start %llu, extent->e_end %llu\n",
+ extent->e_start, extent->e_end);
+ for (i = start_index; i < max_comp; i++) {
+ lod_comp = &lo->ldo_comp_entries[i];
+
+ /* We've passed all components of interest */
+ if (lod_comp->llc_extent.e_start >= extent->e_end)
+ break;
+
+ if (lod_comp->llc_flags & LCME_FL_EXTENSION) {
+ layout_changed = true;
+ rc = lod_sel_handler(env, lo, extent, th, &max_comp,
+ i, write, &sd);
+ if (rc < 0)
+ GOTO(out, rc);
+
+ /* Nothing has changed behind the prev one */
+ i -= 2;
+ continue;
+ }
+ }
+
+ /* 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;
+ for (i = pick + 1; i < lo->ldo_mirror_count; i++) {
+ lo->ldo_mirrors[i].lme_start += change;
+ lo->ldo_mirrors[i].lme_end += change;
+ }
+ }
+
+ EXIT;
+out:
+ /* The amount of components has changed, adjust the lti_comp_idx */
+ rc2 = lod_layout_data_init(info, lo->ldo_comp_cnt);
+
+ return rc < 0 ? rc : rc2 < 0 ? rc2 : layout_changed;
+}
+
+/* If striping is already instantiated or INIT'ed DOM? */
+static bool lod_is_instantiation_needed(struct lod_layout_component *comp)
+{
+ return !(((lov_pattern(comp->llc_pattern) == LOV_PATTERN_MDT) &&
+ lod_comp_inited(comp)) || comp->llc_stripe);
+}
+
+/**
+ * Declare layout update for a non-FLR layout.
+ *
+ * \param[in] env execution environment for this thread
+ * \param[in,out] lo object to update the layout of
+ * \param[in] layout layout intent for requested operation, "update" is
+ * a process of reacting to this
+ * \param[in] buf buffer containing lov ea (see comment on usage inline)
+ * \param[in] th transaction handle for this operation
+ *
+ * \retval 0 on success
+ * \retval negative errno on error
+ */
static int lod_declare_update_plain(const struct lu_env *env,
struct lod_object *lo, struct layout_intent *layout,
const struct lu_buf *buf, struct thandle *th)
struct lod_device *d = lu2lod_dev(lo->ldo_obj.do_lu.lo_dev);
struct lod_layout_component *lod_comp;
struct lov_comp_md_v1 *comp_v1 = NULL;
+ bool layout_changed = false;
bool replay = false;
int i, rc;
ENTRY;
/* old on-disk EA is stored in info->lti_buf */
comp_v1 = (struct lov_comp_md_v1 *)info->lti_buf.lb_buf;
replay = true;
+ layout_changed = true;
+
+ rc = lod_layout_data_init(info, lo->ldo_comp_cnt);
+ if (rc)
+ GOTO(out, rc);
} else {
/* non replay path */
rc = lod_striping_load(env, lo);
if (lo->ldo_comp_cnt > 1 &&
lod_comp->llc_extent.e_end != OBD_OBJECT_EOF &&
lod_comp->llc_extent.e_end < layout->li_extent.e_end) {
- CDEBUG(replay ? D_ERROR : D_LAYOUT,
- "%s: the defined layout [0, %#llx) does not covers "
- "the write range "DEXT"\n",
- lod2obd(d)->obd_name, lod_comp->llc_extent.e_end,
- PEXT(&layout->li_extent));
+ CDEBUG_LIMIT(replay ? D_ERROR : D_LAYOUT,
+ "%s: the defined layout [0, %#llx) does not "
+ "covers the write range "DEXT"\n",
+ lod2obd(d)->obd_name, lod_comp->llc_extent.e_end,
+ PEXT(&layout->li_extent));
GOTO(out, rc = -EINVAL);
}
- CDEBUG(D_LAYOUT, "%s: "DFID": instantiate components "DEXT"\n",
+ CDEBUG(D_LAYOUT, "%s: "DFID": update components "DEXT"\n",
lod2obd(d)->obd_name, PFID(lod_object_fid(lo)),
PEXT(&layout->li_extent));
+ if (!replay) {
+ rc = lod_declare_update_extents(env, lo, &layout->li_extent,
+ th, 0, layout->li_opc == LAYOUT_INTENT_WRITE);
+ if (rc < 0)
+ GOTO(out, rc);
+ else if (rc)
+ layout_changed = true;
+ }
+
/*
* Iterate ld->ldo_comp_entries, find the component whose extent under
* the write range and not instantianted.
break;
if (!replay) {
- if (lod_comp_inited(lod_comp))
+ /* If striping is instantiated or INIT'ed DOM skip */
+ if (!lod_is_instantiation_needed(lod_comp))
continue;
} else {
/**
LASSERT(info->lti_comp_idx != NULL);
info->lti_comp_idx[info->lti_count++] = i;
+ layout_changed = true;
}
- if (info->lti_count == 0)
+ if (!layout_changed)
RETURN(-EALREADY);
lod_obj_inc_layout_gen(lo);
rc = lod_declare_instantiate_components(env, lo, th);
+ EXIT;
out:
if (rc)
lod_striping_free(env, lo);
- RETURN(rc);
+ return rc;
}
static inline int lod_comp_index(struct lod_object *lo,
/**
* Stale other mirrors by writing extent.
*/
-static void lod_stale_components(struct lod_object *lo, int primary,
- struct lu_extent *extent)
+static int lod_stale_components(const struct lu_env *env, struct lod_object *lo,
+ int primary, struct lu_extent *extent,
+ struct thandle *th)
{
struct lod_layout_component *pri_comp, *lod_comp;
+ struct lu_extent pri_extent;
+ int rc = 0;
int i;
+ ENTRY;
/* The writing extent decides which components in the primary
* are affected... */
CDEBUG(D_LAYOUT, "primary mirror %d, "DEXT"\n", primary, PEXT(extent));
+
+restart:
lod_foreach_mirror_comp(pri_comp, lo, primary) {
if (!lu_extent_is_overlapped(extent, &pri_comp->llc_extent))
continue;
lod_comp_index(lo, pri_comp),
PEXT(&pri_comp->llc_extent));
+ pri_extent.e_start = pri_comp->llc_extent.e_start;
+ pri_extent.e_end = pri_comp->llc_extent.e_end;
+
for (i = 0; i < lo->ldo_mirror_count; i++) {
if (i == primary)
continue;
+ rc = lod_declare_update_extents(env, lo, &pri_extent,
+ th, i, 0);
+ /* if update_extents changed the layout, it may have
+ * reallocated the component array, so start over to
+ * avoid using stale pointers */
+ if (rc == 1)
+ goto restart;
+ if (rc < 0)
+ RETURN(rc);
/* ... and then stale other components that are
* overlapping with primary components */
lod_foreach_mirror_comp(lod_comp, lo, i) {
if (!lu_extent_is_overlapped(
- &pri_comp->llc_extent,
+ &pri_extent,
&lod_comp->llc_extent))
continue;
}
}
}
+
+ RETURN(rc);
}
/**
if (mlc->mlc_opc == MD_LAYOUT_WRITE) {
struct layout_intent *layout = mlc->mlc_intent;
+ int write = layout->li_opc == LAYOUT_INTENT_WRITE;
int picked;
extent = layout->li_extent;
PFID(lod_object_fid(lo)),
lo->ldo_mirrors[picked].lme_id);
+ /* Update extents of primary before staling */
+ rc = lod_declare_update_extents(env, lo, &extent, th, picked,
+ write);
+ if (rc < 0)
+ GOTO(out, rc);
+
if (layout->li_opc == LAYOUT_INTENT_TRUNC) {
/**
* trunc transfers [0, size) in the intent extent, we'd
}
/* stale overlapping components from other mirrors */
- lod_stale_components(lo, picked, &extent);
+ rc = lod_stale_components(env, lo, picked, &extent, th);
+ if (rc < 0)
+ GOTO(out, rc);
/* restore truncate intent extent */
if (layout->li_opc == LAYOUT_INTENT_TRUNC)
&lod_comp->llc_extent))
break;
- if (lod_comp_inited(lod_comp))
+ if (!lod_is_instantiation_needed(lod_comp))
continue;
info->lti_comp_idx[info->lti_count++] =
if (lo->ldo_layout_gen > (LCME_ID_MAX >> 1)) {
__u32 layout_version;
- cfs_get_random_bytes(&layout_version, sizeof(layout_version));
+ get_random_bytes(&layout_version, sizeof(layout_version));
lo->ldo_layout_gen = layout_version & 0xffff;
}
* 2. transfer layout version to all objects to close write era. */
if (mlc->mlc_opc == MD_LAYOUT_WRITE) {
+ struct layout_intent *layout = mlc->mlc_intent;
+ int write = layout->li_opc == LAYOUT_INTENT_WRITE;
+
LASSERT(mlc->mlc_intent != NULL);
extent = mlc->mlc_intent->li_extent;
CDEBUG(D_LAYOUT, DFID": intent to write: "DEXT"\n",
PFID(lod_object_fid(lo)), PEXT(&extent));
+ /* 1. Update extents of primary before staling */
+ rc = lod_declare_update_extents(env, lo, &extent, th, primary,
+ write);
+ if (rc < 0)
+ GOTO(out, rc);
+
if (mlc->mlc_intent->li_opc == LAYOUT_INTENT_TRUNC) {
/**
* trunc transfers [0, size) in the intent extent, we'd
extent.e_start = extent.e_end;
extent.e_end = OBD_OBJECT_EOF;
}
- /* 1. stale overlapping components */
- lod_stale_components(lo, primary, &extent);
- /* 2. find out the components need instantiating.
+ /* 2. stale overlapping components */
+ rc = lod_stale_components(env, lo, primary, &extent, th);
+ if (rc < 0)
+ GOTO(out, rc);
+
+ /* 3. find the components which need instantiating.
* instantiate [0, mlc->mlc_intent->e_end) */
/* restore truncate intent extent */
&lod_comp->llc_extent))
break;
- if (lod_comp_inited(lod_comp))
+ if (!lod_is_instantiation_needed(lod_comp))
continue;
CDEBUG(D_LAYOUT, "write instantiate %d / %d\n",
GOTO(out, rc = -EINVAL);
}
- CDEBUG(D_LAYOUT, DFID": resynced %u/%zu components\n",
+ CDEBUG(D_LAYOUT, DFID": synced %u resynced %u/%zu components\n",
PFID(lod_object_fid(lo)),
- resync_components, mlc->mlc_resync_count);
+ sync_components, resync_components, mlc->mlc_resync_count);
lo->ldo_flr_state = LCM_FL_RDONLY;
lod_obj_inc_layout_gen(lo);
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) {
git://git.whamcloud.com / fs / lustre-release.git / blobdiff