xfs: cross-reference with the bnobt

When we're scrubbing various btrees, cross-reference the records with
the bnobt to ensure that we don't also think the space is free.

Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Dave Chinner <dchinner@redhat.com>

diff --git a/fs/xfs/scrub/agheader.c b/fs/xfs/scrub/agheader.c
index 1477aadbfe2717e09524f513505c8b5e288cb09a..713b4e0cd90709c8faf5952915df29fc488ec8b0 100644 (file)
--- a/fs/xfs/scrub/agheader.c
+++ b/fs/xfs/scrub/agheader.c
@@ -107,8 +107,23 @@ xfs_scrub_superblock_xref(
        struct xfs_scrub_context        *sc,
        struct xfs_buf                  *bp)
 {
+       struct xfs_mount                *mp = sc->mp;
+       xfs_agnumber_t                  agno = sc->sm->sm_agno;
+       xfs_agblock_t                   agbno;
+       int                             error;
+
        if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
                return;
+
+       agbno = XFS_SB_BLOCK(mp);
+
+       error = xfs_scrub_ag_init(sc, agno, &sc->sa);
+       if (!xfs_scrub_xref_process_error(sc, agno, agbno, &error))
+               return;
+
+       xfs_scrub_xref_is_used_space(sc, agbno, 1);
+
+       /* scrub teardown will take care of sc->sa for us */
 }
 
 /*
@@ -406,13 +421,61 @@ xfs_scrub_superblock(
 
 /* AGF */
 
+/* Tally freespace record lengths. */
+STATIC int
+xfs_scrub_agf_record_bno_lengths(
+       struct xfs_btree_cur            *cur,
+       struct xfs_alloc_rec_incore     *rec,
+       void                            *priv)
+{
+       xfs_extlen_t                    *blocks = priv;
+
+       (*blocks) += rec->ar_blockcount;
+       return 0;
+}
+
+/* Check agf_freeblks */
+static inline void
+xfs_scrub_agf_xref_freeblks(
+       struct xfs_scrub_context        *sc)
+{
+       struct xfs_agf                  *agf = XFS_BUF_TO_AGF(sc->sa.agf_bp);
+       xfs_extlen_t                    blocks = 0;
+       int                             error;
+
+       if (!sc->sa.bno_cur)
+               return;
+
+       error = xfs_alloc_query_all(sc->sa.bno_cur,
+                       xfs_scrub_agf_record_bno_lengths, &blocks);
+       if (!xfs_scrub_should_check_xref(sc, &error, &sc->sa.bno_cur))
+               return;
+       if (blocks != be32_to_cpu(agf->agf_freeblks))
+               xfs_scrub_block_xref_set_corrupt(sc, sc->sa.agf_bp);
+}
+
 /* Cross-reference with the other btrees. */
 STATIC void
 xfs_scrub_agf_xref(
        struct xfs_scrub_context        *sc)
 {
+       struct xfs_mount                *mp = sc->mp;
+       xfs_agblock_t                   agbno;
+       int                             error;
+
        if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
                return;
+
+       agbno = XFS_AGF_BLOCK(mp);
+
+       error = xfs_scrub_ag_btcur_init(sc, &sc->sa);
+       if (error)
+               return;
+
+       xfs_scrub_xref_is_used_space(sc, agbno, 1);
+       xfs_scrub_agf_xref_freeblks(sc);
+
+       /* scrub teardown will take care of sc->sa for us */
 }
 
 /* Scrub the AGF. */
