This differs from qemu_chr_be_can_write in that it will return 1 as
long as the backend is connected, including when the backend is
connected but not available for receiving, as in the case of
virtio-serial where the guest ring may be full.
If no implementation is provided the backend reports always connected
status. This is not really important right now since there is only a
single user, spice-char-dev.c, which uses virtio-console as the backend,
which does implement the callback.
Signed-off-by: Alon Levy <al...@redhat.com>
---
backends/rng-egd.c | 4 ++--
gdbstub.c | 2 +-
hw/ccid-card-passthru.c | 1 +
hw/debugcon.c | 2 +-
hw/ivshmem.c | 8 ++++----
hw/qdev-properties.c | 2 +-
hw/serial.c | 4 ++--
hw/usb/dev-serial.c | 4 ++--
hw/usb/redirect.c | 2 +-
hw/virtio-console.c | 12 ++++++++++--
main-loop.h | 1 +
monitor.c | 4 ++--
net/slirp.c | 2 +-
qemu-char.c | 11 ++++++++++-
qemu-char.h | 13 +++++++++++++
qtest.c | 2 +-
16 files changed, 53 insertions(+), 21 deletions(-)
diff --git a/backends/rng-egd.c b/backends/rng-egd.c
index ad84737..a20e737 100644
--- a/backends/rng-egd.c
+++ b/backends/rng-egd.c
@@ -150,7 +150,7 @@ static void rng_egd_opened(RngBackend *b, Error **errp)
}
/* FIXME we should resubmit pending requests when the CDS reconnects. */
- qemu_chr_add_handlers(s->chr, rng_egd_chr_can_read, rng_egd_chr_read,
+ qemu_chr_add_handlers(s->chr, NULL, rng_egd_chr_can_read, rng_egd_chr_read,
NULL, s);
}
@@ -190,7 +190,7 @@ static void rng_egd_finalize(Object *obj)
RngEgd *s = RNG_EGD(obj);
if (s->chr) {
- qemu_chr_add_handlers(s->chr, NULL, NULL, NULL, NULL);
+ qemu_chr_add_handlers(s->chr, NULL, NULL, NULL, NULL, NULL);
}
g_free(s->chr_name);
diff --git a/gdbstub.c b/gdbstub.c
index d02ec75..6b0a2f1 100644
--- a/gdbstub.c
+++ b/gdbstub.c
@@ -3002,7 +3002,7 @@ int gdbserver_start(const char *device)
if (!chr)
return -1;
- qemu_chr_add_handlers(chr, gdb_chr_can_receive, gdb_chr_receive,
+ qemu_chr_add_handlers(chr, NULL, gdb_chr_can_receive, gdb_chr_receive,
gdb_chr_event, NULL);
}
diff --git a/hw/ccid-card-passthru.c b/hw/ccid-card-passthru.c
index bd6c777..2734d63 100644
--- a/hw/ccid-card-passthru.c
+++ b/hw/ccid-card-passthru.c
@@ -283,6 +283,7 @@ static int passthru_initfn(CCIDCardState *base)
if (card->cs) {
DPRINTF(card, D_INFO, "initing chardev\n");
qemu_chr_add_handlers(card->cs,
+ NULL,
ccid_card_vscard_can_read,
ccid_card_vscard_read,
ccid_card_vscard_event, card);
diff --git a/hw/debugcon.c b/hw/debugcon.c
index 14ab326..f27ee36 100644
--- a/hw/debugcon.c
+++ b/hw/debugcon.c
@@ -73,7 +73,7 @@ static void debugcon_init_core(DebugconState *s)
exit(1);
}
- qemu_chr_add_handlers(s->chr, NULL, NULL, NULL, s);
+ qemu_chr_add_handlers(s->chr, NULL, NULL, NULL, NULL, s);
}
static int debugcon_isa_initfn(ISADevice *dev)
diff --git a/hw/ivshmem.c b/hw/ivshmem.c
index f6dbb21..d46ef7c 100644
--- a/hw/ivshmem.c
+++ b/hw/ivshmem.c
@@ -294,10 +294,10 @@ static CharDriverState* create_eventfd_chr_device(void *
opaque, EventNotifier *
s->eventfd_table[vector].pdev = &s->dev;
s->eventfd_table[vector].vector = vector;
- qemu_chr_add_handlers(chr, ivshmem_can_receive, fake_irqfd,
+ qemu_chr_add_handlers(chr, NULL, ivshmem_can_receive, fake_irqfd,
ivshmem_event, &s->eventfd_table[vector]);
} else {
- qemu_chr_add_handlers(chr, ivshmem_can_receive, ivshmem_receive,
+ qemu_chr_add_handlers(chr, NULL, ivshmem_can_receive, ivshmem_receive,
ivshmem_event, s);
}
@@ -722,8 +722,8 @@ static int pci_ivshmem_init(PCIDevice *dev)
s->eventfd_chr = g_malloc0(s->vectors * sizeof(CharDriverState *));
- qemu_chr_add_handlers(s->server_chr, ivshmem_can_receive, ivshmem_read,
- ivshmem_event, s);
+ qemu_chr_add_handlers(s->server_chr, NULL, ivshmem_can_receive,
+ ivshmem_read, ivshmem_event, s);
} else {
/* just map the file immediately, we're not using a server */
int fd;
diff --git a/hw/qdev-properties.c b/hw/qdev-properties.c
index 81d901c..6035128 100644
--- a/hw/qdev-properties.c
+++ b/hw/qdev-properties.c
@@ -550,7 +550,7 @@ static void release_chr(Object *obj, const char *name, void
*opaque)
CharDriverState **ptr = qdev_get_prop_ptr(dev, prop);
if (*ptr) {
- qemu_chr_add_handlers(*ptr, NULL, NULL, NULL, NULL);
+ qemu_chr_add_handlers(*ptr, NULL, NULL, NULL, NULL, NULL);
}
}
diff --git a/hw/serial.c b/hw/serial.c
index 60283ea..1cb8d0d 100644
--- a/hw/serial.c
+++ b/hw/serial.c
@@ -690,13 +690,13 @@ void serial_init_core(SerialState *s)
qemu_register_reset(serial_reset, s);
- qemu_chr_add_handlers(s->chr, serial_can_receive1, serial_receive1,
+ qemu_chr_add_handlers(s->chr, NULL, serial_can_receive1, serial_receive1,
serial_event, s);
}
void serial_exit_core(SerialState *s)
{
- qemu_chr_add_handlers(s->chr, NULL, NULL, NULL, NULL);
+ qemu_chr_add_handlers(s->chr, NULL, NULL, NULL, NULL, NULL);
qemu_unregister_reset(serial_reset, s);
}
diff --git a/hw/usb/dev-serial.c b/hw/usb/dev-serial.c
index 99b19df..5216b0c 100644
--- a/hw/usb/dev-serial.c
+++ b/hw/usb/dev-serial.c
@@ -414,7 +414,7 @@ static void usb_serial_handle_destroy(USBDevice *dev)
{
USBSerialState *s = (USBSerialState *)dev;
- qemu_chr_add_handlers(s->cs, NULL, NULL, NULL, NULL);
+ qemu_chr_add_handlers(s->cs, NULL, NULL, NULL, NULL, NULL);
}
static int usb_serial_can_read(void *opaque)
@@ -491,7 +491,7 @@ static int usb_serial_initfn(USBDevice *dev)
return -1;
}
- qemu_chr_add_handlers(s->cs, usb_serial_can_read, usb_serial_read,
+ qemu_chr_add_handlers(s->cs, NULL, usb_serial_can_read, usb_serial_read,
usb_serial_event, s);
usb_serial_handle_reset(dev);
diff --git a/hw/usb/redirect.c b/hw/usb/redirect.c
index 0c95e6b..cf467eb 100644
--- a/hw/usb/redirect.c
+++ b/hw/usb/redirect.c
@@ -1082,7 +1082,7 @@ static int usbredir_initfn(USBDevice *udev)
/* Let the backend know we are ready */
qemu_chr_fe_open(dev->cs);
- qemu_chr_add_handlers(dev->cs, usbredir_chardev_can_read,
+ qemu_chr_add_handlers(dev->cs, NULL, usbredir_chardev_can_read,
usbredir_chardev_read, usbredir_chardev_event, dev);
qemu_add_vm_change_state_handler(usbredir_vm_state_change, dev);
diff --git a/hw/virtio-console.c b/hw/virtio-console.c
index cffee3d..b6022b0 100644
--- a/hw/virtio-console.c
+++ b/hw/virtio-console.c
@@ -74,6 +74,14 @@ static void guest_close(VirtIOSerialPort *port)
qemu_chr_fe_close(vcon->chr);
}
+/* Connectedness of the guest */
+static int chr_connected(void *opaque)
+{
+ VirtConsole *vcon = opaque;
+
+ return virtio_serial_guest_connected(&vcon->port);
+}
+
/* Readiness of the guest to accept data on a port */
static int chr_can_read(void *opaque)
{
@@ -117,8 +125,8 @@ static int virtconsole_initfn(VirtIOSerialPort *port)
}
if (vcon->chr) {
- qemu_chr_add_handlers(vcon->chr, chr_can_read, chr_read, chr_event,
- vcon);
+ qemu_chr_add_handlers(vcon->chr, chr_connected, chr_can_read, chr_read,
+ chr_event, vcon);
}
return 0;
diff --git a/main-loop.h b/main-loop.h
index 326c742..84f5750 100644
--- a/main-loop.h
+++ b/main-loop.h
@@ -165,6 +165,7 @@ void qemu_del_wait_object(HANDLE handle, WaitObjectFunc
*func, void *opaque);
typedef void IOReadHandler(void *opaque, const uint8_t *buf, int size);
typedef int IOCanReadHandler(void *opaque);
+typedef int IOConnectedHandler(void *opaque);
/**
* qemu_set_fd_handler2: Register a file descriptor with the main loop
diff --git a/monitor.c b/monitor.c
index c0e32d6..5a74a4e 100644
--- a/monitor.c
+++ b/monitor.c
@@ -4707,13 +4707,13 @@ void monitor_init(CharDriverState *chr, int flags)
if (monitor_ctrl_mode(mon)) {
mon->mc = g_malloc0(sizeof(MonitorControl));
/* Control mode requires special handlers */
- qemu_chr_add_handlers(chr, monitor_can_read, monitor_control_read,
+ qemu_chr_add_handlers(chr, NULL, monitor_can_read,
monitor_control_read,
monitor_control_event, mon);
qemu_chr_fe_set_echo(chr, true);
json_message_parser_init(&mon->mc->parser, handle_qmp_command);
} else {
- qemu_chr_add_handlers(chr, monitor_can_read, monitor_read,
+ qemu_chr_add_handlers(chr, NULL, monitor_can_read, monitor_read,
monitor_event, mon);
}
diff --git a/net/slirp.c b/net/slirp.c
index afb52c3..c963bee 100644
--- a/net/slirp.c
+++ b/net/slirp.c
@@ -659,7 +659,7 @@ static int slirp_guestfwd(SlirpState *s, const char
*config_str,
fwd->port = port;
fwd->slirp = s->slirp;
- qemu_chr_add_handlers(fwd->hd, guestfwd_can_read, guestfwd_read,
+ qemu_chr_add_handlers(fwd->hd, NULL, guestfwd_can_read, guestfwd_read,
NULL, fwd);
}
return 0;
diff --git a/qemu-char.c b/qemu-char.c
index 242b799..ba316e1 100644
--- a/qemu-char.c
+++ b/qemu-char.c
@@ -152,6 +152,13 @@ int qemu_chr_fe_ioctl(CharDriverState *s, int cmd, void
*arg)
return s->chr_ioctl(s, cmd, arg);
}
+int qemu_chr_be_connected(CharDriverState *s)
+{
+ if (!s->chr_connected)
+ return 1;
+ return s->chr_connected(s->handler_opaque);
+}
+
int qemu_chr_be_can_write(CharDriverState *s)
{
if (!s->chr_can_read)
@@ -194,6 +201,7 @@ void qemu_chr_fe_printf(CharDriverState *s, const char
*fmt, ...)
}
void qemu_chr_add_handlers(CharDriverState *s,
+ IOConnectedHandler *fd_connected,
IOCanReadHandler *fd_can_read,
IOReadHandler *fd_read,
IOEventHandler *fd_event,
@@ -203,6 +211,7 @@ void qemu_chr_add_handlers(CharDriverState *s,
/* chr driver being released. */
++s->avail_connections;
}
+ s->chr_connected = fd_connected;
s->chr_can_read = fd_can_read;
s->chr_read = fd_read;
s->chr_event = fd_event;
@@ -457,7 +466,7 @@ static void mux_chr_update_read_handler(CharDriverState
*chr)
d->chr_event[d->mux_cnt] = chr->chr_event;
/* Fix up the real driver with mux routines */
if (d->mux_cnt == 0) {
- qemu_chr_add_handlers(d->drv, mux_chr_can_read, mux_chr_read,
+ qemu_chr_add_handlers(d->drv, NULL, mux_chr_can_read, mux_chr_read,
mux_chr_event, chr);
}
if (d->focus != -1) {
diff --git a/qemu-char.h b/qemu-char.h
index a121e04..6e93d55 100644
--- a/qemu-char.h
+++ b/qemu-char.h
@@ -61,6 +61,7 @@ struct CharDriverState {
int (*get_msgfd)(struct CharDriverState *s);
int (*chr_add_client)(struct CharDriverState *chr, int fd);
IOEventHandler *chr_event;
+ IOConnectedHandler *chr_connected;
IOCanReadHandler *chr_can_read;
IOReadHandler *chr_read;
void *handler_opaque;
@@ -202,6 +203,17 @@ int qemu_chr_fe_get_msgfd(CharDriverState *s);
int qemu_chr_be_can_write(CharDriverState *s);
/**
+ * @qemu_chr_be_connected:
+ *
+ * Determine if backend is connected. Connected means that data will be
+ * eventually read by the backend, even if at this moment
+ * qemu_chr_be_can_write would return 0.
+ *
+ * Returns: 1 if backend is connected, 0 otherwise.
+ */
+int qemu_chr_be_connected(CharDriverState *s);
+
+/**
* @qemu_chr_be_write:
*
* Write data from the back end to the front end. Before issuing this call,
@@ -224,6 +236,7 @@ void qemu_chr_be_write(CharDriverState *s, uint8_t *buf,
int len);
void qemu_chr_be_event(CharDriverState *s, int event);
void qemu_chr_add_handlers(CharDriverState *s,
+ IOConnectedHandler *fd_connected,
IOCanReadHandler *fd_can_read,
IOReadHandler *fd_read,
IOEventHandler *fd_event,
diff --git a/qtest.c b/qtest.c
index fbfab4e..c5f4193 100644
--- a/qtest.c
+++ b/qtest.c
@@ -425,7 +425,7 @@ int qtest_init(void)
configure_icount("0");
chr = qemu_chr_new("qtest", qtest_chrdev, NULL);
- qemu_chr_add_handlers(chr, qtest_can_read, qtest_read, qtest_event, chr);
+ qemu_chr_add_handlers(chr, NULL, qtest_can_read, qtest_read, qtest_event,
chr);
qemu_chr_fe_set_echo(chr, true);
inbuf = g_string_new("");
--
1.8.0
