Skip to contentSkip to conversation

qcow2: Don't open images with a backing file and the data-file-raw bit

PATCH In review Alberto Garcia 4 participants 11 messages Apr 15, 2020 – Jun 19, 2020 Block layer

lore
Share & tools
lore
#0 lore raw

PATCH 1/1 qcow2: Don't open images with a backing file and the data-file-raw bit

Although we cannot create these images with qemu-img it is still possible to do it using an external tool. QEMU should refuse to open them until the data-file-raw bit is cleared with 'qemu-img check'.

---
 block/qcow2.c              | 39 ++++++++++++++++++++++++++++++++++++++
 tests/qemu-iotests/244     | 13 +++++++++++++
 tests/qemu-iotests/244.out | 14 ++++++++++++++
 3 files changed, 66 insertions(+)
block/qcow2.c +39 -0
index b524b0c53f..fcc3810391 100644
@@ -588,16 +588,49 @@ static void qcow2_add_check_result(BdrvCheckResult *out,
     }
 }
 
+static int qcow2_check_header(BlockDriverState *bs, BdrvCheckResult *result,
+                              BdrvCheckMode fix)
+{
+    BDRVQcow2State *s = bs->opaque;
+    int ret;
+
+    if (bs->backing && data_file_is_raw(bs)) {
+        fprintf(stderr, "%s header: data-file-raw cannot be set "
+                "when there is a backing file.\n",
+                fix & BDRV_FIX_ERRORS ? "Repairing" : "ERROR in");
+        if (fix & BDRV_FIX_ERRORS) {
+            s->autoclear_features &= ~QCOW2_AUTOCLEAR_DATA_FILE_RAW;
+            ret = qcow2_update_header(bs);
+            if (ret < 0) {
+                result->check_errors++;
+                return ret;
+            }
+            result->corruptions_fixed++;
+        } else {
+            result->corruptions++;
+        }
+    }
+
+    return 0;
+}
+
 static int coroutine_fn qcow2_co_check_locked(BlockDriverState *bs,
                                               BdrvCheckResult *result,
                                               BdrvCheckMode fix)
 {
+    BdrvCheckResult header_res = {};
     BdrvCheckResult snapshot_res = {};
     BdrvCheckResult refcount_res = {};
     int ret;
 
     memset(result, 0, sizeof(*result));
 
+    ret = qcow2_check_header(bs, &header_res, fix);
+    qcow2_add_check_result(result, &header_res, false);
+    if (ret < 0) {
+        return ret;
+    }
+
     ret = qcow2_check_read_snapshot_table(bs, &snapshot_res, fix);
     if (ret < 0) {
         qcow2_add_check_result(result, &snapshot_res, false);
@@ -1604,6 +1637,12 @@ static int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options,
 
     /* read the backing file name */
     if (header.backing_file_offset != 0) {
+        if (data_file_is_raw(bs) && (!(flags & BDRV_O_CHECK))) {
+            error_setg(errp, "data-file-raw cannot be set when "
+                       "there is a backing file");
+            ret = -EINVAL;
+            goto fail;
+        }
         len = header.backing_file_size;
         if (len > MIN(1023, s->cluster_size - header.backing_file_offset) ||
             len >= sizeof(bs->backing_file)) {
tests/qemu-iotests/244 +13 -0
index 2ec1815e6f..159941acd4 100755
@@ -211,6 +211,19 @@ $QEMU_IMG amend -f $IMGFMT -o "data_file=blkdebug::$TEST_IMG.data" "$TEST_IMG"
 $QEMU_IMG convert -f $IMGFMT -O $IMGFMT -n -C "$TEST_IMG.src" "$TEST_IMG"
 $QEMU_IMG compare -f $IMGFMT -F $IMGFMT "$TEST_IMG.src" "$TEST_IMG"
 
+echo
+echo "=== Using and repairing an image with backing file and the data_file_raw bit ==="
+echo
+
+# Create an image with a backing file and an external data file
+TEST_IMG_FILE="$TEST_IMG.base" _make_test_img 1M
+_make_test_img -o "data_file=$TEST_IMG.data" -b "$TEST_IMG.base"
+# Set 'data_file_raw' directly on the header (qemu-img amend won't let us)
+poke_file "$TEST_IMG" 95 "\x02"
+# Trying to open the image should produce an error
+$QEMU_IMG info "$TEST_IMG" 2>&1 | _filter_testdir
+_check_test_img -r all
+
 # success, all done
 echo "*** done"
 rm -f $seq.full
tests/qemu-iotests/244.out +14 -0
index 56329deb4b..cab367dfb5 100644
@@ -128,4 +128,18 @@ Offset          Length          Mapped to       File
 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 data_file=TEST_DIR/t.IMGFMT.data
 Images are identical.
 Images are identical.
+
+=== Using and repairing an image with backing file and the data_file_raw bit ===
+
+Formatting 'TEST_DIR/t.IMGFMT.base', fmt=IMGFMT size=1048576
+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576 backing_file=TEST_DIR/t.IMGFMT.base data_file=TEST_DIR/t.IMGFMT.data
+qemu-img: Could not open 'TEST_DIR/t.qcow2': data-file-raw cannot be set when there is a backing file
+Repairing header: data-file-raw cannot be set when there is a backing file.
+The following inconsistencies were found and repaired:
+
+    0 leaked clusters
+    1 corruptions
+
+Double checking the fixed image now...
+No errors were found on the image.
 *** done
Signature · 1 line
2.20.1
Reviewed-by on v1 1/1
#1 lore raw
Quoted 11 lines · Alberto Garcia

Although we cannot create these images with qemu-img it is still possible to do it using an external tool. QEMU should refuse to open them until the data-file-raw bit is cleared with 'qemu-img check'.

---
  block/qcow2.c              | 39 ++++++++++++++++++++++++++++++++++++++
  tests/qemu-iotests/244     | 13 +++++++++++++
  tests/qemu-iotests/244.out | 14 ++++++++++++++
  3 files changed, 66 insertions(+)
Signature · 3 lines
Eric Blake, Principal Software Engineer
Red Hat, Inc.           +1-919-301-3226
Virtualization:  qemu.org | libvirt.org
#3 lore raw
In reply to Alberto Garcia
Quoted 10 lines · Alberto Garcia

Although we cannot create these images with qemu-img it is still possible to do it using an external tool. QEMU should refuse to open them until the data-file-raw bit is cleared with 'qemu-img check'.

---
 block/qcow2.c              | 39 ++++++++++++++++++++++++++++++++++++++
 tests/qemu-iotests/244     | 13 +++++++++++++
 tests/qemu-iotests/244.out | 14 ++++++++++++++
 3 files changed, 66 insertions(+)

Sorry for the long delay. :/

The patch itself looks good, but I’m not sure whether it is extensive enough. Let me just jump straight to the problem:

$ ./qemu-img create -f qcow2 \
    -o data_file=foo.qcow2.raw,data_file_raw=on \
    foo.qcow2 64M
(Create some file empty foo.qcow2 with external data file that’s raw)
$ ./qemu-img create -f qcow2 backing.qcow2 64M
$ ./qemu-io -c 'write -P 42 0 64M' backing.qcow2
(Create some file filled with 42s)
$ ./qemu-img compare foo.qcow2 foo.qcow2.raw
Images are identical.
(As expected, foo.qcow2 is identical to its raw data file)
$ ./qemu-img compare --image-opts \
    file.filename=foo.qcow2,backing.file.filename=backing.qcow2 \
    file.filename=foo.qcow2.raw
Content mismatch at offset 0!
(Oops.)

So when the user manually gives a backing file without one having been given by the image file, we run into the same problem. Now I’m not quite sure what the problem is here. We could make this patch more extensive and also forbid this case.

But I think there actually shouldn’t be a problem. The qcow2 driver shouldn’t fall back to a backing file for raw external data files. But how exactly should that be implemented? I think the correct way would be to preallocate all metadata whenever data_file_raw=on – the qcow2 spec doesn’t say to ignore the metadata with data_file_raw=on, it just says that the data read from the qcow2 file must match that read from the external data file.
(I seem to remember I proposed this before, but I don’t know exactly...)

(In contrast, I don’t think it would be correct to just treat unallocated clusters as zero whenever data_file_raw=on.)

What do you think? Should we force preallocation with data_file_raw=on, and then just take this patch, even though it still lets users give backing files to a qcow2 file at runtime without error? (Except the backing file wouldn’t have an effect, then.)

#4 lore raw

Am 03.06.2020 um 15:53 hat Max Reitz geschrieben:

Quoted 36 lines · Alberto Garcia
Quoted 10 lines

Although we cannot create these images with qemu-img it is still possible to do it using an external tool. QEMU should refuse to open them until the data-file-raw bit is cleared with 'qemu-img check'.

---
 block/qcow2.c              | 39 ++++++++++++++++++++++++++++++++++++++
 tests/qemu-iotests/244     | 13 +++++++++++++
 tests/qemu-iotests/244.out | 14 ++++++++++++++
 3 files changed, 66 insertions(+)

Sorry for the long delay. :/

The patch itself looks good, but I’m not sure whether it is extensive enough. Let me just jump straight to the problem:

$ ./qemu-img create -f qcow2 \
    -o data_file=foo.qcow2.raw,data_file_raw=on \
    foo.qcow2 64M
(Create some file empty foo.qcow2 with external data file that’s raw)
$ ./qemu-img create -f qcow2 backing.qcow2 64M
$ ./qemu-io -c 'write -P 42 0 64M' backing.qcow2
(Create some file filled with 42s)
$ ./qemu-img compare foo.qcow2 foo.qcow2.raw
Images are identical.
(As expected, foo.qcow2 is identical to its raw data file)
$ ./qemu-img compare --image-opts \
    file.filename=foo.qcow2,backing.file.filename=backing.qcow2 \
    file.filename=foo.qcow2.raw
Content mismatch at offset 0!
(Oops.)
Quoted 4 lines

So when the user manually gives a backing file without one having been given by the image file, we run into the same problem. Now I’m not quite sure what the problem is here. We could make this patch more extensive and also forbid this case.

I guess what we should really be checking is that bs->backing is NULL after the node is fully opened. The challenging part is that the backing child isn't managed by the block driver, but by the generic block layer, and .brv_open() comes first. So we don't really have a place to check this. (And there is also the case that the image is originally opened with BDRV_O_NO_BACKING and the later bdrv_open_backing_file().)

Quoted 8 lines

But I think there actually shouldn’t be a problem. The qcow2 driver shouldn’t fall back to a backing file for raw external data files. But how exactly should that be implemented? I think the correct way would be to preallocate all metadata whenever data_file_raw=on – the qcow2 spec doesn’t say to ignore the metadata with data_file_raw=on, it just says that the data read from the qcow2 file must match that read from the external data file.
(I seem to remember I proposed this before, but I don’t know exactly...)

I don't find preallocation convincing, mostly for two reasons.

First is, old images or images created by another program could miss the preallocation, but we still shouldn't access the backing file.

The other one is that discard breaks preallocation, so we would also have to make sure to have a special case in every operation that could end up discarding clusters (and to add it to every future operation we might add).

It just sounds very brittle.

Quoted 7 lines

(In contrast, I don’t think it would be correct to just treat unallocated clusters as zero whenever data_file_raw=on.)

What do you think? Should we force preallocation with data_file_raw=on, and then just take this patch, even though it still lets users give backing files to a qcow2 file at runtime without error? (Except the backing file wouldn’t have an effect, then.)

Honestly, maybe passing a backing file at runtime to an image that doesn't logically have one is just a case of "then don't do that".

Kevin

#5 lore raw
Quoted 58 lines · Kevin Wolf

Am 03.06.2020 um 15:53 hat Max Reitz geschrieben:

Quoted 36 lines · Alberto Garcia
Quoted 10 lines

Although we cannot create these images with qemu-img it is still possible to do it using an external tool. QEMU should refuse to open them until the data-file-raw bit is cleared with 'qemu-img check'.

---
 block/qcow2.c              | 39 ++++++++++++++++++++++++++++++++++++++
 tests/qemu-iotests/244     | 13 +++++++++++++
 tests/qemu-iotests/244.out | 14 ++++++++++++++
 3 files changed, 66 insertions(+)

Sorry for the long delay. :/

The patch itself looks good, but I’m not sure whether it is extensive enough. Let me just jump straight to the problem:

$ ./qemu-img create -f qcow2 \
    -o data_file=foo.qcow2.raw,data_file_raw=on \
    foo.qcow2 64M
(Create some file empty foo.qcow2 with external data file that’s raw)
$ ./qemu-img create -f qcow2 backing.qcow2 64M
$ ./qemu-io -c 'write -P 42 0 64M' backing.qcow2
(Create some file filled with 42s)
$ ./qemu-img compare foo.qcow2 foo.qcow2.raw
Images are identical.
(As expected, foo.qcow2 is identical to its raw data file)
$ ./qemu-img compare --image-opts \
    file.filename=foo.qcow2,backing.file.filename=backing.qcow2 \
    file.filename=foo.qcow2.raw
Content mismatch at offset 0!
(Oops.)
Quoted 4 lines

So when the user manually gives a backing file without one having been given by the image file, we run into the same problem. Now I’m not quite sure what the problem is here. We could make this patch more extensive and also forbid this case.

I guess what we should really be checking is that bs->backing is NULL after the node is fully opened. The challenging part is that the backing child isn't managed by the block driver, but by the generic block layer, and .brv_open() comes first. So we don't really have a place to check this. (And there is also the case that the image is originally opened with BDRV_O_NO_BACKING and the later bdrv_open_backing_file().)

Quoted 8 lines

But I think there actually shouldn’t be a problem. The qcow2 driver shouldn’t fall back to a backing file for raw external data files. But how exactly should that be implemented? I think the correct way would be to preallocate all metadata whenever data_file_raw=on – the qcow2 spec doesn’t say to ignore the metadata with data_file_raw=on, it just says that the data read from the qcow2 file must match that read from the external data file.
(I seem to remember I proposed this before, but I don’t know exactly...)

Quoted 4 lines

I don't find preallocation convincing, mostly for two reasons.

First is, old images or images created by another program could miss the preallocation, but we still shouldn't access the backing file.

I’d take this patch anyway (because its motivation is just that other programs might produce invalid images), and then not worry about the case where we get an image produced by such another program (including older versions of qemu) for which the user overrides the backing file at runtime.

Quoted 1 line

The other one is that discard breaks preallocation,

The preallocation is about ensuring that there are no fall-through-to-backing holes in the image. Discarding doesn’t change that.

Quoted 10 lines

so we would also
have to make sure to have a special case in every operation that could end up discarding clusters (and to add it to every future operation we might add).

It just sounds very brittle.

Quoted 3 lines

(In contrast, I don’t think it would be correct to just treat unallocated clusters as zero whenever data_file_raw=on.)

Quoted 7 lines
Quoted 4 lines

What do you think? Should we force preallocation with data_file_raw=on, and then just take this patch, even though it still lets users give backing files to a qcow2 file at runtime without error? (Except the backing file wouldn’t have an effect, then.)

Honestly, maybe passing a backing file at runtime to an image that doesn't logically have one is just a case of "then don't do that".

Perhaps.

But seeing I wondered whether I didn’t already propose this at some point, there is another reason for preallocation:

https://lists.nongnu.org/archive/html/qemu-block/2020-02/msg00644.html
https://lists.nongnu.org/archive/html/qemu-block/2020-04/msg00329.html

All in all, I think data_file_raw should be interpretable as “You don’t have to look at any metadata to know which data to read or write”. (Maybe I’m wrong about that.)
Without any preallocation of metadata structure, it looks to me like we break that promise.

(Yes, we could also force-zero the external data file during creation, and blame users who put a backing file on images that don’t have one – both of which are not unreasonable! But we could also just preallocate the metadata.)

Max

#6 lore raw

Am 05.06.2020 um 14:11 hat Max Reitz geschrieben:

Quoted 107 lines · Kevin Wolf
Quoted 58 lines

Am 03.06.2020 um 15:53 hat Max Reitz geschrieben:

Quoted 36 lines · Alberto Garcia
Quoted 10 lines

Although we cannot create these images with qemu-img it is still possible to do it using an external tool. QEMU should refuse to open them until the data-file-raw bit is cleared with 'qemu-img check'.

---
 block/qcow2.c              | 39 ++++++++++++++++++++++++++++++++++++++
 tests/qemu-iotests/244     | 13 +++++++++++++
 tests/qemu-iotests/244.out | 14 ++++++++++++++
 3 files changed, 66 insertions(+)

Sorry for the long delay. :/

The patch itself looks good, but I’m not sure whether it is extensive enough. Let me just jump straight to the problem:

$ ./qemu-img create -f qcow2 \
    -o data_file=foo.qcow2.raw,data_file_raw=on \
    foo.qcow2 64M
(Create some file empty foo.qcow2 with external data file that’s raw)
$ ./qemu-img create -f qcow2 backing.qcow2 64M
$ ./qemu-io -c 'write -P 42 0 64M' backing.qcow2
(Create some file filled with 42s)
$ ./qemu-img compare foo.qcow2 foo.qcow2.raw
Images are identical.
(As expected, foo.qcow2 is identical to its raw data file)
$ ./qemu-img compare --image-opts \
    file.filename=foo.qcow2,backing.file.filename=backing.qcow2 \
    file.filename=foo.qcow2.raw
Content mismatch at offset 0!
(Oops.)
Quoted 4 lines

So when the user manually gives a backing file without one having been given by the image file, we run into the same problem. Now I’m not quite sure what the problem is here. We could make this patch more extensive and also forbid this case.

I guess what we should really be checking is that bs->backing is NULL after the node is fully opened. The challenging part is that the backing child isn't managed by the block driver, but by the generic block layer, and .brv_open() comes first. So we don't really have a place to check this. (And there is also the case that the image is originally opened with BDRV_O_NO_BACKING and the later bdrv_open_backing_file().)

Quoted 8 lines

But I think there actually shouldn’t be a problem. The qcow2 driver shouldn’t fall back to a backing file for raw external data files. But how exactly should that be implemented? I think the correct way would be to preallocate all metadata whenever data_file_raw=on – the qcow2 spec doesn’t say to ignore the metadata with data_file_raw=on, it just says that the data read from the qcow2 file must match that read from the external data file.
(I seem to remember I proposed this before, but I don’t know exactly...)

Quoted 4 lines

I don't find preallocation convincing, mostly for two reasons.

First is, old images or images created by another program could miss the preallocation, but we still shouldn't access the backing file.

I’d take this patch anyway (because its motivation is just that other programs might produce invalid images), and then not worry about the case where we get an image produced by such another program (including older versions of qemu) for which the user overrides the backing file at runtime.

Quoted 1 line

The other one is that discard breaks preallocation,

The preallocation is about ensuring that there are no fall-through-to-backing holes in the image. Discarding doesn’t change that.

Quoted 10 lines

so we would also
have to make sure to have a special case in every operation that could end up discarding clusters (and to add it to every future operation we might add).

It just sounds very brittle.

Quoted 3 lines

(In contrast, I don’t think it would be correct to just treat unallocated clusters as zero whenever data_file_raw=on.)

Quoted 7 lines
Quoted 4 lines

What do you think? Should we force preallocation with data_file_raw=on, and then just take this patch, even though it still lets users give backing files to a qcow2 file at runtime without error? (Except the backing file wouldn’t have an effect, then.)

Honestly, maybe passing a backing file at runtime to an image that doesn't logically have one is just a case of "then don't do that".

Perhaps.

But seeing I wondered whether I didn’t already propose this at some point, there is another reason for preallocation:

https://lists.nongnu.org/archive/html/qemu-block/2020-02/msg00644.html
https://lists.nongnu.org/archive/html/qemu-block/2020-04/msg00329.html

All in all, I think data_file_raw should be interpretable as “You don’t have to look at any metadata to know which data to read or write”. (Maybe I’m wrong about that.)
Without any preallocation of metadata structure, it looks to me like we break that promise.

Quoted 4 lines

(Yes, we could also force-zero the external data file during creation, and blame users who put a backing file on images that don’t have one – both of which are not unreasonable! But we could also just preallocate the metadata.)

Makes sense. I'm not against preallocation during image creation. I just think it shouldn't play a role in deciding whether an image is valid or not.

Kevin

#7 lore raw

On 05.06.20 15:00, Kevin Wolf wrote:

[...]

Quoted 3 lines

Makes sense. I'm not against preallocation during image creation. I just think it shouldn't play a role in deciding whether an image is valid or not.

Oh, no. I wouldn’t consider it corrupted just because some clusters are not allocated. I’d just say any program that handles qcow2 files is responsible to ensure that images with the data-file-raw flag actually fulfill the flag’s promise. So if a cluster isn’t allocated in qcow2, it must read as zeroes in the data file (because the spec disallows backing files with data-file-raw anyway[1]).

It’s just my impression that qemu currently doesn’t always ensure this, and the easiest way to do so would be to enforce metadata preallocation for such images.

Max

[1] Such images are indeed corrupt, hence this patch here from Berto.

#8 lore raw
In reply to Max Reitz
Quoted 1 line · Max Reitz

Sorry for the long delay. :/

And sorry for my long delay as well.

Quoted 16 lines

The patch itself looks good, but I’m not sure whether it is extensive enough. Let me just jump straight to the problem:

$ ./qemu-img create -f qcow2 \
    -o data_file=foo.qcow2.raw,data_file_raw=on \
    foo.qcow2 64M
(Create some file empty foo.qcow2 with external data file that’s raw)
$ ./qemu-img create -f qcow2 backing.qcow2 64M
$ ./qemu-io -c 'write -P 42 0 64M' backing.qcow2
(Create some file filled with 42s)
$ ./qemu-img compare foo.qcow2 foo.qcow2.raw
Images are identical.
(As expected, foo.qcow2 is identical to its raw data file)
Quoted 5 lines
$ ./qemu-img compare --image-opts \
    file.filename=foo.qcow2,backing.file.filename=backing.qcow2 \
    file.filename=foo.qcow2.raw
Content mismatch at offset 0!
(Oops.)

If two images have the same contents but then you compare them changing the backing file of one of them you can also get a content mismatch. How is this different?

Regardless of how we should ideally handle bs->backing and data-file-raw (and yes I agree that it would be nice that QEMU would say "you cannot have a backing file and an external raw file" in all cases) I think that if the problem is that the user can override the backing file name and get different contents, then that's not a problem that we should be worried about.

Berto

#9 lore raw
Quoted 27 lines · Alberto Garcia
Quoted 1 line · Max Reitz

Sorry for the long delay. :/

And sorry for my long delay as well.

Quoted 16 lines

The patch itself looks good, but I’m not sure whether it is extensive enough. Let me just jump straight to the problem:

$ ./qemu-img create -f qcow2 \
    -o data_file=foo.qcow2.raw,data_file_raw=on \
    foo.qcow2 64M
(Create some file empty foo.qcow2 with external data file that’s raw)
$ ./qemu-img create -f qcow2 backing.qcow2 64M
$ ./qemu-io -c 'write -P 42 0 64M' backing.qcow2
(Create some file filled with 42s)
$ ./qemu-img compare foo.qcow2 foo.qcow2.raw
Images are identical.
(As expected, foo.qcow2 is identical to its raw data file)
Quoted 5 lines
$ ./qemu-img compare --image-opts \
    file.filename=foo.qcow2,backing.file.filename=backing.qcow2 \
    file.filename=foo.qcow2.raw
Content mismatch at offset 0!
(Oops.)
Quoted 3 lines

If two images have the same contents but then you compare them changing the backing file of one of them you can also get a content mismatch. How is this different?

It’s different in that files with data-file-raw can’t have backing files at all. So maybe users shouldn’t be allowed to give them backing files at runtime either.

Or at least, if we have data-file-raw, *all* data visible on such an image should be taken from the raw data file, never from any backing file.

Quoted 6 lines

Regardless of how we should ideally handle bs->backing and data-file-raw (and yes I agree that it would be nice that QEMU would say "you cannot have a backing file and an external raw file" in all cases) I think that if the problem is that the user can override the backing file name and get different contents, then that's not a problem that we should be worried about.

Well, not really be worried about, but I do think it’s indicative of some problem, though I’m not sure whether the problem is error reporting. I think it’s rather the fact that data-file-raw should imply metadata preallocation.

With preallocation, we’d ensure that we always take all data from the raw data file. So we’d always ignore any potential backing file.

(It makes sense to guard users against giving images with data-file-raw a backing file, and to consider such images corrupt, as done by this patch. But if users can force a backing file at runtime, I think showing its contents is another bug.)

Max

#10 lore raw
Quoted 7 lines · Max Reitz
Quoted 3 lines

If two images have the same contents but then you compare them changing the backing file of one of them you can also get a content mismatch. How is this different?

It’s different in that files with data-file-raw can’t have backing files at all. So maybe users shouldn’t be allowed to give them backing files at runtime either.

I understand that. Ideally it should be forbidden. Perhaps that could be fixed by turning drv->supports_backing into a function.

My point however is that forcing a different backing file is something that is going to cause breakage unless the user really knows that they're doing. And we don't generally forbid that, we just let the user take responsibility. So I'm not too worried about this case.

Quoted 3 lines

Or at least, if we have data-file-raw, *all* data visible on such an image should be taken from the raw data file, never from any backing file.

It should be easy to handle in qcow2_co_preadv_part() and qcow2_co_copy_range_from(), but it feels hackish and error prone.

Quoted 2 lines

With preallocation, we’d ensure that we always take all data from the raw data file. So we’d always ignore any potential backing file.

Preallocation has its problems (and we would also have to handle it differently if there are subclusters, but I think that should be easy). But I don't have a strong opinion.

Berto