tests/qemu-iotests/iotests.py

   1 from __future__ import print_function
   2 # Common utilities and Python wrappers for qemu-iotests
   3 #
   4 # Copyright (C) 2012 IBM Corp.
   5 #
   6 # This program is free software; you can redistribute it and/or modify
   7 # it under the terms of the GNU General Public License as published by
   8 # the Free Software Foundation; either version 2 of the License, or
   9 # (at your option) any later version.
  10 #
  11 # This program is distributed in the hope that it will be useful,
  12 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 # GNU General Public License for more details.
  15 #
  16 # You should have received a copy of the GNU General Public License
  17 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18 #
  19
  20 import errno
  21 import os
  22 import re
  23 import subprocess
  24 import string
  25 import unittest
  26 import sys
  27 import struct
  28 import json
  29 import signal
  30 import logging
  31 import atexit
  32 import io
  33 from collections import OrderedDict
  34
  35 sys.path.append(os.path.join(os.path.dirname(__file__), '..', '..', 'python'))
  36 from qemu import qtest
  37
  38
  39 # This will not work if arguments contain spaces but is necessary if we
  40 # want to support the override options that ./check supports.
  41 qemu_img_args = [os.environ.get('QEMU_IMG_PROG', 'qemu-img')]
  42 if os.environ.get('QEMU_IMG_OPTIONS'):
  43     qemu_img_args += os.environ['QEMU_IMG_OPTIONS'].strip().split(' ')
  44
  45 qemu_io_args = [os.environ.get('QEMU_IO_PROG', 'qemu-io')]
  46 if os.environ.get('QEMU_IO_OPTIONS'):
  47     qemu_io_args += os.environ['QEMU_IO_OPTIONS'].strip().split(' ')
  48
  49 qemu_nbd_args = [os.environ.get('QEMU_NBD_PROG', 'qemu-nbd')]
  50 if os.environ.get('QEMU_NBD_OPTIONS'):
  51     qemu_nbd_args += os.environ['QEMU_NBD_OPTIONS'].strip().split(' ')
  52
  53 qemu_prog = os.environ.get('QEMU_PROG', 'qemu')
  54 qemu_opts = os.environ.get('QEMU_OPTIONS', '').strip().split(' ')
  55
  56 imgfmt = os.environ.get('IMGFMT', 'raw')
  57 imgproto = os.environ.get('IMGPROTO', 'file')
  58 test_dir = os.environ.get('TEST_DIR')
  59 output_dir = os.environ.get('OUTPUT_DIR', '.')
  60 cachemode = os.environ.get('CACHEMODE')
  61 qemu_default_machine = os.environ.get('QEMU_DEFAULT_MACHINE')
  62
  63 socket_scm_helper = os.environ.get('SOCKET_SCM_HELPER', 'socket_scm_helper')
  64 debug = False
  65
  66 luks_default_secret_object = 'secret,id=keysec0,data=' + \
  67                              os.environ.get('IMGKEYSECRET', '')
  68 luks_default_key_secret_opt = 'key-secret=keysec0'
  69
  70
  71 def qemu_img(*args):
  72     '''Run qemu-img and return the exit code'''
  73     devnull = open('/dev/null', 'r+')
  74     exitcode = subprocess.call(qemu_img_args + list(args), stdin=devnull, stdout=devnull)
  75     if exitcode < 0:
  76         sys.stderr.write('qemu-img received signal %i: %s\n' % (-exitcode, ' '.join(qemu_img_args + list(args))))
  77     return exitcode
  78
  79 def ordered_qmp(qmsg, conv_keys=True):
  80     # Dictionaries are not ordered prior to 3.6, therefore:
  81     if isinstance(qmsg, list):
  82         return [ordered_qmp(atom) for atom in qmsg]
  83     if isinstance(qmsg, dict):
  84         od = OrderedDict()
  85         for k, v in sorted(qmsg.items()):
  86             if conv_keys:
  87                 k = k.replace('_', '-')
  88             od[k] = ordered_qmp(v, conv_keys=False)
  89         return od
  90     return qmsg
  91
  92 def qemu_img_create(*args):
  93     args = list(args)
  94
  95     # default luks support
  96     if '-f' in args and args[args.index('-f') + 1] == 'luks':
  97         if '-o' in args:
  98             i = args.index('-o')
  99             if 'key-secret' not in args[i + 1]:
 100                 args[i + 1].append(luks_default_key_secret_opt)
 101                 args.insert(i + 2, '--object')
 102                 args.insert(i + 3, luks_default_secret_object)
 103         else:
 104             args = ['-o', luks_default_key_secret_opt,
 105                     '--object', luks_default_secret_object] + args
 106
 107     args.insert(0, 'create')
 108
 109     return qemu_img(*args)
 110
 111 def qemu_img_verbose(*args):
 112     '''Run qemu-img without suppressing its output and return the exit code'''
 113     exitcode = subprocess.call(qemu_img_args + list(args))
 114     if exitcode < 0:
 115         sys.stderr.write('qemu-img received signal %i: %s\n' % (-exitcode, ' '.join(qemu_img_args + list(args))))
 116     return exitcode
 117
 118 def qemu_img_pipe(*args):
 119     '''Run qemu-img and return its output'''
 120     subp = subprocess.Popen(qemu_img_args + list(args),
 121                             stdout=subprocess.PIPE,
 122                             stderr=subprocess.STDOUT,
 123                             universal_newlines=True)
 124     exitcode = subp.wait()
 125     if exitcode < 0:
 126         sys.stderr.write('qemu-img received signal %i: %s\n' % (-exitcode, ' '.join(qemu_img_args + list(args))))
 127     return subp.communicate()[0]
 128
 129 def qemu_img_log(*args):
 130     result = qemu_img_pipe(*args)
 131     log(result, filters=[filter_testfiles])
 132     return result
 133
 134 def img_info_log(filename, filter_path=None, imgopts=False, extra_args=[]):
 135     args = [ 'info' ]
 136     if imgopts:
 137         args.append('--image-opts')
 138     else:
 139         args += [ '-f', imgfmt ]
 140     args += extra_args
 141     args.append(filename)
 142
 143     output = qemu_img_pipe(*args)
 144     if not filter_path:
 145         filter_path = filename
 146     log(filter_img_info(output, filter_path))
 147
 148 def qemu_io(*args):
 149     '''Run qemu-io and return the stdout data'''
 150     args = qemu_io_args + list(args)
 151     subp = subprocess.Popen(args, stdout=subprocess.PIPE,
 152                             stderr=subprocess.STDOUT,
 153                             universal_newlines=True)
 154     exitcode = subp.wait()
 155     if exitcode < 0:
 156         sys.stderr.write('qemu-io received signal %i: %s\n' % (-exitcode, ' '.join(args)))
 157     return subp.communicate()[0]
 158
 159 def qemu_io_silent(*args):
 160     '''Run qemu-io and return the exit code, suppressing stdout'''
 161     args = qemu_io_args + list(args)
 162     exitcode = subprocess.call(args, stdout=open('/dev/null', 'w'))
 163     if exitcode < 0:
 164         sys.stderr.write('qemu-io received signal %i: %s\n' %
 165                          (-exitcode, ' '.join(args)))
 166     return exitcode
 167
 168
 169 class QemuIoInteractive:
 170     def __init__(self, *args):
 171         self.args = qemu_io_args + list(args)
 172         self._p = subprocess.Popen(self.args, stdin=subprocess.PIPE,
 173                                    stdout=subprocess.PIPE,
 174                                    stderr=subprocess.STDOUT,
 175                                    universal_newlines=True)
 176         assert self._p.stdout.read(9) == 'qemu-io> '
 177
 178     def close(self):
 179         self._p.communicate('q\n')
 180
 181     def _read_output(self):
 182         pattern = 'qemu-io> '
 183         n = len(pattern)
 184         pos = 0
 185         s = []
 186         while pos != n:
 187             c = self._p.stdout.read(1)
 188             # check unexpected EOF
 189             assert c != ''
 190             s.append(c)
 191             if c == pattern[pos]:
 192                 pos += 1
 193             else:
 194                 pos = 0
 195
 196         return ''.join(s[:-n])
 197
 198     def cmd(self, cmd):
 199         # quit command is in close(), '\n' is added automatically
 200         assert '\n' not in cmd
 201         cmd = cmd.strip()
 202         assert cmd != 'q' and cmd != 'quit'
 203         self._p.stdin.write(cmd + '\n')
 204         self._p.stdin.flush()
 205         return self._read_output()
 206
 207
 208 def qemu_nbd(*args):
 209     '''Run qemu-nbd in daemon mode and return the parent's exit code'''
 210     return subprocess.call(qemu_nbd_args + ['--fork'] + list(args))
 211
 212 def qemu_nbd_early_pipe(*args):
 213     '''Run qemu-nbd in daemon mode and return both the parent's exit code
 214        and its output in case of an error'''
 215     subp = subprocess.Popen(qemu_nbd_args + ['--fork'] + list(args),
 216                             stdout=subprocess.PIPE,
 217                             stderr=subprocess.STDOUT,
 218                             universal_newlines=True)
 219     exitcode = subp.wait()
 220     if exitcode < 0:
 221         sys.stderr.write('qemu-nbd received signal %i: %s\n' %
 222                          (-exitcode,
 223                           ' '.join(qemu_nbd_args + ['--fork'] + list(args))))
 224     if exitcode == 0:
 225         return exitcode, ''
 226     else:
 227         return exitcode, subp.communicate()[0]
 228
 229 def compare_images(img1, img2, fmt1=imgfmt, fmt2=imgfmt):
 230     '''Return True if two image files are identical'''
 231     return qemu_img('compare', '-f', fmt1,
 232                     '-F', fmt2, img1, img2) == 0
 233
 234 def create_image(name, size):
 235     '''Create a fully-allocated raw image with sector markers'''
 236     file = open(name, 'wb')
 237     i = 0
 238     while i < size:
 239         sector = struct.pack('>l504xl', i // 512, i // 512)
 240         file.write(sector)
 241         i = i + 512
 242     file.close()
 243
 244 def image_size(img):
 245     '''Return image's virtual size'''
 246     r = qemu_img_pipe('info', '--output=json', '-f', imgfmt, img)
 247     return json.loads(r)['virtual-size']
 248
 249 def is_str(val):
 250     if sys.version_info.major >= 3:
 251         return isinstance(val, str)
 252     else:
 253         return isinstance(val, str) or isinstance(val, unicode)
 254
 255 test_dir_re = re.compile(r"%s" % test_dir)
 256 def filter_test_dir(msg):
 257     return test_dir_re.sub("TEST_DIR", msg)
 258
 259 win32_re = re.compile(r"\r")
 260 def filter_win32(msg):
 261     return win32_re.sub("", msg)
 262
 263 qemu_io_re = re.compile(r"[0-9]* ops; [0-9\/:. sec]* \([0-9\/.inf]* [EPTGMKiBbytes]*\/sec and [0-9\/.inf]* ops\/sec\)")
 264 def filter_qemu_io(msg):
 265     msg = filter_win32(msg)
 266     return qemu_io_re.sub("X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)", msg)
 267
 268 chown_re = re.compile(r"chown [0-9]+:[0-9]+")
 269 def filter_chown(msg):
 270     return chown_re.sub("chown UID:GID", msg)
 271
 272 def filter_qmp_event(event):
 273     '''Filter a QMP event dict'''
 274     event = dict(event)
 275     if 'timestamp' in event:
 276         event['timestamp']['seconds'] = 'SECS'
 277         event['timestamp']['microseconds'] = 'USECS'
 278     return event
 279
 280 def filter_qmp(qmsg, filter_fn):
 281     '''Given a string filter, filter a QMP object's values.
 282     filter_fn takes a (key, value) pair.'''
 283     # Iterate through either lists or dicts;
 284     if isinstance(qmsg, list):
 285         items = enumerate(qmsg)
 286     else:
 287         items = qmsg.items()
 288
 289     for k, v in items:
 290         if isinstance(v, list) or isinstance(v, dict):
 291             qmsg[k] = filter_qmp(v, filter_fn)
 292         else:
 293             qmsg[k] = filter_fn(k, v)
 294     return qmsg
 295
 296 def filter_testfiles(msg):
 297     prefix = os.path.join(test_dir, "%s-" % (os.getpid()))
 298     return msg.replace(prefix, 'TEST_DIR/PID-')
 299
 300 def filter_qmp_testfiles(qmsg):
 301     def _filter(key, value):
 302         if is_str(value):
 303             return filter_testfiles(value)
 304         return value
 305     return filter_qmp(qmsg, _filter)
 306
 307 def filter_generated_node_ids(msg):
 308     return re.sub("#block[0-9]+", "NODE_NAME", msg)
 309
 310 def filter_img_info(output, filename):
 311     lines = []
 312     for line in output.split('\n'):
 313         if 'disk size' in line or 'actual-size' in line:
 314             continue
 315         line = line.replace(filename, 'TEST_IMG') \
 316                    .replace(imgfmt, 'IMGFMT')
 317         line = re.sub('iters: [0-9]+', 'iters: XXX', line)
 318         line = re.sub('uuid: [-a-f0-9]+', 'uuid: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX', line)
 319         line = re.sub('cid: [0-9]+', 'cid: XXXXXXXXXX', line)
 320         lines.append(line)
 321     return '\n'.join(lines)
 322
 323 def filter_imgfmt(msg):
 324     return msg.replace(imgfmt, 'IMGFMT')
 325
 326 def filter_qmp_imgfmt(qmsg):
 327     def _filter(key, value):
 328         if is_str(value):
 329             return filter_imgfmt(value)
 330         return value
 331     return filter_qmp(qmsg, _filter)
 332
 333 def log(msg, filters=[], indent=None):
 334     '''Logs either a string message or a JSON serializable message (like QMP).
 335     If indent is provided, JSON serializable messages are pretty-printed.'''
 336     for flt in filters:
 337         msg = flt(msg)
 338     if isinstance(msg, dict) or isinstance(msg, list):
 339         # Python < 3.4 needs to know not to add whitespace when pretty-printing:
 340         separators = (', ', ': ') if indent is None else (',', ': ')
 341         # Don't sort if it's already sorted
 342         do_sort = not isinstance(msg, OrderedDict)
 343         print(json.dumps(msg, sort_keys=do_sort,
 344                          indent=indent, separators=separators))
 345     else:
 346         print(msg)
 347
 348 class Timeout:
 349     def __init__(self, seconds, errmsg = "Timeout"):
 350         self.seconds = seconds
 351         self.errmsg = errmsg
 352     def __enter__(self):
 353         signal.signal(signal.SIGALRM, self.timeout)
 354         signal.setitimer(signal.ITIMER_REAL, self.seconds)
 355         return self
 356     def __exit__(self, type, value, traceback):
 357         signal.setitimer(signal.ITIMER_REAL, 0)
 358         return False
 359     def timeout(self, signum, frame):
 360         raise Exception(self.errmsg)
 361
 362
 363 class FilePath(object):
 364     '''An auto-generated filename that cleans itself up.
 365
 366     Use this context manager to generate filenames and ensure that the file
 367     gets deleted::
 368
 369         with TestFilePath('test.img') as img_path:
 370             qemu_img('create', img_path, '1G')
 371         # migration_sock_path is automatically deleted
 372     '''
 373     def __init__(self, name):
 374         filename = '{0}-{1}'.format(os.getpid(), name)
 375         self.path = os.path.join(test_dir, filename)
 376
 377     def __enter__(self):
 378         return self.path
 379
 380     def __exit__(self, exc_type, exc_val, exc_tb):
 381         try:
 382             os.remove(self.path)
 383         except OSError:
 384             pass
 385         return False
 386
 387
 388 def file_path_remover():
 389     for path in reversed(file_path_remover.paths):
 390         try:
 391             os.remove(path)
 392         except OSError:
 393             pass
 394
 395
 396 def file_path(*names):
 397     ''' Another way to get auto-generated filename that cleans itself up.
 398
 399     Use is as simple as:
 400
 401     img_a, img_b = file_path('a.img', 'b.img')
 402     sock = file_path('socket')
 403     '''
 404
 405     if not hasattr(file_path_remover, 'paths'):
 406         file_path_remover.paths = []
 407         atexit.register(file_path_remover)
 408
 409     paths = []
 410     for name in names:
 411         filename = '{0}-{1}'.format(os.getpid(), name)
 412         path = os.path.join(test_dir, filename)
 413         file_path_remover.paths.append(path)
 414         paths.append(path)
 415
 416     return paths[0] if len(paths) == 1 else paths
 417
 418 def remote_filename(path):
 419     if imgproto == 'file':
 420         return path
 421     elif imgproto == 'ssh':
 422         return "ssh://%s@127.0.0.1:22%s" % (os.environ.get('USER'), path)
 423     else:
 424         raise Exception("Protocol %s not supported" % (imgproto))
 425
 426 class VM(qtest.QEMUQtestMachine):
 427     '''A QEMU VM'''
 428
 429     def __init__(self, path_suffix=''):
 430         name = "qemu%s-%d" % (path_suffix, os.getpid())
 431         super(VM, self).__init__(qemu_prog, qemu_opts, name=name,
 432                                  test_dir=test_dir,
 433                                  socket_scm_helper=socket_scm_helper)
 434         self._num_drives = 0
 435
 436     def add_object(self, opts):
 437         self._args.append('-object')
 438         self._args.append(opts)
 439         return self
 440
 441     def add_device(self, opts):
 442         self._args.append('-device')
 443         self._args.append(opts)
 444         return self
 445
 446     def add_drive_raw(self, opts):
 447         self._args.append('-drive')
 448         self._args.append(opts)
 449         return self
 450
 451     def add_drive(self, path, opts='', interface='virtio', format=imgfmt):
 452         '''Add a virtio-blk drive to the VM'''
 453         options = ['if=%s' % interface,
 454                    'id=drive%d' % self._num_drives]
 455
 456         if path is not None:
 457             options.append('file=%s' % path)
 458             options.append('format=%s' % format)
 459             options.append('cache=%s' % cachemode)
 460
 461         if opts:
 462             options.append(opts)
 463
 464         if format == 'luks' and 'key-secret' not in opts:
 465             # default luks support
 466             if luks_default_secret_object not in self._args:
 467                 self.add_object(luks_default_secret_object)
 468
 469             options.append(luks_default_key_secret_opt)
 470
 471         self._args.append('-drive')
 472         self._args.append(','.join(options))
 473         self._num_drives += 1
 474         return self
 475
 476     def add_blockdev(self, opts):
 477         self._args.append('-blockdev')
 478         if isinstance(opts, str):
 479             self._args.append(opts)
 480         else:
 481             self._args.append(','.join(opts))
 482         return self
 483
 484     def add_incoming(self, addr):
 485         self._args.append('-incoming')
 486         self._args.append(addr)
 487         return self
 488
 489     def pause_drive(self, drive, event=None):
 490         '''Pause drive r/w operations'''
 491         if not event:
 492             self.pause_drive(drive, "read_aio")
 493             self.pause_drive(drive, "write_aio")
 494             return
 495         self.qmp('human-monitor-command',
 496                     command_line='qemu-io %s "break %s bp_%s"' % (drive, event, drive))
 497
 498     def resume_drive(self, drive):
 499         self.qmp('human-monitor-command',
 500                     command_line='qemu-io %s "remove_break bp_%s"' % (drive, drive))
 501
 502     def hmp_qemu_io(self, drive, cmd):
 503         '''Write to a given drive using an HMP command'''
 504         return self.qmp('human-monitor-command',
 505                         command_line='qemu-io %s "%s"' % (drive, cmd))
 506
 507     def flatten_qmp_object(self, obj, output=None, basestr=''):
 508         if output is None:
 509             output = dict()
 510         if isinstance(obj, list):
 511             for i in range(len(obj)):
 512                 self.flatten_qmp_object(obj[i], output, basestr + str(i) + '.')
 513         elif isinstance(obj, dict):
 514             for key in obj:
 515                 self.flatten_qmp_object(obj[key], output, basestr + key + '.')
 516         else:
 517             output[basestr[:-1]] = obj # Strip trailing '.'
 518         return output
 519
 520     def qmp_to_opts(self, obj):
 521         obj = self.flatten_qmp_object(obj)
 522         output_list = list()
 523         for key in obj:
 524             output_list += [key + '=' + obj[key]]
 525         return ','.join(output_list)
 526
 527     def get_qmp_events_filtered(self, wait=60.0):
 528         result = []
 529         for ev in self.get_qmp_events(wait=wait):
 530             result.append(filter_qmp_event(ev))
 531         return result
 532
 533     def qmp_log(self, cmd, filters=[], indent=None, **kwargs):
 534         full_cmd = OrderedDict((
 535             ("execute", cmd),
 536             ("arguments", ordered_qmp(kwargs))
 537         ))
 538         log(full_cmd, filters, indent=indent)
 539         result = self.qmp(cmd, **kwargs)
 540         log(result, filters, indent=indent)
 541         return result
 542
 543     # Returns None on success, and an error string on failure
 544     def run_job(self, job, auto_finalize=True, auto_dismiss=False,
 545                 pre_finalize=None, wait=60.0):
 546         match_device = {'data': {'device': job}}
 547         match_id = {'data': {'id': job}}
 548         events = [
 549             ('BLOCK_JOB_COMPLETED', match_device),
 550             ('BLOCK_JOB_CANCELLED', match_device),
 551             ('BLOCK_JOB_ERROR', match_device),
 552             ('BLOCK_JOB_READY', match_device),
 553             ('BLOCK_JOB_PENDING', match_id),
 554             ('JOB_STATUS_CHANGE', match_id)
 555         ]
 556         error = None
 557         while True:
 558             ev = filter_qmp_event(self.events_wait(events))
 559             if ev['event'] != 'JOB_STATUS_CHANGE':
 560                 log(ev)
 561                 continue
 562             status = ev['data']['status']
 563             if status == 'aborting':
 564                 result = self.qmp('query-jobs')
 565                 for j in result['return']:
 566                     if j['id'] == job:
 567                         error = j['error']
 568                         log('Job failed: %s' % (j['error']))
 569             elif status == 'pending' and not auto_finalize:
 570                 if pre_finalize:
 571                     pre_finalize()
 572                 self.qmp_log('job-finalize', id=job)
 573             elif status == 'concluded' and not auto_dismiss:
 574                 self.qmp_log('job-dismiss', id=job)
 575             elif status == 'null':
 576                 return error
 577
 578     def node_info(self, node_name):
 579         nodes = self.qmp('query-named-block-nodes')
 580         for x in nodes['return']:
 581             if x['node-name'] == node_name:
 582                 return x
 583         return None
 584
 585
 586 index_re = re.compile(r'([^\[]+)\[([^\]]+)\]')
 587
 588 class QMPTestCase(unittest.TestCase):
 589     '''Abstract base class for QMP test cases'''
 590
 591     def dictpath(self, d, path):
 592         '''Traverse a path in a nested dict'''
 593         for component in path.split('/'):
 594             m = index_re.match(component)
 595             if m:
 596                 component, idx = m.groups()
 597                 idx = int(idx)
 598
 599             if not isinstance(d, dict) or component not in d:
 600                 self.fail('failed path traversal for "%s" in "%s"' % (path, str(d)))
 601             d = d[component]
 602
 603             if m:
 604                 if not isinstance(d, list):
 605                     self.fail('path component "%s" in "%s" is not a list in "%s"' % (component, path, str(d)))
 606                 try:
 607                     d = d[idx]
 608                 except IndexError:
 609                     self.fail('invalid index "%s" in path "%s" in "%s"' % (idx, path, str(d)))
 610         return d
 611
 612     def assert_qmp_absent(self, d, path):
 613         try:
 614             result = self.dictpath(d, path)
 615         except AssertionError:
 616             return
 617         self.fail('path "%s" has value "%s"' % (path, str(result)))
 618
 619     def assert_qmp(self, d, path, value):
 620         '''Assert that the value for a specific path in a QMP dict
 621            matches.  When given a list of values, assert that any of
 622            them matches.'''
 623
 624         result = self.dictpath(d, path)
 625
 626         # [] makes no sense as a list of valid values, so treat it as
 627         # an actual single value.
 628         if isinstance(value, list) and value != []:
 629             for v in value:
 630                 if result == v:
 631                     return
 632             self.fail('no match for "%s" in %s' % (str(result), str(value)))
 633         else:
 634             self.assertEqual(result, value,
 635                              'values not equal "%s" and "%s"'
 636                                  % (str(result), str(value)))
 637
 638     def assert_no_active_block_jobs(self):
 639         result = self.vm.qmp('query-block-jobs')
 640         self.assert_qmp(result, 'return', [])
 641
 642     def assert_has_block_node(self, node_name=None, file_name=None):
 643         """Issue a query-named-block-nodes and assert node_name and/or
 644         file_name is present in the result"""
 645         def check_equal_or_none(a, b):
 646             return a == None or b == None or a == b
 647         assert node_name or file_name
 648         result = self.vm.qmp('query-named-block-nodes')
 649         for x in result["return"]:
 650             if check_equal_or_none(x.get("node-name"), node_name) and \
 651                     check_equal_or_none(x.get("file"), file_name):
 652                 return
 653         self.assertTrue(False, "Cannot find %s %s in result:\n%s" % \
 654                 (node_name, file_name, result))
 655
 656     def assert_json_filename_equal(self, json_filename, reference):
 657         '''Asserts that the given filename is a json: filename and that its
 658            content is equal to the given reference object'''
 659         self.assertEqual(json_filename[:5], 'json:')
 660         self.assertEqual(self.vm.flatten_qmp_object(json.loads(json_filename[5:])),
 661                          self.vm.flatten_qmp_object(reference))
 662
 663     def cancel_and_wait(self, drive='drive0', force=False, resume=False, wait=60.0):
 664         '''Cancel a block job and wait for it to finish, returning the event'''
 665         result = self.vm.qmp('block-job-cancel', device=drive, force=force)
 666         self.assert_qmp(result, 'return', {})
 667
 668         if resume:
 669             self.vm.resume_drive(drive)
 670
 671         cancelled = False
 672         result = None
 673         while not cancelled:
 674             for event in self.vm.get_qmp_events(wait=wait):
 675                 if event['event'] == 'BLOCK_JOB_COMPLETED' or \
 676                    event['event'] == 'BLOCK_JOB_CANCELLED':
 677                     self.assert_qmp(event, 'data/device', drive)
 678                     result = event
 679                     cancelled = True
 680                 elif event['event'] == 'JOB_STATUS_CHANGE':
 681                     self.assert_qmp(event, 'data/id', drive)
 682
 683
 684         self.assert_no_active_block_jobs()
 685         return result
 686
 687     def wait_until_completed(self, drive='drive0', check_offset=True, wait=60.0):
 688         '''Wait for a block job to finish, returning the event'''
 689         while True:
 690             for event in self.vm.get_qmp_events(wait=wait):
 691                 if event['event'] == 'BLOCK_JOB_COMPLETED':
 692                     self.assert_qmp(event, 'data/device', drive)
 693                     self.assert_qmp_absent(event, 'data/error')
 694                     if check_offset:
 695                         self.assert_qmp(event, 'data/offset', event['data']['len'])
 696                     self.assert_no_active_block_jobs()
 697                     return event
 698                 elif event['event'] == 'JOB_STATUS_CHANGE':
 699                     self.assert_qmp(event, 'data/id', drive)
 700
 701     def wait_ready(self, drive='drive0'):
 702         '''Wait until a block job BLOCK_JOB_READY event'''
 703         f = {'data': {'type': 'mirror', 'device': drive } }
 704         event = self.vm.event_wait(name='BLOCK_JOB_READY', match=f)
 705
 706     def wait_ready_and_cancel(self, drive='drive0'):
 707         self.wait_ready(drive=drive)
 708         event = self.cancel_and_wait(drive=drive)
 709         self.assertEqual(event['event'], 'BLOCK_JOB_COMPLETED')
 710         self.assert_qmp(event, 'data/type', 'mirror')
 711         self.assert_qmp(event, 'data/offset', event['data']['len'])
 712
 713     def complete_and_wait(self, drive='drive0', wait_ready=True):
 714         '''Complete a block job and wait for it to finish'''
 715         if wait_ready:
 716             self.wait_ready(drive=drive)
 717
 718         result = self.vm.qmp('block-job-complete', device=drive)
 719         self.assert_qmp(result, 'return', {})
 720
 721         event = self.wait_until_completed(drive=drive)
 722         self.assert_qmp(event, 'data/type', 'mirror')
 723
 724     def pause_wait(self, job_id='job0'):
 725         with Timeout(1, "Timeout waiting for job to pause"):
 726             while True:
 727                 result = self.vm.qmp('query-block-jobs')
 728                 found = False
 729                 for job in result['return']:
 730                     if job['device'] == job_id:
 731                         found = True
 732                         if job['paused'] == True and job['busy'] == False:
 733                             return job
 734                         break
 735                 assert found
 736
 737     def pause_job(self, job_id='job0', wait=True):
 738         result = self.vm.qmp('block-job-pause', device=job_id)
 739         self.assert_qmp(result, 'return', {})
 740         if wait:
 741             return self.pause_wait(job_id)
 742         return result
 743
 744
 745 def notrun(reason):
 746     '''Skip this test suite'''
 747     # Each test in qemu-iotests has a number ("seq")
 748     seq = os.path.basename(sys.argv[0])
 749
 750     open('%s/%s.notrun' % (output_dir, seq), 'w').write(reason + '\n')
 751     print('%s not run: %s' % (seq, reason))
 752     sys.exit(0)
 753
 754 def case_notrun(reason):
 755     '''Skip this test case'''
 756     # Each test in qemu-iotests has a number ("seq")
 757     seq = os.path.basename(sys.argv[0])
 758
 759     open('%s/%s.casenotrun' % (output_dir, seq), 'a').write(
 760         '    [case not run] ' + reason + '\n')
 761
 762 def verify_image_format(supported_fmts=[], unsupported_fmts=[]):
 763     assert not (supported_fmts and unsupported_fmts)
 764
 765     if 'generic' in supported_fmts and \
 766             os.environ.get('IMGFMT_GENERIC', 'true') == 'true':
 767         # similar to
 768         #   _supported_fmt generic
 769         # for bash tests
 770         return
 771
 772     not_sup = supported_fmts and (imgfmt not in supported_fmts)
 773     if not_sup or (imgfmt in unsupported_fmts):
 774         notrun('not suitable for this image format: %s' % imgfmt)
 775
 776 def verify_protocol(supported=[], unsupported=[]):
 777     assert not (supported and unsupported)
 778
 779     if 'generic' in supported:
 780         return
 781
 782     not_sup = supported and (imgproto not in supported)
 783     if not_sup or (imgproto in unsupported):
 784         notrun('not suitable for this protocol: %s' % imgproto)
 785
 786 def verify_platform(supported_oses=['linux']):
 787     if True not in [sys.platform.startswith(x) for x in supported_oses]:
 788         notrun('not suitable for this OS: %s' % sys.platform)
 789
 790 def verify_cache_mode(supported_cache_modes=[]):
 791     if supported_cache_modes and (cachemode not in supported_cache_modes):
 792         notrun('not suitable for this cache mode: %s' % cachemode)
 793
 794 def supports_quorum():
 795     return 'quorum' in qemu_img_pipe('--help')
 796
 797 def verify_quorum():
 798     '''Skip test suite if quorum support is not available'''
 799     if not supports_quorum():
 800         notrun('quorum support missing')
 801
 802 def qemu_pipe(*args):
 803     '''Run qemu with an option to print something and exit (e.g. a help option),
 804     and return its output'''
 805     args = [qemu_prog] + qemu_opts + list(args)
 806     subp = subprocess.Popen(args, stdout=subprocess.PIPE,
 807                             stderr=subprocess.STDOUT,
 808                             universal_newlines=True)
 809     exitcode = subp.wait()
 810     if exitcode < 0:
 811         sys.stderr.write('qemu received signal %i: %s\n' % (-exitcode,
 812                          ' '.join(args)))
 813     return subp.communicate()[0]
 814
 815 def supported_formats(read_only=False):
 816     '''Set 'read_only' to True to check ro-whitelist
 817        Otherwise, rw-whitelist is checked'''
 818     format_message = qemu_pipe("-drive", "format=help")
 819     line = 1 if read_only else 0
 820     return format_message.splitlines()[line].split(":")[1].split()
 821
 822 def skip_if_unsupported(required_formats=[], read_only=False):
 823     '''Skip Test Decorator
 824        Runs the test if all the required formats are whitelisted'''
 825     def skip_test_decorator(func):
 826         def func_wrapper(*args, **kwargs):
 827             usf_list = list(set(required_formats) -
 828                             set(supported_formats(read_only)))
 829             if usf_list:
 830                 case_notrun('{}: formats {} are not whitelisted'.format(
 831                     args[0], usf_list))
 832             else:
 833                 return func(*args, **kwargs)
 834         return func_wrapper
 835     return skip_test_decorator
 836
 837 def main(supported_fmts=[], supported_oses=['linux'], supported_cache_modes=[],
 838          unsupported_fmts=[]):
 839     '''Run tests'''
 840
 841     global debug
 842
 843     # We are using TEST_DIR and QEMU_DEFAULT_MACHINE as proxies to
 844     # indicate that we're not being run via "check". There may be
 845     # other things set up by "check" that individual test cases rely
 846     # on.
 847     if test_dir is None or qemu_default_machine is None:
 848         sys.stderr.write('Please run this test via the "check" script\n')
 849         sys.exit(os.EX_USAGE)
 850
 851     debug = '-d' in sys.argv
 852     verbosity = 1
 853     verify_image_format(supported_fmts, unsupported_fmts)
 854     verify_platform(supported_oses)
 855     verify_cache_mode(supported_cache_modes)
 856
 857     if debug:
 858         output = sys.stdout
 859         verbosity = 2
 860         sys.argv.remove('-d')
 861     else:
 862         # We need to filter out the time taken from the output so that
 863         # qemu-iotest can reliably diff the results against master output.
 864         if sys.version_info.major >= 3:
 865             output = io.StringIO()
 866         else:
 867             # io.StringIO is for unicode strings, which is not what
 868             # 2.x's test runner emits.
 869             output = io.BytesIO()
 870
 871     logging.basicConfig(level=(logging.DEBUG if debug else logging.WARN))
 872
 873     class MyTestRunner(unittest.TextTestRunner):
 874         def __init__(self, stream=output, descriptions=True, verbosity=verbosity):
 875             unittest.TextTestRunner.__init__(self, stream, descriptions, verbosity)
 876
 877     # unittest.main() will use sys.exit() so expect a SystemExit exception
 878     try:
 879         unittest.main(testRunner=MyTestRunner)
 880     finally:
 881         if not debug:
 882             sys.stderr.write(re.sub(r'Ran (\d+) tests? in [\d.]+s', r'Ran \1 tests', output.getvalue()))