Loading...
Note: File does not exist in v3.5.6.
1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * Copyright (C) 2017 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_inode.h"
16#include "xfs_icache.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_refcount_btree.h"
22#include "xfs_rmap.h"
23#include "xfs_rmap_btree.h"
24#include "xfs_log.h"
25#include "xfs_trans_priv.h"
26#include "xfs_attr.h"
27#include "xfs_reflink.h"
28#include "xfs_ag.h"
29#include "scrub/scrub.h"
30#include "scrub/common.h"
31#include "scrub/trace.h"
32#include "scrub/repair.h"
33#include "scrub/health.h"
34
35/* Common code for the metadata scrubbers. */
36
37/*
38 * Handling operational errors.
39 *
40 * The *_process_error() family of functions are used to process error return
41 * codes from functions called as part of a scrub operation.
42 *
43 * If there's no error, we return true to tell the caller that it's ok
44 * to move on to the next check in its list.
45 *
46 * For non-verifier errors (e.g. ENOMEM) we return false to tell the
47 * caller that something bad happened, and we preserve *error so that
48 * the caller can return the *error up the stack to userspace.
49 *
50 * Verifier errors (EFSBADCRC/EFSCORRUPTED) are recorded by setting
51 * OFLAG_CORRUPT in sm_flags and the *error is cleared. In other words,
52 * we track verifier errors (and failed scrub checks) via OFLAG_CORRUPT,
53 * not via return codes. We return false to tell the caller that
54 * something bad happened. Since the error has been cleared, the caller
55 * will (presumably) return that zero and scrubbing will move on to
56 * whatever's next.
57 *
58 * ftrace can be used to record the precise metadata location and the
59 * approximate code location of the failed operation.
60 */
61
62/* Check for operational errors. */
63static bool
64__xchk_process_error(
65 struct xfs_scrub *sc,
66 xfs_agnumber_t agno,
67 xfs_agblock_t bno,
68 int *error,
69 __u32 errflag,
70 void *ret_ip)
71{
72 switch (*error) {
73 case 0:
74 return true;
75 case -EDEADLOCK:
76 /* Used to restart an op with deadlock avoidance. */
77 trace_xchk_deadlock_retry(
78 sc->ip ? sc->ip : XFS_I(file_inode(sc->file)),
79 sc->sm, *error);
80 break;
81 case -EFSBADCRC:
82 case -EFSCORRUPTED:
83 /* Note the badness but don't abort. */
84 sc->sm->sm_flags |= errflag;
85 *error = 0;
86 fallthrough;
87 default:
88 trace_xchk_op_error(sc, agno, bno, *error,
89 ret_ip);
90 break;
91 }
92 return false;
93}
94
95bool
96xchk_process_error(
97 struct xfs_scrub *sc,
98 xfs_agnumber_t agno,
99 xfs_agblock_t bno,
100 int *error)
101{
102 return __xchk_process_error(sc, agno, bno, error,
103 XFS_SCRUB_OFLAG_CORRUPT, __return_address);
104}
105
106bool
107xchk_xref_process_error(
108 struct xfs_scrub *sc,
109 xfs_agnumber_t agno,
110 xfs_agblock_t bno,
111 int *error)
112{
113 return __xchk_process_error(sc, agno, bno, error,
114 XFS_SCRUB_OFLAG_XFAIL, __return_address);
115}
116
117/* Check for operational errors for a file offset. */
118static bool
119__xchk_fblock_process_error(
120 struct xfs_scrub *sc,
121 int whichfork,
122 xfs_fileoff_t offset,
123 int *error,
124 __u32 errflag,
125 void *ret_ip)
126{
127 switch (*error) {
128 case 0:
129 return true;
130 case -EDEADLOCK:
131 /* Used to restart an op with deadlock avoidance. */
132 trace_xchk_deadlock_retry(sc->ip, sc->sm, *error);
133 break;
134 case -EFSBADCRC:
135 case -EFSCORRUPTED:
136 /* Note the badness but don't abort. */
137 sc->sm->sm_flags |= errflag;
138 *error = 0;
139 fallthrough;
140 default:
141 trace_xchk_file_op_error(sc, whichfork, offset, *error,
142 ret_ip);
143 break;
144 }
145 return false;
146}
147
148bool
149xchk_fblock_process_error(
150 struct xfs_scrub *sc,
151 int whichfork,
152 xfs_fileoff_t offset,
153 int *error)
154{
155 return __xchk_fblock_process_error(sc, whichfork, offset, error,
156 XFS_SCRUB_OFLAG_CORRUPT, __return_address);
157}
158
159bool
160xchk_fblock_xref_process_error(
161 struct xfs_scrub *sc,
162 int whichfork,
163 xfs_fileoff_t offset,
164 int *error)
165{
166 return __xchk_fblock_process_error(sc, whichfork, offset, error,
167 XFS_SCRUB_OFLAG_XFAIL, __return_address);
168}
169
170/*
171 * Handling scrub corruption/optimization/warning checks.
172 *
173 * The *_set_{corrupt,preen,warning}() family of functions are used to
174 * record the presence of metadata that is incorrect (corrupt), could be
175 * optimized somehow (preen), or should be flagged for administrative
176 * review but is not incorrect (warn).
177 *
178 * ftrace can be used to record the precise metadata location and
179 * approximate code location of the failed check.
180 */
181
182/* Record a block which could be optimized. */
183void
184xchk_block_set_preen(
185 struct xfs_scrub *sc,
186 struct xfs_buf *bp)
187{
188 sc->sm->sm_flags |= XFS_SCRUB_OFLAG_PREEN;
189 trace_xchk_block_preen(sc, bp->b_bn, __return_address);
190}
191
192/*
193 * Record an inode which could be optimized. The trace data will
194 * include the block given by bp if bp is given; otherwise it will use
195 * the block location of the inode record itself.
196 */
197void
198xchk_ino_set_preen(
199 struct xfs_scrub *sc,
200 xfs_ino_t ino)
201{
202 sc->sm->sm_flags |= XFS_SCRUB_OFLAG_PREEN;
203 trace_xchk_ino_preen(sc, ino, __return_address);
204}
205
206/* Record something being wrong with the filesystem primary superblock. */
207void
208xchk_set_corrupt(
209 struct xfs_scrub *sc)
210{
211 sc->sm->sm_flags |= XFS_SCRUB_OFLAG_CORRUPT;
212 trace_xchk_fs_error(sc, 0, __return_address);
213}
214
215/* Record a corrupt block. */
216void
217xchk_block_set_corrupt(
218 struct xfs_scrub *sc,
219 struct xfs_buf *bp)
220{
221 sc->sm->sm_flags |= XFS_SCRUB_OFLAG_CORRUPT;
222 trace_xchk_block_error(sc, bp->b_bn, __return_address);
223}
224
225/* Record a corruption while cross-referencing. */
226void
227xchk_block_xref_set_corrupt(
228 struct xfs_scrub *sc,
229 struct xfs_buf *bp)
230{
231 sc->sm->sm_flags |= XFS_SCRUB_OFLAG_XCORRUPT;
232 trace_xchk_block_error(sc, bp->b_bn, __return_address);
233}
234
235/*
236 * Record a corrupt inode. The trace data will include the block given
237 * by bp if bp is given; otherwise it will use the block location of the
238 * inode record itself.
239 */
240void
241xchk_ino_set_corrupt(
242 struct xfs_scrub *sc,
243 xfs_ino_t ino)
244{
245 sc->sm->sm_flags |= XFS_SCRUB_OFLAG_CORRUPT;
246 trace_xchk_ino_error(sc, ino, __return_address);
247}
248
249/* Record a corruption while cross-referencing with an inode. */
250void
251xchk_ino_xref_set_corrupt(
252 struct xfs_scrub *sc,
253 xfs_ino_t ino)
254{
255 sc->sm->sm_flags |= XFS_SCRUB_OFLAG_XCORRUPT;
256 trace_xchk_ino_error(sc, ino, __return_address);
257}
258
259/* Record corruption in a block indexed by a file fork. */
260void
261xchk_fblock_set_corrupt(
262 struct xfs_scrub *sc,
263 int whichfork,
264 xfs_fileoff_t offset)
265{
266 sc->sm->sm_flags |= XFS_SCRUB_OFLAG_CORRUPT;
267 trace_xchk_fblock_error(sc, whichfork, offset, __return_address);
268}
269
270/* Record a corruption while cross-referencing a fork block. */
271void
272xchk_fblock_xref_set_corrupt(
273 struct xfs_scrub *sc,
274 int whichfork,
275 xfs_fileoff_t offset)
276{
277 sc->sm->sm_flags |= XFS_SCRUB_OFLAG_XCORRUPT;
278 trace_xchk_fblock_error(sc, whichfork, offset, __return_address);
279}
280
281/*
282 * Warn about inodes that need administrative review but is not
283 * incorrect.
284 */
285void
286xchk_ino_set_warning(
287 struct xfs_scrub *sc,
288 xfs_ino_t ino)
289{
290 sc->sm->sm_flags |= XFS_SCRUB_OFLAG_WARNING;
291 trace_xchk_ino_warning(sc, ino, __return_address);
292}
293
294/* Warn about a block indexed by a file fork that needs review. */
295void
296xchk_fblock_set_warning(
297 struct xfs_scrub *sc,
298 int whichfork,
299 xfs_fileoff_t offset)
300{
301 sc->sm->sm_flags |= XFS_SCRUB_OFLAG_WARNING;
302 trace_xchk_fblock_warning(sc, whichfork, offset, __return_address);
303}
304
305/* Signal an incomplete scrub. */
306void
307xchk_set_incomplete(
308 struct xfs_scrub *sc)
309{
310 sc->sm->sm_flags |= XFS_SCRUB_OFLAG_INCOMPLETE;
311 trace_xchk_incomplete(sc, __return_address);
312}
313
314/*
315 * rmap scrubbing -- compute the number of blocks with a given owner,
316 * at least according to the reverse mapping data.
317 */
318
319struct xchk_rmap_ownedby_info {
320 const struct xfs_owner_info *oinfo;
321 xfs_filblks_t *blocks;
322};
323
324STATIC int
325xchk_count_rmap_ownedby_irec(
326 struct xfs_btree_cur *cur,
327 struct xfs_rmap_irec *rec,
328 void *priv)
329{
330 struct xchk_rmap_ownedby_info *sroi = priv;
331 bool irec_attr;
332 bool oinfo_attr;
333
334 irec_attr = rec->rm_flags & XFS_RMAP_ATTR_FORK;
335 oinfo_attr = sroi->oinfo->oi_flags & XFS_OWNER_INFO_ATTR_FORK;
336
337 if (rec->rm_owner != sroi->oinfo->oi_owner)
338 return 0;
339
340 if (XFS_RMAP_NON_INODE_OWNER(rec->rm_owner) || irec_attr == oinfo_attr)
341 (*sroi->blocks) += rec->rm_blockcount;
342
343 return 0;
344}
345
346/*
347 * Calculate the number of blocks the rmap thinks are owned by something.
348 * The caller should pass us an rmapbt cursor.
349 */
350int
351xchk_count_rmap_ownedby_ag(
352 struct xfs_scrub *sc,
353 struct xfs_btree_cur *cur,
354 const struct xfs_owner_info *oinfo,
355 xfs_filblks_t *blocks)
356{
357 struct xchk_rmap_ownedby_info sroi = {
358 .oinfo = oinfo,
359 .blocks = blocks,
360 };
361
362 *blocks = 0;
363 return xfs_rmap_query_all(cur, xchk_count_rmap_ownedby_irec,
364 &sroi);
365}
366
367/*
368 * AG scrubbing
369 *
370 * These helpers facilitate locking an allocation group's header
371 * buffers, setting up cursors for all btrees that are present, and
372 * cleaning everything up once we're through.
373 */
374
375/* Decide if we want to return an AG header read failure. */
376static inline bool
377want_ag_read_header_failure(
378 struct xfs_scrub *sc,
379 unsigned int type)
380{
381 /* Return all AG header read failures when scanning btrees. */
382 if (sc->sm->sm_type != XFS_SCRUB_TYPE_AGF &&
383 sc->sm->sm_type != XFS_SCRUB_TYPE_AGFL &&
384 sc->sm->sm_type != XFS_SCRUB_TYPE_AGI)
385 return true;
386 /*
387 * If we're scanning a given type of AG header, we only want to
388 * see read failures from that specific header. We'd like the
389 * other headers to cross-check them, but this isn't required.
390 */
391 if (sc->sm->sm_type == type)
392 return true;
393 return false;
394}
395
396/*
397 * Grab all the headers for an AG.
398 *
399 * The headers should be released by xchk_ag_free, but as a fail
400 * safe we attach all the buffers we grab to the scrub transaction so
401 * they'll all be freed when we cancel it.
402 */
403int
404xchk_ag_read_headers(
405 struct xfs_scrub *sc,
406 xfs_agnumber_t agno,
407 struct xchk_ag *sa)
408{
409 struct xfs_mount *mp = sc->mp;
410 int error;
411
412 sa->agno = agno;
413
414 error = xfs_ialloc_read_agi(mp, sc->tp, agno, &sa->agi_bp);
415 if (error && want_ag_read_header_failure(sc, XFS_SCRUB_TYPE_AGI))
416 goto out;
417
418 error = xfs_alloc_read_agf(mp, sc->tp, agno, 0, &sa->agf_bp);
419 if (error && want_ag_read_header_failure(sc, XFS_SCRUB_TYPE_AGF))
420 goto out;
421
422 error = xfs_alloc_read_agfl(mp, sc->tp, agno, &sa->agfl_bp);
423 if (error && want_ag_read_header_failure(sc, XFS_SCRUB_TYPE_AGFL))
424 goto out;
425 error = 0;
426out:
427 return error;
428}
429
430/* Release all the AG btree cursors. */
431void
432xchk_ag_btcur_free(
433 struct xchk_ag *sa)
434{
435 if (sa->refc_cur)
436 xfs_btree_del_cursor(sa->refc_cur, XFS_BTREE_ERROR);
437 if (sa->rmap_cur)
438 xfs_btree_del_cursor(sa->rmap_cur, XFS_BTREE_ERROR);
439 if (sa->fino_cur)
440 xfs_btree_del_cursor(sa->fino_cur, XFS_BTREE_ERROR);
441 if (sa->ino_cur)
442 xfs_btree_del_cursor(sa->ino_cur, XFS_BTREE_ERROR);
443 if (sa->cnt_cur)
444 xfs_btree_del_cursor(sa->cnt_cur, XFS_BTREE_ERROR);
445 if (sa->bno_cur)
446 xfs_btree_del_cursor(sa->bno_cur, XFS_BTREE_ERROR);
447
448 sa->refc_cur = NULL;
449 sa->rmap_cur = NULL;
450 sa->fino_cur = NULL;
451 sa->ino_cur = NULL;
452 sa->bno_cur = NULL;
453 sa->cnt_cur = NULL;
454}
455
456/* Initialize all the btree cursors for an AG. */
457void
458xchk_ag_btcur_init(
459 struct xfs_scrub *sc,
460 struct xchk_ag *sa)
461{
462 struct xfs_mount *mp = sc->mp;
463
464 xchk_perag_get(sc->mp, sa);
465 if (sa->agf_bp &&
466 xchk_ag_btree_healthy_enough(sc, sa->pag, XFS_BTNUM_BNO)) {
467 /* Set up a bnobt cursor for cross-referencing. */
468 sa->bno_cur = xfs_allocbt_init_cursor(mp, sc->tp, sa->agf_bp,
469 sa->pag, XFS_BTNUM_BNO);
470 }
471
472 if (sa->agf_bp &&
473 xchk_ag_btree_healthy_enough(sc, sa->pag, XFS_BTNUM_CNT)) {
474 /* Set up a cntbt cursor for cross-referencing. */
475 sa->cnt_cur = xfs_allocbt_init_cursor(mp, sc->tp, sa->agf_bp,
476 sa->pag, XFS_BTNUM_CNT);
477 }
478
479 /* Set up a inobt cursor for cross-referencing. */
480 if (sa->agi_bp &&
481 xchk_ag_btree_healthy_enough(sc, sa->pag, XFS_BTNUM_INO)) {
482 sa->ino_cur = xfs_inobt_init_cursor(mp, sc->tp, sa->agi_bp,
483 sa->pag, XFS_BTNUM_INO);
484 }
485
486 /* Set up a finobt cursor for cross-referencing. */
487 if (sa->agi_bp && xfs_sb_version_hasfinobt(&mp->m_sb) &&
488 xchk_ag_btree_healthy_enough(sc, sa->pag, XFS_BTNUM_FINO)) {
489 sa->fino_cur = xfs_inobt_init_cursor(mp, sc->tp, sa->agi_bp,
490 sa->pag, XFS_BTNUM_FINO);
491 }
492
493 /* Set up a rmapbt cursor for cross-referencing. */
494 if (sa->agf_bp && xfs_sb_version_hasrmapbt(&mp->m_sb) &&
495 xchk_ag_btree_healthy_enough(sc, sa->pag, XFS_BTNUM_RMAP)) {
496 sa->rmap_cur = xfs_rmapbt_init_cursor(mp, sc->tp, sa->agf_bp,
497 sa->pag);
498 }
499
500 /* Set up a refcountbt cursor for cross-referencing. */
501 if (sa->agf_bp && xfs_sb_version_hasreflink(&mp->m_sb) &&
502 xchk_ag_btree_healthy_enough(sc, sa->pag, XFS_BTNUM_REFC)) {
503 sa->refc_cur = xfs_refcountbt_init_cursor(mp, sc->tp,
504 sa->agf_bp, sa->pag);
505 }
506}
507
508/* Release the AG header context and btree cursors. */
509void
510xchk_ag_free(
511 struct xfs_scrub *sc,
512 struct xchk_ag *sa)
513{
514 xchk_ag_btcur_free(sa);
515 if (sa->agfl_bp) {
516 xfs_trans_brelse(sc->tp, sa->agfl_bp);
517 sa->agfl_bp = NULL;
518 }
519 if (sa->agf_bp) {
520 xfs_trans_brelse(sc->tp, sa->agf_bp);
521 sa->agf_bp = NULL;
522 }
523 if (sa->agi_bp) {
524 xfs_trans_brelse(sc->tp, sa->agi_bp);
525 sa->agi_bp = NULL;
526 }
527 if (sa->pag) {
528 xfs_perag_put(sa->pag);
529 sa->pag = NULL;
530 }
531 sa->agno = NULLAGNUMBER;
532}
533
534/*
535 * For scrub, grab the AGI and the AGF headers, in that order. Locking
536 * order requires us to get the AGI before the AGF. We use the
537 * transaction to avoid deadlocking on crosslinked metadata buffers;
538 * either the caller passes one in (bmap scrub) or we have to create a
539 * transaction ourselves.
540 */
541int
542xchk_ag_init(
543 struct xfs_scrub *sc,
544 xfs_agnumber_t agno,
545 struct xchk_ag *sa)
546{
547 int error;
548
549 error = xchk_ag_read_headers(sc, agno, sa);
550 if (error)
551 return error;
552
553 xchk_ag_btcur_init(sc, sa);
554 return 0;
555}
556
557/*
558 * Grab the per-ag structure if we haven't already gotten it. Teardown of the
559 * xchk_ag will release it for us.
560 */
561void
562xchk_perag_get(
563 struct xfs_mount *mp,
564 struct xchk_ag *sa)
565{
566 if (!sa->pag)
567 sa->pag = xfs_perag_get(mp, sa->agno);
568}
569
570/* Per-scrubber setup functions */
571
572/*
573 * Grab an empty transaction so that we can re-grab locked buffers if
574 * one of our btrees turns out to be cyclic.
575 *
576 * If we're going to repair something, we need to ask for the largest possible
577 * log reservation so that we can handle the worst case scenario for metadata
578 * updates while rebuilding a metadata item. We also need to reserve as many
579 * blocks in the head transaction as we think we're going to need to rebuild
580 * the metadata object.
581 */
582int
583xchk_trans_alloc(
584 struct xfs_scrub *sc,
585 uint resblks)
586{
587 if (sc->sm->sm_flags & XFS_SCRUB_IFLAG_REPAIR)
588 return xfs_trans_alloc(sc->mp, &M_RES(sc->mp)->tr_itruncate,
589 resblks, 0, 0, &sc->tp);
590
591 return xfs_trans_alloc_empty(sc->mp, &sc->tp);
592}
593
594/* Set us up with a transaction and an empty context. */
595int
596xchk_setup_fs(
597 struct xfs_scrub *sc)
598{
599 uint resblks;
600
601 resblks = xrep_calc_ag_resblks(sc);
602 return xchk_trans_alloc(sc, resblks);
603}
604
605/* Set us up with AG headers and btree cursors. */
606int
607xchk_setup_ag_btree(
608 struct xfs_scrub *sc,
609 bool force_log)
610{
611 struct xfs_mount *mp = sc->mp;
612 int error;
613
614 /*
615 * If the caller asks us to checkpont the log, do so. This
616 * expensive operation should be performed infrequently and only
617 * as a last resort. Any caller that sets force_log should
618 * document why they need to do so.
619 */
620 if (force_log) {
621 error = xchk_checkpoint_log(mp);
622 if (error)
623 return error;
624 }
625
626 error = xchk_setup_fs(sc);
627 if (error)
628 return error;
629
630 return xchk_ag_init(sc, sc->sm->sm_agno, &sc->sa);
631}
632
633/* Push everything out of the log onto disk. */
634int
635xchk_checkpoint_log(
636 struct xfs_mount *mp)
637{
638 int error;
639
640 error = xfs_log_force(mp, XFS_LOG_SYNC);
641 if (error)
642 return error;
643 xfs_ail_push_all_sync(mp->m_ail);
644 return 0;
645}
646
647/*
648 * Given an inode and the scrub control structure, grab either the
649 * inode referenced in the control structure or the inode passed in.
650 * The inode is not locked.
651 */
652int
653xchk_get_inode(
654 struct xfs_scrub *sc)
655{
656 struct xfs_imap imap;
657 struct xfs_mount *mp = sc->mp;
658 struct xfs_inode *ip_in = XFS_I(file_inode(sc->file));
659 struct xfs_inode *ip = NULL;
660 int error;
661
662 /* We want to scan the inode we already had opened. */
663 if (sc->sm->sm_ino == 0 || sc->sm->sm_ino == ip_in->i_ino) {
664 sc->ip = ip_in;
665 return 0;
666 }
667
668 /* Look up the inode, see if the generation number matches. */
669 if (xfs_internal_inum(mp, sc->sm->sm_ino))
670 return -ENOENT;
671 error = xfs_iget(mp, NULL, sc->sm->sm_ino,
672 XFS_IGET_UNTRUSTED | XFS_IGET_DONTCACHE, 0, &ip);
673 switch (error) {
674 case -ENOENT:
675 /* Inode doesn't exist, just bail out. */
676 return error;
677 case 0:
678 /* Got an inode, continue. */
679 break;
680 case -EINVAL:
681 /*
682 * -EINVAL with IGET_UNTRUSTED could mean one of several
683 * things: userspace gave us an inode number that doesn't
684 * correspond to fs space, or doesn't have an inobt entry;
685 * or it could simply mean that the inode buffer failed the
686 * read verifiers.
687 *
688 * Try just the inode mapping lookup -- if it succeeds, then
689 * the inode buffer verifier failed and something needs fixing.
690 * Otherwise, we really couldn't find it so tell userspace
691 * that it no longer exists.
692 */
693 error = xfs_imap(sc->mp, sc->tp, sc->sm->sm_ino, &imap,
694 XFS_IGET_UNTRUSTED | XFS_IGET_DONTCACHE);
695 if (error)
696 return -ENOENT;
697 error = -EFSCORRUPTED;
698 fallthrough;
699 default:
700 trace_xchk_op_error(sc,
701 XFS_INO_TO_AGNO(mp, sc->sm->sm_ino),
702 XFS_INO_TO_AGBNO(mp, sc->sm->sm_ino),
703 error, __return_address);
704 return error;
705 }
706 if (VFS_I(ip)->i_generation != sc->sm->sm_gen) {
707 xfs_irele(ip);
708 return -ENOENT;
709 }
710
711 sc->ip = ip;
712 return 0;
713}
714
715/* Set us up to scrub a file's contents. */
716int
717xchk_setup_inode_contents(
718 struct xfs_scrub *sc,
719 unsigned int resblks)
720{
721 int error;
722
723 error = xchk_get_inode(sc);
724 if (error)
725 return error;
726
727 /* Got the inode, lock it and we're ready to go. */
728 sc->ilock_flags = XFS_IOLOCK_EXCL | XFS_MMAPLOCK_EXCL;
729 xfs_ilock(sc->ip, sc->ilock_flags);
730 error = xchk_trans_alloc(sc, resblks);
731 if (error)
732 goto out;
733 sc->ilock_flags |= XFS_ILOCK_EXCL;
734 xfs_ilock(sc->ip, XFS_ILOCK_EXCL);
735
736out:
737 /* scrub teardown will unlock and release the inode for us */
738 return error;
739}
740
741/*
742 * Predicate that decides if we need to evaluate the cross-reference check.
743 * If there was an error accessing the cross-reference btree, just delete
744 * the cursor and skip the check.
745 */
746bool
747xchk_should_check_xref(
748 struct xfs_scrub *sc,
749 int *error,
750 struct xfs_btree_cur **curpp)
751{
752 /* No point in xref if we already know we're corrupt. */
753 if (xchk_skip_xref(sc->sm))
754 return false;
755
756 if (*error == 0)
757 return true;
758
759 if (curpp) {
760 /* If we've already given up on xref, just bail out. */
761 if (!*curpp)
762 return false;
763
764 /* xref error, delete cursor and bail out. */
765 xfs_btree_del_cursor(*curpp, XFS_BTREE_ERROR);
766 *curpp = NULL;
767 }
768
769 sc->sm->sm_flags |= XFS_SCRUB_OFLAG_XFAIL;
770 trace_xchk_xref_error(sc, *error, __return_address);
771
772 /*
773 * Errors encountered during cross-referencing with another
774 * data structure should not cause this scrubber to abort.
775 */
776 *error = 0;
777 return false;
778}
779
780/* Run the structure verifiers on in-memory buffers to detect bad memory. */
781void
782xchk_buffer_recheck(
783 struct xfs_scrub *sc,
784 struct xfs_buf *bp)
785{
786 xfs_failaddr_t fa;
787
788 if (bp->b_ops == NULL) {
789 xchk_block_set_corrupt(sc, bp);
790 return;
791 }
792 if (bp->b_ops->verify_struct == NULL) {
793 xchk_set_incomplete(sc);
794 return;
795 }
796 fa = bp->b_ops->verify_struct(bp);
797 if (!fa)
798 return;
799 sc->sm->sm_flags |= XFS_SCRUB_OFLAG_CORRUPT;
800 trace_xchk_block_error(sc, bp->b_bn, fa);
801}
802
803/*
804 * Scrub the attr/data forks of a metadata inode. The metadata inode must be
805 * pointed to by sc->ip and the ILOCK must be held.
806 */
807int
808xchk_metadata_inode_forks(
809 struct xfs_scrub *sc)
810{
811 __u32 smtype;
812 bool shared;
813 int error;
814
815 if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
816 return 0;
817
818 /* Metadata inodes don't live on the rt device. */
819 if (sc->ip->i_diflags & XFS_DIFLAG_REALTIME) {
820 xchk_ino_set_corrupt(sc, sc->ip->i_ino);
821 return 0;
822 }
823
824 /* They should never participate in reflink. */
825 if (xfs_is_reflink_inode(sc->ip)) {
826 xchk_ino_set_corrupt(sc, sc->ip->i_ino);
827 return 0;
828 }
829
830 /* They also should never have extended attributes. */
831 if (xfs_inode_hasattr(sc->ip)) {
832 xchk_ino_set_corrupt(sc, sc->ip->i_ino);
833 return 0;
834 }
835
836 /* Invoke the data fork scrubber. */
837 smtype = sc->sm->sm_type;
838 sc->sm->sm_type = XFS_SCRUB_TYPE_BMBTD;
839 error = xchk_bmap_data(sc);
840 sc->sm->sm_type = smtype;
841 if (error || (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT))
842 return error;
843
844 /* Look for incorrect shared blocks. */
845 if (xfs_sb_version_hasreflink(&sc->mp->m_sb)) {
846 error = xfs_reflink_inode_has_shared_extents(sc->tp, sc->ip,
847 &shared);
848 if (!xchk_fblock_process_error(sc, XFS_DATA_FORK, 0,
849 &error))
850 return error;
851 if (shared)
852 xchk_ino_set_corrupt(sc, sc->ip->i_ino);
853 }
854
855 return error;
856}
857
858/*
859 * Try to lock an inode in violation of the usual locking order rules. For
860 * example, trying to get the IOLOCK while in transaction context, or just
861 * plain breaking AG-order or inode-order inode locking rules. Either way,
862 * the only way to avoid an ABBA deadlock is to use trylock and back off if
863 * we can't.
864 */
865int
866xchk_ilock_inverted(
867 struct xfs_inode *ip,
868 uint lock_mode)
869{
870 int i;
871
872 for (i = 0; i < 20; i++) {
873 if (xfs_ilock_nowait(ip, lock_mode))
874 return 0;
875 delay(1);
876 }
877 return -EDEADLOCK;
878}
879
880/* Pause background reaping of resources. */
881void
882xchk_stop_reaping(
883 struct xfs_scrub *sc)
884{
885 sc->flags |= XCHK_REAPING_DISABLED;
886 xfs_blockgc_stop(sc->mp);
887}
888
889/* Restart background reaping of resources. */
890void
891xchk_start_reaping(
892 struct xfs_scrub *sc)
893{
894 xfs_blockgc_start(sc->mp);
895 sc->flags &= ~XCHK_REAPING_DISABLED;
896}