Whamcloud - gitweb
LU-5710 all: second batch of corrected typos and grammar errors
[fs/lustre-release.git] / lustre / mdd / mdd_dir.c
index 1bc386a..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, 2013, Intel Corporation.
+ * Copyright (c) 2011, 2014, Intel Corporation.
  */
 /*
  * This file is part of Lustre, http://www.lustre.org/
@@ -57,6 +57,17 @@ static struct lu_name lname_dotdot = {
         sizeof(dotdot) - 1
 };
 
+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(const struct lu_env *env, struct md_object *pobj,
@@ -81,26 +92,15 @@ __mdd_lookup(const struct lu_env *env, struct md_object *pobj,
                RETURN(-ESTALE);
        }
 
-       /* 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, 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 = 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
+                  dt_try_as_dir(env, dir)))
+               rc = dt_lookup(env, dir, (struct dt_rec *)fid, key);
+       else
                rc = -ENOTDIR;
 
        RETURN(rc);
@@ -114,11 +114,12 @@ int mdd_lookup(const struct lu_env *env,
         int rc;
         ENTRY;
 
-       rc = mdd_la_get(env, md2mdd_obj(pobj), pattr, BYPASS_CAPA);
+       rc = mdd_la_get(env, md2mdd_obj(pobj), pattr);
        if (rc != 0)
                RETURN(rc);
 
-       rc = __mdd_lookup(env, pobj, pattr, lname, fid, MAY_EXEC);
+       rc = __mdd_lookup(env, pobj, pattr, lname, fid,
+                         (spec != NULL && spec->sp_permitted) ? 0 : MAY_EXEC);
         RETURN(rc);
 }
 
@@ -169,8 +170,7 @@ 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);
+               /* this is done recursively */
                rc = mdd_parent_fid(env, p1, attr, pfid);
                if (rc)
                        GOTO(out, rc);
@@ -205,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;
@@ -223,7 +223,7 @@ int mdd_is_subdir(const struct lu_env *env, struct md_object *mo,
        if (!S_ISDIR(mdd_object_type(md2mdd_obj(mo))))
                RETURN(0);
 
-       rc = mdd_la_get(env, md2mdd_obj(mo), attr, BYPASS_CAPA);
+       rc = mdd_la_get(env, md2mdd_obj(mo), attr);
        if (rc != 0)
                RETURN(rc);
 
@@ -253,41 +253,55 @@ 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);
+       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);
 }
 
+/**
+ * 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)
 {
@@ -296,26 +310,34 @@ static int __mdd_may_link(const struct lu_env *env, struct mdd_object *obj,
 
        LASSERT(la != NULL);
 
-       if (!S_ISDIR(la->la_mode))
-               RETURN(0);
-
-       /*
-        * Subdir count limitation can be broken through.
-        */
-       if (la->la_nlink >= m->mdd_dt_conf.ddp_max_nlink)
+       /* 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);
-       else
-               RETURN(0);
+
+       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, const struct lu_attr *pattr,
-                  struct mdd_object *cobj, int check_perm, int check_nlink)
+int mdd_may_create(const struct lu_env *env, struct mdd_object *pobj,
+                  const struct lu_attr *pattr, struct mdd_object *cobj,
+                  bool check_perm)
 {
+       struct mdd_thread_info *info = mdd_env_info(env);
+       struct lu_buf   *xbuf;
        int rc = 0;
        ENTRY;
 
@@ -325,13 +347,22 @@ int mdd_may_create(const struct lu_env *env,
        if (mdd_is_dead_obj(pobj))
                RETURN(-ENOENT);
 
+       /* 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;
+
+               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);
-       if (!rc && check_nlink)
-               rc = __mdd_may_link(env, pobj, pattr);
-
        RETURN(rc);
 }
 
@@ -347,17 +378,16 @@ int mdd_may_unlink(const struct lu_env *env, struct mdd_object *pobj,
        if (mdd_is_dead_obj(pobj))
                RETURN(-ENOENT);
 
-       if ((attr->la_valid & LA_FLAGS) &&
-           (attr->la_flags & (LUSTRE_APPEND_FL | LUSTRE_IMMUTABLE_FL)))
+       if (attr->la_flags & (LUSTRE_APPEND_FL | LUSTRE_IMMUTABLE_FL))
                RETURN(-EPERM);
 
        rc = mdd_permission_internal_locked(env, pobj, pattr,
                                            MAY_WRITE | MAY_EXEC,
                                            MOR_TGT_PARENT);
-       if (rc)
+       if (rc != 0)
                RETURN(rc);
 
-       if (mdd_is_append(pobj))
+       if (pattr->la_flags & LUSTRE_APPEND_FL)
                RETURN(-EPERM);
 
        RETURN(rc);
@@ -412,7 +442,7 @@ static int mdd_may_delete_entry(const struct lu_env *env,
                        RETURN(rc);
        }
 
-       if (mdd_is_append(pobj))
+       if (pattr->la_flags & LUSTRE_APPEND_FL)
                RETURN(-EPERM);
 
        RETURN(0);
@@ -449,11 +479,7 @@ int mdd_may_delete(const struct lu_env *env, struct mdd_object *tpobj,
        if (mdd_is_sticky(env, tpobj, tpattr, tobj, tattr))
                RETURN(-EPERM);
 
-       if (mdd_is_immutable(tobj) || mdd_is_append(tobj))
-               RETURN(-EPERM);
-
-       if ((tattr->la_valid & LA_FLAGS) &&
-           (tattr->la_flags & (LUSTRE_APPEND_FL | LUSTRE_IMMUTABLE_FL)))
+       if (tattr->la_flags & (LUSTRE_APPEND_FL | LUSTRE_IMMUTABLE_FL))
                RETURN(-EPERM);
 
        /* additional check the rename case */
@@ -476,9 +502,20 @@ int mdd_may_delete(const struct lu_env *env, struct mdd_object *tpobj,
        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
  */
 static int mdd_link_sanity_check(const struct lu_env *env,
                                 struct mdd_object *tgt_obj,
@@ -498,21 +535,20 @@ static 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, tattr, NULL, 1, 0);
-               if (rc)
-                       RETURN(rc);
-       }
+       rc = mdd_may_create(env, tgt_obj, tattr, NULL, true);
+       if (rc != 0)
+               RETURN(rc);
 
        rc = __mdd_may_link(env, src_obj, cattr);
 
@@ -520,42 +556,41 @@ static int mdd_link_sanity_check(const struct lu_env *env,
 }
 
 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;
        }
@@ -564,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);
@@ -597,52 +633,37 @@ static int __mdd_index_delete(const struct lu_env *env, struct mdd_object *pobj,
         RETURN(rc);
 }
 
