static int mdt_unlock_slaves(struct mdt_thread_info *mti,
struct mdt_object *obj, __u64 ibits,
+ struct mdt_lock_handle *s0_lh,
+ struct mdt_object *s0_obj,
struct ldlm_enqueue_info *einfo)
{
ldlm_policy_data_t *policy = &mti->mti_policy;
if (!S_ISDIR(obj->mot_header.loh_attr))
RETURN(0);
+ /* Unlock stripe 0 */
+ if (s0_lh != NULL && lustre_handle_is_used(&s0_lh->mlh_reg_lh)) {
+ LASSERT(s0_obj != NULL);
+ mdt_object_unlock_put(mti, s0_obj, s0_lh, 1);
+ }
+
memset(policy, 0, sizeof(*policy));
policy->l_inodebits.bits = ibits;
**/
static int mdt_lock_slaves(struct mdt_thread_info *mti, struct mdt_object *obj,
ldlm_mode_t mode, __u64 ibits,
+ struct mdt_lock_handle *s0_lh,
+ struct mdt_object **s0_objp,
struct ldlm_enqueue_info *einfo)
{
ldlm_policy_data_t *policy = &mti->mti_policy;
- int rc;
+ struct lu_buf *buf = &mti->mti_buf;
+ struct lmv_mds_md_v1 *lmv;
+ struct lu_fid *fid = &mti->mti_tmp_fid1;
+ int rc;
ENTRY;
if (!S_ISDIR(obj->mot_header.loh_attr))
RETURN(0);
+ buf->lb_buf = mti->mti_xattr_buf;
+ buf->lb_len = sizeof(mti->mti_xattr_buf);
+ rc = mo_xattr_get(mti->mti_env, mdt_object_child(obj), buf,
+ XATTR_NAME_LMV);
+ if (rc == -ERANGE) {
+ rc = mdt_big_xattr_get(mti, obj, XATTR_NAME_LMV);
+ if (rc > 0) {
+ buf->lb_buf = mti->mti_big_lmm;
+ buf->lb_len = mti->mti_big_lmmsize;
+ }
+ }
+
+ if (rc == -ENODATA || rc == -ENOENT)
+ RETURN(0);
+
+ if (rc <= 0)
+ RETURN(rc);
+
+ lmv = buf->lb_buf;
+ if (le32_to_cpu(lmv->lmv_magic) != LMV_MAGIC_V1)
+ RETURN(-EINVAL);
+
+ /* Sigh, 0_stripe and master object are different
+ * object, though they are in the same MDT, to avoid
+ * adding osd_object_lock here, so we will enqueue the
+ * stripe0 lock in MDT0 for now */
+ fid_le_to_cpu(fid, &lmv->lmv_stripe_fids[0]);
+ *s0_objp = mdt_object_find_lock(mti, fid, s0_lh, ibits);
+ if (IS_ERR(*s0_objp))
+ RETURN(PTR_ERR(*s0_objp));
+
memset(einfo, 0, sizeof(*einfo));
einfo->ei_type = LDLM_IBITS;
einfo->ei_mode = mode;
int mdt_attr_set(struct mdt_thread_info *info, struct mdt_object *mo,
struct md_attr *ma, int flags)
{
- struct mdt_lock_handle *lh;
- int do_vbr = ma->ma_attr.la_valid & (LA_MODE|LA_UID|LA_GID|LA_FLAGS);
- __u64 lockpart = MDS_INODELOCK_UPDATE;
+ struct mdt_lock_handle *lh;
+ int do_vbr = ma->ma_attr.la_valid & (LA_MODE|LA_UID|LA_GID|LA_FLAGS);
+ __u64 lockpart = MDS_INODELOCK_UPDATE;
struct ldlm_enqueue_info *einfo = &info->mti_einfo;
- int rc;
- ENTRY;
+ struct mdt_lock_handle *s0_lh;
+ struct mdt_object *s0_obj = NULL;
+ int rc;
+ ENTRY;
/* attr shouldn't be set on remote object */
LASSERT(!mdt_object_remote(mo));
if (rc != 0)
RETURN(rc);
- rc = mdt_lock_slaves(info, mo, LCK_EX, lockpart, einfo);
+ s0_lh = &info->mti_lh[MDT_LH_LOCAL];
+ mdt_lock_reg_init(s0_lh, LCK_EX);
+ rc = mdt_lock_slaves(info, mo, LCK_PW, lockpart, s0_lh, &s0_obj, einfo);
if (rc != 0)
GOTO(out_unlock, rc);
EXIT;
out_unlock:
- mdt_unlock_slaves(info, mo, lockpart, einfo);
+ mdt_unlock_slaves(info, mo, lockpart, s0_lh, s0_obj, einfo);
mdt_object_unlock(info, mo, lh, rc);
return rc;
}
struct mdt_lock_handle *parent_lh;
struct mdt_lock_handle *child_lh;
struct ldlm_enqueue_info *einfo = &info->mti_einfo;
+ struct mdt_lock_handle *s0_lh = NULL;
+ struct mdt_object *s0_obj = NULL;
int rc;
int no_name = 0;
ENTRY;
ma->ma_need = MA_INODE;
ma->ma_valid = 0;
- rc = mdt_lock_slaves(info, mc, LCK_EX, MDS_INODELOCK_UPDATE, einfo);
+ s0_lh = &info->mti_lh[MDT_LH_LOCAL];
+ mdt_lock_reg_init(s0_lh, LCK_EX);
+ rc = mdt_lock_slaves(info, mc, LCK_EX, MDS_INODELOCK_UPDATE, s0_lh,
+ &s0_obj, einfo);
if (rc != 0)
GOTO(unlock_child, rc);
EXIT;
unlock_child:
- mdt_unlock_slaves(info, mc, MDS_INODELOCK_UPDATE, einfo);
+ mdt_unlock_slaves(info, mc, MDS_INODELOCK_UPDATE, s0_lh, s0_obj, einfo);
mdt_object_unlock(info, mc, child_lh, rc);
-
- /* Since we do not need reply md striped dir info to client, so
- * reset mti_big_lmm_used to avoid confusing mdt_fix_reply */
- if (info->mti_big_lmm_used)
- info->mti_big_lmm_used = 0;
put_child:
mdt_object_put(info->mti_env, mc);
unlock_parent:
return rc;
}
+enum mdt_rename_lock {
+ MRL_RENAME,
+ MRL_MIGRATE,
+};
+
+/**
+ * Get BFL lock for rename or migrate process, right now, it does not support
+ * cross-MDT rename, so we only need global rename lock during migration.
+ **/
static int mdt_rename_lock(struct mdt_thread_info *info,
- struct lustre_handle *lh, bool rename)
+ struct lustre_handle *lh,
+ enum mdt_rename_lock rename_lock)
{
struct ldlm_namespace *ns = info->mti_mdt->mdt_namespace;
- __u64 flags = 0;
- int rc;
ldlm_policy_data_t *policy = &info->mti_policy;
struct ldlm_res_id *res_id = &info->mti_res_id;
+ __u64 flags = 0;
+ int rc;
ENTRY;
/* XXX only do global rename lock for migration */
- if (mdt_seq_site(info->mti_mdt)->ss_node_id != 0 && !rename) {
+ if (mdt_seq_site(info->mti_mdt)->ss_node_id != 0 &&
+ rename_lock == MRL_MIGRATE) {
struct lu_fid *fid = &info->mti_tmp_fid1;
struct mdt_object *obj;
* target. Source should not be ancestor of target dir. May be other rename
* checks can be moved here later.
*/
-static int mdt_rename_sanity(struct mdt_thread_info *info, struct lu_fid *fid)
+static int mdt_rename_sanity(struct mdt_thread_info *info,
+ const struct lu_fid *dir_fid,
+ const struct lu_fid *fid)
{
- struct mdt_reint_record *rr = &info->mti_rr;
- struct lu_fid dst_fid = *rr->rr_fid2;
struct mdt_object *dst;
+ struct lu_fid dst_fid = *dir_fid;
int rc = 0;
ENTRY;
/* If the source and target are in the same directory, they can not
* be parent/child relationship, so subdir check is not needed */
- if (lu_fid_eq(rr->rr_fid1, rr->rr_fid2))
+ if (lu_fid_eq(dir_fid, fid))
return 0;
do {
&dst_fid);
mdt_object_put(info->mti_env, dst);
if (rc != -EREMOTE && rc < 0) {
- CERROR("Failed mdo_is_subdir(), rc %d\n", rc);
+ CERROR("%s: failed subdir check in "DFID" for "
+ DFID": rc = %d\n",
+ mdt_obd_name(info->mti_mdt),
+ PFID(dir_fid), PFID(fid), rc);
+ /* Return EINVAL only if a parent is the @fid */
+ if (rc == -EINVAL)
+ rc = -EIO;
} else {
/* check the found fid */
if (lu_fid_eq(&dst_fid, fid))
lmv_le_to_cpu(ma->ma_lmv, ma->ma_lmv);
lmm1 = &ma->ma_lmv->lmv_md_v1;
- if (lmm1->lmv_magic != LMV_MAGIC_MIGRATE) {
+ if (!(lmm1->lmv_hash_type & LMV_HASH_FLAG_MIGRATION)) {
CERROR("%s: can not migrate striped dir "DFID
": rc = %d\n", mdt_obd_name(info->mti_mdt),
PFID(mdt_object_fid(mold)), -EPERM);
if (IS_ERR(mnew))
GOTO(out_unlock_child, rc = PTR_ERR(mnew));
if (!mdt_object_remote(mnew)) {
- CERROR("%s: Migration "DFID" is on this MDT !\n",
- mdt_obd_name(info->mti_mdt), PFID(rr->rr_fid2));
+ CERROR("%s: Migration "DFID" is on this MDT:"
+ " rc = %d\n", mdt_obd_name(info->mti_mdt),
+ PFID(rr->rr_fid2), -EXDEV);
GOTO(out_put_new, rc = -EXDEV);
}
}
OBD_FAIL_MDS_REINT_RENAME_WRITE);
rc = mdo_migrate(info->mti_env, mdt_object_child(msrcdir),
- old_fid, &rr->rr_name, mdt_object_child(mnew), ma);
+ mdt_object_child(mold), &rr->rr_name,
+ mdt_object_child(mnew), ma);
if (rc != 0)
GOTO(out_unlock_new, rc);
out_unlock_new:
RETURN(rc);
}
+static struct mdt_object *mdt_object_find_check(struct mdt_thread_info *info,
+ const struct lu_fid *fid,
+ int idx)
+{
+ struct mdt_object *dir;
+ int rc;
+ ENTRY;
+
+ dir = mdt_object_find(info->mti_env, info->mti_mdt, fid);
+ if (IS_ERR(dir))
+ RETURN(dir);
+
+ /* check early, the real version will be saved after locking */
+ rc = mdt_version_get_check(info, dir, idx);
+ if (rc)
+ GOTO(out_put, rc);
+
+ RETURN(dir);
+out_put:
+ mdt_object_put(info->mti_env, dir);
+ return ERR_PTR(rc);
+}
+
+static int mdt_object_lock_save(struct mdt_thread_info *info,
+ struct mdt_object *dir,
+ struct mdt_lock_handle *lh,
+ int idx)
+{
+ int rc;
+
+ /* we lock the target dir if it is local */
+ rc = mdt_object_lock(info, dir, lh, MDS_INODELOCK_UPDATE,
+ MDT_LOCAL_LOCK);
+ if (rc != 0)
+ return rc;
+
+ /* get and save correct version after locking */
+ mdt_version_get_save(info, dir, idx);
+ return 0;
+}
+
+
+static int mdt_rename_parents_lock(struct mdt_thread_info *info,
+ struct mdt_object **srcp,
+ struct mdt_object **tgtp)
+{
+ struct mdt_reint_record *rr = &info->mti_rr;
+ const struct lu_fid *fid_src = rr->rr_fid1;
+ const struct lu_fid *fid_tgt = rr->rr_fid2;
+ struct mdt_lock_handle *lh_src = &info->mti_lh[MDT_LH_PARENT];
+ struct mdt_lock_handle *lh_tgt = &info->mti_lh[MDT_LH_CHILD];
+ struct mdt_object *src;
+ struct mdt_object *tgt;
+ int reverse = 0;
+ int rc;
+ ENTRY;
+
+ /* Check if the @src is not a child of the @tgt, otherwise a
+ * reverse locking must take place.
+ *
+ * Note: cannot be called after object_find, because if the object
+ * is destroyed in between it gets stuck in lu_object_find_at(),
+ * waiting for the last ref. */
+ rc = mdt_rename_sanity(info, fid_src, fid_tgt);
+ if (rc == -EINVAL)
+ reverse = 1;
+ else if (rc)
+ RETURN(rc);
+
+ /* find both parents. */
+ src = mdt_object_find_check(info, fid_src, 0);
+ if (IS_ERR(src))
+ RETURN(PTR_ERR(src));
+
+ OBD_FAIL_TIMEOUT(OBD_FAIL_MDS_RENAME3, 5);
+
+ if (lu_fid_eq(fid_src, fid_tgt)) {
+ tgt = src;
+ mdt_object_get(info->mti_env, tgt);
+ } else {
+ tgt = mdt_object_find_check(info, fid_tgt, 1);
+ if (IS_ERR(tgt))
+ GOTO(err_src_put, rc = PTR_ERR(tgt));
+
+ if (unlikely(mdt_object_remote(tgt))) {
+ CDEBUG(D_INFO, "Source dir "DFID" target dir "DFID
+ "on different MDTs\n", PFID(fid_src),
+ PFID(fid_tgt));
+ GOTO(err_tgt_put, rc = -EXDEV);
+ }
+ }
+
+ /* lock parents in the proper order. */
+ if (reverse) {
+ rc = mdt_object_lock_save(info, tgt, lh_tgt, 1);
+ if (rc)
+ GOTO(err_tgt_put, rc);
+
+ OBD_FAIL_TIMEOUT(OBD_FAIL_MDS_RENAME, 5);
+
+ rc = mdt_object_lock_save(info, src, lh_src, 0);
+ } else {
+ rc = mdt_object_lock_save(info, src, lh_src, 0);
+ if (rc)
+ GOTO(err_tgt_put, rc);
+
+ OBD_FAIL_TIMEOUT(OBD_FAIL_MDS_RENAME, 5);
+
+ if (tgt != src)
+ rc = mdt_object_lock_save(info, tgt, lh_tgt, 1);
+ else if (lh_src->mlh_pdo_hash != lh_tgt->mlh_pdo_hash) {
+ rc = mdt_pdir_hash_lock(info, lh_tgt, tgt,
+ MDS_INODELOCK_UPDATE);
+ OBD_FAIL_TIMEOUT(OBD_FAIL_MDS_PDO_LOCK2, 10);
+ }
+ }
+ if (rc)
+ GOTO(err_unlock, rc);
+
+ if (lu_object_is_dying(&tgt->mot_header))
+ GOTO(err_unlock, rc = -ENOENT);
+
+ *srcp = src;
+ *tgtp = tgt;
+ RETURN(0);
+
+err_unlock:
+ /* The order does not matter as the handle is checked inside,
+ * as well as not used handle. */
+ mdt_object_unlock(info, src, lh_src, rc);
+ mdt_object_unlock(info, tgt, lh_tgt, rc);
+err_tgt_put:
+ mdt_object_put(info->mti_env, tgt);
+err_src_put:
+ mdt_object_put(info->mti_env, src);
+ RETURN(rc);
+}
+
/*
* VBR: rename versions in reply: 0 - src parent; 1 - tgt parent;
* 2 - src child; 3 - tgt child.
struct mdt_reint_record *rr = &info->mti_rr;
struct md_attr *ma = &info->mti_attr;
struct ptlrpc_request *req = mdt_info_req(info);
- struct mdt_object *msrcdir;
- struct mdt_object *mtgtdir;
+ struct mdt_object *msrcdir = NULL;
+ struct mdt_object *mtgtdir = NULL;
struct mdt_object *mold;
struct mdt_object *mnew = NULL;
struct mdt_lock_handle *lh_srcdirp;
PFID(rr->rr_fid1), PNAME(&rr->rr_name),
PFID(rr->rr_fid2), PNAME(&rr->rr_tgt_name));
- /* step 1: lock the source dir. */
lh_srcdirp = &info->mti_lh[MDT_LH_PARENT];
mdt_lock_pdo_init(lh_srcdirp, LCK_PW, &rr->rr_name);
- msrcdir = mdt_object_find_lock(info, rr->rr_fid1, lh_srcdirp,
- MDS_INODELOCK_UPDATE);
- if (IS_ERR(msrcdir))
- RETURN(PTR_ERR(msrcdir));
-
- rc = mdt_version_get_check_save(info, msrcdir, 0);
- if (rc)
- GOTO(out_unlock_source, rc);
-
- /* step 2: find & lock the target dir. */
lh_tgtdirp = &info->mti_lh[MDT_LH_CHILD];
mdt_lock_pdo_init(lh_tgtdirp, LCK_PW, &rr->rr_tgt_name);
- if (lu_fid_eq(rr->rr_fid1, rr->rr_fid2)) {
- mdt_object_get(info->mti_env, msrcdir);
- mtgtdir = msrcdir;
- if (lh_tgtdirp->mlh_pdo_hash != lh_srcdirp->mlh_pdo_hash) {
- rc = mdt_pdir_hash_lock(info, lh_tgtdirp, mtgtdir,
- MDS_INODELOCK_UPDATE);
- if (rc != 0)
- GOTO(out_unlock_source, rc);
- OBD_FAIL_TIMEOUT(OBD_FAIL_MDS_PDO_LOCK2, 10);
- }
- } else {
- mtgtdir = mdt_object_find(info->mti_env, info->mti_mdt,
- rr->rr_fid2);
- if (IS_ERR(mtgtdir))
- GOTO(out_unlock_source, rc = PTR_ERR(mtgtdir));
- /* check early, the real version will be saved after locking */
- rc = mdt_version_get_check(info, mtgtdir, 1);
- if (rc)
- GOTO(out_put_target, rc);
+ /* step 1&2: lock the source and target dirs. */
+ rc = mdt_rename_parents_lock(info, &msrcdir, &mtgtdir);
+ if (rc)
+ RETURN(rc);
- if (unlikely(mdt_object_remote(mtgtdir))) {
- CDEBUG(D_INFO, "Source dir "DFID" target dir "DFID
- "on different MDTs\n", PFID(rr->rr_fid1),
- PFID(rr->rr_fid2));
- GOTO(out_put_target, rc = -EXDEV);
- } else {
- if (likely(mdt_object_exists(mtgtdir))) {
- /* we lock the target dir if it is local */
- rc = mdt_object_lock(info, mtgtdir, lh_tgtdirp,
- MDS_INODELOCK_UPDATE,
- MDT_LOCAL_LOCK);
- if (rc != 0)
- GOTO(out_put_target, rc);
- /* get and save correct version after locking */
- mdt_version_get_save(info, mtgtdir, 1);
- } else {
- GOTO(out_put_target, rc = -ESTALE);
- }
- }
- }
+ OBD_FAIL_TIMEOUT(OBD_FAIL_MDS_RENAME2, 5);
/* step 3: find & lock the old object. */
fid_zero(old_fid);
rc = mdt_lookup_version_check(info, msrcdir, &rr->rr_name, old_fid, 2);
if (rc != 0)
- GOTO(out_unlock_target, rc);
+ GOTO(out_unlock_parents, rc);
if (lu_fid_eq(old_fid, rr->rr_fid1) || lu_fid_eq(old_fid, rr->rr_fid2))
- GOTO(out_unlock_target, rc = -EINVAL);
+ GOTO(out_unlock_parents, rc = -EINVAL);
if (!fid_is_md_operative(old_fid))
- GOTO(out_unlock_target, rc = -EPERM);
+ GOTO(out_unlock_parents, rc = -EPERM);
mold = mdt_object_find(info->mti_env, info->mti_mdt, old_fid);
if (IS_ERR(mold))
- GOTO(out_unlock_target, rc = PTR_ERR(mold));
+ GOTO(out_unlock_parents, rc = PTR_ERR(mold));
+
+ /* Check if @mtgtdir is subdir of @mold, before locking child
+ * to avoid reverse locking. */
+ rc = mdt_rename_sanity(info, rr->rr_fid2, old_fid);
+ if (rc)
+ GOTO(out_put_old, rc);
tgt_vbr_obj_set(info->mti_env, mdt_obj2dt(mold));
/* save version after locking */
if (rc != 0)
GOTO(out_put_new, rc);
+ /* Check if @msrcdir is subdir of @mnew, before locking child
+ * to avoid reverse locking. */
+ rc = mdt_rename_sanity(info, rr->rr_fid1, new_fid);
+ if (rc)
+ GOTO(out_unlock_old, rc);
+
/* We used to acquire MDS_INODELOCK_FULL here but we
* can't do this now because a running HSM restore on
* the rename onto victim will hold the layout
mdt_fail_write(info->mti_env, info->mti_mdt->mdt_bottom,
OBD_FAIL_MDS_REINT_RENAME_WRITE);
- /* Check if @dst is subdir of @src. */
- rc = mdt_rename_sanity(info, old_fid);
- if (rc)
- GOTO(out_unlock_new, rc);
-
if (mnew != NULL)
mutex_lock(&mnew->mot_lov_mutex);
}
EXIT;
-out_unlock_new:
if (mnew != NULL)
mdt_object_unlock(info, mnew, lh_newp, rc);
out_unlock_old:
mdt_object_put(info->mti_env, mnew);
out_put_old:
mdt_object_put(info->mti_env, mold);
-out_unlock_target:
- mdt_object_unlock(info, mtgtdir, lh_tgtdirp, rc);
-out_put_target:
- mdt_object_put(info->mti_env, mtgtdir);
-out_unlock_source:
+out_unlock_parents:
+ mdt_object_unlock_put(info, mtgtdir, lh_tgtdirp, rc);
mdt_object_unlock_put(info, msrcdir, lh_srcdirp, rc);
return rc;
}
static int mdt_reint_rename_or_migrate(struct mdt_thread_info *info,
struct mdt_lock_handle *lhc,
- bool rename)
+ enum mdt_rename_lock rename_lock)
{
struct mdt_reint_record *rr = &info->mti_rr;
struct ptlrpc_request *req = mdt_info_req(info);
fid_is_obf(rr->rr_fid2) || fid_is_dot_lustre(rr->rr_fid2))
RETURN(-EPERM);
- rc = mdt_rename_lock(info, &rename_lh, rename);
+ rc = mdt_rename_lock(info, &rename_lh, rename_lock);
if (rc != 0) {
CERROR("%s: can't lock FS for rename: rc = %d\n",
mdt_obd_name(info->mti_mdt), rc);
RETURN(rc);
}
- if (rename)
+ if (rename_lock == MRL_RENAME)
rc = mdt_reint_rename_internal(info, lhc);
else
rc = mdt_reint_migrate_internal(info, lhc);
static int mdt_reint_rename(struct mdt_thread_info *info,
struct mdt_lock_handle *lhc)
{
- return mdt_reint_rename_or_migrate(info, lhc, true);
+ return mdt_reint_rename_or_migrate(info, lhc, MRL_RENAME);
}
static int mdt_reint_migrate(struct mdt_thread_info *info,
struct mdt_lock_handle *lhc)
{
- return mdt_reint_rename_or_migrate(info, lhc, false);
+ return mdt_reint_rename_or_migrate(info, lhc, MRL_MIGRATE);
}
typedef int (*mdt_reinter)(struct mdt_thread_info *info,
git://git.whamcloud.com / fs / lustre-release.git / blobdiff