Whamcloud - gitweb
LU-5710 all: second batch of corrected typos and grammar errors
[fs/lustre-release.git] / lustre / mdd / mdd_dir.c
index 68e1162..9d03d17 100644 (file)
@@ -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, 2014, 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,63 +57,78 @@ 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 inline int
+mdd_name_check(struct mdd_device *m, const struct lu_name *ln)
+{
+       if (!lu_name_is_valid(ln))
+               return -EINVAL;
+       else if (ln->ln_namelen > m->mdd_dt_conf.ddp_max_name_len)
+               return -ENAMETOOLONG;
+       else
+               return 0;
+}
 
+/* Get FID from name and parent */
 static int
-__mdd_lookup_locked(const struct lu_env *env, struct md_object *pobj,
-                    const struct lu_name *lname, struct lu_fid* fid, int mask)
+__mdd_lookup(const struct lu_env *env, struct md_object *pobj,
+            const struct lu_attr *pattr, const struct lu_name *lname,
+            struct lu_fid* fid, int mask)
 {
-        const char *name = lname->ln_name;
-        struct mdd_object *mdd_obj = md2mdd_obj(pobj);
-        struct dynlock_handle *dlh;
+       const char *name                = lname->ln_name;
+       const struct dt_key *key        = (const struct dt_key *)name;
+       struct mdd_object *mdd_obj      = md2mdd_obj(pobj);
+       struct mdd_device *m            = mdo2mdd(pobj);
+       struct dt_object *dir           = mdd_object_child(mdd_obj);
         int rc;
+       ENTRY;
 
-        dlh = mdd_pdo_read_lock(env, mdd_obj, name, MOR_TGT_PARENT);
-        if (unlikely(dlh == NULL))
-                return -ENOMEM;
-        rc = __mdd_lookup(env, pobj, lname, fid, mask);
-        mdd_pdo_read_unlock(env, mdd_obj, dlh);
+       if (unlikely(mdd_is_dead_obj(mdd_obj)))
+               RETURN(-ESTALE);
 
-        return rc;
+       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);
+       }
+
+       rc = mdd_permission_internal_locked(env, mdd_obj, pattr, mask,
+                                           MOR_TGT_PARENT);
+       if (rc)
+               RETURN(rc);
+
+       if (likely(S_ISDIR(mdd_object_type(mdd_obj)) &&
+                  dt_try_as_dir(env, dir)))
+               rc = dt_lookup(env, dir, (struct dt_rec *)fid, key);
+       else
+               rc = -ENOTDIR;
+
+       RETURN(rc);
 }
 
 int mdd_lookup(const struct lu_env *env,
-               struct md_object *pobj, const struct lu_name *lname,
-               struct lu_fid* fid, struct md_op_spec *spec)
+              struct md_object *pobj, const struct lu_name *lname,
+              struct lu_fid *fid, struct md_op_spec *spec)
 {
+       struct lu_attr *pattr = MDD_ENV_VAR(env, pattr);
         int rc;
         ENTRY;
-        rc = __mdd_lookup_locked(env, pobj, lname, fid, MAY_EXEC);
+
+       rc = mdd_la_get(env, md2mdd_obj(pobj), pattr);
+       if (rc != 0)
+               RETURN(rc);
+
+       rc = __mdd_lookup(env, pobj, pattr, lname, fid,
+                         (spec != NULL && spec->sp_permitted) ? 0 : MAY_EXEC);
         RETURN(rc);
 }
 
-static int mdd_parent_fid(const struct lu_env *env, struct mdd_object *obj,
-                          struct lu_fid *fid)
+static inline int mdd_parent_fid(const struct lu_env *env,
+                                struct mdd_object *obj,
+                                const struct lu_attr *attr,
+                                struct lu_fid *fid)
 {
-        return __mdd_lookup_locked(env, &obj->mod_obj, &lname_dotdot, fid, 0);
+       return __mdd_lookup(env, &obj->mod_obj, attr, &lname_dotdot, fid, 0);
 }
 
 /*
@@ -136,10 +151,11 @@ int mdd_is_root(struct mdd_device *mdd, const struct lu_fid *fid)
  * otherwise: values < 0, errors.
  */
 static int mdd_is_parent(const struct lu_env *env,
-                         struct mdd_device *mdd,
-                         struct mdd_object *p1,
-                         const struct lu_fid *lf,
-                         struct lu_fid *pf)
+                       struct mdd_device *mdd,
+                       struct mdd_object *p1,
+                       const struct lu_attr *attr,
+                       const struct lu_fid *lf,
+                       struct lu_fid *pf)
 {
         struct mdd_object *parent = NULL;
         struct lu_fid *pfid;
@@ -154,27 +170,29 @@ static int mdd_is_parent(const struct lu_env *env,
                 RETURN(0);
 
         for(;;) {
-                /* this is done recursively, bypass capa for each obj */
-                mdd_set_capainfo(env, 4, p1, BYPASS_CAPA);
-                rc = mdd_parent_fid(env, p1, pfid);
-                if (rc)
-                        GOTO(out, rc);
+               /* this is done recursively */
+               rc = mdd_parent_fid(env, p1, attr, pfid);
+               if (rc)
+                       GOTO(out, rc);
                 if (mdd_is_root(mdd, pfid))
                         GOTO(out, rc = 0);
+               if (lu_fid_eq(pfid, &mdd->mdd_local_root_fid))
+                       GOTO(out, rc = 0);
                 if (lu_fid_eq(pfid, lf))
                         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:
@@ -187,7 +205,7 @@ out:
  * No permission check is needed.
  *
  * returns 1: if fid is ancestor of @mo;
- * returns 0: if fid is not a ancestor of @mo;
+ * returns 0: if fid is not an ancestor of @mo;
  *
  * returns EREMOTE if remote object is found, fid of remote object is saved to
  * @fid;
@@ -195,25 +213,30 @@ out:
  * returns < 0: if error
  */
 int mdd_is_subdir(const struct lu_env *env, struct md_object *mo,
-                  const struct lu_fid *fid, struct lu_fid *sfid)
+                 const struct lu_fid *fid, struct lu_fid *sfid)
 {
-        struct mdd_device *mdd = mdo2mdd(mo);
-        int rc;
-        ENTRY;
+       struct mdd_device *mdd = mdo2mdd(mo);
+       struct lu_attr *attr = MDD_ENV_VAR(env, cattr);
+       int rc;
+       ENTRY;
 
-        if (!S_ISDIR(mdd_object_type(md2mdd_obj(mo))))
-                RETURN(0);
+       if (!S_ISDIR(mdd_object_type(md2mdd_obj(mo))))
+               RETURN(0);
 
-        rc = mdd_is_parent(env, mdd, md2mdd_obj(mo), fid, sfid);
-        if (rc == 0) {
-                /* found root */
-                fid_zero(sfid);
-        } else if (rc == 1) {
-                /* found @fid is parent */
-                *sfid = *fid;
-                rc = 0;
-        }
-        RETURN(rc);
+       rc = mdd_la_get(env, md2mdd_obj(mo), attr);
+       if (rc != 0)
+               RETURN(rc);
+
+       rc = mdd_is_parent(env, mdd, md2mdd_obj(mo), attr, fid, sfid);
+       if (rc == 0) {
+               /* found root */
+               fid_zero(sfid);
+       } else if (rc == 1) {
+               /* found @fid is parent */
+               *sfid = *fid;
+               rc = 0;
+       }
+       RETURN(rc);
 }
 
 /*
@@ -230,114 +253,144 @@ int mdd_is_subdir(const struct lu_env *env, struct md_object *mo,
 static int mdd_dir_is_empty(const struct lu_env *env,
                             struct mdd_object *dir)
 {
-        struct dt_it     *it;
-        struct dt_object *obj;
-        const struct dt_it_ops *iops;
-        int result;
-        ENTRY;
+       struct dt_it     *it;
+       struct dt_object *obj;
+       const struct dt_it_ops *iops;
+       int result;
+       ENTRY;
 
-        obj = mdd_object_child(dir);
-        if (!dt_try_as_dir(env, obj))
-                RETURN(-ENOTDIR);
-
-        iops = &obj->do_index_ops->dio_it;
-        it = iops->init(env, obj, LUDA_64BITHASH, BYPASS_CAPA);
-        if (!IS_ERR(it)) {
-                result = iops->get(env, it, (const void *)"");
-                if (result > 0) {
-                        int i;
-                        for (result = 0, i = 0; result == 0 && i < 3; ++i)
-                                result = iops->next(env, it);
-                        if (result == 0)
-                                result = -ENOTEMPTY;
-                        else if (result == +1)
-                                result = 0;
-                } else if (result == 0)
-                        /*
-                         * Huh? Index contains no zero key?
-                         */
-                        result = -EIO;
-
-                iops->put(env, it);
-                iops->fini(env, it);
-        } else
-                result = PTR_ERR(it);
-        RETURN(result);
-}
-
-static int __mdd_may_link(const struct lu_env *env, struct mdd_object *obj)
-{
-        struct mdd_device *m = mdd_obj2mdd_dev(obj);
-        struct lu_attr *la = &mdd_env_info(env)->mti_la;
-        int rc;
-        ENTRY;
+       obj = mdd_object_child(dir);
+       if (!dt_try_as_dir(env, obj))
+               RETURN(-ENOTDIR);
+
+       iops = &obj->do_index_ops->dio_it;
+       it = iops->init(env, obj, LUDA_64BITHASH);
+       if (!IS_ERR(it)) {
+               result = iops->get(env, it, (const struct dt_key *)"");
+               if (result > 0) {
+                       int i;
+                       for (result = 0, i = 0; result == 0 && i < 3; ++i)
+                               result = iops->next(env, it);
+                       if (result == 0)
+                               result = -ENOTEMPTY;
+                       else if (result == 1)
+                               result = 0;
+               } else if (result == 0)
+                       /*
+                        * Huh? Index contains no zero key?
+                        */
+                       result = -EIO;
+
+               iops->put(env, it);
+               iops->fini(env, it);
+       } else
+               result = PTR_ERR(it);
+       RETURN(result);
+}
 
-        rc = mdd_la_get(env, obj, la, BYPASS_CAPA);
-        if (rc)
-                RETURN(rc);
+/**
+ * Determine if the target object can be hard linked, and right now it only
+ * checks if the link count reach the maximum limit. Note: for ldiskfs, the
+ * directory nlink count might exceed the maximum link count(see
+ * osd_object_ref_add), so it only check nlink for non-directories.
+ *
+ * \param[in] env      thread environment
+ * \param[in] obj      object being linked to
+ * \param[in] la       attributes of \a obj
+ *
+ * \retval             0 if \a obj can be hard linked
+ * \retval             negative error if \a obj is a directory or has too
+ *                     many links
+ */
+static int __mdd_may_link(const struct lu_env *env, struct mdd_object *obj,
+                         const struct lu_attr *la)
+{
+       struct mdd_device *m = mdd_obj2mdd_dev(obj);
+       ENTRY;
 
-        /*
-         * Subdir count limitation can be broken through.
-         */
-        if (la->la_nlink >= m->mdd_dt_conf.ddp_max_nlink &&
-            !S_ISDIR(la->la_mode))
-                RETURN(-EMLINK);
-        else
-                RETURN(0);
+       LASSERT(la != NULL);
+
+       /* Subdir count limitation can be broken through
+        * (see osd_object_ref_add), so only check non-directory here. */
+       if (!S_ISDIR(la->la_mode) &&
+           la->la_nlink >= m->mdd_dt_conf.ddp_max_nlink)
+               RETURN(-EMLINK);
+
+       RETURN(0);
 }
 
-/*
+/**
  * Check whether it may create the cobj under the pobj.
- * cobj maybe NULL
+ *
+ * \param[in] env      execution environment
+ * \param[in] pobj     the parent directory
+ * \param[in] pattr    the attribute of the parent directory
+ * \param[in] cobj     the child to be created
+ * \param[in] check_perm       if check WRITE|EXEC permission for parent
+ *
+ * \retval             = 0 create the child under this dir is allowed
+ * \retval              negative errno create the child under this dir is
+ *                      not allowed
  */
 int mdd_may_create(const struct lu_env *env, struct mdd_object *pobj,
-                   struct mdd_object *cobj, int check_perm, int check_nlink)
+                  const struct lu_attr *pattr, struct mdd_object *cobj,
+                  bool check_perm)
 {
-        int rc = 0;
-        ENTRY;
+       struct mdd_thread_info *info = mdd_env_info(env);
+       struct lu_buf   *xbuf;
+       int rc = 0;
+       ENTRY;
 
-        if (cobj && mdd_object_exists(cobj))
-                RETURN(-EEXIST);
+       if (cobj && mdd_object_exists(cobj))
+               RETURN(-EEXIST);
 
-        if (mdd_is_dead_obj(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 && check_nlink)
-                rc = __mdd_may_link(env, pobj);
+       /* If the parent is a sub-stripe, check whether it is dead */
+       xbuf = mdd_buf_get(env, info->mti_key, sizeof(info->mti_key));
+       rc = mdo_xattr_get(env, pobj, xbuf, XATTR_NAME_LMV);
+       if (unlikely(rc > 0)) {
+               struct lmv_mds_md_v1  *lmv1 = xbuf->lb_buf;
 
-        RETURN(rc);
+               if (le32_to_cpu(lmv1->lmv_magic) == LMV_MAGIC_STRIPE &&
+                   le32_to_cpu(lmv1->lmv_hash_type) & LMV_HASH_FLAG_DEAD)
+                       RETURN(-ESTALE);
+       }
+       rc = 0;
+
+       if (check_perm)
+               rc = mdd_permission_internal_locked(env, pobj, pattr,
+                                                   MAY_WRITE | MAY_EXEC,
+                                                   MOR_TGT_PARENT);
+       RETURN(rc);
 }
 
 /*
  * Check whether can unlink from the pobj in the case of "cobj == NULL".
  */
 int mdd_may_unlink(const struct lu_env *env, struct mdd_object *pobj,
-                  const struct lu_attr *attr)
+                  const struct lu_attr *pattr, const struct lu_attr *attr)
 {
-        int rc;
-        ENTRY;
+       int rc;
+       ENTRY;
 
-        if (mdd_is_dead_obj(pobj))
-                RETURN(-ENOENT);
+       if (mdd_is_dead_obj(pobj))
+               RETURN(-ENOENT);
 
-       if ((attr->la_valid & LA_FLAGS) &&
-           (attr->la_flags & (LUSTRE_APPEND_FL | LUSTRE_IMMUTABLE_FL)))
-                RETURN(-EPERM);
+       if (attr->la_flags & (LUSTRE_APPEND_FL | LUSTRE_IMMUTABLE_FL))
+               RETURN(-EPERM);
 
-        rc = mdd_permission_internal_locked(env, pobj, NULL,
-                                            MAY_WRITE | MAY_EXEC,
-                                            MOR_TGT_PARENT);
-        if (rc)
-                RETURN(rc);
+       rc = mdd_permission_internal_locked(env, pobj, pattr,
+                                           MAY_WRITE | MAY_EXEC,
+                                           MOR_TGT_PARENT);
+       if (rc != 0)
+               RETURN(rc);
 
-        if (mdd_is_append(pobj))
-                RETURN(-EPERM);
+       if (pattr->la_flags & LUSTRE_APPEND_FL)
+               RETURN(-EPERM);
 
-        RETURN(rc);
+       RETURN(rc);
 }
 
 /*
@@ -346,107 +399,130 @@ int mdd_may_unlink(const struct lu_env *env, struct mdd_object *pobj,
  */
 static inline int mdd_is_sticky(const struct lu_env *env,
                                struct mdd_object *pobj,
-                               struct mdd_object *cobj)
+                               const struct lu_attr *pattr,
+                               struct mdd_object *cobj,
+                               const struct lu_attr *cattr)
 {
-       struct lu_attr *tmp_la = &mdd_env_info(env)->mti_la;
        struct lu_ucred *uc = lu_ucred_assert(env);
-       int rc;
-
-       if (pobj) {
-               rc = mdd_la_get(env, pobj, tmp_la, BYPASS_CAPA);
-               if (rc)
-                       return rc;
 
-               if (!(tmp_la->la_mode & S_ISVTX) ||
-                   (tmp_la->la_uid == uc->uc_fsuid))
+       if (pobj != NULL) {
+               LASSERT(pattr != NULL);
+               if (!(pattr->la_mode & S_ISVTX) ||
+                   (pattr->la_uid == uc->uc_fsuid))
                        return 0;
        }
 
-       rc = mdd_la_get(env, cobj, tmp_la, BYPASS_CAPA);
-       if (rc)
-               return rc;
-
-       if (tmp_la->la_uid == uc->uc_fsuid)
+       LASSERT(cattr != NULL);
+       if (cattr->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,
+                               const struct lu_attr *pattr,
+                               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, pattr,
+                                           MAY_WRITE | MAY_EXEC,
+                                           MOR_TGT_PARENT);
+               if (rc)
+                       RETURN(rc);
+       }
+
+       if (pattr->la_flags & LUSTRE_APPEND_FL)
+               RETURN(-EPERM);
+
+       RETURN(0);
 }
 
 /*
  * Check whether it may delete the cobj from the pobj.
  * pobj maybe NULL
  */
