+1 -501

python/qemu/__init__.py

··· 12 12 # Based on qmp.py. 13 13 # 14 14 15 15 - import errno 16 15 import logging 17 16 import os 18 18 - import subprocess 19 19 - import re 20 20 - import shutil 21 21 - import socket 22 22 - import tempfile 23 17 24 18 from . import qmp 25 25 - 19 19 + from . import machine 26 20 27 21 LOG = logging.getLogger(__name__) 28 22 ··· 39 33 if target_arch != ADDITIONAL_ARCHES.get(host_arch): 40 34 return False 41 35 return os.access("/dev/kvm", os.R_OK | os.W_OK) 42 42 - 43 43 - 44 44 - class QEMUMachineError(Exception): 45 45 - """ 46 46 - Exception called when an error in QEMUMachine happens. 47 47 - """ 48 48 - 49 49 - 50 50 - class QEMUMachineAddDeviceError(QEMUMachineError): 51 51 - """ 52 52 - Exception raised when a request to add a device can not be fulfilled 53 53 - 54 54 - The failures are caused by limitations, lack of information or conflicting 55 55 - requests on the QEMUMachine methods. This exception does not represent 56 56 - failures reported by the QEMU binary itself. 57 57 - """ 58 58 - 59 59 - class MonitorResponseError(qmp.QMPError): 60 60 - """ 61 61 - Represents erroneous QMP monitor reply 62 62 - """ 63 63 - def __init__(self, reply): 64 64 - try: 65 65 - desc = reply["error"]["desc"] 66 66 - except KeyError: 67 67 - desc = reply 68 68 - super(MonitorResponseError, self).__init__(desc) 69 69 - self.reply = reply 70 70 - 71 71 - 72 72 - class QEMUMachine(object): 73 73 - """ 74 74 - A QEMU VM 75 75 - 76 76 - Use this object as a context manager to ensure the QEMU process terminates:: 77 77 - 78 78 - with VM(binary) as vm: 79 79 - ... 80 80 - # vm is guaranteed to be shut down here 81 81 - """ 82 82 - 83 83 - def __init__(self, binary, args=None, wrapper=None, name=None, 84 84 - test_dir="/var/tmp", monitor_address=None, 85 85 - socket_scm_helper=None): 86 86 - ''' 87 87 - Initialize a QEMUMachine 88 88 - 89 89 - @param binary: path to the qemu binary 90 90 - @param args: list of extra arguments 91 91 - @param wrapper: list of arguments used as prefix to qemu binary 92 92 - @param name: prefix for socket and log file names (default: qemu-PID) 93 93 - @param test_dir: where to create socket and log file 94 94 - @param monitor_address: address for QMP monitor 95 95 - @param socket_scm_helper: helper program, required for send_fd_scm() 96 96 - @note: Qemu process is not started until launch() is used. 97 97 - ''' 98 98 - if args is None: 99 99 - args = [] 100 100 - if wrapper is None: 101 101 - wrapper = [] 102 102 - if name is None: 103 103 - name = "qemu-%d" % os.getpid() 104 104 - self._name = name 105 105 - self._monitor_address = monitor_address 106 106 - self._vm_monitor = None 107 107 - self._qemu_log_path = None 108 108 - self._qemu_log_file = None 109 109 - self._popen = None 110 110 - self._binary = binary 111 111 - self._args = list(args) # Force copy args in case we modify them 112 112 - self._wrapper = wrapper 113 113 - self._events = [] 114 114 - self._iolog = None 115 115 - self._socket_scm_helper = socket_scm_helper 116 116 - self._qmp = None 117 117 - self._qemu_full_args = None 118 118 - self._test_dir = test_dir 119 119 - self._temp_dir = None 120 120 - self._launched = False 121 121 - self._machine = None 122 122 - self._console_set = False 123 123 - self._console_device_type = None 124 124 - self._console_address = None 125 125 - self._console_socket = None 126 126 - 127 127 - # just in case logging wasn't configured by the main script: 128 128 - logging.basicConfig() 129 129 - 130 130 - def __enter__(self): 131 131 - return self 132 132 - 133 133 - def __exit__(self, exc_type, exc_val, exc_tb): 134 134 - self.shutdown() 135 135 - return False 136 136 - 137 137 - # This can be used to add an unused monitor instance. 138 138 - def add_monitor_null(self): 139 139 - self._args.append('-monitor') 140 140 - self._args.append('null') 141 141 - 142 142 - def add_fd(self, fd, fdset, opaque, opts=''): 143 143 - """ 144 144 - Pass a file descriptor to the VM 145 145 - """ 146 146 - options = ['fd=%d' % fd, 147 147 - 'set=%d' % fdset, 148 148 - 'opaque=%s' % opaque] 149 149 - if opts: 150 150 - options.append(opts) 151 151 - 152 152 - # This did not exist before 3.4, but since then it is 153 153 - # mandatory for our purpose 154 154 - if hasattr(os, 'set_inheritable'): 155 155 - os.set_inheritable(fd, True) 156 156 - 157 157 - self._args.append('-add-fd') 158 158 - self._args.append(','.join(options)) 159 159 - return self 160 160 - 161 161 - # Exactly one of fd and file_path must be given. 162 162 - # (If it is file_path, the helper will open that file and pass its 163 163 - # own fd) 164 164 - def send_fd_scm(self, fd=None, file_path=None): 165 165 - # In iotest.py, the qmp should always use unix socket. 166 166 - assert self._qmp.is_scm_available() 167 167 - if self._socket_scm_helper is None: 168 168 - raise QEMUMachineError("No path to socket_scm_helper set") 169 169 - if not os.path.exists(self._socket_scm_helper): 170 170 - raise QEMUMachineError("%s does not exist" % 171 171 - self._socket_scm_helper) 172 172 - 173 173 - # This did not exist before 3.4, but since then it is 174 174 - # mandatory for our purpose 175 175 - if hasattr(os, 'set_inheritable'): 176 176 - os.set_inheritable(self._qmp.get_sock_fd(), True) 177 177 - if fd is not None: 178 178 - os.set_inheritable(fd, True) 179 179 - 180 180 - fd_param = ["%s" % self._socket_scm_helper, 181 181 - "%d" % self._qmp.get_sock_fd()] 182 182 - 183 183 - if file_path is not None: 184 184 - assert fd is None 185 185 - fd_param.append(file_path) 186 186 - else: 187 187 - assert fd is not None 188 188 - fd_param.append(str(fd)) 189 189 - 190 190 - devnull = open(os.path.devnull, 'rb') 191 191 - proc = subprocess.Popen(fd_param, stdin=devnull, stdout=subprocess.PIPE, 192 192 - stderr=subprocess.STDOUT, close_fds=False) 193 193 - output = proc.communicate()[0] 194 194 - if output: 195 195 - LOG.debug(output) 196 196 - 197 197 - return proc.returncode 198 198 - 199 199 - @staticmethod 200 200 - def _remove_if_exists(path): 201 201 - """ 202 202 - Remove file object at path if it exists 203 203 - """ 204 204 - try: 205 205 - os.remove(path) 206 206 - except OSError as exception: 207 207 - if exception.errno == errno.ENOENT: 208 208 - return 209 209 - raise 210 210 - 211 211 - def is_running(self): 212 212 - return self._popen is not None and self._popen.poll() is None 213 213 - 214 214 - def exitcode(self): 215 215 - if self._popen is None: 216 216 - return None 217 217 - return self._popen.poll() 218 218 - 219 219 - def get_pid(self): 220 220 - if not self.is_running(): 221 221 - return None 222 222 - return self._popen.pid 223 223 - 224 224 - def _load_io_log(self): 225 225 - if self._qemu_log_path is not None: 226 226 - with open(self._qemu_log_path, "r") as iolog: 227 227 - self._iolog = iolog.read() 228 228 - 229 229 - def _base_args(self): 230 230 - if isinstance(self._monitor_address, tuple): 231 231 - moncdev = "socket,id=mon,host=%s,port=%s" % ( 232 232 - self._monitor_address[0], 233 233 - self._monitor_address[1]) 234 234 - else: 235 235 - moncdev = 'socket,id=mon,path=%s' % self._vm_monitor 236 236 - args = ['-chardev', moncdev, 237 237 - '-mon', 'chardev=mon,mode=control', 238 238 - '-display', 'none', '-vga', 'none'] 239 239 - if self._machine is not None: 240 240 - args.extend(['-machine', self._machine]) 241 241 - if self._console_set: 242 242 - self._console_address = os.path.join(self._temp_dir, 243 243 - self._name + "-console.sock") 244 244 - chardev = ('socket,id=console,path=%s,server,nowait' % 245 245 - self._console_address) 246 246 - args.extend(['-chardev', chardev]) 247 247 - if self._console_device_type is None: 248 248 - args.extend(['-serial', 'chardev:console']) 249 249 - else: 250 250 - device = '%s,chardev=console' % self._console_device_type 251 251 - args.extend(['-device', device]) 252 252 - return args 253 253 - 254 254 - def _pre_launch(self): 255 255 - self._temp_dir = tempfile.mkdtemp(dir=self._test_dir) 256 256 - if self._monitor_address is not None: 257 257 - self._vm_monitor = self._monitor_address 258 258 - else: 259 259 - self._vm_monitor = os.path.join(self._temp_dir, 260 260 - self._name + "-monitor.sock") 261 261 - self._qemu_log_path = os.path.join(self._temp_dir, self._name + ".log") 262 262 - self._qemu_log_file = open(self._qemu_log_path, 'wb') 263 263 - 264 264 - self._qmp = qmp.QEMUMonitorProtocol(self._vm_monitor, 265 265 - server=True) 266 266 - 267 267 - def _post_launch(self): 268 268 - self._qmp.accept() 269 269 - 270 270 - def _post_shutdown(self): 271 271 - if self._qemu_log_file is not None: 272 272 - self._qemu_log_file.close() 273 273 - self._qemu_log_file = None 274 274 - 275 275 - self._qemu_log_path = None 276 276 - 277 277 - if self._console_socket is not None: 278 278 - self._console_socket.close() 279 279 - self._console_socket = None 280 280 - 281 281 - if self._temp_dir is not None: 282 282 - shutil.rmtree(self._temp_dir) 283 283 - self._temp_dir = None 284 284 - 285 285 - def launch(self): 286 286 - """ 287 287 - Launch the VM and make sure we cleanup and expose the 288 288 - command line/output in case of exception 289 289 - """ 290 290 - 291 291 - if self._launched: 292 292 - raise QEMUMachineError('VM already launched') 293 293 - 294 294 - self._iolog = None 295 295 - self._qemu_full_args = None 296 296 - try: 297 297 - self._launch() 298 298 - self._launched = True 299 299 - except: 300 300 - self.shutdown() 301 301 - 302 302 - LOG.debug('Error launching VM') 303 303 - if self._qemu_full_args: 304 304 - LOG.debug('Command: %r', ' '.join(self._qemu_full_args)) 305 305 - if self._iolog: 306 306 - LOG.debug('Output: %r', self._iolog) 307 307 - raise 308 308 - 309 309 - def _launch(self): 310 310 - """ 311 311 - Launch the VM and establish a QMP connection 312 312 - """ 313 313 - devnull = open(os.path.devnull, 'rb') 314 314 - self._pre_launch() 315 315 - self._qemu_full_args = (self._wrapper + [self._binary] + 316 316 - self._base_args() + self._args) 317 317 - LOG.debug('VM launch command: %r', ' '.join(self._qemu_full_args)) 318 318 - self._popen = subprocess.Popen(self._qemu_full_args, 319 319 - stdin=devnull, 320 320 - stdout=self._qemu_log_file, 321 321 - stderr=subprocess.STDOUT, 322 322 - shell=False, 323 323 - close_fds=False) 324 324 - self._post_launch() 325 325 - 326 326 - def wait(self): 327 327 - """ 328 328 - Wait for the VM to power off 329 329 - """ 330 330 - self._popen.wait() 331 331 - self._qmp.close() 332 332 - self._load_io_log() 333 333 - self._post_shutdown() 334 334 - 335 335 - def shutdown(self): 336 336 - """ 337 337 - Terminate the VM and clean up 338 338 - """ 339 339 - if self.is_running(): 340 340 - try: 341 341 - self._qmp.cmd('quit') 342 342 - self._qmp.close() 343 343 - except: 344 344 - self._popen.kill() 345 345 - self._popen.wait() 346 346 - 347 347 - self._load_io_log() 348 348 - self._post_shutdown() 349 349 - 350 350 - exitcode = self.exitcode() 351 351 - if exitcode is not None and exitcode < 0: 352 352 - msg = 'qemu received signal %i: %s' 353 353 - if self._qemu_full_args: 354 354 - command = ' '.join(self._qemu_full_args) 355 355 - else: 356 356 - command = '' 357 357 - LOG.warn(msg, -exitcode, command) 358 358 - 359 359 - self._launched = False 360 360 - 361 361 - def qmp(self, cmd, conv_keys=True, **args): 362 362 - """ 363 363 - Invoke a QMP command and return the response dict 364 364 - """ 365 365 - qmp_args = dict() 366 366 - for key, value in args.items(): 367 367 - if conv_keys: 368 368 - qmp_args[key.replace('_', '-')] = value 369 369 - else: 370 370 - qmp_args[key] = value 371 371 - 372 372 - return self._qmp.cmd(cmd, args=qmp_args) 373 373 - 374 374 - def command(self, cmd, conv_keys=True, **args): 375 375 - """ 376 376 - Invoke a QMP command. 377 377 - On success return the response dict. 378 378 - On failure raise an exception. 379 379 - """ 380 380 - reply = self.qmp(cmd, conv_keys, **args) 381 381 - if reply is None: 382 382 - raise qmp.QMPError("Monitor is closed") 383 383 - if "error" in reply: 384 384 - raise MonitorResponseError(reply) 385 385 - return reply["return"] 386 386 - 387 387 - def get_qmp_event(self, wait=False): 388 388 - """ 389 389 - Poll for one queued QMP events and return it 390 390 - """ 391 391 - if len(self._events) > 0: 392 392 - return self._events.pop(0) 393 393 - return self._qmp.pull_event(wait=wait) 394 394 - 395 395 - def get_qmp_events(self, wait=False): 396 396 - """ 397 397 - Poll for queued QMP events and return a list of dicts 398 398 - """ 399 399 - events = self._qmp.get_events(wait=wait) 400 400 - events.extend(self._events) 401 401 - del self._events[:] 402 402 - self._qmp.clear_events() 403 403 - return events 404 404 - 405 405 - @staticmethod 406 406 - def event_match(event, match=None): 407 407 - """ 408 408 - Check if an event matches optional match criteria. 409 409 - 410 410 - The match criteria takes the form of a matching subdict. The event is 411 411 - checked to be a superset of the subdict, recursively, with matching 412 412 - values whenever the subdict values are not None. 413 413 - 414 414 - This has a limitation that you cannot explicitly check for None values. 415 415 - 416 416 - Examples, with the subdict queries on the left: 417 417 - - None matches any object. 418 418 - - {"foo": None} matches {"foo": {"bar": 1}} 419 419 - - {"foo": None} matches {"foo": 5} 420 420 - - {"foo": {"abc": None}} does not match {"foo": {"bar": 1}} 421 421 - - {"foo": {"rab": 2}} matches {"foo": {"bar": 1, "rab": 2}} 422 422 - """ 423 423 - if match is None: 424 424 - return True 425 425 - 426 426 - try: 427 427 - for key in match: 428 428 - if key in event: 429 429 - if not QEMUMachine.event_match(event[key], match[key]): 430 430 - return False 431 431 - else: 432 432 - return False 433 433 - return True 434 434 - except TypeError: 435 435 - # either match or event wasn't iterable (not a dict) 436 436 - return match == event 437 437 - 438 438 - def event_wait(self, name, timeout=60.0, match=None): 439 439 - """ 440 440 - event_wait waits for and returns a named event from QMP with a timeout. 441 441 - 442 442 - name: The event to wait for. 443 443 - timeout: QEMUMonitorProtocol.pull_event timeout parameter. 444 444 - match: Optional match criteria. See event_match for details. 445 445 - """ 446 446 - return self.events_wait([(name, match)], timeout) 447 447 - 448 448 - def events_wait(self, events, timeout=60.0): 449 449 - """ 450 450 - events_wait waits for and returns a named event from QMP with a timeout. 451 451 - 452 452 - events: a sequence of (name, match_criteria) tuples. 453 453 - The match criteria are optional and may be None. 454 454 - See event_match for details. 455 455 - timeout: QEMUMonitorProtocol.pull_event timeout parameter. 456 456 - """ 457 457 - def _match(event): 458 458 - for name, match in events: 459 459 - if (event['event'] == name and 460 460 - self.event_match(event, match)): 461 461 - return True 462 462 - return False 463 463 - 464 464 - # Search cached events 465 465 - for event in self._events: 466 466 - if _match(event): 467 467 - self._events.remove(event) 468 468 - return event 469 469 - 470 470 - # Poll for new events 471 471 - while True: 472 472 - event = self._qmp.pull_event(wait=timeout) 473 473 - if _match(event): 474 474 - return event 475 475 - self._events.append(event) 476 476 - 477 477 - return None 478 478 - 479 479 - def get_log(self): 480 480 - """ 481 481 - After self.shutdown or failed qemu execution, this returns the output 482 482 - of the qemu process. 483 483 - """ 484 484 - return self._iolog 485 485 - 486 486 - def add_args(self, *args): 487 487 - """ 488 488 - Adds to the list of extra arguments to be given to the QEMU binary 489 489 - """ 490 490 - self._args.extend(args) 491 491 - 492 492 - def set_machine(self, machine_type): 493 493 - """ 494 494 - Sets the machine type 495 495 - 496 496 - If set, the machine type will be added to the base arguments 497 497 - of the resulting QEMU command line. 498 498 - """ 499 499 - self._machine = machine_type 500 500 - 501 501 - def set_console(self, device_type=None): 502 502 - """ 503 503 - Sets the device type for a console device 504 504 - 505 505 - If set, the console device and a backing character device will 506 506 - be added to the base arguments of the resulting QEMU command 507 507 - line. 508 508 - 509 509 - This is a convenience method that will either use the provided 510 510 - device type, or default to a "-serial chardev:console" command 511 511 - line argument. 512 512 - 513 513 - The actual setting of command line arguments will be be done at 514 514 - machine launch time, as it depends on the temporary directory 515 515 - to be created. 516 516 - 517 517 - @param device_type: the device type, such as "isa-serial". If 518 518 - None is given (the default value) a "-serial 519 519 - chardev:console" command line argument will 520 520 - be used instead, resorting to the machine's 521 521 - default device type. 522 522 - """ 523 523 - self._console_set = True 524 524 - self._console_device_type = device_type 525 525 - 526 526 - @property 527 527 - def console_socket(self): 528 528 - """ 529 529 - Returns a socket connected to the console 530 530 - """ 531 531 - if self._console_socket is None: 532 532 - self._console_socket = socket.socket(socket.AF_UNIX, 533 533 - socket.SOCK_STREAM) 534 534 - self._console_socket.connect(self._console_address) 535 535 - return self._console_socket