-int mdd_declare_changelog_store(const struct lu_env *env,
-                               struct mdd_device *mdd,
-                               const struct lu_name *fname,
-                               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)
 {
-       struct obd_device               *obd = mdd2obd_dev(mdd);
-       struct llog_ctxt                *ctxt;
-       struct llog_changelog_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) +
-                              (fname != NULL ? fname->ln_namelen : 0));
-       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_hdr.lrh_len = reclen;
-       rec->cr_hdr.lrh_type = CHANGELOG_REC;
+       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);
 
-       ctxt = llog_get_context(obd, LLOG_CHANGELOG_ORIG_CTXT);
-       if (ctxt == NULL)
-               return -ENXIO;
+       if (sname != NULL)
+               crf |= CLF_RENAME;
 
-       rc = llog_declare_add(env, ctxt->loc_handle, &rec->cr_hdr, handle);
-       llog_ctxt_put(ctxt);
+       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));
 }
 
-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)
+int mdd_declare_changelog_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 llog_changelog_rec       *rec;
        struct lu_buf                   *buf;
+       struct thandle                  *llog_th;
        int                              reclen;
        int                              rc;
 
@@ -650,9 +671,7 @@ static int mdd_declare_changelog_ext_store(const struct lu_env *env,
        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));
+       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;
@@ -665,7 +684,13 @@ static int mdd_declare_changelog_ext_store(const struct lu_env *env,
        if (ctxt == NULL)
                return -ENXIO;
 
-       rc = llog_declare_add(env, ctxt->loc_handle, &rec->cr_hdr, handle);
+       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));
+
+       rc = llog_declare_add(env, ctxt->loc_handle, &rec->cr_hdr, llog_th);
+
+out_put:
        llog_ctxt_put(ctxt);
 
        return rc;
@@ -675,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,
@@ -683,46 +708,12 @@ 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_type = CHANGELOG_REC;
-       rec->cr.cr_time = cl_time();
-
-       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);
-
-       ctxt = llog_get_context(obd, LLOG_CHANGELOG_ORIG_CTXT);
-       if (ctxt == NULL)
-               return -ENXIO;
-
-       rc = llog_add(env, ctxt->loc_handle, &rec->cr_hdr, NULL, NULL, th);
-       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)
-{
-       struct obd_device       *obd = mdd2obd_dev(mdd);
-       struct llog_ctxt        *ctxt;
-       int                      rc;
+       rec->cr_hdr.lrh_len = llog_data_len(sizeof(*rec) +
+                                           changelog_rec_varsize(&rec->cr));
 
-       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();
@@ -738,72 +729,50 @@ int mdd_changelog_ext_store(const struct lu_env *env, struct mdd_device *mdd,
        if (ctxt == NULL)
                return -ENXIO;
 
+       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, NULL, th);
+       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;
 }
 
-/** 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
- */
-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);
+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 changelog_ext_rename     *rnm = changelog_rec_rename(rec);
+       size_t                           extsize = sname->ln_namelen + 1;
 
-       LASSERT(target != NULL);
-       LASSERT(parent != NULL);
-       LASSERT(tname != NULL);
-       LASSERT(handle != NULL);
+       LASSERT(sfid != NULL);
+       LASSERT(spfid != NULL);
+       LASSERT(sname != NULL);
 
-       reclen = llog_data_len(sizeof(*rec) + tname->ln_namelen);
-       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;
+       rnm->cr_sfid = *sfid;
+       rnm->cr_spfid = *spfid;
 
-       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);
+       changelog_rec_name(rec)[rec->cr_namelen] = '\0';
+       strlcpy(changelog_rec_sname(rec), sname->ln_name, extsize);
+       rec->cr_namelen += extsize;
+}
 
-       target->mod_cltime = cfs_time_current_64();
+void mdd_changelog_rec_ext_jobid(struct changelog_rec *rec, const char *jobid)
+{
+       struct changelog_ext_jobid      *jid = changelog_rec_jobid(rec);
 
-       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);
-       }
+       if (jobid == NULL || jobid[0] == '\0')
+               return;
 
-       RETURN(0);
+       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.
@@ -815,55 +784,63 @@ int mdd_changelog_ns_store(const struct lu_env *env, struct mdd_device *mdd,
  * \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)
