]>
Commit | Line | Data |
---|---|---|
87ecb68b PB |
1 | #ifndef QEMU_CHAR_H |
2 | #define QEMU_CHAR_H | |
3 | ||
376253ec | 4 | #include "qemu-common.h" |
1de7afc9 PB |
5 | #include "qemu/queue.h" |
6 | #include "qemu/option.h" | |
7 | #include "qemu/config-file.h" | |
737e150e | 8 | #include "block/aio.h" |
7b1b5d19 PB |
9 | #include "qapi/qmp/qobject.h" |
10 | #include "qapi/qmp/qstring.h" | |
1de7afc9 | 11 | #include "qemu/main-loop.h" |
376253ec | 12 | |
87ecb68b PB |
13 | /* character device */ |
14 | ||
2724b180 AL |
15 | #define CHR_EVENT_BREAK 0 /* serial break char */ |
16 | #define CHR_EVENT_FOCUS 1 /* focus to this terminal (modal input needed) */ | |
b6b8df56 | 17 | #define CHR_EVENT_OPENED 2 /* new connection established */ |
2724b180 AL |
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 */ | |
793cbfb5 | 20 | #define CHR_EVENT_CLOSED 5 /* connection closed */ |
87ecb68b PB |
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 | |
563e3c6e | 42 | #define CHR_IOCTL_PP_DATA_DIR 12 |
87ecb68b | 43 | |
8a98ecad MA |
44 | struct ParallelIOArg { |
45 | void *buffer; | |
46 | int count; | |
47 | }; | |
48 | ||
f0664048 AJ |
49 | #define CHR_IOCTL_SERIAL_SET_TIOCM 13 |
50 | #define CHR_IOCTL_SERIAL_GET_TIOCM 14 | |
81174dae AL |
51 | |
52 | #define CHR_TIOCM_CTS 0x020 | |
53 | #define CHR_TIOCM_CAR 0x040 | |
54 | #define CHR_TIOCM_DSR 0x100 | |
55 | #define CHR_TIOCM_RI 0x080 | |
56 | #define CHR_TIOCM_DTR 0x002 | |
57 | #define CHR_TIOCM_RTS 0x004 | |
58 | ||
87ecb68b PB |
59 | typedef void IOEventHandler(void *opaque, int event); |
60 | ||
61 | struct CharDriverState { | |
9005b2a7 | 62 | QemuMutex chr_write_lock; |
ceecf1d1 | 63 | void (*init)(struct CharDriverState *s); |
87ecb68b | 64 | int (*chr_write)(struct CharDriverState *s, const uint8_t *buf, int len); |
7b0bfdf5 NN |
65 | int (*chr_sync_read)(struct CharDriverState *s, |
66 | const uint8_t *buf, int len); | |
23673ca7 | 67 | GSource *(*chr_add_watch)(struct CharDriverState *s, GIOCondition cond); |
87ecb68b PB |
68 | void (*chr_update_read_handler)(struct CharDriverState *s); |
69 | int (*chr_ioctl)(struct CharDriverState *s, int cmd, void *arg); | |
c76bf6bb | 70 | int (*get_msgfds)(struct CharDriverState *s, int* fds, int num); |
d39aac7a | 71 | int (*set_msgfds)(struct CharDriverState *s, int *fds, int num); |
13661089 | 72 | int (*chr_add_client)(struct CharDriverState *chr, int fd); |
87ecb68b | 73 | IOEventHandler *chr_event; |
7b27a769 | 74 | IOCanReadHandler *chr_can_read; |
87ecb68b PB |
75 | IOReadHandler *chr_read; |
76 | void *handler_opaque; | |
87ecb68b | 77 | void (*chr_close)(struct CharDriverState *chr); |
7d9d17f7 | 78 | void (*chr_disconnect)(struct CharDriverState *chr); |
bd9bdce6 | 79 | void (*chr_accept_input)(struct CharDriverState *chr); |
c48855e1 | 80 | void (*chr_set_echo)(struct CharDriverState *chr, bool echo); |
574b711a | 81 | void (*chr_set_fe_open)(struct CharDriverState *chr, int fe_open); |
d61b0c9a | 82 | void (*chr_fe_event)(struct CharDriverState *chr, int event); |
87ecb68b | 83 | void *opaque; |
5ccfae10 AL |
84 | char *label; |
85 | char *filename; | |
d0d7708b | 86 | int logfd; |
16665b94 | 87 | int be_open; |
c0c4bd2c | 88 | int fe_open; |
19083228 | 89 | int explicit_fe_open; |
bd5c51ee | 90 | int explicit_be_open; |
d5b27167 | 91 | int avail_connections; |
7b7ab18d | 92 | int is_mux; |
7ba9addc | 93 | guint fd_in_tag; |
2274ae9d | 94 | QemuOpts *opts; |
33577b47 | 95 | bool replay; |
72cf2d4f | 96 | QTAILQ_ENTRY(CharDriverState) next; |
87ecb68b PB |
97 | }; |
98 | ||
db39fcf1 | 99 | /** |
d0d7708b DB |
100 | * qemu_chr_alloc: |
101 | * @backend: the common backend config | |
102 | * @errp: pointer to a NULL-initialized error object | |
db39fcf1 PB |
103 | * |
104 | * Allocate and initialize a new CharDriverState. | |
105 | * | |
d0d7708b | 106 | * Returns: a newly allocated CharDriverState, or NULL on error. |
db39fcf1 | 107 | */ |
d0d7708b | 108 | CharDriverState *qemu_chr_alloc(ChardevCommon *backend, Error **errp); |
db39fcf1 | 109 | |
2011fe56 AL |
110 | /** |
111 | * @qemu_chr_new_from_opts: | |
112 | * | |
113 | * Create a new character backend from a QemuOpts list. | |
114 | * | |
115 | * @opts see qemu-config.c for a list of valid options | |
116 | * @init not sure.. | |
117 | * | |
118 | * Returns: a new character backend | |
119 | */ | |
f69554b9 | 120 | CharDriverState *qemu_chr_new_from_opts(QemuOpts *opts, |
bd2d80b2 GH |
121 | void (*init)(struct CharDriverState *s), |
122 | Error **errp); | |
2011fe56 | 123 | |
21a933ea EB |
124 | /** |
125 | * @qemu_chr_parse_common: | |
126 | * | |
127 | * Parse the common options available to all character backends. | |
128 | * | |
129 | * @opts the options that still need parsing | |
130 | * @backend a new backend | |
131 | */ | |
132 | void qemu_chr_parse_common(QemuOpts *opts, ChardevCommon *backend); | |
133 | ||
2011fe56 AL |
134 | /** |
135 | * @qemu_chr_new: | |
136 | * | |
137 | * Create a new character backend from a URI. | |
138 | * | |
139 | * @label the name of the backend | |
140 | * @filename the URI | |
141 | * @init not sure.. | |
142 | * | |
143 | * Returns: a new character backend | |
144 | */ | |
145 | CharDriverState *qemu_chr_new(const char *label, const char *filename, | |
146 | void (*init)(struct CharDriverState *s)); | |
7d9d17f7 TM |
147 | /** |
148 | * @qemu_chr_disconnect: | |
149 | * | |
150 | * Close a fd accpeted by character backend. | |
151 | */ | |
152 | void qemu_chr_disconnect(CharDriverState *chr); | |
2011fe56 | 153 | |
aa5cb7f5 MAL |
154 | /** |
155 | * @qemu_chr_cleanup: | |
156 | * | |
157 | * Delete all chardevs (when leaving qemu) | |
158 | */ | |
159 | void qemu_chr_cleanup(void); | |
160 | ||
33577b47 PD |
161 | /** |
162 | * @qemu_chr_new_noreplay: | |
163 | * | |
164 | * Create a new character backend from a URI. | |
165 | * Character device communications are not written | |
166 | * into the replay log. | |
167 | * | |
168 | * @label the name of the backend | |
169 | * @filename the URI | |
170 | * @init not sure.. | |
171 | * | |
172 | * Returns: a new character backend | |
173 | */ | |
174 | CharDriverState *qemu_chr_new_noreplay(const char *label, const char *filename, | |
175 | void (*init)(struct CharDriverState *s)); | |
176 | ||
2011fe56 AL |
177 | /** |
178 | * @qemu_chr_delete: | |
179 | * | |
1ad78ea5 MAL |
180 | * Destroy a character backend and remove it from the list of |
181 | * identified character backends. | |
2011fe56 AL |
182 | */ |
183 | void qemu_chr_delete(CharDriverState *chr); | |
184 | ||
1ad78ea5 MAL |
185 | /** |
186 | * @qemu_chr_free: | |
187 | * | |
188 | * Destroy a character backend. | |
189 | */ | |
190 | void qemu_chr_free(CharDriverState *chr); | |
191 | ||
2011fe56 AL |
192 | /** |
193 | * @qemu_chr_fe_set_echo: | |
194 | * | |
195 | * Ask the backend to override its normal echo setting. This only really | |
196 | * applies to the stdio backend and is used by the QMP server such that you | |
197 | * can see what you type if you try to type QMP commands. | |
198 | * | |
199 | * @echo true to enable echo, false to disable echo | |
200 | */ | |
15f31519 | 201 | void qemu_chr_fe_set_echo(struct CharDriverState *chr, bool echo); |
2011fe56 AL |
202 | |
203 | /** | |
8e25daa8 | 204 | * @qemu_chr_fe_set_open: |
2011fe56 | 205 | * |
8e25daa8 HG |
206 | * Set character frontend open status. This is an indication that the |
207 | * front end is ready (or not) to begin doing I/O. | |
2011fe56 | 208 | */ |
8e25daa8 | 209 | void qemu_chr_fe_set_open(struct CharDriverState *chr, int fe_open); |
2011fe56 | 210 | |
d61b0c9a MAL |
211 | /** |
212 | * @qemu_chr_fe_event: | |
213 | * | |
214 | * Send an event from the front end to the back end. | |
215 | * | |
216 | * @event the event to send | |
217 | */ | |
218 | void qemu_chr_fe_event(CharDriverState *s, int event); | |
219 | ||
2011fe56 AL |
220 | /** |
221 | * @qemu_chr_fe_printf: | |
222 | * | |
223 | * Write to a character backend using a printf style interface. | |
9005b2a7 | 224 | * This function is thread-safe. |
2011fe56 AL |
225 | * |
226 | * @fmt see #printf | |
227 | */ | |
e7e71b0e | 228 | void qemu_chr_fe_printf(CharDriverState *s, const char *fmt, ...) |
8b7968f7 | 229 | GCC_FMT_ATTR(2, 3); |
2011fe56 | 230 | |
6f1de6b7 PB |
231 | /** |
232 | * @qemu_chr_fe_add_watch: | |
233 | * | |
234 | * If the backend is connected, create and add a #GSource that fires | |
235 | * when the given condition (typically G_IO_OUT|G_IO_HUP or G_IO_HUP) | |
236 | * is active; return the #GSource's tag. If it is disconnected, | |
237 | * return 0. | |
238 | * | |
239 | * @cond the condition to poll for | |
240 | * @func the function to call when the condition happens | |
241 | * @user_data the opaque pointer to pass to @func | |
242 | */ | |
243 | guint qemu_chr_fe_add_watch(CharDriverState *s, GIOCondition cond, | |
244 | GIOFunc func, void *user_data); | |
23673ca7 | 245 | |
2011fe56 AL |
246 | /** |
247 | * @qemu_chr_fe_write: | |
248 | * | |
9005b2a7 PB |
249 | * Write data to a character backend from the front end. This function |
250 | * will send data from the front end to the back end. This function | |
251 | * is thread-safe. | |
2011fe56 AL |
252 | * |
253 | * @buf the data | |
254 | * @len the number of bytes to send | |
255 | * | |
256 | * Returns: the number of bytes consumed | |
257 | */ | |
2cc6e0a1 | 258 | int qemu_chr_fe_write(CharDriverState *s, const uint8_t *buf, int len); |
2011fe56 | 259 | |
cd18720a AL |
260 | /** |
261 | * @qemu_chr_fe_write_all: | |
262 | * | |
263 | * Write data to a character backend from the front end. This function will | |
264 | * send data from the front end to the back end. Unlike @qemu_chr_fe_write, | |
265 | * this function will block if the back end cannot consume all of the data | |
9005b2a7 | 266 | * attempted to be written. This function is thread-safe. |
cd18720a AL |
267 | * |
268 | * @buf the data | |
269 | * @len the number of bytes to send | |
270 | * | |
271 | * Returns: the number of bytes consumed | |
272 | */ | |
273 | int qemu_chr_fe_write_all(CharDriverState *s, const uint8_t *buf, int len); | |
274 | ||
7b0bfdf5 NN |
275 | /** |
276 | * @qemu_chr_fe_read_all: | |
277 | * | |
278 | * Read data to a buffer from the back end. | |
279 | * | |
280 | * @buf the data buffer | |
281 | * @len the number of bytes to read | |
282 | * | |
283 | * Returns: the number of bytes read | |
284 | */ | |
285 | int qemu_chr_fe_read_all(CharDriverState *s, uint8_t *buf, int len); | |
286 | ||
2011fe56 AL |
287 | /** |
288 | * @qemu_chr_fe_ioctl: | |
289 | * | |
9005b2a7 | 290 | * Issue a device specific ioctl to a backend. This function is thread-safe. |
2011fe56 AL |
291 | * |
292 | * @cmd see CHR_IOCTL_* | |
293 | * @arg the data associated with @cmd | |
294 | * | |
295 | * Returns: if @cmd is not supported by the backend, -ENOTSUP, otherwise the | |
296 | * return value depends on the semantics of @cmd | |
297 | */ | |
298 | int qemu_chr_fe_ioctl(CharDriverState *s, int cmd, void *arg); | |
299 | ||
300 | /** | |
301 | * @qemu_chr_fe_get_msgfd: | |
302 | * | |
303 | * For backends capable of fd passing, return the latest file descriptor passed | |
304 | * by a client. | |
305 | * | |
306 | * Returns: -1 if fd passing isn't supported or there is no pending file | |
307 | * descriptor. If a file descriptor is returned, subsequent calls to | |
308 | * this function will return -1 until a client sends a new file | |
309 | * descriptor. | |
310 | */ | |
311 | int qemu_chr_fe_get_msgfd(CharDriverState *s); | |
312 | ||
c76bf6bb NN |
313 | /** |
314 | * @qemu_chr_fe_get_msgfds: | |
315 | * | |
316 | * For backends capable of fd passing, return the number of file received | |
317 | * descriptors and fills the fds array up to num elements | |
318 | * | |
319 | * Returns: -1 if fd passing isn't supported or there are no pending file | |
320 | * descriptors. If file descriptors are returned, subsequent calls to | |
321 | * this function will return -1 until a client sends a new set of file | |
322 | * descriptors. | |
323 | */ | |
324 | int qemu_chr_fe_get_msgfds(CharDriverState *s, int *fds, int num); | |
325 | ||
d39aac7a NN |
326 | /** |
327 | * @qemu_chr_fe_set_msgfds: | |
328 | * | |
329 | * For backends capable of fd passing, set an array of fds to be passed with | |
330 | * the next send operation. | |
331 | * A subsequent call to this function before calling a write function will | |
332 | * result in overwriting the fd array with the new value without being send. | |
333 | * Upon writing the message the fd array is freed. | |
334 | * | |
335 | * Returns: -1 if fd passing isn't supported. | |
336 | */ | |
337 | int qemu_chr_fe_set_msgfds(CharDriverState *s, int *fds, int num); | |
338 | ||
44c473de HG |
339 | /** |
340 | * @qemu_chr_fe_claim: | |
341 | * | |
342 | * Claim a backend before using it, should be called before calling | |
343 | * qemu_chr_add_handlers(). | |
344 | * | |
345 | * Returns: -1 if the backend is already in use by another frontend, 0 on | |
346 | * success. | |
347 | */ | |
348 | int qemu_chr_fe_claim(CharDriverState *s); | |
349 | ||
350 | /** | |
351 | * @qemu_chr_fe_claim_no_fail: | |
352 | * | |
353 | * Like qemu_chr_fe_claim, but will exit qemu with an error when the | |
354 | * backend is already in use. | |
355 | */ | |
356 | void qemu_chr_fe_claim_no_fail(CharDriverState *s); | |
357 | ||
358 | /** | |
359 | * @qemu_chr_fe_claim: | |
360 | * | |
361 | * Release a backend for use by another frontend. | |
362 | * | |
363 | * Returns: -1 if the backend is already in use by another frontend, 0 on | |
364 | * success. | |
365 | */ | |
366 | void qemu_chr_fe_release(CharDriverState *s); | |
367 | ||
2011fe56 AL |
368 | /** |
369 | * @qemu_chr_be_can_write: | |
370 | * | |
371 | * Determine how much data the front end can currently accept. This function | |
372 | * returns the number of bytes the front end can accept. If it returns 0, the | |
373 | * front end cannot receive data at the moment. The function must be polled | |
374 | * to determine when data can be received. | |
375 | * | |
376 | * Returns: the number of bytes the front end can receive via @qemu_chr_be_write | |
377 | */ | |
378 | int qemu_chr_be_can_write(CharDriverState *s); | |
379 | ||
380 | /** | |
381 | * @qemu_chr_be_write: | |
382 | * | |
383 | * Write data from the back end to the front end. Before issuing this call, | |
384 | * the caller should call @qemu_chr_be_can_write to determine how much data | |
385 | * the front end can currently accept. | |
386 | * | |
387 | * @buf a buffer to receive data from the front end | |
388 | * @len the number of bytes to receive from the front end | |
389 | */ | |
390 | void qemu_chr_be_write(CharDriverState *s, uint8_t *buf, int len); | |
391 | ||
33577b47 PD |
392 | /** |
393 | * @qemu_chr_be_write_impl: | |
394 | * | |
395 | * Implementation of back end writing. Used by replay module. | |
396 | * | |
397 | * @buf a buffer to receive data from the front end | |
398 | * @len the number of bytes to receive from the front end | |
399 | */ | |
400 | void qemu_chr_be_write_impl(CharDriverState *s, uint8_t *buf, int len); | |
a425d23f HG |
401 | |
402 | /** | |
403 | * @qemu_chr_be_event: | |
404 | * | |
405 | * Send an event from the back end to the front end. | |
406 | * | |
407 | * @event the event to send | |
408 | */ | |
409 | void qemu_chr_be_event(CharDriverState *s, int event); | |
410 | ||
87ecb68b | 411 | void qemu_chr_add_handlers(CharDriverState *s, |
7b27a769 | 412 | IOCanReadHandler *fd_can_read, |
87ecb68b PB |
413 | IOReadHandler *fd_read, |
414 | IOEventHandler *fd_event, | |
415 | void *opaque); | |
2011fe56 | 416 | |
fee204fd | 417 | void qemu_chr_be_generic_open(CharDriverState *s); |
bd9bdce6 | 418 | void qemu_chr_accept_input(CharDriverState *s); |
13661089 | 419 | int qemu_chr_add_client(CharDriverState *s, int fd); |
c845f401 | 420 | CharDriverState *qemu_chr_find(const char *name); |
8e597779 | 421 | bool chr_is_ringbuf(const CharDriverState *chr); |
87ecb68b | 422 | |
2011fe56 AL |
423 | QemuOpts *qemu_chr_parse_compat(const char *label, const char *filename); |
424 | ||
e4d50d47 | 425 | void register_char_driver(const char *name, ChardevBackendKind kind, |
4ca17281 PB |
426 | void (*parse)(QemuOpts *opts, ChardevBackend *backend, Error **errp), |
427 | CharDriverState *(*create)(const char *id, ChardevBackend *backend, | |
428 | ChardevReturn *ret, Error **errp)); | |
d654f34e | 429 | |
0e82f34d AL |
430 | extern int term_escape_char; |
431 | ||
0beb4942 | 432 | |
3840f842 | 433 | /* console.c */ |
fa19d025 | 434 | typedef CharDriverState *(VcHandler)(ChardevVC *vc, Error **errp); |
3840f842 | 435 | void register_vc_handler(VcHandler *handler); |
fa19d025 | 436 | |
87ecb68b | 437 | #endif |