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)

- 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

Alberto Garcia (2):

quorum: Implement bdrv_co_block_status()

quorum: Implement bdrv_co_pwrite_zeroes()

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: Philippe Mathieu-Daudé <philmd@redhat.com>

NVMe drive cannot be shrunk.

Since commit c80d8b06cfa we can use the @exact parameter (set

to false) to return success if the block device is larger than

the requested offset (even if we can not be shrunk).

Use this parameter to implement the NVMe truncate() coroutine,

similarly how it is done for the iscsi and file-posix drivers

(see commit 82325ae5f2f "Evaluate @exact in protocol drivers").

Reported-by: Xueqiang Wei <xuwei@redhat.com>

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

Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>

Message-Id: <20201210125202.858656-1-philmd@redhat.com>

block/nvme.c | 24 ++++++++++++++++++++++++

1 file changed, 24 insertions(+)

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

--- a/block/nvme.c

+++ b/block/nvme.c

@@ -XXX,XX +XXX,XX @@ out:

}

+static int coroutine_fn nvme_co_truncate(BlockDriverState *bs, int64_t offset,

+ bool exact, PreallocMode prealloc,

+ BdrvRequestFlags flags, Error **errp)

+{

+ int64_t cur_length;

+

+ if (prealloc != PREALLOC_MODE_OFF) {

+ error_setg(errp, "Unsupported preallocation mode '%s'",

+ PreallocMode_str(prealloc));

+ return -ENOTSUP;

+ }

+

+ cur_length = nvme_getlength(bs);

+ if (offset != cur_length && exact) {

+ error_setg(errp, "Cannot resize NVMe devices");

+ return -ENOTSUP;

+ } else if (offset > cur_length) {

+ error_setg(errp, "Cannot grow NVMe devices");

+ return -EINVAL;

+ }

+

+ return 0;

+}

static int nvme_reopen_prepare(BDRVReopenState *reopen_state,

BlockReopenQueue *queue, Error **errp)