-{
-       struct llog_changelog_ext_rec *rec;
-       struct lu_buf *buf;
-       int reclen;
-       int rc;
+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)
+{
+       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);
+       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);
@@ -872,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));
@@ -1006,7 +983,6 @@ int mdd_links_rename(const struct lu_env *env,
                     struct linkea_data *ldata,
                     int first, int check)
 {
-       int rc2 = 0;
        int rc = 0;
        ENTRY;
 
@@ -1024,9 +1000,7 @@ int mdd_links_rename(const struct lu_env *env,
                rc = mdd_links_write(env, mdd_obj, ldata, handle);
        EXIT;
 out:
-       if (rc == 0)
-               rc = rc2;
-       if (rc) {
+       if (rc != 0) {
                int error = 1;
                if (rc == -EOVERFLOW || rc == -ENOSPC)
                        error = 0;
@@ -1061,10 +1035,10 @@ static inline int mdd_links_add(const struct lu_env *env,
                                const struct lu_fid *pfid,
                                const struct lu_name *lname,
                                struct thandle *handle,
-                               struct linkea_data *data, int first)
+                               struct linkea_data *ldata, int first)
 {
        return mdd_links_rename(env, mdd_obj, NULL, NULL,
-                               pfid, lname, handle, data, first, 0);
+                               pfid, lname, handle, ldata, first, 0);
 }
 
 static inline int mdd_links_del(const struct lu_env *env,
@@ -1098,20 +1072,19 @@ int mdd_links_read(const struct lu_env *env, struct mdd_object *mdd_obj,
        if (ldata->ld_buf->lb_buf == NULL)
                return -ENOMEM;
 
-       rc = mdo_xattr_get(env, mdd_obj, ldata->ld_buf, XATTR_NAME_LINK,
-                         BYPASS_CAPA);
+       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, BYPASS_CAPA);
+                                  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, BYPASS_CAPA);
+                                 XATTR_NAME_LINK);
        }
        if (rc < 0) {
                lu_buf_free(ldata->ld_buf);
@@ -1130,7 +1103,7 @@ int mdd_links_read(const struct lu_env *env, struct mdd_object *mdd_obj,
 struct lu_buf *mdd_links_get(const struct lu_env *env,
                             struct mdd_object *mdd_obj)
 {
-       struct linkea_data ldata = { 0 };
+       struct linkea_data ldata = { NULL };
        int rc;
 
        rc = mdd_links_read(env, mdd_obj, &ldata);
@@ -1142,12 +1115,38 @@ int mdd_links_write(const struct lu_env *env, struct mdd_object *mdd_obj,
 {
        const struct lu_buf *buf = mdd_buf_get_const(env, ldata->ld_buf->lb_buf,
                                                     ldata->ld_leh->leh_len);
-       return mdo_xattr_set(env, mdd_obj, buf, XATTR_NAME_LINK, 0, handle,
-                            mdd_object_capa(env, mdd_obj));
+       int                 rc;
+
+       if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_NO_LINKEA))
+               return 0;
+
+       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);
+       }
+
+       return rc;
 }
 
 int mdd_declare_links_add(const struct lu_env *env, struct mdd_object *mdd_obj,
-                         struct thandle *handle, struct linkea_data *ldata)
+                         struct thandle *handle, struct linkea_data *ldata,
+                         enum mdd_links_add_overflow overflow)
 {
        int     rc;
        int     ea_len;
@@ -1165,6 +1164,29 @@ int mdd_declare_links_add(const struct lu_env *env, struct mdd_object *mdd_obj,
        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;
+
+       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;
 }
 
@@ -1177,29 +1199,36 @@ static inline int mdd_declare_links_del(const struct lu_env *env,
        /* 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);
+               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 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;
+       int rc;
 
-        rc = mdo_declare_index_insert(env, p, mdo2fid(c), name->ln_name,handle);
-        if (rc)
-                return 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)
-                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);
@@ -1208,16 +1237,17 @@ static int mdd_declare_link(const struct lu_env *env,
 
        la->la_valid = LA_CTIME;
        rc = mdo_declare_attr_set(env, c, la, handle);
-        if (rc)
-                return rc;
+       if (rc != 0)
+               return rc;
 
-       rc = mdd_declare_links_add(env, c, handle, data);
-        if (rc)
-                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, handle);
+       rc = mdd_declare_changelog_store(env, mdd, name, NULL, handle);
 
-        return rc;
+       return rc;
 }
 
 static int mdd_link(const struct lu_env *env, struct md_object *tgt_obj,
@@ -1236,11 +1266,11 @@ static int mdd_link(const struct lu_env *env, struct md_object *tgt_obj,
        int rc;
        ENTRY;
 
-       rc = mdd_la_get(env, mdd_sobj, cattr, BYPASS_CAPA);
+       rc = mdd_la_get(env, mdd_sobj, cattr);
        if (rc != 0)
                RETURN(rc);
 
-       rc = mdd_la_get(env, mdd_tobj, tattr, BYPASS_CAPA);
+       rc = mdd_la_get(env, mdd_tobj, tattr);
        if (rc != 0)
                RETURN(rc);
 
@@ -1268,14 +1298,31 @@ static int mdd_link(const struct lu_env *env, struct md_object *tgt_obj,
        if (rc)
                GOTO(out_unlock, rc);
 
-       rc = mdo_ref_add(env, mdd_sobj, handle);
-       if (rc)
-               GOTO(out_unlock, 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);
+       }
 
+       if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_MORE_NLINK)) {
+               rc = mdo_ref_add(env, mdd_sobj, handle);
+               if (rc != 0)
+                       GOTO(out_unlock, 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 = __mdd_index_insert_only(env, mdd_tobj, mdo2fid(mdd_sobj),
-                                    name, handle,
-                                    mdd_object_capa(env, mdd_tobj));
        if (rc != 0) {
                mdo_ref_del(env, mdd_sobj, handle);
                GOTO(out_unlock, rc);
@@ -1304,7 +1351,8 @@ out_unlock:
         mdd_write_unlock(env, mdd_sobj);
         if (rc == 0)
                rc = mdd_changelog_ns_store(env, mdd, CL_HARDLINK, 0, mdd_sobj,
-                                           mdd_tobj, lname, handle);
+                                           mdo2fid(mdd_tobj), NULL, NULL,
+                                           lname, NULL, handle);
 stop:
        mdd_trans_stop(env, mdd, rc, handle);
 
@@ -1315,23 +1363,57 @@ out_pending:
         return rc;
 }
 
+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;
+
+       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)
+       if (rc != 0)
                return rc;
 
-       return mdo_declare_destroy(env, obj, handle);
+       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,
-                      struct thandle *th)
+                     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);
@@ -1340,7 +1422,9 @@ int mdd_finish_unlink(const struct lu_env *env,
         LASSERT(mdd_write_locked(env, obj) != 0);
 
        if (ma->ma_attr.la_nlink == 0 || is_dir) {
-                obj->mod_flags |= DEAD_OBJ;
+               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() */
@@ -1360,9 +1444,12 @@ int mdd_finish_unlink(const struct lu_env *env,
                 } 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);
+       RETURN(rc);
 }
 
 /*
@@ -1385,20 +1472,25 @@ int mdd_unlink_sanity_check(const struct lu_env *env, struct mdd_object *pobj,
 static int mdd_declare_unlink(const struct lu_env *env, struct mdd_device *mdd,
                              struct mdd_object *p, struct mdd_object *c,
                              const struct lu_name *name, struct md_attr *ma,
-                             struct thandle *handle, int no_name)
+                             struct thandle *handle, int no_name, int is_dir)
 {
-       struct lu_attr     *la = &mdd_env_info(env)->mti_la_for_fix;
-        int rc;
+       struct lu_attr  *la = &mdd_env_info(env)->mti_la_for_fix;
+       int              rc;
 
-       if (likely(no_name == 0)) {
-               rc = mdo_declare_index_delete(env, p, name->ln_name, handle);
-               if (rc)
-                       return 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;
+               }
 
-        rc = mdo_declare_ref_del(env, p, handle);
-        if (rc)
-                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;
@@ -1425,12 +1517,8 @@ static int mdd_declare_unlink(const struct lu_env *env, struct mdd_device *mdd,
                if (rc)
                        return rc;
 
-               rc = mdd_declare_links_del(env, c, handle);
-               if (rc != 0)
-                       return rc;
-
                /* FIXME: need changelog for remove entry */
-               rc = mdd_declare_changelog_store(env, mdd, name, handle);
+               rc = mdd_declare_changelog_store(env, mdd, name, NULL, handle);
        }
 
        return rc;
@@ -1455,8 +1543,7 @@ static bool mdd_hsm_archive_exists(const struct lu_env *env,
 
                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,
-                                  mdd_object_capa(env, obj));
+               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)
@@ -1500,13 +1587,13 @@ static int mdd_unlink(const struct lu_env *env, struct md_object *pobj,
                        RETURN(-ENOENT);
        }
 
