Skip to content

Commit

Permalink
block: rename BlkTransactionState and BdrvActionOps
Browse files Browse the repository at this point in the history 
These structures are misnomers, somewhat.

(1) BlockTransactionState is not state for a transaction,
    but is rather state for a single transaction action.
    Rename it "BlkActionState" to be more accurate.

(2) The BdrvActionOps describes operations for the BlkActionState,
    above. This name might imply a 'BdrvAction' or a 'BdrvActionState',
    which there isn't.
    Rename this to 'BlkActionOps' to match 'BlkActionState'.

Lastly, update the surrounding in-line documentation and comments
to reflect the current nature of how Transactions operate.

This patch changes only comments and names, and should not affect
behavior in any way.

Reviewed-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Fam Zheng <famz@redhat.com>
Signed-off-by: John Snow <jsnow@redhat.com>
Message-id: 1446765200-3054-4-git-send-email-jsnow@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
  • Loading branch information
@jnsnow @kevmw
jnsnow authored and kevmw committed Nov 12, 2015
1 parent 749ad5e commit 50f43f0
Showing 1 changed file with 69 additions and 55 deletions.
124 changes: 69 additions & 55 deletions blockdev.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -1359,44 +1359,58 @@ static BdrvDirtyBitmap *block_dirty_bitmap_lookup(const char *node,

/* New and old BlockDriverState structs for atomic group operations */

typedef struct BlkTransactionState BlkTransactionState;
typedef struct BlkActionState BlkActionState;

/* Only prepare() may fail. In a single transaction, only one of commit() or
abort() will be called, clean() will always be called if it present. */
typedef struct BdrvActionOps {
/* Size of state struct, in bytes. */
/**
* BlkActionOps:
* Table of operations that define an Action.
*
* @instance_size: Size of state struct, in bytes.
* @prepare: Prepare the work, must NOT be NULL.
* @commit: Commit the changes, can be NULL.
* @abort: Abort the changes on fail, can be NULL.
* @clean: Clean up resources after all transaction actions have called
* commit() or abort(). Can be NULL.
*
* Only prepare() may fail. In a single transaction, only one of commit() or
* abort() will be called. clean() will always be called if it is present.
*/
typedef struct BlkActionOps {
size_t instance_size;
/* Prepare the work, must NOT be NULL. */
void (*prepare)(BlkTransactionState *common, Error **errp);
/* Commit the changes, can be NULL. */
void (*commit)(BlkTransactionState *common);
/* Abort the changes on fail, can be NULL. */
void (*abort)(BlkTransactionState *common);
/* Clean up resource in the end, can be NULL. */
void (*clean)(BlkTransactionState *common);
} BdrvActionOps;
void (*prepare)(BlkActionState *common, Error **errp);
void (*commit)(BlkActionState *common);
void (*abort)(BlkActionState *common);
void (*clean)(BlkActionState *common);
} BlkActionOps;

/*
* This structure must be arranged as first member in child type, assuming
* that compiler will also arrange it to the same address with parent instance.
* Later it will be used in free().
/**
* BlkActionState:
* Describes one Action's state within a Transaction.
*
* @action: QAPI-defined enum identifying which Action to perform.
* @ops: Table of ActionOps this Action can perform.
* @entry: List membership for all Actions in this Transaction.
*
* This structure must be arranged as first member in a subclassed type,
* assuming that the compiler will also arrange it to the same offsets as the
* base class.
*/
struct BlkTransactionState {
struct BlkActionState {
TransactionAction *action;
const BdrvActionOps *ops;
QSIMPLEQ_ENTRY(BlkTransactionState) entry;
const BlkActionOps *ops;
QSIMPLEQ_ENTRY(BlkActionState) entry;
};

/* internal snapshot private data */
typedef struct InternalSnapshotState {
BlkTransactionState common;
BlkActionState common;
BlockDriverState *bs;
AioContext *aio_context;
QEMUSnapshotInfo sn;
bool created;
} InternalSnapshotState;

static void internal_snapshot_prepare(BlkTransactionState *common,
static void internal_snapshot_prepare(BlkActionState *common,
Error **errp)
{
Error *local_err = NULL;
Expand Down Expand Up @@ -1495,7 +1509,7 @@ static void internal_snapshot_prepare(BlkTransactionState *common,
state->created = true;
}

static void internal_snapshot_abort(BlkTransactionState *common)
static void internal_snapshot_abort(BlkActionState *common)
{
InternalSnapshotState *state =
DO_UPCAST(InternalSnapshotState, common, common);
Expand All @@ -1518,7 +1532,7 @@ static void internal_snapshot_abort(BlkTransactionState *common)
}
}

static void internal_snapshot_clean(BlkTransactionState *common)
static void internal_snapshot_clean(BlkActionState *common)
{
InternalSnapshotState *state = DO_UPCAST(InternalSnapshotState,
common, common);
Expand All @@ -1533,13 +1547,13 @@ static void internal_snapshot_clean(BlkTransactionState *common)

/* external snapshot private data */
typedef struct ExternalSnapshotState {
BlkTransactionState common;
BlkActionState common;
BlockDriverState *old_bs;
BlockDriverState *new_bs;
AioContext *aio_context;
} ExternalSnapshotState;

static void external_snapshot_prepare(BlkTransactionState *common,
static void external_snapshot_prepare(BlkActionState *common,
Error **errp)
{
int flags = 0, ret;
Expand Down Expand Up @@ -1686,7 +1700,7 @@ static void external_snapshot_prepare(BlkTransactionState *common,
}
}

static void external_snapshot_commit(BlkTransactionState *common)
static void external_snapshot_commit(BlkActionState *common)
{
ExternalSnapshotState *state =
DO_UPCAST(ExternalSnapshotState, common, common);
Expand All @@ -1702,7 +1716,7 @@ static void external_snapshot_commit(BlkTransactionState *common)
NULL);
}

static void external_snapshot_abort(BlkTransactionState *common)
static void external_snapshot_abort(BlkActionState *common)
{
ExternalSnapshotState *state =
DO_UPCAST(ExternalSnapshotState, common, common);
Expand All @@ -1711,7 +1725,7 @@ static void external_snapshot_abort(BlkTransactionState *common)
}
}

static void external_snapshot_clean(BlkTransactionState *common)
static void external_snapshot_clean(BlkActionState *common)
{
ExternalSnapshotState *state =
DO_UPCAST(ExternalSnapshotState, common, common);
Expand All @@ -1722,13 +1736,13 @@ static void external_snapshot_clean(BlkTransactionState *common)
}

typedef struct DriveBackupState {
BlkTransactionState common;
BlkActionState common;
BlockDriverState *bs;
AioContext *aio_context;
BlockJob *job;
} DriveBackupState;

static void drive_backup_prepare(BlkTransactionState *common, Error **errp)
static void drive_backup_prepare(BlkActionState *common, Error **errp)
{
DriveBackupState *state = DO_UPCAST(DriveBackupState, common, common);
BlockBackend *blk;
Expand Down Expand Up @@ -1773,7 +1787,7 @@ static void drive_backup_prepare(BlkTransactionState *common, Error **errp)
state->job = state->bs->job;
}

static void drive_backup_abort(BlkTransactionState *common)
static void drive_backup_abort(BlkActionState *common)
{
DriveBackupState *state = DO_UPCAST(DriveBackupState, common, common);
BlockDriverState *bs = state->bs;
Expand All @@ -1784,7 +1798,7 @@ static void drive_backup_abort(BlkTransactionState *common)
}
}

static void drive_backup_clean(BlkTransactionState *common)
static void drive_backup_clean(BlkActionState *common)
{
DriveBackupState *state = DO_UPCAST(DriveBackupState, common, common);

Expand All @@ -1795,13 +1809,13 @@ static void drive_backup_clean(BlkTransactionState *common)
}

typedef struct BlockdevBackupState {
BlkTransactionState common;
BlkActionState common;
BlockDriverState *bs;
BlockJob *job;
AioContext *aio_context;
} BlockdevBackupState;

static void blockdev_backup_prepare(BlkTransactionState *common, Error **errp)
static void blockdev_backup_prepare(BlkActionState *common, Error **errp)
{
BlockdevBackupState *state = DO_UPCAST(BlockdevBackupState, common, common);
BlockdevBackup *backup;
Expand Down Expand Up @@ -1853,7 +1867,7 @@ static void blockdev_backup_prepare(BlkTransactionState *common, Error **errp)
state->job = state->bs->job;
}

static void blockdev_backup_abort(BlkTransactionState *common)
static void blockdev_backup_abort(BlkActionState *common)
{
BlockdevBackupState *state = DO_UPCAST(BlockdevBackupState, common, common);
BlockDriverState *bs = state->bs;
Expand All @@ -1864,7 +1878,7 @@ static void blockdev_backup_abort(BlkTransactionState *common)
}
}

static void blockdev_backup_clean(BlkTransactionState *common)
static void blockdev_backup_clean(BlkActionState *common)
{
BlockdevBackupState *state = DO_UPCAST(BlockdevBackupState, common, common);

Expand All @@ -1875,23 +1889,23 @@ static void blockdev_backup_clean(BlkTransactionState *common)
}

typedef struct BlockDirtyBitmapState {
BlkTransactionState common;
BlkActionState common;
BdrvDirtyBitmap *bitmap;
BlockDriverState *bs;
AioContext *aio_context;
HBitmap *backup;
bool prepared;
} BlockDirtyBitmapState;

static void block_dirty_bitmap_add_prepare(BlkTransactionState *common,
static void block_dirty_bitmap_add_prepare(BlkActionState *common,
Error **errp)
{
Error *local_err = NULL;
BlockDirtyBitmapAdd *action;
BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
common, common);

action = common->action->block_dirty_bitmap_add;
action = common->action->u.block_dirty_bitmap_add;
/* AIO context taken and released within qmp_block_dirty_bitmap_add */
qmp_block_dirty_bitmap_add(action->node, action->name,
action->has_granularity, action->granularity,
Expand All @@ -1904,13 +1918,13 @@ static void block_dirty_bitmap_add_prepare(BlkTransactionState *common,
}
}

static void block_dirty_bitmap_add_abort(BlkTransactionState *common)
static void block_dirty_bitmap_add_abort(BlkActionState *common)
{
BlockDirtyBitmapAdd *action;
BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
common, common);

action = common->action->block_dirty_bitmap_add;
action = common->action->u.block_dirty_bitmap_add;
/* Should not be able to fail: IF the bitmap was added via .prepare(),
* then the node reference and bitmap name must have been valid.
*/
Expand All @@ -1919,14 +1933,14 @@ static void block_dirty_bitmap_add_abort(BlkTransactionState *common)
}
}

