Commit a2f790b2 authored by Christoph Hellwig's avatar Christoph Hellwig Committed by Carlos Maiolino
Browse files

xfs: kill XBF_UNMAPPED 



Unmapped buffer access is a pain, so kill it. The switch to large
folios means we rarely pay a vmap penalty for large buffers,
so this functionality is largely unnecessary now.

Signed-off-by: default avatarChristoph Hellwig <hch@lst.de>
Signed-off-by: default avatarDave Chinner <dchinner@redhat.com>
Reviewed-by: default avatarDarrick J. Wong <djwong@kernel.org>
Signed-off-by: default avatarCarlos Maiolino <cem@kernel.org>
parent 94c78cfa

fs/xfs/libxfs/xfs_ialloc.c

+1 −1
Original line number Diff line number Diff line
@@ -364,7 +364,7 @@ xfs_ialloc_inode_init( 
				(j * M_IGEO(mp)->blocks_per_cluster));

		error = xfs_trans_get_buf(tp, mp->m_ddev_targp, d,

				mp->m_bsize * M_IGEO(mp)->blocks_per_cluster,

				XBF_UNMAPPED, &fbuf);

				0, &fbuf);

		if (error)

			return error;

fs/xfs/libxfs/xfs_inode_buf.c

+1 −1
Original line number Diff line number Diff line
@@ -137,7 +137,7 @@ xfs_imap_to_bp( 
	int			error;



	error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp, imap->im_blkno,

			imap->im_len, XBF_UNMAPPED, bpp, &xfs_inode_buf_ops);

			imap->im_len, 0, bpp, &xfs_inode_buf_ops);

	if (xfs_metadata_is_sick(error))

		xfs_agno_mark_sick(mp, xfs_daddr_to_agno(mp, imap->im_blkno),

				XFS_SICK_AG_INODES);

fs/xfs/scrub/inode_repair.c

+1 −2
Original line number Diff line number Diff line
@@ -1560,8 +1560,7 @@ xrep_dinode_core( 


	/* Read the inode cluster buffer. */

	error = xfs_trans_read_buf(sc->mp, sc->tp, sc->mp->m_ddev_targp,

			ri->imap.im_blkno, ri->imap.im_len, XBF_UNMAPPED, &bp,

			NULL);

			ri->imap.im_blkno, ri->imap.im_len, 0, &bp, NULL);

	if (error)

		return error;

fs/xfs/xfs_buf.c