+520

python/qemu/machine.py

··· 1 1 + # QEMU library 2 2 + # 3 3 + # Copyright (C) 2015-2016 Red Hat Inc. 4 4 + # Copyright (C) 2012 IBM Corp. 5 5 + # 6 6 + # Authors: 7 7 + # Fam Zheng <famz@redhat.com> 8 8 + # 9 9 + # This work is licensed under the terms of the GNU GPL, version 2. See 10 10 + # the COPYING file in the top-level directory. 11 11 + # 12 12 + # Based on qmp.py. 13 13 + # 14 14 + 15 15 + import errno 16 16 + import logging 17 17 + import os 18 18 + import subprocess 19 19 + import re 20 20 + import shutil 21 21 + import socket 22 22 + import tempfile 23 23 + 24 24 + from . import qmp 25 25 + 26 26 + LOG = logging.getLogger(__name__) 27 27 + 28 28 + class QEMUMachineError(Exception): 29 29 + """ 30 30 + Exception called when an error in QEMUMachine happens. 31 31 + """ 32 32 + 33 33 + 34 34 + class QEMUMachineAddDeviceError(QEMUMachineError): 35 35 + """ 36 36 + Exception raised when a request to add a device can not be fulfilled 37 37 + 38 38 + The failures are caused by limitations, lack of information or conflicting 39 39 + requests on the QEMUMachine methods. This exception does not represent 40 40 + failures reported by the QEMU binary itself. 41 41 + """ 42 42 + 43 43 + 44 44 + class MonitorResponseError(qmp.QMPError): 45 45 + """ 46 46 + Represents erroneous QMP monitor reply 47 47 + """ 48 48 + def __init__(self, reply): 49 49 + try: 50 50 + desc = reply["error"]["desc"] 51 51 + except KeyError: 52 52 + desc = reply 53 53 + super(MonitorResponseError, self).__init__(desc) 54 54 + self.reply = reply 55 55 + 56 56 + 57 57 + class QEMUMachine(object): 58 58 + """ 59 59 + A QEMU VM 60 60 + 61 61 + Use this object as a context manager to ensure the QEMU process terminates:: 62 62 + 63 63 + with VM(binary) as vm: 64 64 + ... 65 65 + # vm is guaranteed to be shut down here 66 66 + """ 67 67 + 68 68 + def __init__(self, binary, args=None, wrapper=None, name=None, 69 69 + test_dir="/var/tmp", monitor_address=None, 70 70 + socket_scm_helper=None): 71 71 + ''' 72 72 + Initialize a QEMUMachine 73 73 + 74 74 + @param binary: path to the qemu binary 75 75 + @param args: list of extra arguments 76 76 + @param wrapper: list of arguments used as prefix to qemu binary 77 77 + @param name: prefix for socket and log file names (default: qemu-PID) 78 78 + @param test_dir: where to create socket and log file 79 79 + @param monitor_address: address for QMP monitor 80 80 + @param socket_scm_helper: helper program, required for send_fd_scm() 81 81 + @note: Qemu process is not started until launch() is used. 82 82 + ''' 83 83 + if args is None: 84 84 + args = [] 85 85 + if wrapper is None: 86 86 + wrapper = [] 87 87 + if name is None: 88 88 + name = "qemu-%d" % os.getpid() 89 89 + self._name = name 90 90 + self._monitor_address = monitor_address 91 91 + self._vm_monitor = None 92 92 + self._qemu_log_path = None 93 93 + self._qemu_log_file = None 94 94 + self._popen = None 95 95 + self._binary = binary 96 96 + self._args = list(args) # Force copy args in case we modify them 97 97 + self._wrapper = wrapper 98 98 + self._events = [] 99 99 + self._iolog = None 100 100 + self._socket_scm_helper = socket_scm_helper 101 101 + self._qmp = None 102 102 + self._qemu_full_args = None 103 103 + self._test_dir = test_dir 104 104 + self._temp_dir = None 105 105 + self._launched = False 106 106 + self._machine = None 107 107 + self._console_set = False 108 108 + self._console_device_type = None 109 109 + self._console_address = None 110 110 + self._console_socket = None 111 111 + 112 112 + # just in case logging wasn't configured by the main script: 113 113 + logging.basicConfig() 114 114 + 115 115 + def __enter__(self): 116 116 + return self 117 117 + 118 118 + def __exit__(self, exc_type, exc_val, exc_tb): 119 119 + self.shutdown() 120 120 + return False 121 121 + 122 122 + # This can be used to add an unused monitor instance. 123 123 + def add_monitor_null(self): 124 124 + self._args.append('-monitor') 125 125 + self._args.append('null') 126 126 + 127 127 + def add_fd(self, fd, fdset, opaque, opts=''): 128 128 + """ 129 129 + Pass a file descriptor to the VM 130 130 + """ 131 131 + options = ['fd=%d' % fd, 132 132 + 'set=%d' % fdset, 133 133 + 'opaque=%s' % opaque] 134 134 + if opts: 135 135 + options.append(opts) 136 136 + 137 137 + # This did not exist before 3.4, but since then it is 138 138 + # mandatory for our purpose 139 139 + if hasattr(os, 'set_inheritable'): 140 140 + os.set_inheritable(fd, True) 141 141 + 142 142 + self._args.append('-add-fd') 143 143 + self._args.append(','.join(options)) 144 144 + return self 145 145 + 146 146 + # Exactly one of fd and file_path must be given. 147 147 + # (If it is file_path, the helper will open that file and pass its 148 148 + # own fd) 149 149 + def send_fd_scm(self, fd=None, file_path=None): 150 150 + # In iotest.py, the qmp should always use unix socket. 151 151 + assert self._qmp.is_scm_available() 152 152 + if self._socket_scm_helper is None: 153 153 + raise QEMUMachineError("No path to socket_scm_helper set") 154 154 + if not os.path.exists(self._socket_scm_helper): 155 155 + raise QEMUMachineError("%s does not exist" % 156 156 + self._socket_scm_helper) 157 157 + 158 158 + # This did not exist before 3.4, but since then it is 159 159 + # mandatory for our purpose 160 160 + if hasattr(os, 'set_inheritable'): 161 161 + os.set_inheritable(self._qmp.get_sock_fd(), True) 162 162 + if fd is not None: 163 163 + os.set_inheritable(fd, True) 164 164 + 165 165 + fd_param = ["%s" % self._socket_scm_helper, 166 166 + "%d" % self._qmp.get_sock_fd()] 167 167 + 168 168 + if file_path is not None: 169 169 + assert fd is None 170 170 + fd_param.append(file_path) 171 171 + else: 172 172 + assert fd is not None 173 173 + fd_param.append(str(fd)) 174 174 + 175 175 + devnull = open(os.path.devnull, 'rb') 176 176 + proc = subprocess.Popen(fd_param, stdin=devnull, stdout=subprocess.PIPE, 177 177 + stderr=subprocess.STDOUT, close_fds=False) 178 178 + output = proc.communicate()[0] 179 179 + if output: 180 180 + LOG.debug(output) 181 181 + 182 182 + return proc.returncode 183 183 + 184 184 + @staticmethod 185 185 + def _remove_if_exists(path): 186 186 + """ 187 187 + Remove file object at path if it exists 188 188 + """ 189 189 + try: 190 190 + os.remove(path) 191 191 + except OSError as exception: 192 192 + if exception.errno == errno.ENOENT: 193 193 + return 194 194 + raise 195 195 + 196 196 + def is_running(self): 197 197 + return self._popen is not None and self._popen.poll() is None 198 198 + 199 199 + def exitcode(self): 200 200 + if self._popen is None: 201 201 + return None 202 202 + return self._popen.poll() 203 203 + 204 204 + def get_pid(self): 205 205 + if not self.is_running(): 206 206 + return None 207 207 + return self._popen.pid 208 208 + 209 209 + def _load_io_log(self): 210 210 + if self._qemu_log_path is not None: 211 211 + with open(self._qemu_log_path, "r") as iolog: 212 212 + self._iolog = iolog.read() 213 213 + 214 214 + def _base_args(self): 215 215 + if isinstance(self._monitor_address, tuple): 216 216 + moncdev = "socket,id=mon,host=%s,port=%s" % ( 217 217 + self._monitor_address[0], 218 218 + self._monitor_address[1]) 219 219 + else: 220 220 + moncdev = 'socket,id=mon,path=%s' % self._vm_monitor 221 221 + args = ['-chardev', moncdev, 222 222 + '-mon', 'chardev=mon,mode=control', 223 223 + '-display', 'none', '-vga', 'none'] 224 224 + if self._machine is not None: 225 225 + args.extend(['-machine', self._machine]) 226 226 + if self._console_set: 227 227 + self._console_address = os.path.join(self._temp_dir, 228 228 + self._name + "-console.sock") 229 229 + chardev = ('socket,id=console,path=%s,server,nowait' % 230 230 + self._console_address) 231 231 + args.extend(['-chardev', chardev]) 232 232 + if self._console_device_type is None: 233 233 + args.extend(['-serial', 'chardev:console']) 234 234 + else: 235 235 + device = '%s,chardev=console' % self._console_device_type 236 236 + args.extend(['-device', device]) 237 237 + return args 238 238 + 239 239 + def _pre_launch(self): 240 240 + self._temp_dir = tempfile.mkdtemp(dir=self._test_dir) 241 241 + if self._monitor_address is not None: 242 242 + self._vm_monitor = self._monitor_address 243 243 + else: 244 244 + self._vm_monitor = os.path.join(self._temp_dir, 245 245 + self._name + "-monitor.sock") 246 246 + self._qemu_log_path = os.path.join(self._temp_dir, self._name + ".log") 247 247 + self._qemu_log_file = open(self._qemu_log_path, 'wb') 248 248 + 249 249 + self._qmp = qmp.QEMUMonitorProtocol(self._vm_monitor, 250 250 + server=True) 251 251 + 252 252 + def _post_launch(self): 253 253 + self._qmp.accept() 254 254 + 255 255 + def _post_shutdown(self): 256 256 + if self._qemu_log_file is not None: 257 257 + self._qemu_log_file.close() 258 258 + self._qemu_log_file = None 259 259 + 260 260 + self._qemu_log_path = None 261 261 + 262 262 + if self._console_socket is not None: 263 263 + self._console_socket.close() 264 264 + self._console_socket = None 265 265 + 266 266 + if self._temp_dir is not None: 267 267 + shutil.rmtree(self._temp_dir) 268 268 + self._temp_dir = None 269 269 + 270 270 + def launch(self): 271 271 + """ 272 272 + Launch the VM and make sure we cleanup and expose the 273 273 + command line/output in case of exception 274 274 + """ 275 275 + 276 276 + if self._launched: 277 277 + raise QEMUMachineError('VM already launched') 278 278 + 279 279 + self._iolog = None 280 280 + self._qemu_full_args = None 281 281 + try: 282 282 + self._launch() 283 283 + self._launched = True 284 284 + except: 285 285 + self.shutdown() 286 286 + 287 287 + LOG.debug('Error launching VM') 288 288 + if self._qemu_full_args: 289 289 + LOG.debug('Command: %r', ' '.join(self._qemu_full_args)) 290 290 + if self._iolog: 291 291 + LOG.debug('Output: %r', self._iolog) 292 292 + raise 293 293 + 294 294 + def _launch(self): 295 295 + """ 296 296 + Launch the VM and establish a QMP connection 297 297 + """ 298 298 + devnull = open(os.path.devnull, 'rb') 299 299 + self._pre_launch() 300 300 + self._qemu_full_args = (self._wrapper + [self._binary] + 301 301 + self._base_args() + self._args) 302 302 + LOG.debug('VM launch command: %r', ' '.join(self._qemu_full_args)) 303 303 + self._popen = subprocess.Popen(self._qemu_full_args, 304 304 + stdin=devnull, 305 305 + stdout=self._qemu_log_file, 306 306 + stderr=subprocess.STDOUT, 307 307 + shell=False, 308 308 + close_fds=False) 309 309 + self._post_launch() 310 310 + 311 311 + def wait(self): 312 312 + """ 313 313 + Wait for the VM to power off 314 314 + """ 315 315 + self._popen.wait() 316 316 + self._qmp.close() 317 317 + self._load_io_log() 318 318 + self._post_shutdown() 319 319 + 320 320 + def shutdown(self): 321 321 + """ 322 322 + Terminate the VM and clean up 323 323 + """ 324 324 + if self.is_running(): 325 325 + try: 326 326 + self._qmp.cmd('quit') 327 327 + self._qmp.close() 328 328 + except: 329 329 + self._popen.kill() 330 330 + self._popen.wait() 331 331 + 332 332 + self._load_io_log() 333 333 + self._post_shutdown() 334 334 + 335 335 + exitcode = self.exitcode() 336 336 + if exitcode is not None and exitcode < 0: 337 337 + msg = 'qemu received signal %i: %s' 338 338 + if self._qemu_full_args: 339 339 + command = ' '.join(self._qemu_full_args) 340 340 + else: 341 341 + command = '' 342 342 + LOG.warn(msg, -exitcode, command) 343 343 + 344 344 + self._launched = False 345 345 + 346 346 + def qmp(self, cmd, conv_keys=True, **args): 347 347 + """ 348 348 + Invoke a QMP command and return the response dict 349 349 + """ 350 350 + qmp_args = dict() 351 351 + for key, value in args.items(): 352 352 + if conv_keys: 353 353 + qmp_args[key.replace('_', '-')] = value 354 354 + else: 355 355 + qmp_args[key] = value 356 356 + 357 357 + return self._qmp.cmd(cmd, args=qmp_args) 358 358 + 359 359 + def command(self, cmd, conv_keys=True, **args): 360 360 + """ 361 361 + Invoke a QMP command. 362 362 + On success return the response dict. 363 363 + On failure raise an exception. 364 364 + """ 365 365 + reply = self.qmp(cmd, conv_keys, **args) 366 366 + if reply is None: 367 367 + raise qmp.QMPError("Monitor is closed") 368 368 + if "error" in reply: 369 369 + raise MonitorResponseError(reply) 370 370 + return reply["return"] 371 371 + 372 372 + def get_qmp_event(self, wait=False): 373 373 + """ 374 374 + Poll for one queued QMP events and return it 375 375 + """ 376 376 + if len(self._events) > 0: 377 377 + return self._events.pop(0) 378 378 + return self._qmp.pull_event(wait=wait) 379 379 + 380 380 + def get_qmp_events(self, wait=False): 381 381 + """ 382 382 + Poll for queued QMP events and return a list of dicts 383 383 + """ 384 384 + events = self._qmp.get_events(wait=wait) 385 385 + events.extend(self._events) 386 386 + del self._events[:] 387 387 + self._qmp.clear_events() 388 388 + return events 389 389 + 390 390 + @staticmethod 391 391 + def event_match(event, match=None): 392 392 + """ 393 393 + Check if an event matches optional match criteria. 394 394 + 395 395 + The match criteria takes the form of a matching subdict. The event is 396 396 + checked to be a superset of the subdict, recursively, with matching 397 397 + values whenever the subdict values are not None. 398 398 + 399 399 + This has a limitation that you cannot explicitly check for None values. 400 400 + 401 401 + Examples, with the subdict queries on the left: 402 402 + - None matches any object. 403 403 + - {"foo": None} matches {"foo": {"bar": 1}} 404 404 + - {"foo": None} matches {"foo": 5} 405 405 + - {"foo": {"abc": None}} does not match {"foo": {"bar": 1}} 406 406 + - {"foo": {"rab": 2}} matches {"foo": {"bar": 1, "rab": 2}} 407 407 + """ 408 408 + if match is None: 409 409 + return True 410 410 + 411 411 + try: 412 412 + for key in match: 413 413 + if key in event: 414 414 + if not QEMUMachine.event_match(event[key], match[key]): 415 415 + return False 416 416 + else: 417 417 + return False 418 418 + return True 419 419 + except TypeError: 420 420 + # either match or event wasn't iterable (not a dict) 421 421 + return match == event 422 422 + 423 423 + def event_wait(self, name, timeout=60.0, match=None): 424 424 + """ 425 425 + event_wait waits for and returns a named event from QMP with a timeout. 426 426 + 427 427 + name: The event to wait for. 428 428 + timeout: QEMUMonitorProtocol.pull_event timeout parameter. 429 429 + match: Optional match criteria. See event_match for details. 430 430 + """ 431 431 + return self.events_wait([(name, match)], timeout) 432 432 + 433 433 + def events_wait(self, events, timeout=60.0): 434 434 + """ 435 435 + events_wait waits for and returns a named event from QMP with a timeout. 436 436 + 437 437 + events: a sequence of (name, match_criteria) tuples. 438 438 + The match criteria are optional and may be None. 439 439 + See event_match for details. 440 440 + timeout: QEMUMonitorProtocol.pull_event timeout parameter. 441 441 + """ 442 442 + def _match(event): 443 443 + for name, match in events: 444 444 + if (event['event'] == name and 445 445 + self.event_match(event, match)): 446 446 + return True 447 447 + return False 448 448 + 449 449 + # Search cached events 450 450 + for event in self._events: 451 451 + if _match(event): 452 452 + self._events.remove(event) 453 453 + return event 454 454 + 455 455 + # Poll for new events 456 456 + while True: 457 457 + event = self._qmp.pull_event(wait=timeout) 458 458 + if _match(event): 459 459 + return event 460 460 + self._events.append(event) 461 461 + 462 462 + return None 463 463 + 464 464 + def get_log(self): 465 465 + """ 466 466 + After self.shutdown or failed qemu execution, this returns the output 467 467 + of the qemu process. 468 468 + """ 469 469 + return self._iolog 470 470 + 471 471 + def add_args(self, *args): 472 472 + """ 473 473 + Adds to the list of extra arguments to be given to the QEMU binary 474 474 + """ 475 475 + self._args.extend(args) 476 476 + 477 477 + def set_machine(self, machine_type): 478 478 + """ 479 479 + Sets the machine type 480 480 + 481 481 + If set, the machine type will be added to the base arguments 482 482 + of the resulting QEMU command line. 483 483 + """ 484 484 + self._machine = machine_type 485 485 + 486 486 + def set_console(self, device_type=None): 487 487 + """ 488 488 + Sets the device type for a console device 489 489 + 490 490 + If set, the console device and a backing character device will 491 491 + be added to the base arguments of the resulting QEMU command 492 492 + line. 493 493 + 494 494 + This is a convenience method that will either use the provided 495 495 + device type, or default to a "-serial chardev:console" command 496 496 + line argument. 497 497 + 498 498 + The actual setting of command line arguments will be be done at 499 499 + machine launch time, as it depends on the temporary directory 500 500 + to be created. 501 501 + 502 502 + @param device_type: the device type, such as "isa-serial". If 503 503 + None is given (the default value) a "-serial 504 504 + chardev:console" command line argument will 505 505 + be used instead, resorting to the machine's 506 506 + default device type. 507 507 + """ 508 508 + self._console_set = True 509 509 + self._console_device_type = device_type 510 510 + 511 511 + @property 512 512 + def console_socket(self): 513 513 + """ 514 514 + Returns a socket connected to the console 515 515 + """ 516 516 + if self._console_socket is None: 517 517 + self._console_socket = socket.socket(socket.AF_UNIX, 518 518 + socket.SOCK_STREAM) 519 519 + self._console_socket.connect(self._console_address) 520 520 + return self._console_socket

