From: "Darrick J. Wong" <darrick.wong@oracle.com>
To: darrick.wong@oracle.com
Cc: linux-xfs@vger.kernel.org
Subject: [PATCH 29/47] xfs: cross-reference reverse-mapping btree
Date: Fri, 06 Jan 2017 16:38:55 -0800 [thread overview]
Message-ID: <148374953586.30431.8166127209244400711.stgit@birch.djwong.org> (raw)
In-Reply-To: <148374934333.30431.11042523766304087227.stgit@birch.djwong.org>
When scrubbing various btrees, we should cross-reference the records
with the reverse mapping btree.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
---
fs/xfs/libxfs/xfs_rmap.c | 58 ++++++++++++++
fs/xfs/libxfs/xfs_rmap.h | 5 +
| 95 +++++++++++++++++++++++
fs/xfs/repair/alloc.c | 9 ++
fs/xfs/repair/bmap.c | 89 ++++++++++++++++++++++
fs/xfs/repair/btree.c | 10 ++
fs/xfs/repair/ialloc.c | 30 +++++++
fs/xfs/repair/inode.c | 23 ++++++
fs/xfs/repair/refcount.c | 187 ++++++++++++++++++++++++++++++++++++++++++++++
9 files changed, 506 insertions(+)
diff --git a/fs/xfs/libxfs/xfs_rmap.c b/fs/xfs/libxfs/xfs_rmap.c
index c7d5102..cce51cb 100644
--- a/fs/xfs/libxfs/xfs_rmap.c
+++ b/fs/xfs/libxfs/xfs_rmap.c
@@ -2306,3 +2306,61 @@ xfs_rmap_free_extent(
return __xfs_rmap_add(mp, dfops, XFS_RMAP_FREE, owner,
XFS_DATA_FORK, &bmap);
}
+
+/* Is there a record covering a given extent? */
+int
+xfs_rmap_has_record(
+ struct xfs_btree_cur *cur,
+ xfs_fsblock_t bno,
+ xfs_filblks_t len,
+ bool *exists)
+{
+ union xfs_btree_irec low;
+ union xfs_btree_irec high;
+
+ memset(&low, 0, sizeof(low));
+ low.r.rm_startblock = bno;
+ memset(&high, 0xFF, sizeof(high));
+ high.r.rm_startblock = bno + len - 1;
+
+ return xfs_btree_has_record(cur, &low, &high, exists);
+}
+
+/* Is there a record covering a given extent? */
+int
+xfs_rmap_record_exists(
+ struct xfs_btree_cur *cur,
+ xfs_fsblock_t bno,
+ xfs_filblks_t len,
+ struct xfs_owner_info *oinfo,
+ bool *has_rmap)
+{
+ uint64_t owner;
+ uint64_t offset;
+ unsigned int flags;
+ int stat;
+ struct xfs_rmap_irec irec;
+ int error;
+
+ xfs_owner_info_unpack(oinfo, &owner, &offset, &flags);
+
+ error = xfs_rmap_lookup_le(cur, bno, len, owner, offset, flags, &stat);
+ if (error)
+ return error;
+ if (!stat) {
+ *has_rmap = false;
+ return 0;
+ }
+
+ error = xfs_rmap_get_rec(cur, &irec, &stat);
+ if (error)
+ return error;
+ if (!stat) {
+ *has_rmap = false;
+ return 0;
+ }
+
+ *has_rmap = (irec.rm_owner == owner && irec.rm_startblock <= bno &&
+ irec.rm_startblock + irec.rm_blockcount >= bno + len);
+ return 0;
+}
diff --git a/fs/xfs/libxfs/xfs_rmap.h b/fs/xfs/libxfs/xfs_rmap.h
index 3fa4559..ea359ab 100644
--- a/fs/xfs/libxfs/xfs_rmap.h
+++ b/fs/xfs/libxfs/xfs_rmap.h
@@ -217,5 +217,10 @@ int xfs_rmap_lookup_le_range(struct xfs_btree_cur *cur, xfs_agblock_t bno,
union xfs_btree_rec;
int xfs_rmap_btrec_to_irec(union xfs_btree_rec *rec,
struct xfs_rmap_irec *irec);
+int xfs_rmap_has_record(struct xfs_btree_cur *cur, xfs_fsblock_t bno,
+ xfs_filblks_t len, bool *exists);
+int xfs_rmap_record_exists(struct xfs_btree_cur *cur, xfs_fsblock_t bno,
+ xfs_filblks_t len, struct xfs_owner_info *oinfo,
+ bool *has_rmap);
#endif /* __XFS_RMAP_H__ */
--git a/fs/xfs/repair/agheader.c b/fs/xfs/repair/agheader.c
index 9c4bdf1..025f17a 100644
--- a/fs/xfs/repair/agheader.c
+++ b/fs/xfs/repair/agheader.c
@@ -33,6 +33,7 @@
#include "xfs_inode.h"
#include "xfs_alloc.h"
#include "xfs_ialloc.h"
+#include "xfs_rmap.h"
#include "repair/common.h"
/* Set us up to check an AG header. */
@@ -157,10 +158,12 @@ xfs_scrub_superblock(
struct xfs_buf *bp;
struct xfs_scrub_ag *psa;
struct xfs_sb sb;
+ struct xfs_owner_info oinfo;
xfs_agnumber_t agno;
uint32_t v2_ok;
bool is_freesp;
bool has_inodes;
+ bool has_rmap;
int error;
int err2;
@@ -315,6 +318,15 @@ xfs_scrub_superblock(
XFS_SCRUB_SB_CHECK(!has_inodes);
}
+ /* Cross-reference with the rmapbt. */
+ if (psa->rmap_cur) {
+ xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_FS);
+ err2 = xfs_rmap_record_exists(psa->rmap_cur, XFS_SB_BLOCK(mp),
+ 1, &oinfo, &has_rmap);
+ if (xfs_scrub_should_xref(sc, err2, &psa->rmap_cur))
+ XFS_SCRUB_SB_CHECK(has_rmap);
+ }
+
out:
return error;
}
@@ -346,6 +358,7 @@ int
xfs_scrub_agf(
struct xfs_scrub_context *sc)
{
+ struct xfs_owner_info oinfo;
struct xfs_mount *mp = sc->tp->t_mountp;
struct xfs_agf *agf;
struct xfs_scrub_ag *psa;
@@ -359,8 +372,10 @@ xfs_scrub_agf(
xfs_agblock_t agfl_count;
xfs_agblock_t fl_count;
xfs_extlen_t blocks;
+ xfs_extlen_t btreeblks = 0;
bool is_freesp;
bool has_inodes;
+ bool has_rmap;
int have;
int level;
int error = 0;
@@ -496,6 +511,37 @@ xfs_scrub_agf(
XFS_SCRUB_AGF_CHECK(!has_inodes);
}
+ /* Cross-reference with the rmapbt. */
+ if (psa->rmap_cur) {
+ xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_FS);
+ err2 = xfs_rmap_record_exists(psa->rmap_cur, XFS_AGF_BLOCK(mp),
+ 1, &oinfo, &has_rmap);
+ if (xfs_scrub_should_xref(sc, err2, &psa->rmap_cur))
+ XFS_SCRUB_AGF_CHECK(has_rmap);
+ }
+ if (psa->rmap_cur) {
+ err2 = xfs_btree_count_blocks(psa->rmap_cur, &blocks);
+ if (xfs_scrub_should_xref(sc, err2, &psa->rmap_cur)) {
+ btreeblks = blocks - 1;
+ XFS_SCRUB_AGF_CHECK(blocks == be32_to_cpu(
+ agf->agf_rmap_blocks));
+ }
+ }
+
+ /* Check btreeblks */
+ if ((!xfs_sb_version_hasrmapbt(&mp->m_sb) || psa->rmap_cur) &&
+ psa->bno_cur && psa->cnt_cur) {
+ err2 = xfs_btree_count_blocks(psa->bno_cur, &blocks);
+ if (xfs_scrub_should_xref(sc, err2, &psa->bno_cur))
+ btreeblks += blocks - 1;
+ err2 = xfs_btree_count_blocks(psa->cnt_cur, &blocks);
+ if (xfs_scrub_should_xref(sc, err2, &psa->cnt_cur))
+ btreeblks += blocks - 1;
+ if (psa->bno_cur && psa->cnt_cur)
+ XFS_SCRUB_AGF_CHECK(btreeblks == be32_to_cpu(
+ agf->agf_btreeblks));
+ }
+
out:
return error;
}
@@ -507,6 +553,7 @@ xfs_scrub_agf(
#define XFS_SCRUB_AGFL_CHECK(fs_ok) \
XFS_SCRUB_CHECK(sc, sc->sa.agfl_bp, "AGFL", fs_ok)
struct xfs_scrub_agfl {
+ struct xfs_owner_info oinfo;
xfs_agblock_t eoag;
xfs_daddr_t eofs;
};
@@ -523,6 +570,7 @@ xfs_scrub_agfl_block(
struct xfs_scrub_agfl *sagfl = priv;
bool is_freesp;
bool has_inodes;
+ bool has_rmap;
int err2;
XFS_SCRUB_AGFL_CHECK(agbno > XFS_AGI_BLOCK(mp));
@@ -557,6 +605,14 @@ xfs_scrub_agfl_block(
XFS_SCRUB_AGFL_CHECK(!has_inodes);
}
+ /* Cross-reference with the rmapbt. */
+ if (sc->sa.rmap_cur) {
+ err2 = xfs_rmap_record_exists(sc->sa.rmap_cur, agbno, 1,
+ &sagfl->oinfo, &has_rmap);
+ if (xfs_scrub_should_xref(sc, err2, &sc->sa.rmap_cur))
+ XFS_SCRUB_AGFL_CHECK(has_rmap);
+ }
+
return 0;
}
@@ -572,6 +628,8 @@ xfs_scrub_agfl(
struct xfs_mount *mp = sc->tp->t_mountp;
struct xfs_agf *agf;
bool is_freesp;
+ bool has_inodes;
+ bool has_rmap;
int error;
int err2;
@@ -593,7 +651,33 @@ xfs_scrub_agfl(
XFS_SCRUB_AGFL_CHECK(!is_freesp);
}
+ /* Cross-reference with inobt. */
+ if (sc->sa.ino_cur) {
+ err2 = xfs_ialloc_has_inodes_at_extent(sc->sa.ino_cur,
+ XFS_AGFL_BLOCK(mp), 1, &has_inodes);
+ if (xfs_scrub_should_xref(sc, err2, &sc->sa.ino_cur))
+ XFS_SCRUB_AGFL_CHECK(!has_inodes);
+ }
+
+ /* Cross-reference with finobt. */
+ if (sc->sa.fino_cur) {
+ err2 = xfs_ialloc_has_inodes_at_extent(sc->sa.fino_cur,
+ XFS_AGFL_BLOCK(mp), 1, &has_inodes);
+ if (xfs_scrub_should_xref(sc, err2, &sc->sa.fino_cur))
+ XFS_SCRUB_AGFL_CHECK(!has_inodes);
+ }
+
+ /* Set up cross-reference with rmapbt. */
+ if (sc->sa.rmap_cur) {
+ xfs_rmap_ag_owner(&sagfl.oinfo, XFS_RMAP_OWN_FS);
+ err2 = xfs_rmap_record_exists(sc->sa.rmap_cur,
+ XFS_AGFL_BLOCK(mp), 1, &sagfl.oinfo, &has_rmap);
+ if (xfs_scrub_should_xref(sc, err2, &sc->sa.rmap_cur))
+ XFS_SCRUB_AGFL_CHECK(has_rmap);
+ }
+
/* Check the blocks in the AGFL. */
+ xfs_rmap_ag_owner(&sagfl.oinfo, XFS_RMAP_OWN_AG);
return xfs_scrub_walk_agfl(sc, xfs_scrub_agfl_block, &sagfl);
out:
return error;
@@ -613,6 +697,7 @@ int
xfs_scrub_agi(
struct xfs_scrub_context *sc)
{
+ struct xfs_owner_info oinfo;
struct xfs_mount *mp = sc->tp->t_mountp;
struct xfs_agi *agi;
struct xfs_scrub_ag *psa;
@@ -628,6 +713,7 @@ xfs_scrub_agi(
xfs_agino_t freecount;
bool is_freesp;
bool has_inodes;
+ bool has_rmap;
int i;
int level;
int error = 0;
@@ -739,6 +825,15 @@ xfs_scrub_agi(
XFS_SCRUB_AGI_CHECK(!has_inodes);
}
+ /* Cross-reference with the rmapbt. */
+ if (psa->rmap_cur) {
+ xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_FS);
+ err2 = xfs_rmap_record_exists(psa->rmap_cur, XFS_AGI_BLOCK(mp),
+ 1, &oinfo, &has_rmap);
+ if (xfs_scrub_should_xref(sc, err2, &psa->rmap_cur))
+ XFS_SCRUB_AGI_CHECK(has_rmap);
+ }
+
out:
return error;
}
diff --git a/fs/xfs/repair/alloc.c b/fs/xfs/repair/alloc.c
index 7812ee0..ecbc341 100644
--- a/fs/xfs/repair/alloc.c
+++ b/fs/xfs/repair/alloc.c
@@ -73,6 +73,7 @@ xfs_scrub_allocbt_helper(
xfs_agblock_t bno;
xfs_extlen_t flen;
xfs_extlen_t len;
+ bool has_rmap;
bool has_inodes;
int has_otherrec;
int error = 0;
@@ -133,6 +134,14 @@ xfs_scrub_allocbt_helper(
XFS_SCRUB_BTREC_CHECK(bs, !has_inodes);
}
+ /* Cross-reference with the rmapbt. */
+ if (psa->rmap_cur) {
+ err2 = xfs_rmap_has_record(psa->rmap_cur, bno, len,
+ &has_rmap);
+ if (xfs_scrub_btree_should_xref(bs, err2, &psa->rmap_cur))
+ XFS_SCRUB_BTREC_CHECK(bs, !has_rmap);
+ }
+
out:
return error;
}
diff --git a/fs/xfs/repair/bmap.c b/fs/xfs/repair/bmap.c
index dd030081d..b88b450 100644
--- a/fs/xfs/repair/bmap.c
+++ b/fs/xfs/repair/bmap.c
@@ -103,8 +103,13 @@ xfs_scrub_bmap_extent(
xfs_daddr_t dlen;
xfs_agnumber_t agno;
xfs_fsblock_t bno;
+ struct xfs_rmap_irec rmap;
+ uint64_t owner;
+ xfs_fileoff_t offset;
bool is_freesp;
bool has_inodes;
+ unsigned int rflags;
+ int has_rmap;
int error = 0;
int err2 = 0;
@@ -177,6 +182,90 @@ xfs_scrub_bmap_extent(
XFS_SCRUB_BMAP_CHECK(!has_inodes);
}
+ /* Cross-reference with rmapbt. */
+ if (sa.rmap_cur) {
+ if (info->whichfork == XFS_COW_FORK) {
+ owner = XFS_RMAP_OWN_COW;
+ offset = 0;
+ } else {
+ owner = ip->i_ino;
+ offset = irec->br_startoff;
+ }
+
+ /* Look for a corresponding rmap. */
+ rflags = 0;
+ if (info->whichfork == XFS_ATTR_FORK)
+ rflags |= XFS_RMAP_ATTR_FORK;
+
+ if (info->is_shared) {
+ err2 = xfs_rmap_lookup_le_range(sa.rmap_cur, bno, owner,
+ offset, rflags, &rmap,
+ &has_rmap);
+ if (xfs_scrub_should_xref(info->sc, err2,
+ &sa.rmap_cur)) {
+ XFS_SCRUB_BMAP_GOTO(has_rmap, skip_rmap_xref);
+ } else
+ goto skip_rmap_xref;
+ } else {
+ err2 = xfs_rmap_lookup_le(sa.rmap_cur, bno, 0, owner,
+ offset, rflags, &has_rmap);
+ if (xfs_scrub_should_xref(info->sc, err2,
+ &sa.rmap_cur)) {
+ XFS_SCRUB_BMAP_GOTO(has_rmap, skip_rmap_xref);
+ } else
+ goto skip_rmap_xref;
+
+ err2 = xfs_rmap_get_rec(sa.rmap_cur, &rmap,
+ &has_rmap);
+ if (xfs_scrub_should_xref(info->sc, err2,
+ &sa.rmap_cur)) {
+ XFS_SCRUB_BMAP_GOTO(has_rmap, skip_rmap_xref);
+ } else
+ goto skip_rmap_xref;
+ }
+
+ /* Check the rmap. */
+ XFS_SCRUB_BMAP_CHECK(rmap.rm_startblock <= bno);
+ XFS_SCRUB_BMAP_CHECK(rmap.rm_startblock <
+ rmap.rm_startblock + rmap.rm_blockcount);
+ XFS_SCRUB_BMAP_CHECK(bno + irec->br_blockcount <=
+ rmap.rm_startblock + rmap.rm_blockcount);
+ if (owner != XFS_RMAP_OWN_COW) {
+ XFS_SCRUB_BMAP_CHECK(rmap.rm_offset <= offset);
+ XFS_SCRUB_BMAP_CHECK(rmap.rm_offset <
+ rmap.rm_offset + rmap.rm_blockcount);
+ XFS_SCRUB_BMAP_CHECK(offset + irec->br_blockcount <=
+ rmap.rm_offset + rmap.rm_blockcount);
+ }
+ XFS_SCRUB_BMAP_CHECK(rmap.rm_owner == owner);
+ switch (irec->br_state) {
+ case XFS_EXT_UNWRITTEN:
+ XFS_SCRUB_BMAP_CHECK(
+ rmap.rm_flags & XFS_RMAP_UNWRITTEN);
+ break;
+ case XFS_EXT_NORM:
+ XFS_SCRUB_BMAP_CHECK(
+ !(rmap.rm_flags & XFS_RMAP_UNWRITTEN));
+ break;
+ default:
+ break;
+ }
+ switch (info->whichfork) {
+ case XFS_ATTR_FORK:
+ XFS_SCRUB_BMAP_CHECK(
+ rmap.rm_flags & XFS_RMAP_ATTR_FORK);
+ break;
+ case XFS_DATA_FORK:
+ case XFS_COW_FORK:
+ XFS_SCRUB_BMAP_CHECK(
+ !(rmap.rm_flags & XFS_RMAP_ATTR_FORK));
+ break;
+ }
+ XFS_SCRUB_BMAP_CHECK(!(rmap.rm_flags & XFS_RMAP_BMBT_BLOCK));
+skip_rmap_xref:
+ ;
+ }
+
xfs_scrub_ag_free(&sa);
out:
info->lastoff = irec->br_startoff + irec->br_blockcount;
diff --git a/fs/xfs/repair/btree.c b/fs/xfs/repair/btree.c
index c13762e..4e4436a 100644
--- a/fs/xfs/repair/btree.c
+++ b/fs/xfs/repair/btree.c
@@ -32,6 +32,7 @@
#include "xfs_sb.h"
#include "xfs_inode.h"
#include "xfs_alloc.h"
+#include "xfs_rmap.h"
#include "repair/common.h"
#include "repair/btree.h"
@@ -513,6 +514,7 @@ xfs_scrub_btree_check_block_owner(
xfs_agnumber_t agno;
xfs_agblock_t bno;
bool is_freesp;
+ bool has_rmap;
int error = 0;
int err2;
@@ -536,6 +538,14 @@ xfs_scrub_btree_check_block_owner(
XFS_SCRUB_BTREC_CHECK(bs, !is_freesp);
}
+ /* Check that there's an rmap for this. */
+ if (psa->rmap_cur) {
+ err2 = xfs_rmap_record_exists(psa->rmap_cur, bno, 1, bs->oinfo,
+ &has_rmap);
+ if (xfs_scrub_btree_should_xref(bs, err2, NULL))
+ XFS_SCRUB_BTREC_CHECK(bs, has_rmap);
+ }
+
if (bs->cur->bc_flags & XFS_BTREE_LONG_PTRS)
xfs_scrub_ag_free(&sa);
diff --git a/fs/xfs/repair/ialloc.c b/fs/xfs/repair/ialloc.c
index b169ccf..816eb1a 100644
--- a/fs/xfs/repair/ialloc.c
+++ b/fs/xfs/repair/ialloc.c
@@ -86,16 +86,19 @@ xfs_scrub_iallocbt_chunk(
struct xfs_agf *agf;
struct xfs_scrub_ag *psa;
struct xfs_btree_cur **xcur;
+ struct xfs_owner_info oinfo;
xfs_agblock_t eoag;
xfs_agblock_t bno;
bool is_freesp;
bool has_inodes;
+ bool has_rmap;
int error = 0;
int err2;
agf = XFS_BUF_TO_AGF(bs->sc->sa.agf_bp);
eoag = be32_to_cpu(agf->agf_length);
bno = XFS_AGINO_TO_AGBNO(mp, agino);
+ xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_INODES);
*keep_scanning = true;
XFS_SCRUB_BTREC_CHECK(bs, bno < mp->m_sb.sb_agblocks);
@@ -137,6 +140,14 @@ xfs_scrub_iallocbt_chunk(
XFS_SCRUB_BTREC_CHECK(bs, has_inodes);
}
+ /* Cross-reference with rmapbt. */
+ if (psa->rmap_cur) {
+ err2 = xfs_rmap_record_exists(psa->rmap_cur, bno,
+ len, &oinfo, &has_rmap);
+ if (xfs_scrub_btree_should_xref(bs, err2, &psa->rmap_cur))
+ XFS_SCRUB_BTREC_CHECK(bs, has_rmap);
+ }
+
out:
return error;
}
@@ -211,6 +222,7 @@ xfs_scrub_iallocbt_check_freemask(
struct xfs_mount *mp = bs->cur->bc_mp;
struct xfs_dinode *dip;
struct xfs_buf *bp;
+ struct xfs_scrub_ag *psa;
xfs_ino_t fsino;
xfs_agino_t nr_inodes;
xfs_agino_t agino;
@@ -220,12 +232,15 @@ xfs_scrub_iallocbt_check_freemask(
int blks_per_cluster;
__uint16_t holemask;
__uint16_t ir_holemask;
+ bool has;
int error = 0;
+ int err2;
/* Make sure the freemask matches the inode records. */
blks_per_cluster = xfs_icluster_size_fsb(mp);
nr_inodes = XFS_OFFBNO_TO_AGINO(mp, blks_per_cluster, 0);
xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_INODES);
+ psa = &bs->sc->sa;
for (agino = irec->ir_startino;
agino < irec->ir_startino + XFS_INODES_PER_CHUNK;
@@ -245,6 +260,21 @@ xfs_scrub_iallocbt_check_freemask(
XFS_SCRUB_BTREC_CHECK(bs, ir_holemask == holemask ||
ir_holemask == 0);
+ /* Does the rmap agree that we have inodes here? */
+ if (psa->rmap_cur) {
+ err2 = xfs_rmap_record_exists(psa->rmap_cur, agbno,
+ blks_per_cluster, &oinfo, &has);
+ if (!xfs_scrub_btree_should_xref(bs, err2,
+ &psa->rmap_cur))
+ goto skip_xref;
+ if (has)
+ XFS_SCRUB_BTREC_CHECK(bs, ir_holemask == 0);
+ else
+ XFS_SCRUB_BTREC_CHECK(bs,
+ ir_holemask == holemask);
+ }
+
+skip_xref:
/* If any part of this is a hole, skip it. */
if (ir_holemask)
continue;
diff --git a/fs/xfs/repair/inode.c b/fs/xfs/repair/inode.c
index e06d585..14d9e19 100644
--- a/fs/xfs/repair/inode.c
+++ b/fs/xfs/repair/inode.c
@@ -38,6 +38,7 @@
#include "xfs_ialloc.h"
#include "xfs_log.h"
#include "xfs_trans_priv.h"
+#include "xfs_rmap.h"
#include "repair/common.h"
/*
@@ -182,6 +183,7 @@ xfs_scrub_inode(
uint16_t flags;
uint16_t mode;
int error = 0;
+ int err2;
/* Did we get the in-core inode, or are we doing this manually? */
if (sc->ip) {
@@ -368,6 +370,27 @@ xfs_scrub_inode(
XFS_SCRUB_INODE_PREEN(ifp->if_bytes > 0);
}
+ /* Make sure the rmap thinks there's an inode here. */
+ if (xfs_sb_version_hasrmapbt(&mp->m_sb)) {
+ struct xfs_owner_info oinfo;
+ struct xfs_scrub_ag sa = {0};
+ xfs_agnumber_t agno;
+ xfs_agblock_t agbno;
+ bool has_rmap;
+
+ agno = XFS_INO_TO_AGNO(mp, ino);
+ agbno = XFS_INO_TO_AGBNO(mp, ino);
+ xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_INODES);
+ error = xfs_scrub_ag_init(sc, agno, &sa);
+ XFS_SCRUB_INODE_OP_ERROR_GOTO(out);
+
+ err2 = xfs_rmap_record_exists(sa.rmap_cur, agbno,
+ 1, &oinfo, &has_rmap);
+ if (xfs_scrub_should_xref(sc, err2, &sa.rmap_cur))
+ XFS_SCRUB_INODE_CHECK(has_rmap);
+ xfs_scrub_ag_free(&sa);
+ }
+
out:
if (bp)
xfs_trans_brelse(sc->tp, bp);
diff --git a/fs/xfs/repair/refcount.c b/fs/xfs/repair/refcount.c
index 38a8987..75071de 100644
--- a/fs/xfs/repair/refcount.c
+++ b/fs/xfs/repair/refcount.c
@@ -38,6 +38,163 @@
/* Reference count btree scrubber. */
+struct xfs_scrub_refcountbt_fragment {
+ struct xfs_rmap_irec rm;
+ struct list_head list;
+};
+
+struct xfs_scrub_refcountbt_rmap_check_info {
+ struct xfs_scrub_btree *bs;
+ xfs_nlink_t nr;
+ struct xfs_refcount_irec rc;
+ struct list_head fragments;
+};
+
+/*
+ * Decide if the given rmap is large enough that we can redeem it
+ * towards refcount verification now, or if it's a fragment, in
+ * which case we'll hang onto it in the hopes that we'll later
+ * discover that we've collected exactly the correct number of
+ * fragments as the refcountbt says we should have.
+ */
+STATIC int
+xfs_scrub_refcountbt_rmap_check(
+ struct xfs_btree_cur *cur,
+ struct xfs_rmap_irec *rec,
+ void *priv)
+{
+ struct xfs_scrub_refcountbt_rmap_check_info *rsrci = priv;
+ struct xfs_scrub_refcountbt_fragment *frag;
+ xfs_agblock_t rm_last;
+ xfs_agblock_t rc_last;
+
+ rm_last = rec->rm_startblock + rec->rm_blockcount;
+ rc_last = rsrci->rc.rc_startblock + rsrci->rc.rc_blockcount;
+ XFS_SCRUB_BTREC_CHECK(rsrci->bs, rsrci->rc.rc_refcount != 1 ||
+ rec->rm_owner == XFS_RMAP_OWN_COW);
+ if (rec->rm_startblock <= rsrci->rc.rc_startblock && rm_last >= rc_last)
+ rsrci->nr++;
+ else {
+ frag = kmem_zalloc(sizeof(struct xfs_scrub_refcountbt_fragment),
+ KM_SLEEP);
+ frag->rm = *rec;
+ list_add_tail(&frag->list, &rsrci->fragments);
+ }
+
+ return 0;
+}
+
+/*
+ * Given a bunch of rmap fragments, iterate through them, keeping
+ * a running tally of the refcount. If this ever deviates from
+ * what we expect (which is the refcountbt's refcount minus the
+ * number of extents that totally covered the refcountbt extent),
+ * we have a refcountbt error.
+ */
+STATIC void
+xfs_scrub_refcountbt_process_rmap_fragments(
+ struct xfs_mount *mp,
+ struct xfs_scrub_refcountbt_rmap_check_info *rsrci)
+{
+ struct list_head worklist;
+ struct xfs_scrub_refcountbt_fragment *cur;
+ struct xfs_scrub_refcountbt_fragment *n;
+ xfs_agblock_t bno;
+ xfs_agblock_t rbno;
+ xfs_agblock_t next_rbno;
+ xfs_nlink_t nr;
+ xfs_nlink_t target_nr;
+
+ target_nr = rsrci->rc.rc_refcount - rsrci->nr;
+ if (target_nr == 0)
+ return;
+
+ /*
+ * There are (rsrci->rc.rc_refcount - rsrci->nr refcount)
+ * references we haven't found yet. Pull that many off the
+ * fragment list and figure out where the smallest rmap ends
+ * (and therefore the next rmap should start). All the rmaps
+ * we pull off should start at or before the beginning of the
+ * refcount record's range.
+ */
+ INIT_LIST_HEAD(&worklist);
+ rbno = NULLAGBLOCK;
+ nr = 1;
+ list_for_each_entry_safe(cur, n, &rsrci->fragments, list) {
+ if (cur->rm.rm_startblock > rsrci->rc.rc_startblock)
+ goto fail;
+ bno = cur->rm.rm_startblock + cur->rm.rm_blockcount;
+ if (rbno > bno)
+ rbno = bno;
+ list_del(&cur->list);
+ list_add_tail(&cur->list, &worklist);
+ if (nr == target_nr)
+ break;
+ nr++;
+ }
+
+ if (nr != target_nr)
+ goto fail;
+
+ while (!list_empty(&rsrci->fragments)) {
+ /* Discard any fragments ending at rbno. */
+ nr = 0;
+ next_rbno = NULLAGBLOCK;
+ list_for_each_entry_safe(cur, n, &worklist, list) {
+ bno = cur->rm.rm_startblock + cur->rm.rm_blockcount;
+ if (bno != rbno) {
+ if (next_rbno > bno)
+ next_rbno = bno;
+ continue;
+ }
+ list_del(&cur->list);
+ kmem_free(cur);
+ nr++;
+ }
+
+ /* Empty list? We're done. */
+ if (list_empty(&rsrci->fragments))
+ break;
+
+ /* Try to add nr rmaps starting at rbno to the worklist. */
+ list_for_each_entry_safe(cur, n, &rsrci->fragments, list) {
+ bno = cur->rm.rm_startblock + cur->rm.rm_blockcount;
+ if (cur->rm.rm_startblock != rbno)
+ goto fail;
+ list_del(&cur->list);
+ list_add_tail(&cur->list, &worklist);
+ if (next_rbno > bno)
+ next_rbno = bno;
+ nr--;
+ if (nr == 0)
+ break;
+ }
+
+ rbno = next_rbno;
+ }
+
+ /*
+ * Make sure the last extent we processed ends at or beyond
+ * the end of the refcount extent.
+ */
+ if (rbno < rsrci->rc.rc_startblock + rsrci->rc.rc_blockcount)
+ goto fail;
+
+ rsrci->nr = rsrci->rc.rc_refcount;
+fail:
+ /* Delete fragments and work list. */
+ list_for_each_entry_safe(cur, n, &worklist, list) {
+ list_del(&cur->list);
+ kmem_free(cur);
+ }
+ list_for_each_entry_safe(cur, n, &rsrci->fragments, list) {
+ cur = list_first_entry(&rsrci->fragments,
+ struct xfs_scrub_refcountbt_fragment, list);
+ list_del(&cur->list);
+ kmem_free(cur);
+ }
+}
+
/* Scrub a refcountbt record. */
STATIC int
xfs_scrub_refcountbt_helper(
@@ -48,6 +205,11 @@ xfs_scrub_refcountbt_helper(
struct xfs_agf *agf;
struct xfs_scrub_ag *psa;
struct xfs_refcount_irec irec;
+ struct xfs_rmap_irec low;
+ struct xfs_rmap_irec high;
+ struct xfs_scrub_refcountbt_rmap_check_info rsrci;
+ struct xfs_scrub_refcountbt_fragment *cur;
+ struct xfs_scrub_refcountbt_fragment *n;
xfs_agblock_t eoag;
bool has_cowflag;
bool is_freesp;
@@ -109,6 +271,31 @@ xfs_scrub_refcountbt_helper(
XFS_SCRUB_BTREC_CHECK(bs, !has_inodes);
}
+ /* Cross-reference with the rmapbt to confirm the refcount. */
+ if (psa->rmap_cur) {
+ memset(&low, 0, sizeof(low));
+ low.rm_startblock = irec.rc_startblock;
+ memset(&high, 0xFF, sizeof(high));
+ high.rm_startblock = irec.rc_startblock +
+ irec.rc_blockcount - 1;
+
+ rsrci.bs = bs;
+ rsrci.nr = 0;
+ rsrci.rc = irec;
+ INIT_LIST_HEAD(&rsrci.fragments);
+ err2 = xfs_rmap_query_range(psa->rmap_cur, &low, &high,
+ &xfs_scrub_refcountbt_rmap_check, &rsrci);
+ if (xfs_scrub_btree_should_xref(bs, err2, &psa->rmap_cur)) {
+ xfs_scrub_refcountbt_process_rmap_fragments(mp, &rsrci);
+ XFS_SCRUB_BTREC_CHECK(bs, irec.rc_refcount == rsrci.nr);
+ }
+
+ list_for_each_entry_safe(cur, n, &rsrci.fragments, list) {
+ list_del(&cur->list);
+ kmem_free(cur);
+ }
+ }
+
out:
return error;
}
next prev parent reply other threads:[~2017-01-07 0:38 UTC|newest]
Thread overview: 55+ messages / expand[flat|nested] mbox.gz Atom feed top
2017-01-07 0:35 [PATCH v4 00/47] xfs: online scrub/repair support Darrick J. Wong
2017-01-07 0:35 ` [PATCH 01/47] xfs: plumb in needed functions for range querying of the freespace btrees Darrick J. Wong
2017-01-07 0:35 ` [PATCH 02/47] xfs: provide a query_range function for " Darrick J. Wong
2017-01-07 0:36 ` [PATCH 03/47] xfs: create a function to query all records in a btree Darrick J. Wong
2017-01-07 0:36 ` [PATCH 04/47] xfs: introduce the XFS_IOC_GETFSMAP ioctl Darrick J. Wong
2017-01-07 0:36 ` [PATCH 05/47] xfs: report shared extents in getfsmapx Darrick J. Wong
2017-01-07 0:36 ` [PATCH 06/47] xfs: have getfsmap fall back to the freesp btrees when rmap is not present Darrick J. Wong
2017-01-07 0:36 ` [PATCH 07/47] xfs: getfsmap should fall back to rtbitmap when rtrmapbt " Darrick J. Wong
2017-01-07 0:36 ` [PATCH 08/47] xfs: add scrub tracepoints Darrick J. Wong
2017-01-07 0:36 ` [PATCH 09/47] xfs: create an ioctl to scrub AG metadata Darrick J. Wong
2017-01-07 0:36 ` [PATCH 10/47] xfs: generic functions to scrub metadata and btrees Darrick J. Wong
2017-01-07 0:36 ` [PATCH 11/47] xfs: scrub the backup superblocks Darrick J. Wong
2017-01-07 0:37 ` [PATCH 12/47] xfs: scrub AGF and AGFL Darrick J. Wong
2017-01-07 0:37 ` [PATCH 13/47] xfs: scrub the AGI Darrick J. Wong
2017-01-07 0:37 ` [PATCH 14/47] xfs: support scrubbing free space btrees Darrick J. Wong
2017-01-07 0:37 ` [PATCH 15/47] xfs: support scrubbing inode btrees Darrick J. Wong
2017-01-07 0:37 ` [PATCH 16/47] xfs: support scrubbing rmap btree Darrick J. Wong
2017-01-07 0:37 ` [PATCH 17/47] xfs: support scrubbing refcount btree Darrick J. Wong
2017-01-07 0:37 ` [PATCH 18/47] xfs: scrub inodes Darrick J. Wong
2017-01-07 0:37 ` [PATCH 19/47] xfs: scrub inode block mappings Darrick J. Wong
2017-01-07 0:37 ` [PATCH 20/47] xfs: scrub directory/attribute btrees Darrick J. Wong
2017-01-07 0:38 ` [PATCH 21/47] xfs: scrub directory metadata Darrick J. Wong
2017-01-07 0:38 ` [PATCH 22/47] xfs: scrub extended attributes Darrick J. Wong
2017-01-07 0:38 ` [PATCH 23/47] xfs: scrub symbolic links Darrick J. Wong
2017-01-07 0:38 ` [PATCH 24/47] xfs: scrub realtime bitmap/summary Darrick J. Wong
2017-01-07 0:38 ` [PATCH 25/47] xfs: scrub should cross-reference with the bnobt Darrick J. Wong
2017-01-07 0:38 ` [PATCH 26/47] xfs: cross-reference bnobt records with cntbt Darrick J. Wong
2017-01-07 0:38 ` [PATCH 27/47] xfs: cross-reference extents with AG header Darrick J. Wong
2017-01-07 0:38 ` [PATCH 28/47] xfs: cross-reference inode btrees during scrub Darrick J. Wong
2017-01-07 0:38 ` Darrick J. Wong [this message]
2017-01-07 0:39 ` [PATCH 30/47] xfs: cross-reference refcount btree " Darrick J. Wong
2017-01-07 0:39 ` [PATCH 31/47] xfs: scrub should cross-reference the realtime bitmap Darrick J. Wong
2017-01-07 0:39 ` [PATCH 32/47] xfs: cross-reference the block mappings when possible Darrick J. Wong
2017-01-07 0:39 ` [PATCH 33/47] xfs: create tracepoints for online repair Darrick J. Wong
2017-01-07 0:39 ` [PATCH 34/47] xfs: implement the metadata repair ioctl flag Darrick J. Wong
2017-01-07 0:39 ` [PATCH 35/47] xfs: add helper routines for the repair code Darrick J. Wong
2017-01-07 0:39 ` [PATCH 36/47] xfs: repair superblocks Darrick J. Wong
2017-01-07 0:39 ` [PATCH 37/47] xfs: repair the AGF and AGFL Darrick J. Wong
2017-01-07 0:39 ` [PATCH 38/47] xfs: rebuild the AGI Darrick J. Wong
2017-01-07 0:39 ` [PATCH 39/47] xfs: repair free space btrees Darrick J. Wong
2017-01-07 0:40 ` [PATCH 40/47] xfs: repair inode btrees Darrick J. Wong
2017-01-07 0:40 ` [PATCH 41/47] xfs: rebuild the rmapbt Darrick J. Wong
2017-01-07 0:40 ` [PATCH 42/47] xfs: repair refcount btrees Darrick J. Wong
2017-01-07 0:40 ` [PATCH 43/47] xfs: online repair of inodes Darrick J. Wong
2017-01-07 0:40 ` [PATCH 44/47] xfs: repair inode block maps Darrick J. Wong
2017-01-07 0:40 ` [PATCH 45/47] xfs: repair damaged symlinks Darrick J. Wong
2017-01-07 0:40 ` [PATCH 46/47] xfs: query the per-AG reservation counters Darrick J. Wong
2017-01-07 0:40 ` [PATCH 47/47] xfs: avoid mount-time deadlock in CoW extent recovery Darrick J. Wong
2017-01-09 12:40 ` [PATCH v4 00/47] xfs: online scrub/repair support Amir Goldstein
2017-01-09 21:15 ` Darrick J. Wong
2017-01-10 7:54 ` Eryu Guan
2017-01-10 8:13 ` Amir Goldstein
2017-01-10 8:44 ` Eryu Guan
[not found] ` <CAOQ4uxiFg18fVh3RFr-Y1-XRmV82dTxc5r05QH8OFYpv2=juvg@mail.gmail.com>
[not found] ` <CAOQ4uxhTPt7t4-4MmQwogy+d4mgyG+=MX=12NX8R4V-hGR1q0w@mail.gmail.com>
2017-01-12 20:10 ` Darrick J. Wong
2017-01-10 18:20 ` Darrick J. Wong
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=148374953586.30431.8166127209244400711.stgit@birch.djwong.org \
--to=darrick.wong@oracle.com \
--cc=linux-xfs@vger.kernel.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.