ShuriZma
/
xqemu
mirror of https://github.com/xqemu/xqemu.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

char: remaining switch to CharBackend in frontend 

Similar to previous change, for the remaining CharDriverState front ends
users.

Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <20161022095318.17775-13-marcandre.lureau@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
This commit is contained in:
Marc-André Lureau 2016-10-22 12:52:52 +03:00 committed by Paolo Bonzini
parent becdfa00cf
commit 32a6ebecd2
14 changed files with 211 additions and 164 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
backends/rng-egd.c
View File

@ -23,7 +23,7 @@ typedef struct RngEgd
{ {
RngBackend parent; RngBackend parent;
CharDriverState *chr; CharBackend chr;
char *chr_name; char *chr_name;
} RngEgd; } RngEgd;
@ -42,7 +42,7 @@ static void rng_egd_request_entropy(RngBackend *b, RngRequest *req)
/* XXX this blocks entire thread. Rewrite to use /* XXX this blocks entire thread. Rewrite to use
* qemu_chr_fe_write and background I/O callbacks */ * qemu_chr_fe_write and background I/O callbacks */
qemu_chr_fe_write_all(s->chr, header, sizeof(header)); qemu_chr_fe_write_all(s->chr.chr, header, sizeof(header));
size -= len; size -= len;
} }
@ -86,6 +86,7 @@ static void rng_egd_chr_read(void *opaque, const uint8_t *buf, int size)
static void rng_egd_opened(RngBackend *b, Error **errp) static void rng_egd_opened(RngBackend *b, Error **errp)
{ {
RngEgd *s = RNG_EGD(b); RngEgd *s = RNG_EGD(b);
CharDriverState *chr;
if (s->chr_name == NULL) { if (s->chr_name == NULL) {
error_setg(errp, QERR_INVALID_PARAMETER_VALUE, error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
@ -93,21 +94,23 @@ static void rng_egd_opened(RngBackend *b, Error **errp)
return; return;
} }
s->chr = qemu_chr_find(s->chr_name); chr = qemu_chr_find(s->chr_name);
if (s->chr == NULL) { if (chr == NULL) {
error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND, error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
"Device '%s' not found", s->chr_name); "Device '%s' not found", s->chr_name);
return; return;
} }
if (qemu_chr_fe_claim(chr) != 0) {
if (qemu_chr_fe_claim(s->chr) != 0) {
error_setg(errp, QERR_DEVICE_IN_USE, s->chr_name); error_setg(errp, QERR_DEVICE_IN_USE, s->chr_name);
return; return;
} }
if (!qemu_chr_fe_init(&s->chr, chr, errp)) {
return;
}
/* FIXME we should resubmit pending requests when the CDS reconnects. */ /* FIXME we should resubmit pending requests when the CDS reconnects. */
qemu_chr_add_handlers(s->chr, rng_egd_chr_can_read, rng_egd_chr_read, qemu_chr_add_handlers(s->chr.chr, rng_egd_chr_can_read,
NULL, s); rng_egd_chr_read, NULL, s);
} }
static void rng_egd_set_chardev(Object *obj, const char *value, Error **errp) static void rng_egd_set_chardev(Object *obj, const char *value, Error **errp)
@ -127,8 +130,8 @@ static char *rng_egd_get_chardev(Object *obj, Error **errp)
{ {
RngEgd *s = RNG_EGD(obj); RngEgd *s = RNG_EGD(obj);
if (s->chr && s->chr->label) { if (s->chr.chr && s->chr.chr->label) {
return g_strdup(s->chr->label); return g_strdup(s->chr.chr->label);
} }
return NULL; return NULL;
@ -145,9 +148,9 @@ static void rng_egd_finalize(Object *obj)
{ {
RngEgd *s = RNG_EGD(obj); RngEgd *s = RNG_EGD(obj);
if (s->chr) { if (s->chr.chr) {
qemu_chr_add_handlers(s->chr, NULL, NULL, NULL, NULL); qemu_chr_add_handlers(s->chr.chr, NULL, NULL, NULL, NULL);
qemu_chr_fe_release(s->chr); qemu_chr_fe_release(s->chr.chr);
} }
g_free(s->chr_name); g_free(s->chr_name);

22
gdbstub.c
View File

@ -303,7 +303,7 @@ typedef struct GDBState {
int fd; int fd;
int running_state; int running_state;
#else #else
CharDriverState *chr; CharBackend chr;
CharDriverState *mon_chr; CharDriverState *mon_chr;
#endif #endif
char syscall_buf[256]; char syscall_buf[256];
@ -404,7 +404,7 @@ static void put_buffer(GDBState *s, const uint8_t *buf, int len)
#else #else
/* XXX this blocks entire thread. Rewrite to use /* XXX this blocks entire thread. Rewrite to use
* qemu_chr_fe_write and background I/O callbacks */ * qemu_chr_fe_write and background I/O callbacks */
qemu_chr_fe_write_all(s->chr, buf, len); qemu_chr_fe_write_all(s->chr.chr, buf, len);
#endif #endif
} }
@ -1481,7 +1481,7 @@ void gdb_exit(CPUArchState *env, int code)
return; return;
} }
#else #else
if (!s->chr) { if (!s->chr.chr) {
return; return;
} }
#endif #endif
@ -1490,7 +1490,7 @@ void gdb_exit(CPUArchState *env, int code)
put_packet(s, buf); put_packet(s, buf);
#ifndef CONFIG_USER_ONLY #ifndef CONFIG_USER_ONLY
qemu_chr_delete(s->chr); qemu_chr_delete(s->chr.chr);
#endif #endif
} }
@ -1750,8 +1750,6 @@ int gdbserver_start(const char *device)
return -1; return -1;
qemu_chr_fe_claim_no_fail(chr); qemu_chr_fe_claim_no_fail(chr);
qemu_chr_add_handlers(chr, gdb_chr_can_receive, gdb_chr_receive,
gdb_chr_event, NULL);
} }
s = gdbserver_state; s = gdbserver_state;
@ -1766,14 +1764,20 @@ int gdbserver_start(const char *device)
mon_chr->chr_write = gdb_monitor_write; mon_chr->chr_write = gdb_monitor_write;
monitor_init(mon_chr, 0); monitor_init(mon_chr, 0);
} else { } else {
if (s->chr) if (s->chr.chr) {
qemu_chr_delete(s->chr); qemu_chr_delete(s->chr.chr);
}
mon_chr = s->mon_chr; mon_chr = s->mon_chr;
memset(s, 0, sizeof(GDBState)); memset(s, 0, sizeof(GDBState));
s->mon_chr = mon_chr;
} }
s->c_cpu = first_cpu; s->c_cpu = first_cpu;
s->g_cpu = first_cpu; s->g_cpu = first_cpu;
s->chr = chr; if (chr) {
qemu_chr_fe_init(&s->chr, chr, &error_abort);
qemu_chr_add_handlers(s->chr.chr, gdb_chr_can_receive, gdb_chr_receive,
gdb_chr_event, NULL);
}
s->state = chr ? RS_IDLE : RS_INACTIVE; s->state = chr ? RS_IDLE : RS_INACTIVE;
s->mon_chr = mon_chr; s->mon_chr = mon_chr;
s->current_syscall_cb = NULL; s->current_syscall_cb = NULL;

11
hw/arm/omap2.c
View File

