1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * Copyright (C) 2018 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_trans_resv.h"
11 #include "xfs_mount.h"
12 #include "xfs_btree.h"
13 #include "xfs_log_format.h"
14 #include "xfs_trans.h"
15 #include "xfs_sb.h"
16 #include "xfs_inode.h"
17 #include "xfs_alloc.h"
18 #include "xfs_alloc_btree.h"
19 #include "xfs_ialloc.h"
20 #include "xfs_ialloc_btree.h"
21 #include "xfs_rmap.h"
22 #include "xfs_rmap_btree.h"
23 #include "xfs_refcount_btree.h"
24 #include "xfs_extent_busy.h"
25 #include "xfs_ag.h"
26 #include "xfs_ag_resv.h"
27 #include "xfs_quota.h"
28 #include "xfs_qm.h"
29 #include "scrub/scrub.h"
30 #include "scrub/common.h"
31 #include "scrub/trace.h"
32 #include "scrub/repair.h"
33 #include "scrub/bitmap.h"
34 
35 /*
36  * Attempt to repair some metadata, if the metadata is corrupt and userspace
37  * told us to fix it.  This function returns -EAGAIN to mean "re-run scrub",
38  * and will set *fixed to true if it thinks it repaired anything.
39  */
40 int
xrep_attempt(struct xfs_scrub * sc)41 xrep_attempt(
42 	struct xfs_scrub	*sc)
43 {
44 	int			error = 0;
45 
46 	trace_xrep_attempt(XFS_I(file_inode(sc->file)), sc->sm, error);
47 
48 	xchk_ag_btcur_free(&sc->sa);
49 
50 	/* Repair whatever's broken. */
51 	ASSERT(sc->ops->repair);
52 	error = sc->ops->repair(sc);
53 	trace_xrep_done(XFS_I(file_inode(sc->file)), sc->sm, error);
54 	switch (error) {
55 	case 0:
56 		/*
57 		 * Repair succeeded.  Commit the fixes and perform a second
58 		 * scrub so that we can tell userspace if we fixed the problem.
59 		 */
60 		sc->sm->sm_flags &= ~XFS_SCRUB_FLAGS_OUT;
61 		sc->flags |= XREP_ALREADY_FIXED;
62 		return -EAGAIN;
63 	case -EDEADLOCK:
64 	case -EAGAIN:
65 		/* Tell the caller to try again having grabbed all the locks. */
66 		if (!(sc->flags & XCHK_TRY_HARDER)) {
67 			sc->flags |= XCHK_TRY_HARDER;
68 			return -EAGAIN;
69 		}
70 		/*
71 		 * We tried harder but still couldn't grab all the resources
72 		 * we needed to fix it.  The corruption has not been fixed,
73 		 * so report back to userspace.
74 		 */
75 		return -EFSCORRUPTED;
76 	default:
77 		return error;
78 	}
79 }
80 
81 /*
82  * Complain about unfixable problems in the filesystem.  We don't log
83  * corruptions when IFLAG_REPAIR wasn't set on the assumption that the driver
84  * program is xfs_scrub, which will call back with IFLAG_REPAIR set if the
85  * administrator isn't running xfs_scrub in no-repairs mode.
86  *
87  * Use this helper function because _ratelimited silently declares a static
88  * structure to track rate limiting information.
89  */
90 void
xrep_failure(struct xfs_mount * mp)91 xrep_failure(
92 	struct xfs_mount	*mp)
93 {
94 	xfs_alert_ratelimited(mp,
95 "Corruption not fixed during online repair.  Unmount and run xfs_repair.");
96 }
97 
98 /*
99  * Repair probe -- userspace uses this to probe if we're willing to repair a
100  * given mountpoint.
101  */
102 int
xrep_probe(struct xfs_scrub * sc)103 xrep_probe(
104 	struct xfs_scrub	*sc)
105 {
106 	int			error = 0;
107 
108 	if (xchk_should_terminate(sc, &error))
109 		return error;
110 
111 	return 0;
112 }
113 
114 /*
115  * Roll a transaction, keeping the AG headers locked and reinitializing
116  * the btree cursors.
117  */
118 int
xrep_roll_ag_trans(struct xfs_scrub * sc)119 xrep_roll_ag_trans(
120 	struct xfs_scrub	*sc)
121 {
122 	int			error;
123 
124 	/* Keep the AG header buffers locked so we can keep going. */
125 	if (sc->sa.agi_bp)
126 		xfs_trans_bhold(sc->tp, sc->sa.agi_bp);
127 	if (sc->sa.agf_bp)
128 		xfs_trans_bhold(sc->tp, sc->sa.agf_bp);
129 	if (sc->sa.agfl_bp)
130 		xfs_trans_bhold(sc->tp, sc->sa.agfl_bp);
131 
132 	/*
133 	 * Roll the transaction.  We still own the buffer and the buffer lock
134 	 * regardless of whether or not the roll succeeds.  If the roll fails,
135 	 * the buffers will be released during teardown on our way out of the
136 	 * kernel.  If it succeeds, we join them to the new transaction and
137 	 * move on.
138 	 */
139 	error = xfs_trans_roll(&sc->tp);
140 	if (error)
141 		return error;
142 
143 	/* Join AG headers to the new transaction. */
144 	if (sc->sa.agi_bp)
145 		xfs_trans_bjoin(sc->tp, sc->sa.agi_bp);
146 	if (sc->sa.agf_bp)
147 		xfs_trans_bjoin(sc->tp, sc->sa.agf_bp);
148 	if (sc->sa.agfl_bp)
149 		xfs_trans_bjoin(sc->tp, sc->sa.agfl_bp);
150 
151 	return 0;
152 }
153 
154 /*
155  * Does the given AG have enough space to rebuild a btree?  Neither AG
156  * reservation can be critical, and we must have enough space (factoring
157  * in AG reservations) to construct a whole btree.
158  */
159 bool
xrep_ag_has_space(struct xfs_perag * pag,xfs_extlen_t nr_blocks,enum xfs_ag_resv_type type)160 xrep_ag_has_space(
161 	struct xfs_perag	*pag,
162 	xfs_extlen_t		nr_blocks,
163 	enum xfs_ag_resv_type	type)
164 {
165 	return  !xfs_ag_resv_critical(pag, XFS_AG_RESV_RMAPBT) &&
166 		!xfs_ag_resv_critical(pag, XFS_AG_RESV_METADATA) &&
167 		pag->pagf_freeblks > xfs_ag_resv_needed(pag, type) + nr_blocks;
168 }
169 
170 /*
171  * Figure out how many blocks to reserve for an AG repair.  We calculate the
172  * worst case estimate for the number of blocks we'd need to rebuild one of
173  * any type of per-AG btree.
174  */
175 xfs_extlen_t
xrep_calc_ag_resblks(struct xfs_scrub * sc)176 xrep_calc_ag_resblks(
177 	struct xfs_scrub		*sc)
178 {
179 	struct xfs_mount		*mp = sc->mp;
180 	struct xfs_scrub_metadata	*sm = sc->sm;
181 	struct xfs_perag		*pag;
182 	struct xfs_buf			*bp;
183 	xfs_agino_t			icount = NULLAGINO;
184 	xfs_extlen_t			aglen = NULLAGBLOCK;
185 	xfs_extlen_t			usedlen;
186 	xfs_extlen_t			freelen;
187 	xfs_extlen_t			bnobt_sz;
188 	xfs_extlen_t			inobt_sz;
189 	xfs_extlen_t			rmapbt_sz;
190 	xfs_extlen_t			refcbt_sz;
191 	int				error;
192 
193 	if (!(sm->sm_flags & XFS_SCRUB_IFLAG_REPAIR))
194 		return 0;
195 
196 	pag = xfs_perag_get(mp, sm->sm_agno);
197 	if (pag->pagi_init) {
198 		/* Use in-core icount if possible. */
199 		icount = pag->pagi_count;
200 	} else {
201 		/* Try to get the actual counters from disk. */
202 		error = xfs_ialloc_read_agi(pag, NULL, &bp);
203 		if (!error) {
204 			icount = pag->pagi_count;
205 			xfs_buf_relse(bp);
206 		}
207 	}
208 
209 	/* Now grab the block counters from the AGF. */
210 	error = xfs_alloc_read_agf(pag, NULL, 0, &bp);
211 	if (error) {
212 		aglen = pag->block_count;
213 		freelen = aglen;
214 		usedlen = aglen;
215 	} else {
216 		struct xfs_agf	*agf = bp->b_addr;
217 
218 		aglen = be32_to_cpu(agf->agf_length);
219 		freelen = be32_to_cpu(agf->agf_freeblks);
220 		usedlen = aglen - freelen;
221 		xfs_buf_relse(bp);
222 	}
223 
224 	/* If the icount is impossible, make some worst-case assumptions. */
225 	if (icount == NULLAGINO ||
226 	    !xfs_verify_agino(pag, icount)) {
227 		icount = pag->agino_max - pag->agino_min + 1;
228 	}
229 
230 	/* If the block counts are impossible, make worst-case assumptions. */
231 	if (aglen == NULLAGBLOCK ||
232 	    aglen != pag->block_count ||
233 	    freelen >= aglen) {
234 		aglen = pag->block_count;
235 		freelen = aglen;
236 		usedlen = aglen;
237 	}
238 	xfs_perag_put(pag);
239 
240 	trace_xrep_calc_ag_resblks(mp, sm->sm_agno, icount, aglen,
241 			freelen, usedlen);
242 
243 	/*
244 	 * Figure out how many blocks we'd need worst case to rebuild
245 	 * each type of btree.  Note that we can only rebuild the
246 	 * bnobt/cntbt or inobt/finobt as pairs.
247 	 */
248 	bnobt_sz = 2 * xfs_allocbt_calc_size(mp, freelen);
249 	if (xfs_has_sparseinodes(mp))
250 		inobt_sz = xfs_iallocbt_calc_size(mp, icount /
251 				XFS_INODES_PER_HOLEMASK_BIT);
252 	else
253 		inobt_sz = xfs_iallocbt_calc_size(mp, icount /
254 				XFS_INODES_PER_CHUNK);
255 	if (xfs_has_finobt(mp))
256 		inobt_sz *= 2;
257 	if (xfs_has_reflink(mp))
258 		refcbt_sz = xfs_refcountbt_calc_size(mp, usedlen);
259 	else
260 		refcbt_sz = 0;
261 	if (xfs_has_rmapbt(mp)) {
262 		/*
263 		 * Guess how many blocks we need to rebuild the rmapbt.
264 		 * For non-reflink filesystems we can't have more records than
265 		 * used blocks.  However, with reflink it's possible to have
266 		 * more than one rmap record per AG block.  We don't know how
267 		 * many rmaps there could be in the AG, so we start off with
268 		 * what we hope is an generous over-estimation.
269 		 */
270 		if (xfs_has_reflink(mp))
271 			rmapbt_sz = xfs_rmapbt_calc_size(mp,
272 					(unsigned long long)aglen * 2);
273 		else
274 			rmapbt_sz = xfs_rmapbt_calc_size(mp, usedlen);
275 	} else {
276 		rmapbt_sz = 0;
277 	}
278 
279 	trace_xrep_calc_ag_resblks_btsize(mp, sm->sm_agno, bnobt_sz,
280 			inobt_sz, rmapbt_sz, refcbt_sz);
281 
282 	return max(max(bnobt_sz, inobt_sz), max(rmapbt_sz, refcbt_sz));
283 }
284 
285 /* Allocate a block in an AG. */
286 int
xrep_alloc_ag_block(struct xfs_scrub * sc,const struct xfs_owner_info * oinfo,xfs_fsblock_t * fsbno,enum xfs_ag_resv_type resv)287 xrep_alloc_ag_block(
288 	struct xfs_scrub		*sc,
289 	const struct xfs_owner_info	*oinfo,
290 	xfs_fsblock_t			*fsbno,
291 	enum xfs_ag_resv_type		resv)
292 {
293 	struct xfs_alloc_arg		args = {0};
294 	xfs_agblock_t			bno;
295 	int				error;
296 
297 	switch (resv) {
298 	case XFS_AG_RESV_AGFL:
299 	case XFS_AG_RESV_RMAPBT:
300 		error = xfs_alloc_get_freelist(sc->sa.pag, sc->tp,
301 				sc->sa.agf_bp, &bno, 1);
302 		if (error)
303 			return error;
304 		if (bno == NULLAGBLOCK)
305 			return -ENOSPC;
306 		xfs_extent_busy_reuse(sc->mp, sc->sa.pag, bno, 1, false);
307 		*fsbno = XFS_AGB_TO_FSB(sc->mp, sc->sa.pag->pag_agno, bno);
308 		if (resv == XFS_AG_RESV_RMAPBT)
309 			xfs_ag_resv_rmapbt_alloc(sc->mp, sc->sa.pag->pag_agno);
310 		return 0;
311 	default:
312 		break;
313 	}
314 
315 	args.tp = sc->tp;
316 	args.mp = sc->mp;
317 	args.oinfo = *oinfo;
318 	args.fsbno = XFS_AGB_TO_FSB(args.mp, sc->sa.pag->pag_agno, 0);
319 	args.minlen = 1;
320 	args.maxlen = 1;
321 	args.prod = 1;
322 	args.type = XFS_ALLOCTYPE_THIS_AG;
323 	args.resv = resv;
324 
325 	error = xfs_alloc_vextent(&args);
326 	if (error)
327 		return error;
328 	if (args.fsbno == NULLFSBLOCK)
329 		return -ENOSPC;
330 	ASSERT(args.len == 1);
331 	*fsbno = args.fsbno;
332 
333 	return 0;
334 }
335 
336 /* Initialize a new AG btree root block with zero entries. */
337 int
xrep_init_btblock(struct xfs_scrub * sc,xfs_fsblock_t fsb,struct xfs_buf ** bpp,xfs_btnum_t btnum,const struct xfs_buf_ops * ops)338 xrep_init_btblock(
339 	struct xfs_scrub		*sc,
340 	xfs_fsblock_t			fsb,
341 	struct xfs_buf			**bpp,
342 	xfs_btnum_t			btnum,
343 	const struct xfs_buf_ops	*ops)
344 {
345 	struct xfs_trans		*tp = sc->tp;
346 	struct xfs_mount		*mp = sc->mp;
347 	struct xfs_buf			*bp;
348 	int				error;
349 
350 	trace_xrep_init_btblock(mp, XFS_FSB_TO_AGNO(mp, fsb),
351 			XFS_FSB_TO_AGBNO(mp, fsb), btnum);
352 
353 	ASSERT(XFS_FSB_TO_AGNO(mp, fsb) == sc->sa.pag->pag_agno);
354 	error = xfs_trans_get_buf(tp, mp->m_ddev_targp,
355 			XFS_FSB_TO_DADDR(mp, fsb), XFS_FSB_TO_BB(mp, 1), 0,
356 			&bp);
357 	if (error)
358 		return error;
359 	xfs_buf_zero(bp, 0, BBTOB(bp->b_length));
360 	xfs_btree_init_block(mp, bp, btnum, 0, 0, sc->sa.pag->pag_agno);
361 	xfs_trans_buf_set_type(tp, bp, XFS_BLFT_BTREE_BUF);
362 	xfs_trans_log_buf(tp, bp, 0, BBTOB(bp->b_length) - 1);
363 	bp->b_ops = ops;
364 	*bpp = bp;
365 
366 	return 0;
367 }
368 
369 /*
370  * Reconstructing per-AG Btrees
371  *
372  * When a space btree is corrupt, we don't bother trying to fix it.  Instead,
373  * we scan secondary space metadata to derive the records that should be in
374  * the damaged btree, initialize a fresh btree root, and insert the records.
375  * Note that for rebuilding the rmapbt we scan all the primary data to
376  * generate the new records.
377  *
378  * However, that leaves the matter of removing all the metadata describing the
379  * old broken structure.  For primary metadata we use the rmap data to collect
380  * every extent with a matching rmap owner (bitmap); we then iterate all other
381  * metadata structures with the same rmap owner to collect the extents that
382  * cannot be removed (sublist).  We then subtract sublist from bitmap to
383  * derive the blocks that were used by the old btree.  These blocks can be
384  * reaped.
385  *
386  * For rmapbt reconstructions we must use different tactics for extent
387  * collection.  First we iterate all primary metadata (this excludes the old
388  * rmapbt, obviously) to generate new rmap records.  The gaps in the rmap
389  * records are collected as bitmap.  The bnobt records are collected as
390  * sublist.  As with the other btrees we subtract sublist from bitmap, and the
391  * result (since the rmapbt lives in the free space) are the blocks from the
392  * old rmapbt.
393  *
394  * Disposal of Blocks from Old per-AG Btrees
395  *
396  * Now that we've constructed a new btree to replace the damaged one, we want
397  * to dispose of the blocks that (we think) the old btree was using.
398  * Previously, we used the rmapbt to collect the extents (bitmap) with the
399  * rmap owner corresponding to the tree we rebuilt, collected extents for any
400  * blocks with the same rmap owner that are owned by another data structure
401  * (sublist), and subtracted sublist from bitmap.  In theory the extents
402  * remaining in bitmap are the old btree's blocks.
403  *
404  * Unfortunately, it's possible that the btree was crosslinked with other
405  * blocks on disk.  The rmap data can tell us if there are multiple owners, so
406  * if the rmapbt says there is an owner of this block other than @oinfo, then
407  * the block is crosslinked.  Remove the reverse mapping and continue.
408  *
409  * If there is one rmap record, we can free the block, which removes the
410  * reverse mapping but doesn't add the block to the free space.  Our repair
411  * strategy is to hope the other metadata objects crosslinked on this block
412  * will be rebuilt (atop different blocks), thereby removing all the cross
413  * links.
414  *
415  * If there are no rmap records at all, we also free the block.  If the btree
416  * being rebuilt lives in the free space (bnobt/cntbt/rmapbt) then there isn't
417  * supposed to be a rmap record and everything is ok.  For other btrees there
418  * had to have been an rmap entry for the block to have ended up on @bitmap,
419  * so if it's gone now there's something wrong and the fs will shut down.
420  *
421  * Note: If there are multiple rmap records with only the same rmap owner as
422  * the btree we're trying to rebuild and the block is indeed owned by another
423  * data structure with the same rmap owner, then the block will be in sublist
424  * and therefore doesn't need disposal.  If there are multiple rmap records
425  * with only the same rmap owner but the block is not owned by something with
426  * the same rmap owner, the block will be freed.
427  *
428  * The caller is responsible for locking the AG headers for the entire rebuild
429  * operation so that nothing else can sneak in and change the AG state while
430  * we're not looking.  We also assume that the caller already invalidated any
431  * buffers associated with @bitmap.
432  */
433 
434 /*
435  * Invalidate buffers for per-AG btree blocks we're dumping.  This function
436  * is not intended for use with file data repairs; we have bunmapi for that.
437  */
438 int
xrep_invalidate_blocks(struct xfs_scrub * sc,struct xbitmap * bitmap)439 xrep_invalidate_blocks(
440 	struct xfs_scrub	*sc,
441 	struct xbitmap		*bitmap)
442 {
443 	struct xbitmap_range	*bmr;
444 	struct xbitmap_range	*n;
445 	struct xfs_buf		*bp;
446 	xfs_fsblock_t		fsbno;
447 
448 	/*
449 	 * For each block in each extent, see if there's an incore buffer for
450 	 * exactly that block; if so, invalidate it.  The buffer cache only
451 	 * lets us look for one buffer at a time, so we have to look one block
452 	 * at a time.  Avoid invalidating AG headers and post-EOFS blocks
453 	 * because we never own those; and if we can't TRYLOCK the buffer we
454 	 * assume it's owned by someone else.
455 	 */
456 	for_each_xbitmap_block(fsbno, bmr, n, bitmap) {
457 		int		error;
458 
459 		/* Skip AG headers and post-EOFS blocks */
460 		if (!xfs_verify_fsbno(sc->mp, fsbno))
461 			continue;
462 		error = xfs_buf_incore(sc->mp->m_ddev_targp,
463 				XFS_FSB_TO_DADDR(sc->mp, fsbno),
464 				XFS_FSB_TO_BB(sc->mp, 1), XBF_TRYLOCK, &bp);
465 		if (error)
466 			continue;
467 
468 		xfs_trans_bjoin(sc->tp, bp);
469 		xfs_trans_binval(sc->tp, bp);
470 	}
471 
472 	return 0;
473 }
474 
475 /* Ensure the freelist is the correct size. */
476 int
xrep_fix_freelist(struct xfs_scrub * sc,bool can_shrink)477 xrep_fix_freelist(
478 	struct xfs_scrub	*sc,
479 	bool			can_shrink)
480 {
481 	struct xfs_alloc_arg	args = {0};
482 
483 	args.mp = sc->mp;
484 	args.tp = sc->tp;
485 	args.agno = sc->sa.pag->pag_agno;
486 	args.alignment = 1;
487 	args.pag = sc->sa.pag;
488 
489 	return xfs_alloc_fix_freelist(&args,
490 			can_shrink ? 0 : XFS_ALLOC_FLAG_NOSHRINK);
491 }
492 
493 /*
494  * Put a block back on the AGFL.
495  */
496 STATIC int
xrep_put_freelist(struct xfs_scrub * sc,xfs_agblock_t agbno)497 xrep_put_freelist(
498 	struct xfs_scrub	*sc,
499 	xfs_agblock_t		agbno)
500 {
501 	int			error;
502 
503 	/* Make sure there's space on the freelist. */
504 	error = xrep_fix_freelist(sc, true);
505 	if (error)
506 		return error;
507 
508 	/*
509 	 * Since we're "freeing" a lost block onto the AGFL, we have to
510 	 * create an rmap for the block prior to merging it or else other
511 	 * parts will break.
512 	 */
513 	error = xfs_rmap_alloc(sc->tp, sc->sa.agf_bp, sc->sa.pag, agbno, 1,
514 			&XFS_RMAP_OINFO_AG);
515 	if (error)
516 		return error;
517 
518 	/* Put the block on the AGFL. */
519 	error = xfs_alloc_put_freelist(sc->sa.pag, sc->tp, sc->sa.agf_bp,
520 			sc->sa.agfl_bp, agbno, 0);
521 	if (error)
522 		return error;
523 	xfs_extent_busy_insert(sc->tp, sc->sa.pag, agbno, 1,
524 			XFS_EXTENT_BUSY_SKIP_DISCARD);
525 
526 	return 0;
527 }
528 
529 /* Dispose of a single block. */
530 STATIC int
xrep_reap_block(struct xfs_scrub * sc,xfs_fsblock_t fsbno,const struct xfs_owner_info * oinfo,enum xfs_ag_resv_type resv)531 xrep_reap_block(
532 	struct xfs_scrub		*sc,
533 	xfs_fsblock_t			fsbno,
534 	const struct xfs_owner_info	*oinfo,
535 	enum xfs_ag_resv_type		resv)
536 {
537 	struct xfs_btree_cur		*cur;
538 	struct xfs_buf			*agf_bp = NULL;
539 	xfs_agblock_t			agbno;
540 	bool				has_other_rmap;
541 	int				error;
542 
543 	agbno = XFS_FSB_TO_AGBNO(sc->mp, fsbno);
544 	ASSERT(XFS_FSB_TO_AGNO(sc->mp, fsbno) == sc->sa.pag->pag_agno);
545 
546 	/*
547 	 * If we are repairing per-inode metadata, we need to read in the AGF
548 	 * buffer.  Otherwise, we're repairing a per-AG structure, so reuse
549 	 * the AGF buffer that the setup functions already grabbed.
550 	 */
551 	if (sc->ip) {
552 		error = xfs_alloc_read_agf(sc->sa.pag, sc->tp, 0, &agf_bp);
553 		if (error)
554 			return error;
555 	} else {
556 		agf_bp = sc->sa.agf_bp;
557 	}
558 	cur = xfs_rmapbt_init_cursor(sc->mp, sc->tp, agf_bp, sc->sa.pag);
559 
560 	/* Can we find any other rmappings? */
561 	error = xfs_rmap_has_other_keys(cur, agbno, 1, oinfo, &has_other_rmap);
562 	xfs_btree_del_cursor(cur, error);
563 	if (error)
564 		goto out_free;
565 
566 	/*
567 	 * If there are other rmappings, this block is cross linked and must
568 	 * not be freed.  Remove the reverse mapping and move on.  Otherwise,
569 	 * we were the only owner of the block, so free the extent, which will
570 	 * also remove the rmap.
571 	 *
572 	 * XXX: XFS doesn't support detecting the case where a single block
573 	 * metadata structure is crosslinked with a multi-block structure
574 	 * because the buffer cache doesn't detect aliasing problems, so we
575 	 * can't fix 100% of crosslinking problems (yet).  The verifiers will
576 	 * blow on writeout, the filesystem will shut down, and the admin gets
577 	 * to run xfs_repair.
578 	 */
579 	if (has_other_rmap)
580 		error = xfs_rmap_free(sc->tp, agf_bp, sc->sa.pag, agbno,
581 					1, oinfo);
582 	else if (resv == XFS_AG_RESV_AGFL)
583 		error = xrep_put_freelist(sc, agbno);
584 	else
585 		error = xfs_free_extent(sc->tp, fsbno, 1, oinfo, resv);
586 	if (agf_bp != sc->sa.agf_bp)
587 		xfs_trans_brelse(sc->tp, agf_bp);
588 	if (error)
589 		return error;
590 
591 	if (sc->ip)
592 		return xfs_trans_roll_inode(&sc->tp, sc->ip);
593 	return xrep_roll_ag_trans(sc);
594 
595 out_free:
596 	if (agf_bp != sc->sa.agf_bp)
597 		xfs_trans_brelse(sc->tp, agf_bp);
598 	return error;
599 }
600 
601 /* Dispose of every block of every extent in the bitmap. */
602 int
xrep_reap_extents(struct xfs_scrub * sc,struct xbitmap * bitmap,const struct xfs_owner_info * oinfo,enum xfs_ag_resv_type type)603 xrep_reap_extents(
604 	struct xfs_scrub		*sc,
605 	struct xbitmap			*bitmap,
606 	const struct xfs_owner_info	*oinfo,
607 	enum xfs_ag_resv_type		type)
608 {
609 	struct xbitmap_range		*bmr;
610 	struct xbitmap_range		*n;
611 	xfs_fsblock_t			fsbno;
612 	int				error = 0;
613 
614 	ASSERT(xfs_has_rmapbt(sc->mp));
615 
616 	for_each_xbitmap_block(fsbno, bmr, n, bitmap) {
617 		ASSERT(sc->ip != NULL ||
618 		       XFS_FSB_TO_AGNO(sc->mp, fsbno) == sc->sa.pag->pag_agno);
619 		trace_xrep_dispose_btree_extent(sc->mp,
620 				XFS_FSB_TO_AGNO(sc->mp, fsbno),
621 				XFS_FSB_TO_AGBNO(sc->mp, fsbno), 1);
622 
623 		error = xrep_reap_block(sc, fsbno, oinfo, type);
624 		if (error)
625 			break;
626 	}
627 
628 	return error;
629 }
630 
631 /*
632  * Finding per-AG Btree Roots for AGF/AGI Reconstruction
633  *
634  * If the AGF or AGI become slightly corrupted, it may be necessary to rebuild
635  * the AG headers by using the rmap data to rummage through the AG looking for
636  * btree roots.  This is not guaranteed to work if the AG is heavily damaged
637  * or the rmap data are corrupt.
638  *
639  * Callers of xrep_find_ag_btree_roots must lock the AGF and AGFL
640  * buffers if the AGF is being rebuilt; or the AGF and AGI buffers if the
641  * AGI is being rebuilt.  It must maintain these locks until it's safe for
642  * other threads to change the btrees' shapes.  The caller provides
643  * information about the btrees to look for by passing in an array of
644  * xrep_find_ag_btree with the (rmap owner, buf_ops, magic) fields set.
645  * The (root, height) fields will be set on return if anything is found.  The
646  * last element of the array should have a NULL buf_ops to mark the end of the
647  * array.
648  *
649  * For every rmapbt record matching any of the rmap owners in btree_info,
650  * read each block referenced by the rmap record.  If the block is a btree
651  * block from this filesystem matching any of the magic numbers and has a
652  * level higher than what we've already seen, remember the block and the
653  * height of the tree required to have such a block.  When the call completes,
654  * we return the highest block we've found for each btree description; those
655  * should be the roots.
656  */
657 
658 struct xrep_findroot {
659 	struct xfs_scrub		*sc;
660 	struct xfs_buf			*agfl_bp;
661 	struct xfs_agf			*agf;
662 	struct xrep_find_ag_btree	*btree_info;
663 };
664 
665 /* See if our block is in the AGFL. */
666 STATIC int
xrep_findroot_agfl_walk(struct xfs_mount * mp,xfs_agblock_t bno,void * priv)667 xrep_findroot_agfl_walk(
668 	struct xfs_mount	*mp,
669 	xfs_agblock_t		bno,
670 	void			*priv)
671 {
672 	xfs_agblock_t		*agbno = priv;
673 
674 	return (*agbno == bno) ? -ECANCELED : 0;
675 }
676 
677 /* Does this block match the btree information passed in? */
678 STATIC int
xrep_findroot_block(struct xrep_findroot * ri,struct xrep_find_ag_btree * fab,uint64_t owner,xfs_agblock_t agbno,bool * done_with_block)679 xrep_findroot_block(
680 	struct xrep_findroot		*ri,
681 	struct xrep_find_ag_btree	*fab,
682 	uint64_t			owner,
683 	xfs_agblock_t			agbno,
684 	bool				*done_with_block)
685 {
686 	struct xfs_mount		*mp = ri->sc->mp;
687 	struct xfs_buf			*bp;
688 	struct xfs_btree_block		*btblock;
689 	xfs_daddr_t			daddr;
690 	int				block_level;
691 	int				error = 0;
692 
693 	daddr = XFS_AGB_TO_DADDR(mp, ri->sc->sa.pag->pag_agno, agbno);
694 
695 	/*
696 	 * Blocks in the AGFL have stale contents that might just happen to
697 	 * have a matching magic and uuid.  We don't want to pull these blocks
698 	 * in as part of a tree root, so we have to filter out the AGFL stuff
699 	 * here.  If the AGFL looks insane we'll just refuse to repair.
700 	 */
701 	if (owner == XFS_RMAP_OWN_AG) {
702 		error = xfs_agfl_walk(mp, ri->agf, ri->agfl_bp,
703 				xrep_findroot_agfl_walk, &agbno);
704 		if (error == -ECANCELED)
705 			return 0;
706 		if (error)
707 			return error;
708 	}
709 
710 	/*
711 	 * Read the buffer into memory so that we can see if it's a match for
712 	 * our btree type.  We have no clue if it is beforehand, and we want to
713 	 * avoid xfs_trans_read_buf's behavior of dumping the DONE state (which
714 	 * will cause needless disk reads in subsequent calls to this function)
715 	 * and logging metadata verifier failures.
716 	 *
717 	 * Therefore, pass in NULL buffer ops.  If the buffer was already in
718 	 * memory from some other caller it will already have b_ops assigned.
719 	 * If it was in memory from a previous unsuccessful findroot_block
720 	 * call, the buffer won't have b_ops but it should be clean and ready
721 	 * for us to try to verify if the read call succeeds.  The same applies
722 	 * if the buffer wasn't in memory at all.
723 	 *
724 	 * Note: If we never match a btree type with this buffer, it will be
725 	 * left in memory with NULL b_ops.  This shouldn't be a problem unless
726 	 * the buffer gets written.
727 	 */
728 	error = xfs_trans_read_buf(mp, ri->sc->tp, mp->m_ddev_targp, daddr,
729 			mp->m_bsize, 0, &bp, NULL);
730 	if (error)
731 		return error;
732 
733 	/* Ensure the block magic matches the btree type we're looking for. */
734 	btblock = XFS_BUF_TO_BLOCK(bp);
735 	ASSERT(fab->buf_ops->magic[1] != 0);
736 	if (btblock->bb_magic != fab->buf_ops->magic[1])
737 		goto out;
738 
739 	/*
740 	 * If the buffer already has ops applied and they're not the ones for
741 	 * this btree type, we know this block doesn't match the btree and we
742 	 * can bail out.
743 	 *
744 	 * If the buffer ops match ours, someone else has already validated
745 	 * the block for us, so we can move on to checking if this is a root
746 	 * block candidate.
747 	 *
748 	 * If the buffer does not have ops, nobody has successfully validated
749 	 * the contents and the buffer cannot be dirty.  If the magic, uuid,
750 	 * and structure match this btree type then we'll move on to checking
751 	 * if it's a root block candidate.  If there is no match, bail out.
752 	 */
753 	if (bp->b_ops) {
754 		if (bp->b_ops != fab->buf_ops)
755 			goto out;
756 	} else {
757 		ASSERT(!xfs_trans_buf_is_dirty(bp));
758 		if (!uuid_equal(&btblock->bb_u.s.bb_uuid,
759 				&mp->m_sb.sb_meta_uuid))
760 			goto out;
761 		/*
762 		 * Read verifiers can reference b_ops, so we set the pointer
763 		 * here.  If the verifier fails we'll reset the buffer state
764 		 * to what it was before we touched the buffer.
765 		 */
766 		bp->b_ops = fab->buf_ops;
767 		fab->buf_ops->verify_read(bp);
768 		if (bp->b_error) {
769 			bp->b_ops = NULL;
770 			bp->b_error = 0;
771 			goto out;
772 		}
773 
774 		/*
775 		 * Some read verifiers will (re)set b_ops, so we must be
776 		 * careful not to change b_ops after running the verifier.
777 		 */
778 	}
779 
780 	/*
781 	 * This block passes the magic/uuid and verifier tests for this btree
782 	 * type.  We don't need the caller to try the other tree types.
783 	 */
784 	*done_with_block = true;
785 
786 	/*
787 	 * Compare this btree block's level to the height of the current
788 	 * candidate root block.
789 	 *
790 	 * If the level matches the root we found previously, throw away both
791 	 * blocks because there can't be two candidate roots.
792 	 *
793 	 * If level is lower in the tree than the root we found previously,
794 	 * ignore this block.
795 	 */
796 	block_level = xfs_btree_get_level(btblock);
797 	if (block_level + 1 == fab->height) {
798 		fab->root = NULLAGBLOCK;
799 		goto out;
800 	} else if (block_level < fab->height) {
801 		goto out;
802 	}
803 
804 	/*
805 	 * This is the highest block in the tree that we've found so far.
806 	 * Update the btree height to reflect what we've learned from this
807 	 * block.
808 	 */
809 	fab->height = block_level + 1;
810 
811 	/*
812 	 * If this block doesn't have sibling pointers, then it's the new root
813 	 * block candidate.  Otherwise, the root will be found farther up the
814 	 * tree.
815 	 */
816 	if (btblock->bb_u.s.bb_leftsib == cpu_to_be32(NULLAGBLOCK) &&
817 	    btblock->bb_u.s.bb_rightsib == cpu_to_be32(NULLAGBLOCK))
818 		fab->root = agbno;
819 	else
820 		fab->root = NULLAGBLOCK;
821 
822 	trace_xrep_findroot_block(mp, ri->sc->sa.pag->pag_agno, agbno,
823 			be32_to_cpu(btblock->bb_magic), fab->height - 1);
824 out:
825 	xfs_trans_brelse(ri->sc->tp, bp);
826 	return error;
827 }
828 
829 /*
830  * Do any of the blocks in this rmap record match one of the btrees we're
831  * looking for?
832  */
833 STATIC int
xrep_findroot_rmap(struct xfs_btree_cur * cur,const struct xfs_rmap_irec * rec,void * priv)834 xrep_findroot_rmap(
835 	struct xfs_btree_cur		*cur,
836 	const struct xfs_rmap_irec	*rec,
837 	void				*priv)
838 {
839 	struct xrep_findroot		*ri = priv;
840 	struct xrep_find_ag_btree	*fab;
841 	xfs_agblock_t			b;
842 	bool				done;
843 	int				error = 0;
844 
845 	/* Ignore anything that isn't AG metadata. */
846 	if (!XFS_RMAP_NON_INODE_OWNER(rec->rm_owner))
847 		return 0;
848 
849 	/* Otherwise scan each block + btree type. */
850 	for (b = 0; b < rec->rm_blockcount; b++) {
851 		done = false;
852 		for (fab = ri->btree_info; fab->buf_ops; fab++) {
853 			if (rec->rm_owner != fab->rmap_owner)
854 				continue;
855 			error = xrep_findroot_block(ri, fab,
856 					rec->rm_owner, rec->rm_startblock + b,
857 					&done);
858 			if (error)
859 				return error;
860 			if (done)
861 				break;
862 		}
863 	}
864 
865 	return 0;
866 }
867 
868 /* Find the roots of the per-AG btrees described in btree_info. */
869 int
xrep_find_ag_btree_roots(struct xfs_scrub * sc,struct xfs_buf * agf_bp,struct xrep_find_ag_btree * btree_info,struct xfs_buf * agfl_bp)870 xrep_find_ag_btree_roots(
871 	struct xfs_scrub		*sc,
872 	struct xfs_buf			*agf_bp,
873 	struct xrep_find_ag_btree	*btree_info,
874 	struct xfs_buf			*agfl_bp)
875 {
876 	struct xfs_mount		*mp = sc->mp;
877 	struct xrep_findroot		ri;
878 	struct xrep_find_ag_btree	*fab;
879 	struct xfs_btree_cur		*cur;
880 	int				error;
881 
882 	ASSERT(xfs_buf_islocked(agf_bp));
883 	ASSERT(agfl_bp == NULL || xfs_buf_islocked(agfl_bp));
884 
885 	ri.sc = sc;
886 	ri.btree_info = btree_info;
887 	ri.agf = agf_bp->b_addr;
888 	ri.agfl_bp = agfl_bp;
889 	for (fab = btree_info; fab->buf_ops; fab++) {
890 		ASSERT(agfl_bp || fab->rmap_owner != XFS_RMAP_OWN_AG);
891 		ASSERT(XFS_RMAP_NON_INODE_OWNER(fab->rmap_owner));
892 		fab->root = NULLAGBLOCK;
893 		fab->height = 0;
894 	}
895 
896 	cur = xfs_rmapbt_init_cursor(mp, sc->tp, agf_bp, sc->sa.pag);
897 	error = xfs_rmap_query_all(cur, xrep_findroot_rmap, &ri);
898 	xfs_btree_del_cursor(cur, error);
899 
900 	return error;
901 }
902 
903 /* Force a quotacheck the next time we mount. */
904 void
xrep_force_quotacheck(struct xfs_scrub * sc,xfs_dqtype_t type)905 xrep_force_quotacheck(
906 	struct xfs_scrub	*sc,
907 	xfs_dqtype_t		type)
908 {
909 	uint			flag;
910 
911 	flag = xfs_quota_chkd_flag(type);
912 	if (!(flag & sc->mp->m_qflags))
913 		return;
914 
915 	mutex_lock(&sc->mp->m_quotainfo->qi_quotaofflock);
916 	sc->mp->m_qflags &= ~flag;
917 	spin_lock(&sc->mp->m_sb_lock);
918 	sc->mp->m_sb.sb_qflags &= ~flag;
919 	spin_unlock(&sc->mp->m_sb_lock);
920 	xfs_log_sb(sc->tp);
921 	mutex_unlock(&sc->mp->m_quotainfo->qi_quotaofflock);
922 }
923 
924 /*
925  * Attach dquots to this inode, or schedule quotacheck to fix them.
926  *
927  * This function ensures that the appropriate dquots are attached to an inode.
928  * We cannot allow the dquot code to allocate an on-disk dquot block here
929  * because we're already in transaction context with the inode locked.  The
930  * on-disk dquot should already exist anyway.  If the quota code signals
931  * corruption or missing quota information, schedule quotacheck, which will
932  * repair corruptions in the quota metadata.
933  */
934 int
xrep_ino_dqattach(struct xfs_scrub * sc)935 xrep_ino_dqattach(
936 	struct xfs_scrub	*sc)
937 {
938 	int			error;
939 
940 	error = xfs_qm_dqattach_locked(sc->ip, false);
941 	switch (error) {
942 	case -EFSBADCRC:
943 	case -EFSCORRUPTED:
944 	case -ENOENT:
945 		xfs_err_ratelimited(sc->mp,
946 "inode %llu repair encountered quota error %d, quotacheck forced.",
947 				(unsigned long long)sc->ip->i_ino, error);
948 		if (XFS_IS_UQUOTA_ON(sc->mp) && !sc->ip->i_udquot)
949 			xrep_force_quotacheck(sc, XFS_DQTYPE_USER);
950 		if (XFS_IS_GQUOTA_ON(sc->mp) && !sc->ip->i_gdquot)
951 			xrep_force_quotacheck(sc, XFS_DQTYPE_GROUP);
952 		if (XFS_IS_PQUOTA_ON(sc->mp) && !sc->ip->i_pdquot)
953 			xrep_force_quotacheck(sc, XFS_DQTYPE_PROJ);
954 		fallthrough;
955 	case -ESRCH:
956 		error = 0;
957 		break;
958 	default:
959 		break;
960 	}
961 
962 	return error;
963 }
964