1 # Common utilities and Python wrappers for qemu-iotests
3 # Copyright (C) 2012 IBM Corp.
5 # This program is free software; you can redistribute it and/or modify
6 # it under the terms of the GNU General Public License as published by
7 # the Free Software Foundation; either version 2 of the License, or
8 # (at your option) any later version.
10 # This program is distributed in the hope that it will be useful,
11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 # GNU General Public License for more details.
15 # You should have received a copy of the GNU General Public License
16 # along with this program. If not, see <http://www.gnu.org/licenses/>.
26 sys
.path
.append(os
.path
.join(os
.path
.dirname(__file__
), '..', '..', 'scripts'))
32 # This will not work if arguments contain spaces but is necessary if we
33 # want to support the override options that ./check supports.
34 qemu_img_args
= [os
.environ
.get('QEMU_IMG_PROG', 'qemu-img')]
35 if os
.environ
.get('QEMU_IMG_OPTIONS'):
36 qemu_img_args
+= os
.environ
['QEMU_IMG_OPTIONS'].strip().split(' ')
38 qemu_io_args
= [os
.environ
.get('QEMU_IO_PROG', 'qemu-io')]
39 if os
.environ
.get('QEMU_IO_OPTIONS'):
40 qemu_io_args
+= os
.environ
['QEMU_IO_OPTIONS'].strip().split(' ')
42 qemu_prog
= os
.environ
.get('QEMU_PROG', 'qemu')
43 qemu_opts
= os
.environ
.get('QEMU_OPTIONS', '').strip().split(' ')
45 imgfmt
= os
.environ
.get('IMGFMT', 'raw')
46 imgproto
= os
.environ
.get('IMGPROTO', 'file')
47 test_dir
= os
.environ
.get('TEST_DIR')
48 output_dir
= os
.environ
.get('OUTPUT_DIR', '.')
49 cachemode
= os
.environ
.get('CACHEMODE')
50 qemu_default_machine
= os
.environ
.get('QEMU_DEFAULT_MACHINE')
52 socket_scm_helper
= os
.environ
.get('SOCKET_SCM_HELPER', 'socket_scm_helper')
55 '''Run qemu-img and return the exit code'''
56 devnull
= open('/dev/null', 'r+')
57 exitcode
= subprocess
.call(qemu_img_args
+ list(args
), stdin
=devnull
, stdout
=devnull
)
59 sys
.stderr
.write('qemu-img received signal %i: %s\n' % (-exitcode
, ' '.join(qemu_img_args
+ list(args
))))
62 def qemu_img_verbose(*args
):
63 '''Run qemu-img without suppressing its output and return the exit code'''
64 exitcode
= subprocess
.call(qemu_img_args
+ list(args
))
66 sys
.stderr
.write('qemu-img received signal %i: %s\n' % (-exitcode
, ' '.join(qemu_img_args
+ list(args
))))
69 def qemu_img_pipe(*args
):
70 '''Run qemu-img and return its output'''
71 subp
= subprocess
.Popen(qemu_img_args
+ list(args
),
72 stdout
=subprocess
.PIPE
,
73 stderr
=subprocess
.STDOUT
)
74 exitcode
= subp
.wait()
76 sys
.stderr
.write('qemu-img received signal %i: %s\n' % (-exitcode
, ' '.join(qemu_img_args
+ list(args
))))
77 return subp
.communicate()[0]
80 '''Run qemu-io and return the stdout data'''
81 args
= qemu_io_args
+ list(args
)
82 subp
= subprocess
.Popen(args
, stdout
=subprocess
.PIPE
,
83 stderr
=subprocess
.STDOUT
)
84 exitcode
= subp
.wait()
86 sys
.stderr
.write('qemu-io received signal %i: %s\n' % (-exitcode
, ' '.join(args
)))
87 return subp
.communicate()[0]
89 def compare_images(img1
, img2
):
90 '''Return True if two image files are identical'''
91 return qemu_img('compare', '-f', imgfmt
,
92 '-F', imgfmt
, img1
, img2
) == 0
94 def create_image(name
, size
):
95 '''Create a fully-allocated raw image with sector markers'''
96 file = open(name
, 'w')
99 sector
= struct
.pack('>l504xl', i
/ 512, i
/ 512)
105 '''Return image's virtual size'''
106 r
= qemu_img_pipe('info', '--output=json', '-f', imgfmt
, img
)
107 return json
.loads(r
)['virtual-size']
109 test_dir_re
= re
.compile(r
"%s" % test_dir
)
110 def filter_test_dir(msg
):
111 return test_dir_re
.sub("TEST_DIR", msg
)
113 win32_re
= re
.compile(r
"\r")
114 def filter_win32(msg
):
115 return win32_re
.sub("", msg
)
117 qemu_io_re
= re
.compile(r
"[0-9]* ops; [0-9\/:. sec]* \([0-9\/.inf]* [EPTGMKiBbytes]*\/sec and [0-9\/.inf]* ops\/sec\)")
118 def filter_qemu_io(msg
):
119 msg
= filter_win32(msg
)
120 return qemu_io_re
.sub("X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)", msg
)
122 chown_re
= re
.compile(r
"chown [0-9]+:[0-9]+")
123 def filter_chown(msg
):
124 return chown_re
.sub("chown UID:GID", msg
)
126 def log(msg
, filters
=[]):
131 class VM(qtest
.QEMUQtestMachine
):
135 super(VM
, self
).__init
__(qemu_prog
, qemu_opts
, test_dir
=test_dir
,
136 socket_scm_helper
=socket_scm_helper
)
139 def add_drive_raw(self
, opts
):
140 self
._args
.append('-drive')
141 self
._args
.append(opts
)
144 def add_drive(self
, path
, opts
='', interface
='virtio'):
145 '''Add a virtio-blk drive to the VM'''
146 options
= ['if=%s' % interface
,
147 'id=drive%d' % self
._num
_drives
]
150 options
.append('file=%s' % path
)
151 options
.append('format=%s' % imgfmt
)
152 options
.append('cache=%s' % cachemode
)
157 self
._args
.append('-drive')
158 self
._args
.append(','.join(options
))
159 self
._num
_drives
+= 1
162 def pause_drive(self
, drive
, event
=None):
163 '''Pause drive r/w operations'''
165 self
.pause_drive(drive
, "read_aio")
166 self
.pause_drive(drive
, "write_aio")
168 self
.qmp('human-monitor-command',
169 command_line
='qemu-io %s "break %s bp_%s"' % (drive
, event
, drive
))
171 def resume_drive(self
, drive
):
172 self
.qmp('human-monitor-command',
173 command_line
='qemu-io %s "remove_break bp_%s"' % (drive
, drive
))
175 def hmp_qemu_io(self
, drive
, cmd
):
176 '''Write to a given drive using an HMP command'''
177 return self
.qmp('human-monitor-command',
178 command_line
='qemu-io %s "%s"' % (drive
, cmd
))
181 index_re
= re
.compile(r
'([^\[]+)\[([^\]]+)\]')
183 class QMPTestCase(unittest
.TestCase
):
184 '''Abstract base class for QMP test cases'''
186 def dictpath(self
, d
, path
):
187 '''Traverse a path in a nested dict'''
188 for component
in path
.split('/'):
189 m
= index_re
.match(component
)
191 component
, idx
= m
.groups()
194 if not isinstance(d
, dict) or component
not in d
:
195 self
.fail('failed path traversal for "%s" in "%s"' % (path
, str(d
)))
199 if not isinstance(d
, list):
200 self
.fail('path component "%s" in "%s" is not a list in "%s"' % (component
, path
, str(d
)))
204 self
.fail('invalid index "%s" in path "%s" in "%s"' % (idx
, path
, str(d
)))
207 def assert_qmp_absent(self
, d
, path
):
209 result
= self
.dictpath(d
, path
)
210 except AssertionError:
212 self
.fail('path "%s" has value "%s"' % (path
, str(result
)))
214 def assert_qmp(self
, d
, path
, value
):
215 '''Assert that the value for a specific path in a QMP dict matches'''
216 result
= self
.dictpath(d
, path
)
217 self
.assertEqual(result
, value
, 'values not equal "%s" and "%s"' % (str(result
), str(value
)))
219 def assert_no_active_block_jobs(self
):
220 result
= self
.vm
.qmp('query-block-jobs')
221 self
.assert_qmp(result
, 'return', [])
223 def assert_has_block_node(self
, node_name
=None, file_name
=None):
224 """Issue a query-named-block-nodes and assert node_name and/or
225 file_name is present in the result"""
226 def check_equal_or_none(a
, b
):
227 return a
== None or b
== None or a
== b
228 assert node_name
or file_name
229 result
= self
.vm
.qmp('query-named-block-nodes')
230 for x
in result
["return"]:
231 if check_equal_or_none(x
.get("node-name"), node_name
) and \
232 check_equal_or_none(x
.get("file"), file_name
):
234 self
.assertTrue(False, "Cannot find %s %s in result:\n%s" % \
235 (node_name
, file_name
, result
))
237 def cancel_and_wait(self
, drive
='drive0', force
=False, resume
=False):
238 '''Cancel a block job and wait for it to finish, returning the event'''
239 result
= self
.vm
.qmp('block-job-cancel', device
=drive
, force
=force
)
240 self
.assert_qmp(result
, 'return', {})
243 self
.vm
.resume_drive(drive
)
248 for event
in self
.vm
.get_qmp_events(wait
=True):
249 if event
['event'] == 'BLOCK_JOB_COMPLETED' or \
250 event
['event'] == 'BLOCK_JOB_CANCELLED':
251 self
.assert_qmp(event
, 'data/device', drive
)
255 self
.assert_no_active_block_jobs()
258 def wait_until_completed(self
, drive
='drive0', check_offset
=True):
259 '''Wait for a block job to finish, returning the event'''
262 for event
in self
.vm
.get_qmp_events(wait
=True):
263 if event
['event'] == 'BLOCK_JOB_COMPLETED':
264 self
.assert_qmp(event
, 'data/device', drive
)
265 self
.assert_qmp_absent(event
, 'data/error')
267 self
.assert_qmp(event
, 'data/offset', event
['data']['len'])
270 self
.assert_no_active_block_jobs()
273 def wait_ready(self
, drive
='drive0'):
274 '''Wait until a block job BLOCK_JOB_READY event'''
275 f
= {'data': {'type': 'mirror', 'device': drive
} }
276 event
= self
.vm
.event_wait(name
='BLOCK_JOB_READY', match
=f
)
278 def wait_ready_and_cancel(self
, drive
='drive0'):
279 self
.wait_ready(drive
=drive
)
280 event
= self
.cancel_and_wait(drive
=drive
)
281 self
.assertEquals(event
['event'], 'BLOCK_JOB_COMPLETED')
282 self
.assert_qmp(event
, 'data/type', 'mirror')
283 self
.assert_qmp(event
, 'data/offset', event
['data']['len'])
285 def complete_and_wait(self
, drive
='drive0', wait_ready
=True):
286 '''Complete a block job and wait for it to finish'''
288 self
.wait_ready(drive
=drive
)
290 result
= self
.vm
.qmp('block-job-complete', device
=drive
)
291 self
.assert_qmp(result
, 'return', {})
293 event
= self
.wait_until_completed(drive
=drive
)
294 self
.assert_qmp(event
, 'data/type', 'mirror')
297 '''Skip this test suite'''
298 # Each test in qemu-iotests has a number ("seq")
299 seq
= os
.path
.basename(sys
.argv
[0])
301 open('%s/%s.notrun' % (output_dir
, seq
), 'wb').write(reason
+ '\n')
302 print '%s not run: %s' % (seq
, reason
)
305 def verify_image_format(supported_fmts
=[]):
306 if supported_fmts
and (imgfmt
not in supported_fmts
):
307 notrun('not suitable for this image format: %s' % imgfmt
)
309 def verify_platform(supported_oses
=['linux']):
310 if True not in [sys
.platform
.startswith(x
) for x
in supported_oses
]:
311 notrun('not suitable for this OS: %s' % sys
.platform
)
314 '''Skip test suite if quorum support is not available'''
315 if 'quorum' not in qemu_img_pipe('--help'):
316 notrun('quorum support missing')
318 def main(supported_fmts
=[], supported_oses
=['linux']):
321 # We are using TEST_DIR and QEMU_DEFAULT_MACHINE as proxies to
322 # indicate that we're not being run via "check". There may be
323 # other things set up by "check" that individual test cases rely
325 if test_dir
is None or qemu_default_machine
is None:
326 sys
.stderr
.write('Please run this test via the "check" script\n')
327 sys
.exit(os
.EX_USAGE
)
329 debug
= '-d' in sys
.argv
331 verify_image_format(supported_fmts
)
332 verify_platform(supported_oses
)
334 # We need to filter out the time taken from the output so that qemu-iotest
335 # can reliably diff the results against master output.
340 sys
.argv
.remove('-d')
342 output
= StringIO
.StringIO()
344 class MyTestRunner(unittest
.TextTestRunner
):
345 def __init__(self
, stream
=output
, descriptions
=True, verbosity
=verbosity
):
346 unittest
.TextTestRunner
.__init
__(self
, stream
, descriptions
, verbosity
)
348 # unittest.main() will use sys.exit() so expect a SystemExit exception
350 unittest
.main(testRunner
=MyTestRunner
)
353 sys
.stderr
.write(re
.sub(r
'Ran (\d+) tests? in [\d.]+s', r
'Ran \1 tests', output
.getvalue()))