-       rc = mdd_la_get(env, mdd_pobj, pattr, BYPASS_CAPA);
+       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, BYPASS_CAPA);
+               rc = mdd_la_get(env, mdd_cobj, cattr);
                if (rc)
                        RETURN(rc);
 
@@ -1522,7 +1609,7 @@ static int mdd_unlink(const struct lu_env *env, struct md_object *pobj,
                RETURN(PTR_ERR(handle));
 
        rc = mdd_declare_unlink(env, mdd, mdd_pobj, mdd_cobj,
-                               lname, ma, handle, no_name);
+                               lname, ma, handle, no_name, is_dir);
        if (rc)
                GOTO(stop, rc);
 
@@ -1533,20 +1620,23 @@ static int mdd_unlink(const struct lu_env *env, struct md_object *pobj,
        if (likely(mdd_cobj != NULL))
                mdd_write_lock(env, mdd_cobj, MOR_TGT_CHILD);
 
-       if (likely(no_name == 0)) {
-               rc = __mdd_index_delete(env, mdd_pobj, name, is_dir, handle,
-                                       mdd_object_capa(env, mdd_pobj));
+       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),
-                                               name, handle,
-                                               mdd_object_capa(env, mdd_pobj));
+                                               mdd_object_type(mdd_cobj),
+                                               name, handle);
                        GOTO(cleanup, rc);
                }
 
@@ -1555,7 +1645,7 @@ static int mdd_unlink(const struct lu_env *env, struct md_object *pobj,
                        mdo_ref_del(env, mdd_cobj, handle);
 
                /* fetch updated nlink */
-               rc = mdd_la_get(env, mdd_cobj, cattr, BYPASS_CAPA);
+               rc = mdd_la_get(env, mdd_cobj, cattr);
                if (rc)
                        GOTO(cleanup, rc);
        }
@@ -1584,15 +1674,11 @@ static int mdd_unlink(const struct lu_env *env, struct md_object *pobj,
        /* 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, BYPASS_CAPA);
-
-       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) {
@@ -1601,7 +1687,9 @@ static int mdd_unlink(const struct lu_env *env, struct md_object *pobj,
        }
        EXIT;
 cleanup:
-       mdd_write_unlock(env, mdd_cobj);
+       if (likely(mdd_cobj != NULL))
+               mdd_write_unlock(env, mdd_cobj);
+
        if (rc == 0) {
                int cl_flags = 0;
 
@@ -1614,7 +1702,8 @@ cleanup:
 
                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:
@@ -1665,7 +1754,7 @@ 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, BYPASS_CAPA);
+       rc = mdd_la_get(env, son, attr);
        if (rc)
                RETURN(rc);
 
@@ -1696,7 +1785,7 @@ static int mdd_create_data(const struct lu_env *env, struct md_object *pobj,
        if (rc)
                GOTO(stop, rc);
 
-       rc = mdd_declare_changelog_store(env, mdd, NULL, handle);
+       rc = mdd_declare_changelog_store(env, mdd, NULL, NULL, handle);
        if (rc)
                GOTO(stop, rc);
 
@@ -1705,7 +1794,7 @@ static int mdd_create_data(const struct lu_env *env, struct md_object *pobj,
                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);
@@ -1724,7 +1813,7 @@ static int mdd_declare_object_initialize(const struct lu_env *env,
                                         struct lu_attr *attr,
                                         struct thandle *handle)
 {
-        int rc;
+       int rc;
        ENTRY;
 
        /*
@@ -1737,15 +1826,20 @@ static int mdd_declare_object_initialize(const struct lu_env *env,
        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)) {
-               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 || !S_ISDIR(attr->la_mode))
+               RETURN(rc);
 
-               rc = mdo_declare_index_insert(env, child, mdo2fid(parent),
-                                             dotdot, handle);
-        }
+       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);
 }
@@ -1756,36 +1850,41 @@ static int mdd_object_initialize(const struct lu_env *env,
                                 struct lu_attr *attr, struct thandle *handle,
                                 const struct md_op_spec *spec)
 {
-        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 = 0;
+       ENTRY;
 
-       rc = mdd_attr_set_internal(env, child, attr, handle, 0);
-       /* arguments are supposed to stay the same */
        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);
-        }
+                                            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);
 }
 
-/* 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,
                                   const struct lu_attr *pattr,
@@ -1793,12 +1892,13 @@ static int mdd_create_sanity_check(const struct lu_env *env,
                                   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 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))
@@ -1817,20 +1917,17 @@ static int mdd_create_sanity_check(const struct lu_env *env,
                  */
                rc = __mdd_lookup(env, pobj, pattr, 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);
+               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) {
                cattr->la_gid = pattr->la_gid;
@@ -1840,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;
@@ -1958,18 +2059,19 @@ static int mdd_declare_create(const struct lu_env *env, struct mdd_device *mdd,
                        GOTO(out, rc);
        }
 
-       if (spec->sp_cr_flags & MDS_OPEN_VOLATILE) {
+       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), name->ln_name,
-                                             handle);
-               if (rc)
+               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);
+
+               rc = mdd_declare_links_add(env, c, handle, ldata, MLAO_IGNORE);
                if (rc)
                        return rc;
 
@@ -1978,18 +2080,11 @@ static int mdd_declare_create(const struct lu_env *env, struct mdd_device *mdd,
                rc = mdo_declare_attr_set(env, p, la, handle);
                if (rc)
                        return rc;
-       }
-
-        rc = mdd_declare_changelog_store(env, mdd, name, handle);
-        if (rc)
-                return rc;
 
-       /* XXX: For remote create, it should indicate the remote RPC
-        * will be sent after local transaction is finished, which
-        * is not very nice, but it will be removed once we fully support
-        * async update */
-       if (mdd_object_remote(p) && handle->th_update != NULL)
-               handle->th_update->tu_sent_after_local_trans = 1;
+               rc = mdd_declare_changelog_store(env, mdd, name, NULL, handle);
+               if (rc)
+                       return rc;
+       }
 out:
        return rc;
 }
@@ -2009,7 +2104,7 @@ static int mdd_acl_init(const struct lu_env *env, struct mdd_object *pobj,
 
        mdd_read_lock(env, pobj, MOR_TGT_PARENT);
        rc = mdo_xattr_get(env, pobj, def_acl_buf,
-                          XATTR_NAME_ACL_DEFAULT, BYPASS_CAPA);
+                          XATTR_NAME_ACL_DEFAULT);
        mdd_read_unlock(env, pobj);
        if (rc > 0) {
                /* If there are default ACL, fix mode/ACL by default ACL */
@@ -2054,26 +2149,10 @@ static int mdd_object_create(const struct lu_env *env, struct mdd_object *pobj,
        if (rc)
                GOTO(unlock, 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, BYPASS_CAPA);
-               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, BYPASS_CAPA);
-               if (rc)
-                       GOTO(err_destroy, rc);
-       }
-#endif
-
+       /* 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)
@@ -2085,18 +2164,50 @@ static int mdd_object_create(const struct lu_env *env, struct mdd_object *pobj,
         *      MDT calls this xattr_set(LOV) in a different transaction.
         *      probably this way we code can be made better.
         */