static void block_dirty_bitmap_clear_prepare(BlkTransactionState *common,
static void block_dirty_bitmap_clear_prepare(BlkActionState *common,
Error **errp)
{
BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
common, common);
BlockDirtyBitmap *action;

action = common->action->block_dirty_bitmap_clear;
action = common->action->u.block_dirty_bitmap_clear;
state->bitmap = block_dirty_bitmap_lookup(action->node,
action->name,
&state->bs,
Expand All @@ -1948,23 +1962,23 @@ static void block_dirty_bitmap_clear_prepare(BlkTransactionState *common,
/* AioContext is released in .clean() */
}

static void block_dirty_bitmap_clear_abort(BlkTransactionState *common)
static void block_dirty_bitmap_clear_abort(BlkActionState *common)
{
BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
common, common);

bdrv_undo_clear_dirty_bitmap(state->bitmap, state->backup);
}

static void block_dirty_bitmap_clear_commit(BlkTransactionState *common)
static void block_dirty_bitmap_clear_commit(BlkActionState *common)
{
BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
common, common);

hbitmap_free(state->backup);
}

static void block_dirty_bitmap_clear_clean(BlkTransactionState *common)
static void block_dirty_bitmap_clear_clean(BlkActionState *common)
{
BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
common, common);
Expand All @@ -1974,17 +1988,17 @@ static void block_dirty_bitmap_clear_clean(BlkTransactionState *common)
}
}