@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_nvme = {

.bdrv_close = nvme_close,

.bdrv_getlength = nvme_getlength,

.bdrv_probe_blocksizes = nvme_probe_blocksizes,

+ .bdrv_co_truncate = nvme_co_truncate,

.bdrv_co_preadv = nvme_co_preadv,

.bdrv_co_pwritev = nvme_co_pwritev,

2.29.2

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.

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

Reviewed-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,

2.29.2

From: Alberto Garcia <berto@igalia.com>

This simply calls bdrv_co_pwrite_zeroes() in all children.

bs->supported_zero_flags is also set to the flags that are supported

by all children.

Signed-off-by: Alberto Garcia <berto@igalia.com>

Message-Id: <2f09c842781fe336b4c2e40036bba577b7430190.1605286097.git.berto@igalia.com>

block/quorum.c | 36 ++++++++++++++++++++++++++++++++++--

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

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

3 files changed, 53 insertions(+), 2 deletions(-)

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

index XXXXXXX..XXXXXXX 100644

--- a/block/quorum.c

+++ b/block/quorum.c

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

QuorumChildRequest *sacb = &acb->qcrs[i];

sacb->bs = s->children[i]->bs;

- sacb->ret = bdrv_co_pwritev(s->children[i], acb->offset, acb->bytes,

- acb->qiov, acb->flags);

+ if (acb->flags & BDRV_REQ_ZERO_WRITE) {

+ sacb->ret = bdrv_co_pwrite_zeroes(s->children[i], acb->offset,

+ acb->bytes, acb->flags);

+ } else {

+ sacb->ret = bdrv_co_pwritev(s->children[i], acb->offset, acb->bytes,

+ acb->qiov, acb->flags);

+ }

if (sacb->ret == 0) {

acb->success_count++;

} else {

@@ -XXX,XX +XXX,XX @@ static int quorum_co_pwritev(BlockDriverState *bs, uint64_t offset,

return ret;

}

+static int quorum_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset,

+ int bytes, BdrvRequestFlags flags)

+{

+ return quorum_co_pwritev(bs, offset, bytes, NULL,

+ flags | BDRV_REQ_ZERO_WRITE);

+}

+

static int64_t quorum_getlength(BlockDriverState *bs)

{

BDRVQuorumState *s = bs->opaque;

@@ -XXX,XX +XXX,XX @@ static QemuOptsList quorum_runtime_opts = {

},

};

+static void quorum_refresh_flags(BlockDriverState *bs)

+{

+ BDRVQuorumState *s = bs->opaque;

+ int i;

+

+ bs->supported_zero_flags =

+ BDRV_REQ_FUA | BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK;

+

+ for (i = 0; i < s->num_children; i++) {

+ bs->supported_zero_flags &= s->children[i]->bs->supported_zero_flags;

+ }

+

+ bs->supported_zero_flags |= BDRV_REQ_WRITE_UNCHANGED;

+}

+

static int quorum_open(BlockDriverState *bs, QDict *options, int flags,

Error **errp)

{

@@ -XXX,XX +XXX,XX @@ static int quorum_open(BlockDriverState *bs, QDict *options, int flags,

s->next_child_index = s->num_children;

bs->supported_write_flags = BDRV_REQ_WRITE_UNCHANGED;

+ quorum_refresh_flags(bs);

g_free(opened);

goto exit;

@@ -XXX,XX +XXX,XX @@ static void quorum_add_child(BlockDriverState *bs, BlockDriverState *child_bs,

}

s->children = g_renew(BdrvChild *, s->children, s->num_children + 1);

s->children[s->num_children++] = child;

+ quorum_refresh_flags(bs);

out:

bdrv_drained_end(bs);

@@ -XXX,XX +XXX,XX @@ static void quorum_del_child(BlockDriverState *bs, BdrvChild *child,

s->children = g_renew(BdrvChild *, s->children, --s->num_children);

bdrv_unref_child(bs, child);

+ quorum_refresh_flags(bs);

bdrv_drained_end(bs);

}

@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_quorum = {

.bdrv_co_preadv = quorum_co_preadv,

.bdrv_co_pwritev = quorum_co_pwritev,

+ .bdrv_co_pwrite_zeroes = quorum_co_pwrite_zeroes,

.bdrv_add_child = quorum_add_child,

.bdrv_del_child = quorum_del_child,

diff --git a/tests/qemu-iotests/312 b/tests/qemu-iotests/312

index XXXXXXX..XXXXXXX 100755

--- a/tests/qemu-iotests/312

+++ b/tests/qemu-iotests/312

@@ -XXX,XX +XXX,XX @@ $QEMU_IO -c "write -P 0 $((0x200000)) $((0x10000))" "$TEST_IMG.0" | _filter_qemu

$QEMU_IO -c "write -z $((0x200000)) $((0x30000))" "$TEST_IMG.1" | _filter_qemu_io

$QEMU_IO -c "write -P 0 $((0x200000)) $((0x20000))" "$TEST_IMG.2" | _filter_qemu_io

+# Test 5: write data to a region and then zeroize it, doing it

+# directly on the quorum device instead of the individual images.

+# This has no effect on the end result but proves that the quorum driver

+# supports 'write -z'.

+$QEMU_IO -c "open -o $quorum" -c "write -P 1 $((0x250000)) $((0x10000))" | _filter_qemu_io

+# Verify the data that we just wrote

+$QEMU_IO -c "open -o $quorum" -c "read -P 1 $((0x250000)) $((0x10000))" | _filter_qemu_io

+$QEMU_IO -c "open -o $quorum" -c "write -z $((0x250000)) $((0x10000))" | _filter_qemu_io

+# Now it should read back as zeroes

+$QEMU_IO -c "open -o $quorum" -c "read -P 0 $((0x250000)) $((0x10000))" | _filter_qemu_io

echo '### Launch the drive-mirror job'

echo

diff --git a/tests/qemu-iotests/312.out b/tests/qemu-iotests/312.out

--- a/tests/qemu-iotests/312.out

+++ b/tests/qemu-iotests/312.out

@@ -XXX,XX +XXX,XX @@ wrote 196608/196608 bytes at offset 2097152

192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

wrote 131072/131072 bytes at offset 2097152

128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

+wrote 65536/65536 bytes at offset 2424832

+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

+read 65536/65536 bytes at offset 2424832

+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

+wrote 65536/65536 bytes at offset 2424832

+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

+read 65536/65536 bytes at offset 2424832

+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

### Launch the drive-mirror job

2.29.2

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

Benchmark for new preallocate filter.

Example usage:

./bench_prealloc.py ../../build/qemu-img \

ssd-ext4:/path/to/mount/point \

ssd-xfs:/path2 hdd-ext4:/path3 hdd-xfs:/path4

The benchmark shows performance improvement (or degradation) when use

new preallocate filter with qcow2 image.

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

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

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

1 file changed, 132 insertions(+)

create mode 100755 scripts/simplebench/bench_prealloc.py

diff --git a/scripts/simplebench/bench_prealloc.py b/scripts/simplebench/bench_prealloc.py

new file mode 100755

index XXXXXXX..XXXXXXX

--- /dev/null

+++ b/scripts/simplebench/bench_prealloc.py

@@ -XXX,XX +XXX,XX @@

+#!/usr/bin/env python3

+#

+# Benchmark preallocate filter

+#

+# Copyright (c) 2020 Virtuozzo International GmbH.

+#

+# This program is free software; you can redistribute it and/or modify

+# it under the terms of the GNU General Public License as published by

+# the Free Software Foundation; either version 2 of the License, or

+# (at your option) any later version.

+#

+# This program is distributed in the hope that it will be useful,

+# but WITHOUT ANY WARRANTY; without even the implied warranty of

+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

+# GNU General Public License for more details.

+#

+# You should have received a copy of the GNU General Public License

+# along with this program. If not, see <http://www.gnu.org/licenses/>.

+#

+

+

+import sys

+import os

+import subprocess

+import re

+import json

+

+import simplebench

+from results_to_text import results_to_text

+

+

+def qemu_img_bench(args):

+ p = subprocess.run(args, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,

+ universal_newlines=True)

+

+ if p.returncode == 0:

+ try:

+ m = re.search(r'Run completed in (\d+.\d+) seconds.', p.stdout)

+ return {'seconds': float(m.group(1))}

+ except Exception:

+ return {'error': f'failed to parse qemu-img output: {p.stdout}'}

+ else:

+ return {'error': f'qemu-img failed: {p.returncode}: {p.stdout}'}

+

+

+def bench_func(env, case):

+ fname = f"{case['dir']}/prealloc-test.qcow2"

+ try:

+ os.remove(fname)

+ except OSError:

+ pass

+

+ subprocess.run([env['qemu-img-binary'], 'create', '-f', 'qcow2', fname,

+ '16G'], stdout=subprocess.DEVNULL,

+ stderr=subprocess.DEVNULL, check=True)

+

+ args = [env['qemu-img-binary'], 'bench', '-c', str(case['count']),

+ '-d', '64', '-s', case['block-size'], '-t', 'none', '-n', '-w']

+ if env['prealloc']:

+ args += ['--image-opts',

+ 'driver=qcow2,file.driver=preallocate,file.file.driver=file,'

+ f'file.file.filename={fname}']

+ else:

+ args += ['-f', 'qcow2', fname]

+

+ return qemu_img_bench(args)

+

+

+def auto_count_bench_func(env, case):

+ case['count'] = 100

+ while True:

+ res = bench_func(env, case)

+ if 'error' in res:

+ return res

+

+ if res['seconds'] >= 1:

+ break

+

+ case['count'] *= 10

+

+ if res['seconds'] < 5:

+ case['count'] = round(case['count'] * 5 / res['seconds'])

+ res = bench_func(env, case)

+ if 'error' in res:

+ return res

+

+ res['iops'] = case['count'] / res['seconds']

+ return res

+

+

+if __name__ == '__main__':

+ if len(sys.argv) < 2:

+ print(f'USAGE: {sys.argv[0]} <qemu-img binary> '

+ 'DISK_NAME:DIR_PATH ...')

+ exit(1)

+

+ qemu_img = sys.argv[1]

+

+ envs = [

+ {

+ 'id': 'no-prealloc',

+ 'qemu-img-binary': qemu_img,

+ 'prealloc': False

+ },

+ {

+ 'id': 'prealloc',

+ 'qemu-img-binary': qemu_img,

+ 'prealloc': True

+ }

+ ]

+

+ aligned_cases = []

+ unaligned_cases = []

+

+ for disk in sys.argv[2:]:

+ name, path = disk.split(':')

+ aligned_cases.append({

+ 'id': f'{name}, aligned sequential 16k',

+ 'block-size': '16k',

+ 'dir': path

+ })

+ unaligned_cases.append({

+ 'id': f'{name}, unaligned sequential 64k',

+ 'block-size': '16k',

+ 'dir': path

+ })

+

+ result = simplebench.bench(auto_count_bench_func, envs,

+ aligned_cases + unaligned_cases, count=5)

+ print(results_to_text(result))

+ with open('results.json', 'w') as f:

+ json.dump(result, f, indent=4)

2.29.2

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

Make results_to_text a tool to dump results saved in JSON file.

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

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

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

1 file changed, 14 insertions(+)

mode change 100644 => 100755 scripts/simplebench/results_to_text.py

diff --git a/scripts/simplebench/results_to_text.py b/scripts/simplebench/results_to_text.py

old mode 100644

new mode 100755

index XXXXXXX..XXXXXXX

--- a/scripts/simplebench/results_to_text.py

+++ b/scripts/simplebench/results_to_text.py

@@ -XXX,XX +XXX,XX @@

+#!/usr/bin/env python3

+#

# Simple benchmarking framework

#

# Copyright (c) 2019 Virtuozzo International GmbH.

@@ -XXX,XX +XXX,XX @@ def results_to_text(results):

tab.append(row)

return f'All results are in {dim}\n\n' + tabulate.tabulate(tab)

+

+

+if __name__ == '__main__':

+ import sys

+ import json

+

+ if len(sys.argv) < 2:

+ print(f'USAGE: {sys.argv[0]} results.json')

+ exit(1)

+

+ with open(sys.argv[1]) as f:

+ print(results_to_text(json.load(f)))

2.29.2

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

It's intended to be inserted between format and protocol nodes to

preallocate additional space (expanding protocol file) on writes

crossing EOF. It improves performance for file-systems with slow

allocation.

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

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

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

[mreitz: Two comment fixes, and bumped the version from 5.2 to 6.0]

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

qapi/block-core.json | 20 +-

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

block/meson.build | 1 +

4 files changed, 605 insertions(+), 1 deletion(-)

create mode 100644 block/preallocate.c

diff --git a/docs/system/qemu-block-drivers.rst.inc b/docs/system/qemu-block-drivers.rst.inc

--- a/docs/system/qemu-block-drivers.rst.inc

+++ b/docs/system/qemu-block-drivers.rst.inc

@@ -XXX,XX +XXX,XX @@ on host and see if there are locks held by the QEMU process on the image file.

More than one byte could be locked by the QEMU instance, each byte of which

reflects a particular permission that is acquired or protected by the running

block driver.

+

+Filter drivers

+~~~~~~~~~~~~~~

+

+QEMU supports several filter drivers, which don't store any data, but perform

+some additional tasks, hooking io requests.

+

+.. program:: filter-drivers

+.. option:: preallocate

+

+ The preallocate filter driver is intended to be inserted between format

+ and protocol nodes and preallocates some additional space

+ (expanding the protocol file) when writing past the file’s end. This can be

+ useful for file-systems with slow allocation.

+

+ Supported options:

+

+ .. program:: preallocate

+ .. option:: prealloc-align

+

+ On preallocation, align the file length to this value (in bytes), default 1M.

+

+ .. program:: preallocate

+ .. option:: prealloc-size

+

+ How much to preallocate (in bytes), default 128M.

diff --git a/qapi/block-core.json b/qapi/block-core.json

index XXXXXXX..XXXXXXX 100644

--- a/qapi/block-core.json

+++ b/qapi/block-core.json

@@ -XXX,XX +XXX,XX @@

'cloop', 'compress', 'copy-on-read', 'dmg', 'file', 'ftp', 'ftps',

'gluster', 'host_cdrom', 'host_device', 'http', 'https', 'iscsi',

'luks', 'nbd', 'nfs', 'null-aio', 'null-co', 'nvme', 'parallels',

- 'qcow', 'qcow2', 'qed', 'quorum', 'raw', 'rbd',

+ 'preallocate', 'qcow', 'qcow2', 'qed', 'quorum', 'raw', 'rbd',

{ 'name': 'replication', 'if': 'defined(CONFIG_REPLICATION)' },

'sheepdog',

'ssh', 'throttle', 'vdi', 'vhdx', 'vmdk', 'vpc', 'vvfat' ] }

@@ -XXX,XX +XXX,XX @@

'data': { 'aes': 'QCryptoBlockOptionsQCow',

'luks': 'QCryptoBlockOptionsLUKS'} }

+##

+# @BlockdevOptionsPreallocate:

+#

+# Filter driver intended to be inserted between format and protocol node

+# and do preallocation in protocol node on write.

+#

+# @prealloc-align: on preallocation, align file length to this number,

+# default 1048576 (1M)

+#

+# @prealloc-size: how much to preallocate, default 134217728 (128M)

+#

+# Since: 6.0

+##

+{ 'struct': 'BlockdevOptionsPreallocate',

+ 'base': 'BlockdevOptionsGenericFormat',

+ 'data': { '*prealloc-align': 'int', '*prealloc-size': 'int' } }

+

##

# @BlockdevOptionsQcow2:

#

@@ -XXX,XX +XXX,XX @@

'null-co': 'BlockdevOptionsNull',

'nvme': 'BlockdevOptionsNVMe',

'parallels': 'BlockdevOptionsGenericFormat',

+ 'preallocate':'BlockdevOptionsPreallocate',

'qcow2': 'BlockdevOptionsQcow2',

'qcow': 'BlockdevOptionsQcow',

'qed': 'BlockdevOptionsGenericCOWFormat',

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

new file mode 100644

index XXXXXXX..XXXXXXX

--- /dev/null

+++ b/block/preallocate.c

@@ -XXX,XX +XXX,XX @@

+/*

+ * preallocate filter driver

+ *

+ * The driver performs preallocate operation: it is injected above

+ * some node, and before each write over EOF it does additional preallocating

+ * write-zeroes request.

+ *

+ * Copyright (c) 2020 Virtuozzo International GmbH.

+ *

+ * Author:

+ * Sementsov-Ogievskiy Vladimir <vsementsov@virtuozzo.com>

+ *

+ * This program is free software; you can redistribute it and/or modify

+ * it under the terms of the GNU General Public License as published by

+ * the Free Software Foundation; either version 2 of the License, or

+ * (at your option) any later version.

+ *

+ * This program is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

+ * GNU General Public License for more details.

+ *

+ * You should have received a copy of the GNU General Public License

+ * along with this program. If not, see <http://www.gnu.org/licenses/>.

+ */

+

+#include "qemu/osdep.h"

+

+#include "qapi/error.h"

+#include "qemu/module.h"

+#include "qemu/option.h"

+#include "qemu/units.h"

+#include "block/block_int.h"

+

+

+typedef struct PreallocateOpts {

+ int64_t prealloc_size;

+ int64_t prealloc_align;

+} PreallocateOpts;

+

+typedef struct BDRVPreallocateState {

+ PreallocateOpts opts;

+

+ /*

+ * Track real data end, to crop preallocation on close. If < 0 the status is

+ * unknown.

+ *

+ * @data_end is a maximum of file size on open (or when we get write/resize

+ * permissions) and all write request ends after it. So it's safe to

+ * truncate to data_end if it is valid.

+ */

+ int64_t data_end;

+

+ /*

+ * Start of trailing preallocated area which reads as zero. May be smaller

+ * than data_end, if user does over-EOF write zero operation. If < 0 the

+ * status is unknown.

+ *

+ * If both @zero_start and @file_end are valid, the region

+ * [@zero_start, @file_end) is known to be preallocated zeroes. If @file_end

+ * is not valid, @zero_start doesn't make much sense.

+ */

+ int64_t zero_start;

+

+ /*

+ * Real end of file. Actually the cache for bdrv_getlength(bs->file->bs),

+ * to avoid extra lseek() calls on each write operation. If < 0 the status

+ * is unknown.

+ */

+ int64_t file_end;

+

+ /*

+ * All three states @data_end, @zero_start and @file_end are guaranteed to

+ * be invalid (< 0) when we don't have both exclusive BLK_PERM_RESIZE and

+ * BLK_PERM_WRITE permissions on file child.

+ */

+} BDRVPreallocateState;

+

+#define PREALLOCATE_OPT_PREALLOC_ALIGN "prealloc-align"

+#define PREALLOCATE_OPT_PREALLOC_SIZE "prealloc-size"

+static QemuOptsList runtime_opts = {

+ .name = "preallocate",

+ .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head),

+ .desc = {

+ {

+ .name = PREALLOCATE_OPT_PREALLOC_ALIGN,

+ .type = QEMU_OPT_SIZE,

+ .help = "on preallocation, align file length to this number, "

+ "default 1M",

+ },

+ {

+ .name = PREALLOCATE_OPT_PREALLOC_SIZE,

+ .type = QEMU_OPT_SIZE,

+ .help = "how much to preallocate, default 128M",

+ },

+ { /* end of list */ }

+ },

+};

