7d5983e3c8
Introduce the 'event-loop-base' abstract class, it'll hold the
properties common to all event loops and provide the necessary hooks for
their creation and maintenance. Then have iothread inherit from it.
EventLoopBaseClass is defined as user creatable and provides a hook for
its children to attach themselves to the user creatable class 'complete'
function. It also provides an update_params() callback to propagate
property changes onto its children.
The new 'event-loop-base' class will live in the root directory. It is
built on its own using the 'link_whole' option (there are no direct
function dependencies between the class and its children, it all happens
trough 'constructor' magic). And also imposes new compilation
dependencies:
qom <- event-loop-base <- blockdev (iothread.c)
And in subsequent patches:
qom <- event-loop-base <- qemuutil (util/main-loop.c)
All this forced some amount of reordering in meson.build:
- Moved qom build definition before qemuutil. Doing it the other way
around (i.e. moving qemuutil after qom) isn't possible as a lot of
core libraries that live in between the two depend on it.
- Process the 'hw' subdir earlier, as it introduces files into the
'qom' source set.
No functional changes intended.
Signed-off-by: Nicolas Saenz Julienne <nsaenzju@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Acked-by: Markus Armbruster <armbru@redhat.com>
Message-id: 20220425075723.20019-2-nsaenzju@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
105 lines
2.8 KiB
C
105 lines
2.8 KiB
C
/*
|
|
* QEMU event-loop base
|
|
*
|
|
* Copyright (C) 2022 Red Hat Inc
|
|
*
|
|
* Authors:
|
|
* Stefan Hajnoczi <stefanha@redhat.com>
|
|
* Nicolas Saenz Julienne <nsaenzju@redhat.com>
|
|
*
|
|
* This work is licensed under the terms of the GNU GPL, version 2 or later.
|
|
* See the COPYING file in the top-level directory.
|
|
*/
|
|
|
|
#include "qemu/osdep.h"
|
|
#include "qom/object_interfaces.h"
|
|
#include "qapi/error.h"
|
|
#include "sysemu/event-loop-base.h"
|
|
|
|
typedef struct {
|
|
const char *name;
|
|
ptrdiff_t offset; /* field's byte offset in EventLoopBase struct */
|
|
} EventLoopBaseParamInfo;
|
|
|
|
static EventLoopBaseParamInfo aio_max_batch_info = {
|
|
"aio-max-batch", offsetof(EventLoopBase, aio_max_batch),
|
|
};
|
|
|
|
static void event_loop_base_get_param(Object *obj, Visitor *v,
|
|
const char *name, void *opaque, Error **errp)
|
|
{
|
|
EventLoopBase *event_loop_base = EVENT_LOOP_BASE(obj);
|
|
EventLoopBaseParamInfo *info = opaque;
|
|
int64_t *field = (void *)event_loop_base + info->offset;
|
|
|
|
visit_type_int64(v, name, field, errp);
|
|
}
|
|
|
|
static void event_loop_base_set_param(Object *obj, Visitor *v,
|
|
const char *name, void *opaque, Error **errp)
|
|
{
|
|
EventLoopBaseClass *bc = EVENT_LOOP_BASE_GET_CLASS(obj);
|
|
EventLoopBase *base = EVENT_LOOP_BASE(obj);
|
|
EventLoopBaseParamInfo *info = opaque;
|
|
int64_t *field = (void *)base + info->offset;
|
|
int64_t value;
|
|
|
|
if (!visit_type_int64(v, name, &value, errp)) {
|
|
return;
|
|
}
|
|
|
|
if (value < 0) {
|
|
error_setg(errp, "%s value must be in range [0, %" PRId64 "]",
|
|
info->name, INT64_MAX);
|
|
return;
|
|
}
|
|
|
|
*field = value;
|
|
|
|
if (bc->update_params) {
|
|
bc->update_params(base, errp);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
static void event_loop_base_complete(UserCreatable *uc, Error **errp)
|
|
{
|
|
EventLoopBaseClass *bc = EVENT_LOOP_BASE_GET_CLASS(uc);
|
|
EventLoopBase *base = EVENT_LOOP_BASE(uc);
|
|
|
|
if (bc->init) {
|
|
bc->init(base, errp);
|
|
}
|
|
}
|
|
|
|
static void event_loop_base_class_init(ObjectClass *klass, void *class_data)
|
|
{
|
|
UserCreatableClass *ucc = USER_CREATABLE_CLASS(klass);
|
|
ucc->complete = event_loop_base_complete;
|
|
|
|
object_class_property_add(klass, "aio-max-batch", "int",
|
|
event_loop_base_get_param,
|
|
event_loop_base_set_param,
|
|
NULL, &aio_max_batch_info);
|
|
}
|
|
|
|
static const TypeInfo event_loop_base_info = {
|
|
.name = TYPE_EVENT_LOOP_BASE,
|
|
.parent = TYPE_OBJECT,
|
|
.instance_size = sizeof(EventLoopBase),
|
|
.class_size = sizeof(EventLoopBaseClass),
|
|
.class_init = event_loop_base_class_init,
|
|
.abstract = true,
|
|
.interfaces = (InterfaceInfo[]) {
|
|
{ TYPE_USER_CREATABLE },
|
|
{ }
|
|
}
|
|
};
|
|
|
|
static void register_types(void)
|
|
{
|
|
type_register_static(&event_loop_base_info);
|
|
}
|
|
type_init(register_types);
|