+1 -1

python/qemu/qtest.py

··· 14 14 import socket 15 15 import os 16 16 17 17 - from . import QEMUMachine 17 17 + from .machine import QEMUMachine 18 18 19 19 20 20 class QEMUQtestProtocol(object):

+1 -1

scripts/device-crash-test

··· 36 36 from itertools import chain 37 37 38 38 sys.path.append(os.path.join(os.path.dirname(__file__), '..', 'python')) 39 39 - from qemu import QEMUMachine 39 39 + from qemu.machine import QEMUMachine 40 40 41 41 logger = logging.getLogger('device-crash-test') 42 42 dbg = logger.debug

+1 -1

scripts/render_block_graph.py

··· 25 25 from graphviz import Digraph 26 26 27 27 sys.path.append(os.path.join(os.path.dirname(__file__), '..', 'python')) 28 28 - from qemu import MonitorResponseError 28 28 + from qemu.machine import MonitorResponseError 29 29 30 30 31 31 def perm(arr):

+1 -1

tests/acceptance/avocado_qemu/__init__.py

··· 17 17 SRC_ROOT_DIR = os.path.join(os.path.dirname(__file__), '..', '..', '..') 18 18 sys.path.append(os.path.join(SRC_ROOT_DIR, 'python')) 19 19 20 20 - from qemu import QEMUMachine 20 20 + from qemu.machine import QEMUMachine 21 21 22 22 def is_readable_executable_file(path): 23 23 return os.path.isfile(path) and os.access(path, os.R_OK | os.X_OK)

