xref: /openbmc/linux/fs/xfs/scrub/stats.c (revision 7f0e5af2)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * Copyright (C) 2023 Oracle.  All Rights Reserved.
4  * Author: Darrick J. Wong <djwong@kernel.org>
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 };
81 
82 /* Format the scrub stats into a text buffer, similar to pcp style. */
83 STATIC ssize_t
xchk_stats_format(struct xchk_stats * cs,char * buf,size_t remaining)84 xchk_stats_format(
85 	struct xchk_stats	*cs,
86 	char			*buf,
87 	size_t			remaining)
88 {
89 	struct xchk_scrub_stats	*css = &cs->cs_stats[0];
90 	unsigned int		i;
91 	ssize_t			copied = 0;
92 	int			ret = 0;
93 
94 	for (i = 0; i < XFS_SCRUB_TYPE_NR; i++, css++) {
95 		if (!name_map[i])
96 			continue;
97 
98 		ret = scnprintf(buf, remaining,
99  "%s %u %u %u %u %u %u %u %u %u %llu %u %u %llu\n",
100 				name_map[i],
101 				(unsigned int)css->invocations,
102 				(unsigned int)css->clean,
103 				(unsigned int)css->corrupt,
104 				(unsigned int)css->preen,
105 				(unsigned int)css->xfail,
106 				(unsigned int)css->xcorrupt,
107 				(unsigned int)css->incomplete,
108 				(unsigned int)css->warning,
109 				(unsigned int)css->retries,
110 				(unsigned long long)css->checktime_us,
111 				(unsigned int)css->repair_invocations,
112 				(unsigned int)css->repair_success,
113 				(unsigned long long)css->repairtime_us);
114 		if (ret <= 0)
115 			break;
116 
117 		remaining -= ret;
118 		copied += ret;
119 		buf +=  ret;
120 	}
121 
122 	return copied > 0 ? copied : ret;
123 }
124 
125 /* Estimate the worst case buffer size required to hold the whole report. */
126 STATIC size_t
xchk_stats_estimate_bufsize(struct xchk_stats * cs)127 xchk_stats_estimate_bufsize(
128 	struct xchk_stats	*cs)
129 {
130 	struct xchk_scrub_stats	*css = &cs->cs_stats[0];
131 	unsigned int		i;
132 	size_t			field_width;
133 	size_t			ret = 0;
134 
135 	/* 4294967296 plus one space for each u32 field */
136 	field_width = 11 * (offsetof(struct xchk_scrub_stats, checktime_us) /
137 			    sizeof(uint32_t));
138 
139 	/* 18446744073709551615 plus one space for each u64 field */
140 	field_width += 21 * ((offsetof(struct xchk_scrub_stats, css_lock) -
141 			      offsetof(struct xchk_scrub_stats, checktime_us)) /
142 			     sizeof(uint64_t));
143 
144 	for (i = 0; i < XFS_SCRUB_TYPE_NR; i++, css++) {
145 		if (!name_map[i])
146 			continue;
147 
148 		/* name plus one space */
149 		ret += 1 + strlen(name_map[i]);
150 
151 		/* all fields, plus newline */
152 		ret += field_width + 1;
153 	}
154 
155 	return ret;
156 }
157 
158 /* Clear all counters. */
159 STATIC void
xchk_stats_clearall(struct xchk_stats * cs)160 xchk_stats_clearall(
161 	struct xchk_stats	*cs)
162 {
163 	struct xchk_scrub_stats	*css = &cs->cs_stats[0];
164 	unsigned int		i;
165 
166 	for (i = 0; i < XFS_SCRUB_TYPE_NR; i++, css++) {
167 		spin_lock(&css->css_lock);
168 		memset(css, 0, offsetof(struct xchk_scrub_stats, css_lock));
169 		spin_unlock(&css->css_lock);
170 	}
171 }
172 
173 #define XFS_SCRUB_OFLAG_UNCLEAN	(XFS_SCRUB_OFLAG_CORRUPT | \
174 				 XFS_SCRUB_OFLAG_PREEN | \
175 				 XFS_SCRUB_OFLAG_XFAIL | \
176 				 XFS_SCRUB_OFLAG_XCORRUPT | \
177 				 XFS_SCRUB_OFLAG_INCOMPLETE | \
178 				 XFS_SCRUB_OFLAG_WARNING)
179 
180 STATIC void
xchk_stats_merge_one(struct xchk_stats * cs,const struct xfs_scrub_metadata * sm,const struct xchk_stats_run * run)181 xchk_stats_merge_one(
182 	struct xchk_stats		*cs,
183 	const struct xfs_scrub_metadata	*sm,
184 	const struct xchk_stats_run	*run)
185 {
186 	struct xchk_scrub_stats		*css;
187 
188 	if (sm->sm_type >= XFS_SCRUB_TYPE_NR) {
189 		ASSERT(sm->sm_type < XFS_SCRUB_TYPE_NR);
190 		return;
191 	}
192 
193 	css = &cs->cs_stats[sm->sm_type];
194 	spin_lock(&css->css_lock);
195 	css->invocations++;
196 	if (!(sm->sm_flags & XFS_SCRUB_OFLAG_UNCLEAN))
197 		css->clean++;
198 	if (sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
199 		css->corrupt++;
200 	if (sm->sm_flags & XFS_SCRUB_OFLAG_PREEN)
201 		css->preen++;
202 	if (sm->sm_flags & XFS_SCRUB_OFLAG_XFAIL)
203 		css->xfail++;
204 	if (sm->sm_flags & XFS_SCRUB_OFLAG_XCORRUPT)
205 		css->xcorrupt++;
206 	if (sm->sm_flags & XFS_SCRUB_OFLAG_INCOMPLETE)
207 		css->incomplete++;
208 	if (sm->sm_flags & XFS_SCRUB_OFLAG_WARNING)
209 		css->warning++;
210 	css->retries += run->retries;
211 	css->checktime_us += howmany_64(run->scrub_ns, NSEC_PER_USEC);
212 
213 	if (run->repair_attempted)
214 		css->repair_invocations++;
215 	if (run->repair_succeeded)
216 		css->repair_success++;
217 	css->repairtime_us += howmany_64(run->repair_ns, NSEC_PER_USEC);
218 	spin_unlock(&css->css_lock);
219 }
220 
221 /* Merge these scrub-run stats into the global and mount stat data. */
222 void
xchk_stats_merge(struct xfs_mount * mp,const struct xfs_scrub_metadata * sm,const struct xchk_stats_run * run)223 xchk_stats_merge(
224 	struct xfs_mount		*mp,
225 	const struct xfs_scrub_metadata	*sm,
226 	const struct xchk_stats_run	*run)
227 {
228 	xchk_stats_merge_one(&global_stats, sm, run);
229 	xchk_stats_merge_one(mp->m_scrub_stats, sm, run);
230 }
231 
232 /* debugfs boilerplate */
233 
234 static ssize_t
xchk_scrub_stats_read(struct file * file,char __user * ubuf,size_t count,loff_t * ppos)235 xchk_scrub_stats_read(
236 	struct file		*file,
237 	char __user		*ubuf,
238 	size_t			count,
239 	loff_t			*ppos)
240 {
241 	struct xchk_stats	*cs = file->private_data;
242 	char			*buf;
243 	size_t			bufsize;
244 	ssize_t			avail, ret;
245 
246 	/*
247 	 * This generates stringly snapshot of all the scrub counters, so we
248 	 * do not want userspace to receive garbled text from multiple calls.
249 	 * If the file position is greater than 0, return a short read.
250 	 */
251 	if (*ppos > 0)
252 		return 0;
253 
254 	bufsize = xchk_stats_estimate_bufsize(cs);
255 
256 	buf = kvmalloc(bufsize, XCHK_GFP_FLAGS);
257 	if (!buf)
258 		return -ENOMEM;
259 
260 	avail = xchk_stats_format(cs, buf, bufsize);
261 	if (avail < 0) {
262 		ret = avail;
263 		goto out;
264 	}
265 
266 	ret = simple_read_from_buffer(ubuf, count, ppos, buf, avail);
267 out:
268 	kvfree(buf);
269 	return ret;
270 }
271 
272 static const struct file_operations scrub_stats_fops = {
273 	.open			= simple_open,
274 	.read			= xchk_scrub_stats_read,
275 };
276 
277 static ssize_t
xchk_clear_scrub_stats_write(struct file * file,const char __user * ubuf,size_t count,loff_t * ppos)278 xchk_clear_scrub_stats_write(
279 	struct file		*file,
280 	const char __user	*ubuf,
281 	size_t			count,
282 	loff_t			*ppos)
283 {
284 	struct xchk_stats	*cs = file->private_data;
285 	unsigned int		val;
286 	int			ret;
287 
288 	ret = kstrtouint_from_user(ubuf, count, 0, &val);
289 	if (ret)
290 		return ret;
291 
292 	if (val != 1)
293 		return -EINVAL;
294 
295 	xchk_stats_clearall(cs);
296 	return count;
297 }
298 
299 static const struct file_operations clear_scrub_stats_fops = {
300 	.open			= simple_open,
301 	.write			= xchk_clear_scrub_stats_write,
302 };
303 
304 /* Initialize the stats object. */
305 STATIC int
xchk_stats_init(struct xchk_stats * cs,struct xfs_mount * mp)306 xchk_stats_init(
307 	struct xchk_stats	*cs,
308 	struct xfs_mount	*mp)
309 {
310 	struct xchk_scrub_stats	*css = &cs->cs_stats[0];
311 	unsigned int		i;
312 
313 	for (i = 0; i < XFS_SCRUB_TYPE_NR; i++, css++)
314 		spin_lock_init(&css->css_lock);
315 
316 	return 0;
317 }
318 
319 /* Connect the stats object to debugfs. */
320 void
xchk_stats_register(struct xchk_stats * cs,struct dentry * parent)321 xchk_stats_register(
322 	struct xchk_stats	*cs,
323 	struct dentry		*parent)
324 {
325 	if (!parent)
326 		return;
327 
328 	cs->cs_debugfs = xfs_debugfs_mkdir("scrub", parent);
329 	if (!cs->cs_debugfs)
330 		return;
331 
332 	debugfs_create_file("stats", 0444, cs->cs_debugfs, cs,
333 			&scrub_stats_fops);
334 	debugfs_create_file("clear_stats", 0200, cs->cs_debugfs, cs,
335 			&clear_scrub_stats_fops);
336 }
337 
338 /* Free all resources related to the stats object. */
339 STATIC int
xchk_stats_teardown(struct xchk_stats * cs)340 xchk_stats_teardown(
341 	struct xchk_stats	*cs)
342 {
343 	return 0;
344 }
345 
346 /* Disconnect the stats object from debugfs. */
347 void
xchk_stats_unregister(struct xchk_stats * cs)348 xchk_stats_unregister(
349 	struct xchk_stats	*cs)
350 {
351 	debugfs_remove(cs->cs_debugfs);
352 }
353 
354 /* Initialize global stats and register them */
355 int __init
xchk_global_stats_setup(struct dentry * parent)356 xchk_global_stats_setup(
357 	struct dentry		*parent)
358 {
359 	int			error;
360 
361 	error = xchk_stats_init(&global_stats, NULL);
362 	if (error)
363 		return error;
364 
365 	xchk_stats_register(&global_stats, parent);
366 	return 0;
367 }
368 
369 /* Unregister global stats and tear them down */
370 void
xchk_global_stats_teardown(void)371 xchk_global_stats_teardown(void)
372 {
373 	xchk_stats_unregister(&global_stats);
374 	xchk_stats_teardown(&global_stats);
375 }
376 
377 /* Allocate per-mount stats */
378 int
xchk_mount_stats_alloc(struct xfs_mount * mp)379 xchk_mount_stats_alloc(
380 	struct xfs_mount	*mp)
381 {
382 	struct xchk_stats	*cs;
383 	int			error;
384 
385 	cs = kvzalloc(sizeof(struct xchk_stats), GFP_KERNEL);
386 	if (!cs)
387 		return -ENOMEM;
388 
389 	error = xchk_stats_init(cs, mp);
390 	if (error)
391 		goto out_free;
392 
393 	mp->m_scrub_stats = cs;
394 	return 0;
395 out_free:
396 	kvfree(cs);
397 	return error;
398 }
399 
400 /* Free per-mount stats */
401 void
xchk_mount_stats_free(struct xfs_mount * mp)402 xchk_mount_stats_free(
403 	struct xfs_mount	*mp)
404 {
405 	xchk_stats_teardown(mp->m_scrub_stats);
406 	kvfree(mp->m_scrub_stats);
407 	mp->m_scrub_stats = NULL;
408 }
409