[thirdparty/xfsprogs-dev.git] / scrub / phase7.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Copyright (C) 2018-2024 Oracle.  All Rights Reserved.
 * Author: Darrick J. Wong <djwong@kernel.org>
 */
#include "xfs.h"
#include <stdint.h>
#include <stdlib.h>
#include <sys/statvfs.h>
#include <linux/fsmap.h>
#include "libfrog/paths.h"
#include "libfrog/ptvar.h"
#include "list.h"
#include "xfs_scrub.h"
#include "common.h"
#include "scrub.h"
#include "fscounters.h"
#include "spacemap.h"
#include "repair.h"

/* Phase 7: Check summary counters. */

struct summary_counts {
	unsigned long long	dbytes;		/* data dev bytes */
	unsigned long long	rbytes;		/* rt dev bytes */
	unsigned long long	next_phys;	/* next phys bytes we see? */
	unsigned long long	agbytes;	/* freespace bytes */
};

/* Record block usage. */
static int
count_block_summary(
	struct scrub_ctx	*ctx,
	struct fsmap		*fsmap,
	void			*arg)
{
	struct summary_counts	*counts;
	unsigned long long	len;
	int			ret;

	counts = ptvar_get((struct ptvar *)arg, &ret);
	if (ret) {
		str_liberror(ctx, -ret, _("retrieving summary counts"));
		return -ret;
	}
	if (fsmap->fmr_device == ctx->fsinfo.fs_logdev)
		return 0;
	if ((fsmap->fmr_flags & FMR_OF_SPECIAL_OWNER) &&
	    fsmap->fmr_owner == XFS_FMR_OWN_FREE)
		return 0;

	len = fsmap->fmr_length;

	/* freesp btrees live in free space, need to adjust counters later. */
	if ((fsmap->fmr_flags & FMR_OF_SPECIAL_OWNER) &&
	    fsmap->fmr_owner == XFS_FMR_OWN_AG) {
		counts->agbytes += fsmap->fmr_length;
	}
	if (fsmap->fmr_device == ctx->fsinfo.fs_rtdev) {
		/* Count realtime extents. */
		counts->rbytes += len;
	} else {
		/* Count datadev extents. */
		if (counts->next_phys >= fsmap->fmr_physical + len)
			return 0;
		else if (counts->next_phys > fsmap->fmr_physical)
			len = counts->next_phys - fsmap->fmr_physical;
		counts->dbytes += len;
		counts->next_phys = fsmap->fmr_physical + fsmap->fmr_length;
	}

	return 0;
}

/* Add all the summaries in the per-thread counter */
static int
add_summaries(
	struct ptvar		*ptv,
	void			*data,
	void			*arg)
{
	struct summary_counts	*total = arg;
	struct summary_counts	*item = data;

	total->dbytes += item->dbytes;
	total->rbytes += item->rbytes;
	total->agbytes += item->agbytes;
	return 0;
}

/*
 * Count all inodes and blocks in the filesystem as told by GETFSMAP and
 * BULKSTAT, and compare that to summary counters.  Since this is a live
 * filesystem we'll be content if the summary counts are within 10% of
 * what we observed.
 */
int
phase7_func(
	struct scrub_ctx	*ctx)
{
	struct summary_counts	totalcount = {0};
	struct action_list	alist;
	struct ptvar		*ptvar;
	unsigned long long	used_data;
	unsigned long long	used_rt;
	unsigned long long	used_files;
	unsigned long long	stat_data;
	unsigned long long	stat_rt;
	uint64_t		counted_inodes = 0;
	unsigned long long	absdiff;
	unsigned long long	d_blocks;
	unsigned long long	d_bfree;
	unsigned long long	r_blocks;
	unsigned long long	r_bfree;
	bool			complain;
	int			ip;
	int			error;

	/* Check and fix the fs summary counters. */
	action_list_init(&alist);
	error = scrub_fs_summary(ctx, &alist);
	if (error)
		return error;
	error = action_list_process(ctx, -1, &alist,
			ALP_COMPLAIN_IF_UNFIXED | ALP_NOPROGRESS);
	if (error)
		return error;

	/* Flush everything out to disk before we start counting. */
	error = syncfs(ctx->mnt.fd);
	if (error) {
		str_errno(ctx, ctx->mntpoint);
		return error;
	}

	error = -ptvar_alloc(scrub_nproc(ctx), sizeof(struct summary_counts),
			&ptvar);
	if (error) {
		str_liberror(ctx, error, _("setting up block counter"));
		return error;
	}