+1 -1

tests/acceptance/virtio_version.py

··· 12 12 import os 13 13 14 14 sys.path.append(os.path.join(os.path.dirname(__file__), '..', '..', 'python')) 15 15 - from qemu import QEMUMachine 15 15 + from qemu.machine import QEMUMachine 16 16 from avocado_qemu import Test 17 17 18 18 # Virtio Device IDs:

+11 -11

tests/migration/guestperf/engine.py

··· 30 30 31 31 sys.path.append(os.path.join(os.path.dirname(__file__), 32 32 '..', '..', '..', 'python')) 33 33 - import qemu 33 33 + from qemu.machine import QEMUMachine 34 34 35 35 36 36 class Engine(object): ··· 386 386 dstmonaddr = "/var/tmp/qemu-dst-%d-monitor.sock" % os.getpid() 387 387 srcmonaddr = "/var/tmp/qemu-src-%d-monitor.sock" % os.getpid() 388 388 389 389 - src = qemu.QEMUMachine(self._binary, 390 390 - args=self._get_src_args(hardware), 391 391 - wrapper=self._get_src_wrapper(hardware), 392 392 - name="qemu-src-%d" % os.getpid(), 393 393 - monitor_address=srcmonaddr) 389 389 + src = QEMUMachine(self._binary, 390 390 + args=self._get_src_args(hardware), 391 391 + wrapper=self._get_src_wrapper(hardware), 392 392 + name="qemu-src-%d" % os.getpid(), 393 393 + monitor_address=srcmonaddr) 394 394 395 395 - dst = qemu.QEMUMachine(self._binary, 396 396 - args=self._get_dst_args(hardware, uri), 397 397 - wrapper=self._get_dst_wrapper(hardware), 398 398 - name="qemu-dst-%d" % os.getpid(), 399 399 - monitor_address=dstmonaddr) 395 395 + dst = QEMUMachine(self._binary, 396 396 + args=self._get_dst_args(hardware, uri), 397 397 + wrapper=self._get_dst_wrapper(hardware), 398 398 + name="qemu-dst-%d" % os.getpid(), 399 399 + monitor_address=dstmonaddr) 400 400 401 401 try: 402 402 src.launch()

+1 -1

tests/qemu-iotests/235

··· 25 25 26 26 sys.path.append(os.path.join(os.path.dirname(__file__), '..', '..', 'python')) 27 27 28 28 - from qemu import QEMUMachine 28 28 + from qemu.machine import QEMUMachine 29 29 30 30 # Note: 31 31 # This test was added to check that mirror dead-lock was fixed (see previous

+2 -1

tests/vm/basevm.py

··· 18 18 import time 19 19 import datetime 20 20 sys.path.append(os.path.join(os.path.dirname(__file__), '..', '..', 'python')) 21 21 - from qemu import QEMUMachine, kvm_available 21 21 + from qemu import kvm_available 22 22 + from qemu.machine import QEMUMachine 22 23 import subprocess 23 24 import hashlib 24 25 import optparse