Loading...
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_alloc.h"
14#include "xfs_rmap.h"
15#include "scrub/scrub.h"
16#include "scrub/common.h"
17#include "scrub/btree.h"
18
19/*
20 * Set us up to scrub free space btrees.
21 */
22int
23xchk_setup_ag_allocbt(
24 struct xfs_scrub *sc,
25 struct xfs_inode *ip)
26{
27 return xchk_setup_ag_btree(sc, ip, false);
28}
29
30/* Free space btree scrubber. */
31/*
32 * Ensure there's a corresponding cntbt/bnobt record matching this
33 * bnobt/cntbt record, respectively.
34 */
35STATIC void
36xchk_allocbt_xref_other(
37 struct xfs_scrub *sc,
38 xfs_agblock_t agbno,
39 xfs_extlen_t len)
40{
41 struct xfs_btree_cur **pcur;
42 xfs_agblock_t fbno;
43 xfs_extlen_t flen;
44 int has_otherrec;
45 int error;
46
47 if (sc->sm->sm_type == XFS_SCRUB_TYPE_BNOBT)
48 pcur = &sc->sa.cnt_cur;
49 else
50 pcur = &sc->sa.bno_cur;
51 if (!*pcur || xchk_skip_xref(sc->sm))
52 return;
53
54 error = xfs_alloc_lookup_le(*pcur, agbno, len, &has_otherrec);
55 if (!xchk_should_check_xref(sc, &error, pcur))
56 return;
57 if (!has_otherrec) {
58 xchk_btree_xref_set_corrupt(sc, *pcur, 0);
59 return;
60 }
61
62 error = xfs_alloc_get_rec(*pcur, &fbno, &flen, &has_otherrec);
63 if (!xchk_should_check_xref(sc, &error, pcur))
64 return;
65 if (!has_otherrec) {
66 xchk_btree_xref_set_corrupt(sc, *pcur, 0);
67 return;
68 }
69
70 if (fbno != agbno || flen != len)
71 xchk_btree_xref_set_corrupt(sc, *pcur, 0);
72}
73
74/* Cross-reference with the other btrees. */
75STATIC void
76xchk_allocbt_xref(
77 struct xfs_scrub *sc,
78 xfs_agblock_t agbno,
79 xfs_extlen_t len)
80{
81 if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
82 return;
83
84 xchk_allocbt_xref_other(sc, agbno, len);
85 xchk_xref_is_not_inode_chunk(sc, agbno, len);
86 xchk_xref_has_no_owner(sc, agbno, len);
87 xchk_xref_is_not_shared(sc, agbno, len);
88}
89
90/* Scrub a bnobt/cntbt record. */
91STATIC int
92xchk_allocbt_rec(
93 struct xchk_btree *bs,
94 union xfs_btree_rec *rec)
95{
96 struct xfs_mount *mp = bs->cur->bc_mp;
97 xfs_agnumber_t agno = bs->cur->bc_private.a.agno;
98 xfs_agblock_t bno;
99 xfs_extlen_t len;
100
101 bno = be32_to_cpu(rec->alloc.ar_startblock);
102 len = be32_to_cpu(rec->alloc.ar_blockcount);
103
104 if (bno + len <= bno ||
105 !xfs_verify_agbno(mp, agno, bno) ||
106 !xfs_verify_agbno(mp, agno, bno + len - 1))
107 xchk_btree_set_corrupt(bs->sc, bs->cur, 0);
108
109 xchk_allocbt_xref(bs->sc, bno, len);
110
111 return 0;
112}
113
114/* Scrub the freespace btrees for some AG. */
115STATIC int
116xchk_allocbt(
117 struct xfs_scrub *sc,
118 xfs_btnum_t which)
119{
120 struct xfs_btree_cur *cur;
121
122 cur = which == XFS_BTNUM_BNO ? sc->sa.bno_cur : sc->sa.cnt_cur;
123 return xchk_btree(sc, cur, xchk_allocbt_rec, &XFS_RMAP_OINFO_AG, NULL);
124}
125
126int
127xchk_bnobt(
128 struct xfs_scrub *sc)
129{
130 return xchk_allocbt(sc, XFS_BTNUM_BNO);
131}
132
133int
134xchk_cntbt(
135 struct xfs_scrub *sc)
136{
137 return xchk_allocbt(sc, XFS_BTNUM_CNT);
138}
139
140/* xref check that the extent is not free */
141void
142xchk_xref_is_used_space(
143 struct xfs_scrub *sc,
144 xfs_agblock_t agbno,
145 xfs_extlen_t len)
146{
147 bool is_freesp;
148 int error;
149
150 if (!sc->sa.bno_cur || xchk_skip_xref(sc->sm))
151 return;
152
153 error = xfs_alloc_has_record(sc->sa.bno_cur, agbno, len, &is_freesp);
154 if (!xchk_should_check_xref(sc, &error, &sc->sa.bno_cur))
155 return;
156 if (is_freesp)
157 xchk_btree_xref_set_corrupt(sc, sc->sa.bno_cur, 0);
158}
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * Copyright (C) 2017-2023 Oracle. All Rights Reserved.
4 * Author: Darrick J. Wong <djwong@kernel.org>
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_log_format.h"
13#include "xfs_trans.h"
14#include "xfs_btree.h"
15#include "xfs_alloc.h"
16#include "xfs_rmap.h"
17#include "xfs_ag.h"
18#include "scrub/scrub.h"
19#include "scrub/common.h"
20#include "scrub/btree.h"
21#include "scrub/repair.h"
22
23/*
24 * Set us up to scrub free space btrees.
25 */
26int
27xchk_setup_ag_allocbt(
28 struct xfs_scrub *sc)
29{
30 int error;
31
32 if (xchk_need_intent_drain(sc))
33 xchk_fsgates_enable(sc, XCHK_FSGATES_DRAIN);
34
35 error = xchk_setup_ag_btree(sc, false);
36 if (error)
37 return error;
38
39 if (xchk_could_repair(sc))
40 return xrep_setup_ag_allocbt(sc);
41
42 return 0;
43}
44
45/* Free space btree scrubber. */
46
47struct xchk_alloc {
48 /* Previous free space extent. */
49 struct xfs_alloc_rec_incore prev;
50};
51
52/*
53 * Ensure there's a corresponding cntbt/bnobt record matching this
54 * bnobt/cntbt record, respectively.
55 */
56STATIC void
57xchk_allocbt_xref_other(
58 struct xfs_scrub *sc,
59 xfs_agblock_t agbno,
60 xfs_extlen_t len)
61{
62 struct xfs_btree_cur **pcur;
63 xfs_agblock_t fbno;
64 xfs_extlen_t flen;
65 int has_otherrec;
66 int error;
67
68 if (sc->sm->sm_type == XFS_SCRUB_TYPE_BNOBT)
69 pcur = &sc->sa.cnt_cur;
70 else
71 pcur = &sc->sa.bno_cur;
72 if (!*pcur || xchk_skip_xref(sc->sm))
73 return;
74
75 error = xfs_alloc_lookup_le(*pcur, agbno, len, &has_otherrec);
76 if (!xchk_should_check_xref(sc, &error, pcur))
77 return;
78 if (!has_otherrec) {
79 xchk_btree_xref_set_corrupt(sc, *pcur, 0);
80 return;
81 }
82
83 error = xfs_alloc_get_rec(*pcur, &fbno, &flen, &has_otherrec);
84 if (!xchk_should_check_xref(sc, &error, pcur))
85 return;
86 if (!has_otherrec) {
87 xchk_btree_xref_set_corrupt(sc, *pcur, 0);
88 return;
89 }
90
91 if (fbno != agbno || flen != len)
92 xchk_btree_xref_set_corrupt(sc, *pcur, 0);
93}
94
95/* Cross-reference with the other btrees. */
96STATIC void
97xchk_allocbt_xref(
98 struct xfs_scrub *sc,
99 const struct xfs_alloc_rec_incore *irec)
100{
101 xfs_agblock_t agbno = irec->ar_startblock;
102 xfs_extlen_t len = irec->ar_blockcount;
103
104 if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
105 return;
106
107 xchk_allocbt_xref_other(sc, agbno, len);
108 xchk_xref_is_not_inode_chunk(sc, agbno, len);
109 xchk_xref_has_no_owner(sc, agbno, len);
110 xchk_xref_is_not_shared(sc, agbno, len);
111 xchk_xref_is_not_cow_staging(sc, agbno, len);
112}
113
114/* Flag failures for records that could be merged. */
115STATIC void
116xchk_allocbt_mergeable(
117 struct xchk_btree *bs,
118 struct xchk_alloc *ca,
119 const struct xfs_alloc_rec_incore *irec)
120{
121 if (bs->sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
122 return;
123
124 if (ca->prev.ar_blockcount > 0 &&
125 ca->prev.ar_startblock + ca->prev.ar_blockcount == irec->ar_startblock &&
126 ca->prev.ar_blockcount + irec->ar_blockcount < (uint32_t)~0U)
127 xchk_btree_set_corrupt(bs->sc, bs->cur, 0);
128
129 memcpy(&ca->prev, irec, sizeof(*irec));
130}
131
132/* Scrub a bnobt/cntbt record. */
133STATIC int
134xchk_allocbt_rec(
135 struct xchk_btree *bs,
136 const union xfs_btree_rec *rec)
137{
138 struct xfs_alloc_rec_incore irec;
139 struct xchk_alloc *ca = bs->private;
140
141 xfs_alloc_btrec_to_irec(rec, &irec);
142 if (xfs_alloc_check_irec(to_perag(bs->cur->bc_group), &irec) != NULL) {
143 xchk_btree_set_corrupt(bs->sc, bs->cur, 0);
144 return 0;
145 }
146
147 xchk_allocbt_mergeable(bs, ca, &irec);
148 xchk_allocbt_xref(bs->sc, &irec);
149
150 return 0;
151}
152
153/* Scrub one of the freespace btrees for some AG. */
154int
155xchk_allocbt(
156 struct xfs_scrub *sc)
157{
158 struct xchk_alloc ca = { };
159 struct xfs_btree_cur *cur;
160
161 switch (sc->sm->sm_type) {
162 case XFS_SCRUB_TYPE_BNOBT:
163 cur = sc->sa.bno_cur;
164 break;
165 case XFS_SCRUB_TYPE_CNTBT:
166 cur = sc->sa.cnt_cur;
167 break;
168 default:
169 ASSERT(0);
170 return -EIO;
171 }
172
173 return xchk_btree(sc, cur, xchk_allocbt_rec, &XFS_RMAP_OINFO_AG, &ca);
174}
175
176/* xref check that the extent is not free */
177void
178xchk_xref_is_used_space(
179 struct xfs_scrub *sc,
180 xfs_agblock_t agbno,
181 xfs_extlen_t len)
182{
183 enum xbtree_recpacking outcome;
184 int error;
185
186 if (!sc->sa.bno_cur || xchk_skip_xref(sc->sm))
187 return;
188
189 error = xfs_alloc_has_records(sc->sa.bno_cur, agbno, len, &outcome);
190 if (!xchk_should_check_xref(sc, &error, &sc->sa.bno_cur))
191 return;
192 if (outcome != XBTREE_RECPACKING_EMPTY)
193 xchk_btree_xref_set_corrupt(sc, sc->sa.bno_cur, 0);
194}