The following changes since commit 5ec2eca83dc478ddf24077e02a8b34dd26cd3ff9:

Merge remote-tracking branch 'remotes/awilliam/tags/vfio-updates-20190613.0' into staging (2019-06-14 09:33:55 +0100)

https://github.com/XanClic/qemu.git tags/pull-block-2019-06-14

for you to fetch changes up to 21c1ce592a144188dfe59b9e156a97da412a59a2:

iotests: Test qemu-img convert -C --salvage (2019-06-14 15:09:42 +0200)

- Allow blockdev-backup from nodes that are not in qemu's main AIO

context to newly added nodes

- Add salvaging mode to qemu-img convert

- Minor fixes to tests, documentation, and for less Valgrind annoyance

Andrey Shinkevich (1):

hw/block/fdc: floppy command FIFO memory initialization

John Snow (6):

blockdev-backup: don't check aio_context too early

iotests.py: do not use infinite waits

QEMUMachine: add events_wait method

iotests.py: rewrite run_job to be pickier

iotests: add iotest 256 for testing blockdev-backup across iothread

contexts

event_match: always match on None value

Max Reitz (12):

iotests: Filter 175's allocation information

iotests: Fix intermittent failure in 219

qemu-img: Fix options leakage in img_rebase()

qapi/block-core: Overlays are not snapshots

blockdev: Overlays are not snapshots

qemu-img: Move quiet into ImgConvertState

qemu-img: Add salvaging mode to convert

blkdebug: Add @iotype error option

blkdebug: Add "none" event

blkdebug: Inject errors on .bdrv_co_block_status()

iotests: Test qemu-img convert --salvage

iotests: Test qemu-img convert -C --salvage

Vladimir Sementsov-Ogievskiy (1):

iotests: restrict 254 to support only qcow2

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

block/blkdebug.c | 60 ++++++++++--

blockdev.c | 14 +--

hw/block/fdc.c | 1 +

qemu-img.c | 106 +++++++++++++++------

python/qemu/__init__.py | 67 ++++++++++----

qemu-img-cmds.hx | 4 +-

qemu-img.texi | 4 +

tests/qemu-iotests/082 | 1 +

tests/qemu-iotests/082.out | 3 +

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

tests/qemu-iotests/175 | 26 +++++-

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

tests/qemu-iotests/219 | 13 ++-

tests/qemu-iotests/251 | 170 ++++++++++++++++++++++++++++++++++

tests/qemu-iotests/251.out | 43 +++++++++

tests/qemu-iotests/254 | 2 +

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

tests/qemu-iotests/256.out | 119 ++++++++++++++++++++++++

tests/qemu-iotests/group | 2 +

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

21 files changed, 772 insertions(+), 116 deletions(-)

create mode 100755 tests/qemu-iotests/251

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

create mode 100755 tests/qemu-iotests/256

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

2.21.0

We do not support this combination (yet), so this should yield an error

message.

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

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

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

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

tests/qemu-iotests/082 | 1 +

tests/qemu-iotests/082.out | 3 +++

2 files changed, 4 insertions(+)

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

index XXXXXXX..XXXXXXX 100755

--- a/tests/qemu-iotests/082

+++ b/tests/qemu-iotests/082

@@ -XXX,XX +XXX,XX @@ echo === convert: -C and other options ===

run_qemu_img convert -C -S 4k -O $IMGFMT "$TEST_IMG" "$TEST_IMG".target

run_qemu_img convert -C -S 8k -O $IMGFMT "$TEST_IMG" "$TEST_IMG".target

run_qemu_img convert -C -c -O $IMGFMT "$TEST_IMG" "$TEST_IMG".target

+run_qemu_img convert -C --salvage -O $IMGFMT "$TEST_IMG" "$TEST_IMG".target

echo

echo === amend: Options specified more than once ===

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

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

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

@@ -XXX,XX +XXX,XX @@ qemu-img: Cannot enable copy offloading when -S is used

Testing: convert -C -c -O qcow2 TEST_DIR/t.qcow2 TEST_DIR/t.qcow2.target

qemu-img: Cannot enable copy offloading when -c is used

