fs/xfs/scrub/agheader.c

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
xchk_superblock_xref
xchk_superblock
xchk_agf_record_bno_lengths
xchk_agf_xref_freeblks
xchk_agf_xref_cntbt
xchk_agf_xref_btreeblks
xchk_agf_xref_refcblks
xchk_agf_xref
xchk_agf
xchk_agfl_block_xref
xchk_agfl_block
xchk_agblock_cmp
xchk_agfl_xref
xchk_agfl
xchk_agi_xref_icounts
xchk_agi_xref
xchk_agi
   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_btree.h"
  13 #include "xfs_sb.h"
  14 #include "xfs_alloc.h"
  15 #include "xfs_ialloc.h"
  16 #include "xfs_rmap.h"
  17 #include "scrub/scrub.h"
  18 #include "scrub/common.h"
  19 
  20 /* Superblock */
  21 
  22 /* Cross-reference with the other btrees. */
  23 STATIC void
  24 xchk_superblock_xref(
  25         struct xfs_scrub        *sc,
  26         struct xfs_buf          *bp)
  27 {
  28         struct xfs_mount        *mp = sc->mp;
  29         xfs_agnumber_t          agno = sc->sm->sm_agno;
  30         xfs_agblock_t           agbno;
  31         int                     error;
  32 
  33         if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
  34                 return;
  35 
  36         agbno = XFS_SB_BLOCK(mp);
  37 
  38         error = xchk_ag_init(sc, agno, &sc->sa);
  39         if (!xchk_xref_process_error(sc, agno, agbno, &error))
  40                 return;
  41 
  42         xchk_xref_is_used_space(sc, agbno, 1);
  43         xchk_xref_is_not_inode_chunk(sc, agbno, 1);
  44         xchk_xref_is_owned_by(sc, agbno, 1, &XFS_RMAP_OINFO_FS);
  45         xchk_xref_is_not_shared(sc, agbno, 1);
  46 
  47         /* scrub teardown will take care of sc->sa for us */
  48 }
  49 
  50 /*
  51  * Scrub the filesystem superblock.
  52  *
  53  * Note: We do /not/ attempt to check AG 0's superblock.  Mount is
  54  * responsible for validating all the geometry information in sb 0, so
  55  * if the filesystem is capable of initiating online scrub, then clearly
  56  * sb 0 is ok and we can use its information to check everything else.
  57  */
  58 int
  59 xchk_superblock(
  60         struct xfs_scrub        *sc)
  61 {
  62         struct xfs_mount        *mp = sc->mp;
  63         struct xfs_buf          *bp;
  64         struct xfs_dsb          *sb;
  65         xfs_agnumber_t          agno;
  66         uint32_t                v2_ok;
  67         __be32                  features_mask;
  68         int                     error;
  69         __be16                  vernum_mask;
  70 
  71         agno = sc->sm->sm_agno;
  72         if (agno == 0)
  73                 return 0;
  74 
  75         error = xfs_sb_read_secondary(mp, sc->tp, agno, &bp);
  76         /*
  77          * The superblock verifier can return several different error codes
  78          * if it thinks the superblock doesn't look right.  For a mount these
  79          * would all get bounced back to userspace, but if we're here then the
  80          * fs mounted successfully, which means that this secondary superblock
  81          * is simply incorrect.  Treat all these codes the same way we treat
  82          * any corruption.
  83          */
  84         switch (error) {
  85         case -EINVAL:   /* also -EWRONGFS */
  86         case -ENOSYS:
  87         case -EFBIG:
  88                 error = -EFSCORRUPTED;
  89         default:
  90                 break;
  91         }
  92         if (!xchk_process_error(sc, agno, XFS_SB_BLOCK(mp), &error))
  93                 return error;
  94 
  95         sb = XFS_BUF_TO_SBP(bp);
  96 
  97         /*
  98          * Verify the geometries match.  Fields that are permanently
  99          * set by mkfs are checked; fields that can be updated later
 100          * (and are not propagated to backup superblocks) are preen
 101          * checked.
 102          */
 103         if (sb->sb_blocksize != cpu_to_be32(mp->m_sb.sb_blocksize))
 104                 xchk_block_set_corrupt(sc, bp);
 105 
 106         if (sb->sb_dblocks != cpu_to_be64(mp->m_sb.sb_dblocks))
 107                 xchk_block_set_corrupt(sc, bp);
 108 
 109         if (sb->sb_rblocks != cpu_to_be64(mp->m_sb.sb_rblocks))
 110                 xchk_block_set_corrupt(sc, bp);
 111 
 112         if (sb->sb_rextents != cpu_to_be64(mp->m_sb.sb_rextents))
 113                 xchk_block_set_corrupt(sc, bp);
 114 
 115         if (!uuid_equal(&sb->sb_uuid, &mp->m_sb.sb_uuid))
 116                 xchk_block_set_preen(sc, bp);
 117 
 118         if (sb->sb_logstart != cpu_to_be64(mp->m_sb.sb_logstart))
 119                 xchk_block_set_corrupt(sc, bp);
 120 
 121         if (sb->sb_rootino != cpu_to_be64(mp->m_sb.sb_rootino))
 122                 xchk_block_set_preen(sc, bp);
 123 
 124         if (sb->sb_rbmino != cpu_to_be64(mp->m_sb.sb_rbmino))
 125                 xchk_block_set_preen(sc, bp);
 126 
 127         if (sb->sb_rsumino != cpu_to_be64(mp->m_sb.sb_rsumino))
 128                 xchk_block_set_preen(sc, bp);
 129 
 130         if (sb->sb_rextsize != cpu_to_be32(mp->m_sb.sb_rextsize))
 131                 xchk_block_set_corrupt(sc, bp);
 132 
 133         if (sb->sb_agblocks != cpu_to_be32(mp->m_sb.sb_agblocks))
 134                 xchk_block_set_corrupt(sc, bp);
 135 
 136         if (sb->sb_agcount != cpu_to_be32(mp->m_sb.sb_agcount))
 137                 xchk_block_set_corrupt(sc, bp);
 138 
 139         if (sb->sb_rbmblocks != cpu_to_be32(mp->m_sb.sb_rbmblocks))
 140                 xchk_block_set_corrupt(sc, bp);
 141 
 142         if (sb->sb_logblocks != cpu_to_be32(mp->m_sb.sb_logblocks))
 143                 xchk_block_set_corrupt(sc, bp);
 144 
 145         /* Check sb_versionnum bits that are set at mkfs time. */
 146         vernum_mask = cpu_to_be16(~XFS_SB_VERSION_OKBITS |
 147                                   XFS_SB_VERSION_NUMBITS |
 148                                   XFS_SB_VERSION_ALIGNBIT |
 149                                   XFS_SB_VERSION_DALIGNBIT |
 150                                   XFS_SB_VERSION_SHAREDBIT |
 151                                   XFS_SB_VERSION_LOGV2BIT |
 152                                   XFS_SB_VERSION_SECTORBIT |
 153                                   XFS_SB_VERSION_EXTFLGBIT |
 154                                   XFS_SB_VERSION_DIRV2BIT);
 155         if ((sb->sb_versionnum & vernum_mask) !=
 156             (cpu_to_be16(mp->m_sb.sb_versionnum) & vernum_mask))
 157                 xchk_block_set_corrupt(sc, bp);
 158 
 159         /* Check sb_versionnum bits that can be set after mkfs time. */
 160         vernum_mask = cpu_to_be16(XFS_SB_VERSION_ATTRBIT |
 161                                   XFS_SB_VERSION_NLINKBIT |
 162                                   XFS_SB_VERSION_QUOTABIT);
 163         if ((sb->sb_versionnum & vernum_mask) !=
 164             (cpu_to_be16(mp->m_sb.sb_versionnum) & vernum_mask))
 165                 xchk_block_set_preen(sc, bp);
 166 
 167         if (sb->sb_sectsize != cpu_to_be16(mp->m_sb.sb_sectsize))
 168                 xchk_block_set_corrupt(sc, bp);
 169 
 170         if (sb->sb_inodesize != cpu_to_be16(mp->m_sb.sb_inodesize))
 171                 xchk_block_set_corrupt(sc, bp);
 172 
 173         if (sb->sb_inopblock != cpu_to_be16(mp->m_sb.sb_inopblock))
 174                 xchk_block_set_corrupt(sc, bp);
 175 
 176         if (memcmp(sb->sb_fname, mp->m_sb.sb_fname, sizeof(sb->sb_fname)))
 177                 xchk_block_set_preen(sc, bp);
 178 
 179         if (sb->sb_blocklog != mp->m_sb.sb_blocklog)
 180                 xchk_block_set_corrupt(sc, bp);
 181 
 182         if (sb->sb_sectlog != mp->m_sb.sb_sectlog)
 183                 xchk_block_set_corrupt(sc, bp);
 184 
 185         if (sb->sb_inodelog != mp->m_sb.sb_inodelog)
 186                 xchk_block_set_corrupt(sc, bp);
 187 
 188         if (sb->sb_inopblog != mp->m_sb.sb_inopblog)
 189                 xchk_block_set_corrupt(sc, bp);
 190 
 191         if (sb->sb_agblklog != mp->m_sb.sb_agblklog)
 192                 xchk_block_set_corrupt(sc, bp);
 193 
 194         if (sb->sb_rextslog != mp->m_sb.sb_rextslog)
 195                 xchk_block_set_corrupt(sc, bp);
 196 
 197         if (sb->sb_imax_pct != mp->m_sb.sb_imax_pct)
 198                 xchk_block_set_preen(sc, bp);
 199 
 200         /*
 201          * Skip the summary counters since we track them in memory anyway.
 202          * sb_icount, sb_ifree, sb_fdblocks, sb_frexents
 203          */
 204 
 205         if (sb->sb_uquotino != cpu_to_be64(mp->m_sb.sb_uquotino))
 206                 xchk_block_set_preen(sc, bp);
 207 
 208         if (sb->sb_gquotino != cpu_to_be64(mp->m_sb.sb_gquotino))
 209                 xchk_block_set_preen(sc, bp);
 210 
 211         /*
 212          * Skip the quota flags since repair will force quotacheck.
 213          * sb_qflags
 214          */
 215 
 216         if (sb->sb_flags != mp->m_sb.sb_flags)
 217                 xchk_block_set_corrupt(sc, bp);
 218 
 219         if (sb->sb_shared_vn != mp->m_sb.sb_shared_vn)
 220                 xchk_block_set_corrupt(sc, bp);
 221 
 222         if (sb->sb_inoalignmt != cpu_to_be32(mp->m_sb.sb_inoalignmt))
 223                 xchk_block_set_corrupt(sc, bp);
 224 
 225         if (sb->sb_unit != cpu_to_be32(mp->m_sb.sb_unit))
 226                 xchk_block_set_preen(sc, bp);
 227 
 228         if (sb->sb_width != cpu_to_be32(mp->m_sb.sb_width))
 229                 xchk_block_set_preen(sc, bp);
 230 
 231         if (sb->sb_dirblklog != mp->m_sb.sb_dirblklog)
 232                 xchk_block_set_corrupt(sc, bp);
 233 
 234         if (sb->sb_logsectlog != mp->m_sb.sb_logsectlog)
 235                 xchk_block_set_corrupt(sc, bp);
 236 
 237         if (sb->sb_logsectsize != cpu_to_be16(mp->m_sb.sb_logsectsize))
 238                 xchk_block_set_corrupt(sc, bp);
 239 
 240         if (sb->sb_logsunit != cpu_to_be32(mp->m_sb.sb_logsunit))
 241                 xchk_block_set_corrupt(sc, bp);
 242 
 243         /* Do we see any invalid bits in sb_features2? */
 244         if (!xfs_sb_version_hasmorebits(&mp->m_sb)) {
 245                 if (sb->sb_features2 != 0)
 246                         xchk_block_set_corrupt(sc, bp);
 247         } else {
 248                 v2_ok = XFS_SB_VERSION2_OKBITS;
 249                 if (XFS_SB_VERSION_NUM(&mp->m_sb) >= XFS_SB_VERSION_5)
 250                         v2_ok |= XFS_SB_VERSION2_CRCBIT;
 251 
 252                 if (!!(sb->sb_features2 & cpu_to_be32(~v2_ok)))
 253                         xchk_block_set_corrupt(sc, bp);
 254 
 255                 if (sb->sb_features2 != sb->sb_bad_features2)
 256                         xchk_block_set_preen(sc, bp);
 257         }
 258 
 259         /* Check sb_features2 flags that are set at mkfs time. */
 260         features_mask = cpu_to_be32(XFS_SB_VERSION2_LAZYSBCOUNTBIT |
 261                                     XFS_SB_VERSION2_PROJID32BIT |
 262                                     XFS_SB_VERSION2_CRCBIT |
 263                                     XFS_SB_VERSION2_FTYPE);
 264         if ((sb->sb_features2 & features_mask) !=
 265             (cpu_to_be32(mp->m_sb.sb_features2) & features_mask))
 266                 xchk_block_set_corrupt(sc, bp);
 267 
 268         /* Check sb_features2 flags that can be set after mkfs time. */
 269         features_mask = cpu_to_be32(XFS_SB_VERSION2_ATTR2BIT);
 270         if ((sb->sb_features2 & features_mask) !=
 271             (cpu_to_be32(mp->m_sb.sb_features2) & features_mask))
 272                 xchk_block_set_corrupt(sc, bp);
 273 
 274         if (!xfs_sb_version_hascrc(&mp->m_sb)) {
 275                 /* all v5 fields must be zero */
 276                 if (memchr_inv(&sb->sb_features_compat, 0,
 277                                 sizeof(struct xfs_dsb) -
 278                                 offsetof(struct xfs_dsb, sb_features_compat)))
 279                         xchk_block_set_corrupt(sc, bp);
 280         } else {
 281                 /* Check compat flags; all are set at mkfs time. */
 282                 features_mask = cpu_to_be32(XFS_SB_FEAT_COMPAT_UNKNOWN);
 283                 if ((sb->sb_features_compat & features_mask) !=
 284                     (cpu_to_be32(mp->m_sb.sb_features_compat) & features_mask))
 285                         xchk_block_set_corrupt(sc, bp);
 286 
 287                 /* Check ro compat flags; all are set at mkfs time. */
 288                 features_mask = cpu_to_be32(XFS_SB_FEAT_RO_COMPAT_UNKNOWN |
 289                                             XFS_SB_FEAT_RO_COMPAT_FINOBT |
 290                                             XFS_SB_FEAT_RO_COMPAT_RMAPBT |
 291                                             XFS_SB_FEAT_RO_COMPAT_REFLINK);
 292                 if ((sb->sb_features_ro_compat & features_mask) !=
 293                     (cpu_to_be32(mp->m_sb.sb_features_ro_compat) &
 294                      features_mask))
 295                         xchk_block_set_corrupt(sc, bp);
 296 
 297                 /* Check incompat flags; all are set at mkfs time. */
 298                 features_mask = cpu_to_be32(XFS_SB_FEAT_INCOMPAT_UNKNOWN |
 299                                             XFS_SB_FEAT_INCOMPAT_FTYPE |
 300                                             XFS_SB_FEAT_INCOMPAT_SPINODES |
 301                                             XFS_SB_FEAT_INCOMPAT_META_UUID);
 302                 if ((sb->sb_features_incompat & features_mask) !=
 303                     (cpu_to_be32(mp->m_sb.sb_features_incompat) &
 304                      features_mask))
 305                         xchk_block_set_corrupt(sc, bp);
 306 
 307                 /* Check log incompat flags; all are set at mkfs time. */
 308                 features_mask = cpu_to_be32(XFS_SB_FEAT_INCOMPAT_LOG_UNKNOWN);
 309                 if ((sb->sb_features_log_incompat & features_mask) !=
 310                     (cpu_to_be32(mp->m_sb.sb_features_log_incompat) &
 311                      features_mask))
 312                         xchk_block_set_corrupt(sc, bp);
 313 
 314                 /* Don't care about sb_crc */
 315 
 316                 if (sb->sb_spino_align != cpu_to_be32(mp->m_sb.sb_spino_align))
 317                         xchk_block_set_corrupt(sc, bp);
 318 
 319                 if (sb->sb_pquotino != cpu_to_be64(mp->m_sb.sb_pquotino))
 320                         xchk_block_set_preen(sc, bp);
 321 
 322                 /* Don't care about sb_lsn */
 323         }
 324 
 325         if (xfs_sb_version_hasmetauuid(&mp->m_sb)) {
 326                 /* The metadata UUID must be the same for all supers */
 327                 if (!uuid_equal(&sb->sb_meta_uuid, &mp->m_sb.sb_meta_uuid))
 328                         xchk_block_set_corrupt(sc, bp);
 329         }
 330 
 331         /* Everything else must be zero. */
 332         if (memchr_inv(sb + 1, 0,
 333                         BBTOB(bp->b_length) - sizeof(struct xfs_dsb)))
 334                 xchk_block_set_corrupt(sc, bp);
 335 
 336         xchk_superblock_xref(sc, bp);
 337 
 338         return error;
 339 }
 340 
 341 /* AGF */
 342 
 343 /* Tally freespace record lengths. */
 344 STATIC int
 345 xchk_agf_record_bno_lengths(
 346         struct xfs_btree_cur            *cur,
 347         struct xfs_alloc_rec_incore     *rec,
 348         void                            *priv)
 349 {
 350         xfs_extlen_t                    *blocks = priv;
 351 
 352         (*blocks) += rec->ar_blockcount;
 353         return 0;
 354 }
 355 
 356 /* Check agf_freeblks */
 357 static inline void
 358 xchk_agf_xref_freeblks(
 359         struct xfs_scrub        *sc)
 360 {
 361         struct xfs_agf          *agf = XFS_BUF_TO_AGF(sc->sa.agf_bp);
 362         xfs_extlen_t            blocks = 0;
 363         int                     error;
 364 
 365         if (!sc->sa.bno_cur)
 366                 return;
 367 
 368         error = xfs_alloc_query_all(sc->sa.bno_cur,
 369                         xchk_agf_record_bno_lengths, &blocks);
 370         if (!xchk_should_check_xref(sc, &error, &sc->sa.bno_cur))
 371                 return;
 372         if (blocks != be32_to_cpu(agf->agf_freeblks))
 373                 xchk_block_xref_set_corrupt(sc, sc->sa.agf_bp);
 374 }
 375 
 376 /* Cross reference the AGF with the cntbt (freespace by length btree) */
 377 static inline void
 378 xchk_agf_xref_cntbt(
 379         struct xfs_scrub        *sc)
 380 {
 381         struct xfs_agf          *agf = XFS_BUF_TO_AGF(sc->sa.agf_bp);
 382         xfs_agblock_t           agbno;
 383         xfs_extlen_t            blocks;
 384         int                     have;
 385         int                     error;
 386 
 387         if (!sc->sa.cnt_cur)
 388                 return;
 389 
 390         /* Any freespace at all? */
 391         error = xfs_alloc_lookup_le(sc->sa.cnt_cur, 0, -1U, &have);
 392         if (!xchk_should_check_xref(sc, &error, &sc->sa.cnt_cur))
 393                 return;
 394         if (!have) {
 395                 if (agf->agf_freeblks != cpu_to_be32(0))
 396                         xchk_block_xref_set_corrupt(sc, sc->sa.agf_bp);
 397                 return;
 398         }
 399 
 400         /* Check agf_longest */
 401         error = xfs_alloc_get_rec(sc->sa.cnt_cur, &agbno, &blocks, &have);
 402         if (!xchk_should_check_xref(sc, &error, &sc->sa.cnt_cur))
 403                 return;
 404         if (!have || blocks != be32_to_cpu(agf->agf_longest))
 405                 xchk_block_xref_set_corrupt(sc, sc->sa.agf_bp);
 406 }
 407 
 408 /* Check the btree block counts in the AGF against the btrees. */
 409 STATIC void
 410 xchk_agf_xref_btreeblks(
 411         struct xfs_scrub        *sc)
 412 {
 413         struct xfs_agf          *agf = XFS_BUF_TO_AGF(sc->sa.agf_bp);
 414         struct xfs_mount        *mp = sc->mp;
 415         xfs_agblock_t           blocks;
 416         xfs_agblock_t           btreeblks;
 417         int                     error;
 418 
 419         /* Check agf_rmap_blocks; set up for agf_btreeblks check */
 420         if (sc->sa.rmap_cur) {
 421                 error = xfs_btree_count_blocks(sc->sa.rmap_cur, &blocks);
 422                 if (!xchk_should_check_xref(sc, &error, &sc->sa.rmap_cur))
 423                         return;
 424                 btreeblks = blocks - 1;
 425                 if (blocks != be32_to_cpu(agf->agf_rmap_blocks))
 426                         xchk_block_xref_set_corrupt(sc, sc->sa.agf_bp);
 427         } else {
 428                 btreeblks = 0;
 429         }
 430 
 431         /*
 432          * No rmap cursor; we can't xref if we have the rmapbt feature.
 433          * We also can't do it if we're missing the free space btree cursors.
 434          */
 435         if ((xfs_sb_version_hasrmapbt(&mp->m_sb) && !sc->sa.rmap_cur) ||
 436             !sc->sa.bno_cur || !sc->sa.cnt_cur)
 437                 return;
 438 
 439         /* Check agf_btreeblks */
 440         error = xfs_btree_count_blocks(sc->sa.bno_cur, &blocks);
 441         if (!xchk_should_check_xref(sc, &error, &sc->sa.bno_cur))
 442                 return;
 443         btreeblks += blocks - 1;
 444 
 445         error = xfs_btree_count_blocks(sc->sa.cnt_cur, &blocks);
 446         if (!xchk_should_check_xref(sc, &error, &sc->sa.cnt_cur))
 447                 return;
 448         btreeblks += blocks - 1;
 449 
 450         if (btreeblks != be32_to_cpu(agf->agf_btreeblks))
 451                 xchk_block_xref_set_corrupt(sc, sc->sa.agf_bp);
 452 }
 453 
 454 /* Check agf_refcount_blocks against tree size */
 455 static inline void
 456 xchk_agf_xref_refcblks(
 457         struct xfs_scrub        *sc)
 458 {
 459         struct xfs_agf          *agf = XFS_BUF_TO_AGF(sc->sa.agf_bp);
 460         xfs_agblock_t           blocks;
 461         int                     error;
 462 
 463         if (!sc->sa.refc_cur)
 464                 return;
 465 
 466         error = xfs_btree_count_blocks(sc->sa.refc_cur, &blocks);
 467         if (!xchk_should_check_xref(sc, &error, &sc->sa.refc_cur))
 468                 return;
 469         if (blocks != be32_to_cpu(agf->agf_refcount_blocks))
 470                 xchk_block_xref_set_corrupt(sc, sc->sa.agf_bp);
 471 }
 472 
 473 /* Cross-reference with the other btrees. */
 474 STATIC void
 475 xchk_agf_xref(
 476         struct xfs_scrub        *sc)
 477 {
 478         struct xfs_mount        *mp = sc->mp;
 479         xfs_agblock_t           agbno;
 480         int                     error;
 481 
 482         if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
 483                 return;
 484 
 485         agbno = XFS_AGF_BLOCK(mp);
 486 
 487         error = xchk_ag_btcur_init(sc, &sc->sa);
 488         if (error)
 489                 return;
 490 
 491         xchk_xref_is_used_space(sc, agbno, 1);
 492         xchk_agf_xref_freeblks(sc);
 493         xchk_agf_xref_cntbt(sc);
 494         xchk_xref_is_not_inode_chunk(sc, agbno, 1);
 495         xchk_xref_is_owned_by(sc, agbno, 1, &XFS_RMAP_OINFO_FS);
 496         xchk_agf_xref_btreeblks(sc);
 497         xchk_xref_is_not_shared(sc, agbno, 1);
 498         xchk_agf_xref_refcblks(sc);
 499 
 500         /* scrub teardown will take care of sc->sa for us */
 501 }
 502 
 503 /* Scrub the AGF. */
 504 int
 505 xchk_agf(
 506         struct xfs_scrub        *sc)
 507 {
 508         struct xfs_mount        *mp = sc->mp;
 509         struct xfs_agf          *agf;
 510         struct xfs_perag        *pag;
 511         xfs_agnumber_t          agno;
 512         xfs_agblock_t           agbno;
 513         xfs_agblock_t           eoag;
 514         xfs_agblock_t           agfl_first;
 515         xfs_agblock_t           agfl_last;
 516         xfs_agblock_t           agfl_count;
 517         xfs_agblock_t           fl_count;
 518         int                     level;
 519         int                     error = 0;
 520 
 521         agno = sc->sa.agno = sc->sm->sm_agno;
 522         error = xchk_ag_read_headers(sc, agno, &sc->sa.agi_bp,
 523                         &sc->sa.agf_bp, &sc->sa.agfl_bp);
 524         if (!xchk_process_error(sc, agno, XFS_AGF_BLOCK(sc->mp), &error))
 525                 goto out;
 526         xchk_buffer_recheck(sc, sc->sa.agf_bp);
 527 
 528         agf = XFS_BUF_TO_AGF(sc->sa.agf_bp);
 529 
 530         /* Check the AG length */
 531         eoag = be32_to_cpu(agf->agf_length);
 532         if (eoag != xfs_ag_block_count(mp, agno))
 533                 xchk_block_set_corrupt(sc, sc->sa.agf_bp);
 534 
 535         /* Check the AGF btree roots and levels */
 536         agbno = be32_to_cpu(agf->agf_roots[XFS_BTNUM_BNO]);
 537         if (!xfs_verify_agbno(mp, agno, agbno))
 538                 xchk_block_set_corrupt(sc, sc->sa.agf_bp);
 539 
 540         agbno = be32_to_cpu(agf->agf_roots[XFS_BTNUM_CNT]);
 541         if (!xfs_verify_agbno(mp, agno, agbno))
 542                 xchk_block_set_corrupt(sc, sc->sa.agf_bp);
 543 
 544         level = be32_to_cpu(agf->agf_levels[XFS_BTNUM_BNO]);
 545         if (level <= 0 || level > XFS_BTREE_MAXLEVELS)
 546                 xchk_block_set_corrupt(sc, sc->sa.agf_bp);
 547 
 548         level = be32_to_cpu(agf->agf_levels[XFS_BTNUM_CNT]);
 549         if (level <= 0 || level > XFS_BTREE_MAXLEVELS)
 550                 xchk_block_set_corrupt(sc, sc->sa.agf_bp);
 551 
 552         if (xfs_sb_version_hasrmapbt(&mp->m_sb)) {
 553                 agbno = be32_to_cpu(agf->agf_roots[XFS_BTNUM_RMAP]);
 554                 if (!xfs_verify_agbno(mp, agno, agbno))
 555                         xchk_block_set_corrupt(sc, sc->sa.agf_bp);
 556 
 557                 level = be32_to_cpu(agf->agf_levels[XFS_BTNUM_RMAP]);
 558                 if (level <= 0 || level > XFS_BTREE_MAXLEVELS)
 559                         xchk_block_set_corrupt(sc, sc->sa.agf_bp);
 560         }
 561 
 562         if (xfs_sb_version_hasreflink(&mp->m_sb)) {
 563                 agbno = be32_to_cpu(agf->agf_refcount_root);
 564                 if (!xfs_verify_agbno(mp, agno, agbno))
 565                         xchk_block_set_corrupt(sc, sc->sa.agf_bp);
 566 
 567                 level = be32_to_cpu(agf->agf_refcount_level);
 568                 if (level <= 0 || level > XFS_BTREE_MAXLEVELS)
 569                         xchk_block_set_corrupt(sc, sc->sa.agf_bp);
 570         }
 571 
 572         /* Check the AGFL counters */
 573         agfl_first = be32_to_cpu(agf->agf_flfirst);
 574         agfl_last = be32_to_cpu(agf->agf_fllast);
 575         agfl_count = be32_to_cpu(agf->agf_flcount);
 576         if (agfl_last > agfl_first)
 577                 fl_count = agfl_last - agfl_first + 1;
 578         else
 579                 fl_count = xfs_agfl_size(mp) - agfl_first + agfl_last + 1;
 580         if (agfl_count != 0 && fl_count != agfl_count)
 581                 xchk_block_set_corrupt(sc, sc->sa.agf_bp);
 582 
 583         /* Do the incore counters match? */
 584         pag = xfs_perag_get(mp, agno);
 585         if (pag->pagf_freeblks != be32_to_cpu(agf->agf_freeblks))
 586                 xchk_block_set_corrupt(sc, sc->sa.agf_bp);
 587         if (pag->pagf_flcount != be32_to_cpu(agf->agf_flcount))
 588                 xchk_block_set_corrupt(sc, sc->sa.agf_bp);
 589         if (pag->pagf_btreeblks != be32_to_cpu(agf->agf_btreeblks))
 590                 xchk_block_set_corrupt(sc, sc->sa.agf_bp);
 591         xfs_perag_put(pag);
 592 
 593         xchk_agf_xref(sc);
 594 out:
 595         return error;
 596 }
 597 
 598 /* AGFL */
 599 
 600 struct xchk_agfl_info {
 601         unsigned int            sz_entries;
 602         unsigned int            nr_entries;
 603         xfs_agblock_t           *entries;
 604         struct xfs_scrub        *sc;
 605 };
 606 
 607 /* Cross-reference with the other btrees. */
 608 STATIC void
 609 xchk_agfl_block_xref(
 610         struct xfs_scrub        *sc,
 611         xfs_agblock_t           agbno)
 612 {
 613         if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
 614                 return;
 615 
 616         xchk_xref_is_used_space(sc, agbno, 1);
 617         xchk_xref_is_not_inode_chunk(sc, agbno, 1);
 618         xchk_xref_is_owned_by(sc, agbno, 1, &XFS_RMAP_OINFO_AG);
 619         xchk_xref_is_not_shared(sc, agbno, 1);
 620 }
 621 
 622 /* Scrub an AGFL block. */
 623 STATIC int
 624 xchk_agfl_block(
 625         struct xfs_mount        *mp,
 626         xfs_agblock_t           agbno,
 627         void                    *priv)
 628 {
 629         struct xchk_agfl_info   *sai = priv;
 630         struct xfs_scrub        *sc = sai->sc;
 631         xfs_agnumber_t          agno = sc->sa.agno;
 632 
 633         if (xfs_verify_agbno(mp, agno, agbno) &&
 634             sai->nr_entries < sai->sz_entries)
 635                 sai->entries[sai->nr_entries++] = agbno;
 636         else
 637                 xchk_block_set_corrupt(sc, sc->sa.agfl_bp);
 638 
 639         xchk_agfl_block_xref(sc, agbno);
 640 
 641         if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
 642                 return -ECANCELED;
 643 
 644         return 0;
 645 }
 646 
 647 static int
 648 xchk_agblock_cmp(
 649         const void              *pa,
 650         const void              *pb)
 651 {
 652         const xfs_agblock_t     *a = pa;
 653         const xfs_agblock_t     *b = pb;
 654 
 655         return (int)*a - (int)*b;
 656 }
 657 
 658 /* Cross-reference with the other btrees. */
 659 STATIC void
 660 xchk_agfl_xref(
 661         struct xfs_scrub        *sc)
 662 {
 663         struct xfs_mount        *mp = sc->mp;
 664         xfs_agblock_t           agbno;
 665         int                     error;
 666 
 667         if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
 668                 return;
 669 
 670         agbno = XFS_AGFL_BLOCK(mp);
 671 
 672         error = xchk_ag_btcur_init(sc, &sc->sa);
 673         if (error)
 674                 return;
 675 
 676         xchk_xref_is_used_space(sc, agbno, 1);
 677         xchk_xref_is_not_inode_chunk(sc, agbno, 1);
 678         xchk_xref_is_owned_by(sc, agbno, 1, &XFS_RMAP_OINFO_FS);
 679         xchk_xref_is_not_shared(sc, agbno, 1);
 680 
 681         /*
 682          * Scrub teardown will take care of sc->sa for us.  Leave sc->sa
 683          * active so that the agfl block xref can use it too.
 684          */
 685 }
 686 
 687 /* Scrub the AGFL. */
 688 int
 689 xchk_agfl(
 690         struct xfs_scrub        *sc)
 691 {
 692         struct xchk_agfl_info   sai;
 693         struct xfs_agf          *agf;
 694         xfs_agnumber_t          agno;
 695         unsigned int            agflcount;
 696         unsigned int            i;
 697         int                     error;
 698 
 699         agno = sc->sa.agno = sc->sm->sm_agno;
 700         error = xchk_ag_read_headers(sc, agno, &sc->sa.agi_bp,
 701                         &sc->sa.agf_bp, &sc->sa.agfl_bp);
 702         if (!xchk_process_error(sc, agno, XFS_AGFL_BLOCK(sc->mp), &error))
 703                 goto out;
 704         if (!sc->sa.agf_bp)
 705                 return -EFSCORRUPTED;
 706         xchk_buffer_recheck(sc, sc->sa.agfl_bp);
 707 
 708         xchk_agfl_xref(sc);
 709 
 710         if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
 711                 goto out;
 712 
 713         /* Allocate buffer to ensure uniqueness of AGFL entries. */
 714         agf = XFS_BUF_TO_AGF(sc->sa.agf_bp);
 715         agflcount = be32_to_cpu(agf->agf_flcount);
 716         if (agflcount > xfs_agfl_size(sc->mp)) {
 717                 xchk_block_set_corrupt(sc, sc->sa.agf_bp);
 718                 goto out;
 719         }
 720         memset(&sai, 0, sizeof(sai));
 721         sai.sc = sc;
 722         sai.sz_entries = agflcount;
 723         sai.entries = kmem_zalloc(sizeof(xfs_agblock_t) * agflcount,
 724                         KM_MAYFAIL);
 725         if (!sai.entries) {
 726                 error = -ENOMEM;
 727                 goto out;
 728         }
 729 
 730         /* Check the blocks in the AGFL. */
 731         error = xfs_agfl_walk(sc->mp, XFS_BUF_TO_AGF(sc->sa.agf_bp),
 732                         sc->sa.agfl_bp, xchk_agfl_block, &sai);
 733         if (error == -ECANCELED) {
 734                 error = 0;
 735                 goto out_free;
 736         }
 737         if (error)
 738                 goto out_free;
 739 
 740         if (agflcount != sai.nr_entries) {
 741                 xchk_block_set_corrupt(sc, sc->sa.agf_bp);
 742                 goto out_free;
 743         }
 744 
 745         /* Sort entries, check for duplicates. */
 746         sort(sai.entries, sai.nr_entries, sizeof(sai.entries[0]),
 747                         xchk_agblock_cmp, NULL);
 748         for (i = 1; i < sai.nr_entries; i++) {
 749                 if (sai.entries[i] == sai.entries[i - 1]) {
 750                         xchk_block_set_corrupt(sc, sc->sa.agf_bp);
 751                         break;
 752                 }
 753         }
 754 
 755 out_free:
 756         kmem_free(sai.entries);
 757 out:
 758         return error;
 759 }
 760 
 761 /* AGI */
 762 
 763 /* Check agi_count/agi_freecount */
 764 static inline void
 765 xchk_agi_xref_icounts(
 766         struct xfs_scrub        *sc)
 767 {
 768         struct xfs_agi          *agi = XFS_BUF_TO_AGI(sc->sa.agi_bp);
 769         xfs_agino_t             icount;
 770         xfs_agino_t             freecount;
 771         int                     error;
 772 
 773         if (!sc->sa.ino_cur)
 774                 return;
 775 
 776         error = xfs_ialloc_count_inodes(sc->sa.ino_cur, &icount, &freecount);
 777         if (!xchk_should_check_xref(sc, &error, &sc->sa.ino_cur))
 778                 return;
 779         if (be32_to_cpu(agi->agi_count) != icount ||
 780             be32_to_cpu(agi->agi_freecount) != freecount)
 781                 xchk_block_xref_set_corrupt(sc, sc->sa.agi_bp);
 782 }
 783 
 784 /* Cross-reference with the other btrees. */
 785 STATIC void
 786 xchk_agi_xref(
 787         struct xfs_scrub        *sc)
 788 {
 789         struct xfs_mount        *mp = sc->mp;
 790         xfs_agblock_t           agbno;
 791         int                     error;
 792 
 793         if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
 794                 return;
 795 
 796         agbno = XFS_AGI_BLOCK(mp);
 797 
 798         error = xchk_ag_btcur_init(sc, &sc->sa);
 799         if (error)
 800                 return;
 801 
 802         xchk_xref_is_used_space(sc, agbno, 1);
 803         xchk_xref_is_not_inode_chunk(sc, agbno, 1);
 804         xchk_agi_xref_icounts(sc);
 805         xchk_xref_is_owned_by(sc, agbno, 1, &XFS_RMAP_OINFO_FS);
 806         xchk_xref_is_not_shared(sc, agbno, 1);
 807 
 808         /* scrub teardown will take care of sc->sa for us */
 809 }
 810 
 811 /* Scrub the AGI. */
 812 int
 813 xchk_agi(
 814         struct xfs_scrub        *sc)
 815 {
 816         struct xfs_mount        *mp = sc->mp;
 817         struct xfs_agi          *agi;
 818         struct xfs_perag        *pag;
 819         xfs_agnumber_t          agno;
 820         xfs_agblock_t           agbno;
 821         xfs_agblock_t           eoag;
 822         xfs_agino_t             agino;
 823         xfs_agino_t             first_agino;
 824         xfs_agino_t             last_agino;
 825         xfs_agino_t             icount;
 826         int                     i;
 827         int                     level;
 828         int                     error = 0;
 829 
 830         agno = sc->sa.agno = sc->sm->sm_agno;
 831         error = xchk_ag_read_headers(sc, agno, &sc->sa.agi_bp,
 832                         &sc->sa.agf_bp, &sc->sa.agfl_bp);
 833         if (!xchk_process_error(sc, agno, XFS_AGI_BLOCK(sc->mp), &error))
 834                 goto out;
 835         xchk_buffer_recheck(sc, sc->sa.agi_bp);
 836 
 837         agi = XFS_BUF_TO_AGI(sc->sa.agi_bp);
 838 
 839         /* Check the AG length */
 840         eoag = be32_to_cpu(agi->agi_length);
 841         if (eoag != xfs_ag_block_count(mp, agno))
 842                 xchk_block_set_corrupt(sc, sc->sa.agi_bp);
 843 
 844         /* Check btree roots and levels */
 845         agbno = be32_to_cpu(agi->agi_root);
 846         if (!xfs_verify_agbno(mp, agno, agbno))
 847                 xchk_block_set_corrupt(sc, sc->sa.agi_bp);
 848 
 849         level = be32_to_cpu(agi->agi_level);
 850         if (level <= 0 || level > XFS_BTREE_MAXLEVELS)
 851                 xchk_block_set_corrupt(sc, sc->sa.agi_bp);
 852 
 853         if (xfs_sb_version_hasfinobt(&mp->m_sb)) {
 854                 agbno = be32_to_cpu(agi->agi_free_root);
 855                 if (!xfs_verify_agbno(mp, agno, agbno))
 856                         xchk_block_set_corrupt(sc, sc->sa.agi_bp);
 857 
 858                 level = be32_to_cpu(agi->agi_free_level);
 859                 if (level <= 0 || level > XFS_BTREE_MAXLEVELS)
 860                         xchk_block_set_corrupt(sc, sc->sa.agi_bp);
 861         }
 862 
 863         /* Check inode counters */
 864         xfs_agino_range(mp, agno, &first_agino, &last_agino);
 865         icount = be32_to_cpu(agi->agi_count);
 866         if (icount > last_agino - first_agino + 1 ||
 867             icount < be32_to_cpu(agi->agi_freecount))
 868                 xchk_block_set_corrupt(sc, sc->sa.agi_bp);
 869 
 870         /* Check inode pointers */
 871         agino = be32_to_cpu(agi->agi_newino);
 872         if (!xfs_verify_agino_or_null(mp, agno, agino))
 873                 xchk_block_set_corrupt(sc, sc->sa.agi_bp);
 874 
 875         agino = be32_to_cpu(agi->agi_dirino);
 876         if (!xfs_verify_agino_or_null(mp, agno, agino))
 877                 xchk_block_set_corrupt(sc, sc->sa.agi_bp);
 878 
 879         /* Check unlinked inode buckets */
 880         for (i = 0; i < XFS_AGI_UNLINKED_BUCKETS; i++) {
 881                 agino = be32_to_cpu(agi->agi_unlinked[i]);
 882                 if (!xfs_verify_agino_or_null(mp, agno, agino))
 883                         xchk_block_set_corrupt(sc, sc->sa.agi_bp);
 884         }
 885 
 886         if (agi->agi_pad32 != cpu_to_be32(0))
 887                 xchk_block_set_corrupt(sc, sc->sa.agi_bp);
 888 
 889         /* Do the incore counters match? */
 890         pag = xfs_perag_get(mp, agno);
 891         if (pag->pagi_count != be32_to_cpu(agi->agi_count))
 892                 xchk_block_set_corrupt(sc, sc->sa.agi_bp);
 893         if (pag->pagi_freecount != be32_to_cpu(agi->agi_freecount))
 894                 xchk_block_set_corrupt(sc, sc->sa.agi_bp);
 895         xfs_perag_put(pag);
 896 
 897         xchk_agi_xref(sc);
 898 out:
 899         return error;
 900 }
/* [<][>][^][v][top][bottom][index][help] */
root/fs/xfs/scrub/agheader.c

DEFINITIONS
