X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Fmdd%2Fmdd_dir.c;h=9f3c333736c55f693c0adc5251728ff9918242e0;hp=f15e37d5188c54ce892c2d709fc1d0570f1d970d;hb=3e37d73b011ac1203c8cdd9f696652812bde5d2e;hpb=303ea892488b985ba84e6c8e1481f6c7c914c7ed;ds=sidebyside

diff --git a/lustre/mdd/mdd_dir.c b/lustre/mdd/mdd_dir.c
index f15e37d..9f3c333 100644
--- a/lustre/mdd/mdd_dir.c
+++ b/lustre/mdd/mdd_dir.c
@@ -27,7 +27,7 @@
  * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
  * Use is subject to license terms.
  *
- * Copyright (c) 2011, 2012, Intel Corporation.
+ * Copyright (c) 2011, 2013, Intel Corporation.
  */
 /*
  * This file is part of Lustre, http://www.lustre.org/
@@ -37,7 +37,7 @@
  *
  * Lustre Metadata Server (mdd) routines
  *
- * Author: Wang Di <wangdi@clusterfs.com>
+ * Author: Wang Di <wangdi@intel.com>
  */
 
 #define DEBUG_SUBSYSTEM S_MDS
@@ -57,30 +57,8 @@ static struct lu_name lname_dotdot = {
         sizeof(dotdot) - 1
 };
 