	/* Use fsmap to count blocks. */
	error = scrub_scan_all_spacemaps(ctx, count_block_summary, ptvar);
	if (error)
		goto out_free;
	error = -ptvar_foreach(ptvar, add_summaries, &totalcount);
	if (error) {
		str_liberror(ctx, error, _("counting blocks"));
		goto out_free;
	}
	ptvar_free(ptvar);

	/* Scan the whole fs. */
	error = scrub_count_all_inodes(ctx, &counted_inodes);
	if (error) {
		str_liberror(ctx, error, _("counting inodes"));
		return error;
	}

	error = scrub_scan_estimate_blocks(ctx, &d_blocks, &d_bfree, &r_blocks,
			&r_bfree, &used_files);
	if (error) {
		str_liberror(ctx, error, _("estimating verify work"));
		return error;
	}

	/*
	 * If we counted blocks with fsmap, then dblocks includes
	 * blocks for the AGFL and the freespace/rmap btrees.  The
	 * filesystem treats them as "free", but since we scanned
	 * them, we'll consider them used.
	 */
	d_bfree -= cvt_b_to_off_fsbt(&ctx->mnt, totalcount.agbytes);

	/* Report on what we found. */
	used_data = cvt_off_fsb_to_b(&ctx->mnt, d_blocks - d_bfree);
	used_rt = cvt_off_fsb_to_b(&ctx->mnt, r_blocks - r_bfree);
	stat_data = totalcount.dbytes;
	stat_rt = totalcount.rbytes;

	/*
	 * Complain if the counts are off by more than 10% unless
	 * the inaccuracy is less than 32MB worth of blocks or 100 inodes.
	 */
	absdiff = 1ULL << 25;
	complain = verbose;
	complain |= !within_range(ctx, stat_data, used_data, absdiff, 1, 10,
			_("data blocks"));
	complain |= !within_range(ctx, stat_rt, used_rt, absdiff, 1, 10,
			_("realtime blocks"));
	complain |= !within_range(ctx, counted_inodes, used_files, 100, 1, 10,
			_("inodes"));

	if (complain) {
		double		d, r, i;
		char		*du, *ru, *iu;

		if (used_rt || stat_rt) {
			d = auto_space_units(used_data, &du);
			r = auto_space_units(used_rt, &ru);
			i = auto_units(used_files, &iu, &ip);
			fprintf(stdout,
_("%.1f%s data used;  %.1f%s realtime data used;  %.*f%s inodes used.\n"),
					d, du, r, ru, ip, i, iu);
			d = auto_space_units(stat_data, &du);
			r = auto_space_units(stat_rt, &ru);
			i = auto_units(counted_inodes, &iu, &ip);
			fprintf(stdout,
_("%.1f%s data found; %.1f%s realtime data found; %.*f%s inodes found.\n"),
					d, du, r, ru, ip, i, iu);
		} else {
			d = auto_space_units(used_data, &du);
			i = auto_units(used_files, &iu, &ip);
			fprintf(stdout,
_("%.1f%s data used;  %.*f%s inodes used.\n"),
					d, du, ip, i, iu);
			d = auto_space_units(stat_data, &du);
			i = auto_units(counted_inodes, &iu, &ip);
			fprintf(stdout,
_("%.1f%s data found; %.*f%s inodes found.\n"),
					d, du, ip, i, iu);
		}
		fflush(stdout);
	}

	/*
	 * Complain if the checked inode counts are off, which
	 * implies an incomplete check.
	 */
	if (verbose ||
	    !within_range(ctx, counted_inodes, ctx->inodes_checked, 100, 1, 10,
			_("checked inodes"))) {
		double		i1, i2;
		char		*i1u, *i2u;
		int		i1p, i2p;

		i1 = auto_units(counted_inodes, &i1u, &i1p);
		i2 = auto_units(ctx->inodes_checked, &i2u, &i2p);
		fprintf(stdout,
_("%.*f%s inodes counted; %.*f%s inodes checked.\n"),
				i1p, i1, i1u, i2p, i2, i2u);
		fflush(stdout);
	}

	/*
	 * Complain if the checked block counts are off, which
	 * implies an incomplete check.
	 */
	if (ctx->bytes_checked &&
	    (verbose ||
	     !within_range(ctx, used_data + used_rt,
			ctx->bytes_checked, absdiff, 1, 10,
			_("verified blocks")))) {
		double		b1, b2;
		char		*b1u, *b2u;

		b1 = auto_space_units(used_data + used_rt, &b1u);
		b2 = auto_space_units(ctx->bytes_checked, &b2u);
		fprintf(stdout,
_("%.1f%s data counted; %.1f%s data verified.\n"),
				b1, b1u, b2, b2u);
		fflush(stdout);
	}

