motorhead/qemu
1
0
Fork 0
mirror of https://github.com/Motorhead1991/qemu.git synced 2025-08-08 10:13:56 -06:00
Code Issues Projects Releases Packages Wiki Activity Actions

chardev/char-hub: implement backend chardev aggregator

Browse source 
This patch implements a new chardev backend `hub` device, which
aggregates input from multiple backend devices and forwards it to a
single frontend device. Additionally, `hub` device takes the output
from the frontend device and sends it back to all the connected
backend devices. This allows for seamless interaction between
different backend devices and a single frontend interface.

The idea of the change is trivial: keep list of backend devices
(up to 4), init them on demand and forward data buffer back and
forth.

The following is QEMU command line example:

   -chardev pty,path=/tmp/pty,id=pty0 \
   -chardev vc,id=vc0 \
   -chardev hub,id=hub0,chardevs.0=pty0,chardevs.1=vc0 \
   -device virtconsole,chardev=hub0 \
   -vnc 0.0.0.0:0

Which creates 2 backend devices: text virtual console (`vc0`) and a
pseudo TTY (`pty0`) connected to the single virtio hvc console with
the backend aggregator (`hub0`) help. `vc0` renders text to an image,
which can be shared over the VNC protocol.  `pty0` is a pseudo TTY
backend which provides biderectional communication to the virtio hvc
console.

'chardevs.N' list syntax is used for the sake of compatibility with
the representation of JSON lists in 'key=val' pairs format of the
util/keyval.c, despite the fact that modern QAPI way of parsing,
namely qobject_input_visitor_new_str(), is not used. Choice of keeping
QAPI list syntax may help to smoothly switch to modern parsing in the
future.

Signed-off-by: Roman Penyaev <r.peniaev@gmail.com>
Reviewed-by: "Marc-André Lureau" <marcandre.lureau@redhat.com>
Cc: qemu-devel@nongnu.org
Message-ID: <20250123085327.965501-3-r.peniaev@gmail.com>
This commit is contained in:
Roman Penyaev 2025-01-23 09:53:22 +01:00 • committed by Marc-André Lureau
parent 4e059a9d96
commit b66ed23238
6 changed files with 401 additions and 3 deletions
Download patch file Download diff file Expand all files Collapse all files

301
chardev/char-hub.c Normal file
View file

