[linux.git] / fs / xfs / xfs_health.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * Copyright (C) 2019 Oracle.  All Rights Reserved.
 * Author: Darrick J. Wong <[email protected]>
 */
#include "xfs.h"
#include "xfs_fs.h"
#include "xfs_shared.h"
#include "xfs_format.h"
#include "xfs_log_format.h"
#include "xfs_trans_resv.h"
#include "xfs_mount.h"
#include "xfs_inode.h"
#include "xfs_trace.h"
#include "xfs_health.h"
#include "xfs_ag.h"

/*
 * Warn about metadata corruption that we detected but haven't fixed, and
 * make sure we're not sitting on anything that would get in the way of
 * recovery.
 */
void
xfs_health_unmount(
	struct xfs_mount	*mp)
{
	struct xfs_perag	*pag;
	xfs_agnumber_t		agno;
	unsigned int		sick = 0;
	unsigned int		checked = 0;
	bool			warn = false;

	if (XFS_FORCED_SHUTDOWN(mp))
		return;

	/* Measure AG corruption levels. */
	for_each_perag(mp, agno, pag) {
		xfs_ag_measure_sickness(pag, &sick, &checked);
		if (sick) {
			trace_xfs_ag_unfixed_corruption(mp, agno, sick);
			warn = true;
		}
	}

	/* Measure realtime volume corruption levels. */
	xfs_rt_measure_sickness(mp, &sick, &checked);
	if (sick) {
		trace_xfs_rt_unfixed_corruption(mp, sick);
		warn = true;
	}

	/*
	 * Measure fs corruption and keep the sample around for the warning.
	 * See the note below for why we exempt FS_COUNTERS.
	 */
	xfs_fs_measure_sickness(mp, &sick, &checked);
	if (sick & ~XFS_SICK_FS_COUNTERS) {
		trace_xfs_fs_unfixed_corruption(mp, sick);
		warn = true;
	}

	if (warn) {
		xfs_warn(mp,
"Uncorrected metadata errors detected; please run xfs_repair.");

		/*
		 * We discovered uncorrected metadata problems at some point
		 * during this filesystem mount and have advised the
		 * administrator to run repair once the unmount completes.
		 *
		 * However, we must be careful -- when FSCOUNTERS are flagged
		 * unhealthy, the unmount procedure omits writing the clean
		 * unmount record to the log so that the next mount will run
		 * recovery and recompute the summary counters.  In other
		 * words, we leave a dirty log to get the counters fixed.
		 *
		 * Unfortunately, xfs_repair cannot recover dirty logs, so if
		 * there were filesystem problems, FSCOUNTERS was flagged, and
		 * the administrator takes our advice to run xfs_repair,
		 * they'll have to zap the log before repairing structures.
		 * We don't really want to encourage this, so we mark the
		 * FSCOUNTERS healthy so that a subsequent repair run won't see
		 * a dirty log.
		 */
		if (sick & XFS_SICK_FS_COUNTERS)
			xfs_fs_mark_healthy(mp, XFS_SICK_FS_COUNTERS);
	}
}

/* Mark unhealthy per-fs metadata. */
void
xfs_fs_mark_sick(
	struct xfs_mount	*mp,
	unsigned int		mask)
{
	ASSERT(!(mask & ~XFS_SICK_FS_PRIMARY));
	trace_xfs_fs_mark_sick(mp, mask);

	spin_lock(&mp->m_sb_lock);
	mp->m_fs_sick |= mask;
	mp->m_fs_checked |= mask;
	spin_unlock(&mp->m_sb_lock);
}

/* Mark a per-fs metadata healed. */
void
xfs_fs_mark_healthy(
	struct xfs_mount	*mp,
	unsigned int		mask)
{
	ASSERT(!(mask & ~XFS_SICK_FS_PRIMARY));
	trace_xfs_fs_mark_healthy(mp, mask);

	spin_lock(&mp->m_sb_lock);
	mp->m_fs_sick &= ~mask;
	mp->m_fs_checked |= mask;
	spin_unlock(&mp->m_sb_lock);
}