-int mdd_may_delete(const struct lu_env *env, struct mdd_object *pobj,
-                  struct mdd_object *cobj, struct lu_attr *cattr,
-                  struct lu_attr *src_attr, int check_perm, int check_empty)
+int mdd_may_delete(const struct lu_env *env, struct mdd_object *tpobj,
+                  const struct lu_attr *tpattr, struct mdd_object *tobj,
+                  const struct lu_attr *tattr, const struct lu_attr *cattr,
+                  int check_perm, int check_empty)
 {
-        int rc = 0;
-        ENTRY;
-
-        LASSERT(cobj);
-        if (!mdd_object_exists(cobj))
-                RETURN(-ENOENT);
-
-        if (mdd_is_dead_obj(cobj))
-                RETURN(-ESTALE);
-
-        if (pobj) {
-                if (!mdd_object_exists(pobj))
-                        RETURN(-ENOENT);
+       int rc = 0;
+       ENTRY;
 
-                if (mdd_is_dead_obj(pobj))
-                        RETURN(-ENOENT);
+       if (tpobj) {
+               LASSERT(tpattr != NULL);
+               rc = mdd_may_delete_entry(env, tpobj, tpattr, check_perm);
+               if (rc != 0)
+                       RETURN(rc);
+       }
 
-                if (check_perm) {
-                        rc = mdd_permission_internal_locked(env, pobj, NULL,
-                                                    MAY_WRITE | MAY_EXEC,
-                                                    MOR_TGT_PARENT);
-                        if (rc)
-                                RETURN(rc);
-                }
+       if (tobj == NULL)
+               RETURN(0);
 
-                if (mdd_is_append(pobj))
-                        RETURN(-EPERM);
-        }
+       if (!mdd_object_exists(tobj))
+               RETURN(-ENOENT);
 
-       if (mdd_is_sticky(env, pobj, cobj))
-                RETURN(-EPERM);
+       if (mdd_is_dead_obj(tobj))
+               RETURN(-ESTALE);
 
-        if (mdd_is_immutable(cobj) || mdd_is_append(cobj))
-                RETURN(-EPERM);
+       if (mdd_is_sticky(env, tpobj, tpattr, tobj, tattr))
+               RETURN(-EPERM);
 
-       if ((cattr->la_valid & LA_FLAGS) &&
-           (cattr->la_flags & (LUSTRE_APPEND_FL | LUSTRE_IMMUTABLE_FL)))
-                RETURN(-EPERM);
+       if (tattr->la_flags & (LUSTRE_APPEND_FL | LUSTRE_IMMUTABLE_FL))
+               RETURN(-EPERM);
 
        /* additional check the rename case */
-       if (src_attr) {
-               if (S_ISDIR(src_attr->la_mode)) {
-                       struct mdd_device *mdd = mdo2mdd(&cobj->mod_obj);
+       if (cattr) {
+               if (S_ISDIR(cattr->la_mode)) {
+                       struct mdd_device *mdd = mdo2mdd(&tobj->mod_obj);
 
-                       if (!S_ISDIR(cattr->la_mode))
+                       if (!S_ISDIR(tattr->la_mode))
                                RETURN(-ENOTDIR);
 
-                       if (lu_fid_eq(mdo2fid(cobj), &mdd->mdd_root_fid))
+                       if (lu_fid_eq(mdo2fid(tobj), &mdd->mdd_root_fid))
                                RETURN(-EBUSY);
-               } else if (S_ISDIR(cattr->la_mode))
+               } else if (S_ISDIR(tattr->la_mode))
                        RETURN(-EISDIR);
        }
 
-       if (S_ISDIR(cattr->la_mode) && check_empty)
-                rc = mdd_dir_is_empty(env, cobj);
+       if (S_ISDIR(tattr->la_mode) && check_empty)
+               rc = mdd_dir_is_empty(env, tobj);
 
-        RETURN(rc);
+       RETURN(rc);
 }
 
-/*
- * tgt maybe NULL
- * has mdd_write_lock on src already, but not on tgt yet
+/**
+ * Check whether it can create the link file(linked to @src_obj) under
+ * the target directory(@tgt_obj), and src_obj has been locked by
+ * mdd_write_lock.
+ *
+ * \param[in] env      execution environment
+ * \param[in] tgt_obj  the target directory
+ * \param[in] tattr    attributes of target directory
+ * \param[in] lname    the link name
+ * \param[in] src_obj  source object for link
+ * \param[in] cattr    attributes for source object
+ *
+ * \retval             = 0 it is allowed to create the link file under tgt_obj
+ * \retval              negative error not allowed to create the link file
  */
-int mdd_link_sanity_check(const struct lu_env *env,
-                          struct mdd_object *tgt_obj,
-                          const struct lu_name *lname,
-                          struct mdd_object *src_obj)
+static int mdd_link_sanity_check(const struct lu_env *env,
+                                struct mdd_object *tgt_obj,
+                                const struct lu_attr *tattr,
+                                const struct lu_name *lname,
+                                struct mdd_object *src_obj,
+                                const struct lu_attr *cattr)
 {
         struct mdd_device *m = mdd_obj2mdd_dev(src_obj);
         int rc = 0;
@@ -459,64 +535,62 @@ int mdd_link_sanity_check(const struct lu_env *env,
                 RETURN(-ESTALE);
 
         /* Local ops, no lookup before link, check filename length here. */
-        if (lname && (lname->ln_namelen > m->mdd_dt_conf.ddp_max_name_len))
-                RETURN(-ENAMETOOLONG);
+       rc = mdd_name_check(m, lname);
+       if (rc < 0)
+               RETURN(rc);
 
-        if (mdd_is_immutable(src_obj) || mdd_is_append(src_obj))
-                RETURN(-EPERM);
+       if (cattr->la_flags & (LUSTRE_IMMUTABLE_FL | LUSTRE_APPEND_FL))
+               RETURN(-EPERM);
 
-        if (S_ISDIR(mdd_object_type(src_obj)))
-                RETURN(-EPERM);
+       if (S_ISDIR(mdd_object_type(src_obj)))
+               RETURN(-EPERM);
 
-        LASSERT(src_obj != tgt_obj);
-        if (tgt_obj) {
-                rc = mdd_may_create(env, tgt_obj, NULL, 1, 0);
-                if (rc)
-                        RETURN(rc);
-        }
+       LASSERT(src_obj != tgt_obj);
+       rc = mdd_may_create(env, tgt_obj, tattr, NULL, true);
+       if (rc != 0)
+               RETURN(rc);
 
-        rc = __mdd_may_link(env, src_obj);
+       rc = __mdd_may_link(env, src_obj, cattr);
 
-        RETURN(rc);
+       RETURN(rc);
 }
 
 static int __mdd_index_delete_only(const struct lu_env *env, struct mdd_object *pobj,
-                                   const char *name, struct thandle *handle,
-                                   struct lustre_capa *capa)
+                                  const char *name, struct thandle *handle)
 {
-        struct dt_object *next = mdd_object_child(pobj);
-        int               rc;
-        ENTRY;
+       struct dt_object *next = mdd_object_child(pobj);
+       int rc;
+       ENTRY;
 
-        if (dt_try_as_dir(env, next)) {
-                rc = next->do_index_ops->dio_delete(env, next,
-                                                    (struct dt_key *)name,
-                                                    handle, capa);
-        } else
-                rc = -ENOTDIR;
+       if (dt_try_as_dir(env, next))
+               rc = dt_delete(env, next, (struct dt_key *)name, handle);
+       else
+               rc = -ENOTDIR;
 
-        RETURN(rc);
+       RETURN(rc);
 }
 
 static int __mdd_index_insert_only(const struct lu_env *env,
                                   struct mdd_object *pobj,
-                                  const struct lu_fid *lf, const char *name,
-                                  struct thandle *handle,
-                                  struct lustre_capa *capa)
+                                  const struct lu_fid *lf, __u32 type,
+                                  const char *name,
+                                  struct thandle *handle)
 {
        struct dt_object *next = mdd_object_child(pobj);
        int               rc;
        ENTRY;
 
        if (dt_try_as_dir(env, next)) {
-               struct lu_ucred  *uc = lu_ucred_check(env);
-               int ignore_quota;
+               struct dt_insert_rec    *rec = &mdd_env_info(env)->mti_dt_rec;
+               struct lu_ucred         *uc  = lu_ucred_check(env);
+               int                      ignore_quota;
 
+               rec->rec_fid = lf;
+               rec->rec_type = type;
                ignore_quota = uc ? uc->uc_cap & CFS_CAP_SYS_RESOURCE_MASK : 1;
-               rc = next->do_index_ops->dio_insert(env, next,
-                                                   (struct dt_rec*)lf,
-                                                   (const struct dt_key *)name,
-                                                   handle, capa, ignore_quota);
+               rc = dt_insert(env, next, (const struct dt_rec *)rec,
+                              (const struct dt_key *)name, handle,
+                              ignore_quota);
        } else {
                rc = -ENOTDIR;
        }
@@ -525,30 +599,31 @@ static int __mdd_index_insert_only(const struct lu_env *env,
 
 /* insert named index, add reference if isdir */
 static int __mdd_index_insert(const struct lu_env *env, struct mdd_object *pobj,
-                              const struct lu_fid *lf, const char *name, int is_dir,
-                              struct thandle *handle, struct lustre_capa *capa)
+                             const struct lu_fid *lf, __u32 type,
+                             const char *name, struct thandle *handle)
 {
-        int               rc;
-        ENTRY;
+       int rc;
+       ENTRY;
 
-        rc = __mdd_index_insert_only(env, pobj, lf, name, handle, capa);
-        if (rc == 0 && is_dir) {
-                mdd_write_lock(env, pobj, MOR_TGT_PARENT);
-                mdo_ref_add(env, pobj, handle);
-                mdd_write_unlock(env, pobj);
-        }
-        RETURN(rc);
+       rc = __mdd_index_insert_only(env, pobj, lf, type, name, handle);
+       if (rc == 0 && S_ISDIR(type)) {
+               mdd_write_lock(env, pobj, MOR_TGT_PARENT);
+               mdo_ref_add(env, pobj, handle);
+               mdd_write_unlock(env, pobj);
+       }
+
+       RETURN(rc);
 }
 
 /* delete named index, drop reference if isdir */
 static int __mdd_index_delete(const struct lu_env *env, struct mdd_object *pobj,
-                              const char *name, int is_dir, struct thandle *handle,
-                              struct lustre_capa *capa)
+                             const char *name, int is_dir,
+                             struct thandle *handle)
 {
         int               rc;
         ENTRY;
 
-        rc = __mdd_index_delete_only(env, pobj, name, handle, capa);
+       rc = __mdd_index_delete_only(env, pobj, name, handle);
         if (rc == 0 && is_dir) {
                 mdd_write_lock(env, pobj, MOR_TGT_PARENT);
                 mdo_ref_del(env, pobj, handle);
@@ -558,69 +633,37 @@ 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)
+static int mdd_llog_record_calc_size(const struct lu_env *env,
+                                    const struct lu_name *tname,
+                                    const struct lu_name *sname)
 {
-        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;
+       const struct lu_ucred   *uc = lu_ucred(env);
+       enum changelog_rec_flags crf = 0;
+       size_t                   hdr_size = sizeof(struct llog_changelog_rec) -
+                                           sizeof(struct changelog_rec);
 
-        /* new record referencing new plain llog */
-        rc = dt_declare_record_write(env, mdd->mdd_capa,
-                                     DECLARE_LLOG_WRITE, 0, handle);
-        if (rc)
-                return rc;
+       if (sname != NULL)
+               crf |= CLF_RENAME;
 
-        /* catalog's header will be updated as well */
-        rc = dt_declare_record_write(env, mdd->mdd_capa,
-                                     DECLARE_LLOG_REWRITE, 0, handle);
+       if (uc != NULL && uc->uc_jobid[0] != '\0')
+               crf |= CLF_JOBID;
 
-        return rc;
+       return llog_data_len(hdr_size + changelog_rec_offset(crf) +
+                            (tname != NULL ? tname->ln_namelen : 0) +
+                            (sname != NULL ? 1 + sname->ln_namelen : 0));
 }
 
 int mdd_declare_changelog_store(const struct lu_env *env,
                                struct mdd_device *mdd,
-                               const struct lu_name *fname,
+                               const struct lu_name *tname,
+                               const struct lu_name *sname,
                                struct thandle *handle)
 {
        struct obd_device               *obd = mdd2obd_dev(mdd);
        struct llog_ctxt                *ctxt;
        struct llog_changelog_rec       *rec;
        struct lu_buf                   *buf;
+       struct thandle                  *llog_th;
        int                              reclen;
        int                              rc;
 
@@ -628,9 +671,8 @@ int mdd_declare_changelog_store(const struct lu_env *env,
        if (!(mdd->mdd_cl.mc_flags & CLM_ON))
                return 0;
 
-       reclen = llog_data_len(sizeof(*rec) +
-                              (fname != NULL ? fname->ln_namelen : 0));
-       buf = mdd_buf_alloc(env, reclen);
+       reclen = mdd_llog_record_calc_size(env, tname, sname);
+       buf = lu_buf_check_and_alloc(&mdd_env_info(env)->mti_big_buf, reclen);
        if (buf->lb_buf == NULL)
                return -ENOMEM;
 
@@ -642,45 +684,13 @@ int mdd_declare_changelog_store(const struct lu_env *env,
        if (ctxt == NULL)
                return -ENXIO;
 
-       rc = llog_declare_add(env, ctxt->loc_handle, &rec->cr_hdr, handle);
-       llog_ctxt_put(ctxt);
-
-       return rc;
-}
-
-static int mdd_declare_changelog_ext_store(const struct lu_env *env,
-                                          struct mdd_device *mdd,
-                                          const struct lu_name *tname,
-                                          const struct lu_name *sname,
-                                          struct thandle *handle)
-{
-       struct obd_device               *obd = mdd2obd_dev(mdd);
-       struct llog_ctxt                *ctxt;
-       struct llog_changelog_ext_rec   *rec;
-       struct lu_buf                   *buf;
-       int                              reclen;
-       int                              rc;
-
-       /* Not recording */
-       if (!(mdd->mdd_cl.mc_flags & CLM_ON))
-               return 0;
-
-       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);
-       if (buf->lb_buf == NULL)
-               return -ENOMEM;
-
-       rec = buf->lb_buf;
-       rec->cr_hdr.lrh_len = reclen;
-       rec->cr_hdr.lrh_type = CHANGELOG_REC;
+       llog_th = thandle_get_sub(env, handle, ctxt->loc_handle->lgh_obj);
+       if (IS_ERR(llog_th))
+               GOTO(out_put, rc = PTR_ERR(llog_th));
 
-       ctxt = llog_get_context(obd, LLOG_CHANGELOG_ORIG_CTXT);
-       if (ctxt == NULL)
-               return -ENXIO;
+       rc = llog_declare_add(env, ctxt->loc_handle, &rec->cr_hdr, llog_th);
 
-       rc = llog_declare_add(env, ctxt->loc_handle, &rec->cr_hdr, handle);
+out_put:
        llog_ctxt_put(ctxt);
 
        return rc;
@@ -690,7 +700,7 @@ static int mdd_declare_changelog_ext_store(const struct lu_env *env,
  * \param mdd
  * \param rec
  * \param handle - currently ignored since llogs start their own transaction;
- *                 this will hopefully be fixed in llog rewrite
+ *             this will hopefully be fixed in llog rewrite
  * \retval 0 ok
  */
 int mdd_changelog_store(const struct lu_env *env, struct mdd_device *mdd,
@@ -698,9 +708,13 @@ int mdd_changelog_store(const struct lu_env *env, struct mdd_device *mdd,
 {
        struct obd_device       *obd = mdd2obd_dev(mdd);
        struct llog_ctxt        *ctxt;
+       struct thandle          *llog_th;
        int                      rc;
 
-       rec->cr_hdr.lrh_len = llog_data_len(sizeof(*rec) + rec->cr.cr_namelen);
+       rec->cr_hdr.lrh_len = llog_data_len(sizeof(*rec) +
+                                           changelog_rec_varsize(&rec->cr));
+
+       /* llog_lvfs_write_rec sets the llog tail len */
        rec->cr_hdr.lrh_type = CHANGELOG_REC;
        rec->cr.cr_time = cl_time();
 
@@ -715,174 +729,118 @@ int mdd_changelog_store(const struct lu_env *env, struct mdd_device *mdd,
        if (ctxt == NULL)
                return -ENXIO;
 
-       rc = llog_add(env, ctxt->loc_handle, &rec->cr_hdr, NULL, NULL, th);
+       llog_th = thandle_get_sub(env, th, ctxt->loc_handle->lgh_obj);
+       if (IS_ERR(llog_th))
+               GOTO(out_put, rc = PTR_ERR(llog_th));
+
+       /* nested journal transaction */
+       rc = llog_add(env, ctxt->loc_handle, &rec->cr_hdr, NULL, llog_th);
+
+out_put:
        llog_ctxt_put(ctxt);
        if (rc > 0)
                rc = 0;
        return rc;
 }
 
-/** Add a changelog_ext entry \a rec to the changelog llog
- * \param mdd
- * \param rec
- * \param handle - currently ignored since llogs start their own transaction;
- *             this will hopefully be fixed in llog rewrite
- * \retval 0 ok
- */
-int mdd_changelog_ext_store(const struct lu_env *env, struct mdd_device *mdd,
-                           struct llog_changelog_ext_rec *rec,
-                           struct thandle *th)
+static void mdd_changelog_rec_ext_rename(struct changelog_rec *rec,
+                                        const struct lu_fid *sfid,
+                                        const struct lu_fid *spfid,
+                                        const struct lu_name *sname)
 {
-       struct obd_device       *obd = mdd2obd_dev(mdd);
-       struct llog_ctxt        *ctxt;
-       int                      rc;
+       struct changelog_ext_rename     *rnm = changelog_rec_rename(rec);
+       size_t                           extsize = sname->ln_namelen + 1;
 
-       rec->cr_hdr.lrh_len = llog_data_len(sizeof(*rec) + rec->cr.cr_namelen);
-       /* llog_lvfs_write_rec sets the llog tail len */
-       rec->cr_hdr.lrh_type = CHANGELOG_REC;
-       rec->cr.cr_time = cl_time();
+       LASSERT(sfid != NULL);
+       LASSERT(spfid != NULL);
+       LASSERT(sname != NULL);
 
-       spin_lock(&mdd->mdd_cl.mc_lock);
-       /* NB: I suppose it's possible llog_add adds out of order wrt cr_index,
-        * but as long as the MDD transactions are ordered correctly for e.g.
-        * rename conflicts, I don't think this should matter. */
-       rec->cr.cr_index = ++mdd->mdd_cl.mc_index;
-       spin_unlock(&mdd->mdd_cl.mc_lock);
+       rnm->cr_sfid = *sfid;
+       rnm->cr_spfid = *spfid;
 
-       ctxt = llog_get_context(obd, LLOG_CHANGELOG_ORIG_CTXT);
-       if (ctxt == NULL)
-               return -ENXIO;
+       changelog_rec_name(rec)[rec->cr_namelen] = '\0';
+       strlcpy(changelog_rec_sname(rec), sname->ln_name, extsize);
+       rec->cr_namelen += extsize;
+}
 
-       /* nested journal transaction */
-       rc = llog_add(env, ctxt->loc_handle, &rec->cr_hdr, NULL, NULL, th);
-       llog_ctxt_put(ctxt);
-       if (rc > 0)
-               rc = 0;
+void mdd_changelog_rec_ext_jobid(struct changelog_rec *rec, const char *jobid)
+{
+       struct changelog_ext_jobid      *jid = changelog_rec_jobid(rec);
 
-       return rc;
+       if (jobid == NULL || jobid[0] == '\0')
+               return;
+
+       strlcpy(jid->cr_jobid, jobid, sizeof(jid->cr_jobid));
 }
 
 /** Store a namespace change changelog record
  * If this fails, we must fail the whole transaction; we don't
  * want the change to commit without the log entry.
  * \param target - mdd_object of change
- * \param parent - parent dir/object
- * \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)
-{
-       struct llog_changelog_rec *rec;
-       struct lu_buf *buf;
-       int reclen;
-       int rc;
-       ENTRY;
-
-       /* Not recording */
-       if (!(mdd->mdd_cl.mc_flags & CLM_ON))
-               RETURN(0);
-       if ((mdd->mdd_cl.mc_mask & (1 << type)) == 0)
-               RETURN(0);
-
-       LASSERT(target != NULL);
-       LASSERT(parent != NULL);
-       LASSERT(tname != NULL);
-       LASSERT(handle != NULL);
-
-       reclen = llog_data_len(sizeof(*rec) + tname->ln_namelen);
-       buf = mdd_buf_alloc(env, reclen);
-       if (buf->lb_buf == NULL)
-               RETURN(-ENOMEM);
-       rec = buf->lb_buf;
-
-       rec->cr.cr_flags = CLF_VERSION | (CLF_FLAGMASK & flags);
-       rec->cr.cr_type = (__u32)type;
-       rec->cr.cr_tfid = *mdo2fid(target);
-       rec->cr.cr_pfid = *mdo2fid(parent);
-       rec->cr.cr_namelen = tname->ln_namelen;
-       memcpy(rec->cr.cr_name, tname->ln_name, tname->ln_namelen);
-
-       target->mod_cltime = cfs_time_current_64();
-
-       rc = mdd_changelog_store(env, mdd, rec, handle);
-       if (rc < 0) {
-               CERROR("changelog failed: rc=%d, op%d %s c"DFID" p"DFID"\n",
-                       rc, type, tname->ln_name, PFID(&rec->cr.cr_tfid),
-                       PFID(&rec->cr.cr_pfid));
-               RETURN(-EFAULT);
-       }
-
-       RETURN(0);
-}
-
-
-/** Store a namespace change changelog record
- * If this fails, we must fail the whole transaction; we don't
- * want the change to commit without the log entry.
- * \param target - mdd_object of change
- * \param tpfid - target parent dir/object fid
- * \param sfid - source object fid
- * \param spfid - source parent fid
+ * \param tpfid - target parent dir/object fid
+ * \param sfid - source object fid
+ * \param spfid - source parent fid
  * \param tname - target name string
  * \param sname - source name string
  * \param handle - transacion handle
  */
-static int mdd_changelog_ext_ns_store(const struct lu_env  *env,
-                                     struct mdd_device    *mdd,
-                                     enum changelog_rec_type type,
-                                     unsigned flags,
-                                     struct mdd_object    *target,
-                                     const struct lu_fid  *tpfid,
-                                     const struct lu_fid  *sfid,
-                                     const struct lu_fid  *spfid,
-                                     const struct lu_name *tname,
-                                     const struct lu_name *sname,
-                                     struct thandle *handle)
+int mdd_changelog_ns_store(const struct lu_env *env,
+                          struct mdd_device *mdd,
+                          enum changelog_rec_type type,
+                          enum changelog_rec_flags crf,
+                          struct mdd_object *target,
+                          const struct lu_fid *tpfid,
+                          const struct lu_fid *sfid,
+                          const struct lu_fid *spfid,
+                          const struct lu_name *tname,
+                          const struct lu_name *sname,
+                          struct thandle *handle)
 {
-       struct llog_changelog_ext_rec *rec;
-       struct lu_buf *buf;
-       int reclen;
-       int rc;
+       const struct lu_ucred           *uc = lu_ucred(env);
+       struct llog_changelog_rec       *rec;
+       struct lu_buf                   *buf;
+       int                              reclen;
+       int                              rc;
        ENTRY;
 
        /* Not recording */
        if (!(mdd->mdd_cl.mc_flags & CLM_ON))
                RETURN(0);
+
        if ((mdd->mdd_cl.mc_mask & (1 << type)) == 0)
                RETURN(0);
 
-       LASSERT(sfid != NULL);
        LASSERT(tpfid != NULL);
        LASSERT(tname != NULL);
        LASSERT(handle != NULL);
 
-       reclen = llog_data_len(sizeof(*rec) +
-                              sname != NULL ? 1 + sname->ln_namelen : 0);
-       buf = mdd_buf_alloc(env, reclen);
+       reclen = mdd_llog_record_calc_size(env, tname, sname);
+       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;
 
-       rec->cr.cr_flags = CLF_EXT_VERSION | (CLF_FLAGMASK & flags);
+       crf &= CLF_FLAGMASK;
+
+       if (uc != NULL && uc->uc_jobid[0] != '\0')
+               crf |= CLF_JOBID;
+
+       if (sname != NULL)
+               crf |= CLF_RENAME;
+       else
+               crf |= CLF_VERSION;
+
+       rec->cr.cr_flags = crf;
        rec->cr.cr_type = (__u32)type;
        rec->cr.cr_pfid = *tpfid;
-       rec->cr.cr_sfid = *sfid;
-       rec->cr.cr_spfid = *spfid;
        rec->cr.cr_namelen = tname->ln_namelen;
-       memcpy(rec->cr.cr_name, tname->ln_name, tname->ln_namelen);
-       if (sname) {
-               rec->cr.cr_name[tname->ln_namelen] = '\0';
-               memcpy(rec->cr.cr_name + tname->ln_namelen + 1, sname->ln_name,
-                       sname->ln_namelen);
-               rec->cr.cr_namelen += 1 + sname->ln_namelen;
-       }
+       memcpy(changelog_rec_name(&rec->cr), tname->ln_name, tname->ln_namelen);
+
+       if (crf & CLF_RENAME)
+               mdd_changelog_rec_ext_rename(&rec->cr, sfid, spfid, sname);
+
+       if (crf & CLF_JOBID)
+               mdd_changelog_rec_ext_jobid(&rec->cr, uc->uc_jobid);
 
        if (likely(target != NULL)) {
                rec->cr.cr_tfid = *mdo2fid(target);
@@ -891,7 +849,7 @@ static int mdd_changelog_ext_ns_store(const struct lu_env  *env,
                fid_zero(&rec->cr.cr_tfid);
        }
 
-       rc = mdd_changelog_ext_store(env, mdd, rec, handle);
+       rc = mdd_changelog_store(env, mdd, rec, handle);
        if (rc < 0) {
                CERROR("changelog failed: rc=%d, op%d %s c"DFID" p"DFID"\n",
                        rc, type, tname->ln_name, PFID(sfid), PFID(tpfid));
@@ -901,250 +859,432 @@ 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;
+       int rc;
 
-        handle = mdd_trans_create(env, mdd);
-        if (IS_ERR(handle))
-                GOTO(out_pending, rc = PTR_ERR(handle));
+       if (ldata->ld_leh == NULL) {
+               rc = mdd_links_read(env, mdd_obj, ldata);
+               if (rc)
+                       return rc;
+       }
 
-        rc = mdd_declare_link(env, mdd, mdd_tobj, mdd_sobj, lname, handle);
-        if (rc)
-                GOTO(stop, rc);
+       rc = linkea_links_find(ldata, lname, pfid);
+       if (rc)
+               return rc;
 
-        rc = mdd_trans_start(env, mdd, handle);
-        if (rc)
-                GOTO(stop, rc);
+       linkea_del_buf(ldata, lname);
+       return 0;
+}
 
-        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);
+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 = mdd_link_sanity_check(env, mdd_tobj, lname, mdd_sobj);
-        if (rc)
-                GOTO(out_unlock, rc);
+       if (OBD_FAIL_CHECK(OBD_FAIL_FID_IGIF))
+               return 0;
 
-        rc = __mdd_index_insert_only(env, mdd_tobj, mdo2fid(mdd_sobj),
-                                     name, handle,
-                                     mdd_object_capa(env, mdd_tobj));
-        if (rc)
-                GOTO(out_unlock, rc);
+       LASSERT(oldpfid != NULL || newpfid != NULL);
 
-       rc = mdo_ref_add(env, mdd_sobj, handle);
-       if (rc != 0) {
-               __mdd_index_delete_only(env, mdd_tobj, name, handle,
-                                       mdd_object_capa(env, mdd_tobj));
-                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 == 1) ||
+                           (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);
+       }
 
-        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 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) {
+               int error = 1;
+               if (rc == -EOVERFLOW || 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() */
-                if (obj->mod_count) {
-                        rc = __mdd_orphan_add(env, obj, th);
-                        if (rc == 0)
-                                CDEBUG(D_HA, "Object "DFID" is inserted into "
-                                        "orphan list, open count = %d\n",
-                                        PFID(mdd_object_fid(obj)),
-                                        obj->mod_count);
-                        else
-                                CERROR("Object "DFID" fail to be an orphan, "
-                                       "open count = %d, maybe cause failed "
-                                       "open replay\n",
-                                        PFID(mdd_object_fid(obj)),
-                                        obj->mod_count);
-                } else {
-                       rc = mdo_destroy(env, obj, th);
-                }
-        }
+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 *ldata, int first)
+{
+       return mdd_links_rename(env, mdd_obj, NULL, NULL,
+                               pfid, lname, handle, ldata, first, 0);
+}
 
-        RETURN(rc);
+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);
 }
 
-/*
- * pobj maybe NULL
- * has mdd_write_lock on cobj already, but not on pobj yet
+/** 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_unlink_sanity_check(const struct lu_env *env, struct mdd_object *pobj,
-                           struct mdd_object *cobj, struct lu_attr *cattr)
+int mdd_links_read(const struct lu_env *env, struct mdd_object *mdd_obj,
+                  struct linkea_data *ldata)
 {
-        int rc;
-        ENTRY;
+       int rc;
 
-       rc = mdd_may_delete(env, pobj, cobj, cattr, NULL, 1, 1);
+       if (!mdd_object_exists(mdd_obj))
+               return -ENODATA;
 
-        RETURN(rc);
-}
+       /* First try a small buf */
+       LASSERT(env != NULL);
+       ldata->ld_buf = lu_buf_check_and_alloc(&mdd_env_info(env)->mti_link_buf,
+                                              PAGE_CACHE_SIZE);
+       if (ldata->ld_buf->lb_buf == NULL)
+               return -ENOMEM;
 
-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)
+       rc = mdo_xattr_get(env, mdd_obj, ldata->ld_buf, XATTR_NAME_LINK);
+       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);
+               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);
+       }
+       if (rc < 0) {
+               lu_buf_free(ldata->ld_buf);
+               ldata->ld_buf = NULL;
+               return rc;
+       }
+
+       return linkea_init(ldata);
+}
+
+/** 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)
 {
-        int rc;
+       struct linkea_data ldata = { NULL };
+       int rc;
 
-        rc = mdo_declare_index_delete(env, p, name->ln_name, handle);
-        if (rc)
-                return rc;
+       rc = mdd_links_read(env, mdd_obj, &ldata);
+       return rc ? ERR_PTR(rc) : ldata.ld_buf;
+}
 
-        rc = mdo_declare_ref_del(env, p, handle);
-        if (rc)
-                return rc;
+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);
+       int                 rc;
 
-        rc = mdo_declare_ref_del(env, c, handle);
-        if (rc)
-                return rc;
+       if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_NO_LINKEA))
+               return 0;
 
-        rc = mdo_declare_ref_del(env, c, handle);
-        if (rc)
-                return rc;
+       rc = mdo_xattr_set(env, mdd_obj, buf, XATTR_NAME_LINK, 0, handle);
+       if (unlikely(rc == -ENOSPC) && S_ISREG(mdd_object_type(mdd_obj)) &&
+           mdd_object_remote(mdd_obj) == 0) {
+               struct lfsck_request *lr = &mdd_env_info(env)->mti_lr;
+               struct thandle  *sub_th;
+
+               /* XXX: If the linkEA is overflow, then we need to notify the
+                *      namespace LFSCK to skip "nlink" attribute verification
+                *      on this object to avoid the "nlink" to be shrinked by
+                *      wrong. It may be not good an interaction with LFSCK
+                *      like this. We will consider to replace it with other
+                *      mechanism in future. LU-5802. */
+               lfsck_pack_rfa(lr, mdo2fid(mdd_obj), LE_SKIP_NLINK,
+                              LFSCK_TYPE_NAMESPACE);
+
+               sub_th = thandle_get_sub_by_dt(env, handle,
+                               mdo2mdd(&mdd_obj->mod_obj)->mdd_bottom);
+               lfsck_in_notify(env, mdo2mdd(&mdd_obj->mod_obj)->mdd_bottom,
+                               lr, sub_th);
+       }
 
