ShuriZma
/
xemu
mirror of https://github.com/xemu-project/xemu.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

qcow2: mark various functions as coroutine_fn and GRAPH_RDLOCK 

Functions that can do I/O (including calling bdrv_is_allocated
and bdrv_block_status functions) are prime candidates for being
coroutine_fns.  Make the change for those that are themselves called
only from coroutine_fns.  Also annotate that they are called with the
graph rdlock taken, thus allowing them to call bdrv_co_*() functions
for I/O.

Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20230309084456.304669-9-pbonzini@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
This commit is contained in:
Paolo Bonzini 2023-03-09 09:44:55 +01:00 committed by Kevin Wolf
parent 10bf10a8e3
commit a39bae4ecd
6 changed files with 53 additions and 45 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
block/qcow2-bitmap.c
View File

@ -1221,7 +1221,7 @@ out:
} }
/* Checks to see if it's safe to resize bitmaps */ /* Checks to see if it's safe to resize bitmaps */
int qcow2_truncate_bitmaps_check(BlockDriverState *bs, Error **errp) int coroutine_fn qcow2_truncate_bitmaps_check(BlockDriverState *bs, Error **errp)
{ {
BDRVQcow2State *s = bs->opaque; BDRVQcow2State *s = bs->opaque;
Qcow2BitmapList *bm_list; Qcow2BitmapList *bm_list;

21
block/qcow2-cluster.c
View File

@ -1126,7 +1126,7 @@ err:
* Frees the allocated clusters because the request failed and they won't * Frees the allocated clusters because the request failed and they won't
* actually be linked. * actually be linked.
*/ */
void qcow2_alloc_cluster_abort(BlockDriverState *bs, QCowL2Meta *m) void coroutine_fn qcow2_alloc_cluster_abort(BlockDriverState *bs, QCowL2Meta *m)
{ {
BDRVQcow2State *s = bs->opaque; BDRVQcow2State *s = bs->opaque;
if (!has_data_file(bs) && !m->keep_old_clusters) { if (!has_data_file(bs) && !m->keep_old_clusters) {
@ -1156,9 +1156,11 @@ void qcow2_alloc_cluster_abort(BlockDriverState *bs, QCowL2Meta *m)
* *
* Returns 0 on success, -errno on failure. * Returns 0 on success, -errno on failure.
*/ */
static int calculate_l2_meta(BlockDriverState *bs, uint64_t host_cluster_offset, static int coroutine_fn calculate_l2_meta(BlockDriverState *bs,
uint64_t guest_offset, unsigned bytes, uint64_t host_cluster_offset,
uint64_t *l2_slice, QCowL2Meta **m, bool keep_old) uint64_t guest_offset, unsigned bytes,
uint64_t *l2_slice, QCowL2Meta **m,
bool keep_old)
{ {
BDRVQcow2State *s = bs->opaque; BDRVQcow2State *s = bs->opaque;
int sc_index, l2_index = offset_to_l2_slice_index(s, guest_offset); int sc_index, l2_index = offset_to_l2_slice_index(s, guest_offset);
@ -1599,8 +1601,10 @@ out:
* function has been waiting for another request and the allocation must be * function has been waiting for another request and the allocation must be
* restarted, but the whole request should not be failed. * restarted, but the whole request should not be failed.
*/ */
static int do_alloc_cluster_offset(BlockDriverState *bs, uint64_t guest_offset, static int coroutine_fn do_alloc_cluster_offset(BlockDriverState *bs,
uint64_t *host_offset, uint64_t *nb_clusters) uint64_t guest_offset,
uint64_t *host_offset,
uint64_t *nb_clusters)
{ {
BDRVQcow2State *s = bs->opaque; BDRVQcow2State *s = bs->opaque;
@ -2065,8 +2069,9 @@ static int zero_in_l2_slice(BlockDriverState *bs, uint64_t offset,
return nb_clusters; return nb_clusters;
} }
static int zero_l2_subclusters(BlockDriverState *bs, uint64_t offset, static int coroutine_fn
unsigned nb_subclusters) zero_l2_subclusters(BlockDriverState *bs, uint64_t offset,
unsigned nb_subclusters)
{ {
BDRVQcow2State *s = bs->opaque; BDRVQcow2State *s = bs->opaque;
uint64_t *l2_slice; uint64_t *l2_slice;

8
block/qcow2-refcount.c
View File

@ -1030,8 +1030,8 @@ int64_t qcow2_alloc_clusters(BlockDriverState *bs, uint64_t size)
return offset; return offset;
} }
int64_t qcow2_alloc_clusters_at(BlockDriverState *bs, uint64_t offset, int64_t coroutine_fn qcow2_alloc_clusters_at(BlockDriverState *bs, uint64_t offset,
int64_t nb_clusters) int64_t nb_clusters)
{ {
BDRVQcow2State *s = bs->opaque; BDRVQcow2State *s = bs->opaque;
uint64_t cluster_index, refcount; uint64_t cluster_index, refcount;
@ -1069,7 +1069,7 @@ int64_t qcow2_alloc_clusters_at(BlockDriverState *bs, uint64_t offset,
/* only used to allocate compressed sectors. We try to allocate /* only used to allocate compressed sectors. We try to allocate
contiguous sectors. size must be <= cluster_size */ contiguous sectors. size must be <= cluster_size */
int64_t qcow2_alloc_bytes(BlockDriverState *bs, int size) int64_t coroutine_fn qcow2_alloc_bytes(BlockDriverState *bs, int size)
{ {
BDRVQcow2State *s = bs->opaque; BDRVQcow2State *s = bs->opaque;
int64_t offset; int64_t offset;
@ -3685,7 +3685,7 @@ out:
return ret; return ret;
} }
int64_t qcow2_get_last_cluster(BlockDriverState *bs, int64_t size) int64_t coroutine_fn qcow2_get_last_cluster(BlockDriverState *bs, int64_t size)
{ {
BDRVQcow2State *s = bs->opaque; BDRVQcow2State *s = bs->opaque;
int64_t i; int64_t i;

25
block/qcow2-snapshot.c
View File

@ -77,10 +77,11 @@ void qcow2_free_snapshots(BlockDriverState *bs)
* qcow2_check_refcounts() does not do anything with snapshots' * qcow2_check_refcounts() does not do anything with snapshots'
* extra data.) * extra data.)
*/ */
static int qcow2_do_read_snapshots(BlockDriverState *bs, bool repair, static coroutine_fn GRAPH_RDLOCK
int *nb_clusters_reduced, int qcow2_do_read_snapshots(BlockDriverState *bs, bool repair,
int *extra_data_dropped, int *nb_clusters_reduced,
Error **errp) int *extra_data_dropped,
Error **errp)
{ {
BDRVQcow2State *s = bs->opaque; BDRVQcow2State *s = bs->opaque;
QCowSnapshotHeader h; QCowSnapshotHeader h;
@ -108,7 +109,7 @@ static int qcow2_do_read_snapshots(BlockDriverState *bs, bool repair,
/* Read statically sized part of the snapshot header */ /* Read statically sized part of the snapshot header */
offset = ROUND_UP(offset, 8); offset = ROUND_UP(offset, 8);
ret = bdrv_pread(bs->file, offset, sizeof(h), &h, 0); ret = bdrv_co_pread(bs->file, offset, sizeof(h), &h, 0);
if (ret < 0) { if (ret < 0) {
error_setg_errno(errp, -ret, "Failed to read snapshot table"); error_setg_errno(errp, -ret, "Failed to read snapshot table");
goto fail; goto fail;
@ -146,8 +147,8 @@ static int qcow2_do_read_snapshots(BlockDriverState *bs, bool repair,
} }
/* Read known extra data */ /* Read known extra data */
ret = bdrv_pread(bs->file, offset, ret = bdrv_co_pread(bs->file, offset,
MIN(sizeof(extra), sn->extra_data_size), &extra, 0); MIN(sizeof(extra), sn->extra_data_size), &extra, 0);
if (ret < 0) { if (ret < 0) {
error_setg_errno(errp, -ret, "Failed to read snapshot table"); error_setg_errno(errp, -ret, "Failed to read snapshot table");
goto fail; goto fail;
@ -184,8 +185,8 @@ static int qcow2_do_read_snapshots(BlockDriverState *bs, bool repair,
/* Store unknown extra data */ /* Store unknown extra data */
unknown_extra_data_size = sn->extra_data_size - sizeof(extra); unknown_extra_data_size = sn->extra_data_size - sizeof(extra);
sn->unknown_extra_data = g_malloc(unknown_extra_data_size); sn->unknown_extra_data = g_malloc(unknown_extra_data_size);
ret = bdrv_pread(bs->file, offset, unknown_extra_data_size, ret = bdrv_co_pread(bs->file, offset, unknown_extra_data_size,
sn->unknown_extra_data, 0); sn->unknown_extra_data, 0);
if (ret < 0) { if (ret < 0) {
error_setg_errno(errp, -ret, error_setg_errno(errp, -ret,
"Failed to read snapshot table"); "Failed to read snapshot table");
@ -196,7 +197,7 @@ static int qcow2_do_read_snapshots(BlockDriverState *bs, bool repair,
/* Read snapshot ID */ /* Read snapshot ID */
sn->id_str = g_malloc(id_str_size + 1); sn->id_str = g_malloc(id_str_size + 1);
ret = bdrv_pread(bs->file, offset, id_str_size, sn->id_str, 0); ret = bdrv_co_pread(bs->file, offset, id_str_size, sn->id_str, 0);
if (ret < 0) { if (ret < 0) {
error_setg_errno(errp, -ret, "Failed to read snapshot table"); error_setg_errno(errp, -ret, "Failed to read snapshot table");
goto fail; goto fail;
@ -206,7 +207,7 @@ static int qcow2_do_read_snapshots(BlockDriverState *bs, bool repair,
/* Read snapshot name */ /* Read snapshot name */
sn->name = g_malloc(name_size + 1); sn->name = g_malloc(name_size + 1);
ret = bdrv_pread(bs->file, offset, name_size, sn->name, 0); ret = bdrv_co_pread(bs->file, offset, name_size, sn->name, 0);
if (ret < 0) { if (ret < 0) {
error_setg_errno(errp, -ret, "Failed to read snapshot table"); error_setg_errno(errp, -ret, "Failed to read snapshot table");
goto fail; goto fail;
@ -261,7 +262,7 @@ fail:
return ret; return ret;
} }
int qcow2_read_snapshots(BlockDriverState *bs, Error **errp) int coroutine_fn qcow2_read_snapshots(BlockDriverState *bs, Error **errp)
{ {
return qcow2_do_read_snapshots(bs, false, NULL, NULL, errp); return qcow2_do_read_snapshots(bs, false, NULL, NULL, errp);
} }

27
block/qcow2.c
View File

@ -199,10 +199,10 @@ qcow2_extract_crypto_opts(QemuOpts *opts, const char *fmt, Error **errp)
* unknown magic is skipped (future extension this version knows nothing about) * unknown magic is skipped (future extension this version knows nothing about)
* return 0 upon success, non-0 otherwise * return 0 upon success, non-0 otherwise
*/ */
static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset, static int coroutine_fn GRAPH_RDLOCK
uint64_t end_offset, void **p_feature_table, qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
int flags, bool *need_update_header, uint64_t end_offset, void **p_feature_table,
Error **errp) int flags, bool *need_update_header, Error **errp)
{ {
BDRVQcow2State *s = bs->opaque; BDRVQcow2State *s = bs->opaque;
QCowExtension ext; QCowExtension ext;
@ -228,7 +228,7 @@ static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
printf("attempting to read extended header in offset %lu\n", offset); printf("attempting to read extended header in offset %lu\n", offset);
#endif #endif
ret = bdrv_pread(bs->file, offset, sizeof(ext), &ext, 0); ret = bdrv_co_pread(bs->file, offset, sizeof(ext), &ext, 0);
if (ret < 0) { if (ret < 0) {
error_setg_errno(errp, -ret, "qcow2_read_extension: ERROR: " error_setg_errno(errp, -ret, "qcow2_read_extension: ERROR: "
"pread fail from offset %" PRIu64, offset); "pread fail from offset %" PRIu64, offset);
@ -256,7 +256,7 @@ static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
sizeof(bs->backing_format)); sizeof(bs->backing_format));
return 2; return 2;
} }
ret = bdrv_pread(bs->file, offset, ext.len, bs->backing_format, 0); ret = bdrv_co_pread(bs->file, offset, ext.len, bs->backing_format, 0);
if (ret < 0) { if (ret < 0) {
error_setg_errno(errp, -ret, "ERROR: ext_backing_format: " error_setg_errno(errp, -ret, "ERROR: ext_backing_format: "
"Could not read format name"); "Could not read format name");
@ -272,7 +272,7 @@ static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
case QCOW2_EXT_MAGIC_FEATURE_TABLE: case QCOW2_EXT_MAGIC_FEATURE_TABLE:
if (p_feature_table != NULL) { if (p_feature_table != NULL) {
void *feature_table = g_malloc0(ext.len + 2 * sizeof(Qcow2Feature)); void *feature_table = g_malloc0(ext.len + 2 * sizeof(Qcow2Feature));
ret = bdrv_pread(bs->file, offset, ext.len, feature_table, 0); ret = bdrv_co_pread(bs->file, offset, ext.len, feature_table, 0);
if (ret < 0) { if (ret < 0) {
error_setg_errno(errp, -ret, "ERROR: ext_feature_table: " error_setg_errno(errp, -ret, "ERROR: ext_feature_table: "
"Could not read table"); "Could not read table");
@ -298,7 +298,7 @@ static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
return -EINVAL; return -EINVAL;
} }
ret = bdrv_pread(bs->file, offset, ext.len, &s->crypto_header, 0); ret = bdrv_co_pread(bs->file, offset, ext.len, &s->crypto_header, 0);
if (ret < 0) { if (ret < 0) {
error_setg_errno(errp, -ret, error_setg_errno(errp, -ret,
"Unable to read CRYPTO header extension"); "Unable to read CRYPTO header extension");
@ -354,7 +354,7 @@ static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
break; break;
} }
ret = bdrv_pread(bs->file, offset, ext.len, &bitmaps_ext, 0); ret = bdrv_co_pread(bs->file, offset, ext.len, &bitmaps_ext, 0);
if (ret < 0) { if (ret < 0) {
error_setg_errno(errp, -ret, "bitmaps_ext: " error_setg_errno(errp, -ret, "bitmaps_ext: "
"Could not read ext header"); "Could not read ext header");
@ -418,7 +418,7 @@ static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
case QCOW2_EXT_MAGIC_DATA_FILE: case QCOW2_EXT_MAGIC_DATA_FILE:
{ {
s->image_data_file = g_malloc0(ext.len + 1); s->image_data_file = g_malloc0(ext.len + 1);
ret = bdrv_pread(bs->file, offset, ext.len, s->image_data_file, 0); ret = bdrv_co_pread(bs->file, offset, ext.len, s->image_data_file, 0);
if (ret < 0) { if (ret < 0) {
error_setg_errno(errp, -ret, error_setg_errno(errp, -ret,
"ERROR: Could not read data file name"); "ERROR: Could not read data file name");
@ -442,7 +442,7 @@ static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
uext->len = ext.len; uext->len = ext.len;
QLIST_INSERT_HEAD(&s->unknown_header_ext, uext, next); QLIST_INSERT_HEAD(&s->unknown_header_ext, uext, next);
ret = bdrv_pread(bs->file, offset, uext->len, uext->data, 0); ret = bdrv_co_pread(bs->file, offset, uext->len, uext->data, 0);
if (ret < 0) { if (ret < 0) {
error_setg_errno(errp, -ret, "ERROR: unknown extension: " error_setg_errno(errp, -ret, "ERROR: unknown extension: "
"Could not read data"); "Could not read data");
@ -1241,8 +1241,9 @@ static void qcow2_update_options_abort(BlockDriverState *bs,
qapi_free_QCryptoBlockOpenOptions(r->crypto_opts); qapi_free_QCryptoBlockOpenOptions(r->crypto_opts);
} }
static int qcow2_update_options(BlockDriverState *bs, QDict *options, static int coroutine_fn
int flags, Error **errp) qcow2_update_options(BlockDriverState *bs, QDict *options, int flags,
Error **errp)
{ {
Qcow2ReopenState r = {}; Qcow2ReopenState r = {};
int ret; int ret;

15
block/qcow2.h
View File

@ -862,9 +862,9 @@ int64_t qcow2_refcount_area(BlockDriverState *bs, uint64_t offset,
uint64_t new_refblock_offset); uint64_t new_refblock_offset);
int64_t qcow2_alloc_clusters(BlockDriverState *bs, uint64_t size); int64_t qcow2_alloc_clusters(BlockDriverState *bs, uint64_t size);
int64_t qcow2_alloc_clusters_at(BlockDriverState *bs, uint64_t offset, int64_t coroutine_fn qcow2_alloc_clusters_at(BlockDriverState *bs, uint64_t offset,
int64_t nb_clusters); int64_t nb_clusters);
int64_t qcow2_alloc_bytes(BlockDriverState *bs, int size); int64_t coroutine_fn qcow2_alloc_bytes(BlockDriverState *bs, int size);
void qcow2_free_clusters(BlockDriverState *bs, void qcow2_free_clusters(BlockDriverState *bs,
int64_t offset, int64_t size, int64_t offset, int64_t size,
enum qcow2_discard_type type); enum qcow2_discard_type type);
@ -894,7 +894,7 @@ int qcow2_change_refcount_order(BlockDriverState *bs, int refcount_order,
BlockDriverAmendStatusCB *status_cb, BlockDriverAmendStatusCB *status_cb,
void *cb_opaque, Error **errp); void *cb_opaque, Error **errp);
int coroutine_fn GRAPH_RDLOCK qcow2_shrink_reftable(BlockDriverState *bs); int coroutine_fn GRAPH_RDLOCK qcow2_shrink_reftable(BlockDriverState *bs);
int64_t qcow2_get_last_cluster(BlockDriverState *bs, int64_t size); int64_t coroutine_fn qcow2_get_last_cluster(BlockDriverState *bs, int64_t size);
int coroutine_fn qcow2_detect_metadata_preallocation(BlockDriverState *bs); int coroutine_fn qcow2_detect_metadata_preallocation(BlockDriverState *bs);
/* qcow2-cluster.c functions */ /* qcow2-cluster.c functions */
@ -924,7 +924,7 @@ void qcow2_parse_compressed_l2_entry(BlockDriverState *bs, uint64_t l2_entry,
int coroutine_fn GRAPH_RDLOCK int coroutine_fn GRAPH_RDLOCK
qcow2_alloc_cluster_link_l2(BlockDriverState *bs, QCowL2Meta *m); qcow2_alloc_cluster_link_l2(BlockDriverState *bs, QCowL2Meta *m);
void qcow2_alloc_cluster_abort(BlockDriverState *bs, QCowL2Meta *m); void coroutine_fn qcow2_alloc_cluster_abort(BlockDriverState *bs, QCowL2Meta *m);
int qcow2_cluster_discard(BlockDriverState *bs, uint64_t offset, int qcow2_cluster_discard(BlockDriverState *bs, uint64_t offset,
uint64_t bytes, enum qcow2_discard_type type, uint64_t bytes, enum qcow2_discard_type type,
bool full_discard); bool full_discard);
@ -951,7 +951,8 @@ int qcow2_snapshot_load_tmp(BlockDriverState *bs,
Error **errp); Error **errp);
void qcow2_free_snapshots(BlockDriverState *bs); void qcow2_free_snapshots(BlockDriverState *bs);
int qcow2_read_snapshots(BlockDriverState *bs, Error **errp); int coroutine_fn GRAPH_RDLOCK
qcow2_read_snapshots(BlockDriverState *bs, Error **errp);
int qcow2_write_snapshots(BlockDriverState *bs); int qcow2_write_snapshots(BlockDriverState *bs);
int coroutine_fn GRAPH_RDLOCK int coroutine_fn GRAPH_RDLOCK
@ -994,7 +995,7 @@ bool coroutine_fn qcow2_load_dirty_bitmaps(BlockDriverState *bs,
bool qcow2_get_bitmap_info_list(BlockDriverState *bs, bool qcow2_get_bitmap_info_list(BlockDriverState *bs,
Qcow2BitmapInfoList **info_list, Error **errp); Qcow2BitmapInfoList **info_list, Error **errp);
int qcow2_reopen_bitmaps_rw(BlockDriverState *bs, Error **errp); int qcow2_reopen_bitmaps_rw(BlockDriverState *bs, Error **errp);
int qcow2_truncate_bitmaps_check(BlockDriverState *bs, Error **errp); int coroutine_fn qcow2_truncate_bitmaps_check(BlockDriverState *bs, Error **errp);
bool qcow2_store_persistent_dirty_bitmaps(BlockDriverState *bs, bool qcow2_store_persistent_dirty_bitmaps(BlockDriverState *bs,
bool release_stored, Error **errp); bool release_stored, Error **errp);
int qcow2_reopen_bitmaps_ro(BlockDriverState *bs, Error **errp); int qcow2_reopen_bitmaps_ro(BlockDriverState *bs, Error **errp);