test.iofuzz: some modifications of iofuzz

This patch make some modifications on iofuzz:
1. When session is not response, check whether qemu or guest kernel
   crash occurs.
2. Check whether qemu or guest kernel crash occurs after fuzz test.
3. Make the script follow pep8 rules
4. enable image snapshot.
Signed-off-by: NYunping Zheng <yunzheng@redhat.com>

generic/tests/cfg/iofuzz.cfg

 - iofuzz: install setup image_copy unattended_install.cdrom
     virt_test_type = qemu libvirt
+    backup_image_before_testing = yes
+    backup_image_on_check_error = yes
+    restore_image = yes
+    restore_image_on_check_error = yes
     only Linux
     type = iofuzz

generic/tests/iofuzz.py

@@ -2,7 +2,8 @@ import logging
 import re
 import random
 from autotest.client.shared import error
-from virttest import aexpect
+from virttest import aexpect, qemu_vm, virt_vm
+from virttest import data_dir, storage, qemu_storage
 
 
 def run(test, params, env):
@@ -23,6 +24,16 @@ def run(test, params, env):
     :param params: Dictionary with the test parameters
     :param env: Dictionary with test environment.
     """
+    def qemu_img_check():
+        """
+        Check guest disk image, and backup image when error occured
+        """
+        params["backup_image_on_check_error"] = 'yes'
+        base_dir = data_dir.get_data_dir()
+        image_name = storage.get_image_filename(params, base_dir)
+        image = qemu_storage.QemuImg(params, base_dir, image_name)
+        image.check_image(params, base_dir)
+
     def outb(session, port, data):
         """
         Write data to a given port.
@@ -37,8 +48,8 @@ def run(test, params, env):
                     (oct(data), port))
         try:
             session.cmd(outb_cmd)
-        except aexpect.ShellError, e:
-            logging.debug(e)
+        except aexpect.ShellError, err:
+            logging.debug(err)
 
     def inb(session, port):
         """
@@ -51,8 +62,8 @@ def run(test, params, env):
         inb_cmd = "dd if=/dev/port seek=%d of=/dev/null bs=1 count=1" % port
         try:
             session.cmd(inb_cmd)
-        except aexpect.ShellError, e:
-            logging.debug(e)
+        except aexpect.ShellError, err:
+            logging.debug(err)
 
     def fuzz(session, inst_list):
         """
@@ -66,26 +77,36 @@ def run(test, params, env):
         :raise error.TestFail: If the VM process dies in the middle of the
                 fuzzing procedure.
         """
-        for (op, operand) in inst_list:
-            if op == "read":
+        for (wr_op, operand) in inst_list:
+            if wr_op == "read":
                 inb(session, operand[0])
-            elif op == "write":
+            elif wr_op == "write":
                 outb(session, operand[0], operand[1])
             else:
-                raise error.TestError("Unknown command %s" % op)
+                raise error.TestError("Unknown command %s" % wr_op)
 
             if not session.is_responsive():
                 logging.debug("Session is not responsive")
+                try:
+                    vm.verify_alive()
+                except qemu_vm.QemuSegFaultError, err:
+                    raise error.TestFail("Qemu crash, error info: %s" % err)
+                except virt_vm.VMDeadKernelCrashError, err:
+                    raise error.TestFail("Guest kernel crash, info: %s" % err)
+                else:
+                    logging.warn("Guest is not alive during test")
+
                 if vm.process.is_alive():
                     logging.debug("VM is alive, try to re-login")
                     try:
                         session = vm.wait_for_login(timeout=10)
                     except Exception:
                         logging.debug("Could not re-login, reboot the guest")
+                        qemu_img_check()
                         session = vm.reboot(method="system_reset")
                 else:
                     raise error.TestFail("VM has quit abnormally during "
-                                         "%s: %s" % (op, operand))
+                                         "%s: %s" % (wr_op, operand))
 
     login_timeout = float(params.get("login_timeout", 240))
     vm = env.get_vm(params["main_vm"])
@@ -94,12 +115,12 @@ def run(test, params, env):
 
     try:
         ports = {}
-        r = random.SystemRandom()
+        o_random = random.SystemRandom()
 
         logging.info("Enumerate guest devices through /proc/ioports")
         ioports = session.cmd_output("cat /proc/ioports")
         logging.debug(ioports)
-        devices = re.findall("(\w+)-(\w+)\ : (.*)", ioports)
+        devices = re.findall(r"(\w+)-(\w+)\ : (.*)", ioports)
 
         skip_devices = params.get("skip_devices", "")
         fuzz_count = int(params.get("fuzz_count", 10))
@@ -126,10 +147,10 @@ def run(test, params, env):
 
             # Write random values to random ports of the range
             for _ in range(fuzz_count * (end - beg + 1)):
-                inst.append(("write",
-                             [r.randint(beg, end), r.randint(0, 255)]))
+                inst.append(("write",[o_random.randint(beg, end),
+                             o_random.randint(0, 255)]))
 
             fuzz(session, inst)
-
+        vm.verify_alive()
     finally:
         session.close()