qemu-block
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: [PATCH v5 14/31] qcow2: Add QCow2SubclusterType and qcow2_get_subclu


From: Eric Blake
Subject: Re: [PATCH v5 14/31] qcow2: Add QCow2SubclusterType and qcow2_get_subcluster_type()
Date: Tue, 5 May 2020 16:08:57 -0500
User-agent: Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101 Thunderbird/68.7.0

On 5/5/20 12:38 PM, Alberto Garcia wrote:
This patch adds QCow2SubclusterType, which is the subcluster-level
version of QCow2ClusterType. All QCOW2_SUBCLUSTER_* values have the
the same meaning as their QCOW2_CLUSTER_* equivalents (when they
exist). See below for details and caveats.

In images without extended L2 entries clusters are treated as having
exactly one subcluster so it is possible to replace one data type with
the other while keeping the exact same semantics.

With extended L2 entries there are new possible values, and every
subcluster in the same cluster can obviously have a different
QCow2SubclusterType so functions need to be adapted to work on the
subcluster level.

There are several things that have to be taken into account:

   a) QCOW2_SUBCLUSTER_COMPRESSED means that the whole cluster is
      compressed. We do not support compression at the subcluster
      level.

   b) There are two different values for unallocated subclusters:
      QCOW2_SUBCLUSTER_UNALLOCATED_PLAIN which means that the whole
      cluster is unallocated, and QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC
      which means that the cluster is allocated but the subcluster is
      not. The latter can only happen in images with extended L2
      entries.

Or put differently, extents of the qcow2 file are always allocated a contiguous cluster at a time (so using larger clusters reduces fragmentation), but because we can now defer to the backing image a sub-cluster at a time, we have less I/O to perform the first time the guest touches a subcluster. The two different return values thus tell us when we need to do a cluster allocation vs. just an in-place overwrite or a sub-cluster COW.


   c) QCOW2_SUBCLUSTER_INVALID is used to detect the cases where an L2
      entry has a value that violates the specification. The caller is
      responsible for handling these situations.

      To prevent compatibility problems with images that have invalid
      values but are currently being read by QEMU without causing side
      effects, QCOW2_SUBCLUSTER_INVALID is only returned for images
      with extended L2 entries.

qcow2_cluster_to_subcluster_type() is added as a separate function
from qcow2_get_subcluster_type(), but this is only temporary and both
will be merged in a subsequent patch.

Signed-off-by: Alberto Garcia <address@hidden>
---
  block/qcow2.h | 127 +++++++++++++++++++++++++++++++++++++++++++++++++-
  1 file changed, 126 insertions(+), 1 deletion(-)

diff --git a/block/qcow2.h b/block/qcow2.h
index 4ad93772b9..be7816a3b8 100644
--- a/block/qcow2.h
+++ b/block/qcow2.h
@@ -80,6 +80,21 @@
#define QCOW_EXTL2_SUBCLUSTERS_PER_CLUSTER 32 +/* The subcluster X [0..31] is allocated */
+#define QCOW_OFLAG_SUB_ALLOC(X)   (1ULL << (X))
+/* The subcluster X [0..31] reads as zeroes */
+#define QCOW_OFLAG_SUB_ZERO(X)    (QCOW_OFLAG_SUB_ALLOC(X) << 32)
+/* Subclusters X to Y (both included) are allocated */
+#define QCOW_OFLAG_SUB_ALLOC_RANGE(X, Y) \
+    (QCOW_OFLAG_SUB_ALLOC((Y) + 1) - QCOW_OFLAG_SUB_ALLOC(X))

Nicer than my initial thoughts on getting rid of the bit-wise loop. And uses 64-bit math to produce a 32-bit answer, so there are no edge cases where overflow could misbehave even though the intermediate steps may require 33 bits. Works as long as X <= Y (should that be mentioned in the contract?)

+/* Subclusters X to Y (both included) read as zeroes */
+#define QCOW_OFLAG_SUB_ZERO_RANGE(X, Y) \
+    (QCOW_OFLAG_SUB_ALLOC_RANGE(X, Y) << 32)

Also works (you do the math in the low 33 bits before shifting), again if X <= Y.

+/* L2 entry bitmap with all allocation bits set */
+#define QCOW_L2_BITMAP_ALL_ALLOC  (QCOW_OFLAG_SUB_ALLOC_RANGE(0, 31))
+/* L2 entry bitmap with all "read as zeroes" bits set */
+#define QCOW_L2_BITMAP_ALL_ZEROES (QCOW_OFLAG_SUB_ZERO_RANGE(0, 31))

More complicated than merely writing 0xffffffffULL and (0xffffffffULL<<32), but the compiler will constant-fold it to the same value, and it elegantly expresses the intent. I like it.

Reviewed-by: Eric Blake <address@hidden>

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




reply via email to

[Prev in Thread] Current Thread [Next in Thread]