From 0bdaccbcec86e6eb47ee0d374995b30c3f03011d Mon Sep 17 00:00:00 2001 From: Shaun Tancheff Date: Thu, 26 Jan 2023 09:37:41 -0800 Subject: [PATCH] LU-16120 build: Add support for kobj_type default_groups Linux commit v5.1-rc3-29-gaa30f47cf666 kobject: Add support for default attribute groups to kobj_type Linux commit v5.18-rc1-2-gcdb4f26a63c3 kobject: kobj_type: remove default_attrs Switch to using kobj_type default_groups when it is available. Provide support for default_attrs for older kernels. Lustre-change: https://review.whamcloud.com/48365 Lustre-commit: 62e9d055d9516ec6a2fe2f0962b23d478a45dad0 HPE-bug-id: LUS-11196 Signed-off-by: Shaun Tancheff Change-Id: I43b03c67c22307293a2abc444aa1a73889ca09ee Reviewed-by: Andreas Dilger Reviewed-by: Jian Yu Reviewed-on: https://review.whamcloud.com/c/fs/lustre-release/+/49786 Tested-by: jenkins Tested-by: Maloo Reviewed-by: Oleg Drokin --- libcfs/autoconf/lustre-libcfs.m4 | 24 ++++++++++++++ libcfs/include/libcfs/linux/linux-misc.h | 9 +++++ lustre/include/obd_class.h | 57 ++++++++++++++++++++++++++++++++ lustre/ldlm/ldlm_pool.c | 4 ++- lustre/ldlm/ldlm_resource.c | 4 ++- lustre/llite/lproc_llite.c | 4 ++- lustre/lmv/lproc_lmv.c | 4 ++- lustre/lod/lproc_lod.c | 4 ++- lustre/lov/lproc_lov.c | 4 ++- lustre/mdc/lproc_mdc.c | 4 ++- lustre/mdd/mdd_lproc.c | 4 ++- lustre/mdt/mdt_coordinator.c | 4 ++- lustre/mdt/mdt_lproc.c | 4 ++- lustre/mgc/lproc_mgc.c | 4 ++- lustre/mgs/lproc_mgs.c | 27 ++++++--------- lustre/obdclass/obd_config.c | 15 ++------- lustre/ofd/lproc_ofd.c | 4 ++- lustre/osc/lproc_osc.c | 4 ++- lustre/osd-ldiskfs/osd_lproc.c | 4 ++- lustre/osd-zfs/osd_lproc.c | 4 ++- lustre/osp/lproc_osp.c | 10 ++++-- lustre/ptlrpc/lproc_ptlrpc.c | 4 ++- 22 files changed, 159 insertions(+), 47 deletions(-) diff --git a/libcfs/autoconf/lustre-libcfs.m4 b/libcfs/autoconf/lustre-libcfs.m4 index 9b98dab..0058ee2 100644 --- a/libcfs/autoconf/lustre-libcfs.m4 +++ b/libcfs/autoconf/lustre-libcfs.m4 @@ -1519,6 +1519,28 @@ EXTRA_KCFLAGS="$tmp_flags" ]) # LIBCFS_GET_REQUEST_KEY_AUTH # +# LIBCFS_KOBJ_TYPE_DEFAULT_GROUPS +# +# Linux commit v5.1-rc3-29-gaa30f47cf666 +# kobject: Add support for default attribute groups to kobj_type +# Linux commit v5.18-rc1-2-gcdb4f26a63c3 +# kobject: kobj_type: remove default_attrs +# +AC_DEFUN([LIBCFS_KOBJ_TYPE_DEFAULT_GROUPS],[ +LB_CHECK_COMPILE([does struct kobj_type have 'default_groups' member], +kobj_type_default_groups, [ + #include + ],[ + struct kobj_type *kobj_type = NULL; + void *has = kobj_type->default_groups; + (void) has; + ],[ + AC_DEFINE(HAVE_KOBJ_TYPE_DEFAULT_GROUPS, 1, + [struct kobj_type has 'default_groups' member]) + ]) +]) # LIBCFS_KOBJ_TYPE_DEFAULT_GROUPS + +# # LIBCFS_LOOKUP_USER_KEY # # kernel 5.3 commit 3cf5d076fb4d48979f382bc9452765bf8b79e740 @@ -2037,6 +2059,8 @@ LIBCFS_HAVE_IOV_ITER_TYPE # 5.0 LIBCFS_MM_TOTALRAM_PAGES_FUNC LIBCFS_GET_REQUEST_KEY_AUTH +# 5.2 +LIBCFS_KOBJ_TYPE_DEFAULT_GROUPS # 5.3 LIBCFS_LOOKUP_USER_KEY LIBCFS_FORCE_SIG_WITH_TASK diff --git a/libcfs/include/libcfs/linux/linux-misc.h b/libcfs/include/libcfs/linux/linux-misc.h index faec22b..5e21896 100644 --- a/libcfs/include/libcfs/linux/linux-misc.h +++ b/libcfs/include/libcfs/linux/linux-misc.h @@ -166,4 +166,13 @@ static inline void *cfs_kallsyms_lookup_name(const char *name) } #endif +#ifndef HAVE_KOBJ_TYPE_DEFAULT_GROUPS +#define default_groups default_attrs +#define KOBJ_ATTR_GROUPS(_name) _name##_attrs +#define KOBJ_ATTRIBUTE_GROUPS(_name) +#else +#define KOBJ_ATTR_GROUPS(_name) _name##_groups +#define KOBJ_ATTRIBUTE_GROUPS(_name) ATTRIBUTE_GROUPS(_name) +#endif + #endif /* __LIBCFS_LINUX_MISC_H__ */ diff --git a/lustre/include/obd_class.h b/lustre/include/obd_class.h index cd2421b..8d93466 100644 --- a/lustre/include/obd_class.h +++ b/lustre/include/obd_class.h @@ -1894,4 +1894,61 @@ extern __u64 obd_heat_get(struct obd_heat_instance *instance, unsigned int time_second, unsigned int weight, unsigned int period_second); extern void obd_heat_clear(struct obd_heat_instance *instance, int count); + +/* struct kobj_type */ +static inline +struct attribute *_get_attr_matches(const struct kobj_type *typ, + const char *key, size_t keylen, + int (*is_match)(const char *, const char *, + size_t)) +{ + int i; + +#ifdef HAVE_KOBJ_TYPE_DEFAULT_GROUPS + for (i = 0; typ->default_groups[i]; i++) { + int k; + struct attribute **attrs; + + attrs = (struct attribute **)typ->default_groups[i]->attrs; + for (k = 0; attrs[k]; k++) { + if (is_match(attrs[k]->name, key, keylen)) + return (struct attribute *)attrs[k]; + } + } +#else + for (i = 0; typ->default_attrs[i]; i++) { + if (is_match(typ->default_attrs[i]->name, key, keylen)) + return typ->default_attrs[i]; + } +#endif + return NULL; +} + +static inline +int _attr_name_exact(const char *attr_name, const char *key, size_t len) +{ + return !strcmp(attr_name, key); +} + +static inline +struct attribute *get_attr_by_name(const struct kobj_type *typ, + const char *name) +{ + return _get_attr_matches(typ, name, 0, _attr_name_exact); +} + +static inline +int _attr_name_starts_with(const char *attr_name, const char *name, size_t len) +{ + return !strncmp(attr_name, name, len); +} + +static inline +struct attribute *get_attr_starts_with(const struct kobj_type *typ, + const char *name, + size_t len) +{ + return _get_attr_matches(typ, name, len, _attr_name_starts_with); +} + #endif /* __LINUX_OBD_CLASS_H */ diff --git a/lustre/ldlm/ldlm_pool.c b/lustre/ldlm/ldlm_pool.c index c424aac..d23240c7 100644 --- a/lustre/ldlm/ldlm_pool.c +++ b/lustre/ldlm/ldlm_pool.c @@ -792,6 +792,8 @@ static struct attribute *ldlm_pl_attrs[] = { NULL, }; +KOBJ_ATTRIBUTE_GROUPS(ldlm_pl); + static void ldlm_pl_release(struct kobject *kobj) { struct ldlm_pool *pl = container_of(kobj, struct ldlm_pool, @@ -800,7 +802,7 @@ static void ldlm_pl_release(struct kobject *kobj) } static struct kobj_type ldlm_pl_ktype = { - .default_attrs = ldlm_pl_attrs, + .default_groups = KOBJ_ATTR_GROUPS(ldlm_pl), .sysfs_ops = &lustre_sysfs_ops, .release = ldlm_pl_release, }; diff --git a/lustre/ldlm/ldlm_resource.c b/lustre/ldlm/ldlm_resource.c index 3360fa5..92fef33 100644 --- a/lustre/ldlm/ldlm_resource.c +++ b/lustre/ldlm/ldlm_resource.c @@ -702,8 +702,10 @@ static void ldlm_ns_release(struct kobject *kobj) complete(&ns->ns_kobj_unregister); } +KOBJ_ATTRIBUTE_GROUPS(ldlm_ns); + static struct kobj_type ldlm_ns_ktype = { - .default_attrs = ldlm_ns_attrs, + .default_groups = KOBJ_ATTR_GROUPS(ldlm_ns), .sysfs_ops = &lustre_sysfs_ops, .release = ldlm_ns_release, }; diff --git a/lustre/llite/lproc_llite.c b/lustre/llite/lproc_llite.c index a67415e..2499f45 100644 --- a/lustre/llite/lproc_llite.c +++ b/lustre/llite/lproc_llite.c @@ -1747,6 +1747,8 @@ static struct attribute *llite_attrs[] = { NULL, }; +KOBJ_ATTRIBUTE_GROUPS(llite); /* creates llite_groups */ + static void sbi_kobj_release(struct kobject *kobj) { struct ll_sb_info *sbi = container_of(kobj, struct ll_sb_info, @@ -1755,7 +1757,7 @@ static void sbi_kobj_release(struct kobject *kobj) } static struct kobj_type sbi_ktype = { - .default_attrs = llite_attrs, + .default_groups = KOBJ_ATTR_GROUPS(llite), .sysfs_ops = &lustre_sysfs_ops, .release = sbi_kobj_release, }; diff --git a/lustre/lmv/lproc_lmv.c b/lustre/lmv/lproc_lmv.c index 1f118f1..3dee359 100644 --- a/lustre/lmv/lproc_lmv.c +++ b/lustre/lmv/lproc_lmv.c @@ -290,11 +290,13 @@ static struct attribute *lmv_attrs[] = { NULL, }; +KOBJ_ATTRIBUTE_GROUPS(lmv); /* creates lmv_groups */ + int lmv_tunables_init(struct obd_device *obd) { int rc; - obd->obd_ktype.default_attrs = lmv_attrs; + obd->obd_ktype.default_groups = KOBJ_ATTR_GROUPS(lmv); rc = lprocfs_obd_setup(obd, true); if (rc) goto out_failed; diff --git a/lustre/lod/lproc_lod.c b/lustre/lod/lproc_lod.c index 018c551..fac838c 100644 --- a/lustre/lod/lproc_lod.c +++ b/lustre/lod/lproc_lod.c @@ -1265,6 +1265,8 @@ static struct attribute *lod_attrs[] = { NULL, }; +KOBJ_ATTRIBUTE_GROUPS(lod); /* creates lod_groups from lod_attrs */ + /** * Initialize procfs entries for LOD. * @@ -1280,7 +1282,7 @@ int lod_procfs_init(struct lod_device *lod) struct kobject *lov; int rc; - lod->lod_dt_dev.dd_ktype.default_attrs = lod_attrs; + lod->lod_dt_dev.dd_ktype.default_groups = KOBJ_ATTR_GROUPS(lod); rc = dt_tunables_init(&lod->lod_dt_dev, obd->obd_type, obd->obd_name, NULL); if (rc) { diff --git a/lustre/lov/lproc_lov.c b/lustre/lov/lproc_lov.c index 442a491..3898868 100644 --- a/lustre/lov/lproc_lov.c +++ b/lustre/lov/lproc_lov.c @@ -276,12 +276,14 @@ static struct attribute *lov_attrs[] = { NULL, }; +KOBJ_ATTRIBUTE_GROUPS(lov); /* creates lov_groups */ + int lov_tunables_init(struct obd_device *obd) { struct lov_obd *lov = &obd->u.lov; int rc; - obd->obd_ktype.default_attrs = lov_attrs; + obd->obd_ktype.default_groups = KOBJ_ATTR_GROUPS(lov); rc = lprocfs_obd_setup(obd, false); if (rc) GOTO(out, rc); diff --git a/lustre/mdc/lproc_mdc.c b/lustre/mdc/lproc_mdc.c index cd91f3d..91d9aad 100644 --- a/lustre/mdc/lproc_mdc.c +++ b/lustre/mdc/lproc_mdc.c @@ -761,11 +761,13 @@ static struct attribute *mdc_attrs[] = { NULL, }; +KOBJ_ATTRIBUTE_GROUPS(mdc); /* creates mdc_groups */ + int mdc_tunables_init(struct obd_device *obd) { int rc; - obd->obd_ktype.default_attrs = mdc_attrs; + obd->obd_ktype.default_groups = KOBJ_ATTR_GROUPS(mdc); obd->obd_vars = lprocfs_mdc_obd_vars; rc = lprocfs_obd_setup(obd, false); diff --git a/lustre/mdd/mdd_lproc.c b/lustre/mdd/mdd_lproc.c index 120ec92..60bcb67 100644 --- a/lustre/mdd/mdd_lproc.c +++ b/lustre/mdd/mdd_lproc.c @@ -749,6 +749,8 @@ static struct attribute *mdd_attrs[] = { NULL, }; +KOBJ_ATTRIBUTE_GROUPS(mdd); /* creates mdd_groups */ + static void mdd_sysfs_release(struct kobject *kobj) { struct mdd_device *mdd = container_of(kobj, struct mdd_device, @@ -780,7 +782,7 @@ int mdd_procfs_init(struct mdd_device *mdd, const char *name) /* put reference taken by class_search_type */ kobject_put(&type->typ_kobj); - mdd->mdd_ktype.default_attrs = mdd_attrs; + mdd->mdd_ktype.default_groups = KOBJ_ATTR_GROUPS(mdd); mdd->mdd_ktype.release = mdd_sysfs_release; mdd->mdd_ktype.sysfs_ops = &lustre_sysfs_ops; diff --git a/lustre/mdt/mdt_coordinator.c b/lustre/mdt/mdt_coordinator.c index 0ff12de..e1cebc2 100644 --- a/lustre/mdt/mdt_coordinator.c +++ b/lustre/mdt/mdt_coordinator.c @@ -2582,6 +2582,8 @@ static struct attribute *hsm_attrs[] = { NULL, }; +KOBJ_ATTRIBUTE_GROUPS(hsm); /* creates hsm_groups from hsm_attrs */ + static void hsm_kobj_release(struct kobject *kobj) { struct coordinator *cdt = container_of(kobj, struct coordinator, @@ -2594,7 +2596,7 @@ static void hsm_kobj_release(struct kobject *kobj) } static struct kobj_type hsm_ktype = { - .default_attrs = hsm_attrs, + .default_groups = KOBJ_ATTR_GROUPS(hsm), .sysfs_ops = &lustre_sysfs_ops, .release = hsm_kobj_release, }; diff --git a/lustre/mdt/mdt_lproc.c b/lustre/mdt/mdt_lproc.c index 9ae3013..64dffbe 100644 --- a/lustre/mdt/mdt_lproc.c +++ b/lustre/mdt/mdt_lproc.c @@ -1421,6 +1421,8 @@ static struct attribute *mdt_attrs[] = { NULL, }; +KOBJ_ATTRIBUTE_GROUPS(mdt); /* creates mdt_groups from mdt_attrs */ + static struct lprocfs_vars lprocfs_mdt_obd_vars[] = { { .name = "recovery_status", .fops = &mdt_recovery_status_fops }, @@ -1559,7 +1561,7 @@ int mdt_tunables_init(struct mdt_device *mdt, const char *name) ENTRY; LASSERT(name != NULL); - obd->obd_ktype.default_attrs = mdt_attrs; + obd->obd_ktype.default_groups = KOBJ_ATTR_GROUPS(mdt); obd->obd_vars = lprocfs_mdt_obd_vars; rc = lprocfs_obd_setup(obd, true); if (rc) { diff --git a/lustre/mgc/lproc_mgc.c b/lustre/mgc/lproc_mgc.c index 84cd38b..051e315 100644 --- a/lustre/mgc/lproc_mgc.c +++ b/lustre/mgc/lproc_mgc.c @@ -116,11 +116,13 @@ static struct attribute *mgc_attrs[] = { NULL, }; +KOBJ_ATTRIBUTE_GROUPS(mgc); + int mgc_tunables_init(struct obd_device *obd) { int rc; - obd->obd_ktype.default_attrs = mgc_attrs; + obd->obd_ktype.default_groups = KOBJ_ATTR_GROUPS(mgc); obd->obd_debugfs_vars = ldebugfs_mgc_obd_vars; rc = lprocfs_obd_setup(obd, true); if (rc) diff --git a/lustre/mgs/lproc_mgs.c b/lustre/mgs/lproc_mgs.c index 3fd918a..5344f18 100644 --- a/lustre/mgs/lproc_mgs.c +++ b/lustre/mgs/lproc_mgs.c @@ -256,17 +256,19 @@ static struct attribute *mgs_attrs[] = { NULL, }; +KOBJ_ATTRIBUTE_GROUPS(mgs); /* creates mgs_groups from mgs_attrs */ + int lproc_mgs_setup(struct mgs_device *mgs, const char *osd_name) { int osd_len = strlen(osd_name) - strlen("-osd"); struct obd_device *obd = mgs->mgs_obd; const struct kobj_type *bottom_type; + struct attribute *attr; struct obd_device *osd_obd; int rc; - int i; obd->obd_vars = lprocfs_mgs_obd_vars; - obd->obd_ktype.default_attrs = mgs_attrs; + obd->obd_ktype.default_groups = KOBJ_ATTR_GROUPS(mgs); rc = lprocfs_obd_setup(obd, true); if (rc != 0) GOTO(out, rc); @@ -304,21 +306,12 @@ int lproc_mgs_setup(struct mgs_device *mgs, const char *osd_name) } bottom_type = get_ktype(&mgs->mgs_bottom->dd_kobj); - - for (i = 0; bottom_type->default_attrs[i]; i++) { - if (strcmp(bottom_type->default_attrs[i]->name, "fstype") == 0) { - mgs->mgs_fstype = bottom_type->default_attrs[i]; - break; - } - } - - for (i = 0; bottom_type->default_attrs[i]; i++) { - if (strcmp(bottom_type->default_attrs[i]->name, "mntdev") == 0) { - mgs->mgs_mntdev = bottom_type->default_attrs[i]; - break; - } - } - + attr = get_attr_by_name(bottom_type, "fstype"); + if (attr) + mgs->mgs_fstype = attr; + attr = get_attr_by_name(bottom_type, "mntdev"); + if (attr) + mgs->mgs_fstype = mgs->mgs_mntdev; osd_obd = mgs->mgs_bottom->dd_lu_dev.ld_obd; mgs->mgs_proc_osd = lprocfs_add_symlink("osd", obd->obd_proc_entry, diff --git a/lustre/obdclass/obd_config.c b/lustre/obdclass/obd_config.c index 2697b57..183d719 100644 --- a/lustre/obdclass/obd_config.c +++ b/lustre/obdclass/obd_config.c @@ -1633,7 +1633,7 @@ ssize_t class_modify_config(struct lustre_cfg *lcfg, const char *prefix, } typ = get_ktype(kobj); - if (!typ || !typ->default_attrs) + if (!typ || !typ->default_groups) return -ENODEV; print_lustre_cfg(lcfg); @@ -1644,11 +1644,10 @@ ssize_t class_modify_config(struct lustre_cfg *lcfg, const char *prefix, * or lctl conf_param lustre-OST0000.osc.max_dirty_mb=36 */ for (i = 1; i < lcfg->lcfg_bufcount; i++) { - struct attribute *attr; + struct attribute *attr = NULL; size_t keylen; char *value; char *key; - int j; key = lustre_cfg_buf(lcfg, i); /* Strip off prefix */ @@ -1670,15 +1669,7 @@ ssize_t class_modify_config(struct lustre_cfg *lcfg, const char *prefix, keylen = value - key; value++; - attr = NULL; - for (j = 0; typ->default_attrs[j]; j++) { - if (!strncmp(typ->default_attrs[j]->name, key, - keylen)) { - attr = typ->default_attrs[j]; - break; - } - } - + attr = get_attr_starts_with(typ, key, keylen); if (!attr) { char *envp[4], *param, *path; diff --git a/lustre/ofd/lproc_ofd.c b/lustre/ofd/lproc_ofd.c index db81351..ca38cfc 100644 --- a/lustre/ofd/lproc_ofd.c +++ b/lustre/ofd/lproc_ofd.c @@ -1127,6 +1127,8 @@ static struct attribute *ofd_attrs[] = { NULL, }; +KOBJ_ATTRIBUTE_GROUPS(ofd); /* creates ofd_groups from ofd_attrs */ + /** * Initialize all needed procfs entries for OFD device. * @@ -1145,7 +1147,7 @@ int ofd_tunables_init(struct ofd_device *ofd) /* lprocfs must be setup before the ofd so state can be safely added * to /proc incrementally as the ofd is setup */ - obd->obd_ktype.default_attrs = ofd_attrs; + obd->obd_ktype.default_groups = KOBJ_ATTR_GROUPS(ofd); obd->obd_vars = lprocfs_ofd_obd_vars; rc = lprocfs_obd_setup(obd, false); if (rc) { diff --git a/lustre/osc/lproc_osc.c b/lustre/osc/lproc_osc.c index 58d95f3..78a8c14 100644 --- a/lustre/osc/lproc_osc.c +++ b/lustre/osc/lproc_osc.c @@ -884,12 +884,14 @@ static struct attribute *osc_attrs[] = { NULL, }; +KOBJ_ATTRIBUTE_GROUPS(osc); /* creates osc_groups */ + int osc_tunables_init(struct obd_device *obd) { int rc; obd->obd_vars = lprocfs_osc_obd_vars; - obd->obd_ktype.default_attrs = osc_attrs; + obd->obd_ktype.default_groups = KOBJ_ATTR_GROUPS(osc); rc = lprocfs_obd_setup(obd, false); if (rc) return rc; diff --git a/lustre/osd-ldiskfs/osd_lproc.c b/lustre/osd-ldiskfs/osd_lproc.c index b93881b..4abf45c 100644 --- a/lustre/osd-ldiskfs/osd_lproc.c +++ b/lustre/osd-ldiskfs/osd_lproc.c @@ -816,6 +816,8 @@ static struct attribute *ldiskfs_attrs[] = { NULL, }; +KOBJ_ATTRIBUTE_GROUPS(ldiskfs); /* creates ldiskfs_groups from ldiskfs_attrs */ + int osd_procfs_init(struct osd_device *osd, const char *name) { struct obd_type *type; @@ -836,7 +838,7 @@ int osd_procfs_init(struct osd_device *osd, const char *name) /* put reference taken by class_search_type */ kobject_put(&type->typ_kobj); - osd->od_dt_dev.dd_ktype.default_attrs = ldiskfs_attrs; + osd->od_dt_dev.dd_ktype.default_groups = KOBJ_ATTR_GROUPS(ldiskfs); rc = dt_tunables_init(&osd->od_dt_dev, type, name, ldebugfs_osd_obd_vars); if (rc) { diff --git a/lustre/osd-zfs/osd_lproc.c b/lustre/osd-zfs/osd_lproc.c index c199717..45936e8 100644 --- a/lustre/osd-zfs/osd_lproc.c +++ b/lustre/osd-zfs/osd_lproc.c @@ -355,6 +355,8 @@ struct ldebugfs_vars ldebugfs_osd_obd_vars[] = { { 0 } }; +KOBJ_ATTRIBUTE_GROUPS(zfs); /* creates zfs_groups from zfs_attrs */ + int osd_procfs_init(struct osd_device *osd, const char *name) { struct obd_type *type; @@ -373,7 +375,7 @@ int osd_procfs_init(struct osd_device *osd, const char *name) /* put reference taken by class_search_type */ kobject_put(&type->typ_kobj); - osd->od_dt_dev.dd_ktype.default_attrs = zfs_attrs; + osd->od_dt_dev.dd_ktype.default_groups = KOBJ_ATTR_GROUPS(zfs); rc = dt_tunables_init(&osd->od_dt_dev, type, name, ldebugfs_osd_obd_vars); if (rc) { diff --git a/lustre/osp/lproc_osp.c b/lustre/osp/lproc_osp.c index 4a11e55..82ebc33 100644 --- a/lustre/osp/lproc_osp.c +++ b/lustre/osp/lproc_osp.c @@ -1051,6 +1051,8 @@ static struct attribute *osp_obd_attrs[] = { NULL, }; +KOBJ_ATTRIBUTE_GROUPS(osp_obd); /* creates osp_obd_groups from osp_obd_attrs */ + static struct attribute *osp_md_attrs[] = { /* First two for compatiability reasons */ &lustre_attr_lfsck_max_rpcs_in_flight.attr, @@ -1065,6 +1067,8 @@ static struct attribute *osp_md_attrs[] = { NULL, }; +KOBJ_ATTRIBUTE_GROUPS(osp_md); /* creates osp_md_groups from osp_md_attrs */ + void osp_tunables_fini(struct osp_device *osp) { struct obd_device *obd = osp->opd_obd; @@ -1099,10 +1103,12 @@ void osp_tunables_init(struct osp_device *osp) int rc; if (osp->opd_connect_mdt) { - osp->opd_dt_dev.dd_ktype.default_attrs = osp_md_attrs; + osp->opd_dt_dev.dd_ktype.default_groups = + KOBJ_ATTR_GROUPS(osp_md); obd->obd_debugfs_vars = ldebugfs_osp_md_vars; } else { - osp->opd_dt_dev.dd_ktype.default_attrs = osp_obd_attrs; + osp->opd_dt_dev.dd_ktype.default_groups = + KOBJ_ATTR_GROUPS(osp_obd); obd->obd_debugfs_vars = ldebugfs_osp_obd_vars; } diff --git a/lustre/ptlrpc/lproc_ptlrpc.c b/lustre/ptlrpc/lproc_ptlrpc.c index bfb48d6..0e0b170 100644 --- a/lustre/ptlrpc/lproc_ptlrpc.c +++ b/lustre/ptlrpc/lproc_ptlrpc.c @@ -1183,6 +1183,8 @@ static struct attribute *ptlrpc_svc_attrs[] = { NULL, }; +KOBJ_ATTRIBUTE_GROUPS(ptlrpc_svc); /* creates ptlrpc_svc_groups */ + static void ptlrpc_sysfs_svc_release(struct kobject *kobj) { struct ptlrpc_service *svc = container_of(kobj, struct ptlrpc_service, @@ -1192,7 +1194,7 @@ static void ptlrpc_sysfs_svc_release(struct kobject *kobj) } static struct kobj_type ptlrpc_svc_ktype = { - .default_attrs = ptlrpc_svc_attrs, + .default_groups = KOBJ_ATTR_GROUPS(ptlrpc_svc), .sysfs_ops = &lustre_sysfs_ops, .release = ptlrpc_sysfs_svc_release, }; -- 1.8.3.1