-        rc = mdo_declare_attr_set(env, p, NULL, handle);
-        if (rc)
-                return rc;
+       return rc;
+}
 
-        rc = mdo_declare_attr_set(env, c, NULL, handle);
-        if (rc)
-                return rc;
+int mdd_declare_links_add(const struct lu_env *env, struct mdd_object *mdd_obj,
+                         struct thandle *handle, struct linkea_data *ldata,
+                         enum mdd_links_add_overflow overflow)
+{
+       int     rc;
+       int     ea_len;
+       void    *linkea;
 
-        rc = mdd_declare_finish_unlink(env, c, ma, handle);
-        if (rc)
-                return rc;
+       if (ldata != NULL && ldata->ld_leh != NULL) {
+               ea_len = ldata->ld_leh->leh_len;
+               linkea = ldata->ld_buf->lb_buf;
+       } else {
+               ea_len = DEFAULT_LINKEA_SIZE;
+               linkea = NULL;
+       }
 
-        rc = mdd_declare_links_add(env, c, handle);
-        if (rc)
-                return rc;
+       /* XXX: max size? */
+       rc = mdo_declare_xattr_set(env, mdd_obj,
+                                  mdd_buf_get_const(env, linkea, ea_len),
+                                  XATTR_NAME_LINK, 0, handle);
+       if (rc != 0)
+               return rc;
 
-        rc = mdd_declare_changelog_store(env, mdd, name, handle);
+       if (mdd_object_remote(mdd_obj) == 0 && overflow == MLAO_CHECK) {
+               struct lfsck_request *lr = &mdd_env_info(env)->mti_lr;
+               struct thandle  *sub_th;
+
+               /* XXX: If the linkEA is overflow, then we need to notify the
+                *      namespace LFSCK to skip "nlink" attribute verification
+                *      on this object to avoid the "nlink" to be shrinked by
+                *      wrong. It may be not good an interaction with LFSCK
+                *      like this. We will consider to replace it with other
+                *      mechanism in future. LU-5802. */
+               lfsck_pack_rfa(lr, mdo2fid(mdd_obj), LE_SKIP_NLINK_DECLARE,
+                              LFSCK_TYPE_NAMESPACE);
+
+               sub_th = thandle_get_sub_by_dt(env, handle,
+                               mdo2mdd(&mdd_obj->mod_obj)->mdd_bottom);
+               rc = lfsck_in_notify(env,
+                                    mdo2mdd(&mdd_obj->mod_obj)->mdd_bottom,
+                                    lr, sub_th);
+       }
 
-        return rc;
+       return rc;
 }
 
-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)
+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, MLAO_IGNORE);
+
+       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), mdd_object_type(c),
+                                     name->ln_name, handle);
+       if (rc != 0)
+               return rc;
+
+       rc = mdo_declare_ref_add(env, c, handle);
+       if (rc != 0)
+               return rc;
+
+       if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_MORE_NLINK)) {
+               rc = mdo_declare_ref_add(env, c, handle);
+               if (rc != 0)
+                       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 != 0)
+               return rc;
+
+       rc = mdd_declare_links_add(env, c, handle, data,
+                       S_ISREG(mdd_object_type(c)) ? MLAO_CHECK : MLAO_IGNORE);
+       if (rc != 0)
+               return rc;
+
+       rc = mdd_declare_changelog_store(env, mdd, name, NULL, 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     *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_device *mdd = mdo2mdd(pobj);
-        struct dynlock_handle *dlh;
-        struct thandle    *handle;
-       int rc, is_dir;
-        ENTRY;
+        struct mdd_object *mdd_tobj = md2mdd_obj(tgt_obj);
+        struct mdd_object *mdd_sobj = md2mdd_obj(src_obj);
+       struct lu_attr    *cattr = MDD_ENV_VAR(env, cattr);
+       struct lu_attr    *tattr = MDD_ENV_VAR(env, tattr);
+        struct mdd_device *mdd = mdo2mdd(src_obj);
+        struct thandle *handle;
+       struct linkea_data *ldata = &mdd_env_info(env)->mti_link_data;
+       int rc;
+       ENTRY;
 
-        if (mdd_object_exists(mdd_cobj) <= 0)
-                RETURN(-ENOENT);
+       rc = mdd_la_get(env, mdd_sobj, cattr);
+       if (rc != 0)
+               RETURN(rc);
+
+       rc = mdd_la_get(env, mdd_tobj, tattr);
+       if (rc != 0)
+               RETURN(rc);
 
         handle = mdd_trans_create(env, mdd);
         if (IS_ERR(handle))
-                RETURN(PTR_ERR(handle));
+                GOTO(out_pending, rc = PTR_ERR(handle));
 
-        rc = mdd_declare_unlink(env, mdd, mdd_pobj, mdd_cobj,
-                                lname, ma, 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);
 
@@ -1152,101 +1292,424 @@ static int mdd_unlink(const struct lu_env *env, struct md_object *pobj,
         if (rc)
                 GOTO(stop, rc);
 
-        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);
+       mdd_write_lock(env, mdd_sobj, MOR_TGT_CHILD);
+       rc = mdd_link_sanity_check(env, mdd_tobj, tattr, lname, mdd_sobj,
+                                  cattr);
+       if (rc)
+               GOTO(out_unlock, rc);
 
-       /* fetch cattr */
-       rc = mdd_la_get(env, mdd_cobj, cattr, mdd_object_capa(env, mdd_cobj));
-        if (rc)
-                GOTO(cleanup, rc);
+       if (!OBD_FAIL_CHECK(OBD_FAIL_LFSCK_LESS_NLINK)) {
+               rc = mdo_ref_add(env, mdd_sobj, handle);
+               if (rc != 0)
+                       GOTO(out_unlock, rc);
+       }
 
-       is_dir = S_ISDIR(cattr->la_mode);
+       if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_MORE_NLINK)) {
+               rc = mdo_ref_add(env, mdd_sobj, handle);
+               if (rc != 0)
+                       GOTO(out_unlock, rc);
+       }
 
-       rc = mdd_unlink_sanity_check(env, mdd_pobj, mdd_cobj, cattr);
-        if (rc)
-                GOTO(cleanup, rc);
+       if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_DANGLING3)) {
+               struct lu_fid tfid = *mdo2fid(mdd_sobj);
+
+               tfid.f_oid++;
+               rc = __mdd_index_insert_only(env, mdd_tobj, &tfid,
+                                            mdd_object_type(mdd_sobj),
+                                            name, handle);
+       } else {
+               rc = __mdd_index_insert_only(env, mdd_tobj, mdo2fid(mdd_sobj),
+                                            mdd_object_type(mdd_sobj),
+                                            name, handle);
+       }
 
-       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);
+               mdo_ref_del(env, mdd_sobj, handle);
+               GOTO(out_unlock, rc);
        }
 
-       rc = __mdd_index_delete(env, mdd_pobj, name, is_dir, handle,
-                               mdd_object_capa(env, mdd_pobj));
+       la->la_valid = LA_CTIME | LA_MTIME;
+       rc = mdd_update_time(env, mdd_tobj, tattr, la, handle);
        if (rc)
-               GOTO(cleanup, rc);
+               GOTO(out_unlock, rc);
+
+       la->la_valid = LA_CTIME;
+       rc = mdd_update_time(env, mdd_sobj, cattr, la, handle);
+       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);
+        if (rc == 0)
+               rc = mdd_changelog_ns_store(env, mdd, CL_HARDLINK, 0, mdd_sobj,
+                                           mdo2fid(mdd_tobj), NULL, NULL,
+                                           lname, NULL, 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;
+}
 
-        if (is_dir)
-                /* unlink dot */
-                mdo_ref_del(env, mdd_cobj, handle);
+static int mdd_mark_dead_object(const struct lu_env *env,
+                               struct mdd_object *obj, struct thandle *handle,
+                               bool declare)
+{
+       struct lu_attr *attr = MDD_ENV_VAR(env, la_for_start);
+       int rc;
 
-       /* fetch updated nlink */
-       rc = mdd_la_get(env, mdd_cobj, cattr, mdd_object_capa(env, mdd_cobj));
+       if (!declare)
+               obj->mod_flags |= DEAD_OBJ;
+
+       if (!S_ISDIR(mdd_object_type(obj)))
+               return 0;
+
+       attr->la_valid = LA_FLAGS;
+       attr->la_flags = LUSTRE_SLAVE_DEAD_FL;
+
+       if (declare)
+               rc = mdo_declare_attr_set(env, obj, attr, handle);
+       else
+               rc = mdo_attr_set(env, obj, attr, handle);
+
+       return rc;
+}
+
+static int mdd_declare_finish_unlink(const struct lu_env *env,
+                                    struct mdd_object *obj,
+                                    struct thandle *handle)
+{
+       int     rc;
+
+       rc = mdd_mark_dead_object(env, obj, handle, true);
+       if (rc != 0)
+               return rc;
+
+       rc = orph_declare_index_insert(env, obj, mdd_object_type(obj), handle);
+       if (rc != 0)
+               return rc;
+
+       rc = mdo_declare_destroy(env, obj, handle);
+       if (rc != 0)
+               return rc;
+
+       return mdd_declare_links_del(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,
+                     const struct mdd_object *pobj,
+                     const struct lu_name *lname,
+                     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) {
+               rc = mdd_mark_dead_object(env, obj, th, false);
+               if (rc != 0)
+                       RETURN(rc);
+
+                /* 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)
+                                CDEBUG(D_HA, "Object "DFID" is inserted into "
+                                        "orphan list, open count = %d\n",
+                                        PFID(mdd_object_fid(obj)),
+                                        obj->mod_count);
+                        else
+                                CERROR("Object "DFID" fail to be an orphan, "
+                                       "open count = %d, maybe cause failed "
+                                       "open replay\n",
+                                        PFID(mdd_object_fid(obj)),
+                                        obj->mod_count);
+                } else {
+                       rc = mdo_destroy(env, obj, th);
+                }
+       } else if (!is_dir) {
+               /* old files may not have link ea; ignore errors */
+               mdd_links_del(env, obj, mdo2fid(pobj), lname, th);
+       }
+
+       RETURN(rc);
+}
+
+/*
+ * pobj maybe NULL
+ * has mdd_write_lock on cobj already, but not on pobj yet
+ */
+int mdd_unlink_sanity_check(const struct lu_env *env, struct mdd_object *pobj,
+                           const struct lu_attr *pattr,
+                           struct mdd_object *cobj,
+                           const struct lu_attr *cattr)
+{
+       int rc;
+       ENTRY;
+
+       rc = mdd_may_delete(env, pobj, pattr, cobj, cattr, NULL, 1, 1);
+
+       RETURN(rc);
+}
+
+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, int no_name, int is_dir)
+{
+       struct lu_attr  *la = &mdd_env_info(env)->mti_la_for_fix;
+       int              rc;
+
+       if (!OBD_FAIL_CHECK(OBD_FAIL_LFSCK_DANGLING2)) {
+               if (likely(no_name == 0)) {
+                       rc = mdo_declare_index_delete(env, p, name->ln_name,
+                                                     handle);
+                       if (rc != 0)
+                               return rc;
+               }
+
+               if (is_dir != 0) {
+                       rc = mdo_declare_ref_del(env, p, handle);
+                       if (rc != 0)
+                               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)
-               GOTO(cleanup, rc);
+               return rc;
 
-        LASSERT(ma->ma_attr.la_valid & LA_CTIME);
-        la->la_ctime = la->la_mtime = ma->ma_attr.la_ctime;
+       if (c != NULL) {
+               rc = mdo_declare_ref_del(env, c, handle);
+               if (rc)
+                       return rc;
 
-        la->la_valid = LA_CTIME | LA_MTIME;
-       rc = mdd_attr_check_set_internal(env, mdd_pobj, la, handle, 0);
-        if (rc)
-                GOTO(cleanup, rc);
+               rc = mdo_declare_ref_del(env, c, 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, handle);
+               if (rc)
+                       return rc;
+
+               /* FIXME: need changelog for remove entry */
+               rc = mdd_declare_changelog_store(env, mdd, name, NULL, handle);
+       }
+
+       return rc;
+}
+
+/*
+ * test if a file has an HSM archive
+ * if HSM attributes are not found in ma update them from
+ * HSM xattr
+ */
+static bool mdd_hsm_archive_exists(const struct lu_env *env,
+                                  struct mdd_object *obj,
+                                  struct md_attr *ma)
+{
+       ENTRY;
+
+       if (!(ma->ma_valid & MA_HSM)) {
+               /* no HSM MD provided, read xattr */
+               struct lu_buf   *hsm_buf;
+               const size_t     buflen = sizeof(struct hsm_attrs);
+               int              rc;
+
+               hsm_buf = mdd_buf_get(env, NULL, 0);
+               lu_buf_alloc(hsm_buf, buflen);
+               rc = mdo_xattr_get(env, obj, hsm_buf, XATTR_NAME_HSM);
+               rc = lustre_buf2hsm(hsm_buf->lb_buf, rc, &ma->ma_hsm);
+               lu_buf_free(hsm_buf);
+               if (rc < 0)
+                       RETURN(false);
+
+               ma->ma_valid = MA_HSM;
+       }
+       if (ma->ma_hsm.mh_flags & HS_EXISTS)
+               RETURN(true);
+       RETURN(false);
+}
+
+/**
+ * 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, int no_name)
+{
+       const char *name = lname->ln_name;
+       struct lu_attr *pattr = MDD_ENV_VAR(env, pattr);
+       struct lu_attr *cattr = MDD_ENV_VAR(env, 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 = NULL;
+       struct mdd_device *mdd = mdo2mdd(pobj);
+       struct thandle    *handle;
+       int rc, is_dir = 0;
+       ENTRY;
+
+       /* 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);
+       }
+
+       rc = mdd_la_get(env, mdd_pobj, pattr);
+       if (rc)
+               RETURN(rc);
+
+       if (likely(mdd_cobj != NULL)) {
+               /* fetch cattr */
+               rc = mdd_la_get(env, mdd_cobj, cattr);
+               if (rc)
+                       RETURN(rc);
+
+               is_dir = S_ISDIR(cattr->la_mode);
+       }
+
+       rc = mdd_unlink_sanity_check(env, mdd_pobj, pattr, mdd_cobj, cattr);
+       if (rc)
+                RETURN(rc);
+
+       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, no_name, is_dir);
+       if (rc)
+               GOTO(stop, rc);
+
+       rc = mdd_trans_start(env, mdd, handle);
+       if (rc)
+               GOTO(stop, rc);
+
+       if (likely(mdd_cobj != NULL))
+               mdd_write_lock(env, mdd_cobj, MOR_TGT_CHILD);
+
+       if (likely(no_name == 0) && !OBD_FAIL_CHECK(OBD_FAIL_LFSCK_DANGLING2)) {
+               rc = __mdd_index_delete(env, mdd_pobj, name, is_dir, handle);
+               if (rc)
+                       GOTO(cleanup, rc);
+       }
+
+       if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_MUL_REF) ||
+           OBD_FAIL_CHECK(OBD_FAIL_LFSCK_NO_NAMEENTRY))
+               GOTO(cleanup, rc = 0);
+
+       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),
+                                               mdd_object_type(mdd_cobj),
+                                               name, handle);
+                       GOTO(cleanup, rc);
+               }
+
+               if (is_dir)
+                       /* unlink dot */
+                       mdo_ref_del(env, mdd_cobj, handle);
+
+               /* fetch updated nlink */
+               rc = mdd_la_get(env, mdd_cobj, cattr);
+               if (rc)
+                       GOTO(cleanup, 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 = mdd_update_time(env, mdd_pobj, pattr, la, handle);
+       if (rc)
+               GOTO(cleanup, rc);
+
+       /* Enough for only unlink the entry */
+       if (unlikely(mdd_cobj == NULL))
+               GOTO(stop, rc);
 
        if (cattr->la_nlink > 0 || mdd_cobj->mod_count > 0) {
-                /* update ctime of an unlinked file only if it is still
-                 * opened or a link still exists */
-                la->la_valid = LA_CTIME;
-                rc = mdd_attr_check_set_internal(env, mdd_cobj, la, handle, 0);
-                if (rc)
-                        GOTO(cleanup, rc);
-        }
+               /* update ctime of an unlinked file only if it is still
+                * opened or a link still exists */
+               la->la_valid = LA_CTIME;
+               rc = mdd_update_time(env, mdd_cobj, cattr, la, handle);
+               if (rc)
+                       GOTO(cleanup, rc);
+       }
 
        /* XXX: this transfer to ma will be removed with LOD/OSP */
        ma->ma_attr = *cattr;
        ma->ma_valid |= MA_INODE;
