X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fosd-zfs%2Fosd_lproc.c;h=f865343e976fc100dcb156cac81f2e5fd77ce391;hb=8a84c7f9c7d65f6f880be6fe4d94fca26a405d81;hp=0dfb483628b11ab94b1779a6d7234444accb1230;hpb=1cd2189806c82c31256c5ef9756d1dbf97784844;p=fs%2Flustre-release.git diff --git a/lustre/osd-zfs/osd_lproc.c b/lustre/osd-zfs/osd_lproc.c index 0dfb483..f865343 100644 --- a/lustre/osd-zfs/osd_lproc.c +++ b/lustre/osd-zfs/osd_lproc.c @@ -15,11 +15,7 @@ * * You should have received a copy of the GNU General Public License * version 2 along with this program; If not, see - * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf - * - * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, - * CA 95054 USA or visit www.sun.com if you need additional information or - * have any questions. + * http://www.gnu.org/licenses/gpl-2.0.html * * GPL HEADER END */ @@ -27,11 +23,10 @@ * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. * - * Copyright (c) 2012, 2015, 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. * * lustre/osd-zfs/osd_lproc.c * @@ -44,132 +39,17 @@ #include #include #include -#include +#include #include "osd_internal.h" -#ifdef CONFIG_PROC_FS - -#define pct(a, b) (b ? a * 100 / b : 0) - -static void display_brw_stats(struct seq_file *seq, char *name, char *units, - struct obd_histogram *read, - struct obd_histogram *write, int scale) -{ - unsigned long read_tot, write_tot, r, w, read_cum = 0, write_cum = 0; - int i; - - seq_printf(seq, "\n%26s read | write\n", " "); - seq_printf(seq, "%-22s %-5s %% cum %% | %-11s %% cum %%\n", - name, units, units); - - read_tot = lprocfs_oh_sum(read); - write_tot = lprocfs_oh_sum(write); - for (i = 0; i < OBD_HIST_MAX; i++) { - r = read->oh_buckets[i]; - w = write->oh_buckets[i]; - read_cum += r; - write_cum += w; - if (read_cum == 0 && write_cum == 0) - continue; - - if (!scale) - seq_printf(seq, "%u", i); - else if (i < 10) - seq_printf(seq, "%u", scale << i); - else if (i < 20) - seq_printf(seq, "%uK", scale << (i-10)); - else - seq_printf(seq, "%uM", scale << (i-20)); - - seq_printf(seq, ":\t\t%10lu %3lu %3lu | %4lu %3lu %3lu\n", - r, pct(r, read_tot), pct(read_cum, read_tot), - w, pct(w, write_tot), pct(write_cum, write_tot)); - - if (read_cum == read_tot && write_cum == write_tot) - break; - } -} - -static void brw_stats_show(struct seq_file *seq, struct brw_stats *brw_stats) -{ - struct timeval now; - - /* this sampling races with updates */ - do_gettimeofday(&now); - seq_printf(seq, "snapshot_time: %lu.%lu (secs.usecs)\n", - now.tv_sec, now.tv_usec); - - display_brw_stats(seq, "pages per bulk r/w", "rpcs", - &brw_stats->hist[BRW_R_PAGES], - &brw_stats->hist[BRW_W_PAGES], 1); - display_brw_stats(seq, "discontiguous pages", "rpcs", - &brw_stats->hist[BRW_R_DISCONT_PAGES], - &brw_stats->hist[BRW_W_DISCONT_PAGES], 0); -#if 0 - display_brw_stats(seq, "discontiguous blocks", "rpcs", - &brw_stats->hist[BRW_R_DISCONT_BLOCKS], - &brw_stats->hist[BRW_W_DISCONT_BLOCKS], 0); - - display_brw_stats(seq, "disk fragmented I/Os", "ios", - &brw_stats->hist[BRW_R_DIO_FRAGS], - &brw_stats->hist[BRW_W_DIO_FRAGS], 0); -#endif - display_brw_stats(seq, "disk I/Os in flight", "ios", - &brw_stats->hist[BRW_R_RPC_HIST], - &brw_stats->hist[BRW_W_RPC_HIST], 0); - - display_brw_stats(seq, "I/O time (1/1000s)", "ios", - &brw_stats->hist[BRW_R_IO_TIME], - &brw_stats->hist[BRW_W_IO_TIME], 1000 / HZ); - - display_brw_stats(seq, "disk I/O size", "ios", - &brw_stats->hist[BRW_R_DISK_IOSIZE], - &brw_stats->hist[BRW_W_DISK_IOSIZE], 1); -} - -#undef pct - -static int osd_brw_stats_seq_show(struct seq_file *seq, void *v) -{ - struct osd_device *osd = seq->private; - - brw_stats_show(seq, &osd->od_brw_stats); - - return 0; -} - -static ssize_t osd_brw_stats_seq_write(struct file *file, - const char __user *buf, - size_t len, loff_t *off) -{ - struct seq_file *seq = file->private_data; - struct osd_device *osd = seq->private; - int i; - - for (i = 0; i < BRW_LAST; i++) - lprocfs_oh_clear(&osd->od_brw_stats.hist[i]); - - return len; -} - -LPROC_SEQ_FOPS(osd_brw_stats); - static int osd_stats_init(struct osd_device *osd) { - int result, i; - ENTRY; - - for (i = 0; i < BRW_LAST; i++) - spin_lock_init(&osd->od_brw_stats.hist[i].oh_lock); + int result = -ENOMEM; + ENTRY; osd->od_stats = lprocfs_alloc_stats(LPROC_OSD_LAST, 0); - if (osd->od_stats != NULL) { - result = lprocfs_register_stats(osd->od_proc_entry, "stats", - osd->od_stats); - if (result) - GOTO(out, result); - + if (osd->od_stats) { lprocfs_counter_init(osd->od_stats, LPROC_OSD_GET_PAGE, LPROCFS_CNTR_AVGMINMAX|LPROCFS_CNTR_STDDEV, "get_page", "usec"); @@ -205,133 +85,308 @@ static int osd_stats_init(struct osd_device *osd) LPROCFS_CNTR_AVGMINMAX, "thandle_closing", "usec"); #endif - result = lprocfs_seq_create(osd->od_proc_entry, "brw_stats", - 0644, &osd_brw_stats_fops, osd); - } else { - result = -ENOMEM; + result = 0; } -out: + ldebugfs_register_osd_stats(osd->od_dt_dev.dd_debugfs_entry, + &osd->od_brw_stats, osd->od_stats); + /* These fields are not supported for ZFS */ + osd->od_brw_stats.bs_props[BRW_R_DISCONT_BLOCKS / 2].bsp_name = NULL; + osd->od_brw_stats.bs_props[BRW_R_DIO_FRAGS / 2].bsp_name = NULL; + RETURN(result); } -static int zfs_osd_fstype_seq_show(struct seq_file *m, void *data) +static int zfs_osd_oi_scrub_seq_show(struct seq_file *m, void *data) { - seq_puts(m, "zfs\n"); + struct osd_device *dev = osd_dt_dev((struct dt_device *)m->private); + + LASSERT(dev != NULL); + if (!dev->od_os) + return -EINPROGRESS; + + scrub_dump(m, &dev->od_scrub); return 0; } -LPROC_SEQ_FOPS_RO(zfs_osd_fstype); +LDEBUGFS_SEQ_FOPS_RO(zfs_osd_oi_scrub); -static int zfs_osd_mntdev_seq_show(struct seq_file *m, void *data) +static ssize_t auto_scrub_show(struct kobject *kobj, struct attribute *attr, + char *buf) { - struct osd_device *osd = osd_dt_dev((struct dt_device *)m->private); + struct dt_device *dt = container_of(kobj, struct dt_device, + dd_kobj); + struct osd_device *dev = osd_dt_dev(dt); - LASSERT(osd != NULL); - seq_printf(m, "%s\n", osd->od_mntdev); - return 0; + LASSERT(dev); + if (!dev->od_os) + return -EINPROGRESS; + + return scnprintf(buf, PAGE_SIZE, "%lld\n", + dev->od_scrub.os_auto_scrub_interval); } -LPROC_SEQ_FOPS_RO(zfs_osd_mntdev); -static ssize_t -lprocfs_osd_force_sync_seq_write(struct file *file, const char __user *buffer, - size_t count, loff_t *off) +static ssize_t auto_scrub_store(struct kobject *kobj, struct attribute *attr, + const char *buffer, size_t count) +{ + struct dt_device *dt = container_of(kobj, struct dt_device, + dd_kobj); + struct osd_device *dev = osd_dt_dev(dt); + s64 val; + int rc; + + LASSERT(dev); + if (!dev->od_os) + return -EINPROGRESS; + + rc = kstrtoull(buffer, 0, &val); + if (rc) + return rc; + + dev->od_scrub.os_auto_scrub_interval = val; + return count; +} +LUSTRE_RW_ATTR(auto_scrub); + +static ssize_t fstype_show(struct kobject *kobj, struct attribute *attr, + char *buf) { - struct seq_file *m = file->private_data; - struct dt_device *dt = m->private; - struct lu_env env; + return sprintf(buf, "zfs\n"); +} +LUSTRE_RO_ATTR(fstype); + +static ssize_t mntdev_show(struct kobject *kobj, struct attribute *attr, + char *buf) +{ + struct dt_device *dt = container_of(kobj, struct dt_device, + dd_kobj); + struct osd_device *osd = osd_dt_dev(dt); + + LASSERT(osd); + + return sprintf(buf, "%s\n", osd->od_mntdev); +} +LUSTRE_RO_ATTR(mntdev); + +ssize_t force_sync_store(struct kobject *kobj, struct attribute *attr, + const char *buffer, size_t count) +{ + struct dt_device *dt = container_of(kobj, struct dt_device, + dd_kobj); + struct lu_env env; int rc; rc = lu_env_init(&env, LCT_LOCAL); if (rc) return rc; + rc = dt_sync(&env, dt); lu_env_fini(&env); return rc == 0 ? count : rc; } -LPROC_SEQ_FOPS_WO_TYPE(zfs, osd_force_sync); +LUSTRE_WO_ATTR(force_sync); + +static ssize_t sync_on_lseek_show(struct kobject *kobj, struct attribute *attr, + char *buf) +{ + struct dt_device *dt = container_of(kobj, struct dt_device, dd_kobj); + struct osd_device *osd = osd_dt_dev(dt); + + if (!osd->od_os) + return -EINPROGRESS; + + return sprintf(buf, "%u\n", osd->od_sync_on_lseek); +} -static int zfs_osd_iused_est_seq_show(struct seq_file *m, void *data) +ssize_t sync_on_lseek_store(struct kobject *kobj, struct attribute *attr, + const char *buffer, size_t count) +{ + struct dt_device *dt = container_of(kobj, struct dt_device, dd_kobj); + struct osd_device *osd = osd_dt_dev(dt); + bool val; + int rc; + + if (!osd->od_os) + return -EINPROGRESS; + + rc = kstrtobool(buffer, &val); + if (rc) + return rc; + + osd->od_sync_on_lseek = !!val; + + return count; +} +LUSTRE_RW_ATTR(sync_on_lseek); + +static ssize_t nonrotational_show(struct kobject *kobj, struct attribute *attr, + char *buf) +{ + struct dt_device *dt = container_of(kobj, struct dt_device, + dd_kobj); + struct osd_device *osd = osd_dt_dev(dt); + + LASSERT(osd); + if (!osd->od_os) + return -EINPROGRESS; + + return sprintf(buf, "%u\n", osd->od_nonrotational); +} + +static ssize_t nonrotational_store(struct kobject *kobj, + struct attribute *attr, const char *buffer, + size_t count) +{ + struct dt_device *dt = container_of(kobj, struct dt_device, + dd_kobj); + struct osd_device *osd = osd_dt_dev(dt); + bool val; + int rc; + + LASSERT(osd); + if (!osd->od_os) + return -EINPROGRESS; + + rc = kstrtobool(buffer, &val); + if (rc) + return rc; + + osd->od_nonrotational = val; + return count; +} +LUSTRE_RW_ATTR(nonrotational); + +static ssize_t index_backup_show(struct kobject *kobj, struct attribute *attr, + char *buf) +{ + struct dt_device *dt = container_of(kobj, struct dt_device, + dd_kobj); + struct osd_device *dev = osd_dt_dev(dt); + + LASSERT(dev); + if (!dev->od_os) + return -EINPROGRESS; + + return sprintf(buf, "%d\n", dev->od_index_backup_policy); +} + +ssize_t index_backup_store(struct kobject *kobj, struct attribute *attr, + const char *buffer, size_t count) +{ + struct dt_device *dt = container_of(kobj, struct dt_device, + dd_kobj); + struct osd_device *dev = osd_dt_dev(dt); + int val; + int rc; + + LASSERT(dev); + if (!dev->od_os) + return -EINPROGRESS; + + rc = kstrtoint(buffer, 0, &val); + if (rc) + return rc; + + dev->od_index_backup_policy = val; + return count; +} +LUSTRE_RW_ATTR(index_backup); + +static int zfs_osd_readcache_seq_show(struct seq_file *m, void *data) { struct osd_device *osd = osd_dt_dev((struct dt_device *)m->private); + LASSERT(osd != NULL); + if (unlikely(osd->od_os == NULL)) + return -EINPROGRESS; - seq_printf(m, "%d\n", osd->od_quota_iused_est); + seq_printf(m, "%llu\n", osd->od_readcache_max_filesize); return 0; } static ssize_t -zfs_osd_iused_est_seq_write(struct file *file, const char __user *buffer, - size_t count, loff_t *off) +zfs_osd_readcache_seq_write(struct file *file, const char __user *buffer, + size_t count, loff_t *off) { struct seq_file *m = file->private_data; struct dt_device *dt = m->private; struct osd_device *osd = osd_dt_dev(dt); + char kernbuf[22] = ""; + u64 val; int rc; - __s64 val; LASSERT(osd != NULL); + if (unlikely(osd->od_os == NULL)) + return -EINPROGRESS; - rc = lprocfs_str_to_s64(buffer, count, &val); - if (rc) - return rc; + if (count >= sizeof(kernbuf)) + return -EINVAL; - osd->od_quota_iused_est = !!val; + if (copy_from_user(kernbuf, buffer, count)) + return -EFAULT; + kernbuf[count] = 0; + + rc = sysfs_memparse(kernbuf, count, &val, "B"); + if (rc < 0) + return rc; + osd->od_readcache_max_filesize = val > OSD_MAX_CACHE_SIZE ? + OSD_MAX_CACHE_SIZE : val; return count; } -LPROC_SEQ_FOPS(zfs_osd_iused_est); - -LPROC_SEQ_FOPS_RO_TYPE(zfs, dt_blksize); -LPROC_SEQ_FOPS_RO_TYPE(zfs, dt_kbytestotal); -LPROC_SEQ_FOPS_RO_TYPE(zfs, dt_kbytesfree); -LPROC_SEQ_FOPS_RO_TYPE(zfs, dt_kbytesavail); -LPROC_SEQ_FOPS_RO_TYPE(zfs, dt_filestotal); -LPROC_SEQ_FOPS_RO_TYPE(zfs, dt_filesfree); - -struct lprocfs_vars lprocfs_osd_obd_vars[] = { - { .name = "blocksize", - .fops = &zfs_dt_blksize_fops }, - { .name = "kbytestotal", - .fops = &zfs_dt_kbytestotal_fops }, - { .name = "kbytesfree", - .fops = &zfs_dt_kbytesfree_fops }, - { .name = "kbytesavail", - .fops = &zfs_dt_kbytesavail_fops }, - { .name = "filestotal", - .fops = &zfs_dt_filestotal_fops }, - { .name = "filesfree", - .fops = &zfs_dt_filesfree_fops }, - { .name = "fstype", - .fops = &zfs_osd_fstype_fops }, - { .name = "mntdev", - .fops = &zfs_osd_mntdev_fops }, - { .name = "force_sync", - .fops = &zfs_osd_force_sync_fops }, - { .name = "quota_iused_estimate", - .fops = &zfs_osd_iused_est_fops }, +LDEBUGFS_SEQ_FOPS(zfs_osd_readcache); + +static struct attribute *zfs_attrs[] = { + &lustre_attr_fstype.attr, + &lustre_attr_mntdev.attr, + &lustre_attr_force_sync.attr, + &lustre_attr_nonrotational.attr, + &lustre_attr_index_backup.attr, + &lustre_attr_auto_scrub.attr, + &lustre_attr_sync_on_lseek.attr, + NULL, +}; + +struct ldebugfs_vars ldebugfs_osd_obd_vars[] = { + { .name = "oi_scrub", + .fops = &zfs_osd_oi_scrub_fops }, + { .name = "readcache_max_filesize", + .fops = &zfs_osd_readcache_fops }, { 0 } }; int osd_procfs_init(struct osd_device *osd, const char *name) { struct obd_type *type; - int rc; - ENTRY; + int rc; - if (osd->od_proc_entry) - RETURN(0); + ENTRY; /* at the moment there is no linkage between lu_type - * and obd_type, so we lookup obd_type this way */ + * and obd_type, so we lookup obd_type this way + */ type = class_search_type(LUSTRE_OSD_ZFS_NAME); - LASSERT(name != NULL); - LASSERT(type != NULL); + LASSERT(type); + LASSERT(name); + + /* put reference taken by class_search_type */ + kobject_put(&type->typ_kobj); + + osd->od_dt_dev.dd_ktype.default_attrs = zfs_attrs; + rc = dt_tunables_init(&osd->od_dt_dev, type, name, + ldebugfs_osd_obd_vars); + if (rc) { + CERROR("%s: cannot setup sysfs / debugfs entry: %d\n", + name, rc); + GOTO(out, rc); + } + + if (osd->od_proc_entry) + RETURN(0); osd->od_proc_entry = lprocfs_register(name, type->typ_procroot, - lprocfs_osd_obd_vars, - &osd->od_dt_dev); + NULL, &osd->od_dt_dev); if (IS_ERR(osd->od_proc_entry)) { rc = PTR_ERR(osd->od_proc_entry); CERROR("Error %d setting up lprocfs for %s\n", rc, name); @@ -360,7 +415,5 @@ int osd_procfs_fini(struct osd_device *osd) osd->od_proc_entry = NULL; } - RETURN(0); + return dt_tunables_fini(&osd->od_dt_dev); } - -#endif