@ -0,0 +1,301 @@
/*
* QEMU Character Hub Device
*
* Author: Roman Penyaev <r.peniaev@gmail.com>
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include "qemu/osdep.h"
#include "qapi/error.h"
#include "qemu/option.h"
#include "chardev/char.h"
#include "chardev-internal.h"
/*
* Character hub device aggregates input from multiple backend devices
* and forwards it to a single frontend device. Additionally, hub
* device takes the output from the frontend device and sends it back
* to all the connected backend devices.
*/
/*
* Write to all backends. Different backend devices accept data with
* various rate, so it is quite possible that one device returns less,
* then others. In this case we return minimum to the caller,
* expecting caller will repeat operation soon. When repeat happens
* send to the devices which consume data faster must be avoided
* for obvious reasons not to send data, which was already sent.
* Called with chr_write_lock held.
*/
static int hub_chr_write(Chardev *chr, const uint8_t *buf, int len)
{
HubChardev *d = HUB_CHARDEV(chr);
int r, i, ret = len;
unsigned int written;
/* Invalidate index on every write */
d->be_eagain_ind = -1;
for (i = 0; i < d->be_cnt; i++) {
if (!d->backends[i].be.chr->be_open) {
/* Skip closed backend */
continue;
}
written = d->be_written[i] - d->be_min_written;
if (written) {
/* Written in the previous call so take into account */
ret = MIN(written, ret);
continue;
}
r = qemu_chr_fe_write(&d->backends[i].be, buf, len);
if (r < 0) {
if (errno == EAGAIN) {
/* Set index and expect to be called soon on watch wake up */
d->be_eagain_ind = i;
}
return r;
}
d->be_written[i] += r;
ret = MIN(r, ret);
}
d->be_min_written += ret;
return ret;
}
static int hub_chr_can_read(void *opaque)
{
HubCharBackend *backend = opaque;
CharBackend *fe = backend->hub->parent.be;
if (fe && fe->chr_can_read) {
return fe->chr_can_read(fe->opaque);
}
return 0;
}
static void hub_chr_read(void *opaque, const uint8_t *buf, int size)
{
HubCharBackend *backend = opaque;
CharBackend *fe = backend->hub->parent.be;
if (fe && fe->chr_read) {
fe->chr_read(fe->opaque, buf, size);
}
}
static void hub_chr_event(void *opaque, QEMUChrEvent event)
{
HubCharBackend *backend = opaque;
HubChardev *d = backend->hub;
CharBackend *fe = d->parent.be;
if (event == CHR_EVENT_OPENED) {
/*
* Catch up with what was already written while this backend
* was closed
*/
d->be_written[backend->be_ind] = d->be_min_written;
if (d->be_event_opened_cnt++) {
/* Ignore subsequent open events from other backends */
return;
}
} else if (event == CHR_EVENT_CLOSED) {
if (!d->be_event_opened_cnt) {
/* Don't go below zero. Probably assert is better */
return;
}
if (--d->be_event_opened_cnt) {
/* Serve only the last one close event */
return;
}
}
if (fe && fe->chr_event) {
fe->chr_event(fe->opaque, event);
}
}
static GSource *hub_chr_add_watch(Chardev *s, GIOCondition cond)
{
HubChardev *d = HUB_CHARDEV(s);
Chardev *chr;
ChardevClass *cc;
if (d->be_eagain_ind == -1) {
return NULL;
}
assert(d->be_eagain_ind < d->be_cnt);
chr = qemu_chr_fe_get_driver(&d->backends[d->be_eagain_ind].be);
cc = CHARDEV_GET_CLASS(chr);
if (!cc->chr_add_watch) {
return NULL;
}
return cc->chr_add_watch(chr, cond);
}
static bool hub_chr_attach_chardev(HubChardev *d, Chardev *chr,
Error **errp)
{
bool ret;
if (d->be_cnt >= MAX_HUB) {
error_setg(errp, "hub: too many uses of chardevs '%s'"
" (maximum is " stringify(MAX_HUB) ")",
d->parent.label);
return false;
}
ret = qemu_chr_fe_init(&d->backends[d->be_cnt].be, chr, errp);
if (ret) {
d->backends[d->be_cnt].hub = d;
d->backends[d->be_cnt].be_ind = d->be_cnt;
d->be_cnt += 1;
}
return ret;
}
static void char_hub_finalize(Object *obj)
{
HubChardev *d = HUB_CHARDEV(obj);
int i;
for (i = 0; i < d->be_cnt; i++) {
qemu_chr_fe_deinit(&d->backends[i].be, false);
}
}
static void hub_chr_update_read_handlers(Chardev *chr)
{
HubChardev *d = HUB_CHARDEV(chr);
int i;
for (i = 0; i < d->be_cnt; i++) {
qemu_chr_fe_set_handlers_full(&d->backends[i].be,
hub_chr_can_read,
hub_chr_read,
hub_chr_event,
NULL,
&d->backends[i],
chr->gcontext, true, false);
}
}
static void qemu_chr_open_hub(Chardev *chr,
ChardevBackend *backend,
bool *be_opened,
Error **errp)
{
ChardevHub *hub = backend->u.hub.data;
HubChardev *d = HUB_CHARDEV(chr);
strList *list = hub->chardevs;
d->be_eagain_ind = -1;
if (list == NULL) {
error_setg(errp, "hub: 'chardevs' list is not defined");
return;
}
while (list) {
Chardev *s;
s = qemu_chr_find(list->value);
if (s == NULL) {
error_setg(errp, "hub: chardev can't be found by id '%s'",
list->value);
return;
}
if (CHARDEV_IS_HUB(s) || CHARDEV_IS_MUX(s)) {
error_setg(errp, "hub: multiplexers and hub devices can't be "
"stacked, check chardev '%s', chardev should not "
"be a hub device or have 'mux=on' enabled",
list->value);
return;
}
if (!hub_chr_attach_chardev(d, s, errp)) {
return;
}
list = list->next;
}
/* Closed until an explicit event from backend */
*be_opened = false;
}
static void qemu_chr_parse_hub(QemuOpts *opts, ChardevBackend *backend,
Error **errp)
{
ChardevHub *hub;
strList **tail;
int i;
backend->type = CHARDEV_BACKEND_KIND_HUB;
hub = backend->u.hub.data = g_new0(ChardevHub, 1);
qemu_chr_parse_common(opts, qapi_ChardevHub_base(hub));
tail = &hub->chardevs;
for (i = 0; i < MAX_HUB; i++) {
char optbuf[16];
const char *dev;
snprintf(optbuf, sizeof(optbuf), "chardevs.%u", i);
dev = qemu_opt_get(opts, optbuf);
if (!dev) {
break;
}
QAPI_LIST_APPEND(tail, g_strdup(dev));
}
}
static void char_hub_class_init(ObjectClass *oc, void *data)
{
ChardevClass *cc = CHARDEV_CLASS(oc);
cc->parse = qemu_chr_parse_hub;
cc->open = qemu_chr_open_hub;
cc->chr_write = hub_chr_write;
cc->chr_add_watch = hub_chr_add_watch;
/* We handle events from backends only */
cc->chr_be_event = NULL;
cc->chr_update_read_handler = hub_chr_update_read_handlers;
}
static const TypeInfo char_hub_type_info = {
.name = TYPE_CHARDEV_HUB,
.parent = TYPE_CHARDEV,
.class_init = char_hub_class_init,
.instance_size = sizeof(HubChardev),
.instance_finalize = char_hub_finalize,
};
static void register_types(void)
{
type_register_static(&char_hub_type_info);
}
type_init(register_types);