-        rc = mdd_finish_unlink(env, mdd_cobj, ma, handle);
+       rc = mdd_finish_unlink(env, mdd_cobj, ma, mdd_pobj, lname, handle);
 
        /* fetch updated nlink */
        if (rc == 0)
-               rc = mdd_la_get(env, mdd_cobj, cattr,
-                               mdd_object_capa(env, mdd_cobj));
-
-        if (!is_dir)
-               /* old files may not have link ea; ignore errors */
-               mdd_links_del(env, mdd_cobj, mdo2fid(mdd_pobj), lname, handle);
+               rc = mdd_la_get(env, mdd_cobj, cattr);
 
        /* if object is removed then we can't get its attrs, use last get */
        if (cattr->la_nlink == 0) {
                ma->ma_attr = *cattr;
                ma->ma_valid |= MA_INODE;
        }
-        EXIT;
+       EXIT;
 cleanup:
-        mdd_write_unlock(env, mdd_cobj);
-        mdd_pdo_write_unlock(env, mdd_pobj, dlh);
-        if (rc == 0) {
-                int cl_flags;
+       if (likely(mdd_cobj != NULL))
+               mdd_write_unlock(env, mdd_cobj);
 
-               cl_flags = (cattr->la_nlink == 0) ? CLF_UNLINK_LAST : 0;
-                if ((ma->ma_valid & MA_HSM) &&
-                    (ma->ma_hsm.mh_flags & HS_EXISTS))
-                        cl_flags |= CLF_UNLINK_HSM_EXISTS;
+       if (rc == 0) {
+               int cl_flags = 0;
+
+               if (cattr->la_nlink == 0) {
+                       cl_flags |= CLF_UNLINK_LAST;
+                       /* search for an existing archive */
+                       if (mdd_hsm_archive_exists(env, mdd_cobj, ma))
+                               cl_flags |= CLF_UNLINK_HSM_EXISTS;
+               }
 
                rc = mdd_changelog_ns_store(env, mdd,
                        is_dir ? CL_RMDIR : CL_UNLINK, cl_flags,
-                       mdd_cobj, mdd_pobj, lname, handle);
-        }
+                       mdd_cobj, mdo2fid(mdd_pobj), NULL, NULL, lname, NULL,
+                       handle);
+       }
 
 stop:
-        mdd_trans_stop(env, mdd, rc, handle);
+       mdd_trans_stop(env, mdd, rc, handle);
 
-        return rc;
+       return rc;
 }
 
 /*
@@ -1262,33 +1725,28 @@ static int mdd_cd_sanity_check(const struct lu_env *env,
                 RETURN(-ENOENT);
 
         RETURN(0);
-
 }
 
 static int mdd_create_data(const struct lu_env *env, struct md_object *pobj,
                            struct md_object *cobj, const struct md_op_spec *spec,
                            struct md_attr *ma)
 {
-        struct mdd_device *mdd = mdo2mdd(cobj);
-        struct mdd_object *mdd_pobj = md2mdd_obj(pobj);
-        struct mdd_object *son = md2mdd_obj(cobj);
-        struct thandle    *handle;
+       struct mdd_device *mdd = mdo2mdd(cobj);
+       struct mdd_object *mdd_pobj = md2mdd_obj(pobj);
+       struct mdd_object *son = md2mdd_obj(cobj);
+       struct thandle    *handle;
        const struct lu_buf *buf;
-       struct lu_attr    *attr = &mdd_env_info(env)->mti_cattr;
-        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);
+       struct lu_attr    *attr = MDD_ENV_VAR(env, cattr);
+       struct dt_allocation_hint *hint = &mdd_env_info(env)->mti_hint;
+       int                rc;
+       ENTRY;
 
-        rc = mdd_cd_sanity_check(env, son);
-        if (rc)
-                RETURN(rc);
+       rc = mdd_cd_sanity_check(env, son);
+       if (rc)
+               RETURN(rc);
 
-        if (!md_should_create(spec->sp_cr_flags))
-                RETURN(0);
+       if (!md_should_create(spec->sp_cr_flags))
+               RETURN(0);
 
        /*
         * there are following use cases for this function:
@@ -1296,12 +1754,12 @@ static int mdd_create_data(const struct lu_env *env, struct md_object *pobj,
         *    striping can be specified or not
         * 2) CMD?
         */
-       rc = mdd_la_get(env, son, attr, mdd_object_capa(env, son));
+       rc = mdd_la_get(env, son, attr);
        if (rc)
                RETURN(rc);
 
        /* calling ->ah_make_hint() is used to transfer information from parent */
-       mdd_object_make_hint(env, mdd_pobj, son, attr);
+       mdd_object_make_hint(env, mdd_pobj, son, attr, spec, hint);
 
         handle = mdd_trans_create(env, mdd);
         if (IS_ERR(handle))
@@ -1311,25 +1769,15 @@ static int mdd_create_data(const struct lu_env *env, struct md_object *pobj,
          * XXX: Setting the lov ea is not locked but setting the attr is locked?
          * Should this be fixed?
          */
-       CDEBUG(D_OTHER, "ea %p/%u, cr_flags %Lo, no_create %u\n",
+       CDEBUG(D_OTHER, "ea %p/%u, cr_flags "LPO64", no_create %u\n",
               spec->u.sp_ea.eadata, spec->u.sp_ea.eadatalen,
               spec->sp_cr_flags, spec->no_create);
 
-       if (spec->no_create) {
-               /* replay case */
+       if (spec->no_create || (spec->sp_cr_flags & MDS_OPEN_HAS_EA)) {
                buf = mdd_buf_get_const(env, spec->u.sp_ea.eadata,
                                        spec->u.sp_ea.eadatalen);
-       } else  if (!(spec->sp_cr_flags & MDS_OPEN_HAS_OBJS)) {
-               if (spec->sp_cr_flags & MDS_OPEN_HAS_EA) {
-                       /* lfs setstripe */
-                       buf = mdd_buf_get_const(env, spec->u.sp_ea.eadata,
-                                               spec->u.sp_ea.eadatalen);
-               } else {
-                       buf = &LU_BUF_NULL;
-               }
        } else {
-               /* MDS_OPEN_HAS_OBJS is not used anymore ? */
-               LBUG();
+               buf = &LU_BUF_NULL;
        }
 
        rc = dt_declare_xattr_set(env, mdd_object_child(son), buf,
@@ -1337,104 +1785,36 @@ 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, 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));
+                         0, handle);
+
+       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:
        RETURN(rc);
 }
 
-/* Get fid from name and parent */
-static int
-__mdd_lookup(const struct lu_env *env, struct md_object *pobj,
-             const struct lu_name *lname, struct lu_fid* fid, int mask)
-{
-        const char          *name = lname->ln_name;
-        const struct dt_key *key = (const struct dt_key *)name;
-        struct mdd_object   *mdd_obj = md2mdd_obj(pobj);
-        struct mdd_device   *m = mdo2mdd(pobj);
-        struct dt_object    *dir = mdd_object_child(mdd_obj);
-        int rc;
-        ENTRY;
-
-        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);
-        }
-
-        /* The common filename length check. */
-        if (unlikely(lname->ln_namelen > m->mdd_dt_conf.ddp_max_name_len))
-                RETURN(-ENAMETOOLONG);
-
-        rc = mdd_permission_internal_locked(env, mdd_obj, NULL, mask,
-                                            MOR_TGT_PARENT);
-        if (rc)
-                RETURN(rc);
-
-        if (likely(S_ISDIR(mdd_object_type(mdd_obj)) &&
-                   dt_try_as_dir(env, dir))) {
-
-                rc = dir->do_index_ops->dio_lookup(env, dir,
-                                                 (struct dt_rec *)fid, key,
-                                                 mdd_object_capa(env, mdd_obj));
-                if (rc > 0)
-                        rc = 0;
-                else if (rc == 0)
-                        rc = -ENOENT;
-        } else
-                rc = -ENOTDIR;
-
-        RETURN(rc);
-}
-
-int mdd_declare_object_initialize(const struct lu_env *env,
-                                 struct mdd_object *child,
-                                 struct lu_attr *attr,
-                                 struct thandle *handle)
-{
-        int rc;
-
-       rc = mdo_declare_attr_set(env, child, attr, handle);
-       if (rc == 0 && S_ISDIR(attr->la_mode)) {
-               rc = mdo_declare_index_insert(env, child, mdo2fid(child),
-                                             dot, handle);
-                if (rc == 0)
-                        rc = mdo_declare_ref_add(env, child, handle);
-        }
-
-        if (rc == 0)
-                mdd_declare_links_add(env, child, handle);
-
-        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_declare_object_initialize(const struct lu_env *env,
+                                        struct mdd_object *parent,
+                                        struct mdd_object *child,
+                                        struct lu_attr *attr,
+                                        struct thandle *handle)
 {
-        int rc;
-        ENTRY;
-
-        /*
-         * Update attributes for child.
-         *
-         * FIXME:
-         *  (1) the valid bits should be converted between Lustre and Linux;
-         *  (2) maybe, the child attributes should be set in OSD when creation.
-         */
+       int rc;
+       ENTRY;
 
        /*
         * inode mode has been set in creation time, and it's based on umask,
@@ -1442,78 +1822,111 @@ int mdd_object_initialize(const struct lu_env *env, const struct lu_fid *pfid,
         * 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);
-       attr->la_valid &= ~LA_MODE;
-       rc = mdd_attr_set_internal(env, child, attr, handle, 0);
-       /* arguments are supposed to stay the same */
-       attr->la_valid |= LA_MODE;
+       LASSERT(attr->la_valid & (LA_MODE | LA_TYPE));
+       attr->la_valid &= ~(LA_MODE | LA_TYPE);
+       rc = mdo_declare_attr_set(env, child, attr, handle);
+       attr->la_valid |= LA_MODE | LA_TYPE;
+       if (rc != 0 || !S_ISDIR(attr->la_mode))
+               RETURN(rc);
+
+       rc = mdo_declare_index_insert(env, child, mdo2fid(child), S_IFDIR,
+                                     dot, handle);
        if (rc != 0)
                RETURN(rc);
 
+       rc = mdo_declare_ref_add(env, child, handle);
+       if (rc != 0)
+               RETURN(rc);
+
+       rc = mdo_declare_index_insert(env, child, mdo2fid(parent), S_IFDIR,
+                                     dotdot, handle);
+
+       RETURN(rc);
+}
+
+static int mdd_object_initialize(const struct lu_env *env,
+                                const struct lu_fid *pfid,
+                                struct mdd_object *child,
+                                struct lu_attr *attr, struct thandle *handle,
+                                const struct md_op_spec *spec)
+{
+       int rc = 0;
+       ENTRY;
+
        if (S_ISDIR(attr->la_mode)) {
                 /* Add "." and ".." for newly created dir */
                 mdo_ref_add(env, child, handle);
                 rc = __mdd_index_insert_only(env, child, mdo2fid(child),
-                                             dot, handle, BYPASS_CAPA);
-                if (rc == 0)
-                        rc = __mdd_index_insert_only(env, child, pfid,
-                                                     dotdot, handle,
-                                                     BYPASS_CAPA);
-                if (rc != 0)
-                        mdo_ref_del(env, child, handle);
-        }
-        if (rc == 0)
-                mdd_links_add(env, child, pfid, lname, handle, 1);
+                                            S_IFDIR, dot, handle);
+               if (rc == 0)
+                       rc = __mdd_index_insert_only(env, child, pfid, S_IFDIR,
+                                                    dotdot, handle);
+               if (rc != 0)
+                       mdo_ref_del(env, child, handle);
+       }
 
-        RETURN(rc);
+       RETURN(rc);
 }
 
-/* has not lock on pobj yet */
+/**
+ * This function checks whether it can create a file/dir under the
+ * directory(@pobj). The directory(@pobj) is not being locked by
+ * mdd lock.
+ *
+ * \param[in] env      execution environment
+ * \param[in] pobj     the directory to create files
+ * \param[in] pattr    the attributes of the directory
+ * \param[in] lname    the name of the created file/dir
+ * \param[in] cattr    the attributes of the file/dir
+ * \param[in] spec     create specification
+ *
+ * \retval             = 0 it is allowed to create file/dir under
+ *                      the directory
+ * \retval              negative error not allowed to create file/dir
+ *                      under the directory
+ */
 static int mdd_create_sanity_check(const struct lu_env *env,
                                    struct md_object *pobj,
-                                  struct lu_attr *pattr,
+                                  const struct lu_attr *pattr,
                                    const struct lu_name *lname,
                                   struct lu_attr *cattr,
                                    struct md_op_spec *spec)
 {
-        struct mdd_thread_info *info = mdd_env_info(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;
+       struct mdd_thread_info *info = mdd_env_info(env);
+       struct lu_fid     *fid       = &info->mti_fid;
+       struct mdd_object *obj       = md2mdd_obj(pobj);
+       struct mdd_device *m         = mdo2mdd(pobj);
+       bool            check_perm = true;
+       int rc;
+       ENTRY;
 
         /* EEXIST check */
         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
                  * _index_insert.
                  */
-                rc = __mdd_lookup_locked(env, pobj, lname, fid,
-                                         MAY_WRITE | MAY_EXEC);
-                if (rc != -ENOENT)
-                        RETURN(rc ? : -EEXIST);
-        } else {
-                /*
-                 * Check WRITE permission for the parent.
-                 * EXEC permission have been checked
-                 * when lookup before create already.
-                 */
-               rc = mdd_permission_internal_locked(env, obj, pattr, MAY_WRITE,
-                                                   MOR_TGT_PARENT);
-                if (rc)
-                        RETURN(rc);
-        }
+               rc = __mdd_lookup(env, pobj, pattr, lname, fid,
+                                 MAY_WRITE | MAY_EXEC);
+               if (rc != -ENOENT)
+                       RETURN(rc ? : -EEXIST);
+
+               /* Permission is already being checked in mdd_lookup */
+               check_perm = false;
+       }
+
+       rc = mdd_may_create(env, obj, pattr, NULL, check_perm);
+       if (rc != 0)
+               RETURN(rc);
 
         /* sgid check */
        if (pattr->la_mode & S_ISGID) {
@@ -1524,6 +1937,10 @@ static int mdd_create_sanity_check(const struct lu_env *env,
                }
        }
 