@ -621,7 +621,7 @@ struct omap_sti_s {
qemu_irq irq; qemu_irq irq;
MemoryRegion iomem; MemoryRegion iomem;
MemoryRegion iomem_fifo; MemoryRegion iomem_fifo;
CharDriverState *chr; CharBackend chr;
uint32_t sysconfig; uint32_t sysconfig;
uint32_t systest; uint32_t systest;
@ -771,14 +771,14 @@ static void omap_sti_fifo_write(void *opaque, hwaddr addr,
/* Flush channel <i>value</i>. */ /* Flush channel <i>value</i>. */
/* XXX this blocks entire thread. Rewrite to use /* XXX this blocks entire thread. Rewrite to use
* qemu_chr_fe_write and background I/O callbacks */ * qemu_chr_fe_write and background I/O callbacks */
qemu_chr_fe_write_all(s->chr, (const uint8_t *) "\r", 1); qemu_chr_fe_write_all(s->chr.chr, (const uint8_t *) "\r", 1);
} else if (ch == STI_TRACE_CONSOLE_CHANNEL || 1) { } else if (ch == STI_TRACE_CONSOLE_CHANNEL || 1) {
if (value == 0xc0 || value == 0xc3) { if (value == 0xc0 || value == 0xc3) {
/* Open channel <i>ch</i>. */ /* Open channel <i>ch</i>. */
} else if (value == 0x00) } else if (value == 0x00)
qemu_chr_fe_write_all(s->chr, (const uint8_t *) "\n", 1); qemu_chr_fe_write_all(s->chr.chr, (const uint8_t *) "\n", 1);
else else
qemu_chr_fe_write_all(s->chr, &byte, 1); qemu_chr_fe_write_all(s->chr.chr, &byte, 1);
} }
} }
@ -798,7 +798,8 @@ static struct omap_sti_s *omap_sti_init(struct omap_target_agent_s *ta,
s->irq = irq; s->irq = irq;
omap_sti_reset(s); omap_sti_reset(s);
s->chr = chr ?: qemu_chr_new("null", "null"); qemu_chr_fe_init(&s->chr, chr ?: qemu_chr_new("null", "null"),
&error_abort);
memory_region_init_io(&s->iomem, NULL, &omap_sti_ops, s, "omap.sti", memory_region_init_io(&s->iomem, NULL, &omap_sti_ops, s, "omap.sti",
omap_l4_region_size(ta, 0)); omap_l4_region_size(ta, 0));

12
hw/char/mcf_uart.c
View File

@ -10,6 +10,7 @@
#include "hw/m68k/mcf.h" #include "hw/m68k/mcf.h"
#include "sysemu/char.h" #include "sysemu/char.h"
#include "exec/address-spaces.h" #include "exec/address-spaces.h"
#include "qapi/error.h"
typedef struct { typedef struct {
MemoryRegion iomem; MemoryRegion iomem;
@ -26,7 +27,7 @@ typedef struct {
int tx_enabled; int tx_enabled;
int rx_enabled; int rx_enabled;
qemu_irq irq; qemu_irq irq;
CharDriverState *chr; CharBackend chr;
} mcf_uart_state; } mcf_uart_state;
/* UART Status Register bits. */ /* UART Status Register bits. */
@ -92,7 +93,7 @@ uint64_t mcf_uart_read(void *opaque, hwaddr addr,
if (s->fifo_len == 0) if (s->fifo_len == 0)
s->sr &= ~MCF_UART_RxRDY; s->sr &= ~MCF_UART_RxRDY;
mcf_uart_update(s); mcf_uart_update(s);
qemu_chr_accept_input(s->chr); qemu_chr_accept_input(s->chr.chr);
return val; return val;
} }
case 0x10: case 0x10:
@ -113,10 +114,11 @@ uint64_t mcf_uart_read(void *opaque, hwaddr addr,
static void mcf_uart_do_tx(mcf_uart_state *s) static void mcf_uart_do_tx(mcf_uart_state *s)
{ {
if (s->tx_enabled && (s->sr & MCF_UART_TxEMP) == 0) { if (s->tx_enabled && (s->sr & MCF_UART_TxEMP) == 0) {
if (s->chr) if (s->chr.chr) {
/* XXX this blocks entire thread. Rewrite to use /* XXX this blocks entire thread. Rewrite to use
* qemu_chr_fe_write and background I/O callbacks */ * qemu_chr_fe_write and background I/O callbacks */
qemu_chr_fe_write_all(s->chr, (unsigned char *)&s->tb, 1); qemu_chr_fe_write_all(s->chr.chr, (unsigned char *)&s->tb, 1);
}
s->sr |= MCF_UART_TxEMP; s->sr |= MCF_UART_TxEMP;
} }
if (s->tx_enabled) { if (s->tx_enabled) {
@ -280,9 +282,9 @@ void *mcf_uart_init(qemu_irq irq, CharDriverState *chr)
mcf_uart_state *s; mcf_uart_state *s;
s = g_malloc0(sizeof(mcf_uart_state)); s = g_malloc0(sizeof(mcf_uart_state));
s->chr = chr;
s->irq = irq; s->irq = irq;
if (chr) { if (chr) {
qemu_chr_fe_init(&s->chr, chr, &error_abort);
qemu_chr_fe_claim_no_fail(chr); qemu_chr_fe_claim_no_fail(chr);
qemu_chr_add_handlers(chr, mcf_uart_can_receive, mcf_uart_receive, qemu_chr_add_handlers(chr, mcf_uart_can_receive, mcf_uart_receive,
mcf_uart_event, s); mcf_uart_event, s);

10
hw/char/sh_serial.c
View File

@ -29,6 +29,7 @@
#include "hw/sh4/sh.h" #include "hw/sh4/sh.h"
#include "sysemu/char.h" #include "sysemu/char.h"
#include "exec/address-spaces.h" #include "exec/address-spaces.h"
#include "qapi/error.h"
//#define DEBUG_SERIAL //#define DEBUG_SERIAL
@ -62,7 +63,7 @@ typedef struct {
int flags; int flags;
int rtrg; int rtrg;
CharDriverState *chr; CharBackend chr;
qemu_irq eri; qemu_irq eri;
qemu_irq rxi; qemu_irq rxi;
@ -109,11 +110,11 @@ static void sh_serial_write(void *opaque, hwaddr offs,
} }
return; return;
case 0x0c: /* FTDR / TDR */ case 0x0c: /* FTDR / TDR */
if (s->chr) { if (s->chr.chr) {
ch = val; ch = val;
/* XXX this blocks entire thread. Rewrite to use /* XXX this blocks entire thread. Rewrite to use
* qemu_chr_fe_write and background I/O callbacks */ * qemu_chr_fe_write and background I/O callbacks */
qemu_chr_fe_write_all(s->chr, &ch, 1); qemu_chr_fe_write_all(s->chr.chr, &ch, 1);
} }
s->dr = val; s->dr = val;
s->flags &= ~SH_SERIAL_FLAG_TDE; s->flags &= ~SH_SERIAL_FLAG_TDE;
@ -395,10 +396,9 @@ void sh_serial_init(MemoryRegion *sysmem,
0, 0x28); 0, 0x28);
memory_region_add_subregion(sysmem, A7ADDR(base), &s->iomem_a7); memory_region_add_subregion(sysmem, A7ADDR(base), &s->iomem_a7);
s->chr = chr;
if (chr) { if (chr) {
qemu_chr_fe_claim_no_fail(chr); qemu_chr_fe_claim_no_fail(chr);
qemu_chr_fe_init(&s->chr, chr, &error_abort);
qemu_chr_add_handlers(chr, sh_serial_can_receive1, sh_serial_receive1, qemu_chr_add_handlers(chr, sh_serial_can_receive1, sh_serial_receive1,
sh_serial_event, s); sh_serial_event, s);
} }

39
hw/char/xen_console.c
View File

@ -26,6 +26,7 @@
#include "hw/hw.h" #include "hw/hw.h"
#include "sysemu/char.h" #include "sysemu/char.h"
#include "hw/xen/xen_backend.h" #include "hw/xen/xen_backend.h"
#include "qapi/error.h"
#include <xen/io/console.h> #include <xen/io/console.h>
@ -43,7 +44,7 @@ struct XenConsole {
char console[XEN_BUFSIZE]; char console[XEN_BUFSIZE];
int ring_ref; int ring_ref;
void *sring; void *sring;
CharDriverState *chr; CharBackend chr;
int backlog; int backlog;
}; };
@ -148,11 +149,13 @@ static void xencons_send(struct XenConsole *con)
ssize_t len, size; ssize_t len, size;
size = con->buffer.size - con->buffer.consumed; size = con->buffer.size - con->buffer.consumed;
if (con->chr) if (con->chr.chr) {
len = qemu_chr_fe_write(con->chr, con->buffer.data + con->buffer.consumed, len = qemu_chr_fe_write(con->chr.chr,
size); con->buffer.data + con->buffer.consumed,
else size);
} else {
len = size; len = size;
}
if (len < 1) { if (len < 1) {
if (!con->backlog) { if (!con->backlog) {
con->backlog = 1; con->backlog = 1;
@ -196,13 +199,17 @@ static int con_init(struct XenDevice *xendev)
/* no Xen override, use qemu output device */ /* no Xen override, use qemu output device */
if (output == NULL) { if (output == NULL) {
con->chr = serial_hds[con->xendev.dev]; if (con->xendev.dev) {
qemu_chr_fe_init(&con->chr, serial_hds[con->xendev.dev],
&error_abort);
}
} else { } else {
snprintf(label, sizeof(label), "xencons%d", con->xendev.dev); snprintf(label, sizeof(label), "xencons%d", con->xendev.dev);
con->chr = qemu_chr_new(label, output); qemu_chr_fe_init(&con->chr,
qemu_chr_new(label, output), &error_abort);
} }
xenstore_store_pv_console_info(con->xendev.dev, con->chr); xenstore_store_pv_console_info(con->xendev.dev, con->chr.chr);
out: out:
g_free(type); g_free(type);
@ -235,15 +242,15 @@ static int con_initialise(struct XenDevice *xendev)
return -1; return -1;
xen_be_bind_evtchn(&con->xendev); xen_be_bind_evtchn(&con->xendev);
if (con->chr) { if (con->chr.chr) {
if (qemu_chr_fe_claim(con->chr) == 0) { if (qemu_chr_fe_claim(con->chr.chr) == 0) {
qemu_chr_add_handlers(con->chr, xencons_can_receive, qemu_chr_add_handlers(con->chr.chr, xencons_can_receive,
xencons_receive, NULL, con); xencons_receive, NULL, con);
} else { } else {
xen_be_printf(xendev, 0, xen_be_printf(xendev, 0,
"xen_console_init error chardev %s already used\n", "xen_console_init error chardev %s already used\n",
con->chr->label); con->chr.chr->label);
con->chr = NULL; con->chr.chr = NULL;
} }
} }
@ -259,9 +266,9 @@ static void con_disconnect(struct XenDevice *xendev)
{ {
struct XenConsole *con = container_of(xendev, struct XenConsole, xendev); struct XenConsole *con = container_of(xendev, struct XenConsole, xendev);
if (con->chr) { if (con->chr.chr) {
qemu_chr_add_handlers(con->chr, NULL, NULL, NULL, NULL); qemu_chr_add_handlers(con->chr.chr, NULL, NULL, NULL, NULL);
qemu_chr_fe_release(con->chr); qemu_chr_fe_release(con->chr.chr);
} }
xen_be_unbind_evtchn(&con->xendev); xen_be_unbind_evtchn(&con->xendev);

32
hw/mips/mips_malta.c
View File

@ -85,7 +85,7 @@ typedef struct {
uint32_t i2coe; uint32_t i2coe;
uint32_t i2cout; uint32_t i2cout;
uint32_t i2csel; uint32_t i2csel;
CharDriverState *display; CharBackend display;
char display_text[9]; char display_text[9];
SerialState *uart; SerialState *uart;
bool display_inited; bool display_inited;
@ -125,8 +125,10 @@ static void malta_fpga_update_display(void *opaque)
} }
leds_text[8] = '\0'; leds_text[8] = '\0';
qemu_chr_fe_printf(s->display, "\e[H\n\n|\e[32m%-8.8s\e[00m|\r\n", leds_text); qemu_chr_fe_printf(s->display.chr, "\e[H\n\n|\e[32m%-8.8s\e[00m|\r\n",
qemu_chr_fe_printf(s->display, "\n\n\n\n|\e[31m%-8.8s\e[00m|", s->display_text); leds_text);
qemu_chr_fe_printf(s->display.chr, "\n\n\n\n|\e[31m%-8.8s\e[00m|",
s->display_text);
} }
/* /*
@ -536,15 +538,15 @@ static void malta_fgpa_display_event(void *opaque, int event)
MaltaFPGAState *s = opaque; MaltaFPGAState *s = opaque;
if (event == CHR_EVENT_OPENED && !s->display_inited) { if (event == CHR_EVENT_OPENED && !s->display_inited) {
qemu_chr_fe_printf(s->display, "\e[HMalta LEDBAR\r\n"); qemu_chr_fe_printf(s->display.chr, "\e[HMalta LEDBAR\r\n");
qemu_chr_fe_printf(s->display, "+--------+\r\n"); qemu_chr_fe_printf(s->display.chr, "+--------+\r\n");
qemu_chr_fe_printf(s->display, "+ +\r\n"); qemu_chr_fe_printf(s->display.chr, "+ +\r\n");
qemu_chr_fe_printf(s->display, "+--------+\r\n"); qemu_chr_fe_printf(s->display.chr, "+--------+\r\n");
qemu_chr_fe_printf(s->display, "\n"); qemu_chr_fe_printf(s->display.chr, "\n");
qemu_chr_fe_printf(s->display, "Malta ASCII\r\n"); qemu_chr_fe_printf(s->display.chr, "Malta ASCII\r\n");
qemu_chr_fe_printf(s->display, "+--------+\r\n"); qemu_chr_fe_printf(s->display.chr, "+--------+\r\n");
qemu_chr_fe_printf(s->display, "+ +\r\n"); qemu_chr_fe_printf(s->display.chr, "+ +\r\n");
qemu_chr_fe_printf(s->display, "+--------+\r\n"); qemu_chr_fe_printf(s->display.chr, "+--------+\r\n");
s->display_inited = true; s->display_inited = true;
} }
} }
@ -553,6 +555,7 @@ static MaltaFPGAState *malta_fpga_init(MemoryRegion *address_space,
hwaddr base, qemu_irq uart_irq, CharDriverState *uart_chr) hwaddr base, qemu_irq uart_irq, CharDriverState *uart_chr)
{ {
MaltaFPGAState *s; MaltaFPGAState *s;
CharDriverState *chr;
s = (MaltaFPGAState *)g_malloc0(sizeof(MaltaFPGAState)); s = (MaltaFPGAState *)g_malloc0(sizeof(MaltaFPGAState));
@ -566,8 +569,9 @@ static MaltaFPGAState *malta_fpga_init(MemoryRegion *address_space,
memory_region_add_subregion(address_space, base, &s->iomem_lo); memory_region_add_subregion(address_space, base, &s->iomem_lo);
memory_region_add_subregion(address_space, base + 0xa00, &s->iomem_hi); memory_region_add_subregion(address_space, base + 0xa00, &s->iomem_hi);
s->display = qemu_chr_new("fpga", "vc:320x200"); chr = qemu_chr_new("fpga", "vc:320x200");
qemu_chr_add_handlers(s->display, NULL, NULL, qemu_chr_fe_init(&s->display, chr, &error_abort);
qemu_chr_add_handlers(s->display.chr, NULL, NULL,
malta_fgpa_display_event, s); malta_fgpa_display_event, s);
s->uart = serial_mm_init(address_space, base + 0x900, 3, uart_irq, s->uart = serial_mm_init(address_space, base + 0x900, 3, uart_irq,

19
monitor.c
View File

@ -186,7 +186,7 @@ typedef struct {
} MonitorQAPIEventConf; } MonitorQAPIEventConf;
struct Monitor { struct Monitor {
CharDriverState *chr; CharBackend chr;
int reset_seen; int reset_seen;
int flags; int flags;
int suspend_cnt; int suspend_cnt;
@ -297,7 +297,7 @@ static void monitor_flush_locked(Monitor *mon)
len = qstring_get_length(mon->outbuf); len = qstring_get_length(mon->outbuf);
if (len && !mon->mux_out) { if (len && !mon->mux_out) {
rc = qemu_chr_fe_write(mon->chr, (const uint8_t *) buf, len); rc = qemu_chr_fe_write(mon->chr.chr, (const uint8_t *) buf, len);
if ((rc < 0 && errno != EAGAIN) || (rc == len)) { if ((rc < 0 && errno != EAGAIN) || (rc == len)) {
/* all flushed or error */ /* all flushed or error */
QDECREF(mon->outbuf); QDECREF(mon->outbuf);
@ -311,8 +311,9 @@ static void monitor_flush_locked(Monitor *mon)
mon->outbuf = tmp; mon->outbuf = tmp;
} }
if (mon->out_watch == 0) { if (mon->out_watch == 0) {
mon->out_watch = qemu_chr_fe_add_watch(mon->chr, G_IO_OUT|G_IO_HUP, mon->out_watch =
monitor_unblocked, mon); qemu_chr_fe_add_watch(mon->chr.chr, G_IO_OUT | G_IO_HUP,
monitor_unblocked, mon);
} }
} }
} }
@ -581,8 +582,8 @@ static void monitor_data_init(Monitor *mon)
static void monitor_data_destroy(Monitor *mon) static void monitor_data_destroy(Monitor *mon)
{ {
if (mon->chr) { if (mon->chr.chr) {
qemu_chr_add_handlers(mon->chr, NULL, NULL, NULL, NULL); qemu_chr_add_handlers(mon->chr.chr, NULL, NULL, NULL, NULL);
} }
if (monitor_is_qmp(mon)) { if (monitor_is_qmp(mon)) {
json_message_parser_destroy(&mon->qmp.parser); json_message_parser_destroy(&mon->qmp.parser);
@ -1745,7 +1746,7 @@ void qmp_getfd(const char *fdname, Error **errp)
mon_fd_t *monfd; mon_fd_t *monfd;
int fd; int fd;
fd = qemu_chr_fe_get_msgfd(cur_mon->chr); fd = qemu_chr_fe_get_msgfd(cur_mon->chr.chr);
if (fd == -1) { if (fd == -1) {
error_setg(errp, QERR_FD_NOT_SUPPLIED); error_setg(errp, QERR_FD_NOT_SUPPLIED);
return; return;
@ -1870,7 +1871,7 @@ AddfdInfo *qmp_add_fd(bool has_fdset_id, int64_t fdset_id, bool has_opaque,
Monitor *mon = cur_mon; Monitor *mon = cur_mon;
AddfdInfo *fdinfo; AddfdInfo *fdinfo;
fd = qemu_chr_fe_get_msgfd(mon->chr); fd = qemu_chr_fe_get_msgfd(mon->chr.chr);
if (fd == -1) { if (fd == -1) {
error_setg(errp, QERR_FD_NOT_SUPPLIED); error_setg(errp, QERR_FD_NOT_SUPPLIED);
goto error; goto error;
@ -3977,7 +3978,7 @@ void monitor_init(CharDriverState *chr, int flags)
mon = g_malloc(sizeof(*mon)); mon = g_malloc(sizeof(*mon));
monitor_data_init(mon); monitor_data_init(mon);
mon->chr = chr; qemu_chr_fe_init(&mon->chr, chr, &error_abort);
mon->flags = flags; mon->flags = flags;
if (flags & MONITOR_USE_READLINE) { if (flags & MONITOR_USE_READLINE) {
mon->rs = readline_init(monitor_readline_printf, mon->rs = readline_init(monitor_readline_printf,

46
net/colo-compare.c
View File

@ -68,9 +68,9 @@ typedef struct CompareState {
char *pri_indev; char *pri_indev;
char *sec_indev; char *sec_indev;
char *outdev; char *outdev;
CharDriverState *chr_pri_in; CharBackend chr_pri_in;
CharDriverState *chr_sec_in; CharBackend chr_sec_in;
CharDriverState *chr_out; CharBackend chr_out;
SocketReadState pri_rs; SocketReadState pri_rs;
SocketReadState sec_rs; SocketReadState sec_rs;
@ -385,7 +385,7 @@ static void colo_compare_connection(void *opaque, void *user_data)
} }
if (result) { if (result) {
ret = compare_chr_send(s->chr_out, pkt->data, pkt->size); ret = compare_chr_send(s->chr_out.chr, pkt->data, pkt->size);
if (ret < 0) { if (ret < 0) {
error_report("colo_send_primary_packet failed"); error_report("colo_send_primary_packet failed");
} }
@ -451,7 +451,7 @@ static void compare_pri_chr_in(void *opaque, const uint8_t *buf, int size)
ret = net_fill_rstate(&s->pri_rs, buf, size); ret = net_fill_rstate(&s->pri_rs, buf, size);
if (ret == -1) { if (ret == -1) {
qemu_chr_add_handlers(s->chr_pri_in, NULL, NULL, NULL, NULL); qemu_chr_add_handlers(s->chr_pri_in.chr, NULL, NULL, NULL, NULL);
error_report("colo-compare primary_in error"); error_report("colo-compare primary_in error");
} }
} }
@ -467,7 +467,7 @@ static void compare_sec_chr_in(void *opaque, const uint8_t *buf, int size)
ret = net_fill_rstate(&s->sec_rs, buf, size); ret = net_fill_rstate(&s->sec_rs, buf, size);
if (ret == -1) { if (ret == -1) {
qemu_chr_add_handlers(s->chr_sec_in, NULL, NULL, NULL, NULL); qemu_chr_add_handlers(s->chr_sec_in.chr, NULL, NULL, NULL, NULL);
error_report("colo-compare secondary_in error"); error_report("colo-compare secondary_in error");
} }
} }
@ -480,9 +480,9 @@ static void *colo_compare_thread(void *opaque)
worker_context = g_main_context_new(); worker_context = g_main_context_new();
qemu_chr_add_handlers_full(s->chr_pri_in, compare_chr_can_read, qemu_chr_add_handlers_full(s->chr_pri_in.chr, compare_chr_can_read,
compare_pri_chr_in, NULL, s, worker_context); compare_pri_chr_in, NULL, s, worker_context);
qemu_chr_add_handlers_full(s->chr_sec_in, compare_chr_can_read, qemu_chr_add_handlers_full(s->chr_sec_in.chr, compare_chr_can_read,
compare_sec_chr_in, NULL, s, worker_context); compare_sec_chr_in, NULL, s, worker_context);
compare_loop = g_main_loop_new(worker_context, FALSE); compare_loop = g_main_loop_new(worker_context, FALSE);
@ -545,7 +545,7 @@ static void compare_pri_rs_finalize(SocketReadState *pri_rs)
if (packet_enqueue(s, PRIMARY_IN)) { if (packet_enqueue(s, PRIMARY_IN)) {
trace_colo_compare_main("primary: unsupported packet in"); trace_colo_compare_main("primary: unsupported packet in");
compare_chr_send(s->chr_out, pri_rs->buf, pri_rs->packet_len); compare_chr_send(s->chr_out.chr, pri_rs->buf, pri_rs->packet_len);
} else { } else {
/* compare connection */ /* compare connection */
g_queue_foreach(&s->conn_list, colo_compare_connection, s); g_queue_foreach(&s->conn_list, colo_compare_connection, s);
@ -634,23 +634,23 @@ static void colo_compare_complete(UserCreatable *uc, Error **errp)
return; return;
} }
if (find_and_check_chardev(&s->chr_pri_in, s->pri_indev, errp)) { if (find_and_check_chardev(&s->chr_pri_in.chr, s->pri_indev, errp)) {
return; return;
} }
if (find_and_check_chardev(&s->chr_sec_in, s->sec_indev, errp)) { if (find_and_check_chardev(&s->chr_sec_in.chr, s->sec_indev, errp)) {
return; return;
} }
if (find_and_check_chardev(&s->chr_out, s->outdev, errp)) { if (find_and_check_chardev(&s->chr_out.chr, s->outdev, errp)) {
return; return;
} }
qemu_chr_fe_claim_no_fail(s->chr_pri_in); qemu_chr_fe_claim_no_fail(s->chr_pri_in.chr);
qemu_chr_fe_claim_no_fail(s->chr_sec_in); qemu_chr_fe_claim_no_fail(s->chr_sec_in.chr);
qemu_chr_fe_claim_no_fail(s->chr_out); qemu_chr_fe_claim_no_fail(s->chr_out.chr);
net_socket_rs_init(&s->pri_rs, compare_pri_rs_finalize); net_socket_rs_init(&s->pri_rs, compare_pri_rs_finalize);
net_socket_rs_init(&s->sec_rs, compare_sec_rs_finalize); net_socket_rs_init(&s->sec_rs, compare_sec_rs_finalize);
@ -702,16 +702,16 @@ static void colo_compare_finalize(Object *obj)
{ {
CompareState *s = COLO_COMPARE(obj); CompareState *s = COLO_COMPARE(obj);
if (s->chr_pri_in) { if (s->chr_pri_in.chr) {
qemu_chr_add_handlers(s->chr_pri_in, NULL, NULL, NULL, NULL); qemu_chr_add_handlers(s->chr_pri_in.chr, NULL, NULL, NULL, NULL);
qemu_chr_fe_release(s->chr_pri_in); qemu_chr_fe_release(s->chr_pri_in.chr);
} }
if (s->chr_sec_in) { if (s->chr_sec_in.chr) {
qemu_chr_add_handlers(s->chr_sec_in, NULL, NULL, NULL, NULL); qemu_chr_add_handlers(s->chr_sec_in.chr, NULL, NULL, NULL, NULL);
qemu_chr_fe_release(s->chr_sec_in); qemu_chr_fe_release(s->chr_sec_in.chr);
} }
if (s->chr_out) { if (s->chr_out.chr) {
qemu_chr_fe_release(s->chr_out); qemu_chr_fe_release(s->chr_out.chr);
} }
g_queue_free(&s->conn_list); g_queue_free(&s->conn_list);

58
net/filter-mirror.c
View File

@ -38,8 +38,8 @@ typedef struct MirrorState {
NetFilterState parent_obj; NetFilterState parent_obj;
char *indev; char *indev;
char *outdev; char *outdev;
CharDriverState *chr_in; CharBackend chr_in;
CharDriverState *chr_out; CharBackend chr_out;
SocketReadState rs; SocketReadState rs;
} MirrorState; } MirrorState;
@ -110,7 +110,7 @@ static void redirector_chr_read(void *opaque, const uint8_t *buf, int size)
ret = net_fill_rstate(&s->rs, buf, size); ret = net_fill_rstate(&s->rs, buf, size);
if (ret == -1) { if (ret == -1) {
qemu_chr_add_handlers(s->chr_in, NULL, NULL, NULL, NULL); qemu_chr_add_handlers(s->chr_in.chr, NULL, NULL, NULL, NULL);
} }
} }
@ -121,7 +121,7 @@ static void redirector_chr_event(void *opaque, int event)
switch (event) { switch (event) {
case CHR_EVENT_CLOSED: case CHR_EVENT_CLOSED:
qemu_chr_add_handlers(s->chr_in, NULL, NULL, NULL, NULL); qemu_chr_add_handlers(s->chr_in.chr, NULL, NULL, NULL, NULL);
break; break;
default: default:
break; break;
@ -138,7 +138,7 @@ static ssize_t filter_mirror_receive_iov(NetFilterState *nf,
MirrorState *s = FILTER_MIRROR(nf); MirrorState *s = FILTER_MIRROR(nf);
int ret; int ret;
ret = filter_mirror_send(s->chr_out, iov, iovcnt); ret = filter_mirror_send(s->chr_out.chr, iov, iovcnt);
if (ret) { if (ret) {
error_report("filter_mirror_send failed(%s)", strerror(-ret)); error_report("filter_mirror_send failed(%s)", strerror(-ret));
} }
@ -160,8 +160,8 @@ static ssize_t filter_redirector_receive_iov(NetFilterState *nf,
MirrorState *s = FILTER_REDIRECTOR(nf); MirrorState *s = FILTER_REDIRECTOR(nf);
int ret; int ret;
if (s->chr_out) { if (s->chr_out.chr) {
ret = filter_mirror_send(s->chr_out, iov, iovcnt); ret = filter_mirror_send(s->chr_out.chr, iov, iovcnt);
if (ret) { if (ret) {
error_report("filter_mirror_send failed(%s)", strerror(-ret)); error_report("filter_mirror_send failed(%s)", strerror(-ret));
} }
@ -175,8 +175,8 @@ static void filter_mirror_cleanup(NetFilterState *nf)
{ {
MirrorState *s = FILTER_MIRROR(nf); MirrorState *s = FILTER_MIRROR(nf);
if (s->chr_out) { if (s->chr_out.chr) {
qemu_chr_fe_release(s->chr_out); qemu_chr_fe_release(s->chr_out.chr);
} }
} }
@ -184,18 +184,19 @@ static void filter_redirector_cleanup(NetFilterState *nf)
{ {
MirrorState *s = FILTER_REDIRECTOR(nf); MirrorState *s = FILTER_REDIRECTOR(nf);
if (s->chr_in) { if (s->chr_in.chr) {
qemu_chr_add_handlers(s->chr_in, NULL, NULL, NULL, NULL); qemu_chr_add_handlers(s->chr_in.chr, NULL, NULL, NULL, NULL);
qemu_chr_fe_release(s->chr_in); qemu_chr_fe_release(s->chr_in.chr);
} }
if (s->chr_out) { if (s->chr_out.chr) {
qemu_chr_fe_release(s->chr_out); qemu_chr_fe_release(s->chr_out.chr);
} }
} }
static void filter_mirror_setup(NetFilterState *nf, Error **errp) static void filter_mirror_setup(NetFilterState *nf, Error **errp)
{ {
MirrorState *s = FILTER_MIRROR(nf); MirrorState *s = FILTER_MIRROR(nf);
CharDriverState *chr;
if (!s->outdev) { if (!s->outdev) {
error_setg(errp, "filter mirror needs 'outdev' " error_setg(errp, "filter mirror needs 'outdev' "
@ -203,17 +204,19 @@ static void filter_mirror_setup(NetFilterState *nf, Error **errp)
return; return;
} }
s->chr_out = qemu_chr_find(s->outdev); chr = qemu_chr_find(s->outdev);
if (s->chr_out == NULL) { if (chr == NULL) {
error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND, error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
"Device '%s' not found", s->outdev); "Device '%s' not found", s->outdev);
return; return;
} }
if (qemu_chr_fe_claim(s->chr_out) != 0) { if (qemu_chr_fe_claim(chr) != 0) {
error_setg(errp, QERR_DEVICE_IN_USE, s->outdev); error_setg(errp, QERR_DEVICE_IN_USE, s->outdev);
return; return;
} }
qemu_chr_fe_init(&s->chr_out, chr, errp);
} }
static void redirector_rs_finalize(SocketReadState *rs) static void redirector_rs_finalize(SocketReadState *rs)
@ -227,6 +230,7 @@ static void redirector_rs_finalize(SocketReadState *rs)
static void filter_redirector_setup(NetFilterState *nf, Error **errp) static void filter_redirector_setup(NetFilterState *nf, Error **errp)
{ {
MirrorState *s = FILTER_REDIRECTOR(nf); MirrorState *s = FILTER_REDIRECTOR(nf);
CharDriverState *chr;
if (!s->indev && !s->outdev) { if (!s->indev && !s->outdev) {
error_setg(errp, "filter redirector needs 'indev' or " error_setg(errp, "filter redirector needs 'indev' or "
@ -243,26 +247,32 @@ static void filter_redirector_setup(NetFilterState *nf, Error **errp)
net_socket_rs_init(&s->rs, redirector_rs_finalize); net_socket_rs_init(&s->rs, redirector_rs_finalize);
if (s->indev) { if (s->indev) {
s->chr_in = qemu_chr_find(s->indev); chr = qemu_chr_find(s->indev);
if (s->chr_in == NULL) { if (chr == NULL) {
error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND, error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
"IN Device '%s' not found", s->indev); "IN Device '%s' not found", s->indev);
return; return;
} }
qemu_chr_fe_claim_no_fail(s->chr_in); qemu_chr_fe_claim_no_fail(chr);
qemu_chr_add_handlers(s->chr_in, redirector_chr_can_read, if (!qemu_chr_fe_init(&s->chr_in, chr, errp)) {
return;
}
qemu_chr_add_handlers(s->chr_in.chr, redirector_chr_can_read,
redirector_chr_read, redirector_chr_event, nf); redirector_chr_read, redirector_chr_event, nf);
} }
if (s->outdev) { if (s->outdev) {
s->chr_out = qemu_chr_find(s->outdev); chr = qemu_chr_find(s->outdev);
if (s->chr_out == NULL) { if (chr == NULL) {
error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND, error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
"OUT Device '%s' not found", s->outdev); "OUT Device '%s' not found", s->outdev);
return; return;
} }
qemu_chr_fe_claim_no_fail(s->chr_out); qemu_chr_fe_claim_no_fail(chr);
if (!qemu_chr_fe_init(&s->chr_out, chr, errp)) {
return;
}
} }
} }

23
net/slirp.c
View File

@ -40,6 +40,7 @@
#include "sysemu/char.h" #include "sysemu/char.h"
#include "sysemu/sysemu.h" #include "sysemu/sysemu.h"
#include "qemu/cutils.h" #include "qemu/cutils.h"
#include "qapi/error.h"
static int get_str_sep(char *buf, int buf_size, const char **pp, int sep) static int get_str_sep(char *buf, int buf_size, const char **pp, int sep)
{ {
@ -682,7 +683,7 @@ int net_slirp_smb(const char *exported_dir)
#endif /* !defined(_WIN32) */ #endif /* !defined(_WIN32) */
struct GuestFwd { struct GuestFwd {
CharDriverState *hd; CharBackend hd;
struct in_addr server; struct in_addr server;
int port; int port;
Slirp *slirp; Slirp *slirp;
@ -746,15 +747,23 @@ static int slirp_guestfwd(SlirpState *s, const char *config_str,
return -1; return -1;
} }
} else { } else {
fwd = g_new(struct GuestFwd, 1); Error *err = NULL;
fwd->hd = qemu_chr_new(buf, p); CharDriverState *chr = qemu_chr_new(buf, p);
if (!fwd->hd) {
if (!chr) {
error_report("could not open guest forwarding device '%s'", buf); error_report("could not open guest forwarding device '%s'", buf);
return -1;
}
fwd = g_new(struct GuestFwd, 1);
qemu_chr_fe_init(&fwd->hd, chr, &err);
if (err) {
error_report_err(err);
g_free(fwd); g_free(fwd);
return -1; return -1;
} }
if (slirp_add_exec(s->slirp, 3, fwd->hd, &server, port) < 0) { if (slirp_add_exec(s->slirp, 3, fwd->hd.chr, &server, port) < 0) {
error_report("conflicting/invalid host:port in guest forwarding " error_report("conflicting/invalid host:port in guest forwarding "
"rule '%s'", config_str); "rule '%s'", config_str);
g_free(fwd); g_free(fwd);
@ -764,8 +773,8 @@ static int slirp_guestfwd(SlirpState *s, const char *config_str,
fwd->port = port; fwd->port = port;
fwd->slirp = s->slirp; fwd->slirp = s->slirp;
qemu_chr_fe_claim_no_fail(fwd->hd); qemu_chr_fe_claim_no_fail(fwd->hd.chr);
qemu_chr_add_handlers(fwd->hd, guestfwd_can_read, guestfwd_read, qemu_chr_add_handlers(fwd->hd.chr, guestfwd_can_read, guestfwd_read,
NULL, fwd); NULL, fwd);
} }
return 0; return 0;

27
net/vhost-user.c
View File

@ -20,7 +20,7 @@
typedef struct VhostUserState { typedef struct VhostUserState {
NetClientState nc; NetClientState nc;
CharDriverState *chr; CharBackend chr;
VHostNetState *vhost_net; VHostNetState *vhost_net;
guint watch; guint watch;
uint64_t acked_features; uint64_t acked_features;
@ -78,7 +78,7 @@ static int vhost_user_start(int queues, NetClientState *ncs[])
s = DO_UPCAST(VhostUserState, nc, ncs[i]); s = DO_UPCAST(VhostUserState, nc, ncs[i]);
options.net_backend = ncs[i]; options.net_backend = ncs[i];
options.opaque = s->chr; options.opaque = s->chr.chr;
options.busyloop_timeout = 0; options.busyloop_timeout = 0;
net = vhost_net_init(&options); net = vhost_net_init(&options);
if (!net) { if (!net) {
@ -150,10 +150,10 @@ static void vhost_user_cleanup(NetClientState *nc)
g_free(s->vhost_net); g_free(s->vhost_net);
s->vhost_net = NULL; s->vhost_net = NULL;
} }
if (s->chr) { if (s->chr.chr) {
qemu_chr_add_handlers(s->chr, NULL, NULL, NULL, NULL); qemu_chr_add_handlers(s->chr.chr, NULL, NULL, NULL, NULL);
qemu_chr_fe_release(s->chr); qemu_chr_fe_release(s->chr.chr);
s->chr = NULL; s->chr.chr = NULL;
} }
qemu_purge_queued_packets(nc); qemu_purge_queued_packets(nc);
@ -187,7 +187,7 @@ static gboolean net_vhost_user_watch(GIOChannel *chan, GIOCondition cond,
{ {
VhostUserState *s = opaque; VhostUserState *s = opaque;
qemu_chr_disconnect(s->chr); qemu_chr_disconnect(s->chr.chr);
return FALSE; return FALSE;
} }
@ -206,13 +206,13 @@ static void net_vhost_user_event(void *opaque, int event)
assert(queues < MAX_QUEUE_NUM); assert(queues < MAX_QUEUE_NUM);
s = DO_UPCAST(VhostUserState, nc, ncs[0]); s = DO_UPCAST(VhostUserState, nc, ncs[0]);
trace_vhost_user_event(s->chr->label, event); trace_vhost_user_event(s->chr.chr->label, event);
switch (event) { switch (event) {
case CHR_EVENT_OPENED: case CHR_EVENT_OPENED:
s->watch = qemu_chr_fe_add_watch(s->chr, G_IO_HUP, s->watch = qemu_chr_fe_add_watch(s->chr.chr, G_IO_HUP,
net_vhost_user_watch, s); net_vhost_user_watch, s);
if (vhost_user_start(queues, ncs) < 0) { if (vhost_user_start(queues, ncs) < 0) {
qemu_chr_disconnect(s->chr); qemu_chr_disconnect(s->chr.chr);
return; return;
} }
qmp_set_link(name, true, &err); qmp_set_link(name, true, &err);
@ -235,6 +235,7 @@ static int net_vhost_user_init(NetClientState *peer, const char *device,
const char *name, CharDriverState *chr, const char *name, CharDriverState *chr,
int queues) int queues)
{ {
Error *err = NULL;
NetClientState *nc, *nc0 = NULL; NetClientState *nc, *nc0 = NULL;
VhostUserState *s; VhostUserState *s;
int i; int i;
@ -254,12 +255,14 @@ static int net_vhost_user_init(NetClientState *peer, const char *device,
nc->queue_index = i; nc->queue_index = i;
s = DO_UPCAST(VhostUserState, nc, nc); s = DO_UPCAST(VhostUserState, nc, nc);
s->chr = chr; if (!qemu_chr_fe_init(&s->chr, chr, &err)) {
error_report_err(err);
return -1;
}
} }
s = DO_UPCAST(VhostUserState, nc, nc0); s = DO_UPCAST(VhostUserState, nc, nc0);
do { do {
Error *err = NULL;
if (qemu_chr_wait_connected(chr, &err) < 0) { if (qemu_chr_wait_connected(chr, &err) < 0) {
error_report_err(err); error_report_err(err);
return -1; return -1;

8
qtest.c
View File

@ -38,7 +38,7 @@ bool qtest_allowed;
static DeviceState *irq_intercept_dev; static DeviceState *irq_intercept_dev;
static FILE *qtest_log_fp; static FILE *qtest_log_fp;
static CharDriverState *qtest_chr; static CharBackend qtest_chr;
static GString *inbuf; static GString *inbuf;
static int irq_levels[MAX_IRQ]; static int irq_levels[MAX_IRQ];
static qemu_timeval start_time; static qemu_timeval start_time;
@ -249,7 +249,7 @@ static void qtest_irq_handler(void *opaque, int n, int level)
qemu_set_irq(old_irq, level); qemu_set_irq(old_irq, level);
if (irq_levels[n] != level) { if (irq_levels[n] != level) {
CharDriverState *chr = qtest_chr; CharDriverState *chr = qtest_chr.chr;
irq_levels[n] = level; irq_levels[n] = level;
qtest_send_prefix(chr); qtest_send_prefix(chr);
qtest_sendf(chr, "IRQ %s %d\n", qtest_sendf(chr, "IRQ %s %d\n",
@ -690,12 +690,12 @@ void qtest_init(const char *qtest_chrdev, const char *qtest_log, Error **errp)
qemu_chr_fe_set_echo(chr, true); qemu_chr_fe_set_echo(chr, true);
inbuf = g_string_new(""); inbuf = g_string_new("");
qtest_chr = chr; qemu_chr_fe_init(&qtest_chr, chr, errp);
} }
bool qtest_driver(void) bool qtest_driver(void)
{ {
return qtest_chr; return qtest_chr.chr != NULL;
} }
static void qtest_accel_class_init(ObjectClass *oc, void *data) static void qtest_accel_class_init(ObjectClass *oc, void *data)

39
tests/vhost-user-test.c
View File

@ -19,6 +19,7 @@
#include "libqos/libqos.h" #include "libqos/libqos.h"
#include "libqos/pci-pc.h" #include "libqos/pci-pc.h"
#include "libqos/virtio-pci.h" #include "libqos/virtio-pci.h"
#include "qapi/error.h"
#include "libqos/pci-pc.h" #include "libqos/pci-pc.h"
#include "libqos/virtio-pci.h" #include "libqos/virtio-pci.h"
@ -141,7 +142,7 @@ typedef struct TestServer {
gchar *socket_path; gchar *socket_path;
gchar *mig_path; gchar *mig_path;
gchar *chr_name; gchar *chr_name;
CharDriverState *chr; CharBackend chr;
int fds_num; int fds_num;
int fds[VHOST_MEMORY_MAX_NREGIONS]; int fds[VHOST_MEMORY_MAX_NREGIONS];
VhostUserMemory memory; VhostUserMemory memory;
@ -261,13 +262,13 @@ static int chr_can_read(void *opaque)
static void chr_read(void *opaque, const uint8_t *buf, int size) static void chr_read(void *opaque, const uint8_t *buf, int size)
{ {
TestServer *s = opaque; TestServer *s = opaque;
CharDriverState *chr = s->chr; CharBackend *chr = &s->chr;
VhostUserMsg msg; VhostUserMsg msg;
uint8_t *p = (uint8_t *) &msg; uint8_t *p = (uint8_t *) &msg;
int fd; int fd;
if (s->test_fail) { if (s->test_fail) {
qemu_chr_disconnect(chr); qemu_chr_disconnect(chr->chr);
/* now switch to non-failure */ /* now switch to non-failure */
s->test_fail = false; s->test_fail = false;
} }
@ -282,7 +283,7 @@ static void chr_read(void *opaque, const uint8_t *buf, int size)
if (msg.size) { if (msg.size) {
p += VHOST_USER_HDR_SIZE; p += VHOST_USER_HDR_SIZE;
size = qemu_chr_fe_read_all(chr, p, msg.size); size = qemu_chr_fe_read_all(chr->chr, p, msg.size);
if (size != msg.size) { if (size != msg.size) {
g_test_message("Wrong message size received %d != %d\n", g_test_message("Wrong message size received %d != %d\n",
size, msg.size); size, msg.size);
@ -305,14 +306,14 @@ static void chr_read(void *opaque, const uint8_t *buf, int size)
s->test_flags = TEST_FLAGS_END; s->test_flags = TEST_FLAGS_END;
} }
p = (uint8_t *) &msg; p = (uint8_t *) &msg;
qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE + msg.size); qemu_chr_fe_write_all(chr->chr, p, VHOST_USER_HDR_SIZE + msg.size);
break; break;
case VHOST_USER_SET_FEATURES: case VHOST_USER_SET_FEATURES:
g_assert_cmpint(msg.payload.u64 & (0x1ULL << VHOST_USER_F_PROTOCOL_FEATURES), g_assert_cmpint(msg.payload.u64 & (0x1ULL << VHOST_USER_F_PROTOCOL_FEATURES),
!=, 0ULL); !=, 0ULL);
if (s->test_flags == TEST_FLAGS_DISCONNECT) { if (s->test_flags == TEST_FLAGS_DISCONNECT) {
qemu_chr_disconnect(chr); qemu_chr_disconnect(chr->chr);
s->test_flags = TEST_FLAGS_BAD; s->test_flags = TEST_FLAGS_BAD;
} }
break; break;
@ -326,7 +327,7 @@ static void chr_read(void *opaque, const uint8_t *buf, int size)
msg.payload.u64 |= 1 << VHOST_USER_PROTOCOL_F_MQ; msg.payload.u64 |= 1 << VHOST_USER_PROTOCOL_F_MQ;
} }
p = (uint8_t *) &msg; p = (uint8_t *) &msg;
qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE + msg.size); qemu_chr_fe_write_all(chr->chr, p, VHOST_USER_HDR_SIZE + msg.size);
break; break;
case VHOST_USER_GET_VRING_BASE: case VHOST_USER_GET_VRING_BASE:
@ -335,7 +336,7 @@ static void chr_read(void *opaque, const uint8_t *buf, int size)
msg.size = sizeof(m.payload.state); msg.size = sizeof(m.payload.state);
msg.payload.state.num = 0; msg.payload.state.num = 0;
p = (uint8_t *) &msg; p = (uint8_t *) &msg;
qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE + msg.size); qemu_chr_fe_write_all(chr->chr, p, VHOST_USER_HDR_SIZE + msg.size);
assert(msg.payload.state.index < s->queues * 2); assert(msg.payload.state.index < s->queues * 2);
s->rings &= ~(0x1ULL << msg.payload.state.index); s->rings &= ~(0x1ULL << msg.payload.state.index);
@ -344,7 +345,8 @@ static void chr_read(void *opaque, const uint8_t *buf, int size)
case VHOST_USER_SET_MEM_TABLE: case VHOST_USER_SET_MEM_TABLE:
/* received the mem table */ /* received the mem table */
memcpy(&s->memory, &msg.payload.memory, sizeof(msg.payload.memory)); memcpy(&s->memory, &msg.payload.memory, sizeof(msg.payload.memory));
s->fds_num = qemu_chr_fe_get_msgfds(chr, s->fds, G_N_ELEMENTS(s->fds)); s->fds_num = qemu_chr_fe_get_msgfds(chr->chr, s->fds,
G_N_ELEMENTS(s->fds));
/* signal the test that it can continue */ /* signal the test that it can continue */
g_cond_signal(&s->data_cond); g_cond_signal(&s->data_cond);
@ -353,7 +355,7 @@ static void chr_read(void *opaque, const uint8_t *buf, int size)
case VHOST_USER_SET_VRING_KICK: case VHOST_USER_SET_VRING_KICK:
case VHOST_USER_SET_VRING_CALL: case VHOST_USER_SET_VRING_CALL:
/* consume the fd */ /* consume the fd */
qemu_chr_fe_get_msgfds(chr, &fd, 1); qemu_chr_fe_get_msgfds(chr->chr, &fd, 1);
/* /*
* This is a non-blocking eventfd. * This is a non-blocking eventfd.
* The receive function forces it to be blocking, * The receive function forces it to be blocking,
@ -367,11 +369,11 @@ static void chr_read(void *opaque, const uint8_t *buf, int size)
close(s->log_fd); close(s->log_fd);
s->log_fd = -1; s->log_fd = -1;
} }
qemu_chr_fe_get_msgfds(chr, &s->log_fd, 1); qemu_chr_fe_get_msgfds(chr->chr, &s->log_fd, 1);
msg.flags |= VHOST_USER_REPLY_MASK; msg.flags |= VHOST_USER_REPLY_MASK;
msg.size = 0; msg.size = 0;
p = (uint8_t *) &msg; p = (uint8_t *) &msg;
qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE); qemu_chr_fe_write_all(chr->chr, p, VHOST_USER_HDR_SIZE);
g_cond_signal(&s->data_cond); g_cond_signal(&s->data_cond);
break; break;
@ -386,7 +388,7 @@ static void chr_read(void *opaque, const uint8_t *buf, int size)
msg.size = sizeof(m.payload.u64); msg.size = sizeof(m.payload.u64);
msg.payload.u64 = s->queues; msg.payload.u64 = s->queues;
p = (uint8_t *) &msg; p = (uint8_t *) &msg;
qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE + msg.size); qemu_chr_fe_write_all(chr->chr, p, VHOST_USER_HDR_SIZE + msg.size);
break; break;
default: default:
@ -453,12 +455,13 @@ static void chr_event(void *opaque, int event)
static void test_server_create_chr(TestServer *server, const gchar *opt) static void test_server_create_chr(TestServer *server, const gchar *opt)
{ {
gchar *chr_path; gchar *chr_path;
CharDriverState *chr;
chr_path = g_strdup_printf("unix:%s%s", server->socket_path, opt); chr_path = g_strdup_printf("unix:%s%s", server->socket_path, opt);
server->chr = qemu_chr_new(server->chr_name, chr_path); chr = qemu_chr_new(server->chr_name, chr_path);
qemu_chr_fe_init(&server->chr, chr, &error_abort);
g_free(chr_path); g_free(chr_path);
qemu_chr_add_handlers(server->chr, chr_can_read, chr_read, qemu_chr_add_handlers(server->chr.chr, chr_can_read, chr_read,
chr_event, server); chr_event, server);
} }
@ -484,7 +487,7 @@ static gboolean _test_server_free(TestServer *server)
{ {
int i; int i;
qemu_chr_delete(server->chr); qemu_chr_delete(server->chr.chr);
for (i = 0; i < server->fds_num; i++) { for (i = 0; i < server->fds_num; i++) {
close(server->fds[i]); close(server->fds[i]);
@ -721,7 +724,7 @@ reconnect_cb(gpointer user_data)
{ {
TestServer *s = user_data; TestServer *s = user_data;
qemu_chr_disconnect(s->chr); qemu_chr_disconnect(s->chr.chr);
return FALSE; return FALSE;
} }