xref: /qemu/monitor/monitor-internal.h (revision 54e91d1523b412b4cff7cb36c898fa9dc133e886)
1  /*
2   * QEMU monitor
3   *
4   * Copyright (c) 2003-2004 Fabrice Bellard
5   *
6   * Permission is hereby granted, free of charge, to any person obtaining a copy
7   * of this software and associated documentation files (the "Software"), to deal
8   * in the Software without restriction, including without limitation the rights
9   * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10   * copies of the Software, and to permit persons to whom the Software is
11   * furnished to do so, subject to the following conditions:
12   *
13   * The above copyright notice and this permission notice shall be included in
14   * all copies or substantial portions of the Software.
15   *
16   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19   * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21   * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22   * THE SOFTWARE.
23   */
24  
25  #ifndef MONITOR_INTERNAL_H
26  #define MONITOR_INTERNAL_H
27  
28  #include "chardev/char-fe.h"
29  #include "monitor/monitor.h"
30  #include "qapi/qapi-types-control.h"
31  #include "qapi/qmp-registry.h"
32  #include "qobject/json-parser.h"
33  #include "qemu/readline.h"
34  #include "system/iothread.h"
35  
36  /*
37   * Supported types:
38   *
39   * 'F'          filename
40   * 'B'          block device name
41   * 's'          string (accept optional quote)
42   * 'S'          it just appends the rest of the string (accept optional quote)
43   * 'O'          option string of the form NAME=VALUE,...
44   *              parsed according to QemuOptsList given by its name
45   *              Example: 'device:O' uses qemu_device_opts.
46   *              Restriction: only lists with empty desc are supported
47   *              TODO lift the restriction
48   * 'i'          32 bit integer
49   * 'l'          target long (32 or 64 bit)
50   * 'M'          Non-negative target long (32 or 64 bit), in user mode the
51   *              value is multiplied by 2^20 (think Mebibyte)
52   * 'o'          octets (aka bytes)
53   *              user mode accepts an optional E, e, P, p, T, t, G, g, M, m,
54   *              K, k suffix, which multiplies the value by 2^60 for suffixes E
55   *              and e, 2^50 for suffixes P and p, 2^40 for suffixes T and t,
56   *              2^30 for suffixes G and g, 2^20 for M and m, 2^10 for K and k
57   * 'T'          double
58   *              user mode accepts an optional ms, us, ns suffix,
59   *              which divides the value by 1e3, 1e6, 1e9, respectively
60   * '/'          optional gdb-like print format (like "/10x")
61   *
62   * '?'          optional type (for all types, except '/')
63   * '.'          other form of optional type (for 'i' and 'l')
64   * 'b'          boolean
65   *              user mode accepts "on" or "off"
66   * '-'          optional parameter (eg. '-f'); if followed by a 's', it
67   *              specifies an optional string param (e.g. '-fs' allows '-f foo')
68   *
69   */
70  
71  typedef struct HMPCommand {
72      const char *name;
73      const char *args_type;
74      const char *params;
75      const char *help;
76      const char *flags; /* p=preconfig */
77      void (*cmd)(Monitor *mon, const QDict *qdict);
78      /*
79       * If implementing a command that takes no arguments and simply
80       * prints formatted data, then leave @cmd NULL, and then set
81       * @cmd_info_hrt to the corresponding QMP handler that returns
82       * the formatted text.
83       */
84      HumanReadableText *(*cmd_info_hrt)(Error **errp);
85      bool coroutine;
86      /*
87       * @sub_table is a list of 2nd level of commands. If it does not exist,
88       * cmd should be used. If it exists, sub_table[?].cmd should be
89       * used, and cmd of 1st level plays the role of help function.
90       */
91      struct HMPCommand *sub_table;
92      void (*command_completion)(ReadLineState *rs, int nb_args, const char *str);
93  } HMPCommand;
94  
95  struct Monitor {
96      CharBackend chr;
97      int suspend_cnt;            /* Needs to be accessed atomically */
98      bool is_qmp;
99      bool skip_flush;
100      bool use_io_thread;
101  
102      char *mon_cpu_path;
103      QTAILQ_ENTRY(Monitor) entry;
104  
105      /*
106       * The per-monitor lock. We can't access guest memory when holding
107       * the lock.
108       */
109      QemuMutex mon_lock;
110  
111      /*
112       * Members that are protected by the per-monitor lock
113       */
114      QLIST_HEAD(, mon_fd_t) fds;
115      GString *outbuf;
116      guint out_watch;
117      int mux_out;
118      int reset_seen;
119  };
120  
121  struct MonitorHMP {
122      Monitor common;
123      bool use_readline;
124      /*
125       * State used only in the thread "owning" the monitor.
126       * If @use_io_thread, this is @mon_iothread. (This does not actually happen
127       * in the current state of the code.)
128       * Else, it's the main thread.
129       * These members can be safely accessed without locks.
130       */
131      ReadLineState *rs;
132  };
133  
134  typedef struct {
135      Monitor common;
136      JSONMessageParser parser;
137      bool pretty;
138      /*
139       * When a client connects, we're in capabilities negotiation mode.
140       * @commands is &qmp_cap_negotiation_commands then.  When command
141       * qmp_capabilities succeeds, we go into command mode, and
142       * @command becomes &qmp_commands.
143       */
144      const QmpCommandList *commands;
145      bool capab_offered[QMP_CAPABILITY__MAX]; /* capabilities offered */
146      bool capab[QMP_CAPABILITY__MAX];         /* offered and accepted */
147      /*
148       * Protects qmp request/response queue.
149       * Take monitor_lock first when you need both.
150       */
151      QemuMutex qmp_queue_lock;
152      /* Input queue that holds all the parsed QMP requests */
153      GQueue *qmp_requests;
154  } MonitorQMP;
155  
156  /**
157   * Is @mon a QMP monitor?
158   */
monitor_is_qmp(const Monitor * mon)159  static inline bool monitor_is_qmp(const Monitor *mon)
160  {
161      return mon->is_qmp;
162  }
163  
164  typedef QTAILQ_HEAD(MonitorList, Monitor) MonitorList;
165  extern IOThread *mon_iothread;
166  extern Coroutine *qmp_dispatcher_co;
167  extern bool qmp_dispatcher_co_shutdown;
168  extern QmpCommandList qmp_commands, qmp_cap_negotiation_commands;
169  extern QemuMutex monitor_lock;
170  extern MonitorList mon_list;
171  
172  extern HMPCommand hmp_cmds[];
173  
174  void monitor_data_init(Monitor *mon, bool is_qmp, bool skip_flush,
175                         bool use_io_thread);
176  void monitor_data_destroy(Monitor *mon);
177  int monitor_can_read(void *opaque);
178  void monitor_list_append(Monitor *mon);
179  void monitor_fdsets_cleanup(void);
180  
181  void qmp_send_response(MonitorQMP *mon, const QDict *rsp);
182  void monitor_data_destroy_qmp(MonitorQMP *mon);
183  void coroutine_fn monitor_qmp_dispatcher_co(void *data);
184  void qmp_dispatcher_co_wake(void);
185  
186  int get_monitor_def(Monitor *mon, int64_t *pval, const char *name);
187  void handle_hmp_command(MonitorHMP *mon, const char *cmdline);
188  int hmp_compare_cmd(const char *name, const char *list);
189  
190  #endif
191