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_defer.h"
13 #include "xfs_btree.h"
14 #include "xfs_bit.h"
15 #include "xfs_log_format.h"
16 #include "xfs_trans.h"
17 #include "xfs_sb.h"
18 #include "xfs_inode.h"
19 #include "xfs_alloc.h"
20 #include "xfs_ialloc.h"
21 #include "xfs_ialloc_btree.h"
22 #include "xfs_icache.h"
23 #include "xfs_rmap.h"
24 #include "xfs_log.h"
25 #include "xfs_trans_priv.h"
26 #include "scrub/xfs_scrub.h"
27 #include "scrub/scrub.h"
28 #include "scrub/common.h"
29 #include "scrub/btree.h"
30 #include "scrub/trace.h"
31 
32 /*
33  * Set us up to scrub inode btrees.
34  * If we detect a discrepancy between the inobt and the inode,
35  * try again after forcing logged inode cores out to disk.
36  */
37 int
xchk_setup_ag_iallocbt(struct xfs_scrub * sc,struct xfs_inode * ip)38 xchk_setup_ag_iallocbt(
39 	struct xfs_scrub	*sc,
40 	struct xfs_inode	*ip)
41 {
42 	return xchk_setup_ag_btree(sc, ip, sc->try_harder);
43 }
44 
45 /* Inode btree scrubber. */
46 
47 /*
48  * If we're checking the finobt, cross-reference with the inobt.
49  * Otherwise we're checking the inobt; if there is an finobt, make sure
50  * we have a record or not depending on freecount.
51  */
52 static inline void
xchk_iallocbt_chunk_xref_other(struct xfs_scrub * sc,struct xfs_inobt_rec_incore * irec,xfs_agino_t agino)53 xchk_iallocbt_chunk_xref_other(
54 	struct xfs_scrub		*sc,
55 	struct xfs_inobt_rec_incore	*irec,
56 	xfs_agino_t			agino)
57 {
58 	struct xfs_btree_cur		**pcur;
59 	bool				has_irec;
60 	int				error;
61 
62 	if (sc->sm->sm_type == XFS_SCRUB_TYPE_FINOBT)
63 		pcur = &sc->sa.ino_cur;
64 	else
65 		pcur = &sc->sa.fino_cur;
66 	if (!(*pcur))
67 		return;
68 	error = xfs_ialloc_has_inode_record(*pcur, agino, agino, &has_irec);
69 	if (!xchk_should_check_xref(sc, &error, pcur))
70 		return;
71 	if (((irec->ir_freecount > 0 && !has_irec) ||
72 	     (irec->ir_freecount == 0 && has_irec)))
73 		xchk_btree_xref_set_corrupt(sc, *pcur, 0);
74 }
75 
76 /* Cross-reference with the other btrees. */
77 STATIC void
xchk_iallocbt_chunk_xref(struct xfs_scrub * sc,struct xfs_inobt_rec_incore * irec,xfs_agino_t agino,xfs_agblock_t agbno,xfs_extlen_t len)78 xchk_iallocbt_chunk_xref(
79 	struct xfs_scrub		*sc,
80 	struct xfs_inobt_rec_incore	*irec,
81 	xfs_agino_t			agino,
82 	xfs_agblock_t			agbno,
83 	xfs_extlen_t			len)
84 {
85 	struct xfs_owner_info		oinfo;
86 
87 	if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
88 		return;
89 
90 	xchk_xref_is_used_space(sc, agbno, len);
91 	xchk_iallocbt_chunk_xref_other(sc, irec, agino);
92 	xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_INODES);
93 	xchk_xref_is_owned_by(sc, agbno, len, &oinfo);
94 	xchk_xref_is_not_shared(sc, agbno, len);
95 }
96 
97 /* Is this chunk worth checking? */
98 STATIC bool
xchk_iallocbt_chunk(struct xchk_btree * bs,struct xfs_inobt_rec_incore * irec,xfs_agino_t agino,xfs_extlen_t len)99 xchk_iallocbt_chunk(
100 	struct xchk_btree		*bs,
101 	struct xfs_inobt_rec_incore	*irec,
102 	xfs_agino_t			agino,
103 	xfs_extlen_t			len)
104 {
105 	struct xfs_mount		*mp = bs->cur->bc_mp;
106 	xfs_agnumber_t			agno = bs->cur->bc_private.a.agno;
107 	xfs_agblock_t			bno;
108 
109 	bno = XFS_AGINO_TO_AGBNO(mp, agino);
110 	if (bno + len <= bno ||
111 	    !xfs_verify_agbno(mp, agno, bno) ||
112 	    !xfs_verify_agbno(mp, agno, bno + len - 1))
113 		xchk_btree_set_corrupt(bs->sc, bs->cur, 0);
114 
115 	xchk_iallocbt_chunk_xref(bs->sc, irec, agino, bno, len);
116 
117 	return true;
118 }
119 
120 /* Count the number of free inodes. */
121 static unsigned int
xchk_iallocbt_freecount(xfs_inofree_t freemask)122 xchk_iallocbt_freecount(
123 	xfs_inofree_t			freemask)
124 {
125 	BUILD_BUG_ON(sizeof(freemask) != sizeof(__u64));
126 	return hweight64(freemask);
127 }
128 
129 /* Check a particular inode with ir_free. */
130 STATIC int
xchk_iallocbt_check_cluster_freemask(struct xchk_btree * bs,xfs_ino_t fsino,xfs_agino_t chunkino,xfs_agino_t clusterino,struct xfs_inobt_rec_incore * irec,struct xfs_buf * bp)131 xchk_iallocbt_check_cluster_freemask(
132 	struct xchk_btree		*bs,
133 	xfs_ino_t			fsino,
134 	xfs_agino_t			chunkino,
135 	xfs_agino_t			clusterino,
136 	struct xfs_inobt_rec_incore	*irec,
137 	struct xfs_buf			*bp)
138 {
139 	struct xfs_dinode		*dip;
140 	struct xfs_mount		*mp = bs->cur->bc_mp;
141 	bool				inode_is_free = false;
142 	bool				freemask_ok;
143 	bool				inuse;
144 	int				error = 0;
145 
146 	if (xchk_should_terminate(bs->sc, &error))
147 		return error;
148 
149 	dip = xfs_buf_offset(bp, clusterino * mp->m_sb.sb_inodesize);
150 	if (be16_to_cpu(dip->di_magic) != XFS_DINODE_MAGIC ||
151 	    (dip->di_version >= 3 &&
152 	     be64_to_cpu(dip->di_ino) != fsino + clusterino)) {
153 		xchk_btree_set_corrupt(bs->sc, bs->cur, 0);
154 		goto out;
155 	}
156 
157 	if (irec->ir_free & XFS_INOBT_MASK(chunkino + clusterino))
158 		inode_is_free = true;
159 	error = xfs_icache_inode_is_allocated(mp, bs->cur->bc_tp,
160 			fsino + clusterino, &inuse);
161 	if (error == -ENODATA) {
162 		/* Not cached, just read the disk buffer */
163 		freemask_ok = inode_is_free ^ !!(dip->di_mode);
164 		if (!bs->sc->try_harder && !freemask_ok)
165 			return -EDEADLOCK;
166 	} else if (error < 0) {
167 		/*
168 		 * Inode is only half assembled, or there was an IO error,
169 		 * or the verifier failed, so don't bother trying to check.
170 		 * The inode scrubber can deal with this.
171 		 */
172 		goto out;
173 	} else {
174 		/* Inode is all there. */
175 		freemask_ok = inode_is_free ^ inuse;
176 	}
177 	if (!freemask_ok)
178 		xchk_btree_set_corrupt(bs->sc, bs->cur, 0);
179 out:
180 	return 0;
181 }
182 
183 /* Make sure the free mask is consistent with what the inodes think. */
184 STATIC int
xchk_iallocbt_check_freemask(struct xchk_btree * bs,struct xfs_inobt_rec_incore * irec)185 xchk_iallocbt_check_freemask(
186 	struct xchk_btree		*bs,
187 	struct xfs_inobt_rec_incore	*irec)
188 {
189 	struct xfs_owner_info		oinfo;
190 	struct xfs_imap			imap;
191 	struct xfs_mount		*mp = bs->cur->bc_mp;
192 	struct xfs_dinode		*dip;
193 	struct xfs_buf			*bp;
194 	xfs_ino_t			fsino;
195 	xfs_agino_t			nr_inodes;
196 	xfs_agino_t			agino;
197 	xfs_agino_t			chunkino;
198 	xfs_agino_t			clusterino;
199 	xfs_agblock_t			agbno;
200 	int				blks_per_cluster;
201 	uint16_t			holemask;
202 	uint16_t			ir_holemask;
203 	int				error = 0;
204 
205 	/* Make sure the freemask matches the inode records. */
206 	blks_per_cluster = xfs_icluster_size_fsb(mp);
207 	nr_inodes = XFS_OFFBNO_TO_AGINO(mp, blks_per_cluster, 0);
208 	xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_INODES);
209 
210 	for (agino = irec->ir_startino;
211 	     agino < irec->ir_startino + XFS_INODES_PER_CHUNK;
212 	     agino += blks_per_cluster * mp->m_sb.sb_inopblock) {
213 		fsino = XFS_AGINO_TO_INO(mp, bs->cur->bc_private.a.agno, agino);
214 		chunkino = agino - irec->ir_startino;
215 		agbno = XFS_AGINO_TO_AGBNO(mp, agino);
216 
217 		/* Compute the holemask mask for this cluster. */
218 		for (clusterino = 0, holemask = 0; clusterino < nr_inodes;
219 		     clusterino += XFS_INODES_PER_HOLEMASK_BIT)
220 			holemask |= XFS_INOBT_MASK((chunkino + clusterino) /
221 					XFS_INODES_PER_HOLEMASK_BIT);
222 
223 		/* The whole cluster must be a hole or not a hole. */
224 		ir_holemask = (irec->ir_holemask & holemask);
225 		if (ir_holemask != holemask && ir_holemask != 0) {
226 			xchk_btree_set_corrupt(bs->sc, bs->cur, 0);
227 			continue;
228 		}
229 
230 		/* If any part of this is a hole, skip it. */
231 		if (ir_holemask) {
232 			xchk_xref_is_not_owned_by(bs->sc, agbno,
233 					blks_per_cluster, &oinfo);
234 			continue;
235 		}
236 
237 		xchk_xref_is_owned_by(bs->sc, agbno, blks_per_cluster,
238 				&oinfo);
239 
240 		/* Grab the inode cluster buffer. */
241 		imap.im_blkno = XFS_AGB_TO_DADDR(mp, bs->cur->bc_private.a.agno,
242 				agbno);
243 		imap.im_len = XFS_FSB_TO_BB(mp, blks_per_cluster);
244 		imap.im_boffset = 0;
245 
246 		error = xfs_imap_to_bp(mp, bs->cur->bc_tp, &imap,
247 				&dip, &bp, 0, 0);
248 		if (!xchk_btree_xref_process_error(bs->sc, bs->cur, 0,
249 				&error))
250 			continue;
251 
252 		/* Which inodes are free? */
253 		for (clusterino = 0; clusterino < nr_inodes; clusterino++) {
254 			error = xchk_iallocbt_check_cluster_freemask(bs,
255 					fsino, chunkino, clusterino, irec, bp);
256 			if (error) {
257 				xfs_trans_brelse(bs->cur->bc_tp, bp);
258 				return error;
259 			}
260 		}
261 
262 		xfs_trans_brelse(bs->cur->bc_tp, bp);
263 	}
264 
265 	return error;
266 }
267 
268 /* Scrub an inobt/finobt record. */
269 STATIC int
xchk_iallocbt_rec(struct xchk_btree * bs,union xfs_btree_rec * rec)270 xchk_iallocbt_rec(
271 	struct xchk_btree		*bs,
272 	union xfs_btree_rec		*rec)
273 {
274 	struct xfs_mount		*mp = bs->cur->bc_mp;
275 	xfs_filblks_t			*inode_blocks = bs->private;
276 	struct xfs_inobt_rec_incore	irec;
277 	uint64_t			holes;
278 	xfs_agnumber_t			agno = bs->cur->bc_private.a.agno;
279 	xfs_agino_t			agino;
280 	xfs_agblock_t			agbno;
281 	xfs_extlen_t			len;
282 	int				holecount;
283 	int				i;
284 	int				error = 0;
285 	unsigned int			real_freecount;
286 	uint16_t			holemask;
287 
288 	xfs_inobt_btrec_to_irec(mp, rec, &irec);
289 
290 	if (irec.ir_count > XFS_INODES_PER_CHUNK ||
291 	    irec.ir_freecount > XFS_INODES_PER_CHUNK)
292 		xchk_btree_set_corrupt(bs->sc, bs->cur, 0);
293 
294 	real_freecount = irec.ir_freecount +
295 			(XFS_INODES_PER_CHUNK - irec.ir_count);
296 	if (real_freecount != xchk_iallocbt_freecount(irec.ir_free))
297 		xchk_btree_set_corrupt(bs->sc, bs->cur, 0);
298 
299 	agino = irec.ir_startino;
300 	/* Record has to be properly aligned within the AG. */
301 	if (!xfs_verify_agino(mp, agno, agino) ||
302 	    !xfs_verify_agino(mp, agno, agino + XFS_INODES_PER_CHUNK - 1)) {
303 		xchk_btree_set_corrupt(bs->sc, bs->cur, 0);
304 		goto out;
305 	}
306 
307 	/* Make sure this record is aligned to cluster and inoalignmnt size. */
308 	agbno = XFS_AGINO_TO_AGBNO(mp, irec.ir_startino);
309 	if ((agbno & (xfs_ialloc_cluster_alignment(mp) - 1)) ||
310 	    (agbno & (xfs_icluster_size_fsb(mp) - 1)))
311 		xchk_btree_set_corrupt(bs->sc, bs->cur, 0);
312 
313 	*inode_blocks += XFS_B_TO_FSB(mp,
314 			irec.ir_count * mp->m_sb.sb_inodesize);
315 
316 	/* Handle non-sparse inodes */
317 	if (!xfs_inobt_issparse(irec.ir_holemask)) {
318 		len = XFS_B_TO_FSB(mp,
319 				XFS_INODES_PER_CHUNK * mp->m_sb.sb_inodesize);
320 		if (irec.ir_count != XFS_INODES_PER_CHUNK)
321 			xchk_btree_set_corrupt(bs->sc, bs->cur, 0);
322 
323 		if (!xchk_iallocbt_chunk(bs, &irec, agino, len))
324 			goto out;
325 		goto check_freemask;
326 	}
327 
328 	/* Check each chunk of a sparse inode cluster. */
329 	holemask = irec.ir_holemask;
330 	holecount = 0;
331 	len = XFS_B_TO_FSB(mp,
332 			XFS_INODES_PER_HOLEMASK_BIT * mp->m_sb.sb_inodesize);
333 	holes = ~xfs_inobt_irec_to_allocmask(&irec);
334 	if ((holes & irec.ir_free) != holes ||
335 	    irec.ir_freecount > irec.ir_count)
336 		xchk_btree_set_corrupt(bs->sc, bs->cur, 0);
337 
338 	for (i = 0; i < XFS_INOBT_HOLEMASK_BITS; i++) {
339 		if (holemask & 1)
340 			holecount += XFS_INODES_PER_HOLEMASK_BIT;
341 		else if (!xchk_iallocbt_chunk(bs, &irec, agino, len))
342 			break;
343 		holemask >>= 1;
344 		agino += XFS_INODES_PER_HOLEMASK_BIT;
345 	}
346 
347 	if (holecount > XFS_INODES_PER_CHUNK ||
348 	    holecount + irec.ir_count != XFS_INODES_PER_CHUNK)
349 		xchk_btree_set_corrupt(bs->sc, bs->cur, 0);
350 
351 check_freemask:
352 	error = xchk_iallocbt_check_freemask(bs, &irec);
353 	if (error)
354 		goto out;
355 
356 out:
357 	return error;
358 }
359 
360 /*
361  * Make sure the inode btrees are as large as the rmap thinks they are.
362  * Don't bother if we're missing btree cursors, as we're already corrupt.
363  */
364 STATIC void
xchk_iallocbt_xref_rmap_btreeblks(struct xfs_scrub * sc,int which)365 xchk_iallocbt_xref_rmap_btreeblks(
366 	struct xfs_scrub	*sc,
367 	int			which)
368 {
369 	struct xfs_owner_info	oinfo;
370 	xfs_filblks_t		blocks;
371 	xfs_extlen_t		inobt_blocks = 0;
372 	xfs_extlen_t		finobt_blocks = 0;
373 	int			error;
374 
375 	if (!sc->sa.ino_cur || !sc->sa.rmap_cur ||
376 	    (xfs_sb_version_hasfinobt(&sc->mp->m_sb) && !sc->sa.fino_cur) ||
377 	    xchk_skip_xref(sc->sm))
378 		return;
379 
380 	/* Check that we saw as many inobt blocks as the rmap says. */
381 	error = xfs_btree_count_blocks(sc->sa.ino_cur, &inobt_blocks);
382 	if (!xchk_process_error(sc, 0, 0, &error))
383 		return;
384 
385 	if (sc->sa.fino_cur) {
386 		error = xfs_btree_count_blocks(sc->sa.fino_cur, &finobt_blocks);
387 		if (!xchk_process_error(sc, 0, 0, &error))
388 			return;
389 	}
390 
391 	xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_INOBT);
392 	error = xchk_count_rmap_ownedby_ag(sc, sc->sa.rmap_cur, &oinfo,
393 			&blocks);
394 	if (!xchk_should_check_xref(sc, &error, &sc->sa.rmap_cur))
395 		return;
396 	if (blocks != inobt_blocks + finobt_blocks)
397 		xchk_btree_set_corrupt(sc, sc->sa.ino_cur, 0);
398 }
399 
400 /*
401  * Make sure that the inobt records point to the same number of blocks as
402  * the rmap says are owned by inodes.
403  */
404 STATIC void
xchk_iallocbt_xref_rmap_inodes(struct xfs_scrub * sc,int which,xfs_filblks_t inode_blocks)405 xchk_iallocbt_xref_rmap_inodes(
406 	struct xfs_scrub	*sc,
407 	int			which,
408 	xfs_filblks_t		inode_blocks)
409 {
410 	struct xfs_owner_info	oinfo;
411 	xfs_filblks_t		blocks;
412 	int			error;
413 
414 	if (!sc->sa.rmap_cur || xchk_skip_xref(sc->sm))
415 		return;
416 
417 	/* Check that we saw as many inode blocks as the rmap knows about. */
418 	xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_INODES);
419 	error = xchk_count_rmap_ownedby_ag(sc, sc->sa.rmap_cur, &oinfo,
420 			&blocks);
421 	if (!xchk_should_check_xref(sc, &error, &sc->sa.rmap_cur))
422 		return;
423 	if (blocks != inode_blocks)
424 		xchk_btree_xref_set_corrupt(sc, sc->sa.rmap_cur, 0);
425 }
426 
427 /* Scrub the inode btrees for some AG. */
428 STATIC int
xchk_iallocbt(struct xfs_scrub * sc,xfs_btnum_t which)429 xchk_iallocbt(
430 	struct xfs_scrub	*sc,
431 	xfs_btnum_t		which)
432 {
433 	struct xfs_btree_cur	*cur;
434 	struct xfs_owner_info	oinfo;
435 	xfs_filblks_t		inode_blocks = 0;
436 	int			error;
437 
438 	xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_INOBT);
439 	cur = which == XFS_BTNUM_INO ? sc->sa.ino_cur : sc->sa.fino_cur;
440 	error = xchk_btree(sc, cur, xchk_iallocbt_rec, &oinfo,
441 			&inode_blocks);
442 	if (error)
443 		return error;
444 
445 	xchk_iallocbt_xref_rmap_btreeblks(sc, which);
446 
447 	/*
448 	 * If we're scrubbing the inode btree, inode_blocks is the number of
449 	 * blocks pointed to by all the inode chunk records.  Therefore, we
450 	 * should compare to the number of inode chunk blocks that the rmap
451 	 * knows about.  We can't do this for the finobt since it only points
452 	 * to inode chunks with free inodes.
453 	 */
454 	if (which == XFS_BTNUM_INO)
455 		xchk_iallocbt_xref_rmap_inodes(sc, which, inode_blocks);
456 
457 	return error;
458 }
459 
460 int
xchk_inobt(struct xfs_scrub * sc)461 xchk_inobt(
462 	struct xfs_scrub	*sc)
463 {
464 	return xchk_iallocbt(sc, XFS_BTNUM_INO);
465 }
466 
467 int
xchk_finobt(struct xfs_scrub * sc)468 xchk_finobt(
469 	struct xfs_scrub	*sc)
470 {
471 	return xchk_iallocbt(sc, XFS_BTNUM_FINO);
472 }
473 
474 /* See if an inode btree has (or doesn't have) an inode chunk record. */
475 static inline void
xchk_xref_inode_check(struct xfs_scrub * sc,xfs_agblock_t agbno,xfs_extlen_t len,struct xfs_btree_cur ** icur,bool should_have_inodes)476 xchk_xref_inode_check(
477 	struct xfs_scrub	*sc,
478 	xfs_agblock_t		agbno,
479 	xfs_extlen_t		len,
480 	struct xfs_btree_cur	**icur,
481 	bool			should_have_inodes)
482 {
483 	bool			has_inodes;
484 	int			error;
485 
486 	if (!(*icur) || xchk_skip_xref(sc->sm))
487 		return;
488 
489 	error = xfs_ialloc_has_inodes_at_extent(*icur, agbno, len, &has_inodes);
490 	if (!xchk_should_check_xref(sc, &error, icur))
491 		return;
492 	if (has_inodes != should_have_inodes)
493 		xchk_btree_xref_set_corrupt(sc, *icur, 0);
494 }
495 
496 /* xref check that the extent is not covered by inodes */
497 void
xchk_xref_is_not_inode_chunk(struct xfs_scrub * sc,xfs_agblock_t agbno,xfs_extlen_t len)498 xchk_xref_is_not_inode_chunk(
499 	struct xfs_scrub	*sc,
500 	xfs_agblock_t		agbno,
501 	xfs_extlen_t		len)
502 {
503 	xchk_xref_inode_check(sc, agbno, len, &sc->sa.ino_cur, false);
504 	xchk_xref_inode_check(sc, agbno, len, &sc->sa.fino_cur, false);
505 }
506 
507 /* xref check that the extent is covered by inodes */
508 void
xchk_xref_is_inode_chunk(struct xfs_scrub * sc,xfs_agblock_t agbno,xfs_extlen_t len)509 xchk_xref_is_inode_chunk(
510 	struct xfs_scrub	*sc,
511 	xfs_agblock_t		agbno,
512 	xfs_extlen_t		len)
513 {
514 	xchk_xref_inode_check(sc, agbno, len, &sc->sa.ino_cur, true);
515 }
516