Skip to contentSkip to conversation

qcow2: Avoid integer wraparound in qcow2_co_truncate()

PATCH Superseded Alberto Garcia 2 participants 5 messages May 1, 2020 – May 4, 2020 Block layer

v1 of 3 Superseded Latest is v3 →

lore
Share & tools
lore
#0 lore raw

PATCH 1/1 qcow2: Avoid integer wraparound in qcow2_co_truncate()

After commit f01643fb8b47e8a70c04bbf45e0f12a9e5bc54de when an image is extended and BDRV_REQ_ZERO_WRITE is set then the new clusters are zeroized.

The code however does not detect correctly situations when the old and the new end of the image are within the same cluster. The problem can be reproduced with these steps:

   qemu-img create -f qcow2 backing.qcow2 1M
   qemu-img create -f qcow2 -b backing.qcow2 top.qcow2
   qemu-img resize --shrink top.qcow2 520k
   qemu-img resize top.qcow2 567k

In the last step offset - zero_start causes an integer wraparound.

---
 block/qcow2.c | 3 +++
 1 file changed, 3 insertions(+)
block/qcow2.c +3 -0
index 2ba0b17c39..6d34d28c60 100644
@@ -4234,6 +4234,9 @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
     if ((flags & BDRV_REQ_ZERO_WRITE) && offset > old_length) {
         uint64_t zero_start = QEMU_ALIGN_UP(old_length, s->cluster_size);
 
+        /* zero_start should not be after the new end of the image */
+        zero_start = MIN(zero_start, offset);
+
         /*
          * Use zero clusters as much as we can. qcow2_cluster_zeroize()
          * requires a cluster-aligned start. The end may be unaligned if it is
Signature · 1 line
2.20.1
#1 lore raw
Quoted 10 lines · Alberto Garcia

After commit f01643fb8b47e8a70c04bbf45e0f12a9e5bc54de when an image is extended and BDRV_REQ_ZERO_WRITE is set then the new clusters are zeroized.

The code however does not detect correctly situations when the old and the new end of the image are within the same cluster. The problem can be reproduced with these steps:

qemu-img create -f qcow2 backing.qcow2 1M qemu-img create -f qcow2 -b backing.qcow2 top.qcow2

We should get in the habit of documenting -F qcow2 (I have a series, still awaiting review, that would warn if you don't).

Quoted 15 lines

qemu-img resize --shrink top.qcow2 520k
qemu-img resize top.qcow2 567k

In the last step offset - zero_start causes an integer wraparound.

---
  block/qcow2.c | 3 +++
  1 file changed, 3 insertions(+)
block/qcow2.c +0 -0
index 2ba0b17c39..6d34d28c60 100644

block/qcow2.c static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset, · line 4239

Quoted 6 lines
block/qcow2.c +3 -0
@@ -4234,6 +4234,9 @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
      if ((flags & BDRV_REQ_ZERO_WRITE) && offset > old_length) {
          uint64_t zero_start = QEMU_ALIGN_UP(old_length, s->cluster_size);
 
+        /* zero_start should not be after the new end of the image */
+        zero_start = MIN(zero_start, offset);
+

So, using your numbers, pre-patch, we have zero_start = 0x90000 (0x82000 rounded up to 0x10000 alignment). post-patch, the new MIN() lowers it back to 0x8dc00 (the new size), which is unaligned.

block/qcow2.c static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset, · line 4242

Quoted 3 lines
block/qcow2.c +0 -0
          /*
           * Use zero clusters as much as we can. qcow2_cluster_zeroize()
           * requires a cluster-aligned start. The end may be unaligned if it is

* at the end of the image (which it is here). */
ret = qcow2_cluster_zeroize(bs, zero_start, offset -
zero_start, 0);

pre-patch, it called zeroize(, 0x90000, 0xffffffffffffdc00, ) post-patch, it calls zeroize(, 0x8dc00, 0, )

Looking at qcow2_cluster_zeroize, we have:

    assert(QEMU_IS_ALIGNED(offset, s->cluster_size));

which will now trigger. This patch is a good idea, but needs a v2.

Signature · 3 lines
Eric Blake, Principal Software Engineer
Red Hat, Inc.           +1-919-301-3226
Virtualization:  qemu.org | libvirt.org
#2 lore raw
Quoted 5 lines · Eric Blake
Quoted 4 lines · Alberto Garcia

After commit f01643fb8b47e8a70c04bbf45e0f12a9e5bc54de when an image is extended and BDRV_REQ_ZERO_WRITE is set then the new clusters are zeroized.

Quoted 12 lines
Quoted 6 lines

The code however does not detect correctly situations when the old and the new end of the image are within the same cluster. The problem can be reproduced with these steps:

    qemu-img create -f qcow2 backing.qcow2 1M qemu-img create -f qcow2 -b backing.qcow2 top.qcow2

We should get in the habit of documenting -F qcow2 (I have a series, still awaiting review, that would warn if you don't).

Quoted 3 lines

    qemu-img resize --shrink top.qcow2 520k
    qemu-img resize top.qcow2 567k

Since your reproducer triggers assertion failure, I suggest doing this instead:

Quoted 8 lines

block/qcow2.c static int coroutine_fn · line 4239

Quoted 8 lines

+++ b/block/qcow2.c

block/qcow2.c +3 -0
@@ -4234,6 +4234,9 @@ static int coroutine_fn 
 qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
       if ((flags & BDRV_REQ_ZERO_WRITE) && offset > old_length) {
           uint64_t zero_start = QEMU_ALIGN_UP(old_length, s->cluster_size);
+        /* zero_start should not be after the new end of the image */
+        zero_start = MIN(zero_start, offset);
+

Drop this hunk (leave zero_start unchanged), and instead...

Quoted 10 lines

So, using your numbers, pre-patch, we have zero_start = 0x90000 (0x82000 rounded up to 0x10000 alignment).  post-patch, the new MIN() lowers it back to 0x8dc00 (the new size), which is unaligned.

block/qcow2.c static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset, · line 4242

Quoted 3 lines
block/qcow2.c +0 -0
           /*
            * Use zero clusters as much as we can. qcow2_cluster_zeroize()
            * requires a cluster-aligned start. The end may be unaligned if it is

         * at the end of the image (which it is here). */
        ret = qcow2_cluster_zeroize(bs, zero_start, offset -
zero_start, 0);

...patch _this_ call to compute 'QEMU_ALIGN_UP(offset, s->cluster_size) - zero_start' for the length.

Signature · 3 lines
Eric Blake, Principal Software Engineer
Red Hat, Inc.           +1-919-301-3226
Virtualization:  qemu.org | libvirt.org
#3 lore raw
Quoted 24 lines · Eric Blake

Since your reproducer triggers assertion failure, I suggest doing this instead:

Quoted 9 lines

block/qcow2.c static int coroutine_fn · line 4240

Quoted 9 lines

+++ b/block/qcow2.c

block/qcow2.c +3 -0
@@ -4234,6 +4234,9 @@ static int coroutine_fn 
 qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
       if ((flags & BDRV_REQ_ZERO_WRITE) && offset > old_length) {
           uint64_t zero_start = QEMU_ALIGN_UP(old_length, 
 s->cluster_size);
+        /* zero_start should not be after the new end of the image */
+        zero_start = MIN(zero_start, offset);
+

Drop this hunk (leave zero_start unchanged), and instead...

Quoted 9 lines

So, using your numbers, pre-patch, we have zero_start = 0x90000 (0x82000 rounded up to 0x10000 alignment).  post-patch, the new MIN() lowers it back to 0x8dc00 (the new size), which is unaligned.

Quoted 4 lines
block/qcow2.c +0 -0
           /*
            * Use zero clusters as much as we can. qcow2_cluster_zeroize()

           * requires a cluster-aligned start. The end may be unaligned if it is

Quoted 7 lines
Quoted 4 lines

         * at the end of the image (which it is here). */
        ret = qcow2_cluster_zeroize(bs, zero_start, offset -
zero_start, 0);

...patch _this_ call to compute 'QEMU_ALIGN_UP(offset, s->cluster_size)
- zero_start' for the length.

That would work, but then we would be writing zeroes beyond the end of the image (but still within the last cluster).

The other solution is to keep my hunk and call qcow2_cluster_zeroize() only when offset > zero_start.

Berto

#4 lore raw
Quoted 16 lines · Alberto Garcia
Quoted 16 lines

Drop this hunk (leave zero_start unchanged), and instead...

Quoted 13 lines

So, using your numbers, pre-patch, we have zero_start = 0x90000 (0x82000 rounded up to 0x10000 alignment).  post-patch, the new MIN() lowers it back to 0x8dc00 (the new size), which is unaligned.

Quoted 4 lines

          /*
           * Use zero clusters as much as we can. qcow2_cluster_zeroize()
           * requires a cluster-aligned start. The end may be
unaligned if it is

         * at the end of the image (which it is here). */
        ret = qcow2_cluster_zeroize(bs, zero_start, offset -
zero_start, 0);

Quoted 8 lines
Quoted 2 lines

...patch _this_ call to compute 'QEMU_ALIGN_UP(offset, s->cluster_size)
- zero_start' for the length.

That would work, but then we would be writing zeroes beyond the end of the image (but still within the last cluster).

The other solution is to keep my hunk and call qcow2_cluster_zeroize() only when offset > zero_start.

Yes, that would work, and probably less complicated.

Signature · 3 lines
Eric Blake, Principal Software Engineer
Red Hat, Inc.           +1-919-301-3226
Virtualization:  qemu.org | libvirt.org