[KVM-Autotest][PATCH 1/2] kvm test: Change cpuflags test call structure.

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



This changes are neccesary because people who use
the test want to use this test another way.

Signed-off-by: Jiří Župka <jzupka@xxxxxxxxxx>
---
 client/tests/kvm/tests/cpuflags.py |  890 +++++++++++++++++-------------------
 client/virt/subtests.cfg.sample    |   24 +-
 2 files changed, 438 insertions(+), 476 deletions(-)

diff --git a/client/tests/kvm/tests/cpuflags.py b/client/tests/kvm/tests/cpuflags.py
index c2111d4..97dcbaa 100644
--- a/client/tests/kvm/tests/cpuflags.py
+++ b/client/tests/kvm/tests/cpuflags.py
@@ -2,8 +2,6 @@ import logging, re, random, os, time, socket, pickle
 from autotest_lib.client.common_lib import error, utils
 from autotest_lib.client.virt import kvm_vm
 from autotest_lib.client.virt import virt_utils, aexpect
-from autotest_lib.client.common_lib.test import Subtest, subtest_nocleanup
-from autotest_lib.client.common_lib.test import subtest_fatal
 
 
 def run_cpuflags(test, params, env):
@@ -31,7 +29,7 @@ def run_cpuflags(test, params, env):
     class HgFlags(object):
         def __init__(self, cpu_model, extra_flags=set([])):
             virtual_flags = set(map(virt_utils.Flag,
-                                    params.get("guest_spec_flags", "").split()))
+                                   params.get("guest_spec_flags", "").split()))
             self.hw_flags = set(map(virt_utils.Flag,
                                     params.get("host_spec_flags", "").split()))
             self.qemu_support_flags = get_all_qemu_flags()
@@ -61,7 +59,6 @@ def run_cpuflags(test, params, env):
             self.host_all_unsupported_flags -= (self.host_support_flags |
                                                 virtual_flags)
 
-
     def start_guest_with_cpuflags(cpuflags, smp=None, migration=False,
                                   wait=True):
         """
@@ -87,7 +84,6 @@ def run_cpuflags(test, params, env):
 
         return (vm, session)
 
-
     def get_guest_system_cpuflags(vm_session):
         """
         Get guest system cpuflags.
@@ -101,7 +97,6 @@ def run_cpuflags(test, params, env):
         flags = flags_re.search(out).groups()[0].split()
         return set(map(virt_utils.Flag, flags))
 
-
     def get_guest_host_cpuflags(cpumodel):
         """
         Get cpu flags correspond with cpumodel parameters.
@@ -123,7 +118,6 @@ def run_cpuflags(test, params, env):
             flags += flag_group.split()
         return set(map(virt_utils.Flag, flags))
 
-
     def get_all_qemu_flags():
         cmd = qemu_binary + " -cpu ?cpuid"
         output = utils.run(cmd).stdout
@@ -137,7 +131,6 @@ def run_cpuflags(test, params, env):
 
         return set(map(virt_utils.Flag, flags))
 
-
     def get_flags_full_name(cpu_flag):
         """
         Get all name of Flag.
@@ -151,7 +144,6 @@ def run_cpuflags(test, params, env):
                 return virt_utils.Flag(f)
         return []
 
-
     def parse_qemu_cpucommand(cpumodel):
         """
         Parse qemu cpu params.
@@ -175,7 +167,6 @@ def run_cpuflags(test, params, env):
 
         return real_flags
 
-
     def get_cpu_models():
         """
         Get all cpu models from qemu.
@@ -188,7 +179,6 @@ def run_cpuflags(test, params, env):
         cpu_re = re.compile("\w+\s+\[?(\w+)\]?")
         return cpu_re.findall(output)
 
-
     def check_cpuflags(cpumodel, vm_session):
         """
         Check if vm flags are same like flags select by cpumodel.
@@ -206,7 +196,6 @@ def run_cpuflags(test, params, env):
         logging.debug("Flags on guest not defined by host: %s", (gf - rf))
         return rf - gf
 
-
     def disable_cpu(vm_session, cpu, disable=True):
         """
         Disable cpu in guest system.
@@ -224,7 +213,6 @@ def run_cpuflags(test, params, env):
             vm_session.cmd("echo 1 > %s" % cpu_online)
             logging.debug("Guest cpu %d is enabled.", cpu)
 
-
     def install_cpuflags_test_on_vm(vm, dst_dir):
         """
         Install stress to vm.
@@ -240,7 +228,6 @@ def run_cpuflags(test, params, env):
         session.cmd("sync")
         session.close()
 
-
     def check_cpuflags_work(vm, path, flags):
         """
         Check which flags work.
@@ -258,7 +245,7 @@ def run_cpuflags(test, params, env):
             try:
                 for tc in virt_utils.kvm_map_flags_to_test[f]:
                     session.cmd("%s/cpuflags-test --%s" %
-                                (os.path.join(path,"test_cpu_flags"), tc))
+                                (os.path.join(path, "test_cpu_flags"), tc))
                 pass_Flags.append(f)
             except aexpect.ShellCmdError:
                 not_working.append(f)
@@ -268,7 +255,6 @@ def run_cpuflags(test, params, env):
                 set(map(virt_utils.Flag, not_working)),
                 set(map(virt_utils.Flag, not_tested)))
 