/* Sample which per-fs metadata are unhealthy. */
void
xfs_fs_measure_sickness(
	struct xfs_mount	*mp,
	unsigned int		*sick,
	unsigned int		*checked)
{
	spin_lock(&mp->m_sb_lock);
	*sick = mp->m_fs_sick;
	*checked = mp->m_fs_checked;
	spin_unlock(&mp->m_sb_lock);
}

/* Mark unhealthy realtime metadata. */
void
xfs_rt_mark_sick(
	struct xfs_mount	*mp,
	unsigned int		mask)
{
	ASSERT(!(mask & ~XFS_SICK_RT_PRIMARY));
	trace_xfs_rt_mark_sick(mp, mask);

	spin_lock(&mp->m_sb_lock);
	mp->m_rt_sick |= mask;
	mp->m_rt_checked |= mask;
	spin_unlock(&mp->m_sb_lock);
}

/* Mark a realtime metadata healed. */
void
xfs_rt_mark_healthy(
	struct xfs_mount	*mp,
	unsigned int		mask)
{
	ASSERT(!(mask & ~XFS_SICK_RT_PRIMARY));
	trace_xfs_rt_mark_healthy(mp, mask);

	spin_lock(&mp->m_sb_lock);
	mp->m_rt_sick &= ~mask;
	mp->m_rt_checked |= mask;
	spin_unlock(&mp->m_sb_lock);
}

/* Sample which realtime metadata are unhealthy. */
void
xfs_rt_measure_sickness(
	struct xfs_mount	*mp,
	unsigned int		*sick,
	unsigned int		*checked)
{
	spin_lock(&mp->m_sb_lock);
	*sick = mp->m_rt_sick;
	*checked = mp->m_rt_checked;
	spin_unlock(&mp->m_sb_lock);
}

/* Mark unhealthy per-ag metadata. */
void
xfs_ag_mark_sick(
	struct xfs_perag	*pag,
	unsigned int		mask)
{
	ASSERT(!(mask & ~XFS_SICK_AG_PRIMARY));
	trace_xfs_ag_mark_sick(pag->pag_mount, pag->pag_agno, mask);

	spin_lock(&pag->pag_state_lock);
	pag->pag_sick |= mask;
	pag->pag_checked |= mask;
	spin_unlock(&pag->pag_state_lock);
}

/* Mark per-ag metadata ok. */
void
xfs_ag_mark_healthy(
	struct xfs_perag	*pag,
	unsigned int		mask)
{
	ASSERT(!(mask & ~XFS_SICK_AG_PRIMARY));
	trace_xfs_ag_mark_healthy(pag->pag_mount, pag->pag_agno, mask);

	spin_lock(&pag->pag_state_lock);
	pag->pag_sick &= ~mask;
	pag->pag_checked |= mask;
	spin_unlock(&pag->pag_state_lock);
}

/* Sample which per-ag metadata are unhealthy. */
void
xfs_ag_measure_sickness(
	struct xfs_perag	*pag,
	unsigned int		*sick,
	unsigned int		*checked)
{
	spin_lock(&pag->pag_state_lock);
	*sick = pag->pag_sick;
	*checked = pag->pag_checked;
	spin_unlock(&pag->pag_state_lock);
}

/* Mark the unhealthy parts of an inode. */
void
xfs_inode_mark_sick(
	struct xfs_inode	*ip,
	unsigned int		mask)
{
	ASSERT(!(mask & ~XFS_SICK_INO_PRIMARY));
	trace_xfs_inode_mark_sick(ip, mask);

	spin_lock(&ip->i_flags_lock);
	ip->i_sick |= mask;
	ip->i_checked |= mask;
	spin_unlock(&ip->i_flags_lock);

	/*
	 * Keep this inode around so we don't lose the sickness report.  Scrub
	 * grabs inodes with DONTCACHE assuming that most inode are ok, which
	 * is not the case here.
	 */
	spin_lock(&VFS_I(ip)->i_lock);
	VFS_I(ip)->i_state &= ~I_DONTCACHE;
	spin_unlock(&VFS_I(ip)->i_lock);
}

