The following changes since commit 36f87b4513373b3cd79c87c9197d17face95d4ac:

Merge remote-tracking branch 'remotes/dgibson/tags/ppc-for-2.10-20170630' into staging (2017-06-30 11:58:49 +0100)

are available in the git repository at:

git://github.com/famz/qemu.git tags/block-pull-request

for you to fetch changes up to c61e684e44272f2acb2bef34cf2aa234582a73a9:

block: Exploit BDRV_BLOCK_EOF for larger zero blocks (2017-06-30 21:48:06 +0800)

Hi Peter,

Here are Eric Blake's enhancement to block layer API. Thanks!

----------------------------------------------------------------

Eric Blake (2):

block: Add BDRV_BLOCK_EOF to bdrv_get_block_status()

block: Exploit BDRV_BLOCK_EOF for larger zero blocks

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

include/block/block.h | 2 ++

tests/qemu-iotests/154 | 4 ----

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

4 files changed, 41 insertions(+), 19 deletions(-)

2.9.4

From: Eric Blake <eblake@redhat.com>

When we have a BDS with unallocated clusters, but asking the status

of its underlying bs->file or backing layer encounters an end-of-file

condition, we know that the rest of the unallocated area will read as

zeroes. However, pre-patch, this required two separate calls to

bdrv_get_block_status(), as the first call stops at the point where

the underlying file ends. Thanks to BDRV_BLOCK_EOF, we can now widen

the results of the primary status if the secondary status already

includes BDRV_BLOCK_ZERO.

In turn, this fixes a TODO mentioned in iotest 154, where we can now

see that all sectors in a partial cluster at the end of a file read

as zero when coupling the shorter backing file's status along with our

knowledge that the remaining sectors came from an unallocated cluster.

Also, note that the loop in bdrv_co_get_block_status_above() had an

inefficent exit: in cases where the active layer sets BDRV_BLOCK_ZERO

but does NOT set BDRV_BLOCK_ALLOCATED (namely, where we know we read

zeroes merely because our unallocated clusters lie beyond the backing

file's shorter length), we still ended up probing the backing layer

even though we already had a good answer.

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

Message-Id: <20170505021500.19315-3-eblake@redhat.com>

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

Signed-off-by: Fam Zheng <famz@redhat.com>

---

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

tests/qemu-iotests/154 | 4 ----

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

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

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

--- a/block/io.c

+++ b/block/io.c

@@ -XXX,XX +XXX,XX @@ static int64_t coroutine_fn bdrv_co_get_block_status(BlockDriverState *bs,

/* Ignore errors. This is just providing extra information, it

* is useful but not necessary.

*/

- if (!file_pnum) {

- /* !file_pnum indicates an offset at or beyond the EOF; it is

- * perfectly valid for the format block driver to point to such

- * offsets, so catch it and mark everything as zero */

+ if (ret2 & BDRV_BLOCK_EOF &&

+ (!file_pnum || ret2 & BDRV_BLOCK_ZERO)) {

+ /*

+ * It is valid for the format block driver to read

+ * beyond the end of the underlying file's current

+ * size; such areas read as zero.

+ */

ret |= BDRV_BLOCK_ZERO;

} else {

/* Limit request to the range reported by the protocol driver */

@@ -XXX,XX +XXX,XX @@ static int64_t coroutine_fn bdrv_co_get_block_status_above(BlockDriverState *bs,

{

BlockDriverState *p;

int64_t ret = 0;

+ bool first = true;

assert(bs != base);

for (p = bs; p != base; p = backing_bs(p)) {

ret = bdrv_co_get_block_status(p, sector_num, nb_sectors, pnum, file);

- if (ret < 0 || ret & BDRV_BLOCK_ALLOCATED) {

+ if (ret < 0) {

+ break;

+ }

+ if (ret & BDRV_BLOCK_ZERO && ret & BDRV_BLOCK_EOF && !first) {

+ /*

+ * Reading beyond the end of the file continues to read

+ * zeroes, but we can only widen the result to the

+ * unallocated length we learned from an earlier

+ * iteration.

+ */

+ *pnum = nb_sectors;

+ }

+ if (ret & (BDRV_BLOCK_ZERO | BDRV_BLOCK_DATA)) {

break;

}

/* [sector_num, pnum] unallocated on this layer, which could be only

* the first part of [sector_num, nb_sectors]. */

nb_sectors = MIN(nb_sectors, *pnum);

+ first = false;

}

return ret;

}

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

index XXXXXXX..XXXXXXX 100755

--- a/tests/qemu-iotests/154

+++ b/tests/qemu-iotests/154

@@ -XXX,XX +XXX,XX @@ $QEMU_IO -c "alloc $size 2048" "$TEST_IMG" | _filter_qemu_io

$QEMU_IMG map --output=json "$TEST_IMG" | _filter_qemu_img_map

# Repeat with backing file holding unallocated cluster.

-# TODO: Note that this forces an allocation, because we aren't yet able to

-# quickly detect that reads beyond EOF of the backing file are always zero

CLUSTER_SIZE=2048 TEST_IMG="$TEST_IMG.base" _make_test_img $((size + 1024))

# Write at the front: sector-wise, the request is:

@@ -XXX,XX +XXX,XX @@ $QEMU_IO -c "alloc $size 2048" "$TEST_IMG" | _filter_qemu_io

$QEMU_IMG map --output=json "$TEST_IMG" | _filter_qemu_img_map

# Repeat with backing file holding zero'd cluster

-# TODO: Note that this forces an allocation, because we aren't yet able to

-# quickly detect that reads beyond EOF of the backing file are always zero

$QEMU_IO -c "write -z $size 512" "$TEST_IMG.base" | _filter_qemu_io

# Write at the front: sector-wise, the request is:

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

index XXXXXXX..XXXXXXX 100644

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

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

@@ -XXX,XX +XXX,XX @@ wrote 512/512 bytes at offset 134217728

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

2048/2048 bytes allocated at offset 128 MiB

[{ "start": 0, "length": 134217728, "depth": 1, "zero": true, "data": false},

-{ "start": 134217728, "length": 2048, "depth": 0, "zero": false, "data": true, "offset": OFFSET}]

+{ "start": 134217728, "length": 2048, "depth": 0, "zero": true, "data": false}]

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

wrote 512/512 bytes at offset 134219264

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

2048/2048 bytes allocated at offset 128 MiB

[{ "start": 0, "length": 134217728, "depth": 1, "zero": true, "data": false},

-{ "start": 134217728, "length": 2048, "depth": 0, "zero": false, "data": true, "offset": OFFSET}]

+{ "start": 134217728, "length": 2048, "depth": 0, "zero": true, "data": false}]

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

wrote 1024/1024 bytes at offset 134218240

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

2048/2048 bytes allocated at offset 128 MiB

[{ "start": 0, "length": 134217728, "depth": 1, "zero": true, "data": false},

-{ "start": 134217728, "length": 2048, "depth": 0, "zero": false, "data": true, "offset": OFFSET}]

+{ "start": 134217728, "length": 2048, "depth": 0, "zero": true, "data": false}]

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

wrote 2048/2048 bytes at offset 134217728

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

@@ -XXX,XX +XXX,XX @@ wrote 512/512 bytes at offset 134217728

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

2048/2048 bytes allocated at offset 128 MiB

[{ "start": 0, "length": 134217728, "depth": 1, "zero": true, "data": false},

-{ "start": 134217728, "length": 2048, "depth": 0, "zero": false, "data": true, "offset": OFFSET}]

+{ "start": 134217728, "length": 2048, "depth": 0, "zero": true, "data": false}]

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

wrote 512/512 bytes at offset 134219264

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

2048/2048 bytes allocated at offset 128 MiB

[{ "start": 0, "length": 134217728, "depth": 1, "zero": true, "data": false},

-{ "start": 134217728, "length": 2048, "depth": 0, "zero": false, "data": true, "offset": OFFSET}]

+{ "start": 134217728, "length": 2048, "depth": 0, "zero": true, "data": false}]

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

wrote 1024/1024 bytes at offset 134218240

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

2048/2048 bytes allocated at offset 128 MiB

[{ "start": 0, "length": 134217728, "depth": 1, "zero": true, "data": false},

-{ "start": 134217728, "length": 2048, "depth": 0, "zero": false, "data": true, "offset": OFFSET}]

+{ "start": 134217728, "length": 2048, "depth": 0, "zero": true, "data": false}]

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

