Merge remote branch 'autotest-upstream/master' into autotest-merge

client/tests/kvm/kvm_vm.py

 #!/usr/bin/python
 """
 Utility classes and functions to handle Virtual Machine creation using qemu.
 
 @copyright: 2008-2009 Red Hat Inc.
 """
 
 import time, os, logging, fcntl, re, commands, glob
 import kvm_utils, kvm_subprocess, kvm_monitor
 from autotest_lib.client.common_lib import error
@@ skipping 87 matching lines @@
     def __init__(self, status, output):
         VMError.__init__(self, status, output)
         self.status = status
         self.output = output
 
     def __str__(self):
         return ("VM process is dead    (status: %s,    output: %r)" %
                 (self.status, self.output))
 
 
+class VMDeadKernelCrashError(VMError):
+    def __init__(self, kernel_crash):
+        VMError.__init__(self, kernel_crash)
+        self.kernel_crash = kernel_crash
+
+    def __str__(self):
+        return ("VM is dead due to a kernel crash:\n%s" % self.kernel_crash)
+
+
 class VMAddressError(VMError):
     pass
 
 
 class VMPortNotRedirectedError(VMAddressError):
     def __init__(self, port):
         VMAddressError.__init__(self, port)
         self.port = port
 
     def __str__(self):
@@ skipping 160 matching lines @@
         if not "info" in q_output:
             logging.error("qemu-img does not support 'info', "
                           "skipping check...")
             check_img = False
         if check_img:
             try:
                 utils.system("%s info %s" % (qemu_img_cmd, image_filename))
             except error.CmdError:
                 logging.error("Error getting info from image %s",
                               image_filename)
-            try:
-                utils.system("%s check %s" % (qemu_img_cmd, image_filename))
-            except error.CmdError:
+
+            cmd_result = utils.run("%s check %s" %
+                                   (qemu_img_cmd, image_filename),
+                                   ignore_status=True)
+            # Error check, large chances of a non-fatal problem.
+            # There are chances that bad data was skipped though
+            if cmd_result.exit_status == 1:
+                for e_line in cmd_result.stdout.splitlines():
+                    logging.error("[stdout] %s", e_line)
+                for e_line in cmd_result.stderr.splitlines():
+                    logging.error("[stderr] %s", e_line)
+                raise error.TestWarn("qemu-img check error. Some bad data in "
+                                     "the image may have gone unnoticed")
+            # Exit status 2 is data corruption for sure, so fail the test
+            elif cmd_result.exit_status == 2:
+                for e_line in cmd_result.stdout.splitlines():
+                    logging.error("[stdout] %s", e_line)
+                for e_line in cmd_result.stderr.splitlines():
+                    logging.error("[stderr] %s", e_line)
                 raise VMImageCheckError(image_filename)
+            # Leaked clusters, they are known to be harmless to data integrity
+            elif cmd_result.exit_status == 3:
+                raise error.TestWarn("Leaked clusters were noticed during "
+                                     "image check. No data integrity problem "
+                                     "was found though.")
 
     else:
         if not os.path.exists(image_filename):
             logging.debug("Image file %s not found, skipping check...",
                           image_filename)
         elif not image_is_qcow2:
             logging.debug("Image file %s not qcow2, skipping check...",
                           image_filename)
 
 
@@ skipping 26 matching lines @@
             self.device_id = []
             self.uuid = None
 
             # Find a unique identifier for this VM
             while True:
                 self.instance = (time.strftime("%Y%m%d-%H%M%S-") +
                                  kvm_utils.generate_random_string(4))
                 if not glob.glob("/tmp/*%s" % self.instance):
                     break
 
