block: Fix blk->in_flight during blk_wait_while_drained()
v3 cover block: Fix blk->in_flight during blk_wait_while_drained()
This fixes deadlocks when draining a BlockBackend in an iothread that receives new requests at the same time.
v3:
- Call blk_inc/dec_in_flight() in blk_prw() rather than inside the coroutines [Max]
v2:
- Rework the whole thing so that direct callers of blk_co_*() aren't broken after the series [Max]
Kevin Wolf (3):
block-backend: Reorder flush/pdiscard function definitions
block: Increase BB.in_flight for coroutine and sync interfaces
block: Fix blk->in_flight during blk_wait_while_drained()
include/sysemu/block-backend.h | 1 - block/block-backend.c | 206 ++++++++++++++++++++------------- 2 files changed, 128 insertions(+), 79 deletions(-)
Signature · 1 line
2.20.1
PATCH v3 1/3 block-backend: Reorder flush/pdiscard function definitions
Move all variants of the flush/pdiscard functions to a single place and put the blk_co_*() version first because it is called by all other variants (and will become static in the next patch).
--- block/block-backend.c | 92 +++++++++++++++++++++---------------------- 1 file changed, 46 insertions(+), 46 deletions(-)
block/block-backend.c +46 -46
@@ -1488,38 +1488,6 @@ BlockAIOCB *blk_aio_pwritev(BlockBackend *blk, int64_t offset, blk_aio_write_entry, flags, cb, opaque); } -static void blk_aio_flush_entry (void *opaque) -{ -BlkAioEmAIOCB *acb = opaque; -BlkRwCo *rwco = &acb->rwco; - - rwco->ret =blk_co_flush (rwco->blk); -blk_aio_complete (acb); -} - -BlockAIOCB *blk_aio_flush (BlockBackend *blk, -BlockCompletionFunc *cb,void *opaque) -{ -return blk_aio_prwv (blk,0 ,0 ,NULL , blk_aio_flush_entry,0 , cb, opaque); -} - -static void blk_aio_pdiscard_entry (void *opaque) -{ -BlkAioEmAIOCB *acb = opaque; -BlkRwCo *rwco = &acb->rwco; - - rwco->ret =blk_co_pdiscard (rwco->blk, rwco->offset, acb->bytes); -blk_aio_complete (acb); -} - -BlockAIOCB *blk_aio_pdiscard (BlockBackend *blk, -int64_t offset,int bytes, -BlockCompletionFunc *cb,void *opaque) -{ -return blk_aio_prwv (blk, offset, bytes,NULL , blk_aio_pdiscard_entry,0 , - cb, opaque); -} -void blk_aio_cancel (BlockAIOCB *acb) {bdrv_aio_cancel (acb);
@@ -1586,6 +1554,37 @@ int blk_co_pdiscard(BlockBackend *blk, int64_t offset, int bytes)return bdrv_co_pdiscard (blk->root, offset, bytes); } +static void blk_aio_pdiscard_entry (void *opaque) +{ +BlkAioEmAIOCB *acb = opaque; +BlkRwCo *rwco = &acb->rwco; + + rwco->ret =blk_co_pdiscard (rwco->blk, rwco->offset, acb->bytes); +blk_aio_complete (acb); +} + +BlockAIOCB *blk_aio_pdiscard (BlockBackend *blk, +int64_t offset,int bytes, +BlockCompletionFunc *cb,void *opaque) +{ +return blk_aio_prwv (blk, offset, bytes,NULL , blk_aio_pdiscard_entry,0 , + cb, opaque); +} + +static void blk_pdiscard_entry (void *opaque) +{ +BlkRwCo *rwco = opaque; +QEMUIOVector *qiov = rwco->iobuf; + + rwco->ret =blk_co_pdiscard (rwco->blk, rwco->offset, qiov->size); +aio_wait_kick (); +} + +int blk_pdiscard (BlockBackend *blk,int64_t offset,int bytes) +{ +return blk_prw (blk, offset,NULL , bytes, blk_pdiscard_entry,0 ); +} +int blk_co_flush (BlockBackend *blk) {blk_wait_while_drained (blk);
@@ -1597,6 +1596,21 @@ int blk_co_flush(BlockBackend *blk)return bdrv_co_flush (blk_bs (blk)); } +static void blk_aio_flush_entry (void *opaque) +{ +BlkAioEmAIOCB *acb = opaque; +BlkRwCo *rwco = &acb->rwco; + + rwco->ret =blk_co_flush (rwco->blk); +blk_aio_complete (acb); +} + +BlockAIOCB *blk_aio_flush (BlockBackend *blk, +BlockCompletionFunc *cb,void *opaque) +{ +return blk_aio_prwv (blk,0 ,0 ,NULL , blk_aio_flush_entry,0 , cb, opaque); +} +static void blk_flush_entry (void *opaque) {BlkRwCo *rwco = opaque;
@@ -2083,20 +2097,6 @@ int blk_truncate(BlockBackend *blk, int64_t offset, bool exact,return bdrv_truncate (blk->root, offset, exact, prealloc, errp); } -static void blk_pdiscard_entry (void *opaque) -{ -BlkRwCo *rwco = opaque; -QEMUIOVector *qiov = rwco->iobuf; - - rwco->ret =blk_co_pdiscard (rwco->blk, rwco->offset, qiov->size); -aio_wait_kick (); -} - -int blk_pdiscard (BlockBackend *blk,int64_t offset,int bytes) -{ -return blk_prw (blk, offset,NULL , bytes, blk_pdiscard_entry,0 ); -} -int blk_save_vmstate (BlockBackend *blk,const uint8_t *buf,int64_t pos,int size) {
Signature · 1 line
2.20.1
PATCH v3 2/3 block: Increase BB.in_flight for coroutine and sync interfaces
In reply to Kevin WolfExternal callers of blk_co_*() and of the synchronous blk_*() functions don't currently increase the BlockBackend.in_flight counter, but calls from blk_aio_*() do, so there is an inconsistency whether the counter has been increased or not.
This patch moves the actual operations to static functions that can later know they will always be called with in_flight increased exactly once, even for external callers using the blk_co_*() coroutine interfaces.
If the public blk_co_*() interface is unused, remove it.
--- include/sysemu/block-backend.h | 1 - block/block-backend.c | 103 +++++++++++++++++++++++++-------- 2 files changed, 80 insertions(+), 24 deletions(-)
include/sysemu/block-backend.h +0 -1
@@ -171,7 +171,6 @@ BlockAIOCB *blk_aio_pdiscard(BlockBackend *blk, int64_t offset, int bytes, BlockCompletionFunc *cb, void *opaque);void blk_aio_cancel (BlockAIOCB *acb);void blk_aio_cancel_async (BlockAIOCB *acb); -int blk_co_ioctl (BlockBackend *blk,unsigned long int req,void *buf);int blk_ioctl (BlockBackend *blk,unsigned long int req,void *buf);BlockAIOCB *blk_aio_ioctl (BlockBackend *blk,unsigned long int req,void *buf,BlockCompletionFunc *cb,void *opaque);
block/block-backend.c +80 -23
219 lines not on this page · raw message
Signature · 1 line
2.20.1
Re: [PATCH for-5.0 v3 2/3] block: Increase BB.in_flight for coroutine and sync interfaces
Quoted 10 lines · Kevin Wolf
External callers of blk_co_*() and of the synchronous blk_*() functions don't currently increase the BlockBackend.in_flight counter, but calls from blk_aio_*() do, so there is an inconsistency whether the counter has been increased or not.
This patch moves the actual operations to static functions that can later know they will always be called with
in_flightincreased exactly once, even for external callers using the blk_co_*() coroutine interfaces.
Quoted 7 lines
If the public blk_co_*() interface is unused, remove it.
Signed-off-by Kevin Wolf <[email protected]>--- include/sysemu/block-backend.h | 1 - block/block-backend.c | 103 +++++++++++++++++++++++++-------- 2 files changed, 80 insertions(+), 24 deletions(-)
Thanks!
Re: [PATCH for-5.0 v3 2/3] block: Increase BB.in_flight for coroutine and sync interfaces
In reply to Kevin WolfQuoted 5 lines · Kevin Wolf
External callers of blk_co_*() and of the synchronous blk_*() functions don't currently increase the BlockBackend.in_flight counter, but calls from blk_aio_*() do, so there is an inconsistency whether the counter has been increased or not.
Quoted 8 lines
This patch moves the actual operations to static functions that can later know they will always be called with
in_flightincreased exactly once, even for external callers using the blk_co_*() coroutine interfaces.If the public blk_co_*() interface is unused, remove it.
Signed-off-by Kevin Wolf <[email protected]>
side question:
Should we inc/dec in blk_make_zero, blk_truncate?
Signature · 2 lines
Best regards, Vladimir
Re: [PATCH for-5.0 v3 2/3] block: Increase BB.in_flight for coroutine and sync interfaces
Am 07.04.2020 um 16:22 hat Vladimir Sementsov-Ogievskiy geschrieben:
Quoted 13 lines
Quoted 12 lines · Kevin Wolf
External callers of blk_co_*() and of the synchronous blk_*() functions don't currently increase the BlockBackend.in_flight counter, but calls from blk_aio_*() do, so there is an inconsistency whether the counter has been increased or not.
This patch moves the actual operations to static functions that can later know they will always be called with
in_flightincreased exactly once, even for external callers using the blk_co_*() coroutine interfaces.If the public blk_co_*() interface is unused, remove it.
Quoted 7 lines
Quoted 1 line
Signed-off-by Kevin Wolf <[email protected]>Reviewed-by Vladimir Sementsov-Ogievskiy <[email protected]>side question:
Should we inc/dec in
blk_make_zero,blk_truncate?
I don't think it's necessary. They call into their bdrv_* counterpart immediately, so the node-level counter should be enough.
Kevin
Re: [PATCH for-5.0 v3 2/3] block: Increase BB.in_flight for coroutine and sync interfaces
Quoted 16 lines · Kevin Wolf
Am 07.04.2020 um 16:22 hat Vladimir Sementsov-Ogievskiy geschrieben:
Quoted 15 lines
Quoted 13 lines · Kevin Wolf
External callers of blk_co_*() and of the synchronous blk_*() functions don't currently increase the BlockBackend.in_flight counter, but calls from blk_aio_*() do, so there is an inconsistency whether the counter has been increased or not.
This patch moves the actual operations to static functions that can later know they will always be called with
in_flightincreased exactly once, even for external callers using the blk_co_*() coroutine interfaces.If the public blk_co_*() interface is unused, remove it.
Signed-off-by Kevin Wolf <[email protected]>
Quoted 9 lines
Quoted 5 lines
Reviewed-by Vladimir Sementsov-Ogievskiy <[email protected]>side question:
Should we inc/dec in
blk_make_zero,blk_truncate?I don't think it's necessary. They call into their bdrv_* counterpart immediately, so the node-level counter should be enough.
bdrv_make_zero is not one request, it does block_status/pwrite_zeroes in a loop. So drained section may occur during bdrv_make_zero. Possibly, nothing bad in it?
blk_truncate may do coroutine_enter before incrementing node-level counter, which may only schedule it..
Signature · 2 lines
Best regards, Vladimir
Re: [PATCH for-5.0 v3 2/3] block: Increase BB.in_flight for coroutine and sync interfaces
Am 07.04.2020 um 16:56 hat Vladimir Sementsov-Ogievskiy geschrieben:
Quoted 23 lines
Quoted 22 lines · Kevin Wolf
Am 07.04.2020 um 16:22 hat Vladimir Sementsov-Ogievskiy geschrieben:
Quoted 20 lines
Quoted 5 lines · Kevin Wolf
External callers of blk_co_*() and of the synchronous blk_*() functions don't currently increase the BlockBackend.in_flight counter, but calls from blk_aio_*() do, so there is an inconsistency whether the counter has been increased or not.
Quoted 8 lines
This patch moves the actual operations to static functions that can later know they will always be called with
in_flightincreased exactly once, even for external callers using the blk_co_*() coroutine interfaces.If the public blk_co_*() interface is unused, remove it.
Signed-off-by Kevin Wolf <[email protected]>Reviewed-by Vladimir Sementsov-Ogievskiy <[email protected]>side question:
Should we inc/dec in
blk_make_zero,blk_truncate?
Quoted 7 lines
Quoted 3 lines
I don't think it's necessary. They call into their bdrv_* counterpart immediately, so the node-level counter should be enough.
bdrv_make_zerois not one request, it does block_status/pwrite_zeroes in a loop. So drained section may occur duringbdrv_make_zero. Possibly, nothing bad in it?
It would potentially be a problem if it were called in coroutine context. But it's a synchronous function that must be called in the main thread (and also only used in qemu-img), so I don't see how drain could happen while it runs.
If we did want to make it safe for use in coroutine context, it would be by using bdrv_inc/dec_in_flight() in bdrv_make_zero().
Quoted 2 lines
blk_truncatemay docoroutine_enterbefore incrementing node-level counter, which may only schedule it..
This is bdrv_truncate(), not blk_truncate(). If you address it in blk_truncate(), you miss the direct callers of bdrv_truncate().
But you're right that it could potentially be a problem. Not sure if it really is, but maybe better safe than sorry, so if you want to send a patch, go ahead.
Kevin
Re: [PATCH for-5.0 v3 2/3] block: Increase BB.in_flight for coroutine and sync interfaces
Quoted 43 lines · Kevin Wolf
Am 07.04.2020 um 16:56 hat Vladimir Sementsov-Ogievskiy geschrieben:
Quoted 23 lines
Quoted 22 lines · Kevin Wolf
Am 07.04.2020 um 16:22 hat Vladimir Sementsov-Ogievskiy geschrieben:
Quoted 20 lines
Quoted 5 lines · Kevin Wolf
External callers of blk_co_*() and of the synchronous blk_*() functions don't currently increase the BlockBackend.in_flight counter, but calls from blk_aio_*() do, so there is an inconsistency whether the counter has been increased or not.
Quoted 8 lines
This patch moves the actual operations to static functions that can later know they will always be called with
in_flightincreased exactly once, even for external callers using the blk_co_*() coroutine interfaces.If the public blk_co_*() interface is unused, remove it.
Signed-off-by Kevin Wolf <[email protected]>Reviewed-by Vladimir Sementsov-Ogievskiy <[email protected]>side question:
Should we inc/dec in
blk_make_zero,blk_truncate?Quoted 7 lines
Quoted 3 lines
I don't think it's necessary. They call into their bdrv_* counterpart immediately, so the node-level counter should be enough.
bdrv_make_zerois not one request, it does block_status/pwrite_zeroes in a loop. So drained section may occur duringbdrv_make_zero. Possibly, nothing bad in it?It would potentially be a problem if it were called in coroutine context. But it's a synchronous function that must be called in the main thread (and also only used in qemu-img), so I don't see how drain could happen while it runs.
If we did want to make it safe for use in coroutine context, it would be by using bdrv_inc/dec_in_flight() in
bdrv_make_zero().Quoted 2 lines
blk_truncatemay docoroutine_enterbefore incrementing node-level counter, which may only schedule it..
Quoted 7 lines
This is
bdrv_truncate(), notblk_truncate(). If you address it inblk_truncate(), you miss the direct callers ofbdrv_truncate().But you're right that it could potentially be a problem. Not sure if it really is, but maybe better safe than sorry, so if you want to send a patch, go ahead.
Hmm. Same thing may be said about all other coroutine-enter wrappers in block/io.c. OK, I'll make a patch.
Signature · 2 lines
Best regards, Vladimir
PATCH v3 3/3 block: Fix blk->in_flight during blk_wait_while_drained()
In reply to Kevin WolfWaiting in blk_wait_while_drained() while blk->in_flight is increased for the current request is wrong because it will cause the drain operation to deadlock.
This patch makes sure that blk_wait_while_drained() is called with blk->in_flight increased exactly once for the current request, and that it temporarily decreases the counter while it waits.
--- block/block-backend.c | 17 +++++------------ 1 file changed, 5 insertions(+), 12 deletions(-)
block/block-backend.c +5 -12
@@ -1140,10 +1140,15 @@ static int blk_check_byte_request(BlockBackend *blk, int64_t offset,return 0 ; } +/* To be called between exactly one pair of blk_inc/dec_in_flight() */ static void coroutine_fn blk_wait_while_drained(BlockBackend *blk) { +assert (blk->in_flight >0 ); +if (blk->quiesce_counter && !blk->disable_request_queuing) { +blk_dec_in_flight (blk);qemu_co_queue_wait (&blk->queued_requests,NULL ); +blk_inc_in_flight (blk); } }
@@ -1418,12 +1423,6 @@ static void blk_aio_read_entry(void *opaque)BlkRwCo *rwco = &acb->rwco;QEMUIOVector *qiov = rwco->iobuf; -if (rwco->blk->quiesce_counter) { -blk_dec_in_flight (rwco->blk); -blk_wait_while_drained (rwco->blk); -blk_inc_in_flight (rwco->blk); - } -assert (qiov->size == acb->bytes); rwco->ret =blk_do_preadv (rwco->blk, rwco->offset, acb->bytes, qiov, rwco->flags);
@@ -1436,12 +1435,6 @@ static void blk_aio_write_entry(void *opaque)BlkRwCo *rwco = &acb->rwco;QEMUIOVector *qiov = rwco->iobuf; -if (rwco->blk->quiesce_counter) { -blk_dec_in_flight (rwco->blk); -blk_wait_while_drained (rwco->blk); -blk_inc_in_flight (rwco->blk); - } -assert (!qiov || qiov->size == acb->bytes); rwco->ret =blk_do_pwritev_part (rwco->blk, rwco->offset, acb->bytes, qiov,0 , rwco->flags);
Signature · 1 line
2.20.1