]> git.proxmox.com Git - mirror_qemu.git/blob - include/sysemu/char.h
Merge remote-tracking branch 'remotes/mst/tags/for_upstream' into staging
[mirror_qemu.git] / include / sysemu / char.h
1 #ifndef QEMU_CHAR_H
2 #define QEMU_CHAR_H
3
4 #include "qemu-common.h"
5 #include "qemu/queue.h"
6 #include "qemu/option.h"
7 #include "qemu/config-file.h"
8 #include "block/aio.h"
9 #include "qapi/qmp/qobject.h"
10 #include "qapi/qmp/qstring.h"
11 #include "qemu/main-loop.h"
12
13 /* character device */
14
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 */
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
42 #define CHR_IOCTL_PP_DATA_DIR 12
43
44 #define CHR_IOCTL_SERIAL_SET_TIOCM 13
45 #define CHR_IOCTL_SERIAL_GET_TIOCM 14
46
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
53
54 typedef void IOEventHandler(void *opaque, int event);
55
56 struct CharDriverState {
57 QemuMutex chr_write_lock;
58 void (*init)(struct CharDriverState *s);
59 int (*chr_write)(struct CharDriverState *s, const uint8_t *buf, int len);
60 int (*chr_sync_read)(struct CharDriverState *s,
61 const uint8_t *buf, int len);
62 GSource *(*chr_add_watch)(struct CharDriverState *s, GIOCondition cond);
63 void (*chr_update_read_handler)(struct CharDriverState *s);
64 int (*chr_ioctl)(struct CharDriverState *s, int cmd, void *arg);
65 int (*get_msgfds)(struct CharDriverState *s, int* fds, int num);
66 int (*set_msgfds)(struct CharDriverState *s, int *fds, int num);
67 int (*chr_add_client)(struct CharDriverState *chr, int fd);
68 IOEventHandler *chr_event;
69 IOCanReadHandler *chr_can_read;
70 IOReadHandler *chr_read;
71 void *handler_opaque;
72 void (*chr_close)(struct CharDriverState *chr);
73 void (*chr_accept_input)(struct CharDriverState *chr);
74 void (*chr_set_echo)(struct CharDriverState *chr, bool echo);
75 void (*chr_set_fe_open)(struct CharDriverState *chr, int fe_open);
76 void (*chr_fe_event)(struct CharDriverState *chr, int event);
77 void *opaque;
78 char *label;
79 char *filename;
80 int be_open;
81 int fe_open;
82 int explicit_fe_open;
83 int explicit_be_open;
84 int avail_connections;
85 int is_mux;
86 guint fd_in_tag;
87 QemuOpts *opts;
88 QTAILQ_ENTRY(CharDriverState) next;
89 };
90
91 /**
92 * @qemu_chr_alloc:
93 *
94 * Allocate and initialize a new CharDriverState.
95 *
96 * Returns: a newly allocated CharDriverState.
97 */
98 CharDriverState *qemu_chr_alloc(void);
99
100 /**
101 * @qemu_chr_new_from_opts:
102 *
103 * Create a new character backend from a QemuOpts list.
104 *
105 * @opts see qemu-config.c for a list of valid options
106 * @init not sure..
107 *
108 * Returns: a new character backend
109 */
110 CharDriverState *qemu_chr_new_from_opts(QemuOpts *opts,
111 void (*init)(struct CharDriverState *s),
112 Error **errp);
113
114 /**
115 * @qemu_chr_new:
116 *
117 * Create a new character backend from a URI.
118 *
119 * @label the name of the backend
120 * @filename the URI
121 * @init not sure..
122 *
123 * Returns: a new character backend
124 */
125 CharDriverState *qemu_chr_new(const char *label, const char *filename,
126 void (*init)(struct CharDriverState *s));
127
128 /**
129 * @qemu_chr_delete:
130 *
131 * Destroy a character backend.
132 */
133 void qemu_chr_delete(CharDriverState *chr);
134
135 /**
136 * @qemu_chr_fe_set_echo:
137 *
138 * Ask the backend to override its normal echo setting. This only really
139 * applies to the stdio backend and is used by the QMP server such that you
140 * can see what you type if you try to type QMP commands.
141 *
142 * @echo true to enable echo, false to disable echo
143 */
144 void qemu_chr_fe_set_echo(struct CharDriverState *chr, bool echo);
145
146 /**
147 * @qemu_chr_fe_set_open:
148 *
149 * Set character frontend open status. This is an indication that the
150 * front end is ready (or not) to begin doing I/O.
151 */
152 void qemu_chr_fe_set_open(struct CharDriverState *chr, int fe_open);
153
154 /**
155 * @qemu_chr_fe_event:
156 *
157 * Send an event from the front end to the back end.
158 *
159 * @event the event to send
160 */
161 void qemu_chr_fe_event(CharDriverState *s, int event);
162
163 /**
164 * @qemu_chr_fe_printf:
165 *
166 * Write to a character backend using a printf style interface.
167 * This function is thread-safe.
168 *
169 * @fmt see #printf
170 */
171 void qemu_chr_fe_printf(CharDriverState *s, const char *fmt, ...)
172 GCC_FMT_ATTR(2, 3);
173
174 int qemu_chr_fe_add_watch(CharDriverState *s, GIOCondition cond,
175 GIOFunc func, void *user_data);
176
177 /**
178 * @qemu_chr_fe_write:
179 *
180 * Write data to a character backend from the front end. This function
181 * will send data from the front end to the back end. This function
182 * is thread-safe.
183 *
184 * @buf the data
185 * @len the number of bytes to send
186 *
187 * Returns: the number of bytes consumed
188 */
189 int qemu_chr_fe_write(CharDriverState *s, const uint8_t *buf, int len);
190
191 /**
192 * @qemu_chr_fe_write_all:
193 *
194 * Write data to a character backend from the front end. This function will
195 * send data from the front end to the back end. Unlike @qemu_chr_fe_write,
196 * this function will block if the back end cannot consume all of the data
197 * attempted to be written. This function is thread-safe.
198 *
199 * @buf the data
200 * @len the number of bytes to send
201 *
202 * Returns: the number of bytes consumed
203 */
204 int qemu_chr_fe_write_all(CharDriverState *s, const uint8_t *buf, int len);
205
206 /**
207 * @qemu_chr_fe_read_all:
208 *
209 * Read data to a buffer from the back end.
210 *
211 * @buf the data buffer
212 * @len the number of bytes to read
213 *
214 * Returns: the number of bytes read
215 */
216 int qemu_chr_fe_read_all(CharDriverState *s, uint8_t *buf, int len);
217
218 /**
219 * @qemu_chr_fe_ioctl:
220 *
221 * Issue a device specific ioctl to a backend. This function is thread-safe.
222 *
223 * @cmd see CHR_IOCTL_*
224 * @arg the data associated with @cmd
225 *
226 * Returns: if @cmd is not supported by the backend, -ENOTSUP, otherwise the
227 * return value depends on the semantics of @cmd
228 */
229 int qemu_chr_fe_ioctl(CharDriverState *s, int cmd, void *arg);
230
231 /**
232 * @qemu_chr_fe_get_msgfd:
233 *
234 * For backends capable of fd passing, return the latest file descriptor passed
235 * by a client.
236 *
237 * Returns: -1 if fd passing isn't supported or there is no pending file
238 * descriptor. If a file descriptor is returned, subsequent calls to
239 * this function will return -1 until a client sends a new file
240 * descriptor.
241 */
242 int qemu_chr_fe_get_msgfd(CharDriverState *s);
243
244 /**
245 * @qemu_chr_fe_get_msgfds:
246 *
247 * For backends capable of fd passing, return the number of file received
248 * descriptors and fills the fds array up to num elements
249 *
250 * Returns: -1 if fd passing isn't supported or there are no pending file
251 * descriptors. If file descriptors are returned, subsequent calls to
252 * this function will return -1 until a client sends a new set of file
253 * descriptors.
254 */
255 int qemu_chr_fe_get_msgfds(CharDriverState *s, int *fds, int num);
256
257 /**
258 * @qemu_chr_fe_set_msgfds:
259 *
260 * For backends capable of fd passing, set an array of fds to be passed with
261 * the next send operation.
262 * A subsequent call to this function before calling a write function will
263 * result in overwriting the fd array with the new value without being send.
264 * Upon writing the message the fd array is freed.
265 *
266 * Returns: -1 if fd passing isn't supported.
267 */
268 int qemu_chr_fe_set_msgfds(CharDriverState *s, int *fds, int num);
269
270 /**
271 * @qemu_chr_fe_claim:
272 *
273 * Claim a backend before using it, should be called before calling
274 * qemu_chr_add_handlers().
275 *
276 * Returns: -1 if the backend is already in use by another frontend, 0 on
277 * success.
278 */
279 int qemu_chr_fe_claim(CharDriverState *s);
280
281 /**
282 * @qemu_chr_fe_claim_no_fail:
283 *
284 * Like qemu_chr_fe_claim, but will exit qemu with an error when the
285 * backend is already in use.
286 */
287 void qemu_chr_fe_claim_no_fail(CharDriverState *s);
288
289 /**
290 * @qemu_chr_fe_claim:
291 *
292 * Release a backend for use by another frontend.
293 *
294 * Returns: -1 if the backend is already in use by another frontend, 0 on
295 * success.
296 */
297 void qemu_chr_fe_release(CharDriverState *s);
298
299 /**
300 * @qemu_chr_be_can_write:
301 *
302 * Determine how much data the front end can currently accept. This function
303 * returns the number of bytes the front end can accept. If it returns 0, the
304 * front end cannot receive data at the moment. The function must be polled
305 * to determine when data can be received.
306 *
307 * Returns: the number of bytes the front end can receive via @qemu_chr_be_write
308 */
309 int qemu_chr_be_can_write(CharDriverState *s);
310
311 /**
312 * @qemu_chr_be_write:
313 *
314 * Write data from the back end to the front end. Before issuing this call,
315 * the caller should call @qemu_chr_be_can_write to determine how much data
316 * the front end can currently accept.
317 *
318 * @buf a buffer to receive data from the front end
319 * @len the number of bytes to receive from the front end
320 */
321 void qemu_chr_be_write(CharDriverState *s, uint8_t *buf, int len);
322
323
324 /**
325 * @qemu_chr_be_event:
326 *
327 * Send an event from the back end to the front end.
328 *
329 * @event the event to send
330 */
331 void qemu_chr_be_event(CharDriverState *s, int event);
332
333 void qemu_chr_add_handlers(CharDriverState *s,
334 IOCanReadHandler *fd_can_read,
335 IOReadHandler *fd_read,
336 IOEventHandler *fd_event,
337 void *opaque);
338
339 void qemu_chr_be_generic_open(CharDriverState *s);
340 void qemu_chr_accept_input(CharDriverState *s);
341 int qemu_chr_add_client(CharDriverState *s, int fd);
342 CharDriverState *qemu_chr_find(const char *name);
343 bool chr_is_ringbuf(const CharDriverState *chr);
344
345 QemuOpts *qemu_chr_parse_compat(const char *label, const char *filename);
346
347 void register_char_driver(const char *name, ChardevBackendKind kind,
348 void (*parse)(QemuOpts *opts, ChardevBackend *backend, Error **errp));
349
350 /* add an eventfd to the qemu devices that are polled */
351 CharDriverState *qemu_chr_open_eventfd(int eventfd);
352
353 extern int term_escape_char;
354
355 CharDriverState *qemu_char_get_next_serial(void);
356
357 /* msmouse */
358 CharDriverState *qemu_chr_open_msmouse(void);
359
360 /* testdev.c */
361 CharDriverState *chr_testdev_init(void);
362
363 /* baum.c */
364 CharDriverState *chr_baum_init(void);
365
366 /* console.c */
367 typedef CharDriverState *(VcHandler)(ChardevVC *vc);
368
369 void register_vc_handler(VcHandler *handler);
370 CharDriverState *vc_init(ChardevVC *vc);
371 #endif