Use a single allocation for CharDriverState, this avoids extra allocations & pointers, and is a step towards more object-oriented CharDriver.
Gtk console is a bit peculiar, gd_vc_chr_set_echo() used to have a temporary VirtualConsole to save the echo bit. Instead now, we consider whether vcd->console is set or not, and restore the echo bit saved in VCDriverState when calling gd_vc_vte_init(). The casts added are temporary, they are replaced with QOM type-safe macros in a later patch in this series. Signed-off-by: Marc-André Lureau <[email protected]> Reviewed-by: Eric Blake <[email protected]> --- include/sysemu/char.h | 2 +- backends/baum.c | 23 ++--- backends/msmouse.c | 16 +-- backends/testdev.c | 22 ++-- gdbstub.c | 1 + hw/bt/hci-csr.c | 10 +- qemu-char.c | 280 ++++++++++++++++++++++++++------------------------ spice-qemu-char.c | 39 +++---- ui/console.c | 21 ++-- ui/gtk.c | 30 ++++-- 10 files changed, 230 insertions(+), 214 deletions(-) diff --git a/include/sysemu/char.h b/include/sysemu/char.h index 4877439ebf..876ea7e72d 100644 --- a/include/sysemu/char.h +++ b/include/sysemu/char.h @@ -93,7 +93,6 @@ struct CharDriverState { const CharDriver *driver; QemuMutex chr_write_lock; CharBackend *be; - void *opaque; char *label; char *filename; int logfd; @@ -484,6 +483,7 @@ struct CharDriver { ChardevBackend *backend, ChardevReturn *ret, bool *be_opened, Error **errp); + size_t instance_size; int (*chr_write)(struct CharDriverState *s, const uint8_t *buf, int len); int (*chr_sync_read)(struct CharDriverState *s, diff --git a/backends/baum.c b/backends/baum.c index 109469e8f7..4b48cf02b9 100644 --- a/backends/baum.c +++ b/backends/baum.c @@ -85,7 +85,7 @@ #define BUF_SIZE 256 typedef struct { - CharDriverState *chr; + CharDriverState parent; brlapi_handle_t *brlapi; int brlapi_fd; @@ -255,7 +255,7 @@ static int baum_deferred_init(BaumDriverState *baum) /* The serial port can receive more of our data */ static void baum_accept_input(struct CharDriverState *chr) { - BaumDriverState *baum = chr->opaque; + BaumDriverState *baum = (BaumDriverState *)chr; int room, first; if (!baum->out_buf_used) @@ -281,22 +281,23 @@ static void baum_accept_input(struct CharDriverState *chr) /* We want to send a packet */ static void baum_write_packet(BaumDriverState *baum, const uint8_t *buf, int len) { + CharDriverState *chr = (CharDriverState *)baum; uint8_t io_buf[1 + 2 * len], *cur = io_buf; int room; *cur++ = ESC; while (len--) if ((*cur++ = *buf++) == ESC) *cur++ = ESC; - room = qemu_chr_be_can_write(baum->chr); + room = qemu_chr_be_can_write(chr); len = cur - io_buf; if (len <= room) { /* Fits */ - qemu_chr_be_write(baum->chr, io_buf, len); + qemu_chr_be_write(chr, io_buf, len); } else { int first; uint8_t out; /* Can't fit all, send what can be, and store the rest. */ - qemu_chr_be_write(baum->chr, io_buf, room); + qemu_chr_be_write(chr, io_buf, room); len -= room; cur = io_buf + room; if (len > BUF_SIZE - baum->out_buf_used) { @@ -471,7 +472,7 @@ static int baum_eat_packet(BaumDriverState *baum, const uint8_t *buf, int len) /* The other end is writing some data. Store it and try to interpret */ static int baum_write(CharDriverState *chr, const uint8_t *buf, int len) { - BaumDriverState *baum = chr->opaque; + BaumDriverState *baum = (BaumDriverState *)chr; int tocopy, cur, eaten, orig_len = len; if (!len) @@ -612,14 +613,13 @@ static void baum_chr_read(void *opaque) static void baum_free(struct CharDriverState *chr) { - BaumDriverState *baum = chr->opaque; + BaumDriverState *baum = (BaumDriverState *)chr; timer_free(baum->cellCount_timer); if (baum->brlapi) { brlapi__closeConnection(baum->brlapi); g_free(baum->brlapi); } - g_free(baum); } static CharDriverState *chr_baum_init(const CharDriver *driver, @@ -638,10 +638,7 @@ static CharDriverState *chr_baum_init(const CharDriver *driver, if (!chr) { return NULL; } - baum = g_malloc0(sizeof(BaumDriverState)); - baum->chr = chr; - - chr->opaque = baum; + baum = (BaumDriverState *)chr; handle = g_malloc0(brlapi_getHandleSize()); baum->brlapi = handle; @@ -663,13 +660,13 @@ static CharDriverState *chr_baum_init(const CharDriver *driver, fail_handle: g_free(handle); g_free(chr); - g_free(baum); return NULL; } static void register_types(void) { static const CharDriver driver = { + .instance_size = sizeof(BaumDriverState), .kind = CHARDEV_BACKEND_KIND_BRAILLE, .create = chr_baum_init, .chr_write = baum_write, diff --git a/backends/msmouse.c b/backends/msmouse.c index 2c238ba1b3..30087b358f 100644 --- a/backends/msmouse.c +++ b/backends/msmouse.c @@ -31,7 +31,8 @@ #define MSMOUSE_HI2(n) (((n) & 0xc0) >> 6) typedef struct { - CharDriverState *chr; + CharDriverState parent; + QemuInputHandlerState *hs; int axis[INPUT_AXIS__MAX]; bool btns[INPUT_BUTTON__MAX]; @@ -42,7 +43,7 @@ typedef struct { static void msmouse_chr_accept_input(CharDriverState *chr) { - MouseState *mouse = chr->opaque; + MouseState *mouse = (MouseState *)chr; int len; len = qemu_chr_be_can_write(chr); @@ -122,9 +123,10 @@ static void msmouse_input_event(DeviceState *dev, QemuConsole *src, static void msmouse_input_sync(DeviceState *dev) { MouseState *mouse = (MouseState *)dev; + CharDriverState *chr = (CharDriverState *)dev; msmouse_queue_event(mouse); - msmouse_chr_accept_input(mouse->chr); + msmouse_chr_accept_input(chr); } static int msmouse_chr_write (struct CharDriverState *s, const uint8_t *buf, int len) @@ -135,10 +137,9 @@ static int msmouse_chr_write (struct CharDriverState *s, const uint8_t *buf, int static void msmouse_chr_free(struct CharDriverState *chr) { - MouseState *mouse = chr->opaque; + MouseState *mouse = (MouseState *)chr; qemu_input_handler_unregister(mouse->hs); - g_free(mouse); } static QemuInputHandler msmouse_handler = { @@ -165,12 +166,10 @@ static CharDriverState *qemu_chr_open_msmouse(const CharDriver *driver, } *be_opened = false; - mouse = g_new0(MouseState, 1); + mouse = (MouseState *)chr; mouse->hs = qemu_input_handler_register((DeviceState *)mouse, &msmouse_handler); - mouse->chr = chr; - chr->opaque = mouse; return chr; } @@ -178,6 +177,7 @@ static CharDriverState *qemu_chr_open_msmouse(const CharDriver *driver, static void register_types(void) { static const CharDriver driver = { + .instance_size = sizeof(MouseState), .kind = CHARDEV_BACKEND_KIND_MSMOUSE, .create = qemu_chr_open_msmouse, .chr_write = msmouse_chr_write, diff --git a/backends/testdev.c b/backends/testdev.c index 233969391b..dfa4fe14a1 100644 --- a/backends/testdev.c +++ b/backends/testdev.c @@ -30,7 +30,8 @@ #define BUF_SIZE 32 typedef struct { - CharDriverState *chr; + CharDriverState parent; + uint8_t in_buf[32]; int in_buf_used; } TestdevCharState; @@ -79,7 +80,7 @@ static int testdev_eat_packet(TestdevCharState *testdev) /* The other end is writing some data. Store it and try to interpret */ static int testdev_write(CharDriverState *chr, const uint8_t *buf, int len) { - TestdevCharState *testdev = chr->opaque; + TestdevCharState *testdev = (TestdevCharState *)chr; int tocopy, eaten, orig_len = len; while (len) { @@ -102,13 +103,6 @@ static int testdev_write(CharDriverState *chr, const uint8_t *buf, int len) return orig_len; } -static void testdev_free(struct CharDriverState *chr) -{ - TestdevCharState *testdev = chr->opaque; - - g_free(testdev); -} - static CharDriverState *chr_testdev_init(const CharDriver *driver, const char *id, ChardevBackend *backend, @@ -116,14 +110,10 @@ static CharDriverState *chr_testdev_init(const CharDriver *driver, bool *be_opened, Error **errp) { - TestdevCharState *testdev; - CharDriverState *chr; - - testdev = g_new0(TestdevCharState, 1); - testdev->chr = chr = g_new0(CharDriverState, 1); + TestdevCharState *testdev = g_new0(TestdevCharState, 1);; + CharDriverState *chr = (CharDriverState *)testdev; chr->driver = driver; - chr->opaque = testdev; return chr; } @@ -131,10 +121,10 @@ static CharDriverState *chr_testdev_init(const CharDriver *driver, static void register_types(void) { static const CharDriver driver = { + .instance_size = sizeof(TestdevCharState), .kind = CHARDEV_BACKEND_KIND_TESTDEV, .create = chr_testdev_init, .chr_write = testdev_write, - .chr_free = testdev_free, }; register_char_driver(&driver); } diff --git a/gdbstub.c b/gdbstub.c index 5dfba33eb9..a8def2fd6f 100644 --- a/gdbstub.c +++ b/gdbstub.c @@ -1731,6 +1731,7 @@ int gdbserver_start(const char *device) CharDriverState *mon_chr; ChardevCommon common = { 0 }; static const CharDriver driver = { + .instance_size = sizeof(CharDriverState), .kind = -1, .chr_write = gdb_monitor_write }; diff --git a/hw/bt/hci-csr.c b/hw/bt/hci-csr.c index 9c3fb3c8f9..bf2deb0497 100644 --- a/hw/bt/hci-csr.c +++ b/hw/bt/hci-csr.c @@ -28,11 +28,11 @@ #include "hw/bt.h" struct csrhci_s { + CharDriverState chr; int enable; qemu_irq *pins; int pin_state; int modem_state; - CharDriverState chr; #define FIFO_LEN 4096 int out_start; int out_len; @@ -314,7 +314,7 @@ static void csrhci_ready_for_next_inpkt(struct csrhci_s *s) static int csrhci_write(struct CharDriverState *chr, const uint8_t *buf, int len) { - struct csrhci_s *s = (struct csrhci_s *) chr->opaque; + struct csrhci_s *s = (struct csrhci_s *)chr; int total = 0; if (!s->enable) @@ -387,7 +387,7 @@ static void csrhci_out_hci_packet_acl(void *opaque, static int csrhci_ioctl(struct CharDriverState *chr, int cmd, void *arg) { QEMUSerialSetParams *ssp; - struct csrhci_s *s = (struct csrhci_s *) chr->opaque; + struct csrhci_s *s = (struct csrhci_s *) chr; int prev_state = s->modem_state; switch (cmd) { @@ -455,7 +455,7 @@ static void csrhci_pins(void *opaque, int line, int level) qemu_irq *csrhci_pins_get(CharDriverState *chr) { - struct csrhci_s *s = (struct csrhci_s *) chr->opaque; + struct csrhci_s *s = (struct csrhci_s *) chr; return s->pins; } @@ -463,6 +463,7 @@ qemu_irq *csrhci_pins_get(CharDriverState *chr) CharDriverState *uart_hci_init(void) { static const CharDriver hci_driver = { + .instance_size = sizeof(struct csrhci_s), .kind = -1, .chr_write = csrhci_write, .chr_ioctl = csrhci_ioctl, @@ -470,7 +471,6 @@ CharDriverState *uart_hci_init(void) struct csrhci_s *s = (struct csrhci_s *) g_malloc0(sizeof(struct csrhci_s)); - s->chr.opaque = s; s->chr.driver = &hci_driver; s->hci = qemu_next_hci(); diff --git a/qemu-char.c b/qemu-char.c index aea8469163..2215ba94fb 100644 --- a/qemu-char.c +++ b/qemu-char.c @@ -165,12 +165,14 @@ static void qemu_chr_free_common(CharDriverState *chr); CharDriverState *qemu_chr_alloc(const CharDriver *driver, ChardevCommon *backend, Error **errp) { - CharDriverState *chr = g_malloc0(sizeof(CharDriverState)); - qemu_mutex_init(&chr->chr_write_lock); + CharDriverState *chr; assert(driver); assert(driver->chr_write); + assert(driver->instance_size >= sizeof(CharDriverState)); + chr = g_malloc0(driver->instance_size); + qemu_mutex_init(&chr->chr_write_lock); if (backend->has_logfile) { int flags = O_WRONLY | O_CREAT; if (backend->has_logappend && @@ -536,6 +538,7 @@ static CharDriverState *qemu_chr_open_null(const CharDriver *driver, } static const CharDriver null_driver = { + .instance_size = sizeof(CharDriverState), .kind = CHARDEV_BACKEND_KIND_NULL, .create = qemu_chr_open_null, .chr_write = null_chr_write, @@ -546,6 +549,7 @@ static const CharDriver null_driver = { #define MUX_BUFFER_SIZE 32 /* Must be a power of 2. */ #define MUX_BUFFER_MASK (MUX_BUFFER_SIZE - 1) struct MuxDriver { + CharDriverState parent; CharBackend *backends[MAX_MUX]; CharBackend chr; int focus; @@ -568,7 +572,7 @@ struct MuxDriver { /* Called with chr_write_lock held. */ static int mux_chr_write(CharDriverState *chr, const uint8_t *buf, int len) { - MuxDriver *d = chr->opaque; + MuxDriver *d = (MuxDriver *)chr; int ret; if (!d->timestamps) { ret = qemu_chr_fe_write(&d->chr, buf, len); @@ -702,7 +706,7 @@ static int mux_proc_byte(CharDriverState *chr, MuxDriver *d, int ch) static void mux_chr_accept_input(CharDriverState *chr) { - MuxDriver *d = chr->opaque; + MuxDriver *d = (MuxDriver *)chr; int m = d->focus; CharBackend *be = d->backends[m]; @@ -715,8 +719,7 @@ static void mux_chr_accept_input(CharDriverState *chr) static int mux_chr_can_read(void *opaque) { - CharDriverState *chr = opaque; - MuxDriver *d = chr->opaque; + MuxDriver *d = opaque; int m = d->focus; CharBackend *be = d->backends[m]; @@ -734,7 +737,7 @@ static int mux_chr_can_read(void *opaque) static void mux_chr_read(void *opaque, const uint8_t *buf, int size) { CharDriverState *chr = opaque; - MuxDriver *d = chr->opaque; + MuxDriver *d = opaque; int m = d->focus; CharBackend *be = d->backends[m]; int i; @@ -756,8 +759,7 @@ static bool muxes_realized; static void mux_chr_event(void *opaque, int event) { - CharDriverState *chr = opaque; - MuxDriver *d = chr->opaque; + MuxDriver *d = opaque; int i; if (!muxes_realized) { @@ -787,7 +789,7 @@ static void muxes_realize_done(Notifier *notifier, void *unused) QTAILQ_FOREACH(chr, &chardevs, next) { if (qemu_chr_get_kind(chr) == CHARDEV_BACKEND_KIND_MUX) { - MuxDriver *d = chr->opaque; + MuxDriver *d = (MuxDriver *)chr; int i; /* send OPENED to all already-attached FEs */ @@ -809,7 +811,7 @@ static Notifier muxes_realize_notify = { static GSource *mux_chr_add_watch(CharDriverState *s, GIOCondition cond) { - MuxDriver *d = s->opaque; + MuxDriver *d = (MuxDriver *)s; CharDriverState *chr = qemu_chr_fe_get_driver(&d->chr); if (!chr->driver->chr_add_watch) { @@ -821,7 +823,7 @@ static GSource *mux_chr_add_watch(CharDriverState *s, GIOCondition cond) static void mux_chr_free(struct CharDriverState *chr) { - MuxDriver *d = chr->opaque; + MuxDriver *d = (MuxDriver *)chr; int i; for (i = 0; i < d->mux_cnt; i++) { @@ -831,12 +833,11 @@ static void mux_chr_free(struct CharDriverState *chr) } } qemu_chr_fe_deinit(&d->chr); - g_free(d); } static void mux_chr_set_handlers(CharDriverState *chr, GMainContext *context) { - MuxDriver *d = chr->opaque; + MuxDriver *d = (MuxDriver *)chr; /* Fix up the real driver with mux routines */ qemu_chr_fe_set_handlers(&d->chr, @@ -882,9 +883,7 @@ static CharDriverState *qemu_chr_open_mux(const CharDriver *driver, if (!chr) { return NULL; } - d = g_new0(MuxDriver, 1); - - chr->opaque = d; + d = (MuxDriver *)chr; d->focus = -1; /* only default to opened state if we've realized the initial * set of muxes @@ -908,7 +907,7 @@ bool qemu_chr_fe_init(CharBackend *b, CharDriverState *s, Error **errp) int tag = 0; if (qemu_chr_get_kind(s) == CHARDEV_BACKEND_KIND_MUX) { - MuxDriver *d = s->opaque; + MuxDriver *d = (MuxDriver *)s; if (d->mux_cnt >= MAX_MUX) { goto unavailable; @@ -935,7 +934,7 @@ unavailable: static bool qemu_chr_is_busy(CharDriverState *s) { if (qemu_chr_get_kind(s) == CHARDEV_BACKEND_KIND_MUX) { - MuxDriver *d = s->opaque; + MuxDriver *d = (MuxDriver *)s; return d->mux_cnt >= 0; } else { return s->be != NULL; @@ -950,7 +949,7 @@ void qemu_chr_fe_deinit(CharBackend *b) qemu_chr_fe_set_handlers(b, NULL, NULL, NULL, NULL, NULL, true); b->chr->be = NULL; if (qemu_chr_get_kind(b->chr) == CHARDEV_BACKEND_KIND_MUX) { - MuxDriver *d = b->chr->opaque; + MuxDriver *d = (MuxDriver *)b->chr; d->backends[b->tag] = NULL; } b->chr = NULL; @@ -1012,7 +1011,7 @@ void qemu_chr_fe_take_focus(CharBackend *b) } if (qemu_chr_get_kind(b->chr) == CHARDEV_BACKEND_KIND_MUX) { - mux_set_focus(b->chr->opaque, b->tag); + mux_set_focus((MuxDriver *)b->chr, b->tag); } } @@ -1190,6 +1189,7 @@ static int io_channel_send(QIOChannel *ioc, const void *buf, size_t len) typedef struct FDCharDriver { + CharDriverState parent; CharDriverState *chr; QIOChannel *ioc_in, *ioc_out; int max_size; @@ -1198,15 +1198,15 @@ typedef struct FDCharDriver { /* Called with chr_write_lock held. */ static int fd_chr_write(CharDriverState *chr, const uint8_t *buf, int len) { - FDCharDriver *s = chr->opaque; - + FDCharDriver *s = (FDCharDriver *)chr; + return io_channel_send(s->ioc_out, buf, len); } static gboolean fd_chr_read(QIOChannel *chan, GIOCondition cond, void *opaque) { CharDriverState *chr = opaque; - FDCharDriver *s = chr->opaque; + FDCharDriver *s = opaque; int len; uint8_t buf[READ_BUF_LEN]; ssize_t ret; @@ -1236,7 +1236,7 @@ static gboolean fd_chr_read(QIOChannel *chan, GIOCondition cond, void *opaque) static int fd_chr_read_poll(void *opaque) { CharDriverState *chr = opaque; - FDCharDriver *s = chr->opaque; + FDCharDriver *s = opaque; s->max_size = qemu_chr_be_can_write(chr); return s->max_size; @@ -1244,14 +1244,14 @@ static int fd_chr_read_poll(void *opaque) static GSource *fd_chr_add_watch(CharDriverState *chr, GIOCondition cond) { - FDCharDriver *s = chr->opaque; + FDCharDriver *s = (FDCharDriver *)chr; return qio_channel_create_watch(s->ioc_out, cond); } static void fd_chr_update_read_handler(CharDriverState *chr, GMainContext *context) { - FDCharDriver *s = chr->opaque; + FDCharDriver *s = (FDCharDriver *)chr; remove_fd_in_watch(chr); if (s->ioc_in) { @@ -1264,7 +1264,7 @@ static void fd_chr_update_read_handler(CharDriverState *chr, static void fd_chr_free(struct CharDriverState *chr) { - FDCharDriver *s = chr->opaque; + FDCharDriver *s = (FDCharDriver *)chr; remove_fd_in_watch(chr); if (s->ioc_in) { @@ -1274,7 +1274,6 @@ static void fd_chr_free(struct CharDriverState *chr) object_unref(OBJECT(s->ioc_out)); } - g_free(s); qemu_chr_be_event(chr, CHR_EVENT_CLOSED); } @@ -1291,7 +1290,7 @@ static CharDriverState *qemu_chr_open_fd(const CharDriver *driver, if (!chr) { return NULL; } - s = g_new0(FDCharDriver, 1); + s = (FDCharDriver *)chr; s->ioc_in = QIO_CHANNEL(qio_channel_file_new_fd(fd_in)); name = g_strdup_printf("chardev-file-in-%s", chr->label); qio_channel_set_name(QIO_CHANNEL(s->ioc_in), name); @@ -1302,7 +1301,6 @@ static CharDriverState *qemu_chr_open_fd(const CharDriver *driver, g_free(name); qemu_set_nonblock(fd_out); s->chr = chr; - chr->opaque = s; return chr; } @@ -1443,6 +1441,7 @@ static CharDriverState *qemu_chr_open_stdio(const CharDriver *driver, #define HAVE_CHARDEV_PTY 1 typedef struct { + CharDriverState parent; QIOChannel *ioc; int read_bytes; @@ -1458,7 +1457,7 @@ static void pty_chr_state(CharDriverState *chr, int connected); static gboolean pty_chr_timer(gpointer opaque) { struct CharDriverState *chr = opaque; - PtyCharDriver *s = chr->opaque; + PtyCharDriver *s = opaque; qemu_mutex_lock(&chr->chr_write_lock); s->timer_tag = 0; @@ -1474,7 +1473,7 @@ static gboolean pty_chr_timer(gpointer opaque) /* Called with chr_write_lock held. */ static void pty_chr_rearm_timer(CharDriverState *chr, int ms) { - PtyCharDriver *s = chr->opaque; + PtyCharDriver *s = (PtyCharDriver *)chr; char *name; if (s->timer_tag) { @@ -1496,7 +1495,7 @@ static void pty_chr_rearm_timer(CharDriverState *chr, int ms) /* Called with chr_write_lock held. */ static void pty_chr_update_read_handler_locked(CharDriverState *chr) { - PtyCharDriver *s = chr->opaque; + PtyCharDriver *s = (PtyCharDriver *)chr; GPollFD pfd; int rc; QIOChannelFile *fioc = QIO_CHANNEL_FILE(s->ioc); @@ -1527,7 +1526,7 @@ static void pty_chr_update_read_handler(CharDriverState *chr, /* Called with chr_write_lock held. */ static int pty_chr_write(CharDriverState *chr, const uint8_t *buf, int len) { - PtyCharDriver *s = chr->opaque; + PtyCharDriver *s = (PtyCharDriver *)chr; if (!s->connected) { /* guest sends data, check for (re-)connect */ @@ -1541,7 +1540,7 @@ static int pty_chr_write(CharDriverState *chr, const uint8_t *buf, int len) static GSource *pty_chr_add_watch(CharDriverState *chr, GIOCondition cond) { - PtyCharDriver *s = chr->opaque; + PtyCharDriver *s = (PtyCharDriver *)chr; if (!s->connected) { return NULL; } @@ -1551,7 +1550,7 @@ static GSource *pty_chr_add_watch(CharDriverState *chr, GIOCondition cond) static int pty_chr_read_poll(void *opaque) { CharDriverState *chr = opaque; - PtyCharDriver *s = chr->opaque; + PtyCharDriver *s = opaque; s->read_bytes = qemu_chr_be_can_write(chr); return s->read_bytes; @@ -1560,7 +1559,7 @@ static int pty_chr_read_poll(void *opaque) static gboolean pty_chr_read(QIOChannel *chan, GIOCondition cond, void *opaque) { CharDriverState *chr = opaque; - PtyCharDriver *s = chr->opaque; + PtyCharDriver *s = opaque; gsize len; uint8_t buf[READ_BUF_LEN]; ssize_t ret; @@ -1585,7 +1584,7 @@ static gboolean pty_chr_read(QIOChannel *chan, GIOCondition cond, void *opaque) static gboolean qemu_chr_be_generic_open_func(gpointer opaque) { CharDriverState *chr = opaque; - PtyCharDriver *s = chr->opaque; + PtyCharDriver *s = opaque; s->open_tag = 0; qemu_chr_be_generic_open(chr); @@ -1595,7 +1594,7 @@ static gboolean qemu_chr_be_generic_open_func(gpointer opaque) /* Called with chr_write_lock held. */ static void pty_chr_state(CharDriverState *chr, int connected) { - PtyCharDriver *s = chr->opaque; + PtyCharDriver *s = (PtyCharDriver *)chr; if (!connected) { if (s->open_tag) { @@ -1629,7 +1628,7 @@ static void pty_chr_state(CharDriverState *chr, int connected) static void pty_chr_free(struct CharDriverState *chr) { - PtyCharDriver *s = chr->opaque; + PtyCharDriver *s = (PtyCharDriver *)chr; qemu_mutex_lock(&chr->chr_write_lock); pty_chr_state(chr, 0); @@ -1639,7 +1638,6 @@ static void pty_chr_free(struct CharDriverState *chr) s->timer_tag = 0; } qemu_mutex_unlock(&chr->chr_write_lock); - g_free(s); qemu_chr_be_event(chr, CHR_EVENT_CLOSED); } @@ -1679,20 +1677,19 @@ static CharDriverState *qemu_chr_open_pty(const CharDriver *driver, fprintf(stderr, "char device redirected to %s (label %s)\n", pty_name, id); - s = g_new0(PtyCharDriver, 1); - chr->opaque = s; - *be_opened = false; - + s = (PtyCharDriver *)chr; s->ioc = QIO_CHANNEL(qio_channel_file_new_fd(master_fd)); name = g_strdup_printf("chardev-pty-%s", chr->label); qio_channel_set_name(QIO_CHANNEL(s->ioc), name); g_free(name); s->timer_tag = 0; + *be_opened = false; return chr; } static const CharDriver pty_driver = { + .instance_size = sizeof(PtyCharDriver), .kind = CHARDEV_BACKEND_KIND_PTY, .create = qemu_chr_open_pty, .chr_write = pty_chr_write, @@ -1818,7 +1815,7 @@ static void tty_serial_init(int fd, int speed, static int tty_serial_ioctl(CharDriverState *chr, int cmd, void *arg) { - FDCharDriver *s = chr->opaque; + FDCharDriver *s = (FDCharDriver *)chr; QIOChannelFile *fioc = QIO_CHANNEL_FILE(s->ioc_in); switch(cmd) { @@ -1897,6 +1894,7 @@ static void qemu_chr_free_tty(CharDriverState *chr) #define HAVE_CHARDEV_PARPORT 1 typedef struct { + CharDriverState parent; int fd; int mode; } ParallelCharDriver; @@ -1914,7 +1912,7 @@ static int pp_hw_mode(ParallelCharDriver *s, uint16_t mode) static int pp_ioctl(CharDriverState *chr, int cmd, void *arg) { - ParallelCharDriver *drv = chr->opaque; + ParallelCharDriver *drv = (ParallelCharDriver *)chr; int fd = drv->fd; uint8_t b; @@ -1995,13 +1993,12 @@ static int pp_ioctl(CharDriverState *chr, int cmd, void *arg) static void pp_free(CharDriverState *chr) { - ParallelCharDriver *drv = chr->opaque; + ParallelCharDriver *drv = (ParallelCharDriver *)chr; int fd = drv->fd; pp_hw_mode(drv, IEEE1284_MODE_COMPAT); ioctl(fd, PPRELEASE); close(fd); - g_free(drv); qemu_chr_be_event(chr, CHR_EVENT_CLOSED); } @@ -2025,9 +2022,7 @@ static CharDriverState *qemu_chr_open_pp_fd(const CharDriver *driver, return NULL; } - drv = g_new0(ParallelCharDriver, 1); - chr->opaque = drv; - + drv = (ParallelCharDriver *)chr; drv->fd = fd; drv->mode = IEEE1284_MODE_COMPAT; @@ -2039,35 +2034,45 @@ static CharDriverState *qemu_chr_open_pp_fd(const CharDriver *driver, #define HAVE_CHARDEV_PARPORT 1 +typedef struct { + CharDriverState parent; + int fd; +} ParallelCharDriver; + static int pp_ioctl(CharDriverState *chr, int cmd, void *arg) { - int fd = (int)(intptr_t)chr->opaque; + ParallelCharDriver *drv = (ParallelCharDriver *)chr; uint8_t b; - switch(cmd) { + switch (cmd) { case CHR_IOCTL_PP_READ_DATA: - if (ioctl(fd, PPIGDATA, &b) < 0) + if (ioctl(drv->fd, PPIGDATA, &b) < 0) { return -ENOTSUP; + } *(uint8_t *)arg = b; break; case CHR_IOCTL_PP_WRITE_DATA: b = *(uint8_t *)arg; - if (ioctl(fd, PPISDATA, &b) < 0) + if (ioctl(drv->fd, PPISDATA, &b) < 0) { return -ENOTSUP; + } break; case CHR_IOCTL_PP_READ_CONTROL: - if (ioctl(fd, PPIGCTRL, &b) < 0) + if (ioctl(drv->fd, PPIGCTRL, &b) < 0) { return -ENOTSUP; + } *(uint8_t *)arg = b; break; case CHR_IOCTL_PP_WRITE_CONTROL: b = *(uint8_t *)arg; - if (ioctl(fd, PPISCTRL, &b) < 0) + if (ioctl(drv->fd, PPISCTRL, &b) < 0) { return -ENOTSUP; + } break; case CHR_IOCTL_PP_READ_STATUS: - if (ioctl(fd, PPIGSTATUS, &b) < 0) + if (ioctl(drv->fd, PPIGSTATUS, &b) < 0) { return -ENOTSUP; + } *(uint8_t *)arg = b; break; default: @@ -2083,12 +2088,14 @@ static CharDriverState *qemu_chr_open_pp_fd(const CharDriver *driver, Error **errp) { CharDriverState *chr; + ParallelCharDriver *drv; chr = qemu_chr_alloc(driver, backend, errp); if (!chr) { return NULL; } - chr->opaque = (void *)(intptr_t)fd; + drv = (ParallelCharDriver *)chr; + drv->fd = fd; *be_opened = false; return chr; } @@ -2099,6 +2106,7 @@ static CharDriverState *qemu_chr_open_pp_fd(const CharDriver *driver, #define HAVE_CHARDEV_SERIAL 1 typedef struct { + CharDriverState parent; int max_size; HANDLE hcom, hrecv, hsend; OVERLAPPED orecv; @@ -2110,6 +2118,7 @@ typedef struct { } WinCharState; typedef struct { + CharDriverState parent; HANDLE hStdIn; HANDLE hInputReadyEvent; HANDLE hInputDoneEvent; @@ -2127,7 +2136,7 @@ static int win_chr_pipe_poll(void *opaque); static void win_chr_free(CharDriverState *chr) { - WinCharState *s = chr->opaque; + WinCharState *s = (WinCharState *)chr; if (s->hsend) { CloseHandle(s->hsend); @@ -2151,7 +2160,7 @@ static void win_chr_free(CharDriverState *chr) static int win_chr_init(CharDriverState *chr, const char *filename, Error **errp) { - WinCharState *s = chr->opaque; + WinCharState *s = (WinCharState *)chr; COMMCONFIG comcfg; COMMTIMEOUTS cto = { 0, 0, 0, 0, 0}; COMSTAT comstat; @@ -2219,7 +2228,7 @@ static int win_chr_init(CharDriverState *chr, const char *filename, Error **errp /* Called with chr_write_lock held. */ static int win_chr_write(CharDriverState *chr, const uint8_t *buf, int len1) { - WinCharState *s = chr->opaque; + WinCharState *s = (WinCharState *)chr; DWORD len, ret, size, err; len = len1; @@ -2253,7 +2262,7 @@ static int win_chr_write(CharDriverState *chr, const uint8_t *buf, int len1) static int win_chr_read_poll(CharDriverState *chr) { - WinCharState *s = chr->opaque; + WinCharState *s = (WinCharState *)chr; s->max_size = qemu_chr_be_can_write(chr); return s->max_size; @@ -2261,7 +2270,7 @@ static int win_chr_read_poll(CharDriverState *chr) static void win_chr_readfile(CharDriverState *chr) { - WinCharState *s = chr->opaque; + WinCharState *s = (WinCharState *)chr; int ret, err; uint8_t buf[READ_BUF_LEN]; DWORD size; @@ -2283,7 +2292,7 @@ static void win_chr_readfile(CharDriverState *chr) static void win_chr_read(CharDriverState *chr) { - WinCharState *s = chr->opaque; + WinCharState *s = (WinCharState *)chr; if (s->len > s->max_size) s->len = s->max_size; @@ -2296,7 +2305,7 @@ static void win_chr_read(CharDriverState *chr) static int win_chr_poll(void *opaque) { CharDriverState *chr = opaque; - WinCharState *s = chr->opaque; + WinCharState *s = opaque; COMSTAT status; DWORD comerr; @@ -2313,7 +2322,7 @@ static int win_chr_poll(void *opaque) static int win_chr_pipe_poll(void *opaque) { CharDriverState *chr = opaque; - WinCharState *s = chr->opaque; + WinCharState *s = opaque; DWORD size; PeekNamedPipe(s->hcom, NULL, 0, NULL, &size, NULL); @@ -2329,7 +2338,7 @@ static int win_chr_pipe_poll(void *opaque) static int win_chr_pipe_init(CharDriverState *chr, const char *filename, Error **errp) { - WinCharState *s = chr->opaque; + WinCharState *s = (WinCharState *)chr; OVERLAPPED ov; int ret; DWORD size; @@ -2401,18 +2410,14 @@ static CharDriverState *qemu_chr_open_pipe(const CharDriver *driver, ChardevHostdev *opts = backend->u.pipe.data; const char *filename = opts->device; CharDriverState *chr; - WinCharState *s; ChardevCommon *common = qapi_ChardevHostdev_base(opts); chr = qemu_chr_alloc(driver, common, errp); if (!chr) { return NULL; } - s = g_new0(WinCharState, 1); - chr->opaque = s; if (win_chr_pipe_init(chr, filename, errp) < 0) { - g_free(s); qemu_chr_free_common(chr); return NULL; } @@ -2431,9 +2436,8 @@ static CharDriverState *qemu_chr_open_win_file(const CharDriver *driver, if (!chr) { return NULL; } - s = g_new0(WinCharState, 1); + s = (WinCharState *)chr; s->hcom = fd_out; - chr->opaque = s; return chr; } @@ -2451,6 +2455,7 @@ static CharDriverState *qemu_chr_open_win_con(const CharDriver *driver, } static const CharDriver console_driver = { + .instance_size = sizeof(WinCharState), .kind = CHARDEV_BACKEND_KIND_CONSOLE, .create = qemu_chr_open_win_con, .chr_write = win_chr_write, @@ -2478,7 +2483,7 @@ static int win_stdio_write(CharDriverState *chr, const uint8_t *buf, int len) static void win_stdio_wait_func(void *opaque) { CharDriverState *chr = opaque; - WinStdioCharState *stdio = chr->opaque; + WinStdioCharState *stdio = opaque; INPUT_RECORD buf[4]; int ret; DWORD dwSize; @@ -2511,8 +2516,7 @@ static void win_stdio_wait_func(void *opaque) static DWORD WINAPI win_stdio_thread(LPVOID param) { - CharDriverState *chr = param; - WinStdioCharState *stdio = chr->opaque; + WinStdioCharState *stdio = param; int ret; DWORD dwSize; @@ -2551,7 +2555,7 @@ static DWORD WINAPI win_stdio_thread(LPVOID param) static void win_stdio_thread_wait_func(void *opaque) { CharDriverState *chr = opaque; - WinStdioCharState *stdio = chr->opaque; + WinStdioCharState *stdio = opaque; if (qemu_chr_be_can_write(chr)) { qemu_chr_be_write(chr, &stdio->win_stdio_buf, 1); @@ -2562,7 +2566,7 @@ static void win_stdio_thread_wait_func(void *opaque) static void qemu_chr_set_echo_win_stdio(CharDriverState *chr, bool echo) { - WinStdioCharState *stdio = chr->opaque; + WinStdioCharState *stdio = (WinStdioCharState *)chr; DWORD dwMode = 0; GetConsoleMode(stdio->hStdIn, &dwMode); @@ -2576,7 +2580,7 @@ static void qemu_chr_set_echo_win_stdio(CharDriverState *chr, bool echo) static void win_stdio_free(CharDriverState *chr) { - WinStdioCharState *stdio = chr->opaque; + WinStdioCharState *stdio = (WinStdioCharState *)chr; if (stdio->hInputReadyEvent != INVALID_HANDLE_VALUE) { CloseHandle(stdio->hInputReadyEvent); @@ -2587,8 +2591,6 @@ static void win_stdio_free(CharDriverState *chr) if (stdio->hInputThread != INVALID_HANDLE_VALUE) { TerminateThread(stdio->hInputThread, 0); } - - g_free(chr->opaque); } static CharDriverState *qemu_chr_open_stdio(const CharDriver *driver, @@ -2608,7 +2610,7 @@ static CharDriverState *qemu_chr_open_stdio(const CharDriver *driver, if (!chr) { return NULL; } - stdio = g_new0(WinStdioCharState, 1); + stdio = (WinStdioCharState *)chr; stdio->hStdIn = GetStdHandle(STD_INPUT_HANDLE); if (stdio->hStdIn == INVALID_HANDLE_VALUE) { @@ -2618,8 +2620,6 @@ static CharDriverState *qemu_chr_open_stdio(const CharDriver *driver, is_console = GetConsoleMode(stdio->hStdIn, &dwMode) != 0; - chr->opaque = stdio; - if (is_console) { if (qemu_add_wait_object(stdio->hStdIn, win_stdio_wait_func, chr)) { @@ -2679,6 +2679,7 @@ err1: /* UDP Net console */ typedef struct { + CharDriverState parent; QIOChannel *ioc; uint8_t buf[READ_BUF_LEN]; int bufcnt; @@ -2689,7 +2690,7 @@ typedef struct { /* Called with chr_write_lock held. */ static int udp_chr_write(CharDriverState *chr, const uint8_t *buf, int len) { - NetCharDriver *s = chr->opaque; + NetCharDriver *s = (NetCharDriver *)chr; return qio_channel_write( s->ioc, (const char *)buf, len, NULL); @@ -2698,7 +2699,7 @@ static int udp_chr_write(CharDriverState *chr, const uint8_t *buf, int len) static int udp_chr_read_poll(void *opaque) { CharDriverState *chr = opaque; - NetCharDriver *s = chr->opaque; + NetCharDriver *s = opaque; s->max_size = qemu_chr_be_can_write(chr); @@ -2716,7 +2717,7 @@ static int udp_chr_read_poll(void *opaque) static gboolean udp_chr_read(QIOChannel *chan, GIOCondition cond, void *opaque) { CharDriverState *chr = opaque; - NetCharDriver *s = chr->opaque; + NetCharDriver *s = opaque; ssize_t ret; if (s->max_size == 0) { @@ -2743,7 +2744,7 @@ static gboolean udp_chr_read(QIOChannel *chan, GIOCondition cond, void *opaque) static void udp_chr_update_read_handler(CharDriverState *chr, GMainContext *context) { - NetCharDriver *s = chr->opaque; + NetCharDriver *s = (NetCharDriver *)chr; remove_fd_in_watch(chr); if (s->ioc) { @@ -2756,13 +2757,12 @@ static void udp_chr_update_read_handler(CharDriverState *chr, static void udp_chr_free(CharDriverState *chr) { - NetCharDriver *s = chr->opaque; + NetCharDriver *s = (NetCharDriver *)chr; remove_fd_in_watch(chr); if (s->ioc) { object_unref(OBJECT(s->ioc)); } - g_free(s); qemu_chr_be_event(chr, CHR_EVENT_CLOSED); } @@ -2770,6 +2770,7 @@ static void udp_chr_free(CharDriverState *chr) /* TCP Net console */ typedef struct { + CharDriverState parent; QIOChannel *ioc; /* Client I/O channel */ QIOChannelSocket *sioc; /* Client master channel */ QIOChannelSocket *listen_ioc; @@ -2798,8 +2799,9 @@ static gboolean socket_reconnect_timeout(gpointer opaque); static void qemu_chr_socket_restart_timer(CharDriverState *chr) { - TCPCharDriver *s = chr->opaque; + TCPCharDriver *s = (TCPCharDriver *)chr; char *name; + assert(s->connected == 0); s->reconnect_timer = g_timeout_add_seconds(s->reconnect_time, socket_reconnect_timeout, chr); @@ -2811,7 +2813,7 @@ static void qemu_chr_socket_restart_timer(CharDriverState *chr) static void check_report_connect_error(CharDriverState *chr, Error *err) { - TCPCharDriver *s = chr->opaque; + TCPCharDriver *s = (TCPCharDriver *)chr; if (!s->connect_err_reported) { error_report("Unable to connect character device %s: %s", @@ -2828,7 +2830,8 @@ static gboolean tcp_chr_accept(QIOChannel *chan, /* Called with chr_write_lock held. */ static int tcp_chr_write(CharDriverState *chr, const uint8_t *buf, int len) { - TCPCharDriver *s = chr->opaque; + TCPCharDriver *s = (TCPCharDriver *)chr; + if (s->connected) { int ret = io_channel_send_full(s->ioc, buf, len, s->write_msgfds, @@ -2851,7 +2854,7 @@ static int tcp_chr_write(CharDriverState *chr, const uint8_t *buf, int len) static int tcp_chr_read_poll(void *opaque) { CharDriverState *chr = opaque; - TCPCharDriver *s = chr->opaque; + TCPCharDriver *s = opaque; if (!s->connected) return 0; s->max_size = qemu_chr_be_can_write(chr); @@ -2910,7 +2913,8 @@ static void tcp_chr_process_IAC_bytes(CharDriverState *chr, static int tcp_get_msgfds(CharDriverState *chr, int *fds, int num) { - TCPCharDriver *s = chr->opaque; + TCPCharDriver *s = (TCPCharDriver *)chr; + int to_copy = (s->read_msgfds_num < num) ? s->read_msgfds_num : num; assert(num <= TCP_MAX_FDS); @@ -2935,7 +2939,7 @@ static int tcp_get_msgfds(CharDriverState *chr, int *fds, int num) static int tcp_set_msgfds(CharDriverState *chr, int *fds, int num) { - TCPCharDriver *s = chr->opaque; + TCPCharDriver *s = (TCPCharDriver *)chr; /* clear old pending fd array */ g_free(s->write_msgfds); @@ -2960,7 +2964,7 @@ static int tcp_set_msgfds(CharDriverState *chr, int *fds, int num) static ssize_t tcp_chr_recv(CharDriverState *chr, char *buf, size_t len) { - TCPCharDriver *s = chr->opaque; + TCPCharDriver *s = (TCPCharDriver *)chr; struct iovec iov = { .iov_base = buf, .iov_len = len }; int ret; size_t i; @@ -3017,13 +3021,13 @@ static ssize_t tcp_chr_recv(CharDriverState *chr, char *buf, size_t len) static GSource *tcp_chr_add_watch(CharDriverState *chr, GIOCondition cond) { - TCPCharDriver *s = chr->opaque; + TCPCharDriver *s = (TCPCharDriver *)chr; return qio_channel_create_watch(s->ioc, cond); } static void tcp_chr_free_connection(CharDriverState *chr) { - TCPCharDriver *s = chr->opaque; + TCPCharDriver *s = (TCPCharDriver *)chr; int i; if (!s->connected) { @@ -3052,7 +3056,7 @@ static void tcp_chr_free_connection(CharDriverState *chr) static void tcp_chr_disconnect(CharDriverState *chr) { - TCPCharDriver *s = chr->opaque; + TCPCharDriver *s = (TCPCharDriver *)chr; if (!s->connected) { return; @@ -3075,7 +3079,7 @@ static void tcp_chr_disconnect(CharDriverState *chr) static gboolean tcp_chr_read(QIOChannel *chan, GIOCondition cond, void *opaque) { CharDriverState *chr = opaque; - TCPCharDriver *s = chr->opaque; + TCPCharDriver *s = opaque; uint8_t buf[READ_BUF_LEN]; int len, size; @@ -3101,7 +3105,7 @@ static gboolean tcp_chr_read(QIOChannel *chan, GIOCondition cond, void *opaque) static int tcp_chr_sync_read(CharDriverState *chr, const uint8_t *buf, int len) { - TCPCharDriver *s = chr->opaque; + TCPCharDriver *s = (TCPCharDriver *)chr; int size; if (!s->connected) { @@ -3120,7 +3124,7 @@ static int tcp_chr_sync_read(CharDriverState *chr, const uint8_t *buf, int len) static void tcp_chr_connect(void *opaque) { CharDriverState *chr = opaque; - TCPCharDriver *s = chr->opaque; + TCPCharDriver *s = opaque; g_free(chr->filename); chr->filename = sockaddr_to_str( @@ -3141,7 +3145,7 @@ static void tcp_chr_connect(void *opaque) static void tcp_chr_update_read_handler(CharDriverState *chr, GMainContext *context) { - TCPCharDriver *s = chr->opaque; + TCPCharDriver *s = (TCPCharDriver *)chr; if (!s->connected) { return; @@ -3192,7 +3196,7 @@ static gboolean tcp_chr_telnet_init_io(QIOChannel *ioc, static void tcp_chr_telnet_init(CharDriverState *chr) { - TCPCharDriver *s = chr->opaque; + TCPCharDriver *s = (TCPCharDriver *)chr; TCPCharDriverTelnetInit *init = g_new0(TCPCharDriverTelnetInit, 1); size_t n = 0; @@ -3228,7 +3232,7 @@ static void tcp_chr_tls_handshake(Object *source, gpointer user_data) { CharDriverState *chr = user_data; - TCPCharDriver *s = chr->opaque; + TCPCharDriver *s = user_data; if (err) { tcp_chr_disconnect(chr); @@ -3244,7 +3248,7 @@ static void tcp_chr_tls_handshake(Object *source, static void tcp_chr_tls_init(CharDriverState *chr) { - TCPCharDriver *s = chr->opaque; + TCPCharDriver *s = (TCPCharDriver *)chr; QIOChannelTLS *tioc; Error *err = NULL; gchar *name; @@ -3283,7 +3287,7 @@ static void tcp_chr_tls_init(CharDriverState *chr) static void tcp_chr_set_client_ioc_name(CharDriverState *chr, QIOChannelSocket *sioc) { - TCPCharDriver *s = chr->opaque; + TCPCharDriver *s = (TCPCharDriver *)chr; char *name; name = g_strdup_printf("chardev-tcp-%s-%s", s->is_listen ? "server" : "client", @@ -3295,7 +3299,8 @@ static void tcp_chr_set_client_ioc_name(CharDriverState *chr, static int tcp_chr_new_client(CharDriverState *chr, QIOChannelSocket *sioc) { - TCPCharDriver *s = chr->opaque; + TCPCharDriver *s = (TCPCharDriver *)chr; + if (s->ioc != NULL) { return -1; } @@ -3366,7 +3371,7 @@ static gboolean tcp_chr_accept(QIOChannel *channel, static int tcp_chr_wait_connected(CharDriverState *chr, Error **errp) { - TCPCharDriver *s = chr->opaque; + TCPCharDriver *s = (TCPCharDriver *)chr; QIOChannelSocket *sioc; /* It can't wait on s->connected, since it is set asynchronously @@ -3414,7 +3419,7 @@ int qemu_chr_fe_wait_connected(CharBackend *be, Error **errp) static void tcp_chr_free(CharDriverState *chr) { - TCPCharDriver *s = chr->opaque; + TCPCharDriver *s = (TCPCharDriver *)chr; tcp_chr_free_connection(chr); @@ -3433,7 +3438,7 @@ static void tcp_chr_free(CharDriverState *chr) if (s->tls_creds) { object_unref(OBJECT(s->tls_creds)); } - g_free(s); + qemu_chr_be_event(chr, CHR_EVENT_CLOSED); } @@ -3442,7 +3447,7 @@ static void qemu_chr_socket_connected(Object *src, Error *err, void *opaque) { QIOChannelSocket *sioc = QIO_CHANNEL_SOCKET(src); CharDriverState *chr = opaque; - TCPCharDriver *s = chr->opaque; + TCPCharDriver *s = (TCPCharDriver *)chr; if (err) { check_report_connect_error(chr, err); @@ -3460,6 +3465,7 @@ static void qemu_chr_socket_connected(Object *src, Error *err, void *opaque) /* Ring buffer chardev */ typedef struct { + CharDriverState parent; size_t size; size_t prod; size_t cons; @@ -3468,7 +3474,7 @@ typedef struct { static size_t ringbuf_count(const CharDriverState *chr) { - const RingBufCharDriver *d = chr->opaque; + const RingBufCharDriver *d = (RingBufCharDriver *)chr; return d->prod - d->cons; } @@ -3476,7 +3482,7 @@ static size_t ringbuf_count(const CharDriverState *chr) /* Called with chr_write_lock held. */ static int ringbuf_chr_write(CharDriverState *chr, const uint8_t *buf, int len) { - RingBufCharDriver *d = chr->opaque; + RingBufCharDriver *d = (RingBufCharDriver *)chr; int i; if (!buf || (len < 0)) { @@ -3495,7 +3501,7 @@ static int ringbuf_chr_write(CharDriverState *chr, const uint8_t *buf, int len) static int ringbuf_chr_read(CharDriverState *chr, uint8_t *buf, int len) { - RingBufCharDriver *d = chr->opaque; + RingBufCharDriver *d = (RingBufCharDriver *)chr; int i; qemu_mutex_lock(&chr->chr_write_lock); @@ -3509,11 +3515,9 @@ static int ringbuf_chr_read(CharDriverState *chr, uint8_t *buf, int len) static void ringbuf_chr_free(struct CharDriverState *chr) { - RingBufCharDriver *d = chr->opaque; + RingBufCharDriver *d = (RingBufCharDriver *)chr; g_free(d->cbuf); - g_free(d); - chr->opaque = NULL; } static CharDriverState *qemu_chr_open_ringbuf(const CharDriver *driver, @@ -3532,7 +3536,7 @@ static CharDriverState *qemu_chr_open_ringbuf(const CharDriver *driver, if (!chr) { return NULL; } - d = g_malloc(sizeof(*d)); + d = (RingBufCharDriver *)chr; d->size = opts->has_size ? opts->size : 65536; @@ -3546,12 +3550,9 @@ static CharDriverState *qemu_chr_open_ringbuf(const CharDriver *driver, d->cons = 0; d->cbuf = g_malloc0(d->size); - chr->opaque = d; - return chr; fail: - g_free(d); qemu_chr_free_common(chr); return NULL; } @@ -3842,10 +3843,12 @@ static const CharDriver stdio_driver = { .parse = qemu_chr_parse_stdio, .create = qemu_chr_open_stdio, #ifdef _WIN32 + sizeof(WinStdioCharState), .chr_write = win_stdio_write, .chr_set_echo = qemu_chr_set_echo_win_stdio, .chr_free = win_stdio_free, #else + sizeof(FDCharDriver), .chr_add_watch = fd_chr_add_watch, .chr_write = fd_chr_write, .chr_update_read_handler = fd_chr_update_read_handler, @@ -3908,9 +3911,11 @@ static const CharDriver pipe_driver = { .parse = qemu_chr_parse_pipe, .create = qemu_chr_open_pipe, #ifdef _WIN32 + sizeof(WinCharState), .chr_write = win_chr_write, .chr_free = win_chr_free, #else + sizeof(FDCharDriver), .chr_add_watch = fd_chr_add_watch, .chr_write = fd_chr_write, .chr_update_read_handler = fd_chr_update_read_handler, @@ -3935,6 +3940,7 @@ static void qemu_chr_parse_ringbuf(QemuOpts *opts, ChardevBackend *backend, } static const CharDriver ringbuf_driver = { + .instance_size = sizeof(RingBufCharDriver), .kind = CHARDEV_BACKEND_KIND_RINGBUF, .parse = qemu_chr_parse_ringbuf, .create = qemu_chr_open_ringbuf, @@ -3944,6 +3950,7 @@ static const CharDriver ringbuf_driver = { /* Bug-compatibility: */ static const CharDriver memory_driver = { + .instance_size = sizeof(RingBufCharDriver), .kind = CHARDEV_BACKEND_KIND_MEMORY, .parse = qemu_chr_parse_ringbuf, .create = qemu_chr_open_ringbuf, @@ -3967,6 +3974,7 @@ static void qemu_chr_parse_mux(QemuOpts *opts, ChardevBackend *backend, } static const CharDriver mux_driver = { + .instance_size = sizeof(MuxDriver), .kind = CHARDEV_BACKEND_KIND_MUX, .parse = qemu_chr_parse_mux, .create = qemu_chr_open_mux, @@ -4555,17 +4563,13 @@ static CharDriverState *qmp_chardev_open_serial(const CharDriver *driver, ChardevHostdev *serial = backend->u.serial.data; ChardevCommon *common = qapi_ChardevHostdev_base(serial); CharDriverState *chr; - WinCharState *s; chr = qemu_chr_alloc(driver, common, errp); if (!chr) { return NULL; } - s = g_new0(WinCharState, 1); - chr->opaque = s; if (win_chr_init(chr, serial->device, errp) < 0) { - g_free(s); qemu_chr_free_common(chr); return NULL; } @@ -4665,6 +4669,7 @@ static CharDriverState *qmp_chardev_open_parallel(const CharDriver *driver, } static const CharDriver parallel_driver = { + .instance_size = sizeof(ParallelCharDriver), .kind = CHARDEV_BACKEND_KIND_PARALLEL, .alias = "parport", .parse = qemu_chr_parse_parallel, @@ -4688,9 +4693,11 @@ static const CharDriver file_driver = { .parse = qemu_chr_parse_file_out, .create = qmp_chardev_open_file, #ifdef _WIN32 + sizeof(WinCharState), .chr_write = win_chr_write, /* FIXME: no chr_free */ #else + sizeof(FDCharDriver), .chr_add_watch = fd_chr_add_watch, .chr_write = fd_chr_write, .chr_update_read_handler = fd_chr_update_read_handler, @@ -4705,9 +4712,11 @@ static const CharDriver serial_driver = { .parse = qemu_chr_parse_serial, .create = qmp_chardev_open_serial, #ifdef _WIN32 + sizeof(WinCharState), .chr_write = win_chr_write, .chr_free = win_chr_free, #else + sizeof(FDCharDriver), .chr_add_watch = fd_chr_add_watch, .chr_write = fd_chr_write, .chr_update_read_handler = fd_chr_update_read_handler, @@ -4720,7 +4729,7 @@ static const CharDriver serial_driver = { static gboolean socket_reconnect_timeout(gpointer opaque) { CharDriverState *chr = opaque; - TCPCharDriver *s = chr->opaque; + TCPCharDriver *s = opaque; QIOChannelSocket *sioc; s->reconnect_timer = 0; @@ -4761,7 +4770,7 @@ static CharDriverState *qmp_chardev_open_socket(const CharDriver *driver, if (!chr) { return NULL; } - s = g_new0(TCPCharDriver, 1); + s = (TCPCharDriver *)chr; s->is_unix = addr->type == SOCKET_ADDRESS_KIND_UNIX; s->is_listen = is_listen; @@ -4807,7 +4816,6 @@ static CharDriverState *qmp_chardev_open_socket(const CharDriver *driver, qemu_chr_set_feature(chr, QEMU_CHAR_FEATURE_FD_PASS); } - chr->opaque = s; /* be isn't opened until we get a connection */ *be_opened = false; @@ -4864,12 +4872,12 @@ static CharDriverState *qmp_chardev_open_socket(const CharDriver *driver, if (s->tls_creds) { object_unref(OBJECT(s->tls_creds)); } - g_free(s); qemu_chr_free_common(chr); return NULL; } static const CharDriver socket_driver = { + .instance_size = sizeof(TCPCharDriver), .kind = CHARDEV_BACKEND_KIND_SOCKET, .parse = qemu_chr_parse_socket, .create = qmp_chardev_open_socket, @@ -4915,9 +4923,8 @@ static CharDriverState *qmp_chardev_open_udp(const CharDriver *driver, qio_channel_set_name(QIO_CHANNEL(sioc), name); g_free(name); - s = g_new0(NetCharDriver, 1); + s = (NetCharDriver *)chr; s->ioc = QIO_CHANNEL(sioc); - chr->opaque = s; /* be isn't opened until we get a connection */ *be_opened = false; @@ -4925,6 +4932,7 @@ static CharDriverState *qmp_chardev_open_udp(const CharDriver *driver, } static const CharDriver udp_driver = { + .instance_size = sizeof(NetCharDriver), .kind = CHARDEV_BACKEND_KIND_UDP, .parse = qemu_chr_parse_udp, .create = qmp_chardev_open_udp, diff --git a/spice-qemu-char.c b/spice-qemu-char.c index c7eb306f34..1aed45157b 100644 --- a/spice-qemu-char.c +++ b/spice-qemu-char.c @@ -7,7 +7,8 @@ typedef struct SpiceCharDriver { - CharDriverState* chr; + CharDriverState parent; + SpiceCharDeviceInstance sin; bool active; bool blocked; @@ -27,17 +28,18 @@ static QLIST_HEAD(, SpiceCharDriver) spice_chars = static int vmc_write(SpiceCharDeviceInstance *sin, const uint8_t *buf, int len) { SpiceCharDriver *scd = container_of(sin, SpiceCharDriver, sin); + CharDriverState *chr = (CharDriverState *)scd; ssize_t out = 0; ssize_t last_out; uint8_t* p = (uint8_t*)buf; while (len > 0) { - int can_write = qemu_chr_be_can_write(scd->chr); + int can_write = qemu_chr_be_can_write(chr); last_out = MIN(len, can_write); if (last_out <= 0) { break; } - qemu_chr_be_write(scd->chr, p, last_out); + qemu_chr_be_write(chr, p, last_out); out += last_out; len -= last_out; p += last_out; @@ -70,6 +72,7 @@ static int vmc_read(SpiceCharDeviceInstance *sin, uint8_t *buf, int len) static void vmc_event(SpiceCharDeviceInstance *sin, uint8_t event) { SpiceCharDriver *scd = container_of(sin, SpiceCharDriver, sin); + CharDriverState *chr = (CharDriverState *)scd; int chr_event; switch (event) { @@ -81,20 +84,21 @@ static void vmc_event(SpiceCharDeviceInstance *sin, uint8_t event) } trace_spice_vmc_event(chr_event); - qemu_chr_be_event(scd->chr, chr_event); + qemu_chr_be_event(chr, chr_event); } #endif static void vmc_state(SpiceCharDeviceInstance *sin, int connected) { SpiceCharDriver *scd = container_of(sin, SpiceCharDriver, sin); + CharDriverState *chr = (CharDriverState *)scd; - if ((scd->chr->be_open && connected) || - (!scd->chr->be_open && !connected)) { + if ((chr->be_open && connected) || + (!chr->be_open && !connected)) { return; } - qemu_chr_be_event(scd->chr, + qemu_chr_be_event(chr, connected ? CHR_EVENT_OPENED : CHR_EVENT_CLOSED); } @@ -168,7 +172,7 @@ static GSourceFuncs SpiceCharSourceFuncs = { static GSource *spice_chr_add_watch(CharDriverState *chr, GIOCondition cond) { - SpiceCharDriver *scd = chr->opaque; + SpiceCharDriver *scd = (SpiceCharDriver *)chr; SpiceCharSource *src; assert(cond & G_IO_OUT); @@ -182,7 +186,7 @@ static GSource *spice_chr_add_watch(CharDriverState *chr, GIOCondition cond) static int spice_chr_write(CharDriverState *chr, const uint8_t *buf, int len) { - SpiceCharDriver *s = chr->opaque; + SpiceCharDriver *s = (SpiceCharDriver *)chr; int read_bytes; assert(s->datalen == 0); @@ -201,7 +205,7 @@ static int spice_chr_write(CharDriverState *chr, const uint8_t *buf, int len) static void spice_chr_free(struct CharDriverState *chr) { - SpiceCharDriver *s = chr->opaque; + SpiceCharDriver *s = (SpiceCharDriver *)chr; vmc_unregister_interface(s); QLIST_REMOVE(s, next); @@ -210,12 +214,11 @@ static void spice_chr_free(struct CharDriverState *chr) #if SPICE_SERVER_VERSION >= 0x000c02 g_free((char *)s->sin.portname); #endif - g_free(s); } static void spice_vmc_set_fe_open(struct CharDriverState *chr, int fe_open) { - SpiceCharDriver *s = chr->opaque; + SpiceCharDriver *s = (SpiceCharDriver *)chr; if (fe_open) { vmc_register_interface(s); } else { @@ -226,7 +229,7 @@ static void spice_vmc_set_fe_open(struct CharDriverState *chr, int fe_open) static void spice_port_set_fe_open(struct CharDriverState *chr, int fe_open) { #if SPICE_SERVER_VERSION >= 0x000c02 - SpiceCharDriver *s = chr->opaque; + SpiceCharDriver *s = (SpiceCharDriver *)chr; if (fe_open) { spice_server_port_event(&s->sin, SPICE_PORT_EVENT_OPENED); @@ -255,7 +258,7 @@ static void print_allowed_subtypes(void) static void spice_chr_accept_input(struct CharDriverState *chr) { - SpiceCharDriver *s = chr->opaque; + SpiceCharDriver *s = (SpiceCharDriver *)chr; spice_server_char_device_wakeup(&s->sin); } @@ -272,11 +275,9 @@ static CharDriverState *chr_open(const CharDriver *driver, if (!chr) { return NULL; } - s = g_malloc0(sizeof(SpiceCharDriver)); - s->chr = chr; + s = (SpiceCharDriver *)chr; s->active = false; s->sin.subtype = g_strdup(subtype); - chr->opaque = s; QLIST_INSERT_HEAD(&spice_chars, s, next); @@ -334,7 +335,7 @@ static CharDriverState *qemu_chr_open_spice_port(const CharDriver *driver, return NULL; } *be_opened = false; - s = chr->opaque; + s = (SpiceCharDriver *)chr; s->sin.portname = g_strdup(name); return chr; @@ -386,6 +387,7 @@ static void qemu_chr_parse_spice_port(QemuOpts *opts, ChardevBackend *backend, static void register_types(void) { static const CharDriver vmc_driver = { + .instance_size = sizeof(SpiceCharDriver), .kind = CHARDEV_BACKEND_KIND_SPICEVMC, .parse = qemu_chr_parse_spice_vmc, .create = qemu_chr_open_spice_vmc, @@ -396,6 +398,7 @@ static void register_types(void) .chr_free = spice_chr_free, }; static const CharDriver port_driver = { + .instance_size = sizeof(SpiceCharDriver), .kind = CHARDEV_BACKEND_KIND_SPICEPORT, .parse = qemu_chr_parse_spice_port, .create = qemu_chr_open_spice_port, diff --git a/ui/console.c b/ui/console.c index f48ba26d2a..495d5a2121 100644 --- a/ui/console.c +++ b/ui/console.c @@ -1046,9 +1046,15 @@ void console_select(unsigned int index) } } +typedef struct VCDriverState { + CharDriverState parent; + QemuConsole *console; +} VCDriverState; + static int console_puts(CharDriverState *chr, const uint8_t *buf, int len) { - QemuConsole *s = chr->opaque; + VCDriverState *drv = (VCDriverState *)chr; + QemuConsole *s = drv->console; int i; if (!s->ds) { @@ -1958,7 +1964,8 @@ int qemu_console_get_height(QemuConsole *con, int fallback) static void text_console_set_echo(CharDriverState *chr, bool echo) { - QemuConsole *s = chr->opaque; + VCDriverState *drv = (VCDriverState *)chr; + QemuConsole *s = drv->console; s->echo = echo; } @@ -1998,12 +2005,11 @@ static const GraphicHwOps text_console_ops = { static void text_console_do_init(CharDriverState *chr, DisplayState *ds) { - QemuConsole *s; + VCDriverState *drv = (VCDriverState *)chr; + QemuConsole *s = drv->console; int g_width = 80 * FONT_WIDTH; int g_height = 24 * FONT_HEIGHT; - s = chr->opaque; - s->out_fifo.buf = s->out_fifo_buf; s->out_fifo.buf_size = sizeof(s->out_fifo_buf); s->kbd_timer = timer_new_ms(QEMU_CLOCK_REALTIME, kbd_send_chars, s); @@ -2056,6 +2062,7 @@ static CharDriverState *text_console_init(ChardevVC *vc, Error **errp) { ChardevCommon *common = qapi_ChardevVC_base(vc); CharDriverState *chr; + VCDriverState *drv; QemuConsole *s; unsigned width = 0; unsigned height = 0; @@ -2092,7 +2099,8 @@ static CharDriverState *text_console_init(ChardevVC *vc, Error **errp) } s->chr = chr; - chr->opaque = s; + drv = (VCDriverState *)chr; + drv->console = s; if (display_state) { text_console_do_init(chr, display_state); @@ -2196,6 +2204,7 @@ static const TypeInfo qemu_console_info = { }; static const CharDriver vc_driver = { + .instance_size = sizeof(VCDriverState), .kind = CHARDEV_BACKEND_KIND_VC, .parse = qemu_chr_parse_vc, .create = vc_init, diff --git a/ui/gtk.c b/ui/gtk.c index 608400b56d..90cf4d5596 100644 --- a/ui/gtk.c +++ b/ui/gtk.c @@ -181,6 +181,12 @@ struct GtkDisplayState { bool ignore_keys; }; +typedef struct VCDriverState { + CharDriverState parent; + VirtualConsole *console; + bool echo; +} VCDriverState; + static void gd_grab_pointer(VirtualConsole *vc, const char *reason); static void gd_ungrab_pointer(GtkDisplayState *s); static void gd_grab_keyboard(VirtualConsole *vc, const char *reason); @@ -1685,7 +1691,8 @@ static void gd_vc_adjustment_changed(GtkAdjustment *adjustment, void *opaque) static int gd_vc_chr_write(CharDriverState *chr, const uint8_t *buf, int len) { - VirtualConsole *vc = chr->opaque; + VCDriverState *vcd = (VCDriverState *)chr; + VirtualConsole *vc = vcd->console; vte_terminal_feed(VTE_TERMINAL(vc->vte.terminal), (const char *)buf, len); return len; @@ -1693,9 +1700,14 @@ static int gd_vc_chr_write(CharDriverState *chr, const uint8_t *buf, int len) static void gd_vc_chr_set_echo(CharDriverState *chr, bool echo) { - VirtualConsole *vc = chr->opaque; + VCDriverState *vcd = (VCDriverState *)chr; + VirtualConsole *vc = vcd->console; - vc->vte.echo = echo; + if (vc) { + vc->vte.echo = echo; + } else { + vcd->echo = echo; + } } static int nb_vcs; @@ -1704,6 +1716,7 @@ static CharDriverState *vcs[MAX_VCS]; static CharDriverState *gd_vc_handler(ChardevVC *vc, Error **errp) { static const CharDriver gd_vc_driver = { + .instance_size = sizeof(VCDriverState), .kind = CHARDEV_BACKEND_KIND_VC, .chr_write = gd_vc_chr_write, .chr_set_echo = gd_vc_chr_set_echo, @@ -1722,9 +1735,6 @@ static CharDriverState *gd_vc_handler(ChardevVC *vc, Error **errp) return NULL; } - /* Temporary, until gd_vc_vte_init runs. */ - chr->opaque = g_new0(VirtualConsole, 1); - vcs[nb_vcs++] = chr; return chr; @@ -1765,14 +1775,12 @@ static GSList *gd_vc_vte_init(GtkDisplayState *s, VirtualConsole *vc, GtkWidget *box; GtkWidget *scrollbar; GtkAdjustment *vadjustment; - VirtualConsole *tmp_vc = chr->opaque; + VCDriverState *vcd = (VCDriverState *)chr; vc->s = s; - vc->vte.echo = tmp_vc->vte.echo; - + vc->vte.echo = vcd->echo; vc->vte.chr = chr; - chr->opaque = vc; - g_free(tmp_vc); + vcd->console = vc; snprintf(buffer, sizeof(buffer), "vc%d", idx); vc->label = g_strdup_printf("%s", vc->vte.chr->label -- 2.11.0
