On Wed, Oct 09, 2019 at 09:49:02AM -0700, Darrick J. Wong wrote:
> From: Darrick J. Wong <darrick.wong@xxxxxxxxxx>
>
> Shorten the name of xfs_bitmap to xbitmap since the scrub bitmap has
> nothing to do with the libxfs bitmap.
>
> Signed-off-by: Darrick J. Wong <darrick.wong@xxxxxxxxxx>
> ---
Reviewed-by: Brian Foster <bfoster@xxxxxxxxxx>
> fs/xfs/scrub/agheader_repair.c | 42 ++++++++++++-----------
> fs/xfs/scrub/bitmap.c | 72 ++++++++++++++++++++--------------------
> fs/xfs/scrub/bitmap.h | 22 ++++++------
> fs/xfs/scrub/repair.c | 8 ++--
> fs/xfs/scrub/repair.h | 4 +-
> 5 files changed, 74 insertions(+), 74 deletions(-)
>
>
> diff --git a/fs/xfs/scrub/agheader_repair.c b/fs/xfs/scrub/agheader_repair.c
> index 8fcd43040c96..9fbb6035f4e2 100644
> --- a/fs/xfs/scrub/agheader_repair.c
> +++ b/fs/xfs/scrub/agheader_repair.c
> @@ -429,10 +429,10 @@ xrep_agf(
>
> struct xrep_agfl {
> /* Bitmap of other OWN_AG metadata blocks. */
> - struct xfs_bitmap agmetablocks;
> + struct xbitmap agmetablocks;
>
> /* Bitmap of free space. */
> - struct xfs_bitmap *freesp;
> + struct xbitmap *freesp;
>
> struct xfs_scrub *sc;
> };
> @@ -455,12 +455,12 @@ xrep_agfl_walk_rmap(
> if (rec->rm_owner == XFS_RMAP_OWN_AG) {
> fsb = XFS_AGB_TO_FSB(cur->bc_mp, cur->bc_private.a.agno,
> rec->rm_startblock);
> - error = xfs_bitmap_set(ra->freesp, fsb, rec->rm_blockcount);
> + error = xbitmap_set(ra->freesp, fsb, rec->rm_blockcount);
> if (error)
> return error;
> }
>
> - return xfs_bitmap_set_btcur_path(&ra->agmetablocks, cur);
> + return xbitmap_set_btcur_path(&ra->agmetablocks, cur);
> }
>
> /*
> @@ -476,19 +476,19 @@ STATIC int
> xrep_agfl_collect_blocks(
> struct xfs_scrub *sc,
> struct xfs_buf *agf_bp,
> - struct xfs_bitmap *agfl_extents,
> + struct xbitmap *agfl_extents,
> xfs_agblock_t *flcount)
> {
> struct xrep_agfl ra;
> struct xfs_mount *mp = sc->mp;
> struct xfs_btree_cur *cur;
> - struct xfs_bitmap_range *br;
> - struct xfs_bitmap_range *n;
> + struct xbitmap_range *br;
> + struct xbitmap_range *n;
> int error;
>
> ra.sc = sc;
> ra.freesp = agfl_extents;
> - xfs_bitmap_init(&ra.agmetablocks);
> + xbitmap_init(&ra.agmetablocks);
>
> /* Find all space used by the free space btrees & rmapbt. */
> cur = xfs_rmapbt_init_cursor(mp, sc->tp, agf_bp, sc->sa.agno);
> @@ -500,7 +500,7 @@ xrep_agfl_collect_blocks(
> /* Find all blocks currently being used by the bnobt. */
> cur = xfs_allocbt_init_cursor(mp, sc->tp, agf_bp, sc->sa.agno,
> XFS_BTNUM_BNO);
> - error = xfs_bitmap_set_btblocks(&ra.agmetablocks, cur);
> + error = xbitmap_set_btblocks(&ra.agmetablocks, cur);
> if (error)
> goto err;
> xfs_btree_del_cursor(cur, error);
> @@ -508,7 +508,7 @@ xrep_agfl_collect_blocks(
> /* Find all blocks currently being used by the cntbt. */
> cur = xfs_allocbt_init_cursor(mp, sc->tp, agf_bp, sc->sa.agno,
> XFS_BTNUM_CNT);
> - error = xfs_bitmap_set_btblocks(&ra.agmetablocks, cur);
> + error = xbitmap_set_btblocks(&ra.agmetablocks, cur);
> if (error)
> goto err;
>
> @@ -518,8 +518,8 @@ xrep_agfl_collect_blocks(
> * Drop the freesp meta blocks that are in use by btrees.
> * The remaining blocks /should/ be AGFL blocks.
> */
> - error = xfs_bitmap_disunion(agfl_extents, &ra.agmetablocks);
> - xfs_bitmap_destroy(&ra.agmetablocks);
> + error = xbitmap_disunion(agfl_extents, &ra.agmetablocks);
> + xbitmap_destroy(&ra.agmetablocks);
> if (error)
> return error;
>
> @@ -528,7 +528,7 @@ xrep_agfl_collect_blocks(
> * the AGFL we'll free them later.
> */
> *flcount = 0;
> - for_each_xfs_bitmap_extent(br, n, agfl_extents) {
> + for_each_xbitmap_extent(br, n, agfl_extents) {
> *flcount += br->len;
> if (*flcount > xfs_agfl_size(mp))
> break;
> @@ -538,7 +538,7 @@ xrep_agfl_collect_blocks(
> return 0;
>
> err:
> - xfs_bitmap_destroy(&ra.agmetablocks);
> + xbitmap_destroy(&ra.agmetablocks);
> xfs_btree_del_cursor(cur, error);
> return error;
> }
> @@ -573,13 +573,13 @@ STATIC void
> xrep_agfl_init_header(
> struct xfs_scrub *sc,
> struct xfs_buf *agfl_bp,
> - struct xfs_bitmap *agfl_extents,
> + struct xbitmap *agfl_extents,
> xfs_agblock_t flcount)
> {
> struct xfs_mount *mp = sc->mp;
> __be32 *agfl_bno;
> - struct xfs_bitmap_range *br;
> - struct xfs_bitmap_range *n;
> + struct xbitmap_range *br;
> + struct xbitmap_range *n;
> struct xfs_agfl *agfl;
> xfs_agblock_t agbno;
> unsigned int fl_off;
> @@ -603,7 +603,7 @@ xrep_agfl_init_header(
> */
> fl_off = 0;
> agfl_bno = XFS_BUF_TO_AGFL_BNO(mp, agfl_bp);
> - for_each_xfs_bitmap_extent(br, n, agfl_extents) {
> + for_each_xbitmap_extent(br, n, agfl_extents) {
> agbno = XFS_FSB_TO_AGBNO(mp, br->start);
>
> trace_xrep_agfl_insert(mp, sc->sa.agno, agbno, br->len);
> @@ -637,7 +637,7 @@ int
> xrep_agfl(
> struct xfs_scrub *sc)
> {
> - struct xfs_bitmap agfl_extents;
> + struct xbitmap agfl_extents;
> struct xfs_mount *mp = sc->mp;
> struct xfs_buf *agf_bp;
> struct xfs_buf *agfl_bp;
> @@ -649,7 +649,7 @@ xrep_agfl(
> return -EOPNOTSUPP;
>
> xchk_perag_get(sc->mp, &sc->sa);
> - xfs_bitmap_init(&agfl_extents);
> + xbitmap_init(&agfl_extents);
>
> /*
> * Read the AGF so that we can query the rmapbt. We hope that there's
> @@ -701,7 +701,7 @@ xrep_agfl(
> error = xrep_reap_extents(sc, &agfl_extents, &XFS_RMAP_OINFO_AG,
> XFS_AG_RESV_AGFL);
> err:
> - xfs_bitmap_destroy(&agfl_extents);
> + xbitmap_destroy(&agfl_extents);
> return error;
> }
>
> diff --git a/fs/xfs/scrub/bitmap.c b/fs/xfs/scrub/bitmap.c
> index 3d47d111be5a..5b07b46c89c9 100644
> --- a/fs/xfs/scrub/bitmap.c
> +++ b/fs/xfs/scrub/bitmap.c
> @@ -18,14 +18,14 @@
> * This is the logical equivalent of bitmap |= mask(start, len).
> */
> int
> -xfs_bitmap_set(
> - struct xfs_bitmap *bitmap,
> +xbitmap_set(
> + struct xbitmap *bitmap,
> uint64_t start,
> uint64_t len)
> {
> - struct xfs_bitmap_range *bmr;
> + struct xbitmap_range *bmr;
>
> - bmr = kmem_alloc(sizeof(struct xfs_bitmap_range), KM_MAYFAIL);
> + bmr = kmem_alloc(sizeof(struct xbitmap_range), KM_MAYFAIL);
> if (!bmr)
> return -ENOMEM;
>
> @@ -39,13 +39,13 @@ xfs_bitmap_set(
>
> /* Free everything related to this bitmap. */
> void
> -xfs_bitmap_destroy(
> - struct xfs_bitmap *bitmap)
> +xbitmap_destroy(
> + struct xbitmap *bitmap)
> {
> - struct xfs_bitmap_range *bmr;
> - struct xfs_bitmap_range *n;
> + struct xbitmap_range *bmr;
> + struct xbitmap_range *n;
>
> - for_each_xfs_bitmap_extent(bmr, n, bitmap) {
> + for_each_xbitmap_extent(bmr, n, bitmap) {
> list_del(&bmr->list);
> kmem_free(bmr);
> }
> @@ -53,24 +53,24 @@ xfs_bitmap_destroy(
>
> /* Set up a per-AG block bitmap. */
> void
> -xfs_bitmap_init(
> - struct xfs_bitmap *bitmap)
> +xbitmap_init(
> + struct xbitmap *bitmap)
> {
> INIT_LIST_HEAD(&bitmap->list);
> }
>
> /* Compare two btree extents. */
> static int
> -xfs_bitmap_range_cmp(
> +xbitmap_range_cmp(
> void *priv,
> struct list_head *a,
> struct list_head *b)
> {
> - struct xfs_bitmap_range *ap;
> - struct xfs_bitmap_range *bp;
> + struct xbitmap_range *ap;
> + struct xbitmap_range *bp;
>
> - ap = container_of(a, struct xfs_bitmap_range, list);
> - bp = container_of(b, struct xfs_bitmap_range, list);
> + ap = container_of(a, struct xbitmap_range, list);
> + bp = container_of(b, struct xbitmap_range, list);
>
> if (ap->start > bp->start)
> return 1;
> @@ -96,14 +96,14 @@ xfs_bitmap_range_cmp(
> #define LEFT_ALIGNED (1 << 0)
> #define RIGHT_ALIGNED (1 << 1)
> int
> -xfs_bitmap_disunion(
> - struct xfs_bitmap *bitmap,
> - struct xfs_bitmap *sub)
> +xbitmap_disunion(
> + struct xbitmap *bitmap,
> + struct xbitmap *sub)
> {
> struct list_head *lp;
> - struct xfs_bitmap_range *br;
> - struct xfs_bitmap_range *new_br;
> - struct xfs_bitmap_range *sub_br;
> + struct xbitmap_range *br;
> + struct xbitmap_range *new_br;
> + struct xbitmap_range *sub_br;
> uint64_t sub_start;
> uint64_t sub_len;
> int state;
> @@ -113,8 +113,8 @@ xfs_bitmap_disunion(
> return 0;
> ASSERT(!list_empty(&sub->list));
>
> - list_sort(NULL, &bitmap->list, xfs_bitmap_range_cmp);
> - list_sort(NULL, &sub->list, xfs_bitmap_range_cmp);
> + list_sort(NULL, &bitmap->list, xbitmap_range_cmp);
> + list_sort(NULL, &sub->list, xbitmap_range_cmp);
>
> /*
> * Now that we've sorted both lists, we iterate bitmap once, rolling
> @@ -124,11 +124,11 @@ xfs_bitmap_disunion(
> * list traversal is similar to merge sort, but we're deleting
> * instead. In this manner we avoid O(n^2) operations.
> */
> - sub_br = list_first_entry(&sub->list, struct xfs_bitmap_range,
> + sub_br = list_first_entry(&sub->list, struct xbitmap_range,
> list);
> lp = bitmap->list.next;
> while (lp != &bitmap->list) {
> - br = list_entry(lp, struct xfs_bitmap_range, list);
> + br = list_entry(lp, struct xbitmap_range, list);
>
> /*
> * Advance sub_br and/or br until we find a pair that
> @@ -181,7 +181,7 @@ xfs_bitmap_disunion(
> * Deleting from the middle: add the new right extent
> * and then shrink the left extent.
> */
> - new_br = kmem_alloc(sizeof(struct xfs_bitmap_range),
> + new_br = kmem_alloc(sizeof(struct xbitmap_range),
> KM_MAYFAIL);
> if (!new_br) {
> error = -ENOMEM;
> @@ -247,8 +247,8 @@ xfs_bitmap_disunion(
> * blocks going from the leaf towards the root.
> */
> int
> -xfs_bitmap_set_btcur_path(
> - struct xfs_bitmap *bitmap,
> +xbitmap_set_btcur_path(
> + struct xbitmap *bitmap,
> struct xfs_btree_cur *cur)
> {
> struct xfs_buf *bp;
> @@ -261,7 +261,7 @@ xfs_bitmap_set_btcur_path(
> if (!bp)
> continue;
> fsb = XFS_DADDR_TO_FSB(cur->bc_mp, bp->b_bn);
> - error = xfs_bitmap_set(bitmap, fsb, 1);
> + error = xbitmap_set(bitmap, fsb, 1);
> if (error)
> return error;
> }
> @@ -271,12 +271,12 @@ xfs_bitmap_set_btcur_path(
>
> /* Collect a btree's block in the bitmap. */
> STATIC int
> -xfs_bitmap_collect_btblock(
> +xbitmap_collect_btblock(
> struct xfs_btree_cur *cur,
> int level,
> void *priv)
> {
> - struct xfs_bitmap *bitmap = priv;
> + struct xbitmap *bitmap = priv;
> struct xfs_buf *bp;
> xfs_fsblock_t fsbno;
>
> @@ -285,14 +285,14 @@ xfs_bitmap_collect_btblock(
> return 0;
>
> fsbno = XFS_DADDR_TO_FSB(cur->bc_mp, bp->b_bn);
> - return xfs_bitmap_set(bitmap, fsbno, 1);
> + return xbitmap_set(bitmap, fsbno, 1);
> }
>
> /* Walk the btree and mark the bitmap wherever a btree block is found. */
> int
> -xfs_bitmap_set_btblocks(
> - struct xfs_bitmap *bitmap,
> +xbitmap_set_btblocks(
> + struct xbitmap *bitmap,
> struct xfs_btree_cur *cur)
> {
> - return xfs_btree_visit_blocks(cur, xfs_bitmap_collect_btblock, bitmap);
> + return xfs_btree_visit_blocks(cur, xbitmap_collect_btblock, bitmap);
> }
> diff --git a/fs/xfs/scrub/bitmap.h b/fs/xfs/scrub/bitmap.h
> index ae8ecbce6fa6..8db4017ac78e 100644
> --- a/fs/xfs/scrub/bitmap.h
> +++ b/fs/xfs/scrub/bitmap.h
> @@ -6,31 +6,31 @@
> #ifndef __XFS_SCRUB_BITMAP_H__
> #define __XFS_SCRUB_BITMAP_H__
>
> -struct xfs_bitmap_range {
> +struct xbitmap_range {
> struct list_head list;
> uint64_t start;
> uint64_t len;
> };
>
> -struct xfs_bitmap {
> +struct xbitmap {
> struct list_head list;
> };
>
> -void xfs_bitmap_init(struct xfs_bitmap *bitmap);
> -void xfs_bitmap_destroy(struct xfs_bitmap *bitmap);
> +void xbitmap_init(struct xbitmap *bitmap);
> +void xbitmap_destroy(struct xbitmap *bitmap);
>
> -#define for_each_xfs_bitmap_extent(bex, n, bitmap) \
> +#define for_each_xbitmap_extent(bex, n, bitmap) \
> list_for_each_entry_safe((bex), (n), &(bitmap)->list, list)
>
> -#define for_each_xfs_bitmap_block(b, bex, n, bitmap) \
> +#define for_each_xbitmap_block(b, bex, n, bitmap) \
> list_for_each_entry_safe((bex), (n), &(bitmap)->list, list) \
> - for ((b) = bex->start; (b) < bex->start + bex->len; (b)++)
> + for ((b) = (bex)->start; (b) < (bex)->start + (bex)->len; (b)++)
>
> -int xfs_bitmap_set(struct xfs_bitmap *bitmap, uint64_t start, uint64_t len);
> -int xfs_bitmap_disunion(struct xfs_bitmap *bitmap, struct xfs_bitmap *sub);
> -int xfs_bitmap_set_btcur_path(struct xfs_bitmap *bitmap,
> +int xbitmap_set(struct xbitmap *bitmap, uint64_t start, uint64_t len);
> +int xbitmap_disunion(struct xbitmap *bitmap, struct xbitmap *sub);
> +int xbitmap_set_btcur_path(struct xbitmap *bitmap,
> struct xfs_btree_cur *cur);
> -int xfs_bitmap_set_btblocks(struct xfs_bitmap *bitmap,
> +int xbitmap_set_btblocks(struct xbitmap *bitmap,
> struct xfs_btree_cur *cur);
>
> #endif /* __XFS_SCRUB_BITMAP_H__ */
> diff --git a/fs/xfs/scrub/repair.c b/fs/xfs/scrub/repair.c
> index 8349694f985d..d41da4c44f10 100644
> --- a/fs/xfs/scrub/repair.c
> +++ b/fs/xfs/scrub/repair.c
> @@ -600,19 +600,19 @@ xrep_reap_block(
> int
> xrep_reap_extents(
> struct xfs_scrub *sc,
> - struct xfs_bitmap *bitmap,
> + struct xbitmap *bitmap,
> const struct xfs_owner_info *oinfo,
> enum xfs_ag_resv_type type)
> {
> - struct xfs_bitmap_range *bmr;
> - struct xfs_bitmap_range *n;
> + struct xbitmap_range *bmr;
> + struct xbitmap_range *n;
> xfs_fsblock_t fsbno;
> unsigned int deferred = 0;
> int error = 0;
>
> ASSERT(xfs_sb_version_hasrmapbt(&sc->mp->m_sb));
>
> - for_each_xfs_bitmap_block(fsbno, bmr, n, bitmap) {
> + for_each_xbitmap_block(fsbno, bmr, n, bitmap) {
> ASSERT(sc->ip != NULL ||
> XFS_FSB_TO_AGNO(sc->mp, fsbno) == sc->sa.agno);
> trace_xrep_dispose_btree_extent(sc->mp,
> diff --git a/fs/xfs/scrub/repair.h b/fs/xfs/scrub/repair.h
> index eab41928990f..479cfe38065e 100644
> --- a/fs/xfs/scrub/repair.h
> +++ b/fs/xfs/scrub/repair.h
> @@ -28,10 +28,10 @@ int xrep_init_btblock(struct xfs_scrub *sc, xfs_fsblock_t fsb,
> struct xfs_buf **bpp, xfs_btnum_t btnum,
> const struct xfs_buf_ops *ops);
>
> -struct xfs_bitmap;
> +struct xbitmap;
>
> int xrep_fix_freelist(struct xfs_scrub *sc, bool can_shrink);
> -int xrep_reap_extents(struct xfs_scrub *sc, struct xfs_bitmap *exlist,
> +int xrep_reap_extents(struct xfs_scrub *sc, struct xbitmap *exlist,
> const struct xfs_owner_info *oinfo, enum xfs_ag_resv_type type);
>
> struct xrep_find_ag_btree {
>