+        self.spice_port = 8000
         self.name = name
         self.params = params
         self.root_dir = root_dir
         self.address_cache = address_cache
 
 
     def clone(self, name=None, params=None, root_dir=None, address_cache=None,
               copy_state=False):
         """
         Return a clone of the VM object with optionally modified parameters.
@@ skipping 198 matching lines @@
 
         def add_nographic(help):
             return " -nographic"
 
         def add_uuid(help, uuid):
             return " -uuid '%s'" % uuid
 
         def add_pcidevice(help, host):
             return " -pcidevice host='%s'" % host
 
+        def add_spice(help, port, param):
+            if has_option(help,"spice"):
+                return " -spice port=%s,%s" % (port, param)
+            else:
+                return ""
+
+        def add_qxl_vga(help, qxl, vga, qxl_dev_nr=None):
+            str = ""
+            if has_option(help, "qxl"):
+                if qxl and qxl_dev_nr is not None:
+                    str += " -qxl %s" % qxl_dev_nr
+                if has_option(help, "vga") and vga and vga != "qxl":
+                    str += " -vga %s" % vga
+            elif has_option(help, "vga"):
+                if qxl:
+                    str += " -vga qxl"
+                elif vga:
+                    str += " -vga %s" % vga
+            return str
+
         def add_kernel(help, filename):
             return " -kernel '%s'" % filename
 
         def add_initrd(help, filename):
             return " -initrd '%s'" % filename
 
         def add_kernel_cmdline(help, cmdline):
             return " -append %s" % cmdline
 
         def add_testdev(help, filename):
@@ skipping 147 matching lines @@
 
         for host_port, guest_port in redirs:
             qemu_cmd += add_tcp_redir(help, host_port, guest_port)
 
         if params.get("display") == "vnc":
             qemu_cmd += add_vnc(help, vm.vnc_port)
         elif params.get("display") == "sdl":
             qemu_cmd += add_sdl(help)
         elif params.get("display") == "nographic":
             qemu_cmd += add_nographic(help)
+        elif params.get("display") == "spice":
+            qemu_cmd += add_spice(help, self.spice_port, params.get("spice"))
+
+        qxl = ""
+        vga = ""
+        if params.get("qxl"):
+            qxl = params.get("qxl")
+        if params.get("vga"):
+            vga = params.get("vga")
+        if qxl or vga:
+            if params.get("display") == "spice":
+                qxl_dev_nr = params.get("qxl_dev_nr", None)
+                qemu_cmd += add_qxl_vga(help, qxl, vga, qxl_dev_nr)
 
         if params.get("uuid") == "random":
             qemu_cmd += add_uuid(help, vm.uuid)
         elif params.get("uuid"):
             qemu_cmd += add_uuid(help, params.get("uuid"))
 
         if params.get("testdev") == "yes":
             qemu_cmd += add_testdev(help, vm.get_testlog_filename())
 
         if params.get("disable_hpet") == "yes":
@@ skipping 105 matching lines @@
             self.netdev_id = []
             self.device_id = []
             for nic in params.objects("nics"):
                 self.netdev_id.append(kvm_utils.generate_random_id())
                 self.device_id.append(kvm_utils.generate_random_id())
 
             # Find available VNC port, if needed
             if params.get("display") == "vnc":
                 self.vnc_port = kvm_utils.find_free_port(5900, 6100)
 
+            # Find available spice port
+            if params.get("spice"):
+                self.spice_port = kvm_utils.find_free_port(8000, 8100)
+
             # Find random UUID if specified 'uuid = random' in config file
             if params.get("uuid") == "random":
                 f = open("/proc/sys/kernel/random/uuid")
                 self.uuid = f.read().strip()
                 f.close()
 
             # Generate or copy MAC addresses for all NICs
             num_nics = len(params.objects("nics"))
             for vlan in range(num_nics):
                 nic_name = params.objects("nics")[vlan]
@@ skipping 255 matching lines @@
                                        self.monitor.is_responsive())
 
 
     def is_dead(self):
         """
         Return True if the qemu process is dead.
         """
         return not self.process or not self.process.is_alive()
 
 
+    def verify_kernel_crash(self):
+        """
+        Find kernel crash message on the VM serial console.
+
+        @raise: VMDeadKernelCrashError, in case a kernel crash message was
+                found.
+        """
+        data = self.serial_console.get_output()
+        match = re.search(r"BUG:.*---\[ end trace .* \]---", data,
+                          re.DOTALL|re.MULTILINE)
+        if match is not None:
+            raise VMDeadKernelCrashError(match.group(0))
+
+
     def get_params(self):
         """
         Return the VM's params dict. Most modified params take effect only
         upon VM.create().
         """
         return self.params
 
 
     def get_monitor_filename(self, monitor_name):
         """
@@ skipping 456 matching lines @@
             clone = temp
 
             # From now on, clone is the source VM that will soon be destroyed
             # and self is the destination VM that will remain alive.  If this
             # is remote migration, self is a dead VM object.
 
             error.context("after migration")
             if local:
                 time.sleep(1)
                 self.verify_alive()
+                self.verify_kernel_crash()
 
             if local and stable_check:
                 try:
                     save1 = os.path.join(save_path, "src-" + clone.instance)
                     save2 = os.path.join(save_path, "dst-" + self.instance)
                     clone.save_to_file(save1)
                     self.save_to_file(save2)
                     # Fail if we see deltas
                     md5_save1 = utils.hash_file(save1)
                     md5_save2 = utils.hash_file(save2)
@@ skipping 159 matching lines @@
         Save the state of virtual machine to a file through migrate to
         exec
         """
         # Make sure we only get one iteration
         self.monitor.cmd("migrate_set_speed 1000g")
         self.monitor.cmd("migrate_set_downtime 100000000")
         self.monitor.migrate('"exec:cat>%s"' % path)
         # Restore the speed and downtime of migration
         self.monitor.cmd("migrate_set_speed %d" % (32<<20))
         self.monitor.cmd("migrate_set_downtime 0.03")