The following changes since commit 2d2c73d0e3d504a61f868e46e6abd5643f38091b:

Merge remote-tracking branch 'remotes/pmaydell/tags/pull-target-arm-20200914-1' into staging (2020-09-14 16:03:08 +0100)

https://github.com/XanClic/qemu.git tags/pull-block-2020-09-15

for you to fetch changes up to 7bae7c805d82675eb3a02c744093703d84ada2d6:

block/rbd: add 'namespace' to qemu_rbd_strong_runtime_opts[] (2020-09-15 11:31:10 +0200)

- Several qcow2 fixes and refactorings

- Let qemu-img convert try to stay at cluster boundaries

- Stable child names for quorum (with x-blockdev-change)

- Explicitly drop vhdx 4k sector support, as it was never actually

working

- rbd: Mark @namespace a strong runtime option

- iotests.py improvements

- Drop unused runtime_opts objects

- Skip a test case in 030 when run through make check-block

Alberto Garcia (9):

qcow2: Use macros for the L1, refcount and bitmap table entry sizes

qcow2: Fix removal of list members from BDRVQcow2State.cluster_allocs

qcow2: Don't check nb_clusters when removing l2meta from the list

qcow2: Rewrite the documentation of qcow2_alloc_cluster_offset()

qcow2: Handle QCowL2Meta on error in preallocate_co()

qcow2: Make qcow2_free_any_clusters() free only one cluster

qcow2: Return the original error code in qcow2_co_pwrite_zeroes()

qcow2: Make preallocate_co() resize the image to the correct size

qcow2: Convert qcow2_alloc_cluster_offset() into

qcow2_alloc_host_offset()

John Snow (2):

block/rbd: remove runtime_opts

block/qcow: remove runtime opts

Lukas Straub (1):

block/quorum.c: stable children names

Nir Soffer (5):

qemu-iotests: Fix FilePaths cleanup

qemu-iotests: Fix FilePaths docstring

qemu-iotests: Support varargs syntax in FilePaths

qemu-iotests: Merge FilePaths and FilePath

qemu-iotests: Simplify FilePath __init__

Peter Lieven (1):

qemu-img: avoid unaligned read requests during convert

Stefano Garzarella (1):

block/rbd: add 'namespace' to qemu_rbd_strong_runtime_opts[]

Swapnil Ingle (1):

block/vhdx: Support vhdx image only with 512 bytes logical sector size

Thomas Huth (1):

iotests: Skip test_stream_parallel in test 030 when doing "make check"

Yi Li (1):

qemu-img: Explicit number replaced by a constant

block/qcow2.h | 16 +++--

block/qcow.c | 9 ---

block/qcow2-bitmap.c | 11 ++--

block/qcow2-cluster.c | 69 ++++++++++++----------

block/qcow2-refcount.c | 97 +++++++++++++++---------------

block/qcow2-snapshot.c | 20 +++----

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

block/quorum.c | 20 +++++--

block/rbd.c | 43 +-------------

block/vhdx.c | 6 +-

qemu-img.c | 32 ++++++++--

tests/check-block.sh | 3 +

tests/qemu-iotests/030 | 2 +

tests/qemu-iotests/125 | 44 ++++++++------

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

tests/qemu-iotests/194 | 4 +-

tests/qemu-iotests/208 | 2 +-

tests/qemu-iotests/222 | 2 +-

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

tests/qemu-iotests/257 | 10 ++--

tests/qemu-iotests/305 | 74 +++++++++++++++++++++++

tests/qemu-iotests/305.out | 16 +++++

tests/qemu-iotests/group | 1 +

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

24 files changed, 395 insertions(+), 282 deletions(-)

create mode 100755 tests/qemu-iotests/305

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

2.26.2

From: Peter Lieven <pl@kamp.de>

in case of large continous areas that share the same allocation status

it happens that the value of s->sector_next_status is unaligned to the

cluster size or even request alignment of the source. Avoid this by

stripping down the s->sector_next_status position to cluster boundaries.

Signed-off-by: Peter Lieven <pl@kamp.de>

Message-Id: <20200901125129.6398-1-pl@kamp.de>

[mreitz: Disable vhdx for 251]

qemu-img.c | 22 ++++++++++++++++++++++

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

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

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

--- a/qemu-img.c

+++ b/qemu-img.c

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