-
     def run_stress(vm, timeout, guest_flags):
         """
         Run stress on vm for timeout time.
@@ -292,7 +278,6 @@ def run_cpuflags(test, params, env):
         dd_session.close()
         return ret
 
-
     def separe_cpu_model(cpu_model):
         try:
             (cpu_model, _) = cpu_model.split(":")
@@ -300,330 +285,301 @@ def run_cpuflags(test, params, env):
             cpu_model = cpu_model
         return cpu_model
 
-
     def parse_cpu_model():
         """
         Parse cpu_models from config file.
 
         @return: [(cpumodel, extra_flags)]
         """
-        cpu_models = params.get("cpu_models","").split()
-        if not cpu_models:
-            cpu_models = get_cpu_models()
+        cpu_model = params.get("cpu_model", "")
+        logging.debug("CPU model found: %s", str(cpu_model))
 
-        logging.debug("CPU models found: %s", str(cpu_models))
-        models = []
-        for cpu_model in cpu_models:
+        try:
+            (cpu_model, extra_flags) = cpu_model.split(":")
+            extra_flags = set(map(virt_utils.Flag, extra_flags.split(",")))
+        except ValueError:
+            cpu_model = cpu_model
+            extra_flags = set([])
+        return (cpu_model, extra_flags)
+
+    class MiniSubtest(object):
+        def __new__(cls, *args, **kargs):
+            self = super(MiniSubtest, cls).__new__(cls)
+            ret = None
+            if args is None:
+                args = []
             try:
-                (cpu_model, extra_flags) = cpu_model.split(":")
-                extra_flags = set(map(virt_utils.Flag, extra_flags.split(",")))
-            except ValueError:
-                cpu_model = cpu_model
-                extra_flags = set([])
-            models.append((cpu_model,extra_flags))
-        return models
-
+                ret = self.test(*args, **kargs)
+            finally:
+                if hasattr(self, "clean"):
+                    self.clean()
+            return ret
 
-    def test_qemu_interface_group():
-        """
-        1) <qemu-kvm-cmd> -cpu ?model
-        2) <qemu-kvm-cmd> -cpu ?dump
-        3) <qemu-kvm-cmd> -cpu ?cpuid
-        """
-        # 1) <qemu-kvm-cmd> -cpu ?model
-        class test_qemu_cpu_model(Subtest):
-            @subtest_fatal
-            @subtest_nocleanup
-            def test(self):
-                cpu_models = params.get("cpu_models", "core2duo").split()
-                cmd = qemu_binary + " -cpu ?model"
-                result = utils.run(cmd)
-                missing = []
-                cpu_models = map(separe_cpu_model, cpu_models)
-                for cpu_model in cpu_models:
-                    if not cpu_model in result.stdout:
-                        missing.append(cpu_model)
-                if missing:
-                    raise error.TestFail("CPU models %s are not in output "
-                                         "'%s' of command \n%s" %
-                                         (missing, cmd, result.stdout))
-
-        # 2) <qemu-kvm-cmd> -cpu ?dump
-        class test_qemu_dump(Subtest):
-            @subtest_nocleanup
-            def test(self):
-                cpu_models = params.get("cpu_models", "core2duo").split()
-                cmd = qemu_binary + " -cpu ?dump"
-                result = utils.run(cmd)
-                cpu_models = map(separe_cpu_model, cpu_models)
-                missing = []
-                for cpu_model in cpu_models:
-                    if not cpu_model in result.stdout:
-                        missing.append(cpu_model)
-                if missing:
-                    raise error.TestFail("CPU models %s are not in output "
-                                         "'%s' of command \n%s" %
-                                         (missing, cmd, result.stdout))
-
-        # 3) <qemu-kvm-cmd> -cpu ?cpuid
-        class test_qemu_cpuid(Subtest):
-            @subtest_nocleanup
-            def test(self):
-                cmd = qemu_binary + " -cpu ?cpuid"
-                result = utils.run(cmd)
-                if result.stdout is "":
-                    raise error.TestFail("There aren't any cpu Flag in output"
-                                         " '%s' of command \n%s" %
-                                         (cmd, result.stdout))
-
-        test_qemu_cpu_model()
-        test_qemu_dump()
-        test_qemu_cpuid()
-
-
-    class test_temp(Subtest):
+    class Test_temp(MiniSubtest):
         def clean(self):
             logging.info("cleanup")
             if (hasattr(self, "vm")):
                 self.vm.destroy(gracefully=False)
 
-
-    def test_boot_guest_group():
-        """
-        1) boot with cpu_model
-        2) migrate with flags
-        3) <qemu-kvm-cmd> -cpu model_name,+Flag
-        """
-        # 1) boot with cpu_model
-        class test_boot_cpu_model(test_temp):
-            def test(self, cpu_model):
-                logging.debug("Run tests with cpu model %s", cpu_model)
-                flags = HgFlags(cpu_model)
-                (self.vm, session) = start_guest_with_cpuflags(cpu_model)
-                not_enable_flags = (check_cpuflags(cpu_model, session) -
-                                    flags.hw_flags)
-                if not_enable_flags != set([]):
-                    raise error.TestFail("Flags defined on host but not found "
-                                         "on guest: %s" % (not_enable_flags))
-
-
-        # 2) success boot with supported flags
-        class test_boot_cpu_model_and_additional_flags(test_temp):
-            def test(self, cpu_model, extra_flags):
-                flags = HgFlags(cpu_model, extra_flags)
-
-                logging.debug("Cpu mode flags %s.",
-                              str(flags.quest_cpu_model_flags))
-                cpuf_model = cpu_model
-
-                if all_host_supported_flags == "yes":
-                    for fadd in flags.cpumodel_unsupport_flags:
-                        cpuf_model += ",+" + fadd
-                else:
-                    for fadd in extra_flags:
-                        cpuf_model += ",+" + fadd
-
-                for fdel in flags.host_unsupported_flags:
-                    cpuf_model += ",-" + fdel
-
-                if all_host_supported_flags == "yes":
-                    guest_flags = flags.all_possible_guest_flags
-                else:
-                    guest_flags = flags.guest_flags
-
-                (self.vm, session) = start_guest_with_cpuflags(cpuf_model)
-
-                not_enable_flags = (check_cpuflags(cpuf_model, session) -
-                                    flags.hw_flags)
-                if not_enable_flags != set([]):
-                    logging.info("Model unsupported flags: %s",
-                                  str(flags.cpumodel_unsupport_flags))
-                    logging.error("Flags defined on host but not on found "
-                                  "on guest: %s", str(not_enable_flags))
-                logging.info("Check main instruction sets.")
-
-                install_path = "/tmp"
-                install_cpuflags_test_on_vm(self.vm, install_path)
-
-                Flags = check_cpuflags_work(self.vm, install_path,
-                                            flags.all_possible_guest_flags)
-                logging.info("Woking CPU flags: %s", str(Flags[0]))
-                logging.info("Not working CPU flags: %s", str(Flags[1]))
-                logging.warning("Flags works even if not deffined on guest cpu "
-                                "flags: %s", str(Flags[0] - guest_flags))
-                logging.warning("Not tested CPU flags: %s", str(Flags[2]))
-
-                if Flags[1] & guest_flags:
-                    raise error.TestFail("Some flags do not work: %s" %
-                                         (str(Flags[1])))
-
-
-        # 3) fail boot unsupported flags
-        class test_fail_boot_with_host_unsupported_flags(Subtest):
-            @subtest_nocleanup
-            def test(self, cpu_model, extra_flags):
-                #This is virtual cpu flags which are supported by
-                #qemu but no with host cpu.
-                flags = HgFlags(cpu_model, extra_flags)
-
-                logging.debug("Unsupported flags %s.",
-                              str(flags.host_all_unsupported_flags))
-                cpuf_model = cpu_model + ",enforce"
-
-                # Add unsupported flags.
-                for fadd in flags.host_all_unsupported_flags:
-                    cpuf_model += ",+" + fadd
-
-                cmd = qemu_binary + " -cpu " + cpuf_model
-                out = None
-                try:
-                    try:
-                        out = utils.run(cmd, timeout=5, ignore_status=True).stderr
-                    except error.CmdError:
-                        logging.error("Host boot with unsupported flag")
-                finally:
-                    uns_re = re.compile("^warning:.*flag '(.+)'", re.MULTILINE)
-                    warn_flags = set(map(virt_utils.Flag, uns_re.findall(out)))
-                    fwarn_flags = flags.host_all_unsupported_flags - warn_flags
-                    if fwarn_flags:
-                        raise error.TestFail("Qemu did not warn the use of "
-                                             "flags %s" % str(fwarn_flags))
-        for (cpu_model, extra_flags) in parse_cpu_model():
-            test_fail_boot_with_host_unsupported_flags(cpu_model, extra_flags)
-            test_boot_cpu_model(cpu_model)
-            test_boot_cpu_model_and_additional_flags(cpu_model, extra_flags)
-
-
-    def test_stress_guest_group():
-        """
-        4) fail boot unsupported flags
-        5) check guest flags under load cpu, system (dd)
-        6) online/offline CPU
-        """
-        # 4) check guest flags under load cpu, stress and system (dd)
-        class test_boot_guest_and_try_flags_under_load(test_temp):
-            def test(self, cpu_model, extra_flags):
-                logging.info("Check guest working cpuflags under load "
-                             "cpu and stress and system (dd)")
-
-                flags = HgFlags(cpu_model, extra_flags)
-
-                logging.debug("Cpu mode flags %s.",
-                              str(flags.quest_cpu_model_flags))
-                logging.debug("Added flags %s.",
-                              str(flags.cpumodel_unsupport_flags))
-                cpuf_model = cpu_model
-
-                # Add unsupported flags.
+    # 1) <qemu-kvm-cmd> -cpu ?model
+    class test_qemu_cpu_model(MiniSubtest):
+        def test(self):
+            cpu_models = params.get("cpu_models", "core2duo").split()
+            cmd = qemu_binary + " -cpu ?model"
+            result = utils.run(cmd)
+            missing = []
+            cpu_models = map(separe_cpu_model, cpu_models)
+            for cpu_model in cpu_models:
+                if not cpu_model in result.stdout:
+                    missing.append(cpu_model)
+            if missing:
+                raise error.TestFail("CPU models %s are not in output "
+                                     "'%s' of command \n%s" %
+                                     (missing, cmd, result.stdout))
+
+    # 2) <qemu-kvm-cmd> -cpu ?dump
+    class test_qemu_dump(MiniSubtest):
+        def test(self):
+            cpu_models = params.get("cpu_models", "core2duo").split()
+            cmd = qemu_binary + " -cpu ?dump"
+            result = utils.run(cmd)
+            cpu_models = map(separe_cpu_model, cpu_models)
+            missing = []
+            for cpu_model in cpu_models:
+                if not cpu_model in result.stdout:
+                    missing.append(cpu_model)
+            if missing:
+                raise error.TestFail("CPU models %s are not in output "
+                                     "'%s' of command \n%s" %
+                                     (missing, cmd, result.stdout))
+
+    # 3) <qemu-kvm-cmd> -cpu ?cpuid
+    class test_qemu_cpuid(MiniSubtest):
+        def test(self):
+            cmd = qemu_binary + " -cpu ?cpuid"
+            result = utils.run(cmd)
+            if result.stdout is "":
+                raise error.TestFail("There aren't any cpu Flag in output"
+                                     " '%s' of command \n%s" %
+                                     (cmd, result.stdout))
+
+    # 1) boot with cpu_model
+    class test_boot_cpu_model(Test_temp):
+        def test(self):
+            cpu_model, _ = parse_cpu_model()
+            logging.debug("Run tests with cpu model %s", cpu_model)
+            flags = HgFlags(cpu_model)
+            (self.vm, session) = start_guest_with_cpuflags(cpu_model)
+            not_enable_flags = (check_cpuflags(cpu_model, session) -
+                                flags.hw_flags)
+            if not_enable_flags != set([]):
+                raise error.TestFail("Flags defined on host but not found "
+                                     "on guest: %s" % (not_enable_flags))
+
+    # 2) success boot with supported flags
+    class test_boot_cpu_model_and_additional_flags(Test_temp):
+        def test(self):
+            cpu_model, extra_flags = parse_cpu_model()
+
+            flags = HgFlags(cpu_model, extra_flags)
+
+            logging.debug("Cpu mode flags %s.",
+                          str(flags.quest_cpu_model_flags))
+            cpuf_model = cpu_model
+
+            if all_host_supported_flags == "yes":
                 for fadd in flags.cpumodel_unsupport_flags:
                     cpuf_model += ",+" + fadd
+            else:
+                for fadd in extra_flags:
+                    cpuf_model += ",+" + fadd
 
-                for fdel in flags.host_unsupported_flags:
-                    cpuf_model += ",-" + fdel
+            for fdel in flags.host_unsupported_flags:
+                cpuf_model += ",-" + fdel
 
-                (self.vm, _) = start_guest_with_cpuflags(cpuf_model, smp)
+            if all_host_supported_flags == "yes":
+                guest_flags = flags.all_possible_guest_flags
+            else:
+                guest_flags = flags.guest_flags
 
-                if (not run_stress(self.vm, 60, flags.guest_flags)):
-                    raise error.TestFail("Stress test ended before"
-                                         " end of test.")
+            (self.vm, session) = start_guest_with_cpuflags(cpuf_model)
 
-            def clean(self):
-                logging.info("cleanup")
-                self.vm.destroy(gracefully=False)
+            not_enable_flags = (check_cpuflags(cpuf_model, session) -
+                                flags.hw_flags)
+            if not_enable_flags != set([]):
+                logging.info("Model unsupported flags: %s",
+                              str(flags.cpumodel_unsupport_flags))
+                logging.error("Flags defined on host but not on found "
+                              "on guest: %s", str(not_enable_flags))
+            logging.info("Check main instruction sets.")
+
+            install_path = "/tmp"
+            install_cpuflags_test_on_vm(self.vm, install_path)
+
+            Flags = check_cpuflags_work(self.vm, install_path,
+                                        flags.all_possible_guest_flags)
+            logging.info("Woking CPU flags: %s", str(Flags[0]))
+            logging.info("Not working CPU flags: %s", str(Flags[1]))
+            logging.warning("Flags works even if not deffined on guest cpu "
+                            "flags: %s", str(Flags[0] - guest_flags))
+            logging.warning("Not tested CPU flags: %s", str(Flags[2]))
+
+            if Flags[1] & guest_flags:
+                raise error.TestFail("Some flags do not work: %s" %
+                                     (str(Flags[1])))
+
+    # 3) fail boot unsupported flags
+    class test_fail_boot_with_host_unsupported_flags(MiniSubtest):
+        def test(self):
+            #This is virtual cpu flags which are supported by
+            #qemu but no with host cpu.
+            cpu_model, extra_flags = parse_cpu_model()
+
+            flags = HgFlags(cpu_model, extra_flags)
+
+            logging.debug("Unsupported flags %s.",
+                          str(flags.host_all_unsupported_flags))
+            cpuf_model = cpu_model + ",enforce"
+
+            # Add unsupported flags.
+            for fadd in flags.host_all_unsupported_flags:
+                cpuf_model += ",+" + fadd
+
+            cmd = qemu_binary + " -cpu " + cpuf_model
+            out = None
+            try:
+                try:
+                    out = utils.run(cmd, timeout=5, ignore_status=True).stderr
+                except error.CmdError:
+                    logging.error("Host boot with unsupported flag")
+            finally:
+                uns_re = re.compile("^warning:.*flag '(.+)'", re.MULTILINE)
+                warn_flags = set(map(virt_utils.Flag, uns_re.findall(out)))
+                fwarn_flags = flags.host_all_unsupported_flags - warn_flags
+                if fwarn_flags:
+                    raise error.TestFail("Qemu did not warn the use of "
+                                         "flags %s" % str(fwarn_flags))
+
+    # 4) check guest flags under load cpu, stress and system (dd)
+    class test_boot_guest_and_try_flags_under_load(Test_temp):
+        def test(self):
+            logging.info("Check guest working cpuflags under load "
+                         "cpu and stress and system (dd)")
+            cpu_model, extra_flags = parse_cpu_model()
+
+            flags = HgFlags(cpu_model, extra_flags)
+
+            logging.debug("Cpu mode flags %s.",
+                          str(flags.quest_cpu_model_flags))
+            logging.debug("Added flags %s.",
+                          str(flags.cpumodel_unsupport_flags))
+            cpuf_model = cpu_model
+
+            # Add unsupported flags.
+            for fadd in flags.cpumodel_unsupport_flags:
+                cpuf_model += ",+" + fadd
+
+            for fdel in flags.host_unsupported_flags:
+                cpuf_model += ",-" + fdel
+
+            (self.vm, _) = start_guest_with_cpuflags(cpuf_model, smp)
+
+            if (not run_stress(self.vm, 60, flags.guest_flags)):
+                raise error.TestFail("Stress test ended before"
+                                     " end of test.")
 
+        def clean(self):
+            logging.info("cleanup")
+            self.vm.destroy(gracefully=False)
+
+    # 5) Online/offline CPU
+    class test_online_offline_guest_CPUs(Test_temp):
+        def test(self):
+            cpu_model, extra_flags = parse_cpu_model()
+
+            logging.debug("Run tests with cpu model %s.", (cpu_model))
+            flags = HgFlags(cpu_model, extra_flags)
+
+            (self.vm, session) = start_guest_with_cpuflags(cpu_model, smp)
+
+            def encap(timeout):
+                random.seed()
+                begin = time.time()
+                end = begin
+                if smp > 1:
+                    while end - begin < 60:
+                        cpu = random.randint(1, smp - 1)
+                        if random.randint(0, 1):
+                            disable_cpu(session, cpu, True)
+                        else:
+                            disable_cpu(session, cpu, False)
+                        end = time.time()
+                    return True
+                else:
+                    logging.warning("For this test is necessary smp > 1.")
+                    return False
+            timeout = 60
 
-        # 5) Online/offline CPU
-        class test_online_offline_guest_CPUs(test_temp):
-            def test(self, cpu_model, extra_flags):
-                logging.debug("Run tests with cpu model %s.", (cpu_model))
-                flags = HgFlags(cpu_model, extra_flags)
-
-                (self.vm, session) = start_guest_with_cpuflags(cpu_model, smp)
-
-                def encap(timeout):
-                    random.seed()
-                    begin = time.time()
-                    end = begin
-                    if smp > 1:
-                        while end - begin < 60:
-                            cpu = random.randint(1, smp - 1)
-                            if random.randint(0, 1):
-                                disable_cpu(session, cpu, True)
-                            else:
-                                disable_cpu(session, cpu, False)
-                            end = time.time()
-                        return True
-                    else:
-                        logging.warning("For this test is necessary smp > 1.")
-                        return False
-                timeout = 60
-
-                test_flags = flags.guest_flags
-                if all_host_supported_flags == "yes":
-                    test_flags = flags.all_possible_guest_flags
-
-                result = virt_utils.parallel([(encap, [timeout]),
-                                             (run_stress, [self.vm, timeout,
-                                                          test_flags])])
-                if not (result[0] and result[1]):
-                    raise error.TestFail("Stress tests failed before"
-                                         " end of testing.")
-
-
-        # 6) migration test
-        class test_migration_with_additional_flags(test_temp):
-            def test(self, cpu_model, extra_flags):
-                flags = HgFlags(cpu_model, extra_flags)
-
-                logging.debug("Cpu mode flags %s.",
-                              str(flags.quest_cpu_model_flags))
-                logging.debug("Added flags %s.",
-                              str(flags.cpumodel_unsupport_flags))
-                cpuf_model = cpu_model
+            test_flags = flags.guest_flags
+            if all_host_supported_flags == "yes":
+                test_flags = flags.all_possible_guest_flags
 
-                # Add unsupported flags.
-                for fadd in flags.cpumodel_unsupport_flags:
-                    cpuf_model += ",+" + fadd
+            result = virt_utils.parallel([(encap, [timeout]),
+                                         (run_stress, [self.vm, timeout,
+                                                      test_flags])])
+            if not (result[0] and result[1]):
+                raise error.TestFail("Stress tests failed before"
+                                     " end of testing.")
 
-                for fdel in flags.host_unsupported_flags:
-                    cpuf_model += ",-" + fdel
+    # 6) migration test
+    class test_migration_with_additional_flags(Test_temp):
+        def test(self):
+            cpu_model, extra_flags = parse_cpu_model()
 
-                (self.vm, _) = start_guest_with_cpuflags(cpuf_model, smp)
+            flags = HgFlags(cpu_model, extra_flags)
 
-                install_path = "/tmp"
-                install_cpuflags_test_on_vm(self.vm, install_path)
-                flags = check_cpuflags_work(self.vm, install_path,
-                                            flags.guest_flags)
-                dd_session = self.vm.wait_for_login()
-                stress_session = self.vm.wait_for_login()
+            logging.debug("Cpu mode flags %s.",
+                          str(flags.quest_cpu_model_flags))
+            logging.debug("Added flags %s.",
+                          str(flags.cpumodel_unsupport_flags))
+            cpuf_model = cpu_model
 
-                dd_session.sendline("nohup dd if=/dev/[svh]da of=/tmp/"
-                                    "stressblock bs=10MB count=100 &")
-                cmd = ("nohup %s/cpuflags-test --stress  %s%s &" %
-                       (os.path.join(install_path, "test_cpu_flags"), smp,
-                       virt_utils.kvm_flags_to_stresstests(flags[0])))
-                stress_session.sendline(cmd)
+            # Add unsupported flags.
+            for fadd in flags.cpumodel_unsupport_flags:
+                cpuf_model += ",+" + fadd
 
-                time.sleep(5)
+            for fdel in flags.host_unsupported_flags:
+                cpuf_model += ",-" + fdel
 
-                self.vm.monitor.migrate_set_speed(mig_speed)
-                self.vm.migrate(mig_timeout, mig_protocol, offline=False)
+            (self.vm, _) = start_guest_with_cpuflags(cpuf_model, smp)
 
-                time.sleep(5)
+            install_path = "/tmp"
+            install_cpuflags_test_on_vm(self.vm, install_path)
+            flags = check_cpuflags_work(self.vm, install_path,
+                                        flags.guest_flags)
+            dd_session = self.vm.wait_for_login()
+            stress_session = self.vm.wait_for_login()
 
-                #If cpuflags-test hang up during migration test raise exception
-                try:
-                    stress_session.cmd('killall cpuflags-test')
-                except aexpect.ShellCmdError:
-                    raise error.TestFail("Cpuflags-test should work after"
-                                         " migration.")
+            dd_session.sendline("nohup dd if=/dev/[svh]da of=/tmp/"
+                                "stressblock bs=10MB count=100 &")
+            cmd = ("nohup %s/cpuflags-test --stress  %s%s &" %
+                   (os.path.join(install_path, "test_cpu_flags"), smp,
+                   virt_utils.kvm_flags_to_stresstests(flags[0])))
+            stress_session.sendline(cmd)
+
+            time.sleep(5)
 
+            self.vm.monitor.migrate_set_speed(mig_speed)
+            self.vm.migrate(mig_timeout, mig_protocol, offline=False)
 
-        for (cpu_model, extra_flags) in parse_cpu_model():
-            test_boot_guest_and_try_flags_under_load(cpu_model, extra_flags)
-            test_online_offline_guest_CPUs(cpu_model, extra_flags)
-            test_migration_with_additional_flags(cpu_model, extra_flags)
+            time.sleep(5)
 
+            #If cpuflags-test hang up during migration test raise exception
+            try:
+                stress_session.cmd('killall cpuflags-test')
+            except aexpect.ShellCmdError:
+                raise error.TestFail("Cpuflags-test should work after"
+                                     " migration.")
 
     def net_send_object(socket, obj):
         """
