1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Copyright (C) 2019 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_alloc.h" 13 #include "xfs_ialloc.h" 14 #include "xfs_health.h" 15 #include "xfs_btree.h" 16 #include "xfs_ag.h" 17 #include "scrub/scrub.h" 18 #include "scrub/common.h" 19 #include "scrub/trace.h" 20 21 /* 22 * FS Summary Counters 23 * =================== 24 * 25 * The basics of filesystem summary counter checking are that we iterate the 26 * AGs counting the number of free blocks, free space btree blocks, per-AG 27 * reservations, inodes, delayed allocation reservations, and free inodes. 28 * Then we compare what we computed against the in-core counters. 29 * 30 * However, the reality is that summary counters are a tricky beast to check. 31 * While we /could/ freeze the filesystem and scramble around the AGs counting 32 * the free blocks, in practice we prefer not do that for a scan because 33 * freezing is costly. To get around this, we added a per-cpu counter of the 34 * delalloc reservations so that we can rotor around the AGs relatively 35 * quickly, and we allow the counts to be slightly off because we're not taking 36 * any locks while we do this. 37 * 38 * So the first thing we do is warm up the buffer cache in the setup routine by 39 * walking all the AGs to make sure the incore per-AG structure has been 40 * initialized. The expected value calculation then iterates the incore per-AG 41 * structures as quickly as it can. We snapshot the percpu counters before and 42 * after this operation and use the difference in counter values to guess at 43 * our tolerance for mismatch between expected and actual counter values. 44 */ 45 46 /* 47 * Since the expected value computation is lockless but only browses incore 48 * values, the percpu counters should be fairly close to each other. However, 49 * we'll allow ourselves to be off by at least this (arbitrary) amount. 50 */ 51 #define XCHK_FSCOUNT_MIN_VARIANCE (512) 52 53 /* 54 * Make sure the per-AG structure has been initialized from the on-disk header 55 * contents and trust that the incore counters match the ondisk counters. (The 56 * AGF and AGI scrubbers check them, and a normal xfs_scrub run checks the 57 * summary counters after checking all AG headers). Do this from the setup 58 * function so that the inner AG aggregation loop runs as quickly as possible. 59 * 60 * This function runs during the setup phase /before/ we start checking any 61 * metadata. 62 */ 63 STATIC int 64 xchk_fscount_warmup( 65 struct xfs_scrub *sc) 66 { 67 struct xfs_mount *mp = sc->mp; 68 struct xfs_buf *agi_bp = NULL; 69 struct xfs_buf *agf_bp = NULL; 70 struct xfs_perag *pag = NULL; 71 xfs_agnumber_t agno; 72 int error = 0; 73 74 for_each_perag(mp, agno, pag) { 75 if (xchk_should_terminate(sc, &error)) 76 break; 77 if (pag->pagi_init && pag->pagf_init) 78 continue; 79 80 /* Lock both AG headers. */ 81 error = xfs_ialloc_read_agi(mp, sc->tp, agno, &agi_bp); 82 if (error) 83 break; 84 error = xfs_alloc_read_agf(mp, sc->tp, agno, 0, &agf_bp); 85 if (error) 86 break; 87 88 /* 89 * These are supposed to be initialized by the header read 90 * function. 91 */ 92 if (!pag->pagi_init || !pag->pagf_init) { 93 error = -EFSCORRUPTED; 94 break; 95 } 96 97 xfs_buf_relse(agf_bp); 98 agf_bp = NULL; 99 xfs_buf_relse(agi_bp); 100 agi_bp = NULL; 101 } 102 103 if (agf_bp) 104 xfs_buf_relse(agf_bp); 105 if (agi_bp) 106 xfs_buf_relse(agi_bp); 107 if (pag) 108 xfs_perag_put(pag); 109 return error; 110 } 111 112 int 113 xchk_setup_fscounters( 114 struct xfs_scrub *sc) 115 { 116 struct xchk_fscounters *fsc; 117 int error; 118 119 sc->buf = kmem_zalloc(sizeof(struct xchk_fscounters), 0); 120 if (!sc->buf) 121 return -ENOMEM; 122 fsc = sc->buf; 123 124 xfs_icount_range(sc->mp, &fsc->icount_min, &fsc->icount_max); 125 126 /* We must get the incore counters set up before we can proceed. */ 127 error = xchk_fscount_warmup(sc); 128 if (error) 129 return error; 130 131 /* 132 * Pause background reclaim while we're scrubbing to reduce the 133 * likelihood of background perturbations to the counters throwing off 134 * our calculations. 135 */ 136 xchk_stop_reaping(sc); 137 138 return xchk_trans_alloc(sc, 0); 139 } 140 141 /* Count free space btree blocks manually for pre-lazysbcount filesystems. */ 142 static int 143 xchk_fscount_btreeblks( 144 struct xfs_scrub *sc, 145 struct xchk_fscounters *fsc, 146 xfs_agnumber_t agno) 147 { 148 xfs_extlen_t blocks; 149 int error; 150 151 error = xchk_ag_init_existing(sc, agno, &sc->sa); 152 if (error) 153 goto out_free; 154 155 error = xfs_btree_count_blocks(sc->sa.bno_cur, &blocks); 156 if (error) 157 goto out_free; 158 fsc->fdblocks += blocks - 1; 159 160 error = xfs_btree_count_blocks(sc->sa.cnt_cur, &blocks); 161 if (error) 162 goto out_free; 163 fsc->fdblocks += blocks - 1; 164 165 out_free: 166 xchk_ag_free(sc, &sc->sa); 167 return error; 168 } 169 170 /* 171 * Calculate what the global in-core counters ought to be from the incore 172 * per-AG structure. Callers can compare this to the actual in-core counters 173 * to estimate by how much both in-core and on-disk counters need to be 174 * adjusted. 175 */ 176 STATIC int 177 xchk_fscount_aggregate_agcounts( 178 struct xfs_scrub *sc, 179 struct xchk_fscounters *fsc) 180 { 181 struct xfs_mount *mp = sc->mp; 182 struct xfs_perag *pag; 183 uint64_t delayed; 184 xfs_agnumber_t agno; 185 int tries = 8; 186 int error = 0; 187 188 retry: 189 fsc->icount = 0; 190 fsc->ifree = 0; 191 fsc->fdblocks = 0; 192 193 for_each_perag(mp, agno, pag) { 194 if (xchk_should_terminate(sc, &error)) 195 break; 196 197 /* This somehow got unset since the warmup? */ 198 if (!pag->pagi_init || !pag->pagf_init) { 199 error = -EFSCORRUPTED; 200 break; 201 } 202 203 /* Count all the inodes */ 204 fsc->icount += pag->pagi_count; 205 fsc->ifree += pag->pagi_freecount; 206 207 /* Add up the free/freelist/bnobt/cntbt blocks */ 208 fsc->fdblocks += pag->pagf_freeblks; 209 fsc->fdblocks += pag->pagf_flcount; 210 if (xfs_has_lazysbcount(sc->mp)) { 211 fsc->fdblocks += pag->pagf_btreeblks; 212 } else { 213 error = xchk_fscount_btreeblks(sc, fsc, agno); 214 if (error) 215 break; 216 } 217 218 /* 219 * Per-AG reservations are taken out of the incore counters, 220 * so they must be left out of the free blocks computation. 221 */ 222 fsc->fdblocks -= pag->pag_meta_resv.ar_reserved; 223 fsc->fdblocks -= pag->pag_rmapbt_resv.ar_orig_reserved; 224 225 } 226 if (pag) 227 xfs_perag_put(pag); 228 if (error) 229 return error; 230 231 /* 232 * The global incore space reservation is taken from the incore 233 * counters, so leave that out of the computation. 234 */ 235 fsc->fdblocks -= mp->m_resblks_avail; 236 237 /* 238 * Delayed allocation reservations are taken out of the incore counters 239 * but not recorded on disk, so leave them and their indlen blocks out 240 * of the computation. 241 */ 242 delayed = percpu_counter_sum(&mp->m_delalloc_blks); 243 fsc->fdblocks -= delayed; 244 245 trace_xchk_fscounters_calc(mp, fsc->icount, fsc->ifree, fsc->fdblocks, 246 delayed); 247 248 249 /* Bail out if the values we compute are totally nonsense. */ 250 if (fsc->icount < fsc->icount_min || fsc->icount > fsc->icount_max || 251 fsc->fdblocks > mp->m_sb.sb_dblocks || 252 fsc->ifree > fsc->icount_max) 253 return -EFSCORRUPTED; 254 255 /* 256 * If ifree > icount then we probably had some perturbation in the 257 * counters while we were calculating things. We'll try a few times 258 * to maintain ifree <= icount before giving up. 259 */ 260 if (fsc->ifree > fsc->icount) { 261 if (tries--) 262 goto retry; 263 xchk_set_incomplete(sc); 264 return 0; 265 } 266 267 return 0; 268 } 269 270 /* 271 * Is the @counter reasonably close to the @expected value? 272 * 273 * We neither locked nor froze anything in the filesystem while aggregating the 274 * per-AG data to compute the @expected value, which means that the counter 275 * could have changed. We know the @old_value of the summation of the counter 276 * before the aggregation, and we re-sum the counter now. If the expected 277 * value falls between the two summations, we're ok. 278 * 279 * Otherwise, we /might/ have a problem. If the change in the summations is 280 * more than we want to tolerate, the filesystem is probably busy and we should 281 * just send back INCOMPLETE and see if userspace will try again. 282 */ 283 static inline bool 284 xchk_fscount_within_range( 285 struct xfs_scrub *sc, 286 const int64_t old_value, 287 struct percpu_counter *counter, 288 uint64_t expected) 289 { 290 int64_t min_value, max_value; 291 int64_t curr_value = percpu_counter_sum(counter); 292 293 trace_xchk_fscounters_within_range(sc->mp, expected, curr_value, 294 old_value); 295 296 /* Negative values are always wrong. */ 297 if (curr_value < 0) 298 return false; 299 300 /* Exact matches are always ok. */ 301 if (curr_value == expected) 302 return true; 303 304 min_value = min(old_value, curr_value); 305 max_value = max(old_value, curr_value); 306 307 /* Within the before-and-after range is ok. */ 308 if (expected >= min_value && expected <= max_value) 309 return true; 310 311 /* 312 * If the difference between the two summations is too large, the fs 313 * might just be busy and so we'll mark the scrub incomplete. Return 314 * true here so that we don't mark the counter corrupt. 315 * 316 * XXX: In the future when userspace can grant scrub permission to 317 * quiesce the filesystem to solve the outsized variance problem, this 318 * check should be moved up and the return code changed to signal to 319 * userspace that we need quiesce permission. 320 */ 321 if (max_value - min_value >= XCHK_FSCOUNT_MIN_VARIANCE) { 322 xchk_set_incomplete(sc); 323 return true; 324 } 325 326 return false; 327 } 328 329 /* Check the superblock counters. */ 330 int 331 xchk_fscounters( 332 struct xfs_scrub *sc) 333 { 334 struct xfs_mount *mp = sc->mp; 335 struct xchk_fscounters *fsc = sc->buf; 336 int64_t icount, ifree, fdblocks; 337 int error; 338 339 /* Snapshot the percpu counters. */ 340 icount = percpu_counter_sum(&mp->m_icount); 341 ifree = percpu_counter_sum(&mp->m_ifree); 342 fdblocks = percpu_counter_sum(&mp->m_fdblocks); 343 344 /* No negative values, please! */ 345 if (icount < 0 || ifree < 0 || fdblocks < 0) 346 xchk_set_corrupt(sc); 347 348 /* See if icount is obviously wrong. */ 349 if (icount < fsc->icount_min || icount > fsc->icount_max) 350 xchk_set_corrupt(sc); 351 352 /* See if fdblocks is obviously wrong. */ 353 if (fdblocks > mp->m_sb.sb_dblocks) 354 xchk_set_corrupt(sc); 355 356 /* 357 * If ifree exceeds icount by more than the minimum variance then 358 * something's probably wrong with the counters. 359 */ 360 if (ifree > icount && ifree - icount > XCHK_FSCOUNT_MIN_VARIANCE) 361 xchk_set_corrupt(sc); 362 363 /* Walk the incore AG headers to calculate the expected counters. */ 364 error = xchk_fscount_aggregate_agcounts(sc, fsc); 365 if (!xchk_process_error(sc, 0, XFS_SB_BLOCK(mp), &error)) 366 return error; 367 if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_INCOMPLETE) 368 return 0; 369 370 /* Compare the in-core counters with whatever we counted. */ 371 if (!xchk_fscount_within_range(sc, icount, &mp->m_icount, fsc->icount)) 372 xchk_set_corrupt(sc); 373 374 if (!xchk_fscount_within_range(sc, ifree, &mp->m_ifree, fsc->ifree)) 375 xchk_set_corrupt(sc); 376 377 if (!xchk_fscount_within_range(sc, fdblocks, &mp->m_fdblocks, 378 fsc->fdblocks)) 379 xchk_set_corrupt(sc); 380 381 return 0; 382 } 383