SYS-OSS/FRET-qemu
4
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

block: Convert bdrv_refresh_total_sectors() to co_wrapper_mixed

Browse Source 
BlockDriver->bdrv_getlength is categorized as IO callback, and it
currently doesn't run in a coroutine. We should let it take a graph
rdlock since the callback traverses the block nodes graph, which however
is only possible in a coroutine.

Therefore turn it into a co_wrapper to move the actual function into a
coroutine where the lock can be taken.

Because now this function creates a new coroutine and polls, we need to
take the AioContext lock where it is missing, for the only reason that
internally co_wrapper calls AIO_WAIT_WHILE and it expects to release the
AioContext lock.

This is especially messy when a co_wrapper creates a coroutine and polls
in bdrv_open_driver, because this function has so many callers in so
many context that it can easily lead to deadlocks. Therefore the new
rule for bdrv_open_driver is that the caller must always hold the
AioContext lock of the given bs (except if it is a coroutine), because
the function calls bdrv_refresh_total_sectors() which is now a
co_wrapper.

Once the rwlock is ultimated and placed in every place it needs to be,
we will poll using AIO_WAIT_WHILE_UNLOCKED and remove the AioContext
lock.

Signed-off-by: Emanuele Giuseppe Esposito <eesposit@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Message-Id: <20230113204212.359076-7-kwolf@redhat.com>
Reviewed-by: Emanuele Giuseppe Esposito <eesposit@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
This commit is contained in:
Emanuele Giuseppe Esposito 2023-01-13 21:42:04 +01:00 committed by Kevin Wolf
parent c057960c4e
commit c86422c554
35 changed files with 161 additions and 121 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
block.c
View File