@@ -514,6 +577,8 @@ xfs_scrub_agfl_block_xref(
 {
        if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
                return;
+
+       xfs_scrub_xref_is_used_space(sc, agbno, 1);
 }
 
 /* Scrub an AGFL block. */
@@ -554,8 +619,25 @@ STATIC void
 xfs_scrub_agfl_xref(
        struct xfs_scrub_context        *sc)
 {
+       struct xfs_mount                *mp = sc->mp;
+       xfs_agblock_t                   agbno;
+       int                             error;
+
        if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
                return;
+
+       agbno = XFS_AGFL_BLOCK(mp);
+
+       error = xfs_scrub_ag_btcur_init(sc, &sc->sa);
+       if (error)
+               return;
+
+       xfs_scrub_xref_is_used_space(sc, agbno, 1);
+
+       /*
+        * Scrub teardown will take care of sc->sa for us.  Leave sc->sa
+        * active so that the agfl block xref can use it too.
+        */
 }
 
 /* Scrub the AGFL. */
@@ -630,8 +712,22 @@ STATIC void
 xfs_scrub_agi_xref(
        struct xfs_scrub_context        *sc)
 {
+       struct xfs_mount                *mp = sc->mp;
+       xfs_agblock_t                   agbno;
+       int                             error;
+
        if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
                return;
+
+       agbno = XFS_AGI_BLOCK(mp);
+
+       error = xfs_scrub_ag_btcur_init(sc, &sc->sa);
+       if (error)
+               return;
+
+       xfs_scrub_xref_is_used_space(sc, agbno, 1);
+
+       /* scrub teardown will take care of sc->sa for us */
 }
 
 /* Scrub the AGI. */

diff --git a/fs/xfs/scrub/alloc.c b/fs/xfs/scrub/alloc.c
index 03ed403ff0d32c6fc39014741e698c13142e5c22..9b45585c09929631a57226a66879efd985e037cb 100644 (file)
--- a/fs/xfs/scrub/alloc.c
+++ b/fs/xfs/scrub/alloc.c
@@ -113,3 +113,23 @@ xfs_scrub_cntbt(
 {
        return xfs_scrub_allocbt(sc, XFS_BTNUM_CNT);
 }
+
+/* xref check that the extent is not free */
+void
+xfs_scrub_xref_is_used_space(
+       struct xfs_scrub_context        *sc,
+       xfs_agblock_t                   agbno,
+       xfs_extlen_t                    len)
+{
+       bool                            is_freesp;
+       int                             error;
+
+       if (!sc->sa.bno_cur)
+               return;
+
+       error = xfs_alloc_has_record(sc->sa.bno_cur, agbno, len, &is_freesp);
+       if (!xfs_scrub_should_check_xref(sc, &error, &sc->sa.bno_cur))
+               return;
+       if (is_freesp)
+               xfs_scrub_btree_xref_set_corrupt(sc, sc->sa.bno_cur, 0);
+}

diff --git a/fs/xfs/scrub/bmap.c b/fs/xfs/scrub/bmap.c
index b6931928e727b5eb7ed1fb9d72bce91c25536097..7e8e239c2516003f50fd43861d6337be548ca82a 100644 (file)
--- a/fs/xfs/scrub/bmap.c
+++ b/fs/xfs/scrub/bmap.c
@@ -119,8 +119,27 @@ xfs_scrub_bmap_extent_xref(
        struct xfs_btree_cur            *cur,
        struct xfs_bmbt_irec            *irec)
 {
+       struct xfs_mount                *mp = info->sc->mp;
+       xfs_agnumber_t                  agno;
+       xfs_agblock_t                   agbno;
+       xfs_extlen_t                    len;
+       int                             error;
+
        if (info->sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
                return;
+
+       agno = XFS_FSB_TO_AGNO(mp, irec->br_startblock);
+       agbno = XFS_FSB_TO_AGBNO(mp, irec->br_startblock);
+       len = irec->br_blockcount;
+
+       error = xfs_scrub_ag_init(info->sc, agno, &info->sc->sa);
+       if (!xfs_scrub_fblock_process_error(info->sc, info->whichfork,
+                       irec->br_startoff, &error))
+               return;
+
+       xfs_scrub_xref_is_used_space(info->sc, agbno, len);
+
+       xfs_scrub_ag_free(info->sc, &info->sc->sa);
 }
 
 /* Scrub a single extent record. */

diff --git a/fs/xfs/scrub/btree.c b/fs/xfs/scrub/btree.c
index e671d694908bd57377c314f60ab256cd1825ee16..222e0312bd8c7fb09376c4e8c497dd2c1b209655 100644 (file)
--- a/fs/xfs/scrub/btree.c
+++ b/fs/xfs/scrub/btree.c
@@ -378,13 +378,17 @@ xfs_scrub_btree_check_block_owner(
        xfs_daddr_t                     daddr)
 {
        xfs_agnumber_t                  agno;
+       xfs_agblock_t                   agbno;
+       xfs_btnum_t                     btnum;
        bool                            init_sa;
        int                             error = 0;
 
        if (!bs->cur)
                return 0;
 
+       btnum = bs->cur->bc_btnum;
        agno = xfs_daddr_to_agno(bs->cur->bc_mp, daddr);
+       agbno = xfs_daddr_to_agbno(bs->cur->bc_mp, daddr);
 
        init_sa = bs->cur->bc_flags & XFS_BTREE_LONG_PTRS;
        if (init_sa) {
@@ -394,6 +398,15 @@ xfs_scrub_btree_check_block_owner(
                        return error;
        }
 
+       xfs_scrub_xref_is_used_space(bs->sc, agbno, 1);
+       /*
+        * The bnobt scrubber aliases bs->cur to bs->sc->sa.bno_cur, so we
+        * have to nullify it (to shut down further block owner checks) if
+        * self-xref encounters problems.
+        */
+       if (!bs->sc->sa.bno_cur && btnum == XFS_BTNUM_BNO)
+               bs->cur = NULL;
+
        if (init_sa)
                xfs_scrub_ag_free(bs->sc, &bs->sc->sa);
 

diff --git a/fs/xfs/scrub/ialloc.c b/fs/xfs/scrub/ialloc.c
index 9294148267bca8e8fe08e8d3e790798c0756a86f..45268941785abc9bfdb9ca4e47a1f8dc94da9079 100644 (file)
--- a/fs/xfs/scrub/ialloc.c
+++ b/fs/xfs/scrub/ialloc.c
@@ -69,6 +69,8 @@ xfs_scrub_iallocbt_chunk_xref(
 {
        if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
                return;
+
+       xfs_scrub_xref_is_used_space(sc, agbno, len);
 }
 
 /* Is this chunk worth checking? */

diff --git a/fs/xfs/scrub/inode.c b/fs/xfs/scrub/inode.c
index 63525791b3cec1f3477ec132a6a9f591fd22f4e5..153d4eb91b9317f08a3ca6c3a883ba3473ba460d 100644 (file)
--- a/fs/xfs/scrub/inode.c
+++ b/fs/xfs/scrub/inode.c
@@ -584,8 +584,23 @@ xfs_scrub_inode_xref(
        xfs_ino_t                       ino,
        struct xfs_dinode               *dip)
 {
+       xfs_agnumber_t                  agno;
+       xfs_agblock_t                   agbno;
+       int                             error;
+
        if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
                return;
+
+       agno = XFS_INO_TO_AGNO(sc->mp, ino);
+       agbno = XFS_INO_TO_AGBNO(sc->mp, ino);
+
+       error = xfs_scrub_ag_init(sc, agno, &sc->sa);
+       if (!xfs_scrub_xref_process_error(sc, agno, agbno, &error))
+               return;
+
+       xfs_scrub_xref_is_used_space(sc, agbno, 1);
+
+       xfs_scrub_ag_free(sc, &sc->sa);
 }
 
 /* Scrub an inode. */

diff --git a/fs/xfs/scrub/refcount.c b/fs/xfs/scrub/refcount.c
index 4c550b3bfbe6694d4f135656afb6df76c86a636d..09a04ae0895e44ebc2f4d8d42875323e90bccc85 100644 (file)
--- a/fs/xfs/scrub/refcount.c
+++ b/fs/xfs/scrub/refcount.c
@@ -60,6 +60,8 @@ xfs_scrub_refcountbt_xref(
 {
        if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
                return;
+
+       xfs_scrub_xref_is_used_space(sc, agbno, len);
 }
 
 /* Scrub a refcountbt record. */

diff --git a/fs/xfs/scrub/rmap.c b/fs/xfs/scrub/rmap.c
index 86559489592041c7dbc17e0493978d78690e3eb4..54b0eac22707ce742cc58ebf7ca937aaf5e0b1dc 100644 (file)
--- a/fs/xfs/scrub/rmap.c
+++ b/fs/xfs/scrub/rmap.c
@@ -57,8 +57,13 @@ xfs_scrub_rmapbt_xref(
        struct xfs_scrub_context        *sc,
        struct xfs_rmap_irec            *irec)
 {
+       xfs_agblock_t                   agbno = irec->rm_startblock;
+       xfs_extlen_t                    len = irec->rm_blockcount;
+
        if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
                return;
+
+       xfs_scrub_xref_is_used_space(sc, agbno, len);
 }
 
 /* Scrub an rmapbt record. */

diff --git a/fs/xfs/scrub/scrub.h b/fs/xfs/scrub/scrub.h
index 2a7961405f0296866a5c6d54f4c04089cb3a16cc..cbc63632617150dd5d8cc0a675d17686b9b088e4 100644 (file)
--- a/fs/xfs/scrub/scrub.h
+++ b/fs/xfs/scrub/scrub.h
@@ -123,4 +123,8 @@ xfs_scrub_quota(struct xfs_scrub_context *sc)
 }
 #endif
 
+/* cross-referencing helpers */
+void xfs_scrub_xref_is_used_space(struct xfs_scrub_context *sc,
+               xfs_agblock_t agbno, xfs_extlen_t len);
+
 #endif /* __XFS_SCRUB_SCRUB_H__ */