/* Mark parts of an inode healed. */
void
xfs_inode_mark_healthy(
	struct xfs_inode	*ip,
	unsigned int		mask)
{
	ASSERT(!(mask & ~XFS_SICK_INO_PRIMARY));
	trace_xfs_inode_mark_healthy(ip, mask);

	spin_lock(&ip->i_flags_lock);
	ip->i_sick &= ~mask;
	ip->i_checked |= mask;
	spin_unlock(&ip->i_flags_lock);
}

/* Sample which parts of an inode are unhealthy. */
void
xfs_inode_measure_sickness(
	struct xfs_inode	*ip,
	unsigned int		*sick,
	unsigned int		*checked)
{
	spin_lock(&ip->i_flags_lock);
	*sick = ip->i_sick;
	*checked = ip->i_checked;
	spin_unlock(&ip->i_flags_lock);
}

/* Mappings between internal sick masks and ioctl sick masks. */

struct ioctl_sick_map {
	unsigned int		sick_mask;
	unsigned int		ioctl_mask;
};

static const struct ioctl_sick_map fs_map[] = {
	{ XFS_SICK_FS_COUNTERS,	XFS_FSOP_GEOM_SICK_COUNTERS},
	{ XFS_SICK_FS_UQUOTA,	XFS_FSOP_GEOM_SICK_UQUOTA },
	{ XFS_SICK_FS_GQUOTA,	XFS_FSOP_GEOM_SICK_GQUOTA },
	{ XFS_SICK_FS_PQUOTA,	XFS_FSOP_GEOM_SICK_PQUOTA },
	{ 0, 0 },
};

static const struct ioctl_sick_map rt_map[] = {
	{ XFS_SICK_RT_BITMAP,	XFS_FSOP_GEOM_SICK_RT_BITMAP },
	{ XFS_SICK_RT_SUMMARY,	XFS_FSOP_GEOM_SICK_RT_SUMMARY },
	{ 0, 0 },
};

static inline void
xfgeo_health_tick(
	struct xfs_fsop_geom		*geo,
	unsigned int			sick,
	unsigned int			checked,
	const struct ioctl_sick_map	*m)
{
	if (checked & m->sick_mask)
		geo->checked |= m->ioctl_mask;
	if (sick & m->sick_mask)
		geo->sick |= m->ioctl_mask;
}

/* Fill out fs geometry health info. */
void
xfs_fsop_geom_health(
	struct xfs_mount		*mp,
	struct xfs_fsop_geom		*geo)
{
	const struct ioctl_sick_map	*m;
	unsigned int			sick;
	unsigned int			checked;

	geo->sick = 0;
	geo->checked = 0;

	xfs_fs_measure_sickness(mp, &sick, &checked);
	for (m = fs_map; m->sick_mask; m++)
		xfgeo_health_tick(geo, sick, checked, m);

	xfs_rt_measure_sickness(mp, &sick, &checked);
	for (m = rt_map; m->sick_mask; m++)
		xfgeo_health_tick(geo, sick, checked, m);
}