+       rc = mdd_name_check(m, lname);
+       if (rc < 0)
+               RETURN(rc);
+
        switch (cattr->la_mode & S_IFMT) {
         case S_IFLNK: {
                 unsigned int symlen = strlen(spec->u.sp_symname) + 1;
@@ -1548,34 +1965,34 @@ static int mdd_create_sanity_check(const struct lu_env *env,
         RETURN(rc);
 }
 
-static int mdd_declare_create(const struct lu_env *env, struct mdd_device *mdd,
-                             struct mdd_object *p, struct mdd_object *c,
-                             const struct lu_name *name,
-                             struct lu_attr *attr,
-                             int got_def_acl,
-                             struct thandle *handle,
-                             const struct md_op_spec *spec)
+static int mdd_declare_object_create(const struct lu_env *env,
+                                    struct mdd_device *mdd,
+                                    struct mdd_object *p, struct mdd_object *c,
+                                    struct lu_attr *attr,
+                                    struct thandle *handle,
+                                    const struct md_op_spec *spec,
+                                    struct lu_buf *def_acl_buf,
+                                    struct lu_buf *acl_buf,
+                                    struct dt_allocation_hint *hint)
 {
        int rc;
 
-       rc = mdd_declare_object_create_internal(env, p, c, attr, handle, spec);
+       rc = mdd_declare_object_create_internal(env, p, c, attr, handle, spec,
+                                               hint);
         if (rc)
                 GOTO(out, rc);
 
 #ifdef CONFIG_FS_POSIX_ACL
-       if (got_def_acl > 0) {
-               struct lu_buf *acl_buf;
-
-               acl_buf = mdd_buf_get(env, NULL, got_def_acl);
+       if (def_acl_buf->lb_len > 0 && S_ISDIR(attr->la_mode)) {
                /* if dir, then can inherit default ACl */
-               if (S_ISDIR(attr->la_mode)) {
-                       rc = mdo_declare_xattr_set(env, c, acl_buf,
-                                                  XATTR_NAME_ACL_DEFAULT,
-                                                  0, handle);
-                       if (rc)
-                               GOTO(out, rc);
-               }
+               rc = mdo_declare_xattr_set(env, c, def_acl_buf,
+                                          XATTR_NAME_ACL_DEFAULT,
+                                          0, handle);
+               if (rc)
+                       GOTO(out, rc);
+       }
 
+       if (acl_buf->lb_len > 0) {
                rc = mdo_declare_attr_set(env, c, attr, handle);
                if (rc)
                        GOTO(out, rc);
@@ -1583,62 +2000,253 @@ static int mdd_declare_create(const struct lu_env *env, struct mdd_device *mdd,
                rc = mdo_declare_xattr_set(env, c, acl_buf,
                                           XATTR_NAME_ACL_ACCESS, 0, handle);
                if (rc)
-                       GOTO(out, rc);
-       }
-#endif
-
-       if (S_ISDIR(attr->la_mode)) {
-               rc = mdo_declare_ref_add(env, p, handle);
-               if (rc)
-                       GOTO(out, rc);
-        }
-
-       rc = mdd_declare_object_initialize(env, c, attr, handle);
-       if (rc)
-               GOTO(out, rc);
-
-       if (spec->sp_cr_flags & MDS_OPEN_VOLATILE)
-               rc = orph_declare_index_insert(env, c, attr->la_mode, handle);
-       else
-               rc = mdo_declare_index_insert(env, p, mdo2fid(c),
-                                             name->ln_name, handle);
+                       GOTO(out, rc);
+       }
+#endif
+       rc = mdd_declare_object_initialize(env, p, c, attr, handle);
        if (rc)
                GOTO(out, rc);
 
        /* replay case, create LOV EA from client data */
-       if (spec->no_create || (spec->sp_cr_flags & MDS_OPEN_HAS_EA)) {
+       if (spec->no_create ||
+           (spec->sp_cr_flags & MDS_OPEN_HAS_EA && S_ISREG(attr->la_mode))) {
                const struct lu_buf *buf;
 
                buf = mdd_buf_get_const(env, spec->u.sp_ea.eadata,
                                        spec->u.sp_ea.eadatalen);
-               rc = mdo_declare_xattr_set(env, c, buf, XATTR_NAME_LOV,
-                                          0, handle);
+               rc = mdo_declare_xattr_set(env, c, buf, XATTR_NAME_LOV, 0,
+                                          handle);
                if (rc)
                        GOTO(out, rc);
        }
 
        if (S_ISLNK(attr->la_mode)) {
+               const char *target_name = spec->u.sp_symname;
+               int sym_len = strlen(target_name);
+               const struct lu_buf *buf;
+
+               buf = mdd_buf_get_const(env, target_name, sym_len);
                 rc = dt_declare_record_write(env, mdd_object_child(c),
-                                             strlen(spec->u.sp_symname), 0,
-                                             handle);
+                                            buf, 0, handle);
                 if (rc)
                         GOTO(out, rc);
         }
+out:
+       return rc;
+}
+
+static int mdd_declare_create(const struct lu_env *env, struct mdd_device *mdd,
+                             struct mdd_object *p, struct mdd_object *c,
+                             const struct lu_name *name,
+                             struct lu_attr *attr,
+                             struct thandle *handle,
+                             const struct md_op_spec *spec,
+                             struct linkea_data *ldata,
+                             struct lu_buf *def_acl_buf,
+                             struct lu_buf *acl_buf,
+                             struct dt_allocation_hint *hint)
+{
+       int rc;
+
+       rc = mdd_declare_object_create(env, mdd, p, c, attr, handle, spec,
+                                      def_acl_buf, acl_buf, hint);
+       if (rc)
+               GOTO(out, rc);
 
-       if (!(spec->sp_cr_flags & MDS_OPEN_VOLATILE)) {
-               rc = mdo_declare_attr_set(env, p, attr, handle);
+       if (S_ISDIR(attr->la_mode)) {
+               rc = mdo_declare_ref_add(env, p, handle);
                if (rc)
-                       return rc;
+                       GOTO(out, rc);
        }
 
-        rc = mdd_declare_changelog_store(env, mdd, name, handle);
-        if (rc)
-                return rc;
+       if (unlikely(spec->sp_cr_flags & MDS_OPEN_VOLATILE)) {
+               rc = orph_declare_index_insert(env, c, attr->la_mode, handle);
+               if (rc)
+                       GOTO(out, rc);
+       } else {
+               struct lu_attr  *la = &mdd_env_info(env)->mti_la_for_fix;
+
+               rc = mdo_declare_index_insert(env, p, mdo2fid(c), attr->la_mode,
+                                             name->ln_name, handle);
+               if (rc != 0)
+                       return rc;
+
+               rc = mdd_declare_links_add(env, c, handle, ldata, MLAO_IGNORE);
+               if (rc)
+                       return rc;
+
+               *la = *attr;
+               la->la_valid = LA_CTIME | LA_MTIME;
+               rc = mdo_declare_attr_set(env, p, la, handle);
+               if (rc)
+                       return rc;
 
+               rc = mdd_declare_changelog_store(env, mdd, name, NULL, handle);
+               if (rc)
+                       return rc;
+       }
 out:
-        return rc;
+       return rc;
+}
+
+static int mdd_acl_init(const struct lu_env *env, struct mdd_object *pobj,
+                       struct lu_attr *la, struct lu_buf *def_acl_buf,
+                       struct lu_buf *acl_buf)
+{
+       int     rc;
+       ENTRY;
+
+       if (S_ISLNK(la->la_mode)) {
+               acl_buf->lb_len = 0;
+               def_acl_buf->lb_len = 0;
+               RETURN(0);
+       }
+
+       mdd_read_lock(env, pobj, MOR_TGT_PARENT);
+       rc = mdo_xattr_get(env, pobj, def_acl_buf,
+                          XATTR_NAME_ACL_DEFAULT);
+       mdd_read_unlock(env, pobj);
+       if (rc > 0) {
+               /* If there are default ACL, fix mode/ACL by default ACL */
+               def_acl_buf->lb_len = rc;
+               LASSERT(def_acl_buf->lb_len <= acl_buf->lb_len);
+               memcpy(acl_buf->lb_buf, def_acl_buf->lb_buf, rc);
+               acl_buf->lb_len = rc;
+               rc = __mdd_fix_mode_acl(env, acl_buf, &la->la_mode);
+               if (rc < 0)
+                       RETURN(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;
+               acl_buf->lb_len = 0;
+               def_acl_buf->lb_len = 0;
+       }
+
+       RETURN(rc);
 }
 
+/**
+ * Create a metadata object and initialize it, set acl, xattr.
+ **/
+static int mdd_object_create(const struct lu_env *env, struct mdd_object *pobj,
+                            struct mdd_object *son, struct lu_attr *attr,
+                            struct md_op_spec *spec, struct lu_buf *acl_buf,
+                            struct lu_buf *def_acl_buf,
+                            struct dt_allocation_hint *hint,
+                            struct thandle *handle)
+{
+       int                     rc;
+
+       mdd_write_lock(env, son, MOR_TGT_CHILD);
+       rc = mdd_object_create_internal(env, NULL, son, attr, handle, spec,
+                                       hint);
+       if (rc)
+               GOTO(unlock, rc);
+
+       /* Note: In DNE phase I, for striped dir, though sub-stripes will be
+        * created in declare phase, they also needs to be added to master
+        * object as sub-directory entry. So it has to initialize the master
+        * object, then set dir striped EA.(in mdo_xattr_set) */
+       rc = mdd_object_initialize(env, mdo2fid(pobj), son, attr, handle,
+                                  spec);
+       if (rc != 0)
+               GOTO(err_destroy, rc);
+
+       /*
+        * in case of replay we just set LOVEA provided by the client
+        * XXX: I think it would be interesting to try "old" way where
+        *      MDT calls this xattr_set(LOV) in a different transaction.
+        *      probably this way we code can be made better.
+        */
+
+       /* During creation, there are only a few cases we need do xattr_set to
+        * create stripes.
+        * 1. regular file: see comments above.
+        * 2. dir: inherit default striping or pool settings from parent.
+        * 3. create striped directory with provided stripeEA.
+        * 4. create striped directory because inherit default layout from the
+        * parent.
+        */
+       if (spec->no_create ||
+           (S_ISREG(attr->la_mode) && spec->sp_cr_flags & MDS_OPEN_HAS_EA) ||
+           S_ISDIR(attr->la_mode)) {
+               const struct lu_buf *buf;
+
+               buf = mdd_buf_get_const(env, spec->u.sp_ea.eadata,
+                                       spec->u.sp_ea.eadatalen);
+               rc = mdo_xattr_set(env, son, buf,
+                                  S_ISDIR(attr->la_mode) ? XATTR_NAME_LMV :
+                                                           XATTR_NAME_LOV, 0,
+                                  handle);
+               if (rc != 0)
+                       GOTO(err_destroy, rc);
+       }
+
+#ifdef CONFIG_FS_POSIX_ACL
+       if (def_acl_buf != NULL && def_acl_buf->lb_len > 0 &&
+           S_ISDIR(attr->la_mode)) {
+               /* set default acl */
+               rc = mdo_xattr_set(env, son, def_acl_buf,
+                                  XATTR_NAME_ACL_DEFAULT, 0,
+                                  handle);
+               if (rc)
+                       GOTO(err_destroy, rc);
+       }
+       /* set its own acl */
+       if (acl_buf != NULL && acl_buf->lb_len > 0) {
+               rc = mdo_xattr_set(env, son, acl_buf,
+                                  XATTR_NAME_ACL_ACCESS,
+                                  0, handle);
+               if (rc)
+                       GOTO(err_destroy, rc);
+       }
+#endif
+
+       if (S_ISLNK(attr->la_mode)) {
+               struct lu_ucred  *uc = lu_ucred_assert(env);
+               struct dt_object *dt = mdd_object_child(son);
+               const char *target_name = spec->u.sp_symname;
+               int sym_len = strlen(target_name);
+               const struct lu_buf *buf;
+               loff_t pos = 0;
+
+               buf = mdd_buf_get_const(env, target_name, sym_len);
+               rc = dt->do_body_ops->dbo_write(env, dt, buf, &pos, handle,
+                                               uc->uc_cap &
+                                               CFS_CAP_SYS_RESOURCE_MASK);
+
+               if (rc == sym_len)
+                       rc = 0;
+               else
+                       GOTO(err_initlized, rc = -EFAULT);
+       }
+
+err_initlized:
+       if (unlikely(rc != 0)) {
+               int rc2;
+               if (S_ISDIR(attr->la_mode)) {
+                       /* Drop the reference, no need to delete "."/"..",
+                        * because the object to be destroied directly. */
+                       rc2 = mdo_ref_del(env, son, handle);
+                       if (rc2 != 0)
+                               GOTO(unlock, rc);
+               }
+               rc2 = mdo_ref_del(env, son, handle);
+               if (rc2 != 0)
+                       GOTO(unlock, rc);
+err_destroy:
+               mdo_destroy(env, son, handle);
+       }
+unlock:
+       mdd_write_unlock(env, son);
+       RETURN(rc);
+}
 
 /*
  * Create object and insert it into namespace.
@@ -1655,10 +2263,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 dynlock_handle   *dlh;
+       struct lu_buf           acl_buf;
+       struct lu_buf           def_acl_buf;
+       struct linkea_data      *ldata = &info->mti_link_data;
        const char              *name = lname->ln_name;
-       int                      rc, created = 0, initialized = 0, inserted = 0;
-       int                      got_def_acl = 0;
+       struct dt_allocation_hint *hint = &mdd_env_info(env)->mti_hint;
+       int                      rc;
+       int                      rc2;
        ENTRY;
 
         /*
@@ -1697,41 +2308,48 @@ static int mdd_create(const struct lu_env *env, struct md_object *pobj,
          *     2. insert            (__mdd_index_insert(), lookup again)
          */
 
-       rc = mdd_la_get(env, mdd_pobj, pattr, BYPASS_CAPA);
+       rc = mdd_la_get(env, mdd_pobj, pattr);
        if (rc != 0)
                RETURN(rc);
 
-        /* Sanity checks before big job. */
+       /* Sanity checks before big job. */
        rc = mdd_create_sanity_check(env, pobj, pattr, lname, attr, spec);
-        if (rc)
-                RETURN(rc);
+       if (rc)
+               RETURN(rc);
 
         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;
+       handle = mdd_trans_create(env, mdd);
+       if (IS_ERR(handle))
+               GOTO(out_free, rc = PTR_ERR(handle));
 
-               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);
+       def_acl_buf.lb_buf = info->mti_key;
+       def_acl_buf.lb_len = sizeof(info->mti_key);
+       rc = mdd_acl_init(env, mdd_pobj, attr, &def_acl_buf, &acl_buf);
+       if (rc < 0)
+               GOTO(out_stop, rc);
 
-       mdd_object_make_hint(env, mdd_pobj, son, attr);
+       mdd_object_make_hint(env, mdd_pobj, son, attr, spec, hint);
 
-        handle = mdd_trans_create(env, mdd);
-        if (IS_ERR(handle))
-                GOTO(out_free, rc = PTR_ERR(handle));
+       memset(ldata, 0, sizeof(*ldata));
+       if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_BAD_PARENT)) {
+               struct lu_fid tfid = *mdd_object_fid(mdd_pobj);
+
+               tfid.f_oid--;
+               rc = mdd_linkea_prepare(env, son, NULL, NULL,
+                                       &tfid, lname, 1, 0, ldata);
+       } else {
+               rc = 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);
+                               handle, spec, ldata, &def_acl_buf, &acl_buf,
+                               hint);
         if (rc)
                 GOTO(out_stop, rc);
 
@@ -1739,159 +2357,96 @@ static int mdd_create(const struct lu_env *env, struct md_object *pobj,
         if (rc)
                 GOTO(out_stop, rc);
 
-       dlh = mdd_pdo_write_lock(env, mdd_pobj, name, MOR_TGT_PARENT);
-       if (dlh == NULL)
-               GOTO(out_trans, rc = -ENOMEM);
-
-       mdd_write_lock(env, son, MOR_TGT_CHILD);
-       rc = mdd_object_create_internal(env, NULL, son, attr, handle, spec);
-       if (rc) {
-               mdd_write_unlock(env, son);
-               GOTO(cleanup, rc);
-       }
-
-       created = 1;
-
-#ifdef CONFIG_FS_POSIX_ACL
-       if (got_def_acl) {
-               struct lu_buf *acl_buf;
-
-               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);
-               }
-       }
-#endif
-
-       rc = mdd_object_initialize(env, mdo2fid(mdd_pobj), lname,
-                                  son, attr, handle, spec);
-
-       /*
-        * in case of replay we just set LOVEA provided by the client
-        * XXX: I think it would be interesting to try "old" way where
-        *      MDT calls this xattr_set(LOV) in a different transaction.
-        *      probably this way we code can be made better.
-        */
-       if (rc == 0 && (spec->no_create ||
-                       (spec->sp_cr_flags & MDS_OPEN_HAS_EA))) {
-               const struct lu_buf *buf;
-
-               buf = mdd_buf_get_const(env, spec->u.sp_ea.eadata,
-                               spec->u.sp_ea.eadatalen);
-               rc = mdo_xattr_set(env, son, buf, XATTR_NAME_LOV, 0, handle,
-                               BYPASS_CAPA);
-       }
-
-       if (rc == 0 && spec->sp_cr_flags & MDS_OPEN_VOLATILE)
-               rc = __mdd_orphan_add(env, son, handle);
-
-       mdd_write_unlock(env, son);
-
+       rc = mdd_object_create(env, mdd_pobj, son, attr, spec, &acl_buf,
+                              &def_acl_buf, hint, handle);
        if (rc != 0)
-               /*
-                * Object has no links, so it will be destroyed when last
-                * reference is released. (XXX not now.)
-                */
-               GOTO(cleanup, rc);
-
-       initialized = 1;
+               GOTO(out_stop, rc);
 
-       if (!(spec->sp_cr_flags & MDS_OPEN_VOLATILE))
+       if (unlikely(spec->sp_cr_flags & MDS_OPEN_VOLATILE)) {
+               mdd_write_lock(env, son, MOR_TGT_CHILD);
+               rc = __mdd_orphan_add(env, son, handle);
+               GOTO(out_volatile, rc);
+       } else {
                rc = __mdd_index_insert(env, mdd_pobj, mdo2fid(son),
-                                       name, S_ISDIR(attr->la_mode), handle,
-                                       mdd_object_capa(env, mdd_pobj));
-
-       if (rc != 0)
-               GOTO(cleanup, rc);
-
-       inserted = 1;
-
-        if (S_ISLNK(attr->la_mode)) {
-               struct lu_ucred  *uc = lu_ucred_assert(env);
-                struct dt_object *dt = mdd_object_child(son);
-                const char *target_name = spec->u.sp_symname;
-                int sym_len = strlen(target_name);
-                const struct lu_buf *buf;
-                loff_t pos = 0;
-
-                buf = mdd_buf_get_const(env, target_name, sym_len);
-               rc = dt->do_body_ops->dbo_write(env, dt, buf, &pos, handle,
-                                               mdd_object_capa(env, son),
-                                               uc->uc_cap &
-                                               CFS_CAP_SYS_RESOURCE_MASK);
-
-                if (rc == sym_len)
-                        rc = 0;
-                else
-                        GOTO(cleanup, rc = -EFAULT);
-        }
+                                       attr->la_mode, name, handle);
+               if (rc != 0)
+                       GOTO(err_created, rc);
 
-       /* volatile file creation does not update parent directory times */
-       if (spec->sp_cr_flags & MDS_OPEN_VOLATILE)
-               GOTO(cleanup, rc = 0);
+               mdd_links_add(env, son, mdo2fid(mdd_pobj), lname, handle,
+                             ldata, 1);
 
-       /* update parent directory mtime/ctime */
-       *la = *attr;
-       la->la_valid = LA_CTIME | LA_MTIME;
-       rc = mdd_attr_check_set_internal(env, mdd_pobj, la, handle, 0);
-       if (rc)
-               GOTO(cleanup, rc);
+               /* update parent directory mtime/ctime */
+               *la = *attr;
+               la->la_valid = LA_CTIME | LA_MTIME;
+               rc = mdd_update_time(env, mdd_pobj, pattr, la, handle);
+               if (rc)
+                       GOTO(err_insert, rc);
+       }
 
-        EXIT;
-cleanup:
-       if (rc != 0 && created != 0) {
+       EXIT;
+err_insert:
+       if (rc != 0) {
                int rc2;
 
-               if (inserted != 0) {
-                       if (spec->sp_cr_flags & MDS_OPEN_VOLATILE)
-                               rc2 = __mdd_orphan_del(env, son, handle);
-                       else
-                               rc2 = __mdd_index_delete(env, mdd_pobj, name,
-                                                        S_ISDIR(attr->la_mode),
-                                                        handle, BYPASS_CAPA);
-                       if (rc2 != 0)
-                               goto out_stop;
-               }
+               if (spec->sp_cr_flags & MDS_OPEN_VOLATILE)
+                       rc2 = __mdd_orphan_del(env, son, handle);
+               else
+                       rc2 = __mdd_index_delete(env, mdd_pobj, name,
+                                                S_ISDIR(attr->la_mode),
+                                                handle);
+               if (rc2 != 0)
+                       goto out_stop;
 
+err_created:
                mdd_write_lock(env, son, MOR_TGT_CHILD);
-               if (initialized != 0 && S_ISDIR(attr->la_mode)) {
+               if (S_ISDIR(attr->la_mode)) {
                        /* Drop the reference, no need to delete "."/"..",
-                        * because the object to be destroied directly. */
+                        * because the object is to be destroyed directly. */
                        rc2 = mdo_ref_del(env, son, handle);
                        if (rc2 != 0) {
                                mdd_write_unlock(env, son);
                                goto out_stop;
                        }
                }
-
+out_volatile:
+               /* For volatile files drop one link immediately, since there is
+                * no filename in the namespace, and save any error returned. */
                rc2 = mdo_ref_del(env, son, handle);
                if (rc2 != 0) {
                        mdd_write_unlock(env, son);
+                       if (unlikely(rc == 0))
+                               rc = rc2;
                        goto out_stop;
                }
 
-               mdo_destroy(env, son, handle);
+               /* Don't destroy the volatile object on success */
+               if (likely(rc != 0))
+                       mdo_destroy(env, son, handle);
                mdd_write_unlock(env, son);
-        }
+       }
 
-        mdd_pdo_write_unlock(env, mdd_pobj, dlh);
-out_trans:
-        if (rc == 0)
+       if (rc == 0 && fid_is_namespace_visible(mdo2fid(son)) &&
+           likely((spec->sp_cr_flags & MDS_OPEN_VOLATILE) == 0))
                rc = mdd_changelog_ns_store(env, mdd,
-                       S_ISDIR(attr->la_mode) ? CL_MKDIR :
-                       S_ISREG(attr->la_mode) ? CL_CREATE :
-                       S_ISLNK(attr->la_mode) ? CL_SOFTLINK : CL_MKNOD,
-                       0, son, mdd_pobj, lname, handle);
+                               S_ISDIR(attr->la_mode) ? CL_MKDIR :
+                               S_ISREG(attr->la_mode) ? CL_CREATE :
+                               S_ISLNK(attr->la_mode) ? CL_SOFTLINK : CL_MKNOD,
+                               0, son, mdo2fid(mdd_pobj), NULL, NULL, lname,
+                               NULL, handle);
 out_stop:
-        mdd_trans_stop(env, mdd, rc, handle);
+       rc2 = mdd_trans_stop(env, mdd, rc, handle);
+       if (rc == 0)
+               rc = rc2;
 out_free:
-        /* The child object shouldn't be cached anymore */
-        if (rc)
+       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,
-                            &child->mo_lu.lo_header->loh_flags);
-        return rc;
+                       &child->mo_lu.lo_header->loh_flags);
+       return rc;
 }
 
 /*
@@ -1907,6 +2462,7 @@ enum rename_order {
 static int mdd_rename_order(const struct lu_env *env,
                             struct mdd_device *mdd,
                             struct mdd_object *src_pobj,
+                           const struct lu_attr *pattr,
                             struct mdd_object *tgt_pobj)
 {
         /* order of locking, 1 - tgt-src, 0 - src-tgt*/
@@ -1922,7 +2478,8 @@ static int mdd_rename_order(const struct lu_env *env,
         } else if (lu_fid_eq(&mdd->mdd_root_fid, mdo2fid(tgt_pobj))) {
                 rc = MDD_RN_TGTSRC;
         } else {
-                rc = mdd_is_parent(env, mdd, src_pobj, mdo2fid(tgt_pobj), NULL);
+               rc = mdd_is_parent(env, mdd, src_pobj, pattr, mdo2fid(tgt_pobj),
+                                  NULL);
                 if (rc == -EREMOTE)
                         rc = 0;
 
@@ -1938,55 +2495,61 @@ static int mdd_rename_order(const struct lu_env *env,
 /* has not mdd_write{read}_lock on any obj yet. */
 static int mdd_rename_sanity_check(const struct lu_env *env,
                                    struct mdd_object *src_pobj,
+                                  const struct lu_attr *pattr,
                                    struct mdd_object *tgt_pobj,
+                                  const struct lu_attr *tpattr,
                                    struct mdd_object *sobj,
+                                  const struct lu_attr *cattr,
                                    struct mdd_object *tobj,
-                                  struct lu_attr *so_attr,
-                                  struct lu_attr *tg_attr)
+                                  const struct lu_attr *tattr)
 {
-        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);
+       rc = mdd_may_delete(env, src_pobj, pattr, sobj, cattr, NULL, 1, 0);
+       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 cld_rename before mdd_rename and enable
+        * MDS_PERM_BYPASS).
+        * So check may_create, but not check may_unlink. */
+       if (tobj == NULL)
+               rc = mdd_may_create(env, tgt_pobj, tpattr, NULL,
+                                   (src_pobj != tgt_pobj));
+       else
+               rc = mdd_may_delete(env, tgt_pobj, tpattr, tobj, tattr, cattr,
+                                   (src_pobj != tgt_pobj), 1);
 
