The following changes since commit 143c2e0432859826c9e8d5b2baa307355f1a5332:

Merge remote-tracking branch 'remotes/maxreitz/tags/pull-block-2021-07-19' into staging (2021-07-19 19:06:05 +0100)

are available in the Git repository at:

for you to fetch changes up to d21471696b07f30cb00453709d055a25c1afde85:

iotests/307: Test iothread conflict for exports (2021-07-20 16:49:50 +0200)

Kevin Wolf (1):

block: Add option to use driver whitelist even in tools

Lukas Straub (4):

replication: Remove s->active_disk

replication: Reduce usage of s->hidden_disk and s->secondary_disk

replication: Properly attach children

replication: Remove workaround

Max Reitz (2):

block/export: Conditionally ignore set-context error

iotests/307: Test iothread conflict for exports

Vladimir Sementsov-Ogievskiy (4):

block/mirror: set .co for active-write MirrorOp objects

iotest 151: add test-case that shows active mirror dead-lock

block/mirror: fix active mirror dead-lock in mirror_wait_on_conflicts

block/vvfat: fix: drop backing

configure | 14 +++++-

block.c | 3 ++

block/export/export.c | 5 +-

block/mirror.c | 13 ++++++

block/replication.c | 111 +++++++++++++++++++++++++++------------------

block/vvfat.c | 43 ++----------------

meson.build | 1 +

tests/qemu-iotests/151 | 54 +++++++++++++++++++++-

tests/qemu-iotests/151.out | 4 +-

tests/qemu-iotests/307 | 15 ++++++

tests/qemu-iotests/307.out | 8 ++++

11 files changed, 182 insertions(+), 89 deletions(-)

This field is unused, but it very helpful for debugging.

Message-Id: <20210702211636.228981-2-vsementsov@virtuozzo.com>

Signed-off-by: Kevin Wolf <kwolf@redhat.com>

block/mirror.c | 1 +

1 file changed, 1 insertion(+)

diff --git a/block/mirror.c b/block/mirror.c

--- a/block/mirror.c

+++ b/block/mirror.c

@@ -XXX,XX +XXX,XX @@ static MirrorOp *coroutine_fn active_write_prepare(MirrorBlockJob *s,

.bytes = bytes,

.is_active_write = true,

.is_in_flight = true,

+ .co = qemu_coroutine_self(),

};

qemu_co_queue_init(&op->waiting_requests);

QTAILQ_INSERT_TAIL(&s->ops_in_flight, op, next);

2.31.1

There is a dead-lock in active mirror: when we have parallel

intersecting requests (note that non intersecting requests may be

considered intersecting after aligning to mirror granularity), it may

happen that request A waits request B in mirror_wait_on_conflicts() and

request B waits for A.

Look at the test for details. Test now dead-locks, that's why it's

disabled. Next commit will fix mirror and enable the test.

tests/qemu-iotests/151 | 62 ++++++++++++++++++++++++++++++++++++--

tests/qemu-iotests/151.out | 4 +--

2 files changed, 62 insertions(+), 4 deletions(-)

diff --git a/tests/qemu-iotests/151 b/tests/qemu-iotests/151

--- a/tests/qemu-iotests/151

+++ b/tests/qemu-iotests/151

@@ -XXX,XX +XXX,XX @@ class TestActiveMirror(iotests.QMPTestCase):

'if': 'none',

'node-name': 'source-node',

'driver': iotests.imgfmt,

- 'file': {'driver': 'file',

- 'filename': source_img}}

+ 'file': {'driver': 'blkdebug',

+ 'image': {'driver': 'file',

+ 'filename': source_img}}}

