The following changes since commit 75ee62ac606bfc9eb59310b9446df3434bf6e8c2:

Merge remote-tracking branch 'remotes/ehabkost-gl/tags/x86-next-pull-request' into staging (2020-12-17 18:53:36 +0000)

https://github.com/XanClic/qemu.git tags/pull-block-2020-12-18

for you to fetch changes up to 0e72078128229bf9efb542e396ab44bf91b91340:

iotests: Fix _send_qemu_cmd with bash 5.1 (2020-12-18 12:47:38 +0100)

Block patches:

- New block filter: preallocate (which, on writes beyond an image file's

end, allocates big chunks of data so that such post-EOF writes will

occur less frequently)

- write-zeroes and block-status support for Quorum

- Implementation of truncate for the nvme block driver similarly to the

existing implementations for host block devices and iscsi devices

- Block layer refactoring: Drop the tighten_restrictions concept in the

block permission functions

- iotest fixes

Max Reitz (2):

iotests/102: Pass $QEMU_HANDLE to _send_qemu_cmd

iotests: Fix _send_qemu_cmd with bash 5.1

Philippe Mathieu-Daudé (1):

block/nvme: Implement fake truncate() coroutine

Vladimir Sementsov-Ogievskiy (25):

block: add bdrv_refresh_perms() helper

block: bdrv_set_perm() drop redundant parameters.

block: bdrv_child_set_perm() drop redundant parameters.

block: drop tighten_restrictions

block: simplify comment to BDRV_REQ_SERIALISING

block/io.c: drop assertion on double waiting for request serialisation

block/io: split out bdrv_find_conflicting_request

block/io: bdrv_wait_serialising_requests_locked: drop extra bs arg

block: bdrv_mark_request_serialising: split non-waiting function

block: introduce BDRV_REQ_NO_WAIT flag

block: bdrv_check_perm(): process children anyway

block: introduce preallocate filter

qemu-io: add preallocate mode parameter for truncate command

iotests: qemu_io_silent: support --image-opts

iotests.py: execute_setup_common(): add required_fmts argument

iotests: add 298 to test new preallocate filter driver

scripts/simplebench: fix grammar: s/successed/succeeded/

scripts/simplebench: support iops

scripts/simplebench: use standard deviation for +- error

simplebench: rename ascii() to results_to_text()

simplebench: move results_to_text() into separate file

simplebench/results_to_text: improve view of the table

simplebench/results_to_text: add difference line to the table

simplebench/results_to_text: make executable

scripts/simplebench: add bench_prealloc.py

docs/system/qemu-block-drivers.rst.inc | 26 ++

qapi/block-core.json | 20 +-

include/block/block.h | 20 +-

include/block/block_int.h | 3 +-

block.c | 185 +++-----

block/file-posix.c | 2 +-

block/io.c | 130 +++---

block/nvme.c | 24 ++

block/preallocate.c | 559 +++++++++++++++++++++++++

block/quorum.c | 88 +++-

qemu-io-cmds.c | 46 +-

block/meson.build | 1 +

scripts/simplebench/bench-example.py | 3 +-

scripts/simplebench/bench_prealloc.py | 132 ++++++

scripts/simplebench/bench_write_req.py | 3 +-

scripts/simplebench/results_to_text.py | 126 ++++++

scripts/simplebench/simplebench.py | 66 ++-

tests/qemu-iotests/085.out | 167 ++++++--

tests/qemu-iotests/094.out | 10 +-

tests/qemu-iotests/095.out | 4 +-

tests/qemu-iotests/102 | 2 +-

tests/qemu-iotests/102.out | 2 +-

tests/qemu-iotests/109.out | 88 +++-

tests/qemu-iotests/117.out | 13 +-

tests/qemu-iotests/127.out | 12 +-

tests/qemu-iotests/140.out | 10 +-

tests/qemu-iotests/141.out | 128 ++++--

tests/qemu-iotests/143.out | 4 +-

tests/qemu-iotests/144.out | 28 +-

tests/qemu-iotests/153.out | 18 +-

tests/qemu-iotests/156.out | 39 +-

tests/qemu-iotests/161.out | 18 +-

tests/qemu-iotests/173.out | 25 +-

tests/qemu-iotests/182.out | 42 +-

