}
/* check stripe size is multiplier of comp_end */
if (comp_end != LUSTRE_EOF &&
+ comp_end != comp->llc_extent.e_start &&
comp_end % comp->llc_stripe_size) {
/* fix that even for defined stripe size but warn
* about the problem, that must not happen
struct lod_obj_stripe_cb_data *data)
{
struct lod_layout_component *lod_comp;
- int i, j, rc;
+ int i, j, rc = 0;
ENTRY;
- LASSERT(lo->ldo_comp_cnt != 0 && lo->ldo_comp_entries != NULL);
+ mutex_lock(&lo->ldo_layout_mutex);
for (i = 0; i < lo->ldo_comp_cnt; i++) {
lod_comp = &lo->ldo_comp_entries[i];
if (data->locd_comp_cb) {
rc = data->locd_comp_cb(env, lo, i, data);
if (rc)
- RETURN(rc);
+ GOTO(unlock, rc);
}
/* could used just to do sth about component, not each
continue;
rc = data->locd_stripe_cb(env, lo, dt, th, i, j, data);
if (rc != 0)
- RETURN(rc);
+ GOTO(unlock, rc);
}
}
- RETURN(0);
+unlock:
+ mutex_unlock(&lo->ldo_layout_mutex);
+ RETURN(rc);
}
static bool lod_obj_attr_set_comp_skip_cb(const struct lu_env *env,
}
break;
}
+ case LCM_FL_RDONLY:
+ case LCM_FL_SYNC_PENDING:
+ break;
default:
LASSERTF(0, "impossible: %d\n", lo->ldo_flr_state);
- case LCM_FL_SYNC_PENDING:
break;
}
RETURN(-EINVAL);
/* adjust hash for dir merge, which may not be set in user command */
- if (lmv_is_merging(lmv) && !lmv->lmv_migrate_hash)
- lmv->lmv_merge_hash =
- lod->lod_mdt_descs.ltd_lmv_desc.ld_pattern;
+ if (lmv_is_merging(lmv) &&
+ !(lmv->lmv_migrate_hash & LMV_HASH_TYPE_MASK))
+ lmv->lmv_merge_hash |=
+ lod->lod_mdt_descs.ltd_lmv_desc.ld_pattern &
+ LMV_HASH_TYPE_MASK;
LMV_DEBUG(D_INFO, lmv, "set");
return lod->lod_ost_count;
else
return lod_get_stripe_count(lod, lo, comp_idx,
- entry->llc_stripe_count, false);
+ entry->llc_stripe_count,
+ entry->llc_pattern &
+ LOV_PATTERN_OVERSTRIPING);
}
static int lod_comp_md_size(struct lod_object *lo, bool is_dir)
if (magic != LOV_USER_MAGIC_COMP_V1)
RETURN(-EINVAL);
+ mutex_lock(&lo->ldo_layout_mutex);
+
array_cnt = lo->ldo_comp_cnt + comp_v1->lcm_entry_count;
OBD_ALLOC_PTR_ARRAY(comp_array, array_cnt);
- if (comp_array == NULL)
+ if (comp_array == NULL) {
+ mutex_unlock(&lo->ldo_layout_mutex);
RETURN(-ENOMEM);
+ }
+
memcpy(comp_array, lo->ldo_comp_entries,
sizeof(*comp_array) * lo->ldo_comp_cnt);
LASSERT(lo->ldo_mirror_count == 1);
lo->ldo_mirrors[0].lme_end = array_cnt - 1;
+ mutex_unlock(&lo->ldo_layout_mutex);
+
RETURN(0);
error:
}
}
OBD_FREE_PTR_ARRAY(comp_array, array_cnt);
+ mutex_unlock(&lo->ldo_layout_mutex);
+
RETURN(rc);
}
RETURN(-EINVAL);
}
+ mutex_lock(&lo->ldo_layout_mutex);
for (i = 0; i < comp_v1->lcm_entry_count; i++) {
__u32 id = comp_v1->lcm_entries[i].lcme_id;
__u32 flags = comp_v1->lcm_entries[i].lcme_flags;
if (flags & LCME_FL_INIT) {
if (changed)
- lod_striping_free(env, lo);
+ lod_striping_free_nolock(env, lo);
+ mutex_unlock(&lo->ldo_layout_mutex);
RETURN(-EINVAL);
}
if (flags) {
if ((flags & LCME_FL_STALE) &&
lod_last_non_stale_mirror(mirror_id,
- lo))
+ lo)) {
+ mutex_unlock(
+ &lo->ldo_layout_mutex);
RETURN(-EUCLEAN);
+ }
lod_comp->llc_flags |= flags;
}
if (mirror_flag) {
changed = true;
}
}
+ mutex_unlock(&lo->ldo_layout_mutex);
if (!changed) {
CDEBUG(D_LAYOUT, "%s: requested component(s) not found.\n",
flags = 0;
}
+ mutex_lock(&lo->ldo_layout_mutex);
+
left = lo->ldo_comp_cnt;
- if (left <= 0)
+ if (left <= 0) {
+ mutex_unlock(&lo->ldo_layout_mutex);
RETURN(-EINVAL);
+ }
for (i = (lo->ldo_comp_cnt - 1); i >= 0; i--) {
struct lod_layout_component *lod_comp;
if (left != (i + 1)) {
CDEBUG(D_LAYOUT, "%s: this deletion will create "
"a hole.\n", lod2obd(d)->obd_name);
+ mutex_unlock(&lo->ldo_layout_mutex);
RETURN(-EINVAL);
}
left--;
if (obj == NULL)
continue;
rc = lod_sub_declare_destroy(env, obj, th);
- if (rc)
+ if (rc) {
+ mutex_unlock(&lo->ldo_layout_mutex);
RETURN(rc);
+ }
}
}
if (left == lo->ldo_comp_cnt) {
CDEBUG(D_LAYOUT, "%s: requested component id:%#x not found\n",
lod2obd(d)->obd_name, id);
+ mutex_unlock(&lo->ldo_layout_mutex);
RETURN(-EINVAL);
}
+ mutex_unlock(&lo->ldo_layout_mutex);
+
memset(attr, 0, sizeof(*attr));
attr->la_valid = LA_SIZE;
rc = lod_sub_declare_attr_set(env, next, attr, th);
struct dt_object *dt, const struct lu_buf *mbuf,
struct thandle *th)
{
- struct lod_thread_info *info = lod_env_info(env);
- struct lu_buf *buf = &info->lti_buf;
- struct lod_object *lo = lod_dt_obj(dt);
- struct lov_comp_md_v1 *lcm;
- struct lov_comp_md_v1 *cur_lcm;
- struct lov_comp_md_v1 *merge_lcm;
- struct lov_comp_md_entry_v1 *lcme;
+ struct lod_thread_info *info = lod_env_info(env);
+ struct lu_attr *layout_attr = &info->lti_layout_attr;
+ struct lu_buf *buf = &info->lti_buf;
+ struct lod_object *lo = lod_dt_obj(dt);
+ struct lov_comp_md_v1 *lcm;
+ 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;
__u32 id = 0;
__u16 mirror_id = 0;
__u32 mirror_count;
- int rc, i;
+ int rc, i;
bool merge_has_dom;
ENTRY;
}
/* fixup layout information */
- lod_obj_inc_layout_gen(lo);
- lcm->lcm_layout_gen = cpu_to_le32(lo->ldo_layout_gen);
lcm->lcm_size = cpu_to_le32(size);
lcm->lcm_entry_count = cpu_to_le16(cur_entry_count + merge_entry_count);
lcm->lcm_mirror_count = cpu_to_le16(mirror_count);
if (rc)
GOTO(out, rc);
+ lod_obj_inc_layout_gen(lo);
+ lcm->lcm_layout_gen = cpu_to_le32(lo->ldo_layout_gen);
+
+ /* transfer layout version to OST objects. */
+ if (lo->ldo_mirror_count > 1) {
+ struct lod_obj_stripe_cb_data data = { {0} };
+
+ layout_attr->la_valid = LA_LAYOUT_VERSION;
+ layout_attr->la_layout_version = 0;
+ data.locd_attr = layout_attr;
+ data.locd_declare = true;
+ data.locd_stripe_cb = lod_obj_stripe_attr_set_cb;
+ rc = lod_obj_for_each_stripe(env, lo, th, &data);
+ if (rc)
+ GOTO(out, rc);
+ }
+
rc = lod_sub_declare_xattr_set(env, dt_object_child(dt), buf,
XATTR_NAME_LOV, LU_XATTR_REPLACE, th);
struct dt_object *dt, const struct lu_buf *mbuf,
struct thandle *th)
{
+ struct lod_thread_info *info = lod_env_info(env);
+ struct lu_attr *layout_attr = &info->lti_layout_attr;
struct lod_object *lo = lod_dt_obj(dt);
struct lov_comp_md_v1 *lcm = mbuf->lb_buf;
int rc;
/* fix on-disk layout gen */
lcm->lcm_layout_gen = cpu_to_le32(lo->ldo_layout_gen);
+
+ /* transfer layout version to OST objects. */
+ if (lo->ldo_mirror_count > 1) {
+ struct lod_obj_stripe_cb_data data = { {0} };
+
+ layout_attr->la_valid = LA_LAYOUT_VERSION;
+ layout_attr->la_layout_version = 0;
+ data.locd_attr = layout_attr;
+ data.locd_declare = true;
+ data.locd_stripe_cb = lod_obj_stripe_attr_set_cb;
+ rc = lod_obj_for_each_stripe(env, lo, th, &data);
+ if (rc)
+ RETURN(rc);
+ }
+
rc = lod_sub_declare_xattr_set(env, dt_object_child(dt), mbuf,
XATTR_NAME_LOV, LU_XATTR_REPLACE, th);
RETURN(rc);
{
struct lod_thread_info *info = lod_env_info(env);
struct lod_device *d = lu2lod_dev(dt->do_lu.lo_dev);
+ struct lod_object *lo = lod_dt_obj(dt);
struct lov_comp_md_v1 *comp_v1 = buf->lb_buf;
struct lov_comp_md_entry_v1 *entry;
struct lov_mds_md_v1 *lmm;
ENTRY;
+ /**
+ * other ops (like lod_declare_destroy) could destroying sub objects
+ * as well.
+ */
+ mutex_lock(&lo->ldo_layout_mutex);
+
if (!declare) {
/* prepare sub-objects array */
for (i = 0; i < comp_v1->lcm_entry_count; i++) {
array_count += lmm->lmm_stripe_count;
}
OBD_ALLOC_PTR_ARRAY(sub_objs, array_count);
- if (sub_objs == NULL)
+ if (sub_objs == NULL) {
+ mutex_unlock(&lo->ldo_layout_mutex);
RETURN(-ENOMEM);
+ }
}
k = 0; /* sub_objs index */
OBD_FREE_PTR_ARRAY(sub_objs, array_count);
}
+ mutex_unlock(&lo->ldo_layout_mutex);
RETURN(rc);
}
/* Transfer default LMV striping from the parent */
if (lds != NULL && lds->lds_dir_def_striping_set &&
+ lds->lds_dir_def_max_inherit != LMV_INHERIT_END &&
+ lds->lds_dir_def_max_inherit != LMV_INHERIT_NONE &&
!(LMVEA_DELETE_VALUES(lds->lds_dir_def_stripe_count,
lds->lds_dir_def_stripe_offset) &&
le32_to_cpu(lds->lds_dir_def_hash_type) !=
cpu_to_le32(lds->lds_dir_def_stripe_offset);
v1->lum_hash_type =
cpu_to_le32(lds->lds_dir_def_hash_type);
+ v1->lum_max_inherit =
+ lmv_inherit_next(lds->lds_dir_def_max_inherit);
+ v1->lum_max_inherit_rr =
+ lmv_inherit_rr_next(lds->lds_dir_def_max_inherit_rr);
info->lti_buf.lb_buf = v1;
info->lti_buf.lb_len = sizeof(*v1);
LASSERT(lo);
if (lo->ldo_comp_cnt == 0 && !lo->ldo_is_foreign) {
- lod_striping_free(env, lo);
+ lod_striping_free_nolock(env, lo);
rc = lod_sub_xattr_del(env, next, XATTR_NAME_LOV, th);
RETURN(rc);
}
LASSERT(lo->ldo_mirror_count == 1);
+ mutex_lock(&lo->ldo_layout_mutex);
+
rc = lod_layout_del_prep_layout(env, lo, th);
if (rc < 0)
GOTO(out, rc);
EXIT;
out:
if (rc)
- lod_striping_free(env, lo);
+ lod_striping_free_nolock(env, lo);
+
+ mutex_unlock(&lo->ldo_layout_mutex);
+
return rc;
}
const char *name, int fl, struct thandle *th)
{
struct dt_object *next = dt_object_child(dt);
- int rc;
+ struct lu_attr *layout_attr = &lod_env_info(env)->lti_layout_attr;
+ struct lod_object *lo = lod_dt_obj(dt);
+ struct lod_obj_stripe_cb_data data = { {0} };
+ int rc = 0;
ENTRY;
lod_striping_free(env, lod_dt_obj(dt));
rc = lod_sub_xattr_set(env, next, buf, name, fl, th);
+ } else if (fl & LU_XATTR_SPLIT) {
+ rc = lod_sub_xattr_set(env, next, buf, name, fl, th);
+ if (rc)
+ RETURN(rc);
+
+ rc = lod_striping_reload(env, lo, buf);
+ if (rc)
+ RETURN(rc);
+
+ if (lo->ldo_mirror_count > 1 &&
+ layout_attr->la_valid & LA_LAYOUT_VERSION) {
+ /* mirror split */
+ layout_attr->la_layout_version =
+ lo->ldo_layout_gen;
+ data.locd_attr = layout_attr;
+ data.locd_declare = false;
+ data.locd_stripe_cb =
+ lod_obj_stripe_attr_set_cb;
+ rc = lod_obj_for_each_stripe(env, lo, th,
+ &data);
+ if (rc)
+ RETURN(rc);
+ }
} else if (fl & LU_XATTR_PURGE) {
rc = lod_layout_purge(env, dt, buf, th);
} else if (dt_object_remote(dt)) {
!lod_dt_obj(dt)->ldo_comp_cached));
rc = lod_striped_create(env, dt, NULL, NULL, th);
+ if (rc)
+ RETURN(rc);
+
+ if (fl & LU_XATTR_MERGE && lo->ldo_mirror_count > 1 &&
+ layout_attr->la_valid & LA_LAYOUT_VERSION) {
+ /* mirror merge exec phase */
+ layout_attr->la_layout_version =
+ lo->ldo_layout_gen;
+ data.locd_attr = layout_attr;
+ data.locd_declare = false;
+ data.locd_stripe_cb =
+ lod_obj_stripe_attr_set_cb;
+ rc = lod_obj_for_each_stripe(env, lo, th,
+ &data);
+ if (rc)
+ RETURN(rc);
+ }
}
RETURN(rc);
} else if (strcmp(name, XATTR_NAME_FID) == 0) {
ENTRY;
+ lds->lds_def_striping_set = 0;
+
rc = lod_get_lov_ea(env, lo);
if (rc < 0)
RETURN(rc);
le32_to_cpu(lmu->lum_stripe_offset);
lds->lds_dir_def_hash_type =
le32_to_cpu(lmu->lum_hash_type);
+ lds->lds_dir_def_max_inherit = lmu->lum_max_inherit;
+ lds->lds_dir_def_max_inherit_rr = lmu->lum_max_inherit_rr;
lds->lds_dir_def_striping_set = 1;
}
*/
if (likely(lp != NULL)) {
lod_get_default_striping(env, lp, lds);
-
+ if (lds->lds_def_striping_set) {
+ rc = lod_verify_striping(env, d, lp,
+ &info->lti_buf, false);
+ if (rc)
+ lds->lds_def_striping_set = 0;
+ }
/* inherit default striping except ROOT */
if ((lds->lds_def_striping_set ||
lds->lds_dir_def_striping_set) &&
*/
if (likely(lp != NULL)) {
rc = lod_get_default_lov_striping(env, lp, lds, ah);
- if (rc == 0)
- lod_striping_from_default(lc, lds, child_mode);
+ if (rc == 0 && lds->lds_def_striping_set) {
+ rc = lod_verify_striping(env, d, lp, &info->lti_buf,
+ false);
+ if (rc == 0)
+ lod_striping_from_default(lc, lds, child_mode);
+ }
}
/* Initialize lod_device::lod_md_root object reference */
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 || !lds->lds_def_striping_set)
+ goto out;
+
+ rc = lod_verify_striping(env, d, d->lod_md_root, &info->lti_buf,
+ false);
if (rc)
goto out;
+
if (lc->ldo_comp_cnt == 0) {
lod_striping_from_default(lc, lds, child_mode);
} else if (!lds->lds_def_striping_is_composite) {
if (OBD_FAIL_CHECK(OBD_FAIL_MDS_STALE_DIR_LAYOUT))
GOTO(out, rc = -EREMOTE);
- if (lo->ldo_dir_stripe_offset == LMV_OFFSET_DEFAULT) {
- struct lod_default_striping *lds;
-
- lds = lo->ldo_def_striping;
- /*
- * child and parent should be on the same MDT,
- * but if parent has default LMV, and the start
- * MDT offset is -1, it's allowed. This check
- * is not necessary after 2.12.22 because client
- * follows this already, but old client may not.
- */
- if (hint->dah_parent &&
- dt_object_remote(hint->dah_parent) && lds &&
- lds->lds_dir_def_stripe_offset !=
- LMV_OFFSET_DEFAULT)
- GOTO(out, rc = -EREMOTE);
- } else if (lo->ldo_dir_stripe_offset !=
- ss->ss_node_id) {
+ if (lo->ldo_dir_stripe_offset != LMV_OFFSET_DEFAULT &&
+ lo->ldo_dir_stripe_offset != ss->ss_node_id) {
struct lod_device *lod;
struct lu_tgt_desc *mdt = NULL;
bool found_mdt = false;
int rc = 0, i, j;
ENTRY;
+ mutex_lock(&lo->ldo_layout_mutex);
+
LASSERT((lo->ldo_comp_cnt != 0 && lo->ldo_comp_entries != NULL) ||
lo->ldo_is_foreign);
if (rc)
GOTO(out, rc);
+ lo->ldo_comp_cached = 1;
+
rc = lod_generate_and_set_lovea(env, lo, th);
if (rc)
GOTO(out, rc);
- lo->ldo_comp_cached = 1;
+ mutex_unlock(&lo->ldo_layout_mutex);
+
RETURN(0);
out:
- lod_striping_free(env, lo);
+ lod_striping_free_nolock(env, lo);
+ mutex_unlock(&lo->ldo_layout_mutex);
+
RETURN(rc);
}
{
if (data->locd_declare)
return lod_sub_declare_destroy(env, dt, th);
- else if (!OBD_FAIL_CHECK(OBD_FAIL_LFSCK_LOST_SPEOBJ) ||
- stripe_idx == cfs_fail_val)
+
+ if (!OBD_FAIL_CHECK(OBD_FAIL_LFSCK_LOST_SPEOBJ) ||
+ stripe_idx == cfs_fail_val)
return lod_sub_destroy(env, dt, th);
return 0;
* cluster.
*/
lod_qos_statfs_update(env, lod, &lod->lod_ost_descs);
+
+ rc = lod_fill_mirrors(lo);
+ if (rc)
+ RETURN(rc);
+
for (i = 0; i < lo->ldo_mirror_count; i++) {
bool ost_avail = true;
int index = (i + seq) % lo->ldo_mirror_count;
}
/* 2nd pick is for the primary mirror containing unavail OST */
- if (lo->ldo_mirrors[index].lme_primary && second_pick < 0)
+ if (lo->ldo_mirrors[index].lme_prefer && second_pick < 0)
second_pick = index;
/* 3rd pick is for non-primary mirror containing unavail OST */
* we found a non-primary 1st pick, we'd like to find a
* potential pirmary mirror.
*/
- if (picked >= 0 && !lo->ldo_mirrors[index].lme_primary)
+ if (picked >= 0 && !lo->ldo_mirrors[index].lme_prefer)
continue;
/* check the availability of OSTs */
* primary with all OSTs are available, this is the perfect
* 1st pick.
*/
- if (lo->ldo_mirrors[index].lme_primary)
+ if (lo->ldo_mirrors[index].lme_prefer)
break;
} /* for all mirrors */
LASSERT(mlc->mlc_opc == MD_LAYOUT_WRITE ||
mlc->mlc_opc == MD_LAYOUT_RESYNC);
- /* look for the primary mirror */
+ /* look for the first preferred mirror */
for (i = 0; i < lo->ldo_mirror_count; i++) {
if (lo->ldo_mirrors[i].lme_stale)
continue;
- if (lo->ldo_mirrors[i].lme_primary == 0)
+ if (lo->ldo_mirrors[i].lme_prefer == 0)
continue;
- if (unlikely(primary >= 0)) {
- CERROR(DFID " has multiple primary: %u / %u\n",
- PFID(lod_object_fid(lo)),
- lo->ldo_mirrors[i].lme_id,
- lo->ldo_mirrors[primary].lme_id);
- RETURN(-EIO);
- }
-
primary = i;
+ break;
}
if (primary < 0) {
/* no primary, use any in-sync */
struct thandle *th)
{
struct lod_thread_info *info = lod_env_info(env);
+ struct lu_attr *layout_attr = &info->lti_layout_attr;
unsigned sync_components = 0;
unsigned resync_components = 0;
int i;
lo->ldo_flr_state = LCM_FL_RDONLY;
lod_obj_inc_layout_gen(lo);
+ layout_attr->la_valid = LA_LAYOUT_VERSION;
+ layout_attr->la_layout_version = 0; /* set current version */
+ rc = lod_declare_attr_set(env, &lo->ldo_obj, layout_attr, th);
+ if (rc)
+ GOTO(out, rc);
+
info->lti_buf.lb_len = lod_comp_md_size(lo, false);
rc = lod_sub_declare_xattr_set(env, lod_object_child(lo),
&info->lti_buf, XATTR_NAME_LOV, 0, th);
struct lod_object *lo = lod_dt_obj(dt);
struct dt_object *next = dt_object_child(dt);
struct lmv_user_md *lmu = mlc->mlc_buf.lb_buf;
- __u32 final_stripe_count;
char *stripe_name = info->lti_key;
struct lu_buf *lmv_buf = &info->lti_buf;
+ __u32 final_stripe_count;
struct dt_object *dto;
int i;
int rc;
continue;
if (i < final_stripe_count) {
- if (final_stripe_count == 1)
- continue;
-
rc = lod_sub_declare_xattr_set(env, dto, lmv_buf,
XATTR_NAME_LMV,
LU_XATTR_REPLACE, th);
lmv->lmv_magic = cpu_to_le32(LMV_MAGIC_STRIPE);
lmv->lmv_stripe_count = cpu_to_le32(final_stripe_count);
lmv->lmv_hash_type = cpu_to_le32(lo->ldo_dir_hash_type) &
- cpu_to_le32(LMV_HASH_TYPE_MASK);
+ cpu_to_le32(LMV_HASH_TYPE_MASK |
+ LMV_HASH_FLAG_FIXED);
lmv->lmv_layout_version =
cpu_to_le32(lo->ldo_dir_layout_version + 1);
+ lmv->lmv_migrate_offset = 0;
+ lmv->lmv_migrate_hash = 0;
for (i = 0; i < lo->ldo_dir_stripe_count; i++) {
dto = lo->ldo_stripe[i];
continue;
if (i < final_stripe_count) {
- /* if only one stripe left, no need to update
- * LMV because this stripe will replace master
- * object and act as a plain directory.
- */
- if (final_stripe_count == 1)
- continue;
-
-
rc = lod_fld_lookup(env, lod,
lu_object_fid(&dto->do_lu),
&mdtidx, &type);
git://git.whamcloud.com / fs / lustre-release.git / blobdiff