| OLD | NEW |
|---|
| (Empty) |
| 1 #!/usr/bin/python | |
| 2 # -*- coding: utf-8 -*- | |
| 3 """ | |
| 4 Auxiliary script used to send data between ports on guests. | |
| 5 | |
| 6 @copyright: 2008-2009 Red Hat Inc. | |
| 7 @author: Jiri Zupka (jzupka@redhat.com) | |
| 8 @author: Lukas Doktor (ldoktor@redhat.com) | |
| 9 """ | |
| 10 #from _pydev_SimpleXMLRPCServer import fcntl | |
| 11 | |
| 12 """ | |
| 13 TODO: | |
| 14 virt.init([consoles]) # sysfs, udev, OK | |
| 15 virt.open(name) | |
| 16 virt.close(name) | |
| 17 virt.poll(name, eventmask, timeout) # poll.register(), poll.poll(), | |
| 18 return event | |
| 19 virt.send(name, length) # host disconnected | |
| 20 virt.recv(name, length) # host disconnected | |
| 21 virt.blocking(name, true) # true = blocking, false = nonblocking | |
| 22 virt.loopback(in_names, out_names, type="None") # use select/poll | |
| 23 """ | |
| 24 | |
| 25 import threading | |
| 26 from threading import Thread | |
| 27 import os, time, select, re, random, sys, array, fcntl, array, subprocess | |
| 28 | |
| 29 DEBUGPATH = "/sys/kernel/debug" | |
| 30 SYSFSPATH = "/sys/class/virtio-ports/" | |
| 31 | |
| 32 | |
| 33 class virtio_guest(): | |
| 34 | |
| 35 LOOP_NONE = 0 | |
| 36 LOOP_POLL = 1 | |
| 37 LOOP_SELECT = 2 | |
| 38 | |
| 39 def __init__(self): | |
| 40 self.files = {} | |
| 41 self.exit_thread = threading.Event() | |
| 42 self.threads = [] | |
| 43 self.ports = {} | |
| 44 | |
| 45 | |
| 46 def _readfile(self, name): | |
| 47 """ | |
| 48 Read file and return content as string | |
| 49 | |
| 50 @param name: Name of file | |
| 51 @return: Content of file as string | |
| 52 """ | |
| 53 out = "" | |
| 54 try: | |
| 55 f = open(name, "r") | |
| 56 out = f.read() | |
| 57 f.close() | |
| 58 except: | |
| 59 print "FAIL: Cannot open file %s" % (name) | |
| 60 | |
| 61 return out | |
| 62 | |
| 63 | |
| 64 def _get_port_status(self): | |
| 65 """ | |
| 66 Get info about ports from kernel debugfs. | |
| 67 | |
| 68 @return: Ports dictionary of port properties | |
| 69 """ | |
| 70 ports = {} | |
| 71 not_present_msg = "FAIL: There's no virtio-ports dir in debugfs" | |
| 72 if (not os.path.ismount(DEBUGPATH)): | |
| 73 os.system('mount -t debugfs none %s' % (DEBUGPATH)) | |
| 74 try: | |
| 75 if not os.path.isdir('%s/virtio-ports' % (DEBUGPATH)): | |
| 76 print not_present_msg | |
| 77 except: | |
| 78 print not_present_msg | |
| 79 else: | |
| 80 viop_names = os.listdir('%s/virtio-ports' % (DEBUGPATH)) | |
| 81 for name in viop_names: | |
| 82 f = open("%s/virtio-ports/%s" % (DEBUGPATH, name), 'r') | |
| 83 port = {} | |
| 84 for line in iter(f): | |
| 85 m = re.match("(\S+): (\S+)", line) | |
| 86 port[m.group(1)] = m.group(2) | |
| 87 | |
| 88 if (port['is_console'] == "yes"): | |
| 89 port["path"] = "/dev/hvc%s" % (port["console_vtermno"]) | |
| 90 # Console works like a serialport | |
| 91 else: | |
| 92 port["path"] = "/dev/%s" % name | |
| 93 | |
| 94 if (not os.path.exists(port['path'])): | |
| 95 print "FAIL: %s not exist" % port['path'] | |
| 96 | |
| 97 sysfspath = SYSFSPATH + name | |
| 98 if (not os.path.isdir(sysfspath)): | |
| 99 print "FAIL: %s not exist" % (sysfspath) | |
| 100 | |
| 101 info_name = sysfspath + "/name" | |
| 102 port_name = self._readfile(info_name).strip() | |
| 103 if (port_name != port["name"]): | |
| 104 print ("FAIL: Port info not match \n%s - %s\n%s - %s" % | |
| 105 (info_name , port_name, | |
| 106 "%s/virtio-ports/%s" % (DEBUGPATH, name), | |
| 107 port["name"])) | |
| 108 | |
| 109 ports[port['name']] = port | |
| 110 f.close() | |
| 111 | |
| 112 return ports | |
| 113 | |
| 114 | |
| 115 def init(self, in_files): | |
| 116 """ | |
| 117 Init and check port properties. | |
| 118 """ | |
| 119 self.ports = self._get_port_status() | |
| 120 | |
| 121 for item in in_files: | |
| 122 if (item[1] != self.ports[item[0]]["is_console"]): | |
| 123 print self.ports | |
| 124 print "FAIL: Host console is not like console on guest side\n" | |
| 125 print "PASS: Init and check virtioconsole files in system." | |
| 126 | |
| 127 | |
| 128 class switch(Thread): | |
| 129 """ | |
| 130 Thread that sends data between ports. | |
| 131 """ | |
| 132 def __init__ (self, in_files, out_files, event, | |
| 133 cachesize=1024, method=0): | |
| 134 """ | |
| 135 @param in_files: Array of input files. | |
| 136 @param out_files: Array of output files. | |
| 137 @param method: Method of read/write access. | |
| 138 @param cachesize: Block to receive and send. | |
| 139 """ | |
| 140 Thread.__init__(self) | |
| 141 | |
| 142 self.in_files = in_files | |
| 143 self.out_files = out_files | |
| 144 self.exit_thread = event | |
| 145 self.method = method | |
| 146 | |
| 147 self.cachesize = cachesize | |
| 148 | |
| 149 | |
| 150 def _none_mode(self): | |
| 151 """ | |
| 152 Read and write to device in blocking mode | |
| 153 """ | |
| 154 data = "" | |
| 155 while not self.exit_thread.isSet(): | |
| 156 data = "" | |
| 157 for desc in self.in_files: | |
| 158 data += os.read(desc, self.cachesize) | |
| 159 if data != "": | |
| 160 for desc in self.out_files: | |
| 161 os.write(desc, data) | |
| 162 | |
| 163 | |
| 164 def _poll_mode(self): | |
| 165 """ | |
| 166 Read and write to device in polling mode. | |
| 167 """ | |
| 168 | |
| 169 pi = select.poll() | |
| 170 po = select.poll() | |
| 171 | |
| 172 for fd in self.in_files: | |
| 173 pi.register(fd, select.POLLIN) | |
| 174 | |
| 175 for fd in self.out_files: | |
| 176 po.register(fd, select.POLLOUT) | |
| 177 | |
| 178 while not self.exit_thread.isSet(): | |
| 179 data = "" | |
| 180 t_out = self.out_files | |
| 181 | |
| 182 readyf = pi.poll(1.0) | |
| 183 for i in readyf: | |
| 184 data += os.read(i[0], self.cachesize) | |
| 185 | |
| 186 if data != "": | |
| 187 while ((len(t_out) != len(readyf)) and not | |
| 188 self.exit_thread.isSet()): | |
| 189 readyf = po.poll(1.0) | |
| 190 for desc in t_out: | |
| 191 os.write(desc, data) | |
| 192 | |
| 193 | |
| 194 def _select_mode(self): | |
| 195 """ | |
| 196 Read and write to device in selecting mode. | |
| 197 """ | |
| 198 while not self.exit_thread.isSet(): | |
| 199 ret = select.select(self.in_files, [], [], 1.0) | |
| 200 data = "" | |
| 201 if ret[0] != []: | |
| 202 for desc in ret[0]: | |
| 203 data += os.read(desc, self.cachesize) | |
| 204 if data != "": | |
| 205 ret = select.select([], self.out_files, [], 1.0) | |
| 206 while ((len(self.out_files) != len(ret[1])) and not | |
| 207 self.exit_thread.isSet()): | |
| 208 ret = select.select([], self.out_files, [], 1.0) | |
| 209 for desc in ret[1]: | |
| 210 os.write(desc, data) | |
| 211 | |
| 212 | |
| 213 def run(self): | |
| 214 if (self.method == virtio_guest.LOOP_POLL): | |
| 215 self._poll_mode() | |
| 216 elif (self.method == virtio_guest.LOOP_SELECT): | |
| 217 self._select_mode() | |
| 218 else: | |
| 219 self._none_mode() | |
| 220 | |
| 221 | |
| 222 class sender(Thread): | |
| 223 """ | |
| 224 Creates a thread which sends random blocks of data to dst port. | |
| 225 """ | |
| 226 def __init__(self, port, event, length): | |
| 227 """ | |
| 228 @param port: Destination port | |
| 229 @param length: Length of the random data block | |
| 230 """ | |
| 231 Thread.__init__(self) | |
| 232 self.port = port | |
| 233 self.exit_thread = event | |
| 234 self.data = array.array('L') | |
| 235 for i in range(max(length / self.data.itemsize, 1)): | |
| 236 self.data.append(random.randrange(sys.maxint)) | |
| 237 | |
| 238 def run(self): | |
| 239 while not self.exit_thread.isSet(): | |
| 240 os.write(self.port, self.data) | |
| 241 | |
| 242 | |
| 243 def _open(self, in_files): | |
| 244 """ | |
| 245 Open devices and return array of descriptors | |
| 246 | |
| 247 @param in_files: Files array | |
| 248 @return: Array of descriptor | |
| 249 """ | |
| 250 f = [] | |
| 251 | |
| 252 for item in in_files: | |
| 253 name = self.ports[item]["path"] | |
| 254 if (name in self.files): | |
| 255 f.append(self.files[name]) | |
| 256 else: | |
| 257 try: | |
| 258 self.files[name] = os.open(name, os.O_RDWR) | |
| 259 if (self.ports[item]["is_console"] == "yes"): | |
| 260 print os.system("stty -F %s raw -echo" % (name)) | |
| 261 print os.system("stty -F %s -a" % (name)) | |
| 262 f.append(self.files[name]) | |
| 263 except Exception as inst: | |
| 264 print "FAIL: Failed to open file %s" % (name) | |
| 265 raise inst | |
| 266 return f | |
| 267 | |
| 268 | |
| 269 def poll(self, port, expected, timeout=500): | |
| 270 """ | |
| 271 Pool event from device and print event like text. | |
| 272 | |
| 273 @param file: Device. | |
| 274 """ | |
| 275 in_f = self._open([port]) | |
| 276 | |
| 277 p = select.poll() | |
| 278 p.register(in_f[0]) | |
| 279 | |
| 280 mask = p.poll(timeout) | |
| 281 | |
| 282 str = "" | |
| 283 if (mask[0][1] & select.POLLIN): | |
| 284 str += "IN " | |
| 285 if (mask[0][1] & select.POLLPRI): | |
| 286 str += "PRI IN " | |
| 287 if (mask[0][1] & select.POLLOUT): | |
| 288 str += "OUT " | |
| 289 if (mask[0][1] & select.POLLERR): | |
| 290 str += "ERR " | |
| 291 if (mask[0][1] & select.POLLHUP): | |
| 292 str += "HUP " | |
| 293 if (mask[0][1] & select.POLLMSG): | |
| 294 str += "MSG " | |
| 295 | |
| 296 if (mask[0][1] & expected) == expected: | |
| 297 print "PASS: Events: " + str | |
| 298 else: | |
| 299 print "FAIL: Events: " + str | |
| 300 | |
| 301 | |
| 302 def blocking(self, port, mode=False): | |
| 303 """ | |
| 304 Set port function mode blocking/nonblocking | |
| 305 | |
| 306 @param port: port to set mode | |
| 307 @param mode: False to set nonblock mode, True for block mode | |
| 308 """ | |
| 309 path = self.ports[port]["path"] | |
| 310 fd = self.files[path] | |
| 311 | |
| 312 try: | |
| 313 fl = fcntl.fcntl(fd, fcntl.F_GETFL) | |
| 314 if not mode: | |
| 315 fcntl.fcntl(fd, fcntl.F_SETFL, fl | os.O_NONBLOCK) | |
| 316 else: | |
| 317 fcntl.fcntl(fd, fcntl.F_SETFL, fl & ~os.O_NONBLOCK) | |
| 318 | |
| 319 except Exception as inst: | |
| 320 print "FAIL: Setting (non)blocking mode: " + str(inst) | |
| 321 return | |
| 322 | |
| 323 print ("PASS: set blocking mode to %s mode" % | |
| 324 ("blocking" if mode else "nonblocking")) | |
| 325 | |
| 326 | |
| 327 def close(self, file): | |
| 328 """ | |
| 329 Close open port. | |
| 330 | |
| 331 @param file: File to close. | |
| 332 """ | |
| 333 descriptor = None | |
| 334 path = self.ports[file]["path"] | |
| 335 if path != None: | |
| 336 if path in self.files.keys(): | |
| 337 descriptor = self.files[path] | |
| 338 del self.files[path] | |
| 339 try: | |
| 340 os.close(descriptor) | |
| 341 except Exception as inst: | |
| 342 print "FAIL: Closing the file: " + str(inst) | |
| 343 return | |
| 344 print "PASS: Close" | |
| 345 | |
| 346 | |
| 347 def open(self, in_files): | |
| 348 """ | |
| 349 Direct open devices. | |
| 350 | |
| 351 @param in_files: Array of files. | |
| 352 @return: Array of descriptors. | |
| 353 """ | |
| 354 name = self.ports[in_files]["path"] | |
| 355 try: | |
| 356 self.files[name] = os.open(name, os.O_RDWR) | |
| 357 print "PASS: Open all filles correctly." | |
| 358 except Exception as inst: | |
| 359 print "%s\nFAIL: Failed open file %s" % (str(inst), name) | |
| 360 | |
| 361 | |
| 362 def loopback(self, in_files, out_files, cachesize=1024, mode=LOOP_NONE): | |
| 363 """ | |
| 364 Start a switch thread. | |
| 365 | |
| 366 (There is a problem with multiple opens of a single file). | |
| 367 | |
| 368 @param in_files: Array of input files. | |
| 369 @param out_files: Array of output files. | |
| 370 @param cachesize: Cachesize. | |
| 371 """ | |
| 372 self.ports = self._get_port_status() | |
| 373 | |
| 374 in_f = self._open(in_files) | |
| 375 out_f = self._open(out_files) | |
| 376 | |
| 377 s = self.switch(in_f, out_f, self.exit_thread, cachesize, mode) | |
| 378 s.start() | |
| 379 self.threads.append(s) | |
| 380 print "PASS: Start switch" | |
| 381 | |
| 382 | |
| 383 def exit_threads(self): | |
| 384 """ | |
| 385 Function end all running data switch. | |
| 386 """ | |
| 387 self.exit_thread.set() | |
| 388 for th in self.threads: | |
| 389 print "join" | |
| 390 th.join() | |
| 391 self.exit_thread.clear() | |
| 392 | |
| 393 del self.threads[:] | |
| 394 for desc in self.files.itervalues(): | |
| 395 os.close(desc) | |
| 396 self.files.clear() | |
| 397 print "PASS: All threads finished." | |
| 398 | |
| 399 | |
| 400 def die(self): | |
| 401 """ | |
| 402 Quit consoleswitch. | |
| 403 """ | |
| 404 self.exit_threads() | |
| 405 exit() | |
| 406 | |
| 407 | |
| 408 def send_loop_init(self, port, length): | |
| 409 """ | |
| 410 Prepares the sender thread. Requires clean thread structure. | |
| 411 """ | |
| 412 self.ports = self._get_port_status() | |
| 413 in_f = self._open([port]) | |
| 414 | |
| 415 self.threads.append(self.sender(in_f[0], self.exit_thread, length)) | |
| 416 print "PASS: Sender prepare" | |
| 417 | |
| 418 | |
| 419 def send_loop(self): | |
| 420 """ | |
| 421 Start sender data transfer. Requires senderprepare run first. | |
| 422 """ | |
| 423 self.threads[0].start() | |
| 424 print "PASS: Sender start" | |
| 425 | |
| 426 | |
| 427 def send(self, port, length=1, mode=True): | |
| 428 """ | |
| 429 Send a data of some length | |
| 430 | |
| 431 @param port: Port to write data | |
| 432 @param length: Length of data | |
| 433 @param mode: True = loop mode, False = one shoot mode | |
| 434 """ | |
| 435 in_f = self._open([port]) | |
| 436 | |
| 437 data = "" | |
| 438 while len(data) < length: | |
| 439 data += "%c" % random.randrange(255) | |
| 440 try: | |
| 441 writes = os.write(in_f[0], data) | |
| 442 except Exception as inst: | |
| 443 print inst | |
| 444 if not writes: | |
| 445 writes = 0 | |
| 446 if mode: | |
| 447 while (writes < length): | |
| 448 try: | |
| 449 writes += os.write(in_f[0], data) | |
| 450 except Exception as inst: | |
| 451 print inst | |
| 452 if writes >= length: | |
| 453 print "PASS: Send data length %d" % writes | |
| 454 else: | |
| 455 print ("FAIL: Partial send: desired %d, transfered %d" % | |
| 456 (length, writes)) | |
| 457 | |
| 458 | |
| 459 def recv(self, port, length=1, buffer=1024, mode=True): | |
| 460 """ | |
| 461 Recv a data of some length | |
| 462 | |
| 463 @param port: Port to write data | |
| 464 @param length: Length of data | |
| 465 @param mode: True = loop mode, False = one shoot mode | |
| 466 """ | |
| 467 in_f = self._open([port]) | |
| 468 | |
| 469 recvs = "" | |
| 470 try: | |
| 471 recvs = os.read(in_f[0], buffer) | |
| 472 except Exception as inst: | |
| 473 print inst | |
| 474 if mode: | |
| 475 while (len(recvs) < length): | |
| 476 try: | |
| 477 recvs += os.read(in_f[0], buffer) | |
| 478 except Exception as inst: | |
| 479 print inst | |
| 480 if len(recvs) >= length: | |
| 481 print "PASS: Recv data length %d" % len(recvs) | |
| 482 else: | |
| 483 print ("FAIL: Partial recv: desired %d, transfered %d" % | |
| 484 (length, len(recvs))) | |
| 485 | |
| 486 | |
| 487 def compile(): | |
| 488 """ | |
| 489 Compile virtio_guest.py to speed up. | |
| 490 """ | |
| 491 import py_compile | |
| 492 py_compile.compile(sys.path[0] + "/virtio_guest.py") | |
| 493 print "PASS: compile" | |
| 494 exit(0) | |
| 495 | |
| 496 | |
| 497 def main(): | |
| 498 """ | |
| 499 Main (infinite) loop of virtio_guest. | |
| 500 """ | |
| 501 if (len(sys.argv) > 1) and (sys.argv[1] == "-c"): | |
| 502 compile() | |
| 503 | |
| 504 virt = virtio_guest() | |
| 505 print "PASS: Start" | |
| 506 | |
| 507 while True: | |
| 508 str = raw_input() | |
| 509 exec str | |
| 510 | |
| 511 | |
| 512 if __name__ == "__main__": | |
| 513 main() | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 3541002:
Revert "Merge remote branch 'cros/upstream' into tempbranch2" (Closed)
Base URL: ssh://git@gitrw.chromium.org:9222/autotest.git