+

+static bool preallocate_absorb_opts(PreallocateOpts *dest, QDict *options,

+ BlockDriverState *child_bs, Error **errp)

+ QemuOpts *opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort);

+

+ if (!qemu_opts_absorb_qdict(opts, options, errp)) {

+ return false;

+ }

+

+ dest->prealloc_align =

+ qemu_opt_get_size(opts, PREALLOCATE_OPT_PREALLOC_ALIGN, 1 * MiB);

+ dest->prealloc_size =

+ qemu_opt_get_size(opts, PREALLOCATE_OPT_PREALLOC_SIZE, 128 * MiB);

+

+ qemu_opts_del(opts);

+

+ if (!QEMU_IS_ALIGNED(dest->prealloc_align, BDRV_SECTOR_SIZE)) {

+ error_setg(errp, "prealloc-align parameter of preallocate filter "

+ "is not aligned to %llu", BDRV_SECTOR_SIZE);

+ return false;

+ }

+

+ if (!QEMU_IS_ALIGNED(dest->prealloc_align,

+ child_bs->bl.request_alignment)) {

+ error_setg(errp, "prealloc-align parameter of preallocate filter "

+ "is not aligned to underlying node request alignment "

+ "(%" PRIi32 ")", child_bs->bl.request_alignment);

+ return false;

+ }

+

+ return true;

+}

+

+static int preallocate_open(BlockDriverState *bs, QDict *options, int flags,

+ Error **errp)

+{

+ BDRVPreallocateState *s = bs->opaque;

+

+ /*

+ * s->data_end and friends should be initialized on permission update.

+ * For this to work, mark them invalid.

+ */

+ s->file_end = s->zero_start = s->data_end = -EINVAL;

+

+ bs->file = bdrv_open_child(NULL, options, "file", bs, &child_of_bds,

+ BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY,

+ false, errp);

+ if (!bs->file) {