1#ifndef QEMU_CHAR_H
2#define QEMU_CHAR_H
3
4#include "qapi/qapi-types-char.h"
5#include "qemu/bitmap.h"
6#include "qemu/thread.h"
7#include "qom/object.h"
8
9#define IAC_EOR 239
10#define IAC_SE 240
11#define IAC_NOP 241
12#define IAC_BREAK 243
13#define IAC_IP 244
14#define IAC_SB 250
15#define IAC 255
16
17/* character device */
18typedef struct CharBackend CharBackend;
19
20typedef enum {
21 CHR_EVENT_BREAK, /* serial break char */
22 CHR_EVENT_OPENED, /* new connection established */
23 CHR_EVENT_MUX_IN, /* mux-focus was set to this terminal */
24 CHR_EVENT_MUX_OUT, /* mux-focus will move on */
25 CHR_EVENT_CLOSED /* connection closed. NOTE: currently this event
26 * is only bound to the read port of the chardev.
27 * Normally the read port and write port of a
28 * chardev should be the same, but it can be
29 * different, e.g., for fd chardevs, when the two
30 * fds are different. So when we received the
31 * CLOSED event it's still possible that the out
32 * port is still open. TODO: we should only send
33 * the CLOSED event when both ports are closed.
34 */
35} QEMUChrEvent;
36
37#define CHR_READ_BUF_LEN 4096
38
39typedef enum {
40 /* Whether the chardev peer is able to close and
41 * reopen the data channel, thus requiring support
42 * for qemu_chr_wait_connected() to wait for a
43 * valid connection */
44 QEMU_CHAR_FEATURE_RECONNECTABLE,
45 /* Whether it is possible to send/recv file descriptors
46 * over the data channel */
47 QEMU_CHAR_FEATURE_FD_PASS,
48 /* Whether replay or record mode is enabled */
49 QEMU_CHAR_FEATURE_REPLAY,
50 /* Whether the gcontext can be changed after calling
51 * qemu_chr_be_update_read_handlers() */
52 QEMU_CHAR_FEATURE_GCONTEXT,
53
54 QEMU_CHAR_FEATURE_LAST,
55} ChardevFeature;
56
57#define qemu_chr_replay(chr) qemu_chr_has_feature(chr, QEMU_CHAR_FEATURE_REPLAY)
58
59struct Chardev {
60 Object parent_obj;
61
62 QemuMutex chr_write_lock;
63 CharBackend *be;
64 char *label;
65 char *filename;
66 int logfd;
67 int be_open;
68 GSource *gsource;
69 GMainContext *gcontext;
70 DECLARE_BITMAP(features, QEMU_CHAR_FEATURE_LAST);
71};
72
73/**
74 * qemu_chr_new_from_opts:
75 * @opts: see qemu-config.c for a list of valid options
76 * @context: the #GMainContext to be used at initialization time
77 *
78 * Create a new character backend from a QemuOpts list.
79 *
80 * Returns: on success: a new character backend
81 * otherwise: NULL; @errp specifies the error
82 * or left untouched in case of help option
83 */
84Chardev *qemu_chr_new_from_opts(QemuOpts *opts,
85 GMainContext *context,
86 Error **errp);
87
88/**
89 * qemu_chr_parse_common:
90 * @opts: the options that still need parsing
91 * @backend: a new backend
92 *
93 * Parse the common options available to all character backends.
94 */
95void qemu_chr_parse_common(QemuOpts *opts, ChardevCommon *backend);
96
97/**
98 * qemu_chr_parse_opts:
99 *
100 * Parse the options to the ChardevBackend struct.
101 *
102 * Returns: a new backend or NULL on error
103 */
104ChardevBackend *qemu_chr_parse_opts(QemuOpts *opts,
105 Error **errp);
106
107/**
108 * qemu_chr_new:
109 * @label: the name of the backend
110 * @filename: the URI
111 * @context: the #GMainContext to be used at initialization time
112 *
113 * Create a new character backend from a URI.
114 * Do not implicitly initialize a monitor if the chardev is muxed.
115 *
116 * Returns: a new character backend
117 */
118Chardev *qemu_chr_new(const char *label, const char *filename,
119 GMainContext *context);
120
121/**
122 * qemu_chr_new_mux_mon:
123 * @label: the name of the backend
124 * @filename: the URI
125 * @context: the #GMainContext to be used at initialization time
126 *
127 * Create a new character backend from a URI.
128 * Implicitly initialize a monitor if the chardev is muxed.
129 *
130 * Returns: a new character backend
131 */
132Chardev *qemu_chr_new_mux_mon(const char *label, const char *filename,
133 GMainContext *context);
134
135/**
136* qemu_chr_change:
137* @opts: the new backend options
138 *
139 * Change an existing character backend
140 */
141void qemu_chr_change(QemuOpts *opts, Error **errp);
142
143/**
144 * qemu_chr_cleanup:
145 *
146 * Delete all chardevs (when leaving qemu)
147 */
148void qemu_chr_cleanup(void);
149
150/**
151 * qemu_chr_new_noreplay:
152 * @label: the name of the backend
153 * @filename: the URI
154 * @permit_mux_mon: if chardev is muxed, initialize a monitor
155 * @context: the #GMainContext to be used at initialization time
156 *
157 * Create a new character backend from a URI.
158 * Character device communications are not written
159 * into the replay log.
160 *
161 * Returns: a new character backend
162 */
163Chardev *qemu_chr_new_noreplay(const char *label, const char *filename,
164 bool permit_mux_mon, GMainContext *context);
165
166/**
167 * qemu_chr_be_can_write:
168 *
169 * Determine how much data the front end can currently accept. This function
170 * returns the number of bytes the front end can accept. If it returns 0, the
171 * front end cannot receive data at the moment. The function must be polled
172 * to determine when data can be received.
173 *
174 * Returns: the number of bytes the front end can receive via @qemu_chr_be_write
175 */
176int qemu_chr_be_can_write(Chardev *s);
177
178/**
179 * qemu_chr_be_write:
180 * @buf: a buffer to receive data from the front end
181 * @len: the number of bytes to receive from the front end
182 *
183 * Write data from the back end to the front end. Before issuing this call,
184 * the caller should call @qemu_chr_be_can_write to determine how much data
185 * the front end can currently accept.
186 */
187void qemu_chr_be_write(Chardev *s, uint8_t *buf, int len);
188
189/**
190 * qemu_chr_be_write_impl:
191 * @buf: a buffer to receive data from the front end
192 * @len: the number of bytes to receive from the front end
193 *
194 * Implementation of back end writing. Used by replay module.
195 */
196void qemu_chr_be_write_impl(Chardev *s, uint8_t *buf, int len);
197
198/**
199 * qemu_chr_be_update_read_handlers:
200 * @context: the gcontext that will be used to attach the watch sources
201 *
202 * Invoked when frontend read handlers are setup
203 */
204void qemu_chr_be_update_read_handlers(Chardev *s,
205 GMainContext *context);
206
207/**
208 * qemu_chr_be_event:
209 * @event: the event to send
210 *
211 * Send an event from the back end to the front end.
212 */
213void qemu_chr_be_event(Chardev *s, int event);
214
215int qemu_chr_add_client(Chardev *s, int fd);
216Chardev *qemu_chr_find(const char *name);
217
218bool qemu_chr_has_feature(Chardev *chr,
219 ChardevFeature feature);
220void qemu_chr_set_feature(Chardev *chr,
221 ChardevFeature feature);
222QemuOpts *qemu_chr_parse_compat(const char *label, const char *filename,
223 bool permit_mux_mon);
224int qemu_chr_write(Chardev *s, const uint8_t *buf, int len, bool write_all);
225#define qemu_chr_write_all(s, buf, len) qemu_chr_write(s, buf, len, true)
226int qemu_chr_wait_connected(Chardev *chr, Error **errp);
227
228#define TYPE_CHARDEV "chardev"
229#define CHARDEV(obj) OBJECT_CHECK(Chardev, (obj), TYPE_CHARDEV)
230#define CHARDEV_CLASS(klass) \
231 OBJECT_CLASS_CHECK(ChardevClass, (klass), TYPE_CHARDEV)
232#define CHARDEV_GET_CLASS(obj) \
233 OBJECT_GET_CLASS(ChardevClass, (obj), TYPE_CHARDEV)
234
235#define TYPE_CHARDEV_NULL "chardev-null"
236#define TYPE_CHARDEV_MUX "chardev-mux"
237#define TYPE_CHARDEV_RINGBUF "chardev-ringbuf"
238#define TYPE_CHARDEV_PTY "chardev-pty"
239#define TYPE_CHARDEV_CONSOLE "chardev-console"
240#define TYPE_CHARDEV_STDIO "chardev-stdio"
241#define TYPE_CHARDEV_PIPE "chardev-pipe"
242#define TYPE_CHARDEV_MEMORY "chardev-memory"
243#define TYPE_CHARDEV_PARALLEL "chardev-parallel"
244#define TYPE_CHARDEV_FILE "chardev-file"
245#define TYPE_CHARDEV_SERIAL "chardev-serial"
246#define TYPE_CHARDEV_SOCKET "chardev-socket"
247#define TYPE_CHARDEV_UDP "chardev-udp"
248
249#define CHARDEV_IS_RINGBUF(chr) \
250 object_dynamic_cast(OBJECT(chr), TYPE_CHARDEV_RINGBUF)
251#define CHARDEV_IS_PTY(chr) \
252 object_dynamic_cast(OBJECT(chr), TYPE_CHARDEV_PTY)
253
254typedef struct ChardevClass {
255 ObjectClass parent_class;
256
257 bool internal; /* TODO: eventually use TYPE_USER_CREATABLE */
258 void (*parse)(QemuOpts *opts, ChardevBackend *backend, Error **errp);
259
260 void (*open)(Chardev *chr, ChardevBackend *backend,
261 bool *be_opened, Error **errp);
262
263 int (*chr_write)(Chardev *s, const uint8_t *buf, int len);
264 int (*chr_sync_read)(Chardev *s, const uint8_t *buf, int len);
265 GSource *(*chr_add_watch)(Chardev *s, GIOCondition cond);
266 void (*chr_update_read_handler)(Chardev *s);
267 int (*chr_ioctl)(Chardev *s, int cmd, void *arg);
268 int (*get_msgfds)(Chardev *s, int* fds, int num);
269 int (*set_msgfds)(Chardev *s, int *fds, int num);
270 int (*chr_add_client)(Chardev *chr, int fd);
271 int (*chr_wait_connected)(Chardev *chr, Error **errp);
272 void (*chr_disconnect)(Chardev *chr);
273 void (*chr_accept_input)(Chardev *chr);
274 void (*chr_set_echo)(Chardev *chr, bool echo);
275 void (*chr_set_fe_open)(Chardev *chr, int fe_open);
276 void (*chr_be_event)(Chardev *s, int event);
277 /* Return 0 if succeeded, 1 if failed */
278 int (*chr_machine_done)(Chardev *chr);
279} ChardevClass;
280
281Chardev *qemu_chardev_new(const char *id, const char *typename,
282 ChardevBackend *backend, GMainContext *context,
283 Error **errp);
284
285extern int term_escape_char;
286
287GSource *qemu_chr_timeout_add_ms(Chardev *chr, guint ms,
288 GSourceFunc func, void *private);
289
290/* console.c */
291void qemu_chr_parse_vc(QemuOpts *opts, ChardevBackend *backend, Error **errp);
292
293#endif
294