xref: /openbmc/qemu/tests/qemu-iotests/030 (revision 0c817347) 
1#!/usr/bin/env python
2#
3# Tests for image streaming.
4#
5# Copyright (C) 2012 IBM Corp.
6#
7# This program is free software; you can redistribute it and/or modify
8# it under the terms of the GNU General Public License as published by
9# the Free Software Foundation; either version 2 of the License, or
10# (at your option) any later version.
11#
12# This program is distributed in the hope that it will be useful,
13# but WITHOUT ANY WARRANTY; without even the implied warranty of
14# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15# GNU General Public License for more details.
16#
17# You should have received a copy of the GNU General Public License
18# along with this program.  If not, see <http://www.gnu.org/licenses/>.
19#
20
21import time
22import os
23import iotests
24from iotests import qemu_img, qemu_io
25import struct
26
27backing_img = os.path.join(iotests.test_dir, 'backing.img')
28mid_img = os.path.join(iotests.test_dir, 'mid.img')
29test_img = os.path.join(iotests.test_dir, 'test.img')
30
31class ImageStreamingTestCase(iotests.QMPTestCase):
32    '''Abstract base class for image streaming test cases'''
33
34    def assert_no_active_streams(self):
35        result = self.vm.qmp('query-block-jobs')
36        self.assert_qmp(result, 'return', [])
37
38    def cancel_and_wait(self, drive='drive0'):
39        '''Cancel a block job and wait for it to finish'''
40        result = self.vm.qmp('block-job-cancel', device=drive)
41        self.assert_qmp(result, 'return', {})
42
43        cancelled = False
44        while not cancelled:
45            for event in self.vm.get_qmp_events(wait=True):
46                if event['event'] == 'BLOCK_JOB_CANCELLED':
47                    self.assert_qmp(event, 'data/type', 'stream')
48                    self.assert_qmp(event, 'data/device', drive)
49                    cancelled = True
50
51        self.assert_no_active_streams()
52
53    def create_image(self, name, size):
54        file = open(name, 'w')
55        i = 0
56        while i < size:
57            sector = struct.pack('>l504xl', i / 512, i / 512)
58            file.write(sector)
59            i = i + 512
60        file.close()
61
62
63class TestSingleDrive(ImageStreamingTestCase):
64    image_len = 1 * 1024 * 1024 # MB
65
66    def setUp(self):
67        self.create_image(backing_img, TestSingleDrive.image_len)
68        qemu_img('create', '-f', iotests.imgfmt, '-o', 'backing_file=%s' % backing_img, mid_img)
69        qemu_img('create', '-f', iotests.imgfmt, '-o', 'backing_file=%s' % mid_img, test_img)
70        self.vm = iotests.VM().add_drive(test_img)
71        self.vm.launch()
72
73    def tearDown(self):
74        self.vm.shutdown()
75        os.remove(test_img)
76        os.remove(mid_img)
77        os.remove(backing_img)
78
79    def test_stream(self):
80        self.assert_no_active_streams()
81
82        result = self.vm.qmp('block-stream', device='drive0')
83        self.assert_qmp(result, 'return', {})
84
85        completed = False
86        while not completed:
87            for event in self.vm.get_qmp_events(wait=True):
88                if event['event'] == 'BLOCK_JOB_COMPLETED':
89                    self.assert_qmp(event, 'data/type', 'stream')
90                    self.assert_qmp(event, 'data/device', 'drive0')
91                    self.assert_qmp(event, 'data/offset', self.image_len)
92                    self.assert_qmp(event, 'data/len', self.image_len)
93                    completed = True
94
95        self.assert_no_active_streams()
96        self.vm.shutdown()
97
98        self.assertEqual(qemu_io('-c', 'map', backing_img),
99                         qemu_io('-c', 'map', test_img),
100                         'image file map does not match backing file after streaming')
101
102    def test_stream_pause(self):
103        self.assert_no_active_streams()
104
105        result = self.vm.qmp('block-stream', device='drive0')
106        self.assert_qmp(result, 'return', {})
107
108        result = self.vm.qmp('block-job-pause', device='drive0')
109        self.assert_qmp(result, 'return', {})
110
111        time.sleep(1)
112        result = self.vm.qmp('query-block-jobs')
113        offset = self.dictpath(result, 'return[0]/offset')
114
115        time.sleep(1)
116        result = self.vm.qmp('query-block-jobs')
117        self.assert_qmp(result, 'return[0]/offset', offset)
118
119        result = self.vm.qmp('block-job-resume', device='drive0')
120        self.assert_qmp(result, 'return', {})
121
122        completed = False
123        while not completed:
124            for event in self.vm.get_qmp_events(wait=True):
125                if event['event'] == 'BLOCK_JOB_COMPLETED':
126                    self.assert_qmp(event, 'data/type', 'stream')
127                    self.assert_qmp(event, 'data/device', 'drive0')
128                    self.assert_qmp(event, 'data/offset', self.image_len)
129                    self.assert_qmp(event, 'data/len', self.image_len)
130                    completed = True
131
132        self.assert_no_active_streams()
133        self.vm.shutdown()
134
135        self.assertEqual(qemu_io('-c', 'map', backing_img),
136                         qemu_io('-c', 'map', test_img),
137                         'image file map does not match backing file after streaming')
138
139    def test_stream_partial(self):
140        self.assert_no_active_streams()
141
142        result = self.vm.qmp('block-stream', device='drive0', base=mid_img)
143        self.assert_qmp(result, 'return', {})
144
145        completed = False
146        while not completed:
147            for event in self.vm.get_qmp_events(wait=True):
148                if event['event'] == 'BLOCK_JOB_COMPLETED':
149                    self.assert_qmp(event, 'data/type', 'stream')
150                    self.assert_qmp(event, 'data/device', 'drive0')
151                    self.assert_qmp(event, 'data/offset', self.image_len)
152                    self.assert_qmp(event, 'data/len', self.image_len)
153                    completed = True
154
155        self.assert_no_active_streams()
156        self.vm.shutdown()
157
158        self.assertEqual(qemu_io('-c', 'map', mid_img),
159                         qemu_io('-c', 'map', test_img),
160                         'image file map does not match backing file after streaming')
161
162    def test_device_not_found(self):
163        result = self.vm.qmp('block-stream', device='nonexistent')
164        self.assert_qmp(result, 'error/class', 'DeviceNotFound')
165
166
167class TestSmallerBackingFile(ImageStreamingTestCase):
168    backing_len = 1 * 1024 * 1024 # MB
169    image_len = 2 * backing_len
170
171    def setUp(self):
172        self.create_image(backing_img, self.backing_len)
173        qemu_img('create', '-f', iotests.imgfmt, '-o', 'backing_file=%s' % backing_img, test_img, str(self.image_len))
174        self.vm = iotests.VM().add_drive(test_img)
175        self.vm.launch()
176
177    # If this hangs, then you are missing a fix to complete streaming when the
178    # end of the backing file is reached.
179    def test_stream(self):
180        self.assert_no_active_streams()
181
182        result = self.vm.qmp('block-stream', device='drive0')
183        self.assert_qmp(result, 'return', {})
184
185        completed = False
186        while not completed:
187            for event in self.vm.get_qmp_events(wait=True):
188                if event['event'] == 'BLOCK_JOB_COMPLETED':
189                    self.assert_qmp(event, 'data/type', 'stream')
190                    self.assert_qmp(event, 'data/device', 'drive0')
191                    self.assert_qmp(event, 'data/offset', self.image_len)
192                    self.assert_qmp(event, 'data/len', self.image_len)
193                    completed = True
194
195        self.assert_no_active_streams()
196        self.vm.shutdown()
197
198
199class TestStreamStop(ImageStreamingTestCase):
200    image_len = 8 * 1024 * 1024 * 1024 # GB
201
202    def setUp(self):
203        qemu_img('create', backing_img, str(TestStreamStop.image_len))
204        qemu_img('create', '-f', iotests.imgfmt, '-o', 'backing_file=%s' % backing_img, test_img)
205        self.vm = iotests.VM().add_drive(test_img)
206        self.vm.launch()
207
208    def tearDown(self):
209        self.vm.shutdown()
210        os.remove(test_img)
211        os.remove(backing_img)
212
213    def test_stream_stop(self):
214        self.assert_no_active_streams()
215
216        result = self.vm.qmp('block-stream', device='drive0')
217        self.assert_qmp(result, 'return', {})
218
219        time.sleep(0.1)
220        events = self.vm.get_qmp_events(wait=False)
221        self.assertEqual(events, [], 'unexpected QMP event: %s' % events)
222
223        self.cancel_and_wait()
224
225class TestSetSpeed(ImageStreamingTestCase):
226    image_len = 80 * 1024 * 1024 # MB
227
228    def setUp(self):
229        qemu_img('create', backing_img, str(TestSetSpeed.image_len))
230        qemu_img('create', '-f', iotests.imgfmt, '-o', 'backing_file=%s' % backing_img, test_img)
231        self.vm = iotests.VM().add_drive(test_img)
232        self.vm.launch()
233
234    def tearDown(self):
235        self.vm.shutdown()
236        os.remove(test_img)
237        os.remove(backing_img)
238
239    # This is a short performance test which is not run by default.
240    # Invoke "IMGFMT=qed ./030 TestSetSpeed.perf_test_throughput"
241    def perf_test_throughput(self):
242        self.assert_no_active_streams()
243
244        result = self.vm.qmp('block-stream', device='drive0')
245        self.assert_qmp(result, 'return', {})
246
247        result = self.vm.qmp('block-job-set-speed', device='drive0', speed=8 * 1024 * 1024)
248        self.assert_qmp(result, 'return', {})
249
250        completed = False
251        while not completed:
252            for event in self.vm.get_qmp_events(wait=True):
253                if event['event'] == 'BLOCK_JOB_COMPLETED':
254                    self.assert_qmp(event, 'data/type', 'stream')
255                    self.assert_qmp(event, 'data/device', 'drive0')
256                    self.assert_qmp(event, 'data/offset', self.image_len)
257                    self.assert_qmp(event, 'data/len', self.image_len)
258                    completed = True
259
260        self.assert_no_active_streams()
261
262    def test_set_speed(self):
263        self.assert_no_active_streams()
264
265        result = self.vm.qmp('block-stream', device='drive0')
266        self.assert_qmp(result, 'return', {})
267
268        # Default speed is 0
269        result = self.vm.qmp('query-block-jobs')
270        self.assert_qmp(result, 'return[0]/device', 'drive0')
271        self.assert_qmp(result, 'return[0]/speed', 0)
272
273        result = self.vm.qmp('block-job-set-speed', device='drive0', speed=8 * 1024 * 1024)
274        self.assert_qmp(result, 'return', {})
275
276        # Ensure the speed we set was accepted
277        result = self.vm.qmp('query-block-jobs')
278        self.assert_qmp(result, 'return[0]/device', 'drive0')
279        self.assert_qmp(result, 'return[0]/speed', 8 * 1024 * 1024)
280
281        self.cancel_and_wait()
282
283        # Check setting speed in block-stream works
284        result = self.vm.qmp('block-stream', device='drive0', speed=4 * 1024 * 1024)
285        self.assert_qmp(result, 'return', {})
286
287        result = self.vm.qmp('query-block-jobs')
288        self.assert_qmp(result, 'return[0]/device', 'drive0')
289        self.assert_qmp(result, 'return[0]/speed', 4 * 1024 * 1024)
290
291        self.cancel_and_wait()
292
293    def test_set_speed_invalid(self):
294        self.assert_no_active_streams()
295
296        result = self.vm.qmp('block-stream', device='drive0', speed=-1)
297        self.assert_qmp(result, 'error/class', 'GenericError')
298
299        self.assert_no_active_streams()
300
301        result = self.vm.qmp('block-stream', device='drive0')
302        self.assert_qmp(result, 'return', {})
303
304        result = self.vm.qmp('block-job-set-speed', device='drive0', speed=-1)
305        self.assert_qmp(result, 'error/class', 'GenericError')
306
307        self.cancel_and_wait()
308
309if __name__ == '__main__':
310    iotests.main(supported_fmts=['qcow2', 'qed'])
311