23
chardev/char.c
View file

@ -943,7 +943,26 @@ QemuOptsList qemu_chardev_opts = {
},{
.name = "chardev",
.type = QEMU_OPT_STRING,
},
/*
* Multiplexer options. Follows QAPI array syntax.
* See MAX_HUB macro to obtain array capacity.
*/
{
.name = "chardevs.0",
.type = QEMU_OPT_STRING,
},{
.name = "chardevs.1",
.type = QEMU_OPT_STRING,
},{
.name = "chardevs.2",
.type = QEMU_OPT_STRING,
},{
.name = "chardevs.3",
.type = QEMU_OPT_STRING,
},
{
.name = "append",
.type = QEMU_OPT_BOOL,
},{
@ -1106,8 +1125,8 @@ ChardevReturn *qmp_chardev_change(const char *id, ChardevBackend *backend,
return NULL;
}
if (CHARDEV_IS_MUX(chr)) {
error_setg(errp, "Mux device hotswap not supported yet");
if (CHARDEV_IS_MUX(chr) || CHARDEV_IS_HUB(chr)) {
error_setg(errp, "For mux or hub device hotswap is not supported yet");
return NULL;
}

51
chardev/chardev-internal.h
View file

@ -29,13 +29,16 @@
#include "chardev/char-fe.h"
#include "qom/object.h"
#define MAX_HUB 4
#define MAX_MUX 4
#define MUX_BUFFER_SIZE 32 /* Must be a power of 2. */
#define MUX_BUFFER_MASK (MUX_BUFFER_SIZE - 1)
struct MuxChardev {
Chardev parent;
/* Linked frontends */
CharBackend *backends[MAX_MUX];
/* Linked backend */
CharBackend chr;
unsigned long mux_bitset;
int focus;
@ -53,11 +56,57 @@ struct MuxChardev {
int64_t timestamps_start;
};
typedef struct MuxChardev MuxChardev;
typedef struct HubChardev HubChardev;
typedef struct HubCharBackend HubCharBackend;
/*
* Back-pointer on a hub, actual backend and its index in
* `hub->backends` array
*/
struct HubCharBackend {
HubChardev *hub;
CharBackend be;
unsigned int be_ind;
};
struct HubChardev {
Chardev parent;
/* Linked backends */
HubCharBackend backends[MAX_HUB];
/*
* Number of backends attached to this hub. Once attached, a
* backend can't be detached, so the counter is only increasing.
* To safely remove a backend, hub has to be removed first.
*/
unsigned int be_cnt;
/*
* Number of CHR_EVEN_OPENED events from all backends. Needed to
* send CHR_EVEN_CLOSED only when counter goes to zero.
*/
unsigned int be_event_opened_cnt;
/*
* Counters of written bytes from a single frontend device
* to multiple backend devices.
*/
unsigned int be_written[MAX_HUB];
unsigned int be_min_written;
/*
* Index of a backend device which got EAGAIN on last write,
* -1 is invalid index.
*/
int be_eagain_ind;
};
typedef struct HubChardev HubChardev;
DECLARE_INSTANCE_CHECKER(MuxChardev, MUX_CHARDEV,
TYPE_CHARDEV_MUX)
#define CHARDEV_IS_MUX(chr) \
DECLARE_INSTANCE_CHECKER(HubChardev, HUB_CHARDEV,
TYPE_CHARDEV_HUB)
#define CHARDEV_IS_MUX(chr) \
object_dynamic_cast(OBJECT(chr), TYPE_CHARDEV_MUX)
#define CHARDEV_IS_HUB(chr) \
object_dynamic_cast(OBJECT(chr), TYPE_CHARDEV_HUB)
bool mux_chr_attach_frontend(MuxChardev *d, CharBackend *b,
unsigned int *tag, Error **errp);

1
chardev/meson.build
View file

@ -3,6 +3,7 @@ chardev_ss.add(files(
'char-file.c',
'char-io.c',
'char-mux.c',
'char-hub.c',
'char-null.c',
'char-pipe.c',
'char-ringbuf.c',