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"
13 /* character device */
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 */
23 #define CHR_IOCTL_SERIAL_SET_PARAMS 1
29 } QEMUSerialSetParams
;
31 #define CHR_IOCTL_SERIAL_SET_BREAK 2
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
44 struct ParallelIOArg
{
49 #define CHR_IOCTL_SERIAL_SET_TIOCM 13
50 #define CHR_IOCTL_SERIAL_GET_TIOCM 14
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
59 typedef void IOEventHandler(void *opaque
, int event
);
61 struct CharDriverState
{
62 QemuMutex chr_write_lock
;
63 void (*init
)(struct CharDriverState
*s
);
64 int (*chr_write
)(struct CharDriverState
*s
, const uint8_t *buf
, int len
);
65 int (*chr_sync_read
)(struct CharDriverState
*s
,
66 const uint8_t *buf
, int len
);
67 GSource
*(*chr_add_watch
)(struct CharDriverState
*s
, GIOCondition cond
);
68 void (*chr_update_read_handler
)(struct CharDriverState
*s
,
69 GMainContext
*context
);
70 int (*chr_ioctl
)(struct CharDriverState
*s
, int cmd
, void *arg
);
71 int (*get_msgfds
)(struct CharDriverState
*s
, int* fds
, int num
);
72 int (*set_msgfds
)(struct CharDriverState
*s
, int *fds
, int num
);
73 int (*chr_add_client
)(struct CharDriverState
*chr
, int fd
);
74 int (*chr_wait_connected
)(struct CharDriverState
*chr
, Error
**errp
);
75 IOEventHandler
*chr_event
;
76 IOCanReadHandler
*chr_can_read
;
77 IOReadHandler
*chr_read
;
79 void (*chr_close
)(struct CharDriverState
*chr
);
80 void (*chr_disconnect
)(struct CharDriverState
*chr
);
81 void (*chr_accept_input
)(struct CharDriverState
*chr
);
82 void (*chr_set_echo
)(struct CharDriverState
*chr
, bool echo
);
83 void (*chr_set_fe_open
)(struct CharDriverState
*chr
, int fe_open
);
84 void (*chr_fe_event
)(struct CharDriverState
*chr
, int event
);
93 int avail_connections
;
99 QTAILQ_ENTRY(CharDriverState
) next
;
104 * @backend: the common backend config
105 * @errp: pointer to a NULL-initialized error object
107 * Allocate and initialize a new CharDriverState.
109 * Returns: a newly allocated CharDriverState, or NULL on error.
111 CharDriverState
*qemu_chr_alloc(ChardevCommon
*backend
, Error
**errp
);
114 * @qemu_chr_new_from_opts:
116 * Create a new character backend from a QemuOpts list.
118 * @opts see qemu-config.c for a list of valid options
121 * Returns: a new character backend
123 CharDriverState
*qemu_chr_new_from_opts(QemuOpts
*opts
,
124 void (*init
)(struct CharDriverState
*s
),
128 * @qemu_chr_parse_common:
130 * Parse the common options available to all character backends.
132 * @opts the options that still need parsing
133 * @backend a new backend
135 void qemu_chr_parse_common(QemuOpts
*opts
, ChardevCommon
*backend
);
140 * Create a new character backend from a URI.
142 * @label the name of the backend
146 * Returns: a new character backend
148 CharDriverState
*qemu_chr_new(const char *label
, const char *filename
,
149 void (*init
)(struct CharDriverState
*s
));
151 * @qemu_chr_disconnect:
153 * Close a fd accpeted by character backend.
155 void qemu_chr_disconnect(CharDriverState
*chr
);
160 * Delete all chardevs (when leaving qemu)
162 void qemu_chr_cleanup(void);
165 * @qemu_chr_wait_connected:
167 * Wait for characted backend to be connected.
169 int qemu_chr_wait_connected(CharDriverState
*chr
, Error
**errp
);
172 * @qemu_chr_new_noreplay:
174 * Create a new character backend from a URI.
175 * Character device communications are not written
176 * into the replay log.
178 * @label the name of the backend
182 * Returns: a new character backend
184 CharDriverState
*qemu_chr_new_noreplay(const char *label
, const char *filename
,
185 void (*init
)(struct CharDriverState
*s
));
190 * Destroy a character backend and remove it from the list of
191 * identified character backends.
193 void qemu_chr_delete(CharDriverState
*chr
);
198 * Destroy a character backend.
200 void qemu_chr_free(CharDriverState
*chr
);
203 * @qemu_chr_fe_set_echo:
205 * Ask the backend to override its normal echo setting. This only really
206 * applies to the stdio backend and is used by the QMP server such that you
207 * can see what you type if you try to type QMP commands.
209 * @echo true to enable echo, false to disable echo
211 void qemu_chr_fe_set_echo(struct CharDriverState
*chr
, bool echo
);
214 * @qemu_chr_fe_set_open:
216 * Set character frontend open status. This is an indication that the
217 * front end is ready (or not) to begin doing I/O.
219 void qemu_chr_fe_set_open(struct CharDriverState
*chr
, int fe_open
);
222 * @qemu_chr_fe_event:
224 * Send an event from the front end to the back end.
226 * @event the event to send
228 void qemu_chr_fe_event(CharDriverState
*s
, int event
);
231 * @qemu_chr_fe_printf:
233 * Write to a character backend using a printf style interface.
234 * This function is thread-safe.
238 void qemu_chr_fe_printf(CharDriverState
*s
, const char *fmt
, ...)
242 * @qemu_chr_fe_add_watch:
244 * If the backend is connected, create and add a #GSource that fires
245 * when the given condition (typically G_IO_OUT|G_IO_HUP or G_IO_HUP)
246 * is active; return the #GSource's tag. If it is disconnected,
249 * @cond the condition to poll for
250 * @func the function to call when the condition happens
251 * @user_data the opaque pointer to pass to @func
253 guint
qemu_chr_fe_add_watch(CharDriverState
*s
, GIOCondition cond
,
254 GIOFunc func
, void *user_data
);
257 * @qemu_chr_fe_write:
259 * Write data to a character backend from the front end. This function
260 * will send data from the front end to the back end. This function
264 * @len the number of bytes to send
266 * Returns: the number of bytes consumed
268 int qemu_chr_fe_write(CharDriverState
*s
, const uint8_t *buf
, int len
);
271 * @qemu_chr_fe_write_all:
273 * Write data to a character backend from the front end. This function will
274 * send data from the front end to the back end. Unlike @qemu_chr_fe_write,
275 * this function will block if the back end cannot consume all of the data
276 * attempted to be written. This function is thread-safe.
279 * @len the number of bytes to send
281 * Returns: the number of bytes consumed
283 int qemu_chr_fe_write_all(CharDriverState
*s
, const uint8_t *buf
, int len
);
286 * @qemu_chr_fe_read_all:
288 * Read data to a buffer from the back end.
290 * @buf the data buffer
291 * @len the number of bytes to read
293 * Returns: the number of bytes read
295 int qemu_chr_fe_read_all(CharDriverState
*s
, uint8_t *buf
, int len
);
298 * @qemu_chr_fe_ioctl:
300 * Issue a device specific ioctl to a backend. This function is thread-safe.
302 * @cmd see CHR_IOCTL_*
303 * @arg the data associated with @cmd
305 * Returns: if @cmd is not supported by the backend, -ENOTSUP, otherwise the
306 * return value depends on the semantics of @cmd
308 int qemu_chr_fe_ioctl(CharDriverState
*s
, int cmd
, void *arg
);
311 * @qemu_chr_fe_get_msgfd:
313 * For backends capable of fd passing, return the latest file descriptor passed
316 * Returns: -1 if fd passing isn't supported or there is no pending file
317 * descriptor. If a file descriptor is returned, subsequent calls to
318 * this function will return -1 until a client sends a new file
321 int qemu_chr_fe_get_msgfd(CharDriverState
*s
);
324 * @qemu_chr_fe_get_msgfds:
326 * For backends capable of fd passing, return the number of file received
327 * descriptors and fills the fds array up to num elements
329 * Returns: -1 if fd passing isn't supported or there are no pending file
330 * descriptors. If file descriptors are returned, subsequent calls to
331 * this function will return -1 until a client sends a new set of file
334 int qemu_chr_fe_get_msgfds(CharDriverState
*s
, int *fds
, int num
);
337 * @qemu_chr_fe_set_msgfds:
339 * For backends capable of fd passing, set an array of fds to be passed with
340 * the next send operation.
341 * A subsequent call to this function before calling a write function will
342 * result in overwriting the fd array with the new value without being send.
343 * Upon writing the message the fd array is freed.
345 * Returns: -1 if fd passing isn't supported.
347 int qemu_chr_fe_set_msgfds(CharDriverState
*s
, int *fds
, int num
);
350 * @qemu_chr_fe_claim:
352 * Claim a backend before using it, should be called before calling
353 * qemu_chr_add_handlers().
355 * Returns: -1 if the backend is already in use by another frontend, 0 on
358 int qemu_chr_fe_claim(CharDriverState
*s
);
361 * @qemu_chr_fe_claim_no_fail:
363 * Like qemu_chr_fe_claim, but will exit qemu with an error when the
364 * backend is already in use.
366 void qemu_chr_fe_claim_no_fail(CharDriverState
*s
);
369 * @qemu_chr_fe_claim:
371 * Release a backend for use by another frontend.
373 * Returns: -1 if the backend is already in use by another frontend, 0 on
376 void qemu_chr_fe_release(CharDriverState
*s
);
379 * @qemu_chr_be_can_write:
381 * Determine how much data the front end can currently accept. This function
382 * returns the number of bytes the front end can accept. If it returns 0, the
383 * front end cannot receive data at the moment. The function must be polled
384 * to determine when data can be received.
386 * Returns: the number of bytes the front end can receive via @qemu_chr_be_write
388 int qemu_chr_be_can_write(CharDriverState
*s
);
391 * @qemu_chr_be_write:
393 * Write data from the back end to the front end. Before issuing this call,
394 * the caller should call @qemu_chr_be_can_write to determine how much data
395 * the front end can currently accept.
397 * @buf a buffer to receive data from the front end
398 * @len the number of bytes to receive from the front end
400 void qemu_chr_be_write(CharDriverState
*s
, uint8_t *buf
, int len
);
403 * @qemu_chr_be_write_impl:
405 * Implementation of back end writing. Used by replay module.
407 * @buf a buffer to receive data from the front end
408 * @len the number of bytes to receive from the front end
410 void qemu_chr_be_write_impl(CharDriverState
*s
, uint8_t *buf
, int len
);
413 * @qemu_chr_be_event:
415 * Send an event from the back end to the front end.
417 * @event the event to send
419 void qemu_chr_be_event(CharDriverState
*s
, int event
);
421 void qemu_chr_add_handlers(CharDriverState
*s
,
422 IOCanReadHandler
*fd_can_read
,
423 IOReadHandler
*fd_read
,
424 IOEventHandler
*fd_event
,
427 /* This API can make handler run in the context what you pass to. */
428 void qemu_chr_add_handlers_full(CharDriverState
*s
,
429 IOCanReadHandler
*fd_can_read
,
430 IOReadHandler
*fd_read
,
431 IOEventHandler
*fd_event
,
433 GMainContext
*context
);
435 void qemu_chr_be_generic_open(CharDriverState
*s
);
436 void qemu_chr_accept_input(CharDriverState
*s
);
437 int qemu_chr_add_client(CharDriverState
*s
, int fd
);
438 CharDriverState
*qemu_chr_find(const char *name
);
439 bool chr_is_ringbuf(const CharDriverState
*chr
);
441 QemuOpts
*qemu_chr_parse_compat(const char *label
, const char *filename
);
443 void register_char_driver(const char *name
, ChardevBackendKind kind
,
444 void (*parse
)(QemuOpts
*opts
, ChardevBackend
*backend
, Error
**errp
),
445 CharDriverState
*(*create
)(const char *id
, ChardevBackend
*backend
,
446 ChardevReturn
*ret
, Error
**errp
));
448 extern int term_escape_char
;
452 typedef CharDriverState
*(VcHandler
)(ChardevVC
*vc
, Error
**errp
);
453 void register_vc_handler(VcHandler
*handler
);