2017-01-26 15:26:44 +01:00
|
|
|
#ifndef QEMU_CHAR_FE_H
|
|
|
|
#define QEMU_CHAR_FE_H
|
|
|
|
|
|
|
|
#include "chardev/char.h"
|
Include qemu/main-loop.h less
In my "build everything" tree, changing qemu/main-loop.h triggers a
recompile of some 5600 out of 6600 objects (not counting tests and
objects that don't depend on qemu/osdep.h). It includes block/aio.h,
which in turn includes qemu/event_notifier.h, qemu/notify.h,
qemu/processor.h, qemu/qsp.h, qemu/queue.h, qemu/thread-posix.h,
qemu/thread.h, qemu/timer.h, and a few more.
Include qemu/main-loop.h only where it's needed. Touching it now
recompiles only some 1700 objects. For block/aio.h and
qemu/event_notifier.h, these numbers drop from 5600 to 2800. For the
others, they shrink only slightly.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Message-Id: <20190812052359.30071-21-armbru@redhat.com>
Reviewed-by: Alex Bennée <alex.bennee@linaro.org>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Tested-by: Philippe Mathieu-Daudé <philmd@redhat.com>
2019-08-12 07:23:50 +02:00
|
|
|
#include "qemu/main-loop.h"
|
2017-01-26 15:26:44 +01:00
|
|
|
|
chardev: Use QEMUChrEvent enum in IOEventHandler typedef
The Chardev events are listed in the QEMUChrEvent enum.
By using the enum in the IOEventHandler typedef we:
- make the IOEventHandler type more explicit (this handler
process out-of-band information, while the IOReadHandler
is in-band),
- help static code analyzers.
This patch was produced with the following spatch script:
@match@
expression backend, opaque, context, set_open;
identifier fd_can_read, fd_read, fd_event, be_change;
@@
qemu_chr_fe_set_handlers(backend, fd_can_read, fd_read, fd_event,
be_change, opaque, context, set_open);
@depends on match@
identifier opaque, event;
identifier match.fd_event;
@@
static
-void fd_event(void *opaque, int event)
+void fd_event(void *opaque, QEMUChrEvent event)
{
...
}
Then the typedef was modified manually in
include/chardev/char-fe.h.
Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Acked-by: Corey Minyard <cminyard@mvista.com>
Acked-by: Cornelia Huck <cohuck@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <20191218172009.8868-15-philmd@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2019-12-18 18:20:09 +01:00
|
|
|
typedef void IOEventHandler(void *opaque, QEMUChrEvent event);
|
2017-07-06 14:08:49 +02:00
|
|
|
typedef int BackendChangeHandler(void *opaque);
|
2017-01-26 15:26:44 +01:00
|
|
|
|
|
|
|
/* 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;
|
2017-07-06 14:08:49 +02:00
|
|
|
BackendChangeHandler *chr_be_change;
|
2017-01-26 15:26:44 +01:00
|
|
|
void *opaque;
|
|
|
|
int tag;
|
|
|
|
int fe_open;
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
2018-08-24 16:22:47 +02:00
|
|
|
* qemu_chr_fe_init:
|
2017-01-26 15:26:44 +01:00
|
|
|
*
|
|
|
|
* 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);
|
|
|
|
|
|
|
|
/**
|
2018-08-24 16:22:47 +02:00
|
|
|
* qemu_chr_fe_deinit:
|
2017-01-26 21:49:13 +01:00
|
|
|
* @b: a CharBackend
|
|
|
|
* @del: if true, delete the chardev backend
|
|
|
|
*
|
2017-01-26 15:26:44 +01:00
|
|
|
* Dissociate the CharBackend from the Chardev.
|
|
|
|
*
|
|
|
|
* Safe to call without associated Chardev.
|
|
|
|
*/
|
2017-01-26 21:49:13 +01:00
|
|
|
void qemu_chr_fe_deinit(CharBackend *b, bool del);
|
2017-01-26 15:26:44 +01:00
|
|
|
|
|
|
|
/**
|
2018-08-24 16:22:47 +02:00
|
|
|
* qemu_chr_fe_get_driver:
|
2017-01-26 15:26:44 +01:00
|
|
|
*
|
2018-08-24 16:22:47 +02:00
|
|
|
* Returns: the driver associated with a CharBackend or NULL if no
|
2017-01-26 15:26:44 +01:00
|
|
|
* associated Chardev.
|
2017-07-06 14:08:51 +02:00
|
|
|
* 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
|
2017-01-26 15:26:44 +01:00
|
|
|
*/
|
|
|
|
Chardev *qemu_chr_fe_get_driver(CharBackend *be);
|
|
|
|
|
2017-07-06 14:08:51 +02:00
|
|
|
/**
|
2018-08-24 16:22:47 +02:00
|
|
|
* qemu_chr_fe_backend_connected:
|
2017-07-06 14:08:51 +02:00
|
|
|
*
|
2018-08-24 16:22:47 +02:00
|
|
|
* Returns: true if there is a chardevice associated with @be.
|
2017-07-06 14:08:51 +02:00
|
|
|
*/
|
|
|
|
bool qemu_chr_fe_backend_connected(CharBackend *be);
|
|
|
|
|
2017-07-06 14:08:52 +02:00
|
|
|
/**
|
2018-08-24 16:22:47 +02:00
|
|
|
* qemu_chr_fe_backend_open:
|
2017-07-06 14:08:52 +02:00
|
|
|
*
|
2018-08-24 16:22:47 +02:00
|
|
|
* Returns: true if chardevice associated with @be is open.
|
2017-07-06 14:08:52 +02:00
|
|
|
*/
|
|
|
|
bool qemu_chr_fe_backend_open(CharBackend *be);
|
|
|
|
|
2017-01-26 15:26:44 +01:00
|
|
|
/**
|
2018-11-06 13:40:51 +01:00
|
|
|
* qemu_chr_fe_set_handlers_full:
|
2017-01-26 15:26:44 +01:00
|
|
|
* @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
|
2017-07-06 14:08:49 +02:00
|
|
|
* @be_change: backend change callback; passing NULL means hot backend change
|
|
|
|
* is not supported and will not be attempted
|
2017-01-26 15:26:44 +01:00
|
|
|
* @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
|
2018-11-06 13:40:51 +01:00
|
|
|
* @sync_state: whether to issue event callback with updated state
|
2017-01-26 15:26:44 +01:00
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*/
|
2018-11-06 13:40:51 +01:00
|
|
|
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.
|
|
|
|
*/
|
2017-01-26 15:26:44 +01:00
|
|
|
void qemu_chr_fe_set_handlers(CharBackend *b,
|
|
|
|
IOCanReadHandler *fd_can_read,
|
|
|
|
IOReadHandler *fd_read,
|
|
|
|
IOEventHandler *fd_event,
|
2017-07-06 14:08:49 +02:00
|
|
|
BackendChangeHandler *be_change,
|
2017-01-26 15:26:44 +01:00
|
|
|
void *opaque,
|
|
|
|
GMainContext *context,
|
|
|
|
bool set_open);
|
|
|
|
|
|
|
|
/**
|
2018-08-24 16:22:47 +02:00
|
|
|
* qemu_chr_fe_take_focus:
|
2017-01-26 15:26:44 +01:00
|
|
|
*
|
|
|
|
* Take the focus (if the front end is muxed).
|
|
|
|
*
|
|
|
|
* Without associated Chardev, nothing is changed.
|
|
|
|
*/
|
|
|
|
void qemu_chr_fe_take_focus(CharBackend *b);
|
|
|
|
|
|
|
|
/**
|
2018-08-24 16:22:47 +02:00
|
|
|
* qemu_chr_fe_accept_input:
|
2017-01-26 15:26:44 +01:00
|
|
|
*
|
|
|
|
* Notify that the frontend is ready to receive data
|
|
|
|
*/
|
|
|
|
void qemu_chr_fe_accept_input(CharBackend *be);
|
|
|
|
|
|
|
|
/**
|
2018-08-24 16:22:47 +02:00
|
|
|
* qemu_chr_fe_disconnect:
|
2017-01-26 15:26:44 +01:00
|
|
|
*
|
2018-08-13 11:34:02 +02:00
|
|
|
* Close a fd accepted by character backend.
|
2017-01-26 15:26:44 +01:00
|
|
|
* Without associated Chardev, do nothing.
|
|
|
|
*/
|
|
|
|
void qemu_chr_fe_disconnect(CharBackend *be);
|
|
|
|
|
|
|
|
/**
|
2018-08-24 16:22:47 +02:00
|
|
|
* qemu_chr_fe_wait_connected:
|
2017-01-26 15:26:44 +01:00
|
|
|
*
|
|
|
|
* Wait for characted backend to be connected, return < 0 on error or
|
2018-08-13 11:34:02 +02:00
|
|
|
* if no associated Chardev.
|
2017-01-26 15:26:44 +01:00
|
|
|
*/
|
|
|
|
int qemu_chr_fe_wait_connected(CharBackend *be, Error **errp);
|
|
|
|
|
|
|
|
/**
|
2018-08-24 16:22:47 +02:00
|
|
|
* qemu_chr_fe_set_echo:
|
|
|
|
* @echo: true to enable echo, false to disable echo
|
2017-01-26 15:26:44 +01:00
|
|
|
*
|
|
|
|
* 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);
|
|
|
|
|
|
|
|
/**
|
2018-08-24 16:22:47 +02:00
|
|
|
* qemu_chr_fe_set_open:
|
2017-01-26 15:26:44 +01:00
|
|
|
*
|
|
|
|
* 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);
|
|
|
|
|
|
|
|
/**
|
2018-08-24 16:22:47 +02:00
|
|
|
* qemu_chr_fe_printf:
|
|
|
|
* @fmt: see #printf
|
2017-01-26 15:26:44 +01:00
|
|
|
*
|
|
|
|
* 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, ...)
|
2022-02-20 17:39:25 +01:00
|
|
|
G_GNUC_PRINTF(2, 3);
|
2017-01-26 15:26:44 +01:00
|
|
|
|
2021-08-04 15:01:14 +02:00
|
|
|
|
|
|
|
typedef gboolean (*FEWatchFunc)(void *do_not_use, GIOCondition condition, void *data);
|
|
|
|
|
2017-01-26 15:26:44 +01:00
|
|
|
/**
|
2018-08-24 16:22:47 +02:00
|
|
|
* 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
|
2017-01-26 15:26:44 +01:00
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*
|
2019-02-06 18:43:26 +01:00
|
|
|
* Note that you are responsible to update the front-end sources if
|
|
|
|
* you are switching the main context with qemu_chr_fe_set_handlers().
|
|
|
|
*
|
2021-08-04 15:01:14 +02:00
|
|
|
* Warning: DO NOT use the first callback argument (it may be either
|
|
|
|
* a GIOChannel or a QIOChannel, depending on the underlying chardev)
|
|
|
|
*
|
2017-01-26 15:26:44 +01:00
|
|
|
* Returns: the source tag
|
|
|
|
*/
|
|
|
|
guint qemu_chr_fe_add_watch(CharBackend *be, GIOCondition cond,
|
2021-08-04 15:01:14 +02:00
|
|
|
FEWatchFunc func, void *user_data);
|
2017-01-26 15:26:44 +01:00
|
|
|
|
|
|
|
/**
|
2018-08-24 16:22:47 +02:00
|
|
|
* qemu_chr_fe_write:
|
|
|
|
* @buf: the data
|
|
|
|
* @len: the number of bytes to send
|
2017-01-26 15:26:44 +01:00
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*
|
2018-08-13 11:34:02 +02:00
|
|
|
* Returns: the number of bytes consumed (0 if no associated Chardev)
|
2017-01-26 15:26:44 +01:00
|
|
|
*/
|
|
|
|
int qemu_chr_fe_write(CharBackend *be, const uint8_t *buf, int len);
|
|
|
|
|
|
|
|
/**
|
2018-08-24 16:22:47 +02:00
|
|
|
* qemu_chr_fe_write_all:
|
|
|
|
* @buf: the data
|
|
|
|
* @len: the number of bytes to send
|
2017-01-26 15:26:44 +01:00
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*
|
2018-08-13 11:34:02 +02:00
|
|
|
* Returns: the number of bytes consumed (0 if no associated Chardev)
|
2017-01-26 15:26:44 +01:00
|
|
|
*/
|
|
|
|
int qemu_chr_fe_write_all(CharBackend *be, const uint8_t *buf, int len);
|
|
|
|
|
|
|
|
/**
|
2018-08-24 16:22:47 +02:00
|
|
|
* qemu_chr_fe_read_all:
|
|
|
|
* @buf: the data buffer
|
|
|
|
* @len: the number of bytes to read
|
2017-01-26 15:26:44 +01:00
|
|
|
*
|
|
|
|
* Read data to a buffer from the back end.
|
|
|
|
*
|
2018-08-13 11:34:02 +02:00
|
|
|
* Returns: the number of bytes read (0 if no associated Chardev)
|
2017-01-26 15:26:44 +01:00
|
|
|
*/
|
|
|
|
int qemu_chr_fe_read_all(CharBackend *be, uint8_t *buf, int len);
|
|
|
|
|
|
|
|
/**
|
2018-08-24 16:22:47 +02:00
|
|
|
* qemu_chr_fe_ioctl:
|
|
|
|
* @cmd: see CHR_IOCTL_*
|
|
|
|
* @arg: the data associated with @cmd
|
2017-01-26 15:26:44 +01:00
|
|
|
*
|
|
|
|
* 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);
|
|
|
|
|
|
|
|
/**
|
2018-08-24 16:22:47 +02:00
|
|
|
* qemu_chr_fe_get_msgfd:
|
2017-01-26 15:26:44 +01:00
|
|
|
*
|
|
|
|
* 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);
|
|
|
|
|
|
|
|
/**
|
2018-08-24 16:22:47 +02:00
|
|
|
* qemu_chr_fe_get_msgfds:
|
2017-01-26 15:26:44 +01:00
|
|
|
*
|
|
|
|
* 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);
|
|
|
|
|
|
|
|
/**
|
2018-08-24 16:22:47 +02:00
|
|
|
* qemu_chr_fe_set_msgfds:
|
2017-01-26 15:26:44 +01:00
|
|
|
*
|
|
|
|
* 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 */
|