[PATCH 8/8] KVM test: test/module_probe: use installer object to load modules

[Lucas Meneghel Rodrigues <lmr@redhat.com>]

From: Eduardo Habkost <ehabkost@redhat.com>

Instead of writing our own module loading code, use the load_modules()
method offerred by the installer object registered by the 'build' test.

If no previous installer was registered, assume the KVM modules were
pre-installed on the system, and use the PreInstalledKvm class.

For module unloading, use rmmod directly instead of using the
kvm.installer code because utils.unload_module() run too much stuff to
check if the module is available and figure out dependencies, and we
just want a simple 'rmmod' command to be run.

This removes the check for the 'ksm' module from the test code. If an
user wants the ksm module to be loaded/unload, it can be specified on
the 'extra_modules' parameter on the 'build' test, or on the
'module_probe' test itself, in case there's no 'build' test configured.

Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
---
 client/tests/kvm/tests/module_probe.py |   81 ++++++++++++++++----------------
 1 files changed, 41 insertions(+), 40 deletions(-)

diff --git a/client/tests/kvm/tests/module_probe.py b/client/tests/kvm/tests/module_probe.py
index 727dcc2..c370c4d 100644
--- a/client/tests/kvm/tests/module_probe.py
+++ b/client/tests/kvm/tests/module_probe.py
@@ -1,55 +1,56 @@
 import re, commands, logging, os
-from autotest_lib.client.common_lib import error
-import kvm_subprocess, kvm_test_utils, kvm_utils
+from autotest_lib.client.common_lib import error, utils
+import kvm_subprocess, kvm_test_utils, kvm_utils, installer
+
 
 def run_module_probe(test, params, env):
     """
-    load/unload kvm modules several times.
+    load/unload KVM modules several times.
+
+    The test can run in two modes:
 
-    Module load/unload Test:
-    1) check host cpu module
-    2) get module info
-    3) unload modules if they exist, else load them
+    - based on previous 'build' test: in case KVM modules were installed by a
+      'build' test, we used the modules installed by the previous test.
 
-    @param test: Kvm test object
-    @param params: Dictionary with the test parameters
-    @param env: Dictionary with test environment.
+    - based on own params: if no previous 'build' test was run,
+      we assume a pre-installed KVM module. Some parameters that
+      work for the 'build' can be used, then, such as 'extra_modules'.
     """
 
-    def module_probe(name_list, arg=""):
-        for name in name_list:
-            cmd = "modprobe %s %s" % (arg, name)
-            logging.debug(cmd)
-            s, o = commands.getstatusoutput(cmd)
-            if s != 0:
-                logging.error("Failed to load/unload modules %s" % o)
-                return False
-        return True
-
-    #Check host cpu module
-    flags = file("/proc/cpuinfo").read()
-    arch_check = re.findall("%s\s" % "vmx", flags)
-    if arch_check:
-        arch = "kvm_intel"
+    installer_object = env.previous_installer()
+    if installer_object is None:
+        installer_object = installer.PreInstalledKvm()
+        installer_object.set_install_params(test, params)
+
+    logging.debug('installer object: %r', installer_object)
+
+    mod_str = params.get("mod_list")
+    if mod_str:
+        mod_list = re.split("[, ]", mod_str)
+        logging.debug("mod list will be: %r", mod_list)
     else:
-        arch = "kvm_amd"
+        mod_list = installer_object.full_module_list()
+        logging.debug("mod list from installer: %r", mod_list)
 
-    #Check whether ksm module exist
-    mod_str = ""
-    if os.path.exists("/sys/module/ksm"):
-        mod_str = "ksm,"
-    mod_str += "%s, kvm" % arch
+    # unload the modules before starting:
+    installer_object._unload_modules(mod_list)
 
-    mod_str = params.get("mod_list", mod_str)
-    mod_list = re.split(",", mod_str)
-    logging.debug(mod_list)
     load_count = int(params.get("load_count", 100))
-
     try:
         for i in range(load_count):
-                if not module_probe(mod_list):
-                    raise error.TestFail("Failed to load module %s" % mod_list)
-                if not module_probe(mod_list, "-r"):
-                    raise error.TestFail("Failed to remove module %s" % mod_list)
+            try:
+                installer_object.load_modules(mod_list)
+            except Exception,e:
+               raise error.TestFail("Failed to load modules [%r]: %s" %
+                                    (installer_object.full_module_list, e))
+
+            # unload using rmmod directly because utils.unload_module() (used by
+            # installer) does too much (runs lsmod, checks for dependencies),
+            # and we want to run the loop as fast as possible.
+            for mod in reversed(mod_list):
+                r = utils.system("rmmod %s" % (mod), ignore_status=True)
+                if r <> 0:
+                   raise error.TestFail("Failed to unload module %s. "
+                                        "exit status: %d" % (mod, r))
     finally:
-        module_probe(mod_list)
+        installer_object.load_modules()
-- 
1.7.2.3