4 #include "qapi/qapi-types-char.h"
5 #include "qemu/main-loop.h"
6 #include "qemu/bitmap.h"
7 #include "qom/object.h"
17 /* character device */
18 typedef struct CharBackend CharBackend
;
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.
37 #define CHR_READ_BUF_LEN 4096
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
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
,
51 QEMU_CHAR_FEATURE_LAST
,
54 #define qemu_chr_replay(chr) qemu_chr_has_feature(chr, QEMU_CHAR_FEATURE_REPLAY)
59 QemuMutex chr_write_lock
;
66 GMainContext
*gcontext
;
67 DECLARE_BITMAP(features
, QEMU_CHAR_FEATURE_LAST
);
71 * @qemu_chr_new_from_opts:
73 * Create a new character backend from a QemuOpts list.
75 * @opts see qemu-config.c for a list of valid options
77 * Returns: on success: a new character backend
78 * otherwise: NULL; @errp specifies the error
79 * or left untouched in case of help option
81 Chardev
*qemu_chr_new_from_opts(QemuOpts
*opts
,
85 * @qemu_chr_parse_common:
87 * Parse the common options available to all character backends.
89 * @opts the options that still need parsing
90 * @backend a new backend
92 void qemu_chr_parse_common(QemuOpts
*opts
, ChardevCommon
*backend
);
95 * @qemu_chr_parse_opts:
97 * Parse the options to the ChardevBackend struct.
99 * Returns: a new backend or NULL on error
101 ChardevBackend
*qemu_chr_parse_opts(QemuOpts
*opts
,
107 * Create a new character backend from a URI.
109 * @label the name of the backend
112 * Returns: a new character backend
114 Chardev
*qemu_chr_new(const char *label
, const char *filename
);
119 * Change an existing character backend
121 * @opts the new backend options
123 void qemu_chr_change(QemuOpts
*opts
, Error
**errp
);
128 * Delete all chardevs (when leaving qemu)
130 void qemu_chr_cleanup(void);
133 * @qemu_chr_new_noreplay:
135 * Create a new character backend from a URI.
136 * Character device communications are not written
137 * into the replay log.
139 * @label the name of the backend
142 * Returns: a new character backend
144 Chardev
*qemu_chr_new_noreplay(const char *label
, const char *filename
);
147 * @qemu_chr_be_can_write:
149 * Determine how much data the front end can currently accept. This function
150 * returns the number of bytes the front end can accept. If it returns 0, the
151 * front end cannot receive data at the moment. The function must be polled
152 * to determine when data can be received.
154 * Returns: the number of bytes the front end can receive via @qemu_chr_be_write
156 int qemu_chr_be_can_write(Chardev
*s
);
159 * @qemu_chr_be_write:
161 * Write data from the back end to the front end. Before issuing this call,
162 * the caller should call @qemu_chr_be_can_write to determine how much data
163 * the front end can currently accept.
165 * @buf a buffer to receive data from the front end
166 * @len the number of bytes to receive from the front end
168 void qemu_chr_be_write(Chardev
*s
, uint8_t *buf
, int len
);
171 * @qemu_chr_be_write_impl:
173 * Implementation of back end writing. Used by replay module.
175 * @buf a buffer to receive data from the front end
176 * @len the number of bytes to receive from the front end
178 void qemu_chr_be_write_impl(Chardev
*s
, uint8_t *buf
, int len
);
181 * @qemu_chr_be_update_read_handlers:
183 * Invoked when frontend read handlers are setup
185 * @context the gcontext that will be used to attach the watch sources
187 void qemu_chr_be_update_read_handlers(Chardev
*s
,
188 GMainContext
*context
);
191 * @qemu_chr_be_event:
193 * Send an event from the back end to the front end.
195 * @event the event to send
197 void qemu_chr_be_event(Chardev
*s
, int event
);
199 int qemu_chr_add_client(Chardev
*s
, int fd
);
200 Chardev
*qemu_chr_find(const char *name
);
202 bool qemu_chr_has_feature(Chardev
*chr
,
203 ChardevFeature feature
);
204 void qemu_chr_set_feature(Chardev
*chr
,
205 ChardevFeature feature
);
206 QemuOpts
*qemu_chr_parse_compat(const char *label
, const char *filename
);
207 int qemu_chr_write(Chardev
*s
, const uint8_t *buf
, int len
, bool write_all
);
208 #define qemu_chr_write_all(s, buf, len) qemu_chr_write(s, buf, len, true)
209 int qemu_chr_wait_connected(Chardev
*chr
, Error
**errp
);
211 #define TYPE_CHARDEV "chardev"
212 #define CHARDEV(obj) OBJECT_CHECK(Chardev, (obj), TYPE_CHARDEV)
213 #define CHARDEV_CLASS(klass) \
214 OBJECT_CLASS_CHECK(ChardevClass, (klass), TYPE_CHARDEV)
215 #define CHARDEV_GET_CLASS(obj) \
216 OBJECT_GET_CLASS(ChardevClass, (obj), TYPE_CHARDEV)
218 #define TYPE_CHARDEV_NULL "chardev-null"
219 #define TYPE_CHARDEV_MUX "chardev-mux"
220 #define TYPE_CHARDEV_RINGBUF "chardev-ringbuf"
221 #define TYPE_CHARDEV_PTY "chardev-pty"
222 #define TYPE_CHARDEV_CONSOLE "chardev-console"
223 #define TYPE_CHARDEV_STDIO "chardev-stdio"
224 #define TYPE_CHARDEV_PIPE "chardev-pipe"
225 #define TYPE_CHARDEV_MEMORY "chardev-memory"
226 #define TYPE_CHARDEV_PARALLEL "chardev-parallel"
227 #define TYPE_CHARDEV_FILE "chardev-file"
228 #define TYPE_CHARDEV_SERIAL "chardev-serial"
229 #define TYPE_CHARDEV_SOCKET "chardev-socket"
230 #define TYPE_CHARDEV_UDP "chardev-udp"
232 #define CHARDEV_IS_RINGBUF(chr) \
233 object_dynamic_cast(OBJECT(chr), TYPE_CHARDEV_RINGBUF)
234 #define CHARDEV_IS_PTY(chr) \
235 object_dynamic_cast(OBJECT(chr), TYPE_CHARDEV_PTY)
237 typedef struct ChardevClass
{
238 ObjectClass parent_class
;
240 bool internal
; /* TODO: eventually use TYPE_USER_CREATABLE */
241 void (*parse
)(QemuOpts
*opts
, ChardevBackend
*backend
, Error
**errp
);
243 void (*open
)(Chardev
*chr
, ChardevBackend
*backend
,
244 bool *be_opened
, Error
**errp
);
246 int (*chr_write
)(Chardev
*s
, const uint8_t *buf
, int len
);
247 int (*chr_sync_read
)(Chardev
*s
, const uint8_t *buf
, int len
);
248 GSource
*(*chr_add_watch
)(Chardev
*s
, GIOCondition cond
);
249 void (*chr_update_read_handler
)(Chardev
*s
);
250 int (*chr_ioctl
)(Chardev
*s
, int cmd
, void *arg
);
251 int (*get_msgfds
)(Chardev
*s
, int* fds
, int num
);
252 int (*set_msgfds
)(Chardev
*s
, int *fds
, int num
);
253 int (*chr_add_client
)(Chardev
*chr
, int fd
);
254 int (*chr_wait_connected
)(Chardev
*chr
, Error
**errp
);
255 void (*chr_disconnect
)(Chardev
*chr
);
256 void (*chr_accept_input
)(Chardev
*chr
);
257 void (*chr_set_echo
)(Chardev
*chr
, bool echo
);
258 void (*chr_set_fe_open
)(Chardev
*chr
, int fe_open
);
259 void (*chr_be_event
)(Chardev
*s
, int event
);
260 /* Return 0 if succeeded, 1 if failed */
261 int (*chr_machine_done
)(Chardev
*chr
);
264 Chardev
*qemu_chardev_new(const char *id
, const char *typename
,
265 ChardevBackend
*backend
, Error
**errp
);
267 extern int term_escape_char
;
269 GSource
*qemu_chr_timeout_add_ms(Chardev
*chr
, guint ms
,
270 GSourceFunc func
, void *private);
273 void qemu_chr_parse_vc(QemuOpts
*opts
, ChardevBackend
*backend
, Error
**errp
);