// SPDX-License-Identifier: GPL-2.0
/*
 * bcache stats code
 *
 * Copyright 2012 Google, Inc.
 */

#include "bcache.h"
#include "stats.h"
#include "btree.h"
#include "sysfs.h"

/*
 * We keep absolute totals of various statistics, and addionally a set of three
 * rolling averages.
 *
 * Every so often, a timer goes off and rescales the rolling averages.
 * accounting_rescale[] is how many times the timer has to go off before we
 * rescale each set of numbers; that gets us half lives of 5 minutes, one hour,
 * and one day.
 *
 * accounting_delay is how often the timer goes off - 22 times in 5 minutes,
 * and accounting_weight is what we use to rescale:
 *
 * pow(31 / 32, 22) ~= 1/2
 *
 * So that we don't have to increment each set of numbers every time we (say)
 * get a cache hit, we increment a single atomic_t in acc->collector, and when
 * the rescale function runs it resets the atomic counter to 0 and adds its
 * old value to each of the exported numbers.
 *
 * To reduce rounding error, the numbers in struct cache_stats are all
 * stored left shifted by 16, and scaled back in the sysfs show() function.
 */

static const unsigned int DAY_RESCALE           = 288;
static const unsigned int HOUR_RESCALE          = 12;
static const unsigned int FIVE_MINUTE_RESCALE   = 1;
static const unsigned int accounting_delay      = (HZ * 300) / 22;
static const unsigned int accounting_weight     = 32;

/* sysfs reading/writing */

read_attribute(cache_hits);
read_attribute(cache_misses);
read_attribute(cache_bypass_hits);
read_attribute(cache_bypass_misses);
read_attribute(cache_hit_ratio);
read_attribute(cache_miss_collisions);
read_attribute(bypassed);

SHOW(bch_stats)
{
        struct cache_stats *s =
                container_of(kobj, struct cache_stats, kobj);
#define var(stat)               (s->stat >> 16)
        var_print(cache_hits);
        var_print(cache_misses);
        var_print(cache_bypass_hits);
        var_print(cache_bypass_misses);

        sysfs_print(cache_hit_ratio,
                    DIV_SAFE(var(cache_hits) * 100,
                             var(cache_hits) + var(cache_misses)));

        var_print(cache_miss_collisions);
        sysfs_hprint(bypassed,  var(sectors_bypassed) << 9);
#undef var
        return 0;
}

STORE(bch_stats)
{
        return size;
}

static void bch_stats_release(struct kobject *k)
{
}

static struct attribute *bch_stats_attrs[] = {
        &sysfs_cache_hits,
        &sysfs_cache_misses,
        &sysfs_cache_bypass_hits,
        &sysfs_cache_bypass_misses,
        &sysfs_cache_hit_ratio,
        &sysfs_cache_miss_collisions,
        &sysfs_bypassed,
        NULL
};
ATTRIBUTE_GROUPS(bch_stats);
static KTYPE(bch_stats);

int bch_cache_accounting_add_kobjs(struct cache_accounting *acc,
                                   struct kobject *parent)
{
        int ret = kobject_add(&acc->total.kobj, parent,
                              "stats_total");
        ret = ret ?: kobject_add(&acc->five_minute.kobj, parent,
                                 "stats_five_minute");
        ret = ret ?: kobject_add(&acc->hour.kobj, parent,
                                 "stats_hour");
        ret = ret ?: kobject_add(&acc->day.kobj, parent,
                                 "stats_day");
        return ret;
}

void bch_cache_accounting_clear(struct cache_accounting *acc)
{
        acc->total.cache_hits = 0;
        acc->total.cache_misses = 0;
        acc->total.cache_bypass_hits = 0;
        acc->total.cache_bypass_misses = 0;
        acc->total.cache_miss_collisions = 0;
        acc->total.sectors_bypassed = 0;
}

