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