LU-14651 uapi: rename CONFIG_T_* to MGS_CFG_T_*

The Linux kernel uses CONFIG_* as a way to determine if a feature
is available. Using CONFIG_* in an UAPI is considered an error
and in the most recent kernels will break a build. While we don't
have any CONFIG_* in our UAPI headers we do have CONFIG_T_*
which is used for config logs. This naming confuses the Linux
kernel build system so just rename these variables to MGS_CFG_T_*
instead.

Test-Parameters: trivial
Change-Id: I574510c2da90e9ae608c9e2374d75220b7abb19d
Signed-off-by: James Simmons <jsimmons@infradead.org>
Reviewed-on: https://review.whamcloud.com/43494
Reviewed-by: Andreas Dilger <adilger@whamcloud.com>
Reviewed-by: Aurelien Degremont <degremoa@amazon.com>
Tested-by: jenkins <devops@whamcloud.com>
Tested-by: Maloo <maloo@whamcloud.com>
Reviewed-by: Oleg Drokin <green@whamcloud.com>

diff --git a/lustre/include/lustre_disk.h b/lustre/include/lustre_disk.h
index e87d7ee..b7dc9d0 100644 (file)
--- a/lustre/include/lustre_disk.h
+++ b/lustre/include/lustre_disk.h
@@ -362,8 +362,10 @@ int lustre_put_lsi(struct super_block *sb);
 int lmd_parse(char *options, struct lustre_mount_data *lmd);
 
 /* mgc_request.c */
-int mgc_fsname2resid(char *fsname, struct ldlm_res_id *res_id, int type);
-int mgc_logname2resid(char *fsname, struct ldlm_res_id *res_id, int type);
+int mgc_fsname2resid(char *fsname, struct ldlm_res_id *res_id,
+                    enum mgs_cfg_type type);
+int mgc_logname2resid(char *fsname, struct ldlm_res_id *res_id,
+                     enum mgs_cfg_type type);
 
 /** @} disk */
 

diff --git a/lustre/include/obd_class.h b/lustre/include/obd_class.h
index b1fc854..1dc5f12 100644 (file)
--- a/lustre/include/obd_class.h
+++ b/lustre/include/obd_class.h
@@ -261,7 +261,7 @@ struct config_llog_data {
        struct config_llog_data    *cld_barrier;/* barrier log (for MDT only) */
        struct obd_export          *cld_mgcexp;
        struct mutex                cld_lock;
-       int                         cld_type;
+       enum mgs_cfg_type           cld_type;
        unsigned int                cld_stopping:1, /* we were told to stop
                                                     * watching */
                                    cld_lostlock:1; /* lock not requeued */

diff --git a/lustre/include/uapi/linux/lustre/lustre_idl.h b/lustre/include/uapi/linux/lustre/lustre_idl.h
index 1218328..ff7765f 100644 (file)
--- a/lustre/include/uapi/linux/lustre/lustre_idl.h
+++ b/lustre/include/uapi/linux/lustre/lustre_idl.h
@@ -2613,20 +2613,20 @@ struct mgs_nidtbl_entry {
         } u;
 };
 