tests/qemu-iotests/183.out | 19 +-

tests/qemu-iotests/185.out | 45 +-

tests/qemu-iotests/191.out | 12 +-

tests/qemu-iotests/223.out | 92 ++--

tests/qemu-iotests/229.out | 13 +-

tests/qemu-iotests/249.out | 16 +-

tests/qemu-iotests/298 | 186 ++++++++

tests/qemu-iotests/298.out | 5 +

tests/qemu-iotests/308.out | 103 ++++-

tests/qemu-iotests/312 | 159 +++++++

tests/qemu-iotests/312.out | 81 ++++

tests/qemu-iotests/common.qemu | 11 +-

tests/qemu-iotests/group | 2 +

tests/qemu-iotests/iotests.py | 16 +-

48 files changed, 2357 insertions(+), 447 deletions(-)

create mode 100644 block/preallocate.c

create mode 100755 scripts/simplebench/bench_prealloc.py

create mode 100755 scripts/simplebench/results_to_text.py

create mode 100644 tests/qemu-iotests/298

create mode 100644 tests/qemu-iotests/298.out

create mode 100755 tests/qemu-iotests/312

create mode 100644 tests/qemu-iotests/312.out

2.29.2

From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>

To be reused in separate.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>

Message-Id: <20201021145859.11201-4-vsementsov@virtuozzo.com>

Signed-off-by: Max Reitz <mreitz@redhat.com>

block/io.c | 71 +++++++++++++++++++++++++++++++-----------------------

1 file changed, 41 insertions(+), 30 deletions(-)

diff --git a/block/io.c b/block/io.c

--- a/block/io.c

+++ b/block/io.c

@@ -XXX,XX +XXX,XX @@ static bool tracked_request_overlaps(BdrvTrackedRequest *req,

return true;

}

+/* Called with self->bs->reqs_lock held */

+static BdrvTrackedRequest *

+bdrv_find_conflicting_request(BdrvTrackedRequest *self)

+{

+ BdrvTrackedRequest *req;

+

+ QLIST_FOREACH(req, &self->bs->tracked_requests, list) {

+ if (req == self || (!req->serialising && !self->serialising)) {

+ continue;

+ }

+ if (tracked_request_overlaps(req, self->overlap_offset,

+ self->overlap_bytes))

+ {

+ /*

+ * Hitting this means there was a reentrant request, for

+ * example, a block driver issuing nested requests. This must

+ * never happen since it means deadlock.

+ */

+ assert(qemu_coroutine_self() != req->co);

+

+ /*

+ * If the request is already (indirectly) waiting for us, or

+ * will wait for us as soon as it wakes up, then just go on

+ * (instead of producing a deadlock in the former case).

+ */

+ if (!req->waiting_for) {

+ return req;

+ }

+ }

+ }

+

+ return NULL;

+}

+

static bool coroutine_fn

bdrv_wait_serialising_requests_locked(BlockDriverState *bs,

BdrvTrackedRequest *self)

BdrvTrackedRequest *req;

- bool retry;

bool waited = false;

- do {

- retry = false;

- QLIST_FOREACH(req, &bs->tracked_requests, list) {

- if (req == self || (!req->serialising && !self->serialising)) {

- continue;

- }

- if (tracked_request_overlaps(req, self->overlap_offset,

- self->overlap_bytes))

- {

- /* Hitting this means there was a reentrant request, for

- * example, a block driver issuing nested requests. This must

- * never happen since it means deadlock.

- */

- assert(qemu_coroutine_self() != req->co);

-

- /* If the request is already (indirectly) waiting for us, or

- * will wait for us as soon as it wakes up, then just go on

- * (instead of producing a deadlock in the former case). */

- if (!req->waiting_for) {

- self->waiting_for = req;

- qemu_co_queue_wait(&req->wait_queue, &bs->reqs_lock);

- self->waiting_for = NULL;

- retry = true;

- waited = true;

- break;

- }

- }

- }

- } while (retry);

+ while ((req = bdrv_find_conflicting_request(self))) {

+ self->waiting_for = req;

+ qemu_co_queue_wait(&req->wait_queue, &bs->reqs_lock);

+ self->waiting_for = NULL;

+ waited = true;

+ }

