The following changes since commit ae49fbbcd8e4e9d8bf7131add34773f579e1aff7:

Merge remote-tracking branch 'remotes/rth/tags/pull-tcg-20171025' into staging (2017-10-25 16:38:57 +0100)

are available in the git repository at:

for you to fetch changes up to 4254d01ce4eec9a3ccf320d14e2da132b8ad4a51:

Merge remote-tracking branch 'mreitz/tags/pull-block-2017-10-26' into queue-block (2017-10-26 15:02:40 +0200)

Block layer patches

Alberto Garcia (1):

qcow2: Use BDRV_SECTOR_BITS instead of its literal value

Eric Blake (24):

block: Allow NULL file for bdrv_get_block_status()

block: Add flag to avoid wasted work in bdrv_is_allocated()

block: Make bdrv_round_to_clusters() signature more useful

qcow2: Switch is_zero_sectors() to byte-based

block: Switch bdrv_make_zero() to byte-based

qemu-img: Switch get_block_status() to byte-based

block: Convert bdrv_get_block_status() to bytes

block: Switch bdrv_co_get_block_status() to byte-based

block: Switch BdrvCoGetBlockStatusData to byte-based

block: Switch bdrv_common_block_status_above() to byte-based

block: Switch bdrv_co_get_block_status_above() to byte-based

block: Convert bdrv_get_block_status_above() to bytes

qemu-img: Simplify logic in img_compare()

qemu-img: Speed up compare on pre-allocated larger file

qemu-img: Add find_nonzero()

qemu-img: Drop redundant error message in compare

qemu-img: Change check_empty_sectors() to byte-based

qemu-img: Change compare_sectors() to be byte-based

qemu-img: Change img_rebase() to be byte-based

qemu-img: Change img_compare() to be byte-based

block: Align block status requests

block: Reduce bdrv_aligned_preadv() rounding

qcow2: Reduce is_zero() rounding

qemu-io: Relax 'alloc' now that block-status doesn't assert

Kevin Wolf (2):

qemu-iotests: Test backing_fmt with backing node reference

Merge remote-tracking branch 'mreitz/tags/pull-block-2017-10-26' into queue-block

Max Reitz (8):

qemu-img.1: Image invalidation on qemu-img commit

iotests: Add test for dataplane mirroring

iotests: Pull _filter_actual_image_size from 67/87

iotests: Filter actual image size in 184 and 191

qcow2: Emit errp when truncating the image tail

qcow2: Fix unaligned preallocated truncation

qcow2: Always execute preallocate() in a coroutine

iotests: Add cluster_size=64k to 125

Peter Krempa (1):

block: don't add 'driver' to options when referring to backing via node name

include/block/block.h | 29 ++-

include/block/block_int.h | 11 +-

block.c | 3 +-

block/blkdebug.c | 13 +-

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

block/mirror.c | 26 +--

block/qcow2-cluster.c | 2 +-

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

qemu-img.c | 381 ++++++++++++++-----------------

qemu-io-cmds.c | 13 --

block/trace-events | 2 +-

qemu-img.texi | 9 +-

tests/qemu-iotests/067 | 2 +-

tests/qemu-iotests/074.out | 2 -

tests/qemu-iotests/087 | 2 +-

tests/qemu-iotests/125 | 7 +-

tests/qemu-iotests/125.out | 480 +++++++++++++++++++++++++++++++++++----

tests/qemu-iotests/127 | 97 ++++++++

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

tests/qemu-iotests/177 | 12 +-

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

tests/qemu-iotests/184 | 3 +-

tests/qemu-iotests/184.out | 6 +-

tests/qemu-iotests/191 | 7 +-

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

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

tests/qemu-iotests/group | 1 +

27 files changed, 1102 insertions(+), 543 deletions(-)

create mode 100755 tests/qemu-iotests/127

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

From: Peter Krempa <pkrempa@redhat.com>

When referring to a backing file of an image via node name

bdrv_open_backing_file would add the 'driver' option to the option list

filling it with the backing format driver. This breaks construction of

the backing chain via -blockdev, as bdrv_open_inherit reports an error

if both 'reference' and 'options' are provided.

$ qemu-img create -f raw /tmp/backing.raw 64M

