diff options
Diffstat (limited to 'include/chardev')
| -rw-r--r-- | include/chardev/char-fd.h | 47 | ||||
| -rw-r--r-- | include/chardev/char-fe.h | 292 | ||||
| -rw-r--r-- | include/chardev/char-io.h | 46 | ||||
| -rw-r--r-- | include/chardev/char-parallel.h | 45 | ||||
| -rw-r--r-- | include/chardev/char-serial.h | 49 | ||||
| -rw-r--r-- | include/chardev/char-win-stdio.h | 29 | ||||
| -rw-r--r-- | include/chardev/char-win.h | 54 | ||||
| -rw-r--r-- | include/chardev/char.h | 326 | ||||
| -rw-r--r-- | include/chardev/spice.h | 26 |
9 files changed, 914 insertions, 0 deletions
diff --git a/include/chardev/char-fd.h b/include/chardev/char-fd.h new file mode 100644 index 000000000..9de0e440d --- /dev/null +++ b/include/chardev/char-fd.h @@ -0,0 +1,47 @@ +/* + * QEMU System Emulator + * + * Copyright (c) 2003-2008 Fabrice Bellard + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +#ifndef CHAR_FD_H +#define CHAR_FD_H + +#include "io/channel.h" +#include "chardev/char.h" +#include "qom/object.h" + +struct FDChardev { + Chardev parent; + + QIOChannel *ioc_in, *ioc_out; + int max_size; +}; +typedef struct FDChardev FDChardev; + +#define TYPE_CHARDEV_FD "chardev-fd" + +DECLARE_INSTANCE_CHECKER(FDChardev, FD_CHARDEV, + TYPE_CHARDEV_FD) + +void qemu_chr_open_fd(Chardev *chr, int fd_in, int fd_out); +int qmp_chardev_open_file_source(char *src, int flags, Error **errp); + +#endif /* CHAR_FD_H */ diff --git a/include/chardev/char-fe.h b/include/chardev/char-fe.h new file mode 100644 index 000000000..867ef1b3b --- /dev/null +++ b/include/chardev/char-fe.h @@ -0,0 +1,292 @@ +#ifndef QEMU_CHAR_FE_H +#define QEMU_CHAR_FE_H + +#include "chardev/char.h" +#include "qemu/main-loop.h" + +typedef void IOEventHandler(void *opaque, QEMUChrEvent event); +typedef int BackendChangeHandler(void *opaque); + +/* This is the backend as seen by frontend, the actual backend is + * Chardev */ +struct CharBackend { + Chardev *chr; + IOEventHandler *chr_event; + IOCanReadHandler *chr_can_read; + IOReadHandler *chr_read; + BackendChangeHandler *chr_be_change; + void *opaque; + int tag; + int fe_open; +}; + +/** + * qemu_chr_fe_init: + * + * Initializes a front end for the given CharBackend and + * Chardev. Call qemu_chr_fe_deinit() to remove the association and + * release the driver. + * + * Returns: false on error. + */ +bool qemu_chr_fe_init(CharBackend *b, Chardev *s, Error **errp); + +/** + * qemu_chr_fe_deinit: + * @b: a CharBackend + * @del: if true, delete the chardev backend +* + * Dissociate the CharBackend from the Chardev. + * + * Safe to call without associated Chardev. + */ +void qemu_chr_fe_deinit(CharBackend *b, bool del); + +/** + * qemu_chr_fe_get_driver: + * + * Returns: the driver associated with a CharBackend or NULL if no + * associated Chardev. + * Note: avoid this function as the driver should never be accessed directly, + * especially by the frontends that support chardevice hotswap. + * Consider qemu_chr_fe_backend_connected() to check for driver existence + */ +Chardev *qemu_chr_fe_get_driver(CharBackend *be); + +/** + * qemu_chr_fe_backend_connected: + * + * Returns: true if there is a chardevice associated with @be. + */ +bool qemu_chr_fe_backend_connected(CharBackend *be); + +/** + * qemu_chr_fe_backend_open: + * + * Returns: true if chardevice associated with @be is open. + */ +bool qemu_chr_fe_backend_open(CharBackend *be); + +/** + * qemu_chr_fe_set_handlers_full: + * @b: a CharBackend + * @fd_can_read: callback to get the amount of data the frontend may + * receive + * @fd_read: callback to receive data from char + * @fd_event: event callback + * @be_change: backend change callback; passing NULL means hot backend change + * is not supported and will not be attempted + * @opaque: an opaque pointer for the callbacks + * @context: a main loop context or NULL for the default + * @set_open: whether to call qemu_chr_fe_set_open() implicitely when + * any of the handler is non-NULL + * @sync_state: whether to issue event callback with updated state + * + * Set the front end char handlers. The front end takes the focus if + * any of the handler is non-NULL. + * + * Without associated Chardev, nothing is changed. + */ +void qemu_chr_fe_set_handlers_full(CharBackend *b, + IOCanReadHandler *fd_can_read, + IOReadHandler *fd_read, + IOEventHandler *fd_event, + BackendChangeHandler *be_change, + void *opaque, + GMainContext *context, + bool set_open, + bool sync_state); + +/** + * qemu_chr_fe_set_handlers: + * + * Version of qemu_chr_fe_set_handlers_full() with sync_state = true. + */ +void qemu_chr_fe_set_handlers(CharBackend *b, + IOCanReadHandler *fd_can_read, + IOReadHandler *fd_read, + IOEventHandler *fd_event, + BackendChangeHandler *be_change, + void *opaque, + GMainContext *context, + bool set_open); + +/** + * qemu_chr_fe_take_focus: + * + * Take the focus (if the front end is muxed). + * + * Without associated Chardev, nothing is changed. + */ +void qemu_chr_fe_take_focus(CharBackend *b); + +/** + * qemu_chr_fe_accept_input: + * + * Notify that the frontend is ready to receive data + */ +void qemu_chr_fe_accept_input(CharBackend *be); + +/** + * qemu_chr_fe_disconnect: + * + * Close a fd accepted by character backend. + * Without associated Chardev, do nothing. + */ +void qemu_chr_fe_disconnect(CharBackend *be); + +/** + * qemu_chr_fe_wait_connected: + * + * Wait for characted backend to be connected, return < 0 on error or + * if no associated Chardev. + */ +int qemu_chr_fe_wait_connected(CharBackend *be, Error **errp); + +/** + * qemu_chr_fe_set_echo: + * @echo: true to enable echo, false to disable echo + * + * Ask the backend to override its normal echo setting. This only really + * applies to the stdio backend and is used by the QMP server such that you + * can see what you type if you try to type QMP commands. + * Without associated Chardev, do nothing. + */ +void qemu_chr_fe_set_echo(CharBackend *be, bool echo); + +/** + * qemu_chr_fe_set_open: + * + * Set character frontend open status. This is an indication that the + * front end is ready (or not) to begin doing I/O. + * Without associated Chardev, do nothing. + */ +void qemu_chr_fe_set_open(CharBackend *be, int fe_open); + +/** + * qemu_chr_fe_printf: + * @fmt: see #printf + * + * Write to a character backend using a printf style interface. This + * function is thread-safe. It does nothing without associated + * Chardev. + */ +void qemu_chr_fe_printf(CharBackend *be, const char *fmt, ...) + GCC_FMT_ATTR(2, 3); + + +typedef gboolean (*FEWatchFunc)(void *do_not_use, GIOCondition condition, void *data); + +/** + * qemu_chr_fe_add_watch: + * @cond: the condition to poll for + * @func: the function to call when the condition happens + * @user_data: the opaque pointer to pass to @func + * + * If the backend is connected, create and add a #GSource that fires + * when the given condition (typically G_IO_OUT|G_IO_HUP or G_IO_HUP) + * is active; return the #GSource's tag. If it is disconnected, + * or without associated Chardev, return 0. + * + * Note that you are responsible to update the front-end sources if + * you are switching the main context with qemu_chr_fe_set_handlers(). + * + * Warning: DO NOT use the first callback argument (it may be either + * a GIOChannel or a QIOChannel, depending on the underlying chardev) + * + * Returns: the source tag + */ +guint qemu_chr_fe_add_watch(CharBackend *be, GIOCondition cond, + FEWatchFunc func, void *user_data); + +/** + * qemu_chr_fe_write: + * @buf: the data + * @len: the number of bytes to send + * + * Write data to a character backend from the front end. This function + * will send data from the front end to the back end. This function + * is thread-safe. + * + * Returns: the number of bytes consumed (0 if no associated Chardev) + */ +int qemu_chr_fe_write(CharBackend *be, const uint8_t *buf, int len); + +/** + * qemu_chr_fe_write_all: + * @buf: the data + * @len: the number of bytes to send + * + * Write data to a character backend from the front end. This function will + * send data from the front end to the back end. Unlike @qemu_chr_fe_write, + * this function will block if the back end cannot consume all of the data + * attempted to be written. This function is thread-safe. + * + * Returns: the number of bytes consumed (0 if no associated Chardev) + */ +int qemu_chr_fe_write_all(CharBackend *be, const uint8_t *buf, int len); + +/** + * qemu_chr_fe_read_all: + * @buf: the data buffer + * @len: the number of bytes to read + * + * Read data to a buffer from the back end. + * + * Returns: the number of bytes read (0 if no associated Chardev) + */ +int qemu_chr_fe_read_all(CharBackend *be, uint8_t *buf, int len); + +/** + * qemu_chr_fe_ioctl: + * @cmd: see CHR_IOCTL_* + * @arg: the data associated with @cmd + * + * Issue a device specific ioctl to a backend. This function is thread-safe. + * + * Returns: if @cmd is not supported by the backend or there is no + * associated Chardev, -ENOTSUP, otherwise the return + * value depends on the semantics of @cmd + */ +int qemu_chr_fe_ioctl(CharBackend *be, int cmd, void *arg); + +/** + * qemu_chr_fe_get_msgfd: + * + * For backends capable of fd passing, return the latest file descriptor passed + * by a client. + * + * Returns: -1 if fd passing isn't supported or there is no pending file + * descriptor. If a file descriptor is returned, subsequent calls to + * this function will return -1 until a client sends a new file + * descriptor. + */ +int qemu_chr_fe_get_msgfd(CharBackend *be); + +/** + * qemu_chr_fe_get_msgfds: + * + * For backends capable of fd passing, return the number of file received + * descriptors and fills the fds array up to num elements + * + * Returns: -1 if fd passing isn't supported or there are no pending file + * descriptors. If file descriptors are returned, subsequent calls to + * this function will return -1 until a client sends a new set of file + * descriptors. + */ +int qemu_chr_fe_get_msgfds(CharBackend *be, int *fds, int num); + +/** + * qemu_chr_fe_set_msgfds: + * + * For backends capable of fd passing, set an array of fds to be passed with + * the next send operation. + * A subsequent call to this function before calling a write function will + * result in overwriting the fd array with the new value without being send. + * Upon writing the message the fd array is freed. + * + * Returns: -1 if fd passing isn't supported or no associated Chardev. + */ +int qemu_chr_fe_set_msgfds(CharBackend *be, int *fds, int num); + +#endif /* QEMU_CHAR_FE_H */ diff --git a/include/chardev/char-io.h b/include/chardev/char-io.h new file mode 100644 index 000000000..ac379ea70 --- /dev/null +++ b/include/chardev/char-io.h @@ -0,0 +1,46 @@ +/* + * QEMU System Emulator + * + * Copyright (c) 2003-2008 Fabrice Bellard + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +#ifndef CHAR_IO_H +#define CHAR_IO_H + +#include "io/channel.h" +#include "chardev/char.h" +#include "qemu/main-loop.h" + +/* Can only be used for read */ +GSource *io_add_watch_poll(Chardev *chr, + QIOChannel *ioc, + IOCanReadHandler *fd_can_read, + QIOChannelFunc fd_read, + gpointer user_data, + GMainContext *context); + +void remove_fd_in_watch(Chardev *chr); + +int io_channel_send(QIOChannel *ioc, const void *buf, size_t len); + +int io_channel_send_full(QIOChannel *ioc, const void *buf, size_t len, + int *fds, size_t nfds); + +#endif /* CHAR_IO_H */ diff --git a/include/chardev/char-parallel.h b/include/chardev/char-parallel.h new file mode 100644 index 000000000..c09751fd6 --- /dev/null +++ b/include/chardev/char-parallel.h @@ -0,0 +1,45 @@ +/* + * QEMU System Emulator + * + * Copyright (c) 2003-2008 Fabrice Bellard + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +#ifndef CHAR_PARALLEL_H +#define CHAR_PARALLEL_H + +#include "chardev/char.h" + +#define CHR_IOCTL_PP_READ_DATA 3 +#define CHR_IOCTL_PP_WRITE_DATA 4 +#define CHR_IOCTL_PP_READ_CONTROL 5 +#define CHR_IOCTL_PP_WRITE_CONTROL 6 +#define CHR_IOCTL_PP_READ_STATUS 7 +#define CHR_IOCTL_PP_EPP_READ_ADDR 8 +#define CHR_IOCTL_PP_EPP_READ 9 +#define CHR_IOCTL_PP_EPP_WRITE_ADDR 10 +#define CHR_IOCTL_PP_EPP_WRITE 11 +#define CHR_IOCTL_PP_DATA_DIR 12 + +struct ParallelIOArg { + void *buffer; + int count; +}; + +#endif /* CHAR_PARALLEL_H */ diff --git a/include/chardev/char-serial.h b/include/chardev/char-serial.h new file mode 100644 index 000000000..ad6891b26 --- /dev/null +++ b/include/chardev/char-serial.h @@ -0,0 +1,49 @@ +/* + * QEMU System Emulator + * + * Copyright (c) 2003-2008 Fabrice Bellard + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +#ifndef CHAR_SERIAL_H +#define CHAR_SERIAL_H + +#include "chardev/char.h" + +#define CHR_IOCTL_SERIAL_SET_PARAMS 1 +typedef struct { + int speed; + int parity; + int data_bits; + int stop_bits; +} QEMUSerialSetParams; + +#define CHR_IOCTL_SERIAL_SET_BREAK 2 + +#define CHR_IOCTL_SERIAL_SET_TIOCM 13 +#define CHR_IOCTL_SERIAL_GET_TIOCM 14 + +#define CHR_TIOCM_CTS 0x020 +#define CHR_TIOCM_CAR 0x040 +#define CHR_TIOCM_DSR 0x100 +#define CHR_TIOCM_RI 0x080 +#define CHR_TIOCM_DTR 0x002 +#define CHR_TIOCM_RTS 0x004 + +#endif diff --git a/include/chardev/char-win-stdio.h b/include/chardev/char-win-stdio.h new file mode 100644 index 000000000..d7314f734 --- /dev/null +++ b/include/chardev/char-win-stdio.h @@ -0,0 +1,29 @@ +/* + * QEMU System Emulator + * + * Copyright (c) 2003-2008 Fabrice Bellard + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +#ifndef CHAR_WIN_STDIO_H +#define CHAR_WIN_STDIO_H + +#define TYPE_CHARDEV_WIN_STDIO "chardev-win-stdio" + +#endif /* CHAR_WIN_STDIO_H */ diff --git a/include/chardev/char-win.h b/include/chardev/char-win.h new file mode 100644 index 000000000..485521469 --- /dev/null +++ b/include/chardev/char-win.h @@ -0,0 +1,54 @@ +/* + * QEMU System Emulator + * + * Copyright (c) 2003-2008 Fabrice Bellard + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +#ifndef CHAR_WIN_H +#define CHAR_WIN_H + +#include "chardev/char.h" +#include "qom/object.h" + +struct WinChardev { + Chardev parent; + + bool keep_open; /* console do not close file */ + HANDLE file, hrecv, hsend; + OVERLAPPED orecv; + BOOL fpipe; + + /* Protected by the Chardev chr_write_lock. */ + OVERLAPPED osend; +}; +typedef struct WinChardev WinChardev; + +#define NSENDBUF 2048 +#define NRECVBUF 2048 + +#define TYPE_CHARDEV_WIN "chardev-win" +DECLARE_INSTANCE_CHECKER(WinChardev, WIN_CHARDEV, + TYPE_CHARDEV_WIN) + +void win_chr_set_file(Chardev *chr, HANDLE file, bool keep_open); +int win_chr_serial_init(Chardev *chr, const char *filename, Error **errp); +int win_chr_pipe_poll(void *opaque); + +#endif /* CHAR_WIN_H */ diff --git a/include/chardev/char.h b/include/chardev/char.h new file mode 100644 index 000000000..a319b5fdf --- /dev/null +++ b/include/chardev/char.h @@ -0,0 +1,326 @@ +#ifndef QEMU_CHAR_H +#define QEMU_CHAR_H + +#include "qapi/qapi-types-char.h" +#include "qemu/bitmap.h" +#include "qemu/thread.h" +#include "qom/object.h" + +#define IAC_EOR 239 +#define IAC_SE 240 +#define IAC_NOP 241 +#define IAC_BREAK 243 +#define IAC_IP 244 +#define IAC_SB 250 +#define IAC 255 + +/* character device */ +typedef struct CharBackend CharBackend; + +typedef enum { + CHR_EVENT_BREAK, /* serial break char */ + CHR_EVENT_OPENED, /* new connection established */ + CHR_EVENT_MUX_IN, /* mux-focus was set to this terminal */ + CHR_EVENT_MUX_OUT, /* mux-focus will move on */ + CHR_EVENT_CLOSED /* connection closed. NOTE: currently this event + * is only bound to the read port of the chardev. + * Normally the read port and write port of a + * chardev should be the same, but it can be + * different, e.g., for fd chardevs, when the two + * fds are different. So when we received the + * CLOSED event it's still possible that the out + * port is still open. TODO: we should only send + * the CLOSED event when both ports are closed. + */ +} QEMUChrEvent; + +#define CHR_READ_BUF_LEN 4096 + +typedef enum { + /* Whether the chardev peer is able to close and + * reopen the data channel, thus requiring support + * for qemu_chr_wait_connected() to wait for a + * valid connection */ + QEMU_CHAR_FEATURE_RECONNECTABLE, + /* Whether it is possible to send/recv file descriptors + * over the data channel */ + QEMU_CHAR_FEATURE_FD_PASS, + /* Whether replay or record mode is enabled */ + QEMU_CHAR_FEATURE_REPLAY, + /* Whether the gcontext can be changed after calling + * qemu_chr_be_update_read_handlers() */ + QEMU_CHAR_FEATURE_GCONTEXT, + + QEMU_CHAR_FEATURE_LAST, +} ChardevFeature; + +#define qemu_chr_replay(chr) qemu_chr_has_feature(chr, QEMU_CHAR_FEATURE_REPLAY) + +struct Chardev { + Object parent_obj; + + QemuMutex chr_write_lock; + CharBackend *be; + char *label; + char *filename; + int logfd; + int be_open; + /* used to coordinate the chardev-change special-case: */ + bool handover_yank_instance; + GSource *gsource; + GMainContext *gcontext; + DECLARE_BITMAP(features, QEMU_CHAR_FEATURE_LAST); +}; + +/** + * qemu_chr_new_from_opts: + * @opts: see qemu-config.c for a list of valid options + * @context: the #GMainContext to be used at initialization time + * + * Create a new character backend from a QemuOpts list. + * + * Returns: on success: a new character backend + * otherwise: NULL; @errp specifies the error + * or left untouched in case of help option + */ +Chardev *qemu_chr_new_from_opts(QemuOpts *opts, + GMainContext *context, + Error **errp); + +/** + * qemu_chr_parse_common: + * @opts: the options that still need parsing + * @backend: a new backend + * + * Parse the common options available to all character backends. + */ +void qemu_chr_parse_common(QemuOpts *opts, ChardevCommon *backend); + +/** + * qemu_chr_parse_opts: + * + * Parse the options to the ChardevBackend struct. + * + * Returns: a new backend or NULL on error + */ +ChardevBackend *qemu_chr_parse_opts(QemuOpts *opts, + Error **errp); + +/** + * qemu_chr_new: + * @label: the name of the backend + * @filename: the URI + * @context: the #GMainContext to be used at initialization time + * + * Create a new character backend from a URI. + * Do not implicitly initialize a monitor if the chardev is muxed. + * + * Returns: a new character backend + */ +Chardev *qemu_chr_new(const char *label, const char *filename, + GMainContext *context); + +/** + * qemu_chr_new_mux_mon: + * @label: the name of the backend + * @filename: the URI + * @context: the #GMainContext to be used at initialization time + * + * Create a new character backend from a URI. + * Implicitly initialize a monitor if the chardev is muxed. + * + * Returns: a new character backend + */ +Chardev *qemu_chr_new_mux_mon(const char *label, const char *filename, + GMainContext *context); + +/** +* qemu_chr_change: +* @opts: the new backend options + * + * Change an existing character backend + */ +void qemu_chr_change(QemuOpts *opts, Error **errp); + +/** + * qemu_chr_cleanup: + * + * Delete all chardevs (when leaving qemu) + */ +void qemu_chr_cleanup(void); + +/** + * qemu_chr_new_noreplay: + * @label: the name of the backend + * @filename: the URI + * @permit_mux_mon: if chardev is muxed, initialize a monitor + * @context: the #GMainContext to be used at initialization time + * + * Create a new character backend from a URI. + * Character device communications are not written + * into the replay log. + * + * Returns: a new character backend + */ +Chardev *qemu_chr_new_noreplay(const char *label, const char *filename, + bool permit_mux_mon, GMainContext *context); + +/** + * qemu_chr_be_can_write: + * + * Determine how much data the front end can currently accept. This function + * returns the number of bytes the front end can accept. If it returns 0, the + * front end cannot receive data at the moment. The function must be polled + * to determine when data can be received. + * + * Returns: the number of bytes the front end can receive via @qemu_chr_be_write + */ +int qemu_chr_be_can_write(Chardev *s); + +/** + * qemu_chr_be_write: + * @buf: a buffer to receive data from the front end + * @len: the number of bytes to receive from the front end + * + * Write data from the back end to the front end. Before issuing this call, + * the caller should call @qemu_chr_be_can_write to determine how much data + * the front end can currently accept. + */ +void qemu_chr_be_write(Chardev *s, uint8_t *buf, int len); + +/** + * qemu_chr_be_write_impl: + * @buf: a buffer to receive data from the front end + * @len: the number of bytes to receive from the front end + * + * Implementation of back end writing. Used by replay module. + */ +void qemu_chr_be_write_impl(Chardev *s, uint8_t *buf, int len); + +/** + * qemu_chr_be_update_read_handlers: + * @context: the gcontext that will be used to attach the watch sources + * + * Invoked when frontend read handlers are setup + */ +void qemu_chr_be_update_read_handlers(Chardev *s, + GMainContext *context); + +/** + * qemu_chr_be_event: + * @event: the event to send + * + * Send an event from the back end to the front end. + */ +void qemu_chr_be_event(Chardev *s, QEMUChrEvent event); + +int qemu_chr_add_client(Chardev *s, int fd); +Chardev *qemu_chr_find(const char *name); + +bool qemu_chr_has_feature(Chardev *chr, + ChardevFeature feature); +void qemu_chr_set_feature(Chardev *chr, + ChardevFeature feature); +QemuOpts *qemu_chr_parse_compat(const char *label, const char *filename, + bool permit_mux_mon); +int qemu_chr_write(Chardev *s, const uint8_t *buf, int len, bool write_all); +#define qemu_chr_write_all(s, buf, len) qemu_chr_write(s, buf, len, true) +int qemu_chr_wait_connected(Chardev *chr, Error **errp); + +#define TYPE_CHARDEV "chardev" +OBJECT_DECLARE_TYPE(Chardev, ChardevClass, CHARDEV) + +#define TYPE_CHARDEV_NULL "chardev-null" +#define TYPE_CHARDEV_MUX "chardev-mux" +#define TYPE_CHARDEV_RINGBUF "chardev-ringbuf" +#define TYPE_CHARDEV_PTY "chardev-pty" +#define TYPE_CHARDEV_CONSOLE "chardev-console" +#define TYPE_CHARDEV_STDIO "chardev-stdio" +#define TYPE_CHARDEV_PIPE "chardev-pipe" +#define TYPE_CHARDEV_MEMORY "chardev-memory" +#define TYPE_CHARDEV_PARALLEL "chardev-parallel" +#define TYPE_CHARDEV_FILE "chardev-file" +#define TYPE_CHARDEV_SERIAL "chardev-serial" +#define TYPE_CHARDEV_SOCKET "chardev-socket" +#define TYPE_CHARDEV_UDP "chardev-udp" + +#define CHARDEV_IS_RINGBUF(chr) \ + object_dynamic_cast(OBJECT(chr), TYPE_CHARDEV_RINGBUF) +#define CHARDEV_IS_PTY(chr) \ + object_dynamic_cast(OBJECT(chr), TYPE_CHARDEV_PTY) + +struct ChardevClass { + ObjectClass parent_class; + + bool internal; /* TODO: eventually use TYPE_USER_CREATABLE */ + bool supports_yank; + + /* parse command line options and populate QAPI @backend */ + void (*parse)(QemuOpts *opts, ChardevBackend *backend, Error **errp); + + /* called after construction, open/starts the backend */ + void (*open)(Chardev *chr, ChardevBackend *backend, + bool *be_opened, Error **errp); + + /* write buf to the backend */ + int (*chr_write)(Chardev *s, const uint8_t *buf, int len); + + /* + * Read from the backend (blocking). A typical front-end will instead rely + * on chr_can_read/chr_read being called when polling/looping. + */ + int (*chr_sync_read)(Chardev *s, const uint8_t *buf, int len); + + /* create a watch on the backend */ + GSource *(*chr_add_watch)(Chardev *s, GIOCondition cond); + + /* update the backend internal sources */ + void (*chr_update_read_handler)(Chardev *s); + + /* send an ioctl to the backend */ + int (*chr_ioctl)(Chardev *s, int cmd, void *arg); + + /* get ancillary-received fds during last read */ + int (*get_msgfds)(Chardev *s, int* fds, int num); + + /* set ancillary fds to be sent with next write */ + int (*set_msgfds)(Chardev *s, int *fds, int num); + + /* accept the given fd */ + int (*chr_add_client)(Chardev *chr, int fd); + + /* wait for a connection */ + int (*chr_wait_connected)(Chardev *chr, Error **errp); + + /* disconnect a connection */ + void (*chr_disconnect)(Chardev *chr); + + /* called by frontend when it can read */ + void (*chr_accept_input)(Chardev *chr); + + /* set terminal echo */ + void (*chr_set_echo)(Chardev *chr, bool echo); + + /* notify the backend of frontend open state */ + void (*chr_set_fe_open)(Chardev *chr, int fe_open); + + /* handle various events */ + void (*chr_be_event)(Chardev *s, QEMUChrEvent event); +}; + +Chardev *qemu_chardev_new(const char *id, const char *typename, + ChardevBackend *backend, GMainContext *context, + Error **errp); + +extern int term_escape_char; + +GSource *qemu_chr_timeout_add_ms(Chardev *chr, guint ms, + GSourceFunc func, void *private); + +void suspend_mux_open(void); +void resume_mux_open(void); + +/* console.c */ +void qemu_chr_parse_vc(QemuOpts *opts, ChardevBackend *backend, Error **errp); + +#endif diff --git a/include/chardev/spice.h b/include/chardev/spice.h new file mode 100644 index 000000000..58e5b727e --- /dev/null +++ b/include/chardev/spice.h @@ -0,0 +1,26 @@ +#ifndef CHARDEV_SPICE_H +#define CHARDEV_SPICE_H + +#include <spice.h> +#include "chardev/char-fe.h" +#include "qom/object.h" + +struct SpiceChardev { + Chardev parent; + + SpiceCharDeviceInstance sin; + bool active; + bool blocked; + const uint8_t *datapos; + int datalen; +}; +typedef struct SpiceChardev SpiceChardev; + +#define TYPE_CHARDEV_SPICE "chardev-spice" +#define TYPE_CHARDEV_SPICEVMC "chardev-spicevmc" +#define TYPE_CHARDEV_SPICEPORT "chardev-spiceport" + +DECLARE_INSTANCE_CHECKER(SpiceChardev, SPICE_CHARDEV, + TYPE_CHARDEV_SPICE) + +#endif |