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_rtbitmap.h"
15 #include "xfs_inode.h"
16 #include "xfs_bmap.h"
17 #include "xfs_bit.h"
18 #include "xfs_sb.h"
19 #include "scrub/scrub.h"
20 #include "scrub/common.h"
21 #include "scrub/repair.h"
22 #include "scrub/rtbitmap.h"
23
24 /* Set us up with the realtime metadata locked. */
25 int
26 xchk_setup_rtbitmap(
27 struct xfs_scrub *sc)
28 {
29 struct xfs_mount *mp = sc->mp;
30 struct xchk_rtbitmap *rtb;
31 int error;
32
33 rtb = kzalloc(sizeof(struct xchk_rtbitmap), XCHK_GFP_FLAGS);
34 if (!rtb)
35 return -ENOMEM;
36 sc->buf = rtb;
37
38 if (xchk_could_repair(sc)) {
39 error = xrep_setup_rtbitmap(sc, rtb);
40 if (error)
41 return error;
42 }
43
44 error = xchk_trans_alloc(sc, rtb->resblks);
45 if (error)
46 return error;
47
48 error = xchk_install_live_inode(sc, sc->mp->m_rbmip);
49 if (error)
50 return error;
51
52 error = xchk_ino_dqattach(sc);
53 if (error)
54 return error;
55
56 xchk_ilock(sc, XFS_ILOCK_EXCL | XFS_ILOCK_RTBITMAP);
57
58 /*
59 * Now that we've locked the rtbitmap, we can't race with growfsrt
60 * trying to expand the bitmap or change the size of the rt volume.
61 * Hence it is safe to compute and check the geometry values.
62 */
63 if (mp->m_sb.sb_rblocks) {
64 rtb->rextents = xfs_rtb_to_rtx(mp, mp->m_sb.sb_rblocks);
65 rtb->rextslog = xfs_compute_rextslog(rtb->rextents);
66 rtb->rbmblocks = xfs_rtbitmap_blockcount(mp, rtb->rextents);
67 }
68 return 0;
69 }
70
71 /* Realtime bitmap. */
72
73 /* Scrub a free extent record from the realtime bitmap. */
74 STATIC int
75 xchk_rtbitmap_rec(
76 struct xfs_mount *mp,
77 struct xfs_trans *tp,
78 const struct xfs_rtalloc_rec *rec,
79 void *priv)
80 {
81 struct xfs_scrub *sc = priv;
82 xfs_rtblock_t startblock;
83 xfs_filblks_t blockcount;
84
85 startblock = xfs_rtx_to_rtb(mp, rec->ar_startext);
86 blockcount = xfs_rtx_to_rtb(mp, rec->ar_extcount);
87
88 if (!xfs_verify_rtbext(mp, startblock, blockcount))
89 xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, 0);
90 return 0;
91 }
92
93 /* Make sure the entire rtbitmap file is mapped with written extents. */
94 STATIC int
95 xchk_rtbitmap_check_extents(
96 struct xfs_scrub *sc)
97 {
98 struct xfs_bmbt_irec map;
99 struct xfs_iext_cursor icur;
100 struct xfs_mount *mp = sc->mp;
101 struct xfs_inode *ip = sc->ip;
102 xfs_fileoff_t off = 0;
103 xfs_fileoff_t endoff;
104 int error = 0;
105
106 /* Mappings may not cross or lie beyond EOF. */
107 endoff = XFS_B_TO_FSB(mp, ip->i_disk_size);
108 if (xfs_iext_lookup_extent(ip, &ip->i_df, endoff, &icur, &map)) {
109 xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, endoff);
110 return 0;
111 }
112
113 while (off < endoff) {
114 int nmap = 1;
115
116 if (xchk_should_terminate(sc, &error) ||
117 (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT))
118 break;
119
120 /* Make sure we have a written extent. */
121 error = xfs_bmapi_read(ip, off, endoff - off, &map, &nmap,
122 XFS_DATA_FORK);
123 if (!xchk_fblock_process_error(sc, XFS_DATA_FORK, off, &error))
124 break;
125
126 if (nmap != 1 || !xfs_bmap_is_written_extent(&map)) {
127 xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, off);
128 break;
129 }
130
131 off += map.br_blockcount;
132 }
133
134 return error;
135 }
136
137 /* Scrub the realtime bitmap. */
138 int
139 xchk_rtbitmap(
140 struct xfs_scrub *sc)
141 {
142 struct xfs_mount *mp = sc->mp;
143 struct xchk_rtbitmap *rtb = sc->buf;
144 int error;
145
146 /* Is sb_rextents correct? */
147 if (mp->m_sb.sb_rextents != rtb->rextents) {
148 xchk_ino_set_corrupt(sc, mp->m_rbmip->i_ino);
149 return 0;
150 }
151
152 /* Is sb_rextslog correct? */
153 if (mp->m_sb.sb_rextslog != rtb->rextslog) {
154 xchk_ino_set_corrupt(sc, mp->m_rbmip->i_ino);
155 return 0;
156 }
157
158 /*
159 * Is sb_rbmblocks large enough to handle the current rt volume? In no
160 * case can we exceed 4bn bitmap blocks since the super field is a u32.
161 */
162 if (rtb->rbmblocks > U32_MAX) {
163 xchk_ino_set_corrupt(sc, mp->m_rbmip->i_ino);
164 return 0;
165 }
166 if (mp->m_sb.sb_rbmblocks != rtb->rbmblocks) {
167 xchk_ino_set_corrupt(sc, mp->m_rbmip->i_ino);
168 return 0;
169 }
170
171 /* The bitmap file length must be aligned to an fsblock. */
172 if (mp->m_rbmip->i_disk_size & mp->m_blockmask) {
173 xchk_ino_set_corrupt(sc, mp->m_rbmip->i_ino);
174 return 0;
175 }
176
177 /*
178 * Is the bitmap file itself large enough to handle the rt volume?
179 * growfsrt expands the bitmap file before updating sb_rextents, so the
180 * file can be larger than sb_rbmblocks.
181 */
182 if (mp->m_rbmip->i_disk_size < XFS_FSB_TO_B(mp, rtb->rbmblocks)) {
183 xchk_ino_set_corrupt(sc, mp->m_rbmip->i_ino);
184 return 0;
185 }
186
187 /* Invoke the fork scrubber. */
188 error = xchk_metadata_inode_forks(sc);
189 if (error || (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT))
190 return error;
191
192 error = xchk_rtbitmap_check_extents(sc);
193 if (error || (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT))
194 return error;
195
196 error = xfs_rtalloc_query_all(mp, sc->tp, xchk_rtbitmap_rec, sc);
197 if (!xchk_fblock_process_error(sc, XFS_DATA_FORK, 0, &error))
198 return error;
199
200 return 0;
201 }
202
203 /* xref check that the extent is not free in the rtbitmap */
204 void
205 xchk_xref_is_used_rt_space(
206 struct xfs_scrub *sc,
207 xfs_rtblock_t rtbno,
208 xfs_extlen_t len)
209 {
210 xfs_rtxnum_t startext;
211 xfs_rtxnum_t endext;
212 bool is_free;
213 int error;
214
215 if (xchk_skip_xref(sc->sm))
216 return;
217
218 startext = xfs_rtb_to_rtx(sc->mp, rtbno);
219 endext = xfs_rtb_to_rtx(sc->mp, rtbno + len - 1);
220 xfs_ilock(sc->mp->m_rbmip, XFS_ILOCK_SHARED | XFS_ILOCK_RTBITMAP);
221 error = xfs_rtalloc_extent_is_free(sc->mp, sc->tp, startext,
222 endext - startext + 1, &is_free);
223 if (!xchk_should_check_xref(sc, &error, NULL))
224 goto out_unlock;
225 if (is_free)
226 xchk_ino_xref_set_corrupt(sc, sc->mp->m_rbmip->i_ino);
227 out_unlock:
228 xfs_iunlock(sc->mp->m_rbmip, XFS_ILOCK_SHARED | XFS_ILOCK_RTBITMAP);
229 }
230
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.