-enum {
-       CONFIG_T_CONFIG  = 0,
-       CONFIG_T_SPTLRPC = 1,
-       CONFIG_T_RECOVER = 2,
-       CONFIG_T_PARAMS  = 3,
-       CONFIG_T_NODEMAP = 4,
-       CONFIG_T_BARRIER = 5,
-       CONFIG_T_MAX
+enum mgs_cfg_type {
+       MGS_CFG_T_CONFIG        = 0,
+       MGS_CFG_T_SPTLRPC       = 1,
+       MGS_CFG_T_RECOVER       = 2,
+       MGS_CFG_T_PARAMS        = 3,
+       MGS_CFG_T_NODEMAP       = 4,
+       MGS_CFG_T_BARRIER       = 5,
+       MGS_CFG_T_MAX
 };
 
 struct mgs_config_body {
        char     mcb_name[MTI_NAME_MAXLEN]; /* logname */
        __u64    mcb_offset;    /* next index of config log to request */
-       __u16    mcb_type;      /* type of log: CONFIG_T_[CONFIG|RECOVER] */
+       __u16    mcb_type;      /* type of log: MGS_CFG_T_[CONFIG|RECOVER] */
        __u8     mcb_nm_cur_pass;
        __u8     mcb_bits;      /* bits unit size of config log */
        __u32    mcb_units;     /* # of units for bulk transfer */

diff --git a/lustre/mgc/mgc_internal.h b/lustre/mgc/mgc_internal.h
index b9def7b..3657c86 100644 (file)
--- a/lustre/mgc/mgc_internal.h
+++ b/lustre/mgc/mgc_internal.h
@@ -43,24 +43,24 @@ int lprocfs_mgc_rd_ir_state(struct seq_file *m, void *data);
 
 int mgc_process_log(struct obd_device *mgc, struct config_llog_data *cld);
 
-static inline int cld_is_sptlrpc(struct config_llog_data *cld)
+static inline bool cld_is_sptlrpc(struct config_llog_data *cld)
 {
-       return cld->cld_type == CONFIG_T_SPTLRPC;
+       return cld->cld_type == MGS_CFG_T_SPTLRPC;
 }
 
-static inline int cld_is_recover(struct config_llog_data *cld)
+static inline bool cld_is_recover(struct config_llog_data *cld)
 {
-       return cld->cld_type == CONFIG_T_RECOVER;
+       return cld->cld_type == MGS_CFG_T_RECOVER;
 }
 
-static inline int cld_is_nodemap(struct config_llog_data *cld)
+static inline bool cld_is_nodemap(struct config_llog_data *cld)
 {
-       return cld->cld_type == CONFIG_T_NODEMAP;
+       return cld->cld_type == MGS_CFG_T_NODEMAP;
 }
 
-static inline int cld_is_barrier(struct config_llog_data *cld)
+static inline bool cld_is_barrier(struct config_llog_data *cld)
 {
-       return cld->cld_type == CONFIG_T_BARRIER;
+       return cld->cld_type == MGS_CFG_T_BARRIER;
 }
 
 #endif  /* _MGC_INTERNAL_H */

diff --git a/lustre/mgc/mgc_request.c b/lustre/mgc/mgc_request.c
index 893e6a9..e0714c3 100644 (file)
--- a/lustre/mgc/mgc_request.c
+++ b/lustre/mgc/mgc_request.c
@@ -53,7 +53,7 @@
 #include "mgc_internal.h"
 
 static int mgc_name2resid(char *name, int len, struct ldlm_res_id *res_id,
-                          int type)
+                         enum mgs_cfg_type type)
 {
         __u64 resname = 0;
 
@@ -72,14 +72,14 @@ static int mgc_name2resid(char *name, int len, struct ldlm_res_id *res_id,
         res_id->name[0] = cpu_to_le64(resname);
         /* XXX: unfortunately, sptlprc and config llog share one lock */
         switch(type) {
-        case CONFIG_T_CONFIG:
-        case CONFIG_T_SPTLRPC:
+       case MGS_CFG_T_CONFIG:
+       case MGS_CFG_T_SPTLRPC:
                 resname = 0;
                 break;
-       case CONFIG_T_RECOVER:
-       case CONFIG_T_PARAMS:
-       case CONFIG_T_NODEMAP:
-       case CONFIG_T_BARRIER:
+       case MGS_CFG_T_RECOVER:
+       case MGS_CFG_T_PARAMS:
+       case MGS_CFG_T_NODEMAP:
+       case MGS_CFG_T_BARRIER:
                resname = type;
                break;
         default:
@@ -91,7 +91,8 @@ static int mgc_name2resid(char *name, int len, struct ldlm_res_id *res_id,
         return 0;
 }
 
-int mgc_fsname2resid(char *fsname, struct ldlm_res_id *res_id, int type)
+int mgc_fsname2resid(char *fsname, struct ldlm_res_id *res_id,
+                    enum mgs_cfg_type type)
 {
         /* fsname is at most 8 chars long, maybe contain "-".
          * e.g. "lustre", "SUN-000" */
@@ -99,7 +100,8 @@ int mgc_fsname2resid(char *fsname, struct ldlm_res_id *res_id, int type)
 }
 EXPORT_SYMBOL(mgc_fsname2resid);
 
-int mgc_logname2resid(char *logname, struct ldlm_res_id *res_id, int type)
+int mgc_logname2resid(char *logname, struct ldlm_res_id *res_id,
+                     enum mgs_cfg_type type)
 {
        char *name_end;
        int len;
@@ -200,7 +202,7 @@ struct config_llog_data *config_log_find(char *logname,
 static
 struct config_llog_data *do_config_log_add(struct obd_device *obd,
                                           char *logname,
-                                          int type,
+                                          enum mgs_cfg_type type,
                                           struct config_llog_instance *cfg,
                                           struct super_block *sb)
 {
@@ -285,13 +287,14 @@ static struct config_llog_data *config_recover_log_add(struct obd_device *obd,
                strncat(logname, "-cliir", sizeof(logname));
        }
 
-       cld = do_config_log_add(obd, logname, CONFIG_T_RECOVER, &lcfg, sb);
+       cld = do_config_log_add(obd, logname, MGS_CFG_T_RECOVER, &lcfg, sb);
        return cld;
 }
 
-static struct config_llog_data *config_log_find_or_add(struct obd_device *obd,
-                               char *logname, struct super_block *sb, int type,
-                               struct config_llog_instance *cfg)
+static struct config_llog_data *
+config_log_find_or_add(struct obd_device *obd, char *logname,
+                      struct super_block *sb, enum mgs_cfg_type type,
+                      struct config_llog_instance *cfg)
 {
        struct config_llog_instance lcfg = *cfg;
        struct config_llog_data *cld;
@@ -345,7 +348,7 @@ config_log_add(struct obd_device *obd, char *logname,
 
        if (cfg->cfg_sub_clds & CONFIG_SUB_SPTLRPC) {
                sptlrpc_cld = config_log_find_or_add(obd, seclogname, NULL,
-                                                    CONFIG_T_SPTLRPC, cfg);
+                                                    MGS_CFG_T_SPTLRPC, cfg);
                if (IS_ERR(sptlrpc_cld)) {
                        CERROR("%s: can't create sptlrpc log %s: rc = %ld\n",
                               obd->obd_name, seclogname, PTR_ERR(sptlrpc_cld));
@@ -355,7 +358,7 @@ config_log_add(struct obd_device *obd, char *logname,
 
        if (!IS_MGS(lsi) && cfg->cfg_sub_clds & CONFIG_SUB_NODEMAP) {
                nodemap_cld = config_log_find_or_add(obd, LUSTRE_NODEMAP_NAME,
-                                                    NULL, CONFIG_T_NODEMAP,
+                                                    NULL, MGS_CFG_T_NODEMAP,
                                                     cfg);
                if (IS_ERR(nodemap_cld)) {
                        rc = PTR_ERR(nodemap_cld);
@@ -367,7 +370,7 @@ config_log_add(struct obd_device *obd, char *logname,
 
        if (cfg->cfg_sub_clds & CONFIG_SUB_PARAMS) {
                params_cld = config_log_find_or_add(obd, PARAMS_FILENAME, sb,
-                                                   CONFIG_T_PARAMS, cfg);
+                                                   MGS_CFG_T_PARAMS, cfg);
                if (IS_ERR(params_cld)) {
                        rc = PTR_ERR(params_cld);
                        CERROR("%s: can't create params log: rc = %d\n",
@@ -380,7 +383,7 @@ config_log_add(struct obd_device *obd, char *logname,
                snprintf(seclogname + (ptr - logname), sizeof(seclogname) - 1,
                         "-%s", BARRIER_FILENAME);
                barrier_cld = config_log_find_or_add(obd, seclogname, sb,
-                                                    CONFIG_T_BARRIER, cfg);
+                                                    MGS_CFG_T_BARRIER, cfg);
                if (IS_ERR(barrier_cld)) {
                        rc = PTR_ERR(barrier_cld);
                        CERROR("%s: can't create barrier log: rc = %d\n",
@@ -389,7 +392,7 @@ config_log_add(struct obd_device *obd, char *logname,
                }
        }
 
-       cld = do_config_log_add(obd, logname, CONFIG_T_CONFIG, cfg, sb);
+       cld = do_config_log_add(obd, logname, MGS_CFG_T_CONFIG, cfg, sb);
        if (IS_ERR(cld)) {
                rc = PTR_ERR(cld);
                CERROR("%s: can't create log: rc = %d\n",

diff --git a/lustre/mgs/mgs_barrier.c b/lustre/mgs/mgs_barrier.c
index b624f89..053f41d 100644 (file)
--- a/lustre/mgs/mgs_barrier.c
+++ b/lustre/mgs/mgs_barrier.c
@@ -129,7 +129,7 @@ static int mgs_barrier_glimpse_lock(const struct lu_env *env,
 
        LASSERT(fsdb->fsdb_mdt_count > 0);
 
-       rc = mgc_logname2resid(fsdb->fsdb_name, &res_id, CONFIG_T_BARRIER);
+       rc = mgc_logname2resid(fsdb->fsdb_name, &res_id, MGS_CFG_T_BARRIER);
        if (rc)
                RETURN(rc);
 

diff --git a/lustre/mgs/mgs_handler.c b/lustre/mgs/mgs_handler.c
index be44842..3de752a 100644 (file)
--- a/lustre/mgs/mgs_handler.c
+++ b/lustre/mgs/mgs_handler.c
@@ -210,7 +210,8 @@ static int mgs_completion_ast_barrier(struct ldlm_lock *lock, __u64 flags,
        return mgs_completion_ast_generic(lock, flags, cbdata, AST_BARRIER);
 }
 
-void mgs_revoke_lock(struct mgs_device *mgs, struct fs_db *fsdb, int type)
+void mgs_revoke_lock(struct mgs_device *mgs, struct fs_db *fsdb,
+                    enum mgs_cfg_type type)
 {
        ldlm_completion_callback cp = NULL;
        struct lustre_handle     lockh = {
@@ -225,21 +226,21 @@ void mgs_revoke_lock(struct mgs_device *mgs, struct fs_db *fsdb, int type)
        rc = mgc_fsname2resid(fsdb->fsdb_name, &res_id, type);
        LASSERT(rc == 0);
        switch (type) {
-       case CONFIG_T_CONFIG:
-       case CONFIG_T_NODEMAP:
+       case MGS_CFG_T_CONFIG:
+       case MGS_CFG_T_NODEMAP:
                cp = mgs_completion_ast_config;
                if (test_and_set_bit(FSDB_REVOKING_LOCK, &fsdb->fsdb_flags))
                        rc = -EALREADY;
                break;
-       case CONFIG_T_PARAMS:
+       case MGS_CFG_T_PARAMS:
                cp = mgs_completion_ast_params;
                if (test_and_set_bit(FSDB_REVOKING_PARAMS, &fsdb->fsdb_flags))
                        rc = -EALREADY;
                break;
-       case CONFIG_T_RECOVER:
+       case MGS_CFG_T_RECOVER:
                cp = mgs_completion_ast_ir;
                break;
-       case CONFIG_T_BARRIER:
+       case MGS_CFG_T_BARRIER:
                cp = mgs_completion_ast_barrier;
                break;
        default:
@@ -259,11 +260,11 @@ void mgs_revoke_lock(struct mgs_device *mgs, struct fs_db *fsdb, int type)
                               le64_to_cpu(res_id.name[0]),
                               le64_to_cpu(res_id.name[1]), rc);
 
-                       if (type == CONFIG_T_CONFIG)
+                       if (type == MGS_CFG_T_CONFIG)
                                clear_bit(FSDB_REVOKING_LOCK,
                                          &fsdb->fsdb_flags);
 
-                       if (type == CONFIG_T_PARAMS)
+                       if (type == MGS_CFG_T_PARAMS)
                                clear_bit(FSDB_REVOKING_PARAMS,
                                          &fsdb->fsdb_flags);
                }
@@ -509,7 +510,7 @@ static int mgs_target_reg(struct tgt_session_info *tsi)
         }
 
 out:
-       mgs_revoke_lock(mgs, c_fsdb, CONFIG_T_CONFIG);
+       mgs_revoke_lock(mgs, c_fsdb, MGS_CFG_T_CONFIG);
 
 out_norevoke:
        if (!rc && mti->mti_flags & LDD_F_SV_TYPE_MDT && b_fsdb) {
@@ -574,13 +575,13 @@ static int mgs_config_read(struct tgt_session_info *tsi)
        }
 
        switch (body->mcb_type) {
-       case CONFIG_T_RECOVER:
+       case MGS_CFG_T_RECOVER:
                rc = mgs_get_ir_logs(req);
                break;
-       case CONFIG_T_NODEMAP:
+       case MGS_CFG_T_NODEMAP:
                rc = nodemap_get_config_req(req->rq_export->exp_obd, req);
                break;
-       case CONFIG_T_CONFIG:
+       case MGS_CFG_T_CONFIG:
                rc = -EOPNOTSUPP;
                break;
        default:
@@ -877,7 +878,7 @@ static int mgs_iocontrol_nodemap(const struct lu_env *env,
                CWARN("%s: cannot make nodemap fsdb: rc = %d\n",
                      mgs->mgs_obd->obd_name, rc);
        } else {
-               mgs_revoke_lock(mgs, fsdb, CONFIG_T_NODEMAP);
+               mgs_revoke_lock(mgs, fsdb, MGS_CFG_T_NODEMAP);
                mgs_put_fsdb(mgs, fsdb);
        }
 

diff --git a/lustre/mgs/mgs_internal.h b/lustre/mgs/mgs_internal.h
index 2b1dca2..4b36cac 100644 (file)
--- a/lustre/mgs/mgs_internal.h
+++ b/lustre/mgs/mgs_internal.h
@@ -235,7 +235,8 @@ int mgs_nodemap_cmd(const struct lu_env *env, struct mgs_device *mgs,
 int  mgs_get_lock(struct obd_device *obd, struct ldlm_res_id *res,
                   struct lustre_handle *lockh);
 int  mgs_put_lock(struct lustre_handle *lockh);
-void mgs_revoke_lock(struct mgs_device *mgs, struct fs_db *fsdb, int type);
+void mgs_revoke_lock(struct mgs_device *mgs, struct fs_db *fsdb,
+                    enum mgs_cfg_type type);
 
 /* mgs_nids.c */
 int  mgs_ir_update(const struct lu_env *env, struct mgs_device *mgs,

diff --git a/lustre/mgs/mgs_llog.c b/lustre/mgs/mgs_llog.c
index fb2e175..fe5c729 100644 (file)
--- a/lustre/mgs/mgs_llog.c
+++ b/lustre/mgs/mgs_llog.c
@@ -5263,7 +5263,7 @@ static int mgs_set_conf_param(const struct lu_env *env, struct mgs_device *mgs,
        mutex_lock(&fsdb->fsdb_mutex);
        rc = mgs_write_log_param(env, mgs, fsdb, mti, mti->mti_params);
        mutex_unlock(&fsdb->fsdb_mutex);
-       mgs_revoke_lock(mgs, fsdb, CONFIG_T_CONFIG);
+       mgs_revoke_lock(mgs, fsdb, MGS_CFG_T_CONFIG);
 
 out:
        if (fsdb)
@@ -5362,7 +5362,7 @@ static int mgs_set_param2(const struct lu_env *env, struct mgs_device *mgs,
        mutex_lock(&fsdb->fsdb_mutex);
        rc = mgs_write_log_param2(env, mgs, fsdb, mti, mti->mti_params);
        mutex_unlock(&fsdb->fsdb_mutex);
-       mgs_revoke_lock(mgs, fsdb, CONFIG_T_PARAMS);
+       mgs_revoke_lock(mgs, fsdb, MGS_CFG_T_PARAMS);
        mgs_put_fsdb(mgs, fsdb);
 out:
        RETURN(rc);
@@ -5700,7 +5700,7 @@ int mgs_pool_cmd(const struct lu_env *env, struct mgs_device *mgs,
        locked = false;
        name_destroy(&logname);
        /* request for update */
-       mgs_revoke_lock(mgs, fsdb, CONFIG_T_CONFIG);
+       mgs_revoke_lock(mgs, fsdb, MGS_CFG_T_CONFIG);
 
        GOTO(out_mti, rc);
 

diff --git a/lustre/mgs/mgs_nids.c b/lustre/mgs/mgs_nids.c
index 342e7e2..be7fae1 100644 (file)
--- a/lustre/mgs/mgs_nids.c
+++ b/lustre/mgs/mgs_nids.c
@@ -431,7 +431,7 @@ static int mgs_ir_notify(void *arg)
        snprintf(name, sizeof(name) - 1, "mgs_%s_notify", fsdb->fsdb_name);
        complete(&fsdb->fsdb_notify_comp);
        set_user_nice(current, -2);
-       mgc_fsname2resid(fsdb->fsdb_name, &resid, CONFIG_T_RECOVER);
+       mgc_fsname2resid(fsdb->fsdb_name, &resid, MGS_CFG_T_RECOVER);
        while (1) {
                wait_event_idle(fsdb->fsdb_notify_waitq,
                                fsdb->fsdb_notify_stop ||
@@ -444,7 +444,7 @@ static int mgs_ir_notify(void *arg)
                       name, atomic_read(&fsdb->fsdb_notify_phase));
 
                fsdb->fsdb_notify_start = ktime_get();
-               mgs_revoke_lock(fsdb->fsdb_mgs, fsdb, CONFIG_T_RECOVER);
+               mgs_revoke_lock(fsdb->fsdb_mgs, fsdb, MGS_CFG_T_RECOVER);
        }
 
        complete(&fsdb->fsdb_notify_comp);
@@ -616,7 +616,7 @@ int mgs_get_ir_logs(struct ptlrpc_request *req)
        if (!body)
                RETURN(-EINVAL);
 
-       if (body->mcb_type != CONFIG_T_RECOVER)
+       if (body->mcb_type != MGS_CFG_T_RECOVER)
                RETURN(-EINVAL);
 
        rc = delogname(body->mcb_name, fsname, &type);

diff --git a/lustre/ptlrpc/nodemap_storage.c b/lustre/ptlrpc/nodemap_storage.c
index ef559ca..4a3de3d 100644 (file)
--- a/lustre/ptlrpc/nodemap_storage.c
+++ b/lustre/ptlrpc/nodemap_storage.c
@@ -1480,7 +1480,7 @@ int nodemap_get_config_req(struct obd_device *mgs_obd,
        if (!body)
                RETURN(-EINVAL);
 
-       if (body->mcb_type != CONFIG_T_NODEMAP)
+       if (body->mcb_type != MGS_CFG_T_NODEMAP)
                RETURN(-EINVAL);
 
        rdpg.rp_count = (body->mcb_units << body->mcb_bits);

diff --git a/lustre/ptlrpc/wiretest.c b/lustre/ptlrpc/wiretest.c
index 3fa7efe..c20035b 100644 (file)
--- a/lustre/ptlrpc/wiretest.c
+++ b/lustre/ptlrpc/wiretest.c
@@ -4581,12 +4581,12 @@ void lustre_assert_wire_constants(void)
                 (long long)(int)offsetof(struct mgs_config_body, mcb_units));
        LASSERTF((int)sizeof(((struct mgs_config_body *)0)->mcb_units) == 4, "found %lld\n",
                 (long long)(int)sizeof(((struct mgs_config_body *)0)->mcb_units));
-       BUILD_BUG_ON(CONFIG_T_CONFIG != 0);
-       BUILD_BUG_ON(CONFIG_T_SPTLRPC != 1);
-       BUILD_BUG_ON(CONFIG_T_RECOVER != 2);
-       BUILD_BUG_ON(CONFIG_T_PARAMS != 3);
-       BUILD_BUG_ON(CONFIG_T_NODEMAP != 4);
-       BUILD_BUG_ON(CONFIG_T_BARRIER != 5);
+       BUILD_BUG_ON(MGS_CFG_T_CONFIG != 0);
+       BUILD_BUG_ON(MGS_CFG_T_SPTLRPC != 1);
+       BUILD_BUG_ON(MGS_CFG_T_RECOVER != 2);
+       BUILD_BUG_ON(MGS_CFG_T_PARAMS != 3);
+       BUILD_BUG_ON(MGS_CFG_T_NODEMAP != 4);
+       BUILD_BUG_ON(MGS_CFG_T_BARRIER != 5);
 
        /* Checks for struct mgs_config_res */
        LASSERTF((int)sizeof(struct mgs_config_res) == 16, "found %lld\n",

diff --git a/lustre/utils/wirecheck.c b/lustre/utils/wirecheck.c
index c4f550e..f894e93 100644 (file)
--- a/lustre/utils/wirecheck.c
+++ b/lustre/utils/wirecheck.c
@@ -2056,12 +2056,12 @@ check_mgs_config_body(void)
        CHECK_MEMBER(mgs_config_body, mcb_bits);
        CHECK_MEMBER(mgs_config_body, mcb_units);
 
-       CHECK_CVALUE(CONFIG_T_CONFIG);
-       CHECK_CVALUE(CONFIG_T_SPTLRPC);
-       CHECK_CVALUE(CONFIG_T_RECOVER);
-       CHECK_CVALUE(CONFIG_T_PARAMS);
-       CHECK_CVALUE(CONFIG_T_NODEMAP);
-       CHECK_CVALUE(CONFIG_T_BARRIER);
+       CHECK_CVALUE(MGS_CFG_T_CONFIG);
+       CHECK_CVALUE(MGS_CFG_T_SPTLRPC);
+       CHECK_CVALUE(MGS_CFG_T_RECOVER);
+       CHECK_CVALUE(MGS_CFG_T_PARAMS);
+       CHECK_CVALUE(MGS_CFG_T_NODEMAP);
+       CHECK_CVALUE(MGS_CFG_T_BARRIER);
 }
 
 static void

diff --git a/lustre/utils/wiretest.c b/lustre/utils/wiretest.c
index f04b715..3b3f961 100644 (file)
--- a/lustre/utils/wiretest.c
+++ b/lustre/utils/wiretest.c
@@ -4603,12 +4603,12 @@ void lustre_assert_wire_constants(void)
                 (long long)(int)offsetof(struct mgs_config_body, mcb_units));
        LASSERTF((int)sizeof(((struct mgs_config_body *)0)->mcb_units) == 4, "found %lld\n",
                 (long long)(int)sizeof(((struct mgs_config_body *)0)->mcb_units));
-       BUILD_BUG_ON(CONFIG_T_CONFIG != 0);
-       BUILD_BUG_ON(CONFIG_T_SPTLRPC != 1);
-       BUILD_BUG_ON(CONFIG_T_RECOVER != 2);
-       BUILD_BUG_ON(CONFIG_T_PARAMS != 3);
-       BUILD_BUG_ON(CONFIG_T_NODEMAP != 4);
-       BUILD_BUG_ON(CONFIG_T_BARRIER != 5);
+       BUILD_BUG_ON(MGS_CFG_T_CONFIG != 0);
+       BUILD_BUG_ON(MGS_CFG_T_SPTLRPC != 1);
+       BUILD_BUG_ON(MGS_CFG_T_RECOVER != 2);
+       BUILD_BUG_ON(MGS_CFG_T_PARAMS != 3);
+       BUILD_BUG_ON(MGS_CFG_T_NODEMAP != 4);
+       BUILD_BUG_ON(MGS_CFG_T_BARRIER != 5);
 
        /* Checks for struct mgs_config_res */
        LASSERTF((int)sizeof(struct mgs_config_res) == 16, "found %lld\n",