Commit aa0e8833 authored by Dave Chinner's avatar Dave Chinner Committed by Ben Myers
Browse files

xfs: use blocks for storing the desired IO size 



Now that we pass block counts everywhere, and index buffers by block
number and length in units of blocks, convert the desired IO size
into block counts rather than bytes. Convert the code to use block
counts, and those that need byte counts get converted at the time of
use.

Rename the b_desired_count variable to something closer to it's
purpose - b_io_length - as it is only used to specify the length of
an IO for a subset of the buffer.  The only time this is used is for
log IO - both writing iclogs and during log recovery. In all other
cases, the b_io_length matches b_length, and hence a lot of code
confuses the two. e.g. the buf item code uses the io count
exclusively when it should be using the buffer length. Fix these
apprpriately as they are found.

Also, remove the XFS_BUF_{SET_}COUNT() macros that are just wrappers
around the desired IO length. They only serve to make the code
shouty loud, don't actually add any real value, and are often used
incorrectly.

Signed-off-by: default avatarDave Chinner <dchinner@redhat.com>
Reviewed-by: default avatarChristoph Hellwig <hch@lst.de>
Reviewed-by: default avatarMark Tinguely <tinguely@sgi.com>
Signed-off-by: default avatarBen Myers <bpm@sgi.com>
parent 4e94b71b

fs/xfs/xfs_buf.c

