LXR linux/fs/fscache/histogram.c

   1/* FS-Cache latency histogram
   2 *
   3 * Copyright (C) 2008 Red Hat, Inc. All Rights Reserved.
   4 * Written by David Howells (dhowells@redhat.com)
   5 *
   6 * This program is free software; you can redistribute it and/or
   7 * modify it under the terms of the GNU General Public Licence
   8 * as published by the Free Software Foundation; either version
   9 * 2 of the Licence, or (at your option) any later version.
  10 */
  11
  12#define FSCACHE_DEBUG_LEVEL THREAD
  13#include <linux/module.h>
  14#include <linux/proc_fs.h>
  15#include <linux/seq_file.h>
  16#include "internal.h"
  17
  18atomic_t fscache_obj_instantiate_histogram[HZ];
  19atomic_t fscache_objs_histogram[HZ];
  20atomic_t fscache_ops_histogram[HZ];
  21atomic_t fscache_retrieval_delay_histogram[HZ];
  22atomic_t fscache_retrieval_histogram[HZ];
  23
  24/*
  25 * display the time-taken histogram
  26 */
  27static int fscache_histogram_show(struct seq_file *m, void *v)
  28{
  29        unsigned long index;
  30        unsigned n[5], t;
  31
  32        switch ((unsigned long) v) {
  33        case 1:
  34                seq_puts(m, "JIFS  SECS  OBJ INST  OP RUNS   OBJ RUNS "
  35                         " RETRV DLY RETRIEVLS\n");
  36                return 0;
  37        case 2:
  38                seq_puts(m, "===== ===== ========= ========= ========="
  39                         " ========= =========\n");
  40                return 0;
  41        default:
  42                index = (unsigned long) v - 3;
  43                n[0] = atomic_read(&fscache_obj_instantiate_histogram[index]);
  44                n[1] = atomic_read(&fscache_ops_histogram[index]);
  45                n[2] = atomic_read(&fscache_objs_histogram[index]);
  46                n[3] = atomic_read(&fscache_retrieval_delay_histogram[index]);
  47                n[4] = atomic_read(&fscache_retrieval_histogram[index]);
  48                if (!(n[0] | n[1] | n[2] | n[3] | n[4]))
  49                        return 0;
  50
  51                t = (index * 1000) / HZ;
  52
  53                seq_printf(m, "%4lu  0.%03u %9u %9u %9u %9u %9u\n",
  54                           index, t, n[0], n[1], n[2], n[3], n[4]);
  55                return 0;
  56        }
  57}
  58
  59/*
  60 * set up the iterator to start reading from the first line
  61 */
  62static void *fscache_histogram_start(struct seq_file *m, loff_t *_pos)
  63{
  64        if ((unsigned long long)*_pos >= HZ + 2)
  65                return NULL;
  66        if (*_pos == 0)
  67                *_pos = 1;
  68        return (void *)(unsigned long) *_pos;
  69}
  70
  71/*
  72 * move to the next line
  73 */
  74static void *fscache_histogram_next(struct seq_file *m, void *v, loff_t *pos)
  75{
  76        (*pos)++;
  77        return (unsigned long long)*pos > HZ + 2 ?
  78                NULL : (void *)(unsigned long) *pos;
  79}
  80
  81/*
  82 * clean up after reading
  83 */
  84static void fscache_histogram_stop(struct seq_file *m, void *v)
  85{
  86}
  87
  88static const struct seq_operations fscache_histogram_ops = {
  89        .start          = fscache_histogram_start,
  90        .stop           = fscache_histogram_stop,
  91        .next           = fscache_histogram_next,
  92        .show           = fscache_histogram_show,
  93};
  94
  95/*
  96 * open "/proc/fs/fscache/histogram" to provide latency data
  97 */
  98static int fscache_histogram_open(struct inode *inode, struct file *file)
  99{
 100        return seq_open(file, &fscache_histogram_ops);
 101}
 102
 103const struct file_operations fscache_histogram_fops = {
 104        .owner          = THIS_MODULE,
 105        .open           = fscache_histogram_open,
 106        .read           = seq_read,
 107        .llseek         = seq_lseek,
 108        .release        = seq_release,
 109};
 110