The following changes since commit 6972ef1440a9d685482d78672620a7482f2bd09a:

Merge tag 'pull-tcg-20230516-3' of https://gitlab.com/rth7680/qemu into staging (2023-05-16 21:30:27 -0700)

https://repo.or.cz/qemu/kevin.git tags/for-upstream

for you to fetch changes up to 75b2591bbce5dc9f3da89f140b7bdc00e92fa8ec:

tested: add test for nested aio_poll() in poll handlers (2023-05-17 18:01:22 +0200)

Block layer patches

- qcow2 spec: Rename "zlib" compression to "deflate"

- Honour graph read lock even in the main thread + prerequisite fixes

- aio-posix: do not nest poll handlers (fixes infinite recursion)

- Refactor QMP blockdev transactions

- iotests/245: Check if 'compress' driver is available

Akihiro Suda (1):

docs/interop/qcow2.txt: fix description about "zlib" clusters

Kevin Wolf (9):

block: Call .bdrv_co_create(_opts) unlocked

block/export: Fix null pointer dereference in error path

qcow2: Unlock the graph in qcow2_do_open() where necessary

qemu-img: Take graph lock more selectively

test-bdrv-drain: Take graph lock more selectively

test-bdrv-drain: Call bdrv_co_unref() in coroutine context

blockjob: Adhere to rate limit even when reentered early

graph-lock: Honour read locks even in the main thread

iotests/245: Check if 'compress' driver is available

Stefan Hajnoczi (2):

aio-posix: do not nest poll handlers

tested: add test for nested aio_poll() in poll handlers

Vladimir Sementsov-Ogievskiy (6):

blockdev: refactor transaction to use Transaction API

blockdev: transactions: rename some things

blockdev: qmp_transaction: refactor loop to classic for

blockdev: transaction: refactor handling transaction properties

blockdev: use state.bitmap in block-dirty-bitmap-add action

blockdev: qmp_transaction: drop extra generic layer

docs/interop/qcow2.txt | 10 +-

include/block/block-global-state.h | 8 +-

include/block/block_int-common.h | 4 +-

include/block/blockjob_int.h | 14 +-

block.c | 1 -

block/commit.c | 7 +-

block/create.c | 1 -

block/crypto.c | 25 +-

block/export/export.c | 6 +-

block/graph-lock.c | 10 -

block/mirror.c | 23 +-

block/parallels.c | 6 +-

block/qcow.c | 6 +-

block/qcow2.c | 43 ++-

block/qed.c | 6 +-

block/raw-format.c | 2 +-

block/stream.c | 7 +-

block/vdi.c | 11 +-

block/vhdx.c | 8 +-

block/vmdk.c | 27 +-

block/vpc.c | 6 +-

blockdev.c | 606 +++++++++++++++----------------------

blockjob.c | 22 +-

qemu-img.c | 5 +-

tests/unit/test-bdrv-drain.c | 6 +-

tests/unit/test-nested-aio-poll.c | 130 ++++++++

util/aio-posix.c | 11 +

tests/qemu-iotests/245 | 7 +-

tests/qemu-iotests/245.out | 9 +-

tests/unit/meson.build | 1 +

30 files changed, 541 insertions(+), 487 deletions(-)

create mode 100644 tests/unit/test-nested-aio-poll.c

From: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>

Look at qmp_transaction(): dev_list is not obvious name for list of

actions. Let's look at qapi spec, this argument is "actions". Let's

follow the common practice of using same argument names in qapi scheme

and code.

To be honest, rename props to properties for same reason.

Next, we have to rename global map of actions, to not conflict with new

name for function argument.

Rename also dev_entry loop variable accordingly to new name of the

list.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>

Reviewed-by: Kevin Wolf <kwolf@redhat.com>

Message-Id: <20230510150624.310640-3-vsementsov@yandex-team.ru>

blockdev.c | 30 +++++++++++++++---------------

1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/blockdev.c b/blockdev.c

--- a/blockdev.c

+++ b/blockdev.c

@@ -XXX,XX +XXX,XX @@ static void abort_commit(void *opaque)

g_assert_not_reached(); /* this action never succeeds */

}

