]> Git Repo - linux.git/blob - fs/xfs/scrub/stats.c
x86/config: Fix warning for 'make ARCH=x86_64 tinyconfig'
[linux.git] / fs / xfs / scrub / stats.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * Copyright (C) 2023 Oracle.  All Rights Reserved.
4  * Author: Darrick J. Wong <[email protected]>
5  */
6 #include "xfs.h"
7 #include "xfs_fs.h"
8 #include "xfs_shared.h"
9 #include "xfs_format.h"
10 #include "xfs_trans_resv.h"
11 #include "xfs_mount.h"
12 #include "xfs_sysfs.h"
13 #include "xfs_btree.h"
14 #include "xfs_super.h"
15 #include "scrub/scrub.h"
16 #include "scrub/stats.h"
17 #include "scrub/trace.h"
18
19 struct xchk_scrub_stats {
20         /* all 32-bit counters here */
21
22         /* checking stats */
23         uint32_t                invocations;
24         uint32_t                clean;
25         uint32_t                corrupt;
26         uint32_t                preen;
27         uint32_t                xfail;
28         uint32_t                xcorrupt;
29         uint32_t                incomplete;
30         uint32_t                warning;
31         uint32_t                retries;
32
33         /* repair stats */
34         uint32_t                repair_invocations;
35         uint32_t                repair_success;
36
37         /* all 64-bit items here */
38
39         /* runtimes */
40         uint64_t                checktime_us;
41         uint64_t                repairtime_us;
42
43         /* non-counter state must go at the end for clearall */
44         spinlock_t              css_lock;
45 };
46
47 struct xchk_stats {
48         struct dentry           *cs_debugfs;
49         struct xchk_scrub_stats cs_stats[XFS_SCRUB_TYPE_NR];
50 };
51
52
53 static struct xchk_stats        global_stats;
54
55 static const char *name_map[XFS_SCRUB_TYPE_NR] = {
56         [XFS_SCRUB_TYPE_SB]             = "sb",
57         [XFS_SCRUB_TYPE_AGF]            = "agf",
58         [XFS_SCRUB_TYPE_AGFL]           = "agfl",
59         [XFS_SCRUB_TYPE_AGI]            = "agi",
60         [XFS_SCRUB_TYPE_BNOBT]          = "bnobt",
61         [XFS_SCRUB_TYPE_CNTBT]          = "cntbt",
62         [XFS_SCRUB_TYPE_INOBT]          = "inobt",
63         [XFS_SCRUB_TYPE_FINOBT]         = "finobt",
64         [XFS_SCRUB_TYPE_RMAPBT]         = "rmapbt",
65         [XFS_SCRUB_TYPE_REFCNTBT]       = "refcountbt",
66         [XFS_SCRUB_TYPE_INODE]          = "inode",
67         [XFS_SCRUB_TYPE_BMBTD]          = "bmapbtd",
68         [XFS_SCRUB_TYPE_BMBTA]          = "bmapbta",
69         [XFS_SCRUB_TYPE_BMBTC]          = "bmapbtc",
70         [XFS_SCRUB_TYPE_DIR]            = "directory",
71         [XFS_SCRUB_TYPE_XATTR]          = "xattr",
72         [XFS_SCRUB_TYPE_SYMLINK]        = "symlink",
73         [XFS_SCRUB_TYPE_PARENT]         = "parent",
74         [XFS_SCRUB_TYPE_RTBITMAP]       = "rtbitmap",
75         [XFS_SCRUB_TYPE_RTSUM]          = "rtsummary",
76         [XFS_SCRUB_TYPE_UQUOTA]         = "usrquota",
77         [XFS_SCRUB_TYPE_GQUOTA]         = "grpquota",
78         [XFS_SCRUB_TYPE_PQUOTA]         = "prjquota",
79         [XFS_SCRUB_TYPE_FSCOUNTERS]     = "fscounters",
80         [XFS_SCRUB_TYPE_QUOTACHECK]     = "quotacheck",
81         [XFS_SCRUB_TYPE_NLINKS]         = "nlinks",
82 };
83
84 /* Format the scrub stats into a text buffer, similar to pcp style. */
85 STATIC ssize_t
86 xchk_stats_format(
87         struct xchk_stats       *cs,
88         char                    *buf,
89         size_t                  remaining)
90 {
91         struct xchk_scrub_stats *css = &cs->cs_stats[0];
92         unsigned int            i;
93         ssize_t                 copied = 0;
94         int                     ret = 0;
95
96         for (i = 0; i < XFS_SCRUB_TYPE_NR; i++, css++) {
97                 if (!name_map[i])
98                         continue;
99
100                 ret = scnprintf(buf, remaining,
101  "%s %u %u %u %u %u %u %u %u %u %llu %u %u %llu\n",
102                                 name_map[i],
103                                 (unsigned int)css->invocations,
104                                 (unsigned int)css->clean,
105                                 (unsigned int)css->corrupt,
106                                 (unsigned int)css->preen,
107                                 (unsigned int)css->xfail,
108                                 (unsigned int)css->xcorrupt,
109                                 (unsigned int)css->incomplete,
110                                 (unsigned int)css->warning,
111                                 (unsigned int)css->retries,
112                                 (unsigned long long)css->checktime_us,
113                                 (unsigned int)css->repair_invocations,
114                                 (unsigned int)css->repair_success,
115                                 (unsigned long long)css->repairtime_us);
116                 if (ret <= 0)
117                         break;
118
119                 remaining -= ret;
120                 copied += ret;
121                 buf +=  ret;
122         }
123
124         return copied > 0 ? copied : ret;
125 }
126
127 /* Estimate the worst case buffer size required to hold the whole report. */
128 STATIC size_t
129 xchk_stats_estimate_bufsize(
130         struct xchk_stats       *cs)
131 {
132         struct xchk_scrub_stats *css = &cs->cs_stats[0];
133         unsigned int            i;
134         size_t                  field_width;
135         size_t                  ret = 0;
136
137         /* 4294967296 plus one space for each u32 field */
138         field_width = 11 * (offsetof(struct xchk_scrub_stats, checktime_us) /
139                             sizeof(uint32_t));
140
141         /* 18446744073709551615 plus one space for each u64 field */
142         field_width += 21 * ((offsetof(struct xchk_scrub_stats, css_lock) -
143                               offsetof(struct xchk_scrub_stats, checktime_us)) /
144                              sizeof(uint64_t));
145
146         for (i = 0; i < XFS_SCRUB_TYPE_NR; i++, css++) {
147                 if (!name_map[i])
148                         continue;
149
150                 /* name plus one space */
151                 ret += 1 + strlen(name_map[i]);
152
153                 /* all fields, plus newline */
154                 ret += field_width + 1;
155         }
156
157         return ret;
158 }
159
160 /* Clear all counters. */
161 STATIC void
162 xchk_stats_clearall(
163         struct xchk_stats       *cs)
164 {
165         struct xchk_scrub_stats *css = &cs->cs_stats[0];
166         unsigned int            i;
167
168         for (i = 0; i < XFS_SCRUB_TYPE_NR; i++, css++) {
169                 spin_lock(&css->css_lock);
170                 memset(css, 0, offsetof(struct xchk_scrub_stats, css_lock));
171                 spin_unlock(&css->css_lock);
172         }
173 }
174
175 #define XFS_SCRUB_OFLAG_UNCLEAN (XFS_SCRUB_OFLAG_CORRUPT | \
176                                  XFS_SCRUB_OFLAG_PREEN | \
177                                  XFS_SCRUB_OFLAG_XFAIL | \
178                                  XFS_SCRUB_OFLAG_XCORRUPT | \
179                                  XFS_SCRUB_OFLAG_INCOMPLETE | \
180                                  XFS_SCRUB_OFLAG_WARNING)
181
182 STATIC void
183 xchk_stats_merge_one(
184         struct xchk_stats               *cs,
185         const struct xfs_scrub_metadata *sm,
186         const struct xchk_stats_run     *run)
187 {
188         struct xchk_scrub_stats         *css;
189
190         if (sm->sm_type >= XFS_SCRUB_TYPE_NR) {
191                 ASSERT(sm->sm_type < XFS_SCRUB_TYPE_NR);
192                 return;
193         }
194
195         css = &cs->cs_stats[sm->sm_type];
196         spin_lock(&css->css_lock);
197         css->invocations++;
198         if (!(sm->sm_flags & XFS_SCRUB_OFLAG_UNCLEAN))
199                 css->clean++;
200         if (sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
201                 css->corrupt++;
202         if (sm->sm_flags & XFS_SCRUB_OFLAG_PREEN)
203                 css->preen++;
204         if (sm->sm_flags & XFS_SCRUB_OFLAG_XFAIL)
205                 css->xfail++;
206         if (sm->sm_flags & XFS_SCRUB_OFLAG_XCORRUPT)
207                 css->xcorrupt++;
208         if (sm->sm_flags & XFS_SCRUB_OFLAG_INCOMPLETE)
209                 css->incomplete++;
210         if (sm->sm_flags & XFS_SCRUB_OFLAG_WARNING)
211                 css->warning++;
212         css->retries += run->retries;
213         css->checktime_us += howmany_64(run->scrub_ns, NSEC_PER_USEC);
214
215         if (run->repair_attempted)
216                 css->repair_invocations++;
217         if (run->repair_succeeded)
218                 css->repair_success++;
219         css->repairtime_us += howmany_64(run->repair_ns, NSEC_PER_USEC);
220         spin_unlock(&css->css_lock);
221 }
222
223 /* Merge these scrub-run stats into the global and mount stat data. */
224 void
225 xchk_stats_merge(
226         struct xfs_mount                *mp,
227         const struct xfs_scrub_metadata *sm,
228         const struct xchk_stats_run     *run)
229 {
230         xchk_stats_merge_one(&global_stats, sm, run);
231         xchk_stats_merge_one(mp->m_scrub_stats, sm, run);
232 }
233
234 /* debugfs boilerplate */
235
236 static ssize_t
237 xchk_scrub_stats_read(
238         struct file             *file,
239         char __user             *ubuf,
240         size_t                  count,
241         loff_t                  *ppos)
242 {
243         struct xchk_stats       *cs = file->private_data;
244         char                    *buf;
245         size_t                  bufsize;
246         ssize_t                 avail, ret;
247
248         /*
249          * This generates stringly snapshot of all the scrub counters, so we
250          * do not want userspace to receive garbled text from multiple calls.
251          * If the file position is greater than 0, return a short read.
252          */
253         if (*ppos > 0)
254                 return 0;
255
256         bufsize = xchk_stats_estimate_bufsize(cs);
257
258         buf = kvmalloc(bufsize, XCHK_GFP_FLAGS);
259         if (!buf)
260                 return -ENOMEM;
261
262         avail = xchk_stats_format(cs, buf, bufsize);
263         if (avail < 0) {
264                 ret = avail;
265                 goto out;
266         }
267
268         ret = simple_read_from_buffer(ubuf, count, ppos, buf, avail);
269 out:
270         kvfree(buf);
271         return ret;
272 }
273
274 static const struct file_operations scrub_stats_fops = {
275         .open                   = simple_open,
276         .read                   = xchk_scrub_stats_read,
277 };
278
279 static ssize_t
280 xchk_clear_scrub_stats_write(
281         struct file             *file,
282         const char __user       *ubuf,
283         size_t                  count,
284         loff_t                  *ppos)
285 {
286         struct xchk_stats       *cs = file->private_data;
287         unsigned int            val;
288         int                     ret;
289
290         ret = kstrtouint_from_user(ubuf, count, 0, &val);
291         if (ret)
292                 return ret;
293
294         if (val != 1)
295                 return -EINVAL;
296
297         xchk_stats_clearall(cs);
298         return count;
299 }
300
301 static const struct file_operations clear_scrub_stats_fops = {
302         .open                   = simple_open,
303         .write                  = xchk_clear_scrub_stats_write,
304 };
305
306 /* Initialize the stats object. */
307 STATIC int
308 xchk_stats_init(
309         struct xchk_stats       *cs,
310         struct xfs_mount        *mp)
311 {
312         struct xchk_scrub_stats *css = &cs->cs_stats[0];
313         unsigned int            i;
314
315         for (i = 0; i < XFS_SCRUB_TYPE_NR; i++, css++)
316                 spin_lock_init(&css->css_lock);
317
318         return 0;
319 }
320
321 /* Connect the stats object to debugfs. */
322 void
323 xchk_stats_register(
324         struct xchk_stats       *cs,
325         struct dentry           *parent)
326 {
327         if (!parent)
328                 return;
329
330         cs->cs_debugfs = xfs_debugfs_mkdir("scrub", parent);
331         if (!cs->cs_debugfs)
332                 return;
333
334         debugfs_create_file("stats", 0444, cs->cs_debugfs, cs,
335                         &scrub_stats_fops);
336         debugfs_create_file("clear_stats", 0200, cs->cs_debugfs, cs,
337                         &clear_scrub_stats_fops);
338 }
339
340 /* Free all resources related to the stats object. */
341 STATIC int
342 xchk_stats_teardown(
343         struct xchk_stats       *cs)
344 {
345         return 0;
346 }
347
348 /* Disconnect the stats object from debugfs. */
349 void
350 xchk_stats_unregister(
351         struct xchk_stats       *cs)
352 {
353         debugfs_remove(cs->cs_debugfs);
354 }
355
356 /* Initialize global stats and register them */
357 int __init
358 xchk_global_stats_setup(
359         struct dentry           *parent)
360 {
361         int                     error;
362
363         error = xchk_stats_init(&global_stats, NULL);
364         if (error)
365                 return error;
366
367         xchk_stats_register(&global_stats, parent);
368         return 0;
369 }
370
371 /* Unregister global stats and tear them down */
372 void
373 xchk_global_stats_teardown(void)
374 {
375         xchk_stats_unregister(&global_stats);
376         xchk_stats_teardown(&global_stats);
377 }
378
379 /* Allocate per-mount stats */
380 int
381 xchk_mount_stats_alloc(
382         struct xfs_mount        *mp)
383 {
384         struct xchk_stats       *cs;
385         int                     error;
386
387         cs = kvzalloc(sizeof(struct xchk_stats), GFP_KERNEL);
388         if (!cs)
389                 return -ENOMEM;
390
391         error = xchk_stats_init(cs, mp);
392         if (error)
393                 goto out_free;
394
395         mp->m_scrub_stats = cs;
396         return 0;
397 out_free:
398         kvfree(cs);
399         return error;
400 }
401
402 /* Free per-mount stats */
403 void
404 xchk_mount_stats_free(
405         struct xfs_mount        *mp)
406 {
407         xchk_stats_teardown(mp->m_scrub_stats);
408         kvfree(mp->m_scrub_stats);
409         mp->m_scrub_stats = NULL;
410 }
This page took 0.055409 seconds and 4 git commands to generate.