void bch_cache_accounting_destroy(struct cache_accounting *acc)
{
        kobject_put(&acc->total.kobj);
        kobject_put(&acc->five_minute.kobj);
        kobject_put(&acc->hour.kobj);
        kobject_put(&acc->day.kobj);

        atomic_set(&acc->closing, 1);
        if (timer_delete_sync(&acc->timer))
                closure_return(&acc->cl);
}

/* EWMA scaling */

static void scale_stat(unsigned long *stat)
{
        *stat =  ewma_add(*stat, 0, accounting_weight, 0);
}

static void scale_stats(struct cache_stats *stats, unsigned long rescale_at)
{
        if (++stats->rescale == rescale_at) {
                stats->rescale = 0;
                scale_stat(&stats->cache_hits);
                scale_stat(&stats->cache_misses);
                scale_stat(&stats->cache_bypass_hits);
                scale_stat(&stats->cache_bypass_misses);
                scale_stat(&stats->cache_miss_collisions);
                scale_stat(&stats->sectors_bypassed);
        }
}

static void scale_accounting(struct timer_list *t)
{
        struct cache_accounting *acc = timer_container_of(acc, t, timer);

#define move_stat(name) do {                                            \
        unsigned int t = atomic_xchg(&acc->collector.name, 0);          \
        t <<= 16;                                                       \
        acc->five_minute.name += t;                                     \
        acc->hour.name += t;                                            \
        acc->day.name += t;                                             \
        acc->total.name += t;                                           \
} while (0)

        move_stat(cache_hits);
        move_stat(cache_misses);
        move_stat(cache_bypass_hits);
        move_stat(cache_bypass_misses);
        move_stat(cache_miss_collisions);
        move_stat(sectors_bypassed);

        scale_stats(&acc->total, 0);
        scale_stats(&acc->day, DAY_RESCALE);
        scale_stats(&acc->hour, HOUR_RESCALE);
        scale_stats(&acc->five_minute, FIVE_MINUTE_RESCALE);

        acc->timer.expires += accounting_delay;

        if (!atomic_read(&acc->closing))
                add_timer(&acc->timer);
        else
                closure_return(&acc->cl);
}

static void mark_cache_stats(struct cache_stat_collector *stats,
                             bool hit, bool bypass)
{
        if (!bypass)
                if (hit)
                        atomic_inc(&stats->cache_hits);
                else
                        atomic_inc(&stats->cache_misses);
        else
                if (hit)
                        atomic_inc(&stats->cache_bypass_hits);
                else
                        atomic_inc(&stats->cache_bypass_misses);
}

void bch_mark_cache_accounting(struct cache_set *c, struct bcache_device *d,
                               bool hit, bool bypass)
{
        struct cached_dev *dc = container_of(d, struct cached_dev, disk);

        mark_cache_stats(&dc->accounting.collector, hit, bypass);
        mark_cache_stats(&c->accounting.collector, hit, bypass);
}

void bch_mark_cache_miss_collision(struct cache_set *c, struct bcache_device *d)
{
        struct cached_dev *dc = container_of(d, struct cached_dev, disk);

        atomic_inc(&dc->accounting.collector.cache_miss_collisions);
        atomic_inc(&c->accounting.collector.cache_miss_collisions);
}

void bch_mark_sectors_bypassed(struct cache_set *c, struct cached_dev *dc,
                               int sectors)
{
        atomic_add(sectors, &dc->accounting.collector.sectors_bypassed);
        atomic_add(sectors, &c->accounting.collector.sectors_bypassed);
}

void bch_cache_accounting_init(struct cache_accounting *acc,
                               struct closure *parent)
{
        kobject_init(&acc->total.kobj,          &bch_stats_ktype);
        kobject_init(&acc->five_minute.kobj,    &bch_stats_ktype);
        kobject_init(&acc->hour.kobj,           &bch_stats_ktype);
        kobject_init(&acc->day.kobj,            &bch_stats_ktype);

        closure_init(&acc->cl, parent);
        timer_setup(&acc->timer, scale_accounting, 0);
        acc->timer.expires      = jiffies + accounting_delay;
        add_timer(&acc->timer);
}