X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Fosd-ldiskfs%2Fosd_lproc.c;h=0c93d277a4929f0f8ee8e5db49606a984aa9c26c;hp=d50b52862b4b1fb09d46f246b5819eff75c6f6ae;hb=a48853cf3dc51b24cc276fcf5f2e3e25a32c0d25;hpb=e992a95314f9d6721144d5521ebe795a72bb140a diff --git a/lustre/osd-ldiskfs/osd_lproc.c b/lustre/osd-ldiskfs/osd_lproc.c index d50b528..0c93d27 100644 --- a/lustre/osd-ldiskfs/osd_lproc.c +++ b/lustre/osd-ldiskfs/osd_lproc.c @@ -1,6 +1,4 @@ -/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*- - * vim:expandtab:shiftwidth=8:tabstop=8: - * +/* * GPL HEADER START * * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. @@ -17,17 +15,15 @@ * * 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 */ /* * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. + * + * Copyright (c) 2011, 2015, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -38,216 +34,750 @@ * Author: Mikhail Pershin */ -#define DEBUG_SUBSYSTEM S_CLASS +#define DEBUG_SUBSYSTEM S_OSD #include -#include - -#include #include "osd_internal.h" -#ifdef LPROCFS -enum { - LPROC_OSD_NR -}; +#ifdef CONFIG_PROC_FS -static const char *osd_counter_names[LPROC_OSD_NR] = { -}; +void osd_brw_stats_update(struct osd_device *osd, struct osd_iobuf *iobuf) +{ + struct brw_stats *s = &osd->od_brw_stats; + sector_t *last_block = NULL; + struct page **pages = iobuf->dr_pages; + struct page *last_page = NULL; + unsigned long discont_pages = 0; + unsigned long discont_blocks = 0; + sector_t *blocks = iobuf->dr_blocks; + int i, nr_pages = iobuf->dr_npages; + int blocks_per_page; + int rw = iobuf->dr_rw; + + if (unlikely(nr_pages == 0)) + return; + + blocks_per_page = PAGE_SIZE >> osd_sb(osd)->s_blocksize_bits; + + lprocfs_oh_tally_log2(&s->hist[BRW_R_PAGES+rw], nr_pages); + + while (nr_pages-- > 0) { + if (last_page && (*pages)->index != (last_page->index + 1)) + discont_pages++; + last_page = *pages; + pages++; + for (i = 0; i < blocks_per_page; i++) { + if (last_block && *blocks != (*last_block + 1)) + discont_blocks++; + last_block = blocks++; + } + } -int osd_procfs_init(struct osd_device *osd, const char *name) + lprocfs_oh_tally(&s->hist[BRW_R_DISCONT_PAGES+rw], discont_pages); + lprocfs_oh_tally(&s->hist[BRW_R_DISCONT_BLOCKS+rw], discont_blocks); +} + +#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 lprocfs_static_vars lvars; - struct lu_device *ld = &osd->od_dt_dev.dd_lu_dev; - struct obd_type *type; - int rc; + struct timespec64 now; + + /* this sampling races with updates */ + ktime_get_real_ts64(&now); + + seq_printf(seq, "snapshot_time: %lld.%09ld (secs.nsecs)\n", + (s64)now.tv_sec, now.tv_nsec); + + 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); + + 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); + + 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], + jiffies_to_msecs(1000) / MSEC_PER_SEC); + + 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 i, result; ENTRY; - type = ld->ld_type->ldt_obd_type; - - LASSERT(name != NULL); - LASSERT(type != NULL); - - /* Find the type procroot and add the proc entry for this device */ - lprocfs_osd_init_vars(&lvars); - osd->od_proc_entry = lprocfs_register(name, type->typ_procroot, - lvars.obd_vars, osd); - 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); - osd->od_proc_entry = NULL; - GOTO(out, rc); - } + for (i = 0; i < BRW_LAST; i++) + spin_lock_init(&osd->od_brw_stats.hist[i].oh_lock); + + 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); + + lprocfs_counter_init(osd->od_stats, LPROC_OSD_GET_PAGE, + LPROCFS_CNTR_AVGMINMAX|LPROCFS_CNTR_STDDEV, + "get_page", "usec"); + lprocfs_counter_init(osd->od_stats, LPROC_OSD_NO_PAGE, + LPROCFS_CNTR_AVGMINMAX, + "get_page_failures", "num"); + lprocfs_counter_init(osd->od_stats, LPROC_OSD_CACHE_ACCESS, + LPROCFS_CNTR_AVGMINMAX, + "cache_access", "pages"); + lprocfs_counter_init(osd->od_stats, LPROC_OSD_CACHE_HIT, + LPROCFS_CNTR_AVGMINMAX, + "cache_hit", "pages"); + lprocfs_counter_init(osd->od_stats, LPROC_OSD_CACHE_MISS, + LPROCFS_CNTR_AVGMINMAX, + "cache_miss", "pages"); +#if OSD_THANDLE_STATS + lprocfs_counter_init(osd->od_stats, LPROC_OSD_THANDLE_STARTING, + LPROCFS_CNTR_AVGMINMAX, + "thandle starting", "usec"); + lprocfs_counter_init(osd->od_stats, LPROC_OSD_THANDLE_OPEN, + LPROCFS_CNTR_AVGMINMAX, + "thandle open", "usec"); + lprocfs_counter_init(osd->od_stats, LPROC_OSD_THANDLE_CLOSING, + 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; - rc = lu_time_init(&osd->od_stats, - osd->od_proc_entry, - osd_counter_names, ARRAY_SIZE(osd_counter_names)); - EXIT; out: - if (rc) - osd_procfs_fini(osd); - return rc; + RETURN(result); } -int osd_procfs_fini(struct osd_device *osd) +static int ldiskfs_osd_fstype_seq_show(struct seq_file *m, void *data) { - if (osd->od_stats) - lu_time_fini(&osd->od_stats); + struct osd_device *osd = osd_dt_dev((struct dt_device *)m->private); - if (osd->od_proc_entry) { - lprocfs_remove(&osd->od_proc_entry); - osd->od_proc_entry = NULL; - } - RETURN(0); + LASSERT(osd != NULL); + seq_puts(m, "ldiskfs\n"); + return 0; +} +LPROC_SEQ_FOPS_RO(ldiskfs_osd_fstype); + +static int ldiskfs_osd_mntdev_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_mnt == NULL)) + return -EINPROGRESS; + + seq_printf(m, "%s\n", osd->od_mntdev); + return 0; } +LPROC_SEQ_FOPS_RO(ldiskfs_osd_mntdev); -void osd_lprocfs_time_start(const struct lu_env *env) +static int ldiskfs_osd_cache_seq_show(struct seq_file *m, void *data) { - lu_lprocfs_time_start(env); + struct osd_device *osd = osd_dt_dev((struct dt_device *)m->private); + + LASSERT(osd != NULL); + if (unlikely(osd->od_mnt == NULL)) + return -EINPROGRESS; + + seq_printf(m, "%u\n", osd->od_read_cache); + return 0; } -void osd_lprocfs_time_end(const struct lu_env *env, struct osd_device *osd, - int idx) +static ssize_t +ldiskfs_osd_cache_seq_write(struct file *file, const char __user *buffer, + size_t count, loff_t *off) { - lu_lprocfs_time_end(env, osd->od_stats, idx); + struct seq_file *m = file->private_data; + struct dt_device *dt = m->private; + struct osd_device *osd = osd_dt_dev(dt); + int rc; + __s64 val; + + LASSERT(osd != NULL); + if (unlikely(osd->od_mnt == NULL)) + return -EINPROGRESS; + + rc = lprocfs_str_to_s64(buffer, count, &val); + if (rc) + return rc; + + osd->od_read_cache = !!val; + return count; } +LPROC_SEQ_FOPS(ldiskfs_osd_cache); +static int ldiskfs_osd_wcache_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_mnt == NULL)) + return -EINPROGRESS; + seq_printf(m, "%u\n", osd->od_writethrough_cache); + return 0; +} -int lprocfs_osd_rd_blksize(char *page, char **start, off_t off, int count, - int *eof, void *data) +static ssize_t +ldiskfs_osd_wcache_seq_write(struct file *file, const char __user *buffer, + size_t count, loff_t *off) { - struct osd_device *osd = data; - int rc = osd_statfs(NULL, &osd->od_dt_dev, &osd->od_kstatfs); - if (!rc) { - *eof = 1; - rc = snprintf(page, count, "%ld\n", osd->od_kstatfs.f_bsize); - } - return rc; + struct seq_file *m = file->private_data; + struct dt_device *dt = m->private; + struct osd_device *osd = osd_dt_dev(dt); + int rc; + __s64 val; + + LASSERT(osd != NULL); + if (unlikely(osd->od_mnt == NULL)) + return -EINPROGRESS; + + rc = lprocfs_str_to_s64(buffer, count, &val); + if (rc) + return rc; + + osd->od_writethrough_cache = !!val; + return count; } +LPROC_SEQ_FOPS(ldiskfs_osd_wcache); -int lprocfs_osd_rd_kbytestotal(char *page, char **start, off_t off, int count, - int *eof, void *data) +static ssize_t +lprocfs_osd_force_sync_seq_write(struct file *file, const char __user *buffer, + size_t count, loff_t *off) { - struct osd_device *osd = data; - int rc = osd_statfs(NULL, &osd->od_dt_dev, &osd->od_kstatfs); - if (!rc) { - __u32 blk_size = osd->od_kstatfs.f_bsize >> 10; - __u64 result = osd->od_kstatfs.f_blocks; + struct seq_file *m = file->private_data; + struct dt_device *dt = m->private; + struct osd_device *osd = osd_dt_dev(dt); + struct lu_env env; + int rc; + + LASSERT(osd != NULL); + if (unlikely(osd->od_mnt == NULL)) + return -EINPROGRESS; + + 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_WR_ONLY(ldiskfs, osd_force_sync); - while (blk_size >>= 1) - result <<= 1; +static int ldiskfs_osd_pdo_seq_show(struct seq_file *m, void *data) +{ + seq_printf(m, "%s\n", ldiskfs_pdo ? "ON" : "OFF"); + return 0; +} - *eof = 1; - rc = snprintf(page, count, LPU64"\n", result); - } - return rc; +static ssize_t +ldiskfs_osd_pdo_seq_write(struct file *file, const char __user *buffer, + size_t count, loff_t *off) +{ + int rc; + __s64 pdo; + + rc = lprocfs_str_to_s64(buffer, count, &pdo); + if (rc != 0) + return rc; + + ldiskfs_pdo = !!pdo; + + return count; } +LPROC_SEQ_FOPS(ldiskfs_osd_pdo); -int lprocfs_osd_rd_kbytesfree(char *page, char **start, off_t off, int count, - int *eof, void *data) +static int ldiskfs_osd_auto_scrub_seq_show(struct seq_file *m, void *data) { - struct osd_device *osd = data; - int rc = osd_statfs(NULL, &osd->od_dt_dev, &osd->od_kstatfs); - if (!rc) { - __u32 blk_size = osd->od_kstatfs.f_bsize >> 10; - __u64 result = osd->od_kstatfs.f_bfree; + struct osd_device *dev = osd_dt_dev((struct dt_device *)m->private); - while (blk_size >>= 1) - result <<= 1; + LASSERT(dev != NULL); + if (unlikely(dev->od_mnt == NULL)) + return -EINPROGRESS; - *eof = 1; - rc = snprintf(page, count, LPU64"\n", result); - } - return rc; + seq_printf(m, "%lld\n", dev->od_auto_scrub_interval); + return 0; } -int lprocfs_osd_rd_kbytesavail(char *page, char **start, off_t off, int count, - int *eof, void *data) +static ssize_t +ldiskfs_osd_auto_scrub_seq_write(struct file *file, const char __user *buffer, + size_t count, loff_t *off) { - struct osd_device *osd = data; - int rc = osd_statfs(NULL, &osd->od_dt_dev, &osd->od_kstatfs); - if (!rc) { - __u32 blk_size = osd->od_kstatfs.f_bsize >> 10; - __u64 result = osd->od_kstatfs.f_bavail; + struct seq_file *m = file->private_data; + struct dt_device *dt = m->private; + struct osd_device *dev = osd_dt_dev(dt); + int rc; + __s64 val; + + LASSERT(dev != NULL); + if (unlikely(dev->od_mnt == NULL)) + return -EINPROGRESS; + + rc = lprocfs_str_to_s64(buffer, count, &val); + if (rc) + return rc; + + dev->od_auto_scrub_interval = val; + return count; +} +LPROC_SEQ_FOPS(ldiskfs_osd_auto_scrub); - while (blk_size >>= 1) - result <<= 1; +static int ldiskfs_osd_full_scrub_ratio_seq_show(struct seq_file *m, void *data) +{ + struct osd_device *dev = osd_dt_dev((struct dt_device *)m->private); - *eof = 1; - rc = snprintf(page, count, LPU64"\n", result); - } - return rc; + LASSERT(dev != NULL); + if (unlikely(dev->od_mnt == NULL)) + return -EINPROGRESS; + + seq_printf(m, "%llu\n", dev->od_full_scrub_ratio); + return 0; } -int lprocfs_osd_rd_filestotal(char *page, char **start, off_t off, int count, - int *eof, void *data) +static ssize_t +ldiskfs_osd_full_scrub_ratio_seq_write(struct file *file, + const char __user *buffer, + size_t count, loff_t *off) { - struct osd_device *osd = data; - int rc = osd_statfs(NULL, &osd->od_dt_dev, &osd->od_kstatfs); - if (!rc) { - *eof = 1; - rc = snprintf(page, count, LPU64"\n", osd->od_kstatfs.f_files); - } + struct seq_file *m = file->private_data; + struct dt_device *dt = m->private; + struct osd_device *dev = osd_dt_dev(dt); + int rc; + __s64 val; + + LASSERT(dev != NULL); + if (unlikely(dev->od_mnt == NULL)) + return -EINPROGRESS; + + rc = lprocfs_str_to_s64(buffer, count, &val); + if (rc != 0) + return rc; - return rc; + if (val < 0) + return -EINVAL; + + dev->od_full_scrub_ratio = val; + return count; } +LPROC_SEQ_FOPS(ldiskfs_osd_full_scrub_ratio); -int lprocfs_osd_rd_filesfree(char *page, char **start, off_t off, int count, - int *eof, void *data) +static int ldiskfs_osd_full_scrub_threshold_rate_seq_show(struct seq_file *m, + void *data) { - struct osd_device *osd = data; - int rc = osd_statfs(NULL, &osd->od_dt_dev, &osd->od_kstatfs); - if (!rc) { - *eof = 1; - rc = snprintf(page, count, LPU64"\n", osd->od_kstatfs.f_ffree); - } - return rc; + struct osd_device *dev = osd_dt_dev((struct dt_device *)m->private); + + LASSERT(dev != NULL); + if (unlikely(dev->od_mnt == NULL)) + return -EINPROGRESS; + + seq_printf(m, "%llu (bad OI mappings/minute)\n", + dev->od_full_scrub_threshold_rate); + return 0; +} + +static ssize_t +ldiskfs_osd_full_scrub_threshold_rate_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 *dev = osd_dt_dev(dt); + int rc; + __s64 val; + + LASSERT(dev != NULL); + if (unlikely(dev->od_mnt == NULL)) + return -EINPROGRESS; + + rc = lprocfs_str_to_s64(buffer, count, &val); + if (rc != 0) + return rc; + + if (val < 0) + return -EINVAL; + + dev->od_full_scrub_threshold_rate = val; + return count; +} +LPROC_SEQ_FOPS(ldiskfs_osd_full_scrub_threshold_rate); + +static int +ldiskfs_osd_track_declares_assert_seq_show(struct seq_file *m, void *data) +{ + seq_printf(m, "%d\n", ldiskfs_track_declares_assert); + return 0; +} + +static ssize_t +ldiskfs_osd_track_declares_assert_seq_write(struct file *file, + const char __user *buffer, + size_t count, loff_t *off) +{ + __s64 track_declares_assert; + int rc; + + rc = lprocfs_str_to_s64(buffer, count, &track_declares_assert); + if (rc != 0) + return rc; + + ldiskfs_track_declares_assert = !!track_declares_assert; + + return count; +} +LPROC_SEQ_FOPS(ldiskfs_osd_track_declares_assert); + +static int ldiskfs_osd_oi_scrub_seq_show(struct seq_file *m, void *data) +{ + struct osd_device *dev = osd_dt_dev((struct dt_device *)m->private); + + LASSERT(dev != NULL); + if (unlikely(dev->od_mnt == NULL)) + return -EINPROGRESS; + + osd_scrub_dump(m, dev); + return 0; +} +LPROC_SEQ_FOPS_RO(ldiskfs_osd_oi_scrub); + +static int ldiskfs_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_mnt == NULL)) + return -EINPROGRESS; + + seq_printf(m, "%llu\n", osd->od_readcache_max_filesize); + return 0; +} + +static ssize_t +ldiskfs_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); + __s64 val; + int rc; + + LASSERT(osd != NULL); + if (unlikely(osd->od_mnt == NULL)) + return -EINPROGRESS; + + rc = lprocfs_str_with_units_to_s64(buffer, count, &val, '1'); + if (rc) + return rc; + if (val < 0) + return -ERANGE; + + osd->od_readcache_max_filesize = val > OSD_MAX_CACHE_SIZE ? + OSD_MAX_CACHE_SIZE : val; + return count; +} +LPROC_SEQ_FOPS(ldiskfs_osd_readcache); + +#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(3, 0, 52, 0) +static int ldiskfs_osd_index_in_idif_seq_show(struct seq_file *m, void *data) +{ + struct osd_device *dev = osd_dt_dev((struct dt_device *)m->private); + + LASSERT(dev != NULL); + if (unlikely(dev->od_mnt == NULL)) + return -EINPROGRESS; + + seq_printf(m, "%d\n", (int)(dev->od_index_in_idif)); + return 0; +} + +static ssize_t +ldiskfs_osd_index_in_idif_seq_write(struct file *file, + const char __user *buffer, + size_t count, loff_t *off) +{ + struct lu_env env; + struct seq_file *m = file->private_data; + struct dt_device *dt = m->private; + struct osd_device *dev = osd_dt_dev(dt); + struct lu_target *tgt; + __s64 val; + int rc; + + LASSERT(dev != NULL); + if (unlikely(dev->od_mnt == NULL)) + return -EINPROGRESS; + + rc = lprocfs_str_to_s64(buffer, count, &val); + if (rc != 0) + return rc; + + if (dev->od_index_in_idif) { + if (val != 0) + return count; + + LCONSOLE_WARN("%s: OST-index in IDIF has been enabled, " + "it cannot be reverted back.\n", osd_name(dev)); + return -EPERM; + } + + if (val == 0) + return count; + + rc = lu_env_init(&env, LCT_DT_THREAD); + if (rc != 0) + return rc; + + tgt = dev->od_dt_dev.dd_lu_dev.ld_site->ls_tgt; + tgt->lut_lsd.lsd_feature_rocompat |= OBD_ROCOMPAT_IDX_IN_IDIF; + rc = tgt_server_data_update(&env, tgt, 1); + lu_env_fini(&env); + if (rc < 0) + return rc; + + LCONSOLE_INFO("%s: enable OST-index in IDIF successfully, " + "it cannot be reverted back.\n", osd_name(dev)); + + dev->od_index_in_idif = 1; + return count; } +LPROC_SEQ_FOPS(ldiskfs_osd_index_in_idif); -int lprocfs_osd_rd_fstype(char *page, char **start, off_t off, int count, - int *eof, void *data) +int osd_register_proc_index_in_idif(struct osd_device *osd) { - struct obd_device *osd = data; + struct proc_dir_entry *proc; + + proc = proc_create_data("index_in_idif", 0, osd->od_proc_entry, + &ldiskfs_osd_index_in_idif_fops, + &osd->od_dt_dev); + if (proc == NULL) + return -ENOMEM; - LASSERT(osd != NULL); - return snprintf(page, count, "ldiskfs\n"); + return 0; } +#endif -static int lprocfs_osd_rd_mntdev(char *page, char **start, off_t off, int count, - int *eof, void *data) +static int ldiskfs_osd_index_backup_seq_show(struct seq_file *m, void *data) { - struct osd_device *osd = data; + struct osd_device *dev = osd_dt_dev((struct dt_device *)m->private); + + LASSERT(dev != NULL); + if (unlikely(dev->od_mnt == NULL)) + return -EINPROGRESS; - LASSERT(osd != NULL); - LASSERT(osd->od_mount->lmi_mnt->mnt_devname); - *eof = 1; + seq_printf(m, "%d\n", dev->od_index_backup_policy); + return 0; +} - return snprintf(page, count, "%s\n", - osd->od_mount->lmi_mnt->mnt_devname); +static ssize_t ldiskfs_osd_index_backup_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 *dev = osd_dt_dev(dt); + __s64 val; + int rc; + + LASSERT(dev != NULL); + if (unlikely(dev->od_mnt == NULL)) + return -EINPROGRESS; + + rc = lprocfs_str_to_s64(buffer, count, &val); + if (rc) + return rc; + + dev->od_index_backup_policy = val; + return count; } +LPROC_SEQ_FOPS(ldiskfs_osd_index_backup); + +LPROC_SEQ_FOPS_RO_TYPE(ldiskfs, dt_blksize); +LPROC_SEQ_FOPS_RO_TYPE(ldiskfs, dt_kbytestotal); +LPROC_SEQ_FOPS_RO_TYPE(ldiskfs, dt_kbytesfree); +LPROC_SEQ_FOPS_RO_TYPE(ldiskfs, dt_kbytesavail); +LPROC_SEQ_FOPS_RO_TYPE(ldiskfs, dt_filestotal); +LPROC_SEQ_FOPS_RO_TYPE(ldiskfs, dt_filesfree); struct lprocfs_vars lprocfs_osd_obd_vars[] = { - { "blocksize", lprocfs_osd_rd_blksize, 0, 0 }, - { "kbytestotal", lprocfs_osd_rd_kbytestotal, 0, 0 }, - { "kbytesfree", lprocfs_osd_rd_kbytesfree, 0, 0 }, - { "kbytesavail", lprocfs_osd_rd_kbytesavail, 0, 0 }, - { "filestotal", lprocfs_osd_rd_filestotal, 0, 0 }, - { "filesfree", lprocfs_osd_rd_filesfree, 0, 0 }, - { "fstype", lprocfs_osd_rd_fstype, 0, 0 }, - { "mntdev", lprocfs_osd_rd_mntdev, 0, 0 }, - { 0 } + { .name = "blocksize", + .fops = &ldiskfs_dt_blksize_fops }, + { .name = "kbytestotal", + .fops = &ldiskfs_dt_kbytestotal_fops }, + { .name = "kbytesfree", + .fops = &ldiskfs_dt_kbytesfree_fops }, + { .name = "kbytesavail", + .fops = &ldiskfs_dt_kbytesavail_fops }, + { .name = "filestotal", + .fops = &ldiskfs_dt_filestotal_fops }, + { .name = "filesfree", + .fops = &ldiskfs_dt_filesfree_fops }, + { .name = "fstype", + .fops = &ldiskfs_osd_fstype_fops }, + { .name = "mntdev", + .fops = &ldiskfs_osd_mntdev_fops }, + { .name = "force_sync", + .fops = &ldiskfs_osd_force_sync_fops }, + { .name = "pdo", + .fops = &ldiskfs_osd_pdo_fops }, + { .name = "auto_scrub", + .fops = &ldiskfs_osd_auto_scrub_fops }, + { .name = "full_scrub_ratio", + .fops = &ldiskfs_osd_full_scrub_ratio_fops }, + { .name = "full_scrub_threshold_rate", + .fops = &ldiskfs_osd_full_scrub_threshold_rate_fops }, + { .name = "oi_scrub", + .fops = &ldiskfs_osd_oi_scrub_fops }, + { .name = "read_cache_enable", + .fops = &ldiskfs_osd_cache_fops }, + { .name = "writethrough_cache_enable", + .fops = &ldiskfs_osd_wcache_fops }, + { .name = "readcache_max_filesize", + .fops = &ldiskfs_osd_readcache_fops }, + { .name = "index_backup", + .fops = &ldiskfs_osd_index_backup_fops }, + { NULL } }; struct lprocfs_vars lprocfs_osd_module_vars[] = { - { "num_refs", lprocfs_rd_numrefs, 0, 0 }, - { 0 } + { .name = "track_declares_assert", + .fops = &ldiskfs_osd_track_declares_assert_fops }, + { NULL } }; -void lprocfs_osd_init_vars(struct lprocfs_static_vars *lvars) + +int osd_procfs_init(struct osd_device *osd, const char *name) +{ + struct obd_type *type; + int rc; + ENTRY; + + if (osd->od_proc_entry) + RETURN(0); + + /* at the moment there is no linkage between lu_type + * and obd_type, so we lookup obd_type this way */ + type = class_search_type(LUSTRE_OSD_LDISKFS_NAME); + + LASSERT(name != NULL); + LASSERT(type != NULL); + + /* Find the type procroot and add the proc entry for this device */ + osd->od_proc_entry = lprocfs_register(name, type->typ_procroot, + lprocfs_osd_obd_vars, + &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); + osd->od_proc_entry = NULL; + GOTO(out, rc); + } + + rc = osd_stats_init(osd); + + EXIT; +out: + if (rc) + osd_procfs_fini(osd); + return rc; +} + +int osd_procfs_fini(struct osd_device *osd) { - lvars->module_vars = lprocfs_osd_module_vars; - lvars->obd_vars = lprocfs_osd_obd_vars; + if (osd->od_stats) + lprocfs_free_stats(&osd->od_stats); + + if (osd->od_proc_entry) + lprocfs_remove(&osd->od_proc_entry); + RETURN(0); } #endif