static const struct ioctl_sick_map ag_map[] = {
	{ XFS_SICK_AG_SB,	XFS_AG_GEOM_SICK_SB },
	{ XFS_SICK_AG_AGF,	XFS_AG_GEOM_SICK_AGF },
	{ XFS_SICK_AG_AGFL,	XFS_AG_GEOM_SICK_AGFL },
	{ XFS_SICK_AG_AGI,	XFS_AG_GEOM_SICK_AGI },
	{ XFS_SICK_AG_BNOBT,	XFS_AG_GEOM_SICK_BNOBT },
	{ XFS_SICK_AG_CNTBT,	XFS_AG_GEOM_SICK_CNTBT },
	{ XFS_SICK_AG_INOBT,	XFS_AG_GEOM_SICK_INOBT },
	{ XFS_SICK_AG_FINOBT,	XFS_AG_GEOM_SICK_FINOBT },
	{ XFS_SICK_AG_RMAPBT,	XFS_AG_GEOM_SICK_RMAPBT },
	{ XFS_SICK_AG_REFCNTBT,	XFS_AG_GEOM_SICK_REFCNTBT },
	{ 0, 0 },
};

/* Fill out ag geometry health info. */
void
xfs_ag_geom_health(
	struct xfs_perag		*pag,
	struct xfs_ag_geometry		*ageo)
{
	const struct ioctl_sick_map	*m;
	unsigned int			sick;
	unsigned int			checked;

	ageo->ag_sick = 0;
	ageo->ag_checked = 0;

	xfs_ag_measure_sickness(pag, &sick, &checked);
	for (m = ag_map; m->sick_mask; m++) {
		if (checked & m->sick_mask)
			ageo->ag_checked |= m->ioctl_mask;
		if (sick & m->sick_mask)
			ageo->ag_sick |= m->ioctl_mask;
	}
}

static const struct ioctl_sick_map ino_map[] = {
	{ XFS_SICK_INO_CORE,	XFS_BS_SICK_INODE },
	{ XFS_SICK_INO_BMBTD,	XFS_BS_SICK_BMBTD },
	{ XFS_SICK_INO_BMBTA,	XFS_BS_SICK_BMBTA },
	{ XFS_SICK_INO_BMBTC,	XFS_BS_SICK_BMBTC },
	{ XFS_SICK_INO_DIR,	XFS_BS_SICK_DIR },
	{ XFS_SICK_INO_XATTR,	XFS_BS_SICK_XATTR },
	{ XFS_SICK_INO_SYMLINK,	XFS_BS_SICK_SYMLINK },
	{ XFS_SICK_INO_PARENT,	XFS_BS_SICK_PARENT },
	{ 0, 0 },
};

/* Fill out bulkstat health info. */
void
xfs_bulkstat_health(
	struct xfs_inode		*ip,
	struct xfs_bulkstat		*bs)
{
	const struct ioctl_sick_map	*m;
	unsigned int			sick;
	unsigned int			checked;

	bs->bs_sick = 0;
	bs->bs_checked = 0;