	return 0;
out_free:
	ptvar_free(ptvar);
	return error;
}
Commit	Line	Data
8d318d62	1	// SPDX-License-Identifier: GPL-2.0-or-later
698c6c7c	2	/*
52520522	3	* Copyright (C) 2018-2024 Oracle. All Rights Reserved.
8d318d62	4	* Author: Darrick J. Wong <djwong@kernel.org>
698c6c7c	5	*/
a440f877	6	#include "xfs.h"
698c6c7c	7	#include <stdint.h>
698c6c7c DW	8	#include <stdlib.h>
698c6c7c DW	9	#include <sys/statvfs.h>
9b72515a	10	#include <linux/fsmap.h>
42b4c8e8	11	#include "libfrog/paths.h"
14051909	12	#include "libfrog/ptvar.h"
cbaf1c9d	13	#include "list.h"
698c6c7c DW	14	#include "xfs_scrub.h"
698c6c7c DW	15	#include "common.h"
cbaf1c9d	16	#include "scrub.h"
698c6c7c DW	17	#include "fscounters.h"
698c6c7c DW	18	#include "spacemap.h"
cbaf1c9d	19	#include "repair.h"
698c6c7c DW	20
	21	/* Phase 7: Check summary counters. */
	22
593f2ab8	23	struct summary_counts {
698c6c7c DW	24	unsigned long long dbytes; /* data dev bytes */
	25	unsigned long long rbytes; /* rt dev bytes */
	26	unsigned long long next_phys; /* next phys bytes we see? */
	27	unsigned long long agbytes; /* freespace bytes */
	28	};
	29
	30	/* Record block usage. */
7a2eef2b DW	31	static int
7a2eef2b DW	32	count_block_summary(
593f2ab8	33	struct scrub_ctx *ctx,
593f2ab8 DW	34	struct fsmap *fsmap,
593f2ab8 DW	35	void *arg)
698c6c7c	36	{
593f2ab8 DW	37	struct summary_counts *counts;
593f2ab8 DW	38	unsigned long long len;
cb321a39	39	int ret;
698c6c7c	40
cb321a39 DW	41	counts = ptvar_get((struct ptvar *)arg, &ret);
cb321a39 DW	42	if (ret) {
2f4422f4 DW	43	str_liberror(ctx, -ret, _("retrieving summary counts"));
2f4422f4 DW	44	return -ret;
cb321a39	45	}
698c6c7c	46	if (fsmap->fmr_device == ctx->fsinfo.fs_logdev)
7a2eef2b	47	return 0;
698c6c7c DW	48	if ((fsmap->fmr_flags & FMR_OF_SPECIAL_OWNER) &&
698c6c7c DW	49	fsmap->fmr_owner == XFS_FMR_OWN_FREE)
7a2eef2b	50	return 0;
698c6c7c DW	51
	52	len = fsmap->fmr_length;
	53
	54	/* freesp btrees live in free space, need to adjust counters later. */
	55	if ((fsmap->fmr_flags & FMR_OF_SPECIAL_OWNER) &&
	56	fsmap->fmr_owner == XFS_FMR_OWN_AG) {
	57	counts->agbytes += fsmap->fmr_length;
	58	}
	59	if (fsmap->fmr_device == ctx->fsinfo.fs_rtdev) {
	60	/* Count realtime extents. */
	61	counts->rbytes += len;
	62	} else {
	63	/* Count datadev extents. */
	64	if (counts->next_phys >= fsmap->fmr_physical + len)
7a2eef2b	65	return 0;
698c6c7c DW	66	else if (counts->next_phys > fsmap->fmr_physical)
	67	len = counts->next_phys - fsmap->fmr_physical;
	68	counts->dbytes += len;
	69	counts->next_phys = fsmap->fmr_physical + fsmap->fmr_length;
	70	}
	71
7a2eef2b	72	return 0;
698c6c7c DW	73	}
	74
	75	/* Add all the summaries in the per-thread counter */
cb321a39	76	static int
0d96df9d	77	add_summaries(
593f2ab8 DW	78	struct ptvar *ptv,
	79	void *data,
	80	void *arg)
