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_btree.h"
13#include "xfs_inode.h"
14#include "xfs_log_format.h"
15#include "xfs_trans.h"
16#include "xfs_rtbitmap.h"
17#include "xfs_bit.h"
18#include "xfs_bmap.h"
19#include "xfs_sb.h"
20#include "scrub/scrub.h"
21#include "scrub/common.h"
22#include "scrub/trace.h"
23#include "scrub/xfile.h"
24
25/*
26 * Realtime Summary
27 * ================
28 *
29 * We check the realtime summary by scanning the realtime bitmap file to create
30 * a new summary file incore, and then we compare the computed version against
31 * the ondisk version. We use the 'xfile' functionality to store this
32 * (potentially large) amount of data in pageable memory.
33 */
34
35struct xchk_rtsummary {
36 struct xfs_rtalloc_args args;
37
38 uint64_t rextents;
39 uint64_t rbmblocks;
40 uint64_t rsumsize;
41 unsigned int rsumlevels;
42
43 /* Memory buffer for the summary comparison. */
44 union xfs_suminfo_raw words[];
45};
46
47/* Set us up to check the rtsummary file. */
48int
49xchk_setup_rtsummary(
50 struct xfs_scrub *sc)
51{
52 struct xfs_mount *mp = sc->mp;
53 char *descr;
54 struct xchk_rtsummary *rts;
55 int error;
56
57 rts = kvzalloc(struct_size(rts, words, mp->m_blockwsize),
58 XCHK_GFP_FLAGS);
59 if (!rts)
60 return -ENOMEM;
61 sc->buf = rts;
62
63 /*
64 * Create an xfile to construct a new rtsummary file. The xfile allows
65 * us to avoid pinning kernel memory for this purpose.
66 */
67 descr = xchk_xfile_descr(sc, "realtime summary file");
68 error = xfile_create(descr, mp->m_rsumsize, &sc->xfile);
69 kfree(descr);
70 if (error)
71 return error;
72
73 error = xchk_trans_alloc(sc, 0);
74 if (error)
75 return error;
76
77 error = xchk_install_live_inode(sc, mp->m_rsumip);
78 if (error)
79 return error;
80
81 error = xchk_ino_dqattach(sc);
82 if (error)
83 return error;
84
85 /*
86 * Locking order requires us to take the rtbitmap first. We must be
87 * careful to unlock it ourselves when we are done with the rtbitmap
88 * file since the scrub infrastructure won't do that for us. Only
89 * then we can lock the rtsummary inode.
90 */
91 xfs_ilock(mp->m_rbmip, XFS_ILOCK_SHARED | XFS_ILOCK_RTBITMAP);
92 xchk_ilock(sc, XFS_ILOCK_EXCL | XFS_ILOCK_RTSUM);
93
94 /*
95 * Now that we've locked the rtbitmap and rtsummary, we can't race with
96 * growfsrt trying to expand the summary or change the size of the rt
97 * volume. Hence it is safe to compute and check the geometry values.
98 */
99 if (mp->m_sb.sb_rblocks) {
100 xfs_filblks_t rsumblocks;
101 int rextslog;
102
103 rts->rextents = xfs_rtb_to_rtx(mp, mp->m_sb.sb_rblocks);
104 rextslog = xfs_compute_rextslog(rts->rextents);
105 rts->rsumlevels = rextslog + 1;
106 rts->rbmblocks = xfs_rtbitmap_blockcount(mp, rts->rextents);
107 rsumblocks = xfs_rtsummary_blockcount(mp, rts->rsumlevels,
108 rts->rbmblocks);
109 rts->rsumsize = XFS_FSB_TO_B(mp, rsumblocks);
110 }
111 return 0;
112}
113
114/* Helper functions to record suminfo words in an xfile. */
115
116static inline int
117xfsum_load(
118 struct xfs_scrub *sc,
119 xfs_rtsumoff_t sumoff,
120 union xfs_suminfo_raw *rawinfo)
121{
122 return xfile_load(sc->xfile, rawinfo,
123 sizeof(union xfs_suminfo_raw),
124 sumoff << XFS_WORDLOG);
125}
126
127static inline int
128xfsum_store(
129 struct xfs_scrub *sc,
130 xfs_rtsumoff_t sumoff,
131 const union xfs_suminfo_raw rawinfo)
132{
133 return xfile_store(sc->xfile, &rawinfo,
134 sizeof(union xfs_suminfo_raw),
135 sumoff << XFS_WORDLOG);
136}
137
138static inline int
139xfsum_copyout(
140 struct xfs_scrub *sc,
141 xfs_rtsumoff_t sumoff,
142 union xfs_suminfo_raw *rawinfo,
143 unsigned int nr_words)
144{
145 return xfile_load(sc->xfile, rawinfo, nr_words << XFS_WORDLOG,
146 sumoff << XFS_WORDLOG);
147}
148
149static inline xfs_suminfo_t
150xchk_rtsum_inc(
151 struct xfs_mount *mp,
152 union xfs_suminfo_raw *v)
153{
154 v->old += 1;
155 return v->old;
156}
157
158/* Update the summary file to reflect the free extent that we've accumulated. */
159STATIC int
160xchk_rtsum_record_free(
161 struct xfs_mount *mp,
162 struct xfs_trans *tp,
163 const struct xfs_rtalloc_rec *rec,
164 void *priv)
165{
166 struct xfs_scrub *sc = priv;
167 xfs_fileoff_t rbmoff;
168 xfs_rtblock_t rtbno;
169 xfs_filblks_t rtlen;
170 xfs_rtsumoff_t offs;
171 unsigned int lenlog;
172 union xfs_suminfo_raw v;
173 xfs_suminfo_t value;
174 int error = 0;
175
176 if (xchk_should_terminate(sc, &error))
177 return error;
178
179 /* Compute the relevant location in the rtsum file. */
180 rbmoff = xfs_rtx_to_rbmblock(mp, rec->ar_startext);
181 lenlog = xfs_highbit64(rec->ar_extcount);
182 offs = xfs_rtsumoffs(mp, lenlog, rbmoff);
183
184 rtbno = xfs_rtx_to_rtb(mp, rec->ar_startext);
185 rtlen = xfs_rtx_to_rtb(mp, rec->ar_extcount);
186
187 if (!xfs_verify_rtbext(mp, rtbno, rtlen)) {
188 xchk_ino_xref_set_corrupt(sc, mp->m_rbmip->i_ino);
189 return -EFSCORRUPTED;
190 }
191
192 /* Bump the summary count. */
193 error = xfsum_load(sc, offs, &v);
194 if (error)
195 return error;
196
197 value = xchk_rtsum_inc(sc->mp, &v);
198 trace_xchk_rtsum_record_free(mp, rec->ar_startext, rec->ar_extcount,
199 lenlog, offs, value);
200
201 return xfsum_store(sc, offs, v);
202}
203
204/* Compute the realtime summary from the realtime bitmap. */
205STATIC int
206xchk_rtsum_compute(
207 struct xfs_scrub *sc)
208{
209 struct xfs_mount *mp = sc->mp;
210 unsigned long long rtbmp_blocks;
211
212 /* If the bitmap size doesn't match the computed size, bail. */
213 rtbmp_blocks = xfs_rtbitmap_blockcount(mp, mp->m_sb.sb_rextents);
214 if (XFS_FSB_TO_B(mp, rtbmp_blocks) != mp->m_rbmip->i_disk_size)
215 return -EFSCORRUPTED;
216
217 return xfs_rtalloc_query_all(sc->mp, sc->tp, xchk_rtsum_record_free,
218 sc);
219}
220
221/* Compare the rtsummary file against the one we computed. */
222STATIC int
223xchk_rtsum_compare(
224 struct xfs_scrub *sc)
225{
226 struct xfs_bmbt_irec map;
227 struct xfs_iext_cursor icur;
228
229 struct xfs_mount *mp = sc->mp;
230 struct xfs_inode *ip = sc->ip;
231 struct xchk_rtsummary *rts = sc->buf;
232 xfs_fileoff_t off = 0;
233 xfs_fileoff_t endoff;
234 xfs_rtsumoff_t sumoff = 0;
235 int error = 0;
236
237 rts->args.mp = sc->mp;
238 rts->args.tp = sc->tp;
239
240 /* Mappings may not cross or lie beyond EOF. */
241 endoff = XFS_B_TO_FSB(mp, ip->i_disk_size);
242 if (xfs_iext_lookup_extent(ip, &ip->i_df, endoff, &icur, &map)) {
243 xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, endoff);
244 return 0;
245 }
246
247 while (off < endoff) {
248 int nmap = 1;
249
250 if (xchk_should_terminate(sc, &error))
251 return error;
252 if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
253 return 0;
254
255 /* Make sure we have a written extent. */
256 error = xfs_bmapi_read(ip, off, endoff - off, &map, &nmap,
257 XFS_DATA_FORK);
258 if (!xchk_fblock_process_error(sc, XFS_DATA_FORK, off, &error))
259 return error;
260
261 if (nmap != 1 || !xfs_bmap_is_written_extent(&map)) {
262 xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, off);
263 return 0;
264 }
265
266 off += map.br_blockcount;
267 }
268
269 for (off = 0; off < endoff; off++) {
270 union xfs_suminfo_raw *ondisk_info;
271
272 /* Read a block's worth of ondisk rtsummary file. */
273 error = xfs_rtsummary_read_buf(&rts->args, off);
274 if (!xchk_fblock_process_error(sc, XFS_DATA_FORK, off, &error))
275 return error;
276
277 /* Read a block's worth of computed rtsummary file. */
278 error = xfsum_copyout(sc, sumoff, rts->words, mp->m_blockwsize);
279 if (error) {
280 xfs_rtbuf_cache_relse(&rts->args);
281 return error;
282 }
283
284 ondisk_info = xfs_rsumblock_infoptr(&rts->args, 0);
285 if (memcmp(ondisk_info, rts->words,
286 mp->m_blockwsize << XFS_WORDLOG) != 0) {
287 xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, off);
288 xfs_rtbuf_cache_relse(&rts->args);
289 return error;
290 }
291
292 xfs_rtbuf_cache_relse(&rts->args);
293 sumoff += mp->m_blockwsize;
294 }
295
296 return 0;
297}
298
299/* Scrub the realtime summary. */
300int
301xchk_rtsummary(
302 struct xfs_scrub *sc)
303{
304 struct xfs_mount *mp = sc->mp;
305 struct xchk_rtsummary *rts = sc->buf;
306 int error = 0;
307
308 /* Is sb_rextents correct? */
309 if (mp->m_sb.sb_rextents != rts->rextents) {
310 xchk_ino_set_corrupt(sc, mp->m_rbmip->i_ino);
311 goto out_rbm;
312 }
313
314 /* Is m_rsumlevels correct? */
315 if (mp->m_rsumlevels != rts->rsumlevels) {
316 xchk_ino_set_corrupt(sc, mp->m_rsumip->i_ino);
317 goto out_rbm;
318 }
319
320 /* Is m_rsumsize correct? */
321 if (mp->m_rsumsize != rts->rsumsize) {
322 xchk_ino_set_corrupt(sc, mp->m_rsumip->i_ino);
323 goto out_rbm;
324 }
325
326 /* The summary file length must be aligned to an fsblock. */
327 if (mp->m_rsumip->i_disk_size & mp->m_blockmask) {
328 xchk_ino_set_corrupt(sc, mp->m_rsumip->i_ino);
329 goto out_rbm;
330 }
331
332 /*
333 * Is the summary file itself large enough to handle the rt volume?
334 * growfsrt expands the summary file before updating sb_rextents, so
335 * the file can be larger than rsumsize.
336 */
337 if (mp->m_rsumip->i_disk_size < rts->rsumsize) {
338 xchk_ino_set_corrupt(sc, mp->m_rsumip->i_ino);
339 goto out_rbm;
340 }
341
342 /* Invoke the fork scrubber. */
343 error = xchk_metadata_inode_forks(sc);
344 if (error || (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT))
345 goto out_rbm;
346
347 /* Construct the new summary file from the rtbitmap. */
348 error = xchk_rtsum_compute(sc);
349 if (error == -EFSCORRUPTED) {
350 /*
351 * EFSCORRUPTED means the rtbitmap is corrupt, which is an xref
352 * error since we're checking the summary file.
353 */
354 xchk_ino_xref_set_corrupt(sc, mp->m_rbmip->i_ino);
355 error = 0;
356 goto out_rbm;
357 }
358 if (error)
359 goto out_rbm;
360
361 /* Does the computed summary file match the actual rtsummary file? */
362 error = xchk_rtsum_compare(sc);
363
364out_rbm:
365 /* Unlock the rtbitmap since we're done with it. */
366 xfs_iunlock(mp->m_rbmip, XFS_ILOCK_SHARED | XFS_ILOCK_RTBITMAP);
367 return error;
368}
369

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