LXR linux/drivers/md/bcache/stats.c

   1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * bcache stats code
   4 *
   5 * Copyright 2012 Google, Inc.
   6 */
   7
   8#include "bcache.h"
   9#include "stats.h"
  10#include "btree.h"
  11#include "sysfs.h"
  12
  13/*
  14 * We keep absolute totals of various statistics, and addionally a set of three
  15 * rolling averages.
  16 *
  17 * Every so often, a timer goes off and rescales the rolling averages.
  18 * accounting_rescale[] is how many times the timer has to go off before we
  19 * rescale each set of numbers; that gets us half lives of 5 minutes, one hour,
  20 * and one day.
  21 *
  22 * accounting_delay is how often the timer goes off - 22 times in 5 minutes,
  23 * and accounting_weight is what we use to rescale:
  24 *
  25 * pow(31 / 32, 22) ~= 1/2
  26 *
  27 * So that we don't have to increment each set of numbers every time we (say)
  28 * get a cache hit, we increment a single atomic_t in acc->collector, and when
  29 * the rescale function runs it resets the atomic counter to 0 and adds its
  30 * old value to each of the exported numbers.
  31 *
  32 * To reduce rounding error, the numbers in struct cache_stats are all
  33 * stored left shifted by 16, and scaled back in the sysfs show() function.
  34 */
  35
  36static const unsigned int DAY_RESCALE           = 288;
  37static const unsigned int HOUR_RESCALE          = 12;
  38static const unsigned int FIVE_MINUTE_RESCALE   = 1;
  39static const unsigned int accounting_delay      = (HZ * 300) / 22;
  40static const unsigned int accounting_weight     = 32;
  41
  42/* sysfs reading/writing */
  43
  44read_attribute(cache_hits);
  45read_attribute(cache_misses);
  46read_attribute(cache_bypass_hits);
  47read_attribute(cache_bypass_misses);
  48read_attribute(cache_hit_ratio);
  49read_attribute(cache_readaheads);
  50read_attribute(cache_miss_collisions);
  51read_attribute(bypassed);
  52
  53SHOW(bch_stats)
  54{
  55        struct cache_stats *s =
  56                container_of(kobj, struct cache_stats, kobj);
  57#define var(stat)               (s->stat >> 16)
  58        var_print(cache_hits);
  59        var_print(cache_misses);
  60        var_print(cache_bypass_hits);
  61        var_print(cache_bypass_misses);
  62
  63        sysfs_print(cache_hit_ratio,
  64                    DIV_SAFE(var(cache_hits) * 100,
  65                             var(cache_hits) + var(cache_misses)));
  66
  67        var_print(cache_readaheads);
  68        var_print(cache_miss_collisions);
  69        sysfs_hprint(bypassed,  var(sectors_bypassed) << 9);
  70#undef var
  71        return 0;
  72}
  73
  74STORE(bch_stats)
  75{
  76        return size;
  77}
  78
  79static void bch_stats_release(struct kobject *k)
  80{
  81}
  82
  83static struct attribute *bch_stats_files[] = {
  84        &sysfs_cache_hits,
  85        &sysfs_cache_misses,
  86        &sysfs_cache_bypass_hits,
  87        &sysfs_cache_bypass_misses,
  88        &sysfs_cache_hit_ratio,
  89        &sysfs_cache_readaheads,
  90        &sysfs_cache_miss_collisions,
  91        &sysfs_bypassed,
  92        NULL
  93};
  94static KTYPE(bch_stats);
  95
  96int bch_cache_accounting_add_kobjs(struct cache_accounting *acc,
  97                                   struct kobject *parent)
  98{
  99        int ret = kobject_add(&acc->total.kobj, parent,
 100                              "stats_total");
 101        ret = ret ?: kobject_add(&acc->five_minute.kobj, parent,
 102                                 "stats_five_minute");
 103        ret = ret ?: kobject_add(&acc->hour.kobj, parent,
 104                                 "stats_hour");
 105        ret = ret ?: kobject_add(&acc->day.kobj, parent,
 106                                 "stats_day");
 107        return ret;
 108}
 109
 110void bch_cache_accounting_clear(struct cache_accounting *acc)
 111{
 112        acc->total.cache_hits = 0;
 113        acc->total.cache_misses = 0;
 114        acc->total.cache_bypass_hits = 0;
 115        acc->total.cache_bypass_misses = 0;
 116        acc->total.cache_readaheads = 0;
 117        acc->total.cache_miss_collisions = 0;
 118        acc->total.sectors_bypassed = 0;
 119}
 120
 121void bch_cache_accounting_destroy(struct cache_accounting *acc)
 122{
 123        kobject_put(&acc->total.kobj);
 124        kobject_put(&acc->five_minute.kobj);
 125        kobject_put(&acc->hour.kobj);
 126        kobject_put(&acc->day.kobj);
 127
 128        atomic_set(&acc->closing, 1);
 129        if (del_timer_sync(&acc->timer))
 130                closure_return(&acc->cl);
 131}
 132
 133/* EWMA scaling */
 134
 135static void scale_stat(unsigned long *stat)
 136{
 137        *stat =  ewma_add(*stat, 0, accounting_weight, 0);
 138}
 139
 140static void scale_stats(struct cache_stats *stats, unsigned long rescale_at)
 141{
 142        if (++stats->rescale == rescale_at) {
 143                stats->rescale = 0;
 144                scale_stat(&stats->cache_hits);
 145                scale_stat(&stats->cache_misses);
 146                scale_stat(&stats->cache_bypass_hits);
 147                scale_stat(&stats->cache_bypass_misses);
 148                scale_stat(&stats->cache_readaheads);
 149                scale_stat(&stats->cache_miss_collisions);
 150                scale_stat(&stats->sectors_bypassed);
 151        }
 152}
 153
 154static void scale_accounting(struct timer_list *t)
 155{
 156        struct cache_accounting *acc = from_timer(acc, t, timer);
 157
 158#define move_stat(name) do {                                            \
 159        unsigned int t = atomic_xchg(&acc->collector.name, 0);          \
 160        t <<= 16;                                                       \
 161        acc->five_minute.name += t;                                     \
 162        acc->hour.name += t;                                            \
 163        acc->day.name += t;                                             \
 164        acc->total.name += t;                                           \
 165} while (0)
 166
 167        move_stat(cache_hits);
 168        move_stat(cache_misses);
 169        move_stat(cache_bypass_hits);
 170        move_stat(cache_bypass_misses);
 171        move_stat(cache_readaheads);
 172        move_stat(cache_miss_collisions);
 173        move_stat(sectors_bypassed);
 174
 175        scale_stats(&acc->total, 0);
 176        scale_stats(&acc->day, DAY_RESCALE);
 177        scale_stats(&acc->hour, HOUR_RESCALE);
 178        scale_stats(&acc->five_minute, FIVE_MINUTE_RESCALE);
 179
 180        acc->timer.expires += accounting_delay;
 181
 182        if (!atomic_read(&acc->closing))
 183                add_timer(&acc->timer);
 184        else
 185                closure_return(&acc->cl);
 186}
 187
 188static void mark_cache_stats(struct cache_stat_collector *stats,
 189                             bool hit, bool bypass)
 190{
 191        if (!bypass)
 192                if (hit)
 193                        atomic_inc(&stats->cache_hits);
 194                else
 195                        atomic_inc(&stats->cache_misses);
 196        else
 197                if (hit)
 198                        atomic_inc(&stats->cache_bypass_hits);
 199                else
 200                        atomic_inc(&stats->cache_bypass_misses);
 201}
 202
 203void bch_mark_cache_accounting(struct cache_set *c, struct bcache_device *d,
 204                               bool hit, bool bypass)
 205{
 206        struct cached_dev *dc = container_of(d, struct cached_dev, disk);
 207
 208        mark_cache_stats(&dc->accounting.collector, hit, bypass);
 209        mark_cache_stats(&c->accounting.collector, hit, bypass);
 210}
 211
 212void bch_mark_cache_readahead(struct cache_set *c, struct bcache_device *d)
 213{
 214        struct cached_dev *dc = container_of(d, struct cached_dev, disk);
 215
 216        atomic_inc(&dc->accounting.collector.cache_readaheads);
 217        atomic_inc(&c->accounting.collector.cache_readaheads);
 218}
 219
 220void bch_mark_cache_miss_collision(struct cache_set *c, struct bcache_device *d)
 221{
 222        struct cached_dev *dc = container_of(d, struct cached_dev, disk);
 223
 224        atomic_inc(&dc->accounting.collector.cache_miss_collisions);
 225        atomic_inc(&c->accounting.collector.cache_miss_collisions);
 226}
 227
 228void bch_mark_sectors_bypassed(struct cache_set *c, struct cached_dev *dc,
 229                               int sectors)
 230{
 231        atomic_add(sectors, &dc->accounting.collector.sectors_bypassed);
 232        atomic_add(sectors, &c->accounting.collector.sectors_bypassed);
 233}
 234
 235void bch_cache_accounting_init(struct cache_accounting *acc,
 236                               struct closure *parent)
 237{
 238        kobject_init(&acc->total.kobj,          &bch_stats_ktype);
 239        kobject_init(&acc->five_minute.kobj,    &bch_stats_ktype);
 240        kobject_init(&acc->hour.kobj,           &bch_stats_ktype);
 241        kobject_init(&acc->day.kobj,            &bch_stats_ktype);
 242
 243        closure_init(&acc->cl, parent);
 244        timer_setup(&acc->timer, scale_accounting, 0);
 245        acc->timer.expires      = jiffies + accounting_delay;
 246        add_timer(&acc->timer);
 247}
 248