def receiver():
""" Receive side """
logging.info("Starting receiver process on %s", receiver_addr)
if vm_receiver:
session = vm_receiver.wait_for_login(timeout=login_timeout)
else:
username = params.get("username", "")
password = params.get("password", "")
prompt = params.get("shell_prompt", "[\#\$]")
linesep = eval("'%s'" % params.get("shell_linesep", r"\n"))
client = params.get("shell_client")
port = int(params.get("shell_port"))
log_filename = ("session-%s-%s.log" % (receiver_addr,
utils_misc.generate_random_string(4)))
session = remote.remote_login(client, receiver_addr, port,
username, password, prompt,
linesep, log_filename, timeout)
session.set_status_test_command("echo %errorlevel%")
install_ntttcp(session)
ntttcp_receiver_cmd = params.get("ntttcp_receiver_cmd")
global _receiver_ready
f = open(results_path + ".receiver", 'a')
for b in buffers:
utils_misc.wait_for(lambda: not _wait(), timeout)
_receiver_ready = True
rbuf = params.get("fixed_rbuf", b)
cmd = ntttcp_receiver_cmd % (session_num, receiver_addr, rbuf, buf_num)
r = session.cmd_output(cmd, timeout=timeout,
print_func=logging.debug)
f.write("Send buffer size: %s\n%s\n%s" % (b, cmd, r))
f.close()
session.close()
def receiver():
""" Receive side """
logging.info("Starting receiver process on %s", receiver_addr)
if vm_receiver:
session = vm_receiver.wait_for_login(timeout=login_timeout)
else:
username = params.get("username", "")
password = params.get("password", "")
prompt = params.get("shell_prompt", "[\#\$]")
linesep = eval("'%s'" % params.get("shell_linesep", r"\n"))
client = params.get("shell_client")
port = int(params.get("shell_port"))
log_filename = ("session-%s-%s.log" % (receiver_addr,
utils_misc.generate_random_string(4)))
session = remote.remote_login(client, receiver_addr, port,
username, password, prompt,
linesep, log_filename, timeout)
session.set_status_test_command("echo %errorlevel%")
install_ntttcp(session)
ntttcp_receiver_cmd = params.get("ntttcp_receiver_cmd")
global _receiver_ready
f = open(results_path + ".receiver", 'a')
for b in buffers:
utils_misc.wait_for(lambda: not _wait(), timeout)
_receiver_ready = True
rbuf = params.get("fixed_rbuf", b)
cmd = ntttcp_receiver_cmd % (session_num, receiver_addr, rbuf, buf_num)
r = session.cmd_output(cmd, timeout=timeout,
print_func=logging.debug)
f.write("Send buffer size: %s\n%s\n%s" % (b, cmd, r))
f.close()
session.close()
def crash_test(vcpu):
"""
Trigger a crash dump through sysrq-trigger
@param vcpu: vcpu which is used to trigger a crash
"""
session = vm.wait_for_login(timeout=timeout)
session.cmd_output("rm -rf /var/crash/*")
if crash_cmd == "nmi":
session.cmd("echo 1 > /proc/sys/kernel/unknown_nmi_panic")
vm.monitor.cmd('nmi')
else:
logging.info("Triggering crash on vcpu %d ...", vcpu)
session.sendline("taskset -c %d %s" % (vcpu, crash_cmd))
if not utils_misc.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 = vm.wait_for_login(timeout=crash_timeout)
logging.info("Probing vmcore file...")
session.cmd("ls -R /var/crash | grep vmcore")
logging.info("Found vmcore.")
session.cmd_output("rm -rf /var/crash/*")
def crash_test(vcpu):
"""
Trigger a crash dump through sysrq-trigger
@param vcpu: vcpu which is used to trigger a crash
"""
session = vm.wait_for_login(timeout=timeout)
session.cmd_output("rm -rf /var/crash/*")
if crash_cmd == "nmi":
session.cmd("echo 1 > /proc/sys/kernel/unknown_nmi_panic")
vm.monitor.cmd('nmi')
else:
logging.info("Triggering crash on vcpu %d ...", vcpu)
session.sendline("taskset -c %d %s" % (vcpu, crash_cmd))
if not utils_misc.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 = vm.wait_for_login(timeout=crash_timeout)
logging.info("Probing vmcore file...")
session.cmd("ls -R /var/crash | grep vmcore")
logging.info("Found vmcore.")
session.cmd_output("rm -rf /var/crash/*")
def run_mac_change(test, params, env):
"""
Change MAC address of guest.
1) Get a new mac from pool, and the old mac addr of guest.
2) Set new mac in guest and regain new IP.
3) Re-log into guest with new MAC.
@param test: KVM test object.
@param params: Dictionary with the test parameters.
@param env: Dictionary with test environment.
"""
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
timeout = int(params.get("login_timeout", 360))
session_serial = vm.wait_for_serial_login(timeout=timeout)
# This session will be used to assess whether the IP change worked
session = vm.wait_for_login(timeout=timeout)
old_mac = vm.get_mac_address(0)
while True:
vm.virtnet.free_mac_address(0)
new_mac = vm.virtnet.generate_mac_address(0)
if old_mac != new_mac:
break
logging.info("The initial MAC address is %s", old_mac)
interface = utils_test.get_linux_ifname(session_serial, old_mac)
# Start change MAC address
logging.info("Changing MAC address to %s", new_mac)
change_cmd = ("ifconfig %s down && ifconfig %s hw ether %s && "
"ifconfig %s up" %
(interface, interface, new_mac, interface))
session_serial.cmd(change_cmd)
# Verify whether MAC address was changed to the new one
logging.info("Verifying the new mac address")
session_serial.cmd("ifconfig | grep -i %s" % new_mac)
# Restart `dhclient' to regain IP for new mac address
logging.info("Restart the network to gain new IP")
dhclient_cmd = "dhclient -r && dhclient %s" % interface
session_serial.sendline(dhclient_cmd)
# Re-log into the guest after changing mac address
if utils_misc.wait_for(session.is_responsive, 120, 20, 3):
# Just warning when failed to see the session become dead,
# because there is a little chance the ip does not change.
logging.warn("The session is still responsive, settings may fail.")
session.close()
# Re-log into guest and check if session is responsive
logging.info("Re-log into the guest")
session = vm.wait_for_login(timeout=timeout)
if not session.is_responsive():
raise error.TestFail("The new session is not responsive.")
session.close()
def run_mac_change(test, params, env):
"""
Change MAC address of guest.
1) Get a new mac from pool, and the old mac addr of guest.
2) Set new mac in guest and regain new IP.
3) Re-log into guest with new MAC.
@param test: KVM test object.
@param params: Dictionary with the test parameters.
@param env: Dictionary with test environment.
"""
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
timeout = int(params.get("login_timeout", 360))
session_serial = vm.wait_for_serial_login(timeout=timeout)
# This session will be used to assess whether the IP change worked
session = vm.wait_for_login(timeout=timeout)
old_mac = vm.get_mac_address(0)
while True:
vm.virtnet.free_mac_address(0)
new_mac = vm.virtnet.generate_mac_address(0)
if old_mac != new_mac:
break
logging.info("The initial MAC address is %s", old_mac)
interface = utils_test.get_linux_ifname(session_serial, old_mac)
# Start change MAC address
logging.info("Changing MAC address to %s", new_mac)
change_cmd = ("ifconfig %s down && ifconfig %s hw ether %s && "
"ifconfig %s up" % (interface, interface, new_mac, interface))
session_serial.cmd(change_cmd)
# Verify whether MAC address was changed to the new one
logging.info("Verifying the new mac address")
session_serial.cmd("ifconfig | grep -i %s" % new_mac)
# Restart `dhclient' to regain IP for new mac address
logging.info("Restart the network to gain new IP")
dhclient_cmd = "dhclient -r && dhclient %s" % interface
session_serial.sendline(dhclient_cmd)
# Re-log into the guest after changing mac address
if utils_misc.wait_for(session.is_responsive, 120, 20, 3):
# Just warning when failed to see the session become dead,
# because there is a little chance the ip does not change.
logging.warn("The session is still responsive, settings may fail.")
session.close()
# Re-log into guest and check if session is responsive
logging.info("Re-log into the guest")
session = vm.wait_for_login(timeout=timeout)
if not session.is_responsive():
raise error.TestFail("The new session is not responsive.")
session.close()
def sender():
""" Send side """
logging.info("Sarting sender process ...")
session = vm_sender.wait_for_login(timeout=login_timeout)
install_ntttcp(session)
ntttcp_sender_cmd = params.get("ntttcp_sender_cmd")
f = open(results_path + ".sender", 'a')
try:
global _receiver_ready
for b in buffers:
cmd = ntttcp_sender_cmd % (session_num, receiver_addr, b, buf_num)
# Wait until receiver ready
utils_misc.wait_for(_wait, timeout)
r = session.cmd_output(cmd, timeout=timeout,
print_func=logging.debug)
_receiver_ready = False
f.write("Send buffer size: %s\n%s\n%s" % (b, cmd, r))
finally:
f.close()
session.close()
def sender():
""" Send side """
logging.info("Sarting sender process ...")
session = vm_sender.wait_for_login(timeout=login_timeout)
install_ntttcp(session)
ntttcp_sender_cmd = params.get("ntttcp_sender_cmd")
f = open(results_path + ".sender", 'a')
try:
global _receiver_ready
for b in buffers:
cmd = ntttcp_sender_cmd % (session_num, receiver_addr, b, buf_num)
# Wait until receiver ready
utils_misc.wait_for(_wait, timeout)
r = session.cmd_output(cmd, timeout=timeout,
print_func=logging.debug)
_receiver_ready = False
f.write("Send buffer size: %s\n%s\n%s" % (b, cmd, r))
finally:
f.close()
session.close()
def run_seabios(test, params, env):
"""
KVM Seabios test:
1) Start guest with sga bios
2) Display and check the boot menu order
3) Start guest from the specified boot entry
4) Log into the guest to verify it's up
@param test: kvm test object
@param params: Dictionary with the test parameters
@param env: Dictionary with test environment.
"""
error.context("Start guest with sga bios")
vm = env.get_vm(params["main_vm"])
# Since the seabios is displayed in the beginning of guest boot,
# booting guest here so that we can check all of sgabios/seabios
# info, especially the correct time of sending boot menu key.
vm.create()
timeout = float(params.get("login_timeout", 240))
boot_menu_key = params.get("boot_menu_key", 'f12')
boot_menu_hint = params.get("boot_menu_hint")
boot_device = params.get("boot_device", "")
error.context("Display and check the boot menu order")
f = lambda: re.search(boot_menu_hint, vm.serial_console.get_output())
if not (boot_menu_hint and utils_misc.wait_for(f, timeout, 1)):
raise error.TestFail("Could not get boot menu message.")
# Send boot menu key in monitor.
vm.send_key(boot_menu_key)
_ = vm.serial_console.get_output()
boot_list = re.findall("^\d+\. (.*)\s", _, re.M)
if not boot_list:
raise error.TestFail("Could not get boot entries list.")
logging.info("Got boot menu entries: '%s'", boot_list)
for i, v in enumerate(boot_list, start=1):
if re.search(boot_device, v, re.I):
error.context("Start guest from boot entry '%s'" % v,
logging.info)
vm.send_key(str(i))
break
else:
raise error.TestFail("Could not get any boot entry match "
"pattern '%s'" % boot_device)
error.context("Log into the guest to verify it's up")
session = vm.wait_for_login(timeout=timeout)
session.close()
def run_seabios(test, params, env):
"""
KVM Seabios test:
1) Start guest with sga bios
2) Display and check the boot menu order
3) Start guest from the specified boot entry
4) Log into the guest to verify it's up
@param test: kvm test object
@param params: Dictionary with the test parameters
@param env: Dictionary with test environment.
"""
error.context("Start guest with sga bios")
vm = env.get_vm(params["main_vm"])
# Since the seabios is displayed in the beginning of guest boot,
# booting guest here so that we can check all of sgabios/seabios
# info, especially the correct time of sending boot menu key.
vm.create()
timeout = float(params.get("login_timeout", 240))
boot_menu_key = params.get("boot_menu_key", 'f12')
boot_menu_hint = params.get("boot_menu_hint")
boot_device = params.get("boot_device", "")
error.context("Display and check the boot menu order")
f = lambda: re.search(boot_menu_hint, vm.serial_console.get_output())
if not (boot_menu_hint and utils_misc.wait_for(f, timeout, 1)):
raise error.TestFail("Could not get boot menu message.")
# Send boot menu key in monitor.
vm.send_key(boot_menu_key)
_ = vm.serial_console.get_output()
boot_list = re.findall("^\d+\. (.*)\s", _, re.M)
if not boot_list:
raise error.TestFail("Could not get boot entries list.")
logging.info("Got boot menu entries: '%s'", boot_list)
for i, v in enumerate(boot_list, start=1):
if re.search(boot_device, v, re.I):
error.context("Start guest from boot entry '%s'" % v, logging.info)
vm.send_key(str(i))
break
else:
raise error.TestFail("Could not get any boot entry match "
"pattern '%s'" % boot_device)
error.context("Log into the guest to verify it's up")
session = vm.wait_for_login(timeout=timeout)
session.close()
def watchdog_action_reset():
"""
Trigger a crash dump through sysrq-trigger
Ensure watchdog_action(reset) occur.
"""
session = vm.wait_for_login(timeout=timeout)
logging.info("Triggering crash on vm")
crash_cmd = "echo c > /proc/sysrq-trigger"
session.sendline(crash_cmd)
if not utils_misc.wait_for(lambda: not session.is_responsive(),
240, 0, 1):
raise error.TestFail("Could not trigger crash")
logging.info("Waiting for kernel watchdog_action to take place")
session = vm.wait_for_login(timeout=relogin_timeout)
def pci_del(ignore_failure=False):
if cmd_type == "pci_add":
result_domain, bus, slot, _ = add_output.split(',')
domain = int(result_domain.split()[2])
bus = int(bus.split()[1])
slot = int(slot.split()[1])
pci_addr = "%x:%x:%x" % (domain, bus, slot)
cmd = "pci_del pci_addr=%s" % pci_addr
elif cmd_type == "device_add":
cmd = "device_del %s" % device_id
# This should be replaced by a proper monitor method call
vm.monitor.cmd(cmd)
def device_removed():
after_del = vm.monitor.info("pci")
return after_del != after_add
if (not utils_misc.wait_for(device_removed, 10, 0, 1)
and not ignore_failure):
raise error.TestFail("Failed to hot remove PCI device: %s. "
"Monitor command: %s" % (tested_model, cmd))
def pci_del(ignore_failure=False):
if cmd_type == "pci_add":
result_domain, bus, slot, function = add_output.split(',')
domain = int(result_domain.split()[2])
bus = int(bus.split()[1])
slot = int(slot.split()[1])
pci_addr = "%x:%x:%x" % (domain, bus, slot)
cmd = "pci_del pci_addr=%s" % pci_addr
elif cmd_type == "device_add":
cmd = "device_del %s" % device_id
# This should be replaced by a proper monitor method call
vm.monitor.cmd(cmd)
def device_removed():
after_del = vm.monitor.info("pci")
return after_del != after_add
if (not utils_misc.wait_for(device_removed, 10, 0, 1)
and not ignore_failure):
raise error.TestFail("Failed to hot remove PCI device: %s. "
"Monitor command: %s" %
(tested_model, cmd))
def run_shutdown(test, params, env):
"""
KVM shutdown test:
1) Log into a guest
2) Send a shutdown command to the guest, or issue a system_powerdown
monitor command (depending on the value of shutdown_method)
3) Wait until the guest is down
@param test: kvm test object
@param params: Dictionary with the test parameters
@param env: Dictionary with test environment
"""
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
timeout = int(params.get("login_timeout", 360))
session = vm.wait_for_login(timeout=timeout)
try:
error.base_context("shutting down the VM")
if params.get("shutdown_method") == "shell":
# Send a shutdown command to the guest's shell
session.sendline(vm.get_params().get("shutdown_command"))
error.context("waiting VM to go down (shutdown shell cmd)")
elif params.get("shutdown_method") == "system_powerdown":
# Sleep for a while -- give the guest a chance to finish booting
time.sleep(float(params.get("sleep_before_powerdown", 10)))
# Send a system_powerdown monitor command
vm.monitor.cmd("system_powerdown")
error.context("waiting VM to go down "
"(system_powerdown monitor cmd)")
if not utils_misc.wait_for(vm.is_dead, 240, 0, 1):
raise error.TestFail("Guest refuses to go down")
finally:
session.close()
global _unattended_server_thread
global _unattended_server_thread_event
if _unattended_server_thread is not None:
_unattended_server_thread_event.set()
_unattended_server_thread.join(3)
_unattended_server_thread = None
global _syslog_server_thread
global _syslog_server_thread_event
if _syslog_server_thread is not None:
_syslog_server_thread_event.set()
_syslog_server_thread.join(3)
_syslog_server_thread = None
time_elapsed = time.time() - start_time
logging.info("Guest reported successful installation after %d s (%d min)",
time_elapsed, time_elapsed / 60)
if params.get("shutdown_cleanly", "yes") == "yes":
shutdown_cleanly_timeout = int(
params.get("shutdown_cleanly_timeout", 120))
logging.info("Wait for guest to shutdown cleanly")
try:
if utils_misc.wait_for(vm.is_dead, shutdown_cleanly_timeout, 1, 1):
logging.info("Guest managed to shutdown cleanly")
except kvm_monitor.MonitorError, e:
logging.warning(
"Guest apparently shut down, but got a "
"monitor error: %s", e)
utils_disk.cleanup(unattended_install_config.cdrom_cd1_mount)
global _unattended_server_thread
global _unattended_server_thread_event
if _unattended_server_thread is not None:
_unattended_server_thread_event.set()
_unattended_server_thread.join(3)
_unattended_server_thread = None
global _syslog_server_thread
global _syslog_server_thread_event
if _syslog_server_thread is not None:
_syslog_server_thread_event.set()
_syslog_server_thread.join(3)
_syslog_server_thread = None
time_elapsed = time.time() - start_time
logging.info("Guest reported successful installation after %d s (%d min)",
time_elapsed, time_elapsed / 60)
if params.get("shutdown_cleanly", "yes") == "yes":
shutdown_cleanly_timeout = int(params.get("shutdown_cleanly_timeout",
120))
logging.info("Wait for guest to shutdown cleanly")
try:
if utils_misc.wait_for(vm.is_dead, shutdown_cleanly_timeout, 1, 1):
logging.info("Guest managed to shutdown cleanly")
except kvm_monitor.MonitorError, e:
logging.warning("Guest apparently shut down, but got a "
"monitor error: %s", e)
def run_pci_hotplug(test, params, env):
"""
Test hotplug of PCI devices.
(Elements between [] are configurable test parameters)
1) PCI add a deivce (NIC / block)
2) Compare output of monitor command 'info pci'.
3) Compare output of guest command [reference_cmd].
4) Verify whether pci_model is shown in [pci_find_cmd].
5) Check whether the newly added PCI device works fine.
6) PCI delete the device, verify whether could remove the PCI device.
@param test: KVM test object.
@param params: Dictionary with the test parameters.
@param env: Dictionary with test environment.
"""
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
timeout = int(params.get("login_timeout", 360))
session = vm.wait_for_login(timeout=timeout)
# Modprobe the module if specified in config file
module = params.get("modprobe_module")
if module:
session.cmd("modprobe %s" % module)
# Get output of command 'info pci' as reference
info_pci_ref = vm.monitor.info("pci")
# Get output of command as reference
reference = session.cmd_output(params.get("reference_cmd"))
tested_model = params.get("pci_model")
test_type = params.get("pci_type")
image_format = params.get("image_format_stg")
# Probe qemu to verify what is the supported syntax for PCI hotplug
cmd_output = vm.monitor.cmd("?")
if len(re.findall("\ndevice_add", cmd_output)) > 0:
cmd_type = "device_add"
elif len(re.findall("\npci_add", cmd_output)) > 0:
cmd_type = "pci_add"
else:
raise error.TestError("Unknow version of qemu")
# Determine syntax of drive hotplug
# __com.redhat_drive_add == qemu-kvm-0.12 on RHEL 6
if len(re.findall("\n__com.redhat_drive_add", cmd_output)) > 0:
drive_cmd_type = "__com.redhat_drive_add"
# drive_add == qemu-kvm-0.13 onwards
elif len(re.findall("\ndrive_add", cmd_output)) > 0:
drive_cmd_type = "drive_add"
else:
raise error.TestError("Unknow version of qemu")
# Probe qemu for a list of supported devices
devices_support = vm.monitor.cmd("%s ?" % cmd_type)
if cmd_type == "pci_add":
if test_type == "nic":
pci_add_cmd = "pci_add pci_addr=auto nic model=%s" % tested_model
elif test_type == "block":
image_params = params.object_params("stg")
image_filename = storage.get_image_filename(
image_params, test.bindir)
pci_add_cmd = ("pci_add pci_addr=auto storage file=%s,if=%s" %
(image_filename, tested_model))
# Execute pci_add (should be replaced by a proper monitor method call)
add_output = vm.monitor.cmd(pci_add_cmd)
if not "OK domain" in add_output:
raise error.TestFail("Add PCI device failed. "
"Monitor command is: %s, Output: %r" %
(pci_add_cmd, add_output))
after_add = vm.monitor.info("pci")
elif cmd_type == "device_add":
driver_id = test_type + "-" + utils_misc.generate_random_id()
device_id = test_type + "-" + utils_misc.generate_random_id()
if test_type == "nic":
if tested_model == "virtio":
tested_model = "virtio-net-pci"
pci_add_cmd = "device_add id=%s,driver=%s" % (device_id,
tested_model)
elif test_type == "block":
image_params = params.object_params("stg")
image_filename = storage.get_image_filename(
image_params, test.bindir)
controller_model = None
if tested_model == "virtio":
tested_model = "virtio-blk-pci"
if tested_model == "scsi":
tested_model = "scsi-disk"
controller_model = "lsi53c895a"
if len(re.findall(controller_model, devices_support)) == 0:
raise error.TestError("scsi controller device (%s) not "
"supported by qemu" %
controller_model)
if controller_model is not None:
controller_id = "controller-" + device_id
controller_add_cmd = ("device_add %s,id=%s" %
(controller_model, controller_id))
vm.monitor.cmd(controller_add_cmd)
if drive_cmd_type == "drive_add":
driver_add_cmd = ("drive_add auto "
"file=%s,if=none,id=%s,format=%s" %
(image_filename, driver_id, image_format))
elif drive_cmd_type == "__com.redhat_drive_add":
driver_add_cmd = ("__com.redhat_drive_add "
"file=%s,format=%s,id=%s" %
(image_filename, image_format, driver_id))
pci_add_cmd = ("device_add id=%s,driver=%s,drive=%s" %
(device_id, tested_model, driver_id))
vm.monitor.cmd(driver_add_cmd)
# Check if the device is support in qemu
if len(re.findall(tested_model, devices_support)) > 0:
add_output = vm.monitor.cmd(pci_add_cmd)
else:
raise error.TestError("%s doesn't support device: %s" %
(cmd_type, tested_model))
after_add = vm.monitor.info("pci")
if not device_id in after_add:
raise error.TestFail("Add device failed. Monitor command is: %s"
". Output: %r" % (pci_add_cmd, add_output))
# Define a helper function to delete the device
def pci_del(ignore_failure=False):
if cmd_type == "pci_add":
result_domain, bus, slot, _ = add_output.split(',')
domain = int(result_domain.split()[2])
bus = int(bus.split()[1])
slot = int(slot.split()[1])
pci_addr = "%x:%x:%x" % (domain, bus, slot)
cmd = "pci_del pci_addr=%s" % pci_addr
elif cmd_type == "device_add":
cmd = "device_del %s" % device_id
# This should be replaced by a proper monitor method call
vm.monitor.cmd(cmd)
def device_removed():
after_del = vm.monitor.info("pci")
return after_del != after_add
if (not utils_misc.wait_for(device_removed, 10, 0, 1)
and not ignore_failure):
raise error.TestFail("Failed to hot remove PCI device: %s. "
"Monitor command: %s" % (tested_model, cmd))
try:
# Compare the output of 'info pci'
if after_add == info_pci_ref:
raise error.TestFail("No new PCI device shown after executing "
"monitor command: 'info pci'")
# Define a helper function to compare the output
def new_shown():
o = session.cmd_output(params.get("reference_cmd"))
return o != reference
secs = int(params.get("wait_secs_for_hook_up"))
if not utils_misc.wait_for(new_shown, 30, secs, 3):
raise error.TestFail("No new device shown in output of command "
"executed inside the guest: %s" %
params.get("reference_cmd"))
# Define a helper function to catch PCI device string
def find_pci():
o = session.cmd_output(params.get("find_pci_cmd"))
return params.get("match_string") in o
if not utils_misc.wait_for(find_pci, 30, 3, 3):
raise error.TestFail(
"PCI %s %s device not found in guest. "
"Command was: %s" %
(tested_model, test_type, params.get("find_pci_cmd")))
# Test the newly added device
try:
session.cmd(params.get("pci_test_cmd"))
except aexpect.ShellError, e:
raise error.TestFail("Check for %s device failed after PCI "
"hotplug. Output: %r" % (test_type, e.output))
session.close()
try:
utils.system(dd_cmd)
except error.CmdError, e:
return failure
# only capture the new tcp port after offload setup
original_tcp_ports = re.findall(
"tcp.*:(\d+).*%s" % guest_ip,
utils.system_output("/bin/netstat -nap"))
for i in original_tcp_ports:
tcpdump_cmd += " and not port %s" % i
logging.debug("Listening traffic using command: %s", tcpdump_cmd)
session2.sendline(tcpdump_cmd)
if not utils_misc.wait_for(
lambda: session.cmd_status("pgrep tcpdump") == 0, 30):
return (False, "Tcpdump process wasn't launched")
logging.info("Transfering file %s from %s", filename, src)
try:
copy_files_func(filename, filename)
except remote.SCPError, e:
return (False, "File transfer failed (%s)" % e)
session.cmd("killall tcpdump")
try:
tcpdump_string = session2.read_up_to_prompt(timeout=60)
except aexpect.ExpectError:
return (False, "Failed to read tcpdump's output")
if not compare_md5sum(filename):
def run_jumbo(test, params, env):
"""
Test the RX jumbo frame function of vnics:
1) Boot the VM.
2) Change the MTU of guest nics and host taps depending on the NIC model.
3) Add the static ARP entry for guest NIC.
4) Wait for the MTU ok.
5) Verify the path MTU using ping.
6) Ping the guest with large frames.
7) Increment size ping.
8) Flood ping the guest with large frames.
9) Verify the path MTU.
10) Recover the MTU.
@param test: KVM test object.
@param params: Dictionary with the test parameters.
@param env: Dictionary with test environment.
"""
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
session = vm.wait_for_login(timeout=int(params.get("login_timeout", 360)))
mtu = params.get("mtu", "1500")
flood_time = params.get("flood_time", "300")
max_icmp_pkt_size = int(mtu) - 28
ifname = vm.get_ifname(0)
ip = vm.get_address(0)
if ip is None:
raise error.TestError("Could not get the IP address")
try:
# Environment preparation
ethname = utils_test.get_linux_ifname(session, vm.get_mac_address(0))
logging.info("Changing the MTU of guest ...")
guest_mtu_cmd = "ifconfig %s mtu %s" % (ethname, mtu)
session.cmd(guest_mtu_cmd)
logging.info("Chaning the MTU of host tap ...")
host_mtu_cmd = "ifconfig %s mtu %s" % (ifname, mtu)
utils.run(host_mtu_cmd)
logging.info("Add a temporary static ARP entry ...")
arp_add_cmd = "arp -s %s %s -i %s" % (ip, vm.get_mac_address(0),
ifname)
utils.run(arp_add_cmd)
def is_mtu_ok():
s, _ = utils_test.ping(ip,
1,
interface=ifname,
packetsize=max_icmp_pkt_size,
hint="do",
timeout=2)
return s == 0
def verify_mtu():
logging.info("Verify the path MTU")
s, o = utils_test.ping(ip,
10,
interface=ifname,
packetsize=max_icmp_pkt_size,
hint="do",
timeout=15)
if s != 0:
logging.error(o)
raise error.TestFail("Path MTU is not as expected")
if utils_test.get_loss_ratio(o) != 0:
logging.error(o)
raise error.TestFail("Packet loss ratio during MTU "
"verification is not zero")
def flood_ping():
logging.info("Flood with large frames")
utils_test.ping(ip,
interface=ifname,
packetsize=max_icmp_pkt_size,
flood=True,
timeout=float(flood_time))
def large_frame_ping(count=100):
logging.info("Large frame ping")
_, o = utils_test.ping(ip,
count,
interface=ifname,
packetsize=max_icmp_pkt_size,
timeout=float(count) * 2)
ratio = utils_test.get_loss_ratio(o)
if ratio != 0:
raise error.TestFail("Loss ratio of large frame ping is %s" %
ratio)
def size_increase_ping(step=random.randrange(90, 110)):
logging.info("Size increase ping")
for size in range(0, max_icmp_pkt_size + 1, step):
logging.info("Ping %s with size %s", ip, size)
s, o = utils_test.ping(ip,
1,
interface=ifname,
packetsize=size,
hint="do",
timeout=1)
if s != 0:
s, o = utils_test.ping(ip,
10,
interface=ifname,
packetsize=size,
adaptive=True,
hint="do",
timeout=20)
if utils_test.get_loss_ratio(o) > int(
params.get("fail_ratio", 50)):
raise error.TestFail("Ping loss ratio is greater "
"than 50% for size %s" % size)
logging.info("Waiting for the MTU to be OK")
wait_mtu_ok = 10
if not utils_misc.wait_for(is_mtu_ok, wait_mtu_ok, 0, 1):
logging.debug(commands.getoutput("ifconfig -a"))
raise error.TestError("MTU is not as expected even after %s "
"seconds" % wait_mtu_ok)
# Functional Test
verify_mtu()
large_frame_ping()
size_increase_ping()
# Stress test
flood_ping()
verify_mtu()
finally:
# Environment clean
session.close()
logging.info("Removing the temporary ARP entry")
utils.run("arp -d %s -i %s" % (ip, ifname))
def run_guest_s4(test, params, env):
"""
Suspend guest to disk, supports both Linux & Windows OSes.
@param test: kvm test object.
@param params: Dictionary with test parameters.
@param env: Dictionary with the test environment.
"""
error.base_context("before S4")
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
timeout = int(params.get("login_timeout", 360))
session = vm.wait_for_login(timeout=timeout)
error.context("checking whether guest OS supports S4", logging.info)
session.cmd(params.get("check_s4_support_cmd"))
error.context()
logging.info("Waiting until all guest OS services are fully started...")
time.sleep(float(params.get("services_up_timeout", 30)))
# Start up a program (tcpdump for linux & ping for Windows), as a flag.
# If the program died after suspend, then fails this testcase.
test_s4_cmd = params.get("test_s4_cmd")
session.sendline(test_s4_cmd)
time.sleep(5)
# Get the second session to start S4
session2 = vm.wait_for_login(timeout=timeout)
# Make sure the background program is running as expected
error.context("making sure background program is running")
check_s4_cmd = params.get("check_s4_cmd")
session2.cmd(check_s4_cmd)
logging.info("Launched background command in guest: %s", test_s4_cmd)
error.context()
error.base_context()
# Suspend to disk
logging.info("Starting suspend to disk now...")
session2.sendline(params.get("set_s4_cmd"))
# Make sure the VM goes down
error.base_context("after S4")
suspend_timeout = 240 + int(params.get("smp")) * 60
if not utils_misc.wait_for(vm.is_dead, suspend_timeout, 2, 2):
raise error.TestFail("VM refuses to go down. Suspend failed.")
logging.info("VM suspended successfully. Sleeping for a while before "
"resuming it.")
time.sleep(10)
# Start vm, and check whether the program is still running
logging.info("Resuming suspended VM...")
vm.create()
# Log into the resumed VM
relogin_timeout = int(params.get("relogin_timeout", 240))
logging.info("Logging into resumed VM, timeout %s", relogin_timeout)
session2 = vm.wait_for_login(timeout=relogin_timeout)
# Check whether the test command is still alive
error.context("making sure background program is still running",
logging.info)
session2.cmd(check_s4_cmd)
error.context()
logging.info("VM resumed successfuly after suspend to disk")
session2.cmd_output(params.get("kill_test_s4_cmd"))
session.close()
session2.close()
def run_jumbo(test, params, env):
"""
Test the RX jumbo frame function of vnics:
1) Boot the VM.
2) Change the MTU of guest nics and host taps depending on the NIC model.
3) Add the static ARP entry for guest NIC.
4) Wait for the MTU ok.
5) Verify the path MTU using ping.
6) Ping the guest with large frames.
7) Increment size ping.
8) Flood ping the guest with large frames.
9) Verify the path MTU.
10) Recover the MTU.
@param test: KVM test object.
@param params: Dictionary with the test parameters.
@param env: Dictionary with test environment.
"""
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
session = vm.wait_for_login(timeout=int(params.get("login_timeout", 360)))
mtu = params.get("mtu", "1500")
flood_time = params.get("flood_time", "300")
max_icmp_pkt_size = int(mtu) - 28
ifname = vm.get_ifname(0)
ip = vm.get_address(0)
if ip is None:
raise error.TestError("Could not get the IP address")
try:
# Environment preparation
ethname = utils_test.get_linux_ifname(session, vm.get_mac_address(0))
logging.info("Changing the MTU of guest ...")
guest_mtu_cmd = "ifconfig %s mtu %s" % (ethname , mtu)
session.cmd(guest_mtu_cmd)
logging.info("Chaning the MTU of host tap ...")
host_mtu_cmd = "ifconfig %s mtu %s" % (ifname, mtu)
utils.run(host_mtu_cmd)
logging.info("Add a temporary static ARP entry ...")
arp_add_cmd = "arp -s %s %s -i %s" % (ip, vm.get_mac_address(0), ifname)
utils.run(arp_add_cmd)
def is_mtu_ok():
s, o = utils_test.ping(ip, 1, interface=ifname,
packetsize=max_icmp_pkt_size,
hint="do", timeout=2)
return s == 0
def verify_mtu():
logging.info("Verify the path MTU")
s, o = utils_test.ping(ip, 10, interface=ifname,
packetsize=max_icmp_pkt_size,
hint="do", timeout=15)
if s != 0 :
logging.error(o)
raise error.TestFail("Path MTU is not as expected")
if utils_test.get_loss_ratio(o) != 0:
logging.error(o)
raise error.TestFail("Packet loss ratio during MTU "
"verification is not zero")
def flood_ping():
logging.info("Flood with large frames")
utils_test.ping(ip, interface=ifname,
packetsize=max_icmp_pkt_size,
flood=True, timeout=float(flood_time))
def large_frame_ping(count=100):
logging.info("Large frame ping")
s, o = utils_test.ping(ip, count, interface=ifname,
packetsize=max_icmp_pkt_size,
timeout=float(count) * 2)
ratio = utils_test.get_loss_ratio(o)
if ratio != 0:
raise error.TestFail("Loss ratio of large frame ping is %s" %
ratio)
def size_increase_ping(step=random.randrange(90, 110)):
logging.info("Size increase ping")
for size in range(0, max_icmp_pkt_size + 1, step):
logging.info("Ping %s with size %s", ip, size)
s, o = utils_test.ping(ip, 1, interface=ifname,
packetsize=size,
hint="do", timeout=1)
if s != 0:
s, o = utils_test.ping(ip, 10, interface=ifname,
packetsize=size,
adaptive=True, hint="do",
timeout=20)
if utils_test.get_loss_ratio(o) > int(params.get(
"fail_ratio", 50)):
raise error.TestFail("Ping loss ratio is greater "
"than 50% for size %s" % size)
logging.info("Waiting for the MTU to be OK")
wait_mtu_ok = 10
if not utils_misc.wait_for(is_mtu_ok, wait_mtu_ok, 0, 1):
logging.debug(commands.getoutput("ifconfig -a"))
raise error.TestError("MTU is not as expected even after %s "
"seconds" % wait_mtu_ok)
# Functional Test
verify_mtu()
large_frame_ping()
size_increase_ping()
# Stress test
flood_ping()
verify_mtu()
finally:
# Environment clean
session.close()
logging.info("Removing the temporary ARP entry")
utils.run("arp -d %s -i %s" % (ip, ifname))
def run_nfs_corrupt(test, params, env):
"""
Test if VM paused when image NFS shutdown, the drive option 'werror' should
be stop, the drive option 'cache' should be none.
1) Setup NFS service on host
2) Boot up a VM using another disk on NFS server and write the disk by dd
3) Check if VM status is 'running'
4) Reject NFS connection on host
5) Check if VM status is 'paused'
6) Accept NFS connection on host and continue VM by monitor command
7) Check if VM status is 'running'
@param test: kvm test object.
@param params: Dictionary with the test parameters.
@param env: Dictionary with test environment.
"""
def get_nfs_devname(params, session):
"""
Get the possbile name of nfs storage dev name in guest.
@param params: Test params dictionary.
@param session: An SSH session object.
"""
image1_type = params.object_params("image1").get("drive_format")
stg_type = params.object_params("stg").get("drive_format")
cmd = ""
# Seems we can get correct 'stg' devname even if the 'stg' image
# has a different type from main image (we call it 'image1' in
# config file) with these 'if' sentences.
if image1_type == stg_type:
cmd = "ls /dev/[hsv]d[a-z]"
elif stg_type == "virtio":
cmd = "ls /dev/vd[a-z]"
else:
cmd = "ls /dev/[sh]d[a-z]"
cmd += " | tail -n 1"
return session.cmd_output(cmd)
def check_vm_status(vm, status):
"""
Check if VM has the given status or not.
@param vm: VM object.
@param status: String with desired status.
@return: True if VM status matches our desired status.
@return: False if VM status does not match our desired status.
"""
try:
vm.verify_status(status)
except:
return False
else:
return True
config = NFSCorruptConfig(test, params)
config.setup()
image_name = os.path.join(config.mnt_dir, "nfs_corrupt")
params["image_name_stg"] = image_name
params["force_create_image_stg"] = "yes"
params["create_image_stg"] = "yes"
stg_params = params.object_params("stg")
env_process.preprocess_image(test, stg_params, image_name)
vm = env.get_vm(params["main_vm"])
vm.create(params=params)
session = vm.wait_for_login(timeout=int(params.get("login_timeout", 360)))
nfs_devname = get_nfs_devname(params, session)
# Write disk on NFS server
write_disk_cmd = "dd if=/dev/urandom of=%s" % nfs_devname
logging.info("Write disk on NFS server, cmd: %s" % write_disk_cmd)
session.sendline(write_disk_cmd)
try:
# Read some command output, it will timeout
session.read_up_to_prompt(timeout=30)
except:
pass
try:
error.context("Make sure guest is running before test")
vm.resume()
vm.verify_status("running")
try:
cmd = "iptables"
cmd += " -t filter"
cmd += " -A INPUT"
cmd += " -s localhost"
cmd += " -m state"
cmd += " --state NEW"
cmd += " -p tcp"
cmd += " --dport 2049"
cmd += " -j REJECT"
error.context("Reject NFS connection on host")
utils.system(cmd)
error.context("Check if VM status is 'paused'")
if not utils_misc.wait_for(
lambda: check_vm_status(vm, "paused"), int(params.get("wait_paused_timeout", 120))
):
raise error.TestError("Guest is not paused after stop NFS")
finally:
error.context("Accept NFS connection on host")
cmd = "iptables"
cmd += " -t filter"
cmd += " -D INPUT"
cmd += " -s localhost"
cmd += " -m state"
cmd += " --state NEW"
cmd += " -p tcp"
cmd += " --dport 2049"
cmd += " -j REJECT"
utils.system(cmd)
error.context("Continue guest")
vm.resume()
error.context("Check if VM status is 'running'")
if not utils_misc.wait_for(lambda: check_vm_status(vm, "running"), 20):
raise error.TestError("Guest does not restore to 'running' status")
finally:
session.close()
vm.destroy(gracefully=True)
config.cleanup()
def run_cdrom(test, params, env):
"""
KVM cdrom test:
1) Boot up a VM with one iso.
2) Check if VM identifies correctly the iso file.
3) * If cdrom_test_autounlock is set, verifies that device is unlocked
<300s after boot
4) Eject cdrom using monitor and change with another iso several times.
5) * If cdrom_test_tray_status = yes, tests tray reporting.
6) Try to format cdrom and check the return string.
7) Mount cdrom device.
8) Copy file from cdrom and compare files using diff.
9) Umount and mount several times.
@param test: kvm test object
@param params: Dictionary with the test parameters
@param env: Dictionary with test environment.
@param cfg: workaround_eject_time - Some versions of qemu are unable to
eject CDROM directly after insert
@param cfg: cdrom_test_autounlock - Test whether guest OS unlocks cdrom
after boot (<300s after VM is booted)
@param cfg: cdrom_test_tray_status - Test tray reporting (eject and insert
CD couple of times in guest).
@warning: Check dmesg for block device failures
"""
def master_cdroms(params):
""" Creates 'new' cdrom with one file on it """
error.context("creating test cdrom")
os.chdir(test.tmpdir)
cdrom_cd1 = params.get("cdrom_cd1")
if not os.path.isabs(cdrom_cd1):
cdrom_cd1 = os.path.join(test.bindir, cdrom_cd1)
cdrom_dir = os.path.dirname(cdrom_cd1)
utils.run("dd if=/dev/urandom of=orig bs=10M count=1")
utils.run("dd if=/dev/urandom of=new bs=10M count=1")
utils.run("mkisofs -o %s/orig.iso orig" % cdrom_dir)
utils.run("mkisofs -o %s/new.iso new" % cdrom_dir)
return "%s/new.iso" % cdrom_dir
def cleanup_cdroms(cdrom_dir):
""" Removes created cdrom """
error.context("cleaning up temp cdrom images")
os.remove("%s/new.iso" % cdrom_dir)
def get_cdrom_file(device):
"""
@param device: qemu monitor device
@return: file associated with $device device
"""
blocks = vm.monitor.info("block")
cdfile = None
if isinstance(blocks, str):
cdfile = re.findall('%s: .*file=(\S*) ' % device, blocks)
if not cdfile:
return None
else:
cdfile = cdfile[0]
else:
for block in blocks:
if block['device'] == device:
try:
cdfile = block['inserted']['file']
except KeyError:
continue
return cdfile
def check_cdrom_tray(cdrom):
""" Checks whether the tray is opend """
blocks = vm.monitor.info("block")
if isinstance(blocks, str):
for block in blocks.splitlines():
if cdrom in block:
if "tray-open=1" in block:
return True
elif "tray-open=0" in block:
return False
else:
for block in blocks:
if block['device'] == cdrom and 'tray_open' in block.keys():
return block['tray_open']
return None
def eject_cdrom(device, monitor):
""" Ejects the cdrom using kvm-monitor """
if isinstance(monitor, kvm_monitor.HumanMonitor):
monitor.cmd("eject %s" % device)
elif isinstance(monitor, kvm_monitor.QMPMonitor):
monitor.cmd("eject", args={'device': device})
def change_cdrom(device, target, monitor):
""" Changes the medium using kvm-monitor """
if isinstance(monitor, kvm_monitor.HumanMonitor):
monitor.cmd("change %s %s" % (device, target))
elif isinstance(monitor, kvm_monitor.QMPMonitor):
monitor.cmd("change", args={'device': device, 'target': target})
cdrom_new = master_cdroms(params)
cdrom_dir = os.path.dirname(cdrom_new)
vm = env.get_vm(params["main_vm"])
vm.create()
# Some versions of qemu are unable to eject CDROM directly after insert
workaround_eject_time = float(params.get('workaround_eject_time', 0))
session = vm.wait_for_login(timeout=int(params.get("login_timeout", 360)))
cdrom_orig = params.get("cdrom_cd1")
if not os.path.isabs(cdrom_orig):
cdrom_orig = os.path.join(test.bindir, cdrom_orig)
cdrom = cdrom_orig
output = session.get_command_output("ls /dev/cdrom*")
cdrom_dev_list = re.findall("/dev/cdrom-\w+|/dev/cdrom\d*", output)
logging.debug("cdrom_dev_list: %s", cdrom_dev_list)
cdrom_dev = ""
test_cmd = "dd if=%s of=/dev/null bs=1 count=1"
for d in cdrom_dev_list:
try:
output = session.cmd(test_cmd % d)
cdrom_dev = d
break
except aexpect.ShellError:
logging.error(output)
if not cdrom_dev:
raise error.TestFail("Could not find a valid cdrom device")
error.context("Detecting the existence of a cdrom")
cdfile = cdrom
device = vm.get_block({'file': cdfile})
if not device:
device = vm.get_block({'backing_file': cdfile})
if not device:
raise error.TestFail("Could not find a valid cdrom device")
session.get_command_output("umount %s" % cdrom_dev)
if params.get('cdrom_test_autounlock') == 'yes':
error.context("Trying to unlock the cdrom")
if not utils_misc.wait_for(lambda: not vm.check_block_locked(device),
300):
raise error.TestFail("Device %s could not be unlocked" % device)
max_times = int(params.get("max_times", 100))
error.context("Eject the cdrom in monitor %s times" % max_times)
for i in range(1, max_times):
session.cmd('eject %s' % cdrom_dev)
eject_cdrom(device, vm.monitor)
time.sleep(2)
if get_cdrom_file(device) is not None:
raise error.TestFail("Device %s was not ejected (%s)" % (cdrom, i))
cdrom = cdrom_new
# On even attempts, try to change the cdrom
if i % 2 == 0:
cdrom = cdrom_orig
change_cdrom(device, cdrom, vm.monitor)
if get_cdrom_file(device) != cdrom:
raise error.TestFail("It wasn't possible to change cdrom %s (%s)"
% (cdrom, i))
time.sleep(workaround_eject_time)
error.context('Eject the cdrom in guest %s times' % max_times)
if params.get('cdrom_test_tray_status') != 'yes':
pass
elif check_cdrom_tray(device) is None:
logging.error("Tray reporting not supported by qemu!")
logging.error("cdrom_test_tray_status skipped...")
else:
for i in range(1, max_times):
session.cmd('eject %s' % cdrom_dev)
if not check_cdrom_tray(device):
raise error.TestFail("Monitor reports closed tray (%s)" % i)
session.cmd('dd if=%s of=/dev/null count=1' % cdrom_dev)
if check_cdrom_tray(device):
raise error.TestFail("Monitor reports opened tray (%s)" % i)
time.sleep(workaround_eject_time)
error.context("Check whether the cdrom is read-only")
try:
output = session.cmd("echo y | mkfs %s" % cdrom_dev)
raise error.TestFail("Attempt to format cdrom %s succeeded" %
cdrom_dev)
except aexpect.ShellError:
pass
error.context("Mounting the cdrom under /mnt")
session.cmd("mount %s %s" % (cdrom_dev, "/mnt"), timeout=30)
filename = "new"
error.context("File copying test")
session.cmd("rm -f /tmp/%s" % filename)
session.cmd("cp -f /mnt/%s /tmp/" % filename)
error.context("Compare file on disk and on cdrom")
f1_hash = session.cmd("md5sum /mnt/%s" % filename).split()[0].strip()
f2_hash = session.cmd("md5sum /tmp/%s" % filename).split()[0].strip()
if f1_hash != f2_hash:
raise error.TestFail("On disk and on cdrom files are different, "
"md5 mismatch")
error.context("Mount/Unmount cdrom for %s times" % max_times)
for i in range(1, max_times):
try:
session.cmd("umount %s" % cdrom_dev)
session.cmd("mount %s /mnt" % cdrom_dev)
except aexpect.ShellError:
logging.debug(session.cmd("cat /etc/mtab"))
raise
session.cmd("umount %s" % cdrom_dev)
error.context("Cleanup")
# Return the cdrom_orig
cdfile = get_cdrom_file(device)
if cdfile != cdrom_orig:
time.sleep(workaround_eject_time)
session.cmd('eject %s' % cdrom_dev)
eject_cdrom(device, vm.monitor)
if get_cdrom_file(device) is not None:
raise error.TestFail("Device %s was not ejected (%s)" % (cdrom, i))
change_cdrom(device, cdrom_orig, vm.monitor)
if get_cdrom_file(device) != cdrom_orig:
raise error.TestFail("It wasn't possible to change cdrom %s (%s)"
% (cdrom, i))
session.close()
cleanup_cdroms(cdrom_dir)
def run_nfs_corrupt(test, params, env):
"""
Test if VM paused when image NFS shutdown, the drive option 'werror' should
be stop, the drive option 'cache' should be none.
1) Setup NFS service on host
2) Boot up a VM using another disk on NFS server and write the disk by dd
3) Check if VM status is 'running'
4) Reject NFS connection on host
5) Check if VM status is 'paused'
6) Accept NFS connection on host and continue VM by monitor command
7) Check if VM status is 'running'
@param test: kvm test object.
@param params: Dictionary with the test parameters.
@param env: Dictionary with test environment.
"""
def get_nfs_devname(params, session):
"""
Get the possbile name of nfs storage dev name in guest.
@param params: Test params dictionary.
@param session: An SSH session object.
"""
image1_type = params.object_params("image1").get("drive_format")
stg_type = params.object_params("stg").get("drive_format")
cmd = ""
# Seems we can get correct 'stg' devname even if the 'stg' image
# has a different type from main image (we call it 'image1' in
# config file) with these 'if' sentences.
if image1_type == stg_type:
cmd = "ls /dev/[hsv]d[a-z]"
elif stg_type == "virtio":
cmd = "ls /dev/vd[a-z]"
else:
cmd = "ls /dev/[sh]d[a-z]"
cmd += " | tail -n 1"
return session.cmd_output(cmd)
def check_vm_status(vm, status):
"""
Check if VM has the given status or not.
@param vm: VM object.
@param status: String with desired status.
@return: True if VM status matches our desired status.
@return: False if VM status does not match our desired status.
"""
try:
vm.verify_status(status)
except:
return False
else:
return True
config = NFSCorruptConfig(test, params)
config.setup()
image_name = os.path.join(config.mnt_dir, 'nfs_corrupt')
params["image_name_stg"] = image_name
params["force_create_image_stg"] = "yes"
params["create_image_stg"] = "yes"
stg_params = params.object_params("stg")
env_process.preprocess_image(test, stg_params, image_name)
vm = env.get_vm(params["main_vm"])
vm.create(params=params)
session = vm.wait_for_login(timeout=int(params.get("login_timeout", 360)))
nfs_devname = get_nfs_devname(params, session)
# Write disk on NFS server
write_disk_cmd = "dd if=/dev/urandom of=%s" % nfs_devname
logging.info("Write disk on NFS server, cmd: %s" % write_disk_cmd)
session.sendline(write_disk_cmd)
try:
# Read some command output, it will timeout
session.read_up_to_prompt(timeout=30)
except:
pass
try:
error.context("Make sure guest is running before test")
vm.resume()
vm.verify_status("running")
try:
cmd = "iptables"
cmd += " -t filter"
cmd += " -A INPUT"
cmd += " -s localhost"
cmd += " -m state"
cmd += " --state NEW"
cmd += " -p tcp"
cmd += " --dport 2049"
cmd += " -j REJECT"
error.context("Reject NFS connection on host")
utils.system(cmd)
error.context("Check if VM status is 'paused'")
if not utils_misc.wait_for(
lambda: check_vm_status(vm, "paused"),
int(params.get('wait_paused_timeout', 120))):
raise error.TestError("Guest is not paused after stop NFS")
finally:
error.context("Accept NFS connection on host")
cmd = "iptables"
cmd += " -t filter"
cmd += " -D INPUT"
cmd += " -s localhost"
cmd += " -m state"
cmd += " --state NEW"
cmd += " -p tcp"
cmd += " --dport 2049"
cmd += " -j REJECT"
utils.system(cmd)
error.context("Continue guest")
vm.resume()
error.context("Check if VM status is 'running'")
if not utils_misc.wait_for(lambda: check_vm_status(vm, "running"), 20):
raise error.TestError("Guest does not restore to 'running' status")
finally:
session.close()
vm.destroy(gracefully=True)
config.cleanup()
def run_pci_hotplug(test, params, env):
"""
Test hotplug of PCI devices.
(Elements between [] are configurable test parameters)
1) PCI add a deivce (NIC / block)
2) Compare output of monitor command 'info pci'.
3) Compare output of guest command [reference_cmd].
4) Verify whether pci_model is shown in [pci_find_cmd].
5) Check whether the newly added PCI device works fine.
6) PCI delete the device, verify whether could remove the PCI device.
@param test: KVM test object.
@param params: Dictionary with the test parameters.
@param env: Dictionary with test environment.
"""
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
timeout = int(params.get("login_timeout", 360))
session = vm.wait_for_login(timeout=timeout)
# Modprobe the module if specified in config file
module = params.get("modprobe_module")
if module:
session.cmd("modprobe %s" % module)
# Get output of command 'info pci' as reference
info_pci_ref = vm.monitor.info("pci")
# Get output of command as reference
reference = session.cmd_output(params.get("reference_cmd"))
tested_model = params.get("pci_model")
test_type = params.get("pci_type")
image_format = params.get("image_format_stg")
# Probe qemu to verify what is the supported syntax for PCI hotplug
cmd_output = vm.monitor.cmd("?")
if len(re.findall("\ndevice_add", cmd_output)) > 0:
cmd_type = "device_add"
elif len(re.findall("\npci_add", cmd_output)) > 0:
cmd_type = "pci_add"
else:
raise error.TestError("Unknow version of qemu")
# Determine syntax of drive hotplug
# __com.redhat_drive_add == qemu-kvm-0.12 on RHEL 6
if len(re.findall("\n__com.redhat_drive_add", cmd_output)) > 0:
drive_cmd_type = "__com.redhat_drive_add"
# drive_add == qemu-kvm-0.13 onwards
elif len(re.findall("\ndrive_add", cmd_output)) > 0:
drive_cmd_type = "drive_add"
else:
raise error.TestError("Unknow version of qemu")
# Probe qemu for a list of supported devices
devices_support = vm.monitor.cmd("%s ?" % cmd_type)
if cmd_type == "pci_add":
if test_type == "nic":
pci_add_cmd = "pci_add pci_addr=auto nic model=%s" % tested_model
elif test_type == "block":
image_params = params.object_params("stg")
image_filename = storage.get_image_filename(image_params,
test.bindir)
pci_add_cmd = ("pci_add pci_addr=auto storage file=%s,if=%s" %
(image_filename, tested_model))
# Execute pci_add (should be replaced by a proper monitor method call)
add_output = vm.monitor.cmd(pci_add_cmd)
if not "OK domain" in add_output:
raise error.TestFail("Add PCI device failed. "
"Monitor command is: %s, Output: %r" %
(pci_add_cmd, add_output))
after_add = vm.monitor.info("pci")
elif cmd_type == "device_add":
driver_id = test_type + "-" + utils_misc.generate_random_id()
device_id = test_type + "-" + utils_misc.generate_random_id()
if test_type == "nic":
if tested_model == "virtio":
tested_model = "virtio-net-pci"
pci_add_cmd = "device_add id=%s,driver=%s" % (device_id,
tested_model)
elif test_type == "block":
image_params = params.object_params("stg")
image_filename = storage.get_image_filename(image_params,
test.bindir)
controller_model = None
if tested_model == "virtio":
tested_model = "virtio-blk-pci"
if tested_model == "scsi":
tested_model = "scsi-disk"
controller_model = "lsi53c895a"
if len(re.findall(controller_model, devices_support)) == 0:
raise error.TestError("scsi controller device (%s) not "
"supported by qemu" %
controller_model)
if controller_model is not None:
controller_id = "controller-" + device_id
controller_add_cmd = ("device_add %s,id=%s" %
(controller_model, controller_id))
vm.monitor.cmd(controller_add_cmd)
if drive_cmd_type == "drive_add":
driver_add_cmd = ("drive_add auto "
"file=%s,if=none,id=%s,format=%s" %
(image_filename, driver_id, image_format))
elif drive_cmd_type == "__com.redhat_drive_add":
driver_add_cmd = ("__com.redhat_drive_add "
"file=%s,format=%s,id=%s" %
(image_filename, image_format, driver_id))
pci_add_cmd = ("device_add id=%s,driver=%s,drive=%s" %
(device_id, tested_model, driver_id))
vm.monitor.cmd(driver_add_cmd)
# Check if the device is support in qemu
if len(re.findall(tested_model, devices_support)) > 0:
add_output = vm.monitor.cmd(pci_add_cmd)
else:
raise error.TestError("%s doesn't support device: %s" %
(cmd_type, tested_model))
after_add = vm.monitor.info("pci")
if not device_id in after_add:
raise error.TestFail("Add device failed. Monitor command is: %s"
". Output: %r" % (pci_add_cmd, add_output))
# Define a helper function to delete the device
def pci_del(ignore_failure=False):
if cmd_type == "pci_add":
result_domain, bus, slot, function = add_output.split(',')
domain = int(result_domain.split()[2])
bus = int(bus.split()[1])
slot = int(slot.split()[1])
pci_addr = "%x:%x:%x" % (domain, bus, slot)
cmd = "pci_del pci_addr=%s" % pci_addr
elif cmd_type == "device_add":
cmd = "device_del %s" % device_id
# This should be replaced by a proper monitor method call
vm.monitor.cmd(cmd)
def device_removed():
after_del = vm.monitor.info("pci")
return after_del != after_add
if (not utils_misc.wait_for(device_removed, 10, 0, 1)
and not ignore_failure):
raise error.TestFail("Failed to hot remove PCI device: %s. "
"Monitor command: %s" %
(tested_model, cmd))
try:
# Compare the output of 'info pci'
if after_add == info_pci_ref:
raise error.TestFail("No new PCI device shown after executing "
"monitor command: 'info pci'")
# Define a helper function to compare the output
def new_shown():
o = session.cmd_output(params.get("reference_cmd"))
return o != reference
secs = int(params.get("wait_secs_for_hook_up"))
if not utils_misc.wait_for(new_shown, 30, secs, 3):
raise error.TestFail("No new device shown in output of command "
"executed inside the guest: %s" %
params.get("reference_cmd"))
# Define a helper function to catch PCI device string
def find_pci():
o = session.cmd_output(params.get("find_pci_cmd"))
return params.get("match_string") in o
if not utils_misc.wait_for(find_pci, 30, 3, 3):
raise error.TestFail("PCI %s %s device not found in guest. "
"Command was: %s" %
(tested_model, test_type,
params.get("find_pci_cmd")))
# Test the newly added device
try:
session.cmd(params.get("pci_test_cmd"))
except aexpect.ShellError, e:
raise error.TestFail("Check for %s device failed after PCI "
"hotplug. Output: %r" % (test_type, e.output))
session.close()
copy_files_func = vm.copy_files_to
try:
utils.system(dd_cmd)
except error.CmdError, e:
return failure
# only capture the new tcp port after offload setup
original_tcp_ports = re.findall("tcp.*:(\d+).*%s" % guest_ip,
utils.system_output("/bin/netstat -nap"))
for i in original_tcp_ports:
tcpdump_cmd += " and not port %s" % i
logging.debug("Listening traffic using command: %s", tcpdump_cmd)
session2.sendline(tcpdump_cmd)
if not utils_misc.wait_for(
lambda:session.cmd_status("pgrep tcpdump") == 0, 30):
return (False, "Tcpdump process wasn't launched")
logging.info("Transfering file %s from %s", filename, src)
try:
copy_files_func(filename, filename)
except remote.SCPError, e:
return (False, "File transfer failed (%s)" % e)
session.cmd("killall tcpdump")
try:
tcpdump_string = session2.read_up_to_prompt(timeout=60)
except aexpect.ExpectError:
return (False, "Failed to read tcpdump's output")
if not compare_md5sum(filename):
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('unittest_test_list'):
test_list = params.get('unittest_test_list').split()
logging.info('Original test list overriden by user')
logging.info('User defined unit test list: %s', test_list)
black_list = params.get('unittest_test_blacklist', '').split()
if black_list:
for b in black_list:
if b in test_list:
test_list.remove(b)
logging.info('Tests blacklisted by user: %s', black_list)
logging.info('Test list after blacklist: %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')
env_process.preprocess_vm(test, params, env, vm_name)
vm = env.get_vm(vm_name)
vm.create()
vm.resume()
logging.info(
"Waiting for unittest %s to complete, timeout %s, "
"output in %s", t, timeout, vm.get_testlog_filename())
if not utils_misc.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('unittest_test_list'):
test_list = params.get('unittest_test_list').split()
logging.info('Original test list overriden by user')
logging.info('User defined unit test list: %s', test_list)
black_list = params.get('unittest_test_blacklist', '').split()
if black_list:
for b in black_list:
if b in test_list:
test_list.remove(b)
logging.info('Tests blacklisted by user: %s', black_list)
logging.info('Test list after blacklist: %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')
env_process.preprocess_vm(test, params, env, vm_name)
vm = env.get_vm(vm_name)
vm.create()
vm.resume()
logging.info("Waiting for unittest %s to complete, timeout %s, "
"output in %s", t, timeout,
vm.get_testlog_filename())
if not utils_misc.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))