[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Qemu-devel] [PATCH v2 04/11] block: re-add BlkTransactionState
From: |
John Snow |
Subject: |
[Qemu-devel] [PATCH v2 04/11] block: re-add BlkTransactionState |
Date: |
Fri, 27 Mar 2015 15:19:58 -0400 |
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 <address@hidden>
---
blockdev.c | 66 +++++++++++++++++++++++++++++++++++++++++++++++++++++++-------
1 file changed, 59 insertions(+), 7 deletions(-)
diff --git a/blockdev.c b/blockdev.c
index 6247ca7..f806d40 100644
--- a/blockdev.c
+++ b/blockdev.c
@@ -1252,6 +1252,19 @@ typedef struct BlkActionOps {
} BlkActionOps;
/**
+ * BlkTransactionState:
+ * Object to track the job completion info for jobs launched
+ * by a transaction group.
+ *
+ * @jobs: A reference count that tracks how many jobs still need to complete.
+ * @actions: A list of all Actions in the Transaction.
+ */
+typedef struct BlkTransactionState {
+ int jobs;
+ QTAILQ_HEAD(actions, BlkActionState) actions;
+} BlkTransactionState;
+
+/**
* BlkActionState:
* Describes one Action's state within a Transaction.
*
@@ -1266,9 +1279,45 @@ 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);
+
+ /* The qmp_transaction function itself can be considered a pending job
+ * that should complete before pending action callbacks are executed,
+ * so increment the jobs remaining refcount to indicate this. */
+ bts->jobs = 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->jobs--;
+ if (bts->jobs == 0) {
+ destroy_blk_transaction_state(bts);
+ return NULL;
+ }
+ return bts;
+}
+
/* internal snapshot private data */
typedef struct InternalSnapshotState {
BlkActionState common;
@@ -1856,10 +1905,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();
@@ -1880,7 +1929,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) {
@@ -1889,7 +1938,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);
}
@@ -1900,18 +1949,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);
}
--
2.1.0
- [Qemu-devel] [PATCH v2 00/11] block: incremental backup transactions, John Snow, 2015/03/27
- [Qemu-devel] [PATCH v2 07/11] block: add delayed bitmap successor cleanup, John Snow, 2015/03/27
- [Qemu-devel] [PATCH v2 09/11] qmp: Add an implementation wrapper for qmp_drive_backup, John Snow, 2015/03/27
- [Qemu-devel] [PATCH v2 02/11] iotests: add transactional incremental backup test, John Snow, 2015/03/27
- [Qemu-devel] [PATCH v2 11/11] iotests: 124 - transactional failure test, John Snow, 2015/03/27
- [Qemu-devel] [PATCH v2 05/11] block: add transactional callbacks feature, John Snow, 2015/03/27
- [Qemu-devel] [PATCH v2 03/11] block: rename BlkTransactionState and BdrvActionOps, John Snow, 2015/03/27
- [Qemu-devel] [PATCH v2 06/11] block: add refcount to Job object, John Snow, 2015/03/27
- [Qemu-devel] [PATCH v2 10/11] block: drive_backup transaction callback support, John Snow, 2015/03/27
- [Qemu-devel] [PATCH v2 04/11] block: re-add BlkTransactionState,
John Snow <=
- [Qemu-devel] [PATCH v2 08/11] block: move transactions beneath qmp interfaces, John Snow, 2015/03/27
- [Qemu-devel] [PATCH v2 01/11] qapi: Add transaction support to block-dirty-bitmap operations, John Snow, 2015/03/27