4 #include "qemu-common.h"
5 #include "qemu/queue.h"
6 #include "qemu/option.h"
7 #include "qemu/config-file.h"
9 #include "qapi/qmp/qobject.h"
10 #include "qapi/qmp/qstring.h"
11 #include "qemu/main-loop.h"
12 #include "qemu/bitmap.h"
14 /* character device */
16 #define CHR_EVENT_BREAK 0 /* serial break char */
17 #define CHR_EVENT_FOCUS 1 /* focus to this terminal (modal input needed) */
18 #define CHR_EVENT_OPENED 2 /* new connection established */
19 #define CHR_EVENT_MUX_IN 3 /* mux-focus was set to this terminal */
20 #define CHR_EVENT_MUX_OUT 4 /* mux-focus will move on */
21 #define CHR_EVENT_CLOSED 5 /* connection closed */
24 #define CHR_IOCTL_SERIAL_SET_PARAMS 1
30 } QEMUSerialSetParams
;
32 #define CHR_IOCTL_SERIAL_SET_BREAK 2
34 #define CHR_IOCTL_PP_READ_DATA 3
35 #define CHR_IOCTL_PP_WRITE_DATA 4
36 #define CHR_IOCTL_PP_READ_CONTROL 5
37 #define CHR_IOCTL_PP_WRITE_CONTROL 6
38 #define CHR_IOCTL_PP_READ_STATUS 7
39 #define CHR_IOCTL_PP_EPP_READ_ADDR 8
40 #define CHR_IOCTL_PP_EPP_READ 9
41 #define CHR_IOCTL_PP_EPP_WRITE_ADDR 10
42 #define CHR_IOCTL_PP_EPP_WRITE 11
43 #define CHR_IOCTL_PP_DATA_DIR 12
45 struct ParallelIOArg
{
50 #define CHR_IOCTL_SERIAL_SET_TIOCM 13
51 #define CHR_IOCTL_SERIAL_GET_TIOCM 14
53 #define CHR_TIOCM_CTS 0x020
54 #define CHR_TIOCM_CAR 0x040
55 #define CHR_TIOCM_DSR 0x100
56 #define CHR_TIOCM_RI 0x080
57 #define CHR_TIOCM_DTR 0x002
58 #define CHR_TIOCM_RTS 0x004
60 typedef void IOEventHandler(void *opaque
, int event
);
63 /* Whether the chardev peer is able to close and
64 * reopen the data channel, thus requiring support
65 * for qemu_chr_wait_connected() to wait for a
67 QEMU_CHAR_FEATURE_RECONNECTABLE
,
68 /* Whether it is possible to send/recv file descriptors
69 * over the data channel */
70 QEMU_CHAR_FEATURE_FD_PASS
,
72 QEMU_CHAR_FEATURE_LAST
,
75 /* This is the backend as seen by frontend, the actual backend is
77 typedef struct CharBackend
{
79 IOEventHandler
*chr_event
;
80 IOCanReadHandler
*chr_can_read
;
81 IOReadHandler
*chr_read
;
86 struct CharDriverState
{
87 QemuMutex chr_write_lock
;
88 int (*chr_write
)(struct CharDriverState
*s
, const uint8_t *buf
, int len
);
89 int (*chr_sync_read
)(struct CharDriverState
*s
,
90 const uint8_t *buf
, int len
);
91 GSource
*(*chr_add_watch
)(struct CharDriverState
*s
, GIOCondition cond
);
92 void (*chr_update_read_handler
)(struct CharDriverState
*s
,
93 GMainContext
*context
);
94 int (*chr_ioctl
)(struct CharDriverState
*s
, int cmd
, void *arg
);
95 int (*get_msgfds
)(struct CharDriverState
*s
, int* fds
, int num
);
96 int (*set_msgfds
)(struct CharDriverState
*s
, int *fds
, int num
);
97 int (*chr_add_client
)(struct CharDriverState
*chr
, int fd
);
98 int (*chr_wait_connected
)(struct CharDriverState
*chr
, Error
**errp
);
99 void (*chr_close
)(struct CharDriverState
*chr
);
100 void (*chr_disconnect
)(struct CharDriverState
*chr
);
101 void (*chr_accept_input
)(struct CharDriverState
*chr
);
102 void (*chr_set_echo
)(struct CharDriverState
*chr
, bool echo
);
103 void (*chr_set_fe_open
)(struct CharDriverState
*chr
, int fe_open
);
104 void (*chr_fe_event
)(struct CharDriverState
*chr
, int event
);
112 int explicit_fe_open
;
113 int explicit_be_open
;
114 int avail_connections
;
118 DECLARE_BITMAP(features
, QEMU_CHAR_FEATURE_LAST
);
119 QTAILQ_ENTRY(CharDriverState
) next
;
124 * @backend: the common backend config
125 * @errp: pointer to a NULL-initialized error object
127 * Allocate and initialize a new CharDriverState.
129 * Returns: a newly allocated CharDriverState, or NULL on error.
131 CharDriverState
*qemu_chr_alloc(ChardevCommon
*backend
, Error
**errp
);
134 * @qemu_chr_new_from_opts:
136 * Create a new character backend from a QemuOpts list.
138 * @opts see qemu-config.c for a list of valid options
140 * Returns: a new character backend
142 CharDriverState
*qemu_chr_new_from_opts(QemuOpts
*opts
,
146 * @qemu_chr_parse_common:
148 * Parse the common options available to all character backends.
150 * @opts the options that still need parsing
151 * @backend a new backend
153 void qemu_chr_parse_common(QemuOpts
*opts
, ChardevCommon
*backend
);
158 * Create a new character backend from a URI.
160 * @label the name of the backend
163 * Returns: a new character backend
165 CharDriverState
*qemu_chr_new(const char *label
, const char *filename
);
169 * @qemu_chr_fe_disconnect:
171 * Close a fd accpeted by character backend.
172 * Without associated CharDriver, do nothing.
174 void qemu_chr_fe_disconnect(CharBackend
*be
);
179 * Delete all chardevs (when leaving qemu)
181 void qemu_chr_cleanup(void);
184 * @qemu_chr_fe_wait_connected:
186 * Wait for characted backend to be connected, return < 0 on error or
187 * if no assicated CharDriver.
189 int qemu_chr_fe_wait_connected(CharBackend
*be
, Error
**errp
);
192 * @qemu_chr_new_noreplay:
194 * Create a new character backend from a URI.
195 * Character device communications are not written
196 * into the replay log.
198 * @label the name of the backend
201 * Returns: a new character backend
203 CharDriverState
*qemu_chr_new_noreplay(const char *label
, const char *filename
);
208 * Destroy a character backend and remove it from the list of
209 * identified character backends.
211 void qemu_chr_delete(CharDriverState
*chr
);
216 * Destroy a character backend.
218 void qemu_chr_free(CharDriverState
*chr
);
221 * @qemu_chr_fe_set_echo:
223 * Ask the backend to override its normal echo setting. This only really
224 * applies to the stdio backend and is used by the QMP server such that you
225 * can see what you type if you try to type QMP commands.
226 * Without associated CharDriver, do nothing.
228 * @echo true to enable echo, false to disable echo
230 void qemu_chr_fe_set_echo(CharBackend
*be
, bool echo
);
233 * @qemu_chr_fe_set_open:
235 * Set character frontend open status. This is an indication that the
236 * front end is ready (or not) to begin doing I/O.
237 * Without associated CharDriver, do nothing.
239 void qemu_chr_fe_set_open(CharBackend
*be
, int fe_open
);
242 * @qemu_chr_fe_event:
244 * Send an event from the front end to the back end. It does nothing
245 * without associated CharDriver.
247 * @event the event to send
249 void qemu_chr_fe_event(CharBackend
*be
, int event
);
252 * @qemu_chr_fe_printf:
254 * Write to a character backend using a printf style interface. This
255 * function is thread-safe. It does nothing without associated
260 void qemu_chr_fe_printf(CharBackend
*be
, const char *fmt
, ...)
264 * @qemu_chr_fe_add_watch:
266 * If the backend is connected, create and add a #GSource that fires
267 * when the given condition (typically G_IO_OUT|G_IO_HUP or G_IO_HUP)
268 * is active; return the #GSource's tag. If it is disconnected,
269 * or without associated CharDriver, return 0.
271 * @cond the condition to poll for
272 * @func the function to call when the condition happens
273 * @user_data the opaque pointer to pass to @func
275 guint
qemu_chr_fe_add_watch(CharBackend
*be
, GIOCondition cond
,
276 GIOFunc func
, void *user_data
);
279 * @qemu_chr_fe_write:
281 * Write data to a character backend from the front end. This function
282 * will send data from the front end to the back end. This function
286 * @len the number of bytes to send
288 * Returns: the number of bytes consumed (0 if no assicated CharDriver)
290 int qemu_chr_fe_write(CharBackend
*be
, const uint8_t *buf
, int len
);
293 * @qemu_chr_fe_write_all:
295 * Write data to a character backend from the front end. This function will
296 * send data from the front end to the back end. Unlike @qemu_chr_fe_write,
297 * this function will block if the back end cannot consume all of the data
298 * attempted to be written. This function is thread-safe.
301 * @len the number of bytes to send
303 * Returns: the number of bytes consumed (0 if no assicated CharDriver)
305 int qemu_chr_fe_write_all(CharBackend
*be
, const uint8_t *buf
, int len
);
308 * @qemu_chr_fe_read_all:
310 * Read data to a buffer from the back end.
312 * @buf the data buffer
313 * @len the number of bytes to read
315 * Returns: the number of bytes read (0 if no assicated CharDriver)
317 int qemu_chr_fe_read_all(CharBackend
*be
, uint8_t *buf
, int len
);
320 * @qemu_chr_fe_ioctl:
322 * Issue a device specific ioctl to a backend. This function is thread-safe.
324 * @cmd see CHR_IOCTL_*
325 * @arg the data associated with @cmd
327 * Returns: if @cmd is not supported by the backend or there is no
328 * associated CharDriver, -ENOTSUP, otherwise the return
329 * value depends on the semantics of @cmd
331 int qemu_chr_fe_ioctl(CharBackend
*be
, int cmd
, void *arg
);
334 * @qemu_chr_fe_get_msgfd:
336 * For backends capable of fd passing, return the latest file descriptor passed
339 * Returns: -1 if fd passing isn't supported or there is no pending file
340 * descriptor. If a file descriptor is returned, subsequent calls to
341 * this function will return -1 until a client sends a new file
344 int qemu_chr_fe_get_msgfd(CharBackend
*be
);
347 * @qemu_chr_fe_get_msgfds:
349 * For backends capable of fd passing, return the number of file received
350 * descriptors and fills the fds array up to num elements
352 * Returns: -1 if fd passing isn't supported or there are no pending file
353 * descriptors. If file descriptors are returned, subsequent calls to
354 * this function will return -1 until a client sends a new set of file
357 int qemu_chr_fe_get_msgfds(CharBackend
*be
, int *fds
, int num
);
360 * @qemu_chr_fe_set_msgfds:
362 * For backends capable of fd passing, set an array of fds to be passed with
363 * the next send operation.
364 * A subsequent call to this function before calling a write function will
365 * result in overwriting the fd array with the new value without being send.
366 * Upon writing the message the fd array is freed.
368 * Returns: -1 if fd passing isn't supported or no associated CharDriver.
370 int qemu_chr_fe_set_msgfds(CharBackend
*be
, int *fds
, int num
);
373 * @qemu_chr_be_can_write:
375 * Determine how much data the front end can currently accept. This function
376 * returns the number of bytes the front end can accept. If it returns 0, the
377 * front end cannot receive data at the moment. The function must be polled
378 * to determine when data can be received.
380 * Returns: the number of bytes the front end can receive via @qemu_chr_be_write
382 int qemu_chr_be_can_write(CharDriverState
*s
);
385 * @qemu_chr_be_write:
387 * Write data from the back end to the front end. Before issuing this call,
388 * the caller should call @qemu_chr_be_can_write to determine how much data
389 * the front end can currently accept.
391 * @buf a buffer to receive data from the front end
392 * @len the number of bytes to receive from the front end
394 void qemu_chr_be_write(CharDriverState
*s
, uint8_t *buf
, int len
);
397 * @qemu_chr_be_write_impl:
399 * Implementation of back end writing. Used by replay module.
401 * @buf a buffer to receive data from the front end
402 * @len the number of bytes to receive from the front end
404 void qemu_chr_be_write_impl(CharDriverState
*s
, uint8_t *buf
, int len
);
407 * @qemu_chr_be_event:
409 * Send an event from the back end to the front end.
411 * @event the event to send
413 void qemu_chr_be_event(CharDriverState
*s
, int event
);
418 * Initializes a front end for the given CharBackend and
419 * CharDriver. Call qemu_chr_fe_deinit() to remove the association and
420 * release the driver.
422 * Returns: false on error.
424 bool qemu_chr_fe_init(CharBackend
*b
, CharDriverState
*s
, Error
**errp
);
427 * @qemu_chr_fe_get_driver:
429 * Returns the driver associated with a CharBackend or NULL if no
430 * associated CharDriver.
432 CharDriverState
*qemu_chr_fe_get_driver(CharBackend
*be
);
435 * @qemu_chr_fe_deinit:
437 * Dissociate the CharBackend from the CharDriver.
439 * Safe to call without associated CharDriver.
441 void qemu_chr_fe_deinit(CharBackend
*b
);
444 * @qemu_chr_fe_set_handlers:
446 * @fd_can_read: callback to get the amount of data the frontend may
448 * @fd_read: callback to receive data from char
449 * @fd_event: event callback
450 * @opaque: an opaque pointer for the callbacks
451 * @context: a main loop context or NULL for the default
453 * Set the front end char handlers. The front end takes the focus if
454 * any of the handler is non-NULL.
456 * Without associated CharDriver, nothing is changed.
458 void qemu_chr_fe_set_handlers(CharBackend
*b
,
459 IOCanReadHandler
*fd_can_read
,
460 IOReadHandler
*fd_read
,
461 IOEventHandler
*fd_event
,
463 GMainContext
*context
);
466 * @qemu_chr_fe_take_focus:
468 * Take the focus (if the front end is muxed).
470 * Without associated CharDriver, nothing is changed.
472 void qemu_chr_fe_take_focus(CharBackend
*b
);
474 void qemu_chr_be_generic_open(CharDriverState
*s
);
475 void qemu_chr_fe_accept_input(CharBackend
*be
);
476 int qemu_chr_add_client(CharDriverState
*s
, int fd
);
477 CharDriverState
*qemu_chr_find(const char *name
);
478 bool chr_is_ringbuf(const CharDriverState
*chr
);
480 bool qemu_chr_has_feature(CharDriverState
*chr
,
481 CharDriverFeature feature
);
482 void qemu_chr_set_feature(CharDriverState
*chr
,
483 CharDriverFeature feature
);
484 QemuOpts
*qemu_chr_parse_compat(const char *label
, const char *filename
);
486 void register_char_driver(const char *name
, ChardevBackendKind kind
,
487 void (*parse
)(QemuOpts
*opts
, ChardevBackend
*backend
, Error
**errp
),
488 CharDriverState
*(*create
)(const char *id
, ChardevBackend
*backend
,
489 ChardevReturn
*ret
, Error
**errp
));
491 extern int term_escape_char
;
495 typedef CharDriverState
*(VcHandler
)(ChardevVC
*vc
, Error
**errp
);
496 void register_vc_handler(VcHandler
*handler
);