Hi Paolo,
Are you plannig to respin this and related patches?
If yes, when?
On Tue, Apr 03, 2012 at 01:15:51PM +0200, Paolo Bonzini wrote:
> Since we had to move the state field from DeviceState to Object, we cannot
> delay the implementation of the "realized" property. The property is
> a trigger for two actions that propagate through the composition tree.
> "Realize" is called when the property becomes true, and propagates in
> pre-order; realize can fail if the values of the properties are not valid.
> "Unrealize" is called when the property becomes false, and propagates in
> post-order; unrealize cannot fail.
>
> Unrealize is also called by object_deinit, as a separate step before
> finalization.
>
> Realize/unrealize is separate from reset. Reset propagation is a thorny
> issue of its own. We expect classes that care to implement a reset method
> and call it from realize or realize_children, depending on whether
> pre-order or post-order is more appropriate.
>
> This patch adds four methods (realize, realize_children, unrealize,
> unrealize_children) to ObjectClass, together with a default implementation
> of realize_children and unrealize_children.
>
> Signed-off-by: Paolo Bonzini <pbonz...@redhat.com>
> ---
> include/qemu/object.h | 20 +++++++++++
> qom/object.c | 93
> +++++++++++++++++++++++++++++++++++++++++++++++++
> 2 files changed, 113 insertions(+)
>
> diff --git a/include/qemu/object.h b/include/qemu/object.h
> index 6db376d..6bded2a 100644
> --- a/include/qemu/object.h
> +++ b/include/qemu/object.h
> @@ -245,6 +245,10 @@ struct ObjectClass
>
> /*< public >*/
> Property *props;
> + void (*realize)(Object *obj, struct Error **errp);
> + void (*realize_children)(Object *obj, struct Error **errp);
> + void (*unrealize)(Object *obj);
> + void (*unrealize_children)(Object *obj);
> };
>
> typedef enum ObjectState {
> @@ -463,6 +467,22 @@ Object *object_new_with_type(Type type);
> void object_delete(Object *obj);
>
> /**
> + * object_realize_children:
> + * @obj: The object whose children should be realized.
> + *
> + * The default implementation of realize_children.
> + */
> +void object_realize_children(Object *obj, struct Error **errp);
> +
> +/**
> + * object_unrealize_children:
> + * @obj: The object whose children should be unrealize.
> + *
> + * The default implementation of unrealize_children.
> + */
> +void object_unrealize_children(Object *obj);
> +
> +/**
> * object_initialize_with_type:
> * @obj: A pointer to the memory to be used for the object.
> * @type: The type of the object to instantiate.
> diff --git a/qom/object.c b/qom/object.c
> index 3a6b37b..2a3753a 100644
> --- a/qom/object.c
> +++ b/qom/object.c
> @@ -259,6 +259,87 @@ static void object_interface_init(Object *obj,
> InterfaceImpl *iface)
> obj->interfaces = g_slist_prepend(obj->interfaces, iface_obj);
> }
>
> +static void object_get_realized(Object *obj, Visitor *v, void *opaque,
> + const char *name, Error **errp)
> +{
> + bool value = object_is_realized(obj);
> +
> + visit_type_bool(v, &value, name, errp);
> +}
> +
> +static void object_unrealize(Object *obj)
> +{
> + ObjectClass *klass = object_get_class(obj);
> +
> + if (klass->unrealize_children) {
> + klass->unrealize_children(obj);
> + }
> + if (obj->state != OBJECT_STATE_CREATED && klass->unrealize) {
> + klass->unrealize(obj);
> + }
> + obj->state = OBJECT_STATE_CREATED;
> +}
> +
> +static int object_unrealize_1(Object *obj, void *unused)
> +{
> + object_unrealize(obj);
> + return 0;
> +}
> +
> +void object_unrealize_children(Object *obj)
> +{
> + object_child_foreach(obj, object_unrealize_1, NULL);
> +}
> +
> +static void object_realize(Object *obj, Error **errp)
> +{
> + ObjectClass *klass = object_get_class(obj);
> +
> + if (obj->state != OBJECT_STATE_REALIZED && klass->realize) {
> + klass->realize(obj, errp);
> + }
> + obj->state = OBJECT_STATE_REALIZED;
> + if (klass->realize_children) {
> + klass->realize_children(obj, errp);
> + }
> +}
> +
> +static int object_realize_1(Object *obj, void *errp)
> +{
> + Error *err = NULL;
> + object_realize(obj, &err);
> + if (err) {
> + error_propagate((Error **)errp, err);
> + return 1;
> + }
> +
> + return 0;
> +}
> +
> +void object_realize_children(Object *obj, Error **errp)
> +{
> + object_child_foreach(obj, object_realize_1, errp);
> +}
> +
> +static void object_set_realized(Object *obj, Visitor *v, void *opaque,
> + const char *name, Error **errp)
> +{
> + bool value;
> + Error *err = NULL;
> +
> + visit_type_bool(v, &value, name, &err);
> + if (err) {
> + error_propagate(errp, err);
> + return;
> + }
> +
> + if (value) {
> + object_realize(obj, errp);
> + } else {
> + object_unrealize(obj);
> + }
> +}
> +
> static void object_init_with_type(Object *obj, TypeImpl *ti)
> {
> int i;
> @@ -337,6 +418,8 @@ void object_unparent(Object *obj)
>
> static void object_deinit(Object *obj, TypeImpl *type)
> {
> + object_property_set_bool(obj, false, "realized", NULL);
> +
> if (type->instance_finalize) {
> type->instance_finalize(obj);
> }
> @@ -1239,7 +1322,10 @@ static void object_instance_init(Object *obj)
> Property *prop;
>
> object_property_add_str(obj, "type", qdev_get_type, NULL, NULL);
> +
> obj->state = OBJECT_STATE_CREATED;
> + object_property_add(obj, "realized", "bool", object_get_realized,
> + object_set_realized, NULL, NULL, NULL);
>
> class = object_get_class(obj);
> do {
> @@ -1250,6 +1336,12 @@ static void object_instance_init(Object *obj)
> } while (class != object_class_by_name(TYPE_OBJECT));
> }
>
> +static void object_class_init(ObjectClass *klass, void *class_data)
> +{
> + klass->realize_children = object_realize_children;
> + klass->unrealize_children = object_unrealize_children;
> +}
> +
> static void register_types(void)
> {
> static TypeInfo interface_info = {
> @@ -1262,6 +1354,7 @@ static void register_types(void)
> .name = TYPE_OBJECT,
> .instance_size = sizeof(Object),
> .class_base_init = object_class_base_init,
> + .class_init = object_class_init,
> .instance_init = object_instance_init,
> .abstract = true,
> };
> --
> 1.7.9.3
>
