def check_mcast_network(session):
"""
Check multicast ip address on guests
"""
username = params.get("username")
password = params.get("password")
src_addr = ast.literal_eval(iface_source)['address']
add_session = additional_vm.wait_for_serial_login(username=username,
password=password)
vms_sess_dict = {vm_name: session,
additional_vm.name: add_session}
# Check mcast address on host
cmd = "netstat -g | grep %s" % src_addr
if utils.run(cmd, ignore_status=True).exit_status:
raise error.TestFail("Can't find multicast ip address"
" on host")
vms_ip_dict = {}
# Get ip address on each guest
for vms in vms_sess_dict.keys():
vm_mac = vm_xml.VMXML.get_first_mac_by_name(vms)
vm_ip = get_guest_ip(vms_sess_dict[vms], vm_mac)
if not vm_ip:
raise error.TestFail("Can't get multicast ip"
" address on guest")
vms_ip_dict.update({vms: vm_ip})
if len(set(vms_ip_dict.values())) != len(vms_sess_dict):
raise error.TestFail("Got duplicated multicast ip address")
logging.debug("Found ips on guest: %s", vms_ip_dict)
# Run omping server on host
if not utils_misc.yum_install(["omping"]):
raise error.TestError("Failed to install omping"
" on host")
cmd = ("iptables -F;omping -m %s %s" %
(src_addr, "192.168.122.1 %s" %
' '.join(vms_ip_dict.values())))
# Run a backgroup job waiting for connection of client
bgjob = utils.AsyncJob(cmd)
# Run omping client on guests
for vms in vms_sess_dict.keys():
# omping should be installed first
if not utils_misc.yum_install(["omping"], vms_sess_dict[vms]):
raise error.TestError("Failed to install omping"
" on guest")
cmd = ("iptables -F; omping -c 5 -T 5 -m %s %s" %
(src_addr, "192.168.122.1 %s" %
vms_ip_dict[vms]))
ret, output = vms_sess_dict[vms].cmd_status_output(cmd)
logging.debug("omping ret: %s, output: %s", ret, output)
if (not output.count('multicast, xmt/rcv/%loss = 5/5/0%') or
not output.count('unicast, xmt/rcv/%loss = 5/5/0%')):
raise error.TestFail("omping failed on guest")
# Kill the backgroup job
bgjob.kill_func()
def check_mcast_network(session):
"""
Check multicast ip address on guests
"""
username = params.get("username")
password = params.get("password")
src_addr = ast.literal_eval(iface_source)['address']
add_session = additional_vm.wait_for_serial_login(username=username,
password=password)
vms_sess_dict = {vm_name: session,
additional_vm.name: add_session}
# Check mcast address on host
cmd = "netstat -g | grep %s" % src_addr
if utils.run(cmd, ignore_status=True).exit_status:
raise error.TestFail("Can't find multicast ip address"
" on host")
vms_ip_dict = {}
# Get ip address on each guest
for vms in vms_sess_dict.keys():
vm_mac = vm_xml.VMXML.get_first_mac_by_name(vms)
vm_ip = get_guest_ip(vms_sess_dict[vms], vm_mac)
if not vm_ip:
raise error.TestFail("Can't get multicast ip"
" address on guest")
vms_ip_dict.update({vms: vm_ip})
if len(set(vms_ip_dict.values())) != len(vms_sess_dict):
raise error.TestFail("Got duplicated multicast ip address")
logging.debug("Found ips on guest: %s", vms_ip_dict)
# Run omping server on host
if not utils_misc.yum_install(["omping"]):
raise error.TestError("Failed to install omping"
" on host")
cmd = ("iptables -F;omping -m %s %s" %
(src_addr, "192.168.122.1 %s" %
' '.join(vms_ip_dict.values())))
# Run a backgroup job waiting for connection of client
bgjob = utils.AsyncJob(cmd)
# Run omping client on guests
for vms in vms_sess_dict.keys():
# omping should be installed first
if not utils_misc.yum_install(["omping"], vms_sess_dict[vms]):
raise error.TestError("Failed to install omping"
" on guest")
cmd = ("iptables -F; omping -c 5 -T 5 -m %s %s" %
(src_addr, "192.168.122.1 %s" %
vms_ip_dict[vms]))
ret, output = vms_sess_dict[vms].cmd_status_output(cmd)
logging.debug("omping ret: %s, output: %s", ret, output)
if (not output.count('multicast, xmt/rcv/%loss = 5/5/0%') or
not output.count('unicast, xmt/rcv/%loss = 5/5/0%')):
raise error.TestFail("omping failed on guest")
# Kill the backgroup job
bgjob.kill_func()
def install_kernel(session, url=None, kernel_debug=False):
"""
Install kernel to vm
"""
if kernel_debug:
if not utils_misc.yum_install(['kernel-debug'], session=session):
raise exceptions.TestFail('Fail on installing debug kernel')
else:
logging.info('Install kernel-debug success')
else:
if not (url and url.endswith('.rpm')):
raise exceptions.TestError('kernel url not contain ".rpm"')
# rhel6 need to install kernel-firmware first
if '.el6' in session.cmd('uname -r'):
kernel_fm_url = params.get('kernel_fm_url')
cmd_install_firmware = 'rpm -Uv %s' % kernel_fm_url
try:
session.cmd(cmd_install_firmware, timeout=v2v_timeout)
except Exception, e:
raise exceptions.TestError(str(e))
cmd_install_kernel = 'rpm -iv %s' % url
try:
session.cmd(cmd_install_kernel, timeout=v2v_timeout)
except Exception, e:
raise exceptions.TestError(str(e))
def run_guest_libvirt(session):
"""
Check guest libvirt network
"""
# Try to install required packages
if not utils_misc.yum_install(['libvirt'], session):
raise error.TestError("Failed ot install libvirt"
" package on guest")
result = True
# Try to load tun module first
session.cmd("lsmod | grep tun || modprobe tun")
# Check network state on guest
cmd = ("service libvirtd restart; virsh net-info default"
" | grep 'Active:.*no'")
if session.cmd_status(cmd):
result = False
logging.error("Default network isn't in inactive state")
# Try to start default network on guest, check error messages
if result:
cmd = "virsh net-start default"
status, output = session.cmd_status_output(cmd)
logging.debug("Run command on guest exit %s, output %s"
% (status, output))
if not status or not output.count("already in use"):
result = False
logging.error("Failed to see network messges on guest")
if session.cmd_status("yum -y remove libvirt*"):
logging.error("Failed to remove libvirt packages on guest")
if not result:
raise error.TestFail("Check libvirt network on guest failed")
def prepare_pxe_boot():
"""
Prepare tftp server and pxe boot files
"""
pkg_list = ["syslinux", "tftp-server",
"tftp", "ipxe-roms-qemu", "wget"]
# Try to install required packages
if not utils_misc.yum_install(pkg_list):
raise error.TestError("Failed ot install "
"required packages")
boot_initrd = params.get("boot_initrd", "EXAMPLE_INITRD")
boot_vmlinuz = params.get("boot_vmlinuz", "EXAMPLE_VMLINUZ")
if boot_initrd.count("EXAMPLE") or boot_vmlinuz.count("EXAMPLE"):
raise error.TestNAError("Please provide initrd/vmlinuz URL")
# Download pxe boot images
utils.run("wget %s -O %s/initrd.img"
% (boot_initrd, tftp_root))
utils.run("wget %s -O %s/vmlinuz"
% (boot_vmlinuz, tftp_root))
utils.run("cp -f /usr/share/syslinux/pxelinux.0 {0};"
" mkdir -m 777 -p {0}/pxelinux.cfg".format(tftp_root))
pxe_file = "%s/pxelinux.cfg/default" % tftp_root
boot_txt = """
DISPLAY boot.txt
DEFAULT rhel
LABEL rhel
kernel vmlinuz
append initrd=initrd.img
PROMPT 1
TIMEOUT 3"""
with open(pxe_file, 'w') as p_file:
p_file.write(boot_txt)
def run_guest_libvirt(session):
"""
Check guest libvirt network
"""
# Try to install required packages
if not utils_misc.yum_install(['libvirt'], session):
raise error.TestNAError("Failed ot install libvirt"
" package on guest")
result = True
# Check network state on guest
cmd = ("service libvirtd restart; virsh net-info default"
" | grep 'Active:.*no'")
if session.cmd_status(cmd):
result = False
logging.error("Default network isn't in inactive state")
# Try to start default network on guest, check error messages
if result:
cmd = "virsh net-start default"
status, output = session.cmd_status_output(cmd)
logging.debug("Run command on guest exit %s, output %s"
% (status, output))
if not status or not output.count("already in use"):
result = False
logging.error("Failed to see network messges on guest")
if session.cmd_status("rpm -e libvirt"):
logging.error("Failed to remove libvirt packages on guest")
if not result:
raise error.TestFail("Check libvirt network on guest failed")
def install_kernel(session, url=None, kernel_debug=False):
"""
Install kernel to vm
"""
if kernel_debug:
if not utils_misc.yum_install(['kernel-debug'], session=session):
raise exceptions.TestFail('Fail on installing debug kernel')
else:
logging.info('Install kernel-debug success')
else:
if not (url and url.endswith('.rpm')):
raise exceptions.TestError('kernel url not contain ".rpm"')
# rhel6 need to install kernel-firmware first
if '.el6' in session.cmd('uname -r'):
kernel_fm_url = params.get('kernel_fm_url')
cmd_install_firmware = 'rpm -Uv %s' % kernel_fm_url
try:
session.cmd(cmd_install_firmware, timeout=v2v_timeout)
except Exception, e:
raise exceptions.TestError(str(e))
cmd_install_kernel = 'rpm -iv %s' % url
try:
session.cmd(cmd_install_kernel, timeout=v2v_timeout)
except Exception, e:
raise exceptions.TestError(str(e))
def prepare_pxe_boot():
"""
Prepare tftp server and pxe boot files
"""
pkg_list = ["syslinux", "tftp-server",
"tftp", "ipxe-roms-qemu", "wget"]
# Try to install required packages
if not utils_misc.yum_install(pkg_list):
raise error.TestNAError("Failed ot install "
"required packages")
boot_initrd = params.get("boot_initrd")
boot_vmlinuz = params.get("boot_vmlinuz")
# Download pxe boot images
utils.run("wget %s -O %s/initrd.img"
% (boot_initrd, tftp_root))
utils.run("wget %s -O %s/vmlinuz"
% (boot_vmlinuz, tftp_root))
utils.run("cp -f /usr/share/syslinux/pxelinux.0 {0};"
" mkdir -m 777 -p {0}/pxelinux.cfg".format(tftp_root))
pxe_file = "%s/pxelinux.cfg/default" % tftp_root
boot_txt = """
DISPLAY boot.txt
DEFAULT rhel
LABEL rhel
kernel vmlinuz
append initrd=initrd.img
PROMPT 1
TIMEOUT 3"""
with open(pxe_file, 'w') as p_file:
p_file.write(boot_txt)
def __init__(self):
# libcgroup lack libcgroup-tools dependency will introduces
# following error,
# Failed to issue method call:
# Unit cgconfig.service failed to load:
# No such file or directory
#
# Please refer to
# https://bugzilla.redhat.com/show_bug.cgi?format=multiple&id=882887
if not utils_misc.yum_install(['libcgroup-tools']):
error.TestError("Failed to install libcgroup-tools on host")
self._service_manager = service.Factory.create_service("cgconfig")
def __init__(self):
# libcgroup lack libcgroup-tools dependency will introduces
# following error,
# Failed to issue method call:
# Unit cgconfig.service failed to load:
# No such file or directory
#
# Please refer to
# https://bugzilla.redhat.com/show_bug.cgi?format=multiple&id=882887
if not utils_misc.yum_install(['libcgroup-tools']):
error.TestError("Failed to install libcgroup-tools on host")
self._service_manager = service.Factory.create_service("cgconfig")
def check_name_ip(session):
"""
Check dns resolving on guest
"""
# Check if bind-utils is installed
if not utils_misc.yum_install(['bind-utils'], session):
raise error.TestNAError("Failed to install bind-utils" " on guest")
# Run host command to check if hostname can be resolved
if not guest_ipv4 and not guest_ipv6:
raise error.TestFail("No ip address found from parameters")
guest_ip = guest_ipv4 if guest_ipv4 else guest_ipv6
cmd = "host %s | grep %s" % (guest_name, guest_ip)
if session.cmd_status(cmd):
raise error.TestFail("Can't resolve name %s on guest" % guest_name)
def check_name_ip(session):
"""
Check dns resolving on guest
"""
# Check if bind-utils is installed
if not utils_misc.yum_install(["bind-utils"], session):
raise error.TestError("Failed to install bind-utils" " on guest")
# Run host command to check if hostname can be resolved
if not guest_ipv4 and not guest_ipv6:
raise error.TestFail("No ip address found from parameters")
guest_ip = guest_ipv4 if guest_ipv4 else guest_ipv6
cmd = "host %s | grep %s" % (guest_name, guest_ip)
if session.cmd_status(cmd):
raise error.TestFail("Can't resolve name %s on guest" % guest_name)
# try to login and run some program
try:
session = vm.wait_for_login()
except (LoginError, ShellError), e:
error_msg = "Test failed in positive case.\n error: %s\n" % e
raise error.TestFail(error_msg)
sessions.append(session)
if test_type == "stress":
# prepare file for increasing stress
stress_path = prepare_c_file()
remote.scp_to_remote(vm.get_address(), 22, 'root',
params.get('password'), stress_path, "/tmp/")
# Try to install gcc on guest first
utils_misc.yum_install(["gcc"], session, 360)
# increasing workload
session.cmd("gcc %s -o %s" % (stress_path, target_path))
session.cmd("%s &" % target_path)
if test_type == "unixbench":
params["main_vm"] = vm_name
params["test_control_file"] = unixbench_control_file
control_path = os.path.join(test.virtdir, "control",
unixbench_control_file)
command = utils_test.run_autotest(vm, session, control_path,
None, None,
params, copy_only=True)
session.cmd("%s &" % command)
# wait for autotest running on vm
# try to login and run some program
try:
session = vm.wait_for_login()
except (LoginError, ShellError), e:
error_msg = "Test failed in positive case.\n error: %s\n" % e
raise error.TestFail(error_msg)
sessions.append(session)
if test_type == "stress":
# prepare file for increasing stress
stress_path = prepare_c_file()
remote.scp_to_remote(vm.get_address(), 22, 'root',
params.get('password'), stress_path, "/tmp/")
# Try to install gcc on guest first
utils_misc.yum_install(["gcc"], session, 360)
# increasing workload
session.cmd("gcc %s -o %s" % (stress_path, target_path))
session.cmd("%s &" % target_path)
if test_type == "unixbench":
params["main_vm"] = vm_name
params["test_control_file"] = unixbench_control_file
control_path = os.path.join(test.virtdir, "control",
unixbench_control_file)
command = utils_test.run_autotest(vm,
session,
control_path,
None,
None,
def run(test, params, env):
"""
Test rng device options.
1.Prepare test environment, destroy or suspend a VM.
2.Edit xml and start the domain.
3.Perform test operation.
4.Recover test environment.
5.Confirm the test result.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
def modify_rng_xml(dparams, sync=True):
"""
Modify interface xml options
"""
rng_model = dparams.get("rng_model", "virtio")
rng_rate = dparams.get("rng_rate")
backend_model = dparams.get("backend_model", "random")
backend_type = dparams.get("backend_type")
backend_dev = dparams.get("backend_dev", "")
backend_source_list = dparams.get("backend_source", "").split()
backend_protocol = dparams.get("backend_protocol")
vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
rng_xml = rng.Rng()
rng_xml.rng_model = rng_model
if rng_rate:
rng_xml.rate = ast.literal_eval(rng_rate)
backend = rng.Rng.Backend()
backend.backend_model = backend_model
if backend_type:
backend.backend_type = backend_type
if backend_dev:
backend.backend_dev = backend_dev
if backend_source_list:
source_list = [
ast.literal_eval(source) for source in backend_source_list
]
backend.source = source_list
if backend_protocol:
backend.backend_protocol = backend_protocol
rng_xml.backend = backend
logging.debug("Rng xml: %s", rng_xml)
if sync:
vmxml.add_device(rng_xml)
vmxml.xmltreefile.write()
vmxml.sync()
else:
status = libvirt.exec_virsh_edit(
vm_name, [(r":/<devices>/s/$/%s" %
re.findall(r"<rng.*<\/rng>", str(rng_xml),
re.M)[0].replace("/", "\/"))])
if not status:
raise error.TestFail("Failed to edit vm xml")
def check_qemu_cmd(dparams):
"""
Verify qemu-kvm command line.
"""
rng_model = dparams.get("rng_model", "virtio")
rng_rate = dparams.get("rng_rate")
backend_type = dparams.get("backend_type")
backend_source_list = dparams.get("backend_source", "").split()
cmd = ("ps -ef | grep %s | grep -v grep" % vm_name)
chardev = src_host = src_port = None
if backend_type == "tcp":
chardev = "socket"
elif backend_type == "udp":
chardev = "udp"
for bc_source in backend_source_list:
source = ast.literal_eval(bc_source)
if "mode" in source and source['mode'] == "connect":
src_host = source['host']
src_port = source['service']
if chardev and src_host and src_port:
cmd += (" | grep 'chardev %s,.*host=%s,port=%s'" %
(chardev, src_host, src_port))
if rng_model == "virtio":
cmd += (" | grep 'device virtio-rng-pci'")
if rng_rate:
rate = ast.literal_eval(rng_rate)
cmd += (" | grep 'max-bytes=%s,period=%s'" %
(rate['bytes'], rate['period']))
if utils.run(cmd, ignore_status=True).exit_status:
raise error.TestFail("Cann't see rng option" " in command line")
def check_host():
"""
Check random device on host
"""
backend_dev = params.get("backend_dev")
if backend_dev:
cmd = "lsof %s" % backend_dev
ret = utils.run(cmd, ignore_status=True)
if ret.exit_status or not ret.stdout.count("qemu"):
raise error.TestFail(
"Failed to check random device"
" on host, command output: %s", ret.stdout)
def check_snapshot(bgjob=None):
"""
Do snapshot operation and check the results
"""
snapshot_name1 = "snap.s1"
snapshot_name2 = "snap.s2"
if not snapshot_vm_running:
vm.destroy(gracefully=False)
ret = virsh.snapshot_create_as(vm_name, snapshot_name1)
libvirt.check_exit_status(ret)
snap_lists = virsh.snapshot_list(vm_name)
if snapshot_name not in snap_lists:
raise error.TestFail("Snapshot %s doesn't exist" % snapshot_name)
if snapshot_vm_running:
options = "--force"
else:
options = ""
ret = virsh.snapshot_revert(vm_name,
("%s %s" % (snapshot_name, options)))
libvirt.check_exit_status(ret)
ret = virsh.dumpxml(vm_name)
if ret.stdout.count("<rng model="):
raise error.TestFail("Found rng device in xml")
if snapshot_with_rng:
if vm.is_alive():
vm.destroy(gracefully=False)
if bgjob:
bgjob.kill_func()
modify_rng_xml(params, False)
# Start the domain before disk-only snapshot
if vm.is_dead():
# Add random server
if params.get("backend_type") == "tcp":
cmd = "cat /dev/random | nc -4 -l localhost 1024"
bgjob = utils.AsyncJob(cmd)
vm.start()
vm.wait_for_login().close()
err_msgs = ("live disk snapshot not supported"
" with this QEMU binary")
ret = virsh.snapshot_create_as(vm_name,
"%s --disk-only" % snapshot_name2)
if ret.exit_status:
if ret.stderr.count(err_msgs):
raise error.TestNAError(err_msgs)
else:
raise error.TestFail("Failed to create external snapshot")
snap_lists = virsh.snapshot_list(vm_name)
if snapshot_name2 not in snap_lists:
raise error.TestFail("Failed to check snapshot list")
ret = virsh.domblklist(vm_name)
if not ret.stdout.count(snapshot_name2):
raise error.TestFail("Failed to find snapshot disk")
def check_guest(session):
"""
Check random device on guest
"""
rng_files = ("/sys/devices/virtual/misc/hw_random/rng_available",
"/sys/devices/virtual/misc/hw_random/rng_current")
rng_avail = session.cmd_output("cat %s" % rng_files[0],
timeout=600).strip()
rng_currt = session.cmd_output("cat %s" % rng_files[1],
timeout=600).strip()
logging.debug("rng avail:%s, current:%s", rng_avail, rng_currt)
if not rng_currt.count("virtio") or rng_currt not in rng_avail:
raise error.TestFail("Failed to check rng file on guest")
# Read the random device
cmd = ("dd if=/dev/hwrng of=rng.test count=100" " && rm -f rng.test")
ret, output = session.cmd_status_output(cmd, timeout=600)
if ret:
raise error.TestFail("Failed to read the random device")
rng_rate = params.get("rng_rate")
if rng_rate:
rate_bytes, rate_period = ast.literal_eval(rng_rate).values()
rate_conf = float(rate_bytes) / (float(rate_period) / 1000)
ret = re.search(r"(\d+) bytes.*copied, (\d+.\d+) s", output, re.M)
if not ret:
raise error.TestFail("Can't find rate from output")
rate_real = float(ret.group(1)) / float(ret.group(2))
logging.debug("Find rate: %s, config rate: %s", rate_real,
rate_conf)
if rate_real > rate_conf * 1.2:
raise error.TestFail("The rate of reading exceed"
" the limitation of configuration")
if device_num > 1:
rng_dev = rng_avail.split()
if len(rng_dev) != device_num:
raise error.TestNAError("Multiple virtio-rng devices are not"
" supported on this guest kernel. "
"Bug: https://bugzilla.redhat.com/"
"show_bug.cgi?id=915335")
session.cmd("echo -n %s > %s" % (rng_dev[1], rng_files[1]))
# Read the random device
if session.cmd_status(cmd, timeout=120):
raise error.TestFail("Failed to read the random device")
start_error = "yes" == params.get("start_error", "no")
test_host = "yes" == params.get("test_host", "no")
test_guest = "yes" == params.get("test_guest", "no")
test_qemu_cmd = "yes" == params.get("test_qemu_cmd", "no")
test_snapshot = "yes" == params.get("test_snapshot", "no")
snapshot_vm_running = "yes" == params.get("snapshot_vm_running", "no")
snapshot_with_rng = "yes" == params.get("snapshot_with_rng", "no")
snapshot_name = params.get("snapshot_name")
device_num = int(params.get("device_num", 1))
if device_num > 1 and not libvirt_version.version_compare(1, 2, 7):
raise error.TestNAError("Multiple virtio-rng devices not "
"supported on this libvirt version")
# Back up xml file.
vmxml_backup = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
# Try to install rng-tools on host, it can speed up random rate
# if installation failed, ignore the error and continue the test
if utils_misc.yum_install(["rng-tools"], timeout=300):
rngd_conf = "/etc/sysconfig/rngd"
rngd_srv = "/usr/lib/systemd/system/rngd.service"
if os.path.exists(rngd_conf):
# For rhel6 host, add extraoptions
with open(rngd_conf, 'w') as f_rng:
f_rng.write('EXTRAOPTIONS="--rng-device /dev/urandom"')
elif os.path.exists(rngd_srv):
# For rhel7 host, modify start options
rngd_srv_conf = "/etc/systemd/system/rngd.service"
if not os.path.exists(rngd_srv_conf):
shutil.copy(rngd_srv, rngd_srv_conf)
utils.run("sed -i -e 's#^ExecStart=.*#ExecStart=/sbin/rngd"
" -f -r /dev/urandom -o /dev/random#' %s" %
rngd_srv_conf)
utils.run('systemctl daemon-reload')
utils.run("service rngd start")
# Build the xml and run test.
try:
bgjob = None
# Take snapshot if needed
if snapshot_name:
if snapshot_vm_running:
vm.start()
vm.wait_for_login().close()
ret = virsh.snapshot_create_as(vm_name, snapshot_name)
libvirt.check_exit_status(ret)
# Destroy VM first
if vm.is_alive():
vm.destroy(gracefully=False)
# Build vm xml.
dparams = {}
if device_num > 1:
for i in xrange(device_num):
dparams[i] = {
"rng_model": params.get("rng_model_%s" % i, "virtio")
}
dparams[i].update({
"backend_model":
params.get("backend_model_%s" % i, "random")
})
bk_type = params.get("backend_type_%s" % i)
if bk_type:
dparams[i].update({"backend_type": bk_type})
bk_dev = params.get("backend_dev_%s" % i)
if bk_dev:
dparams[i].update({"backend_dev": bk_dev})
bk_src = params.get("backend_source_%s" % i)
if bk_src:
dparams[i].update({"backend_source": bk_src})
bk_pro = params.get("backend_protocol_%s" % i)
if bk_pro:
dparams[i].update({"backend_protocol": bk_pro})
modify_rng_xml(dparams[i], False)
else:
modify_rng_xml(params, not test_snapshot)
try:
# Add random server
if params.get("backend_type") == "tcp":
cmd = "cat /dev/random | nc -4 -l localhost 1024"
bgjob = utils.AsyncJob(cmd)
# Start the VM.
vm.start()
if start_error:
raise error.TestFail("VM started unexpectedly")
if test_qemu_cmd:
if device_num > 1:
for i in xrange(device_num):
check_qemu_cmd(dparams[i])
else:
check_qemu_cmd(params)
if test_host:
check_host()
session = vm.wait_for_login()
if test_guest:
check_guest(session)
session.close()
if test_snapshot:
check_snapshot(bgjob)
except virt_vm.VMStartError as details:
logging.info(str(details))
if not start_error:
raise error.TestFail('VM failed to start, '
'please refer to https://bugzilla.'
'redhat.com/show_bug.cgi?id=1220252:'
'\n%s' % details)
finally:
# Delete snapshots.
snapshot_lists = virsh.snapshot_list(vm_name)
if len(snapshot_lists) > 0:
libvirt.clean_up_snapshots(vm_name, snapshot_lists)
for snapshot in snapshot_lists:
virsh.snapshot_delete(vm_name, snapshot, "--metadata")
# Recover VM.
if vm.is_alive():
vm.destroy(gracefully=False)
logging.info("Restoring vm...")
vmxml_backup.sync()
if bgjob:
bgjob.kill_func()
raise exceptions.TestError('No CDROM image attached')
# Check if xen guest exists again
if not virsh.domain_exists(vm_name, uri=uri):
logging.error('VM %s not exists', vm_name)
# Execute virt-v2v
v2v_result = utils_v2v.v2v_cmd(v2v_params)
if new_vm_name:
vm_name = new_vm_name
params['main_vm'] = new_vm_name
check_result(v2v_result, status_error)
finally:
process.run('ssh-agent -k')
if params.get('vmchecker'):
params['vmchecker'].cleanup()
if output_mode == 'libvirt':
pvt.cleanup_pool(pool_name, pool_type, pool_target, '')
if bk_xml:
bk_xml.sync(virsh_instance=virsh_instance)
virsh_instance.close_session()
if checkpoint == 'ssh_banner':
logging.info('Remove ssh_banner file')
session = remote.remote_login("ssh", xen_host, "22", "root",
xen_host_passwd, "#")
session.cmd('rm -f /etc/ssh/ssh_banner')
session.cmd('service sshd restart')
if checkpoint.startswith('virtio_win'):
utils_misc.yum_install(['virtio-win'])
def run(test, params, env):
"""
Test steps:
1) Get the params from params.
2) check the environment
3) Strat the VM and check whether the VM been started successfully
4) Compare the Hugepage memory size to the Guest memory setted.
5) Check the hugepage memory usage.
6) Clean up
"""
test_type = params.get("test_type", 'normal')
tlbfs_enable = 'yes' == params.get("hugetlbfs_enable", 'no')
shp_num = int(params.get("static_hugepage_num", 1024))
thp_enable = 'yes' == params.get("trans_hugepage_enable", 'no')
mb_enable = 'yes' == params.get("mb_enable", 'yes')
delay = int(params.get("delay_time", 10))
# Skip cases early
vm_names = []
if test_type == "contrast":
vm_names = params.get("vms").split()[:2]
if len(vm_names) < 2:
raise error.TestNAError("This test requires two VMs")
# confirm no VM running
allvms = virsh.dom_list('--name').stdout.strip()
if allvms != '':
raise error.TestNAError("one or more VMs are alive")
err_range = float(params.get("mem_error_range", 1.25))
else:
vm_names.append(params.get("main_vm"))
if test_type == "stress":
target_path = params.get("target_path", "/tmp/test.out")
elif test_type == "unixbench":
unixbench_control_file = params.get("unixbench_controle_file",
"unixbench5.control")
# backup orignal setting
shp_orig_num = utils_memory.get_num_huge_pages()
thp_orig_status = utils_memory.get_transparent_hugepage()
page_size = utils_memory.get_huge_page_size()
# mount/umount hugetlbfs
tlbfs_status = utils_misc.is_mounted("hugetlbfs", "/dev/hugepages",
"hugetlbfs")
if tlbfs_enable is True:
if tlbfs_status is not True:
utils_misc.mount("hugetlbfs", "/dev/hugepages", "hugetlbfs")
else:
if tlbfs_status is True:
utils_misc.umount("hugetlbfs", "/dev/hugepages", "hugetlbfs")
# set static hugepage
utils_memory.set_num_huge_pages(shp_num)
# enable/disable transparent hugepage
if thp_enable:
utils_memory.set_transparent_hugepage('always')
else:
utils_memory.set_transparent_hugepage('never')
# set/del memoryBacking tag
for vm_name in vm_names:
if mb_enable:
vm_xml.VMXML.set_memoryBacking_tag(vm_name)
else:
vm_xml.VMXML.del_memoryBacking_tag(vm_name)
utils_libvirtd.libvirtd_restart()
non_started_free = utils_memory.get_num_huge_pages_free()
vms = []
sessions = []
try:
for vm_name in vm_names:
# try to start vm and login
try:
vm = env.get_vm(vm_name)
vm.start()
except VMError, e:
if mb_enable and not tlbfs_enable:
# if hugetlbfs not be mounted,
# VM start with memoryBacking tag will fail
logging.debug(e)
else:
error_msg = "Test failed in positive case. error: %s\n" % e
raise error.TestFail(error_msg)
if vm.is_alive() is not True:
break
vms.append(vm)
# try to login and run some program
try:
session = vm.wait_for_login()
except (LoginError, ShellError), e:
error_msg = "Test failed in positive case.\n error: %s\n" % e
raise error.TestFail(error_msg)
sessions.append(session)
if test_type == "stress":
# prepare file for increasing stress
stress_path = prepare_c_file()
remote.scp_to_remote(vm.get_address(), 22, 'root',
params.get('password'), stress_path,
"/tmp/")
# Try to install gcc on guest first
utils_misc.yum_install(["gcc"], session, 360)
# increasing workload
session.cmd("gcc %s -o %s" % (stress_path, target_path))
session.cmd("%s &" % target_path)
if test_type == "unixbench":
params["main_vm"] = vm_name
params["test_control_file"] = unixbench_control_file
control_path = os.path.join(test.virtdir, "control",
unixbench_control_file)
# unixbench test need 'patch' and 'perl' commands installed
utils_misc.yum_install(["patch", "perl"], session, 360)
command = utils_test.run_autotest(vm,
session,
control_path,
None,
None,
params,
copy_only=True)
session.cmd("%s &" % command, ignore_all_errors=True)
# wait for autotest running on vm
time.sleep(delay)
def _is_unixbench_running():
cmd = "ps -ef | grep perl | grep Run"
return not session.cmd_status(cmd)
if not utils_misc.wait_for(_is_unixbench_running, timeout=240):
raise error.TestNAError("Failed to run unixbench in guest,"
" please make sure some necessary"
" packages are installed in guest,"
" such as gcc, tar, bzip2")
logging.debug("Unixbench test is running in VM")
def run(test, params, env):
"""
Test steps:
1) Get the params from params.
2) check the environment
3) Strat the VM and check whether the VM been started successfully
4) Compare the Hugepage memory size to the Guest memory setted.
5) Check the hugepage memory usage.
6) Clean up
"""
test_type = params.get("test_type", 'normal')
tlbfs_enable = 'yes' == params.get("hugetlbfs_enable", 'no')
shp_num = int(params.get("static_hugepage_num", 1024))
thp_enable = 'yes' == params.get("trans_hugepage_enable", 'no')
mb_enable = 'yes' == params.get("mb_enable", 'yes')
delay = int(params.get("delay_time", 10))
# backup orignal setting
shp_orig_num = utils_memory.get_num_huge_pages()
thp_orig_status = utils_memory.get_transparent_hugepage()
page_size = utils_memory.get_huge_page_size()
if test_type == "contrast":
range = float(params.get("mem_error_range", 1.25))
elif test_type == "stress":
target_path = params.get("target_path", "/tmp/test.out")
elif test_type == "unixbench":
unixbench_control_file = params.get("unixbench_controle_file",
"unixbench5.control")
vm_names = []
if test_type == "contrast":
vm_names = params.get("vms").split()[:2]
if len(vm_names) < 2:
raise error.TestNAError("Hugepage Stress Test need two VM(s).")
# confirm no VM(s) running
allvms = virsh.dom_list('--name').stdout.strip()
if allvms != '':
raise error.TestNAError("one or more VM(s) is living.")
else:
vm_names.append(params.get("main_vm"))
# mount/umount hugetlbfs
tlbfs_status = utils_misc.is_mounted("hugetlbfs", "/dev/hugepages", "hugetlbfs")
if tlbfs_enable is True:
if tlbfs_status is not True:
utils_misc.mount("hugetlbfs", "/dev/hugepages", "hugetlbfs")
else:
if tlbfs_status is True:
utils_misc.umount("hugetlbfs", "/dev/hugepages", "hugetlbfs")
# set static hugepage
utils_memory.set_num_huge_pages(shp_num)
# enable/disable transparent hugepage
if thp_enable:
utils_memory.set_transparent_hugepage('always')
else:
utils_memory.set_transparent_hugepage('never')
# set/del memoryBacking tag
vmxml_backup = {}
for vm_name in vm_names:
vmxml_backup[vm_name] = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
if mb_enable:
vm_xml.VMXML.set_memoryBacking_tag(vm_name)
else:
vm_xml.VMXML.del_memoryBacking_tag(vm_name)
try:
utils_libvirtd.libvirtd_restart()
non_started_free = utils_memory.get_num_huge_pages_free()
vms = []
sessions = []
for vm_name in vm_names:
# try to start vm and login
try:
vm = env.get_vm(vm_name)
vm.start()
except VMError, e:
if mb_enable and not tlbfs_enable:
# if hugetlbfs not be mounted,
# VM start with memoryBacking tag will fail
logging.debug(e)
pass # jump out of for-loop
else:
error_msg = "Test failed in positive case. error: %s\n" % e
raise error.TestFail(error_msg)
if vm.is_alive() is not True:
break
vms.append(vm)
# try to login and run some program
try:
session = vm.wait_for_login()
except (LoginError, ShellError), e:
error_msg = "Test failed in positive case.\n error: %s\n" % e
raise error.TestFail(error_msg)
sessions.append(session)
if test_type == "stress":
# prepare file for increasing stress
stress_path = prepare_c_file()
remote.scp_to_remote(vm.get_address(), 22, 'root',
params.get('password'), stress_path, "/tmp/")
# Try to install gcc on guest first
utils_misc.yum_install(["gcc"], session, 360)
# increasing workload
session.cmd("gcc %s -o %s" % (stress_path, target_path))
session.cmd("%s &" % target_path)
if test_type == "unixbench":
params["main_vm"] = vm_name
params["test_control_file"] = unixbench_control_file
control_path = os.path.join(test.virtdir, "control",
unixbench_control_file)
command = utils_test.run_autotest(vm, session, control_path,
None, None,
params, copy_only=True)
session.cmd("%s &" % command)
# wait for autotest running on vm
time.sleep(delay)
def _is_unixbench_running():
return (not session.cmd_status("ps -ef | grep perl | grep Run"))
if not utils_misc.wait_for(_is_unixbench_running, timeout=240):
raise error.TestNAError("Failed to run unixbench in guest.\n"
"so please make sure there are some necessary"
"packages in guest, such as gcc, tar, bzip2")
logging.debug("Unixbench is already running in VM(s).")
unsupported_err.append('live disk snapshot not supported')
unsupported_err.append('internal snapshot for disk .* unsupported')
if test_blockcopy:
unsupported_err.append('block copy is not supported')
if attach_disk:
unsupported_err.append('No such file or directory')
if create_volume:
unsupported_err.append("backing 'volume' disks isn't yet supported")
unsupported_err.append('this function is not supported')
try:
# Set domain state
libvirt.set_domain_state(vm, pre_vm_state)
# Install ceph-common package which include rbd command
if utils_misc.yum_install(["ceph-common"]):
if client_name and client_key:
with open(key_file, 'w') as f:
f.write("[%s]\n\tkey = %s\n" % (client_name, client_key))
key_opt = "--keyring %s" % key_file
# Create secret xml
sec_xml = secret_xml.SecretXML("no", "no")
sec_xml.usage = auth_type
sec_xml.usage_name = auth_usage
sec_xml.xmltreefile.write()
logging.debug("Secret xml: %s", sec_xml)
ret = virsh.secret_define(sec_xml.xml)
libvirt.check_exit_status(ret)
