Merge pull request #1890 from vivianQizhu/chardev

virtio_serial: Add test case for port and pci hotplug

qemu/tests/cfg/virtio_port_hotplug.cfg

@@ -16,3 +16,20 @@
         - @unplug_port:
             unplug_chardev_vc1 = no
             unplug_chardev_vc2 = no
+        - hotplug_port_pci:
+            type = virtio_serial_hotplug_port_pci
+            start_vm = no
+            extra_chardevs = "channel1 channel2"
+            extra_serials = "port1 port2"
+            serial_type_port1 = "virtserialport"
+            serial_type_port2 = "virtserialport"
+            guest_scripts = VirtIoChannel_guest_send_receive.py;windows_support.py
+            host_script = serial_host_send_receive.py
+            guest_script = VirtIoChannel_guest_send_receive.py
+            clean_cmd = rm -f
+            guest_script_folder = /var/tmp/
+            Windows:
+                guest_script_folder = C:\
+                clean_cmd = del /f /q
+                tmp_dir = %TEMP%
+                python_bin = python2.7

qemu/tests/virtio_console.py

@@ -24,6 +24,8 @@ from virttest import utils_misc
 from virttest import funcatexit
 from virttest.qemu_devices import qdevices
 from virttest.utils_virtio_port import VirtioPortTest
+from virttest.qemu_devices import qcontainer
+
 
 EXIT_EVENT = threading.Event()
 
@@ -37,6 +39,84 @@ def __set_exit_event():
     EXIT_EVENT.set()
 
 