+Testing: convert -C --salvage -O qcow2 TEST_DIR/t.qcow2 TEST_DIR/t.qcow2.target

+qemu-img: Cannot use copy offloading in salvaging mode

=== amend: Options specified more than once ===

Testing: amend -f foo -f qcow2 -o lazy_refcounts=on TEST_DIR/t.qcow2

2.21.0

Together with @iotypes and @sector, this can be used to trap e.g. the

first read or write access to a certain sector without having to know

what happens internally in the block layer, i.e. which "real" events

happen right before such an access.

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

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

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

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

block/blkdebug.c | 2 ++

2 files changed, 5 insertions(+), 1 deletion(-)

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 @@

#

# @cluster_alloc_space: an allocation of file space for a cluster (since 4.1)

#

+# @none: triggers once at creation of the blkdebug node (since 4.1)

+#

# Since: 2.9

##

{ 'enum': 'BlkdebugEvent', 'prefix': 'BLKDBG',

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

'pwritev_rmw_tail', 'pwritev_rmw_after_tail', 'pwritev',

'pwritev_zero', 'pwritev_done', 'empty_image_prepare',

'l1_shrink_write_table', 'l1_shrink_free_l2_clusters',

- 'cor_write', 'cluster_alloc_space'] }

+ 'cor_write', 'cluster_alloc_space', 'none'] }

##

# @BlkdebugIOType:

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

index XXXXXXX..XXXXXXX 100644

--- a/block/blkdebug.c

+++ b/block/blkdebug.c

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

goto out;

+ bdrv_debug_event(bs, BLKDBG_NONE);

+

ret = 0;

out:

if (ret < 0) {

2.21.0

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

Reviewed-by: Eric Blake <eblake@redhat.com>

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

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

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

block/blkdebug.c | 8 ++++++++

2 files changed, 12 insertions(+), 1 deletion(-)

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 @@

#

# @flush: .bdrv_co_flush_to_disk()

#

+# @block-status: .bdrv_co_block_status()

+#

# Since: 4.1

##

{ 'enum': 'BlkdebugIOType', 'prefix': 'BLKDEBUG_IO_TYPE',

- 'data': [ 'read', 'write', 'write-zeroes', 'discard', 'flush' ] }

+ 'data': [ 'read', 'write', 'write-zeroes', 'discard', 'flush',

+ 'block-status' ] }

##

# @BlkdebugInjectErrorOptions:

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

index XXXXXXX..XXXXXXX 100644

--- a/block/blkdebug.c

+++ b/block/blkdebug.c

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

int64_t *map,

BlockDriverState **file)

{

+ int err;

+

assert(QEMU_IS_ALIGNED(offset | bytes, bs->bl.request_alignment));

+

+ err = rule_check(bs, offset, bytes, BLKDEBUG_IO_TYPE_BLOCK_STATUS);

+ if (err) {

+ return err;

+ }

+

return bdrv_co_block_status_from_file(bs, want_zero, offset, bytes,

pnum, map, file);

}

2.21.0

This adds a salvaging mode (--salvage) to qemu-img convert which ignores

read errors and treats the respective areas as containing only zeroes.

This can be used for instance to at least partially recover the data

from terminally corrupted qcow2 images.

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

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

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

qemu-img.c | 90 +++++++++++++++++++++++++++++++++++++-----------

qemu-img-cmds.hx | 4 +--

qemu-img.texi | 4 +++

3 files changed, 75 insertions(+), 23 deletions(-)

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

--- a/qemu-img.c

+++ b/qemu-img.c

@@ -XXX,XX +XXX,XX @@ enum {

OPTION_SIZE = 264,

OPTION_PREALLOCATION = 265,

OPTION_SHRINK = 266,

+ OPTION_SALVAGE = 267,

};

