block: Move more functions to coroutines
Subsystems (2)
cover block: Move more functions to coroutines
This series converts some IO_CODE() functions to coroutine_fn because they access the graph and will need to hold the graph lock in the future. IO_CODE() functions can be called from iothreads, so taking the graph lock requires the function to run in coroutine context.
Pretty much all of the changes in this series were posted by Emanuele before as part of "Protect the block layer with a rwlock: part 3". The major difference is that in the old version, the patches did two things at once: Converting functions to coroutine_fn, and adding the locking to them. This series does only the coroutine conversion. The locking part will be in another series which now comes with TSA annotations and makes the locking related changes big enough to have separate patches.
Emanuele Giuseppe Esposito (14):
block-coroutine-wrapper: support void functions
block: Convert bdrv_io_plug() to co_wrapper
block: Convert bdrv_io_unplug() to co_wrapper
block: Rename refresh_total_sectors to bdrv_refresh_total_sectors
block: Convert bdrv_refresh_total_sectors() to co_wrapper_mixed
block-backend: use bdrv_getlength instead of blk_getlength
block: use bdrv_co_refresh_total_sectors when possible
block: Convert bdrv_get_allocated_file_size() to co_wrapper
block: Convert bdrv_get_info() to co_wrapper_mixed
block: Convert bdrv_is_inserted() to co_wrapper
block: Convert bdrv_eject() to co_wrapper
block: convert bdrv_lock_medium in co_wrapper
block: Convert bdrv_debug_event to co_wrapper_mixed
block: Rename newly converted BlockDriver IO coroutine functions
include/block/block-io.h | 36 +++++++++---- include/block/block_int-common.h | 26 ++++++---- include/block/block_int-io.h | 5 +- include/sysemu/block-backend-io.h | 31 ++++++++--- block.c | 82 ++++++++++++++++++------------ block/blkdebug.c | 4 +- block/blkio.c | 6 +-- block/blklogwrites.c | 2 +- block/blkreplay.c | 2 +- block/blkverify.c | 2 +- block/block-backend.c | 36 ++++++------- block/commit.c | 4 +- block/copy-on-read.c | 12 ++--- block/crypto.c | 6 +-- block/curl.c | 8 +-- block/file-posix.c | 48 ++++++++--------- block/file-win32.c | 12 ++--- block/filter-compress.c | 10 ++-- block/gluster.c | 16 +++--- block/io.c | 76 +++++++++++++-------------- block/iscsi.c | 8 +-- block/mirror.c | 6 +-- block/nbd.c | 6 +-- block/nfs.c | 2 +- block/null.c | 8 +-- block/nvme.c | 6 +-- block/preallocate.c | 2 +- block/qcow.c | 2 +- block/qcow2-refcount.c | 2 +- block/qcow2.c | 6 +-- block/qed.c | 4 +- block/quorum.c | 2 +- block/raw-format.c | 14 ++--- block/rbd.c | 4 +- block/replication.c | 2 +- block/ssh.c | 2 +- block/throttle.c | 2 +- block/vdi.c | 2 +- block/vhdx.c | 2 +- block/vmdk.c | 4 +- block/vpc.c | 2 +- blockdev.c | 8 ++- hw/scsi/scsi-disk.c | 5 ++ tests/unit/test-block-iothread.c | 3 ++ scripts/block-coroutine-wrapper.py | 20 ++++++-- block/meson.build | 1 + 46 files changed, 316 insertions(+), 233 deletions(-)
Signature · 1 line
2.38.1
PATCH 1/14 block-coroutine-wrapper: support void functions
From: Emanuele Giuseppe Esposito <[email protected]>
Just omit the various 'return' when the return type is void.
--- scripts/block-coroutine-wrapper.py | 20 +++++++++++++++----- 1 file changed, 15 insertions(+), 5 deletions(-)
scripts/block-coroutine-wrapper.py +15 -5
@@ -85,6 +85,16 @@ def __init__(self, return_type: str, name: str, args: str, ctx = 'qemu_get_aio_context()' self.ctx = ctx + self.get_result = 's->ret = ' + self.ret = 'return s.ret;' + self.co_ret = 'return ' + self.return_field = self.return_type + " ret;" + if self.return_type == 'void': + self.get_result = '' + self.ret = '' + self.co_ret = '' + self.return_field = '' + def gen_list(self, format: str) -> str: return ', '.join(format.format_map(arg.__dict__) for arg in self.args)
@@ -131,7 +141,7 @@ def create_mixed_wrapper(func: FuncDecl) -> str: {{ if (qemu_in_coroutine()) {{ {graph_assume_lock} - return {name}({ func.gen_list('{name}') }); + {func.co_ret}{name}({ func.gen_list('{name}') }); }} else {{ {struct_name} s = {{ .poll_state.ctx = {func.ctx},
@@ -143,7 +153,7 @@ def create_mixed_wrapper(func: FuncDecl) -> str: s.poll_state.co = qemu_coroutine_create({name}_entry, &s); bdrv_poll_co(&s.poll_state); - return s.ret; + {func.ret} }} }}"""
@@ -168,7 +178,7 @@ def create_co_wrapper(func: FuncDecl) -> str: s.poll_state.co = qemu_coroutine_create({name}_entry, &s); bdrv_poll_co(&s.poll_state); - return s.ret; + {func.ret} }}"""
@@ -195,7 +205,7 @@ def gen_wrapper(func: FuncDecl) -> str: typedef struct {struct_name} {{ BdrvPollCo poll_state; - {func.return_type} ret; + {func.return_field} { func.gen_block(' {decl};') } }} {struct_name};
@@ -204,7 +214,7 @@ def gen_wrapper(func: FuncDecl) -> str: {struct_name} *s = opaque; {graph_lock} - s->ret = {name}({ func.gen_list('s->{name}') }); + {func.get_result}{name}({ func.gen_list('s->{name}') }); {graph_unlock} s->poll_state.in_progress = false;
Signature · 1 line
2.38.1
Re: [PATCH 01/14] block-coroutine-wrapper: support void functions
Quoted 6 lines · Kevin Wolf
From: Emanuele Giuseppe Esposito<[email protected]>
Just omit the various 'return' when the return type is void.
Signed-off-by Emanuele Giuseppe Esposito<[email protected]>Signed-off-by Kevin Wolf<[email protected]>
Signature · 2 lines
Best regards, Vladimir
PATCH 2/14 block: Convert bdrv_io_plug() to co_wrapper
In reply to Kevin WolfFrom: Emanuele Giuseppe Esposito <[email protected]>
BlockDriver->bdrv_io_plug 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.
The only caller of this function is blk_io_plug(), therefore make blk_io_plug() a co_wrapper, so that we're always running in a coroutine where the lock can be taken.
--- include/block/block-io.h | 3 ++- include/block/block_int-common.h | 2 +- include/sysemu/block-backend-io.h | 4 +++- block/block-backend.c | 4 ++-- block/io.c | 4 ++-- 5 files changed, 10 insertions(+), 7 deletions(-)
include/block/block-io.h +2 -1
@@ -217,7 +217,8 @@ void bdrv_coroutine_enter(BlockDriverState *bs, Coroutine *co);AioContext *child_of_bds_get_parent_aio_context (BdrvChild *c); -void bdrv_io_plug (BlockDriverState *bs); +void coroutine_fn bdrv_co_io_plug(BlockDriverState *bs); +void bdrv_io_unplug (BlockDriverState *bs); bool coroutine_fn bdrv_co_can_store_new_dirty_bitmap(BlockDriverState *bs,
include/block/block_int-common.h +1 -1
@@ -729,7 +729,7 @@ struct BlockDriver {void (*bdrv_debug_event)(BlockDriverState *bs,BlkdebugEvent event);/* io queue for linux-aio */ -void (*bdrv_io_plug)(BlockDriverState *bs); + void coroutine_fn (*bdrv_io_plug)(BlockDriverState *bs);void (*bdrv_io_unplug)(BlockDriverState *bs);/**
include/sysemu/block-backend-io.h +3 -1
@@ -73,7 +73,9 @@ void blk_iostatus_set_err(BlockBackend *blk, int error);int blk_get_max_iov (BlockBackend *blk);int blk_get_max_hw_iov (BlockBackend *blk); -void blk_io_plug (BlockBackend *blk); +void coroutine_fn blk_co_io_plug(BlockBackend *blk); +void co_wrapper blk_io_plug(BlockBackend *blk); +void blk_io_unplug (BlockBackend *blk);AioContext *blk_get_aio_context (BlockBackend *blk);BlockAcctStats *blk_get_stats (BlockBackend *blk);
block/block-backend.c +2 -2
@@ -2315,13 +2315,13 @@ void blk_add_insert_bs_notifier(BlockBackend *blk, Notifier *notify)notifier_list_add (&blk->insert_bs_notifiers, notify); } -void blk_io_plug (BlockBackend *blk) +void coroutine_fn blk_co_io_plug(BlockBackend *blk) {BlockDriverState *bs =blk_bs (blk);IO_CODE ();if (bs) { -bdrv_io_plug (bs); +bdrv_co_io_plug (bs); } }
block/io.c +2 -2
@@ -3127,13 +3127,13 @@ void *qemu_try_blockalign0(BlockDriverState *bs, size_t size)return mem; } -void bdrv_io_plug (BlockDriverState *bs) +void coroutine_fn bdrv_co_io_plug(BlockDriverState *bs) {BdrvChild *child;IO_CODE (); QLIST_FOREACH(child, &bs->children, next) { -bdrv_io_plug (child->bs); +bdrv_co_io_plug (child->bs); }if (qatomic_fetch_inc (&bs->io_plugged) ==0 ) {
Signature · 1 line
2.38.1
Re: [PATCH 02/14] block: Convert bdrv_io_plug() to co_wrapper
Quoted 14 lines · Kevin Wolf
From: Emanuele Giuseppe Esposito <[email protected]>
BlockDriver->bdrv_io_plugis 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.The only caller of this function is
blk_io_plug(), therefore makeblk_io_plug()aco_wrapper, so that we're always running in a coroutine where the lock can be taken.Signed-off-by Emanuele Giuseppe Esposito <[email protected]>Signed-off-by Kevin Wolf <[email protected]>---
[..]
include/block/block_int-common.h struct BlockDriver { · line 732
Quoted 8 lines
include/block/block_int-common.h +1
-1@@ -729,7 +729,7 @@ struct BlockDriver {void (*bdrv_debug_event)(BlockDriverState *bs,BlkdebugEvent event);/* io queue for linux-aio */ -void (*bdrv_io_plug)(BlockDriverState *bs); + void coroutine_fn (*bdrv_io_plug)(BlockDriverState *bs);
don't we want to rename it to _co_ too?
anyway:
Signature · 2 lines
Best regards, Vladimir
Re: [PATCH 02/14] block: Convert bdrv_io_plug() to co_wrapper
Am 16/12/2022 um 15:26 schrieb Vladimir Sementsov-Ogievskiy:
Quoted 18 lines · Kevin Wolf
Quoted 14 lines
From: Emanuele Giuseppe Esposito <[email protected]>
BlockDriver->bdrv_io_plugis 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.The only caller of this function is
blk_io_plug(), therefore makeblk_io_plug()aco_wrapper, so that we're always running in a coroutine where the lock can be taken.Signed-off-by Emanuele Giuseppe Esposito <[email protected]>Signed-off-by Kevin Wolf <[email protected]>---
[..]
Quoted 10 lines
Quoted 8 lines
include/block/block_int-common.h +0
-0@@ -729,7 +729,7 @@ struct BlockDriver {void (*bdrv_debug_event)(BlockDriverState *bs, BlkdebugEvent event);
/* io queue for linux-aio */
- void (*bdrv_io_plug)(BlockDriverState *bs);
+ voidcoroutine_fn(*bdrv_io_plug)(BlockDriverState *bs);don't we want to rename it to _co_ too?
I think you realized this is done in patch 14
Thanks,
Emanuele
Quoted 6 lines
anyway:
Reviewed-by Vladimir Sementsov-Ogievskiy <[email protected]>
Re: [PATCH 02/14] block: Convert bdrv_io_plug() to co_wrapper
In reply to Kevin Wolfinclude/block/block_int-common.h struct BlockDriver { · line 732
Quoted 8 lines · Kevin Wolf
include/block/block_int-common.h +1
-1@@ -729,7 +729,7 @@ struct BlockDriver {void (*bdrv_debug_event)(BlockDriverState *bs,BlkdebugEvent event);/* io queue for linux-aio */ -void (*bdrv_io_plug)(BlockDriverState *bs); + void coroutine_fn (*bdrv_io_plug)(BlockDriverState *bs);
But you didn't add coroutine_fn to realizations of this callback. Seems, it should be done
Signature · 2 lines
Best regards, Vladimir
Re: [PATCH 02/14] block: Convert bdrv_io_plug() to co_wrapper
Am 16/12/2022 um 17:12 schrieb Vladimir Sementsov-Ogievskiy:
Quoted 13 lines · Kevin Wolf
Quoted 8 lines
include/block/block_int-common.h +0
-0@@ -729,7 +729,7 @@ struct BlockDriver {void (*bdrv_debug_event)(BlockDriverState *bs, BlkdebugEvent event);
/* io queue for linux-aio */
- void (*bdrv_io_plug)(BlockDriverState *bs);
+ voidcoroutine_fn(*bdrv_io_plug)(BlockDriverState *bs);But you didn't add
coroutine_fnto realizations of this callback. Seems, it should be done
This has to be done by Paolo & Alberto Faria work to add missing coroutine_fn and various annotations in a systematic way. It has to be done using tools like vrc, and not manually because it's not feasible. Not covered by this serie.
Thank you,
Emanuele
Re: [PATCH 02/14] block: Convert bdrv_io_plug() to co_wrapper
Am 19.12.2022 um 13:26 hat Emanuele Giuseppe Esposito geschrieben:
Quoted 14 lines
Am 16/12/2022 um 17:12 schrieb Vladimir Sementsov-Ogievskiy:
Quoted 12 lines · Kevin Wolf
Quoted 8 lines
include/block/block_int-common.h +0
-0@@ -729,7 +729,7 @@ struct BlockDriver {void (*bdrv_debug_event)(BlockDriverState *bs, BlkdebugEvent event);
/* io queue for linux-aio */
- void (*bdrv_io_plug)(BlockDriverState *bs);
+ voidcoroutine_fn(*bdrv_io_plug)(BlockDriverState *bs);But you didn't add
coroutine_fnto realizations of this callback. Seems, it should be done
Quoted 4 lines
This has to be done by Paolo & Alberto Faria work to add missing
coroutine_fnand various annotations in a systematic way. It has to be done using tools like vrc, and not manually because it's not feasible. Not covered by this serie.
I didn't want to change your patches too much (and I'm sure it has nothing at all to do with laziness!), but Vladimir is really right. Doing the renames in the final patch is a bit sloppy, just as not adding coroutine_fn is.
I'll fix it for v2 to do all of the changes in the respective patches.
Kevin
PATCH 3/14 block: Convert bdrv_io_unplug() to co_wrapper
In reply to Kevin WolfFrom: Emanuele Giuseppe Esposito <[email protected]>
BlockDriver->bdrv_io_unplug 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.
The only caller of this function is blk_io_unplug(), therefore make blk_io_unplug() a co_wrapper, so that we're always running in a coroutine where the lock can be taken.
--- include/block/block-io.h | 3 +-- include/block/block_int-common.h | 2 +- include/sysemu/block-backend-io.h | 4 +++- block/block-backend.c | 4 ++-- block/io.c | 4 ++-- 5 files changed, 9 insertions(+), 8 deletions(-)
include/block/block-io.h +1 -2
@@ -218,8 +218,7 @@ void bdrv_coroutine_enter(BlockDriverState *bs, Coroutine *co);AioContext *child_of_bds_get_parent_aio_context (BdrvChild *c); void coroutine_fn bdrv_co_io_plug(BlockDriverState *bs); - -void bdrv_io_unplug (BlockDriverState *bs); +void coroutine_fn bdrv_co_io_unplug(BlockDriverState *bs); bool coroutine_fn bdrv_co_can_store_new_dirty_bitmap(BlockDriverState *bs, const char *name,
include/block/block_int-common.h +1 -1
@@ -730,7 +730,7 @@ struct BlockDriver {/* io queue for linux-aio */ void coroutine_fn (*bdrv_io_plug)(BlockDriverState *bs); -void (*bdrv_io_unplug)(BlockDriverState *bs); + void coroutine_fn (*bdrv_io_unplug)(BlockDriverState *bs);/** * bdrv_drain_begin is called if implemented in the beginning of a
include/sysemu/block-backend-io.h +3 -1
@@ -76,7 +76,9 @@ int blk_get_max_hw_iov(BlockBackend *blk); void coroutine_fn blk_co_io_plug(BlockBackend *blk); void co_wrapper blk_io_plug(BlockBackend *blk); -void blk_io_unplug (BlockBackend *blk); +void coroutine_fn blk_co_io_unplug(BlockBackend *blk); +void co_wrapper blk_io_unplug(BlockBackend *blk); +AioContext *blk_get_aio_context (BlockBackend *blk);BlockAcctStats *blk_get_stats (BlockBackend *blk); void *blk_aio_get(const AIOCBInfo *aiocb_info, BlockBackend *blk,
block/block-backend.c +2 -2
@@ -2325,13 +2325,13 @@ void coroutine_fn blk_co_io_plug(BlockBackend *blk) } } -void blk_io_unplug (BlockBackend *blk) +void coroutine_fn blk_co_io_unplug(BlockBackend *blk) {BlockDriverState *bs =blk_bs (blk);IO_CODE ();if (bs) { -bdrv_io_unplug (bs); +bdrv_co_io_unplug (bs); } }
block/io.c +2 -2
@@ -3144,7 +3144,7 @@ void coroutine_fn bdrv_co_io_plug(BlockDriverState *bs) } } -void bdrv_io_unplug (BlockDriverState *bs) +void coroutine_fn bdrv_co_io_unplug(BlockDriverState *bs) {BdrvChild *child;IO_CODE ();
@@ -3158,7 +3158,7 @@ void bdrv_io_unplug(BlockDriverState *bs) } QLIST_FOREACH(child, &bs->children, next) { -bdrv_io_unplug (child->bs); +bdrv_co_io_unplug (child->bs); } }
Signature · 1 line
2.38.1
PATCH 4/14 block: Rename refresh_total_sectors to bdrv_refresh_total_sectors
In reply to Kevin WolfFrom: Emanuele Giuseppe Esposito <[email protected]>
The name is not good, not the least because we are going to convert this to a generated co_wrapper, which adds a _co infix after the first part of the name.
No functional change intended.
--- include/block/block_int-io.h | 2 +- block.c | 8 ++++---- block/io.c | 8 +++++--- 3 files changed, 10 insertions(+), 8 deletions(-)
include/block/block_int-io.h +1 -1
@@ -120,7 +120,7 @@ int coroutine_fn bdrv_co_copy_range_to(BdrvChild *src, int64_t src_offset,BdrvRequestFlags read_flags, BdrvRequestFlags write_flags); -int refresh_total_sectors (BlockDriverState *bs,int64_t hint); +int bdrv_refresh_total_sectors (BlockDriverState *bs,int64_t hint);BdrvChild *bdrv_cow_child (BlockDriverState *bs);BdrvChild *bdrv_filter_child (BlockDriverState *bs);
block.c +4 -4
@@ -1034,7 +1034,7 @@ static int find_image_format(BlockBackend *file, const char *filename,* Set the current 'total_sectors' value * Return 0 on success, -errno on error. */ -int refresh_total_sectors (BlockDriverState *bs,int64_t hint) +int bdrv_refresh_total_sectors (BlockDriverState *bs,int64_t hint) {BlockDriver *drv = bs->drv;IO_CODE ();
@@ -1651,7 +1651,7 @@ static int bdrv_open_driver(BlockDriverState *bs, BlockDriver *drv, bs->supported_read_flags |=BDRV_REQ_REGISTERED_BUF ; bs->supported_write_flags |=BDRV_REQ_REGISTERED_BUF ; - ret =refresh_total_sectors (bs, bs->total_sectors); + ret =bdrv_refresh_total_sectors (bs, bs->total_sectors);if (ret <0 ) {error_setg_errno (errp, -ret,"Could not refresh total sector count" );return ret;
@@ -5808,7 +5808,7 @@ int64_t bdrv_nb_sectors(BlockDriverState *bs)return -ENOMEDIUM ;if (drv->has_variable_length) { -int ret =refresh_total_sectors (bs, bs->total_sectors); +int ret =bdrv_refresh_total_sectors (bs, bs->total_sectors);if (ret <0 ) {return ret; }
@@ -6590,7 +6590,7 @@ int bdrv_activate(BlockDriverState *bs, Error **errp)bdrv_dirty_bitmap_skip_store (bm, false); } - ret =refresh_total_sectors (bs, bs->total_sectors); + ret =bdrv_refresh_total_sectors (bs, bs->total_sectors);if (ret <0 ) { bs->open_flags |=BDRV_O_INACTIVE ;error_setg_errno (errp, -ret,"Could not refresh total sector count" );
block/io.c +5 -3
@@ -3464,15 +3464,17 @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact, goto out; } - ret =refresh_total_sectors (bs, offset >>BDRV_SECTOR_BITS ); + ret =bdrv_refresh_total_sectors (bs, offset >>BDRV_SECTOR_BITS );if (ret <0 ) {error_setg_errno (errp, -ret,"Could not refresh total sector count" ); }else { offset = bs->total_sectors *BDRV_SECTOR_SIZE ; } -/* It's possible that truncation succeeded but refresh_total_sectors +/* +* It's possible that truncation succeeded but bdrv_refresh_total_sectors * failed, but the latter doesn't affect how we should finish the request. -* Pass 0 as the last parameter so that dirty bitmaps etc. are handled. */ +* Pass 0 as the last parameter so that dirty bitmaps etc. are handled. +*/ bdrv_co_write_req_finish (child, offset - new_bytes, new_bytes, &req,0 ); out:
Signature · 1 line
2.38.1
Re: [PATCH 04/14] block: Rename refresh_total_sectors to bdrv_refresh_total_sectors
Quoted 10 lines · Kevin Wolf
From: Emanuele Giuseppe Esposito<[email protected]>
The name is not good, not the least because we are going to convert this to a generated
co_wrapper, which adds a_coinfix after the first part of the name.No functional change intended.
Signed-off-by Emanuele Giuseppe Esposito<[email protected]>Signed-off-by Kevin Wolf<[email protected]>
Signature · 2 lines
Best regards, Vladimir
PATCH 5/14 block: Convert bdrv_refresh_total_sectors() to co_wrapper_mixed
In reply to Kevin WolfFrom: Emanuele Giuseppe Esposito <[email protected]>
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.
--- include/block/block-io.h | 8 ++++++-- include/block/block_int-common.h | 2 +- include/block/block_int-io.h | 5 ++++- include/sysemu/block-backend-io.h | 10 ++++++++-- block.c | 26 +++++++++++++++++++++----- block/block-backend.c | 10 ++++++---- block/commit.c | 4 ++-- block/mirror.c | 4 ++-- hw/scsi/scsi-disk.c | 5 +++++ tests/unit/test-block-iothread.c | 3 +++ block/meson.build | 1 + 11 files changed, 59 insertions(+), 19 deletions(-)
include/block/block-io.h +6 -2
@@ -73,8 +73,12 @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact, PreallocMode prealloc, BdrvRequestFlags flags, Error **errp); -int64_t bdrv_nb_sectors (BlockDriverState *bs); -int64_t bdrv_getlength (BlockDriverState *bs); +int64_t coroutine_fn bdrv_co_nb_sectors(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);BlockMeasureInfo *bdrv_measure (BlockDriver *drv,QemuOpts *opts,BlockDriverState *in_bs,Error **errp);
include/block/block_int-common.h +1 -1
@@ -684,7 +684,7 @@ struct BlockDriver { int coroutine_fn (*bdrv_co_truncate)(BlockDriverState *bs, int64_t offset,bool exact,PreallocMode prealloc,BdrvRequestFlags flags,Error **errp); -int64_t (*bdrv_getlength)(BlockDriverState *bs); + int64_t coroutine_fn (*bdrv_getlength)(BlockDriverState *bs);int64_t (*bdrv_get_allocated_file_size)(BlockDriverState *bs); BlockMeasureInfo *(*bdrv_measure)(QemuOpts *opts, BlockDriverState *in_bs, Error **errp);
include/block/block_int-io.h +4 -1
@@ -120,7 +120,10 @@ int coroutine_fn bdrv_co_copy_range_to(BdrvChild *src, int64_t src_offset,BdrvRequestFlags read_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_filter_child (BlockDriverState *bs);
include/sysemu/block-backend-io.h +8 -2
@@ -57,9 +57,15 @@ bool blk_is_inserted(BlockBackend *blk);bool blk_is_available (BlockBackend *blk);void blk_lock_medium (BlockBackend *blk,bool locked);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); -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_blockalign (BlockBackend *blk,size_t size);bool blk_is_writable (BlockBackend *blk);
block.c +21 -5
@@ -1034,7 +1034,8 @@ static int find_image_format(BlockBackend *file, const char *filename,* Set the current 'total_sectors' value * 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;IO_CODE ();
@@ -1600,6 +1601,11 @@ out: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,const char *node_name,QDict *options,int open_flags,Error **errp)
@@ -3795,6 +3801,10 @@ out:* 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, * 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, const char *reference,
@@ -4083,6 +4093,11 @@ close_and_fail: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,QDict *options,int flags,Error **errp) {
@@ -5799,7 +5814,7 @@ BlockMeasureInfo *bdrv_measure(BlockDriver *drv, QemuOpts *opts,/** * 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;IO_CODE ();
@@ -5808,7 +5823,7 @@ int64_t bdrv_nb_sectors(BlockDriverState *bs)return -ENOMEDIUM ;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 ) {return ret; }
@@ -5820,11 +5835,12 @@ int64_t bdrv_nb_sectors(BlockDriverState *bs)* Return length in bytes on success, -errno on error. * 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 (); + ret =bdrv_co_nb_sectors (bs);if (ret <0 ) {return ret; }
block/block-backend.c +6 -4
@@ -1599,14 +1599,15 @@ BlockAIOCB *blk_aio_pwrite_zeroes(BlockBackend *blk, int64_t offset, flags | BDRV_REQ_ZERO_WRITE, cb, opaque); } -int64_t blk_getlength (BlockBackend *blk) +int64_t coroutine_fn blk_co_getlength(BlockBackend *blk) {IO_CODE (); +if (!blk_is_available (blk)) {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)
@@ -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 (); +if (!blk_is_available (blk)) {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,
block/commit.c +2 -2
@@ -123,13 +123,13 @@ static int coroutine_fn commit_run(Job *job, Error **errp) QEMU_AUTO_VFREE void *buf = NULL;int64_t len, base_len; - len =blk_getlength (s->top); + len =blk_co_getlength (s->top);if (len <0 ) {return 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 ) {return base_len; }
block/mirror.c +2 -2
@@ -909,13 +909,13 @@ static int coroutine_fn mirror_run(Job *job, Error **errp) goto immediate_exit; } - s->bdev_length =bdrv_getlength (bs); + s->bdev_length =bdrv_co_getlength (bs);if (s->bdev_length <0 ) { ret = s->bdev_length; goto immediate_exit; } - target_length =blk_getlength (s->target); + target_length =blk_co_getlength (s->target);if (target_length <0 ) { ret = target_length; goto immediate_exit;
hw/scsi/scsi-disk.c +5 -0
@@ -2332,10 +2332,15 @@ static void scsi_disk_reset(DeviceState *dev) {SCSIDiskState *s =DO_UPCAST (SCSIDiskState, qdev.qdev, dev);uint64_t nb_sectors; +AioContext *ctx;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); +aio_context_release (ctx); + nb_sectors /= s->qdev.blocksize /BDRV_SECTOR_SIZE ;if (nb_sectors) { nb_sectors--;
tests/unit/test-block-iothread.c +3 -0
@@ -831,7 +831,10 @@ static void test_attach_second_node(void)qdict_put_str (options,"driver" ,"raw" );qdict_put_str (options,"file" ,"base" ); +aio_context_acquire (ctx); 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 (bdrv_get_aio_context (bs) == ctx);g_assert (bdrv_get_aio_context (filter) == ctx);
block/meson.build +1 -0
@@ -139,6 +139,7 @@ block_gen_c = custom_target('block-gen.c', input: files( '../include/block/block-io.h', '../include/block/dirty-bitmap.h', + '../include/block/block_int-io.h', '../include/block/block-global-state.h', '../include/sysemu/block-backend-io.h', 'coroutines.h'
Signature · 1 line
2.38.1
Re: [PATCH 05/14] block: Convert bdrv_refresh_total_sectors() to co_wrapper_mixed
include/block/block_int-common.h struct BlockDriver { · line 687
Quoted 8 lines · Kevin Wolf
include/block/block_int-common.h +1
-1@@ -684,7 +684,7 @@ struct BlockDriver { int coroutine_fn (*bdrv_co_truncate)(BlockDriverState *bs, int64_t offset,bool exact,PreallocMode prealloc,BdrvRequestFlags flags,Error **errp); -int64_t (*bdrv_getlength)(BlockDriverState *bs); + int64_t coroutine_fn (*bdrv_getlength)(BlockDriverState *bs);
Like in 02 and 03, realizations of the callback are not marked coroutine_fn. [*]
(do we want to reanme it to _co_ ? This also simplifies review, in a way to check [*])
Signature · 2 lines
Best regards, Vladimir
PATCH 6/14 block-backend: use bdrv_getlength instead of blk_getlength
In reply to Kevin WolfFrom: Emanuele Giuseppe Esposito <[email protected]>
The only difference is that blk_ checks if the block is available, but this check is already performed above in blk_check_byte_request().
This is in preparation for the graph rdlock, which will be taken by both the callers of blk_check_byte_request() and blk_getlength().
--- block/block-backend.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
block/block-backend.c +1 -1
@@ -1253,7 +1253,7 @@ static int blk_check_byte_request(BlockBackend *blk, int64_t offset, }if (!blk->allow_write_beyond_eof) { - len =blk_getlength (blk); + len =bdrv_getlength (blk_bs (blk));if (len <0 ) {return len; }
Signature · 1 line
2.38.1
Re: [PATCH 06/14] block-backend: use bdrv_getlength instead of blk_getlength
Quoted 19 lines · Kevin Wolf
From: Emanuele Giuseppe Esposito <[email protected]>
The only difference is that
blk_checks if the block is available, but this check is already performed above inblk_check_byte_request().This is in preparation for the graph rdlock, which will be taken by both the callers of
blk_check_byte_request()andblk_getlength().Signed-off-by Emanuele Giuseppe Esposito <[email protected]>Signed-off-by Kevin Wolf <[email protected]>--- block/block-backend.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)block/block-backend.c +0
-0
block/block-backend.c static int blk_check_byte_request(BlockBackend *blk, int64_t offset, · line 1256
Quoted 5 lines
block/block-backend.c +1
-1@@ -1253,7 +1253,7 @@ static int blk_check_byte_request(BlockBackend *blk, int64_t offset, }if (!blk->allow_write_beyond_eof) { - len =blk_getlength (blk); + len =bdrv_getlength (blk_bs (blk));
I understand the reasoning, but the change looks like a degradation.. bdrv_* functions becomes kind of *_locked() ? If we are going to introduce a lot of such changes, that's not good. But this one is not a problem of course.
Quoted 3 lines
block/block-backend.c +0
-0if (len <0 ) {return len; }
Signature · 2 lines
Best regards, Vladimir
Re: [PATCH 06/14] block-backend: use bdrv_getlength instead of blk_getlength
Am 16/12/2022 um 18:22 schrieb Vladimir Sementsov-Ogievskiy:
Quoted 15 lines · Kevin Wolf
Quoted 14 lines
From: Emanuele Giuseppe Esposito <[email protected]>
The only difference is that
blk_checks if the block is available, but this check is already performed above inblk_check_byte_request().This is in preparation for the graph rdlock, which will be taken by both the callers of
blk_check_byte_request()andblk_getlength().Signed-off-by Emanuele Giuseppe Esposito <[email protected]>Signed-off-by Kevin Wolf <[email protected]>---
block/block-backend.c| 2 +-1 file changed, 1 insertion(+), 1 deletion(-)
Quoted 15 lines
block/block-backend.c static int blk_check_byte_request(BlockBackend · line 1256
Quoted 10 lines
block/block-backend.c +1
-1@@ -1253,7 +1253,7 @@ static int blk_check_byte_request(BlockBackend *blk, int64_t offset, } if (!blk->allow_write_beyond_eof) { - len = blk_getlength(blk); + len = bdrv_getlength(blk_bs(blk));I understand the reasoning, but the change looks like a degradation.. bdrv_* functions becomes kind of
*_locked()? If we are going to introduce a lot of such changes, that's not good. But this one is not a problem of course.
Nope, that's the only one (you can check my previous series "part 1", "part 2" and "part 3" to have an idea on what is coming).
Thank you,
Emanuele
Quoted 7 lines
Reviewed-by Vladimir Sementsov-Ogievskiy <[email protected]>Quoted 3 lines
block/block-backend.c +0
-0if (len < 0) { return len; }
PATCH 7/14 block: use bdrv_co_refresh_total_sectors when possible
In reply to Kevin WolfFrom: Emanuele Giuseppe Esposito <[email protected]>
In some places we are sure we are always running in a coroutine, therefore it's useless to call the generated_co_wrapper, instead call directly the _co_ function.
--- block/block-backend.c | 6 +++--- block/copy-on-read.c | 2 +- block/io.c | 4 ++-- 3 files changed, 6 insertions(+), 6 deletions(-)
block/block-backend.c +3 -3
@@ -1235,8 +1235,8 @@ void blk_set_disable_request_queuing(BlockBackend *blk, bool disable) blk->disable_request_queuing = disable; } -static int blk_check_byte_request (BlockBackend *blk,int64_t offset, -int64_t bytes) +static coroutine_fn int blk_check_byte_request(BlockBackend *blk, +int64_t offset,int64_t bytes) {int64_t len;
@@ -1253,7 +1253,7 @@ static int blk_check_byte_request(BlockBackend *blk, int64_t offset, }if (!blk->allow_write_beyond_eof) { - len =bdrv_getlength (blk_bs (blk)); + len =bdrv_co_getlength (blk_bs (blk));if (len <0 ) {return len; }
block/copy-on-read.c +1 -1
@@ -122,7 +122,7 @@ static void cor_child_perm(BlockDriverState *bs, BdrvChild *c,static int64_t cor_getlength (BlockDriverState *bs) { -return bdrv_getlength (bs->file->bs); +return bdrv_co_getlength (bs->file->bs); }
block/io.c +2 -2
@@ -3434,7 +3434,7 @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact,if (new_bytes && backing) {int64_t backing_len; - backing_len =bdrv_getlength (backing->bs); + backing_len =bdrv_co_getlength (backing->bs);if (backing_len <0 ) { ret = backing_len;error_setg_errno (errp, -ret,"Could not get backing file size" );
@@ -3464,7 +3464,7 @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact, goto out; } - ret =bdrv_refresh_total_sectors (bs, offset >>BDRV_SECTOR_BITS ); + ret =bdrv_co_refresh_total_sectors (bs, offset >>BDRV_SECTOR_BITS );if (ret <0 ) {error_setg_errno (errp, -ret,"Could not refresh total sector count" ); }else {
Signature · 1 line
2.38.1
Re: [PATCH 07/14] block: use bdrv_co_refresh_total_sectors when possible
Quoted 43 lines · Kevin Wolf
From: Emanuele Giuseppe Esposito <[email protected]>
In some places we are sure we are always running in a coroutine, therefore it's useless to call the
generated_co_wrapper, instead call directly the _co_ function.Signed-off-by Emanuele Giuseppe Esposito <[email protected]>Signed-off-by Kevin Wolf <[email protected]>--- block/block-backend.c | 6 +++--- block/copy-on-read.c | 2 +- block/io.c | 4 ++-- 3 files changed, 6 insertions(+), 6 deletions(-)block/block-backend.c +3
-3@@ -1235,8 +1235,8 @@ void blk_set_disable_request_queuing(BlockBackend *blk, bool disable) blk->disable_request_queuing = disable; } -static int blk_check_byte_request (BlockBackend *blk,int64_t offset, -int64_t bytes) +static coroutine_fn int blk_check_byte_request(BlockBackend *blk, +int64_t offset,int64_t bytes) {int64_t len;@@ -1253,7 +1253,7 @@ static int blk_check_byte_request(BlockBackend *blk, int64_t offset, }if (!blk->allow_write_beyond_eof) { - len =bdrv_getlength (blk_bs (blk)); + len =bdrv_co_getlength (blk_bs (blk));if (len <0 ) {return len; }block/copy-on-read.c +0
-0
block/copy-on-read.c static void cor_child_perm(BlockDriverState *bs, BdrvChild *c, · line 123
Quoted 2 lines
block/copy-on-read.c +0
-0@@ -122,7 +122,7 @@ static void cor_child_perm(BlockDriverState *bs, BdrvChild *c,static int64_t cor_getlength (BlockDriverState *bs)
obviously missed coroutine_fn, in 05
Quoted 28 lines
block/copy-on-read.c +1
-1{ -return bdrv_getlength (bs->file->bs); +return bdrv_co_getlength (bs->file->bs); }block/io.c +2
-2@@ -3434,7 +3434,7 @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact,if (new_bytes && backing) {int64_t backing_len; - backing_len =bdrv_getlength (backing->bs); + backing_len =bdrv_co_getlength (backing->bs);if (backing_len <0 ) { ret = backing_len;error_setg_errno (errp, -ret,"Could not get backing file size" );@@ -3464,7 +3464,7 @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact, goto out; } - ret =bdrv_refresh_total_sectors (bs, offset >>BDRV_SECTOR_BITS ); + ret =bdrv_co_refresh_total_sectors (bs, offset >>BDRV_SECTOR_BITS );if (ret <0 ) {error_setg_errno (errp, -ret,"Could not refresh total sector count" ); }else {
Signature · 2 lines
Best regards, Vladimir
PATCH 8/14 block: Convert bdrv_get_allocated_file_size() to co_wrapper
In reply to Kevin WolfFrom: Emanuele Giuseppe Esposito <[email protected]>
bdrv_get_allocated_file_size() is categorized as an I/O function, and it currently doesn't run in a coroutine. We should let it take a graph rdlock since it 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.
--- include/block/block-io.h | 4 +++- include/block/block_int-common.h | 3 ++- block.c | 6 +++--- block/qcow2-refcount.c | 2 +- 4 files changed, 9 insertions(+), 6 deletions(-)
include/block/block-io.h +3 -1
@@ -79,7 +79,9 @@ 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 coroutine_fn bdrv_co_get_allocated_file_size(BlockDriverState *bs); +int64_t co_wrapper bdrv_get_allocated_file_size(BlockDriverState *bs); +BlockMeasureInfo *bdrv_measure (BlockDriver *drv,QemuOpts *opts,BlockDriverState *in_bs,Error **errp);void bdrv_get_geometry (BlockDriverState *bs,uint64_t *nb_sectors_ptr);
include/block/block_int-common.h +2 -1
@@ -685,7 +685,8 @@ struct BlockDriver { bool exact, PreallocMode prealloc, BdrvRequestFlags flags, Error **errp); int64_t coroutine_fn (*bdrv_getlength)(BlockDriverState *bs); -int64_t (*bdrv_get_allocated_file_size)(BlockDriverState *bs); + int64_t coroutine_fn (*bdrv_get_allocated_file_size)(BlockDriverState *bs); + BlockMeasureInfo *(*bdrv_measure)(QemuOpts *opts, BlockDriverState *in_bs, Error **errp);
block.c +3 -3
@@ -5732,7 +5732,7 @@ static int64_t bdrv_sum_allocated_file_size(BlockDriverState *bs)if (child->role & (BDRV_CHILD_DATA |BDRV_CHILD_METADATA |BDRV_CHILD_FILTERED )) { - child_size =bdrv_get_allocated_file_size (child->bs); + child_size =bdrv_co_get_allocated_file_size (child->bs);if (child_size <0 ) {return child_size; }
@@ -5747,7 +5747,7 @@ static int64_t bdrv_sum_allocated_file_size(BlockDriverState *bs)* Length of a allocated file in bytes. Sparse files are counted by actual * allocated space. Return < 0 if error or unknown. */ -int64_t bdrv_get_allocated_file_size (BlockDriverState *bs) +int64_t coroutine_fn bdrv_co_get_allocated_file_size(BlockDriverState *bs) {BlockDriver *drv = bs->drv;IO_CODE ();
@@ -5768,7 +5768,7 @@ int64_t bdrv_get_allocated_file_size(BlockDriverState *bs)return -ENOTSUP ; }else if (drv->is_filter) {/* Filter drivers default to the size of their filtered child */ -return bdrv_get_allocated_file_size (bdrv_filter_bs (bs)); +return bdrv_co_get_allocated_file_size (bdrv_filter_bs (bs)); }else {/* Other drivers default to summing their children's sizes */ return bdrv_sum_allocated_file_size (bs);
block/qcow2-refcount.c +1 -1
@@ -3719,7 +3719,7 @@ int coroutine_fn qcow2_detect_metadata_preallocation(BlockDriverState *bs)return file_length; } - real_allocation =bdrv_get_allocated_file_size (bs->file->bs); + real_allocation =bdrv_co_get_allocated_file_size (bs->file->bs);if (real_allocation <0 ) {return real_allocation; }
Signature · 1 line
2.38.1
PATCH 9/14 block: Convert bdrv_get_info() to co_wrapper_mixed
In reply to Kevin WolfFrom: Emanuele Giuseppe Esposito <[email protected]>
bdrv_get_info() is categorized as an I/O function, and it currently doesn't run in a coroutine. We should let it take a graph rdlock since it 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.
--- include/block/block-io.h | 5 ++++- include/block/block_int-common.h | 3 ++- block.c | 4 ++-- block/crypto.c | 2 +- block/io.c | 8 ++++---- block/mirror.c | 2 +- block/raw-format.c | 2 +- 7 files changed, 15 insertions(+), 11 deletions(-)
include/block/block-io.h +4 -1
@@ -148,7 +148,10 @@ bool bdrv_supports_compressed_writes(BlockDriverState *bs);const char *bdrv_get_node_name (const BlockDriverState *bs);const char *bdrv_get_device_name (const BlockDriverState *bs);const char *bdrv_get_device_or_node_name (const BlockDriverState *bs); -int bdrv_get_info (BlockDriverState *bs,BlockDriverInfo *bdi); + +int coroutine_fn bdrv_co_get_info(BlockDriverState *bs, BlockDriverInfo *bdi); +int co_wrapper_mixed bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi); +ImageInfoSpecific *bdrv_get_specific_info (BlockDriverState *bs,Error **errp);BlockStatsSpecific *bdrv_get_specific_stats (BlockDriverState *bs);
include/block/block_int-common.h +2 -1
@@ -696,7 +696,8 @@ struct BlockDriver { int64_t offset, int64_t bytes, QEMUIOVector *qiov, size_t qiov_offset); -int (*bdrv_get_info)(BlockDriverState *bs,BlockDriverInfo *bdi); + int coroutine_fn (*bdrv_get_info)(BlockDriverState *bs, +BlockDriverInfo *bdi); ImageInfoSpecific *(*bdrv_get_specific_info)(BlockDriverState *bs, Error **errp);
block.c +2 -2
@@ -6300,7 +6300,7 @@ void bdrv_get_backing_filename(BlockDriverState *bs,pstrcpy (filename, filename_size, bs->backing_file); } -int bdrv_get_info (BlockDriverState *bs,BlockDriverInfo *bdi) +int coroutine_fn bdrv_co_get_info(BlockDriverState *bs, BlockDriverInfo *bdi) {int ret;BlockDriver *drv = bs->drv;
@@ -6312,7 +6312,7 @@ int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)if (!drv->bdrv_get_info) {BlockDriverState *filtered =bdrv_filter_bs (bs);if (filtered) { -return bdrv_get_info (filtered, bdi); +return bdrv_co_get_info (filtered, bdi); }return -ENOTSUP ; }
block/crypto.c +1 -1
@@ -743,7 +743,7 @@ static int block_crypto_get_info_luks(BlockDriverState *bs,BlockDriverInfo subbdi;int ret; - ret =bdrv_get_info (bs->file->bs, &subbdi); + ret =bdrv_co_get_info (bs->file->bs, &subbdi);if (ret !=0 ) {return ret; }
block/io.c +4 -4
@@ -712,14 +712,14 @@ BdrvTrackedRequest *coroutine_fn bdrv_co_get_self_request(BlockDriverState *bs)/** * Round a region to cluster boundaries */ -void bdrv_round_to_clusters (BlockDriverState *bs, +void coroutine_fn bdrv_round_to_clusters(BlockDriverState *bs,int64_t offset,int64_t bytes,int64_t *cluster_offset,int64_t *cluster_bytes) {BlockDriverInfo bdi;IO_CODE (); -if (bdrv_get_info (bs, &bdi) <0 || bdi.cluster_size ==0 ) { +if (bdrv_co_get_info (bs, &bdi) <0 || bdi.cluster_size ==0 ) { *cluster_offset = offset; *cluster_bytes = bytes; }else {
@@ -729,12 +729,12 @@ void bdrv_round_to_clusters(BlockDriverState *bs, } } -static int bdrv_get_cluster_size (BlockDriverState *bs) +static coroutine_fn int bdrv_get_cluster_size(BlockDriverState *bs) {BlockDriverInfo bdi;int ret; - ret =bdrv_get_info (bs, &bdi); + ret =bdrv_co_get_info (bs, &bdi);if (ret <0 || bdi.cluster_size ==0 ) {return bs->bl.request_alignment; }else {
block/mirror.c +1 -1
@@ -956,7 +956,7 @@ static int coroutine_fn mirror_run(Job *job, Error **errp)*/ bdrv_get_backing_filename (target_bs, backing_filename,sizeof (backing_filename)); -if (!bdrv_get_info (target_bs, &bdi) && bdi.cluster_size) { +if (!bdrv_co_get_info (target_bs, &bdi) && bdi.cluster_size) { s->target_cluster_size = bdi.cluster_size; }else { s->target_cluster_size =BDRV_SECTOR_SIZE ;
block/raw-format.c +1 -1
@@ -369,7 +369,7 @@ static BlockMeasureInfo *raw_measure(QemuOpts *opts, BlockDriverState *in_bs,static int raw_get_info (BlockDriverState *bs,BlockDriverInfo *bdi) { -return bdrv_get_info (bs->file->bs, bdi); +return bdrv_co_get_info (bs->file->bs, bdi); }static void raw_refresh_limits (BlockDriverState *bs,Error **errp)
Signature · 1 line
2.38.1
PATCH 10/14 block: Convert bdrv_is_inserted() to co_wrapper
In reply to Kevin WolfFrom: Emanuele Giuseppe Esposito <[email protected]>
bdrv_is_inserted() is categorized as an I/O function, and it currently doesn't run in a coroutine. We should let it take a graph rdlock since it 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.
At the same time, add also blk_is_inserted as co_wrapper_mixed, since it is called in both coroutine and non-coroutine contexts.
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 c_w_mixed_bdrv_rdlock calls AIO_WAIT_WHILE and it expects to release the AioContext lock. 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.
--- include/block/block-io.h | 5 ++++- include/block/block_int-common.h | 2 +- include/sysemu/block-backend-io.h | 5 ++++- block.c | 4 ++-- block/block-backend.c | 4 ++-- block/io.c | 12 ++++++------ blockdev.c | 8 +++++++- 7 files changed, 26 insertions(+), 14 deletions(-)
include/block/block-io.h +4 -1
@@ -139,7 +139,10 @@ bool bdrv_is_read_only(BlockDriverState *bs);bool bdrv_is_writable (BlockDriverState *bs);bool bdrv_is_sg (BlockDriverState *bs);int bdrv_get_flags (BlockDriverState *bs); -bool bdrv_is_inserted (BlockDriverState *bs); + +bool coroutine_fn bdrv_co_is_inserted(BlockDriverState *bs); +bool co_wrapper bdrv_is_inserted(BlockDriverState *bs); +void bdrv_lock_medium (BlockDriverState *bs,bool locked);void bdrv_eject (BlockDriverState *bs,bool eject_flag);const char *bdrv_get_format_name (BlockDriverState *bs);
include/block/block_int-common.h +1 -1
@@ -710,7 +710,7 @@ struct BlockDriver { BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos);/* removable device specific */ -bool (*bdrv_is_inserted)(BlockDriverState *bs); + bool coroutine_fn (*bdrv_is_inserted)(BlockDriverState *bs);void (*bdrv_eject)(BlockDriverState *bs,bool eject_flag);void (*bdrv_lock_medium)(BlockDriverState *bs,bool locked);
include/sysemu/block-backend-io.h +4 -1
@@ -53,7 +53,10 @@ BlockAIOCB *blk_aio_ioctl(BlockBackend *blk, unsigned long int req, void *buf,void blk_inc_in_flight (BlockBackend *blk);void blk_dec_in_flight (BlockBackend *blk); -bool blk_is_inserted (BlockBackend *blk); + +bool coroutine_fn blk_co_is_inserted(BlockBackend *blk); +bool co_wrapper_mixed blk_is_inserted(BlockBackend *blk); +bool blk_is_available (BlockBackend *blk);void blk_lock_medium (BlockBackend *blk,bool locked);void blk_eject (BlockBackend *blk,bool eject_flag);
block.c +2 -2
@@ -6797,7 +6797,7 @@ out:/** * Return TRUE if the media is present */ -bool bdrv_is_inserted (BlockDriverState *bs) +bool coroutine_fn bdrv_co_is_inserted(BlockDriverState *bs) {BlockDriver *drv = bs->drv;BdrvChild *child;
@@ -6810,7 +6810,7 @@ bool bdrv_is_inserted(BlockDriverState *bs)return drv->bdrv_is_inserted (bs); } QLIST_FOREACH(child, &bs->children, next) { -if (!bdrv_is_inserted (child->bs)) { +if (!bdrv_co_is_inserted (child->bs)) {return false; } }
block/block-backend.c +2 -2
@@ -1985,12 +1985,12 @@ void blk_activate(BlockBackend *blk, Error **errp)bdrv_activate (bs, errp); } -bool blk_is_inserted (BlockBackend *blk) +bool coroutine_fn blk_co_is_inserted(BlockBackend *blk) {BlockDriverState *bs =blk_bs (blk);IO_CODE (); -return bs &&bdrv_is_inserted (bs); +return bs &&bdrv_co_is_inserted (bs); }bool blk_is_available (BlockBackend *blk)
block/io.c +6 -6
@@ -1612,7 +1612,7 @@ int coroutine_fn bdrv_co_preadv_part(BdrvChild *child,trace_bdrv_co_preadv_part (bs, offset, bytes, flags); -if (!bdrv_is_inserted (bs)) { +if (!bdrv_co_is_inserted (bs)) {return -ENOMEDIUM ; }
@@ -2057,7 +2057,7 @@ int coroutine_fn bdrv_co_pwritev_part(BdrvChild *child,trace_bdrv_co_pwritev_part (child->bs, offset, bytes, flags); -if (!bdrv_is_inserted (bs)) { +if (!bdrv_co_is_inserted (bs)) {return -ENOMEDIUM ; }
@@ -2825,7 +2825,7 @@ int coroutine_fn bdrv_co_flush(BlockDriverState *bs)bdrv_inc_in_flight (bs); -if (!bdrv_is_inserted (bs) ||bdrv_is_read_only (bs) || +if (!bdrv_co_is_inserted (bs) ||bdrv_is_read_only (bs) ||bdrv_is_sg (bs)) { goto early_exit; }
@@ -2949,7 +2949,7 @@ int coroutine_fn bdrv_co_pdiscard(BdrvChild *child, int64_t offset,BlockDriverState *bs = child->bs;IO_CODE (); -if (!bs || !bs->drv || !bdrv_is_inserted (bs)) { +if (!bs || !bs->drv || !bdrv_co_is_inserted (bs)) {return -ENOMEDIUM ; }
@@ -3231,7 +3231,7 @@ static int coroutine_fn bdrv_co_copy_range_internal(assert (!(read_flags &BDRV_REQ_NO_WAIT ));assert (!(write_flags &BDRV_REQ_NO_WAIT )); -if (!dst || !dst->bs || !bdrv_is_inserted (dst->bs)) { +if (!dst || !dst->bs || !bdrv_co_is_inserted (dst->bs)) {return -ENOMEDIUM ; } ret =bdrv_check_request32 (dst_offset, bytes,NULL ,0 );
@@ -3242,7 +3242,7 @@ static int coroutine_fn bdrv_co_copy_range_internal(return bdrv_co_pwrite_zeroes (dst, dst_offset, bytes, write_flags); } -if (!src || !src->bs || !bdrv_is_inserted (src->bs)) { +if (!src || !src->bs || !bdrv_co_is_inserted (src->bs)) {return -ENOMEDIUM ; } ret =bdrv_check_request32 (src_offset, bytes,NULL ,0 );
blockdev.c +7 -1
@@ -1023,6 +1023,7 @@ fail:static BlockDriverState *qmp_get_root_bs (const char *name,Error **errp) {BlockDriverState *bs; +AioContext *aio_context; bs =bdrv_lookup_bs (name, name, errp);if (bs ==NULL ) {
@@ -1034,11 +1035,16 @@ static BlockDriverState *qmp_get_root_bs(const char *name, Error **errp)return NULL ; } + aio_context =bdrv_get_aio_context (bs); +aio_context_acquire (aio_context); +if (!bdrv_is_inserted (bs)) {error_setg (errp,"Device has no medium" ); -return NULL ; + bs =NULL ; } +aio_context_release (aio_context); +return bs; }
Signature · 1 line
2.38.1
PATCH 11/14 block: Convert bdrv_eject() to co_wrapper
In reply to Kevin WolfFrom: Emanuele Giuseppe Esposito <[email protected]>
bdrv_eject() is categorized as an I/O function, and it currently doesn't run in a coroutine. We should let it take a graph rdlock since it traverses the block nodes graph, which however is only possible in a coroutine.
The only caller of this function is blk_eject(). Therefore make blk_eject() a co_wrapper, so that it always creates a new coroutine, and then make bdrv_eject() coroutine_fn where the lock can be taken.
--- include/block/block-io.h | 3 ++- include/block/block_int-common.h | 2 +- include/sysemu/block-backend-io.h | 4 +++- block.c | 2 +- block/block-backend.c | 4 ++-- block/copy-on-read.c | 2 +- block/filter-compress.c | 2 +- block/raw-format.c | 2 +- 8 files changed, 12 insertions(+), 9 deletions(-)
include/block/block-io.h +2 -1
@@ -144,7 +144,8 @@ bool coroutine_fn bdrv_co_is_inserted(BlockDriverState *bs); bool co_wrapper bdrv_is_inserted(BlockDriverState *bs);void bdrv_lock_medium (BlockDriverState *bs,bool locked); -void bdrv_eject (BlockDriverState *bs,bool eject_flag); +void coroutine_fn bdrv_co_eject(BlockDriverState *bs, bool eject_flag); +const char *bdrv_get_format_name (BlockDriverState *bs);bool bdrv_supports_compressed_writes (BlockDriverState *bs);
include/block/block_int-common.h +1 -1
@@ -711,7 +711,7 @@ struct BlockDriver {/* removable device specific */ bool coroutine_fn (*bdrv_is_inserted)(BlockDriverState *bs); -void (*bdrv_eject)(BlockDriverState *bs,bool eject_flag); + void coroutine_fn (*bdrv_eject)(BlockDriverState *bs, bool eject_flag);void (*bdrv_lock_medium)(BlockDriverState *bs,bool locked);/* to control generic scsi devices */
include/sysemu/block-backend-io.h +3 -1
@@ -59,7 +59,9 @@ bool co_wrapper_mixed blk_is_inserted(BlockBackend *blk);bool blk_is_available (BlockBackend *blk);void blk_lock_medium (BlockBackend *blk,bool locked); -void blk_eject (BlockBackend *blk,bool eject_flag); + +void coroutine_fn blk_co_eject(BlockBackend *blk, bool eject_flag); +void co_wrapper blk_eject(BlockBackend *blk, bool eject_flag); int64_t coroutine_fn blk_co_getlength(BlockBackend *blk); int64_t co_wrapper_mixed blk_getlength(BlockBackend *blk);
block.c +1 -1
@@ -6820,7 +6820,7 @@ bool coroutine_fn bdrv_co_is_inserted(BlockDriverState *bs)/** * If eject_flag is TRUE, eject the media. Otherwise, close the tray */ -void bdrv_eject (BlockDriverState *bs,bool eject_flag) +void coroutine_fn bdrv_co_eject(BlockDriverState *bs, bool eject_flag) {BlockDriver *drv = bs->drv;IO_CODE ();
block/block-backend.c +2 -2
@@ -2009,14 +2009,14 @@ void blk_lock_medium(BlockBackend *blk, bool locked) } } -void blk_eject (BlockBackend *blk,bool eject_flag) +void coroutine_fn blk_co_eject(BlockBackend *blk, bool eject_flag) {BlockDriverState *bs =blk_bs (blk);char *id;IO_CODE ();if (bs) { -bdrv_eject (bs, eject_flag); +bdrv_co_eject (bs, eject_flag); }/* Whether or not we ejected on the backend,
block/copy-on-read.c +1 -1
@@ -218,7 +218,7 @@ static int coroutine_fn cor_co_pwritev_compressed(BlockDriverState *bs,static void cor_eject (BlockDriverState *bs,bool eject_flag) { -bdrv_eject (bs->file->bs, eject_flag); +bdrv_co_eject (bs->file->bs, eject_flag); }
block/filter-compress.c +1 -1
@@ -118,7 +118,7 @@ static void compress_refresh_limits(BlockDriverState *bs, Error **errp)static void compress_eject (BlockDriverState *bs,bool eject_flag) { -bdrv_eject (bs->file->bs, eject_flag); +bdrv_co_eject (bs->file->bs, eject_flag); }
block/raw-format.c +1 -1
@@ -405,7 +405,7 @@ static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,static void raw_eject (BlockDriverState *bs,bool eject_flag) { -bdrv_eject (bs->file->bs, eject_flag); +bdrv_co_eject (bs->file->bs, eject_flag); }static void raw_lock_medium (BlockDriverState *bs,bool locked)
Signature · 1 line
2.38.1
PATCH 12/14 block: convert bdrv_lock_medium in co_wrapper
In reply to Kevin WolfFrom: Emanuele Giuseppe Esposito <[email protected]>
bdrv_lock_medium() is categorized as an I/O function, and it currently doesn't run in a coroutine. We should let it take a graph rdlock since it traverses the block nodes graph, which however is only possible in a coroutine.
The only caller of this function is blk_lock_medium(). Therefore make blk_lock_medium() a co_wrapper, so that it always creates a new coroutine, and then make bdrv_lock_medium() a coroutine_fn where the lock can be taken.
--- include/block/block-io.h | 2 +- include/block/block_int-common.h | 2 +- include/sysemu/block-backend-io.h | 4 +++- block.c | 2 +- block/block-backend.c | 4 ++-- block/copy-on-read.c | 2 +- block/filter-compress.c | 2 +- block/raw-format.c | 2 +- 8 files changed, 11 insertions(+), 9 deletions(-)
include/block/block-io.h +1 -1
@@ -143,7 +143,7 @@ int bdrv_get_flags(BlockDriverState *bs); bool coroutine_fn bdrv_co_is_inserted(BlockDriverState *bs); bool co_wrapper bdrv_is_inserted(BlockDriverState *bs); -void bdrv_lock_medium (BlockDriverState *bs,bool locked); +void coroutine_fn bdrv_co_lock_medium(BlockDriverState *bs, bool locked); void coroutine_fn bdrv_co_eject(BlockDriverState *bs, bool eject_flag);const char *bdrv_get_format_name (BlockDriverState *bs);
include/block/block_int-common.h +1 -1
@@ -712,7 +712,7 @@ struct BlockDriver {/* removable device specific */ bool coroutine_fn (*bdrv_is_inserted)(BlockDriverState *bs); void coroutine_fn (*bdrv_eject)(BlockDriverState *bs, bool eject_flag); -void (*bdrv_lock_medium)(BlockDriverState *bs,bool locked); + void coroutine_fn (*bdrv_lock_medium)(BlockDriverState *bs, bool locked);/* to control generic scsi devices */ BlockAIOCB *(*bdrv_aio_ioctl)(BlockDriverState *bs,
include/sysemu/block-backend-io.h +3 -1
@@ -58,7 +58,9 @@ bool coroutine_fn blk_co_is_inserted(BlockBackend *blk); bool co_wrapper_mixed blk_is_inserted(BlockBackend *blk);bool blk_is_available (BlockBackend *blk); -void blk_lock_medium (BlockBackend *blk,bool locked); + +void coroutine_fn blk_co_lock_medium(BlockBackend *blk, bool locked); +void co_wrapper blk_lock_medium(BlockBackend *blk, bool locked); void coroutine_fn blk_co_eject(BlockBackend *blk, bool eject_flag); void co_wrapper blk_eject(BlockBackend *blk, bool eject_flag);
block.c +1 -1
@@ -6834,7 +6834,7 @@ void coroutine_fn bdrv_co_eject(BlockDriverState *bs, bool eject_flag)* Lock or unlock the media (if it is locked, the user won't be able * to eject it manually). */ -void bdrv_lock_medium (BlockDriverState *bs,bool locked) +void coroutine_fn bdrv_co_lock_medium(BlockDriverState *bs, bool locked) {BlockDriver *drv = bs->drv;IO_CODE ();
block/block-backend.c +2 -2
@@ -1999,13 +1999,13 @@ bool blk_is_available(BlockBackend *blk)return blk_is_inserted (blk) && !blk_dev_is_tray_open (blk); } -void blk_lock_medium (BlockBackend *blk,bool locked) +void coroutine_fn blk_co_lock_medium(BlockBackend *blk, bool locked) {BlockDriverState *bs =blk_bs (blk);IO_CODE ();if (bs) { -bdrv_lock_medium (bs, locked); +bdrv_co_lock_medium (bs, locked); } }
block/copy-on-read.c +1 -1
@@ -224,7 +224,7 @@ static void cor_eject(BlockDriverState *bs, bool eject_flag)static void cor_lock_medium (BlockDriverState *bs,bool locked) { -bdrv_lock_medium (bs->file->bs, locked); +bdrv_co_lock_medium (bs->file->bs, locked); }
block/filter-compress.c +1 -1
@@ -124,7 +124,7 @@ static void compress_eject(BlockDriverState *bs, bool eject_flag)static void compress_lock_medium (BlockDriverState *bs,bool locked) { -bdrv_lock_medium (bs->file->bs, locked); +bdrv_co_lock_medium (bs->file->bs, locked); }
block/raw-format.c +1 -1
@@ -410,7 +410,7 @@ static void raw_eject(BlockDriverState *bs, bool eject_flag)static void raw_lock_medium (BlockDriverState *bs,bool locked) { -bdrv_lock_medium (bs->file->bs, locked); +bdrv_co_lock_medium (bs->file->bs, locked); } static int coroutine_fn raw_co_ioctl(BlockDriverState *bs,
Signature · 1 line
2.38.1
PATCH 13/14 block: Convert bdrv_debug_event to co_wrapper_mixed
In reply to Kevin WolfFrom: Emanuele Giuseppe Esposito <[email protected]>
bdrv_debug_event() is categorized as an I/O function, and it currently doesn't run in a coroutine. We should let it take a graph rdlock since it traverses the block nodes graph, which however is only possible in a coroutine.
Therefore turn it into a co_wrapper_mixed to move the actual function into a coroutine where the lock can be taken.
--- include/block/block-io.h | 5 ++++- include/block/block_int-common.h | 3 ++- block.c | 2 +- block/io.c | 22 +++++++++++----------- 4 files changed, 18 insertions(+), 14 deletions(-)
include/block/block-io.h +4 -1
@@ -188,7 +188,10 @@ void *qemu_try_blockalign0(BlockDriverState *bs, size_t size);void bdrv_enable_copy_on_read (BlockDriverState *bs);void bdrv_disable_copy_on_read (BlockDriverState *bs); -void bdrv_debug_event (BlockDriverState *bs,BlkdebugEvent event); +void coroutine_fn bdrv_co_debug_event(BlockDriverState *bs, +BlkdebugEvent event); +void co_wrapper_mixed bdrv_debug_event(BlockDriverState *bs, +BlkdebugEvent event);#define BLKDBG_EVENT (child, evt) \ do { \
include/block/block_int-common.h +2 -1
@@ -728,7 +728,8 @@ struct BlockDriver { int coroutine_fn GRAPH_RDLOCK_PTR (*bdrv_co_check)(BlockDriverState *bs,BdrvCheckResult *result,BdrvCheckMode fix); -void (*bdrv_debug_event)(BlockDriverState *bs,BlkdebugEvent event); + void coroutine_fn (*bdrv_debug_event)(BlockDriverState *bs, +BlkdebugEvent event);/* io queue for linux-aio */ void coroutine_fn (*bdrv_io_plug)(BlockDriverState *bs);
block.c +1 -1
@@ -6350,7 +6350,7 @@ BlockStatsSpecific *bdrv_get_specific_stats(BlockDriverState *bs)return drv->bdrv_get_specific_stats (bs); } -void bdrv_debug_event (BlockDriverState *bs,BlkdebugEvent event) +void coroutine_fn bdrv_co_debug_event(BlockDriverState *bs, BlkdebugEvent event) {IO_CODE ();if (!bs || !bs->drv || !bs->drv->bdrv_debug_event) {
block/io.c +11 -11
@@ -1241,7 +1241,7 @@ static int coroutine_fn bdrv_co_do_copy_on_readv(BdrvChild *child, goto err; } -bdrv_debug_event (bs,BLKDBG_COR_WRITE ); +bdrv_co_debug_event (bs,BLKDBG_COR_WRITE );if (drv->bdrv_co_pwrite_zeroes &&buffer_is_zero (bounce_buffer, pnum)) {/* FIXME: Should we (perhaps conditionally) be setting
@@ -1486,10 +1486,10 @@ static coroutine_fn int bdrv_padding_rmw_read(BdrvChild *child,qemu_iovec_init_buf (&local_qiov, pad->buf, bytes);if (pad->head) { -bdrv_debug_event (bs,BLKDBG_PWRITEV_RMW_HEAD ); +bdrv_co_debug_event (bs,BLKDBG_PWRITEV_RMW_HEAD ); }if (pad->merge_reads && pad->tail) { -bdrv_debug_event (bs,BLKDBG_PWRITEV_RMW_TAIL ); +bdrv_co_debug_event (bs,BLKDBG_PWRITEV_RMW_TAIL ); } ret =bdrv_aligned_preadv (child, req, req->overlap_offset, bytes, align, &local_qiov,0 ,0 );
@@ -1497,10 +1497,10 @@ static coroutine_fn int bdrv_padding_rmw_read(BdrvChild *child,return ret; }if (pad->head) { -bdrv_debug_event (bs,BLKDBG_PWRITEV_RMW_AFTER_HEAD ); +bdrv_co_debug_event (bs,BLKDBG_PWRITEV_RMW_AFTER_HEAD ); }if (pad->merge_reads && pad->tail) { -bdrv_debug_event (bs,BLKDBG_PWRITEV_RMW_AFTER_TAIL ); +bdrv_co_debug_event (bs,BLKDBG_PWRITEV_RMW_AFTER_TAIL ); }if (pad->merge_reads) {
@@ -1511,7 +1511,7 @@ static coroutine_fn int bdrv_padding_rmw_read(BdrvChild *child,if (pad->tail) {qemu_iovec_init_buf (&local_qiov, pad->tail_buf, align); -bdrv_debug_event (bs,BLKDBG_PWRITEV_RMW_TAIL ); +bdrv_co_debug_event (bs,BLKDBG_PWRITEV_RMW_TAIL ); ret = bdrv_aligned_preadv( child, req, req->overlap_offset + req->overlap_bytes - align,
@@ -1519,7 +1519,7 @@ static coroutine_fn int bdrv_padding_rmw_read(BdrvChild *child,if (ret <0 ) {return ret; } -bdrv_debug_event (bs,BLKDBG_PWRITEV_RMW_AFTER_TAIL ); +bdrv_co_debug_event (bs,BLKDBG_PWRITEV_RMW_AFTER_TAIL ); } zero_mem:
@@ -1921,16 +1921,16 @@ static int coroutine_fn bdrv_aligned_pwritev(BdrvChild *child,if (ret <0 ) {/* Do nothing, write notifier decided to fail this request */ }else if (flags &BDRV_REQ_ZERO_WRITE ) { -bdrv_debug_event (bs,BLKDBG_PWRITEV_ZERO ); +bdrv_co_debug_event (bs,BLKDBG_PWRITEV_ZERO ); ret =bdrv_co_do_pwrite_zeroes (bs, offset, bytes, flags); }else if (flags &BDRV_REQ_WRITE_COMPRESSED ) { ret =bdrv_driver_pwritev_compressed (bs, offset, bytes, qiov, qiov_offset); }else if (bytes <= max_transfer) { -bdrv_debug_event (bs,BLKDBG_PWRITEV ); +bdrv_co_debug_event (bs,BLKDBG_PWRITEV ); ret =bdrv_driver_pwritev (bs, offset, bytes, qiov, qiov_offset, flags); }else { -bdrv_debug_event (bs,BLKDBG_PWRITEV ); +bdrv_co_debug_event (bs,BLKDBG_PWRITEV );while (bytes_remaining) {int num =MIN (bytes_remaining, max_transfer);int local_flags = flags;
@@ -1953,7 +1953,7 @@ static int coroutine_fn bdrv_aligned_pwritev(BdrvChild *child, bytes_remaining -= num; } } -bdrv_debug_event (bs,BLKDBG_PWRITEV_DONE ); +bdrv_co_debug_event (bs,BLKDBG_PWRITEV_DONE );if (ret >=0 ) { ret =0 ;
Signature · 1 line
2.38.1
PATCH 14/14 block: Rename newly converted BlockDriver IO coroutine functions
In reply to Kevin WolfFrom: Emanuele Giuseppe Esposito <[email protected]>
Since these functions always run in coroutine context, adjust their name to include "_co_", just like all other BlockDriver callbacks.
No functional change intended.
--- include/block/block_int-common.h | 27 +++++++++--------- block.c | 32 ++++++++++----------- block/blkdebug.c | 4 +-- block/blkio.c | 6 ++-- block/blklogwrites.c | 2 +- block/blkreplay.c | 2 +- block/blkverify.c | 2 +- block/copy-on-read.c | 6 ++-- block/crypto.c | 4 +-- block/curl.c | 8 +++--- block/file-posix.c | 48 ++++++++++++++++---------------- block/file-win32.c | 12 ++++---- block/filter-compress.c | 6 ++-- block/gluster.c | 16 +++++------ block/io.c | 16 +++++------ block/iscsi.c | 8 +++--- block/nbd.c | 6 ++-- block/nfs.c | 2 +- block/null.c | 8 +++--- block/nvme.c | 6 ++-- block/preallocate.c | 2 +- block/qcow.c | 2 +- block/qcow2.c | 6 ++-- block/qed.c | 4 +-- block/quorum.c | 2 +- block/raw-format.c | 8 +++--- block/rbd.c | 4 +-- block/replication.c | 2 +- block/ssh.c | 2 +- block/throttle.c | 2 +- block/vdi.c | 2 +- block/vhdx.c | 2 +- block/vmdk.c | 4 +-- block/vpc.c | 2 +- 34 files changed, 132 insertions(+), 133 deletions(-)
include/block/block_int-common.h +14 -13
@@ -684,8 +684,9 @@ struct BlockDriver { int coroutine_fn (*bdrv_co_truncate)(BlockDriverState *bs, int64_t offset,bool exact,PreallocMode prealloc,BdrvRequestFlags flags,Error **errp); - int64_t coroutine_fn (*bdrv_getlength)(BlockDriverState *bs); - int64_t coroutine_fn (*bdrv_get_allocated_file_size)(BlockDriverState *bs); + int64_t coroutine_fn (*bdrv_co_getlength)(BlockDriverState *bs); + int64_t coroutine_fn (*bdrv_co_get_allocated_file_size)( +BlockDriverState *bs); BlockMeasureInfo *(*bdrv_measure)(QemuOpts *opts, BlockDriverState *in_bs, Error **errp);
@@ -696,23 +697,23 @@ struct BlockDriver { int64_t offset, int64_t bytes, QEMUIOVector *qiov, size_t qiov_offset); - int coroutine_fn (*bdrv_get_info)(BlockDriverState *bs, -BlockDriverInfo *bdi); + int coroutine_fn (*bdrv_co_get_info)(BlockDriverState *bs, +BlockDriverInfo *bdi); ImageInfoSpecific *(*bdrv_get_specific_info)(BlockDriverState *bs, Error **errp); BlockStatsSpecific *(*bdrv_get_specific_stats)(BlockDriverState *bs); - int coroutine_fn GRAPH_RDLOCK_PTR (*bdrv_save_vmstate)( + int coroutine_fn GRAPH_RDLOCK_PTR (*bdrv_co_save_vmstate)(BlockDriverState *bs,QEMUIOVector *qiov,int64_t pos); - int coroutine_fn GRAPH_RDLOCK_PTR (*bdrv_load_vmstate)( + int coroutine_fn GRAPH_RDLOCK_PTR (*bdrv_co_load_vmstate)(BlockDriverState *bs,QEMUIOVector *qiov,int64_t pos);/* removable device specific */ - bool coroutine_fn (*bdrv_is_inserted)(BlockDriverState *bs); - void coroutine_fn (*bdrv_eject)(BlockDriverState *bs, bool eject_flag); - void coroutine_fn (*bdrv_lock_medium)(BlockDriverState *bs, bool locked); + bool coroutine_fn (*bdrv_co_is_inserted)(BlockDriverState *bs); + void coroutine_fn (*bdrv_co_eject)(BlockDriverState *bs, bool eject_flag); + void coroutine_fn (*bdrv_co_lock_medium)(BlockDriverState *bs, bool locked);/* to control generic scsi devices */ BlockAIOCB *(*bdrv_aio_ioctl)(BlockDriverState *bs,
@@ -728,12 +729,12 @@ struct BlockDriver { int coroutine_fn GRAPH_RDLOCK_PTR (*bdrv_co_check)(BlockDriverState *bs,BdrvCheckResult *result,BdrvCheckMode fix); - void coroutine_fn (*bdrv_debug_event)(BlockDriverState *bs, -BlkdebugEvent event); + void coroutine_fn (*bdrv_co_debug_event)(BlockDriverState *bs, +BlkdebugEvent event);/* io queue for linux-aio */ - void coroutine_fn (*bdrv_io_plug)(BlockDriverState *bs); - void coroutine_fn (*bdrv_io_unplug)(BlockDriverState *bs); + void coroutine_fn (*bdrv_co_io_plug)(BlockDriverState *bs); + void coroutine_fn (*bdrv_co_io_unplug)(BlockDriverState *bs);/** * bdrv_drain_begin is called if implemented in the beginning of a
block.c +16 -16
@@ -1044,13 +1044,13 @@ int coroutine_fn bdrv_co_refresh_total_sectors(BlockDriverState *bs,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))return 0 ;/* query actual device if possible, otherwise just trust the hint */ -if (drv->bdrv_getlength) { -int64_t length = drv->bdrv_getlength (bs); +if (drv->bdrv_co_getlength) { +int64_t length = drv->bdrv_co_getlength (bs);if (length <0 ) {return length; }
@@ -5719,7 +5719,7 @@ exit: }/** -* Implementation of BlockDriver.bdrv_get_allocated_file_size() that +* Implementation of BlockDriver.bdrv_co_get_allocated_file_size() that * sums the size of all data-bearing children. (This excludes backing * children.) */
@@ -5755,8 +5755,8 @@ int64_t coroutine_fn bdrv_co_get_allocated_file_size(BlockDriverState *bs)if (!drv) {return -ENOMEDIUM ; } -if (drv->bdrv_get_allocated_file_size) { -return drv->bdrv_get_allocated_file_size (bs); +if (drv->bdrv_co_get_allocated_file_size) { +return drv->bdrv_co_get_allocated_file_size (bs); }if (drv->bdrv_file_open) {
@@ -6309,7 +6309,7 @@ int coroutine_fn bdrv_co_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)if (!drv) {return -ENOMEDIUM ; } -if (!drv->bdrv_get_info) { +if (!drv->bdrv_co_get_info) {BlockDriverState *filtered =bdrv_filter_bs (bs);if (filtered) {return bdrv_co_get_info (filtered, bdi);
@@ -6317,7 +6317,7 @@ int coroutine_fn bdrv_co_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)return -ENOTSUP ; }memset (bdi,0 ,sizeof (*bdi)); - ret = drv->bdrv_get_info (bs, bdi); + ret = drv->bdrv_co_get_info (bs, bdi);if (ret <0 ) {return ret; }
@@ -6353,11 +6353,11 @@ BlockStatsSpecific *bdrv_get_specific_stats(BlockDriverState *bs) void coroutine_fn bdrv_co_debug_event(BlockDriverState *bs, BlkdebugEvent event) {IO_CODE (); -if (!bs || !bs->drv || !bs->drv->bdrv_debug_event) { +if (!bs || !bs->drv || !bs->drv->bdrv_co_debug_event) {return ; } - bs->drv->bdrv_debug_event (bs, event); + bs->drv->bdrv_co_debug_event (bs, event); }static BlockDriverState *bdrv_find_debug_node (BlockDriverState *bs)
@@ -6806,8 +6806,8 @@ bool coroutine_fn bdrv_co_is_inserted(BlockDriverState *bs)if (!drv) {return false; } -if (drv->bdrv_is_inserted) { -return drv->bdrv_is_inserted (bs); +if (drv->bdrv_co_is_inserted) { +return drv->bdrv_co_is_inserted (bs); } QLIST_FOREACH(child, &bs->children, next) {if (!bdrv_co_is_inserted (child->bs)) {
@@ -6825,8 +6825,8 @@ void coroutine_fn bdrv_co_eject(BlockDriverState *bs, bool eject_flag)BlockDriver *drv = bs->drv;IO_CODE (); -if (drv && drv->bdrv_eject) { - drv->bdrv_eject (bs, eject_flag); +if (drv && drv->bdrv_co_eject) { + drv->bdrv_co_eject (bs, eject_flag); } }
@@ -6840,8 +6840,8 @@ void coroutine_fn bdrv_co_lock_medium(BlockDriverState *bs, bool locked)IO_CODE ();trace_bdrv_lock_medium (bs, locked); -if (drv && drv->bdrv_lock_medium) { - drv->bdrv_lock_medium (bs, locked); +if (drv && drv->bdrv_co_lock_medium) { + drv->bdrv_co_lock_medium (bs, locked); } }
block/blkdebug.c +2 -2
@@ -1076,7 +1076,7 @@ static BlockDriver bdrv_blkdebug = { .bdrv_reopen_prepare = blkdebug_reopen_prepare, .bdrv_child_perm = blkdebug_child_perm, - .bdrv_getlength = blkdebug_getlength, + .bdrv_co_getlength = blkdebug_getlength, .bdrv_refresh_filename = blkdebug_refresh_filename, .bdrv_refresh_limits = blkdebug_refresh_limits,
@@ -1087,7 +1087,7 @@ static BlockDriver bdrv_blkdebug = { .bdrv_co_pdiscard = blkdebug_co_pdiscard, .bdrv_co_block_status = blkdebug_co_block_status, - .bdrv_debug_event = blkdebug_debug_event, + .bdrv_co_debug_event = blkdebug_debug_event, .bdrv_debug_breakpoint = blkdebug_debug_breakpoint, .bdrv_debug_remove_breakpoint = blkdebug_debug_remove_breakpoint,
block/blkio.c +3 -3
@@ -996,9 +996,9 @@ static void blkio_refresh_limits(BlockDriverState *bs, Error **errp) .instance_size = sizeof(BDRVBlkioState), \ .bdrv_file_open = blkio_file_open, \ .bdrv_close = blkio_close, \ - .bdrv_getlength = blkio_getlength, \ + .bdrv_co_getlength = blkio_getlength, \ .bdrv_co_truncate = blkio_truncate, \ - .bdrv_get_info = blkio_get_info, \ + .bdrv_co_get_info = blkio_get_info, \ .bdrv_attach_aio_context = blkio_attach_aio_context, \ .bdrv_detach_aio_context = blkio_detach_aio_context, \ .bdrv_co_pdiscard = blkio_co_pdiscard, \
@@ -1006,7 +1006,7 @@ static void blkio_refresh_limits(BlockDriverState *bs, Error **errp) .bdrv_co_pwritev = blkio_co_pwritev, \ .bdrv_co_flush_to_disk = blkio_co_flush, \ .bdrv_co_pwrite_zeroes = blkio_co_pwrite_zeroes, \ - .bdrv_io_unplug = blkio_io_unplug, \ + .bdrv_co_io_unplug = blkio_io_unplug, \ .bdrv_refresh_limits = blkio_refresh_limits, \ .bdrv_register_buf = blkio_register_buf, \ .bdrv_unregister_buf = blkio_unregister_buf, \
block/blklogwrites.c +1 -1
@@ -497,7 +497,7 @@ static BlockDriver bdrv_blk_log_writes = { .bdrv_open = blk_log_writes_open, .bdrv_close = blk_log_writes_close, - .bdrv_getlength = blk_log_writes_getlength, + .bdrv_co_getlength = blk_log_writes_getlength, .bdrv_child_perm = blk_log_writes_child_perm, .bdrv_refresh_limits = blk_log_writes_refresh_limits,
block/blkreplay.c +1 -1
@@ -135,7 +135,7 @@ static BlockDriver bdrv_blkreplay = { .bdrv_open = blkreplay_open, .bdrv_child_perm = bdrv_default_perms, - .bdrv_getlength = blkreplay_getlength, + .bdrv_co_getlength = blkreplay_getlength, .bdrv_co_preadv = blkreplay_co_preadv, .bdrv_co_pwritev = blkreplay_co_pwritev,
block/blkverify.c +1 -1
@@ -313,7 +313,7 @@ static BlockDriver bdrv_blkverify = { .bdrv_file_open = blkverify_open, .bdrv_close = blkverify_close, .bdrv_child_perm = bdrv_default_perms, - .bdrv_getlength = blkverify_getlength, + .bdrv_co_getlength = blkverify_getlength, .bdrv_refresh_filename = blkverify_refresh_filename, .bdrv_dirname = blkverify_dirname,
block/copy-on-read.c +3 -3
@@ -249,7 +249,7 @@ static BlockDriver bdrv_copy_on_read = { .bdrv_close = cor_close, .bdrv_child_perm = cor_child_perm, - .bdrv_getlength = cor_getlength, + .bdrv_co_getlength = cor_getlength, .bdrv_co_preadv_part = cor_co_preadv_part, .bdrv_co_pwritev_part = cor_co_pwritev_part,
@@ -257,8 +257,8 @@ static BlockDriver bdrv_copy_on_read = { .bdrv_co_pdiscard = cor_co_pdiscard, .bdrv_co_pwritev_compressed = cor_co_pwritev_compressed, - .bdrv_eject = cor_eject, - .bdrv_lock_medium = cor_lock_medium, + .bdrv_co_eject = cor_eject, + .bdrv_co_lock_medium = cor_lock_medium, .has_variable_length = true, .is_filter = true,
block/crypto.c +2 -2
@@ -953,9 +953,9 @@ static BlockDriver bdrv_crypto_luks = { .bdrv_refresh_limits = block_crypto_refresh_limits, .bdrv_co_preadv = block_crypto_co_preadv, .bdrv_co_pwritev = block_crypto_co_pwritev, - .bdrv_getlength = block_crypto_getlength, + .bdrv_co_getlength = block_crypto_getlength, .bdrv_measure = block_crypto_measure, - .bdrv_get_info = block_crypto_get_info_luks, + .bdrv_co_get_info = block_crypto_get_info_luks, .bdrv_get_specific_info = block_crypto_get_specific_info_luks, .bdrv_amend_options = block_crypto_amend_options_luks, .bdrv_co_amend = block_crypto_co_amend_luks,
block/curl.c +4 -4
@@ -1001,7 +1001,7 @@ static BlockDriver bdrv_http = { .bdrv_parse_filename = curl_parse_filename, .bdrv_file_open = curl_open, .bdrv_close = curl_close, - .bdrv_getlength = curl_getlength, + .bdrv_co_getlength = curl_getlength, .bdrv_co_preadv = curl_co_preadv,
@@ -1020,7 +1020,7 @@ static BlockDriver bdrv_https = { .bdrv_parse_filename = curl_parse_filename, .bdrv_file_open = curl_open, .bdrv_close = curl_close, - .bdrv_getlength = curl_getlength, + .bdrv_co_getlength = curl_getlength, .bdrv_co_preadv = curl_co_preadv,
@@ -1039,7 +1039,7 @@ static BlockDriver bdrv_ftp = { .bdrv_parse_filename = curl_parse_filename, .bdrv_file_open = curl_open, .bdrv_close = curl_close, - .bdrv_getlength = curl_getlength, + .bdrv_co_getlength = curl_getlength, .bdrv_co_preadv = curl_co_preadv,
@@ -1058,7 +1058,7 @@ static BlockDriver bdrv_ftps = { .bdrv_parse_filename = curl_parse_filename, .bdrv_file_open = curl_open, .bdrv_close = curl_close, - .bdrv_getlength = curl_getlength, + .bdrv_co_getlength = curl_getlength, .bdrv_co_preadv = curl_co_preadv,
block/file-posix.c +24 -24
92 lines not on this page · raw message
block/file-win32.c +5 -7
@@ -763,8 +763,8 @@ BlockDriver bdrv_file = { .bdrv_aio_flush = raw_aio_flush, .bdrv_co_truncate = raw_co_truncate, - .bdrv_getlength = raw_getlength, - .bdrv_get_allocated_file_size + .bdrv_co_getlength = raw_getlength, + .bdrv_co_get_allocated_file_size = raw_get_allocated_file_size, .create_opts = &raw_create_opts,
@@ -932,11 +932,9 @@ static BlockDriver bdrv_host_device = { .bdrv_detach_aio_context = raw_detach_aio_context, .bdrv_attach_aio_context = raw_attach_aio_context, - .bdrv_getlength = raw_getlength, - .has_variable_length = true, - - .bdrv_get_allocated_file_size - = raw_get_allocated_file_size, + .bdrv_co_getlength = raw_getlength, + .has_variable_length = true, + .bdrv_co_get_allocated_file_size = raw_get_allocated_file_size, };static void bdrv_file_init (void )
block/filter-compress.c +3 -3
@@ -134,7 +134,7 @@ static BlockDriver bdrv_compress = { .bdrv_open = compress_open, .bdrv_child_perm = bdrv_default_perms, - .bdrv_getlength = compress_getlength, + .bdrv_co_getlength = compress_getlength, .bdrv_co_preadv_part = compress_co_preadv_part, .bdrv_co_pwritev_part = compress_co_pwritev_part,
@@ -142,8 +142,8 @@ static BlockDriver bdrv_compress = { .bdrv_co_pdiscard = compress_co_pdiscard, .bdrv_refresh_limits = compress_refresh_limits, - .bdrv_eject = compress_eject, - .bdrv_lock_medium = compress_lock_medium, + .bdrv_co_eject = compress_eject, + .bdrv_co_lock_medium = compress_lock_medium, .has_variable_length = true, .is_filter = true,
block/gluster.c +8 -8
@@ -1561,8 +1561,8 @@ static BlockDriver bdrv_gluster = { .bdrv_close = qemu_gluster_close, .bdrv_co_create = qemu_gluster_co_create, .bdrv_co_create_opts = qemu_gluster_co_create_opts, - .bdrv_getlength = qemu_gluster_getlength, - .bdrv_get_allocated_file_size = qemu_gluster_allocated_file_size, + .bdrv_co_getlength = qemu_gluster_getlength, + .bdrv_co_get_allocated_file_size = qemu_gluster_allocated_file_size, .bdrv_co_truncate = qemu_gluster_co_truncate, .bdrv_co_readv = qemu_gluster_co_readv, .bdrv_co_writev = qemu_gluster_co_writev,
@@ -1590,8 +1590,8 @@ static BlockDriver bdrv_gluster_tcp = { .bdrv_close = qemu_gluster_close, .bdrv_co_create = qemu_gluster_co_create, .bdrv_co_create_opts = qemu_gluster_co_create_opts, - .bdrv_getlength = qemu_gluster_getlength, - .bdrv_get_allocated_file_size = qemu_gluster_allocated_file_size, + .bdrv_co_getlength = qemu_gluster_getlength, + .bdrv_co_get_allocated_file_size = qemu_gluster_allocated_file_size, .bdrv_co_truncate = qemu_gluster_co_truncate, .bdrv_co_readv = qemu_gluster_co_readv, .bdrv_co_writev = qemu_gluster_co_writev,
@@ -1619,8 +1619,8 @@ static BlockDriver bdrv_gluster_unix = { .bdrv_close = qemu_gluster_close, .bdrv_co_create = qemu_gluster_co_create, .bdrv_co_create_opts = qemu_gluster_co_create_opts, - .bdrv_getlength = qemu_gluster_getlength, - .bdrv_get_allocated_file_size = qemu_gluster_allocated_file_size, + .bdrv_co_getlength = qemu_gluster_getlength, + .bdrv_co_get_allocated_file_size = qemu_gluster_allocated_file_size, .bdrv_co_truncate = qemu_gluster_co_truncate, .bdrv_co_readv = qemu_gluster_co_readv, .bdrv_co_writev = qemu_gluster_co_writev,
@@ -1654,8 +1654,8 @@ static BlockDriver bdrv_gluster_rdma = { .bdrv_close = qemu_gluster_close, .bdrv_co_create = qemu_gluster_co_create, .bdrv_co_create_opts = qemu_gluster_co_create_opts, - .bdrv_getlength = qemu_gluster_getlength, - .bdrv_get_allocated_file_size = qemu_gluster_allocated_file_size, + .bdrv_co_getlength = qemu_gluster_getlength, + .bdrv_co_get_allocated_file_size = qemu_gluster_allocated_file_size, .bdrv_co_truncate = qemu_gluster_co_truncate, .bdrv_co_readv = qemu_gluster_co_readv, .bdrv_co_writev = qemu_gluster_co_writev,
block/io.c +8 -8
@@ -2710,8 +2710,8 @@ bdrv_co_readv_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos)bdrv_inc_in_flight (bs); -if (drv->bdrv_load_vmstate) { - ret = drv->bdrv_load_vmstate (bs, qiov, pos); +if (drv->bdrv_co_load_vmstate) { + ret = drv->bdrv_co_load_vmstate (bs, qiov, pos); }else if (child_bs) { ret =bdrv_co_readv_vmstate (child_bs, qiov, pos); }else {
@@ -2743,8 +2743,8 @@ bdrv_co_writev_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos)bdrv_inc_in_flight (bs); -if (drv->bdrv_save_vmstate) { - ret = drv->bdrv_save_vmstate (bs, qiov, pos); +if (drv->bdrv_co_save_vmstate) { + ret = drv->bdrv_co_save_vmstate (bs, qiov, pos); }else if (child_bs) { ret =bdrv_co_writev_vmstate (child_bs, qiov, pos); }else {
@@ -3138,8 +3138,8 @@ void coroutine_fn bdrv_co_io_plug(BlockDriverState *bs)if (qatomic_fetch_inc (&bs->io_plugged) ==0 ) {BlockDriver *drv = bs->drv; -if (drv && drv->bdrv_io_plug) { - drv->bdrv_io_plug (bs); +if (drv && drv->bdrv_co_io_plug) { + drv->bdrv_co_io_plug (bs); } } }
@@ -3152,8 +3152,8 @@ void coroutine_fn bdrv_co_io_unplug(BlockDriverState *bs)assert (bs->io_plugged);if (qatomic_fetch_dec (&bs->io_plugged) ==1 ) {BlockDriver *drv = bs->drv; -if (drv && drv->bdrv_io_unplug) { - drv->bdrv_io_unplug (bs); +if (drv && drv->bdrv_co_io_unplug) { + drv->bdrv_co_io_unplug (bs); } }
block/iscsi.c +4 -4
@@ -2433,8 +2433,8 @@ static BlockDriver bdrv_iscsi = { .bdrv_reopen_commit = iscsi_reopen_commit, .bdrv_co_invalidate_cache = iscsi_co_invalidate_cache, - .bdrv_getlength = iscsi_getlength, - .bdrv_get_info = iscsi_get_info, + .bdrv_co_getlength = iscsi_getlength, + .bdrv_co_get_info = iscsi_get_info, .bdrv_co_truncate = iscsi_co_truncate, .bdrv_refresh_limits = iscsi_refresh_limits,
@@ -2472,8 +2472,8 @@ static BlockDriver bdrv_iser = { .bdrv_reopen_commit = iscsi_reopen_commit, .bdrv_co_invalidate_cache = iscsi_co_invalidate_cache, - .bdrv_getlength = iscsi_getlength, - .bdrv_get_info = iscsi_get_info, + .bdrv_co_getlength = iscsi_getlength, + .bdrv_co_get_info = iscsi_get_info, .bdrv_co_truncate = iscsi_co_truncate, .bdrv_refresh_limits = iscsi_refresh_limits,
block/nbd.c +3 -3
@@ -2124,7 +2124,7 @@ static BlockDriver bdrv_nbd = { .bdrv_co_pdiscard = nbd_client_co_pdiscard, .bdrv_refresh_limits = nbd_refresh_limits, .bdrv_co_truncate = nbd_co_truncate, - .bdrv_getlength = nbd_getlength, + .bdrv_co_getlength = nbd_getlength, .bdrv_refresh_filename = nbd_refresh_filename, .bdrv_co_block_status = nbd_client_co_block_status, .bdrv_dirname = nbd_dirname,
@@ -2152,7 +2152,7 @@ static BlockDriver bdrv_nbd_tcp = { .bdrv_co_pdiscard = nbd_client_co_pdiscard, .bdrv_refresh_limits = nbd_refresh_limits, .bdrv_co_truncate = nbd_co_truncate, - .bdrv_getlength = nbd_getlength, + .bdrv_co_getlength = nbd_getlength, .bdrv_refresh_filename = nbd_refresh_filename, .bdrv_co_block_status = nbd_client_co_block_status, .bdrv_dirname = nbd_dirname,
@@ -2180,7 +2180,7 @@ static BlockDriver bdrv_nbd_unix = { .bdrv_co_pdiscard = nbd_client_co_pdiscard, .bdrv_refresh_limits = nbd_refresh_limits, .bdrv_co_truncate = nbd_co_truncate, - .bdrv_getlength = nbd_getlength, + .bdrv_co_getlength = nbd_getlength, .bdrv_refresh_filename = nbd_refresh_filename, .bdrv_co_block_status = nbd_client_co_block_status, .bdrv_dirname = nbd_dirname,
block/nfs.c +1 -1
@@ -884,7 +884,7 @@ static BlockDriver bdrv_nfs = { .bdrv_has_zero_init = nfs_has_zero_init,/* libnfs does not provide the allocated filesize of a file on win32. */ #if !defined(_WIN32) - .bdrv_get_allocated_file_size = nfs_get_allocated_file_size, + .bdrv_co_get_allocated_file_size = nfs_get_allocated_file_size, #endif .bdrv_co_truncate = nfs_file_co_truncate,
block/null.c +4 -4
@@ -283,8 +283,8 @@ static BlockDriver bdrv_null_co = { .bdrv_file_open = null_file_open, .bdrv_parse_filename = null_co_parse_filename, - .bdrv_getlength = null_getlength, - .bdrv_get_allocated_file_size = null_allocated_file_size, + .bdrv_co_getlength = null_getlength, + .bdrv_co_get_allocated_file_size = null_allocated_file_size, .bdrv_co_preadv = null_co_preadv, .bdrv_co_pwritev = null_co_pwritev,
@@ -304,8 +304,8 @@ static BlockDriver bdrv_null_aio = { .bdrv_file_open = null_file_open, .bdrv_parse_filename = null_aio_parse_filename, - .bdrv_getlength = null_getlength, - .bdrv_get_allocated_file_size = null_allocated_file_size, + .bdrv_co_getlength = null_getlength, + .bdrv_co_get_allocated_file_size = null_allocated_file_size, .bdrv_aio_preadv = null_aio_preadv, .bdrv_aio_pwritev = null_aio_pwritev,
block/nvme.c +3 -3
@@ -1642,7 +1642,7 @@ static BlockDriver bdrv_nvme = { .bdrv_parse_filename = nvme_parse_filename, .bdrv_file_open = nvme_file_open, .bdrv_close = nvme_close, - .bdrv_getlength = nvme_getlength, + .bdrv_co_getlength = nvme_getlength, .bdrv_probe_blocksizes = nvme_probe_blocksizes, .bdrv_co_truncate = nvme_co_truncate,
@@ -1663,8 +1663,8 @@ static BlockDriver bdrv_nvme = { .bdrv_detach_aio_context = nvme_detach_aio_context, .bdrv_attach_aio_context = nvme_attach_aio_context, - .bdrv_io_plug = nvme_aio_plug, - .bdrv_io_unplug = nvme_aio_unplug, + .bdrv_co_io_plug = nvme_aio_plug, + .bdrv_co_io_unplug = nvme_aio_unplug, .bdrv_register_buf = nvme_register_buf, .bdrv_unregister_buf = nvme_unregister_buf,
block/preallocate.c +1 -1
@@ -536,7 +536,7 @@ BlockDriver bdrv_preallocate_filter = { .format_name = "preallocate", .instance_size = sizeof(BDRVPreallocateState), - .bdrv_getlength = preallocate_getlength, + .bdrv_co_getlength = preallocate_getlength, .bdrv_open = preallocate_open, .bdrv_close = preallocate_close,
block/qcow.c +1 -1
@@ -1198,7 +1198,7 @@ static BlockDriver bdrv_qcow = { .bdrv_make_empty = qcow_make_empty, .bdrv_co_pwritev_compressed = qcow_co_pwritev_compressed, - .bdrv_get_info = qcow_get_info, + .bdrv_co_get_info = qcow_get_info, .create_opts = &qcow_create_opts, .strong_runtime_opts = qcow_strong_runtime_opts,
block/qcow2.c +3 -3
@@ -6078,11 +6078,11 @@ BlockDriver bdrv_qcow2 = { .bdrv_snapshot_list = qcow2_snapshot_list, .bdrv_snapshot_load_tmp = qcow2_snapshot_load_tmp, .bdrv_measure = qcow2_measure, - .bdrv_get_info = qcow2_get_info, + .bdrv_co_get_info = qcow2_get_info, .bdrv_get_specific_info = qcow2_get_specific_info, - .bdrv_save_vmstate = qcow2_save_vmstate, - .bdrv_load_vmstate = qcow2_load_vmstate, + .bdrv_co_save_vmstate = qcow2_save_vmstate, + .bdrv_co_load_vmstate = qcow2_load_vmstate, .is_format = true, .supports_backing = true,
block/qed.c +2 -2
@@ -1653,8 +1653,8 @@ static BlockDriver bdrv_qed = { .bdrv_co_writev = bdrv_qed_co_writev, .bdrv_co_pwrite_zeroes = bdrv_qed_co_pwrite_zeroes, .bdrv_co_truncate = bdrv_qed_co_truncate, - .bdrv_getlength = bdrv_qed_getlength, - .bdrv_get_info = bdrv_qed_get_info, + .bdrv_co_getlength = bdrv_qed_getlength, + .bdrv_co_get_info = bdrv_qed_get_info, .bdrv_refresh_limits = bdrv_qed_refresh_limits, .bdrv_change_backing_file = bdrv_qed_change_backing_file, .bdrv_co_invalidate_cache = bdrv_qed_co_invalidate_cache,
block/quorum.c +1 -1
@@ -1283,7 +1283,7 @@ static BlockDriver bdrv_quorum = { .bdrv_co_flush = quorum_co_flush, - .bdrv_getlength = quorum_getlength, + .bdrv_co_getlength = quorum_getlength, .bdrv_co_preadv = quorum_co_preadv, .bdrv_co_pwritev = quorum_co_pwritev,
block/raw-format.c +4 -4
@@ -621,16 +621,16 @@ BlockDriver bdrv_raw = { .bdrv_co_copy_range_from = &raw_co_copy_range_from, .bdrv_co_copy_range_to = &raw_co_copy_range_to, .bdrv_co_truncate = &raw_co_truncate, - .bdrv_getlength = &raw_getlength, + .bdrv_co_getlength = &raw_getlength, .is_format = true, .has_variable_length = true, .bdrv_measure = &raw_measure, - .bdrv_get_info = &raw_get_info, + .bdrv_co_get_info = &raw_get_info, .bdrv_refresh_limits = &raw_refresh_limits, .bdrv_probe_blocksizes = &raw_probe_blocksizes, .bdrv_probe_geometry = &raw_probe_geometry, - .bdrv_eject = &raw_eject, - .bdrv_lock_medium = &raw_lock_medium, + .bdrv_co_eject = &raw_eject, + .bdrv_co_lock_medium = &raw_lock_medium, .bdrv_co_ioctl = &raw_co_ioctl, .create_opts = &raw_create_opts, .bdrv_has_zero_init = &raw_has_zero_init,
block/rbd.c +2 -2
@@ -1655,10 +1655,10 @@ static BlockDriver bdrv_rbd = { .bdrv_co_create = qemu_rbd_co_create, .bdrv_co_create_opts = qemu_rbd_co_create_opts, .bdrv_has_zero_init = bdrv_has_zero_init_1, - .bdrv_get_info = qemu_rbd_getinfo, + .bdrv_co_get_info = qemu_rbd_getinfo, .bdrv_get_specific_info = qemu_rbd_get_specific_info, .create_opts = &qemu_rbd_create_opts, - .bdrv_getlength = qemu_rbd_getlength, + .bdrv_co_getlength = qemu_rbd_getlength, .bdrv_co_truncate = qemu_rbd_co_truncate, .protocol_name = "rbd",
block/replication.c +1 -1
@@ -758,7 +758,7 @@ static BlockDriver bdrv_replication = { .bdrv_close = replication_close, .bdrv_child_perm = replication_child_perm, - .bdrv_getlength = replication_getlength, + .bdrv_co_getlength = replication_getlength, .bdrv_co_readv = replication_co_readv, .bdrv_co_writev = replication_co_writev,
block/ssh.c +1 -1
@@ -1363,7 +1363,7 @@ static BlockDriver bdrv_ssh = { .bdrv_has_zero_init = ssh_has_zero_init, .bdrv_co_readv = ssh_co_readv, .bdrv_co_writev = ssh_co_writev, - .bdrv_getlength = ssh_getlength, + .bdrv_co_getlength = ssh_getlength, .bdrv_co_truncate = ssh_co_truncate, .bdrv_co_flush_to_disk = ssh_co_flush, .bdrv_refresh_filename = ssh_refresh_filename,
block/throttle.c +1 -1
@@ -245,7 +245,7 @@ static BlockDriver bdrv_throttle = { .bdrv_child_perm = bdrv_default_perms, - .bdrv_getlength = throttle_getlength, + .bdrv_co_getlength = throttle_getlength, .bdrv_co_preadv = throttle_co_preadv, .bdrv_co_pwritev = throttle_co_pwritev,
block/vdi.c +1 -1
@@ -1049,7 +1049,7 @@ static BlockDriver bdrv_vdi = { .bdrv_co_pwritev = vdi_co_pwritev, #endif - .bdrv_get_info = vdi_get_info, + .bdrv_co_get_info = vdi_get_info, .is_format = true, .create_opts = &vdi_create_opts,
block/vhdx.c +1 -1
@@ -2245,7 +2245,7 @@ static BlockDriver bdrv_vhdx = { .bdrv_co_writev = vhdx_co_writev, .bdrv_co_create = vhdx_co_create, .bdrv_co_create_opts = vhdx_co_create_opts, - .bdrv_get_info = vhdx_get_info, + .bdrv_co_get_info = vhdx_get_info, .bdrv_co_check = vhdx_co_check, .bdrv_has_zero_init = vhdx_has_zero_init,
block/vmdk.c +2 -2
@@ -3130,11 +3130,11 @@ static BlockDriver bdrv_vmdk = { .bdrv_co_create_opts = vmdk_co_create_opts, .bdrv_co_create = vmdk_co_create, .bdrv_co_block_status = vmdk_co_block_status, - .bdrv_get_allocated_file_size = vmdk_get_allocated_file_size, + .bdrv_co_get_allocated_file_size = vmdk_get_allocated_file_size, .bdrv_has_zero_init = vmdk_has_zero_init, .bdrv_get_specific_info = vmdk_get_specific_info, .bdrv_refresh_limits = vmdk_refresh_limits, - .bdrv_get_info = vmdk_get_info, + .bdrv_co_get_info = vmdk_get_info, .bdrv_gather_child_options = vmdk_gather_child_options, .is_format = true,
block/vpc.c +1 -1
@@ -1240,7 +1240,7 @@ static BlockDriver bdrv_vpc = { .bdrv_co_pwritev = vpc_co_pwritev, .bdrv_co_block_status = vpc_co_block_status, - .bdrv_get_info = vpc_get_info, + .bdrv_co_get_info = vpc_get_info, .is_format = true, .create_opts = &vpc_create_opts,
Signature · 1 line
2.38.1
Re: [PATCH 14/14] block: Rename newly converted BlockDriver IO coroutine functions
block/blkdebug.c static BlockDriver bdrv_blkdebug = { · line 1079
Quoted 10 lines · Kevin Wolf
block/blkdebug.c +1
-1@@ -1076,7 +1076,7 @@ static BlockDriver bdrv_blkdebug = { .bdrv_reopen_prepare = blkdebug_reopen_prepare, .bdrv_child_perm = blkdebug_child_perm, - .bdrv_getlength = blkdebug_getlength, + .bdrv_co_getlength = blkdebug_getlength,
To follow usual practice, we should also rename blkdebug_getlength, IMHO
Signature · 2 lines
Best regards, Vladimir
Am 13/12/2022 um 09:53 schrieb Kevin Wolf:
Quoted 5 lines
This series converts some
IO_CODE()functions tocoroutine_fnbecause they access the graph and will need to hold the graph lock in the future.IO_CODE()functions can be called from iothreads, so taking the graph lock requires the function to run in coroutine context.
Quoted 8 lines
Pretty much all of the changes in this series were posted by Emanuele before as part of "Protect the block layer with a rwlock: part 3". The major difference is that in the old version, the patches did two things at once: Converting functions to
coroutine_fn, and adding the locking to them. This series does only the coroutine conversion. The locking part will be in another series which now comes with TSA annotations and makes the locking related changes big enough to have separate patches.
Quoted 64 lines
Emanuele Giuseppe Esposito (14):
block-coroutine-wrapper: support void functions
block: Convertbdrv_io_plug()toco_wrapper
block: Convertbdrv_io_unplug()toco_wrapper
block: Renamerefresh_total_sectorstobdrv_refresh_total_sectors
block: Convertbdrv_refresh_total_sectors()toco_wrapper_mixed
block-backend: usebdrv_getlengthinstead ofblk_getlength
block: usebdrv_co_refresh_total_sectorswhen possible
block: Convertbdrv_get_allocated_file_size()toco_wrapper
block: Convertbdrv_get_info()toco_wrapper_mixed
block: Convertbdrv_is_inserted()toco_wrapper
block: Convertbdrv_eject()toco_wrapper
block: convertbdrv_lock_mediuminco_wrapper
block: Convertbdrv_debug_eventtoco_wrapper_mixed
block: Rename newly converted BlockDriver IO coroutine functionsinclude/block/block-io.h | 36 +++++++++---- include/block/block_int-common.h | 26 ++++++---- include/block/block_int-io.h | 5 +- include/sysemu/block-backend-io.h | 31 ++++++++--- block.c | 82 ++++++++++++++++++------------ block/blkdebug.c | 4 +- block/blkio.c | 6 +-- block/blklogwrites.c | 2 +- block/blkreplay.c | 2 +- block/blkverify.c | 2 +- block/block-backend.c | 36 ++++++------- block/commit.c | 4 +- block/copy-on-read.c | 12 ++--- block/crypto.c | 6 +-- block/curl.c | 8 +-- block/file-posix.c | 48 ++++++++--------- block/file-win32.c | 12 ++--- block/filter-compress.c | 10 ++-- block/gluster.c | 16 +++--- block/io.c | 76 +++++++++++++-------------- block/iscsi.c | 8 +-- block/mirror.c | 6 +-- block/nbd.c | 6 +-- block/nfs.c | 2 +- block/null.c | 8 +-- block/nvme.c | 6 +-- block/preallocate.c | 2 +- block/qcow.c | 2 +- block/qcow2-refcount.c | 2 +- block/qcow2.c | 6 +-- block/qed.c | 4 +- block/quorum.c | 2 +- block/raw-format.c | 14 ++--- block/rbd.c | 4 +- block/replication.c | 2 +- block/ssh.c | 2 +- block/throttle.c | 2 +- block/vdi.c | 2 +- block/vhdx.c | 2 +- block/vmdk.c | 4 +- block/vpc.c | 2 +- blockdev.c | 8 ++- hw/scsi/scsi-disk.c | 5 ++ tests/unit/test-block-iothread.c | 3 ++ scripts/block-coroutine-wrapper.py | 20 ++++++-- block/meson.build | 1 + 46 files changed, 316 insertions(+), 233 deletions(-)