if (ma->ma_valid & MA_LOV)
GOTO(out_put, rc = -EPROTO);
+ /* MDT supports FMD for regular files due to Data-on-MDT */
+ if (S_ISREG(lu_object_attr(&mo->mot_obj)) &&
+ ma->ma_attr.la_valid & (LA_ATIME | LA_MTIME | LA_CTIME))
+ tgt_fmd_update(info->mti_exp, mdt_object_fid(mo),
+ req->rq_xid);
+
rc = mdt_attr_set(info, mo, ma);
if (rc)
GOTO(out_put, rc);
}
}
+static inline void mdt_migrate_object_unlock(struct mdt_thread_info *info,
+ struct mdt_object *obj,
+ struct mdt_lock_handle *lh,
+ struct ldlm_enqueue_info *einfo,
+ struct list_head *slave_locks,
+ int decref)
+{
+ if (mdt_object_remote(obj)) {
+ mdt_unlock_list(info, slave_locks, decref);
+ mdt_object_unlock(info, obj, lh, decref);
+ } else {
+ mdt_reint_striped_unlock(info, obj, lh, einfo, decref);
+ }
+}
+
/*
* lock parents of links, and also check whether total locks don't exceed
* RS_MAX_LOCKS.
* \retval 1 on success, but total lock count may exceed RS_MAX_LOCKS
* \retval -ev negative errno upon error
*/
-static int mdt_lock_links(struct mdt_thread_info *info,
- struct mdt_object *pobj,
- const struct md_attr *ma,
- struct mdt_object *obj,
- struct list_head *link_locks)
+static int mdt_link_parents_lock(struct mdt_thread_info *info,
+ struct mdt_object *pobj,
+ const struct md_attr *ma,
+ struct mdt_object *obj,
+ struct mdt_lock_handle *lhp,
+ struct ldlm_enqueue_info *peinfo,
+ struct list_head *parent_slave_locks,
+ struct list_head *link_locks)
{
struct mdt_device *mdt = info->mti_mdt;
struct lu_buf *buf = &info->mti_big_buf;
struct lu_name *lname = &info->mti_name;
struct linkea_data ldata = { NULL };
bool blocked = false;
- int retries = 5;
int local_lnkp_cnt = 0;
int rc;
RETURN(rc);
}
-repeat:
for (linkea_first_entry(&ldata); ldata.ld_lee && !rc;
linkea_next_entry(&ldata)) {
struct mdt_object *lnkp;
rc = mdt_object_lock_try(info, lnkp, &msl->msl_lh, &ibits,
MDS_INODELOCK_UPDATE, true);
if (!(ibits & MDS_INODELOCK_UPDATE)) {
- blocked = true;
- CDEBUG(D_INFO, "busy lock on "DFID" "DNAME" retry %d\n",
- PFID(&fid), PNAME(lname), retries);
+ CDEBUG(D_INFO, "busy lock on "DFID" "DNAME"\n",
+ PFID(&fid), PNAME(lname));
mdt_unlock_list(info, link_locks, 1);
+ /* also unlock parent locks to avoid deadlock */
+ if (!blocked)
+ mdt_migrate_object_unlock(info, pobj, lhp,
+ peinfo,
+ parent_slave_locks,
+ 1);
+
+ blocked = true;
mdt_lock_pdo_init(&msl->msl_lh, LCK_PW, lname);
rc = mdt_object_lock(info, lnkp, &msl->msl_lh,
rc = mdt_revoke_remote_lookup_lock(info, lnkp, obj);
}
- if (blocked) {
- rc = -EBUSY;
- if (--retries > 0) {
- mdt_unlock_list(info, link_locks, rc);
- blocked = false;
- local_lnkp_cnt = 0;
- goto repeat;
- }
- }
+ if (blocked)
+ GOTO(out, rc = -EBUSY);
EXIT;
out:
return rc;
}
-static inline void mdt_migrate_object_unlock(struct mdt_thread_info *info,
- struct mdt_object *obj,
- struct mdt_lock_handle *lh,
- struct ldlm_enqueue_info *einfo,
- struct list_head *slave_locks,
- int decref)
-{
- if (mdt_object_remote(obj)) {
- mdt_unlock_list(info, slave_locks, decref);
- mdt_object_unlock(info, obj, lh, decref);
- } else {
- mdt_reint_striped_unlock(info, obj, lh, einfo, decref);
- }
-}
-
/* lock parent and its stripes */
static int mdt_migrate_parent_lock(struct mdt_thread_info *info,
struct mdt_object *obj,
* 9. unlock above locks
* 10. sync device if source has links
*/
-static int mdt_reint_migrate_internal(struct mdt_thread_info *info)
+static int mdt_reint_migrate(struct mdt_thread_info *info,
+ struct mdt_lock_handle *unused)
{
const struct lu_env *env = info->mti_env;
struct mdt_device *mdt = info->mti_mdt;
+ struct ptlrpc_request *req = mdt_info_req(info);
struct mdt_reint_record *rr = &info->mti_rr;
struct lu_ucred *uc = mdt_ucred(info);
struct md_attr *ma = &info->mti_attr;
struct mdt_object *spobj = NULL;
struct mdt_object *sobj = NULL;
struct mdt_object *tobj;
+ struct lustre_handle rename_lh = { 0 };
struct mdt_lock_handle *lhp;
struct mdt_lock_handle *lhs;
struct mdt_lock_handle *lht;
LIST_HEAD(parent_slave_locks);
LIST_HEAD(child_slave_locks);
LIST_HEAD(link_locks);
+ int lock_retries = 5;
bool open_sem_locked = false;
bool do_sync = false;
int rc;
CDEBUG(D_INODE, "migrate "DFID"/"DNAME" to "DFID"\n", PFID(rr->rr_fid1),
PNAME(&rr->rr_name), PFID(rr->rr_fid2));
+ if (info->mti_dlm_req)
+ ldlm_request_cancel(req, info->mti_dlm_req, 0, LATF_SKIP);
+
+ if (!fid_is_md_operative(rr->rr_fid1) ||
+ !fid_is_md_operative(rr->rr_fid2))
+ RETURN(-EPERM);
+
/* don't allow migrate . or .. */
if (lu_name_is_dot_or_dotdot(&rr->rr_name))
RETURN(-EBUSY);
mdt->mdt_enable_remote_dir_gid != -1)
RETURN(-EPERM);
+ /*
+ * Note: do not enqueue rename lock for replay request, because
+ * if other MDT holds rename lock, but being blocked to wait for
+ * this MDT to finish its recovery, and the failover MDT can not
+ * get rename lock, which will cause deadlock.
+ */
+ if (!req_is_replay(req)) {
+ rc = mdt_rename_lock(info, &rename_lh);
+ if (rc != 0) {
+ CERROR("%s: can't lock FS for rename: rc = %d\n",
+ mdt_obd_name(info->mti_mdt), rc);
+ RETURN(rc);
+ }
+ }
+
/* pobj is master object of parent */
pobj = mdt_parent_find_check(info, rr->rr_fid1, 0);
if (IS_ERR(pobj))
- RETURN(PTR_ERR(pobj));
+ GOTO(unlock_rename, rc = PTR_ERR(pobj));
if (unlikely(!info->mti_big_lmm)) {
info->mti_big_lmmsize = lmv_mds_md_size(64, LMV_MAGIC);
if (rc)
GOTO(put_parent, rc);
+lock_parent:
/* lock parent object */
lhp = &info->mti_lh[MDT_LH_PARENT];
mdt_lock_reg_init(lhp, LCK_PW);
GOTO(unlock_parent, rc);
/* lock parents of source links, and revoke LOOKUP lock of links */
- rc = mdt_lock_links(info, pobj, ma, sobj, &link_locks);
+ rc = mdt_link_parents_lock(info, pobj, ma, sobj, lhp, peinfo,
+ &parent_slave_locks, &link_locks);
+ if (rc == -EBUSY && lock_retries-- > 0) {
+ mdt_object_put(env, sobj);
+ mdt_object_put(env, spobj);
+ goto lock_parent;
+ }
+
if (rc < 0)
GOTO(put_source, rc);
if (open_sem_locked)
up_write(&sobj->mot_open_sem);
unlock_links:
- mdt_unlock_list(info, &link_locks, rc);
+ mdt_unlock_list(info, &link_locks, do_sync ? 1 : rc);
put_source:
mdt_object_put(env, sobj);
mdt_object_put(env, spobj);
&parent_slave_locks, rc);
put_parent:
mdt_object_put(env, pobj);
+unlock_rename:
+ if (lustre_handle_is_used(&rename_lh))
+ mdt_rename_unlock(&rename_lh);
if (!rc && do_sync)
mdt_device_sync(env, mdt);
* 2 - srcdir child; 3 - tgtdir child.
* Update on disk version of srcdir child.
*/
-/**
- * For DNE phase I, only these renames are allowed
- * mv src_p/src_c tgt_p/tgt_c
- * 1. src_p/src_c/tgt_p/tgt_c are in the same MDT.
- * 2. src_p and tgt_p are same directory, and tgt_c does not
- * exists. In this case, all of modification will happen
- * in the MDT where ithesource parent is, only one remote
- * update is needed, i.e. set c_time/m_time on the child.
- * And tgt_c will be still in the same MDT as the original
- * src_c.
- */
-static int mdt_reint_rename_internal(struct mdt_thread_info *info,
- struct mdt_lock_handle *lhc)
+static int mdt_reint_rename(struct mdt_thread_info *info,
+ struct mdt_lock_handle *unused)
{
+ struct mdt_device *mdt = info->mti_mdt;
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 *mtgtdir = NULL;
struct mdt_object *mold;
struct mdt_object *mnew = NULL;
+ struct lustre_handle rename_lh = { 0 };
struct mdt_lock_handle *lh_srcdirp;
struct mdt_lock_handle *lh_tgtdirp;
struct mdt_lock_handle *lh_oldp = NULL;
PFID(rr->rr_fid1), PNAME(&rr->rr_name),
PFID(rr->rr_fid2), PNAME(&rr->rr_tgt_name));
+ if (info->mti_dlm_req)
+ ldlm_request_cancel(req, info->mti_dlm_req, 0, LATF_SKIP);
+
+ if (!fid_is_md_operative(rr->rr_fid1) ||
+ !fid_is_md_operative(rr->rr_fid2))
+ RETURN(-EPERM);
+
/* find both parents. */
msrcdir = mdt_parent_find_check(info, rr->rr_fid1, 0);
if (IS_ERR(msrcdir))
GOTO(out_put_srcdir, rc = PTR_ERR(mtgtdir));
}
+ /*
+ * Note: do not enqueue rename lock for replay request, because
+ * if other MDT holds rename lock, but being blocked to wait for
+ * this MDT to finish its recovery, and the failover MDT can not
+ * get rename lock, which will cause deadlock.
+ */
+ if (!req_is_replay(req)) {
+ /*
+ * Normally rename RPC is handled on the MDT with the target
+ * directory (if target exists, it's on the MDT with the
+ * target), if the source directory is remote, it's a hint that
+ * source is remote too (this may not be true, but it won't
+ * cause any issue), return -EXDEV early to avoid taking
+ * rename_lock.
+ */
+ if (!mdt->mdt_enable_remote_rename &&
+ mdt_object_remote(msrcdir))
+ GOTO(out_put_tgtdir, rc = -EXDEV);
+
+ rc = mdt_rename_lock(info, &rename_lh);
+ if (rc != 0) {
+ CERROR("%s: can't lock FS for rename: rc = %d\n",
+ mdt_obd_name(mdt), rc);
+ GOTO(out_put_tgtdir, rc);
+ }
+ }
+
rc = mdt_rename_determine_lock_order(info, msrcdir, mtgtdir);
if (rc < 0)
- GOTO(out_put_tgtdir, rc);
+ GOTO(out_unlock_rename, rc);
reverse = rc;
rc = mdt_object_lock_save(info, mtgtdir, lh_tgtdirp, 1,
cos_incompat);
if (rc)
- GOTO(out_put_tgtdir, rc);
+ GOTO(out_unlock_rename, rc);
OBD_FAIL_TIMEOUT(OBD_FAIL_MDS_RENAME, 5);
cos_incompat);
if (rc != 0) {
mdt_object_unlock(info, mtgtdir, lh_tgtdirp, rc);
- GOTO(out_put_tgtdir, rc);
+ GOTO(out_unlock_rename, rc);
}
} else {
rc = mdt_object_lock_save(info, msrcdir, lh_srcdirp, 0,
cos_incompat);
if (rc)
- GOTO(out_put_tgtdir, rc);
+ GOTO(out_unlock_rename, rc);
OBD_FAIL_TIMEOUT(OBD_FAIL_MDS_RENAME, 5);
if (mtgtdir != msrcdir) {
rc = mdt_object_lock_save(info, mtgtdir, lh_tgtdirp, 1,
cos_incompat);
- } else if (lh_srcdirp->mlh_pdo_hash !=
+ } else if (!mdt_object_remote(mtgtdir) &&
+ lh_srcdirp->mlh_pdo_hash !=
lh_tgtdirp->mlh_pdo_hash) {
rc = mdt_pdir_hash_lock(info, lh_tgtdirp, mtgtdir,
MDS_INODELOCK_UPDATE,
}
if (rc != 0) {
mdt_object_unlock(info, msrcdir, lh_srcdirp, rc);
- GOTO(out_put_tgtdir, rc);
+ GOTO(out_unlock_rename, rc);
}
}
GOTO(out_put_old, rc = -ENOENT);
}
+ if (mdt_object_remote(mold) && !mdt->mdt_enable_remote_rename)
+ GOTO(out_put_old, rc = -EXDEV);
+
/* Check if @mtgtdir is subdir of @mold, before locking child
* to avoid reverse locking. */
if (mtgtdir != msrcdir) {
out_unlock_parents:
mdt_object_unlock(info, mtgtdir, lh_tgtdirp, rc);
mdt_object_unlock(info, msrcdir, lh_srcdirp, rc);
+out_unlock_rename:
+ if (lustre_handle_is_used(&rename_lh))
+ mdt_rename_unlock(&rename_lh);
out_put_tgtdir:
mdt_object_put(info->mti_env, mtgtdir);
out_put_srcdir:
return rc;
}
-static int mdt_reint_rename_or_migrate(struct mdt_thread_info *info,
- struct mdt_lock_handle *lhc, bool rename)
-{
- struct mdt_reint_record *rr = &info->mti_rr;
- struct ptlrpc_request *req = mdt_info_req(info);
- struct lustre_handle rename_lh = { 0 };
- int rc;
- ENTRY;
-
- if (info->mti_dlm_req)
- ldlm_request_cancel(req, info->mti_dlm_req, 0, LATF_SKIP);
-
- if (!fid_is_md_operative(rr->rr_fid1) ||
- !fid_is_md_operative(rr->rr_fid2))
- RETURN(-EPERM);
-
- /* Note: do not enqueue rename lock for replay request, because
- * if other MDT holds rename lock, but being blocked to wait for
- * this MDT to finish its recovery, and the failover MDT can not
- * get rename lock, which will cause deadlock. */
- if (!req_is_replay(req)) {
- rc = mdt_rename_lock(info, &rename_lh);
- 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)
- rc = mdt_reint_rename_internal(info, lhc);
- else
- rc = mdt_reint_migrate_internal(info);
-
- if (lustre_handle_is_used(&rename_lh))
- mdt_rename_unlock(&rename_lh);
-
- RETURN(rc);
-}
-
-static int mdt_reint_rename(struct mdt_thread_info *info,
- struct mdt_lock_handle *lhc)
-{
- return mdt_reint_rename_or_migrate(info, lhc, true);
-}
-
-static int mdt_reint_migrate(struct mdt_thread_info *info,
- struct mdt_lock_handle *lhc)
-{
- return mdt_reint_rename_or_migrate(info, lhc, false);
-}
-
static int mdt_reint_resync(struct mdt_thread_info *info,
struct mdt_lock_handle *lhc)
{
git://git.whamcloud.com / fs / lustre-release.git / blobdiff