typedef enum OutputFormat {

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

int64_t target_backing_sectors; /* negative if unknown */

bool wr_in_order;

bool copy_range;

+ bool salvage;

bool quiet;

int min_sparse;

int alignment;

@@ -XXX,XX +XXX,XX @@ static int convert_iteration_sectors(ImgConvertState *s, int64_t sector_num)

if (s->sector_next_status <= sector_num) {

- int64_t count = n * BDRV_SECTOR_SIZE;

+ uint64_t offset = (sector_num - src_cur_offset) * BDRV_SECTOR_SIZE;

+ int64_t count;

- if (s->target_has_backing) {

+ do {

+ count = n * BDRV_SECTOR_SIZE;

+

+ if (s->target_has_backing) {

+ ret = bdrv_block_status(blk_bs(s->src[src_cur]), offset,

+ count, &count, NULL, NULL);

+ } else {

+ ret = bdrv_block_status_above(blk_bs(s->src[src_cur]), NULL,

+ offset, count, &count, NULL,

+ NULL);

+ }

+

+ if (ret < 0) {

+ if (s->salvage) {

+ if (n == 1) {

+ if (!s->quiet) {

+ warn_report("error while reading block status at "

+ "offset %" PRIu64 ": %s", offset,

+ strerror(-ret));

+ }

+ /* Just try to read the data, then */

+ ret = BDRV_BLOCK_DATA;

+ count = BDRV_SECTOR_SIZE;

+ } else {

+ /* Retry on a shorter range */

+ n = DIV_ROUND_UP(n, 4);

+ }

+ } else {

+ error_report("error while reading block status at offset "

+ "%" PRIu64 ": %s", offset, strerror(-ret));

+ return ret;

+ }

+ }

+ } while (ret < 0);

- ret = bdrv_block_status(blk_bs(s->src[src_cur]),

- (sector_num - src_cur_offset) *

- BDRV_SECTOR_SIZE,

- count, &count, NULL, NULL);

- } else {

- ret = bdrv_block_status_above(blk_bs(s->src[src_cur]), NULL,

- (sector_num - src_cur_offset) *

- BDRV_SECTOR_SIZE,

- count, &count, NULL, NULL);

- }

- if (ret < 0) {

- error_report("error while reading block status of sector %" PRId64

- ": %s", sector_num, strerror(-ret));

- return ret;

- }

n = DIV_ROUND_UP(count, BDRV_SECTOR_SIZE);

if (ret & BDRV_BLOCK_ZERO) {

@@ -XXX,XX +XXX,XX @@ static int convert_iteration_sectors(ImgConvertState *s, int64_t sector_num)

static int coroutine_fn convert_co_read(ImgConvertState *s, int64_t sector_num,

int nb_sectors, uint8_t *buf)

{

+ uint64_t single_read_until = 0;

int n, ret;

assert(nb_sectors <= s->buf_sectors);

@@ -XXX,XX +XXX,XX @@ static int coroutine_fn convert_co_read(ImgConvertState *s, int64_t sector_num,

BlockBackend *blk;

int src_cur;

int64_t bs_sectors, src_cur_offset;

+ uint64_t offset;

/* In the case of compression with multiple source files, we can get a

* nb_sectors that spreads into the next part. So we must be able to

@@ -XXX,XX +XXX,XX @@ static int coroutine_fn convert_co_read(ImgConvertState *s, int64_t sector_num,

blk = s->src[src_cur];

bs_sectors = s->src_sectors[src_cur];

+ offset = (sector_num - src_cur_offset) << BDRV_SECTOR_BITS;

+

n = MIN(nb_sectors, bs_sectors - (sector_num - src_cur_offset));

+ if (single_read_until > offset) {

+ n = 1;

- ret = blk_co_pread(

- blk, (sector_num - src_cur_offset) << BDRV_SECTOR_BITS,

- n << BDRV_SECTOR_BITS, buf, 0);

+ ret = blk_co_pread(blk, offset, n << BDRV_SECTOR_BITS, buf, 0);

if (ret < 0) {

- return ret;

+ if (s->salvage) {

+ if (n > 1) {

+ single_read_until = offset + (n << BDRV_SECTOR_BITS);

+ continue;

+ } else {

+ if (!s->quiet) {

+ warn_report("error while reading offset %" PRIu64

+ ": %s", offset, strerror(-ret));

+ }

+ memset(buf, 0, BDRV_SECTOR_SIZE);

+ }

+ } else {

+ return ret;

+ }

}

sector_num += n;

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

{"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},

{"force-share", no_argument, 0, 'U'},

{"target-image-opts", no_argument, 0, OPTION_TARGET_IMAGE_OPTS},

+ {"salvage", no_argument, 0, OPTION_SALVAGE},

{0, 0, 0, 0}

};

c = getopt_long(argc, argv, ":hf:O:B:Cco:l:S:pt:T:qnm:WU",

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

case OPTION_IMAGE_OPTS:

image_opts = true;

break;

+ case OPTION_SALVAGE:

+ s.salvage = true;

+ break;

case OPTION_TARGET_IMAGE_OPTS:

tgt_image_opts = true;

break;

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

goto fail_getopt;

+ if (s.copy_range && s.salvage) {

+ error_report("Cannot use copy offloading in salvaging mode");

+ goto fail_getopt;

+ }

+

if (tgt_image_opts && !skip_create) {

error_report("--target-image-opts requires use of -n flag");

goto fail_getopt;

diff --git a/qemu-img-cmds.hx b/qemu-img-cmds.hx

index XXXXXXX..XXXXXXX 100644

--- a/qemu-img-cmds.hx

+++ b/qemu-img-cmds.hx

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

ETEXI

DEF("convert", img_convert,

- "convert [--object objectdef] [--image-opts] [--target-image-opts] [-U] [-C] [-c] [-p] [-q] [-n] [-f fmt] [-t cache] [-T src_cache] [-O output_fmt] [-B backing_file] [-o options] [-l snapshot_param] [-S sparse_size] [-m num_coroutines] [-W] filename [filename2 [...]] output_filename")

+ "convert [--object objectdef] [--image-opts] [--target-image-opts] [-U] [-C] [-c] [-p] [-q] [-n] [-f fmt] [-t cache] [-T src_cache] [-O output_fmt] [-B backing_file] [-o options] [-l snapshot_param] [-S sparse_size] [-m num_coroutines] [-W] [--salvage] filename [filename2 [...]] output_filename")

STEXI

-@item convert [--object @var{objectdef}] [--image-opts] [--target-image-opts] [-U] [-C] [-c] [-p] [-q] [-n] [-f @var{fmt}] [-t @var{cache}] [-T @var{src_cache}] [-O @var{output_fmt}] [-B @var{backing_file}] [-o @var{options}] [-l @var{snapshot_param}] [-S @var{sparse_size}] [-m @var{num_coroutines}] [-W] @var{filename} [@var{filename2} [...]] @var{output_filename}

+@item convert [--object @var{objectdef}] [--image-opts] [--target-image-opts] [-U] [-C] [-c] [-p] [-q] [-n] [-f @var{fmt}] [-t @var{cache}] [-T @var{src_cache}] [-O @var{output_fmt}] [-B @var{backing_file}] [-o @var{options}] [-l @var{snapshot_param}] [-S @var{sparse_size}] [-m @var{num_coroutines}] [-W] [--salvage] @var{filename} [@var{filename2} [...]] @var{output_filename}

ETEXI

DEF("create", img_create,

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

index XXXXXXX..XXXXXXX 100644

--- a/qemu-img.texi

+++ b/qemu-img.texi

@@ -XXX,XX +XXX,XX @@ improve performance if the data is remote, such as with NFS or iSCSI backends,

but will not automatically sparsify zero sectors, and may result in a fully

allocated target image depending on the host support for getting allocation

information.

+@item --salvage

+Try to ignore I/O errors when reading. Unless in quiet mode (@code{-q}), errors

+will still be printed. Areas that cannot be read from the source will be

+treated as containing only zeroes.

@end table

Parameters to dd subcommand:

2.21.0

Don't pull events out of the queue that don't belong to us;

be choosier so that we can use this method to drive jobs that

were launched by transactions that may have more jobs.

Message-id: 20190523170643.20794-5-jsnow@redhat.com

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

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

1 file changed, 29 insertions(+), 19 deletions(-)

@@ -XXX,XX +XXX,XX @@ class VM(qtest.QEMUQtestMachine):

# Returns None on success, and an error string on failure

def run_job(self, job, auto_finalize=True, auto_dismiss=False,

pre_finalize=None, wait=60.0):

+ match_device = {'data': {'device': job}}

+ match_id = {'data': {'id': job}}

+ events = [

+ ('BLOCK_JOB_COMPLETED', match_device),

+ ('BLOCK_JOB_CANCELLED', match_device),

+ ('BLOCK_JOB_ERROR', match_device),

+ ('BLOCK_JOB_READY', match_device),

+ ('BLOCK_JOB_PENDING', match_id),

+ ('JOB_STATUS_CHANGE', match_id)

+ ]

error = None

while True:

- for ev in self.get_qmp_events_filtered(wait=wait):

- if ev['event'] == 'JOB_STATUS_CHANGE':

- status = ev['data']['status']

- if status == 'aborting':

- result = self.qmp('query-jobs')

- for j in result['return']:

- if j['id'] == job:

- error = j['error']

- log('Job failed: %s' % (j['error']))

- elif status == 'pending' and not auto_finalize:

- if pre_finalize:

- pre_finalize()

- self.qmp_log('job-finalize', id=job)

- elif status == 'concluded' and not auto_dismiss:

- self.qmp_log('job-dismiss', id=job)

- elif status == 'null':

- return error

- else:

- log(ev)

+ ev = filter_qmp_event(self.events_wait(events))

+ if ev['event'] != 'JOB_STATUS_CHANGE':

+ log(ev)

+ continue

+ status = ev['data']['status']

+ if status == 'aborting':

+ result = self.qmp('query-jobs')

+ for j in result['return']:

+ if j['id'] == job:

+ error = j['error']

+ log('Job failed: %s' % (j['error']))

+ elif status == 'pending' and not auto_finalize:

+ if pre_finalize:

+ pre_finalize()

+ self.qmp_log('job-finalize', id=job)

+ elif status == 'concluded' and not auto_dismiss:

+ self.qmp_log('job-dismiss', id=job)

+ elif status == 'null':

+ return error

def node_info(self, node_name):

nodes = self.qmp('query-named-block-nodes')

2.21.0

Move img_convert()'s quiet flag into the ImgConvertState so it is

accessible by nested functions. -q dictates that it suppresses anything

but errors, so if those functions want to emit warnings, they need to

query this flag first. (There currently are no such warnings, but there

will be as of the next patch.)

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

Reviewed-by: Eric Blake <eblake@redhat.com>

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

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

qemu-img.c | 13 +++++++------

1 file changed, 7 insertions(+), 6 deletions(-)

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

index XXXXXXX..XXXXXXX 100644

--- a/qemu-img.c

+++ b/qemu-img.c

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

int64_t target_backing_sectors; /* negative if unknown */

bool wr_in_order;

bool copy_range;

+ bool quiet;

int min_sparse;

int alignment;

size_t cluster_sectors;

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

QDict *open_opts = NULL;

char *options = NULL;

Error *local_err = NULL;

- bool writethrough, src_writethrough, quiet = false, image_opts = false,

+ bool writethrough, src_writethrough, image_opts = false,

skip_create = false, progress = false, tgt_image_opts = false;

int64_t ret = -EINVAL;

bool force_share = false;

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

src_cache = optarg;

break;

case 'q':

- quiet = true;

+ s.quiet = true;

break;

case 'n':

skip_create = true;

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

}

/* Initialize before goto out */

- if (quiet) {

+ if (s.quiet) {

progress = false;

}

qemu_progress_init(progress, 1.0);

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

for (bs_i = 0; bs_i < s.src_num; bs_i++) {

s.src[bs_i] = img_open(image_opts, argv[optind + bs_i],

- fmt, src_flags, src_writethrough, quiet,

+ fmt, src_flags, src_writethrough, s.quiet,

force_share);

if (!s.src[bs_i]) {

ret = -1;

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

if (skip_create) {

s.target = img_open(tgt_image_opts, out_filename, out_fmt,

- flags, writethrough, quiet, false);

+ flags, writethrough, s.quiet, false);

} else {

/* TODO ultimately we should allow --target-image-opts

* to be used even when -n is not given.

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

* to allow filenames in option syntax

*/

s.target = img_open_file(out_filename, open_opts, out_fmt,

- flags, writethrough, quiet, false);

+ flags, writethrough, s.quiet, false);

open_opts = NULL; /* blk_new_open will have freed it */

}

if (!s.target) {

2.21.0

From: Andrey Shinkevich <andrey.shinkevich@virtuozzo.com>

The uninitialized memory allocated for the command FIFO of the

floppy controller during the VM hardware initialization incurs

many unwanted reports by Valgrind when VM state is being saved.

That verbosity hardens a search for the real memory issues when

the iotests run. Particularly, the patch eliminates 20 unnecessary

reports of the Valgrind tool in the iotest #169.

Signed-off-by: Andrey Shinkevich <andrey.shinkevich@virtuozzo.com>

Message-id: 1559154027-282547-1-git-send-email-andrey.shinkevich@virtuozzo.com

Reviewed-by: John Snow <jsnow@redhat.com>

hw/block/fdc.c | 1 +

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

index XXXXXXX..XXXXXXX 100644

--- a/hw/block/fdc.c

+++ b/hw/block/fdc.c

@@ -XXX,XX +XXX,XX @@ static void fdctrl_realize_common(DeviceState *dev, FDCtrl *fdctrl,

FLOPPY_DPRINTF("init controller\n");

fdctrl->fifo = qemu_memalign(512, FD_SECTOR_LEN);

+ memset(fdctrl->fifo, 0, FD_SECTOR_LEN);

fdctrl->fifo_size = 512;

fdctrl->result_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL,

fdctrl_result_timer, fdctrl);

2.21.0

It is possible for an empty file to take up blocks on a filesystem, for

example:

$ qemu-img create -f raw test.img 1G

Formatting 'test.img', fmt=raw size=1073741824

$ mkfs.ext4 -I 128 -q test.img

$ mkdir test-mount

$ sudo mount -o loop test.img test-mount

$ sudo touch test-mount/test-file

$ stat -c 'blocks=%b' test-mount/test-file

blocks=8

These extra blocks (one cluster) are apparently used for metadata,

because they are always there, on top of blocks used for data:

$ sudo dd if=/dev/zero of=test-mount/test-file bs=1M count=1

1+0 records in

1+0 records out

1048576 bytes (1.0 MB, 1.0 MiB) copied, 0.00135339 s, 775 MB/s

$ stat -c 'blocks=%b' test-mount/test-file

blocks=2056

Make iotest 175 take this into account.

Reported-by: Thomas Huth <thuth@redhat.com>

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

Reviewed-by: Eric Blake <eblake@redhat.com>

Reviewed-by: Nir Soffer <nsoffer@redhat.com>

Message-id: 20190516144319.12570-1-mreitz@redhat.com

tests/qemu-iotests/175 | 26 ++++++++++++++++++++++----

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

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

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

--- a/tests/qemu-iotests/175

+++ b/tests/qemu-iotests/175

@@ -XXX,XX +XXX,XX @@ status=1    # failure is the default!

_cleanup()

-    _cleanup_test_img

+ _cleanup_test_img

+ rm -f "$TEST_DIR/empty"

trap "_cleanup; exit \$status" 0 1 2 3 15

+# Some file systems sometimes allocate extra blocks independently of

+# the file size. This function hides the resulting difference in the

+# stat -c '%b' output.

+# Parameter 1: Number of blocks an empty file occupies

+# Parameter 2: Image size in bytes

+_filter_blocks()

+ extra_blocks=$1

+ img_size=$2

+

+ sed -e "s/blocks=$extra_blocks\\(\$\\|[^0-9]\\)/nothing allocated/" \

+ -e "s/blocks=$((extra_blocks + img_size / 512))\\(\$\\|[^0-9]\\)/everything allocated/"

# get standard environment, filters and checks

. ./common.rc

. ./common.filter

@@ -XXX,XX +XXX,XX @@ _supported_fmt raw

_supported_proto file

_supported_os Linux

-size=1m

+size=$((1 * 1024 * 1024))

+

+touch "$TEST_DIR/empty"

+extra_blocks=$(stat -c '%b' "$TEST_DIR/empty")

echo

echo "== creating image with default preallocation =="

_make_test_img $size | _filter_imgfmt

-stat -c "size=%s, blocks=%b" $TEST_IMG

+stat -c "size=%s, blocks=%b" $TEST_IMG | _filter_blocks $extra_blocks $size

for mode in off full falloc; do

echo

echo "== creating image with preallocation $mode =="

IMGOPTS=preallocation=$mode _make_test_img $size | _filter_imgfmt

- stat -c "size=%s, blocks=%b" $TEST_IMG

+ stat -c "size=%s, blocks=%b" $TEST_IMG | _filter_blocks $extra_blocks $size

done

# success, all done

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

index XXXXXXX..XXXXXXX 100644

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

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

@@ -XXX,XX +XXX,XX @@ QA output created by 175

== creating image with default preallocation ==

Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576

-size=1048576, blocks=0

+size=1048576, nothing allocated

== creating image with preallocation off ==

Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576 preallocation=off

-size=1048576, blocks=0

+size=1048576, nothing allocated

== creating image with preallocation full ==

Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576 preallocation=full

-size=1048576, blocks=2048

+size=1048576, everything allocated

== creating image with preallocation falloc ==

Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576 preallocation=falloc

-size=1048576, blocks=2048

+size=1048576, everything allocated

*** done

2.21.0

A snapshot is something that reflects the state of something at a

certain point in time. It does not change.

The file our snapshot commands create (or the node they install) is not

a snapshot, as it does change over time. It is an overlay. We cannot

do anything about the parameter names, but we can at least adjust the

descriptions to reflect that fact.

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

Reviewed-by: Eric Blake <eblake@redhat.com>

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

Reviewed-by: John Snow <jsnow@redhat.com>

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

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

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

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 @@

#

# Either @device or @node-name must be set but not both.

#

-# @device: the name of the device to generate the snapshot from.

+# @device: the name of the device to take a snapshot of.

#

# @node-name: graph node name to generate the snapshot from (Since 2.0)

#

-# @snapshot-file: the target of the new image. If the file exists, or

-# if it is a device, the snapshot will be created in the existing

-# file/device. Otherwise, a new file will be created.

+# @snapshot-file: the target of the new overlay image. If the file

+# exists, or if it is a device, the overlay will be created in the

+# existing file/device. Otherwise, a new file will be created.

#

# @snapshot-node-name: the graph node name of the new image (Since 2.0)

#

-# @format: the format of the snapshot image, default is 'qcow2'.

+# @format: the format of the overlay image, default is 'qcow2'.

#

# @mode: whether and how QEMU should create a new image, default is

# 'absolute-paths'.

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

##

# @BlockdevSnapshot:

#

-# @node: device or node name that will have a snapshot created.

+# @node: device or node name that will have a snapshot taken.

#

# @overlay: reference to the existing block device that will become

-# the overlay of @node, as part of creating the snapshot.

+# the overlay of @node, as part of taking the snapshot.

# It must not have a current backing file (this can be

# achieved by passing "backing": null to blockdev-add).

#

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

##

# @blockdev-snapshot-sync:

#

-# Generates a synchronous snapshot of a block device.

+# Takes a synchronous snapshot of a block device.

#

# For the arguments, see the documentation of BlockdevSnapshotSync.

#

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

##

# @blockdev-snapshot:

#

-# Generates a snapshot of a block device.

+# Takes a snapshot of a block device.

#

-# Create a snapshot, by installing 'node' as the backing image of

+# Take a snapshot, by installing 'node' as the backing image of

# 'overlay'. Additionally, if 'node' is associated with a block

# device, the block device changes to using 'overlay' as its new active

# image.

2.21.0

This test converts a simple image to another, but blkdebug injects

block_status and read faults at some offsets. The resulting image

should be the same as the input image, except that sectors that could

not be read have to be 0.

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

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

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

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

[mreitz: Dropped superfluous printf from _filter_offsets, as suggested

by Vladimir; disable test for VDI and IMGOPTSSYNTAX]

tests/qemu-iotests/251 | 170 +++++++++++++++++++++++++++++++++++++

tests/qemu-iotests/251.out | 43 ++++++++++

tests/qemu-iotests/group | 1 +

3 files changed, 214 insertions(+)

create mode 100755 tests/qemu-iotests/251

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