def run(test, params, env):
"""
Test the virtio bus autommated assignement for passthrough devices
1. prepare a passthrough device xml without bus defined
2. start the guest and check if the device can be attached
3. check if the new device is properly listed in guest xml
"""
if not libvirt_version.version_compare(6, 3, 0):
test.cancel('The feature of automatic assignment of virtio bus for '
'passthrough devices is supported since version 6.3.0')
vm_name = params.get("main_vm", "avocado-vt-vm1")
# Create a new passthrough device without bus assigned
input_dev = Input(type_name="passthrough")
input_dev.source_evdev = "/dev/input/event1"
xml = input_dev.get_xml()
logging.debug('Attached device xml:\n{}'.format(input_dev.xmltreefile))
logging.debug('New Passthrough device XML is available at:{}'.format(xml))
# Start the VM
vm = env.get_vm(vm_name)
vm_xml = VMXML.new_from_dumpxml(vm_name)
vm_xml_backup = vm_xml.copy()
if vm.is_alive():
vm.destroy()
vm_xml.remove_all_device_by_type('input')
try:
vm.start()
vm.wait_for_login().close()
# Attach new device and check for result
cmd_result = virsh.attach_device(vm_name, input_dev.get_xml(), debug=True)
if cmd_result.exit_status != 0:
test.error(cmd_result.stderr_text)
# Get the VM XML and check for a new device
vm_xml = VMXML.new_from_dumpxml(vm_name)
device_list = vm_xml.get_devices()
for device in device_list:
if device['device_tag'] == 'input':
device_xml = device['xml']
# Create a new instance of Input device and fill with input
# device found
input_device = Input(type_name="passthrough")
input_device.set_xml(device_xml)
if input_device.type_name == "passthrough":
with open(device_xml, 'r') as device_xml_file:
for line in device_xml_file:
logging.debug(line.rstrip())
if not input_device.input_bus == "virtio":
test.fail("The newly attached passthrough device has no"
" added virtio as a bus by default.")
else:
logging.debug("Newly added passthrough device has a "
"virtio automatically assigned as a bus.")
finally:
if vm.is_alive():
virsh.destroy(vm_name)
vm_xml_backup.sync()
def add_keyboard_device(vm_name):
"""
Add keyboard to guest if guest doesn't have
:params: vm_name: the guest name
"""
inputs = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)\
.get_devices(device_type="input")
for input_device in inputs:
if input_device.type_name == "keyboard":
logging.debug("Guest already has a keyboard device")
return
kbd = Input("keyboard")
kbd.input_bus = "virtio"
logging.debug("Add keyboard device %s" % kbd)
result = virsh.attach_device(vm_name, kbd.xml)
if result.exit_status:
test.error("Failed to add keyboard device")
if input.type_name == "tablet":
vmxml.del_device(input)
# Add new usb controllers.
usb_controller1 = Controller("controller")
usb_controller1.type = "usb"
usb_controller1.index = "0"
usb_controller1.model = "piix3-uhci"
vmxml.add_device(usb_controller1)
usb_controller2 = Controller("controller")
usb_controller2.type = "usb"
usb_controller2.index = "1"
usb_controller2.model = "ich9-ehci1"
vmxml.add_device(usb_controller2)
input_obj = Input("tablet")
input_obj.input_bus = "usb"
addr_dict = {}
if input_usb_address != "":
for addr_option in input_usb_address.split(','):
if addr_option != "":
d = addr_option.split('=')
addr_dict.update({d[0].strip(): d[1].strip()})
if addr_dict:
input_obj.address = input_obj.new_input_address(
**{"attrs": addr_dict})
vmxml.add_device(input_obj)
usb_devices.update({"input": addr_dict})
hub_obj = Hub("usb")
addr_dict = {}
def run(test, params, env):
"""
Test the input virtual devices
1. prepare a guest with different input devices
2. check whether the guest can be started
3. check the qemu cmd line
"""
def check_dumpxml():
"""
Check whether the added devices are shown in the guest xml
"""
pattern = "<input bus=\"%s\" type=\"%s\">" % (bus_type, input_type)
if with_packed:
pattern = "<driver packed=\"%s\"" % (driver_packed)
logging.debug('Searching for %s in vm xml', pattern)
xml_after_adding_device = VMXML.new_from_dumpxml(vm_name)
logging.debug('xml_after_adding_device:\n%s', xml_after_adding_device)
if pattern not in str(xml_after_adding_device):
test.fail("Can not find the %s input device xml "
"in the guest xml file." % input_type)
def check_qemu_cmd_line():
"""
Check whether the added devices are shown in the qemu cmd line
"""
# if the tested input device is a keyboard or mouse with ps2 bus,
# there is no keyboard or mouse in qemu cmd line
if bus_type == "ps2" and input_type in ["keyboard", "mouse"]:
return
with open('/proc/%s/cmdline' % vm.get_pid(), 'r') as cmdline_file:
cmdline = cmdline_file.read()
if bus_type == "usb" and input_type == "keyboard":
pattern = r"-device.*%s-kbd" % bus_type
elif input_type == "passthrough":
pattern = r"-device.*%s-input-host-pci" % bus_type
else:
pattern = r"-device.*%s-%s" % (bus_type, input_type)
if not re.search(pattern, cmdline):
test.fail("Can not find the %s input device "
"in qemu cmd line." % input_type)
if with_packed:
pattern = r"packed.*%s" % driver_packed
if not re.search(pattern, cmdline):
test.fail("Can not find the packed driver " "in qemu cmd line")
vm_name = params.get("main_vm", "avocado-vt-vm1")
machine_type = params.get('machine_type', '')
status_error = params.get("status_error", "no") == "yes"
with_packed = params.get("with_packed", "no") == "yes"
driver_packed = params.get("driver_packed", "on")
bus_type = params.get("bus_type")
input_type = params.get("input_type")
check_preconditions(bus_type, input_type, with_packed, test)
vm = env.get_vm(vm_name)
vm_xml = VMXML.new_from_dumpxml(vm_name)
vm_xml_backup = vm_xml.copy()
if vm.is_alive():
vm.destroy()
try:
# ps2 keyboard and ps2 mouse are default, no need to re-add the xml,
# unless it's machine_type is pseries
if not (bus_type == "ps2" and input_type in ["keyboard", "mouse"]
and machine_type != 'pseries'):
vm_xml.remove_all_device_by_type('input')
input_dev = Input(type_name=input_type)
input_dev.input_bus = bus_type
if input_type == "passthrough":
kbd_dev_name = glob.glob('/dev/input/by-path/*kbd')
if not kbd_dev_name:
test.cancel("There is no keyboard device on this host.")
logging.debug(
"keyboard %s is going to be passthrough "
"to the host.", kbd_dev_name[0])
input_dev.source_evdev = kbd_dev_name[0]
if with_packed:
input_dev.driver_packed = driver_packed
vm_xml.add_device(input_dev)
try:
vm_xml.sync()
except Exception as error:
if not status_error:
test.fail(
"Failed to define the guest after adding the %s input "
"device xml. Details: %s " % (input_type, error))
logging.debug(
"This is the expected failing in negative cases.")
return
res = virsh.start(vm_name)
if res.exit_status:
if not status_error:
test.fail("Failed to start vm after adding the %s input "
"device xml. Details: %s " %
(input_type, res.stderr))
logging.debug("This is the expected failure in negative cases.")
return
if status_error:
test.fail(
"Expected fail in negative cases but vm started successfully.")
return
logging.debug("VM started successfully in positive cases.")
check_dumpxml()
check_qemu_cmd_line()
finally:
if vm.is_alive():
virsh.destroy(vm_name)
vm_xml_backup.sync()
if input.type_name == "tablet":
vmxml.del_device(input)
# Add new usb controllers.
usb_controller1 = Controller("controller")
usb_controller1.type = "usb"
usb_controller1.index = "0"
usb_controller1.model = "piix3-uhci"
vmxml.add_device(usb_controller1)
usb_controller2 = Controller("controller")
usb_controller2.type = "usb"
usb_controller2.index = "1"
usb_controller2.model = "ich9-ehci1"
vmxml.add_device(usb_controller2)
input_obj = Input("tablet")
input_obj.input_bus = "usb"
addr_dict = {}
if input_usb_address != "":
for addr_option in input_usb_address.split(','):
if addr_option != "":
d = addr_option.split('=')
addr_dict.update({d[0].strip(): d[1].strip()})
if addr_dict:
input_obj.address = input_obj.new_input_address(
**{"attrs": addr_dict})
vmxml.add_device(input_obj)
usb_devices.update({"input": addr_dict})
hub_obj = Hub("usb")
addr_dict = {}
def run(test, params, env):
"""
Stress test for the hotplug feature of usb device.
"""
# get the params from params
vm_name = params.get("main_vm", "avocado-vt-vm1")
vm = env.get_vm(vm_name)
keyboard = "yes" == params.get("usb_hotplug_keyboard", "no")
mouse = "yes" == params.get("usb_hotplug_mouse", "no")
tablet = "yes" == params.get("usb_hotplug_tablet", "no")
disk = "yes" == params.get("usb_hotplug_disk", "no")
attach_count = int(params.get("attach_count", "1"))
attach_type = params.get("attach_type", "attach_device")
bench_type = params.get("guest_bench", None)
control_file = params.get("control_file", None)
status_error = "yes" == params.get("status_error", "no")
vm_xml = VMXML.new_from_inactive_dumpxml(vm_name)
vm_xml_backup = vm_xml.copy()
tmp_dir = os.path.join(data_dir.get_tmp_dir(), "usb_hotplug_files")
if control_file is not None:
params["test_control_file"] = control_file
params["main_vm"] = vm_name
control_path = os.path.join(test.virtdir, "control", control_file)
session = vm.wait_for_login()
command = utils_test.run_autotest(vm, session, control_path, None, None, params, copy_only=True)
session.cmd("%s &" % command)
def _is_iozone_running():
session_tmp = vm.wait_for_login()
return not session_tmp.cmd_status("ps -ef|grep iozone|grep -v grep")
def _is_stress_running():
session_tmp = vm.wait_for_login()
return not session_tmp.cmd_status("ps -ef|grep stress|grep -v grep")
if bench_type == "stress":
if not utils_misc.wait_for(_is_stress_running, timeout=160):
raise error.TestNAError(
"Failed to run stress in guest.\n"
"Since we need to run a autotest of iozone "
"in guest, so please make sure there are "
"some necessary packages in guest,"
"such as gcc, tar, bzip2"
)
elif bench_type == "iozone":
if not utils_misc.wait_for(_is_iozone_running, timeout=160):
raise error.TestNAError(
"Failed to run iozone in guest.\n"
"Since we need to run a autotest of iozone "
"in guest, so please make sure there are "
"some necessary packages in guest,"
"such as gcc, tar, bzip2"
)
logging.debug("bench is already running in guest.")
try:
try:
result = None
disk_xml = None
tablet_xml = None
mouse_xml = None
if not os.path.isdir(tmp_dir):
os.mkdir(tmp_dir)
for i in range(attach_count):
path = os.path.join(tmp_dir, "%s.img" % i)
if attach_type == "qemu_monitor":
options = "--hmp"
if disk:
utils_test.libvirt.create_local_disk("file", path, size="1M")
attach_cmd = "drive_add"
attach_cmd += " 0 id=drive-usb-disk%s,if=none,file=%s" % (i, path)
result = virsh.qemu_monitor_command(vm_name, attach_cmd, options=options)
if result.exit_status:
raise process.CmdError(result.command, result)
if keyboard:
attach_cmd = "device_add"
attach_cmd += " usb-kdb,bus=usb1.0,id=kdb"
result = virsh.qemu_monitor_command(vm_name, attach_cmd, options=options)
if result.exit_status:
raise process.CmdError(result.command, result)
if mouse:
attach_cmd = "device_add"
attach_cmd += " usb-mouse,bus=usb1.0,id=mouse"
result = virsh.qemu_monitor_command(vm_name, attach_cmd, options=options)
if result.exit_status:
raise process.CmdError(result.command, result)
if tablet:
attach_cmd = "device_add"
attach_cmd += " usb-tablet,bus=usb1.0,id=tablet"
result = virsh.qemu_monitor_command(vm_name, attach_cmd, options=options)
if result.exit_status:
raise process.CmdError(result.command, result)
else:
if disk:
utils_test.libvirt.create_local_disk("file", path, size="1M")
os.chmod(path, 0666)
disk_xml = Disk(type_name="file")
disk_xml.device = "disk"
disk_xml.source = disk_xml.new_disk_source(**{"attrs": {"file": path}})
disk_xml.driver = {"name": "qemu", "type": "raw", "cache": "none"}
disk_xml.target = {"dev": "sdb", "bus": "usb"}
attributes = {"type_name": "usb", "bus": "1", "port": "0"}
disk_xml.address = disk_xml.new_disk_address(**{"attrs": attributes})
result = virsh.attach_device(vm_name, disk_xml.xml)
if result.exit_status:
raise process.CmdError(result.command, result)
if mouse:
mouse_xml = Input("mouse")
mouse_xml.input_bus = "usb"
attributes = {"type_name": "usb", "bus": "1", "port": "0"}
mouse_xml.address = mouse_xml.new_input_address(**{"attrs": attributes})
result = virsh.attach_device(vm_name, mouse_xml.xml)
if result.exit_status:
raise process.CmdError(result.command, result)
if tablet:
tablet_xml = Input("tablet")
tablet_xml.input_bus = "usb"
attributes = {"type_name": "usb", "bus": "1", "port": "0"}
tablet_xml.address = tablet_xml.new_input_address(**{"attrs": attributes})
result = virsh.attach_device(vm_name, tablet_xml.xml)
if result.exit_status:
raise process.CmdError(result.command, result)
if keyboard:
kbd_xml = Input("keyboard")
kbd_xml.input_bus = "usb"
attributes = {"type_name": "usb", "bus": "1", "port": "0"}
kbd_xml.address = kbd_xml.new_input_address(**{"attrs": attributes})
result = virsh.attach_device(vm_name, kbd_xml.xml)
if result.exit_status:
raise process.CmdError(result.command, result)
if attach_type == "qemu_monitor":
options = "--hmp"
if disk:
attach_cmd = "drive_del"
attach_cmd += " drive-usb-disk"
result = virsh.qemu_monitor_command(vm_name, attach_cmd, options=options)
if result.exit_status:
raise process.CmdError(result.command, result)
if mouse:
attach_cmd = "device_del"
attach_cmd += " mouse"
result = virsh.qemu_monitor_command(vm_name, attach_cmd, options=options)
if result.exit_status:
raise process.CmdError(result.command, result)
if keyboard:
attach_cmd = "device_del"
attach_cmd += " keyboard"
result = virsh.qemu_monitor_command(vm_name, attach_cmd, options=options)
if result.exit_status:
raise process.CmdError(result.command, result)
if tablet:
attach_cmd = "device_del"
attach_cmd += " tablet"
result = virsh.qemu_monitor_command(vm_name, attach_cmd, options=options)
if result.exit_status:
raise process.CmdError(result.command, result)
else:
if disk:
result = virsh.detach_device(vm_name, disk_xml.xml)
if result.exit_status:
raise process.CmdError(result.command, result)
if mouse:
result = virsh.detach_device(vm_name, mouse_xml.xml)
if result.exit_status:
raise process.CmdError(result.command, result)
if keyboard:
result = virsh.detach_device(vm_name, kbd_xml.xml)
if result.exit_status:
raise process.CmdError(result.command, result)
if tablet:
result = virsh.detach_device(vm_name, tablet_xml.xml)
if result.exit_status:
raise process.CmdError(result.command, result)
except process.CmdError, e:
if not status_error:
raise error.TestFail("failed to attach device.\n" "Detail: %s." % result)
finally:
if os.path.isdir(tmp_dir):
shutil.rmtree(tmp_dir)
vm_xml_backup.sync()
dev_xml.device = "disk"
dev_xml.source = dev_xml.new_disk_source(
**{"attrs": {
'file': path
}})
dev_xml.driver = {
"name": "qemu",
"type": 'qcow2',
"cache": "none"
}
dev_xml.target = {"dev": 'sdb', "bus": "usb"}
dev_xml.address = dev_xml.new_disk_address(
**{"attrs": attributes})
else:
if usb_type == "mouse":
dev_xml = Input("mouse")
elif usb_type == "tablet":
dev_xml = Input("tablet")
else:
dev_xml = Input("keyboard")
dev_xml.input_bus = "usb"
dev_xml.address = dev_xml.new_input_address(
**{"attrs": attributes})
result = virsh.attach_device(vm_name, dev_xml.xml)
if result.exit_status:
raise process.CmdError(result.command, result)
if status_error and usb_type == "storage":
if utils_misc.wait_for(is_hotplug_ok, timeout=30):
if hub.type_name == "usb":
vmxml.del_device(hub)
# Add new usb controllers.
usb_controller1 = Controller("controller")
usb_controller1.type = "usb"
usb_controller1.index = "0"
usb_controller1.model = "piix3-uhci"
vmxml.add_device(usb_controller1)
usb_controller2 = Controller("controller")
usb_controller2.type = "usb"
usb_controller2.index = "1"
usb_controller2.model = "ich9-ehci1"
vmxml.add_device(usb_controller2)
input_obj = Input("tablet")
input_obj.input_bus = "usb"
vmxml.add_device(input_obj)
usb_devices.update({"input": None})
hub_obj = Hub("usb")
vmxml.add_device(hub_obj)
usb_devices.update({"hub": None})
if dom_iothreads:
# Delete cputune/iothreadids section, it may have conflict
# with domain iothreads
del vmxml.cputune
del vmxml.iothreadids
vmxml.iothreads = int(dom_iothreads)
vmxml.sync()
def run(test, params, env):
"""
Stress test for the hotplug feature of usb device.
"""
# get the params from params
vm_name = params.get("main_vm", "virt-tests-vm1")
vm = env.get_vm(vm_name)
keyboard = "yes" == params.get("usb_hotplug_keyboard", "no")
mouse = "yes" == params.get("usb_hotplug_mouse", "no")
tablet = "yes" == params.get("usb_hotplug_tablet", "no")
disk = "yes" == params.get("usb_hotplug_disk", "no")
attach_count = int(params.get("attach_count", "1"))
attach_type = params.get("attach_type", "attach_device")
bench_type = params.get("guest_bench", None)
control_file = params.get("control_file", None)
status_error = ("yes" == params.get("status_error", "no"))
vm_xml = VMXML.new_from_inactive_dumpxml(vm_name)
vm_xml_backup = vm_xml.copy()
tmp_dir = os.path.join(data_dir.get_tmp_dir(), "usb_hotplug_files")
if control_file is not None:
params["test_control_file"] = control_file
params["main_vm"] = vm_name
control_path = os.path.join(test.virtdir, "control", control_file)
session = vm.wait_for_login()
command = utils_test.run_autotest(vm,
session,
control_path,
None,
None,
params,
copy_only=True)
session.cmd("%s &" % command)
def _is_iozone_running():
session_tmp = vm.wait_for_login()
return (
not session_tmp.cmd_status("ps -ef|grep iozone|grep -v grep"))
def _is_stress_running():
session_tmp = vm.wait_for_login()
return (
not session_tmp.cmd_status("ps -ef|grep stress|grep -v grep"))
if bench_type == "stress":
if not utils_misc.wait_for(_is_stress_running, timeout=160):
raise error.TestNAError(
"Failed to run stress in guest.\n"
"Since we need to run a autotest of iozone "
"in guest, so please make sure there are "
"some necessary packages in guest,"
"such as gcc, tar, bzip2")
elif bench_type == "iozone":
if not utils_misc.wait_for(_is_iozone_running, timeout=160):
raise error.TestNAError(
"Failed to run iozone in guest.\n"
"Since we need to run a autotest of iozone "
"in guest, so please make sure there are "
"some necessary packages in guest,"
"such as gcc, tar, bzip2")
logging.debug("bench is already running in guest.")
try:
try:
result = None
disk_xml = None
tablet_xml = None
mouse_xml = None
if not os.path.isdir(tmp_dir):
os.mkdir(tmp_dir)
for i in range(attach_count):
path = os.path.join(tmp_dir, "%s.img" % i)
if attach_type == "qemu_monitor":
options = "--hmp"
if disk:
utils_test.libvirt.create_local_disk("file",
path,
size="1M")
attach_cmd = "drive_add"
attach_cmd += (
" 0 id=drive-usb-disk%s,if=none,file=%s" %
(i, path))
result = virsh.qemu_monitor_command(vm_name,
attach_cmd,
options=options)
if result.exit_status:
raise error.CmdError(result.command, result)
if keyboard:
attach_cmd = "device_add"
attach_cmd += " usb-kdb,bus=usb1.0,id=kdb"
result = virsh.qemu_monitor_command(vm_name,
attach_cmd,
options=options)
if result.exit_status:
raise error.CmdError(result.command, result)
if mouse:
attach_cmd = "device_add"
attach_cmd += " usb-mouse,bus=usb1.0,id=mouse"
result = virsh.qemu_monitor_command(vm_name,
attach_cmd,
options=options)
if result.exit_status:
raise error.CmdError(result.command, result)
if tablet:
attach_cmd = "device_add"
attach_cmd += " usb-tablet,bus=usb1.0,id=tablet"
result = virsh.qemu_monitor_command(vm_name,
attach_cmd,
options=options)
if result.exit_status:
raise error.CmdError(result.command, result)
else:
if disk:
utils_test.libvirt.create_local_disk("file",
path,
size="1M")
os.chmod(path, 0666)
disk_xml = Disk(type_name="file")
disk_xml.device = "disk"
disk_xml.source = disk_xml.new_disk_source(
**{"attrs": {
'file': path
}})
disk_xml.driver = {
"name": "qemu",
"type": 'raw',
"cache": "none"
}
disk_xml.target = {"dev": 'sdb', "bus": "usb"}
attributes = {
'type_name': "usb",
'bus': "1",
'port': "0"
}
disk_xml.address = disk_xml.new_disk_address(
**{"attrs": attributes})
result = virsh.attach_device(vm_name, disk_xml.xml)
if result.exit_status:
raise error.CmdError(result.command, result)
if mouse:
mouse_xml = Input("mouse")
mouse_xml.input_bus = "usb"
attributes = {
'type_name': "usb",
'bus': "1",
'port': "0"
}
mouse_xml.address = mouse_xml.new_input_address(
**{"attrs": attributes})
result = virsh.attach_device(vm_name, mouse_xml.xml)
if result.exit_status:
raise error.CmdError(result.command, result)
if tablet:
tablet_xml = Input("tablet")
tablet_xml.input_bus = "usb"
attributes = {
'type_name': "usb",
'bus': "1",
'port': "0"
}
tablet_xml.address = tablet_xml.new_input_address(
**{"attrs": attributes})
result = virsh.attach_device(vm_name, tablet_xml.xml)
if result.exit_status:
raise error.CmdError(result.command, result)
if keyboard:
kbd_xml = Input("keyboard")
kbd_xml.input_bus = "usb"
attributes = {
'type_name': "usb",
'bus': "1",
'port': "0"
}
kbd_xml.address = kbd_xml.new_input_address(
**{"attrs": attributes})
result = virsh.attach_device(vm_name, kbd_xml.xml)
if result.exit_status:
raise error.CmdError(result.command, result)
if attach_type == "qemu_monitor":
options = "--hmp"
if disk:
attach_cmd = "drive_del"
attach_cmd += (" drive-usb-disk")
result = virsh.qemu_monitor_command(vm_name,
attach_cmd,
options=options)
if result.exit_status:
raise error.CmdError(result.command, result)
if mouse:
attach_cmd = "device_del"
attach_cmd += (" mouse")
result = virsh.qemu_monitor_command(vm_name,
attach_cmd,
options=options)
if result.exit_status:
raise error.CmdError(result.command, result)
if keyboard:
attach_cmd = "device_del"
attach_cmd += (" keyboard")
result = virsh.qemu_monitor_command(vm_name,
attach_cmd,
options=options)
if result.exit_status:
raise error.CmdError(result.command, result)
if tablet:
attach_cmd = "device_del"
attach_cmd += (" tablet")
result = virsh.qemu_monitor_command(vm_name,
attach_cmd,
options=options)
if result.exit_status:
raise error.CmdError(result.command, result)
else:
if disk:
result = virsh.detach_device(vm_name, disk_xml.xml)
if result.exit_status:
raise error.CmdError(result.command, result)
if mouse:
result = virsh.detach_device(vm_name, mouse_xml.xml)
if result.exit_status:
raise error.CmdError(result.command, result)
if keyboard:
result = virsh.detach_device(vm_name, kbd_xml.xml)
if result.exit_status:
raise error.CmdError(result.command, result)
if tablet:
result = virsh.detach_device(vm_name, tablet_xml.xml)
if result.exit_status:
raise error.CmdError(result.command, result)
except error.CmdError, e:
if not status_error:
raise error.TestFail("failed to attach device.\n"
"Detail: %s." % result)
finally:
if os.path.isdir(tmp_dir):
shutil.rmtree(tmp_dir)
vm_xml_backup.sync()
def run(test, params, env):
"""
Test for hotplug usb device.
"""
# get the params from params
vm_name = params.get("main_vm", "avocado-vt-vm1")
vm = env.get_vm(vm_name)
usb_type = params.get("usb_type", "kbd")
attach_type = params.get("attach_type", "attach_device")
attach_count = int(params.get("attach_count", "1"))
if usb_type == "storage":
model = params.get("model", "nec-xhci")
index = params.get("index", "1")
status_error = ("yes" == params.get("status_error", "no"))
vm_xml = VMXML.new_from_inactive_dumpxml(vm_name)
vm_xml_backup = vm_xml.copy()
# Set selinux of host.
backup_sestatus = utils_selinux.get_status()
utils_selinux.set_status("permissive")
if usb_type == "storage":
controllers = vm_xml.get_devices(device_type="controller")
devices = vm_xml.get_devices()
for dev in controllers:
if dev.type == "usb" and dev.index == "1":
devices.remove(dev)
controller = Controller("controller")
controller.type = "usb"
controller.index = index
controller.model = model
devices.append(controller)
vm_xml.set_devices(devices)
try:
session = vm.wait_for_login()
except (LoginError, VMError, ShellError) as e:
test.fail("Test failed: %s" % str(e))
def is_hotplug_ok():
try:
output = session.cmd_output(
"fdisk -l | grep -c '^Disk /dev/.* 1 M'")
if int(output.strip()) != attach_count:
return False
else:
return True
except ShellTimeoutError as detail:
test.fail("unhotplug failed: %s, " % detail)
tmp_dir = os.path.join(data_dir.get_tmp_dir(), "usb_hotplug_files")
if not os.path.isdir(tmp_dir):
os.mkdir(tmp_dir)
try:
result = None
dev_xml = None
opt = "--hmp"
for i in range(attach_count):
if usb_type == "storage":
path = os.path.join(tmp_dir, "%s.img" % i)
libvirt.create_local_disk("file",
path,
size="1M",
disk_format="qcow2")
os.chmod(path, 0o666)
if attach_type == "qemu_monitor":
if usb_type == "storage":
attach_cmd = "drive_add"
attach_cmd += (" 0 id=drive-usb-%s,if=none,file=%s" %
(i, path))
result = virsh.qemu_monitor_command(vm_name,
attach_cmd,
options=opt)
if result.exit_status or (result.stdout.strip().find("OK")
== -1):
raise process.CmdError(result.command, result)
attach_cmd = "device_add usb-storage,"
attach_cmd += (
"id=drive-usb-%s,bus=usb1.0,drive=drive-usb-%s" %
(i, i))
else:
attach_cmd = "device_add"
attach_cmd += " usb-%s,bus=usb1.0,id=%s%s" % (usb_type,
usb_type, i)
result = virsh.qemu_monitor_command(vm_name,
attach_cmd,
options=opt)
if result.exit_status:
raise process.CmdError(result.command, result)
else:
attributes = {'type_name': "usb", 'bus': "1", 'port': "0"}
if usb_type == "storage":
dev_xml = Disk(type_name="file")
dev_xml.device = "disk"
dev_xml.source = dev_xml.new_disk_source(
**{"attrs": {
'file': path
}})
dev_xml.driver = {
"name": "qemu",
"type": 'qcow2',
"cache": "none"
}
dev_xml.target = {"dev": 'sdb', "bus": "usb"}
dev_xml.address = dev_xml.new_disk_address(
**{"attrs": attributes})
else:
if usb_type == "mouse":
dev_xml = Input("mouse")
elif usb_type == "tablet":
dev_xml = Input("tablet")
else:
dev_xml = Input("keyboard")
dev_xml.input_bus = "usb"
dev_xml.address = dev_xml.new_input_address(
**{"attrs": attributes})
result = virsh.attach_device(vm_name, dev_xml.xml)
if result.exit_status:
raise process.CmdError(result.command, result)
if status_error and usb_type == "storage":
if utils_misc.wait_for(is_hotplug_ok, timeout=30):
# Sometimes we meet an error but the ret in $? is 0.
test.fail("\nAttach device successfully in negative case."
"\nExcept it fail when attach count exceed maximum."
"\nDetail: %s" % result)
for i in range(attach_count):
attach_cmd = "device_del"
if attach_type == "qemu_monitor":
if usb_type == "storage":
attach_cmd += (" drive-usb-%s" % i)
else:
if usb_type == "mouse":
attach_cmd += " mouse"
elif usb_type == "tablet":
attach_cmd += " tablet"
else:
attach_cmd += " keyboard"
result = virsh.qemu_monitor_command(vm_name,
attach_cmd,
options=opt)
if result.exit_status:
raise process.CmdError(result.command, result)
else:
result = virsh.detach_device(vm_name, dev_xml.xml)
if result.exit_status:
raise process.CmdError(result.command, result)
except process.CmdError as e:
if not status_error:
# live attach of device 'input' is not supported
ret = result.stderr.find("Operation not supported")
if usb_type != "storage" and ret > -1:
pass
else:
test.fail("failed to attach device.\nDetail: %s." % result)
finally:
session.close()
if os.path.isdir(tmp_dir):
shutil.rmtree(tmp_dir)
utils_selinux.set_status(backup_sestatus)
vm_xml_backup.sync()
def run(test, params, env):
"""
Test the input virtual devices
1. prepare a guest with different input devices
2. check whether the guest can be started
3. check the qemu cmd line
"""
def check_dumpxml():
"""
Check whether the added devices are shown in the guest xml
"""
pattern = "<input bus=\"%s\" type=\"%s\">" % (bus_type, input_type)
xml_after_adding_device = VMXML.new_from_dumpxml(vm_name)
if pattern not in str(xml_after_adding_device):
test.fail("Can not find the %s input device xml "
"in the guest xml file." % input_type)
def check_qemu_cmd_line():
"""
Check whether the added devices are shown in the qemu cmd line
"""
# if the tested input device is a keyboard or mouse with ps2 bus,
# there is no keyboard or mouse in qemu cmd line
if bus_type == "ps2" and input_type in ["keyboard", "mouse"]:
return
with open('/proc/%s/cmdline' % vm.get_pid(), 'r') as cmdline_file:
cmdline = cmdline_file.read()
if bus_type == "usb" and input_type == "keyboard":
pattern = r"-device.%s-kbd" % bus_type
elif input_type == "passthrough":
pattern = r"-device.%s-input-host-pci" % bus_type
else:
pattern = r"-device.%s-%s" % (bus_type, input_type)
if not re.search(pattern, cmdline):
test.fail("Can not find the %s input device "
"in qemu cmd line." % input_type)
vm_name = params.get("main_vm", "avocado-vt-vm1")
vm = env.get_vm(vm_name)
status_error = params.get("status_error", "no") == "yes"
bus_type = params.get("bus_type")
input_type = params.get("input_type")
if input_type == "tablet":
if not libvirt_version.version_compare(1, 2, 2):
test.cancel("tablet input type is not supported "
"on the current version.")
if input_type == "passthrough" or bus_type == "virtio":
if not libvirt_version.version_compare(1, 3, 0):
test.cancel("passthrough input type or virtio bus type "
"is not supported on current version.")
vm_xml = VMXML.new_from_dumpxml(vm_name)
vm_xml_backup = vm_xml.copy()
if vm.is_alive():
vm.destroy()
try:
# ps2 keyboard and ps2 mouse are default, no need to re-add the xml
if not (bus_type == "ps2" and input_type in ["keyboard", "mouse"]):
vm_xml.remove_all_device_by_type('input')
input_dev = Input(type_name=input_type)
input_dev.input_bus = bus_type
if input_type == "passthrough":
kbd_dev_name = glob.glob('/dev/input/by-path/*kbd')
if not kbd_dev_name:
test.cancel("There is no keyboard device on this host.")
logging.debug(
"keyboard %s is going to be passthrough "
"to the host.", kbd_dev_name[0])
input_dev.source_evdev = kbd_dev_name[0]
vm_xml.add_device(input_dev)
try:
vm_xml.sync()
except Exception as error:
if not status_error:
test.fail(
"Failed to define the guest after adding the %s input "
"device xml. Details: %s " % (input_type, error))
logging.debug(
"This is the expected failing in negative cases.")
return
res = virsh.start(vm_name)
if res.exit_status:
if not status_error:
test.fail("Failed to start vm after adding the %s input "
"device xml. Details: %s " % (input_type, error))
logging.debug("This is the expected failure in negative cases.")
return
if status_error:
test.fail(
"Expected fail in negative cases but vm started successfully.")
return
logging.debug("VM started successfully in postive cases.")
check_dumpxml()
check_qemu_cmd_line()
finally:
if vm.is_alive():
virsh.destroy(vm_name)
vm_xml_backup.sync()