CryptoDevBackend parent_obj;
VhostUserState vhost_user;
- CharBackend chr;
+ CharFrontend chr;
char *chr_name;
bool opened;
CryptoDevBackendVhost *vhost_crypto[MAX_CRYPTO_QUEUE_NUM];
struct RngEgd {
RngBackend parent;
- CharBackend chr;
+ CharFrontend chr;
char *chr_name;
};
TPMBackend parent;
TPMEmulatorOptions *options;
- CharBackend ctrl_chr;
+ CharFrontend ctrl_chr;
QIOChannel *data_ioc;
TPMVersion tpm_version;
uint32_t caps; /* capabilities of the TPM */
size_t msg_len_in, size_t msg_len_out_err,
size_t msg_len_out_total)
{
- CharBackend *dev = &tpm->ctrl_chr;
+ CharFrontend *dev = &tpm->ctrl_chr;
uint32_t cmd_no = cpu_to_be32(cmd);
ssize_t n = sizeof(uint32_t) + msg_len_in;
ptm_res res;
#include "chardev/char-io.h"
#include "chardev-internal.h"
-int qemu_chr_fe_write(CharBackend *be, const uint8_t *buf, int len)
+int qemu_chr_fe_write(CharFrontend *c, const uint8_t *buf, int len)
{
- Chardev *s = be->chr;
+ Chardev *s = c->chr;
if (!s) {
return 0;
return qemu_chr_write(s, buf, len, false);
}
-int qemu_chr_fe_write_all(CharBackend *be, const uint8_t *buf, int len)
+int qemu_chr_fe_write_all(CharFrontend *c, const uint8_t *buf, int len)
{
- Chardev *s = be->chr;
+ Chardev *s = c->chr;
if (!s) {
return 0;
return qemu_chr_write(s, buf, len, true);
}
-int qemu_chr_fe_read_all(CharBackend *be, uint8_t *buf, int len)
+int qemu_chr_fe_read_all(CharFrontend *c, uint8_t *buf, int len)
{
- Chardev *s = be->chr;
+ Chardev *s = c->chr;
int offset = 0;
int res;
return offset;
}
-int qemu_chr_fe_ioctl(CharBackend *be, int cmd, void *arg)
+int qemu_chr_fe_ioctl(CharFrontend *c, int cmd, void *arg)
{
- Chardev *s = be->chr;
+ Chardev *s = c->chr;
int res;
if (!s || !CHARDEV_GET_CLASS(s)->chr_ioctl || qemu_chr_replay(s)) {
return res;
}
-int qemu_chr_fe_get_msgfd(CharBackend *be)
+int qemu_chr_fe_get_msgfd(CharFrontend *c)
{
- Chardev *s = be->chr;
+ Chardev *s = c->chr;
int fd;
- int res = (qemu_chr_fe_get_msgfds(be, &fd, 1) == 1) ? fd : -1;
+ int res = (qemu_chr_fe_get_msgfds(c, &fd, 1) == 1) ? fd : -1;
if (s && qemu_chr_replay(s)) {
error_report("Replay: get msgfd is not supported "
"for serial devices yet");
return res;
}
-int qemu_chr_fe_get_msgfds(CharBackend *be, int *fds, int len)
+int qemu_chr_fe_get_msgfds(CharFrontend *c, int *fds, int len)
{
- Chardev *s = be->chr;
+ Chardev *s = c->chr;
if (!s) {
return -1;
CHARDEV_GET_CLASS(s)->get_msgfds(s, fds, len) : -1;
}
-int qemu_chr_fe_set_msgfds(CharBackend *be, int *fds, int num)
+int qemu_chr_fe_set_msgfds(CharFrontend *c, int *fds, int num)
{
- Chardev *s = be->chr;
+ Chardev *s = c->chr;
if (!s) {
return -1;
CHARDEV_GET_CLASS(s)->set_msgfds(s, fds, num) : -1;
}
-void qemu_chr_fe_accept_input(CharBackend *be)
+void qemu_chr_fe_accept_input(CharFrontend *c)
{
- Chardev *s = be->chr;
+ Chardev *s = c->chr;
if (!s) {
return;
qemu_notify_event();
}
-void qemu_chr_fe_printf(CharBackend *be, const char *fmt, ...)
+void qemu_chr_fe_printf(CharFrontend *c, const char *fmt, ...)
{
char buf[CHR_READ_BUF_LEN];
va_list ap;
vsnprintf(buf, sizeof(buf), fmt, ap);
/* XXX this blocks entire thread. Rewrite to use
* qemu_chr_fe_write and background I/O callbacks */
- qemu_chr_fe_write_all(be, (uint8_t *)buf, strlen(buf));
+ qemu_chr_fe_write_all(c, (uint8_t *)buf, strlen(buf));
va_end(ap);
}
-Chardev *qemu_chr_fe_get_driver(CharBackend *be)
+Chardev *qemu_chr_fe_get_driver(CharFrontend *c)
{
/* this is unsafe for the users that support chardev hotswap */
- assert(be->chr_be_change == NULL);
- return be->chr;
+ assert(c->chr_be_change == NULL);
+ return c->chr;
}
-bool qemu_chr_fe_backend_connected(CharBackend *be)
+bool qemu_chr_fe_backend_connected(CharFrontend *c)
{
- return !!be->chr;
+ return !!c->chr;
}
-bool qemu_chr_fe_backend_open(CharBackend *be)
+bool qemu_chr_fe_backend_open(CharFrontend *c)
{
- return be->chr && be->chr->be_open;
+ return c->chr && c->chr->be_open;
}
-bool qemu_chr_fe_init(CharBackend *b, Chardev *s, Error **errp)
+bool qemu_chr_fe_init(CharFrontend *c, Chardev *s, Error **errp)
{
unsigned int tag = 0;
if (CHARDEV_IS_MUX(s)) {
MuxChardev *d = MUX_CHARDEV(s);
- if (!mux_chr_attach_frontend(d, b, &tag, errp)) {
+ if (!mux_chr_attach_frontend(d, c, &tag, errp)) {
return false;
}
- } else if (s->be) {
+ } else if (s->fe) {
error_setg(errp, "chardev '%s' is already in use", s->label);
return false;
} else {
- s->be = b;
+ s->fe = c;
}
}
- b->fe_is_open = false;
- b->tag = tag;
- b->chr = s;
+ c->fe_is_open = false;
+ c->tag = tag;
+ c->chr = s;
return true;
}
-void qemu_chr_fe_deinit(CharBackend *b, bool del)
+void qemu_chr_fe_deinit(CharFrontend *c, bool del)
{
- assert(b);
+ assert(c);
- if (b->chr) {
- qemu_chr_fe_set_handlers(b, NULL, NULL, NULL, NULL, NULL, NULL, true);
- if (b->chr->be == b) {
- b->chr->be = NULL;
+ if (c->chr) {
+ qemu_chr_fe_set_handlers(c, NULL, NULL, NULL, NULL, NULL, NULL, true);
+ if (c->chr->fe == c) {
+ c->chr->fe = NULL;
}
- if (CHARDEV_IS_MUX(b->chr)) {
- MuxChardev *d = MUX_CHARDEV(b->chr);
- mux_chr_detach_frontend(d, b->tag);
+ if (CHARDEV_IS_MUX(c->chr)) {
+ MuxChardev *d = MUX_CHARDEV(c->chr);
+ mux_chr_detach_frontend(d, c->tag);
}
if (del) {
- Object *obj = OBJECT(b->chr);
+ Object *obj = OBJECT(c->chr);
if (obj->parent) {
object_unparent(obj);
} else {
object_unref(obj);
}
}
- b->chr = NULL;
+ c->chr = NULL;
}
}
-void qemu_chr_fe_set_handlers_full(CharBackend *b,
+void qemu_chr_fe_set_handlers_full(CharFrontend *c,
IOCanReadHandler *fd_can_read,
IOReadHandler *fd_read,
IOEventHandler *fd_event,
Chardev *s;
bool fe_open;
- s = b->chr;
+ s = c->chr;
if (!s) {
return;
}
} else {
fe_open = true;
}
- b->chr_can_read = fd_can_read;
- b->chr_read = fd_read;
- b->chr_event = fd_event;
- b->chr_be_change = be_change;
- b->opaque = opaque;
+ c->chr_can_read = fd_can_read;
+ c->chr_read = fd_read;
+ c->chr_event = fd_event;
+ c->chr_be_change = be_change;
+ c->opaque = opaque;
qemu_chr_be_update_read_handlers(s, context);
if (set_open) {
- qemu_chr_fe_set_open(b, fe_open);
+ qemu_chr_fe_set_open(c, fe_open);
}
if (fe_open) {
- qemu_chr_fe_take_focus(b);
+ qemu_chr_fe_take_focus(c);
/* We're connecting to an already opened device, so let's make sure we
also get the open event */
if (sync_state && s->be_open) {
}
}
-void qemu_chr_fe_set_handlers(CharBackend *b,
+void qemu_chr_fe_set_handlers(CharFrontend *c,
IOCanReadHandler *fd_can_read,
IOReadHandler *fd_read,
IOEventHandler *fd_event,
GMainContext *context,
bool set_open)
{
- qemu_chr_fe_set_handlers_full(b, fd_can_read, fd_read, fd_event, be_change,
+ qemu_chr_fe_set_handlers_full(c, fd_can_read, fd_read, fd_event, be_change,
opaque, context, set_open,
true);
}
-void qemu_chr_fe_take_focus(CharBackend *b)
+void qemu_chr_fe_take_focus(CharFrontend *c)
{
- if (!b->chr) {
+ if (!c->chr) {
return;
}
- if (CHARDEV_IS_MUX(b->chr)) {
- mux_set_focus(b->chr, b->tag);
+ if (CHARDEV_IS_MUX(c->chr)) {
+ mux_set_focus(c->chr, c->tag);
}
}
-int qemu_chr_fe_wait_connected(CharBackend *be, Error **errp)
+int qemu_chr_fe_wait_connected(CharFrontend *c, Error **errp)
{
- if (!be->chr) {
+ if (!c->chr) {
error_setg(errp, "missing associated backend");
return -1;
}
- return qemu_chr_wait_connected(be->chr, errp);
+ return qemu_chr_wait_connected(c->chr, errp);
}
-void qemu_chr_fe_set_echo(CharBackend *be, bool echo)
+void qemu_chr_fe_set_echo(CharFrontend *c, bool echo)
{
- Chardev *chr = be->chr;
+ Chardev *chr = c->chr;
if (chr && CHARDEV_GET_CLASS(chr)->chr_set_echo) {
CHARDEV_GET_CLASS(chr)->chr_set_echo(chr, echo);
}
}
-void qemu_chr_fe_set_open(CharBackend *be, bool is_open)
+void qemu_chr_fe_set_open(CharFrontend *c, bool is_open)
{
- Chardev *chr = be->chr;
+ Chardev *chr = c->chr;
if (!chr) {
return;
}
- if (be->fe_is_open == is_open) {
+ if (c->fe_is_open == is_open) {
return;
}
- be->fe_is_open = is_open;
+ c->fe_is_open = is_open;
if (CHARDEV_GET_CLASS(chr)->chr_set_fe_open) {
CHARDEV_GET_CLASS(chr)->chr_set_fe_open(chr, is_open);
}
}
-guint qemu_chr_fe_add_watch(CharBackend *be, GIOCondition cond,
+guint qemu_chr_fe_add_watch(CharFrontend *c, GIOCondition cond,
FEWatchFunc func, void *user_data)
{
- Chardev *s = be->chr;
+ Chardev *s = c->chr;
GSource *src;
guint tag;
return tag;
}
-void qemu_chr_fe_disconnect(CharBackend *be)
+void qemu_chr_fe_disconnect(CharFrontend *c)
{
- Chardev *chr = be->chr;
+ Chardev *chr = c->chr;
if (chr && CHARDEV_GET_CLASS(chr)->chr_disconnect) {
CHARDEV_GET_CLASS(chr)->chr_disconnect(chr);
d->be_eagain_ind = -1;
for (i = 0; i < d->be_cnt; i++) {
- if (!d->backends[i].be.chr->be_open) {
+ if (!d->backends[i].fe.chr->be_open) {
/* Skip closed backend */
continue;
}
ret = MIN(written, ret);
continue;
}
- r = qemu_chr_fe_write(&d->backends[i].be, buf, len);
+ r = qemu_chr_fe_write(&d->backends[i].fe, buf, len);
if (r < 0) {
if (errno == EAGAIN) {
/* Set index and expect to be called soon on watch wake up */
static int hub_chr_can_read(void *opaque)
{
HubCharBackend *backend = opaque;
- CharBackend *fe = backend->hub->parent.be;
+ CharFrontend *fe = backend->hub->parent.fe;
if (fe && fe->chr_can_read) {
return fe->chr_can_read(fe->opaque);
static void hub_chr_read(void *opaque, const uint8_t *buf, int size)
{
HubCharBackend *backend = opaque;
- CharBackend *fe = backend->hub->parent.be;
+ CharFrontend *fe = backend->hub->parent.fe;
if (fe && fe->chr_read) {
fe->chr_read(fe->opaque, buf, size);
{
HubCharBackend *backend = opaque;
HubChardev *d = backend->hub;
- CharBackend *fe = d->parent.be;
+ CharFrontend *fe = d->parent.fe;
if (event == CHR_EVENT_OPENED) {
/*
}
assert(d->be_eagain_ind < d->be_cnt);
- chr = qemu_chr_fe_get_driver(&d->backends[d->be_eagain_ind].be);
+ chr = qemu_chr_fe_get_driver(&d->backends[d->be_eagain_ind].fe);
cc = CHARDEV_GET_CLASS(chr);
if (!cc->chr_add_watch) {
return NULL;
d->parent.label);
return false;
}
- ret = qemu_chr_fe_init(&d->backends[d->be_cnt].be, chr, errp);
+ ret = qemu_chr_fe_init(&d->backends[d->be_cnt].fe, chr, errp);
if (ret) {
d->backends[d->be_cnt].hub = d;
d->backends[d->be_cnt].be_ind = d->be_cnt;
int i;
for (i = 0; i < d->be_cnt; i++) {
- qemu_chr_fe_deinit(&d->backends[i].be, false);
+ qemu_chr_fe_deinit(&d->backends[i].fe, false);
}
}
int i;
for (i = 0; i < d->be_cnt; i++) {
- qemu_chr_fe_set_handlers_full(&d->backends[i].be,
+ qemu_chr_fe_set_handlers_full(&d->backends[i].fe,
hub_chr_can_read,
hub_chr_read,
hub_chr_event,
static void mux_chr_send_event(MuxChardev *d, unsigned int mux_nr,
QEMUChrEvent event)
{
- CharBackend *be = d->backends[mux_nr];
+ CharFrontend *fe = d->frontends[mux_nr];
- if (be && be->chr_event) {
- be->chr_event(be->opaque, event);
+ if (fe && fe->chr_event) {
+ fe->chr_event(fe->opaque, event);
}
}
{
MuxChardev *d = MUX_CHARDEV(chr);
int m = d->focus;
- CharBackend *be = d->backends[m];
+ CharFrontend *fe = d->frontends[m];
- while (be && d->prod[m] != d->cons[m] &&
- be->chr_can_read && be->chr_can_read(be->opaque)) {
- be->chr_read(be->opaque,
+ while (fe && d->prod[m] != d->cons[m] &&
+ fe->chr_can_read && fe->chr_can_read(fe->opaque)) {
+ fe->chr_read(fe->opaque,
&d->buffer[m][d->cons[m]++ & MUX_BUFFER_MASK], 1);
}
}
{
MuxChardev *d = MUX_CHARDEV(opaque);
int m = d->focus;
- CharBackend *be = d->backends[m];
+ CharFrontend *fe = d->frontends[m];
if ((d->prod[m] - d->cons[m]) < MUX_BUFFER_SIZE) {
return 1;
}
- if (be && be->chr_can_read) {
- return be->chr_can_read(be->opaque);
+ if (fe && fe->chr_can_read) {
+ return fe->chr_can_read(fe->opaque);
}
return 0;
Chardev *chr = CHARDEV(opaque);
MuxChardev *d = MUX_CHARDEV(opaque);
int m = d->focus;
- CharBackend *be = d->backends[m];
+ CharFrontend *fe = d->frontends[m];
int i;
mux_chr_accept_input(opaque);
for (i = 0; i < size; i++)
if (mux_proc_byte(chr, d, buf[i])) {
if (d->prod[m] == d->cons[m] &&
- be && be->chr_can_read &&
- be->chr_can_read(be->opaque)) {
- be->chr_read(be->opaque, &buf[i], 1);
+ fe && fe->chr_can_read &&
+ fe->chr_can_read(fe->opaque)) {
+ fe->chr_read(fe->opaque, &buf[i], 1);
} else {
d->buffer[m][d->prod[m]++ & MUX_BUFFER_MASK] = buf[i];
}
bit = -1;
while ((bit = find_next_bit(&d->mux_bitset, MAX_MUX, bit + 1)) < MAX_MUX) {
- CharBackend *be = d->backends[bit];
+ CharFrontend *be = d->frontends[bit];
be->chr = NULL;
- d->backends[bit] = NULL;
+ d->frontends[bit] = NULL;
}
d->mux_bitset = 0;
qemu_chr_fe_deinit(&d->chr, false);
chr->gcontext, true, false);
}
-bool mux_chr_attach_frontend(MuxChardev *d, CharBackend *b,
+bool mux_chr_attach_frontend(MuxChardev *d, CharFrontend *c,
unsigned int *tag, Error **errp)
{
unsigned int bit;
}
d->mux_bitset |= (1ul << bit);
- d->backends[bit] = b;
+ d->frontends[bit] = c;
*tag = bit;
return true;
}
d->mux_bitset &= ~(1ul << tag);
- d->backends[tag] = NULL;
+ d->frontends[tag] = NULL;
return true;
}
}
d->focus = focus;
- chr->be = d->backends[focus];
+ chr->fe = d->frontends[focus];
mux_chr_send_event(d, d->focus, CHR_EVENT_MUX_IN);
}
static void chr_be_event(Chardev *s, QEMUChrEvent event)
{
- CharBackend *be = s->be;
+ CharFrontend *fe = s->fe;
- if (!be || !be->chr_event) {
+ if (!fe || !fe->chr_event) {
return;
}
- be->chr_event(be->opaque, event);
+ fe->chr_event(fe->opaque, event);
}
void qemu_chr_be_event(Chardev *s, QEMUChrEvent event)
int qemu_chr_be_can_write(Chardev *s)
{
- CharBackend *be = s->be;
+ CharFrontend *fe = s->fe;
- if (!be || !be->chr_can_read) {
+ if (!fe || !fe->chr_can_read) {
return 0;
}
- return be->chr_can_read(be->opaque);
+ return fe->chr_can_read(fe->opaque);
}
void qemu_chr_be_write_impl(Chardev *s, const uint8_t *buf, int len)
{
- CharBackend *be = s->be;
+ CharFrontend *fe = s->fe;
- if (be && be->chr_read) {
- be->chr_read(be->opaque, buf, len);
+ if (fe && fe->chr_read) {
+ fe->chr_read(fe->opaque, buf, len);
}
}
{
Chardev *chr = CHARDEV(obj);
- if (chr->be) {
- chr->be->chr = NULL;
+ if (chr->fe) {
+ chr->fe->chr = NULL;
}
g_free(chr->filename);
g_free(chr->label);
MuxChardev *d = MUX_CHARDEV(s);
return d->mux_bitset != 0;
} else {
- return s->be != NULL;
+ return s->fe != NULL;
}
}
value->label = g_strdup(chr->label);
value->filename = g_strdup(chr->filename);
- value->frontend_open = chr->be && chr->be->fe_is_open;
+ value->frontend_open = chr->fe && chr->fe->fe_is_open;
QAPI_LIST_PREPEND(*list, value);
ChardevReturn *qmp_chardev_change(const char *id, ChardevBackend *backend,
Error **errp)
{
- CharBackend *be;
+ CharFrontend *fe;
const ChardevClass *cc, *cc_new;
Chardev *chr, *chr_new;
bool closed_sent = false;
return NULL;
}
- be = chr->be;
- if (!be) {
+ fe = chr->fe;
+ if (!fe) {
/* easy case */
object_unparent(OBJECT(chr));
return qmp_chardev_add(id, backend, errp);
}
- if (!be->chr_be_change) {
+ if (!fe->chr_be_change) {
error_setg(errp, "Chardev user does not support chardev hotswap");
return NULL;
}
closed_sent = true;
}
- chr->be = NULL;
- qemu_chr_fe_init(be, chr_new, &error_abort);
+ chr->fe = NULL;
+ qemu_chr_fe_init(fe, chr_new, &error_abort);
- if (be->chr_be_change(be->opaque) < 0) {
+ if (fe->chr_be_change(fe->opaque) < 0) {
error_setg(errp, "Chardev '%s' change failed", chr_new->label);
- chr_new->be = NULL;
- qemu_chr_fe_init(be, chr, &error_abort);
+ chr_new->fe = NULL;
+ qemu_chr_fe_init(fe, chr, &error_abort);
if (closed_sent) {
qemu_chr_be_event(chr, CHR_EVENT_OPENED);
}
struct MuxChardev {
Chardev parent;
/* Linked frontends */
- CharBackend *backends[MAX_MUX];
- /* Linked backend */
- CharBackend chr;
+ CharFrontend *frontends[MAX_MUX];
+ /* frontend of the underlying muxed chardev */
+ CharFrontend chr;
unsigned long mux_bitset;
int focus;
bool term_got_escape;
* `hub->backends` array
*/
struct HubCharBackend {
- HubChardev *hub;
- CharBackend be;
+ HubChardev *hub;
+ CharFrontend fe;
unsigned int be_ind;
};
#define CHARDEV_IS_HUB(chr) \
object_dynamic_cast(OBJECT(chr), TYPE_CHARDEV_HUB)
-bool mux_chr_attach_frontend(MuxChardev *d, CharBackend *b,
+bool mux_chr_attach_frontend(MuxChardev *d, CharFrontend *c,
unsigned int *tag, Error **errp);
bool mux_chr_detach_frontend(MuxChardev *d, unsigned int tag);
void mux_set_focus(Chardev *chr, unsigned int focus);
/* System emulation specific state */
typedef struct {
- CharBackend chr;
+ CharFrontend chr;
Chardev *mon_chr;
} GDBSystemState;
SysBusDevice parent_obj;
MemoryRegion iomem;
- CharBackend chr;
+ CharFrontend chr;
qemu_irq irq;
uint8_t utcr0;
typedef struct DebugconState {
MemoryRegion io;
- CharBackend chr;
+ CharFrontend chr;
uint32_t readback;
} DebugconState;
QEMUTimer *fifo_timeout_timer;
uint64_t wordtime; /* word time in ns */
- CharBackend chr;
+ CharFrontend chr;
qemu_irq irq;
qemu_irq dmairq;
MemoryRegion iomem;
qemu_irq irq;
- CharBackend chr;
+ CharFrontend chr;
/* registers */
uint32_t status;
struct SCC2698Channel {
IPOctalState *ipoctal;
- CharBackend dev;
+ CharFrontend dev;
bool rx_enabled;
uint8_t mr[2];
uint8_t mr_idx;
int tx_enabled;
int rx_enabled;
qemu_irq irq;
- CharBackend chr;
+ CharFrontend chr;
};
#define TYPE_MCF_UART "mcf-uart"
struct SCLPConsoleLM {
SCLPEvent event;
- CharBackend chr;
+ CharFrontend chr;
bool echo; /* immediate echo of input if true */
uint32_t write_errors; /* errors writing to char layer */
uint32_t length; /* length of byte stream in buffer */
struct SCLPConsole {
SCLPEvent event;
- CharBackend chr;
+ CharFrontend chr;
uint8_t iov[SIZE_BUFFER_VT220];
uint32_t iov_sclp; /* offset in buf for SCLP read operation */
uint32_t iov_bs; /* offset in buf for char layer read operation */
int flags;
int rtrg;
- CharBackend chr;
+ CharFrontend chr;
QEMUTimer fifo_timeout_timer;
uint64_t etu; /* Elementary Time Unit (ns) */
struct SpaprVioVty {
SpaprVioDevice sdev;
- CharBackend chardev;
+ CharFrontend chardev;
uint32_t in, out;
uint8_t buf[VTERM_BUFSIZE];
};
struct Terminal3270 {
EmulatedCcw3270Device cdev;
- CharBackend chr;
+ CharFrontend chr;
uint8_t inv[INPUT_BUFFER_SIZE];
uint8_t outv[OUTPUT_BUFFER_SIZE];
int in_len;
struct VirtConsole {
VirtIOSerialPort parent_obj;
- CharBackend chr;
+ CharFrontend chr;
guint watch;
};
char *fe_path;
unsigned int ring_ref;
void *sring;
- CharBackend chr;
+ CharFrontend chr;
int backlog;
};
typedef struct XenConsole XenConsole;
EndianMode model_endianness;
MemoryRegion mmio;
- CharBackend chr;
+ CharFrontend chr;
qemu_irq irq;
uint8_t rx_fifo[8];
static void get_chr(Object *obj, Visitor *v, const char *name, void *opaque,
Error **errp)
{
- CharBackend *be = object_field_prop_ptr(obj, opaque);
+ CharFrontend *fe = object_field_prop_ptr(obj, opaque);
char *p;
- p = g_strdup(be->chr && be->chr->label ? be->chr->label : "");
+ p = g_strdup(fe->chr && fe->chr->label ? fe->chr->label : "");
visit_type_str(v, name, &p, errp);
g_free(p);
}
{
ERRP_GUARD();
const Property *prop = opaque;
- CharBackend *be = object_field_prop_ptr(obj, prop);
+ CharFrontend *fe = object_field_prop_ptr(obj, prop);
Chardev *s;
char *str;
* TODO Should this really be an error? If no, the old value
* needs to be released before we store the new one.
*/
- if (!check_prop_still_unset(obj, name, be->chr, str, false, errp)) {
+ if (!check_prop_still_unset(obj, name, fe->chr, str, false, errp)) {
return;
}
if (!*str) {
g_free(str);
- be->chr = NULL;
+ fe->chr = NULL;
return;
}
if (s == NULL) {
error_setg(errp, "Property '%s.%s' can't find value '%s'",
object_get_typename(obj), name, str);
- } else if (!qemu_chr_fe_init(be, s, errp)) {
+ } else if (!qemu_chr_fe_init(fe, s, errp)) {
error_prepend(errp, "Property '%s.%s' can't take value '%s': ",
object_get_typename(obj), name, str);
}
static void release_chr(Object *obj, const char *name, void *opaque)
{
const Property *prop = opaque;
- CharBackend *be = object_field_prop_ptr(obj, prop);
+ CharFrontend *fe = object_field_prop_ptr(obj, prop);
- qemu_chr_fe_deinit(be, false);
+ qemu_chr_fe_deinit(fe, false);
}
const PropertyInfo qdev_prop_chr = {
ch = val;
debugout = serial_hd(0);
if (debugout) {
- qemu_chr_fe_write_all(debugout->be, &ch, 1);
+ qemu_chr_fe_write_all(debugout->fe, &ch, 1);
} else {
fprintf(stderr, "%c", ch);
}
struct IPMIBmcExtern {
IPMIBmc parent;
- CharBackend chr;
+ CharFrontend chr;
bool connected;
SerialMM *uart;
Clock *cpuclk;
- CharBackend lcd_display;
+ CharFrontend lcd_display;
char lcd_content[8];
bool lcd_inited;
uint32_t i2coe;
uint32_t i2cout;
uint32_t i2csel;
- CharBackend display;
+ CharFrontend display;
char display_text[9];
SerialMM *uart;
bool display_inited;
/* exactly one of these two may be set */
HostMemoryBackend *hostmem; /* with interrupts */
- CharBackend server_chr; /* without interrupts */
+ CharFrontend server_chr; /* without interrupts */
/* registers */
uint32_t intrmask;
return H_PARAMETER;
}
-static bool spapr_qtest_callback(CharBackend *chr, gchar **words)
+static bool spapr_qtest_callback(CharFrontend *chr, gchar **words)
{
if (strcmp(words[0], "rtas") == 0) {
uint64_t res, args, ret;
g_assert(ret == RISCV_EXCP_NONE);
}
-static bool csr_qtest_callback(CharBackend *chr, gchar **words)
+static bool csr_qtest_callback(CharFrontend *chr, gchar **words)
{
if (strcmp(words[0], "csr") == 0) {
struct PassthruState {
CCIDCardState base;
- CharBackend cs;
+ CharFrontend cs;
uint8_t vscard_in_data[VSCARD_IN_SIZE];
uint32_t vscard_in_pos;
uint32_t vscard_in_hdr;
uint8_t xoff;
QEMUSerialSetParams params;
int latency; /* ms */
- CharBackend cs;
+ CharFrontend cs;
};
#define TYPE_USB_SERIAL "usb-serial-dev"
struct USBRedirDevice {
USBDevice dev;
/* Properties */
- CharBackend cs;
+ CharFrontend cs;
bool enable_streams;
bool suppress_remote_wake;
bool in_write;
return UINT_MAX;
}
-bool vhost_user_init(VhostUserState *user, CharBackend *chr, Error **errp)
+bool vhost_user_init(VhostUserState *user, CharFrontend *chr, Error **errp)
{
return false;
}
static int vhost_user_read_header(struct vhost_dev *dev, VhostUserMsg *msg)
{
struct vhost_user *u = dev->opaque;
- CharBackend *chr = u->user->chr;
+ CharFrontend *chr = u->user->chr;
uint8_t *p = (uint8_t *) msg;
int r, size = VHOST_USER_HDR_SIZE;
static int vhost_user_read(struct vhost_dev *dev, VhostUserMsg *msg)
{
struct vhost_user *u = dev->opaque;
- CharBackend *chr = u->user->chr;
+ CharFrontend *chr = u->user->chr;
uint8_t *p = (uint8_t *) msg;
int r, size;
int *fds, int fd_num)
{
struct vhost_user *u = dev->opaque;
- CharBackend *chr = u->user->chr;
+ CharFrontend *chr = u->user->chr;
int ret, size = VHOST_USER_HDR_SIZE + msg->hdr.size;
/*
int *dmabuf_fd)
{
struct vhost_user *u = dev->opaque;
- CharBackend *chr = u->user->chr;
+ CharFrontend *chr = u->user->chr;
int ret;
VhostUserMsg msg = {
.hdr.request = VHOST_USER_GET_SHARED_OBJECT,
VhostUserPayload *payload)
{
QemuUUID uuid;
- CharBackend *chr = u->user->chr;
+ CharFrontend *chr = u->user->chr;
Error *local_err = NULL;
int dmabuf_fd = -1;
int fd_num = 0;
{
#ifdef CONFIG_LINUX
struct vhost_user *u = dev->opaque;
- CharBackend *chr = u->user->chr;
+ CharFrontend *chr = u->user->chr;
int ufd;
int ret;
VhostUserMsg msg = {
int fd;
int ret;
struct vhost_user *u = dev->opaque;
- CharBackend *chr = u->user->chr;
+ CharFrontend *chr = u->user->chr;
VhostUserMsg msg = {
.hdr.request = VHOST_USER_GET_INFLIGHT_FD,
.hdr.flags = VHOST_USER_VERSION,
vhost_user_host_notifier_remove(n, NULL, true);
}
-bool vhost_user_init(VhostUserState *user, CharBackend *chr, Error **errp)
+bool vhost_user_init(VhostUserState *user, CharFrontend *chr, Error **errp)
{
if (user->chr) {
error_setg(errp, "Cannot initialize vhost-user state");
typedef struct {
vu_async_close_fn cb;
DeviceState *dev;
- CharBackend *cd;
+ CharFrontend *cd;
struct vhost_dev *vhost;
} VhostAsyncCallback;
* purposes.
*/
void vhost_user_async_close(DeviceState *d,
- CharBackend *chardev, struct vhost_dev *vhost,
+ CharFrontend *chardev, struct vhost_dev *vhost,
vu_async_close_fn cb)
{
if (!runstate_check(RUN_STATE_SHUTDOWN)) {
typedef int BackendChangeHandler(void *opaque);
/**
- * struct CharBackend - back end as seen by front end
+ * struct CharFrontend - Chardev as seen by front end
* @fe_is_open: the front end is ready for IO
*
* The actual backend is Chardev
*/
-struct CharBackend {
+struct CharFrontend {
Chardev *chr;
IOEventHandler *chr_event;
IOCanReadHandler *chr_can_read;
/**
* qemu_chr_fe_init:
*
- * Initializes a front end for the given CharBackend and
- * Chardev. Call qemu_chr_fe_deinit() to remove the association and
- * release the driver.
+ * Initializes the frontend @c for the given Chardev backend @s. Call
+ * qemu_chr_fe_deinit() to remove the association and release the backend.
*
* Returns: false on error.
*/
-bool qemu_chr_fe_init(CharBackend *b, Chardev *s, Error **errp);
+bool qemu_chr_fe_init(CharFrontend *c, Chardev *be, Error **errp);
/**
* qemu_chr_fe_deinit:
- * @b: a CharBackend
+ * @c: a CharFrontend
* @del: if true, delete the chardev backend
*
- * Dissociate the CharBackend from the Chardev.
+ * Dissociate the CharFrontend from the Chardev.
*
* Safe to call without associated Chardev.
*/
-void qemu_chr_fe_deinit(CharBackend *b, bool del);
+void qemu_chr_fe_deinit(CharFrontend *c, bool del);
/**
* qemu_chr_fe_get_driver:
*
- * Returns: the driver associated with a CharBackend or NULL if no
+ * Returns: the driver associated with a CharFrontend or NULL if no
* associated Chardev.
* Note: avoid this function as the driver should never be accessed directly,
* especially by the frontends that support chardevice hotswap.
* Consider qemu_chr_fe_backend_connected() to check for driver existence
*/
-Chardev *qemu_chr_fe_get_driver(CharBackend *be);
+Chardev *qemu_chr_fe_get_driver(CharFrontend *c);
/**
* qemu_chr_fe_backend_connected:
*
- * Returns: true if there is a chardevice associated with @be.
+ * Returns: true if there is a backend associated with @c.
*/
-bool qemu_chr_fe_backend_connected(CharBackend *be);
+bool qemu_chr_fe_backend_connected(CharFrontend *c);
/**
* qemu_chr_fe_backend_open:
*
- * Returns: true if chardevice associated with @be is open.
+ * Returns: true if the backend associated with @c is open.
*/
-bool qemu_chr_fe_backend_open(CharBackend *be);
+bool qemu_chr_fe_backend_open(CharFrontend *c);
/**
* qemu_chr_fe_set_handlers_full:
- * @b: a CharBackend
+ * @c: a CharFrontend
* @fd_can_read: callback to get the amount of data the frontend may
* receive
* @fd_read: callback to receive data from char
*
* Without associated Chardev, nothing is changed.
*/
-void qemu_chr_fe_set_handlers_full(CharBackend *b,
+void qemu_chr_fe_set_handlers_full(CharFrontend *c,
IOCanReadHandler *fd_can_read,
IOReadHandler *fd_read,
IOEventHandler *fd_event,
*
* Version of qemu_chr_fe_set_handlers_full() with sync_state = true.
*/
-void qemu_chr_fe_set_handlers(CharBackend *b,
+void qemu_chr_fe_set_handlers(CharFrontend *c,
IOCanReadHandler *fd_can_read,
IOReadHandler *fd_read,
IOEventHandler *fd_event,
*
* Without associated Chardev, nothing is changed.
*/
-void qemu_chr_fe_take_focus(CharBackend *b);
+void qemu_chr_fe_take_focus(CharFrontend *c);
/**
* qemu_chr_fe_accept_input:
*
* Notify that the frontend is ready to receive data
*/
-void qemu_chr_fe_accept_input(CharBackend *be);
+void qemu_chr_fe_accept_input(CharFrontend *c);
/**
* qemu_chr_fe_disconnect:
* Close a fd accepted by character backend.
* Without associated Chardev, do nothing.
*/
-void qemu_chr_fe_disconnect(CharBackend *be);
+void qemu_chr_fe_disconnect(CharFrontend *c);
/**
* qemu_chr_fe_wait_connected:
* Wait for character backend to be connected, return < 0 on error or
* if no associated Chardev.
*/
-int qemu_chr_fe_wait_connected(CharBackend *be, Error **errp);
+int qemu_chr_fe_wait_connected(CharFrontend *c, Error **errp);
/**
* qemu_chr_fe_set_echo:
* can see what you type if you try to type QMP commands.
* Without associated Chardev, do nothing.
*/
-void qemu_chr_fe_set_echo(CharBackend *be, bool echo);
+void qemu_chr_fe_set_echo(CharFrontend *c, bool echo);
/**
* qemu_chr_fe_set_open:
- * @be: a CharBackend
+ * @c: a CharFrontend
* @is_open: the front end open status
*
* This is an indication that the front end is ready (or not) to begin
* doing I/O. Without associated Chardev, do nothing.
*/
-void qemu_chr_fe_set_open(CharBackend *be, bool is_open);
+void qemu_chr_fe_set_open(CharFrontend *c, bool is_open);
/**
* qemu_chr_fe_printf:
* function is thread-safe. It does nothing without associated
* Chardev.
*/
-void qemu_chr_fe_printf(CharBackend *be, const char *fmt, ...)
+void qemu_chr_fe_printf(CharFrontend *c, const char *fmt, ...)
G_GNUC_PRINTF(2, 3);
*
* Returns: the source tag
*/
-guint qemu_chr_fe_add_watch(CharBackend *be, GIOCondition cond,
+guint qemu_chr_fe_add_watch(CharFrontend *c, GIOCondition cond,
FEWatchFunc func, void *user_data);
/**
* Returns: the number of bytes consumed (0 if no associated Chardev)
* or -1 on error.
*/
-int qemu_chr_fe_write(CharBackend *be, const uint8_t *buf, int len);
+int qemu_chr_fe_write(CharFrontend *c, const uint8_t *buf, int len);
/**
* qemu_chr_fe_write_all:
* Returns: the number of bytes consumed (0 if no associated Chardev)
* or -1 on error.
*/
-int qemu_chr_fe_write_all(CharBackend *be, const uint8_t *buf, int len);
+int qemu_chr_fe_write_all(CharFrontend *c, const uint8_t *buf, int len);
/**
* qemu_chr_fe_read_all:
* Returns: the number of bytes read (0 if no associated Chardev)
* or -1 on error.
*/
-int qemu_chr_fe_read_all(CharBackend *be, uint8_t *buf, int len);
+int qemu_chr_fe_read_all(CharFrontend *c, uint8_t *buf, int len);
/**
* qemu_chr_fe_ioctl:
* associated Chardev, -ENOTSUP, otherwise the return
* value depends on the semantics of @cmd
*/
-int qemu_chr_fe_ioctl(CharBackend *be, int cmd, void *arg);
+int qemu_chr_fe_ioctl(CharFrontend *c, int cmd, void *arg);
/**
* qemu_chr_fe_get_msgfd:
* this function will return -1 until a client sends a new file
* descriptor.
*/
-int qemu_chr_fe_get_msgfd(CharBackend *be);
+int qemu_chr_fe_get_msgfd(CharFrontend *c);
/**
* qemu_chr_fe_get_msgfds:
* this function will return -1 until a client sends a new set of file
* descriptors.
*/
-int qemu_chr_fe_get_msgfds(CharBackend *be, int *fds, int num);
+int qemu_chr_fe_get_msgfds(CharFrontend *c, int *fds, int num);
/**
* qemu_chr_fe_set_msgfds:
*
* Returns: -1 if fd passing isn't supported or no associated Chardev.
*/
-int qemu_chr_fe_set_msgfds(CharBackend *be, int *fds, int num);
+int qemu_chr_fe_set_msgfds(CharFrontend *c, int *fds, int num);
#endif /* QEMU_CHAR_FE_H */
#define IAC 255
/* character device */
-typedef struct CharBackend CharBackend;
+typedef struct CharFrontend CharFrontend;
typedef enum {
CHR_EVENT_BREAK, /* serial break char */
Object parent_obj;
QemuMutex chr_write_lock;
- CharBackend *be;
+ CharFrontend *fe;
char *label;
char *filename;
int logfd;
/* <public> */
MemoryRegion mmio;
- CharBackend chr;
+ CharFrontend chr;
bool enabled;
/*< public >*/
MemoryRegion iomem;
- CharBackend chr;
+ CharFrontend chr;
qemu_irq irq;
uint8_t read_fifo[BCM2835_AUX_RX_FIFO_LEN];
uint32_t rx_count;
uint32_t tx_count;
uint64_t char_tx_time;
- CharBackend chr;
+ CharFrontend chr;
qemu_irq irq;
QEMUTimer *fifo_trigger_handle;
Clock *refclk;
/*< public >*/
MemoryRegion iomem;
- CharBackend chr;
+ CharFrontend chr;
qemu_irq txint;
qemu_irq rxint;
qemu_irq txovrint;
/*< public >*/
MemoryRegion regs_region;
- CharBackend chr;
+ CharFrontend chr;
uint32_t reg_rx;
uint32_t reg_st;
uint32_t reg;
uint8_t wregs[ESCC_SERIAL_REGS], rregs[ESCC_SERIAL_REGS];
ESCCSERIOQueue queue;
- CharBackend chr;
+ CharFrontend chr;
int e0_mode, led_mode, caps_lock_mode, num_lock_mode;
int disabled;
int clock;
MemoryRegion iomem;
qemu_irq irq;
- CharBackend chr;
+ CharFrontend chr;
uint32_t data_len;
uint64_t data_ptr;
Clock *f_clk;
- CharBackend chr;
+ CharFrontend chr;
qemu_irq tx_watermark;
qemu_irq rx_watermark;
qemu_irq tx_empty;
uint32_t ucr4;
qemu_irq irq;
- CharBackend chr;
+ CharFrontend chr;
};
#endif
Fifo8 rx_fifo;
- CharBackend chr;
+ CharFrontend chr;
qemu_irq irq;
};
#endif /* HW_STM32F2XX_USART_H */
SysBusDevice parent_obj;
MemoryRegion iomem;
- CharBackend chr;
+ CharFrontend chr;
qemu_irq irq;
guint watch_tag;
uint8_t control;
qemu_irq irq;
int irq_pending;
- CharBackend chr;
+ CharFrontend chr;
int hw_driver;
int epp_timeout;
uint32_t last_read_offset; /* For debugging */
int read_pos;
int read_count;
int read_trigger;
- CharBackend chr;
+ CharFrontend chr;
qemu_irq irq[6];
Clock *clk;
bool migrate_clk;
MemoryRegion memory;
QEMUTimer timer;
- CharBackend chr;
+ CharFrontend chr;
qemu_irq irq[SCI_NR_IRQ];
uint8_t smr;
hwaddr fromhost_offset;
MemoryRegion mmio;
- CharBackend chr;
+ CharFrontend chr;
uint64_t pending_read;
} HTIFState;
it can be reset while reading iir */
int thr_ipending;
qemu_irq irq;
- CharBackend chr;
+ CharFrontend chr;
int last_break_enable;
uint32_t baudbase;
uint32_t tsr_retry;
uint32_t uart_iq_cycles;
uint32_t uart_rx_threshold;
- CharBackend chr;
+ CharFrontend chr;
} ShaktiUartState;
#endif /* HW_SHAKTI_UART_H */
/*< public >*/
qemu_irq irq;
MemoryRegion mmio;
- CharBackend chr;
+ CharFrontend chr;
uint32_t txfifo;
uint32_t ie;
uint32_t usart_cr3;
uint32_t usart_gtpr;
- CharBackend chr;
+ CharFrontend chr;
qemu_irq irq;
};
#endif /* HW_STM32F2XX_USART_H */
uint32_t tdr;
Clock *clk;
- CharBackend chr;
+ CharFrontend chr;
qemu_irq irq;
guint watch_tag;
};
QTAILQ_HEAD(, IvshmemPeer) peer;
IvshmemPeer own;
- CharBackend server_chr;
+ CharFrontend server_chr;
/* IRQ */
qemu_irq irq;
DEFINE_PROP_SIGNED(_n, _s, _f, _d, qdev_prop_pci_devfn, int32_t)
#define DEFINE_PROP_CHR(_n, _s, _f) \
- DEFINE_PROP(_n, _s, _f, qdev_prop_chr, CharBackend)
+ DEFINE_PROP(_n, _s, _f, qdev_prop_chr, CharFrontend)
#define DEFINE_PROP_NETDEV(_n, _s, _f) \
DEFINE_PROP(_n, _s, _f, qdev_prop_netdev, NICPeers)
#define DEFINE_PROP_DRIVE(_n, _s, _f) \
VirtIODevice parent_obj;
/* Properties */
- CharBackend chardev;
+ CharFrontend chardev;
uint16_t virtio_id;
uint32_t num_vqs;
uint32_t vq_size; /* can't exceed VIRTIO_QUEUE_MAX */
struct VHostUserBlk {
VirtIODevice parent_obj;
- CharBackend chardev;
+ CharFrontend chardev;
int32_t bootindex;
struct virtio_blk_config blkcfg;
uint16_t num_queues;
OBJECT_DECLARE_SIMPLE_TYPE(VHostUserFS, VHOST_USER_FS)
typedef struct {
- CharBackend chardev;
+ CharFrontend chardev;
char *tag;
uint16_t num_request_queues;
uint16_t queue_size;
struct VHostUserSCMI {
VirtIODevice parent;
- CharBackend chardev;
+ CharFrontend chardev;
struct vhost_virtqueue *vhost_vqs;
struct vhost_dev vhost_dev;
VhostUserState vhost_user;
OBJECT_DECLARE_SIMPLE_TYPE(VHostUserVSock, VHOST_USER_VSOCK)
typedef struct {
- CharBackend chardev;
+ CharFrontend chardev;
} VHostUserVSockConf;
struct VHostUserVSock {
* @memory_slots:
*/
typedef struct VhostUserState {
- CharBackend *chr;
+ CharFrontend *chr;
GPtrArray *notifiers;
int memory_slots;
bool supports_config;
*
* Return: true on success, false on error while setting errp.
*/
-bool vhost_user_init(VhostUserState *user, CharBackend *chr, Error **errp);
+bool vhost_user_init(VhostUserState *user, CharFrontend *chr, Error **errp);
/**
* vhost_user_cleanup() - cleanup state
/**
* vhost_user_async_close() - cleanup vhost-user post connection drop
* @d: DeviceState for the associated device (passed to callback)
- * @chardev: the CharBackend associated with the connection
+ * @chardev: the CharFrontend associated with the connection
* @vhost: the common vhost device
* @cb: the user callback function to complete the clean-up
*
typedef void (*vu_async_close_fn)(DeviceState *cb);
void vhost_user_async_close(DeviceState *d,
- CharBackend *chardev, struct vhost_dev *vhost,
+ CharFrontend *chardev, struct vhost_dev *vhost,
vu_async_close_fn cb);
#endif
VhostUserBackend *vhost;
int vhost_gpu_fd; /* closed by the chardev */
- CharBackend vhost_chr;
+ CharFrontend vhost_chr;
QemuDmaBuf *dmabuf[VIRTIO_GPU_MAX_SCANOUTS];
bool backend_blocked;
};
uint32_t cmd_per_lun;
char *vhostfd;
char *wwpn;
- CharBackend chardev;
+ CharFrontend chardev;
uint32_t boot_tpgt;
IOThread *iothread;
IOThreadVirtQueueMappingList *iothread_vq_mapping_list;
return qtest_allowed;
}
-void G_GNUC_PRINTF(2, 3) qtest_sendf(CharBackend *chr, const char *fmt, ...);
-void qtest_set_command_cb(bool (*pc_cb)(CharBackend *chr, gchar **words));
+void G_GNUC_PRINTF(2, 3) qtest_sendf(CharFrontend *chr, const char *fmt, ...);
+void qtest_set_command_cb(bool (*pc_cb)(CharFrontend *chr, gchar **words));
bool qtest_driver(void);
void qtest_server_init(const char *qtest_chrdev, const char *qtest_log, Error **errp);
Object parent;
char *chr_name;
- CharBackend chr;
+ CharFrontend chr;
VhostUserState vhost_user;
struct vhost_dev dev;
VirtIODevice *vdev;
} HMPCommand;
struct Monitor {
- CharBackend chr;
+ CharFrontend chr;
int suspend_cnt; /* Needs to be accessed atomically */
bool is_qmp;
bool skip_flush;
typedef struct SendCo {
Coroutine *co;
struct CompareState *s;
- CharBackend *chr;
+ CharFrontend *chr;
GQueue send_list;
bool notify_remote_frame;
bool done;
char *sec_indev;
char *outdev;
char *notify_dev;
- CharBackend chr_pri_in;
- CharBackend chr_sec_in;
- CharBackend chr_out;
- CharBackend chr_notify_dev;
+ CharFrontend chr_pri_in;
+ CharFrontend chr_sec_in;
+ CharFrontend chr_out;
+ CharFrontend chr_notify_dev;
SocketReadState pri_rs;
SocketReadState sec_rs;
SocketReadState notify_rs;
NetFilterState parent_obj;
char *indev;
char *outdev;
- CharBackend chr_in;
- CharBackend chr_out;
+ CharFrontend chr_in;
+ CharFrontend chr_out;
SocketReadState rs;
bool vnet_hdr;
};
/* vhost user */
VhostUserState *vhost_user;
VHostNetState *vhost_net;
- CharBackend vhost_chr;
+ CharFrontend vhost_chr;
guint vhost_watch;
uint64_t acked_features;
bool started;
};
struct GuestFwd {
- CharBackend hd;
+ CharFrontend hd;
struct in_addr server;
int port;
Slirp *slirp;
typedef struct NetVhostUserState {
NetClientState nc;
- CharBackend chr; /* only queue index 0 */
+ CharFrontend chr; /* only queue index 0 */
VhostUserState *vhost_user;
VHostNetState *vhost_net;
guint watch;
// BQL is taken, either directly or via `BqlCell` and `BqlRefCell`.
// When bindings for character devices are introduced, this can be
// moved to the Opaque<> wrapper in src/chardev.rs.
-unsafe impl Send for CharBackend {}
-unsafe impl Sync for CharBackend {}
+unsafe impl Send for CharFrontend {}
+unsafe impl Sync for CharFrontend {}
// SAFETY: this is a pure data struct
unsafe impl Send for CoalescedMemoryRange {}
// BQL is taken, either directly or via `BqlCell` and `BqlRefCell`.
// When bindings for character devices are introduced, this can be
// moved to the Opaque<> wrapper in src/chardev.rs.
-unsafe impl Send for CharBackend {}
-unsafe impl Sync for CharBackend {}
+unsafe impl Send for CharFrontend {}
+unsafe impl Sync for CharFrontend {}
-unsafe impl Zeroable for CharBackend {}
+unsafe impl Zeroable for CharFrontend {}
//!
//! Character devices in QEMU can run under the big QEMU lock or in a separate
//! `GMainContext`. Here we only support the former, because the bindings
-//! enforce that the BQL is taken whenever the functions in [`CharBackend`] are
+//! enforce that the BQL is taken whenever the functions in [`CharFrontend`] are
//! called.
use std::{
pub type ChardevClass = bindings::ChardevClass;
pub type Event = bindings::QEMUChrEvent;
-/// A safe wrapper around [`bindings::CharBackend`], denoting the character
+/// A safe wrapper around [`bindings::CharFrontend`], denoting the character
/// back-end that is used for example by a device. Compared to the
/// underlying C struct it adds BQL protection, and is marked as pinned
/// because the QOM object ([`bindings::Chardev`]) contains a pointer to
-/// the `CharBackend`.
-pub struct CharBackend {
- inner: BqlRefCell<bindings::CharBackend>,
+/// the `CharFrontend`.
+pub struct CharFrontend {
+ inner: BqlRefCell<bindings::CharFrontend>,
_pin: PhantomPinned,
}
-pub struct CharBackendMut<'a>(BqlRefMut<'a, bindings::CharBackend>);
+pub struct CharFrontendMut<'a>(BqlRefMut<'a, bindings::CharFrontend>);
-impl Write for CharBackendMut<'_> {
+impl Write for CharFrontendMut<'_> {
fn flush(&mut self) -> io::Result<()> {
Ok(())
}
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
- let chr: &mut bindings::CharBackend = &mut self.0;
+ let chr: &mut bindings::CharFrontend = &mut self.0;
let len = buf.len().try_into().unwrap();
let r = unsafe { bindings::qemu_chr_fe_write(addr_of_mut!(*chr), buf.as_ptr(), len) };
}
fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
- let chr: &mut bindings::CharBackend = &mut self.0;
+ let chr: &mut bindings::CharFrontend = &mut self.0;
let len = buf.len().try_into().unwrap();
let r = unsafe { bindings::qemu_chr_fe_write_all(addr_of_mut!(*chr), buf.as_ptr(), len) };
}
}
-impl Debug for CharBackend {
+impl Debug for CharFrontend {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
// SAFETY: accessed just to print the values
let chr = self.inner.as_ptr();
}
// FIXME: use something like PinnedDrop from the pinned_init crate
-impl Drop for CharBackend {
+impl Drop for CharFrontend {
fn drop(&mut self) {
self.disable_handlers();
}
}
-impl CharBackend {
+impl CharFrontend {
/// Enable the front-end's character device handlers, if there is an
/// associated `Chardev`.
pub fn enable_handlers<
/// the big QEMU lock while the character device is borrowed, as
/// that might cause C code to write to the character device.
pub fn borrow_mut(&self) -> impl Write + '_ {
- CharBackendMut(self.inner.borrow_mut())
+ CharFrontendMut(self.inner.borrow_mut())
}
/// Send a continuous stream of zero bits on the line if `enabled` is
use std::{ffi::CStr, mem::size_of};
use bql::BqlRefCell;
-use chardev::{CharBackend, Chardev, Event};
+use chardev::{CharFrontend, Chardev, Event};
use common::{static_assert, uninit_field_mut};
use hwcore::{
Clock, ClockEvent, DeviceImpl, DeviceMethods, DeviceState, IRQState, InterruptSource,
pub iomem: MemoryRegion,
#[doc(alias = "chr")]
#[property(rename = "chardev")]
- pub char_backend: CharBackend,
+ pub char_frontend: CharFrontend,
pub regs: BqlRefCell<PL011Registers>,
/// QEMU interrupts
///
}
let update = (self.line_control.send_break() != new_val.send_break()) && {
let break_enable = new_val.send_break();
- let _ = device.char_backend.send_break(break_enable);
+ let _ = device.char_frontend.send_break(break_enable);
self.loopback_break(break_enable)
};
self.line_control = new_val;
trace::trace_pl011_read(offset, result, c"");
if update_irq {
self.update();
- self.char_backend.accept_input();
+ self.char_frontend.accept_input();
}
result.into()
}
let ch: [u8; 1] = [value as u8];
// XXX this blocks entire thread. Rewrite to use
// qemu_chr_fe_write and background I/O callbacks
- let _ = self.char_backend.write_all(&ch);
+ let _ = self.char_frontend.write_all(&ch);
}
update_irq = self.regs.borrow_mut().write(field, value as u32, self);
}
fn realize(&self) -> util::Result<()> {
- self.char_backend
+ self.char_frontend
.enable_handlers(self, Self::can_receive, Self::receive, Self::event);
Ok(())
}
impl_qdev_prop!(usize, qdev_prop_usize);
impl_qdev_prop!(i32, qdev_prop_int32);
impl_qdev_prop!(i64, qdev_prop_int64);
-impl_qdev_prop!(chardev::CharBackend, qdev_prop_chr);
+impl_qdev_prop!(chardev::CharFrontend, qdev_prop_chr);
/// Trait to define device properties.
///
/* Access to this structure is protected by the BQL */
typedef struct SemihostingConsole {
- CharBackend backend;
+ CharFrontend frontend;
Chardev *chr;
GSList *sleeping_cpus;
bool got;
console.chr = chr;
if (chr) {
fifo8_create(&console.fifo, FIFO_SIZE);
- qemu_chr_fe_init(&console.backend, chr, &error_abort);
- qemu_chr_fe_set_handlers(&console.backend,
+ qemu_chr_fe_init(&console.frontend, chr, &error_abort);
+ qemu_chr_fe_set_handlers(&console.frontend,
console_can_read,
console_read,
NULL, NULL, &console,
bool has_machine_link;
char *chr_name;
Chardev *chr;
- CharBackend qtest_chr;
+ CharFrontend qtest_chr;
char *log;
};
static void qtest_server_char_be_send(void *opaque, const char *str)
{
size_t len = strlen(str);
- CharBackend* chr = (CharBackend *)opaque;
+ CharFrontend* chr = (CharFrontend *)opaque;
qemu_chr_fe_write_all(chr, (uint8_t *)str, len);
if (qtest_log_fp && qtest_opened) {
fprintf(qtest_log_fp, "%s", str);
}
}
-static void qtest_send(CharBackend *chr, const char *str)
+static void qtest_send(CharFrontend *chr, const char *str)
{
qtest_log_timestamp();
qtest_server_send(qtest_server_send_opaque, str);
}
-void qtest_sendf(CharBackend *chr, const char *fmt, ...)
+void qtest_sendf(CharFrontend *chr, const char *fmt, ...)
{
va_list ap;
gchar *buffer;
qemu_set_irq(old_irq, level);
if (irq_levels[n] != level) {
- CharBackend *chr = &qtest->qtest_chr;
+ CharFrontend *chr = &qtest->qtest_chr;
irq_levels[n] = level;
qtest_sendf(chr, "IRQ %s %d\n",
level ? "raise" : "lower", n);
}
}
-static bool (*process_command_cb)(CharBackend *chr, gchar **words);
+static bool (*process_command_cb)(CharFrontend *chr, gchar **words);
-void qtest_set_command_cb(bool (*pc_cb)(CharBackend *chr, gchar **words))
+void qtest_set_command_cb(bool (*pc_cb)(CharFrontend *chr, gchar **words))
{
assert(!process_command_cb); /* Switch to a list if we need more than one */
*disconnected = qdev_intercept_gpio_out(dev, icpt, name, n);
}
-static void qtest_process_command(CharBackend *chr, gchar **words)
+static void qtest_process_command(CharFrontend *chr, gchar **words)
{
const gchar *command;
* Process as much of @inbuf as we can in newline terminated chunks.
* Remove the processed commands from @inbuf as we go.
*/
-static void qtest_process_inbuf(CharBackend *chr, GString *inbuf)
+static void qtest_process_inbuf(CharFrontend *chr, GString *inbuf)
{
char *end;
static void qtest_read(void *opaque, const uint8_t *buf, int size)
{
- CharBackend *chr = opaque;
+ CharFrontend *chr = opaque;
g_string_append_len(inbuf, (const gchar *)buf, size);
qtest_process_inbuf(chr, inbuf);
*/
void HELPER(diag_console_output)(CPUHPPAState *env)
{
- CharBackend *serial_backend;
+ CharFrontend *fe;
Chardev *serial_port;
unsigned char c;
return;
}
- /* get serial_backend for the serial port */
- serial_backend = serial_port->be;
- if (!serial_backend ||
- !qemu_chr_fe_backend_connected(serial_backend)) {
+ /* get the frontend for the serial port */
+ fe = serial_port->fe;
+ if (!fe ||
+ !qemu_chr_fe_backend_connected(fe)) {
return;
}
c = (unsigned char)env->gr[26];
- qemu_chr_fe_write(serial_backend, &c, sizeof(c));
+ qemu_chr_fe_write(fe, &c, sizeof(c));
}
#endif
buf = g_malloc0(num_bytes);
if (run->riscv_sbi.function_id == SBI_EXT_DBCN_CONSOLE_READ) {
- ret = qemu_chr_fe_read_all(serial_hd(0)->be, buf, num_bytes);
+ ret = qemu_chr_fe_read_all(serial_hd(0)->fe, buf, num_bytes);
if (ret < 0) {
error_report("SBI_EXT_DBCN_CONSOLE_READ: error when "
"reading chardev");
} else {
address_space_read(cs->as, addr, attrs, buf, num_bytes);
- ret = qemu_chr_fe_write_all(serial_hd(0)->be, buf, num_bytes);
+ ret = qemu_chr_fe_write_all(serial_hd(0)->fe, buf, num_bytes);
if (ret < 0) {
error_report("SBI_EXT_DBCN_CONSOLE_WRITE: error when "
"writing chardev");
break;
case SBI_EXT_DBCN_CONSOLE_WRITE_BYTE:
ch = run->riscv_sbi.args[0];
- ret = qemu_chr_fe_write_all(serial_hd(0)->be, &ch, sizeof(ch));
+ ret = qemu_chr_fe_write_all(serial_hd(0)->fe, &ch, sizeof(ch));
if (ret < 0) {
error_report("SBI_EXT_DBCN_CONSOLE_WRITE_BYTE: error when "
switch (run->riscv_sbi.extension_id) {
case SBI_EXT_0_1_CONSOLE_PUTCHAR:
ch = run->riscv_sbi.args[0];
- qemu_chr_fe_write(serial_hd(0)->be, &ch, sizeof(ch));
+ qemu_chr_fe_write(serial_hd(0)->fe, &ch, sizeof(ch));
break;
case SBI_EXT_0_1_CONSOLE_GETCHAR:
- ret = qemu_chr_fe_read_all(serial_hd(0)->be, &ch, sizeof(ch));
+ ret = qemu_chr_fe_read_all(serial_hd(0)->fe, &ch, sizeof(ch));
if (ret == sizeof(ch)) {
run->riscv_sbi.ret[0] = ch;
} else {
}
typedef struct XtensaSimConsole {
- CharBackend be;
+ CharFrontend fe;
struct {
char buffer[16];
size_t offset;
{
static XtensaSimConsole console;
- qemu_chr_fe_init(&console.be, chr, &error_abort);
- qemu_chr_fe_set_handlers(&console.be,
+ qemu_chr_fe_init(&console.fe, chr, &error_abort);
+ qemu_chr_fe_set_handlers(&console.fe,
sim_console_can_read,
sim_console_read,
NULL, NULL, &console,
len -= io_sz;
if (fd < 3 && sim_console) {
if (is_write && (fd == 1 || fd == 2)) {
- io_done = qemu_chr_fe_write_all(&sim_console->be,
+ io_done = qemu_chr_fe_write_all(&sim_console->fe,
buf, io_sz);
regs[3] = errno_h2g(errno);
} else if (!is_write && fd == 0) {
sim_console->input.buffer + io_done,
sim_console->input.offset - io_done);
sim_console->input.offset -= io_done;
- qemu_chr_fe_accept_input(&sim_console->be);
+ qemu_chr_fe_accept_input(&sim_console->fe);
} else {
io_done = -1;
regs[3] = TARGET_EAGAIN;
gchar *mig_path;
gchar *chr_name;
gchar *tmpfs;
- CharBackend chr;
+ CharFrontend chr;
int fds_num;
int fds[VHOST_MEMORY_MAX_NREGIONS];
VhostUserMemory memory;
/* VHOST-USER commands. */
uint64_t (*get_features)(TestServer *s);
- void (*set_features)(TestServer *s, CharBackend *chr,
+ void (*set_features)(TestServer *s, CharFrontend *chr,
VhostUserMsg *msg);
void (*get_protocol_features)(TestServer *s,
- CharBackend *chr, VhostUserMsg *msg);
+ CharFrontend *chr, VhostUserMsg *msg);
};
static const char *init_hugepagefs(void);
static void chr_read(void *opaque, const uint8_t *buf, int size)
{
TestServer *s = opaque;
- CharBackend *chr = &s->chr;
+ CharFrontend *chr = &s->chr;
VhostUserMsg msg;
uint8_t *p = (uint8_t *) &msg;
int fd = -1;
return features;
}
-static void vu_net_set_features(TestServer *s, CharBackend *chr,
+static void vu_net_set_features(TestServer *s, CharFrontend *chr,
VhostUserMsg *msg)
{
g_assert(msg->payload.u64 & (0x1ULL << VHOST_USER_F_PROTOCOL_FEATURES));
}
}
-static void vu_net_get_protocol_features(TestServer *s, CharBackend *chr,
+static void vu_net_get_protocol_features(TestServer *s, CharFrontend *chr,
VhostUserMsg *msg)
{
/* send back features to qemu */
* that we support VHOST_USER_PROTOCOL_F_CONFIG as gpio would use it
* talking to a read vhost-user daemon.
*/
-static void vu_gpio_get_protocol_features(TestServer *s, CharBackend *chr,
+static void vu_gpio_get_protocol_features(TestServer *s, CharFrontend *chr,
VhostUserMsg *msg)
{
/* send back features to qemu */
0x1ULL << VHOST_USER_F_PROTOCOL_FEATURES;
}
-static void vu_scmi_get_protocol_features(TestServer *s, CharBackend *chr,
+static void vu_scmi_get_protocol_features(TestServer *s, CharFrontend *chr,
VhostUserMsg *msg)
{
msg->flags |= VHOST_USER_REPLY_MASK;
static void char_stdio_test_subprocess(void)
{
Chardev *chr;
- CharBackend be;
+ CharFrontend c;
int ret;
chr = qemu_chr_new("label", "stdio", NULL);
g_assert_nonnull(chr);
- qemu_chr_fe_init(&be, chr, &error_abort);
- qemu_chr_fe_set_open(&be, true);
- ret = qemu_chr_fe_write(&be, (void *)"buf", 4);
+ qemu_chr_fe_init(&c, chr, &error_abort);
+ qemu_chr_fe_set_open(&c, true);
+ ret = qemu_chr_fe_write(&c, (void *)"buf", 4);
g_assert_cmpint(ret, ==, 4);
- qemu_chr_fe_deinit(&be, true);
+ qemu_chr_fe_deinit(&c, true);
}
static void char_stdio_test(void)
{
QemuOpts *opts;
Chardev *chr;
- CharBackend be;
+ CharFrontend c;
char *data;
int ret;
g_assert_nonnull(chr);
qemu_opts_del(opts);
- qemu_chr_fe_init(&be, chr, &error_abort);
- ret = qemu_chr_fe_write(&be, (void *)"buff", 4);
+ qemu_chr_fe_init(&c, chr, &error_abort);
+ ret = qemu_chr_fe_write(&c, (void *)"buff", 4);
g_assert_cmpint(ret, ==, 4);
data = qmp_ringbuf_read("ringbuf-label", 4, false, 0, &error_abort);
g_assert_cmpstr(data, ==, "");
g_free(data);
- qemu_chr_fe_deinit(&be, true);
+ qemu_chr_fe_deinit(&c, true);
/* check alias */
opts = qemu_opts_create(qemu_find_opts("chardev"), "memory-label",
Chardev *chr, *base;
char *data;
FeHandler h1 = { 0, false, 0, false, }, h2 = { 0, false, 0, false, };
- CharBackend chr_be1, chr_be2;
+ CharFrontend chr_fe1, chr_fe2;
Error *error = NULL;
/* Create mux and chardev to be immediately removed */
g_assert_nonnull(chr);
qemu_opts_del(opts);
- qemu_chr_fe_init(&chr_be1, chr, &error_abort);
- qemu_chr_fe_set_handlers(&chr_be1,
+ qemu_chr_fe_init(&chr_fe1, chr, &error_abort);
+ qemu_chr_fe_set_handlers(&chr_fe1,
fe_can_read,
fe_read,
fe_event,
&h1,
NULL, true);
- qemu_chr_fe_init(&chr_be2, chr, &error_abort);
- qemu_chr_fe_set_handlers(&chr_be2,
+ qemu_chr_fe_init(&chr_fe2, chr, &error_abort);
+ qemu_chr_fe_set_handlers(&chr_fe2,
fe_can_read,
fe_read,
fe_event,
NULL,
&h2,
NULL, true);
- qemu_chr_fe_take_focus(&chr_be2);
+ qemu_chr_fe_take_focus(&chr_fe2);
base = qemu_chr_find("mux-label-base");
g_assert_cmpint(qemu_chr_be_can_write(base), !=, 0);
g_assert_cmpint(h2.last_event, ==, CHR_EVENT_MUX_OUT);
/* open/close state and corresponding events */
- g_assert_true(qemu_chr_fe_backend_open(&chr_be1));
- g_assert_true(qemu_chr_fe_backend_open(&chr_be2));
+ g_assert_true(qemu_chr_fe_backend_open(&chr_fe1));
+ g_assert_true(qemu_chr_fe_backend_open(&chr_fe2));
g_assert_true(h1.is_open);
g_assert_false(h1.openclose_mismatch);
g_assert_true(h2.is_open);
h1.openclose_count = h2.openclose_count = 0;
- qemu_chr_fe_set_handlers(&chr_be1, NULL, NULL, NULL, NULL,
+ qemu_chr_fe_set_handlers(&chr_fe1, NULL, NULL, NULL, NULL,
NULL, NULL, false);
- qemu_chr_fe_set_handlers(&chr_be2, NULL, NULL, NULL, NULL,
+ qemu_chr_fe_set_handlers(&chr_fe2, NULL, NULL, NULL, NULL,
NULL, NULL, false);
g_assert_cmpint(h1.openclose_count, ==, 0);
g_assert_cmpint(h2.openclose_count, ==, 0);
h1.is_open = h2.is_open = false;
- qemu_chr_fe_set_handlers(&chr_be1,
+ qemu_chr_fe_set_handlers(&chr_fe1,
NULL,
NULL,
fe_event,
NULL,
&h1,
NULL, false);
- qemu_chr_fe_set_handlers(&chr_be2,
+ qemu_chr_fe_set_handlers(&chr_fe2,
NULL,
NULL,
fe_event,
g_assert_cmpint(h2.openclose_count, ==, 3);
g_assert_false(h2.openclose_mismatch);
- qemu_chr_fe_set_handlers(&chr_be2,
+ qemu_chr_fe_set_handlers(&chr_fe2,
fe_can_read,
fe_read,
fe_event,
NULL,
&h2,
NULL, false);
- qemu_chr_fe_set_handlers(&chr_be1,
+ qemu_chr_fe_set_handlers(&chr_fe1,
fe_can_read,
fe_read,
fe_event,
NULL, false);
/* remove first handler */
- qemu_chr_fe_set_handlers(&chr_be1, NULL, NULL, NULL, NULL,
+ qemu_chr_fe_set_handlers(&chr_fe1, NULL, NULL, NULL, NULL,
NULL, NULL, true);
qemu_chr_be_write(base, (void *)"hello", 6);
g_assert_cmpint(h1.read_count, ==, 0);
g_assert_cmpint(strlen(data), !=, 0);
g_free(data);
- qemu_chr_fe_deinit(&chr_be1, false);
+ qemu_chr_fe_deinit(&chr_fe1, false);
qmp_chardev_remove("mux-label", &error);
g_assert_cmpstr(error_get_pretty(error), ==, "Chardev 'mux-label' is busy");
error_free(error);
- qemu_chr_fe_deinit(&chr_be2, false);
+ qemu_chr_fe_deinit(&chr_fe2, false);
qmp_chardev_remove("mux-label", &error_abort);
}
char *data;
FeHandler h = { 0, false, 0, false, };
Error *error = NULL;
- CharBackend chr_be;
+ CharFrontend chr_fe;
int ret, i;
#define RB_SIZE 128
qemu_opts_del(opts);
/* Attach hub to a frontend */
- qemu_chr_fe_init(&chr_be, hub, &error_abort);
- qemu_chr_fe_set_handlers(&chr_be,
+ qemu_chr_fe_init(&chr_fe, hub, &error_abort);
+ qemu_chr_fe_set_handlers(&chr_fe,
fe_can_read,
fe_read,
fe_event,
NULL, true);
/* Fails second time */
- qemu_chr_fe_init(&chr_be, hub, &error);
+ qemu_chr_fe_init(&chr_fe, hub, &error);
g_assert_cmpstr(error_get_pretty(error), ==, "chardev 'hub0' is already in use");
error_free(error);
error = NULL;
h.read_count = 0;
/* Write to frontend, chr_be */
- ret = qemu_chr_fe_write(&chr_be, (void *)"heyhey", 6);
+ ret = qemu_chr_fe_write(&chr_fe, (void *)"heyhey", 6);
g_assert_cmpint(ret, ==, 6);
data = qmp_ringbuf_read("chr1", RB_SIZE, false, 0, &error_abort);
error = NULL;
/* Finalize frontend */
- qemu_chr_fe_deinit(&chr_be, false);
+ qemu_chr_fe_deinit(&chr_fe, false);
/* Finalize hub0 */
qmp_chardev_remove("hub0", &error_abort);
qemu_opts_del(opts);
/* Attach hub to a frontend */
- qemu_chr_fe_init(&chr_be, hub, &error_abort);
- qemu_chr_fe_set_handlers(&chr_be,
+ qemu_chr_fe_init(&chr_fe, hub, &error_abort);
+ qemu_chr_fe_set_handlers(&chr_fe,
fe_can_read,
fe_read,
fe_event,
NULL, true);
/* Write to frontend, chr_be */
- ret = qemu_chr_fe_write(&chr_be, (void *)"thisis", 6);
+ ret = qemu_chr_fe_write(&chr_fe, (void *)"thisis", 6);
g_assert_cmpint(ret, ==, 6);
data = qmp_ringbuf_read("chr1", RB_SIZE, false, 0, &error_abort);
close(fd);
/* Add watch. 0 indicates no watches if nothing to wait for */
- ret = qemu_chr_fe_add_watch(&chr_be, G_IO_OUT | G_IO_HUP,
+ ret = qemu_chr_fe_add_watch(&chr_fe, G_IO_OUT | G_IO_HUP,
NULL, NULL);
g_assert_cmpint(ret, ==, 0);
* power of two to fit nicely the whole pipe buffer.
*/
len = 0;
- while ((ret = qemu_chr_fe_write(&chr_be, (void *)"thisisit", 8))
+ while ((ret = qemu_chr_fe_write(&chr_fe, (void *)"thisisit", 8))
!= -1) {
len += ret;
}
g_assert_cmpint(errno, ==, EAGAIN);
/* Further all writes should cause EAGAIN */
- ret = qemu_chr_fe_write(&chr_be, (void *)"b", 1);
+ ret = qemu_chr_fe_write(&chr_fe, (void *)"b", 1);
g_assert_cmpint(ret, ==, -1);
g_assert_cmpint(errno, ==, EAGAIN);
* Add watch. Non 0 indicates we have a blocked chardev, which
* can wakes us up when write is possible.
*/
- ret = qemu_chr_fe_add_watch(&chr_be, G_IO_OUT | G_IO_HUP,
+ ret = qemu_chr_fe_add_watch(&chr_fe, G_IO_OUT | G_IO_HUP,
NULL, NULL);
g_assert_cmpint(ret, !=, 0);
g_source_remove(ret);
* was already consumed and drained by the ring buffers, but
* pipe have not recieved that yet.
*/
- ret = qemu_chr_fe_write(&chr_be, (void *)"thisisit", 8);
+ ret = qemu_chr_fe_write(&chr_fe, (void *)"thisisit", 8);
g_assert_cmpint(ret, ==, 8);
- ret = qemu_chr_fe_write(&chr_be, (void *)"streamisrestored", 16);
+ ret = qemu_chr_fe_write(&chr_fe, (void *)"streamisrestored", 16);
g_assert_cmpint(ret, ==, 16);
data = qmp_ringbuf_read("chr1", RB_SIZE, false, 0, &error_abort);
g_free(pipe);
/* Finalize frontend */
- qemu_chr_fe_deinit(&chr_be, false);
+ qemu_chr_fe_deinit(&chr_fe, false);
/* Finalize hub0 */
qmp_chardev_remove("hub0", &error_abort);
Chardev *chr_client = opaque;
if (websock_check_http_headers((char *) buf, size)) {
- qemu_chr_fe_write(chr_client->be, ping, sizeof(ping));
+ qemu_chr_fe_write(chr_client->fe, ping, sizeof(ping));
} else if (buf[0] == 0x8a && buf[1] == 0x05) {
g_assert(strncmp((char *) buf + 2, "hello", 5) == 0);
- qemu_chr_fe_write(chr_client->be, binary, sizeof(binary));
+ qemu_chr_fe_write(chr_client->fe, binary, sizeof(binary));
} else {
g_assert(buf[0] == 0x88 && buf[1] == 0x16);
g_assert(strncmp((char *) buf + 4, "peer requested close", 10) == 0);
const char *port;
char *tmp;
char *handshake_port;
- CharBackend be;
- CharBackend client_be;
+ CharFrontend fe;
+ CharFrontend client_fe;
Chardev *chr_client;
Chardev *chr = qemu_chr_new("server",
"websocket:127.0.0.1:0,server=on,wait=off", NULL);
handshake_port = g_strdup_printf(handshake, port, port);
qobject_unref(qdict);
- qemu_chr_fe_init(&be, chr, &error_abort);
- qemu_chr_fe_set_handlers(&be, websock_server_can_read, websock_server_read,
+ qemu_chr_fe_init(&fe, chr, &error_abort);
+ qemu_chr_fe_set_handlers(&fe, websock_server_can_read, websock_server_read,
NULL, NULL, chr, NULL, true);
chr_client = qemu_chr_new("client", tmp, NULL);
- qemu_chr_fe_init(&client_be, chr_client, &error_abort);
- qemu_chr_fe_set_handlers(&client_be, websock_client_can_read,
+ qemu_chr_fe_init(&client_fe, chr_client, &error_abort);
+ qemu_chr_fe_set_handlers(&client_fe, websock_client_can_read,
websock_client_read,
NULL, NULL, chr_client, NULL, true);
g_free(tmp);
gchar *tmp_path = g_dir_make_tmp("qemu-test-char.XXXXXX", NULL);
gchar *tmp, *in, *out, *pipe = g_build_filename(tmp_path, "pipe", NULL);
Chardev *chr;
- CharBackend be;
+ CharFrontend c;
int ret, fd;
char buf[10];
FeHandler fe = { 0, };
g_assert_nonnull(chr);
g_free(tmp);
- qemu_chr_fe_init(&be, chr, &error_abort);
+ qemu_chr_fe_init(&c, chr, &error_abort);
- ret = qemu_chr_fe_write(&be, (void *)"pipe-out", 9);
+ ret = qemu_chr_fe_write(&c, (void *)"pipe-out", 9);
g_assert_cmpint(ret, ==, 9);
fd = open(out, O_RDWR);
g_assert_cmpint(ret, ==, 8);
close(fd);
- qemu_chr_fe_set_handlers(&be,
+ qemu_chr_fe_set_handlers(&c,
fe_can_read,
fe_read,
fe_event,
g_assert_cmpint(fe.read_count, ==, 8);
g_assert_cmpstr(fe.read_buf, ==, "pipe-in");
- qemu_chr_fe_deinit(&be, true);
+ qemu_chr_fe_deinit(&c, true);
g_assert(g_unlink(in) == 0);
g_assert(g_unlink(out) == 0);
GMainLoop *loop;
Chardev *chr;
bool conn_expected;
- CharBackend *be;
- CharBackend *client_be;
+ CharFrontend *fe;
+ CharFrontend *client_fe;
} SocketIdleData;
struct sockaddr_in other;
SocketIdleData d = { 0, };
Chardev *chr;
- CharBackend stack_be, *be = &stack_be;
+ CharFrontend stack_fe, *fe = &stack_fe;
socklen_t alen = sizeof(other);
int ret;
char buf[10];
if (reuse_chr) {
chr = reuse_chr;
- be = chr->be;
+ fe = chr->fe;
} else {
int port;
sock = make_udp_socket(&port);
chr = qemu_chr_new("client", tmp, NULL);
g_assert_nonnull(chr);
- qemu_chr_fe_init(be, chr, &error_abort);
+ qemu_chr_fe_init(fe, chr, &error_abort);
}
d.chr = chr;
- qemu_chr_fe_set_handlers(be, socket_can_read_hello, socket_read_hello,
+ qemu_chr_fe_set_handlers(fe, socket_can_read_hello, socket_read_hello,
NULL, NULL, &d, NULL, true);
ret = qemu_chr_write_all(chr, (uint8_t *)"hello", 5);
g_assert_cmpint(ret, ==, 5);
if (!reuse_chr) {
close(sock);
- qemu_chr_fe_deinit(be, true);
+ qemu_chr_fe_deinit(fe, true);
}
g_free(tmp);
}
typedef struct {
int event;
bool got_pong;
- CharBackend *be;
+ CharFrontend *fe;
} CharSocketTestData;
{
static bool first_error;
CharSocketTestData *data = opaque;
- CharBackend *be = data->be;
+ CharFrontend *fe = data->fe;
data->event = event;
switch (event) {
case CHR_EVENT_OPENED:
if (!first_error) {
first_error = true;
- qemu_chr_fe_disconnect(be);
+ qemu_chr_fe_disconnect(fe);
}
return;
case CHR_EVENT_CLOSED:
{
const CharSocketServerTestConfig *config = opaque;
Chardev *chr;
- CharBackend be = {0};
+ CharFrontend c = {0};
CharSocketTestData data = {0};
QObject *qaddr;
SocketAddress *addr;
visit_free(v);
qobject_unref(qaddr);
- qemu_chr_fe_init(&be, chr, &error_abort);
+ qemu_chr_fe_init(&c, chr, &error_abort);
reconnect:
data.event = -1;
- data.be = &be;
- qemu_chr_fe_set_handlers(&be, NULL, NULL,
+ data.fe = &c;
+ qemu_chr_fe_set_handlers(&c, NULL, NULL,
char_socket_event, NULL,
&data, NULL, true);
g_assert(data.event == -1);
data.event = -1;
/* Send a greeting to the client */
- ret = qemu_chr_fe_write_all(&be, (const uint8_t *)SOCKET_PING,
+ ret = qemu_chr_fe_write_all(&c, (const uint8_t *)SOCKET_PING,
sizeof(SOCKET_PING));
g_assert_cmpint(ret, ==, sizeof(SOCKET_PING));
g_assert(data.event == -1);
/* Setup a callback to receive the reply to our greeting */
- qemu_chr_fe_set_handlers(&be, char_socket_can_read,
+ qemu_chr_fe_set_handlers(&c, char_socket_can_read,
char_socket_read,
char_socket_event, NULL,
&data, NULL, true);
QIOChannelSocket *ioc;
char *optstr;
Chardev *chr;
- CharBackend be = {0};
+ CharFrontend c = {0};
CharSocketTestData data = {0};
SocketAddress *addr;
QemuThread thread;
&error_abort));
}
- qemu_chr_fe_init(&be, chr, &error_abort);
+ qemu_chr_fe_init(&c, chr, &error_abort);
reconnect:
data.event = -1;
- data.be = &be;
- qemu_chr_fe_set_handlers(&be, NULL, NULL,
+ data.fe = &c;
+ qemu_chr_fe_set_handlers(&c, NULL, NULL,
event_cb, NULL,
&data, NULL, true);
if (config->reconnect) {
g_assert(object_property_get_bool(OBJECT(chr), "connected", &error_abort));
/* Send a greeting to the server */
- ret = qemu_chr_fe_write_all(&be, (const uint8_t *)SOCKET_PING,
+ ret = qemu_chr_fe_write_all(&c, (const uint8_t *)SOCKET_PING,
sizeof(SOCKET_PING));
g_assert_cmpint(ret, ==, sizeof(SOCKET_PING));
g_assert(data.event == -1);
/* Setup a callback to receive the reply to our greeting */
- qemu_chr_fe_set_handlers(&be, char_socket_can_read,
+ qemu_chr_fe_set_handlers(&c, char_socket_can_read,
char_socket_read,
event_cb, NULL,
&data, NULL, true);
{
SocketAddress *incoming_addr = (gpointer) opaque;
Chardev *chr;
- CharBackend be = {0};
+ CharFrontend c = {0};
QObject *qaddr;
SocketAddress *addr;
Visitor *v;
visit_free(v);
qobject_unref(qaddr);
- qemu_chr_fe_init(&be, chr, &error_abort);
+ qemu_chr_fe_init(&c, chr, &error_abort);
- qemu_chr_fe_set_handlers(&be, char_socket_can_read, char_socket_discard_read,
+ qemu_chr_fe_set_handlers(&c, char_socket_can_read, char_socket_discard_read,
count_closed_event, NULL,
&closed, NULL, true);
/* switch the chardev to another context */
GMainContext *ctx = g_main_context_new();
- qemu_chr_fe_set_handlers(&be, char_socket_can_read, char_socket_discard_read,
+ qemu_chr_fe_set_handlers(&c, char_socket_can_read, char_socket_discard_read,
count_closed_event, NULL,
&closed, ctx, true);
static void char_file_fifo_test(void)
{
Chardev *chr;
- CharBackend be;
+ CharFrontend c;
char *tmp_path = g_dir_make_tmp("qemu-test-char.XXXXXX", NULL);
char *fifo = g_build_filename(tmp_path, "fifo", NULL);
char *out = g_build_filename(tmp_path, "out", NULL);
chr = qemu_chardev_new("label-file", TYPE_CHARDEV_FILE, &backend,
NULL, &error_abort);
- qemu_chr_fe_init(&be, chr, &error_abort);
- qemu_chr_fe_set_handlers(&be,
+ qemu_chr_fe_init(&c, chr, &error_abort);
+ qemu_chr_fe_set_handlers(&c,
fe_can_read,
fe_read,
fe_event,
g_assert_cmpint(fe.read_count, ==, 8);
g_assert_cmpstr(fe.read_buf, ==, "fifo-in");
- qemu_chr_fe_deinit(&be, true);
+ qemu_chr_fe_deinit(&c, true);
g_unlink(fifo);
g_free(fifo);
{
Error *err = NULL;
Chardev *chr;
- CharBackend be;
+ CharFrontend c;
int ret;
chr = qemu_chr_find("label-null");
QEMU_CHAR_FEATURE_RECONNECTABLE) == false);
/* check max avail */
- qemu_chr_fe_init(&be, chr, &error_abort);
- qemu_chr_fe_init(&be, chr, &err);
+ qemu_chr_fe_init(&c, chr, &error_abort);
+ qemu_chr_fe_init(&c, chr, &err);
error_free_or_abort(&err);
/* deinit & reinit */
- qemu_chr_fe_deinit(&be, false);
- qemu_chr_fe_init(&be, chr, &error_abort);
+ qemu_chr_fe_deinit(&c, false);
+ qemu_chr_fe_init(&c, chr, &error_abort);
- qemu_chr_fe_set_open(&be, true);
+ qemu_chr_fe_set_open(&c, true);
- qemu_chr_fe_set_handlers(&be,
+ qemu_chr_fe_set_handlers(&c,
fe_can_read,
fe_read,
fe_event,
NULL,
NULL, NULL, true);
- ret = qemu_chr_fe_write(&be, (void *)"buf", 4);
+ ret = qemu_chr_fe_write(&c, (void *)"buf", 4);
g_assert_cmpint(ret, ==, 4);
- qemu_chr_fe_deinit(&be, true);
+ qemu_chr_fe_deinit(&c, true);
}
static void char_invalid_test(void)
{
char *chr_args;
Chardev *chr;
- CharBackend be;
+ CharFrontend c;
gchar *tmp_path = g_dir_make_tmp("qemu-test-char.XXXXXX", NULL);
char *filename = g_build_filename(tmp_path, "file", NULL);
chr_args = g_strdup_printf("udp:127.0.0.1:%d", port);
chr = qemu_chr_new("chardev", chr_args, NULL);
- qemu_chr_fe_init(&be, chr, &error_abort);
+ qemu_chr_fe_init(&c, chr, &error_abort);
/* check that chardev operates correctly */
char_udp_test_internal(chr, sock);
/* set the handler that denies the hotswap */
- qemu_chr_fe_set_handlers(&be, NULL, NULL,
+ qemu_chr_fe_set_handlers(&c, NULL, NULL,
NULL, chardev_change_denied, NULL, NULL, true);
/* now, change is denied and has to keep the old backend operating */
ret = qmp_chardev_change("chardev", &backend, NULL);
g_assert(!ret);
- g_assert(be.chr == chr);
+ g_assert(c.chr == chr);
char_udp_test_internal(chr, sock);
/* now allow the change */
- qemu_chr_fe_set_handlers(&be, NULL, NULL,
+ qemu_chr_fe_set_handlers(&c, NULL, NULL,
NULL, chardev_change, NULL, NULL, true);
/* has to succeed now */
ret = qmp_chardev_change("chardev", &backend, &error_abort);
- g_assert(be.chr != chr);
+ g_assert(c.chr != chr);
close(sock);
- chr = be.chr;
+ chr = c.chr;
/* run the file chardev test */
char_file_test_internal(chr, filename);
CharChangeTestConfig *conf = (gpointer) opaque;
SocketAddress *addr;
Chardev *chr;
- CharBackend be;
+ CharFrontend fe;
ChardevReturn *ret;
QIOChannelSocket *ioc;
QemuThread thread;
qemu_thread_join(&thread);
}
- qemu_chr_fe_init(&be, chr, &error_abort);
+ qemu_chr_fe_init(&fe, chr, &error_abort);
/* allow chardev-change */
- qemu_chr_fe_set_handlers(&be, NULL, NULL,
+ qemu_chr_fe_set_handlers(&fe, NULL, NULL,
NULL, chardev_change, NULL, NULL, true);
if (conf->fail) {
ret = qmp_chardev_change("chardev", &fail_backend[conf->new_yank],
NULL);
g_assert_null(ret);
- g_assert(be.chr == chr);
+ g_assert(fe.chr == chr);
g_assert(is_yank_instance_registered() == conf->old_yank);
g_unsetenv("QTEST_SILENT_ERRORS");
} else {
qemu_thread_join(&thread);
}
g_assert_nonnull(ret);
- g_assert(be.chr != chr);
+ g_assert(fe.chr != chr);
g_assert(is_yank_instance_registered() == conf->new_yank);
}
- object_unparent(OBJECT(be.chr));
+ object_unparent(OBJECT(fe.chr));
object_unref(OBJECT(ioc));
qapi_free_ChardevReturn(ret);
qapi_free_SocketAddress(addr);
projects / thirdparty / qemu.git / commitdiff
