* [PATCH 1/5] xfs: store inode btree block counts in AGI header
2020-09-02 2:55 [PATCH v4 0/5] xfs: add inode btree blocks counters to the AGI header Darrick J. Wong
@ 2020-09-02 2:55 ` Darrick J. Wong
2020-09-02 13:23 ` Brian Foster
2020-09-02 2:56 ` [PATCH 2/5] xfs: use the finobt block counts to speed up mount times Darrick J. Wong
` (3 subsequent siblings)
4 siblings, 1 reply; 11+ messages in thread
From: Darrick J. Wong @ 2020-09-02 2:55 UTC (permalink / raw)
To: darrick.wong, bfoster; +Cc: linux-xfs
From: Darrick J. Wong <darrick.wong@oracle.com>
Add a btree block usage counters for both inode btrees to the AGI header
so that we don't have to walk the entire finobt at mount time to create
the per-AG reservations.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
---
fs/xfs/libxfs/xfs_ag.c | 5 +++++
fs/xfs/libxfs/xfs_format.h | 18 +++++++++++++++++-
fs/xfs/libxfs/xfs_ialloc.c | 1 +
fs/xfs/libxfs/xfs_ialloc_btree.c | 24 ++++++++++++++++++++++++
fs/xfs/xfs_ondisk.h | 2 +-
fs/xfs/xfs_super.c | 4 ++++
6 files changed, 52 insertions(+), 2 deletions(-)
diff --git a/fs/xfs/libxfs/xfs_ag.c b/fs/xfs/libxfs/xfs_ag.c
index 8cf73fe4338e..9331f3516afa 100644
--- a/fs/xfs/libxfs/xfs_ag.c
+++ b/fs/xfs/libxfs/xfs_ag.c
@@ -333,6 +333,11 @@ xfs_agiblock_init(
}
for (bucket = 0; bucket < XFS_AGI_UNLINKED_BUCKETS; bucket++)
agi->agi_unlinked[bucket] = cpu_to_be32(NULLAGINO);
+ if (xfs_sb_version_hasinobtcounts(&mp->m_sb)) {
+ agi->agi_iblocks = cpu_to_be32(1);
+ if (xfs_sb_version_hasfinobt(&mp->m_sb))
+ agi->agi_fblocks = cpu_to_be32(1);
+ }
}
typedef void (*aghdr_init_work_f)(struct xfs_mount *mp, struct xfs_buf *bp,
diff --git a/fs/xfs/libxfs/xfs_format.h b/fs/xfs/libxfs/xfs_format.h
index 31b7ece985bb..03cbedb7eafc 100644
--- a/fs/xfs/libxfs/xfs_format.h
+++ b/fs/xfs/libxfs/xfs_format.h
@@ -449,6 +449,7 @@ xfs_sb_has_compat_feature(
#define XFS_SB_FEAT_RO_COMPAT_FINOBT (1 << 0) /* free inode btree */
#define XFS_SB_FEAT_RO_COMPAT_RMAPBT (1 << 1) /* reverse map btree */
#define XFS_SB_FEAT_RO_COMPAT_REFLINK (1 << 2) /* reflinked files */
+#define XFS_SB_FEAT_RO_COMPAT_INOBTCNT (1 << 3) /* inobt block counts */
#define XFS_SB_FEAT_RO_COMPAT_ALL \
(XFS_SB_FEAT_RO_COMPAT_FINOBT | \
XFS_SB_FEAT_RO_COMPAT_RMAPBT | \
@@ -563,6 +564,17 @@ static inline bool xfs_sb_version_hasreflink(struct xfs_sb *sbp)
(sbp->sb_features_ro_compat & XFS_SB_FEAT_RO_COMPAT_REFLINK);
}
+/*
+ * Inode btree block counter. We record the number of inobt and finobt blocks
+ * in the AGI header so that we can skip the finobt walk at mount time when
+ * setting up per-AG reservations.
+ */
+static inline bool xfs_sb_version_hasinobtcounts(struct xfs_sb *sbp)
+{
+ return XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_5 &&
+ (sbp->sb_features_ro_compat & XFS_SB_FEAT_RO_COMPAT_INOBTCNT);
+}
+
/*
* end of superblock version macros
*/
@@ -765,6 +777,9 @@ typedef struct xfs_agi {
__be32 agi_free_root; /* root of the free inode btree */
__be32 agi_free_level;/* levels in free inode btree */
+ __be32 agi_iblocks; /* inobt blocks used */
+ __be32 agi_fblocks; /* finobt blocks used */
+
/* structure must be padded to 64 bit alignment */
} xfs_agi_t;
@@ -785,7 +800,8 @@ typedef struct xfs_agi {
#define XFS_AGI_ALL_BITS_R1 ((1 << XFS_AGI_NUM_BITS_R1) - 1)
#define XFS_AGI_FREE_ROOT (1 << 11)
#define XFS_AGI_FREE_LEVEL (1 << 12)
-#define XFS_AGI_NUM_BITS_R2 13
+#define XFS_AGI_IBLOCKS (1 << 13) /* both inobt/finobt block counters */
+#define XFS_AGI_NUM_BITS_R2 14
/* disk block (xfs_daddr_t) in the AG */
#define XFS_AGI_DADDR(mp) ((xfs_daddr_t)(2 << (mp)->m_sectbb_log))
diff --git a/fs/xfs/libxfs/xfs_ialloc.c b/fs/xfs/libxfs/xfs_ialloc.c
index f742a96a2fe1..fef1d94c60a4 100644
--- a/fs/xfs/libxfs/xfs_ialloc.c
+++ b/fs/xfs/libxfs/xfs_ialloc.c
@@ -2473,6 +2473,7 @@ xfs_ialloc_log_agi(
offsetof(xfs_agi_t, agi_unlinked),
offsetof(xfs_agi_t, agi_free_root),
offsetof(xfs_agi_t, agi_free_level),
+ offsetof(xfs_agi_t, agi_iblocks),
sizeof(xfs_agi_t)
};
#ifdef DEBUG
diff --git a/fs/xfs/libxfs/xfs_ialloc_btree.c b/fs/xfs/libxfs/xfs_ialloc_btree.c
index 3c8aebc36e64..cf51b342b6ef 100644
--- a/fs/xfs/libxfs/xfs_ialloc_btree.c
+++ b/fs/xfs/libxfs/xfs_ialloc_btree.c
@@ -67,6 +67,28 @@ xfs_finobt_set_root(
XFS_AGI_FREE_ROOT | XFS_AGI_FREE_LEVEL);
}
+/* Update the inode btree block counter for this btree. */
+static inline void
+xfs_inobt_mod_blockcount(
+ struct xfs_btree_cur *cur,
+ int howmuch)
+{
+ struct xfs_buf *agbp = cur->bc_ag.agbp;
+ struct xfs_agi *agi = agbp->b_addr;
+
+ if (!xfs_sb_version_hasinobtcounts(&cur->bc_mp->m_sb))
+ return;
+
+ if (cur->bc_btnum == XFS_BTNUM_FINO &&
+ xfs_sb_version_hasfinobt(&cur->bc_mp->m_sb)) {
+ be32_add_cpu(&agi->agi_fblocks, howmuch);
+ xfs_ialloc_log_agi(cur->bc_tp, agbp, XFS_AGI_IBLOCKS);
+ } else if (cur->bc_btnum == XFS_BTNUM_INO) {
+ be32_add_cpu(&agi->agi_iblocks, howmuch);
+ xfs_ialloc_log_agi(cur->bc_tp, agbp, XFS_AGI_IBLOCKS);
+ }
+}
+
STATIC int
__xfs_inobt_alloc_block(
struct xfs_btree_cur *cur,
@@ -102,6 +124,7 @@ __xfs_inobt_alloc_block(
new->s = cpu_to_be32(XFS_FSB_TO_AGBNO(args.mp, args.fsbno));
*stat = 1;
+ xfs_inobt_mod_blockcount(cur, 1);
return 0;
}
@@ -134,6 +157,7 @@ __xfs_inobt_free_block(
struct xfs_buf *bp,
enum xfs_ag_resv_type resv)
{
+ xfs_inobt_mod_blockcount(cur, -1);
return xfs_free_extent(cur->bc_tp,
XFS_DADDR_TO_FSB(cur->bc_mp, XFS_BUF_ADDR(bp)), 1,
&XFS_RMAP_OINFO_INOBT, resv);
diff --git a/fs/xfs/xfs_ondisk.h b/fs/xfs/xfs_ondisk.h
index 5f04d8a5ab2a..acb9b737fe6b 100644
--- a/fs/xfs/xfs_ondisk.h
+++ b/fs/xfs/xfs_ondisk.h
@@ -23,7 +23,7 @@ xfs_check_ondisk_structs(void)
XFS_CHECK_STRUCT_SIZE(struct xfs_acl_entry, 12);
XFS_CHECK_STRUCT_SIZE(struct xfs_agf, 224);
XFS_CHECK_STRUCT_SIZE(struct xfs_agfl, 36);
- XFS_CHECK_STRUCT_SIZE(struct xfs_agi, 336);
+ XFS_CHECK_STRUCT_SIZE(struct xfs_agi, 344);
XFS_CHECK_STRUCT_SIZE(struct xfs_bmbt_key, 8);
XFS_CHECK_STRUCT_SIZE(struct xfs_bmbt_rec, 16);
XFS_CHECK_STRUCT_SIZE(struct xfs_bmdr_block, 4);
diff --git a/fs/xfs/xfs_super.c b/fs/xfs/xfs_super.c
index 71ac6c1cdc36..c7ffcb57b586 100644
--- a/fs/xfs/xfs_super.c
+++ b/fs/xfs/xfs_super.c
@@ -1549,6 +1549,10 @@ xfs_fc_fill_super(
goto out_filestream_unmount;
}
+ if (xfs_sb_version_hasinobtcounts(&mp->m_sb))
+ xfs_warn(mp,
+ "EXPERIMENTAL inode btree counters feature in use. Use at your own risk!");
+
error = xfs_mountfs(mp);
if (error)
goto out_filestream_unmount;
^ permalink raw reply related [flat|nested] 11+ messages in thread* Re: [PATCH 1/5] xfs: store inode btree block counts in AGI header
2020-09-02 2:55 ` [PATCH 1/5] xfs: store inode btree block counts in " Darrick J. Wong
@ 2020-09-02 13:23 ` Brian Foster
2020-09-02 17:13 ` Darrick J. Wong
0 siblings, 1 reply; 11+ messages in thread
From: Brian Foster @ 2020-09-02 13:23 UTC (permalink / raw)
To: Darrick J. Wong; +Cc: linux-xfs
On Tue, Sep 01, 2020 at 07:55:58PM -0700, Darrick J. Wong wrote:
> From: Darrick J. Wong <darrick.wong@oracle.com>
>
> Add a btree block usage counters for both inode btrees to the AGI header
> so that we don't have to walk the entire finobt at mount time to create
> the per-AG reservations.
>
> Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
> ---
A couple nits..
> fs/xfs/libxfs/xfs_ag.c | 5 +++++
> fs/xfs/libxfs/xfs_format.h | 18 +++++++++++++++++-
> fs/xfs/libxfs/xfs_ialloc.c | 1 +
> fs/xfs/libxfs/xfs_ialloc_btree.c | 24 ++++++++++++++++++++++++
> fs/xfs/xfs_ondisk.h | 2 +-
> fs/xfs/xfs_super.c | 4 ++++
> 6 files changed, 52 insertions(+), 2 deletions(-)
>
>
> diff --git a/fs/xfs/libxfs/xfs_ag.c b/fs/xfs/libxfs/xfs_ag.c
> index 8cf73fe4338e..9331f3516afa 100644
> --- a/fs/xfs/libxfs/xfs_ag.c
> +++ b/fs/xfs/libxfs/xfs_ag.c
> @@ -333,6 +333,11 @@ xfs_agiblock_init(
> }
> for (bucket = 0; bucket < XFS_AGI_UNLINKED_BUCKETS; bucket++)
> agi->agi_unlinked[bucket] = cpu_to_be32(NULLAGINO);
> + if (xfs_sb_version_hasinobtcounts(&mp->m_sb)) {
> + agi->agi_iblocks = cpu_to_be32(1);
> + if (xfs_sb_version_hasfinobt(&mp->m_sb))
> + agi->agi_fblocks = cpu_to_be32(1);
> + }
> }
>
> typedef void (*aghdr_init_work_f)(struct xfs_mount *mp, struct xfs_buf *bp,
> diff --git a/fs/xfs/libxfs/xfs_format.h b/fs/xfs/libxfs/xfs_format.h
> index 31b7ece985bb..03cbedb7eafc 100644
> --- a/fs/xfs/libxfs/xfs_format.h
> +++ b/fs/xfs/libxfs/xfs_format.h
> @@ -449,6 +449,7 @@ xfs_sb_has_compat_feature(
> #define XFS_SB_FEAT_RO_COMPAT_FINOBT (1 << 0) /* free inode btree */
> #define XFS_SB_FEAT_RO_COMPAT_RMAPBT (1 << 1) /* reverse map btree */
> #define XFS_SB_FEAT_RO_COMPAT_REFLINK (1 << 2) /* reflinked files */
> +#define XFS_SB_FEAT_RO_COMPAT_INOBTCNT (1 << 3) /* inobt block counts */
> #define XFS_SB_FEAT_RO_COMPAT_ALL \
> (XFS_SB_FEAT_RO_COMPAT_FINOBT | \
> XFS_SB_FEAT_RO_COMPAT_RMAPBT | \
> @@ -563,6 +564,17 @@ static inline bool xfs_sb_version_hasreflink(struct xfs_sb *sbp)
> (sbp->sb_features_ro_compat & XFS_SB_FEAT_RO_COMPAT_REFLINK);
> }
>
> +/*
> + * Inode btree block counter. We record the number of inobt and finobt blocks
> + * in the AGI header so that we can skip the finobt walk at mount time when
> + * setting up per-AG reservations.
> + */
> +static inline bool xfs_sb_version_hasinobtcounts(struct xfs_sb *sbp)
> +{
> + return XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_5 &&
> + (sbp->sb_features_ro_compat & XFS_SB_FEAT_RO_COMPAT_INOBTCNT);
> +}
> +
> /*
> * end of superblock version macros
> */
> @@ -765,6 +777,9 @@ typedef struct xfs_agi {
> __be32 agi_free_root; /* root of the free inode btree */
> __be32 agi_free_level;/* levels in free inode btree */
>
> + __be32 agi_iblocks; /* inobt blocks used */
> + __be32 agi_fblocks; /* finobt blocks used */
> +
> /* structure must be padded to 64 bit alignment */
> } xfs_agi_t;
>
> @@ -785,7 +800,8 @@ typedef struct xfs_agi {
> #define XFS_AGI_ALL_BITS_R1 ((1 << XFS_AGI_NUM_BITS_R1) - 1)
> #define XFS_AGI_FREE_ROOT (1 << 11)
> #define XFS_AGI_FREE_LEVEL (1 << 12)
> -#define XFS_AGI_NUM_BITS_R2 13
> +#define XFS_AGI_IBLOCKS (1 << 13) /* both inobt/finobt block counters */
> +#define XFS_AGI_NUM_BITS_R2 14
I still find it a little odd that we'd log both fields if only one might
be supported/modified, as opposed to just tracking them both
independently with a couple extra lines of code. That said, I don't see
it as a functional problem that couldn't be fixed later.
>
> /* disk block (xfs_daddr_t) in the AG */
> #define XFS_AGI_DADDR(mp) ((xfs_daddr_t)(2 << (mp)->m_sectbb_log))
> diff --git a/fs/xfs/libxfs/xfs_ialloc.c b/fs/xfs/libxfs/xfs_ialloc.c
> index f742a96a2fe1..fef1d94c60a4 100644
> --- a/fs/xfs/libxfs/xfs_ialloc.c
> +++ b/fs/xfs/libxfs/xfs_ialloc.c
> @@ -2473,6 +2473,7 @@ xfs_ialloc_log_agi(
> offsetof(xfs_agi_t, agi_unlinked),
> offsetof(xfs_agi_t, agi_free_root),
> offsetof(xfs_agi_t, agi_free_level),
> + offsetof(xfs_agi_t, agi_iblocks),
> sizeof(xfs_agi_t)
> };
> #ifdef DEBUG
> diff --git a/fs/xfs/libxfs/xfs_ialloc_btree.c b/fs/xfs/libxfs/xfs_ialloc_btree.c
> index 3c8aebc36e64..cf51b342b6ef 100644
> --- a/fs/xfs/libxfs/xfs_ialloc_btree.c
> +++ b/fs/xfs/libxfs/xfs_ialloc_btree.c
> @@ -67,6 +67,28 @@ xfs_finobt_set_root(
> XFS_AGI_FREE_ROOT | XFS_AGI_FREE_LEVEL);
> }
>
> +/* Update the inode btree block counter for this btree. */
> +static inline void
> +xfs_inobt_mod_blockcount(
> + struct xfs_btree_cur *cur,
> + int howmuch)
> +{
> + struct xfs_buf *agbp = cur->bc_ag.agbp;
> + struct xfs_agi *agi = agbp->b_addr;
> +
> + if (!xfs_sb_version_hasinobtcounts(&cur->bc_mp->m_sb))
> + return;
> +
> + if (cur->bc_btnum == XFS_BTNUM_FINO &&
> + xfs_sb_version_hasfinobt(&cur->bc_mp->m_sb)) {
This check might be spurious because I suspect you wouldn't get a finobt
cursor without the feature enabled. Those nits aside:
Reviewed-by: Brian Foster <bfoster@redhat.com>
> + be32_add_cpu(&agi->agi_fblocks, howmuch);
> + xfs_ialloc_log_agi(cur->bc_tp, agbp, XFS_AGI_IBLOCKS);
> + } else if (cur->bc_btnum == XFS_BTNUM_INO) {
> + be32_add_cpu(&agi->agi_iblocks, howmuch);
> + xfs_ialloc_log_agi(cur->bc_tp, agbp, XFS_AGI_IBLOCKS);
> + }
> +}
> +
> STATIC int
> __xfs_inobt_alloc_block(
> struct xfs_btree_cur *cur,
> @@ -102,6 +124,7 @@ __xfs_inobt_alloc_block(
>
> new->s = cpu_to_be32(XFS_FSB_TO_AGBNO(args.mp, args.fsbno));
> *stat = 1;
> + xfs_inobt_mod_blockcount(cur, 1);
> return 0;
> }
>
> @@ -134,6 +157,7 @@ __xfs_inobt_free_block(
> struct xfs_buf *bp,
> enum xfs_ag_resv_type resv)
> {
> + xfs_inobt_mod_blockcount(cur, -1);
> return xfs_free_extent(cur->bc_tp,
> XFS_DADDR_TO_FSB(cur->bc_mp, XFS_BUF_ADDR(bp)), 1,
> &XFS_RMAP_OINFO_INOBT, resv);
> diff --git a/fs/xfs/xfs_ondisk.h b/fs/xfs/xfs_ondisk.h
> index 5f04d8a5ab2a..acb9b737fe6b 100644
> --- a/fs/xfs/xfs_ondisk.h
> +++ b/fs/xfs/xfs_ondisk.h
> @@ -23,7 +23,7 @@ xfs_check_ondisk_structs(void)
> XFS_CHECK_STRUCT_SIZE(struct xfs_acl_entry, 12);
> XFS_CHECK_STRUCT_SIZE(struct xfs_agf, 224);
> XFS_CHECK_STRUCT_SIZE(struct xfs_agfl, 36);
> - XFS_CHECK_STRUCT_SIZE(struct xfs_agi, 336);
> + XFS_CHECK_STRUCT_SIZE(struct xfs_agi, 344);
> XFS_CHECK_STRUCT_SIZE(struct xfs_bmbt_key, 8);
> XFS_CHECK_STRUCT_SIZE(struct xfs_bmbt_rec, 16);
> XFS_CHECK_STRUCT_SIZE(struct xfs_bmdr_block, 4);
> diff --git a/fs/xfs/xfs_super.c b/fs/xfs/xfs_super.c
> index 71ac6c1cdc36..c7ffcb57b586 100644
> --- a/fs/xfs/xfs_super.c
> +++ b/fs/xfs/xfs_super.c
> @@ -1549,6 +1549,10 @@ xfs_fc_fill_super(
> goto out_filestream_unmount;
> }
>
> + if (xfs_sb_version_hasinobtcounts(&mp->m_sb))
> + xfs_warn(mp,
> + "EXPERIMENTAL inode btree counters feature in use. Use at your own risk!");
> +
> error = xfs_mountfs(mp);
> if (error)
> goto out_filestream_unmount;
>
^ permalink raw reply [flat|nested] 11+ messages in thread* Re: [PATCH 1/5] xfs: store inode btree block counts in AGI header
2020-09-02 13:23 ` Brian Foster
@ 2020-09-02 17:13 ` Darrick J. Wong
0 siblings, 0 replies; 11+ messages in thread
From: Darrick J. Wong @ 2020-09-02 17:13 UTC (permalink / raw)
To: Brian Foster; +Cc: linux-xfs
On Wed, Sep 02, 2020 at 09:23:36AM -0400, Brian Foster wrote:
> On Tue, Sep 01, 2020 at 07:55:58PM -0700, Darrick J. Wong wrote:
> > From: Darrick J. Wong <darrick.wong@oracle.com>
> >
> > Add a btree block usage counters for both inode btrees to the AGI header
> > so that we don't have to walk the entire finobt at mount time to create
> > the per-AG reservations.
> >
> > Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
> > ---
>
> A couple nits..
>
> > fs/xfs/libxfs/xfs_ag.c | 5 +++++
> > fs/xfs/libxfs/xfs_format.h | 18 +++++++++++++++++-
> > fs/xfs/libxfs/xfs_ialloc.c | 1 +
> > fs/xfs/libxfs/xfs_ialloc_btree.c | 24 ++++++++++++++++++++++++
> > fs/xfs/xfs_ondisk.h | 2 +-
> > fs/xfs/xfs_super.c | 4 ++++
> > 6 files changed, 52 insertions(+), 2 deletions(-)
> >
> >
> > diff --git a/fs/xfs/libxfs/xfs_ag.c b/fs/xfs/libxfs/xfs_ag.c
> > index 8cf73fe4338e..9331f3516afa 100644
> > --- a/fs/xfs/libxfs/xfs_ag.c
> > +++ b/fs/xfs/libxfs/xfs_ag.c
> > @@ -333,6 +333,11 @@ xfs_agiblock_init(
> > }
> > for (bucket = 0; bucket < XFS_AGI_UNLINKED_BUCKETS; bucket++)
> > agi->agi_unlinked[bucket] = cpu_to_be32(NULLAGINO);
> > + if (xfs_sb_version_hasinobtcounts(&mp->m_sb)) {
> > + agi->agi_iblocks = cpu_to_be32(1);
> > + if (xfs_sb_version_hasfinobt(&mp->m_sb))
> > + agi->agi_fblocks = cpu_to_be32(1);
> > + }
> > }
> >
> > typedef void (*aghdr_init_work_f)(struct xfs_mount *mp, struct xfs_buf *bp,
> > diff --git a/fs/xfs/libxfs/xfs_format.h b/fs/xfs/libxfs/xfs_format.h
> > index 31b7ece985bb..03cbedb7eafc 100644
> > --- a/fs/xfs/libxfs/xfs_format.h
> > +++ b/fs/xfs/libxfs/xfs_format.h
> > @@ -449,6 +449,7 @@ xfs_sb_has_compat_feature(
> > #define XFS_SB_FEAT_RO_COMPAT_FINOBT (1 << 0) /* free inode btree */
> > #define XFS_SB_FEAT_RO_COMPAT_RMAPBT (1 << 1) /* reverse map btree */
> > #define XFS_SB_FEAT_RO_COMPAT_REFLINK (1 << 2) /* reflinked files */
> > +#define XFS_SB_FEAT_RO_COMPAT_INOBTCNT (1 << 3) /* inobt block counts */
> > #define XFS_SB_FEAT_RO_COMPAT_ALL \
> > (XFS_SB_FEAT_RO_COMPAT_FINOBT | \
> > XFS_SB_FEAT_RO_COMPAT_RMAPBT | \
> > @@ -563,6 +564,17 @@ static inline bool xfs_sb_version_hasreflink(struct xfs_sb *sbp)
> > (sbp->sb_features_ro_compat & XFS_SB_FEAT_RO_COMPAT_REFLINK);
> > }
> >
> > +/*
> > + * Inode btree block counter. We record the number of inobt and finobt blocks
> > + * in the AGI header so that we can skip the finobt walk at mount time when
> > + * setting up per-AG reservations.
> > + */
> > +static inline bool xfs_sb_version_hasinobtcounts(struct xfs_sb *sbp)
> > +{
> > + return XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_5 &&
> > + (sbp->sb_features_ro_compat & XFS_SB_FEAT_RO_COMPAT_INOBTCNT);
> > +}
> > +
> > /*
> > * end of superblock version macros
> > */
> > @@ -765,6 +777,9 @@ typedef struct xfs_agi {
> > __be32 agi_free_root; /* root of the free inode btree */
> > __be32 agi_free_level;/* levels in free inode btree */
> >
> > + __be32 agi_iblocks; /* inobt blocks used */
> > + __be32 agi_fblocks; /* finobt blocks used */
> > +
> > /* structure must be padded to 64 bit alignment */
> > } xfs_agi_t;
> >
> > @@ -785,7 +800,8 @@ typedef struct xfs_agi {
> > #define XFS_AGI_ALL_BITS_R1 ((1 << XFS_AGI_NUM_BITS_R1) - 1)
> > #define XFS_AGI_FREE_ROOT (1 << 11)
> > #define XFS_AGI_FREE_LEVEL (1 << 12)
> > -#define XFS_AGI_NUM_BITS_R2 13
> > +#define XFS_AGI_IBLOCKS (1 << 13) /* both inobt/finobt block counters */
> > +#define XFS_AGI_NUM_BITS_R2 14
>
> I still find it a little odd that we'd log both fields if only one might
> be supported/modified, as opposed to just tracking them both
> independently with a couple extra lines of code. That said, I don't see
> it as a functional problem that couldn't be fixed later.
Yeah. I didn't want to go burning two bits for this since in all
likelihood the finobt will be enabled anytime inobtcounts are active.
I guess we could revisit that if someone uses db to frankenstein a
filesystem into having inobtcounts without a finobt and shows that the
overhead makes a difference, but the xfs_admin and mkfs tools aren't
going to allow that combination.
> >
> > /* disk block (xfs_daddr_t) in the AG */
> > #define XFS_AGI_DADDR(mp) ((xfs_daddr_t)(2 << (mp)->m_sectbb_log))
> > diff --git a/fs/xfs/libxfs/xfs_ialloc.c b/fs/xfs/libxfs/xfs_ialloc.c
> > index f742a96a2fe1..fef1d94c60a4 100644
> > --- a/fs/xfs/libxfs/xfs_ialloc.c
> > +++ b/fs/xfs/libxfs/xfs_ialloc.c
> > @@ -2473,6 +2473,7 @@ xfs_ialloc_log_agi(
> > offsetof(xfs_agi_t, agi_unlinked),
> > offsetof(xfs_agi_t, agi_free_root),
> > offsetof(xfs_agi_t, agi_free_level),
> > + offsetof(xfs_agi_t, agi_iblocks),
> > sizeof(xfs_agi_t)
> > };
> > #ifdef DEBUG
> > diff --git a/fs/xfs/libxfs/xfs_ialloc_btree.c b/fs/xfs/libxfs/xfs_ialloc_btree.c
> > index 3c8aebc36e64..cf51b342b6ef 100644
> > --- a/fs/xfs/libxfs/xfs_ialloc_btree.c
> > +++ b/fs/xfs/libxfs/xfs_ialloc_btree.c
> > @@ -67,6 +67,28 @@ xfs_finobt_set_root(
> > XFS_AGI_FREE_ROOT | XFS_AGI_FREE_LEVEL);
> > }
> >
> > +/* Update the inode btree block counter for this btree. */
> > +static inline void
> > +xfs_inobt_mod_blockcount(
> > + struct xfs_btree_cur *cur,
> > + int howmuch)
> > +{
> > + struct xfs_buf *agbp = cur->bc_ag.agbp;
> > + struct xfs_agi *agi = agbp->b_addr;
> > +
> > + if (!xfs_sb_version_hasinobtcounts(&cur->bc_mp->m_sb))
> > + return;
> > +
> > + if (cur->bc_btnum == XFS_BTNUM_FINO &&
> > + xfs_sb_version_hasfinobt(&cur->bc_mp->m_sb)) {
>
> This check might be spurious because I suspect you wouldn't get a finobt
> cursor without the feature enabled. Those nits aside:
Heh, yeah. I'll fix that one up, at least. Thanks for the review!
--D
> Reviewed-by: Brian Foster <bfoster@redhat.com>
>
> > + be32_add_cpu(&agi->agi_fblocks, howmuch);
> > + xfs_ialloc_log_agi(cur->bc_tp, agbp, XFS_AGI_IBLOCKS);
> > + } else if (cur->bc_btnum == XFS_BTNUM_INO) {
> > + be32_add_cpu(&agi->agi_iblocks, howmuch);
> > + xfs_ialloc_log_agi(cur->bc_tp, agbp, XFS_AGI_IBLOCKS);
> > + }
> > +}
> > +
> > STATIC int
> > __xfs_inobt_alloc_block(
> > struct xfs_btree_cur *cur,
> > @@ -102,6 +124,7 @@ __xfs_inobt_alloc_block(
> >
> > new->s = cpu_to_be32(XFS_FSB_TO_AGBNO(args.mp, args.fsbno));
> > *stat = 1;
> > + xfs_inobt_mod_blockcount(cur, 1);
> > return 0;
> > }
> >
> > @@ -134,6 +157,7 @@ __xfs_inobt_free_block(
> > struct xfs_buf *bp,
> > enum xfs_ag_resv_type resv)
> > {
> > + xfs_inobt_mod_blockcount(cur, -1);
> > return xfs_free_extent(cur->bc_tp,
> > XFS_DADDR_TO_FSB(cur->bc_mp, XFS_BUF_ADDR(bp)), 1,
> > &XFS_RMAP_OINFO_INOBT, resv);
> > diff --git a/fs/xfs/xfs_ondisk.h b/fs/xfs/xfs_ondisk.h
> > index 5f04d8a5ab2a..acb9b737fe6b 100644
> > --- a/fs/xfs/xfs_ondisk.h
> > +++ b/fs/xfs/xfs_ondisk.h
> > @@ -23,7 +23,7 @@ xfs_check_ondisk_structs(void)
> > XFS_CHECK_STRUCT_SIZE(struct xfs_acl_entry, 12);
> > XFS_CHECK_STRUCT_SIZE(struct xfs_agf, 224);
> > XFS_CHECK_STRUCT_SIZE(struct xfs_agfl, 36);
> > - XFS_CHECK_STRUCT_SIZE(struct xfs_agi, 336);
> > + XFS_CHECK_STRUCT_SIZE(struct xfs_agi, 344);
> > XFS_CHECK_STRUCT_SIZE(struct xfs_bmbt_key, 8);
> > XFS_CHECK_STRUCT_SIZE(struct xfs_bmbt_rec, 16);
> > XFS_CHECK_STRUCT_SIZE(struct xfs_bmdr_block, 4);
> > diff --git a/fs/xfs/xfs_super.c b/fs/xfs/xfs_super.c
> > index 71ac6c1cdc36..c7ffcb57b586 100644
> > --- a/fs/xfs/xfs_super.c
> > +++ b/fs/xfs/xfs_super.c
> > @@ -1549,6 +1549,10 @@ xfs_fc_fill_super(
> > goto out_filestream_unmount;
> > }
> >
> > + if (xfs_sb_version_hasinobtcounts(&mp->m_sb))
> > + xfs_warn(mp,
> > + "EXPERIMENTAL inode btree counters feature in use. Use at your own risk!");
> > +
> > error = xfs_mountfs(mp);
> > if (error)
> > goto out_filestream_unmount;
> >
>
^ permalink raw reply [flat|nested] 11+ messages in thread
* [PATCH 2/5] xfs: use the finobt block counts to speed up mount times
2020-09-02 2:55 [PATCH v4 0/5] xfs: add inode btree blocks counters to the AGI header Darrick J. Wong
2020-09-02 2:55 ` [PATCH 1/5] xfs: store inode btree block counts in " Darrick J. Wong
@ 2020-09-02 2:56 ` Darrick J. Wong
2020-09-02 2:56 ` [PATCH 3/5] xfs: support inode btree blockcounts in online scrub Darrick J. Wong
` (2 subsequent siblings)
4 siblings, 0 replies; 11+ messages in thread
From: Darrick J. Wong @ 2020-09-02 2:56 UTC (permalink / raw)
To: darrick.wong, bfoster; +Cc: linux-xfs
From: Darrick J. Wong <darrick.wong@oracle.com>
Now that we have reliable finobt block counts, use them to speed up the
per-AG block reservation calculations at mount time.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
---
fs/xfs/libxfs/xfs_ialloc_btree.c | 28 +++++++++++++++++++++++++++-
1 file changed, 27 insertions(+), 1 deletion(-)
diff --git a/fs/xfs/libxfs/xfs_ialloc_btree.c b/fs/xfs/libxfs/xfs_ialloc_btree.c
index cf51b342b6ef..1df04e48bd87 100644
--- a/fs/xfs/libxfs/xfs_ialloc_btree.c
+++ b/fs/xfs/libxfs/xfs_ialloc_btree.c
@@ -697,6 +697,28 @@ xfs_inobt_count_blocks(
return error;
}
+/* Read finobt block count from AGI header. */
+static int
+xfs_finobt_read_blocks(
+ struct xfs_mount *mp,
+ struct xfs_trans *tp,
+ xfs_agnumber_t agno,
+ xfs_extlen_t *tree_blocks)
+{
+ struct xfs_buf *agbp;
+ struct xfs_agi *agi;
+ int error;
+
+ error = xfs_ialloc_read_agi(mp, tp, agno, &agbp);
+ if (error)
+ return error;
+
+ agi = agbp->b_addr;
+ *tree_blocks = be32_to_cpu(agi->agi_fblocks);
+ xfs_trans_brelse(tp, agbp);
+ return 0;
+}
+
/*
* Figure out how many blocks to reserve and how many are used by this btree.
*/
@@ -714,7 +736,11 @@ xfs_finobt_calc_reserves(
if (!xfs_sb_version_hasfinobt(&mp->m_sb))
return 0;
- error = xfs_inobt_count_blocks(mp, tp, agno, XFS_BTNUM_FINO, &tree_len);
+ if (xfs_sb_version_hasinobtcounts(&mp->m_sb))
+ error = xfs_finobt_read_blocks(mp, tp, agno, &tree_len);
+ else
+ error = xfs_inobt_count_blocks(mp, tp, agno, XFS_BTNUM_FINO,
+ &tree_len);
if (error)
return error;
^ permalink raw reply related [flat|nested] 11+ messages in thread* [PATCH 3/5] xfs: support inode btree blockcounts in online scrub
2020-09-02 2:55 [PATCH v4 0/5] xfs: add inode btree blocks counters to the AGI header Darrick J. Wong
2020-09-02 2:55 ` [PATCH 1/5] xfs: store inode btree block counts in " Darrick J. Wong
2020-09-02 2:56 ` [PATCH 2/5] xfs: use the finobt block counts to speed up mount times Darrick J. Wong
@ 2020-09-02 2:56 ` Darrick J. Wong
2020-09-02 2:56 ` [PATCH 4/5] xfs: support inode btree blockcounts in online repair Darrick J. Wong
2020-09-02 2:56 ` [PATCH 5/5] xfs: enable new inode btree counters feature Darrick J. Wong
4 siblings, 0 replies; 11+ messages in thread
From: Darrick J. Wong @ 2020-09-02 2:56 UTC (permalink / raw)
To: darrick.wong, bfoster; +Cc: linux-xfs
From: Darrick J. Wong <darrick.wong@oracle.com>
Add the necessary bits to the online scrub code to check the inode btree
counters when enabled.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
---
| 30 ++++++++++++++++++++++++++++++
1 file changed, 30 insertions(+)
--git a/fs/xfs/scrub/agheader.c b/fs/xfs/scrub/agheader.c
index e9bcf1faa183..ae8e2e0ac64a 100644
--- a/fs/xfs/scrub/agheader.c
+++ b/fs/xfs/scrub/agheader.c
@@ -781,6 +781,35 @@ xchk_agi_xref_icounts(
xchk_block_xref_set_corrupt(sc, sc->sa.agi_bp);
}
+/* Check agi_[fi]blocks against tree size */
+static inline void
+xchk_agi_xref_fiblocks(
+ struct xfs_scrub *sc)
+{
+ struct xfs_agi *agi = sc->sa.agi_bp->b_addr;
+ xfs_agblock_t blocks;
+ int error = 0;
+
+ if (!xfs_sb_version_hasinobtcounts(&sc->mp->m_sb))
+ return;
+
+ if (sc->sa.ino_cur) {
+ error = xfs_btree_count_blocks(sc->sa.ino_cur, &blocks);
+ if (!xchk_should_check_xref(sc, &error, &sc->sa.ino_cur))
+ return;
+ if (blocks != be32_to_cpu(agi->agi_iblocks))
+ xchk_block_xref_set_corrupt(sc, sc->sa.agi_bp);
+ }
+
+ if (sc->sa.fino_cur) {
+ error = xfs_btree_count_blocks(sc->sa.fino_cur, &blocks);
+ if (!xchk_should_check_xref(sc, &error, &sc->sa.fino_cur))
+ return;
+ if (blocks != be32_to_cpu(agi->agi_fblocks))
+ xchk_block_xref_set_corrupt(sc, sc->sa.agi_bp);
+ }
+}
+
/* Cross-reference with the other btrees. */
STATIC void
xchk_agi_xref(
@@ -804,6 +833,7 @@ xchk_agi_xref(
xchk_agi_xref_icounts(sc);
xchk_xref_is_owned_by(sc, agbno, 1, &XFS_RMAP_OINFO_FS);
xchk_xref_is_not_shared(sc, agbno, 1);
+ xchk_agi_xref_fiblocks(sc);
/* scrub teardown will take care of sc->sa for us */
}
^ permalink raw reply related [flat|nested] 11+ messages in thread* [PATCH 4/5] xfs: support inode btree blockcounts in online repair
2020-09-02 2:55 [PATCH v4 0/5] xfs: add inode btree blocks counters to the AGI header Darrick J. Wong
` (2 preceding siblings ...)
2020-09-02 2:56 ` [PATCH 3/5] xfs: support inode btree blockcounts in online scrub Darrick J. Wong
@ 2020-09-02 2:56 ` Darrick J. Wong
2020-09-02 13:23 ` Brian Foster
2020-09-02 2:56 ` [PATCH 5/5] xfs: enable new inode btree counters feature Darrick J. Wong
4 siblings, 1 reply; 11+ messages in thread
From: Darrick J. Wong @ 2020-09-02 2:56 UTC (permalink / raw)
To: darrick.wong, bfoster; +Cc: linux-xfs
From: Darrick J. Wong <darrick.wong@oracle.com>
Add the necessary bits to the online repair code to support logging the
inode btree counters when rebuilding the btrees, and to support fixing
the counters when rebuilding the AGI.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
---
fs/xfs/libxfs/xfs_ialloc_btree.c | 16 +++++++++++++---
| 24 ++++++++++++++++++++++++
2 files changed, 37 insertions(+), 3 deletions(-)
diff --git a/fs/xfs/libxfs/xfs_ialloc_btree.c b/fs/xfs/libxfs/xfs_ialloc_btree.c
index 1df04e48bd87..219f57f4b5a7 100644
--- a/fs/xfs/libxfs/xfs_ialloc_btree.c
+++ b/fs/xfs/libxfs/xfs_ialloc_btree.c
@@ -504,19 +504,29 @@ xfs_inobt_commit_staged_btree(
{
struct xfs_agi *agi = agbp->b_addr;
struct xbtree_afakeroot *afake = cur->bc_ag.afake;
+ int fields;
ASSERT(cur->bc_flags & XFS_BTREE_STAGING);
if (cur->bc_btnum == XFS_BTNUM_INO) {
+ fields = XFS_AGI_ROOT | XFS_AGI_LEVEL;
agi->agi_root = cpu_to_be32(afake->af_root);
agi->agi_level = cpu_to_be32(afake->af_levels);
- xfs_ialloc_log_agi(tp, agbp, XFS_AGI_ROOT | XFS_AGI_LEVEL);
+ if (xfs_sb_version_hasinobtcounts(&cur->bc_mp->m_sb)) {
+ agi->agi_iblocks = cpu_to_be32(afake->af_blocks);
+ fields |= XFS_AGI_IBLOCKS;
+ }
+ xfs_ialloc_log_agi(tp, agbp, fields);
xfs_btree_commit_afakeroot(cur, tp, agbp, &xfs_inobt_ops);
} else {
+ fields = XFS_AGI_FREE_ROOT | XFS_AGI_FREE_LEVEL;
agi->agi_free_root = cpu_to_be32(afake->af_root);
agi->agi_free_level = cpu_to_be32(afake->af_levels);
- xfs_ialloc_log_agi(tp, agbp, XFS_AGI_FREE_ROOT |
- XFS_AGI_FREE_LEVEL);
+ if (xfs_sb_version_hasinobtcounts(&cur->bc_mp->m_sb)) {
+ agi->agi_fblocks = cpu_to_be32(afake->af_blocks);
+ fields |= XFS_AGI_IBLOCKS;
+ }
+ xfs_ialloc_log_agi(tp, agbp, fields);
xfs_btree_commit_afakeroot(cur, tp, agbp, &xfs_finobt_ops);
}
}
--git a/fs/xfs/scrub/agheader_repair.c b/fs/xfs/scrub/agheader_repair.c
index bca2ab1d4be9..401f71579ce6 100644
--- a/fs/xfs/scrub/agheader_repair.c
+++ b/fs/xfs/scrub/agheader_repair.c
@@ -810,10 +810,34 @@ xrep_agi_calc_from_btrees(
error = xfs_ialloc_count_inodes(cur, &count, &freecount);
if (error)
goto err;
+ if (xfs_sb_version_hasinobtcounts(&mp->m_sb)) {
+ xfs_agblock_t blocks;
+
+ error = xfs_btree_count_blocks(cur, &blocks);
+ if (error)
+ goto err;
+ agi->agi_iblocks = cpu_to_be32(blocks);
+ }
xfs_btree_del_cursor(cur, error);
agi->agi_count = cpu_to_be32(count);
agi->agi_freecount = cpu_to_be32(freecount);
+
+ if (xfs_sb_version_hasfinobt(&mp->m_sb) &&
+ xfs_sb_version_hasinobtcounts(&mp->m_sb)) {
+ xfs_agblock_t blocks;
+
+ cur = xfs_inobt_init_cursor(mp, sc->tp, agi_bp, sc->sa.agno,
+ XFS_BTNUM_FINO);
+ if (error)
+ goto err;
+ error = xfs_btree_count_blocks(cur, &blocks);
+ if (error)
+ goto err;
+ xfs_btree_del_cursor(cur, error);
+ agi->agi_fblocks = cpu_to_be32(blocks);
+ }
+
return 0;
err:
xfs_btree_del_cursor(cur, error);
^ permalink raw reply related [flat|nested] 11+ messages in thread* Re: [PATCH 4/5] xfs: support inode btree blockcounts in online repair
2020-09-02 2:56 ` [PATCH 4/5] xfs: support inode btree blockcounts in online repair Darrick J. Wong
@ 2020-09-02 13:23 ` Brian Foster
0 siblings, 0 replies; 11+ messages in thread
From: Brian Foster @ 2020-09-02 13:23 UTC (permalink / raw)
To: Darrick J. Wong; +Cc: linux-xfs
On Tue, Sep 01, 2020 at 07:56:17PM -0700, Darrick J. Wong wrote:
> From: Darrick J. Wong <darrick.wong@oracle.com>
>
> Add the necessary bits to the online repair code to support logging the
> inode btree counters when rebuilding the btrees, and to support fixing
> the counters when rebuilding the AGI.
>
> Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
> ---
Reviewed-by: Brian Foster <bfoster@redhat.com>
> fs/xfs/libxfs/xfs_ialloc_btree.c | 16 +++++++++++++---
> fs/xfs/scrub/agheader_repair.c | 24 ++++++++++++++++++++++++
> 2 files changed, 37 insertions(+), 3 deletions(-)
>
>
> diff --git a/fs/xfs/libxfs/xfs_ialloc_btree.c b/fs/xfs/libxfs/xfs_ialloc_btree.c
> index 1df04e48bd87..219f57f4b5a7 100644
> --- a/fs/xfs/libxfs/xfs_ialloc_btree.c
> +++ b/fs/xfs/libxfs/xfs_ialloc_btree.c
> @@ -504,19 +504,29 @@ xfs_inobt_commit_staged_btree(
> {
> struct xfs_agi *agi = agbp->b_addr;
> struct xbtree_afakeroot *afake = cur->bc_ag.afake;
> + int fields;
>
> ASSERT(cur->bc_flags & XFS_BTREE_STAGING);
>
> if (cur->bc_btnum == XFS_BTNUM_INO) {
> + fields = XFS_AGI_ROOT | XFS_AGI_LEVEL;
> agi->agi_root = cpu_to_be32(afake->af_root);
> agi->agi_level = cpu_to_be32(afake->af_levels);
> - xfs_ialloc_log_agi(tp, agbp, XFS_AGI_ROOT | XFS_AGI_LEVEL);
> + if (xfs_sb_version_hasinobtcounts(&cur->bc_mp->m_sb)) {
> + agi->agi_iblocks = cpu_to_be32(afake->af_blocks);
> + fields |= XFS_AGI_IBLOCKS;
> + }
> + xfs_ialloc_log_agi(tp, agbp, fields);
> xfs_btree_commit_afakeroot(cur, tp, agbp, &xfs_inobt_ops);
> } else {
> + fields = XFS_AGI_FREE_ROOT | XFS_AGI_FREE_LEVEL;
> agi->agi_free_root = cpu_to_be32(afake->af_root);
> agi->agi_free_level = cpu_to_be32(afake->af_levels);
> - xfs_ialloc_log_agi(tp, agbp, XFS_AGI_FREE_ROOT |
> - XFS_AGI_FREE_LEVEL);
> + if (xfs_sb_version_hasinobtcounts(&cur->bc_mp->m_sb)) {
> + agi->agi_fblocks = cpu_to_be32(afake->af_blocks);
> + fields |= XFS_AGI_IBLOCKS;
> + }
> + xfs_ialloc_log_agi(tp, agbp, fields);
> xfs_btree_commit_afakeroot(cur, tp, agbp, &xfs_finobt_ops);
> }
> }
> diff --git a/fs/xfs/scrub/agheader_repair.c b/fs/xfs/scrub/agheader_repair.c
> index bca2ab1d4be9..401f71579ce6 100644
> --- a/fs/xfs/scrub/agheader_repair.c
> +++ b/fs/xfs/scrub/agheader_repair.c
> @@ -810,10 +810,34 @@ xrep_agi_calc_from_btrees(
> error = xfs_ialloc_count_inodes(cur, &count, &freecount);
> if (error)
> goto err;
> + if (xfs_sb_version_hasinobtcounts(&mp->m_sb)) {
> + xfs_agblock_t blocks;
> +
> + error = xfs_btree_count_blocks(cur, &blocks);
> + if (error)
> + goto err;
> + agi->agi_iblocks = cpu_to_be32(blocks);
> + }
> xfs_btree_del_cursor(cur, error);
>
> agi->agi_count = cpu_to_be32(count);
> agi->agi_freecount = cpu_to_be32(freecount);
> +
> + if (xfs_sb_version_hasfinobt(&mp->m_sb) &&
> + xfs_sb_version_hasinobtcounts(&mp->m_sb)) {
> + xfs_agblock_t blocks;
> +
> + cur = xfs_inobt_init_cursor(mp, sc->tp, agi_bp, sc->sa.agno,
> + XFS_BTNUM_FINO);
> + if (error)
> + goto err;
> + error = xfs_btree_count_blocks(cur, &blocks);
> + if (error)
> + goto err;
> + xfs_btree_del_cursor(cur, error);
> + agi->agi_fblocks = cpu_to_be32(blocks);
> + }
> +
> return 0;
> err:
> xfs_btree_del_cursor(cur, error);
>
^ permalink raw reply [flat|nested] 11+ messages in thread
* [PATCH 5/5] xfs: enable new inode btree counters feature
2020-09-02 2:55 [PATCH v4 0/5] xfs: add inode btree blocks counters to the AGI header Darrick J. Wong
` (3 preceding siblings ...)
2020-09-02 2:56 ` [PATCH 4/5] xfs: support inode btree blockcounts in online repair Darrick J. Wong
@ 2020-09-02 2:56 ` Darrick J. Wong
4 siblings, 0 replies; 11+ messages in thread
From: Darrick J. Wong @ 2020-09-02 2:56 UTC (permalink / raw)
To: darrick.wong, bfoster; +Cc: linux-xfs
From: Darrick J. Wong <darrick.wong@oracle.com>
Enable the new inode btree counters feature.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
---
fs/xfs/libxfs/xfs_format.h | 3 ++-
1 file changed, 2 insertions(+), 1 deletion(-)
diff --git a/fs/xfs/libxfs/xfs_format.h b/fs/xfs/libxfs/xfs_format.h
index 03cbedb7eafc..fe129fe16d5f 100644
--- a/fs/xfs/libxfs/xfs_format.h
+++ b/fs/xfs/libxfs/xfs_format.h
@@ -453,7 +453,8 @@ xfs_sb_has_compat_feature(
#define XFS_SB_FEAT_RO_COMPAT_ALL \
(XFS_SB_FEAT_RO_COMPAT_FINOBT | \
XFS_SB_FEAT_RO_COMPAT_RMAPBT | \
- XFS_SB_FEAT_RO_COMPAT_REFLINK)
+ XFS_SB_FEAT_RO_COMPAT_REFLINK| \
+ XFS_SB_FEAT_RO_COMPAT_INOBTCNT)
#define XFS_SB_FEAT_RO_COMPAT_UNKNOWN ~XFS_SB_FEAT_RO_COMPAT_ALL
static inline bool
xfs_sb_has_ro_compat_feature(
^ permalink raw reply related [flat|nested] 11+ messages in thread