static void abort_prepare(BlkTransactionState *common, Error **errp)
static void abort_prepare(BlkActionState *common, Error **errp)
{
error_setg(errp, "Transaction aborted using Abort action");
}

static void abort_commit(BlkTransactionState *common)
static void abort_commit(BlkActionState *common)
{
g_assert_not_reached(); /* this action never succeeds */
}

static const BdrvActionOps actions[] = {
static const BlkActionOps actions[] = {
[TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT] = {
.instance_size = sizeof(ExternalSnapshotState),
.prepare = external_snapshot_prepare,
Expand All @@ -2011,7 +2025,7 @@ static const BdrvActionOps actions[] = {
.clean = blockdev_backup_clean,
},
[TRANSACTION_ACTION_KIND_ABORT] = {
.instance_size = sizeof(BlkTransactionState),
.instance_size = sizeof(BlkActionState),
.prepare = abort_prepare,
.commit = abort_commit,
},
Expand Down Expand Up @@ -2042,10 +2056,10 @@ static const BdrvActionOps actions[] = {
void qmp_transaction(TransactionActionList *dev_list, Error **errp)
{
TransactionActionList *dev_entry = dev_list;
BlkTransactionState *state, *next;
BlkActionState *state, *next;
Error *local_err = NULL;

QSIMPLEQ_HEAD(snap_bdrv_states, BlkTransactionState) snap_bdrv_states;
QSIMPLEQ_HEAD(snap_bdrv_states, BlkActionState) snap_bdrv_states;
QSIMPLEQ_INIT(&snap_bdrv_states);

/* drain all i/o before any operations */
Expand All @@ -2054,7 +2068,7 @@ void qmp_transaction(TransactionActionList *dev_list, Error **errp)
/* We don't do anything in this loop that commits us to the operations */
while (NULL != dev_entry) {
TransactionAction *dev_info = NULL;
const BdrvActionOps *ops;
const BlkActionOps *ops;

dev_info = dev_entry->value;
dev_entry = dev_entry->next;
Expand Down

0 comments on commit 50f43f0

Please sign in to comment.