X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Flod%2Flod_object.c;h=02c14c21af2db221a9e1ab8760cbb35a0c10daf2;hb=e88992a3b5b9d9ba0a69883671f1b5888514e05d;hp=8fa06a6567fea51cc67d7129609ac20c74cbb740;hpb=040179b84330689b1b2cd128dcdd711bfc8f0b4e;p=fs%2Flustre-release.git

diff --git a/lustre/lod/lod_object.c b/lustre/lod/lod_object.c
index 8fa06a6..02c14c2 100644
--- a/lustre/lod/lod_object.c
+++ b/lustre/lod/lod_object.c
@@ -23,7 +23,7 @@
  * Copyright  2009 Sun Microsystems, Inc. All rights reserved
  * Use is subject to license terms.
  *
- * Copyright (c) 2012, Intel Corporation.
+ * Copyright (c) 2012, 2013, Intel Corporation.
  */
 /*
  * lustre/lod/lod_object.c
@@ -31,9 +31,6 @@
  * Author: Alex Zhuravlev <alexey.zhuravlev@intel.com>
  */
 
-#ifndef EXPORT_SYMTAB
-# define EXPORT_SYMTAB
-#endif
 #define DEBUG_SUBSYSTEM S_MDS
 
 #include <obd.h>
@@ -45,11 +42,16 @@
 #include <lustre_fid.h>
 #include <lustre_param.h>
 #include <lustre_fid.h>
+#include <lustre_lmv.h>
 #include <obd_lov.h>
+#include <md_object.h>
 
 #include "lod_internal.h"
 
-extern cfs_mem_cache_t *lod_object_kmem;
+static const char dot[] = ".";
+static const char dotdot[] = "..";
+
+extern struct kmem_cache *lod_object_kmem;
 static const struct dt_body_operations lod_body_lnk_ops;
 
 static int lod_index_lookup(const struct lu_env *env, struct dt_object *dt,
@@ -298,9 +300,17 @@ static int lod_declare_attr_set(const struct lu_env *env,
 	 * Therefore we need not load striping unless ownership is
 	 * changing.  This should save memory and (we hope) speed up
 	 * rename(). */
-	if (!(attr->la_valid & (LA_UID | LA_GID)))
-		RETURN(rc);
+	if (!S_ISDIR(dt->do_lu.lo_header->loh_attr)) {
+		if (!(attr->la_valid & (LA_UID | LA_GID)))
+			RETURN(rc);
 
+		if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_BAD_OWNER))
+			RETURN(0);
+	} else {
+		if (!(attr->la_valid & (LA_UID | LA_GID | LA_MODE |
+					LA_ATIME | LA_MTIME | LA_CTIME)))
+			RETURN(rc);
+	}
 	/*
 	 * load striping information, notice we don't do this when object
 	 * is being initialized as we don't need this information till
@@ -310,12 +320,38 @@ static int lod_declare_attr_set(const struct lu_env *env,
 	if (rc)
 		RETURN(rc);
 
+	if (lo->ldo_stripenr == 0)
+		RETURN(0);
+
+	if (!(attr->la_valid & ~(LA_ATIME | LA_MTIME | LA_CTIME))) {
+		struct lu_attr	 *la = &lod_env_info(env)->lti_attr;
+		bool		 setattr_time = false;
+
+		rc = dt_attr_get(env, dt_object_child(dt), la,
+				 BYPASS_CAPA);
+		if (rc != 0)
+			RETURN(rc);
+
+		/* If it will only setattr time, it will only set
+		 * time < current_time */
+		if ((attr->la_valid & LA_ATIME &&
+		     attr->la_atime < la->la_atime) ||
+		    (attr->la_valid & LA_CTIME &&
+		     attr->la_ctime < la->la_ctime) ||
+		    (attr->la_valid & LA_MTIME &&
+		     attr->la_mtime < la->la_mtime))
+			setattr_time = true;
+
+		if (!setattr_time)
+			RETURN(0);
+	}
 	/*
 	 * if object is striped declare changes on the stripes
 	 */
-	LASSERT(lo->ldo_stripe || lo->ldo_stripenr == 0);
+	LASSERT(lo->ldo_stripe);
 	for (i = 0; i < lo->ldo_stripenr; i++) {
 		LASSERT(lo->ldo_stripe[i]);
+
 		rc = dt_declare_attr_set(env, lo->ldo_stripe[i], attr, handle);
 		if (rc) {
 			CERROR("failed declaration: %d\n", rc);
@@ -323,6 +359,23 @@ static int lod_declare_attr_set(const struct lu_env *env,
 		}
 	}
 
+	if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_LOST_STRIPE) &&
+	    dt_object_exists(next) != 0 &&
+	    dt_object_remote(next) == 0)
+		dt_declare_xattr_del(env, next, XATTR_NAME_LOV, handle);
+
+	if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_CHANGE_STRIPE) &&
+	    dt_object_exists(next) &&
+	    dt_object_remote(next) == 0 && S_ISREG(attr->la_mode)) {
+		struct lod_thread_info *info = lod_env_info(env);
+		struct lu_buf *buf = &info->lti_buf;
+
+		buf->lb_buf = info->lti_ea_store;
+		buf->lb_len = info->lti_ea_store_size;
+		dt_declare_xattr_set(env, next, buf, XATTR_NAME_LOV,
+				     LU_XATTR_REPLACE, handle);
+	}
+
 	RETURN(rc);
 }
 
@@ -344,13 +397,48 @@ static int lod_attr_set(const struct lu_env *env,
 	if (rc)
 		RETURN(rc);
 
-	if (!(attr->la_valid & (LA_UID | LA_GID)))
-		RETURN(rc);
+	if (!S_ISDIR(dt->do_lu.lo_header->loh_attr)) {
+		if (!(attr->la_valid & (LA_UID | LA_GID)))
+			RETURN(rc);
+
+		if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_BAD_OWNER))
+			RETURN(0);
+	} else {
+		if (!(attr->la_valid & (LA_UID | LA_GID | LA_MODE |
+					LA_ATIME | LA_MTIME | LA_CTIME)))
+			RETURN(rc);
+	}
+
+	if (lo->ldo_stripenr == 0)
+		RETURN(0);
+
+	if (!(attr->la_valid & ~(LA_ATIME | LA_MTIME | LA_CTIME))) {
+		struct lu_attr	 *la = &lod_env_info(env)->lti_attr;
+		bool		 setattr_time = false;
+
+		rc = dt_attr_get(env, dt_object_child(dt), la,
+				 BYPASS_CAPA);
+		if (rc != 0)
+			RETURN(rc);
+
+		/* If it will only setattr time, it will only set
+		 * time < current_time */
+		if ((attr->la_valid & LA_ATIME &&
+		     attr->la_atime < la->la_atime) ||
+		    (attr->la_valid & LA_CTIME &&
+		     attr->la_ctime < la->la_ctime) ||
+		    (attr->la_valid & LA_MTIME &&
+		     attr->la_mtime < la->la_mtime))
+			setattr_time = true;
+
+		if (!setattr_time)
+			RETURN(0);
+	}
 
 	/*
 	 * if object is striped, apply changes to all the stripes
 	 */
-	LASSERT(lo->ldo_stripe || lo->ldo_stripenr == 0);
+	LASSERT(lo->ldo_stripe);
 	for (i = 0; i < lo->ldo_stripenr; i++) {
 		LASSERT(lo->ldo_stripe[i]);
 		rc = dt_attr_set(env, lo->ldo_stripe[i], attr, handle, capa);
@@ -360,6 +448,44 @@ static int lod_attr_set(const struct lu_env *env,
 		}
 	}
 
+	if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_LOST_STRIPE) &&
+	    dt_object_exists(next) != 0 &&
+	    dt_object_remote(next) == 0)
+		dt_xattr_del(env, next, XATTR_NAME_LOV, handle, BYPASS_CAPA);
+
+	if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_CHANGE_STRIPE) &&
+	    dt_object_exists(next) &&
+	    dt_object_remote(next) == 0 && S_ISREG(attr->la_mode)) {
+		struct lod_thread_info *info = lod_env_info(env);
+		struct lu_buf *buf = &info->lti_buf;
+		struct ost_id *oi = &info->lti_ostid;
+		struct lu_fid *fid = &info->lti_fid;
+		struct lov_mds_md_v1 *lmm;
+		struct lov_ost_data_v1 *objs;
+		__u32 magic;
+		int rc1;
+
+		rc1 = lod_get_lov_ea(env, lo);
+		if (rc1  <= 0)
+			RETURN(rc);
+
+		buf->lb_buf = info->lti_ea_store;
+		buf->lb_len = info->lti_ea_store_size;
+		lmm = info->lti_ea_store;
+		magic = le32_to_cpu(lmm->lmm_magic);
+		if (magic == LOV_MAGIC_V1)
+			objs = &(lmm->lmm_objects[0]);
+		else
+			objs = &((struct lov_mds_md_v3 *)lmm)->lmm_objects[0];
+		ostid_le_to_cpu(&objs->l_ost_oi, oi);
+		ostid_to_fid(fid, oi, le32_to_cpu(objs->l_ost_idx));
+		fid->f_oid--;
+		fid_to_ostid(fid, oi);
+		ostid_cpu_to_le(oi, &objs->l_ost_oi);
+		dt_xattr_set(env, next, buf, XATTR_NAME_LOV,
+			     LU_XATTR_REPLACE, handle, BYPASS_CAPA);
+	}
+
 	RETURN(rc);
 }
 