+4 −54
Original line number Diff line number Diff line
@@ -145,7 +145,7 @@ _xfs_buf_alloc( 
	 * We don't want certain flags to appear in b_flags unless they are

	 * specifically set by later operations on the buffer.

	 */

	flags &= ~(XBF_UNMAPPED | XBF_TRYLOCK | XBF_ASYNC | XBF_READ_AHEAD);

	flags &= ~(XBF_TRYLOCK | XBF_ASYNC | XBF_READ_AHEAD);



	/*

	 * A new buffer is held and locked by the owner.  This ensures that the
@@ -289,9 +289,7 @@ xfs_buf_alloc_kmem( 
 *

 * The third type of buffer is the multi-page buffer. These are always made

 * up of single pages so that they can be fed to vmap_ram() to return a

 * contiguous memory region we can access the data through, or mark it as

 * XBF_UNMAPPED and access the data directly through individual page_address()

 * calls.

 * contiguous memory region we can access the data through.

 */

static int

xfs_buf_alloc_backing_mem(
@@ -413,8 +411,6 @@ _xfs_buf_map_pages( 
	if (bp->b_page_count == 1) {

		/* A single page buffer is always mappable */

		bp->b_addr = page_address(bp->b_pages[0]);

	} else if (flags & XBF_UNMAPPED) {

		bp->b_addr = NULL;

	} else {

		int retried = 0;

		unsigned nofs_flag;
@@ -1345,7 +1341,7 @@ __xfs_buf_ioend( 
	trace_xfs_buf_iodone(bp, _RET_IP_);



	if (bp->b_flags & XBF_READ) {

		if (!bp->b_error && bp->b_addr && is_vmalloc_addr(bp->b_addr))

		if (!bp->b_error && is_vmalloc_addr(bp->b_addr))

			invalidate_kernel_vmap_range(bp->b_addr,

					xfs_buf_vmap_len(bp));

		if (!bp->b_error && bp->b_ops)
@@ -1526,7 +1522,7 @@ xfs_buf_submit_bio( 
			__bio_add_page(bio, bp->b_pages[p], PAGE_SIZE, 0);

		bio->bi_iter.bi_size = size; /* limit to the actual size used */



		if (bp->b_addr && is_vmalloc_addr(bp->b_addr))

		if (is_vmalloc_addr(bp->b_addr))

			flush_kernel_vmap_range(bp->b_addr,

					xfs_buf_vmap_len(bp));

	}
@@ -1657,52 +1653,6 @@ xfs_buf_submit( 
	xfs_buf_submit_bio(bp);

}



void *

xfs_buf_offset(

	struct xfs_buf		*bp,

	size_t			offset)

{

	struct page		*page;



	if (bp->b_addr)

		return bp->b_addr + offset;



	page = bp->b_pages[offset >> PAGE_SHIFT];

	return page_address(page) + (offset & (PAGE_SIZE-1));

}



void

xfs_buf_zero(

	struct xfs_buf		*bp,

	size_t			boff,

	size_t			bsize)

{

	size_t			bend;



	if (bp->b_addr) {

		memset(bp->b_addr + boff, 0, bsize);

		return;

	}



	bend = boff + bsize;

	while (boff < bend) {

		struct page	*page;

		int		page_index, page_offset, csize;



		page_index = boff >> PAGE_SHIFT;

		page_offset = boff & ~PAGE_MASK;

		page = bp->b_pages[page_index];

		csize = min_t(size_t, PAGE_SIZE - page_offset,

				      BBTOB(bp->b_length) - boff);



		ASSERT((csize + page_offset) <= PAGE_SIZE);



		memset(page_address(page) + page_offset, 0, csize);



		boff += csize;

	}

}



/*

 * Log a message about and stale a buffer that a caller has decided is corrupt.

 *

fs/xfs/xfs_buf.h

+11 −5
Original line number Diff line number Diff line
@@ -48,7 +48,6 @@ struct xfs_buf; 
#define XBF_LIVESCAN	 (1u << 28)

#define XBF_INCORE	 (1u << 29)/* lookup only, return if found in cache */

#define XBF_TRYLOCK	 (1u << 30)/* lock requested, but do not wait */

#define XBF_UNMAPPED	 (1u << 31)/* do not map the buffer */





typedef unsigned int xfs_buf_flags_t;
@@ -68,8 +67,7 @@ typedef unsigned int xfs_buf_flags_t; 
	/* The following interface flags should never be set */ \

	{ XBF_LIVESCAN,		"LIVESCAN" }, \

	{ XBF_INCORE,		"INCORE" }, \

	{ XBF_TRYLOCK,		"TRYLOCK" }, \

	{ XBF_UNMAPPED,		"UNMAPPED" }

	{ XBF_TRYLOCK,		"TRYLOCK" }



/*

 * Internal state flags.
@@ -313,12 +311,20 @@ extern void __xfs_buf_ioerror(struct xfs_buf *bp, int error, 
#define xfs_buf_ioerror(bp, err) __xfs_buf_ioerror((bp), (err), __this_address)

extern void xfs_buf_ioerror_alert(struct xfs_buf *bp, xfs_failaddr_t fa);

void xfs_buf_ioend_fail(struct xfs_buf *);

void xfs_buf_zero(struct xfs_buf *bp, size_t boff, size_t bsize);

void __xfs_buf_mark_corrupt(struct xfs_buf *bp, xfs_failaddr_t fa);

#define xfs_buf_mark_corrupt(bp) __xfs_buf_mark_corrupt((bp), __this_address)



/* Buffer Utility Routines */

extern void *xfs_buf_offset(struct xfs_buf *, size_t);

static inline void *xfs_buf_offset(struct xfs_buf *bp, size_t offset)

{

	return bp->b_addr + offset;

}



static inline void xfs_buf_zero(struct xfs_buf *bp, size_t boff, size_t bsize)

{

	memset(bp->b_addr + boff, 0, bsize);

}



extern void xfs_buf_stale(struct xfs_buf *bp);



/* Delayed Write Buffer Routines */