From patchwork Mon Jul 25 01:44:37 2011 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Anthony Liguori X-Patchwork-Id: 106596 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from lists.gnu.org (lists.gnu.org [140.186.70.17]) (using TLSv1 with cipher AES256-SHA (256/256 bits)) (Client did not present a certificate) by ozlabs.org (Postfix) with ESMTPS id 1BAEEB6F75 for ; Mon, 25 Jul 2011 12:34:25 +1000 (EST) Received: from localhost ([::1]:55539 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1QlAF3-0005kY-4p for incoming@patchwork.ozlabs.org; Sun, 24 Jul 2011 21:45:57 -0400 Received: from eggs.gnu.org ([140.186.70.92]:42270) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1QlAEB-0003j4-Vs for qemu-devel@nongnu.org; Sun, 24 Jul 2011 21:45:08 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1QlAE9-0005S1-Kp for qemu-devel@nongnu.org; Sun, 24 Jul 2011 21:45:03 -0400 Received: from e9.ny.us.ibm.com ([32.97.182.139]:52996) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1QlAE9-0005Rq-IE for qemu-devel@nongnu.org; Sun, 24 Jul 2011 21:45:01 -0400 Received: from d01relay06.pok.ibm.com (d01relay06.pok.ibm.com [9.56.227.116]) by e9.ny.us.ibm.com (8.14.4/8.13.1) with ESMTP id p6P1CY2D024288 for ; Sun, 24 Jul 2011 21:12:34 -0400 Received: from d01av04.pok.ibm.com (d01av04.pok.ibm.com [9.56.224.64]) by d01relay06.pok.ibm.com (8.13.8/8.13.8/NCO v10.0) with ESMTP id p6P1j0hV1568892 for ; Sun, 24 Jul 2011 21:45:00 -0400 Received: from d01av04.pok.ibm.com (loopback [127.0.0.1]) by d01av04.pok.ibm.com (8.14.4/8.13.1/NCO v10.0 AVout) with ESMTP id p6P1ix8u006964 for ; Sun, 24 Jul 2011 21:45:00 -0400 Received: from titi.austin.rr.com (sig-9-65-207-230.mts.ibm.com [9.65.207.230]) by d01av04.pok.ibm.com (8.14.4/8.13.1/NCO v10.0 AVin) with ESMTP id p6P1itKk006824; Sun, 24 Jul 2011 21:44:59 -0400 From: Anthony Liguori To: qemu-devel@nongnu.org Date: Sun, 24 Jul 2011 20:44:37 -0500 Message-Id: <1311558293-5855-6-git-send-email-aliguori@us.ibm.com> X-Mailer: git-send-email 1.7.4.1 In-Reply-To: <1311558293-5855-1-git-send-email-aliguori@us.ibm.com> References: <1311558293-5855-1-git-send-email-aliguori@us.ibm.com> X-detected-operating-system: by eggs.gnu.org: GNU/Linux 2.6, seldom 2.4 (older, 4) X-Received-From: 32.97.182.139 Cc: Anthony Liguori Subject: [Qemu-devel] [PATCH 05/21] plug: add Plug property type X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.14 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org Sender: qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org Plug properties types allow composition within the object model. A plug is an object that is directly created from the current object, usually using the same memory as the current object. Realize state is propagated to any plugs assocatied with the object. Lifecycle is also propagated such that when a plug is added, its automatically initialized and the plug is finalized when the parent object is finalized. Signed-off-by: Anthony Liguori --- include/qemu/plug.h | 4 ++ qom/plug.c | 104 +++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 108 insertions(+), 0 deletions(-) diff --git a/include/qemu/plug.h b/include/qemu/plug.h index f6948a0..fdefa04 100644 --- a/include/qemu/plug.h +++ b/include/qemu/plug.h @@ -68,6 +68,10 @@ bool plug_get_realized(Plug *plug); void plug_realize_all(Plug *plug); void plug_unrealize_all(Plug *plug); +void plug_add_property_plug(Plug *plug, Plug *value, const char *typename, const char *name, ...); + +Plug *plug_get_property_plug(Plug *plug, Error **errp, const char *name, ...); + #include "qemu/plug-proptypes.h" #endif diff --git a/qom/plug.c b/qom/plug.c index 4a5f2fb..725cac2 100644 --- a/qom/plug.c +++ b/qom/plug.c @@ -159,12 +159,115 @@ bool plug_get_realized(Plug *plug) return plug->realized; } +static char *plug_get_property_str(Plug *plug, const char *name, Error **errp) +{ + StringOutputVisitor sov; + + string_output_visitor_init(&sov); + plug_get_property(plug, name, &sov.parent, errp); + + return qemu_strdup(sov.value); +} + +static void plug_propagate_realized(Plug *plug, const char *name, + const char *typename, int flags, + void *opaque) +{ + if (strstart(typename, "plug<", NULL)) { + char *child_name; + Plug *child_plug; + + child_name = plug_get_property_str(plug, name, NULL); + child_plug = PLUG(type_find_by_id(child_name)); + + plug_set_realized(child_plug, plug_get_realized(plug)); + + qemu_free(child_name); + } +} + +typedef struct PlugData +{ + const char *typename; + Plug *value; +} PlugData; + +static void plug_get_property__plug(Plug *plug, const char *name, Visitor *v, void *opaque, Error **errp) +{ + PlugData *data = opaque; + char *value; + + value = (char *)TYPE_INSTANCE(data->value)->id; + visit_type_str(v, &value, name, errp); +} + +static void plug_del_property__plug(Plug *plug, const char *name, void *opaque) +{ + PlugData *data = opaque; + + type_finalize(data->value); + qemu_free(data); +} + +void plug_add_property_plug(Plug *plug, Plug *value, const char *typename, + const char *name, ...) +{ + PlugData *data = qemu_mallocz(sizeof(*data)); + char fullid[MAX_NAME]; + char fulltype[MAX_TYPENAME]; + size_t off; + va_list ap; + + data->typename = typename; + data->value = value; + + snprintf(fulltype, sizeof(fulltype), "plug<%s>", typename); + + va_start(ap, name); + off = snprintf(fullid, sizeof(fullid), "%s::", + type_get_id(TYPE_INSTANCE(plug))); + vsnprintf(&fullid[off], sizeof(fullid) - off, name, ap); + va_end(ap); + + type_initialize(plug, typename, fullid); + + plug_add_property_full(plug, name, + plug_get_property__plug, + NULL, + plug_del_property__plug, + data, fulltype, PROP_F_READ); +} + +Plug *plug_get_property_plug(Plug *plug, Error **errp, const char *name, ...) +{ + char fullname[MAX_NAME]; + char *plugname; + Plug *value; + va_list ap; + + va_start(ap, name); + vsnprintf(fullname, sizeof(fullname), name, ap); + va_end(ap); + + plugname = plug_get_property_str(plug, fullname, errp); + if (error_is_set(errp)) { + return NULL; + } + + value = PLUG(type_find_by_id(plugname)); + + qemu_free(plugname); + + return value; +} + void plug_realize_all(Plug *plug) { /* This doesn't loop infinitely because the callbacks are only called when * the state changes. */ plug_set_realized(plug, true); plug_lock_all_properties(plug); + plug_foreach_property(plug, plug_propagate_realized, NULL); } void plug_unrealize_all(Plug *plug) @@ -173,6 +276,7 @@ void plug_unrealize_all(Plug *plug) * the state changes. */ plug_set_realized(plug, false); plug_unlock_all_properties(plug); + plug_foreach_property(plug, plug_propagate_realized, NULL); } static void plug_class_initfn(TypeClass *base_class)