@@ -390,15 +516,20 @@ static int lod_xattr_get(const struct lu_env *env, struct dt_object *dt,
 		struct lov_desc    *desc = &dev->lod_desc;
 
 		if (buf->lb_buf == NULL) {
-			rc = sizeof(struct lov_user_md_v1);
-		} else if (buf->lb_len >= sizeof(struct lov_user_md_v1)) {
-			lum->lmm_magic = LOV_USER_MAGIC_V1;
-			ostid_set_seq(&lum->lmm_oi, FID_SEQ_LOV_DEFAULT);
-			lum->lmm_pattern = desc->ld_pattern;
-			lum->lmm_stripe_size = desc->ld_default_stripe_size;
-			lum->lmm_stripe_count = desc->ld_default_stripe_count;
-			lum->lmm_stripe_offset = desc->ld_default_stripe_offset;
-			rc = sizeof(struct lov_user_md_v1);
+			rc = sizeof(*lum);
+		} else if (buf->lb_len >= sizeof(*lum)) {
+			lum->lmm_magic = cpu_to_le32(LOV_USER_MAGIC_V1);
+			lmm_oi_set_seq(&lum->lmm_oi, FID_SEQ_LOV_DEFAULT);
+			lmm_oi_set_id(&lum->lmm_oi, 0);
+			lmm_oi_cpu_to_le(&lum->lmm_oi, &lum->lmm_oi);
+			lum->lmm_pattern = cpu_to_le32(desc->ld_pattern);
+			lum->lmm_stripe_size = cpu_to_le32(
+						desc->ld_default_stripe_size);
+			lum->lmm_stripe_count = cpu_to_le16(
+						desc->ld_default_stripe_count);
+			lum->lmm_stripe_offset = cpu_to_le16(
+						desc->ld_default_stripe_offset);
+			rc = sizeof(*lum);
 		} else {
 			rc = -ERANGE;
 		}
@@ -407,6 +538,393 @@ static int lod_xattr_get(const struct lu_env *env, struct dt_object *dt,
 	RETURN(rc);
 }
 
+static int lod_verify_md_striping(struct lod_device *lod,
+				  const struct lmv_user_md_v1 *lum)
+{
+	int	rc = 0;
+	ENTRY;
+
+	if (unlikely(le32_to_cpu(lum->lum_magic) != LMV_USER_MAGIC))
+		GOTO(out, rc = -EINVAL);
+
+	if (unlikely(le32_to_cpu(lum->lum_stripe_count) == 0))
+		GOTO(out, rc = -EINVAL);
+
+	if (unlikely(le32_to_cpu(lum->lum_stripe_count) >
+				lod->lod_remote_mdt_count + 1))
+		GOTO(out, rc = -EINVAL);
+out:
+	if (rc != 0)
+		CERROR("%s: invalid lmv_user_md: magic = %x, "
+		       "stripe_offset = %d, stripe_count = %u: rc = %d\n",
+		       lod2obd(lod)->obd_name, le32_to_cpu(lum->lum_magic),
+		       (int)le32_to_cpu(lum->lum_stripe_offset),
+		       le32_to_cpu(lum->lum_stripe_count), rc);
+	return rc;
+}
+
+int lod_prep_lmv_md(const struct lu_env *env, struct dt_object *dt,
+		    struct lu_buf *lmv_buf)
+{
+	struct lod_thread_info	*info = lod_env_info(env);
+	struct lod_device	*lod = lu2lod_dev(dt->do_lu.lo_dev);
+	struct lod_object	*lo = lod_dt_obj(dt);
+	struct lmv_mds_md_v1	*lmm1;
+	int			stripe_count;
+	int			lmm_size;
+	int			type = LU_SEQ_RANGE_ANY;
+	int			i;
+	int			rc;
+	__u32			mdtidx;
+	ENTRY;
+
+	LASSERT(lo->ldo_dir_striped != 0);
+	LASSERT(lo->ldo_stripenr > 0);
+	stripe_count = lo->ldo_stripenr + 1;
+	lmm_size = lmv_mds_md_size(stripe_count, LMV_MAGIC);
+	if (info->lti_ea_store_size < lmm_size) {
+		rc = lod_ea_store_resize(info, lmm_size);
+		if (rc != 0)
+			RETURN(rc);
+	}
+
+	lmm1 = (struct lmv_mds_md_v1 *)info->lti_ea_store;
+	lmm1->lmv_magic = cpu_to_le32(LMV_MAGIC);
+	lmm1->lmv_stripe_count = cpu_to_le32(stripe_count);
+	lmm1->lmv_hash_type = cpu_to_le32(lo->ldo_dir_hash_type);
+	rc = lod_fld_lookup(env, lod, lu_object_fid(&dt->do_lu),
+			    &mdtidx, &type);
+	if (rc != 0)
+		RETURN(rc);
+
+	lmm1->lmv_master_mdt_index = cpu_to_le32(mdtidx);
+	fid_cpu_to_le(&lmm1->lmv_stripe_fids[0], lu_object_fid(&dt->do_lu));
+	for (i = 0; i < lo->ldo_stripenr; i++) {
+		struct dt_object *dto;
+
+		dto = lo->ldo_stripe[i];
+		LASSERT(dto != NULL);
+		fid_cpu_to_le(&lmm1->lmv_stripe_fids[i + 1],
+			      lu_object_fid(&dto->do_lu));
+	}
+
+	lmv_buf->lb_buf = info->lti_ea_store;
+	lmv_buf->lb_len = lmm_size;
+	lo->ldo_dir_striping_cached = 1;
+
+	RETURN(rc);
+}
+
+int lod_parse_dir_striping(const struct lu_env *env, struct lod_object *lo,
+			   const struct lu_buf *buf)
+{
+	struct lod_thread_info	*info = lod_env_info(env);
+	struct lod_device	*lod = lu2lod_dev(lo->ldo_obj.do_lu.lo_dev);
+	struct lod_tgt_descs	*ltd = &lod->lod_mdt_descs;
+	struct dt_object	**stripe;
+	union lmv_mds_md	*lmm = buf->lb_buf;
+	struct lmv_mds_md_v1	*lmv1 = &lmm->lmv_md_v1;
+	struct lu_fid		*fid = &info->lti_fid;
+	int			i;
+	int			rc = 0;
+	ENTRY;
+
+	if (le32_to_cpu(lmv1->lmv_magic) == LMV_MAGIC_MIGRATE)
+		RETURN(0);
+
+	if (le32_to_cpu(lmv1->lmv_magic) != LMV_MAGIC_V1)
+		RETURN(-EINVAL);
+
+	if (le32_to_cpu(lmv1->lmv_stripe_count) <= 1)
+		RETURN(0);
+
+	fid_le_to_cpu(fid, &lmv1->lmv_stripe_fids[0]);
+	/* Do not load striping information for slave inode */
+	if (!lu_fid_eq(fid, lu_object_fid(&lo->ldo_obj.do_lu))) {
+		lo->ldo_dir_slave_stripe = 1;
+		RETURN(0);
+	}
+
+	LASSERT(lo->ldo_stripe == NULL);
+	OBD_ALLOC(stripe, sizeof(stripe[0]) *
+		  (le32_to_cpu(lmv1->lmv_stripe_count) - 1));
+	if (stripe == NULL)
+		RETURN(-ENOMEM);
+
+	/* skip master stripe */
+	for (i = 1; i < le32_to_cpu(lmv1->lmv_stripe_count); i++) {
+		struct lod_tgt_desc	*tgt;
+		int			idx;
+		int			type = LU_SEQ_RANGE_ANY;
+		struct dt_object	*dto;
+
+		fid_le_to_cpu(fid, &lmv1->lmv_stripe_fids[i]);
+		rc = lod_fld_lookup(env, lod, fid, &idx, &type);
+		if (rc != 0)
+			GOTO(out, rc);
+
+		tgt = LTD_TGT(ltd, idx);
+		if (tgt == NULL)
+			GOTO(out, rc = -ESTALE);
+
+		dto = dt_locate_at(env, tgt->ltd_tgt, fid,
+				  lo->ldo_obj.do_lu.lo_dev->ld_site->ls_top_dev,
+				  NULL);
+		if (IS_ERR(dto))
+			GOTO(out, rc = PTR_ERR(dto));
+
+		stripe[i - 1] = dto;
+	}
+out:
+	lo->ldo_stripe = stripe;
+	lo->ldo_stripenr = le32_to_cpu(lmv1->lmv_stripe_count) - 1;
+	lo->ldo_stripes_allocated = le32_to_cpu(lmv1->lmv_stripe_count) - 1;
+	if (rc != 0)
+		lod_object_free_striping(env, lo);
+
+	RETURN(rc);
+}
+
+static int lod_prep_md_striped_create(const struct lu_env *env,
+				      struct dt_object *dt,
+				      struct lu_attr *attr,
+				      const struct lmv_user_md_v1 *lum,
+				      struct thandle *th)
+{
+	struct lod_device	*lod = lu2lod_dev(dt->do_lu.lo_dev);
+	struct lod_tgt_descs	*ltd = &lod->lod_mdt_descs;
+	struct lod_object	*lo = lod_dt_obj(dt);
+	struct dt_object	**stripe;
+	struct lu_buf		lmv_buf;
+	int			stripe_count;
+	int			*idx_array;
+	int			rc = 0;
+	int			i;
+	int			j;
+	ENTRY;
+
+	/* The lum has been verifed in lod_verify_md_striping */
+	LASSERT(le32_to_cpu(lum->lum_magic) == LMV_USER_MAGIC);
+	LASSERT(le32_to_cpu(lum->lum_stripe_count) > 0);
+
+	/* Do not need allocated master stripe */
+	stripe_count = le32_to_cpu(lum->lum_stripe_count);
+	OBD_ALLOC(stripe, sizeof(stripe[0]) * (stripe_count - 1));
+	if (stripe == NULL)
+		RETURN(-ENOMEM);
+
+	OBD_ALLOC(idx_array, sizeof(idx_array[0]) * stripe_count);
+	if (idx_array == NULL)
+		GOTO(out_free, rc = -ENOMEM);
+
+	idx_array[0] = le32_to_cpu(lum->lum_stripe_offset);
+	for (i = 1; i < stripe_count; i++) {
+		struct lod_tgt_desc	*tgt;
+		struct dt_object	*dto;
+		struct lu_fid		fid;
+		int			idx;
+		struct lu_object_conf	conf = { 0 };
+
+		idx = (idx_array[i - 1] + 1) % (lod->lod_remote_mdt_count + 1);
+
+		for (j = 0; j < lod->lod_remote_mdt_count;
+		     j++, idx = (idx + 1) % (lod->lod_remote_mdt_count + 1)) {
+			bool already_allocated = false;
+			int k;
+
+			CDEBUG(D_INFO, "try idx %d, mdt cnt %d,"
+			       " allocated %d, last allocated %d\n", idx,
+			       lod->lod_remote_mdt_count, i, idx_array[i - 1]);
+
+			/* Find next avaible target */
+			if (!cfs_bitmap_check(ltd->ltd_tgt_bitmap, idx))
+				continue;
+
+			/* check whether the idx already exists
+			 * in current allocated array */
+			for (k = 0; k < i; k++) {
+				if (idx_array[k] == idx) {
+					already_allocated = true;
+					break;
+				}
+			}
+
+			if (already_allocated)
+				continue;
+
+			break;
+		}
+
+		/* Can not allocate more stripes */
+		if (j == lod->lod_remote_mdt_count) {
+			CDEBUG(D_INFO, "%s: require stripes %d only get %d\n",
+			       lod2obd(lod)->obd_name, stripe_count, i - 1);
+			break;
+		}
+
+		CDEBUG(D_INFO, "idx %d, mdt cnt %d,"
+		       " allocated %d, last allocated %d\n", idx,
+		       lod->lod_remote_mdt_count, i, idx_array[i - 1]);
+
+		tgt = LTD_TGT(ltd, idx);
+		LASSERT(tgt != NULL);
+
+		rc = obd_fid_alloc(tgt->ltd_exp, &fid, NULL);
+		if (rc < 0)
+			GOTO(out_put, rc);
+		rc = 0;
+
+		conf.loc_flags = LOC_F_NEW;
+		dto = dt_locate_at(env, tgt->ltd_tgt, &fid,
+				  dt->do_lu.lo_dev->ld_site->ls_top_dev, &conf);
+		if (IS_ERR(dto))
+			GOTO(out_put, rc = PTR_ERR(dto));
+		stripe[i - 1] = dto;
+		idx_array[i] = idx;
+	}
+
+	lo->ldo_dir_striped = 1;
+	lo->ldo_stripe = stripe;
+	lo->ldo_stripenr = i - 1;
+	lo->ldo_stripes_allocated = stripe_count - 1;
+
+	if (lo->ldo_stripenr == 0)
+		GOTO(out_put, rc = -ENOSPC);
+
+	rc = lod_prep_lmv_md(env, dt, &lmv_buf);
+	if (rc != 0)
+		GOTO(out_put, rc);
+
+	for (i = 0; i < lo->ldo_stripenr; i++) {
+		struct dt_object *dto;
+
+		dto = stripe[i];
+		/* only create slave striped object */
+		rc = dt_declare_create(env, dto, attr, NULL, NULL, th);
+		if (rc != 0)
+			GOTO(out_put, rc);
+
+		if (!dt_try_as_dir(env, dto))
+			GOTO(out_put, rc = -EINVAL);
+
+		rc = dt_declare_insert(env, dto,
+		     (const struct dt_rec *)lu_object_fid(&dto->do_lu),
+		     (const struct dt_key *)dot, th);
+		if (rc != 0)
+			GOTO(out_put, rc);
+
+		/* master stripe FID will be put to .. */
+		rc = dt_declare_insert(env, dto,
+		     (const struct dt_rec *)lu_object_fid(&dt->do_lu),
+		     (const struct dt_key *)dotdot, th);
+		if (rc != 0)
+			GOTO(out_put, rc);
+
+		/* probably nothing to inherite */
+		if (lo->ldo_striping_cached &&
+		    !LOVEA_DELETE_VALUES(lo->ldo_def_stripe_size,
+					 lo->ldo_def_stripenr,
+					 lo->ldo_def_stripe_offset)) {
+			struct lod_thread_info	*info;
+			struct lov_user_md_v3	*v3;
+
+			/* sigh, lti_ea_store has been used for lmv_buf,
+			 * so we have to allocate buffer for default
+			 * stripe EA */
+			OBD_ALLOC_PTR(v3);
+			if (v3 == NULL)
+				GOTO(out_put, rc = -ENOMEM);
+
+			memset(v3, 0, sizeof(*v3));
+			v3->lmm_magic = cpu_to_le32(LOV_USER_MAGIC_V3);
+			v3->lmm_stripe_count =
+				cpu_to_le32(lo->ldo_def_stripenr);
+			v3->lmm_stripe_offset =
+				cpu_to_le32(lo->ldo_def_stripe_offset);
+			v3->lmm_stripe_size =
+				cpu_to_le32(lo->ldo_def_stripe_size);
+			if (lo->ldo_pool)
+				strncpy(v3->lmm_pool_name, lo->ldo_pool,
+					LOV_MAXPOOLNAME);
+
+			info = lod_env_info(env);
+			info->lti_buf.lb_buf = v3;
+			info->lti_buf.lb_len = sizeof(*v3);
+			rc = dt_declare_xattr_set(env, dto,
+						  &info->lti_buf,
+						  XATTR_NAME_LOV,
+						  0, th);
+			OBD_FREE_PTR(v3);
+			if (rc != 0)
+				GOTO(out_put, rc);
+		}
+		rc = dt_declare_xattr_set(env, dto, &lmv_buf, XATTR_NAME_LMV, 0,
+					  th);
+		if (rc != 0)
+			GOTO(out_put, rc);
+	}
+
+	rc = dt_declare_xattr_set(env, dt_object_child(dt), &lmv_buf,
+				  XATTR_NAME_LMV, 0, th);
+	if (rc != 0)
+		GOTO(out_put, rc);
+
+out_put:
+	if (rc < 0) {
+		for (i = 0; i < stripe_count - 1; i++)
+			if (stripe[i] != NULL)
+				lu_object_put(env, &stripe[i]->do_lu);
+		OBD_FREE(stripe, sizeof(stripe[0]) * (stripe_count - 1));
+	}
+
+out_free:
+	if (idx_array != NULL)
+		OBD_FREE(idx_array, sizeof(idx_array[0]) * stripe_count);
+
+	RETURN(rc);
+}
+
+/**
+ * Declare create striped md object.
+ */
+static int lod_declare_xattr_set_lmv(const struct lu_env *env,
+				     struct dt_object *dt,
+				     struct lu_attr *attr,
+				     const struct lu_buf *lum_buf,
+				     struct thandle *th)
+{
+	struct lod_object	*lo = lod_dt_obj(dt);
+	struct lod_device	*lod = lu2lod_dev(dt->do_lu.lo_dev);
+	struct lmv_user_md_v1	*lum;
+	int			rc;
+	ENTRY;
+
+	lum = lum_buf->lb_buf;
+	LASSERT(lum != NULL);
+
+	CDEBUG(D_INFO, "lum magic = %x count = %u offset = %d\n",
+	       le32_to_cpu(lum->lum_magic), le32_to_cpu(lum->lum_stripe_count),
+	       (int)le32_to_cpu(lum->lum_stripe_offset));
+
+	if (le32_to_cpu(lum->lum_stripe_count) <= 1)
+		GOTO(out, rc = 0);
+
+	rc = lod_verify_md_striping(lod, lum);
+	if (rc != 0)
+		GOTO(out, rc);
+
+	/* prepare dir striped objects */
+	rc = lod_prep_md_striped_create(env, dt, attr, lum, th);
+	if (rc != 0) {
+		/* failed to create striping, let's reset
+		 * config so that others don't get confused */
+		lod_object_free_striping(env, lo);
+		GOTO(out, rc);
+	}
+out:
+	RETURN(rc);
+}
+
 /*
  * LOV xattr is a storage for striping, and LOD owns this xattr.
  * but LOD allows others to control striping to some extent
@@ -436,7 +954,7 @@ static int lod_declare_xattr_set(const struct lu_env *env,
 	 * LU_XATTR_REPLACE is set to indicate a layout swap
 	 */
 	mode = dt->do_lu.lo_header->loh_attr & S_IFMT;
-	if ((S_ISREG(mode) || !mode) && !strcmp(name, XATTR_NAME_LOV) &&
+	if ((S_ISREG(mode) || mode == 0) && strcmp(name, XATTR_NAME_LOV) == 0 &&
 	     !(fl & LU_XATTR_REPLACE)) {
 		/*
 		 * this is a request to manipulate object's striping
@@ -451,15 +969,56 @@ static int lod_declare_xattr_set(const struct lu_env *env,
 			attr->la_mode = S_IFREG;
 		}
 		rc = lod_declare_striped_object(env, dt, attr, buf, th);
-		if (rc)
+	} else if (S_ISDIR(mode)) {
+		struct lod_device	*d = lu2lod_dev(dt->do_lu.lo_dev);
+		struct lod_object	*lo = lod_dt_obj(dt);
+		int			i;
+
+		if (strcmp(name, XATTR_NAME_DEFAULT_LMV) == 0) {
+			struct lmv_user_md_v1 *lum;
+
+			LASSERT(buf != NULL && buf->lb_buf != NULL);
+			lum = buf->lb_buf;
+			rc = lod_verify_md_striping(d, lum);
+			if (rc != 0)
+				RETURN(rc);
+		}
+
+		rc = dt_declare_xattr_set(env, next, buf, name, fl, th);
+		if (rc != 0)
+			RETURN(rc);
+
+		/* set xattr to each stripes, if needed */
+		rc = lod_load_striping(env, lo);
+		if (rc != 0)
 			RETURN(rc);
-	}
 
-	rc = dt_declare_xattr_set(env, next, buf, name, fl, th);
+		if (lo->ldo_stripenr == 0)
+			RETURN(rc);
+
+		for (i = 0; i < lo->ldo_stripenr; i++) {
+			LASSERT(lo->ldo_stripe[i]);
+			rc = dt_declare_xattr_set(env, lo->ldo_stripe[i], buf,
+						  name, fl, th);
+			if (rc != 0)
+				break;
+		}
+	} else {
+		rc = dt_declare_xattr_set(env, next, buf, name, fl, th);
+	}
 
 	RETURN(rc);
 }
 