	xfs_inode_measure_sickness(ip, &sick, &checked);
	for (m = ino_map; m->sick_mask; m++) {
		if (checked & m->sick_mask)
			bs->bs_checked |= m->ioctl_mask;
		if (sick & m->sick_mask)
			bs->bs_sick |= m->ioctl_mask;
	}
}
Commit	Line	Data
6772c1f1 DW	1	// SPDX-License-Identifier: GPL-2.0+
	2	/*
	3	* Copyright (C) 2019 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_log_format.h"
	11	#include "xfs_trans_resv.h"
6772c1f1	12	#include "xfs_mount.h"
6772c1f1 DW	13	#include "xfs_inode.h"
	14	#include "xfs_trace.h"
	15	#include "xfs_health.h"
9bbafc71	16	#include "xfs_ag.h"
6772c1f1	17
519841c2 DW	18	/*
	19	* Warn about metadata corruption that we detected but haven't fixed, and
	20	* make sure we're not sitting on anything that would get in the way of
	21	* recovery.
	22	*/
	23	void
	24	xfs_health_unmount(
	25	struct xfs_mount *mp)
	26	{
	27	struct xfs_perag *pag;
	28	xfs_agnumber_t agno;
	29	unsigned int sick = 0;
	30	unsigned int checked = 0;
	31	bool warn = false;
	32
	33	if (XFS_FORCED_SHUTDOWN(mp))
	34	return;
	35
	36	/* Measure AG corruption levels. */
f250eedc	37	for_each_perag(mp, agno, pag) {
519841c2 DW	38	xfs_ag_measure_sickness(pag, &sick, &checked);
	39	if (sick) {
	40	trace_xfs_ag_unfixed_corruption(mp, agno, sick);
	41	warn = true;
	42	}
519841c2 DW	43	}
	44
	45	/* Measure realtime volume corruption levels. */
	46	xfs_rt_measure_sickness(mp, &sick, &checked);
	47	if (sick) {
	48	trace_xfs_rt_unfixed_corruption(mp, sick);
	49	warn = true;
	50	}
	51
	52	/*
	53	* Measure fs corruption and keep the sample around for the warning.
	54	* See the note below for why we exempt FS_COUNTERS.
	55	*/
	56	xfs_fs_measure_sickness(mp, &sick, &checked);
	57	if (sick & ~XFS_SICK_FS_COUNTERS) {
	58	trace_xfs_fs_unfixed_corruption(mp, sick);
	59	warn = true;
	60	}
	61
	62	if (warn) {
	63	xfs_warn(mp,
	64	"Uncorrected metadata errors detected; please run xfs_repair.");
	65
	66	/*
	67	* We discovered uncorrected metadata problems at some point
	68	* during this filesystem mount and have advised the
	69	* administrator to run repair once the unmount completes.
	70	*
	71	* However, we must be careful -- when FSCOUNTERS are flagged
	72	* unhealthy, the unmount procedure omits writing the clean
	73	* unmount record to the log so that the next mount will run
	74	* recovery and recompute the summary counters. In other
	75	* words, we leave a dirty log to get the counters fixed.
	76	*
	77	* Unfortunately, xfs_repair cannot recover dirty logs, so if
	78	* there were filesystem problems, FSCOUNTERS was flagged, and
	79	* the administrator takes our advice to run xfs_repair,
	80	* they'll have to zap the log before repairing structures.
	81	* We don't really want to encourage this, so we mark the
	82	* FSCOUNTERS healthy so that a subsequent repair run won't see
	83	* a dirty log.
	84	*/
	85	if (sick & XFS_SICK_FS_COUNTERS)
	86	xfs_fs_mark_healthy(mp, XFS_SICK_FS_COUNTERS);
	87	}
	88	}
	89