$ qemu-img create -f qcow2 -F raw -b /tmp/backing.raw /tmp/test.qcow2

$ qemu-system-x86_64 \

-blockdev driver=file,filename=/tmp/backing.raw,node-name=backing \

-blockdev driver=qcow2,file.driver=file,file.filename=/tmp/test.qcow2,node-name=root,backing=backing

qemu-system-x86_64: -blockdev driver=qcow2,file.driver=file,file.filename=/tmp/test.qcow2,node-name=root,backing=backing: Could not open backing file: Cannot reference an existing block device with additional options or a new filename

Signed-off-by: Peter Krempa <pkrempa@redhat.com>

block.c | 3 ++-

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

@@ -XXX,XX +XXX,XX @@ int bdrv_open_backing_file(BlockDriverState *bs, QDict *parent_options,

goto free_exit;

- if (bs->backing_format[0] != '\0' && !qdict_haskey(options, "driver")) {

+ if (!reference &&

+ bs->backing_format[0] != '\0' && !qdict_haskey(options, "driver")) {

qdict_put_str(options, "driver", bs->backing_format);

}

2.13.6

From: Eric Blake <eblake@redhat.com>

Now that bdrv_is_allocated accepts non-aligned inputs, we can

remove the TODO added in earlier refactoring.

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

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

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

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

--- a/block/qcow2.c

+++ b/block/qcow2.c

@@ -XXX,XX +XXX,XX @@ static bool is_zero(BlockDriverState *bs, int64_t offset, int64_t bytes)

{

int64_t nr;

int res;

- int64_t start;

-

- /* TODO: Widening to sector boundaries should only be needed as

- * long as we can't query finer granularity. */

- start = QEMU_ALIGN_DOWN(offset, BDRV_SECTOR_SIZE);

- bytes = QEMU_ALIGN_UP(offset + bytes, BDRV_SECTOR_SIZE) - start;

/* Clamp to image length, before checking status of underlying sectors */

- if (start + bytes > bs->total_sectors * BDRV_SECTOR_SIZE) {

- bytes = bs->total_sectors * BDRV_SECTOR_SIZE - start;

+ if (offset + bytes > bs->total_sectors * BDRV_SECTOR_SIZE) {

+ bytes = bs->total_sectors * BDRV_SECTOR_SIZE - offset;

}

if (!bytes) {

return true;

}

- res = bdrv_block_status_above(bs, NULL, start, bytes, &nr, NULL, NULL);

+ res = bdrv_block_status_above(bs, NULL, offset, bytes, &nr, NULL, NULL);

return res >= 0 && (res & BDRV_BLOCK_ZERO) && nr == bytes;

}

2.13.6

From: Max Reitz <mreitz@redhat.com>

qemu-img commit invalidates all images between base and top. This

should be mentioned in the man page.

Suggested-by: Ping Li <pingl@redhat.com>

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

Reviewed-by: Jeff Cody <jcody@redhat.com>

qemu-img.texi | 9 ++++-----

1 file changed, 4 insertions(+), 5 deletions(-)

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

--- a/qemu-img.texi

+++ b/qemu-img.texi

@@ -XXX,XX +XXX,XX @@ If the backing chain of the given image file @var{filename} has more than one

layer, the backing file into which the changes will be committed may be

specified as @var{base} (which has to be part of @var{filename}'s backing

chain). If @var{base} is not specified, the immediate backing file of the top

-image (which is @var{filename}) will be used. For reasons of consistency,

-explicitly specifying @var{base} will always imply @code{-d} (since emptying an

-image after committing to an indirect backing file would lead to different data

-being read from the image due to content in the intermediate backing chain

-overruling the commit target).

+image (which is @var{filename}) will be used. Note that after a commit operation

+all images between @var{base} and the top image will be invalid and may return

+garbage data when read. For this reason, @code{-b} implies @code{-d} (so that

+the top image stays valid).

@item compare [-f @var{fmt}] [-F @var{fmt}] [-T @var{src_cache}] [-p] [-s] [-q] @var{filename1} @var{filename2}

2.13.6

From: Eric Blake <eblake@redhat.com>

In the continuing quest to make more things byte-based, change

the internal iteration of img_compare(). We can finally drop the

TODO assertions added earlier, now that the entire algorithm is

byte-based and no longer has to shift from bytes to sectors.

Most of the change is mechanical ('total_sectors' becomes

'total_size', 'sector_num' becomes 'offset', 'nb_sectors' becomes

'chunk', 'progress_base' goes from sectors to bytes); some of it

is also a cleanup (sectors_to_bytes() is now unused, loss of

variable 'count' added earlier in commit 51b0a488).

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

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

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

---

qemu-img.c | 124 ++++++++++++++++++++++++-------------------------------------

1 file changed, 48 insertions(+), 76 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 @@ static int compare_buffers(const uint8_t *buf1, const uint8_t *buf2,

#define IO_BUF_SIZE (2 * 1024 * 1024)

-static int64_t sectors_to_bytes(int64_t sectors)

-{

- return sectors << BDRV_SECTOR_BITS;

-}

-

/*

* Check if passed sectors are empty (not allocated or contain only 0 bytes)

*

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

const char *fmt1 = NULL, *fmt2 = NULL, *cache, *filename1, *filename2;

BlockBackend *blk1, *blk2;

BlockDriverState *bs1, *bs2;

- int64_t total_sectors1, total_sectors2;

+ int64_t total_size1, total_size2;

uint8_t *buf1 = NULL, *buf2 = NULL;

int64_t pnum1, pnum2;

int allocated1, allocated2;

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

bool progress = false, quiet = false, strict = false;

int flags;

bool writethrough;

- int64_t total_sectors;

- int64_t sector_num = 0;

- int64_t nb_sectors;

+ int64_t total_size;

+ int64_t offset = 0;

+ int64_t chunk;

int c;

uint64_t progress_base;

bool image_opts = false;

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

buf1 = blk_blockalign(blk1, IO_BUF_SIZE);

buf2 = blk_blockalign(blk2, IO_BUF_SIZE);

- total_sectors1 = blk_nb_sectors(blk1);

- if (total_sectors1 < 0) {

+ total_size1 = blk_getlength(blk1);

+ if (total_size1 < 0) {

error_report("Can't get size of %s: %s",

- filename1, strerror(-total_sectors1));

+ filename1, strerror(-total_size1));

ret = 4;

goto out;

}

- total_sectors2 = blk_nb_sectors(blk2);

- if (total_sectors2 < 0) {

+ total_size2 = blk_getlength(blk2);

+ if (total_size2 < 0) {

error_report("Can't get size of %s: %s",

- filename2, strerror(-total_sectors2));

+ filename2, strerror(-total_size2));

ret = 4;

goto out;

}

- total_sectors = MIN(total_sectors1, total_sectors2);

- progress_base = MAX(total_sectors1, total_sectors2);

+ total_size = MIN(total_size1, total_size2);

+ progress_base = MAX(total_size1, total_size2);

qemu_progress_print(0, 100);

- if (strict && total_sectors1 != total_sectors2) {

+ if (strict && total_size1 != total_size2) {

ret = 1;

qprintf(quiet, "Strict mode: Image size mismatch!\n");

goto out;

}

- while (sector_num < total_sectors) {

+ while (offset < total_size) {

int status1, status2;

- status1 = bdrv_block_status_above(bs1, NULL,

- sector_num * BDRV_SECTOR_SIZE,

- (total_sectors1 - sector_num) *

- BDRV_SECTOR_SIZE,

- &pnum1, NULL, NULL);

+ status1 = bdrv_block_status_above(bs1, NULL, offset,

+ total_size1 - offset, &pnum1, NULL,

+ NULL);

if (status1 < 0) {

ret = 3;

error_report("Sector allocation test failed for %s", filename1);

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

}

allocated1 = status1 & BDRV_BLOCK_ALLOCATED;

- status2 = bdrv_block_status_above(bs2, NULL,

- sector_num * BDRV_SECTOR_SIZE,

- (total_sectors2 - sector_num) *

- BDRV_SECTOR_SIZE,

- &pnum2, NULL, NULL);

+ status2 = bdrv_block_status_above(bs2, NULL, offset,

+ total_size2 - offset, &pnum2, NULL,

+ NULL);

if (status2 < 0) {

ret = 3;

error_report("Sector allocation test failed for %s", filename2);

goto out;

}

allocated2 = status2 & BDRV_BLOCK_ALLOCATED;

- /* TODO: Relax this once comparison is byte-based, and we no longer

- * have to worry about sector alignment */

- assert(QEMU_IS_ALIGNED(pnum1 | pnum2, BDRV_SECTOR_SIZE));

assert(pnum1 && pnum2);

- nb_sectors = MIN(pnum1, pnum2) >> BDRV_SECTOR_BITS;

+ chunk = MIN(pnum1, pnum2);

if (strict) {

if (status1 != status2) {

ret = 1;

qprintf(quiet, "Strict mode: Offset %" PRId64

- " block status mismatch!\n",

- sectors_to_bytes(sector_num));

+ " block status mismatch!\n", offset);

goto out;

}

}

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

if (allocated1) {

int64_t pnum;

- nb_sectors = MIN(nb_sectors, IO_BUF_SIZE >> BDRV_SECTOR_BITS);

- ret = blk_pread(blk1, sector_num << BDRV_SECTOR_BITS, buf1,

- nb_sectors << BDRV_SECTOR_BITS);

+ chunk = MIN(chunk, IO_BUF_SIZE);

+ ret = blk_pread(blk1, offset, buf1, chunk);

if (ret < 0) {

- error_report("Error while reading offset %" PRId64 " of %s:"

- " %s", sectors_to_bytes(sector_num), filename1,

- strerror(-ret));

+ error_report("Error while reading offset %" PRId64

+ " of %s: %s",

+ offset, filename1, strerror(-ret));

ret = 4;

goto out;

}

- ret = blk_pread(blk2, sector_num << BDRV_SECTOR_BITS, buf2,

- nb_sectors << BDRV_SECTOR_BITS);

+ ret = blk_pread(blk2, offset, buf2, chunk);

if (ret < 0) {

error_report("Error while reading offset %" PRId64

- " of %s: %s", sectors_to_bytes(sector_num),

- filename2, strerror(-ret));

+ " of %s: %s",

+ offset, filename2, strerror(-ret));

ret = 4;

goto out;

}

- ret = compare_buffers(buf1, buf2,

- nb_sectors * BDRV_SECTOR_SIZE, &pnum);

- if (ret || pnum != nb_sectors * BDRV_SECTOR_SIZE) {

+ ret = compare_buffers(buf1, buf2, chunk, &pnum);

+ if (ret || pnum != chunk) {

qprintf(quiet, "Content mismatch at offset %" PRId64 "!\n",

- sectors_to_bytes(sector_num) + (ret ? 0 : pnum));

+ offset + (ret ? 0 : pnum));

ret = 1;

goto out;

}

}

} else {

- nb_sectors = MIN(nb_sectors, IO_BUF_SIZE >> BDRV_SECTOR_BITS);

+ chunk = MIN(chunk, IO_BUF_SIZE);

if (allocated1) {

- ret = check_empty_sectors(blk1, sector_num * BDRV_SECTOR_SIZE,

- nb_sectors * BDRV_SECTOR_SIZE,

+ ret = check_empty_sectors(blk1, offset, chunk,

filename1, buf1, quiet);

} else {

- ret = check_empty_sectors(blk2, sector_num * BDRV_SECTOR_SIZE,

- nb_sectors * BDRV_SECTOR_SIZE,

+ ret = check_empty_sectors(blk2, offset, chunk,

filename2, buf1, quiet);

}

if (ret) {

goto out;

}

}

- sector_num += nb_sectors;

- qemu_progress_print(((float) nb_sectors / progress_base)*100, 100);

+ offset += chunk;

+ qemu_progress_print(((float) chunk / progress_base) * 100, 100);

}

- if (total_sectors1 != total_sectors2) {

+ if (total_size1 != total_size2) {

BlockBackend *blk_over;

const char *filename_over;

qprintf(quiet, "Warning: Image size mismatch!\n");

- if (total_sectors1 > total_sectors2) {

+ if (total_size1 > total_size2) {

blk_over = blk1;

filename_over = filename1;

} else {

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

filename_over = filename2;

}

- while (sector_num < progress_base) {

- int64_t count;

-

- ret = bdrv_block_status_above(blk_bs(blk_over), NULL,

- sector_num * BDRV_SECTOR_SIZE,

- (progress_base - sector_num) *

- BDRV_SECTOR_SIZE,

- &count, NULL, NULL);

+ while (offset < progress_base) {

+ ret = bdrv_block_status_above(blk_bs(blk_over), NULL, offset,

+ progress_base - offset, &chunk,

+ NULL, NULL);

if (ret < 0) {

ret = 3;

error_report("Sector allocation test failed for %s",

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

goto out;

}

- /* TODO relax this once bdrv_block_status_above does not enforce

- * sector alignment */

- assert(QEMU_IS_ALIGNED(count, BDRV_SECTOR_SIZE));

- nb_sectors = count >> BDRV_SECTOR_BITS;

if (ret & BDRV_BLOCK_ALLOCATED && !(ret & BDRV_BLOCK_ZERO)) {

- nb_sectors = MIN(nb_sectors, IO_BUF_SIZE >> BDRV_SECTOR_BITS);

- ret = check_empty_sectors(blk_over,

- sector_num * BDRV_SECTOR_SIZE,

- nb_sectors * BDRV_SECTOR_SIZE,

+ chunk = MIN(chunk, IO_BUF_SIZE);

+ ret = check_empty_sectors(blk_over, offset, chunk,

filename_over, buf1, quiet);

if (ret) {

goto out;

}

}

- sector_num += nb_sectors;

- qemu_progress_print(((float) nb_sectors / progress_base)*100, 100);

+ offset += chunk;

+ qemu_progress_print(((float) chunk / progress_base) * 100, 100);

}

}

2.13.6

From: Eric Blake <eblake@redhat.com>

Previously, the alloc command required that input parameters be

sector-aligned and clamped to 32 bits, because the underlying

bdrv_is_allocated used a 32-bit parameter and asserted aligned

inputs. But now that we have fixed block status to report a

64-bit bytes value, and to properly round requests on behalf of

guests, we can pass any values, and can use qemu-io to add

coverage that our rounding is correct regardless of the guest

alignment constraints.

qemu-io-cmds.c | 13 -------------

tests/qemu-iotests/177 | 12 ++++++++++--

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

3 files changed, 24 insertions(+), 20 deletions(-)

diff --git a/qemu-io-cmds.c b/qemu-io-cmds.c

--- a/qemu-io-cmds.c

+++ b/qemu-io-cmds.c

@@ -XXX,XX +XXX,XX @@ static int alloc_f(BlockBackend *blk, int argc, char **argv)

if (offset < 0) {

print_cvtnum_err(offset, argv[1]);

return 0;

- } else if (!QEMU_IS_ALIGNED(offset, BDRV_SECTOR_SIZE)) {

- printf("%" PRId64 " is not a sector-aligned value for 'offset'\n",

- offset);

- return 0;

}

if (argc == 3) {

@@ -XXX,XX +XXX,XX @@ static int alloc_f(BlockBackend *blk, int argc, char **argv)

if (count < 0) {

print_cvtnum_err(count, argv[2]);

return 0;

- } else if (count > INT_MAX * BDRV_SECTOR_SIZE) {

- printf("length argument cannot exceed %llu, given %s\n",

- INT_MAX * BDRV_SECTOR_SIZE, argv[2]);

- return 0;

}

} else {

count = BDRV_SECTOR_SIZE;

}

- if (!QEMU_IS_ALIGNED(count, BDRV_SECTOR_SIZE)) {

- printf("%" PRId64 " is not a sector-aligned value for 'count'\n",

- count);

- return 0;

- }

remaining = count;

sum_alloc = 0;

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

index XXXXXXX..XXXXXXX 100755

--- a/tests/qemu-iotests/177

+++ b/tests/qemu-iotests/177

@@ -XXX,XX +XXX,XX @@ echo "== setting up files =="

TEST_IMG="$TEST_IMG.base" _make_test_img $size

$QEMU_IO -c "write -P 11 0 $size" "$TEST_IMG.base" | _filter_qemu_io

_make_test_img -b "$TEST_IMG.base"

-$QEMU_IO -c "write -P 22 0 $size" "$TEST_IMG" | _filter_qemu_io

+$QEMU_IO -c "write -P 22 0 110M" "$TEST_IMG" | _filter_qemu_io

# Limited to 64k max-transfer

echo

@@ -XXX,XX +XXX,XX @@ $QEMU_IO -c "open -o $options,$limits blkdebug::$TEST_IMG" \

-c "discard 80000001 30M" | _filter_qemu_io

echo

+echo "== block status smaller than alignment =="

+limits=align=4k

+$QEMU_IO -c "open -o $options,$limits blkdebug::$TEST_IMG" \

+     -c "alloc 1 1" -c "alloc 0x6dffff0 1000" -c "alloc 127m 5P" \

+     -c map | _filter_qemu_io

+

+echo

echo "== verify image content =="

function verify_io()

@@ -XXX,XX +XXX,XX @@ function verify_io()

echo read -P 0 32M 32M

echo read -P 22 64M 13M

echo read -P $discarded 77M 29M

- echo read -P 22 106M 22M

+ echo read -P 22 106M 4M

+ echo read -P 11 110M 18M

verify_io | $QEMU_IO -r "$TEST_IMG" | _filter_qemu_io

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

index XXXXXXX..XXXXXXX 100644

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

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

@@ -XXX,XX +XXX,XX @@ Formatting 'TEST_DIR/t.IMGFMT.base', fmt=IMGFMT size=134217728

wrote 134217728/134217728 bytes at offset 0

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

Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 backing_file=TEST_DIR/t.IMGFMT.base

-wrote 134217728/134217728 bytes at offset 0

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

+wrote 115343360/115343360 bytes at offset 0

+110 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

== constrained alignment and max-transfer ==

wrote 131072/131072 bytes at offset 1000

@@ -XXX,XX +XXX,XX @@ wrote 33554432/33554432 bytes at offset 33554432

discard 31457280/31457280 bytes at offset 80000001

30 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

+== block status smaller than alignment ==

+1/1 bytes allocated at offset 1 bytes

+16/1000 bytes allocated at offset 110 MiB

+0/1048576 bytes allocated at offset 127 MiB

+110 MiB (0x6e00000) bytes allocated at offset 0 bytes (0x0)

+18 MiB (0x1200000) bytes not allocated at offset 110 MiB (0x6e00000)

+

== verify image content ==

read 1000/1000 bytes at offset 0

1000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

@@ -XXX,XX +XXX,XX @@ read 13631488/13631488 bytes at offset 67108864

13 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

read 30408704/30408704 bytes at offset 80740352

29 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

-read 23068672/23068672 bytes at offset 111149056

-22 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

+read 4194304/4194304 bytes at offset 111149056

+4 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

+read 18874368/18874368 bytes at offset 115343360

+18 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

Offset Length File

0 0x800000 TEST_DIR/t.IMGFMT

0x900000 0x2400000 TEST_DIR/t.IMGFMT

0x3c00000 0x1100000 TEST_DIR/t.IMGFMT

-0x6a00000 0x1600000 TEST_DIR/t.IMGFMT

+0x6a00000 0x400000 TEST_DIR/t.IMGFMT

No errors were found on the image.

*** done

2.13.6

From: Eric Blake <eblake@redhat.com>

include/block/block_int.h | 3 +-

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

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

3 files changed, 59 insertions(+), 28 deletions(-)

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

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

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

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

* according to the current layer, and should not set

* BDRV_BLOCK_ALLOCATED, but may set BDRV_BLOCK_RAW. See block.h

* for the meaning of _DATA, _ZERO, and _OFFSET_VALID. The block

- * layer guarantees non-NULL pnum and file.

+ * layer guarantees input aligned to request_alignment, as well as

+ * non-NULL pnum and file.

*/

int64_t coroutine_fn (*bdrv_co_get_block_status)(BlockDriverState *bs,

int64_t sector_num, int nb_sectors, int *pnum,

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_pdiscard(BlockDriverState *bs,

return bdrv_co_pdiscard(bs->file->bs, offset, bytes);

+static int64_t coroutine_fn blkdebug_co_get_block_status(

+ BlockDriverState *bs, int64_t sector_num, int nb_sectors, int *pnum,

+ BlockDriverState **file)

+ assert(QEMU_IS_ALIGNED(sector_num | nb_sectors,

+ DIV_ROUND_UP(bs->bl.request_alignment,

+ BDRV_SECTOR_SIZE)));

+ return bdrv_co_get_block_status_from_file(bs, sector_num, nb_sectors,

+ pnum, file);

static void blkdebug_close(BlockDriverState *bs)

{

BDRVBlkdebugState *s = bs->opaque;

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

.bdrv_co_flush_to_disk = blkdebug_co_flush,

.bdrv_co_pwrite_zeroes = blkdebug_co_pwrite_zeroes,

.bdrv_co_pdiscard = blkdebug_co_pdiscard,

- .bdrv_co_get_block_status = bdrv_co_get_block_status_from_file,

+ .bdrv_co_get_block_status = blkdebug_co_get_block_status,

.bdrv_debug_event = blkdebug_debug_event,

.bdrv_debug_breakpoint = blkdebug_debug_breakpoint,

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

index XXXXXXX..XXXXXXX 100644

--- a/block/io.c

+++ b/block/io.c

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

{

int64_t total_size;

int64_t n; /* bytes */

- int64_t ret;

+ int ret;

int64_t local_map = 0;

BlockDriverState *local_file = NULL;

- int count; /* sectors */

+ int64_t aligned_offset, aligned_bytes;

+ uint32_t align;

assert(pnum);

*pnum = 0;

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

}

bdrv_inc_in_flight(bs);

+ /* Round out to request_alignment boundaries */

+ /* TODO: until we have a byte-based driver callback, we also have to

+ * round out to sectors, even if that is bigger than request_alignment */

+ align = MAX(bs->bl.request_alignment, BDRV_SECTOR_SIZE);

+ aligned_offset = QEMU_ALIGN_DOWN(offset, align);

+ aligned_bytes = ROUND_UP(offset + bytes, align) - aligned_offset;

+ {

+ int count; /* sectors */

+ int64_t longret;

+ assert(QEMU_IS_ALIGNED(aligned_offset | aligned_bytes,

+ BDRV_SECTOR_SIZE));

+ /*

+ * The contract allows us to return pnum smaller than bytes, even

+ * if the next query would see the same status; we truncate the

+ * request to avoid overflowing the driver's 32-bit interface.

+ */

+ longret = bs->drv->bdrv_co_get_block_status(

+ bs, aligned_offset >> BDRV_SECTOR_BITS,

+ MIN(INT_MAX, aligned_bytes) >> BDRV_SECTOR_BITS, &count,

+ &local_file);

+ if (longret < 0) {

+ assert(INT_MIN <= longret);

+ ret = longret;

+ goto out;

+ }

+ if (longret & BDRV_BLOCK_OFFSET_VALID) {

+ local_map = longret & BDRV_BLOCK_OFFSET_MASK;

+ }

+ ret = longret & ~BDRV_BLOCK_OFFSET_MASK;

+ *pnum = count * BDRV_SECTOR_SIZE;

/*

- * TODO: Rather than require aligned offsets, we could instead

- * round to the driver's request_alignment here, then touch up

- * count afterwards back to the caller's expectations.

- */

- assert(QEMU_IS_ALIGNED(offset | bytes, BDRV_SECTOR_SIZE));

- /*

- * The contract allows us to return pnum smaller than bytes, even

- * if the next query would see the same status; we truncate the

- * request to avoid overflowing the driver's 32-bit interface.

+ * The driver's result must be a multiple of request_alignment.

+ * Clamp pnum and adjust map to original request.

*/

- bytes = MIN(bytes, BDRV_REQUEST_MAX_BYTES);

- ret = bs->drv->bdrv_co_get_block_status(bs, offset >> BDRV_SECTOR_BITS,

- bytes >> BDRV_SECTOR_BITS, &count,

- &local_file);

- if (ret < 0) {

- goto out;

+ assert(QEMU_IS_ALIGNED(*pnum, align) && align > offset - aligned_offset);

+ *pnum -= offset - aligned_offset;

+ if (*pnum > bytes) {

+ *pnum = bytes;

if (ret & BDRV_BLOCK_OFFSET_VALID) {

- local_map = ret & BDRV_BLOCK_OFFSET_MASK;

+ local_map += offset - aligned_offset;