blk_target = {'node-name': 'target-node',

'driver': iotests.imgfmt,

@@ -XXX,XX +XXX,XX @@ class TestActiveMirror(iotests.QMPTestCase):

self.potential_writes_in_flight = False

+ def testIntersectingActiveIO(self):

+ # FIXME: test-case is dead-locking. To reproduce dead-lock just drop

+ # this return statement

+ return

+

+ # Fill the source image

+ result = self.vm.hmp_qemu_io('source', 'write -P 1 0 2M')

+

+ # Start the block job (very slowly)

+ result = self.vm.qmp('blockdev-mirror',

+ job_id='mirror',

+ filter_node_name='mirror-node',

+ device='source-node',

+ target='target-node',

+ sync='full',

+ copy_mode='write-blocking',

+ speed=1)

+

+ self.vm.hmp_qemu_io('source', 'break write_aio A')

+ self.vm.hmp_qemu_io('source', 'aio_write 0 1M') # 1

+ self.vm.hmp_qemu_io('source', 'wait_break A')

+ self.vm.hmp_qemu_io('source', 'aio_write 0 2M') # 2

+ self.vm.hmp_qemu_io('source', 'aio_write 0 2M') # 3

+

+ # Now 2 and 3 are in mirror_wait_on_conflicts, waiting for 1

+

+ self.vm.hmp_qemu_io('source', 'break write_aio B')

+ self.vm.hmp_qemu_io('source', 'aio_write 1M 2M') # 4

+ self.vm.hmp_qemu_io('source', 'wait_break B')

+

+ # 4 doesn't wait for 2 and 3, because they didn't yet set

+ # in_flight_bitmap. So, nothing prevents 4 to go except for our

+ # break-point B.

+

+ self.vm.hmp_qemu_io('source', 'resume A')

+

+ # Now we resumed 1, so 2 and 3 goes to the next iteration of while loop

+ # in mirror_wait_on_conflicts(). They don't exit, as bitmap is dirty

+ # due to request 4. And they start to wait: 2 wait for 3, 3 wait for 2

+ # - DEAD LOCK.

+ # Note that it's important that we add request 4 at last: requests are

+ # appended to the list, so we are sure that 4 is last in the list, so 2

+ # and 3 now waits for each other, not for 4.

+

+ self.vm.hmp_qemu_io('source', 'resume B')

+

+ # Resuming 4 doesn't help, 2 and 3 already dead-locked

+ # To check the dead-lock run:

+ # gdb -p $(pidof qemu-system-x86_64) -ex 'set $job=(MirrorBlockJob *)jobs.lh_first' -ex 'p *$job->ops_in_flight.tqh_first' -ex 'p *$job->ops_in_flight.tqh_first->next.tqe_next'

+ # You'll see two MirrorOp objects waiting on each other

+

+ result = self.vm.qmp('block-job-set-speed', device='mirror', speed=0)

+ self.assert_qmp(result, 'return', {})

+ self.complete_and_wait(drive='mirror')

+

+ self.potential_writes_in_flight = False

+

if __name__ == '__main__':

iotests.main(supported_fmts=['qcow2', 'raw'],

diff --git a/tests/qemu-iotests/151.out b/tests/qemu-iotests/151.out

--- a/tests/qemu-iotests/151.out

+++ b/tests/qemu-iotests/151.out

@@ -XXX,XX +XXX,XX @@

-...

+....

----------------------------------------------------------------------

-Ran 3 tests

+Ran 4 tests

OK

2.31.1

From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>

It's possible that requests start to wait each other in

mirror_wait_on_conflicts(). To avoid it let's use same technique as in

block/io.c in bdrv_wait_serialising_requests_locked() /

bdrv_find_conflicting_request(): don't wait on intersecting request if

it is already waiting for some other request.

For details of the dead-lock look at testIntersectingActiveIO()

test-case which we actually fixing now.

Fixes: d06107ade0ce74dc39739bac80de84b51ec18546

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>

Message-Id: <20210702211636.228981-4-vsementsov@virtuozzo.com>

block/mirror.c | 12 ++++++++++++

tests/qemu-iotests/151 | 18 +++++-------------

2 files changed, 17 insertions(+), 13 deletions(-)

diff --git a/block/mirror.c b/block/mirror.c

--- a/block/mirror.c

+++ b/block/mirror.c

@@ -XXX,XX +XXX,XX @@ struct MirrorOp {

bool is_in_flight;

CoQueue waiting_requests;

Coroutine *co;

+ MirrorOp *waiting_for_op;

QTAILQ_ENTRY(MirrorOp) next;

};

@@ -XXX,XX +XXX,XX @@ static void coroutine_fn mirror_wait_on_conflicts(MirrorOp *self,

if (ranges_overlap(self_start_chunk, self_nb_chunks,

op_start_chunk, op_nb_chunks))

{

+ /*

+ * If the operation is already (indirectly) waiting for us, or

+ * will wait for us as soon as it wakes up, then just go on

+ * (instead of producing a deadlock in the former case).

+ */

+ if (op->waiting_for_op) {

+ continue;

+ }

+ self->waiting_for_op = op;

qemu_co_queue_wait(&op->waiting_requests, NULL);

+ self->waiting_for_op = NULL;

break;

}

}

diff --git a/tests/qemu-iotests/151 b/tests/qemu-iotests/151

index XXXXXXX..XXXXXXX 100755

--- a/tests/qemu-iotests/151

+++ b/tests/qemu-iotests/151

@@ -XXX,XX +XXX,XX @@ class TestActiveMirror(iotests.QMPTestCase):

self.potential_writes_in_flight = False

def testIntersectingActiveIO(self):

- # FIXME: test-case is dead-locking. To reproduce dead-lock just drop

- # this return statement

- return

# Fill the source image

result = self.vm.hmp_qemu_io('source', 'write -P 1 0 2M')

@@ -XXX,XX +XXX,XX @@ class TestActiveMirror(iotests.QMPTestCase):

# Now we resumed 1, so 2 and 3 goes to the next iteration of while loop

# in mirror_wait_on_conflicts(). They don't exit, as bitmap is dirty

- # due to request 4. And they start to wait: 2 wait for 3, 3 wait for 2