numa: add -numa node,memdev= option
[qemu.git] / include / sysemu / char.h
1 #ifndef QEMU_CHAR_H
2 #define QEMU_CHAR_H
3
4 #include "qemu-common.h"
5 #include "qemu/queue.h"
6 #include "qemu/option.h"
7 #include "qemu/config-file.h"
8 #include "block/aio.h"
9 #include "qapi/qmp/qobject.h"
10 #include "qapi/qmp/qstring.h"
11 #include "qemu/main-loop.h"
12
13 /* character device */
14
15 #define CHR_EVENT_BREAK 0 /* serial break char */
16 #define CHR_EVENT_FOCUS 1 /* focus to this terminal (modal input needed) */
17 #define CHR_EVENT_OPENED 2 /* new connection established */
18 #define CHR_EVENT_MUX_IN 3 /* mux-focus was set to this terminal */
19 #define CHR_EVENT_MUX_OUT 4 /* mux-focus will move on */
20 #define CHR_EVENT_CLOSED 5 /* connection closed */
21
22
23 #define CHR_IOCTL_SERIAL_SET_PARAMS 1
24 typedef struct {
25 int speed;
26 int parity;
27 int data_bits;
28 int stop_bits;
29 } QEMUSerialSetParams;
30
31 #define CHR_IOCTL_SERIAL_SET_BREAK 2
32
33 #define CHR_IOCTL_PP_READ_DATA 3
34 #define CHR_IOCTL_PP_WRITE_DATA 4
35 #define CHR_IOCTL_PP_READ_CONTROL 5
36 #define CHR_IOCTL_PP_WRITE_CONTROL 6
37 #define CHR_IOCTL_PP_READ_STATUS 7
38 #define CHR_IOCTL_PP_EPP_READ_ADDR 8
39 #define CHR_IOCTL_PP_EPP_READ 9
40 #define CHR_IOCTL_PP_EPP_WRITE_ADDR 10
41 #define CHR_IOCTL_PP_EPP_WRITE 11
42 #define CHR_IOCTL_PP_DATA_DIR 12
43
44 #define CHR_IOCTL_SERIAL_SET_TIOCM 13
45 #define CHR_IOCTL_SERIAL_GET_TIOCM 14
46
47 #define CHR_TIOCM_CTS 0x020
48 #define CHR_TIOCM_CAR 0x040
49 #define CHR_TIOCM_DSR 0x100
50 #define CHR_TIOCM_RI 0x080
51 #define CHR_TIOCM_DTR 0x002
52 #define CHR_TIOCM_RTS 0x004
53
54 typedef void IOEventHandler(void *opaque, int event);
55
56 struct CharDriverState {
57 void (*init)(struct CharDriverState *s);
58 int (*chr_write)(struct CharDriverState *s, const uint8_t *buf, int len);
59 int (*chr_sync_read)(struct CharDriverState *s,
60 const uint8_t *buf, int len);
61 GSource *(*chr_add_watch)(struct CharDriverState *s, GIOCondition cond);
62 void (*chr_update_read_handler)(struct CharDriverState *s);
63 int (*chr_ioctl)(struct CharDriverState *s, int cmd, void *arg);
64 int (*get_msgfds)(struct CharDriverState *s, int* fds, int num);
65 int (*set_msgfds)(struct CharDriverState *s, int *fds, int num);
66 int (*chr_add_client)(struct CharDriverState *chr, int fd);
67 IOEventHandler *chr_event;
68 IOCanReadHandler *chr_can_read;
69 IOReadHandler *chr_read;
70 void *handler_opaque;
71 void (*chr_close)(struct CharDriverState *chr);
72 void (*chr_accept_input)(struct CharDriverState *chr);
73 void (*chr_set_echo)(struct CharDriverState *chr, bool echo);
74 void (*chr_set_fe_open)(struct CharDriverState *chr, int fe_open);
75 void (*chr_fe_event)(struct CharDriverState *chr, int event);
76 void *opaque;
77 char *label;
78 char *filename;
79 int be_open;
80 int fe_open;
81 int explicit_fe_open;
82 int explicit_be_open;
83 int avail_connections;
84 int is_mux;
85 guint fd_in_tag;
86 guint fd_hup_tag;
87 QemuOpts *opts;
88 QTAILQ_ENTRY(CharDriverState) next;
89 };
90
91 /**
92 * @qemu_chr_new_from_opts:
93 *
94 * Create a new character backend from a QemuOpts list.
95 *
96 * @opts see qemu-config.c for a list of valid options
97 * @init not sure..
98 *
99 * Returns: a new character backend
100 */
101 CharDriverState *qemu_chr_new_from_opts(QemuOpts *opts,
102 void (*init)(struct CharDriverState *s),
103 Error **errp);
104
105 /**
106 * @qemu_chr_new:
107 *
108 * Create a new character backend from a URI.
109 *
110 * @label the name of the backend
111 * @filename the URI
112 * @init not sure..
113 *
114 * Returns: a new character backend
115 */
116 CharDriverState *qemu_chr_new(const char *label, const char *filename,
117 void (*init)(struct CharDriverState *s));
118
119 /**
120 * @qemu_chr_delete:
121 *
122 * Destroy a character backend.
123 */
124 void qemu_chr_delete(CharDriverState *chr);
125
126 /**
127 * @qemu_chr_fe_set_echo:
128 *
129 * Ask the backend to override its normal echo setting. This only really
130 * applies to the stdio backend and is used by the QMP server such that you
131 * can see what you type if you try to type QMP commands.
132 *
133 * @echo true to enable echo, false to disable echo
134 */
135 void qemu_chr_fe_set_echo(struct CharDriverState *chr, bool echo);
136
137 /**
138 * @qemu_chr_fe_set_open:
139 *
140 * Set character frontend open status. This is an indication that the
141 * front end is ready (or not) to begin doing I/O.
142 */
143 void qemu_chr_fe_set_open(struct CharDriverState *chr, int fe_open);
144
145 /**
146 * @qemu_chr_fe_event:
147 *
148 * Send an event from the front end to the back end.
149 *
150 * @event the event to send
151 */
152 void qemu_chr_fe_event(CharDriverState *s, int event);
153
154 /**
155 * @qemu_chr_fe_printf:
156 *
157 * Write to a character backend using a printf style interface.
158 *
159 * @fmt see #printf
160 */
161 void qemu_chr_fe_printf(CharDriverState *s, const char *fmt, ...)
162 GCC_FMT_ATTR(2, 3);
163
164 int qemu_chr_fe_add_watch(CharDriverState *s, GIOCondition cond,
165 GIOFunc func, void *user_data);
166
167 /**
168 * @qemu_chr_fe_write:
169 *
170 * Write data to a character backend from the front end. This function will
171 * send data from the front end to the back end.
172 *
173 * @buf the data
174 * @len the number of bytes to send
175 *
176 * Returns: the number of bytes consumed
177 */
178 int qemu_chr_fe_write(CharDriverState *s, const uint8_t *buf, int len);
179
180 /**
181 * @qemu_chr_fe_write_all:
182 *
183 * Write data to a character backend from the front end. This function will
184 * send data from the front end to the back end. Unlike @qemu_chr_fe_write,
185 * this function will block if the back end cannot consume all of the data
186 * attempted to be written.
187 *
188 * @buf the data
189 * @len the number of bytes to send
190 *
191 * Returns: the number of bytes consumed
192 */
193 int qemu_chr_fe_write_all(CharDriverState *s, const uint8_t *buf, int len);
194
195 /**
196 * @qemu_chr_fe_read_all:
197 *
198 * Read data to a buffer from the back end.
199 *
200 * @buf the data buffer
201 * @len the number of bytes to read
202 *
203 * Returns: the number of bytes read
204 */
205 int qemu_chr_fe_read_all(CharDriverState *s, uint8_t *buf, int len);
206
207 /**
208 * @qemu_chr_fe_ioctl:
209 *
210 * Issue a device specific ioctl to a backend.
211 *
212 * @cmd see CHR_IOCTL_*
213 * @arg the data associated with @cmd
214 *
215 * Returns: if @cmd is not supported by the backend, -ENOTSUP, otherwise the
216 * return value depends on the semantics of @cmd
217 */
218 int qemu_chr_fe_ioctl(CharDriverState *s, int cmd, void *arg);
219
220 /**
221 * @qemu_chr_fe_get_msgfd:
222 *
223 * For backends capable of fd passing, return the latest file descriptor passed
224 * by a client.
225 *
226 * Returns: -1 if fd passing isn't supported or there is no pending file
227 * descriptor. If a file descriptor is returned, subsequent calls to
228 * this function will return -1 until a client sends a new file
229 * descriptor.
230 */
231 int qemu_chr_fe_get_msgfd(CharDriverState *s);
232
233 /**
234 * @qemu_chr_fe_get_msgfds:
235 *
236 * For backends capable of fd passing, return the number of file received
237 * descriptors and fills the fds array up to num elements
238 *
239 * Returns: -1 if fd passing isn't supported or there are no pending file
240 * descriptors. If file descriptors are returned, subsequent calls to
241 * this function will return -1 until a client sends a new set of file
242 * descriptors.
243 */
244 int qemu_chr_fe_get_msgfds(CharDriverState *s, int *fds, int num);
245
246 /**
247 * @qemu_chr_fe_set_msgfds:
248 *
249 * For backends capable of fd passing, set an array of fds to be passed with
250 * the next send operation.
251 * A subsequent call to this function before calling a write function will
252 * result in overwriting the fd array with the new value without being send.
253 * Upon writing the message the fd array is freed.
254 *
255 * Returns: -1 if fd passing isn't supported.
256 */
257 int qemu_chr_fe_set_msgfds(CharDriverState *s, int *fds, int num);
258
259 /**
260 * @qemu_chr_fe_claim:
261 *
262 * Claim a backend before using it, should be called before calling
263 * qemu_chr_add_handlers().
264 *
265 * Returns: -1 if the backend is already in use by another frontend, 0 on
266 * success.
267 */
268 int qemu_chr_fe_claim(CharDriverState *s);
269
270 /**
271 * @qemu_chr_fe_claim_no_fail:
272 *
273 * Like qemu_chr_fe_claim, but will exit qemu with an error when the
274 * backend is already in use.
275 */
276 void qemu_chr_fe_claim_no_fail(CharDriverState *s);
277
278 /**
279 * @qemu_chr_fe_claim:
280 *
281 * Release a backend for use by another frontend.
282 *
283 * Returns: -1 if the backend is already in use by another frontend, 0 on
284 * success.
285 */
286 void qemu_chr_fe_release(CharDriverState *s);
287
288 /**
289 * @qemu_chr_be_can_write:
290 *
291 * Determine how much data the front end can currently accept. This function
292 * returns the number of bytes the front end can accept. If it returns 0, the
293 * front end cannot receive data at the moment. The function must be polled
294 * to determine when data can be received.
295 *
296 * Returns: the number of bytes the front end can receive via @qemu_chr_be_write
297 */
298 int qemu_chr_be_can_write(CharDriverState *s);
299
300 /**
301 * @qemu_chr_be_write:
302 *
303 * Write data from the back end to the front end. Before issuing this call,
304 * the caller should call @qemu_chr_be_can_write to determine how much data
305 * the front end can currently accept.
306 *
307 * @buf a buffer to receive data from the front end
308 * @len the number of bytes to receive from the front end
309 */
310 void qemu_chr_be_write(CharDriverState *s, uint8_t *buf, int len);
311
312
313 /**
314 * @qemu_chr_be_event:
315 *
316 * Send an event from the back end to the front end.
317 *
318 * @event the event to send
319 */
320 void qemu_chr_be_event(CharDriverState *s, int event);
321
322 void qemu_chr_add_handlers(CharDriverState *s,
323 IOCanReadHandler *fd_can_read,
324 IOReadHandler *fd_read,
325 IOEventHandler *fd_event,
326 void *opaque);
327
328 void qemu_chr_be_generic_open(CharDriverState *s);
329 void qemu_chr_accept_input(CharDriverState *s);
330 int qemu_chr_add_client(CharDriverState *s, int fd);
331 CharDriverState *qemu_chr_find(const char *name);
332 bool chr_is_ringbuf(const CharDriverState *chr);
333
334 QemuOpts *qemu_chr_parse_compat(const char *label, const char *filename);
335
336 void register_char_driver(const char *name, CharDriverState *(*open)(QemuOpts *));
337 void register_char_driver_qapi(const char *name, ChardevBackendKind kind,
338 void (*parse)(QemuOpts *opts, ChardevBackend *backend, Error **errp));
339
340 /* add an eventfd to the qemu devices that are polled */
341 CharDriverState *qemu_chr_open_eventfd(int eventfd);
342
343 extern int term_escape_char;
344
345 CharDriverState *qemu_char_get_next_serial(void);
346
347 /* msmouse */
348 CharDriverState *qemu_chr_open_msmouse(void);
349
350 /* baum.c */
351 CharDriverState *chr_baum_init(void);
352
353 #endif