-        /* 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
-               rc = mdd_may_delete(env, tgt_pobj, tobj, tg_attr, so_attr,
-                                    (src_pobj != tgt_pobj), 1);
-
-        if (!rc && !tobj && (src_pobj != tgt_pobj) &&
-           S_ISDIR(so_attr->la_mode))
-                rc = __mdd_may_link(env, tgt_pobj);
+       if (!rc && !tobj && (src_pobj != tgt_pobj) && S_ISDIR(cattr->la_mode))
+               rc = __mdd_may_link(env, tgt_pobj, tpattr);
 
-        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,44 +2567,51 @@ 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 != 0)
+                               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),
+                                                     S_IFDIR, dotdot, handle);
+                       if (rc != 0)
+                               return rc;
+               }
 
-                /* new target child can be directory,
-                 * counted by target dir's nlink */
-                rc = mdo_declare_ref_add(env, mdd_tpobj, 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);
+               if (rc != 0)
+                       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_spobj, NULL, 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_sobj, NULL, handle);
-        if (rc)
-                return rc;
-        mdd_declare_links_add(env, mdd_sobj, 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 = mdo_declare_attr_set(env, mdd_tpobj, NULL, handle);
-        if (rc)
-                return rc;
+       rc = mdd_declare_links_add(env, mdd_sobj, handle, ldata,
+               S_ISREG(mdd_object_type(mdd_sobj)) ? MLAO_CHECK : MLAO_IGNORE);
+       if (rc)
+               return rc;
 
-        /* new name */
-        rc = mdo_declare_index_insert(env, mdd_tpobj, mdo2fid(mdd_sobj),
-                        tname->ln_name, handle);
-        if (rc)
-                return rc;
+       /* new name */
+       rc = mdo_declare_index_insert(env, mdd_tpobj, mdo2fid(mdd_sobj),
+                                     mdd_object_type(mdd_sobj),
+                                     tname->ln_name, handle);
+       if (rc != 0)
+               return rc;
 
         /* name from target dir (old name), we declare it unconditionally
          * as mdd_rename() calls delete unconditionally as well. so just
@@ -2069,20 +2639,17 @@ static int mdd_declare_rename(const struct lu_env *env,
                                 return rc;
                 }
 
-                rc = mdo_declare_attr_set(env, mdd_tobj, NULL, handle);
-                if (rc)
-                        return rc;
-
-                mdd_declare_links_add(env, mdd_tobj, handle);
-                if (rc)
-                        return rc;
+               la->la_valid = LA_CTIME;
+               rc = mdo_declare_attr_set(env, mdd_tobj, la, handle);
+               if (rc)
+                       return rc;
 
-                rc = mdd_declare_finish_unlink(env, mdd_tobj, ma, handle);
-                if (rc)
-                        return rc;
+               rc = mdd_declare_finish_unlink(env, mdd_tobj, handle);
+               if (rc)
+                       return rc;
         }
 
-       rc = mdd_declare_changelog_ext_store(env, mdd, tname, sname, handle);
+       rc = mdd_declare_changelog_store(env, mdd, tname, sname, handle);
         if (rc)
                 return rc;
 
@@ -2096,105 +2663,98 @@ 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;
-       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;
+       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 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 lu_attr *cattr = MDD_ENV_VAR(env, cattr);
+       struct lu_attr *pattr = MDD_ENV_VAR(env, pattr);
+       struct lu_attr *tattr = MDD_ENV_VAR(env, tattr);
+       struct lu_attr *tpattr = MDD_ENV_VAR(env, tpattr);
+       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);
+
+       rc = mdd_la_get(env, mdd_sobj, cattr);
+       if (rc)
+               GOTO(out_pending, rc);
+
+       rc = mdd_la_get(env, mdd_spobj, pattr);
+       if (rc)
+               GOTO(out_pending, rc);
 
-        if (tobj)
-                mdd_tobj = md2mdd_obj(tobj);
+       if (mdd_tobj) {
+               rc = mdd_la_get(env, mdd_tobj, tattr);
+               if (rc)
+                       GOTO(out_pending, rc);
+       }
+
+       rc = mdd_la_get(env, mdd_tpobj, tpattr);
+       if (rc)
+               GOTO(out_pending, rc);
+
+       rc = mdd_rename_sanity_check(env, mdd_spobj, pattr, mdd_tpobj, tpattr,
+                                    mdd_sobj, cattr, mdd_tobj, tattr);
+       if (rc)
+               GOTO(out_pending, rc);
 
-        mdd_sobj = mdd_object_find(env, mdd, lf);
+       rc = mdd_name_check(mdd, ltname);
+       if (rc < 0)
+               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)
                 GOTO(stop, rc);
 
         /* FIXME: Should consider tobj and sobj too in rename_lock. */
-        rc = mdd_rename_order(env, mdd, mdd_spobj, mdd_tpobj);
-        if (rc < 0)
-                GOTO(cleanup_unlocked, rc);
-
-        /* Get locks in determined order */
-        if (rc == MDD_RN_SAME) {
-                sdlh = mdd_pdo_write_lock(env, mdd_spobj,
-                                          sname, MOR_SRC_PARENT);
-                /* check hashes to determine do we need one lock or two */
-                if (mdd_name2hash(sname) != mdd_name2hash(tname))
-                        tdlh = mdd_pdo_write_lock(env, mdd_tpobj, tname,
-                                MOR_TGT_PARENT);
-                else
-                        tdlh = sdlh;
-        } else if (rc == MDD_RN_SRCTGT) {
-                sdlh = mdd_pdo_write_lock(env, mdd_spobj, sname,MOR_SRC_PARENT);
-                tdlh = mdd_pdo_write_lock(env, mdd_tpobj, tname,MOR_TGT_PARENT);
-        } else {
-                tdlh = mdd_pdo_write_lock(env, mdd_tpobj, tname,MOR_SRC_PARENT);
-                sdlh = mdd_pdo_write_lock(env, mdd_spobj, sname,MOR_TGT_PARENT);
-        }
-        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);
+       rc = mdd_rename_order(env, mdd, mdd_spobj, pattr, mdd_tpobj);
+       if (rc < 0)
+               GOTO(cleanup_unlocked, rc);
 
-       is_dir = S_ISDIR(so_attr->la_mode);
+       is_dir = S_ISDIR(cattr->la_mode);
 
         /* Remove source name from source directory */
-        rc = __mdd_index_delete(env, mdd_spobj, sname, is_dir, handle,
-                                mdd_object_capa(env, mdd_spobj));
+       rc = __mdd_index_delete(env, mdd_spobj, sname, is_dir, handle);
         if (rc)
                 GOTO(cleanup, rc);
 
         /* "mv dir1 dir2" needs "dir1/.." link update */
         if (is_dir && mdd_sobj && !lu_fid_eq(spobj_fid, tpobj_fid)) {
-                rc = __mdd_index_delete_only(env, mdd_sobj, dotdot, handle,
-                                        mdd_object_capa(env, mdd_sobj));
-                if (rc)
-                        GOTO(fixup_spobj2, rc);
+               rc = __mdd_index_delete_only(env, mdd_sobj, dotdot, handle);
+               if (rc != 0)
+                       GOTO(fixup_spobj2, rc);
 
-                rc = __mdd_index_insert_only(env, mdd_sobj, tpobj_fid, dotdot,
-                                      handle, mdd_object_capa(env, mdd_sobj));
-                if (rc)
+               rc = __mdd_index_insert_only(env, mdd_sobj, tpobj_fid, S_IFDIR,
+                                            dotdot, handle);
+               if (rc != 0)
                         GOTO(fixup_spobj, rc);
         }
 
