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_rtalloc.h"
17 #include "xfs_bit.h"
18 #include "xfs_bmap.h"
19 #include "scrub/scrub.h"
20 #include "scrub/common.h"
21 #include "scrub/trace.h"
22 #include "scrub/xfile.h"
23
24 /*
25 * Realtime Summary
26 * ================
27 *
28 * We check the realtime summary by scanning the realtime bitmap file to create
29 * a new summary file incore, and then we compare the computed version against
30 * the ondisk version. We use the 'xfile' functionality to store this
31 * (potentially large) amount of data in pageable memory.
32 */
33
34 /* Set us up to check the rtsummary file. */
35 int
xchk_setup_rtsummary(struct xfs_scrub * sc)36 xchk_setup_rtsummary(
37 struct xfs_scrub *sc)
38 {
39 struct xfs_mount *mp = sc->mp;
40 char *descr;
41 int error;
42
43 /*
44 * Create an xfile to construct a new rtsummary file. The xfile allows
45 * us to avoid pinning kernel memory for this purpose.
46 */
47 descr = xchk_xfile_descr(sc, "realtime summary file");
48 error = xfile_create(descr, mp->m_rsumsize, &sc->xfile);
49 kfree(descr);
50 if (error)
51 return error;
52
53 error = xchk_trans_alloc(sc, 0);
54 if (error)
55 return error;
56
57 /* Allocate a memory buffer for the summary comparison. */
58 sc->buf = kvmalloc(mp->m_sb.sb_blocksize, XCHK_GFP_FLAGS);
59 if (!sc->buf)
60 return -ENOMEM;
61
62 error = xchk_install_live_inode(sc, mp->m_rsumip);
63 if (error)
64 return error;
65
66 /*
67 * Locking order requires us to take the rtbitmap first. We must be
68 * careful to unlock it ourselves when we are done with the rtbitmap
69 * file since the scrub infrastructure won't do that for us. Only
70 * then we can lock the rtsummary inode.
71 */
72 xfs_ilock(mp->m_rbmip, XFS_ILOCK_SHARED | XFS_ILOCK_RTBITMAP);
73 xchk_ilock(sc, XFS_ILOCK_EXCL | XFS_ILOCK_RTSUM);
74 return 0;
75 }
76
77 /* Helper functions to record suminfo words in an xfile. */
78
79 typedef unsigned int xchk_rtsumoff_t;
80
81 static inline int
xfsum_load(struct xfs_scrub * sc,xchk_rtsumoff_t sumoff,xfs_suminfo_t * info)82 xfsum_load(
83 struct xfs_scrub *sc,
84 xchk_rtsumoff_t sumoff,
85 xfs_suminfo_t *info)
86 {
87 return xfile_obj_load(sc->xfile, info, sizeof(xfs_suminfo_t),
88 sumoff << XFS_WORDLOG);
89 }
90
91 static inline int
xfsum_store(struct xfs_scrub * sc,xchk_rtsumoff_t sumoff,const xfs_suminfo_t info)92 xfsum_store(
93 struct xfs_scrub *sc,
94 xchk_rtsumoff_t sumoff,
95 const xfs_suminfo_t info)
96 {
97 return xfile_obj_store(sc->xfile, &info, sizeof(xfs_suminfo_t),
98 sumoff << XFS_WORDLOG);
99 }
100
101 static inline int
xfsum_copyout(struct xfs_scrub * sc,xchk_rtsumoff_t sumoff,xfs_suminfo_t * info,unsigned int nr_words)102 xfsum_copyout(
103 struct xfs_scrub *sc,
104 xchk_rtsumoff_t sumoff,
105 xfs_suminfo_t *info,
106 unsigned int nr_words)
107 {
108 return xfile_obj_load(sc->xfile, info, nr_words << XFS_WORDLOG,
109 sumoff << XFS_WORDLOG);
110 }
111
112 /* Update the summary file to reflect the free extent that we've accumulated. */
113 STATIC int
xchk_rtsum_record_free(struct xfs_mount * mp,struct xfs_trans * tp,const struct xfs_rtalloc_rec * rec,void * priv)114 xchk_rtsum_record_free(
115 struct xfs_mount *mp,
116 struct xfs_trans *tp,
117 const struct xfs_rtalloc_rec *rec,
118 void *priv)
119 {
120 struct xfs_scrub *sc = priv;
121 xfs_fileoff_t rbmoff;
122 xfs_rtblock_t rtbno;
123 xfs_filblks_t rtlen;
124 xchk_rtsumoff_t offs;
125 unsigned int lenlog;
126 xfs_suminfo_t v = 0;
127 int error = 0;
128
129 if (xchk_should_terminate(sc, &error))
130 return error;
131
132 /* Compute the relevant location in the rtsum file. */
133 rbmoff = XFS_BITTOBLOCK(mp, rec->ar_startext);
134 lenlog = XFS_RTBLOCKLOG(rec->ar_extcount);
135 offs = XFS_SUMOFFS(mp, lenlog, rbmoff);
136
137 rtbno = rec->ar_startext * mp->m_sb.sb_rextsize;
138 rtlen = rec->ar_extcount * mp->m_sb.sb_rextsize;
139
140 if (!xfs_verify_rtext(mp, rtbno, rtlen)) {
141 xchk_ino_xref_set_corrupt(sc, mp->m_rbmip->i_ino);
142 return -EFSCORRUPTED;
143 }
144
145 /* Bump the summary count. */
146 error = xfsum_load(sc, offs, &v);
147 if (error)
148 return error;
149
150 v++;
151 trace_xchk_rtsum_record_free(mp, rec->ar_startext, rec->ar_extcount,
152 lenlog, offs, v);
153
154 return xfsum_store(sc, offs, v);
155 }
156
157 /* Compute the realtime summary from the realtime bitmap. */
158 STATIC int
xchk_rtsum_compute(struct xfs_scrub * sc)159 xchk_rtsum_compute(
160 struct xfs_scrub *sc)
161 {
162 struct xfs_mount *mp = sc->mp;
163 unsigned long long rtbmp_bytes;
164
165 /* If the bitmap size doesn't match the computed size, bail. */
166 rtbmp_bytes = howmany_64(mp->m_sb.sb_rextents, NBBY);
167 if (roundup_64(rtbmp_bytes, mp->m_sb.sb_blocksize) !=
168 mp->m_rbmip->i_disk_size)
169 return -EFSCORRUPTED;
170
171 return xfs_rtalloc_query_all(sc->mp, sc->tp, xchk_rtsum_record_free,
172 sc);
173 }
174
175 /* Compare the rtsummary file against the one we computed. */
176 STATIC int
xchk_rtsum_compare(struct xfs_scrub * sc)177 xchk_rtsum_compare(
178 struct xfs_scrub *sc)
179 {
180 struct xfs_mount *mp = sc->mp;
181 struct xfs_buf *bp;
182 struct xfs_bmbt_irec map;
183 xfs_fileoff_t off;
184 xchk_rtsumoff_t sumoff = 0;
185 int nmap;
186
187 for (off = 0; off < XFS_B_TO_FSB(mp, mp->m_rsumsize); off++) {
188 int error = 0;
189
190 if (xchk_should_terminate(sc, &error))
191 return error;
192 if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
193 return 0;
194
195 /* Make sure we have a written extent. */
196 nmap = 1;
197 error = xfs_bmapi_read(mp->m_rsumip, off, 1, &map, &nmap,
198 XFS_DATA_FORK);
199 if (!xchk_fblock_process_error(sc, XFS_DATA_FORK, off, &error))
200 return error;
201
202 if (nmap != 1 || !xfs_bmap_is_written_extent(&map)) {
203 xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, off);
204 return 0;
205 }
206
207 /* Read a block's worth of ondisk rtsummary file. */
208 error = xfs_rtbuf_get(mp, sc->tp, off, 1, &bp);
209 if (!xchk_fblock_process_error(sc, XFS_DATA_FORK, off, &error))
210 return error;
211
212 /* Read a block's worth of computed rtsummary file. */
213 error = xfsum_copyout(sc, sumoff, sc->buf, mp->m_blockwsize);
214 if (error) {
215 xfs_trans_brelse(sc->tp, bp);
216 return error;
217 }
218
219 if (memcmp(bp->b_addr, sc->buf,
220 mp->m_blockwsize << XFS_WORDLOG) != 0)
221 xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, off);
222
223 xfs_trans_brelse(sc->tp, bp);
224 sumoff += mp->m_blockwsize;
225 }
226
227 return 0;
228 }
229
230 /* Scrub the realtime summary. */
231 int
xchk_rtsummary(struct xfs_scrub * sc)232 xchk_rtsummary(
233 struct xfs_scrub *sc)
234 {
235 struct xfs_mount *mp = sc->mp;
236 int error = 0;
237
238 /* Invoke the fork scrubber. */
239 error = xchk_metadata_inode_forks(sc);
240 if (error || (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT))
241 goto out_rbm;
242
243 /* Construct the new summary file from the rtbitmap. */
244 error = xchk_rtsum_compute(sc);
245 if (error == -EFSCORRUPTED) {
246 /*
247 * EFSCORRUPTED means the rtbitmap is corrupt, which is an xref
248 * error since we're checking the summary file.
249 */
250 xchk_ino_xref_set_corrupt(sc, mp->m_rbmip->i_ino);
251 error = 0;
252 goto out_rbm;
253 }
254 if (error)
255 goto out_rbm;
256
257 /* Does the computed summary file match the actual rtsummary file? */
258 error = xchk_rtsum_compare(sc);
259
260 out_rbm:
261 /* Unlock the rtbitmap since we're done with it. */
262 xfs_iunlock(mp->m_rbmip, XFS_ILOCK_SHARED | XFS_ILOCK_RTBITMAP);
263 return error;
264 }
265