def run_set_link(test, params, env):
"""
KVM guest link test:
1) Boot up guest with one nic
2) Ping guest from host
3) Disable guest link and ping guest from host
4) Re-enable guest link and ping guest from host
5) Do file transfer test
@param test: kvm test object
@param params: Dictionary with the test parameters
@param env: Dictionary with test environment.
"""
vm = virt_test_utils.get_living_vm(env, params.get("main_vm"))
timeout = float(params.get("login_timeout", 360))
session = virt_test_utils.wait_for_login(vm, 0, timeout, 0, 2)
def set_link_test(linkid):
"""
Issue set_link commands and test its function
@param linkid: id of netdev or devices to be tested
"""
ip = vm.get_address(0)
vm.monitor.cmd("set_link %s down" % linkid)
s, o = virt_test_utils.ping(ip, count=10, timeout=20)
if virt_test_utils.get_loss_ratio(o) != 100:
raise error.TestFail("Still can ping the %s after down %s" %
(ip, linkid))
vm.monitor.cmd("set_link %s up" % linkid)
s, o = virt_test_utils.ping(ip, count=10, timeout=20)
# we use 100% here as the notification of link status changed may be
# delayed in guest driver
if virt_test_utils.get_loss_ratio(o) == 100:
raise error.TestFail("Packet loss during ping %s after up %s" %
(ip, linkid))
netdev_id = vm.netdev_id[0]
device_id = vm.get_peer(netdev_id)
logging.info("Issue set_link commands for netdevs")
set_link_test(netdev_id)
logging.info("Issue set_link commands for network devics")
set_link_test(device_id)
file_transfer.run_file_transfer(test, params, env)
session.close()
def run_trans_hugepage_defrag(test, params, env):
"""
KVM khugepage userspace side test:
1) Verify that the host supports kernel hugepages.
If it does proceed with the test.
2) Verify that the kernel hugepages can be used in host.
3) Verify that the kernel hugepages can be used in guest.
4) Migrate guest while using hugepages.
@param test: KVM test object.
@param params: Dictionary with test parameters.
@param env: Dictionary with the test environment.
"""
def get_mem_status(params):
for line in file('/proc/meminfo', 'r').readlines():
if line.startswith("%s" % params):
output = re.split('\s+', line)[1]
return output
def set_libhugetlbfs(number):
f = file("/proc/sys/vm/nr_hugepages", "w+")
f.write(number)
f.seek(0)
ret = f.read()
return int(ret)
test_config = virt_test_setup.TransparentHugePageConfig(test, params)
# Test the defrag
logging.info("Defrag test start")
login_timeout = float(params.get("login_timeout", 360))
vm = virt_test_utils.get_living_vm(env, params.get("main_vm"))
session = virt_test_utils.wait_for_login(vm, timeout=login_timeout)
mem_path = os.path.join("/tmp", "thp_space")
try:
test_config.setup()
error.context("Fragmenting guest memory")
try:
if not os.path.isdir(mem_path):
os.makedirs(mem_path)
if os.system("mount -t tmpfs none %s" % mem_path):
raise error.TestError("Can not mount tmpfs")
# Try to fragment the memory a bit
cmd = ("for i in `seq 262144`; do dd if=/dev/urandom of=%s/$i "
"bs=4K count=1 & done" % mem_path)
utils.run(cmd)
finally:
utils.run("umount %s" % mem_path)
total = int(get_mem_status('MemTotal'))
hugepagesize = int(get_mem_status('Hugepagesize'))
nr_full = str(total / hugepagesize)
error.context("activating khugepaged defrag functionality")
# Allocate hugepages for libhugetlbfs before and after enable defrag,
# and check out the difference.
nr_hp_before = set_libhugetlbfs(nr_full)
try:
defrag_path = os.path.join(test_config.thp_path, 'khugepaged',
'defrag')
file(str(defrag_path), 'w').write('yes')
except IOError, e:
raise error.TestFail("Can not start defrag on khugepaged: %s" % e)
# TODO: Is sitting an arbitrary amount of time appropriate? Aren't there
# better ways to do this?
time.sleep(1)
nr_hp_after = set_libhugetlbfs(nr_full)
if nr_hp_before >= nr_hp_after:
raise error.TestFail("There was no memory defragmentation on host: "
"%s huge pages allocated before turning "
"khugepaged defrag on, %s allocated after it" %
(nr_hp_before, nr_hp_after))
logging.info("Defrag test succeeded")
session.close()
def run_trans_hugepage_swapping(test, params, env):
"""
KVM khugepage user side test:
1) Verify that the hugepages can be swapped in/out.
@param test: KVM test object.
@param params: Dictionary with test parameters.
@param env: Dictionary with the test environment.
"""
def get_args(args_list):
"""
Get the memory arguments from system
"""
args_list_tmp = args_list.copy()
for line in file('/proc/meminfo', 'r').readlines():
for key in args_list_tmp.keys():
if line.startswith("%s" % args_list_tmp[key]):
args_list_tmp[key] = int(re.split('\s+', line)[1])
return args_list_tmp
test_config = virt_test_setup.TransparentHugePageConfig(test, params)
try:
test_config.setup()
# Swapping test
logging.info("Swapping test start")
# Parameters of memory information
# @total: Memory size
# @free: Free memory size
# @swap_size: Swap size
# @swap_free: Free swap size
# @hugepage_size: Page size of one hugepage
# @page_size: The biggest page size that app can ask for
args_dict_check = {"free" : "MemFree", "swap_size" : "SwapTotal",
"swap_free" : "SwapFree", "total" : "MemTotal",
"hugepage_size" : "Hugepagesize",}
args_dict = get_args(args_dict_check)
swap_free = []
total = int(args_dict['total']) / 1024
free = int(args_dict['free']) / 1024
swap_size = int(args_dict['swap_size']) / 1024
swap_free.append(int(args_dict['swap_free'])/1024)
hugepage_size = int(args_dict['hugepage_size']) / 1024
dd_timeout = float(params.get("dd_timeout", 900))
login_timeout = float(params.get("login_timeout", 360))
check_cmd_timeout = float(params.get("check_cmd_timeout", 900))
mem_path = os.path.join(test.tmpdir, 'thp_space')
tmpfs_path = "/space"
# If swap is enough fill all memory with dd
if swap_free > (total - free):
count = total / hugepage_size
tmpfs_size = total
else:
count = free / hugepage_size
tmpfs_size = free
if swap_size <= 0:
raise logging.info("Host does not have swap enabled")
session = None
try:
if not os.path.isdir(mem_path):
os.makedirs(mem_path)
utils.run("mount -t tmpfs -o size=%sM none %s" % (tmpfs_size,
mem_path))
# Set the memory size of vm
# To ignore the oom killer set it to the free swap size
vm = virt_test_utils.get_living_vm(env, params.get("main_vm"))
if int(params['mem']) > swap_free[0]:
vm.destroy()
vm_name = 'vmsw'
vm0 = params.get("main_vm")
vm0_key = virt_utils.env_get_vm(env, vm0)
params['vms'] = params['vms'] + " " + vm_name
params['mem'] = str(swap_free[0])
vm_key = vm0_key.clone(vm0, params)
virt_utils.env_register_vm(env, vm_name, vm_key)
virt_env_process.preprocess_vm(test, params, env, vm_name)
vm_key.create()
session = virt_utils.wait_for(vm_key.remote_login,
timeout=login_timeout)
else:
session = virt_test_utils.wait_for_login(vm,
timeout=login_timeout)
error.context("making guest to swap memory")
cmd = ("dd if=/dev/zero of=%s/zero bs=%s000000 count=%s" %
(mem_path, hugepage_size, count))
utils.run(cmd)
args_dict = get_args(args_dict_check)
swap_free.append(int(args_dict['swap_free'])/1024)
if swap_free[1] - swap_free[0] >= 0:
raise error.TestFail("No data was swapped to memory")
# Try harder to make guest memory to be swapped
session.cmd("find / -name \"*\"", timeout=check_cmd_timeout)
finally:
if session is not None:
utils.run("umount %s" % mem_path)
logging.info("Swapping test succeed")
finally:
session.close()
test_config.cleanup()
def run_trans_hugepage(test, params, env):
"""
KVM kernel hugepages user side test:
1) Smoke test
2) Stress test
@param test: KVM test object.
@param params: Dictionary with test parameters.
@param env: Dictionary with the test environment.
"""
def get_mem_status(params, role):
if role == "host":
info = utils.system_output("cat /proc/meminfo")
else:
info = session.cmd("cat /proc/meminfo")
for h in re.split("\n+", info):
if h.startswith("%s" % params):
output = re.split('\s+', h)[1]
return output
dd_timeout = float(params.get("dd_timeout", 900))
mem = params['mem']
failures = []
debugfs_flag = 1
debugfs_path = os.path.join(test.tmpdir, 'debugfs')
mem_path = os.path.join("/tmp", 'thp_space')
login_timeout = float(params.get("login_timeout", "3600"))
error.context("smoke test setup")
if not os.path.ismount(debugfs_path):
if not os.path.isdir(debugfs_path):
os.makedirs(debugfs_path)
utils.run("mount -t debugfs none %s" % debugfs_path)
test_config = virt_test_setup.TransparentHugePageConfig(test, params)
vm = virt_test_utils.get_living_vm(env, params.get("main_vm"))
session = virt_test_utils.wait_for_login(vm, timeout=login_timeout)
try:
# Check khugepage is used by guest
test_config.setup()
logging.info("Smoke test start")
error.context("smoke test")
nr_ah_before = int(get_mem_status('AnonHugePages', 'host'))
if nr_ah_before <= 0:
e_msg = 'smoke: Host is not using THP'
logging.error(e_msg)
failures.append(e_msg)
# Protect system from oom killer
if int(get_mem_status('MemFree', 'guest')) / 1024 < mem:
mem = int(get_mem_status('MemFree', 'guest')) / 1024
session.cmd("mkdir -p %s" % mem_path)
session.cmd("mount -t tmpfs -o size=%sM none %s" %
(str(mem), mem_path))
count = mem / 4
session.cmd("dd if=/dev/zero of=%s/1 bs=4000000 count=%s" %
(mem_path, count),
timeout=dd_timeout)
nr_ah_after = int(get_mem_status('AnonHugePages', 'host'))
if nr_ah_after <= nr_ah_before:
e_msg = ('smoke: Host did not use new THP during dd')
logging.error(e_msg)
failures.append(e_msg)
if debugfs_flag == 1:
if int(open('%s/kvm/largepages' % debugfs_path, 'r').read()) <= 0:
e_msg = 'smoke: KVM is not using THP'
logging.error(e_msg)
failures.append(e_msg)
logging.info("Smoke test finished")
# Use parallel dd as stress for memory
count = count / 3
logging.info("Stress test start")
error.context("stress test")
cmd = "rm -rf %s/*; for i in `seq %s`; do dd " % (mem_path, count)
cmd += "if=/dev/zero of=%s/$i bs=4000000 count=1& done;wait" % mem_path
output = session.cmd_output(cmd, timeout=dd_timeout)
if len(re.findall("No space", output)) > count * 0.05:
e_msg = "stress: Too many dd instances failed in guest"
logging.error(e_msg)
failures.append(e_msg)
try:
output = session.cmd('pidof dd')
except Exception:
output = None
if output is not None:
for i in re.split('\n+', output):
session.cmd('kill -9 %s' % i)
session.cmd("umount %s" % mem_path)
logging.info("Stress test finished")
finally:
error.context("all tests cleanup")
if os.path.ismount(debugfs_path):
utils.run("umount %s" % debugfs_path)
if os.path.isdir(debugfs_path):
os.removedirs(debugfs_path)
session.close()
test_config.cleanup()
error.context("")
if failures:
raise error.TestFail("THP base test reported %s failures:\n%s" %
(len(failures), "\n".join(failures)))
def run_nic_hotplug(test, params, env):
"""
Test hotplug of NIC devices
1) Boot up guest with one nic
2) Add a host network device through monitor cmd and check if it's added
3) Add nic device through monitor cmd and check if it's added
4) Check if new interface gets ip address
5) Disable primary link of guest
6) Ping guest new ip from host
7) Delete nic device and netdev
8) Re-enable primary link of guest
BEWARE OF THE NETWORK BRIDGE DEVICE USED FOR THIS TEST ("bridge" param).
The KVM autotest default bridge virbr0, leveraging libvirt, works fine
for the purpose of this test. When using other bridges, the timeouts
which usually happen when the bridge topology changes (that is, devices
get added and removed) may cause random failures.
@param test: KVM test object.
@param params: Dictionary with the test parameters.
@param env: Dictionary with test environment.
"""
vm = virt_test_utils.get_living_vm(env, params.get("main_vm"))
login_timeout = int(params.get("login_timeout", 360))
guest_delay = int(params.get("guest_delay", 20))
pci_model = params.get("pci_model", "rtl8139")
run_dhclient = params.get("run_dhclient", "no")
guest_is_not_windows = "Win" not in params.get("guest_name", "")
session = virt_test_utils.wait_for_login(vm, timeout=login_timeout)
udev_rules_path = "/etc/udev/rules.d/70-persistent-net.rules"
udev_rules_bkp_path = "/tmp/70-persistent-net.rules"
def guest_path_isfile(path):
try:
session.cmd("test -f %s" % path)
except aexpect.ShellError:
return False
return True
if guest_is_not_windows:
if guest_path_isfile(udev_rules_path):
session.cmd("mv -f %s %s" % (udev_rules_path, udev_rules_bkp_path))
# Modprobe the module if specified in config file
module = params.get("modprobe_module")
if module:
session.get_command_output("modprobe %s" % module)
# hot-add the nic
nic_info = vm.add_nic(model=pci_model)
# Only run dhclient if explicitly set and guest is not running Windows.
# Most modern Linux guests run NetworkManager, and thus do not need this.
if run_dhclient == "yes" and guest_is_not_windows:
session_serial = vm.wait_for_serial_login(timeout=login_timeout)
ifname = virt_test_utils.get_linux_ifname(session, nic_info['mac'])
session_serial.cmd("dhclient %s &" % ifname)
logging.info("Shutting down the primary link")
vm.monitor.cmd("set_link %s off" % vm.netdev_id[0])
try:
logging.info("Waiting for new nic's ip address acquisition...")
if not virt_utils.wait_for(
lambda:
(vm.address_cache.get(nic_info['mac']) is not None), 10, 1):
raise error.TestFail("Could not get ip address of new nic")
ip = vm.address_cache.get(nic_info['mac'])
if not virt_utils.verify_ip_address_ownership(ip, nic_info['mac']):
raise error.TestFail("Could not verify the ip address of new nic")
else:
logging.info("Got the ip address of new nic: %s", ip)
logging.info("Ping test the new nic ...")
s, o = virt_test_utils.ping(ip, 100)
if s != 0:
logging.error(o)
raise error.TestFail("New nic failed ping test")
logging.info("Detaching the previously attached nic from vm")
vm.del_nic(nic_info, guest_delay)
finally:
vm.free_mac_address(1)
logging.info("Re-enabling the primary link")
vm.monitor.cmd("set_link %s on" % vm.netdev_id[0])
# Attempt to put back udev network naming rules, even if the command to
# disable the rules failed. We may be undoing what was done in a previous
# (failed) test that never reached this point.
if guest_is_not_windows:
if guest_path_isfile(udev_rules_bkp_path):
session.cmd("mv -f %s %s" % (udev_rules_bkp_path, udev_rules_path))
def run_nic_hotplug(test, params, env):
"""
Test hotplug of NIC devices
1) Boot up guest with one nic
2) Add a host network device through monitor cmd and check if it's added
3) Add nic device through monitor cmd and check if it's added
4) Check if new interface gets ip address
5) Disable primary link of guest
6) Ping guest new ip from host
7) Delete nic device and netdev
8) Re-enable primary link of guest
BEWARE OF THE NETWORK BRIDGE DEVICE USED FOR THIS TEST ("bridge" param).
The KVM autotest default bridge virbr0, leveraging libvirt, works fine
for the purpose of this test. When using other bridges, the timeouts
which usually happen when the bridge topology changes (that is, devices
get added and removed) may cause random failures.
@param test: KVM test object.
@param params: Dictionary with the test parameters.
@param env: Dictionary with test environment.
"""
vm = virt_test_utils.get_living_vm(env, params.get("main_vm"))
login_timeout = int(params.get("login_timeout", 360))
guest_delay = int(params.get("guest_delay", 20))
romfile = params.get("romfile", "")
pci_model = params.get("pci_model", "rtl8139")
run_dhclient = params.get("run_dhclient", "no")
guest_is_not_windows = "Win" not in params.get("guest_name", "")
session = virt_test_utils.wait_for_login(vm, timeout=login_timeout)
if guest_is_not_windows:
# Disable udev rules that usually mess up with device naming
mv_stat, o = session.cmd_status_output("mv /etc/udev/rules.d/"
"70-persistent-net.rules /tmp")
logging.debug("command to disable udev rules returned status: %s" %
mv_stat)
# Modprobe the module if specified in config file
module = params.get("modprobe_module")
if module:
session.get_command_output("modprobe %s" % module)
# hot-add the nic
nic_info = vm.add_nic(model=pci_model)
# Only run dhclient if explicitly set and guest is not running Windows.
# Most modern Linux guests run NetworkManager, and thus do not need this.
if run_dhclient == "yes" and guest_is_not_windows:
session_serial = vm.wait_for_serial_login(timeout=login_timeout)
ifname = virt_test_utils.get_linux_ifname(session, nic_info['mac'])
session_serial.cmd("dhclient %s &" % ifname)
logging.info("Shutting down the primary link")
vm.monitor.cmd("set_link %s off" % vm.netdev_id[0])
try:
logging.info("Waiting for new nic's ip address acquisition...")
if not virt_utils.wait_for(lambda:
(vm.address_cache.get(nic_info['mac'])
is not None),
10, 1):
raise error.TestFail("Could not get ip address of new nic")
ip = vm.address_cache.get(nic_info['mac'])
if not virt_utils.verify_ip_address_ownership(ip, nic_info['mac']):
raise error.TestFail("Could not verify the ip address of new nic")
else:
logging.info("Got the ip address of new nic: %s", ip)
logging.info("Ping test the new nic ...")
s, o = virt_test_utils.ping(ip, 100)
if s != 0:
logging.error(o)
raise error.TestFail("New nic failed ping test")
logging.info("Detaching the previously attached nic from vm")
vm.del_nic(nic_info, guest_delay)
finally:
vm.free_mac_address(1)
logging.info("Re-enabling the primary link")
vm.monitor.cmd("set_link %s on" % vm.netdev_id[0])
# Attempt to put back udev network naming rules, even if the command to
# disable the rules failed. We may be undoing what was done in a previous
# (failed) test that never reached this point.
if guest_is_not_windows:
mv_stat, o = session.cmd_status_output("mv /tmp/70-persistent-net"
".rules /etc/udev/rules.d/")
logging.debug("command to revert udev rules returned status: %s" %
mv_stat)
def run_trans_hugepage(test, params, env):
"""
KVM kernel hugepages user side test:
1) Smoke test
2) Stress test
@param test: KVM test object.
@param params: Dictionary with test parameters.
@param env: Dictionary with the test environment.
"""
def get_mem_status(params, role):
if role == "host":
info = utils.system_output("cat /proc/meminfo")
else:
info = session.cmd("cat /proc/meminfo")
for h in re.split("\n+", info):
if h.startswith("%s" % params):
output = re.split('\s+', h)[1]
return output
dd_timeout = float(params.get("dd_timeout", 900))
mem = params['mem']
failures = []
debugfs_flag = 1
debugfs_path = os.path.join(test.tmpdir, 'debugfs')
mem_path = os.path.join("/tmp", 'thp_space')
login_timeout = float(params.get("login_timeout", "3600"))
error.context("smoke test setup")
if not os.path.ismount(debugfs_path):
if not os.path.isdir(debugfs_path):
os.makedirs(debugfs_path)
utils.run("mount -t debugfs none %s" % debugfs_path)
test_config = virt_test_setup.TransparentHugePageConfig(test, params)
vm = virt_test_utils.get_living_vm(env, params.get("main_vm"))
session = virt_test_utils.wait_for_login(vm, timeout=login_timeout)
try:
# Check khugepage is used by guest
test_config.setup()
logging.info("Smoke test start")
error.context("smoke test")
nr_ah_before = get_mem_status('AnonHugePages', 'host')
if nr_ah_before <= 0:
e_msg = 'smoke: Host is not using THP'
logging.error(e_msg)
failures.append(e_msg)
# Protect system from oom killer
if int(get_mem_status('MemFree', 'guest')) / 1024 < mem :
mem = int(get_mem_status('MemFree', 'guest')) / 1024
session.cmd("mkdir -p %s" % mem_path)
session.cmd("mount -t tmpfs -o size=%sM none %s" % (str(mem), mem_path))
count = mem / 4
session.cmd("dd if=/dev/zero of=%s/1 bs=4000000 count=%s" %
(mem_path, count), timeout=dd_timeout)
nr_ah_after = get_mem_status('AnonHugePages', 'host')
if nr_ah_after <= nr_ah_before:
e_msg = ('smoke: Host did not use new THP during dd')
logging.error(e_msg)
failures.append(e_msg)
if debugfs_flag == 1:
if int(open('%s/kvm/largepages' % debugfs_path, 'r').read()) <= 0:
e_msg = 'smoke: KVM is not using THP'
logging.error(e_msg)
failures.append(e_msg)
logging.info("Smoke test finished")
# Use parallel dd as stress for memory
count = count / 3
logging.info("Stress test start")
error.context("stress test")
cmd = "rm -rf %s/*; for i in `seq %s`; do dd " % (mem_path, count)
cmd += "if=/dev/zero of=%s/$i bs=4000000 count=1& done;wait" % mem_path
output = session.cmd_output(cmd, timeout=dd_timeout)
if len(re.findall("No space", output)) > count * 0.05:
e_msg = "stress: Too many dd instances failed in guest"
logging.error(e_msg)
failures.append(e_msg)
try:
output = session.cmd('pidof dd')
except Exception:
output = None
if output is not None:
for i in re.split('\n+', output):
session.cmd('kill -9 %s' % i)
session.cmd("umount %s" % mem_path)
logging.info("Stress test finished")
finally:
error.context("all tests cleanup")
if os.path.ismount(debugfs_path):
utils.run("umount %s" % debugfs_path)
if os.path.isdir(debugfs_path):
os.removedirs(debugfs_path)
session.close()
test_config.cleanup()
error.context("")
if failures:
raise error.TestFail("THP base test reported %s failures:\n%s" %
(len(failures), "\n".join(failures)))
def run_nic_hotplug(test, params, env):
"""
Test hotplug of NIC devices
1) Boot up guest with one nic
2) Add a host network device through monitor cmd and check if it's added
3) Add nic device through monitor cmd and check if it's added
4) Check if new interface gets ip address
5) Disable primary link of guest
6) Ping guest new ip from host
7) Delete nic device and netdev
8) Re-enable primary link of guest
@param test: KVM test object.
@param params: Dictionary with the test parameters.
@param env: Dictionary with test environment.
"""
vm = virt_test_utils.get_living_vm(env, params.get("main_vm"))
timeout = int(params.get("login_timeout", 360))
guest_delay = int(params.get("guest_delay", 20))
session = virt_test_utils.wait_for_login(vm, timeout=timeout)
romfile = params.get("romfile")
# Modprobe the module if specified in config file
module = params.get("modprobe_module")
if module:
session.get_command_output("modprobe %s" % module)
def netdev_add(vm):
netdev_id = virt_utils.generate_random_id()
attach_cmd = ("netdev_add tap,id=%s" % netdev_id)
nic_script = params.get("nic_script")
if nic_script:
attach_cmd += ",script=%s" % virt_utils.get_path(
vm.root_dir, nic_script)
netdev_extra_params = params.get("netdev_extra_params")
if netdev_extra_params:
attach_cmd += ",%s" % netdev_extra_params
logging.info("Adding netdev through %s", attach_cmd)
vm.monitor.cmd(attach_cmd)
network = vm.monitor.info("network")
if netdev_id not in network:
logging.error(network)
raise error.TestError("Fail to add netdev: %s" % netdev_id)
else:
return netdev_id
def netdev_del(vm, n_id):
vm.monitor.cmd("netdev_del %s" % n_id)
network = vm.monitor.info("network")
if n_id in network:
logging.error(network)
raise error.TestError("Fail to remove netdev %s" % n_id)
def nic_add(vm, model, netdev_id, mac, rom=None):
"""
Add a nic to virtual machine
@vm: VM object
@model: nic model
@netdev_id: id of netdev
@mac: Mac address of new nic
@rom: Rom file
"""
nic_id = virt_utils.generate_random_id()
if model == "virtio":
model = "virtio-net-pci"
device_add_cmd = "device_add %s,netdev=%s,mac=%s,id=%s" % (
model, netdev_id, mac, nic_id)
if rom:
device_add_cmd += ",romfile=%s" % rom
logging.info("Adding nic through %s", device_add_cmd)
vm.monitor.cmd(device_add_cmd)
qdev = vm.monitor.info("qtree")
if not nic_id in qdev:
logging.error(qdev)
raise error.TestFail("Device %s was not plugged into qdev"
"tree" % nic_id)
else:
return nic_id
def nic_del(vm, nic_id, wait=True):
"""
Remove the nic from pci tree.
@vm: VM object
@id: the nic id
@wait: Whether need to wait for the guest to unplug the device
"""
nic_del_cmd = "device_del %s" % nic_id
vm.monitor.cmd(nic_del_cmd)
if wait:
logging.info("waiting for the guest to finish the unplug")
if not virt_utils.wait_for(
lambda: nic_id not in vm.monitor.info("qtree"),
guest_delay, 5, 1):
logging.error(vm.monitor.info("qtree"))
raise error.TestError("Device is not unplugged by "
"guest, please check whether the "
"hotplug module was loaded in guest")
logging.info("Attach a virtio nic to vm")
mac = virt_utils.generate_mac_address(vm.instance, 1)
if not mac:
mac = "00:00:02:00:00:02"
netdev_id = netdev_add(vm)
device_id = nic_add(vm, "virtio", netdev_id, mac, romfile)
if "Win" not in params.get("guest_name", ""):
session.sendline("dhclient %s &" %
virt_test_utils.get_linux_ifname(session, mac))
logging.info("Shutting down the primary link")
vm.monitor.cmd("set_link %s down" % vm.netdev_id[0])
try:
logging.info("Waiting for new nic's ip address acquisition...")
if not virt_utils.wait_for(
lambda: (vm.address_cache.get(mac) is not None), 10, 1):
raise error.TestFail("Could not get ip address of new nic")
ip = vm.address_cache.get(mac)
if not virt_utils.verify_ip_address_ownership(ip, mac):
raise error.TestFail("Could not verify the ip address of new nic")
else:
logging.info("Got the ip address of new nic: %s", ip)
logging.info("Ping test the new nic ...")
s, o = virt_test_utils.ping(ip, 100)
if s != 0:
logging.error(o)
raise error.TestFail("New nic failed ping test")
logging.info("Detaching a virtio nic from vm")
nic_del(vm, device_id)
netdev_del(vm, netdev_id)
finally:
vm.free_mac_address(1)
logging.info("Re-enabling the primary link")
vm.monitor.cmd("set_link %s up" % vm.netdev_id[0])
def run_nic_hotplug(test, params, env):
"""
Test hotplug of NIC devices
1) Boot up guest with one nic
2) Add a host network device through monitor cmd and check if it's added
3) Add nic device through monitor cmd and check if it's added
4) Check if new interface gets ip address
5) Disable primary link of guest
6) Ping guest new ip from host
7) Delete nic device and netdev
8) Re-enable primary link of guest
@param test: KVM test object.
@param params: Dictionary with the test parameters.
@param env: Dictionary with test environment.
"""
vm = virt_test_utils.get_living_vm(env, params.get("main_vm"))
timeout = int(params.get("login_timeout", 360))
guest_delay = int(params.get("guest_delay", 20))
session = virt_test_utils.wait_for_login(vm, timeout=timeout)
romfile = params.get("romfile")
# Modprobe the module if specified in config file
module = params.get("modprobe_module")
if module:
session.get_command_output("modprobe %s" % module)
def netdev_add(vm):
netdev_id = virt_utils.generate_random_id()
attach_cmd = ("netdev_add tap,id=%s" % netdev_id)
nic_script = params.get("nic_script")
if nic_script:
attach_cmd += ",script=%s" % virt_utils.get_path(vm.root_dir,
nic_script)
netdev_extra_params = params.get("netdev_extra_params")
if netdev_extra_params:
attach_cmd += ",%s" % netdev_extra_params
logging.info("Adding netdev through %s", attach_cmd)
vm.monitor.cmd(attach_cmd)
network = vm.monitor.info("network")
if netdev_id not in network:
logging.error(network)
raise error.TestError("Fail to add netdev: %s" % netdev_id)
else:
return netdev_id
def netdev_del(vm, n_id):
vm.monitor.cmd("netdev_del %s" % n_id)
network = vm.monitor.info("network")
if n_id in network:
logging.error(network)
raise error.TestError("Fail to remove netdev %s" % n_id)
def nic_add(vm, model, netdev_id, mac, rom=None):
"""
Add a nic to virtual machine
@vm: VM object
@model: nic model
@netdev_id: id of netdev
@mac: Mac address of new nic
@rom: Rom file
"""
nic_id = virt_utils.generate_random_id()
if model == "virtio":
model = "virtio-net-pci"
device_add_cmd = "device_add %s,netdev=%s,mac=%s,id=%s" % (model,
netdev_id,
mac, nic_id)
if rom:
device_add_cmd += ",romfile=%s" % rom
logging.info("Adding nic through %s", device_add_cmd)
vm.monitor.cmd(device_add_cmd)
qdev = vm.monitor.info("qtree")
if not nic_id in qdev:
logging.error(qdev)
raise error.TestFail("Device %s was not plugged into qdev"
"tree" % nic_id)
else:
return nic_id
def nic_del(vm, nic_id, wait=True):
"""
Remove the nic from pci tree.
@vm: VM object
@id: the nic id
@wait: Whether need to wait for the guest to unplug the device
"""
nic_del_cmd = "device_del %s" % nic_id
vm.monitor.cmd(nic_del_cmd)
if wait:
logging.info("waiting for the guest to finish the unplug")
if not virt_utils.wait_for(lambda: nic_id not in
vm.monitor.info("qtree"),
guest_delay, 5 ,1):
logging.error(vm.monitor.info("qtree"))
raise error.TestError("Device is not unplugged by "
"guest, please check whether the "
"hotplug module was loaded in guest")
logging.info("Attach a virtio nic to vm")
mac = virt_utils.generate_mac_address(vm.instance, 1)
if not mac:
mac = "00:00:02:00:00:02"
netdev_id = netdev_add(vm)
device_id = nic_add(vm, "virtio", netdev_id, mac, romfile)
if "Win" not in params.get("guest_name", ""):
session.sendline("dhclient %s &" %
virt_test_utils.get_linux_ifname(session, mac))
logging.info("Shutting down the primary link")
vm.monitor.cmd("set_link %s down" % vm.netdev_id[0])
try:
logging.info("Waiting for new nic's ip address acquisition...")
if not virt_utils.wait_for(lambda: (vm.address_cache.get(mac) is
not None), 10, 1):
raise error.TestFail("Could not get ip address of new nic")
ip = vm.address_cache.get(mac)
if not virt_utils.verify_ip_address_ownership(ip, mac):
raise error.TestFail("Could not verify the ip address of new nic")
else:
logging.info("Got the ip address of new nic: %s", ip)
logging.info("Ping test the new nic ...")
s, o = virt_test_utils.ping(ip, 100)
if s != 0:
logging.error(o)
raise error.TestFail("New nic failed ping test")
logging.info("Detaching a virtio nic from vm")
nic_del(vm, device_id)
netdev_del(vm, netdev_id)
finally:
vm.free_mac_address(1)
logging.info("Re-enabling the primary link")
vm.monitor.cmd("set_link %s up" % vm.netdev_id[0])
finally:
utils.run("umount %s" % mem_path)
test_config = virt_test_setup.TransparentHugePageConfig(test, params)
logging.info("Defrag test start")
login_timeout = float(params.get("login_timeout", 360))
mem_path = os.path.join("/tmp", "thp_space")
try:
test_config.setup()
error.context("deactivating khugepaged defrag functionality")
change_feature_status("off", "khugepaged/defrag", test_config)
change_feature_status("off", "defrag", test_config)
vm = virt_test_utils.get_living_vm(env, params.get("main_vm"))
session = virt_test_utils.wait_for_login(vm, timeout=login_timeout)
fragment_host_memory(mem_path)
total = get_mem_stat('MemTotal')
hugepagesize = get_mem_stat('Hugepagesize')
nr_full = int(0.8 * (total / hugepagesize))
nr_hp_before = set_libhugetlbfs(nr_full)
error.context("activating khugepaged defrag functionality")
change_feature_status("on", "khugepaged/defrag", test_config)
change_feature_status("on", "defrag", test_config)
sleep_time = 10
utils.run(cmd)
finally:
utils.run("umount %s" % mem_path)
test_config = virt_test_setup.TransparentHugePageConfig(test, params)
logging.info("Defrag test start")
login_timeout = float(params.get("login_timeout", 360))
mem_path = os.path.join("/tmp", "thp_space")
try:
test_config.setup()
error.context("deactivating khugepaged defrag functionality")
change_feature_status("off", "khugepaged/defrag", test_config)
change_feature_status("off", "defrag", test_config)
vm = virt_test_utils.get_living_vm(env, params.get("main_vm"))
session = virt_test_utils.wait_for_login(vm, timeout=login_timeout)
fragment_host_memory(mem_path)
total = get_mem_stat('MemTotal')
hugepagesize = get_mem_stat('Hugepagesize')
nr_full = int(0.8 * (total / hugepagesize))
nr_hp_before = set_libhugetlbfs(nr_full)
error.context("activating khugepaged defrag functionality")
change_feature_status("on", "khugepaged/defrag", test_config)
change_feature_status("on", "defrag", test_config)
sleep_time = 10
