Commit e3643d32 authored by Peter Maydell's avatar Peter Maydell
Browse files

Merge remote-tracking branch 'remotes/amit-migration/tags/migration-for-2.7-6' into staging 



Migration:
- Fix a postcopy bug
- Add a testsuite for measuring migration performance

# gpg: Signature made Fri 22 Jul 2016 08:56:44 BST
# gpg:                using RSA key 0xEB0B4DFC657EF670
# gpg: Good signature from "Amit Shah <amit@amitshah.net>"
# gpg:                 aka "Amit Shah <amit@kernel.org>"
# gpg:                 aka "Amit Shah <amitshah@gmx.net>"
# Primary key fingerprint: 48CA 3722 5FE7 F4A8 B337  2735 1E9A 3B5F 8540 83B6
#      Subkey fingerprint: CC63 D332 AB8F 4617 4529  6534 EB0B 4DFC 657E F670

* remotes/amit-migration/tags/migration-for-2.7-6:
  tests: introduce a framework for testing migration performance
  scripts: ensure monitor socket has SO_REUSEADDR set
  scripts: set timeout when waiting for qemu monitor connection
  scripts: refactor the VM class in iotests for reuse
  scripts: add a 'debug' parameter to QEMUMonitorProtocol
  scripts: add __init__.py file to scripts/qmp/
  migration: set state to post-migrate on failure

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents 206d0c24 409437e1

configure

+2 −0
Original line number Diff line number Diff line
@@ -3121,6 +3121,7 @@ else 
      if test "$found" = "no"; then

        LIBS="$pthread_lib $LIBS"

      fi

      PTHREAD_LIB="$pthread_lib"

      break

    fi

  done
@@ -5537,6 +5538,7 @@ echo "LDFLAGS_NOPIE=$LDFLAGS_NOPIE" >> $config_host_mak 
echo "LD_REL_FLAGS=$LD_REL_FLAGS" >> $config_host_mak

echo "LIBS+=$LIBS" >> $config_host_mak

echo "LIBS_TOOLS+=$libs_tools" >> $config_host_mak

echo "PTHREAD_LIB=$PTHREAD_LIB" >> $config_host_mak

echo "EXESUF=$EXESUF" >> $config_host_mak

echo "DSOSUF=$DSOSUF" >> $config_host_mak

echo "LDFLAGS_SHARED=$LDFLAGS_SHARED" >> $config_host_mak

migration/migration.c

+4 −0
Original line number Diff line number Diff line
@@ -1837,6 +1837,10 @@ static void *migration_thread(void *opaque) 
    } else {

        if (old_vm_running && !entered_postcopy) {

            vm_start();

        } else {

            if (runstate_check(RUN_STATE_FINISH_MIGRATE)) {

                runstate_set(RUN_STATE_POSTMIGRATE);

            }

        }

    }

    qemu_bh_schedule(s->cleanup_bh);

scripts/qemu.py

0 → 100644
+202 −0
Original line number Diff line number Diff line 
# QEMU library

#

# Copyright (C) 2015-2016 Red Hat Inc.

# Copyright (C) 2012 IBM Corp.

#

# Authors:

#  Fam Zheng <famz@redhat.com>

#

# This work is licensed under the terms of the GNU GPL, version 2.  See

# the COPYING file in the top-level directory.

#

# Based on qmp.py.

#



import errno

import string

import os

import sys

import subprocess

import qmp.qmp





