From 7a78607683a3c3a25ab715d6a5e137be9cf29e66 Mon Sep 17 00:00:00 2001
From: Amit Shah <amit.shah@redhat.com>
Date: Mon, 21 Mar 2011 20:31:45 +0100
Subject: [PATCH 26/35] char: Add a QemuChrHandlers struct to initialise
chardev handlers
Instead of passing each handler in the qemu_add_handlers() function,
create a struct of handlers that can be passed to the function instead.
Signed-off-by: Amit Shah <amit.shah@redhat.com>
---
gdbstub.c | 9 +++++++--
hw/ccid-card-passthru.c | 11 +++++++----
hw/debugcon.c | 2 +-
hw/escc.c | 9 +++++++--
hw/etraxfs_ser.c | 13 +++++++++----
hw/grlib_apbuart.c | 12 +++++++-----
hw/ivshmem.c | 28 ++++++++++++++++++++++------
hw/lm32_juart.c | 8 +++++++-
hw/lm32_uart.c | 8 +++++++-
hw/mcf_uart.c | 9 +++++++--
hw/milkymist-uart.c | 8 +++++++-
hw/pl011.c | 9 +++++++--
hw/pxa2xx.c | 13 +++++++++----
hw/serial.c | 9 +++++++--
hw/sh_serial.c | 12 +++++++++---
hw/spapr_vty.c | 8 ++++++--
hw/strongarm.c | 12 +++++++-----
hw/syborg_serial.c | 9 +++++++--
hw/usb-serial.c | 9 +++++++--
hw/virtio-console.c | 11 ++++++++---
hw/xen_console.c | 16 +++++++++++-----
hw/xilinx_uartlite.c | 11 +++++++++--
monitor.c | 18 ++++++++++++++----
net/slirp.c | 8 ++++++--
qemu-char.c | 32 ++++++++++++++++++++++----------
qemu-char.h | 13 +++++++++----
usb-redir.c | 9 +++++++--
27 files changed, 233 insertions(+), 83 deletions(-)
diff --git a/gdbstub.c b/gdbstub.c
index c085a5a..0ff61cb 100644
--- a/gdbstub.c
+++ b/gdbstub.c
@@ -2739,6 +2739,12 @@ static void gdb_sigterm_handler(int signal)
}
#endif
+static const QemuChrHandlers gdb_handlers = {
+ .fd_can_read = gdb_chr_can_receive,
+ .fd_read = gdb_chr_receive,
+ .fd_event = gdb_chr_event,
+};
+
int gdbserver_start(const char *device)
{
GDBState *s;
@@ -2768,8 +2774,7 @@ int gdbserver_start(const char *device)
if (!chr)
return -1;
- qemu_chr_add_handlers(chr, gdb_chr_can_receive, gdb_chr_receive,
- gdb_chr_event, NULL);
+ qemu_chr_add_handlers(chr, &gdb_handlers, NULL);
}
s = gdbserver_state;
diff --git a/hw/ccid-card-passthru.c b/hw/ccid-card-passthru.c
index 28eb9d1..1dee6f7 100644
--- a/hw/ccid-card-passthru.c
+++ b/hw/ccid-card-passthru.c
@@ -273,6 +273,12 @@ static const uint8_t *passthru_get_atr(CCIDCardState *base, uint32_t *len)
return card->atr;
}
+static const QemuChrHandlers passthru_handlers = {
+ .fd_can_read = ccid_card_vscard_can_read,
+ .fd_read = ccid_card_vscard_read,
+ .fd_event = ccid_card_vscard_event,
+};
+
static int passthru_initfn(CCIDCardState *base)
{
PassthruState *card = DO_UPCAST(PassthruState, base, base);
@@ -281,10 +287,7 @@ static int passthru_initfn(CCIDCardState *base)
card->vscard_in_hdr = 0;
if (card->cs) {
DPRINTF(card, D_INFO, "initing chardev\n");
- qemu_chr_add_handlers(card->cs,
- ccid_card_vscard_can_read,
- ccid_card_vscard_read,
- ccid_card_vscard_event, card);
+ qemu_chr_add_handlers(card->cs, &passthru_handlers, card);
ccid_card_vscard_send_init(card);
} else {
error_report("missing chardev");
diff --git a/hw/debugcon.c b/hw/debugcon.c
index 5ee6821..e79a595 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, s);
}
static int debugcon_isa_initfn(ISADevice *dev)
diff --git a/hw/escc.c b/hw/escc.c
index f6fd919..dfa329a 100644
--- a/hw/escc.c
+++ b/hw/escc.c
@@ -898,6 +898,12 @@ void slavio_serial_ms_kbd_init(target_phys_addr_t base, qemu_irq irq,
sysbus_mmio_map(s, 0, base);
}
+static const QemuChrHandlers serial_handlers = {
+ .fd_can_read = serial_can_receive,
+ .fd_read = serial_receive1,
+ .fd_event = serial_event,
+};
+
static int escc_init1(SysBusDevice *dev)
{
SerialState *s = FROM_SYSBUS(SerialState, dev);
@@ -911,8 +917,7 @@ static int escc_init1(SysBusDevice *dev)
s->chn[i].chn = 1 - i;
s->chn[i].clock = s->frequency / 2;
if (s->chn[i].chr) {
- qemu_chr_add_handlers(s->chn[i].chr, serial_can_receive,
- serial_receive1, serial_event, &s->chn[i]);
+ qemu_chr_add_handlers(s->chn[i].chr, &serial_handlers, &s->chn[i]);
}
}
s->chn[0].otherchn = &s->chn[1];
diff --git a/hw/etraxfs_ser.c b/hw/etraxfs_ser.c
index b917d4d..ebbad77 100644
--- a/hw/etraxfs_ser.c
+++ b/hw/etraxfs_ser.c
@@ -202,6 +202,12 @@ static void etraxfs_ser_reset(DeviceState *d)
}
+static const QemuChrHandlers serial_handlers = {
+ .fd_can_read = serial_can_receive,
+ .fd_read = serial_receive,
+ .fd_event = serial_event,
+};
+
static int etraxfs_ser_init(SysBusDevice *dev)
{
struct etrax_serial *s = FROM_SYSBUS(typeof (*s), dev);
@@ -212,10 +218,9 @@ static int etraxfs_ser_init(SysBusDevice *dev)
DEVICE_NATIVE_ENDIAN);
sysbus_init_mmio(dev, R_MAX * 4, ser_regs);
s->chr = qdev_init_chardev(&dev->qdev);
- if (s->chr)
- qemu_chr_add_handlers(s->chr,
- serial_can_receive, serial_receive,
- serial_event, s);
+ if (s->chr) {
+ qemu_chr_add_handlers(s->chr, &serial_handlers, s);
+ }
return 0;
}
diff --git a/hw/grlib_apbuart.c b/hw/grlib_apbuart.c
index 169a56e..310687b 100644
--- a/hw/grlib_apbuart.c
+++ b/hw/grlib_apbuart.c
@@ -144,16 +144,18 @@ static CPUWriteMemoryFunc * const grlib_apbuart_write[] = {
NULL, NULL, grlib_apbuart_writel,
};
+static const QemuChrHandlers grlib_handlers = {
+ .fd_can_read = grlib_apbuart_can_receive,
+ .fd_read = grlib_apbuart_receive,
+ .fd_event = grlib_apbuart_event,
+};
+
static int grlib_apbuart_init(SysBusDevice *dev)
{
UART *uart = FROM_SYSBUS(typeof(*uart), dev);
int uart_regs = 0;
- qemu_chr_add_handlers(uart->chr,
- grlib_apbuart_can_receive,
- grlib_apbuart_receive,
- grlib_apbuart_event,
- uart);
+ qemu_chr_add_handlers(uart->chr, &grlib_handlers, uart);
sysbus_init_irq(dev, &uart->irq);
diff --git a/hw/ivshmem.c b/hw/ivshmem.c
index 3055dd2..4f59575 100644
--- a/hw/ivshmem.c
+++ b/hw/ivshmem.c
@@ -312,6 +312,18 @@ static void fake_irqfd(void *opaque, const uint8_t *buf, int size) {
msix_notify(pdev, entry->vector);
}
+static const QemuChrHandlers ivshmem_handlers = {
+ .fd_can_read = ivshmem_can_receive,
+ .fd_read = ivshmem_receive,
+ .fd_event = ivshmem_event,
+};
+
+static const QemuChrHandlers ivshmem_msi_handlers = {
+ .fd_can_read = ivshmem_can_receive,
+ .fd_read = fake_irqfd,
+ .fd_event = ivshmem_event,
+};
+
static CharDriverState* create_eventfd_chr_device(void * opaque, int eventfd,
int vector)
{
@@ -331,11 +343,10 @@ static CharDriverState* create_eventfd_chr_device(void * opaque, int eventfd,
s->eventfd_table[vector].pdev = &s->dev;
s->eventfd_table[vector].vector = vector;
- qemu_chr_add_handlers(chr, ivshmem_can_receive, fake_irqfd,
- ivshmem_event, &s->eventfd_table[vector]);
+ qemu_chr_add_handlers(chr, &ivshmem_msi_handlers,
+ &s->eventfd_table[vector]);
} else {
- qemu_chr_add_handlers(chr, ivshmem_can_receive, ivshmem_receive,
- ivshmem_event, s);
+ qemu_chr_add_handlers(chr, &ivshmem_handlers, s);
}
return chr;
@@ -666,6 +677,12 @@ static int ivshmem_load(QEMUFile* f, void *opaque, int version_id)
return 0;
}
+static const QemuChrHandlers ivshmem_server_handlers = {
+ .fd_can_read = ivshmem_can_receive,
+ .fd_read = ivshmem_read,
+ .fd_event = ivshmem_event,
+};
+
static int pci_ivshmem_init(PCIDevice *dev)
{
IVShmemState *s = DO_UPCAST(IVShmemState, dev, dev);
@@ -749,8 +766,7 @@ static int pci_ivshmem_init(PCIDevice *dev)
s->eventfd_chr = qemu_mallocz(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, &ivshmem_server_handlers, s);
} else {
/* just map the file immediately, we're not using a server */
int fd;
diff --git a/hw/lm32_juart.c b/hw/lm32_juart.c
index fddcf7e..12dd1e8 100644
--- a/hw/lm32_juart.c
+++ b/hw/lm32_juart.c
@@ -110,13 +110,19 @@ static void juart_reset(DeviceState *d)
s->jrx = 0;
}
+static const QemuChrHandlers juart_handlers = {
+ .fd_can_read = juart_can_rx,
+ .fd_read = juart_rx,
+ .fd_event = juart_event,
+};
+
static int lm32_juart_init(SysBusDevice *dev)
{
LM32JuartState *s = FROM_SYSBUS(typeof(*s), dev);
s->chr = qdev_init_chardev(&dev->qdev);
if (s->chr) {
- qemu_chr_add_handlers(s->chr, juart_can_rx, juart_rx, juart_event, s);
+ qemu_chr_add_handlers(s->chr, juart_handlers, s);
}
return 0;
diff --git a/hw/lm32_uart.c b/hw/lm32_uart.c
index 09090e9..5438660 100644
--- a/hw/lm32_uart.c
+++ b/hw/lm32_uart.c
@@ -242,6 +242,12 @@ static void uart_reset(DeviceState *d)
s->regs[R_LSR] = LSR_THRE | LSR_TEMT;
}
+static const QemuChrHandlers uart_handlers = {
+ .fd_can_read = uart_can_rx,
+ .fd_read = uart_rx,
+ .fd_event = uart_event,
+};
+
static int lm32_uart_init(SysBusDevice *dev)
{
LM32UartState *s = FROM_SYSBUS(typeof(*s), dev);
@@ -255,7 +261,7 @@ static int lm32_uart_init(SysBusDevice *dev)
s->chr = qdev_init_chardev(&dev->qdev);
if (s->chr) {
- qemu_chr_add_handlers(s->chr, uart_can_rx, uart_rx, uart_event, s);
+ qemu_chr_add_handlers(s->chr, uart_handlers, s);
}
return 0;
diff --git a/hw/mcf_uart.c b/hw/mcf_uart.c
index db57096..9928c11 100644
--- a/hw/mcf_uart.c
+++ b/hw/mcf_uart.c
@@ -268,6 +268,12 @@ static void mcf_uart_receive(void *opaque, const uint8_t *buf, int size)
mcf_uart_push_byte(s, buf[0]);
}
+static const QemuChrHandlers mcf_uart_handlers = {
+ .fd_can_read = mcf_uart_can_receive,
+ .fd_read = mcf_uart_receive,
+ .fd_event = mcf_uart_event,
+};
+
void *mcf_uart_init(qemu_irq irq, CharDriverState *chr)
{
mcf_uart_state *s;
@@ -276,8 +282,7 @@ void *mcf_uart_init(qemu_irq irq, CharDriverState *chr)
s->chr = chr;
s->irq = irq;
if (chr) {
- qemu_chr_add_handlers(chr, mcf_uart_can_receive, mcf_uart_receive,
- mcf_uart_event, s);
+ qemu_chr_add_handlers(chr, &mcf_uart_handlers, s);
}
mcf_uart_reset(s);
return s;
diff --git a/hw/milkymist-uart.c b/hw/milkymist-uart.c
index 56c90da..4412b1b 100644
--- a/hw/milkymist-uart.c
+++ b/hw/milkymist-uart.c
@@ -133,6 +133,12 @@ static void milkymist_uart_reset(DeviceState *d)
}
}
+static const QemuChrHandlers uart_handlers = {
+ .fd_can_read = uart_can_rx,
+ .fd_read = uart_rx,
+ .fd_event = uart_event,
+};
+
static int milkymist_uart_init(SysBusDevice *dev)
{
MilkymistUartState *s = FROM_SYSBUS(typeof(*s), dev);
@@ -147,7 +153,7 @@ static int milkymist_uart_init(SysBusDevice *dev)
s->chr = qdev_init_chardev(&dev->qdev);
if (s->chr) {
- qemu_chr_add_handlers(s->chr, uart_can_rx, uart_rx, uart_event, s);
+ qemu_chr_add_handlers(s->chr, uart_handlers, s);
}
return 0;
diff --git a/hw/pl011.c b/hw/pl011.c
index 3b94b14..7b4f3ae 100644
--- a/hw/pl011.c
+++ b/hw/pl011.c
@@ -260,6 +260,12 @@ static const VMStateDescription vmstate_pl011 = {
}
};
+static const QemuChrHandlers pl011_handlers = {
+ .fd_can_read = pl011_can_receive,
+ .fd_read = pl011_receive,
+ .fd_event = pl011_event,
+};
+
static int pl011_init(SysBusDevice *dev, const unsigned char *id)
{
int iomemtype;
@@ -278,8 +284,7 @@ static int pl011_init(SysBusDevice *dev, const unsigned char *id)
s->cr = 0x300;
s->flags = 0x90;
if (s->chr) {
- qemu_chr_add_handlers(s->chr, pl011_can_receive, pl011_receive,
- pl011_event, s);
+ qemu_chr_add_handlers(s->chr, &pl011_handlers, s);
}
vmstate_register(&dev->qdev, -1, &vmstate_pl011, s);
return 0;
diff --git a/hw/pxa2xx.c b/hw/pxa2xx.c
index ac5d95d..779081c 100644
--- a/hw/pxa2xx.c
+++ b/hw/pxa2xx.c
@@ -2019,6 +2019,12 @@ static int pxa2xx_fir_load(QEMUFile *f, void *opaque, int version_id)
return 0;
}
+static const QemuChrHandlers pxa2xx_handlers = {
+ .fd_can_read = pxa2xx_fir_is_empty,
+ .fd_read = pxa2xx_fir_rx,
+ .fd_event = pxa2xx_fir_event,
+};
+
static PXA2xxFIrState *pxa2xx_fir_init(target_phys_addr_t base,
qemu_irq irq, qemu_irq rx_dma, qemu_irq tx_dma,
CharDriverState *chr)
@@ -2038,10 +2044,9 @@ static PXA2xxFIrState *pxa2xx_fir_init(target_phys_addr_t base,
pxa2xx_fir_writefn, s, DEVICE_NATIVE_ENDIAN);
cpu_register_physical_memory(base, 0x1000, iomemtype);
- if (chr)
- qemu_chr_add_handlers(chr, pxa2xx_fir_is_empty,
- pxa2xx_fir_rx, pxa2xx_fir_event, s);
-
+ if (chr) {
+ qemu_chr_add_handlers(chr, &pxa2xx_handlers, s);
+ }
register_savevm(NULL, "pxa2xx_fir", 0, 0, pxa2xx_fir_save,
pxa2xx_fir_load, s);
diff --git a/hw/serial.c b/hw/serial.c
index 0ee61dd..d496bcf 100644
--- a/hw/serial.c
+++ b/hw/serial.c
@@ -727,6 +727,12 @@ static void serial_reset(void *opaque)
qemu_irq_lower(s->irq);
}
+static const QemuChrHandlers serial_handlers = {
+ .fd_can_read = serial_can_receive1,
+ .fd_read = serial_receive1,
+ .fd_event = serial_event,
+};
+
static void serial_init_core(SerialState *s)
{
if (!s->chr) {
@@ -741,8 +747,7 @@ static void serial_init_core(SerialState *s)
qemu_register_reset(serial_reset, s);
- qemu_chr_add_handlers(s->chr, serial_can_receive1, serial_receive1,
- serial_event, s);
+ qemu_chr_add_handlers(s->chr, &serial_handlers, s);
}
/* Change the main reference oscillator frequency. */
diff --git a/hw/sh_serial.c b/hw/sh_serial.c
index 191f4a6..8b6460d 100644
--- a/hw/sh_serial.c
+++ b/hw/sh_serial.c
@@ -350,6 +350,12 @@ static CPUWriteMemoryFunc * const sh_serial_writefn[] = {
&sh_serial_write,
};
+static const QemuChrHandlers sh_serial_handlers = {
+ .fd_can_read = sh_serial_can_receive1,
+ .fd_read = sh_serial_receive1,
+ .fd_event = sh_serial_event,
+};
+
void sh_serial_init (target_phys_addr_t base, int feat,
uint32_t freq, CharDriverState *chr,
qemu_irq eri_source,
@@ -389,9 +395,9 @@ void sh_serial_init (target_phys_addr_t base, int feat,
s->chr = chr;
- if (chr)
- qemu_chr_add_handlers(chr, sh_serial_can_receive1, sh_serial_receive1,
- sh_serial_event, s);
+ if (chr) {
+ qemu_chr_add_handlers(chr, &sh_serial_handlers, s);
+ }
s->eri = eri_source;
s->rxi = rxi_source;
diff --git a/hw/spapr_vty.c b/hw/spapr_vty.c
index 6fc0105..5968d85 100644
--- a/hw/spapr_vty.c
+++ b/hw/spapr_vty.c
@@ -54,12 +54,16 @@ void vty_putchars(VIOsPAPRDevice *sdev, uint8_t *buf, int len)
qemu_chr_write(dev->chardev, buf, len);
}
+static const QemuChrHandlers vty_handlers = {
+ .fd_can_read = vty_can_receive,
+ .fd_read = vty_receive,
+};
+
static int spapr_vty_init(VIOsPAPRDevice *sdev)
{
VIOsPAPRVTYDevice *dev = (VIOsPAPRVTYDevice *)sdev;
- qemu_chr_add_handlers(dev->chardev, vty_can_receive,
- vty_receive, NULL, dev);
+ qemu_chr_add_handlers(dev->chardev, vty_handlers, dev);
return 0;
}
diff --git a/hw/strongarm.c b/hw/strongarm.c
index 0e03d61..c2dce95 100644
--- a/hw/strongarm.c
+++ b/hw/strongarm.c
@@ -1188,6 +1188,12 @@ static CPUWriteMemoryFunc * const strongarm_uart_writefn[] = {
strongarm_uart_write,
};
+static const QemuChrHandlers strongarm_uart_handlers = {
+ .fd_can_read = strongarm_uart_can_receive,
+ .fd_read = strongarm_uart_receive,
+ .fd_event = strongarm_uart_event,
+};
+
static int strongarm_uart_init(SysBusDevice *dev)
{
StrongARMUARTState *s = FROM_SYSBUS(StrongARMUARTState, dev);
@@ -1202,11 +1208,7 @@ static int strongarm_uart_init(SysBusDevice *dev)
s->tx_timer = qemu_new_timer_ns(vm_clock, strongarm_uart_tx, s);
if (s->chr) {
- qemu_chr_add_handlers(s->chr,
- strongarm_uart_can_receive,
- strongarm_uart_receive,
- strongarm_uart_event,
- s);
+ qemu_chr_add_handlers(s->chr, &strongarm_uart_handlers, s);
}
return 0;
diff --git a/hw/syborg_serial.c b/hw/syborg_serial.c
index 2ef7175..ac68022 100644
--- a/hw/syborg_serial.c
+++ b/hw/syborg_serial.c
@@ -292,6 +292,12 @@ static const VMStateDescription vmstate_syborg_serial = {
}
};
+static const QemuChrHandlers syborg_serial_handlers = {
+ .fd_can_read = syborg_serial_can_receive,
+ .fd_read = syborg_serial_receive,
+ .fd_event = syborg_serial_event,
+};
+
static int syborg_serial_init(SysBusDevice *dev)
{
SyborgSerialState *s = FROM_SYSBUS(SyborgSerialState, dev);
@@ -304,8 +310,7 @@ static int syborg_serial_init(SysBusDevice *dev)
sysbus_init_mmio(dev, 0x1000, iomemtype);
s->chr = qdev_init_chardev(&dev->qdev);
if (s->chr) {
- qemu_chr_add_handlers(s->chr, syborg_serial_can_receive,
- syborg_serial_receive, syborg_serial_event, s);
+ qemu_chr_add_handlers(s->chr, &syborg_serial_handlers, s);
}
if (s->fifo_size <= 0) {
fprintf(stderr, "syborg_serial: fifo too small\n");
diff --git a/hw/usb-serial.c b/hw/usb-serial.c
index 59cb0fb..bebd900 100644
--- a/hw/usb-serial.c
+++ b/hw/usb-serial.c
@@ -476,6 +476,12 @@ static void usb_serial_event(void *opaque, int event)
}
}
+static const QemuChrHandlers usb_serial_handlers = {
+ .fd_can_read = usb_serial_can_read,
+ .fd_read = usb_serial_read,
+ .fd_event = usb_serial_event,
+};
+
static int usb_serial_initfn(USBDevice *dev)
{
USBSerialState *s = DO_UPCAST(USBSerialState, dev, dev);
@@ -487,8 +493,7 @@ static int usb_serial_initfn(USBDevice *dev)
return -1;
}
- qemu_chr_add_handlers(s->cs, usb_serial_can_read, usb_serial_read,
- usb_serial_event, s);
+ qemu_chr_add_handlers(s->cs, &usb_serial_handlers, s);
usb_serial_handle_reset(dev);
return 0;
}
diff --git a/hw/virtio-console.c b/hw/virtio-console.c
index b076331..147a467 100644
--- a/hw/virtio-console.c
+++ b/hw/virtio-console.c
@@ -74,6 +74,12 @@ static void chr_event(void *opaque, int event)
}
}
+static const QemuChrHandlers chr_handlers = {
+ .fd_can_read = chr_can_read,
+ .fd_read = chr_read,
+ .fd_event = chr_event,
+};
+
static int virtconsole_initfn(VirtIOSerialPort *port)
{
VirtConsole *vcon = DO_UPCAST(VirtConsole, port, port);
@@ -86,8 +92,7 @@ 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_handlers, vcon);
info->have_data = flush_buf;
info->guest_open = guest_open;
info->guest_close = guest_close;
@@ -105,7 +110,7 @@ static int virtconsole_exitfn(VirtIOSerialPort *port)
* Instead of closing the chardev, free it so it can be used
* for other purposes.
*/
- qemu_chr_add_handlers(vcon->chr, NULL, NULL, NULL, NULL);
+ qemu_chr_add_handlers(vcon->chr, NULL, NULL);
}
return 0;
diff --git a/hw/xen_console.c b/hw/xen_console.c
index c6c8163..4c39310 100644
--- a/hw/xen_console.c
+++ b/hw/xen_console.c
@@ -201,6 +201,11 @@ static int con_init(struct XenDevice *xendev)
return 0;
}
+static const QemuChrHandlers xencons_handlers = {
+ .fd_can_read = xencons_can_receive,
+ .fd_read = xencons_receive,
+};
+
static int con_connect(struct XenDevice *xendev)
{
struct XenConsole *con = container_of(xendev, struct XenConsole, xendev);
@@ -221,9 +226,9 @@ static int con_connect(struct XenDevice *xendev)
return -1;
xen_be_bind_evtchn(&con->xendev);
- if (con->chr)
- qemu_chr_add_handlers(con->chr, xencons_can_receive, xencons_receive,
- NULL, con);
+ if (con->chr) {
+ qemu_chr_add_handlers(con->chr, &xencons_handlers, con);
+ }
xen_be_printf(xendev, 1, "ring mfn %d, remote port %d, local port %d, limit %zd\n",
con->ring_ref,
@@ -237,8 +242,9 @@ static void con_disconnect(struct XenDevice *xendev)
{
struct XenConsole *con = container_of(xendev, struct XenConsole, xendev);
- if (con->chr)
- qemu_chr_add_handlers(con->chr, NULL, NULL, NULL, NULL);
+ if (con->chr) {
+ qemu_chr_add_handlers(con->chr, NULL, NULL);
+ }
xen_be_unbind_evtchn(&con->xendev);
if (con->sring) {
diff --git a/hw/xilinx_uartlite.c b/hw/xilinx_uartlite.c
index 9b94e98..1845577 100644
--- a/hw/xilinx_uartlite.c
+++ b/hw/xilinx_uartlite.c
@@ -193,6 +193,12 @@ static void uart_event(void *opaque, int event)
}
+static const QemuChrHandlers uart_handlers = {
+ .fd_can_read = uart_can_rx,
+ .fd_read = uart_rx,
+ .fd_event = uart_event,
+};
+
static int xilinx_uartlite_init(SysBusDevice *dev)
{
struct xlx_uartlite *s = FROM_SYSBUS(typeof (*s), dev);
@@ -206,8 +212,9 @@ static int xilinx_uartlite_init(SysBusDevice *dev)
sysbus_init_mmio(dev, R_MAX * 4, uart_regs);
s->chr = qdev_init_chardev(&dev->qdev);
- if (s->chr)
- qemu_chr_add_handlers(s->chr, uart_can_rx, uart_rx, uart_event, s);
+ if (s->chr) {
+ qemu_chr_add_handlers(s->chr, &uart_handlers, s);
+ }
return 0;
}
diff --git a/monitor.c b/monitor.c
index a6388a9..5e7ce62 100644
--- a/monitor.c
+++ b/monitor.c
@@ -5238,6 +5238,18 @@ static void monitor_event(void *opaque, int event)
* End:
*/
+static const QemuChrHandlers monitor_handlers = {
+ .fd_can_read = monitor_can_read,
+ .fd_read = monitor_read,
+ .fd_event = monitor_event,
+};
+
+static const QemuChrHandlers monitor_control_handlers = {
+ .fd_can_read = monitor_can_read,
+ .fd_read = monitor_control_read,
+ .fd_event = monitor_control_event,
+};
+
void monitor_init(CharDriverState *chr, int flags)
{
static int is_first_init = 1;
@@ -5260,12 +5272,10 @@ void monitor_init(CharDriverState *chr, int flags)
if (monitor_ctrl_mode(mon)) {
mon->mc = qemu_mallocz(sizeof(MonitorControl));
/* Control mode requires special handlers */
- qemu_chr_add_handlers(chr, monitor_can_read, monitor_control_read,
- monitor_control_event, mon);
+ qemu_chr_add_handlers(chr, &monitor_control_handlers, mon);
qemu_chr_set_echo(chr, true);
} else {
- qemu_chr_add_handlers(chr, monitor_can_read, monitor_read,
- monitor_event, mon);
+ qemu_chr_add_handlers(chr, &monitor_handlers, mon);
}
QLIST_INSERT_HEAD(&mon_list, mon, entry);
diff --git a/net/slirp.c b/net/slirp.c
index e057a14..6eb0c51 100644
--- a/net/slirp.c
+++ b/net/slirp.c
@@ -576,6 +576,11 @@ static void guestfwd_read(void *opaque, const uint8_t *buf, int size)
slirp_socket_recv(fwd->slirp, fwd->server, fwd->port, buf, size);
}
+static const QemuChrHandlers guestfwd_handlers = {
+ .fd_can_read = guestfwd_can_read,
+ .fd_read = guestfwd_read,
+};
+
static int slirp_guestfwd(SlirpState *s, const char *config_str,
int legacy_format)
{
@@ -632,8 +637,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,
- NULL, fwd);
+ qemu_chr_add_handlers(fwd->hd, &guestfwd_handlers, fwd);
return 0;
fail_syntax:
diff --git a/qemu-char.c b/qemu-char.c
index 75efa60..ee763d5 100644
--- a/qemu-char.c
+++ b/qemu-char.c
@@ -190,19 +190,26 @@ void qemu_chr_send_event(CharDriverState *s, int event)
s->chr_send_event(s, event);
}
+static const QemuChrHandlers null_handlers = {
+ /* All handlers are initialised to NULL */
+};
+
void qemu_chr_add_handlers(CharDriverState *s,
- IOCanReadHandler *fd_can_read,
- IOReadHandler *fd_read,
- IOEventHandler *fd_event,
- void *opaque)
+ const QemuChrHandlers *handlers, void *opaque)
{
- if (!opaque && !fd_can_read && !fd_read && !fd_event) {
+ if (!s) {
+ return;
+ }
+ if (!opaque && !handlers) {
/* chr driver being released. */
++s->avail_connections;
}
- s->chr_can_read = fd_can_read;
- s->chr_read = fd_read;
- s->chr_event = fd_event;
+ if (!handlers) {
+ handlers = &null_handlers;
+ }
+ s->chr_can_read = handlers->fd_can_read;
+ s->chr_read = handlers->fd_read;
+ s->chr_event = handlers->fd_event;
s->handler_opaque = opaque;
if (s->chr_update_read_handler)
s->chr_update_read_handler(s);
@@ -440,6 +447,12 @@ static void mux_chr_event(void *opaque, int event)
mux_chr_send_event(d, i, event);
}
+static const QemuChrHandlers mux_chr_handlers = {
+ .fd_can_read = mux_chr_can_read,
+ .fd_read = mux_chr_read,
+ .fd_event = mux_chr_event,
+};
+
static void mux_chr_update_read_handler(CharDriverState *chr)
{
MuxDriver *d = chr->opaque;
@@ -454,8 +467,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,
- mux_chr_event, chr);
+ qemu_chr_add_handlers(d->drv, &mux_chr_handlers, chr);
}
if (d->focus != -1) {
mux_chr_send_event(d, d->focus, CHR_EVENT_MUX_OUT);
diff --git a/qemu-char.h b/qemu-char.h
index 892c6da..c8e3f2b 100644
--- a/qemu-char.h
+++ b/qemu-char.h
@@ -1,6 +1,7 @@
#ifndef QEMU_CHAR_H
#define QEMU_CHAR_H
+#include <stdbool.h>
#include "qemu-common.h"
#include "qemu-queue.h"
#include "qemu-option.h"
@@ -76,6 +77,13 @@ struct CharDriverState {
QTAILQ_ENTRY(CharDriverState) next;
};
+typedef struct QemuChrHandlers {
+ IOCanReadHandler *fd_can_read;
+ IOReadHandler *fd_read;
+ IOHandler *fd_write_unblocked;
+ IOEventHandler *fd_event;
+} QemuChrHandlers;
+
QemuOpts *qemu_chr_parse_compat(const char *label, const char *filename);
CharDriverState *qemu_chr_open_opts(QemuOpts *opts,
void (*init)(struct CharDriverState *s));
@@ -88,10 +96,7 @@ void qemu_chr_printf(CharDriverState *s, const char *fmt, ...)
GCC_FMT_ATTR(2, 3);
int qemu_chr_write(CharDriverState *s, const uint8_t *buf, int len);
void qemu_chr_send_event(CharDriverState *s, int event);
-void qemu_chr_add_handlers(CharDriverState *s,
- IOCanReadHandler *fd_can_read,
- IOReadHandler *fd_read,
- IOEventHandler *fd_event,
+void qemu_chr_add_handlers(CharDriverState *s, const QemuChrHandlers *handlers,
void *opaque);
int qemu_chr_ioctl(CharDriverState *s, int cmd, void *arg);
void qemu_chr_generic_open(CharDriverState *s);
diff --git a/usb-redir.c b/usb-redir.c
index e212993..e2b5a2c 100644
--- a/usb-redir.c
+++ b/usb-redir.c
@@ -782,6 +782,12 @@ static void usbredir_chardev_event(void *opaque, int event)
}
}
+static const QemuChrHandlers usbredir_chr_handlers = {
+ .fd_can_read = usbredir_chardev_can_read,
+ .fd_read = usbredir_chardev_read,
+ .fd_event = usbredir_chardev_event,
+};
+
/*
* init + destroy
*/
@@ -807,8 +813,7 @@ static int usbredir_initfn(USBDevice *udev)
/* We'll do the attach once we receive the speed from the usb-host */
udev->auto_attach = 0;
- qemu_chr_add_handlers(dev->cs, usbredir_chardev_can_read,
- usbredir_chardev_read, usbredir_chardev_event, dev);
+ qemu_chr_add_handlers(dev->cs, &usbredir_chr_handlers, dev);
return 0;
}
--
1.7.5.1