-static int __mdd_lookup(const struct lu_env *env, struct md_object *pobj,
-                        const struct lu_name *lname, struct lu_fid* fid,
-                        int mask);
-static int mdd_declare_links_add(const struct lu_env *env,
-                                 struct mdd_object *mdd_obj,
-                                 struct thandle *handle);
-static inline int mdd_links_add(const struct lu_env *env,
-				struct mdd_object *mdd_obj,
-				const struct lu_fid *pfid,
-				const struct lu_name *lname,
-				struct thandle *handle, int first);
-static inline int mdd_links_del(const struct lu_env *env,
-				struct mdd_object *mdd_obj,
-				const struct lu_fid *pfid,
-				const struct lu_name *lname,
-				struct thandle *handle);
-static int mdd_links_rename(const struct lu_env *env,
-			    struct mdd_object *mdd_obj,
-			    const struct lu_fid *oldpfid,
-			    const struct lu_name *oldlname,
-			    const struct lu_fid *newpfid,
-			    const struct lu_name *newlname,
-			    struct thandle *handle,
-			    int first, int check);
+static int __mdd_lookup(const struct lu_env *, struct md_object *,
+			const struct lu_name *, struct lu_fid*, int);
 
 static int
 __mdd_lookup_locked(const struct lu_env *env, struct md_object *pobj,
@@ -110,8 +88,8 @@ int mdd_lookup(const struct lu_env *env,
         RETURN(rc);
 }
 
-static int mdd_parent_fid(const struct lu_env *env, struct mdd_object *obj,
-                          struct lu_fid *fid)
+int mdd_parent_fid(const struct lu_env *env, struct mdd_object *obj,
+		   struct lu_fid *fid)
 {
         return __mdd_lookup_locked(env, &obj->mod_obj, &lname_dotdot, fid, 0);
 }
@@ -165,16 +143,17 @@ static int mdd_is_parent(const struct lu_env *env,
                         GOTO(out, rc = 1);
                 if (parent)
                         mdd_object_put(env, parent);
-                parent = mdd_object_find(env, mdd, pfid);
-
-                /* cross-ref parent */
-                if (parent == NULL) {
-                        if (pf != NULL)
-                                *pf = *pfid;
-                        GOTO(out, rc = -EREMOTE);
-                } else if (IS_ERR(parent))
-                        GOTO(out, rc = PTR_ERR(parent));
-                p1 = parent;
+
+		parent = mdd_object_find(env, mdd, pfid);
+		if (IS_ERR(parent)) {
+			GOTO(out, rc = PTR_ERR(parent));
+		} else if (mdd_object_remote(parent)) {
+			/*FIXME: Because of the restriction of rename in Phase I.
+			 * If the parent is remote, we just assumed lf is not the
+			 * parent of P1 for now */
+			GOTO(out, rc = 0);
+		}
+		p1 = parent;
         }
         EXIT;
 out:
@@ -296,7 +275,7 @@ int mdd_may_create(const struct lu_env *env, struct mdd_object *pobj,
         int rc = 0;
         ENTRY;
 
-        if (cobj && mdd_object_exists(cobj))
+	if (cobj && mdd_object_exists(cobj))
                 RETURN(-EEXIST);
 
         if (mdd_is_dead_obj(pobj))
@@ -369,7 +348,34 @@ static inline int mdd_is_sticky(const struct lu_env *env,
 	if (tmp_la->la_uid == uc->uc_fsuid)
 		return 0;
 
-	return !mdd_capable(uc, CFS_CAP_FOWNER);
+	return !md_capable(uc, CFS_CAP_FOWNER);
+}
+
+static int mdd_may_delete_entry(const struct lu_env *env,
+				struct mdd_object *pobj, int check_perm)
+{
+	ENTRY;
+
+	LASSERT(pobj != NULL);
+	if (!mdd_object_exists(pobj))
+		RETURN(-ENOENT);
+
+	if (mdd_is_dead_obj(pobj))
+		RETURN(-ENOENT);
+
+	if (check_perm) {
+		int rc;
+		rc = mdd_permission_internal_locked(env, pobj, NULL,
+					    MAY_WRITE | MAY_EXEC,
+					    MOR_TGT_PARENT);
+		if (rc)
+			RETURN(rc);
+	}
+
+	if (mdd_is_append(pobj))
+		RETURN(-EPERM);
+
+	RETURN(0);
 }
 
 /*
@@ -383,31 +389,21 @@ int mdd_may_delete(const struct lu_env *env, struct mdd_object *pobj,
         int rc = 0;
         ENTRY;
 
-        LASSERT(cobj);
+	if (pobj) {
+		rc = mdd_may_delete_entry(env, pobj, check_perm);
+		if (rc != 0)
+			RETURN(rc);
+	}
+
+	if (cobj == NULL)
+		RETURN(0);
+
         if (!mdd_object_exists(cobj))
                 RETURN(-ENOENT);
 
         if (mdd_is_dead_obj(cobj))
                 RETURN(-ESTALE);
 
-        if (pobj) {
-                if (!mdd_object_exists(pobj))
-                        RETURN(-ENOENT);
-
-                if (mdd_is_dead_obj(pobj))
-                        RETURN(-ENOENT);
-
-                if (check_perm) {
-                        rc = mdd_permission_internal_locked(env, pobj, NULL,
-                                                    MAY_WRITE | MAY_EXEC,
-                                                    MOR_TGT_PARENT);
-                        if (rc)
-                                RETURN(rc);
-                }
-
-                if (mdd_is_append(pobj))
-                        RETURN(-EPERM);
-        }
 
 	if (mdd_is_sticky(env, pobj, cobj))
                 RETURN(-EPERM);
@@ -558,60 +554,6 @@ static int __mdd_index_delete(const struct lu_env *env, struct mdd_object *pobj,
         RETURN(rc);
 }
 
-int mdd_declare_llog_record(const struct lu_env *env, struct mdd_device *mdd,
-                            int reclen, struct thandle *handle)
-{
-        int rc;
-
-        /* XXX: this is a temporary solution to declare llog changes
-         *      will be fixed in 2.3 with new llog implementation */
-
-        LASSERT(mdd->mdd_capa);
-
-        /* XXX: Since we use the 'mdd_capa' as fake llog object here, we
-         *      have to set the parameter 'size' as INT_MAX or 0 to inform
-         *      OSD that this record write is for a llog write or catalog
-         *      header update, and osd declare function will reserve less
-         *      credits for optimization purpose.
-         *
-         *      Reserve 6 blocks for a llog write, since the llog file is
-         *      usually small, reserve 2 blocks for catalog header update,
-         *      because we know for sure that catalog header is already
-         *      allocated.
-         *
-         *      This hack should be removed in 2.3.
-         */
-
-        /* record itself */
-        rc = dt_declare_record_write(env, mdd->mdd_capa,
-                                     DECLARE_LLOG_WRITE, 0, handle);
-        if (rc)
-                return rc;
-
-        /* header will be updated as well */
-        rc = dt_declare_record_write(env, mdd->mdd_capa,
-                                     DECLARE_LLOG_WRITE, 0, handle);
-        if (rc)
-                return rc;
-
-        /* also we should be able to create new plain log */
-        rc = dt_declare_create(env, mdd->mdd_capa, NULL, NULL, NULL, handle);
-        if (rc)
-                return rc;
-
-        /* new record referencing new plain llog */
-        rc = dt_declare_record_write(env, mdd->mdd_capa,
-                                     DECLARE_LLOG_WRITE, 0, handle);
-        if (rc)
-                return rc;
-
-        /* catalog's header will be updated as well */
-        rc = dt_declare_record_write(env, mdd->mdd_capa,
-                                     DECLARE_LLOG_REWRITE, 0, handle);
-
-        return rc;
-}
-
 int mdd_declare_changelog_store(const struct lu_env *env,
 				struct mdd_device *mdd,
 				const struct lu_name *fname,
@@ -630,7 +572,7 @@ int mdd_declare_changelog_store(const struct lu_env *env,
 
 	reclen = llog_data_len(sizeof(*rec) +
 			       (fname != NULL ? fname->ln_namelen : 0));
-	buf = mdd_buf_alloc(env, reclen);
+	buf = lu_buf_check_and_alloc(&mdd_env_info(env)->mti_big_buf, reclen);
 	if (buf->lb_buf == NULL)
 		return -ENOMEM;
 
@@ -668,7 +610,7 @@ static int mdd_declare_changelog_ext_store(const struct lu_env *env,
 	reclen = llog_data_len(sizeof(*rec) +
 			       (tname != NULL ? tname->ln_namelen : 0) +
 			       (sname != NULL ? 1 + sname->ln_namelen : 0));
-	buf = mdd_buf_alloc(env, reclen);
+	buf = lu_buf_check_and_alloc(&mdd_env_info(env)->mti_big_buf, reclen);
 	if (buf->lb_buf == NULL)
 		return -ENOMEM;
 
@@ -770,14 +712,10 @@ int mdd_changelog_ext_store(const struct lu_env *env, struct mdd_device *mdd,
  * \param tname - target name string
  * \param handle - transacion handle
  */
-static int mdd_changelog_ns_store(const struct lu_env  *env,
-				  struct mdd_device    *mdd,
-				  enum changelog_rec_type type,
-				  unsigned flags,
-				  struct mdd_object    *target,
-				  struct mdd_object    *parent,
-				  const struct lu_name *tname,
-				  struct thandle *handle)
+int mdd_changelog_ns_store(const struct lu_env *env, struct mdd_device *mdd,
+			   enum changelog_rec_type type, unsigned flags,
+			   struct mdd_object *target, struct mdd_object *parent,
+			   const struct lu_name *tname, struct thandle *handle)
 {
 	struct llog_changelog_rec *rec;
 	struct lu_buf *buf;
@@ -797,7 +735,7 @@ static int mdd_changelog_ns_store(const struct lu_env  *env,
 	LASSERT(handle != NULL);
 
 	reclen = llog_data_len(sizeof(*rec) + tname->ln_namelen);
-	buf = mdd_buf_alloc(env, reclen);
+	buf = lu_buf_check_and_alloc(&mdd_env_info(env)->mti_big_buf, reclen);
 	if (buf->lb_buf == NULL)
 		RETURN(-ENOMEM);
 	rec = buf->lb_buf;
@@ -865,7 +803,7 @@ static int mdd_changelog_ext_ns_store(const struct lu_env  *env,
 
 	reclen = llog_data_len(sizeof(*rec) +
 			       sname != NULL ? 1 + sname->ln_namelen : 0);
-	buf = mdd_buf_alloc(env, reclen);
+	buf = lu_buf_check_and_alloc(&mdd_env_info(env)->mti_big_buf, reclen);
 	if (buf->lb_buf == NULL)
 		RETURN(-ENOMEM);
 	rec = buf->lb_buf;
@@ -901,146 +839,465 @@ static int mdd_changelog_ext_ns_store(const struct lu_env  *env,
 	return 0;
 }
 
-static int mdd_declare_link(const struct lu_env *env,
-                            struct mdd_device *mdd,
-                            struct mdd_object *p,
-                            struct mdd_object *c,
-                            const struct lu_name *name,
-                            struct thandle *handle)
+static int __mdd_links_add(const struct lu_env *env,
+			   struct mdd_object *mdd_obj,
+			   struct linkea_data *ldata,
+			   const struct lu_name *lname,
+			   const struct lu_fid *pfid,
+			   int first, int check)
 {
-        int rc;
-
-        rc = mdo_declare_index_insert(env, p, mdo2fid(c), name->ln_name,handle);
-        if (rc)
-                return rc;
+	int rc;
 
-        rc = mdo_declare_ref_add(env, c, handle);
-        if (rc)
-                return rc;
+	if (ldata->ld_leh == NULL) {
+		rc = first ? -ENODATA : mdd_links_read(env, mdd_obj, ldata);
+		if (rc) {
+			if (rc != -ENODATA)
+				return rc;
+			rc = linkea_data_new(ldata,
+					     &mdd_env_info(env)->mti_link_buf);
+			if (rc)
+				return rc;
+		}
+	}
 
-        rc = mdo_declare_attr_set(env, p, NULL, handle);
-        if (rc)
-                return rc;
+	if (check) {
+		rc = linkea_links_find(ldata, lname, pfid);
+		if (rc && rc != -ENOENT)
+			return rc;
+		if (rc == 0)
+			return -EEXIST;
+	}
 
-        rc = mdo_declare_attr_set(env, c, NULL, handle);
-        if (rc)
-                return rc;
+	if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_LINKEA_MORE)) {
+		struct lu_fid *tfid = &mdd_env_info(env)->mti_fid2;
 
-        rc = mdd_declare_links_add(env, c, handle);
-        if (rc)
-                return rc;
+		*tfid = *pfid;
+		tfid->f_ver = ~0;
+		linkea_add_buf(ldata, lname, tfid);
+	}
 
-        rc = mdd_declare_changelog_store(env, mdd, name, handle);
+	if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_LINKEA_MORE2))
+		linkea_add_buf(ldata, lname, pfid);
 
-        return rc;
+	return linkea_add_buf(ldata, lname, pfid);
 }
 
-static int mdd_link(const struct lu_env *env, struct md_object *tgt_obj,
-                    struct md_object *src_obj, const struct lu_name *lname,
-                    struct md_attr *ma)
+static int __mdd_links_del(const struct lu_env *env,
+			   struct mdd_object *mdd_obj,
+			   struct linkea_data *ldata,
+			   const struct lu_name *lname,
+			   const struct lu_fid *pfid)
 {
-        const char *name = lname->ln_name;
-        struct lu_attr    *la = &mdd_env_info(env)->mti_la_for_fix;
-        struct mdd_object *mdd_tobj = md2mdd_obj(tgt_obj);
-        struct mdd_object *mdd_sobj = md2mdd_obj(src_obj);
-        struct mdd_device *mdd = mdo2mdd(src_obj);
-        struct dynlock_handle *dlh;
-        struct thandle *handle;
-        int rc;
-        ENTRY;
-
-        handle = mdd_trans_create(env, mdd);
-        if (IS_ERR(handle))
-                GOTO(out_pending, rc = PTR_ERR(handle));
+	int rc;
 
-        rc = mdd_declare_link(env, mdd, mdd_tobj, mdd_sobj, lname, handle);
-        if (rc)
-                GOTO(stop, rc);
+	if (ldata->ld_leh == NULL) {
+		rc = mdd_links_read(env, mdd_obj, ldata);
+		if (rc)
+			return rc;
+	}
 
-        rc = mdd_trans_start(env, mdd, handle);
-        if (rc)
-                GOTO(stop, rc);
+	rc = linkea_links_find(ldata, lname, pfid);
+	if (rc)
+		return rc;
 
-        dlh = mdd_pdo_write_lock(env, mdd_tobj, name, MOR_TGT_CHILD);
-        if (dlh == NULL)
-                GOTO(out_trans, rc = -ENOMEM);
-        mdd_write_lock(env, mdd_sobj, MOR_TGT_CHILD);
+	linkea_del_buf(ldata, lname);
+	return 0;
+}
 
-        rc = mdd_link_sanity_check(env, mdd_tobj, lname, mdd_sobj);
-        if (rc)
-                GOTO(out_unlock, rc);
+static int mdd_linkea_prepare(const struct lu_env *env,
+			      struct mdd_object *mdd_obj,
+			      const struct lu_fid *oldpfid,
+			      const struct lu_name *oldlname,
+			      const struct lu_fid *newpfid,
+			      const struct lu_name *newlname,
+			      int first, int check,
+			      struct linkea_data *ldata)
+{
+	int rc = 0;
+	int rc2 = 0;
+	ENTRY;
 
-	rc = mdo_ref_add(env, mdd_sobj, handle);
-	if (rc)
-		GOTO(out_unlock, rc);
+	if (OBD_FAIL_CHECK(OBD_FAIL_FID_IGIF))
+		return 0;
 
+	LASSERT(oldpfid != NULL || newpfid != NULL);
 
-	rc = __mdd_index_insert_only(env, mdd_tobj, mdo2fid(mdd_sobj),
-				     name, handle,
-				     mdd_object_capa(env, mdd_tobj));
-	if (rc != 0) {
-		mdo_ref_del(env, mdd_sobj, handle);
-		GOTO(out_unlock, rc);
+	if (mdd_obj->mod_flags & DEAD_OBJ) {
+		/* Prevent linkea to be updated which is NOT necessary. */
+		ldata->ld_reclen = 0;
+		/* No more links, don't bother */
+		RETURN(0);
 	}
 
-        LASSERT(ma->ma_attr.la_valid & LA_CTIME);
-        la->la_ctime = la->la_mtime = ma->ma_attr.la_ctime;
+	if (oldpfid != NULL) {
+		rc = __mdd_links_del(env, mdd_obj, ldata, oldlname, oldpfid);
+		if (rc) {
+			if ((check == 0) ||
+			    (rc != -ENODATA && rc != -ENOENT))
+				RETURN(rc);
+			/* No changes done. */
+			rc = 0;
+		}
+	}
 
-        la->la_valid = LA_CTIME | LA_MTIME;
-	rc = mdd_attr_check_set_internal(env, mdd_tobj, la, handle, 0);
-        if (rc)
-                GOTO(out_unlock, rc);
+	/* If renaming, add the new record */
+	if (newpfid != NULL) {
+		/* even if the add fails, we still delete the out-of-date
+		 * old link */
+		rc2 = __mdd_links_add(env, mdd_obj, ldata, newlname, newpfid,
+				      first, check);
+		if (rc2 == -EEXIST)
+			rc2 = 0;
+	}
 
-        la->la_valid = LA_CTIME;
-        rc = mdd_attr_check_set_internal(env, mdd_sobj, la, handle, 0);
-        if (rc == 0) {
-                mdd_links_add(env, mdd_sobj,
-                              mdo2fid(mdd_tobj), lname, handle, 0);
-        }
+	rc = rc != 0 ? rc : rc2;
 
-        EXIT;
-out_unlock:
-        mdd_write_unlock(env, mdd_sobj);
-        mdd_pdo_write_unlock(env, mdd_tobj, dlh);
-out_trans:
-        if (rc == 0)
-		rc = mdd_changelog_ns_store(env, mdd, CL_HARDLINK, 0, mdd_sobj,
-					    mdd_tobj, lname, handle);
-stop:
-        mdd_trans_stop(env, mdd, rc, handle);
-out_pending:
-        return rc;
+	RETURN(rc);
 }
 
-int mdd_declare_finish_unlink(const struct lu_env *env,
-			      struct mdd_object *obj,
-			      struct md_attr *ma,
-			      struct thandle *handle)
+int mdd_links_rename(const struct lu_env *env,
+		     struct mdd_object *mdd_obj,
+		     const struct lu_fid *oldpfid,
+		     const struct lu_name *oldlname,
+		     const struct lu_fid *newpfid,
+		     const struct lu_name *newlname,
+		     struct thandle *handle,
+		     struct linkea_data *ldata,
+		     int first, int check)
 {
-	int	rc;
+	int rc2 = 0;
+	int rc = 0;
+	ENTRY;
 
-	rc = orph_declare_index_insert(env, obj, mdd_object_type(obj), handle);
-	if (rc)
-		return rc;
+	if (ldata == NULL) {
+		ldata = &mdd_env_info(env)->mti_link_data;
+		memset(ldata, 0, sizeof(*ldata));
+		rc = mdd_linkea_prepare(env, mdd_obj, oldpfid, oldlname,
+					newpfid, newlname, first, check,
+					ldata);
+		if (rc != 0)
+			GOTO(out, rc);
+	}
 
-	return mdo_declare_destroy(env, obj, handle);
-}
+	if (ldata->ld_reclen != 0)
+		rc = mdd_links_write(env, mdd_obj, ldata, handle);
+	EXIT;
+out:
+	if (rc == 0)
+		rc = rc2;
+	if (rc) {
+		int error = 1;
+		if (rc == -EOVERFLOW || rc == -ENOENT || rc == -ENOSPC)
+			error = 0;
+		if (oldpfid == NULL)
+			CDEBUG(error ? D_ERROR : D_OTHER,
+			       "link_ea add '%.*s' failed %d "DFID"\n",
+			       newlname->ln_namelen, newlname->ln_name,
+			       rc, PFID(mdd_object_fid(mdd_obj)));
+		else if (newpfid == NULL)
+			CDEBUG(error ? D_ERROR : D_OTHER,
+			       "link_ea del '%.*s' failed %d "DFID"\n",
+			       oldlname->ln_namelen, oldlname->ln_name,
+			       rc, PFID(mdd_object_fid(mdd_obj)));
+		else
+			CDEBUG(error ? D_ERROR : D_OTHER,
+			       "link_ea rename '%.*s'->'%.*s' failed %d "
+			       DFID"\n",
+			       oldlname->ln_namelen, oldlname->ln_name,
+			       newlname->ln_namelen, newlname->ln_name,
+			       rc, PFID(mdd_object_fid(mdd_obj)));
+	}
 
-/* caller should take a lock before calling */
-int mdd_finish_unlink(const struct lu_env *env,
-                      struct mdd_object *obj, struct md_attr *ma,
-                      struct thandle *th)
-{
-	int rc = 0;
-        int is_dir = S_ISDIR(ma->ma_attr.la_mode);
-        ENTRY;
+	if (ldata->ld_buf && ldata->ld_buf->lb_len > OBD_ALLOC_BIG)
+		/* if we vmalloced a large buffer drop it */
+		lu_buf_free(ldata->ld_buf);
 
-        LASSERT(mdd_write_locked(env, obj) != 0);
+	return rc;
+}
 
-	if (rc == 0 && (ma->ma_attr.la_nlink == 0 || is_dir)) {
-                obj->mod_flags |= DEAD_OBJ;
-                /* add new orphan and the object
-                 * will be deleted during mdd_close() */
+static inline int mdd_links_add(const struct lu_env *env,
+				struct mdd_object *mdd_obj,
+				const struct lu_fid *pfid,
+				const struct lu_name *lname,
+				struct thandle *handle,
+				struct linkea_data *data, int first)
+{
+	return mdd_links_rename(env, mdd_obj, NULL, NULL,
+				pfid, lname, handle, data, first, 0);
+}
+
+static inline int mdd_links_del(const struct lu_env *env,
+				struct mdd_object *mdd_obj,
+				const struct lu_fid *pfid,
+				const struct lu_name *lname,
+				struct thandle *handle)
+{
+	return mdd_links_rename(env, mdd_obj, pfid, lname,
+				NULL, NULL, handle, NULL, 0, 0);
+}
+
+/** Read the link EA into a temp buffer.
+ * Uses the mdd_thread_info::mti_big_buf since it is generally large.
+ * A pointer to the buffer is stored in \a ldata::ld_buf.
+ *
+ * \retval 0 or error
+ */
+int mdd_links_read(const struct lu_env *env, struct mdd_object *mdd_obj,
+		   struct linkea_data *ldata)
+{
+	int rc;
+
+	/* First try a small buf */
+	LASSERT(env != NULL);
+	ldata->ld_buf = lu_buf_check_and_alloc(&mdd_env_info(env)->mti_link_buf,
+					       CFS_PAGE_SIZE);
+	if (ldata->ld_buf->lb_buf == NULL)
+		return -ENOMEM;
+
+	if (!mdd_object_exists(mdd_obj))
+		return -ENODATA;
+
+	rc = mdo_xattr_get(env, mdd_obj, ldata->ld_buf, XATTR_NAME_LINK,
+			  BYPASS_CAPA);
+	if (rc == -ERANGE) {
+		/* Buf was too small, figure out what we need. */
+		lu_buf_free(ldata->ld_buf);
+		rc = mdo_xattr_get(env, mdd_obj, ldata->ld_buf,
+				   XATTR_NAME_LINK, BYPASS_CAPA);
+		if (rc < 0)
+			return rc;
+		ldata->ld_buf = lu_buf_check_and_alloc(ldata->ld_buf, rc);
+		if (ldata->ld_buf->lb_buf == NULL)
+			return -ENOMEM;
+		rc = mdo_xattr_get(env, mdd_obj, ldata->ld_buf,
+				  XATTR_NAME_LINK, BYPASS_CAPA);
+	}
+	if (rc < 0)
+		return rc;
+
+	linkea_init(ldata);
+	return 0;
+}
+
+/** Read the link EA into a temp buffer.
+ * Uses the name_buf since it is generally large.
+ * \retval IS_ERR err
+ * \retval ptr to \a lu_buf (always \a mti_big_buf)
+ */
+struct lu_buf *mdd_links_get(const struct lu_env *env,
+			     struct mdd_object *mdd_obj)
+{
+	struct linkea_data ldata = { 0 };
+	int rc;
+
+	rc = mdd_links_read(env, mdd_obj, &ldata);
+	return rc ? ERR_PTR(rc) : ldata.ld_buf;
+}
+
+int mdd_links_write(const struct lu_env *env, struct mdd_object *mdd_obj,
+		    struct linkea_data *ldata, struct thandle *handle)
+{
+	const struct lu_buf *buf = mdd_buf_get_const(env, ldata->ld_buf->lb_buf,
+						     ldata->ld_leh->leh_len);
+	return mdo_xattr_set(env, mdd_obj, buf, XATTR_NAME_LINK, 0, handle,
+			     mdd_object_capa(env, mdd_obj));
+}
+
+int mdd_declare_links_add(const struct lu_env *env, struct mdd_object *mdd_obj,
+			  struct thandle *handle, struct linkea_data *ldata)
+{
+	int	rc;
+	int	ea_len;
+	void	*linkea;
+
+	if (ldata != NULL && ldata->ld_lee != NULL) {
+		ea_len = ldata->ld_leh->leh_len;
+		linkea = ldata->ld_buf->lb_buf;
+	} else {
+		ea_len = DEFAULT_LINKEA_SIZE;
+		linkea = NULL;
+	}
+
+	/* XXX: max size? */
+	rc = mdo_declare_xattr_set(env, mdd_obj,
+				   mdd_buf_get_const(env, linkea, ea_len),
+				   XATTR_NAME_LINK, 0, handle);
+	return rc;
+}
+
+static inline int mdd_declare_links_del(const struct lu_env *env,
+					struct mdd_object *c,
+					struct thandle *handle)
+{
+	int rc = 0;
+
+	/* For directory, the linkEA will be removed together
+	 * with the object. */
+	if (!S_ISDIR(mdd_object_type(c)))
+		rc = mdd_declare_links_add(env, c, handle, NULL);
+
+	return rc;
+}
+
+static int mdd_declare_link(const struct lu_env *env,
+                            struct mdd_device *mdd,
+                            struct mdd_object *p,
+                            struct mdd_object *c,
+                            const struct lu_name *name,
+			    struct thandle *handle,
+			    struct lu_attr *la,
+			    struct linkea_data *data)
+{
+        int rc;
+
+        rc = mdo_declare_index_insert(env, p, mdo2fid(c), name->ln_name,handle);
+        if (rc)
+                return rc;
+
+        rc = mdo_declare_ref_add(env, c, handle);
+        if (rc)
+                return rc;
+
+	la->la_valid = LA_CTIME | LA_MTIME;
+	rc = mdo_declare_attr_set(env, p, la, handle);
+	if (rc != 0)
+		return rc;
+
+	la->la_valid = LA_CTIME;
+	rc = mdo_declare_attr_set(env, c, la, handle);
+        if (rc)
+                return rc;
+
+	rc = mdd_declare_links_add(env, c, handle, data);
+        if (rc)
+                return rc;
+
+        rc = mdd_declare_changelog_store(env, mdd, name, handle);
+
+        return rc;
+}
+
+static int mdd_link(const struct lu_env *env, struct md_object *tgt_obj,
+                    struct md_object *src_obj, const struct lu_name *lname,
+                    struct md_attr *ma)
+{
+        const char *name = lname->ln_name;
+        struct lu_attr    *la = &mdd_env_info(env)->mti_la_for_fix;
+        struct mdd_object *mdd_tobj = md2mdd_obj(tgt_obj);
+        struct mdd_object *mdd_sobj = md2mdd_obj(src_obj);
+        struct mdd_device *mdd = mdo2mdd(src_obj);
+        struct dynlock_handle *dlh;
+        struct thandle *handle;
+	struct linkea_data *ldata = &mdd_env_info(env)->mti_link_data;
+        int rc;
+        ENTRY;
+
+        handle = mdd_trans_create(env, mdd);
+        if (IS_ERR(handle))
+                GOTO(out_pending, rc = PTR_ERR(handle));
+
+	memset(ldata, 0, sizeof(*ldata));
+
+	LASSERT(ma->ma_attr.la_valid & LA_CTIME);
+	la->la_ctime = la->la_mtime = ma->ma_attr.la_ctime;
+
+	rc = mdd_declare_link(env, mdd, mdd_tobj, mdd_sobj, lname, handle,
+			      la, ldata);
+        if (rc)
+                GOTO(stop, rc);
+
+        rc = mdd_trans_start(env, mdd, handle);
+        if (rc)
+                GOTO(stop, rc);
+
+        dlh = mdd_pdo_write_lock(env, mdd_tobj, name, MOR_TGT_CHILD);
+        if (dlh == NULL)
+                GOTO(out_trans, rc = -ENOMEM);
+        mdd_write_lock(env, mdd_sobj, MOR_TGT_CHILD);
+
+        rc = mdd_link_sanity_check(env, mdd_tobj, lname, mdd_sobj);
+        if (rc)
+                GOTO(out_unlock, rc);
+
+	rc = mdo_ref_add(env, mdd_sobj, handle);
+	if (rc)
+		GOTO(out_unlock, rc);
+
+
+	rc = __mdd_index_insert_only(env, mdd_tobj, mdo2fid(mdd_sobj),
+				     name, handle,
+				     mdd_object_capa(env, mdd_tobj));
+	if (rc != 0) {
+		mdo_ref_del(env, mdd_sobj, handle);
+		GOTO(out_unlock, rc);
+	}
+
+        la->la_valid = LA_CTIME | LA_MTIME;
+	rc = mdd_attr_check_set_internal(env, mdd_tobj, la, handle, 0);
+        if (rc)
+                GOTO(out_unlock, rc);
+
+        la->la_valid = LA_CTIME;
+        rc = mdd_attr_check_set_internal(env, mdd_sobj, la, handle, 0);
+	if (rc == 0) {
+		rc = mdd_linkea_prepare(env, mdd_sobj, NULL, NULL,
+					mdo2fid(mdd_tobj), lname, 0, 0,
+					ldata);
+		if (rc == 0)
+			mdd_links_add(env, mdd_sobj, mdo2fid(mdd_tobj),
+				      lname, handle, ldata, 0);
+		/* The failure of links_add should not cause the link
+		 * failure, reset rc here */
+		rc = 0;
+	}
+        EXIT;
+out_unlock:
+        mdd_write_unlock(env, mdd_sobj);
+        mdd_pdo_write_unlock(env, mdd_tobj, dlh);
+out_trans:
+        if (rc == 0)
+		rc = mdd_changelog_ns_store(env, mdd, CL_HARDLINK, 0, mdd_sobj,
+					    mdd_tobj, lname, handle);
+stop:
+	mdd_trans_stop(env, mdd, rc, handle);
+
+	if (ldata->ld_buf && ldata->ld_buf->lb_len > OBD_ALLOC_BIG)
+		/* if we vmalloced a large buffer drop it */
+		lu_buf_free(ldata->ld_buf);
+out_pending:
+        return rc;
+}
+
+int mdd_declare_finish_unlink(const struct lu_env *env,
+			      struct mdd_object *obj,
+			      struct md_attr *ma,
+			      struct thandle *handle)
+{
+	int	rc;
+
+	rc = orph_declare_index_insert(env, obj, mdd_object_type(obj), handle);
+	if (rc)
+		return rc;
+
+	return mdo_declare_destroy(env, obj, handle);
+}
+
+/* caller should take a lock before calling */
+int mdd_finish_unlink(const struct lu_env *env,
+                      struct mdd_object *obj, struct md_attr *ma,
+                      struct thandle *th)
+{
+	int rc = 0;
+        int is_dir = S_ISDIR(ma->ma_attr.la_mode);
+        ENTRY;
+
+        LASSERT(mdd_write_locked(env, obj) != 0);
+
+	if (ma->ma_attr.la_nlink == 0 || is_dir) {
+                obj->mod_flags |= DEAD_OBJ;
+
+                /* add new orphan and the object
+                 * will be deleted during mdd_close() */
                 if (obj->mod_count) {
                         rc = __mdd_orphan_add(env, obj, th);
                         if (rc == 0)
@@ -1078,125 +1335,168 @@ int mdd_unlink_sanity_check(const struct lu_env *env, struct mdd_object *pobj,
 }
 
 static int mdd_declare_unlink(const struct lu_env *env, struct mdd_device *mdd,
-                              struct mdd_object *p, struct mdd_object *c,
-                              const struct lu_name *name, struct md_attr *ma,
-                              struct thandle *handle)
+			      struct mdd_object *p, struct mdd_object *c,
+			      const struct lu_name *name, struct md_attr *ma,
+			      struct thandle *handle, int no_name)
 {
+	struct lu_attr     *la = &mdd_env_info(env)->mti_la_for_fix;
         int rc;
 
-        rc = mdo_declare_index_delete(env, p, name->ln_name, handle);
-        if (rc)
-                return rc;
+	if (likely(no_name == 0)) {
+		rc = mdo_declare_index_delete(env, p, name->ln_name, handle);
+		if (rc)
+			return rc;
+	}
 
         rc = mdo_declare_ref_del(env, p, handle);
         if (rc)
                 return rc;
 
-        rc = mdo_declare_ref_del(env, c, handle);
-        if (rc)
-                return rc;
+	LASSERT(ma->ma_attr.la_valid & LA_CTIME);
+	la->la_ctime = la->la_mtime = ma->ma_attr.la_ctime;
+	la->la_valid = LA_CTIME | LA_MTIME;
+	rc = mdo_declare_attr_set(env, p, la, handle);
+	if (rc)
+		return rc;
 
-        rc = mdo_declare_ref_del(env, c, handle);
-        if (rc)
-                return rc;
+	if (c != NULL) {
+		rc = mdo_declare_ref_del(env, c, handle);
+		if (rc)
+			return rc;
 
-        rc = mdo_declare_attr_set(env, p, NULL, handle);
-        if (rc)
-                return rc;
+		rc = mdo_declare_ref_del(env, c, handle);
+		if (rc)
+			return rc;
 
-        rc = mdo_declare_attr_set(env, c, NULL, handle);
-        if (rc)
-                return rc;
+		la->la_valid = LA_CTIME;
+		rc = mdo_declare_attr_set(env, c, la, handle);
+		if (rc)
+			return rc;
 
-        rc = mdd_declare_finish_unlink(env, c, ma, handle);
-        if (rc)
-                return rc;
+		rc = mdd_declare_finish_unlink(env, c, ma, handle);
+		if (rc)
+			return rc;
 
-        rc = mdd_declare_links_add(env, c, handle);
-        if (rc)
-                return rc;
+		rc = mdd_declare_links_del(env, c, handle);
+		if (rc != 0)
+			return rc;
 
-        rc = mdd_declare_changelog_store(env, mdd, name, handle);
+		/* FIXME: need changelog for remove entry */
+		rc = mdd_declare_changelog_store(env, mdd, name, handle);
+	}
 
-        return rc;
+	return rc;
 }
 
+/**
+ * Delete name entry and the object.
+ * Note: no_name == 1 means it only destory the object, i.e. name_entry
+ * does not exist for this object, and it could only happen during resending
+ * of remote unlink. see the comments in mdt_reint_unlink. Unfortunately, lname
+ * is also needed in this case(needed by changelog), so we have to add another
+ * parameter(no_name)here. XXX: this is only needed in DNE phase I, on Phase II,
+ * the ENOENT failure should be able to be fixed by redo mechanism.
+ */
 static int mdd_unlink(const struct lu_env *env, struct md_object *pobj,
-                      struct md_object *cobj, const struct lu_name *lname,
-                      struct md_attr *ma)
+		      struct md_object *cobj, const struct lu_name *lname,
+		      struct md_attr *ma, int no_name)
 {
         const char *name = lname->ln_name;
 	struct lu_attr     *cattr = &mdd_env_info(env)->mti_cattr;
         struct lu_attr    *la = &mdd_env_info(env)->mti_la_for_fix;
         struct mdd_object *mdd_pobj = md2mdd_obj(pobj);
-        struct mdd_object *mdd_cobj = md2mdd_obj(cobj);
+	struct mdd_object *mdd_cobj = NULL;
         struct mdd_device *mdd = mdo2mdd(pobj);
         struct dynlock_handle *dlh;
         struct thandle    *handle;
-	int rc, is_dir;
+	int rc, is_dir = 0;
         ENTRY;
 
-        if (mdd_object_exists(mdd_cobj) <= 0)
-                RETURN(-ENOENT);
+	/* cobj == NULL means only delete name entry */
+	if (likely(cobj != NULL)) {
+		mdd_cobj = md2mdd_obj(cobj);
+		if (mdd_object_exists(mdd_cobj) == 0)
+			RETURN(-ENOENT);
+		/* currently it is assume, it could only delete
+		 * name entry of remote directory */
+		is_dir = 1;
+	}
 
-        handle = mdd_trans_create(env, mdd);
+	handle = mdd_trans_create(env, mdd);
         if (IS_ERR(handle))
                 RETURN(PTR_ERR(handle));
 
-        rc = mdd_declare_unlink(env, mdd, mdd_pobj, mdd_cobj,
-                                lname, ma, handle);
-        if (rc)
-                GOTO(stop, rc);
+	rc = mdd_declare_unlink(env, mdd, mdd_pobj, mdd_cobj,
+				lname, ma, handle, no_name);
+	if (rc)
+		GOTO(stop, rc);
 
-        rc = mdd_trans_start(env, mdd, handle);
-        if (rc)
-                GOTO(stop, rc);
+	rc = mdd_trans_start(env, mdd, handle);
+	if (rc)
+		GOTO(stop, rc);
 
-        dlh = mdd_pdo_write_lock(env, mdd_pobj, name, MOR_TGT_PARENT);
-        if (dlh == NULL)
+	dlh = mdd_pdo_write_lock(env, mdd_pobj, name, MOR_TGT_PARENT);
+	if (dlh == NULL)
 		GOTO(stop, rc = -ENOMEM);
-        mdd_write_lock(env, mdd_cobj, MOR_TGT_CHILD);
 
-	/* fetch cattr */
-	rc = mdd_la_get(env, mdd_cobj, cattr, mdd_object_capa(env, mdd_cobj));
-        if (rc)
-                GOTO(cleanup, rc);
+	if (likely(mdd_cobj != NULL)) {
+		mdd_write_lock(env, mdd_cobj, MOR_TGT_CHILD);
 
-	is_dir = S_ISDIR(cattr->la_mode);
+		/* fetch cattr */
+		rc = mdd_la_get(env, mdd_cobj, cattr,
+				mdd_object_capa(env, mdd_cobj));
+		if (rc)
+			GOTO(cleanup, rc);
 
-	rc = mdd_unlink_sanity_check(env, mdd_pobj, mdd_cobj, cattr);
-        if (rc)
-                GOTO(cleanup, rc);
+		is_dir = S_ISDIR(cattr->la_mode);
 
-	rc = __mdd_index_delete(env, mdd_pobj, name, is_dir, handle,
-				mdd_object_capa(env, mdd_pobj));
+	}
+
+	rc = mdd_unlink_sanity_check(env, mdd_pobj, mdd_cobj, cattr);
 	if (rc)
 		GOTO(cleanup, rc);
 
-	rc = mdo_ref_del(env, mdd_cobj, handle);
-	if (rc != 0) {
-		__mdd_index_insert_only(env, mdd_pobj, mdo2fid(mdd_cobj),
-					name, handle,
+	if (likely(no_name == 0)) {
+		rc = __mdd_index_delete(env, mdd_pobj, name, is_dir, handle,
 					mdd_object_capa(env, mdd_pobj));
-		GOTO(cleanup, rc);
+		if (rc)
+			GOTO(cleanup, rc);
 	}
 
-        if (is_dir)
-                /* unlink dot */
-                mdo_ref_del(env, mdd_cobj, handle);
+	if (likely(mdd_cobj != NULL)) {
+		rc = mdo_ref_del(env, mdd_cobj, handle);
+		if (rc != 0) {
+			__mdd_index_insert_only(env, mdd_pobj,
+						mdo2fid(mdd_cobj),
+						name, handle,
+						mdd_object_capa(env, mdd_pobj));
+			GOTO(cleanup, rc);
+		}
 
-	/* fetch updated nlink */
-	rc = mdd_la_get(env, mdd_cobj, cattr, mdd_object_capa(env, mdd_cobj));
-	if (rc)
-		GOTO(cleanup, rc);
+		if (is_dir)
+			/* unlink dot */
+			mdo_ref_del(env, mdd_cobj, handle);
 
-        LASSERT(ma->ma_attr.la_valid & LA_CTIME);
-        la->la_ctime = la->la_mtime = ma->ma_attr.la_ctime;
+		/* fetch updated nlink */
+		rc = mdd_la_get(env, mdd_cobj, cattr,
+				mdd_object_capa(env, mdd_cobj));
+		if (rc)
+			GOTO(cleanup, rc);
+	}
 
-        la->la_valid = LA_CTIME | LA_MTIME;
+	LASSERT(ma->ma_attr.la_valid & LA_CTIME);
+	la->la_ctime = la->la_mtime = ma->ma_attr.la_ctime;
+
+	la->la_valid = LA_CTIME | LA_MTIME;
 	rc = mdd_attr_check_set_internal(env, mdd_pobj, la, handle, 0);
-        if (rc)
-                GOTO(cleanup, rc);
+	if (rc)
+		GOTO(cleanup, rc);
+
+	/* Enough for only unlink the entry */
+	if (unlikely(mdd_cobj == NULL)) {
+		mdd_pdo_write_unlock(env, mdd_pobj, dlh);
+		GOTO(stop, rc);
+	}
 
 	if (cattr->la_nlink > 0 || mdd_cobj->mod_count > 0) {
                 /* update ctime of an unlinked file only if it is still
@@ -1278,11 +1578,6 @@ static int mdd_create_data(const struct lu_env *env, struct md_object *pobj,
         int                rc;
         ENTRY;
 
-	/* do not let users to create stripes via .lustre/
-	 * mdd_obf_setup() sets IMMUTE_OBJ on this directory */
-	if (pobj && mdd_pobj->mod_flags & IMMUTE_OBJ)
-		RETURN(-ENOENT);
-
         rc = mdd_cd_sanity_check(env, son);
         if (rc)
                 RETURN(rc);
@@ -1328,12 +1623,22 @@ static int mdd_create_data(const struct lu_env *env, struct md_object *pobj,
 	if (rc)
 		GOTO(stop, rc);
 
+	rc = mdd_declare_changelog_store(env, mdd, NULL, handle);
+	if (rc)
+		GOTO(stop, rc);
+
 	rc = mdd_trans_start(env, mdd, handle);
 	if (rc)
 		GOTO(stop, rc);
 
 	rc = dt_xattr_set(env, mdd_object_child(son), buf, XATTR_NAME_LOV,
 			  0, handle, mdd_object_capa(env, son));
+
+	if (rc)
+		GOTO(stop, rc);
+
+	rc = mdd_changelog_data_store(env, mdd, CL_LAYOUT, 0, son, handle);
+
 stop:
 	mdd_trans_stop(env, mdd, rc, handle);
 out_free:
@@ -1356,14 +1661,12 @@ __mdd_lookup(const struct lu_env *env, struct md_object *pobj,
         if (unlikely(mdd_is_dead_obj(mdd_obj)))
                 RETURN(-ESTALE);
 
-        rc = mdd_object_exists(mdd_obj);
-        if (unlikely(rc == 0))
-                RETURN(-ESTALE);
-        else if (unlikely(rc < 0)) {
-                CERROR("Object "DFID" locates on remote server\n",
-                        PFID(mdo2fid(mdd_obj)));
-                RETURN(-EINVAL);
-        }
+	if (mdd_object_remote(mdd_obj)) {
+		CDEBUG(D_INFO, "%s: Object "DFID" locates on remote server\n",
+		       mdd2obd_dev(m)->obd_name, PFID(mdo2fid(mdd_obj)));
+	} else if (!mdd_object_exists(mdd_obj)) {
+		RETURN(-ESTALE);
+	}
 
         /* The common filename length check. */
         if (unlikely(lname->ln_namelen > m->mdd_dt_conf.ddp_max_name_len))
@@ -1390,12 +1693,15 @@ __mdd_lookup(const struct lu_env *env, struct md_object *pobj,
         RETURN(rc);
 }
 
-int mdd_declare_object_initialize(const struct lu_env *env,
-				  struct mdd_object *child,
-				  struct lu_attr *attr,
-				  struct thandle *handle)
+static int mdd_declare_object_initialize(const struct lu_env *env,
+					 struct mdd_object *parent,
+					 struct mdd_object *child,
+					 struct lu_attr *attr,
+					 struct thandle *handle,
+					 struct linkea_data *ldata)
 {
         int rc;
+	ENTRY;
 
 	/*
 	 * inode mode has been set in creation time, and it's based on umask,
@@ -1412,18 +1718,24 @@ int mdd_declare_object_initialize(const struct lu_env *env,
 					      dot, handle);
                 if (rc == 0)
                         rc = mdo_declare_ref_add(env, child, handle);
+
+		rc = mdo_declare_index_insert(env, child, mdo2fid(parent),
+					      dotdot, handle);
         }
 
-        if (rc == 0)
-                mdd_declare_links_add(env, child, handle);
+	if (rc == 0)
+		mdd_declare_links_add(env, child, handle, ldata);
 
-        return rc;
+	RETURN(rc);
 }
 
-int mdd_object_initialize(const struct lu_env *env, const struct lu_fid *pfid,
-			  const struct lu_name *lname, struct mdd_object *child,
-			  struct lu_attr *attr, struct thandle *handle,
-			  const struct md_op_spec *spec)
+static int mdd_object_initialize(const struct lu_env *env,
+				 const struct lu_fid *pfid,
+				 const struct lu_name *lname,
+				 struct mdd_object *child,
+				 struct lu_attr *attr, struct thandle *handle,
+				 const struct md_op_spec *spec,
+				 struct linkea_data *ldata)
 {
         int rc;
         ENTRY;
@@ -1436,20 +1748,8 @@ int mdd_object_initialize(const struct lu_env *env, const struct lu_fid *pfid,
          *  (2) maybe, the child attributes should be set in OSD when creation.
          */
 
-	/*
-	 * inode mode has been set in creation time, and it's based on umask,
-	 * la_mode and acl, don't set here again! (which will go wrong
-	 * because below function doesn't consider umask).
-	 * I'd suggest set all object attributes in creation time, see above.
-	 */
-	LASSERT(attr->la_valid & (LA_MODE | LA_TYPE));
-	attr->la_valid &= ~(LA_MODE | LA_TYPE);
 	rc = mdd_attr_set_internal(env, child, attr, handle, 0);
 	/* arguments are supposed to stay the same */
-	attr->la_valid |= LA_MODE | LA_TYPE;
-	if (rc != 0)
-		RETURN(rc);
-
 	if (S_ISDIR(attr->la_mode)) {
                 /* Add "." and ".." for newly created dir */
                 mdo_ref_add(env, child, handle);
@@ -1462,10 +1762,11 @@ int mdd_object_initialize(const struct lu_env *env, const struct lu_fid *pfid,
                 if (rc != 0)
                         mdo_ref_del(env, child, handle);
         }
-        if (rc == 0)
-                mdd_links_add(env, child, pfid, lname, handle, 1);
 
-        RETURN(rc);
+	if (rc == 0)
+		mdd_links_add(env, child, pfid, lname, handle, ldata, 1);
+
+	RETURN(rc);
 }
 
 /* has not lock on pobj yet */
@@ -1480,7 +1781,6 @@ static int mdd_create_sanity_check(const struct lu_env *env,
         struct lu_fid     *fid       = &info->mti_fid;
         struct mdd_object *obj       = md2mdd_obj(pobj);
         struct mdd_device *m         = mdo2mdd(pobj);
-        int lookup                   = spec->sp_cr_lookup;
         int rc;
         ENTRY;
 
@@ -1488,12 +1788,12 @@ static int mdd_create_sanity_check(const struct lu_env *env,
         if (mdd_is_dead_obj(obj))
                 RETURN(-ENOENT);
 
-        /*
+	/*
          * In some cases this lookup is not needed - we know before if name
          * exists or not because MDT performs lookup for it.
          * name length check is done in lookup.
          */
-        if (lookup) {
+	if (spec->sp_cr_lookup) {
                 /*
                  * Check if the name already exist, though it will be checked in
                  * _index_insert also, for avoiding rolling back if exists
@@ -1554,7 +1854,8 @@ static int mdd_declare_create(const struct lu_env *env, struct mdd_device *mdd,
 			      struct lu_attr *attr,
 			      int got_def_acl,
 			      struct thandle *handle,
-			      const struct md_op_spec *spec)
+			      const struct md_op_spec *spec,
+			      struct linkea_data *ldata)
 {
 	int rc;
 
@@ -1593,7 +1894,7 @@ static int mdd_declare_create(const struct lu_env *env, struct mdd_device *mdd,
 			GOTO(out, rc);
         }
 
-	rc = mdd_declare_object_initialize(env, c, attr, handle);
+	rc = mdd_declare_object_initialize(env, p, c, attr, handle, ldata);
 	if (rc)
 		GOTO(out, rc);
 
@@ -1639,6 +1940,41 @@ out:
         return rc;
 }
 
+static int mdd_acl_init(const struct lu_env *env, struct mdd_object *pobj,
+			struct lu_attr *la, struct lu_buf *acl_buf,
+			int *got_def_acl, int *reset_acl)
+{
+	int	rc;
+	ENTRY;
+
+	if (S_ISLNK(la->la_mode))
+		RETURN(0);
+
+	mdd_read_lock(env, pobj, MOR_TGT_PARENT);
+	rc = mdo_xattr_get(env, pobj, acl_buf,
+			   XATTR_NAME_ACL_DEFAULT, BYPASS_CAPA);
+	mdd_read_unlock(env, pobj);
+	if (rc > 0) {
+		/* If there are default ACL, fix mode by default ACL */
+		*got_def_acl = rc;
+		acl_buf->lb_len = rc;
+		rc = __mdd_fix_mode_acl(env, acl_buf, &la->la_mode);
+		if (rc < 0)
+			RETURN(rc);
+		*reset_acl = rc;
+	} else if (rc == -ENODATA || rc == -EOPNOTSUPP) {
+		/* If there are no default ACL, fix mode by mask */
+		struct lu_ucred *uc = lu_ucred(env);
+
+		/* The create triggered by MDT internal events, such as
+		 * LFSCK reset, will not contain valid "uc". */
+		if (unlikely(uc != NULL))
+			la->la_mode &= ~uc->uc_umask;
+		rc = 0;
+	}
+
+	RETURN(rc);
+}
 
 /*
  * Create object and insert it into namespace.
@@ -1655,10 +1991,13 @@ static int mdd_create(const struct lu_env *env, struct md_object *pobj,
 	struct lu_attr		*attr = &ma->ma_attr;
 	struct thandle		*handle;
 	struct lu_attr		*pattr = &info->mti_pattr;
+	struct lu_buf		acl_buf;
+	struct linkea_data	*ldata = &info->mti_link_data;
 	struct dynlock_handle	*dlh;
 	const char		*name = lname->ln_name;
 	int			 rc, created = 0, initialized = 0, inserted = 0;
 	int			 got_def_acl = 0;
+	int			 reset_acl = 0;
 	ENTRY;
 
         /*
@@ -1709,20 +2048,12 @@ static int mdd_create(const struct lu_env *env, struct md_object *pobj,
         if (OBD_FAIL_CHECK(OBD_FAIL_MDS_DQACQ_NET))
 		GOTO(out_free, rc = -EINPROGRESS);
 
-        if (!S_ISLNK(attr->la_mode)) {
-		struct lu_buf *acl_buf;
-
-		acl_buf = mdd_buf_get(env, info->mti_xattr_buf,
-				sizeof(info->mti_xattr_buf));
-                mdd_read_lock(env, mdd_pobj, MOR_TGT_PARENT);
-		rc = mdo_xattr_get(env, mdd_pobj, acl_buf,
-				XATTR_NAME_ACL_DEFAULT, BYPASS_CAPA);
-                mdd_read_unlock(env, mdd_pobj);
-		if (rc > 0)
-			got_def_acl = rc;
-		else if (rc < 0 && rc != -EOPNOTSUPP && rc != -ENODATA)
-			GOTO(out_free, rc);
-        }
+	acl_buf.lb_buf = info->mti_xattr_buf;
+	acl_buf.lb_len = sizeof(info->mti_xattr_buf);
+	rc = mdd_acl_init(env, mdd_pobj, attr, &acl_buf, &got_def_acl,
+			  &reset_acl);
+	if (rc < 0)
+		GOTO(out_free, rc);
 
 	mdd_object_make_hint(env, mdd_pobj, son, attr);
 
@@ -1730,8 +2061,11 @@ static int mdd_create(const struct lu_env *env, struct md_object *pobj,
         if (IS_ERR(handle))
                 GOTO(out_free, rc = PTR_ERR(handle));
 
+	memset(ldata, 0, sizeof(*ldata));
+	mdd_linkea_prepare(env, son, NULL, NULL, mdd_object_fid(mdd_pobj),
+			   lname, 1, 0, ldata);
 	rc = mdd_declare_create(env, mdd, mdd_pobj, son, lname, attr,
-				got_def_acl, handle, spec);
+				got_def_acl, handle, spec, ldata);
         if (rc)
                 GOTO(out_stop, rc);
 
@@ -1754,19 +2088,39 @@ static int mdd_create(const struct lu_env *env, struct md_object *pobj,
 
 #ifdef CONFIG_FS_POSIX_ACL
 	if (got_def_acl) {
-		struct lu_buf *acl_buf;
+		/* set default acl */
+		if (S_ISDIR(attr->la_mode)) {
+			LASSERTF(acl_buf.lb_len  == got_def_acl,
+				 "invalid acl_buf: %p:%d got_def %d\n",
+				 acl_buf.lb_buf, (int)acl_buf.lb_len,
+				 got_def_acl);
+			rc = mdo_xattr_set(env, son, &acl_buf,
+					   XATTR_NAME_ACL_DEFAULT, 0,
+					   handle, BYPASS_CAPA);
+			if (rc) {
+				mdd_write_unlock(env, son);
+				GOTO(cleanup, rc);
+			}
+		}
 
-		acl_buf = mdd_buf_get(env, info->mti_xattr_buf, got_def_acl);
-		rc = __mdd_acl_init(env, son, acl_buf, &attr->la_mode, handle);
-		if (rc) {
-			mdd_write_unlock(env, son);
-			GOTO(cleanup, rc);
+		/* set its own acl */
+		if (reset_acl) {
+			LASSERTF(acl_buf.lb_buf != NULL && acl_buf.lb_len != 0,
+				 "invalid acl_buf %p:%d\n", acl_buf.lb_buf,
+				 (int)acl_buf.lb_len);
+			rc = mdo_xattr_set(env, son, &acl_buf,
+					   XATTR_NAME_ACL_ACCESS,
+					   0, handle, BYPASS_CAPA);
+			if (rc) {
+				mdd_write_unlock(env, son);
+				GOTO(cleanup, rc);
+			}
 		}
 	}
 #endif
 
 	rc = mdd_object_initialize(env, mdo2fid(mdd_pobj), lname,
-				   son, attr, handle, spec);
+				   son, attr, handle, spec, ldata);
 
 	/*
 	 * in case of replay we just set LOVEA provided by the client
@@ -1878,7 +2232,7 @@ cleanup:
 
         mdd_pdo_write_unlock(env, mdd_pobj, dlh);
 out_trans:
-        if (rc == 0)
+	if (rc == 0 && fid_is_namespace_visible(mdo2fid(son)))
 		rc = mdd_changelog_ns_store(env, mdd,
 			S_ISDIR(attr->la_mode) ? CL_MKDIR :
 			S_ISREG(attr->la_mode) ? CL_CREATE :
@@ -1887,6 +2241,10 @@ out_trans:
 out_stop:
         mdd_trans_stop(env, mdd, rc, handle);
 out_free:
+	if (ldata->ld_buf && ldata->ld_buf->lb_len > OBD_ALLOC_BIG)
+		/* if we vmalloced a large buffer drop it */
+		lu_buf_free(ldata->ld_buf);
+
         /* The child object shouldn't be cached anymore */
         if (rc)
 		set_bit(LU_OBJECT_HEARD_BANSHEE,
@@ -1944,49 +2302,54 @@ static int mdd_rename_sanity_check(const struct lu_env *env,
 				   struct lu_attr *so_attr,
 				   struct lu_attr *tg_attr)
 {
-        int rc = 0;
-        ENTRY;
+	int rc = 0;
+	ENTRY;
 
-        /* XXX: when get here, sobj must NOT be NULL,
-         * the other case has been processed in cml_rename
-         * before mdd_rename and enable MDS_PERM_BYPASS. */
-        LASSERT(sobj);
+	/* XXX: when get here, sobj must NOT be NULL,
+	 * the other case has been processed in cld_rename
+	 * before mdd_rename and enable MDS_PERM_BYPASS. */
+	LASSERT(sobj);
 
 	rc = mdd_may_delete(env, src_pobj, sobj, so_attr, NULL, 1, 0);
-        if (rc)
-                RETURN(rc);
+	if (rc)
+		RETURN(rc);
 
-        /* XXX: when get here, "tobj == NULL" means tobj must
-         * NOT exist (neither on remote MDS, such case has been
-         * processed in cml_rename before mdd_rename and enable
-         * MDS_PERM_BYPASS).
-         * So check may_create, but not check may_unlink. */
-        if (!tobj)
-                rc = mdd_may_create(env, tgt_pobj, NULL,
-                                    (src_pobj != tgt_pobj), 0);
-        else
+	/* XXX: when get here, "tobj == NULL" means tobj must
+	 * NOT exist (neither on remote MDS, such case has been
+	 * processed in cld_rename before mdd_rename and enable
+	 * MDS_PERM_BYPASS).
+	 * So check may_create, but not check may_unlink. */
+	if (!tobj)
+		rc = mdd_may_create(env, tgt_pobj, NULL,
+				    (src_pobj != tgt_pobj), 0);
+	else
 		rc = mdd_may_delete(env, tgt_pobj, tobj, tg_attr, so_attr,
-                                    (src_pobj != tgt_pobj), 1);
+				    (src_pobj != tgt_pobj), 1);
 
-        if (!rc && !tobj && (src_pobj != tgt_pobj) &&
+	if (!rc && !tobj && (src_pobj != tgt_pobj) &&
 	    S_ISDIR(so_attr->la_mode))
-                rc = __mdd_may_link(env, tgt_pobj);
+		rc = __mdd_may_link(env, tgt_pobj);
 
-        RETURN(rc);
+	RETURN(rc);
 }
 
 static int mdd_declare_rename(const struct lu_env *env,
-                              struct mdd_device *mdd,
-                              struct mdd_object *mdd_spobj,
-                              struct mdd_object *mdd_tpobj,
-                              struct mdd_object *mdd_sobj,
-                              struct mdd_object *mdd_tobj,
-                              const struct lu_name *tname,
+			      struct mdd_device *mdd,
+			      struct mdd_object *mdd_spobj,
+			      struct mdd_object *mdd_tpobj,
+			      struct mdd_object *mdd_sobj,
+			      struct mdd_object *mdd_tobj,
+			      const struct lu_name *tname,
 			      const struct lu_name *sname,
-                              struct md_attr *ma,
-                              struct thandle *handle)
+			      struct md_attr *ma,
+			      struct linkea_data *ldata,
+			      struct thandle *handle)
 {
-        int rc;
+	struct lu_attr    *la = &mdd_env_info(env)->mti_la_for_fix;
+	int rc;
+
+	LASSERT(ma->ma_attr.la_valid & LA_CTIME);
+	la->la_ctime = la->la_mtime = ma->ma_attr.la_ctime;
 
         LASSERT(mdd_spobj);
         LASSERT(mdd_tpobj);
@@ -2004,16 +2367,18 @@ static int mdd_declare_rename(const struct lu_env *env,
                 rc = mdo_declare_ref_del(env, mdd_spobj, handle);
                 if (rc)
                         return rc;
+		if (mdd_spobj != mdd_tpobj) {
+			rc = mdo_declare_index_delete(env, mdd_sobj, dotdot,
+						      handle);
+			if (rc)
+				return rc;
 
-                rc = mdo_declare_index_delete(env, mdd_sobj, dotdot, handle);
-                if (rc)
-                        return rc;
-
-                rc = mdo_declare_index_insert(env, mdd_sobj, mdo2fid(mdd_tpobj),
-                                              dotdot, handle);
-                if (rc)
-                        return rc;
-
+			rc = mdo_declare_index_insert(env, mdd_sobj,
+						      mdo2fid(mdd_tpobj),
+						      dotdot, handle);
+			if (rc)
+				return rc;
+		}
                 /* new target child can be directory,
                  * counted by target dir's nlink */
                 rc = mdo_declare_ref_add(env, mdd_tpobj, handle);
@@ -2022,20 +2387,23 @@ static int mdd_declare_rename(const struct lu_env *env,
 
         }
 
-        rc = mdo_declare_attr_set(env, mdd_spobj, NULL, handle);
-        if (rc)
-                return rc;
+	la->la_valid = LA_CTIME | LA_MTIME;
+	rc = mdo_declare_attr_set(env, mdd_spobj, la, handle);
+	if (rc != 0)
+		return rc;
 
-        rc = mdo_declare_attr_set(env, mdd_sobj, NULL, handle);
-        if (rc)
-                return rc;
-        mdd_declare_links_add(env, mdd_sobj, handle);
-        if (rc)
-                return rc;
+	rc = mdo_declare_attr_set(env, mdd_tpobj, la, handle);
+	if (rc != 0)
+		return rc;
 
-        rc = mdo_declare_attr_set(env, mdd_tpobj, NULL, handle);
-        if (rc)
-                return rc;
+	la->la_valid = LA_CTIME;
+	rc = mdo_declare_attr_set(env, mdd_sobj, la, handle);
+	if (rc)
+		return rc;
+
+	rc = mdd_declare_links_add(env, mdd_sobj, handle, ldata);
+	if (rc)
+		return rc;
 
         /* new name */
         rc = mdo_declare_index_insert(env, mdd_tpobj, mdo2fid(mdd_sobj),
@@ -2069,11 +2437,12 @@ static int mdd_declare_rename(const struct lu_env *env,
                                 return rc;
                 }
 
-                rc = mdo_declare_attr_set(env, mdd_tobj, NULL, handle);
+		la->la_valid = LA_CTIME;
+		rc = mdo_declare_attr_set(env, mdd_tobj, la, handle);
                 if (rc)
                         return rc;
 
-                mdd_declare_links_add(env, mdd_tobj, handle);
+		mdd_declare_links_del(env, mdd_tobj, handle);
                 if (rc)
                         return rc;
 
@@ -2096,40 +2465,61 @@ static int mdd_rename(const struct lu_env *env,
                       struct md_object *tobj, const struct lu_name *ltname,
                       struct md_attr *ma)
 {
-        const char *sname = lsname->ln_name;
-        const char *tname = ltname->ln_name;
-        struct lu_attr    *la = &mdd_env_info(env)->mti_la_for_fix;
+	const char *sname = lsname->ln_name;
+	const char *tname = ltname->ln_name;
+	struct lu_attr    *la = &mdd_env_info(env)->mti_la_for_fix;
 	struct lu_attr    *so_attr = &mdd_env_info(env)->mti_cattr;
 	struct lu_attr    *tg_attr = &mdd_env_info(env)->mti_pattr;
-        struct mdd_object *mdd_spobj = md2mdd_obj(src_pobj); /* source parent */
-        struct mdd_object *mdd_tpobj = md2mdd_obj(tgt_pobj);
-        struct mdd_device *mdd = mdo2mdd(src_pobj);
-        struct mdd_object *mdd_sobj = NULL;                  /* source object */
-        struct mdd_object *mdd_tobj = NULL;
-        struct dynlock_handle *sdlh, *tdlh;
-        struct thandle *handle;
-        const struct lu_fid *tpobj_fid = mdo2fid(mdd_tpobj);
-        const struct lu_fid *spobj_fid = mdo2fid(mdd_spobj);
-        bool is_dir;
+	struct mdd_object *mdd_spobj = md2mdd_obj(src_pobj); /* source parent */
+	struct mdd_object *mdd_tpobj = md2mdd_obj(tgt_pobj);
+	struct mdd_device *mdd = mdo2mdd(src_pobj);
+	struct mdd_object *mdd_sobj = NULL;                  /* source object */
+	struct mdd_object *mdd_tobj = NULL;
+	struct dynlock_handle *sdlh = NULL, *tdlh = NULL;
+	struct thandle *handle;
+	struct linkea_data  *ldata = &mdd_env_info(env)->mti_link_data;
+	const struct lu_fid *tpobj_fid = mdo2fid(mdd_tpobj);
+	const struct lu_fid *spobj_fid = mdo2fid(mdd_spobj);
+	bool is_dir;
 	bool tobj_ref = 0;
 	bool tobj_locked = 0;
 	unsigned cl_flags = 0;
-        int rc, rc2;
-        ENTRY;
+	int rc, rc2;
+	ENTRY;
 
         if (tobj)
                 mdd_tobj = md2mdd_obj(tobj);
 
-        mdd_sobj = mdd_object_find(env, mdd, lf);
+        mdd_sobj = mdd_object_find(env, mdd, lf);
+
+	rc = mdd_la_get(env, mdd_sobj, so_attr,
+			mdd_object_capa(env, mdd_sobj));
+	if (rc)
+		GOTO(out_pending, rc);
+
+	if (mdd_tobj) {
+		rc = mdd_la_get(env, mdd_tobj, tg_attr,
+				mdd_object_capa(env, mdd_tobj));
+		if (rc)
+			GOTO(out_pending, rc);
+	}
+
+	rc = mdd_rename_sanity_check(env, mdd_spobj, mdd_tpobj, mdd_sobj,
+				     mdd_tobj, so_attr, tg_attr);
+	if (rc)
+		GOTO(out_pending, rc);
 
         handle = mdd_trans_create(env, mdd);
         if (IS_ERR(handle))
                 GOTO(out_pending, rc = PTR_ERR(handle));
 
-        rc = mdd_declare_rename(env, mdd, mdd_spobj, mdd_tpobj, mdd_sobj,
-                                mdd_tobj, lsname, ltname, ma, handle);
-        if (rc)
-                GOTO(stop, rc);
+	memset(ldata, 0, sizeof(*ldata));
+	mdd_linkea_prepare(env, mdd_sobj, NULL, NULL, mdd_object_fid(mdd_tpobj),
+			   ltname, 1, 0, ldata);
+	rc = mdd_declare_rename(env, mdd, mdd_spobj, mdd_tpobj, mdd_sobj,
+				mdd_tobj, lsname, ltname, ma, ldata, handle);
+	if (rc)
+		GOTO(stop, rc);
 
         rc = mdd_trans_start(env, mdd, handle);
         if (rc)
@@ -2160,23 +2550,6 @@ static int mdd_rename(const struct lu_env *env,
         if (sdlh == NULL || tdlh == NULL)
                 GOTO(cleanup, rc = -ENOMEM);
 
-	rc = mdd_la_get(env, mdd_sobj, so_attr,
-			mdd_object_capa(env, mdd_sobj));
-	if (rc)
-		GOTO(cleanup, rc);
-
-	if (mdd_tobj) {
-		rc = mdd_la_get(env, mdd_tobj, tg_attr,
-				mdd_object_capa(env, mdd_tobj));
-		if (rc)
-			GOTO(cleanup, rc);
-	}
-
-	rc = mdd_rename_sanity_check(env, mdd_spobj, mdd_tpobj, mdd_sobj,
-				     mdd_tobj, so_attr, tg_attr);
-        if (rc)
-                GOTO(cleanup, rc);
-
 	is_dir = S_ISDIR(so_attr->la_mode);
 
         /* Remove source name from source directory */
@@ -2313,14 +2686,15 @@ static int mdd_rename(const struct lu_env *env,
 						 handle, 0);
         }
 
-        if (rc == 0 && mdd_sobj) {
-                mdd_write_lock(env, mdd_sobj, MOR_SRC_CHILD);
+	if (rc == 0 && mdd_sobj) {
+		mdd_write_lock(env, mdd_sobj, MOR_SRC_CHILD);
 		rc = mdd_links_rename(env, mdd_sobj, mdo2fid(mdd_spobj), lsname,
-				      mdo2fid(mdd_tpobj), ltname, handle, 0, 0);
+				      mdo2fid(mdd_tpobj), ltname, handle, NULL,
+				      0, 0);
                 if (rc == -ENOENT)
                         /* Old files might not have EA entry */
                         mdd_links_add(env, mdd_sobj, mdo2fid(mdd_spobj),
-                                      lsname, handle, 0);
+				      lsname, handle, NULL, 0);
                 mdd_write_unlock(env, mdd_sobj);
                 /* We don't fail the transaction if the link ea can't be
                    updated -- fid2path will use alternate lookup method. */
@@ -2355,19 +2729,21 @@ fixup_tpobj:
         }
 
 fixup_spobj:
-        if (rc && is_dir && mdd_sobj) {
-                rc2 = __mdd_index_delete_only(env, mdd_sobj, dotdot, handle,
-                                              BYPASS_CAPA);
+	if (rc && is_dir && mdd_sobj && mdd_spobj != mdd_tpobj) {
+		rc2 = __mdd_index_delete_only(env, mdd_sobj, dotdot, handle,
+					      BYPASS_CAPA);
 
-                if (rc2)
-                        CWARN("sp obj dotdot delete error %d\n",rc2);
+		if (rc2)
+			CWARN("%s: sp obj dotdot delete error: rc = %d\n",
+			       mdd2obd_dev(mdd)->obd_name, rc2);
 
 
-                rc2 = __mdd_index_insert_only(env, mdd_sobj, spobj_fid,
-                                              dotdot, handle, BYPASS_CAPA);
-                if (rc2)
-                        CWARN("sp obj dotdot insert error %d\n",rc2);
-        }
+		rc2 = __mdd_index_insert_only(env, mdd_sobj, spobj_fid,
+					      dotdot, handle, BYPASS_CAPA);
+		if (rc2)
+			CWARN("%s: sp obj dotdot insert error: rc = %d\n",
+			      mdd2obd_dev(mdd)->obd_name, rc2);
+	}
 
 fixup_spobj2:
         if (rc) {
@@ -2392,429 +2768,11 @@ cleanup_unlocked:
 
 stop:
         mdd_trans_stop(env, mdd, rc, handle);
-        if (mdd_sobj)
-                mdd_object_put(env, mdd_sobj);
 out_pending:
-        return rc;
-}
-
-/**
- * The data that link search is done on.
- */
-struct mdd_link_data {
-	/**
-	 * Buffer to keep link EA body.
-	 */
-	struct lu_buf           *ml_buf;
-	/**
-	 * The matched header, entry and its lenght in the EA
-	 */
-	struct link_ea_header   *ml_leh;
-	struct link_ea_entry    *ml_lee;
-	int                      ml_reclen;
-};
-
-static int mdd_links_new(const struct lu_env *env,
-			 struct mdd_link_data *ldata)
-{
-	ldata->ml_buf = mdd_buf_alloc(env, CFS_PAGE_SIZE);
-	if (ldata->ml_buf->lb_buf == NULL)
-		return -ENOMEM;
-	ldata->ml_leh = ldata->ml_buf->lb_buf;
-	ldata->ml_leh->leh_magic = LINK_EA_MAGIC;
-	ldata->ml_leh->leh_len = sizeof(struct link_ea_header);
-	ldata->ml_leh->leh_reccount = 0;
-	return 0;
-}
-
-/** Read the link EA into a temp buffer.
- * Uses the mdd_thread_info::mti_big_buf since it is generally large.
- * A pointer to the buffer is stored in \a ldata::ml_buf.
- *
- * \retval 0 or error
- */
-int mdd_links_read(const struct lu_env *env,
-		   struct mdd_object *mdd_obj,
-		   struct mdd_link_data *ldata)
-{
-	struct lustre_capa *capa;
-	struct link_ea_header *leh;
-	int rc;
-
-	/* First try a small buf */
-	LASSERT(env != NULL);
-	ldata->ml_buf = mdd_buf_alloc(env, CFS_PAGE_SIZE);
-	if (ldata->ml_buf->lb_buf == NULL)
-		return -ENOMEM;
-
-	if (!mdd_object_exists(mdd_obj))
-		return -ENODATA;
-
-	capa = mdd_object_capa(env, mdd_obj);
-	rc = mdo_xattr_get(env, mdd_obj, ldata->ml_buf,
-			   XATTR_NAME_LINK, capa);
-	if (rc == -ERANGE) {
-		/* Buf was too small, figure out what we need. */
-		mdd_buf_put(ldata->ml_buf);
-		rc = mdo_xattr_get(env, mdd_obj, ldata->ml_buf,
-				   XATTR_NAME_LINK, capa);
-		if (rc < 0)
-			return rc;
-		ldata->ml_buf = mdd_buf_alloc(env, rc);
-		if (ldata->ml_buf->lb_buf == NULL)
-			return -ENOMEM;
-		rc = mdo_xattr_get(env, mdd_obj, ldata->ml_buf,
-				   XATTR_NAME_LINK, capa);
-	}
-	if (rc < 0)
-		return rc;
-
-	leh = ldata->ml_buf->lb_buf;
-	if (leh->leh_magic == __swab32(LINK_EA_MAGIC)) {
-		leh->leh_magic = LINK_EA_MAGIC;
-		leh->leh_reccount = __swab32(leh->leh_reccount);
-		leh->leh_len = __swab64(leh->leh_len);
-		/* entries are swabbed by mdd_lee_unpack */
-	}
-	if (leh->leh_magic != LINK_EA_MAGIC)
-		return -EINVAL;
-	if (leh->leh_reccount == 0)
-		return -ENODATA;
-
-	ldata->ml_leh = leh;
-	return 0;
-}
-
-/** Read the link EA into a temp buffer.
- * Uses the name_buf since it is generally large.
- * \retval IS_ERR err
- * \retval ptr to \a lu_buf (always \a mti_big_buf)
- */
-struct lu_buf *mdd_links_get(const struct lu_env *env,
-			     struct mdd_object *mdd_obj)
-{
-	struct mdd_link_data ldata = { 0 };
-	int rc;
-
-	rc = mdd_links_read(env, mdd_obj, &ldata);
-	return rc ? ERR_PTR(rc) : ldata.ml_buf;
-}
-
-static int mdd_links_write(const struct lu_env *env,
-			   struct mdd_object *mdd_obj,
-			   struct mdd_link_data *ldata,
-			   struct thandle *handle)
-{
-	const struct lu_buf *buf = mdd_buf_get_const(env, ldata->ml_buf->lb_buf,
-						     ldata->ml_leh->leh_len);
-	return mdo_xattr_set(env, mdd_obj, buf, XATTR_NAME_LINK, 0, handle,
-			     mdd_object_capa(env, mdd_obj));
-}
-
-/** Pack a link_ea_entry.
- * All elements are stored as chars to avoid alignment issues.
- * Numbers are always big-endian
- * \retval record length
- */
-static int mdd_lee_pack(struct link_ea_entry *lee, const struct lu_name *lname,
-                        const struct lu_fid *pfid)
-{
-        struct lu_fid   tmpfid;
-        int             reclen;
-
-        fid_cpu_to_be(&tmpfid, pfid);
-        memcpy(&lee->lee_parent_fid, &tmpfid, sizeof(tmpfid));
-        memcpy(lee->lee_name, lname->ln_name, lname->ln_namelen);
-        reclen = sizeof(struct link_ea_entry) + lname->ln_namelen;
-
-        lee->lee_reclen[0] = (reclen >> 8) & 0xff;
-        lee->lee_reclen[1] = reclen & 0xff;
-        return reclen;
-}
-
-void mdd_lee_unpack(const struct link_ea_entry *lee, int *reclen,
-                    struct lu_name *lname, struct lu_fid *pfid)
-{
-        *reclen = (lee->lee_reclen[0] << 8) | lee->lee_reclen[1];
-        memcpy(pfid, &lee->lee_parent_fid, sizeof(*pfid));
-        fid_be_to_cpu(pfid, pfid);
-        lname->ln_name = lee->lee_name;
-        lname->ln_namelen = *reclen - sizeof(struct link_ea_entry);
-}
-
-static int mdd_declare_links_add(const struct lu_env *env,
-                                 struct mdd_object *mdd_obj,
-                                 struct thandle *handle)
-{
-        int rc;
-
-        /* XXX: max size? */
-        rc = mdo_declare_xattr_set(env, mdd_obj,
-                             mdd_buf_get_const(env, NULL, 4096),
-                             XATTR_NAME_LINK, 0, handle);
-
-        return rc;
-}
-
-/* For pathologic linkers, we don't want to spend lots of time scanning the
- * link ea.  Limit ourseleves to something reasonable; links not in the EA
- * can be looked up via (slower) parent lookup.
- */
-#define LINKEA_MAX_COUNT 128
-
-/** Add a record to the end of link ea buf */
-static int mdd_links_add_buf(const struct lu_env *env,
-			     struct mdd_link_data *ldata,
-			     const struct lu_name *lname,
-			     const struct lu_fid *pfid)
-{
-	LASSERT(ldata->ml_leh != NULL);
-
-	if (lname == NULL || pfid == NULL)
-		return -EINVAL;
-
-	/* Make sure our buf is big enough for the new one */
-	if (ldata->ml_leh->leh_reccount > LINKEA_MAX_COUNT)
-		return -EOVERFLOW;
-
-	ldata->ml_reclen = lname->ln_namelen + sizeof(struct link_ea_entry);
-	if (ldata->ml_leh->leh_len + ldata->ml_reclen >
-	    ldata->ml_buf->lb_len) {
-		if (mdd_buf_grow(env, ldata->ml_leh->leh_len +
-				 ldata->ml_reclen) < 0)
-			return -ENOMEM;
-	}
-
-	ldata->ml_leh = ldata->ml_buf->lb_buf;
-	ldata->ml_lee = ldata->ml_buf->lb_buf + ldata->ml_leh->leh_len;
-	ldata->ml_reclen = mdd_lee_pack(ldata->ml_lee, lname, pfid);
-	ldata->ml_leh->leh_len += ldata->ml_reclen;
-	ldata->ml_leh->leh_reccount++;
-	CDEBUG(D_INODE, "New link_ea name '%.*s' is added\n",
-	       lname->ln_namelen, lname->ln_name);
-	return 0;
-}
-
-/** Del the current record from the link ea buf */
-static void mdd_links_del_buf(const struct lu_env *env,
-			      struct mdd_link_data *ldata,
-			      const struct lu_name *lname)
-{
-	LASSERT(ldata->ml_leh != NULL);
-
-	ldata->ml_leh->leh_reccount--;
-	ldata->ml_leh->leh_len -= ldata->ml_reclen;
-	memmove(ldata->ml_lee, (char *)ldata->ml_lee + ldata->ml_reclen,
-		(char *)ldata->ml_leh + ldata->ml_leh->leh_len -
-		(char *)ldata->ml_lee);
-	CDEBUG(D_INODE, "Old link_ea name '%.*s' is removed\n",
-	       lname->ln_namelen, lname->ln_name);
-
-}
-
-/**
- * Check if such a link exists in linkEA.
- *
- * \param mdd_obj object being handled
- * \param pfid parent fid the link to be found for
- * \param lname name in the parent's directory entry pointing to this object
- * \param ldata link data the search to be done on
- *
- * \retval   0 success
- * \retval -ENOENT link does not exist
- * \retval -ve on error
- */
-static int mdd_links_find(const struct lu_env  *env,
-			  struct mdd_object    *mdd_obj,
-			  struct mdd_link_data *ldata,
-			  const struct lu_name *lname,
-			  const struct lu_fid  *pfid)
-{
-	struct lu_name *tmpname = &mdd_env_info(env)->mti_name2;
-	struct lu_fid  *tmpfid = &mdd_env_info(env)->mti_fid;
-	int count;
-
-	LASSERT(ldata->ml_leh != NULL);
-
-	/* link #0 */
-	ldata->ml_lee = (struct link_ea_entry *)(ldata->ml_leh + 1);
-
-	for (count = 0; count < ldata->ml_leh->leh_reccount; count++) {
-		mdd_lee_unpack(ldata->ml_lee, &ldata->ml_reclen,
-			       tmpname, tmpfid);
-		if (tmpname->ln_namelen == lname->ln_namelen &&
-		    lu_fid_eq(tmpfid, pfid) &&
-		    (strncmp(tmpname->ln_name, lname->ln_name,
-			     tmpname->ln_namelen) == 0))
-			break;
-		ldata->ml_lee = (struct link_ea_entry *)((char *)ldata->ml_lee +
-							 ldata->ml_reclen);
-	}
-
-	if (count == ldata->ml_leh->leh_reccount) {
-		CDEBUG(D_INODE, "Old link_ea name '%.*s' not found\n",
-		       lname->ln_namelen, lname->ln_name);
-		return -ENOENT;
-	}
-	return 0;
-}
-
-static int __mdd_links_add(const struct lu_env *env,
-			   struct mdd_object *mdd_obj,
-			   struct mdd_link_data *ldata,
-			   const struct lu_name *lname,
-			   const struct lu_fid *pfid,
-			   int first, int check)
-{
-	int rc;
-
-	if (ldata->ml_leh == NULL) {
-		rc = first ? -ENODATA : mdd_links_read(env, mdd_obj, ldata);
-		if (rc) {
-			if (rc != -ENODATA)
-				return rc;
-			rc = mdd_links_new(env, ldata);
-			if (rc)
-				return rc;
-		}
-	}
-
-	if (check) {
-		rc = mdd_links_find(env, mdd_obj, ldata, lname, pfid);
-		if (rc && rc != -ENOENT)
-			return rc;
-		if (rc == 0)
-			return -EEXIST;
-	}
-
-	return mdd_links_add_buf(env, ldata, lname, pfid);
-}
-
-static int __mdd_links_del(const struct lu_env *env,
-			   struct mdd_object *mdd_obj,
-			   struct mdd_link_data *ldata,
-			   const struct lu_name *lname,
-			   const struct lu_fid *pfid)
-{
-	int rc;
-
-	if (ldata->ml_leh == NULL) {
-		rc = mdd_links_read(env, mdd_obj, ldata);
-		if (rc)
-			return rc;
-	}
-
-	rc = mdd_links_find(env, mdd_obj, ldata, lname, pfid);
-	if (rc)
-		return rc;
-
-	mdd_links_del_buf(env, ldata, lname);
-	return 0;
-}
-
-static int mdd_links_rename(const struct lu_env *env,
-			    struct mdd_object *mdd_obj,
-			    const struct lu_fid *oldpfid,
-			    const struct lu_name *oldlname,
-			    const struct lu_fid *newpfid,
-			    const struct lu_name *newlname,
-			    struct thandle *handle,
-			    int first, int check)
-{
-	struct mdd_link_data ldata = { 0 };
-	int updated = 0;
-	int rc2 = 0;
-	int rc = 0;
-	ENTRY;
-
-	LASSERT(oldpfid != NULL || newpfid != NULL);
-
-	if (mdd_obj->mod_flags & DEAD_OBJ)
-		/* No more links, don't bother */
-		RETURN(0);
-
-	if (oldpfid != NULL) {
-		rc = __mdd_links_del(env, mdd_obj, &ldata,
-				     oldlname, oldpfid);
-		if (rc) {
-			if ((check == 0) ||
-			    (rc != -ENODATA && rc != -ENOENT))
-				GOTO(out, rc);
-			/* No changes done. */
-			rc = 0;
-		} else {
-			updated = 1;
-		}
-	}
-
-	/* If renaming, add the new record */
-	if (newpfid != NULL) {
-		/* even if the add fails, we still delete the out-of-date
-		 * old link */
-		rc2 = __mdd_links_add(env, mdd_obj, &ldata,
-				      newlname, newpfid, first, check);
-		if (rc2 == -EEXIST)
-			rc2 = 0;
-		else if (rc2 == 0)
-			updated = 1;
-	}
-
-	if (updated)
-		rc = mdd_links_write(env, mdd_obj, &ldata, handle);
-	EXIT;
-out:
-	if (rc == 0)
-		rc = rc2;
-	if (rc) {
-		int error = 1;
-		if (rc == -EOVERFLOW || rc == - ENOENT)
-			error = 0;
-		if (oldpfid == NULL)
-			CDEBUG(error ? D_ERROR : D_OTHER,
-			       "link_ea add '%.*s' failed %d "DFID"\n",
-			       newlname->ln_namelen, newlname->ln_name,
-			       rc, PFID(mdd_object_fid(mdd_obj)));
-		else if (newpfid == NULL)
-			CDEBUG(error ? D_ERROR : D_OTHER,
-			       "link_ea del '%.*s' failed %d "DFID"\n",
-			       oldlname->ln_namelen, oldlname->ln_name,
-			       rc, PFID(mdd_object_fid(mdd_obj)));
-		else
-			CDEBUG(error ? D_ERROR : D_OTHER,
-			       "link_ea rename '%.*s'->'%.*s' failed %d "
-			       DFID"\n",
-			       oldlname->ln_namelen, oldlname->ln_name,
-			       newlname->ln_namelen, newlname->ln_name,
-			       rc, PFID(mdd_object_fid(mdd_obj)));
-	}
-
-	if (ldata.ml_buf && ldata.ml_buf->lb_len > OBD_ALLOC_BIG)
-		/* if we vmalloced a large buffer drop it */
-		mdd_buf_put(ldata.ml_buf);
-
+	mdd_object_put(env, mdd_sobj);
 	return rc;
 }
 
-static inline int mdd_links_add(const struct lu_env *env,
-				struct mdd_object *mdd_obj,
-				const struct lu_fid *pfid,
-				const struct lu_name *lname,
-				struct thandle *handle, int first)
-{
-	return mdd_links_rename(env, mdd_obj, NULL, NULL,
-				pfid, lname, handle, first, 0);
-}
-
-static inline int mdd_links_del(const struct lu_env *env,
-				struct mdd_object *mdd_obj,
-				const struct lu_fid *pfid,
-				const struct lu_name *lname,
-				struct thandle *handle)
-{
-	return mdd_links_rename(env, mdd_obj, pfid, lname,
-				NULL, NULL, handle, 0, 0);
-}
-
 const struct md_dir_operations mdd_dir_ops = {
         .mdo_is_subdir     = mdd_is_subdir,
         .mdo_lookup        = mdd_lookup,