def run_stress_boot(test, params, env):
"""
Boots VMs until one of them becomes unresponsive, and records the maximum
number of VMs successfully started:
1) boot the first vm
2) boot the second vm cloned from the first vm, check whether it boots up
and all booted vms respond to shell commands
3) go on until cannot create VM anymore or cannot allocate memory for VM
@param test: kvm test object
@param params: Dictionary with the test parameters
@param env: Dictionary with test environment.
"""
error.base_context("waiting for the first guest to be up", logging.info)
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
login_timeout = float(params.get("login_timeout", 240))
session = vm.wait_for_login(timeout=login_timeout)
num = 2
sessions = [session]
# Boot the VMs
try:
while num <= int(params.get("max_vms")):
# Clone vm according to the first one
error.base_context("booting guest #%d" % num, logging.info)
vm_name = "vm%d" % num
vm_params = vm.params.copy()
curr_vm = vm.clone(vm_name, vm_params)
env.register_vm(vm_name, curr_vm)
virt_env_process.preprocess_vm(test, vm_params, env, vm_name)
params["vms"] += " " + vm_name
sessions.append(curr_vm.wait_for_login(timeout=login_timeout))
logging.info("Guest #%d booted up successfully", num)
# Check whether all previous shell sessions are responsive
for i, se in enumerate(sessions):
error.context("checking responsiveness of guest #%d" % (i + 1),
logging.debug)
se.cmd(params.get("alive_test_cmd"))
num += 1
finally:
for se in sessions:
se.close()
logging.info("Total number booted: %d" % (num -1))
def run_stress_boot(test, params, env):
"""
Boots VMs until one of them becomes unresponsive, and records the maximum
number of VMs successfully started:
1) boot the first vm
2) boot the second vm cloned from the first vm, check whether it boots up
and all booted vms respond to shell commands
3) go on until cannot create VM anymore or cannot allocate memory for VM
@param test: kvm test object
@param params: Dictionary with the test parameters
@param env: Dictionary with test environment.
"""
error.base_context("waiting for the first guest to be up", logging.info)
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
login_timeout = float(params.get("login_timeout", 240))
session = vm.wait_for_login(timeout=login_timeout)
num = 2
sessions = [session]
# Boot the VMs
try:
while num <= int(params.get("max_vms")):
# Clone vm according to the first one
error.base_context("booting guest #%d" % num, logging.info)
vm_name = "vm%d" % num
vm_params = vm.params.copy()
curr_vm = vm.clone(vm_name, vm_params)
env.register_vm(vm_name, curr_vm)
virt_env_process.preprocess_vm(test, vm_params, env, vm_name)
params["vms"] += " " + vm_name
sessions.append(curr_vm.wait_for_login(timeout=login_timeout))
logging.info("Guest #%d booted up successfully", num)
# Check whether all previous shell sessions are responsive
for i, se in enumerate(sessions):
error.context("checking responsiveness of guest #%d" % (i + 1),
logging.debug)
se.cmd(params.get("alive_test_cmd"))
num += 1
finally:
for se in sessions:
se.close()
logging.info("Total number booted: %d" % (num - 1))
def run_trans_hugepage_swapping(test, params, env):
"""
KVM khugepage user side test:
1) Verify that the hugepages can be swapped in/out.
@param test: KVM test object.
@param params: Dictionary with test parameters.
@param env: Dictionary with the test environment.
"""
def get_args(args_list):
"""
Get the memory arguments from system
"""
args_list_tmp = args_list.copy()
for line in file('/proc/meminfo', 'r').readlines():
for key in args_list_tmp.keys():
if line.startswith("%s" % args_list_tmp[key]):
args_list_tmp[key] = int(re.split('\s+', line)[1])
return args_list_tmp
test_config = virt_test_setup.TransparentHugePageConfig(test, params)
try:
test_config.setup()
# Swapping test
logging.info("Swapping test start")
# Parameters of memory information
# @total: Memory size
# @free: Free memory size
# @swap_size: Swap size
# @swap_free: Free swap size
# @hugepage_size: Page size of one hugepage
# @page_size: The biggest page size that app can ask for
args_dict_check = {"free" : "MemFree", "swap_size" : "SwapTotal",
"swap_free" : "SwapFree", "total" : "MemTotal",
"hugepage_size" : "Hugepagesize",}
args_dict = get_args(args_dict_check)
swap_free = []
total = int(args_dict['total']) / 1024
free = int(args_dict['free']) / 1024
swap_size = int(args_dict['swap_size']) / 1024
swap_free.append(int(args_dict['swap_free'])/1024)
hugepage_size = int(args_dict['hugepage_size']) / 1024
dd_timeout = float(params.get("dd_timeout", 900))
login_timeout = float(params.get("login_timeout", 360))
check_cmd_timeout = float(params.get("check_cmd_timeout", 900))
mem_path = os.path.join(test.tmpdir, 'thp_space')
tmpfs_path = "/space"
# If swap is enough fill all memory with dd
if swap_free > (total - free):
count = total / hugepage_size
tmpfs_size = total
else:
count = free / hugepage_size
tmpfs_size = free
if swap_size <= 0:
raise logging.info("Host does not have swap enabled")
session = None
try:
if not os.path.isdir(mem_path):
os.makedirs(mem_path)
utils.run("mount -t tmpfs -o size=%sM none %s" % (tmpfs_size,
mem_path))
# Set the memory size of vm
# To ignore the oom killer set it to the free swap size
vm = virt_test_utils.get_living_vm(env, params.get("main_vm"))
if int(params['mem']) > swap_free[0]:
vm.destroy()
vm_name = 'vmsw'
vm0 = params.get("main_vm")
vm0_key = virt_utils.env_get_vm(env, vm0)
params['vms'] = params['vms'] + " " + vm_name
params['mem'] = str(swap_free[0])
vm_key = vm0_key.clone(vm0, params)
virt_utils.env_register_vm(env, vm_name, vm_key)
virt_env_process.preprocess_vm(test, params, env, vm_name)
vm_key.create()
session = virt_utils.wait_for(vm_key.remote_login,
timeout=login_timeout)
else:
session = virt_test_utils.wait_for_login(vm,
timeout=login_timeout)
error.context("making guest to swap memory")
cmd = ("dd if=/dev/zero of=%s/zero bs=%s000000 count=%s" %
(mem_path, hugepage_size, count))
utils.run(cmd)
args_dict = get_args(args_dict_check)
swap_free.append(int(args_dict['swap_free'])/1024)
if swap_free[1] - swap_free[0] >= 0:
raise error.TestFail("No data was swapped to memory")
# Try harder to make guest memory to be swapped
session.cmd("find / -name \"*\"", timeout=check_cmd_timeout)
finally:
if session is not None:
utils.run("umount %s" % mem_path)
logging.info("Swapping test succeed")
finally:
session.close()
test_config.cleanup()
# Associate pidfile name
params['pid_' + vm_name] = virt_utils.generate_tmp_file_name(vm_name,
'pid')
if not params.get('extra_params'):
params['extra_params'] = ' '
params['extra_params_' + vm_name] = params.get('extra_params')
params['extra_params_' + vm_name] += (" -pidfile %s" %
(params.get('pid_' + vm_name)))
params['extra_params'] = params.get('extra_params_'+vm_name)
# ksm_size: amount of memory used by allocator
ksm_size = mem - guest_reserve
logging.debug("Memory used by allocator on guests = %dM", ksm_size)
# Creating the first guest
virt_env_process.preprocess_vm(test, params, env, vm_name)
lvms.append(env.get_vm(vm_name))
if not lvms[0]:
raise error.TestError("VM object not found in environment")
if not lvms[0].is_alive():
raise error.TestError("VM seems to be dead; Test requires a living "
"VM")
logging.debug("Booting first guest %s", lvms[0].name)
lsessions.append(lvms[0].wait_for_login(timeout=360))
# Associate vm PID
try:
tmp = open(params.get('pid_' + vm_name), 'r')
params['pid_' + vm_name] = int(tmp.readline())
except Exception:
def run_smbios_table(test, params, env):
"""
Check smbios table :
1) Boot a guest with smbios options
2) verify if host bios options have been emulated
@param test: KVM test object.
@param params: Dictionary with the test parameters.
@param env: Dictionary with test environment.
"""
vendor_cmd = "dmidecode --type 0 | grep Vendor | awk '{print $2}'"
date_cmd = "dmidecode --type 0 | grep Date | awk '{print $3}'"
version_cmd = "dmidecode --type 0 | grep Version | awk '{print $2}'"
error.context("getting smbios table on host")
host_vendor = utils.system_output(vendor_cmd)
host_date = utils.system_output(date_cmd)
host_version = utils.system_output(version_cmd)
smbios = (" -smbios type=0,vendor=%s,version=%s,date=%s" %
(host_vendor, host_version, host_date))
extra_params = params.get("extra_params", "")
params["extra_params"] = extra_params + smbios
logging.debug("Booting guest %s", params.get("main_vm"))
virt_env_process.preprocess_vm(test, params, env, params.get("main_vm"))
vm = env.get_vm(params["main_vm"])
vm.create()
login_timeout = float(params.get("login_timeout", 360))
session = vm.wait_for_login(timeout=login_timeout)
error.context("getting smbios table on guest")
guest_vendor = session.cmd(vendor_cmd).strip()
guest_date = session.cmd(date_cmd).strip()
guest_version = session.cmd(version_cmd).strip()
failures = []
if host_vendor != guest_vendor:
e_msg = ("Vendor str mismatch -> host: %s guest: %s" %
(guest_vendor, host_vendor))
logging.error(e_msg)
failures.append(e_msg)
if host_date != guest_date:
e_msg = ("Date str mismatch -> host: %s guest: %s" %
(guest_date, host_date))
logging.error(e_msg)
failures.append(e_msg)
if host_version != guest_version:
e_msg = ("Version str mismatch -> host: %s guest: %s" %
(guest_version, host_version))
logging.error(e_msg)
failures.append(e_msg)
error.context("")
if failures:
raise error.TestFail("smbios table test reported %s failures:\n%s" %
(len(failures), "\n".join(failures)))
# Associate pidfile name
params['pid_' + vm_name] = virt_utils.generate_tmp_file_name(
vm_name, 'pid')
if not params.get('extra_params'):
params['extra_params'] = ' '
params['extra_params_' + vm_name] = params.get('extra_params')
params['extra_params_' + vm_name] += (" -pidfile %s" %
(params.get('pid_' + vm_name)))
params['extra_params'] = params.get('extra_params_' + vm_name)
# ksm_size: amount of memory used by allocator
ksm_size = mem - guest_reserve
logging.debug("Memory used by allocator on guests = %dM", ksm_size)
# Creating the first guest
virt_env_process.preprocess_vm(test, params, env, vm_name)
lvms.append(env.get_vm(vm_name))
if not lvms[0]:
raise error.TestError("VM object not found in environment")
if not lvms[0].is_alive():
raise error.TestError("VM seems to be dead; Test requires a living "
"VM")
logging.debug("Booting first guest %s", lvms[0].name)
lsessions.append(lvms[0].wait_for_login(timeout=360))
# Associate vm PID
try:
tmp = open(params.get('pid_' + vm_name), 'r')
params['pid_' + vm_name] = int(tmp.readline())
except Exception:
def commit_test(cmd):
"""
Subcommand 'qemu-img commit' test.
1) Create a backing file of the qemu harddisk specified by image_name.
2) Start a VM using the backing file as its harddisk.
3) Touch a file "commit_testfile" in the backing_file, and shutdown the
VM.
4) Make sure touching the file does not affect the original harddisk.
5) Commit the change to the original harddisk by executing
"qemu-img commit" command.
6) Start the VM using the original harddisk.
7) Check if the file "commit_testfile" exists.
@param cmd: qemu-img base command.
"""
cmd += " commit"
logging.info("Commit testing started!")
image_name = params.get("image_name", "image")
image_format = params.get("image_format", "qcow2")
backing_file_name = "%s_bak" % (image_name)
try:
# Remove the existing backing file
backing_file = "%s.%s" % (backing_file_name, image_format)
if os.path.isfile(backing_file):
os.remove(backing_file)
# Create the new backing file
create_cmd = "qemu-img create -b %s.%s -f %s %s.%s" % (image_name,
image_format,
image_format,
backing_file_name,
image_format)
try:
utils.system(create_cmd)
except error.CmdError, e:
raise error.TestFail("Could not create a backing file!")
logging.info("backing_file created!")
# Set the qemu harddisk to the backing file
logging.info("Original image_name is: %s", params.get('image_name'))
params['image_name'] = backing_file_name
logging.info("Param image_name changed to: %s",
params.get('image_name'))
# Start a new VM, using backing file as its harddisk
vm_name = params.get('main_vm')
virt_env_process.preprocess_vm(test, params, env, vm_name)
vm = env.get_vm(vm_name)
vm.create()
timeout = int(params.get("login_timeout", 360))
session = vm.wait_for_login(timeout=timeout)
# Do some changes to the backing_file harddisk
try:
output = session.cmd("touch /commit_testfile")
logging.info("Output of touch /commit_testfile: %s", output)
output = session.cmd("ls / | grep commit_testfile")
logging.info("Output of ls / | grep commit_testfile: %s",
output)
except Exception, e:
raise error.TestFail("Could not create commit_testfile in the "
"backing file %s", e)
def commit_test(cmd):
"""
Subcommand 'qemu-img commit' test.
1) Create a backing file of the qemu harddisk specified by image_name.
2) Start a VM using the backing file as its harddisk.
3) Touch a file "commit_testfile" in the backing_file, and shutdown the
VM.
4) Make sure touching the file does not affect the original harddisk.
5) Commit the change to the original harddisk by executing
"qemu-img commit" command.
6) Start the VM using the original harddisk.
7) Check if the file "commit_testfile" exists.
@param cmd: qemu-img base command.
"""
cmd += " commit"
logging.info("Commit testing started!")
image_name = params.get("image_name", "image")
image_format = params.get("image_format", "qcow2")
backing_file_name = "%s_bak" % (image_name)
try:
# Remove the existing backing file
backing_file = "%s.%s" % (backing_file_name, image_format)
if os.path.isfile(backing_file):
os.remove(backing_file)
# Create the new backing file
create_cmd = "qemu-img create -b %s.%s -f %s %s.%s" % (
image_name, image_format, image_format, backing_file_name,
image_format)
try:
utils.system(create_cmd)
except error.CmdError, e:
raise error.TestFail("Could not create a backing file!")
logging.info("backing_file created!")
# Set the qemu harddisk to the backing file
logging.info("Original image_name is: %s",
params.get('image_name'))
params['image_name'] = backing_file_name
logging.info("Param image_name changed to: %s",
params.get('image_name'))
# Start a new VM, using backing file as its harddisk
vm_name = params.get('main_vm')
virt_env_process.preprocess_vm(test, params, env, vm_name)
vm = env.get_vm(vm_name)
vm.create()
timeout = int(params.get("login_timeout", 360))
session = vm.wait_for_login(timeout=timeout)
# Do some changes to the backing_file harddisk
try:
output = session.cmd("touch /commit_testfile")
logging.info("Output of touch /commit_testfile: %s", output)
output = session.cmd("ls / | grep commit_testfile")
logging.info("Output of ls / | grep commit_testfile: %s",
output)
except Exception, e:
raise error.TestFail(
"Could not create commit_testfile in the "
"backing file %s", e)
def run_unittest(test, params, env):
"""
KVM RHEL-6 style unit test:
1) Resume a stopped VM
2) Wait for VM to terminate
3) If qemu exited with code = 0, the unittest passed. Otherwise, it failed
4) Collect all logs generated
@param test: kvm test object
@param params: Dictionary with the test parameters
@param env: Dictionary with test environment
"""
unittest_dir = os.path.join(test.bindir, 'unittests')
if not os.path.isdir(unittest_dir):
raise error.TestError("No unittest dir %s available (did you run the "
"build test first?)" % unittest_dir)
os.chdir(unittest_dir)
unittest_list = glob.glob('*.flat')
if not unittest_list:
raise error.TestError("No unittest files available (did you run the "
"build test first?)")
logging.debug('Flat file list: %s', unittest_list)
unittest_cfg = os.path.join(unittest_dir, 'unittests.cfg')
parser = ConfigParser.ConfigParser()
parser.read(unittest_cfg)
test_list = parser.sections()
if not test_list:
raise error.TestError("No tests listed on config file %s" %
unittest_cfg)
logging.debug('Unit test list: %s', test_list)
if params.get('test_list'):
test_list = params.get('test_list').split()
logging.info('Original test list overriden by user')
logging.info('User defined unit test list: %s', test_list)
nfail = 0
tests_failed = []
timeout = int(params.get('unittest_timeout', 600))
extra_params_original = params['extra_params']
for t in test_list:
logging.info('Running %s', t)
flat_file = None
if parser.has_option(t, 'file'):
flat_file = parser.get(t, 'file')
if flat_file is None:
nfail += 1
tests_failed.append(t)
logging.error(
'Unittest config file %s has section %s but no '
'mandatory option file', unittest_cfg, t)
continue
if flat_file not in unittest_list:
nfail += 1
tests_failed.append(t)
logging.error(
'Unittest file %s referenced in config file %s but '
'was not find under the unittest dir', flat_file, unittest_cfg)
continue
smp = None
if parser.has_option(t, 'smp'):
smp = int(parser.get(t, 'smp'))
params['smp'] = smp
extra_params = None
if parser.has_option(t, 'extra_params'):
extra_params = parser.get(t, 'extra_params')
params['extra_params'] += ' %s' % extra_params
vm_name = params.get("main_vm")
params['kernel'] = os.path.join(unittest_dir, flat_file)
testlog_path = os.path.join(test.debugdir, "%s.log" % t)
try:
try:
vm_name = params.get('main_vm')
virt_env_process.preprocess_vm(test, params, env, vm_name)
vm = env.get_vm(vm_name)
vm.create()
vm.monitor.cmd("cont")
logging.info(
"Waiting for unittest %s to complete, timeout %s, "
"output in %s", t, timeout, vm.get_testlog_filename())
if not virt_utils.wait_for(vm.is_dead, timeout):
raise error.TestFail("Timeout elapsed (%ss)" % timeout)
# Check qemu's exit status
status = vm.process.get_status()
if status != 0:
nfail += 1
tests_failed.append(t)
logging.error("Unit test %s failed", t)
except Exception, e:
nfail += 1
tests_failed.append(t)
logging.error('Exception happened during %s: %s', t, str(e))
finally:
try:
shutil.copy(vm.get_testlog_filename(), testlog_path)
logging.info("Unit test log collected and available under %s",
testlog_path)
except (NameError, IOError):
logging.error("Not possible to collect logs")
# Restore the extra params so other tests can run normally
params['extra_params'] = extra_params_original
if nfail != 0:
raise error.TestFail("Unit tests failed: %s" % " ".join(tests_failed))
def run_unittest(test, params, env):
"""
KVM RHEL-6 style unit test:
1) Resume a stopped VM
2) Wait for VM to terminate
3) If qemu exited with code = 0, the unittest passed. Otherwise, it failed
4) Collect all logs generated
@param test: kvm test object
@param params: Dictionary with the test parameters
@param env: Dictionary with test environment
"""
unittest_dir = os.path.join(test.bindir, 'unittests')
if not os.path.isdir(unittest_dir):
raise error.TestError("No unittest dir %s available (did you run the "
"build test first?)" % unittest_dir)
os.chdir(unittest_dir)
unittest_list = glob.glob('*.flat')
if not unittest_list:
raise error.TestError("No unittest files available (did you run the "
"build test first?)")
logging.debug('Flat file list: %s', unittest_list)
unittest_cfg = os.path.join(unittest_dir, 'unittests.cfg')
parser = ConfigParser.ConfigParser()
parser.read(unittest_cfg)
test_list = parser.sections()
if not test_list:
raise error.TestError("No tests listed on config file %s" %
unittest_cfg)
logging.debug('Unit test list: %s', test_list)
if params.get('test_list'):
test_list = params.get('test_list').split()
logging.info('Original test list overriden by user')
logging.info('User defined unit test list: %s', test_list)
nfail = 0
tests_failed = []
timeout = int(params.get('unittest_timeout', 600))
extra_params_original = params['extra_params']
for t in test_list:
logging.info('Running %s', t)
flat_file = None
if parser.has_option(t, 'file'):
flat_file = parser.get(t, 'file')
if flat_file is None:
nfail += 1
tests_failed.append(t)
logging.error('Unittest config file %s has section %s but no '
'mandatory option file', unittest_cfg, t)
continue
if flat_file not in unittest_list:
nfail += 1
tests_failed.append(t)
logging.error('Unittest file %s referenced in config file %s but '
'was not find under the unittest dir', flat_file,
unittest_cfg)
continue
smp = None
if parser.has_option(t, 'smp'):
smp = int(parser.get(t, 'smp'))
params['smp'] = smp
extra_params = None
if parser.has_option(t, 'extra_params'):
extra_params = parser.get(t, 'extra_params')
params['extra_params'] += ' %s' % extra_params
vm_name = params.get("main_vm")
params['kernel'] = os.path.join(unittest_dir, flat_file)
testlog_path = os.path.join(test.debugdir, "%s.log" % t)
try:
try:
vm_name = params.get('main_vm')
virt_env_process.preprocess_vm(test, params, env, vm_name)
vm = env.get_vm(vm_name)
vm.create()
vm.monitor.cmd("cont")
logging.info("Waiting for unittest %s to complete, timeout %s, "
"output in %s", t, timeout,
vm.get_testlog_filename())
if not virt_utils.wait_for(vm.is_dead, timeout):
raise error.TestFail("Timeout elapsed (%ss)" % timeout)
# Check qemu's exit status
status = vm.process.get_status()
if status != 0:
nfail += 1
tests_failed.append(t)
logging.error("Unit test %s failed", t)
except Exception, e:
nfail += 1
tests_failed.append(t)
logging.error('Exception happened during %s: %s', t, str(e))
finally:
try:
shutil.copy(vm.get_testlog_filename(), testlog_path)
logging.info("Unit test log collected and available under %s",
testlog_path)
except (NameError, IOError):
logging.error("Not possible to collect logs")
# Restore the extra params so other tests can run normally
params['extra_params'] = extra_params_original
if nfail != 0:
raise error.TestFail("Unit tests failed: %s" % " ".join(tests_failed))