typedef struct ImgConvertState {

BlockBackend **src;

int64_t *src_sectors;

+ int *src_alignment;

int src_num;

int64_t total_sectors;

int64_t allocated_sectors;

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

if (s->sector_next_status <= sector_num) {

uint64_t offset = (sector_num - src_cur_offset) * BDRV_SECTOR_SIZE;

int64_t count;

+ int tail;

BlockDriverState *src_bs = blk_bs(s->src[src_cur]);

BlockDriverState *base;

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

n = DIV_ROUND_UP(count, BDRV_SECTOR_SIZE);

+ /*

+ * Avoid that s->sector_next_status becomes unaligned to the source

+ * request alignment and/or cluster size to avoid unnecessary read

+ * cycles.

+ */

+ tail = (sector_num - src_cur_offset + n) % s->src_alignment[src_cur];

+ if (n > tail) {

+ n -= tail;

+ }

if (ret & BDRV_BLOCK_ZERO) {

s->status = post_backing_zero ? BLK_BACKING_FILE : BLK_ZERO;

} else if (ret & BDRV_BLOCK_DATA) {

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

s.src = g_new0(BlockBackend *, s.src_num);

s.src_sectors = g_new(int64_t, s.src_num);

+ s.src_alignment = g_new(int, s.src_num);

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

+ BlockDriverState *src_bs;

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

fmt, src_flags, src_writethrough, s.quiet,

force_share);

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

ret = -1;

goto out;

}

+ src_bs = blk_bs(s.src[bs_i]);

+ s.src_alignment[bs_i] = DIV_ROUND_UP(src_bs->bl.request_alignment,

+ BDRV_SECTOR_SIZE);

+ if (!bdrv_get_info(src_bs, &bdi)) {

+ s.src_alignment[bs_i] = MAX(s.src_alignment[bs_i],

+ bdi.cluster_size / BDRV_SECTOR_SIZE);

+ }

s.total_sectors += s.src_sectors[bs_i];

@@ -XXX,XX +XXX,XX @@ out:

g_free(s.src);

}

g_free(s.src_sectors);

+ g_free(s.src_alignment);

fail_getopt:

g_free(options);

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

index XXXXXXX..XXXXXXX 100755

--- a/tests/qemu-iotests/251

+++ b/tests/qemu-iotests/251

@@ -XXX,XX +XXX,XX @@ if [ "$IMGOPTSSYNTAX" = "true" ]; then

# We use json:{} filenames here, so we cannot work with additional options.

_unsupported_fmt $IMGFMT

else

- # With VDI, the output is ordered differently. Just disable it.

- _unsupported_fmt vdi

+ # - With VDI, the output is ordered differently. Just disable it.

+ # - VHDX has large clusters; because qemu-img convert tries to

+ # align the requests to the cluster size, the output is ordered

+ # differently, so disable it, too.

+ _unsupported_fmt vdi vhdx

fi

2.26.2

From: Alberto Garcia <berto@igalia.com>

This patch replaces instances of sizeof(uint64_t) in the qcow2 driver

with macros that indicate what those sizes are actually referring to.

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

Message-Id: <20200828110828.13833-1-berto@igalia.com>

block/qcow2.h | 6 +++

block/qcow2-bitmap.c | 11 ++++--

block/qcow2-cluster.c | 24 ++++++------

block/qcow2-refcount.c | 89 ++++++++++++++++++++++--------------------

block/qcow2-snapshot.c | 20 +++++-----

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

6 files changed, 94 insertions(+), 83 deletions(-)

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

--- a/block/qcow2.h

+++ b/block/qcow2.h

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

#define L2E_SIZE_NORMAL (sizeof(uint64_t))

#define L2E_SIZE_EXTENDED (sizeof(uint64_t) * 2)

+/* Size of L1 table entries */

+#define L1E_SIZE (sizeof(uint64_t))

+

+/* Size of reftable entries */

+#define REFTABLE_ENTRY_SIZE (sizeof(uint64_t))

+

#define MIN_CLUSTER_BITS 9

#define MAX_CLUSTER_BITS 21

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

--- a/block/qcow2-bitmap.c

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

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

#define BME_MIN_GRANULARITY_BITS 9

#define BME_MAX_NAME_SIZE 1023

+/* Size of bitmap table entries */

+#define BME_TABLE_ENTRY_SIZE (sizeof(uint64_t))

+

QEMU_BUILD_BUG_ON(BME_MAX_NAME_SIZE != BDRV_BITMAP_MAX_NAME_SIZE);