wrote 2048/2048 bytes at offset 134217728

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

2.9.4

From: Eric Blake <eblake@redhat.com>

Just as the block layer already sets BDRV_BLOCK_ALLOCATED as a

shortcut for subsequent operations, there are also some optimizations

that are made easier if we can quickly tell that *pnum will advance

us to the end of a file, via a new BDRV_BLOCK_EOF which gets set

by the block layer.

This just plumbs up the new bit; subsequent patches will make use

of it.

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

Message-Id: <20170505021500.19315-2-eblake@redhat.com>

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

Signed-off-by: Fam Zheng <famz@redhat.com>

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

include/block/block.h | 2 ++

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

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

--- a/block/io.c

+++ b/block/io.c

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

* Drivers not implementing the functionality are assumed to not support

* backing files, hence all their sectors are reported as allocated.

*

- * If 'sector_num' is beyond the end of the disk image the return value is 0

- * and 'pnum' is set to 0.

+ * If 'sector_num' is beyond the end of the disk image the return value is

+ * BDRV_BLOCK_EOF and 'pnum' is set to 0.

*

* 'pnum' is set to the number of sectors (including and immediately following

* the specified sector) that are known to be in the same

* allocated/unallocated state.

*

* 'nb_sectors' is the max value 'pnum' should be set to. If nb_sectors goes

- * beyond the end of the disk image it will be clamped.

+ * beyond the end of the disk image it will be clamped; if 'pnum' is set to

+ * the end of the image, then the returned value will include BDRV_BLOCK_EOF.

*

* If returned value is positive and BDRV_BLOCK_OFFSET_VALID bit is set, 'file'

* points to the BDS which the sector range is allocated in.

@@ -XXX,XX +XXX,XX @@ static int64_t coroutine_fn bdrv_co_get_block_status(BlockDriverState *bs,

if (sector_num >= total_sectors) {

*pnum = 0;

- return 0;

+ return BDRV_BLOCK_EOF;

}

n = total_sectors - sector_num;

@@ -XXX,XX +XXX,XX @@ static int64_t coroutine_fn bdrv_co_get_block_status(BlockDriverState *bs,

if (!bs->drv->bdrv_co_get_block_status) {

*pnum = nb_sectors;

ret = BDRV_BLOCK_DATA | BDRV_BLOCK_ALLOCATED;

+ if (sector_num + nb_sectors == total_sectors) {

+ ret |= BDRV_BLOCK_EOF;

+ }

if (bs->drv->protocol_name) {

ret |= BDRV_BLOCK_OFFSET_VALID | (sector_num * BDRV_SECTOR_SIZE);

}

@@ -XXX,XX +XXX,XX @@ static int64_t coroutine_fn bdrv_co_get_block_status(BlockDriverState *bs,

out:

bdrv_dec_in_flight(bs);

+ if (ret >= 0 && sector_num + *pnum == total_sectors) {

+ ret |= BDRV_BLOCK_EOF;

+ }

return ret;

2.9.4