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 */
17 CHR_EVENT_BREAK
, /* serial break char */
18 CHR_EVENT_OPENED
, /* new connection established */
19 CHR_EVENT_MUX_IN
, /* mux-focus was set to this terminal */
20 CHR_EVENT_MUX_OUT
, /* mux-focus will move on */
21 CHR_EVENT_CLOSED
/* connection closed */
25 #define CHR_IOCTL_SERIAL_SET_PARAMS 1
31 } QEMUSerialSetParams
;
33 #define CHR_IOCTL_SERIAL_SET_BREAK 2
35 #define CHR_IOCTL_PP_READ_DATA 3
36 #define CHR_IOCTL_PP_WRITE_DATA 4
37 #define CHR_IOCTL_PP_READ_CONTROL 5
38 #define CHR_IOCTL_PP_WRITE_CONTROL 6
39 #define CHR_IOCTL_PP_READ_STATUS 7
40 #define CHR_IOCTL_PP_EPP_READ_ADDR 8
41 #define CHR_IOCTL_PP_EPP_READ 9
42 #define CHR_IOCTL_PP_EPP_WRITE_ADDR 10
43 #define CHR_IOCTL_PP_EPP_WRITE 11
44 #define CHR_IOCTL_PP_DATA_DIR 12
46 struct ParallelIOArg
{
51 #define CHR_IOCTL_SERIAL_SET_TIOCM 13
52 #define CHR_IOCTL_SERIAL_GET_TIOCM 14
54 #define CHR_TIOCM_CTS 0x020
55 #define CHR_TIOCM_CAR 0x040
56 #define CHR_TIOCM_DSR 0x100
57 #define CHR_TIOCM_RI 0x080
58 #define CHR_TIOCM_DTR 0x002
59 #define CHR_TIOCM_RTS 0x004
61 typedef void IOEventHandler(void *opaque
, int event
);
64 /* Whether the chardev peer is able to close and
65 * reopen the data channel, thus requiring support
66 * for qemu_chr_wait_connected() to wait for a
68 QEMU_CHAR_FEATURE_RECONNECTABLE
,
69 /* Whether it is possible to send/recv file descriptors
70 * over the data channel */
71 QEMU_CHAR_FEATURE_FD_PASS
,
72 /* Whether replay or record mode is enabled */
73 QEMU_CHAR_FEATURE_REPLAY
,
75 QEMU_CHAR_FEATURE_LAST
,
78 /* This is the backend as seen by frontend, the actual backend is
80 typedef struct CharBackend
{
82 IOEventHandler
*chr_event
;
83 IOCanReadHandler
*chr_can_read
;
84 IOReadHandler
*chr_read
;
90 typedef struct CharDriver CharDriver
;
93 const CharDriver
*driver
;
94 QemuMutex chr_write_lock
;
101 DECLARE_BITMAP(features
, QEMU_CHAR_FEATURE_LAST
);
102 QTAILQ_ENTRY(Chardev
) next
;
107 * @backend: the common backend config
108 * @errp: pointer to a NULL-initialized error object
110 * Allocate and initialize a new Chardev.
112 * Returns: a newly allocated Chardev, or NULL on error.
114 Chardev
*qemu_chr_alloc(const CharDriver
*driver
,
115 ChardevCommon
*backend
, Error
**errp
);
118 * @qemu_chr_new_from_opts:
120 * Create a new character backend from a QemuOpts list.
122 * @opts see qemu-config.c for a list of valid options
124 * Returns: a new character backend
126 Chardev
*qemu_chr_new_from_opts(QemuOpts
*opts
,
130 * @qemu_chr_parse_common:
132 * Parse the common options available to all character backends.
134 * @opts the options that still need parsing
135 * @backend a new backend
137 void qemu_chr_parse_common(QemuOpts
*opts
, ChardevCommon
*backend
);
142 * Create a new character backend from a URI.
144 * @label the name of the backend
147 * Returns: a new character backend
149 Chardev
*qemu_chr_new(const char *label
, const char *filename
);
153 * @qemu_chr_fe_disconnect:
155 * Close a fd accpeted by character backend.
156 * Without associated CharDriver, do nothing.
158 void qemu_chr_fe_disconnect(CharBackend
*be
);
163 * Delete all chardevs (when leaving qemu)
165 void qemu_chr_cleanup(void);
168 * @qemu_chr_fe_wait_connected:
170 * Wait for characted backend to be connected, return < 0 on error or
171 * if no assicated CharDriver.
173 int qemu_chr_fe_wait_connected(CharBackend
*be
, Error
**errp
);
176 * @qemu_chr_new_noreplay:
178 * Create a new character backend from a URI.
179 * Character device communications are not written
180 * into the replay log.
182 * @label the name of the backend
185 * Returns: a new character backend
187 Chardev
*qemu_chr_new_noreplay(const char *label
, const char *filename
);
192 * Destroy a character backend and remove it from the list of
193 * identified character backends.
195 void qemu_chr_delete(Chardev
*chr
);
200 * Destroy a character backend.
202 void qemu_chr_free(Chardev
*chr
);
205 * @qemu_chr_fe_set_echo:
207 * Ask the backend to override its normal echo setting. This only really
208 * applies to the stdio backend and is used by the QMP server such that you
209 * can see what you type if you try to type QMP commands.
210 * Without associated CharDriver, do nothing.
212 * @echo true to enable echo, false to disable echo
214 void qemu_chr_fe_set_echo(CharBackend
*be
, bool echo
);
217 * @qemu_chr_fe_set_open:
219 * Set character frontend open status. This is an indication that the
220 * front end is ready (or not) to begin doing I/O.
221 * Without associated CharDriver, do nothing.
223 void qemu_chr_fe_set_open(CharBackend
*be
, int fe_open
);
226 * @qemu_chr_fe_printf:
228 * Write to a character backend using a printf style interface. This
229 * function is thread-safe. It does nothing without associated
234 void qemu_chr_fe_printf(CharBackend
*be
, const char *fmt
, ...)
238 * @qemu_chr_fe_add_watch:
240 * If the backend is connected, create and add a #GSource that fires
241 * when the given condition (typically G_IO_OUT|G_IO_HUP or G_IO_HUP)
242 * is active; return the #GSource's tag. If it is disconnected,
243 * or without associated CharDriver, return 0.
245 * @cond the condition to poll for
246 * @func the function to call when the condition happens
247 * @user_data the opaque pointer to pass to @func
249 * Returns: the source tag
251 guint
qemu_chr_fe_add_watch(CharBackend
*be
, GIOCondition cond
,
252 GIOFunc func
, void *user_data
);
255 * @qemu_chr_fe_write:
257 * Write data to a character backend from the front end. This function
258 * will send data from the front end to the back end. This function
262 * @len the number of bytes to send
264 * Returns: the number of bytes consumed (0 if no assicated CharDriver)
266 int qemu_chr_fe_write(CharBackend
*be
, const uint8_t *buf
, int len
);
269 * @qemu_chr_fe_write_all:
271 * Write data to a character backend from the front end. This function will
272 * send data from the front end to the back end. Unlike @qemu_chr_fe_write,
273 * this function will block if the back end cannot consume all of the data
274 * attempted to be written. This function is thread-safe.
277 * @len the number of bytes to send
279 * Returns: the number of bytes consumed (0 if no assicated CharDriver)
281 int qemu_chr_fe_write_all(CharBackend
*be
, const uint8_t *buf
, int len
);
284 * @qemu_chr_fe_read_all:
286 * Read data to a buffer from the back end.
288 * @buf the data buffer
289 * @len the number of bytes to read
291 * Returns: the number of bytes read (0 if no assicated CharDriver)
293 int qemu_chr_fe_read_all(CharBackend
*be
, uint8_t *buf
, int len
);
296 * @qemu_chr_fe_ioctl:
298 * Issue a device specific ioctl to a backend. This function is thread-safe.
300 * @cmd see CHR_IOCTL_*
301 * @arg the data associated with @cmd
303 * Returns: if @cmd is not supported by the backend or there is no
304 * associated CharDriver, -ENOTSUP, otherwise the return
305 * value depends on the semantics of @cmd
307 int qemu_chr_fe_ioctl(CharBackend
*be
, int cmd
, void *arg
);
310 * @qemu_chr_fe_get_msgfd:
312 * For backends capable of fd passing, return the latest file descriptor passed
315 * Returns: -1 if fd passing isn't supported or there is no pending file
316 * descriptor. If a file descriptor is returned, subsequent calls to
317 * this function will return -1 until a client sends a new file
320 int qemu_chr_fe_get_msgfd(CharBackend
*be
);
323 * @qemu_chr_fe_get_msgfds:
325 * For backends capable of fd passing, return the number of file received
326 * descriptors and fills the fds array up to num elements
328 * Returns: -1 if fd passing isn't supported or there are no pending file
329 * descriptors. If file descriptors are returned, subsequent calls to
330 * this function will return -1 until a client sends a new set of file
333 int qemu_chr_fe_get_msgfds(CharBackend
*be
, int *fds
, int num
);
336 * @qemu_chr_fe_set_msgfds:
338 * For backends capable of fd passing, set an array of fds to be passed with
339 * the next send operation.
340 * A subsequent call to this function before calling a write function will
341 * result in overwriting the fd array with the new value without being send.
342 * Upon writing the message the fd array is freed.
344 * Returns: -1 if fd passing isn't supported or no associated CharDriver.
346 int qemu_chr_fe_set_msgfds(CharBackend
*be
, int *fds
, int num
);
349 * @qemu_chr_be_can_write:
351 * Determine how much data the front end can currently accept. This function
352 * returns the number of bytes the front end can accept. If it returns 0, the
353 * front end cannot receive data at the moment. The function must be polled
354 * to determine when data can be received.
356 * Returns: the number of bytes the front end can receive via @qemu_chr_be_write
358 int qemu_chr_be_can_write(Chardev
*s
);
361 * @qemu_chr_be_write:
363 * Write data from the back end to the front end. Before issuing this call,
364 * the caller should call @qemu_chr_be_can_write to determine how much data
365 * the front end can currently accept.
367 * @buf a buffer to receive data from the front end
368 * @len the number of bytes to receive from the front end
370 void qemu_chr_be_write(Chardev
*s
, uint8_t *buf
, int len
);
373 * @qemu_chr_be_write_impl:
375 * Implementation of back end writing. Used by replay module.
377 * @buf a buffer to receive data from the front end
378 * @len the number of bytes to receive from the front end
380 void qemu_chr_be_write_impl(Chardev
*s
, uint8_t *buf
, int len
);
383 * @qemu_chr_be_event:
385 * Send an event from the back end to the front end.
387 * @event the event to send
389 void qemu_chr_be_event(Chardev
*s
, int event
);
394 * Initializes a front end for the given CharBackend and
395 * CharDriver. Call qemu_chr_fe_deinit() to remove the association and
396 * release the driver.
398 * Returns: false on error.
400 bool qemu_chr_fe_init(CharBackend
*b
, Chardev
*s
, Error
**errp
);
403 * @qemu_chr_fe_get_driver:
405 * Returns the driver associated with a CharBackend or NULL if no
406 * associated CharDriver.
408 Chardev
*qemu_chr_fe_get_driver(CharBackend
*be
);
411 * @qemu_chr_fe_deinit:
413 * Dissociate the CharBackend from the CharDriver.
415 * Safe to call without associated CharDriver.
417 void qemu_chr_fe_deinit(CharBackend
*b
);
420 * @qemu_chr_fe_set_handlers:
422 * @fd_can_read: callback to get the amount of data the frontend may
424 * @fd_read: callback to receive data from char
425 * @fd_event: event callback
426 * @opaque: an opaque pointer for the callbacks
427 * @context: a main loop context or NULL for the default
428 * @set_open: whether to call qemu_chr_fe_set_open() implicitely when
429 * any of the handler is non-NULL
431 * Set the front end char handlers. The front end takes the focus if
432 * any of the handler is non-NULL.
434 * Without associated CharDriver, nothing is changed.
436 void qemu_chr_fe_set_handlers(CharBackend
*b
,
437 IOCanReadHandler
*fd_can_read
,
438 IOReadHandler
*fd_read
,
439 IOEventHandler
*fd_event
,
441 GMainContext
*context
,
445 * @qemu_chr_fe_take_focus:
447 * Take the focus (if the front end is muxed).
449 * Without associated CharDriver, nothing is changed.
451 void qemu_chr_fe_take_focus(CharBackend
*b
);
453 void qemu_chr_be_generic_open(Chardev
*s
);
454 void qemu_chr_fe_accept_input(CharBackend
*be
);
455 int qemu_chr_add_client(Chardev
*s
, int fd
);
456 Chardev
*qemu_chr_find(const char *name
);
459 * @qemu_chr_get_kind:
461 * Returns the kind of char backend, or -1 if unspecified.
463 ChardevBackendKind
qemu_chr_get_kind(const Chardev
*chr
);
465 static inline bool qemu_chr_is_ringbuf(const Chardev
*chr
)
467 return qemu_chr_get_kind(chr
) == CHARDEV_BACKEND_KIND_RINGBUF
||
468 qemu_chr_get_kind(chr
) == CHARDEV_BACKEND_KIND_MEMORY
;
471 bool qemu_chr_has_feature(Chardev
*chr
,
472 CharDriverFeature feature
);
473 void qemu_chr_set_feature(Chardev
*chr
,
474 CharDriverFeature feature
);
475 QemuOpts
*qemu_chr_parse_compat(const char *label
, const char *filename
);
478 ChardevBackendKind kind
;
480 void (*parse
)(QemuOpts
*opts
, ChardevBackend
*backend
, Error
**errp
);
481 Chardev
*(*create
)(const CharDriver
*driver
,
483 ChardevBackend
*backend
,
484 ChardevReturn
*ret
, bool *be_opened
,
486 size_t instance_size
;
488 int (*chr_write
)(struct Chardev
*s
, const uint8_t *buf
, int len
);
489 int (*chr_sync_read
)(struct Chardev
*s
,
490 const uint8_t *buf
, int len
);
491 GSource
*(*chr_add_watch
)(struct Chardev
*s
, GIOCondition cond
);
492 void (*chr_update_read_handler
)(struct Chardev
*s
,
493 GMainContext
*context
);
494 int (*chr_ioctl
)(struct Chardev
*s
, int cmd
, void *arg
);
495 int (*get_msgfds
)(struct Chardev
*s
, int* fds
, int num
);
496 int (*set_msgfds
)(struct Chardev
*s
, int *fds
, int num
);
497 int (*chr_add_client
)(struct Chardev
*chr
, int fd
);
498 int (*chr_wait_connected
)(struct Chardev
*chr
, Error
**errp
);
499 void (*chr_free
)(struct Chardev
*chr
);
500 void (*chr_disconnect
)(struct Chardev
*chr
);
501 void (*chr_accept_input
)(struct Chardev
*chr
);
502 void (*chr_set_echo
)(struct Chardev
*chr
, bool echo
);
503 void (*chr_set_fe_open
)(struct Chardev
*chr
, int fe_open
);
506 void register_char_driver(const CharDriver
*driver
);
508 extern int term_escape_char
;
511 void qemu_chr_parse_vc(QemuOpts
*opts
, ChardevBackend
*backend
, Error
**errp
);