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>

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

---

block.c | 3 ++-

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

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

index XXXXXXX..XXXXXXX 100644

--- a/block.c

+++ b/block.c

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

In the process of converting sector-based interfaces to bytes,

I'm finding it easier to represent a byte count as a 64-bit

integer at the block layer (even if we are internally capped

by SIZE_MAX or even INT_MAX for individual transactions, it's

still nicer to not have to worry about truncation/overflow

issues on as many variables). Update the signature of

bdrv_round_to_clusters() to uniformly use int64_t, matching

the signature already chosen for bdrv_is_allocated and the

fact that off_t is also a signed type, then adjust clients

according to the required fallout (even where the result could

now exceed 32 bits, no client is directly assigning the result

into a 32-bit value without breaking things into a loop first).

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

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

---

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

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

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

block/trace-events | 2 +-

4 files changed, 9 insertions(+), 10 deletions(-)

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

index XXXXXXX..XXXXXXX 100644

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

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

@@ -XXX,XX +XXX,XX @@ int bdrv_get_flags(BlockDriverState *bs);

int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi);

ImageInfoSpecific *bdrv_get_specific_info(BlockDriverState *bs);

void bdrv_round_to_clusters(BlockDriverState *bs,

- int64_t offset, unsigned int bytes,

+ int64_t offset, int64_t bytes,

int64_t *cluster_offset,

- unsigned int *cluster_bytes);

+ int64_t *cluster_bytes);

const char *bdrv_get_encrypted_filename(BlockDriverState *bs);

void bdrv_get_backing_filename(BlockDriverState *bs,

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 void mark_request_serialising(BdrvTrackedRequest *req, uint64_t align)

* Round a region to cluster boundaries

*/

void bdrv_round_to_clusters(BlockDriverState *bs,

- int64_t offset, unsigned int bytes,

+ int64_t offset, int64_t bytes,

int64_t *cluster_offset,

- unsigned int *cluster_bytes)

+ int64_t *cluster_bytes)