@@ -2202,8 +2762,7 @@ static int mdd_rename(const struct lu_env *env,
          * Here tobj can be remote one, so we do index_delete unconditionally
          * and -ENOENT is allowed.
          */
-        rc = __mdd_index_delete(env, mdd_tpobj, tname, is_dir, handle,
-                                mdd_object_capa(env, mdd_tpobj));
+       rc = __mdd_index_delete(env, mdd_tpobj, tname, is_dir, handle);
         if (rc != 0) {
                 if (mdd_tobj) {
                         /* tname might been renamed to something else */
@@ -2214,21 +2773,21 @@ static int mdd_rename(const struct lu_env *env,
         }
 
         /* Insert new fid with target name into target dir */
-        rc = __mdd_index_insert(env, mdd_tpobj, lf, tname, is_dir, handle,
-                                mdd_object_capa(env, mdd_tpobj));
-        if (rc)
+       rc = __mdd_index_insert(env, mdd_tpobj, lf, cattr->la_mode,
+                               tname, handle);
+       if (rc != 0)
                 GOTO(fixup_tpobj, rc);
 
         LASSERT(ma->ma_attr.la_valid & LA_CTIME);
         la->la_ctime = la->la_mtime = ma->ma_attr.la_ctime;
 
         /* XXX: mdd_sobj must be local one if it is NOT NULL. */
-        if (mdd_sobj) {
-                la->la_valid = LA_CTIME;
-               rc = mdd_attr_check_set_internal(env, mdd_sobj, la, handle, 0);
-                if (rc)
-                        GOTO(fixup_tpobj, rc);
-        }
+       if (mdd_sobj) {
+               la->la_valid = LA_CTIME;
+               rc = mdd_update_time(env, mdd_sobj, cattr, la, handle);
+               if (rc)
+                       GOTO(fixup_tpobj, rc);
+       }
 
         /* Remove old target object
          * For tobj is remote case cmm layer has processed
@@ -2247,13 +2806,12 @@ static int mdd_rename(const struct lu_env *env,
                 mdo_ref_del(env, mdd_tobj, handle);
 
                 /* Remove dot reference. */
-               if (S_ISDIR(tg_attr->la_mode))
+               if (S_ISDIR(tattr->la_mode))
                         mdo_ref_del(env, mdd_tobj, handle);
                tobj_ref = 1;
 
                /* fetch updated nlink */
-               rc = mdd_la_get(env, mdd_tobj, tg_attr,
-                               mdd_object_capa(env, mdd_tobj));
+               rc = mdd_la_get(env, mdd_tobj, tattr);
                if (rc != 0) {
                        CERROR("%s: Failed to get nlink for tobj "
                                DFID": rc = %d\n",
@@ -2263,7 +2821,7 @@ static int mdd_rename(const struct lu_env *env,
                }
 
                la->la_valid = LA_CTIME;
-               rc = mdd_attr_check_set_internal(env, mdd_tobj, la, handle, 0);
+               rc = mdd_update_time(env, mdd_tobj, tattr, la, handle);
                if (rc != 0) {
                        CERROR("%s: Failed to set ctime for tobj "
                                DFID": rc = %d\n",
@@ -2273,9 +2831,10 @@ static int mdd_rename(const struct lu_env *env,
                }
 
                /* XXX: this transfer to ma will be removed with LOD/OSP */
-               ma->ma_attr = *tg_attr;
+               ma->ma_attr = *tattr;
                ma->ma_valid |= MA_INODE;
-               rc = mdd_finish_unlink(env, mdd_tobj, ma, handle);
+               rc = mdd_finish_unlink(env, mdd_tobj, ma, mdd_tpobj, ltname,
+                                      handle);
                if (rc != 0) {
                        CERROR("%s: Failed to unlink tobj "
                                DFID": rc = %d\n",
@@ -2285,8 +2844,7 @@ static int mdd_rename(const struct lu_env *env,
                }
 
                /* fetch updated nlink */
-               rc = mdd_la_get(env, mdd_tobj, tg_attr,
-                               mdd_object_capa(env, mdd_tobj));
+               rc = mdd_la_get(env, mdd_tobj, tattr);
                if (rc != 0) {
                        CERROR("%s: Failed to get nlink for tobj "
                                DFID": rc = %d\n",
@@ -2295,32 +2853,35 @@ static int mdd_rename(const struct lu_env *env,
                        GOTO(fixup_tpobj, rc);
                }
                /* XXX: this transfer to ma will be removed with LOD/OSP */
-               ma->ma_attr = *tg_attr;
+               ma->ma_attr = *tattr;
                ma->ma_valid |= MA_INODE;
 
-               if (so_attr->la_nlink == 0)
+               if (tattr->la_nlink == 0) {
                        cl_flags |= CLF_RENAME_LAST;
+                       if (mdd_hsm_archive_exists(env, mdd_tobj, ma))
+                               cl_flags |= CLF_RENAME_LAST_EXISTS;
+               }
         }
 
-        la->la_valid = LA_CTIME | LA_MTIME;
-       rc = mdd_attr_check_set_internal(env, mdd_spobj, la, handle, 0);
-        if (rc)
-                GOTO(fixup_tpobj, rc);
+       la->la_valid = LA_CTIME | LA_MTIME;
+       rc = mdd_update_time(env, mdd_spobj, pattr, la, handle);
+       if (rc)
+               GOTO(fixup_tpobj, rc);
 
-        if (mdd_spobj != mdd_tpobj) {
-                la->la_valid = LA_CTIME | LA_MTIME;
-               rc = mdd_attr_check_set_internal(env, mdd_tpobj, la,
-                                                handle, 0);
-        }
+       if (mdd_spobj != mdd_tpobj) {
+               la->la_valid = LA_CTIME | LA_MTIME;
+               rc = mdd_update_time(env, mdd_tpobj, tpattr, la, handle);
+       }
 
-        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. */
@@ -2331,8 +2892,7 @@ static int mdd_rename(const struct lu_env *env,
 
 fixup_tpobj:
         if (rc) {
-                rc2 = __mdd_index_delete(env, mdd_tpobj, tname, is_dir, handle,
-                                         BYPASS_CAPA);
+               rc2 = __mdd_index_delete(env, mdd_tpobj, tname, is_dir, handle);
                 if (rc2)
                         CWARN("tp obj fix error %d\n",rc2);
 
@@ -2344,483 +2904,1183 @@ fixup_tpobj:
                                        mdo_ref_add(env, mdd_tobj, handle);
                        }
 
-                        rc2 = __mdd_index_insert(env, mdd_tpobj,
-                                         mdo2fid(mdd_tobj), tname,
-                                         is_dir, handle,
-                                         BYPASS_CAPA);
-
-                        if (rc2)
-                                CWARN("tp obj fix error %d\n",rc2);
-                }
-        }
+                       rc2 = __mdd_index_insert(env, mdd_tpobj,
+                                                 mdo2fid(mdd_tobj),
+                                                 mdd_object_type(mdd_tobj),
+                                                 tname, handle);
+                       if (rc2 != 0)
+                               CWARN("tp obj fix error: rc = %d\n", rc2);
+               }
+       }
 
 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);
+               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, S_IFDIR,
+                                             dotdot, handle);
+               if (rc2 != 0)
+                       CWARN("%s: sp obj dotdot insert error: rc = %d\n",
+                             mdd2obd_dev(mdd)->obd_name, rc2);
+       }
 
-                if (rc2)
-                        CWARN("sp obj dotdot delete error %d\n",rc2);
+fixup_spobj2:
+       if (rc != 0) {
+               rc2 = __mdd_index_insert(env, mdd_spobj, lf,
+                                        mdd_object_type(mdd_sobj), sname,
+                                        handle);
+               if (rc2 != 0)
+                       CWARN("sp obj fix error: rc = %d\n", rc2);
+       }
+
+cleanup:
+       if (tobj_locked)
+               mdd_write_unlock(env, mdd_tobj);
+
+cleanup_unlocked:
+       if (rc == 0)
+               rc = mdd_changelog_ns_store(env, mdd, CL_RENAME, cl_flags,
+                                           mdd_tobj, tpobj_fid, lf, spobj_fid,
+                                           ltname, lsname, handle);
+
+stop:
+       mdd_trans_stop(env, mdd, rc, handle);
+
+out_pending:
+       mdd_object_put(env, mdd_sobj);
+       return rc;
+}
+
+/**
+ * During migration once the parent FID has been changed,
+ * we need update the parent FID in linkea.
+ **/
+static int mdd_linkea_update_child_internal(const struct lu_env *env,
+                                           struct mdd_object *parent,
+                                           struct mdd_object *child,
+                                           const char *name, int namelen,
+                                           struct thandle *handle,
+                                           bool declare)
+{
+       struct mdd_thread_info  *info = mdd_env_info(env);
+       struct linkea_data      ldata = { NULL };
+       struct lu_buf           *buf = &info->mti_link_buf;
+       int                     count;
+       int                     rc = 0;
+
+       ENTRY;
+
+       buf = lu_buf_check_and_alloc(buf, PATH_MAX);
+       if (buf->lb_buf == NULL)
+               RETURN(-ENOMEM);
+
+       ldata.ld_buf = buf;
+       rc = mdd_links_read(env, child, &ldata);
+       if (rc != 0) {
+               if (rc == -ENOENT || rc == -ENODATA)
+                       rc = 0;
+               RETURN(rc);
+       }
+
+       LASSERT(ldata.ld_leh != NULL);
+       ldata.ld_lee = (struct link_ea_entry *)(ldata.ld_leh + 1);
+       for (count = 0; count < ldata.ld_leh->leh_reccount; count++) {
+               struct mdd_device *mdd = mdo2mdd(&child->mod_obj);
+               struct lu_name lname;
+               struct lu_fid  fid;
+
+               linkea_entry_unpack(ldata.ld_lee, &ldata.ld_reclen,
+                                   &lname, &fid);
+
+               if (strncmp(lname.ln_name, name, namelen) != 0 ||
+                   lu_fid_eq(&fid, mdd_object_fid(parent))) {
+                       ldata.ld_lee = (struct link_ea_entry *)
+                                      ((char *)ldata.ld_lee +
+                                       ldata.ld_reclen);
+                       continue;
+               }
+
+               CDEBUG(D_INFO, "%s: update "DFID" with %.*s:"DFID"\n",
+                      mdd2obd_dev(mdd)->obd_name, PFID(mdd_object_fid(child)),
+                      lname.ln_namelen, lname.ln_name,
+                      PFID(mdd_object_fid(parent)));
+               /* update to the new parent fid */
+               linkea_entry_pack(ldata.ld_lee, &lname,
+                                 mdd_object_fid(parent));
+               if (declare)
+                       rc = mdd_declare_links_add(env, child, handle, &ldata,
+                                                  MLAO_IGNORE);
+               else
+                       rc = mdd_links_write(env, child, &ldata, handle);
+               break;
+       }
+       RETURN(rc);
+}
+
+static int mdd_linkea_declare_update_child(const struct lu_env *env,
+                                          struct mdd_object *parent,
+                                          struct mdd_object *child,
+                                          const char *name, int namelen,
+                                          struct thandle *handle)
+{
+       return mdd_linkea_update_child_internal(env, parent, child, name,
+                                               namelen, handle, true);
+}
+
+static int mdd_linkea_update_child(const struct lu_env *env,
+                                  struct mdd_object *parent,
+                                  struct mdd_object *child,
+                                  const char *name, int namelen,
+                                  struct thandle *handle)
+{
+       return mdd_linkea_update_child_internal(env, parent, child, name,
+                                               namelen, handle, false);
+}
+
+static int mdd_update_linkea_internal(const struct lu_env *env,
+                                     struct mdd_object *mdd_pobj,
+                                     struct mdd_object *mdd_sobj,
+                                     struct mdd_object *mdd_tobj,
+                                     const struct lu_name *child_name,
+                                     struct thandle *handle,
+                                     int declare)
+{
+       struct mdd_thread_info  *info = mdd_env_info(env);
+       struct linkea_data      *ldata = &info->mti_link_data;
+       int                     count;
+       int                     rc = 0;
+       ENTRY;
+
+       rc = mdd_links_read(env, mdd_sobj, ldata);
+       if (rc != 0) {
+               if (rc == -ENOENT || rc == -ENODATA)
+                       rc = 0;
+               RETURN(rc);
+       }
+
+       /* If it is mulitple links file, we need update the name entry for
+        * all parent */
+       LASSERT(ldata->ld_leh != NULL);
+       ldata->ld_lee = (struct link_ea_entry *)(ldata->ld_leh + 1);
+       for (count = 0; count < ldata->ld_leh->leh_reccount; count++) {
+               struct mdd_device       *mdd = mdo2mdd(&mdd_sobj->mod_obj);
+               struct mdd_object       *pobj;
+               struct lu_name          lname;
+               struct lu_fid           fid;
+
+               linkea_entry_unpack(ldata->ld_lee, &ldata->ld_reclen,
+                                   &lname, &fid);
+               ldata->ld_lee = (struct link_ea_entry *)((char *)ldata->ld_lee +
+                                                        ldata->ld_reclen);
+               pobj = mdd_object_find(env, mdd, &fid);
+               if (IS_ERR(pobj)) {
+                       CWARN("%s: cannot find obj "DFID": rc = %ld\n",
+                             mdd2obd_dev(mdd)->obd_name, PFID(&fid),
+                             PTR_ERR(pobj));
+                       continue;
+               }
+
+               if (!mdd_object_exists(pobj)) {
+                       CDEBUG(D_INFO, "%s: obj "DFID" does not exist\n",
+                             mdd2obd_dev(mdd)->obd_name, PFID(&fid));
+                       GOTO(next_put, rc);
+               }
+
+               if (pobj == mdd_pobj &&
+                   lname.ln_namelen == child_name->ln_namelen &&
+                   strncmp(lname.ln_name, child_name->ln_name,
+                           lname.ln_namelen) == 0) {
+                       CDEBUG(D_INFO, "%s: skip its own %s: "DFID"\n",
+                             mdd2obd_dev(mdd)->obd_name, child_name->ln_name,
+                             PFID(&fid));
+                       GOTO(next_put, rc);
+               }
+
+               CDEBUG(D_INFO, "%s: update "DFID" with "DNAME":"DFID"\n",
+                      mdd2obd_dev(mdd)->obd_name, PFID(mdd_object_fid(pobj)),
+                      PNAME(&lname), PFID(mdd_object_fid(mdd_tobj)));
+
+               if (declare) {
+                       /* Remove source name from source directory */
+                       /* Insert new fid with target name into target dir */
+                       rc = mdo_declare_index_delete(env, pobj, lname.ln_name,
+                                                     handle);
+                       if (rc != 0)
+                               GOTO(next_put, rc);
+
+                       rc = mdo_declare_index_insert(env, pobj,
+                                       mdd_object_fid(mdd_tobj),
+                                       mdd_object_type(mdd_tobj),
+                                       lname.ln_name, handle);
+                       if (rc != 0)
+                               GOTO(next_put, rc);
+
+                       rc = mdo_declare_ref_add(env, mdd_tobj, handle);
+                       if (rc)
+                               GOTO(next_put, rc);
+
+                       rc = mdo_declare_ref_del(env, mdd_sobj, handle);
+                       if (rc)
+                               GOTO(next_put, rc);
+               } else {
+                       rc = __mdd_index_delete(env, pobj, lname.ln_name,
+                                               0, handle);
+                       if (rc)
+                               GOTO(next_put, rc);
+
+                       rc = __mdd_index_insert(env, pobj,
+                                       mdd_object_fid(mdd_tobj),
+                                       mdd_object_type(mdd_tobj),
+                                       lname.ln_name, handle);
+                       if (rc != 0)
+                               GOTO(next_put, rc);
+
+                       mdd_write_lock(env, mdd_tobj, MOR_SRC_CHILD);
+                       rc = mdo_ref_add(env, mdd_tobj, handle);
+                       mdd_write_unlock(env, mdd_tobj);
+                       if (rc)
+                               GOTO(next_put, rc);
+
+                       mdd_write_lock(env, mdd_sobj, MOR_TGT_CHILD);
+                       mdo_ref_del(env, mdd_sobj, handle);
+                       mdd_write_unlock(env, mdd_sobj);
+               }
+next_put:
+               mdd_object_put(env, pobj);
+               if (rc != 0)
+                       break;
+       }
+
+       RETURN(rc);
+}
+
+static int mdd_migrate_xattrs(const struct lu_env *env,
+                             struct mdd_object *mdd_sobj,
+                             struct mdd_object *mdd_tobj)
+{
+       struct mdd_thread_info  *info = mdd_env_info(env);
+       struct mdd_device       *mdd = mdo2mdd(&mdd_sobj->mod_obj);
+       char                    *xname;
+       struct thandle          *handle;
+       struct lu_buf           xbuf;
+       int                     xlen;
+       int                     rem;
+       int                     xsize;
+       int                     list_xsize;
+       struct lu_buf           list_xbuf;
+       int                     rc;
+
+       /* retrieve xattr list from the old object */
+       list_xsize = mdo_xattr_list(env, mdd_sobj, &LU_BUF_NULL);
+       if (list_xsize == -ENODATA)
+               return 0;
+
+       if (list_xsize < 0)
+               return list_xsize;
+
+       lu_buf_check_and_alloc(&info->mti_big_buf, list_xsize);
+       if (info->mti_big_buf.lb_buf == NULL)
+               return -ENOMEM;
+
+       list_xbuf.lb_buf = info->mti_big_buf.lb_buf;
+       list_xbuf.lb_len = list_xsize;
+       rc = mdo_xattr_list(env, mdd_sobj, &list_xbuf);
+       if (rc < 0)
+               return rc;
+       rc = 0;
+       rem = list_xsize;
+       xname = list_xbuf.lb_buf;
+       while (rem > 0) {
+               xlen = strnlen(xname, rem - 1) + 1;
+               if (strcmp(XATTR_NAME_LINK, xname) == 0 ||
+                   strcmp(XATTR_NAME_LMA, xname) == 0 ||
+                   strcmp(XATTR_NAME_LMV, xname) == 0)
+                       goto next;
+
+               /* For directory, if there are default layout, migrate here */
+               if (strcmp(XATTR_NAME_LOV, xname) == 0 &&
+                   !S_ISDIR(lu_object_attr(&mdd_sobj->mod_obj.mo_lu)))
+                       goto next;
+
+               xsize = mdo_xattr_get(env, mdd_sobj, &LU_BUF_NULL, xname);
+               if (xsize == -ENODATA)
+                       goto next;
+               if (xsize < 0)
+                       GOTO(out, rc);
+
+               lu_buf_check_and_alloc(&info->mti_link_buf, xsize);
+               if (info->mti_link_buf.lb_buf == NULL)
+                       GOTO(out, rc = -ENOMEM);
+
+               xbuf.lb_len = xsize;
+               xbuf.lb_buf = info->mti_link_buf.lb_buf;
+               rc = mdo_xattr_get(env, mdd_sobj, &xbuf, xname);
+               if (rc == -ENODATA)
+                       goto next;
+               if (rc < 0)
+                       GOTO(out, rc);
+
+               handle = mdd_trans_create(env, mdd);
+               if (IS_ERR(handle))
+                       GOTO(out, rc = PTR_ERR(handle));
+
+               rc = mdo_declare_xattr_set(env, mdd_tobj, &xbuf, xname, 0,
+                                          handle);
+               if (rc != 0)
+                       GOTO(stop_trans, rc);
+               /* Note: this transaction is part of migration, and it is not
+                * the last step of migration, so we set th_local = 1 to avoid
+                * update last rcvd for this transaction */
+               handle->th_local = 1;
+               rc = mdd_trans_start(env, mdd, handle);
+               if (rc != 0)
+                       GOTO(stop_trans, rc);
+
+               rc = mdo_xattr_set(env, mdd_tobj, &xbuf, xname, 0, handle);
+               if (rc == -EEXIST)
+                       GOTO(stop_trans, rc = 0);
+
+               if (rc != 0)
+                       GOTO(stop_trans, rc);
+stop_trans:
+               mdd_trans_stop(env, mdd, rc, handle);
+               if (rc != 0)
+                       GOTO(out, rc);
+next:
+               rem -= xlen;
+               memmove(xname, xname + xlen, rem);
+       }
+out:
+       return rc;
+}
+
+static int mdd_declare_migrate_create(const struct lu_env *env,
+                                     struct mdd_object *mdd_pobj,
+                                     struct mdd_object *mdd_sobj,
+                                     struct mdd_object *mdd_tobj,
+                                     struct md_op_spec *spec,
+                                     struct lu_attr *la,
+                                     union lmv_mds_md *mgr_ea,
+                                     struct linkea_data *ldata,
+                                     struct thandle *handle)
+{
+       struct lu_attr          *la_flag = MDD_ENV_VAR(env, la_for_fix);
+       const struct lu_buf     *buf;
+       int                     rc;
+       int                     mgr_easize;
+
+       rc = mdd_declare_object_create_internal(env, mdd_pobj, mdd_tobj, la,
+                                               handle, spec, NULL);
+       if (rc != 0)
+               return rc;
+
+       rc = mdd_declare_object_initialize(env, mdd_pobj, mdd_tobj, la,
+                                          handle);
+       if (rc != 0)
+               return rc;
+
+       if (S_ISLNK(la->la_mode)) {
+               const char *target_name = spec->u.sp_symname;
+               int sym_len = strlen(target_name);
+               const struct lu_buf *buf;
+
+               buf = mdd_buf_get_const(env, target_name, sym_len);
+               rc = dt_declare_record_write(env, mdd_object_child(mdd_tobj),
+                                            buf, 0, handle);
+               if (rc != 0)
+                       return rc;
+       } else if (S_ISDIR(la->la_mode)) {
+               rc = mdd_declare_links_add(env, mdd_tobj, handle, ldata,
+                                          MLAO_IGNORE);
+               if (rc != 0)
+                       return rc;
+       }
+
+       if (spec->u.sp_ea.eadata != NULL && spec->u.sp_ea.eadatalen != 0) {
+               buf = mdd_buf_get_const(env, spec->u.sp_ea.eadata,
+                                       spec->u.sp_ea.eadatalen);
+               rc = mdo_declare_xattr_set(env, mdd_tobj, buf, XATTR_NAME_LOV,
+                                          0, handle);
+               if (rc)
+                       return rc;
+       }
+
+       mgr_easize = lmv_mds_md_size(2, LMV_MAGIC_V1);
+       buf = mdd_buf_get_const(env, mgr_ea, mgr_easize);
+       rc = mdo_declare_xattr_set(env, mdd_sobj, buf, XATTR_NAME_LMV,
+                                  0, handle);
+       if (rc)
+               return rc;
+
+       la_flag->la_valid = LA_FLAGS;
+       la_flag->la_flags = la->la_flags | LUSTRE_IMMUTABLE_FL;
+       rc = mdo_declare_attr_set(env, mdd_sobj, la_flag, handle);
+
+       return rc;
+}
+
+static int mdd_migrate_create(const struct lu_env *env,
+                             struct mdd_object *mdd_pobj,
+                             struct mdd_object *mdd_sobj,
+                             struct mdd_object *mdd_tobj,
+                             const struct lu_name *lname,
+                             struct lu_attr *la)
+{
+       struct mdd_thread_info  *info = mdd_env_info(env);
+       struct mdd_device       *mdd = mdo2mdd(&mdd_sobj->mod_obj);
+       struct md_op_spec       *spec = &info->mti_spec;
+       struct lu_buf           lmm_buf = { NULL };
+       struct lu_buf           link_buf = { NULL };
+       const struct lu_buf     *buf;
+       struct thandle          *handle;
+       struct lmv_mds_md_v1    *mgr_ea;
+       struct lu_attr          *la_flag = MDD_ENV_VAR(env, la_for_fix);
+       struct dt_allocation_hint *hint = &mdd_env_info(env)->mti_hint;
+       int                     mgr_easize;
+       struct linkea_data      *ldata = &mdd_env_info(env)->mti_link_data;
+       int                     rc;
+       ENTRY;
+
+       /* prepare spec for create */
+       memset(spec, 0, sizeof(*spec));
+       spec->sp_cr_lookup = 0;
+       spec->sp_feat = &dt_directory_features;
+       if (S_ISLNK(la->la_mode)) {
+               buf = lu_buf_check_and_alloc(
+                               &mdd_env_info(env)->mti_big_buf,
+                               la->la_size + 1);
+               link_buf = *buf;
+               link_buf.lb_len = la->la_size + 1;
+               memset(link_buf.lb_buf, 0, link_buf.lb_len);
+               rc = mdd_readlink(env, &mdd_sobj->mod_obj, &link_buf);
+               if (rc <= 0) {
+                       rc = rc != 0 ? rc : -EFAULT;
+                       CERROR("%s: "DFID" readlink failed: rc = %d\n",
+                              mdd2obd_dev(mdd)->obd_name,
+                              PFID(mdd_object_fid(mdd_sobj)), rc);
+                       RETURN(rc);
+               }
+               spec->u.sp_symname = link_buf.lb_buf;
+       } else if S_ISREG(la->la_mode) {
+               /* retrieve lov of the old object */
+               rc = mdd_get_lov_ea(env, mdd_sobj, &lmm_buf);
+               if (rc != 0 && rc != -ENODATA)
+                       RETURN(rc);
+               if (lmm_buf.lb_buf != NULL && lmm_buf.lb_len != 0) {
+                       spec->u.sp_ea.eadata = lmm_buf.lb_buf;
+                       spec->u.sp_ea.eadatalen = lmm_buf.lb_len;
+                       spec->sp_cr_flags |= MDS_OPEN_HAS_EA;
+               }
+       } else if (S_ISDIR(la->la_mode)) {
+               rc = mdd_links_read(env, mdd_sobj, ldata);
+               if (rc < 0 && rc != -ENODATA)
+                       RETURN(rc);
+       }
+
+       mgr_ea = (struct lmv_mds_md_v1 *)info->mti_xattr_buf;
+       memset(mgr_ea, 0, sizeof(*mgr_ea));
+       mgr_ea->lmv_magic = cpu_to_le32(LMV_MAGIC_V1);
+       mgr_ea->lmv_stripe_count = cpu_to_le32(2);
+       mgr_ea->lmv_master_mdt_index = mdd_seq_site(mdd)->ss_node_id;
+       mgr_ea->lmv_hash_type = cpu_to_le32(LMV_HASH_FLAG_MIGRATION);
+       fid_cpu_to_le(&mgr_ea->lmv_stripe_fids[0], mdd_object_fid(mdd_sobj));
+       fid_cpu_to_le(&mgr_ea->lmv_stripe_fids[1], mdd_object_fid(mdd_tobj));
+
+       mdd_object_make_hint(env, mdd_pobj, mdd_tobj, la, spec, hint);
+
+       handle = mdd_trans_create(env, mdd);
+       if (IS_ERR(handle))
+               GOTO(out_free, rc = PTR_ERR(handle));
+
+       /* Note: this transaction is part of migration, and it is not
+        * the last step of migration, so we set th_local = 1 to avoid
+        * update last rcvd for this transaction */
+       handle->th_local = 1;
+       rc = mdd_declare_migrate_create(env, mdd_pobj, mdd_sobj, mdd_tobj,
+                                       spec, la,
+                                       (union lmv_mds_md *)info->mti_xattr_buf,
+                                       ldata, handle);
+       if (rc != 0)
+               GOTO(stop_trans, rc);
+
+       rc = mdd_trans_start(env, mdd, handle);
+       if (rc != 0)
+               GOTO(stop_trans, rc);
+
+       /* create the target object */
+       rc = mdd_object_create(env, mdd_pobj, mdd_tobj, la, spec, NULL, NULL,
+                              hint, handle);
+       if (rc != 0)
+               GOTO(stop_trans, rc);
+
+       if (S_ISDIR(la->la_mode)) {
+               rc = mdd_links_write(env, mdd_tobj, ldata, handle);
+               if (rc != 0)
+                       GOTO(stop_trans, rc);
+       }
+
+       /* Set MIGRATE EA on the source inode, so once the migration needs
+        * to be re-done during failover, the re-do process can locate the
+        * target object which is already being created. */
+       mgr_easize = lmv_mds_md_size(2, LMV_MAGIC_V1);
+       buf = mdd_buf_get_const(env, mgr_ea, mgr_easize);
+       rc = mdo_xattr_set(env, mdd_sobj, buf, XATTR_NAME_LMV, 0, handle);
+       if (rc != 0)
+               GOTO(stop_trans, rc);
+
+       /* Set immutable flag, so any modification is disabled until
+        * the migration is done. Once the migration is interrupted,
+        * if the resume process find the migrating object has both
+        * IMMUTALBE flag and MIGRATE EA, it need to clear IMMUTABLE
+        * flag and approve the migration */
+       la_flag->la_valid = LA_FLAGS;
+       la_flag->la_flags = la->la_flags | LUSTRE_IMMUTABLE_FL;
+       rc = mdo_attr_set(env, mdd_sobj, la_flag, handle);
+stop_trans:
+       if (handle != NULL)
+               mdd_trans_stop(env, mdd, rc, handle);
+out_free:
+       if (lmm_buf.lb_buf != NULL)
+               OBD_FREE(lmm_buf.lb_buf, lmm_buf.lb_len);
+       RETURN(rc);
+}
+
+static int mdd_migrate_entries(const struct lu_env *env,
+                              struct mdd_object *mdd_sobj,
+                              struct mdd_object *mdd_tobj)
+{
+       struct dt_object        *next = mdd_object_child(mdd_sobj);
+       struct mdd_device       *mdd = mdo2mdd(&mdd_sobj->mod_obj);
+       struct dt_object        *dt_tobj = mdd_object_child(mdd_tobj);
+       struct thandle          *handle;
+       struct dt_it            *it;
+       const struct dt_it_ops  *iops;
+       int                      rc;
+       int                      result;
+       struct lu_dirent        *ent;
+       ENTRY;
+
+       OBD_ALLOC(ent, NAME_MAX + sizeof(*ent) + 1);
+       if (ent == NULL)
+               RETURN(-ENOMEM);
+
+       if (!dt_try_as_dir(env, next))
+               GOTO(out_ent, rc = -ENOTDIR);
+       /*
+        * iterate directories
+        */
+       iops = &next->do_index_ops->dio_it;
+       it = iops->init(env, next, LUDA_FID | LUDA_TYPE);
+       if (IS_ERR(it))
+               GOTO(out_ent, rc = PTR_ERR(it));
+
+       rc = iops->load(env, it, 0);
+       if (rc == 0)
+               rc = iops->next(env, it);
+       else if (rc > 0)
+               rc = 0;
+       /*
+        * At this point and across for-loop:
+        *
+        *  rc == 0 -> ok, proceed.
+        *  rc >  0 -> end of directory.
+        *  rc <  0 -> error.
+        */
+       do {
+               struct mdd_object       *child;
+               char                    *name = mdd_env_info(env)->mti_key;
+               int                     len;
+               int                     recsize;
+               int                     is_dir;
+               bool                    target_exist = false;
+
+               len = iops->key_size(env, it);
+               if (len == 0)
+                       goto next;
+
+               result = iops->rec(env, it, (struct dt_rec *)ent,
+                                  LUDA_FID | LUDA_TYPE);
+               if (result == -ESTALE)
+                       goto next;
+               if (result != 0) {
+                       rc = result;
+                       goto out;
+               }
+
+               fid_le_to_cpu(&ent->lde_fid, &ent->lde_fid);
+               recsize = le16_to_cpu(ent->lde_reclen);
+
+               /* Insert new fid with target name into target dir */
+               if ((ent->lde_namelen == 1 && ent->lde_name[0] == '.') ||
+                   (ent->lde_namelen == 2 && ent->lde_name[0] == '.' &&
+                    ent->lde_name[1] == '.'))
+                       goto next;
 
+               child = mdd_object_find(env, mdd, &ent->lde_fid);
+               if (IS_ERR(child))
+                       GOTO(out, rc = PTR_ERR(child));
+
+               is_dir = S_ISDIR(mdd_object_type(child));
+
+               snprintf(name, ent->lde_namelen + 1, "%s", ent->lde_name);
+
+               /* Check whether the name has been inserted to the target */
+               if (dt_try_as_dir(env, dt_tobj)) {
+                       struct lu_fid *fid = &mdd_env_info(env)->mti_fid2;
+
+                       rc = dt_lookup(env, dt_tobj, (struct dt_rec *)fid,
+                                      (struct dt_key *)name);
+                       if (unlikely(rc == 0))
+                               target_exist = true;
+               }
+
+               handle = mdd_trans_create(env, mdd);
+               if (IS_ERR(handle))
+                       GOTO(out, rc = PTR_ERR(handle));
+
+               /* Note: this transaction is part of migration, and it is not
+                * the last step of migration, so we set th_local = 1 to avoid
+                * updating last rcvd for this transaction */
+               handle->th_local = 1;
+               if (likely(!target_exist)) {
+                       rc = mdo_declare_index_insert(env, mdd_tobj,
+                                                     &ent->lde_fid,
+                                                     mdd_object_type(child),
+                                                     name, handle);
+                       if (rc != 0)
+                               GOTO(out_put, rc);
+
+                       if (is_dir) {
+                               rc = mdo_declare_ref_add(env, mdd_tobj, handle);
+                               if (rc != 0)
+                                       GOTO(out_put, rc);
+                       }
+               }
+
+               rc = mdo_declare_index_delete(env, mdd_sobj, name, handle);
+               if (rc != 0)
+                       GOTO(out_put, rc);
+
+               if (is_dir) {
+                       rc = mdo_declare_ref_del(env, mdd_sobj, handle);
+                       if (rc != 0)
+                               GOTO(out_put, rc);
+
+                       /* Update .. for child */
+                       rc = mdo_declare_index_delete(env, child, dotdot,
+                                                     handle);
+                       if (rc != 0)
+                               GOTO(out_put, rc);
+
+                       rc = mdo_declare_index_insert(env, child,
+                                                     mdd_object_fid(mdd_tobj),
+                                                     S_IFDIR, dotdot, handle);
+                       if (rc != 0)
+                               GOTO(out_put, rc);
+               }
+
+               rc = mdd_linkea_declare_update_child(env, mdd_tobj,
+                                                    child, name,
+                                                    strlen(name),
+                                                    handle);
+               if (rc != 0)
+                       GOTO(out_put, rc);
+
+               rc = mdd_trans_start(env, mdd, handle);
+               if (rc != 0) {
+                       CERROR("%s: transaction start failed: rc = %d\n",
+                              mdd2obd_dev(mdd)->obd_name, rc);
+                       GOTO(out_put, rc);
+               }
+
+               if (likely(!target_exist)) {
+                       rc = __mdd_index_insert(env, mdd_tobj, &ent->lde_fid,
+                                               mdd_object_type(child),
+                                               name, handle);
+                       if (rc != 0)
+                               GOTO(out_put, rc);
+               }
 
-                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);
-        }
+               rc = __mdd_index_delete(env, mdd_sobj, name, is_dir, handle);
+               if (rc != 0)
+                       GOTO(out_put, rc);
+
+               if (is_dir) {
+                       rc = __mdd_index_delete_only(env, child, dotdot,
+                                                    handle);
+                       if (rc != 0)
+                               GOTO(out_put, rc);
+
+                       rc = __mdd_index_insert_only(env, child,
+                                        mdd_object_fid(mdd_tobj), S_IFDIR,
+                                        dotdot, handle);
+                       if (rc != 0)
+                               GOTO(out_put, rc);
+               }
 
-fixup_spobj2:
-        if (rc) {
-                rc2 = __mdd_index_insert(env, mdd_spobj,
-                                         lf, sname, is_dir, handle, BYPASS_CAPA);
-                if (rc2)
-                        CWARN("sp obj fix error %d\n",rc2);
-        }
-cleanup:
-       if (tobj_locked)
-               mdd_write_unlock(env, mdd_tobj);
-        if (likely(tdlh) && sdlh != tdlh)
-                mdd_pdo_write_unlock(env, mdd_tpobj, tdlh);
-        if (likely(sdlh))
-                mdd_pdo_write_unlock(env, mdd_spobj, sdlh);
-cleanup_unlocked:
-        if (rc == 0)
-               rc = mdd_changelog_ext_ns_store(env, mdd, CL_RENAME, cl_flags,
-                                               mdd_tobj, tpobj_fid, lf,
-                                               spobj_fid, ltname, lsname,
-                                               handle);
+               rc = mdd_linkea_update_child(env, mdd_tobj, child, name,
+                                            strlen(name), handle);
 
-stop:
-        mdd_trans_stop(env, mdd, rc, handle);
-        if (mdd_sobj)
-                mdd_object_put(env, mdd_sobj);
-out_pending:
-        return rc;
+out_put:
+               mdd_object_put(env, child);
+               mdd_trans_stop(env, mdd, rc, handle);
+               if (rc != 0)
+                       GOTO(out, rc);
+next:
+               result = iops->next(env, it);
+               if (OBD_FAIL_CHECK(OBD_FAIL_MIGRATE_ENTRIES))
+                       GOTO(out, rc = -EINTR);
+
+               if (result == -ESTALE)
+                       goto next;
+       } while (result == 0);
+out:
+       iops->put(env, it);
+       iops->fini(env, it);
+out_ent:
+       OBD_FREE(ent, NAME_MAX + sizeof(*ent) + 1);
+       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_declare_update_linkea(const struct lu_env *env,
+                                    struct mdd_object *mdd_pobj,
+                                    struct mdd_object *mdd_sobj,
+                                    struct mdd_object *mdd_tobj,
+                                    struct thandle *handle,
+                                    const struct lu_name *child_name)
+{
+       return mdd_update_linkea_internal(env, mdd_pobj, mdd_sobj, mdd_tobj,
+                                         child_name, handle, 1);
+}
 
-static int mdd_links_new(const struct lu_env *env,
-                        struct mdd_link_data *ldata)
+static int mdd_update_linkea(const struct lu_env *env,
+                            struct mdd_object *mdd_pobj,
+                            struct mdd_object *mdd_sobj,
+                            struct mdd_object *mdd_tobj,
+                            struct thandle *handle,
+                            const struct lu_name *child_name)
 {
-       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;
+       return mdd_update_linkea_internal(env, mdd_pobj, mdd_sobj, mdd_tobj,
+                                         child_name, handle, 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)
+static int mdd_declare_migrate_update_name(const struct lu_env *env,
+                                          struct mdd_object *mdd_pobj,
+                                          struct mdd_object *mdd_sobj,
+                                          struct mdd_object *mdd_tobj,
+                                          const struct lu_name *lname,
+                                          struct lu_attr *la,
+                                          struct lu_attr *parent_la,
+                                          struct thandle *handle)
 {
-       struct lustre_capa *capa;
-       struct link_ea_header *leh;
-       int rc;
+       struct lu_attr  *la_flag = MDD_ENV_VAR(env, tattr);
+       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;
+       /* Revert IMMUTABLE flag */
+       la_flag->la_valid = LA_FLAGS;
+       la_flag->la_flags = la->la_flags & ~LUSTRE_IMMUTABLE_FL;
+       rc = mdo_declare_attr_set(env, mdd_sobj, la_flag, handle);
+       if (rc != 0)
+               return rc;
 
-       if (!mdd_object_exists(mdd_obj))
-               return -ENODATA;
+       /* delete entry from source dir */
+       rc = mdo_declare_index_delete(env, mdd_pobj, lname->ln_name, handle);
+       if (rc != 0)
+               return rc;
 
-       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)
+       rc = mdd_declare_update_linkea(env, mdd_pobj, mdd_sobj,
+                                      mdd_tobj, handle, lname);
+       if (rc != 0)
+               return rc;
+
+       if (S_ISREG(mdd_object_type(mdd_sobj))) {
+               rc = mdo_declare_xattr_del(env, mdd_sobj, XATTR_NAME_LOV,
+                                          handle);
+               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 (S_ISDIR(mdd_object_type(mdd_sobj))) {
+               rc = mdo_declare_ref_del(env, mdd_pobj, handle);
+               if (rc != 0)
+                       return rc;
        }
-       if (leh->leh_magic != LINK_EA_MAGIC)
-               return -EINVAL;
-       if (leh->leh_reccount == 0)
-               return -ENODATA;
 
-       ldata->ml_leh = leh;
-       return 0;
-}
+       /* new name */
+       rc = mdo_declare_index_insert(env, mdd_pobj, mdo2fid(mdd_tobj),
+                                     mdd_object_type(mdd_tobj),
+                                     lname->ln_name, handle);
+       if (rc != 0)
+               return rc;
 
-/** 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_declare_links_add(env, mdd_tobj, handle, NULL, MLAO_IGNORE);
+       if (rc != 0)
+               return rc;
 
-       rc = mdd_links_read(env, mdd_obj, &ldata);
-       return rc ? ERR_PTR(rc) : ldata.ml_buf;
-}
+       if (S_ISDIR(mdd_object_type(mdd_sobj))) {
+               rc = mdo_declare_ref_add(env, mdd_pobj, handle);
+               if (rc != 0)
+                       return rc;
+       }
 
-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));
-}
+       /* delete old object */
+       rc = mdo_declare_ref_del(env, mdd_sobj, handle);
+       if (rc != 0)
+               return rc;
 
-/** 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;
+       if (S_ISDIR(mdd_object_type(mdd_sobj))) {
+               /* delete old object */
+               rc = mdo_declare_ref_del(env, mdd_sobj, handle);
+               if (rc != 0)
+                       return rc;
+               /* set nlink to 0 */
+               rc = mdo_declare_attr_set(env, mdd_sobj, la, handle);
+               if (rc != 0)
+                       return rc;
+       }
 
-        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;
+       rc = mdd_declare_finish_unlink(env, mdd_sobj, handle);
+       if (rc)
+               return rc;
 
-        lee->lee_reclen[0] = (reclen >> 8) & 0xff;
-        lee->lee_reclen[1] = reclen & 0xff;
-        return reclen;
-}
+       rc = mdo_declare_attr_set(env, mdd_pobj, parent_la, handle);
 
-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);
+       return rc;
 }
 