+def add_chardev(vm, params):
+    """
+    Generate extra CharDevice without serial device utilize it
+
+    :param vm: VM object to be operated
+    :param params: Dictionary with the test parameters
+    :return list of added CharDevice object
+    """
+    qemu_binary = utils_misc.get_qemu_binary(params)
+    qdevices = qcontainer.DevContainer(qemu_binary, vm.name,
+                                       params.get('strict_mode'),
+                                       params.get(
+                                           'workaround_qemu_qmp_crash'),
+                                       params.get('allow_hotplugged_vm'))
+    char_devices = params['extra_chardevs'].split()
+    host = params.get('chardev_host', '127.0.0.1')
+    free_ports = utils_misc.find_free_ports(
+        5000, 6000, len(char_devices), host)
+    device_list = []
+    for index, chardev in enumerate(char_devices):
+        chardev_param = params.object_params(chardev)
+        file_name = vm.get_serial_console_filename(chardev)
+        backend = chardev_param.get('chardev_backend',
+                                    'unix_socket')
+        if backend in ['udp', 'tcp_socket']:
+            chardev_param['chardev_host'] = host
+            chardev_param['chardev_port'] = str(free_ports[index])
+        device = qdevices.chardev_define_by_params(
+            chardev, chardev_param, file_name)
+        device_list.append(device)
+    return device_list
+
+
+def add_virtserial_device(vm, params, serial_id, chardev_id):
+    """
+    Generate extra serial devices individually, without CharDevice
+
+    :param vm: VM object to be operated
+    :param params: Dictionary with the test parameters
+    :return list of added serial devices
+    """
+    s_params = params.object_params(serial_id)
+    serial_type = s_params['serial_type']
+    machine = params.get('machine_type')
+    if '-mmio' in machine:
+        controller_suffix = 'device'
+    elif machine.startswith("s390"):
+        controller_suffix = 'ccw'
+    else:
+        controller_suffix = 'pci'
+    bus_type = 'virtio-serial-%s' % controller_suffix
+    return vm.devices.serials_define_by_variables(
+        serial_id, serial_type, chardev_id, bus_type,
+        s_params.get('serial_name'), s_params.get('serial_bus'),
+        s_params.get('serial_nr'), s_params.get('serial_reg'))
+
+
+def add_virtio_ports_to_vm(vm, params, serial_device):
+    """
+    Add serial device to vm.virtio_ports
+
+    :param vm: VM object to be operated
+    :param params: Dictionary with the test parameters
+    :param serial_device: serial device object
+    """
+    serial_id = serial_device.get_qid()
+    chardev_id = serial_device.get_param('chardev')
+    chardev = vm.devices.get(chardev_id)
+    filename = chardev.get_param('path')
+    chardev_params = params.object_params(chardev_id)
+    backend = chardev_params.get('chardev_backend', 'unix_socket')
+    if backend in ['udp', 'tcp_socket']:
+        filename = (chardev.get_param('host'), chardev.get_param('port'))
+    serial_name = serial_device.get_param('name')
+    vm.virtio_ports.append(qemu_virtio_port.VirtioSerial(
+        serial_id, serial_name, filename, backend))
+
+
 @error_context.context_aware
 def run(test, params, env):
     """

qemu/tests/virtio_serial_hotplug_port_pci.py

+from virttest import error_context
+from virttest import env_process
+from virttest.qemu_monitor import QMPCmdError
+
+from qemu.tests.virtio_console import add_chardev
+from qemu.tests.virtio_console import add_virtserial_device
+from qemu.tests.virtio_console import add_virtio_ports_to_vm
+from qemu.tests.virtio_serial_file_transfer import transfer_data
+
+
+@error_context.context_aware
+def run(test, params, env):
+    """
+    Hot-plug virtio-serial-pci and virtserialport
+
+    1. Boot a guest with 2 chardev, no serial port & no pci
+    2. Hot plug virtio-serial-bus
+    3. Hot add virtserialport, attached on chardev 1
+    4. Hot plug another serial port on chardev 2 with "nr=1", should fail
+    5. Hot plug the serial port again with "nr=2"
+    6. Transfer data from host to guest via port1
+    7. Transfer data from guest to host via port2
+
+    :param test: kvm test object
+    :param params: Dictionary with the test parameters
+    :param env: Dictionary with test environment
+    """
+
+    params['serials'] = params.objects('serials')[0]
+    vm = env.get_vm(params['main_vm'])
+    char_devices = add_chardev(vm, params)
+    for device in char_devices:
+        extra_params = ' ' + device.cmdline()
+        params['extra_params'] = params.get('extra_params', '') + extra_params
+    params['start_vm'] = "yes"
+    env_process.preprocess(test, params, env)
+    vm = env.get_vm(params['main_vm'])
+    vm.devices.insert(char_devices)
+    serials = params.objects('extra_serials')
+    buses = []
+    serial_devices = []
+    for index, serial_id in enumerate(serials):
+        chardev_id = char_devices[index].get_qid()
+        params['serial_name_%s' % serial_id] = serial_id
+        devices = add_virtserial_device(vm, params, serial_id, chardev_id)
+        for device in devices:
+            if device.child_bus:
+                buses.append(device)
+            else:
+                serial_devices.append(device)
+    vm.devices.simple_hotplug(buses[0], vm.monitor)
+    vm.devices.simple_hotplug(serial_devices[0], vm.monitor)
+    pre_nr = serial_devices[0].get_param('nr')
+    # Try hotplug different device with same 'nr'
+    serial_devices[1].set_param('bus', serial_devices[0].get_param('bus'))
+    serial_devices[1].set_param('nr', pre_nr)
+    try:
+        serial_devices[1].hotplug(vm.monitor)
+    except QMPCmdError as e:
+        if 'A port already exists at id %d' % pre_nr not in str(e.data):
+            test.fail('Hotplug fail for %s, not as expected' % str(e.data))
+    else:
+        test.fail('Hotplug with same "nr" option success while should fail')
+    serial_devices[1].set_param('nr', int(pre_nr) + 1)
+    vm.devices.simple_hotplug(serial_devices[1], vm.monitor)
+    for device in serial_devices:
+        add_virtio_ports_to_vm(vm, params, device)
+    params['file_transfer_serial_port'] = serials[0]
+    transfer_data(params, vm, sender='host')
+    params['file_transfer_serial_port'] = serials[1]
+    transfer_data(params, vm, sender='guest')