-static const BlkActionOps actions[] = {

+static const BlkActionOps actions_map[] = {

[TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT] = {

.instance_size = sizeof(ExternalSnapshotState),

.action = external_snapshot_action,

@@ -XXX,XX +XXX,XX @@ static TransactionProperties *get_transaction_properties(

*

* Always run under BQL.

*/

-void qmp_transaction(TransactionActionList *dev_list,

- struct TransactionProperties *props,

+void qmp_transaction(TransactionActionList *actions,

+ struct TransactionProperties *properties,

Error **errp)

{

- TransactionActionList *dev_entry = dev_list;

- bool has_props = !!props;

+ TransactionActionList *act = actions;

+ bool has_properties = !!properties;

JobTxn *block_job_txn = NULL;

Error *local_err = NULL;

Transaction *tran = tran_new();

@@ -XXX,XX +XXX,XX @@ void qmp_transaction(TransactionActionList *dev_list,

/* Does this transaction get canceled as a group on failure?

* If not, we don't really need to make a JobTxn.

- props = get_transaction_properties(props);

- if (props->completion_mode != ACTION_COMPLETION_MODE_INDIVIDUAL) {

+ properties = get_transaction_properties(properties);

+ if (properties->completion_mode != ACTION_COMPLETION_MODE_INDIVIDUAL) {

block_job_txn = job_txn_new();

@@ -XXX,XX +XXX,XX @@ void qmp_transaction(TransactionActionList *dev_list,

bdrv_drain_all();

/* We don't do anything in this loop that commits us to the operations */

- while (NULL != dev_entry) {

+ while (NULL != act) {

TransactionAction *dev_info = NULL;

const BlkActionOps *ops;

BlkActionState *state;

- dev_info = dev_entry->value;

- dev_entry = dev_entry->next;

+ dev_info = act->value;

+ act = act->next;

- assert(dev_info->type < ARRAY_SIZE(actions));

+ assert(dev_info->type < ARRAY_SIZE(actions_map));

- ops = &actions[dev_info->type];

+ ops = &actions_map[dev_info->type];

assert(ops->instance_size > 0);

state = g_malloc0(ops->instance_size);

state->ops = ops;

state->action = dev_info;

state->block_job_txn = block_job_txn;

- state->txn_props = props;

+ state->txn_props = properties;

state->ops->action(state, tran, &local_err);

if (local_err) {

@@ -XXX,XX +XXX,XX @@ delete_and_fail:

/* failure, and it is all-or-none; roll back all operations */

tran_abort(tran);

exit:

- if (!has_props) {

- qapi_free_TransactionProperties(props);

+ if (!has_properties) {

+ qapi_free_TransactionProperties(properties);

}

job_txn_unref(block_job_txn);

2.40.1

From: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>

Only backup supports GROUPED mode. Make this logic more clear. And

avoid passing extra thing to each action.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>

Message-Id: <20230510150624.310640-5-vsementsov@yandex-team.ru>

Reviewed-by: Kevin Wolf <kwolf@redhat.com>

blockdev.c | 96 +++++++++++++-----------------------------------------

1 file changed, 22 insertions(+), 74 deletions(-)

diff --git a/blockdev.c b/blockdev.c

--- a/blockdev.c

+++ b/blockdev.c

@@ -XXX,XX +XXX,XX @@ struct BlkActionState {

TransactionAction *action;

const BlkActionOps *ops;

JobTxn *block_job_txn;

- TransactionProperties *txn_props;

QTAILQ_ENTRY(BlkActionState) entry;

};

@@ -XXX,XX +XXX,XX @@ TransactionActionDrv internal_snapshot_drv = {

.clean = internal_snapshot_clean,

};

-static int action_check_completion_mode(BlkActionState *s, Error **errp)

-{

- if (s->txn_props->completion_mode != ACTION_COMPLETION_MODE_INDIVIDUAL) {

- error_setg(errp,

- "Action '%s' does not support Transaction property "

- "completion-mode = %s",

- TransactionActionKind_str(s->action->type),

- ActionCompletionMode_str(s->txn_props->completion_mode));

- return -1;

- }

- return 0;

-}

-

static void internal_snapshot_action(BlkActionState *common,

Transaction *tran, Error **errp)

{

@@ -XXX,XX +XXX,XX @@ static void internal_snapshot_action(BlkActionState *common,

tran_add(tran, &internal_snapshot_drv, state);

- /* 1. parse input */

device = internal->device;

name = internal->name;

- /* 2. check for validation */

- if (action_check_completion_mode(common, errp) < 0) {

- return;

- }

-

bs = qmp_get_root_bs(device, errp);

if (!bs) {

return;

@@ -XXX,XX +XXX,XX @@ static void external_snapshot_action(BlkActionState *common, Transaction *tran,

/* start processing */

- if (action_check_completion_mode(common, errp) < 0) {

- return;

- }

state->old_bs = bdrv_lookup_bs(device, node_name, errp);

if (!state->old_bs) {

@@ -XXX,XX +XXX,XX @@ static void block_dirty_bitmap_add_action(BlkActionState *common,

tran_add(tran, &block_dirty_bitmap_add_drv, state);

- if (action_check_completion_mode(common, errp) < 0) {

- return;

- }

-

action = common->action->u.block_dirty_bitmap_add.data;

/* AIO context taken and released within qmp_block_dirty_bitmap_add */

qmp_block_dirty_bitmap_add(action->node, action->name,

@@ -XXX,XX +XXX,XX @@ static void block_dirty_bitmap_clear_action(BlkActionState *common,

tran_add(tran, &block_dirty_bitmap_clear_drv, state);

- if (action_check_completion_mode(common, errp) < 0) {

- return;

- }

-

action = common->action->u.block_dirty_bitmap_clear.data;

state->bitmap = block_dirty_bitmap_lookup(action->node,

action->name,

@@ -XXX,XX +XXX,XX @@ static void block_dirty_bitmap_enable_action(BlkActionState *common,

tran_add(tran, &block_dirty_bitmap_enable_drv, state);

- if (action_check_completion_mode(common, errp) < 0) {

- return;

- }

-

action = common->action->u.block_dirty_bitmap_enable.data;