X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Fosd-ldiskfs%2Fosd_lproc.c;h=2bc3f372e0b756c8e82ba90f633b881b84a3ffc2;hp=6f1bbacd800460de0eb1b6220252f653e9a927b6;hb=67076c3c7e2b11023b943db2f5031d9b9a11329c;hpb=8e858671be59ed53fad2d340cf841b026943cc8a;ds=sidebyside diff --git a/lustre/osd-ldiskfs/osd_lproc.c b/lustre/osd-ldiskfs/osd_lproc.c index 6f1bbac..2bc3f37 100644 --- a/lustre/osd-ldiskfs/osd_lproc.c +++ b/lustre/osd-ldiskfs/osd_lproc.c @@ -28,6 +28,8 @@ /* * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. + * + * Copyright (c) 2011, Whamcloud, Inc. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -49,7 +51,197 @@ #ifdef LPROCFS -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; + unsigned long *last_block = NULL; + struct page **pages = iobuf->dr_pages; + struct page *last_page = NULL; + unsigned long discont_pages = 0; + unsigned long discont_blocks = 0; + unsigned long *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 = CFS_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++; + } + } + + 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 timeval now; + + /* this sampling races with updates */ + cfs_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); + + 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], 1000 / CFS_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 *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; + + for (i = 0; i < BRW_LAST; i++) + cfs_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 + lprocfs_seq_create(osd->od_proc_entry, "brw_stats", + 0444, &osd_brw_stats_fops, osd); + } else + result = -ENOMEM; + +out: + RETURN(result); +} + +static const char *osd_counter_names[] = { #if OSD_THANDLE_STATS [LPROC_OSD_THANDLE_STARTING] = "thandle starting", [LPROC_OSD_THANDLE_OPEN] = "thandle open", @@ -85,6 +277,9 @@ int osd_procfs_init(struct osd_device *osd, const char *name) rc = lu_time_init(&osd->od_stats, osd->od_proc_entry, osd_counter_names, ARRAY_SIZE(osd_counter_names)); + + rc = osd_stats_init(osd); + EXIT; out: if (rc)