* Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
*
- * Copyright (c) 2012, 2016, Intel Corporation.
+ * Copyright (c) 2012, 2017, Intel Corporation.
*/
/*
* This file is part of Lustre, http://www.lustre.org/
- * Lustre is a trademark of Sun Microsystems, Inc.
*/
#define DEBUG_SUBSYSTEM S_LLITE
#include <linux/version.h>
#include <linux/user_namespace.h>
-#ifdef HAVE_UIDGID_HEADER
-# include <linux/uidgid.h>
-#endif
-#include <lustre_param.h>
+#include <linux/uidgid.h>
+
+#include <uapi/linux/lustre/lustre_param.h>
#include <lprocfs_status.h>
#include <obd_support.h>
#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;
-#ifdef CONFIG_PROC_FS
-/* /proc/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);
+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 int ll_blksize_seq_show(struct seq_file *m, void *v)
+static struct kobj_type llite_kobj_ktype = {
+ .release = llite_kobj_release,
+ .sysfs_ops = &lustre_sysfs_ops,
+};
+
+int llite_tunables_register(void)
{
- struct super_block *sb = m->private;
- struct obd_statfs osfs;
int rc;
- LASSERT(sb != NULL);
- rc = ll_statfs_internal(sb, &osfs,
- cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS),
- OBD_STATFS_NODELAY);
- if (!rc)
- seq_printf(m, "%u\n", osfs.os_bsize);
+ llite_kobj = kzalloc(sizeof(*llite_kobj), GFP_KERNEL);
+ if (!llite_kobj)
+ return -ENOMEM;
+
+ 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);
+ return 0;
+
+free_kobj:
+ kobject_put(llite_kobj);
+ llite_kobj = NULL;
+
return rc;
}
-LPROC_SEQ_FOPS_RO(ll_blksize);
-static int ll_kbytestotal_seq_show(struct seq_file *m, void *v)
+void llite_tunables_unregister(void)
{
- struct super_block *sb = m->private;
- struct obd_statfs osfs;
+ kobject_put(llite_kobj);
+ llite_kobj = NULL;
+}
+
+/* <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;
+
+/**
+ * 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;
- LASSERT(sb != NULL);
- rc = ll_statfs_internal(sb, &osfs,
- cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS),
- OBD_STATFS_NODELAY);
- if (!rc) {
- __u32 blk_size = osfs.os_bsize >> 10;
- __u64 result = osfs.os_blocks;
+ 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;
- while (blk_size >>= 1)
- result <<= 1;
+ if (kernbuf[len - 1] == '\n')
+ kernbuf[len - 1] = 0;
- seq_printf(m, "%llu\n", result);
+ if (strncasecmp(kernbuf, "disable", 7) == 0)
+ value = 0;
}
- return rc;
+
+ return value;
}
-LPROC_SEQ_FOPS_RO(ll_kbytestotal);
-static int ll_kbytesfree_seq_show(struct seq_file *m, void *v)
+static ssize_t blocksize_show(struct kobject *kobj, struct attribute *attr,
+ char *buf)
{
- struct super_block *sb = m->private;
+ struct ll_sb_info *sbi = container_of(kobj, struct ll_sb_info,
+ ll_kset.kobj);
struct obd_statfs osfs;
int rc;
- LASSERT(sb != NULL);
- rc = ll_statfs_internal(sb, &osfs,
- cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS),
- OBD_STATFS_NODELAY);
- if (!rc) {
- __u32 blk_size = osfs.os_bsize >> 10;
- __u64 result = osfs.os_bfree;
+ rc = ll_statfs_internal(sbi, &osfs, OBD_STATFS_NODELAY);
+ if (rc)
+ return rc;
- while (blk_size >>= 1)
- result <<= 1;
+ return sprintf(buf, "%u\n", osfs.os_bsize);
+}
+LUSTRE_RO_ATTR(blocksize);
- seq_printf(m, "%llu\n", result);
- }
- return rc;
+static ssize_t stat_blocksize_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 sprintf(buf, "%u\n", sbi->ll_stat_blksize);
}
-LPROC_SEQ_FOPS_RO(ll_kbytesfree);
-static int ll_kbytesavail_seq_show(struct seq_file *m, void *v)
+static ssize_t stat_blocksize_store(struct kobject *kobj,
+ struct attribute *attr,
+ const char *buffer,
+ size_t count)
{
- struct super_block *sb = m->private;
- struct obd_statfs osfs;
+ struct ll_sb_info *sbi = container_of(kobj, struct ll_sb_info,
+ ll_kset.kobj);
+ unsigned int val;
int rc;
- LASSERT(sb != NULL);
- rc = ll_statfs_internal(sb, &osfs,
- cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS),
- OBD_STATFS_NODELAY);
- if (!rc) {
- __u32 blk_size = osfs.os_bsize >> 10;
- __u64 result = osfs.os_bavail;
+ rc = kstrtouint(buffer, 10, &val);
+ if (rc)
+ return rc;
- while (blk_size >>= 1)
- result <<= 1;
+ if (val != 0 && (val < PAGE_SIZE || (val & (val - 1))) != 0)
+ return -ERANGE;
- seq_printf(m, "%llu\n", result);
- }
- return rc;
+ sbi->ll_stat_blksize = val;
+
+ return count;
}
-LPROC_SEQ_FOPS_RO(ll_kbytesavail);
+LUSTRE_RW_ATTR(stat_blocksize);
-static int ll_filestotal_seq_show(struct seq_file *m, void *v)
+static ssize_t kbytestotal_show(struct kobject *kobj, struct attribute *attr,
+ char *buf)
{
- struct super_block *sb = m->private;
+ struct ll_sb_info *sbi = container_of(kobj, struct ll_sb_info,
+ ll_kset.kobj);
struct obd_statfs osfs;
+ u32 blk_size;
+ u64 result;
int rc;
- LASSERT(sb != NULL);
- rc = ll_statfs_internal(sb, &osfs,
- cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS),
- OBD_STATFS_NODELAY);
- if (!rc)
- seq_printf(m, "%llu\n", osfs.os_files);
- return rc;
+ rc = ll_statfs_internal(sbi, &osfs, OBD_STATFS_NODELAY);
+ if (rc)
+ return rc;
+
+ blk_size = osfs.os_bsize >> 10;
+ result = osfs.os_blocks;
+
+ while (blk_size >>= 1)
+ result <<= 1;
+
+ return sprintf(buf, "%llu\n", result);
}
-LPROC_SEQ_FOPS_RO(ll_filestotal);
+LUSTRE_RO_ATTR(kbytestotal);
-static int ll_filesfree_seq_show(struct seq_file *m, void *v)
+static ssize_t kbytesfree_show(struct kobject *kobj, struct attribute *attr,
+ char *buf)
{
- struct super_block *sb = m->private;
+ struct ll_sb_info *sbi = container_of(kobj, struct ll_sb_info,
+ ll_kset.kobj);
struct obd_statfs osfs;
+ u32 blk_size;
+ u64 result;
int rc;
- LASSERT(sb != NULL);
- rc = ll_statfs_internal(sb, &osfs,
- cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS),
- OBD_STATFS_NODELAY);
- if (!rc)
- seq_printf(m, "%llu\n", osfs.os_ffree);
- return rc;
-}
-LPROC_SEQ_FOPS_RO(ll_filesfree);
+ rc = ll_statfs_internal(sbi, &osfs, OBD_STATFS_NODELAY);
+ if (rc)
+ return rc;
-static int ll_client_type_seq_show(struct seq_file *m, void *v)
-{
- struct ll_sb_info *sbi = ll_s2sbi((struct super_block *)m->private);
+ blk_size = osfs.os_bsize >> 10;
+ result = osfs.os_bfree;
- LASSERT(sbi != NULL);
+ while (blk_size >>= 1)
+ result <<= 1;
- seq_puts(m, "local client\n");
- return 0;
+ return sprintf(buf, "%llu\n", result);
}
-LPROC_SEQ_FOPS_RO(ll_client_type);
+LUSTRE_RO_ATTR(kbytesfree);
-static int ll_fstype_seq_show(struct seq_file *m, void *v)
+static ssize_t kbytesavail_show(struct kobject *kobj, struct attribute *attr,
+ char *buf)
{
- struct super_block *sb = m->private;
+ struct ll_sb_info *sbi = container_of(kobj, struct ll_sb_info,
+ ll_kset.kobj);
+ struct obd_statfs osfs;
+ u32 blk_size;
+ u64 result;
+ int rc;
- LASSERT(sb != NULL);
- seq_printf(m, "%s\n", sb->s_type->name);
- return 0;
-}
-LPROC_SEQ_FOPS_RO(ll_fstype);
+ rc = ll_statfs_internal(sbi, &osfs, OBD_STATFS_NODELAY);
+ if (rc)
+ return rc;
-static int ll_sb_uuid_seq_show(struct seq_file *m, void *v)
-{
- struct super_block *sb = m->private;
+ blk_size = osfs.os_bsize >> 10;
+ result = osfs.os_bavail;
- LASSERT(sb != NULL);
- seq_printf(m, "%s\n", ll_s2sbi(sb)->ll_sb_uuid.uuid);
- return 0;
+ while (blk_size >>= 1)
+ result <<= 1;
+
+ return sprintf(buf, "%llu\n", result);
}
-LPROC_SEQ_FOPS_RO(ll_sb_uuid);
+LUSTRE_RO_ATTR(kbytesavail);
-static int ll_xattr_cache_seq_show(struct seq_file *m, void *v)
+static ssize_t filestotal_show(struct kobject *kobj, struct attribute *attr,
+ char *buf)
{
- 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);
+ struct obd_statfs osfs;
+ int rc;
- seq_printf(m, "%u\n", sbi->ll_xattr_cache_enabled);
- return 0;
+ rc = ll_statfs_internal(sbi, &osfs, OBD_STATFS_NODELAY);
+ if (rc)
+ return rc;
+
+ return sprintf(buf, "%llu\n", osfs.os_files);
}
+LUSTRE_RO_ATTR(filestotal);
-static ssize_t ll_xattr_cache_seq_write(struct file *file,
- const char __user *buffer,
- size_t count, loff_t *off)
+static ssize_t filesfree_show(struct kobject *kobj, struct attribute *attr,
+ char *buf)
{
- struct seq_file *m = file->private_data;
- struct ll_sb_info *sbi = ll_s2sbi((struct super_block *)m->private);
- __s64 val;
+ struct ll_sb_info *sbi = container_of(kobj, struct ll_sb_info,
+ ll_kset.kobj);
+ struct obd_statfs osfs;
int rc;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = ll_statfs_internal(sbi, &osfs, OBD_STATFS_NODELAY);
if (rc)
return rc;
- if (val != 0 && val != 1)
- return -ERANGE;
+ return sprintf(buf, "%llu\n", osfs.os_ffree);
+}
+LUSTRE_RO_ATTR(filesfree);
- if (val == 1 && !(sbi->ll_flags & LL_SBI_XATTR_CACHE))
- return -ENOTSUPP;
+static ssize_t client_type_show(struct kobject *kobj, struct attribute *attr,
+ char *buf)
+{
+ return sprintf(buf, "local client\n");
+}
+LUSTRE_RO_ATTR(client_type);
- sbi->ll_xattr_cache_enabled = val;
+LUSTRE_RW_ATTR(foreign_symlink_enable);
- return count;
+LUSTRE_RW_ATTR(foreign_symlink_prefix);
+
+LUSTRE_RW_ATTR(foreign_symlink_upcall);
+
+LUSTRE_WO_ATTR(foreign_symlink_upcall_info);
+
+static ssize_t fstype_show(struct kobject *kobj, struct attribute *attr,
+ char *buf)
+{
+ return sprintf(buf, "lustre\n");
}
-LPROC_SEQ_FOPS(ll_xattr_cache);
+LUSTRE_RO_ATTR(fstype);
+
+static ssize_t uuid_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 sprintf(buf, "%s\n", sbi->ll_sb_uuid.uuid);
+}
+LUSTRE_RO_ATTR(uuid);
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);
-static int ll_max_readahead_mb_seq_show(struct seq_file *m, void *v)
-{
- struct super_block *sb = m->private;
- struct ll_sb_info *sbi = ll_s2sbi(sb);
- long pages_number;
- int mult;
+LDEBUGFS_SEQ_FOPS_RO(ll_site_stats);
- spin_lock(&sbi->ll_lock);
- pages_number = sbi->ll_ra_info.ra_max_pages;
- spin_unlock(&sbi->ll_lock);
+static ssize_t max_read_ahead_mb_show(struct kobject *kobj,
+ struct attribute *attr, char *buf)
+{
+ struct ll_sb_info *sbi = container_of(kobj, struct ll_sb_info,
+ ll_kset.kobj);
- mult = 1 << (20 - PAGE_SHIFT);
- return lprocfs_seq_read_frac_helper(m, pages_number, mult);
+ return scnprintf(buf, PAGE_SIZE, "%lu\n",
+ PAGES_TO_MiB(sbi->ll_ra_info.ra_max_pages));
}
-static ssize_t
-ll_max_readahead_mb_seq_write(struct file *file, const char __user *buffer,
- size_t count, loff_t *off)
+static ssize_t max_read_ahead_mb_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);
- __s64 pages_number;
+ struct ll_sb_info *sbi = container_of(kobj, struct ll_sb_info,
+ ll_kset.kobj);
+ u64 ra_max_mb, pages_number;
int rc;
- rc = lprocfs_str_with_units_to_s64(buffer, count, &pages_number, 'M');
+ rc = sysfs_memparse(buffer, count, &ra_max_mb, "MiB");
if (rc)
return rc;
- pages_number >>= PAGE_SHIFT;
-
- if (pages_number < 0 || pages_number > totalram_pages / 2) {
+ pages_number = round_up(ra_max_mb, 1024 * 1024) >> PAGE_SHIFT;
+ CDEBUG(D_INFO, "%s: set max_read_ahead_mb=%llu (%llu pages)\n",
+ sbi->ll_fsname, PAGES_TO_MiB(pages_number), pages_number);
+ if (pages_number > cfs_totalram_pages() / 2) {
/* 1/2 of RAM */
- CERROR("%s: can't set max_readahead_mb=%lu > %luMB\n",
- ll_get_fsname(sb, NULL, 0),
- (unsigned long)pages_number >> (20 - PAGE_SHIFT),
- totalram_pages >> (20 - PAGE_SHIFT + 1));
+ CERROR("%s: cannot set max_read_ahead_mb=%llu > totalram/2=%luMB\n",
+ sbi->ll_fsname, PAGES_TO_MiB(pages_number),
+ PAGES_TO_MiB(cfs_totalram_pages() / 2));
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);
+LUSTRE_RW_ATTR(max_read_ahead_mb);
-static int ll_max_readahead_per_file_mb_seq_show(struct seq_file *m, void *v)
+static ssize_t max_read_ahead_per_file_mb_show(struct kobject *kobj,
+ struct attribute *attr,
+ char *buf)
{
- struct super_block *sb = m->private;
- struct ll_sb_info *sbi = ll_s2sbi(sb);
- long pages_number;
- int mult;
-
- spin_lock(&sbi->ll_lock);
- pages_number = sbi->ll_ra_info.ra_max_pages_per_file;
- spin_unlock(&sbi->ll_lock);
+ struct ll_sb_info *sbi = container_of(kobj, struct ll_sb_info,
+ ll_kset.kobj);
- mult = 1 << (20 - PAGE_SHIFT);
- return lprocfs_seq_read_frac_helper(m, pages_number, mult);
+ return scnprintf(buf, PAGE_SIZE, "%lu\n",
+ PAGES_TO_MiB(sbi->ll_ra_info.ra_max_pages_per_file));
}
-static ssize_t
-ll_max_readahead_per_file_mb_seq_write(struct file *file,
- const char __user *buffer,
- size_t count, loff_t *off)
+static ssize_t max_read_ahead_per_file_mb_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);
+ u64 ra_max_file_mb, pages_number;
int rc;
- __s64 pages_number;
- rc = lprocfs_str_with_units_to_s64(buffer, count, &pages_number, 'M');
+ rc = sysfs_memparse(buffer, count, &ra_max_file_mb, "MiB");
if (rc)
return rc;
- pages_number >>= PAGE_SHIFT;
-
- 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),
- (unsigned long)pages_number >> (20 - PAGE_SHIFT),
- sbi->ll_ra_info.ra_max_pages >> (20 - PAGE_SHIFT));
+ pages_number = round_up(ra_max_file_mb, 1024 * 1024) >> PAGE_SHIFT;
+ if (pages_number > sbi->ll_ra_info.ra_max_pages) {
+ CERROR("%s: cannot set max_read_ahead_per_file_mb=%llu > max_read_ahead_mb=%lu\n",
+ sbi->ll_fsname, PAGES_TO_MiB(pages_number),
+ PAGES_TO_MiB(sbi->ll_ra_info.ra_max_pages));
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);
+LUSTRE_RW_ATTR(max_read_ahead_per_file_mb);
-static int ll_max_read_ahead_whole_mb_seq_show(struct seq_file *m, void *v)
+static ssize_t max_read_ahead_whole_mb_show(struct kobject *kobj,
+ struct attribute *attr, char *buf)
{
- struct super_block *sb = m->private;
- struct ll_sb_info *sbi = ll_s2sbi(sb);
- long pages_number;
- int mult;
-
- spin_lock(&sbi->ll_lock);
- pages_number = sbi->ll_ra_info.ra_max_read_ahead_whole_pages;
- spin_unlock(&sbi->ll_lock);
+ struct ll_sb_info *sbi = container_of(kobj, struct ll_sb_info,
+ ll_kset.kobj);
- mult = 1 << (20 - PAGE_SHIFT);
- return lprocfs_seq_read_frac_helper(m, pages_number, mult);
+ return scnprintf(buf, PAGE_SIZE, "%lu\n",
+ PAGES_TO_MiB(sbi->ll_ra_info.ra_max_read_ahead_whole_pages));
}
-static ssize_t
-ll_max_read_ahead_whole_mb_seq_write(struct file *file,
- const char __user *buffer,
- size_t count, loff_t *off)
+static ssize_t max_read_ahead_whole_mb_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);
+ u64 ra_max_whole_mb, pages_number;
int rc;
- __s64 pages_number;
- rc = lprocfs_str_with_units_to_s64(buffer, count, &pages_number, 'M');
+ rc = sysfs_memparse(buffer, count, &ra_max_whole_mb, "MiB");
if (rc)
return rc;
- pages_number >>= PAGE_SHIFT;
-
+ pages_number = round_up(ra_max_whole_mb, 1024 * 1024) >> PAGE_SHIFT;
/* Cap this at the current max readahead window size, the readahead
- * algorithm does this anyway so it's pointless to set it larger. */
- if (pages_number < 0 ||
- pages_number > sbi->ll_ra_info.ra_max_pages_per_file) {
- 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),
- (unsigned long)pages_number >> pages_shift,
- sbi->ll_ra_info.ra_max_pages_per_file >> pages_shift);
+ * algorithm does this anyway so it's pointless to set it larger.
+ */
+ if (pages_number > sbi->ll_ra_info.ra_max_pages_per_file) {
+ CERROR("%s: cannot set max_read_ahead_whole_mb=%llu > max_read_ahead_per_file_mb=%lu\n",
+ sbi->ll_fsname, PAGES_TO_MiB(pages_number),
+ PAGES_TO_MiB(sbi->ll_ra_info.ra_max_pages_per_file));
+
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);
+LUSTRE_RW_ATTR(max_read_ahead_whole_mb);
static int ll_max_cached_mb_seq_show(struct seq_file *m, void *v)
{
struct super_block *sb = m->private;
struct ll_sb_info *sbi = ll_s2sbi(sb);
struct cl_client_cache *cache = sbi->ll_cache;
- int shift = 20 - PAGE_SHIFT;
+ struct ll_ra_info *ra = &sbi->ll_ra_info;
long max_cached_mb;
long unused_mb;
- max_cached_mb = cache->ccc_lru_max >> shift;
- unused_mb = atomic_long_read(&cache->ccc_lru_left) >> shift;
+ mutex_lock(&cache->ccc_max_cache_mb_lock);
+ max_cached_mb = PAGES_TO_MiB(cache->ccc_lru_max);
+ unused_mb = PAGES_TO_MiB(atomic_long_read(&cache->ccc_lru_left));
+ mutex_unlock(&cache->ccc_max_cache_mb_lock);
+
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"
+ "max_read_ahead_mb: %lu\n"
+ "used_read_ahead_mb: %d\n",
atomic_read(&cache->ccc_users),
max_cached_mb,
max_cached_mb - unused_mb,
unused_mb,
- cache->ccc_lru_shrinkers);
+ cache->ccc_lru_shrinkers,
+ PAGES_TO_MiB(ra->ra_max_pages),
+ PAGES_TO_MiB(atomic_read(&ra->ra_cur_pages)));
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 diff = 0;
long nrpages = 0;
__u16 refcheck;
- __s64 pages_number;
- long rc;
- char kernbuf[128];
- ENTRY;
+ u64 pages_number;
+ int rc;
+ char kernbuf[128], *ptr;
+ ENTRY;
if (count >= sizeof(kernbuf))
RETURN(-EINVAL);
if (copy_from_user(kernbuf, buffer, count))
RETURN(-EFAULT);
- kernbuf[count] = 0;
+ kernbuf[count] = '\0';
- buffer += lprocfs_find_named_value(kernbuf, "max_cached_mb:", &count) -
- kernbuf;
- rc = lprocfs_str_with_units_to_s64(buffer, count, &pages_number, 'M');
+ ptr = lprocfs_find_named_value(kernbuf, "max_cached_mb:", &count);
+ rc = sysfs_memparse(ptr, count, &pages_number, "MiB");
if (rc)
RETURN(rc);
pages_number >>= PAGE_SHIFT;
- if (pages_number < 0 || pages_number > totalram_pages) {
+ if (pages_number < 0 || pages_number > cfs_totalram_pages()) {
CERROR("%s: can't set max cache more than %lu MB\n",
- ll_get_fsname(sb, NULL, 0),
- totalram_pages >> (20 - PAGE_SHIFT));
+ sbi->ll_fsname,
+ PAGES_TO_MiB(cfs_totalram_pages()));
RETURN(-ERANGE);
}
/* Allow enough cache so clients can make well-formed RPCs */
pages_number = max_t(long, pages_number, PTLRPC_MAX_BRW_PAGES);
- spin_lock(&sbi->ll_lock);
+ mutex_lock(&cache->ccc_max_cache_mb_lock);
diff = pages_number - cache->ccc_lru_max;
- spin_unlock(&sbi->ll_lock);
/* easy - add more LRU slots. */
if (diff >= 0) {
env = cl_env_get(&refcheck);
if (IS_ERR(env))
- RETURN(rc);
+ GOTO(out_unlock, rc = PTR_ERR(env));
diff = -diff;
while (diff > 0) {
/* reduce LRU budget from free slots. */
do {
- long ov, nv;
+ long lru_left_old, lru_left_new, lru_left_ret;
- ov = atomic_long_read(&cache->ccc_lru_left);
- if (ov == 0)
+ lru_left_old = atomic_long_read(&cache->ccc_lru_left);
+ if (lru_left_old == 0)
break;
- nv = ov > diff ? ov - diff : 0;
- rc = atomic_long_cmpxchg(&cache->ccc_lru_left, ov, nv);
- if (likely(ov == rc)) {
- diff -= ov - nv;
- nrpages += ov - nv;
+ lru_left_new = lru_left_old > diff ?
+ lru_left_old - diff : 0;
+ lru_left_ret =
+ atomic_long_cmpxchg(&cache->ccc_lru_left,
+ lru_left_old,
+ lru_left_new);
+ if (likely(lru_left_old == lru_left_ret)) {
+ diff -= lru_left_old - lru_left_new;
+ nrpages += lru_left_old - lru_left_new;
break;
}
} while (1);
break;
}
+ /* Request extra free slots to avoid them all being used
+ * by other processes before this can continue shrinking.
+ */
+ tmp = diff + min_t(long, diff, MiB_TO_PAGES(1024));
/* difficult - have to ask OSCs to drop LRU slots. */
- tmp = diff << 1;
rc = obd_set_info_async(env, sbi->ll_dt_exp,
sizeof(KEY_CACHE_LRU_SHRINK),
KEY_CACHE_LRU_SHRINK,
out:
if (rc >= 0) {
- spin_lock(&sbi->ll_lock);
cache->ccc_lru_max = pages_number;
- spin_unlock(&sbi->ll_lock);
rc = count;
} else {
atomic_long_add(nrpages, &cache->ccc_lru_left);
}
+out_unlock:
+ mutex_unlock(&cache->ccc_max_cache_mb_lock);
return rc;
}
-LPROC_SEQ_FOPS(ll_max_cached_mb);
+LDEBUGFS_SEQ_FOPS(ll_max_cached_mb);
-static int ll_checksum_seq_show(struct seq_file *m, void *v)
+static ssize_t checksums_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_CHECKSUM) ? 1 : 0);
- return 0;
+ return sprintf(buf, "%u\n", (sbi->ll_flags & LL_SBI_CHECKSUM) ? 1 : 0);
}
-static ssize_t ll_checksum_seq_write(struct file *file,
- const char __user *buffer,
- size_t count, loff_t *off)
+static ssize_t checksums_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);
+ bool val;
+ int tmp;
int rc;
- __s64 val;
if (!sbi->ll_dt_exp)
/* Not set up yet */
return -EAGAIN;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtobool(buffer, &val);
if (rc)
return rc;
if (val)
sbi->ll_flags |= LL_SBI_CHECKSUM;
else
sbi->ll_flags &= ~LL_SBI_CHECKSUM;
+ tmp = val;
rc = obd_set_info_async(NULL, sbi->ll_dt_exp, sizeof(KEY_CHECKSUM),
- KEY_CHECKSUM, sizeof(val), &val, NULL);
+ KEY_CHECKSUM, sizeof(tmp), &tmp, NULL);
if (rc)
CWARN("Failed to set OSC checksum flags: %d\n", rc);
return count;
}
-LPROC_SEQ_FOPS(ll_checksum);
+LUSTRE_RW_ATTR(checksums);
-static int ll_rd_track_id(struct seq_file *m, enum stats_track_type type)
+LUSTRE_ATTR(checksum_pages, 0644, checksums_show, checksums_store);
+
+static ssize_t ll_rd_track_id(struct kobject *kobj, char *buf,
+ enum stats_track_type type)
{
- struct super_block *sb = m->private;
+ struct ll_sb_info *sbi = container_of(kobj, struct ll_sb_info,
+ ll_kset.kobj);
- if (ll_s2sbi(sb)->ll_stats_track_type == type) {
- seq_printf(m, "%d\n",
- ll_s2sbi(sb)->ll_stats_track_id);
- } else if (ll_s2sbi(sb)->ll_stats_track_type == STATS_TRACK_ALL) {
- seq_puts(m, "0 (all)\n");
- } else {
- seq_puts(m, "untracked\n");
- }
- return 0;
+ if (sbi->ll_stats_track_type == type)
+ return sprintf(buf, "%d\n", sbi->ll_stats_track_id);
+ else if (sbi->ll_stats_track_type == STATS_TRACK_ALL)
+ return sprintf(buf, "0 (all)\n");
+
+ return sprintf(buf, "untracked\n");
}
-static int ll_wr_track_id(const char __user *buffer, unsigned long count,
- void *data, enum stats_track_type type)
+static ssize_t ll_wr_track_id(struct kobject *kobj, const char *buffer,
+ size_t count, enum stats_track_type type)
{
- struct super_block *sb = data;
+ struct ll_sb_info *sbi = container_of(kobj, struct ll_sb_info,
+ ll_kset.kobj);
+ unsigned long pid;
int rc;
- __s64 pid;
- rc = lprocfs_str_to_s64(buffer, count, &pid);
+ rc = kstrtoul(buffer, 10, &pid);
if (rc)
return rc;
- if (pid > INT_MAX || pid < 0)
- return -ERANGE;
- ll_s2sbi(sb)->ll_stats_track_id = pid;
+ sbi->ll_stats_track_id = pid;
if (pid == 0)
- ll_s2sbi(sb)->ll_stats_track_type = STATS_TRACK_ALL;
+ sbi->ll_stats_track_type = STATS_TRACK_ALL;
else
- ll_s2sbi(sb)->ll_stats_track_type = type;
- lprocfs_clear_stats(ll_s2sbi(sb)->ll_stats);
+ sbi->ll_stats_track_type = type;
+ lprocfs_clear_stats(sbi->ll_stats);
return count;
}
-static int ll_track_pid_seq_show(struct seq_file *m, void *v)
+static ssize_t stats_track_pid_show(struct kobject *kobj,
+ struct attribute *attr,
+ char *buf)
{
- return ll_rd_track_id(m, STATS_TRACK_PID);
+ return ll_rd_track_id(kobj, buf, STATS_TRACK_PID);
}
-static ssize_t ll_track_pid_seq_write(struct file *file,
- const char __user *buffer,
- size_t count, loff_t *off)
+static ssize_t stats_track_pid_store(struct kobject *kobj,
+ struct attribute *attr,
+ const char *buffer,
+ size_t count)
{
- struct seq_file *seq = file->private_data;
- return ll_wr_track_id(buffer, count, seq->private, STATS_TRACK_PID);
+ return ll_wr_track_id(kobj, buffer, count, STATS_TRACK_PID);
}
-LPROC_SEQ_FOPS(ll_track_pid);
+LUSTRE_RW_ATTR(stats_track_pid);
-static int ll_track_ppid_seq_show(struct seq_file *m, void *v)
+static ssize_t stats_track_ppid_show(struct kobject *kobj,
+ struct attribute *attr,
+ char *buf)
{
- return ll_rd_track_id(m, STATS_TRACK_PPID);
+ return ll_rd_track_id(kobj, buf, STATS_TRACK_PPID);
}
-static ssize_t ll_track_ppid_seq_write(struct file *file,
- const char __user *buffer,
- size_t count, loff_t *off)
+static ssize_t stats_track_ppid_store(struct kobject *kobj,
+ struct attribute *attr,
+ const char *buffer,
+ size_t count)
{
- struct seq_file *seq = file->private_data;
- return ll_wr_track_id(buffer, count, seq->private, STATS_TRACK_PPID);
+ return ll_wr_track_id(kobj, buffer, count, STATS_TRACK_PPID);
}
-LPROC_SEQ_FOPS(ll_track_ppid);
+LUSTRE_RW_ATTR(stats_track_ppid);
-static int ll_track_gid_seq_show(struct seq_file *m, void *v)
+static ssize_t stats_track_gid_show(struct kobject *kobj,
+ struct attribute *attr,
+ char *buf)
{
- return ll_rd_track_id(m, STATS_TRACK_GID);
+ return ll_rd_track_id(kobj, buf, STATS_TRACK_GID);
}
-static ssize_t ll_track_gid_seq_write(struct file *file,
- const char __user *buffer,
- size_t count, loff_t *off)
+static ssize_t stats_track_gid_store(struct kobject *kobj,
+ struct attribute *attr,
+ const char *buffer,
+ size_t count)
{
- struct seq_file *seq = file->private_data;
- return ll_wr_track_id(buffer, count, seq->private, STATS_TRACK_GID);
+ return ll_wr_track_id(kobj, buffer, count, STATS_TRACK_GID);
}
-LPROC_SEQ_FOPS(ll_track_gid);
+LUSTRE_RW_ATTR(stats_track_gid);
-static int ll_statahead_max_seq_show(struct seq_file *m, void *v)
+static ssize_t statahead_running_max_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_sa_max);
- return 0;
+ return scnprintf(buf, PAGE_SIZE, "%u\n", sbi->ll_sa_running_max);
}
-static ssize_t ll_statahead_max_seq_write(struct file *file,
- const char __user *buffer,
- size_t count, loff_t *off)
+static ssize_t statahead_running_max_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 long val;
int rc;
- __s64 val;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtoul(buffer, 0, &val);
if (rc)
return rc;
- if (val >= 0 && val <= LL_SA_RPC_MAX)
+ if (val <= LL_SA_RUNNING_MAX) {
+ sbi->ll_sa_running_max = val;
+ return count;
+ }
+
+ CERROR("Bad statahead_running_max value %lu. Valid values "
+ "are in the range [0, %d]\n", val, LL_SA_RUNNING_MAX);
+
+ return -ERANGE;
+}
+LUSTRE_RW_ATTR(statahead_running_max);
+
+static ssize_t statahead_max_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 sprintf(buf, "%u\n", sbi->ll_sa_max);
+}
+
+static ssize_t statahead_max_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, 0, &val);
+ if (rc)
+ return rc;
+
+ if (val <= LL_SA_RPC_MAX)
sbi->ll_sa_max = val;
else
- CERROR("Bad statahead_max value %lld. Valid values are in "
- "the range [0, %d]\n", val, LL_SA_RPC_MAX);
+ CERROR("Bad statahead_max value %lu. Valid values are in the range [0, %d]\n",
+ val, LL_SA_RPC_MAX);
return count;
}
-LPROC_SEQ_FOPS(ll_statahead_max);
+LUSTRE_RW_ATTR(statahead_max);
-static int ll_statahead_agl_seq_show(struct seq_file *m, void *v)
+static ssize_t statahead_agl_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_AGL_ENABLED ? 1 : 0);
- return 0;
+ return sprintf(buf, "%u\n", sbi->ll_flags & LL_SBI_AGL_ENABLED ? 1 : 0);
}
-static ssize_t ll_statahead_agl_seq_write(struct file *file,
- const char __user *buffer,
- size_t count, loff_t *off)
+static ssize_t statahead_agl_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);
+ bool val;
int rc;
- __s64 val;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtobool(buffer, &val);
if (rc)
return rc;
return count;
}
-LPROC_SEQ_FOPS(ll_statahead_agl);
+LUSTRE_RW_ATTR(statahead_agl);
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);
-static int ll_lazystatfs_seq_show(struct seq_file *m, void *v)
+LDEBUGFS_SEQ_FOPS_RO(ll_statahead_stats);
+
+static ssize_t lazystatfs_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_LAZYSTATFS) ? 1 : 0);
- return 0;
+ return sprintf(buf, "%u\n", (sbi->ll_flags & LL_SBI_LAZYSTATFS) ? 1 : 0);
}
-static ssize_t ll_lazystatfs_seq_write(struct file *file,
- const char __user *buffer,
- size_t count, loff_t *off)
+static ssize_t lazystatfs_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);
+ bool val;
int rc;
- __s64 val;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtobool(buffer, &val);
if (rc)
return rc;
return count;
}
-LPROC_SEQ_FOPS(ll_lazystatfs);
+LUSTRE_RW_ATTR(lazystatfs);
-static int ll_max_easize_seq_show(struct seq_file *m, void *v)
+static ssize_t statfs_max_age_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);
+
+ return scnprintf(buf, PAGE_SIZE, "%u\n", sbi->ll_statfs_max_age);
+}
+
+static ssize_t statfs_max_age_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 int val;
+ int rc;
+
+ rc = kstrtouint(buffer, 10, &val);
+ if (rc)
+ return rc;
+ if (val > OBD_STATFS_CACHE_MAX_AGE)
+ return -EINVAL;
+
+ sbi->ll_statfs_max_age = val;
+
+ return count;
+}
+LUSTRE_RW_ATTR(statfs_max_age);
+
+static ssize_t max_easize_show(struct kobject *kobj,
+ struct attribute *attr,
+ char *buf)
+{
+ struct ll_sb_info *sbi = container_of(kobj, struct ll_sb_info,
+ ll_kset.kobj);
unsigned int ealen;
int rc;
if (rc)
return rc;
- seq_printf(m, "%u\n", ealen);
- return 0;
+ /* Limit xattr size returned to userspace based on kernel maximum */
+ return scnprintf(buf, PAGE_SIZE, "%u\n",
+ ealen > XATTR_SIZE_MAX ? XATTR_SIZE_MAX : ealen);
}
-LPROC_SEQ_FOPS_RO(ll_max_easize);
+LUSTRE_RO_ATTR(max_easize);
/**
* Get default_easize.
* \retval 0 on success
* \retval negative negated errno on failure
*/
-static int ll_default_easize_seq_show(struct seq_file *m, void *v)
+static ssize_t default_easize_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);
unsigned int ealen;
int rc;
if (rc)
return rc;
- seq_printf(m, "%u\n", ealen);
- return 0;
+ /* Limit xattr size returned to userspace based on kernel maximum */
+ return scnprintf(buf, PAGE_SIZE, "%u\n",
+ ealen > XATTR_SIZE_MAX ? XATTR_SIZE_MAX : ealen);
}
/**
* \retval positive \a count on success
* \retval negative negated errno on failure
*/
-static ssize_t ll_default_easize_seq_write(struct file *file,
- const char __user *buffer,
- size_t count, loff_t *unused)
+static ssize_t default_easize_store(struct kobject *kobj,
+ struct attribute *attr,
+ const char *buffer,
+ size_t count)
{
- struct seq_file *seq = file->private_data;
- struct super_block *sb = (struct super_block *)seq->private;
- struct ll_sb_info *sbi = ll_s2sbi(sb);
- __s64 val;
+ struct ll_sb_info *sbi = container_of(kobj, struct ll_sb_info,
+ ll_kset.kobj);
+ unsigned int val;
int rc;
if (count == 0)
return 0;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtouint(buffer, 10, &val);
if (rc)
return rc;
- if (val < 0 || val > INT_MAX)
- return -ERANGE;
rc = ll_set_default_mdsize(sbi, val);
if (rc)
return count;
}
-LPROC_SEQ_FOPS(ll_default_easize);
+LUSTRE_RW_ATTR(default_easize);
static int ll_sbi_flags_seq_show(struct seq_file *m, void *v)
{
- const char *str[] = LL_SBI_FLAGS;
+ const char *const str[] = LL_SBI_FLAGS;
struct super_block *sb = m->private;
int flags = ll_s2sbi(sb)->ll_flags;
int i = 0;
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);
-static int ll_fast_read_seq_show(struct seq_file *m, void *v)
+LDEBUGFS_SEQ_FOPS_RO(ll_sbi_flags);
+
+static ssize_t xattr_cache_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_xattr_cache_enabled);
+}
+
+static ssize_t xattr_cache_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);
+ bool val;
+ int rc;
+
+ rc = kstrtobool(buffer, &val);
+ if (rc)
+ return rc;
+
+ if (val && !(sbi->ll_flags & LL_SBI_XATTR_CACHE))
+ return -ENOTSUPP;
+
+ sbi->ll_xattr_cache_enabled = val;
+ sbi->ll_xattr_cache_set = 1;
+
+ return count;
+}
+LUSTRE_RW_ATTR(xattr_cache);
+
+static ssize_t tiny_write_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 sprintf(buf, "%u\n", !!(sbi->ll_flags & LL_SBI_TINY_WRITE));
+}
+
+static ssize_t tiny_write_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);
+ bool val;
+ int rc;
+
+ rc = kstrtobool(buffer, &val);
+ if (rc)
+ return rc;
+
+ spin_lock(&sbi->ll_lock);
+ if (val)
+ sbi->ll_flags |= LL_SBI_TINY_WRITE;
+ else
+ sbi->ll_flags &= ~LL_SBI_TINY_WRITE;
+ spin_unlock(&sbi->ll_lock);
+
+ return count;
+}
+LUSTRE_RW_ATTR(tiny_write);
+
+static ssize_t max_read_ahead_async_active_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 scnprintf(buf, PAGE_SIZE, "%u\n",
+ sbi->ll_ra_info.ra_async_max_active);
+}
+
+static ssize_t max_read_ahead_async_active_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 int val;
+ int rc;
+
+ rc = kstrtouint(buffer, 10, &val);
+ if (rc)
+ return rc;
+
+ /**
+ * It doesn't make any sense to make it exceed what
+ * workqueue could acutally support. This can easily
+ * over subscripe the cores but Lustre internally
+ * throttles to avoid those impacts.
+ */
+ if (val > WQ_UNBOUND_MAX_ACTIVE) {
+ CERROR("%s: cannot set max_read_ahead_async_active=%u larger than %u\n",
+ sbi->ll_fsname, val, WQ_UNBOUND_MAX_ACTIVE);
+ return -ERANGE;
+ }
+
+ spin_lock(&sbi->ll_lock);
+ sbi->ll_ra_info.ra_async_max_active = val;
+ spin_unlock(&sbi->ll_lock);
+
+ return count;
+}
+LUSTRE_RW_ATTR(max_read_ahead_async_active);
+
+static ssize_t read_ahead_async_file_threshold_mb_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 scnprintf(buf, PAGE_SIZE, "%lu\n", PAGES_TO_MiB(
+ sbi->ll_ra_info.ra_async_pages_per_file_threshold));
}
static ssize_t
-ll_fast_read_seq_write(struct file *file, const char __user *buffer,
- size_t count, loff_t *off)
+read_ahead_async_file_threshold_mb_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);
+ unsigned long pages_number;
+ unsigned long max_ra_per_file;
+ struct ll_sb_info *sbi = container_of(kobj, struct ll_sb_info,
+ ll_kset.kobj);
int rc;
- __s64 val;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtoul(buffer, 10, &pages_number);
if (rc)
return rc;
+ pages_number = MiB_TO_PAGES(pages_number);
+ max_ra_per_file = sbi->ll_ra_info.ra_max_pages_per_file;
+ if (pages_number < 0 || pages_number > max_ra_per_file) {
+ CERROR("%s: can't set read_ahead_async_file_threshold_mb=%lu > "
+ "max_read_readahead_per_file_mb=%lu\n", sbi->ll_fsname,
+ PAGES_TO_MiB(pages_number),
+ PAGES_TO_MiB(max_ra_per_file));
+ return -ERANGE;
+ }
+ sbi->ll_ra_info.ra_async_pages_per_file_threshold = pages_number;
+
+ return count;
+}
+LUSTRE_RW_ATTR(read_ahead_async_file_threshold_mb);
+
+static ssize_t read_ahead_range_kb_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, "%lu\n",
+ sbi->ll_ra_info.ra_range_pages << (PAGE_SHIFT - 10));
+}
+
+static ssize_t
+read_ahead_range_kb_store(struct kobject *kobj,
+ struct attribute *attr,
+ const char *buffer, size_t count)
+{
+ unsigned long pages_number;
+ unsigned long max_ra_per_file;
+ u64 val;
+ struct ll_sb_info *sbi = container_of(kobj, struct ll_sb_info,
+ ll_kset.kobj);
+ int rc;
+
+ rc = sysfs_memparse(buffer, count, &val, "KiB");
+ if (rc < 0)
+ return rc;
+
+ pages_number = val >> PAGE_SHIFT;
+ /* Disable mmap range read */
+ if (pages_number == 0)
+ goto out;
+
+ max_ra_per_file = sbi->ll_ra_info.ra_max_pages_per_file;
+ if (pages_number > max_ra_per_file ||
+ pages_number < RA_MIN_MMAP_RANGE_PAGES)
+ return -ERANGE;
+
+out:
spin_lock(&sbi->ll_lock);
- if (val == 1)
+ sbi->ll_ra_info.ra_range_pages = pages_number;
+ spin_unlock(&sbi->ll_lock);
+
+ return count;
+}
+LUSTRE_RW_ATTR(read_ahead_range_kb);
+
+static ssize_t fast_read_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 sprintf(buf, "%u\n", !!(sbi->ll_flags & LL_SBI_FAST_READ));
+}
+
+static ssize_t fast_read_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);
+ bool val;
+ int rc;
+
+ rc = kstrtobool(buffer, &val);
+ if (rc)
+ return rc;
+
+ spin_lock(&sbi->ll_lock);
+ if (val)
sbi->ll_flags |= LL_SBI_FAST_READ;
else
sbi->ll_flags &= ~LL_SBI_FAST_READ;
return count;
}
-LPROC_SEQ_FOPS(ll_fast_read);
+LUSTRE_RW_ATTR(fast_read);
+
+static ssize_t file_heat_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 scnprintf(buf, PAGE_SIZE, "%u\n",
+ !!(sbi->ll_flags & LL_SBI_FILE_HEAT));
+}
+
+static ssize_t file_heat_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);
+ bool val;
+ int rc;
+
+ rc = kstrtobool(buffer, &val);
+ if (rc)
+ return rc;
+
+ spin_lock(&sbi->ll_lock);
+ if (val)
+ sbi->ll_flags |= LL_SBI_FILE_HEAT;
+ else
+ sbi->ll_flags &= ~LL_SBI_FILE_HEAT;
+ spin_unlock(&sbi->ll_lock);
+
+ return count;
+}
+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 scnprintf(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 scnprintf(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;
}
struct seq_file *seq = file->private_data;
struct ll_sb_info *sbi = ll_s2sbi((struct super_block *)seq->private);
char kernbuf[128];
+ bool val;
int rc;
- __s64 val;
if (count == 0)
return 0;
buffer += lprocfs_find_named_value(kernbuf, "unstable_check:", &count) -
kernbuf;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtobool_from_user(buffer, count, &val);
if (rc < 0)
return rc;
/* borrow lru lock to set the value */
spin_lock(&sbi->ll_cache->ccc_lru_lock);
- sbi->ll_cache->ccc_unstable_check = !!val;
+ sbi->ll_cache->ccc_unstable_check = val;
spin_unlock(&sbi->ll_cache->ccc_lru_lock);
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 len;
- down_read(&squash->rsi_sem);
+ spin_lock(&squash->rsi_lock);
if (!list_empty(&squash->rsi_nosquash_nids)) {
len = cfs_print_nidlist(m->buf + m->count, m->size - m->count,
&squash->rsi_nosquash_nids);
} else {
seq_puts(m, "NONE\n");
}
- up_read(&squash->rsi_sem);
+ spin_unlock(&squash->rsi_lock);
return 0;
}
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);
-struct lprocfs_vars lprocfs_llite_obd_vars[] = {
- { .name = "uuid",
- .fops = &ll_sb_uuid_fops },
- { .name = "fstype",
- .fops = &ll_fstype_fops },
+LDEBUGFS_SEQ_FOPS(ll_nosquash_nids);
+
+static int ll_pcc_seq_show(struct seq_file *m, void *v)
+{
+ struct super_block *sb = m->private;
+ struct ll_sb_info *sbi = ll_s2sbi(sb);
+
+ return pcc_super_dump(&sbi->ll_pcc_super, m);
+}
+
+static ssize_t ll_pcc_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;
+ struct ll_sb_info *sbi = ll_s2sbi(sb);
+ int rc;
+ char *kernbuf;
+
+ if (count >= LPROCFS_WR_PCC_MAX_CMD)
+ return -EINVAL;
+
+ if (!(exp_connect_flags2(sbi->ll_md_exp) & OBD_CONNECT2_PCC))
+ return -EOPNOTSUPP;
+
+ OBD_ALLOC(kernbuf, count + 1);
+ if (kernbuf == NULL)
+ return -ENOMEM;
+
+ if (copy_from_user(kernbuf, buffer, count))
+ GOTO(out_free_kernbuff, rc = -EFAULT);
+
+ rc = pcc_cmd_handle(kernbuf, count, &sbi->ll_pcc_super);
+out_free_kernbuff:
+ OBD_FREE(kernbuf, count + 1);
+ return rc ? rc : count;
+}
+LDEBUGFS_SEQ_FOPS(ll_pcc);
+
+struct ldebugfs_vars lprocfs_llite_obd_vars[] = {
{ .name = "site",
.fops = &ll_site_stats_fops },
- { .name = "blocksize",
- .fops = &ll_blksize_fops },
- { .name = "kbytestotal",
- .fops = &ll_kbytestotal_fops },
- { .name = "kbytesfree",
- .fops = &ll_kbytesfree_fops },
- { .name = "kbytesavail",
- .fops = &ll_kbytesavail_fops },
- { .name = "filestotal",
- .fops = &ll_filestotal_fops },
- { .name = "filesfree",
- .fops = &ll_filesfree_fops },
- { .name = "client_type",
- .fops = &ll_client_type_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 = "checksum_pages",
- .fops = &ll_checksum_fops },
- { .name = "stats_track_pid",
- .fops = &ll_track_pid_fops },
- { .name = "stats_track_ppid",
- .fops = &ll_track_ppid_fops },
- { .name = "stats_track_gid",
- .fops = &ll_track_gid_fops },
- { .name = "statahead_max",
- .fops = &ll_statahead_max_fops },
- { .name = "statahead_agl",
- .fops = &ll_statahead_agl_fops },
{ .name = "statahead_stats",
.fops = &ll_statahead_stats_fops },
- { .name = "lazystatfs",
- .fops = &ll_lazystatfs_fops },
- { .name = "max_easize",
- .fops = &ll_max_easize_fops },
- { .name = "default_easize",
- .fops = &ll_default_easize_fops },
- { .name = "sbi_flags",
- .fops = &ll_sbi_flags_fops },
- { .name = "xattr_cache",
- .fops = &ll_xattr_cache_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 = "pcc",
+ .fops = &ll_pcc_fops, },
{ NULL }
};
#define MAX_STRING_SIZE 128
+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_filestotal.attr,
+ &lustre_attr_filesfree.attr,
+ &lustre_attr_client_type.attr,
+ &lustre_attr_foreign_symlink_enable.attr,
+ &lustre_attr_foreign_symlink_prefix.attr,
+ &lustre_attr_foreign_symlink_upcall.attr,
+ &lustre_attr_foreign_symlink_upcall_info.attr,
+ &lustre_attr_fstype.attr,
+ &lustre_attr_uuid.attr,
+ &lustre_attr_checksums.attr,
+ &lustre_attr_checksum_pages.attr,
+ &lustre_attr_max_read_ahead_mb.attr,
+ &lustre_attr_max_read_ahead_per_file_mb.attr,
+ &lustre_attr_max_read_ahead_whole_mb.attr,
+ &lustre_attr_max_read_ahead_async_active.attr,
+ &lustre_attr_read_ahead_async_file_threshold_mb.attr,
+ &lustre_attr_read_ahead_range_kb.attr,
+ &lustre_attr_stats_track_pid.attr,
+ &lustre_attr_stats_track_ppid.attr,
+ &lustre_attr_stats_track_gid.attr,
+ &lustre_attr_statahead_running_max.attr,
+ &lustre_attr_statahead_max.attr,
+ &lustre_attr_statahead_agl.attr,
+ &lustre_attr_lazystatfs.attr,
+ &lustre_attr_statfs_max_age.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 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 sbi_ktype = {
+ .default_attrs = llite_attrs,
+ .sysfs_ops = &lustre_sysfs_ops,
+ .release = sbi_kobj_release,
+};
+
static const struct llite_file_opcode {
- __u32 opcode;
- __u32 type;
- const char *opname;
+ __u32 opcode;
+ __u32 type;
+ const char *opname;
} llite_opcode_table[LPROC_LL_FILE_OPCODES] = {
- /* file operation */
- { LPROC_LL_DIRTY_HITS, LPROCFS_TYPE_REGS, "dirty_pages_hits" },
- { LPROC_LL_DIRTY_MISSES, LPROCFS_TYPE_REGS, "dirty_pages_misses" },
- { LPROC_LL_READ_BYTES, LPROCFS_CNTR_AVGMINMAX|LPROCFS_TYPE_BYTES,
- "read_bytes" },
- { LPROC_LL_WRITE_BYTES, LPROCFS_CNTR_AVGMINMAX|LPROCFS_TYPE_BYTES,
- "write_bytes" },
- { LPROC_LL_BRW_READ, LPROCFS_CNTR_AVGMINMAX|LPROCFS_TYPE_PAGES,
- "brw_read" },
- { LPROC_LL_BRW_WRITE, LPROCFS_CNTR_AVGMINMAX|LPROCFS_TYPE_PAGES,
- "brw_write" },
- { LPROC_LL_IOCTL, LPROCFS_TYPE_REGS, "ioctl" },
- { LPROC_LL_OPEN, LPROCFS_TYPE_REGS, "open" },
- { LPROC_LL_RELEASE, LPROCFS_TYPE_REGS, "close" },
- { LPROC_LL_MAP, LPROCFS_TYPE_REGS, "mmap" },
- { LPROC_LL_FAULT, LPROCFS_TYPE_REGS, "page_fault" },
- { LPROC_LL_MKWRITE, LPROCFS_TYPE_REGS, "page_mkwrite" },
- { LPROC_LL_LLSEEK, LPROCFS_TYPE_REGS, "seek" },
- { LPROC_LL_FSYNC, LPROCFS_TYPE_REGS, "fsync" },
- { LPROC_LL_READDIR, LPROCFS_TYPE_REGS, "readdir" },
- /* inode operation */
- { LPROC_LL_SETATTR, LPROCFS_TYPE_REGS, "setattr" },
- { LPROC_LL_TRUNC, LPROCFS_TYPE_REGS, "truncate" },
- { LPROC_LL_FLOCK, LPROCFS_TYPE_REGS, "flock" },
- { LPROC_LL_GETATTR, LPROCFS_TYPE_REGS, "getattr" },
- /* dir inode operation */
- { LPROC_LL_CREATE, LPROCFS_TYPE_REGS, "create" },
- { LPROC_LL_LINK, LPROCFS_TYPE_REGS, "link" },
- { LPROC_LL_UNLINK, LPROCFS_TYPE_REGS, "unlink" },
- { LPROC_LL_SYMLINK, LPROCFS_TYPE_REGS, "symlink" },
- { LPROC_LL_MKDIR, LPROCFS_TYPE_REGS, "mkdir" },
- { LPROC_LL_RMDIR, LPROCFS_TYPE_REGS, "rmdir" },
- { LPROC_LL_MKNOD, LPROCFS_TYPE_REGS, "mknod" },
- { LPROC_LL_RENAME, LPROCFS_TYPE_REGS, "rename" },
- /* special inode operation */
- { LPROC_LL_STAFS, LPROCFS_TYPE_REGS, "statfs" },
- { LPROC_LL_ALLOC_INODE, LPROCFS_TYPE_REGS, "alloc_inode" },
- { LPROC_LL_SETXATTR, LPROCFS_TYPE_REGS, "setxattr" },
- { LPROC_LL_GETXATTR, LPROCFS_TYPE_REGS, "getxattr" },
- { LPROC_LL_GETXATTR_HITS, LPROCFS_TYPE_REGS, "getxattr_hits" },
- { LPROC_LL_LISTXATTR, LPROCFS_TYPE_REGS, "listxattr" },
- { LPROC_LL_REMOVEXATTR, LPROCFS_TYPE_REGS, "removexattr" },
- { LPROC_LL_INODE_PERM, LPROCFS_TYPE_REGS, "inode_permission" },
+ /* file operation */
+ { LPROC_LL_READ_BYTES, LPROCFS_TYPE_BYTES_FULL, "read_bytes" },
+ { LPROC_LL_WRITE_BYTES, LPROCFS_TYPE_BYTES_FULL, "write_bytes" },
+ { LPROC_LL_READ, LPROCFS_TYPE_LATENCY, "read" },
+ { LPROC_LL_WRITE, LPROCFS_TYPE_LATENCY, "write" },
+ { LPROC_LL_IOCTL, LPROCFS_TYPE_REQS, "ioctl" },
+ { LPROC_LL_OPEN, LPROCFS_TYPE_LATENCY, "open" },
+ { LPROC_LL_RELEASE, LPROCFS_TYPE_LATENCY, "close" },
+ { LPROC_LL_MMAP, LPROCFS_TYPE_LATENCY, "mmap" },
+ { LPROC_LL_FAULT, LPROCFS_TYPE_LATENCY, "page_fault" },
+ { LPROC_LL_MKWRITE, LPROCFS_TYPE_LATENCY, "page_mkwrite" },
+ { LPROC_LL_LLSEEK, LPROCFS_TYPE_LATENCY, "seek" },
+ { LPROC_LL_FSYNC, LPROCFS_TYPE_LATENCY, "fsync" },
+ { LPROC_LL_READDIR, LPROCFS_TYPE_LATENCY, "readdir" },
+ /* inode operation */
+ { LPROC_LL_SETATTR, LPROCFS_TYPE_LATENCY, "setattr" },
+ { LPROC_LL_TRUNC, LPROCFS_TYPE_LATENCY, "truncate" },
+ { LPROC_LL_FLOCK, LPROCFS_TYPE_LATENCY, "flock" },
+ { LPROC_LL_GETATTR, LPROCFS_TYPE_LATENCY, "getattr" },
+ { LPROC_LL_FALLOCATE, LPROCFS_TYPE_LATENCY, "fallocate"},
+ /* dir inode operation */
+ { LPROC_LL_CREATE, LPROCFS_TYPE_LATENCY, "create" },
+ { LPROC_LL_LINK, LPROCFS_TYPE_LATENCY, "link" },
+ { LPROC_LL_UNLINK, LPROCFS_TYPE_LATENCY, "unlink" },
+ { LPROC_LL_SYMLINK, LPROCFS_TYPE_LATENCY, "symlink" },
+ { LPROC_LL_MKDIR, LPROCFS_TYPE_LATENCY, "mkdir" },
+ { LPROC_LL_RMDIR, LPROCFS_TYPE_LATENCY, "rmdir" },
+ { LPROC_LL_MKNOD, LPROCFS_TYPE_LATENCY, "mknod" },
+ { LPROC_LL_RENAME, LPROCFS_TYPE_LATENCY, "rename" },
+ /* special inode operation */
+ { LPROC_LL_STATFS, LPROCFS_TYPE_LATENCY, "statfs" },
+ { LPROC_LL_SETXATTR, LPROCFS_TYPE_LATENCY, "setxattr" },
+ { LPROC_LL_GETXATTR, LPROCFS_TYPE_LATENCY, "getxattr" },
+ { LPROC_LL_GETXATTR_HITS, LPROCFS_TYPE_REQS, "getxattr_hits" },
+ { LPROC_LL_LISTXATTR, LPROCFS_TYPE_LATENCY, "listxattr" },
+ { LPROC_LL_REMOVEXATTR, LPROCFS_TYPE_LATENCY, "removexattr" },
+ { LPROC_LL_INODE_PERM, LPROCFS_TYPE_LATENCY, "inode_permission" },
};
-void ll_stats_ops_tally(struct ll_sb_info *sbi, int op, int count)
+void ll_stats_ops_tally(struct ll_sb_info *sbi, int op, long count)
{
- if (!sbi->ll_stats)
- return;
- if (sbi->ll_stats_track_type == STATS_TRACK_ALL)
- lprocfs_counter_add(sbi->ll_stats, op, count);
- else if (sbi->ll_stats_track_type == STATS_TRACK_PID &&
- sbi->ll_stats_track_id == current->pid)
- lprocfs_counter_add(sbi->ll_stats, op, count);
- else if (sbi->ll_stats_track_type == STATS_TRACK_PPID &&
- sbi->ll_stats_track_id == current->parent->pid)
- lprocfs_counter_add(sbi->ll_stats, op, count);
+ if (!sbi->ll_stats)
+ return;
+
+ if (sbi->ll_stats_track_type == STATS_TRACK_ALL)
+ lprocfs_counter_add(sbi->ll_stats, op, count);
+ else if (sbi->ll_stats_track_type == STATS_TRACK_PID &&
+ sbi->ll_stats_track_id == current->pid)
+ lprocfs_counter_add(sbi->ll_stats, op, count);
+ else if (sbi->ll_stats_track_type == STATS_TRACK_PPID &&
+ sbi->ll_stats_track_id == current->parent->pid)
+ lprocfs_counter_add(sbi->ll_stats, op, count);
else if (sbi->ll_stats_track_type == STATS_TRACK_GID &&
sbi->ll_stats_track_id ==
from_kgid(&init_user_ns, current_gid()))
}
EXPORT_SYMBOL(ll_stats_ops_tally);
-static const char *ra_stat_string[] = {
- [RA_STAT_HIT] = "hits",
- [RA_STAT_MISS] = "misses",
- [RA_STAT_DISTANT_READPAGE] = "readpage not consecutive",
- [RA_STAT_MISS_IN_WINDOW] = "miss inside window",
- [RA_STAT_FAILED_GRAB_PAGE] = "failed grab_cache_page",
- [RA_STAT_FAILED_MATCH] = "failed lock match",
- [RA_STAT_DISCARDED] = "read but discarded",
- [RA_STAT_ZERO_LEN] = "zero length file",
- [RA_STAT_ZERO_WINDOW] = "zero size window",
- [RA_STAT_EOF] = "read-ahead to EOF",
- [RA_STAT_MAX_IN_FLIGHT] = "hit max r-a issue",
- [RA_STAT_WRONG_GRAB_PAGE] = "wrong page from grab_cache_page",
- [RA_STAT_FAILED_REACH_END] = "failed to reach end"
+static const char *const ra_stat_string[] = {
+ [RA_STAT_HIT] = "hits",
+ [RA_STAT_MISS] = "misses",
+ [RA_STAT_DISTANT_READPAGE] = "readpage_not_consecutive",
+ [RA_STAT_MISS_IN_WINDOW] = "miss_inside_window",
+ [RA_STAT_FAILED_GRAB_PAGE] = "failed_grab_cache_page",
+ [RA_STAT_FAILED_MATCH] = "failed_lock_match",
+ [RA_STAT_DISCARDED] = "read_but_discarded",
+ [RA_STAT_ZERO_LEN] = "zero_length_file",
+ [RA_STAT_ZERO_WINDOW] = "zero_size_window",
+ [RA_STAT_EOF] = "readahead_to_eof",
+ [RA_STAT_MAX_IN_FLIGHT] = "hit_max_readahead_issue",
+ [RA_STAT_WRONG_GRAB_PAGE] = "wrong_page_from_grab_cache_page",
+ [RA_STAT_FAILED_REACH_END] = "failed_to_reach_end",
+ [RA_STAT_ASYNC] = "async_readahead",
+ [RA_STAT_FAILED_FAST_READ] = "failed_to_fast_read",
+ [RA_STAT_MMAP_RANGE_READ] = "mmap_range_read",
};
-LPROC_SEQ_FOPS_RO_TYPE(llite, name);
-LPROC_SEQ_FOPS_RO_TYPE(llite, uuid);
-
-int lprocfs_register_mountpoint(struct proc_dir_entry *parent,
- struct super_block *sb, char *osc, char *mdc)
+int ll_debugfs_register_super(struct super_block *sb, const char *name)
{
- 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], *ptr;
- int err, id, len, rc;
- ENTRY;
+ int err, id;
- memset(lvars, 0, sizeof(lvars));
-
- name[MAX_STRING_SIZE] = '\0';
- lvars[0].name = name;
-
- LASSERT(sbi != NULL);
- LASSERT(mdc != NULL);
- LASSERT(osc != NULL);
-
- /* Get fsname */
- len = strlen(lsi->lsi_lmd->lmd_profile);
- ptr = strrchr(lsi->lsi_lmd->lmd_profile, '-');
- if (ptr && (strcmp(ptr, "-client") == 0))
- len -= 7;
-
- /* Mount info */
- snprintf(name, MAX_STRING_SIZE, "%.*s-%p", len,
- lsi->lsi_lmd->lmd_profile, sb);
-
- sbi->ll_proc_root = lprocfs_register(name, parent, NULL, NULL);
- if (IS_ERR(sbi->ll_proc_root)) {
- err = PTR_ERR(sbi->ll_proc_root);
- sbi->ll_proc_root = NULL;
- RETURN(err);
+ ENTRY;
+ LASSERT(sbi);
+
+ if (IS_ERR_OR_NULL(llite_root))
+ goto out_ll_kset;
+
+ sbi->ll_debugfs_entry = debugfs_create_dir(name, llite_root);
+ ldebugfs_add_vars(sbi->ll_debugfs_entry, lprocfs_llite_obd_vars, sb);
+
+ debugfs_create_file("dump_page_cache", 0444, sbi->ll_debugfs_entry, sbi,
+ &vvp_dump_pgcache_file_ops);
+
+ debugfs_create_file("extents_stats", 0644, sbi->ll_debugfs_entry, sbi,
+ &ll_rw_extents_stats_fops);
+
+ debugfs_create_file("extents_stats_per_process", 0644,
+ sbi->ll_debugfs_entry, sbi,
+ &ll_rw_extents_stats_pp_fops);
+
+ debugfs_create_file("offset_stats", 0644, sbi->ll_debugfs_entry, sbi,
+ &ll_rw_offset_stats_fops);
+
+ /* File operations stats */
+ sbi->ll_stats = lprocfs_alloc_stats(LPROC_LL_FILE_OPCODES,
+ LPROCFS_STATS_FLAG_NONE);
+ if (sbi->ll_stats == NULL)
+ GOTO(out_debugfs, err = -ENOMEM);
+
+ /* do counter init */
+ for (id = 0; id < LPROC_LL_FILE_OPCODES; id++) {
+ u32 type = llite_opcode_table[id].type;
+ void *ptr = "unknown";
+
+ if (type & LPROCFS_TYPE_REQS)
+ ptr = "reqs";
+ else if (type & LPROCFS_TYPE_BYTES)
+ ptr = "bytes";
+ else if (type & LPROCFS_TYPE_USEC)
+ ptr = "usec";
+ lprocfs_counter_init(sbi->ll_stats,
+ llite_opcode_table[id].opcode, type,
+ llite_opcode_table[id].opname, ptr);
}
- rc = lprocfs_seq_create(sbi->ll_proc_root, "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);
- 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);
- 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);
- if (rc)
- CWARN("Error adding the offset_stats file\n");
-
- /* File operations stats */
- sbi->ll_stats = lprocfs_alloc_stats(LPROC_LL_FILE_OPCODES,
- LPROCFS_STATS_FLAG_NONE);
- if (sbi->ll_stats == NULL)
- GOTO(out, err = -ENOMEM);
- /* do counter init */
- for (id = 0; id < LPROC_LL_FILE_OPCODES; id++) {
- __u32 type = llite_opcode_table[id].type;
- void *ptr = NULL;
- if (type & LPROCFS_TYPE_REGS)
- ptr = "regs";
- else if (type & LPROCFS_TYPE_BYTES)
- ptr = "bytes";
- else if (type & LPROCFS_TYPE_PAGES)
- ptr = "pages";
- lprocfs_counter_init(sbi->ll_stats,
- llite_opcode_table[id].opcode,
- (type & LPROCFS_CNTR_AVGMINMAX),
- llite_opcode_table[id].opname, ptr);
- }
- err = lprocfs_register_stats(sbi->ll_proc_root, "stats", sbi->ll_stats);
- if (err)
- GOTO(out, err);
+ debugfs_create_file("stats", 0644, sbi->ll_debugfs_entry,
+ sbi->ll_stats, &ldebugfs_stats_seq_fops);
- sbi->ll_ra_stats = lprocfs_alloc_stats(ARRAY_SIZE(ra_stat_string),
- LPROCFS_STATS_FLAG_NONE);
- if (sbi->ll_ra_stats == NULL)
- GOTO(out, err = -ENOMEM);
+ sbi->ll_ra_stats = lprocfs_alloc_stats(ARRAY_SIZE(ra_stat_string),
+ LPROCFS_STATS_FLAG_NONE);
+ if (sbi->ll_ra_stats == NULL)
+ GOTO(out_stats, err = -ENOMEM);
- 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, 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");
+ debugfs_create_file("read_ahead_stats", 0644, sbi->ll_debugfs_entry,
+ sbi->ll_ra_stats, &ldebugfs_stats_seq_fops);
- err = lprocfs_add_vars(sbi->ll_proc_root, lprocfs_llite_obd_vars, sb);
+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 = &sbi_ktype;
+ init_completion(&sbi->ll_kobj_unregister);
+ err = kobject_set_name(&sbi->ll_kset.kobj, "%s", name);
if (err)
- GOTO(out, err);
+ GOTO(out_ra_stats, err);
- /* MDC info */
- obd = class_name2obd(mdc);
+ err = kset_register(&sbi->ll_kset);
+ if (err)
+ GOTO(out_ra_stats, err);
- LASSERT(obd != NULL);
- LASSERT(obd->obd_magic == OBD_DEVICE_MAGIC);
- LASSERT(obd->obd_type->typ_name != NULL);
+ lsi->lsi_kobj = kobject_get(&sbi->ll_kset.kobj);
- dir = proc_mkdir(obd->obd_type->typ_name, sbi->ll_proc_root);
- if (dir == NULL)
- GOTO(out, err = -ENOMEM);
+ RETURN(0);
+out_ra_stats:
+ lprocfs_free_stats(&sbi->ll_ra_stats);
+out_stats:
+ lprocfs_free_stats(&sbi->ll_stats);
+out_debugfs:
+ debugfs_remove_recursive(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);
+ RETURN(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);
+void ll_debugfs_unregister_super(struct super_block *sb)
+{
+ struct lustre_sb_info *lsi = s2lsi(sb);
+ struct ll_sb_info *sbi = ll_s2sbi(sb);
- /* OSC */
- obd = class_name2obd(osc);
+ debugfs_remove_recursive(sbi->ll_debugfs_entry);
- LASSERT(obd != NULL);
- LASSERT(obd->obd_magic == OBD_DEVICE_MAGIC);
- LASSERT(obd->obd_type->typ_name != NULL);
+ if (sbi->ll_dt_obd)
+ sysfs_remove_link(&sbi->ll_kset.kobj,
+ sbi->ll_dt_obd->obd_type->typ_name);
- dir = proc_mkdir(obd->obd_type->typ_name, sbi->ll_proc_root);
- if (dir == NULL)
- GOTO(out, err = -ENOMEM);
+ if (sbi->ll_md_obd)
+ sysfs_remove_link(&sbi->ll_kset.kobj,
+ sbi->ll_md_obd->obd_type->typ_name);
- 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);
+ kobject_put(lsi->lsi_kobj);
- snprintf(name, MAX_STRING_SIZE, "uuid");
- lvars[0].fops = &llite_uuid_fops;
- err = lprocfs_add_vars(dir, lvars, obd);
-out:
- if (err) {
- lprocfs_remove(&sbi->ll_proc_root);
- lprocfs_free_stats(&sbi->ll_ra_stats);
- lprocfs_free_stats(&sbi->ll_stats);
- }
- RETURN(err);
-}
+ kset_unregister(&sbi->ll_kset);
+ wait_for_completion(&sbi->ll_kobj_unregister);
-void lprocfs_unregister_mountpoint(struct ll_sb_info *sbi)
-{
- 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)
{
write_tot += pp_info->pp_w_hist.oh_buckets[i];
}
- for(i = 0; i < LL_HIST_MAX; i++) {
- r = pp_info->pp_r_hist.oh_buckets[i];
- 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,
- (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) {
- start = 1;
- units += 10;
- unitp++;
- }
- if (read_cum == read_tot && write_cum == write_tot)
- break;
- }
+ for(i = 0; i < LL_HIST_MAX; i++) {
+ r = pp_info->pp_r_hist.oh_buckets[i];
+ 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 %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)) {
+ start = 1;
+ units += 10;
+ unitp++;
+ }
+ if (read_cum == read_tot && write_cum == write_tot)
+ break;
+ }
}
static int ll_rw_extents_stats_pp_seq_show(struct seq_file *seq, void *v)
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)) &&
- (i < (LL_HIST_MAX - 1)); i++);
- if (rw == 0) {
- io_extents->pp_extents[cur].pp_r_hist.oh_buckets[i]++;
- io_extents->pp_extents[LL_PROCESS_HIST_MAX].pp_r_hist.oh_buckets[i]++;
- } else {
- io_extents->pp_extents[cur].pp_w_hist.oh_buckets[i]++;
- io_extents->pp_extents[LL_PROCESS_HIST_MAX].pp_w_hist.oh_buckets[i]++;
- }
+ for (i = 0; (count >= 1 << (LL_HIST_START + i)) &&
+ (i < (LL_HIST_MAX - 1)); i++);
+ if (rw == 0) {
+ io_extents->pp_extents[cur].pp_r_hist.oh_buckets[i]++;
+ io_extents->pp_extents[LL_PROCESS_HIST_MAX].pp_r_hist.oh_buckets[i]++;
+ } else {
+ io_extents->pp_extents[cur].pp_w_hist.oh_buckets[i]++;
+ io_extents->pp_extents[LL_PROCESS_HIST_MAX].pp_w_hist.oh_buckets[i]++;
+ }
spin_unlock(&sbi->ll_pp_extent_lock);
spin_lock(&sbi->ll_process_lock);
for (i = 0; i < LL_OFFSET_HIST_MAX; i++) {
if (offset[i].rw_pid != 0)
seq_printf(seq,
- "%3c %10d %14Lu %14Lu %17lu %17lu %14Lu",
+ "%3c %10d %14llu %14llu %17lu %17lu %14lld\n",
offset[i].rw_op == READ ? 'R' : 'W',
offset[i].rw_pid,
offset[i].rw_range_start,
for (i = 0; i < LL_PROCESS_HIST_MAX; i++) {
if (process[i].rw_pid != 0)
seq_printf(seq,
- "%3c %10d %14Lu %14Lu %17lu %17lu %14Lu",
+ "%3c %10d %14llu %14llu %17lu %17lu %14lld\n",
process[i].rw_op == READ ? 'R' : 'W',
process[i].rw_pid,
process[i].rw_range_start,
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)
-{
- __s64 value = 1;
- int rc;
- char kernbuf[16];
-
- rc = lprocfs_str_to_s64(buf, len, &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