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