1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * Copyright (C) 2019 Oracle.  All Rights Reserved.
4 * Author: Darrick J. Wong <darrick.wong@oracle.com>
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"
12#include "xfs_mount.h"
13#include "xfs_inode.h"
14#include "xfs_trace.h"
15#include "xfs_health.h"
16#include "xfs_ag.h"
17
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 */
23void
24xfs_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_is_shutdown(mp))
34		return;
35
36	/* Measure AG corruption levels. */
37	for_each_perag(mp, agno, pag) {
38		xfs_ag_measure_sickness(pag, &sick, &checked);
39		if (sick) {
40			trace_xfs_ag_unfixed_corruption(mp, agno, sick);
41			warn = true;
42		}
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
90/* Mark unhealthy per-fs metadata. */
91void
92xfs_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. */
106void
107xfs_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. */
121void
122xfs_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. */
134void
135xfs_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. */
149void
150xfs_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. */
164void
165xfs_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. */
177void
178xfs_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. */
192void
193xfs_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. */
207void
208xfs_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. */
220void
221xfs_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);
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);
241}
242
243/* Mark parts of an inode healed. */
244void
245xfs_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. */
259void
260xfs_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}
270
271/* Mappings between internal sick masks and ioctl sick masks. */
272
273struct ioctl_sick_map {
274	unsigned int		sick_mask;
275	unsigned int		ioctl_mask;
276};
277
278static 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
286static 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
292static inline void
293xfgeo_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. */
306void
307xfs_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}
326
327static 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. */
342void
343xfs_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}
362
363static 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. */
376void
377xfs_bulkstat_health(
378	struct xfs_inode		*ip,
379	struct xfs_bulkstat		*bs)
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}
396