qcow2: Assert that host cluster offsets fit in L2 table entries
PATCH 1/1 qcow2: Assert that host cluster offsets fit in L2 table entries
The standard cluster descriptor in L2 table entries has a field to store the host cluster offset. When we need to get that offset from an entry we use L2E_OFFSET_MASK to ensure that we only use the bits that belong to that field.
But while that mask is used every time we read from an L2 entry, it is never used when we write to it. Due to the QCOW_MAX_CLUSTER_OFFSET limit set in the cluster allocation code QEMU can never produce offsets that don't fit in that field so any such offset would indicate a bug in QEMU.
Compressed cluster descriptors contain two fields (host cluster offset and size of the compressed data) and the situation with them is similar. In this case the masks are not constant but are stored in the csize_mask and cluster_offset_mask fields of BDRVQcow2State.
--- block/qcow2-cluster.c | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-)
block/qcow2-cluster.c +12 -2
@@ -799,6 +799,10 @@ int qcow2_alloc_compressed_cluster_offset(BlockDriverState *bs, nb_csectors = ((cluster_offset + compressed_size -1 ) >>9 ) - (cluster_offset >>9 ); +/* The offset and size must fit in their fields of the L2 table entry */ +assert ((cluster_offset & s->cluster_offset_mask) == cluster_offset); +assert ((nb_csectors & s->csize_mask) == nb_csectors); + cluster_offset |=QCOW_OFLAG_COMPRESSED | ((uint64_t )nb_csectors << s->csize_shift);
@@ -984,6 +988,7 @@ int qcow2_alloc_cluster_link_l2(BlockDriverState *bs, QCowL2Meta *m)assert (l2_index + m->nb_clusters <= s->l2_slice_size);for (i =0 ; i < m->nb_clusters; i++) { +uint64_t offset = cluster_offset + (i << s->cluster_bits);/* if two concurrent writes happen to the same unallocated cluster * each write allocates separate cluster and writes data concurrently. * The first one to complete updates l2 table with pointer to its
@@ -994,8 +999,10 @@ int qcow2_alloc_cluster_link_l2(BlockDriverState *bs, QCowL2Meta *m) old_cluster[j++] = l2_slice[l2_index + i]; } - l2_slice[l2_index + i] =cpu_to_be64 ((cluster_offset + - (i << s->cluster_bits)) |QCOW_OFLAG_COPIED ); +/* The offset must fit in the offset field of the L2 table entry */ +assert ((offset &L2E_OFFSET_MASK ) == offset); + + l2_slice[l2_index + i] =cpu_to_be64 (offset |QCOW_OFLAG_COPIED ); }
@@ -1928,6 +1935,9 @@ static int expand_zero_clusters_in_l1(BlockDriverState *bs, uint64_t *l1_table, goto fail; } +/* The offset must fit in the offset field */ +assert ((offset &L2E_OFFSET_MASK ) == offset); +if (l2_refcount >1 ) {/* For shared L2 tables, set the refcount accordingly * (it is already 1 and needs to be l2_refcount) */
Signature · 1 line
2.11.0
Quoted 10 lines · Alberto Garcia
The standard cluster descriptor in L2 table entries has a field to store the host cluster offset. When we need to get that offset from an entry we use
L2E_OFFSET_MASKto ensure that we only use the bits that belong to that field.But while that mask is used every time we read from an L2 entry, it is never used when we write to it. Due to the
QCOW_MAX_CLUSTER_OFFSETlimit set in the cluster allocation code QEMU can never produce offsets that don't fit in that field so any such offset would indicate a bug in QEMU.
Yeah, I'm not seeing where this one could ever overflow.
Quoted 5 lines
Compressed cluster descriptors contain two fields (host cluster offset and size of the compressed data) and the situation with them is similar. In this case the masks are not constant but are stored in the
csize_maskandcluster_offset_maskfields of BDRVQcow2State.
For this one, we did have a bug in the past where we were overflowing, as evidenced by iotest 220 shortly after we patched the bug (77d6a215).
Quoted 6 lines
Signed-off-by Alberto Garcia <[email protected]>--- block/qcow2-cluster.c | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-)
Adding more assertions shouldn't hurt.
Signature · 3 lines
Eric Blake, Principal Software Engineer Red Hat, Inc. +1-919-301-3226 Virtualization: qemu.org | libvirt.org