The following changes since commit 3fbd3405d2b0604ea530fc7a1828f19da1e95ff9:

Merge remote-tracking branch 'remotes/huth-gitlab/tags/pull-request-2019-08-17' into staging (2019-08-19 14:14:09 +0100)

are available in the Git repository at:

https://github.com/XanClic/qemu.git tags/pull-block-2019-08-19

for you to fetch changes up to fa27c478102a6b5d1c6b02c005607ad9404b915f:

doc: Preallocation does not require writing zeroes (2019-08-19 17:13:26 +0200)

Maxim Levitsky (1):

LUKS: support preallocation

qapi/block-core.json | 15 +++++---

include/block/block.h | 1 +

include/block/block_int.h | 9 +++++

block.c | 21 +++++++++++

block/crypto.c | 30 ++++++++++++++--

block/file-posix.c | 1 +

block/file-win32.c | 1 +

block/gluster.c | 4 +++

block/mirror.c | 11 ++++--

block/nfs.c | 1 +

block/parallels.c | 2 +-

block/qcow2.c | 30 +++++++++++++++-

block/qed.c | 1 +

block/raw-format.c | 6 ++++

block/rbd.c | 1 +

block/sheepdog.c | 1 +

block/ssh.c | 1 +

block/vdi.c | 16 +++++++--

block/vhdx.c | 28 +++++++++++++--

block/vmdk.c | 3 ++

block/vpc.c | 2 +-

blockdev.c | 16 +++++++--

qemu-img.c | 11 ++++--

tests/test-block-iothread.c | 2 +-

docs/qemu-block-drivers.texi | 4 +--

qemu-img.texi | 4 +--

tests/qemu-iotests/041 | 62 +++++++++++++++++++++++++++++---

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

tests/qemu-iotests/122 | 17 +++++++++

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

tests/qemu-iotests/141 | 9 +++--

tests/qemu-iotests/141.out | 5 ---

tests/qemu-iotests/188 | 20 ++++++++++-

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

tests/qemu-iotests/common.filter | 5 +++

35 files changed, 313 insertions(+), 43 deletions(-)

2.21.0

From: Maxim Levitsky <mlevitsk@redhat.com>

preallocation=off and preallocation=metadata

both allocate luks header only, and preallocation=falloc/full

is passed to underlying file.

Fixes: https://bugzilla.redhat.com/show_bug.cgi?id=1534951

Signed-off-by: Maxim Levitsky <mlevitsk@redhat.com>

Message-id: 20190716161901.1430-1-mlevitsk@redhat.com

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

qapi/block-core.json | 6 +++++-

block/crypto.c | 30 +++++++++++++++++++++++++++---

2 files changed, 32 insertions(+), 4 deletions(-)

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

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

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

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

#

# @file Node to create the image format on

# @size Size of the virtual disk in bytes

+# @preallocation Preallocation mode for the new image

+# (since: 4.2)

+# (default: off; allowed values: off, metadata, falloc, full)

#

# Since: 2.12

##

{ 'struct': 'BlockdevCreateOptionsLUKS',

'base': 'QCryptoBlockCreateOptionsLUKS',

'data': { 'file': 'BlockdevRef',

- 'size': 'size' } }

+ 'size': 'size',

+ '*preallocation': 'PreallocMode' } }

##

# @BlockdevCreateOptionsNfs:

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

index XXXXXXX..XXXXXXX 100644

--- a/block/crypto.c

+++ b/block/crypto.c

