LU-14520 ldlm: rename LCK_MAXMODE/LDLM_MAX_TYPE

Rename the "MAX" definitions for the ldlm_type and ldlm_mode enums,
since they do not actually represent the "maximum" value of the enum.
They are also better named following the enum, while we are at it.

    LCK_MINMODE -> LCK_MODE_MIN
    LCK_MAXMODE -> LCK_MODE_END
    LDLM_MIN_TYPE -> LDLM_TYPE_MIN
    LDLM_MAX_TYPE -> LDLM_TYPE_END

Add spelling.txt rules to notify in-flight patches of this change, but
include backward compatibility macros since they are in lustre_idl.h.

Test-Parameters: trivial
Signed-off-by: Andreas Dilger <adilger@whamcloud.com>
Change-Id: Ia709775ffc60092883971853470195678b2b9b08
Reviewed-on: https://review.whamcloud.com/c/fs/lustre-release/+/56760
Tested-by: jenkins <devops@whamcloud.com>
Tested-by: Maloo <maloo@whamcloud.com>
Reviewed-by: Timothy Day <timday@amazon.com>
Reviewed-by: James Simmons <jsimmons@infradead.org>
Reviewed-by: Arshad Hussain <arshad.hussain@aeoncomputing.com>
Reviewed-by: Oleg Drokin <green@whamcloud.com>

diff --git a/contrib/scripts/spelling.txt b/contrib/scripts/spelling.txt
index 886a721..8b28f51 100644 (file)
--- a/contrib/scripts/spelling.txt
+++ b/contrib/scripts/spelling.txt
@@ -54,6 +54,8 @@ f_dentry||f_path.dentry
 [^_]get_seconds||ktime_get_real_seconds
 it_flags||it_open_flags
 kmem_cache_alloc.*GFP_ZERO||kmem_cache_zalloc
+LCK_MINMODE||LCK_MODE_MIN
+LCK_MAXMODE||LCK_MODE_END
 ldebugfs_remove||debugfs_remove_recursive
 ldlm_appetite_t||enum ldlm_appetite
 ldlm_cancel_flags_t||enum ldlm_cancel_flags
@@ -64,6 +66,7 @@ ldlm_ns_type_t||enum ldlm_ns_type
 ldlm_policy_data_t||enum ldlm_policy_data
 ldlm_policy_res_t||enum ldlm_policy_res
 ldlm_side_t||enum ldlm_side
+LDLM_TYPE_MAX||LDLM_TYPE_END
 ldlm_type_t||enum ldlm_type
 ldlm_wire_policy_data_t||union ldlm_wire_policy_data
 libcfs_debug_vmsg2||libcfs_debug_msg

