+ 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);
+ if (rc2)
+ CWARN("%s: sp obj dotdot delete error: rc = %d\n",
+ mdd2obd_dev(mdd)->obd_name, rc2);
+
+
+ rc2 = __mdd_index_insert_only(env, mdd_sobj, spobj_fid, S_IFDIR,
+ dotdot, handle);
+ if (rc2 != 0)
+ CWARN("%s: sp obj dotdot insert error: rc = %d\n",
+ mdd2obd_dev(mdd)->obd_name, rc2);
+ }
+
+fixup_spobj2:
+ if (rc != 0) {
+ rc2 = __mdd_index_insert(env, mdd_spobj, lf,
+ mdd_object_type(mdd_sobj), sname,
+ handle);
+ if (rc2 != 0)
+ CWARN("sp obj fix error: rc = %d\n", rc2);
+ }
+
+cleanup:
+ if (tobj_locked)
+ mdd_write_unlock(env, mdd_tobj);
+
+cleanup_unlocked:
+ if (rc == 0)
+ rc = mdd_changelog_ns_store(env, mdd, CL_RENAME, cl_flags,
+ mdd_tobj, tpobj_fid, lf, spobj_fid,
+ ltname, lsname, handle);
+
+stop:
+ mdd_trans_stop(env, mdd, rc, handle);
+
+out_pending:
+ mdd_object_put(env, mdd_sobj);
+ return rc;
+}
+
+/**
+ * During migration once the parent FID has been changed,
+ * we need update the parent FID in linkea.
+ **/
+static int mdd_linkea_update_child_internal(const struct lu_env *env,
+ struct mdd_object *parent,
+ struct mdd_object *child,
+ const char *name, int namelen,
+ struct thandle *handle,
+ bool declare)
+{
+ struct mdd_thread_info *info = mdd_env_info(env);
+ struct linkea_data ldata = { NULL };
+ struct lu_buf *buf = &info->mti_link_buf;
+ int count;
+ int rc = 0;
+
+ ENTRY;
+
+ buf = lu_buf_check_and_alloc(buf, PATH_MAX);
+ if (buf->lb_buf == NULL)
+ RETURN(-ENOMEM);
+
+ ldata.ld_buf = buf;
+ rc = mdd_links_read(env, child, &ldata);
+ if (rc != 0) {
+ if (rc == -ENOENT || rc == -ENODATA)
+ rc = 0;
+ RETURN(rc);
+ }
+
+ LASSERT(ldata.ld_leh != NULL);
+ ldata.ld_lee = (struct link_ea_entry *)(ldata.ld_leh + 1);
+ for (count = 0; count < ldata.ld_leh->leh_reccount; count++) {
+ struct mdd_device *mdd = mdo2mdd(&child->mod_obj);
+ struct lu_name lname;
+ struct lu_fid fid;
+
+ linkea_entry_unpack(ldata.ld_lee, &ldata.ld_reclen,
+ &lname, &fid);
+
+ if (strncmp(lname.ln_name, name, namelen) != 0 ||
+ lu_fid_eq(&fid, mdd_object_fid(parent))) {
+ ldata.ld_lee = (struct link_ea_entry *)
+ ((char *)ldata.ld_lee +
+ ldata.ld_reclen);
+ continue;
+ }
+
+ CDEBUG(D_INFO, "%s: update "DFID" with %.*s:"DFID"\n",
+ mdd2obd_dev(mdd)->obd_name, PFID(mdd_object_fid(child)),
+ lname.ln_namelen, lname.ln_name,
+ PFID(mdd_object_fid(parent)));
+ /* update to the new parent fid */
+ linkea_entry_pack(ldata.ld_lee, &lname,
+ mdd_object_fid(parent));
+ if (declare)
+ rc = mdd_declare_links_add(env, child, handle, &ldata,
+ MLAO_IGNORE);
+ else
+ rc = mdd_links_write(env, child, &ldata, handle);
+ break;
+ }
+ RETURN(rc);
+}
+
+static int mdd_linkea_declare_update_child(const struct lu_env *env,
+ struct mdd_object *parent,
+ struct mdd_object *child,
+ const char *name, int namelen,
+ struct thandle *handle)
+{
+ return mdd_linkea_update_child_internal(env, parent, child, name,
+ namelen, handle, true);
+}
+
+static int mdd_linkea_update_child(const struct lu_env *env,
+ struct mdd_object *parent,
+ struct mdd_object *child,
+ const char *name, int namelen,
+ struct thandle *handle)
+{
+ return mdd_linkea_update_child_internal(env, parent, child, name,
+ namelen, handle, false);
+}
+
+static int mdd_update_linkea_internal(const struct lu_env *env,
+ struct mdd_object *mdd_pobj,
+ struct mdd_object *mdd_sobj,
+ struct mdd_object *mdd_tobj,
+ const struct lu_name *child_name,
+ struct thandle *handle,
+ int declare)
+{
+ struct mdd_thread_info *info = mdd_env_info(env);
+ struct linkea_data *ldata = &info->mti_link_data;
+ int count;
+ int rc = 0;
+ ENTRY;
+
+ rc = mdd_links_read(env, mdd_sobj, ldata);
+ if (rc != 0) {
+ if (rc == -ENOENT || rc == -ENODATA)
+ rc = 0;
+ RETURN(rc);
+ }
+
+ /* If it is mulitple links file, we need update the name entry for
+ * all parent */
+ LASSERT(ldata->ld_leh != NULL);
+ ldata->ld_lee = (struct link_ea_entry *)(ldata->ld_leh + 1);
+ for (count = 0; count < ldata->ld_leh->leh_reccount; count++) {
+ struct mdd_device *mdd = mdo2mdd(&mdd_sobj->mod_obj);
+ struct mdd_object *pobj;
+ struct lu_name lname;
+ struct lu_fid fid;
+
+ linkea_entry_unpack(ldata->ld_lee, &ldata->ld_reclen,
+ &lname, &fid);
+ ldata->ld_lee = (struct link_ea_entry *)((char *)ldata->ld_lee +
+ ldata->ld_reclen);
+ pobj = mdd_object_find(env, mdd, &fid);
+ if (IS_ERR(pobj)) {
+ CWARN("%s: cannot find obj "DFID": rc = %ld\n",
+ mdd2obd_dev(mdd)->obd_name, PFID(&fid),
+ PTR_ERR(pobj));
+ continue;
+ }
+
+ if (!mdd_object_exists(pobj)) {
+ CDEBUG(D_INFO, "%s: obj "DFID" does not exist\n",
+ mdd2obd_dev(mdd)->obd_name, PFID(&fid));
+ GOTO(next_put, rc);
+ }
+
+ if (pobj == mdd_pobj &&
+ lname.ln_namelen == child_name->ln_namelen &&
+ strncmp(lname.ln_name, child_name->ln_name,
+ lname.ln_namelen) == 0) {
+ CDEBUG(D_INFO, "%s: skip its own %s: "DFID"\n",
+ mdd2obd_dev(mdd)->obd_name, child_name->ln_name,
+ PFID(&fid));
+ GOTO(next_put, rc);
+ }
+
+ CDEBUG(D_INFO, "%s: update "DFID" with "DNAME":"DFID"\n",
+ mdd2obd_dev(mdd)->obd_name, PFID(mdd_object_fid(pobj)),
+ PNAME(&lname), PFID(mdd_object_fid(mdd_tobj)));
+
+ if (declare) {
+ /* Remove source name from source directory */
+ /* Insert new fid with target name into target dir */
+ rc = mdo_declare_index_delete(env, pobj, lname.ln_name,
+ handle);
+ if (rc != 0)
+ GOTO(next_put, rc);
+
+ rc = mdo_declare_index_insert(env, pobj,
+ mdd_object_fid(mdd_tobj),
+ mdd_object_type(mdd_tobj),
+ lname.ln_name, handle);
+ if (rc != 0)
+ GOTO(next_put, rc);
+
+ rc = mdo_declare_ref_add(env, mdd_tobj, handle);
+ if (rc)
+ GOTO(next_put, rc);
+
+ rc = mdo_declare_ref_del(env, mdd_sobj, handle);
+ if (rc)
+ GOTO(next_put, rc);
+ } else {
+ rc = __mdd_index_delete(env, pobj, lname.ln_name,
+ 0, handle);
+ if (rc)
+ GOTO(next_put, rc);
+
+ rc = __mdd_index_insert(env, pobj,
+ mdd_object_fid(mdd_tobj),
+ mdd_object_type(mdd_tobj),
+ lname.ln_name, handle);
+ if (rc != 0)
+ GOTO(next_put, rc);
+
+ mdd_write_lock(env, mdd_tobj, MOR_SRC_CHILD);
+ rc = mdo_ref_add(env, mdd_tobj, handle);
+ mdd_write_unlock(env, mdd_tobj);
+ if (rc)
+ GOTO(next_put, rc);
+
+ mdd_write_lock(env, mdd_sobj, MOR_TGT_CHILD);
+ mdo_ref_del(env, mdd_sobj, handle);
+ mdd_write_unlock(env, mdd_sobj);
+ }
+next_put:
+ mdd_object_put(env, pobj);
+ if (rc != 0)
+ break;
+ }
+
+ RETURN(rc);
+}
+
+static int mdd_migrate_xattrs(const struct lu_env *env,
+ struct mdd_object *mdd_sobj,
+ struct mdd_object *mdd_tobj)
+{
+ struct mdd_thread_info *info = mdd_env_info(env);
+ struct mdd_device *mdd = mdo2mdd(&mdd_sobj->mod_obj);
+ char *xname;
+ struct thandle *handle;
+ struct lu_buf xbuf;
+ int xlen;
+ int rem;
+ int xsize;
+ int list_xsize;
+ struct lu_buf list_xbuf;
+ int rc;
+
+ /* retrieve xattr list from the old object */
+ list_xsize = mdo_xattr_list(env, mdd_sobj, &LU_BUF_NULL);
+ if (list_xsize == -ENODATA)
+ return 0;
+
+ if (list_xsize < 0)
+ return list_xsize;
+
+ lu_buf_check_and_alloc(&info->mti_big_buf, list_xsize);
+ if (info->mti_big_buf.lb_buf == NULL)
+ return -ENOMEM;
+
+ list_xbuf.lb_buf = info->mti_big_buf.lb_buf;
+ list_xbuf.lb_len = list_xsize;
+ rc = mdo_xattr_list(env, mdd_sobj, &list_xbuf);
+ if (rc < 0)
+ return rc;
+ rc = 0;
+ rem = list_xsize;
+ xname = list_xbuf.lb_buf;
+ while (rem > 0) {
+ xlen = strnlen(xname, rem - 1) + 1;
+ if (strcmp(XATTR_NAME_LINK, xname) == 0 ||
+ strcmp(XATTR_NAME_LMA, xname) == 0 ||
+ strcmp(XATTR_NAME_LMV, xname) == 0)
+ goto next;
+
+ /* For directory, if there are default layout, migrate here */
+ if (strcmp(XATTR_NAME_LOV, xname) == 0 &&
+ !S_ISDIR(lu_object_attr(&mdd_sobj->mod_obj.mo_lu)))
+ goto next;
+
+ xsize = mdo_xattr_get(env, mdd_sobj, &LU_BUF_NULL, xname);
+ if (xsize == -ENODATA)
+ goto next;
+ if (xsize < 0)
+ GOTO(out, rc);
+
+ lu_buf_check_and_alloc(&info->mti_link_buf, xsize);
+ if (info->mti_link_buf.lb_buf == NULL)
+ GOTO(out, rc = -ENOMEM);
+
+ xbuf.lb_len = xsize;
+ xbuf.lb_buf = info->mti_link_buf.lb_buf;
+ rc = mdo_xattr_get(env, mdd_sobj, &xbuf, xname);
+ if (rc == -ENODATA)
+ goto next;
+ if (rc < 0)
+ GOTO(out, rc);
+
+ handle = mdd_trans_create(env, mdd);
+ if (IS_ERR(handle))
+ GOTO(out, rc = PTR_ERR(handle));
+
+ rc = mdo_declare_xattr_set(env, mdd_tobj, &xbuf, xname, 0,
+ handle);
+ if (rc != 0)
+ GOTO(stop_trans, rc);
+ /* Note: this transaction is part of migration, and it is not
+ * the last step of migration, so we set th_local = 1 to avoid
+ * update last rcvd for this transaction */
+ handle->th_local = 1;
+ rc = mdd_trans_start(env, mdd, handle);
+ if (rc != 0)
+ GOTO(stop_trans, rc);
+
+ rc = mdo_xattr_set(env, mdd_tobj, &xbuf, xname, 0, handle);
+ if (rc == -EEXIST)
+ GOTO(stop_trans, rc = 0);
+
+ if (rc != 0)
+ GOTO(stop_trans, rc);
+stop_trans:
+ mdd_trans_stop(env, mdd, rc, handle);
+ if (rc != 0)
+ GOTO(out, rc);
+next:
+ rem -= xlen;
+ memmove(xname, xname + xlen, rem);
+ }
+out:
+ return rc;
+}
+
+static int mdd_declare_migrate_create(const struct lu_env *env,
+ struct mdd_object *mdd_pobj,
+ struct mdd_object *mdd_sobj,
+ struct mdd_object *mdd_tobj,
+ struct md_op_spec *spec,
+ struct lu_attr *la,
+ union lmv_mds_md *mgr_ea,
+ struct linkea_data *ldata,
+ struct thandle *handle)
+{
+ struct lu_attr *la_flag = MDD_ENV_VAR(env, la_for_fix);
+ const struct lu_buf *buf;
+ int rc;
+ int mgr_easize;
+
+ rc = mdd_declare_object_create_internal(env, mdd_pobj, mdd_tobj, la,
+ handle, spec, NULL);
+ if (rc != 0)
+ return rc;
+
+ rc = mdd_declare_object_initialize(env, mdd_pobj, mdd_tobj, la,
+ handle);
+ if (rc != 0)
+ return rc;
+
+ if (S_ISLNK(la->la_mode)) {
+ const char *target_name = spec->u.sp_symname;
+ int sym_len = strlen(target_name);
+ const struct lu_buf *buf;
+
+ buf = mdd_buf_get_const(env, target_name, sym_len);
+ rc = dt_declare_record_write(env, mdd_object_child(mdd_tobj),
+ buf, 0, handle);
+ if (rc != 0)
+ return rc;
+ } else if (S_ISDIR(la->la_mode)) {
+ rc = mdd_declare_links_add(env, mdd_tobj, handle, ldata,
+ MLAO_IGNORE);
+ if (rc != 0)
+ return rc;
+ }
+
+ if (spec->u.sp_ea.eadata != NULL && spec->u.sp_ea.eadatalen != 0) {
+ buf = mdd_buf_get_const(env, spec->u.sp_ea.eadata,
+ spec->u.sp_ea.eadatalen);
+ rc = mdo_declare_xattr_set(env, mdd_tobj, buf, XATTR_NAME_LOV,
+ 0, handle);
+ if (rc)
+ return rc;
+ }
+
+ mgr_easize = lmv_mds_md_size(2, LMV_MAGIC_V1);
+ buf = mdd_buf_get_const(env, mgr_ea, mgr_easize);
+ rc = mdo_declare_xattr_set(env, mdd_sobj, buf, XATTR_NAME_LMV,
+ 0, handle);
+ if (rc)
+ return rc;
+
+ la_flag->la_valid = LA_FLAGS;
+ la_flag->la_flags = la->la_flags | LUSTRE_IMMUTABLE_FL;
+ rc = mdo_declare_attr_set(env, mdd_sobj, la_flag, handle);
+
+ return rc;
+}
+
+static int mdd_migrate_create(const struct lu_env *env,
+ struct mdd_object *mdd_pobj,
+ struct mdd_object *mdd_sobj,
+ struct mdd_object *mdd_tobj,
+ const struct lu_name *lname,
+ struct lu_attr *la)
+{
+ struct mdd_thread_info *info = mdd_env_info(env);
+ struct mdd_device *mdd = mdo2mdd(&mdd_sobj->mod_obj);
+ struct md_op_spec *spec = &info->mti_spec;
+ struct lu_buf lmm_buf = { NULL };
+ struct lu_buf link_buf = { NULL };
+ const struct lu_buf *buf;
+ struct thandle *handle;
+ struct lmv_mds_md_v1 *mgr_ea;
+ struct lu_attr *la_flag = MDD_ENV_VAR(env, la_for_fix);
+ struct dt_allocation_hint *hint = &mdd_env_info(env)->mti_hint;
+ int mgr_easize;
+ struct linkea_data *ldata = &mdd_env_info(env)->mti_link_data;
+ int rc;
+ ENTRY;
+
+ /* prepare spec for create */
+ memset(spec, 0, sizeof(*spec));
+ spec->sp_cr_lookup = 0;
+ spec->sp_feat = &dt_directory_features;
+ if (S_ISLNK(la->la_mode)) {
+ buf = lu_buf_check_and_alloc(
+ &mdd_env_info(env)->mti_big_buf,
+ la->la_size + 1);
+ link_buf = *buf;
+ link_buf.lb_len = la->la_size + 1;
+ memset(link_buf.lb_buf, 0, link_buf.lb_len);
+ rc = mdd_readlink(env, &mdd_sobj->mod_obj, &link_buf);
+ if (rc <= 0) {
+ rc = rc != 0 ? rc : -EFAULT;
+ CERROR("%s: "DFID" readlink failed: rc = %d\n",
+ mdd2obd_dev(mdd)->obd_name,
+ PFID(mdd_object_fid(mdd_sobj)), rc);
+ RETURN(rc);
+ }
+ spec->u.sp_symname = link_buf.lb_buf;
+ } else if S_ISREG(la->la_mode) {
+ /* retrieve lov of the old object */
+ rc = mdd_get_lov_ea(env, mdd_sobj, &lmm_buf);
+ if (rc != 0 && rc != -ENODATA)
+ RETURN(rc);
+ if (lmm_buf.lb_buf != NULL && lmm_buf.lb_len != 0) {
+ spec->u.sp_ea.eadata = lmm_buf.lb_buf;
+ spec->u.sp_ea.eadatalen = lmm_buf.lb_len;
+ spec->sp_cr_flags |= MDS_OPEN_HAS_EA;
+ }
+ } else if (S_ISDIR(la->la_mode)) {
+ rc = mdd_links_read(env, mdd_sobj, ldata);
+ if (rc < 0 && rc != -ENODATA)
+ RETURN(rc);
+ }
+
+ mgr_ea = (struct lmv_mds_md_v1 *)info->mti_xattr_buf;
+ memset(mgr_ea, 0, sizeof(*mgr_ea));
+ mgr_ea->lmv_magic = cpu_to_le32(LMV_MAGIC_V1);
+ mgr_ea->lmv_stripe_count = cpu_to_le32(2);
+ mgr_ea->lmv_master_mdt_index = mdd_seq_site(mdd)->ss_node_id;
+ mgr_ea->lmv_hash_type = cpu_to_le32(LMV_HASH_FLAG_MIGRATION);
+ fid_cpu_to_le(&mgr_ea->lmv_stripe_fids[0], mdd_object_fid(mdd_sobj));
+ fid_cpu_to_le(&mgr_ea->lmv_stripe_fids[1], mdd_object_fid(mdd_tobj));
+
+ mdd_object_make_hint(env, mdd_pobj, mdd_tobj, la, spec, hint);
+
+ handle = mdd_trans_create(env, mdd);
+ if (IS_ERR(handle))
+ GOTO(out_free, rc = PTR_ERR(handle));
+
+ /* Note: this transaction is part of migration, and it is not
+ * the last step of migration, so we set th_local = 1 to avoid
+ * update last rcvd for this transaction */
+ handle->th_local = 1;
+ rc = mdd_declare_migrate_create(env, mdd_pobj, mdd_sobj, mdd_tobj,
+ spec, la,
+ (union lmv_mds_md *)info->mti_xattr_buf,
+ ldata, handle);
+ if (rc != 0)
+ GOTO(stop_trans, rc);
+
+ rc = mdd_trans_start(env, mdd, handle);
+ if (rc != 0)
+ GOTO(stop_trans, rc);
+
+ /* create the target object */
+ rc = mdd_object_create(env, mdd_pobj, mdd_tobj, la, spec, NULL, NULL,
+ hint, handle);
+ if (rc != 0)
+ GOTO(stop_trans, rc);
+
+ if (S_ISDIR(la->la_mode)) {
+ rc = mdd_links_write(env, mdd_tobj, ldata, handle);
+ if (rc != 0)
+ GOTO(stop_trans, rc);
+ }
+
+ /* Set MIGRATE EA on the source inode, so once the migration needs
+ * to be re-done during failover, the re-do process can locate the
+ * target object which is already being created. */
+ mgr_easize = lmv_mds_md_size(2, LMV_MAGIC_V1);
+ buf = mdd_buf_get_const(env, mgr_ea, mgr_easize);
+ rc = mdo_xattr_set(env, mdd_sobj, buf, XATTR_NAME_LMV, 0, handle);
+ if (rc != 0)
+ GOTO(stop_trans, rc);
+
+ /* Set immutable flag, so any modification is disabled until
+ * the migration is done. Once the migration is interrupted,
+ * if the resume process find the migrating object has both
+ * IMMUTALBE flag and MIGRATE EA, it need to clear IMMUTABLE
+ * flag and approve the migration */
+ la_flag->la_valid = LA_FLAGS;
+ la_flag->la_flags = la->la_flags | LUSTRE_IMMUTABLE_FL;
+ rc = mdo_attr_set(env, mdd_sobj, la_flag, handle);
+stop_trans:
+ if (handle != NULL)
+ mdd_trans_stop(env, mdd, rc, handle);
+out_free:
+ if (lmm_buf.lb_buf != NULL)
+ OBD_FREE(lmm_buf.lb_buf, lmm_buf.lb_len);
+ RETURN(rc);
+}
+
+static int mdd_migrate_entries(const struct lu_env *env,
+ struct mdd_object *mdd_sobj,
+ struct mdd_object *mdd_tobj)
+{
+ struct dt_object *next = mdd_object_child(mdd_sobj);
+ struct mdd_device *mdd = mdo2mdd(&mdd_sobj->mod_obj);
+ struct dt_object *dt_tobj = mdd_object_child(mdd_tobj);
+ struct thandle *handle;
+ struct dt_it *it;
+ const struct dt_it_ops *iops;
+ int rc;
+ int result;
+ struct lu_dirent *ent;
+ ENTRY;
+
+ OBD_ALLOC(ent, NAME_MAX + sizeof(*ent) + 1);
+ if (ent == NULL)
+ RETURN(-ENOMEM);
+
+ if (!dt_try_as_dir(env, next))
+ GOTO(out_ent, rc = -ENOTDIR);
+ /*
+ * iterate directories
+ */
+ iops = &next->do_index_ops->dio_it;
+ it = iops->init(env, next, LUDA_FID | LUDA_TYPE);
+ if (IS_ERR(it))
+ GOTO(out_ent, rc = PTR_ERR(it));
+
+ rc = iops->load(env, it, 0);
+ if (rc == 0)
+ rc = iops->next(env, it);
+ else if (rc > 0)
+ rc = 0;
+ /*
+ * At this point and across for-loop:
+ *
+ * rc == 0 -> ok, proceed.
+ * rc > 0 -> end of directory.
+ * rc < 0 -> error.
+ */
+ do {
+ struct mdd_object *child;
+ char *name = mdd_env_info(env)->mti_key;
+ int len;
+ int recsize;
+ int is_dir;
+ bool target_exist = false;
+
+ len = iops->key_size(env, it);
+ if (len == 0)
+ goto next;
+
+ result = iops->rec(env, it, (struct dt_rec *)ent,
+ LUDA_FID | LUDA_TYPE);
+ if (result == -ESTALE)
+ goto next;
+ if (result != 0) {
+ rc = result;
+ goto out;
+ }
+
+ fid_le_to_cpu(&ent->lde_fid, &ent->lde_fid);
+ recsize = le16_to_cpu(ent->lde_reclen);
+
+ /* Insert new fid with target name into target dir */
+ if ((ent->lde_namelen == 1 && ent->lde_name[0] == '.') ||
+ (ent->lde_namelen == 2 && ent->lde_name[0] == '.' &&
+ ent->lde_name[1] == '.'))
+ goto next;
+
+ child = mdd_object_find(env, mdd, &ent->lde_fid);
+ if (IS_ERR(child))
+ GOTO(out, rc = PTR_ERR(child));
+
+ is_dir = S_ISDIR(mdd_object_type(child));
+
+ snprintf(name, ent->lde_namelen + 1, "%s", ent->lde_name);
+
+ /* Check whether the name has been inserted to the target */
+ if (dt_try_as_dir(env, dt_tobj)) {
+ struct lu_fid *fid = &mdd_env_info(env)->mti_fid2;
+
+ rc = dt_lookup(env, dt_tobj, (struct dt_rec *)fid,
+ (struct dt_key *)name);
+ if (unlikely(rc == 0))
+ target_exist = true;
+ }