diff mbox series

[4/7] iotests/129: Use throttle node

Message ID 20210113140616.150283-5-mreitz@redhat.com (mailing list archive)
State New, archived
Headers show
Series iotests/129: Fix it | expand

Commit Message

Max Reitz Jan. 13, 2021, 2:06 p.m. UTC
Throttling on the BB has not affected block jobs in a while, so it is
possible that one of the jobs in 129 finishes before the VM is stopped.
We can fix that by running the job from a throttle node.

Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 tests/qemu-iotests/129 | 39 +++++++++++++++------------------------
 1 file changed, 15 insertions(+), 24 deletions(-)

Comments

Max Reitz Jan. 13, 2021, 2:10 p.m. UTC | #1
On 13.01.21 15:06, Max Reitz wrote:
> Throttling on the BB has not affected block jobs in a while, so it is
> possible that one of the jobs in 129 finishes before the VM is stopped.
> We can fix that by running the job from a throttle node.
> 
> Signed-off-by: Max Reitz <mreitz@redhat.com>
> ---
>   tests/qemu-iotests/129 | 39 +++++++++++++++------------------------
>   1 file changed, 15 insertions(+), 24 deletions(-)
> 
> diff --git a/tests/qemu-iotests/129 b/tests/qemu-iotests/129
> index dd23bb2e5a..febc806398 100755
> --- a/tests/qemu-iotests/129
> +++ b/tests/qemu-iotests/129

[...]

> @@ -53,33 +51,26 @@ class TestStopWithBlockJob(iotests.QMPTestCase):
>       def do_test_stop(self, cmd, **args):
>           """Test 'stop' while block job is running on a throttled drive.
>           The 'stop' command shouldn't drain the job"""
> -        params = {"device": "drive0",
> -                  "bps": 1024,
> -                  "bps_rd": 0,
> -                  "bps_wr": 0,
> -                  "iops": 0,
> -                  "iops_rd": 0,
> -                  "iops_wr": 0,
> -                 }
> -        result = self.vm.qmp("block_set_io_throttle", conv_keys=False,
> -                             **params)
> -        self.assert_qmp(result, 'return', {})
>           result = self.vm.qmp(cmd, **args)
>           self.assert_qmp(result, 'return', {})
> +
>           result = self.vm.qmp("stop")
>           self.assert_qmp(result, 'return', {})
>           result = self.vm.qmp("query-block-jobs")
> +
>           self.assert_qmp(result, 'return[0]/status', 'running')
>           self.assert_qmp(result, 'return[0]/ready', False)
>   
> +        self.vm.qmp("block-job-cancel", device="drive0", force=True)
> +

Sorry, somewhere along the way I forgot to remove this block-job-cancel. 
  It’s still from
https://lists.nongnu.org/archive/html/qemu-block/2019-06/msg00499.html 
and I don’t know why I added it there.  It should probably go.

('stop' should have drained, that’s the point, so there shouldn’t be any 
further delay if we quit the VM without cancelling the job.)

Max
Eric Blake Jan. 13, 2021, 2:53 p.m. UTC | #2
On 1/13/21 8:10 AM, Max Reitz wrote:
> On 13.01.21 15:06, Max Reitz wrote:
>> Throttling on the BB has not affected block jobs in a while, so it is
>> possible that one of the jobs in 129 finishes before the VM is stopped.
>> We can fix that by running the job from a throttle node.
>>
>> Signed-off-by: Max Reitz <mreitz@redhat.com>
>> ---
>>   tests/qemu-iotests/129 | 39 +++++++++++++++------------------------
>>   1 file changed, 15 insertions(+), 24 deletions(-)
>>

>>           result = self.vm.qmp("stop")
>>           self.assert_qmp(result, 'return', {})
>>           result = self.vm.qmp("query-block-jobs")
>> +
>>           self.assert_qmp(result, 'return[0]/status', 'running')
>>           self.assert_qmp(result, 'return[0]/ready', False)
>>   +        self.vm.qmp("block-job-cancel", device="drive0", force=True)
>> +
> 
> Sorry, somewhere along the way I forgot to remove this block-job-cancel.
>  It’s still from
> https://lists.nongnu.org/archive/html/qemu-block/2019-06/msg00499.html
> and I don’t know why I added it there.  It should probably go.
> 
> ('stop' should have drained, that’s the point, so there shouldn’t be any
> further delay if we quit the VM without cancelling the job.)