class QEMUMachine(object):

    '''A QEMU VM'''



    def __init__(self, binary, args=[], wrapper=[], name=None, test_dir="/var/tmp",

                 monitor_address=None, debug=False):

        if name is None:

            name = "qemu-%d" % os.getpid()

        if monitor_address is None:

            monitor_address = os.path.join(test_dir, name + "-monitor.sock")

        self._monitor_address = monitor_address

        self._qemu_log_path = os.path.join(test_dir, name + ".log")

        self._popen = None

        self._binary = binary

        self._args = args

        self._wrapper = wrapper

        self._events = []

        self._iolog = None

        self._debug = debug



    # This can be used to add an unused monitor instance.

    def add_monitor_telnet(self, ip, port):

        args = 'tcp:%s:%d,server,nowait,telnet' % (ip, port)

        self._args.append('-monitor')

        self._args.append(args)



    def add_fd(self, fd, fdset, opaque, opts=''):

        '''Pass a file descriptor to the VM'''

        options = ['fd=%d' % fd,

                   'set=%d' % fdset,

                   'opaque=%s' % opaque]

        if opts:

            options.append(opts)



        self._args.append('-add-fd')

        self._args.append(','.join(options))

        return self



    def send_fd_scm(self, fd_file_path):

        # In iotest.py, the qmp should always use unix socket.

        assert self._qmp.is_scm_available()

        bin = socket_scm_helper

        if os.path.exists(bin) == False:

            print "Scm help program does not present, path '%s'." % bin

            return -1

        fd_param = ["%s" % bin,

                    "%d" % self._qmp.get_sock_fd(),

                    "%s" % fd_file_path]

        devnull = open('/dev/null', 'rb')

        p = subprocess.Popen(fd_param, stdin=devnull, stdout=sys.stdout,

                             stderr=sys.stderr)

        return p.wait()



    @staticmethod

    def _remove_if_exists(path):

        '''Remove file object at path if it exists'''

        try:

            os.remove(path)

        except OSError as exception:

            if exception.errno == errno.ENOENT:

                return

            raise



    def get_pid(self):

        if not self._popen:

            return None

        return self._popen.pid



    def _load_io_log(self):

        with open(self._qemu_log_path, "r") as fh:

            self._iolog = fh.read()



    def _base_args(self):

        if isinstance(self._monitor_address, tuple):

            moncdev = "socket,id=mon,host=%s,port=%s" % (

                self._monitor_address[0],

                self._monitor_address[1])

        else:

            moncdev = 'socket,id=mon,path=%s' % self._monitor_address

        return ['-chardev', moncdev,

                '-mon', 'chardev=mon,mode=control',

                '-display', 'none', '-vga', 'none']



    def _pre_launch(self):

        self._qmp = qmp.qmp.QEMUMonitorProtocol(self._monitor_address, server=True,

                                                debug=self._debug)



    def _post_launch(self):

        self._qmp.accept()



    def _post_shutdown(self):

        if not isinstance(self._monitor_address, tuple):

            self._remove_if_exists(self._monitor_address)

        self._remove_if_exists(self._qemu_log_path)



    def launch(self):

        '''Launch the VM and establish a QMP connection'''

        devnull = open('/dev/null', 'rb')

        qemulog = open(self._qemu_log_path, 'wb')

        try:

            self._pre_launch()

            args = self._wrapper + [self._binary] + self._base_args() + self._args

            self._popen = subprocess.Popen(args, stdin=devnull, stdout=qemulog,

                                           stderr=subprocess.STDOUT, shell=False)

            self._post_launch()

        except:

            if self._popen:

                self._popen.kill()

            self._load_io_log()

            self._post_shutdown()

            self._popen = None

            raise



    def shutdown(self):

        '''Terminate the VM and clean up'''

        if not self._popen is None:

            try:

                self._qmp.cmd('quit')

                self._qmp.close()

            except:

                self._popen.kill()



            exitcode = self._popen.wait()

            if exitcode < 0:

                sys.stderr.write('qemu received signal %i: %s\n' % (-exitcode, ' '.join(self._args)))

            self._load_io_log()

            self._post_shutdown()

            self._popen = None



    underscore_to_dash = string.maketrans('_', '-')

    def qmp(self, cmd, conv_keys=True, **args):

        '''Invoke a QMP command and return the result dict'''

        qmp_args = dict()

        for k in args.keys():

            if conv_keys:

                qmp_args[k.translate(self.underscore_to_dash)] = args[k]

            else:

                qmp_args[k] = args[k]



        return self._qmp.cmd(cmd, args=qmp_args)



    def command(self, cmd, conv_keys=True, **args):

        reply = self.qmp(cmd, conv_keys, **args)

        if reply is None:

            raise Exception("Monitor is closed")

        if "error" in reply:

            raise Exception(reply["error"]["desc"])

        return reply["return"]



    def get_qmp_event(self, wait=False):

        '''Poll for one queued QMP events and return it'''

        if len(self._events) > 0:

            return self._events.pop(0)

        return self._qmp.pull_event(wait=wait)



    def get_qmp_events(self, wait=False):

        '''Poll for queued QMP events and return a list of dicts'''

        events = self._qmp.get_events(wait=wait)

        events.extend(self._events)

        del self._events[:]

        self._qmp.clear_events()

        return events



    def event_wait(self, name, timeout=60.0, match=None):

        # Search cached events

        for event in self._events:

            if (event['event'] == name) and event_match(event, match):

                self._events.remove(event)

                return event



        # Poll for new events

        while True:

            event = self._qmp.pull_event(wait=timeout)

            if (event['event'] == name) and event_match(event, match):

                return event

            self._events.append(event)



        return None



    def get_log(self):

        return self._iolog

scripts/qmp/__init__.py

0 → 100644
+0 −0

Empty file added.

scripts/qmp/qmp.py

+13 −2
Original line number Diff line number Diff line
@@ -11,6 +11,7 @@ 
import json

import errno

import socket

import sys



class QMPError(Exception):

    pass
@@ -25,7 +26,7 @@ class QMPTimeoutError(QMPError): 
    pass



class QEMUMonitorProtocol:

    def __init__(self, address, server=False):

    def __init__(self, address, server=False, debug=False):

        """

        Create a QEMUMonitorProtocol class.
@@ -39,8 +40,10 @@ class QEMUMonitorProtocol: 
        """

        self.__events = []

        self.__address = address

        self._debug = debug

        self.__sock = self.__get_sock()

        if server:

            self.__sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

            self.__sock.bind(self.__address)

            self.__sock.listen(1)
@@ -68,6 +71,8 @@ class QEMUMonitorProtocol: 
                return

            resp = json.loads(data)

            if 'event' in resp:

                if self._debug:

                    print >>sys.stderr, "QMP:<<< %s" % resp

                self.__events.append(resp)

                if not only_event:

                    continue
@@ -136,6 +141,7 @@ class QEMUMonitorProtocol: 
        @raise QMPConnectError if the greeting is not received

        @raise QMPCapabilitiesError if fails to negotiate capabilities

        """

        self.__sock.settimeout(15)

        self.__sock, _ = self.__sock.accept()

        self.__sockfile = self.__sock.makefile()

        return self.__negotiate_capabilities()
@@ -148,13 +154,18 @@ class QEMUMonitorProtocol: 
        @return QMP response as a Python dict or None if the connection has

                been closed

        """

        if self._debug:

            print >>sys.stderr, "QMP:>>> %s" % qmp_cmd

        try:

            self.__sock.sendall(json.dumps(qmp_cmd))

        except socket.error as err:

            if err[0] == errno.EPIPE:

                return

            raise socket.error(err)

        return self.__json_read()

        resp = self.__json_read()

        if self._debug:

            print >>sys.stderr, "QMP:<<< %s" % resp

        return resp



    def cmd(self, name, args=None, id=None):

        """