#if BME_MAX_TABLE_SIZE * 8ULL > INT_MAX

@@ -XXX,XX +XXX,XX @@ static int bitmap_table_load(BlockDriverState *bs, Qcow2BitmapTable *tb,

assert(tb->size <= BME_MAX_TABLE_SIZE);

ret = bdrv_pread(bs->file, tb->offset,

- table, tb->size * sizeof(uint64_t));

+ table, tb->size * BME_TABLE_ENTRY_SIZE);

if (ret < 0) {

goto fail;

}

@@ -XXX,XX +XXX,XX @@ static int free_bitmap_clusters(BlockDriverState *bs, Qcow2BitmapTable *tb)

}

clear_bitmap_table(bs, bitmap_table, tb->size);

- qcow2_free_clusters(bs, tb->offset, tb->size * sizeof(uint64_t),

+ qcow2_free_clusters(bs, tb->offset, tb->size * BME_TABLE_ENTRY_SIZE,

QCOW2_DISCARD_OTHER);

g_free(bitmap_table);

@@ -XXX,XX +XXX,XX @@ int qcow2_check_bitmaps_refcounts(BlockDriverState *bs, BdrvCheckResult *res,

ret = qcow2_inc_refcounts_imrt(bs, res,

refcount_table, refcount_table_size,

bm->table.offset,

- bm->table.size * sizeof(uint64_t));

+ bm->table.size * BME_TABLE_ENTRY_SIZE);

if (ret < 0) {

goto out;

}

@@ -XXX,XX +XXX,XX @@ uint64_t qcow2_get_persistent_dirty_bitmap_size(BlockDriverState *in_bs,

/* Assume the entire bitmap is allocated */

bitmaps_size += bmclusters * cluster_size;

/* Also reserve space for the bitmap table entries */

- bitmaps_size += ROUND_UP(bmclusters * sizeof(uint64_t),

+ bitmaps_size += ROUND_UP(bmclusters * BME_TABLE_ENTRY_SIZE,

cluster_size);

/* And space for contribution to bitmap directory size */

bitmap_dir_size += calc_dir_entry_size(strlen(name), 0);

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 @@ int qcow2_shrink_l1_table(BlockDriverState *bs, uint64_t exact_size)

BLKDBG_EVENT(bs->file, BLKDBG_L1_SHRINK_WRITE_TABLE);

ret = bdrv_pwrite_zeroes(bs->file, s->l1_table_offset +

- new_l1_size * sizeof(uint64_t),

- (s->l1_size - new_l1_size) * sizeof(uint64_t), 0);

+ new_l1_size * L1E_SIZE,

+ (s->l1_size - new_l1_size) * L1E_SIZE, 0);

if (ret < 0) {

goto fail;

}

@@ -XXX,XX +XXX,XX @@ fail:

* l1_table in memory to avoid possible image corruption.

*/

memset(s->l1_table + new_l1_size, 0,

- (s->l1_size - new_l1_size) * sizeof(uint64_t));

+ (s->l1_size - new_l1_size) * L1E_SIZE);

return ret;

@@ -XXX,XX +XXX,XX @@ int qcow2_grow_l1_table(BlockDriverState *bs, uint64_t min_size,

/* Do a sanity check on min_size before trying to calculate new_l1_size

* (this prevents overflows during the while loop for the calculation of

* new_l1_size) */

- if (min_size > INT_MAX / sizeof(uint64_t)) {

+ if (min_size > INT_MAX / L1E_SIZE) {

return -EFBIG;

}

@@ -XXX,XX +XXX,XX @@ int qcow2_grow_l1_table(BlockDriverState *bs, uint64_t min_size,

}

QEMU_BUILD_BUG_ON(QCOW_MAX_L1_SIZE > INT_MAX);

- if (new_l1_size > QCOW_MAX_L1_SIZE / sizeof(uint64_t)) {

+ if (new_l1_size > QCOW_MAX_L1_SIZE / L1E_SIZE) {

return -EFBIG;

}

@@ -XXX,XX +XXX,XX @@ int qcow2_grow_l1_table(BlockDriverState *bs, uint64_t min_size,

s->l1_size, new_l1_size);

#endif

- new_l1_size2 = sizeof(uint64_t) * new_l1_size;

+ new_l1_size2 = L1E_SIZE * new_l1_size;

new_l1_table = qemu_try_blockalign(bs->file->bs, new_l1_size2);

if (new_l1_table == NULL) {

return -ENOMEM;

@@ -XXX,XX +XXX,XX @@ int qcow2_grow_l1_table(BlockDriverState *bs, uint64_t min_size,

memset(new_l1_table, 0, new_l1_size2);

if (s->l1_size) {

- memcpy(new_l1_table, s->l1_table, s->l1_size * sizeof(uint64_t));

+ memcpy(new_l1_table, s->l1_table, s->l1_size * L1E_SIZE);

}

/* write new table (align to cluster) */

@@ -XXX,XX +XXX,XX @@ int qcow2_grow_l1_table(BlockDriverState *bs, uint64_t min_size,

s->l1_table = new_l1_table;

old_l1_size = s->l1_size;

s->l1_size = new_l1_size;

- qcow2_free_clusters(bs, old_l1_table_offset, old_l1_size * sizeof(uint64_t),

+ qcow2_free_clusters(bs, old_l1_table_offset, old_l1_size * L1E_SIZE,

QCOW2_DISCARD_OTHER);

return 0;

fail:

@@ -XXX,XX +XXX,XX @@ int qcow2_write_l1_entry(BlockDriverState *bs, int l1_index)

BDRVQcow2State *s = bs->opaque;

int l1_start_index;

int i, ret;

- int bufsize = MAX(sizeof(uint64_t),

+ int bufsize = MAX(L1E_SIZE,

MIN(bs->file->bs->bl.request_alignment, s->cluster_size));

- int nentries = bufsize / sizeof(uint64_t);

+ int nentries = bufsize / L1E_SIZE;

g_autofree uint64_t *buf = g_try_new0(uint64_t, nentries);

if (buf == NULL) {

@@ -XXX,XX +XXX,XX @@ int qcow2_expand_zero_clusters(BlockDriverState *bs,

Error *local_err = NULL;

ret = qcow2_validate_table(bs, s->snapshots[i].l1_table_offset,

- s->snapshots[i].l1_size, sizeof(uint64_t),

+ s->snapshots[i].l1_size, L1E_SIZE,

QCOW_MAX_L1_SIZE, "Snapshot L1 table",

&local_err);

if (ret < 0) {

@@ -XXX,XX +XXX,XX @@ int qcow2_expand_zero_clusters(BlockDriverState *bs,

goto fail;

}

- l1_size2 = s->snapshots[i].l1_size * sizeof(uint64_t);

+ l1_size2 = s->snapshots[i].l1_size * L1E_SIZE;

new_l1_table = g_try_realloc(l1_table, l1_size2);

if (!new_l1_table) {

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

index XXXXXXX..XXXXXXX 100644

--- a/block/qcow2-refcount.c

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

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

s->get_refcount = get_refcount_funcs[s->refcount_order];

s->set_refcount = set_refcount_funcs[s->refcount_order];

- assert(s->refcount_table_size <= INT_MAX / sizeof(uint64_t));

- refcount_table_size2 = s->refcount_table_size * sizeof(uint64_t);

+ assert(s->refcount_table_size <= INT_MAX / REFTABLE_ENTRY_SIZE);

+ refcount_table_size2 = s->refcount_table_size * REFTABLE_ENTRY_SIZE;

s->refcount_table = g_try_malloc(refcount_table_size2);

if (s->refcount_table_size > 0) {

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

if (refcount_table_index < s->refcount_table_size) {

uint64_t data64 = cpu_to_be64(new_block);

BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC_HOOKUP);

- ret = bdrv_pwrite_sync(bs->file,

- s->refcount_table_offset + refcount_table_index * sizeof(uint64_t),

+ ret = bdrv_pwrite_sync(bs->file, s->refcount_table_offset +

+ refcount_table_index * REFTABLE_ENTRY_SIZE,

&data64, sizeof(data64));

if (ret < 0) {

goto fail;

@@ -XXX,XX +XXX,XX @@ int64_t qcow2_refcount_area(BlockDriverState *bs, uint64_t start_offset,

DIV_ROUND_UP(total_refblock_count, 2);

}

/* The qcow2 file can only store the reftable size in number of clusters */

- table_size = ROUND_UP(table_size, s->cluster_size / sizeof(uint64_t));

- table_clusters = (table_size * sizeof(uint64_t)) / s->cluster_size;

+ table_size = ROUND_UP(table_size, s->cluster_size / REFTABLE_ENTRY_SIZE);

+ table_clusters = (table_size * REFTABLE_ENTRY_SIZE) / s->cluster_size;

if (table_size > QCOW_MAX_REFTABLE_SIZE) {

return -EFBIG;

@@ -XXX,XX +XXX,XX @@ int64_t qcow2_refcount_area(BlockDriverState *bs, uint64_t start_offset,

if (table_size > s->max_refcount_table_index) {

/* We're actually growing the reftable */

memcpy(new_table, s->refcount_table,

- (s->max_refcount_table_index + 1) * sizeof(uint64_t));

+ (s->max_refcount_table_index + 1) * REFTABLE_ENTRY_SIZE);

} else {

/* Improbable case: We're shrinking the reftable. However, the caller

* has assured us that there is only empty space beyond @start_offset,

* so we can simply drop all of the refblocks that won't fit into the

* new reftable. */

- memcpy(new_table, s->refcount_table, table_size * sizeof(uint64_t));

+ memcpy(new_table, s->refcount_table, table_size * REFTABLE_ENTRY_SIZE);

}

if (new_refblock_offset) {

@@ -XXX,XX +XXX,XX @@ int64_t qcow2_refcount_area(BlockDriverState *bs, uint64_t start_offset,

BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC_WRITE_TABLE);

ret = bdrv_pwrite_sync(bs->file, table_offset, new_table,

- table_size * sizeof(uint64_t));

+ table_size * REFTABLE_ENTRY_SIZE);

if (ret < 0) {

goto fail;

}

@@ -XXX,XX +XXX,XX @@ int64_t qcow2_refcount_area(BlockDriverState *bs, uint64_t start_offset,

update_max_refcount_table_index(s);

/* Free old table. */

- qcow2_free_clusters(bs, old_table_offset, old_table_size * sizeof(uint64_t),

+ qcow2_free_clusters(bs, old_table_offset,

+ old_table_size * REFTABLE_ENTRY_SIZE,

QCOW2_DISCARD_OTHER);

return end_offset;

@@ -XXX,XX +XXX,XX @@ int qcow2_update_snapshot_refcount(BlockDriverState *bs,

l2_slice = NULL;

l1_table = NULL;

- l1_size2 = l1_size * sizeof(uint64_t);

+ l1_size2 = l1_size * L1E_SIZE;

slice_size2 = s->l2_slice_size * l2_entry_size(s);

n_slices = s->cluster_size / slice_size2;

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

uint64_t *l1_table = NULL, l2_offset, l1_size2;

int i, ret;

- l1_size2 = l1_size * sizeof(uint64_t);

+ l1_size2 = l1_size * L1E_SIZE;

/* Mark L1 table as used */

ret = qcow2_inc_refcounts_imrt(bs, res, refcount_table, refcount_table_size,

@@ -XXX,XX +XXX,XX @@ static int calculate_refcounts(BlockDriverState *bs, BdrvCheckResult *res,

res->corruptions++;

continue;

}

- if (sn->l1_size > QCOW_MAX_L1_SIZE / sizeof(uint64_t)) {

+ if (sn->l1_size > QCOW_MAX_L1_SIZE / L1E_SIZE) {

fprintf(stderr, "ERROR snapshot %s (%s) l1_size=%#" PRIx32 ": "

"L1 table is too large; snapshot table entry corrupted\n",

sn->id_str, sn->name, sn->l1_size);

@@ -XXX,XX +XXX,XX @@ static int calculate_refcounts(BlockDriverState *bs, BdrvCheckResult *res,

/* refcount data */

ret = qcow2_inc_refcounts_imrt(bs, res, refcount_table, nb_clusters,

s->refcount_table_offset,

- s->refcount_table_size * sizeof(uint64_t));

+ s->refcount_table_size *

+ REFTABLE_ENTRY_SIZE);

if (ret < 0) {

return ret;

}

@@ -XXX,XX +XXX,XX @@ write_refblocks:

uint32_t old_reftable_size = reftable_size;

uint64_t *new_on_disk_reftable;

- reftable_size = ROUND_UP((refblock_index + 1) * sizeof(uint64_t),

- s->cluster_size) / sizeof(uint64_t);

+ reftable_size = ROUND_UP((refblock_index + 1) * REFTABLE_ENTRY_SIZE,

+ s->cluster_size) / REFTABLE_ENTRY_SIZE;

new_on_disk_reftable = g_try_realloc(on_disk_reftable,

reftable_size *

- sizeof(uint64_t));

+ REFTABLE_ENTRY_SIZE);

if (!new_on_disk_reftable) {

res->check_errors++;

ret = -ENOMEM;

@@ -XXX,XX +XXX,XX @@ write_refblocks:

on_disk_reftable = new_on_disk_reftable;

memset(on_disk_reftable + old_reftable_size, 0,

- (reftable_size - old_reftable_size) * sizeof(uint64_t));

+ (reftable_size - old_reftable_size) * REFTABLE_ENTRY_SIZE);

/* The offset we have for the reftable is now no longer valid;

* this will leak that range, but we can easily fix that by running

@@ -XXX,XX +XXX,XX @@ write_refblocks:

reftable_offset < 0)

{

uint64_t reftable_clusters = size_to_clusters(s, reftable_size *

- sizeof(uint64_t));

+ REFTABLE_ENTRY_SIZE);

reftable_offset = alloc_clusters_imrt(bs, reftable_clusters,

refcount_table, nb_clusters,

&first_free_cluster);

@@ -XXX,XX +XXX,XX @@ write_refblocks:

uint64_t post_refblock_start, reftable_clusters;

post_refblock_start = ROUND_UP(*nb_clusters, s->refcount_block_size);

- reftable_clusters = size_to_clusters(s,

- reftable_size * sizeof(uint64_t));

+ reftable_clusters =

+ size_to_clusters(s, reftable_size * REFTABLE_ENTRY_SIZE);

/* Not pretty but simple */

if (first_free_cluster < post_refblock_start) {

first_free_cluster = post_refblock_start;

@@ -XXX,XX +XXX,XX @@ write_refblocks:

}

ret = qcow2_pre_write_overlap_check(bs, 0, reftable_offset,

- reftable_size * sizeof(uint64_t),

+ reftable_size * REFTABLE_ENTRY_SIZE,

false);

if (ret < 0) {

fprintf(stderr, "ERROR writing reftable: %s\n", strerror(-ret));

goto fail;

}

- assert(reftable_size < INT_MAX / sizeof(uint64_t));

+ assert(reftable_size < INT_MAX / REFTABLE_ENTRY_SIZE);

ret = bdrv_pwrite(bs->file, reftable_offset, on_disk_reftable,

- reftable_size * sizeof(uint64_t));

+ reftable_size * REFTABLE_ENTRY_SIZE);

if (ret < 0) {

fprintf(stderr, "ERROR writing reftable: %s\n", strerror(-ret));

goto fail;

@@ -XXX,XX +XXX,XX @@ write_refblocks:

/* Enter new reftable into the image header */

reftable_offset_and_clusters.reftable_offset = cpu_to_be64(reftable_offset);

reftable_offset_and_clusters.reftable_clusters =

- cpu_to_be32(size_to_clusters(s, reftable_size * sizeof(uint64_t)));

+ cpu_to_be32(size_to_clusters(s, reftable_size * REFTABLE_ENTRY_SIZE));

ret = bdrv_pwrite_sync(bs->file,

offsetof(QCowHeader, refcount_table_offset),

&reftable_offset_and_clusters,

@@ -XXX,XX +XXX,XX @@ int qcow2_check_metadata_overlap(BlockDriverState *bs, int ign, int64_t offset,

offset = start_of_cluster(s, offset);

if ((chk & QCOW2_OL_ACTIVE_L1) && s->l1_size) {

- if (overlaps_with(s->l1_table_offset, s->l1_size * sizeof(uint64_t))) {

+ if (overlaps_with(s->l1_table_offset, s->l1_size * L1E_SIZE)) {

return QCOW2_OL_ACTIVE_L1;

}

}

if ((chk & QCOW2_OL_REFCOUNT_TABLE) && s->refcount_table_size) {

if (overlaps_with(s->refcount_table_offset,

- s->refcount_table_size * sizeof(uint64_t))) {

+ s->refcount_table_size * REFTABLE_ENTRY_SIZE)) {

return QCOW2_OL_REFCOUNT_TABLE;

}

}

@@ -XXX,XX +XXX,XX @@ int qcow2_check_metadata_overlap(BlockDriverState *bs, int ign, int64_t offset,

for (i = 0; i < s->nb_snapshots; i++) {

if (s->snapshots[i].l1_size &&

overlaps_with(s->snapshots[i].l1_table_offset,

- s->snapshots[i].l1_size * sizeof(uint64_t))) {

+ s->snapshots[i].l1_size * L1E_SIZE)) {

return QCOW2_OL_INACTIVE_L1;

}

}

@@ -XXX,XX +XXX,XX @@ int qcow2_check_metadata_overlap(BlockDriverState *bs, int ign, int64_t offset,

for (i = 0; i < s->nb_snapshots; i++) {

uint64_t l1_ofs = s->snapshots[i].l1_table_offset;

uint32_t l1_sz = s->snapshots[i].l1_size;

- uint64_t l1_sz2 = l1_sz * sizeof(uint64_t);

+ uint64_t l1_sz2 = l1_sz * L1E_SIZE;

uint64_t *l1;

int ret;

- ret = qcow2_validate_table(bs, l1_ofs, l1_sz, sizeof(uint64_t),

+ ret = qcow2_validate_table(bs, l1_ofs, l1_sz, L1E_SIZE,

QCOW_MAX_L1_SIZE, "", NULL);

if (ret < 0) {

return ret;

@@ -XXX,XX +XXX,XX @@ static int alloc_refblock(BlockDriverState *bs, uint64_t **reftable,

uint64_t new_reftable_size;

new_reftable_size = ROUND_UP(reftable_index + 1,

- s->cluster_size / sizeof(uint64_t));

- if (new_reftable_size > QCOW_MAX_REFTABLE_SIZE / sizeof(uint64_t)) {

+ s->cluster_size / REFTABLE_ENTRY_SIZE);

+ if (new_reftable_size > QCOW_MAX_REFTABLE_SIZE / REFTABLE_ENTRY_SIZE) {

error_setg(errp,

"This operation would make the refcount table grow "

"beyond the maximum size supported by QEMU, aborting");

@@ -XXX,XX +XXX,XX @@ static int alloc_refblock(BlockDriverState *bs, uint64_t **reftable,

}

new_reftable = g_try_realloc(*reftable, new_reftable_size *

- sizeof(uint64_t));

+ REFTABLE_ENTRY_SIZE);

if (!new_reftable) {

error_setg(errp, "Failed to increase reftable buffer size");

return -ENOMEM;

}

memset(new_reftable + *reftable_size, 0,

- (new_reftable_size - *reftable_size) * sizeof(uint64_t));

+ (new_reftable_size - *reftable_size) * REFTABLE_ENTRY_SIZE);

*reftable = new_reftable;

*reftable_size = new_reftable_size;

@@ -XXX,XX +XXX,XX @@ int qcow2_change_refcount_order(BlockDriverState *bs, int refcount_order,

if (new_allocation) {

if (new_reftable_offset) {

- qcow2_free_clusters(bs, new_reftable_offset,

- allocated_reftable_size * sizeof(uint64_t),

- QCOW2_DISCARD_NEVER);

+ qcow2_free_clusters(

+ bs, new_reftable_offset,

+ allocated_reftable_size * REFTABLE_ENTRY_SIZE,

+ QCOW2_DISCARD_NEVER);

}

new_reftable_offset = qcow2_alloc_clusters(bs, new_reftable_size *

- sizeof(uint64_t));

+ REFTABLE_ENTRY_SIZE);

if (new_reftable_offset < 0) {

error_setg_errno(errp, -new_reftable_offset,

"Failed to allocate the new reftable");

@@ -XXX,XX +XXX,XX @@ int qcow2_change_refcount_order(BlockDriverState *bs, int refcount_order,

/* Write the new reftable */

ret = qcow2_pre_write_overlap_check(bs, 0, new_reftable_offset,

- new_reftable_size * sizeof(uint64_t),

+ new_reftable_size * REFTABLE_ENTRY_SIZE,

false);

if (ret < 0) {

error_setg_errno(errp, -ret, "Overlap check failed");

@@ -XXX,XX +XXX,XX @@ int qcow2_change_refcount_order(BlockDriverState *bs, int refcount_order,

}

ret = bdrv_pwrite(bs->file, new_reftable_offset, new_reftable,

- new_reftable_size * sizeof(uint64_t));

+ new_reftable_size * REFTABLE_ENTRY_SIZE);

for (i = 0; i < new_reftable_size; i++) {

be64_to_cpus(&new_reftable[i]);

@@ -XXX,XX +XXX,XX @@ done:

if (new_reftable_offset > 0) {

qcow2_free_clusters(bs, new_reftable_offset,

- new_reftable_size * sizeof(uint64_t),

+ new_reftable_size * REFTABLE_ENTRY_SIZE,

QCOW2_DISCARD_OTHER);

}

}

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

BDRVQcow2State *s = bs->opaque;

uint64_t *reftable_tmp =

- g_malloc(s->refcount_table_size * sizeof(uint64_t));

+ g_malloc(s->refcount_table_size * REFTABLE_ENTRY_SIZE);

int i, ret;

for (i = 0; i < s->refcount_table_size; i++) {

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

}

ret = bdrv_pwrite_sync(bs->file, s->refcount_table_offset, reftable_tmp,

- s->refcount_table_size * sizeof(uint64_t));

+ s->refcount_table_size * REFTABLE_ENTRY_SIZE);

/*

* If the write in the reftable failed the image may contain a partially

* overwritten reftable. In this case it would be better to clear the

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

index XXXXXXX..XXXXXXX 100644

--- a/block/qcow2-snapshot.c

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

@@ -XXX,XX +XXX,XX @@ int qcow2_snapshot_create(BlockDriverState *bs, QEMUSnapshotInfo *sn_info)

sn->extra_data_size = sizeof(QCowSnapshotExtraData);

/* Allocate the L1 table of the snapshot and copy the current one there. */

- l1_table_offset = qcow2_alloc_clusters(bs, s->l1_size * sizeof(uint64_t));

+ l1_table_offset = qcow2_alloc_clusters(bs, s->l1_size * L1E_SIZE);

if (l1_table_offset < 0) {

ret = l1_table_offset;

goto fail;

@@ -XXX,XX +XXX,XX @@ int qcow2_snapshot_create(BlockDriverState *bs, QEMUSnapshotInfo *sn_info)

}

ret = qcow2_pre_write_overlap_check(bs, 0, sn->l1_table_offset,

- s->l1_size * sizeof(uint64_t), false);

+ s->l1_size * L1E_SIZE, false);

if (ret < 0) {

goto fail;

}

ret = bdrv_pwrite(bs->file, sn->l1_table_offset, l1_table,

- s->l1_size * sizeof(uint64_t));

+ s->l1_size * L1E_SIZE);

if (ret < 0) {

goto fail;

}

@@ -XXX,XX +XXX,XX @@ int qcow2_snapshot_goto(BlockDriverState *bs, const char *snapshot_id)

sn = &s->snapshots[snapshot_index];

ret = qcow2_validate_table(bs, sn->l1_table_offset, sn->l1_size,

- sizeof(uint64_t), QCOW_MAX_L1_SIZE,

+ L1E_SIZE, QCOW_MAX_L1_SIZE,

"Snapshot L1 table", &local_err);

if (ret < 0) {

error_report_err(local_err);

@@ -XXX,XX +XXX,XX @@ int qcow2_snapshot_goto(BlockDriverState *bs, const char *snapshot_id)

goto fail;

}

- cur_l1_bytes = s->l1_size * sizeof(uint64_t);

- sn_l1_bytes = sn->l1_size * sizeof(uint64_t);

+ cur_l1_bytes = s->l1_size * L1E_SIZE;

+ sn_l1_bytes = sn->l1_size * L1E_SIZE;

/*

* Copy the snapshot L1 table to the current L1 table.

@@ -XXX,XX +XXX,XX @@ int qcow2_snapshot_delete(BlockDriverState *bs,

sn = s->snapshots[snapshot_index];

ret = qcow2_validate_table(bs, sn.l1_table_offset, sn.l1_size,

- sizeof(uint64_t), QCOW_MAX_L1_SIZE,

+ L1E_SIZE, QCOW_MAX_L1_SIZE,

"Snapshot L1 table", errp);

if (ret < 0) {

return ret;

@@ -XXX,XX +XXX,XX @@ int qcow2_snapshot_delete(BlockDriverState *bs,

error_setg_errno(errp, -ret, "Failed to free the cluster and L1 table");

return ret;

}

- qcow2_free_clusters(bs, sn.l1_table_offset, sn.l1_size * sizeof(uint64_t),

+ qcow2_free_clusters(bs, sn.l1_table_offset, sn.l1_size * L1E_SIZE,