ppc/pnv: add a PnvICPState object
[qemu.git] / scripts / qmp / qmp-shell
1 #!/usr/bin/python
2 #
3 # Low-level QEMU shell on top of QMP.
4 #
5 # Copyright (C) 2009, 2010 Red Hat Inc.
6 #
7 # Authors:
8 #  Luiz Capitulino <lcapitulino@redhat.com>
9 #
10 # This work is licensed under the terms of the GNU GPL, version 2.  See
11 # the COPYING file in the top-level directory.
12 #
13 # Usage:
14 #
15 # Start QEMU with:
16 #
17 # # qemu [...] -qmp unix:./qmp-sock,server
18 #
19 # Run the shell:
20 #
21 # $ qmp-shell ./qmp-sock
22 #
23 # Commands have the following format:
24 #
25 #    < command-name > [ arg-name1=arg1 ] ... [ arg-nameN=argN ]
26 #
27 # For example:
28 #
29 # (QEMU) device_add driver=e1000 id=net1
30 # {u'return': {}}
31 # (QEMU)
32 #
33 # key=value pairs also support Python or JSON object literal subset notations,
34 # without spaces. Dictionaries/objects {} are supported as are arrays [].
35 #
36 #    example-command arg-name1={'key':'value','obj'={'prop':"value"}}
37 #
38 # Both JSON and Python formatting should work, including both styles of
39 # string literal quotes. Both paradigms of literal values should work,
40 # including null/true/false for JSON and None/True/False for Python.
41 #
42 #
43 # Transactions have the following multi-line format:
44 #
45 #    transaction(
46 #    action-name1 [ arg-name1=arg1 ] ... [arg-nameN=argN ]
47 #    ...
48 #    action-nameN [ arg-name1=arg1 ] ... [arg-nameN=argN ]
49 #    )
50 #
51 # One line transactions are also supported:
52 #
53 #    transaction( action-name1 ... )
54 #
55 # For example:
56 #
57 #     (QEMU) transaction(
58 #     TRANS> block-dirty-bitmap-add node=drive0 name=bitmap1
59 #     TRANS> block-dirty-bitmap-clear node=drive0 name=bitmap0
60 #     TRANS> )
61 #     {"return": {}}
62 #     (QEMU)
63 #
64 # Use the -v and -p options to activate the verbose and pretty-print options,
65 # which will echo back the properly formatted JSON-compliant QMP that is being
66 # sent to QEMU, which is useful for debugging and documentation generation.
67
68 import qmp
69 import json
70 import ast
71 import readline
72 import sys
73
74 class QMPCompleter(list):
75     def complete(self, text, state):
76         for cmd in self:
77             if cmd.startswith(text):
78                 if not state:
79                     return cmd
80                 else:
81                     state -= 1
82
83 class QMPShellError(Exception):
84     pass
85
86 class QMPShellBadPort(QMPShellError):
87     pass
88
89 class FuzzyJSON(ast.NodeTransformer):
90     '''This extension of ast.NodeTransformer filters literal "true/false/null"
91     values in an AST and replaces them by proper "True/False/None" values that
92     Python can properly evaluate.'''
93     def visit_Name(self, node):
94         if node.id == 'true':
95             node.id = 'True'
96         if node.id == 'false':
97             node.id = 'False'
98         if node.id == 'null':
99             node.id = 'None'
100         return node
101
102 # TODO: QMPShell's interface is a bit ugly (eg. _fill_completion() and
103 #       _execute_cmd()). Let's design a better one.
104 class QMPShell(qmp.QEMUMonitorProtocol):
105     def __init__(self, address, pretty=False):
106         qmp.QEMUMonitorProtocol.__init__(self, self.__get_address(address))
107         self._greeting = None
108         self._completer = None
109         self._pretty = pretty
110         self._transmode = False
111         self._actions = list()
112
113     def __get_address(self, arg):
114         """
115         Figure out if the argument is in the port:host form, if it's not it's
116         probably a file path.
117         """
118         addr = arg.split(':')
119         if len(addr) == 2:
120             try:
121                 port = int(addr[1])
122             except ValueError:
123                 raise QMPShellBadPort
124             return ( addr[0], port )
125         # socket path
126         return arg
127
128     def _fill_completion(self):
129         for cmd in self.cmd('query-commands')['return']:
130             self._completer.append(cmd['name'])
131
132     def __completer_setup(self):
133         self._completer = QMPCompleter()
134         self._fill_completion()
135         readline.set_completer(self._completer.complete)
136         readline.parse_and_bind("tab: complete")
137         # XXX: default delimiters conflict with some command names (eg. query-),
138         # clearing everything as it doesn't seem to matter
139         readline.set_completer_delims('')
140
141     def __parse_value(self, val):
142         try:
143             return int(val)
144         except ValueError:
145             pass
146
147         if val.lower() == 'true':
148             return True
149         if val.lower() == 'false':
150             return False
151         if val.startswith(('{', '[')):
152             # Try first as pure JSON:
153             try:
154                 return json.loads(val)
155             except ValueError:
156                 pass
157             # Try once again as FuzzyJSON:
158             try:
159                 st = ast.parse(val, mode='eval')
160                 return ast.literal_eval(FuzzyJSON().visit(st))
161             except SyntaxError:
162                 pass
163             except ValueError:
164                 pass
165         return val
166
167     def __cli_expr(self, tokens, parent):
168         for arg in tokens:
169             (key, sep, val) = arg.partition('=')
170             if sep != '=':
171                 raise QMPShellError("Expected a key=value pair, got '%s'" % arg)
172
173             value = self.__parse_value(val)
174             optpath = key.split('.')
175             curpath = []
176             for p in optpath[:-1]:
177                 curpath.append(p)
178                 d = parent.get(p, {})
179                 if type(d) is not dict:
180                     raise QMPShellError('Cannot use "%s" as both leaf and non-leaf key' % '.'.join(curpath))
181                 parent[p] = d
182                 parent = d
183             if optpath[-1] in parent:
184                 if type(parent[optpath[-1]]) is dict:
185                     raise QMPShellError('Cannot use "%s" as both leaf and non-leaf key' % '.'.join(curpath))
186                 else:
187                     raise QMPShellError('Cannot set "%s" multiple times' % key)
188             parent[optpath[-1]] = value
189
190     def __build_cmd(self, cmdline):
191         """
192         Build a QMP input object from a user provided command-line in the
193         following format:
194
195             < command-name > [ arg-name1=arg1 ] ... [ arg-nameN=argN ]
196         """
197         cmdargs = cmdline.split()
198
199         # Transactional CLI entry/exit:
200         if cmdargs[0] == 'transaction(':
201             self._transmode = True
202             cmdargs.pop(0)
203         elif cmdargs[0] == ')' and self._transmode:
204             self._transmode = False
205             if len(cmdargs) > 1:
206                 raise QMPShellError("Unexpected input after close of Transaction sub-shell")
207             qmpcmd = { 'execute': 'transaction',
208                        'arguments': { 'actions': self._actions } }
209             self._actions = list()
210             return qmpcmd
211
212         # Nothing to process?
213         if not cmdargs:
214             return None
215
216         # Parse and then cache this Transactional Action
217         if self._transmode:
218             finalize = False
219             action = { 'type': cmdargs[0], 'data': {} }
220             if cmdargs[-1] == ')':
221                 cmdargs.pop(-1)
222                 finalize = True
223             self.__cli_expr(cmdargs[1:], action['data'])
224             self._actions.append(action)
225             return self.__build_cmd(')') if finalize else None
226
227         # Standard command: parse and return it to be executed.
228         qmpcmd = { 'execute': cmdargs[0], 'arguments': {} }
229         self.__cli_expr(cmdargs[1:], qmpcmd['arguments'])
230         return qmpcmd
231
232     def _print(self, qmp):
233         indent = None
234         if self._pretty:
235             indent = 4
236         jsobj = json.dumps(qmp, indent=indent)
237         print str(jsobj)
238
239     def _execute_cmd(self, cmdline):
240         try:
241             qmpcmd = self.__build_cmd(cmdline)
242         except Exception as e:
243             print 'Error while parsing command line: %s' % e
244             print 'command format: <command-name> ',
245             print '[arg-name1=arg1] ... [arg-nameN=argN]'
246             return True
247         # For transaction mode, we may have just cached the action:
248         if qmpcmd is None:
249             return True
250         if self._verbose:
251             self._print(qmpcmd)
252         resp = self.cmd_obj(qmpcmd)
253         if resp is None:
254             print 'Disconnected'
255             return False
256         self._print(resp)
257         return True
258
259     def connect(self):
260         self._greeting = qmp.QEMUMonitorProtocol.connect(self)
261         self.__completer_setup()
262
263     def show_banner(self, msg='Welcome to the QMP low-level shell!'):
264         print msg
265         version = self._greeting['QMP']['version']['qemu']
266         print 'Connected to QEMU %d.%d.%d\n' % (version['major'],version['minor'],version['micro'])
267
268     def get_prompt(self):
269         if self._transmode:
270             return "TRANS> "
271         return "(QEMU) "
272
273     def read_exec_command(self, prompt):
274         """
275         Read and execute a command.
276
277         @return True if execution was ok, return False if disconnected.
278         """
279         try:
280             cmdline = raw_input(prompt)
281         except EOFError:
282             print
283             return False
284         if cmdline == '':
285             for ev in self.get_events():
286                 print ev
287             self.clear_events()
288             return True
289         else:
290             return self._execute_cmd(cmdline)
291
292     def set_verbosity(self, verbose):
293         self._verbose = verbose
294
295 class HMPShell(QMPShell):
296     def __init__(self, address):
297         QMPShell.__init__(self, address)
298         self.__cpu_index = 0
299
300     def __cmd_completion(self):
301         for cmd in self.__cmd_passthrough('help')['return'].split('\r\n'):
302             if cmd and cmd[0] != '[' and cmd[0] != '\t':
303                 name = cmd.split()[0] # drop help text
304                 if name == 'info':
305                     continue
306                 if name.find('|') != -1:
307                     # Command in the form 'foobar|f' or 'f|foobar', take the
308                     # full name
309                     opt = name.split('|')
310                     if len(opt[0]) == 1:
311                         name = opt[1]
312                     else:
313                         name = opt[0]
314                 self._completer.append(name)
315                 self._completer.append('help ' + name) # help completion
316
317     def __info_completion(self):
318         for cmd in self.__cmd_passthrough('info')['return'].split('\r\n'):
319             if cmd:
320                 self._completer.append('info ' + cmd.split()[1])
321
322     def __other_completion(self):
323         # special cases
324         self._completer.append('help info')
325
326     def _fill_completion(self):
327         self.__cmd_completion()
328         self.__info_completion()
329         self.__other_completion()
330
331     def __cmd_passthrough(self, cmdline, cpu_index = 0):
332         return self.cmd_obj({ 'execute': 'human-monitor-command', 'arguments':
333                               { 'command-line': cmdline,
334                                 'cpu-index': cpu_index } })
335
336     def _execute_cmd(self, cmdline):
337         if cmdline.split()[0] == "cpu":
338             # trap the cpu command, it requires special setting
339             try:
340                 idx = int(cmdline.split()[1])
341                 if not 'return' in self.__cmd_passthrough('info version', idx):
342                     print 'bad CPU index'
343                     return True
344                 self.__cpu_index = idx
345             except ValueError:
346                 print 'cpu command takes an integer argument'
347                 return True
348         resp = self.__cmd_passthrough(cmdline, self.__cpu_index)
349         if resp is None:
350             print 'Disconnected'
351             return False
352         assert 'return' in resp or 'error' in resp
353         if 'return' in resp:
354             # Success
355             if len(resp['return']) > 0:
356                 print resp['return'],
357         else:
358             # Error
359             print '%s: %s' % (resp['error']['class'], resp['error']['desc'])
360         return True
361
362     def show_banner(self):
363         QMPShell.show_banner(self, msg='Welcome to the HMP shell!')
364
365 def die(msg):
366     sys.stderr.write('ERROR: %s\n' % msg)
367     sys.exit(1)
368
369 def fail_cmdline(option=None):
370     if option:
371         sys.stderr.write('ERROR: bad command-line option \'%s\'\n' % option)
372     sys.stderr.write('qemu-shell [ -v ] [ -p ] [ -H ] < UNIX socket path> | < TCP address:port >\n')
373     sys.exit(1)
374
375 def main():
376     addr = ''
377     qemu = None
378     hmp = False
379     pretty = False
380     verbose = False
381
382     try:
383         for arg in sys.argv[1:]:
384             if arg == "-H":
385                 if qemu is not None:
386                     fail_cmdline(arg)
387                 hmp = True
388             elif arg == "-p":
389                 pretty = True
390             elif arg == "-v":
391                 verbose = True
392             else:
393                 if qemu is not None:
394                     fail_cmdline(arg)
395                 if hmp:
396                     qemu = HMPShell(arg)
397                 else:
398                     qemu = QMPShell(arg, pretty)
399                 addr = arg
400
401         if qemu is None:
402             fail_cmdline()
403     except QMPShellBadPort:
404         die('bad port number in command-line')
405
406     try:
407         qemu.connect()
408     except qmp.QMPConnectError:
409         die('Didn\'t get QMP greeting message')
410     except qmp.QMPCapabilitiesError:
411         die('Could not negotiate capabilities')
412     except qemu.error:
413         die('Could not connect to %s' % addr)
414
415     qemu.show_banner()
416     qemu.set_verbosity(verbose)
417     while qemu.read_exec_command(qemu.get_prompt()):
418         pass
419     qemu.close()
420
421 if __name__ == '__main__':
422     main()