From adb5aca3d67380078c4bd35c74651a7b9f848f4d Mon Sep 17 00:00:00 2001 From: James Simmons Date: Sat, 13 Oct 2018 15:24:46 -0400 Subject: [PATCH] LU-8066 llite: Move all remaining procfs entries to debugfs This moves all remaining procfs handling in llite layer to debugfs. This is a modified version of Linux-commit : ae7c0f4833a65b7648cceaf1a60503a89e057f0f Change-Id: Id5c411d21a660a17a015ca9976b857e6b088c28a Signed-off-by: Dmitry Eremin Signed-off-by: Oleg Drokin Signed-off-by: Greg Kroah-Hartman Signed-off-by: James Simmons Reviewed-on: https://review.whamcloud.com/32517 Tested-by: Jenkins Tested-by: Maloo Reviewed-by: Andreas Dilger Reviewed-by: Ben Evans Reviewed-by: Oleg Drokin --- lustre/llite/llite_internal.h | 31 ++--- lustre/llite/llite_lib.c | 44 ++++--- lustre/llite/lproc_llite.c | 268 ++++++++++++++++++++------------------- lustre/llite/vvp_dev.c | 6 +- lustre/obdclass/lprocfs_status.c | 10 -- 5 files changed, 179 insertions(+), 180 deletions(-) diff --git a/lustre/llite/llite_internal.h b/lustre/llite/llite_internal.h index 45cf1a0..bcc6c2e 100644 --- a/lustre/llite/llite_internal.h +++ b/lustre/llite/llite_internal.h @@ -499,16 +499,16 @@ struct lustre_client_ocd { struct ll_sb_info { /* this protects pglist and ra_info. It isn't safe to * grab from interrupt contexts */ - spinlock_t ll_lock; - spinlock_t ll_pp_extent_lock; /* pp_extent entry*/ - spinlock_t ll_process_lock; /* ll_rw_process_info */ - struct obd_uuid ll_sb_uuid; - struct obd_export *ll_md_exp; - struct obd_export *ll_dt_exp; - struct obd_device *ll_md_obd; - struct obd_device *ll_dt_obd; - struct proc_dir_entry* ll_proc_root; - struct lu_fid ll_root_fid; /* root object fid */ + spinlock_t ll_lock; + spinlock_t ll_pp_extent_lock; /* pp_extent entry*/ + spinlock_t ll_process_lock; /* ll_rw_process_info */ + struct obd_uuid ll_sb_uuid; + struct obd_export *ll_md_exp; + struct obd_export *ll_dt_exp; + struct obd_device *ll_md_obd; + struct obd_device *ll_dt_obd; + struct dentry *ll_debugfs_entry; + struct lu_fid ll_root_fid; /* root object fid */ int ll_flags; unsigned int ll_umounting:1, @@ -684,7 +684,6 @@ struct ll_file_data { __u32 fd_layout_version; }; -extern struct proc_dir_entry *proc_lustre_fs_root; void llite_tunables_unregister(void); int llite_tunables_register(void); @@ -739,17 +738,9 @@ int cl_get_grouplock(struct cl_object *obj, unsigned long gid, int nonblock, void cl_put_grouplock(struct ll_grouplock *lg); /* llite/lproc_llite.c */ -#ifdef CONFIG_PROC_FS -void ll_stats_ops_tally(struct ll_sb_info *sbi, int op, int count); -extern struct lprocfs_vars lprocfs_llite_obd_vars[]; -#else -static inline int ll_debugs_register_super(struct super_block *sb, - const char *name) -{ return 0; } -static void ll_stats_ops_tally(struct ll_sb_info *sbi, int op, int count) {} -#endif int ll_debugfs_register_super(struct super_block *sb, const char *name); void ll_debugfs_unregister_super(struct super_block *sb); +void ll_stats_ops_tally(struct ll_sb_info *sbi, int op, int count); enum { LPROC_LL_DIRTY_HITS, diff --git a/lustre/llite/llite_lib.c b/lustre/llite/llite_lib.c index 654c874..f8db6a1 100644 --- a/lustre/llite/llite_lib.c +++ b/lustre/llite/llite_lib.c @@ -296,7 +296,7 @@ static int client_common_fill_super(struct super_block *sb, char *md, char *dt, * can make sure the client can be mounted as long as MDT0 is * avaible */ err = obd_statfs(NULL, sbi->ll_md_exp, osfs, - ktime_get_seconds() -OBD_STATFS_CACHE_SECONDS, + ktime_get_seconds() - OBD_STATFS_CACHE_SECONDS, OBD_STATFS_FOR_MDT0); if (err) GOTO(out_md_fid, err); @@ -431,8 +431,9 @@ static int client_common_fill_super(struct super_block *sb, char *md, char *dt, /* OBD_CONNECT_CKSUM should always be set, even if checksums are * disabled by default, because it can still be enabled on the - * fly via /proc. As a consequence, we still need to come to an - * agreement on the supported algorithms at connect time */ + * fly via /sys. As a consequence, we still need to come to an + * agreement on the supported algorithms at connect time + */ data->ocd_connect_flags |= OBD_CONNECT_CKSUM; if (OBD_FAIL_CHECK(OBD_FAIL_OSC_CKSUM_ADLER_ONLY)) @@ -1029,20 +1030,20 @@ int ll_fill_super(struct super_block *sb, struct vfsmount *mnt) OBD_ALLOC_PTR(cfg); if (cfg == NULL) - GOTO(out_free, err = -ENOMEM); + GOTO(out_free_cfg, err = -ENOMEM); /* client additional sb info */ lsi->lsi_llsbi = sbi = ll_init_sbi(); if (!sbi) - GOTO(out_free, err = -ENOMEM); + GOTO(out_free_cfg, err = -ENOMEM); err = ll_options(lsi->lsi_lmd->lmd_opts, sbi); if (err) - GOTO(out_free, err); + GOTO(out_free_cfg, err); err = super_setup_bdi_name(sb, "lustre-%p", sb); if (err) - GOTO(out_free, err); + GOTO(out_free_cfg, err); #ifndef HAVE_DCACHE_LOCK /* kernel >= 2.6.38 store dentry operations in sb->s_d_op. */ @@ -1069,8 +1070,9 @@ int ll_fill_super(struct super_block *sb, struct vfsmount *mnt) } /* Generate a string unique to this super, in case some joker tries - to mount the same fs at two mount points. - Use the address of the super itself.*/ + * to mount the same fs at two mount points. + * Use the address of the super itself. + */ cfg->cfg_instance = sb; cfg->cfg_uuid = lsi->lsi_llsbi->ll_sb_uuid; cfg->cfg_callback = class_config_llog_handler; @@ -1078,7 +1080,7 @@ int ll_fill_super(struct super_block *sb, struct vfsmount *mnt) /* set up client obds */ err = lustre_process_log(sb, profilenm, cfg); if (err < 0) - GOTO(out_proc, err); + GOTO(out_debugfs, err); /* Profile set with LCFG_MOUNTOPT so we can find our mdc and osc obds */ lprof = class_get_profile(profilenm); @@ -1086,7 +1088,7 @@ int ll_fill_super(struct super_block *sb, struct vfsmount *mnt) LCONSOLE_ERROR_MSG(0x156, "The client profile '%s' could not be" " read from the MGS. Does that filesystem " "exist?\n", profilenm); - GOTO(out_proc, err = -EINVAL); + GOTO(out_debugfs, err = -EINVAL); } CDEBUG(D_CONFIG, "Found profile %s: mdc=%s osc=%s\n", profilenm, lprof->lp_md, lprof->lp_dt); @@ -1094,34 +1096,38 @@ int ll_fill_super(struct super_block *sb, struct vfsmount *mnt) dt_len = strlen(lprof->lp_dt) + instlen + 2; OBD_ALLOC(dt, dt_len); if (!dt) - GOTO(out_proc, err = -ENOMEM); + GOTO(out_profile, err = -ENOMEM); snprintf(dt, dt_len - 1, "%s-%p", lprof->lp_dt, cfg->cfg_instance); md_len = strlen(lprof->lp_md) + instlen + 2; OBD_ALLOC(md, md_len); if (!md) - GOTO(out_proc, err = -ENOMEM); + GOTO(out_free_dt, err = -ENOMEM); snprintf(md, md_len - 1, "%s-%p", lprof->lp_md, cfg->cfg_instance); /* connections, registrations, sb setup */ err = client_common_fill_super(sb, md, dt, mnt); if (err < 0) - GOTO(out_proc, err); + GOTO(out_free_md, err); sbi->ll_client_common_fill_super_succeeded = 1; -out_proc: - if (err < 0) - ll_debugfs_unregister_super(sb); -out_free: +out_free_md: if (md) OBD_FREE(md, md_len); +out_free_dt: if (dt) OBD_FREE(dt, dt_len); - if (lprof != NULL) +out_profile: + if (lprof) class_put_profile(lprof); +out_debugfs: + if (err < 0) + ll_debugfs_unregister_super(sb); +out_free_cfg: if (cfg) OBD_FREE_PTR(cfg); + if (err) ll_put_super(sb); else if (sbi->ll_flags & LL_SBI_VERBOSE) diff --git a/lustre/llite/lproc_llite.c b/lustre/llite/lproc_llite.c index 30c7cea..24b4010 100644 --- a/lustre/llite/lproc_llite.c +++ b/lustre/llite/lproc_llite.c @@ -43,26 +43,22 @@ #include "llite_internal.h" #include "vvp_internal.h" -struct proc_dir_entry *proc_lustre_fs_root; static struct kobject *llite_kobj; +static struct dentry *llite_root; int llite_tunables_register(void) { int rc = 0; - proc_lustre_fs_root = lprocfs_register("llite", proc_lustre_root, - NULL, NULL); - if (IS_ERR(proc_lustre_fs_root)) { - rc = PTR_ERR(proc_lustre_fs_root); - CERROR("cannot register '/proc/fs/lustre/llite': rc = %d\n", - rc); - proc_lustre_fs_root = NULL; - return rc; - } - llite_kobj = class_setup_tunables("llite"); - if (IS_ERR(llite_kobj)) { - rc = PTR_ERR(llite_kobj); + if (IS_ERR(llite_kobj)) + return PTR_ERR(llite_kobj); + + llite_root = debugfs_create_dir("llite", debugfs_lustre_root); + if (IS_ERR_OR_NULL(llite_root)) { + rc = llite_root ? PTR_ERR(llite_root) : -ENOMEM; + llite_root = NULL; + kobject_put(llite_kobj); llite_kobj = NULL; } @@ -71,18 +67,56 @@ int llite_tunables_register(void) void llite_tunables_unregister(void) { - if (llite_kobj) + if (llite_kobj) { kobject_put(llite_kobj); + llite_kobj = NULL; + } - lprocfs_remove(&proc_lustre_fs_root); + if (!IS_ERR_OR_NULL(llite_root)) { + debugfs_remove(llite_root); + llite_root = NULL; + } } -#ifdef CONFIG_PROC_FS -/* /proc/lustre/llite mount point registration */ +/* /lustre/llite mount point registration */ static const struct file_operations ll_rw_extents_stats_fops; static const struct file_operations ll_rw_extents_stats_pp_fops; static const struct file_operations ll_rw_offset_stats_fops; -static __s64 ll_stats_pid_write(const char __user *buf, size_t len); + +/** + * ll_stats_pid_write() - Determine if stats collection should be enabled + * @buf: Buffer containing the data written + * @len: Number of bytes in the buffer + * + * Several proc files begin collecting stats when a value is written, and stop + * collecting when either '0' or 'disable' is written. This function checks the + * written value to see if collection should be enabled or disabled. + * + * Return: If '0' or 'disable' is provided, 0 is returned. If the text + * equivalent of a number is written, that number is returned. Otherwise, + * 1 is returned. Non-zero return values indicate collection should be enabled. + */ +static s64 ll_stats_pid_write(const char __user *buf, size_t len) +{ + unsigned long long value = 1; + char kernbuf[16]; + int rc; + + rc = kstrtoull_from_user(buf, len, 0, &value); + if (rc < 0 && len < sizeof(kernbuf)) { + if (copy_from_user(kernbuf, buf, len)) + return -EFAULT; + kernbuf[len] = 0; + + if (kernbuf[len - 1] == '\n') + kernbuf[len - 1] = 0; + + if (strncasecmp(kernbuf, "disable", 7) == 0) + value = 0; + } + + return value; +} static ssize_t blocksize_show(struct kobject *kobj, struct attribute *attr, char *buf) @@ -270,7 +304,8 @@ static int ll_site_stats_seq_show(struct seq_file *m, void *v) */ return cl_site_stats_print(lu2cl_site(ll_s2sbi(sb)->ll_site), m); } -LPROC_SEQ_FOPS_RO(ll_site_stats); + +LDEBUGFS_SEQ_FOPS_RO(ll_site_stats); static int ll_max_readahead_mb_seq_show(struct seq_file *m, void *v) { @@ -315,9 +350,11 @@ ll_max_readahead_mb_seq_write(struct file *file, const char __user *buffer, spin_lock(&sbi->ll_lock); sbi->ll_ra_info.ra_max_pages = pages_number; spin_unlock(&sbi->ll_lock); + return count; } -LPROC_SEQ_FOPS(ll_max_readahead_mb); + +LDEBUGFS_SEQ_FOPS(ll_max_readahead_mb); static int ll_max_readahead_per_file_mb_seq_show(struct seq_file *m, void *v) { @@ -362,9 +399,11 @@ ll_max_readahead_per_file_mb_seq_write(struct file *file, spin_lock(&sbi->ll_lock); sbi->ll_ra_info.ra_max_pages_per_file = pages_number; spin_unlock(&sbi->ll_lock); + return count; } -LPROC_SEQ_FOPS(ll_max_readahead_per_file_mb); + +LDEBUGFS_SEQ_FOPS(ll_max_readahead_per_file_mb); static int ll_max_read_ahead_whole_mb_seq_show(struct seq_file *m, void *v) { @@ -414,9 +453,11 @@ ll_max_read_ahead_whole_mb_seq_write(struct file *file, spin_lock(&sbi->ll_lock); sbi->ll_ra_info.ra_max_read_ahead_whole_pages = pages_number; spin_unlock(&sbi->ll_lock); + return count; } -LPROC_SEQ_FOPS(ll_max_read_ahead_whole_mb); + +LDEBUGFS_SEQ_FOPS(ll_max_read_ahead_whole_mb); static int ll_max_cached_mb_seq_show(struct seq_file *m, void *v) { @@ -430,10 +471,10 @@ static int ll_max_cached_mb_seq_show(struct seq_file *m, void *v) max_cached_mb = cache->ccc_lru_max >> shift; unused_mb = atomic_long_read(&cache->ccc_lru_left) >> shift; seq_printf(m, "users: %d\n" - "max_cached_mb: %ld\n" - "used_mb: %ld\n" - "unused_mb: %ld\n" - "reclaim_count: %u\n", + "max_cached_mb: %ld\n" + "used_mb: %ld\n" + "unused_mb: %ld\n" + "reclaim_count: %u\n", atomic_read(&cache->ccc_users), max_cached_mb, max_cached_mb - unused_mb, @@ -442,9 +483,9 @@ static int ll_max_cached_mb_seq_show(struct seq_file *m, void *v) return 0; } -static ssize_t -ll_max_cached_mb_seq_write(struct file *file, const char __user *buffer, - size_t count, loff_t *off) +static ssize_t ll_max_cached_mb_seq_write(struct file *file, + const char __user *buffer, + size_t count, loff_t *off) { struct seq_file *m = file->private_data; struct super_block *sb = m->private; @@ -455,10 +496,10 @@ ll_max_cached_mb_seq_write(struct file *file, const char __user *buffer, long nrpages = 0; __u16 refcheck; __s64 pages_number; - long rc; + int rc; char kernbuf[128]; - ENTRY; + ENTRY; if (count >= sizeof(kernbuf)) RETURN(-EINVAL); @@ -495,7 +536,7 @@ ll_max_cached_mb_seq_write(struct file *file, const char __user *buffer, env = cl_env_get(&refcheck); if (IS_ERR(env)) - RETURN(rc); + RETURN(PTR_ERR(env)); diff = -diff; while (diff > 0) { @@ -548,7 +589,8 @@ out: } return rc; } -LPROC_SEQ_FOPS(ll_max_cached_mb); + +LDEBUGFS_SEQ_FOPS(ll_max_cached_mb); static ssize_t checksums_show(struct kobject *kobj, struct attribute *attr, char *buf) @@ -784,14 +826,15 @@ static int ll_statahead_stats_seq_show(struct seq_file *m, void *v) struct ll_sb_info *sbi = ll_s2sbi(sb); seq_printf(m, "statahead total: %u\n" - "statahead wrong: %u\n" - "agl total: %u\n", - atomic_read(&sbi->ll_sa_total), - atomic_read(&sbi->ll_sa_wrong), - atomic_read(&sbi->ll_agl_total)); + "statahead wrong: %u\n" + "agl total: %u\n", + atomic_read(&sbi->ll_sa_total), + atomic_read(&sbi->ll_sa_wrong), + atomic_read(&sbi->ll_agl_total)); return 0; } -LPROC_SEQ_FOPS_RO(ll_statahead_stats); + +LDEBUGFS_SEQ_FOPS_RO(ll_statahead_stats); static ssize_t lazystatfs_show(struct kobject *kobj, struct attribute *attr, @@ -933,7 +976,8 @@ static int ll_sbi_flags_seq_show(struct seq_file *m, void *v) seq_printf(m, "\b\n"); return 0; } -LPROC_SEQ_FOPS_RO(ll_sbi_flags); + +LDEBUGFS_SEQ_FOPS_RO(ll_sbi_flags); static ssize_t xattr_cache_show(struct kobject *kobj, struct attribute *attr, @@ -1086,8 +1130,8 @@ static int ll_unstable_stats_seq_show(struct seq_file *m, void *v) mb = (pages * PAGE_SIZE) >> 20; seq_printf(m, "unstable_check: %8d\n" - "unstable_pages: %12ld\n" - "unstable_mb: %8d\n", + "unstable_pages: %12ld\n" + "unstable_mb: %8d\n", cache->ccc_unstable_check, pages, mb); return 0; } @@ -1124,7 +1168,8 @@ static ssize_t ll_unstable_stats_seq_write(struct file *file, return count; } -LPROC_SEQ_FOPS(ll_unstable_stats); + +LDEBUGFS_SEQ_FOPS(ll_unstable_stats); static int ll_root_squash_seq_show(struct seq_file *m, void *v) { @@ -1148,7 +1193,8 @@ static ssize_t ll_root_squash_seq_write(struct file *file, return lprocfs_wr_root_squash(buffer, count, squash, ll_get_fsname(sb, NULL, 0)); } -LPROC_SEQ_FOPS(ll_root_squash); + +LDEBUGFS_SEQ_FOPS(ll_root_squash); static int ll_nosquash_nids_seq_show(struct seq_file *m, void *v) { @@ -1190,25 +1236,26 @@ static ssize_t ll_nosquash_nids_seq_write(struct file *file, return rc; } -LPROC_SEQ_FOPS(ll_nosquash_nids); + +LDEBUGFS_SEQ_FOPS(ll_nosquash_nids); struct lprocfs_vars lprocfs_llite_obd_vars[] = { { .name = "site", .fops = &ll_site_stats_fops }, - { .name = "max_read_ahead_mb", - .fops = &ll_max_readahead_mb_fops }, - { .name = "max_read_ahead_per_file_mb", - .fops = &ll_max_readahead_per_file_mb_fops }, - { .name = "max_read_ahead_whole_mb", - .fops = &ll_max_read_ahead_whole_mb_fops }, + { .name = "max_read_ahead_mb", + .fops = &ll_max_readahead_mb_fops }, + { .name = "max_read_ahead_per_file_mb", + .fops = &ll_max_readahead_per_file_mb_fops }, + { .name = "max_read_ahead_whole_mb", + .fops = &ll_max_read_ahead_whole_mb_fops }, { .name = "max_cached_mb", .fops = &ll_max_cached_mb_fops }, { .name = "statahead_stats", .fops = &ll_statahead_stats_fops }, - { .name = "sbi_flags", - .fops = &ll_sbi_flags_fops }, { .name = "unstable_stats", .fops = &ll_unstable_stats_fops }, + { .name = "sbi_flags", + .fops = &ll_sbi_flags_fops }, { .name = "root_squash", .fops = &ll_root_squash_fops }, { .name = "nosquash_nids", @@ -1349,40 +1396,41 @@ int ll_debugfs_register_super(struct super_block *sb, const char *name) { struct lustre_sb_info *lsi = s2lsi(sb); struct ll_sb_info *sbi = ll_s2sbi(sb); - struct lprocfs_vars lvars[2]; int err, id, rc; ENTRY; - memset(lvars, 0, sizeof(lvars)); - lvars[0].name = name; + LASSERT(sbi); - LASSERT(sbi != NULL); + if (IS_ERR_OR_NULL(llite_root)) + goto out_ll_kset; - sbi->ll_proc_root = lprocfs_register(name, proc_lustre_fs_root, - NULL, NULL); - if (IS_ERR(sbi->ll_proc_root)) { - err = PTR_ERR(sbi->ll_proc_root); - sbi->ll_proc_root = NULL; + sbi->ll_debugfs_entry = ldebugfs_register(name, llite_root, + lprocfs_llite_obd_vars, sb); + if (IS_ERR_OR_NULL(sbi->ll_debugfs_entry)) { + err = sbi->ll_debugfs_entry ? PTR_ERR(sbi->ll_debugfs_entry) : + -ENOMEM; + sbi->ll_debugfs_entry = NULL; RETURN(err); } - rc = lprocfs_seq_create(sbi->ll_proc_root, "dump_page_cache", 0444, - &vvp_dump_pgcache_file_ops, sbi); + rc = ldebugfs_seq_create(sbi->ll_debugfs_entry, "dump_page_cache",0444, + &vvp_dump_pgcache_file_ops, sbi); if (rc) CWARN("Error adding the dump_page_cache file\n"); - rc = lprocfs_seq_create(sbi->ll_proc_root, "extents_stats", 0644, - &ll_rw_extents_stats_fops, sbi); + rc = ldebugfs_seq_create(sbi->ll_debugfs_entry, "extents_stats", 0644, + &ll_rw_extents_stats_fops, sbi); if (rc) CWARN("Error adding the extent_stats file\n"); - rc = lprocfs_seq_create(sbi->ll_proc_root, "extents_stats_per_process", - 0644, &ll_rw_extents_stats_pp_fops, sbi); + rc = ldebugfs_seq_create(sbi->ll_debugfs_entry, + "extents_stats_per_process", 0644, + &ll_rw_extents_stats_pp_fops, sbi); if (rc) CWARN("Error adding the extents_stats_per_process file\n"); - rc = lprocfs_seq_create(sbi->ll_proc_root, "offset_stats", 0644, - &ll_rw_offset_stats_fops, sbi); + rc = ldebugfs_seq_create(sbi->ll_debugfs_entry, "offset_stats", 0644, + &ll_rw_offset_stats_fops, sbi); if (rc) CWARN("Error adding the offset_stats file\n"); @@ -1390,12 +1438,13 @@ int ll_debugfs_register_super(struct super_block *sb, const char *name) sbi->ll_stats = lprocfs_alloc_stats(LPROC_LL_FILE_OPCODES, LPROCFS_STATS_FLAG_NONE); if (sbi->ll_stats == NULL) - GOTO(out_proc, err = -ENOMEM); + GOTO(out_debugfs, err = -ENOMEM); /* do counter init */ for (id = 0; id < LPROC_LL_FILE_OPCODES; id++) { - __u32 type = llite_opcode_table[id].type; + u32 type = llite_opcode_table[id].type; void *ptr = NULL; + if (type & LPROCFS_TYPE_REGS) ptr = "regs"; else if (type & LPROCFS_TYPE_BYTES) @@ -1408,7 +1457,8 @@ int ll_debugfs_register_super(struct super_block *sb, const char *name) llite_opcode_table[id].opname, ptr); } - err = lprocfs_register_stats(sbi->ll_proc_root, "stats", sbi->ll_stats); + err = ldebugfs_register_stats(sbi->ll_debugfs_entry, "stats", + sbi->ll_stats); if (err) GOTO(out_stats, err); @@ -1420,15 +1470,13 @@ int ll_debugfs_register_super(struct super_block *sb, const char *name) for (id = 0; id < ARRAY_SIZE(ra_stat_string); id++) lprocfs_counter_init(sbi->ll_ra_stats, id, 0, ra_stat_string[id], "pages"); - err = lprocfs_register_stats(sbi->ll_proc_root, "read_ahead_stats", - sbi->ll_ra_stats); - if (err) - GOTO(out_ra_stats, err); - err = lprocfs_add_vars(sbi->ll_proc_root, lprocfs_llite_obd_vars, sb); + err = ldebugfs_register_stats(sbi->ll_debugfs_entry, "read_ahead_stats", + sbi->ll_ra_stats); if (err) GOTO(out_ra_stats, err); +out_ll_kset: /* Yes we also register sysfs mount kset here as well */ sbi->ll_kset.kobj.parent = llite_kobj; sbi->ll_kset.kobj.ktype = &llite_ktype; @@ -1448,8 +1496,8 @@ out_ra_stats: lprocfs_free_stats(&sbi->ll_ra_stats); out_stats: lprocfs_free_stats(&sbi->ll_stats); -out_proc: - lprocfs_remove(&sbi->ll_proc_root); +out_debugfs: + ldebugfs_remove(&sbi->ll_debugfs_entry); RETURN(err); } @@ -1459,6 +1507,9 @@ void ll_debugfs_unregister_super(struct super_block *sb) struct lustre_sb_info *lsi = s2lsi(sb); struct ll_sb_info *sbi = ll_s2sbi(sb); + if (!IS_ERR_OR_NULL(sbi->ll_debugfs_entry)) + ldebugfs_remove(&sbi->ll_debugfs_entry); + if (sbi->ll_dt_obd) sysfs_remove_link(&sbi->ll_kset.kobj, sbi->ll_dt_obd->obd_type->typ_name); @@ -1472,11 +1523,8 @@ void ll_debugfs_unregister_super(struct super_block *sb) kset_unregister(&sbi->ll_kset); wait_for_completion(&sbi->ll_kobj_unregister); - if (sbi->ll_proc_root) { - lprocfs_remove(&sbi->ll_proc_root); - lprocfs_free_stats(&sbi->ll_ra_stats); - lprocfs_free_stats(&sbi->ll_stats); - } + lprocfs_free_stats(&sbi->ll_ra_stats); + lprocfs_free_stats(&sbi->ll_stats); } #undef MAX_STRING_SIZE @@ -1505,14 +1553,14 @@ static void ll_display_extents_info(struct ll_rw_extents_info *io_extents, w = pp_info->pp_w_hist.oh_buckets[i]; read_cum += r; write_cum += w; - end = 1 << (i + LL_HIST_START - units); + end = BIT(i + LL_HIST_START - units); seq_printf(seq, "%4lu%c - %4lu%c%c: %14lu %4lu %4lu | " "%14lu %4lu %4lu\n", start, *unitp, end, *unitp, (i == LL_HIST_MAX - 1) ? '+' : ' ', r, pct(r, read_tot), pct(read_cum, read_tot), w, pct(w, write_tot), pct(write_cum, write_tot)); start = end; - if (start == 1<<10) { + if (start == BIT(10)) { start = 1; units += 10; unitp++; @@ -1584,7 +1632,7 @@ static ssize_t ll_rw_extents_stats_pp_seq_write(struct file *file, return len; } -LPROC_SEQ_FOPS(ll_rw_extents_stats_pp); +LDEBUGFS_SEQ_FOPS(ll_rw_extents_stats_pp); static int ll_rw_extents_stats_seq_show(struct seq_file *seq, void *v) { @@ -1642,7 +1690,8 @@ static ssize_t ll_rw_extents_stats_seq_write(struct file *file, return len; } -LPROC_SEQ_FOPS(ll_rw_extents_stats); + +LDEBUGFS_SEQ_FOPS(ll_rw_extents_stats); void ll_rw_stats_tally(struct ll_sb_info *sbi, pid_t pid, struct ll_file_data *file, loff_t pos, @@ -1679,7 +1728,7 @@ void ll_rw_stats_tally(struct ll_sb_info *sbi, pid_t pid, lprocfs_oh_clear(&io_extents->pp_extents[cur].pp_w_hist); } - for(i = 0; (count >= (1 << LL_HIST_START << i)) && + for(i = 0; (count >= BIT(LL_HIST_START << i)) && (i < (LL_HIST_MAX - 1)); i++); if (rw == 0) { io_extents->pp_extents[cur].pp_r_hist.oh_buckets[i]++; @@ -1833,41 +1882,4 @@ static ssize_t ll_rw_offset_stats_seq_write(struct file *file, return len; } -/** - * ll_stats_pid_write() - Determine if stats collection should be enabled - * @buf: Buffer containing the data written - * @len: Number of bytes in the buffer - * - * Several proc files begin collecting stats when a value is written, and stop - * collecting when either '0' or 'disable' is written. This function checks the - * written value to see if collection should be enabled or disabled. - * - * Return: If '0' or 'disable' is provided, 0 is returned. If the text - * equivalent of a number is written, that number is returned. Otherwise, - * 1 is returned. Non-zero return values indicate collection should be enabled. - */ -static __s64 ll_stats_pid_write(const char __user *buf, size_t len) -{ - unsigned long long value = 1; - int rc; - char kernbuf[16]; - - rc = kstrtoull_from_user(buf, len, 0, &value); - if (rc < 0 && len < sizeof(kernbuf)) { - - if (copy_from_user(kernbuf, buf, len)) - return -EFAULT; - kernbuf[len] = 0; - - if (kernbuf[len - 1] == '\n') - kernbuf[len - 1] = 0; - - if (strncasecmp(kernbuf, "disable", 7) == 0) - value = 0; - } - - return value; -} - -LPROC_SEQ_FOPS(ll_rw_offset_stats); -#endif /* CONFIG_PROC_FS */ +LDEBUGFS_SEQ_FOPS(ll_rw_offset_stats); diff --git a/lustre/llite/vvp_dev.c b/lustre/llite/vvp_dev.c index 0ebe920..3802bc7 100644 --- a/lustre/llite/vvp_dev.c +++ b/lustre/llite/vvp_dev.c @@ -355,7 +355,7 @@ int cl_sb_fini(struct super_block *sb) /**************************************************************************** * - * /proc/fs/lustre/llite/$MNT/dump_page_cache + * debugfs/lustre/llite/$MNT/dump_page_cache * ****************************************************************************/ @@ -426,7 +426,7 @@ static struct page *vvp_pgcache_current(struct vvp_seq_private *priv) { struct lu_device *dev = &priv->vsp_sbi->ll_cl->cd_lu_dev; - while(1) { + while (1) { struct inode *inode; struct page *vmpage; int nr; @@ -583,7 +583,7 @@ static int vvp_dump_pgcache_seq_open(struct inode *inode, struct file *filp) if (!priv) return -ENOMEM; - priv->vsp_sbi = PDE_DATA(inode); + priv->vsp_sbi = inode->i_private; priv->vsp_env = cl_env_get(&priv->vsp_refcheck); priv->vsp_clob = NULL; memset(&priv->vvp_id, 0, sizeof(priv->vvp_id)); diff --git a/lustre/obdclass/lprocfs_status.c b/lustre/obdclass/lprocfs_status.c index 028b47b..2a93688 100644 --- a/lustre/obdclass/lprocfs_status.c +++ b/lustre/obdclass/lprocfs_status.c @@ -389,16 +389,6 @@ static ssize_t uuid_show(struct kobject *kobj, struct attribute *attr, } LUSTRE_RO_ATTR(uuid); -int lprocfs_name_seq_show(struct seq_file *m, void *data) -{ - struct obd_device *dev = data; - - LASSERT(dev != NULL); - seq_printf(m, "%s\n", dev->obd_name); - return 0; -} -EXPORT_SYMBOL(lprocfs_name_seq_show); - static ssize_t blocksize_show(struct kobject *kobj, struct attribute *attr, char *buf) { -- 1.8.3.1