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. */
25int
26xchk_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. */
74STATIC int
75xchk_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. */
94STATIC int
95xchk_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. */
138int
139xchk_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 */
204void
205xchk_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);
227out_unlock:
228 xfs_iunlock(sc->mp->m_rbmip, XFS_ILOCK_SHARED | XFS_ILOCK_RTBITMAP);
229}
230

source code of linux/fs/xfs/scrub/rtbitmap.c