]>
Commit | Line | Data |
---|---|---|
66613974 DB |
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 | |
4738b0a8 | 16 | import logging |
66613974 | 17 | import os |
66613974 DB |
18 | import subprocess |
19 | import qmp.qmp | |
af99fa9f AP |
20 | import shutil |
21 | import tempfile | |
66613974 DB |
22 | |
23 | ||
4738b0a8 AP |
24 | LOG = logging.getLogger(__name__) |
25 | ||
26 | ||
27 | class QEMUMachineError(Exception): | |
28 | """ | |
29 | Exception called when an error in QEMUMachine happens. | |
30 | """ | |
31 | ||
32 | ||
a004e249 LD |
33 | class MonitorResponseError(qmp.qmp.QMPError): |
34 | ''' | |
35 | Represents erroneous QMP monitor reply | |
36 | ''' | |
37 | def __init__(self, reply): | |
38 | try: | |
39 | desc = reply["error"]["desc"] | |
40 | except KeyError: | |
41 | desc = reply | |
42 | super(MonitorResponseError, self).__init__(desc) | |
43 | self.reply = reply | |
44 | ||
45 | ||
66613974 | 46 | class QEMUMachine(object): |
d792bc38 SH |
47 | '''A QEMU VM |
48 | ||
49 | Use this object as a context manager to ensure the QEMU process terminates:: | |
50 | ||
51 | with VM(binary) as vm: | |
52 | ... | |
53 | # vm is guaranteed to be shut down here | |
54 | ''' | |
66613974 | 55 | |
2782fc51 | 56 | def __init__(self, binary, args=None, wrapper=None, name=None, |
2d853c70 | 57 | test_dir="/var/tmp", monitor_address=None, |
1a6d3757 | 58 | socket_scm_helper=None): |
2d853c70 LD |
59 | ''' |
60 | Initialize a QEMUMachine | |
61 | ||
62 | @param binary: path to the qemu binary | |
63 | @param args: list of extra arguments | |
64 | @param wrapper: list of arguments used as prefix to qemu binary | |
65 | @param name: prefix for socket and log file names (default: qemu-PID) | |
66 | @param test_dir: where to create socket and log file | |
67 | @param monitor_address: address for QMP monitor | |
68 | @param socket_scm_helper: helper program, required for send_fd_scm()" | |
2d853c70 LD |
69 | @note: Qemu process is not started until launch() is used. |
70 | ''' | |
2782fc51 LD |
71 | if args is None: |
72 | args = [] | |
73 | if wrapper is None: | |
74 | wrapper = [] | |
66613974 DB |
75 | if name is None: |
76 | name = "qemu-%d" % os.getpid() | |
af99fa9f | 77 | self._name = name |
66613974 | 78 | self._monitor_address = monitor_address |
af99fa9f AP |
79 | self._vm_monitor = None |
80 | self._qemu_log_path = None | |
81 | self._qemu_log_file = None | |
66613974 DB |
82 | self._popen = None |
83 | self._binary = binary | |
2d853c70 | 84 | self._args = list(args) # Force copy args in case we modify them |
66613974 DB |
85 | self._wrapper = wrapper |
86 | self._events = [] | |
87 | self._iolog = None | |
4c44b4a4 | 88 | self._socket_scm_helper = socket_scm_helper |
2d853c70 | 89 | self._qmp = None |
dab91d9a | 90 | self._qemu_full_args = None |
af99fa9f AP |
91 | self._test_dir = test_dir |
92 | self._temp_dir = None | |
66613974 | 93 | |
5810314e | 94 | # just in case logging wasn't configured by the main script: |
1a6d3757 | 95 | logging.basicConfig() |
5810314e | 96 | |
d792bc38 SH |
97 | def __enter__(self): |
98 | return self | |
99 | ||
100 | def __exit__(self, exc_type, exc_val, exc_tb): | |
101 | self.shutdown() | |
102 | return False | |
103 | ||
66613974 DB |
104 | # This can be used to add an unused monitor instance. |
105 | def add_monitor_telnet(self, ip, port): | |
106 | args = 'tcp:%s:%d,server,nowait,telnet' % (ip, port) | |
107 | self._args.append('-monitor') | |
108 | self._args.append(args) | |
109 | ||
110 | def add_fd(self, fd, fdset, opaque, opts=''): | |
111 | '''Pass a file descriptor to the VM''' | |
112 | options = ['fd=%d' % fd, | |
113 | 'set=%d' % fdset, | |
114 | 'opaque=%s' % opaque] | |
115 | if opts: | |
116 | options.append(opts) | |
117 | ||
118 | self._args.append('-add-fd') | |
119 | self._args.append(','.join(options)) | |
120 | return self | |
121 | ||
122 | def send_fd_scm(self, fd_file_path): | |
123 | # In iotest.py, the qmp should always use unix socket. | |
124 | assert self._qmp.is_scm_available() | |
4c44b4a4 | 125 | if self._socket_scm_helper is None: |
4738b0a8 | 126 | raise QEMUMachineError("No path to socket_scm_helper set") |
2d853c70 | 127 | if not os.path.exists(self._socket_scm_helper): |
4738b0a8 AP |
128 | raise QEMUMachineError("%s does not exist" % |
129 | self._socket_scm_helper) | |
4c44b4a4 | 130 | fd_param = ["%s" % self._socket_scm_helper, |
66613974 DB |
131 | "%d" % self._qmp.get_sock_fd(), |
132 | "%s" % fd_file_path] | |
63e0ba55 | 133 | devnull = open(os.path.devnull, 'rb') |
4738b0a8 AP |
134 | proc = subprocess.Popen(fd_param, stdin=devnull, stdout=subprocess.PIPE, |
135 | stderr=subprocess.STDOUT) | |
136 | output = proc.communicate()[0] | |
137 | if output: | |
138 | LOG.debug(output) | |
139 | ||
140 | return proc.returncode | |
66613974 DB |
141 | |
142 | @staticmethod | |
143 | def _remove_if_exists(path): | |
144 | '''Remove file object at path if it exists''' | |
145 | try: | |
146 | os.remove(path) | |
147 | except OSError as exception: | |
148 | if exception.errno == errno.ENOENT: | |
149 | return | |
150 | raise | |
151 | ||
37bbcd57 | 152 | def is_running(self): |
17589cae | 153 | return self._popen is not None and self._popen.poll() is None |
37bbcd57 | 154 | |
b2b8d986 EH |
155 | def exitcode(self): |
156 | if self._popen is None: | |
157 | return None | |
17589cae | 158 | return self._popen.poll() |
b2b8d986 | 159 | |
66613974 | 160 | def get_pid(self): |
37bbcd57 | 161 | if not self.is_running(): |
66613974 DB |
162 | return None |
163 | return self._popen.pid | |
164 | ||
165 | def _load_io_log(self): | |
04a963b4 AP |
166 | if self._qemu_log_path is not None: |
167 | with open(self._qemu_log_path, "r") as iolog: | |
168 | self._iolog = iolog.read() | |
66613974 DB |
169 | |
170 | def _base_args(self): | |
171 | if isinstance(self._monitor_address, tuple): | |
172 | moncdev = "socket,id=mon,host=%s,port=%s" % ( | |
173 | self._monitor_address[0], | |
174 | self._monitor_address[1]) | |
175 | else: | |
af99fa9f | 176 | moncdev = 'socket,id=mon,path=%s' % self._vm_monitor |
66613974 DB |
177 | return ['-chardev', moncdev, |
178 | '-mon', 'chardev=mon,mode=control', | |
179 | '-display', 'none', '-vga', 'none'] | |
180 | ||
181 | def _pre_launch(self): | |
af99fa9f AP |
182 | self._temp_dir = tempfile.mkdtemp(dir=self._test_dir) |
183 | if self._monitor_address is not None: | |
184 | self._vm_monitor = self._monitor_address | |
185 | else: | |
186 | self._vm_monitor = os.path.join(self._temp_dir, | |
187 | self._name + "-monitor.sock") | |
188 | self._qemu_log_path = os.path.join(self._temp_dir, self._name + ".log") | |
189 | self._qemu_log_file = open(self._qemu_log_path, 'wb') | |
190 | ||
191 | self._qmp = qmp.qmp.QEMUMonitorProtocol(self._vm_monitor, | |
09177654 | 192 | server=True) |
66613974 DB |
193 | |
194 | def _post_launch(self): | |
195 | self._qmp.accept() | |
196 | ||
197 | def _post_shutdown(self): | |
af99fa9f AP |
198 | if self._qemu_log_file is not None: |
199 | self._qemu_log_file.close() | |
200 | self._qemu_log_file = None | |
201 | ||
202 | self._qemu_log_path = None | |
203 | ||
204 | if self._temp_dir is not None: | |
205 | shutil.rmtree(self._temp_dir) | |
206 | self._temp_dir = None | |
66613974 DB |
207 | |
208 | def launch(self): | |
d301bccf AP |
209 | """ |
210 | Launch the VM and make sure we cleanup and expose the | |
211 | command line/output in case of exception | |
212 | """ | |
b92a0011 | 213 | self._iolog = None |
dab91d9a | 214 | self._qemu_full_args = None |
66613974 | 215 | try: |
d301bccf | 216 | self._launch() |
66613974 | 217 | except: |
37bbcd57 | 218 | if self.is_running(): |
66613974 | 219 | self._popen.kill() |
37bbcd57 | 220 | self._popen.wait() |
66613974 DB |
221 | self._load_io_log() |
222 | self._post_shutdown() | |
b92a0011 AP |
223 | |
224 | LOG.debug('Error launching VM') | |
225 | if self._qemu_full_args: | |
226 | LOG.debug('Command: %r', ' '.join(self._qemu_full_args)) | |
227 | if self._iolog: | |
228 | LOG.debug('Output: %r', self._iolog) | |
66613974 DB |
229 | raise |
230 | ||
d301bccf AP |
231 | def _launch(self): |
232 | '''Launch the VM and establish a QMP connection''' | |
233 | devnull = open(os.path.devnull, 'rb') | |
234 | self._pre_launch() | |
235 | self._qemu_full_args = (self._wrapper + [self._binary] + | |
236 | self._base_args() + self._args) | |
237 | self._popen = subprocess.Popen(self._qemu_full_args, | |
238 | stdin=devnull, | |
239 | stdout=self._qemu_log_file, | |
240 | stderr=subprocess.STDOUT, | |
241 | shell=False) | |
242 | self._post_launch() | |
243 | ||
22491a2f FZ |
244 | def wait(self): |
245 | '''Wait for the VM to power off''' | |
246 | self._popen.wait() | |
247 | self._qmp.close() | |
248 | self._load_io_log() | |
249 | self._post_shutdown() | |
250 | ||
66613974 DB |
251 | def shutdown(self): |
252 | '''Terminate the VM and clean up''' | |
37bbcd57 | 253 | if self.is_running(): |
66613974 DB |
254 | try: |
255 | self._qmp.cmd('quit') | |
256 | self._qmp.close() | |
257 | except: | |
258 | self._popen.kill() | |
dab91d9a | 259 | self._popen.wait() |
66613974 | 260 | |
04a963b4 AP |
261 | self._load_io_log() |
262 | self._post_shutdown() | |
66613974 | 263 | |
dab91d9a AP |
264 | exitcode = self.exitcode() |
265 | if exitcode is not None and exitcode < 0: | |
266 | msg = 'qemu received signal %i: %s' | |
267 | if self._qemu_full_args: | |
268 | command = ' '.join(self._qemu_full_args) | |
269 | else: | |
270 | command = '' | |
271 | LOG.warn(msg, exitcode, command) | |
272 | ||
66613974 | 273 | def qmp(self, cmd, conv_keys=True, **args): |
2d853c70 | 274 | '''Invoke a QMP command and return the response dict''' |
66613974 | 275 | qmp_args = dict() |
7f33ca78 | 276 | for key, value in args.iteritems(): |
66613974 | 277 | if conv_keys: |
41f714b1 | 278 | qmp_args[key.replace('_', '-')] = value |
66613974 | 279 | else: |
7f33ca78 | 280 | qmp_args[key] = value |
66613974 DB |
281 | |
282 | return self._qmp.cmd(cmd, args=qmp_args) | |
283 | ||
284 | def command(self, cmd, conv_keys=True, **args): | |
2d853c70 LD |
285 | ''' |
286 | Invoke a QMP command. | |
287 | On success return the response dict. | |
288 | On failure raise an exception. | |
289 | ''' | |
66613974 DB |
290 | reply = self.qmp(cmd, conv_keys, **args) |
291 | if reply is None: | |
a004e249 | 292 | raise qmp.qmp.QMPError("Monitor is closed") |
66613974 | 293 | if "error" in reply: |
a004e249 | 294 | raise MonitorResponseError(reply) |
66613974 DB |
295 | return reply["return"] |
296 | ||
297 | def get_qmp_event(self, wait=False): | |
298 | '''Poll for one queued QMP events and return it''' | |
299 | if len(self._events) > 0: | |
300 | return self._events.pop(0) | |
301 | return self._qmp.pull_event(wait=wait) | |
302 | ||
303 | def get_qmp_events(self, wait=False): | |
304 | '''Poll for queued QMP events and return a list of dicts''' | |
305 | events = self._qmp.get_events(wait=wait) | |
306 | events.extend(self._events) | |
307 | del self._events[:] | |
308 | self._qmp.clear_events() | |
309 | return events | |
310 | ||
311 | def event_wait(self, name, timeout=60.0, match=None): | |
2d853c70 LD |
312 | ''' |
313 | Wait for specified timeout on named event in QMP; optionally filter | |
314 | results by match. | |
315 | ||
316 | The 'match' is checked to be a recursive subset of the 'event'; skips | |
317 | branch processing on match's value None | |
318 | {"foo": {"bar": 1}} matches {"foo": None} | |
319 | {"foo": {"bar": 1}} does not matches {"foo": {"baz": None}} | |
320 | ''' | |
4c44b4a4 DB |
321 | def event_match(event, match=None): |
322 | if match is None: | |
323 | return True | |
324 | ||
325 | for key in match: | |
326 | if key in event: | |
327 | if isinstance(event[key], dict): | |
328 | if not event_match(event[key], match[key]): | |
329 | return False | |
330 | elif event[key] != match[key]: | |
331 | return False | |
332 | else: | |
333 | return False | |
334 | ||
335 | return True | |
336 | ||
66613974 DB |
337 | # Search cached events |
338 | for event in self._events: | |
339 | if (event['event'] == name) and event_match(event, match): | |
340 | self._events.remove(event) | |
341 | return event | |
342 | ||
343 | # Poll for new events | |
344 | while True: | |
345 | event = self._qmp.pull_event(wait=timeout) | |
346 | if (event['event'] == name) and event_match(event, match): | |
347 | return event | |
348 | self._events.append(event) | |
349 | ||
350 | return None | |
351 | ||
352 | def get_log(self): | |
2d853c70 LD |
353 | ''' |
354 | After self.shutdown or failed qemu execution, this returns the output | |
355 | of the qemu process. | |
356 | ''' | |
66613974 | 357 | return self._iolog |