| """ |
| virtio_console test |
| |
| @copyright: 2010 Red Hat, Inc. |
| """ |
| import array, logging, os, random, re, select, shutil, socket, sys, tempfile |
| import threading, time, traceback |
| from collections import deque |
| from threading import Thread |
| |
| from autotest_lib.client.common_lib import error |
| from autotest_lib.client.bin import utils |
| from autotest_lib.client.virt import virt_utils, virt_test_utils, kvm_monitor |
| from autotest_lib.client.virt import virt_env_process, aexpect |
| |
| |
| def run_virtio_console(test, params, env): |
| """ |
| KVM virtio_console test |
| |
| 1) Starts VMs with the specified number of virtio console devices |
| 2) Start smoke test |
| 3) Start loopback test |
| 4) Start performance test |
| |
| This test uses an auxiliary script, virtio_console_guest.py, that is copied |
| to guests. This script has functions to send and write data to virtio |
| console ports. Details of each test can be found on the docstrings for the |
| test_* functions. |
| |
| @param test: kvm test object |
| @param params: Dictionary with the test parameters |
| @param env: Dictionary with test environment |
| """ |
| class SubTest(object): |
| """ |
| Collect result of subtest of main test. |
| """ |
| def __init__(self): |
| """ |
| Initialize object |
| """ |
| self.result = [] |
| self.passed = 0 |
| self.failed = 0 |
| self.cleanup_func = None |
| self.cleanup_args = None |
| |
| |
| def set_cleanup_func(self, func, args): |
| """ |
| Set cleanup function which is called when subtest fails. |
| |
| @param func: Function which should be called when test fails. |
| @param args: Arguments of cleanup function. |
| """ |
| self.cleanup_func = func |
| self.cleanup_args = args |
| |
| |
| def get_cleanup_func(self): |
| """ |
| Returns the tupple of cleanup_func and clenaup_args |
| |
| @return: Tupple of self.cleanup_func and self.cleanup_args |
| """ |
| return (self.cleanup_func, self.cleanup_args) |
| |
| |
| def do_test(self, function, args=None, fatal=False, cleanup=True): |
| """ |
| Execute subtest function. |
| |
| @param function: Object of function. |
| @param args: List of arguments of function. |
| @param fatal: If true exception is forwarded to main test. |
| @param cleanup: If true call cleanup function after crash of test. |
| @return: Return what returned executed subtest. |
| @raise TestError: If collapse of test is fatal raise forward |
| exception from subtest. |
| """ |
| if args is None: |
| args = [] |
| res = [None, function.func_name, args] |
| try: |
| logging.info("Starting test %s" % function.func_name) |
| ret = function(*args) |
| res[0] = True |
| logging.info(self.result_to_string(res)) |
| self.result.append(res) |
| self.passed += 1 |
| return ret |
| except: |
| exc_type, exc_value, exc_traceback = sys.exc_info() |
| logging.error("In function (" + function.func_name + "):") |
| logging.error("Call from:\n" + |
| traceback.format_stack()[-2][:-1]) |
| logging.error("Exception from:\n" + |
| "".join(traceback.format_exception( |
| exc_type, exc_value, |
| exc_traceback.tb_next))) |
| # Clean up environment after subTest crash |
| res[0] = False |
| logging.info(self.result_to_string(res)) |
| self.result.append(res) |
| self.failed += 1 |
| |
| if cleanup: |
| try: |
| self.cleanup_func(*self.cleanup_args) |
| except: |
| error.TestFail("Cleanup function crashed as well") |
| if fatal: |
| raise |
| |
| |
| def is_failed(self): |
| """ |
| @return: If any of subtest not pass return True. |
| """ |
| if self.failed > 0: |
| return True |
| else: |
| return False |
| |
| |
| def get_result(self): |
| """ |
| @return: Result of subtests. |
| Format: |
| tuple(pass/fail,function_name,call_arguments) |
| """ |
| return self.result |
| |
| |
| def result_to_string_debug(self, result): |
| """ |
| @param result: Result of test. |
| """ |
| sargs = "" |
| for arg in result[2]: |
| sargs += str(arg) + "," |
| sargs = sargs[:-1] |
| if result[0]: |
| status = "PASS" |
| else: |
| status = "FAIL" |
| return ("Subtest (%s(%s)): --> %s") % (result[1], sargs, status) |
| |
| |
| def result_to_string(self, result): |
| """ |
| @param result: Result of test. |
| """ |
| if result[0]: |
| status = "PASS" |
| else: |
| status = "FAIL" |
| return ("Subtest (%s): --> %s") % (result[1], status) |
| |
| |
| def headline(self, msg): |
| """ |
| Add headline to result output. |
| |
| @param msg: Test of headline |
| """ |
| self.result.append([msg]) |
| |
| |
| def _gen_res(self, format_func): |
| """ |
| Format result with formatting function |
| |
| @param format_func: Func for formating result. |
| """ |
| result = "" |
| for res in self.result: |
| if (len(res) == 3): |
| result += format_func(res) + "\n" |
| else: |
| result += res[0] + "\n" |
| return result |
| |
| |
| def get_full_text_result(self): |
| """ |
| @return string with text form of result |
| """ |
| return self._gen_res(lambda str: self.result_to_string_debug(str)) |
| |
| |
| def get_text_result(self): |
| """ |
| @return string with text form of result |
| """ |
| return self._gen_res(lambda str: self.result_to_string(str)) |
| |
| |
| class Port(object): |
| """ |
| Define structure to keep information about used port. |
| """ |
| def __init__(self, sock, name, port_type, path): |
| """ |
| @param vm: virtual machine object that port owned |
| @param sock: Socket of port if port is open. |
| @param name: Name of port for guest side. |
| @param port_type: Type of port yes = console, no= serialport. |
| @param path: Path to port on host side. |
| """ |
| self.sock = sock |
| self.name = name |
| self.port_type = port_type |
| self.path = path |
| self.is_open = False |
| |
| |
| def for_guest(self): |
| """ |
| Format data for communication with guest side. |
| """ |
| return [self.name, self.port_type] |
| |
| |
| def open(self): |
| """ |
| Open port on host side. |
| """ |
| attempt = 11 |
| while attempt > 0: |
| try: |
| self.sock = socket.socket(socket.AF_UNIX, |
| socket.SOCK_STREAM) |
| self.sock.connect(self.path) |
| self.sock.setsockopt(1,socket.SO_SNDBUF, 2048) |
| self.is_open = True |
| return |
| except Exception, inst: |
| attempt -= 1 |
| time.sleep(1) |
| raise error.TestFail("Can't open the %s sock" % self.name) |
| |
| |
| def clean_port(self): |
| """ |
| Clean all data from opened port on host side. |
| """ |
| if self.is_open: |
| self.close() |
| self.open() |
| ret = select.select([self.sock], [], [], 1.0) |
| if ret[0]: |
| buf = self.sock.recv(1024) |
| logging.debug("Rest in socket: " + buf) |
| |
| |
| def close(self): |
| """ |
| Close port. |
| """ |
| self.sock.shutdown(socket.SHUT_RDWR) |
| self.sock.close() |
| self.is_open = False |
| |
| |
| def __str__(self): |
| """ |
| Convert to text. |
| """ |
| return ("%s,%s,%s,%s,%d" % ("Socket", self.name, self.port_type, |
| self.path, self.is_open)) |
| |
| |
| class ThSend(Thread): |
| """ |
| Random data sender thread. |
| """ |
| def __init__(self, port, data, event, quiet=False): |
| """ |
| @param port: Destination port. |
| @param data: The data intend to be send in a loop. |
| @param event: Exit event. |
| @param quiet: If true don't raise event when crash. |
| """ |
| Thread.__init__(self) |
| self.port = port |
| # FIXME: socket.send(data>>127998) without read blocks thread |
| if len(data) > 102400: |
| data = data[0:102400] |
| logging.error("Data is too long, using only first %d bytes", |
| len(data)) |
| self.data = data |
| self.exitevent = event |
| self.idx = 0 |
| self.quiet = quiet |
| |
| |
| def run(self): |
| logging.debug("ThSend %s: run", self.getName()) |
| try: |
| while not self.exitevent.isSet(): |
| self.idx += self.port.send(self.data) |
| logging.debug("ThSend %s: exit(%d)", self.getName(), |
| self.idx) |
| except Exception, ints: |
| if not self.quiet: |
| raise ints |
| logging.debug(ints) |
| |
| |
| class ThSendCheck(Thread): |
| """ |
| Random data sender thread. |
| """ |
| def __init__(self, port, event, queues, blocklen=1024): |
| """ |
| @param port: Destination port |
| @param event: Exit event |
| @param queues: Queues for the control data (FIFOs) |
| @param blocklen: Block length |
| """ |
| Thread.__init__(self) |
| self.port = port |
| self.queues = queues |
| # FIXME: socket.send(data>>127998) without read blocks thread |
| if blocklen > 102400: |
| blocklen = 102400 |
| logging.error("Data is too long, using blocklen = %d", |
| blocklen) |
| self.blocklen = blocklen |
| self.exitevent = event |
| self.idx = 0 |
| |
| |
| def run(self): |
| logging.debug("ThSendCheck %s: run", self.getName()) |
| too_much_data = False |
| while not self.exitevent.isSet(): |
| # FIXME: workaround the problem with qemu-kvm stall when too |
| # much data is sent without receiving |
| for queue in self.queues: |
| while not self.exitevent.isSet() and len(queue) > 1048576: |
| too_much_data = True |
| time.sleep(0.1) |
| ret = select.select([], [self.port.sock], [], 1.0) |
| if ret[1]: |
| # Generate blocklen of random data add them to the FIFO |
| # and send them over virtio_console |
| buf = "" |
| for i in range(self.blocklen): |
| ch = "%c" % random.randrange(255) |
| buf += ch |
| for queue in self.queues: |
| queue.append(ch) |
| target = self.idx + self.blocklen |
| while not self.exitevent.isSet() and self.idx < target: |
| try: |
| idx = self.port.sock.send(buf) |
| except Exception, inst: |
| # Broken pipe |
| if inst.errno == 32: |
| logging.debug("ThSendCheck %s: Broken pipe " |
| "(migration?), reconnecting", |
| self.getName()) |
| attempt = 10 |
| while (attempt > 1 |
| and not self.exitevent.isSet()): |
| self.port.is_open = False |
| self.port.open() |
| try: |
| idx = self.port.sock.send(buf) |
| except: |
| attempt += 1 |
| time.sleep(10) |
| else: |
| attempt = 0 |
| buf = buf[idx:] |
| self.idx += idx |
| logging.debug("ThSendCheck %s: exit(%d)", self.getName(), |
| self.idx) |
| if too_much_data: |
| logging.error("ThSendCheck: working around the 'too_much_data'" |
| "bug") |
| |
| |
| class ThRecv(Thread): |
| """ |
| Recieves data and throws it away. |
| """ |
| def __init__(self, port, event, blocklen=1024, quiet=False): |
| """ |
| @param port: Data source port. |
| @param event: Exit event. |
| @param blocklen: Block length. |
| @param quiet: If true don't raise event when crash. |
| """ |
| Thread.__init__(self) |
| self.port = port |
| self._port_timeout = self.port.gettimeout() |
| self.port.settimeout(0.1) |
| self.exitevent = event |
| self.blocklen = blocklen |
| self.idx = 0 |
| self.quiet = quiet |
| |
| |
| def run(self): |
| logging.debug("ThRecv %s: run", self.getName()) |
| try: |
| while not self.exitevent.isSet(): |
| # TODO: Workaround, it didn't work with select :-/ |
| try: |
| self.idx += len(self.port.recv(self.blocklen)) |
| except socket.timeout: |
| pass |
| self.port.settimeout(self._port_timeout) |
| logging.debug("ThRecv %s: exit(%d)", self.getName(), self.idx) |
| except Exception, ints: |
| if not self.quiet: |
| raise ints |
| logging.debug(ints) |
| |
| |
| class ThRecvCheck(Thread): |
| """ |
| Random data receiver/checker thread. |
| """ |
| def __init__(self, port, buffer, event, blocklen=1024, sendlen=0): |
| """ |
| @param port: Source port. |
| @param buffer: Control data buffer (FIFO). |
| @param length: Amount of data we want to receive. |
| @param blocklen: Block length. |
| @param sendlen: Block length of the send function (on guest) |
| """ |
| Thread.__init__(self) |
| self.port = port |
| self.buffer = buffer |
| self.exitevent = event |
| self.blocklen = blocklen |
| self.idx = 0 |
| self.sendlen = sendlen + 1 # >= |
| |
| |
| def run(self): |
| logging.debug("ThRecvCheck %s: run", self.getName()) |
| attempt = 10 |
| sendidx = -1 |
| minsendidx = self.sendlen |
| while not self.exitevent.isSet(): |
| ret = select.select([self.port.sock], [], [], 1.0) |
| if ret[0] and (not self.exitevent.isSet()): |
| buf = self.port.sock.recv(self.blocklen) |
| if buf: |
| # Compare the received data with the control data |
| for ch in buf: |
| ch_ = self.buffer.popleft() |
| if ch == ch_: |
| self.idx += 1 |
| else: |
| # TODO BUG: data from the socket on host can |
| # be lost during migration |
| while ch != ch_: |
| if sendidx > 0: |
| sendidx -= 1 |
| ch_ = self.buffer.popleft() |
| else: |
| self.exitevent.set() |
| logging.error("ThRecvCheck %s: " |
| "Failed to recv %dth " |
| "character", |
| self.getName(), self.idx) |
| logging.error("ThRecvCheck %s: " |
| "%s != %s", |
| self.getName(), |
| repr(ch), repr(ch_)) |
| logging.error("ThRecvCheck %s: " |
| "Recv = %s", |
| self.getName(), repr(buf)) |
| # sender might change the buffer :-( |
| time.sleep(1) |
| ch_ = "" |
| for buf in self.buffer: |
| ch_ += buf |
| ch_ += ' ' |
| logging.error("ThRecvCheck %s: " |
| "Queue = %s", |
| self.getName(), repr(ch_)) |
| logging.info("ThRecvCheck %s: " |
| "MaxSendIDX = %d", |
| self.getName(), |
| (self.sendlen - sendidx)) |
| raise error.TestFail("ThRecvCheck %s: " |
| "incorrect data", |
| self.getName()) |
| attempt = 10 |
| else: # ! buf |
| # Broken socket |
| if attempt > 0: |
| attempt -= 1 |
| logging.debug("ThRecvCheck %s: Broken pipe " |
| "(migration?), reconnecting. ", |
| self.getName()) |
| # TODO BUG: data from the socket on host can be lost |
| if sendidx >= 0: |
| minsendidx = min(minsendidx, sendidx) |
| logging.debug("ThRecvCheck %s: Previous data " |
| "loss was %d.", |
| self.getName(), |
| (self.sendlen - sendidx)) |
| sendidx = self.sendlen |
| self.port.is_open = False |
| self.port.open() |
| if sendidx >= 0: |
| minsendidx = min(minsendidx, sendidx) |
| if (self.sendlen - minsendidx): |
| logging.error("ThRecvCheck %s: Data loss occured during socket" |
| "reconnection. Maximal loss was %d per one " |
| "migration.", self.getName(), |
| (self.sendlen - minsendidx)) |
| logging.debug("ThRecvCheck %s: exit(%d)", self.getName(), |
| self.idx) |
| |
| |
| def process_stats(stats, scale=1.0): |
| """ |
| Process and print the stats. |
| |
| @param stats: List of measured data. |
| """ |
| if not stats: |
| return None |
| for i in range((len(stats) - 1), 0, -1): |
| stats[i] = stats[i] - stats[i - 1] |
| stats[i] /= scale |
| stats[0] /= scale |
| stats = sorted(stats) |
| return stats |
| |
| |
| def _init_guest(vm, timeout=10): |
| """ |
| Execute virtio_console_guest.py on guest, wait until it is initialized. |
| |
| @param vm: Informations about the guest. |
| @param timeout: Timeout that will be used to verify if the script |
| started properly. |
| """ |
| logging.debug("compile virtio_console_guest.py on guest %s", |
| vm[0].name) |
| |
| (match, data) = _on_guest("python -OO /tmp/virtio_console_guest.py -c" |
| "&& echo -n 'PASS: Compile virtio_guest finished' ||" |
| "echo -n 'FAIL: Compile virtio_guest failed'", |
| vm, timeout) |
| |
| if match != 0: |
| raise error.TestFail("Command console_switch.py on guest %s " |
| "failed.\nreturn code: %s\n output:\n%s" % |
| (vm[0].name, match, data)) |
| logging.debug("Starting virtio_console_guest.py on guest %s", |
| vm[0].name) |
| vm[1].sendline() |
| (match, data) = _on_guest("python /tmp/virtio_console_guest.pyo &&" |
| "echo -n 'PASS: virtio_guest finished' ||" |
| "echo -n 'FAIL: virtio_guest failed'", |
| vm, timeout) |
| if match != 0: |
| raise error.TestFail("Command console_switch.py on guest %s " |
| "failed.\nreturn code: %s\n output:\n%s" % |
| (vm[0].name, match, data)) |
| # Let the system rest |
| time.sleep(2) |
| |
| |
| def init_guest(vm, consoles): |
| """ |
| Prepares guest, executes virtio_console_guest.py and initializes test. |
| |
| @param vm: Informations about the guest. |
| @param consoles: Informations about consoles. |
| """ |
| conss = [] |
| for mode in consoles: |
| for cons in mode: |
| conss.append(cons.for_guest()) |
| _init_guest(vm, 10) |
| on_guest("virt.init(%s)" % (conss), vm, 10) |
| |
| |
| def _search_kernel_crashlog(vm_port, timeout=2): |
| """ |
| Find kernel crash message. |
| |
| @param vm_port : Guest output port. |
| @param timeout: Timeout used to verify expected output. |
| |
| @return: Kernel crash log or None. |
| """ |
| data = vm_port.read_nonblocking() |
| match = re.search("BUG:", data, re.MULTILINE) |
| if match is None: |
| return None |
| |
| match = re.search(r"BUG:.*---\[ end trace .* \]---", |
| data, re.DOTALL |re.MULTILINE) |
| if match is None: |
| data += vm_port.read_until_last_line_matches( |
| ["---\[ end trace .* \]---"],timeout) |
| |
| match = re.search(r"(BUG:.*---\[ end trace .* \]---)", |
| data, re.DOTALL |re.MULTILINE) |
| return match.group(0) |
| |
| |
| |
| def _on_guest(command, vm, timeout=2): |
| """ |
| Execute given command inside the script's main loop, indicating the vm |
| the command was executed on. |
| |
| @param command: Command that will be executed. |
| @param vm: Informations about the guest. |
| @param timeout: Timeout used to verify expected output. |
| |
| @return: Tuple (match index, data, kernel_crash) |
| """ |
| logging.debug("Executing '%s' on virtio_console_guest.py loop," + |
| " vm: %s, timeout: %s", command, vm[0].name, timeout) |
| vm[1].sendline(command) |
| try: |
| (match, data) = vm[1].read_until_last_line_matches(["PASS:", |
| "FAIL:"], |
| timeout) |
| |
| except aexpect.ExpectError, e: |
| match = None |
| data = "Cmd process timeout. Data in console: " + e.output |
| |
| kcrash_data = _search_kernel_crashlog(vm[3]) |
| if kcrash_data is not None: |
| logging.error(kcrash_data) |
| vm[4] = True |
| |
| return (match, data) |
| |
| |
| def on_guest(command, vm, timeout=2): |
| """ |
| Wrapper around the _on_guest command which executes the command on |
| guest. Unlike _on_guest command when the command fails it raises the |
| test error. |
| |
| @param command: Command that will be executed. |
| @param vm: Informations about the guest. |
| @param timeout: Timeout used to verify expected output. |
| |
| @return: Tuple (match index, data) |
| """ |
| match, data = _on_guest(command, vm, timeout) |
| if match == 1 or match is None: |
| raise error.TestFail("Failed to execute '%s' on" |
| " virtio_console_guest.py, " |
| "vm: %s, output:\n%s" % |
| (command, vm[0].name, data)) |
| |
| return (match, data) |
| |
| |
| def _guest_exit_threads(vm, send_pts, recv_pts): |
| """ |
| Safely executes on_guest("virt.exit_threads()") using workaround of |
| the stuck thread in loopback in mode=virt.LOOP_NONE . |
| |
| @param vm: Informations about the guest. |
| @param send_pts: list of possible send sockets we need to work around. |
| @param recv_pts: list of possible recv sockets we need to read-out. |
| """ |
| # in LOOP_NONE mode it might stuck in read/write |
| match, tmp = _on_guest("virt.exit_threads()", vm, 10) |
| if match is None: |
| logging.debug("Workaround the stuck thread on guest") |
| # Thread is stucked in read/write |
| for send_pt in send_pts: |
| send_pt.sock.sendall(".") |
| elif match != 0: |
| # Something else |
| raise error.TestFail("Unexpected fail\nMatch: %s\nData:\n%s" |
| % (match, tmp)) |
| |
| # Read-out all remaining data |
| for recv_pt in recv_pts: |
| while select.select([recv_pt.sock], [], [], 0.1)[0]: |
| recv_pt.sock.recv(1024) |
| |
| # This will cause fail in case anything went wrong. |
| on_guest("print 'PASS: nothing'", vm, 10) |
| |
| |
| def _vm_create(no_console=3, no_serialport=3, spread=True): |
| """ |
| Creates the VM and connects the specified number of consoles and serial |
| ports. |
| Ports are allocated by 2 per 1 virtio-serial-pci device starting with |
| console. (3+2 => CC|CS|S; 0+2 => SS; 3+4 => CC|CS|SS|S, ...) This way |
| it's easy to test communication on the same or different |
| virtio-serial-pci device. |
| Further in tests the consoles are being picked always from the first |
| available one (3+2: 2xC => CC|cs|s <communication on the same PCI>; |
| 2xC,1xS => CC|cS|s <communication between 2 PCI devs) |
| |
| @param no_console: Number of desired virtconsoles. |
| @param no_serialport: Number of desired virtserialports. |
| @return: Tuple with (guest information, consoles information) |
| guest informations = [vm, session, tmp_dir, kcrash] |
| consoles informations = [consoles[], serialports[]] |
| """ |
| consoles = [] |
| serialports = [] |
| tmp_dir = tempfile.mkdtemp(prefix="virtio-console-", dir="/tmp/") |
| params['extra_params'] = standard_extra_params |
| |
| if not spread: |
| pci = "virtio-serial-pci0" |
| params['extra_params'] += (" -device virtio-serial-pci,id=" |
| + pci) |
| pci += ".0" |
| for i in range(0, no_console): |
| # Spread consoles between multiple PCI devices (2 per a dev) |
| if not i % 2 and spread: |
| pci = "virtio-serial-pci%d" % (i / 2) |
| params['extra_params'] += (" -device virtio-serial-pci,id=" |
| + pci) |
| pci += ".0" |
| params['extra_params'] += (" -chardev socket,path=%s/%d,id=vc%d," |
| "server,nowait" % (tmp_dir, i, i)) |
| params['extra_params'] += (" -device virtconsole,chardev=vc%d," |
| "name=console-%d,id=console-%d,bus=%s" |
| % (i, i, i, pci)) |
| |
| for i in range(no_console, no_console + no_serialport): |
| # Spread serial ports between multiple PCI devices (2 per each dev) |
| if not i % 2 and spread: |
| pci = "virtio-serial-pci%d" % (i / 2) |
| params['extra_params'] += (" -device virtio-serial-pci,id=" |
| + pci) |
| pci += ".0" |
| params['extra_params'] += (" -chardev socket,path=%s/%d,id=vs%d," |
| "server,nowait" % (tmp_dir, i, i)) |
| params['extra_params'] += (" -device virtserialport,chardev=vs%d," |
| "name=serialport-%d,id=serialport-%d," |
| "bus=%s" % (i, i, i, pci)) |
| |
| (vm, session, sserial) = _restore_vm() |
| |
| # connect the sockets |
| for i in range(0, no_console): |
| consoles.append(Port(None ,"console-%d" % i, |
| "yes", "%s/%d" % (tmp_dir, i))) |
| for i in range(no_console, no_console + no_serialport): |
| serialports.append(Port(None ,"serialport-%d" % i, |
| "no", "%s/%d" % (tmp_dir, i))) |
| |
| kcrash = False |
| |
| return [vm, session, tmp_dir, sserial, kcrash], [consoles, serialports] |
| |
| |
| def _restore_vm(): |
| """ |
| Restore old virtual machine when VM is destroyed. |
| """ |
| logging.debug("Booting guest %s", params.get("main_vm")) |
| virt_env_process.preprocess_vm(test, params, env, |
| params.get("main_vm")) |
| |
| vm = env.get_vm(params.get("main_vm")) |
| |
| kernel_bug = None |
| try: |
| session = virt_test_utils.wait_for_login(vm, 0, |
| float(params.get("boot_timeout", 100)), |
| 0, 2) |
| except (error.TestFail): |
| kernel_bug = _search_kernel_crashlog(vm.serial_console, 10) |
| if kernel_bug is not None: |
| logging.error(kernel_bug) |
| raise |
| |
| kernel_bug = _search_kernel_crashlog(vm.serial_console, 10) |
| if kernel_bug is not None: |
| logging.error(kernel_bug) |
| |
| sserial = virt_test_utils.wait_for_login(vm, 0, |
| float(params.get("boot_timeout", 20)), |
| 0, 2, serial=True) |
| return [vm, session, sserial] |
| |
| |
| def topen(vm, port): |
| """ |
| Open virtioconsole port. |
| |
| @param vm: Target virtual machine [vm, session, tmp_dir, ser_session]. |
| @param port: Port identifier. |
| """ |
| on_guest("virt.open('%s')" % (port.name), vm, 10) |
| port.open() |
| |
| |
| def tcheck_zero_sym(vm): |
| """ |
| Check if port /dev/vport0p0 was created. |
| |
| @param vm: Target virtual machine [vm, session, tmp_dir, ser_session]. |
| """ |
| on_guest("virt.check_zero_sym()", vm, 10) |
| |
| |
| def tmulti_open(vm, port): |
| """ |
| Multiopen virtioconsole port. |
| |
| @param vm: Target virtual machine [vm, session, tmp_dir, ser_session]. |
| @param port: Port identifier. |
| """ |
| on_guest("virt.close('%s')" % (port.name), vm, 10) |
| on_guest("virt.open('%s')" % (port.name), vm, 10) |
| (match, data) = _on_guest("virt.open('%s')" % (port.name), vm, 10) |
| # Console is permitted to open the device multiple times |
| if port.port_type == "yes": #is console? |
| if match != 0: #Multiopen not pass |
| raise error.TestFail("Unexpected fail of opening the console" |
| " device for the 2nd time.\n%s" % data) |
| else: |
| if match != 1: #Multiopen not fail: |
| raise error.TestFail("Unexpetded pass of opening the" |
| " serialport device for the 2nd time.") |
| elif not "[Errno 24]" in data: |
| raise error.TestFail("Multiple opening fail but with another" |
| " exception %s" % data) |
| port.open() |
| |
| |
| def tclose(vm, port): |
| """ |
| Close socket. |
| |
| @param vm: Target virtual machine [vm, session, tmp_dir, ser_session]. |
| @param port: Port to open. |
| """ |
| on_guest("virt.close('%s')" % (port.name), vm, 10) |
| port.close() |
| |
| |
| def tpolling(vm, port): |
| """ |
| Test try polling function. |
| |
| @param vm: Target virtual machine [vm, session, tmp_dir, ser_session]. |
| @param port: Port used in test. |
| """ |
| # Poll (OUT) |
| on_guest("virt.poll('%s', %s)" % (port.name, select.POLLOUT), vm, |
| 2) |
| |
| # Poll (IN, OUT) |
| port.sock.sendall("test") |
| for test in [select.POLLIN, select.POLLOUT]: |
| on_guest("virt.poll('%s', %s)" % (port.name, test), vm, 10) |
| |
| # Poll (IN HUP) |
| # I store the socket informations and close the socket |
| port.close() |
| for test in [select.POLLIN, select.POLLHUP]: |
| on_guest("virt.poll('%s', %s)" % (port.name, test), vm, 10) |
| |
| # Poll (HUP) |
| on_guest("virt.recv('%s', 4, 1024, False)" % (port.name), vm, 10) |
| on_guest("virt.poll('%s', %s)" % (port.name, select.POLLHUP), vm, |
| 2) |
| |
| # Reconnect the socket |
| port.open() |
| # Redefine socket in consoles |
| on_guest("virt.poll('%s', %s)" % (port.name, select.POLLOUT), vm, |
| 2) |
| |
| |
| def tsigio(vm, port): |
| """ |
| Test try sigio function. |
| |
| @param vm: Target virtual machine [vm, session, tmp_dir, ser_session]. |
| @param port: Port used in test. |
| """ |
| if port.is_open: |
| port.close() |
| |
| # Enable sigio on specific port |
| on_guest("virt.async('%s', True, 0)" % |
| (port.name) , vm, 10) |
| on_guest("virt.get_sigio_poll_return('%s')" % (port.name) , vm, 10) |
| |
| #Test sigio when port open |
| on_guest("virt.set_pool_want_return('%s', select.POLLOUT)" % |
| (port.name), vm, 10) |
| port.open() |
| match = _on_guest("virt.get_sigio_poll_return('%s')" % |
| (port.name) , vm, 10)[0] |
| if match == 1: |
| raise error.TestFail("Problem with HUP on console port.") |
| |
| #Test sigio when port receive data |
| on_guest("virt.set_pool_want_return('%s', select.POLLOUT |" |
| " select.POLLIN)" % (port.name), vm, 10) |
| port.sock.sendall("0123456789") |
| on_guest("virt.get_sigio_poll_return('%s')" % (port.name) , vm, 10) |
| |
| #Test sigio port close event |
| on_guest("virt.set_pool_want_return('%s', select.POLLHUP |" |
| " select.POLLIN)" % (port.name), vm, 10) |
| port.close() |
| on_guest("virt.get_sigio_poll_return('%s')" % (port.name) , vm, 10) |
| |
| #Test sigio port open event and persistence of written data on port. |
| on_guest("virt.set_pool_want_return('%s', select.POLLOUT |" |
| " select.POLLIN)" % (port.name), vm, 10) |
| port.open() |
| on_guest("virt.get_sigio_poll_return('%s')" % (port.name) , vm, 10) |
| |
| #Test event when erase data. |
| on_guest("virt.clean_port('%s')" % (port.name), vm, 10) |
| port.close() |
| on_guest("virt.set_pool_want_return('%s', select.POLLOUT)" |
| % (port.name), vm, 10) |
| port.open() |
| on_guest("virt.get_sigio_poll_return('%s')" % (port.name) , vm, 10) |
| |
| # Disable sigio on specific port |
| on_guest("virt.async('%s', False, 0)" % |
| (port.name) , vm, 10) |
| |
| |
| def tlseek(vm, port): |
| """ |
| Tests the correct handling of lseek (expected fail) |
| |
| @param vm: Target virtual machine [vm, session, tmp_dir, ser_session]. |
| @param port: Port used in test. |
| """ |
| # The virt.lseek returns PASS when the seek fails |
| on_guest("virt.lseek('%s', 0, 0)" % (port.name), vm, 10) |
| |
| |
| def trw_host_offline(vm, port): |
| """ |
| Guest read/write from host when host is disconnected. |
| |
| @param vm: Target virtual machine [vm, session, tmp_dir, ser_session]. |
| @param port: Port used in test. |
| """ |
| if port.is_open: |
| port.close() |
| |
| on_guest("virt.recv('%s', 0, 1024, False)" % port.name, vm, 10) |
| match, tmp = _on_guest("virt.send('%s', 10, True)" % port.name, |
| vm, 10) |
| if match is not None: |
| raise error.TestFail("Write on guest while host disconnected " |
| "didn't time out.\nOutput:\n%s" |
| % tmp) |
| |
| port.open() |
| |
| if (port.sock.recv(1024) < 10): |
| raise error.TestFail("Didn't received data from guest") |
| # Now the _on_guest("virt.send('%s'... command should be finished |
| on_guest("print('PASS: nothing')", vm, 10) |
| |
| |
| def trw_host_offline_big_data(vm, port): |
| """ |
| Guest read/write from host when host is disconnected. |
| |
| @param vm: Target virtual machine [vm, session, tmp_dir, ser_session]. |
| @param port: Port used in test. |
| """ |
| if port.is_open: |
| port.close() |
| |
| port.clean_port() |
| port.close() |
| on_guest("virt.clean_port('%s'),1024" % port.name, vm, 10) |
| match, tmp = _on_guest("virt.send('%s', (1024**3)*3, True, " |
| "is_static=True)" % port.name, vm, 30) |
| if match is None: |
| raise error.TestFail("Write on guest while host disconnected " |
| "didn't time out.\nOutput:\n%s" |
| % tmp) |
| |
| time.sleep(20) |
| |
| port.open() |
| |
| rlen = 0 |
| while rlen < (1024**3*3): |
| ret = select.select([port.sock], [], [], 10.0) |
| if (ret[0] != []): |
| rlen += len(port.sock.recv(((4096)))) |
| elif rlen != (1024**3*3): |
| raise error.TestFail("Not all data was received," |
| "only %d from %d" % (rlen, 1024**3*3)) |
| on_guest("print('PASS: nothing')", vm, 10) |
| |
| |
| def trw_notconnect_guest(vm, port, consoles): |
| """ |
| Host send data to guest port and guest not read any data from port. |
| |
| @param vm: Target virtual machine [vm, session, tmp_dir, ser_session]. |
| @param port: Port used in test. |
| """ |
| vm[0].destroy(gracefully = False) |
| (vm[0], vm[1], vm[3]) = _restore_vm() |
| if not port.is_open: |
| port.open() |
| else: |
| port.close() |
| port.open() |
| |
| port.sock.settimeout(20.0) |
| |
| loads = utils.SystemLoad([(os.getpid(), 'autotest'), |
| (vm[0].get_pid(), 'VM'), 0]) |
| loads.start() |
| |
| try: |
| sent1 = 0 |
| for i in range(1000000): |
| sent1 += port.sock.send("a") |
| except socket.timeout: |
| logging.info("Data sending to closed port timed out.") |
| |
| logging.info("Bytes sent to client: %d" % (sent1)) |
| logging.info("\n" + loads.get_cpu_status_string()[:-1]) |
| |
| on_guest('echo -n "PASS:"', vm, 10) |
| |
| logging.info("Open and then close port %s" % (port.name)) |
| init_guest(vm, consoles) |
| # Test of live and open and close port again |
| _clean_ports(vm, consoles) |
| on_guest("virt.close('%s')" % (port.name), vm, 10) |
| |
| # With serialport it is a different behavior |
| on_guest("guest_exit()", vm, 10) |
| port.sock.settimeout(20.0) |
| |
| loads.start() |
| try: |
| sent2 = 0 |
| for i in range(40000): |
| sent2 = port.sock.send("a") |
| except socket.timeout: |
| logging.info("Data sending to closed port timed out.") |
| |
| logging.info("Bytes sent to client: %d" % (sent2)) |
| logging.info("\n" + loads.get_cpu_status_string()[:-1]) |
| loads.stop() |
| if (sent1 != sent2): |
| logging.warning("Inconsistent behavior: First sent %d bytes and " |
| "second sent %d bytes" % (sent1, sent2)) |
| |
| port.sock.settimeout(None) |
| (vm[0], vm[1], vm[3]) = _restore_vm() |
| |
| init_guest(vm, consoles) |
| _clean_ports(vm, consoles) |
| |
| |
| def trw_blocking_mode(vm, port): |
| """ |
| Guest read\write data in blocking mode. |
| |
| @param vm: Target virtual machine [vm, session, tmp_dir, ser_session]. |
| @param port: Port used in test. |
| """ |
| # Blocking mode |
| if not port.is_open: |
| port.open() |
| on_guest("virt.blocking('%s', True)" % port.name, vm, 10) |
| # Recv should timed out |
| match, tmp = _on_guest("virt.recv('%s', 10, 1024, False)" % |
| port.name, vm, 10) |
| if match == 0: |
| raise error.TestFail("Received data even when none was sent\n" |
| "Data:\n%s" % tmp) |
| elif match is not None: |
| raise error.TestFail("Unexpected fail\nMatch: %s\nData:\n%s" % |
| (match, tmp)) |
| port.sock.sendall("1234567890") |
| # Now guest received the data end escaped from the recv() |
| on_guest("print('PASS: nothing')", vm, 10) |
| |
| |
| def trw_nonblocking_mode(vm, port): |
| """ |
| Guest read\write data in nonblocking mode. |
| |
| @param vm: Target virtual machine [vm, session, tmp_dir, ser_session]. |
| @param port: Port used in test. |
| """ |
| # Non-blocking mode |
| if not port.is_open: |
| port.open() |
| on_guest("virt.blocking('%s', False)" % port.name, vm, 10) |
| # Recv should return FAIL with 0 received data |
| match, tmp = _on_guest("virt.recv('%s', 10, 1024, False)" % |
| port.name, vm, 10) |
| if match == 0: |
| raise error.TestFail("Received data even when none was sent\n" |
| "Data:\n%s" % tmp) |
| elif match is None: |
| raise error.TestFail("Timed out, probably in blocking mode\n" |
| "Data:\n%s" % tmp) |
| elif match != 1: |
| raise error.TestFail("Unexpected fail\nMatch: %s\nData:\n%s" % |
| (match, tmp)) |
| port.sock.sendall("1234567890") |
| on_guest("virt.recv('%s', 10, 1024, False)" % port.name, vm, 10) |
| |
| |
| def tbasic_loopback(vm, send_port, recv_port, data="Smoke test data"): |
| """ |
| Easy loop back test with loop over only two ports. |
| |
| @param vm: Target virtual machine [vm, session, tmp_dir, ser_session]. |
| @param port: Port used in test. |
| """ |
| if not send_port.is_open: |
| send_port.open() |
| if not recv_port.is_open: |
| recv_port.open() |
| on_guest("virt.loopback(['%s'], ['%s'], 1024, virt.LOOP_NONE)" % |
| (send_port.name, recv_port.name), vm, 10) |
| send_port.sock.sendall(data) |
| tmp = "" |
| i = 0 |
| while i <= 10: |
| i += 1 |
| ret = select.select([recv_port.sock], [], [], 1.0) |
| if ret: |
| tmp += recv_port.sock.recv(1024) |
| if len(tmp) >= len(data): |
| break |
| if tmp != data: |
| raise error.TestFail("Incorrect data: '%s' != '%s'", |
| data, tmp) |
| _guest_exit_threads(vm, [send_port], [recv_port]) |
| |
| |
| def trmmod(vm, consoles): |
| """ |
| Remove and load virtio_console kernel modules. |
| |
| @param vm: Target virtual machine [vm, session, tmp_dir, ser_session]. |
| @param consoles: Consoles which should be close before rmmod. |
| """ |
| on_guest("guest_exit()", vm, 5) |
| |
| on_guest("rmmod -f virtio_console && echo -n PASS: rmmod " |
| "|| echo -n FAIL: rmmod", vm, 10) |
| on_guest("modprobe virtio_console " |
| "&& echo -n PASS: modprobe || echo -n FAIL: modprobe", |
| vm, 10) |
| |
| init_guest(vm, consoles) |
| try: |
| cname = consoles[0][0].name |
| except (IndexError): |
| cname = consoles[1][0].name |
| on_guest("virt.clean_port('%s'),1024" % cname, vm, 2) |
| |
| |
| def tmax_serial_ports(vm, consoles): |
| """ |
| Test maximum count of ports in guest machine. |
| |
| @param vm: Target virtual machine [vm, session, tmp_dir, ser_session]. |
| @param consoles: Consoles which should be close before rmmod. |
| """ |
| logging.debug("Count of serial ports: 30") |
| vm[0].destroy(gracefully = False) |
| (vm, consoles) = _vm_create(0, 30, False) |
| try: |
| init_guest(vm, consoles) |
| except error.TestFail, ints: |
| logging.info("Count of serial ports: 30") |
| raise ints |
| clean_reload_vm(vm, consoles, expected=True) |
| |
| |
| def tmax_console_ports(vm, consoles): |
| """ |
| Test maximum count of ports in guest machine. |
| |
| @param vm: Target virtual machine [vm, session, tmp_dir, ser_session]. |
| @param consoles: Consoles which should be close before rmmod. |
| """ |
| logging.debug("Count of console ports: 30") |
| vm[0].destroy(gracefully = False) |
| (vm, consoles) = _vm_create(30, 0, False) |
| try: |
| init_guest(vm, consoles) |
| except error.TestFail, ints: |
| logging.info("Count of console ports: 30") |
| raise ints |
| clean_reload_vm(vm, consoles, expected=True) |
| |
| |
| def tmax_mix_serial_conosle_port(vm, consoles): |
| """ |
| Test maximim count of ports in guest machine. |
| |
| @param vm: Target virtual machine [vm, session, tmp_dir, ser_session]. |
| @param consoles: Consoles which should be close before rmmod. |
| """ |
| logging.debug("Count of ports (serial+console): 30") |
| vm[0].destroy(gracefully = False) |
| (vm, consoles) = _vm_create(15, 15, False) |
| try: |
| init_guest(vm, consoles) |
| except error.TestFail, ints: |
| logging.info("Count of ports (serial+console): 30") |
| raise ints |
| clean_reload_vm(vm, consoles, expected=True) |
| |
| |
| def tshutdown(vm, consoles): |
| """ |
| Try to gently shutdown the machine. Virtio_console shouldn't block this. |
| |
| @param vm: Target virtual machine [vm, session, tmp_dir, ser_session]. |
| @param consoles: Consoles which should be close before rmmod. |
| """ |
| ports = [] |
| for console in consoles[0]: |
| ports.append(console) |
| for console in consoles[1]: |
| ports.append(console) |
| for port in ports: |
| port.open() |
| # If more than one, send data on the other ports |
| for port in ports[1:]: |
| on_guest("virt.close('%s')" % (port.name), vm, 2) |
| on_guest("virt.open('%s')" % (port.name), vm, 2) |
| try: |
| os.system("dd if=/dev/random of='%s' bs=4096 &>/dev/null &" |
| % port.path) |
| except: |
| pass |
| # Just start sending, it won't finish anyway... |
| _on_guest("virt.send('%s', 1024**3, True, is_static=True)" |
| % ports[0].name, vm, 1) |
| |
| # Let the computer transfer some bytes :-) |
| time.sleep(2) |
| |
| # Power off the computer |
| vm[0].destroy(gracefully=True) |
| clean_reload_vm(vm, consoles, expected=True) |
| |
| |
| def __tmigrate(vm, consoles, parms, offline=True): |
| """ |
| An actual migration test. It creates loopback on guest from first port |
| to all remaining ports. Than it sends and validates the data. |
| During this it tries to migrate the vm n-times. |
| |
| @param vm: Target virtual machine [vm, session, tmp_dir, ser_session]. |
| @param consoles: Field of virtio ports with the minimum of 2 items. |
| @param parms: [media, no_migration, send-, recv-, loopback-buffer_len] |
| """ |
| # PREPARE |
| send_pt = consoles[parms[0]][0] |
| recv_pts = consoles[parms[0]][1:] |
| # TODO BUG: sendlen = max allowed data to be lost per one migration |
| # TODO BUG: using SMP the data loss is upto 4 buffers |
| # 2048 = char. dev. socket size, parms[2] = host->guest send buffer size |
| sendlen = 2*2*max(2048, parms[2]) |
| if not offline: # TODO BUG: online migration causes more loses |
| # TODO: Online migration lose n*buffer. n depends on the console |
| # troughput. FIX or analyse it's cause. |
| sendlen = 1000 * sendlen |
| for p in recv_pts: |
| if not p.is_open: |
| p.open() |
| |
| if not send_pt.is_open: |
| send_pt.open() |
| |
| threads = [] |
| queues = [] |
| verified = [] |
| for i in range(0, len(recv_pts)): |
| queues.append(deque()) |
| verified.append(0) |
| |
| tmp = "'%s'" % recv_pts[0].name |
| for recv_pt in recv_pts[1:]: |
| tmp += ", '%s'" % (recv_pt.name) |
| on_guest("virt.loopback(['%s'], [%s], %d, virt.LOOP_POLL)" |
| % (send_pt.name, tmp, parms[4]), vm, 10) |
| |
| exit_event = threading.Event() |
| |
| # TEST |
| thread = ThSendCheck(send_pt, exit_event, queues, |
| parms[2]) |
| thread.start() |
| threads.append(thread) |
| |
| for i in range(len(recv_pts)): |
| thread = ThRecvCheck(recv_pts[i], queues[i], exit_event, |
| parms[3], sendlen=sendlen) |
| thread.start() |
| threads.append(thread) |
| |
| i=0 |
| while i < 6: |
| tmp = "%d data sent; " % threads[0].idx |
| for thread in threads[1:]: |
| tmp += "%d, " % thread.idx |
| logging.debug("test_loopback: %s data received and verified", |
| tmp[:-2]) |
| i+=1 |
| time.sleep(2) |
| |
| |
| for j in range(parms[1]): |
| vm[0] = virt_test_utils.migrate(vm[0], env, 3600, "exec", 0, |
| offline) |
| if not vm[1]: |
| raise error.TestFail("Could not log into guest after migration") |
| vm[1] = virt_test_utils.wait_for_login(vm[0], 0, |
| float(params.get("boot_timeout", 100)), |
| 0, 2) |
| # OS is sometime a bit dizzy. DL=30 |
| _init_guest(vm, 30) |
| |
| i=0 |
| while i < 6: |
| tmp = "%d data sent; " % threads[0].idx |
| for thread in threads[1:]: |
| tmp += "%d, " % thread.idx |
| logging.debug("test_loopback: %s data received and verified", |
| tmp[:-2]) |
| i+=1 |
| time.sleep(2) |
| if not threads[0].is_alive(): |
| if exit_event.isSet(): |
| raise error.TestFail("Exit event emited, check the log for" |
| "send/recv thread failure.") |
| else: |
| raise error.TestFail("Send thread died unexpectedly in " |
| "migration %d", (j+1)) |
| for i in range(0, len(recv_pts)): |
| if not threads[i+1].is_alive(): |
| raise error.TestFail("Recv thread %d died unexpectedly in " |
| "migration %d", i, (j+1)) |
| if verified[i] == threads[i+1].idx: |
| raise error.TestFail("No new data in %d console were " |
| "transfered after migration %d" |
| , i, (j+1)) |
| verified[i] = threads[i+1].idx |
| logging.info("%d out of %d migration(s) passed" % ((j+1), parms[1])) |
| # TODO detect recv-thread failure and throw out whole test |
| |
| # FINISH |
| exit_event.set() |
| # Send thread might fail to exit when the guest stucks |
| i = 30 |
| while threads[0].is_alive(): |
| if i <= 0: |
| raise error.TestFail("Send thread did not finish") |
| time.sleep(1) |
| i -= 1 |
| tmp = "%d data sent; " % threads[0].idx |
| for thread in threads[1:]: |
| thread.join() |
| tmp += "%d, " % thread.idx |
| logging.info("test_loopback: %s data received and verified during %d " |
| "migrations", tmp[:-2], parms[1]) |
| |
| # CLEANUP |
| _guest_exit_threads(vm, [send_pt], recv_pts) |
| del exit_event |
| del threads[:] |
| |
| |
| def _tmigrate(vm, consoles, parms, offline): |
| """ |
| Wrapper which parses the params for __migrate test. |
| |
| @param vm: Target virtual machine [vm, session, tmp_dir, ser_session]. |
| @param consoles: Field of virtio ports with the minimum of 2 items. |
| @param parms: test parameters, multiple recievers allowed. |
| '[{serialport,console}]:$no_migrations:send_buf_len:recv_buf_len: |
| loopback_buf_len;...' |
| """ |
| for param in parms.split(';'): |
| if not param: |
| continue |
| if offline: |
| logging.info("test_migrate_offline: params: %s", param) |
| else: |
| logging.info("test_migrate_online: params: %s", param) |
| param = param.split(':') |
| media = 1 |
| if param[0].isalpha(): |
| if param[0] == "console": |
| param[0] = 0 |
| else: |
| param[0] = 1 |
| else: |
| param = [0] + param |
| for i in range(1,5): |
| if not param[i].isdigit(): |
| param[i] = 1 |
| else: |
| param[i] = int(param[i]) |
| |
| __tmigrate(vm, consoles, param, offline=offline) |
| |
| |
| def tmigrate_offline(vm, consoles, parms): |
| """ |
| Tests whether the virtio-{console,port} are able to survive the offline |
| migration. |
| |
| @param vm: Target virtual machine [vm, session, tmp_dir, ser_session]. |
| @param consoles: Field of virtio ports with the minimum of 2 items. |
| @param parms: test parameters, multiple recievers allowed. |
| '[{serialport,console}]:$no_migrations:send_buf_len:recv_buf_len: |
| loopback_buf_len;...' |
| """ |
| _tmigrate(vm, consoles, parms, offline=True) |
| |
| |
| def tmigrate_online(vm, consoles, parms): |
| """ |
| Tests whether the virtio-{console,port} are able to survive the online |
| migration. |
| |
| @param vm: Target virtual machine [vm, session, tmp_dir, ser_session]. |
| @param consoles: Field of virtio ports with the minimum of 2 items. |
| @param parms: test parameters, multiple recievers allowed. |
| '[{serialport,console}]:$no_migrations:send_buf_len:recv_buf_len: |
| loopback_buf_len;...' |
| """ |
| _tmigrate(vm, consoles, parms, offline=False) |
| |
| |
| def _virtio_dev_create(vm, ports_name, pciid, id, console="no"): |
| """ |
| Add virtio serialport device. |
| |
| @param vm: Target virtual machine [vm, session, tmp_dir, ser_session]. |
| @param ports_name: Structure of ports. |
| @param pciid: Id of virtio-serial-pci device. |
| @param id: Id of port. |
| @param console: if "yes" inicialize console. |
| """ |
| port = "serialport-" |
| port_type = "virtserialport" |
| if console == "yes": |
| port = "console-" |
| port_type = "virtconsole" |
| port += "%d%d" % (pciid, id) |
| ret = vm[0].monitors[0].cmd("device_add %s," |
| "bus=virtio-serial-pci%d.0," |
| "id=%s," |
| "name=%s" |
| % (port_type, pciid, port, port)) |
| ports_name.append([ port, console]) |
| if ret != "": |
| logging.error(ret) |
| |
| |
| def _virtio_dev_del(vm, ports_name, pciid, id): |
| """ |
| Del virtio serialport device. |
| |
| @param vm: Target virtual machine [vm, session, tmp_dir, ser_session]. |
| @param ports_name: Structure of ports. |
| @param pciid: Id of virtio-serial-pci device. |
| @param id: Id of port. |
| """ |
| port = filter(lambda x: x[0].endswith("-%d%d" % (pciid, id)), |
| ports_name) |
| ret = vm[0].monitors[0].cmd("device_del %s" |
| % (port[0][0])) |
| ports_name.remove(port[0]) |
| if ret != "": |
| logging.error(ret) |
| |
| |
| def thotplug(vm, consoles, console="no", timeout=1): |
| """ |
| Try hotplug function of virtio-consoles ports. |
| |
| @param vm: Target virtual machine [vm, session, tmp_dir, ser_session]. |
| @param consoles: Consoles. |
| @param console: If "yes" inicialize console. |
| @param timeout: Timeout between hotplug operations. |
| """ |
| logging.info("Timeout between hotplug operations t=%fs" % timeout) |
| _reset_vm(vm, consoles, 1, 1) |
| ports_name = [] |
| ports_name.append(['serialport-1','no']) |
| ports_name.append(['console-0','yes']) |
| |
| logging.info("Test correct initialization of hotplug ports") |
| for id in range(1,5): #count of pci device |
| ret = vm[0].monitors[0].cmd("device_add virtio-serial-pci," |
| "id=virtio-serial-pci%d" % (id)) |
| if ret != "": |
| logging.error(ret) |
| for i in range(id*5+5): #max port 30 |
| _virtio_dev_create(vm, ports_name, id, i, console) |
| time.sleep(timeout) |
| |
| # Test correct initialization of hotplug ports |
| time.sleep(10) # Timeout for port initialization |
| _init_guest(vm, 10) |
| on_guest('virt.init(%s)' % (ports_name), vm, 10) |
| |
| logging.info("Delete ports when ports are used") |
| # Delete ports when ports are used. |
| if not consoles[0][0].is_open: |
| consoles[0][0].open() |
| if not consoles[1][0].is_open: |
| consoles[1][0].open() |
| on_guest("virt.loopback(['%s'], ['%s'], 1024," |
| "virt.LOOP_POLL)" % (consoles[0][0].name, |
| consoles[1][0].name), vm, 10) |
| exit_event = threading.Event() |
| send = ThSend(consoles[0][0].sock, "Data", exit_event, quiet = True) |
| recv = ThRecv(consoles[1][0].sock, exit_event, quiet = True) |
| send.start() |
| time.sleep(2) |
| recv.start() |
| |
| # Try to delete ports under load |
| ret = vm[0].monitors[0].cmd("device_del serialport-1") |
| ret += vm[0].monitors[0].cmd("device_del console-0") |
| ports_name.remove(['serialport-1','no']) |
| ports_name.remove(['console-0','yes']) |
| if ret != "": |
| logging.error(ret) |
| |
| exit_event.set() |
| send.join() |
| recv.join() |
| on_guest("virt.exit_threads()", vm, 10) |
| on_guest('guest_exit()', vm, 10) |
| |
| logging.info("Trying to add maximum count of ports to one pci device") |
| # Try to add ports |
| for i in range(30): # max port 30 |
| _virtio_dev_create(vm, ports_name, 0, i, console) |
| time.sleep(timeout) |
| _init_guest(vm, 10) |
| time.sleep(10) |
| on_guest('virt.init(%s)' % (ports_name), vm, 20) |
| on_guest('guest_exit()', vm, 10) |
| |
| logging.info("Trying delete and add again part of ports") |
| # Try to delete ports |
| for i in range(25): # max port 30 |
| _virtio_dev_del(vm, ports_name, 0, i) |
| time.sleep(timeout) |
| _init_guest(vm, 10) |
| on_guest('virt.init(%s)' % (ports_name), vm, 10) |
| on_guest('guest_exit()', vm, 10) |
| |
| # Try to add ports |
| for i in range(5): # max port 30 |
| _virtio_dev_create(vm, ports_name, 0, i, console) |
| time.sleep(timeout) |
| _init_guest(vm, 10) |
| on_guest('virt.init(%s)' % (ports_name), vm, 10) |
| on_guest('guest_exit()', vm, 10) |
| |
| logging.info("Trying to add and delete one port 100 times") |
| # Try 100 times add and delete one port. |
| for i in range(100): |
| _virtio_dev_del(vm, ports_name, 0, 0) |
| time.sleep(timeout) |
| _virtio_dev_create(vm, ports_name, 0, 0, console) |
| time.sleep(timeout) |
| _init_guest(vm, 10) |
| on_guest('virt.init(%s)' % (ports_name), vm, 10) |
| on_guest('guest_exit()', vm, 10) |
| |
| |
| def thotplug_no_timeout(vm, consoles, console="no"): |
| """ |
| Start hotplug test without any timeout. |
| |
| @param vm: Target virtual machine [vm, session, tmp_dir, ser_session]. |
| @param consoles: Consoles which should be close before rmmod. |
| @param console: If "yes" inicialize console. |
| """ |
| thotplug(vm, consoles, console, 0) |
| |
| |
| def thotplug_virtio_pci(vm, consoles): |
| """ |
| Test hotplug of virtio-serial-pci. |
| |
| @param vm: Target virtual machine [vm, session, tmp_dir, ser_session]. |
| @param consoles: Consoles which should be close before rmmod. |
| """ |
| vm[0].destroy(gracefully = False) |
| (vm, consoles) = _vm_create(1, 1, False) |
| id = 1 |
| ret = vm[0].monitors[0].cmd("device_add virtio-serial-pci," |
| "id=virtio-serial-pci%d" % (id)) |
| time.sleep(10) |
| ret += vm[0].monitors[0].cmd("device_del virtio-serial-pci%d" % (id)) |
| time.sleep(10) |
| ret += vm[0].monitors[0].cmd("device_add virtio-serial-pci," |
| "id=virtio-serial-pci%d" % (id)) |
| if ret != "": |
| logging.error(ret) |
| |
| |
| def tloopback(vm, consoles, params): |
| """ |
| Virtio console loopback subtest. |
| |
| Creates loopback on the vm machine between send_pt and recv_pts |
| ports and sends length amount of data through this connection. |
| It validates the correctness of the data sent. |
| |
| @param vm: Target virtual machine [vm, session, tmp_dir, ser_session]. |
| @param consoles: Field of virtio ports with the minimum of 2 items. |
| @param params: test parameters, multiple recievers allowed. |
| '$source_console_type@buffer_length: |
| $destination_console_type1@$buffer_length:...: |
| $loopback_buffer_length;...' |
| """ |
| # PREPARE |
| for param in params.split(';'): |
| if not param: |
| continue |
| logging.info("test_loopback: params: %s", param) |
| param = param.split(':') |
| idx_serialport = 0 |
| idx_console = 0 |
| buf_len = [] |
| if (param[0].startswith('console')): |
| send_pt = consoles[0][idx_console] |
| idx_console += 1 |
| else: |
| send_pt = consoles[1][idx_serialport] |
| idx_serialport += 1 |
| if (len(param[0].split('@')) == 2): |
| buf_len.append(int(param[0].split('@')[1])) |
| else: |
| buf_len.append(1024) |
| recv_pts = [] |
| for parm in param[1:]: |
| if (parm.isdigit()): |
| buf_len.append(int(parm)) |
| break # buf_len is the last portion of param |
| if (parm.startswith('console')): |
| recv_pts.append(consoles[0][idx_console]) |
| idx_console += 1 |
| else: |
| recv_pts.append(consoles[1][idx_serialport]) |
| idx_serialport += 1 |
| if (len(parm[0].split('@')) == 2): |
| buf_len.append(int(parm[0].split('@')[1])) |
| else: |
| buf_len.append(1024) |
| # There must be sum(idx_*) consoles + last item as loopback buf_len |
| if len(buf_len) == (idx_console + idx_serialport): |
| buf_len.append(1024) |
| |
| for p in recv_pts: |
| if not p.is_open: |
| p.open() |
| |
| if not send_pt.is_open: |
| send_pt.open() |
| |
| if len(recv_pts) == 0: |
| raise error.TestFail("test_loopback: incorrect recv consoles" |
| "definition") |
| |
| threads = [] |
| queues = [] |
| for i in range(0, len(recv_pts)): |
| queues.append(deque()) |
| |
| tmp = "'%s'" % recv_pts[0].name |
| for recv_pt in recv_pts[1:]: |
| tmp += ", '%s'" % (recv_pt.name) |
| on_guest("virt.loopback(['%s'], [%s], %d, virt.LOOP_POLL)" |
| % (send_pt.name, tmp, buf_len[-1]), vm, 10) |
| |
| exit_event = threading.Event() |
| |
| # TEST |
| thread = ThSendCheck(send_pt, exit_event, queues, |
| buf_len[0]) |
| thread.start() |
| threads.append(thread) |
| |
| for i in range(len(recv_pts)): |
| thread = ThRecvCheck(recv_pts[i], queues[i], exit_event, |
| buf_len[i + 1]) |
| thread.start() |
| threads.append(thread) |
| |
| time.sleep(60) |
| exit_event.set() |
| threads[0].join() |
| tmp = "%d data sent; " % threads[0].idx |
| for thread in threads[1:]: |
| thread.join() |
| tmp += "%d, " % thread.idx |
| logging.info("test_loopback: %s data received and verified", |
| tmp[:-2]) |
| |
| # Read-out all remaining data |
| for recv_pt in recv_pts: |
| while select.select([recv_pt.sock], [], [], 0.1)[0]: |
| recv_pt.sock.recv(1024) |
| |
| _guest_exit_threads(vm, [send_pt], recv_pts) |
| |
| del exit_event |
| del threads[:] |
| |
| |
| def tperf(vm, consoles, params): |
| """ |
| Tests performance of the virtio_console tunel. First it sends the data |
| from host to guest and than back. It provides informations about |
| computer utilisation and statistic informations about the troughput. |
| |
| @param vm: Target virtual machine [vm, session, tmp_dir, ser_session]. |
| @param consoles: Field of virtio ports with the minimum of 2 items. |
| @param params: test parameters: |
| '$console_type@$buffer_length:$test_duration;...' |
| """ |
| for param in params.split(';'): |
| if not param: |
| continue |
| logging.info("test_perf: params: %s", param) |
| param = param.split(':') |
| duration = 60.0 |
| if len(param) > 1: |
| try: |
| duration = float(param[1]) |
| except: |
| pass |
| param = param[0].split('@') |
| if len(param) > 1 and param[1].isdigit(): |
| buf_len = int(param[1]) |
| else: |
| buf_len = 1024 |
| param = (param[0] == 'serialport') |
| port = consoles[param][0] |
| |
| if not port.is_open: |
| port.open() |
| |
| data = "" |
| for i in range(buf_len): |
| data += "%c" % random.randrange(255) |
| |
| exit_event = threading.Event() |
| time_slice = float(duration) / 100 |
| |
| # HOST -> GUEST |
| on_guest('virt.loopback(["%s"], [], %d, virt.LOOP_NONE)' % |
| (port.name, buf_len), vm, 10) |
| thread = ThSend(port.sock, data, exit_event) |
| stats = array.array('f', []) |
| loads = utils.SystemLoad([(os.getpid(), 'autotest'), |
| (vm[0].get_pid(), 'VM'), 0]) |
| loads.start() |
| _time = time.time() |
| thread.start() |
| for i in range(100): |
| stats.append(thread.idx) |
| time.sleep(time_slice) |
| _time = time.time() - _time - duration |
| logging.info("\n" + loads.get_cpu_status_string()[:-1]) |
| logging.info("\n" + loads.get_mem_status_string()[:-1]) |
| exit_event.set() |
| thread.join() |
| |
| # Let the guest read-out all the remaining data |
| while not _on_guest("virt.poll('%s', %s)" % |
| (port.name, select.POLLIN), vm, 10)[0]: |
| time.sleep(1) |
| |
| _guest_exit_threads(vm, [port], []) |
| |
| if (_time > time_slice): |
| logging.error( |
| "Test ran %fs longer which is more than one time slice", _time) |
| else: |
| logging.debug("Test ran %fs longer", _time) |
| stats = process_stats(stats[1:], time_slice * 1048576) |
| logging.debug("Stats = %s", stats) |
| logging.info("Host -> Guest [MB/s] (min/med/max) = %.3f/%.3f/%.3f", |
| stats[0], stats[len(stats) / 2], stats[-1]) |
| |
| del thread |
| |
| # GUEST -> HOST |
| exit_event.clear() |
| stats = array.array('f', []) |
| on_guest("virt.send_loop_init('%s', %d)" % (port.name, buf_len), |
| vm, 30) |
| thread = ThRecv(port.sock, exit_event, buf_len) |
| thread.start() |
| loads.start() |
| on_guest("virt.send_loop()", vm, 10) |
| _time = time.time() |
| for i in range(100): |
| stats.append(thread.idx) |
| time.sleep(time_slice) |
| _time = time.time() - _time - duration |
| logging.info("\n" + loads.get_cpu_status_string()[:-1]) |
| logging.info("\n" + loads.get_mem_status_string()[:-1]) |
| on_guest("virt.exit_threads()", vm, 10) |
| exit_event.set() |
| thread.join() |
| if (_time > time_slice): # Deviation is higher than 1 time_slice |
| logging.error( |
| "Test ran %fs longer which is more than one time slice", _time) |
| else: |
| logging.debug("Test ran %fs longer", _time) |
| stats = process_stats(stats[1:], time_slice * 1048576) |
| logging.debug("Stats = %s", stats) |
| logging.info("Guest -> Host [MB/s] (min/med/max) = %.3f/%.3f/%.3f", |
| stats[0], stats[len(stats) / 2], stats[-1]) |
| |
| del thread |
| del exit_event |
| |
| |
| def _clean_ports(vm, consoles): |
| """ |
| Read all data from all ports, in both sides of each port. |
| |
| @param vm: Target virtual machine [vm, session, tmp_dir, ser_session]. |
| @param consoles: Consoles which should be clean. |
| """ |
| for ctype in consoles: |
| for port in ctype: |
| openned = port.is_open |
| port.clean_port() |
| on_guest("virt.clean_port('%s'),1024" % port.name, vm, 10) |
| if not openned: |
| port.close() |
| on_guest("virt.close('%s'),1024" % port.name, vm, 10) |
| |
| |
| def clean_ports(vm, consoles): |
| """ |
| Clean state of all ports and set port to default state. |
| Default state: |
| No data on port or in port buffer. |
| Read mode = blocking. |
| |
| @param vm: Target virtual machine [vm, session, tmp_dir, ser_session]. |
| @param consoles: Consoles which should be clean. |
| """ |
| # Check if python is still alive |
| logging.info("CLEANING") |
| match, tmp = _on_guest("is_alive()", vm, 10) |
| if (match is None) or (match != 0): |
| logging.error("Python died/is stucked/have remaining threads") |
| logging.debug(tmp) |
| try: |
| kernel_bug = _search_kernel_crashlog(vm[0].serial_console, 10) |
| if kernel_bug is not None: |
| logging.error(kernel_bug) |
| raise error.TestFail("Kernel crash.") |
| |
| if vm[4] == True: |
| raise error.TestFail("Kernel crash.") |
| match, tmp = _on_guest("guest_exit()", vm, 10) |
| if (match is None) or (match == 0): |
| vm[1].close() |
| vm[1] = virt_test_utils.wait_for_login(vm[0], 0, |
| float(params.get("boot_timeout", 5)), |
| 0, 10) |
| on_guest("killall -9 python " |
| "&& echo -n PASS: python killed" |
| "|| echo -n PASS: python was already dead", |
| vm, 10) |
| |
| init_guest(vm, consoles) |
| _clean_ports(vm, consoles) |
| |
| except (error.TestFail, aexpect.ExpectError, |
| Exception), inst: |
| logging.error(inst) |
| logging.error("Virtio-console driver is irreparably" |
| " blocked. Every comd end with sig KILL." |
| "Trying to reboot vm to continue testing...") |
| try: |
| vm[0].destroy(gracefully = True) |
| (vm[0], vm[1], vm[3]) = _restore_vm() |
| except (kvm_monitor.MonitorProtocolError): |
| logging.error("Qemu is blocked. Monitor no longer " |
| "communicates") |
| vm[0].destroy(gracefully = False) |
| os.system("kill -9 %d" % (vm[0].get_pid())) |
| (vm[0], vm[1], vm[3]) = _restore_vm() |
| init_guest(vm, consoles) |
| cname = "" |
| try: |
| cname = consoles[0][0].name |
| except (IndexError): |
| cname = consoles[1][0].name |
| match = _on_guest("virt.clean_port('%s'),1024" % |
| cname, vm, 10)[0] |
| |
| if (match is None) or (match != 0): |
| raise error.TestFail("Virtio-console driver is irreparably " |
| "blocked. Every comd ended with sig " |
| "KILL. The restart didn't help") |
| _clean_ports(vm, consoles) |
| |
| |
| def _reset_vm(vm, consoles, no_console=1, no_serialport=1): |
| """ |
| Destroy and reload vm. |
| |
| @param vm: Target virtual machine [vm, session, tmp_dir, ser_session]. |
| @param consoles: Consoles which should be close and than renew. |
| @param no_console: Number of desired virtconsoles. |
| @param no_serialport: Number of desired virtserialports. |
| """ |
| vm[0].destroy(gracefully=False) |
| shutil.rmtree(vm[2]) # Remove virtio sockets tmp directory |
| (_vm, _consoles) = _vm_create(no_console, no_serialport) |
| consoles[:] = _consoles[:] |
| vm[:] = _vm[:] |
| |
| |
| def clean_reload_vm(vm, consoles, expected=False): |
| """ |
| Reloads and boots the damaged vm |
| |
| @param vm: Target virtual machine [vm, session, tmp_dir, ser_session]. |
| @param consoles: Consoles which should be clean. |
| """ |
| if expected: |
| logging.info("Scheduled vm reboot") |
| else: |
| logging.info("SCHWARZENEGGER is CLEANING") |
| _reset_vm(vm, consoles, len(consoles[0]), len(consoles[1])) |
| init_guest(vm, consoles) |
| |
| |
| def test_smoke(test, vm, consoles, params, global_params): |
| """ |
| Virtio console smoke test. |
| |
| Tests the basic functionalities (poll, read/write with and without |
| connected host, etc. |
| |
| @param test: Main test object. |
| @param vm: Target virtual machine [vm, session, tmp_dir, ser_session]. |
| @param consoles: Field of virtio ports with the minimum of 2 items. |
| @param params: Test parameters '$console_type:$data;...' |
| @param global_params: Params defined by tests_base.conf. |
| """ |
| # PREPARE |
| if (global_params.get('smoke_test') == "yes"): |
| for param in params.split(';'): |
| if not param: |
| continue |
| headline = "test_smoke: params: %s" % (param) |
| logging.info(headline) |
| param = param.split(':') |
| if len(param) > 1: |
| data = param[1] |
| else: |
| data = "Smoke test data" |
| param = (param[0] == 'serialport') |
| send_pt = consoles[param][0] |
| recv_pt = consoles[param][1] |
| subtest.headline(headline) |
| subtest.do_test(tcheck_zero_sym, [vm], cleanup=False) |
| subtest.do_test(topen, [vm, send_pt], True) |
| subtest.do_test(tclose, [vm, send_pt], True) |
| subtest.do_test(tmulti_open, [vm, send_pt]) |
| subtest.do_test(tpolling, [vm, send_pt]) |
| subtest.do_test(tsigio, [vm, send_pt]) |
| subtest.do_test(tlseek, [vm, send_pt]) |
| subtest.do_test(trw_host_offline, [vm, send_pt]) |
| subtest.do_test(trw_host_offline_big_data, [vm, send_pt], |
| cleanup=False) |
| subtest.do_test(trw_notconnect_guest, |
| [vm, send_pt, consoles]) |
| subtest.do_test(trw_nonblocking_mode, [vm, send_pt]) |
| subtest.do_test(trw_blocking_mode, [vm, send_pt]) |
| subtest.do_test(tbasic_loopback, [vm, send_pt, recv_pt, data], |
| True) |
| |
| |
| def test_multiport(test, vm, consoles, params, global_params): |
| """ |
| This is group of test which test virtio_console in maximal load and |
| with multiple ports. |
| |
| @param test: Main test object. |
| @param vm: Target virtual machine [vm, session, tmp_dir, ser_session]. |
| @param consoles: Field of virtio ports with the minimum of 2 items. |
| @param params: Test parameters '$console_type:$data;...' |
| @param global_params: Params defined by tests_base.conf. |
| """ |
| subtest.headline("test_multiport:") |
| # Test Loopback |
| if (global_params.get('loopback_test') == "yes"): |
| subtest.do_test(tloopback, [vm, consoles, params[0]]) |
| |
| # Test Performance |
| if (global_params.get('perf_test') == "yes"): |
| subtest.do_test(tperf, [vm, consoles, params[1]]) |
| |
| |
| def test_destructive(test, vm, consoles, global_params, params): |
| """ |
| This is group of tests which might be destructive. |
| |
| @param test: Main test object. |
| @param vm: Target virtual machine [vm, session, tmp_dir, ser_session]. |
| @param consoles: Field of virtio ports with the minimum of 2 items. |
| @param global_params: Params defined by tests_base.conf. |
| @param params: Dictionary of subtest params from tests_base.conf. |
| """ |
| subtest.headline("test_destructive:") |
| # Uses stronger clean up function |
| (_cleanup_func, _cleanup_args) = subtest.get_cleanup_func() |
| subtest.set_cleanup_func(clean_reload_vm, [vm, consoles]) |
| |
| if (global_params.get('rmmod_test') == "yes"): |
| subtest.do_test(trmmod,[vm, consoles]) |
| if (global_params.get('max_ports_test') == "yes"): |
| subtest.do_test(tmax_serial_ports, [vm, consoles]) |
| subtest.do_test(tmax_console_ports, [vm, consoles]) |
| subtest.do_test(tmax_mix_serial_conosle_port, [vm, consoles]) |
| if (global_params.get('shutdown_test') == "yes"): |
| subtest.do_test(tshutdown, [vm, consoles]) |
| if (global_params.get('migrate_offline_test') == "yes"): |
| subtest.do_test(tmigrate_offline, |
| [vm, consoles, params['tmigrate_offline_params']]) |
| if (global_params.get('migrate_online_test') == "yes"): |
| subtest.do_test(tmigrate_online, |
| [vm, consoles, params['tmigrate_online_params']]) |
| if (global_params.get('hotplug_serial_test') == "yes"): |
| subtest.do_test(thotplug, [vm, consoles]) |
| subtest.do_test(thotplug_no_timeout, [vm, consoles]) |
| if (global_params.get('hotplug_console_test') == "yes"): |
| subtest.do_test(thotplug, [vm, consoles, "yes"]) |
| subtest.do_test(thotplug_no_timeout, [vm, consoles, "yes"]) |
| if (global_params.get('hotplug_pci_test') == "yes"): |
| subtest.do_test(thotplug_virtio_pci, [vm, consoles]) |
| |
| subtest.set_cleanup_func(_cleanup_func, _cleanup_args) |
| |
| |
| # INITIALIZE |
| if "extra_params" in params: |
| standard_extra_params = params['extra_params'] |
| else: |
| standard_extra_params = "" |
| |
| tsmoke_params = params.get('virtio_console_smoke', '') |
| tloopback_params = params.get('virtio_console_loopback', '') |
| tperf_params = params.get('virtio_console_perf', '') |
| tmigrate_offline_params = params.get('virtio_console_migration_offline', '') |
| tmigrate_online_params = params.get('virtio_console_migration_online', '') |
| |
| # destructive params |
| tdestructive_params = {} |
| tdestructive_params['tmigrate_offline_params'] = tmigrate_offline_params |
| tdestructive_params['tmigrate_online_params'] = tmigrate_online_params |
| |
| no_serialports = int(params.get('virtio_console_no_serialports', 0)) |
| no_consoles = int(params.get('virtio_console_no_consoles', 0)) |
| # consoles required for Smoke test |
| if tsmoke_params.count('serialport'): |
| no_serialports = max(2, no_serialports) |
| if tsmoke_params.count('console'): |
| no_consoles = max(2, no_consoles) |
| # consoles required for Loopback test |
| for param in tloopback_params.split(';'): |
| no_serialports = max(no_serialports, param.count('serialport')) |
| no_consoles = max(no_consoles, param.count('console')) |
| # consoles required for Performance test |
| if tperf_params.count('serialport'): |
| no_serialports = max(1, no_serialports) |
| if tperf_params.count('console'): |
| no_consoles = max(1, no_consoles) |
| # consoles required for Migration offline test |
| if tmigrate_offline_params.count('serial'): |
| no_serialports = max(2, no_serialports) |
| if tmigrate_offline_params.count('console'): |
| no_consoles = max(2, no_consoles) |
| if tmigrate_online_params.count('serial'): |
| no_serialports = max(2, no_serialports) |
| if tmigrate_online_params.count('console'): |
| no_consoles = max(2, no_consoles) |
| |
| if no_serialports + no_consoles == 0: |
| raise error.TestFail("No tests defined, probably incorrect " |
| "configuration in tests_base.cfg") |
| |
| vm, consoles = _vm_create(no_consoles, no_serialports) |
| |
| # Copy virtio_console_guest.py into guests |
| pwd = os.path.join(os.environ['AUTODIR'], 'tests/kvm') |
| vksmd_src = os.path.join(pwd, "scripts/virtio_console_guest.py") |
| dst_dir = "/tmp" |
| |
| vm[0].copy_files_to(vksmd_src, dst_dir) |
| |
| # ACTUAL TESTING |
| # Defines all available consoles; tests udev and sysfs |
| |
| subtest = SubTest() |
| try: |
| init_guest(vm, consoles) |
| |
| subtest.set_cleanup_func(clean_ports, [vm, consoles]) |
| # Test Smoke |
| test_smoke(subtest, vm, consoles, tsmoke_params, params) |
| |
| # Test multiport functionality and performance. |
| test_multiport(subtest, vm, consoles, [tloopback_params, tperf_params], |
| params) |
| |
| #Test destructive test. |
| test_destructive(subtest, vm, consoles, params, tdestructive_params) |
| finally: |
| logging.info(("Summary: %d tests passed %d test failed :\n" % |
| (subtest.passed, subtest.failed)) + |
| subtest.get_text_result()) |
| |
| if subtest.is_failed(): |
| raise error.TestFail("%d out of %d virtio console tests failed" % |
| (subtest.failed, (subtest.passed+subtest.failed))) |
| |
| |
| # CLEANUP |
| vm[1].close() |
| vm[0].destroy(gracefully=False) |
| shutil.rmtree(vm[2]) |
