LU-12509 ofd: ofd_precreate_objects lockdep warning

ofd_precreate_objects()->ofd_write_lock() is used to
get the write locks, later dt_write_lock() is called
to do the same on the last_id object.

This triggers a false positive with lockdep enabled,
use a different sublass on the last_id to silence
the warning.

Consolidate lockdep subclasses into a single place,
dt_object_role.

Signed-off-by: Li Dongyang <dongyangli@ddn.com>
Change-Id: I283782352bef8422e6c327ce5cfac306da289e37
Reviewed-on: https://review.whamcloud.com/35420
Tested-by: jenkins <devops@whamcloud.com>
Tested-by: Maloo <maloo@whamcloud.com>
Reviewed-by: Andreas Dilger <adilger@whamcloud.com>
Reviewed-by: Li Xi <lixi@ddn.com>
Reviewed-by: Oleg Drokin <green@whamcloud.com>

diff --git a/lustre/include/dt_object.h b/lustre/include/dt_object.h
index 950c372..efe5c3e 100644 (file)
--- a/lustre/include/dt_object.h
+++ b/lustre/include/dt_object.h
@@ -347,6 +347,16 @@ enum dt_index_flags {
         DT_IND_RANGE = 1 << 4,
 };
 
+/* for dt_read_lock() and dt_write_lock() object lock rule */
+enum dt_object_role {
+       DT_SRC_PARENT,
+       DT_SRC_CHILD,
+       DT_TGT_PARENT,
+       DT_TGT_CHILD,
+       DT_TGT_ORPHAN,
+       DT_LASTID,
+};
+
 /**
  * Features, required from index to support file system directories (mapping
  * names to fids).

diff --git a/lustre/include/md_object.h b/lustre/include/md_object.h
index c43539a..763e54b 100644 (file)
--- a/lustre/include/md_object.h
+++ b/lustre/include/md_object.h
@@ -661,17 +661,6 @@ static inline int mdo_statfs(const struct lu_env *env,
        return m->md_ops->mdo_statfs(env, m, sfs);
 }
 
-/**
- * Used in MDD/OUT layer for object lock rule
- **/
-enum mdd_object_role {
-       MOR_SRC_PARENT,
-       MOR_SRC_CHILD,
-       MOR_TGT_PARENT,
-       MOR_TGT_CHILD,
-       MOR_TGT_ORPHAN
-};
-
 struct dt_device;
 
 void lustre_som_swab(struct lustre_som_attrs *attrs);

diff --git a/lustre/lfsck/lfsck_engine.c b/lustre/lfsck/lfsck_engine.c
index a25d949..94fd76b 100644 (file)
--- a/lustre/lfsck/lfsck_engine.c
+++ b/lustre/lfsck/lfsck_engine.c
@@ -187,7 +187,7 @@ static int lfsck_needs_scan_dir(const struct lu_env *env,
                                GOTO(out, rc = 0);
                }
 
