From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from eggs.gnu.org ([208.118.235.92]:41509) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1Scnyc-0004EI-9k for qemu-devel@nongnu.org; Thu, 07 Jun 2012 21:27:00 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1ScnyZ-0002QW-VS for qemu-devel@nongnu.org; Thu, 07 Jun 2012 21:26:57 -0400 Received: from mail-gg0-f173.google.com ([209.85.161.173]:48625) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1ScnyZ-0002QK-Qv for qemu-devel@nongnu.org; Thu, 07 Jun 2012 21:26:55 -0400 Received: by ggnp1 with SMTP id p1so1035779ggn.4 for ; Thu, 07 Jun 2012 18:26:54 -0700 (PDT) Message-ID: <4FD154D8.3000105@codemonkey.ws> Date: Fri, 08 Jun 2012 09:26:48 +0800 From: Anthony Liguori MIME-Version: 1.0 References: <1339097465-22977-1-git-send-email-afaerber@suse.de> <1339097465-22977-7-git-send-email-afaerber@suse.de> In-Reply-To: <1339097465-22977-7-git-send-email-afaerber@suse.de> Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: 8bit Subject: Re: [Qemu-devel] [PATCH qom-next 6/7] qom: Add "realized" property List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: =?UTF-8?B?QW5kcmVhcyBGw6RyYmVy?= Cc: pbonzini@redhat.com, qemu-devel@nongnu.org On 06/08/2012 03:31 AM, Andreas Färber wrote: > From: Paolo Bonzini > > 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. > > 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 > Signed-off-by: Andreas Färber Reviewed-by: Anthony Liguori Regards, Anthony Liguori > --- > include/qemu/object.h | 20 +++++++++++ > qom/object.c | 89 +++++++++++++++++++++++++++++++++++++++++++++++++ > 2 files changed, 109 insertions(+), 0 deletions(-) > > diff --git a/include/qemu/object.h b/include/qemu/object.h > index 4ea1187..05ea711 100644 > --- a/include/qemu/object.h > +++ b/include/qemu/object.h > @@ -246,6 +246,10 @@ struct ObjectClass > /*< public>*/ > Property *props; > const char *(*get_id)(Object *); > + 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 { > @@ -464,6 +468,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 a639348..40bc23a 100644 > --- a/qom/object.c > +++ b/qom/object.c > @@ -265,6 +265,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_INITIALIZED&& klass->unrealize) { > + klass->unrealize(obj); > + } > + obj->state = OBJECT_STATE_INITIALIZED; > +} > + > +static int object_unrealize_one(Object *obj, void *unused) > +{ > + object_unrealize(obj); > + return 0; > +} > + > +void object_unrealize_children(Object *obj) > +{ > + object_child_foreach(obj, object_unrealize_one, 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_one(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_one, 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; > @@ -373,6 +454,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); > } > @@ -1277,6 +1360,9 @@ static void object_instance_init(Object *obj) > > object_property_add_str(obj, "type", qdev_get_type, NULL, NULL); > > + object_property_add(obj, "realized", "bool", object_get_realized, > + object_set_realized, NULL, NULL, NULL); > + > class = object_get_class(obj); > do { > for (prop = OBJECT_CLASS(class)->props; prop&& prop->name; prop++) { > @@ -1289,6 +1375,8 @@ static void object_instance_init(Object *obj) > static void object_class_init(ObjectClass *klass, void *class_data) > { > klass->get_id = object_instance_get_id; > + klass->realize_children = object_realize_children; > + klass->unrealize_children = object_unrealize_children; > } > > static void register_types(void) > @@ -1303,6 +1391,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, > .class_init = object_class_init, > .abstract = true,