def _generate_usb_redir_cmdline():
extra_params = ''
_backend = 'socket' if 'socket' in backend else backend
chardev_id = usbredir_params.get("chardev_id",
"chardev_%s" % usbredirdev_name)
chardev_params = Params({'backend': _backend, 'id': chardev_id})
if backend == 'spicevmc':
chardev_params['debug'] = usbredir_params.get('chardev_debug')
chardev_params['name'] = usbredir_params.get('chardev_name')
else:
chardev_params['host'] = usbredir_params['chardev_host']
chardev_params['port'] = free_port
chardev_params['server'] = usbredir_params.get(
'chardev_server')
chardev_params['wait'] = usbredir_params.get('chardev_wait')
chardev = qdevices.CharDevice(chardev_params, chardev_id)
usbredir_dev = qdevices.QDevice('usb-redir',
aobject=usbredirdev_name)
usbredir_filter = usbredir_params.get("usbdev_option_filter")
usbredir_bootindex = usbredir_params.get("usbdev_option_bootindex")
usbredir_bus = usbredir_params.get("usb_bus")
usbredir_dev.set_param('id', 'usb-%s' % usbredirdev_name)
usbredir_dev.set_param('chardev', chardev_id)
usbredir_dev.set_param('filter', usbredir_filter)
usbredir_dev.set_param('bootindex', usbredir_bootindex)
usbredir_dev.set_param('bus', usbredir_bus)
extra_params += ' '.join(
[chardev.cmdline(), usbredir_dev.cmdline()])
return extra_params
def run(test, params, env):
"""
Test hotplug of balloon devices.
1) Boot up guest w/o balloon device.
2) Hoplug balloon device and check hotplug successfully or not.
3) Do memory balloon.
4) Unplug balloon device and check unplug successfully or not.
:param test: QEMU test object.
:param params: Dictionary with the test parameters.
:param env: Dictionary with test environment.
"""
pause = float(params.get("virtio_balloon_pause", 3.0))
idx = 0
err = ""
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
error_context.context("Hotplug and unplug balloon device in a loop",
logging.info)
for i in xrange(int(params.get("balloon_repeats", 3))):
vm.devices.set_dirty()
new_dev = qdevices.QDevice("virtio-balloon-pci",
{'id': 'balloon%d' % idx},
parent_bus={'aobject': 'pci.0'})
error_context.context("Hotplug balloon device for %d times" % (i + 1),
logging.info)
out = new_dev.hotplug(vm.monitor)
if out:
err += "\nHotplug monitor output: %s" % out
# Pause
time.sleep(pause)
ver_out = new_dev.verify_hotplug(out, vm.monitor)
if not ver_out:
err += ("\nDevice is not in qtree %ss after hotplug:\n%s" %
(pause, vm.monitor.info("qtree")))
error_context.context(
"Check whether balloon device work after hotplug", logging.info)
balloon_check.run(test, params, env)
error_context.context("Unplug balloon device for %d times" % (i + 1),
logging.info)
out = new_dev.unplug(vm.monitor)
if out:
err += "\nUnplug monitor output: %s" % out
# Pause
time.sleep(pause)
ver_out = new_dev.verify_unplug(out, vm.monitor)
if not ver_out:
err += ("\nDevice is still in qtree %ss after unplug:\n%s" %
(pause, vm.monitor.info("qtree")))
if err:
logging.error(vm.monitor.info("qtree"))
raise exceptions.TestFail("Error occurred while hotpluging "
"virtio-pci. Iteration %s, monitor "
"output:%s" % (i, err))
def run(test, params, env):
"""
Test hotplug/unplug of rng device
1) Boot up w/o rng device
2) Hotplug one or more rng devices
3) Run random read test after hotplug
4) Unplug rng devices
5) Repeat step 2 ~ step4 (option)
:param test: QEMU test object
:param params: Dictionary with the test parameters
:param env: Dictionary with test environment
"""
login_timeout = int(params.get("login_timeout", 360))
repeat_times = int(params.get("repeat_times", 1))
rng_num = int(params.get("rng_num", 1))
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
vm.wait_for_login(timeout=login_timeout)
for i in xrange(repeat_times):
dev_list = []
logging.info("Hotplug/unplug rng devices the %sth times", (i + 1))
for num in xrange(rng_num):
vm.devices.set_dirty()
new_dev = qdevices.QDevice("virtio-rng-pci",
{'id': 'virtio-rng-pci-%d' % num})
dev_list.append(new_dev)
error_context.context("Hotplug %s" % new_dev, logging.info)
output = new_dev.hotplug(vm.monitor)
time.sleep(2)
error_context.context("Check %sfrom qtree after hotplug" % new_dev,
logging.info)
qtree_output = new_dev.verify_hotplug(output, vm.monitor)
if not qtree_output:
msg = "no % device in qtree after hotplug"
msg += "the %sth time" % (new_dev, i)
raise exceptions.TestFail(msg)
logging.info("virtio-rng-pci-%d is hotpluged successfully" % num)
sub_test = params.get("sub_test_after_hotplug")
if sub_test:
utils_test.run_virt_sub_test(test, params, env, sub_test)
for dev in dev_list:
error_context.context("Unplug %s" % dev, logging.info)
output = dev.unplug(vm.monitor)
time.sleep(2)
error_context.context("Check rng device from qtree after unplug",
logging.info)
qtree_output = dev.verify_unplug(output, vm.monitor)
if not qtree_output:
msg = "Still get %s in qtree after unplug %s times" % (dev, i)
raise exceptions.TestFail(msg)
logging.info("%s is unpluged successfully" % dev)
def test_pci(self):
qdev = self.create_qdev('vm1')
devs = qdev.machine_by_params(ParamsDict({'machine_type': 'pc'}))
for dev in devs:
qdev.insert(dev)
# machine creates main pci (pci.0)
# buses root.1 pci_switch pci_bridge
# root.1: ioh3420(pci.0)
# pci_switch: x3130(root.1)
# pci_bridge: pci-bridge(root.1)
devs = qdev.pcic_by_params('root.1', {'pci_bus': 'pci.0',
'type': 'ioh3420'})
qdev.insert(devs)
devs = qdev.pcic_by_params('pci_switch', {'pci_bus': 'root.1',
'type': 'x3130'})
qdev.insert(devs)
devs = qdev.pcic_by_params('pci_bridge', {'pci_bus': 'root.1',
'type': 'pci-bridge'})
qdev.insert(devs)
qdev.insert(qdevices.QDevice("ahci", {'id': 'in_bridge'},
parent_bus={'type': ('PCI', 'PCIE'),
'aobject': 'pci_bridge'}))
qdev.insert(qdevices.QDevice("ahci", {'id': 'in_switch1'},
parent_bus={'type': ('PCI', 'PCIE'),
'aobject': 'pci_switch'}))
qdev.insert(qdevices.QDevice("ahci", {'id': 'in_switch2'},
parent_bus={'type': ('PCI', 'PCIE'),
'aobject': 'pci_switch'}))
qdev.insert(qdevices.QDevice("ahci", {'id': 'in_switch3'},
parent_bus={'type': ('PCI', 'PCIE'),
'aobject': 'pci_switch'}))
qdev.insert(qdevices.QDevice("ahci", {'id': 'in_root1'},
parent_bus={'type': ('PCI', 'PCIE'),
'aobject': 'root.1'}))
qdev.insert(qdevices.QDevice("ahci", {'id': 'in_pci.0'},
parent_bus={'type': ('PCI', 'PCIE'),
'aobject': 'pci.0'}))
exp = ("-machine pc -device ioh3420,id=root.1,bus=pci.0,addr=02 "
"-device x3130-upstream,id=pci_switch,bus=root.1,addr=00 "
"-device pci-bridge,id=pci_bridge,bus=root.1,addr=01,"
"chassis_nr=1 -device ahci,id=in_bridge,bus=pci_bridge,addr=01"
" -device xio3130-downstream,bus=pci_switch,id=pci_switch.0,"
"addr=00,chassis=1 -device ahci,id=in_switch1,bus=pci_switch.0"
",addr=00 "
"-device xio3130-downstream,bus=pci_switch,id=pci_switch.1,"
"addr=01,chassis=2 -device ahci,id=in_switch2,bus=pci_switch.1"
",addr=00 "
"-device xio3130-downstream,bus=pci_switch,id=pci_switch.2,"
"addr=02,chassis=3 -device ahci,id=in_switch3,bus=pci_switch.2"
",addr=00 "
"-device ahci,id=in_root1,bus=root.1,addr=02 "
"-device ahci,id=in_pci.0,bus=pci.0,addr=03")
out = qdev.cmdline()
assert out == exp, (out, exp)
def test_qdev_equal(self):
qdev1 = self.create_qdev('vm1', allow_hotplugged_vm='no')
qdev2 = self.create_qdev('vm1', allow_hotplugged_vm='no')
qdev3 = self.create_qdev('vm1', allow_hotplugged_vm='yes')
monitor = MockHMPMonitor()
assert qdev1 == qdev2, ("Init qdevs are not alike\n%s\n%s" %
(qdev1.str_long(), qdev2.str_long()))
# Insert a device to qdev1
dev = qdevices.QDevice('dev1', {'id': 'dev1'})
qdev1.insert(dev)
assert qdev1 != qdev2, ("Different qdevs match:\n%s\n%s" %
(qdev1.str_long(), qdev2.str_long()))
# Insert similar device to qdev2
dev = qdevices.QDevice('dev1', {'id': 'dev1'})
qdev2.insert(dev)
assert qdev1 == qdev2, ("Similar qdevs are not alike\n%s\n%s" %
(qdev1.str_long(), qdev2.str_long()))
# Hotplug similar device to qdev3
dev = qdevices.QDevice('dev1', {'id': 'dev1'})
dev.hotplug = lambda _monitor: "" # override the hotplug method
dev.verify_hotplug = lambda _out, _monitor: True
qdev3.simple_hotplug(dev, monitor)
assert qdev1 == qdev3, ("Similar hotplugged qdevs are not alike\n%s\n"
"%s" % (qdev1.str_long(), qdev2.str_long()))
# Eq. is not symmetrical, qdev1 doesn't allow hotplugged VMs.
assert qdev3 != qdev1, ("Similar hotplugged qdevs match even thought "
"qdev1 doesn't allow hotplugged VM\n%s\n%s" %
(qdev1.str_long(), qdev2.str_long()))
qdev2.__qemu_help = "I support only this :-)" # pylint: disable=W0212
assert qdev1 == qdev2, ("qdevs of different qemu versions match:\n%s\n"
"%s" % (qdev1.str_long(), qdev2.str_long()))
def run(test, params, env):
"""
hotplug guest agent device
:param test: kvm test object
:param params: Dictionary with the test parameters
:param env: Dictionary with test environment.
"""
def check_status_unplug(out, dev):
if out is True:
logging.debug("Unplug %s successfully", dev)
else:
test.fail("Error occurred while unpluging %s" % dev)
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
char_backend = params["backend_char_plug"]
char_id = params["id_char_plug"]
gagent_name = params["gagent_name"]
char_path = vm.get_serial_console_filename(gagent_name)
params["path_char_plug"] = char_path
dev_driver = params["dev_driver"]
dev_id = params["dev_id"]
error_context.context("hotplug guest agent device", logging.info)
params_char_plug = params.object_params("char_plug")
chardev = qdevices.CharDevice(params=params_char_plug)
chardev.hotplug(vm.monitor, vm.devices.qemu_version)
device = qdevices.QDevice(dev_driver)
device.set_param("chardev", char_id)
device.set_param("id", dev_id)
device.set_param("name", gagent_name)
device.hotplug(vm.monitor, vm.devices.qemu_version)
error_context.context("install and start guest agent", logging.info)
guest_agent_run(test, params, env)
error_context.context("hot unplug guest agent device", logging.info)
device.unplug(vm.monitor)
device_status = device.verify_unplug("", vm.monitor)
check_status_unplug(device_status, "virtserialport")
time.sleep(3)
chardev.unplug(vm.monitor)
chardev_status = chardev.verify_unplug("", vm.monitor)
check_status_unplug(chardev_status, "socket")
vm.verify_alive()
def test_q_device(self):
""" QDevice tests """
qdevice = qdevices.QDevice('ahci', {'addr': '0x7'})
self.assertEqual(str(qdevice), "a'ahci'", "Alternative name error %s "
"!= %s" % (str(qdevice), "a'ahci'"))
qdevice['id'] = 'ahci1'
self.assertEqual(str(qdevice), "q'ahci1'", "Id name error %s "
"!= %s" % (str(qdevice), "q'ahci1'"))
exp = "device_add ahci,addr=0x7,id=ahci1"
out = qdevice.hotplug_hmp()
self.assertEqual(out, exp, "HMP command corrupted:\n%s\n%s"
% (out, exp))
exp = ("('device_add', OrderedDict([('addr', '0x7'), "
"('driver', 'ahci'), ('id', 'ahci1')]))")
out = str(qdevice.hotplug_qmp())
self.assertEqual(out, exp, "QMP command corrupted:\n%s\n%s"
% (out, exp))
def run(test, params, env):
"""
Test hotplug of block devices.
1) Boot up guest with/without block device(s).
2) Hoplug block device and verify
3) Do read/write data on hotplug block.
4) Unplug block device and verify
:param test: QEMU test object.
:param params: Dictionary with the test parameters.
:param env: Dictionary with test environment.
"""
def find_image(image_name):
"""
Find the path of the iamge.
"""
image_params = params.object_params(image_name)
o = storage.get_image_filename(image_params, data_dir.get_data_dir())
return o
def find_disk(vm, cmd):
"""
Find all disks in guest.
"""
if params.get("os_type") == "linux":
pattern = params.get("get_disk_pattern", "^/dev/vd[a-z]*$")
elif params.get("os_type") == "windows":
pattern = "^\d+"
cmd = params.get("get_disk_index", "wmic diskdrive get index")
else:
test.cancel("Unsupported OS type '%s'" % params.get("os_type"))
session = vm.wait_for_login(timeout=timeout)
output = session.cmd_output_safe(cmd)
disks = re.findall(pattern, output, re.M)
session.close()
return disks
def get_new_disk(disk1, disk2):
"""
Get the different disk between disk1 and disk2.
"""
disk = list(set(disk2).difference(set(disk1)))
return disk
img_list = params.get("images").split()
img_format_type = params.get("img_format_type", "qcow2")
pci_type = params.get("pci_type", "virtio-blk-pci")
#sometimes, ppc can't get new plugged disk in 5s, so time to 10s
pause = float(params.get("virtio_block_pause", 10.0))
blk_num = int(params.get("blk_num", 1))
repeat_times = int(params.get("repeat_times", 3))
timeout = int(params.get("login_timeout", 360))
disk_op_timeout = int(params.get("disk_op_timeout", 360))
get_disk_cmd = params.get("get_disk_cmd")
context_msg = "Running sub test '%s' %s"
device_list = []
disk_index = params.objects("disk_index")
disk_letter = params.objects("disk_letter")
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
for iteration in xrange(repeat_times):
error_context.context(
"Hotplug block device (iteration %d)" % iteration, logging.info)
sub_type = params.get("sub_type_before_plug")
if sub_type:
error_context.context(context_msg % (sub_type, "before hotplug"),
logging.info)
utils_test.run_virt_sub_test(test, params, env, sub_type)
for num in xrange(blk_num):
device = qdevices.QDevice(pci_type)
if params.get("need_plug") == "yes":
disks_before_plug = find_disk(vm, get_disk_cmd)
if params.get("need_controller", "no") == "yes":
controller_model = params.get("controller_model")
controller = qdevices.QDevice(controller_model)
bus_extra_param = params.get("bus_extra_params_%s" %
img_list[num + 1])
# TODO:Add iothread support for qdevice
if bus_extra_param and "iothread" in bus_extra_param:
match = re.search("iothread=(\w+)", bus_extra_param)
if match:
qdevice_params = {"iothread": match.group(1)}
controller.params.update(qdevice_params)
controller.hotplug(vm.monitor)
ver_out = controller.verify_hotplug("", vm.monitor)
if not ver_out:
err = "%s is not in qtree after hotplug" % controller_model
test.fail(err)
drive = qdevices.QRHDrive("block%d" % num)
drive.set_param("file", find_image(img_list[num + 1]))
drive.set_param("format", img_format_type)
drive_id = drive.get_param("id")
drive.hotplug(vm.monitor)
device.set_param("drive", drive_id)
device.set_param("id", "block%d" % num)
blk_extra_param = params.get("blk_extra_params_%s" %
img_list[num + 1])
if blk_extra_param and "iothread" in blk_extra_param:
match = re.search("iothread=(\w+)", blk_extra_param)
if match:
device.set_param("iothread", match.group(1))
device.hotplug(vm.monitor)
ver_out = device.verify_hotplug("", vm.monitor)
if not ver_out:
err = "%s is not in qtree after hotplug" % pci_type
test.fail(err)
plug_status = utils_misc.wait_for(
lambda: len(
get_new_disk(disks_before_plug,
find_disk(vm, get_disk_cmd))) != 0, pause)
if plug_status:
disks_after_plug = find_disk(vm, get_disk_cmd)
new_disks = get_new_disk(disks_before_plug,
disks_after_plug)
else:
test.fail("Can't get new disks")
else:
if params.get("drive_format") in pci_type:
get_disk_cmd += " | egrep -v '^/dev/[hsv]da[0-9]*$'"
device.set_param("id", img_list[num + 1])
new_disks = find_disk(vm, get_disk_cmd)
device_list.append(device)
if not new_disks:
test.fail("Cannot find new disk after hotplug.")
if params.get("need_plug") == "yes":
disk = new_disks[0]
else:
disk = new_disks[num]
session = vm.wait_for_login(timeout=timeout)
if params.get("os_type") == "windows":
if iteration == 0:
error_context.context("Format disk", logging.info)
utils_misc.format_windows_disk(session,
disk_index[num],
mountpoint=disk_letter[num])
error_context.context("Check block device after hotplug.",
logging.info)
if params.get("disk_op_cmd"):
if params.get("os_type") == "linux":
test_cmd = params.get("disk_op_cmd") % (disk, disk)
elif params.get("os_type") == "windows":
test_cmd = params.get("disk_op_cmd") % (disk_letter[num],
disk_letter[num])
test_cmd = utils_misc.set_winutils_letter(
session, test_cmd)
else:
test.cancel("Unsupported OS type '%s'" %
params.get("os_type"))
status, output = session.cmd_status_output(
test_cmd, timeout=disk_op_timeout)
if status:
test.fail("Check for block device failed "
"after hotplug, Output: %r" % output)
session.close()
sub_type = params.get("sub_type_after_plug")
if sub_type:
error_context.context(context_msg % (sub_type, "after hotplug"),
logging.info)
utils_test.run_virt_sub_test(test, params, env, sub_type)
if vm.is_dead():
return
sub_type = params.get("sub_type_before_unplug")
if sub_type:
error_context.context(context_msg % (sub_type, "before unplug"),
logging.info)
utils_test.run_virt_sub_test(test, params, env, sub_type)
for num in xrange(blk_num):
error_context.context(
"Unplug block device (iteration %d)" % iteration, logging.info)
disks_before_unplug = find_disk(vm, get_disk_cmd)
device_list[num].unplug(vm.monitor)
device_list[num].verify_unplug("", vm.monitor)
unplug_status = utils_misc.wait_for(
lambda: len(
get_new_disk(find_disk(vm, get_disk_cmd),
disks_before_unplug)) != 0, pause)
if not unplug_status:
test.fail("Failed to unplug disks")
sub_type = params.get("sub_type_after_unplug")
if sub_type:
error_context.context(context_msg % (sub_type, "after unplug"),
logging.info)
utils_test.run_virt_sub_test(test, params, env, sub_type)
def run(test, params, env):
"""
Test hotplug of block devices.
1) Boot up guest with/without block device(s).
2) Hoplug block device and verify
3) Do read/write data on hotplug block.
4) Unplug block device and verify
:param test: QEMU test object.
:param params: Dictionary with the test parameters.
:param env: Dictionary with test environment.
"""
def find_image(image_name):
"""
Find the path of the iamge.
"""
image_params = params.object_params(image_name)
o = storage.get_image_filename(image_params, data_dir.get_data_dir())
return o
def find_disk(vm, cmd):
"""
Find all disks in guest.
"""
if params.get("os_type") == "linux":
pattern = params.get("get_disk_pattern", "^/dev/vd[a-z]*$")
else:
pattern = "^\d+"
cmd = params.get("get_disk_index", "wmic diskdrive get index")
session = vm.wait_for_login(timeout=timeout)
output = session.cmd_output_safe(cmd)
disks = re.findall(pattern, output, re.M)
session.close()
return disks
def get_new_disk(disk1, disk2):
"""
Get the different disk between disk1 and disk2.
"""
disk = list(set(disk2).difference(set(disk1)))
return disk
img_list = params.get("images").split()
img_format_type = params.get("img_format_type", "qcow2")
pci_type = params.get("pci_type", "virtio-blk-pci")
pause = float(params.get("virtio_block_pause", 5.0))
blk_num = int(params.get("blk_num", 1))
repeat_times = int(params.get("repeat_times", 3))
timeout = int(params.get("login_timeout", 360))
disk_op_timeout = int(params.get("disk_op_timeout", 360))
get_disk_cmd = params.get("get_disk_cmd")
context_msg = "Running sub test '%s' %s"
device_list = []
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
for i in xrange(repeat_times):
error_context.context("Hotplug block device (iteration %d)" % i,
logging.info)
sub_type = params.get("sub_type_before_plug")
if sub_type:
error_context.context(context_msg % (sub_type, "before hotplug"),
logging.info)
utils_test.run_virt_sub_test(test, params, env, sub_type)
for num in xrange(blk_num):
device = qdevices.QDevice(pci_type)
if params.get("need_plug") == "yes":
if params.get("need_controller", "no") == "yes":
controller_model = params.get("controller_model")
controller = qdevices.QDevice(controller_model)
controller.hotplug(vm.monitor)
ver_out = controller.verify_hotplug("", vm.monitor)
if not ver_out:
err = "%s is not in qtree after hotplug" % controller_model
raise exceptions.TestFail(err)
disks_before_plug = find_disk(vm, get_disk_cmd)
drive = qdevices.QRHDrive("block%d" % num)
drive.set_param("file", find_image(img_list[num + 1]))
drive.set_param("format", img_format_type)
drive_id = drive.get_param("id")
drive.hotplug(vm.monitor)
device.set_param("drive", drive_id)
device.set_param("id", "block%d" % num)
device.hotplug(vm.monitor)
ver_out = device.verify_hotplug("", vm.monitor)
if not ver_out:
err = "%s is not in qtree after hotplug" % pci_type
raise exceptions.TestFail(err)
time.sleep(pause)
disks_after_plug = find_disk(vm, get_disk_cmd)
new_disks = get_new_disk(disks_before_plug, disks_after_plug)
else:
if params.get("drive_format") in pci_type:
get_disk_cmd += " | egrep -v '^/dev/[hsv]da[0-9]*$'"
device.set_param("id", img_list[num + 1])
new_disks = find_disk(vm, get_disk_cmd)
device_list.append(device)
if not new_disks:
raise exceptions.TestFail(
"Cannot find new disk after hotplug.")
if params.get("need_plug") == "yes":
disk = new_disks[0]
else:
disk = new_disks[num]
error_context.context("Check block device after hotplug.",
logging.info)
if params.get("pci_test_cmd"):
if params.get("os_type") == "linux":
test_cmd = params.get("pci_test_cmd") % (disk, disk)
else:
test_cmd = re.sub("PCI_NUM", "%s" % (num + 1),
params.get("pci_test_cmd"))
session = vm.wait_for_login(timeout=timeout)
s, o = session.cmd_status_output(test_cmd,
timeout=disk_op_timeout)
session.close()
if s:
raise exceptions.TestFail("Check for block device failed "
"after hotplug, Output: %r" % o)
sub_type = params.get("sub_type_after_plug")
if sub_type:
error_context.context(context_msg % (sub_type, "after hotplug"),
logging.info)
utils_test.run_virt_sub_test(test, params, env, sub_type)
sub_type = params.get("sub_type_before_unplug")
if sub_type:
error_context.context(context_msg % (sub_type, "before unplug"),
logging.info)
utils_test.run_virt_sub_test(test, params, env, sub_type)
for num in xrange(blk_num):
error_context.context("Unplug block device (iteration %d)" % i,
logging.info)
device_list[num].unplug(vm.monitor)
device_list[num].verify_unplug("", vm.monitor)
time.sleep(pause)
sub_type = params.get("sub_type_after_unplug")
if sub_type:
error_context.context(context_msg % (sub_type, "after unplug"),
logging.info)
utils_test.run_virt_sub_test(test, params, env, sub_type)
def run(test, params, env):
"""
Test hotplug of balloon devices.
1) Boot up guest w/o balloon device.
2) Hoplug balloon device and check hotplug successfully or not.
3) Do memory balloon.
4) Reboot/shutdown guest after hotplug balloon device(option)
5) Do memory balloon after guest reboot(option)
6) Unplug balloon device and check unplug successfully or not.
7) Reboot/shutdown guest after unplug balloon device(option)
:param test: QEMU test object.
:param params: Dictionary with the test parameters.
:param env: Dictionary with test environment.
"""
def run_pm_test(pm_test, plug_type):
"""
Run pm(reboot/system_reset/shutdown) related test after balloon
device is hot-plug or hot-unplug
:param pm_test: power management test name,e.g. reboot/shutdown
:param plug_type:balloon device plug operation,e.g.hot_plug or hot_unplug
"""
error_context.context(
"Run %s test after %s balloon device" % (pm_test, plug_type),
logging.info)
utils_test.run_virt_sub_test(test, params, env, pm_test)
pause = float(params.get("virtio_balloon_pause", 3.0))
pm_test_after_plug = params.get("pm_test_after_plug")
pm_test_after_unplug = params.get("pm_test_after_unplug")
idx = 0
err = ""
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
error_context.context("Hotplug and unplug balloon device in a loop",
logging.info)
for i in xrange(int(params.get("balloon_repeats", 3))):
vm.devices.set_dirty()
new_dev = qdevices.QDevice("virtio-balloon-pci",
{'id': 'balloon%d' % idx},
parent_bus={'aobject': 'pci.0'})
error_context.context("Hotplug balloon device for %d times" % (i + 1),
logging.info)
out = new_dev.hotplug(vm.monitor)
if out:
err += "\nHotplug monitor output: %s" % out
# Pause
time.sleep(pause)
ver_out = new_dev.verify_hotplug(out, vm.monitor)
if not ver_out:
err += ("\nDevice is not in qtree %ss after hotplug:\n%s" %
(pause, vm.monitor.info("qtree")))
error_context.context(
"Check whether balloon device work after hotplug", logging.info)
balloon_check.run(test, params, env)
if pm_test_after_plug:
run_pm_test(pm_test_after_plug, "hot-plug")
# run balloon test after reboot,skip followed test if
# pm_test_after_plug is shutdown
if vm.is_alive():
balloon_check.run(test, params, env)
else:
return
error_context.context("Unplug balloon device for %d times" % (i + 1),
logging.info)
out = new_dev.unplug(vm.monitor)
if out:
err += "\nUnplug monitor output: %s" % out
# Pause
time.sleep(pause)
ver_out = new_dev.verify_unplug(out, vm.monitor)
if not ver_out:
err += ("\nDevice is still in qtree %ss after unplug:\n%s" %
(pause, vm.monitor.info("qtree")))
if err:
logging.error(vm.monitor.info("qtree"))
raise exceptions.TestFail("Error occurred while hotpluging "
"virtio-pci. Iteration %s, monitor "
"output:%s" % (i, err))
else:
if pm_test_after_unplug:
run_pm_test(pm_test_after_unplug, "hot-unplug")
if not vm.is_alive():
return
def run(test, params, env):
"""
Test hotplug of balloon devices.
1) Boot up guest w/o balloon device.
2) Hoplug balloon device and check hotplug successfully or not.
3) Install balloon service and check its status in windows guests.
4) Do memory balloon.
5) Reboot/shutdown guest after hotplug balloon device(option)
6) Do memory balloon after guest reboot(option)
7) Unplug balloon device and check unplug successfully or not.
8) Reboot/shutdown guest after unplug balloon device(option)
:param test: QEMU test object.
:param params: Dictionary with the test parameters.
:param env: Dictionary with test environment.
"""
def run_pm_test(pm_test, plug_type):
"""
Run pm(reboot/system_reset/shutdown) related test after balloon
device is hot-plug or hot-unplug
:param pm_test: power management test name,e.g. reboot/shutdown
:param plug_type:balloon device plug operation,e.g.hot_plug or hot_unplug
"""
error_context.context(
"Run %s test after %s balloon device" % (pm_test, plug_type),
logging.info)
utils_test.run_virt_sub_test(test, params, env, pm_test)
def enable_balloon_service():
"""
Install balloon service and check its status in windows guests
"""
if params['os_type'] != 'windows':
return
error_context.context(
"Install and check balloon service in windows "
"guest", logging.info)
session = vm.wait_for_login()
driver_name = params.get("driver_name", "balloon")
session = utils_test.qemu.windrv_check_running_verifier(
session, vm, test, driver_name)
balloon_test.configure_balloon_service(session)
output = balloon_test.operate_balloon_service(session, "status")
if not re.search(r"running", output.lower(), re.M):
test.error("Ballooon service status is not running")
session.close()
pm_test_after_plug = params.get("pm_test_after_plug")
pm_test_after_unplug = params.get("pm_test_after_unplug")
unplug_timeout = params.get("unplug_timeout", 30)
idx = 0
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
balloon_device = params.get("balloon_device", "virtio-balloon-pci")
error_context.context("Hotplug and unplug balloon device in a loop",
logging.info)
for i in range(int(params.get("balloon_repeats", 3))):
vm.devices.set_dirty()
new_dev = qdevices.QDevice(
balloon_device, {'id': 'balloon%d' % idx},
parent_bus={'aobject': params.get("balloon_bus", 'pci.0')})
error_context.context("Hotplug balloon device for %d times" % (i + 1),
logging.info)
out = vm.devices.simple_hotplug(new_dev, vm.monitor)
if out[1] is False:
test.fail("Failed to hotplug balloon in iteration %s, %s" %
(i, out[0]))
# temporary workaround for migration
vm.params["balloon"] = "balloon%d" % idx
vm.params["balloon_dev_devid"] = "balloon%d" % idx
vm.params["balloon_dev_add_bus"] = "yes"
devs = vm.devices.get_by_params({"id": 'balloon%d' % idx})
vm.params["balloon_pci_bus"] = devs[0]["bus"]
if params['os_type'] == 'windows':
balloon_test = BallooningTestWin(test, params, env)
else:
balloon_test = BallooningTestLinux(test, params, env)
min_sz, max_sz = balloon_test.get_memory_boundary()
enable_balloon_service()
error_context.context(
"Check whether balloon device work after hotplug", logging.info)
balloon_test.balloon_memory(int(random.uniform(min_sz, max_sz)))
if pm_test_after_plug:
run_pm_test(pm_test_after_plug, "hot-plug")
# run balloon test after reboot,skip followed test if
# pm_test_after_plug is shutdown
if vm.is_alive():
balloon_test.balloon_memory(int(random.uniform(min_sz,
max_sz)))
else:
return
if params['os_type'] == 'windows':
time.sleep(10)
error_context.context("Unplug balloon device for %d times" % (i + 1),
logging.info)
out = vm.devices.simple_unplug(devs[0].get_aid(),
vm.monitor,
timeout=unplug_timeout)
if out[1] is False:
test.fail("Failed to unplug balloon in iteration %s, %s" %
(i, out[0]))
time.sleep(2)
if params.get("migrate_after_unplug", "no") == "yes":
error_context.context("Migrate after hotunplug balloon device",
logging.info)
# temporary workaround for migration
del vm.params["balloon"]
del vm.params["balloon_dev_devid"]
del vm.params["balloon_dev_add_bus"]
del vm.params["balloon_pci_bus"]
vm.migrate(float(params.get("mig_timeout", "3600")))
if pm_test_after_unplug:
run_pm_test(pm_test_after_unplug, "hot-unplug")
if not vm.is_alive():
return
error_context.context("Verify guest alive!", logging.info)
vm.verify_kernel_crash()
def run(test, params, env):
"""
Test virtio-fs by sharing the data between host and guest.
Steps:
1. Create shared directories on the host.
2. Set capability on the host.
3. Run virtiofsd daemons on capability shell env.
4. Boot a guest on the host with virtiofs options.
5. Log into guest then mount the virtiofs targets.
6. Generate files or run stress on the mount points inside guest.
:param test: QEMU test object.
:param params: Dictionary with the test parameters.
:param env: Dictionary with test environment.
"""
def get_viofs_exe(session):
"""
Get viofs.exe from virtio win iso,such as E:\viofs\2k19\amd64
"""
media_type = params["virtio_win_media_type"]
try:
get_drive_letter = getattr(virtio_win,
"drive_letter_%s" % media_type)
get_product_dirname = getattr(virtio_win,
"product_dirname_%s" % media_type)
get_arch_dirname = getattr(virtio_win,
"arch_dirname_%s" % media_type)
except AttributeError:
test.error("Not supported virtio win media type '%s'", media_type)
viowin_ltr = get_drive_letter(session)
if not viowin_ltr:
test.error("Could not find virtio-win drive in guest")
guest_name = get_product_dirname(session)
if not guest_name:
test.error("Could not get product dirname of the vm")
guest_arch = get_arch_dirname(session)
if not guest_arch:
test.error("Could not get architecture dirname of the vm")
exe_middle_path = ("{name}\\{arch}" if media_type == "iso" else
"{arch}\\{name}").format(name=guest_name,
arch=guest_arch)
exe_file_name = "virtiofs.exe"
exe_find_cmd = 'dir /b /s %s\\%s | findstr "\\%s\\\\"'
exe_find_cmd %= (viowin_ltr, exe_file_name, exe_middle_path)
exe_path = session.cmd(exe_find_cmd).strip()
logging.info("Found exe file '%s'", exe_path)
return exe_path
# data io config
cmd_dd = params.get('cmd_dd')
cmd_md5 = params.get('cmd_md5')
io_timeout = params.get_numeric('io_timeout')
# remove capability config
cmd_create_fs_source = params.get('cmd_create_fs_source')
cmd_run_virtiofsd = params.get('cmd_run_virtiofsd')
capability = params.get('capability')
cmd_capsh_print = params.get('cmd_capsh_print')
cmd_capsh_drop = params.get('cmd_capsh_drop')
# set trusted config
cmd_yum_attr = params.get('cmd_yum_attr')
cmd_set_trusted = params.get('cmd_set_trusted')
cmd_get_trusted = params.get('cmd_get_trusted')
cmd_create_file = params.get('cmd_create_file')
cmd_set_capability = params.get('cmd_set_capability')
cmd_get_capability = params.get('cmd_get_capability')
cmd_echo_file = params.get('cmd_echo_file')
# set fs daemon path
target = params.get('fs_target')
fs_source = params.get('fs_source_dir')
base_dir = params.get('fs_source_base_dir', data_dir.get_data_dir())
if not os.path.isabs(fs_source):
fs_source = os.path.join(base_dir, fs_source)
if os.path.exists(fs_source):
shutil.rmtree(fs_source, ignore_errors=True)
logging.info("Create filesystem source %s.", fs_source)
os.makedirs(fs_source)
sock_path = os.path.join(
data_dir.get_tmp_dir(), '-'.join(
('avocado-vt-vm1', 'viofs', 'virtiofsd.sock')))
# set capability
cmd_capsh_drop = (cmd_capsh_drop % capability)
error_context.context("Remove capability on host.", logging.info)
session = aexpect.ShellSession(
cmd_capsh_drop,
auto_close=False,
output_func=utils_misc.log_line,
output_params=('virtiofs_fs-virtiofs.log', ),
prompt=r"^\[.*\][\#\$]\s*$")
output = session.cmd_output(cmd_capsh_print)
logging.info("Check current capability is %s.", output)
if capability in output:
test.error("It's failed to check the trusted info from the host.")
# run daemon
session.sendline(cmd_create_fs_source)
cmd_run_virtiofsd = cmd_run_virtiofsd % sock_path
cmd_run_virtiofsd += ' -o source=%s' % fs_source
cmd_run_virtiofsd += params.get('fs_binary_extra_options')
logging.info('Running daemon command %s.', cmd_run_virtiofsd)
session.sendline(cmd_run_virtiofsd)
# insert devices
vm = env.get_vm(params.get("main_vm"))
vm.devices, _ = vm.make_create_command()
machine_type = params.get("machine_type", "")
qbus_type = "PCI"
if machine_type.startswith("q35") or machine_type.startswith("arm64"):
qbus_type = "PCIE"
devices = []
vfsd = qdevices.QCustomDevice('chardev null,id=serial_vfsd',
aobject='fs',
child_bus=qdevices.QUnixSocketBus(
sock_path, 'fs'))
devices.append(vfsd)
char_params = Params()
char_params["backend"] = "socket"
char_params["id"] = 'virtiofs_fs'
sock_bus = {'busid': sock_path}
char = qdevices.CharDevice(char_params, parent_bus=sock_bus)
char.set_aid('virtiofs_fs')
devices.append(char)
qdriver = "vhost-user-fs"
if "-mmio:" in machine_type:
qdriver += "-device"
qbus_type = "virtio-bus"
elif machine_type.startswith("s390"):
qdriver += "-ccw"
qbus_type = "virtio-bus"
else:
qdriver += "-pci"
bus = {"type": qbus_type}
dev_params = {
"id": "vufs_virtiofs_fs",
"chardev": char.get_qid(),
"tag": target
}
fs_driver_props = json.loads(params.get("fs_driver_props", "{}"))
dev_params.update(fs_driver_props)
vufs = qdevices.QDevice(qdriver, params=dev_params, parent_bus=bus)
vufs.set_aid('virtiofs_fs')
devices.append(vufs)
vm.devices.insert(devices)
# Since if 'redirs' has a value, the vm.create() method will reset the devices.
# So set 'redirs' to empty for a workaround.
vm.params['redirs'] = ''
vm.create()
vm.verify_alive()
is_windows = params.get("os_type") == "windows"
session = vm.wait_for_login()
if is_windows:
cmd_timeout = params.get_numeric("cmd_timeout", 120)
driver_name = params["driver_name"]
install_path = params["install_path"]
check_installed_cmd = params["check_installed_cmd"] % install_path
# Check whether windows driver is running,and enable driver verifier
session = utils_test.qemu.windrv_check_running_verifier(
session, vm, test, driver_name)
# Install winfsp tool
error_context.context("Install winfsp for windows guest.",
logging.info)
is_installed = session.cmd_status(check_installed_cmd) == 0
if is_installed:
logging.info("Winfsp tool is already installed.")
else:
install_cmd = utils_misc.set_winutils_letter(
session, params["install_cmd"])
session.cmd(install_cmd, cmd_timeout)
if not utils_misc.wait_for(
lambda: not session.cmd_status(check_installed_cmd), 60):
test.error("Winfsp tool is not installed.")
fs_params = params.object_params('fs')
fs_target = fs_params.get("fs_target")
fs_dest = fs_params.get("fs_dest")
host_data = os.path.join(fs_source, 'fs_test')
if not is_windows:
error_context.context(
"Create a destination directory %s "
"inside guest." % fs_dest, logging.info)
utils_misc.make_dirs(fs_dest, session)
error_context.context(
"Mount virtiofs target %s to %s inside"
" guest." % (fs_target, fs_dest), logging.info)
if not utils_disk.mount(
fs_target, fs_dest, 'virtiofs', session=session):
test.fail('Mount virtiofs target failed.')
else:
error_context.context("Start virtiofs service in guest.", logging.info)
viofs_sc_create_cmd = params["viofs_sc_create_cmd"]
viofs_sc_start_cmd = params["viofs_sc_start_cmd"]
viofs_sc_query_cmd = params["viofs_sc_query_cmd"]
logging.info("Check if virtiofs service is registered.")
status, output = session.cmd_status_output(viofs_sc_query_cmd)
if "not exist as an installed service" in output:
logging.info("Register virtiofs service in windows guest.")
exe_path = get_viofs_exe(session)
viofs_sc_create_cmd = viofs_sc_create_cmd % exe_path
sc_create_s, sc_create_o = session.cmd_status_output(
viofs_sc_create_cmd)
if sc_create_s != 0:
test.fail("Failed to register virtiofs service, output is %s" %
sc_create_o)
logging.info("Check if virtiofs service is started.")
status, output = session.cmd_status_output(viofs_sc_query_cmd)
if "RUNNING" not in output:
logging.info("Start virtiofs service.")
sc_start_s, sc_start_o = session.cmd_status_output(
viofs_sc_start_cmd)
if sc_start_s != 0:
test.fail("Failed to start virtiofs service, output is %s" %
sc_start_o)
else:
logging.info("Virtiofs service is running.")
# get fs dest for vm
virtio_fs_disk_label = fs_target
error_context.context(
"Get Volume letter of virtio fs target, the disk"
"lable is %s." % virtio_fs_disk_label, logging.info)
vol_con = "VolumeName='%s'" % virtio_fs_disk_label
vol_func = utils_misc.get_win_disk_vol(session, condition=vol_con)
volume_letter = utils_misc.wait_for(lambda: vol_func, 120)
if volume_letter is None:
test.fail("Could not get virtio-fs mounted volume letter.")
fs_dest = "%s:" % volume_letter
guest_file = os.path.join(fs_dest, 'fs_test')
logging.info("The guest file in shared dir is %s.", guest_file)
try:
# No extended attributes (file steams) in virtio-fs for windows
if not is_windows:
if cmd_set_trusted:
error_context.context(
"Trusted attribute test without "
"%s for linux guest" % capability, logging.info)
host_attributes = params["host_attributes"]
guest_trusted = params["guest_trusted"]
file_capability = params["file_capability"]
logging.info("Set a trusted on guest.")
session.cmd(cmd_yum_attr)
session.cmd(cmd_set_trusted)
output = session.cmd_output(cmd_get_trusted)
logging.info(
"Failed to check the trusted attribute from "
"guest, the output is %s.", output)
if guest_trusted not in output:
test.fail(
"It's failed to check the trusted info from the guest."
)
process.run(cmd_yum_attr)
output = str(
process.run('getfattr %s' % fs_source).stdout.strip())
logging.info("The host file trusted is %s.", output)
if host_attributes not in output:
test.fail("Failed to check the trusted attribute from "
"host, the output is %s." % output)
session.cmd(cmd_create_file)
error_context.context(
"Privileged capabilities test without "
"%s for linux guest" % capability, logging.info)
session.cmd(cmd_set_capability)
output = session.cmd_output(cmd_get_capability)
logging.info("The guest file capability is %s.", output)
if file_capability not in output:
test.fail("Failed to check the trusted attribute from "
"guest, the output is %s." % output)
logging.info(
"Modify file content and check the file capability.")
session.cmd(cmd_echo_file)
output = session.cmd_output(cmd_get_capability)
logging.info("The guest change file capability is %s.", output)
if file_capability in output:
test.fail(
"Still can get capability after file content is changed."
)
if cmd_dd:
error_context.context(
"Creating file under %s inside guest." % fs_dest, logging.info)
session.cmd(cmd_dd % guest_file, io_timeout)
if not is_windows:
cmd_md5_vm = cmd_md5 % guest_file
else:
guest_file_win = guest_file.replace("/", "\\")
cmd_md5_vm = cmd_md5 % (volume_letter, guest_file_win)
md5_guest = session.cmd_output(cmd_md5_vm,
io_timeout).strip().split()[0]
logging.info(md5_guest)
md5_host = process.run("md5sum %s" % host_data,
io_timeout).stdout_text.strip().split()[0]
if md5_guest != md5_host:
test.fail('The md5 value of host is not same to guest.')
finally:
if not is_windows:
utils_disk.umount(fs_target, fs_dest, 'virtiofs', session=session)
utils_misc.safe_rmdir(fs_dest, session=session)
session.close()
vm.destroy()
utils_misc.safe_rmdir(fs_source)
def test_usb_bus(self):
""" Tests the specific handlings of QUSBBus """
usbc1 = qbuses.QUSBBus(2, 'usb1.0', 'uhci')
# Insert device into usb controller, default port
dev = qdevices.QDevice('usb-kbd', parent_bus={'type': 'uhci'})
assert usbc1.insert(dev) == []
# Insert usb-hub into usb controller, default port
dev = qdevices.QDevice('usb-hub', parent_bus={'type': 'uhci'})
assert usbc1.insert(dev) == []
hub1 = dev.child_bus[-1]
# Insert usb-hub into usb-hub, exact port
dev = qdevices.QDevice('usb-hub', {'port': '2.4'},
parent_bus={'type': 'uhci'})
assert hub1.insert(dev) == []
hub2 = dev.child_bus[-1]
# Insert usb-hub into usb-hub in usb-hub, exact port
dev = qdevices.QDevice('usb-hub', {'port': '2.4.3'},
parent_bus={'type': 'uhci'})
assert hub2.insert(dev) == []
hub3 = dev.child_bus[-1]
# verify that port is updated correctly
self.assertEqual("2.4.3", dev.get_param("port"))
# Insert usb-device into usb-hub in usb-hub in usb-hub, exact port
dev = qdevices.QDevice('usb-kbd', {'port': '2.4.3.1'},
parent_bus={'type': 'uhci'})
assert hub3.insert(dev) == []
# Insert usb-device into usb-hub in usb-hub in usb-hub, default port
dev = qdevices.QDevice('usb-kbd', parent_bus={'type': 'uhci'})
assert hub3.insert(dev) == []
# Try to insert device into specific port which belongs to inferior bus
out = hub2.insert(
qdevices.QDevice('usb-kbd', {'port': '2.4.3.3'},
parent_bus={'type': 'uhci'}))
assert out == "BusId"
# Try to insert device into specific port which belongs to superior bus
out = hub2.insert(
qdevices.QDevice('usb-kbd', {'port': '2.4'},
parent_bus={'type': 'uhci'}))
assert out == "BusId"
# Try to insert device into specific port which belongs to same level
# but different port
out = hub2.insert(
qdevices.QDevice('usb-kbd', {'port': '2.3.4'},
parent_bus={'type': 'uhci'}))
assert out == "BusId"
# Force insert device with port which belongs to other hub
dev = qdevices.QDevice('usb-hub', {'port': '2.4.3.4'},
parent_bus={'type': 'uhci'})
# Check the overall buses correctness
self.assertEqual("usb1.0(uhci): {1:a'usb-kbd',2:a'usb-hub'}",
usbc1.str_short())
self.assertEqual("usb1.0(uhci): {4:a'usb-hub'}", hub1.str_short())
self.assertEqual("usb1.0(uhci): {3:a'usb-hub'}", hub2.str_short())
self.assertEqual("usb1.0(uhci): {1:a'usb-kbd',2:a'usb-kbd'}",
hub3.str_short())
def test_qdev_low_level(self):
""" Test low level functions """
qdev = self.create_qdev('vm1')
# Representation state (used for hotplug or other nasty things)
out = qdev.get_state()
assert out == -1, "qdev state is incorrect %s != %s" % (out, 1)
qdev.set_dirty()
out = qdev.get_state()
self.assertEqual(out, 1, "qdev state is incorrect %s != %s" % (out, 1))
qdev.set_dirty()
out = qdev.get_state()
self.assertEqual(out, 2, "qdev state is incorrect %s != %s" % (out, 1))
qdev.set_clean()
out = qdev.get_state()
self.assertEqual(out, 1, "qdev state is incorrect %s != %s" % (out, 1))
qdev.set_clean()
out = qdev.get_state()
self.assertEqual(out, 0, "qdev state is incorrect %s != %s" % (out, 1))
qdev.reset_state()
out = qdev.get_state()
assert out == -1, "qdev state is incorrect %s != %s" % (out, 1)
# __create_unique_aid
dev = qdevices.QDevice()
qdev.insert(dev)
out = dev.get_aid()
self.assertEqual(out, '__0', "incorrect aid %s != %s" % (out, '__0'))
dev = qdevices.QDevice(None, {'id': 'qid'})
qdev.insert(dev)
out = dev.get_aid()
self.assertEqual(out, 'qid', "incorrect aid %s != %s" % (out, 'qid'))
# has_option
out = qdev.has_option('device')
self.assertEqual(out, True)
out = qdev.has_option('missing_option')
self.assertEqual(out, False)
# has_device
out = qdev.has_device('ide-drive')
self.assertEqual(out, True)
out = qdev.has_device('missing_device')
self.assertEqual(out, False)
# get_help_text
out = qdev.get_help_text()
self.assertEqual(out, QEMU_HELP)
# has_hmp_cmd
self.assertTrue(qdev.has_hmp_cmd('pcie_aer_inject_error'))
self.assertTrue(qdev.has_hmp_cmd('c'))
self.assertTrue(qdev.has_hmp_cmd('cont'))
self.assertFalse(qdev.has_hmp_cmd('off'))
self.assertFalse(qdev.has_hmp_cmd('\ndump-guest-memory'))
self.assertFalse(qdev.has_hmp_cmd('The'))
# has_qmp_cmd
self.assertTrue(qdev.has_qmp_cmd('device_add'))
self.assertFalse(qdev.has_qmp_cmd('RAND91'))
# Add some buses
bus1 = qbuses.QPCIBus('pci.0', 'pci', 'a_pci0')
qdev.insert(qdevices.QDevice(params={'id': 'pci0'}, child_bus=bus1))
bus2 = qbuses.QPCIBus('pci.1', 'pci', 'a_pci1')
qdev.insert(qdevices.QDevice(child_bus=bus2))
bus3 = qbuses.QPCIBus('pci.2', 'pci', 'a_pci2')
qdev.insert(qdevices.QDevice(child_bus=bus3))
bus4 = qbuses.QPCIBus('pcie.0', 'pcie', 'a_pcie0')
qdev.insert(qdevices.QDevice(child_bus=bus4))
# get_buses (all buses of this type)
out = qdev.get_buses({'type': 'pci'})
self.assertEqual(
len(out), 3, 'get_buses should return 3 buses but '
'returned %s instead:\n%s' % (len(out), out))
# get_first_free_bus (last added bus of this type)
out = qdev.get_first_free_bus({'type': 'pci'}, [None, None])
self.assertEqual(bus3, out)
# fill the first pci bus
for _ in xrange(32):
qdev.insert(qdevices.QDevice(parent_bus={'type': 'pci'}))
# get_first_free_bus (last one is full, return the previous one)
out = qdev.get_first_free_bus({'type': 'pci'}, [None, None])
self.assertEqual(bus2, out)
# list_named_buses
out = qdev.list_missing_named_buses('pci.', 'pci', 5)
self.assertEqual(
len(out), 2, 'Number of missing named buses is '
'incorrect: %s != %s\n%s' % (len(out), 2, out))
out = qdev.list_missing_named_buses('pci.', 'abc', 5)
self.assertEqual(
len(out), 5, 'Number of missing named buses is '
'incorrect: %s != %s\n%s' % (len(out), 2, out))
# idx_of_next_named_bus
out = qdev.idx_of_next_named_bus('pci.')
self.assertEqual(
out, 3, 'Incorrect idx of next named bus: %s !='
' %s' % (out, 3))
# get_children
dev = qdevices.QDevice(parent_bus={'aobject': 'a_pci0'})
bus = qbuses.QPCIBus('test1', 'test', 'a_test1')
dev.add_child_bus(bus)
bus = qbuses.QPCIBus('test2', 'test', 'a_test2')
dev.add_child_bus(bus)
qdev.insert(dev)
qdev.insert(qdevices.QDevice(parent_bus={'aobject': 'a_test1'}))
qdev.insert(qdevices.QDevice(parent_bus={'aobject': 'a_test2'}))
out = dev.get_children()
assert len(out) == 2, ("Not all children were listed %d != 2:\n%s" %
(len(out), out))
out = bus.get_device()
assert out == dev, ("bus.get_device() returned different device "
"than the one in which it was plugged:\n"
"%s\n%s\n%s" %
(out.str_long(), dev.str_long(), qdev.str_long()))
def run(test, params, env):
"""
Hotplug/unhotplug virtio-vsock device
1. Boot guest without virtio-vsock-pci device
2. Hotplug virtio-vsock device
3. Check device inside guest(lspci/dmesg)
4. Transfer data from guest to host
5. Unplug virtio-vsock device
6. Cancel the vsock process on host
7. Reboot guest
:param test: QEMU test object
:param params: Dictionary with the test parameters
:param env: Dictionary with test environment
"""
linux_modules.load_module('vhost_vsock')
vm = env.get_vm(params['main_vm'])
session = vm.wait_for_login()
guest_cid = utils_vsock.get_guest_cid(3)
vsock_id = 'hotplugged_vsock'
vsock_params = {'id': vsock_id, 'guest-cid': guest_cid}
vsock_test_tool = params["vsock_test_tool"]
if '-mmio:' in params.get('machine_type'):
dev_vsock = qdevices.QDevice('vhost-vsock-device', vsock_params)
elif params.get('machine_type').startswith("s390"):
vsock_params['devno'] = params.get('devno')
dev_vsock = qdevices.QDevice("vhost-vsock-ccw", vsock_params)
else:
dev_vsock = qdevices.QDevice('vhost-vsock-pci', vsock_params)
vm.devices.simple_hotplug(dev_vsock, vm.monitor)
error_context.context(
'Check vsock device exist in guest lspci and '
'dmesg output.', logging.info)
addr_pattern = params['addr_pattern']
device_pattern = params['device_pattern']
check_vsock_cmd = params.get('check_vsock_cmd', 'lspci')
time.sleep(10)
lspci_output = session.cmd_output(check_vsock_cmd)
device_str = re.findall(r'%s\s%s' % (addr_pattern, device_pattern),
lspci_output)
if params.get('dmesg_check') == 'yes':
if not device_str:
test.fail('check_vsock_cmd failed, no device "%s"' %
device_pattern)
else:
address = re.findall(addr_pattern, device_str[0])[0]
chk_dmesg_cmd = 'dmesg'
output = re.findall(address, session.cmd_output(chk_dmesg_cmd))
if not output:
test.fail('dmesg failed, no info related to %s' % address)
else:
error_msg = ''
for o in output:
if re.search(r'fail|error', o, re.I):
error_msg += '%s' % o
break
if error_msg:
test.fail("dmesg check failed: %s" % error_msg)
# Transfer data from guest to host
try:
if vsock_test_tool == "nc_vsock":
tool_bin = vsock_test.compile_nc_vsock(test, vm, session)
if vsock_test_tool == "ncat":
tool_bin = path.find_command("ncat")
tmp_file = "/tmp/vsock_file_%s" % utils_misc.generate_random_string(6)
rec_session = vsock_test.send_data_from_guest_to_host(session,
tool_bin,
guest_cid,
tmp_file,
file_size=10000)
vsock_negative_test.check_data_received(test, rec_session, tmp_file)
vm.devices.simple_unplug(dev_vsock, vm.monitor)
vsock_negative_test.kill_host_receive_process(test, rec_session)
vsock_test.check_guest_vsock_conn_exit(test, session)
finally:
session.cmd_output("rm -f %s" % tmp_file)
session.close()
vm.reboot()
def run(test, params, env):
"""
Test hotplug of block devices.
1) Boot up guest without block device.
2) Hotplug a drive
2) Hoplug block device with invalid blk params.
3) Unplug the drive
4) Hotplug the drive again
5) Check vm is alive after drive unplug/hotplug
:param test: QEMU test object.
:param params: Dictionary with the test parameters.
:param env: Dictionary with test environment.
"""
def find_image(image_name):
"""
Find the path of the iamge.
:param image_name: name of image.
:return mage_filename: filename of image.
"""
image_params = params.object_params(image_name)
image_filename = storage.get_image_filename(image_params,
data_dir.get_data_dir())
return image_filename
def drive_unplug_plug(drive, vm):
"""
Unplug drive then replug it.
:param drive: instance of QRHDrive
:param vm: Vitual Machine object
"""
error_context.context("unplug the drive", logging.info)
drive.unplug(vm.monitor)
time.sleep(5)
error_context.context("Hotplug the drive", logging.info)
drive.hotplug(vm.monitor)
img_list = params.get("images").split()
img_format_type = params.get("img_format_type", "qcow2")
pci_type = params.get("pci_type", "virtio-blk-pci")
blk_num = int(params.get("blk_num", 1))
add_block_device = True
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
error_context.context("Hotplug block device", logging.info)
for num in xrange(blk_num):
device = qdevices.QDevice(pci_type)
drive = qdevices.QRHDrive("block%d" % num)
drive.set_param("file", find_image(img_list[num + 1]))
drive.set_param("format", img_format_type)
drive_id = drive.get_param("id")
drive.hotplug(vm.monitor)
#add controller if needed
if params.get("need_controller", "no") == "yes":
controller_model = params.get("controller_model")
controller = qdevices.QDevice(controller_model)
bus_extra_param = params.get("bus_extra_params_%s" %
img_list[num + 1])
if bus_extra_param:
key, value = bus_extra_param.split("=")
qdevice_params = {key: value}
controller.params.update(qdevice_params)
try:
controller.hotplug(vm.monitor)
except Exception, e:
if "QMP command 'device_add' failed" in str(e):
logging.info(
"Failed to add controller with invalid params")
drive_unplug_plug(drive, vm)
add_block_device = False
if add_block_device:
device.set_param("drive", drive_id)
device.set_param("id", "block%d" % num)
blk_extra_param = params.get("blk_extra_params_%s" %
img_list[num + 1])
if blk_extra_param:
key, value = blk_extra_param.split("=")
device.set_param(key, value)
try:
device.hotplug(vm.monitor)
except Exception, e:
if "QMP command 'device_add' failed" in str(e):
logging.info("Failed to add block with invalid params")
drive_unplug_plug(drive, vm)
def run(test, params, env):
"""
Test usb host device passthrough
:param test: kvm test object
:param params: Dictionary with the test parameters
:param env: Dictionary with test environment.
"""
def get_usb_host_dev():
device_list = []
for device in vm.devices:
if isinstance(device, qdevices.QDevice):
if device.get_param("driver") == "usb-host":
device_list.append(device)
return device_list
def get_vendorid_productid(bus, addr):
out = process.getoutput("lsusb -v -s %s:%s" % (bus, addr))
res = re.search(r"idVendor\s+0x(\w+).*idProduct\s+0x(\w+)", out, re.S)
return (res.group(1), res.group(2))
@error_context.context_aware
def usb_dev_hotplug(dev):
error_context.context("Hotplug usb-host device", logging.info)
session.cmd_status("dmesg -c")
vm.devices.simple_hotplug(dev, vm.monitor)
session.cmd_status("sleep 2")
session.cmd_status("udevadm settle")
messages_add = session.cmd("dmesg")
for line in messages_add.splitlines():
logging.debug("[dmesg add] %s", line)
if messages_add.find(match_add) == -1:
test.fail("kernel didn't detect plugin")
@error_context.context_aware
def usb_dev_verify():
error_context.context("Check usb device in guest", logging.info)
session.cmd(lsusb_cmd)
@error_context.context_aware
def usb_dev_unplug(dev):
error_context.context("Unplug usb-host device", logging.info)
session.cmd("dmesg -c")
vm.devices.simple_unplug(dev, vm.monitor)
session.cmd_status("sleep 2")
messages_del = session.cmd("dmesg -c")
for line in messages_del.splitlines():
logging.debug("[dmesg del] %s", line)
if messages_del.find(match_del) == -1:
test.fail("kernel didn't detect unplug")
def _get_usb_mount_point():
""" Get passthrough usb stick mount point """
dmesg_cmd = "dmesg | grep 'Attached SCSI removable disk'"
s, o = session.cmd_status_output(dmesg_cmd)
if s:
test.error("Fail to get passthrough usb stick in guest.")
dev = re.findall(r'\[(sd\w+)\]', o)[0]
mounts_cmd = "cat /proc/mounts | grep /dev/%s" % dev
s, o = session.cmd_status_output(mounts_cmd)
if not s:
s, o = session.cmd_status_output('umount /dev/%s' % dev)
if s:
test.error("Fail to umount /dev/%s, output: %s" % (s, o))
mkfs_cmd = "mkfs.vfat /dev/%s" % dev
s, o = session.cmd_status_output(mkfs_cmd)
if s:
test.error("Fail to build filesystem on usb stick: %s" % o)
mount_point = "/mnt"
s, o = session.cmd_status_output("mount /dev/%s %s" %
(dev, mount_point))
if s:
test.error("Fail to mount /dev/%s, output: %s" % (s, o))
return mount_point
def _usb_stick_io(mount_point, bg=False):
"""
Do I/O operations on passthrough usb stick
"""
error_context.context("Read and write on usb stick ", logging.info)
testfile = os.path.join(mount_point, 'testfile')
if bg:
iozone_cmd = params.get("iozone_cmd_bg", " -az -I -g 1g -f %s")
iozone_thread = BackgroundTest(iozone_test.run,
(iozone_cmd % testfile, ))
iozone_thread.start()
if not utils_misc.wait_for(iozone_thread.is_alive, timeout=10):
test.fail("Fail to start the iozone background test.")
time.sleep(10)
else:
iozone_cmd = params.get("iozone_cmd",
" -a -I -r 64k -s 1m -i 0 -i 1 -f %s")
iozone_test.run(iozone_cmd % testfile)
usb_params = {}
if params.get("usb_negative_test", "no") != "no":
# Negative test.
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
session = vm.wait_for_login()
usb_reply_msg_list = params.get("usb_reply_msg").split(";")
usb_host_device_list = params["usb_host_device_list"].split(",")
for dev in usb_host_device_list:
vid, pid = dev.split(":")
usb_params["vendorid"] = vid
usb_params["productid"] = pid
dev = qdevices.QDevice("usb-host", usb_params)
try:
vm.devices.simple_hotplug(dev, vm.monitor)
except QMPCmdError as detail:
logging.warn(detail)
for msg in usb_reply_msg_list:
if msg in detail.data['desc']:
break
else:
test.fail("Could not get expected warning"
" msg in negative test, monitor"
" returns: '%s'" % detail)
else:
test.fail("Hotplug operation in negative test"
" should not succeed.")
return
usb_hostdev = params["usb_devices"].split()[-1]
usb_options = params.get("options")
if usb_options == "with_vendorid_productid":
vendorid = params["usbdev_option_vendorid_%s" % usb_hostdev]
productid = params["usbdev_option_productid_%s" % usb_hostdev]
usb_params["vendorid"] = "0x%s" % vendorid
usb_params["productid"] = "0x%s" % productid
elif usb_options == "with_hostbus_hostaddr":
hostbus = params["usbdev_option_hostbus_%s" % usb_hostdev]
hostaddr = params["usbdev_option_hostaddr_%s" % usb_hostdev]
usb_params["hostbus"] = hostbus
usb_params["hostaddr"] = hostaddr
(vendorid, productid) = get_vendorid_productid(hostbus, hostaddr)
lsusb_cmd = "lsusb -v -d %s:%s" % (vendorid, productid)
match_add = "New USB device found, "
match_add += "idVendor=%s, idProduct=%s" % (vendorid, productid)
match_del = "USB disconnect"
usb_stick = "Mass Storage" in process.getoutput(lsusb_cmd)
error_context.context("Log into guest", logging.info)
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
session = vm.wait_for_login()
try:
usb_dev_verify()
if usb_stick:
iozone_test = None
mount_point = _get_usb_mount_point()
iozone_test = generate_instance(params, vm, 'iozone')
_usb_stick_io(mount_point)
usb_devs = get_usb_host_dev()
for dev in usb_devs:
usb_dev_unplug(dev)
repeat_times = int(params.get("usb_repeat_times", "1"))
for i in range(repeat_times):
msg = "Hotplug (iteration %d)" % (i + 1)
usb_params["id"] = "usbhostdev%s" % i
if params.get("usb_check_isobufs", "no") == "yes":
# The value of isobufs could only be in '4, 8, 16'
isobufs = (2 << (i % 3 + 1))
usb_params["isobufs"] = isobufs
msg += ", with 'isobufs' option set to %d." % isobufs
error_context.context(msg, logging.info)
usb_dev = qdevices.QDevice("usb-host", usb_params)
usb_dev_hotplug(usb_dev)
usb_dev_verify()
if usb_stick:
mount_point = _get_usb_mount_point()
_usb_stick_io(mount_point, bg=True)
usb_dev_unplug(usb_dev)
finally:
if usb_stick and iozone_test:
iozone_test.clean()
session.close()
def run(test, params, env):
"""
Test hotplug/unplug of rng device
1) Boot up w/o rng device
2) Hotplug one or more rng devices
3) Run random read test after hotplug
4) Unplug rng devices
5) Repeat step 2 ~ step4 (option)
:param test: QEMU test object
:param params: Dictionary with the test parameters
:param env: Dictionary with test environment
"""
def get_rng_id(vm):
device_list = []
for device in vm.devices:
if isinstance(device, qdevices.QDevice):
if device.get_param("driver") == "virtio-rng-pci":
device_list.append(device)
return device_list
def hotplug_rng(vm, dev):
error_context.context("Hotplug %s" % dev, logging.info)
output = dev.hotplug(vm.monitor)
time.sleep(5)
error_context.context("Check %s from qtree after hotplug" % dev,
logging.info)
qtree_output = dev.verify_hotplug(output, vm.monitor)
if not qtree_output:
msg = "no % device in qtree after hotplug" % dev
raise exceptions.TestFail(msg)
logging.info("%s is hotpluged successfully" % dev)
def unplug_rng(vm, dev):
error_context.context("Hot-unplug %s" % dev, logging.info)
output = dev.unplug(vm.monitor)
time.sleep(5)
error_context.context("Check %s from qtree after unplug" % dev,
logging.info)
qtree_output = dev.verify_unplug(output, vm.monitor)
if not qtree_output:
msg = "Still get %s in qtree after unplug" % dev
raise exceptions.TestFail(msg)
logging.info("%s is unpluged successfully" % dev)
def restart_rngd(vm):
if params.get("restart_rngd"):
session = vm.wait_for_login()
error_context.context("Restart rngd service", logging.info)
status, output = session.cmd_status_output("service rngd restart")
if status != 0:
raise exceptions.TestError(output)
session.close()
def stop_rngd(vm):
if params.get("stop_rngd"):
session = vm.wait_for_login()
error_context.context("Disable rngd service before unplug",
logging.info)
status, output = session.cmd_status_output(params.get("stop_rngd"))
if status != 0:
raise exceptions.TestError(output)
session.close()
login_timeout = int(params.get("login_timeout", 360))
repeat_times = int(params.get("repeat_times", 1))
rng_num = int(params.get("rng_num", 1))
test_before_hotplug = params.get("test_before_hotplug")
test_after_hotplug = params.get("test_after_hotplug")
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
vm.wait_for_login(timeout=login_timeout)
if test_before_hotplug:
restart_rngd(vm)
error_context.context("Run %s before hotplug" % test_before_hotplug)
utils_test.run_virt_sub_test(test, params, env, test_before_hotplug)
# Unplug attached rng device
device_ids = get_rng_id(vm)
if device_ids:
stop_rngd(vm)
time.sleep(5)
for device in device_ids:
unplug_rng(vm, device)
for i in xrange(repeat_times):
dev_list = []
error_context.context(
"Hotplug/unplug rng devices the %s time" % (i + 1), logging.info)
for num in xrange(rng_num):
vm.devices.set_dirty()
new_dev = qdevices.QDevice("virtio-rng-pci",
{'id': 'virtio-rng-pci-%d' % num})
hotplug_rng(vm, new_dev)
dev_list.append(new_dev)
# Run test after hotplug
if test_after_hotplug and i == xrange(repeat_times)[-1]:
restart_rngd(vm)
error_context.context("Run %s after hotplug" % test_after_hotplug,
logging.info)
utils_test.run_virt_sub_test(test, params, env, test_after_hotplug)
stop_rngd(vm)
time.sleep(5)
for dev in dev_list:
unplug_rng(vm, dev)
def run(test, params, env):
"""
Test hotplug of block devices.
1) Boot up guest with/without block device(s).
2) Hoplug block device and verify
3) Do read/write data on hotplug block.
4) Unplug block device and verify
:param test: QEMU test object.
:param params: Dictionary with the test parameters.
:param env: Dictionary with test environment.
"""
def find_image(image_name):
"""
Find the path of the iamge.
"""
image_params = params.object_params(image_name)
o = storage.get_image_filename(image_params, data_dir.get_data_dir())
return o
def find_disk(vm, cmd):
"""
Find all disks in guest.
"""
if params.get("os_type") == "linux":
pattern = params.get("get_disk_pattern", "^/dev/vd[a-z]*$")
elif params.get("os_type") == "windows":
pattern = r"^\d+"
cmd = params.get("get_disk_index", "wmic diskdrive get index")
else:
test.cancel("Unsupported OS type '%s'" % params.get("os_type"))
session = vm.wait_for_login(timeout=timeout)
output = session.cmd_output_safe(cmd)
disks = re.findall(pattern, output, re.M)
session.close()
return disks
def get_new_disk(disk1, disk2):
"""
Get the different disk between disk1 and disk2.
"""
disk = list(set(disk2).difference(set(disk1)))
return disk
def unplug_device(vm, get_disk_cmd, device):
"""
Unplug device
"""
disks_before_unplug = find_disk(vm, get_disk_cmd)
device.unplug(vm.monitor)
device.verify_unplug("", vm.monitor)
unplug_status = utils_misc.wait_for(
lambda: len(
get_new_disk(find_disk(vm, get_disk_cmd), disks_before_unplug))
!= 0, pause)
return unplug_status
img_list = params.get("images").split()
img_format_type = params.get("img_format_type", "qcow2")
pci_type = params.get("pci_type", "virtio-blk-pci")
#sometimes, ppc can't get new plugged disk in 5s, so time to 10s
pause = float(params.get("virtio_block_pause", 10.0))
blk_num = int(params.get("blk_num", 1))
repeat_times = int(params.get("repeat_times", 3))
timeout = int(params.get("login_timeout", 360))
disk_op_timeout = int(params.get("disk_op_timeout", 360))
get_disk_cmd = params.get("get_disk_cmd")
context_msg = "Running sub test '%s' %s"
disk_index = params.objects("disk_index")
disk_letter = params.objects("disk_letter")
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
for iteration in range(repeat_times):
device_list = []
controller_list = []
controller_device_dict = {}
error_context.context(
"Hotplug block device (iteration %d)" % iteration, logging.info)
sub_type = params.get("sub_type_before_plug")
if sub_type:
error_context.context(context_msg % (sub_type, "before hotplug"),
logging.info)
utils_test.run_virt_sub_test(test, params, env, sub_type)
for num in range(blk_num):
device = qdevices.QDevice(pci_type)
if params.get("need_plug") == "yes":
disks_before_plug = find_disk(vm, get_disk_cmd)
if params.get("need_controller", "no") == "yes":
controller_model = params.get("controller_model")
controller = qdevices.QDevice(
controller_model,
params={"id": "hotadded_scsi%s" % num})
bus_extra_param = params.get("bus_extra_params_%s" %
img_list[num + 1])
if bus_extra_param:
for item in bus_extra_param.split():
key, value = item.split("=", 1)
qdevice_params = {key: value}
controller.params.update(qdevice_params)
controller.hotplug(vm.monitor)
ver_out = controller.verify_hotplug("", vm.monitor)
if not ver_out:
err = "%s is not in qtree after hotplug" % controller_model
test.fail(err)
else:
controller_list.append(controller)
drive = qdevices.QRHDrive("block%d" % num)
drive.set_param("file", find_image(img_list[num + 1]))
drive.set_param("format", img_format_type)
drive_id = drive.get_param("id")
drive.hotplug(vm.monitor)
device.set_param("drive", drive_id)
device.set_param("id", "block%d" % num)
if params.get("need_controller", "no") == "yes" and bool(
random.randrange(2)):
device.set_param("bus", controller.get_param("id") + '.0')
blk_extra_param = params.get("blk_extra_params_%s" %
img_list[num + 1])
if blk_extra_param:
for item in blk_extra_param.split():
key, value = item.split("=", 1)
device.set_param(key, value)
device.hotplug(vm.monitor)
ver_out = device.verify_hotplug("", vm.monitor)
if not ver_out:
err = "%s is not in qtree after hotplug" % pci_type
test.fail(err)
plug_status = utils_misc.wait_for(
lambda: len(
get_new_disk(disks_before_plug,
find_disk(vm, get_disk_cmd))) != 0, pause)
if plug_status:
disks_after_plug = find_disk(vm, get_disk_cmd)
new_disks = get_new_disk(disks_before_plug,
disks_after_plug)
else:
test.fail("Can't get new disks")
if params.get("need_controller", "no") == "yes":
info_qtree = vm.monitor.info('qtree', False)
qtree = qemu_qtree.QtreeContainer()
qtree.parse_info_qtree(info_qtree)
for node in qtree.get_nodes():
if node.qtree.get("id") == device.get_param("id"):
try:
controller_id = node.parent.qtree.get(
"id").split(".")[0]
except AttributeError:
test.fail("can't get parent of:\n%s" % node)
controller_device_dict.setdefault(
controller_id, []).append(device)
break
else:
test.fail("Can't find device '%s' in qtree" %
device.get_param("id"))
else:
if params.get("drive_format") in pci_type:
get_disk_cmd += " | egrep -v '^/dev/[hsv]da[0-9]*$'"
device.set_param("id", img_list[num + 1])
new_disks = find_disk(vm, get_disk_cmd)
device_list.append(device)
if not new_disks:
test.fail("Cannot find new disk after hotplug.")
if params.get("need_plug") == "yes":
disk = new_disks[0]
else:
disk = new_disks[num]
session = vm.wait_for_login(timeout=timeout)
if params.get("os_type") == "windows":
if iteration == 0:
error_context.context("Format disk", logging.info)
utils_misc.format_windows_disk(session,
disk_index[num],
mountpoint=disk_letter[num])
error_context.context("Check block device after hotplug.",
logging.info)
if params.get("disk_op_cmd"):
if params.get("os_type") == "linux":
test_cmd = params.get("disk_op_cmd") % (disk, disk)
elif params.get("os_type") == "windows":
test_cmd = params.get("disk_op_cmd") % (disk_letter[num],
disk_letter[num])
test_cmd = utils_misc.set_winutils_letter(
session, test_cmd)
else:
test.cancel("Unsupported OS type '%s'" %
params.get("os_type"))
status, output = session.cmd_status_output(
test_cmd, timeout=disk_op_timeout)
if status:
test.fail("Check for block device failed "
"after hotplug, Output: %r" % output)
session.close()
sub_type = params.get("sub_type_after_plug")
if sub_type:
error_context.context(context_msg % (sub_type, "after hotplug"),
logging.info)
utils_test.run_virt_sub_test(test, params, env, sub_type)
if sub_type == "shutdown" and vm.is_dead():
return
sub_type = params.get("sub_type_before_unplug")
if sub_type:
error_context.context(context_msg % (sub_type, "before unplug"),
logging.info)
utils_test.run_virt_sub_test(test, params, env, sub_type)
error_context.context("Unplug block device (iteration %d)" % iteration,
logging.info)
for controller in controller_list:
controller_id = controller.get_param("id")
for device in controller_device_dict.get(controller_id, []):
unplug_status = unplug_device(vm, get_disk_cmd, device)
if not unplug_status:
test.fail("Failed to unplug disks '%s'" %
device.get_param("id"))
device_list.remove(device)
controller.unplug(vm.monitor)
for device in device_list:
unplug_status = unplug_device(vm, get_disk_cmd, device)
if not unplug_status:
test.fail("Failed to unplug disks '%s'" %
device.get_param("id"))
sub_type = params.get("sub_type_after_unplug")
if sub_type:
error_context.context(context_msg % (sub_type, "after unplug"),
logging.info)
utils_test.run_virt_sub_test(test, params, env, sub_type)
def run(test, params, env):
"""
Test hotplug/unplug of rng device
1) Boot up w/ one rng device
2) Unplug rng device
3) reboot/shutdown guest(optional)
4) Hotplug one or more rng devices
5) Run random read test after hotplug
6) Unplug rng devices
7) Repeat step 4 ~ step 6 (optional)
8) Hotplug one rng device
9) Run random read test after hotplug
10) Reboot/shutdown guest(optional)
:param test: QEMU test object
:param params: Dictionary with the test parameters
:param env: Dictionary with test environment
"""
def get_rng_id(vm):
device_list = []
for device in vm.devices:
if isinstance(device, qdevices.QDevice):
if device.get_param("driver") == "virtio-rng-pci":
device_list.append(device)
return device_list
def hotplug_rng(vm, dev):
error_context.context("Hotplug %s" % dev, logging.info)
out, ver_out = vm.devices.simple_hotplug(dev, vm.monitor)
if not ver_out:
msg = "no % device in qtree after hotplug" % dev
raise exceptions.TestFail(msg)
logging.info("%s is hotpluged successfully", dev)
def unplug_rng(vm, dev):
error_context.context("Hot-unplug %s" % dev, logging.info)
out, ver_out = vm.devices.simple_unplug(dev, vm.monitor)
if not ver_out:
msg = "Still get %s in qtree after unplug" % dev
raise exceptions.TestFail(msg)
time.sleep(15)
logging.info("%s is unpluged successfully", dev)
def restart_rngd(vm):
if params.get("restart_rngd"):
session = vm.wait_for_login()
error_context.context("Restart rngd service", logging.info)
status, output = session.cmd_status_output("service rngd restart")
if status != 0:
raise exceptions.TestError(output)
session.close()
def stop_rngd(vm):
if params.get("stop_rngd"):
session = vm.wait_for_login()
error_context.context("Disable rngd service before unplug",
logging.info)
status, output = session.cmd_status_output(params.get("stop_rngd"))
if status != 0:
raise exceptions.TestError(output)
session.close()
def run_subtest(sub_test):
"""
Run subtest(e.g. rng_bat,reboot,shutdown) when it's not None
:param sub_test: subtest name
"""
error_context.context("Run %s subtest" % sub_test)
utils_test.run_virt_sub_test(test, params, env, sub_test)
login_timeout = int(params.get("login_timeout", 360))
repeat_times = int(params.get("repeat_times", 1))
rng_num = int(params.get("rng_num", 1))
rng_basic_test = params.get("rng_basic_test")
pm_test_after_plug = params.get("pm_test_after_plug")
pm_test_after_unplug = params.get("pm_test_after_unplug")
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
vm.wait_for_login(timeout=login_timeout)
# run rng test before hot-unplug
restart_rngd(vm)
run_subtest(rng_basic_test)
# Unplug attached rng device
device_ids = get_rng_id(vm)
if device_ids:
stop_rngd(vm)
time.sleep(5)
for device in device_ids:
unplug_rng(vm, device)
for i in range(repeat_times):
dev_list = []
error_context.context(
"Hotplug/unplug rng devices the %s time" % (i + 1), logging.info)
for num in range(rng_num):
vm.devices.set_dirty()
new_dev = qdevices.QDevice("virtio-rng-pci",
{'id': 'virtio-rng-pci-%d' % num})
hotplug_rng(vm, new_dev)
dev_list.append(new_dev)
# run rng test after hotplug
restart_rngd(vm)
run_subtest(rng_basic_test)
# run reboot/shutdown after hotplug
if pm_test_after_plug:
run_subtest(pm_test_after_plug)
# run rng test after reboot,skip followed test if
# pm_test_after_plug is shutdown
if vm.is_alive():
run_subtest(rng_basic_test)
else:
return
stop_rngd(vm)
time.sleep(5)
for dev in dev_list:
unplug_rng(vm, dev)
# run reboot/shutdown test after hot-unplug
if pm_test_after_unplug:
run_subtest(pm_test_after_unplug)
if not vm.is_alive():
return
def run(test, params, env):
"""
Test hotplug of balloon devices.
1) Boot up guest w/o balloon device.
2) Hoplug balloon device and check hotplug successfully or not.
3) Install balloon service and check its status in windows guests.
4) Do memory balloon.
5) Reboot/shutdown guest after hotplug balloon device(option)
6) Do memory balloon after guest reboot(option)
7) Unplug balloon device and check unplug successfully or not.
8) Reboot/shutdown guest after unplug balloon device(option)
:param test: QEMU test object.
:param params: Dictionary with the test parameters.
:param env: Dictionary with test environment.
"""
def run_pm_test(pm_test, plug_type):
"""
Run pm(reboot/system_reset/shutdown) related test after balloon
device is hot-plug or hot-unplug
:param pm_test: power management test name,e.g. reboot/shutdown
:param plug_type:balloon device plug operation,e.g.hot_plug or hot_unplug
"""
error_context.context("Run %s test after %s balloon device"
% (pm_test, plug_type), logging.info)
utils_test.run_virt_sub_test(test, params, env, pm_test)
def enable_balloon_service():
"""
Install balloon service and check its status in windows guests
"""
if params['os_type'] != 'windows':
return
error_context.context("Install and check balloon service in windows "
"guest", logging.info)
session = vm.wait_for_login()
driver_name = params.get("driver_name", "balloon")
session = utils_test.qemu.windrv_check_running_verifier(session,
vm, test,
driver_name)
balloon_test = BallooningTestWin(test, params, env)
balloon_test.configure_balloon_service(session)
output = balloon_test.operate_balloon_service(session, "status")
if not re.search(r"running", output.lower(), re.M):
test.error("Ballooon service status is not running")
session.close()
pause = float(params.get("virtio_balloon_pause", 3.0))
pm_test_after_plug = params.get("pm_test_after_plug")
pm_test_after_unplug = params.get("pm_test_after_unplug")
idx = 0
err = ""
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
balloon_device = params.get("ballon_device", "virtio-balloon-pci")
error_context.context("Hotplug and unplug balloon device in a loop",
logging.info)
for i in range(int(params.get("balloon_repeats", 3))):
vm.devices.set_dirty()
new_dev = qdevices.QDevice(balloon_device,
{'id': 'balloon%d' % idx},
parent_bus={'aobject': 'pci.0'})
error_context.context("Hotplug balloon device for %d times" % (i+1),
logging.info)
out = new_dev.hotplug(vm.monitor)
if out:
err += "\nHotplug monitor output: %s" % out
# Pause
time.sleep(pause)
ver_out = new_dev.verify_hotplug(out, vm.monitor)
if not ver_out:
err += ("\nDevice is not in qtree %ss after hotplug:\n%s"
% (pause, vm.monitor.info("qtree")))
# temporary workaround for migration
vm.params["balloon"] = "balloon%d" % idx
vm.params["balloon_dev_devid"] = "balloon%d" % idx
vm.params["balloon_dev_add_bus"] = "yes"
enable_balloon_service()
error_context.context("Check whether balloon device work after hotplug",
logging.info)
balloon_check.run(test, params, env)
if pm_test_after_plug:
run_pm_test(pm_test_after_plug, "hot-plug")
# run balloon test after reboot,skip followed test if
# pm_test_after_plug is shutdown
if vm.is_alive():
balloon_check.run(test, params, env)
else:
return
error_context.context("Unplug balloon device for %d times" % (i+1),
logging.info)
out = new_dev.unplug(vm.monitor)
if out:
err += "\nUnplug monitor output: %s" % out
# Pause
time.sleep(pause)
ver_out = new_dev.verify_unplug(out, vm.monitor)
if not ver_out:
err += ("\nDevice is still in qtree %ss after unplug:\n%s"
% (pause, vm.monitor.info("qtree")))
if err:
logging.error(vm.monitor.info("qtree"))
test.fail("Error occurred while hotpluging "
"virtio-pci. Iteration %s, monitor "
"output:%s" % (i, err))
else:
if params.get("migrate_after_unplug", "no") == "yes":
error_context.context("Migrate after hotunplug balloon device",
logging.info)
# temporary workaround for migration
del vm.params["balloon"]
del vm.params["balloon_dev_devid"]
del vm.params["balloon_dev_add_bus"]
vm.migrate(float(params.get("mig_timeout", "3600")))
if pm_test_after_unplug:
run_pm_test(pm_test_after_unplug, "hot-unplug")
if not vm.is_alive():
return
error_context.context("Verify guest alive!", logging.info)
vm.verify_kernel_crash()