6772c1f1 DW	90	/* Mark unhealthy per-fs metadata. */
	91	void
	92	xfs_fs_mark_sick(
	93	struct xfs_mount *mp,
	94	unsigned int mask)
	95	{
	96	ASSERT(!(mask & ~XFS_SICK_FS_PRIMARY));
	97	trace_xfs_fs_mark_sick(mp, mask);
	98
	99	spin_lock(&mp->m_sb_lock);
	100	mp->m_fs_sick \|= mask;
	101	mp->m_fs_checked \|= mask;
	102	spin_unlock(&mp->m_sb_lock);
	103	}
	104
	105	/* Mark a per-fs metadata healed. */
	106	void
	107	xfs_fs_mark_healthy(
	108	struct xfs_mount *mp,
	109	unsigned int mask)
	110	{
	111	ASSERT(!(mask & ~XFS_SICK_FS_PRIMARY));
	112	trace_xfs_fs_mark_healthy(mp, mask);
	113
	114	spin_lock(&mp->m_sb_lock);
	115	mp->m_fs_sick &= ~mask;
	116	mp->m_fs_checked \|= mask;
	117	spin_unlock(&mp->m_sb_lock);
	118	}
	119
	120	/* Sample which per-fs metadata are unhealthy. */
	121	void
	122	xfs_fs_measure_sickness(
	123	struct xfs_mount *mp,
	124	unsigned int *sick,
	125	unsigned int *checked)
	126	{
	127	spin_lock(&mp->m_sb_lock);
	128	*sick = mp->m_fs_sick;
	129	*checked = mp->m_fs_checked;
	130	spin_unlock(&mp->m_sb_lock);
	131	}
	132
	133	/* Mark unhealthy realtime metadata. */
	134	void
	135	xfs_rt_mark_sick(
	136	struct xfs_mount *mp,
	137	unsigned int mask)
	138	{
	139	ASSERT(!(mask & ~XFS_SICK_RT_PRIMARY));
	140	trace_xfs_rt_mark_sick(mp, mask);
	141
	142	spin_lock(&mp->m_sb_lock);
	143	mp->m_rt_sick \|= mask;
	144	mp->m_rt_checked \|= mask;
	145	spin_unlock(&mp->m_sb_lock);
	146	}
	147
	148	/* Mark a realtime metadata healed. */
	149	void
	150	xfs_rt_mark_healthy(
	151	struct xfs_mount *mp,
	152	unsigned int mask)
	153	{
154	ASSERT(!(mask & ~XFS_SICK_RT_PRIMARY));
155	trace_xfs_rt_mark_healthy(mp, mask);
156
157	spin_lock(&mp->m_sb_lock);
158	mp->m_rt_sick &= ~mask;
159	mp->m_rt_checked \|= mask;
160	spin_unlock(&mp->m_sb_lock);
161	}
162
163	/* Sample which realtime metadata are unhealthy. */
164	void
165	xfs_rt_measure_sickness(
166	struct xfs_mount *mp,
167	unsigned int *sick,
168	unsigned int *checked)
169	{
170	spin_lock(&mp->m_sb_lock);
171	*sick = mp->m_rt_sick;
172	*checked = mp->m_rt_checked;
173	spin_unlock(&mp->m_sb_lock);
174	}
175
176	/* Mark unhealthy per-ag metadata. */
177	void
178	xfs_ag_mark_sick(
179	struct xfs_perag *pag,
180	unsigned int mask)
181	{
182	ASSERT(!(mask & ~XFS_SICK_AG_PRIMARY));
183	trace_xfs_ag_mark_sick(pag->pag_mount, pag->pag_agno, mask);
184
185	spin_lock(&pag->pag_state_lock);
186	pag->pag_sick \|= mask;
187	pag->pag_checked \|= mask;
188	spin_unlock(&pag->pag_state_lock);
189	}
190
191	/* Mark per-ag metadata ok. */
192	void
193	xfs_ag_mark_healthy(
194	struct xfs_perag *pag,
195	unsigned int mask)
196	{
197	ASSERT(!(mask & ~XFS_SICK_AG_PRIMARY));
198	trace_xfs_ag_mark_healthy(pag->pag_mount, pag->pag_agno, mask);
199
200	spin_lock(&pag->pag_state_lock);
201	pag->pag_sick &= ~mask;
202	pag->pag_checked \|= mask;
203	spin_unlock(&pag->pag_state_lock);
204	}
205
206	/* Sample which per-ag metadata are unhealthy. */
207	void
208	xfs_ag_measure_sickness(
209	struct xfs_perag *pag,
210	unsigned int *sick,
211	unsigned int *checked)
212	{
213	spin_lock(&pag->pag_state_lock);
214	*sick = pag->pag_sick;
215	*checked = pag->pag_checked;
216	spin_unlock(&pag->pag_state_lock);
217	}
218
219	/* Mark the unhealthy parts of an inode. */
220	void
221	xfs_inode_mark_sick(
222	struct xfs_inode *ip,
223	unsigned int mask)
224	{
225	ASSERT(!(mask & ~XFS_SICK_INO_PRIMARY));
226	trace_xfs_inode_mark_sick(ip, mask);
227
228	spin_lock(&ip->i_flags_lock);
229	ip->i_sick \|= mask;
230	ip->i_checked \|= mask;
231	spin_unlock(&ip->i_flags_lock);
7975e465 DW	232
	233	/*
	234	* Keep this inode around so we don't lose the sickness report. Scrub
	235	* grabs inodes with DONTCACHE assuming that most inode are ok, which
	236	* is not the case here.
	237	*/
	238	spin_lock(&VFS_I(ip)->i_lock);
	239	VFS_I(ip)->i_state &= ~I_DONTCACHE;
	240	spin_unlock(&VFS_I(ip)->i_lock);
6772c1f1 DW	241	}
	242
	243	/* Mark parts of an inode healed. */
	244	void
	245	xfs_inode_mark_healthy(
	246	struct xfs_inode *ip,
	247	unsigned int mask)
	248	{
	249	ASSERT(!(mask & ~XFS_SICK_INO_PRIMARY));
	250	trace_xfs_inode_mark_healthy(ip, mask);
	251
	252	spin_lock(&ip->i_flags_lock);
	253	ip->i_sick &= ~mask;
	254	ip->i_checked \|= mask;
	255	spin_unlock(&ip->i_flags_lock);
	256	}
	257
	258	/* Sample which parts of an inode are unhealthy. */
	259	void
	260	xfs_inode_measure_sickness(
	261	struct xfs_inode *ip,
	262	unsigned int *sick,
	263	unsigned int *checked)
	264	{
	265	spin_lock(&ip->i_flags_lock);
	266	*sick = ip->i_sick;
	267	*checked = ip->i_checked;
	268	spin_unlock(&ip->i_flags_lock);
	269	}