+static void lod_lov_stripe_cache_clear(struct lod_object *lo)
+{
+	lo->ldo_striping_cached = 0;
+	lo->ldo_def_striping_set = 0;
+	lod_object_set_pool(lo, NULL);
+	lo->ldo_def_stripe_size = 0;
+	lo->ldo_def_stripenr = 0;
+}
+
 static int lod_xattr_set_lov_on_dir(const struct lu_env *env,
 				    struct dt_object *dt,
 				    const struct lu_buf *buf,
@@ -475,15 +1034,12 @@ static int lod_xattr_set_lov_on_dir(const struct lu_env *env,
 	int			 rc;
 	ENTRY;
 
-	LASSERT(l->ldo_stripe == NULL);
-	l->ldo_striping_cached = 0;
-	l->ldo_def_striping_set = 0;
-	lod_object_set_pool(l, NULL);
-	l->ldo_def_stripe_size = 0;
-	l->ldo_def_stripenr = 0;
-
-	LASSERT(buf);
-	LASSERT(buf->lb_buf);
+	/* If it is striped dir, we should clear the stripe cache for
+	 * slave stripe as well, but there are no effective way to
+	 * notify the LOD on the slave MDT, so we do not cache stripe
+	 * information for slave stripe for now. XXX*/
+	lod_lov_stripe_cache_clear(l);
+	LASSERT(buf != NULL && buf->lb_buf != NULL);
 	lum = buf->lb_buf;
 
 	rc = lod_verify_striping(d, buf, 0);
@@ -517,24 +1073,161 @@ static int lod_xattr_set_lov_on_dir(const struct lu_env *env,
 	RETURN(rc);
 }
 
+static int lod_xattr_set_default_lmv_on_dir(const struct lu_env *env,
+					    struct dt_object *dt,
+					    const struct lu_buf *buf,
+					    const char *name, int fl,
+					    struct thandle *th,
+					    struct lustre_capa *capa)
+{
+	struct dt_object	*next = dt_object_child(dt);
+	struct lod_object	*l = lod_dt_obj(dt);
+	struct lmv_user_md_v1	*lum;
+	int			 rc;
+	ENTRY;
+
+	LASSERT(buf != NULL && buf->lb_buf != NULL);
+	lum = buf->lb_buf;
+
+	CDEBUG(D_OTHER, "set default stripe_count # %u stripe_offset %d\n",
+	      le32_to_cpu(lum->lum_stripe_count),
+	      (int)le32_to_cpu(lum->lum_stripe_offset));
+
+	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) {
+		rc = dt_xattr_del(env, next, name, th, capa);
+		if (rc == -ENODATA)
+			rc = 0;
+	} else {
+		rc = dt_xattr_set(env, next, buf, name, fl, th, capa);
+		if (rc != 0)
+			RETURN(rc);
+
+		/* Update default stripe cache */
+		if (l->ldo_dir_stripe == NULL) {
+			OBD_ALLOC_PTR(l->ldo_dir_stripe);
+			if (l->ldo_dir_stripe == NULL)
+				RETURN(-ENOMEM);
+		}
+
+		l->ldo_dir_striping_cached = 0;
+		l->ldo_dir_def_striping_set = 1;
+		l->ldo_dir_def_stripenr =
+			le32_to_cpu(lum->lum_stripe_count) - 1;
+	}
+
+	RETURN(rc);
+}
+
+static int lod_xattr_set_lmv(const struct lu_env *env, struct dt_object *dt,
+			     const struct lu_buf *buf, const char *name,
+			     int fl, struct thandle *th,
+			     struct lustre_capa *capa)
+{
+	struct lod_object	*lo = lod_dt_obj(dt);
+	struct lu_buf		lmv_buf;
+	int			i;
+	int			rc;
+	ENTRY;
+
+	if (!S_ISDIR(dt->do_lu.lo_header->loh_attr))
+		RETURN(-ENOTDIR);
+
+	/* The stripes are supposed to be allocated in declare phase,
+	 * if there are no stripes being allocated, it will skip */
+	if (lo->ldo_stripenr == 0)
+		RETURN(0);
+
+	rc = lod_prep_lmv_md(env, dt, &lmv_buf);
+	if (rc != 0)
+		RETURN(rc);
+
+	for (i = 0; i < lo->ldo_stripenr; i++) {
+		struct dt_object *dto;
+		struct lu_attr	*attr = &lod_env_info(env)->lti_attr;
+
+		dto = lo->ldo_stripe[i];
+		memset(attr, 0, sizeof(*attr));
+		attr->la_valid = LA_TYPE | LA_MODE;
+		attr->la_mode = S_IFDIR;
+		rc = dt_create(env, dto, attr, NULL, NULL, th);
+		if (rc != 0)
+			RETURN(rc);
+
+		rc = dt_insert(env, dto,
+			      (const struct dt_rec *)lu_object_fid(&dto->do_lu),
+			      (const struct dt_key *)dot, th, capa, 0);
+		if (rc != 0)
+			RETURN(rc);
+
+		rc = dt_insert(env, dto,
+			      (struct dt_rec *)lu_object_fid(&dt->do_lu),
+			      (const struct dt_key *)dotdot, th, capa, 0);
+		if (rc != 0)
+			RETURN(rc);
+
+		if (lo->ldo_striping_cached &&
+		    !LOVEA_DELETE_VALUES(lo->ldo_def_stripe_size,
+					 lo->ldo_def_stripenr,
+					 lo->ldo_def_stripe_offset)) {
+			struct lod_thread_info	*info;
+			struct lov_user_md_v3	*v3;
+
+			/* sigh, lti_ea_store has been used for lmv_buf,
+			 * so we have to allocate buffer for default
+			 * stripe EA */
+			OBD_ALLOC_PTR(v3);
+			if (v3 == NULL)
+				RETURN(-ENOMEM);
+
+			memset(v3, 0, sizeof(*v3));
+			v3->lmm_magic = cpu_to_le32(LOV_USER_MAGIC_V3);
+			v3->lmm_stripe_count =
+				cpu_to_le32(lo->ldo_def_stripenr);
+			v3->lmm_stripe_offset =
+				cpu_to_le32(lo->ldo_def_stripe_offset);
+			v3->lmm_stripe_size =
+				cpu_to_le32(lo->ldo_def_stripe_size);
+			if (lo->ldo_pool)
+				strncpy(v3->lmm_pool_name, lo->ldo_pool,
+					LOV_MAXPOOLNAME);
+
+			info = lod_env_info(env);
+			info->lti_buf.lb_buf = v3;
+			info->lti_buf.lb_len = sizeof(*v3);
+			rc = dt_xattr_set(env, dto, &info->lti_buf,
+					  XATTR_NAME_LOV, 0, th, capa);
+			OBD_FREE_PTR(v3);
+			if (rc != 0)
+				RETURN(rc);
+		}
+
+		rc = dt_xattr_set(env, dto, &lmv_buf, XATTR_NAME_LMV, fl, th,
+				  capa);
+	}
+
+	rc = dt_xattr_set(env, dt_object_child(dt), &lmv_buf, XATTR_NAME_LMV,
+			  fl, th, capa);
+
+	RETURN(rc);
+}
+
 static int lod_xattr_set(const struct lu_env *env,
 			 struct dt_object *dt, const struct lu_buf *buf,
 			 const char *name, int fl, struct thandle *th,
 			 struct lustre_capa *capa)
 {
+	struct lod_object	*lo = lod_dt_obj(dt);
 	struct dt_object	*next = dt_object_child(dt);
 	__u32			 attr;
 	int			 rc;
+	int			i;
 	ENTRY;
 
 	attr = dt->do_lu.lo_header->loh_attr & S_IFMT;
-	if (S_ISDIR(attr)) {
-		if (strncmp(name, XATTR_NAME_LOV, strlen(XATTR_NAME_LOV)) == 0)
-			rc = lod_xattr_set_lov_on_dir(env, dt, buf, name,
-						      fl, th, capa);
-		else
-			rc = dt_xattr_set(env, next, buf, name, fl, th, capa);
-
+	if (S_ISDIR(attr) && strcmp(name, XATTR_NAME_LOV) == 0) {
+		rc = lod_xattr_set_lov_on_dir(env, dt, buf, name, fl, th, capa);
 	} else if (S_ISREG(attr) && !strcmp(name, XATTR_NAME_LOV)) {
 		/* in case of lov EA swap, just set it
 		 * if not, it is a replay so check striping match what we
@@ -548,7 +1241,11 @@ static int lod_xattr_set(const struct lu_env *env,
 		} else {
 			rc = lod_striping_create(env, dt, NULL, NULL, th);
 		}
-		RETURN(rc);
+	} else if (strcmp(name, XATTR_NAME_DEFAULT_LMV) == 0) {
+		if (!S_ISDIR(attr))
+			RETURN(-ENOTDIR);
+		rc = lod_xattr_set_default_lmv_on_dir(env, dt, buf, name, fl,
+						      th, capa);
 	} else {
 		/*
 		 * behave transparantly for all other EAs
@@ -556,6 +1253,20 @@ static int lod_xattr_set(const struct lu_env *env,
 		rc = dt_xattr_set(env, next, buf, name, fl, th, capa);
 	}
 
+	if (rc != 0 || !S_ISDIR(attr))
+		RETURN(rc);
+
+	if (lo->ldo_stripenr == 0)
+		RETURN(rc);
+
+	for (i = 0; i < lo->ldo_stripenr; i++) {
+		LASSERT(lo->ldo_stripe[i]);
+		rc = dt_xattr_set(env, lo->ldo_stripe[i], buf, name, fl, th,
+				  capa);
+		if (rc != 0)
+			break;
+	}
+
 	RETURN(rc);
 }
 
@@ -570,6 +1281,8 @@ static int lod_xattr_del(const struct lu_env *env, struct dt_object *dt,
 			 const char *name, struct thandle *th,
 			 struct lustre_capa *capa)
 {
+	if (!strcmp(name, XATTR_NAME_LOV))
+		lod_object_free_striping(env, lod_dt_obj(dt));
 	return dt_xattr_del(env, dt_object_child(dt), name, th, capa);
 }
 
@@ -604,20 +1317,19 @@ static inline int lod_object_will_be_striped(int is_reg, const struct lu_fid *fi
 	return (is_reg && fid_seq(fid) != FID_SEQ_LOCAL_FILE);
 }
 
-static int lod_cache_parent_striping(const struct lu_env *env,
-				     struct lod_object *lp)
+
+static int lod_cache_parent_lov_striping(const struct lu_env *env,
+					 struct lod_object *lp)
 {
+	struct lod_thread_info	*info = lod_env_info(env);
 	struct lov_user_md_v1	*v1 = NULL;
 	struct lov_user_md_v3	*v3 = NULL;
 	int			 rc;
 	ENTRY;
 
-	/* dt_ah_init() is called from MDD without parent being write locked
+	/* called from MDD without parent being write locked,
 	 * lock it here */
 	dt_write_lock(env, dt_object_child(&lp->ldo_obj), 0);
-	if (lp->ldo_striping_cached)
-		GOTO(unlock, rc = 0);
-
 	rc = lod_get_lov_ea(env, lp);
 	if (rc < 0)
 		GOTO(unlock, rc);
@@ -632,7 +1344,8 @@ static int lod_cache_parent_striping(const struct lu_env *env,
 		GOTO(unlock, rc = 0);
 	}
 
-	v1 = (struct lov_user_md_v1 *)lod_env_info(env)->lti_ea_store;
+	rc = 0;
+	v1 = info->lti_ea_store;
 	if (v1->lmm_magic == __swab32(LOV_USER_MAGIC_V1))
 		lustre_swab_lov_user_md_v1(v1);
 	else if (v1->lmm_magic == __swab32(LOV_USER_MAGIC_V3))
@@ -644,23 +1357,63 @@ static int lod_cache_parent_striping(const struct lu_env *env,
 	if (v1->lmm_pattern != LOV_PATTERN_RAID0 && v1->lmm_pattern != 0)
 		GOTO(unlock, rc = 0);
 
+	CDEBUG(D_INFO, DFID" stripe_count=%d stripe_size=%d stripe_offset=%d\n",
+	       PFID(lu_object_fid(&lp->ldo_obj.do_lu)),
+	       (int)v1->lmm_stripe_count,
+	       (int)v1->lmm_stripe_size, (int)v1->lmm_stripe_offset);
+
 	lp->ldo_def_stripenr = v1->lmm_stripe_count;
 	lp->ldo_def_stripe_size = v1->lmm_stripe_size;
 	lp->ldo_def_stripe_offset = v1->lmm_stripe_offset;
 	lp->ldo_striping_cached = 1;
 	lp->ldo_def_striping_set = 1;
-
 	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])
 			lod_object_set_pool(lp, v3->lmm_pool_name);
 	}
+	EXIT;
+unlock:
+	dt_write_unlock(env, dt_object_child(&lp->ldo_obj));
+	return rc;
+}
+
+
+static int lod_cache_parent_lmv_striping(const struct lu_env *env,
+					 struct lod_object *lp)
+{
+	struct lod_thread_info	*info = lod_env_info(env);
+	struct lmv_user_md_v1	*v1 = NULL;
+	int			 rc;
+	ENTRY;
+
+	/* called from MDD without parent being write locked,
+	 * lock it here */
+	dt_write_lock(env, dt_object_child(&lp->ldo_obj), 0);
+	rc = lod_get_default_lmv_ea(env, lp);
+	if (rc < 0)
+		GOTO(unlock, rc);
+
+	if (rc < sizeof(struct lmv_user_md)) {
+		/* don't lookup for non-existing or invalid striping */
+		lp->ldo_dir_def_striping_set = 0;
+		lp->ldo_dir_striping_cached = 1;
+		lp->ldo_dir_def_stripenr = 0;
+		lp->ldo_dir_def_stripe_offset =
+					(typeof(v1->lum_stripe_offset))(-1);
+		lp->ldo_dir_def_hash_type = LMV_HASH_TYPE_FNV_1A_64;
+		GOTO(unlock, rc = 0);
+	}
+
+	rc = 0;
+	v1 = info->lti_ea_store;
 
-	CDEBUG(D_OTHER, "def. striping: # %d, sz %d, off %d %s%s on "DFID"\n",
-	       lp->ldo_def_stripenr, lp->ldo_def_stripe_size,
-	       lp->ldo_def_stripe_offset, v3 ? "from " : "",
-	       v3 ? lp->ldo_pool : "", PFID(lu_object_fid(&lp->ldo_obj.do_lu)));
+	lp->ldo_dir_def_stripenr = le32_to_cpu(v1->lum_stripe_count) - 1;
+	lp->ldo_dir_def_stripe_offset = le32_to_cpu(v1->lum_stripe_offset);
+	lp->ldo_dir_def_hash_type = le32_to_cpu(v1->lum_hash_type);
+	lp->ldo_dir_def_striping_set = 1;
+	lp->ldo_dir_striping_cached = 1;
 
 	EXIT;
 unlock:
@@ -668,6 +1421,31 @@ unlock:
 	return rc;
 }
 
+static int lod_cache_parent_striping(const struct lu_env *env,
+				     struct lod_object *lp,
+				     umode_t child_mode)
+{
+	int rc = 0;
+	ENTRY;
+
+	rc = lod_load_striping(env, lp);
+	if (rc != 0)
+		RETURN(rc);
+
+	if (!lp->ldo_striping_cached) {
+		/* we haven't tried to get default striping for
+		 * the directory yet, let's cache it in the object */
+		rc = lod_cache_parent_lov_striping(env, lp);
+		if (rc != 0)
+			RETURN(rc);
+	}
+
+	if (S_ISDIR(child_mode) && !lp->ldo_dir_striping_cached)
+		rc = lod_cache_parent_lmv_striping(env, lp);
+
+	RETURN(rc);
+}
+
 /**
  * used to transfer default striping data to the object being created
  */
@@ -675,7 +1453,7 @@ static void lod_ah_init(const struct lu_env *env,
 			struct dt_allocation_hint *ah,
 			struct dt_object *parent,
 			struct dt_object *child,
-			cfs_umode_t child_mode)
+			umode_t child_mode)
 {
 	struct lod_device *d = lu2lod_dev(child->do_lu.lo_dev);
 	struct dt_object  *nextp = NULL;
@@ -704,14 +1482,28 @@ static void lod_ah_init(const struct lu_env *env,
 	 * can be called with local object existing
 	 */
 	if (!dt_object_exists(nextc) || dt_object_remote(nextc))
-		nextc->do_ops->do_ah_init(env, ah, nextp, nextc, child_mode);
+		nextc->do_ops->do_ah_init(env, ah, dt_object_remote(nextp) ?
+					  NULL : nextp, nextc, child_mode);
 
 	if (S_ISDIR(child_mode)) {
-		if (lp->ldo_striping_cached == 0) {
-			/* we haven't tried to get default striping for
-			 * the directory yet, let's cache it in the object */
-			lod_cache_parent_striping(env, lp);
+		int rc;
+
+		if (lc->ldo_dir_stripe == NULL) {
+			OBD_ALLOC_PTR(lc->ldo_dir_stripe);
+			if (lc->ldo_dir_stripe == NULL)
+				return;
+		}
+
+		if (lp->ldo_dir_stripe == NULL) {
+			OBD_ALLOC_PTR(lp->ldo_dir_stripe);
+			if (lp->ldo_dir_stripe == NULL)
+				return;
 		}
+
+		rc = lod_cache_parent_striping(env, lp, child_mode);
+		if (rc != 0)
+			return;
+
 		/* transfer defaults to new directory */
 		if (lp->ldo_striping_cached) {
 			if (lp->ldo_pool)
@@ -722,11 +1514,66 @@ static void lod_ah_init(const struct lu_env *env,
 			lc->ldo_striping_cached = 1;
 			lc->ldo_def_striping_set = 1;
 			CDEBUG(D_OTHER, "inherite EA sz:%d off:%d nr:%d\n",
-			       (int)lc->ldo_def_stripenr,
 			       (int)lc->ldo_def_stripe_size,
-			       (int)lc->ldo_def_stripe_offset);
+			       (int)lc->ldo_def_stripe_offset,
+			       (int)lc->ldo_def_stripenr);
 		}
-		return;
+
+		/* transfer dir defaults to new directory */
+		if (lp->ldo_dir_striping_cached) {
+			lc->ldo_dir_def_stripenr = lp->ldo_dir_def_stripenr;
+			lc->ldo_dir_def_stripe_offset =
+						  lp->ldo_dir_def_stripe_offset;
+			lc->ldo_dir_def_hash_type =
+						  lp->ldo_dir_def_hash_type;
+			lc->ldo_dir_striping_cached = 1;
+			lc->ldo_dir_def_striping_set = 1;
+			CDEBUG(D_INFO, "inherit default EA nr:%d off:%d t%u\n",
+			       (int)lc->ldo_dir_def_stripenr,
+			       (int)lc->ldo_dir_def_stripe_offset,
+			       lc->ldo_dir_def_hash_type);
+		}
+
+		/* If the directory is specified with certain stripes */
+		if (ah->dah_eadata != NULL && ah->dah_eadata_len != 0) {
+			const struct lmv_user_md_v1 *lum1 = ah->dah_eadata;
+			int rc;
+
+			rc = lod_verify_md_striping(d, lum1);
+			if (rc == 0 &&
+				le32_to_cpu(lum1->lum_stripe_count) > 1) {
+				/* Directory will be striped only if
+				 * stripe_count > 1 */
+				lc->ldo_stripenr =
+					le32_to_cpu(lum1->lum_stripe_count) - 1;
+				lc->ldo_dir_stripe_offset =
+					le32_to_cpu(lum1->lum_stripe_offset);
+				lc->ldo_dir_hash_type =
+					le32_to_cpu(lum1->lum_hash_type);
+				CDEBUG(D_INFO, "set stripe EA nr:%hu off:%d\n",
+				       lc->ldo_stripenr,
+				       (int)lc->ldo_dir_stripe_offset);
+			}
+		} else if (lp->ldo_dir_def_striping_set) {
+			/* If there are default dir stripe from parent */
+			lc->ldo_stripenr = lp->ldo_dir_def_stripenr;
+			lc->ldo_dir_stripe_offset =
+					lp->ldo_dir_def_stripe_offset;
+			lc->ldo_dir_hash_type =
+					lp->ldo_dir_def_hash_type;
+			CDEBUG(D_INFO, "inherit EA nr:%hu off:%d\n",
+			       lc->ldo_stripenr,
+			       (int)lc->ldo_dir_stripe_offset);
+		} else {
+			/* set default stripe for this directory */
+			lc->ldo_stripenr = 0;
+			lc->ldo_dir_stripe_offset = -1;
+		}
+
+		CDEBUG(D_INFO, "final striping count:%hu, offset:%d\n",
+		       lc->ldo_stripenr, (int)lc->ldo_dir_stripe_offset);
+
+		goto out;
 	}
 
 	/*
@@ -736,17 +1583,12 @@ static void lod_ah_init(const struct lu_env *env,
 	 */
 	if (!lod_object_will_be_striped(S_ISREG(child_mode),
 					lu_object_fid(&child->do_lu)))
-		return;
-
+		goto out;
 	/*
 	 * try from the parent
 	 */
 	if (likely(parent)) {
-		if (lp->ldo_striping_cached == 0) {
-			/* we haven't tried to get default striping for
-			 * the directory yet, let's cache it in the object */
-			lod_cache_parent_striping(env, lp);
-		}
+		lod_cache_parent_striping(env, lp, child_mode);
 
 		lc->ldo_def_stripe_offset = (__u16) -1;
 
@@ -774,6 +1616,12 @@ static void lod_ah_init(const struct lu_env *env,
 	       lc->ldo_stripenr, lc->ldo_stripe_size,
 	       lc->ldo_pool ? lc->ldo_pool : "");
 
+out:
+	/* we do not cache stripe information for slave stripe, see
+	 * lod_xattr_set_lov_on_dir */
+	if (lp != NULL && lp->ldo_dir_slave_stripe)
+		lod_lov_stripe_cache_clear(lp);
+
 	EXIT;
 }
 
@@ -823,7 +1671,6 @@ static int lod_declare_init_size(const struct lu_env *env,
 	RETURN(rc);
 }
 
-
 /**
  * Create declaration of striped object
  */
@@ -844,22 +1691,33 @@ int lod_declare_striped_object(const struct lu_env *env, struct dt_object *dt,
 		GOTO(out, rc = -ENOMEM);
 	}
 
-	/* choose OST and generate appropriate objects */
-	rc = lod_qos_prep_create(env, lo, attr, lovea, th);
-	if (rc) {
-		/* failed to create striping, let's reset
-		 * config so that others don't get confused */
-		lod_object_free_striping(env, lo);
-		GOTO(out, rc);
-	}
+	if (!dt_object_remote(next)) {
+		/* choose OST and generate appropriate objects */
+		rc = lod_qos_prep_create(env, lo, attr, lovea, th);
+		if (rc) {
+			/* failed to create striping, let's reset
+			 * config so that others don't get confused */
+			lod_object_free_striping(env, lo);
+			GOTO(out, rc);
+		}
 
-	/*
-	 * declare storage for striping data
-	 */
-	info->lti_buf.lb_len = lov_mds_md_size(lo->ldo_stripenr,
+		/*
+		 * declare storage for striping data
+		 */
+		info->lti_buf.lb_len = lov_mds_md_size(lo->ldo_stripenr,
 				lo->ldo_pool ?  LOV_MAGIC_V3 : LOV_MAGIC_V1);
-	rc = dt_declare_xattr_set(env, next, &info->lti_buf, XATTR_NAME_LOV,
-				  0, th);
+	} else {
+		/* LOD can not choose OST objects for remote objects, i.e.
+		 * stripes must be ready before that. Right now, it can only
+		 * happen during migrate, i.e. migrate process needs to create
+		 * remote regular file (mdd_migrate_create), then the migrate
+		 * process will provide stripeEA. */
+		LASSERT(lovea != NULL);
+		info->lti_buf = *lovea;
+	}
+
+	rc = dt_declare_xattr_set(env, next, &info->lti_buf,
+				  XATTR_NAME_LOV, 0, th);
 	if (rc)
 		GOTO(out, rc);
 
@@ -875,6 +1733,146 @@ out:
 	RETURN(rc);
 }
 
+int lod_dir_striping_create_internal(const struct lu_env *env,
+				     struct dt_object *dt,
+				     struct lu_attr *attr,
+				     const struct dt_object_format *dof,
+				     struct thandle *th,
+				     bool declare)
+{
+	struct lod_thread_info	*info = lod_env_info(env);
+	struct dt_object	*next = dt_object_child(dt);
+	struct lod_object	*lo = lod_dt_obj(dt);
+	int			rc;
+	ENTRY;
+
+	if (lo->ldo_dir_def_striping_set &&
+	    !LMVEA_DELETE_VALUES(lo->ldo_stripenr,
+				 lo->ldo_dir_stripe_offset)) {
+		struct lmv_user_md_v1 *v1 = info->lti_ea_store;
+		int stripe_count = lo->ldo_stripenr + 1;
+
+		if (info->lti_ea_store_size < sizeof(*v1)) {
+			rc = lod_ea_store_resize(info, sizeof(*v1));
+			if (rc != 0)
+				RETURN(rc);
+			v1 = info->lti_ea_store;
+		}
+
+		memset(v1, 0, sizeof(*v1));
+		v1->lum_magic = cpu_to_le32(LMV_USER_MAGIC);
+		v1->lum_stripe_count = cpu_to_le32(stripe_count);
+		v1->lum_stripe_offset =
+				cpu_to_le32(lo->ldo_dir_stripe_offset);
+
+		info->lti_buf.lb_buf = v1;
+		info->lti_buf.lb_len = sizeof(*v1);
+
+		if (declare)
+			rc = lod_declare_xattr_set_lmv(env, dt, attr,
+						       &info->lti_buf, th);
+		else
+			rc = lod_xattr_set_lmv(env, dt, &info->lti_buf,
+					       XATTR_NAME_LMV, 0, th,
+					       BYPASS_CAPA);
+		if (rc != 0)
+			RETURN(rc);
+	}
+
+	/* Transfer default LMV striping from the parent */
+	if (lo->ldo_dir_striping_cached &&
+	    !LMVEA_DELETE_VALUES(lo->ldo_dir_def_stripenr,
+				 lo->ldo_dir_def_stripe_offset)) {
+		struct lmv_user_md_v1 *v1 = info->lti_ea_store;
+		int def_stripe_count = lo->ldo_dir_def_stripenr + 1;
+
+		if (info->lti_ea_store_size < sizeof(*v1)) {
+			rc = lod_ea_store_resize(info, sizeof(*v1));
+			if (rc != 0)
+				RETURN(rc);
+			v1 = info->lti_ea_store;
+		}
+
+		memset(v1, 0, sizeof(*v1));
+		v1->lum_magic = cpu_to_le32(LMV_USER_MAGIC);
+		v1->lum_stripe_count = cpu_to_le32(def_stripe_count);
+		v1->lum_stripe_offset =
+				cpu_to_le32(lo->ldo_dir_def_stripe_offset);
+		v1->lum_hash_type =
+				cpu_to_le32(lo->ldo_dir_def_hash_type);
+
+		info->lti_buf.lb_buf = v1;
+		info->lti_buf.lb_len = sizeof(*v1);
+		if (declare)
+			rc = dt_declare_xattr_set(env, next, &info->lti_buf,
+						  XATTR_NAME_DEFAULT_LMV, 0,
+						  th);
+		else
+			rc = dt_xattr_set(env, next, &info->lti_buf,
+					   XATTR_NAME_DEFAULT_LMV, 0, th,
+					   BYPASS_CAPA);
+		if (rc != 0)
+			RETURN(rc);
+	}
+
+	/* Transfer default LOV striping from the parent */
+	if (lo->ldo_striping_cached &&
+	    !LOVEA_DELETE_VALUES(lo->ldo_def_stripe_size,
+				 lo->ldo_def_stripenr,
+				 lo->ldo_def_stripe_offset)) {
+		struct lov_user_md_v3 *v3 = info->lti_ea_store;
+
+		if (info->lti_ea_store_size < sizeof(*v3)) {
+			rc = lod_ea_store_resize(info, sizeof(*v3));
+			if (rc != 0)
+				RETURN(rc);
+			v3 = info->lti_ea_store;
+		}
+
+		memset(v3, 0, sizeof(*v3));
+		v3->lmm_magic = cpu_to_le32(LOV_USER_MAGIC_V3);
+		v3->lmm_stripe_count = cpu_to_le16(lo->ldo_def_stripenr);
+		v3->lmm_stripe_offset = cpu_to_le16(lo->ldo_def_stripe_offset);
+		v3->lmm_stripe_size = cpu_to_le32(lo->ldo_def_stripe_size);
+		if (lo->ldo_pool)
+			strncpy(v3->lmm_pool_name, lo->ldo_pool,
+				LOV_MAXPOOLNAME);
+
+		info->lti_buf.lb_buf = v3;
+		info->lti_buf.lb_len = sizeof(*v3);
+
+		if (declare)
+			rc = dt_declare_xattr_set(env, next, &info->lti_buf,
+						  XATTR_NAME_LOV, 0, th);
+		else
+			rc = dt_xattr_set(env, next, &info->lti_buf,
+					  XATTR_NAME_LOV, 0, th,
+					  BYPASS_CAPA);
+		if (rc != 0)
+			RETURN(rc);
+	}
+
+	RETURN(0);
+}
+
+static int lod_declare_dir_striping_create(const struct lu_env *env,
+					   struct dt_object *dt,
+					   struct lu_attr *attr,
+					   struct dt_object_format *dof,
+					   struct thandle *th)
+{
+	return lod_dir_striping_create_internal(env, dt, attr, dof, th, true);
+}
+
+static int lod_dir_striping_create(const struct lu_env *env,
+				   struct dt_object *dt,
+				   struct lu_attr *attr,
+				   struct dt_object_format *dof,
+				   struct thandle *th)
+{
+	return lod_dir_striping_create_internal(env, dt, attr, dof, th, false);
+}
+
 static int lod_declare_object_create(const struct lu_env *env,
 				     struct dt_object *dt,
 				     struct lu_attr *attr,
@@ -914,40 +1912,13 @@ static int lod_declare_object_create(const struct lu_env *env,
 		if (lo->ldo_stripenr > 0)
 			rc = lod_declare_striped_object(env, dt, attr,
 							NULL, th);
-	} else if (dof->dof_type == DFT_DIR && lo->ldo_striping_cached) {
-		struct lod_thread_info *info = lod_env_info(env);
-
-		struct lov_user_md_v3 *v3;
-
-		if (LOVEA_DELETE_VALUES(lo->ldo_def_stripe_size,
-					lo->ldo_def_stripenr,
-					lo->ldo_def_stripe_offset))
-			RETURN(0);
-
-		OBD_ALLOC_PTR(v3);
-		if (v3 == NULL)
-			RETURN(-ENOMEM);
-
-		v3->lmm_magic = cpu_to_le32(LOV_MAGIC_V3);
-		v3->lmm_pattern = cpu_to_le32(LOV_PATTERN_RAID0);
-		fid_to_ostid(lu_object_fid(&dt->do_lu), &v3->lmm_oi);
-		ostid_cpu_to_le(&v3->lmm_oi, &v3->lmm_oi);
-		v3->lmm_stripe_size = cpu_to_le32(lo->ldo_def_stripe_size);
-		v3->lmm_stripe_count = cpu_to_le32(lo->ldo_def_stripenr);
-		v3->lmm_stripe_offset = cpu_to_le16(lo->ldo_def_stripe_offset);
-		if (lo->ldo_pool)
-			strncpy(v3->lmm_pool_name, lo->ldo_pool,
-				LOV_MAXPOOLNAME);
-
-		info->lti_buf.lb_buf = v3;
-		info->lti_buf.lb_len = sizeof(*v3);
-
-		/* to transfer default striping from the parent */
-		rc = dt_declare_xattr_set(env, next, &info->lti_buf,
-					  XATTR_NAME_LOV, 0, th);
-		OBD_FREE_PTR(v3);
+	} else if (dof->dof_type == DFT_DIR) {
+		/* Orphan object (like migrating object) does not have
+		 * lod_dir_stripe, see lod_ah_init */
+		if (lo->ldo_dir_stripe != NULL)
+			rc = lod_declare_dir_striping_create(env, dt, attr,
+							     dof, th);
 	}
-
 out:
 	RETURN(rc);
 }
@@ -960,8 +1931,6 @@ int lod_striping_create(const struct lu_env *env, struct dt_object *dt,
 	int		   rc = 0, i;
 	ENTRY;
 
-	LASSERT(lo->ldo_stripe);
-	LASSERT(lo->ldo_stripenr > 0);
 	LASSERT(lo->ldo_striping_cached == 0);
 
 	/* create all underlying objects */
@@ -992,9 +1961,10 @@ static int lod_object_create(const struct lu_env *env, struct dt_object *dt,
 	rc = dt_create(env, next, attr, hint, dof, th);
 
 	if (rc == 0) {
-		if (S_ISDIR(dt->do_lu.lo_header->loh_attr))
-			rc = lod_store_def_striping(env, dt, th);
-		else if (lo->ldo_stripe)
+		if (S_ISDIR(dt->do_lu.lo_header->loh_attr) &&
+		    lo->ldo_dir_stripe != NULL)
+			rc = lod_dir_striping_create(env, dt, attr, dof, th);
+		else if (lo->ldo_stripe && dof->u.dof_reg.striped != 0)
 			rc = lod_striping_create(env, dt, attr, dof, th);
 	}
 
@@ -1017,6 +1987,9 @@ static int lod_declare_object_destroy(const struct lu_env *env,
 	if (rc)
 		RETURN(rc);
 
+	if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_LOST_MDTOBJ))
+		RETURN(0);
+
 	/*
 	 * load striping information, notice we don't do this when object
 	 * is being initialized as we don't need this information till
@@ -1051,12 +2024,18 @@ static int lod_object_destroy(const struct lu_env *env,
 	if (rc)
 		RETURN(rc);
 
+	if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_LOST_MDTOBJ))
+		RETURN(0);
+
 	/* destroy all underlying objects */
 	for (i = 0; i < lo->ldo_stripenr; i++) {
 		LASSERT(lo->ldo_stripe[i]);
-		rc = dt_destroy(env, lo->ldo_stripe[i], th);
-		if (rc)
-			break;
+		/* for striped directory, next == ldo_stripe[0] */
+		if (next != lo->ldo_stripe[i]) {
+			rc = dt_destroy(env, lo->ldo_stripe[i], th);
+			if (rc)
+				break;
+		}
 	}
 
 	RETURN(rc);
@@ -1115,19 +2094,143 @@ static int lod_object_sync(const struct lu_env *env, struct dt_object *dt)
 	return dt_object_sync(env, dt_object_child(dt));
 }
 
+struct lod_slave_locks	{
+	int			lsl_lock_count;
+	struct lustre_handle	lsl_handle[0];
+};
+
+static int lod_object_unlock_internal(const struct lu_env *env,
+				      struct dt_object *dt,
+				      struct ldlm_enqueue_info *einfo,
+				      ldlm_policy_data_t *policy)
+{
+	struct lod_object	*lo = lod_dt_obj(dt);
+	struct lod_slave_locks  *slave_locks = einfo->ei_cbdata;
+	int			rc = 0;
+	int			i;
+	ENTRY;
+
+	if (slave_locks == NULL)
+		RETURN(0);
+
+	for (i = 0; i < slave_locks->lsl_lock_count; i++) {
+		if (lustre_handle_is_used(&slave_locks->lsl_handle[i])) {
+			int	rc1;
+
+			einfo->ei_cbdata = &slave_locks->lsl_handle[i];
+			rc1 = dt_object_unlock(env, lo->ldo_stripe[i], einfo,
+					       policy);
+			if (rc1 < 0)
+				rc = rc == 0 ? rc1 : rc;
+		}
+	}
+
+	RETURN(rc);
+}
+
+static int lod_object_unlock(const struct lu_env *env, struct dt_object *dt,
+			     struct ldlm_enqueue_info *einfo,
+			     union ldlm_policy_data *policy)
+{
+	struct lod_object	*lo = lod_dt_obj(dt);
+	struct lod_slave_locks  *slave_locks = einfo->ei_cbdata;
+	int			slave_locks_size;
+	int			rc;
+	ENTRY;
+
+	if (slave_locks == NULL)
+		RETURN(0);
+
+	rc = lod_load_striping(env, lo);
+	if (rc != 0)
+		RETURN(rc);
+
+	/* Note: for remote lock for single stripe dir, MDT will cancel
+	 * the lock by lockh directly */
+	if (lo->ldo_stripenr == 0 && dt_object_remote(dt_object_child(dt)))
+		RETURN(0);
+
+	if (!S_ISDIR(dt->do_lu.lo_header->loh_attr))
+		RETURN(-ENOTDIR);
+
+	/* Only cancel slave lock for striped dir */
+	rc = lod_object_unlock_internal(env, dt, einfo, policy);
+
+	slave_locks_size = sizeof(*slave_locks) + slave_locks->lsl_lock_count *
+			   sizeof(slave_locks->lsl_handle[0]);
+	OBD_FREE(slave_locks, slave_locks_size);
+	einfo->ei_cbdata = NULL;
+
+	RETURN(rc);
+}
+
 static int lod_object_lock(const struct lu_env *env,
-			   struct dt_object *dt, struct lustre_handle *lh,
+			   struct dt_object *dt,
+			   struct lustre_handle *lh,
 			   struct ldlm_enqueue_info *einfo,
-			   void *policy)
+			   union ldlm_policy_data *policy)
 {
-	struct dt_object   *next = dt_object_child(dt);
-	int		 rc;
+	struct lod_object	*lo = lod_dt_obj(dt);
+	int			rc = 0;
+	int			i;
+	int			slave_locks_size;
+	struct lod_slave_locks	*slave_locks = NULL;
 	ENTRY;
 
-	/*
-	 * declare setattr on the local object
-	 */
-	rc = dt_object_lock(env, next, lh, einfo, policy);
+	/* remote object lock */
+	if (!einfo->ei_enq_slave) {
+		LASSERT(dt_object_remote(dt));
+		return dt_object_lock(env, dt_object_child(dt), lh, einfo,
+				      policy);
+	}
+
+	if (!S_ISDIR(dt->do_lu.lo_header->loh_attr))
+		RETURN(-ENOTDIR);
+
+	rc = lod_load_striping(env, lo);
+	if (rc != 0)
+		RETURN(rc);
+
+	/* No stripes */
+	if (lo->ldo_stripenr == 0)
+		RETURN(0);
+
+	slave_locks_size = sizeof(*slave_locks) + lo->ldo_stripenr *
+			   sizeof(slave_locks->lsl_handle[0]);
+	/* Freed in lod_object_unlock */
+	OBD_ALLOC(slave_locks, slave_locks_size);
+	if (slave_locks == NULL)
+		RETURN(-ENOMEM);
+	slave_locks->lsl_lock_count = lo->ldo_stripenr;
+
+	/* striped directory lock */
+	for (i = 0; i < lo->ldo_stripenr; i++) {
+		struct lustre_handle	lockh;
+		struct ldlm_res_id	*res_id;
+
+		res_id = &lod_env_info(env)->lti_res_id;
+		fid_build_reg_res_name(lu_object_fid(&lo->ldo_stripe[i]->do_lu),
+				       res_id);
+		einfo->ei_res_id = res_id;
+
+		LASSERT(lo->ldo_stripe[i]);
+		rc = dt_object_lock(env, lo->ldo_stripe[i], &lockh, einfo,
+				    policy);
+		if (rc != 0)
+			GOTO(out, rc);
+
+		slave_locks->lsl_handle[i] = lockh;
+	}
+
+	einfo->ei_cbdata = slave_locks;
+
+out:
+	if (rc != 0 && slave_locks != NULL) {
+		einfo->ei_cbdata = slave_locks;
+		lod_object_unlock_internal(env, dt, einfo, policy);
+		OBD_FREE(slave_locks, slave_locks_size);
+		einfo->ei_cbdata = NULL;
+	}
 
 	RETURN(rc);
 }
@@ -1160,6 +2263,7 @@ struct dt_object_operations lod_obj_ops = {
 	.do_capa_get		= lod_capa_get,
 	.do_object_sync		= lod_object_sync,
 	.do_object_lock		= lod_object_lock,
+	.do_object_unlock	= lod_object_unlock,
 };
 
 static ssize_t lod_read(const struct lu_env *env, struct dt_object *dt,
@@ -1172,11 +2276,11 @@ static ssize_t lod_read(const struct lu_env *env, struct dt_object *dt,
 
 static ssize_t lod_declare_write(const struct lu_env *env,
 				 struct dt_object *dt,
-				 const loff_t size, loff_t pos,
+				 const struct lu_buf *buf, loff_t pos,
 				 struct thandle *th)
 {
 	return dt_declare_record_write(env, dt_object_child(dt),
-				       size, pos, th);
+				       buf, pos, th);
 }
 
 static ssize_t lod_write(const struct lu_env *env, struct dt_object *dt,
@@ -1194,23 +2298,57 @@ static const struct dt_body_operations lod_body_lnk_ops = {
 	.dbo_write		= lod_write
 };
 
-static int lod_object_init(const struct lu_env *env, struct lu_object *o,
+static int lod_object_init(const struct lu_env *env, struct lu_object *lo,
 			   const struct lu_object_conf *conf)
 {
-	struct lod_device *d = lu2lod_dev(o->lo_dev);
-	struct lu_object  *below;
-	struct lu_device  *under;
+	struct lod_device	*lod	= lu2lod_dev(lo->lo_dev);
+	struct lu_device	*cdev	= NULL;
+	struct lu_object	*cobj;
+	struct lod_tgt_descs	*ltd	= NULL;
+	struct lod_tgt_desc	*tgt;
+	mdsno_t			 idx	= 0;
+	int			 type	= LU_SEQ_RANGE_ANY;
+	int			 rc;
 	ENTRY;
 
-	/*
-	 * create local object
-	 */
-	under = &d->lod_child->dd_lu_dev;
-	below = under->ld_ops->ldo_object_alloc(env, o->lo_header, under);
-	if (below == NULL)
+	rc = lod_fld_lookup(env, lod, lu_object_fid(lo), &idx, &type);
+	if (rc != 0)
+		RETURN(rc);
+
+	if (type == LU_SEQ_RANGE_MDT &&
+	    idx == lu_site2seq(lo->lo_dev->ld_site)->ss_node_id) {
+		cdev = &lod->lod_child->dd_lu_dev;
+	} else if (type == LU_SEQ_RANGE_MDT) {
+		ltd = &lod->lod_mdt_descs;
+		lod_getref(ltd);
+	} else if (type == LU_SEQ_RANGE_OST) {
+		ltd = &lod->lod_ost_descs;
+		lod_getref(ltd);
+	} else {
+		LBUG();
+	}
+
+	if (ltd != NULL) {
+		if (ltd->ltd_tgts_size > idx &&
+		    cfs_bitmap_check(ltd->ltd_tgt_bitmap, idx)) {
+			tgt = LTD_TGT(ltd, idx);
+
+			LASSERT(tgt != NULL);
+			LASSERT(tgt->ltd_tgt != NULL);
+
+			cdev = &(tgt->ltd_tgt->dd_lu_dev);
+		}
+		lod_putref(lod, ltd);
+	}
+
+	if (unlikely(cdev == NULL))
+		RETURN(-ENOENT);
+
+	cobj = cdev->ld_ops->ldo_object_alloc(env, lo->lo_header, cdev);
+	if (unlikely(cobj == NULL))
 		RETURN(-ENOMEM);
 
-	lu_object_add(o, below);
+	lu_object_add(lo, cobj);
 
 	RETURN(0);
 }
@@ -1219,6 +2357,11 @@ void lod_object_free_striping(const struct lu_env *env, struct lod_object *lo)
 {
 	int i;
 
+	if (lo->ldo_dir_stripe != NULL) {
+		OBD_FREE_PTR(lo->ldo_dir_stripe);
+		lo->ldo_dir_stripe = NULL;
+	}
+
 	if (lo->ldo_stripe) {
 		LASSERT(lo->ldo_stripes_allocated > 0);
 
@@ -1233,6 +2376,7 @@ void lod_object_free_striping(const struct lu_env *env, struct lod_object *lo)
 		lo->ldo_stripes_allocated = 0;
 	}
 	lo->ldo_stripenr = 0;
+	lo->ldo_pattern = 0;
 }
 
 /*
@@ -1283,51 +2427,3 @@ struct lu_object_operations lod_lu_obj_ops = {
 	.loo_object_release	= lod_object_release,
 	.loo_object_print	= lod_object_print,
 };
-
-/**
- * Init remote lod object
- */
-static int lod_robject_init(const struct lu_env *env, struct lu_object *lo,
-			    const struct lu_object_conf *conf)
-{
-	struct lod_device *lod = lu2lod_dev(lo->lo_dev);
-	struct lod_tgt_descs *ltd = &lod->lod_mdt_descs;
-	struct lu_device  *c_dev = NULL;
-	struct lu_object  *c_obj;
-	int i;
-	ENTRY;
-
-	lod_getref(ltd);
-	if (ltd->ltd_tgts_size > 0) {
-		cfs_foreach_bit(ltd->ltd_tgt_bitmap, i) {
-			struct lod_tgt_desc *tgt;
-			tgt = LTD_TGT(ltd, i);
-			LASSERT(tgt && tgt->ltd_tgt);
-			if (tgt->ltd_index ==
-			    lu2lod_obj(lo)->ldo_mds_num) {
-				c_dev = &(tgt->ltd_tgt->dd_lu_dev);
-				break;
-			}
-		}
-	}
-	lod_putref(lod, ltd);
-
-	if (unlikely(c_dev == NULL))
-		RETURN(-ENOENT);
-
-	c_obj = c_dev->ld_ops->ldo_object_alloc(env, lo->lo_header, c_dev);
-	if (unlikely(c_obj == NULL))
-		RETURN(-ENOMEM);
-
-	lu_object_add(lo, c_obj);
-
-	RETURN(0);
-}
-
-struct lu_object_operations lod_lu_robj_ops = {
-	.loo_object_init      = lod_robject_init,
-	.loo_object_start     = lod_object_start,
-	.loo_object_free      = lod_object_free,
-	.loo_object_release   = lod_object_release,
-	.loo_object_print     = lod_object_print,
-};