Since the test still passes without the added block-job-cancel, I'm fine
with removing that line then adding:

Reviewed-by: Eric Blake <eblake@redhat.com>
Vladimir Sementsov-Ogievskiy Jan. 13, 2021, 3:07 p.m. UTC | #3
13.01.2021 17:10, Max Reitz wrote:
> On 13.01.21 15:06, Max Reitz wrote:
>> Throttling on the BB has not affected block jobs in a while, so it is
>> possible that one of the jobs in 129 finishes before the VM is stopped.
>> We can fix that by running the job from a throttle node.
>>
>> Signed-off-by: Max Reitz <mreitz@redhat.com>
>> ---
>>   tests/qemu-iotests/129 | 39 +++++++++++++++------------------------
>>   1 file changed, 15 insertions(+), 24 deletions(-)
>>
>> diff --git a/tests/qemu-iotests/129 b/tests/qemu-iotests/129
>> index dd23bb2e5a..febc806398 100755
>> --- a/tests/qemu-iotests/129
>> +++ b/tests/qemu-iotests/129
> 
> [...]
> 
>> @@ -53,33 +51,26 @@ class TestStopWithBlockJob(iotests.QMPTestCase):
>>       def do_test_stop(self, cmd, **args):
>>           """Test 'stop' while block job is running on a throttled drive.
>>           The 'stop' command shouldn't drain the job"""
>> -        params = {"device": "drive0",
>> -                  "bps": 1024,
>> -                  "bps_rd": 0,
>> -                  "bps_wr": 0,
>> -                  "iops": 0,
>> -                  "iops_rd": 0,
>> -                  "iops_wr": 0,
>> -                 }
>> -        result = self.vm.qmp("block_set_io_throttle", conv_keys=False,
>> -                             **params)
>> -        self.assert_qmp(result, 'return', {})
>>           result = self.vm.qmp(cmd, **args)
>>           self.assert_qmp(result, 'return', {})
>> +
>>           result = self.vm.qmp("stop")
>>           self.assert_qmp(result, 'return', {})
>>           result = self.vm.qmp("query-block-jobs")
>> +
>>           self.assert_qmp(result, 'return[0]/status', 'running')
>>           self.assert_qmp(result, 'return[0]/ready', False)
>> +        self.vm.qmp("block-job-cancel", device="drive0", force=True)
>> +
> 
> Sorry, somewhere along the way I forgot to remove this block-job-cancel.  It’s still from
> https://lists.nongnu.org/archive/html/qemu-block/2019-06/msg00499.html and I don’t know why I added it there.  It should probably go.
> 
> ('stop' should have drained, that’s the point, so there shouldn’t be any further delay if we quit the VM without cancelling the job.)
> 

what do you mean by 'stop' should have drained? As I understand, after "stop" jobs should continue and it's OK.. So, immediately after "stop" command job may generate new requests, why not?
Max Reitz Jan. 13, 2021, 3:15 p.m. UTC | #4
On 13.01.21 16:07, Vladimir Sementsov-Ogievskiy wrote:
> 13.01.2021 17:10, Max Reitz wrote:
>> On 13.01.21 15:06, Max Reitz wrote:
>>> Throttling on the BB has not affected block jobs in a while, so it is
>>> possible that one of the jobs in 129 finishes before the VM is stopped.
>>> We can fix that by running the job from a throttle node.
>>>
>>> Signed-off-by: Max Reitz <mreitz@redhat.com>
>>> ---
>>>   tests/qemu-iotests/129 | 39 +++++++++++++++------------------------
>>>   1 file changed, 15 insertions(+), 24 deletions(-)
>>>
>>> diff --git a/tests/qemu-iotests/129 b/tests/qemu-iotests/129
>>> index dd23bb2e5a..febc806398 100755
>>> --- a/tests/qemu-iotests/129
>>> +++ b/tests/qemu-iotests/129
>>
>> [...]
>>
>>> @@ -53,33 +51,26 @@ class TestStopWithBlockJob(iotests.QMPTestCase):
>>>       def do_test_stop(self, cmd, **args):
>>>           """Test 'stop' while block job is running on a throttled 
>>> drive.
>>>           The 'stop' command shouldn't drain the job"""
>>> -        params = {"device": "drive0",
>>> -                  "bps": 1024,
>>> -                  "bps_rd": 0,
>>> -                  "bps_wr": 0,
>>> -                  "iops": 0,
>>> -                  "iops_rd": 0,
>>> -                  "iops_wr": 0,
>>> -                 }
>>> -        result = self.vm.qmp("block_set_io_throttle", conv_keys=False,
>>> -                             **params)
>>> -        self.assert_qmp(result, 'return', {})
>>>           result = self.vm.qmp(cmd, **args)
>>>           self.assert_qmp(result, 'return', {})
>>> +
>>>           result = self.vm.qmp("stop")
>>>           self.assert_qmp(result, 'return', {})
>>>           result = self.vm.qmp("query-block-jobs")
>>> +
>>>           self.assert_qmp(result, 'return[0]/status', 'running')
>>>           self.assert_qmp(result, 'return[0]/ready', False)
>>> +        self.vm.qmp("block-job-cancel", device="drive0", force=True)
>>> +
>>
>> Sorry, somewhere along the way I forgot to remove this 
>> block-job-cancel.  It’s still from
>> https://lists.nongnu.org/archive/html/qemu-block/2019-06/msg00499.html 
>> and I don’t know why I added it there.  It should probably go.
>>
>> ('stop' should have drained, that’s the point, so there shouldn’t be 
>> any further delay if we quit the VM without cancelling the job.)
>>
> 
> what do you mean by 'stop' should have drained? As I understand, after 
> "stop" jobs should continue and it's OK.. So, immediately after "stop" 
> command job may generate new requests, why not?

