From e783bbffe35b2b8ebebde5bc70abf288d07df5a3 Mon Sep 17 00:00:00 2001 From: James Simmons Date: Thu, 15 Nov 2018 13:20:30 -0500 Subject: [PATCH] LU-8066 mdd: migrate from proc to sysfs Move the ofd module from using proc for most single value files to sysfs. The more complex proc entries are moved to debugfs. Change-Id: I01eebf1c58f1a13c2f5e8c599a1363c80468b0bd Signed-off-by: James Simmons Reviewed-on: https://review.whamcloud.com/33632 Tested-by: Jenkins Tested-by: Maloo Reviewed-by: Alex Zhuravlev Reviewed-by: Andreas Dilger Reviewed-by: Oleg Drokin --- lustre/include/lustre_lfsck.h | 2 +- lustre/lfsck/lfsck_lib.c | 5 +- lustre/mdd/mdd_device.c | 9 +- lustre/mdd/mdd_internal.h | 4 +- lustre/mdd/mdd_lproc.c | 412 ++++++++++++++++++++++-------------------- lustre/utils/lustre_lfsck.c | 18 +- 6 files changed, 244 insertions(+), 206 deletions(-) diff --git a/lustre/include/lustre_lfsck.h b/lustre/include/lustre_lfsck.h index d982b1a..11409b9 100644 --- a/lustre/include/lustre_lfsck.h +++ b/lustre/include/lustre_lfsck.h @@ -103,7 +103,7 @@ int lfsck_query(const struct lu_env *env, struct dt_device *key, int lfsck_get_speed(struct seq_file *m, char *buf, struct dt_device *key); int lfsck_set_speed(struct dt_device *key, __u32 val); -int lfsck_get_windows(struct seq_file *m, struct dt_device *key); +int lfsck_get_windows(char *buf, struct dt_device *key); int lfsck_set_windows(struct dt_device *key, unsigned int val); int lfsck_dump(struct seq_file *m, struct dt_device *key, enum lfsck_type type); diff --git a/lustre/lfsck/lfsck_lib.c b/lustre/lfsck/lfsck_lib.c index 80cb8eb..5f5860f 100644 --- a/lustre/lfsck/lfsck_lib.c +++ b/lustre/lfsck/lfsck_lib.c @@ -2804,7 +2804,7 @@ int lfsck_set_speed(struct dt_device *key, __u32 val) } EXPORT_SYMBOL(lfsck_set_speed); -int lfsck_get_windows(struct seq_file *m, struct dt_device *key) +int lfsck_get_windows(char *buf, struct dt_device *key) { struct lu_env env; struct lfsck_instance *lfsck; @@ -2817,7 +2817,8 @@ int lfsck_get_windows(struct seq_file *m, struct dt_device *key) lfsck = lfsck_instance_find(key, true, false); if (likely(lfsck != NULL)) { - seq_printf(m, "%u\n", lfsck->li_bookmark_ram.lb_async_windows); + rc = sprintf(buf, "%u\n", + lfsck->li_bookmark_ram.lb_async_windows); lfsck_instance_put(&env, lfsck); } else { rc = -ENXIO; diff --git a/lustre/mdd/mdd_device.c b/lustre/mdd/mdd_device.c index ac5ee30..4bf260f 100644 --- a/lustre/mdd/mdd_device.c +++ b/lustre/mdd/mdd_device.c @@ -1095,10 +1095,11 @@ static int mdd_process_config(const struct lu_env *env, switch (cfg->lcfg_command) { case LCFG_PARAM: { - struct obd_device *obd = mdd2obd_dev(m); + ssize_t count; - rc = class_process_proc_param(PARAM_MDD, obd->obd_vars, cfg, m); - if (rc > 0 || rc == -ENOSYS) + count = class_modify_config(cfg, PARAM_MDD, &m->mdd_kobj); + rc = count > 0 ? 0 : count; + if (rc) /* we don't understand; pass it on */ rc = next->ld_ops->ldo_process_config(env, next, cfg); break; @@ -1982,7 +1983,7 @@ static int __init mdd_init(void) if (rc) return rc; - rc = class_register_type(&mdd_obd_device_ops, NULL, true, NULL, + rc = class_register_type(&mdd_obd_device_ops, NULL, false, NULL, LUSTRE_MDD_NAME, &mdd_device_type); if (rc) lu_kmem_fini(mdd_caches); diff --git a/lustre/mdd/mdd_internal.h b/lustre/mdd/mdd_internal.h index ba43571..d1f195c 100644 --- a/lustre/mdd/mdd_internal.h +++ b/lustre/mdd/mdd_internal.h @@ -139,7 +139,6 @@ struct mdd_device { struct lu_fid mdd_local_root_fid; struct dt_device_param mdd_dt_conf; struct dt_object *mdd_orphans; /* PENDING directory */ - struct proc_dir_entry *mdd_proc_entry; struct mdd_changelog mdd_cl; unsigned int mdd_changelog_gc; time64_t mdd_changelog_max_idle_time; @@ -153,6 +152,9 @@ struct mdd_device { int mdd_connects; struct local_oid_storage *mdd_los; struct mdd_generic_thread mdd_orphan_cleanup_thread; + struct kobject mdd_kobj; + struct kobj_type mdd_ktype; + struct completion mdd_kobj_unregister; }; enum mod_flags { diff --git a/lustre/mdd/mdd_lproc.c b/lustre/mdd/mdd_lproc.c index 78366e3..fe3ddaa 100644 --- a/lustre/mdd/mdd_lproc.c +++ b/lustre/mdd/mdd_lproc.c @@ -45,31 +45,43 @@ #include #include "mdd_internal.h" -static ssize_t -mdd_atime_diff_seq_write(struct file *file, const char __user *buffer, - size_t count, loff_t *off) +static ssize_t uuid_show(struct kobject *kobj, struct attribute *attr, + char *buf) { - struct seq_file *m = file->private_data; - struct mdd_device *mdd = m->private; + struct mdd_device *mdd = container_of(kobj, struct mdd_device, + mdd_kobj); + struct obd_device *obd = mdd2obd_dev(mdd); + + return sprintf(buf, "%s\n", obd->obd_uuid.uuid); +} +LUSTRE_RO_ATTR(uuid); + +static ssize_t atime_diff_show(struct kobject *kobj, struct attribute *attr, + char *buf) +{ + struct mdd_device *mdd = container_of(kobj, struct mdd_device, + mdd_kobj); + + return sprintf(buf, "%lld\n", mdd->mdd_atime_diff); +} + +static ssize_t atime_diff_store(struct kobject *kobj, + struct attribute *attr, + const char *buffer, size_t count) +{ + struct mdd_device *mdd = container_of(kobj, struct mdd_device, + mdd_kobj); time64_t diff = 0; int rc; - rc = kstrtoll_from_user(buffer, count, 0, &diff); + rc = kstrtoll(buffer, 10, &diff); if (rc) return rc; mdd->mdd_atime_diff = diff; return count; } - -static int mdd_atime_diff_seq_show(struct seq_file *m, void *data) -{ - struct mdd_device *mdd = m->private; - - seq_printf(m, "%lld\n", mdd->mdd_atime_diff); - return 0; -} -LPROC_SEQ_FOPS(mdd_atime_diff); +LUSTRE_RW_ATTR(atime_diff); /**** changelogs ****/ static int mdd_changelog_mask_seq_show(struct seq_file *m, void *data) @@ -113,7 +125,7 @@ out: OBD_FREE(kernbuf, PAGE_SIZE); return rc; } -LPROC_SEQ_FOPS(mdd_changelog_mask); +LDEBUGFS_SEQ_FOPS(mdd_changelog_mask); static int lprocfs_changelog_users_cb(const struct lu_env *env, struct llog_handle *llh, @@ -166,7 +178,7 @@ static int mdd_changelog_users_seq_show(struct seq_file *m, void *data) llog_ctxt_put(ctxt); return 0; } -LPROC_SEQ_FOPS_RO(mdd_changelog_users); +LDEBUGFS_SEQ_FOPS_RO(mdd_changelog_users); static int mdd_changelog_size_ctxt(const struct lu_env *env, struct mdd_device *mdd, @@ -193,12 +205,15 @@ static int mdd_changelog_size_ctxt(const struct lu_env *env, return 0; } -static int mdd_changelog_size_seq_show(struct seq_file *m, void *data) +static ssize_t changelog_size_show(struct kobject *kobj, + struct attribute *attr, + char *buf) { - struct lu_env env; - struct mdd_device *mdd = m->private; - __u64 tmp = 0; - int rc; + struct mdd_device *mdd = container_of(kobj, struct mdd_device, + mdd_kobj); + struct lu_env env; + u64 tmp = 0; + int rc; rc = lu_env_init(&env, LCT_LOCAL); if (rc) @@ -213,32 +228,32 @@ static int mdd_changelog_size_seq_show(struct seq_file *m, void *data) rc = mdd_changelog_size_ctxt(&env, mdd, LLOG_CHANGELOG_USER_ORIG_CTXT, &tmp); - seq_printf(m, "%llu\n", tmp); + rc = sprintf(buf, "%llu\n", tmp); lu_env_fini(&env); return rc; } -LPROC_SEQ_FOPS_RO(mdd_changelog_size); +LUSTRE_RO_ATTR(changelog_size); -static int mdd_changelog_gc_seq_show(struct seq_file *m, void *data) +static ssize_t changelog_gc_show(struct kobject *kobj, + struct attribute *attr, + char *buf) { - struct mdd_device *mdd = m->private; + struct mdd_device *mdd = container_of(kobj, struct mdd_device, + mdd_kobj); - LASSERT(mdd != NULL); - seq_printf(m, "%u\n", mdd->mdd_changelog_gc); - return 0; + return sprintf(buf, "%u\n", mdd->mdd_changelog_gc); } -static ssize_t -mdd_changelog_gc_seq_write(struct file *file, const char __user *buffer, - size_t count, loff_t *off) +static ssize_t changelog_gc_store(struct kobject *kobj, + struct attribute *attr, + const char *buffer, size_t count) { - struct seq_file *m = file->private_data; - struct mdd_device *mdd = m->private; + struct mdd_device *mdd = container_of(kobj, struct mdd_device, + mdd_kobj); bool val; int rc; - LASSERT(mdd != NULL); - rc = kstrtobool_from_user(buffer, count, &val); + rc = kstrtobool(buffer, &val); if (rc) return rc; @@ -246,30 +261,28 @@ mdd_changelog_gc_seq_write(struct file *file, const char __user *buffer, return count; } -LPROC_SEQ_FOPS(mdd_changelog_gc); +LUSTRE_RW_ATTR(changelog_gc); -static int mdd_changelog_max_idle_time_seq_show(struct seq_file *m, void *data) +static ssize_t changelog_max_idle_time_show(struct kobject *kobj, + struct attribute *attr, + char *buf) { - struct mdd_device *mdd = m->private; + struct mdd_device *mdd = container_of(kobj, struct mdd_device, + mdd_kobj); - LASSERT(mdd != NULL); - seq_printf(m, "%lld\n", mdd->mdd_changelog_max_idle_time); - return 0; + return sprintf(buf, "%lld\n", mdd->mdd_changelog_max_idle_time); } -static ssize_t -mdd_changelog_max_idle_time_seq_write(struct file *file, - const char __user *buffer, size_t count, - loff_t *off) +static ssize_t changelog_max_idle_time_store(struct kobject *kobj, + struct attribute *attr, + const char *buffer, size_t count) { - struct seq_file *m = file->private_data; - struct mdd_device *mdd = m->private; + struct mdd_device *mdd = container_of(kobj, struct mdd_device, + mdd_kobj); time64_t val; int rc; - LASSERT(mdd != NULL); - - rc = kstrtoll_from_user(buffer, count, 0, &val); + rc = kstrtoll(buffer, 10, &val); if (rc) return rc; @@ -284,30 +297,30 @@ mdd_changelog_max_idle_time_seq_write(struct file *file, return count; } -LPROC_SEQ_FOPS(mdd_changelog_max_idle_time); +LUSTRE_RW_ATTR(changelog_max_idle_time); -static int mdd_changelog_max_idle_indexes_seq_show(struct seq_file *m, - void *data) +static ssize_t changelog_max_idle_indexes_show(struct kobject *kobj, + struct attribute *attr, + char *buf) { - struct mdd_device *mdd = m->private; + struct mdd_device *mdd = container_of(kobj, struct mdd_device, + mdd_kobj); - LASSERT(mdd != NULL); - seq_printf(m, "%lu\n", mdd->mdd_changelog_max_idle_indexes); - return 0; + return sprintf(buf, "%lu\n", mdd->mdd_changelog_max_idle_indexes); } -static ssize_t -mdd_changelog_max_idle_indexes_seq_write(struct file *file, - const char __user *buffer, - size_t count, loff_t *off) +static ssize_t changelog_max_idle_indexes_store(struct kobject *kobj, + struct attribute *attr, + const char *buffer, + size_t count) { - struct seq_file *m = file->private_data; - struct mdd_device *mdd = m->private; + struct mdd_device *mdd = container_of(kobj, struct mdd_device, + mdd_kobj); unsigned long val; int rc; LASSERT(mdd != NULL); - rc = kstrtoul_from_user(buffer, count, 0, &val); + rc = kstrtoul(buffer, 0, &val); if (rc) return rc; @@ -318,30 +331,29 @@ mdd_changelog_max_idle_indexes_seq_write(struct file *file, return count; } -LPROC_SEQ_FOPS(mdd_changelog_max_idle_indexes); +LUSTRE_RW_ATTR(changelog_max_idle_indexes); -static int mdd_changelog_min_gc_interval_seq_show(struct seq_file *m, - void *data) +static ssize_t changelog_min_gc_interval_show(struct kobject *kobj, + struct attribute *attr, + char *buf) { - struct mdd_device *mdd = m->private; + struct mdd_device *mdd = container_of(kobj, struct mdd_device, + mdd_kobj); - LASSERT(mdd != NULL); - seq_printf(m, "%lld\n", mdd->mdd_changelog_min_gc_interval); - return 0; + return sprintf(buf, "%lld\n", mdd->mdd_changelog_min_gc_interval); } -static ssize_t -mdd_changelog_min_gc_interval_seq_write(struct file *file, - const char __user *buffer, - size_t count, loff_t *off) +static ssize_t changelog_min_gc_interval_store(struct kobject *kobj, + struct attribute *attr, + const char *buffer, + size_t count) { - struct seq_file *m = file->private_data; - struct mdd_device *mdd = m->private; + struct mdd_device *mdd = container_of(kobj, struct mdd_device, + mdd_kobj); time64_t val; int rc; - LASSERT(mdd != NULL); - rc = kstrtoll_from_user(buffer, count, 0, &val); + rc = kstrtoll(buffer, 10, &val); if (rc) return rc; @@ -353,30 +365,29 @@ mdd_changelog_min_gc_interval_seq_write(struct file *file, return count; } -LPROC_SEQ_FOPS(mdd_changelog_min_gc_interval); +LUSTRE_RW_ATTR(changelog_min_gc_interval); -static int mdd_changelog_min_free_cat_entries_seq_show(struct seq_file *m, - void *data) +static ssize_t changelog_min_free_cat_entries_show(struct kobject *kobj, + struct attribute *attr, + char *buf) { - struct mdd_device *mdd = m->private; + struct mdd_device *mdd = container_of(kobj, struct mdd_device, + mdd_kobj); - LASSERT(mdd != NULL); - seq_printf(m, "%u\n", mdd->mdd_changelog_min_free_cat_entries); - return 0; + return sprintf(buf, "%u\n", mdd->mdd_changelog_min_free_cat_entries); } -static ssize_t -mdd_changelog_min_free_cat_entries_seq_write(struct file *file, - const char __user *buffer, - size_t count, loff_t *off) +static ssize_t changelog_min_free_cat_entries_store(struct kobject *kobj, + struct attribute *attr, + const char *buffer, + size_t count) { - struct seq_file *m = file->private_data; - struct mdd_device *mdd = m->private; + struct mdd_device *mdd = container_of(kobj, struct mdd_device, + mdd_kobj); unsigned int val; int rc; - LASSERT(mdd != NULL); - rc = kstrtouint_from_user(buffer, count, 0, &val); + rc = kstrtouint(buffer, 10, &val); if (rc) return rc; @@ -388,63 +399,55 @@ mdd_changelog_min_free_cat_entries_seq_write(struct file *file, return count; } -LPROC_SEQ_FOPS(mdd_changelog_min_free_cat_entries); +LUSTRE_RW_ATTR(changelog_min_free_cat_entries); -static int mdd_changelog_deniednext_seq_show(struct seq_file *m, void *data) +static ssize_t changelog_deniednext_show(struct kobject *kobj, + struct attribute *attr, + char *buf) { - struct mdd_device *mdd = m->private; + struct mdd_device *mdd = container_of(kobj, struct mdd_device, + mdd_kobj); - seq_printf(m, "%u\n", mdd->mdd_cl.mc_deniednext); - return 0; + return sprintf(buf, "%u\n", mdd->mdd_cl.mc_deniednext); } -static ssize_t -mdd_changelog_deniednext_seq_write(struct file *file, const char __user *buffer, - size_t count, loff_t *off) +static ssize_t changelog_deniednext_store(struct kobject *kobj, + struct attribute *attr, + const char *buffer, + size_t count) { - struct seq_file *m = file->private_data; - struct mdd_device *mdd = m->private; - char kernbuf[11]; + struct mdd_device *mdd = container_of(kobj, struct mdd_device, + mdd_kobj); unsigned int time = 0; int rc; - if (count > (sizeof(kernbuf) - 1)) - return -EINVAL; - - if (copy_from_user(kernbuf, buffer, count)) - return -EFAULT; - - kernbuf[count] = '\0'; - - rc = kstrtoul(kernbuf, 0, (unsigned long int *)&time); + rc = kstrtouint(buffer, 0, &time); if (rc) return rc; mdd->mdd_cl.mc_deniednext = time; return count; } -LPROC_SEQ_FOPS(mdd_changelog_deniednext); +LUSTRE_RW_ATTR(changelog_deniednext); -static int mdd_sync_perm_seq_show(struct seq_file *m, void *data) +static ssize_t sync_perm_show(struct kobject *kobj, struct attribute *attr, + char *buf) { - struct mdd_device *mdd = m->private; + struct mdd_device *mdd = container_of(kobj, struct mdd_device, + mdd_kobj); - LASSERT(mdd != NULL); - seq_printf(m, "%d\n", mdd->mdd_sync_permission); - return 0; + return sprintf(buf, "%d\n", mdd->mdd_sync_permission); } -static ssize_t -mdd_sync_perm_seq_write(struct file *file, const char __user *buffer, - size_t count, loff_t *off) +static ssize_t sync_perm_store(struct kobject *kobj, struct attribute *attr, + const char *buffer, size_t count) { - struct seq_file *m = file->private_data; - struct mdd_device *mdd = m->private; + struct mdd_device *mdd = container_of(kobj, struct mdd_device, + mdd_kobj); bool val; int rc; - LASSERT(mdd != NULL); - rc = kstrtobool_from_user(buffer, count, &val); + rc = kstrtobool(buffer, &val); if (rc) return rc; @@ -452,54 +455,54 @@ mdd_sync_perm_seq_write(struct file *file, const char __user *buffer, return count; } -LPROC_SEQ_FOPS(mdd_sync_perm); +LUSTRE_RW_ATTR(sync_perm); -static int mdd_lfsck_speed_limit_seq_show(struct seq_file *m, void *data) +static ssize_t lfsck_speed_limit_show(struct kobject *kobj, + struct attribute *attr, char *buf) { - struct mdd_device *mdd = m->private; + struct mdd_device *mdd = container_of(kobj, struct mdd_device, + mdd_kobj); - LASSERT(mdd != NULL); - return lfsck_get_speed(m, NULL, mdd->mdd_bottom); + return lfsck_get_speed(NULL, buf, mdd->mdd_bottom); } -static ssize_t -mdd_lfsck_speed_limit_seq_write(struct file *file, const char __user *buffer, - size_t count, loff_t *off) +static ssize_t lfsck_speed_limit_store(struct kobject *kobj, + struct attribute *attr, + const char *buffer, size_t count) { - struct seq_file *m = file->private_data; - struct mdd_device *mdd = m->private; + struct mdd_device *mdd = container_of(kobj, struct mdd_device, + mdd_kobj); unsigned int val; int rc; - LASSERT(mdd != NULL); - rc = kstrtouint_from_user(buffer, count, 0, &val); + rc = kstrtouint(buffer, 10, &val); if (rc != 0) return rc; rc = lfsck_set_speed(mdd->mdd_bottom, val); return rc != 0 ? rc : count; } -LPROC_SEQ_FOPS(mdd_lfsck_speed_limit); +LUSTRE_RW_ATTR(lfsck_speed_limit); -static int mdd_lfsck_async_windows_seq_show(struct seq_file *m, void *data) +static ssize_t lfsck_async_windows_show(struct kobject *kobj, + struct attribute *attr, char *buf) { - struct mdd_device *mdd = m->private; + struct mdd_device *mdd = container_of(kobj, struct mdd_device, + mdd_kobj); - LASSERT(mdd != NULL); - return lfsck_get_windows(m, mdd->mdd_bottom); + return lfsck_get_windows(buf, mdd->mdd_bottom); } -static ssize_t -mdd_lfsck_async_windows_seq_write(struct file *file, const char __user *buffer, - size_t count, loff_t *off) +static ssize_t lfsck_async_windows_store(struct kobject *kobj, + struct attribute *attr, + const char *buffer, size_t count) { - struct seq_file *m = file->private_data; - struct mdd_device *mdd = m->private; + struct mdd_device *mdd = container_of(kobj, struct mdd_device, + mdd_kobj); unsigned int val; int rc; - LASSERT(mdd != NULL); - rc = kstrtouint_from_user(buffer, count, 0, &val); + rc = kstrtouint(buffer, 10, &val); if (rc) return rc; @@ -507,7 +510,7 @@ mdd_lfsck_async_windows_seq_write(struct file *file, const char __user *buffer, return rc != 0 ? rc : count; } -LPROC_SEQ_FOPS(mdd_lfsck_async_windows); +LUSTRE_RW_ATTR(lfsck_async_windows); static int mdd_lfsck_namespace_seq_show(struct seq_file *m, void *data) { @@ -517,7 +520,7 @@ static int mdd_lfsck_namespace_seq_show(struct seq_file *m, void *data) return lfsck_dump(m, mdd->mdd_bottom, LFSCK_TYPE_NAMESPACE); } -LPROC_SEQ_FOPS_RO(mdd_lfsck_namespace); +LDEBUGFS_SEQ_FOPS_RO(mdd_lfsck_namespace); static int mdd_lfsck_layout_seq_show(struct seq_file *m, void *data) { @@ -527,35 +530,13 @@ static int mdd_lfsck_layout_seq_show(struct seq_file *m, void *data) return lfsck_dump(m, mdd->mdd_bottom, LFSCK_TYPE_LAYOUT); } -LPROC_SEQ_FOPS_RO(mdd_lfsck_layout); +LDEBUGFS_SEQ_FOPS_RO(mdd_lfsck_layout); static struct lprocfs_vars lprocfs_mdd_obd_vars[] = { - { .name = "atime_diff", - .fops = &mdd_atime_diff_fops }, { .name = "changelog_mask", .fops = &mdd_changelog_mask_fops }, { .name = "changelog_users", .fops = &mdd_changelog_users_fops }, - { .name = "changelog_size", - .fops = &mdd_changelog_size_fops }, - { .name = "changelog_gc", - .fops = &mdd_changelog_gc_fops }, - { .name = "changelog_max_idle_time", - .fops = &mdd_changelog_max_idle_time_fops }, - { .name = "changelog_max_idle_indexes", - .fops = &mdd_changelog_max_idle_indexes_fops }, - { .name = "changelog_min_gc_interval", - .fops = &mdd_changelog_min_gc_interval_fops }, - { .name = "changelog_min_free_cat_entries", - .fops = &mdd_changelog_min_free_cat_entries_fops }, - { .name = "changelog_deniednext", - .fops = &mdd_changelog_deniednext_fops }, - { .name = "sync_permission", - .fops = &mdd_sync_perm_fops }, - { .name = "lfsck_speed_limit", - .fops = &mdd_lfsck_speed_limit_fops }, - { .name = "lfsck_async_windows", - .fops = &mdd_lfsck_async_windows_fops }, { .name = "lfsck_namespace", .fops = &mdd_lfsck_namespace_fops }, { .name = "lfsck_layout", @@ -563,42 +544,81 @@ static struct lprocfs_vars lprocfs_mdd_obd_vars[] = { { NULL } }; +static struct attribute *mdd_attrs[] = { + &lustre_attr_uuid.attr, + &lustre_attr_atime_diff.attr, + &lustre_attr_changelog_size.attr, + &lustre_attr_changelog_gc.attr, + &lustre_attr_changelog_max_idle_time.attr, + &lustre_attr_changelog_max_idle_indexes.attr, + &lustre_attr_changelog_min_gc_interval.attr, + &lustre_attr_changelog_min_free_cat_entries.attr, + &lustre_attr_changelog_deniednext.attr, + &lustre_attr_lfsck_async_windows.attr, + &lustre_attr_lfsck_speed_limit.attr, + &lustre_attr_sync_perm.attr, + NULL, +}; + +static void mdd_sysfs_release(struct kobject *kobj) +{ + struct mdd_device *mdd = container_of(kobj, struct mdd_device, + mdd_kobj); + + complete(&mdd->mdd_kobj_unregister); +} + int mdd_procfs_init(struct mdd_device *mdd, const char *name) { struct obd_device *obd = mdd2obd_dev(mdd); - struct obd_type *type; - int rc; - ENTRY; + struct obd_type *type; + int rc; + ENTRY; /* at the moment there is no linkage between lu_type - * and obd_type, so we lookup obd_type this way */ + * and obd_type, so we lookup obd_type this way + */ type = class_search_type(LUSTRE_MDD_NAME); LASSERT(name != NULL); LASSERT(type != NULL); LASSERT(obd != NULL); + mdd->mdd_ktype.default_attrs = mdd_attrs; + mdd->mdd_ktype.release = mdd_sysfs_release; + mdd->mdd_ktype.sysfs_ops = &lustre_sysfs_ops; + + init_completion(&mdd->mdd_kobj_unregister); + rc = kobject_init_and_add(&mdd->mdd_kobj, &mdd->mdd_ktype, + type->typ_kobj, "%s", name); + if (rc) + return rc; + /* Find the type procroot and add the proc entry for this device */ obd->obd_vars = lprocfs_mdd_obd_vars; - mdd->mdd_proc_entry = lprocfs_register(name, type->typ_procroot, - obd->obd_vars, mdd); - if (IS_ERR(mdd->mdd_proc_entry)) { - rc = PTR_ERR(mdd->mdd_proc_entry); - CERROR("Error %d setting up lprocfs for %s\n", + obd->obd_debugfs_entry = ldebugfs_register(name, + type->typ_debugfs_entry, + obd->obd_vars, mdd); + if (IS_ERR_OR_NULL(obd->obd_debugfs_entry)) { + rc = obd->obd_debugfs_entry ? PTR_ERR(obd->obd_debugfs_entry) + : -ENOMEM; + CERROR("Error %d setting up debugfs for %s\n", rc, name); - mdd->mdd_proc_entry = NULL; - GOTO(out, rc); + obd->obd_debugfs_entry = NULL; + + kobject_put(&mdd->mdd_kobj); } - rc = 0; - EXIT; -out: - if (rc) - mdd_procfs_fini(mdd); - return rc; + + RETURN(rc); } void mdd_procfs_fini(struct mdd_device *mdd) { - if (mdd->mdd_proc_entry) - lprocfs_remove(&mdd->mdd_proc_entry); + struct obd_device *obd = mdd2obd_dev(mdd); + + kobject_put(&mdd->mdd_kobj); + wait_for_completion(&mdd->mdd_kobj_unregister); + + if (!IS_ERR_OR_NULL(obd->obd_debugfs_entry)) + ldebugfs_remove(&obd->obd_debugfs_entry); } diff --git a/lustre/utils/lustre_lfsck.c b/lustre/utils/lustre_lfsck.c index e486000..b6bef2a 100644 --- a/lustre/utils/lustre_lfsck.c +++ b/lustre/utils/lustre_lfsck.c @@ -203,6 +203,7 @@ static int lfsck_get_dev_name(struct obd_ioctl_data *data, char *device, int types, bool multipe_devices) { glob_t param = { 0 }; + size_t count = 0; char *ptr; int rc; int i; @@ -226,7 +227,16 @@ static int lfsck_get_dev_name(struct obd_ioctl_data *data, char *device, } } - if (param.gl_pathc == 1) + /* we have both sysfs and debugfs entries so to get the correct number + * of devices only count the entries in the sysfs tree + */ + for (i = 0; i < param.gl_pathc; i++) { + if (strstr(param.gl_pathv[i], "/sys/kernel/debug/lustre")) + continue; + count++; + } + + if (count == 1) goto pack; if (!multipe_devices) { @@ -245,8 +255,12 @@ static int lfsck_get_dev_name(struct obd_ioctl_data *data, char *device, } for (i = 1; i < param.gl_pathc; i++) { - char *ptr2 = strrchr(param.gl_pathv[i], '-'); + char *ptr2; + + if (strstr(param.gl_pathv[i], "/sys/kernel/debug/lustre")) + continue; + ptr2 = strrchr(param.gl_pathv[i], '-'); if (ptr2 == NULL) { rc = -EINVAL; goto out; -- 1.8.3.1