leandrof/linux
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

xfs: clean up buffer get/read call API

Browse Source 
The xfs_buf_get/read API is not consistent in the units it uses, and
does not use appropriate or consistent units/types for the
variables.

Convert the API to use disk addresses and block counts for all
buffer get and read calls. Use consistent naming for all the
functions and their declarations, and convert the internal functions
to use disk addresses and block counts to avoid need to convert them
from one type to another and back again.

Fix all the callers to use disk addresses and block counts. In many
cases, this removes an additional conversion from the function call
as the callers already have a block count.

Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
This commit is contained in:
Dave Chinner 2012-04-23 15:58:49 +10:00 committed by Ben Myers
parent bf813cdddf
commit e70b73f84f
8 changed files with 83 additions and 73 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

86
fs/xfs/xfs_buf.c
View File

@ -172,8 +172,8 @@ xfs_buf_stale(
struct xfs_buf * struct xfs_buf *
xfs_buf_alloc( xfs_buf_alloc(
struct xfs_buftarg *target, struct xfs_buftarg *target,
xfs_off_t range_base, xfs_daddr_t blkno,
size_t range_length, size_t numblks,
xfs_buf_flags_t flags) xfs_buf_flags_t flags)
{ {
struct xfs_buf *bp; struct xfs_buf *bp;
@ -196,14 +196,21 @@ xfs_buf_alloc(
sema_init(&bp->b_sema, 0); /* held, no waiters */ sema_init(&bp->b_sema, 0); /* held, no waiters */
XB_SET_OWNER(bp); XB_SET_OWNER(bp);
bp->b_target = target; bp->b_target = target;
bp->b_file_offset = range_base; bp->b_file_offset = blkno << BBSHIFT;
/* /*
* Set buffer_length and count_desired to the same value initially. * Set buffer_length and count_desired to the same value initially.
* I/O routines should use count_desired, which will be the same in * I/O routines should use count_desired, which will be the same in
* most cases but may be reset (e.g. XFS recovery). * most cases but may be reset (e.g. XFS recovery).
*/ */
bp->b_buffer_length = bp->b_count_desired = range_length; bp->b_buffer_length = bp->b_count_desired = numblks << BBSHIFT;
bp->b_flags = flags; bp->b_flags = flags;
/*
* We do not set the block number here in the buffer because we have not
* finished initialising the buffer. We insert the buffer into the cache
* in this state, so this ensures that we are unable to do IO on a
* buffer that hasn't been fully initialised.
*/
bp->b_bn = XFS_BUF_DADDR_NULL; bp->b_bn = XFS_BUF_DADDR_NULL;
atomic_set(&bp->b_pin_count, 0); atomic_set(&bp->b_pin_count, 0);
init_waitqueue_head(&bp->b_waiters); init_waitqueue_head(&bp->b_waiters);
@ -426,29 +433,29 @@ _xfs_buf_map_pages(
*/ */
xfs_buf_t * xfs_buf_t *
_xfs_buf_find( _xfs_buf_find(
xfs_buftarg_t *btp, /* block device target */ struct xfs_buftarg *btp,
xfs_off_t ioff, /* starting offset of range */ xfs_daddr_t blkno,
size_t isize, /* length of range */ size_t numblks,
xfs_buf_flags_t flags, xfs_buf_flags_t flags,
xfs_buf_t *new_bp) xfs_buf_t *new_bp)
{ {
xfs_off_t range_base; xfs_off_t offset;
size_t range_length; size_t numbytes;
struct xfs_perag *pag; struct xfs_perag *pag;
struct rb_node **rbp; struct rb_node **rbp;
struct rb_node *parent; struct rb_node *parent;
xfs_buf_t *bp; xfs_buf_t *bp;
range_base = (ioff << BBSHIFT); offset = BBTOB(blkno);
range_length = (isize << BBSHIFT); numbytes = BBTOB(numblks);
/* Check for IOs smaller than the sector size / not sector aligned */ /* Check for IOs smaller than the sector size / not sector aligned */
ASSERT(!(range_length < (1 << btp->bt_sshift))); ASSERT(!(numbytes < (1 << btp->bt_sshift)));
ASSERT(!(range_base & (xfs_off_t)btp->bt_smask)); ASSERT(!(offset & (xfs_off_t)btp->bt_smask));
/* get tree root */ /* get tree root */
pag = xfs_perag_get(btp->bt_mount, pag = xfs_perag_get(btp->bt_mount,
xfs_daddr_to_agno(btp->bt_mount, ioff)); xfs_daddr_to_agno(btp->bt_mount, blkno));
/* walk tree */ /* walk tree */
spin_lock(&pag->pag_buf_lock); spin_lock(&pag->pag_buf_lock);
@ -459,9 +466,9 @@ _xfs_buf_find(
parent = *rbp; parent = *rbp;
bp = rb_entry(parent, struct xfs_buf, b_rbnode); bp = rb_entry(parent, struct xfs_buf, b_rbnode);
if (range_base < bp->b_file_offset) if (offset < bp->b_file_offset)
rbp = &(*rbp)->rb_left; rbp = &(*rbp)->rb_left;
else if (range_base > bp->b_file_offset) else if (offset > bp->b_file_offset)
rbp = &(*rbp)->rb_right; rbp = &(*rbp)->rb_right;
else { else {
/* /*
@ -472,7 +479,7 @@ _xfs_buf_find(
* reallocating a busy extent. Skip this buffer and * reallocating a busy extent. Skip this buffer and
* continue searching to the right for an exact match. * continue searching to the right for an exact match.
*/ */
if (bp->b_buffer_length != range_length) { if (bp->b_buffer_length != numbytes) {
ASSERT(bp->b_flags & XBF_STALE); ASSERT(bp->b_flags & XBF_STALE);
rbp = &(*rbp)->rb_right; rbp = &(*rbp)->rb_right;
continue; continue;
@ -532,21 +539,20 @@ found:
*/ */
struct xfs_buf * struct xfs_buf *
xfs_buf_get( xfs_buf_get(
xfs_buftarg_t *target,/* target for buffer */ xfs_buftarg_t *target,
xfs_off_t ioff, /* starting offset of range */ xfs_daddr_t blkno,
size_t isize, /* length of range */ size_t numblks,
xfs_buf_flags_t flags) xfs_buf_flags_t flags)
{ {
struct xfs_buf *bp; struct xfs_buf *bp;
struct xfs_buf *new_bp; struct xfs_buf *new_bp;
int error = 0; int error = 0;
bp = _xfs_buf_find(target, ioff, isize, flags, NULL); bp = _xfs_buf_find(target, blkno, numblks, flags, NULL);
if (likely(bp)) if (likely(bp))
goto found; goto found;
new_bp = xfs_buf_alloc(target, ioff << BBSHIFT, isize << BBSHIFT, new_bp = xfs_buf_alloc(target, blkno, numblks, flags);
flags);
if (unlikely(!new_bp)) if (unlikely(!new_bp))
return NULL; return NULL;
@ -556,7 +562,7 @@ xfs_buf_get(
return NULL; return NULL;
} }
bp = _xfs_buf_find(target, ioff, isize, flags, new_bp); bp = _xfs_buf_find(target, blkno, numblks, flags, new_bp);
if (!bp) { if (!bp) {
xfs_buf_free(new_bp); xfs_buf_free(new_bp);
return NULL; return NULL;
@ -569,7 +575,7 @@ xfs_buf_get(
* Now we have a workable buffer, fill in the block number so * Now we have a workable buffer, fill in the block number so
* that we can do IO on it. * that we can do IO on it.
*/ */
bp->b_bn = ioff; bp->b_bn = blkno;
bp->b_count_desired = bp->b_buffer_length; bp->b_count_desired = bp->b_buffer_length;
found: found:
@ -613,15 +619,15 @@ _xfs_buf_read(
xfs_buf_t * xfs_buf_t *
xfs_buf_read( xfs_buf_read(
xfs_buftarg_t *target, xfs_buftarg_t *target,
xfs_off_t ioff, xfs_daddr_t blkno,
size_t isize, size_t numblks,
xfs_buf_flags_t flags) xfs_buf_flags_t flags)
{ {
xfs_buf_t *bp; xfs_buf_t *bp;
flags |= XBF_READ; flags |= XBF_READ;
bp = xfs_buf_get(target, ioff, isize, flags); bp = xfs_buf_get(target, blkno, numblks, flags);
if (bp) { if (bp) {
trace_xfs_buf_read(bp, flags, _RET_IP_); trace_xfs_buf_read(bp, flags, _RET_IP_);
@ -656,13 +662,13 @@ xfs_buf_read(
void void
xfs_buf_readahead( xfs_buf_readahead(
xfs_buftarg_t *target, xfs_buftarg_t *target,
xfs_off_t ioff, xfs_daddr_t blkno,
size_t isize) size_t numblks)
{ {
if (bdi_read_congested(target->bt_bdi)) if (bdi_read_congested(target->bt_bdi))
return; return;
xfs_buf_read(target, ioff, isize, xfs_buf_read(target, blkno, numblks,
XBF_TRYLOCK|XBF_ASYNC|XBF_READ_AHEAD|XBF_DONT_BLOCK); XBF_TRYLOCK|XBF_ASYNC|XBF_READ_AHEAD|XBF_DONT_BLOCK);
} }
@ -672,16 +678,15 @@ xfs_buf_readahead(
*/ */
struct xfs_buf * struct xfs_buf *
xfs_buf_read_uncached( xfs_buf_read_uncached(
struct xfs_mount *mp,
struct xfs_buftarg *target, struct xfs_buftarg *target,
xfs_daddr_t daddr, xfs_daddr_t daddr,
size_t length, size_t numblks,
int flags) int flags)
{ {
xfs_buf_t *bp; xfs_buf_t *bp;
int error; int error;
bp = xfs_buf_get_uncached(target, length, flags); bp = xfs_buf_get_uncached(target, numblks, flags);
if (!bp) if (!bp)
return NULL; return NULL;
@ -689,7 +694,7 @@ xfs_buf_read_uncached(
XFS_BUF_SET_ADDR(bp, daddr); XFS_BUF_SET_ADDR(bp, daddr);
XFS_BUF_READ(bp); XFS_BUF_READ(bp);
xfsbdstrat(mp, bp); xfsbdstrat(target->bt_mount, bp);
error = xfs_buf_iowait(bp); error = xfs_buf_iowait(bp);
if (error) { if (error) {
xfs_buf_relse(bp); xfs_buf_relse(bp);
@ -705,7 +710,7 @@ xfs_buf_read_uncached(
void void
xfs_buf_set_empty( xfs_buf_set_empty(
struct xfs_buf *bp, struct xfs_buf *bp,
size_t len) size_t numblks)
{ {
if (bp->b_pages) if (bp->b_pages)
_xfs_buf_free_pages(bp); _xfs_buf_free_pages(bp);
@ -714,7 +719,7 @@ xfs_buf_set_empty(
bp->b_page_count = 0; bp->b_page_count = 0;
bp->b_addr = NULL; bp->b_addr = NULL;
bp->b_file_offset = 0; bp->b_file_offset = 0;
bp->b_buffer_length = bp->b_count_desired = len; bp->b_buffer_length = bp->b_count_desired = numblks << BBSHIFT;
bp->b_bn = XFS_BUF_DADDR_NULL; bp->b_bn = XFS_BUF_DADDR_NULL;
bp->b_flags &= ~XBF_MAPPED; bp->b_flags &= ~XBF_MAPPED;
} }
@ -776,17 +781,18 @@ xfs_buf_associate_memory(
xfs_buf_t * xfs_buf_t *
xfs_buf_get_uncached( xfs_buf_get_uncached(
struct xfs_buftarg *target, struct xfs_buftarg *target,
size_t len, size_t numblks,
int flags) int flags)
{ {
unsigned long page_count = PAGE_ALIGN(len) >> PAGE_SHIFT; unsigned long page_count;
int error, i; int error, i;
xfs_buf_t *bp; xfs_buf_t *bp;
bp = xfs_buf_alloc(target, 0, len, 0); bp = xfs_buf_alloc(target, 0, numblks, 0);
if (unlikely(bp == NULL)) if (unlikely(bp == NULL))
goto fail; goto fail;
page_count = PAGE_ALIGN(numblks << BBSHIFT) >> PAGE_SHIFT;
error = _xfs_buf_get_pages(bp, page_count, 0); error = _xfs_buf_get_pages(bp, page_count, 0);
if (error) if (error)
goto fail_free_buf; goto fail_free_buf;

36
fs/xfs/xfs_buf.h
View File

@ -150,26 +150,30 @@ typedef struct xfs_buf {
/* Finding and Reading Buffers */ /* Finding and Reading Buffers */
extern xfs_buf_t *_xfs_buf_find(xfs_buftarg_t *, xfs_off_t, size_t, struct xfs_buf *_xfs_buf_find(struct xfs_buftarg *target, xfs_daddr_t blkno,
xfs_buf_flags_t, xfs_buf_t *); size_t numblks, xfs_buf_flags_t flags,
struct xfs_buf *new_bp);
#define xfs_incore(buftarg,blkno,len,lockit) \ #define xfs_incore(buftarg,blkno,len,lockit) \
_xfs_buf_find(buftarg, blkno ,len, lockit, NULL) _xfs_buf_find(buftarg, blkno ,len, lockit, NULL)
extern xfs_buf_t *xfs_buf_get(xfs_buftarg_t *, xfs_off_t, size_t, struct xfs_buf *xfs_buf_get(struct xfs_buftarg *target, xfs_daddr_t blkno,
xfs_buf_flags_t); size_t numblks, xfs_buf_flags_t flags);
extern xfs_buf_t *xfs_buf_read(xfs_buftarg_t *, xfs_off_t, size_t, struct xfs_buf *xfs_buf_read(struct xfs_buftarg *target, xfs_daddr_t blkno,
xfs_buf_flags_t); size_t numblks, xfs_buf_flags_t flags);
void xfs_buf_readahead(struct xfs_buftarg *target, xfs_daddr_t blkno,
size_t numblks);
struct xfs_buf *xfs_buf_alloc(struct xfs_buftarg *, xfs_off_t, size_t, struct xfs_buf *xfs_buf_get_empty(struct xfs_buftarg *target, size_t numblks);
xfs_buf_flags_t); struct xfs_buf *xfs_buf_alloc(struct xfs_buftarg *target, xfs_daddr_t blkno,
extern void xfs_buf_set_empty(struct xfs_buf *bp, size_t len); size_t numblks, xfs_buf_flags_t flags);
extern xfs_buf_t *xfs_buf_get_uncached(struct xfs_buftarg *, size_t, int); void xfs_buf_set_empty(struct xfs_buf *bp, size_t numblks);
extern int xfs_buf_associate_memory(xfs_buf_t *, void *, size_t); int xfs_buf_associate_memory(struct xfs_buf *bp, void *mem, size_t length);
extern void xfs_buf_hold(xfs_buf_t *);
extern void xfs_buf_readahead(xfs_buftarg_t *, xfs_off_t, size_t); struct xfs_buf *xfs_buf_get_uncached(struct xfs_buftarg *target, size_t numblks,
struct xfs_buf *xfs_buf_read_uncached(struct xfs_mount *mp, int flags);
struct xfs_buftarg *target, struct xfs_buf *xfs_buf_read_uncached(struct xfs_buftarg *target,
xfs_daddr_t daddr, size_t length, int flags); xfs_daddr_t daddr, size_t numblks, int flags);
void xfs_buf_hold(struct xfs_buf *bp);
/* Releasing Buffers */ /* Releasing Buffers */
extern void xfs_buf_free(xfs_buf_t *); extern void xfs_buf_free(xfs_buf_t *);

4
fs/xfs/xfs_fsops.c
View File

@ -147,9 +147,9 @@ xfs_growfs_data_private(
if ((error = xfs_sb_validate_fsb_count(&mp->m_sb, nb))) if ((error = xfs_sb_validate_fsb_count(&mp->m_sb, nb)))
return error; return error;
dpct = pct - mp->m_sb.sb_imax_pct; dpct = pct - mp->m_sb.sb_imax_pct;
bp = xfs_buf_read_uncached(mp, mp->m_ddev_targp, bp = xfs_buf_read_uncached(mp->m_ddev_targp,
XFS_FSB_TO_BB(mp, nb) - XFS_FSS_TO_BB(mp, 1), XFS_FSB_TO_BB(mp, nb) - XFS_FSS_TO_BB(mp, 1),
BBTOB(XFS_FSS_TO_BB(mp, 1)), 0); XFS_FSS_TO_BB(mp, 1), 0);
if (!bp) if (!bp)
return EIO; return EIO;
xfs_buf_relse(bp); xfs_buf_relse(bp);

6
fs/xfs/xfs_log.c
View File

@ -1187,7 +1187,7 @@ xlog_alloc_log(xfs_mount_t *mp,
xlog_get_iclog_buffer_size(mp, log); xlog_get_iclog_buffer_size(mp, log);
error = ENOMEM; error = ENOMEM;
bp = xfs_buf_alloc(mp->m_logdev_targp, 0, log->l_iclog_size, 0); bp = xfs_buf_alloc(mp->m_logdev_targp, 0, BTOBB(log->l_iclog_size), 0);
if (!bp) if (!bp)
goto out_free_log; goto out_free_log;
bp->b_iodone = xlog_iodone; bp->b_iodone = xlog_iodone;
@ -1219,7 +1219,7 @@ xlog_alloc_log(xfs_mount_t *mp,
prev_iclog = iclog; prev_iclog = iclog;
bp = xfs_buf_get_uncached(mp->m_logdev_targp, bp = xfs_buf_get_uncached(mp->m_logdev_targp,
log->l_iclog_size, 0); BTOBB(log->l_iclog_size), 0);
if (!bp) if (!bp)
goto out_free_iclog; goto out_free_iclog;
@ -1588,7 +1588,7 @@ xlog_dealloc_log(xlog_t *log)
* always need to ensure that the extra buffer does not point to memory * always need to ensure that the extra buffer does not point to memory
* owned by another log buffer before we free it. * owned by another log buffer before we free it.
*/ */
xfs_buf_set_empty(log->l_xbuf, log->l_iclog_size); xfs_buf_set_empty(log->l_xbuf, BTOBB(log->l_iclog_size));
xfs_buf_free(log->l_xbuf); xfs_buf_free(log->l_xbuf);
iclog = log->l_iclog; iclog = log->l_iclog;

2
fs/xfs/xfs_log_recover.c
View File

@ -120,7 +120,7 @@ xlog_get_bp(
nbblks += log->l_sectBBsize; nbblks += log->l_sectBBsize;
nbblks = round_up(nbblks, log->l_sectBBsize); nbblks = round_up(nbblks, log->l_sectBBsize);
bp = xfs_buf_get_uncached(log->l_mp->m_logdev_targp, BBTOB(nbblks), 0); bp = xfs_buf_get_uncached(log->l_mp->m_logdev_targp, nbblks, 0);
if (bp) if (bp)
xfs_buf_unlock(bp); xfs_buf_unlock(bp);
return bp; return bp;

12
fs/xfs/xfs_mount.c
View File

@ -684,8 +684,8 @@ xfs_readsb(xfs_mount_t *mp, int flags)
sector_size = xfs_getsize_buftarg(mp->m_ddev_targp); sector_size = xfs_getsize_buftarg(mp->m_ddev_targp);
reread: reread:
bp = xfs_buf_read_uncached(mp, mp->m_ddev_targp, bp = xfs_buf_read_uncached(mp->m_ddev_targp, XFS_SB_DADDR,
XFS_SB_DADDR, sector_size, 0); BTOBB(sector_size), 0);
if (!bp) { if (!bp) {
if (loud) if (loud)
xfs_warn(mp, "SB buffer read failed"); xfs_warn(mp, "SB buffer read failed");
@ -1033,9 +1033,9 @@ xfs_check_sizes(xfs_mount_t *mp)
xfs_warn(mp, "filesystem size mismatch detected"); xfs_warn(mp, "filesystem size mismatch detected");
return XFS_ERROR(EFBIG); return XFS_ERROR(EFBIG);
} }
bp = xfs_buf_read_uncached(mp, mp->m_ddev_targp, bp = xfs_buf_read_uncached(mp->m_ddev_targp,
d - XFS_FSS_TO_BB(mp, 1), d - XFS_FSS_TO_BB(mp, 1),
BBTOB(XFS_FSS_TO_BB(mp, 1)), 0); XFS_FSS_TO_BB(mp, 1), 0);
if (!bp) { if (!bp) {
xfs_warn(mp, "last sector read failed"); xfs_warn(mp, "last sector read failed");
return EIO; return EIO;
@ -1048,9 +1048,9 @@ xfs_check_sizes(xfs_mount_t *mp)
xfs_warn(mp, "log size mismatch detected"); xfs_warn(mp, "log size mismatch detected");
return XFS_ERROR(EFBIG); return XFS_ERROR(EFBIG);
} }
bp = xfs_buf_read_uncached(mp, mp->m_logdev_targp, bp = xfs_buf_read_uncached(mp->m_logdev_targp,
d - XFS_FSB_TO_BB(mp, 1), d - XFS_FSB_TO_BB(mp, 1),
XFS_FSB_TO_B(mp, 1), 0); XFS_FSB_TO_BB(mp, 1), 0);
if (!bp) { if (!bp) {
xfs_warn(mp, "log device read failed"); xfs_warn(mp, "log device read failed");
return EIO; return EIO;

8
fs/xfs/xfs_rtalloc.c
View File

@ -1872,9 +1872,9 @@ xfs_growfs_rt(
/* /*
* Read in the last block of the device, make sure it exists. * Read in the last block of the device, make sure it exists.
*/ */
bp = xfs_buf_read_uncached(mp, mp->m_rtdev_targp, bp = xfs_buf_read_uncached(mp->m_rtdev_targp,
XFS_FSB_TO_BB(mp, nrblocks - 1), XFS_FSB_TO_BB(mp, nrblocks - 1),
XFS_FSB_TO_B(mp, 1), 0); XFS_FSB_TO_BB(mp, 1), 0);
if (!bp) if (!bp)
return EIO; return EIO;
xfs_buf_relse(bp); xfs_buf_relse(bp);
@ -2219,9 +2219,9 @@ xfs_rtmount_init(
(unsigned long long) mp->m_sb.sb_rblocks); (unsigned long long) mp->m_sb.sb_rblocks);
return XFS_ERROR(EFBIG); return XFS_ERROR(EFBIG);
} }
bp = xfs_buf_read_uncached(mp, mp->m_rtdev_targp, bp = xfs_buf_read_uncached(mp->m_rtdev_targp,
d - XFS_FSB_TO_BB(mp, 1), d - XFS_FSB_TO_BB(mp, 1),
XFS_FSB_TO_B(mp, 1), 0); XFS_FSB_TO_BB(mp, 1), 0);
if (!bp) { if (!bp) {
xfs_warn(mp, "realtime device size check failed"); xfs_warn(mp, "realtime device size check failed");
return EIO; return EIO;

2
fs/xfs/xfs_vnodeops.c
View File

@ -1966,7 +1966,7 @@ xfs_zero_remaining_bytes(
bp = xfs_buf_get_uncached(XFS_IS_REALTIME_INODE(ip) ? bp = xfs_buf_get_uncached(XFS_IS_REALTIME_INODE(ip) ?
mp->m_rtdev_targp : mp->m_ddev_targp, mp->m_rtdev_targp : mp->m_ddev_targp,
mp->m_sb.sb_blocksize, XBF_DONT_BLOCK); BTOBB(mp->m_sb.sb_blocksize), XBF_DONT_BLOCK);
if (!bp) if (!bp)
return XFS_ERROR(ENOMEM); return XFS_ERROR(ENOMEM);