-       if (spec->no_create || (spec->sp_cr_flags & MDS_OPEN_HAS_EA &&
-                               S_ISREG(attr->la_mode))) {
+
+       /* 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, XATTR_NAME_LOV, 0, handle,
-                                  BYPASS_CAPA);
+                                       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);
@@ -2107,7 +2218,6 @@ static int mdd_object_create(const struct lu_env *env, struct mdd_object *pobj,
 
                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);
 
@@ -2198,7 +2308,7 @@ 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);
 
@@ -2225,9 +2335,17 @@ static int mdd_create(const struct lu_env *env, struct md_object *pobj,
        mdd_object_make_hint(env, mdd_pobj, son, attr, spec, hint);
 
        memset(ldata, 0, sizeof(*ldata));
-       rc = mdd_linkea_prepare(env, son, NULL, NULL,
-                               mdd_object_fid(mdd_pobj),
-                               lname, 1, 0, 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,
                                handle, spec, ldata, &def_acl_buf, &acl_buf,
@@ -2247,13 +2365,10 @@ static int mdd_create(const struct lu_env *env, struct md_object *pobj,
        if (unlikely(spec->sp_cr_flags & MDS_OPEN_VOLATILE)) {
                mdd_write_lock(env, son, MOR_TGT_CHILD);
                rc = __mdd_orphan_add(env, son, handle);
-               mdd_write_unlock(env, son);
-               if (rc != 0)
-                       GOTO(err_created, rc);
+               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));
+                                       attr->la_mode, name, handle);
                if (rc != 0)
                        GOTO(err_created, rc);
 
@@ -2278,7 +2393,7 @@ err_insert:
                else
                        rc2 = __mdd_index_delete(env, mdd_pobj, name,
                                                 S_ISDIR(attr->la_mode),
-                                                handle, BYPASS_CAPA);
+                                                handle);
                if (rc2 != 0)
                        goto out_stop;
 
@@ -2286,29 +2401,38 @@ err_created:
                mdd_write_lock(env, son, MOR_TGT_CHILD);
                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);
-        }
+       }
 
-       if (rc == 0 && fid_is_namespace_visible(mdo2fid(son)))
+       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:
        rc2 = mdd_trans_stop(env, mdd, rc, handle);
        if (rc == 0)
@@ -2318,11 +2442,11 @@ out_free:
                /* if we vmalloced a large buffer drop it */
                lu_buf_free(ldata->ld_buf);
 
-        /* The child object shouldn't be cached anymore */
-        if (rc)
+       /* 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;
 }
 
 /*
@@ -2396,9 +2520,9 @@ static int mdd_rename_sanity_check(const struct lu_env *env,
         * processed in cld_rename before mdd_rename and enable
         * MDS_PERM_BYPASS).
         * So check may_create, but not check may_unlink. */
-       if (!tobj)
+       if (tobj == NULL)
                rc = mdd_may_create(env, tgt_pobj, tpattr, NULL,
-                                   (src_pobj != tgt_pobj), 0);
+                                   (src_pobj != tgt_pobj));
        else
                rc = mdd_may_delete(env, tgt_pobj, tpattr, tobj, tattr, cattr,
                                    (src_pobj != tgt_pobj), 1);