-static int mdd_declare_links_add(const struct lu_env *env,
-                                 struct mdd_object *mdd_obj,
-                                 struct thandle *handle)
+static int mdd_migrate_update_name(const struct lu_env *env,
+                                  struct mdd_object *mdd_pobj,
+                                  struct mdd_object *mdd_sobj,
+                                  struct mdd_object *mdd_tobj,
+                                  const struct lu_name *lname,
+                                  struct md_attr *ma)
 {
-        int rc;
+       struct lu_attr          *p_la = MDD_ENV_VAR(env, la_for_fix);
+       struct lu_attr          *so_attr = MDD_ENV_VAR(env, cattr);
+       struct lu_attr          *la_flag = MDD_ENV_VAR(env, tattr);
+       struct mdd_device       *mdd = mdo2mdd(&mdd_sobj->mod_obj);
+       struct thandle          *handle;
+       int                     is_dir = S_ISDIR(mdd_object_type(mdd_sobj));
+       const char              *name = lname->ln_name;
+       int                     rc;
+       ENTRY;
 
-        /* XXX: max size? */
-        rc = mdo_declare_xattr_set(env, mdd_obj,
-                             mdd_buf_get_const(env, NULL, 4096),
-                             XATTR_NAME_LINK, 0, handle);
+       /* update time for parent */
+       LASSERT(ma->ma_attr.la_valid & LA_CTIME);
+       p_la->la_ctime = p_la->la_mtime = ma->ma_attr.la_ctime;
+       p_la->la_valid = LA_CTIME;
 
-        return rc;
-}
+       rc = mdd_la_get(env, mdd_sobj, so_attr);
+       if (rc != 0)
+               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
+       handle = mdd_trans_create(env, mdd);
+       if (IS_ERR(handle))
+               RETURN(PTR_ERR(handle));
 
-/** 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);
+       rc = mdd_declare_migrate_update_name(env, mdd_pobj, mdd_sobj, mdd_tobj,
+                                            lname, so_attr, p_la, handle);
+       if (rc != 0) {
+               /* If the migration can not be fit in one transaction, just
+                * leave it in the original MDT */
+               if (rc == -E2BIG)
+                       GOTO(stop_trans, rc = 0);
+               else
+                       GOTO(stop_trans, rc);
+       }
 
-       if (lname == NULL || pfid == NULL)
-               return -EINVAL;
+       CDEBUG(D_INFO, "%s: update "DFID"/"DFID" with %s:"DFID"\n",
+              mdd2obd_dev(mdd)->obd_name, PFID(mdd_object_fid(mdd_pobj)),
+              PFID(mdd_object_fid(mdd_sobj)), lname->ln_name,
+              PFID(mdd_object_fid(mdd_tobj)));
 
-       /* Make sure our buf is big enough for the new one */
-       if (ldata->ml_leh->leh_reccount > LINKEA_MAX_COUNT)
-               return -EOVERFLOW;
+       rc = mdd_trans_start(env, mdd, handle);
+       if (rc != 0)
+               GOTO(stop_trans, rc);
 
-       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;
+       /* Revert IMMUTABLE flag */
+       la_flag->la_valid = LA_FLAGS;
+       la_flag->la_flags = so_attr->la_flags & ~LUSTRE_IMMUTABLE_FL;
+       rc = mdo_attr_set(env, mdd_sobj, la_flag, handle);
+       if (rc != 0)
+               GOTO(stop_trans, rc);
+
+       /* Remove source name from source directory */
+       rc = __mdd_index_delete(env, mdd_pobj, name, is_dir, handle);
+       if (rc != 0)
+               GOTO(stop_trans, rc);
+
+       rc = mdd_update_linkea(env, mdd_pobj, mdd_sobj, mdd_tobj,
+                              handle, lname);
+       if (rc != 0)
+               GOTO(stop_trans, rc);
+
+       if (S_ISREG(so_attr->la_mode)) {
+               if (so_attr->la_nlink == 1) {
+                       rc = mdo_xattr_del(env, mdd_sobj, XATTR_NAME_LOV,
+                                          handle);
+                       if (rc != 0 && rc != -ENODATA)
+                               GOTO(stop_trans, rc);
+               }
        }
 
-       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;
-}
+       /* Insert new fid with target name into target dir */
+       rc = __mdd_index_insert(env, mdd_pobj, mdd_object_fid(mdd_tobj),
+                               mdd_object_type(mdd_tobj), name, handle);
+       if (rc != 0)
+               GOTO(stop_trans, rc);
 
-/** 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);
+       rc = mdd_links_add(env, mdd_tobj, mdo2fid(mdd_pobj), lname, handle,
+                          NULL, 1);
+       if (rc != 0)
+               GOTO(stop_trans, rc);
 
-       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);
+       mdd_write_lock(env, mdd_sobj, MOR_SRC_CHILD);
+       mdo_ref_del(env, mdd_sobj, handle);
+       if (is_dir)
+               mdo_ref_del(env, mdd_sobj, handle);
 
-}
+       /* Get the attr again after ref_del */
+       rc = mdd_la_get(env, mdd_sobj, so_attr);
+       if (rc != 0)
+               GOTO(out_unlock, rc);
 
-/**
- * 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);
-       }
+       ma->ma_attr = *so_attr;
+       ma->ma_valid |= MA_INODE;
+       rc = mdd_finish_unlink(env, mdd_sobj, ma, mdd_pobj, lname, handle);
+       if (rc != 0)
+               GOTO(out_unlock, rc);
 
-       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;
+       rc = mdd_attr_set_internal(env, mdd_pobj, p_la, handle, 0);
+       if (rc != 0)
+               GOTO(out_unlock, rc);
+
+out_unlock:
+       mdd_write_unlock(env, mdd_sobj);
+
+stop_trans:
+       mdd_trans_stop(env, mdd, rc, handle);
+
+       RETURN(rc);
 }
 
-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)
+/**
+ * Check whether we should migrate the file/dir
+ * return val
+ *     < 0  permission check failed or other error.
+ *     = 0  the file can be migrated.
+ *     > 0  the file does not need to be migrated, mostly
+ *          for multiple link file
+ **/
+static int mdd_migrate_sanity_check(const struct lu_env *env,
+                                   struct mdd_object *pobj,
+                                   const struct lu_attr *pattr,
+                                   struct mdd_object *sobj,
+                                   struct lu_attr *sattr)
 {
-       int rc;
+       struct mdd_thread_info  *info = mdd_env_info(env);
+       struct linkea_data      *ldata = &info->mti_link_data;
+       int                     mgr_easize;
+       struct lu_buf           *mgr_buf;
+       int                     count;
+       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;
+       ENTRY;
+
+       mgr_easize = lmv_mds_md_size(2, LMV_MAGIC_V1);
+       mgr_buf = lu_buf_check_and_alloc(&info->mti_big_buf, mgr_easize);
+       if (mgr_buf->lb_buf == NULL)
+               RETURN(-ENOMEM);
+
+       rc = mdo_xattr_get(env, sobj, mgr_buf, XATTR_NAME_LMV);
+       if (rc > 0) {
+               union lmv_mds_md *lmm = mgr_buf->lb_buf;
+
+               /* If the object has migrateEA, it means IMMUTE flag
+                * is being set by previous migration process, so it
+                * needs to override the IMMUTE flag, otherwise the
+                * following sanity check will fail */
+               if (le32_to_cpu(lmm->lmv_md_v1.lmv_hash_type) &
+                                               LMV_HASH_FLAG_MIGRATION) {
+                       struct mdd_device *mdd = mdo2mdd(&sobj->mod_obj);
+
+                       sattr->la_flags &= ~LUSTRE_IMMUTABLE_FL;
+                       CDEBUG(D_HA, "%s: "DFID" override IMMUTE FLAG\n",
+                              mdd2obd_dev(mdd)->obd_name,
+                              PFID(mdd_object_fid(sobj)));
                }
        }
 
-       if (check) {
-               rc = mdd_links_find(env, mdd_obj, ldata, lname, pfid);
-               if (rc && rc != -ENOENT)
-                       return rc;
-               if (rc == 0)
-                       return -EEXIST;
+       rc = mdd_rename_sanity_check(env, pobj, pattr, pobj, pattr,
+                                    sobj, sattr, NULL, NULL);
+       if (rc != 0)
+               RETURN(rc);
+
+       /* Then it will check if the file should be migrated. If the file
+        * has mulitple links, we only need migrate the file if all of its
+        * entries has been migrated to the remote MDT */
+       if (!S_ISREG(sattr->la_mode) || sattr->la_nlink < 2)
+               RETURN(0);
+
+       rc = mdd_links_read(env, sobj, ldata);
+       if (rc != 0) {
+               /* For multiple links files, if there are no linkEA data at all,
+                * means the file might be created before linkEA is enabled, and
+                * all all of its links should not be migrated yet, otherwise
+                * it should have some linkEA there */
+               if (rc == -ENOENT || rc == -ENODATA)
+                       RETURN(1);
+               RETURN(rc);
        }
 
-       return mdd_links_add_buf(env, ldata, lname, pfid);
-}
+       /* If it is mulitple links file, we need update the name entry for
+        * all parent */
+       LASSERT(ldata->ld_leh != NULL);
+       ldata->ld_lee = (struct link_ea_entry *)(ldata->ld_leh + 1);
+       for (count = 0; count < ldata->ld_leh->leh_reccount; count++) {
+               struct mdd_device       *mdd = mdo2mdd(&sobj->mod_obj);
+               struct mdd_object       *lpobj;
+               struct lu_name          lname;
+               struct lu_fid           fid;
+
+               linkea_entry_unpack(ldata->ld_lee, &ldata->ld_reclen,
+                                   &lname, &fid);
+               ldata->ld_lee = (struct link_ea_entry *)((char *)ldata->ld_lee +
+                                                        ldata->ld_reclen);
+               lpobj = mdd_object_find(env, mdd, &fid);
+               if (IS_ERR(lpobj)) {
+                       CWARN("%s: cannot find obj "DFID": rc = %ld\n",
+                             mdd2obd_dev(mdd)->obd_name, PFID(&fid),
+                             PTR_ERR(lpobj));
+                       continue;
+               }
 
-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 (!mdd_object_exists(lpobj) || mdd_object_remote(lpobj)) {
+                       CDEBUG(D_INFO, DFID"%.*s: is on remote MDT.\n",
+                              PFID(&fid), lname.ln_namelen, lname.ln_name);
+                       mdd_object_put(env, lpobj);
+                       continue;
+               }
 
-       if (ldata->ml_leh == NULL) {
-               rc = mdd_links_read(env, mdd_obj, ldata);
-               if (rc)
-                       return rc;
+               CDEBUG(D_INFO, DFID"still has local entry %.*s "DFID"\n",
+                      PFID(mdd_object_fid(sobj)), lname.ln_namelen,
+                      lname.ln_name, PFID(&fid));
+               mdd_object_put(env, lpobj);
+               rc = 1;
+               break;
        }
 
-       rc = mdd_links_find(env, mdd_obj, ldata, lname, pfid);
-       if (rc)
-               return rc;
-
-       mdd_links_del_buf(env, ldata, lname);
-       return 0;
+       RETURN(rc);
 }
 
-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_migrate(const struct lu_env *env, struct md_object *pobj,
+                      struct md_object *sobj, const struct lu_name *lname,
+                      struct md_object *tobj, struct md_attr *ma)
 {
-       struct mdd_link_data ldata = { 0 };
-       int updated = 0;
-       int rc2 = 0;
-       int rc = 0;
+       struct mdd_object       *mdd_pobj = md2mdd_obj(pobj);
+       struct mdd_device       *mdd = mdo2mdd(pobj);
+       struct mdd_object       *mdd_sobj = md2mdd_obj(sobj);
+       struct mdd_object       *mdd_tobj = NULL;
+       struct lu_attr          *so_attr = MDD_ENV_VAR(env, cattr);
+       struct lu_attr          *pattr = MDD_ENV_VAR(env, pattr);
+       int                     rc;
+
        ENTRY;
+       /* If the file will being migrated, it will check whether
+        * the file is being opened by someone else right now */
+       mdd_read_lock(env, mdd_sobj, MOR_SRC_CHILD);
+       if (mdd_sobj->mod_count >= 1) {
+               CERROR("%s: "DFID"%s is already opened count %d: rc = %d\n",
+                      mdd2obd_dev(mdd)->obd_name,
+                      PFID(mdd_object_fid(mdd_sobj)), lname->ln_name,
+                      mdd_sobj->mod_count, -EBUSY);
+               mdd_read_unlock(env, mdd_sobj);
+               GOTO(put, rc = -EBUSY);
+       }
+       mdd_read_unlock(env, mdd_sobj);
 
-       LASSERT(oldpfid != NULL || newpfid != NULL);
+       rc = mdd_la_get(env, mdd_sobj, so_attr);
+       if (rc != 0)
+               GOTO(put, rc);
 
-       if (mdd_obj->mod_flags & DEAD_OBJ)
-               /* No more links, don't bother */
-               RETURN(0);
+       rc = mdd_la_get(env, mdd_pobj, pattr);
+       if (rc != 0)
+               GOTO(put, rc);
 
-       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 = mdd_migrate_sanity_check(env, mdd_pobj, pattr, mdd_sobj, so_attr);
+       if (rc != 0) {
+               if (rc > 0)
                        rc = 0;
-               } else {
-                       updated = 1;
-               }
+               GOTO(put, 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;
-               else if (rc2 == 0)
-                       updated = 1;
-       }
+       /* Sigh, it is impossible to finish all of migration in a single
+        * transaction, for example migrating big directory entries to the
+        * new MDT, it needs insert all of name entries of children in the
+        * new directory.
+        *
+        * So migration will be done in multiple steps and transactions.
+        *
+        * 1. create an orphan object on the remote MDT in one transaction.
+        * 2. migrate extend attributes to the new target file/directory.
+        * 3. For directory, migrate the entries to the new MDT and update
+        * linkEA of each children. Because we can not migrate all entries
+        * in a single transaction, so the migrating directory will become
+        * a striped directory during migration, so once the process is
+        * interrupted, the directory is still accessible. (During lookup,
+        * client will locate the name by searching both original and target
+        * object).
+        * 4. Finally, update the name/FID to point to the new file/directory
+        * in a separate transaction.
+        */
 
-       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)));
+       /* step 1: Check whether the orphan object has been created, and create
+        * orphan object on the remote MDT if needed */
+       mdd_tobj = md2mdd_obj(tobj);
+       if (!mdd_object_exists(mdd_tobj)) {
+               rc = mdd_migrate_create(env, mdd_pobj, mdd_sobj, mdd_tobj,
+                                       lname, so_attr);
+               if (rc != 0)
+                       GOTO(put, rc);
        }
 
-       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);
-
-       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);
-}
+       /* step 2: migrate xattr */
+       rc = mdd_migrate_xattrs(env, mdd_sobj, mdd_tobj);
+       if (rc != 0)
+               GOTO(put, rc);
+
+       /* step 3: migrate name entries to the orphan object */
+       if (S_ISDIR(lu_object_attr(&mdd_sobj->mod_obj.mo_lu))) {
+               rc = mdd_migrate_entries(env, mdd_sobj, mdd_tobj);
+               if (rc != 0)
+                       GOTO(put, rc);
+               if (unlikely(OBD_FAIL_CHECK_RESET(OBD_FAIL_MIGRATE_NET_REP,
+                                                 OBD_FAIL_MDS_REINT_NET_REP)))
+                       GOTO(put, rc = 0);
+       } else {
+               OBD_FAIL_TIMEOUT(OBD_FAIL_MIGRATE_DELAY, cfs_fail_val);
+       }
 
-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);
+       /* step 4: update name entry to the new object */
+       rc = mdd_migrate_update_name(env, mdd_pobj, mdd_sobj, mdd_tobj, lname,
+                                    ma);
+       if (rc != 0)
+               GOTO(put, rc);
+put:
+       RETURN(rc);
 }
 
 const struct md_dir_operations mdd_dir_ops = {
-        .mdo_is_subdir     = mdd_is_subdir,
-        .mdo_lookup        = mdd_lookup,
-        .mdo_create        = mdd_create,
-        .mdo_rename        = mdd_rename,
-        .mdo_link          = mdd_link,
-        .mdo_unlink        = mdd_unlink,
-        .mdo_create_data   = mdd_create_data,
+       .mdo_is_subdir     = mdd_is_subdir,
+       .mdo_lookup        = mdd_lookup,
+       .mdo_create        = mdd_create,
+       .mdo_rename        = mdd_rename,
+       .mdo_link          = mdd_link,
+       .mdo_unlink        = mdd_unlink,
+       .mdo_create_data   = mdd_create_data,
+       .mdo_migrate       = mdd_migrate,
 };