c23232d4 DW	270
	271	/* Mappings between internal sick masks and ioctl sick masks. */
	272
	273	struct ioctl_sick_map {
	274	unsigned int sick_mask;
	275	unsigned int ioctl_mask;
	276	};
	277
	278	static const struct ioctl_sick_map fs_map[] = {
	279	{ XFS_SICK_FS_COUNTERS, XFS_FSOP_GEOM_SICK_COUNTERS},
	280	{ XFS_SICK_FS_UQUOTA, XFS_FSOP_GEOM_SICK_UQUOTA },
	281	{ XFS_SICK_FS_GQUOTA, XFS_FSOP_GEOM_SICK_GQUOTA },
	282	{ XFS_SICK_FS_PQUOTA, XFS_FSOP_GEOM_SICK_PQUOTA },
	283	{ 0, 0 },
	284	};
	285
	286	static const struct ioctl_sick_map rt_map[] = {
	287	{ XFS_SICK_RT_BITMAP, XFS_FSOP_GEOM_SICK_RT_BITMAP },
	288	{ XFS_SICK_RT_SUMMARY, XFS_FSOP_GEOM_SICK_RT_SUMMARY },
	289	{ 0, 0 },
	290	};
	291
	292	static inline void
	293	xfgeo_health_tick(
	294	struct xfs_fsop_geom *geo,
	295	unsigned int sick,
	296	unsigned int checked,
	297	const struct ioctl_sick_map *m)
	298	{
	299	if (checked & m->sick_mask)
	300	geo->checked \|= m->ioctl_mask;
	301	if (sick & m->sick_mask)
	302	geo->sick \|= m->ioctl_mask;
	303	}
	304
	305	/* Fill out fs geometry health info. */
	306	void
	307	xfs_fsop_geom_health(
	308	struct xfs_mount *mp,
	309	struct xfs_fsop_geom *geo)
	310	{
	311	const struct ioctl_sick_map *m;
	312	unsigned int sick;
	313	unsigned int checked;
	314
	315	geo->sick = 0;
	316	geo->checked = 0;
	317
	318	xfs_fs_measure_sickness(mp, &sick, &checked);
	319	for (m = fs_map; m->sick_mask; m++)
	320	xfgeo_health_tick(geo, sick, checked, m);
	321
	322	xfs_rt_measure_sickness(mp, &sick, &checked);
	323	for (m = rt_map; m->sick_mask; m++)
	324	xfgeo_health_tick(geo, sick, checked, m);
	325	}