@@ -2446,21 +2570,22 @@ static int mdd_declare_rename(const struct lu_env *env,
                if (mdd_spobj != mdd_tpobj) {
                        rc = mdo_declare_index_delete(env, mdd_sobj, dotdot,
                                                      handle);
-                       if (rc)
+                       if (rc != 0)
                                return rc;
 
                        rc = mdo_declare_index_insert(env, mdd_sobj,
                                                      mdo2fid(mdd_tpobj),
-                                                     dotdot, handle);
-                       if (rc)
+                                                     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);
@@ -2476,15 +2601,17 @@ static int mdd_declare_rename(const struct lu_env *env,
        if (rc)
                return rc;
 
-       rc = mdd_declare_links_add(env, mdd_sobj, handle, ldata);
+       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
@@ -2517,16 +2644,12 @@ static int mdd_declare_rename(const struct lu_env *env,
                if (rc)
                        return rc;
 
-               rc = mdd_declare_links_del(env, mdd_tobj, 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;
 
@@ -2568,21 +2691,21 @@ static int mdd_rename(const struct lu_env *env,
 
        mdd_sobj = mdd_object_find(env, mdd, lf);
 
-       rc = mdd_la_get(env, mdd_sobj, cattr, BYPASS_CAPA);
+       rc = mdd_la_get(env, mdd_sobj, cattr);
        if (rc)
                GOTO(out_pending, rc);
 
-       rc = mdd_la_get(env, mdd_spobj, pattr, BYPASS_CAPA);
+       rc = mdd_la_get(env, mdd_spobj, pattr);
        if (rc)
                GOTO(out_pending, rc);
 
        if (mdd_tobj) {
-               rc = mdd_la_get(env, mdd_tobj, tattr, BYPASS_CAPA);
+               rc = mdd_la_get(env, mdd_tobj, tattr);
                if (rc)
                        GOTO(out_pending, rc);
        }
 
-       rc = mdd_la_get(env, mdd_tpobj, tpattr, BYPASS_CAPA);
+       rc = mdd_la_get(env, mdd_tpobj, tpattr);
        if (rc)
                GOTO(out_pending, rc);
 
@@ -2591,6 +2714,10 @@ static int mdd_rename(const struct lu_env *env,
        if (rc)
                GOTO(out_pending, rc);
 
+       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));
@@ -2615,21 +2742,19 @@ static int mdd_rename(const struct lu_env *env,
        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);
         }
 
@@ -2637,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 */
@@ -2649,9 +2773,9 @@ 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);
@@ -2687,7 +2811,7 @@ static int mdd_rename(const struct lu_env *env,
                tobj_ref = 1;
 
                /* fetch updated nlink */
-               rc = mdd_la_get(env, mdd_tobj, tattr, BYPASS_CAPA);
+               rc = mdd_la_get(env, mdd_tobj, tattr);
                if (rc != 0) {
                        CERROR("%s: Failed to get nlink for tobj "
                                DFID": rc = %d\n",
@@ -2709,7 +2833,8 @@ static int mdd_rename(const struct lu_env *env,
                /* XXX: this transfer to ma will be removed with LOD/OSP */
                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",
@@ -2719,7 +2844,7 @@ static int mdd_rename(const struct lu_env *env,
                }
 
                /* fetch updated nlink */
-               rc = mdd_la_get(env, mdd_tobj, tattr, BYPASS_CAPA);
+               rc = mdd_la_get(env, mdd_tobj, tattr);
                if (rc != 0) {
                        CERROR("%s: Failed to get nlink for tobj "
                                DFID": rc = %d\n",
@@ -2767,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);
 
@@ -2780,52 +2904,52 @@ 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 && mdd_spobj != mdd_tpobj) {
-               rc2 = __mdd_index_delete_only(env, mdd_sobj, dotdot, handle,
-                                             BYPASS_CAPA);
-
+               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,
-                                             dotdot, handle, BYPASS_CAPA);
-               if (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);
        }
 
 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);
-        }
+       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_ext_ns_store(env, mdd, CL_RENAME, cl_flags,
-                                               mdd_tobj, tpobj_fid, lf,
-                                               spobj_fid, ltname, lsname,
-                                               handle);
+       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);
+       mdd_trans_stop(env, mdd, rc, handle);
+
 out_pending:
        mdd_object_put(env, mdd_sobj);
        return rc;
@@ -2843,7 +2967,7 @@ static int mdd_linkea_update_child_internal(const struct lu_env *env,
                                            bool declare)
 {
        struct mdd_thread_info  *info = mdd_env_info(env);
-       struct linkea_data      ldata = {0};
+       struct linkea_data      ldata = { NULL };
        struct lu_buf           *buf = &info->mti_link_buf;
        int                     count;
        int                     rc = 0;
@@ -2888,7 +3012,8 @@ static int mdd_linkea_update_child_internal(const struct lu_env *env,
                linkea_entry_pack(ldata.ld_lee, &lname,
                                  mdd_object_fid(parent));
                if (declare)
-                       rc = mdd_declare_links_add(env, child, handle, &ldata);
+                       rc = mdd_declare_links_add(env, child, handle, &ldata,
+                                                  MLAO_IGNORE);
                else
                        rc = mdd_links_write(env, child, &ldata, handle);
                break;
@@ -2937,14 +3062,6 @@ static int mdd_update_linkea_internal(const struct lu_env *env,
                RETURN(rc);
        }
 
-       if (declare)
-               rc = mdd_declare_links_add(env, mdd_tobj, handle, ldata);
-       else
-               rc = mdd_links_write(env, mdd_tobj, ldata, handle);
-
-       if (rc != 0)
-               RETURN(rc);
-
        /* If it is mulitple links file, we need update the name entry for
         * all parent */
        LASSERT(ldata->ld_leh != NULL);
@@ -2992,13 +3109,14 @@ static int mdd_update_linkea_internal(const struct lu_env *env,
                        /* Insert new fid with target name into target dir */
                        rc = mdo_declare_index_delete(env, pobj, lname.ln_name,
                                                      handle);
-                       if (rc)
+                       if (rc != 0)
                                GOTO(next_put, rc);
 
                        rc = mdo_declare_index_insert(env, pobj,
-                                                     mdd_object_fid(mdd_tobj),
-                                                     lname.ln_name, handle);
-                       if (rc)
+                                       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);
@@ -3010,16 +3128,15 @@ static int mdd_update_linkea_internal(const struct lu_env *env,
                                GOTO(next_put, rc);
                } else {
                        rc = __mdd_index_delete(env, pobj, lname.ln_name,
-                                               0, handle,
-                                               mdd_object_capa(env, pobj));
+                                               0, handle);
                        if (rc)
                                GOTO(next_put, rc);
 
                        rc = __mdd_index_insert(env, pobj,
-                                               mdd_object_fid(mdd_tobj),
-                                               lname.ln_name, 0, handle,
-                                               mdd_object_capa(env, pobj));
-                       if (rc)
+                                       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);
@@ -3058,8 +3175,7 @@ static int mdd_migrate_xattrs(const struct lu_env *env,
        int                     rc;
 
        /* retrieve xattr list from the old object */
-       list_xsize = mdo_xattr_list(env, mdd_sobj, &LU_BUF_NULL,
-                                   mdd_object_capa(env, mdd_sobj));
+       list_xsize = mdo_xattr_list(env, mdd_sobj, &LU_BUF_NULL);
        if (list_xsize == -ENODATA)
                return 0;
 
@@ -3072,8 +3188,7 @@ static int mdd_migrate_xattrs(const struct lu_env *env,
 
        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,
-                           mdd_object_capa(env, mdd_sobj));
+       rc = mdo_xattr_list(env, mdd_sobj, &list_xbuf);
        if (rc < 0)
                return rc;
        rc = 0;
@@ -3091,9 +3206,7 @@ static int mdd_migrate_xattrs(const struct lu_env *env,
                    !S_ISDIR(lu_object_attr(&mdd_sobj->mod_obj.mo_lu)))
                        goto next;
 
-               xsize = mdo_xattr_get(env, mdd_sobj, &LU_BUF_NULL,
-                                     xname,
-                                     mdd_object_capa(env, mdd_sobj));
+               xsize = mdo_xattr_get(env, mdd_sobj, &LU_BUF_NULL, xname);
                if (xsize == -ENODATA)
                        goto next;
                if (xsize < 0)
@@ -3105,8 +3218,7 @@ static int mdd_migrate_xattrs(const struct lu_env *env,
 
                xbuf.lb_len = xsize;
                xbuf.lb_buf = info->mti_link_buf.lb_buf;
-               rc = mdo_xattr_get(env, mdd_sobj, &xbuf, xname,
-                                  mdd_object_capa(env, mdd_sobj));
+               rc = mdo_xattr_get(env, mdd_sobj, &xbuf, xname);
                if (rc == -ENODATA)
                        goto next;
                if (rc < 0)
@@ -3128,8 +3240,7 @@ static int mdd_migrate_xattrs(const struct lu_env *env,
                if (rc != 0)
                        GOTO(stop_trans, rc);
 
-               rc = mdo_xattr_set(env, mdd_tobj, &xbuf, xname, 0, handle,
-                                  mdd_object_capa(env, mdd_sobj));
+               rc = mdo_xattr_set(env, mdd_tobj, &xbuf, xname, 0, handle);
                if (rc == -EEXIST)
                        GOTO(stop_trans, rc = 0);
 
@@ -3154,6 +3265,7 @@ static int mdd_declare_migrate_create(const struct lu_env *env,
                                      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);
@@ -3181,6 +3293,11 @@ static int mdd_declare_migrate_create(const struct lu_env *env,
                                             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) {
@@ -3192,7 +3309,7 @@ static int mdd_declare_migrate_create(const struct lu_env *env,
                        return rc;
        }
 
-       mgr_easize = lmv_mds_md_size(2, LMV_MAGIC_MIGRATE);
+       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);
@@ -3200,8 +3317,7 @@ static int mdd_declare_migrate_create(const struct lu_env *env,
                return rc;
 
        la_flag->la_valid = LA_FLAGS;
-       la_flag->la_flags = LUSTRE_IMMUTABLE_FL;
-       mdd_flags_xlate(mdd_sobj, la_flag->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;
@@ -3211,18 +3327,21 @@ 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 = { 0 };
-       struct lu_buf           link_buf = { 0 };
+       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;
 
@@ -3236,6 +3355,7 @@ static int mdd_migrate_create(const struct lu_env *env,
                                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;
@@ -3245,7 +3365,7 @@ static int mdd_migrate_create(const struct lu_env *env,
                        RETURN(rc);
                }
                spec->u.sp_symname = link_buf.lb_buf;
-       } else{
+       } 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)
@@ -3255,16 +3375,23 @@ static int mdd_migrate_create(const struct lu_env *env,
                        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;
-       mgr_ea->lmv_magic = cpu_to_le32(LMV_MAGIC_MIGRATE);
+       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_TYPE_MIGRATION);
+       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));
@@ -3276,7 +3403,7 @@ static int mdd_migrate_create(const struct lu_env *env,
        rc = mdd_declare_migrate_create(env, mdd_pobj, mdd_sobj, mdd_tobj,
                                        spec, la,
                                        (union lmv_mds_md *)info->mti_xattr_buf,
-                                       handle);
+                                       ldata, handle);
        if (rc != 0)
                GOTO(stop_trans, rc);
 
@@ -3286,14 +3413,12 @@ static int mdd_migrate_create(const struct lu_env *env,
 
        /* create the target object */
        rc = mdd_object_create(env, mdd_pobj, mdd_tobj, la, spec, NULL, NULL,
-                              NULL, handle);
+                              hint, handle);
        if (rc != 0)
                GOTO(stop_trans, rc);
 
-       if (lmm_buf.lb_buf != NULL && lmm_buf.lb_len != 0) {
-               buf = mdd_buf_get_const(env, lmm_buf.lb_buf, lmm_buf.lb_len);
-               rc = mdo_xattr_set(env, mdd_tobj, buf, XATTR_NAME_LOV,
-                                  0, handle, mdd_object_capa(env, mdd_sobj));
+       if (S_ISDIR(la->la_mode)) {
+               rc = mdd_links_write(env, mdd_tobj, ldata, handle);
                if (rc != 0)
                        GOTO(stop_trans, rc);
        }
@@ -3301,10 +3426,9 @@ static int mdd_migrate_create(const struct lu_env *env,
        /* 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_MIGRATE);
+       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, mdd_object_capa(env, mdd_sobj));
+       rc = mdo_xattr_set(env, mdd_sobj, buf, XATTR_NAME_LMV, 0, handle);
        if (rc != 0)
                GOTO(stop_trans, rc);
 
@@ -3314,10 +3438,8 @@ static int mdd_migrate_create(const struct lu_env *env,
         * 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 = LUSTRE_IMMUTABLE_FL;
-       mdd_flags_xlate(mdd_sobj, la_flag->la_flags);
-       rc = mdo_attr_set(env, mdd_sobj, la_flag, handle,
-                         mdd_object_capa(env, mdd_sobj));
+       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);
@@ -3352,8 +3474,7 @@ static int mdd_migrate_entries(const struct lu_env *env,
         * iterate directories
         */
        iops = &next->do_index_ops->dio_it;
-       it = iops->init(env, next, LUDA_FID | LUDA_TYPE,
-                       mdd_object_capa(env, mdd_sobj));
+       it = iops->init(env, next, LUDA_FID | LUDA_TYPE);
        if (IS_ERR(it))
                GOTO(out_ent, rc = PTR_ERR(it));
 
@@ -3403,7 +3524,7 @@ static int mdd_migrate_entries(const struct lu_env *env,
                if (IS_ERR(child))
                        GOTO(out, rc = PTR_ERR(child));
 
-               is_dir = S_ISDIR(lu_object_attr(&child->mod_obj.mo_lu));
+               is_dir = S_ISDIR(mdd_object_type(child));
 
                snprintf(name, ent->lde_namelen + 1, "%s", ent->lde_name);
 
@@ -3411,10 +3532,8 @@ static int mdd_migrate_entries(const struct lu_env *env,
                if (dt_try_as_dir(env, dt_tobj)) {
                        struct lu_fid *fid = &mdd_env_info(env)->mti_fid2;
 
-                       rc = dt_tobj->do_index_ops->dio_lookup(env, dt_tobj,
-                                                        (struct dt_rec *)fid,
-                                                        (struct dt_key *)name,
-                                               mdd_object_capa(env, mdd_tobj));
+                       rc = dt_lookup(env, dt_tobj, (struct dt_rec *)fid,
+                                      (struct dt_key *)name);
                        if (unlikely(rc == 0))
                                target_exist = true;
                }
@@ -3430,6 +3549,7 @@ static int mdd_migrate_entries(const struct lu_env *env,
                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);
@@ -3458,7 +3578,7 @@ static int mdd_migrate_entries(const struct lu_env *env,
 
                        rc = mdo_declare_index_insert(env, child,
                                                      mdd_object_fid(mdd_tobj),
-                                                             dotdot, handle);
+                                                     S_IFDIR, dotdot, handle);
                        if (rc != 0)
                                GOTO(out_put, rc);
                }
@@ -3479,34 +3599,25 @@ static int mdd_migrate_entries(const struct lu_env *env,
 
                if (likely(!target_exist)) {
                        rc = __mdd_index_insert(env, mdd_tobj, &ent->lde_fid,
-                                               name, is_dir, handle,
-                                               mdd_object_capa(env, mdd_tobj));
+                                               mdd_object_type(child),
+                                               name, handle);
                        if (rc != 0)
                                GOTO(out_put, rc);
-
-                       if (is_dir) {
-                               rc = mdo_ref_add(env, mdd_tobj, handle);
-                               if (rc != 0)
-                                       GOTO(out_put, rc);
-
-                       }
                }
 
-               rc = __mdd_index_delete(env, mdd_sobj, name, is_dir, handle,
-                                       mdd_object_capa(env, mdd_sobj));
+               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,
-                                                  mdd_object_capa(env, child));
+                       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),
-                                        dotdot, handle,
-                                        mdd_object_capa(env, child));
+                                        mdd_object_fid(mdd_tobj), S_IFDIR,
+                                        dotdot, handle);
                        if (rc != 0)
                                GOTO(out_put, rc);
                }
@@ -3572,7 +3683,6 @@ static int mdd_declare_migrate_update_name(const struct lu_env *env,
        /* Revert IMMUTABLE flag */
        la_flag->la_valid = LA_FLAGS;
        la_flag->la_flags = la->la_flags & ~LUSTRE_IMMUTABLE_FL;
-       mdd_flags_xlate(mdd_sobj, la_flag->la_flags);
        rc = mdo_declare_attr_set(env, mdd_sobj, la_flag, handle);
        if (rc != 0)
                return rc;
@@ -3602,10 +3712,15 @@ static int mdd_declare_migrate_update_name(const struct lu_env *env,
 
        /* 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;
 
+       rc = mdd_declare_links_add(env, mdd_tobj, handle, NULL, MLAO_IGNORE);
+       if (rc != 0)
+               return rc;
+
        if (S_ISDIR(mdd_object_type(mdd_sobj))) {
                rc = mdo_declare_ref_add(env, mdd_pobj, handle);
                if (rc != 0)
@@ -3659,7 +3774,7 @@ static int mdd_migrate_update_name(const struct lu_env *env,
        p_la->la_ctime = p_la->la_mtime = ma->ma_attr.la_ctime;
        p_la->la_valid = LA_CTIME;
 
-       rc = mdd_la_get(env, mdd_sobj, so_attr, mdd_object_capa(env, mdd_sobj));
+       rc = mdd_la_get(env, mdd_sobj, so_attr);
        if (rc != 0)
                RETURN(rc);
 
@@ -3690,15 +3805,12 @@ static int mdd_migrate_update_name(const struct lu_env *env,
        /* Revert IMMUTABLE flag */
        la_flag->la_valid = LA_FLAGS;
        la_flag->la_flags = so_attr->la_flags & ~LUSTRE_IMMUTABLE_FL;
-       mdd_flags_xlate(mdd_sobj, la_flag->la_flags);
-       rc = mdo_attr_set(env, mdd_sobj, la_flag, handle,
-                         mdd_object_capa(env, mdd_pobj));
+       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,
-                               mdd_object_capa(env, mdd_pobj));
+       rc = __mdd_index_delete(env, mdd_pobj, name, is_dir, handle);
        if (rc != 0)
                GOTO(stop_trans, rc);
 
@@ -3710,16 +3822,15 @@ static int mdd_migrate_update_name(const struct lu_env *env,
        if (S_ISREG(so_attr->la_mode)) {
                if (so_attr->la_nlink == 1) {
                        rc = mdo_xattr_del(env, mdd_sobj, XATTR_NAME_LOV,
-                                          handle,
-                                          mdd_object_capa(env, mdd_sobj));
+                                          handle);
                        if (rc != 0 && rc != -ENODATA)
                                GOTO(stop_trans, rc);
                }
        }
 
        /* Insert new fid with target name into target dir */
-       rc = __mdd_index_insert(env, mdd_pobj, mdd_object_fid(mdd_tobj), name,
-                               is_dir, handle, mdd_object_capa(env, mdd_pobj));
+       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);
 
@@ -3734,20 +3845,21 @@ static int mdd_migrate_update_name(const struct lu_env *env,
                mdo_ref_del(env, mdd_sobj, handle);
 
        /* Get the attr again after ref_del */
-       rc = mdd_la_get(env, mdd_sobj, so_attr,
-                       mdd_object_capa(env, mdd_sobj));
+       rc = mdd_la_get(env, mdd_sobj, so_attr);
        if (rc != 0)
-               GOTO(stop_trans, rc);
+               GOTO(out_unlock, rc);
+
        ma->ma_attr = *so_attr;
        ma->ma_valid |= MA_INODE;
-       rc = mdd_finish_unlink(env, mdd_sobj, ma, handle);
+       rc = mdd_finish_unlink(env, mdd_sobj, ma, mdd_pobj, lname, handle);
        if (rc != 0)
-               GOTO(stop_trans, rc);
+               GOTO(out_unlock, rc);
 
        rc = mdd_attr_set_internal(env, mdd_pobj, p_la, handle, 0);
        if (rc != 0)
-               GOTO(stop_trans, rc);
+               GOTO(out_unlock, rc);
 
+out_unlock:
        mdd_write_unlock(env, mdd_sobj);
 
 stop_trans:
@@ -3779,13 +3891,12 @@ static int mdd_migrate_sanity_check(const struct lu_env *env,
 
        ENTRY;
 
-       mgr_easize = lmv_mds_md_size(2, LMV_MAGIC_MIGRATE);
+       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,
-                          mdd_object_capa(env, sobj));
+       rc = mdo_xattr_get(env, sobj, mgr_buf, XATTR_NAME_LMV);
        if (rc > 0) {
                union lmv_mds_md *lmm = mgr_buf->lb_buf;
 
@@ -3793,12 +3904,11 @@ static int mdd_migrate_sanity_check(const struct lu_env *env,
                 * 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_magic) ==
-                                               LMV_MAGIC_MIGRATE) {
+               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;
-                       sobj->mod_flags &= ~IMMUTE_OBJ;
                        CDEBUG(D_HA, "%s: "DFID" override IMMUTE FLAG\n",
                               mdd2obd_dev(mdd)->obd_name,
                               PFID(mdd_object_fid(sobj)));
@@ -3893,11 +4003,11 @@ static int mdd_migrate(const struct lu_env *env, struct md_object *pobj,
        }
        mdd_read_unlock(env, mdd_sobj);
 
-       rc = mdd_la_get(env, mdd_sobj, so_attr, mdd_object_capa(env, mdd_sobj));
+       rc = mdd_la_get(env, mdd_sobj, so_attr);
        if (rc != 0)
                GOTO(put, rc);
 
-       rc = mdd_la_get(env, mdd_pobj, pattr, BYPASS_CAPA);
+       rc = mdd_la_get(env, mdd_pobj, pattr);
        if (rc != 0)
                GOTO(put, rc);
 
@@ -3933,7 +4043,7 @@ static int mdd_migrate(const struct lu_env *env, struct md_object *pobj,
        mdd_tobj = md2mdd_obj(tobj);
        if (!mdd_object_exists(mdd_tobj)) {
                rc = mdd_migrate_create(env, mdd_pobj, mdd_sobj, mdd_tobj,
-                                       so_attr);
+                                       lname, so_attr);
                if (rc != 0)
                        GOTO(put, rc);
        }
@@ -3951,6 +4061,8 @@ static int mdd_migrate(const struct lu_env *env, struct md_object *pobj,
                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);
        }
 
        /* step 4: update name entry to the new object */