diff --git a/lustre/include/lustre_dlm.h b/lustre/include/lustre_dlm.h
index d7c9bb3..541347d 100644 (file)
--- a/lustre/include/lustre_dlm.h
+++ b/lustre/include/lustre_dlm.h
@@ -150,7 +150,7 @@ extern enum ldlm_mode lck_compat_array[];
 
 static inline void lockmode_verify(enum ldlm_mode mode)
 {
-       LASSERT(mode > LCK_MINMODE && mode < LCK_MAXMODE);
+       LASSERT(mode > LCK_MODE_MIN && mode < LCK_MODE_END);
 }
 
 static inline int lockmode_compat(enum ldlm_mode exist_mode,

diff --git a/lustre/include/uapi/linux/lustre/lustre_idl.h b/lustre/include/uapi/linux/lustre/lustre_idl.h
index d73ec61..83c881a 100644 (file)
--- a/lustre/include/uapi/linux/lustre/lustre_idl.h
+++ b/lustre/include/uapi/linux/lustre/lustre_idl.h
@@ -2514,7 +2514,7 @@ struct ldlm_res_id {
 
 /* lock types */
 enum ldlm_mode {
-       LCK_MINMODE     = 0,
+       LCK_MODE_MIN    = 0,
        LCK_EX          = 1,
        LCK_PW          = 2,
        LCK_PR          = 4,
@@ -2524,9 +2524,11 @@ enum ldlm_mode {
        LCK_GROUP       = 64,
        LCK_COS         = 128,
        LCK_TXN         = 256,
-       LCK_MAXMODE
+       LCK_MODE_END
 };
 
+#define LCK_MINMODE    LCK_MODE_MIN /* deprecated since 2.16.0 */
+#define LCK_MAXMODE    LCK_MODE_MAX /* deprecated since 2.16.0 */
 #define LCK_MODE_NUM    9
 
 enum ldlm_type {
@@ -2534,10 +2536,12 @@ enum ldlm_type {
        LDLM_EXTENT     = 11,
        LDLM_FLOCK      = 12,
        LDLM_IBITS      = 13,
-       LDLM_MAX_TYPE
+       LDLM_TYPE_END,
+       LDLM_TYPE_MIN   = LDLM_PLAIN
 };
 
-#define LDLM_MIN_TYPE LDLM_PLAIN
+#define LDLM_TYPE_MAX  LDLM_TYPE_END /* deprecated since 2.16.0 */
+
 
 struct ldlm_extent {
        __u64 start;

diff --git a/lustre/ldlm/ldlm_lock.c b/lustre/ldlm/ldlm_lock.c
index 001bc1a..d9625e4 100644 (file)
--- a/lustre/ldlm/ldlm_lock.c
+++ b/lustre/ldlm/ldlm_lock.c
@@ -49,17 +49,17 @@ char *ldlm_typename[] = {
 };
 
 static ldlm_policy_wire_to_local_t ldlm_policy_wire_to_local[] = {
-       [LDLM_PLAIN - LDLM_MIN_TYPE]  = ldlm_plain_policy_wire_to_local,
-       [LDLM_EXTENT - LDLM_MIN_TYPE] = ldlm_extent_policy_wire_to_local,
-       [LDLM_FLOCK - LDLM_MIN_TYPE]  = ldlm_flock_policy_wire_to_local,
-       [LDLM_IBITS - LDLM_MIN_TYPE]  = ldlm_ibits_policy_wire_to_local,
+       [LDLM_PLAIN - LDLM_TYPE_MIN]  = ldlm_plain_policy_wire_to_local,
+       [LDLM_EXTENT - LDLM_TYPE_MIN] = ldlm_extent_policy_wire_to_local,
+       [LDLM_FLOCK - LDLM_TYPE_MIN]  = ldlm_flock_policy_wire_to_local,
+       [LDLM_IBITS - LDLM_TYPE_MIN]  = ldlm_ibits_policy_wire_to_local,
 };
 
 static ldlm_policy_local_to_wire_t ldlm_policy_local_to_wire[] = {
-       [LDLM_PLAIN - LDLM_MIN_TYPE]  = ldlm_plain_policy_local_to_wire,
-       [LDLM_EXTENT - LDLM_MIN_TYPE] = ldlm_extent_policy_local_to_wire,
-       [LDLM_FLOCK - LDLM_MIN_TYPE]  = ldlm_flock_policy_local_to_wire,
-       [LDLM_IBITS - LDLM_MIN_TYPE]  = ldlm_ibits_policy_local_to_wire,
+       [LDLM_PLAIN - LDLM_TYPE_MIN]  = ldlm_plain_policy_local_to_wire,
+       [LDLM_EXTENT - LDLM_TYPE_MIN] = ldlm_extent_policy_local_to_wire,
+       [LDLM_FLOCK - LDLM_TYPE_MIN]  = ldlm_flock_policy_local_to_wire,
+       [LDLM_IBITS - LDLM_TYPE_MIN]  = ldlm_ibits_policy_local_to_wire,
 };
 
 /**
@@ -71,7 +71,7 @@ void ldlm_convert_policy_to_wire(enum ldlm_type type,
 {
        ldlm_policy_local_to_wire_t convert;
 
-       convert = ldlm_policy_local_to_wire[type - LDLM_MIN_TYPE];
+       convert = ldlm_policy_local_to_wire[type - LDLM_TYPE_MIN];
 
        convert(lpolicy, wpolicy);
 }
@@ -85,7 +85,7 @@ void ldlm_convert_policy_to_local(struct obd_export *exp, enum ldlm_type type,
 {
        ldlm_policy_wire_to_local_t convert;
 
-       convert = ldlm_policy_wire_to_local[type - LDLM_MIN_TYPE];
+       convert = ldlm_policy_wire_to_local[type - LDLM_TYPE_MIN];
 
        convert(wpolicy, lpolicy);
 }
@@ -461,7 +461,7 @@ static struct ldlm_lock *ldlm_lock_new(struct ldlm_resource *resource)
                RB_CLEAR_NODE(&lock->l_rb);
                INIT_LIST_HEAD(&lock->l_same_extent);
                break;
-       case LDLM_MAX_TYPE:
+       case LDLM_TYPE_END:
                break;
        }
        INIT_HLIST_NODE(&lock->l_exp_hash);
@@ -1164,7 +1164,7 @@ static bool lock_matches(struct ldlm_lock *lock, void *vdata)
 {
        struct ldlm_match_data *data = vdata;
        union ldlm_policy_data *lpol = &lock->l_policy_data;
-       enum ldlm_mode match = LCK_MINMODE;
+       enum ldlm_mode match = LCK_MODE_MIN;
 
        if (lock == data->lmd_old)
                return true;
@@ -2530,7 +2530,7 @@ void ldlm_lock_cancel(struct ldlm_lock *lock)
                ldlm_pool_del(&ns->ns_pool, lock);
 
        /* should not be called again for same lock(zero out l_granted_mode) */
-       lock->l_granted_mode = LCK_MINMODE;
+       lock->l_granted_mode = LCK_MODE_MIN;
        unlock_res_and_lock(lock);
 
        EXIT;
@@ -2720,7 +2720,7 @@ void ldlm_lock_mode_downgrade(struct ldlm_lock *lock, enum ldlm_mode new_mode)
        if (!(lock->l_granted_mode & (LCK_PW | LCK_EX))) {
                unlock_res_and_lock(lock);
 
-               LASSERT(lock->l_granted_mode == LCK_MINMODE);
+               LASSERT(lock->l_granted_mode == LCK_MODE_MIN);
                LDLM_DEBUG(lock, "lock was canceled before downgrade");
                RETURN_EXIT;
        }

diff --git a/lustre/ldlm/ldlm_lockd.c b/lustre/ldlm/ldlm_lockd.c
index 686d848..498cb87 100644 (file)
--- a/lustre/ldlm/ldlm_lockd.c
+++ b/lustre/ldlm/ldlm_lockd.c
@@ -1327,15 +1327,15 @@ int ldlm_handle_enqueue(struct ldlm_namespace *ns,
                lprocfs_counter_incr(req->rq_export->exp_nid_stats->nid_ldlm_stats,
                                     LDLM_ENQUEUE - LDLM_FIRST_OPC);
 
-       if (unlikely(dlm_req->lock_desc.l_resource.lr_type < LDLM_MIN_TYPE ||
-                    dlm_req->lock_desc.l_resource.lr_type >= LDLM_MAX_TYPE)) {
+       if (unlikely(dlm_req->lock_desc.l_resource.lr_type < LDLM_TYPE_MIN ||
+                    dlm_req->lock_desc.l_resource.lr_type >= LDLM_TYPE_END)) {
                DEBUG_REQ(D_ERROR, req, "invalid lock request type %d",
                          dlm_req->lock_desc.l_resource.lr_type);
                GOTO(out, rc = -EFAULT);
        }
 
-       if (unlikely(dlm_req->lock_desc.l_req_mode <= LCK_MINMODE ||
-                    dlm_req->lock_desc.l_req_mode >= LCK_MAXMODE ||
+       if (unlikely(dlm_req->lock_desc.l_req_mode <= LCK_MODE_MIN ||
+                    dlm_req->lock_desc.l_req_mode >= LCK_MODE_END ||
                     dlm_req->lock_desc.l_req_mode &
                     (dlm_req->lock_desc.l_req_mode-1))) {
                DEBUG_REQ(D_ERROR, req, "invalid lock request mode %d",
@@ -3513,9 +3513,9 @@ static int ldlm_cleanup(void)
 
 int ldlm_init(void)
 {
-       BUILD_BUG_ON(LDLM_MAX_TYPE > (1 << 4 /* lr_type bits */));
+       BUILD_BUG_ON(LDLM_TYPE_END  > (1 << 4 /* lr_type bits */));
        BUILD_BUG_ON(LVB_T_END      > (1 << 3 /* l_lvb_type bits */));
-       BUILD_BUG_ON(LCK_MAXMODE   > (1 << 9 /* l_req_mode/l_granted_mode */));
+       BUILD_BUG_ON(LCK_MODE_END   > (1 << 9 /* l_req_mode/l_granted_mode */));
 
        ldlm_resource_slab = kmem_cache_create("ldlm_resources",
                                               sizeof(struct ldlm_resource), 0,

diff --git a/lustre/ldlm/ldlm_request.c b/lustre/ldlm/ldlm_request.c
index 9f4d32d..81133ff 100644 (file)
--- a/lustre/ldlm/ldlm_request.c
+++ b/lustre/ldlm/ldlm_request.c
@@ -2330,7 +2330,7 @@ ldlm_cli_hash_cancel_unused(struct cfs_hash *hs, struct cfs_hash_bd *bd,
        struct ldlm_cli_cancel_arg     *lc = arg;
 
        ldlm_cli_cancel_unused_resource(ldlm_res_to_ns(res), &res->lr_name,
-                                       NULL, LCK_MINMODE, lc->lc_flags,
+                                       NULL, LCK_MODE_MIN, lc->lc_flags,
                                        lc->lc_opaque);
        /* must return 0 for hash iteration */
        return 0;
@@ -2359,7 +2359,7 @@ int ldlm_cli_cancel_unused(struct ldlm_namespace *ns,
 
        if (res_id != NULL) {
                RETURN(ldlm_cli_cancel_unused_resource(ns, res_id, NULL,
-                                                      LCK_MINMODE, flags,
+                                                      LCK_MODE_MIN, flags,
                                                       opaque));
        } else {
                cfs_hash_for_each_nolock(ns->ns_rs_hash,

diff --git a/lustre/ldlm/ldlm_resource.c b/lustre/ldlm/ldlm_resource.c
index 2c453f9..5d976b7 100644 (file)
--- a/lustre/ldlm/ldlm_resource.c
+++ b/lustre/ldlm/ldlm_resource.c
@@ -1546,7 +1546,7 @@ ldlm_resource_get(struct ldlm_namespace *ns, const struct ldlm_res_id *name,
        if (create == 0)
                return ERR_PTR(-ENOENT);
 
-       LASSERTF(type >= LDLM_MIN_TYPE && type < LDLM_MAX_TYPE,
+       LASSERTF(type >= LDLM_TYPE_MIN && type < LDLM_TYPE_END,
                 "type: %d\n", type);
        res = ldlm_resource_new(type);
        if (res == NULL)

diff --git a/lustre/llite/dir.c b/lustre/llite/dir.c
index e1f0dcc..ee4bf10 100644 (file)
--- a/lustre/llite/dir.c
+++ b/lustre/llite/dir.c
@@ -340,7 +340,7 @@ static int ll_readdir(struct file *filp, void *cookie, filldir_t filldir)
                        struct obd_export *exp = ll_i2mdexp(i_dir);
                        enum mds_ibits_locks ibits = MDS_INODELOCK_LOOKUP;
 
-                       if (ll_have_md_lock(exp, i_dir, &ibits, LCK_MINMODE, 0))
+                       if (ll_have_md_lock(exp, i_dir, &ibits, LCK_MODE_MIN,0))
                                pfid = *ll_inode2fid(i_dir);
                }
                dput(parent);

diff --git a/lustre/llite/file.c b/lustre/llite/file.c
index ea0b766..ace2ec9 100644 (file)
--- a/lustre/llite/file.c
+++ b/lustre/llite/file.c
@@ -5897,7 +5897,7 @@ int ll_have_md_lock(struct obd_export *exp, struct inode *inode,
 {
        struct lustre_handle lockh;
        union ldlm_policy_data policy;
-       enum ldlm_mode mode = (l_req_mode == LCK_MINMODE) ?
+       enum ldlm_mode mode = (l_req_mode == LCK_MODE_MIN) ?
                              (LCK_CR | LCK_CW | LCK_PR | LCK_PW) : l_req_mode;
        struct lu_fid *fid;
        __u64 flags;

diff --git a/lustre/llite/namei.c b/lustre/llite/namei.c
index 90c8681..738ca26 100644 (file)
--- a/lustre/llite/namei.c
+++ b/lustre/llite/namei.c
@@ -286,8 +286,8 @@ static void ll_lock_cancel_bits(struct ldlm_lock *lock,
        if (bits & (MDS_INODELOCK_LOOKUP | MDS_INODELOCK_UPDATE |
                    MDS_INODELOCK_LAYOUT | MDS_INODELOCK_PERM |
                    MDS_INODELOCK_DOM))
-               ll_have_md_lock(lock->l_conn_export, inode, &bits, LCK_MINMODE,
-                               0);
+               ll_have_md_lock(lock->l_conn_export, inode, &bits,
+                               LCK_MODE_MIN, 0);
 
        if (bits & MDS_INODELOCK_DOM) {
                rc =  ll_dom_lock_cancel(inode, lock);
@@ -388,7 +388,7 @@ static int ll_md_need_convert(struct ldlm_lock *lock)
 {
        struct ldlm_namespace *ns = ldlm_lock_to_ns(lock);
        __u64 wanted = lock->l_policy_data.l_inodebits.cancel_bits;
-       enum ldlm_mode mode = LCK_MINMODE;
+       enum ldlm_mode mode = LCK_MODE_MIN;
        enum mds_ibits_locks bits;
        struct inode *inode;
 

diff --git a/lustre/lmv/lmv_obd.c b/lustre/lmv/lmv_obd.c
index b83ebe9..9b7d205 100644 (file)
--- a/lustre/lmv/lmv_obd.c
+++ b/lustre/lmv/lmv_obd.c
@@ -3951,7 +3951,7 @@ lmv_lock_match(struct obd_export *exp, __u64 flags,
        struct lmv_obd *lmv = &obd->u.lmv;
        struct lu_tgt_desc *tgt;
        __u64 bits = policy->l_inodebits.bits;
-       enum ldlm_mode rc = LCK_MINMODE;
+       enum ldlm_mode rc = LCK_MODE_MIN;
        int index;
        int i;
 

diff --git a/lustre/mdt/mdt_handler.c b/lustre/mdt/mdt_handler.c
index cebe87f..0ae495c 100644 (file)
--- a/lustre/mdt/mdt_handler.c
+++ b/lustre/mdt/mdt_handler.c
@@ -84,18 +84,18 @@ MODULE_PARM_DESC(max_mod_rpcs_per_client,
 #endif
 
 mdl_mode_t mdt_mdl_lock_modes[] = {
-       [LCK_MINMODE] = MDL_MINMODE,
-       [LCK_EX]      = MDL_EX,
-       [LCK_PW]      = MDL_PW,
-       [LCK_PR]      = MDL_PR,
-       [LCK_CW]      = MDL_CW,
-       [LCK_CR]      = MDL_CR,
-       [LCK_NL]      = MDL_NL,
-       [LCK_GROUP]   = MDL_GROUP
+       [LCK_MODE_MIN]  = MDL_MINMODE,
+       [LCK_EX]        = MDL_EX,
+       [LCK_PW]        = MDL_PW,
+       [LCK_PR]        = MDL_PR,
+       [LCK_CW]        = MDL_CW,
+       [LCK_CR]        = MDL_CR,
+       [LCK_NL]        = MDL_NL,
+       [LCK_GROUP]     = MDL_GROUP
 };
 
 enum ldlm_mode mdt_dlm_lock_modes[] = {
-       [MDL_MINMODE]   = LCK_MINMODE,
+       [MDL_MINMODE]   = LCK_MODE_MIN,
        [MDL_EX]        = LCK_EX,
        [MDL_PW]        = LCK_PW,
        [MDL_PR]        = LCK_PR,
@@ -197,7 +197,7 @@ void mdt_lock_pdo_init(struct mdt_lock_handle *lh, enum ldlm_mode lock_mode,
 {
        mdt_lock_handle_assert(lh);
        lh->mlh_reg_mode = lock_mode;
-       lh->mlh_pdo_mode = LCK_MINMODE;
+       lh->mlh_pdo_mode = LCK_MODE_MIN;
        lh->mlh_rreg_mode = lock_mode;
        lh->mlh_type = MDT_PDO_LOCK;
 
@@ -247,8 +247,8 @@ static void mdt_lock_pdo_mode(struct mdt_thread_info *info, struct mdt_object *o
         * (lookup/modify/split) - LCK_EX --bzzz
         */
 
-       LASSERT(lh->mlh_reg_mode != LCK_MINMODE);
-       LASSERT(lh->mlh_pdo_mode == LCK_MINMODE);
+       LASSERT(lh->mlh_reg_mode != LCK_MODE_MIN);
+       LASSERT(lh->mlh_pdo_mode == LCK_MODE_MIN);
 
        /*
         * Ask underlaying level its opinion about preferable PDO lock mode
@@ -290,7 +290,7 @@ static void mdt_lock_pdo_mode(struct mdt_thread_info *info, struct mdt_object *o
                }
        }
 
-       LASSERT(lh->mlh_pdo_mode != LCK_MINMODE);
+       LASSERT(lh->mlh_pdo_mode != LCK_MODE_MIN);
        EXIT;
 }
 
@@ -4027,7 +4027,7 @@ int mdt_object_lock_internal(struct mdt_thread_info *info,
        if (obj && mdt_object_remote(obj)) {
                handle = &lh->mlh_rreg_lh;
                LASSERT(!lustre_handle_is_used(handle));
-               LASSERT(lh->mlh_rreg_mode != LCK_MINMODE);
+               LASSERT(lh->mlh_rreg_mode != LCK_MODE_MIN);
                LASSERT(lh->mlh_type != MDT_NUL_LOCK);
                rc = mdt_remote_object_lock_try(info, obj, handle,
                                                lh->mlh_rreg_mode, policy,
@@ -4045,7 +4045,7 @@ int mdt_object_lock_internal(struct mdt_thread_info *info,
 
                handle = &lh->mlh_reg_lh;
                LASSERT(!lustre_handle_is_used(handle));
-               LASSERT(lh->mlh_reg_mode != LCK_MINMODE);
+               LASSERT(lh->mlh_reg_mode != LCK_MODE_MIN);
                LASSERT(lh->mlh_type != MDT_NUL_LOCK);
 
                /* Lease lock are granted with LDLM_FL_CANCEL_ON_BLOCK */

diff --git a/lustre/mdt/mdt_internal.h b/lustre/mdt/mdt_internal.h
index 19febc4..59444c3 100644 (file)
--- a/lustre/mdt/mdt_internal.h
+++ b/lustre/mdt/mdt_internal.h
@@ -1278,11 +1278,11 @@ static inline bool mdt_slc_is_enabled(struct mdt_device *mdt)
 extern mdl_mode_t mdt_mdl_lock_modes[];
 extern enum ldlm_mode mdt_dlm_lock_modes[];
 
-/* LCK_MINMODE which is zero returns false for is_power_of_2 */
+/* LCK_MODE_MIN which is zero returns false for is_power_of_2 */
 
 static inline mdl_mode_t mdt_dlm_mode2mdl_mode(enum ldlm_mode mode)
 {
-       LASSERT(mode == LCK_MINMODE || is_power_of_2(mode));
+       LASSERT(mode == LCK_MODE_MIN || is_power_of_2(mode));
        return mdt_mdl_lock_modes[mode];
 }
 

diff --git a/lustre/osc/osc_object.c b/lustre/osc/osc_object.c
index 9e3afb7..4da9aa5 100644 (file)
--- a/lustre/osc/osc_object.c
+++ b/lustre/osc/osc_object.c
@@ -240,7 +240,7 @@ static int osc_object_fiemap(const struct lu_env *env, struct cl_object *obj,
        struct ldlm_res_id resid;
        union ldlm_policy_data policy;
        struct lustre_handle lockh;
-       enum ldlm_mode mode = LCK_MINMODE;
+       enum ldlm_mode mode = LCK_MODE_MIN;
        struct ptlrpc_request *req;
        struct fiemap *reply;
        char *tmp;

diff --git a/lustre/ptlrpc/wiretest.c b/lustre/ptlrpc/wiretest.c
index dbff368..e71f8de 100644 (file)
--- a/lustre/ptlrpc/wiretest.c
+++ b/lustre/ptlrpc/wiretest.c
@@ -299,8 +299,8 @@ void lustre_assert_wire_constants(void)
                 (long long)LDLM_SET_INFO);
        LASSERTF(LDLM_LAST_OPC == 108, "found %lld\n",
                 (long long)LDLM_LAST_OPC);
-       LASSERTF(LCK_MINMODE == 0, "found %lld\n",
-                (long long)LCK_MINMODE);
+       LASSERTF(LCK_MODE_MIN == 0, "found %lld\n",
+                (long long)LCK_MODE_MIN);
        LASSERTF(LCK_EX == 1, "found %lld\n",
                 (long long)LCK_EX);
        LASSERTF(LCK_PW == 2, "found %lld\n",
@@ -319,15 +319,15 @@ void lustre_assert_wire_constants(void)
                 (long long)LCK_COS);
        LASSERTF(LCK_TXN == 256, "found %lld\n",
                 (long long)LCK_TXN);
-       LASSERTF(LCK_MAXMODE == 257, "found %lld\n",
-                (long long)LCK_MAXMODE);
+       LASSERTF(LCK_MODE_END == 257, "found %lld\n",
+                (long long)LCK_MODE_END);
        LASSERTF(LCK_MODE_NUM == 9, "found %lld\n",
                 (long long)LCK_MODE_NUM);
        BUILD_BUG_ON(LDLM_PLAIN != 10);
        BUILD_BUG_ON(LDLM_EXTENT != 11);
        BUILD_BUG_ON(LDLM_FLOCK != 12);
        BUILD_BUG_ON(LDLM_IBITS != 13);
-       BUILD_BUG_ON(LDLM_MAX_TYPE != 14);
+       BUILD_BUG_ON(LDLM_TYPE_END != 14);
        BUILD_BUG_ON(LUSTRE_RES_ID_SEQ_OFF != 0);
        BUILD_BUG_ON(LUSTRE_RES_ID_VER_OID_OFF != 1);
        BUILD_BUG_ON(LUSTRE_RES_ID_QUOTA_SEQ_OFF != 2);

diff --git a/lustre/utils/wirecheck.c b/lustre/utils/wirecheck.c
index 4c7e572..87d509f 100644 (file)
--- a/lustre/utils/wirecheck.c
+++ b/lustre/utils/wirecheck.c
@@ -3552,7 +3552,7 @@ main(int argc, char **argv)
        CHECK_VALUE(LDLM_SET_INFO);
        CHECK_VALUE(LDLM_LAST_OPC);
 
-       CHECK_VALUE(LCK_MINMODE);
+       CHECK_VALUE(LCK_MODE_MIN);
        CHECK_VALUE(LCK_EX);
        CHECK_VALUE(LCK_PW);
        CHECK_VALUE(LCK_PR);
@@ -3562,14 +3562,14 @@ main(int argc, char **argv)
        CHECK_VALUE(LCK_GROUP);
        CHECK_VALUE(LCK_COS);
        CHECK_VALUE(LCK_TXN);
-       CHECK_VALUE(LCK_MAXMODE);
+       CHECK_VALUE(LCK_MODE_END);
        CHECK_VALUE(LCK_MODE_NUM);
 
        CHECK_CVALUE(LDLM_PLAIN);
        CHECK_CVALUE(LDLM_EXTENT);
        CHECK_CVALUE(LDLM_FLOCK);
        CHECK_CVALUE(LDLM_IBITS);
-       CHECK_CVALUE(LDLM_MAX_TYPE);
+       CHECK_CVALUE(LDLM_TYPE_END);
 
        CHECK_CVALUE(LUSTRE_RES_ID_SEQ_OFF);
        CHECK_CVALUE(LUSTRE_RES_ID_VER_OID_OFF);

diff --git a/lustre/utils/wiretest.c b/lustre/utils/wiretest.c
index eb3e146..06757d0 100644 (file)
--- a/lustre/utils/wiretest.c
+++ b/lustre/utils/wiretest.c
@@ -342,8 +342,8 @@ void lustre_assert_wire_constants(void)
                 (long long)LDLM_SET_INFO);
        LASSERTF(LDLM_LAST_OPC == 108, "found %lld\n",
                 (long long)LDLM_LAST_OPC);
-       LASSERTF(LCK_MINMODE == 0, "found %lld\n",
-                (long long)LCK_MINMODE);
+       LASSERTF(LCK_MODE_MIN == 0, "found %lld\n",
+                (long long)LCK_MODE_MIN);
        LASSERTF(LCK_EX == 1, "found %lld\n",
                 (long long)LCK_EX);
        LASSERTF(LCK_PW == 2, "found %lld\n",
@@ -362,15 +362,15 @@ void lustre_assert_wire_constants(void)
                 (long long)LCK_COS);
        LASSERTF(LCK_TXN == 256, "found %lld\n",
                 (long long)LCK_TXN);
-       LASSERTF(LCK_MAXMODE == 257, "found %lld\n",
-                (long long)LCK_MAXMODE);
+       LASSERTF(LCK_MODE_END == 257, "found %lld\n",
+                (long long)LCK_MODE_END);
        LASSERTF(LCK_MODE_NUM == 9, "found %lld\n",
                 (long long)LCK_MODE_NUM);
        BUILD_BUG_ON(LDLM_PLAIN != 10);
        BUILD_BUG_ON(LDLM_EXTENT != 11);
        BUILD_BUG_ON(LDLM_FLOCK != 12);
        BUILD_BUG_ON(LDLM_IBITS != 13);
-       BUILD_BUG_ON(LDLM_MAX_TYPE != 14);
+       BUILD_BUG_ON(LDLM_TYPE_END != 14);
        BUILD_BUG_ON(LUSTRE_RES_ID_SEQ_OFF != 0);
        BUILD_BUG_ON(LUSTRE_RES_ID_VER_OID_OFF != 1);
        BUILD_BUG_ON(LUSTRE_RES_ID_QUOTA_SEQ_OFF != 2);