@ -1035,7 +1035,8 @@ static int find_image_format(BlockBackend *file, const char *filename,
* Set the current 'total_sectors' value * Set the current 'total_sectors' value
* Return 0 on success, -errno on error. * Return 0 on success, -errno on error.
*/ */
int bdrv_refresh_total_sectors(BlockDriverState *bs, int64_t hint) int coroutine_fn bdrv_co_refresh_total_sectors(BlockDriverState *bs,
int64_t hint)
{ {
BlockDriver *drv = bs->drv; BlockDriver *drv = bs->drv;
IO_CODE(); IO_CODE();
@ -1044,13 +1045,13 @@ int bdrv_refresh_total_sectors(BlockDriverState *bs, int64_t hint)
return -ENOMEDIUM; return -ENOMEDIUM;
} }
/* Do not attempt drv->bdrv_getlength() on scsi-generic devices */ /* Do not attempt drv->bdrv_co_getlength() on scsi-generic devices */
if (bdrv_is_sg(bs)) if (bdrv_is_sg(bs))
return 0; return 0;
/* query actual device if possible, otherwise just trust the hint */ /* query actual device if possible, otherwise just trust the hint */
if (drv->bdrv_getlength) { if (drv->bdrv_co_getlength) {
int64_t length = drv->bdrv_getlength(bs); int64_t length = drv->bdrv_co_getlength(bs);
if (length < 0) { if (length < 0) {
return length; return length;
} }
@ -1601,6 +1602,11 @@ out:
g_free(gen_node_name); g_free(gen_node_name);
} }
/*
* The caller must always hold @bs AioContext lock, because this function calls
* bdrv_refresh_total_sectors() which polls when called from non-coroutine
* context.
*/
static int bdrv_open_driver(BlockDriverState *bs, BlockDriver *drv, static int bdrv_open_driver(BlockDriverState *bs, BlockDriver *drv,
const char *node_name, QDict *options, const char *node_name, QDict *options,
int open_flags, Error **errp) int open_flags, Error **errp)
@ -3796,6 +3802,10 @@ out:
* The reference parameter may be used to specify an existing block device which * The reference parameter may be used to specify an existing block device which
* should be opened. If specified, neither options nor a filename may be given, * should be opened. If specified, neither options nor a filename may be given,
* nor can an existing BDS be reused (that is, *pbs has to be NULL). * nor can an existing BDS be reused (that is, *pbs has to be NULL).
*
* The caller must always hold @filename AioContext lock, because this
* function eventually calls bdrv_refresh_total_sectors() which polls
* when called from non-coroutine context.
*/ */
static BlockDriverState *bdrv_open_inherit(const char *filename, static BlockDriverState *bdrv_open_inherit(const char *filename,
const char *reference, const char *reference,
@ -4084,6 +4094,11 @@ close_and_fail:
return NULL; return NULL;
} }
/*
* The caller must always hold @filename AioContext lock, because this
* function eventually calls bdrv_refresh_total_sectors() which polls
* when called from non-coroutine context.
*/
BlockDriverState *bdrv_open(const char *filename, const char *reference, BlockDriverState *bdrv_open(const char *filename, const char *reference,
QDict *options, int flags, Error **errp) QDict *options, int flags, Error **errp)
{ {
@ -5800,7 +5815,7 @@ BlockMeasureInfo *bdrv_measure(BlockDriver *drv, QemuOpts *opts,
/** /**
* Return number of sectors on success, -errno on error. * Return number of sectors on success, -errno on error.
*/ */
int64_t bdrv_nb_sectors(BlockDriverState *bs) int64_t coroutine_fn bdrv_co_nb_sectors(BlockDriverState *bs)
{ {
BlockDriver *drv = bs->drv; BlockDriver *drv = bs->drv;
IO_CODE(); IO_CODE();
@ -5809,7 +5824,7 @@ int64_t bdrv_nb_sectors(BlockDriverState *bs)
return -ENOMEDIUM; return -ENOMEDIUM;
if (drv->has_variable_length) { if (drv->has_variable_length) {
int ret = bdrv_refresh_total_sectors(bs, bs->total_sectors); int ret = bdrv_co_refresh_total_sectors(bs, bs->total_sectors);
if (ret < 0) { if (ret < 0) {
return ret; return ret;
} }
@ -5821,11 +5836,12 @@ int64_t bdrv_nb_sectors(BlockDriverState *bs)
* Return length in bytes on success, -errno on error. * Return length in bytes on success, -errno on error.
* The length is always a multiple of BDRV_SECTOR_SIZE. * The length is always a multiple of BDRV_SECTOR_SIZE.
*/ */
int64_t bdrv_getlength(BlockDriverState *bs) int64_t coroutine_fn bdrv_co_getlength(BlockDriverState *bs)
{ {
int64_t ret = bdrv_nb_sectors(bs); int64_t ret;
IO_CODE(); IO_CODE();
ret = bdrv_co_nb_sectors(bs);
if (ret < 0) { if (ret < 0) {
return ret; return ret;
} }

6
block/blkdebug.c
View File

@ -966,9 +966,9 @@ static bool blkdebug_debug_is_suspended(BlockDriverState *bs, const char *tag)
return false; return false;
} }
static int64_t blkdebug_getlength(BlockDriverState *bs) static int64_t coroutine_fn blkdebug_co_getlength(BlockDriverState *bs)
{ {
return bdrv_getlength(bs->file->bs); return bdrv_co_getlength(bs->file->bs);
} }
static void blkdebug_refresh_filename(BlockDriverState *bs) static void blkdebug_refresh_filename(BlockDriverState *bs)
@ -1075,7 +1075,7 @@ static BlockDriver bdrv_blkdebug = {
.bdrv_reopen_prepare = blkdebug_reopen_prepare, .bdrv_reopen_prepare = blkdebug_reopen_prepare,
.bdrv_child_perm = blkdebug_child_perm, .bdrv_child_perm = blkdebug_child_perm,
.bdrv_getlength = blkdebug_getlength, .bdrv_co_getlength = blkdebug_co_getlength,
.bdrv_refresh_filename = blkdebug_refresh_filename, .bdrv_refresh_filename = blkdebug_refresh_filename,
.bdrv_refresh_limits = blkdebug_refresh_limits, .bdrv_refresh_limits = blkdebug_refresh_limits,

6
block/blkio.c
View File

@ -839,7 +839,7 @@ static void blkio_close(BlockDriverState *bs)
} }
} }
static int64_t blkio_getlength(BlockDriverState *bs) static int64_t coroutine_fn blkio_co_getlength(BlockDriverState *bs)
{ {
BDRVBlkioState *s = bs->opaque; BDRVBlkioState *s = bs->opaque;
uint64_t capacity; uint64_t capacity;
@ -867,7 +867,7 @@ static int coroutine_fn blkio_truncate(BlockDriverState *bs, int64_t offset,
return -ENOTSUP; return -ENOTSUP;
} }
current_length = blkio_getlength(bs); current_length = blkio_co_getlength(bs);
if (offset > current_length) { if (offset > current_length) {
error_setg(errp, "Cannot grow device"); error_setg(errp, "Cannot grow device");
@ -998,7 +998,7 @@ static void blkio_refresh_limits(BlockDriverState *bs, Error **errp)
.instance_size = sizeof(BDRVBlkioState), \ .instance_size = sizeof(BDRVBlkioState), \
.bdrv_file_open = blkio_file_open, \ .bdrv_file_open = blkio_file_open, \
.bdrv_close = blkio_close, \ .bdrv_close = blkio_close, \
.bdrv_getlength = blkio_getlength, \ .bdrv_co_getlength = blkio_co_getlength, \
.bdrv_co_truncate = blkio_truncate, \ .bdrv_co_truncate = blkio_truncate, \
.bdrv_get_info = blkio_get_info, \ .bdrv_get_info = blkio_get_info, \
.bdrv_attach_aio_context = blkio_attach_aio_context, \ .bdrv_attach_aio_context = blkio_attach_aio_context, \

6
block/blklogwrites.c
View File

@ -267,9 +267,9 @@ static void blk_log_writes_close(BlockDriverState *bs)
s->log_file = NULL; s->log_file = NULL;
} }
static int64_t blk_log_writes_getlength(BlockDriverState *bs) static int64_t coroutine_fn blk_log_writes_co_getlength(BlockDriverState *bs)
{ {
return bdrv_getlength(bs->file->bs); return bdrv_co_getlength(bs->file->bs);
} }
static void blk_log_writes_child_perm(BlockDriverState *bs, BdrvChild *c, static void blk_log_writes_child_perm(BlockDriverState *bs, BdrvChild *c,
@ -498,7 +498,7 @@ static BlockDriver bdrv_blk_log_writes = {
.bdrv_open = blk_log_writes_open, .bdrv_open = blk_log_writes_open,
.bdrv_close = blk_log_writes_close, .bdrv_close = blk_log_writes_close,
.bdrv_getlength = blk_log_writes_getlength, .bdrv_co_getlength = blk_log_writes_co_getlength,
.bdrv_child_perm = blk_log_writes_child_perm, .bdrv_child_perm = blk_log_writes_child_perm,
.bdrv_refresh_limits = blk_log_writes_refresh_limits, .bdrv_refresh_limits = blk_log_writes_refresh_limits,

6
block/blkreplay.c
View File

@ -40,9 +40,9 @@ fail:
return ret; return ret;
} }
static int64_t blkreplay_getlength(BlockDriverState *bs) static int64_t coroutine_fn blkreplay_co_getlength(BlockDriverState *bs)
{ {
return bdrv_getlength(bs->file->bs); return bdrv_co_getlength(bs->file->bs);
} }
/* This bh is used for synchronization of return from coroutines. /* This bh is used for synchronization of return from coroutines.
@ -136,7 +136,7 @@ static BlockDriver bdrv_blkreplay = {
.bdrv_open = blkreplay_open, .bdrv_open = blkreplay_open,
.bdrv_child_perm = bdrv_default_perms, .bdrv_child_perm = bdrv_default_perms,
.bdrv_getlength = blkreplay_getlength, .bdrv_co_getlength = blkreplay_co_getlength,
.bdrv_co_preadv = blkreplay_co_preadv, .bdrv_co_preadv = blkreplay_co_preadv,
.bdrv_co_pwritev = blkreplay_co_pwritev, .bdrv_co_pwritev = blkreplay_co_pwritev,

6
block/blkverify.c
View File

@ -155,11 +155,11 @@ static void blkverify_close(BlockDriverState *bs)
s->test_file = NULL; s->test_file = NULL;
} }
static int64_t blkverify_getlength(BlockDriverState *bs) static int64_t coroutine_fn blkverify_co_getlength(BlockDriverState *bs)
{ {
BDRVBlkverifyState *s = bs->opaque; BDRVBlkverifyState *s = bs->opaque;
return bdrv_getlength(s->test_file->bs); return bdrv_co_getlength(s->test_file->bs);
} }
static void coroutine_fn blkverify_do_test_req(void *opaque) static void coroutine_fn blkverify_do_test_req(void *opaque)
@ -314,7 +314,7 @@ static BlockDriver bdrv_blkverify = {
.bdrv_file_open = blkverify_open, .bdrv_file_open = blkverify_open,
.bdrv_close = blkverify_close, .bdrv_close = blkverify_close,
.bdrv_child_perm = bdrv_default_perms, .bdrv_child_perm = bdrv_default_perms,
.bdrv_getlength = blkverify_getlength, .bdrv_co_getlength = blkverify_co_getlength,
.bdrv_refresh_filename = blkverify_refresh_filename, .bdrv_refresh_filename = blkverify_refresh_filename,
.bdrv_dirname = blkverify_dirname, .bdrv_dirname = blkverify_dirname,

10
block/block-backend.c
View File

@ -1599,14 +1599,15 @@ BlockAIOCB *blk_aio_pwrite_zeroes(BlockBackend *blk, int64_t offset,
flags | BDRV_REQ_ZERO_WRITE, cb, opaque); flags | BDRV_REQ_ZERO_WRITE, cb, opaque);
} }
int64_t blk_getlength(BlockBackend *blk) int64_t coroutine_fn blk_co_getlength(BlockBackend *blk)
{ {
IO_CODE(); IO_CODE();
if (!blk_is_available(blk)) { if (!blk_is_available(blk)) {
return -ENOMEDIUM; return -ENOMEDIUM;
} }
return bdrv_getlength(blk_bs(blk)); return bdrv_co_getlength(blk_bs(blk));
} }
void blk_get_geometry(BlockBackend *blk, uint64_t *nb_sectors_ptr) void blk_get_geometry(BlockBackend *blk, uint64_t *nb_sectors_ptr)
@ -1619,14 +1620,15 @@ void blk_get_geometry(BlockBackend *blk, uint64_t *nb_sectors_ptr)
} }
} }
int64_t blk_nb_sectors(BlockBackend *blk) int64_t coroutine_fn blk_co_nb_sectors(BlockBackend *blk)
{ {
IO_CODE(); IO_CODE();
if (!blk_is_available(blk)) { if (!blk_is_available(blk)) {
return -ENOMEDIUM; return -ENOMEDIUM;
} }
return bdrv_nb_sectors(blk_bs(blk)); return bdrv_co_nb_sectors(blk_bs(blk));
} }
BlockAIOCB *blk_aio_preadv(BlockBackend *blk, int64_t offset, BlockAIOCB *blk_aio_preadv(BlockBackend *blk, int64_t offset,

4
block/commit.c
View File

@ -123,13 +123,13 @@ static int coroutine_fn commit_run(Job *job, Error **errp)
QEMU_AUTO_VFREE void *buf = NULL; QEMU_AUTO_VFREE void *buf = NULL;
int64_t len, base_len; int64_t len, base_len;
len = blk_getlength(s->top); len = blk_co_getlength(s->top);
if (len < 0) { if (len < 0) {
return len; return len;
} }
job_progress_set_remaining(&s->common.job, len); job_progress_set_remaining(&s->common.job, len);
base_len = blk_getlength(s->base); base_len = blk_co_getlength(s->base);
if (base_len < 0) { if (base_len < 0) {
return base_len; return base_len;
} }

6
block/copy-on-read.c
View File

@ -121,9 +121,9 @@ static void cor_child_perm(BlockDriverState *bs, BdrvChild *c,
} }
static int64_t cor_getlength(BlockDriverState *bs) static int64_t coroutine_fn cor_co_getlength(BlockDriverState *bs)
{ {
return bdrv_getlength(bs->file->bs); return bdrv_co_getlength(bs->file->bs);
} }
@ -250,7 +250,7 @@ static BlockDriver bdrv_copy_on_read = {
.bdrv_close = cor_close, .bdrv_close = cor_close,
.bdrv_child_perm = cor_child_perm, .bdrv_child_perm = cor_child_perm,
.bdrv_getlength = cor_getlength, .bdrv_co_getlength = cor_co_getlength,
.bdrv_co_preadv_part = cor_co_preadv_part, .bdrv_co_preadv_part = cor_co_preadv_part,
.bdrv_co_pwritev_part = cor_co_pwritev_part, .bdrv_co_pwritev_part = cor_co_pwritev_part,

6
block/crypto.c
View File

@ -531,10 +531,10 @@ static void block_crypto_refresh_limits(BlockDriverState *bs, Error **errp)
} }
static int64_t block_crypto_getlength(BlockDriverState *bs) static int64_t coroutine_fn block_crypto_co_getlength(BlockDriverState *bs)
{ {
BlockCrypto *crypto = bs->opaque; BlockCrypto *crypto = bs->opaque;
int64_t len = bdrv_getlength(bs->file->bs); int64_t len = bdrv_co_getlength(bs->file->bs);
uint64_t offset = qcrypto_block_get_payload_offset(crypto->block); uint64_t offset = qcrypto_block_get_payload_offset(crypto->block);
assert(offset < INT64_MAX); assert(offset < INT64_MAX);
@ -953,7 +953,7 @@ static BlockDriver bdrv_crypto_luks = {
.bdrv_refresh_limits = block_crypto_refresh_limits, .bdrv_refresh_limits = block_crypto_refresh_limits,
.bdrv_co_preadv = block_crypto_co_preadv, .bdrv_co_preadv = block_crypto_co_preadv,
.bdrv_co_pwritev = block_crypto_co_pwritev, .bdrv_co_pwritev = block_crypto_co_pwritev,
.bdrv_getlength = block_crypto_getlength, .bdrv_co_getlength = block_crypto_co_getlength,
.bdrv_measure = block_crypto_measure, .bdrv_measure = block_crypto_measure,
.bdrv_get_info = block_crypto_get_info_luks, .bdrv_get_info = block_crypto_get_info_luks,
.bdrv_get_specific_info = block_crypto_get_specific_info_luks, .bdrv_get_specific_info = block_crypto_get_specific_info_luks,

10
block/curl.c
View File

@ -958,7 +958,7 @@ static void curl_close(BlockDriverState *bs)
g_free(s->proxypassword); g_free(s->proxypassword);
} }
static int64_t curl_getlength(BlockDriverState *bs) static int64_t coroutine_fn curl_co_getlength(BlockDriverState *bs)
{ {
BDRVCURLState *s = bs->opaque; BDRVCURLState *s = bs->opaque;
return s->len; return s->len;
@ -1002,7 +1002,7 @@ static BlockDriver bdrv_http = {
.bdrv_parse_filename = curl_parse_filename, .bdrv_parse_filename = curl_parse_filename,
.bdrv_file_open = curl_open, .bdrv_file_open = curl_open,
.bdrv_close = curl_close, .bdrv_close = curl_close,
.bdrv_getlength = curl_getlength, .bdrv_co_getlength = curl_co_getlength,
.bdrv_co_preadv = curl_co_preadv, .bdrv_co_preadv = curl_co_preadv,
@ -1021,7 +1021,7 @@ static BlockDriver bdrv_https = {
.bdrv_parse_filename = curl_parse_filename, .bdrv_parse_filename = curl_parse_filename,
.bdrv_file_open = curl_open, .bdrv_file_open = curl_open,
.bdrv_close = curl_close, .bdrv_close = curl_close,
.bdrv_getlength = curl_getlength, .bdrv_co_getlength = curl_co_getlength,
.bdrv_co_preadv = curl_co_preadv, .bdrv_co_preadv = curl_co_preadv,
@ -1040,7 +1040,7 @@ static BlockDriver bdrv_ftp = {
.bdrv_parse_filename = curl_parse_filename, .bdrv_parse_filename = curl_parse_filename,
.bdrv_file_open = curl_open, .bdrv_file_open = curl_open,
.bdrv_close = curl_close, .bdrv_close = curl_close,
.bdrv_getlength = curl_getlength, .bdrv_co_getlength = curl_co_getlength,
.bdrv_co_preadv = curl_co_preadv, .bdrv_co_preadv = curl_co_preadv,
@ -1059,7 +1059,7 @@ static BlockDriver bdrv_ftps = {
.bdrv_parse_filename = curl_parse_filename, .bdrv_parse_filename = curl_parse_filename,
.bdrv_file_open = curl_open, .bdrv_file_open = curl_open,
.bdrv_close = curl_close, .bdrv_close = curl_close,
.bdrv_getlength = curl_getlength, .bdrv_co_getlength = curl_co_getlength,
.bdrv_co_preadv = curl_co_preadv, .bdrv_co_preadv = curl_co_preadv,

30
block/file-posix.c
View File

@ -189,7 +189,7 @@ static int fd_open(BlockDriverState *bs)
return -EIO; return -EIO;
} }
static int64_t raw_getlength(BlockDriverState *bs); static int64_t coroutine_fn raw_co_getlength(BlockDriverState *bs);
typedef struct RawPosixAIOData { typedef struct RawPosixAIOData {
BlockDriverState *bs; BlockDriverState *bs;
@ -2280,7 +2280,7 @@ static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,
} }
if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) { if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
int64_t cur_length = raw_getlength(bs); int64_t cur_length = raw_co_getlength(bs);
if (offset != cur_length && exact) { if (offset != cur_length && exact) {
error_setg(errp, "Cannot resize device files"); error_setg(errp, "Cannot resize device files");
@ -2298,7 +2298,7 @@ static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,
} }
#ifdef __OpenBSD__ #ifdef __OpenBSD__
static int64_t raw_getlength(BlockDriverState *bs) static int64_t coroutine_fn raw_co_getlength(BlockDriverState *bs)
{ {
BDRVRawState *s = bs->opaque; BDRVRawState *s = bs->opaque;
int fd = s->fd; int fd = s->fd;
@ -2317,7 +2317,7 @@ static int64_t raw_getlength(BlockDriverState *bs)
return st.st_size; return st.st_size;
} }
#elif defined(__NetBSD__) #elif defined(__NetBSD__)
static int64_t raw_getlength(BlockDriverState *bs) static int64_t coroutine_fn raw_co_getlength(BlockDriverState *bs)
{ {
BDRVRawState *s = bs->opaque; BDRVRawState *s = bs->opaque;
int fd = s->fd; int fd = s->fd;
@ -2342,7 +2342,7 @@ static int64_t raw_getlength(BlockDriverState *bs)
return st.st_size; return st.st_size;
} }
#elif defined(__sun__) #elif defined(__sun__)
static int64_t raw_getlength(BlockDriverState *bs) static int64_t coroutine_fn raw_co_getlength(BlockDriverState *bs)
{ {
BDRVRawState *s = bs->opaque; BDRVRawState *s = bs->opaque;
struct dk_minfo minfo; struct dk_minfo minfo;
@ -2373,7 +2373,7 @@ static int64_t raw_getlength(BlockDriverState *bs)
return size; return size;
} }
#elif defined(CONFIG_BSD) #elif defined(CONFIG_BSD)
static int64_t raw_getlength(BlockDriverState *bs) static int64_t coroutine_fn raw_co_getlength(BlockDriverState *bs)
{ {
BDRVRawState *s = bs->opaque; BDRVRawState *s = bs->opaque;
int fd = s->fd; int fd = s->fd;
@ -2445,7 +2445,7 @@ again:
return size; return size;
} }
#else #else
static int64_t raw_getlength(BlockDriverState *bs) static int64_t coroutine_fn raw_co_getlength(BlockDriverState *bs)
{ {
BDRVRawState *s = bs->opaque; BDRVRawState *s = bs->opaque;
int ret; int ret;
@ -2830,7 +2830,7 @@ static int coroutine_fn raw_co_block_status(BlockDriverState *bs,
* round up if necessary. * round up if necessary.
*/ */
if (!QEMU_IS_ALIGNED(*pnum, bs->bl.request_alignment)) { if (!QEMU_IS_ALIGNED(*pnum, bs->bl.request_alignment)) {
int64_t file_length = raw_getlength(bs); int64_t file_length = raw_co_getlength(bs);
if (file_length > 0) { if (file_length > 0) {
/* Ignore errors, this is just a safeguard */ /* Ignore errors, this is just a safeguard */
assert(hole == file_length); assert(hole == file_length);
@ -2852,7 +2852,7 @@ static int coroutine_fn raw_co_block_status(BlockDriverState *bs,
#if defined(__linux__) #if defined(__linux__)
/* Verify that the file is not in the page cache */ /* Verify that the file is not in the page cache */
static void check_cache_dropped(BlockDriverState *bs, Error **errp) static void coroutine_fn check_cache_dropped(BlockDriverState *bs, Error **errp)
{ {
const size_t window_size = 128 * 1024 * 1024; const size_t window_size = 128 * 1024 * 1024;
BDRVRawState *s = bs->opaque; BDRVRawState *s = bs->opaque;
@ -2867,7 +2867,7 @@ static void check_cache_dropped(BlockDriverState *bs, Error **errp)
page_size = sysconf(_SC_PAGESIZE); page_size = sysconf(_SC_PAGESIZE);
vec = g_malloc(DIV_ROUND_UP(window_size, page_size)); vec = g_malloc(DIV_ROUND_UP(window_size, page_size));
end = raw_getlength(bs); end = raw_co_getlength(bs);
for (offset = 0; offset < end; offset += window_size) { for (offset = 0; offset < end; offset += window_size) {
void *new_window; void *new_window;
@ -3322,7 +3322,7 @@ BlockDriver bdrv_file = {
.bdrv_attach_aio_context = raw_aio_attach_aio_context, .bdrv_attach_aio_context = raw_aio_attach_aio_context,
.bdrv_co_truncate = raw_co_truncate, .bdrv_co_truncate = raw_co_truncate,
.bdrv_getlength = raw_getlength, .bdrv_co_getlength = raw_co_getlength,
.bdrv_get_info = raw_get_info, .bdrv_get_info = raw_get_info,
.bdrv_get_allocated_file_size .bdrv_get_allocated_file_size
= raw_get_allocated_file_size, = raw_get_allocated_file_size,
@ -3694,7 +3694,7 @@ static BlockDriver bdrv_host_device = {
.bdrv_attach_aio_context = raw_aio_attach_aio_context, .bdrv_attach_aio_context = raw_aio_attach_aio_context,
.bdrv_co_truncate = raw_co_truncate, .bdrv_co_truncate = raw_co_truncate,
.bdrv_getlength = raw_getlength, .bdrv_co_getlength = raw_co_getlength,
.bdrv_get_info = raw_get_info, .bdrv_get_info = raw_get_info,
.bdrv_get_allocated_file_size .bdrv_get_allocated_file_size
= raw_get_allocated_file_size, = raw_get_allocated_file_size,
@ -3818,7 +3818,7 @@ static BlockDriver bdrv_host_cdrom = {
.bdrv_attach_aio_context = raw_aio_attach_aio_context, .bdrv_attach_aio_context = raw_aio_attach_aio_context,
.bdrv_co_truncate = raw_co_truncate, .bdrv_co_truncate = raw_co_truncate,
.bdrv_getlength = raw_getlength, .bdrv_co_getlength = raw_co_getlength,
.has_variable_length = true, .has_variable_length = true,
.bdrv_get_allocated_file_size .bdrv_get_allocated_file_size
= raw_get_allocated_file_size, = raw_get_allocated_file_size,
@ -3885,7 +3885,7 @@ static int cdrom_reopen(BlockDriverState *bs)
static bool coroutine_fn cdrom_co_is_inserted(BlockDriverState *bs) static bool coroutine_fn cdrom_co_is_inserted(BlockDriverState *bs)
{ {
return raw_getlength(bs) > 0; return raw_co_getlength(bs) > 0;
} }
static void cdrom_eject(BlockDriverState *bs, bool eject_flag) static void cdrom_eject(BlockDriverState *bs, bool eject_flag)
@ -3948,7 +3948,7 @@ static BlockDriver bdrv_host_cdrom = {
.bdrv_attach_aio_context = raw_aio_attach_aio_context, .bdrv_attach_aio_context = raw_aio_attach_aio_context,
.bdrv_co_truncate = raw_co_truncate, .bdrv_co_truncate = raw_co_truncate,
.bdrv_getlength = raw_getlength, .bdrv_co_getlength = raw_co_getlength,
.has_variable_length = true, .has_variable_length = true,
.bdrv_get_allocated_file_size .bdrv_get_allocated_file_size
= raw_get_allocated_file_size, = raw_get_allocated_file_size,

6
block/file-win32.c
View File

@ -526,7 +526,7 @@ static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,
return 0; return 0;
} }
static int64_t raw_getlength(BlockDriverState *bs) static int64_t coroutine_fn raw_co_getlength(BlockDriverState *bs)
{ {
BDRVRawState *s = bs->opaque; BDRVRawState *s = bs->opaque;
LARGE_INTEGER l; LARGE_INTEGER l;
@ -764,7 +764,7 @@ BlockDriver bdrv_file = {
.bdrv_aio_flush = raw_aio_flush, .bdrv_aio_flush = raw_aio_flush,
.bdrv_co_truncate = raw_co_truncate, .bdrv_co_truncate = raw_co_truncate,
.bdrv_getlength = raw_getlength, .bdrv_co_getlength = raw_co_getlength,
.bdrv_get_allocated_file_size .bdrv_get_allocated_file_size
= raw_get_allocated_file_size, = raw_get_allocated_file_size,
@ -933,7 +933,7 @@ static BlockDriver bdrv_host_device = {
.bdrv_detach_aio_context = raw_detach_aio_context, .bdrv_detach_aio_context = raw_detach_aio_context,
.bdrv_attach_aio_context = raw_attach_aio_context, .bdrv_attach_aio_context = raw_attach_aio_context,
.bdrv_getlength = raw_getlength, .bdrv_co_getlength = raw_co_getlength,
.has_variable_length = true, .has_variable_length = true,
.bdrv_get_allocated_file_size .bdrv_get_allocated_file_size

6
block/filter-compress.c
View File

@ -55,9 +55,9 @@ static int compress_open(BlockDriverState *bs, QDict *options, int flags,
} }
static int64_t compress_getlength(BlockDriverState *bs) static int64_t coroutine_fn compress_co_getlength(BlockDriverState *bs)
{ {
return bdrv_getlength(bs->file->bs); return bdrv_co_getlength(bs->file->bs);
} }
@ -135,7 +135,7 @@ static BlockDriver bdrv_compress = {
.bdrv_open = compress_open, .bdrv_open = compress_open,
.bdrv_child_perm = bdrv_default_perms, .bdrv_child_perm = bdrv_default_perms,
.bdrv_getlength = compress_getlength, .bdrv_co_getlength = compress_co_getlength,
.bdrv_co_preadv_part = compress_co_preadv_part, .bdrv_co_preadv_part = compress_co_preadv_part,
.bdrv_co_pwritev_part = compress_co_pwritev_part, .bdrv_co_pwritev_part = compress_co_pwritev_part,

12
block/gluster.c
View File

@ -1318,7 +1318,7 @@ static coroutine_fn int qemu_gluster_co_pdiscard(BlockDriverState *bs,
} }
#endif #endif
static int64_t qemu_gluster_getlength(BlockDriverState *bs) static int64_t coroutine_fn qemu_gluster_co_getlength(BlockDriverState *bs)
{ {
BDRVGlusterState *s = bs->opaque; BDRVGlusterState *s = bs->opaque;
int64_t ret; int64_t ret;
@ -1510,7 +1510,7 @@ static int coroutine_fn qemu_gluster_co_block_status(BlockDriverState *bs,
* round up if necessary. * round up if necessary.
*/ */
if (!QEMU_IS_ALIGNED(*pnum, bs->bl.request_alignment)) { if (!QEMU_IS_ALIGNED(*pnum, bs->bl.request_alignment)) {
int64_t file_length = qemu_gluster_getlength(bs); int64_t file_length = qemu_gluster_co_getlength(bs);
if (file_length > 0) { if (file_length > 0) {
/* Ignore errors, this is just a safeguard */ /* Ignore errors, this is just a safeguard */
assert(hole == file_length); assert(hole == file_length);
@ -1559,7 +1559,7 @@ static BlockDriver bdrv_gluster = {
.bdrv_close = qemu_gluster_close, .bdrv_close = qemu_gluster_close,
.bdrv_co_create = qemu_gluster_co_create, .bdrv_co_create = qemu_gluster_co_create,
.bdrv_co_create_opts = qemu_gluster_co_create_opts, .bdrv_co_create_opts = qemu_gluster_co_create_opts,
.bdrv_getlength = qemu_gluster_getlength, .bdrv_co_getlength = qemu_gluster_co_getlength,
.bdrv_get_allocated_file_size = qemu_gluster_allocated_file_size, .bdrv_get_allocated_file_size = qemu_gluster_allocated_file_size,
.bdrv_co_truncate = qemu_gluster_co_truncate, .bdrv_co_truncate = qemu_gluster_co_truncate,
.bdrv_co_readv = qemu_gluster_co_readv, .bdrv_co_readv = qemu_gluster_co_readv,
@ -1588,7 +1588,7 @@ static BlockDriver bdrv_gluster_tcp = {
.bdrv_close = qemu_gluster_close, .bdrv_close = qemu_gluster_close,
.bdrv_co_create = qemu_gluster_co_create, .bdrv_co_create = qemu_gluster_co_create,
.bdrv_co_create_opts = qemu_gluster_co_create_opts, .bdrv_co_create_opts = qemu_gluster_co_create_opts,
.bdrv_getlength = qemu_gluster_getlength, .bdrv_co_getlength = qemu_gluster_co_getlength,
.bdrv_get_allocated_file_size = qemu_gluster_allocated_file_size, .bdrv_get_allocated_file_size = qemu_gluster_allocated_file_size,
.bdrv_co_truncate = qemu_gluster_co_truncate, .bdrv_co_truncate = qemu_gluster_co_truncate,
.bdrv_co_readv = qemu_gluster_co_readv, .bdrv_co_readv = qemu_gluster_co_readv,
@ -1617,7 +1617,7 @@ static BlockDriver bdrv_gluster_unix = {
.bdrv_close = qemu_gluster_close, .bdrv_close = qemu_gluster_close,
.bdrv_co_create = qemu_gluster_co_create, .bdrv_co_create = qemu_gluster_co_create,
.bdrv_co_create_opts = qemu_gluster_co_create_opts, .bdrv_co_create_opts = qemu_gluster_co_create_opts,
.bdrv_getlength = qemu_gluster_getlength, .bdrv_co_getlength = qemu_gluster_co_getlength,
.bdrv_get_allocated_file_size = qemu_gluster_allocated_file_size, .bdrv_get_allocated_file_size = qemu_gluster_allocated_file_size,
.bdrv_co_truncate = qemu_gluster_co_truncate, .bdrv_co_truncate = qemu_gluster_co_truncate,
.bdrv_co_readv = qemu_gluster_co_readv, .bdrv_co_readv = qemu_gluster_co_readv,
@ -1652,7 +1652,7 @@ static BlockDriver bdrv_gluster_rdma = {
.bdrv_close = qemu_gluster_close, .bdrv_close = qemu_gluster_close,
.bdrv_co_create = qemu_gluster_co_create, .bdrv_co_create = qemu_gluster_co_create,
.bdrv_co_create_opts = qemu_gluster_co_create_opts, .bdrv_co_create_opts = qemu_gluster_co_create_opts,
.bdrv_getlength = qemu_gluster_getlength, .bdrv_co_getlength = qemu_gluster_co_getlength,
.bdrv_get_allocated_file_size = qemu_gluster_allocated_file_size, .bdrv_get_allocated_file_size = qemu_gluster_allocated_file_size,
.bdrv_co_truncate = qemu_gluster_co_truncate, .bdrv_co_truncate = qemu_gluster_co_truncate,
.bdrv_co_readv = qemu_gluster_co_readv, .bdrv_co_readv = qemu_gluster_co_readv,

10
block/iscsi.c
View File

@ -1127,8 +1127,8 @@ static BlockAIOCB *iscsi_aio_ioctl(BlockDriverState *bs,
#endif #endif
static int64_t static int64_t coroutine_fn
iscsi_getlength(BlockDriverState *bs) iscsi_co_getlength(BlockDriverState *bs)
{ {
IscsiLun *iscsilun = bs->opaque; IscsiLun *iscsilun = bs->opaque;
int64_t len; int64_t len;
@ -2155,7 +2155,7 @@ static int coroutine_fn iscsi_co_truncate(BlockDriverState *bs, int64_t offset,
return -EIO; return -EIO;
} }
cur_length = iscsi_getlength(bs); cur_length = iscsi_co_getlength(bs);
if (offset != cur_length && exact) { if (offset != cur_length && exact) {
error_setg(errp, "Cannot resize iSCSI devices"); error_setg(errp, "Cannot resize iSCSI devices");
return -ENOTSUP; return -ENOTSUP;
@ -2434,7 +2434,7 @@ static BlockDriver bdrv_iscsi = {
.bdrv_reopen_commit = iscsi_reopen_commit, .bdrv_reopen_commit = iscsi_reopen_commit,
.bdrv_co_invalidate_cache = iscsi_co_invalidate_cache, .bdrv_co_invalidate_cache = iscsi_co_invalidate_cache,
.bdrv_getlength = iscsi_getlength, .bdrv_co_getlength = iscsi_co_getlength,
.bdrv_get_info = iscsi_get_info, .bdrv_get_info = iscsi_get_info,
.bdrv_co_truncate = iscsi_co_truncate, .bdrv_co_truncate = iscsi_co_truncate,
.bdrv_refresh_limits = iscsi_refresh_limits, .bdrv_refresh_limits = iscsi_refresh_limits,
@ -2473,7 +2473,7 @@ static BlockDriver bdrv_iser = {
.bdrv_reopen_commit = iscsi_reopen_commit, .bdrv_reopen_commit = iscsi_reopen_commit,
.bdrv_co_invalidate_cache = iscsi_co_invalidate_cache, .bdrv_co_invalidate_cache = iscsi_co_invalidate_cache,
.bdrv_getlength = iscsi_getlength, .bdrv_co_getlength = iscsi_co_getlength,
.bdrv_get_info = iscsi_get_info, .bdrv_get_info = iscsi_get_info,
.bdrv_co_truncate = iscsi_co_truncate, .bdrv_co_truncate = iscsi_co_truncate,
.bdrv_refresh_limits = iscsi_refresh_limits, .bdrv_refresh_limits = iscsi_refresh_limits,

1
block/meson.build
View File

@ -139,6 +139,7 @@ block_gen_c = custom_target('block-gen.c',
input: files( input: files(
'../include/block/block-io.h', '../include/block/block-io.h',
'../include/block/dirty-bitmap.h', '../include/block/dirty-bitmap.h',
'../include/block/block_int-io.h',
'../include/block/block-global-state.h', '../include/block/block-global-state.h',
'../include/sysemu/block-backend-io.h', '../include/sysemu/block-backend-io.h',
'coroutines.h' 'coroutines.h'

4
block/mirror.c
View File

@ -910,13 +910,13 @@ static int coroutine_fn mirror_run(Job *job, Error **errp)
goto immediate_exit; goto immediate_exit;
} }
s->bdev_length = bdrv_getlength(bs); s->bdev_length = bdrv_co_getlength(bs);
if (s->bdev_length < 0) { if (s->bdev_length < 0) {
ret = s->bdev_length; ret = s->bdev_length;
goto immediate_exit; goto immediate_exit;
} }
target_length = blk_getlength(s->target); target_length = blk_co_getlength(s->target);
if (target_length < 0) { if (target_length < 0) {
ret = target_length; ret = target_length;
goto immediate_exit; goto immediate_exit;

8
block/nbd.c
View File

@ -1992,7 +1992,7 @@ static int coroutine_fn nbd_co_truncate(BlockDriverState *bs, int64_t offset,
return 0; return 0;
} }
static int64_t nbd_getlength(BlockDriverState *bs) static int64_t coroutine_fn nbd_co_getlength(BlockDriverState *bs)
{ {
BDRVNBDState *s = bs->opaque; BDRVNBDState *s = bs->opaque;
@ -2124,7 +2124,7 @@ static BlockDriver bdrv_nbd = {
.bdrv_co_pdiscard = nbd_client_co_pdiscard, .bdrv_co_pdiscard = nbd_client_co_pdiscard,
.bdrv_refresh_limits = nbd_refresh_limits, .bdrv_refresh_limits = nbd_refresh_limits,
.bdrv_co_truncate = nbd_co_truncate, .bdrv_co_truncate = nbd_co_truncate,
.bdrv_getlength = nbd_getlength, .bdrv_co_getlength = nbd_co_getlength,
.bdrv_refresh_filename = nbd_refresh_filename, .bdrv_refresh_filename = nbd_refresh_filename,
.bdrv_co_block_status = nbd_client_co_block_status, .bdrv_co_block_status = nbd_client_co_block_status,
.bdrv_dirname = nbd_dirname, .bdrv_dirname = nbd_dirname,
@ -2152,7 +2152,7 @@ static BlockDriver bdrv_nbd_tcp = {
.bdrv_co_pdiscard = nbd_client_co_pdiscard, .bdrv_co_pdiscard = nbd_client_co_pdiscard,
.bdrv_refresh_limits = nbd_refresh_limits, .bdrv_refresh_limits = nbd_refresh_limits,
.bdrv_co_truncate = nbd_co_truncate, .bdrv_co_truncate = nbd_co_truncate,
.bdrv_getlength = nbd_getlength, .bdrv_co_getlength = nbd_co_getlength,
.bdrv_refresh_filename = nbd_refresh_filename, .bdrv_refresh_filename = nbd_refresh_filename,
.bdrv_co_block_status = nbd_client_co_block_status, .bdrv_co_block_status = nbd_client_co_block_status,
.bdrv_dirname = nbd_dirname, .bdrv_dirname = nbd_dirname,
@ -2180,7 +2180,7 @@ static BlockDriver bdrv_nbd_unix = {
.bdrv_co_pdiscard = nbd_client_co_pdiscard, .bdrv_co_pdiscard = nbd_client_co_pdiscard,
.bdrv_refresh_limits = nbd_refresh_limits, .bdrv_refresh_limits = nbd_refresh_limits,
.bdrv_co_truncate = nbd_co_truncate, .bdrv_co_truncate = nbd_co_truncate,
.bdrv_getlength = nbd_getlength, .bdrv_co_getlength = nbd_co_getlength,
.bdrv_refresh_filename = nbd_refresh_filename, .bdrv_refresh_filename = nbd_refresh_filename,
.bdrv_co_block_status = nbd_client_co_block_status, .bdrv_co_block_status = nbd_client_co_block_status,
.bdrv_dirname = nbd_dirname, .bdrv_dirname = nbd_dirname,

6
block/null.c
View File

@ -100,7 +100,7 @@ static int null_file_open(BlockDriverState *bs, QDict *options, int flags,
return ret; return ret;
} }
static int64_t null_getlength(BlockDriverState *bs) static int64_t coroutine_fn null_co_getlength(BlockDriverState *bs)
{ {
BDRVNullState *s = bs->opaque; BDRVNullState *s = bs->opaque;
return s->length; return s->length;
@ -284,7 +284,7 @@ static BlockDriver bdrv_null_co = {
.bdrv_file_open = null_file_open, .bdrv_file_open = null_file_open,
.bdrv_parse_filename = null_co_parse_filename, .bdrv_parse_filename = null_co_parse_filename,
.bdrv_getlength = null_getlength, .bdrv_co_getlength = null_co_getlength,
.bdrv_get_allocated_file_size = null_allocated_file_size, .bdrv_get_allocated_file_size = null_allocated_file_size,
.bdrv_co_preadv = null_co_preadv, .bdrv_co_preadv = null_co_preadv,
@ -305,7 +305,7 @@ static BlockDriver bdrv_null_aio = {
.bdrv_file_open = null_file_open, .bdrv_file_open = null_file_open,
.bdrv_parse_filename = null_aio_parse_filename, .bdrv_parse_filename = null_aio_parse_filename,
.bdrv_getlength = null_getlength, .bdrv_co_getlength = null_co_getlength,
.bdrv_get_allocated_file_size = null_allocated_file_size, .bdrv_get_allocated_file_size = null_allocated_file_size,
.bdrv_aio_preadv = null_aio_preadv, .bdrv_aio_preadv = null_aio_preadv,

6
block/nvme.c
View File

@ -1002,7 +1002,7 @@ fail:
return ret; return ret;
} }
static int64_t nvme_getlength(BlockDriverState *bs) static int64_t coroutine_fn nvme_co_getlength(BlockDriverState *bs)
{ {
BDRVNVMeState *s = bs->opaque; BDRVNVMeState *s = bs->opaque;
return s->nsze << s->blkshift; return s->nsze << s->blkshift;
@ -1486,7 +1486,7 @@ static int coroutine_fn nvme_co_truncate(BlockDriverState *bs, int64_t offset,
return -ENOTSUP; return -ENOTSUP;
} }
cur_length = nvme_getlength(bs); cur_length = nvme_co_getlength(bs);
if (offset != cur_length && exact) { if (offset != cur_length && exact) {
error_setg(errp, "Cannot resize NVMe devices"); error_setg(errp, "Cannot resize NVMe devices");
return -ENOTSUP; return -ENOTSUP;
@ -1643,7 +1643,7 @@ static BlockDriver bdrv_nvme = {
.bdrv_parse_filename = nvme_parse_filename, .bdrv_parse_filename = nvme_parse_filename,
.bdrv_file_open = nvme_file_open, .bdrv_file_open = nvme_file_open,
.bdrv_close = nvme_close, .bdrv_close = nvme_close,
.bdrv_getlength = nvme_getlength, .bdrv_co_getlength = nvme_co_getlength,
.bdrv_probe_blocksizes = nvme_probe_blocksizes, .bdrv_probe_blocksizes = nvme_probe_blocksizes,
.bdrv_co_truncate = nvme_co_truncate, .bdrv_co_truncate = nvme_co_truncate,

6
block/preallocate.c
View File

@ -442,7 +442,7 @@ static int coroutine_fn preallocate_co_flush(BlockDriverState *bs)
return bdrv_co_flush(bs->file->bs); return bdrv_co_flush(bs->file->bs);
} }
static int64_t preallocate_getlength(BlockDriverState *bs) static int64_t coroutine_fn preallocate_co_getlength(BlockDriverState *bs)
{ {
int64_t ret; int64_t ret;
BDRVPreallocateState *s = bs->opaque; BDRVPreallocateState *s = bs->opaque;
@ -451,7 +451,7 @@ static int64_t preallocate_getlength(BlockDriverState *bs)
return s->data_end; return s->data_end;
} }
ret = bdrv_getlength(bs->file->bs); ret = bdrv_co_getlength(bs->file->bs);
if (has_prealloc_perms(bs)) { if (has_prealloc_perms(bs)) {
s->file_end = s->zero_start = s->data_end = ret; s->file_end = s->zero_start = s->data_end = ret;
@ -537,7 +537,7 @@ BlockDriver bdrv_preallocate_filter = {
.format_name = "preallocate", .format_name = "preallocate",
.instance_size = sizeof(BDRVPreallocateState), .instance_size = sizeof(BDRVPreallocateState),
.bdrv_getlength = preallocate_getlength, .bdrv_co_getlength = preallocate_co_getlength,
.bdrv_open = preallocate_open, .bdrv_open = preallocate_open,
.bdrv_close = preallocate_close, .bdrv_close = preallocate_close,

4
block/qed.c
View File

@ -1480,7 +1480,7 @@ static int coroutine_fn bdrv_qed_co_truncate(BlockDriverState *bs,
return ret; return ret;
} }
static int64_t bdrv_qed_getlength(BlockDriverState *bs) static int64_t coroutine_fn bdrv_qed_co_getlength(BlockDriverState *bs)
{ {
BDRVQEDState *s = bs->opaque; BDRVQEDState *s = bs->opaque;
return s->header.image_size; return s->header.image_size;
@ -1653,7 +1653,7 @@ static BlockDriver bdrv_qed = {
.bdrv_co_writev = bdrv_qed_co_writev, .bdrv_co_writev = bdrv_qed_co_writev,
.bdrv_co_pwrite_zeroes = bdrv_qed_co_pwrite_zeroes, .bdrv_co_pwrite_zeroes = bdrv_qed_co_pwrite_zeroes,
.bdrv_co_truncate = bdrv_qed_co_truncate, .bdrv_co_truncate = bdrv_qed_co_truncate,
.bdrv_getlength = bdrv_qed_getlength, .bdrv_co_getlength = bdrv_qed_co_getlength,
.bdrv_get_info = bdrv_qed_get_info, .bdrv_get_info = bdrv_qed_get_info,
.bdrv_refresh_limits = bdrv_qed_refresh_limits, .bdrv_refresh_limits = bdrv_qed_refresh_limits,
.bdrv_change_backing_file = bdrv_qed_change_backing_file, .bdrv_change_backing_file = bdrv_qed_change_backing_file,

8
block/quorum.c
View File

@ -754,19 +754,19 @@ static int coroutine_fn quorum_co_pwrite_zeroes(BlockDriverState *bs,
flags | BDRV_REQ_ZERO_WRITE); flags | BDRV_REQ_ZERO_WRITE);
} }
static int64_t quorum_getlength(BlockDriverState *bs) static int64_t coroutine_fn quorum_co_getlength(BlockDriverState *bs)
{ {
BDRVQuorumState *s = bs->opaque; BDRVQuorumState *s = bs->opaque;
int64_t result; int64_t result;
int i; int i;
/* check that all file have the same length */ /* check that all file have the same length */
result = bdrv_getlength(s->children[0]->bs); result = bdrv_co_getlength(s->children[0]->bs);
if (result < 0) { if (result < 0) {
return result; return result;
} }
for (i = 1; i < s->num_children; i++) { for (i = 1; i < s->num_children; i++) {
int64_t value = bdrv_getlength(s->children[i]->bs); int64_t value = bdrv_co_getlength(s->children[i]->bs);
if (value < 0) { if (value < 0) {
return value; return value;
} }
@ -1283,7 +1283,7 @@ static BlockDriver bdrv_quorum = {
.bdrv_co_flush = quorum_co_flush, .bdrv_co_flush = quorum_co_flush,
.bdrv_getlength = quorum_getlength, .bdrv_co_getlength = quorum_co_getlength,
.bdrv_co_preadv = quorum_co_preadv, .bdrv_co_preadv = quorum_co_preadv,
.bdrv_co_pwritev = quorum_co_pwritev, .bdrv_co_pwritev = quorum_co_pwritev,

6
block/raw-format.c
View File

@ -317,14 +317,14 @@ static int coroutine_fn raw_co_pdiscard(BlockDriverState *bs,
return bdrv_co_pdiscard(bs->file, offset, bytes); return bdrv_co_pdiscard(bs->file, offset, bytes);
} }
static int64_t raw_getlength(BlockDriverState *bs) static int64_t coroutine_fn raw_co_getlength(BlockDriverState *bs)
{ {
int64_t len; int64_t len;
BDRVRawState *s = bs->opaque; BDRVRawState *s = bs->opaque;
/* Update size. It should not change unless the file was externally /* Update size. It should not change unless the file was externally
* modified. */ * modified. */
len = bdrv_getlength(bs->file->bs); len = bdrv_co_getlength(bs->file->bs);
if (len < 0) { if (len < 0) {
return len; return len;
} }
@ -622,7 +622,7 @@ BlockDriver bdrv_raw = {
.bdrv_co_copy_range_from = &raw_co_copy_range_from, .bdrv_co_copy_range_from = &raw_co_copy_range_from,
.bdrv_co_copy_range_to = &raw_co_copy_range_to, .bdrv_co_copy_range_to = &raw_co_copy_range_to,
.bdrv_co_truncate = &raw_co_truncate, .bdrv_co_truncate = &raw_co_truncate,
.bdrv_getlength = &raw_getlength, .bdrv_co_getlength = &raw_co_getlength,
.is_format = true, .is_format = true,
.has_variable_length = true, .has_variable_length = true,
.bdrv_measure = &raw_measure, .bdrv_measure = &raw_measure,

4
block/rbd.c
View File

@ -1430,7 +1430,7 @@ static int coroutine_fn qemu_rbd_co_block_status(BlockDriverState *bs,
return status; return status;
} }
static int64_t qemu_rbd_getlength(BlockDriverState *bs) static int64_t coroutine_fn qemu_rbd_co_getlength(BlockDriverState *bs)
{ {
BDRVRBDState *s = bs->opaque; BDRVRBDState *s = bs->opaque;
int r; int r;
@ -1654,7 +1654,7 @@ static BlockDriver bdrv_rbd = {
.bdrv_get_info = qemu_rbd_getinfo, .bdrv_get_info = qemu_rbd_getinfo,
.bdrv_get_specific_info = qemu_rbd_get_specific_info, .bdrv_get_specific_info = qemu_rbd_get_specific_info,
.create_opts = &qemu_rbd_create_opts, .create_opts = &qemu_rbd_create_opts,
.bdrv_getlength = qemu_rbd_getlength, .bdrv_co_getlength = qemu_rbd_co_getlength,
.bdrv_co_truncate = qemu_rbd_co_truncate, .bdrv_co_truncate = qemu_rbd_co_truncate,
.protocol_name = "rbd", .protocol_name = "rbd",

6
block/replication.c
View File

@ -179,9 +179,9 @@ static void replication_child_perm(BlockDriverState *bs, BdrvChild *c,
return; return;
} }
static int64_t replication_getlength(BlockDriverState *bs) static int64_t coroutine_fn replication_co_getlength(BlockDriverState *bs)
{ {
return bdrv_getlength(bs->file->bs); return bdrv_co_getlength(bs->file->bs);
} }
static int replication_get_io_status(BDRVReplicationState *s) static int replication_get_io_status(BDRVReplicationState *s)
@ -758,7 +758,7 @@ static BlockDriver bdrv_replication = {
.bdrv_close = replication_close, .bdrv_close = replication_close,
.bdrv_child_perm = replication_child_perm, .bdrv_child_perm = replication_child_perm,
.bdrv_getlength = replication_getlength, .bdrv_co_getlength = replication_co_getlength,
.bdrv_co_readv = replication_co_readv, .bdrv_co_readv = replication_co_readv,
.bdrv_co_writev = replication_co_writev, .bdrv_co_writev = replication_co_writev,

4
block/ssh.c
View File

@ -1253,7 +1253,7 @@ static coroutine_fn int ssh_co_flush(BlockDriverState *bs)
return ret; return ret;
} }
static int64_t ssh_getlength(BlockDriverState *bs) static int64_t coroutine_fn ssh_co_getlength(BlockDriverState *bs)
{ {
BDRVSSHState *s = bs->opaque; BDRVSSHState *s = bs->opaque;
int64_t length; int64_t length;
@ -1364,7 +1364,7 @@ static BlockDriver bdrv_ssh = {
.bdrv_has_zero_init = ssh_has_zero_init, .bdrv_has_zero_init = ssh_has_zero_init,
.bdrv_co_readv = ssh_co_readv, .bdrv_co_readv = ssh_co_readv,
.bdrv_co_writev = ssh_co_writev, .bdrv_co_writev = ssh_co_writev,
.bdrv_getlength = ssh_getlength, .bdrv_co_getlength = ssh_co_getlength,
.bdrv_co_truncate = ssh_co_truncate, .bdrv_co_truncate = ssh_co_truncate,
.bdrv_co_flush_to_disk = ssh_co_flush, .bdrv_co_flush_to_disk = ssh_co_flush,
.bdrv_refresh_filename = ssh_refresh_filename, .bdrv_refresh_filename = ssh_refresh_filename,

6
block/throttle.c
View File

@ -106,9 +106,9 @@ static void throttle_close(BlockDriverState *bs)
} }
static int64_t throttle_getlength(BlockDriverState *bs) static int64_t coroutine_fn throttle_co_getlength(BlockDriverState *bs)
{ {
return bdrv_getlength(bs->file->bs); return bdrv_co_getlength(bs->file->bs);
} }
static int coroutine_fn throttle_co_preadv(BlockDriverState *bs, static int coroutine_fn throttle_co_preadv(BlockDriverState *bs,
@ -247,7 +247,7 @@ static BlockDriver bdrv_throttle = {
.bdrv_child_perm = bdrv_default_perms, .bdrv_child_perm = bdrv_default_perms,
.bdrv_getlength = throttle_getlength, .bdrv_co_getlength = throttle_co_getlength,
.bdrv_co_preadv = throttle_co_preadv, .bdrv_co_preadv = throttle_co_preadv,
.bdrv_co_pwritev = throttle_co_pwritev, .bdrv_co_pwritev = throttle_co_pwritev,

5
hw/scsi/scsi-disk.c
View File

@ -2332,10 +2332,15 @@ static void scsi_disk_reset(DeviceState *dev)
{ {
SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev.qdev, dev); SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev.qdev, dev);
uint64_t nb_sectors; uint64_t nb_sectors;
AioContext *ctx;
scsi_device_purge_requests(&s->qdev, SENSE_CODE(RESET)); scsi_device_purge_requests(&s->qdev, SENSE_CODE(RESET));
ctx = blk_get_aio_context(s->qdev.conf.blk);
aio_context_acquire(ctx);
blk_get_geometry(s->qdev.conf.blk, &nb_sectors); blk_get_geometry(s->qdev.conf.blk, &nb_sectors);
aio_context_release(ctx);
nb_sectors /= s->qdev.blocksize / BDRV_SECTOR_SIZE; nb_sectors /= s->qdev.blocksize / BDRV_SECTOR_SIZE;
if (nb_sectors) { if (nb_sectors) {
nb_sectors--; nb_sectors--;

8
include/block/block-io.h
View File

@ -76,8 +76,12 @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact,
PreallocMode prealloc, BdrvRequestFlags flags, PreallocMode prealloc, BdrvRequestFlags flags,
Error **errp); Error **errp);
int64_t bdrv_nb_sectors(BlockDriverState *bs); int64_t coroutine_fn bdrv_co_nb_sectors(BlockDriverState *bs);
int64_t bdrv_getlength(BlockDriverState *bs); int64_t co_wrapper_mixed bdrv_nb_sectors(BlockDriverState *bs);
int64_t coroutine_fn bdrv_co_getlength(BlockDriverState *bs);
int64_t co_wrapper_mixed bdrv_getlength(BlockDriverState *bs);
int64_t bdrv_get_allocated_file_size(BlockDriverState *bs); int64_t bdrv_get_allocated_file_size(BlockDriverState *bs);
BlockMeasureInfo *bdrv_measure(BlockDriver *drv, QemuOpts *opts, BlockMeasureInfo *bdrv_measure(BlockDriver *drv, QemuOpts *opts,
BlockDriverState *in_bs, Error **errp); BlockDriverState *in_bs, Error **errp);

2
include/block/block_int-common.h
View File

@ -680,7 +680,7 @@ struct BlockDriver {
int coroutine_fn (*bdrv_co_truncate)(BlockDriverState *bs, int64_t offset, int coroutine_fn (*bdrv_co_truncate)(BlockDriverState *bs, int64_t offset,
bool exact, PreallocMode prealloc, bool exact, PreallocMode prealloc,
BdrvRequestFlags flags, Error **errp); BdrvRequestFlags flags, Error **errp);
int64_t (*bdrv_getlength)(BlockDriverState *bs); int64_t coroutine_fn (*bdrv_co_getlength)(BlockDriverState *bs);
int64_t (*bdrv_get_allocated_file_size)(BlockDriverState *bs); int64_t (*bdrv_get_allocated_file_size)(BlockDriverState *bs);
BlockMeasureInfo *(*bdrv_measure)(QemuOpts *opts, BlockDriverState *in_bs, BlockMeasureInfo *(*bdrv_measure)(QemuOpts *opts, BlockDriverState *in_bs,
Error **errp); Error **errp);

5
include/block/block_int-io.h
View File

@ -122,7 +122,10 @@ int coroutine_fn bdrv_co_copy_range_to(BdrvChild *src, int64_t src_offset,
BdrvRequestFlags read_flags, BdrvRequestFlags read_flags,
BdrvRequestFlags write_flags); BdrvRequestFlags write_flags);
int bdrv_refresh_total_sectors(BlockDriverState *bs, int64_t hint); int coroutine_fn bdrv_co_refresh_total_sectors(BlockDriverState *bs,
int64_t hint);
int co_wrapper_mixed
bdrv_refresh_total_sectors(BlockDriverState *bs, int64_t hint);
BdrvChild *bdrv_cow_child(BlockDriverState *bs); BdrvChild *bdrv_cow_child(BlockDriverState *bs);
BdrvChild *bdrv_filter_child(BlockDriverState *bs); BdrvChild *bdrv_filter_child(BlockDriverState *bs);

10
include/sysemu/block-backend-io.h
View File

@ -61,9 +61,15 @@ bool co_wrapper_mixed blk_is_inserted(BlockBackend *blk);
bool blk_is_available(BlockBackend *blk); bool blk_is_available(BlockBackend *blk);
void blk_lock_medium(BlockBackend *blk, bool locked); void blk_lock_medium(BlockBackend *blk, bool locked);
void blk_eject(BlockBackend *blk, bool eject_flag); void blk_eject(BlockBackend *blk, bool eject_flag);
int64_t blk_getlength(BlockBackend *blk);
int64_t coroutine_fn blk_co_getlength(BlockBackend *blk);
int64_t co_wrapper_mixed blk_getlength(BlockBackend *blk);
void blk_get_geometry(BlockBackend *blk, uint64_t *nb_sectors_ptr); void blk_get_geometry(BlockBackend *blk, uint64_t *nb_sectors_ptr);
int64_t blk_nb_sectors(BlockBackend *blk);
int64_t coroutine_fn blk_co_nb_sectors(BlockBackend *blk);
int64_t co_wrapper_mixed blk_nb_sectors(BlockBackend *blk);
void *blk_try_blockalign(BlockBackend *blk, size_t size); void *blk_try_blockalign(BlockBackend *blk, size_t size);
void *blk_blockalign(BlockBackend *blk, size_t size); void *blk_blockalign(BlockBackend *blk, size_t size);
bool blk_is_writable(BlockBackend *blk); bool blk_is_writable(BlockBackend *blk);

3
tests/unit/test-block-iothread.c
View File

@ -832,7 +832,10 @@ static void test_attach_second_node(void)
qdict_put_str(options, "driver", "raw"); qdict_put_str(options, "driver", "raw");
qdict_put_str(options, "file", "base"); qdict_put_str(options, "file", "base");
aio_context_acquire(ctx);
filter = bdrv_open(NULL, NULL, options, BDRV_O_RDWR, &error_abort); filter = bdrv_open(NULL, NULL, options, BDRV_O_RDWR, &error_abort);
aio_context_release(ctx);
g_assert(blk_get_aio_context(blk) == ctx); g_assert(blk_get_aio_context(blk) == ctx);
g_assert(bdrv_get_aio_context(bs) == ctx); g_assert(bdrv_get_aio_context(bs) == ctx);
g_assert(bdrv_get_aio_context(filter) == ctx); g_assert(bdrv_get_aio_context(filter) == ctx);