Hm, right.

Well, either way, the cancel shouldn’t make a difference.  If quitting 
the VM were to stall because of the job, then cancelling it beforehand 
only means that then cancel will stall.

Max
Vladimir Sementsov-Ogievskiy Jan. 13, 2021, 4:46 p.m. UTC | #5
13.01.2021 17:06, Max Reitz wrote:
> Throttling on the BB has not affected block jobs in a while, so it is
> possible that one of the jobs in 129 finishes before the VM is stopped.
> We can fix that by running the job from a throttle node.
> 
> Signed-off-by: Max Reitz <mreitz@redhat.com>
> ---
>   tests/qemu-iotests/129 | 39 +++++++++++++++------------------------
>   1 file changed, 15 insertions(+), 24 deletions(-)
> 
> diff --git a/tests/qemu-iotests/129 b/tests/qemu-iotests/129
> index dd23bb2e5a..febc806398 100755
> --- a/tests/qemu-iotests/129
> +++ b/tests/qemu-iotests/129
> @@ -32,20 +32,18 @@ class TestStopWithBlockJob(iotests.QMPTestCase):
>           iotests.qemu_img('create', '-f', iotests.imgfmt, self.test_img,
>                            "-b", self.base_img, '-F', iotests.imgfmt)
>           iotests.qemu_io('-f', iotests.imgfmt, '-c', 'write -P0x5d 1M 128M', self.test_img)
> -        self.vm = iotests.VM().add_drive(self.test_img)
> +        self.vm = iotests.VM()
> +        self.vm.add_object('throttle-group,id=tg0,x-bps-total=1024')
> +
> +        source_drive = 'driver=throttle,' + \
> +                       'throttle-group=tg0,' + \
> +                      f'file.driver={iotests.imgfmt},' + \
> +                      f'file.file.filename={self.test_img}'

