def run_boot(test, params, env):
"""
KVM reboot test:
1) Log into a guest
2) Send a reboot command or a system_reset monitor command (optional)
3) Wait until the guest is up again
4) Log into the guest to verify it's up again
@param test: kvm test object
@param params: Dictionary with the test parameters
@param env: Dictionary with test environment.
"""
vm = kvm_test_utils.get_living_vm(env, params.get("main_vm"))
timeout = float(params.get("login_timeout", 240))
session = kvm_test_utils.wait_for_login(vm, 0, timeout, 0, 2)
try:
if not params.get("reboot_method"):
return
# Reboot the VM
session = kvm_test_utils.reboot(vm, session,
params.get("reboot_method"),
float(params.get("sleep_before_reset", 10)),
0, timeout)
finally:
session.close()
def fuzz(session, inst_list):
"""
Executes a series of read/write/randwrite instructions.
If the guest SSH session hangs, an attempt to relogin will be made.
If it fails, the guest will be reset. If during the process the VM
process abnormally ends, the test fails.
@param inst_list: List of instructions that will be executed.
@raise error.TestFail: If the VM process dies in the middle of the
fuzzing procedure.
"""
for (op, operand) in inst_list:
if op == "read":
inb(session, operand[0])
elif op =="write":
outb(session, operand[0], operand[1])
else:
raise error.TestError("Unknown command %s" % op)
if not session.is_responsive():
logging.debug("Session is not responsive")
if vm.process.is_alive():
logging.debug("VM is alive, try to re-login")
try:
session = kvm_test_utils.wait_for_login(vm, 0, 10, 0, 2)
except:
logging.debug("Could not re-login, reboot the guest")
session = kvm_test_utils.reboot(vm, session,
method = "system_reset")
else:
raise error.TestFail("VM has quit abnormally during %s",
(op, operand))
def run_timedrift_with_reboot(test, params, env):
"""
Time drift test with reboot:
1) Log into a guest.
2) Take a time reading from the guest and host.
3) Reboot the guest.
4) Take a second time reading.
5) If the drift (in seconds) is higher than a user specified value, fail.
@param test: KVM test object.
@param params: Dictionary with test parameters.
@param env: Dictionary with the test environment.
"""
vm = kvm_test_utils.get_living_vm(env, params.get("main_vm"))
timeout = int(params.get("login_timeout", 360))
session = kvm_test_utils.wait_for_login(vm, timeout=timeout)
# Collect test parameters:
# Command to run to get the current time
time_command = params.get("time_command")
# Filter which should match a string to be passed to time.strptime()
time_filter_re = params.get("time_filter_re")
# Time format for time.strptime()
time_format = params.get("time_format")
drift_threshold = float(params.get("drift_threshold", "10"))
drift_threshold_single = float(params.get("drift_threshold_single", "3"))
reboot_iterations = int(params.get("reboot_iterations", 1))
try:
# Get initial time
# (ht stands for host time, gt stands for guest time)
(ht0, gt0) = kvm_test_utils.get_time(session, time_command,
time_filter_re, time_format)
# Reboot
for i in range(reboot_iterations):
# Get time before current iteration
(ht0_, gt0_) = kvm_test_utils.get_time(session, time_command,
time_filter_re, time_format)
# Run current iteration
logging.info("Rebooting: iteration %d of %d..." %
(i + 1, reboot_iterations))
session = kvm_test_utils.reboot(vm, session)
# Get time after current iteration
(ht1_, gt1_) = kvm_test_utils.get_time(session, time_command,
time_filter_re, time_format)
# Report iteration results
host_delta = ht1_ - ht0_
guest_delta = gt1_ - gt0_
drift = abs(host_delta - guest_delta)
logging.info("Host duration (iteration %d): %.2f" %
(i + 1, host_delta))
logging.info("Guest duration (iteration %d): %.2f" %
(i + 1, guest_delta))
logging.info("Drift at iteration %d: %.2f seconds" %
(i + 1, drift))
# Fail if necessary
if drift > drift_threshold_single:
raise error.TestFail("Time drift too large at iteration %d: "
"%.2f seconds" % (i + 1, drift))
# Get final time
(ht1, gt1) = kvm_test_utils.get_time(session, time_command,
time_filter_re, time_format)
finally:
if session:
session.close()
# Report results
host_delta = ht1 - ht0
guest_delta = gt1 - gt0
drift = abs(host_delta - guest_delta)
logging.info("Host duration (%d reboots): %.2f" %
(reboot_iterations, host_delta))
logging.info("Guest duration (%d reboots): %.2f" %
(reboot_iterations, guest_delta))
logging.info("Drift after %d reboots: %.2f seconds" %
(reboot_iterations, drift))
# Fail if necessary
if drift > drift_threshold:
raise error.TestFail("Time drift too large after %d reboots: "
"%.2f seconds" % (reboot_iterations, drift))
def run_kdump(test, params, env):
"""
KVM reboot test:
1) Log into a guest
2) Check and enable the kdump
3) For each vcpu, trigger a crash and check the vmcore
@param test: kvm test object
@param params: Dictionary with the test parameters
@param env: Dictionary with test environment.
"""
vm = kvm_test_utils.get_living_vm(env, params.get("main_vm"))
timeout = float(params.get("login_timeout", 240))
crash_timeout = float(params.get("crash_timeout", 360))
session = kvm_test_utils.wait_for_login(vm, 0, timeout, 0, 2)
def_kernel_param_cmd = ("grubby --update-kernel=`grubby --default-kernel`"
" --args=crashkernel=128M")
kernel_param_cmd = params.get("kernel_param_cmd", def_kernel_param_cmd)
def_kdump_enable_cmd = "chkconfig kdump on && service kdump start"
kdump_enable_cmd = params.get("kdump_enable_cmd", def_kdump_enable_cmd)
def_crash_kernel_prob_cmd = "grep -q 1 /sys/kernel/kexec_crash_loaded"
crash_kernel_prob_cmd = params.get("crash_kernel_prob_cmd",
def_crash_kernel_prob_cmd)
def crash_test(vcpu):
"""
Trigger a crash dump through sysrq-trigger
@param vcpu: vcpu which is used to trigger a crash
"""
session = kvm_test_utils.wait_for_login(vm, 0, timeout, 0, 2)
session.cmd_output("rm -rf /var/crash/*")
logging.info("Triggering crash on vcpu %d ...", vcpu)
crash_cmd = "taskset -c %d echo c > /proc/sysrq-trigger" % vcpu
session.sendline(crash_cmd)
if not kvm_utils.wait_for(lambda: not session.is_responsive(), 240, 0,
1):
raise error.TestFail("Could not trigger crash on vcpu %d" % vcpu)
logging.info("Waiting for kernel crash dump to complete")
session = kvm_test_utils.wait_for_login(vm, 0, crash_timeout, 0, 2)
logging.info("Probing vmcore file...")
session.cmd("ls -R /var/crash | grep vmcore")
logging.info("Found vmcore.")
session.cmd_output("rm -rf /var/crash/*")
try:
logging.info("Checking the existence of crash kernel...")
try:
session.cmd(crash_kernel_prob_cmd)
except:
logging.info("Crash kernel is not loaded. Trying to load it")
session.cmd(kernel_param_cmd)
session = kvm_test_utils.reboot(vm, session, timeout=timeout)
logging.info("Enabling kdump service...")
# the initrd may be rebuilt here so we need to wait a little more
session.cmd(kdump_enable_cmd, timeout=120)
nvcpu = int(params.get("smp", 1))
for i in range (nvcpu):
crash_test(i)
finally:
session.close()
def clean_ports(vm, consoles):
"""
Clean state of all ports and set port to default state.
Default state:
No data on port or in port buffer.
Read mode = blocking.
@param consoles: Consoles which should be clean.
"""
# Check if python is still alive
print "CLEANED"
match, tmp = _on_guest("is_alive()", vm, 10)
if (match == None) or (match != 0):
logging.error("Python died/is stucked/have remaining threads")
logging.debug(tmp)
vm[1].close()
vm[1] = kvm_test_utils.wait_for_login(vm[0], 0,
float(params.get("boot_timeout", 240)),
0, 2)
(match, data) = _on_guest("killall -9 python "
"&& echo -n PASS: python killed"
"|| echo -n PASS: python was death",
vm, 30)
if (match == None):
# killall -9 command didn't finished - python stucked
raise error.TestFail("Python is really stucked - "
"can't kill -9 it")
#on_guest("rmmod -f virtio_console && echo -n PASS: rmmod "
# "|| echo -n FAIL: rmmod", vm, 10)
#on_guest("modprobe virtio_console "
# "&& echo -n PASS: modprobe || echo -n FAIL: modprobe",
# vm, 10)
init_guest(vm, consoles)
(match, data) = _on_guest("virt.clean_port('%s'),1024" %
consoles[0][0].name, vm, 2)
if (match == None) or (match != 0):
logging.error(data)
logging.error("Virtio-console driver is irreparably"
" blocked. Every comd end with sig KILL."
"Try reboot vm for continue in testing.")
vm[1] = kvm_test_utils.reboot(vm[0], vm[1], "system_reset")
init_guest(vm, consoles)
(match, data) = _on_guest("virt.clean_port('%s'),1024" %
consoles[0][0].name, vm, 2)
if (match == None) or (match != 0):
raise error.TestFail("Virtio-console driver is irreparably"
" blocked. Every comd end with sig"
" KILL. Neither the restart did not"
" help.")
else:
on_guest("virt.close('%s'),1024" % consoles[0][0].name, vm, 2)
for ctype in consoles:
for port in ctype:
openned = port.is_open
port.clean_port()
#on_guest("virt.blocking('%s', True)" % port.name, vm, 2)
on_guest("virt.clean_port('%s'),1024" % port.name, vm, 2)
if not openned:
port.close()
on_guest("virt.close('%s'),1024" % port.name, vm, 2)
def run_whql_client_install(test, params, env):
"""
WHQL DTM client installation:
1) Log into the guest (the client machine) and into a DTM server machine
2) Stop the DTM client service (wttsvc) on the client machine
3) Delete the client machine from the server's data store
4) Rename the client machine (give it a randomly generated name)
5) Move the client machine into the server's workgroup
6) Reboot the client machine
7) Install the DTM client software
@param test: kvm test object
@param params: Dictionary with the test parameters
@param env: Dictionary with test environment.
"""
vm = kvm_test_utils.get_living_vm(env, params.get("main_vm"))
session = kvm_test_utils.wait_for_login(vm, 0, 240)
# Collect test params
server_address = params.get("server_address")
server_shell_port = int(params.get("server_shell_port"))
server_file_transfer_port = int(params.get("server_file_transfer_port"))
server_studio_path = params.get("server_studio_path", "%programfiles%\\ "
"Microsoft Driver Test Manager\\Studio")
server_username = params.get("server_username")
server_password = params.get("server_password")
dsso_delete_machine_binary = params.get("dsso_delete_machine_binary",
"deps/whql_delete_machine_15.exe")
dsso_delete_machine_binary = kvm_utils.get_path(test.bindir,
dsso_delete_machine_binary)
install_timeout = float(params.get("install_timeout", 600))
install_cmd = params.get("install_cmd")
wtt_services = params.get("wtt_services")
# Stop WTT service(s) on client
for svc in wtt_services.split():
kvm_test_utils.stop_windows_service(session, svc)
# Copy dsso_delete_machine_binary to server
rss_file_transfer.upload(server_address, server_file_transfer_port,
dsso_delete_machine_binary, server_studio_path,
timeout=60)
# Open a shell session with server
server_session = kvm_utils.remote_login("nc", server_address,
server_shell_port, "", "",
session.prompt, session.linesep)
server_session.set_status_test_command(session.status_test_command)
# Get server and client information
cmd = "echo %computername%"
server_name = server_session.cmd_output(cmd).strip()
client_name = session.cmd_output(cmd).strip()
cmd = "wmic computersystem get domain"
server_workgroup = server_session.cmd_output(cmd).strip()
server_workgroup = server_workgroup.splitlines()[-1]
regkey = r"HKLM\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters"
cmd = "reg query %s /v Domain" % regkey
o = server_session.cmd_output(cmd).strip().splitlines()[-1]
try:
server_dns_suffix = o.split(None, 2)[2]
except IndexError:
server_dns_suffix = ""
# Delete the client machine from the server's data store (if it's there)
server_session.cmd("cd %s" % server_studio_path)
cmd = "%s %s %s" % (os.path.basename(dsso_delete_machine_binary),
server_name, client_name)
server_session.cmd(cmd, print_func=logging.info)
server_session.close()
# Rename the client machine
client_name = "autotest_%s" % kvm_utils.generate_random_string(4)
logging.info("Renaming client machine to '%s'" % client_name)
cmd = ('wmic computersystem where name="%%computername%%" rename name="%s"'
% client_name)
session.cmd(cmd, timeout=600)
# Join the server's workgroup
logging.info("Joining workgroup '%s'" % server_workgroup)
cmd = ('wmic computersystem where name="%%computername%%" call '
'joindomainorworkgroup name="%s"' % server_workgroup)
session.cmd(cmd, timeout=600)
# Set the client machine's DNS suffix
logging.info("Setting DNS suffix to '%s'" % server_dns_suffix)
cmd = 'reg add %s /v Domain /d "%s" /f' % (regkey, server_dns_suffix)
session.cmd(cmd, timeout=300)
# Reboot
session = kvm_test_utils.reboot(vm, session)
# Access shared resources on the server machine
logging.info("Attempting to access remote share on server")
cmd = r"net use \\%s /user:%s %s" % (server_name, server_username,
server_password)
end_time = time.time() + 120
while time.time() < end_time:
try:
session.cmd(cmd)
break
except:
pass
time.sleep(5)
else:
raise error.TestError("Could not access server share from client "
"machine")
# Install
logging.info("Installing DTM client (timeout=%ds)", install_timeout)
install_cmd = r"cmd /c \\%s\%s" % (server_name, install_cmd.lstrip("\\"))
session.cmd(install_cmd, timeout=install_timeout)
session.close()
def run_guest_test(test, params, env):
"""
A wrapper for running customized tests in guests.
1) Log into a guest.
2) Run script.
3) Wait for script execution to complete.
4) Pass/fail according to exit status of script.
@param test: KVM test object.
@param params: Dictionary with test parameters.
@param env: Dictionary with the test environment.
"""
login_timeout = int(params.get("login_timeout", 360))
reboot = params.get("reboot", "no")
vm = kvm_test_utils.get_living_vm(env, params.get("main_vm"))
serial_login = (params.get("serial_login", "no") == "yes")
session = kvm_test_utils.wait_for_login(vm, timeout=login_timeout,
serial=serial_login)
if reboot == "yes":
logging.debug("Rebooting guest before test ...")
session = kvm_test_utils.reboot(vm, session, timeout=login_timeout)
try:
logging.info("Starting script...")
# Collect test parameters
interpreter = params.get("interpreter")
script = params.get("guest_script")
dst_rsc_path = params.get("dst_rsc_path", "script.au3")
script_params = params.get("script_params", "")
test_timeout = float(params.get("test_timeout", 600))
logging.debug("Starting preparing resouce files...")
# Download the script resource from a remote server, or
# prepare the script using rss?
if params.get("download") == "yes":
download_cmd = params.get("download_cmd")
rsc_server = params.get("rsc_server")
rsc_dir = os.path.basename(rsc_server)
dst_rsc_dir = params.get("dst_rsc_dir")
# Change dir to dst_rsc_dir, and remove the guest script dir there
rm_cmd = "cd %s && (rmdir /s /q %s || del /s /q %s)" % \
(dst_rsc_dir, rsc_dir, rsc_dir)
session.cmd(rm_cmd, timeout=test_timeout)
logging.debug("Clean directory succeeded.")
# then download the resource.
rsc_cmd = "cd %s && %s %s" %(dst_rsc_dir, download_cmd, rsc_server)
session.cmd(rsc_cmd, timeout=test_timeout)
logging.info("Download resource finished.")
else:
session.cmd_output("del %s" % dst_rsc_path, internal_timeout=0)
script_path = kvm_utils.get_path(test.bindir, script)
vm.copy_files_to(script_path, dst_rsc_path, timeout=60)
cmd = "%s %s %s" % (interpreter, dst_rsc_path, script_params)
try:
logging.info("------------ Script output ------------")
session.cmd(cmd, print_func=logging.info, timeout=test_timeout)
finally:
logging.info("------------ End of script output ------------")
if reboot == "yes":
logging.debug("Rebooting guest after test ...")
session = kvm_test_utils.reboot(vm, session, timeout=login_timeout)
logging.debug("guest test PASSED.")
finally:
session.close()