{

BlockDriverInfo bdi;

@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_do_copy_on_readv(BdrvChild *child,

struct iovec iov;

QEMUIOVector local_qiov;

int64_t cluster_offset;

- unsigned int cluster_bytes;

+ int64_t cluster_bytes;

size_t skip_bytes;

int ret;

int max_transfer = MIN_NON_ZERO(bs->bl.max_transfer,

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 @@ static int mirror_cow_align(MirrorBlockJob *s, int64_t *offset,

bool need_cow;

int ret = 0;

int64_t align_offset = *offset;

- unsigned int align_bytes = *bytes;

+ int64_t align_bytes = *bytes;

int max_bytes = s->granularity * s->max_iov;

- assert(*bytes < INT_MAX);

need_cow = !test_bit(*offset / s->granularity, s->cow_bitmap);

need_cow |= !test_bit((*offset + *bytes - 1) / s->granularity,

s->cow_bitmap);

@@ -XXX,XX +XXX,XX @@ static uint64_t coroutine_fn mirror_iteration(MirrorBlockJob *s)

while (nb_chunks > 0 && offset < s->bdev_length) {

int64_t ret;

int io_sectors;

- unsigned int io_bytes;

+ int64_t io_bytes;

int64_t io_bytes_acct;

enum MirrorMethod {

MIRROR_METHOD_COPY,

@@ -XXX,XX +XXX,XX @@ static uint64_t coroutine_fn mirror_iteration(MirrorBlockJob *s)

io_bytes = s->granularity;

} else if (ret >= 0 && !(ret & BDRV_BLOCK_DATA)) {

int64_t target_offset;

- unsigned int target_bytes;

+ int64_t target_bytes;

bdrv_round_to_clusters(blk_bs(s->target), offset, io_bytes,

&target_offset, &target_bytes);

if (target_offset == offset &&

diff --git a/block/trace-events b/block/trace-events

index XXXXXXX..XXXXXXX 100644

--- a/block/trace-events

+++ b/block/trace-events

@@ -XXX,XX +XXX,XX @@ blk_co_pwritev(void *blk, void *bs, int64_t offset, unsigned int bytes, int flag

bdrv_co_preadv(void *bs, int64_t offset, int64_t nbytes, unsigned int flags) "bs %p offset %"PRId64" nbytes %"PRId64" flags 0x%x"

bdrv_co_pwritev(void *bs, int64_t offset, int64_t nbytes, unsigned int flags) "bs %p offset %"PRId64" nbytes %"PRId64" flags 0x%x"

bdrv_co_pwrite_zeroes(void *bs, int64_t offset, int count, int flags) "bs %p offset %"PRId64" count %d flags 0x%x"

-bdrv_co_do_copy_on_readv(void *bs, int64_t offset, unsigned int bytes, int64_t cluster_offset, unsigned int cluster_bytes) "bs %p offset %"PRId64" bytes %u cluster_offset %"PRId64" cluster_bytes %u"

+bdrv_co_do_copy_on_readv(void *bs, int64_t offset, unsigned int bytes, int64_t cluster_offset, int64_t cluster_bytes) "bs %p offset %"PRId64" bytes %u cluster_offset %"PRId64" cluster_bytes %"PRId64

# block/stream.c

stream_one_iteration(void *s, int64_t offset, uint64_t bytes, int is_allocated) "s %p offset %" PRId64 " bytes %" PRIu64 " is_allocated %d"

--

2.13.6

From: Eric Blake <eblake@redhat.com>

We are gradually converting to byte-based interfaces, as they are

easier to reason about than sector-based. Convert another internal

function (no semantic change), and rename it to is_zero() in the

process.

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

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

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

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

---

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

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

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

index XXXXXXX..XXXXXXX 100644

--- a/block/qcow2.c

+++ b/block/qcow2.c

@@ -XXX,XX +XXX,XX @@ finish:

}

-static bool is_zero_sectors(BlockDriverState *bs, int64_t start,

- uint32_t count)

+static bool is_zero(BlockDriverState *bs, int64_t offset, int64_t bytes)

{

int nr;

int64_t res;

+ int64_t start;

- if (start + count > bs->total_sectors) {

- count = bs->total_sectors - 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 (!count) {

+ if (!bytes) {

return true;

}

- res = bdrv_get_block_status_above(bs, NULL, start, count, &nr, NULL);

- return res >= 0 && (res & BDRV_BLOCK_ZERO) && nr == count;

+ res = bdrv_get_block_status_above(bs, NULL, start >> BDRV_SECTOR_BITS,

+ bytes >> BDRV_SECTOR_BITS, &nr, NULL);

+ return res >= 0 && (res & BDRV_BLOCK_ZERO) &&

+ nr * BDRV_SECTOR_SIZE == bytes;

}

static coroutine_fn int qcow2_co_pwrite_zeroes(BlockDriverState *bs,

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

}

if (head || tail) {

- int64_t cl_start = (offset - head) >> BDRV_SECTOR_BITS;

uint64_t off;

unsigned int nr;

assert(head + bytes <= s->cluster_size);

/* check whether remainder of cluster already reads as zero */

- if (!(is_zero_sectors(bs, cl_start,

- DIV_ROUND_UP(head, BDRV_SECTOR_SIZE)) &&

- is_zero_sectors(bs, (offset + bytes) >> BDRV_SECTOR_BITS,

- DIV_ROUND_UP(-tail & (s->cluster_size - 1),

- BDRV_SECTOR_SIZE)))) {

+ if (!(is_zero(bs, offset - head, head) &&

+ is_zero(bs, offset + bytes,

+ tail ? s->cluster_size - tail : 0))) {

return -ENOTSUP;

}

qemu_co_mutex_lock(&s->lock);

/* We can have new write after previous check */

- offset = cl_start << BDRV_SECTOR_BITS;

+ offset = QEMU_ALIGN_DOWN(offset, s->cluster_size);

bytes = s->cluster_size;

nr = s->cluster_size;

ret = qcow2_get_cluster_offset(bs, offset, &nr, &off);

--

2.13.6

From: Eric Blake <eblake@redhat.com>

We are gradually converting to byte-based interfaces, as they are

easier to reason about than sector-based. Change the internal

loop iteration of zeroing a device to track by bytes instead of

sectors (although we are still guaranteed that we iterate by steps

that are sector-aligned).

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

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

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

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

---

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

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

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 @@ int bdrv_pwrite_zeroes(BdrvChild *child, int64_t offset,

*/

int bdrv_make_zero(BdrvChild *child, BdrvRequestFlags flags)

{

- int64_t target_sectors, ret, nb_sectors, sector_num = 0;

+ int64_t target_size, ret, bytes, offset = 0;

BlockDriverState *bs = child->bs;

- int n;

+ int n; /* sectors */

- target_sectors = bdrv_nb_sectors(bs);

- if (target_sectors < 0) {

- return target_sectors;

+ target_size = bdrv_getlength(bs);

+ if (target_size < 0) {

+ return target_size;

}

for (;;) {

- nb_sectors = MIN(target_sectors - sector_num, BDRV_REQUEST_MAX_SECTORS);

- if (nb_sectors <= 0) {

+ bytes = MIN(target_size - offset, BDRV_REQUEST_MAX_BYTES);

+ if (bytes <= 0) {

return 0;

}

- ret = bdrv_get_block_status(bs, sector_num, nb_sectors, &n, NULL);

+ ret = bdrv_get_block_status(bs, offset >> BDRV_SECTOR_BITS,

+ bytes >> BDRV_SECTOR_BITS, &n, NULL);

if (ret < 0) {

- error_report("error getting block status at sector %" PRId64 ": %s",

- sector_num, strerror(-ret));

+ error_report("error getting block status at offset %" PRId64 ": %s",

+ offset, strerror(-ret));

return ret;

}

if (ret & BDRV_BLOCK_ZERO) {

- sector_num += n;

+ offset += n * BDRV_SECTOR_BITS;

continue;

}

- ret = bdrv_pwrite_zeroes(child, sector_num << BDRV_SECTOR_BITS,

- n << BDRV_SECTOR_BITS, flags);

+ ret = bdrv_pwrite_zeroes(child, offset, n * BDRV_SECTOR_SIZE, flags);

if (ret < 0) {

- error_report("error writing zeroes at sector %" PRId64 ": %s",

- sector_num, strerror(-ret));

+ error_report("error writing zeroes at offset %" PRId64 ": %s",

+ offset, strerror(-ret));

return ret;

}

- sector_num += n;

+ offset += n * BDRV_SECTOR_SIZE;

}

}

--

2.13.6

From: Eric Blake <eblake@redhat.com>

We are gradually converting to byte-based interfaces, as they are

easier to reason about than sector-based. Continue by converting

an internal function (no semantic change), and simplifying its

caller accordingly.

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

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

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

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

---

qemu-img.c | 24 +++++++++++-------------

1 file changed, 11 insertions(+), 13 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 void dump_map_entry(OutputFormat output_format, MapEntry *e,

}

}

-static int get_block_status(BlockDriverState *bs, int64_t sector_num,

- int nb_sectors, MapEntry *e)

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

+ int64_t bytes, MapEntry *e)

{

int64_t ret;

int depth;

BlockDriverState *file;

bool has_offset;

+ int nb_sectors = bytes >> BDRV_SECTOR_BITS;

+ assert(bytes < INT_MAX);

/* As an optimization, we could cache the current range of unallocated

* clusters in each file of the chain, and avoid querying the same

* range repeatedly.

@@ -XXX,XX +XXX,XX @@ static int get_block_status(BlockDriverState *bs, int64_t sector_num,

depth = 0;

for (;;) {

- ret = bdrv_get_block_status(bs, sector_num, nb_sectors, &nb_sectors,

- &file);

+ ret = bdrv_get_block_status(bs, offset >> BDRV_SECTOR_BITS, nb_sectors,

+ &nb_sectors, &file);

if (ret < 0) {

return ret;

}

@@ -XXX,XX +XXX,XX @@ static int get_block_status(BlockDriverState *bs, int64_t sector_num,

has_offset = !!(ret & BDRV_BLOCK_OFFSET_VALID);

*e = (MapEntry) {

- .start = sector_num * BDRV_SECTOR_SIZE,

+ .start = offset,

.length = nb_sectors * BDRV_SECTOR_SIZE,

.data = !!(ret & BDRV_BLOCK_DATA),

.zero = !!(ret & BDRV_BLOCK_ZERO),

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

length = blk_getlength(blk);

while (curr.start + curr.length < length) {

- int64_t nsectors_left;

- int64_t sector_num;

- int n;

-

- sector_num = (curr.start + curr.length) >> BDRV_SECTOR_BITS;

+ int64_t offset = curr.start + curr.length;

+ int64_t n;

/* Probe up to 1 GiB at a time. */

- nsectors_left = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE) - sector_num;

- n = MIN(1 << (30 - BDRV_SECTOR_BITS), nsectors_left);

- ret = get_block_status(bs, sector_num, n, &next);

+ n = QEMU_ALIGN_DOWN(MIN(1 << 30, length - offset), BDRV_SECTOR_SIZE);

+ ret = get_block_status(bs, offset, n, &next);

if (ret < 0) {

error_report("Could not read file metadata: %s", strerror(-ret));

--

2.13.6

From: Eric Blake <eblake@redhat.com>

We are gradually moving away from sector-based interfaces, towards

byte-based. In the common case, allocation is unlikely to ever use

values that are not naturally sector-aligned, but it is possible

that byte-based values will let us be more precise about allocation

at the end of an unaligned file that can do byte-based access.

Changing the name of the function from bdrv_get_block_status() to

bdrv_block_status() ensures that the compiler enforces that all

callers are updated. For now, the io.c layer still assert()s that

all callers are sector-aligned, but that can be relaxed when a later

patch implements byte-based block status in the drivers.

There was an inherent limitation in returning the offset via the

return value: we only have room for BDRV_BLOCK_OFFSET_MASK bits, which

means an offset can only be mapped for sector-aligned queries (or,

if we declare that non-aligned input is at the same relative position

modulo 512 of the answer), so the new interface also changes things to

return the offset via output through a parameter by reference rather

than mashed into the return value. We'll have some glue code that

munges between the two styles until we finish converting all uses.

For the most part this patch is just the addition of scaling at the

callers followed by inverse scaling at bdrv_block_status(), coupled

with the tweak in calling convention. But some code, particularly

bdrv_is_allocated(), gets a lot simpler because it no longer has to

mess with sectors.

For ease of review, bdrv_get_block_status_above() will be tackled

separately.

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

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

---

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

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

block/qcow2-cluster.c | 2 +-

qemu-img.c | 25 ++++++++++++++-----------

4 files changed, 58 insertions(+), 33 deletions(-)

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

index XXXXXXX..XXXXXXX 100644

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

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

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

#define BDRV_REQUEST_MAX_BYTES (BDRV_REQUEST_MAX_SECTORS << BDRV_SECTOR_BITS)

/*

- * Allocation status flags for bdrv_get_block_status() and friends.

+ * Allocation status flags for bdrv_block_status() and friends.

*

* Public flags:

* BDRV_BLOCK_DATA: allocation for data at offset is tied to this layer

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

* that the block layer recompute the answer from the returned

* BDS; must be accompanied by just BDRV_BLOCK_OFFSET_VALID.

*

- * If BDRV_BLOCK_OFFSET_VALID is set, bits 9-62 (BDRV_BLOCK_OFFSET_MASK)

- * represent the offset in the returned BDS that is allocated for the

- * corresponding raw data; however, whether that offset actually contains

- * data also depends on BDRV_BLOCK_DATA and BDRV_BLOCK_ZERO, as follows:

+ * If BDRV_BLOCK_OFFSET_VALID is set, bits 9-62 (BDRV_BLOCK_OFFSET_MASK) of

+ * the return value (old interface) or the entire map parameter (new

+ * interface) represent the offset in the returned BDS that is allocated for

+ * the corresponding raw data. However, whether that offset actually

+ * contains data also depends on BDRV_BLOCK_DATA, as follows:

*

* DATA ZERO OFFSET_VALID

* t t t sectors read as zero, returned file is zero at offset

@@ -XXX,XX +XXX,XX @@ int bdrv_has_zero_init_1(BlockDriverState *bs);

int bdrv_has_zero_init(BlockDriverState *bs);

bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs);

bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs);

-int64_t bdrv_get_block_status(BlockDriverState *bs, int64_t sector_num,

- int nb_sectors, int *pnum,

- BlockDriverState **file);

+int bdrv_block_status(BlockDriverState *bs, int64_t offset,

+ int64_t bytes, int64_t *pnum, int64_t *map,

+ BlockDriverState **file);

int64_t bdrv_get_block_status_above(BlockDriverState *bs,

BlockDriverState *base,

int64_t sector_num,

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 @@ int bdrv_pwrite_zeroes(BdrvChild *child, int64_t offset,

*/

int bdrv_make_zero(BdrvChild *child, BdrvRequestFlags flags)

{

- int64_t target_size, ret, bytes, offset = 0;

+ int ret;

+ int64_t target_size, bytes, offset = 0;

BlockDriverState *bs = child->bs;

- int n; /* sectors */

target_size = bdrv_getlength(bs);

if (target_size < 0) {

@@ -XXX,XX +XXX,XX @@ int bdrv_make_zero(BdrvChild *child, BdrvRequestFlags flags)

if (bytes <= 0) {

return 0;

}

- ret = bdrv_get_block_status(bs, offset >> BDRV_SECTOR_BITS,

- bytes >> BDRV_SECTOR_BITS, &n, NULL);

+ ret = bdrv_block_status(bs, offset, bytes, &bytes, NULL, NULL);

if (ret < 0) {

error_report("error getting block status at offset %" PRId64 ": %s",

offset, strerror(-ret));

return ret;

}

if (ret & BDRV_BLOCK_ZERO) {

- offset += n * BDRV_SECTOR_BITS;

+ offset += bytes;

continue;

}

- ret = bdrv_pwrite_zeroes(child, offset, n * BDRV_SECTOR_SIZE, flags);

+ ret = bdrv_pwrite_zeroes(child, offset, bytes, flags);

if (ret < 0) {

error_report("error writing zeroes at offset %" PRId64 ": %s",

offset, strerror(-ret));

return ret;

}

- offset += n * BDRV_SECTOR_SIZE;

+ offset += bytes;

}

}

@@ -XXX,XX +XXX,XX @@ int64_t bdrv_get_block_status_above(BlockDriverState *bs,

nb_sectors, pnum, file);

}

-int64_t bdrv_get_block_status(BlockDriverState *bs,

- int64_t sector_num,

- int nb_sectors, int *pnum,

- BlockDriverState **file)

+int bdrv_block_status(BlockDriverState *bs, int64_t offset, int64_t bytes,

+ int64_t *pnum, int64_t *map, BlockDriverState **file)

{

- return bdrv_get_block_status_above(bs, backing_bs(bs),

- sector_num, nb_sectors, pnum, file);

+ int64_t ret;

+ int n;

+

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

+ assert(pnum);

+ /*

+ * 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.

+ */

+ bytes = MIN(bytes, BDRV_REQUEST_MAX_BYTES);

+ ret = bdrv_get_block_status_above(bs, backing_bs(bs),

+ offset >> BDRV_SECTOR_BITS,

+ bytes >> BDRV_SECTOR_BITS, &n, file);

+ if (ret < 0) {

+ assert(INT_MIN <= ret);

+ *pnum = 0;

+ return ret;

+ }

+ *pnum = n * BDRV_SECTOR_SIZE;

+ if (map) {

+ *map = ret & BDRV_BLOCK_OFFSET_MASK;

+ } else {

+ ret &= ~BDRV_BLOCK_OFFSET_VALID;

+ }

+ return ret & ~BDRV_BLOCK_OFFSET_MASK;

}

int coroutine_fn bdrv_is_allocated(BlockDriverState *bs, int64_t offset,

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

index XXXXXXX..XXXXXXX 100644

--- a/block/qcow2-cluster.c

+++ b/block/qcow2-cluster.c

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

* cluster is already marked as zero, or if it's unallocated and we

* don't have a backing file.

*