From patchwork Fri Jun 5 21:53:02 2015 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: John Snow X-Patchwork-Id: 481567 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from lists.gnu.org (lists.gnu.org [208.118.235.17]) (using TLSv1 with cipher AES256-SHA (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 54AB5140284 for ; Sat, 6 Jun 2015 07:53:50 +1000 (AEST) Received: from localhost ([::1]:49757 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1Z0zYi-0003of-IN for incoming@patchwork.ozlabs.org; Fri, 05 Jun 2015 17:53:48 -0400 Received: from eggs.gnu.org ([2001:4830:134:3::10]:53747) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1Z0zYG-0002uF-PS for qemu-devel@nongnu.org; Fri, 05 Jun 2015 17:53:21 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1Z0zYF-0006gi-Bx for qemu-devel@nongnu.org; Fri, 05 Jun 2015 17:53:20 -0400 Received: from mx1.redhat.com ([209.132.183.28]:43330) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1Z0zYC-0006dV-JW; Fri, 05 Jun 2015 17:53:16 -0400 Received: from int-mx09.intmail.prod.int.phx2.redhat.com (int-mx09.intmail.prod.int.phx2.redhat.com [10.5.11.22]) by mx1.redhat.com (Postfix) with ESMTPS id 2B6BC1BE36D; Fri, 5 Jun 2015 21:53:16 +0000 (UTC) Received: from scv.usersys.redhat.com (dhcp-17-29.bos.redhat.com [10.18.17.29]) by int-mx09.intmail.prod.int.phx2.redhat.com (8.14.4/8.14.4) with ESMTP id t55LrAn0018408; Fri, 5 Jun 2015 17:53:15 -0400 From: John Snow To: qemu-block@nongnu.org Date: Fri, 5 Jun 2015 17:53:02 -0400 Message-Id: <1433541188-13491-5-git-send-email-jsnow@redhat.com> In-Reply-To: <1433541188-13491-1-git-send-email-jsnow@redhat.com> References: <1433541188-13491-1-git-send-email-jsnow@redhat.com> X-Scanned-By: MIMEDefang 2.68 on 10.5.11.22 X-detected-operating-system: by eggs.gnu.org: GNU/Linux 3.x X-Received-From: 209.132.183.28 Cc: kwolf@redhat.com, famz@redhat.com, John Snow , qemu-devel@nongnu.org, mreitz@redhat.com, vsementsov@parallels.com, stefanha@redhat.com Subject: [Qemu-devel] [PATCH v6 04/10] block: re-add BlkTransactionState 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 Now that the structure formerly known as BlkTransactionState has been renamed to something sensible (BlkActionState), re-introduce an actual BlkTransactionState that actually manages state for the entire Transaction. In the process, convert the old QSIMPLEQ list of actions into a QTAILQ, to let us more efficiently delete items in arbitrary order, which will be more important in the future when some actions will expire at the end of the transaction, but others may persist until all callbacks triggered by the transaction are recollected. Signed-off-by: John Snow Reviewed-by: Max Reitz --- blockdev.c | 63 +++++++++++++++++++++++++++++++++++++++++++++++++++++++------- 1 file changed, 56 insertions(+), 7 deletions(-) diff --git a/blockdev.c b/blockdev.c index e30e986..d2c92e7 100644 --- a/blockdev.c +++ b/blockdev.c @@ -1253,6 +1253,19 @@ typedef struct BlkActionOps { } BlkActionOps; /** + * BlkTransactionState: + * Object to track the job completion info for jobs launched + * by a transaction group. + * + * @refcnt: A reference count for this object. + * @actions: A list of all Actions in the Transaction. + */ +typedef struct BlkTransactionState { + int refcnt; + QTAILQ_HEAD(actions, BlkActionState) actions; +} BlkTransactionState; + +/** * BlkActionState: * Describes one Action's state within a Transaction. * @@ -1267,9 +1280,42 @@ typedef struct BlkActionOps { struct BlkActionState { TransactionAction *action; const BlkActionOps *ops; - QSIMPLEQ_ENTRY(BlkActionState) entry; + QTAILQ_ENTRY(BlkActionState) entry; }; +static BlkTransactionState *new_blk_transaction_state(void) +{ + BlkTransactionState *bts = g_new0(BlkTransactionState, 1); + + bts->refcnt = 1; + QTAILQ_INIT(&bts->actions); + return bts; +} + +static void destroy_blk_transaction_state(BlkTransactionState *bts) +{ + BlkActionState *bas, *bas_next; + + /* The list should in normal cases be empty, + * but in case someone really just wants to kibosh the whole deal: */ + QTAILQ_FOREACH_SAFE(bas, &bts->actions, entry, bas_next) { + QTAILQ_REMOVE(&bts->actions, bas, entry); + g_free(bas); + } + + g_free(bts); +} + +static BlkTransactionState *transaction_job_complete(BlkTransactionState *bts) +{ + bts->refcnt--; + if (bts->refcnt == 0) { + destroy_blk_transaction_state(bts); + return NULL; + } + return bts; +} + /* internal snapshot private data */ typedef struct InternalSnapshotState { BlkActionState common; @@ -1870,10 +1916,10 @@ void qmp_transaction(TransactionActionList *dev_list, Error **errp) { TransactionActionList *dev_entry = dev_list; BlkActionState *state, *next; + BlkTransactionState *bts; Error *local_err = NULL; - QSIMPLEQ_HEAD(snap_bdrv_states, BlkActionState) snap_bdrv_states; - QSIMPLEQ_INIT(&snap_bdrv_states); + bts = new_blk_transaction_state(); /* drain all i/o before any operations */ bdrv_drain_all(); @@ -1894,7 +1940,7 @@ void qmp_transaction(TransactionActionList *dev_list, Error **errp) state = g_malloc0(ops->instance_size); state->ops = ops; state->action = dev_info; - QSIMPLEQ_INSERT_TAIL(&snap_bdrv_states, state, entry); + QTAILQ_INSERT_TAIL(&bts->actions, state, entry); state->ops->prepare(state, &local_err); if (local_err) { @@ -1903,7 +1949,7 @@ void qmp_transaction(TransactionActionList *dev_list, Error **errp) } } - QSIMPLEQ_FOREACH(state, &snap_bdrv_states, entry) { + QTAILQ_FOREACH(state, &bts->actions, entry) { if (state->ops->commit) { state->ops->commit(state); } @@ -1914,18 +1960,21 @@ void qmp_transaction(TransactionActionList *dev_list, Error **errp) delete_and_fail: /* failure, and it is all-or-none; roll back all operations */ - QSIMPLEQ_FOREACH(state, &snap_bdrv_states, entry) { + QTAILQ_FOREACH(state, &bts->actions, entry) { if (state->ops->abort) { state->ops->abort(state); } } exit: - QSIMPLEQ_FOREACH_SAFE(state, &snap_bdrv_states, entry, next) { + QTAILQ_FOREACH_SAFE(state, &bts->actions, entry, next) { if (state->ops->clean) { state->ops->clean(state); } + QTAILQ_REMOVE(&bts->actions, state, entry); g_free(state); } + + transaction_job_complete(bts); }