#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;
+
+static void llite_kobj_release(struct kobject *kobj)
+{
+ if (!IS_ERR_OR_NULL(llite_root)) {
+ debugfs_remove(llite_root);
+ llite_root = NULL;
+ }
+
+ kfree(kobj);
+}
+
+static struct kobj_type llite_kobj_ktype = {
+ .release = llite_kobj_release,
+ .sysfs_ops = &lustre_sysfs_ops,
+};
int llite_tunables_register(void)
{
- int rc = 0;
+ int rc;
- 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 = kzalloc(sizeof(*llite_kobj), GFP_KERNEL);
+ if (!llite_kobj)
+ return -ENOMEM;
- llite_kobj = class_setup_tunables("llite");
- if (IS_ERR(llite_kobj)) {
- rc = PTR_ERR(llite_kobj);
+ llite_kobj->kset = lustre_kset;
+ rc = kobject_init_and_add(llite_kobj, &llite_kobj_ktype,
+ &lustre_kset->kobj, "%s", "llite");
+ if (rc)
+ goto free_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;
+free_kobj:
+ kobject_put(llite_kobj);
llite_kobj = NULL;
}
void llite_tunables_unregister(void)
{
- if (llite_kobj)
- kobject_put(llite_kobj);
-
- lprocfs_remove(&proc_lustre_fs_root);
+ kobject_put(llite_kobj);
+ llite_kobj = NULL;
}
-#ifdef CONFIG_PROC_FS
-/* /proc/lustre/llite mount point registration */
+/* <debugfs>/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)
}
LUSTRE_RO_ATTR(blocksize);
-static int ll_stat_blksize_seq_show(struct seq_file *m, void *v)
+static ssize_t stat_blocksize_show(struct kobject *kobj, struct attribute *attr,
+ char *buf)
{
- struct ll_sb_info *sbi = ll_s2sbi((struct super_block *)m->private);
-
- seq_printf(m, "%u\n", sbi->ll_stat_blksize);
+ struct ll_sb_info *sbi = container_of(kobj, struct ll_sb_info,
+ ll_kset.kobj);
- return 0;
+ return sprintf(buf, "%u\n", sbi->ll_stat_blksize);
}
-static ssize_t ll_stat_blksize_seq_write(struct file *file,
- const char __user *buffer,
- size_t count, loff_t *off)
+static ssize_t stat_blocksize_store(struct kobject *kobj,
+ struct attribute *attr,
+ const char *buffer,
+ size_t count)
{
- struct seq_file *m = file->private_data;
- struct ll_sb_info *sbi = ll_s2sbi((struct super_block *)m->private);
+ struct ll_sb_info *sbi = container_of(kobj, struct ll_sb_info,
+ ll_kset.kobj);
unsigned int val;
int rc;
- rc = kstrtouint_from_user(buffer, count, 0, &val);
+ rc = kstrtouint(buffer, 10, &val);
if (rc)
return rc;
return count;
}
-LPROC_SEQ_FOPS(ll_stat_blksize);
+LUSTRE_RW_ATTR(stat_blocksize);
static ssize_t kbytestotal_show(struct kobject *kobj, struct attribute *attr,
char *buf)
*/
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)
{
if (pages_number < 0 || pages_number > totalram_pages / 2) {
/* 1/2 of RAM */
CERROR("%s: can't set max_readahead_mb=%lu > %luMB\n",
- ll_get_fsname(sb, NULL, 0),
+ sbi->ll_fsname,
(unsigned long)pages_number >> (20 - PAGE_SHIFT),
totalram_pages >> (20 - PAGE_SHIFT + 1));
return -ERANGE;
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)
{
if (pages_number < 0 || pages_number > sbi->ll_ra_info.ra_max_pages) {
CERROR("%s: can't set max_readahead_per_file_mb=%lu > "
- "max_read_ahead_mb=%lu\n", ll_get_fsname(sb, NULL, 0),
+ "max_read_ahead_mb=%lu\n", sbi->ll_fsname,
(unsigned long)pages_number >> (20 - PAGE_SHIFT),
sbi->ll_ra_info.ra_max_pages >> (20 - PAGE_SHIFT));
return -ERANGE;
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)
{
int pages_shift = 20 - PAGE_SHIFT;
CERROR("%s: can't set max_read_ahead_whole_mb=%lu > "
"max_read_ahead_per_file_mb=%lu\n",
- ll_get_fsname(sb, NULL, 0),
+ sbi->ll_fsname,
(unsigned long)pages_number >> pages_shift,
sbi->ll_ra_info.ra_max_pages_per_file >> pages_shift);
return -ERANGE;
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)
{
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,
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;
long nrpages = 0;
__u16 refcheck;
__s64 pages_number;
- long rc;
+ int rc;
char kernbuf[128];
- ENTRY;
+ ENTRY;
if (count >= sizeof(kernbuf))
RETURN(-EINVAL);
if (pages_number < 0 || pages_number > totalram_pages) {
CERROR("%s: can't set max cache more than %lu MB\n",
- ll_get_fsname(sb, NULL, 0),
+ sbi->ll_fsname,
totalram_pages >> (20 - PAGE_SHIFT));
RETURN(-ERANGE);
}
env = cl_env_get(&refcheck);
if (IS_ERR(env))
- RETURN(rc);
+ RETURN(PTR_ERR(env));
diff = -diff;
while (diff > 0) {
}
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)
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,
while (flags != 0) {
if (ARRAY_SIZE(str) <= i) {
CERROR("%s: Revise array LL_SBI_FLAGS to match sbi "
- "flags please.\n", ll_get_fsname(sb, NULL, 0));
+ "flags please.\n", ll_s2sbi(sb)->ll_fsname);
return -EINVAL;
}
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,
}
LUSTRE_RW_ATTR(xattr_cache);
-static int ll_tiny_write_seq_show(struct seq_file *m, void *v)
+static ssize_t tiny_write_show(struct kobject *kobj,
+ struct attribute *attr,
+ char *buf)
{
- struct super_block *sb = m->private;
- struct ll_sb_info *sbi = ll_s2sbi(sb);
+ struct ll_sb_info *sbi = container_of(kobj, struct ll_sb_info,
+ ll_kset.kobj);
- seq_printf(m, "%u\n", !!(sbi->ll_flags & LL_SBI_TINY_WRITE));
- return 0;
+ return sprintf(buf, "%u\n", !!(sbi->ll_flags & LL_SBI_TINY_WRITE));
}
-static ssize_t ll_tiny_write_seq_write(
- struct file *file, const char __user *buffer, size_t count, loff_t *off)
+static ssize_t tiny_write_store(struct kobject *kobj,
+ struct attribute *attr,
+ const char *buffer,
+ size_t count)
{
- struct seq_file *m = file->private_data;
- struct super_block *sb = m->private;
- struct ll_sb_info *sbi = ll_s2sbi(sb);
+ struct ll_sb_info *sbi = container_of(kobj, struct ll_sb_info,
+ ll_kset.kobj);
bool val;
int rc;
- rc = kstrtobool_from_user(buffer, count, &val);
+ rc = kstrtobool(buffer, &val);
if (rc)
return rc;
return count;
}
-LPROC_SEQ_FOPS(ll_tiny_write);
+LUSTRE_RW_ATTR(tiny_write);
-static int ll_fast_read_seq_show(struct seq_file *m, void *v)
+static ssize_t fast_read_show(struct kobject *kobj,
+ struct attribute *attr,
+ char *buf)
{
- struct super_block *sb = m->private;
- struct ll_sb_info *sbi = ll_s2sbi(sb);
+ struct ll_sb_info *sbi = container_of(kobj, struct ll_sb_info,
+ ll_kset.kobj);
- seq_printf(m, "%u\n", !!(sbi->ll_flags & LL_SBI_FAST_READ));
- return 0;
+ return sprintf(buf, "%u\n", !!(sbi->ll_flags & LL_SBI_FAST_READ));
}
-static ssize_t
-ll_fast_read_seq_write(struct file *file, const char __user *buffer,
- size_t count, loff_t *off)
+static ssize_t fast_read_store(struct kobject *kobj,
+ struct attribute *attr,
+ const char *buffer,
+ size_t count)
{
- struct seq_file *m = file->private_data;
- struct super_block *sb = m->private;
- struct ll_sb_info *sbi = ll_s2sbi(sb);
+ struct ll_sb_info *sbi = container_of(kobj, struct ll_sb_info,
+ ll_kset.kobj);
bool val;
int rc;
- rc = kstrtobool_from_user(buffer, count, &val);
+ rc = kstrtobool(buffer, &val);
if (rc)
return rc;
return count;
}
-LPROC_SEQ_FOPS(ll_fast_read);
+LUSTRE_RW_ATTR(fast_read);
-static int ll_pio_seq_show(struct seq_file *m, void *v)
+static ssize_t file_heat_show(struct kobject *kobj,
+ struct attribute *attr,
+ char *buf)
{
- struct super_block *sb = m->private;
- struct ll_sb_info *sbi = ll_s2sbi(sb);
+ struct ll_sb_info *sbi = container_of(kobj, struct ll_sb_info,
+ ll_kset.kobj);
- seq_printf(m, "%u\n", !!(sbi->ll_flags & LL_SBI_PIO));
- return 0;
+ return snprintf(buf, PAGE_SIZE, "%u\n",
+ !!(sbi->ll_flags & LL_SBI_FILE_HEAT));
}
-static ssize_t ll_pio_seq_write(struct file *file, const char __user *buffer,
- size_t count, loff_t *off)
+static ssize_t file_heat_store(struct kobject *kobj,
+ struct attribute *attr,
+ const char *buffer,
+ size_t count)
{
- struct seq_file *m = file->private_data;
- struct super_block *sb = m->private;
- struct ll_sb_info *sbi = ll_s2sbi(sb);
+ struct ll_sb_info *sbi = container_of(kobj, struct ll_sb_info,
+ ll_kset.kobj);
bool val;
int rc;
- rc = kstrtobool_from_user(buffer, count, &val);
+ rc = kstrtobool(buffer, &val);
if (rc)
return rc;
spin_lock(&sbi->ll_lock);
if (val)
- sbi->ll_flags |= LL_SBI_PIO;
+ sbi->ll_flags |= LL_SBI_FILE_HEAT;
else
- sbi->ll_flags &= ~LL_SBI_PIO;
+ sbi->ll_flags &= ~LL_SBI_FILE_HEAT;
spin_unlock(&sbi->ll_lock);
return count;
}
-LPROC_SEQ_FOPS(ll_pio);
+LUSTRE_RW_ATTR(file_heat);
+
+static ssize_t heat_decay_percentage_show(struct kobject *kobj,
+ struct attribute *attr,
+ char *buf)
+{
+ struct ll_sb_info *sbi = container_of(kobj, struct ll_sb_info,
+ ll_kset.kobj);
+
+ return snprintf(buf, PAGE_SIZE, "%u\n",
+ (sbi->ll_heat_decay_weight * 100 + 128) / 256);
+}
+
+static ssize_t heat_decay_percentage_store(struct kobject *kobj,
+ struct attribute *attr,
+ const char *buffer,
+ size_t count)
+{
+ struct ll_sb_info *sbi = container_of(kobj, struct ll_sb_info,
+ ll_kset.kobj);
+ unsigned long val;
+ int rc;
+
+ rc = kstrtoul(buffer, 10, &val);
+ if (rc)
+ return rc;
+
+ if (val < 0 || val > 100)
+ return -ERANGE;
+
+ sbi->ll_heat_decay_weight = (val * 256 + 50) / 100;
+
+ return count;
+}
+LUSTRE_RW_ATTR(heat_decay_percentage);
+
+static ssize_t heat_period_second_show(struct kobject *kobj,
+ struct attribute *attr,
+ char *buf)
+{
+ struct ll_sb_info *sbi = container_of(kobj, struct ll_sb_info,
+ ll_kset.kobj);
+
+ return snprintf(buf, PAGE_SIZE, "%u\n", sbi->ll_heat_period_second);
+}
+
+static ssize_t heat_period_second_store(struct kobject *kobj,
+ struct attribute *attr,
+ const char *buffer,
+ size_t count)
+{
+ struct ll_sb_info *sbi = container_of(kobj, struct ll_sb_info,
+ ll_kset.kobj);
+ unsigned long val;
+ int rc;
+
+ rc = kstrtoul(buffer, 10, &val);
+ if (rc)
+ return rc;
+
+ if (val <= 0)
+ return -ERANGE;
+
+ sbi->ll_heat_period_second = val;
+
+ return count;
+}
+LUSTRE_RW_ATTR(heat_period_second);
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;
}
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)
{
struct ll_sb_info *sbi = ll_s2sbi(sb);
struct root_squash_info *squash = &sbi->ll_squash;
- return lprocfs_wr_root_squash(buffer, count, squash,
- ll_get_fsname(sb, NULL, 0));
+ return lprocfs_wr_root_squash(buffer, count, squash, sbi->ll_fsname);
}
-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)
{
struct root_squash_info *squash = &sbi->ll_squash;
int rc;
- rc = lprocfs_wr_nosquash_nids(buffer, count, squash,
- ll_get_fsname(sb, NULL, 0));
+ rc = lprocfs_wr_nosquash_nids(buffer, count, squash, sbi->ll_fsname);
if (rc < 0)
return rc;
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 = "stat_blocksize",
- .fops = &ll_stat_blksize_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",
.fops = &ll_nosquash_nids_fops },
- { .name = "fast_read",
- .fops = &ll_fast_read_fops, },
- { .name = "pio",
- .fops = &ll_pio_fops, },
- { .name = "tiny_write",
- .fops = &ll_tiny_write_fops, },
{ NULL }
};
static struct attribute *llite_attrs[] = {
&lustre_attr_blocksize.attr,
+ &lustre_attr_stat_blocksize.attr,
&lustre_attr_kbytestotal.attr,
&lustre_attr_kbytesfree.attr,
&lustre_attr_kbytesavail.attr,
&lustre_attr_max_easize.attr,
&lustre_attr_default_easize.attr,
&lustre_attr_xattr_cache.attr,
+ &lustre_attr_fast_read.attr,
+ &lustre_attr_tiny_write.attr,
+ &lustre_attr_file_heat.attr,
+ &lustre_attr_heat_decay_percentage.attr,
+ &lustre_attr_heat_period_second.attr,
NULL,
};
-static void llite_kobj_release(struct kobject *kobj)
+static void sbi_kobj_release(struct kobject *kobj)
{
struct ll_sb_info *sbi = container_of(kobj, struct ll_sb_info,
ll_kset.kobj);
complete(&sbi->ll_kobj_unregister);
}
-static struct kobj_type llite_ktype = {
+static struct kobj_type sbi_ktype = {
.default_attrs = llite_attrs,
.sysfs_ops = &lustre_sysfs_ops,
- .release = llite_kobj_release,
+ .release = sbi_kobj_release,
};
static const struct llite_file_opcode {
[RA_STAT_FAILED_REACH_END] = "failed to reach end"
};
-LPROC_SEQ_FOPS_RO_TYPE(llite, name);
-LPROC_SEQ_FOPS_RO_TYPE(llite, uuid);
-
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");
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)
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);
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;
+ sbi->ll_kset.kobj.ktype = &sbi_ktype;
init_completion(&sbi->ll_kobj_unregister);
err = kobject_set_name(&sbi->ll_kset.kobj, "%s", name);
if (err)
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);
}
-int lprocfs_ll_register_obd(struct super_block *sb, const char *obdname)
+void ll_debugfs_unregister_super(struct super_block *sb)
{
- struct lprocfs_vars lvars[2];
+ struct lustre_sb_info *lsi = s2lsi(sb);
struct ll_sb_info *sbi = ll_s2sbi(sb);
- struct obd_device *obd;
- struct proc_dir_entry *dir;
- char name[MAX_STRING_SIZE + 1];
- int err;
- ENTRY;
-
- memset(lvars, 0, sizeof(lvars));
-
- name[MAX_STRING_SIZE] = '\0';
- lvars[0].name = name;
-
- LASSERT(sbi != NULL);
- LASSERT(obdname != NULL);
-
- obd = class_name2obd(obdname);
-
- LASSERT(obd != NULL);
- LASSERT(obd->obd_magic == OBD_DEVICE_MAGIC);
- LASSERT(obd->obd_type->typ_name != NULL);
- dir = proc_mkdir(obd->obd_type->typ_name, sbi->ll_proc_root);
- if (dir == NULL)
- GOTO(out, err = -ENOMEM);
+ if (!IS_ERR_OR_NULL(sbi->ll_debugfs_entry))
+ ldebugfs_remove(&sbi->ll_debugfs_entry);
- snprintf(name, MAX_STRING_SIZE, "common_name");
- lvars[0].fops = &llite_name_fops;
- err = lprocfs_add_vars(dir, lvars, obd);
- if (err)
- GOTO(out, err);
-
- snprintf(name, MAX_STRING_SIZE, "uuid");
- lvars[0].fops = &llite_uuid_fops;
- err = lprocfs_add_vars(dir, lvars, obd);
- if (err)
- GOTO(out, err);
-
-out:
- if (err) {
- lprocfs_remove(&sbi->ll_proc_root);
- lprocfs_free_stats(&sbi->ll_ra_stats);
- lprocfs_free_stats(&sbi->ll_stats);
- }
- RETURN(err);
-}
+ if (sbi->ll_dt_obd)
+ sysfs_remove_link(&sbi->ll_kset.kobj,
+ sbi->ll_dt_obd->obd_type->typ_name);
-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 (sbi->ll_md_obd)
+ sysfs_remove_link(&sbi->ll_kset.kobj,
+ sbi->ll_md_obd->obd_type->typ_name);
kobject_put(lsi->lsi_kobj);
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
-#define pct(a,b) (b ? a * 100 / b : 0)
-
static void ll_display_extents_info(struct ll_rw_extents_info *io_extents,
struct seq_file *seq, int which)
{
w = pp_info->pp_w_hist.oh_buckets[i];
read_cum += r;
write_cum += w;
- end = 1 << (i + LL_HIST_START - units);
- seq_printf(seq, "%4lu%c - %4lu%c%c: %14lu %4lu %4lu | "
- "%14lu %4lu %4lu\n", start, *unitp, end, *unitp,
+ end = BIT(i + LL_HIST_START - units);
+ seq_printf(seq, "%4lu%c - %4lu%c%c: %14lu %4u %4u | "
+ "%14lu %4u %4u\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++;
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)
{
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,
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]++;
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);
git://git.whamcloud.com / fs / lustre-release.git / blobdiff