block: more fixes to coroutine_fn marking
cover block: more fixes to coroutine_fn marking
*** BLURB HERE ***
Paolo Bonzini (12):
file-posix: remove incorrect coroutine_fn calls
qed: mark more functions as coroutine_fns and GRAPH_RDLOCK
vpc: mark more functions as coroutine_fns and GRAPH_RDLOCK
bochs: mark more functions as coroutine_fns and GRAPH_RDLOCK
block: mark another function as coroutine_fns and GRAPH_UNLOCKED
cloop: mark more functions as coroutine_fns and GRAPH_RDLOCK
dmg: mark more functions as coroutine_fns and GRAPH_RDLOCK
vmdk: mark more functions as coroutine_fns and GRAPH_RDLOCK
vhdx: mark more functions as coroutine_fns and GRAPH_RDLOCK
qcow2: mark more functions as coroutine_fns and GRAPH_RDLOCK
block: use bdrv_co_getlength in coroutine context
block: use bdrv_co_debug_event in coroutine context
block.c | 11 ++-- block/bochs.c | 7 +- block/cloop.c | 9 +-- block/dmg.c | 21 +++--- block/file-posix.c | 29 +++++---- block/io.c | 14 ++-- block/parallels.c | 4 +- block/qcow.c | 30 ++++----- block/qcow2-bitmap.c | 26 ++++---- block/qcow2-cluster.c | 24 +++---- block/qcow2-refcount.c | 134 ++++++++++++++++++++------------------- block/qcow2.c | 20 +++--- block/qcow2.h | 33 +++++----- block/qed-check.c | 5 +- block/qed-table.c | 6 +- block/qed.c | 15 +++-- block/raw-format.c | 4 +- block/vhdx-log.c | 36 ++++++----- block/vhdx.c | 73 ++++++++++----------- block/vhdx.h | 5 +- block/vmdk.c | 55 ++++++++-------- block/vpc.c | 52 +++++++-------- include/block/block-io.h | 7 ++ 23 files changed, 323 insertions(+), 297 deletions(-)
Signature · 1 line
2.40.1
PATCH 1/12 file-posix: remove incorrect coroutine_fn calls
raw_co_getlength is called by handle_aiocb_write_zeroes, which is not a coroutine function. This is harmless because raw_co_getlength does not actually suspend, but in the interest of clarity make it a non-coroutine_fn that is just wrapped by the coroutine_fn raw_co_getlength. Likewise, check_cache_dropped was only a coroutine_fn because it called raw_co_getlength, so it can be made non-coroutine as well.
--- block/file-posix.c | 29 +++++++++++++++++------------ 1 file changed, 17 insertions(+), 12 deletions(-)
block/file-posix.c +17 -12
@@ -193,7 +193,7 @@ static int fd_open(BlockDriverState *bs)return -EIO ; } -static int64_t coroutine_fn raw_co_getlength(BlockDriverState *bs); +static int64_t raw_getlength (BlockDriverState *bs); typedef struct RawPosixAIOData { BlockDriverState *bs;
@@ -1974,7 +1974,7 @@ static int handle_aiocb_write_zeroes(void *opaque)#ifdef CONFIG_FALLOCATE /* Last resort: we are trying to extend the file with zeroed data. This * can be done via fallocate(fd, 0) */ - len =raw_co_getlength (aiocb->bs); + len =raw_getlength (aiocb->bs);if (s->has_fallocate && len >=0 && aiocb->aio_offset >= len) {int ret =do_fallocate (s->fd,0 , aiocb->aio_offset, aiocb->aio_nbytes);if (ret ==0 || ret != -ENOTSUP ) {
@@ -2696,7 +2696,7 @@ static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset, }if (S_ISCHR (st.st_mode) ||S_ISBLK (st.st_mode)) { -int64_t cur_length =raw_co_getlength (bs); +int64_t cur_length =raw_getlength (bs);if (offset != cur_length && exact) {error_setg (errp,"Cannot resize device files" );
@@ -2714,7 +2714,7 @@ static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset, }#ifdef __OpenBSD__ -static int64_t coroutine_fn raw_co_getlength(BlockDriverState *bs) +static int64_t raw_getlength (BlockDriverState *bs) {BDRVRawState *s = bs->opaque;int fd = s->fd;
@@ -2733,7 +2733,7 @@ static int64_t coroutine_fn raw_co_getlength(BlockDriverState *bs) return st.st_size; }#elif defined(__NetBSD__) -static int64_t coroutine_fn raw_co_getlength(BlockDriverState *bs) +static int64_t raw_getlength (BlockDriverState *bs) {BDRVRawState *s = bs->opaque;int fd = s->fd;
@@ -2758,7 +2758,7 @@ static int64_t coroutine_fn raw_co_getlength(BlockDriverState *bs) return st.st_size; }#elif defined(__sun__) -static int64_t coroutine_fn raw_co_getlength(BlockDriverState *bs) +static int64_t raw_getlength (BlockDriverState *bs) {BDRVRawState *s = bs->opaque;struct dk_minfo minfo;
@@ -2789,7 +2789,7 @@ static int64_t coroutine_fn raw_co_getlength(BlockDriverState *bs) return size; }#elif defined(CONFIG_BSD) -static int64_t coroutine_fn raw_co_getlength(BlockDriverState *bs) +static int64_t raw_getlength (BlockDriverState *bs) {BDRVRawState *s = bs->opaque;int fd = s->fd;
@@ -2861,7 +2861,7 @@ again: return size; }#else -static int64_t coroutine_fn raw_co_getlength(BlockDriverState *bs) +static int64_t raw_getlength (BlockDriverState *bs) {BDRVRawState *s = bs->opaque;int ret;
@@ -2880,6 +2880,11 @@ static int64_t coroutine_fn raw_co_getlength(BlockDriverState *bs) }#endif +static int64_t coroutine_fn raw_co_getlength(BlockDriverState *bs) +{ +return raw_getlength (bs); +} + static int64_t coroutine_fn raw_co_get_allocated_file_size(BlockDriverState *bs) {struct stat st;
@@ -3245,7 +3250,7 @@ static int coroutine_fn raw_co_block_status(BlockDriverState *bs,* round up if necessary. */ if (!QEMU_IS_ALIGNED (*pnum, bs->bl.request_alignment)) { -int64_t file_length =raw_co_getlength (bs); +int64_t file_length =raw_getlength (bs);if (file_length >0 ) {/* Ignore errors, this is just a safeguard */ assert (hole == file_length);
@@ -3267,7 +3272,7 @@ static int coroutine_fn raw_co_block_status(BlockDriverState *bs,#if defined(__linux__)/* Verify that the file is not in the page cache */ -static void coroutine_fn check_cache_dropped(BlockDriverState *bs, Error **errp) +static void check_cache_dropped (BlockDriverState *bs,Error **errp) {const size_t window_size =128 *1024 *1024 ;BDRVRawState *s = bs->opaque;
@@ -3282,7 +3287,7 @@ static void coroutine_fn check_cache_dropped(BlockDriverState *bs, Error **errp) page_size =sysconf (_SC_PAGESIZE); vec =g_malloc (DIV_ROUND_UP (window_size, page_size)); - end =raw_co_getlength (bs); + end =raw_getlength (bs);for (offset =0 ; offset < end; offset += window_size) {void *new_window;
@@ -4504,7 +4509,7 @@ static int cdrom_reopen(BlockDriverState *bs) static bool coroutine_fn cdrom_co_is_inserted(BlockDriverState *bs) { -return raw_co_getlength (bs) >0 ; +return raw_getlength (bs) >0 ; } static void coroutine_fn cdrom_co_eject(BlockDriverState *bs, bool eject_flag)
Signature · 1 line
2.40.1
Re: [PATCH 01/12] file-posix: remove incorrect coroutine_fn calls
Quoted 14 lines · Paolo Bonzini
raw_co_getlengthis called byhandle_aiocb_write_zeroes, which is not a coroutine function. This is harmless becauseraw_co_getlengthdoes not actually suspend, but in the interest of clarity make it a non-coroutine_fn that is just wrapped by thecoroutine_fnraw_co_getlength. Likewise,check_cache_droppedwas only acoroutine_fnbecause it calledraw_co_getlength, so it can be made non-coroutine as well.Signed-off-by Paolo Bonzini <[email protected]>--- block/file-posix.c | 29 +++++++++++++++++------------ 1 file changed, 17 insertions(+), 12 deletions(-)
block/file-posix.c static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset, · line 2699
Quoted 5 lines
block/file-posix.c +1
-1@@ -2696,7 +2696,7 @@ static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset, }if (S_ISCHR (st.st_mode) ||S_ISBLK (st.st_mode)) { -int64_t cur_length =raw_co_getlength (bs); +int64_t cur_length =raw_getlength (bs);
Shouldn't this one still call the raw_co_getlength() wrapper?
block/file-posix.c static int coroutine_fn raw_co_block_status(BlockDriverState *bs, · line 3253
Quoted 6 lines
block/file-posix.c +1
-1@@ -3245,7 +3250,7 @@ static int coroutine_fn raw_co_block_status(BlockDriverState *bs,* round up if necessary. */ if (!QEMU_IS_ALIGNED (*pnum, bs->bl.request_alignment)) { -int64_t file_length =raw_co_getlength (bs); +int64_t file_length =raw_getlength (bs);
Likewise this one?
Quoted 6 lines
block/file-posix.c +1
-1static bool coroutine_fn cdrom_co_is_inserted(BlockDriverState *bs) { -return raw_co_getlength (bs) >0 ; +return raw_getlength (bs) >0 ;}
and this one?
Signature · 3 lines
Eric Blake, Principal Software Engineer Red Hat, Inc. +1-919-301-3266 Virtualization: qemu.org | libvirt.org
Re: [PATCH 01/12] file-posix: remove incorrect coroutine_fn calls
Il gio 1 giu 2023, 15:50 Eric Blake <[email protected]> ha scritto:
Quoted 10 lines
Review static int coroutine_fn
Quoted 1 line
(quoted diff) +0
-0@@ -2696,7 +2696,7 @@ static int coroutine_fnraw_co_truncate(BlockDriverState *bs,
int64_toffset,block/file-posix.c static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset, · line 2699
Quoted 5 lines
block/file-posix.c +1
-1}if (S_ISCHR (st.st_mode) ||S_ISBLK (st.st_mode)) { -int64_t cur_length =raw_co_getlength (bs); +int64_t cur_length =raw_getlength (bs);Shouldn't this one still call the
raw_co_getlength()wrapper?
It could, but instead I wanted to clarify that this will never suspend (because it's calling the function directly rather than bdrv_co_getlength).
Paolo
Quoted 25 lines
Review static int coroutine_fn
Quoted 1 line
(quoted diff) +0
-0@@ -3245,7 +3250,7 @@ static int coroutine_fnraw_co_block_status(BlockDriverState *bs,
block/file-posix.c static int coroutine_fn raw_co_block_status(BlockDriverState *bs, · line 3253
Quoted 5 lines
block/file-posix.c +1
-1* round up if necessary. */ if (!QEMU_IS_ALIGNED (*pnum, bs->bl.request_alignment)) { -int64_t file_length =raw_co_getlength (bs); +int64_t file_length =raw_getlength (bs);Likewise this one?
Quoted 6 lines
block/file-posix.c +1
-1static bool coroutine_fn cdrom_co_is_inserted(BlockDriverState *bs) { -return raw_co_getlength (bs) >0 ; +return raw_getlength (bs) >0 ;}
and this one?
--
Eric Blake, Principal Software Engineer
Red Hat, Inc. +1-919-301-3266
Virtualization: qemu.org | libvirt.org
PATCH 2/12 qed: mark more functions as coroutine_fns and GRAPH_RDLOCK
In reply to Paolo BonziniMark functions as coroutine_fn when they are only called by other coroutine_fns and they can suspend. Change calls to co_wrappers to use the non-wrapped functions, which in turn requires adding GRAPH_RDLOCK annotations.
--- block/qed-check.c | 5 +++-- block/qed.c | 7 ++++--- 2 files changed, 7 insertions(+), 5 deletions(-)
block/qed-check.c +3 -2
@@ -200,7 +200,8 @@ static void qed_check_for_leaks(QEDCheck *check)/** * Mark an image clean once it passes check or has been repaired */ -static void qed_check_mark_clean (BDRVQEDState *s,BdrvCheckResult *result) +static void coroutine_fn GRAPH_RDLOCK +qed_check_mark_clean (BDRVQEDState *s,BdrvCheckResult *result) {/* Skip if there were unfixable corruptions or I/O errors */ if (result->corruptions >0 || result->check_errors >0 ) {
@@ -213,7 +214,7 @@ static void qed_check_mark_clean(BDRVQEDState *s, BdrvCheckResult *result) }/* Ensure fixes reach storage before clearing check bit */ -bdrv_flush (s->bs); +bdrv_co_flush (s->bs); s->header.features &= ~QED_F_NEED_CHECK ;qed_write_header_sync (s);
block/qed.c +4 -3
@@ -195,14 +195,15 @@ static bool qed_is_image_size_valid(uint64_t image_size, uint32_t cluster_size,* * The string is NUL-terminated. */ -static int qed_read_string (BdrvChild *file,uint64_t offset,size_t n, -char *buf,size_t buflen) +static int coroutine_fn GRAPH_RDLOCK +qed_read_string (BdrvChild *file,uint64_t offset, +size_t n,char *buf,size_t buflen) {int ret;if (n >= buflen) {return -EINVAL ; } - ret =bdrv_pread (file, offset, n, buf,0 ); + ret =bdrv_co_pread (file, offset, n, buf,0 );if (ret <0 ) {return ret; }
Signature · 1 line
2.40.1
PATCH 3/12 vpc: mark more functions as coroutine_fns and GRAPH_RDLOCK
In reply to Paolo BonziniMark functions as coroutine_fn when they are only called by other coroutine_fns and they can suspend. Change calls to co_wrappers to use the non-wrapped functions, which in turn requires adding GRAPH_RDLOCK annotations.
--- block/vpc.c | 52 ++++++++++++++++++++++++++-------------------------- 1 file changed, 26 insertions(+), 26 deletions(-)
block/vpc.c +26 -26
@@ -486,8 +486,8 @@ static int vpc_reopen_prepare(BDRVReopenState *state,* operation (the block bitmaps is updated then), 0 otherwise. * If write is true then err must not be NULL. */ -static inline int64_t get_image_offset (BlockDriverState *bs,uint64_t offset, -bool write,int *err) +static int64_t coroutine_fn GRAPH_RDLOCK +get_image_offset (BlockDriverState *bs,uint64_t offset,bool write,int *err) {BDRVVPCState *s = bs->opaque;uint64_t bitmap_offset, block_offset;
@@ -515,8 +515,7 @@ static inline int64_t get_image_offset(BlockDriverState *bs, uint64_t offset, s->last_bitmap_offset = bitmap_offset;memset (bitmap,0xff , s->bitmap_size); - r =bdrv_pwrite_sync (bs->file, bitmap_offset, s->bitmap_size, bitmap, -0 ); + r =bdrv_co_pwrite_sync (bs->file, bitmap_offset, s->bitmap_size, bitmap,0 );if (r <0 ) { *err = r;return -2 ;
@@ -532,13 +531,13 @@ static inline int64_t get_image_offset(BlockDriverState *bs, uint64_t offset,* * Returns 0 on success and < 0 on error */ -static int rewrite_footer (BlockDriverState *bs) +static int coroutine_fn GRAPH_RDLOCK rewrite_footer(BlockDriverState *bs) {int ret;BDRVVPCState *s = bs->opaque;int64_t offset = s->free_data_block_offset; - ret =bdrv_pwrite_sync (bs->file, offset,sizeof (s->footer), &s->footer,0 ); + ret =bdrv_co_pwrite_sync (bs->file, offset,sizeof (s->footer), &s->footer,0 );if (ret <0 )return ret;
@@ -552,7 +551,8 @@ static int rewrite_footer(BlockDriverState *bs)* * Returns the sectors' offset in the image file on success and < 0 on error */ -static int64_t alloc_block (BlockDriverState *bs,int64_t offset) +static int64_t coroutine_fn GRAPH_RDLOCK +alloc_block (BlockDriverState *bs,int64_t offset) {BDRVVPCState *s = bs->opaque;int64_t bat_offset;
@@ -572,8 +572,8 @@ static int64_t alloc_block(BlockDriverState *bs, int64_t offset)/* Initialize the block's bitmap */ memset (bitmap,0xff , s->bitmap_size); - ret =bdrv_pwrite_sync (bs->file, s->free_data_block_offset, - s->bitmap_size, bitmap,0 ); + ret =bdrv_co_pwrite_sync (bs->file, s->free_data_block_offset, + s->bitmap_size, bitmap,0 );if (ret <0 ) {return ret; }
@@ -587,7 +587,7 @@ static int64_t alloc_block(BlockDriverState *bs, int64_t offset)/* Write BAT entry to disk */ bat_offset = s->bat_offset + (4 * index); bat_value =cpu_to_be32 (s->pagetable[index]); - ret =bdrv_pwrite_sync (bs->file, bat_offset,4 , &bat_value,0 ); + ret =bdrv_co_pwrite_sync (bs->file, bat_offset,4 , &bat_value,0 );if (ret <0 ) goto fail;
@@ -718,11 +718,11 @@ fail:return ret; } -static int coroutine_fn vpc_co_block_status(BlockDriverState *bs, -bool want_zero, -int64_t offset,int64_t bytes, -int64_t *pnum,int64_t *map, -BlockDriverState **file) +static int coroutine_fn GRAPH_RDLOCK +vpc_co_block_status (BlockDriverState *bs,bool want_zero, +int64_t offset,int64_t bytes, +int64_t *pnum,int64_t *map, +BlockDriverState **file) {BDRVVPCState *s = bs->opaque;int64_t image_offset;
@@ -820,8 +820,8 @@ static int calculate_geometry(int64_t total_sectors, uint16_t *cyls,return 0 ; } -static int create_dynamic_disk (BlockBackend *blk,VHDFooter *footer, -int64_t total_sectors) +static int coroutine_fn create_dynamic_disk(BlockBackend *blk, VHDFooter *footer, +int64_t total_sectors) {VHDDynDiskHeader dyndisk_header;uint8_t bat_sector[512 ];
@@ -834,13 +834,13 @@ static int create_dynamic_disk(BlockBackend *blk, VHDFooter *footer, block_size =0x200000 ; num_bat_entries =DIV_ROUND_UP (total_sectors, block_size /512 ); - ret =blk_pwrite (blk, offset,sizeof (*footer), footer,0 ); + ret =blk_co_pwrite (blk, offset,sizeof (*footer), footer,0 );if (ret <0 ) { goto fail; } offset =1536 + ((num_bat_entries *4 +511 ) & ~511 ); - ret =blk_pwrite (blk, offset,sizeof (*footer), footer,0 ); + ret =blk_co_pwrite (blk, offset,sizeof (*footer), footer,0 );if (ret <0 ) { goto fail; }
@@ -850,7 +850,7 @@ static int create_dynamic_disk(BlockBackend *blk, VHDFooter *footer,memset (bat_sector,0xFF ,512 );for (i =0 ; i <DIV_ROUND_UP (num_bat_entries *4 ,512 ); i++) { - ret =blk_pwrite (blk, offset,512 , bat_sector,0 ); + ret =blk_co_pwrite (blk, offset,512 , bat_sector,0 );if (ret <0 ) { goto fail; }
@@ -878,7 +878,7 @@ static int create_dynamic_disk(BlockBackend *blk, VHDFooter *footer,/* Write the header */ offset =512 ; - ret =blk_pwrite (blk, offset,sizeof (dyndisk_header), &dyndisk_header,0 ); + ret =blk_co_pwrite (blk, offset,sizeof (dyndisk_header), &dyndisk_header,0 );if (ret <0 ) { goto fail; }
@@ -888,21 +888,21 @@ static int create_dynamic_disk(BlockBackend *blk, VHDFooter *footer,return ret; } -static int create_fixed_disk (BlockBackend *blk,VHDFooter *footer, -int64_t total_size,Error **errp) +static int coroutine_fn create_fixed_disk(BlockBackend *blk, VHDFooter *footer, +int64_t total_size,Error **errp) {int ret;/* Add footer to total size */ total_size +=sizeof (*footer); - ret =blk_truncate (blk, total_size, false,PREALLOC_MODE_OFF ,0 , errp); + ret =blk_co_truncate (blk, total_size, false,PREALLOC_MODE_OFF ,0 , errp);if (ret <0 ) {return ret; } - ret =blk_pwrite (blk, total_size -sizeof (*footer),sizeof (*footer), - footer,0 ); + ret =blk_co_pwrite (blk, total_size -sizeof (*footer),sizeof (*footer), + footer,0 );if (ret <0 ) {error_setg_errno (errp, -ret,"Unable to write VHD header" );return ret;
Signature · 1 line
2.40.1
PATCH 4/12 bochs: mark more functions as coroutine_fns and GRAPH_RDLOCK
In reply to Paolo BonziniMark functions as coroutine_fn when they are only called by other coroutine_fns and they can suspend. Change calls to co_wrappers to use the non-wrapped functions, which in turn requires adding GRAPH_RDLOCK annotations.
--- block/bochs.c | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-)
block/bochs.c +4 -3
@@ -203,7 +203,8 @@ static void bochs_refresh_limits(BlockDriverState *bs, Error **errp) bs->bl.request_alignment =BDRV_SECTOR_SIZE ;/* No sub-sector I/O */ } -static int64_t seek_to_sector (BlockDriverState *bs,int64_t sector_num) +static int64_t coroutine_fn GRAPH_RDLOCK +seek_to_sector (BlockDriverState *bs,int64_t sector_num) {BDRVBochsState *s = bs->opaque;uint64_t offset = sector_num *512 ;
@@ -224,8 +225,8 @@ static int64_t seek_to_sector(BlockDriverState *bs, int64_t sector_num) (s->extent_blocks + s->bitmap_blocks));/* read in bitmap for current extent */ - ret =bdrv_pread (bs->file, bitmap_offset + (extent_offset /8 ),1 , - &bitmap_entry,0 ); + ret =bdrv_co_pread (bs->file, bitmap_offset + (extent_offset /8 ),1 , + &bitmap_entry,0 );if (ret <0 ) {return ret; }
Signature · 1 line
2.40.1
PATCH 5/12 block: mark another function as coroutine_fns and GRAPH_UNLOCKED
In reply to Paolo BonziniMark functions as coroutine_fn when they are only called by other coroutine_fns and they can suspend. Because this function operates on a BlockBackend, mark it GRAPH_UNLOCKED.
--- block.c | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-)
block.c +6 -5
@@ -555,8 +555,9 @@ int coroutine_fn bdrv_co_create(BlockDriver *drv, const char *filename,* On success, return @blk's actual length. * Otherwise, return -errno. */ -static int64_t create_file_fallback_truncate (BlockBackend *blk, -int64_t minimum_size,Error **errp) +static int64_t coroutine_fn GRAPH_UNLOCKED +create_file_fallback_truncate (BlockBackend *blk,int64_t minimum_size, +Error **errp) {Error *local_err =NULL ;int64_t size;
@@ -564,14 +565,14 @@ static int64_t create_file_fallback_truncate(BlockBackend *blk,GLOBAL_STATE_CODE (); - ret =blk_truncate (blk, minimum_size, false,PREALLOC_MODE_OFF ,0 , - &local_err); + ret =blk_co_truncate (blk, minimum_size, false,PREALLOC_MODE_OFF ,0 , + &local_err);if (ret <0 && ret != -ENOTSUP ) {error_propagate (errp, local_err);return ret; } - size =blk_getlength (blk); + size =blk_co_getlength (blk);if (size <0 ) {error_free (local_err); error_setg_errno(errp, -size,
Signature · 1 line
2.40.1
PATCH 6/12 cloop: mark more functions as coroutine_fns and GRAPH_RDLOCK
In reply to Paolo BonziniMark functions as coroutine_fn when they are only called by other coroutine_fns and they can suspend. Change calls to co_wrappers to use the non-wrapped functions, which in turn requires adding GRAPH_RDLOCK annotations.
--- block/cloop.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-)
block/cloop.c +5 -4
@@ -212,7 +212,8 @@ static void cloop_refresh_limits(BlockDriverState *bs, Error **errp) bs->bl.request_alignment =BDRV_SECTOR_SIZE ;/* No sub-sector I/O */ } -static inline int cloop_read_block (BlockDriverState *bs,int block_num) +static int coroutine_fn GRAPH_RDLOCK +cloop_read_block (BlockDriverState *bs,int block_num) {BDRVCloopState *s = bs->opaque;
@@ -220,8 +221,8 @@ static inline int cloop_read_block(BlockDriverState *bs, int block_num)int ret;uint32_t bytes = s->offsets[block_num +1 ] - s->offsets[block_num]; - ret =bdrv_pread (bs->file, s->offsets[block_num], bytes, - s->compressed_block,0 ); + ret =bdrv_co_pread (bs->file, s->offsets[block_num], bytes, + s->compressed_block,0 );if (ret <0 ) {return -1 ; }
@@ -244,7 +245,7 @@ static inline int cloop_read_block(BlockDriverState *bs, int block_num)return 0 ; } -static int coroutine_fn +static int coroutine_fn GRAPH_RDLOCKcloop_co_preadv (BlockDriverState *bs,int64_t offset,int64_t bytes,QEMUIOVector *qiov,BdrvRequestFlags flags) {
Signature · 1 line
2.40.1
PATCH 7/12 dmg: mark more functions as coroutine_fns and GRAPH_RDLOCK
In reply to Paolo BonziniMark functions as coroutine_fn when they are only called by other coroutine_fns and they can suspend. Change calls to co_wrappers to use the non-wrapped functions, which in turn requires adding GRAPH_RDLOCK annotations.
--- block/dmg.c | 21 +++++++++++---------- 1 file changed, 11 insertions(+), 10 deletions(-)
block/dmg.c +11 -10
@@ -616,7 +616,8 @@ err:return s->n_chunks;/* error */ } -static inline int dmg_read_chunk (BlockDriverState *bs,uint64_t sector_num) +static int coroutine_fn GRAPH_RDLOCK +dmg_read_chunk (BlockDriverState *bs,uint64_t sector_num) {BDRVDMGState *s = bs->opaque;
@@ -633,8 +634,8 @@ static inline int dmg_read_chunk(BlockDriverState *bs, uint64_t sector_num)case UDZO : {/* zlib compressed */ /* we need to buffer, because only the chunk as whole can be * inflated. */ - ret =bdrv_pread (bs->file, s->offsets[chunk], s->lengths[chunk], - s->compressed_chunk,0 ); + ret =bdrv_co_pread (bs->file, s->offsets[chunk], s->lengths[chunk], + s->compressed_chunk,0 );if (ret <0 ) {return -1 ; }
@@ -659,8 +660,8 @@ static inline int dmg_read_chunk(BlockDriverState *bs, uint64_t sector_num) }/* we need to buffer, because only the chunk as whole can be * inflated. */ - ret =bdrv_pread (bs->file, s->offsets[chunk], s->lengths[chunk], - s->compressed_chunk,0 ); + ret =bdrv_co_pread (bs->file, s->offsets[chunk], s->lengths[chunk], + s->compressed_chunk,0 );if (ret <0 ) {return -1 ; }
@@ -680,8 +681,8 @@ static inline int dmg_read_chunk(BlockDriverState *bs, uint64_t sector_num) }/* we need to buffer, because only the chunk as whole can be * inflated. */ - ret =bdrv_pread (bs->file, s->offsets[chunk], s->lengths[chunk], - s->compressed_chunk,0 ); + ret =bdrv_co_pread (bs->file, s->offsets[chunk], s->lengths[chunk], + s->compressed_chunk,0 );if (ret <0 ) {return -1 ; }
@@ -696,8 +697,8 @@ static inline int dmg_read_chunk(BlockDriverState *bs, uint64_t sector_num) }break ;case UDRW :/* copy */ - ret =bdrv_pread (bs->file, s->offsets[chunk], s->lengths[chunk], - s->uncompressed_chunk,0 ); + ret =bdrv_co_pread (bs->file, s->offsets[chunk], s->lengths[chunk], + s->uncompressed_chunk,0 );if (ret <0 ) {return -1 ; }
@@ -713,7 +714,7 @@ static inline int dmg_read_chunk(BlockDriverState *bs, uint64_t sector_num)return 0 ; } -static int coroutine_fn +static int coroutine_fn GRAPH_RDLOCKdmg_co_preadv (BlockDriverState *bs,int64_t offset,int64_t bytes,QEMUIOVector *qiov,BdrvRequestFlags flags) {
Signature · 1 line
2.40.1
PATCH 8/12 vmdk: mark more functions as coroutine_fns and GRAPH_RDLOCK
In reply to Paolo BonziniMark functions as coroutine_fn when they are only called by other coroutine_fns and they can suspend. Change calls to co_wrappers to use the non-wrapped functions, which in turn requires adding GRAPH_RDLOCK annotations.
--- block/vmdk.c | 27 ++++++++++++++------------- 1 file changed, 14 insertions(+), 13 deletions(-)
block/vmdk.c +14 -13
@@ -339,7 +339,8 @@ out:return ret; } -static int vmdk_write_cid (BlockDriverState *bs,uint32_t cid) +static int coroutine_fn GRAPH_RDLOCK +vmdk_write_cid (BlockDriverState *bs,uint32_t cid) {char *desc, *tmp_desc;char *p_name, *tmp_str;
@@ -348,7 +349,7 @@ static int vmdk_write_cid(BlockDriverState *bs, uint32_t cid) desc =g_malloc0 (DESC_SIZE ); tmp_desc =g_malloc0 (DESC_SIZE ); - ret =bdrv_pread (bs->file, s->desc_offset,DESC_SIZE , desc,0 ); + ret =bdrv_co_pread (bs->file, s->desc_offset,DESC_SIZE , desc,0 );if (ret <0 ) { goto out; }
@@ -368,7 +369,7 @@ static int vmdk_write_cid(BlockDriverState *bs, uint32_t cid)pstrcat (desc,DESC_SIZE , tmp_desc); } - ret =bdrv_pwrite_sync (bs->file, s->desc_offset,DESC_SIZE , desc,0 ); + ret =bdrv_co_pwrite_sync (bs->file, s->desc_offset,DESC_SIZE , desc,0 ); out:g_free (desc);
@@ -2165,7 +2166,7 @@ vmdk_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset, int64_t bytes,return ret; } -static int GRAPH_UNLOCKED +static int coroutine_fn GRAPH_UNLOCKEDvmdk_init_extent (BlockBackend *blk,int64_t filesize,bool flat,bool compress,bool zeroed_grain,Error **errp) {
@@ -2176,7 +2177,7 @@ vmdk_init_extent(BlockBackend *blk, int64_t filesize, bool flat, bool compress,int gd_buf_size;if (flat) { - ret =blk_truncate (blk, filesize, false,PREALLOC_MODE_OFF ,0 , errp); + ret =blk_co_truncate (blk, filesize, false,PREALLOC_MODE_OFF ,0 , errp); goto exit; } magic =cpu_to_be32 (VMDK4_MAGIC );
@@ -2228,19 +2229,19 @@ vmdk_init_extent(BlockBackend *blk, int64_t filesize, bool flat, bool compress, header.check_bytes[3 ] =0xa ;/* write all the data */ - ret =blk_pwrite (blk,0 ,sizeof (magic), &magic,0 ); + ret =blk_co_pwrite (blk,0 ,sizeof (magic), &magic,0 );if (ret <0 ) {error_setg (errp,QERR_IO_ERROR ); goto exit; } - ret =blk_pwrite (blk,sizeof (magic),sizeof (header), &header,0 ); + ret =blk_co_pwrite (blk,sizeof (magic),sizeof (header), &header,0 );if (ret <0 ) {error_setg (errp,QERR_IO_ERROR ); goto exit; } - ret =blk_truncate (blk,le64_to_cpu (header.grain_offset) <<9 , false, -PREALLOC_MODE_OFF ,0 , errp); + ret =blk_co_truncate (blk,le64_to_cpu (header.grain_offset) <<9 , false, +PREALLOC_MODE_OFF ,0 , errp);if (ret <0 ) { goto exit; }
@@ -2252,8 +2253,8 @@ vmdk_init_extent(BlockBackend *blk, int64_t filesize, bool flat, bool compress, i < gt_count; i++, tmp += gt_size) { gd_buf[i] =cpu_to_le32 (tmp); } - ret =blk_pwrite (blk,le64_to_cpu (header.rgd_offset) *BDRV_SECTOR_SIZE , - gd_buf_size, gd_buf,0 ); + ret =blk_co_pwrite (blk,le64_to_cpu (header.rgd_offset) *BDRV_SECTOR_SIZE , + gd_buf_size, gd_buf,0 );if (ret <0 ) {error_setg (errp,QERR_IO_ERROR ); goto exit;
@@ -2264,8 +2265,8 @@ vmdk_init_extent(BlockBackend *blk, int64_t filesize, bool flat, bool compress, i < gt_count; i++, tmp += gt_size) { gd_buf[i] =cpu_to_le32 (tmp); } - ret =blk_pwrite (blk,le64_to_cpu (header.gd_offset) *BDRV_SECTOR_SIZE , - gd_buf_size, gd_buf,0 ); + ret =blk_co_pwrite (blk,le64_to_cpu (header.gd_offset) *BDRV_SECTOR_SIZE , + gd_buf_size, gd_buf,0 );if (ret <0 ) {error_setg (errp,QERR_IO_ERROR ); }
Signature · 1 line
2.40.1
PATCH 9/12 vhdx: mark more functions as coroutine_fns and GRAPH_RDLOCK
In reply to Paolo BonziniMark functions as coroutine_fn when they are only called by other coroutine_fns and they can suspend. Change calls to co_wrappers to use the non-wrapped functions, which in turn requires adding GRAPH_RDLOCK annotations.
--- block/vhdx-log.c | 36 +++++++++++++----------- block/vhdx.c | 73 +++++++++++++++++++++++------------------------- block/vhdx.h | 5 ++-- 3 files changed, 57 insertions(+), 57 deletions(-)
block/vhdx-log.c +19 -17
@@ -169,9 +169,10 @@ exit:* It is assumed that 'buffer' is at least 4096*num_sectors large. * * 0 is returned on success, -errno otherwise */ -static int vhdx_log_write_sectors (BlockDriverState *bs,VHDXLogEntries *log, -uint32_t *sectors_written,void *buffer, -uint32_t num_sectors) +static int coroutine_fn GRAPH_RDLOCK +vhdx_log_write_sectors (BlockDriverState *bs,VHDXLogEntries *log, +uint32_t *sectors_written,void *buffer, +uint32_t num_sectors) {int ret =0 ;uint64_t offset;
@@ -195,8 +196,7 @@ static int vhdx_log_write_sectors(BlockDriverState *bs, VHDXLogEntries *log,/* full */ break ; } - ret =bdrv_pwrite (bs->file, offset,VHDX_LOG_SECTOR_SIZE , buffer_tmp, -0 ); + ret =bdrv_co_pwrite (bs->file, offset,VHDX_LOG_SECTOR_SIZE , buffer_tmp,0 );if (ret <0 ) { goto exit; }
@@ -853,8 +853,9 @@ static void vhdx_log_raw_to_le_sector(VHDXLogDescriptor *desc, } -static int vhdx_log_write (BlockDriverState *bs,BDRVVHDXState *s, -void *data,uint32_t length,uint64_t offset) +static int coroutine_fn GRAPH_RDLOCK +vhdx_log_write (BlockDriverState *bs,BDRVVHDXState *s, +void *data,uint32_t length,uint64_t offset) {int ret =0 ;void *buffer =NULL ;
@@ -924,7 +925,7 @@ static int vhdx_log_write(BlockDriverState *bs, BDRVVHDXState *s, sectors += partial_sectors; - file_length =bdrv_getlength (bs->file->bs); + file_length =bdrv_co_getlength (bs->file->bs);if (file_length <0 ) { ret = file_length; goto exit;
@@ -971,8 +972,8 @@ static int vhdx_log_write(BlockDriverState *bs, BDRVVHDXState *s,if (i ==0 && leading_length) {/* partial sector at the front of the buffer */ - ret =bdrv_pread (bs->file, file_offset,VHDX_LOG_SECTOR_SIZE , - merged_sector,0 ); + ret =bdrv_co_pread (bs->file, file_offset,VHDX_LOG_SECTOR_SIZE , + merged_sector,0 );if (ret <0 ) { goto exit; }
@@ -981,9 +982,9 @@ static int vhdx_log_write(BlockDriverState *bs, BDRVVHDXState *s, sector_write = merged_sector; }else if (i == sectors -1 && trailing_length) {/* partial sector at the end of the buffer */ - ret =bdrv_pread (bs->file, file_offset + trailing_length, -VHDX_LOG_SECTOR_SIZE - trailing_length, - merged_sector + trailing_length,0 ); + ret =bdrv_co_pread (bs->file, file_offset + trailing_length, +VHDX_LOG_SECTOR_SIZE - trailing_length, + merged_sector + trailing_length,0 );if (ret <0 ) { goto exit; }
@@ -1036,8 +1037,9 @@ exit: }/* Perform a log write, and then immediately flush the entire log */ -int vhdx_log_write_and_flush (BlockDriverState *bs,BDRVVHDXState *s, -void *data,uint32_t length,uint64_t offset) +int coroutine_fn GRAPH_RDLOCK +vhdx_log_write_and_flush (BlockDriverState *bs,BDRVVHDXState *s, +void *data,uint32_t length,uint64_t offset) {int ret =0 ;VHDXLogSequence logs = { .valid = true,
@@ -1047,7 +1049,7 @@ int vhdx_log_write_and_flush(BlockDriverState *bs, BDRVVHDXState *s,/* Make sure data written (new and/or changed blocks) is stable * on disk, before creating log entry */ - ret =bdrv_flush (bs); + ret =bdrv_co_flush (bs);if (ret <0 ) { goto exit; }
@@ -1059,7 +1061,7 @@ int vhdx_log_write_and_flush(BlockDriverState *bs, BDRVVHDXState *s, logs.log = s->log;/* Make sure log is stable on disk */ - ret =bdrv_flush (bs); + ret =bdrv_co_flush (bs);if (ret <0 ) { goto exit; }
block/vhdx.c +35 -38
149 lines not on this page · raw message
block/vhdx.h +3 -2
@@ -413,8 +413,9 @@ bool vhdx_checksum_is_valid(uint8_t *buf, size_t size, int crc_offset);int vhdx_parse_log (BlockDriverState *bs,BDRVVHDXState *s,bool *flushed,Error **errp); -int vhdx_log_write_and_flush (BlockDriverState *bs,BDRVVHDXState *s, -void *data,uint32_t length,uint64_t offset); +int coroutine_fn vhdx_log_write_and_flush(BlockDriverState *bs, BDRVVHDXState *s, +void *data,uint32_t length, +uint64_t offset);static inline void leguid_to_cpus (MSGUID *guid) {
Signature · 1 line
2.40.1
Re: [PATCH 09/12] vhdx: mark more functions as coroutine_fns and GRAPH_RDLOCK
Am 01.06.2023 um 13:51 hat Paolo Bonzini geschrieben:
Quoted 8 lines
Mark functions as
coroutine_fnwhen they are only called by othercoroutine_fnsand they can suspend. Change calls toco_wrappersto use the non-wrapped functions, which in turn requires addingGRAPH_RDLOCKannotations.Signed-off-by Paolo Bonzini <[email protected]>block/vhdx-log.c +0
-0@@ -1036,8 +1037,9 @@ exit: }
block/vhdx-log.c exit: · line 1045
Quoted 10 lines
block/vhdx-log.c +3
-2/* Perform a log write, and then immediately flush the entire log */ -int vhdx_log_write_and_flush (BlockDriverState *bs,BDRVVHDXState *s, -void *data,uint32_t length,uint64_t offset) +int coroutine_fn GRAPH_RDLOCK +vhdx_log_write_and_flush (BlockDriverState *bs,BDRVVHDXState *s, +void *data,uint32_t length,uint64_t offset) {int ret =0 ;VHDXLogSequence logs = { .valid = true,
This is a public function, so GRAPH_RDLOCK needs to move to the header so that callers in other source files are actually checked. I can fix this up while applying.
Kevin
PATCH 10/12 qcow2: mark more functions as coroutine_fns and GRAPH_RDLOCK
In reply to Paolo BonziniMark functions as coroutine_fn when they are only called by other coroutine_fns and they can suspend. Change calls to co_wrappers to use the non-wrapped functions, which in turn requires adding GRAPH_RDLOCK annotations.
--- block/qcow2-bitmap.c | 26 +++++---- block/qcow2-cluster.c | 12 ++-- block/qcow2-refcount.c | 130 +++++++++++++++++++++-------------------- block/qcow2.c | 2 +- block/qcow2.h | 33 +++++------ 5 files changed, 105 insertions(+), 98 deletions(-)
block/qcow2-bitmap.c +14 -12
@@ -283,10 +283,9 @@ static int free_bitmap_clusters(BlockDriverState *bs, Qcow2BitmapTable *tb)/* load_bitmap_data * @bitmap_table entries must satisfy specification constraints. * @bitmap must be cleared */ -static int load_bitmap_data (BlockDriverState *bs, -const uint64_t *bitmap_table, -uint32_t bitmap_table_size, -BdrvDirtyBitmap *bitmap) +static int coroutine_fn GRAPH_RDLOCK +load_bitmap_data (BlockDriverState *bs,const uint64_t *bitmap_table, +uint32_t bitmap_table_size,BdrvDirtyBitmap *bitmap) {int ret =0 ;BDRVQcow2State *s = bs->opaque;
@@ -319,7 +318,7 @@ static int load_bitmap_data(BlockDriverState *bs,* already cleared */ } }else { - ret =bdrv_pread (bs->file, data_offset, s->cluster_size, buf,0 ); + ret =bdrv_co_pread (bs->file, data_offset, s->cluster_size, buf,0 );if (ret <0 ) { goto finish; }
@@ -337,8 +336,9 @@ finish:return ret; } -static BdrvDirtyBitmap *load_bitmap (BlockDriverState *bs, -Qcow2Bitmap *bm,Error **errp) +static coroutine_fn GRAPH_RDLOCK +BdrvDirtyBitmap *load_bitmap (BlockDriverState *bs, +Qcow2Bitmap *bm,Error **errp) {int ret;uint64_t *bitmap_table =NULL ;
@@ -649,9 +649,10 @@ fail:return NULL ; } -int qcow2_check_bitmaps_refcounts (BlockDriverState *bs,BdrvCheckResult *res, -void **refcount_table, -int64_t *refcount_table_size) +int coroutine_fn +qcow2_check_bitmaps_refcounts (BlockDriverState *bs,BdrvCheckResult *res, +void **refcount_table, +int64_t *refcount_table_size) {int ret;BDRVQcow2State *s = bs->opaque;
@@ -957,8 +958,9 @@ static void set_readonly_helper(gpointer bitmap, gpointer value)* If header_updated is not NULL then it is set appropriately regardless of * the return value. */ -bool coroutine_fn qcow2_load_dirty_bitmaps(BlockDriverState *bs, -bool *header_updated,Error **errp) +bool coroutine_fn GRAPH_RDLOCK +qcow2_load_dirty_bitmaps (BlockDriverState *bs, +bool *header_updated,Error **errp) {BDRVQcow2State *s = bs->opaque;Qcow2BitmapList *bm_list;
block/qcow2-cluster.c +6 -6
@@ -823,10 +823,9 @@ static int get_cluster_table(BlockDriverState *bs, uint64_t offset,* * Return 0 on success and -errno in error cases */ -int coroutine_fn qcow2_alloc_compressed_cluster_offset(BlockDriverState *bs, -uint64_t offset, -int compressed_size, -uint64_t *host_offset) +int coroutine_fn GRAPH_RDLOCK +qcow2_alloc_compressed_cluster_offset (BlockDriverState *bs,uint64_t offset, +int compressed_size,uint64_t *host_offset) {BDRVQcow2State *s = bs->opaque;int l2_index, ret;
@@ -2014,8 +2013,9 @@ fail:* all clusters in the same L2 slice) and returns the number of zeroed * clusters. */ -static int zero_in_l2_slice (BlockDriverState *bs,uint64_t offset, -uint64_t nb_clusters,int flags) +static int coroutine_fn +zero_in_l2_slice (BlockDriverState *bs,uint64_t offset, +uint64_t nb_clusters,int flags) {BDRVQcow2State *s = bs->opaque;uint64_t *l2_slice;
block/qcow2-refcount.c +68 -62
284 lines not on this page · raw message
block/qcow2.c +1 -1
@@ -570,7 +570,7 @@ int qcow2_mark_corrupt(BlockDriverState *bs)* Marks the image as consistent, i.e., unsets the corrupt bit, and flushes * before if necessary. */ -int qcow2_mark_consistent (BlockDriverState *bs) +static int coroutine_fn qcow2_mark_consistent(BlockDriverState *bs) {BDRVQcow2State *s = bs->opaque;
block/qcow2.h +16 -17
@@ -833,7 +833,6 @@ int64_t qcow2_refcount_metadata_size(int64_t clusters, size_t cluster_size,int qcow2_mark_dirty (BlockDriverState *bs);int qcow2_mark_corrupt (BlockDriverState *bs); -int qcow2_mark_consistent (BlockDriverState *bs);int qcow2_update_header (BlockDriverState *bs); void qcow2_signal_corruption(BlockDriverState *bs, bool fatal, int64_t offset,
@@ -864,7 +863,7 @@ int64_t qcow2_refcount_area(BlockDriverState *bs, uint64_t offset,int64_t qcow2_alloc_clusters (BlockDriverState *bs,uint64_t size); int64_t coroutine_fn qcow2_alloc_clusters_at(BlockDriverState *bs, uint64_t offset,int64_t nb_clusters); -int64_t coroutine_fn qcow2_alloc_bytes(BlockDriverState *bs, int size); +int64_t coroutine_fn GRAPH_RDLOCK qcow2_alloc_bytes(BlockDriverState *bs, int size);void qcow2_free_clusters (BlockDriverState *bs,int64_t offset,int64_t size,enum qcow2_discard_type type);
@@ -876,8 +875,8 @@ int qcow2_update_snapshot_refcount(BlockDriverState *bs,int qcow2_flush_caches (BlockDriverState *bs);int qcow2_write_caches (BlockDriverState *bs); -int qcow2_check_refcounts (BlockDriverState *bs,BdrvCheckResult *res, -BdrvCheckMode fix); +int coroutine_fn qcow2_check_refcounts(BlockDriverState *bs, BdrvCheckResult *res, +BdrvCheckMode fix);void qcow2_process_discards (BlockDriverState *bs,int ret);
@@ -885,10 +884,10 @@ int qcow2_check_metadata_overlap(BlockDriverState *bs, int ign, int64_t offset, int64_t size);int qcow2_pre_write_overlap_check (BlockDriverState *bs,int ign,int64_t offset,int64_t size,bool data_file); -int qcow2_inc_refcounts_imrt (BlockDriverState *bs,BdrvCheckResult *res, -void **refcount_table, -int64_t *refcount_table_size, -int64_t offset,int64_t size); +int coroutine_fn qcow2_inc_refcounts_imrt(BlockDriverState *bs, BdrvCheckResult *res, +void **refcount_table, +int64_t *refcount_table_size, +int64_t offset,int64_t size); int qcow2_change_refcount_order(BlockDriverState *bs, int refcount_order, BlockDriverAmendStatusCB *status_cb,
@@ -916,10 +915,9 @@ int qcow2_get_host_offset(BlockDriverState *bs, uint64_t offset, int coroutine_fn qcow2_alloc_host_offset(BlockDriverState *bs, uint64_t offset,unsigned int *bytes,uint64_t *host_offset,QCowL2Meta **m); -int coroutine_fn qcow2_alloc_compressed_cluster_offset(BlockDriverState *bs, -uint64_t offset, -int compressed_size, -uint64_t *host_offset); +int coroutine_fn GRAPH_RDLOCK +qcow2_alloc_compressed_cluster_offset (BlockDriverState *bs,uint64_t offset, +int compressed_size,uint64_t *host_offset);void qcow2_parse_compressed_l2_entry (BlockDriverState *bs,uint64_t l2_entry,uint64_t *coffset,int *csize);
@@ -989,11 +987,12 @@ void *qcow2_cache_is_table_offset(Qcow2Cache *c, uint64_t offset);void qcow2_cache_discard (Qcow2Cache *c,void *table);/* qcow2-bitmap.c functions */ -int qcow2_check_bitmaps_refcounts (BlockDriverState *bs,BdrvCheckResult *res, -void **refcount_table, -int64_t *refcount_table_size); -bool coroutine_fn qcow2_load_dirty_bitmaps(BlockDriverState *bs, - bool *header_updated, Error **errp); +int coroutine_fn +qcow2_check_bitmaps_refcounts (BlockDriverState *bs, BdrvCheckResult *res, + void **refcount_table, + int64_t *refcount_table_size); +bool coroutine_fn GRAPH_RDLOCK +qcow2_load_dirty_bitmaps (BlockDriverState *bs,bool *header_updated,Error **errp);bool qcow2_get_bitmap_info_list (BlockDriverState *bs,Qcow2BitmapInfoList **info_list,Error **errp);int qcow2_reopen_bitmaps_rw (BlockDriverState *bs,Error **errp);
Signature · 1 line
2.40.1
PATCH 11/12 block: use bdrv_co_getlength in coroutine context
In reply to Paolo Bonzinibdrv_co_getlength was recently introduced, with bdrv_getlength becoming a wrapper for use in unknown context. Switch to bdrv_co_getlength when possible.
--- block/io.c | 10 +++++----- block/parallels.c | 4 ++-- block/qcow.c | 6 +++--- block/vmdk.c | 4 ++-- 4 files changed, 12 insertions(+), 12 deletions(-)
block/io.c +5 -5
@@ -1379,7 +1379,7 @@ bdrv_aligned_preadv(BdrvChild *child, BdrvTrackedRequest *req, }/* Forward the request to the BlockDriver, possibly fragmenting it */ - total_bytes =bdrv_getlength (bs); + total_bytes =bdrv_co_getlength (bs);if (total_bytes <0 ) { ret = total_bytes; goto out;
@@ -2252,7 +2252,7 @@ bdrv_co_do_block_status(BlockDriverState *bs, bool want_zero,assert (pnum);assert_bdrv_graph_readable (); *pnum =0 ; - total_size =bdrv_getlength (bs); + total_size =bdrv_co_getlength (bs);if (total_size <0 ) { ret = total_size; goto early_out;
@@ -2272,7 +2272,7 @@ bdrv_co_do_block_status(BlockDriverState *bs, bool want_zero, bytes = n; } -/* Must be non-NULL or bdrv_getlength() would have failed */ +/* Must be non-NULL or bdrv_co_getlength() would have failed */ assert (bs->drv); has_filtered_child =bdrv_filter_child (bs);if (!bs->drv->bdrv_co_block_status && !has_filtered_child) {
@@ -2410,7 +2410,7 @@ bdrv_co_do_block_status(BlockDriverState *bs, bool want_zero,if (!cow_bs) { ret |=BDRV_BLOCK_ZERO ; }else if (want_zero) { -int64_t size2 =bdrv_getlength (cow_bs); +int64_t size2 =bdrv_co_getlength (cow_bs);if (size2 >=0 && offset >= size2) { ret |=BDRV_BLOCK_ZERO ;
@@ -3445,7 +3445,7 @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact,return ret; } - old_size =bdrv_getlength (bs); + old_size =bdrv_co_getlength (bs);if (old_size <0 ) {error_setg_errno (errp, -old_size,"Failed to get old image size" );return old_size;
block/parallels.c +2 -2
@@ -193,7 +193,7 @@ allocate_clusters(BlockDriverState *bs, int64_t sector_num,assert (idx < s->bat_size && idx + to_allocate <= s->bat_size); space = to_allocate * s->tracks; - len =bdrv_getlength (bs->file->bs); + len =bdrv_co_getlength (bs->file->bs);if (len <0 ) {return len; }
@@ -426,7 +426,7 @@ parallels_co_check(BlockDriverState *bs, BdrvCheckResult *res,uint32_t i;bool flush_bat = false; - size =bdrv_getlength (bs->file->bs); + size =bdrv_co_getlength (bs->file->bs);if (size <0 ) { res->check_errors++;return size;
block/qcow.c +3 -3
@@ -370,7 +370,7 @@ get_cluster_offset(BlockDriverState *bs, uint64_t offset, int allocate,if (!allocate)return 0 ;/* allocate a new l2 entry */ - l2_offset =bdrv_getlength (bs->file->bs); + l2_offset =bdrv_co_getlength (bs->file->bs);if (l2_offset <0 ) {return l2_offset; }
@@ -445,7 +445,7 @@ get_cluster_offset(BlockDriverState *bs, uint64_t offset, int allocate,if (decompress_cluster (bs, cluster_offset) <0 ) {return -EIO ; } - cluster_offset =bdrv_getlength (bs->file->bs); + cluster_offset =bdrv_co_getlength (bs->file->bs);if ((int64_t ) cluster_offset <0 ) {return cluster_offset; }
@@ -458,7 +458,7 @@ get_cluster_offset(BlockDriverState *bs, uint64_t offset, int allocate,return ret; } }else { - cluster_offset =bdrv_getlength (bs->file->bs); + cluster_offset =bdrv_co_getlength (bs->file->bs);if ((int64_t ) cluster_offset <0 ) {return cluster_offset; }
block/vmdk.c +2 -2
@@ -2132,7 +2132,7 @@ vmdk_co_pwritev_compressed(BlockDriverState *bs, int64_t offset, int64_t bytes,int64_t length;for (i =0 ; i < s->num_extents; i++) { - length =bdrv_getlength (s->extents[i].file->bs); + length =bdrv_co_getlength (s->extents[i].file->bs);if (length <0 ) {return length; }
@@ -2939,7 +2939,7 @@ vmdk_co_check(BlockDriverState *bs, BdrvCheckResult *result, BdrvCheckMode fix)break ; }if (ret ==VMDK_OK ) { -int64_t extent_len =bdrv_getlength (extent->file->bs); +int64_t extent_len =bdrv_co_getlength (extent->file->bs);if (extent_len <0 ) {fprintf (stderr, "ERROR: could not get extent file length for sector %"
Signature · 1 line
2.40.1
PATCH 12/12 block: use bdrv_co_debug_event in coroutine context
In reply to Paolo Bonzinibdrv_co_debug_event was recently introduced, with bdrv_debug_event becoming a wrapper for use in unknown context. Because most of the time bdrv_debug_event is used on a BdrvChild via the wrapper macro BLKDBG_EVENT, introduce a similar macro BLKDBG_CO_EVENT that calls bdrv_co_debug_event, and switch whenever possible.
--- block/io.c | 4 ++-- block/qcow.c | 24 ++++++++++++------------ block/qcow2-cluster.c | 12 ++++++------ block/qcow2-refcount.c | 4 ++-- block/qcow2.c | 18 +++++++++--------- block/qed-table.c | 6 +++--- block/qed.c | 8 ++++---- block/raw-format.c | 4 ++-- block/vmdk.c | 24 ++++++++++++------------ include/block/block-io.h | 7 +++++++ 10 files changed, 59 insertions(+), 52 deletions(-)
block/io.c +2 -2
@@ -2827,7 +2827,7 @@ int coroutine_fn bdrv_co_flush(BlockDriverState *bs) }/* Write back cached data to the OS even with cache=unsafe */ -BLKDBG_EVENT (primary_child,BLKDBG_FLUSH_TO_OS ); +BLKDBG_CO_EVENT (primary_child,BLKDBG_FLUSH_TO_OS );if (bs->drv->bdrv_co_flush_to_os) { ret = bs->drv->bdrv_co_flush_to_os (bs);if (ret <0 ) {
@@ -2845,7 +2845,7 @@ int coroutine_fn bdrv_co_flush(BlockDriverState *bs) goto flush_children; } -BLKDBG_EVENT (primary_child,BLKDBG_FLUSH_TO_DISK ); +BLKDBG_CO_EVENT (primary_child,BLKDBG_FLUSH_TO_DISK );if (!bs->drv) {/* bs->drv->bdrv_co_flush() might have ejected the BDS * (even in case of apparent success) */
block/qcow.c +12 -12
@@ -379,7 +379,7 @@ get_cluster_offset(BlockDriverState *bs, uint64_t offset, int allocate,/* update the L1 entry */ s->l1_table[l1_index] = l2_offset; tmp =cpu_to_be64 (l2_offset); -BLKDBG_EVENT (bs->file,BLKDBG_L1_UPDATE ); +BLKDBG_CO_EVENT (bs->file,BLKDBG_L1_UPDATE ); ret =bdrv_co_pwrite_sync (bs->file, s->l1_table_offset + l1_index *sizeof (tmp),sizeof (tmp), &tmp,0 );
@@ -410,7 +410,7 @@ get_cluster_offset(BlockDriverState *bs, uint64_t offset, int allocate, } } l2_table = s->l2_cache + (min_index << s->l2_bits); -BLKDBG_EVENT (bs->file,BLKDBG_L2_LOAD ); +BLKDBG_CO_EVENT (bs->file,BLKDBG_L2_LOAD );if (new_l2_table) {memset (l2_table,0 , s->l2_size *sizeof (uint64_t )); ret = bdrv_co_pwrite_sync(bs->file, l2_offset,
@@ -434,7 +434,7 @@ get_cluster_offset(BlockDriverState *bs, uint64_t offset, int allocate, ((cluster_offset & QCOW_OFLAG_COMPRESSED) && allocate == 1)) {if (!allocate)return 0 ; -BLKDBG_EVENT (bs->file,BLKDBG_CLUSTER_ALLOC ); +BLKDBG_CO_EVENT (bs->file,BLKDBG_CLUSTER_ALLOC );assert (QEMU_IS_ALIGNED (n_start | n_end,BDRV_SECTOR_SIZE ));/* allocate a new cluster */ if ((cluster_offset & QCOW_OFLAG_COMPRESSED) &&
@@ -451,7 +451,7 @@ get_cluster_offset(BlockDriverState *bs, uint64_t offset, int allocate, } cluster_offset =QEMU_ALIGN_UP (cluster_offset, s->cluster_size);/* write the cluster content */ -BLKDBG_EVENT (bs->file,BLKDBG_WRITE_AIO ); +BLKDBG_CO_EVENT (bs->file,BLKDBG_WRITE_AIO ); ret =bdrv_co_pwrite (bs->file, cluster_offset, s->cluster_size, s->cluster_cache,0 );if (ret <0 ) {
@@ -491,7 +491,7 @@ get_cluster_offset(BlockDriverState *bs, uint64_t offset, int allocate, NULL) < 0) {return -EIO ; } -BLKDBG_EVENT (bs->file,BLKDBG_WRITE_AIO ); +BLKDBG_CO_EVENT (bs->file,BLKDBG_WRITE_AIO ); ret =bdrv_co_pwrite (bs->file, cluster_offset + i,BDRV_SECTOR_SIZE , s->cluster_data,0 );
@@ -510,9 +510,9 @@ get_cluster_offset(BlockDriverState *bs, uint64_t offset, int allocate, tmp =cpu_to_be64 (cluster_offset); l2_table[l2_index] = tmp;if (allocate ==2 ) { -BLKDBG_EVENT (bs->file,BLKDBG_L2_UPDATE_COMPRESSED ); +BLKDBG_CO_EVENT (bs->file,BLKDBG_L2_UPDATE_COMPRESSED ); }else { -BLKDBG_EVENT (bs->file,BLKDBG_L2_UPDATE ); +BLKDBG_CO_EVENT (bs->file,BLKDBG_L2_UPDATE ); } ret =bdrv_co_pwrite_sync (bs->file, l2_offset + l2_index *sizeof (tmp),sizeof (tmp), &tmp,0 );
@@ -595,7 +595,7 @@ decompress_cluster(BlockDriverState *bs, uint64_t cluster_offset)if (s->cluster_cache_offset != coffset) { csize = cluster_offset >> (63 - s->cluster_bits); csize &= (s->cluster_size -1 ); -BLKDBG_EVENT (bs->file,BLKDBG_READ_COMPRESSED ); +BLKDBG_CO_EVENT (bs->file,BLKDBG_READ_COMPRESSED ); ret =bdrv_co_pread (bs->file, coffset, csize, s->cluster_data,0 );if (ret <0 )return -1 ;
@@ -657,7 +657,7 @@ qcow_co_preadv(BlockDriverState *bs, int64_t offset, int64_t bytes,/* read from the base image */ qemu_co_mutex_unlock (&s->lock);/* qcow2 emits this on bs->file instead of bs->backing */ -BLKDBG_EVENT (bs->file,BLKDBG_READ_BACKING_AIO ); +BLKDBG_CO_EVENT (bs->file,BLKDBG_READ_BACKING_AIO ); ret =bdrv_co_pread (bs->backing, offset, n, buf,0 );qemu_co_mutex_lock (&s->lock);if (ret <0 ) {
@@ -680,7 +680,7 @@ qcow_co_preadv(BlockDriverState *bs, int64_t offset, int64_t bytes,break ; }qemu_co_mutex_unlock (&s->lock); -BLKDBG_EVENT (bs->file,BLKDBG_READ_AIO ); +BLKDBG_CO_EVENT (bs->file,BLKDBG_READ_AIO ); ret =bdrv_co_pread (bs->file, cluster_offset + offset_in_cluster, n, buf,0 );qemu_co_mutex_lock (&s->lock);
@@ -765,7 +765,7 @@ qcow_co_pwritev(BlockDriverState *bs, int64_t offset, int64_t bytes, }qemu_co_mutex_unlock (&s->lock); -BLKDBG_EVENT (bs->file,BLKDBG_WRITE_AIO ); +BLKDBG_CO_EVENT (bs->file,BLKDBG_WRITE_AIO ); ret =bdrv_co_pwrite (bs->file, cluster_offset + offset_in_cluster, n, buf,0 );qemu_co_mutex_lock (&s->lock);
@@ -1114,7 +1114,7 @@ qcow_co_pwritev_compressed(BlockDriverState *bs, int64_t offset, int64_t bytes, } cluster_offset &= s->cluster_offset_mask; -BLKDBG_EVENT (bs->file,BLKDBG_WRITE_COMPRESSED ); +BLKDBG_CO_EVENT (bs->file,BLKDBG_WRITE_COMPRESSED ); ret =bdrv_co_pwrite (bs->file, cluster_offset, out_len, out_buf,0 );if (ret <0 ) { goto fail;
block/qcow2-cluster.c +6 -6
@@ -48,7 +48,7 @@ int coroutine_fn qcow2_shrink_l1_table(BlockDriverState *bs,fprintf (stderr,"shrink l1_table from %d to %d\n" , s->l1_size, new_l1_size);#endif -BLKDBG_EVENT (bs->file,BLKDBG_L1_SHRINK_WRITE_TABLE ); +BLKDBG_CO_EVENT (bs->file,BLKDBG_L1_SHRINK_WRITE_TABLE ); ret =bdrv_co_pwrite_zeroes (bs->file, s->l1_table_offset + new_l1_size *L1E_SIZE , (s->l1_size - new_l1_size) *L1E_SIZE ,0 );
@@ -61,7 +61,7 @@ int coroutine_fn qcow2_shrink_l1_table(BlockDriverState *bs, goto fail; } -BLKDBG_EVENT (bs->file,BLKDBG_L1_SHRINK_FREE_L2_CLUSTERS ); +BLKDBG_CO_EVENT (bs->file,BLKDBG_L1_SHRINK_FREE_L2_CLUSTERS );for (i = s->l1_size -1 ; i > new_l1_size -1 ; i--) {if ((s->l1_table[i] &L1E_OFFSET_MASK ) ==0 ) {continue ;
@@ -501,7 +501,7 @@ do_perform_cow_read(BlockDriverState *bs, uint64_t src_cluster_offset,return 0 ; } -BLKDBG_EVENT (bs->file,BLKDBG_COW_READ ); +BLKDBG_CO_EVENT (bs->file,BLKDBG_COW_READ );if (!bs->drv) {return -ENOMEDIUM ;
@@ -551,7 +551,7 @@ do_perform_cow_write(BlockDriverState *bs, uint64_t cluster_offset,return ret; } -BLKDBG_EVENT (bs->file,BLKDBG_COW_WRITE ); +BLKDBG_CO_EVENT (bs->file,BLKDBG_COW_WRITE ); ret =bdrv_co_pwritev (s->data_file, cluster_offset + offset_in_cluster, qiov->size, qiov,0 );if (ret <0 ) {
@@ -871,7 +871,7 @@ qcow2_alloc_compressed_cluster_offset(BlockDriverState *bs, uint64_t offset,/* compressed clusters never have the copied flag */ -BLKDBG_EVENT (bs->file,BLKDBG_L2_UPDATE_COMPRESSED ); +BLKDBG_CO_EVENT (bs->file,BLKDBG_L2_UPDATE_COMPRESSED );qcow2_cache_entry_mark_dirty (s->l2_table_cache, l2_slice);set_l2_entry (s, l2_slice, l2_index, cluster_offset);if (has_subclusters (s)) {
@@ -991,7 +991,7 @@ perform_cow(BlockDriverState *bs, QCowL2Meta *m)/* NOTE: we have a write_aio blkdebug event here followed by * a cow_write one in do_perform_cow_write(), but there's only * one single I/O operation */ -BLKDBG_EVENT (bs->file,BLKDBG_WRITE_AIO ); +BLKDBG_CO_EVENT (bs->file,BLKDBG_WRITE_AIO ); ret =do_perform_cow_write (bs, m->alloc_offset, start->offset, &qiov); }else {/* If there's no guest data then write both COW regions separately */
block/qcow2-refcount.c +2 -2
@@ -118,7 +118,7 @@ int coroutine_fn qcow2_refcount_init(BlockDriverState *bs) ret = -ENOMEM ; goto fail; } -BLKDBG_EVENT (bs->file,BLKDBG_REFTABLE_LOAD ); +BLKDBG_CO_EVENT (bs->file,BLKDBG_REFTABLE_LOAD ); ret =bdrv_co_pread (bs->file, s->refcount_table_offset, refcount_table_size2, s->refcount_table,0 );if (ret <0 ) {
@@ -1076,7 +1076,7 @@ int64_t coroutine_fn GRAPH_RDLOCK qcow2_alloc_bytes(BlockDriverState *bs, int sisize_t free_in_cluster;int ret; -BLKDBG_EVENT (bs->file,BLKDBG_CLUSTER_ALLOC_BYTES ); +BLKDBG_CO_EVENT (bs->file,BLKDBG_CLUSTER_ALLOC_BYTES );assert (size >0 && size <= s->cluster_size);assert (!s->free_byte_offset ||offset_into_cluster (s, s->free_byte_offset));
block/qcow2.c +9 -9
@@ -2207,7 +2207,7 @@ qcow2_co_preadv_encrypted(BlockDriverState *bs,return -ENOMEM ; } -BLKDBG_EVENT (bs->file,BLKDBG_READ_AIO ); +BLKDBG_CO_EVENT (bs->file,BLKDBG_READ_AIO ); ret =bdrv_co_pread (s->data_file, host_offset, bytes, buf,0 );if (ret <0 ) { goto fail;
@@ -2297,7 +2297,7 @@ qcow2_co_preadv_task(BlockDriverState *bs, QCow2SubclusterType subc_type,case QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC :assert (bs->backing);/* otherwise handled in qcow2_co_preadv_part */ -BLKDBG_EVENT (bs->file,BLKDBG_READ_BACKING_AIO ); +BLKDBG_CO_EVENT (bs->file,BLKDBG_READ_BACKING_AIO );return bdrv_co_preadv_part (bs->backing, offset, bytes, qiov, qiov_offset,0 );
@@ -2311,7 +2311,7 @@ qcow2_co_preadv_task(BlockDriverState *bs, QCow2SubclusterType subc_type, offset, bytes, qiov, qiov_offset); } -BLKDBG_EVENT (bs->file,BLKDBG_READ_AIO ); +BLKDBG_CO_EVENT (bs->file,BLKDBG_READ_AIO );return bdrv_co_preadv_part (s->data_file, host_offset, bytes, qiov, qiov_offset,0 );
@@ -2521,7 +2521,7 @@ handle_alloc_space(BlockDriverState *bs, QCowL2Meta *l2meta)return ret; } -BLKDBG_EVENT (bs->file,BLKDBG_CLUSTER_ALLOC_SPACE ); +BLKDBG_CO_EVENT (bs->file,BLKDBG_CLUSTER_ALLOC_SPACE ); ret =bdrv_co_pwrite_zeroes (s->data_file, start_offset, nb_bytes,BDRV_REQ_NO_FALLBACK );if (ret <0 ) {
@@ -2586,7 +2586,7 @@ int qcow2_co_pwritev_task(BlockDriverState *bs, uint64_t host_offset,* guest data now. */ if (!merge_cow (offset, bytes, qiov, qiov_offset, l2meta)) { -BLKDBG_EVENT (bs->file,BLKDBG_WRITE_AIO ); +BLKDBG_CO_EVENT (bs->file,BLKDBG_WRITE_AIO );trace_qcow2_writev_data (qemu_coroutine_self (), host_offset); ret =bdrv_co_pwritev_part (s->data_file, host_offset, bytes, qiov, qiov_offset,0 );
@@ -4661,7 +4661,7 @@ qcow2_co_pwritev_compressed_task(BlockDriverState *bs, goto fail; } -BLKDBG_EVENT (s->data_file,BLKDBG_WRITE_COMPRESSED ); +BLKDBG_CO_EVENT (s->data_file,BLKDBG_WRITE_COMPRESSED ); ret =bdrv_co_pwrite (s->data_file, cluster_offset, out_len, out_buf,0 );if (ret <0 ) { goto fail;
@@ -4780,7 +4780,7 @@ qcow2_co_preadv_compressed(BlockDriverState *bs, out_buf =qemu_blockalign (bs, s->cluster_size); -BLKDBG_EVENT (bs->file,BLKDBG_READ_COMPRESSED ); +BLKDBG_CO_EVENT (bs->file,BLKDBG_READ_COMPRESSED ); ret =bdrv_co_pread (bs->file, coffset, csize, buf,0 );if (ret <0 ) { goto fail;
@@ -5327,7 +5327,7 @@ qcow2_co_save_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos)return offset; } -BLKDBG_EVENT (bs->file,BLKDBG_VMSTATE_SAVE ); +BLKDBG_CO_EVENT (bs->file,BLKDBG_VMSTATE_SAVE );return bs->drv->bdrv_co_pwritev_part (bs, offset, qiov->size, qiov,0 ,0 ); }
@@ -5339,7 +5339,7 @@ qcow2_co_load_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos)return offset; } -BLKDBG_EVENT (bs->file,BLKDBG_VMSTATE_LOAD ); +BLKDBG_CO_EVENT (bs->file,BLKDBG_VMSTATE_LOAD );return bs->drv->bdrv_co_preadv_part (bs, offset, qiov->size, qiov,0 ,0 ); }
block/qed-table.c +3 -3
@@ -122,7 +122,7 @@ int coroutine_fn qed_read_l1_table_sync(BDRVQEDState *s) int coroutine_fn qed_write_l1_table(BDRVQEDState *s, unsigned int index,unsigned int n) { -BLKDBG_EVENT (s->bs->file,BLKDBG_L1_UPDATE ); +BLKDBG_CO_EVENT (s->bs->file,BLKDBG_L1_UPDATE );return qed_write_table (s, s->header.l1_table_offset, s->l1_table, index, n, false); }
@@ -150,7 +150,7 @@ int coroutine_fn qed_read_l2_table(BDRVQEDState *s, QEDRequest *request, request->l2_table =qed_alloc_l2_cache_entry (&s->l2_cache); request->l2_table->table =qed_alloc_table (s); -BLKDBG_EVENT (s->bs->file,BLKDBG_L2_LOAD ); +BLKDBG_CO_EVENT (s->bs->file,BLKDBG_L2_LOAD ); ret =qed_read_table (s, offset, request->l2_table->table);if (ret) {
@@ -183,7 +183,7 @@ int coroutine_fn qed_write_l2_table(BDRVQEDState *s, QEDRequest *request, unsigned int index, unsigned int n, bool flush) { - BLKDBG_EVENT(s->bs->file, BLKDBG_L2_UPDATE); + BLKDBG_CO_EVENT(s->bs->file, BLKDBG_L2_UPDATE);return qed_write_table (s, request->l2_table->offset, request->l2_table->table, index, n, flush); }
block/qed.c +4 -4
@@ -883,7 +883,7 @@ static int coroutine_fn GRAPH_RDLOCK qed_read_backing_file(BDRVQEDState *s, uint64_t pos, QEMUIOVector *qiov) {if (s->bs->backing) { -BLKDBG_EVENT (s->bs->file,BLKDBG_READ_BACKING_AIO ); +BLKDBG_CO_EVENT (s->bs->file,BLKDBG_READ_BACKING_AIO );return bdrv_co_preadv (s->bs->backing, pos, qiov->size, qiov,0 ); }qemu_iovec_memset (qiov,0 ,0 , qiov->size);
@@ -918,7 +918,7 @@ qed_copy_from_backing_file(BDRVQEDState *s, uint64_t pos, uint64_t len, goto out; } -BLKDBG_EVENT (s->bs->file,BLKDBG_COW_WRITE ); +BLKDBG_CO_EVENT (s->bs->file,BLKDBG_COW_WRITE ); ret =bdrv_co_pwritev (s->bs->file, offset, qiov.size, &qiov,0 );if (ret <0 ) { goto out;
@@ -1070,7 +1070,7 @@ static int coroutine_fn GRAPH_RDLOCK qed_aio_write_main(QEDAIOCB *acb)trace_qed_aio_write_main (s, acb,0 , offset, acb->cur_qiov.size); -BLKDBG_EVENT (s->bs->file,BLKDBG_WRITE_AIO ); +BLKDBG_CO_EVENT (s->bs->file,BLKDBG_WRITE_AIO );return bdrv_co_pwritev (s->bs->file, offset, acb->cur_qiov.size, &acb->cur_qiov,0 ); }
@@ -1324,7 +1324,7 @@ qed_aio_read_data(void *opaque, int ret, uint64_t offset, size_t len) }else if (ret !=QED_CLUSTER_FOUND ) { r =qed_read_backing_file (s, acb->cur_pos, &acb->cur_qiov); }else { -BLKDBG_EVENT (bs->file,BLKDBG_READ_AIO ); +BLKDBG_CO_EVENT (bs->file,BLKDBG_READ_AIO ); r =bdrv_co_preadv (bs->file, offset, acb->cur_qiov.size, &acb->cur_qiov,0 ); }
block/raw-format.c +2 -2
@@ -214,7 +214,7 @@ raw_co_preadv(BlockDriverState *bs, int64_t offset, int64_t bytes,return ret; } -BLKDBG_EVENT (bs->file,BLKDBG_READ_AIO ); +BLKDBG_CO_EVENT (bs->file,BLKDBG_READ_AIO );return bdrv_co_preadv (bs->file, offset, bytes, qiov, flags); }
@@ -268,7 +268,7 @@ raw_co_pwritev(BlockDriverState *bs, int64_t offset, int64_t bytes, goto fail; } -BLKDBG_EVENT (bs->file,BLKDBG_WRITE_AIO ); +BLKDBG_CO_EVENT (bs->file,BLKDBG_WRITE_AIO ); ret =bdrv_co_pwritev (bs->file, offset, bytes, qiov, flags); fail:
block/vmdk.c +12 -12
@@ -1438,7 +1438,7 @@ get_whole_cluster(BlockDriverState *bs, VmdkExtent *extent,if (skip_start_bytes >0 ) {if (copy_from_backing) {/* qcow2 emits this on bs->file instead of bs->backing */ -BLKDBG_EVENT (extent->file,BLKDBG_COW_READ ); +BLKDBG_CO_EVENT (extent->file,BLKDBG_COW_READ ); ret =bdrv_co_pread (bs->backing, offset, skip_start_bytes, whole_grain,0 );if (ret <0 ) {
@@ -1446,7 +1446,7 @@ get_whole_cluster(BlockDriverState *bs, VmdkExtent *extent, goto exit; } } -BLKDBG_EVENT (extent->file,BLKDBG_COW_WRITE ); +BLKDBG_CO_EVENT (extent->file,BLKDBG_COW_WRITE ); ret =bdrv_co_pwrite (extent->file, cluster_offset, skip_start_bytes, whole_grain,0 );if (ret <0 ) {
@@ -1458,7 +1458,7 @@ get_whole_cluster(BlockDriverState *bs, VmdkExtent *extent,if (skip_end_bytes < cluster_bytes) {if (copy_from_backing) {/* qcow2 emits this on bs->file instead of bs->backing */ -BLKDBG_EVENT (extent->file,BLKDBG_COW_READ ); +BLKDBG_CO_EVENT (extent->file,BLKDBG_COW_READ ); ret =bdrv_co_pread (bs->backing, offset + skip_end_bytes, cluster_bytes - skip_end_bytes, whole_grain + skip_end_bytes,0 );
@@ -1467,7 +1467,7 @@ get_whole_cluster(BlockDriverState *bs, VmdkExtent *extent, goto exit; } } -BLKDBG_EVENT (extent->file,BLKDBG_COW_WRITE ); +BLKDBG_CO_EVENT (extent->file,BLKDBG_COW_WRITE ); ret =bdrv_co_pwrite (extent->file, cluster_offset + skip_end_bytes, cluster_bytes - skip_end_bytes, whole_grain + skip_end_bytes,0 );
@@ -1488,7 +1488,7 @@ vmdk_L2update(VmdkExtent *extent, VmdkMetaData *m_data, uint32_t offset) { offset =cpu_to_le32 (offset);/* update L2 table */ -BLKDBG_EVENT (extent->file,BLKDBG_L2_UPDATE ); +BLKDBG_CO_EVENT (extent->file,BLKDBG_L2_UPDATE ); if (bdrv_co_pwrite(extent->file, ((int64_t)m_data->l2_offset * 512) + (m_data->l2_index * sizeof(offset)),
@@ -1618,7 +1618,7 @@ get_cluster_offset(BlockDriverState *bs, VmdkExtent *extent, } } l2_table = (char *)extent->l2_cache + (min_index * l2_size_bytes); -BLKDBG_EVENT (extent->file,BLKDBG_L2_LOAD ); +BLKDBG_CO_EVENT (extent->file,BLKDBG_L2_LOAD ); if (bdrv_co_pread(extent->file, (int64_t)l2_offset * 512, l2_size_bytes,
@@ -1829,12 +1829,12 @@ vmdk_write_extent(VmdkExtent *extent, int64_t cluster_offset, n_bytes = buf_len +sizeof (VmdkGrainMarker);qemu_iovec_init_buf (&local_qiov, data, n_bytes); -BLKDBG_EVENT (extent->file,BLKDBG_WRITE_COMPRESSED ); +BLKDBG_CO_EVENT (extent->file,BLKDBG_WRITE_COMPRESSED ); }else {qemu_iovec_init (&local_qiov, qiov->niov);qemu_iovec_concat (&local_qiov, qiov, qiov_offset, n_bytes); -BLKDBG_EVENT (extent->file,BLKDBG_WRITE_AIO ); +BLKDBG_CO_EVENT (extent->file,BLKDBG_WRITE_AIO ); } write_offset = cluster_offset + offset_in_cluster;
@@ -1876,7 +1876,7 @@ vmdk_read_extent(VmdkExtent *extent, int64_t cluster_offset,if (!extent->compressed) { -BLKDBG_EVENT (extent->file,BLKDBG_READ_AIO ); +BLKDBG_CO_EVENT (extent->file,BLKDBG_READ_AIO ); ret =bdrv_co_preadv (extent->file, cluster_offset + offset_in_cluster, bytes, qiov,0 );
@@ -1890,7 +1890,7 @@ vmdk_read_extent(VmdkExtent *extent, int64_t cluster_offset, buf_bytes = cluster_bytes *2 ; cluster_buf =g_malloc (buf_bytes); uncomp_buf =g_malloc (cluster_bytes); -BLKDBG_EVENT (extent->file,BLKDBG_READ_COMPRESSED ); +BLKDBG_CO_EVENT (extent->file,BLKDBG_READ_COMPRESSED ); ret =bdrv_co_pread (extent->file, cluster_offset, buf_bytes, cluster_buf,0 );if (ret <0 ) {
@@ -1968,7 +1968,7 @@ vmdk_co_preadv(BlockDriverState *bs, int64_t offset, int64_t bytes,qemu_iovec_concat (&local_qiov, qiov, bytes_done, n_bytes);/* qcow2 emits this on bs->file instead of bs->backing */ -BLKDBG_EVENT (bs->file,BLKDBG_READ_BACKING_AIO ); +BLKDBG_CO_EVENT (bs->file,BLKDBG_READ_BACKING_AIO ); ret =bdrv_co_preadv (bs->backing, offset, n_bytes, &local_qiov,0 );if (ret <0 ) {
@@ -2909,7 +2909,7 @@ vmdk_co_check(BlockDriverState *bs, BdrvCheckResult *result, BdrvCheckMode fix)BDRVVmdkState *s = bs->opaque;VmdkExtent *extent =NULL ;int64_t sector_num =0 ; -int64_t total_sectors =bdrv_nb_sectors (bs); +int64_t total_sectors =bdrv_co_nb_sectors (bs);int ret;uint64_t cluster_offset;
include/block/block-io.h +7 -0
@@ -232,6 +232,13 @@ bdrv_co_debug_event(BlockDriverState *bs, BlkdebugEvent event); void co_wrapper_mixed_bdrv_rdlockbdrv_debug_event (BlockDriverState *bs,BlkdebugEvent event); +#define BLKDBG_CO_EVENT (child, evt) \ + do { \ + if (child) { \ + bdrv_co_debug_event(child->bs, evt); \ + } \ + } while (0) +#define BLKDBG_EVENT (child, evt) \ do { \ if (child) { \
Signature · 1 line
2.40.1
Kevin Wolf
AppliedAm 01.06.2023 um 13:51 hat Paolo Bonzini geschrieben:
Quoted 15 lines
*** BLURB HERE ***
Paolo Bonzini (12):
file-posix: remove incorrectcoroutine_fncalls
qed: mark more functions ascoroutine_fnsandGRAPH_RDLOCK
vpc: mark more functions ascoroutine_fnsandGRAPH_RDLOCK
bochs: mark more functions ascoroutine_fnsandGRAPH_RDLOCK
block: mark another function ascoroutine_fnsandGRAPH_UNLOCKED
cloop: mark more functions ascoroutine_fnsandGRAPH_RDLOCK
dmg: mark more functions ascoroutine_fnsandGRAPH_RDLOCK
vmdk: mark more functions ascoroutine_fnsandGRAPH_RDLOCK
vhdx: mark more functions ascoroutine_fnsandGRAPH_RDLOCK
qcow2: mark more functions ascoroutine_fnsandGRAPH_RDLOCK
block: usebdrv_co_getlengthin coroutine context
block: usebdrv_co_debug_eventin coroutine context
Thanks, applied to the block branch.
Kevin