From patchwork Wed Sep 15 15:41:28 2010 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: =?utf-8?b?THVrw6HFoSBEb2t0b3I=?= X-Patchwork-Id: 183022 Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by demeter1.kernel.org (8.14.4/8.14.3) with ESMTP id o8FFfpqd003347 for ; Wed, 15 Sep 2010 15:41:51 GMT Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1754474Ab0IOPlr (ORCPT ); Wed, 15 Sep 2010 11:41:47 -0400 Received: from mx1.redhat.com ([209.132.183.28]:4489 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1753359Ab0IOPlp (ORCPT ); Wed, 15 Sep 2010 11:41:45 -0400 Received: from int-mx02.intmail.prod.int.phx2.redhat.com (int-mx02.intmail.prod.int.phx2.redhat.com [10.5.11.12]) by mx1.redhat.com (8.13.8/8.13.8) with ESMTP id o8FFfiUr022880 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-SHA bits=256 verify=OK); Wed, 15 Sep 2010 11:41:44 -0400 Received: from dhcp-27-189.brq.redhat.com (dhcp-27-189.brq.redhat.com [10.34.27.189]) by int-mx02.intmail.prod.int.phx2.redhat.com (8.13.8/8.13.8) with ESMTP id o8FFfcls004857; Wed, 15 Sep 2010 11:41:42 -0400 From: Lukas Doktor To: ldoktor@redhat.com, jzupka@redhat.com, autotest@test.kernel.org, kvm@vger.kernel.org, lmr@redhat.com, amit.shah@redhat.com Subject: [KVM-autotest] virtio_console test v3.0 Date: Wed, 15 Sep 2010 17:41:28 +0200 Message-Id: <1284565288-28094-2-git-send-email-ldoktor@redhat.com> In-Reply-To: <1284565288-28094-1-git-send-email-ldoktor@redhat.com> References: <1284565288-28094-1-git-send-email-ldoktor@redhat.com> X-Scanned-By: MIMEDefang 2.67 on 10.5.11.12 Sender: kvm-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: kvm@vger.kernel.org X-Greylist: IP, sender and recipient auto-whitelisted, not delayed by milter-greylist-4.2.3 (demeter1.kernel.org [140.211.167.41]); Wed, 15 Sep 2010 15:41:52 +0000 (UTC) diff --git a/client/tests/kvm/scripts/console_switch.py b/client/tests/kvm/scripts/console_switch.py deleted file mode 100644 index 3df4094..0000000 --- a/client/tests/kvm/scripts/console_switch.py +++ /dev/null @@ -1,219 +0,0 @@ -#!/usr/bin/python -# -*- coding: utf-8 -*- -""" -Auxiliary script used to send data between ports on guests. - -@copyright: 2008-2009 Red Hat Inc. -@author: Jiri Zupka (jzupka@redhat.com) -@author: Lukas Doktor (ldoktor@redhat.com) -""" -import threading -from threading import Thread -import os,time,select,re,random,sys,array - -files = {} -ev = threading.Event() -threads = [] - -DEBUGPATH="/sys/kernel/debug" - - -class Switch(Thread): - """ - Create a thread which sends data between ports. - """ - def __init__(self, exitevent, in_files, out_files, cachesize=1): - """ - @param exitevent: Event to end switch. - @param in_files: Array of input files. - @param out_files: Array of output files. - @param cachesize: Block to receive and send. - """ - Thread.__init__(self) - - self.in_files = in_files - self.out_files = out_files - - self.cachesize = cachesize - self.exitevent = exitevent - - - def run(self): - while not self.exitevent.isSet(): - #TODO: Why select causes trouble? :-( - #ret = select.select(self.in_files,[],[],1.0) - data = "" - #if not ret[0] == []: - for desc in self.in_files: - data += os.read(desc, self.cachesize) - for desc in self.out_files: - os.write(desc, data) - - -class Sender(Thread): - """ - Creates thread which sends random blocks of data to the destination port. - """ - def __init__(self, port, length): - """ - @param port: Destination port. - @param length: Length of the random data block. - """ - Thread.__init__(self) - self.port = port - self.data = array.array('L') - for i in range(max(length/self.data.itemsize, 1)): - self.data.append(random.randrange(sys.maxint)) - - - def run(self): - while True: - os.write(self.port, self.data) - del threads[:] - - -def get_port_status(): - """ - Get info about ports from kernel debugfs. - - @return: ports dictionary of port properties - """ - ports = {} - - not_present_msg = "FAIL: There's no virtio-ports dir in debugfs" - if not os.path.ismount(DEBUGPATH): - os.system('mount -t debugfs none %s' % DEBUGPATH) - try: - if not os.path.isdir('%s/virtio-ports' % DEBUGPATH): - print not_present_msg - except: - print not_present_msg - else: - viop_names = os.listdir('%s/virtio-ports' % DEBUGPATH) - for name in viop_names: - f = open("%s/virtio-ports/%s" % (DEBUGPATH, name), 'r') - port = {} - for line in iter(f): - m = re.match("(\S+): (\S+)",line) - port[m.group(1)] = m.group(2) - - if (port['is_console'] == "yes"): - port["path"] = "/dev/hvc%s" % port["console_vtermno"] - # Console works like a serialport - else: - port["path"] = "/dev/%s" % name - ports[port['name']] = port - f.close() - - return ports - - -def open_device(in_files, ports): - """ - Open devices and return an array of descriptors. - - @param in_files: files array - @return: array of descriptors - """ - f = [] - - for item in in_files: - name = ports[item[0]]["path"] - if (not item[1] == ports[item[0]]["is_console"]): - print ports - print "FAIL: Host console is not like console on guest side\n" - - if (name in files): - f.append(files[name]) - else: - try: - files[name] = os.open(name, os.O_RDWR) - if (ports[item[0]]["is_console"] == "yes"): - print os.system("stty -F %s raw -echo" % - (ports[item[0]]["path"])) - print os.system("stty -F %s -a" % ports[item[0]]["path"]) - f.append(files[name]) - except Exception as inst: - print "FAIL: Failed to open file %s" % name - raise inst - return f - - -def start_switch(in_files,out_files,cachesize=1): - """ - Start a switch thread - (because there is a problem with opening one file multiple times). - - @param in_files: array of input files - @param out_files: array of output files - @param cachesize: cachesize - """ - ports = get_port_status() - - in_f = open_device(in_files, ports) - out_f = open_device(out_files, ports) - - s = Switch(ev, in_f, out_f, cachesize) - s.start() - threads.append(s) - - print "PASS: Start switch" - - -def end_switches(): - """ - End all running data switches. - """ - ev.set() - for th in threads: - print "join" - th.join(3.0) - ev.clear() - - del threads[:] - print "PASS: End switch" - - -def die(): - """ - Quit consoleswitch. - """ - for desc in files.itervalues(): - os.close(desc) - current_pid = os.getpid() - os.kill(current_pid, 15) - - -def sender_prepare(port, length): - """ - Prepares the sender thread. Requires a clean thread structure. - """ - del threads[:] - ports = get_port_status() - in_f = open_device([port], ports) - - threads.append(Sender(in_f[0], length)) - print "PASS: Sender prepare" - - -def sender_start(): - """ - Start sender data transfer. Requires sender_prepare to run first. - """ - threads[0].start() - print "PASS: Sender start" - - -def main(): - """ - Main (infinite) loop of console_switch. - """ - print "PASS: Start" - end = False - while not end: - str = raw_input() - exec str - - -if __name__ == "__main__": - main() diff --git a/client/tests/kvm/scripts/virtio_guest.py b/client/tests/kvm/scripts/virtio_guest.py new file mode 100644 index 0000000..a0f9df8 --- /dev/null +++ b/client/tests/kvm/scripts/virtio_guest.py @@ -0,0 +1,571 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- +""" +Auxiliary script used to send data between ports on guests. + +@copyright: 2008-2009 Red Hat Inc. +@author: Jiri Zupka (jzupka@redhat.com) +@author: Lukas Doktor (ldoktor@redhat.com) +""" +#from _pydev_SimpleXMLRPCServer import fcntl + +""" +TODO: +virt.init([consoles]) # sysfs, udev, OK +virt.open(name) +virt.close(name) +virt.poll(name, eventmask, timeout) # poll.register(), poll.poll(), +return event +virt.send(name, length) # host disconnected +virt.recv(name, length) # host disconnected +virt.blocking(name, true) # true = blocking, false = nonblocking +virt.loopback(in_names, out_names, type="None") # use select/poll +""" + +import threading +from threading import Thread +import os, time, select, re, random, sys, array, fcntl, array, subprocess + +DEBUGPATH = "/sys/kernel/debug" +SYSFSPATH = "/sys/class/virtio-ports/" + + +class virtio_guest(): + + LOOP_NONE = 0 + LOOP_POLL = 1 + LOOP_SELECT = 2 + + def __init__(self): + self.files = {} + self.exit_thread = threading.Event() + self.threads = [] + self.ports = {} + + def _readfile(self, name): + """ + Read file and return content as string + + @param name: Name of file + @return: Content of file as string + """ + out = "" + try: + f = open(name, "r") + out = f.read() + f.close() + except: + print "FAIL: Cannot open file %s" % (name) + + return out + + def _get_port_status(self): + """ + Get info about ports from kernel debugfs. + + @return: Ports dictionary of port properties + """ + ports = {} + not_present_msg = "FAIL: There's no virtio-ports dir in debugfs" + if (not os.path.ismount(DEBUGPATH)): + os.system('mount -t debugfs none %s' % (DEBUGPATH)) + try: + if not os.path.isdir('%s/virtio-ports' % (DEBUGPATH)): + print not_present_msg + except: + print not_present_msg + else: + viop_names = os.listdir('%s/virtio-ports' % (DEBUGPATH)) + for name in viop_names: + f = open("%s/virtio-ports/%s" % (DEBUGPATH, name), 'r') + port = {} + for line in iter(f): + m = re.match("(\S+): (\S+)", line) + port[m.group(1)] = m.group(2) + + if (port['is_console'] == "yes"): + port["path"] = "/dev/hvc%s" % (port["console_vtermno"]) + # Console works like a serialport + else: + port["path"] = "/dev/%s" % name + + if (not os.path.exists(port['path'])): + print "FAIL: %s not exist" % port['path'] + + sysfspath = SYSFSPATH + name + if (not os.path.isdir(sysfspath)): + print "FAIL: %s not exist" % (sysfspath) + + info_name = sysfspath + "/name" + port_name = self._readfile(info_name).strip() + if (port_name != port["name"]): + print "FAIL: Port info not match \n%s - %s\n%s - %s" \ + % (info_name , port_name, \ + "%s/virtio-ports/%s" % (DEBUGPATH, name), port["name"]) + + ports[port['name']] = port + f.close() + + return ports + + def init(self, in_files): + """ + Init and check port properties + """ + self.ports = self._get_port_status() + + for item in in_files: + if (item[1] != self.ports[item[0]]["is_console"]): + print self.ports + print "FAIL: Host console is not like console on guest side\n" + print "PASS: Init and check virtioconsole files in system." + + class switch(Thread): + """ + Create a thread which sends data between ports. + """ + def __init__ (self, in_files, out_files, event, \ + cachesize=1024, method=0): + """ + @param in_files: Array of input files + @param out_files: Array of output files + @param method: Method of read/write access + @param cachesize: Block to receive and send + """ + Thread.__init__(self) + + self.in_files = in_files + self.out_files = out_files + self.exit_thread = event + self.method = method + + self.cachesize = cachesize + + def _none_mode(self): + """ + Read and write to device in blocking mode + """ + data = "" + while not self.exit_thread.isSet(): + data = "" + for desc in self.in_files: + data += os.read(desc, self.cachesize) + if data != "": + for desc in self.out_files: + os.write(desc, data) + + def _poll_mode(self): + """ + Read and write to device in polling mode + """ + + pi = select.poll() + po = select.poll() + + for fd in self.in_files: + pi.register(fd, select.POLLIN) + + for fd in self.out_files: + po.register(fd, select.POLLOUT) + readyf = [] + data = ""#array.array('B') + while not self.exit_thread.isSet(): + data = "" + t_out = self.out_files + + readyf = pi.poll(1.0) + for i in readyf: + try: + data += os.read(desc, self.cachesize) + except EOFError: + pass + + if data.count(x): + readyf = [] + while (len(t_out) != len(readyf)) and \ + not self.exit_thread.isSet(): + readyf = po.poll(1.0) + for desc in t_out: + os.write(desc, data) + + + + def _select_mode(self): + """ + Read and write to device in selecting mode + """ + data = "" + ret = [] + while not self.exit_thread.isSet(): + #TODO: Why select causes trouble? :-( + ret = select.select(self.in_files, [], [], 1.0) + data = "" + if ret[0] != []: + for desc in ret[0]: + data += os.read(desc, self.cachesize) + if data != "": + ret = select.select([], self.out_files, [], 1.0) + while (len(self.out_files) != len(ret[1])) and \ + not self.exit_thread.isSet(): + ret = select.select([], self.out_files, [], 1.0) + for desc in ret[1]: + os.write(desc, data) + + def run(self): + if (self.method == virtio_guest.LOOP_POLL): + self._poll_mode() + elif (self.method == virtio_guest.LOOP_SELECT): + self._select_mode() + else: + self._none_mode() + + def _poll_mode(self): + """ + Read and write to device in polling mode + """ + + pi = select.poll() + po = select.poll() + + for fd in self.in_files: + pi.register(fd, select.POLLIN) + + for fd in self.out_files: + po.register(fd, select.POLLOUT) + + while not self.exit_thread.isSet(): + data = "" + t_out = self.out_files + + readyf = pi.poll(1.0) + for i in readyf: + data += os.read(i[0], self.cachesize) + + if data != "": + while (len(t_out) != len(readyf)) and \ + not self.exit_thread.isSet(): + readyf = po.poll(1.0) + for desc in t_out: + os.write(desc, data) + + + + def _select_mode(self): + """ + Read and write to device in selecting mode + """ + while not self.exit_thread.isSet(): + #TODO: Why select causes trouble? :-( + ret = select.select(self.in_files, [], [], 1.0) + data = "" + if ret[0] != []: + for desc in ret[0]: + data += os.read(desc, self.cachesize) + if data != "": + ret = select.select([], self.out_files, [], 1.0) + while (len(self.out_files) != len(ret[1])) and \ + not self.exit_thread.isSet(): + ret = select.select([], self.out_files, [], 1.0) + for desc in ret[1]: + os.write(desc, data) + + def run(self): + if (self.method == virtio_guest.LOOP_POLL): + self._poll_mode() + elif (self.method == virtio_guest.LOOP_SELECT): + self._select_mode() + else: + self._none_mode() + + class sender(Thread): + """ + Creates thread which sends random blocks of data to the destination + port. + """ + def __init__(self, port, event, length): + """ + @param port: Destination port + @param length: Length of the random data block + """ + Thread.__init__(self) + self.port = port + self.exit_thread = event + self.data = array.array('L') + for i in range(max(length / self.data.itemsize, 1)): + self.data.append(random.randrange(sys.maxint)) + + def run(self): + while not self.exit_thread.isSet(): + os.write(self.port, self.data) + + + def _open(self, in_files): + """ + Open devices and return array of descriptors + + @param in_files: Files array + @return: Array of descriptor + """ + + f = [] + + for item in in_files: + name = self.ports[item]["path"] + if (name in self.files): + f.append(self.files[name]) + else: + try: + self.files[name] = os.open(name, os.O_RDWR) + if (self.ports[item]["is_console"] == "yes"): + print os.system("stty -F %s raw -echo" % (name)) + print os.system("stty -F %s -a" % (name)) + f.append(self.files[name]) + except Exception as inst: + print "FAIL: Failed to open file %s" % (name) + raise inst + return f + + + def poll(self, port, expected, timeout=500): + """ + Pool event from device and print event like text + + @param file: Device + """ + + in_f = self._open([port]) + + p = select.poll() + p.register(in_f[0]) + + mask = p.poll(timeout) + + str = "" + if (mask[0][1] & select.POLLIN): + str += "IN " + if (mask[0][1] & select.POLLPRI): + str += "PRI IN " + if (mask[0][1] & select.POLLOUT): + str += "OUT " + if (mask[0][1] & select.POLLERR): + str += "ERR " + if (mask[0][1] & select.POLLHUP): + str += "HUP " + if (mask[0][1] & select.POLLMSG): + str += "MSG " + + if (mask[0][1] & expected) == expected: + print "PASS: Events: " + str + else: + print "FAIL: Events: " + str + + + def blocking(self, port, mode=False): + """ + Set port function mode blocking/nonblocking + + @param port: port to set mode + @param mode: False to set nonblock mode, True for block mode + """ + path = self.ports[port]["path"] + fd = self.files[path] + + try: + fl = fcntl.fcntl(fd, fcntl.F_GETFL) + if not mode: + fcntl.fcntl(fd, fcntl.F_SETFL, fl | os.O_NONBLOCK) + else: + fcntl.fcntl(fd, fcntl.F_SETFL, fl & ~os.O_NONBLOCK) + + except Exception as inst: + print "FAIL: Setting (non)blocking mode: " + str(inst) + return + + print "PASS: set blocking mode to %s mode" % \ + ("blocking" if mode else "nonblocking") + + + def close(self, file): + """ + Close open port + + @param file: file to close + """ + descriptor = None + path = self.ports[file]["path"] + if path != None: + if path in self.files.keys(): + descriptor = self.files[path] + del self.files[path] + try: + os.close(descriptor) + except Exception as inst: + print "FAIL: Closing the file: " + str(inst) + return + print "PASS: Close" + + def open(self, in_files): + """ + Direct open devices. + + @param in_files: Files array + @return: Array of descriptor + """ + + name = self.ports[in_files]["path"] + try: + self.files[name] = os.open(name, os.O_RDWR) + print "PASS: Open all filles correctly." + except Exception as inst: + print "%s\nFAIL: Failed open file %s" % (str(inst), name) + + + def loopback(self, in_files, out_files, cachesize=1024, mode=LOOP_NONE): + """ + Function starts switch thread (because there is problem with multiple + open of one files). + + @param in_files: Array of input files + @param out_files: Array of output files + @param cachesize: Cachesize + """ + + + self.ports = self._get_port_status() + + in_f = self._open(in_files) + out_f = self._open(out_files) + + s = self.switch(in_f, out_f, self.exit_thread, cachesize, mode) + s.start() + self.threads.append(s) + print "PASS: Start switch" + + def exit_threads(self): + """ + Function end all running data switch. + """ + self.exit_thread.set() + for th in self.threads: + print "join" + th.join() + self.exit_thread.clear() + + del self.threads[:] + for desc in self.files.itervalues(): + os.close(desc) + self.files.clear() + print "PASS: All threads finished." + + def die(self): + """ + Quit consoleswitch. + """ + self.exit_threads() + exit() + + + def send_loop_init(self, port, length): + """ + Prepares the sender thread. Requires clean thread structure. + """ + self.ports = self._get_port_status() + in_f = self._open([port]) + + self.threads.append(self.sender(in_f[0], self.exit_thread, length)) + print "PASS: Sender prepare" + + + def send_loop(self): + """ + Start sender data transfer. Requires senderprepare run firs. + """ + self.threads[0].start() + print "PASS: Sender start" + + + def send(self, port, length=1, mode=True): + """ + Send a data of some length + + @param port: Port to write data + @param length: Length of data + @param mode: True = loop mode, False = one shoot mode + """ + in_f = self._open([port]) + + data = "" + while len(data) < length: + data += "%c" % random.randrange(255) + try: + writes = os.write(in_f[0], data) + except Exception as inst: + print inst + if not writes: + writes = 0 + if mode: + while (writes < length): + try: + writes += os.write(in_f[0], data) + except Exception as inst: + print inst + if writes >= length: + print "PASS: Send data length %d" % writes + else: + print "FAIL: Partial send: desired %d, transfered %d" \ + % (length, writes) + + + def recv(self, port, length=1, buffer=1024, mode=True): + """ + Recv a data of some length + + @param port: Port to write data + @param length: Length of data + @param mode: True = loop mode, False = one shoot mode + """ + in_f = self._open([port]) + + recvs = "" + try: + recvs = os.read(in_f[0], buffer) + except Exception as inst: + print inst + if mode: + while (len(recvs) < length): + try: + recvs += os.read(in_f[0], buffer) + except Exception as inst: + print inst + if len(recvs) >= length: + print "PASS: Recv data length %d" % len(recvs) + else: + print "FAIL: Partial recv: desired %d, transfered %d" \ + % (length, len(recvs)) + +def compile(): + """ + Compile virtio_guest.py to speed up. + """ + import py_compile + py_compile.compile(sys.path[0] + "/virtio_guest.py") + print "PASS: compile" + exit(0) + +def main(): + """ + Main (infinite) loop of virtio_guest. + """ + if (len(sys.argv) > 1) and (sys.argv[1] == "-c"): + compile() + + virt = virtio_guest() + print "PASS: Start" + + while True: + str = raw_input() + exec str + + +if __name__ == "__main__": + main() diff --git a/client/tests/kvm/tests/virtio_console.py b/client/tests/kvm/tests/virtio_console.py index 2e22f2f..058bb94 100644 --- a/client/tests/kvm/tests/virtio_console.py +++ b/client/tests/kvm/tests/virtio_console.py @@ -1,10 +1,10 @@ -import socket, random, array, sys, os, tempfile, shutil, threading, select, re -import logging, time -from threading import Thread +import array, logging, os, random, re, select, shutil, socket, sys, tempfile +import threading, time from collections import deque -from autotest_lib.client.common_lib import error -import kvm_subprocess, kvm_test_utils, kvm_utils, kvm_preprocessing +from threading import Thread +import kvm_subprocess, kvm_test_utils, kvm_utils, kvm_preprocessing +from autotest_lib.client.common_lib import error def run_virtio_console(test, params, env): """ @@ -28,139 +28,162 @@ def run_virtio_console(test, params, env): """ Random data sender thread. """ - def __init__(self, port, length, buffers, blocklen=32): - """ - @param port: Destination port. - @param length: Amount of data we want to send. - @param buffers: Buffers for the control data (FIFOs). - @param blocklen: Block length. - """ - Thread.__init__(self) - self.ExitState = True - self.port = port[0] - self.length = length - self.buffers = buffers - self.blocklen = blocklen - - - def run(self): - logging.debug("th_send %s: run", self.getName()) - idx = 0 - while idx < self.length: - ret = select.select([], [self.port], [], 1.0) - if ret: - # Generate blocklen of random data add them to the FIFO - # and send tham over virtio_console - buf = "" - for i in range(min(self.blocklen, self.length-idx)): - ch = "%c" % random.randrange(255) - buf += ch - for buffer in self.buffers: - buffer.append(ch) - idx += len(buf) - self.port.sendall(buf) - logging.debug("th_send %s: exit(%d)", self.getName(), idx) - if idx >= self.length: - self.ExitState = False - - - class th_send_loop(Thread): - """ - Send data in the loop until the exit event is set - """ def __init__(self, port, data, event): """ - @param port: destination port - @param data: the data intend to be send in a loop - @param event: exit event + @param port: Destination port. + @param data: The data intend to be send in a loop. + @param event: Exit event. """ 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 are too long, using only first %d bytes", + len(data)) self.data = data self.exitevent = event self.idx = 0 - - def run(self): - logging.debug("th_send_loop %s: run", self.getName()) + logging.debug("th_send %s: run", self.getName()) while not self.exitevent.isSet(): self.idx += self.port.send(self.data) - logging.debug("th_send_loop %s: exit(%d)", self.getName(), + logging.debug("th_send %s: exit(%d)", self.getName(), self.idx) - - class th_recv(Thread): + class th_send_check(Thread): """ - Random data reciever/checker thread + Random data sender thread """ - def __init__(self, port, buffer, length, blocklen=32): + def __init__(self, port, event, queues, blocklen=1024): """ - @param port: source port - @param buffer: control data buffer (FIFO) - @param length: amount of data we want to receive - @param blocklen: block length + @param port: Destination port + @param event: Exit event + @param queues: Queues for the control data (FIFOs) + @param blocklen: Block length """ Thread.__init__(self) - self.ExitState = True - self.port = port[0] - self.buffer = buffer - self.length = length + self.port = port + self.queues = queues + # FIXME: socket.send(data>>127998) without read blocks thread + if blocklen > 102400: + blocklen = 102400 + logging.error("Data are too long, using blocklen = %d", + blocklen) self.blocklen = blocklen - + self.exitevent = event + self.idx = 0 def run(self): - logging.debug("th_recv %s: run", self.getName()) - idx = 0 - while idx < self.length: - ret = select.select([self.port], [], [], 1.0) - if ret: - buf = self.port.recv(self.blocklen) - if buf: - # Compare the recvd data with the control data - for ch in buf: - if not ch == self.buffer.popleft(): - error.TestFail("th_recv: incorrect data") - idx += len(buf) - logging.debug("th_recv %s: exit(%d)", self.getName(), idx) - if (idx >= self.length) and (len(self.buffer) == 0): - self.ExitState = False + logging.debug("th_send_check %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 send 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], [], 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: + idx = self.port.send(buf) + buf = buf[idx:] + self.idx += idx + logging.debug("th_send_check %s: exit(%d)", self.getName(), + self.idx) + if too_much_data: + logging.error("th_send_check: workaround the 'too_much_data'" + "bug") - class th_recv_null(Thread): + class th_recv(Thread): """ - Receives data and throws it away. + Recieves data and throw them away """ - def __init__(self, port, event, blocklen=32): + def __init__(self, port, event, blocklen=1024): """ @param port: Data source port. @param event: Exit event. @param blocklen: Block length. """ Thread.__init__(self) - self.port = port[0] + self.port = port self._port_timeout = self.port.gettimeout() self.port.settimeout(0.1) self.exitevent = event self.blocklen = blocklen self.idx = 0 - - def run(self): - logging.debug("th_recv_null %s: run", self.getName()) + logging.debug("th_recv %s: run", self.getName()) while not self.exitevent.isSet(): - # Workaround, it didn't work with select :-/ + # 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("th_recv_null %s: exit(%d)", self.getName(), + logging.debug("th_recv %s: exit(%d)", self.getName(), self.idx) + + + class th_recv_check(Thread): + """ + Random data reciever/checker thread + """ + def __init__(self, port, buffer, event, blocklen=1024): + """ + @param port: Source port. + @param buffer: Control data buffer (FIFO). + @param length: Amount of data we want to receive. + @param blocklen: Block length. + """ + Thread.__init__(self) + self.port = port + self.buffer = buffer + self.exitevent = event + self.blocklen = blocklen + self.idx = 0 + def run(self): + logging.debug("th_recv_check %s: run", self.getName()) + while not self.exitevent.isSet(): + ret = select.select([self.port], [], [], 1.0) + if ret and (not self.exitevent.isSet()): + buf = self.port.recv(self.blocklen) + if buf: + # Compare the recvd data with the control data + for ch in buf: + ch_ = self.buffer.popleft() + if not ch == ch_: + self.exitevent.set() + logging.error("Failed to recv %dth character", + self.idx) + logging.error("%s != %s", repr(ch), repr(ch_)) + logging.error("Recv = %s", repr(buf)) + # sender might change the buffer :-( + time.sleep(1) + ch_ = "" + for buf in self.buffer: + ch_ += buf + logging.error("Queue = %s", repr(ch_)) + raise error.TestFail("th_recv_check: incorrect " + "data") + self.idx += len(buf) + logging.debug("th_recv_check %s: exit(%d)", self.getName(), self.idx) seqTest = threading.Lock(); - class average_cpu_load(): + class cpu_load(): """ Get average cpu load between start and get_load """ @@ -198,10 +221,11 @@ def run_virtio_console(test, params, env): return load - def start ( self ): + def start (self): """ Start CPU usage measurement """ + self.old_load = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0] self.startTime = time.time(); self._get_cpu_load() @@ -209,10 +233,11 @@ def run_virtio_console(test, params, env): def get_load(self): """ Get and reset CPU usage + @return: return group cpu (user[%], system[%], sum[%], testTime[s]) """ self.endTime = time.time() - testTime = self.endTime-self.startTime + testTime = self.endTime - self.startTime load = self._get_cpu_load() user = load[0] / testTime @@ -222,7 +247,7 @@ def run_virtio_console(test, params, env): return (user, system, sum, testTime) - class average_process_cpu_load(): + class pid_load(): """ Get average process cpu load between start and get_load """ @@ -234,7 +259,7 @@ def run_virtio_console(test, params, env): self.name = name - def _get_cpu_load(self,pid): + def _get_cpu_load(self, pid): # Let's see if we can calc system load. try: f = open("/proc/%d/stat" % (pid), "r") @@ -249,19 +274,19 @@ def run_virtio_console(test, params, env): load_values = reg.findall(line) del load_values[0:11] # extract values from /proc/stat - load = [0,0] + load = [0, 0] for i in range(2): - load[i] = int(load_values[i])-self.old_load[i] + load[i] = int(load_values[i]) - self.old_load[i] for i in range(2): self.old_load[i] = int(load_values[i]) return load - - def start ( self ): + def start (self): """ Start CPU usage measurement """ + self.old_load = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0] self.startTime = time.time(); self._get_cpu_load(self.pid) @@ -274,7 +299,7 @@ def run_virtio_console(test, params, env): (pid, user[%], system[%], sum[%], testTime[s]) """ self.endTime = time.time() - testTime = self.endTime - self.startTime + testTime = self.endTime - self.startTime load = self._get_cpu_load(self.pid) user = load[0] / testTime @@ -288,12 +313,12 @@ def run_virtio_console(test, params, env): """ Print load in tabular mode. - @param process: list of process statistic tuples - @param system: tuple of system cpu usage + @param process: List of process statistic tuples. + @param system: Tuple of system cpu usage. """ logging.info("%-10s %6s %5s %5s %5s %11s", - "NAME", "PID","USER","SYS","SUM","TIME") + "NAME", "PID", "USER", "SYS", "SUM", "TIME") for pr in process: logging.info("%-10s %6d %4.0f%% %4.0f%% %4.0f%% %10.3fs" % pr) logging.info("TOTAL: ------ %4.0f%% %4.0f%% %4.0f%% %10.3fs" % @@ -302,64 +327,96 @@ def run_virtio_console(test, params, env): def process_stats(stats, scale=1.0): """ - Process and print the stats. + Process and print the statistic. @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] + 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 _start_console_switch(vm, timeout=2): + def init_guest(vm, timeout=2): """ - Execute console_switch.py on guest, wait until it is initialized. + Execute virtio_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("Starting console_switch.py on guest %s", vm[0].name) - vm[1].sendline("python /tmp/console_switch.py") + logging.debug("compile virtio_guest.py on guest %s", vm[0].name) + vm[1].sendline("python -OO /tmp/virtio_guest.py -c &&" + "echo -n 'PASS: Compile virtio_guest finished' ||" + "echo -n 'FAIL: Compile virtio_guest failed'") (match, data) = vm[1].read_until_last_line_matches(["PASS:", "FAIL:"], timeout) if match == 1 or match is None: 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_guest.py on guest %s", vm[0].name) + vm[1].sendline("python /tmp/virtio_guest.pyo &&" + "echo -n 'PASS: virtio_guest finished' ||" + "echo -n 'FAIL: virtio_guest failed'") + (match, data) = vm[1].read_until_last_line_matches(["PASS:", "FAIL:"], + timeout) + if match == 1 or match is None: + 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 _execute_console_switch(command, vm, timeout=2): + 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 vm: Informations about the guest. @param timeout: Timeout used to verify expected output. @return: Tuple (match index, data) """ - logging.debug("Executing '%s' on console_switch.py loop, vm: %s," + logging.debug("Executing '%s' on virtio_guest.py loop, vm: %s," + "timeout: %s", command, vm[0].name, timeout) vm[1].sendline(command) - (match, data) = vm[1].read_until_last_line_matches(["PASS:","FAIL:"], - timeout) + (match, data) = vm[1].read_until_last_line_matches(["PASS:", "FAIL:" \ + "[Failed to execute]"], \ + timeout) + 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 console_switch.py, " + raise error.TestFail("Failed to execute '%s' on virtio_guest.py, " "vm: %s, output:\n%s" % (command, vm[0].name, data)) + return (match, data) def socket_readall(sock, read_timeout, mesagesize): """ - Read everything from the socket. + Read everything from the socket @param sock: socket @param read_timeout: read timeout @@ -380,14 +437,44 @@ def run_virtio_console(test, params, env): return message + def _guest_exit_threads(vm, send_pts, recv_pts): + """ + Safely executes on_guest("virt.exit_threads()") using workaround of + the stucked 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 == None: + logging.debug("Workaround the stucked thread on Guest") + # Thread is stucked in read/write + for send_pt in send_pts: + send_pt[0].sendall(".") + elif match != 0: + # Something else + raise error.TestFail("Unexpected fail\nMatch: %s\nData:\n" + % (match, tmp)) + + # Read-out all remaining data + for recv_pt in recv_pts: + while select.select([recv_pt[0]], [], [], 0.1)[0]: + recv_pt[0].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): """ Creates the VM and connects the specified number of consoles and serial ports. - @param no_console: number of desired virtconsoles - @param no_serialport: number of desired virtserialports - @return tuple with (guest information, consoles information) + @param no_console: Number of desired virtconsoles. + @param no_serialport: Number of desired virtserialports. + @return tupple with (guest information, consoles information) guest informations = [vm, session, tmp_dir] consoles informations = [consoles[], serialports[]] """ @@ -398,24 +485,24 @@ def run_virtio_console(test, params, env): params['extra_params'] = '' params['extra_params'] += " -device virtio-serial" - for i in range(0, no_console): - params['extra_params'] += (" -chardev socket,path=%s/%d,id=c%d," + for i in range(0, no_console): + params['extra_params'] += (" -chardev socket,path=%s/%d,id=%d," "server,nowait" % (tmp_dir, i, i)) - params['extra_params'] += (" -device virtconsole,chardev=c%d," - "name=org.fedoraproject.console.%d," - "id=c%d" % (i, i, i)) + params['extra_params'] += (" -device virtconsole,chardev=%d," + "name=console-%d,id=c%d" % (i, i, i)) for i in range(no_console, no_console + no_serialport): - params['extra_params'] += (" -chardev socket,path=%s/%d,id=p%d," + params['extra_params'] += (" -chardev socket,path=%s/%d,id=%d," "server,nowait" % (tmp_dir, i, i)) - params['extra_params'] += (" -device virtserialport,chardev=p%d," - "name=org.fedoraproject.data.%d,id=p%d" % - (i, i, i)) + params['extra_params'] += (" -device virtserialport,chardev=%d," + "name=serialport-%d,id=p%d" % (i, i, i)) + logging.debug("Booting first guest %s", params.get("main_vm")) kvm_preprocessing.preprocess_vm(test, params, env, params.get("main_vm")) + vm = kvm_utils.env_get_vm(env, params.get("main_vm")) session = kvm_test_utils.wait_for_login(vm, 0, @@ -426,12 +513,11 @@ def run_virtio_console(test, params, env): for i in range(0, no_console): sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) sock.connect("%s/%d" % (tmp_dir, i)) - consoles.append([sock, "org.fedoraproject.console.%d" % i, "yes"]) - + consoles.append([sock, "console-%d" % i, "yes"]) for i in range(no_console, no_console + no_serialport): sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) sock.connect("%s/%d" % (tmp_dir, i)) - serialports.append([sock, "org.fedoraproject.data.%d" % i, "no"]) + serialports.append([sock, "serialport-%d" % i, "no"]) return [vm, session, tmp_dir], [consoles, serialports] @@ -440,15 +526,15 @@ def run_virtio_console(test, params, env): """ Virtio console smoke test. - Creates loopback on the vm machine between the ports[>=2] provided and - sends the data + Tests the basic functionalities (poll, read/write with and without + connected host, etc. @param vm: target virtual machine [vm, session, tmp_dir] @param consoles: a field of virtio ports with the minimum of 2 items @param params: test parameters '$console_type:$data;...' """ - logging.info("Smoke test: Send data on the sender port, " - "verify data integrity on the receiving port") + logging.info("Smoke test: Tests the basic capabilities of " + "virtio_consoles.") # PREPARE for param in params.split(';'): if not param: @@ -462,23 +548,118 @@ def run_virtio_console(test, params, env): param = (param[0] == 'serialport') send_pt = consoles[param][0] recv_pt = consoles[param][1] - _start_console_switch(vm, 10.0) # TEST - _execute_console_switch('start_switch([%s], [%s])' % - (str(send_pt[1:3]), str(recv_pt[1:3])), - vm, 2.0) - + # Poll (OUT) + on_guest("virt.poll('%s', %s)" % (send_pt[1], select.POLLOUT), vm, + 2) + + # Poll (IN, OUT) + send_pt[0].sendall("test") + for test in [select.POLLIN, select.POLLOUT]: + on_guest("virt.poll('%s', %s)" % (send_pt[1], test), vm, 2) + + # Poll (IN HUP) + # I store the socket informations and close the socket + sock = send_pt[0] + send_pt[0] = sock.getpeername() + sock.shutdown(2) + sock.close() + del sock + for test in [select.POLLIN, select.POLLHUP]: + on_guest("virt.poll('%s', %s)" % (send_pt[1], test), vm, 2) + + # Poll (HUP) + on_guest("virt.recv('%s', 4, 1024, False)" % (send_pt[1]), vm, 2) + on_guest("virt.poll('%s', %s)" % (send_pt[1], select.POLLHUP), vm, + 2) + + # Reconnect the socket + sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) + sock.connect(send_pt[0]) + send_pt[0] = sock + # Redefine socket in consoles + consoles[param][0] = send_pt + on_guest("virt.poll('%s', %s)" % (send_pt[1], select.POLLOUT), vm, + 2) + + # Read/write without host connected + # I store the socket informations and close the socket + sock = send_pt[0] + send_pt[0] = sock.getpeername() + sock.shutdown(2) + sock.close() + del sock + # Read should pass + on_guest("virt.recv('%s', 0, 1024, False)" % send_pt[1], vm, 2) + # Write should timed-out + match, tmp = _on_guest("virt.send('%s', 10, False)" + % send_pt[1], vm, 2) + if match != None: + raise error.TestFail("Read on guest while host disconnected " + "didn't timed out.\nOutput:\n%s" + % tmp) + sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) + sock.connect(send_pt[0]) + send_pt[0] = sock + # Redefine socket in consoles + consoles[param][0] = send_pt + if (send_pt[0].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, 2) + + # Non-blocking mode + on_guest("virt.blocking('%s', False)" % send_pt[1], vm, 2) + # Recv should return FAIL with 0 received data + match, tmp = _on_guest("virt.recv('%s', 10, 1024, False)" + % send_pt[1], vm, 2) + if match == 0: + raise error.TestFail("Received data even when non were sent\n" + "Data:\n%s" % tmp) + elif match == 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" + % (match, tmp)) + send_pt[0].sendall("1234567890") + on_guest("virt.recv('%s', 10, 1024, False)" % send_pt[1], vm, 2) + + # Blocking mode + on_guest("virt.blocking('%s', True)" % send_pt[1], vm, 2) + # Recv should timed out + match, tmp = _on_guest("virt.recv('%s', 10, 1024, False)" + % send_pt[1], vm, 2) + if match == 0: + raise error.TestFail("Received data even when non were sent\n" + "Data:\n%s" % tmp) + elif match != None: + raise error.TestFail("Unexpected fail\nMatch: %s\nData:\n" + % (match, tmp)) + send_pt[0].sendall("1234567890") + # Now guest received the data end escaped from the recv() + on_guest("print 'PASS: nothing'", vm, 2) + + # Basic loopback test + on_guest("virt.loopback(['%s'], ['%s'], 1024, virt.LOOP_NONE)" + % (send_pt[1], recv_pt[1]), vm, 2) send_pt[0].sendall(data) - d = socket_readall(recv_pt[0], 1.0, len(data)) - if data != d: - raise error.TestFail("test_smoke: received data on port %s " - "does not match data sent through " - "port %s" % (recv_pt, send_pt)) - - vm[1].sendline('die()') + tmp = "" + i = 0 + while i <= 10: + i += 1 + ret = select.select([recv_pt[0]], [], [], 1.0) + if ret: + tmp += recv_pt[0].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_pt], [recv_pt]) - logging.info("test_smoke: PASS") + return consoles def test_loopback(vm, consoles, params): @@ -492,9 +673,9 @@ def run_virtio_console(test, params, env): @param vm: target virtual machine [vm, session, tmp_dir] @param consoles: a 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;...' + '$source_console_type@buffer_length: + $destination_console_type1@$buffer_length:...: + $loopback_buffer_length;...' """ logging.info("Loopback test: Creates a loopback between sender port " "and receiving port, send data through this connection, " @@ -517,7 +698,7 @@ def run_virtio_console(test, params, env): if (len(param[0].split('@')) == 2): buf_len.append(int(param[0].split('@')[1])) else: - buf_len.append(32) + buf_len.append(1024) recv_pts = [] for parm in param[1:]: if (parm.isdigit()): @@ -532,201 +713,170 @@ def run_virtio_console(test, params, env): if (len(parm[0].split('@')) == 2): buf_len.append(int(parm[0].split('@')[1])) else: - buf_len.append(32) + 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(32) + buf_len.append(1024) if len(recv_pts) == 0: raise error.TestFail("test_loopback: incorrect recv consoles" "definition") + threads = [] - buffers = [] + queues = [] for i in range(0, len(recv_pts)): - buffers.append(deque()) + queues.append(deque()) - _start_console_switch(vm, 10.0) - tmp = str(recv_pts[0][1:3]) + tmp = "'%s'" % recv_pts[0][1] for recv_pt in recv_pts[1:]: - tmp += ", " + str(recv_pt[1:3]) - _execute_console_switch('start_switch([%s], [%s], %d)' % - (str(send_pt[1:3]), tmp, buf_len[-1]), - vm, 2.0) + tmp += ", '%s'" % (recv_pt[1]) + on_guest("virt.loopback(['%s'], [%s], %d, virt.LOOP_POLL)" + % (send_pt[1], tmp, buf_len[-1]), vm, 2) + + exit_event = threading.Event() # TEST - thread = th_send(send_pt, 1048576, buffers, buf_len[0]) + thread = th_send_check(send_pt[0], exit_event, queues, buf_len[0]) thread.start() threads.append(thread) for i in range(len(recv_pts)): - thread = th_recv(recv_pts[i], buffers[i], 1048576, - buf_len[i+1]) + thread = th_recv_check(recv_pts[i][0], queues[i], exit_event, + buf_len[i + 1]) thread.start() threads.append(thread) - dead_threads = False - # Send + recv threads, DL 60s - for i in range(60): - for t in threads: - if not t.is_alive(): - if t.ExitState: - error.TestFail("test_loopback: send/recv thread " - "failed") - dead_threads = True - if dead_threads: - break - tmp = "" - for buf in buffers: - tmp += str(len(buf)) + ", " - logging.debug("test_loopback: buffer length (%s)", tmp[:-2]) - time.sleep(1) - - if not dead_threads: - raise error.TestFail("test_loopback: send/recv timeout") - # at this point at least one thread died. It should be the send one. - - # Wait for recv threads to finish their's work - for i in range(60): - dead_threads = True - for t in threads: - if t.is_alive(): - dead_threads = False - # There are no living threads - if dead_threads: - break - tmp = "" - for buf in buffers: - tmp += str(len(buf)) + ", " - logging.debug("test_loopback: buffer length (%s)", tmp[:-2]) - time.sleep(1) + 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]) - for t in threads: - if t.ExitState: - raise error.TestFail("test_loopback: recv thread failed") + # Read-out all remaining data + for recv_pt in recv_pts: + while select.select([recv_pt[0]], [], [], 0.1)[0]: + recv_pt[0].recv(1024) - # At least one thread is still alive - if not dead_threads: - raise error.TestFail("test_loopback: recv timeout") + _guest_exit_threads(vm, [send_pt], recv_pts) - vm[1].sendline("die()") - - logging.info("test_loopback: PASS") + del exit_event + del threads[:] def test_perf(vm, consoles, params): """ - Virtio console performance test. - Tests performance of the virtio_console tunel. First it sends the data - from host to guest and then back. It provides informations about - computer utilization and statistic information about the throughput. + 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] @param consoles: a field of virtio ports with the minimum of 2 items @param params: test parameters: - '$console_type@buffer_length:$test_duration;...' + '$console_type@$buffer_length:$test_duration;...' """ logging.info("Performance test: Measure performance for the " - "virtio console tunnel") - # PREPARE + "virtio console tunnel") for param in params.split(';'): if not param: continue - logging.info("test_perf: params: %s", param) + print "test_perf: params: %s" % param param = param.split(':') - if len(param) > 1 and param[1].isdigit(): - duration = float(param[1]) - else: - duration = 30.0 + 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 = 32 - if param[0] == "serialport": - port = consoles[1][0] - else: - port = consoles[0][0] - data = array.array("L") - for i in range(max((buf_len / data.itemsize), 1)): - data.append(random.randrange(sys.maxint)) - - ev = threading.Event() - thread = th_send_loop(port[0], data.tostring(), ev) + buf_len = 1024 + param = (param[0] == 'serialport') + port = consoles[param][0] - _start_console_switch(vm, 10.0) + data = "" + for i in range(buf_len): + data += "%c" % random.randrange(255) - _execute_console_switch('start_switch([%s], [], %d)' % - (str(port[1:3]), buf_len), vm, 2.0) + exit_event = threading.Event() + slice = float(duration)/100 - # TEST - # Host -> Guest - load = [] + # HOST->GUEST + on_guest('virt.loopback(["%s"], [], %d, virt.LOOP_NONE)' % ( + port[1], buf_len), vm, 2) + thread = th_send(port[0], data, exit_event) stats = array.array('f', []) - slice = float(duration)/100 - load.append(average_cpu_load()) - load.append(average_process_cpu_load(os.getpid(), 'autotest')) - load.append(average_process_cpu_load(vm[0].get_pid(), 'VM')) - for ld in load: - ld.start() + loads = [] + loads.append(cpu_load()) + loads.append(pid_load(os.getpid(), 'autotest')) + loads.append(pid_load(vm[0].get_pid(), 'VM')) + + for load in loads: + load.start() _time = time.time() thread.start() for i in range(100): stats.append(thread.idx) time.sleep(slice) _time = time.time() - _time - duration - print_load([load[1].get_load(), load[2].get_load()], - load[0].get_load()) - ev.set() + print_load([loads[1].get_load(), loads[2].get_load()], + loads[0].get_load()) + exit_event.set() thread.join() + + _guest_exit_threads(vm, [port], []) + if (_time > slice): - logging.error("test_perf: test ran %fs longer " - "(more than 1 slice)", _time) + logging.error( + "Test ran %fs longer which is more than one slice", _time) else: - logging.debug("test_perf: test ran %fs longer " - "(less than 1 slice)", _time) - stats = process_stats(stats[1:], slice*1024*1024) - logging.info("Host -> Guest [MB/s] min/med/max = %.3f/%.3f/%.3f", + logging.debug("Test ran %fs longer", _time) + stats = process_stats(stats[1:], 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]) - time.sleep(5) - vm[1].sendline("die()") - # Guest -> Host - _start_console_switch(vm, 10.0) - _execute_console_switch('sender_prepare(%s, %d)' % - (str(port[1:3]), buf_len), vm, 10) + del thread + + # GUEST->HOST + exit_event.clear() stats = array.array('f', []) - ev.clear() - thread = th_recv_null(port, ev, buf_len) + on_guest("virt.send_loop_init('%s', %d)" % (port[1], buf_len), + vm, 30) + thread = th_recv(port[0], exit_event, buf_len) thread.start() - # reset load measures - for ld in load: - ld.get_load() - _execute_console_switch('sender_start()', vm, 2) + for load in loads: + load.start() + on_guest("virt.send_loop()", vm, 2) _time = time.time() for i in range(100): stats.append(thread.idx) time.sleep(slice) _time = time.time() - _time - duration - print_load([load[1].get_load(), load[2].get_load()], - load[0].get_load()) - vm[1].sendline("die()") - time.sleep(5) - ev.set() + print_load([loads[1].get_load(), loads[2].get_load()], + loads[0].get_load()) + on_guest("virt.exit_threads()", vm, 2) + exit_event.set() thread.join() if (_time > slice): # Deviation is higher than 1 slice - logging.error("test_perf: test ran %fs longer " - "(more than 1 slice)", _time) + logging.error( + "Test ran %fs longer which is more than one slice", _time) else: - logging.debug("test_perf: test ran %fs longer " - "(less than 1 slice)", _time) - stats = process_stats(stats[1:], slice*1024*1024) - logging.info("Guest -> Host [MB/s] min/med/max = %.3f/%.3f/%.3f", + logging.debug("Test ran %fs longer" % _time) + stats = process_stats(stats[1:], 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]) - for ld in load: - del(ld) - logging.info("test_perf: PASS") + del thread + + del exit_event + del loads[:] # INITIALIZE @@ -736,35 +886,44 @@ def run_virtio_console(test, params, env): no_serialports = 0 no_consoles = 0 - # consoles required for Smoke test if (test_smoke_params.count('serialport')): no_serialports = max(2, no_serialports) if (test_smoke_params.count('console')): no_consoles = max(2, no_consoles) - # consoles required for Loopback test for param in test_loopback_params.split(';'): no_serialports = max(no_serialports, param.count('serialport')) no_consoles = max(no_consoles, param.count('console')) - # consoles required for Performance test if (test_perf_params.count('serialport')): no_serialports = max(1, no_serialports) if (test_perf_params.count('console')): no_consoles = max(1, 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 console_switch.py into guests + # Copy allocator.py into guests pwd = os.path.join(os.environ['AUTODIR'], 'tests/kvm') - vksmd_src = os.path.join(pwd, "scripts/console_switch.py") + vksmd_src = os.path.join(pwd, "scripts/virtio_guest.py") dst_dir = "/tmp" if not vm[0].copy_files_to(vksmd_src, dst_dir): raise error.TestFail("copy_files_to failed %s" % vm[0].name) # ACTUAL TESTING - test_smoke(vm, consoles, test_smoke_params) + # Defines all available consoles; tests udev and sysfs + conss = [] + for mode in consoles: + for cons in mode: + conss.append(cons[1:3]) + init_guest(vm, 10) + on_guest("virt.init(%s)" % (conss), vm, 10) + + consoles = test_smoke(vm, consoles, test_smoke_params) test_loopback(vm, consoles, test_loopback_params) test_perf(vm, consoles, test_perf_params) @@ -772,3 +931,4 @@ def run_virtio_console(test, params, env): vm[1].close() vm[0].destroy(gracefully=False) shutil.rmtree(vm[2]) + diff --git a/client/tests/kvm/tests_base.cfg.sample b/client/tests/kvm/tests_base.cfg.sample index bef0f1c..ff0a760 100644 --- a/client/tests/kvm/tests_base.cfg.sample +++ b/client/tests/kvm/tests_base.cfg.sample @@ -502,11 +502,15 @@ variants: vms = '' type = virtio_console # smoke params - $console_type:data_string - virtio_console_smoke = "serialport;console:Custom data" + # FIXME: test_smoke doesn't work with console yet (virtio_console bug) + # "serialport;console:Custom data" + virtio_console_smoke = "serialport" # loopback params - '$source_console_type@buffer_length:$destination_console_type1@buffer_length:...:$loopback_buffer_length;...' virtio_console_loopback = "serialport:serialport;serialport@1024:serialport@32:console@1024:console@8:16" # perf params - $console_type@buffer_length:$test_duration - virtio_console_perf = "serialport;serialport@1000000:120;console@1024:60" + # FIXME: test_perf doesn't work with console yet (virtio_console bug) + # virtio_console_perf = "serialport;serialport@1000000:120;console@1024:60" + virtio_console_perf = "serialport;serialport@1000000:120" # This unit test module is for older branches of KVM that use the # kvmctl test harness (such as the code shipped with RHEL 5.x)