698c6c7c	81	{
593f2ab8 DW	82	struct summary_counts *total = arg;
593f2ab8 DW	83	struct summary_counts *item = data;
698c6c7c DW	84
	85	total->dbytes += item->dbytes;
	86	total->rbytes += item->rbytes;
	87	total->agbytes += item->agbytes;
cb321a39	88	return 0;
698c6c7c DW	89	}
	90
	91	/*
	92	* Count all inodes and blocks in the filesystem as told by GETFSMAP and
	93	* BULKSTAT, and compare that to summary counters. Since this is a live
	94	* filesystem we'll be content if the summary counts are within 10% of
	95	* what we observed.
	96	*/
0d96df9d DW	97	int
0d96df9d DW	98	phase7_func(
593f2ab8	99	struct scrub_ctx *ctx)
698c6c7c	100	{
593f2ab8	101	struct summary_counts totalcount = {0};
83d2c80b	102	struct action_list alist;
593f2ab8 DW	103	struct ptvar *ptvar;
	104	unsigned long long used_data;
	105	unsigned long long used_rt;
	106	unsigned long long used_files;
	107	unsigned long long stat_data;
	108	unsigned long long stat_rt;
	109	uint64_t counted_inodes = 0;
	110	unsigned long long absdiff;
	111	unsigned long long d_blocks;
	112	unsigned long long d_bfree;
	113	unsigned long long r_blocks;
	114	unsigned long long r_bfree;
593f2ab8 DW	115	bool complain;
	116	int ip;
	117	int error;
698c6c7c	118
cbaf1c9d	119	/* Check and fix the fs summary counters. */
83d2c80b	120	action_list_init(&alist);
273165cc	121	error = scrub_fs_summary(ctx, &alist);
d22f2471	122	if (error)
0d96df9d	123	return error;
bb9be147	124	error = action_list_process(ctx, -1, &alist,
cbaf1c9d	125	ALP_COMPLAIN_IF_UNFIXED \| ALP_NOPROGRESS);
83d2c80b	126	if (error)
0d96df9d	127	return error;
cbaf1c9d	128
698c6c7c	129	/* Flush everything out to disk before we start counting. */
3f9efb2e	130	error = syncfs(ctx->mnt.fd);
698c6c7c DW	131	if (error) {
698c6c7c DW	132	str_errno(ctx, ctx->mntpoint);
0d96df9d	133	return error;
698c6c7c DW	134	}
698c6c7c DW	135
2f4422f4	136	error = -ptvar_alloc(scrub_nproc(ctx), sizeof(struct summary_counts),
cb321a39 DW	137	&ptvar);
	138	if (error) {
	139	str_liberror(ctx, error, _("setting up block counter"));
0d96df9d	140	return error;
698c6c7c DW	141	}
	142
	143	/* Use fsmap to count blocks. */
7a2eef2b	144	error = scrub_scan_all_spacemaps(ctx, count_block_summary, ptvar);
0d96df9d	145	if (error)
698c6c7c	146	goto out_free;
2f4422f4	147	error = -ptvar_foreach(ptvar, add_summaries, &totalcount);
cb321a39 DW	148	if (error) {
cb321a39 DW	149	str_liberror(ctx, error, _("counting blocks"));
698c6c7c	150	goto out_free;
cb321a39	151	}
698c6c7c DW	152	ptvar_free(ptvar);
	153
	154	/* Scan the whole fs. */
934d8d3a DW	155	error = scrub_count_all_inodes(ctx, &counted_inodes);
	156	if (error) {
	157	str_liberror(ctx, error, _("counting inodes"));
0d96df9d	158	return error;
934d8d3a	159	}
698c6c7c	160
934d8d3a	161	error = scrub_scan_estimate_blocks(ctx, &d_blocks, &d_bfree, &r_blocks,
0b78ac05	162	&r_bfree, &used_files);
934d8d3a DW	163	if (error) {
934d8d3a DW	164	str_liberror(ctx, error, _("estimating verify work"));
0d96df9d	165	return error;
934d8d3a	166	}
698c6c7c DW	167
	168	/*
	169	* If we counted blocks with fsmap, then dblocks includes
	170	* blocks for the AGFL and the freespace/rmap btrees. The
	171	* filesystem treats them as "free", but since we scanned
	172	* them, we'll consider them used.
	173	*/
a749451c	174	d_bfree -= cvt_b_to_off_fsbt(&ctx->mnt, totalcount.agbytes);
698c6c7c DW	175
698c6c7c DW	176	/* Report on what we found. */
a749451c DW	177	used_data = cvt_off_fsb_to_b(&ctx->mnt, d_blocks - d_bfree);
a749451c DW	178	used_rt = cvt_off_fsb_to_b(&ctx->mnt, r_blocks - r_bfree);
698c6c7c DW	179	stat_data = totalcount.dbytes;
	180	stat_rt = totalcount.rbytes;
	181
	182	/*
	183	* Complain if the counts are off by more than 10% unless
	184	* the inaccuracy is less than 32MB worth of blocks or 100 inodes.
	185	*/
	186	absdiff = 1ULL << 25;
	187	complain = verbose;
	188	complain \|= !within_range(ctx, stat_data, used_data, absdiff, 1, 10,
	189	_("data blocks"));
	190	complain \|= !within_range(ctx, stat_rt, used_rt, absdiff, 1, 10,
	191	_("realtime blocks"));
	192	complain \|= !within_range(ctx, counted_inodes, used_files, 100, 1, 10,
	193	_("inodes"));
	194
	195	if (complain) {
	196	double d, r, i;
	197	char du, ru, *iu;
	198
	199	if (used_rt \|\| stat_rt) {
	200	d = auto_space_units(used_data, &du);
	201	r = auto_space_units(used_rt, &ru);
058f45da	202	i = auto_units(used_files, &iu, &ip);
698c6c7c	203	fprintf(stdout,
058f45da DW	204	_("%.1f%s data used; %.1f%s realtime data used; %.*f%s inodes used.\n"),
058f45da DW	205	d, du, r, ru, ip, i, iu);
698c6c7c DW	206	d = auto_space_units(stat_data, &du);
698c6c7c DW	207	r = auto_space_units(stat_rt, &ru);
058f45da	208	i = auto_units(counted_inodes, &iu, &ip);
698c6c7c	209	fprintf(stdout,
058f45da DW	210	_("%.1f%s data found; %.1f%s realtime data found; %.*f%s inodes found.\n"),
058f45da DW	211	d, du, r, ru, ip, i, iu);
698c6c7c DW	212	} else {
698c6c7c DW	213	d = auto_space_units(used_data, &du);
058f45da	214	i = auto_units(used_files, &iu, &ip);
698c6c7c	215	fprintf(stdout,
058f45da DW	216	_("%.1f%s data used; %.*f%s inodes used.\n"),
058f45da DW	217	d, du, ip, i, iu);
698c6c7c	218	d = auto_space_units(stat_data, &du);
058f45da	219	i = auto_units(counted_inodes, &iu, &ip);
698c6c7c	220	fprintf(stdout,
058f45da DW	221	_("%.1f%s data found; %.*f%s inodes found.\n"),
058f45da DW	222	d, du, ip, i, iu);
698c6c7c DW	223	}
	224	fflush(stdout);
	225	}
	226
	227	/*
	228	* Complain if the checked inode counts are off, which
	229	* implies an incomplete check.
	230	*/
	231	if (verbose \|\|
	232	!within_range(ctx, counted_inodes, ctx->inodes_checked, 100, 1, 10,
	233	_("checked inodes"))) {
	234	double i1, i2;
	235	char i1u, i2u;
058f45da	236	int i1p, i2p;
698c6c7c	237
058f45da DW	238	i1 = auto_units(counted_inodes, &i1u, &i1p);
058f45da DW	239	i2 = auto_units(ctx->inodes_checked, &i2u, &i2p);
698c6c7c	240	fprintf(stdout,
058f45da DW	241	_("%.f%s inodes counted; %.f%s inodes checked.\n"),
058f45da DW	242	i1p, i1, i1u, i2p, i2, i2u);
698c6c7c DW	243	fflush(stdout);
	244	}
	245
	246	/*
	247	* Complain if the checked block counts are off, which
	248	* implies an incomplete check.
	249	*/
	250	if (ctx->bytes_checked &&
	251	(verbose \|\|
	252	!within_range(ctx, used_data + used_rt,
	253	ctx->bytes_checked, absdiff, 1, 10,
	254	_("verified blocks")))) {
	255	double b1, b2;
	256	char b1u, b2u;
	257
	258	b1 = auto_space_units(used_data + used_rt, &b1u);
	259	b2 = auto_space_units(ctx->bytes_checked, &b2u);
	260	fprintf(stdout,
	261	_("%.1f%s data counted; %.1f%s data verified.\n"),
	262	b1, b1u, b2, b2u);
	263	fflush(stdout);
	264	}
	265
0d96df9d	266	return 0;
698c6c7c DW	267	out_free:
698c6c7c DW	268	ptvar_free(ptvar);
0d96df9d DW	269	return error;
0d96df9d DW	270	}