From 61efa48e1973eaac16615c85198d9d74e36a3124 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 107/118] 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 640cf4e..b984e12 100644

--- a/gdbstub.c

+++ b/gdbstub.c

@@ -2860,6 +2860,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;

@@ -2889,8 +2895,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 9f51c6c..c5bff01 100644

--- a/hw/ccid-card-passthru.c

+++ b/hw/ccid-card-passthru.c

@@ -274,6 +274,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);

@@ -282,10 +288,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 c9ee6d9..1d3c3ca 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 13c7e66..997377e 100644

--- a/hw/escc.c

+++ b/hw/escc.c

@@ -867,6 +867,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);

@@ -879,8 +885,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 298b985..29d486e 100644

--- a/hw/etraxfs_ser.c

+++ b/hw/etraxfs_ser.c

@@ -208,6 +208,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);

@@ -217,10 +223,9 @@ static int etraxfs_ser_init(SysBusDevice *dev)

     sysbus_init_mmio_region(dev, &s->mmio);

     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 c90b810..ac6c33b 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 7b4dbf6..ee78576 100644

--- a/hw/ivshmem.c

+++ b/hw/ivshmem.c

@@ -276,6 +276,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)

 {

@@ -295,11 +307,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;

@@ -614,6 +625,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);

@@ -703,8 +720,7 @@ 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, &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 5454aa4..1b9fa07 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 3678545..ccaf88c 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 e6b2ab0..2870683 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 5404ca9..fd10e12 100644

--- a/hw/milkymist-uart.c

+++ b/hw/milkymist-uart.c

@@ -189,6 +189,12 @@ static void milkymist_uart_reset(DeviceState *d)

     s->regs[R_STAT] = STAT_THRE;

 }

+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);

@@ -201,7 +207,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 707a161..7482246 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 e9a507e..24925b6 100644

--- a/hw/pxa2xx.c

+++ b/hw/pxa2xx.c

@@ -1984,6 +1984,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(MemoryRegion *sysmem,

                 target_phys_addr_t base,

                 qemu_irq irq, qemu_irq rx_dma, qemu_irq tx_dma,

@@ -2002,10 +2008,9 @@ static PXA2xxFIrState *pxa2xx_fir_init(MemoryRegion *sysmem,

     memory_region_init_io(&s->iomem, &pxa2xx_fir_ops, s, "pxa2xx-fir", 0x1000);

     memory_region_add_subregion(sysmem, base, &s->iomem);

-    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 d35c7a9..6499d4a 100644

--- a/hw/serial.c

+++ b/hw/serial.c

@@ -728,6 +728,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) {

@@ -742,8 +748,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 a20c59e..470ce7a 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 f23cc36..0d9cd59 100644

--- a/hw/spapr_vty.c

+++ b/hw/spapr_vty.c

@@ -54,6 +54,11 @@ void vty_putchars(VIOsPAPRDevice *sdev, uint8_t *buf, int len)

     qemu_chr_fe_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;

@@ -63,8 +68,7 @@ static int spapr_vty_init(VIOsPAPRDevice *sdev)

         exit(1);

     }

-    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 a3d9080..8a8a219 100644

--- a/hw/strongarm.c

+++ b/hw/strongarm.c

@@ -1160,6 +1160,12 @@ static const MemoryRegionOps strongarm_uart_ops = {

     .endianness = DEVICE_NATIVE_ENDIAN,

 };

+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);

@@ -1172,11 +1178,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 c83f82c..fff76da 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 7dbf6df..bcf6622 100644

--- a/hw/usb-serial.c

+++ b/hw/usb-serial.c

@@ -482,6 +482,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);

@@ -493,8 +499,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 d3351c8..6d6f3ef 100644

--- a/hw/virtio-console.c

+++ b/hw/virtio-console.c

@@ -95,6 +95,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);

@@ -107,8 +113,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;

@@ -126,7 +131,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 edcb31c..2ba74f0 100644

--- a/hw/xen_console.c

+++ b/hw/xen_console.c

@@ -212,6 +212,11 @@ out:

     return ret;

 }

+static const QemuChrHandlers xencons_handlers = {

+    .fd_can_read = xencons_can_receive,

+    .fd_read = xencons_receive,

+};

+

 static int con_initialise(struct XenDevice *xendev)

 {

     struct XenConsole *con = container_of(xendev, struct XenConsole, xendev);

@@ -232,9 +237,9 @@ static int con_initialise(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,

@@ -248,8 +253,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 ceb7b4d..69f7191 100644

--- a/hw/xilinx_uartlite.c

+++ b/hw/xilinx_uartlite.c

@@ -195,6 +195,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_region(dev, &s->mmio);

     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 f956eb7..a82fda3 100644

--- a/monitor.c

+++ b/monitor.c

@@ -4882,6 +4882,18 @@ static void sortcmdlist(void)

  * 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;

@@ -4904,12 +4916,10 @@ 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,

-                              monitor_control_event, mon);

+        qemu_chr_add_handlers(chr, &monitor_control_handlers, mon);

         qemu_chr_fe_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 6646ecb..05405ff 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 a5ca611..d2a99a6 100644

--- a/qemu-char.c

+++ b/qemu-char.c

@@ -189,19 +189,26 @@ void qemu_chr_fe_printf(CharDriverState *s, const char *fmt, ...)

     va_end(ap);

 }

+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);

@@ -441,6 +448,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;

@@ -455,8 +468,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 8ca1e2d..564e688 100644

--- a/qemu-char.h

+++ b/qemu-char.h

@@ -222,10 +222,15 @@ 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,

-                           IOCanReadHandler *fd_can_read,

-                           IOReadHandler *fd_read,

-                           IOEventHandler *fd_event,

+

+typedef struct QemuChrHandlers {

+    IOCanReadHandler *fd_can_read;

+    IOReadHandler *fd_read;

+    IOHandler *fd_write_unblocked;

+    IOEventHandler *fd_event;

+} QemuChrHandlers;

+

+void qemu_chr_add_handlers(CharDriverState *s, const QemuChrHandlers *handlers,

                            void *opaque);

 void qemu_chr_generic_open(CharDriverState *s);

diff --git a/usb-redir.c b/usb-redir.c

index 86bccf8..e421cff 100644

--- a/usb-redir.c

+++ b/usb-redir.c

@@ -865,6 +865,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

  */

@@ -892,8 +898,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,

-                          usbredir_chardev_read, usbredir_chardev_event, dev);

+    qemu_chr_add_handlers(dev->cs, &usbredir_chr_handlers, dev);

     return 0;

 }

-- 

1.7.7.5