+13 −13
Original line number Diff line number Diff line
@@ -198,12 +198,12 @@ xfs_buf_alloc( 
	bp->b_target = target;



	/*

	 * Set length and count_desired to the same value initially.

	 * I/O routines should use count_desired, which will be the same in

	 * Set length and io_length to the same value initially.

	 * I/O routines should use io_length, which will be the same in

	 * most cases but may be reset (e.g. XFS recovery).

	 */

	bp->b_length = numblks;

	bp->b_count_desired = numblks << BBSHIFT;

	bp->b_io_length = numblks;

	bp->b_flags = flags;



	/*
@@ -302,7 +302,7 @@ xfs_buf_allocate_memory( 
	xfs_buf_t		*bp,

	uint			flags)

{

	size_t			size = bp->b_count_desired;

	size_t			size;

	size_t			nbytes, offset;

	gfp_t			gfp_mask = xb_to_gfp(flags);

	unsigned short		page_count, i;
@@ -345,6 +345,7 @@ use_alloc_page: 
		return error;



	offset = bp->b_offset;

	size = BBTOB(bp->b_length);

	bp->b_flags |= _XBF_PAGES;



	for (i = 0; i < bp->b_page_count; i++) {
@@ -575,7 +576,7 @@ xfs_buf_get( 
	 * that we can do IO on it.

	 */

	bp->b_bn = blkno;

	bp->b_count_desired = BBTOB(bp->b_length);

	bp->b_io_length = bp->b_length;



found:

	if (!(bp->b_flags & XBF_MAPPED)) {
@@ -718,7 +719,7 @@ xfs_buf_set_empty( 
	bp->b_page_count = 0;

	bp->b_addr = NULL;

	bp->b_length = numblks;

	bp->b_count_desired = numblks << BBSHIFT;

	bp->b_io_length = numblks;

	bp->b_bn = XFS_BUF_DADDR_NULL;

	bp->b_flags &= ~XBF_MAPPED;

}
@@ -770,7 +771,7 @@ xfs_buf_associate_memory( 
		pageaddr += PAGE_SIZE;

	}



	bp->b_count_desired = len;

	bp->b_io_length = BTOBB(len);

	bp->b_length = BTOBB(buflen);

	bp->b_flags |= XBF_MAPPED;
@@ -1012,9 +1013,8 @@ xfs_buf_ioerror_alert( 
	const char		*func)

{

	xfs_alert(bp->b_target->bt_mount,

"metadata I/O error: block 0x%llx (\"%s\") error %d buf count %zd",

		(__uint64_t)XFS_BUF_ADDR(bp), func,

		bp->b_error, XFS_BUF_COUNT(bp));

"metadata I/O error: block 0x%llx (\"%s\") error %d numblks %d",

		(__uint64_t)XFS_BUF_ADDR(bp), func, bp->b_error, bp->b_length);

}



int
@@ -1186,7 +1186,7 @@ _xfs_buf_ioapply( 
	int			rw, map_i, total_nr_pages, nr_pages;

	struct bio		*bio;

	int			offset = bp->b_offset;

	int			size = bp->b_count_desired;

	int			size = BBTOB(bp->b_io_length);

	sector_t		sector = bp->b_bn;



	total_nr_pages = bp->b_page_count;
@@ -1234,7 +1234,7 @@ next_chunk: 
			break;



		offset = 0;

		sector += nbytes >> BBSHIFT;

		sector += BTOBB(nbytes);

		size -= nbytes;

		total_nr_pages--;

	}
@@ -1328,7 +1328,7 @@ xfs_buf_iomove( 
		page = bp->b_pages[xfs_buf_btoct(boff + bp->b_offset)];

		cpoff = xfs_buf_poff(boff + bp->b_offset);

		csize = min_t(size_t,

			      PAGE_SIZE-cpoff, bp->b_count_desired-boff);

			      PAGE_SIZE - cpoff, BBTOB(bp->b_io_length) - boff);



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

fs/xfs/xfs_buf.h

+1 −3
Original line number Diff line number Diff line
@@ -128,7 +128,6 @@ typedef struct xfs_buf { 
	struct list_head	b_list;

	struct xfs_perag	*b_pag;		/* contains rbtree root */

	xfs_buftarg_t		*b_target;	/* buffer target (device) */

	size_t			b_count_desired;/* desired transfer size */

	void			*b_addr;	/* virtual address of buffer */

	struct work_struct	b_iodone_work;

	xfs_buf_iodone_t	b_iodone;	/* I/O completion function */
@@ -137,6 +136,7 @@ typedef struct xfs_buf { 
	struct xfs_trans	*b_transp;

	struct page		**b_pages;	/* array of page pointers */

	struct page		*b_page_array[XB_PAGES]; /* inline pages */

	int			b_io_length;	/* IO size in BBs */

	atomic_t		b_pin_count;	/* pin count */

	atomic_t		b_io_remaining;	/* #outstanding I/O requests */

	unsigned int		b_page_count;	/* size of page array */
@@ -244,8 +244,6 @@ void xfs_buf_stale(struct xfs_buf *bp); 


#define XFS_BUF_ADDR(bp)		((bp)->b_bn)

#define XFS_BUF_SET_ADDR(bp, bno)	((bp)->b_bn = (xfs_daddr_t)(bno))

#define XFS_BUF_COUNT(bp)		((bp)->b_count_desired)

#define XFS_BUF_SET_COUNT(bp, cnt)	((bp)->b_count_desired = (cnt))



static inline void xfs_buf_set_ref(struct xfs_buf *bp, int lru_ref)

{

fs/xfs/xfs_buf_item.c

+8 −7
Original line number Diff line number Diff line
@@ -123,11 +123,11 @@ xfs_buf_item_log_check( 
	ASSERT(bip->bli_logged != NULL);



	bp = bip->bli_buf;

	ASSERT(XFS_BUF_COUNT(bp) > 0);

	ASSERT(bp->b_length > 0);

	ASSERT(bp->b_addr != NULL);

	orig = bip->bli_orig;

	buffer = bp->b_addr;

	for (x = 0; x < XFS_BUF_COUNT(bp); x++) {

	for (x = 0; x < BBTOB(bp->b_length); x++) {

		if (orig[x] != buffer[x] && !btst(bip->bli_logged, x)) {

			xfs_emerg(bp->b_mount,

				"%s: bip %x buffer %x orig %x index %d",
@@ -657,7 +657,8 @@ xfs_buf_item_init( 
	 * truncate any pieces.  map_size is the size of the

	 * bitmap needed to describe the chunks of the buffer.

	 */

	chunks = (int)((XFS_BUF_COUNT(bp) + (XFS_BLF_CHUNK - 1)) >> XFS_BLF_SHIFT);

	chunks = (int)((BBTOB(bp->b_length) + (XFS_BLF_CHUNK - 1)) >>

								XFS_BLF_SHIFT);

	map_size = (int)((chunks + NBWORD) >> BIT_TO_WORD_SHIFT);



	bip = (xfs_buf_log_item_t*)kmem_zone_zalloc(xfs_buf_item_zone,
@@ -667,7 +668,7 @@ xfs_buf_item_init( 
	xfs_buf_hold(bp);

	bip->bli_format.blf_type = XFS_LI_BUF;

	bip->bli_format.blf_blkno = (__int64_t)XFS_BUF_ADDR(bp);

	bip->bli_format.blf_len = (ushort)BTOBB(XFS_BUF_COUNT(bp));

	bip->bli_format.blf_len = (ushort)bp->b_length;

	bip->bli_format.blf_map_size = map_size;



#ifdef XFS_TRANS_DEBUG
@@ -679,9 +680,9 @@ xfs_buf_item_init( 
	 * the buffer to indicate which bytes the callers have asked

	 * to have logged.

	 */

	bip->bli_orig = (char *)kmem_alloc(XFS_BUF_COUNT(bp), KM_SLEEP);

	memcpy(bip->bli_orig, bp->b_addr, XFS_BUF_COUNT(bp));

	bip->bli_logged = (char *)kmem_zalloc(XFS_BUF_COUNT(bp) / NBBY, KM_SLEEP);

	bip->bli_orig = kmem_alloc(BBTOB(bp->b_length), KM_SLEEP);

	memcpy(bip->bli_orig, bp->b_addr, BBTOB(bp->b_length));

	bip->bli_logged = kmem_zalloc(BBTOB(bp->b_length) / NBBY, KM_SLEEP);

#endif



	/*

fs/xfs/xfs_da_btree.c

+8 −8
Original line number Diff line number Diff line
@@ -2277,20 +2277,20 @@ xfs_da_buf_make(int nbuf, xfs_buf_t **bps) 
	if (nbuf == 1) {

		dabuf->nbuf = 1;

		bp = bps[0];

		dabuf->bbcount = (short)BTOBB(XFS_BUF_COUNT(bp));

		dabuf->bbcount = bp->b_length;

		dabuf->data = bp->b_addr;

		dabuf->bps[0] = bp;

	} else {

		dabuf->nbuf = nbuf;

		for (i = 0, dabuf->bbcount = 0; i < nbuf; i++) {

			dabuf->bps[i] = bp = bps[i];

			dabuf->bbcount += BTOBB(XFS_BUF_COUNT(bp));

			dabuf->bbcount += bp->b_length;

		}

		dabuf->data = kmem_alloc(BBTOB(dabuf->bbcount), KM_SLEEP);

		for (i = off = 0; i < nbuf; i++, off += XFS_BUF_COUNT(bp)) {

		for (i = off = 0; i < nbuf; i++, off += BBTOB(bp->b_length)) {

			bp = bps[i];

			memcpy((char *)dabuf->data + off, bp->b_addr,

				XFS_BUF_COUNT(bp));

				BBTOB(bp->b_length));

		}

	}

	return dabuf;
@@ -2310,10 +2310,10 @@ xfs_da_buf_clean(xfs_dabuf_t *dabuf) 
		ASSERT(dabuf->nbuf > 1);

		dabuf->dirty = 0;

		for (i = off = 0; i < dabuf->nbuf;

				i++, off += XFS_BUF_COUNT(bp)) {

				i++, off += BBTOB(bp->b_length)) {

			bp = dabuf->bps[i];

			memcpy(bp->b_addr, dabuf->data + off,

						XFS_BUF_COUNT(bp));

						BBTOB(bp->b_length));

		}

	}

}
@@ -2356,10 +2356,10 @@ xfs_da_log_buf(xfs_trans_t *tp, xfs_dabuf_t *dabuf, uint first, uint last) 
	}

	dabuf->dirty = 1;

	ASSERT(first <= last);

	for (i = off = 0; i < dabuf->nbuf; i++, off += XFS_BUF_COUNT(bp)) {

	for (i = off = 0; i < dabuf->nbuf; i++, off += BBTOB(bp->b_length)) {

		bp = dabuf->bps[i];

		f = off;

		l = f + XFS_BUF_COUNT(bp) - 1;

		l = f + BBTOB(bp->b_length) - 1;

		if (f < first)

			f = first;

		if (l > last)

fs/xfs/xfs_log.c

+1 −1
Original line number Diff line number Diff line
@@ -1487,7 +1487,7 @@ xlog_sync(xlog_t *log, 
	} else {

		iclog->ic_bwritecnt = 1;

	}

	XFS_BUF_SET_COUNT(bp, count);

	bp->b_io_length = BTOBB(count);

	bp->b_fspriv = iclog;

	XFS_BUF_ZEROFLAGS(bp);

	XFS_BUF_ASYNC(bp);

CRA Git | Maintained and supported by SUSTech CRA and CCSE