]>
git.proxmox.com Git - qemu.git/blob - include/char/char.h
afe002498eba52fc2fdfe1bd1cbcb0b4ea5bc526
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 #define CHR_IOCTL_SERIAL_SET_TIOCM 13
45 #define CHR_IOCTL_SERIAL_GET_TIOCM 14
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
54 typedef void IOEventHandler(void *opaque
, int event
);
56 struct CharDriverState
{
57 void (*init
)(struct CharDriverState
*s
);
58 int (*chr_write
)(struct CharDriverState
*s
, const uint8_t *buf
, int len
);
59 GSource
*(*chr_add_watch
)(struct CharDriverState
*s
, GIOCondition cond
);
60 void (*chr_update_read_handler
)(struct CharDriverState
*s
);
61 int (*chr_ioctl
)(struct CharDriverState
*s
, int cmd
, void *arg
);
62 int (*get_msgfd
)(struct CharDriverState
*s
);
63 int (*chr_add_client
)(struct CharDriverState
*chr
, int fd
);
64 IOEventHandler
*chr_event
;
65 IOCanReadHandler
*chr_can_read
;
66 IOReadHandler
*chr_read
;
68 void (*chr_close
)(struct CharDriverState
*chr
);
69 void (*chr_accept_input
)(struct CharDriverState
*chr
);
70 void (*chr_set_echo
)(struct CharDriverState
*chr
, bool echo
);
71 void (*chr_guest_open
)(struct CharDriverState
*chr
);
72 void (*chr_guest_close
)(struct CharDriverState
*chr
);
78 int avail_connections
;
80 QTAILQ_ENTRY(CharDriverState
) next
;
84 * @qemu_chr_new_from_opts:
86 * Create a new character backend from a QemuOpts list.
88 * @opts see qemu-config.c for a list of valid options
91 * Returns: a new character backend
93 CharDriverState
*qemu_chr_new_from_opts(QemuOpts
*opts
,
94 void (*init
)(struct CharDriverState
*s
),
100 * Create a new character backend from a URI.
102 * @label the name of the backend
106 * Returns: a new character backend
108 CharDriverState
*qemu_chr_new(const char *label
, const char *filename
,
109 void (*init
)(struct CharDriverState
*s
));
114 * Destroy a character backend.
116 void qemu_chr_delete(CharDriverState
*chr
);
119 * @qemu_chr_fe_set_echo:
121 * Ask the backend to override its normal echo setting. This only really
122 * applies to the stdio backend and is used by the QMP server such that you
123 * can see what you type if you try to type QMP commands.
125 * @echo true to enable echo, false to disable echo
127 void qemu_chr_fe_set_echo(struct CharDriverState
*chr
, bool echo
);
132 * Open a character backend. This function call is an indication that the
133 * front end is ready to begin doing I/O.
135 void qemu_chr_fe_open(struct CharDriverState
*chr
);
138 * @qemu_chr_fe_close:
140 * Close a character backend. This function call indicates that the front end
141 * no longer is able to process I/O. To process I/O again, the front end will
142 * call @qemu_chr_fe_open.
144 void qemu_chr_fe_close(struct CharDriverState
*chr
);
147 * @qemu_chr_fe_printf:
149 * Write to a character backend using a printf style interface.
153 void qemu_chr_fe_printf(CharDriverState
*s
, const char *fmt
, ...)
156 guint
qemu_chr_fe_add_watch(CharDriverState
*s
, GIOCondition cond
,
157 GIOFunc func
, void *user_data
);
160 * @qemu_chr_fe_write:
162 * Write data to a character backend from the front end. This function will
163 * send data from the front end to the back end.
166 * @len the number of bytes to send
168 * Returns: the number of bytes consumed
170 int qemu_chr_fe_write(CharDriverState
*s
, const uint8_t *buf
, int len
);
173 * @qemu_chr_fe_ioctl:
175 * Issue a device specific ioctl to a backend.
177 * @cmd see CHR_IOCTL_*
178 * @arg the data associated with @cmd
180 * Returns: if @cmd is not supported by the backend, -ENOTSUP, otherwise the
181 * return value depends on the semantics of @cmd
183 int qemu_chr_fe_ioctl(CharDriverState
*s
, int cmd
, void *arg
);
186 * @qemu_chr_fe_get_msgfd:
188 * For backends capable of fd passing, return the latest file descriptor passed
191 * Returns: -1 if fd passing isn't supported or there is no pending file
192 * descriptor. If a file descriptor is returned, subsequent calls to
193 * this function will return -1 until a client sends a new file
196 int qemu_chr_fe_get_msgfd(CharDriverState
*s
);
199 * @qemu_chr_be_can_write:
201 * Determine how much data the front end can currently accept. This function
202 * returns the number of bytes the front end can accept. If it returns 0, the
203 * front end cannot receive data at the moment. The function must be polled
204 * to determine when data can be received.
206 * Returns: the number of bytes the front end can receive via @qemu_chr_be_write
208 int qemu_chr_be_can_write(CharDriverState
*s
);
211 * @qemu_chr_be_write:
213 * Write data from the back end to the front end. Before issuing this call,
214 * the caller should call @qemu_chr_be_can_write to determine how much data
215 * the front end can currently accept.
217 * @buf a buffer to receive data from the front end
218 * @len the number of bytes to receive from the front end
220 void qemu_chr_be_write(CharDriverState
*s
, uint8_t *buf
, int len
);
224 * @qemu_chr_be_event:
226 * Send an event from the back end to the front end.
228 * @event the event to send
230 void qemu_chr_be_event(CharDriverState
*s
, int event
);
232 void qemu_chr_add_handlers(CharDriverState
*s
,
233 IOCanReadHandler
*fd_can_read
,
234 IOReadHandler
*fd_read
,
235 IOEventHandler
*fd_event
,
238 void qemu_chr_generic_open(CharDriverState
*s
);
239 void qemu_chr_accept_input(CharDriverState
*s
);
240 int qemu_chr_add_client(CharDriverState
*s
, int fd
);
241 void qemu_chr_info_print(Monitor
*mon
, const QObject
*ret_data
);
242 void qemu_chr_info(Monitor
*mon
, QObject
**ret_data
);
243 CharDriverState
*qemu_chr_find(const char *name
);
245 QemuOpts
*qemu_chr_parse_compat(const char *label
, const char *filename
);
247 void register_char_driver(const char *name
, CharDriverState
*(*open
)(QemuOpts
*));
248 void register_char_driver_qapi(const char *name
, int kind
,
249 void (*parse
)(QemuOpts
*opts
, ChardevBackend
*backend
, Error
**errp
));
251 /* add an eventfd to the qemu devices that are polled */
252 CharDriverState
*qemu_chr_open_eventfd(int eventfd
);
254 extern int term_escape_char
;
257 void qemu_chr_init_mem(CharDriverState
*chr
);
258 void qemu_chr_close_mem(CharDriverState
*chr
);
259 QString
*qemu_chr_mem_to_qs(CharDriverState
*chr
);
260 size_t qemu_chr_mem_osize(const CharDriverState
*chr
);
262 CharDriverState
*qemu_char_get_next_serial(void);