python has a "c-like" string "concatenation", i.e., you may omit "+" operators (I don't know is it a good practice, but I do so:)

> +
> +        self.vm.add_drive(None, source_drive)
>           self.vm.launch()
>   
>       def tearDown(self):
> -        params = {"device": "drive0",
> -                  "bps": 0,
> -                  "bps_rd": 0,
> -                  "bps_wr": 0,
> -                  "iops": 0,
> -                  "iops_rd": 0,
> -                  "iops_wr": 0,
> -                 }
> -        result = self.vm.qmp("block_set_io_throttle", conv_keys=False,
> -                             **params)
>           self.vm.shutdown()
>           for img in (self.test_img, self.target_img, self.base_img):
>               iotests.try_remove(img)
> @@ -53,33 +51,26 @@ class TestStopWithBlockJob(iotests.QMPTestCase):
>       def do_test_stop(self, cmd, **args):
>           """Test 'stop' while block job is running on a throttled drive.
>           The 'stop' command shouldn't drain the job"""
> -        params = {"device": "drive0",
> -                  "bps": 1024,
> -                  "bps_rd": 0,
> -                  "bps_wr": 0,
> -                  "iops": 0,
> -                  "iops_rd": 0,
> -                  "iops_wr": 0,
> -                 }
> -        result = self.vm.qmp("block_set_io_throttle", conv_keys=False,
> -                             **params)
> -        self.assert_qmp(result, 'return', {})
>           result = self.vm.qmp(cmd, **args)
>           self.assert_qmp(result, 'return', {})
> +
>           result = self.vm.qmp("stop")
>           self.assert_qmp(result, 'return', {})
>           result = self.vm.qmp("query-block-jobs")
> +
>           self.assert_qmp(result, 'return[0]/status', 'running')
>           self.assert_qmp(result, 'return[0]/ready', False)
>   
> +        self.vm.qmp("block-job-cancel", device="drive0", force=True)

won't hurt, but I'd drop it as unrelated to commit

> +
>       def test_drive_mirror(self):
>           self.do_test_stop("drive-mirror", device="drive0",
> -                          target=self.target_img,
> +                          target=self.target_img, format=iotests.imgfmt,
>                             sync="full")

this doesn't seem need/related too..

>   
>       def test_drive_backup(self):
>           self.do_test_stop("drive-backup", device="drive0",
> -                          target=self.target_img,
> +                          target=self.target_img, format=iotests.imgfmt,
>                             sync="full")
>   
>       def test_block_commit(self):
>
Max Reitz Jan. 13, 2021, 5:02 p.m. UTC | #6
On 13.01.21 17:46, Vladimir Sementsov-Ogievskiy wrote:
> 13.01.2021 17:06, Max Reitz wrote:
>> Throttling on the BB has not affected block jobs in a while, so it is
>> possible that one of the jobs in 129 finishes before the VM is stopped.
>> We can fix that by running the job from a throttle node.
>>
>> Signed-off-by: Max Reitz <mreitz@redhat.com>
>> ---
>>   tests/qemu-iotests/129 | 39 +++++++++++++++------------------------
>>   1 file changed, 15 insertions(+), 24 deletions(-)
>>
>> diff --git a/tests/qemu-iotests/129 b/tests/qemu-iotests/129
>> index dd23bb2e5a..febc806398 100755
>> --- a/tests/qemu-iotests/129
>> +++ b/tests/qemu-iotests/129
>> @@ -32,20 +32,18 @@ class TestStopWithBlockJob(iotests.QMPTestCase):
>>           iotests.qemu_img('create', '-f', iotests.imgfmt, self.test_img,
>>                            "-b", self.base_img, '-F', iotests.imgfmt)
>>           iotests.qemu_io('-f', iotests.imgfmt, '-c', 'write -P0x5d 1M 
>> 128M', self.test_img)
>> -        self.vm = iotests.VM().add_drive(self.test_img)
>> +        self.vm = iotests.VM()
>> +        self.vm.add_object('throttle-group,id=tg0,x-bps-total=1024')
>> +
>> +        source_drive = 'driver=throttle,' + \
>> +                       'throttle-group=tg0,' + \
>> +                      f'file.driver={iotests.imgfmt},' + \
>> +                      f'file.file.filename={self.test_img}'
> 
> python has a "c-like" string "concatenation", i.e., you may omit "+" 
> operators (I don't know is it a good practice, but I do so:)

OK, why not.

>> +
>> +        self.vm.add_drive(None, source_drive)
>>           self.vm.launch()
>>       def tearDown(self):
>> -        params = {"device": "drive0",
>> -                  "bps": 0,
>> -                  "bps_rd": 0,
>> -                  "bps_wr": 0,
>> -                  "iops": 0,
>> -                  "iops_rd": 0,
>> -                  "iops_wr": 0,
>> -                 }
>> -        result = self.vm.qmp("block_set_io_throttle", conv_keys=False,
>> -                             **params)
>>           self.vm.shutdown()
>>           for img in (self.test_img, self.target_img, self.base_img):
>>               iotests.try_remove(img)
>> @@ -53,33 +51,26 @@ class TestStopWithBlockJob(iotests.QMPTestCase):
>>       def do_test_stop(self, cmd, **args):
>>           """Test 'stop' while block job is running on a throttled drive.
>>           The 'stop' command shouldn't drain the job"""
>> -        params = {"device": "drive0",
>> -                  "bps": 1024,
>> -                  "bps_rd": 0,
>> -                  "bps_wr": 0,
>> -                  "iops": 0,
>> -                  "iops_rd": 0,
>> -                  "iops_wr": 0,
>> -                 }
>> -        result = self.vm.qmp("block_set_io_throttle", conv_keys=False,
>> -                             **params)
>> -        self.assert_qmp(result, 'return', {})
>>           result = self.vm.qmp(cmd, **args)
>>           self.assert_qmp(result, 'return', {})
>> +
>>           result = self.vm.qmp("stop")
>>           self.assert_qmp(result, 'return', {})
>>           result = self.vm.qmp("query-block-jobs")
>> +
>>           self.assert_qmp(result, 'return[0]/status', 'running')
>>           self.assert_qmp(result, 'return[0]/ready', False)
>> +        self.vm.qmp("block-job-cancel", device="drive0", force=True)
> 
> won't hurt, but I'd drop it as unrelated to commit
> 
>> +
>>       def test_drive_mirror(self):
>>           self.do_test_stop("drive-mirror", device="drive0",
>> -                          target=self.target_img,
>> +                          target=self.target_img, format=iotests.imgfmt,
>>                             sync="full")
> 
> this doesn't seem need/related too..

It is, because without a @format parameter, the job uses the driver of 
@device as the output format.  That driver is now 'throttle', which 
doesn’t work as a format.

Max
Vladimir Sementsov-Ogievskiy Jan. 13, 2021, 5:05 p.m. UTC | #7
13.01.2021 20:02, Max Reitz wrote:
> On 13.01.21 17:46, Vladimir Sementsov-Ogievskiy wrote:
>> 13.01.2021 17:06, Max Reitz wrote:
>>> Throttling on the BB has not affected block jobs in a while, so it is
>>> possible that one of the jobs in 129 finishes before the VM is stopped.
>>> We can fix that by running the job from a throttle node.
>>>
>>> Signed-off-by: Max Reitz <mreitz@redhat.com>
>>> ---
>>>   tests/qemu-iotests/129 | 39 +++++++++++++++------------------------
>>>   1 file changed, 15 insertions(+), 24 deletions(-)
>>>
>>> diff --git a/tests/qemu-iotests/129 b/tests/qemu-iotests/129
>>> index dd23bb2e5a..febc806398 100755
>>> --- a/tests/qemu-iotests/129
>>> +++ b/tests/qemu-iotests/129
>>> @@ -32,20 +32,18 @@ class TestStopWithBlockJob(iotests.QMPTestCase):
>>>           iotests.qemu_img('create', '-f', iotests.imgfmt, self.test_img,
>>>                            "-b", self.base_img, '-F', iotests.imgfmt)
>>>           iotests.qemu_io('-f', iotests.imgfmt, '-c', 'write -P0x5d 1M 128M', self.test_img)
>>> -        self.vm = iotests.VM().add_drive(self.test_img)
>>> +        self.vm = iotests.VM()
>>> +        self.vm.add_object('throttle-group,id=tg0,x-bps-total=1024')
>>> +
>>> +        source_drive = 'driver=throttle,' + \
>>> +                       'throttle-group=tg0,' + \
>>> +                      f'file.driver={iotests.imgfmt},' + \
>>> +                      f'file.file.filename={self.test_img}'
>>
>> python has a "c-like" string "concatenation", i.e., you may omit "+" operators (I don't know is it a good practice, but I do so:)
> 
> OK, why not.
> 
>>> +
>>> +        self.vm.add_drive(None, source_drive)
>>>           self.vm.launch()
>>>       def tearDown(self):
>>> -        params = {"device": "drive0",
>>> -                  "bps": 0,
>>> -                  "bps_rd": 0,
>>> -                  "bps_wr": 0,
>>> -                  "iops": 0,
>>> -                  "iops_rd": 0,
>>> -                  "iops_wr": 0,
>>> -                 }
>>> -        result = self.vm.qmp("block_set_io_throttle", conv_keys=False,
>>> -                             **params)
>>>           self.vm.shutdown()
>>>           for img in (self.test_img, self.target_img, self.base_img):
>>>               iotests.try_remove(img)
>>> @@ -53,33 +51,26 @@ class TestStopWithBlockJob(iotests.QMPTestCase):
>>>       def do_test_stop(self, cmd, **args):
>>>           """Test 'stop' while block job is running on a throttled drive.
>>>           The 'stop' command shouldn't drain the job"""
>>> -        params = {"device": "drive0",
>>> -                  "bps": 1024,
>>> -                  "bps_rd": 0,
>>> -                  "bps_wr": 0,
>>> -                  "iops": 0,
>>> -                  "iops_rd": 0,
>>> -                  "iops_wr": 0,
>>> -                 }
>>> -        result = self.vm.qmp("block_set_io_throttle", conv_keys=False,
>>> -                             **params)
>>> -        self.assert_qmp(result, 'return', {})
>>>           result = self.vm.qmp(cmd, **args)
>>>           self.assert_qmp(result, 'return', {})
>>> +
>>>           result = self.vm.qmp("stop")
>>>           self.assert_qmp(result, 'return', {})
>>>           result = self.vm.qmp("query-block-jobs")
>>> +
>>>           self.assert_qmp(result, 'return[0]/status', 'running')
>>>           self.assert_qmp(result, 'return[0]/ready', False)
>>> +        self.vm.qmp("block-job-cancel", device="drive0", force=True)
>>
>> won't hurt, but I'd drop it as unrelated to commit
>>
>>> +
>>>       def test_drive_mirror(self):
>>>           self.do_test_stop("drive-mirror", device="drive0",
>>> -                          target=self.target_img,
>>> +                          target=self.target_img, format=iotests.imgfmt,
>>>                             sync="full")
>>
>> this doesn't seem need/related too..
> 
> It is, because without a @format parameter, the job uses the driver of @device as the output format.  That driver is now 'throttle', which doesn’t work as a format.
> 

Ah, understand now, OK.
diff mbox series

Patch

diff --git a/tests/qemu-iotests/129 b/tests/qemu-iotests/129
index dd23bb2e5a..febc806398 100755
--- a/tests/qemu-iotests/129
+++ b/tests/qemu-iotests/129
@@ -32,20 +32,18 @@  class TestStopWithBlockJob(iotests.QMPTestCase):
         iotests.qemu_img('create', '-f', iotests.imgfmt, self.test_img,
                          "-b", self.base_img, '-F', iotests.imgfmt)
         iotests.qemu_io('-f', iotests.imgfmt, '-c', 'write -P0x5d 1M 128M', self.test_img)
-        self.vm = iotests.VM().add_drive(self.test_img)
+        self.vm = iotests.VM()
+        self.vm.add_object('throttle-group,id=tg0,x-bps-total=1024')
+
+        source_drive = 'driver=throttle,' + \
+                       'throttle-group=tg0,' + \
+                      f'file.driver={iotests.imgfmt},' + \
+                      f'file.file.filename={self.test_img}'
+
+        self.vm.add_drive(None, source_drive)
         self.vm.launch()
 
     def tearDown(self):
-        params = {"device": "drive0",
-                  "bps": 0,
-                  "bps_rd": 0,
-                  "bps_wr": 0,
-                  "iops": 0,
-                  "iops_rd": 0,
-                  "iops_wr": 0,
-                 }
-        result = self.vm.qmp("block_set_io_throttle", conv_keys=False,
-                             **params)
         self.vm.shutdown()
         for img in (self.test_img, self.target_img, self.base_img):
             iotests.try_remove(img)
@@ -53,33 +51,26 @@  class TestStopWithBlockJob(iotests.QMPTestCase):
     def do_test_stop(self, cmd, **args):
         """Test 'stop' while block job is running on a throttled drive.
         The 'stop' command shouldn't drain the job"""
-        params = {"device": "drive0",
-                  "bps": 1024,
-                  "bps_rd": 0,
-                  "bps_wr": 0,
-                  "iops": 0,
-                  "iops_rd": 0,
-                  "iops_wr": 0,
-                 }
-        result = self.vm.qmp("block_set_io_throttle", conv_keys=False,
-                             **params)
-        self.assert_qmp(result, 'return', {})
         result = self.vm.qmp(cmd, **args)
         self.assert_qmp(result, 'return', {})
+
         result = self.vm.qmp("stop")
         self.assert_qmp(result, 'return', {})
         result = self.vm.qmp("query-block-jobs")
+
         self.assert_qmp(result, 'return[0]/status', 'running')
         self.assert_qmp(result, 'return[0]/ready', False)
 
+        self.vm.qmp("block-job-cancel", device="drive0", force=True)
+
     def test_drive_mirror(self):
         self.do_test_stop("drive-mirror", device="drive0",
-                          target=self.target_img,
+                          target=self.target_img, format=iotests.imgfmt,
                           sync="full")
 
     def test_drive_backup(self):
         self.do_test_stop("drive-backup", device="drive0",
-                          target=self.target_img,
+                          target=self.target_img, format=iotests.imgfmt,
                           sync="full")
 
     def test_block_commit(self):