@@ -636,7 +592,6 @@ def run_cpuflags(test, params, env):
         socket.sendall("%6d" % len(data))
         socket.sendall(data)
 
-
     def net_recv_object(socket, timeout=60):
         """
         Receive python object over network.
@@ -659,181 +614,170 @@ def run_cpuflags(test, params, env):
             error.TestFail("Failed to receive python object over the network")
             raise
 
+    class test_multi_host_migration(Test_temp):
+        def test(self):
+            """
+            Test migration between multiple hosts.
+            """
+            def guest_active(vm):
+                o = vm.monitor.info("status")
+                if isinstance(o, str):
+                    return "status: running" in o
+                else:
+                    return o.get("status") == "running"
 
-    def test_multi_host_migration_group():
-        class test_multi_host_migration(test_temp):
-            def test(self, cpu_model, extra_flags):
-                """
-                Test migration between multiple hosts.
-                """
-                def guest_active(vm):
-                    o = vm.monitor.info("status")
-                    if isinstance(o, str):
-                        return "status: running" in o
-                    else:
-                        return o.get("status") == "running"
-
-                flags = HgFlags(cpu_model, extra_flags)
-
-                logging.debug("Cpu mode flags %s.",
-                              str(flags.quest_cpu_model_flags))
-                logging.debug("Added flags %s.",
-                              str(flags.cpumodel_unsupport_flags))
-                cpuf_model = cpu_model
+            cpu_model, extra_flags = parse_cpu_model()
 
-                for fadd in extra_flags:
-                    cpuf_model += ",+" + fadd
+            flags = HgFlags(cpu_model, extra_flags)
 
-                for fdel in flags.host_unsupported_flags:
-                    cpuf_model += ",-" + fdel
-
-                install_path = "/tmp"
-                login_timeout = int(params.get("login_timeout", 360))
-                role = params.get("role")
-                srchost = params.get("srchost")
-                dsthost = params.get("dsthost")
-                # Port used to communicate info between source and destination
-                comm_port = int(params.get("comm_port", 12324))
-                comm_timeout = float(params.get("comm_timeout", "10"))
-                regain_ip_cmd = params.get("regain_ip_cmd", "dhclient")
-
-                if role == 'source':
-                    (self.vm, session) = start_guest_with_cpuflags(cpuf_model,
-                                                                   smp)
-
-                    install_cpuflags_test_on_vm(self.vm, install_path)
-
-                    Flags = check_cpuflags_work(self.vm, install_path,
-                                                flags.all_possible_guest_flags)
-                    logging.info("Woking CPU flags: %s", str(Flags[0]))
-                    logging.info("Not working CPU flags: %s", str(Flags[1]))
-                    logging.warning("Flags works even if not deffined on"
-                                    " guest cpu flags: %s",
-                                    str(Flags[0] - flags.guest_flags))
-                    logging.warning("Not tested CPU flags: %s", str(Flags[2]))
-
-                    session.sendline("nohup dd if=/dev/[svh]da of=/tmp/"
-                                    "stressblock bs=10MB count=100 &")
-
-                    cmd = ("nohup %s/cpuflags-test --stress  %s%s &" %
-                          (os.path.join(install_path, "test_cpu_flags"), smp,
-                          virt_utils.kvm_flags_to_stresstests(Flags[0] &
-                                                        flags.guest_flags)))
-                    logging.debug("Guest_flags: %s",str(flags.guest_flags))
-                    logging.debug("Working_flags: %s",str(Flags[0]))
-                    logging.debug("Start stress on guest: %s", cmd)
-                    session.sendline(cmd)
-
-                    # Listen on a port to get the migration port received from
-                    # dest machine
-                    s_socket = socket.socket(socket.AF_INET,
-                                             socket.SOCK_STREAM)
-                    s_socket.bind(('', comm_port))
-                    s_socket.listen(1)
-                    s_socket.settimeout(comm_timeout)
-
-                    # Wait 30 seconds for source and dest to reach this point
-                    test.job.barrier(srchost,
-                                     'socket_started', 120).rendezvous(srchost,
-                                                                      dsthost)
-
-                    c_socket = s_socket.accept()[0]
-
-                    mig_port = int(c_socket.recv(6))
-                    logging.info("Received from destination the"
-                                 " migration port %s" % mig_port)
-                    c_socket.close()
-
-                    #Wait for start cpuflags-test stress.
-                    time.sleep(10)
-                    logging.info("Start migrating now...")
-                    self.vm.monitor.migrate_set_speed(mig_speed)
-                    self.vm.migrate(dest_host=dsthost, remote_port=mig_port)
-
-                    # Wait up to 30 seconds for dest to reach this point
-                    test.job.barrier(srchost,
-                                     'mig_finished', 30).rendezvous(srchost,
-                                                                    dsthost)
-
-                elif role == 'destination':
-                    # Wait up to login_timeout + 30 seconds for the source to
-                    # reach this point
-                    (self.vm, _) = start_guest_with_cpuflags(cpuf_model,
-                                                             smp,
-                                                             True,
-                                                             False)
-
-                    test.job.barrier(dsthost, 'socket_started',
-                                     login_timeout + 120).rendezvous(srchost,
-                                                                    dsthost)
-
-                    c_socket = socket.socket(socket.AF_INET,
-                                             socket.SOCK_STREAM)
-                    c_socket.settimeout(comm_timeout)
-                    c_socket.connect((srchost, comm_port))
-
-                    logging.info("Communicating to source migration"
-                                 " port %s" % self.vm.migration_port)
-                    c_socket.send("%d" % self.vm.migration_port)
-                    c_socket.close()
-
-                    # Wait up to mig_timeout + 30 seconds for the source to
-                    # reach this point: migration finished
-                    test.job.barrier(dsthost, 'mig_finished',
-                                     mig_timeout + 30).rendezvous(srchost,
-                                                                  dsthost)
+            logging.debug("Cpu mode flags %s.",
+                          str(flags.quest_cpu_model_flags))
+            logging.debug("Added flags %s.",
+                          str(flags.cpumodel_unsupport_flags))
+            cpuf_model = cpu_model
 
-                    if not guest_active(self.vm):
-                        raise error.TestFail("Guest not active after"
-                                             " migration")
+            for fadd in extra_flags:
+                cpuf_model += ",+" + fadd
 
-                    logging.info("Migrated guest appears to be running")
+            for fdel in flags.host_unsupported_flags:
+                cpuf_model += ",-" + fdel
 
-                    # Log into the guest again
-                    logging.info("Logging into migrated guest after"
-                                 " migration...")
-                    session_serial = self.vm.wait_for_serial_login(timeout=
-                                                                login_timeout)
-                    session_serial.cmd(regain_ip_cmd)
+            install_path = "/tmp"
+            login_timeout = int(params.get("login_timeout", 360))
+            role = params.get("role")
+            srchost = params.get("srchost")
+            dsthost = params.get("dsthost")
+            # Port used to communicate info between source and destination
+            comm_port = int(params.get("comm_port", 12324))
+            comm_timeout = float(params.get("comm_timeout", "10"))
+            regain_ip_cmd = params.get("regain_ip_cmd", "dhclient")
 
-                    self.vm.verify_illegal_instructonn()
+            if role == 'source':
+                (self.vm, session) = start_guest_with_cpuflags(cpuf_model,
+                                                               smp)
 
-                    session = self.vm.wait_for_login(timeout=login_timeout)
+                install_cpuflags_test_on_vm(self.vm, install_path)
 
-                    try:
-                        session.cmd('killall cpuflags-test')
-                    except aexpect.ShellCmdError:
-                        raise error.TestFail("The cpuflags-test program should"
-                                             " be active after migration and"
-                                             " it's not.")
+                Flags = check_cpuflags_work(self.vm, install_path,
+                                            flags.all_possible_guest_flags)
+                logging.info("Woking CPU flags: %s", str(Flags[0]))
+                logging.info("Not working CPU flags: %s", str(Flags[1]))
+                logging.warning("Flags works even if not deffined on"
+                                " guest cpu flags: %s",
+                                str(Flags[0] - flags.guest_flags))
+                logging.warning("Not tested CPU flags: %s", str(Flags[2]))
 
-                    Flags = check_cpuflags_work(self.vm, install_path,
-                                                flags.all_possible_guest_flags)
-                    logging.info("Woking CPU flags: %s", str(Flags[0]))
-                    logging.info("Not working CPU flags: %s", str(Flags[1]))
-                    logging.warning("Flags works even if not deffined on"
-                                    " guest cpu flags: %s",
-                                    str(Flags[0] - flags.guest_flags))
-                    logging.warning("Not tested CPU flags: %s", str(Flags[2]))
+                session.sendline("nohup dd if=/dev/[svh]da of=/tmp/"
+                                "stressblock bs=10MB count=100 &")
 
-                else:
-                    raise error.TestError('Invalid role specified')
+                cmd = ("nohup %s/cpuflags-test --stress  %s%s &" %
+                      (os.path.join(install_path, "test_cpu_flags"), smp,
+                      virt_utils.kvm_flags_to_stresstests(Flags[0] &
+                                                    flags.guest_flags)))
+                logging.debug("Guest_flags: %s", str(flags.guest_flags))
+                logging.debug("Working_flags: %s", str(Flags[0]))
+                logging.debug("Start stress on guest: %s", cmd)
+                session.sendline(cmd)
+
+                # Listen on a port to get the migration port received from
+                # dest machine
+                s_socket = socket.socket(socket.AF_INET,
+                                         socket.SOCK_STREAM)
+                s_socket.bind(('', comm_port))
+                s_socket.listen(1)
+                s_socket.settimeout(comm_timeout)
+
+                # Wait 30 seconds for source and dest to reach this point
+                test.job.barrier(srchost,
+                                 'socket_started', 120).rendezvous(srchost,
+                                                                  dsthost)
 
-        for (cpu_model, extra_flags) in parse_cpu_model():
-            test_multi_host_migration(cpu_model, extra_flags)
+                c_socket = s_socket.accept()[0]
 
-    try:
-        test_type = params.get("test_type")
-        if (test_type in locals()):
-            tests_group = locals()[test_type]
-            tests_group()
-        else:
-            raise error.TestFail("Test group '%s' is not defined in"
-                                 " cpuflags test" % test_type)
-    finally:
-        logging.info("RESULTS:")
-        for line in Subtest.get_text_result().splitlines():
-            logging.info(line)
-
-    if Subtest.has_failed():
-        raise error.TestFail("Some subtests failed")
+                mig_port = int(c_socket.recv(6))
+                logging.info("Received from destination the"
+                             " migration port %s" % mig_port)
+                c_socket.close()
+
+                #Wait for start cpuflags-test stress.
+                time.sleep(10)
+                logging.info("Start migrating now...")
+                self.vm.monitor.migrate_set_speed(mig_speed)
+                self.vm.migrate(dest_host=dsthost, remote_port=mig_port)
+
+                # Wait up to 30 seconds for dest to reach this point
+                test.job.barrier(srchost,
+                                 'mig_finished', 30).rendezvous(srchost,
+                                                                dsthost)
+
+            elif role == 'destination':
+                # Wait up to login_timeout + 30 seconds for the source to
+                # reach this point
+                (self.vm, _) = start_guest_with_cpuflags(cpuf_model,
+                                                         smp,
+                                                         True,
+                                                         False)
+
+                test.job.barrier(dsthost, 'socket_started',
+                                 login_timeout + 120).rendezvous(srchost,
+                                                                dsthost)
+
+                c_socket = socket.socket(socket.AF_INET,
+                                         socket.SOCK_STREAM)
+                c_socket.settimeout(comm_timeout)
+                c_socket.connect((srchost, comm_port))
+
+                logging.info("Communicating to source migration"
+                             " port %s" % self.vm.migration_port)
+                c_socket.send("%d" % self.vm.migration_port)
+                c_socket.close()
+
+                # Wait up to mig_timeout + 30 seconds for the source to
+                # reach this point: migration finished
+                test.job.barrier(dsthost, 'mig_finished',
+                                 mig_timeout + 30).rendezvous(srchost,
+                                                              dsthost)
+
+                if not guest_active(self.vm):
+                    raise error.TestFail("Guest not active after"
+                                         " migration")
+
+                logging.info("Migrated guest appears to be running")
+
+                # Log into the guest again
+                logging.info("Logging into migrated guest after"
+                             " migration...")
+                session_serial = self.vm.wait_for_serial_login(
+                                                    timeout=login_timeout)
+                session_serial.cmd(regain_ip_cmd)
+
+                self.vm.verify_illegal_instructonn()
+
+                session = self.vm.wait_for_login(timeout=login_timeout)
+
+                try:
+                    session.cmd('killall cpuflags-test')
+                except aexpect.ShellCmdError:
+                    raise error.TestFail("The cpuflags-test program should"
+                                         " be active after migration and"
+                                         " it's not.")
+
+                Flags = check_cpuflags_work(self.vm, install_path,
+                                            flags.all_possible_guest_flags)
+                logging.info("Woking CPU flags: %s", str(Flags[0]))
+                logging.info("Not working CPU flags: %s", str(Flags[1]))
+                logging.warning("Flags works even if not deffined on"
+                                " guest cpu flags: %s",
+                                str(Flags[0] - flags.guest_flags))
+                logging.warning("Not tested CPU flags: %s", str(Flags[2]))
+
+            else:
+                raise error.TestError('Invalid role specified')
+
+    test_type = params.get("test_type")
+    if (test_type in locals()):
+        tests_group = locals()[test_type]
+        tests_group()
+    else:
+        raise error.TestFail("Test group '%s' is not defined in"
+                             " cpuflags test" % test_type)
diff --git a/client/virt/subtests.cfg.sample b/client/virt/subtests.cfg.sample
index b08a5c4..ad24075 100644
--- a/client/virt/subtests.cfg.sample
+++ b/client/virt/subtests.cfg.sample
@@ -1424,11 +1424,29 @@ variants:
         host_spec_flags = "pbe tm ds_cpl monitor acpi dtes64 ht tm2 xtpr est pdcm smx"
         variants:
             - interface:
-                test_type = "test_qemu_interface_group"
+                variants:
+                    - qemu_cpu_model:
+                        test_type = "test_qemu_cpu_model"
+                    - qemu_cpu_dump:
+                        test_type = "test_qemu_dump"
+                    - qemu_cpu_cpuid:
+                        test_type = "test_qemu_cpuid"
             - boot_guest:
-                test_type = "test_boot_guest_group"
+                variants:
+                    - qemu_boot_cpu_model:
+                        test_type = "test_boot_cpu_model"
+                    - qemu_boot_cpu_model_and_flags:
+                        test_type = "test_boot_cpu_model_and_additional_flags"
+                    - qemu_boot_fail_cpu_model:
+                        test_type = "test_fail_boot_with_host_unsupported_flags"
             - stress_guest:
-                test_type = "test_stress_guest_group"
+                variants:
+                    - qemu_test_boot_guest_and_try_flags_under_load:
+                        test_type = "test_boot_guest_and_try_flags_under_load"
+                    - qemu_test_online_offline_guest_CPUs:
+                        test_type = "test_online_offline_guest_CPUs"
+                    - qemu_test_migration_with_additional_flags:
+                        test_type = "test_migration_with_additional_flags"
 
     - cpuflags_multi_host:
         type = cpuflags
-- 
1.7.7.6

--
To unsubscribe from this list: send the line "unsubscribe kvm" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at  http://vger.kernel.org/majordomo-info.html


[Index of Archives]     [KVM ARM]     [KVM ia64]     [KVM ppc]     [Virtualization Tools]     [Spice Development]     [Libvirt]     [Libvirt Users]     [Linux USB Devel]     [Linux Audio Users]     [Yosemite Questions]     [Linux Kernel]     [Linux SCSI]     [XFree86]
  Powered by Linux