From 8565f19a165f91322635cebd5cec2d92ea814589 Mon Sep 17 00:00:00 2001 From: Yu Jian Date: Fri, 29 Jun 2012 11:40:52 +0800 Subject: [PATCH] LU-1203 mdt: recognize old rootsquash and nosquash_nid params Change mdt_process_config() to make it capable of recognizing old "mdt.rootsquash" and "mdt.nosquash_nid" parameters. The new parameters are "mdt.root_squash" and "mdt.nosquash_nids". Signed-off-by: Yu Jian Change-Id: I258609ea6f63f14f2e16ec141de1455dd8137b9c Reviewed-on: http://review.whamcloud.com/3237 Tested-by: Hudson Reviewed-by: Liang Zhen Tested-by: Maloo Reviewed-by: Niu Yawei Reviewed-by: Andreas Dilger --- lustre/include/lustre_cfg.h | 65 +++++++++++++------------ lustre/include/obd_class.h | 2 + lustre/mdt/mdt_handler.c | 113 +++++++++++++++++++++++++++++++------------ lustre/obdclass/obd_config.c | 73 ++++++++++++++++++++++++++++ 4 files changed, 189 insertions(+), 64 deletions(-) diff --git a/lustre/include/lustre_cfg.h b/lustre/include/lustre_cfg.h index f3d60a6..b3ef747 100644 --- a/lustre/include/lustre_cfg.h +++ b/lustre/include/lustre_cfg.h @@ -95,16 +95,16 @@ struct lustre_cfg_bufs { }; struct lustre_cfg { - __u32 lcfg_version; - __u32 lcfg_command; + __u32 lcfg_version; + __u32 lcfg_command; - __u32 lcfg_num; - __u32 lcfg_flags; - __u64 lcfg_nid; - __u32 lcfg_nal; /* not used any more */ + __u32 lcfg_num; + __u32 lcfg_flags; + __u64 lcfg_nid; + __u32 lcfg_nal; /* not used any more */ - __u32 lcfg_bufcount; - __u32 lcfg_buflens[0]; + __u32 lcfg_bufcount; + __u32 lcfg_buflens[0]; }; enum cfg_record_type { @@ -179,29 +179,30 @@ static inline void lustre_cfg_bufs_init(struct lustre_cfg_bufs *bufs, static inline char *lustre_cfg_string(struct lustre_cfg *lcfg, int index) { - char *s; - - if (!lcfg->lcfg_buflens[index]) - return NULL; - - s = lustre_cfg_buf(lcfg, index); - if (!s) - return NULL; - - /* make sure it's NULL terminated, even if this kills a char - * of data. Try to use the padding first though. - */ - if (s[lcfg->lcfg_buflens[index] - 1] != '\0') { - int last = min((int)lcfg->lcfg_buflens[index], - cfs_size_round(lcfg->lcfg_buflens[index]) - 1); - char lost = s[last]; - s[last] = '\0'; - if (lost != '\0') { - CWARN("Truncated buf %d to '%s' (lost '%c'...)\n", - index, s, lost); - } - } - return s; + char *s; + + if (lcfg->lcfg_buflens[index] == 0) + return NULL; + + s = lustre_cfg_buf(lcfg, index); + if (s == NULL) + return NULL; + + /* + * make sure it's NULL terminated, even if this kills a char + * of data. Try to use the padding first though. + */ + if (s[lcfg->lcfg_buflens[index] - 1] != '\0') { + int last = min((int)lcfg->lcfg_buflens[index], + cfs_size_round(lcfg->lcfg_buflens[index]) - 1); + char lost = s[last]; + s[last] = '\0'; + if (lost != '\0') { + CWARN("Truncated buf %d to '%s' (lost '%c'...)\n", + index, s, lost); + } + } + return s; } static inline int lustre_cfg_len(__u32 bufcount, __u32 *buflens) @@ -270,7 +271,7 @@ static inline int lustre_cfg_sanity_check(void *buf, int len) if (lcfg->lcfg_version != LUSTRE_CFG_VERSION) RETURN(-EINVAL); - + if (lcfg->lcfg_bufcount >= LUSTRE_CFG_MAX_BUFCOUNT) RETURN(-EINVAL); diff --git a/lustre/include/obd_class.h b/lustre/include/obd_class.h index 7ff3843..c93984b 100644 --- a/lustre/include/obd_class.h +++ b/lustre/include/obd_class.h @@ -114,6 +114,8 @@ void *kuc_alloc(int payload_len, int transport, int type); void kuc_free(void *p, int payload_len); /* obd_config.c */ +struct lustre_cfg *lustre_cfg_rename(struct lustre_cfg *cfg, + const char *new_name); int class_process_config(struct lustre_cfg *lcfg); int class_process_proc_param(char *prefix, struct lprocfs_vars *lvars, struct lustre_cfg *lcfg, void *data); diff --git a/lustre/mdt/mdt_handler.c b/lustre/mdt/mdt_handler.c index b61170ab..4d1f727 100644 --- a/lustre/mdt/mdt_handler.c +++ b/lustre/mdt/mdt_handler.c @@ -4717,6 +4717,15 @@ err_lmi: return (rc); } +/* For interoperability between 1.8 and 2.0. */ +#define CFG_GROUP_UPCALL "mdt.group_upcall" +#define CFG_QUOTA_TYPE_OLD "mdt.quota_type" +#define CFG_QUOTA_TYPE_NEW "mdd.quota_type" +#define CFG_ROOT_SQUASH_OLD "mdt.rootsquash" +#define CFG_ROOT_SQUASH_NEW "mdt.root_squash" +#define CFG_NOSQUASH_NID_OLD "mdt.nosquash_nid" +#define CFG_NOSQUASH_NID_NEW "mdt.nosquash_nids" + /* used by MGS to process specific configurations */ static int mdt_process_config(const struct lu_env *env, struct lu_device *d, struct lustre_cfg *cfg) @@ -4727,38 +4736,78 @@ static int mdt_process_config(const struct lu_env *env, int rc = 0; ENTRY; - switch (cfg->lcfg_command) { - case LCFG_PARAM: { - struct lprocfs_static_vars lvars; - struct obd_device *obd = d->ld_obd; - - /* - * For interoperability between 1.8 and 2.0, - */ - { - /* Skip old "mdt.group_upcall" param. */ - char *param = lustre_cfg_string(cfg, 1); - if (param && !strncmp("mdt.group_upcall", param, 16)) { - CWARN("For 1.8 interoperability, skip this" - " mdt.group_upcall. It is obsolete\n"); - break; - } - /* Rename old "mdt.quota_type" to "mdd.quota_type. */ - if (param && !strncmp("mdt.quota_type", param, 14)) { - CWARN("Found old param mdt.quota_type, changed" - " it to mdd.quota_type.\n"); - param[2] = 'd'; - } - } - - lprocfs_mdt_init_vars(&lvars); - rc = class_process_proc_param(PARAM_MDT, lvars.obd_vars, - cfg, obd); - if (rc > 0 || rc == -ENOSYS) - /* we don't understand; pass it on */ - rc = next->ld_ops->ldo_process_config(env, next, cfg); - break; - } + switch (cfg->lcfg_command) { + case LCFG_PARAM: { + struct lprocfs_static_vars lvars; + struct obd_device *obd = d->ld_obd; + + /* For interoperability between 1.8 and 2.0. */ + struct lustre_cfg *old_cfg = NULL; + char *param = NULL; + char *new_name = NULL; + + param = lustre_cfg_string(cfg, 1); + if (param == NULL) { + CERROR("param is empty\n"); + rc = -EINVAL; + break; + } + + /* Skip old "mdt.group_upcall" param. */ + if (strncmp(param, CFG_GROUP_UPCALL, + strlen(CFG_GROUP_UPCALL)) == 0) { + CWARN("For 1.8 interoperability, skip this %s." + " It is obsolete.\n", CFG_GROUP_UPCALL); + break; + } + + /* Rename old "mdt.quota_type" to "mdd.quota_type". */ + if (strncmp(param, CFG_QUOTA_TYPE_OLD, + strlen(CFG_QUOTA_TYPE_OLD)) == 0) { + CWARN("Found old param %s, changed it to %s.\n", + CFG_QUOTA_TYPE_OLD, CFG_QUOTA_TYPE_NEW); + new_name = CFG_QUOTA_TYPE_NEW; + + } else if (strncmp(param, CFG_ROOT_SQUASH_OLD, + strlen(CFG_ROOT_SQUASH_OLD)) == 0) { + /* Rename old "mdt.rootsquash" to "mdt.root_squash". */ + CWARN("Found old param %s, changed it to %s.\n", + CFG_ROOT_SQUASH_OLD, CFG_ROOT_SQUASH_NEW); + new_name = CFG_ROOT_SQUASH_NEW; + + } else if (strncmp(param, CFG_NOSQUASH_NID_OLD, + strlen(CFG_NOSQUASH_NID_OLD)) == 0 && + param[strlen(CFG_NOSQUASH_NID_OLD)] != 's') { + /* + * Rename old "mdt.nosquash_nid" to + * "mdt.nosquash_nids". + */ + CWARN("Found old param %s, changed it to %s.\n", + CFG_NOSQUASH_NID_OLD, CFG_NOSQUASH_NID_NEW); + new_name = CFG_NOSQUASH_NID_NEW; + } + + if (new_name != NULL) { + old_cfg = cfg; + cfg = lustre_cfg_rename(old_cfg, new_name); + if (IS_ERR(cfg)) { + rc = PTR_ERR(cfg); + break; + } + } + + lprocfs_mdt_init_vars(&lvars); + rc = class_process_proc_param(PARAM_MDT, lvars.obd_vars, + cfg, obd); + if (rc > 0 || rc == -ENOSYS) + /* we don't understand; pass it on */ + rc = next->ld_ops->ldo_process_config(env, next, cfg); + + if (old_cfg != NULL) + lustre_cfg_free(cfg); + + break; + } case LCFG_ADD_MDC: /* * Add mdc hook to get first MDT uuid and connect it to diff --git a/lustre/obdclass/obd_config.c b/lustre/obdclass/obd_config.c index 4c2cf37..79af076 100644 --- a/lustre/obdclass/obd_config.c +++ b/lustre/obdclass/obd_config.c @@ -903,6 +903,79 @@ void lustre_register_client_process_config(int (*cpc)(struct lustre_cfg *lcfg)) } EXPORT_SYMBOL(lustre_register_client_process_config); +/** + * Rename the proc parameter in \a cfg with a new name \a new_name. + * + * \param cfg config structure which contains the proc parameter + * \param new_name new name of the proc parameter + * + * \retval valid-pointer pointer to the newly-allocated config structure + * which contains the renamed proc parameter + * \retval ERR_PTR(-EINVAL) if \a cfg or \a new_name is NULL, or \a cfg does + * not contain a proc parameter + * \retval ERR_PTR(-ENOMEM) if memory allocation failure occurs + */ +struct lustre_cfg *lustre_cfg_rename(struct lustre_cfg *cfg, + const char *new_name) +{ + struct lustre_cfg_bufs *bufs = NULL; + struct lustre_cfg *new_cfg = NULL; + char *param = NULL; + char *new_param = NULL; + char *value = NULL; + int name_len = 0; + int new_len = 0; + ENTRY; + + if (cfg == NULL || new_name == NULL) + RETURN(ERR_PTR(-EINVAL)); + + param = lustre_cfg_string(cfg, 1); + if (param == NULL) + RETURN(ERR_PTR(-EINVAL)); + + value = strchr(param, '='); + if (value == NULL) + name_len = strlen(param); + else + name_len = value - param; + + new_len = LUSTRE_CFG_BUFLEN(cfg, 1) + strlen(new_name) - name_len; + + OBD_ALLOC(new_param, new_len); + if (new_param == NULL) + RETURN(ERR_PTR(-ENOMEM)); + + strcpy(new_param, new_name); + if (value != NULL) + strcat(new_param, value); + + OBD_ALLOC_PTR(bufs); + if (bufs == NULL) { + OBD_FREE(new_param, new_len); + RETURN(ERR_PTR(-ENOMEM)); + } + + lustre_cfg_bufs_reset(bufs, NULL); + lustre_cfg_bufs_init(bufs, cfg); + lustre_cfg_bufs_set_string(bufs, 1, new_param); + + new_cfg = lustre_cfg_new(cfg->lcfg_command, bufs); + + OBD_FREE(new_param, new_len); + OBD_FREE_PTR(bufs); + if (new_cfg == NULL) + RETURN(ERR_PTR(-ENOMEM)); + + new_cfg->lcfg_num = cfg->lcfg_num; + new_cfg->lcfg_flags = cfg->lcfg_flags; + new_cfg->lcfg_nid = cfg->lcfg_nid; + new_cfg->lcfg_nal = cfg->lcfg_nal; + + RETURN(new_cfg); +} +EXPORT_SYMBOL(lustre_cfg_rename); + /** Process configuration commands given in lustre_cfg form. * These may come from direct calls (e.g. class_manual_cleanup) * or processing the config llog, or ioctl from lctl. -- 1.8.3.1