Merge tag 'ceph-for-5.11-rc2' of git://github.com/ceph/ceph-client
[linux-2.6-microblaze.git] / 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
36 static const unsigned int DAY_RESCALE           = 288;
37 static const unsigned int HOUR_RESCALE          = 12;
38 static const unsigned int FIVE_MINUTE_RESCALE   = 1;
39 static const unsigned int accounting_delay      = (HZ * 300) / 22;
40 static const unsigned int accounting_weight     = 32;
41
42 /* sysfs reading/writing */
43
44 read_attribute(cache_hits);
45 read_attribute(cache_misses);
46 read_attribute(cache_bypass_hits);
47 read_attribute(cache_bypass_misses);
48 read_attribute(cache_hit_ratio);
49 read_attribute(cache_readaheads);
50 read_attribute(cache_miss_collisions);
51 read_attribute(bypassed);
52
53 SHOW(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
74 STORE(bch_stats)
75 {
76         return size;
77 }
78
79 static void bch_stats_release(struct kobject *k)
80 {
81 }
82
83 static 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 };
94 static KTYPE(bch_stats);
95
96 int 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
110 void 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
121 void 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
135 static void scale_stat(unsigned long *stat)
136 {
137         *stat =  ewma_add(*stat, 0, accounting_weight, 0);
138 }
139
140 static 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
154 static 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
188 static 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
203 void 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
212 void 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
220 void 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
228 void 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
235 void 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 }