xfs: move the per-AG datatype bitmaps to separate files (0f08af0f) · Commits · git / linux-net

fs/xfs/Makefile

+1 −0

Original line number	Diff line number	Diff line
		@@ -145,6 +145,7 @@ ifeq ($(CONFIG_XFS_ONLINE_SCRUB),y)

		xfs-y += $(addprefix scrub/, \
		trace.o \
		agb_bitmap.o \
		agheader.o \
		alloc.o \
		attr.o \

fs/xfs/scrub/agb_bitmap.c

0 → 100644

+103 −0

Original line number	Diff line number	Diff line
		// SPDX-License-Identifier: GPL-2.0-or-later
		/*
		* Copyright (C) 2018-2023 Oracle. All Rights Reserved.
		* Author: Darrick J. Wong <djwong@kernel.org>
		*/
		#include "xfs.h"
		#include "xfs_shared.h"
		#include "xfs_bit.h"
		#include "xfs_format.h"
		#include "xfs_trans_resv.h"
		#include "xfs_mount.h"
		#include "xfs_btree.h"
		#include "bitmap.h"
		#include "scrub/agb_bitmap.h"

		/*
		* Record all btree blocks seen while iterating all records of a btree.
		*
		* We know that the btree query_all function starts at the left edge and walks
		* towards the right edge of the tree. Therefore, we know that we can walk up
		* the btree cursor towards the root; if the pointer for a given level points
		* to the first record/key in that block, we haven't seen this block before;
		* and therefore we need to remember that we saw this block in the btree.
		*
		* So if our btree is:
		*
		* 4
		* / \| \
		* 1 2 3
		*
		* Pretend for this example that each leaf block has 100 btree records. For
		* the first btree record, we'll observe that bc_levels[0].ptr == 1, so we
		* record that we saw block 1. Then we observe that bc_levels[1].ptr == 1, so
		* we record block 4. The list is [1, 4].
		*
		* For the second btree record, we see that bc_levels[0].ptr == 2, so we exit
		* the loop. The list remains [1, 4].
		*
		* For the 101st btree record, we've moved onto leaf block 2. Now
		* bc_levels[0].ptr == 1 again, so we record that we saw block 2. We see that
		* bc_levels[1].ptr == 2, so we exit the loop. The list is now [1, 4, 2].
		*
		* For the 102nd record, bc_levels[0].ptr == 2, so we continue.
		*
		* For the 201st record, we've moved on to leaf block 3.
		* bc_levels[0].ptr == 1, so we add 3 to the list. Now it is [1, 4, 2, 3].
		*
		* For the 300th record we just exit, with the list being [1, 4, 2, 3].
		*/

		/* Mark a btree block to the agblock bitmap. */
		STATIC int
		xagb_bitmap_visit_btblock(
		struct xfs_btree_cur *cur,
		int level,
		void *priv)
		{
		struct xagb_bitmap *bitmap = priv;
		struct xfs_buf *bp;
		xfs_fsblock_t fsbno;
		xfs_agblock_t agbno;

		xfs_btree_get_block(cur, level, &bp);
		if (!bp)
		return 0;

		fsbno = XFS_DADDR_TO_FSB(cur->bc_mp, xfs_buf_daddr(bp));
		agbno = XFS_FSB_TO_AGBNO(cur->bc_mp, fsbno);

		return xagb_bitmap_set(bitmap, agbno, 1);
		}

		/* Mark all (per-AG) btree blocks in the agblock bitmap. */
		int
		xagb_bitmap_set_btblocks(
		struct xagb_bitmap *bitmap,
		struct xfs_btree_cur *cur)
		{
		return xfs_btree_visit_blocks(cur, xagb_bitmap_visit_btblock,
		XFS_BTREE_VISIT_ALL, bitmap);
		}

		/*
		* Record all the buffers pointed to by the btree cursor. Callers already
		* engaged in a btree walk should call this function to capture the list of
		* blocks going from the leaf towards the root.
		*/
		int
		xagb_bitmap_set_btcur_path(
		struct xagb_bitmap *bitmap,
		struct xfs_btree_cur *cur)
		{
		int i;
		int error;

		for (i = 0; i < cur->bc_nlevels && cur->bc_levels[i].ptr == 1; i++) {
		error = xagb_bitmap_visit_btblock(cur, i, bitmap);
		if (error)
		return error;
		}

		return 0;
		}

fs/xfs/scrub/agb_bitmap.h

0 → 100644

+68 −0

Original line number	Diff line number	Diff line
		// SPDX-License-Identifier: GPL-2.0-or-later
		/*
		* Copyright (C) 2018-2023 Oracle. All Rights Reserved.
		* Author: Darrick J. Wong <djwong@kernel.org>
		*/
		#ifndef __XFS_SCRUB_AGB_BITMAP_H__
		#define __XFS_SCRUB_AGB_BITMAP_H__

		/* Bitmaps, but for type-checked for xfs_agblock_t */

		struct xagb_bitmap {
		struct xbitmap32 agbitmap;
		};

		static inline void xagb_bitmap_init(struct xagb_bitmap *bitmap)
		{
		xbitmap32_init(&bitmap->agbitmap);
		}

		static inline void xagb_bitmap_destroy(struct xagb_bitmap *bitmap)
		{
		xbitmap32_destroy(&bitmap->agbitmap);
		}

		static inline int xagb_bitmap_clear(struct xagb_bitmap *bitmap,
		xfs_agblock_t start, xfs_extlen_t len)
		{
		return xbitmap32_clear(&bitmap->agbitmap, start, len);
		}
		static inline int xagb_bitmap_set(struct xagb_bitmap *bitmap,
		xfs_agblock_t start, xfs_extlen_t len)
		{
		return xbitmap32_set(&bitmap->agbitmap, start, len);
		}

		static inline bool xagb_bitmap_test(struct xagb_bitmap *bitmap,
		xfs_agblock_t start, xfs_extlen_t *len)
		{
		return xbitmap32_test(&bitmap->agbitmap, start, len);
		}

		static inline int xagb_bitmap_disunion(struct xagb_bitmap *bitmap,
		struct xagb_bitmap *sub)
		{
		return xbitmap32_disunion(&bitmap->agbitmap, &sub->agbitmap);
		}

		static inline uint32_t xagb_bitmap_hweight(struct xagb_bitmap *bitmap)
		{
		return xbitmap32_hweight(&bitmap->agbitmap);
		}
		static inline bool xagb_bitmap_empty(struct xagb_bitmap *bitmap)
		{
		return xbitmap32_empty(&bitmap->agbitmap);
		}

		static inline int xagb_bitmap_walk(struct xagb_bitmap *bitmap,
		xbitmap32_walk_fn fn, void *priv)
		{
		return xbitmap32_walk(&bitmap->agbitmap, fn, priv);
		}

		int xagb_bitmap_set_btblocks(struct xagb_bitmap *bitmap,
		struct xfs_btree_cur *cur);
		int xagb_bitmap_set_btcur_path(struct xagb_bitmap *bitmap,
		struct xfs_btree_cur *cur);

		#endif /* __XFS_SCRUB_AGB_BITMAP_H__ */

fs/xfs/scrub/agheader_repair.c

+1 −0

Original line number	Diff line number	Diff line
		@@ -26,6 +26,7 @@
		#include "scrub/trace.h"
		#include "scrub/repair.h"
		#include "scrub/bitmap.h"
		#include "scrub/agb_bitmap.h"
		#include "scrub/reap.h"

		/* Superblock */

fs/xfs/scrub/bitmap.c

+0 −91

Original line number	Diff line number	Diff line
		@@ -566,94 +566,3 @@ xbitmap32_test(
		*len = bn->bn_start - start;
		return false;
		}

		/* xfs_agblock_t bitmap */

		/*
		* Record all btree blocks seen while iterating all records of a btree.
		*
		* We know that the btree query_all function starts at the left edge and walks
		* towards the right edge of the tree. Therefore, we know that we can walk up
		* the btree cursor towards the root; if the pointer for a given level points
		* to the first record/key in that block, we haven't seen this block before;
		* and therefore we need to remember that we saw this block in the btree.
		*
		* So if our btree is:
		*
		* 4
		* / \| \
		* 1 2 3
		*
		* Pretend for this example that each leaf block has 100 btree records. For
		* the first btree record, we'll observe that bc_levels[0].ptr == 1, so we
		* record that we saw block 1. Then we observe that bc_levels[1].ptr == 1, so
		* we record block 4. The list is [1, 4].
		*
		* For the second btree record, we see that bc_levels[0].ptr == 2, so we exit
		* the loop. The list remains [1, 4].
		*
		* For the 101st btree record, we've moved onto leaf block 2. Now
		* bc_levels[0].ptr == 1 again, so we record that we saw block 2. We see that
		* bc_levels[1].ptr == 2, so we exit the loop. The list is now [1, 4, 2].
		*
		* For the 102nd record, bc_levels[0].ptr == 2, so we continue.
		*
		* For the 201st record, we've moved on to leaf block 3.
		* bc_levels[0].ptr == 1, so we add 3 to the list. Now it is [1, 4, 2, 3].
		*
		* For the 300th record we just exit, with the list being [1, 4, 2, 3].
		*/

		/* Mark a btree block to the agblock bitmap. */
		STATIC int
		xagb_bitmap_visit_btblock(
		struct xfs_btree_cur *cur,
		int level,
		void *priv)
		{
		struct xagb_bitmap *bitmap = priv;
		struct xfs_buf *bp;
		xfs_fsblock_t fsbno;
		xfs_agblock_t agbno;

		xfs_btree_get_block(cur, level, &bp);
		if (!bp)
		return 0;

		fsbno = XFS_DADDR_TO_FSB(cur->bc_mp, xfs_buf_daddr(bp));
		agbno = XFS_FSB_TO_AGBNO(cur->bc_mp, fsbno);

		return xagb_bitmap_set(bitmap, agbno, 1);
		}

		/* Mark all (per-AG) btree blocks in the agblock bitmap. */
		int
		xagb_bitmap_set_btblocks(
		struct xagb_bitmap *bitmap,
		struct xfs_btree_cur *cur)
		{
		return xfs_btree_visit_blocks(cur, xagb_bitmap_visit_btblock,
		XFS_BTREE_VISIT_ALL, bitmap);
		}

		/*
		* Record all the buffers pointed to by the btree cursor. Callers already
		* engaged in a btree walk should call this function to capture the list of
		* blocks going from the leaf towards the root.
		*/
		int
		xagb_bitmap_set_btcur_path(
		struct xagb_bitmap *bitmap,
		struct xfs_btree_cur *cur)
		{
		int i;
		int error;

		for (i = 0; i < cur->bc_nlevels && cur->bc_levels[i].ptr == 1; i++) {
		error = xagb_bitmap_visit_btblock(cur, i, bitmap);
		if (error)
		return error;
		}

		return 0;
		}