@@ -XXX,XX +XXX,XX @@ static ssize_t block_crypto_read_func(QCryptoBlock *block,

struct BlockCryptoCreateData {

BlockBackend *blk;

uint64_t size;

+ PreallocMode prealloc;

};

@@ -XXX,XX +XXX,XX @@ static ssize_t block_crypto_init_func(QCryptoBlock *block,

* available to the guest, so we must take account of that

* which will be used by the crypto header

*/

- return blk_truncate(data->blk, data->size + headerlen, PREALLOC_MODE_OFF,

+ return blk_truncate(data->blk, data->size + headerlen, data->prealloc,

errp);

}

@@ -XXX,XX +XXX,XX @@ static int block_crypto_open_generic(QCryptoBlockFormat format,

static int block_crypto_co_create_generic(BlockDriverState *bs,

int64_t size,

QCryptoBlockCreateOptions *opts,

+ PreallocMode prealloc,

Error **errp)

int ret;

@@ -XXX,XX +XXX,XX @@ static int block_crypto_co_create_generic(BlockDriverState *bs,

goto cleanup;

+ if (prealloc == PREALLOC_MODE_METADATA) {

+ prealloc = PREALLOC_MODE_OFF;

data = (struct BlockCryptoCreateData) {

.blk = blk,

.size = size,

+ .prealloc = prealloc,

};

crypto = qcrypto_block_create(opts, NULL,

@@ -XXX,XX +XXX,XX @@ block_crypto_co_create_luks(BlockdevCreateOptions *create_options, Error **errp)

BlockdevCreateOptionsLUKS *luks_opts;

BlockDriverState *bs = NULL;

QCryptoBlockCreateOptions create_opts;

+ PreallocMode preallocation = PREALLOC_MODE_OFF;

int ret;

assert(create_options->driver == BLOCKDEV_DRIVER_LUKS);

@@ -XXX,XX +XXX,XX @@ block_crypto_co_create_luks(BlockdevCreateOptions *create_options, Error **errp)

.u.luks = *qapi_BlockdevCreateOptionsLUKS_base(luks_opts),

};

+ if (luks_opts->has_preallocation) {

+ preallocation = luks_opts->preallocation;

+ }

+

ret = block_crypto_co_create_generic(bs, luks_opts->size, &create_opts,

- errp);

+ preallocation, errp);

if (ret < 0) {

goto fail;

@@ -XXX,XX +XXX,XX @@ static int coroutine_fn block_crypto_co_create_opts_luks(const char *filename,

QCryptoBlockCreateOptions *create_opts = NULL;

BlockDriverState *bs = NULL;

QDict *cryptoopts;

+ PreallocMode prealloc;

+ char *buf = NULL;

int64_t size;

int ret;

+ Error *local_err = NULL;

/* Parse options */

size = qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0);

+ buf = qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC);

+ prealloc = qapi_enum_parse(&PreallocMode_lookup, buf,

+ PREALLOC_MODE_OFF, &local_err);

+ g_free(buf);

+ if (local_err) {

+ error_propagate(errp, local_err);

+ return -EINVAL;

+ }

+

cryptoopts = qemu_opts_to_qdict_filtered(opts, NULL,

&block_crypto_create_opts_luks,

true);

@@ -XXX,XX +XXX,XX @@ static int coroutine_fn block_crypto_co_create_opts_luks(const char *filename,

/* Create format layer */

- ret = block_crypto_co_create_generic(bs, size, create_opts, errp);

+ ret = block_crypto_co_create_generic(bs, size, create_opts, prealloc, errp);

if (ret < 0) {

goto fail;

}

2.21.0

bdrv_has_zero_init() only has meaning for newly created images or image

areas. If qemu-img convert did not create the image itself, it cannot

rely on bdrv_has_zero_init()'s result to carry any meaning.

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

Message-id: 20190724171239.8764-2-mreitz@redhat.com

Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com>

Reviewed-by: Stefano Garzarella <sgarzare@redhat.com>

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

---

qemu-img.c | 11 ++++++++---

1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/qemu-img.c b/qemu-img.c

--- a/qemu-img.c

+++ b/qemu-img.c

@@ -XXX,XX +XXX,XX @@ typedef struct ImgConvertState {

bool has_zero_init;

bool compressed;

bool unallocated_blocks_are_zero;

+ bool target_is_new;

bool target_has_backing;

int64_t target_backing_sectors; /* negative if unknown */

bool wr_in_order;

@@ -XXX,XX +XXX,XX @@ static int convert_do_copy(ImgConvertState *s)

int64_t sector_num = 0;

/* Check whether we have zero initialisation or can get it efficiently */

- s->has_zero_init = s->min_sparse && !s->target_has_backing

- ? bdrv_has_zero_init(blk_bs(s->target))

- : false;

+ if (s->target_is_new && s->min_sparse && !s->target_has_backing) {

+ s->has_zero_init = bdrv_has_zero_init(blk_bs(s->target));

+ } else {

+ s->has_zero_init = false;

+ }

if (!s->has_zero_init && !s->target_has_backing &&

bdrv_can_write_zeroes_with_unmap(blk_bs(s->target)))

@@ -XXX,XX +XXX,XX @@ static int img_convert(int argc, char **argv)

}

+ s.target_is_new = !skip_create;

+

flags = s.min_sparse ? (BDRV_O_RDWR | BDRV_O_UNMAP) : BDRV_O_RDWR;

ret = bdrv_parse_cache_mode(cache, &flags, &writethrough);

if (ret < 0) {

2.21.0

bdrv_has_zero_init() only has meaning for newly created images or image

areas. If the mirror job itself did not create the image, it cannot

rely on bdrv_has_zero_init()'s result to carry any meaning.

This is the case for drive-mirror with mode=existing and always for

blockdev-mirror.

Note that we only have to zero-initialize the target with sync=full,

because other modes actually do not promise that the target will contain

the same data as the source after the job -- sync=top only promises to

copy anything allocated in the top layer, and sync=none will only copy

new I/O. (Which is how mirror has always handled it.)

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

Message-id: 20190724171239.8764-3-mreitz@redhat.com

Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com>

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

---

include/block/block_int.h | 2 ++

block/mirror.c | 11 ++++++++---

blockdev.c | 16 +++++++++++++---

tests/test-block-iothread.c | 2 +-

4 files changed, 24 insertions(+), 7 deletions(-)

diff --git a/include/block/block_int.h b/include/block/block_int.h

index XXXXXXX..XXXXXXX 100644

--- a/include/block/block_int.h

+++ b/include/block/block_int.h

@@ -XXX,XX +XXX,XX @@ BlockJob *commit_active_start(const char *job_id, BlockDriverState *bs,

* @buf_size: The amount of data that can be in flight at one time.

* @mode: Whether to collapse all images in the chain to the target.

* @backing_mode: How to establish the target's backing chain after completion.

+ * @zero_target: Whether the target should be explicitly zero-initialized

* @on_source_error: The action to take upon error reading from the source.

* @on_target_error: The action to take upon error writing to the target.

* @unmap: Whether to unmap target where source sectors only contain zeroes.

@@ -XXX,XX +XXX,XX @@ void mirror_start(const char *job_id, BlockDriverState *bs,

int creation_flags, int64_t speed,

uint32_t granularity, int64_t buf_size,

MirrorSyncMode mode, BlockMirrorBackingMode backing_mode,

+ bool zero_target,

BlockdevOnError on_source_error,

BlockdevOnError on_target_error,

bool unmap, const char *filter_node_name,

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

index XXXXXXX..XXXXXXX 100644

--- a/block/mirror.c

+++ b/block/mirror.c

@@ -XXX,XX +XXX,XX @@ typedef struct MirrorBlockJob {

Error *replace_blocker;

bool is_none_mode;

BlockMirrorBackingMode backing_mode;

+ /* Whether the target image requires explicit zero-initialization */

+ bool zero_target;

MirrorCopyMode copy_mode;

BlockdevOnError on_source_error, on_target_error;

bool synced;

@@ -XXX,XX +XXX,XX @@ static int coroutine_fn mirror_dirty_init(MirrorBlockJob *s)

int ret;

int64_t count;

- if (base == NULL && !bdrv_has_zero_init(target_bs)) {

+ if (s->zero_target) {

if (!bdrv_can_write_zeroes_with_unmap(target_bs)) {

bdrv_set_dirty_bitmap(s->dirty_bitmap, 0, s->bdev_length);

return 0;

@@ -XXX,XX +XXX,XX @@ static BlockJob *mirror_start_job(

const char *replaces, int64_t speed,

uint32_t granularity, int64_t buf_size,

BlockMirrorBackingMode backing_mode,

+ bool zero_target,

BlockdevOnError on_source_error,

BlockdevOnError on_target_error,

bool unmap,

@@ -XXX,XX +XXX,XX @@ static BlockJob *mirror_start_job(

s->on_target_error = on_target_error;

s->is_none_mode = is_none_mode;

s->backing_mode = backing_mode;

+ s->zero_target = zero_target;

s->copy_mode = copy_mode;

s->base = base;

s->granularity = granularity;

@@ -XXX,XX +XXX,XX @@ void mirror_start(const char *job_id, BlockDriverState *bs,

int creation_flags, int64_t speed,

uint32_t granularity, int64_t buf_size,

MirrorSyncMode mode, BlockMirrorBackingMode backing_mode,

+ bool zero_target,

BlockdevOnError on_source_error,

BlockdevOnError on_target_error,

bool unmap, const char *filter_node_name,

@@ -XXX,XX +XXX,XX @@ void mirror_start(const char *job_id, BlockDriverState *bs,

is_none_mode = mode == MIRROR_SYNC_MODE_NONE;

base = mode == MIRROR_SYNC_MODE_TOP ? backing_bs(bs) : NULL;

mirror_start_job(job_id, bs, creation_flags, target, replaces,

- speed, granularity, buf_size, backing_mode,

+ speed, granularity, buf_size, backing_mode, zero_target,

on_source_error, on_target_error, unmap, NULL, NULL,

&mirror_job_driver, is_none_mode, base, false,

filter_node_name, true, copy_mode, errp);

@@ -XXX,XX +XXX,XX @@ BlockJob *commit_active_start(const char *job_id, BlockDriverState *bs,

ret = mirror_start_job(

job_id, bs, creation_flags, base, NULL, speed, 0, 0,

- MIRROR_LEAVE_BACKING_CHAIN,

+ MIRROR_LEAVE_BACKING_CHAIN, false,

on_error, on_error, true, cb, opaque,

&commit_active_job_driver, false, base, auto_complete,

filter_node_name, false, MIRROR_COPY_MODE_BACKGROUND,

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

index XXXXXXX..XXXXXXX 100644

--- a/blockdev.c

+++ b/blockdev.c

@@ -XXX,XX +XXX,XX @@ static void blockdev_mirror_common(const char *job_id, BlockDriverState *bs,

bool has_replaces, const char *replaces,

enum MirrorSyncMode sync,

BlockMirrorBackingMode backing_mode,

+ bool zero_target,

bool has_speed, int64_t speed,

bool has_granularity, uint32_t granularity,

bool has_buf_size, int64_t buf_size,

@@ -XXX,XX +XXX,XX @@ static void blockdev_mirror_common(const char *job_id, BlockDriverState *bs,

*/

mirror_start(job_id, bs, target,

has_replaces ? replaces : NULL, job_flags,

- speed, granularity, buf_size, sync, backing_mode,

+ speed, granularity, buf_size, sync, backing_mode, zero_target,

on_source_error, on_target_error, unmap, filter_node_name,

copy_mode, errp);

}

@@ -XXX,XX +XXX,XX @@ void qmp_drive_mirror(DriveMirror *arg, Error **errp)

int flags;

int64_t size;

const char *format = arg->format;

+ bool zero_target;

int ret;

bs = qmp_get_root_bs(arg->device, errp);

@@ -XXX,XX +XXX,XX @@ void qmp_drive_mirror(DriveMirror *arg, Error **errp)

goto out;

}

+ zero_target = (arg->sync == MIRROR_SYNC_MODE_FULL &&

+ (arg->mode == NEW_IMAGE_MODE_EXISTING ||

+ !bdrv_has_zero_init(target_bs)));

+

ret = bdrv_try_set_aio_context(target_bs, aio_context, errp);

if (ret < 0) {

bdrv_unref(target_bs);

@@ -XXX,XX +XXX,XX @@ void qmp_drive_mirror(DriveMirror *arg, Error **errp)

blockdev_mirror_common(arg->has_job_id ? arg->job_id : NULL, bs, target_bs,

arg->has_replaces, arg->replaces, arg->sync,

- backing_mode, arg->has_speed, arg->speed,

+ backing_mode, zero_target,

+ arg->has_speed, arg->speed,

arg->has_granularity, arg->granularity,

arg->has_buf_size, arg->buf_size,

arg->has_on_source_error, arg->on_source_error,

@@ -XXX,XX +XXX,XX @@ void qmp_blockdev_mirror(bool has_job_id, const char *job_id,

AioContext *aio_context;

BlockMirrorBackingMode backing_mode = MIRROR_LEAVE_BACKING_CHAIN;

Error *local_err = NULL;

+ bool zero_target;

int ret;

bs = qmp_get_root_bs(device, errp);

@@ -XXX,XX +XXX,XX @@ void qmp_blockdev_mirror(bool has_job_id, const char *job_id,

return;

}

+ zero_target = (sync == MIRROR_SYNC_MODE_FULL);

+

aio_context = bdrv_get_aio_context(bs);

aio_context_acquire(aio_context);

@@ -XXX,XX +XXX,XX @@ void qmp_blockdev_mirror(bool has_job_id, const char *job_id,

blockdev_mirror_common(has_job_id ? job_id : NULL, bs, target_bs,

has_replaces, replaces, sync, backing_mode,

- has_speed, speed,

+ zero_target, has_speed, speed,

has_granularity, granularity,

has_buf_size, buf_size,

has_on_source_error, on_source_error,

diff --git a/tests/test-block-iothread.c b/tests/test-block-iothread.c

index XXXXXXX..XXXXXXX 100644

--- a/tests/test-block-iothread.c

+++ b/tests/test-block-iothread.c

@@ -XXX,XX +XXX,XX @@ static void test_propagate_mirror(void)

/* Start a mirror job */

mirror_start("job0", src, target, NULL, JOB_DEFAULT, 0, 0, 0,

- MIRROR_SYNC_MODE_NONE, MIRROR_OPEN_BACKING_CHAIN,

+ MIRROR_SYNC_MODE_NONE, MIRROR_OPEN_BACKING_CHAIN, false,

BLOCKDEV_ON_ERROR_REPORT, BLOCKDEV_ON_ERROR_REPORT,

false, "filter_node", MIRROR_COPY_MODE_BACKGROUND,

&error_abort);

--

2.21.0

We need to implement .bdrv_has_zero_init_truncate() for every block

driver that supports truncation and has a .bdrv_has_zero_init()

implementation.

Implement it the same way each driver implements .bdrv_has_zero_init().

This is at least not any more unsafe than what we had before.

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

Message-id: 20190724171239.8764-5-mreitz@redhat.com

Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com>

Reviewed-by: Stefano Garzarella <sgarzare@redhat.com>

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

---

block/file-posix.c | 1 +

block/file-win32.c | 1 +

block/gluster.c | 4 ++++

block/nfs.c | 1 +

block/qcow2.c | 1 +

block/qed.c | 1 +

block/raw-format.c | 6 ++++++

block/rbd.c | 1 +

block/sheepdog.c | 1 +

block/ssh.c | 1 +

10 files changed, 18 insertions(+)

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

--- a/block/file-posix.c

+++ b/block/file-posix.c

@@ -XXX,XX +XXX,XX @@ BlockDriver bdrv_file = {

.bdrv_co_create = raw_co_create,

.bdrv_co_create_opts = raw_co_create_opts,

.bdrv_has_zero_init = bdrv_has_zero_init_1,

+ .bdrv_has_zero_init_truncate = bdrv_has_zero_init_1,

.bdrv_co_block_status = raw_co_block_status,

.bdrv_co_invalidate_cache = raw_co_invalidate_cache,

.bdrv_co_pwrite_zeroes = raw_co_pwrite_zeroes,

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

index XXXXXXX..XXXXXXX 100644

--- a/block/file-win32.c

+++ b/block/file-win32.c

@@ -XXX,XX +XXX,XX @@ BlockDriver bdrv_file = {

.bdrv_close = raw_close,

.bdrv_co_create_opts = raw_co_create_opts,

.bdrv_has_zero_init = bdrv_has_zero_init_1,

+ .bdrv_has_zero_init_truncate = bdrv_has_zero_init_1,

.bdrv_aio_preadv = raw_aio_preadv,

.bdrv_aio_pwritev = raw_aio_pwritev,

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

index XXXXXXX..XXXXXXX 100644

--- a/block/gluster.c

+++ b/block/gluster.c

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

.bdrv_co_writev = qemu_gluster_co_writev,

.bdrv_co_flush_to_disk = qemu_gluster_co_flush_to_disk,

.bdrv_has_zero_init = qemu_gluster_has_zero_init,

+ .bdrv_has_zero_init_truncate = qemu_gluster_has_zero_init,

#ifdef CONFIG_GLUSTERFS_DISCARD

.bdrv_co_pdiscard = qemu_gluster_co_pdiscard,

#endif

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

.bdrv_co_writev = qemu_gluster_co_writev,

.bdrv_co_flush_to_disk = qemu_gluster_co_flush_to_disk,

.bdrv_has_zero_init = qemu_gluster_has_zero_init,

+ .bdrv_has_zero_init_truncate = qemu_gluster_has_zero_init,

#ifdef CONFIG_GLUSTERFS_DISCARD

.bdrv_co_pdiscard = qemu_gluster_co_pdiscard,

#endif

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

.bdrv_co_writev = qemu_gluster_co_writev,

.bdrv_co_flush_to_disk = qemu_gluster_co_flush_to_disk,

.bdrv_has_zero_init = qemu_gluster_has_zero_init,

+ .bdrv_has_zero_init_truncate = qemu_gluster_has_zero_init,

#ifdef CONFIG_GLUSTERFS_DISCARD

.bdrv_co_pdiscard = qemu_gluster_co_pdiscard,

#endif

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

.bdrv_co_writev = qemu_gluster_co_writev,

.bdrv_co_flush_to_disk = qemu_gluster_co_flush_to_disk,

.bdrv_has_zero_init = qemu_gluster_has_zero_init,

+ .bdrv_has_zero_init_truncate = qemu_gluster_has_zero_init,

#ifdef CONFIG_GLUSTERFS_DISCARD

.bdrv_co_pdiscard = qemu_gluster_co_pdiscard,

#endif

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

index XXXXXXX..XXXXXXX 100644

--- a/block/nfs.c

+++ b/block/nfs.c

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

.create_opts = &nfs_create_opts,

.bdrv_has_zero_init = nfs_has_zero_init,

+ .bdrv_has_zero_init_truncate = nfs_has_zero_init,

.bdrv_get_allocated_file_size = nfs_get_allocated_file_size,

.bdrv_co_truncate = nfs_file_co_truncate,

@@ -XXX,XX +XXX,XX @@ BlockDriver bdrv_qcow2 = {

.bdrv_co_create_opts = qcow2_co_create_opts,

.bdrv_co_create = qcow2_co_create,

.bdrv_has_zero_init = bdrv_has_zero_init_1,

+ .bdrv_has_zero_init_truncate = bdrv_has_zero_init_1,

.bdrv_co_block_status = qcow2_co_block_status,

.bdrv_co_preadv = qcow2_co_preadv,

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

index XXXXXXX..XXXXXXX 100644

--- a/block/qed.c

+++ b/block/qed.c

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

.bdrv_co_create = bdrv_qed_co_create,

.bdrv_co_create_opts = bdrv_qed_co_create_opts,

.bdrv_has_zero_init = bdrv_has_zero_init_1,

+ .bdrv_has_zero_init_truncate = bdrv_has_zero_init_1,

.bdrv_co_block_status = bdrv_qed_co_block_status,

.bdrv_co_readv = bdrv_qed_co_readv,

.bdrv_co_writev = bdrv_qed_co_writev,

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

index XXXXXXX..XXXXXXX 100644

--- a/block/raw-format.c

+++ b/block/raw-format.c

@@ -XXX,XX +XXX,XX @@ static int raw_has_zero_init(BlockDriverState *bs)

return bdrv_has_zero_init(bs->file->bs);

}

+static int raw_has_zero_init_truncate(BlockDriverState *bs)

+{

+ return bdrv_has_zero_init_truncate(bs->file->bs);

+}

+

static int coroutine_fn raw_co_create_opts(const char *filename, QemuOpts *opts,

Error **errp)

{

@@ -XXX,XX +XXX,XX @@ BlockDriver bdrv_raw = {

.bdrv_co_ioctl = &raw_co_ioctl,

.create_opts = &raw_create_opts,

.bdrv_has_zero_init = &raw_has_zero_init,

+ .bdrv_has_zero_init_truncate = &raw_has_zero_init_truncate,

.strong_runtime_opts = raw_strong_runtime_opts,

.mutable_opts = mutable_opts,

};

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

index XXXXXXX..XXXXXXX 100644

--- a/block/rbd.c

+++ b/block/rbd.c

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

.bdrv_co_create = qemu_rbd_co_create,

.bdrv_co_create_opts = qemu_rbd_co_create_opts,

.bdrv_has_zero_init = bdrv_has_zero_init_1,

+ .bdrv_has_zero_init_truncate = bdrv_has_zero_init_1,

.bdrv_get_info = qemu_rbd_getinfo,

.create_opts = &qemu_rbd_create_opts,

.bdrv_getlength = qemu_rbd_getlength,

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

index XXXXXXX..XXXXXXX 100644

--- a/block/sheepdog.c

+++ b/block/sheepdog.c

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

.bdrv_co_create = sd_co_create,

.bdrv_co_create_opts = sd_co_create_opts,

.bdrv_has_zero_init = bdrv_has_zero_init_1,

+ .bdrv_has_zero_init_truncate = bdrv_has_zero_init_1,

.bdrv_getlength = sd_getlength,

.bdrv_get_allocated_file_size = sd_get_allocated_file_size,

.bdrv_co_truncate = sd_co_truncate,

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

index XXXXXXX..XXXXXXX 100644

--- a/block/ssh.c

+++ b/block/ssh.c

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

.bdrv_co_create_opts = ssh_co_create_opts,

.bdrv_close = ssh_close,

.bdrv_has_zero_init = ssh_has_zero_init,

+ .bdrv_has_zero_init_truncate = ssh_has_zero_init,

.bdrv_co_readv = ssh_co_readv,

.bdrv_co_writev = ssh_co_writev,

.bdrv_getlength = ssh_getlength,

2.21.0

vhdx and parallels call bdrv_has_zero_init() when they do not really

care about an image's post-create state but only about what happens when

you grow an image. That is a bit ugly, and also overly safe when

growing preallocated images without preallocating the new areas.

Let them use bdrv_has_zero_init_truncate() instead.

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

Message-id: 20190724171239.8764-6-mreitz@redhat.com

Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com>

Reviewed-by: Stefano Garzarella <sgarzare@redhat.com>

[mreitz: Added commit message]

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

---

block/parallels.c | 2 +-

block/vhdx.c | 2 +-

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

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

--- a/block/parallels.c

+++ b/block/parallels.c

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

goto fail_options;

- if (!bdrv_has_zero_init(bs->file->bs)) {

+ if (!bdrv_has_zero_init_truncate(bs->file->bs)) {

s->prealloc_mode = PRL_PREALLOC_MODE_FALLOCATE;

2.21.0

If a qcow2 file is preallocated, it can no longer guarantee that it

initially appears as filled with zeroes.

So implement .bdrv_has_zero_init() by checking whether the file is

preallocated; if so, forward the call to the underlying storage node,

except for when it is encrypted: Encrypted preallocated images always

return effectively random data, so .bdrv_has_zero_init() must always

return 0 for them.

.bdrv_has_zero_init_truncate() can remain bdrv_has_zero_init_1(),

because it presupposes PREALLOC_MODE_OFF.

Reported-by: Stefano Garzarella <sgarzare@redhat.com>

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

Message-id: 20190724171239.8764-7-mreitz@redhat.com

Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com>

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

block/qcow2.c | 29 ++++++++++++++++++++++++++++-

1 file changed, 28 insertions(+), 1 deletion(-)

@@ -XXX,XX +XXX,XX @@ static ImageInfoSpecific *qcow2_get_specific_info(BlockDriverState *bs,

return spec_info;

}

+static int qcow2_has_zero_init(BlockDriverState *bs)

+{

+ BDRVQcow2State *s = bs->opaque;

+ bool preallocated;

+

+ if (qemu_in_coroutine()) {

+ qemu_co_mutex_lock(&s->lock);

+ }

+ /*

+ * Check preallocation status: Preallocated images have all L2

+ * tables allocated, nonpreallocated images have none. It is

+ * therefore enough to check the first one.

+ */

+ preallocated = s->l1_size > 0 && s->l1_table[0] != 0;

+ if (qemu_in_coroutine()) {

+ qemu_co_mutex_unlock(&s->lock);

+ }

+

+ if (!preallocated) {

+ return 1;

+ } else if (bs->encrypted) {

+ return 0;

+ } else {

+ return bdrv_has_zero_init(s->data_file->bs);

+ }

+}

+

static int qcow2_save_vmstate(BlockDriverState *bs, QEMUIOVector *qiov,

int64_t pos)

@@ -XXX,XX +XXX,XX @@ BlockDriver bdrv_qcow2 = {

.bdrv_child_perm = bdrv_format_default_perms,

.bdrv_co_create_opts = qcow2_co_create_opts,

.bdrv_co_create = qcow2_co_create,

- .bdrv_has_zero_init = bdrv_has_zero_init_1,

+ .bdrv_has_zero_init = qcow2_has_zero_init,

.bdrv_has_zero_init_truncate = bdrv_has_zero_init_1,

.bdrv_co_block_status = qcow2_co_block_status,

2.21.0

Static VDI images cannot guarantee to be zero-initialized. If the image

has been statically allocated, forward the call to the underlying

storage node.

Reported-by: Stefano Garzarella <sgarzare@redhat.com>

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

Reviewed-by: Stefan Weil <sw@weilnetz.de>

Acked-by: Stefano Garzarella <sgarzare@redhat.com>

Tested-by: Stefano Garzarella <sgarzare@redhat.com>

Message-id: 20190724171239.8764-8-mreitz@redhat.com

Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com>

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

block/vdi.c | 13 ++++++++++++-

1 file changed, 12 insertions(+), 1 deletion(-)

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

--- a/block/vdi.c

+++ b/block/vdi.c

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

error_free(s->migration_blocker);

+static int vdi_has_zero_init(BlockDriverState *bs)

+ BDRVVdiState *s = bs->opaque;

+ if (s->header.image_type == VDI_TYPE_STATIC) {

+ return bdrv_has_zero_init(bs->file->bs);

+ } else {

+ return 1;

static QemuOptsList vdi_create_opts = {

.name = "vdi-create-opts",

.head = QTAILQ_HEAD_INITIALIZER(vdi_create_opts.head),

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

.bdrv_child_perm = bdrv_format_default_perms,

.bdrv_co_create = vdi_co_create,

.bdrv_co_create_opts = vdi_co_create_opts,

- .bdrv_has_zero_init = bdrv_has_zero_init_1,

+ .bdrv_has_zero_init = vdi_has_zero_init,

.bdrv_co_block_status = vdi_co_block_status,

.bdrv_make_empty = vdi_make_empty,

2.21.0

Fixed VHDX images cannot guarantee to be zero-initialized. If the image

has the "fixed" subformat, forward the call to the underlying storage

node.

Reported-by: Stefano Garzarella <sgarzare@redhat.com>

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

Message-id: 20190724171239.8764-9-mreitz@redhat.com

Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com>

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

---

block/vhdx.c | 26 +++++++++++++++++++++++++-

1 file changed, 25 insertions(+), 1 deletion(-)

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

--- a/block/vhdx.c

+++ b/block/vhdx.c

@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vhdx_co_check(BlockDriverState *bs,

return 0;

}

+static int vhdx_has_zero_init(BlockDriverState *bs)

+{

+ BDRVVHDXState *s = bs->opaque;

+ int state;

+

+ /*

+ * Check the subformat: Fixed images have all BAT entries present,

+ * dynamic images have none (right after creation). It is

+ * therefore enough to check the first BAT entry.

+ */

+ if (!s->bat_entries) {

+ return 1;

+ }

+