xref: /qemu/tests/qemu-iotests/281 (revision c5955f4f) 
1#!/usr/bin/env python3
2# group: rw
3#
4# Test cases for blockdev + IOThread interactions
5#
6# Copyright (C) 2019 Red Hat, Inc.
7#
8# This program is free software; you can redistribute it and/or modify
9# it under the terms of the GNU General Public License as published by
10# the Free Software Foundation; either version 2 of the License, or
11# (at your option) any later version.
12#
13# This program is distributed in the hope that it will be useful,
14# but WITHOUT ANY WARRANTY; without even the implied warranty of
15# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16# GNU General Public License for more details.
17#
18# You should have received a copy of the GNU General Public License
19# along with this program.  If not, see <http://www.gnu.org/licenses/>.
20#
21
22import os
23import time
24import iotests
25from iotests import qemu_img, QemuStorageDaemon
26
27image_len = 64 * 1024 * 1024
28
29# Test for RHBZ#1782175
30class TestDirtyBitmapIOThread(iotests.QMPTestCase):
31    drive0_img = os.path.join(iotests.test_dir, 'drive0.img')
32    images = { 'drive0': drive0_img }
33
34    def setUp(self):
35        for name in self.images:
36            qemu_img('create', '-f', iotests.imgfmt,
37                     self.images[name], str(image_len))
38
39        self.vm = iotests.VM()
40        self.vm.add_object('iothread,id=iothread0')
41
42        for name in self.images:
43            self.vm.add_blockdev('driver=file,filename=%s,node-name=file_%s'
44                                 % (self.images[name], name))
45            self.vm.add_blockdev('driver=qcow2,file=file_%s,node-name=%s'
46                                 % (name, name))
47
48        self.vm.launch()
49        self.vm.qmp('x-blockdev-set-iothread',
50                    node_name='drive0', iothread='iothread0',
51                    force=True)
52
53    def tearDown(self):
54        self.vm.shutdown()
55        for name in self.images:
56            os.remove(self.images[name])
57
58    def test_add_dirty_bitmap(self):
59        result = self.vm.qmp(
60            'block-dirty-bitmap-add',
61            node='drive0',
62            name='bitmap1',
63            persistent=True,
64        )
65
66        self.assert_qmp(result, 'return', {})
67
68
69# Test for RHBZ#1746217 & RHBZ#1773517
70class TestNBDMirrorIOThread(iotests.QMPTestCase):
71    nbd_sock = os.path.join(iotests.sock_dir, 'nbd.sock')
72    drive0_img = os.path.join(iotests.test_dir, 'drive0.img')
73    mirror_img = os.path.join(iotests.test_dir, 'mirror.img')
74    images = { 'drive0': drive0_img, 'mirror': mirror_img }
75
76    def setUp(self):
77        for name in self.images:
78            qemu_img('create', '-f', iotests.imgfmt,
79                     self.images[name], str(image_len))
80
81        self.vm_src = iotests.VM(path_suffix='src')
82        self.vm_src.add_object('iothread,id=iothread0')
83        self.vm_src.add_blockdev('driver=file,filename=%s,node-name=file0'
84                          % (self.drive0_img))
85        self.vm_src.add_blockdev('driver=qcow2,file=file0,node-name=drive0')
86        self.vm_src.launch()
87        self.vm_src.qmp('x-blockdev-set-iothread',
88                        node_name='drive0', iothread='iothread0',
89                        force=True)
90
91        self.vm_tgt = iotests.VM(path_suffix='tgt')
92        self.vm_tgt.add_object('iothread,id=iothread0')
93        self.vm_tgt.add_blockdev('driver=file,filename=%s,node-name=file0'
94                          % (self.mirror_img))
95        self.vm_tgt.add_blockdev('driver=qcow2,file=file0,node-name=drive0')
96        self.vm_tgt.launch()
97        self.vm_tgt.qmp('x-blockdev-set-iothread',
98                        node_name='drive0', iothread='iothread0',
99                        force=True)
100
101    def tearDown(self):
102        self.vm_src.shutdown()
103        self.vm_tgt.shutdown()
104        for name in self.images:
105            os.remove(self.images[name])
106
107    def test_nbd_mirror(self):
108        result = self.vm_tgt.qmp(
109            'nbd-server-start',
110            addr={
111                'type': 'unix',
112                'data': { 'path': self.nbd_sock }
113            }
114        )
115        self.assert_qmp(result, 'return', {})
116
117        result = self.vm_tgt.qmp(
118            'nbd-server-add',
119            device='drive0',
120            writable=True
121        )
122        self.assert_qmp(result, 'return', {})
123
124        result = self.vm_src.qmp(
125            'drive-mirror',
126            device='drive0',
127            target='nbd+unix:///drive0?socket=' + self.nbd_sock,
128            sync='full',
129            mode='existing',
130            speed=64*1024*1024,
131            job_id='j1'
132        )
133        self.assert_qmp(result, 'return', {})
134
135        self.vm_src.event_wait(name="BLOCK_JOB_READY")
136
137
138# Test for RHBZ#1779036
139class TestExternalSnapshotAbort(iotests.QMPTestCase):
140    drive0_img = os.path.join(iotests.test_dir, 'drive0.img')
141    snapshot_img = os.path.join(iotests.test_dir, 'snapshot.img')
142    images = { 'drive0': drive0_img, 'snapshot': snapshot_img }
143
144    def setUp(self):
145        for name in self.images:
146            qemu_img('create', '-f', iotests.imgfmt,
147                     self.images[name], str(image_len))
148
149        self.vm = iotests.VM()
150        self.vm.add_object('iothread,id=iothread0')
151        self.vm.add_blockdev('driver=file,filename=%s,node-name=file0'
152                          % (self.drive0_img))
153        self.vm.add_blockdev('driver=qcow2,file=file0,node-name=drive0')
154        self.vm.launch()
155        self.vm.qmp('x-blockdev-set-iothread',
156                    node_name='drive0', iothread='iothread0',
157                    force=True)
158
159    def tearDown(self):
160        self.vm.shutdown()
161        for name in self.images:
162            os.remove(self.images[name])
163
164    def test_external_snapshot_abort(self):
165        # Use a two actions transaction with a bogus values on the second
166        # one to trigger an abort of the transaction.
167        result = self.vm.qmp('transaction', actions=[
168            {
169                'type': 'blockdev-snapshot-sync',
170                'data': { 'node-name': 'drive0',
171                          'snapshot-file': self.snapshot_img,
172                          'snapshot-node-name': 'snap1',
173                          'mode': 'absolute-paths',
174                          'format': 'qcow2' }
175            },
176            {
177                'type': 'blockdev-snapshot-sync',
178                'data': { 'node-name': 'drive0',
179                          'snapshot-file': '/fakesnapshot',
180                          'snapshot-node-name': 'snap2',
181                          'mode': 'absolute-paths',
182                          'format': 'qcow2' }
183            },
184        ])
185
186        # Crashes on failure, we expect this error.
187        self.assert_qmp(result, 'error/class', 'GenericError')
188
189
190# Test for RHBZ#1782111
191class TestBlockdevBackupAbort(iotests.QMPTestCase):
192    drive0_img = os.path.join(iotests.test_dir, 'drive0.img')
193    drive1_img = os.path.join(iotests.test_dir, 'drive1.img')
194    snap0_img = os.path.join(iotests.test_dir, 'snap0.img')
195    snap1_img = os.path.join(iotests.test_dir, 'snap1.img')
196    images = { 'drive0': drive0_img,
197               'drive1': drive1_img,
198               'snap0': snap0_img,
199               'snap1': snap1_img }
200
201    def setUp(self):
202        for name in self.images:
203            qemu_img('create', '-f', iotests.imgfmt,
204                     self.images[name], str(image_len))
205
206        self.vm = iotests.VM()
207        self.vm.add_object('iothread,id=iothread0')
208        self.vm.add_device('virtio-scsi,iothread=iothread0')
209
210        for name in self.images:
211            self.vm.add_blockdev('driver=file,filename=%s,node-name=file_%s'
212                                 % (self.images[name], name))
213            self.vm.add_blockdev('driver=qcow2,file=file_%s,node-name=%s'
214                                 % (name, name))
215
216        self.vm.add_device('scsi-hd,drive=drive0')
217        self.vm.add_device('scsi-hd,drive=drive1')
218        self.vm.launch()
219
220    def tearDown(self):
221        self.vm.shutdown()
222        for name in self.images:
223            os.remove(self.images[name])
224
225    def test_blockdev_backup_abort(self):
226        # Use a two actions transaction with a bogus values on the second
227        # one to trigger an abort of the transaction.
228        result = self.vm.qmp('transaction', actions=[
229            {
230                'type': 'blockdev-backup',
231                'data': { 'device': 'drive0',
232                          'target': 'snap0',
233                          'sync': 'full',
234                          'job-id': 'j1' }
235            },
236            {
237                'type': 'blockdev-backup',
238                'data': { 'device': 'drive1',
239                          'target': 'snap1',
240                          'sync': 'full' }
241            },
242        ])
243
244        # Hangs on failure, we expect this error.
245        self.assert_qmp(result, 'error/class', 'GenericError')
246
247# Test for RHBZ#2033626
248class TestYieldingAndTimers(iotests.QMPTestCase):
249    sock = os.path.join(iotests.sock_dir, 'nbd.sock')
250    qsd = None
251
252    def setUp(self):
253        self.create_nbd_export()
254
255        # Simple VM with an NBD block device connected to the NBD export
256        # provided by the QSD, and an (initially unused) iothread
257        self.vm = iotests.VM()
258        self.vm.add_object('iothread,id=iothr')
259        self.vm.add_blockdev('nbd,node-name=nbd,server.type=unix,' +
260                             f'server.path={self.sock},export=exp,' +
261                             'reconnect-delay=1,open-timeout=1')
262
263        self.vm.launch()
264
265    def tearDown(self):
266        self.stop_nbd_export()
267        self.vm.shutdown()
268
269    def test_timers_with_blockdev_del(self):
270        # The NBD BDS will have had an active open timer, because setUp() gave
271        # a positive value for @open-timeout.  It should be gone once the BDS
272        # has been opened.
273        # (But there used to be a bug where it remained active, which will
274        # become important below.)
275
276        # Stop and restart the NBD server, and do some I/O on the client to
277        # trigger a reconnect and start the reconnect delay timer
278        self.stop_nbd_export()
279        self.create_nbd_export()
280
281        result = self.vm.qmp('human-monitor-command',
282                             command_line='qemu-io nbd "write 0 512"')
283        self.assert_qmp(result, 'return', '')
284
285        # Reconnect is done, so the reconnect delay timer should be gone.
286        # (This is similar to how the open timer should be gone after open,
287        # and similarly there used to be a bug where it was not gone.)
288
289        # Delete the BDS to see whether both timers are gone.  If they are not,
290        # they will remain active, fire later, and then access freed data.
291        # (Or, with "block/nbd: Assert there are no timers when closed"
292        # applied, the assertions added in that patch will fail.)
293        result = self.vm.qmp('blockdev-del', node_name='nbd')
294        self.assert_qmp(result, 'return', {})
295
296        # Give the timers some time to fire (both have a timeout of 1 s).
297        # (Sleeping in an iotest may ring some alarm bells, but note that if
298        # the timing is off here, the test will just always pass.  If we kill
299        # the VM too early, then we just kill the timers before they can fire,
300        # thus not see the error, and so the test will pass.)
301        time.sleep(2)
302
303    def test_yield_in_iothread(self):
304        # Move the NBD node to the I/O thread; the NBD block driver should
305        # attach the connection's QIOChannel to that thread's AioContext, too
306        result = self.vm.qmp('x-blockdev-set-iothread',
307                             node_name='nbd', iothread='iothr')
308        self.assert_qmp(result, 'return', {})
309
310        # Do some I/O that will be throttled by the QSD, so that the network
311        # connection hopefully will yield here.  When it is resumed, it must
312        # then be resumed in the I/O thread's AioContext.
313        result = self.vm.qmp('human-monitor-command',
314                             command_line='qemu-io nbd "read 0 128K"')
315        self.assert_qmp(result, 'return', '')
316
317    def create_nbd_export(self):
318        assert self.qsd is None
319
320        # Export a throttled null-co BDS: Reads are throttled (max 64 kB/s),
321        # writes are not.
322        self.qsd = QemuStorageDaemon(
323            '--object',
324            'throttle-group,id=thrgr,x-bps-read=65536,x-bps-read-max=65536',
325
326            '--blockdev',
327            'null-co,node-name=null,read-zeroes=true',
328
329            '--blockdev',
330            'throttle,node-name=thr,file=null,throttle-group=thrgr',
331
332            '--nbd-server',
333            f'addr.type=unix,addr.path={self.sock}',
334
335            '--export',
336            'nbd,id=exp,node-name=thr,name=exp,writable=true'
337        )
338
339    def stop_nbd_export(self):
340        self.qsd.stop()
341        self.qsd = None
342
343if __name__ == '__main__':
344    iotests.main(supported_fmts=['qcow2'],
345                 supported_protocols=['file'],
346                 unsupported_imgopts=['compat'])
347