-               dt_read_lock(env, obj, MOR_TGT_CHILD);
+               dt_read_lock(env, obj, DT_TGT_CHILD);
                if (unlikely(lfsck_is_dead_obj(obj))) {
                        dt_read_unlock(env, obj);
 

diff --git a/lustre/lod/lod_object.c b/lustre/lod/lod_object.c
index d33a667..311515b 100644 (file)
--- a/lustre/lod/lod_object.c
+++ b/lustre/lod/lod_object.c
@@ -3817,7 +3817,7 @@ static int lod_xattr_set_lmv(const struct lu_env *env, struct dt_object *dt,
                /* if it's source stripe of migrating directory, don't create */
                if (!((lo->ldo_dir_hash_type & LMV_HASH_FLAG_MIGRATION) &&
                      i >= lo->ldo_dir_migrate_offset)) {
-                       dt_write_lock(env, dto, MOR_TGT_CHILD);
+                       dt_write_lock(env, dto, DT_TGT_CHILD);
                        rc = lod_sub_create(env, dto, attr, NULL, dof, th);
                        if (rc != 0) {
                                dt_write_unlock(env, dto);
@@ -6010,7 +6010,7 @@ static int lod_destroy(const struct lu_env *env, struct dt_object *dt,
 
                        if (!OBD_FAIL_CHECK(OBD_FAIL_LFSCK_LOST_SPEOBJ) ||
                            i == cfs_fail_val) {
-                               dt_write_lock(env, stripe, MOR_TGT_CHILD);
+                               dt_write_lock(env, stripe, DT_TGT_CHILD);
                                rc = lod_sub_ref_del(env, stripe, th);
                                dt_write_unlock(env, stripe);
                                if (rc != 0)

diff --git a/lustre/mdd/mdd_dir.c b/lustre/mdd/mdd_dir.c
index 325fb19..17613d6 100644 (file)
--- a/lustre/mdd/mdd_dir.c
+++ b/lustre/mdd/mdd_dir.c
@@ -92,7 +92,7 @@ __mdd_lookup(const struct lu_env *env, struct md_object *pobj,
        }
 
        rc = mdd_permission_internal_locked(env, mdd_obj, pattr, mask,
-                                           MOR_TGT_PARENT);
+                                           DT_TGT_PARENT);
        if (rc)
                RETURN(rc);
 
@@ -454,7 +454,7 @@ int mdd_may_create(const struct lu_env *env, struct mdd_object *pobj,
        if (check_perm)
                rc = mdd_permission_internal_locked(env, pobj, pattr,
                                                    MAY_WRITE | MAY_EXEC,
-                                                   MOR_TGT_PARENT);
+                                                   DT_TGT_PARENT);
        RETURN(rc);
 }
 
@@ -475,7 +475,7 @@ int mdd_may_unlink(const struct lu_env *env, struct mdd_object *pobj,
 
        rc = mdd_permission_internal_locked(env, pobj, pattr,
                                            MAY_WRITE | MAY_EXEC,
-                                           MOR_TGT_PARENT);
+                                           DT_TGT_PARENT);
        if (rc != 0)
                RETURN(rc);
 
@@ -529,7 +529,7 @@ static int mdd_may_delete_entry(const struct lu_env *env,
                int rc;
                rc = mdd_permission_internal_locked(env, pobj, pattr,
                                            MAY_WRITE | MAY_EXEC,
-                                           MOR_TGT_PARENT);
+                                           DT_TGT_PARENT);
                if (rc)
                        RETURN(rc);
        }
@@ -695,7 +695,7 @@ static int __mdd_index_insert(const struct lu_env *env, struct mdd_object *pobj,
 
        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);
+               mdd_write_lock(env, pobj, DT_TGT_PARENT);
                mdo_ref_add(env, pobj, handle);
                mdd_write_unlock(env, pobj);
        }
@@ -708,17 +708,17 @@ static int __mdd_index_delete(const struct lu_env *env, struct mdd_object *pobj,
                              const char *name, int is_dir,
                              struct thandle *handle)
 {
-        int               rc;
-        ENTRY;
+       int rc;
+       ENTRY;
 
        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);
-                mdd_write_unlock(env, pobj);
-        }
+       if (rc == 0 && is_dir) {
+               mdd_write_lock(env, pobj, DT_TGT_PARENT);
+               mdo_ref_del(env, pobj, handle);
+               mdd_write_unlock(env, pobj);
+       }
 
-        RETURN(rc);
+       RETURN(rc);
 }
 
 static int mdd_llog_record_calc_size(const struct lu_env *env,
@@ -1397,7 +1397,7 @@ static int mdd_link(const struct lu_env *env, struct md_object *tgt_obj,
         if (rc)
                 GOTO(stop, rc);
 
-       mdd_write_lock(env, mdd_sobj, MOR_TGT_CHILD);
+       mdd_write_lock(env, mdd_sobj, DT_TGT_CHILD);
        rc = mdd_link_sanity_check(env, mdd_tobj, tattr, lname, mdd_sobj,
                                   cattr);
        if (rc)
@@ -1716,7 +1716,7 @@ static int mdd_unlink(const struct lu_env *env, struct md_object *pobj,
                GOTO(stop, rc);
 
        if (likely(mdd_cobj != NULL))
-               mdd_write_lock(env, mdd_cobj, MOR_TGT_CHILD);
+               mdd_write_lock(env, mdd_cobj, DT_TGT_CHILD);
 
        if (likely(no_name == 0) && !OBD_FAIL_CHECK(OBD_FAIL_LFSCK_DANGLING2)) {
                rc = __mdd_index_delete(env, mdd_pobj, name, is_dir, handle);
@@ -2265,7 +2265,7 @@ static int mdd_acl_init(const struct lu_env *env, struct mdd_object *pobj,
                RETURN(0);
        }
 
-       mdd_read_lock(env, pobj, MOR_TGT_PARENT);
+       mdd_read_lock(env, pobj, DT_TGT_PARENT);
        rc = mdo_xattr_get(env, pobj, def_acl_buf,
                           XATTR_NAME_ACL_DEFAULT);
        mdd_read_unlock(env, pobj);
@@ -2308,7 +2308,7 @@ static int mdd_create_object(const struct lu_env *env, struct mdd_object *pobj,
        const struct lu_buf *buf;
        int rc;
 
-       mdd_write_lock(env, son, MOR_TGT_CHILD);
+       mdd_write_lock(env, son, DT_TGT_CHILD);
        rc = mdd_create_object_internal(env, NULL, son, attr, handle, spec,
                                        hint);
        if (rc)
@@ -2612,7 +2612,7 @@ int mdd_create(const struct lu_env *env, struct md_object *pobj,
                GOTO(out_stop, rc);
 
        if (unlikely(spec->sp_cr_flags & MDS_OPEN_VOLATILE)) {
-               mdd_write_lock(env, son, MOR_TGT_CHILD);
+               mdd_write_lock(env, son, DT_TGT_CHILD);
                son->mod_flags |= VOLATILE_OBJ;
                rc = mdd_orphan_insert(env, son, handle);
                GOTO(out_volatile, rc);
@@ -2646,7 +2646,7 @@ err_insert:
                        goto out_stop;
 
 err_created:
-               mdd_write_lock(env, son, MOR_TGT_CHILD);
+               mdd_write_lock(env, son, DT_TGT_CHILD);
                if (S_ISDIR(attr->la_mode)) {
                        /* Drop the reference, no need to delete "."/"..",
                         * because the object is to be destroyed directly. */
@@ -3063,7 +3063,7 @@ static int mdd_rename(const struct lu_env *env,
                GOTO(fixup_tpobj, rc);
 
        /* Update the linkEA for the source object */
-       mdd_write_lock(env, mdd_sobj, MOR_SRC_CHILD);
+       mdd_write_lock(env, mdd_sobj, DT_SRC_CHILD);
        rc = mdd_links_rename(env, mdd_sobj, mdo2fid(mdd_spobj), lsname,
                              mdo2fid(mdd_tpobj), ltname, handle, ldata,
                              0, 0);
@@ -3082,7 +3082,7 @@ static int mdd_rename(const struct lu_env *env,
          * it must be local one.
          */
         if (tobj && mdd_object_exists(mdd_tobj)) {
-                mdd_write_lock(env, mdd_tobj, MOR_TGT_CHILD);
+               mdd_write_lock(env, mdd_tobj, DT_TGT_CHILD);
                tobj_locked = 1;
                 if (mdd_is_dead_obj(mdd_tobj)) {
                         /* shld not be dead, something is wrong */
@@ -3253,7 +3253,7 @@ static int mdd_migrate_sanity_check(const struct lu_env *env,
        ENTRY;
 
        if (!mdd_object_remote(sobj)) {
-               mdd_read_lock(env, sobj, MOR_SRC_CHILD);
+               mdd_read_lock(env, sobj, DT_SRC_CHILD);
                if (sobj->mod_count > 0) {
                        CDEBUG(D_INFO, "%s: "DFID" is opened, count %d\n",
                               mdd2obd_dev(mdd)->obd_name, PFID(mdo2fid(sobj)),
@@ -3337,7 +3337,7 @@ static int mdd_dir_delete_stripe(const struct lu_env *env,
        if (index < del_offset)
                RETURN(0);
 
-       mdd_write_lock(env, stripe, MOR_SRC_CHILD);
+       mdd_write_lock(env, stripe, DT_SRC_CHILD);
        rc = __mdd_index_delete_only(env, stripe, dotdot, handle);
        if (rc)
                GOTO(out, rc);
@@ -3428,7 +3428,7 @@ static int mdd_dir_destroy_stripe(const struct lu_env *env,
                RETURN(rc);
        }
 
-       mdd_write_lock(env, stripe, MOR_SRC_CHILD);
+       mdd_write_lock(env, stripe, DT_SRC_CHILD);
        rc = mdo_ref_del(env, stripe, handle);
        if (!rc)
                rc = mdo_destroy(env, stripe, handle);
@@ -3685,7 +3685,7 @@ static int mdd_update_link(const struct lu_env *env,
                RETURN(-ENOENT);
        }
 
-       mdd_write_lock(env, pobj, MOR_TGT_PARENT);
+       mdd_write_lock(env, pobj, DT_TGT_PARENT);
        rc = __mdd_index_delete_only(env, pobj, lname->ln_name, handle);
        if (!rc)
                rc = __mdd_index_insert_only(env, pobj, mdo2fid(tobj),
@@ -3696,13 +3696,13 @@ static int mdd_update_link(const struct lu_env *env,
        if (rc)
                RETURN(rc);
 
-       mdd_write_lock(env, tobj, MOR_TGT_CHILD);
+       mdd_write_lock(env, tobj, DT_TGT_CHILD);
        rc = mdo_ref_add(env, tobj, handle);
        mdd_write_unlock(env, tobj);
        if (rc)
                RETURN(rc);
 
-       mdd_write_lock(env, sobj, MOR_SRC_CHILD);
+       mdd_write_lock(env, sobj, DT_SRC_CHILD);
        rc = mdo_ref_del(env, sobj, handle);
        mdd_write_unlock(env, sobj);
 
@@ -3884,7 +3884,7 @@ static int mdd_dir_layout_delete(const struct lu_env *env,
 
        ENTRY;
 
-       mdd_write_lock(env, obj, MOR_SRC_PARENT);
+       mdd_write_lock(env, obj, DT_SRC_PARENT);
        if (!lmv_buf->lb_buf)
                /* normal dir */
                rc = __mdd_index_delete_only(env, obj, dotdot, handle);
@@ -4090,7 +4090,7 @@ static int mdd_migrate_create(const struct lu_env *env,
                 * stripes again.
                 */
                if (sbuf->lb_buf) {
-                       mdd_write_lock(env, sobj, MOR_SRC_CHILD);
+                       mdd_write_lock(env, sobj, DT_SRC_CHILD);
                        rc = mdo_xattr_del(env, sobj, XATTR_NAME_LMV, handle);
                        mdd_write_unlock(env, sobj);
                        if (rc)
@@ -4106,7 +4106,7 @@ static int mdd_migrate_create(const struct lu_env *env,
        if (rc)
                RETURN(rc);
 
-       mdd_write_lock(env, tobj, MOR_TGT_CHILD);
+       mdd_write_lock(env, tobj, DT_TGT_CHILD);
        rc = mdd_iterate_xattrs(env, sobj, tobj, true, handle, mdo_xattr_set);
        mdd_write_unlock(env, tobj);
        if (rc)
@@ -4125,7 +4125,7 @@ static int mdd_migrate_create(const struct lu_env *env,
                        RETURN(rc);
 
                /* delete LOV to avoid deleting OST objs when destroying sobj */
-               mdd_write_lock(env, sobj, MOR_SRC_CHILD);
+               mdd_write_lock(env, sobj, DT_SRC_CHILD);
                rc = mdo_xattr_del(env, sobj, XATTR_NAME_LOV, handle);
                mdd_write_unlock(env, sobj);
                if (rc)
@@ -4254,7 +4254,7 @@ static int mdd_migrate_update(const struct lu_env *env,
 
        la->la_ctime = la->la_mtime = ma->ma_attr.la_ctime;
        la->la_valid = LA_CTIME | LA_MTIME;
-       mdd_write_lock(env, spobj, MOR_SRC_PARENT);
+       mdd_write_lock(env, spobj, DT_SRC_PARENT);
        rc = mdd_update_time(env, spobj, spattr, la, handle);
        mdd_write_unlock(env, spobj);
        if (rc)
@@ -4262,7 +4262,7 @@ static int mdd_migrate_update(const struct lu_env *env,
 
        if (tpobj != spobj) {
                la->la_valid = LA_CTIME | LA_MTIME;
-               mdd_write_lock(env, tpobj, MOR_TGT_PARENT);
+               mdd_write_lock(env, tpobj, DT_TGT_PARENT);
                rc = mdd_update_time(env, tpobj, tpattr, la, handle);
                mdd_write_unlock(env, tpobj);
                if (rc)
@@ -4287,7 +4287,7 @@ static int mdd_migrate_update(const struct lu_env *env,
         *  message, this won't cause any inconsistency or trouble.
         */
        if (do_create && do_destroy) {
-               mdd_write_lock(env, sobj, MOR_SRC_CHILD);
+               mdd_write_lock(env, sobj, DT_SRC_CHILD);
                mdo_ref_del(env, sobj, handle);
                rc = mdo_destroy(env, sobj, handle);
                mdd_write_unlock(env, sobj);
@@ -4732,7 +4732,7 @@ static int __mdd_dir_layout_shrink(const struct lu_env *env,
                lmu->lum_stripe_count = cpu_to_le32(1);
 
                /* delete LMV to avoid deleting stripes again upon destroy */
-               mdd_write_lock(env, obj, MOR_SRC_CHILD);
+               mdd_write_lock(env, obj, DT_SRC_CHILD);
                rc = mdo_xattr_del(env, obj, XATTR_NAME_LMV, handle);
                mdd_write_unlock(env, obj);
                if (rc)
@@ -4740,7 +4740,7 @@ static int __mdd_dir_layout_shrink(const struct lu_env *env,
        }
 
        /* destroy stripes after lmu_stripe_count */
-       mdd_write_lock(env, obj, MOR_SRC_PARENT);
+       mdd_write_lock(env, obj, DT_SRC_PARENT);
        rc = mdd_dir_iterate_stripes(env, obj, lmv_buf, &shrink_buf, handle,
                                     mdd_dir_destroy_stripe);
        mdd_write_unlock(env, obj);
@@ -4764,8 +4764,8 @@ static int __mdd_dir_layout_shrink(const struct lu_env *env,
        LASSERT(pobj);
        LASSERT(stripe);
 
-       mdd_write_lock(env, pobj, MOR_SRC_PARENT);
-       mdd_write_lock(env, obj, MOR_SRC_CHILD);
+       mdd_write_lock(env, pobj, DT_SRC_PARENT);
+       mdd_write_lock(env, obj, DT_SRC_CHILD);
 
        /* insert dotdot to stripe which points to parent */
        rc = __mdd_index_insert_only(env, stripe, mdo2fid(pobj), S_IFDIR,

diff --git a/lustre/mdd/mdd_internal.h b/lustre/mdd/mdd_internal.h
index d1f195c..ac8ecc3 100644 (file)
--- a/lustre/mdd/mdd_internal.h
+++ b/lustre/mdd/mdd_internal.h
@@ -231,9 +231,9 @@ int mdd_create_object_internal(const struct lu_env *env, struct mdd_object *p,
 
 /* mdd_lock.c */
 void mdd_write_lock(const struct lu_env *env, struct mdd_object *obj,
-                    enum mdd_object_role role);
+                   enum dt_object_role role);
 void mdd_read_lock(const struct lu_env *env, struct mdd_object *obj,
-                   enum mdd_object_role role);
+                  enum dt_object_role role);
 void mdd_write_unlock(const struct lu_env *env, struct mdd_object *obj);
 void mdd_read_unlock(const struct lu_env *env, struct mdd_object *obj);
 int mdd_write_locked(const struct lu_env *env, struct mdd_object *obj);
@@ -539,7 +539,7 @@ static inline int mdd_permission_internal_locked(const struct lu_env *env,
                                                struct mdd_object *obj,
                                                const struct lu_attr *la,
                                                int mask,
-                                               enum mdd_object_role role)
+                                               enum dt_object_role role)
 {
        return __mdd_permission_internal(env, obj, la, mask, role);
 }

diff --git a/lustre/mdd/mdd_lock.c b/lustre/mdd/mdd_lock.c
index 193de6e..768ee77 100644 (file)
--- a/lustre/mdd/mdd_lock.c
+++ b/lustre/mdd/mdd_lock.c
@@ -42,7 +42,7 @@
 #include "mdd_internal.h"
 
 void mdd_write_lock(const struct lu_env *env, struct mdd_object *obj,
-                   enum mdd_object_role role)
+                   enum dt_object_role role)
 {
        struct dt_object *next = mdd_object_child(obj);
 
@@ -50,7 +50,7 @@ void mdd_write_lock(const struct lu_env *env, struct mdd_object *obj,
 }
 
 void mdd_read_lock(const struct lu_env *env, struct mdd_object *obj,
-                  enum mdd_object_role role)
+                  enum dt_object_role role)
 {
        struct dt_object *next = mdd_object_child(obj);
 

diff --git a/lustre/mdd/mdd_object.c b/lustre/mdd/mdd_object.c
index e94118e..a67cedc 100644 (file)
--- a/lustre/mdd/mdd_object.c
+++ b/lustre/mdd/mdd_object.c
@@ -421,7 +421,7 @@ static int mdd_xattr_get(const struct lu_env *env,
                      strcmp(name, XATTR_NAME_LINK) == 0))
                RETURN(-ENOENT);
 
-       mdd_read_lock(env, mdd_obj, MOR_TGT_CHILD);
+       mdd_read_lock(env, mdd_obj, DT_TGT_CHILD);
        rc = mdo_xattr_get(env, mdd_obj, buf, name);
        mdd_read_unlock(env, mdd_obj);
 
@@ -487,7 +487,7 @@ int mdd_readlink(const struct lu_env *env, struct md_object *obj,
        LASSERT(next != NULL);
        LASSERT(next->do_body_ops != NULL);
        LASSERT(next->do_body_ops->dbo_read != NULL);
-       mdd_read_lock(env, mdd_obj, MOR_TGT_CHILD);
+       mdd_read_lock(env, mdd_obj, DT_TGT_CHILD);
        rc = dt_read(env, next, buf, &pos);
         mdd_read_unlock(env, mdd_obj);
         RETURN(rc);
@@ -504,7 +504,7 @@ static int mdd_xattr_list(const struct lu_env *env, struct md_object *obj,
 
         ENTRY;
 
-        mdd_read_lock(env, mdd_obj, MOR_TGT_CHILD);
+       mdd_read_lock(env, mdd_obj, DT_TGT_CHILD);
        rc = mdo_xattr_list(env, mdd_obj, buf);
         mdd_read_unlock(env, mdd_obj);
 
@@ -1071,7 +1071,7 @@ static int mdd_declare_attr_set(const struct lu_env *env,
 
 #ifdef CONFIG_FS_POSIX_ACL
        if (attr->la_valid & LA_MODE) {
-                mdd_read_lock(env, obj, MOR_TGT_CHILD);
+               mdd_read_lock(env, obj, DT_TGT_CHILD);
                rc = mdo_xattr_get(env, obj, &LU_BUF_NULL,
                                   XATTR_NAME_ACL_ACCESS);
                 mdd_read_unlock(env, obj);
@@ -1245,7 +1245,7 @@ int mdd_attr_set(const struct lu_env *env, struct md_object *obj,
                CDEBUG(D_INODE, "setting mtime %llu, ctime %llu\n",
                       la->la_mtime, la->la_ctime);
 
-       mdd_write_lock(env, mdd_obj, MOR_TGT_CHILD);
+       mdd_write_lock(env, mdd_obj, DT_TGT_CHILD);
 
        /* LU-10509: setattr of LA_SIZE should be skipped case of DOM,
         * otherwise following truncate will do nothing and truncated
@@ -1509,11 +1509,11 @@ static int mdd_xattr_merge(const struct lu_env *env, struct md_object *md_obj,
                RETURN(PTR_ERR(handle));
 
        if (rc > 0) {
-               mdd_write_lock(env, obj, MOR_TGT_CHILD);
-               mdd_write_lock(env, vic, MOR_TGT_CHILD);
+               mdd_write_lock(env, obj, DT_TGT_CHILD);
+               mdd_write_lock(env, vic, DT_TGT_CHILD);
        } else {
-               mdd_write_lock(env, vic, MOR_TGT_CHILD);
-               mdd_write_lock(env, obj, MOR_TGT_CHILD);
+               mdd_write_lock(env, vic, DT_TGT_CHILD);
+               mdd_write_lock(env, obj, DT_TGT_CHILD);
        }
 
        /* get EA of victim file */
@@ -1735,11 +1735,11 @@ static int mdd_xattr_split(const struct lu_env *env, struct md_object *md_obj,
                RETURN(PTR_ERR(handle));
 
        if (rc > 0) {
-               mdd_write_lock(env, obj, MOR_TGT_CHILD);
-               mdd_write_lock(env, vic, MOR_TGT_CHILD);
+               mdd_write_lock(env, obj, DT_TGT_CHILD);
+               mdd_write_lock(env, vic, DT_TGT_CHILD);
        } else {
-               mdd_write_lock(env, vic, MOR_TGT_CHILD);
-               mdd_write_lock(env, obj, MOR_TGT_CHILD);
+               mdd_write_lock(env, vic, DT_TGT_CHILD);
+               mdd_write_lock(env, obj, DT_TGT_CHILD);
        }
 
        /* get EA of mirrored file */
@@ -1918,7 +1918,7 @@ static int mdd_xattr_set(const struct lu_env *env, struct md_object *obj,
        if (rc)
                GOTO(stop, rc);
 
-       mdd_write_lock(env, mdd_obj, MOR_TGT_CHILD);
+       mdd_write_lock(env, mdd_obj, DT_TGT_CHILD);
 
        if (strcmp(XATTR_NAME_HSM, name) == 0) {
                rc = mdd_hsm_update_locked(env, obj, buf, handle, &clf_flags);
@@ -1999,7 +1999,7 @@ static int mdd_xattr_del(const struct lu_env *env, struct md_object *obj,
        if (rc)
                GOTO(stop, rc);
 
-       mdd_write_lock(env, mdd_obj, MOR_TGT_CHILD);
+       mdd_write_lock(env, mdd_obj, DT_TGT_CHILD);
        rc = mdo_xattr_del(env, mdd_obj, name, handle);
        mdd_write_unlock(env, mdd_obj);
        if (rc)
@@ -2312,8 +2312,8 @@ static int mdd_swap_layouts(const struct lu_env *env, struct md_object *obj1,
                RETURN(PTR_ERR(handle));
 
        /* objects are already sorted */
-       mdd_write_lock(env, fst_o, MOR_TGT_CHILD);
-       mdd_write_lock(env, snd_o, MOR_TGT_CHILD);
+       mdd_write_lock(env, fst_o, DT_TGT_CHILD);
+       mdd_write_lock(env, snd_o, DT_TGT_CHILD);
 
        rc = mdd_stripe_get(env, fst_o, fst_buf, XATTR_NAME_LOV);
        if (rc < 0 && rc != -ENODATA)
@@ -2631,7 +2631,7 @@ mdd_layout_instantiate_component(const struct lu_env *env,
        if (rc)
                RETURN(rc);
 
-       mdd_write_lock(env, obj, MOR_TGT_CHILD);
+       mdd_write_lock(env, obj, DT_TGT_CHILD);
        rc = mdo_layout_change(env, obj, mlc, handle);
        mdd_write_unlock(env, obj);
        if (rc)
@@ -2708,7 +2708,7 @@ mdd_layout_update_rdonly(const struct lu_env *env, struct mdd_object *obj,
        /* it needs a sync tx to make FLR to work properly */
        handle->th_sync = 1;
 
-       mdd_write_lock(env, obj, MOR_TGT_CHILD);
+       mdd_write_lock(env, obj, DT_TGT_CHILD);
        rc = mdo_layout_change(env, obj, mlc, handle);
        if (!rc && fl) {
                /* SOM state transition from STRICT to STALE */
@@ -2775,7 +2775,7 @@ mdd_layout_update_write_pending(const struct lu_env *env,
        /* it needs a sync tx to make FLR to work properly */
        handle->th_sync = 1;
 
-       mdd_write_lock(env, obj, MOR_TGT_CHILD);
+       mdd_write_lock(env, obj, DT_TGT_CHILD);
        rc = mdo_layout_change(env, obj, mlc, handle);
        mdd_write_unlock(env, obj);
        if (rc)
@@ -3053,7 +3053,7 @@ static int mdd_open(const struct lu_env *env, struct md_object *obj,
        enum changelog_rec_type type = CL_OPEN;
        int rc = 0;
 
-       mdd_write_lock(env, mdd_obj, MOR_TGT_CHILD);
+       mdd_write_lock(env, mdd_obj, DT_TGT_CHILD);
 
        rc = mdd_la_get(env, mdd_obj, attr);
        if (rc != 0)
@@ -3152,7 +3152,7 @@ static int mdd_close(const struct lu_env *env, struct md_object *obj,
        ENTRY;
 
        if (ma->ma_valid & MA_FLAGS && ma->ma_attr_flags & MDS_KEEP_ORPHAN) {
-               mdd_write_lock(env, mdd_obj, MOR_TGT_CHILD);
+               mdd_write_lock(env, mdd_obj, DT_TGT_CHILD);
                mdd_obj->mod_count--;
                mdd_write_unlock(env, mdd_obj);
 
@@ -3207,7 +3207,7 @@ again:
        }
 
 cont:
-       mdd_write_lock(env, mdd_obj, MOR_TGT_CHILD);
+       mdd_write_lock(env, mdd_obj, DT_TGT_CHILD);
        rc = mdd_la_get(env, mdd_obj, &ma->ma_attr);
        if (rc != 0) {
                CERROR("%s: failed to get lu_attr of "DFID": rc = %d\n",
@@ -3447,7 +3447,7 @@ int mdd_readpage(const struct lu_env *env, struct md_object *obj,
                 return -ENOENT;
         }
 
-        mdd_read_lock(env, mdd_obj, MOR_TGT_CHILD);
+       mdd_read_lock(env, mdd_obj, DT_TGT_CHILD);
         rc = mdd_readpage_sanity_check(env, mdd_obj);
         if (rc)
                 GOTO(out_unlock, rc);

diff --git a/lustre/mdd/mdd_orphans.c b/lustre/mdd/mdd_orphans.c
index 2de5baa..de1500b 100644 (file)
--- a/lustre/mdd/mdd_orphans.c
+++ b/lustre/mdd/mdd_orphans.c
@@ -164,7 +164,7 @@ int mdd_orphan_insert(const struct lu_env *env, struct mdd_object *obj,
        LASSERT(mdd_write_locked(env, obj) != 0);
        LASSERT(!(obj->mod_flags & ORPHAN_OBJ));
 
-       dt_write_lock(env, mdd->mdd_orphans, MOR_TGT_ORPHAN);
+       dt_write_lock(env, mdd->mdd_orphans, DT_TGT_ORPHAN);
 
        rc = mdd_orphan_insert_obj(env, mdd, obj, th);
        if (rc)
@@ -255,7 +255,7 @@ int mdd_orphan_delete(const struct lu_env *env, struct mdd_object *obj,
        LASSERT(dor);
 
        key = mdd_orphan_key_fill(env, mdo2fid(obj));
-       dt_write_lock(env, mdd->mdd_orphans, MOR_TGT_ORPHAN);
+       dt_write_lock(env, mdd->mdd_orphans, DT_TGT_ORPHAN);
 
        if (OBD_FAIL_CHECK(OBD_FAIL_MDS_ORPHAN_DELETE))
                goto ref_del;
@@ -303,7 +303,7 @@ static int mdd_orphan_destroy(const struct lu_env *env, struct mdd_object *obj,
                RETURN(rc);
        }
 
-       mdd_write_lock(env, obj, MOR_TGT_CHILD);
+       mdd_write_lock(env, obj, DT_TGT_CHILD);
        rc = mdd_orphan_declare_delete(env, obj, th);
        if (rc == -ENOENT)
                orphan_exists = false;
@@ -321,7 +321,7 @@ static int mdd_orphan_destroy(const struct lu_env *env, struct mdd_object *obj,
                GOTO(unlock, rc);
 
        if (likely(obj->mod_count == 0)) {
-               dt_write_lock(env, mdd->mdd_orphans, MOR_TGT_ORPHAN);
+               dt_write_lock(env, mdd->mdd_orphans, DT_TGT_ORPHAN);
                rc = dt_delete(env, mdd->mdd_orphans, key, th);
                if (rc) {
                        CERROR("%s: could not delete orphan "DFID": rc = %d\n",
@@ -379,7 +379,7 @@ static int mdd_orphan_key_test_and_delete(const struct lu_env *env,
                        CERROR("%s: error unlinking orphan "DFID": rc = %d\n",
                               mdd2obd_dev(mdd)->obd_name, PFID(lf), rc);
         } else {
-                mdd_write_lock(env, mdo, MOR_TGT_CHILD);
+               mdd_write_lock(env, mdo, DT_TGT_CHILD);
                 if (likely(mdo->mod_count > 0)) {
                         CDEBUG(D_HA, "Found orphan "DFID" count %d, skip it\n",
                                PFID(lf), mdo->mod_count);

diff --git a/lustre/mdd/mdd_permission.c b/lustre/mdd/mdd_permission.c
index 01b30e1..5d00907 100644 (file)
--- a/lustre/mdd/mdd_permission.c
+++ b/lustre/mdd/mdd_permission.c
@@ -147,7 +147,7 @@ int mdd_acl_set(const struct lu_env *env, struct mdd_object *obj,
        if (rc)
                GOTO(stop, rc);
 
-       mdd_write_lock(env, obj, MOR_TGT_CHILD);
+       mdd_write_lock(env, obj, DT_TGT_CHILD);
        /* whether ACL can be represented by i_mode only */
        if (not_equiv)
                rc = mdo_xattr_set(env, obj, buf, XATTR_NAME_ACL_ACCESS, fl,
@@ -342,7 +342,7 @@ int mdd_permission(const struct lu_env *env, struct md_object *pobj,
 
        rc = mdd_permission_internal_locked(env, mdd_cobj, cattr,
                                            mask & ~MAY_RGETFACL,
-                                           MOR_TGT_CHILD);
+                                           DT_TGT_CHILD);
 
        if (unlikely(rc == 0 && (mask & MAY_RGETFACL))) {
                if (likely(!uc))

diff --git a/lustre/obdclass/local_storage.c b/lustre/obdclass/local_storage.c
index 04c25eb..b27ef92 100644 (file)
--- a/lustre/obdclass/local_storage.c
+++ b/lustre/obdclass/local_storage.c
@@ -371,7 +371,7 @@ static struct dt_object *__local_file_create(const struct lu_env *env,
        if (rc)
                GOTO(trans_stop, rc);
 
-       dt_write_lock(env, dto, LOS_CHILD);
+       dt_write_lock(env, dto, DT_SRC_CHILD);
        if (dt_object_exists(dto))
                GOTO(unlock, rc = 0);
 
@@ -402,7 +402,7 @@ static struct dt_object *__local_file_create(const struct lu_env *env,
 
        rec->rec_fid = fid;
        rec->rec_type = dto->do_lu.lo_header->loh_attr;
-       dt_write_lock(env, parent, LOS_PARENT);
+       dt_write_lock(env, parent, DT_SRC_PARENT);
        rc = dt_insert(env, parent, (const struct dt_rec *)rec,
                       (const struct dt_key *)name, th);
        if (dti->dti_dof.dof_type == DFT_DIR)

diff --git a/lustre/obdclass/local_storage.h b/lustre/obdclass/local_storage.h
index caf26bf..7ff6faa 100644 (file)
--- a/lustre/obdclass/local_storage.h
+++ b/lustre/obdclass/local_storage.h
@@ -91,12 +91,4 @@ struct los_ondisk {
 
 #define LOS_MAGIC      0xdecafbee
 
-/**
- * Used in __local_file_create() for object lock role
- **/
-enum los_object_role {
-       LOS_PARENT,
-       LOS_CHILD,
-};
-
 #endif

diff --git a/lustre/ofd/ofd_internal.h b/lustre/ofd/ofd_internal.h
index dbc10e8..60174fd 100644 (file)
--- a/lustre/ofd/ofd_internal.h
+++ b/lustre/ofd/ofd_internal.h
@@ -477,4 +477,5 @@ static inline int ofd_validate_seq(struct obd_export *exp, __u64 seq)
 
        return 0;
 }
+
 #endif /* _OFD_INTERNAL_H */

diff --git a/lustre/ofd/ofd_objects.c b/lustre/ofd/ofd_objects.c
index 3e71d4b..a30f42f 100644 (file)
--- a/lustre/ofd/ofd_objects.c
+++ b/lustre/ofd/ofd_objects.c
@@ -320,7 +320,7 @@ int ofd_precreate_objects(const struct lu_env *env, struct ofd_device *ofd,
          * may cannot get latest last_id although new OST-object created. */
        if (!OBD_FAIL_CHECK(OBD_FAIL_LFSCK_SKIP_LASTID)) {
                tmp = cpu_to_le64(id + nr - 1);
-               dt_write_lock(env, oseq->os_lastid_obj, 0);
+               dt_write_lock(env, oseq->os_lastid_obj, DT_LASTID);
                rc = dt_record_write(env, oseq->os_lastid_obj,
                                     &info->fti_buf, &info->fti_off, th);
                dt_write_unlock(env, oseq->os_lastid_obj);
@@ -368,7 +368,7 @@ int ofd_precreate_objects(const struct lu_env *env, struct ofd_device *ofd,
 
                info->fti_off = 0;
                tmp = cpu_to_le64(ofd_seq_last_oid(oseq));
-               dt_write_lock(env, oseq->os_lastid_obj, 0);
+               dt_write_lock(env, oseq->os_lastid_obj, DT_LASTID);
                rc1 = dt_record_write(env, oseq->os_lastid_obj,
                                      &info->fti_buf, &info->fti_off, th);
                dt_write_unlock(env, oseq->os_lastid_obj);

diff --git a/lustre/osp/osp_md_object.c b/lustre/osp/osp_md_object.c
index fb1c055..864462e 100644 (file)
--- a/lustre/osp/osp_md_object.c
+++ b/lustre/osp/osp_md_object.c
@@ -363,7 +363,7 @@ int osp_md_attr_set(const struct lu_env *env, struct dt_object *dt,
  *
  * \param[in] env      execution environment
  * \param[in] dt       object to be locked
- * \param[in] role     lock role from MDD layer, see mdd_object_role().
+ * \param[in] role     lock role from MDD layer, see dt_object_role().
  */
 static void osp_md_read_lock(const struct lu_env *env, struct dt_object *dt,
                             unsigned role)
@@ -383,7 +383,7 @@ static void osp_md_read_lock(const struct lu_env *env, struct dt_object *dt,
  *
  * \param[in] env      execution environment
  * \param[in] dt       object to be locked
- * \param[in] role     lock role from MDD layer, see mdd_object_role().
+ * \param[in] role     lock role from MDD layer, see dt_object_role().
  */
 static void osp_md_write_lock(const struct lu_env *env, struct dt_object *dt,
                              unsigned role)

diff --git a/lustre/target/out_handler.c b/lustre/target/out_handler.c
index 910f9b0..f3ec5a7 100644 (file)
--- a/lustre/target/out_handler.c
+++ b/lustre/target/out_handler.c
@@ -217,7 +217,7 @@ static int out_attr_get(struct tgt_session_info *tsi)
                RETURN(-ENOENT);
        }
 
-       dt_read_lock(env, obj, MOR_TGT_CHILD);
+       dt_read_lock(env, obj, DT_TGT_CHILD);
        rc = dt_attr_get(env, obj, la);
        if (rc)
                GOTO(out_unlock, rc);
@@ -279,7 +279,7 @@ static int out_xattr_get(struct tgt_session_info *tsi)
        else
                lbuf->lb_buf = update_result->our_data;
 
-       dt_read_lock(env, obj, MOR_TGT_CHILD);
+       dt_read_lock(env, obj, DT_TGT_CHILD);
        rc = dt_xattr_get(env, obj, lbuf, name);
        dt_read_unlock(env, obj);
        if (rc <= 0) {
@@ -332,7 +332,7 @@ static int out_xattr_list(struct tgt_session_info *tsi)
        if (lbuf->lb_len == 0)
                lbuf->lb_buf = 0;
 
-       dt_read_lock(env, obj, MOR_TGT_CHILD);
+       dt_read_lock(env, obj, DT_TGT_CHILD);
        rc = dt_xattr_list(env, obj, lbuf);
        dt_read_unlock(env, obj);
        if (rc <= 0) {
@@ -377,7 +377,7 @@ static int out_index_lookup(struct tgt_session_info *tsi)
                RETURN(PTR_ERR(name));
        }
 
-       dt_read_lock(env, obj, MOR_TGT_CHILD);
+       dt_read_lock(env, obj, DT_TGT_CHILD);
        if (!dt_try_as_dir(env, obj))
                GOTO(out_unlock, rc = -ENOTDIR);
 
@@ -733,7 +733,7 @@ static int out_read(struct tgt_session_info *tsi)
                        GOTO(out_free, rc = -ENOMEM);
 
                rdbuf->rb_bufs[i].lb_len = read_size;
-               dt_read_lock(env, obj, MOR_TGT_CHILD);
+               dt_read_lock(env, obj, DT_TGT_CHILD);
                rc = dt_read(env, obj, &rdbuf->rb_bufs[i], &pos);
                dt_read_unlock(env, obj);
 

diff --git a/lustre/target/out_lib.c b/lustre/target/out_lib.c
index e8bdfd1..173e4d4 100644 (file)
--- a/lustre/target/out_lib.c
+++ b/lustre/target/out_lib.c
@@ -509,7 +509,7 @@ static int out_obj_destroy(const struct lu_env *env, struct dt_object *dt_obj,
        CDEBUG(D_INFO, "%s: destroy "DFID"\n", dt_obd_name(th->th_dev),
               PFID(lu_object_fid(&dt_obj->do_lu)));
 
-       dt_write_lock(env, dt_obj, MOR_TGT_CHILD);
+       dt_write_lock(env, dt_obj, DT_TGT_CHILD);
        rc = dt_destroy(env, dt_obj, th);
        dt_write_unlock(env, dt_obj);
 
@@ -547,7 +547,7 @@ int out_tx_create_exec(const struct lu_env *env, struct thandle *th,
               arg->u.create.dof.dof_type,
               arg->u.create.attr.la_mode & S_IFMT);
 
-       dt_write_lock(env, dt_obj, MOR_TGT_CHILD);
+       dt_write_lock(env, dt_obj, DT_TGT_CHILD);
        rc = dt_create(env, dt_obj, &arg->u.create.attr,
                       &arg->u.create.hint, &arg->u.create.dof, th);
 
@@ -640,7 +640,7 @@ static int out_tx_attr_set_exec(const struct lu_env *env, struct thandle *th,
        CDEBUG(D_OTHER, "%s: attr set "DFID"\n", dt_obd_name(th->th_dev),
               PFID(lu_object_fid(&dt_obj->do_lu)));
 
-       dt_write_lock(env, dt_obj, MOR_TGT_CHILD);
+       dt_write_lock(env, dt_obj, DT_TGT_CHILD);
        rc = dt_attr_set(env, dt_obj, &arg->u.attr_set.attr, th);
        dt_write_unlock(env, dt_obj);
 
@@ -697,7 +697,7 @@ static int out_tx_write_exec(const struct lu_env *env, struct thandle *th,
        if (OBD_FAIL_CHECK(OBD_FAIL_OUT_ENOSPC)) {
                rc = -ENOSPC;
        } else {
-               dt_write_lock(env, dt_obj, MOR_TGT_CHILD);
+               dt_write_lock(env, dt_obj, DT_TGT_CHILD);
                rc = dt_record_write(env, dt_obj, &arg->u.write.buf,
                                     &arg->u.write.pos, th);
                dt_write_unlock(env, dt_obj);
@@ -820,7 +820,7 @@ static int out_tx_xattr_set_exec(const struct lu_env *env,
                        linkea = false;
                }
 
-               dt_write_lock(env, dt_obj, MOR_TGT_CHILD);
+               dt_write_lock(env, dt_obj, DT_TGT_CHILD);
 
 again:
                rc = dt_xattr_set(env, dt_obj, ldata.ld_buf,
@@ -893,7 +893,7 @@ static int out_tx_xattr_del_exec(const struct lu_env *env, struct thandle *th,
        if (!lu_object_exists(&dt_obj->do_lu))
                GOTO(out, rc = -ENOENT);
 
-       dt_write_lock(env, dt_obj, MOR_TGT_CHILD);
+       dt_write_lock(env, dt_obj, DT_TGT_CHILD);
        rc = dt_xattr_del(env, dt_obj, arg->u.xattr_set.name,
                          th);
        dt_write_unlock(env, dt_obj);
@@ -939,7 +939,7 @@ static int out_obj_ref_add(const struct lu_env *env,
 {
        int rc;
 
-       dt_write_lock(env, dt_obj, MOR_TGT_CHILD);
+       dt_write_lock(env, dt_obj, DT_TGT_CHILD);
        rc = dt_ref_add(env, dt_obj, th);
        dt_write_unlock(env, dt_obj);
 
@@ -952,7 +952,7 @@ static int out_obj_ref_del(const struct lu_env *env,
 {
        int rc;
 
-       dt_write_lock(env, dt_obj, MOR_TGT_CHILD);
+       dt_write_lock(env, dt_obj, DT_TGT_CHILD);
        rc = dt_ref_del(env, dt_obj, th);
        dt_write_unlock(env, dt_obj);
 
@@ -1072,7 +1072,7 @@ static int out_obj_index_insert(const struct lu_env *env,
        if (dt_try_as_dir(env, dt_obj) == 0)
                return -ENOTDIR;
 
-       dt_write_lock(env, dt_obj, MOR_TGT_CHILD);
+       dt_write_lock(env, dt_obj, DT_TGT_CHILD);
        rc = dt_insert(env, dt_obj, rec, key, th);
        dt_write_unlock(env, dt_obj);
 
@@ -1093,7 +1093,7 @@ static int out_obj_index_delete(const struct lu_env *env,
        if (dt_try_as_dir(env, dt_obj) == 0)
                return -ENOTDIR;
 
-       dt_write_lock(env, dt_obj, MOR_TGT_CHILD);
+       dt_write_lock(env, dt_obj, DT_TGT_CHILD);
        rc = dt_delete(env, dt_obj, key, th);
        dt_write_unlock(env, dt_obj);