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

block: Mark bdrv_co_flush() and callers GRAPH_RDLOCK 

This adds GRAPH_RDLOCK annotations to declare that callers of
bdrv_co_flush() need to hold a reader lock for the graph.

For some places, we know that they will hold the lock, but we don't have
the GRAPH_RDLOCK annotations yet. In this case, add assume_graph_lock()
with a FIXME comment. These places will be removed once everything is
properly annotated.

Signed-off-by: Emanuele Giuseppe Esposito <eesposit@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Message-Id: <20230203152202.49054-8-kwolf@redhat.com>
Reviewed-by: Emanuele Giuseppe Esposito <eesposit@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
This commit is contained in:
Emanuele Giuseppe Esposito 2023-02-03 16:21:46 +01:00 committed by Kevin Wolf
parent c16b8bd4e5
commit 8809534933
20 changed files with 98 additions and 60 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
block/blkdebug.c
View File

@ -668,7 +668,7 @@ blkdebug_co_pwritev(BlockDriverState *bs, int64_t offset, int64_t bytes,
return bdrv_co_pwritev(bs->file, offset, bytes, qiov, flags); return bdrv_co_pwritev(bs->file, offset, bytes, qiov, flags);
} }
static int coroutine_fn blkdebug_co_flush(BlockDriverState *bs) static int GRAPH_RDLOCK coroutine_fn blkdebug_co_flush(BlockDriverState *bs)
{ {
int err = rule_check(bs, 0, 0, BLKDEBUG_IO_TYPE_FLUSH); int err = rule_check(bs, 0, 0, BLKDEBUG_IO_TYPE_FLUSH);

21
block/blklogwrites.c
View File

@ -307,7 +307,7 @@ typedef struct BlkLogWritesFileReq {
uint64_t bytes; uint64_t bytes;
int file_flags; int file_flags;
QEMUIOVector *qiov; QEMUIOVector *qiov;
int (*func)(struct BlkLogWritesFileReq *r); int GRAPH_RDLOCK_PTR (*func)(struct BlkLogWritesFileReq *r);
int file_ret; int file_ret;
} BlkLogWritesFileReq; } BlkLogWritesFileReq;
@ -319,7 +319,8 @@ typedef struct {
int log_ret; int log_ret;
} BlkLogWritesLogReq; } BlkLogWritesLogReq;
static void coroutine_fn blk_log_writes_co_do_log(BlkLogWritesLogReq *lr) static void coroutine_fn GRAPH_RDLOCK
blk_log_writes_co_do_log(BlkLogWritesLogReq *lr)
{ {
BDRVBlkLogWritesState *s = lr->bs->opaque; BDRVBlkLogWritesState *s = lr->bs->opaque;
uint64_t cur_log_offset = s->cur_log_sector << s->sectorbits; uint64_t cur_log_offset = s->cur_log_sector << s->sectorbits;
@ -368,15 +369,16 @@ static void coroutine_fn blk_log_writes_co_do_log(BlkLogWritesLogReq *lr)
} }
} }
static void coroutine_fn blk_log_writes_co_do_file(BlkLogWritesFileReq *fr) static void coroutine_fn GRAPH_RDLOCK
blk_log_writes_co_do_file(BlkLogWritesFileReq *fr)
{ {
fr->file_ret = fr->func(fr); fr->file_ret = fr->func(fr);
} }
static int coroutine_fn static int coroutine_fn GRAPH_RDLOCK
blk_log_writes_co_log(BlockDriverState *bs, uint64_t offset, uint64_t bytes, blk_log_writes_co_log(BlockDriverState *bs, uint64_t offset, uint64_t bytes,
QEMUIOVector *qiov, int flags, QEMUIOVector *qiov, int flags,
int (*file_func)(BlkLogWritesFileReq *r), int /*GRAPH_RDLOCK*/ (*file_func)(BlkLogWritesFileReq *r),
uint64_t entry_flags, bool is_zero_write) uint64_t entry_flags, bool is_zero_write)
{ {
QEMUIOVector log_qiov; QEMUIOVector log_qiov;
@ -442,7 +444,8 @@ blk_log_writes_co_do_file_pwrite_zeroes(BlkLogWritesFileReq *fr)
fr->file_flags); fr->file_flags);
} }
static int coroutine_fn blk_log_writes_co_do_file_flush(BlkLogWritesFileReq *fr) static int coroutine_fn GRAPH_RDLOCK
blk_log_writes_co_do_file_flush(BlkLogWritesFileReq *fr)
{ {
return bdrv_co_flush(fr->bs->file->bs); return bdrv_co_flush(fr->bs->file->bs);
} }
@ -457,6 +460,7 @@ static int coroutine_fn
blk_log_writes_co_pwritev(BlockDriverState *bs, int64_t offset, int64_t bytes, blk_log_writes_co_pwritev(BlockDriverState *bs, int64_t offset, int64_t bytes,
QEMUIOVector *qiov, BdrvRequestFlags flags) QEMUIOVector *qiov, BdrvRequestFlags flags)
{ {
assume_graph_lock(); /* FIXME */
return blk_log_writes_co_log(bs, offset, bytes, qiov, flags, return blk_log_writes_co_log(bs, offset, bytes, qiov, flags,
blk_log_writes_co_do_file_pwritev, 0, false); blk_log_writes_co_do_file_pwritev, 0, false);
} }
@ -465,12 +469,14 @@ static int coroutine_fn
blk_log_writes_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset, blk_log_writes_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset,
int64_t bytes, BdrvRequestFlags flags) int64_t bytes, BdrvRequestFlags flags)
{ {
assume_graph_lock(); /* FIXME */
return blk_log_writes_co_log(bs, offset, bytes, NULL, flags, return blk_log_writes_co_log(bs, offset, bytes, NULL, flags,
blk_log_writes_co_do_file_pwrite_zeroes, 0, blk_log_writes_co_do_file_pwrite_zeroes, 0,
true); true);
} }
static int coroutine_fn blk_log_writes_co_flush_to_disk(BlockDriverState *bs) static int coroutine_fn GRAPH_RDLOCK
blk_log_writes_co_flush_to_disk(BlockDriverState *bs)
{ {
return blk_log_writes_co_log(bs, 0, 0, NULL, 0, return blk_log_writes_co_log(bs, 0, 0, NULL, 0,
blk_log_writes_co_do_file_flush, blk_log_writes_co_do_file_flush,
@ -480,6 +486,7 @@ static int coroutine_fn blk_log_writes_co_flush_to_disk(BlockDriverState *bs)
static int coroutine_fn static int coroutine_fn
blk_log_writes_co_pdiscard(BlockDriverState *bs, int64_t offset, int64_t bytes) blk_log_writes_co_pdiscard(BlockDriverState *bs, int64_t offset, int64_t bytes)
{ {
assume_graph_lock(); /* FIXME */
return blk_log_writes_co_log(bs, offset, bytes, NULL, 0, return blk_log_writes_co_log(bs, offset, bytes, NULL, 0,
blk_log_writes_co_do_file_pdiscard, blk_log_writes_co_do_file_pdiscard,
LOG_DISCARD_FLAG, false); LOG_DISCARD_FLAG, false);

2
block/blkreplay.c
View File

@ -113,7 +113,7 @@ static int coroutine_fn blkreplay_co_pdiscard(BlockDriverState *bs,
return ret; return ret;
} }
static int coroutine_fn blkreplay_co_flush(BlockDriverState *bs) static int coroutine_fn GRAPH_RDLOCK blkreplay_co_flush(BlockDriverState *bs)
{ {
uint64_t reqid = blkreplay_next_id(); uint64_t reqid = blkreplay_next_id();
int ret = bdrv_co_flush(bs->file->bs); int ret = bdrv_co_flush(bs->file->bs);

2
block/blkverify.c
View File

@ -256,7 +256,7 @@ blkverify_co_pwritev(BlockDriverState *bs, int64_t offset, int64_t bytes,
return blkverify_co_prwv(bs, &r, offset, bytes, qiov, qiov, flags, true); return blkverify_co_prwv(bs, &r, offset, bytes, qiov, qiov, flags, true);
} }
static int coroutine_fn blkverify_co_flush(BlockDriverState *bs) static int coroutine_fn GRAPH_RDLOCK blkverify_co_flush(BlockDriverState *bs)
{ {
BDRVBlkverifyState *s = bs->opaque; BDRVBlkverifyState *s = bs->opaque;

3
block/block-backend.c
View File

@ -1762,8 +1762,9 @@ int coroutine_fn blk_co_pdiscard(BlockBackend *blk, int64_t offset,
/* To be called between exactly one pair of blk_inc/dec_in_flight() */ /* To be called between exactly one pair of blk_inc/dec_in_flight() */
static int coroutine_fn blk_co_do_flush(BlockBackend *blk) static int coroutine_fn blk_co_do_flush(BlockBackend *blk)
{ {
blk_wait_while_drained(blk);
IO_CODE(); IO_CODE();
blk_wait_while_drained(blk);
GRAPH_RDLOCK_GUARD();
if (!blk_is_available(blk)) { if (!blk_is_available(blk)) {
return -ENOMEDIUM; return -ENOMEDIUM;

2
block/copy-before-write.c
View File

@ -185,7 +185,7 @@ static coroutine_fn int cbw_co_pwritev(BlockDriverState *bs,
return bdrv_co_pwritev(bs->file, offset, bytes, qiov, flags); return bdrv_co_pwritev(bs->file, offset, bytes, qiov, flags);
} }
static int coroutine_fn cbw_co_flush(BlockDriverState *bs) static int coroutine_fn GRAPH_RDLOCK cbw_co_flush(BlockDriverState *bs)
{ {
if (!bs->file) { if (!bs->file) {
return 0; return 0;

4
block/file-posix.c
View File

@ -2920,8 +2920,8 @@ static void coroutine_fn check_cache_dropped(BlockDriverState *bs, Error **errp)
} }
#endif /* __linux__ */ #endif /* __linux__ */
static void coroutine_fn raw_co_invalidate_cache(BlockDriverState *bs, static void coroutine_fn GRAPH_RDLOCK
Error **errp) raw_co_invalidate_cache(BlockDriverState *bs, Error **errp)
{ {
BDRVRawState *s = bs->opaque; BDRVRawState *s = bs->opaque;
int ret; int ret;

7
block/io.c
View File

@ -933,6 +933,8 @@ int coroutine_fn bdrv_co_pwrite_sync(BdrvChild *child, int64_t offset,
int ret; int ret;
IO_CODE(); IO_CODE();
assume_graph_lock(); /* FIXME */
ret = bdrv_co_pwrite(child, offset, bytes, buf, flags); ret = bdrv_co_pwrite(child, offset, bytes, buf, flags);
if (ret < 0) { if (ret < 0) {
return ret; return ret;
@ -1041,6 +1043,8 @@ static int coroutine_fn bdrv_driver_pwritev(BlockDriverState *bs,
QEMUIOVector local_qiov; QEMUIOVector local_qiov;
int ret; int ret;
assume_graph_lock(); /* FIXME */
bdrv_check_qiov_request(offset, bytes, qiov, qiov_offset, &error_abort); bdrv_check_qiov_request(offset, bytes, qiov, qiov_offset, &error_abort);
if (!drv) { if (!drv) {
@ -1680,6 +1684,8 @@ static int coroutine_fn bdrv_co_do_pwrite_zeroes(BlockDriverState *bs,
int head = 0; int head = 0;
int tail = 0; int tail = 0;
assume_graph_lock(); /* FIXME */
int64_t max_write_zeroes = MIN_NON_ZERO(bs->bl.max_pwrite_zeroes, int64_t max_write_zeroes = MIN_NON_ZERO(bs->bl.max_pwrite_zeroes,
INT64_MAX); INT64_MAX);
int alignment = MAX(bs->bl.pwrite_zeroes_alignment, int alignment = MAX(bs->bl.pwrite_zeroes_alignment,
@ -2839,6 +2845,7 @@ int coroutine_fn bdrv_co_flush(BlockDriverState *bs)
int ret = 0; int ret = 0;
IO_CODE(); IO_CODE();
assert_bdrv_graph_readable();
bdrv_inc_in_flight(bs); bdrv_inc_in_flight(bs);
if (!bdrv_co_is_inserted(bs) || bdrv_is_read_only(bs) || if (!bdrv_co_is_inserted(bs) || bdrv_is_read_only(bs) ||

2
block/mirror.c
View File

@ -1535,7 +1535,7 @@ static int coroutine_fn bdrv_mirror_top_pwritev(BlockDriverState *bs,
return ret; return ret;
} }
static int coroutine_fn bdrv_mirror_top_flush(BlockDriverState *bs) static int coroutine_fn GRAPH_RDLOCK bdrv_mirror_top_flush(BlockDriverState *bs)
{ {
if (bs->backing == NULL) { if (bs->backing == NULL) {
/* we can be here after failed bdrv_append in mirror_start_job */ /* we can be here after failed bdrv_append in mirror_start_job */

2
block/preallocate.c
View File

@ -437,7 +437,7 @@ preallocate_co_truncate(BlockDriverState *bs, int64_t offset,
return 0; return 0;
} }
static int coroutine_fn preallocate_co_flush(BlockDriverState *bs) static int coroutine_fn GRAPH_RDLOCK preallocate_co_flush(BlockDriverState *bs)
{ {
return bdrv_co_flush(bs->file->bs); return bdrv_co_flush(bs->file->bs);
} }

5
block/qcow2.h
View File

@ -900,7 +900,10 @@ int coroutine_fn qcow2_detect_metadata_preallocation(BlockDriverState *bs);
/* qcow2-cluster.c functions */ /* qcow2-cluster.c functions */
int qcow2_grow_l1_table(BlockDriverState *bs, uint64_t min_size, int qcow2_grow_l1_table(BlockDriverState *bs, uint64_t min_size,
bool exact_size); bool exact_size);
int coroutine_fn qcow2_shrink_l1_table(BlockDriverState *bs, uint64_t max_size);
int coroutine_fn GRAPH_RDLOCK
qcow2_shrink_l1_table(BlockDriverState *bs, uint64_t max_size);
int qcow2_write_l1_entry(BlockDriverState *bs, int l1_index); int qcow2_write_l1_entry(BlockDriverState *bs, int l1_index);
int qcow2_encrypt_sectors(BDRVQcow2State *s, int64_t sector_num, int qcow2_encrypt_sectors(BDRVQcow2State *s, int64_t sector_num,
uint8_t *buf, int nb_sectors, bool enc, Error **errp); uint8_t *buf, int nb_sectors, bool enc, Error **errp);

3
block/qed-check.c
View File

@ -107,7 +107,8 @@ static unsigned int qed_check_l2_table(QEDCheck *check, QEDTable *table)
/** /**
* Descend tables and check each cluster is referenced once only * Descend tables and check each cluster is referenced once only
*/ */
static int coroutine_fn qed_check_l1_table(QEDCheck *check, QEDTable *table) static int coroutine_fn GRAPH_RDLOCK
qed_check_l1_table(QEDCheck *check, QEDTable *table)
{ {
BDRVQEDState *s = check->s; BDRVQEDState *s = check->s;
unsigned int i, num_invalid_l1 = 0; unsigned int i, num_invalid_l1 = 0;

6
block/qed-table.c
View File

@ -63,9 +63,9 @@ out:
* *
* Called with table_lock held. * Called with table_lock held.
*/ */
static int coroutine_fn qed_write_table(BDRVQEDState *s, uint64_t offset, static int coroutine_fn GRAPH_RDLOCK
QEDTable *table, unsigned int index, qed_write_table(BDRVQEDState *s, uint64_t offset, QEDTable *table,
unsigned int n, bool flush) unsigned int index, unsigned int n, bool flush)
{ {
unsigned int sector_mask = BDRV_SECTOR_SIZE / sizeof(uint64_t) - 1; unsigned int sector_mask = BDRV_SECTOR_SIZE / sizeof(uint64_t) - 1;
unsigned int start, end, i; unsigned int start, end, i;

44
block/qed.c
View File

@ -395,8 +395,8 @@ static void bdrv_qed_init_state(BlockDriverState *bs)
} }
/* Called with table_lock held. */ /* Called with table_lock held. */
static int coroutine_fn bdrv_qed_do_open(BlockDriverState *bs, QDict *options, static int coroutine_fn GRAPH_RDLOCK
int flags, Error **errp) bdrv_qed_do_open(BlockDriverState *bs, QDict *options, int flags, Error **errp)
{ {
BDRVQEDState *s = bs->opaque; BDRVQEDState *s = bs->opaque;
QEDHeader le_header; QEDHeader le_header;
@ -557,7 +557,7 @@ typedef struct QEDOpenCo {
int ret; int ret;
} QEDOpenCo; } QEDOpenCo;
static void coroutine_fn bdrv_qed_open_entry(void *opaque) static void coroutine_fn GRAPH_RDLOCK bdrv_qed_open_entry(void *opaque)
{ {
QEDOpenCo *qoc = opaque; QEDOpenCo *qoc = opaque;
BDRVQEDState *s = qoc->bs->opaque; BDRVQEDState *s = qoc->bs->opaque;
@ -579,6 +579,8 @@ static int bdrv_qed_open(BlockDriverState *bs, QDict *options, int flags,
}; };
int ret; int ret;
assume_graph_lock(); /* FIXME */
ret = bdrv_open_file_child(NULL, options, "file", bs, errp); ret = bdrv_open_file_child(NULL, options, "file", bs, errp);
if (ret < 0) { if (ret < 0) {
return ret; return ret;
@ -995,7 +997,7 @@ static void coroutine_fn qed_aio_complete(QEDAIOCB *acb)
* *
* Called with table_lock held. * Called with table_lock held.
*/ */
static int coroutine_fn qed_aio_write_l1_update(QEDAIOCB *acb) static int coroutine_fn GRAPH_RDLOCK qed_aio_write_l1_update(QEDAIOCB *acb)
{ {
BDRVQEDState *s = acb_to_s(acb); BDRVQEDState *s = acb_to_s(acb);
CachedL2Table *l2_table = acb->request.l2_table; CachedL2Table *l2_table = acb->request.l2_table;
@ -1025,7 +1027,8 @@ static int coroutine_fn qed_aio_write_l1_update(QEDAIOCB *acb)
* *
* Called with table_lock held. * Called with table_lock held.
*/ */
static int coroutine_fn qed_aio_write_l2_update(QEDAIOCB *acb, uint64_t offset) static int coroutine_fn GRAPH_RDLOCK
qed_aio_write_l2_update(QEDAIOCB *acb, uint64_t offset)
{ {
BDRVQEDState *s = acb_to_s(acb); BDRVQEDState *s = acb_to_s(acb);
bool need_alloc = acb->find_cluster_ret == QED_CLUSTER_L1; bool need_alloc = acb->find_cluster_ret == QED_CLUSTER_L1;
@ -1081,7 +1084,7 @@ static int coroutine_fn qed_aio_write_main(QEDAIOCB *acb)
* *
* Called with table_lock held. * Called with table_lock held.
*/ */
static int coroutine_fn qed_aio_write_cow(QEDAIOCB *acb) static int coroutine_fn GRAPH_RDLOCK qed_aio_write_cow(QEDAIOCB *acb)
{ {
BDRVQEDState *s = acb_to_s(acb); BDRVQEDState *s = acb_to_s(acb);
uint64_t start, len, offset; uint64_t start, len, offset;
@ -1159,7 +1162,8 @@ static bool qed_should_set_need_check(BDRVQEDState *s)
* *
* Called with table_lock held. * Called with table_lock held.
*/ */
static int coroutine_fn qed_aio_write_alloc(QEDAIOCB *acb, size_t len) static int coroutine_fn GRAPH_RDLOCK
qed_aio_write_alloc(QEDAIOCB *acb, size_t len)
{ {
BDRVQEDState *s = acb_to_s(acb); BDRVQEDState *s = acb_to_s(acb);
int ret; int ret;
@ -1265,8 +1269,8 @@ out:
* *
* Called with table_lock held. * Called with table_lock held.
*/ */
static int coroutine_fn qed_aio_write_data(void *opaque, int ret, static int coroutine_fn GRAPH_RDLOCK
uint64_t offset, size_t len) qed_aio_write_data(void *opaque, int ret, uint64_t offset, size_t len)
{ {
QEDAIOCB *acb = opaque; QEDAIOCB *acb = opaque;
@ -1336,7 +1340,7 @@ static int coroutine_fn qed_aio_read_data(void *opaque, int ret,
/** /**
* Begin next I/O or complete the request * Begin next I/O or complete the request
*/ */
static int coroutine_fn qed_aio_next_io(QEDAIOCB *acb) static int coroutine_fn GRAPH_RDLOCK qed_aio_next_io(QEDAIOCB *acb)
{ {
BDRVQEDState *s = acb_to_s(acb); BDRVQEDState *s = acb_to_s(acb);
uint64_t offset; uint64_t offset;
@ -1381,9 +1385,9 @@ static int coroutine_fn qed_aio_next_io(QEDAIOCB *acb)
return ret; return ret;
} }
static int coroutine_fn qed_co_request(BlockDriverState *bs, int64_t sector_num, static int coroutine_fn GRAPH_RDLOCK
QEMUIOVector *qiov, int nb_sectors, qed_co_request(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov,
int flags) int nb_sectors, int flags)
{ {
QEDAIOCB acb = { QEDAIOCB acb = {
.bs = bs, .bs = bs,
@ -1404,6 +1408,7 @@ static int coroutine_fn bdrv_qed_co_readv(BlockDriverState *bs,
int64_t sector_num, int nb_sectors, int64_t sector_num, int nb_sectors,
QEMUIOVector *qiov) QEMUIOVector *qiov)
{ {
assume_graph_lock(); /* FIXME */
return qed_co_request(bs, sector_num, qiov, nb_sectors, 0); return qed_co_request(bs, sector_num, qiov, nb_sectors, 0);
} }
@ -1411,6 +1416,7 @@ static int coroutine_fn bdrv_qed_co_writev(BlockDriverState *bs,
int64_t sector_num, int nb_sectors, int64_t sector_num, int nb_sectors,
QEMUIOVector *qiov, int flags) QEMUIOVector *qiov, int flags)
{ {
assume_graph_lock(); /* FIXME */
return qed_co_request(bs, sector_num, qiov, nb_sectors, QED_AIOCB_WRITE); return qed_co_request(bs, sector_num, qiov, nb_sectors, QED_AIOCB_WRITE);
} }
@ -1421,6 +1427,8 @@ static int coroutine_fn bdrv_qed_co_pwrite_zeroes(BlockDriverState *bs,
{ {
BDRVQEDState *s = bs->opaque; BDRVQEDState *s = bs->opaque;
assume_graph_lock(); /* FIXME */
/* /*
* Zero writes start without an I/O buffer. If a buffer becomes necessary * Zero writes start without an I/O buffer. If a buffer becomes necessary
* then it will be allocated during request processing. * then it will be allocated during request processing.
@ -1571,8 +1579,8 @@ static int bdrv_qed_change_backing_file(BlockDriverState *bs,
return ret; return ret;
} }
static void coroutine_fn bdrv_qed_co_invalidate_cache(BlockDriverState *bs, static void coroutine_fn GRAPH_RDLOCK
Error **errp) bdrv_qed_co_invalidate_cache(BlockDriverState *bs, Error **errp)
{ {
BDRVQEDState *s = bs->opaque; BDRVQEDState *s = bs->opaque;
int ret; int ret;
@ -1588,9 +1596,9 @@ static void coroutine_fn bdrv_qed_co_invalidate_cache(BlockDriverState *bs,
} }
} }
static int coroutine_fn bdrv_qed_co_check(BlockDriverState *bs, static int coroutine_fn GRAPH_RDLOCK
BdrvCheckResult *result, bdrv_qed_co_check(BlockDriverState *bs, BdrvCheckResult *result,
BdrvCheckMode fix) BdrvCheckMode fix)
{ {
BDRVQEDState *s = bs->opaque; BDRVQEDState *s = bs->opaque;
int ret; int ret;

29
block/qed.h
View File

@ -201,20 +201,25 @@ void qed_commit_l2_cache_entry(L2TableCache *l2_cache, CachedL2Table *l2_table);
* Table I/O functions * Table I/O functions
*/ */
int coroutine_fn qed_read_l1_table_sync(BDRVQEDState *s); 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); int coroutine_fn GRAPH_RDLOCK
int coroutine_fn qed_write_l1_table_sync(BDRVQEDState *s, unsigned int index, qed_write_l1_table(BDRVQEDState *s, unsigned int index, unsigned int n);
unsigned int n);
int coroutine_fn GRAPH_RDLOCK
qed_write_l1_table_sync(BDRVQEDState *s, unsigned int index, unsigned int n);
int coroutine_fn qed_read_l2_table_sync(BDRVQEDState *s, QEDRequest *request, int coroutine_fn qed_read_l2_table_sync(BDRVQEDState *s, QEDRequest *request,
uint64_t offset); uint64_t offset);
int coroutine_fn qed_read_l2_table(BDRVQEDState *s, QEDRequest *request, int coroutine_fn qed_read_l2_table(BDRVQEDState *s, QEDRequest *request,
uint64_t offset); uint64_t offset);
int coroutine_fn qed_write_l2_table(BDRVQEDState *s, QEDRequest *request,
unsigned int index, unsigned int n, int coroutine_fn GRAPH_RDLOCK
bool flush); qed_write_l2_table(BDRVQEDState *s, QEDRequest *request, unsigned int index,
int coroutine_fn qed_write_l2_table_sync(BDRVQEDState *s, QEDRequest *request, unsigned int n, bool flush);
unsigned int index, unsigned int n,
bool flush); int coroutine_fn GRAPH_RDLOCK
qed_write_l2_table_sync(BDRVQEDState *s, QEDRequest *request,
unsigned int index, unsigned int n, bool flush);
/** /**
* Cluster functions * Cluster functions
@ -226,7 +231,9 @@ int coroutine_fn qed_find_cluster(BDRVQEDState *s, QEDRequest *request,
/** /**
* Consistency check * Consistency check
*/ */
int coroutine_fn qed_check(BDRVQEDState *s, BdrvCheckResult *result, bool fix); int coroutine_fn GRAPH_RDLOCK
qed_check(BDRVQEDState *s, BdrvCheckResult *result, bool fix);
QEDTable *qed_alloc_table(BDRVQEDState *s); QEDTable *qed_alloc_table(BDRVQEDState *s);

2
block/quorum.c
View File

@ -778,7 +778,7 @@ static int64_t coroutine_fn quorum_co_getlength(BlockDriverState *bs)
return result; return result;
} }
static coroutine_fn int quorum_co_flush(BlockDriverState *bs) static coroutine_fn GRAPH_RDLOCK int quorum_co_flush(BlockDriverState *bs)
{ {
BDRVQuorumState *s = bs->opaque; BDRVQuorumState *s = bs->opaque;
QuorumVoteVersion *winner = NULL; QuorumVoteVersion *winner = NULL;

2
block/throttle.c
View File

@ -162,7 +162,7 @@ static int coroutine_fn throttle_co_pwritev_compressed(BlockDriverState *bs,
BDRV_REQ_WRITE_COMPRESSED); BDRV_REQ_WRITE_COMPRESSED);
} }
static int coroutine_fn throttle_co_flush(BlockDriverState *bs) static int coroutine_fn GRAPH_RDLOCK throttle_co_flush(BlockDriverState *bs)
{ {
return bdrv_co_flush(bs->file->bs); return bdrv_co_flush(bs->file->bs);
} }

6
block/vmdk.c
View File

@ -1484,8 +1484,8 @@ exit:
return ret; return ret;
} }
static int coroutine_fn vmdk_L2update(VmdkExtent *extent, VmdkMetaData *m_data, static int coroutine_fn GRAPH_RDLOCK
uint32_t offset) vmdk_L2update(VmdkExtent *extent, VmdkMetaData *m_data, uint32_t offset)
{ {
offset = cpu_to_le32(offset); offset = cpu_to_le32(offset);
/* update L2 table */ /* update L2 table */
@ -2028,6 +2028,8 @@ static int coroutine_fn vmdk_pwritev(BlockDriverState *bs, uint64_t offset,
uint64_t bytes_done = 0; uint64_t bytes_done = 0;
VmdkMetaData m_data; VmdkMetaData m_data;
assume_graph_lock(); /* FIXME */
if (DIV_ROUND_UP(offset, BDRV_SECTOR_SIZE) > bs->total_sectors) { if (DIV_ROUND_UP(offset, BDRV_SECTOR_SIZE) > bs->total_sectors) {
error_report("Wrong offset: offset=0x%" PRIx64 error_report("Wrong offset: offset=0x%" PRIx64
" total_sectors=0x%" PRIx64, " total_sectors=0x%" PRIx64,

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

@ -101,7 +101,7 @@ int coroutine_fn GRAPH_RDLOCK
bdrv_co_ioctl(BlockDriverState *bs, int req, void *buf); bdrv_co_ioctl(BlockDriverState *bs, int req, void *buf);
/* Ensure contents are flushed to disk. */ /* Ensure contents are flushed to disk. */
int coroutine_fn bdrv_co_flush(BlockDriverState *bs); int coroutine_fn GRAPH_RDLOCK bdrv_co_flush(BlockDriverState *bs);
int coroutine_fn bdrv_co_pdiscard(BdrvChild *child, int64_t offset, int coroutine_fn bdrv_co_pdiscard(BdrvChild *child, int64_t offset,
int64_t bytes); int64_t bytes);

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

@ -477,8 +477,8 @@ struct BlockDriver {
BlockAIOCB *(*bdrv_aio_pwritev)(BlockDriverState *bs, BlockAIOCB *(*bdrv_aio_pwritev)(BlockDriverState *bs,
int64_t offset, int64_t bytes, QEMUIOVector *qiov, int64_t offset, int64_t bytes, QEMUIOVector *qiov,
BdrvRequestFlags flags, BlockCompletionFunc *cb, void *opaque); BdrvRequestFlags flags, BlockCompletionFunc *cb, void *opaque);
BlockAIOCB *(*bdrv_aio_flush)(BlockDriverState *bs, BlockAIOCB * GRAPH_RDLOCK_PTR (*bdrv_aio_flush)(
BlockCompletionFunc *cb, void *opaque); BlockDriverState *bs, BlockCompletionFunc *cb, void *opaque);
BlockAIOCB *(*bdrv_aio_pdiscard)(BlockDriverState *bs, BlockAIOCB *(*bdrv_aio_pdiscard)(BlockDriverState *bs,
int64_t offset, int bytes, int64_t offset, int bytes,
BlockCompletionFunc *cb, void *opaque); BlockCompletionFunc *cb, void *opaque);
@ -646,7 +646,7 @@ struct BlockDriver {
* layers, if needed. This function is needed for deterministic * layers, if needed. This function is needed for deterministic
* synchronization of the flush finishing callback. * synchronization of the flush finishing callback.
*/ */
int coroutine_fn (*bdrv_co_flush)(BlockDriverState *bs); int coroutine_fn GRAPH_RDLOCK_PTR (*bdrv_co_flush)(BlockDriverState *bs);
/* Delete a created file. */ /* Delete a created file. */
int coroutine_fn (*bdrv_co_delete_file)(BlockDriverState *bs, int coroutine_fn (*bdrv_co_delete_file)(BlockDriverState *bs,
@ -656,14 +656,16 @@ struct BlockDriver {
* Flushes all data that was already written to the OS all the way down to * Flushes all data that was already written to the OS all the way down to
* the disk (for example file-posix.c calls fsync()). * the disk (for example file-posix.c calls fsync()).
*/ */
int coroutine_fn (*bdrv_co_flush_to_disk)(BlockDriverState *bs); int coroutine_fn GRAPH_RDLOCK_PTR (*bdrv_co_flush_to_disk)(
BlockDriverState *bs);
/* /*
* Flushes all internal caches to the OS. The data may still sit in a * Flushes all internal caches to the OS. The data may still sit in a
* writeback cache of the host OS, but it will survive a crash of the qemu * writeback cache of the host OS, but it will survive a crash of the qemu
* process. * process.
*/ */
int coroutine_fn (*bdrv_co_flush_to_os)(BlockDriverState *bs); int coroutine_fn GRAPH_RDLOCK_PTR (*bdrv_co_flush_to_os)(
BlockDriverState *bs);
/* /*
* Truncate @bs to @offset bytes using the given @prealloc mode * Truncate @bs to @offset bytes using the given @prealloc mode