1302c6a2 DW	326
	327	static const struct ioctl_sick_map ag_map[] = {
	328	{ XFS_SICK_AG_SB, XFS_AG_GEOM_SICK_SB },
	329	{ XFS_SICK_AG_AGF, XFS_AG_GEOM_SICK_AGF },
	330	{ XFS_SICK_AG_AGFL, XFS_AG_GEOM_SICK_AGFL },
	331	{ XFS_SICK_AG_AGI, XFS_AG_GEOM_SICK_AGI },
	332	{ XFS_SICK_AG_BNOBT, XFS_AG_GEOM_SICK_BNOBT },
	333	{ XFS_SICK_AG_CNTBT, XFS_AG_GEOM_SICK_CNTBT },
	334	{ XFS_SICK_AG_INOBT, XFS_AG_GEOM_SICK_INOBT },
	335	{ XFS_SICK_AG_FINOBT, XFS_AG_GEOM_SICK_FINOBT },
	336	{ XFS_SICK_AG_RMAPBT, XFS_AG_GEOM_SICK_RMAPBT },
	337	{ XFS_SICK_AG_REFCNTBT, XFS_AG_GEOM_SICK_REFCNTBT },
	338	{ 0, 0 },
	339	};
	340
	341	/* Fill out ag geometry health info. */
	342	void
	343	xfs_ag_geom_health(
	344	struct xfs_perag *pag,
	345	struct xfs_ag_geometry *ageo)
	346	{
	347	const struct ioctl_sick_map *m;
	348	unsigned int sick;
	349	unsigned int checked;
	350
	351	ageo->ag_sick = 0;
	352	ageo->ag_checked = 0;
	353
	354	xfs_ag_measure_sickness(pag, &sick, &checked);
	355	for (m = ag_map; m->sick_mask; m++) {
	356	if (checked & m->sick_mask)
	357	ageo->ag_checked \|= m->ioctl_mask;
	358	if (sick & m->sick_mask)
	359	ageo->ag_sick \|= m->ioctl_mask;
	360	}
	361	}
89d139d5 DW	362
	363	static const struct ioctl_sick_map ino_map[] = {
	364	{ XFS_SICK_INO_CORE, XFS_BS_SICK_INODE },
	365	{ XFS_SICK_INO_BMBTD, XFS_BS_SICK_BMBTD },
	366	{ XFS_SICK_INO_BMBTA, XFS_BS_SICK_BMBTA },
	367	{ XFS_SICK_INO_BMBTC, XFS_BS_SICK_BMBTC },
	368	{ XFS_SICK_INO_DIR, XFS_BS_SICK_DIR },
	369	{ XFS_SICK_INO_XATTR, XFS_BS_SICK_XATTR },
	370	{ XFS_SICK_INO_SYMLINK, XFS_BS_SICK_SYMLINK },
	371	{ XFS_SICK_INO_PARENT, XFS_BS_SICK_PARENT },
	372	{ 0, 0 },
	373	};
	374
	375	/* Fill out bulkstat health info. */
	376	void
	377	xfs_bulkstat_health(
	378	struct xfs_inode *ip,
7035f972	379	struct xfs_bulkstat *bs)
89d139d5 DW	380	{
	381	const struct ioctl_sick_map *m;
	382	unsigned int sick;
	383	unsigned int checked;
	384
	385	bs->bs_sick = 0;
	386	bs->bs_checked = 0;
	387
	388	xfs_inode_measure_sickness(ip, &sick, &checked);
	389	for (m = ino_map; m->sick_mask; m++) {
	390	if (checked & m->sick_mask)
	391	bs->bs_checked \|= m->ioctl_mask;
	392	if (sick & m->sick_mask)
	393	bs->bs_sick \|= m->ioctl_mask;
	394	}
	395	}