+

return waited;

}

2.29.2

From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>

We should never set permissions other than cumulative permissions of

parents. During bdrv_reopen_multiple() we _check_ for synthetic

permissions but when we do _set_ the graph is already updated.

Add an assertion to bdrv_reopen_multiple(), other cases are more

obvious.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>

Message-Id: <20201106124241.16950-6-vsementsov@virtuozzo.com>

Reviewed-by: Max Reitz <mreitz@redhat.com>

Signed-off-by: Max Reitz <mreitz@redhat.com>

block.c | 29 +++++++++++++++--------------

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

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

--- a/block.c

+++ b/block.c

@@ -XXX,XX +XXX,XX @@ static void bdrv_abort_perm_update(BlockDriverState *bs)

}

-static void bdrv_set_perm(BlockDriverState *bs, uint64_t cumulative_perms,

- uint64_t cumulative_shared_perms)

+static void bdrv_set_perm(BlockDriverState *bs)

+ uint64_t cumulative_perms, cumulative_shared_perms;

BlockDriver *drv = bs->drv;

BdrvChild *c;

@@ -XXX,XX +XXX,XX @@ static void bdrv_set_perm(BlockDriverState *bs, uint64_t cumulative_perms,

+ bdrv_get_cumulative_perm(bs, &cumulative_perms, &cumulative_shared_perms);

+

/* Update this node */

if (drv->bdrv_set_perm) {

drv->bdrv_set_perm(bs, cumulative_perms, cumulative_shared_perms);

@@ -XXX,XX +XXX,XX @@ static int bdrv_child_check_perm(BdrvChild *c, BlockReopenQueue *q,

static void bdrv_child_set_perm(BdrvChild *c, uint64_t perm, uint64_t shared)

- uint64_t cumulative_perms, cumulative_shared_perms;

-

c->has_backup_perm = false;

c->perm = perm;

c->shared_perm = shared;

- bdrv_get_cumulative_perm(c->bs, &cumulative_perms,

- &cumulative_shared_perms);

- bdrv_set_perm(c->bs, cumulative_perms, cumulative_shared_perms);

+ bdrv_set_perm(c->bs);

static void bdrv_child_abort_perm_update(BdrvChild *c)

@@ -XXX,XX +XXX,XX @@ static int bdrv_refresh_perms(BlockDriverState *bs, bool *tighten_restrictions,

bdrv_abort_perm_update(bs);

return ret;

- bdrv_set_perm(bs, perm, shared_perm);

+ bdrv_set_perm(bs);

return 0;

}

@@ -XXX,XX +XXX,XX @@ static void bdrv_replace_child_noperm(BdrvChild *child,

static void bdrv_replace_child(BdrvChild *child, BlockDriverState *new_bs)

{

BlockDriverState *old_bs = child->bs;

- uint64_t perm, shared_perm;

/* Asserts that child->frozen == false */

bdrv_replace_child_noperm(child, new_bs);

@@ -XXX,XX +XXX,XX @@ static void bdrv_replace_child(BdrvChild *child, BlockDriverState *new_bs)

* restrictions.

*/

if (new_bs) {

- bdrv_get_cumulative_perm(new_bs, &perm, &shared_perm);

- bdrv_set_perm(new_bs, perm, shared_perm);

+ bdrv_set_perm(new_bs);

}

if (old_bs) {

@@ -XXX,XX +XXX,XX @@ cleanup_perm:

}

if (ret == 0) {

- bdrv_set_perm(state->bs, state->perm, state->shared_perm);

+ uint64_t perm, shared;

+

+ bdrv_get_cumulative_perm(state->bs, &perm, &shared);

+ assert(perm == state->perm);

+ assert(shared == state->shared_perm);

+

+ bdrv_set_perm(state->bs);

} else {

bdrv_abort_perm_update(state->bs);

if (state->replace_backing_bs && state->new_backing_bs) {

@@ -XXX,XX +XXX,XX @@ static void bdrv_replace_node_common(BlockDriverState *from,

bdrv_unref(from);

}

- bdrv_get_cumulative_perm(to, &perm, &shared);

- bdrv_set_perm(to, perm, shared);

+ bdrv_set_perm(to);

out:

g_slist_free(list);

2.29.2