Refactored KVM install test. Recently the source directory layout
for KVM was changed (now the toplevel is the userspace (qemu) code
with a kvm directory) and that was breaking the install test.
While I was working on the install test, I've refactored it:
* Fixed build for upstream release tarballs as well as git
repos.
* Pointed the test to the more recent upstream git repos.
* Each install method was encapsulated under classes. Will
adapt Mike's custom install method to this approach later.
* Moved functions that fall into the 'more general utility
functions' category to kvm_utils.
* Made a simple function to detect kvm source code directory
layout, to handle automatically build differences.
* Made module code removal more robust using as a base the
work previously done by Mike.
* Apply a patch to fix a build issue on current release tarballs.
* Made the build process to use all processors available on the
machine, reducing the time needed to build the userspace programs
and the kernel modules.
The refactor is already against the upstream version of the kvm
test.
Signed-off-by: Lucas Meneghel Rodrigues <lmr@xxxxxxxxxx>
---
client/tests/kvm/control | 3 +-
client/tests/kvm/kvm_install.py | 571 +++++++++++++++++++++------------------
client/tests/kvm/kvm_utils.py | 109 ++++++++-
3 files changed, 414 insertions(+), 269 deletions(-)
diff --git a/client/tests/kvm/control b/client/tests/kvm/control
index 154d513..133a975 100644
--- a/client/tests/kvm/control
+++ b/client/tests/kvm/control
@@ -102,7 +102,8 @@ params = {
## Install from git
"git_repo": 'git://git.kernel.org/pub/scm/linux/kernel/git/avi/kvm.git',
- "user_git_repo": 'git://git.kernel.org/pub/scm/linux/kernel/git/avi/kvm-userspace.git'
+ "user_git_repo": 'git://git.kernel.org/pub/scm/virt/kvm/qemu-kvm.git',
+ "kmod_repo": 'git://git.kernel.org/pub/scm/virt/kvm/kvm-kmod.git'
}
# Comment the job.run_test line if you do not want to install kvm on the host.
diff --git a/client/tests/kvm/kvm_install.py b/client/tests/kvm/kvm_install.py
index deb37ba..e76b74c 100755
--- a/client/tests/kvm/kvm_install.py
+++ b/client/tests/kvm/kvm_install.py
@@ -1,40 +1,246 @@
import time, os, sys, urllib, re, signal, logging, datetime
-from datetime import *
from autotest_lib.client.bin import utils, test
from autotest_lib.client.common_lib import error
import kvm_utils
-def run_kvm_install(test, params, env):
+def load_kvm_modules(module_dir):
"""
- KVM build test. Installs KVM using the selected install mode. Most install
- methods will take kvm source code, build it and install it to a given
- location.
+ Unload previously loaded kvm modules, then load modules present on any
+ sub directory of module_dir. Function will walk through module_dir until
+ it finds the modules.
- @param test: kvm test object.
- @param params: Dictionary with the test parameters.
- @param env: Dictionary with test environment.
+ @param module_dir: Directory where the KVM modules are located.
"""
- install_mode = params.get("mode")
- logging.info("Selected installation mode: %s" % install_mode)
+ vendor = "intel"
+ if os.system("grep vmx /proc/cpuinfo 1>/dev/null") != 0:
+ vendor = "amd"
+ logging.debug("Detected CPU vendor as '%s'" %(vendor))
- srcdir = params.get("srcdir", test.srcdir)
- if not os.path.exists(srcdir):
- os.mkdir(srcdir)
+ logging.debug("Killing any qemu processes that might be left behind")
+ utils.system("pkill qemu", ignore_status=True)
+
+ logging.info("Unloading previously loaded KVM modules")
+ kvm_utils.unload_module("kvm")
+ if utils.module_is_loaded("kvm"):
+ message = "Failed to remove old KVM modules"
+ logging.error(message)
+ raise error.TestError(message)
+
+ logging.info("Loading new KVM modules...")
+ kvm_module_path = None
+ kvm_vendor_module_path = None
+ for folder, subdirs, files in os.walk(module_dir):
+ if "kvm.ko" in files:
+ kvm_module_path = os.path.join(folder, "kvm.ko")
+ kvm_vendor_module_path = os.path.join(folder, "kvm-%s.ko" % vendor)
+ abort = False
+ if not os.path.isfile(kvm_module_path):
+ logging.error("Could not find KVM module that was supposed to be"
+ " built on the source dir")
+ abort = True
+ elif not os.path.isfile(kvm_vendor_module_path):
+ logging.error("Could not find KVM (%s) module that was supposed to be"
+ " built on the source dir", vendor)
+ abort = True
+ if abort:
+ raise error.TestError("Could not load KVM modules.")
+ utils.system("/sbin/insmod %s" % kvm_module_path)
+ time.sleep(1)
+ utils.system("/sbin/insmod %s" % kvm_vendor_module_path)
+
+ if not utils.module_is_loaded("kvm"):
+ message = "Failed to load the KVM modules built for the test"
+ logging.error(message)
+ raise error.TestError(message)
+
+
+def create_symlinks(test_bindir, prefix):
+ """
+ Create symbolic links for the appropriate qemu and qemu-img commands on
+ the kvm test bindir.
+
+ @param test_bindir: KVM test bindir
+ @param prefix: KVM prefix path
+ """
+ qemu_path = os.path.join(test_bindir, "qemu")
+ qemu_img_path = os.path.join(test_bindir, "qemu-img")
+ if os.path.lexists(qemu_path):
+ os.unlink(qemu_path)
+ if os.path.lexists(qemu_img_path):
+ os.unlink(qemu_img_path)
+ kvm_qemu = os.path.join(prefix, "bin", "qemu-system-x86_64")
+ if not os.path.isfile(kvm_qemu):
+ raise error.TestError('Invalid qemu path')
+ kvm_qemu_img = os.path.join(prefix, "bin", "qemu-img")
+ if not os.path.isfile(kvm_qemu_img):
+ raise error.TestError('Invalid qemu-img path')
+ os.symlink(kvm_qemu, qemu_path)
+ os.symlink(kvm_qemu_img, qemu_img_path)
- # do not install
- if install_mode == "noinstall":
- logging.info("Skipping installation")
- # install from git
- elif install_mode == "git":
- repo = params.get("git_repo")
+class SourceDirInstaller:
+ """
+ Class that handles building/installing KVM directly from a tarball or
+ a single source code dir.
+ """
+ def __init__(self, test, params):
+ """
+ Initializes class attributes, and retrieves KVM code.
+
+ @param test: kvm test object
+ @param params: Dictionary with test arguments
+ """
+ install_mode = params["mode"]
+ srcdir = params.get("srcdir")
+ # KVM build prefix
+ self.test_bindir = test.bindir
+ prefix = os.path.join(test.bindir, 'build')
+ self.prefix = os.path.abspath(prefix)
+ # Are we going to load modules?
+ load_modules = params.get('load_modules')
+ if not load_modules:
+ self.load_modules = True
+ elif load_modules == 'yes':
+ self.load_modules = True
+ elif load_modules == 'no':
+ self.load_modules = False
+
+ if install_mode == 'localsrc':
+ if not srcdir:
+ raise error.TestError("Install from source directory specified"
+ "but no source directory provided on the"
+ "control file.")
+ else:
+ self.srcdir = srcdir
+ self.repo_type = kvm_utils.check_kvm_source_dir(self.srcdir)
+ return
+ else:
+ srcdir = test.srcdir
+ if not os.path.isdir(srcdir):
+ os.makedirs(srcdir)
+
+ if install_mode == 'release':
+ release_tag = params.get("release_tag")
+ release_dir = params.get("release_dir")
+ logging.info("Installing KVM from release tarball")
+ if not release_tag:
+ release_tag = kvm_utils.get_latest_kvm_release_tag(release_dir)
+ tarball = os.path.join(release_dir, "kvm-%s.tar.gz" % release_tag)
+ logging.info("Retrieving release kvm-%s" % release_tag)
+ tarball = utils.unmap_url("/", tarball, "/tmp")
+
+ elif install_mode == 'snapshot':
+ logging.info("Installing KVM from snapshot")
+ snapshot_date = params.get("snapshot_date")
+ snapshot_dir = params.get("snapshot_dir")
+ if not snapshot_date:
+ # Take yesterday's snapshot
+ d = (datetime.date.today() -
+ datetime.timedelta(1)).strftime("%Y%m%d")
+ else:
+ d = snapshot_date
+ tarball = os.path.join(snapshot_dir, "kvm-snapshot-%s.tar.gz" % d)
+ logging.info("Retrieving kvm-snapshot-%s" % d)
+ tarball = utils.unmap_url("/", tarball, "/tmp")
+
+ elif install_mode == 'localtar':
+ tarball = params.get("tarball")
+ if not tarball:
+ raise error.TestError("KVM Tarball install specified but no"
+ " tarball provided on control file.")
+ logging.info("Installing KVM from a local tarball")
+ logging.info("Using tarball %s")
+ tarball = utils.unmap_url("/", params.get("tarball"), "/tmp")
+
+ os.chdir(srcdir)
+ self.srcdir = os.path.join(srcdir, utils.extract_tarball(tarball))
+ self.repo_type = kvm_utils.check_kvm_source_dir(self.srcdir)
+
+
+ def __build(self):
+ os.chdir(self.srcdir)
+ cfg = "./configure --prefix=%s" % self.prefix
+ if self.repo_type == 1:
+ steps = [cfg, "make clean", "make -j %s" % utils.count_cpus()]
+ if not os.path.exists('qemu/pc-bios/bios.bin'):
+ steps.append("make -C bios")
+ steps.append("make -C extboot")
+ steps.append("cp -f bios/BIOS-bochs-latest"
+ " qemu/pc-bios/bios.bin")
+ steps.append("cp -f vgabios/VGABIOS-lgpl-latest.bin"
+ " qemu/pc-bios/vgabios.bin")
+ steps.append("cp -f vgabios/VGABIOS-lgpl-latest.cirrus.bin"
+ " qemu/pc-bios/vgabios-cirrus.bin")
+ steps.append("cp -f extboot/extboot.bin"
+ " qemu/pc-bios/extboot.bin")
+ elif self.repo_type == 2:
+ steps = [cfg, "make clean", "make -j %s" % utils.count_cpus()]
+
+ logging.info("Building KVM")
+ for step in steps:
+ utils.system(step)
+
+
+ def __install(self):
+ os.chdir(self.srcdir)
+ logging.info("Installing KVM userspace")
+ if self.repo_type == 1:
+ utils.system("make -C qemu install")
+ elif self.repo_type == 2:
+ utils.system("make install")
+ create_symlinks(self.test_bindir, self.prefix)
+
+
+ def __load_modules(self):
+ load_kvm_modules(self.srcdir)
+
+
+ def install(self):
+ self.__build()
+ self.__install()
+ if self.load_modules:
+ self.__load_modules()
+
+
+class GitInstaller:
+ def __init__(self, test, params):
+ """
+ Initialize class parameters and retrieves code from git repositories.
+
+ @param test: kvm test object.
+ @param params: Dictionary with test parameters.
+ """
+ install_mode = params["mode"]
+ srcdir = params.get("srcdir", test.bindir)
+ if not srcdir:
+ os.makedirs(srcdir)
+ self.srcdir = srcdir
+ # KVM build prefix
+ self.test_bindir = test.bindir
+ prefix = os.path.join(test.bindir, 'build')
+ self.prefix = os.path.abspath(prefix)
+ # Are we going to load modules?
+ load_modules = params.get('load_modules')
+ if not load_modules:
+ self.load_modules = True
+ elif load_modules == 'yes':
+ self.load_modules = True
+ elif load_modules == 'no':
+ self.load_modules = False
+
+ kernel_repo = params.get("git_repo")
user_repo = params.get("user_git_repo")
+ kmod_repo = params.get("kmod_repo")
+
branch = params.get("git_branch", "master")
lbranch = params.get("lbranch")
+
tag = params.get("git_tag", "HEAD")
user_tag = params.get("user_git_tag", "HEAD")
- if not repo:
+ kmod_tag = params.get("kmod_git_tag", "HEAD")
+
+ if not kernel_repo:
message = "KVM git repository path not specified"
logging.error(message)
raise error.TestError(message)
@@ -42,256 +248,89 @@ def run_kvm_install(test, params, env):
message = "KVM user git repository path not specified"
logging.error(message)
raise error.TestError(message)
- __install_kvm_from_git(test, srcdir, repo, user_repo, branch, tag,
- user_tag, lbranch)
-
- # install from release
- elif install_mode == "release":
- release_dir = params.get("release_dir")
- release_tag = params.get("release_tag")
- if not release_dir:
- message = "Release dir not specified"
- logging.error(message)
- raise error.TestError(message)
- __install_kvm_release(test, srcdir, release_dir, release_tag)
-
- # install from snapshot
- elif install_mode == "snapshot":
- snapshot_dir = params.get("snapshot_dir")
- snapshot_date = params.get("snapshot_date")
- if not snapshot_dir:
- message = "Snapshot dir not specified"
- logging.error(message)
- raise error.TestError(message)
- __install_kvm_from_snapshot(test, srcdir, snapshot_dir, snapshot_date)
- # install from tarball
- elif install_mode == "localtar":
- tarball = params.get("tarball")
- if not tarball:
- message = "Local tarball filename not specified"
- logging.error(message)
- raise error.TestError(message)
- __install_kvm_from_local_tarball(test, srcdir, tarball)
+ kernel_srcdir = os.path.join(srcdir, "kvm")
+ kvm_utils.get_git_branch(kernel_repo, branch, kernel_srcdir, tag,
+ lbranch)
+ self.kernel_srcdir = kernel_srcdir
+
+ userspace_srcdir = os.path.join(srcdir, "kvm_userspace")
+ kvm_utils.get_git_branch(user_repo, branch, userspace_srcdir, user_tag,
+ lbranch)
+ self.userspace_srcdir = userspace_srcdir
+
+ if kmod_repo:
+ kmod_srcdir = os.path.join (srcdir, "kvm_kmod")
+ kvm_utils.get_git_branch(kmod_repo, branch, kmod_srcdir, user_tag,
+ lbranch)
+ self.kmod_srcdir = kmod_srcdir
+
+
+ def __build(self):
+ if self.kmod_srcdir:
+ logging.info('Building KVM modules')
+ os.chdir(self.kmod_srcdir)
+ utils.system('./configure')
+ utils.system('make clean')
+ utils.system('make sync LINUX=%s' % self.kernel_srcdir)
+ utils.system('make -j %s' % utils.count_cpus())
+ logging.info('Building KVM userspace code')
+ os.chdir(self.userspace_srcdir)
+ utils.system('./configure --prefix=%s' % self.prefix)
+ utils.system('make clean')
+ utils.system('make -j %s' % utils.count_cpus())
+ else:
+ os.chdir(self.userspace_srcdir)
+ utils.system('./configure --prefix=%s' % self.prefix)
+ logging.info('Building KVM modules')
+ utils.system('make clean')
+ utils.system('make -C kernel LINUX=%s sync' % self.kernel_srcdir)
+ logging.info('Building KVM userspace code')
+ utils.system('make -j %s' % utils.count_cpus())
+
+
+ def __install(self):
+ os.chdir(self.userspace_srcdir)
+ utils.system('make install')
+ create_symlinks(self.test_bindir, self.prefix)
+
+
+ def __load_modules(self):
+ if self.kmod_srcdir:
+ load_kvm_modules(self.kmod_srcdir)
+ else:
+ load_kvm_modules(self.userspace_srcdir)
+
+
+ def install(self):
+ self.__build()
+ self.__install()
+ if self.load_modules:
+ self.__load_modules()
- # install from local sources
- elif install_mode == "localsrc":
- __install_kvm(test, srcdir)
-
- # invalid installation mode
- else:
- message = "Invalid installation mode: '%s'" % install_mode
- logging.error(message)
- raise error.TestError(message)
-
- # load kvm modules (unless requested not to)
- if params.get('load_modules', "yes") == "yes":
- __load_kvm_modules()
- else:
- logging.info("user requested not to load kvm modules")
-
-def __cleanup_dir(dir):
- # only alerts if src directory is not empty
- for root, dirs, files in os.walk(dir):
- if dirs or files:
- message = "Directory \'%s\' is not empty" % dir
- logging.error(message)
- raise error.TestError(message)
-
-def __install_kvm_release(test, srcdir, release_dir, release_tag):
- if not release_tag:
- try:
- # look for the latest release in the web
- page_url = os.path.join(release_dir, "showfiles.php")
- local_web_page = utils.unmap_url("/", page_url, "/tmp")
- f = open(local_web_page, "r")
- data = f.read()
- f.close()
- rx = re.compile("package_id=(\d+).*\>kvm\<", re.IGNORECASE)
- matches = rx.findall(data)
- package_id = matches[0]
- #package_id = 209008
- rx = re.compile("package_id=%s.*release_id=\d+\">(\d+)" %
- package_id, re.IGNORECASE)
- matches = rx.findall(data)
- # the first match contains the latest release tag
- release_tag = matches[0]
- except Exception, e:
- message = "Could not fetch latest KVM release tag (%s)" % str(e)
- logging.error(message)
- raise error.TestError(message)
-
- logging.info("Installing release %s (kvm-%s)" % (release_tag, release_tag))
- tarball = os.path.join(release_dir, "kvm-%s.tar.gz" % release_tag)
- tarball = utils.unmap_url("/", tarball, "/tmp")
- __install_kvm_from_local_tarball(test, srcdir, tarball)
-
-
-def __install_kvm_from_git(test, srcdir, repo, user_repo, branch, tag,
- user_tag, lbranch):
- local_git_srcdir = os.path.join(srcdir, "kvm")
- if not os.path.exists(local_git_srcdir):
- os.mkdir(local_git_srcdir)
- local_user_git_srcdir = os.path.join(srcdir, "kvmuser")
- if not os.path.exists(local_user_git_srcdir):
- os.mkdir(local_user_git_srcdir)
-
- __get_git_branch(repo, branch, local_git_srcdir, tag, lbranch)
- __get_git_branch(user_repo, branch, local_user_git_srcdir, user_tag,
- lbranch)
- utils.system("cd %s && ./configure && make -C kernel LINUX=%s sync" %
- (local_user_git_srcdir, local_git_srcdir))
- __install_kvm(test, local_user_git_srcdir)
-
-
-def __get_git_branch(repository, branch, srcdir, commit=None, lbranch=None):
- logging.info("Getting sources from git <REP=%s BRANCH=%s TAG=%s> to local"
- "directory <%s>" % (repository, branch, commit, srcdir))
- pwd = os.getcwd()
- os.chdir(srcdir)
- if os.path.exists(".git"):
- utils.system("git reset --hard")
- else:
- utils.system("git init")
-
- if not lbranch:
- lbranch = branch
-
- utils.system("git fetch -q -f -u -t %s %s:%s" %
- (repository, branch, lbranch))
- utils.system("git checkout %s" % lbranch)
- if commit:
- utils.system("git checkout %s" % commit)
-
- h = utils.system_output('git log --pretty=format:"%H" -1')
- desc = utils.system_output("git describe")
- logging.info("Commit hash for %s is %s (%s)" % (repository, h.strip(),
- desc))
- os.chdir(pwd)
+def run_kvm_install(test, params, env):
+ """
+ Installs KVM using the selected install mode. Most install methods will
+ take kvm source code, build it and install it to a given location.
-def __install_kvm_from_snapshot(test, srcdir, snapshot_dir ,snapshot_date):
- logging.info("Source snapshot dir: %s" % snaphost_dir)
- logging.info("Source snapshot date: %s" % snapshot_date)
+ @param test: kvm test object.
+ @param params: Dictionary with test parameters.
+ @param env: Test environment.
+ """
+ install_mode = params.get("mode")
+ srcdir = params.get("srcdir", test.srcdir)
+ params["srcdir"] = srcdir
- if not snapshot_date:
- # takes yesterday's snapshot
- d = (datetime.date.today() - datetime.timedelta(1)).strftime("%Y%m%d")
+ if install_mode == 'noinstall':
+ logging.info("Skipping installation")
+ return
+ elif install_mode in ['localsrc', 'localtar', 'release', 'snapshot']:
+ installer = SourceDirInstaller(test, params)
+ elif install_mode == 'git':
+ installer = GitInstaller(test, params)
else:
- d = snapshot_date
-
- tarball = os.path.join(snaphost_dir, "kvm-snapshot-%s.tar.gz" % d)
- logging.info("Tarball url: %s" % tarball)
- tarball = utils.unmap_url("/", tarball, "/tmp")
- __install_kvm_from_local_tarball(test, srcdir, tarball)
-
-
-def __install_kvm_from_local_tarball(test, srcdir, tarball):
- pwd = os.getcwd()
- os.chdir(srcdir)
- newdir = utils.extract_tarball(tarball)
- if newdir:
- srcdir = os.path.join(srcdir, newdir)
- os.chdir(pwd)
- __install_kvm(test, srcdir)
-
-
-def __load_kvm_modules():
- logging.info("Detecting CPU vendor...")
- vendor = "intel"
- if os.system("grep vmx /proc/cpuinfo 1>/dev/null") != 0:
- vendor = "amd"
- logging.info("Detected CPU vendor as '%s'" %(vendor))
-
- #if self.config.load_modules == "yes":
- # remove existing in kernel kvm modules
- logging.info("Unloading loaded KVM modules (if present)...")
- #utils.system("pkill qemu 1>/dev/null 2>&1", ignore_status=True)
- utils.system("pkill qemu", ignore_status=True)
- #if utils.system("grep kvm_%s /proc/modules 1>/dev/null" % vendor,
- # ignore_status=True) == 0:
- utils.system("/sbin/modprobe -r kvm_%s" % vendor, ignore_status=True)
- #if utils.system("grep kvm /proc/modules 1>/dev/null",
- # ignore_status=True) == 0:
- utils.system("/sbin/modprobe -r kvm", ignore_status=True)
-
- if utils.system("grep kvm /proc/modules 1>/dev/null",
- ignore_status=True) == 0:
- message = "Failed to remove old KVM modules"
- logging.error(message)
- raise error.TestError(message)
-
- logging.info("Loading new KVM modules...")
- os.chdir("kernel")
- if os.path.exists("x86"):
- os.chdir("x86")
- utils.system("/sbin/insmod ./kvm.ko && sleep 1 && /sbin/insmod"
- "./kvm-%s.ko" % vendor)
-
- #elif self.config.load_modules == "no":
- #logging.info("user requested not to load kvm modules")
-
- ### no matter if new kvm modules are to be loaded or not
- ### make sure there are kvm modules installed.
- if utils.system("grep kvm_%s /proc/modules 1>/dev/null" %(vendor),
- ignore_status=True) != 0:
- message = "Failed to load KVM modules"
- logging.error(message)
- raise error.TestError(message)
-
-def __install_kvm(test, srcdir):
- # create destination dir
-
- kvm_build_dir = os.path.join(srcdir, '..', '..', 'build')
- kvm_build_dir = os.path.abspath(kvm_build_dir)
-
- if not os.path.exists(kvm_build_dir):
- os.mkdir(kvm_build_dir)
-
- # change to source dir
- os.chdir(srcdir)
-
- # start working...
- logging.info("Building KVM...")
-
- def run(cmd, title, timeout):
- (status, pid, output) = kvm_utils.run_bg(cmd, None, logging.info,
- '(%s)' % title,
- timeout=timeout)
- if status != 0:
- kvm_utils.safe_kill(pid, signal.SIGTERM)
- raise error.TestFail, "'%s' failed" % cmd
-
- # configure + make
- run("./configure --prefix=%s" % kvm_build_dir, "configure", 30)
- run("make clean", "make clean", 30)
- run("make", "make", 1200)
-
- # make bios binaries if missing
- if not os.path.exists('qemu/pc-bios/bios.bin'):
- run("make -C bios", "make bios", 60)
- run("make -C vgabios", "make vgabios", 60)
- run("make -C extboot", "make extboot", 60)
- cp1 = "cp -f bios/BIOS-bochs-latest qemu/pc-bios/bios.bin"
- cp2 = "cp -f vgabios/VGABIOS-lgpl-latest.bin qemu/pc-bios/vgabios.bin"
- cp3 = "cp -f vgabios/VGABIOS-lgpl-latest.cirrus.bin qemu/pc-bios/vgabios-cirrus.bin"
- cp4 = "cp -f extboot/extboot.bin qemu/pc-bios/extboot.bin"
- cmd = "&& ".join([cp1, cp2, cp3, cp4])
- run(cmd, "copy bios binaries", 30)
-
- # install from qemu directory
- run("make -C qemu install", "(make install) ", 120)
-
- # create symlinks
- qemu_path = os.path.join(test.bindir, "qemu")
- qemu_img_path = os.path.join(test.bindir, "qemu-img")
- if os.path.lexists(qemu_path):
- os.unlink(qemu_path)
- if os.path.lexists(qemu_img_path):
- os.unlink(qemu_img_path)
- kvm_qemu = os.path.join(kvm_build_dir, "bin", "qemu-system-x86_64")
- kvm_qemu_img = os.path.join(kvm_build_dir, "bin", "qemu-img")
- os.symlink(kvm_qemu, qemu_path)
- os.symlink(kvm_qemu_img, qemu_img_path)
+ raise error.TestError('Invalid or unsupported'
+ ' install mode: %s' % install_mode)
- logging.info("Done building and installing KVM")
+ installer.install()
\ No newline at end of file
diff --git a/client/tests/kvm/kvm_utils.py b/client/tests/kvm/kvm_utils.py
index 434190d..27bc7c1 100644
--- a/client/tests/kvm/kvm_utils.py
+++ b/client/tests/kvm/kvm_utils.py
@@ -1,5 +1,7 @@
import md5, thread, subprocess, time, string, random, socket, os, signal, pty
import select, re, logging
+from autotest_lib.client.bin import utils
+from autotest_lib.client.common_lib import error
"""
KVM test utility functions.
@@ -125,6 +127,109 @@ def safe_kill(pid, signal):
return False
+def get_latest_kvm_release_tag(release_dir):
+ """
+ Fetches the latest release tag for KVM.
+
+ @param release_dir: KVM source forge download location.
+ """
+ try:
+ page_url = os.path.join(release_dir, "showfiles.php")
+ local_web_page = utils.unmap_url("/", page_url, "/tmp")
+ f = open(local_web_page, "r")
+ data = f.read()
+ f.close()
+ rx = re.compile("package_id=(\d+).*\>kvm\<", re.IGNORECASE)
+ matches = rx.findall(data)
+ package_id = matches[0]
+ #package_id = 209008
+ rx = re.compile("package_id=%s.*release_id=\d+\">(\d+)" % package_id,
+ re.IGNORECASE)
+ matches = rx.findall(data)
+ return matches[0] # the first match contains the latest release tag
+ except Exception, e:
+ message = "Could not fetch latest KVM release tag: %s" % str(e)
+ logging.error(message)
+ raise error.TestError(message)
+
+
+def get_git_branch(repository, branch, srcdir, commit=None, lbranch=None):
+ """
+ Retrieves a given git code repository.
+
+ @param repository: Git repository URL
+ """
+ logging.info("Fetching git [REP '%s' BRANCH '%s' TAG '%s'] -> %s",
+ repository, branch, commit, srcdir)
+ if not os.path.exists(srcdir):
+ os.makedirs(srcdir)
+ os.chdir(srcdir)
+
+ if os.path.exists(".git"):
+ utils.system("git reset --hard")
+ else:
+ utils.system("git init")
+
+ if not lbranch:
+ lbranch = branch
+
+ utils.system("git fetch -q -f -u -t %s %s:%s" %
+ (repository, branch, lbranch))
+ utils.system("git checkout %s" % lbranch)
+ if commit:
+ utils.system("git checkout %s" % commit)
+
+ h = utils.system_output('git log --pretty=format:"%H" -1')
+ desc = utils.system_output("git describe")
+ logging.info("Commit hash for %s is %s (%s)" % (repository, h.strip(),
+ desc))
+ return srcdir
+
+
+def unload_module(module_name):
+ """
+ Removes a module. Handles dependencies. If even then it's not possible
+ to remove one of the modules, it will trhow an error.CmdError exception.
+
+ @param module_name: Name of the module we want to remove.
+ """
+ l_raw = utils.system_output("/sbin/lsmod").splitlines()
+ lsmod = [x for x in l_raw if x.split()[0] == module_name]
+ if len(lsmod) > 0:
+ line_parts = lsmod[0].split()
+ if len(line_parts) == 4:
+ submodules = line_parts[3].split(",")
+ for submodule in submodules:
+ unload_module(submodule)
+ utils.system("/sbin/modprobe -r %s" % module_name)
+ logging.info("Module %s unloaded" % module_name)
+ else:
+ logging.info("Module %s is already unloaded" % module_name)
+
+
+def check_kvm_source_dir(source_dir):
+ """
+ Inspects the kvm source directory and verifies its disposition. In some
+ occasions build may be dependant on the source directory disposition.
+ The reason why the return codes are numbers is that we might have more
+ changes on the source directory layout, so it's not scalable to just use
+ strings like 'old_repo', 'new_repo' and such.
+
+ @param source_dir: Source code path that will be inspected.
+ """
+ os.chdir(source_dir)
+ has_qemu_dir = os.path.isdir('qemu')
+ has_kvm_dir = os.path.isdir('kvm')
+ if has_qemu_dir and not has_kvm_dir:
+ logging.debug("qemu directory detected, source dir layout 1")
+ return 1
+ if has_kvm_dir and not has_qemu_dir:
+ logging.debug("kvm directory detected, source dir layout 2")
+ return 2
+ else:
+ raise error.TestError("Unknown source dir layout, cannot proceed.")
+
+
# The following are a class and functions used for SSH, SCP and Telnet
# communication with guests.
@@ -297,14 +402,14 @@ class kvm_spawn:
done = True
# Check if child has died
if self.poll() != None:
- logging.debug("Process terminated with status %d" % self.poll())
+ logging.debug("Process terminated with status %d", self.poll())
done = True
# Are we done?
if done: break
# Print some debugging info
if match == None and self.poll() != 0:
- logging.debug("Timeout elapsed or process terminated. Output:",
+ logging.debug("Timeout elapsed or process terminated. Output: %s",
format_str_for_message(data.strip()))
return (match, data)
--
1.6.2.2
--
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
