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 <marcandre.lureau@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
#define BUF_SIZE 256
typedef struct {
#define BUF_SIZE 256
typedef struct {
+ CharDriverState parent;
brlapi_handle_t *brlapi;
int brlapi_fd;
brlapi_handle_t *brlapi;
int brlapi_fd;
/* The serial port can receive more of our data */
static void baum_accept_input(struct CharDriverState *chr)
{
/* 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)
int room, first;
if (!baum->out_buf_used)
/* We want to send a packet */
static void baum_write_packet(BaumDriverState *baum, const uint8_t *buf, int len)
{
/* 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;
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 */
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. */
} 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) {
len -= room;
cur = io_buf + room;
if (len > BUF_SIZE - baum->out_buf_used) {
/* 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)
{
/* 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)
int tocopy, cur, eaten, orig_len = len;
if (!len)
static void baum_free(struct CharDriverState *chr)
{
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);
}
timer_free(baum->cellCount_timer);
if (baum->brlapi) {
brlapi__closeConnection(baum->brlapi);
g_free(baum->brlapi);
}
}
static CharDriverState *chr_baum_init(const CharDriver *driver,
}
static CharDriverState *chr_baum_init(const CharDriver *driver,
if (!chr) {
return NULL;
}
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;
handle = g_malloc0(brlapi_getHandleSize());
baum->brlapi = handle;
fail_handle:
g_free(handle);
g_free(chr);
fail_handle:
g_free(handle);
g_free(chr);
return NULL;
}
static void register_types(void)
{
static const CharDriver driver = {
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,
.kind = CHARDEV_BACKEND_KIND_BRAILLE,
.create = chr_baum_init,
.chr_write = baum_write,
#define MSMOUSE_HI2(n) (((n) & 0xc0) >> 6)
typedef struct {
#define MSMOUSE_HI2(n) (((n) & 0xc0) >> 6)
typedef struct {
+ CharDriverState parent;
+
QemuInputHandlerState *hs;
int axis[INPUT_AXIS__MAX];
bool btns[INPUT_BUTTON__MAX];
QemuInputHandlerState *hs;
int axis[INPUT_AXIS__MAX];
bool btns[INPUT_BUTTON__MAX];
static void msmouse_chr_accept_input(CharDriverState *chr)
{
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);
int len;
len = qemu_chr_be_can_write(chr);
static void msmouse_input_sync(DeviceState *dev)
{
MouseState *mouse = (MouseState *)dev;
static void msmouse_input_sync(DeviceState *dev)
{
MouseState *mouse = (MouseState *)dev;
+ CharDriverState *chr = (CharDriverState *)dev;
msmouse_queue_event(mouse);
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)
}
static int msmouse_chr_write (struct CharDriverState *s, const uint8_t *buf, int len)
static void msmouse_chr_free(struct CharDriverState *chr)
{
static void msmouse_chr_free(struct CharDriverState *chr)
{
- MouseState *mouse = chr->opaque;
+ MouseState *mouse = (MouseState *)chr;
qemu_input_handler_unregister(mouse->hs);
qemu_input_handler_unregister(mouse->hs);
}
static QemuInputHandler msmouse_handler = {
}
static QemuInputHandler msmouse_handler = {
- mouse = g_new0(MouseState, 1);
+ mouse = (MouseState *)chr;
mouse->hs = qemu_input_handler_register((DeviceState *)mouse,
&msmouse_handler);
mouse->hs = qemu_input_handler_register((DeviceState *)mouse,
&msmouse_handler);
- mouse->chr = chr;
- chr->opaque = mouse;
static void register_types(void)
{
static 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,
.kind = CHARDEV_BACKEND_KIND_MSMOUSE,
.create = qemu_chr_open_msmouse,
.chr_write = msmouse_chr_write,
#define BUF_SIZE 32
typedef struct {
#define BUF_SIZE 32
typedef struct {
+ CharDriverState parent;
+
uint8_t in_buf[32];
int in_buf_used;
} TestdevCharState;
uint8_t in_buf[32];
int in_buf_used;
} TestdevCharState;
/* 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)
{
/* 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) {
int tocopy, eaten, orig_len = len;
while (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,
static CharDriverState *chr_testdev_init(const CharDriver *driver,
const char *id,
ChardevBackend *backend,
bool *be_opened,
Error **errp)
{
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;
static void register_types(void)
{
static 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,
.kind = CHARDEV_BACKEND_KIND_TESTDEV,
.create = chr_testdev_init,
.chr_write = testdev_write,
- .chr_free = testdev_free,
};
register_char_driver(&driver);
}
};
register_char_driver(&driver);
}
CharDriverState *mon_chr;
ChardevCommon common = { 0 };
static const CharDriver driver = {
CharDriverState *mon_chr;
ChardevCommon common = { 0 };
static const CharDriver driver = {
+ .instance_size = sizeof(CharDriverState),
.kind = -1,
.chr_write = gdb_monitor_write,
};
.kind = -1,
.chr_write = gdb_monitor_write,
};
#include "hw/bt.h"
struct csrhci_s {
#include "hw/bt.h"
struct csrhci_s {
int enable;
qemu_irq *pins;
int pin_state;
int modem_state;
int enable;
qemu_irq *pins;
int pin_state;
int modem_state;
#define FIFO_LEN 4096
int out_start;
int out_len;
#define FIFO_LEN 4096
int out_start;
int out_len;
static int csrhci_write(struct CharDriverState *chr,
const uint8_t *buf, int len)
{
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)
int total = 0;
if (!s->enable)
static int csrhci_ioctl(struct CharDriverState *chr, int cmd, void *arg)
{
QEMUSerialSetParams *ssp;
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) {
int prev_state = s->modem_state;
switch (cmd) {
qemu_irq *csrhci_pins_get(CharDriverState *chr)
{
qemu_irq *csrhci_pins_get(CharDriverState *chr)
{
- struct csrhci_s *s = (struct csrhci_s *) chr->opaque;
+ struct csrhci_s *s = (struct csrhci_s *) chr;
CharDriverState *uart_hci_init(void)
{
static const CharDriver hci_driver = {
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,
.kind = -1,
.chr_write = csrhci_write,
.chr_ioctl = csrhci_ioctl,
struct csrhci_s *s = (struct csrhci_s *)
g_malloc0(sizeof(struct csrhci_s));
struct csrhci_s *s = (struct csrhci_s *)
g_malloc0(sizeof(struct csrhci_s));
s->chr.driver = &hci_driver;
s->hci = qemu_next_hci();
s->chr.driver = &hci_driver;
s->hci = qemu_next_hci();
const CharDriver *driver;
QemuMutex chr_write_lock;
CharBackend *be;
const CharDriver *driver;
QemuMutex chr_write_lock;
CharBackend *be;
char *label;
char *filename;
int logfd;
char *label;
char *filename;
int logfd;
ChardevBackend *backend,
ChardevReturn *ret, bool *be_opened,
Error **errp);
ChardevBackend *backend,
ChardevReturn *ret, bool *be_opened,
Error **errp);
int (*chr_write)(struct CharDriverState *s, const uint8_t *buf, int len);
int (*chr_sync_read)(struct CharDriverState *s,
int (*chr_write)(struct CharDriverState *s, const uint8_t *buf, int len);
int (*chr_sync_read)(struct CharDriverState *s,
CharDriverState *qemu_chr_alloc(const CharDriver *driver,
ChardevCommon *backend, Error **errp)
{
CharDriverState *qemu_chr_alloc(const CharDriver *driver,
ChardevCommon *backend, Error **errp)
{
- CharDriverState *chr = g_malloc0(sizeof(CharDriverState));
- qemu_mutex_init(&chr->chr_write_lock);
assert(driver);
assert(driver->chr_write);
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 &&
if (backend->has_logfile) {
int flags = O_WRONLY | O_CREAT;
if (backend->has_logappend &&
}
static const CharDriver null_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,
.kind = CHARDEV_BACKEND_KIND_NULL,
.create = qemu_chr_open_null,
.chr_write = null_chr_write,
#define MUX_BUFFER_SIZE 32 /* Must be a power of 2. */
#define MUX_BUFFER_MASK (MUX_BUFFER_SIZE - 1)
struct MuxDriver {
#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;
CharBackend *backends[MAX_MUX];
CharBackend chr;
int focus;
/* Called with chr_write_lock held. */
static int mux_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
{
/* 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);
int ret;
if (!d->timestamps) {
ret = qemu_chr_fe_write(&d->chr, buf, len);
static void mux_chr_accept_input(CharDriverState *chr)
{
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];
int m = d->focus;
CharBackend *be = d->backends[m];
static int mux_chr_can_read(void *opaque)
{
static int mux_chr_can_read(void *opaque)
{
- CharDriverState *chr = opaque;
- MuxDriver *d = chr->opaque;
int m = d->focus;
CharBackend *be = d->backends[m];
int m = d->focus;
CharBackend *be = d->backends[m];
static void mux_chr_read(void *opaque, const uint8_t *buf, int size)
{
CharDriverState *chr = opaque;
static void mux_chr_read(void *opaque, const uint8_t *buf, int size)
{
CharDriverState *chr = opaque;
- MuxDriver *d = chr->opaque;
int m = d->focus;
CharBackend *be = d->backends[m];
int i;
int m = d->focus;
CharBackend *be = d->backends[m];
int i;
static void mux_chr_event(void *opaque, int event)
{
static void mux_chr_event(void *opaque, int event)
{
- CharDriverState *chr = opaque;
- MuxDriver *d = chr->opaque;
int i;
if (!muxes_realized) {
int i;
if (!muxes_realized) {
QTAILQ_FOREACH(chr, &chardevs, next) {
if (qemu_chr_get_kind(chr) == CHARDEV_BACKEND_KIND_MUX) {
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 */
int i;
/* send OPENED to all already-attached FEs */
static GSource *mux_chr_add_watch(CharDriverState *s, GIOCondition cond)
{
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) {
CharDriverState *chr = qemu_chr_fe_get_driver(&d->chr);
if (!chr->driver->chr_add_watch) {
static void mux_chr_free(struct CharDriverState *chr)
{
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++) {
int i;
for (i = 0; i < d->mux_cnt; i++) {
}
}
qemu_chr_fe_deinit(&d->chr);
}
}
qemu_chr_fe_deinit(&d->chr);
}
static void mux_chr_set_handlers(CharDriverState *chr, GMainContext *context)
{
}
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,
/* Fix up the real driver with mux routines */
qemu_chr_fe_set_handlers(&d->chr,
static void mux_set_focus(CharDriverState *chr, int focus)
{
static void mux_set_focus(CharDriverState *chr, int focus)
{
- MuxDriver *d = chr->opaque;
+ MuxDriver *d = (MuxDriver *)chr;
assert(focus >= 0);
assert(focus < d->mux_cnt);
assert(focus >= 0);
assert(focus < d->mux_cnt);
if (!chr) {
return NULL;
}
if (!chr) {
return NULL;
}
- d = g_new0(MuxDriver, 1);
-
- chr->opaque = d;
d->focus = -1;
/* only default to opened state if we've realized the initial
* set of muxes
d->focus = -1;
/* only default to opened state if we've realized the initial
* set of muxes
int tag = 0;
if (qemu_chr_get_kind(s) == CHARDEV_BACKEND_KIND_MUX) {
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;
if (d->mux_cnt >= MAX_MUX) {
goto unavailable;
static bool qemu_chr_is_busy(CharDriverState *s)
{
if (qemu_chr_get_kind(s) == CHARDEV_BACKEND_KIND_MUX) {
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;
return d->mux_cnt >= 0;
} else {
return s->be != NULL;
b->chr->be = NULL;
}
if (qemu_chr_get_kind(b->chr) == CHARDEV_BACKEND_KIND_MUX) {
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;
d->backends[b->tag] = NULL;
}
b->chr = NULL;
typedef struct FDCharDriver {
typedef struct FDCharDriver {
+ CharDriverState parent;
CharDriverState *chr;
QIOChannel *ioc_in, *ioc_out;
int max_size;
CharDriverState *chr;
QIOChannel *ioc_in, *ioc_out;
int max_size;
/* Called with chr_write_lock held. */
static int fd_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
{
/* 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;
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;
int len;
uint8_t buf[READ_BUF_LEN];
ssize_t ret;
static int fd_chr_read_poll(void *opaque)
{
CharDriverState *chr = 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;
s->max_size = qemu_chr_be_can_write(chr);
return s->max_size;
static GSource *fd_chr_add_watch(CharDriverState *chr, GIOCondition cond)
{
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)
{
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) {
remove_fd_in_watch(chr);
if (s->ioc_in) {
static void fd_chr_free(struct 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) {
remove_fd_in_watch(chr);
if (s->ioc_in) {
object_unref(OBJECT(s->ioc_out));
}
object_unref(OBJECT(s->ioc_out));
}
qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
}
qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
}
if (!chr) {
return NULL;
}
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);
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);
g_free(name);
qemu_set_nonblock(fd_out);
s->chr = chr;
g_free(name);
qemu_set_nonblock(fd_out);
s->chr = chr;
#define HAVE_CHARDEV_PTY 1
typedef struct {
#define HAVE_CHARDEV_PTY 1
typedef struct {
+ CharDriverState parent;
QIOChannel *ioc;
int read_bytes;
QIOChannel *ioc;
int read_bytes;
static gboolean pty_chr_timer(gpointer opaque)
{
struct CharDriverState *chr = opaque;
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;
qemu_mutex_lock(&chr->chr_write_lock);
s->timer_tag = 0;
/* Called with chr_write_lock held. */
static void pty_chr_rearm_timer(CharDriverState *chr, int ms)
{
/* 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) {
char *name;
if (s->timer_tag) {
/* Called with chr_write_lock held. */
static void pty_chr_update_read_handler_locked(CharDriverState *chr)
{
/* 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);
GPollFD pfd;
int rc;
QIOChannelFile *fioc = QIO_CHANNEL_FILE(s->ioc);
/* Called with chr_write_lock held. */
static int pty_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
{
/* 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 */
if (!s->connected) {
/* guest sends data, check for (re-)connect */
static GSource *pty_chr_add_watch(CharDriverState *chr, GIOCondition cond)
{
static GSource *pty_chr_add_watch(CharDriverState *chr, GIOCondition cond)
{
- PtyCharDriver *s = chr->opaque;
+ PtyCharDriver *s = (PtyCharDriver *)chr;
if (!s->connected) {
return NULL;
}
if (!s->connected) {
return NULL;
}
static int pty_chr_read_poll(void *opaque)
{
CharDriverState *chr = opaque;
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;
s->read_bytes = qemu_chr_be_can_write(chr);
return s->read_bytes;
static gboolean pty_chr_read(QIOChannel *chan, GIOCondition cond, void *opaque)
{
CharDriverState *chr = 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;
gsize len;
uint8_t buf[READ_BUF_LEN];
ssize_t ret;
static gboolean qemu_chr_be_generic_open_func(gpointer opaque)
{
CharDriverState *chr = 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);
s->open_tag = 0;
qemu_chr_be_generic_open(chr);
/* Called with chr_write_lock held. */
static void pty_chr_state(CharDriverState *chr, int connected)
{
/* 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) {
if (!connected) {
if (s->open_tag) {
static void pty_chr_free(struct CharDriverState *chr)
{
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);
qemu_mutex_lock(&chr->chr_write_lock);
pty_chr_state(chr, 0);
s->timer_tag = 0;
}
qemu_mutex_unlock(&chr->chr_write_lock);
s->timer_tag = 0;
}
qemu_mutex_unlock(&chr->chr_write_lock);
qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
}
qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
}
fprintf(stderr, "char device redirected to %s (label %s)\n",
pty_name, id);
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;
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;
return chr;
}
static const CharDriver pty_driver = {
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,
.kind = CHARDEV_BACKEND_KIND_PTY,
.create = qemu_chr_open_pty,
.chr_write = pty_chr_write,
static int tty_serial_ioctl(CharDriverState *chr, int cmd, void *arg)
{
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) {
QIOChannelFile *fioc = QIO_CHANNEL_FILE(s->ioc_in);
switch(cmd) {
#define HAVE_CHARDEV_PARPORT 1
typedef struct {
#define HAVE_CHARDEV_PARPORT 1
typedef struct {
+ CharDriverState parent;
int fd;
int mode;
} ParallelCharDriver;
int fd;
int mode;
} ParallelCharDriver;
static int pp_ioctl(CharDriverState *chr, int cmd, void *arg)
{
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;
int fd = drv->fd;
uint8_t b;
static void pp_free(CharDriverState *chr)
{
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);
int fd = drv->fd;
pp_hw_mode(drv, IEEE1284_MODE_COMPAT);
ioctl(fd, PPRELEASE);
close(fd);
qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
}
qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
}
- drv = g_new0(ParallelCharDriver, 1);
- chr->opaque = drv;
-
+ drv = (ParallelCharDriver *)chr;
drv->fd = fd;
drv->mode = IEEE1284_MODE_COMPAT;
drv->fd = fd;
drv->mode = IEEE1284_MODE_COMPAT;
#define HAVE_CHARDEV_PARPORT 1
#define HAVE_CHARDEV_PARPORT 1
+typedef struct {
+ CharDriverState parent;
+ int fd;
+} ParallelCharDriver;
+
static int pp_ioctl(CharDriverState *chr, int cmd, void *arg)
{
static int pp_ioctl(CharDriverState *chr, int cmd, void *arg)
{
- int fd = (int)(intptr_t)chr->opaque;
+ ParallelCharDriver *drv = (ParallelCharDriver *)chr;
case CHR_IOCTL_PP_READ_DATA:
case CHR_IOCTL_PP_READ_DATA:
- if (ioctl(fd, PPIGDATA, &b) < 0)
+ if (ioctl(drv->fd, PPIGDATA, &b) < 0) {
*(uint8_t *)arg = b;
break;
case CHR_IOCTL_PP_WRITE_DATA:
b = *(uint8_t *)arg;
*(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) {
break;
case CHR_IOCTL_PP_READ_CONTROL:
break;
case CHR_IOCTL_PP_READ_CONTROL:
- if (ioctl(fd, PPIGCTRL, &b) < 0)
+ if (ioctl(drv->fd, PPIGCTRL, &b) < 0) {
*(uint8_t *)arg = b;
break;
case CHR_IOCTL_PP_WRITE_CONTROL:
b = *(uint8_t *)arg;
*(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) {
break;
case CHR_IOCTL_PP_READ_STATUS:
break;
case CHR_IOCTL_PP_READ_STATUS:
- if (ioctl(fd, PPIGSTATUS, &b) < 0)
+ if (ioctl(drv->fd, PPIGSTATUS, &b) < 0) {
*(uint8_t *)arg = b;
break;
default:
*(uint8_t *)arg = b;
break;
default:
Error **errp)
{
CharDriverState *chr;
Error **errp)
{
CharDriverState *chr;
+ ParallelCharDriver *drv;
chr = qemu_chr_alloc(driver, backend, errp);
if (!chr) {
return NULL;
}
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;
}
*be_opened = false;
return chr;
}
#define HAVE_CHARDEV_SERIAL 1
typedef struct {
#define HAVE_CHARDEV_SERIAL 1
typedef struct {
+ CharDriverState parent;
int max_size;
HANDLE hcom, hrecv, hsend;
OVERLAPPED orecv;
int max_size;
HANDLE hcom, hrecv, hsend;
OVERLAPPED orecv;
} WinCharState;
typedef struct {
} WinCharState;
typedef struct {
+ CharDriverState parent;
HANDLE hStdIn;
HANDLE hInputReadyEvent;
HANDLE hInputDoneEvent;
HANDLE hStdIn;
HANDLE hInputReadyEvent;
HANDLE hInputDoneEvent;
static void win_chr_free(CharDriverState *chr)
{
static void win_chr_free(CharDriverState *chr)
{
- WinCharState *s = chr->opaque;
+ WinCharState *s = (WinCharState *)chr;
if (s->hsend) {
CloseHandle(s->hsend);
if (s->hsend) {
CloseHandle(s->hsend);
static int win_chr_init(CharDriverState *chr, const char *filename, Error **errp)
{
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;
COMMCONFIG comcfg;
COMMTIMEOUTS cto = { 0, 0, 0, 0, 0};
COMSTAT comstat;
/* Called with chr_write_lock held. */
static int win_chr_write(CharDriverState *chr, const uint8_t *buf, int len1)
{
/* 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;
DWORD len, ret, size, err;
len = len1;
static int win_chr_read_poll(CharDriverState *chr)
{
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;
s->max_size = qemu_chr_be_can_write(chr);
return s->max_size;
static void win_chr_readfile(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;
int ret, err;
uint8_t buf[READ_BUF_LEN];
DWORD size;
static void win_chr_read(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;
if (s->len > s->max_size)
s->len = s->max_size;
static int win_chr_poll(void *opaque)
{
CharDriverState *chr = opaque;
static int win_chr_poll(void *opaque)
{
CharDriverState *chr = opaque;
- WinCharState *s = chr->opaque;
+ WinCharState *s = opaque;
COMSTAT status;
DWORD comerr;
COMSTAT status;
DWORD comerr;
static int win_chr_pipe_poll(void *opaque)
{
CharDriverState *chr = 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);
DWORD size;
PeekNamedPipe(s->hcom, NULL, 0, NULL, &size, NULL);
static int win_chr_pipe_init(CharDriverState *chr, const char *filename,
Error **errp)
{
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;
OVERLAPPED ov;
int ret;
DWORD size;
ChardevHostdev *opts = backend->u.pipe.data;
const char *filename = opts->device;
CharDriverState *chr;
ChardevHostdev *opts = backend->u.pipe.data;
const char *filename = opts->device;
CharDriverState *chr;
ChardevCommon *common = qapi_ChardevHostdev_base(opts);
chr = qemu_chr_alloc(driver, common, errp);
if (!chr) {
return NULL;
}
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) {
if (win_chr_pipe_init(chr, filename, errp) < 0) {
qemu_chr_free_common(chr);
return NULL;
}
qemu_chr_free_common(chr);
return NULL;
}
if (!chr) {
return NULL;
}
if (!chr) {
return NULL;
}
- s = g_new0(WinCharState, 1);
+ s = (WinCharState *)chr;
}
static const CharDriver console_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,
.kind = CHARDEV_BACKEND_KIND_CONSOLE,
.create = qemu_chr_open_win_con,
.chr_write = win_chr_write,
static void win_stdio_wait_func(void *opaque)
{
CharDriverState *chr = opaque;
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;
INPUT_RECORD buf[4];
int ret;
DWORD dwSize;
static DWORD WINAPI win_stdio_thread(LPVOID param)
{
static DWORD WINAPI win_stdio_thread(LPVOID param)
{
- CharDriverState *chr = param;
- WinStdioCharState *stdio = chr->opaque;
+ WinStdioCharState *stdio = param;
static void win_stdio_thread_wait_func(void *opaque)
{
CharDriverState *chr = opaque;
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);
if (qemu_chr_be_can_write(chr)) {
qemu_chr_be_write(chr, &stdio->win_stdio_buf, 1);
static void qemu_chr_set_echo_win_stdio(CharDriverState *chr, bool echo)
{
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);
DWORD dwMode = 0;
GetConsoleMode(stdio->hStdIn, &dwMode);
static void win_stdio_free(CharDriverState *chr)
{
static void win_stdio_free(CharDriverState *chr)
{
- WinStdioCharState *stdio = chr->opaque;
+ WinStdioCharState *stdio = (WinStdioCharState *)chr;
if (stdio->hInputReadyEvent != INVALID_HANDLE_VALUE) {
CloseHandle(stdio->hInputReadyEvent);
if (stdio->hInputReadyEvent != INVALID_HANDLE_VALUE) {
CloseHandle(stdio->hInputReadyEvent);
if (stdio->hInputThread != INVALID_HANDLE_VALUE) {
TerminateThread(stdio->hInputThread, 0);
}
if (stdio->hInputThread != INVALID_HANDLE_VALUE) {
TerminateThread(stdio->hInputThread, 0);
}
}
static CharDriverState *qemu_chr_open_stdio(const CharDriver *driver,
}
static CharDriverState *qemu_chr_open_stdio(const CharDriver *driver,
if (!chr) {
return NULL;
}
if (!chr) {
return NULL;
}
- stdio = g_new0(WinStdioCharState, 1);
+ stdio = (WinStdioCharState *)chr;
stdio->hStdIn = GetStdHandle(STD_INPUT_HANDLE);
if (stdio->hStdIn == INVALID_HANDLE_VALUE) {
stdio->hStdIn = GetStdHandle(STD_INPUT_HANDLE);
if (stdio->hStdIn == INVALID_HANDLE_VALUE) {
is_console = GetConsoleMode(stdio->hStdIn, &dwMode) != 0;
is_console = GetConsoleMode(stdio->hStdIn, &dwMode) != 0;
if (is_console) {
if (qemu_add_wait_object(stdio->hStdIn,
win_stdio_wait_func, chr)) {
if (is_console) {
if (qemu_add_wait_object(stdio->hStdIn,
win_stdio_wait_func, chr)) {
/* UDP Net console */
typedef struct {
/* UDP Net console */
typedef struct {
+ CharDriverState parent;
QIOChannel *ioc;
uint8_t buf[READ_BUF_LEN];
int bufcnt;
QIOChannel *ioc;
uint8_t buf[READ_BUF_LEN];
int bufcnt;
/* Called with chr_write_lock held. */
static int udp_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
{
/* 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);
return qio_channel_write(
s->ioc, (const char *)buf, len, NULL);
static int udp_chr_read_poll(void *opaque)
{
CharDriverState *chr = opaque;
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);
s->max_size = qemu_chr_be_can_write(chr);
static gboolean udp_chr_read(QIOChannel *chan, GIOCondition cond, void *opaque)
{
CharDriverState *chr = 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) {
ssize_t ret;
if (s->max_size == 0) {
static void udp_chr_update_read_handler(CharDriverState *chr,
GMainContext *context)
{
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) {
remove_fd_in_watch(chr);
if (s->ioc) {
static void udp_chr_free(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));
}
remove_fd_in_watch(chr);
if (s->ioc) {
object_unref(OBJECT(s->ioc));
}
qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
}
qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
}
/* TCP Net console */
typedef struct {
/* TCP Net console */
typedef struct {
+ CharDriverState parent;
QIOChannel *ioc; /* Client I/O channel */
QIOChannelSocket *sioc; /* Client master channel */
QIOChannelSocket *listen_ioc;
QIOChannel *ioc; /* Client I/O channel */
QIOChannelSocket *sioc; /* Client master channel */
QIOChannelSocket *listen_ioc;
static void qemu_chr_socket_restart_timer(CharDriverState *chr)
{
static void qemu_chr_socket_restart_timer(CharDriverState *chr)
{
- TCPCharDriver *s = chr->opaque;
+ TCPCharDriver *s = (TCPCharDriver *)chr;
assert(s->connected == 0);
s->reconnect_timer = g_timeout_add_seconds(s->reconnect_time,
socket_reconnect_timeout, chr);
assert(s->connected == 0);
s->reconnect_timer = g_timeout_add_seconds(s->reconnect_time,
socket_reconnect_timeout, chr);
static void check_report_connect_error(CharDriverState *chr,
Error *err)
{
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",
if (!s->connect_err_reported) {
error_report("Unable to connect character device %s: %s",
/* Called with chr_write_lock held. */
static int tcp_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
{
/* 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,
if (s->connected) {
int ret = io_channel_send_full(s->ioc, buf, len,
s->write_msgfds,
static int tcp_chr_read_poll(void *opaque)
{
CharDriverState *chr = opaque;
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);
if (!s->connected)
return 0;
s->max_size = qemu_chr_be_can_write(chr);
static int tcp_get_msgfds(CharDriverState *chr, int *fds, int num)
{
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);
int to_copy = (s->read_msgfds_num < num) ? s->read_msgfds_num : num;
assert(num <= TCP_MAX_FDS);
static int tcp_set_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);
/* clear old pending fd array */
g_free(s->write_msgfds);
static ssize_t tcp_chr_recv(CharDriverState *chr, char *buf, size_t len)
{
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;
struct iovec iov = { .iov_base = buf, .iov_len = len };
int ret;
size_t i;
static GSource *tcp_chr_add_watch(CharDriverState *chr, GIOCondition cond)
{
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)
{
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) {
int i;
if (!s->connected) {
static void tcp_chr_disconnect(CharDriverState *chr)
{
static void tcp_chr_disconnect(CharDriverState *chr)
{
- TCPCharDriver *s = chr->opaque;
+ TCPCharDriver *s = (TCPCharDriver *)chr;
if (!s->connected) {
return;
if (!s->connected) {
return;
static gboolean tcp_chr_read(QIOChannel *chan, GIOCondition cond, void *opaque)
{
CharDriverState *chr = opaque;
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;
uint8_t buf[READ_BUF_LEN];
int len, size;
static int tcp_chr_sync_read(CharDriverState *chr, const uint8_t *buf, int len)
{
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) {
int size;
if (!s->connected) {
static void tcp_chr_connect(void *opaque)
{
CharDriverState *chr = opaque;
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(
g_free(chr->filename);
chr->filename = sockaddr_to_str(
static void tcp_chr_update_read_handler(CharDriverState *chr,
GMainContext *context)
{
static void tcp_chr_update_read_handler(CharDriverState *chr,
GMainContext *context)
{
- TCPCharDriver *s = chr->opaque;
+ TCPCharDriver *s = (TCPCharDriver *)chr;
if (!s->connected) {
return;
if (!s->connected) {
return;
static void tcp_chr_telnet_init(CharDriverState *chr)
{
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;
TCPCharDriverTelnetInit *init =
g_new0(TCPCharDriverTelnetInit, 1);
size_t n = 0;
gpointer user_data)
{
CharDriverState *chr = user_data;
gpointer user_data)
{
CharDriverState *chr = user_data;
- TCPCharDriver *s = chr->opaque;
+ TCPCharDriver *s = user_data;
if (qio_task_propagate_error(task, NULL)) {
tcp_chr_disconnect(chr);
if (qio_task_propagate_error(task, NULL)) {
tcp_chr_disconnect(chr);
static void tcp_chr_tls_init(CharDriverState *chr)
{
static void tcp_chr_tls_init(CharDriverState *chr)
{
- TCPCharDriver *s = chr->opaque;
+ TCPCharDriver *s = (TCPCharDriver *)chr;
QIOChannelTLS *tioc;
Error *err = NULL;
gchar *name;
QIOChannelTLS *tioc;
Error *err = NULL;
gchar *name;
static void tcp_chr_set_client_ioc_name(CharDriverState *chr,
QIOChannelSocket *sioc)
{
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",
char *name;
name = g_strdup_printf("chardev-tcp-%s-%s",
s->is_listen ? "server" : "client",
static int tcp_chr_new_client(CharDriverState *chr, QIOChannelSocket *sioc)
{
static int tcp_chr_new_client(CharDriverState *chr, QIOChannelSocket *sioc)
{
- TCPCharDriver *s = chr->opaque;
+ TCPCharDriver *s = (TCPCharDriver *)chr;
+
if (s->ioc != NULL) {
return -1;
}
if (s->ioc != NULL) {
return -1;
}
static int tcp_chr_wait_connected(CharDriverState *chr, Error **errp)
{
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
QIOChannelSocket *sioc;
/* It can't wait on s->connected, since it is set asynchronously
static void tcp_chr_free(CharDriverState *chr)
{
static void tcp_chr_free(CharDriverState *chr)
{
- TCPCharDriver *s = chr->opaque;
+ TCPCharDriver *s = (TCPCharDriver *)chr;
tcp_chr_free_connection(chr);
tcp_chr_free_connection(chr);
if (s->tls_creds) {
object_unref(OBJECT(s->tls_creds));
}
if (s->tls_creds) {
object_unref(OBJECT(s->tls_creds));
}
qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
}
qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
}
{
QIOChannelSocket *sioc = QIO_CHANNEL_SOCKET(qio_task_get_source(task));
CharDriverState *chr = opaque;
{
QIOChannelSocket *sioc = QIO_CHANNEL_SOCKET(qio_task_get_source(task));
CharDriverState *chr = opaque;
- TCPCharDriver *s = chr->opaque;
+ TCPCharDriver *s = (TCPCharDriver *)chr;
Error *err = NULL;
if (qio_task_propagate_error(task, &err)) {
Error *err = NULL;
if (qio_task_propagate_error(task, &err)) {
/* Ring buffer chardev */
typedef struct {
/* Ring buffer chardev */
typedef struct {
+ CharDriverState parent;
size_t size;
size_t prod;
size_t cons;
size_t size;
size_t prod;
size_t cons;
static size_t ringbuf_count(const CharDriverState *chr)
{
static size_t ringbuf_count(const CharDriverState *chr)
{
- const RingBufCharDriver *d = chr->opaque;
+ const RingBufCharDriver *d = (RingBufCharDriver *)chr;
return d->prod - d->cons;
}
return d->prod - d->cons;
}
/* Called with chr_write_lock held. */
static int ringbuf_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
{
/* 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)) {
int i;
if (!buf || (len < 0)) {
static int ringbuf_chr_read(CharDriverState *chr, 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);
int i;
qemu_mutex_lock(&chr->chr_write_lock);
static void ringbuf_chr_free(struct CharDriverState *chr)
{
static void ringbuf_chr_free(struct CharDriverState *chr)
{
- RingBufCharDriver *d = chr->opaque;
+ RingBufCharDriver *d = (RingBufCharDriver *)chr;
- g_free(d);
- chr->opaque = NULL;
}
static CharDriverState *qemu_chr_open_ringbuf(const CharDriver *driver,
}
static CharDriverState *qemu_chr_open_ringbuf(const CharDriver *driver,
if (!chr) {
return NULL;
}
if (!chr) {
return NULL;
}
- d = g_malloc(sizeof(*d));
+ d = (RingBufCharDriver *)chr;
d->size = opts->has_size ? opts->size : 65536;
d->size = opts->has_size ? opts->size : 65536;
d->cons = 0;
d->cbuf = g_malloc0(d->size);
d->cons = 0;
d->cbuf = g_malloc0(d->size);
qemu_chr_free_common(chr);
return NULL;
}
qemu_chr_free_common(chr);
return NULL;
}
.parse = qemu_chr_parse_stdio,
.create = qemu_chr_open_stdio,
#ifdef _WIN32
.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
.chr_write = win_stdio_write,
.chr_set_echo = qemu_chr_set_echo_win_stdio,
.chr_free = win_stdio_free,
#else
.chr_add_watch = fd_chr_add_watch,
.chr_write = fd_chr_write,
.chr_update_read_handler = fd_chr_update_read_handler,
.chr_add_watch = fd_chr_add_watch,
.chr_write = fd_chr_write,
.chr_update_read_handler = fd_chr_update_read_handler,
.parse = qemu_chr_parse_pipe,
.create = qemu_chr_open_pipe,
#ifdef _WIN32
.parse = qemu_chr_parse_pipe,
.create = qemu_chr_open_pipe,
#ifdef _WIN32
.chr_write = win_chr_write,
.chr_free = win_chr_free,
#else
.chr_write = win_chr_write,
.chr_free = win_chr_free,
#else
.chr_add_watch = fd_chr_add_watch,
.chr_write = fd_chr_write,
.chr_update_read_handler = fd_chr_update_read_handler,
.chr_add_watch = fd_chr_add_watch,
.chr_write = fd_chr_write,
.chr_update_read_handler = fd_chr_update_read_handler,
}
static const CharDriver ringbuf_driver = {
}
static const CharDriver ringbuf_driver = {
+ .instance_size = sizeof(RingBufCharDriver),
.kind = CHARDEV_BACKEND_KIND_RINGBUF,
.parse = qemu_chr_parse_ringbuf,
.create = qemu_chr_open_ringbuf,
.kind = CHARDEV_BACKEND_KIND_RINGBUF,
.parse = qemu_chr_parse_ringbuf,
.create = qemu_chr_open_ringbuf,
/* Bug-compatibility: */
static const CharDriver memory_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,
.kind = CHARDEV_BACKEND_KIND_MEMORY,
.parse = qemu_chr_parse_ringbuf,
.create = qemu_chr_open_ringbuf,
}
static const CharDriver mux_driver = {
}
static const CharDriver mux_driver = {
+ .instance_size = sizeof(MuxDriver),
.kind = CHARDEV_BACKEND_KIND_MUX,
.parse = qemu_chr_parse_mux,
.create = qemu_chr_open_mux,
.kind = CHARDEV_BACKEND_KIND_MUX,
.parse = qemu_chr_parse_mux,
.create = qemu_chr_open_mux,
ChardevHostdev *serial = backend->u.serial.data;
ChardevCommon *common = qapi_ChardevHostdev_base(serial);
CharDriverState *chr;
ChardevHostdev *serial = backend->u.serial.data;
ChardevCommon *common = qapi_ChardevHostdev_base(serial);
CharDriverState *chr;
chr = qemu_chr_alloc(driver, common, errp);
if (!chr) {
return NULL;
}
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) {
if (win_chr_init(chr, serial->device, errp) < 0) {
qemu_chr_free_common(chr);
return NULL;
}
qemu_chr_free_common(chr);
return NULL;
}
}
static const CharDriver parallel_driver = {
}
static const CharDriver parallel_driver = {
+ .instance_size = sizeof(ParallelCharDriver),
.kind = CHARDEV_BACKEND_KIND_PARALLEL,
.alias = "parport",
.parse = qemu_chr_parse_parallel,
.kind = CHARDEV_BACKEND_KIND_PARALLEL,
.alias = "parport",
.parse = qemu_chr_parse_parallel,
.parse = qemu_chr_parse_file_out,
.create = qmp_chardev_open_file,
#ifdef _WIN32
.parse = qemu_chr_parse_file_out,
.create = qmp_chardev_open_file,
#ifdef _WIN32
.chr_write = win_chr_write,
/* FIXME: no chr_free */
#else
.chr_write = win_chr_write,
/* FIXME: no chr_free */
#else
.chr_add_watch = fd_chr_add_watch,
.chr_write = fd_chr_write,
.chr_update_read_handler = fd_chr_update_read_handler,
.chr_add_watch = fd_chr_add_watch,
.chr_write = fd_chr_write,
.chr_update_read_handler = fd_chr_update_read_handler,
.parse = qemu_chr_parse_serial,
.create = qmp_chardev_open_serial,
#ifdef _WIN32
.parse = qemu_chr_parse_serial,
.create = qmp_chardev_open_serial,
#ifdef _WIN32
.chr_write = win_chr_write,
.chr_free = win_chr_free,
#else
.chr_write = win_chr_write,
.chr_free = win_chr_free,
#else
.chr_add_watch = fd_chr_add_watch,
.chr_write = fd_chr_write,
.chr_update_read_handler = fd_chr_update_read_handler,
.chr_add_watch = fd_chr_add_watch,
.chr_write = fd_chr_write,
.chr_update_read_handler = fd_chr_update_read_handler,
static gboolean socket_reconnect_timeout(gpointer opaque)
{
CharDriverState *chr = opaque;
static gboolean socket_reconnect_timeout(gpointer opaque)
{
CharDriverState *chr = opaque;
- TCPCharDriver *s = chr->opaque;
+ TCPCharDriver *s = opaque;
QIOChannelSocket *sioc;
s->reconnect_timer = 0;
QIOChannelSocket *sioc;
s->reconnect_timer = 0;
if (!chr) {
return NULL;
}
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;
s->is_unix = addr->type == SOCKET_ADDRESS_KIND_UNIX;
s->is_listen = is_listen;
qemu_chr_set_feature(chr, QEMU_CHAR_FEATURE_FD_PASS);
}
qemu_chr_set_feature(chr, QEMU_CHAR_FEATURE_FD_PASS);
}
/* be isn't opened until we get a connection */
*be_opened = false;
/* be isn't opened until we get a connection */
*be_opened = false;
if (s->tls_creds) {
object_unref(OBJECT(s->tls_creds));
}
if (s->tls_creds) {
object_unref(OBJECT(s->tls_creds));
}
qemu_chr_free_common(chr);
return NULL;
}
static const CharDriver socket_driver = {
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,
.kind = CHARDEV_BACKEND_KIND_SOCKET,
.parse = qemu_chr_parse_socket,
.create = qmp_chardev_open_socket,
qio_channel_set_name(QIO_CHANNEL(sioc), name);
g_free(name);
qio_channel_set_name(QIO_CHANNEL(sioc), name);
g_free(name);
- s = g_new0(NetCharDriver, 1);
+ s = (NetCharDriver *)chr;
s->ioc = QIO_CHANNEL(sioc);
s->ioc = QIO_CHANNEL(sioc);
/* be isn't opened until we get a connection */
*be_opened = false;
/* be isn't opened until we get a connection */
*be_opened = false;
}
static const CharDriver udp_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,
.kind = CHARDEV_BACKEND_KIND_UDP,
.parse = qemu_chr_parse_udp,
.create = qmp_chardev_open_udp,
typedef struct SpiceCharDriver {
typedef struct SpiceCharDriver {
+ CharDriverState parent;
+
SpiceCharDeviceInstance sin;
bool active;
bool blocked;
SpiceCharDeviceInstance sin;
bool active;
bool blocked;
static int vmc_write(SpiceCharDeviceInstance *sin, const uint8_t *buf, int len)
{
SpiceCharDriver *scd = container_of(sin, SpiceCharDriver, sin);
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) {
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;
}
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;
out += last_out;
len -= last_out;
p += last_out;
static void vmc_event(SpiceCharDeviceInstance *sin, uint8_t event)
{
SpiceCharDriver *scd = container_of(sin, SpiceCharDriver, sin);
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) {
int chr_event;
switch (event) {
}
trace_spice_vmc_event(chr_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);
}
#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)) {
- qemu_chr_be_event(scd->chr,
connected ? CHR_EVENT_OPENED : CHR_EVENT_CLOSED);
}
connected ? CHR_EVENT_OPENED : CHR_EVENT_CLOSED);
}
static GSource *spice_chr_add_watch(CharDriverState *chr, GIOCondition cond)
{
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);
SpiceCharSource *src;
assert(cond & G_IO_OUT);
static int spice_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
{
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);
int read_bytes;
assert(s->datalen == 0);
static void spice_chr_free(struct CharDriverState *chr)
{
static void spice_chr_free(struct CharDriverState *chr)
{
- SpiceCharDriver *s = chr->opaque;
+ SpiceCharDriver *s = (SpiceCharDriver *)chr;
vmc_unregister_interface(s);
QLIST_REMOVE(s, next);
vmc_unregister_interface(s);
QLIST_REMOVE(s, next);
#if SPICE_SERVER_VERSION >= 0x000c02
g_free((char *)s->sin.portname);
#endif
#if SPICE_SERVER_VERSION >= 0x000c02
g_free((char *)s->sin.portname);
#endif
}
static void spice_vmc_set_fe_open(struct CharDriverState *chr, int fe_open)
{
}
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 {
if (fe_open) {
vmc_register_interface(s);
} else {
static void spice_port_set_fe_open(struct CharDriverState *chr, int fe_open)
{
#if SPICE_SERVER_VERSION >= 0x000c02
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);
if (fe_open) {
spice_server_port_event(&s->sin, SPICE_PORT_EVENT_OPENED);
static void spice_chr_accept_input(struct CharDriverState *chr)
{
static void spice_chr_accept_input(struct CharDriverState *chr)
{
- SpiceCharDriver *s = chr->opaque;
+ SpiceCharDriver *s = (SpiceCharDriver *)chr;
spice_server_char_device_wakeup(&s->sin);
}
spice_server_char_device_wakeup(&s->sin);
}
if (!chr) {
return NULL;
}
if (!chr) {
return NULL;
}
- s = g_malloc0(sizeof(SpiceCharDriver));
- s->chr = chr;
+ s = (SpiceCharDriver *)chr;
s->active = false;
s->sin.subtype = g_strdup(subtype);
s->active = false;
s->sin.subtype = g_strdup(subtype);
QLIST_INSERT_HEAD(&spice_chars, s, next);
QLIST_INSERT_HEAD(&spice_chars, s, next);
return NULL;
}
*be_opened = false;
return NULL;
}
*be_opened = false;
+ s = (SpiceCharDriver *)chr;
s->sin.portname = g_strdup(name);
return chr;
s->sin.portname = g_strdup(name);
return chr;
static void register_types(void)
{
static const CharDriver vmc_driver = {
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,
.kind = CHARDEV_BACKEND_KIND_SPICEVMC,
.parse = qemu_chr_parse_spice_vmc,
.create = qemu_chr_open_spice_vmc,
.chr_free = spice_chr_free,
};
static const CharDriver port_driver = {
.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,
.kind = CHARDEV_BACKEND_KIND_SPICEPORT,
.parse = qemu_chr_parse_spice_port,
.create = qemu_chr_open_spice_port,
+typedef struct VCDriverState {
+ CharDriverState parent;
+ QemuConsole *console;
+} VCDriverState;
+
static int console_puts(CharDriverState *chr, const uint8_t *buf, int len)
{
static int console_puts(CharDriverState *chr, const uint8_t *buf, int len)
{
- QemuConsole *s = chr->opaque;
+ VCDriverState *drv = (VCDriverState *)chr;
+ QemuConsole *s = drv->console;
static void text_console_set_echo(CharDriverState *chr, bool echo)
{
static void text_console_set_echo(CharDriverState *chr, bool echo)
{
- QemuConsole *s = chr->opaque;
+ VCDriverState *drv = (VCDriverState *)chr;
+ QemuConsole *s = drv->console;
static void text_console_do_init(CharDriverState *chr, DisplayState *ds)
{
static void text_console_do_init(CharDriverState *chr, DisplayState *ds)
{
+ VCDriverState *drv = (VCDriverState *)chr;
+ QemuConsole *s = drv->console;
int g_width = 80 * FONT_WIDTH;
int g_height = 24 * FONT_HEIGHT;
int g_width = 80 * FONT_WIDTH;
int g_height = 24 * FONT_HEIGHT;
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);
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);
{
ChardevCommon *common = qapi_ChardevVC_base(vc);
CharDriverState *chr;
{
ChardevCommon *common = qapi_ChardevVC_base(vc);
CharDriverState *chr;
QemuConsole *s;
unsigned width = 0;
unsigned height = 0;
QemuConsole *s;
unsigned width = 0;
unsigned height = 0;
+ drv = (VCDriverState *)chr;
+ drv->console = s;
if (display_state) {
text_console_do_init(chr, display_state);
if (display_state) {
text_console_do_init(chr, display_state);
};
static const CharDriver vc_driver = {
};
static const CharDriver vc_driver = {
+ .instance_size = sizeof(VCDriverState),
.kind = CHARDEV_BACKEND_KIND_VC,
.parse = qemu_chr_parse_vc,
.create = vc_init,
.kind = CHARDEV_BACKEND_KIND_VC,
.parse = qemu_chr_parse_vc,
.create = vc_init,
+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);
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);
static int gd_vc_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
{
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;
vte_terminal_feed(VTE_TERMINAL(vc->vte.terminal), (const char *)buf, len);
return len;
static void gd_vc_chr_set_echo(CharDriverState *chr, bool echo)
{
static void gd_vc_chr_set_echo(CharDriverState *chr, bool echo)
{
- VirtualConsole *vc = chr->opaque;
+ VCDriverState *vcd = (VCDriverState *)chr;
+ VirtualConsole *vc = vcd->console;
+ if (vc) {
+ vc->vte.echo = echo;
+ } else {
+ vcd->echo = echo;
+ }
static CharDriverState *gd_vc_handler(ChardevVC *vc, Error **errp)
{
static const CharDriver gd_vc_driver = {
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,
.kind = CHARDEV_BACKEND_KIND_VC,
.chr_write = gd_vc_chr_write,
.chr_set_echo = gd_vc_chr_set_echo,
- /* Temporary, until gd_vc_vte_init runs. */
- chr->opaque = g_new0(VirtualConsole, 1);
-
vcs[nb_vcs++] = chr;
return chr;
vcs[nb_vcs++] = chr;
return chr;
GtkWidget *box;
GtkWidget *scrollbar;
GtkAdjustment *vadjustment;
GtkWidget *box;
GtkWidget *scrollbar;
GtkAdjustment *vadjustment;
- VirtualConsole *tmp_vc = chr->opaque;
+ VCDriverState *vcd = (VCDriverState *)chr;
- vc->vte.echo = tmp_vc->vte.echo;
-
+ vc->vte.echo = vcd->echo;
- chr->opaque = vc;
- g_free(tmp_vc);
snprintf(buffer, sizeof(buffer), "vc%d", idx);
vc->label = g_strdup_printf("%s", vc->vte.chr->label
snprintf(buffer, sizeof(buffer), "vc%d", idx);
vc->label = g_strdup_printf("%s", vc->vte.chr->label