motorhead/qemu
1
0
Fork 0
mirror of https://github.com/Motorhead1991/qemu.git synced 2025-08-10 02:54:58 -06:00
Code Issues Projects Releases Packages Wiki Activity Actions

block: Drop unused .bdrv_co_get_block_status()

Browse source 
We are gradually moving away from sector-based interfaces, towards
byte-based.  Now that all drivers have been updated to provide the
byte-based .bdrv_co_block_status(), we can delete the sector-based
interface.

Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
This commit is contained in:
Eric Blake 2018-02-13 14:27:01 -06:00 • committed by Kevin Wolf
parent fba3998dae
commit 636cb51258
2 changed files with 10 additions and 43 deletions
Download patch file Download diff file Expand all files Collapse all files

50
block/io.c
View file

@ -1963,7 +1963,7 @@ static int coroutine_fn bdrv_co_block_status(BlockDriverState *bs,
/* Must be non-NULL or bdrv_getlength() would have failed */ /* Must be non-NULL or bdrv_getlength() would have failed */
assert(bs->drv); assert(bs->drv);
if (!bs->drv->bdrv_co_get_block_status && !bs->drv->bdrv_co_block_status) { if (!bs->drv->bdrv_co_block_status) {
*pnum = bytes; *pnum = bytes;
ret = BDRV_BLOCK_DATA | BDRV_BLOCK_ALLOCATED; ret = BDRV_BLOCK_DATA | BDRV_BLOCK_ALLOCATED;
if (offset + bytes == total_size) { if (offset + bytes == total_size) {
@ -1981,53 +1981,23 @@ static int coroutine_fn bdrv_co_block_status(BlockDriverState *bs,
/* Round out to request_alignment boundaries */ /* Round out to request_alignment boundaries */
align = bs->bl.request_alignment; align = bs->bl.request_alignment;
if (bs->drv->bdrv_co_get_block_status && align < BDRV_SECTOR_SIZE) {
align = BDRV_SECTOR_SIZE;
}
aligned_offset = QEMU_ALIGN_DOWN(offset, align); aligned_offset = QEMU_ALIGN_DOWN(offset, align);
aligned_bytes = ROUND_UP(offset + bytes, align) - aligned_offset; aligned_bytes = ROUND_UP(offset + bytes, align) - aligned_offset;
if (bs->drv->bdrv_co_get_block_status) { ret = bs->drv->bdrv_co_block_status(bs, want_zero, aligned_offset,
int count; /* sectors */ aligned_bytes, pnum, &local_map,
int64_t longret; &local_file);
if (ret < 0) {
assert(QEMU_IS_ALIGNED(aligned_offset | aligned_bytes, *pnum = 0;
BDRV_SECTOR_SIZE)); goto out;
/*
* The contract allows us to return pnum smaller than bytes, even
* if the next query would see the same status; we truncate the
* request to avoid overflowing the driver's 32-bit interface.
*/
longret = bs->drv->bdrv_co_get_block_status(
bs, aligned_offset >> BDRV_SECTOR_BITS,
MIN(INT_MAX, aligned_bytes) >> BDRV_SECTOR_BITS, &count,
&local_file);
if (longret < 0) {
assert(INT_MIN <= longret);
ret = longret;
goto out;
}
if (longret & BDRV_BLOCK_OFFSET_VALID) {
local_map = longret & BDRV_BLOCK_OFFSET_MASK;
}
ret = longret & ~BDRV_BLOCK_OFFSET_MASK;
*pnum = count * BDRV_SECTOR_SIZE;
} else {
ret = bs->drv->bdrv_co_block_status(bs, want_zero, aligned_offset,
aligned_bytes, pnum, &local_map,
&local_file);
if (ret < 0) {
*pnum = 0;
goto out;
}
assert(*pnum); /* The block driver must make progress */
} }
/* /*
* The driver's result must be a multiple of request_alignment. * The driver's result must be a non-zero multiple of request_alignment.
* Clamp pnum and adjust map to original request. * Clamp pnum and adjust map to original request.
*/ */
assert(QEMU_IS_ALIGNED(*pnum, align) && align > offset - aligned_offset); assert(*pnum && QEMU_IS_ALIGNED(*pnum, align) &&
align > offset - aligned_offset);
*pnum -= offset - aligned_offset; *pnum -= offset - aligned_offset;
if (*pnum > bytes) { if (*pnum > bytes) {
*pnum = bytes; *pnum = bytes;

3
include/block/block_int.h
View file

@ -215,9 +215,6 @@ struct BlockDriver {
* as well as non-NULL pnum, map, and file; in turn, the driver * as well as non-NULL pnum, map, and file; in turn, the driver
* must return an error or set pnum to an aligned non-zero value. * must return an error or set pnum to an aligned non-zero value.
*/ */
int64_t coroutine_fn (*bdrv_co_get_block_status)(BlockDriverState *bs,
int64_t sector_num, int nb_sectors, int *pnum,
BlockDriverState **file);
int coroutine_fn (*bdrv_co_block_status)(BlockDriverState *bs, int coroutine_fn (*bdrv_co_block_status)(BlockDriverState *bs,
bool want_zero, int64_t offset, int64_t bytes, int64_t *pnum, bool want_zero, int64_t offset, int64_t bytes, int64_t *pnum,
int64_t *map, BlockDriverState **file); int64_t *map, BlockDriverState **file);