Add subcluster allocation to qcow2
PATCH v5 10/31 qcow2: Add offset_to_sc_index()
In reply to Alberto GarciaFor a given offset, return the subcluster number within its cluster (i.e. with 32 subclusters per cluster it returns a number between 0 and 31).
--- block/qcow2.h | 5 +++++ 1 file changed, 5 insertions(+)
block/qcow2.h +5 -0
@@ -563,6 +563,11 @@ static inline int offset_to_l2_slice_index(BDRVQcow2State *s, int64_t offset)return (offset >> s->cluster_bits) & (s->l2_slice_size -1 ); } +static inline int offset_to_sc_index (BDRVQcow2State *s,int64_t offset) +{ +return (offset >> s->subcluster_bits) & (s->subclusters_per_cluster -1 ); +} +static inline int64_t qcow2_vm_state_offset (BDRVQcow2State *s) {return (int64_t )s->l1_vm_state_index << (s->cluster_bits + s->l2_bits);
Signature · 1 line
2.20.1
PATCH v5 3/31 qcow2: Add calculate_l2_meta()
In reply to Alberto Garciahandle_alloc() creates a QCowL2Meta structure in order to update the image metadata and perform the necessary copy-on-write operations.
This patch moves that code to a separate function so it can be used from other places.
--- block/qcow2-cluster.c | 77 +++++++++++++++++++++++++++++-------------- 1 file changed, 53 insertions(+), 24 deletions(-)
block/qcow2-cluster.c +53 -24
@@ -1037,6 +1037,56 @@ void qcow2_alloc_cluster_abort(BlockDriverState *bs, QCowL2Meta *m) } } +/* +* For a given write request, create a new QCowL2Meta structure, add +* it to @m and the BDRVQcow2State.cluster_allocs list. +* +* @host_cluster_offset points to the beginning of the first cluster. +* +* @guest_offset and @bytes indicate the offset and length of the +* request. +* +* If @keep_old is true it means that the clusters were already +* allocated and will be overwritten. If false then the clusters are +* new and we have to decrease the reference count of the old ones. +*/ +static void calculate_l2_meta (BlockDriverState *bs, +uint64_t host_cluster_offset, +uint64_t guest_offset,unsigned bytes, +QCowL2Meta **m,bool keep_old) +{ +BDRVQcow2State *s = bs->opaque; +unsigned cow_start_from =0 ; +unsigned cow_start_to =offset_into_cluster (s, guest_offset); +unsigned cow_end_from = cow_start_to + bytes; +unsigned cow_end_to =ROUND_UP (cow_end_from, s->cluster_size); +unsigned nb_clusters =size_to_clusters (s, cow_end_from); +QCowL2Meta *old_m = *m; + + *m =g_malloc0 (sizeof (**m)); + **m = (QCowL2Meta ) { + .next = old_m, + + .alloc_offset = host_cluster_offset, + .offset =start_of_cluster (s, guest_offset), + .nb_clusters = nb_clusters, + + .keep_old_clusters = keep_old, + + .cow_start = { + .offset = cow_start_from, + .nb_bytes = cow_start_to - cow_start_from, + }, + .cow_end = { + .offset = cow_end_from, + .nb_bytes = cow_end_to - cow_end_from, + }, + }; + +qemu_co_queue_init (&(*m)->dependent_requests); +QLIST_INSERT_HEAD (&s->cluster_allocs, *m, next_in_flight); +} +/* * Returns the number of contiguous clusters that can be used for an allocating * write, but require COW to be performed (this includes yet unallocated space,
@@ -1435,35 +1485,14 @@ static int handle_alloc(BlockDriverState *bs, uint64_t guest_offset,uint64_t requested_bytes = *bytes +offset_into_cluster (s, guest_offset);int avail_bytes = nb_clusters << s->cluster_bits;int nb_bytes =MIN (requested_bytes, avail_bytes); -QCowL2Meta *old_m = *m; - - *m =g_malloc0 (sizeof (**m)); - - **m = (QCowL2Meta ) { - .next = old_m, - - .alloc_offset = alloc_cluster_offset, - .offset =start_of_cluster (s, guest_offset), - .nb_clusters = nb_clusters, - - .keep_old_clusters = keep_old_clusters, - - .cow_start = { - .offset =0 , - .nb_bytes =offset_into_cluster (s, guest_offset), - }, - .cow_end = { - .offset = nb_bytes, - .nb_bytes = avail_bytes - nb_bytes, - }, - }; -qemu_co_queue_init (&(*m)->dependent_requests); -QLIST_INSERT_HEAD (&s->cluster_allocs, *m, next_in_flight); *host_offset = alloc_cluster_offset +offset_into_cluster (s, guest_offset); *bytes =MIN (*bytes, nb_bytes -offset_into_cluster (s, guest_offset));assert (*bytes !=0 ); +calculate_l2_meta (bs, alloc_cluster_offset, guest_offset, *bytes, + m, keep_old_clusters); +return 1 ; fail:
Signature · 1 line
2.20.1
PATCH v5 8/31 qcow2: Add dummy has_subclusters() function
In reply to Alberto GarciaThis function will be used by the qcow2 code to check if an image has subclusters or not.
At the moment this simply returns false. Once all patches needed for subcluster support are ready then QEMU will be able to create and read images with subclusters and this function will return the actual value.
--- block/qcow2.h | 6 ++++++ 1 file changed, 6 insertions(+)
block/qcow2.h +6 -0
@@ -492,6 +492,12 @@ typedef enum QCow2MetadataOverlap {#define INV_OFFSET (-1ULL) +static inline bool has_subclusters (BDRVQcow2State *s) +{ +/* FIXME: Return false until this feature is complete */ +return false; +} +static inline uint64_t get_l2_entry (BDRVQcow2State *s,uint64_t *l2_slice,int idx) {
Signature · 1 line
2.20.1
PATCH v5 24/31 qcow2: Update L2 bitmap in qcow2_alloc_cluster_link_l2()
In reply to Alberto GarciaThe L2 bitmap needs to be updated after each write to indicate what new subclusters are now allocated. This needs to happen even if the cluster was already allocated and the L2 entry was otherwise valid.
In some cases however a write operation doesn't need change the L2 bitmap (because all affected subclusters were already allocated). This is detected in calculate_l2_meta(), and qcow2_alloc_cluster_link_l2() is never called in those cases.
--- block/qcow2-cluster.c | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+)
block/qcow2-cluster.c +18 -0
@@ -1000,6 +1000,24 @@ int qcow2_alloc_cluster_link_l2(BlockDriverState *bs, QCowL2Meta *m)assert ((offset &L2E_OFFSET_MASK ) == offset);set_l2_entry (s, l2_slice, l2_index + i, offset |QCOW_OFLAG_COPIED ); + +/* Update bitmap with the subclusters that were just written */ +if (has_subclusters (s)) { +uint64_t l2_bitmap =get_l2_bitmap (s, l2_slice, l2_index + i); +unsigned written_from = m->cow_start.offset; +unsigned written_to = m->cow_end.offset + m->cow_end.nb_bytes ?: + m->nb_clusters << s->cluster_bits; +int first_sc, last_sc; +/* Narrow written_from and written_to down to the current cluster */ + written_from =MAX (written_from, i << s->cluster_bits); + written_to =MIN (written_to, (i +1 ) << s->cluster_bits); +assert (written_from < written_to); + first_sc =offset_to_sc_index (s, written_from); + last_sc =offset_to_sc_index (s, written_to -1 ); + l2_bitmap |=QCOW_OFLAG_SUB_ALLOC_RANGE (first_sc, last_sc); + l2_bitmap &= ~QCOW_OFLAG_SUB_ZERO_RANGE (first_sc, last_sc); +set_l2_bitmap (s, l2_slice, l2_index + i, l2_bitmap); + } }
Signature · 1 line
2.20.1
PATCH v5 1/31 qcow2: Make Qcow2AioTask store the full host offset
In reply to Alberto GarciaThe file_cluster_offset field of Qcow2AioTask stores a cluster-aligned host offset. In practice this is not very useful because all users(*) of this structure need the final host offset into the cluster, which they calculate using
host_offset = file_cluster_offset + offset_into_cluster(s, offset)
There is no reason why Qcow2AioTask cannot store host_offset directly and that is what this patch does.
(*) compressed clusters are the exception: in this case what
file_cluster_offset was storing was the full compressed cluster descriptor (offset + size). This does not change with this patch but it is documented now.
--- block/qcow2.c | 69 ++++++++++++++++++++++------------------------ block/trace-events | 2 +- 2 files changed, 34 insertions(+), 37 deletions(-)
block/qcow2.c +33 -36
@@ -74,7 +74,7 @@ typedef struct { static int coroutine_fn qcow2_co_preadv_compressed(BlockDriverState *bs, - uint64_t file_cluster_offset, + uint64_t cluster_descriptor, uint64_t offset, uint64_t bytes, QEMUIOVector *qiov,
@@ -2043,7 +2043,7 @@ out: static coroutine_fn int qcow2_co_preadv_encrypted(BlockDriverState *bs, - uint64_t file_cluster_offset, + uint64_t host_offset, uint64_t offset, uint64_t bytes, QEMUIOVector *qiov,
@@ -2070,16 +2070,12 @@ qcow2_co_preadv_encrypted(BlockDriverState *bs, }BLKDBG_EVENT (bs->file,BLKDBG_READ_AIO ); - ret =bdrv_co_pread (s->data_file, - file_cluster_offset +offset_into_cluster (s, offset), - bytes, buf,0 ); + ret =bdrv_co_pread (s->data_file, host_offset, bytes, buf,0 );if (ret <0 ) { goto fail; } -if (qcow2_co_decrypt (bs, - file_cluster_offset +offset_into_cluster (s, offset), - offset, buf, bytes) <0 ) +if (qcow2_co_decrypt (bs, host_offset, offset, buf, bytes) <0 ) { ret = -EIO ; goto fail;
@@ -2097,7 +2093,7 @@ typedef struct Qcow2AioTask {BlockDriverState *bs;QCow2ClusterType cluster_type;/* only for read */ -uint64_t file_cluster_offset; +uint64_t host_offset;/* or full descriptor in compressed clusters */ uint64_t offset;uint64_t bytes;QEMUIOVector *qiov;
@@ -2110,7 +2106,7 @@ static coroutine_fn int qcow2_add_task(BlockDriverState *bs,AioTaskPool *pool, AioTaskFunc func, QCow2ClusterType cluster_type, - uint64_t file_cluster_offset, + uint64_t host_offset, uint64_t offset, uint64_t bytes, QEMUIOVector *qiov,
@@ -2125,7 +2121,7 @@ static coroutine_fn int qcow2_add_task(BlockDriverState *bs, .bs = bs, .cluster_type = cluster_type, .qiov = qiov, - .file_cluster_offset = file_cluster_offset, + .host_offset = host_offset, .offset = offset, .bytes = bytes, .qiov_offset = qiov_offset,
@@ -2134,7 +2130,7 @@ static coroutine_fn int qcow2_add_task(BlockDriverState *bs,trace_qcow2_add_task (qemu_coroutine_self (), bs, pool, func == qcow2_co_preadv_task_entry ?"read" :"write" , - cluster_type, file_cluster_offset, offset, bytes, + cluster_type, host_offset, offset, bytes, qiov, qiov_offset);if (!pool) {
@@ -2148,13 +2144,12 @@ static coroutine_fn int qcow2_add_task(BlockDriverState *bs, static coroutine_fn int qcow2_co_preadv_task(BlockDriverState *bs,QCow2ClusterType cluster_type, -uint64_t file_cluster_offset, +uint64_t host_offset,uint64_t offset,uint64_t bytes,QEMUIOVector *qiov,size_t qiov_offset) {BDRVQcow2State *s = bs->opaque; -int offset_in_cluster =offset_into_cluster (s, offset);switch (cluster_type) {case QCOW2_CLUSTER_ZERO_PLAIN :
@@ -2170,19 +2165,17 @@ static coroutine_fn int qcow2_co_preadv_task(BlockDriverState *bs, qiov, qiov_offset, 0);case QCOW2_CLUSTER_COMPRESSED : -return qcow2_co_preadv_compressed (bs, file_cluster_offset, +return qcow2_co_preadv_compressed (bs, host_offset, offset, bytes, qiov, qiov_offset);case QCOW2_CLUSTER_NORMAL : -assert (offset_into_cluster (s, file_cluster_offset) ==0 );if (bs->encrypted) { -return qcow2_co_preadv_encrypted (bs, file_cluster_offset, +return qcow2_co_preadv_encrypted (bs, host_offset, offset, bytes, qiov, qiov_offset); }BLKDBG_EVENT (bs->file,BLKDBG_READ_AIO ); -return bdrv_co_preadv_part (s->data_file, - file_cluster_offset + offset_in_cluster, +return bdrv_co_preadv_part (s->data_file, host_offset, bytes, qiov, qiov_offset,0 );default :
@@ -2198,7 +2191,7 @@ static coroutine_fn int qcow2_co_preadv_task_entry(AioTask *task)assert (!t->l2meta); -return qcow2_co_preadv_task (t->bs, t->cluster_type, t->file_cluster_offset, +return qcow2_co_preadv_task (t->bs, t->cluster_type, t->host_offset, t->offset, t->bytes, t->qiov, t->qiov_offset); }
@@ -2234,11 +2227,20 @@ static coroutine_fn int qcow2_co_preadv_part(BlockDriverState *bs, {qemu_iovec_memset (qiov, qiov_offset,0 , cur_bytes); } else { +/* +* For compressed clusters the variable cluster_offset +* does not actually store the offset but the full +* descriptor. We need to leave it unchanged because +* that's what qcow2_co_preadv_compressed() expects. +*/ +uint64_t host_offset = (ret ==QCOW2_CLUSTER_COMPRESSED ) ? + cluster_offset : + cluster_offset +offset_into_cluster (s, offset);if (!aio && cur_bytes != bytes) { aio =aio_task_pool_new (QCOW2_MAX_WORKERS ); } ret =qcow2_add_task (bs, aio, qcow2_co_preadv_task_entry, ret, - cluster_offset, offset, cur_bytes, + host_offset, offset, cur_bytes, qiov, qiov_offset,NULL );if (ret <0 ) { goto out;
@@ -2389,7 +2391,7 @@ static int handle_alloc_space(BlockDriverState *bs, QCowL2Meta *l2meta)* not use it somehow after qcow2_co_pwritev_task() call */ static coroutine_fn int qcow2_co_pwritev_task(BlockDriverState *bs, - uint64_t file_cluster_offset, + uint64_t host_offset, uint64_t offset, uint64_t bytes, QEMUIOVector *qiov, uint64_t qiov_offset,
@@ -2398,7 +2400,6 @@ static coroutine_fn int qcow2_co_pwritev_task(BlockDriverState *bs,int ret;BDRVQcow2State *s = bs->opaque;void *crypt_buf =NULL ; -int offset_in_cluster =offset_into_cluster (s, offset);QEMUIOVector encrypted_qiov;if (bs->encrypted) {
@@ -2411,9 +2412,7 @@ static coroutine_fn int qcow2_co_pwritev_task(BlockDriverState *bs, }qemu_iovec_to_buf (qiov, qiov_offset, crypt_buf, bytes); -if (qcow2_co_encrypt (bs, file_cluster_offset + offset_in_cluster, - offset, crypt_buf, bytes) <0 ) - { +if (qcow2_co_encrypt (bs, host_offset, offset, crypt_buf, bytes) <0 ) { ret = -EIO ; goto out_unlocked; }
@@ -2437,10 +2436,8 @@ static coroutine_fn int qcow2_co_pwritev_task(BlockDriverState *bs,*/ if (!merge_cow (offset, bytes, qiov, qiov_offset, l2meta)) {BLKDBG_EVENT (bs->file,BLKDBG_WRITE_AIO ); -trace_qcow2_writev_data (qemu_coroutine_self (), - file_cluster_offset + offset_in_cluster); - ret =bdrv_co_pwritev_part (s->data_file, - file_cluster_offset + offset_in_cluster, +trace_qcow2_writev_data (qemu_coroutine_self (), host_offset); + ret =bdrv_co_pwritev_part (s->data_file, host_offset, bytes, qiov, qiov_offset,0 );if (ret <0 ) { goto out_unlocked;
@@ -2470,7 +2467,7 @@ static coroutine_fn int qcow2_co_pwritev_task_entry(AioTask *task)assert (!t->cluster_type); -return qcow2_co_pwritev_task (t->bs, t->file_cluster_offset, +return qcow2_co_pwritev_task (t->bs, t->host_offset, t->offset, t->bytes, t->qiov, t->qiov_offset, t->l2meta); }
@@ -2525,8 +2522,8 @@ static coroutine_fn int qcow2_co_pwritev_part( aio =aio_task_pool_new (QCOW2_MAX_WORKERS ); } ret =qcow2_add_task (bs, aio, qcow2_co_pwritev_task_entry,0 , - cluster_offset, offset, cur_bytes, - qiov, qiov_offset, l2meta); + cluster_offset + offset_in_cluster, offset, + cur_bytes, qiov, qiov_offset, l2meta); l2meta =NULL ;/* l2meta is consumed by qcow2_co_pwritev_task() */ if (ret <0 ) { goto fail_nometa;
@@ -4445,7 +4442,7 @@ qcow2_co_pwritev_compressed_part(BlockDriverState *bs, static int coroutine_fn qcow2_co_preadv_compressed(BlockDriverState *bs, - uint64_t file_cluster_offset, + uint64_t cluster_descriptor, uint64_t offset, uint64_t bytes, QEMUIOVector *qiov,
@@ -4457,8 +4454,8 @@ qcow2_co_preadv_compressed(BlockDriverState *bs,uint8_t *buf, *out_buf;int offset_in_cluster =offset_into_cluster (s, offset); - coffset = file_cluster_offset & s->cluster_offset_mask; - nb_csectors = ((file_cluster_offset >> s->csize_shift) & s->csize_mask) +1 ; + coffset = cluster_descriptor & s->cluster_offset_mask; + nb_csectors = ((cluster_descriptor >> s->csize_shift) & s->csize_mask) +1 ; csize = nb_csectors *QCOW2_COMPRESSED_SECTOR_SIZE - (coffset & ~QCOW2_COMPRESSED_SECTOR_MASK );
block/trace-events +1 -1
@@ -77,7 +77,7 @@ luring_io_uring_submit(void *s, int ret) "LuringState %p ret %d" luring_resubmit_short_read(void *s, void *luringcb, int nread) "LuringState %p luringcb %p nread %d" # qcow2.c -qcow2_add_task(void *co, void *bs, void *pool, const char *action, int cluster_type, uint64_t file_cluster_offset, uint64_t offset, uint64_t bytes, void *qiov, size_t qiov_offset) "co %p bs %p pool %p: %s: cluster_type %d file_cluster_offset %" PRIu64 " offset %" PRIu64 " bytes %" PRIu64 " qiov %p qiov_offset %zu" +qcow2_add_task(void *co, void *bs, void *pool, const char *action, int cluster_type, uint64_t host_offset, uint64_t offset, uint64_t bytes, void *qiov, size_t qiov_offset) "co %p bs %p pool %p: %s: cluster_type %d file_cluster_offset %" PRIu64 " offset %" PRIu64 " bytes %" PRIu64 " qiov %p qiov_offset %zu" qcow2_writev_start_req(void *co, int64_t offset, int bytes) "co %p offset 0x%" PRIx64 " bytes %d" qcow2_writev_done_req(void *co, int ret) "co %p ret %d" qcow2_writev_start_part(void *co) "co %p"
Signature · 1 line
2.20.1
PATCH v5 11/31 qcow2: Add offset_into_subcluster() and size_to_subclusters()
In reply to Alberto GarciaLike offset_into_cluster() and size_to_clusters(), but for subclusters.
--- block/qcow2.h | 10 ++++++++++ 1 file changed, 10 insertions(+)
block/qcow2.h +10 -0
@@ -537,11 +537,21 @@ static inline int64_t offset_into_cluster(BDRVQcow2State *s, int64_t offset)return offset & (s->cluster_size -1 ); } +static inline int64_t offset_into_subcluster (BDRVQcow2State *s,int64_t offset) +{ +return offset & (s->subcluster_size -1 ); +} +static inline uint64_t size_to_clusters (BDRVQcow2State *s,uint64_t size) {return (size + (s->cluster_size -1 )) >> s->cluster_bits; } +static inline uint64_t size_to_subclusters (BDRVQcow2State *s,uint64_t size) +{ +return (size + (s->subcluster_size -1 )) >> s->subcluster_bits; +} +static inline int64_t size_to_l1 (BDRVQcow2State *s,int64_t size) {int shift = s->cluster_bits + s->l2_bits;
Signature · 1 line
2.20.1
PATCH v5 18/31 qcow2: Handle QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC
In reply to Alberto GarciaWhen dealing with subcluster types there is a new value called QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC that has no equivalent in QCow2ClusterType.
This patch handles that value in all places where subcluster types are processed.
--- block/qcow2.c | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-)
block/qcow2.c +9 -3
@@ -1994,7 +1994,8 @@ static int coroutine_fn qcow2_co_block_status(BlockDriverState *bs, *pnum = bytes;if ((type ==QCOW2_SUBCLUSTER_NORMAL || - type ==QCOW2_SUBCLUSTER_ZERO_ALLOC ) && !s->crypto) { + type ==QCOW2_SUBCLUSTER_ZERO_ALLOC || + type ==QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC ) && !s->crypto) { *map = host_offset; *file = s->data_file->bs; status |=BDRV_BLOCK_OFFSET_VALID ;
@@ -2002,7 +2003,8 @@ static int coroutine_fn qcow2_co_block_status(BlockDriverState *bs,if (type ==QCOW2_SUBCLUSTER_ZERO_PLAIN || type ==QCOW2_SUBCLUSTER_ZERO_ALLOC ) { status |=BDRV_BLOCK_ZERO ; - }else if (type !=QCOW2_SUBCLUSTER_UNALLOCATED_PLAIN ) { + }else if (type !=QCOW2_SUBCLUSTER_UNALLOCATED_PLAIN && + type !=QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC ) { status |=BDRV_BLOCK_DATA ; } if (s->metadata_preallocation && (status & BDRV_BLOCK_DATA) &&
@@ -2165,6 +2167,7 @@ static coroutine_fn int qcow2_co_preadv_task(BlockDriverState *bs,g_assert_not_reached ();case QCOW2_SUBCLUSTER_UNALLOCATED_PLAIN : +case QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC :assert (bs->backing);/* otherwise handled in qcow2_co_preadv_part */ BLKDBG_EVENT (bs->file,BLKDBG_READ_BACKING_AIO );
@@ -2233,7 +2236,8 @@ static coroutine_fn int qcow2_co_preadv_part(BlockDriverState *bs,if (type ==QCOW2_SUBCLUSTER_ZERO_PLAIN || type ==QCOW2_SUBCLUSTER_ZERO_ALLOC || - (type ==QCOW2_SUBCLUSTER_UNALLOCATED_PLAIN && !bs->backing)) + (type ==QCOW2_SUBCLUSTER_UNALLOCATED_PLAIN && !bs->backing) || + (type ==QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC && !bs->backing)) {qemu_iovec_memset (qiov, qiov_offset,0 , cur_bytes); }else {
@@ -3761,6 +3765,7 @@ static coroutine_fn int qcow2_co_pwrite_zeroes(BlockDriverState *bs, ret =qcow2_get_host_offset (bs, offset, &nr, &off, &type);if (ret <0 || (type !=QCOW2_SUBCLUSTER_UNALLOCATED_PLAIN && + type !=QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC && type !=QCOW2_SUBCLUSTER_ZERO_PLAIN && type !=QCOW2_SUBCLUSTER_ZERO_ALLOC )) {qemu_co_mutex_unlock (&s->lock);
@@ -3839,6 +3844,7 @@ qcow2_co_copy_range_from(BlockDriverState *bs,switch (type) {case QCOW2_SUBCLUSTER_UNALLOCATED_PLAIN : +case QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC :if (bs->backing && bs->backing->bs) {int64_t backing_length =bdrv_getlength (bs->backing->bs);if (src_offset >= backing_length) {
Signature · 1 line
2.20.1
PATCH v5 21/31 qcow2: Add subcluster support to zero_in_l2_slice()
In reply to Alberto GarciaThe QCOW_OFLAG_ZERO bit that indicates that a cluster reads as zeroes is only used in standard L2 entries. Extended L2 entries use individual 'all zeroes' bits for each subcluster.
This must be taken into account when updating the L2 entry and also when deciding that an existing entry does not need to be updated.
--- block/qcow2-cluster.c | 36 +++++++++++++++++++----------------- 1 file changed, 19 insertions(+), 17 deletions(-)
block/qcow2-cluster.c +19 -17
@@ -1913,7 +1913,6 @@ static int zero_in_l2_slice(BlockDriverState *bs, uint64_t offset,int l2_index;int ret;int i; -bool unmap = !!(flags &BDRV_REQ_MAY_UNMAP ); ret =get_cluster_table (bs, offset, &l2_slice, &l2_index);if (ret <0 ) {
@@ -1925,28 +1924,31 @@ static int zero_in_l2_slice(BlockDriverState *bs, uint64_t offset,assert (nb_clusters <=INT_MAX );for (i =0 ; i < nb_clusters; i++) { -uint64_t old_offset; -QCow2ClusterType cluster_type; +uint64_t old_l2_entry =get_l2_entry (s, l2_slice, l2_index + i); +uint64_t old_l2_bitmap =get_l2_bitmap (s, l2_slice, l2_index + i); +QCow2ClusterType type =qcow2_get_cluster_type (bs, old_l2_entry); +bool unmap = (type ==QCOW2_CLUSTER_COMPRESSED ) || + ((flags &BDRV_REQ_MAY_UNMAP ) &&qcow2_cluster_is_allocated (type)); +uint64_t new_l2_entry = unmap ?0 : old_l2_entry; +uint64_t new_l2_bitmap = old_l2_bitmap; - old_offset =get_l2_entry (s, l2_slice, l2_index + i); +if (has_subclusters (s)) { + new_l2_bitmap =QCOW_L2_BITMAP_ALL_ZEROES ; + }else { + new_l2_entry |=QCOW_OFLAG_ZERO ; + } -/* -* Minimize L2 changes if the cluster already reads back as -* zeroes with correct allocation. -*/ - cluster_type =qcow2_get_cluster_type (bs, old_offset); -if (cluster_type ==QCOW2_CLUSTER_ZERO_PLAIN || - (cluster_type ==QCOW2_CLUSTER_ZERO_ALLOC && !unmap)) { +if (old_l2_entry == new_l2_entry && old_l2_bitmap == new_l2_bitmap) {continue ; }qcow2_cache_entry_mark_dirty (s->l2_table_cache, l2_slice); -if (cluster_type ==QCOW2_CLUSTER_COMPRESSED || unmap) { -set_l2_entry (s, l2_slice, l2_index + i,QCOW_OFLAG_ZERO ); -qcow2_free_any_clusters (bs, old_offset,1 ,QCOW2_DISCARD_REQUEST ); - }else { -uint64_t entry =get_l2_entry (s, l2_slice, l2_index + i); -set_l2_entry (s, l2_slice, l2_index + i, entry |QCOW_OFLAG_ZERO ); +if (unmap) { +qcow2_free_any_clusters (bs, old_l2_entry,1 ,QCOW2_DISCARD_REQUEST ); + } +set_l2_entry (s, l2_slice, l2_index + i, new_l2_entry); +if (has_subclusters (s)) { +set_l2_bitmap (s, l2_slice, l2_index + i, new_l2_bitmap); } }
Signature · 1 line
2.20.1
PATCH v5 15/31 qcow2: Add qcow2_cluster_is_allocated()
In reply to Alberto GarciaThis helper function tells us if a cluster is allocated (that is, there is an associated host offset for it).
--- block/qcow2.h | 6 ++++++ 1 file changed, 6 insertions(+)
block/qcow2.h +6 -0
@@ -763,6 +763,12 @@ QCow2SubclusterType qcow2_get_subcluster_type(BlockDriverState *bs, } } +static inline bool qcow2_cluster_is_allocated (QCow2ClusterType type) +{ +return (type ==QCOW2_CLUSTER_COMPRESSED || type ==QCOW2_CLUSTER_NORMAL || + type ==QCOW2_CLUSTER_ZERO_ALLOC ); +} +/* Check whether refcounts are eager or lazy */ static inline bool qcow2_need_accurate_refcounts (BDRVQcow2State *s) {
Signature · 1 line
2.20.1
PATCH v5 2/31 qcow2: Convert qcow2_get_cluster_offset() into qcow2_get_host_offset()
In reply to Alberto Garciaqcow2_get_cluster_offset() takes an (unaligned) guest offset and returns the (aligned) offset of the corresponding cluster in the qcow2 image.
In practice none of the callers need to know where the cluster starts so this patch makes the function calculate and return the final host offset directly. The function is also renamed accordingly.
There is a pre-existing exception with compressed clusters: in this case the function returns the complete cluster descriptor (containing the offset and size of the compressed data). This does not change with this patch but it is now documented.
--- block/qcow2.h | 4 ++-- block/qcow2-cluster.c | 42 +++++++++++++++++++++++------------------- block/qcow2.c | 24 +++++++----------------- 3 files changed, 32 insertions(+), 38 deletions(-)
block/qcow2.h +2 -2
@@ -676,8 +676,8 @@ int qcow2_write_l1_entry(BlockDriverState *bs, int l1_index);int qcow2_encrypt_sectors (BDRVQcow2State *s,int64_t sector_num,uint8_t *buf,int nb_sectors,bool enc,Error **errp); -int qcow2_get_cluster_offset (BlockDriverState *bs,uint64_t offset, -unsigned int *bytes,uint64_t *cluster_offset); +int qcow2_get_host_offset (BlockDriverState *bs,uint64_t offset, +unsigned int *bytes,uint64_t *host_offset);int qcow2_alloc_cluster_offset (BlockDriverState *bs,uint64_t offset,unsigned int *bytes,uint64_t *host_offset,QCowL2Meta **m);
block/qcow2-cluster.c +23 -19
109 lines not on this page · raw message
block/qcow2.c +7 -17
@@ -1966,7 +1966,7 @@ static int coroutine_fn qcow2_co_block_status(BlockDriverState *bs, BlockDriverState **file) {BDRVQcow2State *s = bs->opaque; -uint64_t cluster_offset; +uint64_t host_offset;unsigned int bytes;int ret, status =0 ;
@@ -1979,7 +1979,7 @@ static int coroutine_fn qcow2_co_block_status(BlockDriverState *bs, } bytes =MIN (INT_MAX , count); - ret =qcow2_get_cluster_offset (bs, offset, &bytes, &cluster_offset); + ret =qcow2_get_host_offset (bs, offset, &bytes, &host_offset);qemu_co_mutex_unlock (&s->lock);if (ret <0 ) {return ret;
@@ -1989,7 +1989,7 @@ static int coroutine_fn qcow2_co_block_status(BlockDriverState *bs,if ((ret ==QCOW2_CLUSTER_NORMAL || ret ==QCOW2_CLUSTER_ZERO_ALLOC ) && !s->crypto) { - *map = cluster_offset |offset_into_cluster (s, offset); + *map = host_offset; *file = s->data_file->bs; status |=BDRV_BLOCK_OFFSET_VALID ; }
@@ -2203,7 +2203,7 @@ static coroutine_fn int qcow2_co_preadv_part(BlockDriverState *bs,BDRVQcow2State *s = bs->opaque;int ret =0 ;unsigned int cur_bytes;/* number of bytes in current iteration */ -uint64_t cluster_offset =0 ; +uint64_t host_offset =0 ;AioTaskPool *aio =NULL ;while (bytes !=0 &&aio_task_pool_status (aio) ==0 ) {
@@ -2215,7 +2215,7 @@ static coroutine_fn int qcow2_co_preadv_part(BlockDriverState *bs, }qemu_co_mutex_lock (&s->lock); - ret =qcow2_get_cluster_offset (bs, offset, &cur_bytes, &cluster_offset); + ret =qcow2_get_host_offset (bs, offset, &cur_bytes, &host_offset);qemu_co_mutex_unlock (&s->lock);if (ret <0 ) { goto out;
@@ -2227,15 +2227,6 @@ static coroutine_fn int qcow2_co_preadv_part(BlockDriverState *bs, {qemu_iovec_memset (qiov, qiov_offset,0 , cur_bytes); } else { -/* -* For compressed clusters the variable cluster_offset -* does not actually store the offset but the full -* descriptor. We need to leave it unchanged because -* that's what qcow2_co_preadv_compressed() expects. -*/ -uint64_t host_offset = (ret ==QCOW2_CLUSTER_COMPRESSED ) ? - cluster_offset : - cluster_offset +offset_into_cluster (s, offset);if (!aio && cur_bytes != bytes) { aio =aio_task_pool_new (QCOW2_MAX_WORKERS ); }
@@ -3756,7 +3747,7 @@ static coroutine_fn int qcow2_co_pwrite_zeroes(BlockDriverState *bs, offset =QEMU_ALIGN_DOWN (offset, s->cluster_size); bytes = s->cluster_size; nr = s->cluster_size; - ret =qcow2_get_cluster_offset (bs, offset, &nr, &off); + ret =qcow2_get_host_offset (bs, offset, &nr, &off);if (ret !=QCOW2_CLUSTER_UNALLOCATED && ret !=QCOW2_CLUSTER_ZERO_PLAIN && ret !=QCOW2_CLUSTER_ZERO_ALLOC ) {
@@ -3827,7 +3818,7 @@ qcow2_co_copy_range_from(BlockDriverState *bs, cur_bytes =MIN (bytes,INT_MAX ); cur_write_flags = write_flags; - ret =qcow2_get_cluster_offset (bs, src_offset, &cur_bytes, ©_offset); + ret =qcow2_get_host_offset (bs, src_offset, &cur_bytes, ©_offset);if (ret <0 ) { goto out; }
@@ -3859,7 +3850,6 @@ qcow2_co_copy_range_from(BlockDriverState *bs,case QCOW2_CLUSTER_NORMAL : child = s->data_file; - copy_offset +=offset_into_cluster (s, src_offset);break ;default :
Signature · 1 line
2.20.1
PATCH v5 22/31 qcow2: Add subcluster support to discard_in_l2_slice()
In reply to Alberto GarciaTwo things need to be taken into account here:
1) With full_discard == true the L2 entry must be cleared completely. This also includes the L2 bitmap if the image has extended L2 entries.
2) With full_discard == false we have to make the discarded cluster read back as zeroes. With normal L2 entries this is done with the QCOW_OFLAG_ZERO bit, whereas with extended L2 entries this is done with the individual 'all zeroes' bits for each subcluster.
Note however that QCOW_OFLAG_ZERO is not supported in v2 qcow2 images so, if there is a backing file, discard cannot guarantee that the image will read back as zeroes. If this is important for the caller it should forbid it as qcow2_co_pdiscard() does (see 80f5c01183 for more details).
--- block/qcow2-cluster.c | 51 +++++++++++++++++++------------------------ 1 file changed, 22 insertions(+), 29 deletions(-)
block/qcow2-cluster.c +22 -29
@@ -1804,11 +1804,16 @@ static int discard_in_l2_slice(BlockDriverState *bs, uint64_t offset,assert (nb_clusters <=INT_MAX );for (i =0 ; i < nb_clusters; i++) { -uint64_t old_l2_entry; - - old_l2_entry =get_l2_entry (s, l2_slice, l2_index + i); +uint64_t old_l2_entry =get_l2_entry (s, l2_slice, l2_index + i); +uint64_t old_l2_bitmap =get_l2_bitmap (s, l2_slice, l2_index + i); +uint64_t new_l2_entry = old_l2_entry; +uint64_t new_l2_bitmap = old_l2_bitmap; +QCow2ClusterType type =qcow2_get_cluster_type (bs, old_l2_entry);/* +* If full_discard is true, the cluster should not read back as zeroes, +* but rather fall through to the backing file. +* * If full_discard is false, make sure that a discarded area reads back * as zeroes for v3 images (we cannot do it for v2 without actually * writing a zero-filled buffer). We can skip the operation if the
@@ -1817,40 +1822,28 @@ static int discard_in_l2_slice(BlockDriverState *bs, uint64_t offset,* * TODO We might want to use bdrv_block_status(bs) here, but we're * holding s->lock, so that doesn't work today. -* -* If full_discard is true, the sector should not read back as zeroes, -* but rather fall through to the backing file. */ -switch (qcow2_get_cluster_type (bs, old_l2_entry)) { -case QCOW2_CLUSTER_UNALLOCATED : -if (full_discard || !bs->backing) { -continue ; +if (full_discard) { + new_l2_entry = new_l2_bitmap =0 ; + }else if (bs->backing ||qcow2_cluster_is_allocated (type)) { +if (has_subclusters (s)) { + new_l2_entry =0 ; + new_l2_bitmap =QCOW_L2_BITMAP_ALL_ZEROES ; + }else { + new_l2_entry = s->qcow_version >=3 ?QCOW_OFLAG_ZERO :0 ; } -break ; + } -case QCOW2_CLUSTER_ZERO_PLAIN : -if (!full_discard) { -continue ; - } -break ; - -case QCOW2_CLUSTER_ZERO_ALLOC : -case QCOW2_CLUSTER_NORMAL : -case QCOW2_CLUSTER_COMPRESSED : -break ; - -default : -abort (); +if (old_l2_entry == new_l2_entry && old_l2_bitmap == new_l2_bitmap) { +continue ; }/* First remove L2 entries */ qcow2_cache_entry_mark_dirty (s->l2_table_cache, l2_slice); -if (!full_discard && s->qcow_version >=3 ) { -set_l2_entry (s, l2_slice, l2_index + i,QCOW_OFLAG_ZERO ); - }else { -set_l2_entry (s, l2_slice, l2_index + i,0 ); +set_l2_entry (s, l2_slice, l2_index + i, new_l2_entry); +if (has_subclusters (s)) { +set_l2_bitmap (s, l2_slice, l2_index + i, new_l2_bitmap); } -/* Then decrease the refcount */ qcow2_free_any_clusters (bs, old_l2_entry,1 , type); }
Signature · 1 line
2.20.1
PATCH v5 4/31 qcow2: Split cluster_needs_cow() out of count_cow_clusters()
In reply to Alberto GarciaWe are going to need it in other places.
--- block/qcow2-cluster.c | 34 +++++++++++++++++++--------------- 1 file changed, 19 insertions(+), 15 deletions(-)
block/qcow2-cluster.c +19 -15
@@ -1087,6 +1087,24 @@ static void calculate_l2_meta(BlockDriverState *bs,QLIST_INSERT_HEAD (&s->cluster_allocs, *m, next_in_flight); } +/* Returns true if writing to a cluster requires COW */ +static bool cluster_needs_cow (BlockDriverState *bs,uint64_t l2_entry) +{ +switch (qcow2_get_cluster_type (bs, l2_entry)) { +case QCOW2_CLUSTER_NORMAL : +if (l2_entry &QCOW_OFLAG_COPIED ) { +return false; + } +case QCOW2_CLUSTER_UNALLOCATED : +case QCOW2_CLUSTER_COMPRESSED : +case QCOW2_CLUSTER_ZERO_PLAIN : +case QCOW2_CLUSTER_ZERO_ALLOC : +return true; +default : +abort (); + } +} +/* * Returns the number of contiguous clusters that can be used for an allocating * write, but require COW to be performed (this includes yet unallocated space,
@@ -1099,25 +1117,11 @@ static int count_cow_clusters(BlockDriverState *bs, int nb_clusters,for (i =0 ; i < nb_clusters; i++) {uint64_t l2_entry =be64_to_cpu (l2_slice[l2_index + i]); -QCow2ClusterType cluster_type =qcow2_get_cluster_type (bs, l2_entry); - -switch (cluster_type) { -case QCOW2_CLUSTER_NORMAL : -if (l2_entry &QCOW_OFLAG_COPIED ) { - goto out; - } +if (!cluster_needs_cow (bs, l2_entry)) {break ; -case QCOW2_CLUSTER_UNALLOCATED : -case QCOW2_CLUSTER_COMPRESSED : -case QCOW2_CLUSTER_ZERO_PLAIN : -case QCOW2_CLUSTER_ZERO_ALLOC : -break ; -default : -abort (); } } -out:assert (i <= nb_clusters);return i; }
Signature · 1 line
2.20.1
PATCH v5 9/31 qcow2: Add subcluster-related fields to BDRVQcow2State
In reply to Alberto GarciaThis patch adds the following new fields to BDRVQcow2State:
- subclusters_per_cluster: Number of subclusters in a cluster
- subcluster_size: The size of each subcluster, in bytes
- subcluster_bits: No. of bits so 1 << subcluster_bits = subcluster_size
Images without subclusters are treated as if they had exactly one subcluster per cluster (i.e. subcluster_size = cluster_size).
--- block/qcow2.h | 5 +++++ block/qcow2.c | 5 +++++ 2 files changed, 10 insertions(+)
block/qcow2.h +5 -0
@@ -78,6 +78,8 @@/* The cluster reads as all zeros */ #define QCOW_OFLAG_ZERO (1ULL << 0) +#define QCOW_EXTL2_SUBCLUSTERS_PER_CLUSTER 32 +#define MIN_CLUSTER_BITS 9#define MAX_CLUSTER_BITS 21
@@ -284,6 +286,9 @@ typedef struct BDRVQcow2State {int cluster_bits;int cluster_size;int l2_slice_size; +int subcluster_bits; +int subcluster_size; +int subclusters_per_cluster;int l2_bits;int l2_size;int l1_size;
block/qcow2.c +5 -0
@@ -1380,6 +1380,11 @@ static int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options, } } + s->subclusters_per_cluster = +has_subclusters (s) ?QCOW_EXTL2_SUBCLUSTERS_PER_CLUSTER :1 ; + s->subcluster_size = s->cluster_size / s->subclusters_per_cluster; + s->subcluster_bits =ctz32 (s->subcluster_size); +/* Check support for various header values */ if (header.refcount_order >6 ) { error_setg(errp, "Reference count entry width too large; may not "
Signature · 1 line
2.20.1
PATCH v5 6/31 qcow2: Add get_l2_entry() and set_l2_entry()
In reply to Alberto GarciaThe size of an L2 entry is 64 bits, but if we want to have subclusters we need extended L2 entries. This means that we have to access L2 tables and slices differently depending on whether an image has extended L2 entries or not.
This patch replaces all l2_slice[] accesses with calls to get_l2_entry() and set_l2_entry().
--- block/qcow2.h | 12 ++++++++ block/qcow2-cluster.c | 63 ++++++++++++++++++++++-------------------- block/qcow2-refcount.c | 17 ++++++------ 3 files changed, 54 insertions(+), 38 deletions(-)
block/qcow2.h +12 -0
@@ -492,6 +492,18 @@ typedef enum QCow2MetadataOverlap {#define INV_OFFSET (-1ULL) +static inline uint64_t get_l2_entry (BDRVQcow2State *s,uint64_t *l2_slice, +int idx) +{ +return be64_to_cpu (l2_slice[idx]); +} + +static inline void set_l2_entry (BDRVQcow2State *s,uint64_t *l2_slice, +int idx,uint64_t entry) +{ + l2_slice[idx] =cpu_to_be64 (entry); +} +static inline bool has_data_file (BlockDriverState *bs) {BDRVQcow2State *s = bs->opaque;
block/qcow2-cluster.c +33 -30
219 lines not on this page · raw message
block/qcow2-refcount.c +9 -8
@@ -1310,7 +1310,7 @@ int qcow2_update_snapshot_refcount(BlockDriverState *bs,uint64_t cluster_index;uint64_t offset; - entry =be64_to_cpu (l2_slice[j]); + entry =get_l2_entry (s, l2_slice, j); old_entry = entry; entry &= ~QCOW_OFLAG_COPIED ; offset = entry &L2E_OFFSET_MASK ;
@@ -1384,7 +1384,7 @@ int qcow2_update_snapshot_refcount(BlockDriverState *bs,qcow2_cache_set_dependency (bs, s->l2_table_cache, s->refcount_block_cache); } - l2_slice[j] =cpu_to_be64 (entry); +set_l2_entry (s, l2_slice, j, entry);qcow2_cache_entry_mark_dirty (s->l2_table_cache, l2_slice); }
@@ -1617,7 +1617,7 @@ static int check_refcounts_l2(BlockDriverState *bs, BdrvCheckResult *res,/* Do the actual checks */ for (i =0 ; i < s->l2_size; i++) { - l2_entry =be64_to_cpu (l2_table[i]); + l2_entry =get_l2_entry (s, l2_table, i);switch (qcow2_get_cluster_type (bs, l2_entry)) {case QCOW2_CLUSTER_COMPRESSED :
@@ -1686,7 +1686,7 @@ static int check_refcounts_l2(BlockDriverState *bs, BdrvCheckResult *res,QCOW2_OL_INACTIVE_L2 ; l2_entry =QCOW_OFLAG_ZERO ; - l2_table[i] =cpu_to_be64 (l2_entry); +set_l2_entry (s, l2_table, i, l2_entry); ret =qcow2_pre_write_overlap_check (bs, ign, l2e_offset,sizeof (uint64_t ), false);if (ret <0 ) {
@@ -1914,7 +1914,7 @@ static int check_oflag_copied(BlockDriverState *bs, BdrvCheckResult *res, }for (j =0 ; j < s->l2_size; j++) { -uint64_t l2_entry =be64_to_cpu (l2_table[j]); +uint64_t l2_entry =get_l2_entry (s, l2_table, j);uint64_t data_offset = l2_entry &L2E_OFFSET_MASK ;QCow2ClusterType cluster_type =qcow2_get_cluster_type (bs, l2_entry);
@@ -1937,9 +1937,10 @@ static int check_oflag_copied(BlockDriverState *bs, BdrvCheckResult *res,"l2_entry=%" PRIx64" refcount=%" PRIu64"\n" , repair ? "Repairing" : "ERROR", l2_entry, refcount);if (repair) { - l2_table[j] =cpu_to_be64 (refcount ==1 - ? l2_entry |QCOW_OFLAG_COPIED - : l2_entry & ~QCOW_OFLAG_COPIED ); +set_l2_entry (s, l2_table, j, + refcount ==1 ? + l2_entry |QCOW_OFLAG_COPIED : + l2_entry & ~QCOW_OFLAG_COPIED ); l2_dirty++; } }
Signature · 1 line
2.20.1
PATCH v5 29/31 qcow2: Assert that expand_zero_clusters_in_l1() does not support subclusters
In reply to Alberto GarciaThis function is only used by qcow2_expand_zero_clusters() to downgrade a qcow2 image to a previous version. It is however not possible to downgrade an image with extended L2 entries because older versions of qcow2 do not have this feature.
--- block/qcow2-cluster.c | 8 +++++++- tests/qemu-iotests/061 | 6 ++++++ tests/qemu-iotests/061.out | 5 +++++ 3 files changed, 18 insertions(+), 1 deletion(-)
block/qcow2-cluster.c +7 -1
@@ -2113,6 +2113,9 @@ static int expand_zero_clusters_in_l1(BlockDriverState *bs, uint64_t *l1_table,int ret;int i, j; +/* qcow2_downgrade() is not allowed in images with subclusters */ +assert (!has_subclusters (s)); + slice_size2 = s->l2_slice_size *l2_entry_size (s); n_slices = s->cluster_size / slice_size2;
@@ -2181,7 +2184,8 @@ static int expand_zero_clusters_in_l1(BlockDriverState *bs, uint64_t *l1_table,if (cluster_type ==QCOW2_CLUSTER_ZERO_PLAIN ) {if (!bs->backing) {/* not backed; therefore we can simply deallocate the -* cluster */ +* cluster. No need to call set_l2_bitmap(), this +* function doesn't support images with subclusters. */ set_l2_entry (s, l2_slice, j,0 ); l2_dirty = true;continue ;
@@ -2252,6 +2256,8 @@ static int expand_zero_clusters_in_l1(BlockDriverState *bs, uint64_t *l1_table, }else {set_l2_entry (s, l2_slice, j, offset); } +/* No need to call set_l2_bitmap() after set_l2_entry() because +* this function doesn't support images with subclusters. */ l2_dirty = true; }
tests/qemu-iotests/061 +6 -0
@@ -268,6 +268,12 @@ $QEMU_IMG amend -o "compat=0.10" "$TEST_IMG" _img_info --format-specific _check_test_img +echo +echo "=== Testing version downgrade with extended L2 entries ===" +echo +_make_test_img -o "compat=1.1,extended_l2=on" 64M +$QEMU_IMG amend -o "compat=0.10" "$TEST_IMG" + echo echo "=== Try changing the external data file ===" echo
tests/qemu-iotests/061.out +5 -0
@@ -499,6 +499,11 @@ Format specific information: extended l2: false No errors were found on the image. +=== Testing version downgrade with extended L2 entries === + +Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 +qemu-img: Cannot downgrade an image with incompatible features 0x10 set + === Try changing the external data file === Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
Signature · 1 line
2.20.1
PATCH v5 13/31 qcow2: Update get/set_l2_entry() and add get/set_l2_bitmap()
In reply to Alberto GarciaExtended L2 entries are 128-bit wide: 64 bits for the entry itself and 64 bits for the subcluster allocation bitmap.
In order to support them correctly get/set_l2_entry() need to be updated so they take the entry width into account in order to calculate the correct offset.
This patch also adds the get/set_l2_bitmap() functions that are used to access the bitmaps. For convenience we allow calling get_l2_bitmap() on images without subclusters. In this case the returned value is always 0 and has no meaning.
--- block/qcow2.h | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+)
block/qcow2.h +21 -0
@@ -515,15 +515,36 @@ static inline size_t l2_entry_size(BDRVQcow2State *s)static inline uint64_t get_l2_entry (BDRVQcow2State *s,uint64_t *l2_slice,int idx) { + idx *=l2_entry_size (s) /sizeof (uint64_t );return be64_to_cpu (l2_slice[idx]); } +static inline uint64_t get_l2_bitmap (BDRVQcow2State *s,uint64_t *l2_slice, +int idx) +{ +if (has_subclusters (s)) { + idx *=l2_entry_size (s) /sizeof (uint64_t ); +return be64_to_cpu (l2_slice[idx +1 ]); + }else { +return 0 ;/* For convenience only; this value has no meaning. */ + } +} +static inline void set_l2_entry (BDRVQcow2State *s,uint64_t *l2_slice,int idx,uint64_t entry) { + idx *=l2_entry_size (s) /sizeof (uint64_t ); l2_slice[idx] =cpu_to_be64 (entry); } +static inline void set_l2_bitmap (BDRVQcow2State *s,uint64_t *l2_slice, +int idx,uint64_t bitmap) +{ +assert (has_subclusters (s)); + idx *=l2_entry_size (s) /sizeof (uint64_t ); + l2_slice[idx +1 ] =cpu_to_be64 (bitmap); +} +static inline bool has_data_file (BlockDriverState *bs) {BDRVQcow2State *s = bs->opaque;
Signature · 1 line
2.20.1
PATCH v5 12/31 qcow2: Add l2_entry_size()
In reply to Alberto Garciaqcow2 images with subclusters have 128-bit L2 entries. The first 64 bits contain the same information as traditional images and the last 64 bits form a bitmap with the status of each individual subcluster.
Because of that we cannot assume that L2 entries are sizeof(uint64_t) anymore. This function returns the proper value for the image.
--- block/qcow2.h | 9 +++++++++ block/qcow2-cluster.c | 12 ++++++------ block/qcow2-refcount.c | 14 ++++++++------ block/qcow2.c | 8 ++++---- 4 files changed, 27 insertions(+), 16 deletions(-)
block/qcow2.h +9 -0
@@ -80,6 +80,10 @@#define QCOW_EXTL2_SUBCLUSTERS_PER_CLUSTER 32 +/* Size of normal and extended L2 entries */ +#define L2E_SIZE_NORMAL (sizeof(uint64_t)) +#define L2E_SIZE_EXTENDED (sizeof(uint64_t) * 2) +#define MIN_CLUSTER_BITS 9#define MAX_CLUSTER_BITS 21
@@ -503,6 +507,11 @@ static inline bool has_subclusters(BDRVQcow2State *s)return false; } +static inline size_t l2_entry_size (BDRVQcow2State *s) +{ +return has_subclusters (s) ?L2E_SIZE_EXTENDED :L2E_SIZE_NORMAL ; +} +static inline uint64_t get_l2_entry (BDRVQcow2State *s,uint64_t *l2_slice,int idx) {
block/qcow2-cluster.c +6 -6
@@ -208,7 +208,7 @@ static int l2_load(BlockDriverState *bs, uint64_t offset, uint64_t l2_offset, uint64_t **l2_slice) { BDRVQcow2State *s = bs->opaque; -int start_of_slice =sizeof (uint64_t ) * +int start_of_slice =l2_entry_size (s) * (offset_to_l2_index (s, offset) -offset_to_l2_slice_index (s, offset)); return qcow2_cache_get(bs, s->l2_table_cache, l2_offset + start_of_slice,
@@ -281,7 +281,7 @@ static int l2_allocate(BlockDriverState *bs, int l1_index)/* allocate a new l2 entry */ - l2_offset =qcow2_alloc_clusters (bs, s->l2_size *sizeof (uint64_t )); + l2_offset =qcow2_alloc_clusters (bs, s->l2_size *l2_entry_size (s));if (l2_offset <0 ) { ret = l2_offset; goto fail;
@@ -305,7 +305,7 @@ static int l2_allocate(BlockDriverState *bs, int l1_index)/* allocate a new entry in the l2 cache */ - slice_size2 = s->l2_slice_size *sizeof (uint64_t ); + slice_size2 = s->l2_slice_size *l2_entry_size (s); n_slices = s->cluster_size / slice_size2;trace_qcow2_l2_allocate_get_empty (bs, l1_index);
@@ -369,7 +369,7 @@ fail: } s->l1_table[l1_index] = old_l2_offset;if (l2_offset >0 ) { -qcow2_free_clusters (bs, l2_offset, s->l2_size *sizeof (uint64_t ), +qcow2_free_clusters (bs, l2_offset, s->l2_size *l2_entry_size (s),QCOW2_DISCARD_ALWAYS ); }return ret;
@@ -716,7 +716,7 @@ static int get_cluster_table(BlockDriverState *bs, uint64_t offset,/* Then decrease the refcount of the old table */ if (l2_offset) { -qcow2_free_clusters (bs, l2_offset, s->l2_size *sizeof (uint64_t ), +qcow2_free_clusters (bs, l2_offset, s->l2_size *l2_entry_size (s),QCOW2_DISCARD_OTHER ); }
@@ -1913,7 +1913,7 @@ static int expand_zero_clusters_in_l1(BlockDriverState *bs, uint64_t *l1_table,int ret;int i, j; - slice_size2 = s->l2_slice_size *sizeof (uint64_t ); + slice_size2 = s->l2_slice_size *l2_entry_size (s); n_slices = s->cluster_size / slice_size2;if (!is_active_l1) {
block/qcow2-refcount.c +8 -6
@@ -1254,7 +1254,7 @@ int qcow2_update_snapshot_refcount(BlockDriverState *bs, l2_slice =NULL ; l1_table =NULL ; l1_size2 = l1_size *sizeof (uint64_t ); - slice_size2 = s->l2_slice_size *sizeof (uint64_t ); + slice_size2 = s->l2_slice_size *l2_entry_size (s); n_slices = s->cluster_size / slice_size2; s->cache_discards = true;
@@ -1605,7 +1605,7 @@ static int check_refcounts_l2(BlockDriverState *bs, BdrvCheckResult *res,int i, l2_size, nb_csectors, ret;/* Read L2 table from disk */ - l2_size = s->l2_size *sizeof (uint64_t ); + l2_size = s->l2_size *l2_entry_size (s); l2_table =g_malloc (l2_size); ret =bdrv_pread (bs->file, l2_offset, l2_table, l2_size);
@@ -1680,15 +1680,16 @@ static int check_refcounts_l2(BlockDriverState *bs, BdrvCheckResult *res, fix &BDRV_FIX_ERRORS ?"Repairing" :"ERROR" , offset);if (fix &BDRV_FIX_ERRORS ) { +int idx = i * (l2_entry_size (s) /sizeof (uint64_t ));uint64_t l2e_offset = - l2_offset + (uint64_t )i *sizeof (uint64_t ); + l2_offset + (uint64_t )i *l2_entry_size (s);int ign = active ?QCOW2_OL_ACTIVE_L2 :QCOW2_OL_INACTIVE_L2 ; l2_entry =QCOW_OFLAG_ZERO ;set_l2_entry (s, l2_table, i, l2_entry); ret =qcow2_pre_write_overlap_check (bs, ign, - l2e_offset,sizeof (uint64_t ), false); + l2e_offset,l2_entry_size (s), false);if (ret <0 ) {fprintf (stderr,"ERROR: Overlap check failed\n" ); res->check_errors++;
@@ -1698,7 +1699,8 @@ static int check_refcounts_l2(BlockDriverState *bs, BdrvCheckResult *res, } ret =bdrv_pwrite_sync (bs->file, l2e_offset, - &l2_table[i],sizeof (uint64_t )); + &l2_table[idx], +l2_entry_size (s));if (ret <0 ) {fprintf (stderr,"ERROR: Failed to overwrite L2 " "table entry: %s\n" ,strerror (-ret));
@@ -1905,7 +1907,7 @@ static int check_oflag_copied(BlockDriverState *bs, BdrvCheckResult *res, } ret =bdrv_pread (bs->file, l2_offset, l2_table, - s->l2_size *sizeof (uint64_t )); + s->l2_size *l2_entry_size (s));if (ret <0 ) {fprintf (stderr,"ERROR: Could not read L2 table: %s\n" ,strerror (-ret));
block/qcow2.c +4 -4
@@ -870,7 +870,7 @@ static void read_cache_sizes(BlockDriverState *bs, QemuOpts *opts,uint64_t max_l2_entries =DIV_ROUND_UP (virtual_disk_size, s->cluster_size);/* An L2 table is always one cluster in size so the max cache size * should be a multiple of the cluster size. */ -uint64_t max_l2_cache =ROUND_UP (max_l2_entries *sizeof (uint64_t ), +uint64_t max_l2_cache =ROUND_UP (max_l2_entries *l2_entry_size (s), s->cluster_size); combined_cache_size_set =qemu_opt_get (opts,QCOW2_OPT_CACHE_SIZE );
@@ -1031,7 +1031,7 @@ static int qcow2_update_options_prepare(BlockDriverState *bs, } } - r->l2_slice_size = l2_cache_entry_size /sizeof (uint64_t ); + r->l2_slice_size = l2_cache_entry_size /l2_entry_size (s); r->l2_table_cache =qcow2_cache_create (bs, l2_cache_size, l2_cache_entry_size); r->refcount_block_cache = qcow2_cache_create(bs, refcount_cache_size,
@@ -1425,7 +1425,7 @@ static int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options, bs->encrypted = true; } - s->l2_bits = s->cluster_bits -3 ;/* L2 is always one cluster */ + s->l2_bits = s->cluster_bits -ctz32 (l2_entry_size (s)); s->l2_size =1 << s->l2_bits;/* 2^(s->refcount_order - 3) is the refcount width in bytes */ s->refcount_block_bits = s->cluster_bits - (s->refcount_order -3 );
@@ -4132,7 +4132,7 @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,* preallocation. All that matters is that we will not have to allocate * new refcount structures for them.) */ nb_new_l2_tables =DIV_ROUND_UP (nb_new_data_clusters, - s->cluster_size /sizeof (uint64_t )); + s->cluster_size /l2_entry_size (s));/* The cluster range may not be aligned to L2 boundaries, so add one L2 * table for a potential head/tail */ nb_new_l2_tables++;
Signature · 1 line
2.20.1
PATCH v5 20/31 qcow2: Add subcluster support to qcow2_get_host_offset()
In reply to Alberto GarciaThe logic of this function remains pretty much the same, except that it uses count_contiguous_subclusters(), which combines the logic of count_contiguous_clusters() / count_contiguous_clusters_unallocated() and checks individual subclusters.
--- block/qcow2.h | 38 +++++------- block/qcow2-cluster.c | 141 ++++++++++++++++++++---------------------- 2 files changed, 82 insertions(+), 97 deletions(-)
block/qcow2.h +14 -24
@@ -692,29 +692,6 @@ static inline QCow2ClusterType qcow2_get_cluster_type(BlockDriverState *bs, } } -/* -* For an image without extended L2 entries, return the -* QCow2SubclusterType equivalent of a given QCow2ClusterType. -*/ -static inline -QCow2SubclusterType qcow2_cluster_to_subcluster_type (QCow2ClusterType type) -{ -switch (type) { -case QCOW2_CLUSTER_COMPRESSED : -return QCOW2_SUBCLUSTER_COMPRESSED ; -case QCOW2_CLUSTER_ZERO_PLAIN : -return QCOW2_SUBCLUSTER_ZERO_PLAIN ; -case QCOW2_CLUSTER_ZERO_ALLOC : -return QCOW2_SUBCLUSTER_ZERO_ALLOC ; -case QCOW2_CLUSTER_NORMAL : -return QCOW2_SUBCLUSTER_NORMAL ; -case QCOW2_CLUSTER_UNALLOCATED : -return QCOW2_SUBCLUSTER_UNALLOCATED_PLAIN ; -default : -g_assert_not_reached (); - } -} -/* * In an image without subsclusters @l2_bitmap is ignored and * @sc_index must be 0.
@@ -759,7 +736,20 @@ QCow2SubclusterType qcow2_get_subcluster_type(BlockDriverState *bs,g_assert_not_reached (); } }else { -return qcow2_cluster_to_subcluster_type (type); +switch (type) { +case QCOW2_CLUSTER_COMPRESSED : +return QCOW2_SUBCLUSTER_COMPRESSED ; +case QCOW2_CLUSTER_ZERO_PLAIN : +return QCOW2_SUBCLUSTER_ZERO_PLAIN ; +case QCOW2_CLUSTER_ZERO_ALLOC : +return QCOW2_SUBCLUSTER_ZERO_ALLOC ; +case QCOW2_CLUSTER_NORMAL : +return QCOW2_SUBCLUSTER_NORMAL ; +case QCOW2_CLUSTER_UNALLOCATED : +return QCOW2_SUBCLUSTER_UNALLOCATED_PLAIN ; +default : +g_assert_not_reached (); + } } }
block/qcow2-cluster.c +68 -73
222 lines not on this page · raw message
Signature · 1 line
2.20.1
PATCH v5 7/31 qcow2: Document the Extended L2 Entries feature
In reply to Alberto GarciaSubcluster allocation in qcow2 is implemented by extending the existing L2 table entries and adding additional information to indicate the allocation status of each subcluster.
This patch documents the changes to the qcow2 format and how they affect the calculation of the L2 cache size.
--- docs/interop/qcow2.txt | 68 ++++++++++++++++++++++++++++++++++++++++-- docs/qcow2-cache.txt | 19 +++++++++++- 2 files changed, 83 insertions(+), 4 deletions(-)
docs/interop/qcow2.txt +65 -3
@@ -42,6 +42,9 @@ The first cluster of a qcow2 image contains the file header: as the maximum cluster size and won't be able to open images with larger cluster sizes. + Note: if the image has Extended L2 Entries then cluster_bits + must be at least 14 (i.e. 16384 byte clusters). + 24 - 31: size Virtual disk size in bytes.
@@ -117,7 +120,12 @@ the next fields through header_length. clusters. The compression_type field must be present and not zero. - Bits 4-63: Reserved (set to 0) + Bit 4: Extended L2 Entries. If this bit is set then + L2 table entries use an extended format that + allows subcluster-based allocation. See the + Extended L2 Entries section for more details. + + Bits 5-63: Reserved (set to 0) 80 - 87: compatible_features Bitmask of compatible features. An implementation can
@@ -497,7 +505,7 @@ cannot be relaxed without an incompatible layout change). Given an offset into the virtual disk, the offset into the image file can be obtained as follows: - l2_entries = (cluster_size / sizeof(uint64_t)) + l2_entries = (cluster_size / sizeof(uint64_t)) [*] l2_index = (offset / cluster_size) % l2_entries l1_index = (offset / cluster_size) / l2_entries
@@ -507,6 +515,8 @@ obtained as follows: return cluster_offset + (offset % cluster_size) + [*] this changes if Extended L2 Entries are enabled, see next section + L1 table entry: Bit 0 - 8: Reserved (set to 0)
@@ -547,7 +557,8 @@ Standard Cluster Descriptor: nor is data read from the backing file if the cluster is unallocated. - With version 2, this is always 0. + With version 2 or with extended L2 entries (see the next + section), this is always 0. 1 - 8: Reserved (set to 0)
@@ -584,6 +595,57 @@ file (except if bit 0 in the Standard Cluster Descriptor is set). If there is no backing file or the backing file is smaller than the image, they shall read zeros for all parts that are not covered by the backing file. +== Extended L2 Entries == + +An image uses Extended L2 Entries if bit 4 is set on the incompatible_features +field of the header. + +In these images standard data clusters are divided into 32 subclusters of the +same size. They are contiguous and start from the beginning of the cluster. +Subclusters can be allocated independently and the L2 entry contains information +indicating the status of each one of them. Compressed data clusters don't have +subclusters so they are treated the same as in images without this feature. + +The size of an extended L2 entry is 128 bits so the number of entries per table +is calculated using this formula: + + l2_entries = (cluster_size / (2 * sizeof(uint64_t))) + +The first 64 bits have the same format as the standard L2 table entry described +in the previous section, with the exception of bit 0 of the standard cluster +descriptor. + +The last 64 bits contain a subcluster allocation bitmap with this format: + +Subcluster Allocation Bitmap (for standard clusters): + + Bit 0 - 31: Allocation status (one bit per subcluster) + + 1: the subcluster is allocated. In this case the + host cluster offset field must contain a valid + offset. + 0: the subcluster is not allocated. In this case + read requests shall go to the backing file or + return zeros if there is no backing file data. + + Bits are assigned starting from the least significant + one (i.e. bit x is used for subcluster x). + + 32 - 63 Subcluster reads as zeros (one bit per subcluster) + + 1: the subcluster reads as zeros. In this case the + allocation status bit must be unset. The host + cluster offset field may or may not be set. + 0: no effect. + + Bits are assigned starting from the least significant + one (i.e. bit x is used for subcluster x - 32). + +Subcluster Allocation Bitmap (for compressed clusters): + + Bit 0 - 63: Reserved (set to 0) + Compressed clusters don't have subclusters, + so this field is not used. == Snapshots ==
docs/qcow2-cache.txt +18 -1
@@ -1,6 +1,6 @@ qcow2 L2/refcount cache configuration ===================================== -Copyright (C) 2015, 2018 Igalia, S.L. +Copyright (C) 2015, 2018-2020 Igalia, S.L. Author: Alberto Garcia <[email protected]> This work is licensed under the terms of the GNU GPL, version 2 or
@@ -222,3 +222,20 @@ support this functionality, and is 0 (disabled) on other platforms. This functionality currently relies on the MADV_DONTNEED argument for madvise() to actually free the memory. This is a Linux-specific feature, so cache-clean-interval is not supported on other systems. + + +Extended L2 Entries +------------------- +All numbers shown in this document are valid for qcow2 images with normal +64-bit L2 entries. + +Images with extended L2 entries need twice as much L2 metadata, so the L2 +cache size must be twice as large for the same disk space. + + disk_size = l2_cache_size * cluster_size / 16 + +i.e. + + l2_cache_size = disk_size * 16 / cluster_size + +Refcount blocks are not affected by this.
Signature · 1 line
2.20.1
PATCH v5 28/31 qcow2: Add the 'extended_l2' option and the QCOW2_INCOMPAT_EXTL2 bit
In reply to Alberto GarciaNow that the implementation of subclusters is complete we can finally add the necessary options to create and read images with this feature, which we call "extended L2 entries".
--- qapi/block-core.json | 7 +++ block/qcow2.h | 8 ++- include/block/block_int.h | 1 + block/qcow2.c | 65 ++++++++++++++++++-- tests/qemu-iotests/031.out | 8 +-- tests/qemu-iotests/036.out | 4 +- tests/qemu-iotests/049.out | 102 +++++++++++++++---------------- tests/qemu-iotests/060.out | 1 + tests/qemu-iotests/061.out | 20 +++--- tests/qemu-iotests/065 | 18 ++++-- tests/qemu-iotests/082.out | 48 ++++++++++++--- tests/qemu-iotests/085.out | 38 ++++++------ tests/qemu-iotests/144.out | 4 +- tests/qemu-iotests/182.out | 2 +- tests/qemu-iotests/185.out | 8 +-- tests/qemu-iotests/198.out | 2 + tests/qemu-iotests/206.out | 4 ++ tests/qemu-iotests/242.out | 5 ++ tests/qemu-iotests/255.out | 8 +-- tests/qemu-iotests/274.out | 49 ++++++++------- tests/qemu-iotests/280.out | 2 +- tests/qemu-iotests/common.filter | 1 + 22 files changed, 266 insertions(+), 139 deletions(-)
qapi/block-core.json +7 -0
@@ -66,6 +66,9 @@ # standalone (read-only) raw image without looking at qcow2 # metadata (since: 4.0) # +# @extended-l2: true if the image has extended L2 entries; only valid for +# compat >= 1.1 (since 5.1) +# # @lazy-refcounts: on or off; only valid for compat >= 1.1 # # @corrupt: true if the image has been marked corrupt; only valid for
@@ -85,6 +88,7 @@ 'compat': 'str', '*data-file': 'str', '*data-file-raw': 'bool', + '*extended-l2': 'bool', '*lazy-refcounts': 'bool', '*corrupt': 'bool', 'refcount-bits': 'int',
@@ -4296,6 +4300,8 @@ # @data-file-raw: True if the external data file must stay valid as a # standalone (read-only) raw image without looking at qcow2 # metadata (default: false; since: 4.0) +# @extended-l2 True to make the image have extended L2 entries +# (default: false; since 5.1) # @size: Size of the virtual disk in bytes # @version: Compatibility level (default: v3) # @backing-file: File name of the backing file if a backing file
@@ -4314,6 +4320,7 @@ 'data': { 'file': 'BlockdevRef', '*data-file': 'BlockdevRef', '*data-file-raw': 'bool', + '*extended-l2': 'bool', 'size': 'size', '*version': 'BlockdevQcow2Version', '*backing-file': 'str',
block/qcow2.h +5 -3
@@ -237,13 +237,16 @@ enum {QCOW2_INCOMPAT_DIRTY_BITNR =0 ,QCOW2_INCOMPAT_CORRUPT_BITNR =1 ,QCOW2_INCOMPAT_DATA_FILE_BITNR =2 , +QCOW2_INCOMPAT_EXTL2_BITNR =4 ,QCOW2_INCOMPAT_DIRTY =1 <<QCOW2_INCOMPAT_DIRTY_BITNR ,QCOW2_INCOMPAT_CORRUPT =1 <<QCOW2_INCOMPAT_CORRUPT_BITNR ,QCOW2_INCOMPAT_DATA_FILE =1 <<QCOW2_INCOMPAT_DATA_FILE_BITNR , +QCOW2_INCOMPAT_EXTL2 =1 <<QCOW2_INCOMPAT_EXTL2_BITNR ,QCOW2_INCOMPAT_MASK =QCOW2_INCOMPAT_DIRTY |QCOW2_INCOMPAT_CORRUPT - | QCOW2_INCOMPAT_DATA_FILE, + |QCOW2_INCOMPAT_DATA_FILE + | QCOW2_INCOMPAT_EXTL2, };/* Compatible feature bits */
@@ -555,8 +558,7 @@ typedef enum QCow2MetadataOverlap {static inline bool has_subclusters (BDRVQcow2State *s) { -/* FIXME: Return false until this feature is complete */ -return false; +return s->incompatible_features &QCOW2_INCOMPAT_EXTL2 ; }static inline size_t l2_entry_size (BDRVQcow2State *s)
include/block/block_int.h +1 -0
@@ -57,6 +57,7 @@#define BLOCK_OPT_REFCOUNT_BITS "refcount_bits"#define BLOCK_OPT_DATA_FILE "data_file"#define BLOCK_OPT_DATA_FILE_RAW "data_file_raw" +#define BLOCK_OPT_EXTL2 "extended_l2"#define BLOCK_PROBE_BUF_SIZE 512
block/qcow2.c +60 -5
135 lines not on this page · raw message
tests/qemu-iotests/031.out +4 -4
@@ -117,7 +117,7 @@ header_length 104 Header extension: magic 0x6803f857 -length 288 +length 336 data <binary> Header extension:
@@ -150,7 +150,7 @@ header_length 104 Header extension: magic 0x6803f857 -length 288 +length 336 data <binary> Header extension:
@@ -164,7 +164,7 @@ No errors were found on the image. magic 0x514649fb version 3 -backing_file_offset 0x1d8 +backing_file_offset 0x208 backing_file_size 0x17 cluster_bits 16 size 67108864
@@ -188,7 +188,7 @@ data 'host_device' Header extension: magic 0x6803f857 -length 288 +length 336 data <binary> Header extension:
tests/qemu-iotests/036.out +2 -2
@@ -26,7 +26,7 @@ compatible_features [] autoclear_features [63] Header extension: magic 0x6803f857 -length 288 +length 336 data <binary>
@@ -38,7 +38,7 @@ compatible_features [] autoclear_features [] Header extension: magic 0x6803f857 -length 288 +length 336 data <binary> *** done
tests/qemu-iotests/049.out +51 -51
225 lines not on this page · raw message
tests/qemu-iotests/060.out +1 -0
@@ -20,6 +20,7 @@ Format specific information: lazy refcounts: false refcount bits: 16 corrupt: true + extended l2: false qemu-io: can't open device TEST_DIR/t.IMGFMT: IMGFMT: Image is corrupt; cannot be opened read/write no file open, try 'help open' read 512/512 bytes at offset 0
tests/qemu-iotests/061.out +13 -7
@@ -26,7 +26,7 @@ header_length 104 Header extension: magic 0x6803f857 -length 288 +length 336 data <binary> magic 0x514649fb
@@ -84,7 +84,7 @@ header_length 104 Header extension: magic 0x6803f857 -length 288 +length 336 data <binary> magic 0x514649fb
@@ -140,7 +140,7 @@ header_length 104 Header extension: magic 0x6803f857 -length 288 +length 336 data <binary> ERROR cluster 5 refcount=0 reference=1
@@ -195,7 +195,7 @@ header_length 104 Header extension: magic 0x6803f857 -length 288 +length 336 data <binary> magic 0x514649fb
@@ -264,7 +264,7 @@ header_length 104 Header extension: magic 0x6803f857 -length 288 +length 336 data <binary> read 65536/65536 bytes at offset 44040192
@@ -298,7 +298,7 @@ header_length 104 Header extension: magic 0x6803f857 -length 288 +length 336 data <binary> ERROR cluster 5 refcount=0 reference=1
@@ -327,7 +327,7 @@ header_length 104 Header extension: magic 0x6803f857 -length 288 +length 336 data <binary> read 131072/131072 bytes at offset 0
@@ -496,6 +496,7 @@ Format specific information: data file: TEST_DIR/t.IMGFMT.data data file raw: false corrupt: false + extended l2: false No errors were found on the image. === Try changing the external data file ===
@@ -516,6 +517,7 @@ Format specific information: data file: foo data file raw: false corrupt: false + extended l2: false qemu-img: Could not open 'TEST_DIR/t.IMGFMT': 'data-file' is required for this image image: TEST_DIR/t.IMGFMT
@@ -528,6 +530,7 @@ Format specific information: refcount bits: 16 data file raw: false corrupt: false + extended l2: false === Clearing and setting data-file-raw ===
@@ -543,6 +546,7 @@ Format specific information: data file: TEST_DIR/t.IMGFMT.data data file raw: true corrupt: false + extended l2: false No errors were found on the image. image: TEST_DIR/t.IMGFMT file format: IMGFMT
@@ -555,6 +559,7 @@ Format specific information: data file: TEST_DIR/t.IMGFMT.data data file raw: false corrupt: false + extended l2: false No errors were found on the image. qemu-img: data-file-raw cannot be set on existing images image: TEST_DIR/t.IMGFMT
@@ -568,5 +573,6 @@ Format specific information: data file: TEST_DIR/t.IMGFMT.data data file raw: false corrupt: false + extended l2: false No errors were found on the image. *** done
tests/qemu-iotests/065 +12 -6
@@ -95,17 +95,21 @@ class TestQCow3NotLazy(TestQemuImgInfo): '''Testing a qcow2 version 3 image with lazy refcounts disabled''' img_options = 'compat=1.1,lazy_refcounts=off' json_compare = { 'compat': '1.1', 'lazy-refcounts': False, - 'refcount-bits': 16, 'corrupt': False } + 'refcount-bits': 16, 'corrupt': False, + 'extended-l2': False } human_compare = [ 'compat: 1.1', 'lazy refcounts: false', - 'refcount bits: 16', 'corrupt: false' ] + 'refcount bits: 16', 'corrupt: false', + 'extended l2: false' ] class TestQCow3Lazy(TestQemuImgInfo): '''Testing a qcow2 version 3 image with lazy refcounts enabled''' img_options = 'compat=1.1,lazy_refcounts=on' json_compare = { 'compat': '1.1', 'lazy-refcounts': True, - 'refcount-bits': 16, 'corrupt': False } + 'refcount-bits': 16, 'corrupt': False, + 'extended-l2': False } human_compare = [ 'compat: 1.1', 'lazy refcounts: true', - 'refcount bits: 16', 'corrupt: false' ] + 'refcount bits: 16', 'corrupt: false', + 'extended l2: false' ] class TestQCow3NotLazyQMP(TestQMP): '''Testing a qcow2 version 3 image with lazy refcounts disabled, opening
@@ -113,7 +117,8 @@ class TestQCow3NotLazyQMP(TestQMP): img_options = 'compat=1.1,lazy_refcounts=off' qemu_options = 'lazy-refcounts=on' compare = { 'compat': '1.1', 'lazy-refcounts': False, - 'refcount-bits': 16, 'corrupt': False } + 'refcount-bits': 16, 'corrupt': False, + 'extended-l2': False } class TestQCow3LazyQMP(TestQMP):
@@ -122,7 +127,8 @@ class TestQCow3LazyQMP(TestQMP): img_options = 'compat=1.1,lazy_refcounts=on' qemu_options = 'lazy-refcounts=off' compare = { 'compat': '1.1', 'lazy-refcounts': True, - 'refcount-bits': 16, 'corrupt': False } + 'refcount-bits': 16, 'corrupt': False, + 'extended-l2': False } TestImageInfoSpecific = None TestQemuImgInfo = None
tests/qemu-iotests/082.out +41 -7
282 lines not on this page · raw message
tests/qemu-iotests/085.out +19 -19
@@ -13,7 +13,7 @@ Formatting 'TEST_DIR/t.IMGFMT.2', fmt=IMGFMT size=134217728 === Create a single snapshot on virtio0 === { 'execute': 'blockdev-snapshot-sync', 'arguments': { 'device': 'virtio0', 'snapshot-file':'TEST_DIR/1-snapshot-v0.IMGFMT', 'format': 'IMGFMT' } } -Formatting 'TEST_DIR/1-snapshot-v0.qcow2', fmt=qcow2 size=134217728 backing_file=TEST_DIR/t.qcow2.1 backing_fmt=qcow2 cluster_size=65536 lazy_refcounts=off refcount_bits=16 +Formatting 'TEST_DIR/1-snapshot-v0.qcow2', fmt=qcow2 size=134217728 backing_file=TEST_DIR/t.qcow2.1 backing_fmt=qcow2 cluster_size=65536 lazy_refcounts=off extended_l2=off refcount_bits=16 {"return": {}} === Invalid command - missing device and nodename ===
@@ -30,40 +30,40 @@ Formatting 'TEST_DIR/1-snapshot-v0.qcow2', fmt=qcow2 size=134217728 backing_file === Create several transactional group snapshots === { 'execute': 'transaction', 'arguments': {'actions': [ { 'type': 'blockdev-snapshot-sync', 'data' : { 'device': 'virtio0', 'snapshot-file': 'TEST_DIR/2-snapshot-v0.IMGFMT' } }, { 'type': 'blockdev-snapshot-sync', 'data' : { 'device': 'virtio1', 'snapshot-file': 'TEST_DIR/2-snapshot-v1.IMGFMT' } } ] } } -Formatting 'TEST_DIR/2-snapshot-v0.qcow2', fmt=qcow2 size=134217728 backing_file=TEST_DIR/1-snapshot-v0.qcow2 backing_fmt=qcow2 cluster_size=65536 lazy_refcounts=off refcount_bits=16 -Formatting 'TEST_DIR/2-snapshot-v1.qcow2', fmt=qcow2 size=134217728 backing_file=TEST_DIR/t.qcow2.2 backing_fmt=qcow2 cluster_size=65536 lazy_refcounts=off refcount_bits=16 +Formatting 'TEST_DIR/2-snapshot-v0.qcow2', fmt=qcow2 size=134217728 backing_file=TEST_DIR/1-snapshot-v0.qcow2 backing_fmt=qcow2 cluster_size=65536 lazy_refcounts=off extended_l2=off refcount_bits=16 +Formatting 'TEST_DIR/2-snapshot-v1.qcow2', fmt=qcow2 size=134217728 backing_file=TEST_DIR/t.qcow2.2 backing_fmt=qcow2 cluster_size=65536 lazy_refcounts=off extended_l2=off refcount_bits=16 {"return": {}} { 'execute': 'transaction', 'arguments': {'actions': [ { 'type': 'blockdev-snapshot-sync', 'data' : { 'device': 'virtio0', 'snapshot-file': 'TEST_DIR/3-snapshot-v0.IMGFMT' } }, { 'type': 'blockdev-snapshot-sync', 'data' : { 'device': 'virtio1', 'snapshot-file': 'TEST_DIR/3-snapshot-v1.IMGFMT' } } ] } } -Formatting 'TEST_DIR/3-snapshot-v0.qcow2', fmt=qcow2 size=134217728 backing_file=TEST_DIR/2-snapshot-v0.qcow2 backing_fmt=qcow2 cluster_size=65536 lazy_refcounts=off refcount_bits=16 -Formatting 'TEST_DIR/3-snapshot-v1.qcow2', fmt=qcow2 size=134217728 backing_file=TEST_DIR/2-snapshot-v1.qcow2 backing_fmt=qcow2 cluster_size=65536 lazy_refcounts=off refcount_bits=16 +Formatting 'TEST_DIR/3-snapshot-v0.qcow2', fmt=qcow2 size=134217728 backing_file=TEST_DIR/2-snapshot-v0.qcow2 backing_fmt=qcow2 cluster_size=65536 lazy_refcounts=off extended_l2=off refcount_bits=16 +Formatting 'TEST_DIR/3-snapshot-v1.qcow2', fmt=qcow2 size=134217728 backing_file=TEST_DIR/2-snapshot-v1.qcow2 backing_fmt=qcow2 cluster_size=65536 lazy_refcounts=off extended_l2=off refcount_bits=16 {"return": {}} { 'execute': 'transaction', 'arguments': {'actions': [ { 'type': 'blockdev-snapshot-sync', 'data' : { 'device': 'virtio0', 'snapshot-file': 'TEST_DIR/4-snapshot-v0.IMGFMT' } }, { 'type': 'blockdev-snapshot-sync', 'data' : { 'device': 'virtio1', 'snapshot-file': 'TEST_DIR/4-snapshot-v1.IMGFMT' } } ] } } -Formatting 'TEST_DIR/4-snapshot-v0.qcow2', fmt=qcow2 size=134217728 backing_file=TEST_DIR/3-snapshot-v0.qcow2 backing_fmt=qcow2 cluster_size=65536 lazy_refcounts=off refcount_bits=16 -Formatting 'TEST_DIR/4-snapshot-v1.qcow2', fmt=qcow2 size=134217728 backing_file=TEST_DIR/3-snapshot-v1.qcow2 backing_fmt=qcow2 cluster_size=65536 lazy_refcounts=off refcount_bits=16 +Formatting 'TEST_DIR/4-snapshot-v0.qcow2', fmt=qcow2 size=134217728 backing_file=TEST_DIR/3-snapshot-v0.qcow2 backing_fmt=qcow2 cluster_size=65536 lazy_refcounts=off extended_l2=off refcount_bits=16 +Formatting 'TEST_DIR/4-snapshot-v1.qcow2', fmt=qcow2 size=134217728 backing_file=TEST_DIR/3-snapshot-v1.qcow2 backing_fmt=qcow2 cluster_size=65536 lazy_refcounts=off extended_l2=off refcount_bits=16 {"return": {}} { 'execute': 'transaction', 'arguments': {'actions': [ { 'type': 'blockdev-snapshot-sync', 'data' : { 'device': 'virtio0', 'snapshot-file': 'TEST_DIR/5-snapshot-v0.IMGFMT' } }, { 'type': 'blockdev-snapshot-sync', 'data' : { 'device': 'virtio1', 'snapshot-file': 'TEST_DIR/5-snapshot-v1.IMGFMT' } } ] } } -Formatting 'TEST_DIR/5-snapshot-v0.qcow2', fmt=qcow2 size=134217728 backing_file=TEST_DIR/4-snapshot-v0.qcow2 backing_fmt=qcow2 cluster_size=65536 lazy_refcounts=off refcount_bits=16 -Formatting 'TEST_DIR/5-snapshot-v1.qcow2', fmt=qcow2 size=134217728 backing_file=TEST_DIR/4-snapshot-v1.qcow2 backing_fmt=qcow2 cluster_size=65536 lazy_refcounts=off refcount_bits=16 +Formatting 'TEST_DIR/5-snapshot-v0.qcow2', fmt=qcow2 size=134217728 backing_file=TEST_DIR/4-snapshot-v0.qcow2 backing_fmt=qcow2 cluster_size=65536 lazy_refcounts=off extended_l2=off refcount_bits=16 +Formatting 'TEST_DIR/5-snapshot-v1.qcow2', fmt=qcow2 size=134217728 backing_file=TEST_DIR/4-snapshot-v1.qcow2 backing_fmt=qcow2 cluster_size=65536 lazy_refcounts=off extended_l2=off refcount_bits=16 {"return": {}} { 'execute': 'transaction', 'arguments': {'actions': [ { 'type': 'blockdev-snapshot-sync', 'data' : { 'device': 'virtio0', 'snapshot-file': 'TEST_DIR/6-snapshot-v0.IMGFMT' } }, { 'type': 'blockdev-snapshot-sync', 'data' : { 'device': 'virtio1', 'snapshot-file': 'TEST_DIR/6-snapshot-v1.IMGFMT' } } ] } } -Formatting 'TEST_DIR/6-snapshot-v0.qcow2', fmt=qcow2 size=134217728 backing_file=TEST_DIR/5-snapshot-v0.qcow2 backing_fmt=qcow2 cluster_size=65536 lazy_refcounts=off refcount_bits=16 -Formatting 'TEST_DIR/6-snapshot-v1.qcow2', fmt=qcow2 size=134217728 backing_file=TEST_DIR/5-snapshot-v1.qcow2 backing_fmt=qcow2 cluster_size=65536 lazy_refcounts=off refcount_bits=16 +Formatting 'TEST_DIR/6-snapshot-v0.qcow2', fmt=qcow2 size=134217728 backing_file=TEST_DIR/5-snapshot-v0.qcow2 backing_fmt=qcow2 cluster_size=65536 lazy_refcounts=off extended_l2=off refcount_bits=16 +Formatting 'TEST_DIR/6-snapshot-v1.qcow2', fmt=qcow2 size=134217728 backing_file=TEST_DIR/5-snapshot-v1.qcow2 backing_fmt=qcow2 cluster_size=65536 lazy_refcounts=off extended_l2=off refcount_bits=16 {"return": {}} { 'execute': 'transaction', 'arguments': {'actions': [ { 'type': 'blockdev-snapshot-sync', 'data' : { 'device': 'virtio0', 'snapshot-file': 'TEST_DIR/7-snapshot-v0.IMGFMT' } }, { 'type': 'blockdev-snapshot-sync', 'data' : { 'device': 'virtio1', 'snapshot-file': 'TEST_DIR/7-snapshot-v1.IMGFMT' } } ] } } -Formatting 'TEST_DIR/7-snapshot-v0.qcow2', fmt=qcow2 size=134217728 backing_file=TEST_DIR/6-snapshot-v0.qcow2 backing_fmt=qcow2 cluster_size=65536 lazy_refcounts=off refcount_bits=16 -Formatting 'TEST_DIR/7-snapshot-v1.qcow2', fmt=qcow2 size=134217728 backing_file=TEST_DIR/6-snapshot-v1.qcow2 backing_fmt=qcow2 cluster_size=65536 lazy_refcounts=off refcount_bits=16 +Formatting 'TEST_DIR/7-snapshot-v0.qcow2', fmt=qcow2 size=134217728 backing_file=TEST_DIR/6-snapshot-v0.qcow2 backing_fmt=qcow2 cluster_size=65536 lazy_refcounts=off extended_l2=off refcount_bits=16 +Formatting 'TEST_DIR/7-snapshot-v1.qcow2', fmt=qcow2 size=134217728 backing_file=TEST_DIR/6-snapshot-v1.qcow2 backing_fmt=qcow2 cluster_size=65536 lazy_refcounts=off extended_l2=off refcount_bits=16 {"return": {}} { 'execute': 'transaction', 'arguments': {'actions': [ { 'type': 'blockdev-snapshot-sync', 'data' : { 'device': 'virtio0', 'snapshot-file': 'TEST_DIR/8-snapshot-v0.IMGFMT' } }, { 'type': 'blockdev-snapshot-sync', 'data' : { 'device': 'virtio1', 'snapshot-file': 'TEST_DIR/8-snapshot-v1.IMGFMT' } } ] } } -Formatting 'TEST_DIR/8-snapshot-v0.qcow2', fmt=qcow2 size=134217728 backing_file=TEST_DIR/7-snapshot-v0.qcow2 backing_fmt=qcow2 cluster_size=65536 lazy_refcounts=off refcount_bits=16 -Formatting 'TEST_DIR/8-snapshot-v1.qcow2', fmt=qcow2 size=134217728 backing_file=TEST_DIR/7-snapshot-v1.qcow2 backing_fmt=qcow2 cluster_size=65536 lazy_refcounts=off refcount_bits=16 +Formatting 'TEST_DIR/8-snapshot-v0.qcow2', fmt=qcow2 size=134217728 backing_file=TEST_DIR/7-snapshot-v0.qcow2 backing_fmt=qcow2 cluster_size=65536 lazy_refcounts=off extended_l2=off refcount_bits=16 +Formatting 'TEST_DIR/8-snapshot-v1.qcow2', fmt=qcow2 size=134217728 backing_file=TEST_DIR/7-snapshot-v1.qcow2 backing_fmt=qcow2 cluster_size=65536 lazy_refcounts=off extended_l2=off refcount_bits=16 {"return": {}} { 'execute': 'transaction', 'arguments': {'actions': [ { 'type': 'blockdev-snapshot-sync', 'data' : { 'device': 'virtio0', 'snapshot-file': 'TEST_DIR/9-snapshot-v0.IMGFMT' } }, { 'type': 'blockdev-snapshot-sync', 'data' : { 'device': 'virtio1', 'snapshot-file': 'TEST_DIR/9-snapshot-v1.IMGFMT' } } ] } } -Formatting 'TEST_DIR/9-snapshot-v0.qcow2', fmt=qcow2 size=134217728 backing_file=TEST_DIR/8-snapshot-v0.qcow2 backing_fmt=qcow2 cluster_size=65536 lazy_refcounts=off refcount_bits=16 -Formatting 'TEST_DIR/9-snapshot-v1.qcow2', fmt=qcow2 size=134217728 backing_file=TEST_DIR/8-snapshot-v1.qcow2 backing_fmt=qcow2 cluster_size=65536 lazy_refcounts=off refcount_bits=16 +Formatting 'TEST_DIR/9-snapshot-v0.qcow2', fmt=qcow2 size=134217728 backing_file=TEST_DIR/8-snapshot-v0.qcow2 backing_fmt=qcow2 cluster_size=65536 lazy_refcounts=off extended_l2=off refcount_bits=16 +Formatting 'TEST_DIR/9-snapshot-v1.qcow2', fmt=qcow2 size=134217728 backing_file=TEST_DIR/8-snapshot-v1.qcow2 backing_fmt=qcow2 cluster_size=65536 lazy_refcounts=off extended_l2=off refcount_bits=16 {"return": {}} { 'execute': 'transaction', 'arguments': {'actions': [ { 'type': 'blockdev-snapshot-sync', 'data' : { 'device': 'virtio0', 'snapshot-file': 'TEST_DIR/10-snapshot-v0.IMGFMT' } }, { 'type': 'blockdev-snapshot-sync', 'data' : { 'device': 'virtio1', 'snapshot-file': 'TEST_DIR/10-snapshot-v1.IMGFMT' } } ] } } -Formatting 'TEST_DIR/10-snapshot-v0.qcow2', fmt=qcow2 size=134217728 backing_file=TEST_DIR/9-snapshot-v0.qcow2 backing_fmt=qcow2 cluster_size=65536 lazy_refcounts=off refcount_bits=16 -Formatting 'TEST_DIR/10-snapshot-v1.qcow2', fmt=qcow2 size=134217728 backing_file=TEST_DIR/9-snapshot-v1.qcow2 backing_fmt=qcow2 cluster_size=65536 lazy_refcounts=off refcount_bits=16 +Formatting 'TEST_DIR/10-snapshot-v0.qcow2', fmt=qcow2 size=134217728 backing_file=TEST_DIR/9-snapshot-v0.qcow2 backing_fmt=qcow2 cluster_size=65536 lazy_refcounts=off extended_l2=off refcount_bits=16 +Formatting 'TEST_DIR/10-snapshot-v1.qcow2', fmt=qcow2 size=134217728 backing_file=TEST_DIR/9-snapshot-v1.qcow2 backing_fmt=qcow2 cluster_size=65536 lazy_refcounts=off extended_l2=off refcount_bits=16 {"return": {}} === Create a couple of snapshots using blockdev-snapshot ===
tests/qemu-iotests/144.out +2 -2
@@ -9,7 +9,7 @@ Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=536870912 { 'execute': 'qmp_capabilities' } {"return": {}} { 'execute': 'blockdev-snapshot-sync', 'arguments': { 'device': 'virtio0', 'snapshot-file':'TEST_DIR/tmp.IMGFMT', 'format': 'IMGFMT' } } -Formatting 'TEST_DIR/tmp.qcow2', fmt=qcow2 size=536870912 backing_file=TEST_DIR/t.qcow2 backing_fmt=qcow2 cluster_size=65536 lazy_refcounts=off refcount_bits=16 +Formatting 'TEST_DIR/tmp.qcow2', fmt=qcow2 size=536870912 backing_file=TEST_DIR/t.qcow2 backing_fmt=qcow2 cluster_size=65536 lazy_refcounts=off extended_l2=off refcount_bits=16 {"return": {}} === Performing block-commit on active layer ===
@@ -31,6 +31,6 @@ Formatting 'TEST_DIR/tmp.qcow2', fmt=qcow2 size=536870912 backing_file=TEST_DIR/ === Performing Live Snapshot 2 === { 'execute': 'blockdev-snapshot-sync', 'arguments': { 'device': 'virtio0', 'snapshot-file':'TEST_DIR/tmp2.IMGFMT', 'format': 'IMGFMT' } } -Formatting 'TEST_DIR/tmp2.qcow2', fmt=qcow2 size=536870912 backing_file=TEST_DIR/t.qcow2 backing_fmt=qcow2 cluster_size=65536 lazy_refcounts=off refcount_bits=16 +Formatting 'TEST_DIR/tmp2.qcow2', fmt=qcow2 size=536870912 backing_file=TEST_DIR/t.qcow2 backing_fmt=qcow2 cluster_size=65536 lazy_refcounts=off extended_l2=off refcount_bits=16 {"return": {}} *** done
tests/qemu-iotests/182.out +1 -1
@@ -13,7 +13,7 @@ Is another process using the image [TEST_DIR/t.qcow2]? {'execute': 'blockdev-add', 'arguments': { 'node-name': 'node0', 'driver': 'file', 'filename': 'TEST_DIR/t.IMGFMT', 'locking': 'on' } } {"return": {}} {'execute': 'blockdev-snapshot-sync', 'arguments': { 'node-name': 'node0', 'snapshot-file': 'TEST_DIR/t.IMGFMT.overlay', 'snapshot-node-name': 'node1' } } -Formatting 'TEST_DIR/t.qcow2.overlay', fmt=qcow2 size=197120 backing_file=TEST_DIR/t.qcow2 backing_fmt=file cluster_size=65536 lazy_refcounts=off refcount_bits=16 +Formatting 'TEST_DIR/t.qcow2.overlay', fmt=qcow2 size=197120 backing_file=TEST_DIR/t.qcow2 backing_fmt=file cluster_size=65536 lazy_refcounts=off extended_l2=off refcount_bits=16 {"return": {}} {'execute': 'blockdev-add', 'arguments': { 'node-name': 'node1', 'driver': 'file', 'filename': 'TEST_DIR/t.IMGFMT', 'locking': 'on' } } {"return": {}}
tests/qemu-iotests/185.out +4 -4
@@ -9,14 +9,14 @@ Formatting 'TEST_DIR/t.IMGFMT.base', fmt=IMGFMT size=67108864 === Creating backing chain === { 'execute': 'blockdev-snapshot-sync', 'arguments': { 'device': 'disk', 'snapshot-file': 'TEST_DIR/t.IMGFMT.mid', 'format': 'IMGFMT', 'mode': 'absolute-paths' } } -Formatting 'TEST_DIR/t.qcow2.mid', fmt=qcow2 size=67108864 backing_file=TEST_DIR/t.qcow2.base backing_fmt=qcow2 cluster_size=65536 lazy_refcounts=off refcount_bits=16 +Formatting 'TEST_DIR/t.qcow2.mid', fmt=qcow2 size=67108864 backing_file=TEST_DIR/t.qcow2.base backing_fmt=qcow2 cluster_size=65536 lazy_refcounts=off extended_l2=off refcount_bits=16 {"return": {}} { 'execute': 'human-monitor-command', 'arguments': { 'command-line': 'qemu-io disk "write 0 4M"' } } wrote 4194304/4194304 bytes at offset 0 4 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) {"return": ""} { 'execute': 'blockdev-snapshot-sync', 'arguments': { 'device': 'disk', 'snapshot-file': 'TEST_DIR/t.IMGFMT', 'format': 'IMGFMT', 'mode': 'absolute-paths' } } -Formatting 'TEST_DIR/t.qcow2', fmt=qcow2 size=67108864 backing_file=TEST_DIR/t.qcow2.mid backing_fmt=qcow2 cluster_size=65536 lazy_refcounts=off refcount_bits=16 +Formatting 'TEST_DIR/t.qcow2', fmt=qcow2 size=67108864 backing_file=TEST_DIR/t.qcow2.mid backing_fmt=qcow2 cluster_size=65536 lazy_refcounts=off extended_l2=off refcount_bits=16 {"return": {}} === Start commit job and exit qemu ===
@@ -48,7 +48,7 @@ Formatting 'TEST_DIR/t.qcow2', fmt=qcow2 size=67108864 backing_file=TEST_DIR/t.q { 'execute': 'qmp_capabilities' } {"return": {}} { 'execute': 'drive-mirror', 'arguments': { 'device': 'disk', 'target': 'TEST_DIR/t.IMGFMT.copy', 'format': 'IMGFMT', 'sync': 'full', 'speed': 65536 } } -Formatting 'TEST_DIR/t.qcow2.copy', fmt=qcow2 size=67108864 cluster_size=65536 lazy_refcounts=off refcount_bits=16 +Formatting 'TEST_DIR/t.qcow2.copy', fmt=qcow2 size=67108864 cluster_size=65536 lazy_refcounts=off extended_l2=off refcount_bits=16 {"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "created", "id": "disk"}} {"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "running", "id": "disk"}} {"return": {}}
@@ -62,7 +62,7 @@ Formatting 'TEST_DIR/t.qcow2.copy', fmt=qcow2 size=67108864 cluster_size=65536 l { 'execute': 'qmp_capabilities' } {"return": {}} { 'execute': 'drive-backup', 'arguments': { 'device': 'disk', 'target': 'TEST_DIR/t.IMGFMT.copy', 'format': 'IMGFMT', 'sync': 'full', 'speed': 65536 } } -Formatting 'TEST_DIR/t.qcow2.copy', fmt=qcow2 size=67108864 cluster_size=65536 lazy_refcounts=off refcount_bits=16 +Formatting 'TEST_DIR/t.qcow2.copy', fmt=qcow2 size=67108864 cluster_size=65536 lazy_refcounts=off extended_l2=off refcount_bits=16 {"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "created", "id": "disk"}} {"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "running", "id": "disk"}} {"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "paused", "id": "disk"}}
tests/qemu-iotests/198.out +2 -0
@@ -72,6 +72,7 @@ Format specific information: key offset: 1810432 payload offset: 2068480 master key iters: 1024 + extended l2: false == checking image layer == image: json:{ /* filtered */ }
@@ -115,4 +116,5 @@ Format specific information: key offset: 1810432 payload offset: 2068480 master key iters: 1024 + extended l2: false *** done
tests/qemu-iotests/206.out +4 -0
@@ -21,6 +21,7 @@ Format specific information: lazy refcounts: false refcount bits: 16 corrupt: false + extended l2: false === Successful image creation (inline blockdev-add, explicit defaults) ===
@@ -43,6 +44,7 @@ Format specific information: lazy refcounts: false refcount bits: 16 corrupt: false + extended l2: false === Successful image creation (v3 non-default options) ===
@@ -65,6 +67,7 @@ Format specific information: lazy refcounts: true refcount bits: 1 corrupt: false + extended l2: false === Successful image creation (v2 non-default options) ===
@@ -141,6 +144,7 @@ Format specific information: payload offset: 528384 master key iters: XXX corrupt: false + extended l2: false === Invalid BlockdevRef ===
tests/qemu-iotests/242.out +5 -0
@@ -15,6 +15,7 @@ Format specific information: lazy refcounts: false refcount bits: 16 corrupt: false + extended l2: false No bitmap in JSON format output
@@ -40,6 +41,7 @@ Format specific information: granularity: 32768 refcount bits: 16 corrupt: false + extended l2: false The same bitmaps in JSON format: [
@@ -77,6 +79,7 @@ Format specific information: granularity: 65536 refcount bits: 16 corrupt: false + extended l2: false The same bitmaps in JSON format: [
@@ -119,6 +122,7 @@ Format specific information: granularity: 65536 refcount bits: 16 corrupt: false + extended l2: false The same bitmaps in JSON format: [
@@ -162,5 +166,6 @@ Format specific information: granularity: 16384 refcount bits: 16 corrupt: false + extended l2: false Test complete
tests/qemu-iotests/255.out +4 -4
@@ -3,9 +3,9 @@ Finishing a commit job with background reads === Create backing chain and start VM === -Formatting 'TEST_DIR/PID-t.qcow2.mid', fmt=qcow2 size=134217728 cluster_size=65536 lazy_refcounts=off refcount_bits=16 +Formatting 'TEST_DIR/PID-t.qcow2.mid', fmt=qcow2 size=134217728 cluster_size=65536 lazy_refcounts=off extended_l2=off refcount_bits=16 -Formatting 'TEST_DIR/PID-t.qcow2', fmt=qcow2 size=134217728 cluster_size=65536 lazy_refcounts=off refcount_bits=16 +Formatting 'TEST_DIR/PID-t.qcow2', fmt=qcow2 size=134217728 cluster_size=65536 lazy_refcounts=off extended_l2=off refcount_bits=16 === Start background read requests ===
@@ -23,9 +23,9 @@ Closing the VM while a job is being cancelled === Create images and start VM === -Formatting 'TEST_DIR/PID-src.qcow2', fmt=qcow2 size=134217728 cluster_size=65536 lazy_refcounts=off refcount_bits=16 +Formatting 'TEST_DIR/PID-src.qcow2', fmt=qcow2 size=134217728 cluster_size=65536 lazy_refcounts=off extended_l2=off refcount_bits=16 -Formatting 'TEST_DIR/PID-dst.qcow2', fmt=qcow2 size=134217728 cluster_size=65536 lazy_refcounts=off refcount_bits=16 +Formatting 'TEST_DIR/PID-dst.qcow2', fmt=qcow2 size=134217728 cluster_size=65536 lazy_refcounts=off extended_l2=off refcount_bits=16 wrote 1048576/1048576 bytes at offset 0 1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
tests/qemu-iotests/274.out +26 -23
138 lines not on this page · raw message
tests/qemu-iotests/280.out +1 -1
@@ -1,4 +1,4 @@ -Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=67108864 cluster_size=65536 lazy_refcounts=off refcount_bits=16 +Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=67108864 cluster_size=65536 lazy_refcounts=off extended_l2=off refcount_bits=16 === Launch VM === Enabling migration QMP events on VM...
tests/qemu-iotests/common.filter +1 -0
@@ -146,6 +146,7 @@ _filter_img_create() -e "s# adapter_type=[^ ]*##g" \ -e "s# hwversion=[^ ]*##g" \ -e "s# lazy_refcounts=\\(on\\|off\\)##g" \ + -e "s# extended_l2=\\(on\\|off\\)##g" \ -e "s# block_size=[0-9]\\+##g" \ -e "s# block_state_zero=\\(on\\|off\\)##g" \ -e "s# log_size=[0-9]\\+##g" \
Signature · 1 line
2.20.1
PATCH v5 14/31 qcow2: Add QCow2SubclusterType and qcow2_get_subcluster_type()
In reply to Alberto GarciaThis 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.
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.
--- block/qcow2.h | 127 +++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 126 insertions(+), 1 deletion(-)
block/qcow2.h +126 -1
@@ -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)) +/* 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) +/* 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)) +/* Size of normal and extended L2 entries */ #define L2E_SIZE_NORMAL (sizeof(uint64_t))#define L2E_SIZE_EXTENDED (sizeof(uint64_t) * 2)
@@ -444,6 +459,33 @@ typedef struct QCowL2MetaQLIST_ENTRY (QCowL2Meta) next_in_flight; } QCowL2Meta; +/* +* In images with standard L2 entries all clusters are treated as if +* they had one subcluster so QCow2ClusterType and QCow2SubclusterType +* can be mapped to each other and have the exact same meaning +* (QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC cannot happen in these images). +* +* In images with extended L2 entries QCow2ClusterType refers to the +* complete cluster and QCow2SubclusterType to each of the individual +* subclusters, so there are several possible combinations: +* +* |--------------+---------------------------| +* | Cluster type | Possible subcluster types | +* |--------------+---------------------------| +* | UNALLOCATED | UNALLOCATED_PLAIN | +* | | ZERO_PLAIN | +* |--------------+---------------------------| +* | NORMAL | UNALLOCATED_ALLOC | +* | | ZERO_ALLOC | +* | | NORMAL | +* |--------------+---------------------------| +* | COMPRESSED | COMPRESSED | +* |--------------+---------------------------| +* +* QCOW2_SUBCLUSTER_INVALID means that the L2 entry is incorrect and +* the image should be marked corrupt. +*/ + typedef enum QCow2ClusterType { QCOW2_CLUSTER_UNALLOCATED, QCOW2_CLUSTER_ZERO_PLAIN,
@@ -452,6 +494,16 @@ typedef enum QCow2ClusterType {QCOW2_CLUSTER_COMPRESSED , } QCow2ClusterType; +typedef enum QCow2SubclusterType { +QCOW2_SUBCLUSTER_UNALLOCATED_PLAIN , +QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC , +QCOW2_SUBCLUSTER_ZERO_PLAIN , +QCOW2_SUBCLUSTER_ZERO_ALLOC , +QCOW2_SUBCLUSTER_NORMAL , +QCOW2_SUBCLUSTER_COMPRESSED , +QCOW2_SUBCLUSTER_INVALID , +}QCow2SubclusterType ; + typedef enum QCow2MetadataOverlap { QCOW2_OL_MAIN_HEADER_BITNR = 0, QCOW2_OL_ACTIVE_L1_BITNR = 1,
@@ -616,9 +668,11 @@ static inline int64_t qcow2_vm_state_offset(BDRVQcow2State *s)static inline QCow2ClusterType qcow2_get_cluster_type (BlockDriverState *bs,uint64_t l2_entry) { +BDRVQcow2State *s = bs->opaque; +if (l2_entry &QCOW_OFLAG_COMPRESSED ) {return QCOW2_CLUSTER_COMPRESSED ; - }else if (l2_entry &QCOW_OFLAG_ZERO ) { + }else if ((l2_entry &QCOW_OFLAG_ZERO ) && !has_subclusters (s)) {if (l2_entry &L2E_OFFSET_MASK ) {return QCOW2_CLUSTER_ZERO_ALLOC ; }
@@ -638,6 +692,77 @@ static inline QCow2ClusterType qcow2_get_cluster_type(BlockDriverState *bs, } } +/* +* For an image without extended L2 entries, return the +* QCow2SubclusterType equivalent of a given QCow2ClusterType. +*/ +static inline +QCow2SubclusterType qcow2_cluster_to_subcluster_type (QCow2ClusterType type) +{ +switch (type) { +case QCOW2_CLUSTER_COMPRESSED : +return QCOW2_SUBCLUSTER_COMPRESSED ; +case QCOW2_CLUSTER_ZERO_PLAIN : +return QCOW2_SUBCLUSTER_ZERO_PLAIN ; +case QCOW2_CLUSTER_ZERO_ALLOC : +return QCOW2_SUBCLUSTER_ZERO_ALLOC ; +case QCOW2_CLUSTER_NORMAL : +return QCOW2_SUBCLUSTER_NORMAL ; +case QCOW2_CLUSTER_UNALLOCATED : +return QCOW2_SUBCLUSTER_UNALLOCATED_PLAIN ; +default : +g_assert_not_reached (); + } +} + +/* +* In an image without subsclusters @l2_bitmap is ignored and +* @sc_index must be 0. +*/ +static inline +QCow2SubclusterType qcow2_get_subcluster_type (BlockDriverState *bs, +uint64_t l2_entry, +uint64_t l2_bitmap, +unsigned sc_index) +{ +BDRVQcow2State *s = bs->opaque; +QCow2ClusterType type =qcow2_get_cluster_type (bs, l2_entry); +assert (sc_index < s->subclusters_per_cluster); + +if (has_subclusters (s)) { +bool sc_zero = l2_bitmap &QCOW_OFLAG_SUB_ZERO (sc_index); +bool sc_alloc = l2_bitmap &QCOW_OFLAG_SUB_ALLOC (sc_index); +switch (type) { +case QCOW2_CLUSTER_COMPRESSED : +return QCOW2_SUBCLUSTER_COMPRESSED ; +case QCOW2_CLUSTER_NORMAL : +if (!sc_zero && !sc_alloc) { +return QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC ; + }else if (!sc_zero && sc_alloc) { +return QCOW2_SUBCLUSTER_NORMAL ; + }else if (sc_zero && !sc_alloc) { +return QCOW2_SUBCLUSTER_ZERO_ALLOC ; + }else {/* sc_zero && sc_alloc */ +return QCOW2_SUBCLUSTER_INVALID ; + } +case QCOW2_CLUSTER_UNALLOCATED : +if (!sc_zero && !sc_alloc) { +return QCOW2_SUBCLUSTER_UNALLOCATED_PLAIN ; + }else if (!sc_zero && sc_alloc) { +return QCOW2_SUBCLUSTER_INVALID ; + }else if (sc_zero && !sc_alloc) { +return QCOW2_SUBCLUSTER_ZERO_PLAIN ; + }else {/* sc_zero && sc_alloc */ +return QCOW2_SUBCLUSTER_INVALID ; + } +default : +g_assert_not_reached (); + } + }else { +return qcow2_cluster_to_subcluster_type (type); + } +} +/* Check whether refcounts are eager or lazy */ static inline bool qcow2_need_accurate_refcounts (BDRVQcow2State *s) {
Signature · 1 line
2.20.1
PATCH v5 27/31 qcow2: Add subcluster support to qcow2_co_pwrite_zeroes()
In reply to Alberto GarciaThis works now at the subcluster level and pwrite_zeroes_alignment is updated accordingly.
qcow2_cluster_zeroize() is turned into qcow2_subcluster_zeroize() with the following changes:
- The request can now be subcluster-aligned.
- The cluster-aligned body of the request is still zeroized using zero_in_l2_slice() as before.
- The subcluster-aligned head and tail of the request are zeroized with the new zero_l2_subclusters() function.
There is just one thing to take into account for a possible future
improvement: compressed clusters cannot be partially zeroized so zero_l2_subclusters() on the head or the tail can return -ENOTSUP. This makes the caller repeat the *complete* request and write actual zeroes to disk. This is sub-optimal because
1) if the head area was compressed we would still be able to use the fast path for the body and possibly the tail.
2) if the tail area was compressed we are writing zeroes to the head and the body areas, which are already zeroized.
--- block/qcow2.h | 4 +-- block/qcow2-cluster.c | 80 +++++++++++++++++++++++++++++++++++++++---- block/qcow2.c | 27 ++++++++------- 3 files changed, 90 insertions(+), 21 deletions(-)
block/qcow2.h +2 -2
@@ -881,8 +881,8 @@ void qcow2_alloc_cluster_abort(BlockDriverState *bs, QCowL2Meta *m);int qcow2_cluster_discard (BlockDriverState *bs,uint64_t offset,uint64_t bytes,enum qcow2_discard_type type,bool full_discard); -int qcow2_cluster_zeroize (BlockDriverState *bs,uint64_t offset, -uint64_t bytes,int flags); +int qcow2_subcluster_zeroize (BlockDriverState *bs,uint64_t offset, +uint64_t bytes,int flags); int qcow2_expand_zero_clusters(BlockDriverState *bs, BlockDriverAmendStatusCB *status_cb,
block/qcow2-cluster.c +74 -6
111 lines not on this page · raw message
block/qcow2.c +14 -13
@@ -1843,7 +1843,7 @@ static void qcow2_refresh_limits(BlockDriverState *bs, Error **errp)/* Encryption works on a sector granularity */ bs->bl.request_alignment =qcrypto_block_get_sector_size (s->crypto); } - bs->bl.pwrite_zeroes_alignment = s->cluster_size; + bs->bl.pwrite_zeroes_alignment = s->subcluster_size; bs->bl.pdiscard_alignment = s->cluster_size; }
@@ -3736,8 +3736,9 @@ static coroutine_fn int qcow2_co_pwrite_zeroes(BlockDriverState *bs,int ret;BDRVQcow2State *s = bs->opaque; -uint32_t head = offset % s->cluster_size; -uint32_t tail = (offset + bytes) % s->cluster_size; +uint32_t head =offset_into_subcluster (s, offset); +uint32_t tail =ROUND_UP (offset + bytes, s->subcluster_size) - + (offset + bytes);trace_qcow2_pwrite_zeroes_start_req (qemu_coroutine_self (), offset, bytes);if (offset + bytes == bs->total_sectors *BDRV_SECTOR_SIZE ) {
@@ -3749,20 +3750,19 @@ static coroutine_fn int qcow2_co_pwrite_zeroes(BlockDriverState *bs,unsigned int nr;QCow2SubclusterType type; -assert (head + bytes <= s->cluster_size); +assert (head + bytes + tail <= s->subcluster_size);/* check whether remainder of cluster already reads as zero */ if (!(is_zero (bs, offset - head, head) && -is_zero (bs, offset + bytes, - tail ? s->cluster_size - tail :0 ))) { +is_zero (bs, offset + bytes, tail))) {return -ENOTSUP ; }qemu_co_mutex_lock (&s->lock);/* We can have new write after previous check */ - offset =QEMU_ALIGN_DOWN (offset, s->cluster_size); - bytes = s->cluster_size; - nr = s->cluster_size; + offset -= head; + bytes = s->subcluster_size; + nr = s->subcluster_size; ret =qcow2_get_host_offset (bs, offset, &nr, &off, &type); if (ret < 0 || (type != QCOW2_SUBCLUSTER_UNALLOCATED_PLAIN &&
@@ -3778,8 +3778,8 @@ static coroutine_fn int qcow2_co_pwrite_zeroes(BlockDriverState *bs,trace_qcow2_pwrite_zeroes (qemu_coroutine_self (), offset, bytes); -/* Whatever is left can use real zero clusters */ - ret =qcow2_cluster_zeroize (bs, offset, bytes, flags); +/* Whatever is left can use real zero subclusters */ + ret =qcow2_subcluster_zeroize (bs, offset, bytes, flags);qemu_co_mutex_unlock (&s->lock);return ret;
@@ -4243,12 +4243,13 @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,uint64_t zero_start =QEMU_ALIGN_UP (old_length, s->cluster_size);/* -* Use zero clusters as much as we can. qcow2_cluster_zeroize() +* Use zero clusters as much as we can. qcow2_subcluster_zeroize() * requires a cluster-aligned start. The end may be unaligned if it is * at the end of the image (which it is here). */ if (offset > zero_start) { - ret =qcow2_cluster_zeroize (bs, zero_start, offset - zero_start,0 ); + ret =qcow2_subcluster_zeroize (bs, zero_start, offset - zero_start, +0 );if (ret <0 ) {error_setg_errno (errp, -ret,"Failed to zero out new clusters" ); goto fail;
Signature · 1 line
2.20.1
PATCH v5 5/31 qcow2: Process QCOW2_CLUSTER_ZERO_ALLOC clusters in handle_copied()
In reply to Alberto GarciaWhen writing to a qcow2 file there are two functions that take a virtual offset and return a host offset, possibly allocating new clusters if necessary:
- handle_copied() looks for normal data clusters that are already allocated and have a reference count of 1. In those clusters we can simply write the data and there is no need to perform any copy-on-write.
- handle_alloc() looks for clusters that do need copy-on-write, either because they haven't been allocated yet, because their reference count is != 1 or because they are ZERO_ALLOC clusters.
The ZERO_ALLOC case is a bit special because those are clusters that are already allocated and they could perfectly be dealt with in handle_copied() (as long as copy-on-write is performed when required).
In fact, there is extra code specifically for them in handle_alloc() that tries to reuse the existing allocation if possible and frees them otherwise.
This patch changes the handling of ZERO_ALLOC clusters so the semantics of these two functions are now like this:
- handle_copied() looks for clusters that are already allocated and which we can overwrite (NORMAL and ZERO_ALLOC clusters with a reference count of 1).
- handle_alloc() looks for clusters for which we need a new allocation (all other cases).
One important difference after this change is that clusters found in handle_copied() may now require copy-on-write, but this will be necessary anyway once we add support for subclusters.
--- block/qcow2-cluster.c | 256 +++++++++++++++++++++++------------------- 1 file changed, 141 insertions(+), 115 deletions(-)
block/qcow2-cluster.c +141 -115
@@ -1039,13 +1039,18 @@ void qcow2_alloc_cluster_abort(BlockDriverState *bs, QCowL2Meta *m)/* * For a given write request, create a new QCowL2Meta structure, add -* it to @m and the BDRVQcow2State.cluster_allocs list. +* it to @m and the BDRVQcow2State.cluster_allocs list. If the write +* request does not need copy-on-write or changes to the L2 metadata +* then this function does nothing. * * @host_cluster_offset points to the beginning of the first cluster. * * @guest_offset and @bytes indicate the offset and length of the * request. * +* @l2_slice contains the L2 entries of all clusters involved in this +* write request. +* * If @keep_old is true it means that the clusters were already * allocated and will be overwritten. If false then the clusters are * new and we have to decrease the reference count of the old ones.
@@ -1053,15 +1058,53 @@ void qcow2_alloc_cluster_abort(BlockDriverState *bs, QCowL2Meta *m)static void calculate_l2_meta (BlockDriverState *bs,uint64_t host_cluster_offset,uint64_t guest_offset,unsigned bytes, -QCowL2Meta **m,bool keep_old) +uint64_t *l2_slice,QCowL2Meta **m,bool keep_old) {BDRVQcow2State *s = bs->opaque; -unsigned cow_start_from =0 ; +int l2_index =offset_to_l2_slice_index (s, guest_offset); +uint64_t l2_entry; +unsigned cow_start_from, cow_end_to;unsigned cow_start_to =offset_into_cluster (s, guest_offset);unsigned cow_end_from = cow_start_to + bytes; -unsigned cow_end_to =ROUND_UP (cow_end_from, s->cluster_size);unsigned nb_clusters =size_to_clusters (s, cow_end_from);QCowL2Meta *old_m = *m; +QCow2ClusterType type; + +assert (nb_clusters <= s->l2_slice_size - l2_index); + +/* Return if there's no COW (all clusters are normal and we keep them) */ +if (keep_old) { +int i; +for (i =0 ; i < nb_clusters; i++) { + l2_entry =be64_to_cpu (l2_slice[l2_index + i]); +if (qcow2_get_cluster_type (bs, l2_entry) !=QCOW2_CLUSTER_NORMAL ) { +break ; + } + } +if (i == nb_clusters) { +return ; + } + } + +/* Get the L2 entry of the first cluster */ + l2_entry =be64_to_cpu (l2_slice[l2_index]); + type =qcow2_get_cluster_type (bs, l2_entry); + +if (type ==QCOW2_CLUSTER_NORMAL && keep_old) { + cow_start_from = cow_start_to; + }else { + cow_start_from =0 ; + } + +/* Get the L2 entry of the last cluster */ + l2_entry =be64_to_cpu (l2_slice[l2_index + nb_clusters -1 ]); + type =qcow2_get_cluster_type (bs, l2_entry); + +if (type ==QCOW2_CLUSTER_NORMAL && keep_old) { + cow_end_to = cow_end_from; + }else { + cow_end_to =ROUND_UP (cow_end_from, s->cluster_size); + } *m =g_malloc0 (sizeof (**m)); **m = (QCowL2Meta ) {
@@ -1087,18 +1130,22 @@ static void calculate_l2_meta(BlockDriverState *bs,QLIST_INSERT_HEAD (&s->cluster_allocs, *m, next_in_flight); } -/* Returns true if writing to a cluster requires COW */ -static bool cluster_needs_cow (BlockDriverState *bs,uint64_t l2_entry) +/* +* Returns true if writing to the cluster pointed to by @l2_entry +* requires a new allocation (that is, if the cluster is unallocated +* or has refcount > 1 and therefore cannot be written in-place). +*/ +static bool cluster_needs_new_alloc (BlockDriverState *bs,uint64_t l2_entry) {switch (qcow2_get_cluster_type (bs, l2_entry)) {case QCOW2_CLUSTER_NORMAL : +case QCOW2_CLUSTER_ZERO_ALLOC :if (l2_entry &QCOW_OFLAG_COPIED ) {return false; }case QCOW2_CLUSTER_UNALLOCATED :case QCOW2_CLUSTER_COMPRESSED :case QCOW2_CLUSTER_ZERO_PLAIN : -case QCOW2_CLUSTER_ZERO_ALLOC :return true;default :abort ();
@@ -1106,20 +1153,38 @@ static bool cluster_needs_cow(BlockDriverState *bs, uint64_t l2_entry) }/* -* Returns the number of contiguous clusters that can be used for an allocating -* write, but require COW to be performed (this includes yet unallocated space, -* which must copy from the backing file) +* Returns the number of contiguous clusters that can be written to +* using one single write request, starting from @l2_index. +* At most @nb_clusters are checked. +* +* If @new_alloc is true this counts clusters that are either +* unallocated, or allocated but with refcount > 1 (so they need to be +* newly allocated and COWed). +* +* If @new_alloc is false this counts clusters that are already +* allocated and can be overwritten in-place (this includes clusters +* of type QCOW2_CLUSTER_ZERO_ALLOC). */ -static int count_cow_clusters (BlockDriverState *bs,int nb_clusters, -uint64_t *l2_slice,int l2_index) +static int count_single_write_clusters (BlockDriverState *bs,int nb_clusters, +uint64_t *l2_slice,int l2_index, +bool new_alloc) { +BDRVQcow2State *s = bs->opaque; +uint64_t l2_entry =be64_to_cpu (l2_slice[l2_index]); +uint64_t expected_offset = l2_entry &L2E_OFFSET_MASK ;int i;for (i =0 ; i < nb_clusters; i++) { -uint64_t l2_entry =be64_to_cpu (l2_slice[l2_index + i]); -if (!cluster_needs_cow (bs, l2_entry)) { + l2_entry =be64_to_cpu (l2_slice[l2_index + i]); +if (cluster_needs_new_alloc (bs, l2_entry) != new_alloc) {break ; } +if (!new_alloc) { +if (expected_offset != (l2_entry &L2E_OFFSET_MASK )) { +break ; + } + expected_offset += s->cluster_size; + } }assert (i <= nb_clusters);
@@ -1190,10 +1255,10 @@ static int handle_dependencies(BlockDriverState *bs, uint64_t guest_offset, }/* -* Checks how many already allocated clusters that don't require a copy on -* write there are at the given guest_offset (up to *bytes). If *host_offset is -* not INV_OFFSET, only physically contiguous clusters beginning at this host -* offset are counted. +* Checks how many already allocated clusters that don't require a new +* allocation there are at the given guest_offset (up to *bytes). +* If *host_offset is not INV_OFFSET, only physically contiguous clusters +* beginning at this host offset are counted. * * Note that guest_offset may not be cluster aligned. In this case, the * returned *host_offset points to exact byte referenced by guest_offset and
@@ -1202,12 +1267,12 @@ static int handle_dependencies(BlockDriverState *bs, uint64_t guest_offset,* Returns: * 0: if no allocated clusters are available at the given offset. * *bytes is normally unchanged. It is set to 0 if the cluster -* is allocated and doesn't need COW, but doesn't have the right -* physical offset. +* is allocated and can be overwritten in-place but doesn't have +* the right physical offset. * -* 1: if allocated clusters that don't require a COW are available at -* the requested offset. *bytes may have decreased and describes -* the length of the area that can be written to. +* 1: if allocated clusters that can be overwritten in place are +* available at the requested offset. *bytes may have decreased +* and describes the length of the area that can be written to. * * -errno: in error cases */
@@ -1216,7 +1281,7 @@ static int handle_copied(BlockDriverState *bs, uint64_t guest_offset, {BDRVQcow2State *s = bs->opaque;int l2_index; -uint64_t cluster_offset; +uint64_t l2_entry, cluster_offset;uint64_t *l2_slice;uint64_t nb_clusters;unsigned int keep_clusters;
@@ -1237,7 +1302,8 @@ static int handle_copied(BlockDriverState *bs, uint64_t guest_offset, l2_index =offset_to_l2_slice_index (s, guest_offset); nb_clusters =MIN (nb_clusters, s->l2_slice_size - l2_index); -assert (nb_clusters <=INT_MAX ); +/* Limit total byte count to BDRV_REQUEST_MAX_BYTES */ + nb_clusters =MIN (nb_clusters,BDRV_REQUEST_MAX_BYTES >> s->cluster_bits);/* Find L2 entry for the first involved cluster */ ret =get_cluster_table (bs, guest_offset, &l2_slice, &l2_index);
@@ -1245,41 +1311,39 @@ static int handle_copied(BlockDriverState *bs, uint64_t guest_offset,return ret; } - cluster_offset =be64_to_cpu (l2_slice[l2_index]); + l2_entry =be64_to_cpu (l2_slice[l2_index]); + cluster_offset = l2_entry &L2E_OFFSET_MASK ; + +if (!cluster_needs_new_alloc (bs, l2_entry)) { +if (offset_into_cluster (s, cluster_offset)) { +qcow2_signal_corruption (bs, true,-1 ,-1 ,"%s cluster offset " +"%#" PRIx64" unaligned (guest offset: %#" + PRIx64")" , l2_entry &QCOW_OFLAG_ZERO ? +"Preallocated zero" :"Data" , + cluster_offset, guest_offset); + ret = -EIO ; + goto out; + } -/* Check how many clusters are already allocated and don't need COW */ -if (qcow2_get_cluster_type (bs, cluster_offset) ==QCOW2_CLUSTER_NORMAL - && (cluster_offset &QCOW_OFLAG_COPIED )) - {/* If a specific host_offset is required, check it */ -bool offset_matches = - (cluster_offset &L2E_OFFSET_MASK ) == *host_offset; - -if (offset_into_cluster (s, cluster_offset &L2E_OFFSET_MASK )) { -qcow2_signal_corruption (bs, true,-1 ,-1 ,"Data cluster offset " -"%#llx unaligned (guest offset: %#" PRIx64 -")" , cluster_offset &L2E_OFFSET_MASK , - guest_offset); - ret = -EIO ; - goto out; - } - -if (*host_offset !=INV_OFFSET && !offset_matches) { +if (*host_offset !=INV_OFFSET && cluster_offset != *host_offset) { *bytes =0 ; ret =0 ; goto out; }/* We keep all QCOW_OFLAG_COPIED clusters */ - keep_clusters = -count_contiguous_clusters (bs, nb_clusters, s->cluster_size, - &l2_slice[l2_index], -QCOW_OFLAG_COPIED |QCOW_OFLAG_ZERO ); + keep_clusters =count_single_write_clusters (bs, nb_clusters, l2_slice, + l2_index, false);assert (keep_clusters <= nb_clusters); *bytes =MIN (*bytes, keep_clusters * s->cluster_size -offset_into_cluster (s, guest_offset)); +assert (*bytes !=0 ); + +calculate_l2_meta (bs, cluster_offset, guest_offset, + *bytes, l2_slice, m, true); ret =1 ; }else {
@@ -1293,8 +1357,7 @@ out:/* Only return a host offset if we actually made progress. Otherwise we * would make requirements for handle_alloc() that it can't fulfill */ if (ret >0 ) { - *host_offset = (cluster_offset &L2E_OFFSET_MASK ) - +offset_into_cluster (s, guest_offset); + *host_offset = cluster_offset +offset_into_cluster (s, guest_offset); }return ret;
@@ -1355,9 +1418,10 @@ static int do_alloc_cluster_offset(BlockDriverState *bs, uint64_t guest_offset, }/* -* Allocates new clusters for an area that either is yet unallocated or needs a -* copy on write. If *host_offset is not INV_OFFSET, clusters are only -* allocated if the new allocation can match the specified host offset. +* Allocates new clusters for an area that is either still unallocated or +* cannot be overwritten in-place. If *host_offset is not INV_OFFSET, +* clusters are only allocated if the new allocation can match the specified +* host offset. * * Note that guest_offset may not be cluster aligned. In this case, the * returned *host_offset points to exact byte referenced by guest_offset and
@@ -1380,12 +1444,10 @@ static int handle_alloc(BlockDriverState *bs, uint64_t guest_offset,BDRVQcow2State *s = bs->opaque;int l2_index;uint64_t *l2_slice; -uint64_t entry;uint64_t nb_clusters;int ret; -bool keep_old_clusters = false; -uint64_t alloc_cluster_offset =INV_OFFSET ; +uint64_t alloc_cluster_offset;trace_qcow2_handle_alloc (qemu_coroutine_self (), guest_offset, *host_offset, *bytes);
@@ -1400,10 +1462,8 @@ static int handle_alloc(BlockDriverState *bs, uint64_t guest_offset, l2_index =offset_to_l2_slice_index (s, guest_offset); nb_clusters =MIN (nb_clusters, s->l2_slice_size - l2_index); -assert (nb_clusters <=INT_MAX ); - -/* Limit total allocation byte count to INT_MAX */ - nb_clusters =MIN (nb_clusters,INT_MAX >> s->cluster_bits); +/* Limit total allocation byte count to BDRV_REQUEST_MAX_BYTES */ + nb_clusters =MIN (nb_clusters,BDRV_REQUEST_MAX_BYTES >> s->cluster_bits);/* Find L2 entry for the first involved cluster */ ret =get_cluster_table (bs, guest_offset, &l2_slice, &l2_index);
@@ -1411,67 +1471,32 @@ static int handle_alloc(BlockDriverState *bs, uint64_t guest_offset,return ret; } - entry =be64_to_cpu (l2_slice[l2_index]); - nb_clusters =count_cow_clusters (bs, nb_clusters, l2_slice, l2_index); + nb_clusters =count_single_write_clusters (bs, nb_clusters, + l2_slice, l2_index, true);/* This function is only called when there were no non-COW clusters, so if * we can't find any unallocated or COW clusters either, something is * wrong with our code. */ assert (nb_clusters >0 ); -if (qcow2_get_cluster_type (bs, entry) ==QCOW2_CLUSTER_ZERO_ALLOC && - (entry &QCOW_OFLAG_COPIED ) && - (*host_offset ==INV_OFFSET || -start_of_cluster (s, *host_offset) == (entry &L2E_OFFSET_MASK ))) - { -int preallocated_nb_clusters; - -if (offset_into_cluster (s, entry &L2E_OFFSET_MASK )) { -qcow2_signal_corruption (bs, true,-1 ,-1 ,"Preallocated zero " -"cluster offset %#llx unaligned (guest " -"offset: %#" PRIx64")" , - entry &L2E_OFFSET_MASK , guest_offset); - ret = -EIO ; - goto fail; - } - -/* Try to reuse preallocated zero clusters; contiguous normal clusters -* would be fine, too, but count_cow_clusters() above has limited -* nb_clusters already to a range of COW clusters */ - preallocated_nb_clusters = -count_contiguous_clusters (bs, nb_clusters, s->cluster_size, - &l2_slice[l2_index],QCOW_OFLAG_COPIED ); -assert (preallocated_nb_clusters >0 ); - - nb_clusters = preallocated_nb_clusters; - alloc_cluster_offset = entry &L2E_OFFSET_MASK ; - -/* We want to reuse these clusters, so qcow2_alloc_cluster_link_l2() -* should not free them. */ - keep_old_clusters = true; +/* Allocate at a given offset in the image file */ + alloc_cluster_offset = *host_offset ==INV_OFFSET ?INV_OFFSET : +start_of_cluster (s, *host_offset); + ret =do_alloc_cluster_offset (bs, guest_offset, &alloc_cluster_offset, + &nb_clusters); +if (ret <0 ) { + goto out; } -qcow2_cache_put (s->l2_table_cache, (void **) &l2_slice); - -if (alloc_cluster_offset ==INV_OFFSET ) { -/* Allocate, if necessary at a given offset in the image file */ - alloc_cluster_offset = *host_offset ==INV_OFFSET ?INV_OFFSET : -start_of_cluster (s, *host_offset); - ret =do_alloc_cluster_offset (bs, guest_offset, &alloc_cluster_offset, - &nb_clusters); -if (ret <0 ) { - goto fail; - } - -/* Can't extend contiguous allocation */ -if (nb_clusters ==0 ) { - *bytes =0 ; -return 0 ; - } - -assert (alloc_cluster_offset !=INV_OFFSET ); +/* Can't extend contiguous allocation */ +if (nb_clusters ==0 ) { + *bytes =0 ; + ret =0 ; + goto out; } +assert (alloc_cluster_offset !=INV_OFFSET ); +/* * Save info needed for meta data update. *
@@ -1494,13 +1519,14 @@ static int handle_alloc(BlockDriverState *bs, uint64_t guest_offset, *bytes =MIN (*bytes, nb_bytes -offset_into_cluster (s, guest_offset));assert (*bytes !=0 ); -calculate_l2_meta (bs, alloc_cluster_offset, guest_offset, *bytes, - m, keep_old_clusters); +calculate_l2_meta (bs, alloc_cluster_offset, guest_offset, *bytes, l2_slice, + m, false); -return 1 ; + ret =1 ; -fail: -if (*m && (*m)->nb_clusters >0 ) { +out: +qcow2_cache_put (s->l2_table_cache, (void **) &l2_slice); +if (ret <0 && *m && (*m)->nb_clusters >0 ) {QLIST_REMOVE (*m, next_in_flight); }return ret;
Signature · 1 line
2.20.1
PATCH v5 31/31 iotests: Add tests for qcow2 images with extended L2 entries
In reply to Alberto Garcia--- tests/qemu-iotests/271 | 664 +++++++++++++++++++++++++++++++++++++ tests/qemu-iotests/271.out | 519 +++++++++++++++++++++++++++++ tests/qemu-iotests/group | 1 + 3 files changed, 1184 insertions(+) create mode 100755 tests/qemu-iotests/271 create mode 100644 tests/qemu-iotests/271.out
tests/qemu-iotests/271 new file +664 -0
@@ -0,0 +1,664 @@ +#!/bin/bash +# +# Test qcow2 images with extended L2 entries +# +# Copyright (C) 2019-2020 Igalia, S.L. +# Author: Alberto Garcia <[email protected]> +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see <http://www.gnu.org/licenses/>. +# + +# creator [email protected] + +seq="$(basename $0)" +echo "QA output created by $seq" + +here="$PWD" +status=1 # failure is the default! + +_cleanup() +{ + _cleanup_test_img + rm -f "$TEST_IMG.raw" +} +trap "_cleanup; exit \$status" 0 1 2 3 15 + +# get standard environment, filters and checks +. ./common.rc +. ./common.filter + +_supported_fmt qcow2 +_supported_proto file nfs +_supported_os Linux +_unsupported_imgopts extended_l2 compat=0.10 cluster_size data_file + +l2_offset=262144 # 0x40000 + +_verify_img() +{ + $QEMU_IMG compare "$TEST_IMG" "$TEST_IMG.raw" | grep -v 'Images are identical' + $QEMU_IMG check "$TEST_IMG" | _filter_qemu_img_check | \ + grep -v 'No errors were found on the image' +} + +# Compare the bitmap of an extended L2 entry against an expected value +_verify_l2_bitmap() +{ + entry_no="$1" # L2 entry number, starting from 0 + expected_alloc="$2" # Space-separated list of allocated subcluster indexes + expected_zero="$3" # Space-separated list of zero subcluster indexes + + offset=$(($l2_offset + $entry_no * 16)) + entry=`peek_file_be "$TEST_IMG" $offset 8` + offset=$(($offset + 8)) + bitmap=`peek_file_be "$TEST_IMG" $offset 8` + + expected_bitmap=0 + for bit in $expected_alloc; do + expected_bitmap=$(($expected_bitmap | (1 << $bit))) + done + for bit in $expected_zero; do + expected_bitmap=$(($expected_bitmap | (1 << (32 + $bit)))) + done + expected_bitmap=`printf "%llu" $expected_bitmap` + + printf "L2 entry #%d: 0x%016lx %016lx\n" "$entry_no" "$entry" "$bitmap" + if [ "$bitmap" != "$expected_bitmap" ]; then + printf "ERROR: expecting bitmap 0x%016lx\n" "$expected_bitmap" + fi +} + +_test_write() +{ + cmd="$1" + alloc_bitmap="$2" + zero_bitmap="$3" + l2_entry_idx="$4" + [ -n "$l2_entry_idx" ] || l2_entry_idx=0 + raw_cmd=`echo $cmd | sed s/-c//` # Raw images don't support -c + echo "$cmd" + $QEMU_IO -c "$cmd" "$TEST_IMG" | _filter_qemu_io + $QEMU_IO -c "$raw_cmd" -f raw "$TEST_IMG.raw" | _filter_qemu_io + _verify_img + _verify_l2_bitmap "$l2_entry_idx" "$alloc_bitmap" "$zero_bitmap" +} + +_reset_img() +{ + size="$1" + $QEMU_IMG create -f raw "$TEST_IMG.raw" "$size" | _filter_img_create + if [ "$use_backing_file" = "yes" ]; then + $QEMU_IMG create -f raw "$TEST_IMG.base" "$size" | _filter_img_create + $QEMU_IO -c "write -q -P 0xFF 0 $size" -f raw "$TEST_IMG.base" | _filter_qemu_io + $QEMU_IO -c "write -q -P 0xFF 0 $size" -f raw "$TEST_IMG.raw" | _filter_qemu_io + _make_test_img -o extended_l2=on -b "$TEST_IMG.base" "$size" + else + _make_test_img -o extended_l2=on "$size" + fi +} + +# Test that writing to an image with subclusters produces the expected +# results, in images with and without backing files +for use_backing_file in yes no; do + echo + echo "### Standard write tests (backing file: $use_backing_file) ###" + echo + _reset_img 1M + ### Write subcluster #0 (beginning of subcluster) ### + alloc="0"; zero="" + _test_write 'write -q -P 1 0 1k' "$alloc" "$zero" + + ### Write subcluster #1 (middle of subcluster) ### + alloc="0 1"; zero="" + _test_write 'write -q -P 2 3k 512' "$alloc" "$zero" + + ### Write subcluster #2 (end of subcluster) ### + alloc="0 1 2"; zero="" + _test_write 'write -q -P 3 5k 1k' "$alloc" "$zero" + + ### Write subcluster #3 (full subcluster) ### + alloc="0 1 2 3"; zero="" + _test_write 'write -q -P 4 6k 2k' "$alloc" "$zero" + + ### Write subclusters #4-6 (full subclusters) ### + alloc="`seq 0 6`"; zero="" + _test_write 'write -q -P 5 8k 6k' "$alloc" "$zero" + + ### Write subclusters #7-9 (partial subclusters) ### + alloc="`seq 0 9`"; zero="" + _test_write 'write -q -P 6 15k 4k' "$alloc" "$zero" + + ### Write subcluster #16 (partial subcluster) ### + alloc="`seq 0 9` 16"; zero="" + _test_write 'write -q -P 7 32k 1k' "$alloc" "$zero" + + ### Write subcluster #31-#33 (cluster overlap) ### + alloc="`seq 0 9` 16 31"; zero="" + _test_write 'write -q -P 8 63k 4k' "$alloc" "$zero" + alloc="0 1" ; zero="" + _verify_l2_bitmap 1 "$alloc" "$zero" + + ### Zero subcluster #1 + alloc="0 `seq 2 9` 16 31"; zero="1" + _test_write 'write -q -z 2k 2k' "$alloc" "$zero" + + ### Zero cluster #0 + alloc=""; zero="`seq 0 31`" + _test_write 'write -q -z 0 64k' "$alloc" "$zero" + + ### Fill cluster #0 with data + alloc="`seq 0 31`"; zero="" + _test_write 'write -q -P 9 0 64k' "$alloc" "$zero" + + ### Zero and unmap half of cluster #0 (this won't unmap it) + alloc="`seq 16 31`"; zero="`seq 0 15`" + _test_write 'write -q -z -u 0 32k' "$alloc" "$zero" + + ### Zero and unmap cluster #0 + alloc=""; zero="`seq 0 31`" + _test_write 'write -q -z -u 0 64k' "$alloc" "$zero" + + ### Write subcluster #1 (middle of subcluster) + alloc="1"; zero="0 `seq 2 31`" + _test_write 'write -q -P 10 3k 512' "$alloc" "$zero" + + ### Fill cluster #0 with data + alloc="`seq 0 31`"; zero="" + _test_write 'write -q -P 11 0 64k' "$alloc" "$zero" + + ### Discard cluster #0 + alloc=""; zero="`seq 0 31`" + _test_write 'discard -q 0 64k' "$alloc" "$zero" + + ### Write compressed data to cluster #0 + alloc=""; zero="" + _test_write 'write -q -c -P 12 0 64k' "$alloc" "$zero" + + ### Write subcluster #2 (middle of subcluster) + alloc="`seq 0 31`"; zero="" + _test_write 'write -q -P 13 3k 512' "$alloc" "$zero" + + ################################################################ + # Test full and partial zero writes to unallocated subclusters # + ################################################################ + ### Zeroize an unallocated cluster (#2) + alloc=""; zero="`seq 0 31`" + _test_write 'write -q -z 128k 64k' "$alloc" "$zero" 2 + + ### Partially zeroize an unallocated cluster (#3) + alloc=""; zero="`seq 0 15`" + _test_write 'write -q -z 192k 32k' "$alloc" "$zero" 3 + + ### Partially zeroize an unallocated cluster (#4) + alloc=""; zero="`seq 8 23`" + _test_write 'write -q -z 272k 32k' "$alloc" "$zero" 4 + + ### Partially zeroize an unallocated cluster (#5) + alloc=""; zero="`seq 16 31`" + _test_write 'write -q -z 352k 32k' "$alloc" "$zero" 5 + + ### Zeroize cluster #4 with head in #3 and tail in #5 + alloc=""; zero="`seq 0 15` 30 31" + _test_write 'write -q -z 252k 72k' "$alloc" "$zero" 3 + alloc=""; zero="`seq 0 31`" + _verify_l2_bitmap 4 "$alloc" "$zero" + alloc=""; zero="0 1 `seq 16 31`" + _verify_l2_bitmap 5 "$alloc" "$zero" + + ### Zeroize part of subcluster #4 from cluster #5 (unaligned write). + ### If there's a backing file we have to perform cow on subcluster #4, + ### otherwise we can zero the complete subcluster + if [ "$use_backing_file" = "yes" ]; then + alloc="4"; zero="0 1 `seq 16 31`" + else + alloc=""; zero="0 1 4 `seq 16 31`" + fi + _test_write 'write -q -z 329k 512' "$alloc" "$zero" 5 + + ################################################################### + # Repeat the zero writes, this time with fully allocated clusters # + ################################################################### + ### Fill clusters #2 to #5 with data + alloc="`seq 0 31`"; zero="" + _test_write 'write -q -P 14 128k 256k' "$alloc" "$zero" 2 + _verify_l2_bitmap 3 "$alloc" "$zero" + _verify_l2_bitmap 4 "$alloc" "$zero" + _verify_l2_bitmap 5 "$alloc" "$zero" + + ### Zeroize an allocated cluster (#2) + alloc=""; zero="`seq 0 31`" + _test_write 'write -q -z 128k 64k' "$alloc" "$zero" 2 + + ### Partially zeroize an allocated cluster (#3) + alloc="`seq 16 31`"; zero="`seq 0 15`" + _test_write 'write -q -z 192k 32k' "$alloc" "$zero" 3 + + ### Partially zeroize an allocated cluster (#4) + alloc="`seq 0 7` `seq 24 31`"; zero="`seq 8 23`" + _test_write 'write -q -z 272k 32k' "$alloc" "$zero" 4 + + ### Partially zeroize an allocated cluster (#5) + alloc="`seq 0 15`"; zero="`seq 16 31`" + _test_write 'write -q -z 352k 32k' "$alloc" "$zero" 5 + + ### Zeroize cluster #4 with head in #3 and tail in #5 + alloc="`seq 16 29`"; zero="`seq 0 15` 30 31" + _test_write 'write -q -z 252k 72k' "$alloc" "$zero" 3 + alloc=""; zero="`seq 0 31`" + _verify_l2_bitmap 4 "$alloc" "$zero" + alloc="`seq 2 15`"; zero="0 1 `seq 16 31`" + _verify_l2_bitmap 5 "$alloc" "$zero" + + #### + + alloc=""; zero="`seq 0 31`" + _test_write 'discard -q 0 64k' "$alloc" "$zero" + alloc=""; zero="" + _test_write 'write -q -c -P 15 0 64k' "$alloc" "$zero" + + alloc="`seq 0 31`"; zero="" + _test_write 'write -q -P 15 64k 64k' "$alloc" "$zero" 1 + + # This should set the ZERO bit in half of the subclusters of each cluster + # alloc="`seq 0 15`"; zero="`seq 16 31`" + alloc="`seq 0 31`"; zero="" + _test_write 'write -q -z 32k 64k' "$alloc" "$zero" 0 + # This should set the ZERO bit in half of the subclusters of each cluster + # alloc="`seq 16 31`"; zero="`seq 0 15`" + alloc="`seq 0 31`"; zero="" + _verify_l2_bitmap 1 "$alloc" "$zero" + + #### + + alloc=""; zero="`seq 0 31`" + _test_write 'discard -q 0 64k' "$alloc" "$zero" + alloc=""; zero="" + _test_write 'write -q -c -P 15 0 64k' "$alloc" "$zero" + + alloc="`seq 0 31`"; zero="" + _test_write 'write -q -P 15 64k 64k' "$alloc" "$zero" 1 + + # This correctly sets the ZERO bit in half of the subclusters of each cluster + alloc="`seq 0 15`"; zero="`seq 16 31`" + _test_write 'write -q -z 31k 65k' "$alloc" "$zero" 0 + # This correctly sets the ZERO bit in half of the subclusters of each cluster + alloc="`seq 16 31`"; zero="`seq 0 15`" + _verify_l2_bitmap 1 "$alloc" "$zero" +done + +for use_backing_file in yes no; do + echo + echo "### Writing zeroes (backing file: $use_backing_file) ###" + echo + # Note that the image size is not a multiple of the cluster size + _reset_img 2083k + + # Cluster-aligned request from clusters #0 to #2 + alloc=""; zero="`seq 0 31`" + _test_write 'write -q -z 0 192k' "$alloc" "$zero" 0 + _verify_l2_bitmap 1 "$alloc" "$zero" + _verify_l2_bitmap 2 "$alloc" "$zero" + + # Subcluster-aligned request from clusters #3 to #5 + alloc=""; zero="`seq 16 31`" + _test_write 'write -q -z 224k 128k' "$alloc" "$zero" 3 + alloc=""; zero="`seq 0 31`" + _verify_l2_bitmap 4 "$alloc" "$zero" + alloc=""; zero="`seq 0 15`" + _verify_l2_bitmap 5 "$alloc" "$zero" + + # Unaligned request from clusters #6 to #8 + if [ "$use_backing_file" = "yes" ]; then + alloc="15"; zero="`seq 16 31`" # copy-on-write happening here + else + alloc=""; zero="`seq 15 31`" + fi + _test_write 'write -q -z 415k 128k' "$alloc" "$zero" 6 + alloc=""; zero="`seq 0 31`" + _verify_l2_bitmap 7 "$alloc" "$zero" + if [ "$use_backing_file" = "yes" ]; then + alloc="15"; zero="`seq 0 14`" # copy-on-write happening here + else + alloc=""; zero="`seq 0 15`" + fi + _verify_l2_bitmap 8 "$alloc" "$zero" + + # Now we'll repeat the previous tests but writing to allocated + # clusters instead, so we fill them with data first. + alloc="`seq 0 31`"; zero="" + _test_write 'write -q -P 1 576k 576k' "$alloc" "$zero" 9 + _verify_l2_bitmap 10 "$alloc" "$zero" + _verify_l2_bitmap 11 "$alloc" "$zero" + _verify_l2_bitmap 12 "$alloc" "$zero" + _verify_l2_bitmap 13 "$alloc" "$zero" + _verify_l2_bitmap 14 "$alloc" "$zero" + _verify_l2_bitmap 15 "$alloc" "$zero" + _verify_l2_bitmap 16 "$alloc" "$zero" + _verify_l2_bitmap 17 "$alloc" "$zero" + + # Cluster-aligned request from clusters #9 to #11 + alloc=""; zero="`seq 0 31`" + _test_write 'write -q -z 576k 192k' "$alloc" "$zero" 9 + _verify_l2_bitmap 10 "$alloc" "$zero" + _verify_l2_bitmap 11 "$alloc" "$zero" + + # Subcluster-aligned request from clusters #12 to #14 + alloc="`seq 0 15`"; zero="`seq 16 31`" + _test_write 'write -q -z 800k 128k' "$alloc" "$zero" 12 + alloc=""; zero="`seq 0 31`" + _verify_l2_bitmap 13 "$alloc" "$zero" + alloc="`seq 16 31`"; zero="`seq 0 15`" + _verify_l2_bitmap 14 "$alloc" "$zero" + + # Unaligned request from clusters #15 to #17 + alloc="`seq 0 15`"; zero="`seq 16 31`" + _test_write 'write -q -z 991k 128k' "$alloc" "$zero" 15 + alloc=""; zero="`seq 0 31`" + _verify_l2_bitmap 16 "$alloc" "$zero" + alloc="`seq 15 31`"; zero="`seq 0 14`" + _verify_l2_bitmap 17 "$alloc" "$zero" + + # Same tests, but writing to compressed clusters instead, so we + # fill them with data first. + alloc=""; zero="" + for c in `seq 18 28`; do + _test_write "write -q -c -P 2 $(($c*64))k 64k" "$alloc" "$zero" $c + done + + # Cluster-aligned request from clusters #18 to #20 + alloc=""; zero="`seq 0 31`" + _test_write 'write -q -z 1152k 192k' "$alloc" "$zero" 18 + _verify_l2_bitmap 19 "$alloc" "$zero" + _verify_l2_bitmap 20 "$alloc" "$zero" + + # Subcluster-aligned request from clusters #21 to #23. + # We cannot partially zero a compressed cluster so the code + # returns -ENOTSUP, which means copy-on-write of the compressed + # data and fill the rest with actual zeroes on disk. + # TODO: cluster #22 should use the 'all zeroes' bits. + alloc="`seq 0 31`"; zero="" + _test_write 'write -q -z 1376k 128k' "$alloc" "$zero" 21 + _verify_l2_bitmap 22 "$alloc" "$zero" + _verify_l2_bitmap 23 "$alloc" "$zero" + + # Unaligned request from clusters #24 to #26 + # In this case QEMU internally sends a 1k request followed by a + # subcluster-aligned 128k request. The first request decompresses + # cluster #24, but that's not enough to perform efficiently the + # second request because it partially writes to cluster #26 (which + # is compressed) so we hit the same problem as before. + alloc="`seq 0 31`"; zero="" + _test_write 'write -q -z 1567k 129k' "$alloc" "$zero" 24 + _verify_l2_bitmap 25 "$alloc" "$zero" + _verify_l2_bitmap 26 "$alloc" "$zero" + + # Unaligned request from clusters #27 to #29 + # Similar to the previous case, but this time the tail of the + # request does not correspond to a compressed cluster, so it can + # be zeroed efficiently. + # Note that the very last subcluster is partially written, so if + # there's a backing file we need to perform cow. + alloc="`seq 0 15`"; zero="`seq 16 31`" + _test_write 'write -q -z 1759k 128k' "$alloc" "$zero" 27 + alloc=""; zero="`seq 0 31`" + _verify_l2_bitmap 28 "$alloc" "$zero" + if [ "$use_backing_file" = "yes" ]; then + alloc="15"; zero="`seq 0 14`" + else + alloc=""; zero="`seq 0 15`" + fi + _verify_l2_bitmap 29 "$alloc" "$zero" + + # Unaligned request in the middle of cluster #30. + # If there's a backing file we need to allocate and do + # copy-on-write on the partially zeroed subclusters. + # If not we can set the 'all zeroes' bit on them. + if [ "$use_backing_file" = "yes" ]; then + alloc="15 19"; zero="`seq 16 18`" + else + alloc=""; zero="`seq 15 19`" + fi + _test_write 'write -q -z 1951k 8k' "$alloc" "$zero" 30 + + # Fill the last cluster with zeroes, up to the end of the image + # (the image size is not a multiple of the cluster or subcluster size). + alloc=""; zero="`seq 0 17`" + _test_write 'write -q -z 2048k 35k' "$alloc" "$zero" 32 +done + +for use_backing_file in yes no; do + echo + echo "### Discarding clusters with non-zero bitmaps (backing file: $use_backing_file) ###" + echo + if [ "$use_backing_file" = "yes" ]; then + _make_test_img -o extended_l2=on -b "$TEST_IMG.base" 1M + else + _make_test_img -o extended_l2=on 1M + fi + # Write clusters #0-#2 and then discard them + $QEMU_IO -c 'write -q 0 128k' "$TEST_IMG" + $QEMU_IO -c 'discard -q 0 128k' "$TEST_IMG" + # 'qemu-io discard' doesn't do a full discard, it zeroizes the + # cluster, so both clusters have all zero bits set now + alloc=""; zero="`seq 0 31`" + _verify_l2_bitmap 0 "$alloc" "$zero" + _verify_l2_bitmap 1 "$alloc" "$zero" + # Now deallocate half of the subclusters of the first cluster + poke_file "$TEST_IMG" $(($l2_offset+8)) "\x00\x00" + # Discard cluster #0 again to see how the zero bits have changed + $QEMU_IO -c 'discard -q 0 64k' "$TEST_IMG" + # And do a full discard of cluster #1 by shrinking and growing the image + $QEMU_IMG resize --shrink "$TEST_IMG" 64k + $QEMU_IMG resize "$TEST_IMG" 1M + # A normal discard sets all 'zero' bits only if the image has a + # backing file, otherwise it won't touch them. + if [ "$use_backing_file" = "yes" ]; then + alloc=""; zero="`seq 0 31`" + else + alloc=""; zero="`seq 0 15`" + fi + _verify_l2_bitmap 0 "$alloc" "$zero" + # A full discard should clear the L2 entry completely. However + # when growing an image with a backing file the new clusters are + # zeroized to hide the stale data from the backing file + if [ "$use_backing_file" = "yes" ]; then + alloc=""; zero="`seq 0 31`" + else + alloc=""; zero="" + fi + _verify_l2_bitmap 1 "$alloc" "$zero" +done + +# Test that corrupted L2 entries are detected in both read and write +# operations +for corruption_test_cmd in read write; do + echo + echo "### Corrupted L2 entries - $corruption_test_cmd test (allocated) ###" + echo + echo "# 'cluster is zero' bit set on the standard cluster descriptor" + echo + # We actually don't consider this a corrupted image. + # The 'cluster is zero' bit is unused is unused in extended L2 entries + # so QEMU ignores it. + # TODO: maybe treat the image as corrupted and make qemu-img check fix it? + _make_test_img -o extended_l2=on 1M + $QEMU_IO -c 'write -q -P 0x11 0 2k' "$TEST_IMG" + poke_file "$TEST_IMG" $(($l2_offset+7)) "\x01" + alloc="0"; zero="" + _verify_l2_bitmap 0 "$alloc" "$zero" + $QEMU_IO -c "$corruption_test_cmd -q -P 0x11 0 1k" "$TEST_IMG" + if [ "$corruption_test_cmd" = "write" ]; then + alloc="0"; zero="" + fi + _verify_l2_bitmap 0 "$alloc" "$zero" + + echo + echo "# Both 'subcluster is zero' and 'subcluster is allocated' bits set" + echo + _make_test_img -o extended_l2=on 1M + $QEMU_IO -c 'write -q 0 2k' "$TEST_IMG" + poke_file "$TEST_IMG" $(($l2_offset+11)) "\x01" + alloc="0"; zero="0" + _verify_l2_bitmap 0 "$alloc" "$zero" + $QEMU_IO -c "$corruption_test_cmd 0 1k" "$TEST_IMG" + + echo + echo "### Corrupted L2 entries - $corruption_test_cmd test (unallocated) ###" + echo + echo "# 'cluster is zero' bit set on the standard cluster descriptor" + echo + # We actually don't consider this a corrupted image. + # The 'cluster is zero' bit is unused is unused in extended L2 entries + # so QEMU ignores it. + # TODO: maybe treat the image as corrupted and make qemu-img check fix it? + _make_test_img -o extended_l2=on 1M + # We want to modify the (empty) L2 entry from cluster #0, + # but we write to #4 in order to initialize the L2 table first + $QEMU_IO -c 'write -q 256k 1k' "$TEST_IMG" + poke_file "$TEST_IMG" $(($l2_offset+7)) "\x01" + alloc=""; zero="" + _verify_l2_bitmap 0 "$alloc" "$zero" + $QEMU_IO -c "$corruption_test_cmd -q 0 1k" "$TEST_IMG" + if [ "$corruption_test_cmd" = "write" ]; then + alloc="0"; zero="" + fi + _verify_l2_bitmap 0 "$alloc" "$zero" + + echo + echo "# 'subcluster is allocated' bit set" + echo + _make_test_img -o extended_l2=on 1M + # We want to corrupt the (empty) L2 entry from cluster #0, + # but we write to #4 in order to initialize the L2 table first + $QEMU_IO -c 'write -q 256k 1k' "$TEST_IMG" + poke_file "$TEST_IMG" $(($l2_offset+15)) "\x01" + alloc="0"; zero="" + _verify_l2_bitmap 0 "$alloc" "$zero" + $QEMU_IO -c "$corruption_test_cmd 0 1k" "$TEST_IMG" + + echo + echo "# Both 'subcluster is zero' and 'subcluster is allocated' bits set" + echo + _make_test_img -o extended_l2=on 1M + # We want to corrupt the (empty) L2 entry from cluster #0, + # but we write to #4 in order to initialize the L2 table first + $QEMU_IO -c 'write -q 256k 1k' "$TEST_IMG" + poke_file "$TEST_IMG" $(($l2_offset+8)) "\x00\x00\x00\x01\x00\x00\x00\x01" + alloc="0"; zero="0" + _verify_l2_bitmap 0 "$alloc" "$zero" + $QEMU_IO -c "$corruption_test_cmd 0 1k" "$TEST_IMG" + + echo + echo "### Compressed cluster with subcluster bitmap != 0 - $corruption_test_cmd test ###" + echo + # We actually don't consider this a corrupted image. + # The bitmap in compressed clusters is unused so QEMU should just ignore it. + _make_test_img -o extended_l2=on 1M + $QEMU_IO -c 'write -q -P 11 -c 0 64k' "$TEST_IMG" + poke_file "$TEST_IMG" $(($l2_offset+11)) "\x01\x01" + alloc="24"; zero="0" + _verify_l2_bitmap 0 "$alloc" "$zero" + $QEMU_IO -c "$corruption_test_cmd -P 11 0 64k" "$TEST_IMG" | _filter_qemu_io + # Writing allocates a new uncompressed cluster so we get a new bitmap + if [ "$corruption_test_cmd" = "write" ]; then + alloc="`seq 0 31`"; zero="" + fi + _verify_l2_bitmap 0 "$alloc" "$zero" +done + +echo +echo "### Image creation options ###" +echo +echo "# cluster_size < 16k" +_make_test_img -o extended_l2=on,cluster_size=8k 1M + +# TODO: allow preallocation with backing files when subclusters are used +echo "# backing file and preallocation=metadata" +_make_test_img -o extended_l2=on,preallocation=metadata -b "$TEST_IMG.base" 1M + +echo "# backing file and preallocation=falloc" +_make_test_img -o extended_l2=on,preallocation=falloc -b "$TEST_IMG.base" 1M + +echo "# backing file and preallocation=full" +_make_test_img -o extended_l2=on,preallocation=full -b "$TEST_IMG.base" 1M + +echo +echo "### qemu-img measure ###" +echo +echo "# 512MB, extended_l2=off" # This needs one L2 table +$QEMU_IMG measure --size 512M -O qcow2 -o extended_l2=off +echo "# 512MB, extended_l2=on" # This needs two L2 tables +$QEMU_IMG measure --size 512M -O qcow2 -o extended_l2=on + +echo "# 16K clusters, 64GB, extended_l2=off" # This needs one full L1 table cluster +$QEMU_IMG measure --size 64G -O qcow2 -o cluster_size=16k,extended_l2=off +echo "# 16K clusters, 64GB, extended_l2=on" # This needs two full L2 table clusters +$QEMU_IMG measure --size 64G -O qcow2 -o cluster_size=16k,extended_l2=on + +echo "# 8k clusters" # This should fail +$QEMU_IMG measure --size 1M -O qcow2 -o cluster_size=8k,extended_l2=on + +echo "# 1024 TB" # Maximum allowed size with extended_l2=on and 64K clusters +$QEMU_IMG measure --size 1024T -O qcow2 -o extended_l2=on +echo "# 1025 TB" # This should fail +$QEMU_IMG measure --size 1025T -O qcow2 -o extended_l2=on + +echo +echo "### Test copy-on-write on an image with snapshots ###" +echo +_make_test_img -o extended_l2=on 1M + +# For each cluster from #0 to #9 this loop zeroes subcluster #7 +# and allocates subclusters #13 and #18. +alloc="13 18"; zero="7" +for c in `seq 0 9`; do + $QEMU_IO -c "write -q -z $((64*$c+14))k 2k" \ + -c "write -q -P $((0xd0+$c)) $((64*$c+26))k 2k" \ + -c "write -q -P $((0xe0+$c)) $((64*$c+36))k 2k" "$TEST_IMG" + _verify_l2_bitmap "$c" "$alloc" "$zero" +done + +# Create a snapshot and set l2_offset to the new L2 table +$QEMU_IMG snapshot -c snap1 "$TEST_IMG" +l2_offset=1114112 # 0x110000 + +# Write different patterns to each one of the clusters +# in order to see how copy-on-write behaves in each case. +$QEMU_IO -c "write -q -P 0xf0 $((64*0+30))k 1k" \ + -c "write -q -P 0xf1 $((64*1+20))k 1k" \ + -c "write -q -P 0xf2 $((64*2+40))k 1k" \ + -c "write -q -P 0xf3 $((64*3+26))k 1k" \ + -c "write -q -P 0xf4 $((64*4+14))k 1k" \ + -c "write -q -P 0xf5 $((64*5+1))k 1k" \ + -c "write -q -z $((64*6+30))k 3k" \ + -c "write -q -z $((64*7+26))k 2k" \ + -c "write -q -z $((64*8+26))k 1k" \ + -c "write -q -z $((64*9+12))k 1k" \ + "$TEST_IMG" +alloc="`seq 13 18`"; zero="7"; _verify_l2_bitmap 0 "$alloc" "$zero" +alloc="`seq 10 18`"; zero="7"; _verify_l2_bitmap 1 "$alloc" "$zero" +alloc="`seq 13 20`"; zero="7"; _verify_l2_bitmap 2 "$alloc" "$zero" +alloc="`seq 13 18`"; zero="7"; _verify_l2_bitmap 3 "$alloc" "$zero" +alloc="`seq 7 18`"; zero=""; _verify_l2_bitmap 4 "$alloc" "$zero" +alloc="`seq 0 18`"; zero=""; _verify_l2_bitmap 5 "$alloc" "$zero" +alloc="13 18"; zero="7 15 16"; _verify_l2_bitmap 6 "$alloc" "$zero" +alloc="18"; zero="7 13"; _verify_l2_bitmap 7 "$alloc" "$zero" +alloc="`seq 13 18`"; zero="7"; _verify_l2_bitmap 8 "$alloc" "$zero" +alloc="13 18"; zero="6 7"; _verify_l2_bitmap 9 "$alloc" "$zero" + +# success, all done +echo "*** done" +rm -f $seq.full +status=0
tests/qemu-iotests/271.out new file +519 -0
519 lines not on this page · raw message
tests/qemu-iotests/group +1 -0
@@ -284,6 +284,7 @@ 267 rw auto quick snapshot 268 rw auto quick 270 rw backing quick +271 rw auto 272 rw 273 backing quick 274 rw backing
Signature · 1 line
2.20.1
PATCH v5 17/31 qcow2: Replace QCOW2_CLUSTER_* with QCOW2_SUBCLUSTER_*
In reply to Alberto GarciaIn order to support extended L2 entries some functions of the qcow2 driver need to start dealing with subclusters instead of clusters.
qcow2_get_host_offset() is modified to return the subcluster type instead of the cluster type, and all callers are updated to replace all values of QCow2ClusterType with their QCow2SubclusterType equivalents.
This patch only changes the data types, there are no semantic changes.
--- block/qcow2.h | 2 +- block/qcow2-cluster.c | 10 +++---- block/qcow2.c | 70 ++++++++++++++++++++++--------------------- 3 files changed, 42 insertions(+), 40 deletions(-)
block/qcow2.h +1 -1
@@ -877,7 +877,7 @@ int qcow2_encrypt_sectors(BDRVQcow2State *s, int64_t sector_num,int qcow2_get_host_offset (BlockDriverState *bs,uint64_t offset,unsigned int *bytes,uint64_t *host_offset, -QCow2ClusterType *cluster_type); +QCow2SubclusterType *subcluster_type);int qcow2_alloc_cluster_offset (BlockDriverState *bs,uint64_t offset,unsigned int *bytes,uint64_t *host_offset,QCowL2Meta **m);
block/qcow2-cluster.c +5 -5
@@ -513,15 +513,15 @@ static int coroutine_fn do_perform_cow_write(BlockDriverState *bs,* offset that we are interested in. * * On exit, *bytes is the number of bytes starting at offset that have the same -* cluster type and (if applicable) are stored contiguously in the image file. -* The cluster type is stored in *cluster_type. -* Compressed clusters are always returned one by one. +* subcluster type and (if applicable) are stored contiguously in the image +* file. The subcluster type is stored in *subcluster_type. +* Compressed clusters are always processed one by one. * * Returns 0 on success, -errno in error cases. */ int qcow2_get_host_offset (BlockDriverState *bs,uint64_t offset,unsigned int *bytes,uint64_t *host_offset, -QCow2ClusterType *cluster_type) +QCow2SubclusterType *subcluster_type) {BDRVQcow2State *s = bs->opaque;unsigned int l2_index;
@@ -662,7 +662,7 @@ out:assert (bytes_available - offset_in_cluster <=UINT_MAX ); *bytes = bytes_available - offset_in_cluster; - *cluster_type = type; + *subcluster_type =qcow2_cluster_to_subcluster_type (type);return 0 ;
block/qcow2.c +36 -34
201 lines not on this page · raw message
Signature · 1 line
2.20.1
v5 cover Add subcluster allocation to qcow2
Hi,
here's the new version of the patches to add subcluster allocation support to qcow2.
Please refer to the cover letter of the first version for a full description of the patches:
https://lists.gnu.org/archive/html/qemu-block/2019-10/msg00983.html
Important changes here:
- I fixed hopefully all of the issues mentioned in the previous review. Thanks to everyone who contributed.
- There's now support for partial zeroing of clusters (i.e. at the subcluster level).
- Many more tests.
- QCOW_OFLAG_ZERO is simply ignored now and not considered a sign of a corrupt image anymore. I hesitated about this, but we could still add that check later. I think there's a case for adding a new QCOW2_CLUSTER_INVALID type and include this and other scenarios that we already consider corrupt (for example: clusters with unaligned offsets). We would need to see if for 'qemu-img check' adding QCOW2_CLUSTER_INVALID complicates things or not. But I think that all is material for its own series.
And I think that's all. See below for the detailed list of changes, and thanks again for the feedback.
Berto
v5:
- Patch 01: Fix indentation [Max], add trace event [Vladimir]
- Patch 02: Add host_cluster_offset variable [Vladirmir]
- Patch 05: Have separate l2_entry and cluster_offset variables [Vladimir]
- Patch 06: Only context changes due to patch 05
- Patch 11: New patch
- Patch 13: Change documentation of get_l2_entry()
- Patch 14: Add QCOW_OFLAG_SUB_{ALLOC,ZERO}_RANGE [Eric] and rewrite the other macros.
Ignore QCOW_OFLAG_ZERO on images with subclusters (i.e. don't treat them as corrupted).
- Patch 15: New patch
- Patch 19: Optimize cow by skipping all leading and trailing zero and unallocated subclusters [Vladimir]
Return 0 on success [Vladimir]
Squash patch that updated handle_dependencies() [Vladirmir]
- Patch 20: Call count_contiguous_subclusters() after the main switch in qcow2_get_host_offset() [Vladimir]
Add assertion and remove goto statement [Vladimir]
- Patch 21: Rewrite algorithm.
- Patch 22: Rewrite algorithm.
- Patch 24: Replace loop with the _RANGE macros from patch 14 [Eric]
- Patch 27: New patch
- Patch 28: Update version number and expected output from tests.
- Patch 31: Add many more new tests
v4: https://lists.gnu.org/archive/html/qemu-block/2020-03/msg00966.html
v3: https://lists.gnu.org/archive/html/qemu-block/2019-12/msg00587.html
v2: https://lists.gnu.org/archive/html/qemu-block/2019-10/msg01642.html
v1: https://lists.gnu.org/archive/html/qemu-block/2019-10/msg00983.html
Output of git backport-diff against v4:
Key:
[----] : patches are identical
[####] : number of functional differences between upstream/downstream patch [down] : patch is downstream-only
The flags [FC] indicate (F)unctional and (C)ontextual differences, respectively
001/31:[0005] [FC] 'qcow2: Make Qcow2AioTask store the full host offset' 002/31:[0018] [FC] 'qcow2: Convert qcow2_get_cluster_offset() into qcow2_get_host_offset()' 003/31:[----] [--] 'qcow2: Add calculate_l2_meta()'
004/31:[----] [--] 'qcow2: Split cluster_needs_cow() out of count_cow_clusters()' 005/31:[0038] [FC] 'qcow2: Process QCOW2_CLUSTER_ZERO_ALLOC clusters in handle_copied()' 006/31:[0004] [FC] 'qcow2: Add get_l2_entry() and set_l2_entry()'
007/31:[----] [--] 'qcow2: Document the Extended L2 Entries feature' 008/31:[----] [--] 'qcow2: Add dummy has_subclusters() function'
009/31:[----] [--] 'qcow2: Add subcluster-related fields to BDRVQcow2State' 010/31:[----] [--] 'qcow2: Add offset_to_sc_index()'
011/31:[down] 'qcow2: Add offset_into_subcluster() and size_to_subclusters()' 012/31:[----] [--] 'qcow2: Add l2_entry_size()'
013/31:[0003] [FC] 'qcow2: Update get/set_l2_entry() and add get/set_l2_bitmap()' 014/31:[0023] [FC] 'qcow2: Add QCow2SubclusterType and qcow2_get_subcluster_type()' 015/31:[down] 'qcow2: Add qcow2_cluster_is_allocated()'
016/31:[----] [--] 'qcow2: Add cluster type parameter to qcow2_get_host_offset()' 017/31:[----] [--] 'qcow2: Replace QCOW2_CLUSTER_* with QCOW2_SUBCLUSTER_*' 018/31:[----] [--] 'qcow2: Handle QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC' 019/31:[0066] [FC] 'qcow2: Add subcluster support to calculate_l2_meta()' 020/31:[0022] [FC] 'qcow2: Add subcluster support to qcow2_get_host_offset()' 021/31:[0040] [FC] 'qcow2: Add subcluster support to zero_in_l2_slice()' 022/31:[0061] [FC] 'qcow2: Add subcluster support to discard_in_l2_slice()' 023/31:[----] [--] 'qcow2: Add subcluster support to check_refcounts_l2()' 024/31:[0019] [FC] 'qcow2: Update L2 bitmap in qcow2_alloc_cluster_link_l2()' 025/31:[----] [--] 'qcow2: Clear the L2 bitmap when allocating a compressed cluster' 026/31:[----] [--] 'qcow2: Add subcluster support to handle_alloc_space()' 027/31:[down] 'qcow2: Add subcluster support to qcow2_co_pwrite_zeroes()' 028/31:[0105] [FC] 'qcow2: Add the 'extended_l2' option and the QCOW2_INCOMPAT_EXTL2 bit' 029/31:[----] [-C] 'qcow2: Assert that expand_zero_clusters_in_l1() does not support subclusters' 030/31:[----] [--] 'qcow2: Add subcluster support to qcow2_measure()' 031/31:[0694] [FC] 'iotests: Add tests for qcow2 images with extended L2 entries'
Alberto Garcia (31):
qcow2: Make Qcow2AioTask store the full host offset
qcow2: Convert qcow2_get_cluster_offset() into qcow2_get_host_offset()
qcow2: Add calculate_l2_meta()
qcow2: Split cluster_needs_cow() out of count_cow_clusters()
qcow2: Process QCOW2_CLUSTER_ZERO_ALLOC clusters in handle_copied()
qcow2: Add get_l2_entry() and set_l2_entry()
qcow2: Document the Extended L2 Entries feature
qcow2: Add dummy has_subclusters() function
qcow2: Add subcluster-related fields to BDRVQcow2State
qcow2: Add offset_to_sc_index()
qcow2: Add offset_into_subcluster() and size_to_subclusters()
qcow2: Add l2_entry_size()
qcow2: Update get/set_l2_entry() and add get/set_l2_bitmap()
qcow2: Add QCow2SubclusterType and qcow2_get_subcluster_type()
qcow2: Add qcow2_cluster_is_allocated()
qcow2: Add cluster type parameter to qcow2_get_host_offset()
qcow2: Replace QCOW2_CLUSTER_* with QCOW2_SUBCLUSTER_*
qcow2: Handle QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC
qcow2: Add subcluster support to calculate_l2_meta()
qcow2: Add subcluster support to qcow2_get_host_offset()
qcow2: Add subcluster support to zero_in_l2_slice()
qcow2: Add subcluster support to discard_in_l2_slice()
qcow2: Add subcluster support to check_refcounts_l2()
qcow2: Update L2 bitmap in qcow2_alloc_cluster_link_l2()
qcow2: Clear the L2 bitmap when allocating a compressed cluster
qcow2: Add subcluster support to handle_alloc_space()
qcow2: Add subcluster support to qcow2_co_pwrite_zeroes()
qcow2: Add the 'extended_l2' option and the QCOW2_INCOMPAT_EXTL2 bit
qcow2: Assert that expand_zero_clusters_in_l1() does not support
subclusters
qcow2: Add subcluster support to qcow2_measure()
iotests: Add tests for qcow2 images with extended L2 entries
docs/interop/qcow2.txt | 68 ++- docs/qcow2-cache.txt | 19 +- qapi/block-core.json | 7 + block/qcow2.h | 204 ++++++- include/block/block_int.h | 1 + block/qcow2-cluster.c | 892 ++++++++++++++++++++----------- block/qcow2-refcount.c | 38 +- block/qcow2.c | 283 ++++++---- block/trace-events | 2 +- tests/qemu-iotests/031.out | 8 +- tests/qemu-iotests/036.out | 4 +- tests/qemu-iotests/049.out | 102 ++-- tests/qemu-iotests/060.out | 1 + tests/qemu-iotests/061 | 6 + tests/qemu-iotests/061.out | 25 +- tests/qemu-iotests/065 | 18 +- tests/qemu-iotests/082.out | 48 +- tests/qemu-iotests/085.out | 38 +- tests/qemu-iotests/144.out | 4 +- tests/qemu-iotests/182.out | 2 +- tests/qemu-iotests/185.out | 8 +- tests/qemu-iotests/198.out | 2 + tests/qemu-iotests/206.out | 4 + tests/qemu-iotests/242.out | 5 + tests/qemu-iotests/255.out | 8 +- tests/qemu-iotests/271 | 664 +++++++++++++++++++++++ tests/qemu-iotests/271.out | 519 ++++++++++++++++++ tests/qemu-iotests/274.out | 49 +- tests/qemu-iotests/280.out | 2 +- tests/qemu-iotests/common.filter | 1 + tests/qemu-iotests/group | 1 + 31 files changed, 2459 insertions(+), 574 deletions(-) create mode 100755 tests/qemu-iotests/271 create mode 100644 tests/qemu-iotests/271.out
Signature · 1 line
2.20.1
PATCH v5 19/31 qcow2: Add subcluster support to calculate_l2_meta()
If an image has subclusters then there are more copy-on-write scenarios that we need to consider. Let's say we have a write request from the middle of subcluster #3 until the end of the cluster:
1) If we are writing to a newly allocated cluster then we need copy-on-write. The previous contents of subclusters #0 to #3 must be copied to the new cluster. We can optimize this process by skipping all leading unallocated or zero subclusters (the status of those skipped subclusters will be reflected in the new L2 bitmap).
2) If we are overwriting an existing cluster:
2.1) If subcluster #3 is unallocated or has the all-zeroes bit set
then we need copy-on-write (on subcluster #3 only).
2.2) If subcluster #3 was already allocated then there is no need
for any copy-on-write. However we still need to update the L2 bitmap to reflect possible changes in the allocation status of subclusters #4 to #31. Because of this, this function checks if all the overwritten subclusters are already allocated and in this case it returns without creating a new QCowL2Meta structure.
After all these changes l2meta_cow_start() and l2meta_cow_end() are not necessarily cluster-aligned anymore. We need to update the calculation of old_start and old_end in handle_dependencies() to guarantee that no two requests try to write on the same cluster.
--- block/qcow2-cluster.c | 174 +++++++++++++++++++++++++++++++++++------- 1 file changed, 146 insertions(+), 28 deletions(-)
block/qcow2-cluster.c +146 -28
@@ -1059,56 +1059,156 @@ void qcow2_alloc_cluster_abort(BlockDriverState *bs, QCowL2Meta *m)* If @keep_old is true it means that the clusters were already * allocated and will be overwritten. If false then the clusters are * new and we have to decrease the reference count of the old ones. +* +* Returns 0 on success, -errno on failure. */ -static void calculate_l2_meta (BlockDriverState *bs, -uint64_t host_cluster_offset, -uint64_t guest_offset,unsigned bytes, -uint64_t *l2_slice,QCowL2Meta **m,bool keep_old) +static int calculate_l2_meta (BlockDriverState *bs,uint64_t host_cluster_offset, +uint64_t guest_offset,unsigned bytes, +uint64_t *l2_slice,QCowL2Meta **m,bool keep_old) {BDRVQcow2State *s = bs->opaque; -int l2_index =offset_to_l2_slice_index (s, guest_offset); -uint64_t l2_entry; +int sc_index, l2_index =offset_to_l2_slice_index (s, guest_offset); +uint64_t l2_entry, l2_bitmap;unsigned cow_start_from, cow_end_to;unsigned cow_start_to =offset_into_cluster (s, guest_offset);unsigned cow_end_from = cow_start_to + bytes;unsigned nb_clusters =size_to_clusters (s, cow_end_from);QCowL2Meta *old_m = *m; -QCow2ClusterType type; +QCow2SubclusterType type;assert (nb_clusters <= s->l2_slice_size - l2_index); -/* Return if there's no COW (all clusters are normal and we keep them) */ +/* Return if there's no COW (all subclusters are normal and we are +* keeping the clusters) */ if (keep_old) { +unsigned first_sc = cow_start_to / s->subcluster_size; +unsigned last_sc = (cow_end_from -1 ) / s->subcluster_size;int i; -for (i =0 ; i < nb_clusters; i++) { - l2_entry =get_l2_entry (s, l2_slice, l2_index + i); -if (qcow2_get_cluster_type (bs, l2_entry) !=QCOW2_CLUSTER_NORMAL ) { +for (i = first_sc; i <= last_sc; i++) { +unsigned c = i / s->subclusters_per_cluster; +unsigned sc = i % s->subclusters_per_cluster; + l2_entry =get_l2_entry (s, l2_slice, l2_index + c); + l2_bitmap =get_l2_bitmap (s, l2_slice, l2_index + c); + type =qcow2_get_subcluster_type (bs, l2_entry, l2_bitmap, sc); +if (type ==QCOW2_SUBCLUSTER_INVALID ) { + l2_index += c;/* Point to the invalid entry */ + goto fail; + } +if (type !=QCOW2_SUBCLUSTER_NORMAL ) {break ; } } -if (i == nb_clusters) { -return ; +if (i == last_sc +1 ) { +return 0 ; } }/* Get the L2 entry of the first cluster */ l2_entry =get_l2_entry (s, l2_slice, l2_index); - type =qcow2_get_cluster_type (bs, l2_entry); + l2_bitmap =get_l2_bitmap (s, l2_slice, l2_index); + sc_index =offset_to_sc_index (s, guest_offset); + type =qcow2_get_subcluster_type (bs, l2_entry, l2_bitmap, sc_index); -if (type ==QCOW2_CLUSTER_NORMAL && keep_old) { - cow_start_from = cow_start_to; +if (type ==QCOW2_SUBCLUSTER_INVALID ) { + goto fail; + } + +if (!keep_old) { +switch (type) { +case QCOW2_SUBCLUSTER_COMPRESSED : + cow_start_from =0 ; +break ; +case QCOW2_SUBCLUSTER_NORMAL : +case QCOW2_SUBCLUSTER_ZERO_ALLOC : +case QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC : { +int i; +/* Skip all leading zero and unallocated subclusters */ +for (i =0 ; i < sc_index; i++) { +QCow2SubclusterType t; + t =qcow2_get_subcluster_type (bs, l2_entry, l2_bitmap, i); +if (t ==QCOW2_SUBCLUSTER_INVALID ) { + goto fail; + }else if (t ==QCOW2_SUBCLUSTER_NORMAL ) { +break ; + } + } + cow_start_from = i << s->subcluster_bits; +break ; + } +case QCOW2_SUBCLUSTER_ZERO_PLAIN : +case QCOW2_SUBCLUSTER_UNALLOCATED_PLAIN : + cow_start_from = sc_index << s->subcluster_bits; +break ; +default : +g_assert_not_reached (); + } }else { - cow_start_from =0 ; +switch (type) { +case QCOW2_SUBCLUSTER_NORMAL : + cow_start_from = cow_start_to; +break ; +case QCOW2_SUBCLUSTER_ZERO_ALLOC : +case QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC : + cow_start_from = sc_index << s->subcluster_bits; +break ; +default : +g_assert_not_reached (); + } }/* Get the L2 entry of the last cluster */ - l2_entry =get_l2_entry (s, l2_slice, l2_index + nb_clusters -1 ); - type =qcow2_get_cluster_type (bs, l2_entry); + l2_index += nb_clusters -1 ; + l2_entry =get_l2_entry (s, l2_slice, l2_index); + l2_bitmap =get_l2_bitmap (s, l2_slice, l2_index); + sc_index =offset_to_sc_index (s, guest_offset + bytes -1 ); + type =qcow2_get_subcluster_type (bs, l2_entry, l2_bitmap, sc_index); -if (type ==QCOW2_CLUSTER_NORMAL && keep_old) { - cow_end_to = cow_end_from; +if (type ==QCOW2_SUBCLUSTER_INVALID ) { + goto fail; + } + +if (!keep_old) { +switch (type) { +case QCOW2_SUBCLUSTER_COMPRESSED : + cow_end_to =ROUND_UP (cow_end_from, s->cluster_size); +break ; +case QCOW2_SUBCLUSTER_NORMAL : +case QCOW2_SUBCLUSTER_ZERO_ALLOC : +case QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC : { +int i; + cow_end_to =ROUND_UP (cow_end_from, s->cluster_size); +/* Skip all trailing zero and unallocated subclusters */ +for (i = s->subclusters_per_cluster -1 ; i > sc_index; i--) { +QCow2SubclusterType t; + t =qcow2_get_subcluster_type (bs, l2_entry, l2_bitmap, i); +if (t ==QCOW2_SUBCLUSTER_INVALID ) { + goto fail; + }else if (t ==QCOW2_SUBCLUSTER_NORMAL ) { +break ; + } + cow_end_to -= s->subcluster_size; + } +break ; + } +case QCOW2_SUBCLUSTER_ZERO_PLAIN : +case QCOW2_SUBCLUSTER_UNALLOCATED_PLAIN : + cow_end_to =ROUND_UP (cow_end_from, s->subcluster_size); +break ; +default : +g_assert_not_reached (); + } }else { - cow_end_to =ROUND_UP (cow_end_from, s->cluster_size); +switch (type) { +case QCOW2_SUBCLUSTER_NORMAL : + cow_end_to = cow_end_from; +break ; +case QCOW2_SUBCLUSTER_ZERO_ALLOC : +case QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC : + cow_end_to =ROUND_UP (cow_end_from, s->subcluster_size); +break ; +default : +g_assert_not_reached (); + } } *m =g_malloc0 (sizeof (**m));
@@ -1133,6 +1233,18 @@ static void calculate_l2_meta(BlockDriverState *bs,qemu_co_queue_init (&(*m)->dependent_requests);QLIST_INSERT_HEAD (&s->cluster_allocs, *m, next_in_flight); + +fail: +if (type ==QCOW2_SUBCLUSTER_INVALID ) { +uint64_t l1_index =offset_to_l1_index (s, guest_offset); +uint64_t l2_offset = s->l1_table[l1_index] &L1E_OFFSET_MASK ; +qcow2_signal_corruption (bs, true,-1 ,-1 ,"Invalid cluster entry found " +" (L2 offset: %#" PRIx64", L2 index: %#x)" , + l2_offset, l2_index); +return -EIO ; + } + +return 0 ; }/*
@@ -1221,8 +1333,8 @@ static int handle_dependencies(BlockDriverState *bs, uint64_t guest_offset,uint64_t start = guest_offset;uint64_t end = start + bytes; -uint64_t old_start =l2meta_cow_start (old_alloc); -uint64_t old_end =l2meta_cow_end (old_alloc); +uint64_t old_start =start_of_cluster (s,l2meta_cow_start (old_alloc)); +uint64_t old_end =ROUND_UP (l2meta_cow_end (old_alloc), s->cluster_size);if (end <= old_start || start >= old_end) {/* No intersection */
@@ -1347,8 +1459,11 @@ static int handle_copied(BlockDriverState *bs, uint64_t guest_offset, - offset_into_cluster(s, guest_offset));assert (*bytes !=0 ); -calculate_l2_meta (bs, cluster_offset, guest_offset, - *bytes, l2_slice, m, true); + ret =calculate_l2_meta (bs, cluster_offset, guest_offset, + *bytes, l2_slice, m, true); +if (ret <0 ) { + goto out; + } ret =1 ; }else {
@@ -1524,8 +1639,11 @@ static int handle_alloc(BlockDriverState *bs, uint64_t guest_offset, *bytes =MIN (*bytes, nb_bytes -offset_into_cluster (s, guest_offset));assert (*bytes !=0 ); -calculate_l2_meta (bs, alloc_cluster_offset, guest_offset, *bytes, l2_slice, - m, false); + ret =calculate_l2_meta (bs, alloc_cluster_offset, guest_offset, *bytes, + l2_slice, m, false); +if (ret <0 ) { + goto out; + } ret =1 ;
Signature · 1 line
2.20.1
PATCH v5 30/31 qcow2: Add subcluster support to qcow2_measure()
In reply to Alberto GarciaExtended L2 entries are bigger than normal L2 entries so this has an impact on the amount of metadata needed for a qcow2 file.
--- block/qcow2.c | 19 ++++++++++++------- 1 file changed, 12 insertions(+), 7 deletions(-)
block/qcow2.c +12 -7
@@ -3173,28 +3173,31 @@ int64_t qcow2_refcount_metadata_size(int64_t clusters, size_t cluster_size,* @total_size: virtual disk size in bytes * @cluster_size: cluster size in bytes * @refcount_order: refcount bits power-of-2 exponent +* @extended_l2: true if the image has extended L2 entries * * Returns: Total number of bytes required for the fully allocated image * (including metadata). */ static int64_t qcow2_calc_prealloc_size (int64_t total_size,size_t cluster_size, -int refcount_order) +int refcount_order, +bool extended_l2) {int64_t meta_size =0 ;uint64_t nl1e, nl2e;int64_t aligned_total_size =ROUND_UP (total_size, cluster_size); +size_t l2e_size = extended_l2 ?L2E_SIZE_EXTENDED :L2E_SIZE_NORMAL ;/* header: 1 cluster */ meta_size += cluster_size;/* total size of L2 tables */ nl2e = aligned_total_size / cluster_size; - nl2e =ROUND_UP (nl2e, cluster_size /sizeof (uint64_t )); - meta_size += nl2e *sizeof (uint64_t ); + nl2e =ROUND_UP (nl2e, cluster_size / l2e_size); + meta_size += nl2e * l2e_size;/* total size of L1 tables */ - nl1e = nl2e *sizeof (uint64_t ) / cluster_size; + nl1e = nl2e * l2e_size / cluster_size; nl1e =ROUND_UP (nl1e, cluster_size /sizeof (uint64_t )); meta_size += nl1e *sizeof (uint64_t );
@@ -4765,6 +4768,7 @@ static BlockMeasureInfo *qcow2_measure(QemuOpts *opts, BlockDriverState *in_bs,bool has_backing_file;bool has_luks;bool extended_l2; +size_t l2e_size;/* Parse image creation options */ extended_l2 =qemu_opt_get_bool_del (opts,BLOCK_OPT_EXTL2 , false);
@@ -4833,8 +4837,9 @@ static BlockMeasureInfo *qcow2_measure(QemuOpts *opts, BlockDriverState *in_bs, virtual_size =ROUND_UP (virtual_size, cluster_size);/* Check that virtual disk size is valid */ + l2e_size = extended_l2 ?L2E_SIZE_EXTENDED :L2E_SIZE_NORMAL ; l2_tables =DIV_ROUND_UP (virtual_size / cluster_size, - cluster_size /sizeof (uint64_t )); + cluster_size / l2e_size);if (l2_tables *sizeof (uint64_t ) >QCOW_MAX_L1_SIZE ) {error_setg (&local_err,"The image size is too large " "(try using a larger cluster size)" );
@@ -4897,9 +4902,9 @@ static BlockMeasureInfo *qcow2_measure(QemuOpts *opts, BlockDriverState *in_bs, } info =g_new (BlockMeasureInfo,1 ); - info->fully_allocated = + info->fully_allocated = luks_payload_size +qcow2_calc_prealloc_size (virtual_size, cluster_size, -ctz32 (refcount_bits)) + luks_payload_size; +ctz32 (refcount_bits), extended_l2);/* Remove data clusters that are not required. This overestimates the * required size because metadata needed for the fully allocated file is
Signature · 1 line
2.20.1
PATCH v5 26/31 qcow2: Add subcluster support to handle_alloc_space()
In reply to Alberto GarciaThe bdrv_co_pwrite_zeroes() call here fills complete clusters with zeroes, but it can happen that some subclusters are not part of the write request or the copy-on-write. This patch makes sure that only the affected subclusters are overwritten.
A potential improvement would be to also fill with zeroes the other subclusters if we can guarantee that we are not overwriting existing data. However this would waste more disk space, so we should first evaluate if it's really worth doing.
--- block/qcow2.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-)
block/qcow2.c +5 -4
@@ -2351,6 +2351,9 @@ static int handle_alloc_space(BlockDriverState *bs, QCowL2Meta *l2meta)for (m = l2meta; m !=NULL ; m = m->next) {int ret; +uint64_t start_offset = m->alloc_offset + m->cow_start.offset; +unsigned nb_bytes = m->cow_end.offset + m->cow_end.nb_bytes - + m->cow_start.offset;if (!m->cow_start.nb_bytes && !m->cow_end.nb_bytes) {continue ;
@@ -2365,16 +2368,14 @@ static int handle_alloc_space(BlockDriverState *bs, QCowL2Meta *l2meta)* efficiently zero out the whole clusters */ - ret =qcow2_pre_write_overlap_check (bs,0 , m->alloc_offset, - m->nb_clusters * s->cluster_size, + ret =qcow2_pre_write_overlap_check (bs,0 , start_offset, nb_bytes, true);if (ret <0 ) {return ret; }BLKDBG_EVENT (bs->file,BLKDBG_CLUSTER_ALLOC_SPACE ); - ret =bdrv_co_pwrite_zeroes (s->data_file, m->alloc_offset, - m->nb_clusters * s->cluster_size, + ret =bdrv_co_pwrite_zeroes (s->data_file, start_offset, nb_bytes,BDRV_REQ_NO_FALLBACK );if (ret <0 ) {if (ret != -ENOTSUP && ret != -EAGAIN ) {
Signature · 1 line
2.20.1
PATCH v5 23/31 qcow2: Add subcluster support to check_refcounts_l2()
In reply to Alberto GarciaSetting the QCOW_OFLAG_ZERO bit of the L2 entry is forbidden if an image has subclusters. Instead, the individual 'all zeroes' bits must be used.
--- block/qcow2-refcount.c | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-)
block/qcow2-refcount.c +7 -2
@@ -1686,8 +1686,13 @@ static int check_refcounts_l2(BlockDriverState *bs, BdrvCheckResult *res,int ign = active ?QCOW2_OL_ACTIVE_L2 :QCOW2_OL_INACTIVE_L2 ; - l2_entry =QCOW_OFLAG_ZERO ; -set_l2_entry (s, l2_table, i, l2_entry); +if (has_subclusters (s)) { +set_l2_entry (s, l2_table, i,0 ); +set_l2_bitmap (s, l2_table, i, +QCOW_L2_BITMAP_ALL_ZEROES ); + }else { +set_l2_entry (s, l2_table, i,QCOW_OFLAG_ZERO ); + } ret =qcow2_pre_write_overlap_check (bs, ign, l2e_offset,l2_entry_size (s), false);if (ret <0 ) {
Signature · 1 line
2.20.1
PATCH v5 25/31 qcow2: Clear the L2 bitmap when allocating a compressed cluster
In reply to Alberto GarciaCompressed clusters always have the bitmap part of the extended L2 entry set to 0.
--- block/qcow2-cluster.c | 3 +++ 1 file changed, 3 insertions(+)
block/qcow2-cluster.c +3 -0
@@ -800,6 +800,9 @@ int qcow2_alloc_compressed_cluster_offset(BlockDriverState *bs,BLKDBG_EVENT (bs->file,BLKDBG_L2_UPDATE_COMPRESSED );qcow2_cache_entry_mark_dirty (s->l2_table_cache, l2_slice);set_l2_entry (s, l2_slice, l2_index, cluster_offset); +if (has_subclusters (s)) { +set_l2_bitmap (s, l2_slice, l2_index,0 ); + }qcow2_cache_put (s->l2_table_cache, (void **) &l2_slice); *host_offset = cluster_offset & s->cluster_offset_mask;
Signature · 1 line
2.20.1
PATCH v5 16/31 qcow2: Add cluster type parameter to qcow2_get_host_offset()
In reply to Alberto GarciaThis function returns an integer that can be either an error code or a cluster type (a value from the QCow2ClusterType enum).
We are going to start using subcluster types instead of cluster types in some functions so it's better to use the exact data types instead of integers for clarity and in order to detect errors more easily.
This patch makes qcow2_get_host_offset() return 0 on success and puts the returned cluster type in a separate parameter. There are no semantic changes.
--- block/qcow2.h | 3 ++- block/qcow2-cluster.c | 11 +++++++---- block/qcow2.c | 37 ++++++++++++++++++++++--------------- 3 files changed, 31 insertions(+), 20 deletions(-)
block/qcow2.h +2 -1
@@ -876,7 +876,8 @@ int qcow2_encrypt_sectors(BDRVQcow2State *s, int64_t sector_num, uint8_t *buf, int nb_sectors, bool enc, Error **errp);int qcow2_get_host_offset (BlockDriverState *bs,uint64_t offset, -unsigned int *bytes,uint64_t *host_offset); +unsigned int *bytes,uint64_t *host_offset, +QCow2ClusterType *cluster_type);int qcow2_alloc_cluster_offset (BlockDriverState *bs,uint64_t offset,unsigned int *bytes,uint64_t *host_offset,QCowL2Meta **m);
block/qcow2-cluster.c +7 -4
@@ -514,13 +514,14 @@ static int coroutine_fn do_perform_cow_write(BlockDriverState *bs,* * On exit, *bytes is the number of bytes starting at offset that have the same * cluster type and (if applicable) are stored contiguously in the image file. +* The cluster type is stored in *cluster_type. * Compressed clusters are always returned one by one. * -* Returns the cluster type (QCOW2_CLUSTER_*) on success, -errno in error -* cases. +* Returns 0 on success, -errno in error cases. */ int qcow2_get_host_offset (BlockDriverState *bs,uint64_t offset, -unsigned int *bytes,uint64_t *host_offset) +unsigned int *bytes,uint64_t *host_offset, +QCow2ClusterType *cluster_type) {BDRVQcow2State *s = bs->opaque;unsigned int l2_index;
@@ -661,7 +662,9 @@ out:assert (bytes_available - offset_in_cluster <=UINT_MAX ); *bytes = bytes_available - offset_in_cluster; -return type; + *cluster_type = type; + +return 0 ; fail:qcow2_cache_put (s->l2_table_cache, (void **)&l2_slice);
block/qcow2.c +22 -15
@@ -1973,6 +1973,7 @@ static int coroutine_fn qcow2_co_block_status(BlockDriverState *bs,BDRVQcow2State *s = bs->opaque;uint64_t host_offset;unsigned int bytes; +QCow2ClusterType type;int ret, status =0 ;qemu_co_mutex_lock (&s->lock);
@@ -1984,7 +1985,7 @@ static int coroutine_fn qcow2_co_block_status(BlockDriverState *bs, } bytes =MIN (INT_MAX , count); - ret =qcow2_get_host_offset (bs, offset, &bytes, &host_offset); + ret =qcow2_get_host_offset (bs, offset, &bytes, &host_offset, &type);qemu_co_mutex_unlock (&s->lock);if (ret <0 ) {return ret;
@@ -1992,15 +1993,15 @@ static int coroutine_fn qcow2_co_block_status(BlockDriverState *bs, *pnum = bytes; -if ((ret ==QCOW2_CLUSTER_NORMAL || ret ==QCOW2_CLUSTER_ZERO_ALLOC ) && +if ((type ==QCOW2_CLUSTER_NORMAL || type ==QCOW2_CLUSTER_ZERO_ALLOC ) && !s->crypto) { *map = host_offset; *file = s->data_file->bs; status |=BDRV_BLOCK_OFFSET_VALID ; } -if (ret ==QCOW2_CLUSTER_ZERO_PLAIN || ret ==QCOW2_CLUSTER_ZERO_ALLOC ) { +if (type ==QCOW2_CLUSTER_ZERO_PLAIN || type ==QCOW2_CLUSTER_ZERO_ALLOC ) { status |=BDRV_BLOCK_ZERO ; - }else if (ret !=QCOW2_CLUSTER_UNALLOCATED ) { + }else if (type !=QCOW2_CLUSTER_UNALLOCATED ) { status |=BDRV_BLOCK_DATA ; } if (s->metadata_preallocation && (status & BDRV_BLOCK_DATA) &&
@@ -2209,6 +2210,7 @@ static coroutine_fn int qcow2_co_preadv_part(BlockDriverState *bs,int ret =0 ;unsigned int cur_bytes;/* number of bytes in current iteration */ uint64_t host_offset =0 ; +QCow2ClusterType type;AioTaskPool *aio =NULL ;while (bytes !=0 &&aio_task_pool_status (aio) ==0 ) {
@@ -2220,22 +2222,23 @@ static coroutine_fn int qcow2_co_preadv_part(BlockDriverState *bs, }qemu_co_mutex_lock (&s->lock); - ret =qcow2_get_host_offset (bs, offset, &cur_bytes, &host_offset); + ret =qcow2_get_host_offset (bs, offset, &cur_bytes, + &host_offset, &type);qemu_co_mutex_unlock (&s->lock);if (ret <0 ) { goto out; } -if (ret ==QCOW2_CLUSTER_ZERO_PLAIN || - ret ==QCOW2_CLUSTER_ZERO_ALLOC || - (ret ==QCOW2_CLUSTER_UNALLOCATED && !bs->backing)) +if (type ==QCOW2_CLUSTER_ZERO_PLAIN || + type ==QCOW2_CLUSTER_ZERO_ALLOC || + (type ==QCOW2_CLUSTER_UNALLOCATED && !bs->backing)) {qemu_iovec_memset (qiov, qiov_offset,0 , cur_bytes); }else {if (!aio && cur_bytes != bytes) { aio =aio_task_pool_new (QCOW2_MAX_WORKERS ); } - ret =qcow2_add_task (bs, aio, qcow2_co_preadv_task_entry, ret, + ret =qcow2_add_task (bs, aio, qcow2_co_preadv_task_entry, type, host_offset, offset, cur_bytes, qiov, qiov_offset,NULL );if (ret <0 ) {
@@ -3737,6 +3740,7 @@ static coroutine_fn int qcow2_co_pwrite_zeroes(BlockDriverState *bs,if (head || tail) {uint64_t off;unsigned int nr; +QCow2ClusterType type;assert (head + bytes <= s->cluster_size);
@@ -3752,10 +3756,11 @@ static coroutine_fn int qcow2_co_pwrite_zeroes(BlockDriverState *bs, offset =QEMU_ALIGN_DOWN (offset, s->cluster_size); bytes = s->cluster_size; nr = s->cluster_size; - ret =qcow2_get_host_offset (bs, offset, &nr, &off); -if (ret !=QCOW2_CLUSTER_UNALLOCATED && - ret !=QCOW2_CLUSTER_ZERO_PLAIN && - ret !=QCOW2_CLUSTER_ZERO_ALLOC ) { + ret =qcow2_get_host_offset (bs, offset, &nr, &off, &type); +if (ret <0 || + (type !=QCOW2_CLUSTER_UNALLOCATED && + type !=QCOW2_CLUSTER_ZERO_PLAIN && + type !=QCOW2_CLUSTER_ZERO_ALLOC )) {qemu_co_mutex_unlock (&s->lock);return -ENOTSUP ; }
@@ -3819,16 +3824,18 @@ qcow2_co_copy_range_from(BlockDriverState *bs,while (bytes !=0 ) {uint64_t copy_offset =0 ; +QCow2ClusterType type;/* prepare next request */ cur_bytes =MIN (bytes,INT_MAX ); cur_write_flags = write_flags; - ret =qcow2_get_host_offset (bs, src_offset, &cur_bytes, ©_offset); + ret =qcow2_get_host_offset (bs, src_offset, &cur_bytes, + ©_offset, &type);if (ret <0 ) { goto out; } -switch (ret) { +switch (type) {case QCOW2_CLUSTER_UNALLOCATED :if (bs->backing && bs->backing->bs) {int64_t backing_length =bdrv_getlength (bs->backing->bs);
Signature · 1 line
2.20.1
Re: [PATCH v5 05/31] qcow2: Process QCOW2_CLUSTER_ZERO_ALLOC clusters in handle_copied()
In reply to Alberto GarciaQuoted 41 lines · Alberto Garcia
When writing to a qcow2 file there are two functions that take a virtual offset and return a host offset, possibly allocating new clusters if necessary:
-
handle_copied()looks for normal data clusters that are already allocated and have a reference count of 1. In those clusters we can simply write the data and there is no need to perform any copy-on-write.-
handle_alloc()looks for clusters that do need copy-on-write, either because they haven't been allocated yet, because their reference count is != 1 or because they areZERO_ALLOCclusters.The
ZERO_ALLOCcase is a bit special because those are clusters that are already allocated and they could perfectly be dealt with inhandle_copied()(as long as copy-on-write is performed when required).In fact, there is extra code specifically for them in
handle_alloc()that tries to reuse the existing allocation if possible and frees them otherwise.This patch changes the handling of
ZERO_ALLOCclusters so the semantics of these two functions are now like this:-
handle_copied()looks for clusters that are already allocated and which we can overwrite (NORMAL andZERO_ALLOCclusters with a reference count of 1).-
handle_alloc()looks for clusters for which we need a new allocation (all other cases).One important difference after this change is that clusters found in
handle_copied()may now require copy-on-write, but this will be necessary anyway once we add support for subclusters.Signed-off-by Alberto Garcia <[email protected]>--- block/qcow2-cluster.c | 256 +++++++++++++++++++++++------------------- 1 file changed, 141 insertions(+), 115 deletions(-)
block/qcow2-cluster.c void qcow2_alloc_cluster_abort(BlockDriverState *bs, QCowL2Meta *m) · line 1062
Quoted 6 lines
block/qcow2-cluster.c +1
-1@@ -1053,15 +1058,53 @@ void qcow2_alloc_cluster_abort(BlockDriverState *bs, QCowL2Meta *m)static void calculate_l2_meta (BlockDriverState *bs,uint64_t host_cluster_offset,uint64_t guest_offset,unsigned bytes, -QCowL2Meta **m,bool keep_old) +uint64_t *l2_slice,QCowL2Meta **m,bool keep_old) {
Borderline long line, but it fits ;)
Quoted 20 lines
block/qcow2-cluster.c +13
-2BDRVQcow2State *s = bs->opaque; -unsigned cow_start_from =0 ; +int l2_index =offset_to_l2_slice_index (s, guest_offset); +uint64_t l2_entry; +unsigned cow_start_from, cow_end_to;unsigned cow_start_to =offset_into_cluster (s, guest_offset);unsigned cow_end_from = cow_start_to + bytes; -unsigned cow_end_to =ROUND_UP (cow_end_from, s->cluster_size);unsigned nb_clusters =size_to_clusters (s, cow_end_from);QCowL2Meta *old_m = *m; +QCow2ClusterType type; + +assert (nb_clusters <= s->l2_slice_size - l2_index); + +/* Return if there's no COW (all clusters are normal and we keep them) */ +if (keep_old) { +int i; +for (i =0 ; i < nb_clusters; i++) { + l2_entry =be64_to_cpu (l2_slice[l2_index + i]); +if (qcow2_get_cluster_type (bs, l2_entry) !=QCOW2_CLUSTER_NORMAL ) {
block/qcow2-cluster.c void qcow2_alloc_cluster_abort(BlockDriverState *bs, QCowL2Meta *m) · line 1090
Quoted 10 lines
block/qcow2-cluster.c +10
-0+break ; + } + } +if (i == nb_clusters) { +return ; + } + } + +/* Get the L2 entry of the first cluster */ + l2_entry =be64_to_cpu (l2_slice[l2_index]);
This is the second time we're grabbing the first entry in this function. But I don't think it's worth trying to micro-optimize.
block/qcow2-cluster.c static bool cluster_needs_cow(BlockDriverState *bs, uint64_t l2_entry) · line 1178
Quoted 13 lines
block/qcow2-cluster.c +7
-2+static int count_single_write_clusters (BlockDriverState *bs,int nb_clusters, +uint64_t *l2_slice,int l2_index, +bool new_alloc) { +BDRVQcow2State *s = bs->opaque; +uint64_t l2_entry =be64_to_cpu (l2_slice[l2_index]); +uint64_t expected_offset = l2_entry &L2E_OFFSET_MASK ;int i;for (i =0 ; i < nb_clusters; i++) { -uint64_t l2_entry =be64_to_cpu (l2_slice[l2_index + i]); -if (!cluster_needs_cow (bs, l2_entry)) { + l2_entry =be64_to_cpu (l2_slice[l2_index + i]);
And another place where we compute l2_entry for the first cluster twice, and again not worth micro-optimizing.
I didn't find anything that needs a change.
Signature · 3 lines
Eric Blake, Principal Software Engineer Red Hat, Inc. +1-919-301-3226 Virtualization: qemu.org | libvirt.org
Re: [PATCH v5 07/31] qcow2: Document the Extended L2 Entries feature
In reply to Alberto GarciaQuoted 16 lines · Alberto Garcia
Subcluster allocation in qcow2 is implemented by extending the existing L2 table entries and adding additional information to indicate the allocation status of each subcluster.
This patch documents the changes to the qcow2 format and how they affect the calculation of the L2 cache size.
Signed-off-by Alberto Garcia <[email protected]>Reviewed-by Max Reitz <[email protected]>--- docs/interop/qcow2.txt | 68 ++++++++++++++++++++++++++++++++++++++++-- docs/qcow2-cache.txt | 19 +++++++++++- 2 files changed, 83 insertions(+), 4 deletions(-)
docs/interop/qcow2.txt Standard Cluster Descriptor: · line 561
Quoted 6 lines
docs/interop/qcow2.txt +2
-1@@ -547,7 +557,8 @@ Standard Cluster Descriptor: nor is data read from the backing file if the cluster is unallocated. - With version 2, this is always 0. + With version 2 or with extended L2 entries (see the next + section), this is always 0.
In your cover letter, you said you changed things to tolerate this bit being set even with extended L2 entries. Does this sentence need a tweak?
Quoted 16 lines
docs/interop/qcow2.txt +9
-01 - 8: Reserved (set to 0)@@ -584,6 +595,57 @@ file (except if bit 0 in the Standard Cluster Descriptor is set). If there is no backing file or the backing file is smaller than the image, they shall read zeros for all parts that are not covered by the backing file. +== Extended L2 Entries == + +An image uses Extended L2 Entries if bit 4 is set on the incompatible_features +field of the header. + +In these images standard data clusters are divided into 32 subclusters of the +same size. They are contiguous and start from the beginning of the cluster. +Subclusters can be allocated independently and the L2 entry contains information +indicating the status of each one of them. Compressed data clusters don't have
docs/interop/qcow2.txt file (except if bit 0 in the Standard Cluster Descriptor is set). If there is · line 616
Quoted 10 lines
docs/interop/qcow2.txt +10
-0+subclusters so they are treated the same as in images without this feature. + +The size of an extended L2 entry is 128 bits so the number of entries per table +is calculated using this formula: + + l2_entries = (cluster_size / (2 * sizeof(uint64_t))) + +The first 64 bits have the same format as the standard L2 table entry described +in the previous section, with the exception of bit 0 of the standard cluster +descriptor.
Also this sentence.
docs/interop/qcow2.txt file (except if bit 0 in the Standard Cluster Descriptor is set). If there is · line 622
Quoted 6 lines
docs/interop/qcow2.txt +6
-0+ +The last 64 bits contain a subcluster allocation bitmap with this format: + +Subcluster Allocation Bitmap (for standard clusters): + + Bit 0 - 31: Allocation status (one bit per subcluster)
Why two spaces after '-'? I understand it in situations like '0 - 3' in the same list as '16 - 19', to make for a right-justified column, but here, everything in the second column is two digits, so the extra padding doesn't add anything useful. Or did you mean to have '64 - 95' and '96 - 127', making it obvious that these are the second set of bits on top of the existing bits in the first 8 bytes?
Quoted 10 lines
docs/interop/qcow2.txt +10
-0+ + 1: the subcluster is allocated. In this case the + host cluster offset field must contain a valid + offset. + 0: the subcluster is not allocated. In this case + read requests shall go to the backing file or + return zeros if there is no backing file data. + + Bits are assigned starting from the least significant + one (i.e. bit x is used for subcluster x).
docs/interop/qcow2.txt file (except if bit 0 in the Standard Cluster Descriptor is set). If there is · line 642
Quoted 10 lines
docs/interop/qcow2.txt +10
-0+ + 32 - 63 Subcluster reads as zeros (one bit per subcluster) + + 1: the subcluster reads as zeros. In this case the + allocation status bit must be unset. The host + cluster offset field may or may not be set. + 0: no effect. + + Bits are assigned starting from the least significant + one (i.e. bit x is used for subcluster x - 32).
Of course, if you change to 64-95 and 96-127, the two sentences mapping bit x to subcluster y need adjusting by 64 as well.
docs/interop/qcow2.txt file (except if bit 0 in the Standard Cluster Descriptor is set). If there is · line 648
Quoted 6 lines
docs/interop/qcow2.txt +6
-0+ +Subcluster Allocation Bitmap (for compressed clusters): + + Bit 0 - 63: Reserved (set to 0) + Compressed clusters don't have subclusters, + so this field is not used.
I can live with the wording as-is (since you did call out the "second 64 bits" or with the adjusted bit numberings.
Signature · 3 lines
Eric Blake, Principal Software Engineer Red Hat, Inc. +1-919-301-3226 Virtualization: qemu.org | libvirt.org
Re: [PATCH v5 11/31] qcow2: Add offset_into_subcluster() and size_to_subclusters()
In reply to Alberto GarciaQuoted 15 lines · Alberto Garcia
Like
offset_into_cluster()andsize_to_clusters(), but for subclusters.Signed-off-by Alberto Garcia <[email protected]>--- block/qcow2.h | 10 ++++++++++ 1 file changed, 10 insertions(+)block/qcow2.h +0
-0@@ -537,11 +537,21 @@ static inline int64_t offset_into_cluster(BDRVQcow2State *s, int64_t offset)return offset & (s->cluster_size -1 ); }
block/qcow2.h static inline int64_t offset_into_cluster(BDRVQcow2State *s, int64_t offset) · line 548
Quoted 10 lines
block/qcow2.h +5
-0+static inline int64_t offset_into_subcluster (BDRVQcow2State *s,int64_t offset) +{ +return offset & (s->subcluster_size -1 ); +} +static inline uint64_t size_to_clusters (BDRVQcow2State *s,uint64_t size) {return (size + (s->cluster_size -1 )) >> s->cluster_bits; }
Pre-existing, but this could use DIV_ROUND_UP.
block/qcow2.h static inline int64_t offset_into_cluster(BDRVQcow2State *s, int64_t offset) · line 553
Quoted 5 lines
block/qcow2.h +4
-0+static inline uint64_t size_to_subclusters (BDRVQcow2State *s,uint64_t size) +{ +return (size + (s->subcluster_size -1 )) >> s->subcluster_bits; +}
at which point, your addition could be:
return DIV_ROUND_UP(size, s->subcluster_size);
Either way,
Signature · 3 lines
Eric Blake, Principal Software Engineer Red Hat, Inc. +1-919-301-3226 Virtualization: qemu.org | libvirt.org
Re: [PATCH v5 13/31] qcow2: Update get/set_l2_entry() and add get/set_l2_bitmap()
In reply to Alberto GarciaQuoted 18 lines · Alberto Garcia
Extended L2 entries are 128-bit wide: 64 bits for the entry itself and 64 bits for the subcluster allocation bitmap.
In order to support them correctly get/set_l2_entry() need to be updated so they take the entry width into account in order to calculate the correct offset.
This patch also adds the get/set_l2_bitmap() functions that are used to access the bitmaps. For convenience we allow calling
get_l2_bitmap()on images without subclusters. In this case the returned value is always 0 and has no meaning.Signed-off-by Alberto Garcia <[email protected]>--- block/qcow2.h | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+)
block/qcow2.h static inline size_t l2_entry_size(BDRVQcow2State *s) · line 546
Quoted 7 lines
block/qcow2.h +7
-0+static inline void set_l2_bitmap (BDRVQcow2State *s,uint64_t *l2_slice, +int idx,uint64_t bitmap) +{ +assert (has_subclusters (s)); + idx *=l2_entry_size (s) /sizeof (uint64_t ); + l2_slice[idx +1 ] =cpu_to_be64 (bitmap); +}
Unrelated to this patch, but I just thought of it:
What happens for an image whose size is not cluster-aligned? Must the bits corresponding to subclusters not present in the final cluster always be zero, or are they instead ignored regardless of value?
But for this patch:
Signature · 3 lines
Eric Blake, Principal Software Engineer Red Hat, Inc. +1-919-301-3226 Virtualization: qemu.org | libvirt.org
Re: [PATCH v5 14/31] qcow2: Add QCow2SubclusterType and qcow2_get_subcluster_type()
In reply to Alberto GarciaQuoted 20 lines · Alberto Garcia
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_COMPRESSEDmeans that the whole cluster is compressed. We do not support compression at the subcluster level.
Quoted 6 lines
b) There are two different values for unallocated subclusters:
QCOW2_SUBCLUSTER_UNALLOCATED_PLAINwhich means that the whole cluster is unallocated, andQCOW2_SUBCLUSTER_UNALLOCATED_ALLOCwhich 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.
Quoted 24 lines
c)
QCOW2_SUBCLUSTER_INVALIDis 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_INVALIDis only returned for images with extended L2 entries.
qcow2_cluster_to_subcluster_type()is added as a separate function fromqcow2_get_subcluster_type(), but this is only temporary and both will be merged in a subsequent patch.Signed-off-by Alberto Garcia <[email protected]>--- block/qcow2.h | 127 +++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 126 insertions(+), 1 deletion(-)block/qcow2.h +0
-0
block/qcow2.h line 89
Quoted 10 lines
block/qcow2.h +7
-0@@ -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?)
block/qcow2.h line 92
Quoted 3 lines
block/qcow2.h +3
-0+/* 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.
block/qcow2.h line 96
Quoted 4 lines
block/qcow2.h +4
-0+/* 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.
Signature · 3 lines
Eric Blake, Principal Software Engineer Red Hat, Inc. +1-919-301-3226 Virtualization: qemu.org | libvirt.org
Re: [PATCH v5 15/31] qcow2: Add qcow2_cluster_is_allocated()
In reply to Alberto GarciaQuoted 7 lines · Alberto Garcia
This helper function tells us if a cluster is allocated (that is, there is an associated host offset for it).
Signed-off-by Alberto Garcia <[email protected]>--- block/qcow2.h | 6 ++++++ 1 file changed, 6 insertions(+)
Quoted 19 lines
block/qcow2.h +6
-0@@ -763,6 +763,12 @@ QCow2SubclusterType qcow2_get_subcluster_type(BlockDriverState *bs, } } +static inline bool qcow2_cluster_is_allocated (QCow2ClusterType type) +{ +return (type ==QCOW2_CLUSTER_COMPRESSED || type ==QCOW2_CLUSTER_NORMAL || + type ==QCOW2_CLUSTER_ZERO_ALLOC ); +} +/* Check whether refcounts are eager or lazy */ static inline bool qcow2_need_accurate_refcounts (BDRVQcow2State *s) {
Signature · 3 lines
Eric Blake, Principal Software Engineer Red Hat, Inc. +1-919-301-3226 Virtualization: qemu.org | libvirt.org
Re: [PATCH v5 19/31] qcow2: Add subcluster support to calculate_l2_meta()
In reply to Alberto GarciaQuoted 48 lines · Alberto Garcia
If an image has subclusters then there are more copy-on-write scenarios that we need to consider. Let's say we have a write request from the middle of subcluster #3 until the end of the cluster:
1) If we are writing to a newly allocated cluster then we need copy-on-write. The previous contents of subclusters #0 to #3 must be copied to the new cluster. We can optimize this process by skipping all leading unallocated or zero subclusters (the status of those skipped subclusters will be reflected in the new L2 bitmap).
2) If we are overwriting an existing cluster:
2.1) If subcluster #3 is unallocated or has the all-zeroes bit set
then we need copy-on-write (on subcluster #3 only).2.2) If subcluster #3 was already allocated then there is no need
for any copy-on-write. However we still need to update the L2 bitmap to reflect possible changes in the allocation status of subclusters #4 to #31. Because of this, this function checks if all the overwritten subclusters are already allocated and in this case it returns without creating a new QCowL2Meta structure.After all these changes
l2meta_cow_start()andl2meta_cow_end()are not necessarily cluster-aligned anymore. We need to update the calculation ofold_startandold_endinhandle_dependencies()to guarantee that no two requests try to write on the same cluster.Signed-off-by Alberto Garcia <[email protected]>--- block/qcow2-cluster.c | 174 +++++++++++++++++++++++++++++++++++------- 1 file changed, 146 insertions(+), 28 deletions(-)block/qcow2-cluster.c +8
-4-/* Return if there's no COW (all clusters are normal and we keep them) */ +/* Return if there's no COW (all subclusters are normal and we are +* keeping the clusters) */ if (keep_old) { +unsigned first_sc = cow_start_to / s->subcluster_size; +unsigned last_sc = (cow_end_from -1 ) / s->subcluster_size;int i; -for (i =0 ; i < nb_clusters; i++) { - l2_entry =get_l2_entry (s, l2_slice, l2_index + i); -if (qcow2_get_cluster_type (bs, l2_entry) !=QCOW2_CLUSTER_NORMAL ) { +for (i = first_sc; i <= last_sc; i++) { +unsigned c = i / s->subclusters_per_cluster; +unsigned sc = i % s->subclusters_per_cluster; + l2_entry =get_l2_entry (s, l2_slice, l2_index + c);
block/qcow2-cluster.c void qcow2_alloc_cluster_abort(BlockDriverState *bs, QCowL2Meta *m) · line 1100
Quoted 10 lines
block/qcow2-cluster.c +7
-0+ l2_bitmap =get_l2_bitmap (s, l2_slice, l2_index + c); + type =qcow2_get_subcluster_type (bs, l2_entry, l2_bitmap, sc); +if (type ==QCOW2_SUBCLUSTER_INVALID ) { + l2_index += c;/* Point to the invalid entry */ + goto fail; + } +if (type !=QCOW2_SUBCLUSTER_NORMAL ) {break ; } }
This loop is now 32 times slower (for extended L2 entries). Do you really need to check for an invalid subcluster here, or can we just blindly check that all 32 subclusters are NORMAL, and leave handling of invalid clusters for the rest of the function after we failed the exit-early test? For that matter, for all but the first and last cluster, checking if 32 clusters are NORMAL is a simple 64-bit comparison rather than 32 iterations of a loop; and even for the first and last cluster, the _RANGE macros in 14/31 work well to mask out which bits must be set/cleared. My guess is that optimizing this loop is worthwhile, since overwriting existing data is probably more common than allocating new data.
block/qcow2-cluster.c void qcow2_alloc_cluster_abort(BlockDriverState *bs, QCowL2Meta *m) · line 1104
Quoted 6 lines
block/qcow2-cluster.c +2
-2-if (i == nb_clusters) { -return ; +if (i == last_sc +1 ) { +return 0 ; } }
If we get here, then i is now the address of the first subcluster that was not NORMAL, even if it is much smaller than the final subcluster learned by nb_clusters for the overall request. [1]
Quoted 25 lines
/* Get the L2 entry of the first cluster */ l2_entry = get_l2_entry(s, l2_slice, l2_index);block/qcow2-cluster.c +18
-3- type =qcow2_get_cluster_type (bs, l2_entry); + l2_bitmap =get_l2_bitmap (s, l2_slice, l2_index); + sc_index =offset_to_sc_index (s, guest_offset); + type =qcow2_get_subcluster_type (bs, l2_entry, l2_bitmap, sc_index); -if (type ==QCOW2_CLUSTER_NORMAL && keep_old) { - cow_start_from = cow_start_to; +if (type ==QCOW2_SUBCLUSTER_INVALID ) { + goto fail; + } + +if (!keep_old) { +switch (type) { +case QCOW2_SUBCLUSTER_COMPRESSED : + cow_start_from =0 ; +break ; +case QCOW2_SUBCLUSTER_NORMAL : +case QCOW2_SUBCLUSTER_ZERO_ALLOC : +case QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC : { +int i; +/* Skip all leading zero and unallocated subclusters */ +for (i =0 ; i < sc_index; i++) {
block/qcow2-cluster.c void qcow2_alloc_cluster_abort(BlockDriverState *bs, QCowL2Meta *m) · line 1136
Quoted 10 lines
block/qcow2-cluster.c +10
-0+QCow2SubclusterType t; + t =qcow2_get_subcluster_type (bs, l2_entry, l2_bitmap, i); +if (t ==QCOW2_SUBCLUSTER_INVALID ) { + goto fail; + }else if (t ==QCOW2_SUBCLUSTER_NORMAL ) { +break ; + } + } + cow_start_from = i << s->subcluster_bits; +break ;
Note that you are only skipping until the first normal subcluster, even if other zero/unallocated clusters occur between the first normal cluster and the start of the action. Or visually, suppose we have:
--0-NN-0_NNNNNNNN_NNNNNNNN_NNNNNNNN
as our 32 subclusters, with sc_index of 8. You will end up skipping subclusters 0-3, but NOT 6 and 7. Still, even though we spend time copying the allocated contents of those two subclusters, we also copy the subcluster status, and the guest still ends up reading the same data as before. I don't know if it is worth trying to further minimize I/O to non-contiguous zero/unalloc subclusters in the head.
Quoted 21 lines
block/qcow2-cluster.c +19
-1+ } +case QCOW2_SUBCLUSTER_ZERO_PLAIN : +case QCOW2_SUBCLUSTER_UNALLOCATED_PLAIN : + cow_start_from = sc_index << s->subcluster_bits; +break ; +default : +g_assert_not_reached (); + } }else { - cow_start_from =0 ; +switch (type) { +case QCOW2_SUBCLUSTER_NORMAL : + cow_start_from = cow_start_to; +break ; +case QCOW2_SUBCLUSTER_ZERO_ALLOC : +case QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC : + cow_start_from = sc_index << s->subcluster_bits; +break ; +default : +g_assert_not_reached (); + }
block/qcow2-cluster.c void qcow2_alloc_cluster_abort(BlockDriverState *bs, QCowL2Meta *m) · line 1164
Quoted 10 lines
block/qcow2-cluster.c +5
-2}/* Get the L2 entry of the last cluster */ - l2_entry =get_l2_entry (s, l2_slice, l2_index + nb_clusters -1 ); - type =qcow2_get_cluster_type (bs, l2_entry); + l2_index += nb_clusters -1 ; + l2_entry =get_l2_entry (s, l2_slice, l2_index); + l2_bitmap =get_l2_bitmap (s, l2_slice, l2_index); + sc_index =offset_to_sc_index (s, guest_offset + bytes -1 ); + type =qcow2_get_subcluster_type (bs, l2_entry, l2_bitmap, sc_index);
[1] but here, we are skipping any intermediate clusters, and worrying only about the state of the final cluster. Is that always going to do the correct thing, or will there be cases where we need to update the L2 entries of intermediate clusters? If we don't check specifically for INVALID in the initial subcluster, but instead break the loop as soon as we find non-NORMAL, then it seems like the rest of the function should fragment the overall request to deal with just the clusters up to the point where we found a non-NORMAL, and leave the remaining portion of the original request for another round.
Thus, I'm not convinced that this patch is quite right.
Signature · 3 lines
Eric Blake, Principal Software Engineer Red Hat, Inc. +1-919-301-3226 Virtualization: qemu.org | libvirt.org
Re: [PATCH v5 11/31] qcow2: Add offset_into_subcluster() and size_to_subclusters()
In reply to Eric BlakeQuoted 17 lines · Eric Blake
Quoted 16 lines · Alberto Garcia
Like
offset_into_cluster()andsize_to_clusters(), but for subclusters.Signed-off-by Alberto Garcia <[email protected]>--- block/qcow2.h | 10 ++++++++++ 1 file changed, 10 insertions(+)block/qcow2.h +0
-0@@ -537,11 +537,21 @@ static inline int64_t offset_into_cluster(BDRVQcow2State *s, int64_t offset)return offset & (s->cluster_size -1 ); }
Quoted 11 lines
block/qcow2.h static inline int64_t offset_into_cluster(BDRVQcow2State *s, int64_t offset) · line 548
Quoted 9 lines
block/qcow2.h +5
-0+static inline int64_t offset_into_subcluster (BDRVQcow2State *s,int64_t offset) +{ +return offset & (s->subcluster_size -1 ); +} +static inline uint64_t size_to_clusters (BDRVQcow2State *s,uint64_t size) {return (size + (s->cluster_size -1 )) >> s->cluster_bits; }Pre-existing, but this could use
DIV_ROUND_UP.
Yeah but it would be nicer to have a version of the macro optimized for powers of two.
Berto
Re: [PATCH v5 13/31] qcow2: Update get/set_l2_entry() and add get/set_l2_bitmap()
In reply to Eric BlakeQuoted 3 lines · Eric Blake
What happens for an image whose size is not cluster-aligned? Must the bits corresponding to subclusters not present in the final cluster always be zero, or are they instead ignored regardless of value?
Attempting to read or write beyond the end of the image returns an error (see blk_check_byte_request()).
But let's say we have a 32k image (only 1/2 of the first cluster is used) and we manipulate the bitmap to mark all subclusters as allocated.
In this case if you try 'read 0 32k' then count_contiguous_subclusters() would indeed say that there are 64k of data available. However the caller knows that we only want 32k and
if (bytes_available > bytes_needed) {
bytes_available = bytes_needed;
}so in the end it doesn't really matter.
I think in practice it's the same as with traditional qcow2 images: once we reach qcow2_get_host_offset() the code does not really know or care about the size of the image or how much of the last cluster contains actual data. It only cares about how much data the caller needs. The limits have already been checked before.
But we could document it: "if the image size is not a multiple of the cluster size then the bits corresponding to the subclusters beyond the end of the image are ignored and should be set to zero", or something like that.
Berto
Re: [PATCH v5 07/31] qcow2: Document the Extended L2 Entries feature
In reply to Eric BlakeQuoted 20 lines · Eric Blake
Quoted 19 lines · Alberto Garcia
Subcluster allocation in qcow2 is implemented by extending the existing L2 table entries and adding additional information to indicate the allocation status of each subcluster.
This patch documents the changes to the qcow2 format and how they affect the calculation of the L2 cache size.
Signed-off-by Alberto Garcia <[email protected]>Reviewed-by Max Reitz <[email protected]>--- docs/interop/qcow2.txt | 68 ++++++++++++++++++++++++++++++++++++++++-- docs/qcow2-cache.txt | 19 +++++++++++- 2 files changed, 83 insertions(+), 4 deletions(-)docs/interop/qcow2.txt +0
-0@@ -547,7 +557,8 @@ Standard Cluster Descriptor: nor is data read from the backing file if the cluster is unallocated.
Quoted 7 lines
docs/interop/qcow2.txt Standard Cluster Descriptor: · line 561
Quoted 3 lines
docs/interop/qcow2.txt +2
-1- With version 2, this is always 0. + With version 2 or with extended L2 entries (see the next + section), this is always 0.In your cover letter, you said you changed things to tolerate this bit being set even with extended L2 entries. Does this sentence need a tweak?
Not a bad idea.
Quoted 7 lines
docs/interop/qcow2.txt file (except if bit 0 in the Standard Cluster Descriptor is set). If there is · line 622
Quoted 5 lines
docs/interop/qcow2.txt +5
-0+The last 64 bits contain a subcluster allocation bitmap with this format: + +Subcluster Allocation Bitmap (for standard clusters): + + Bit 0 - 31: Allocation status (one bit per subcluster)Why two spaces after '-'?
No reason, I guess I just didn't notice. I'll fix it.
Berto
Re: [PATCH v5 07/31] qcow2: Document the Extended L2 Entries feature
Quoted 9 lines · Alberto Garcia
Quoted 7 lines
docs/interop/qcow2.txt Standard Cluster Descriptor: · line 561
Quoted 3 lines
docs/interop/qcow2.txt +2
-1- With version 2, this is always 0. + With version 2 or with extended L2 entries (see the next + section), this is always 0.In your cover letter, you said you changed things to tolerate this bit being set even with extended L2 entries. Does this sentence need a tweak?
Not a bad idea.
I just had a look at what happens with v2 images. There the bit is actually checked and the image is marked corrupt, but that only seems to happen in qcow2_get_host_offset(). You can write to a cluster that has that bit set and QEMU won't complain (the bit is however cleared).
'qemu-img check' does not detect any inconsistency either.
As I said in my cover letter maybe it's worth preparing a separate series that adds a QCOW2_CLUSTER_INVALID type and includes all these cases.
Berto
Re: [PATCH v5 19/31] qcow2: Add subcluster support to calculate_l2_meta()
In reply to Eric BlakeQuoted 15 lines · Eric Blake
Quoted 4 lines
block/qcow2-cluster.c +4
-0+for (i = first_sc; i <= last_sc; i++) { +unsigned c = i / s->subclusters_per_cluster; +unsigned sc = i % s->subclusters_per_cluster; + l2_entry =get_l2_entry (s, l2_slice, l2_index + c);block/qcow2-cluster.c void qcow2_alloc_cluster_abort(BlockDriverState *bs, QCowL2Meta *m) · line 1100
Quoted 10 lines
block/qcow2-cluster.c +7
-0+ l2_bitmap =get_l2_bitmap (s, l2_slice, l2_index + c); + type =qcow2_get_subcluster_type (bs, l2_entry, l2_bitmap, sc); +if (type ==QCOW2_SUBCLUSTER_INVALID ) { + l2_index += c;/* Point to the invalid entry */ + goto fail; + } +if (type !=QCOW2_SUBCLUSTER_NORMAL ) {break ; } }
Quoted 11 lines
This loop is now 32 times slower (for extended L2 entries). Do you really need to check for an invalid subcluster here, or can we just blindly check that all 32 subclusters are NORMAL, and leave handling of invalid clusters for the rest of the function after we failed the exit-early test? For that matter, for all but the first and last cluster, checking if 32 clusters are NORMAL is a simple 64-bit comparison rather than 32 iterations of a loop; and even for the first and last cluster, the
_RANGEmacros in 14/31 work well to mask out which bits must be set/cleared. My guess is that optimizing this loop is worthwhile, since overwriting existing data is probably more common than allocating new data.
I think you're right, and now we have the _RANGE macros so it should be doable. I'll look into it.
Quoted 10 lines
block/qcow2-cluster.c void qcow2_alloc_cluster_abort(BlockDriverState *bs, QCowL2Meta *m) · line 1104
Quoted 6 lines
block/qcow2-cluster.c +2
-2-if (i == nb_clusters) { -return ; +if (i == last_sc +1 ) { +return 0 ; } }If we get here, then i is now the address of the first subcluster that was not NORMAL, even if it is much smaller than the final subcluster learned by
nb_clustersfor the overall request. [1]
I'm replying to this part later in [1]
Quoted 35 lines
Quoted 24 lines
/* Get the L2 entry of the first cluster */ l2_entry = get_l2_entry(s, l2_slice, l2_index);block/qcow2-cluster.c +18
-3- type =qcow2_get_cluster_type (bs, l2_entry); + l2_bitmap =get_l2_bitmap (s, l2_slice, l2_index); + sc_index =offset_to_sc_index (s, guest_offset); + type =qcow2_get_subcluster_type (bs, l2_entry, l2_bitmap, sc_index); -if (type ==QCOW2_CLUSTER_NORMAL && keep_old) { - cow_start_from = cow_start_to; +if (type ==QCOW2_SUBCLUSTER_INVALID ) { + goto fail; + } + +if (!keep_old) { +switch (type) { +case QCOW2_SUBCLUSTER_COMPRESSED : + cow_start_from =0 ; +break ; +case QCOW2_SUBCLUSTER_NORMAL : +case QCOW2_SUBCLUSTER_ZERO_ALLOC : +case QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC : { +int i; +/* Skip all leading zero and unallocated subclusters */ +for (i =0 ; i < sc_index; i++) {block/qcow2-cluster.c void qcow2_alloc_cluster_abort(BlockDriverState *bs, QCowL2Meta *m) · line 1136
Quoted 10 lines
block/qcow2-cluster.c +10
-0+QCow2SubclusterType t; + t =qcow2_get_subcluster_type (bs, l2_entry, l2_bitmap, i); +if (t ==QCOW2_SUBCLUSTER_INVALID ) { + goto fail; + }else if (t ==QCOW2_SUBCLUSTER_NORMAL ) { +break ; + } + } + cow_start_from = i << s->subcluster_bits; +break ;
Quoted 3 lines
Note that you are only skipping until the first normal subcluster, even if other zero/unallocated clusters occur between the first normal cluster and the start of the action.
That's correct.
Quoted 6 lines
Or visually, suppose we have:
--0-NN-0_NNNNNNNN_NNNNNNNN_NNNNNNNN
as our 32 subclusters, with
sc_indexof 8. You will end up skipping subclusters 0-3, but NOT 6 and 7.
That's correct. This function works with the assumption that the initial COW region is located immediately before the data region, which is in turn contiguous to the tail COW region.
I'm actually not sure that it necessarily has to be that way, but at least it seems that functions like handle_alloc_space() rely on that. Certainly before subclusters I don't see how there would be any space between the COW regions and the actual data region.
While checking the documentation of QCowL2Meta I also realized that maybe it also needs to be updated. "The COW Region between the start of the first allocated cluster and the area the guest actually writes to", it's not necessarily the start of the cluster anymore, although the word "between" leaves some room for interpretation.
Anyway, even if we could do COW of subclusters 4-5 only, there's no general way to do that without touching QCowL2Meta or using more than one structure (imagine we have -N-N-N-N_NNNN ...). I'm also not sure that it's worth it.
Quoted 3 lines
Still, even though we spend time copying the allocated contents of those two subclusters, we also copy the subcluster status, and the guest still ends up reading the same data as before.
No, the subcluster status is updated and those subclusters are marked now as allocated. That's actually why we can use the _RANGE masks that you proposed here:
https://lists.gnu.org/archive/html/qemu-block/2020-04/msg01155.html
In other words, we have this bitmap:
--0-NN-0_NNNNNNNN_NNNNNNNN_NNNNNNNN
If we write to subcluster 8 (which was already allocated), the resulting bitmap is this one:
--0-NNNN_NNNNNNNN_NNNNNNNN_NNNNNNNN
The last block in iotest 271 deals exactly with this kind of scenarios.
Quoted 9 lines
block/qcow2-cluster.c void qcow2_alloc_cluster_abort(BlockDriverState *bs, QCowL2Meta *m) · line 1164
Quoted 8 lines
/* Get the L2 entry of the last cluster */block/qcow2-cluster.c +5
-2- l2_entry =get_l2_entry (s, l2_slice, l2_index + nb_clusters -1 ); - type =qcow2_get_cluster_type (bs, l2_entry); + l2_index += nb_clusters -1 ; + l2_entry =get_l2_entry (s, l2_slice, l2_index); + l2_bitmap =get_l2_bitmap (s, l2_slice, l2_index); + sc_index =offset_to_sc_index (s, guest_offset + bytes -1 ); + type =qcow2_get_subcluster_type (bs, l2_entry, l2_bitmap, sc_index);
Quoted 4 lines
[1] but here, we are skipping any intermediate clusters, and worrying only about the state of the final cluster. Is that always going to do the correct thing, or will there be cases where we need to update the L2 entries of intermediate clusters?
Cluster 1 Cluster 2 Cluster 3
|---------------------|---------------------|---------------------|
<---cow_start--><-------write request--------><--cow_end--->
All L2 entries from the beginning of cow_start until the end of cow_end are always updated. That's again what the loop that I optimized using the _RANGE masks (and that I liked above) was doing.
The code in calculate_l2_meta() is only concerned with determining the actual start and end points. Everything between them will be written to and marked as allocated. It's only the subclusters outside that range that keep the previous values (unallocated, or zero).
Berto
Eric Blake
Reviewed-byRe: [PATCH v5 19/31] qcow2: Add subcluster support to calculate_l2_meta()
Quoted 17 lines · Alberto Garcia
Quoted 3 lines
Note that you are only skipping until the first normal subcluster, even if other zero/unallocated clusters occur between the first normal cluster and the start of the action.
That's correct.
Quoted 6 lines
Or visually, suppose we have:
--0-NN-0_NNNNNNNN_NNNNNNNN_NNNNNNNN
as our 32 subclusters, with
sc_indexof 8. You will end up skipping subclusters 0-3, but NOT 6 and 7.That's correct. This function works with the assumption that the initial COW region is located immediately before the data region, which is in turn contiguous to the tail COW region.
...
Quoted 12 lines
Quoted 3 lines
Still, even though we spend time copying the allocated contents of those two subclusters, we also copy the subcluster status, and the guest still ends up reading the same data as before.
No, the subcluster status is updated and those subclusters are marked now as allocated. That's actually why we can use the
_RANGEmasks that you proposed here:https://lists.gnu.org/archive/html/qemu-block/2020-04/msg01155.htmlIn other words, we have this bitmap:
Quoted 8 lines
--0-NN-0_NNNNNNNN_NNNNNNNN_NNNNNNNNIf we write to subcluster 8 (which was already allocated), the resulting bitmap is this one:
--0-NNNN_NNNNNNNN_NNNNNNNN_NNNNNNNN
The last block in iotest 271 deals exactly with this kind of scenarios.
Ah, that's what I was missing. So we indeed do more I/O than strictly necessary (by reading from the backing file or writing explicit zeroes rather than leaving unallocated or zero subclusters), but we are careful that the COW range of the operation puts the correct data into the head and tail (either from the backing file or explicitly zero) so that even though the status changes to N, the guest still sees the same contents.
I also agree that it is not worth trying to optimize to those later subclusters - it adds a lot of complexity for something that does not occur as frequently. It is more important to optimize to the initial sequence of unalloc/zero clusters, but once we hit data, taking the penalty of COWing a few extra subclusters isn't going to be much worse.
Quoted 15 lines
Quoted 10 lines
block/qcow2-cluster.c void qcow2_alloc_cluster_abort(BlockDriverState *bs, QCowL2Meta *m) · line 1164
Quoted 9 lines
/* Get the L2 entry of the last cluster */block/qcow2-cluster.c +5
-2- l2_entry =get_l2_entry (s, l2_slice, l2_index + nb_clusters -1 ); - type =qcow2_get_cluster_type (bs, l2_entry); + l2_index += nb_clusters -1 ; + l2_entry =get_l2_entry (s, l2_slice, l2_index); + l2_bitmap =get_l2_bitmap (s, l2_slice, l2_index); + sc_index =offset_to_sc_index (s, guest_offset + bytes -1 ); + type =qcow2_get_subcluster_type (bs, l2_entry, l2_bitmap, sc_index);Quoted 4 lines
[1] but here, we are skipping any intermediate clusters, and worrying only about the state of the final cluster. Is that always going to do the correct thing, or will there be cases where we need to update the L2 entries of intermediate clusters?
Quoted 8 lines
Cluster 1 Cluster 2 Cluster 3
|---------------------|---------------------|---------------------|<---cow_start--><-------write request--------><--cow_end--->All L2 entries from the beginning of
cow_startuntil the end ofcow_endare always updated. That's again what the loop that I optimized using the_RANGEmasks (and that I liked above) was doing.
I guess the other thing that helps is that even if there are intermediate invalid subclusters, ideally the caller of this function is setting nb_clusters according to its own scan of how many contiguous clusters are even available for us to attempt to write into. So patch 20/31 catches the case where we don't have contiguous clusters if any of the subclusters are invalid. And in _this_ patch, it shouldn't really matter if we don't detect that we are overwriting what used to be an invalid subcluster with something that is now valid data.
Quoted 5 lines
The code in
calculate_l2_meta()is only concerned with determining the actual start and end points. Everything between them will be written to and marked as allocated. It's only the subclusters outside that range that keep the previous values (unallocated, or zero).
I think you've convinced me that we are safe on what this function does.
In fact, if we rely on 20/31 checking for invalid subclusters when
computing nb_clusters, we could probably assert that the start and end cluster in this function are not invalid, instead of adding the fail: label. But even if you don't do that, I can live with:
Signature · 3 lines
Eric Blake, Principal Software Engineer Red Hat, Inc. +1-919-301-3226 Virtualization: qemu.org | libvirt.org
Re: [PATCH v5 20/31] qcow2: Add subcluster support to qcow2_get_host_offset()
In reply to Alberto GarciaQuoted 5 lines · Alberto Garcia
The logic of this function remains pretty much the same, except that it uses
count_contiguous_subclusters(), which combines the logic ofcount_contiguous_clusters()/count_contiguous_clusters_unallocated()and checks individual subclusters.
Maybe mention that qcow2_cluster_to_subcluster_type() is now inlined into its lone remaining caller.
Quoted 12 lines
Signed-off-by Alberto Garcia <[email protected]>--- block/qcow2.h | 38 +++++------- block/qcow2-cluster.c | 141 ++++++++++++++++++++---------------------- 2 files changed, 82 insertions(+), 97 deletions(-)+++
b/block/qcow2-cluster.cblock/qcow2-cluster.c +2
-0@@ -376,66 +376,58 @@ fail: +static int count_contiguous_subclusters(BlockDriverState *bs, int nb_clusters, + unsigned sc_index, uint64_t *l2_slice,
block/qcow2-cluster.c fail: · line 388
Quoted 10 lines
block/qcow2-cluster.c +8
-0+ int l2_index) { + +assert (type !=QCOW2_SUBCLUSTER_INVALID );/* The caller should check this */ +assert (l2_index + nb_clusters <= s->l2_size); + +if (type ==QCOW2_SUBCLUSTER_COMPRESSED ) { +/* Compressed clusters are always processed one by one */ +return s->subclusters_per_cluster - sc_index;
Should this assert(sc_index == 0)?
Quoted 5 lines
block/qcow2-cluster.c +0
-4for (i =0 ; i < nb_clusters; i++) { -uint64_t entry =get_l2_entry (s, l2_slice, l2_index + i); -QCow2ClusterType type =qcow2_get_cluster_type (bs, entry); - -if (type != wanted_type) {
block/qcow2-cluster.c fail: · line 424
Quoted 10 lines
block/qcow2-cluster.c +9
-1-break ; + l2_entry =get_l2_entry (s, l2_slice, l2_index + i); + l2_bitmap =get_l2_bitmap (s, l2_slice, l2_index + i); +if (check_offset && expected_offset != (l2_entry &L2E_OFFSET_MASK )) { +return count; + } +for (j = (i ==0 ) ? sc_index :0 ; j < s->subclusters_per_cluster; j++) { +if (qcow2_get_subcluster_type (bs, l2_entry, l2_bitmap, j) != type) { +return count; + }
This really is checking that sub-clusters have the exact same type.
block/qcow2-cluster.c int qcow2_get_host_offset(BlockDriverState *bs, uint64_t offset, · line 615
Quoted 13 lines
block/qcow2-cluster.c +0
-7@@ -604,24 +604,17 @@ int qcow2_get_host_offset(BlockDriverState *bs, uint64_t offset, ret = -EIO ; goto fail; } -/* Compressed clusters can only be processed one by one */ - c =1 ; *host_offset = l2_entry &L2E_COMPRESSED_OFFSET_SIZE_MASK ;break ; -case QCOW2_CLUSTER_ZERO_PLAIN : -case QCOW2_CLUSTER_UNALLOCATED : -/* how many empty clusters ? */ - c =count_contiguous_clusters_unallocated (bs, nb_clusters, - l2_slice, l2_index, type);
The old code was counting how many contiguous clusters has similar types, coalescing ranges of two different cluster types into one nb_clusters result.
Quoted 4 lines
block/qcow2-cluster.c +2
-0+case QCOW2_SUBCLUSTER_ZERO_PLAIN : +case QCOW2_SUBCLUSTER_UNALLOCATED_PLAIN : *host_offset =0 ;break ;
block/qcow2-cluster.c int qcow2_get_host_offset(BlockDriverState *bs, uint64_t offset, · line 624
Quoted 10 lines
block/qcow2-cluster.c +3
-5-case QCOW2_CLUSTER_ZERO_ALLOC : -case QCOW2_CLUSTER_NORMAL : { +case QCOW2_SUBCLUSTER_ZERO_ALLOC : +case QCOW2_SUBCLUSTER_NORMAL : +case QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC : {uint64_t host_cluster_offset = l2_entry &L2E_OFFSET_MASK ; *host_offset = host_cluster_offset + offset_in_cluster; -/* how many allocated clusters ? */ - c =count_contiguous_clusters (bs, nb_clusters, s->cluster_size, - l2_slice, l2_index,QCOW_OFLAG_ZERO );
and here coalescing three different cluster types into one nb_clusters result.
block/qcow2-cluster.c int qcow2_get_host_offset(BlockDriverState *bs, uint64_t offset, · line 644
Quoted 9 lines
block/qcow2-cluster.c +2
-0if (offset_into_cluster (s, host_cluster_offset)) {qcow2_signal_corruption (bs, true,-1 ,-1 , "Cluster allocation offset %#"@@ -647,9 +640,11 @@ int qcow2_get_host_offset(BlockDriverState *bs, uint64_t offset,abort (); } + sc =count_contiguous_subclusters (bs, nb_clusters, sc_index, + l2_slice, l2_index);
But the new code is stopping at the first different subcluster type, rather than trying to coalesce as many compatible types into one larger nb_clusters. When coupled with patch 19, that factors into my concern over whether patch 19 needed to check for INVALID clusters in the middle, or whether its fail: label was unreachable. But it also means that you are potentially fragmenting the write in more places (every time a subcluster status changes) rather than coalescing similar status, the way the old code used to operate.
I don't think the extra fragmentation causes any correctness issues, but it may cause performance issues.
Signature · 3 lines
Eric Blake, Principal Software Engineer Red Hat, Inc. +1-919-301-3226 Virtualization: qemu.org | libvirt.org
Re: [PATCH v5 23/31] qcow2: Add subcluster support to check_refcounts_l2()
In reply to Alberto GarciaQuoted 3 lines · Alberto Garcia
Setting the
QCOW_OFLAG_ZERObit of the L2 entry is forbidden if an image has subclusters. Instead, the individual 'all zeroes' bits must be used.
Should we s/is forbidden/is ignored/ based on your spec changes?
But the patch itself is right.
Quoted 29 lines
Signed-off-by Alberto Garcia <[email protected]>Reviewed-by Max Reitz <[email protected]>Reviewed-by Vladimir Sementsov-Ogievskiy <[email protected]>--- block/qcow2-refcount.c | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-)block/qcow2-refcount.c +7
-2@@ -1686,8 +1686,13 @@ static int check_refcounts_l2(BlockDriverState *bs, BdrvCheckResult *res,int ign = active ?QCOW2_OL_ACTIVE_L2 :QCOW2_OL_INACTIVE_L2 ; - l2_entry =QCOW_OFLAG_ZERO ; -set_l2_entry (s, l2_table, i, l2_entry); +if (has_subclusters (s)) { +set_l2_entry (s, l2_table, i,0 ); +set_l2_bitmap (s, l2_table, i, +QCOW_L2_BITMAP_ALL_ZEROES ); + }else { +set_l2_entry (s, l2_table, i,QCOW_OFLAG_ZERO ); + } ret =qcow2_pre_write_overlap_check (bs, ign, l2e_offset,l2_entry_size (s), false);if (ret <0 ) {
Signature · 3 lines
Eric Blake, Principal Software Engineer Red Hat, Inc. +1-919-301-3226 Virtualization: qemu.org | libvirt.org
Re: [PATCH v5 28/31] qcow2: Add the 'extended_l2' option and the QCOW2_INCOMPAT_EXTL2 bit
In reply to Alberto GarciaQuoted 7 lines · Alberto Garcia
Now that the implementation of subclusters is complete we can finally add the necessary options to create and read images with this feature, which we call "extended L2 entries".
Signed-off-by Alberto Garcia <[email protected]>Reviewed-by Max Reitz <[email protected]>---
What you have looks good, but I didn't notice anything affecting amend. The simplest option: amend can reject attempts to toggle the extended L2 option (the zstd compression patches take that path). More complicated is actually supporting it (in either direction, turning it on or off), which requires rewriting ALL L2 tables in the entry (including any in internal snapshots), which could be quite time-intensive, and where you must be careful to stage things so that failures during partial conversion merely leave leaked clusters rather than a header pointing to a half-converted state. Either way, one of the iotests should probably add coverage on what happens when you attempt to amend the bit on or off.
Signature · 3 lines
Eric Blake, Principal Software Engineer Red Hat, Inc. +1-919-301-3226 Virtualization: qemu.org | libvirt.org
Re: [PATCH v5 29/31] qcow2: Assert that expand_zero_clusters_in_l1() does not support subclusters
In reply to Alberto GarciaQuoted 11 lines · Alberto Garcia
This function is only used by
qcow2_expand_zero_clusters()to downgrade a qcow2 image to a previous version. It is however not possible to downgrade an image with extended L2 entries because older versions of qcow2 do not have this feature.Signed-off-by Alberto Garcia <[email protected]>--- block/qcow2-cluster.c | 8 +++++++- tests/qemu-iotests/061 | 6 ++++++ tests/qemu-iotests/061.out | 5 +++++ 3 files changed, 18 insertions(+), 1 deletion(-)
Signature · 3 lines
Eric Blake, Principal Software Engineer Red Hat, Inc. +1-919-301-3226 Virtualization: qemu.org | libvirt.org
Re: [PATCH v5 30/31] qcow2: Add subcluster support to qcow2_measure()
In reply to Alberto GarciaQuoted 8 lines · Alberto Garcia
Extended L2 entries are bigger than normal L2 entries so this has an impact on the amount of metadata needed for a qcow2 file.
Signed-off-by Alberto Garcia <[email protected]>Reviewed-by Max Reitz <[email protected]>--- block/qcow2.c | 19 ++++++++++++------- 1 file changed, 12 insertions(+), 7 deletions(-)
Should this be hoisted earlier in the series, before 28/31?
Should there be iotest coverage?
Signature · 3 lines
Eric Blake, Principal Software Engineer Red Hat, Inc. +1-919-301-3226 Virtualization: qemu.org | libvirt.org
Re: [PATCH v5 28/31] qcow2: Add the 'extended_l2' option and the QCOW2_INCOMPAT_EXTL2 bit
In reply to Eric BlakeQuoted 3 lines · Eric Blake
What you have looks good, but I didn't notice anything affecting amend. The simplest option: amend can reject attempts to toggle the extended L2 option (the zstd compression patches take that path).
You're right, thanks! I think I'll just disable it, I'm not sure that it's worth the complexity.
Berto
Re: [PATCH v5 30/31] qcow2: Add subcluster support to qcow2_measure()
In reply to Eric BlakeQuoted 11 lines · Eric Blake
Quoted 8 lines · Alberto Garcia
Extended L2 entries are bigger than normal L2 entries so this has an impact on the amount of metadata needed for a qcow2 file.
Signed-off-by Alberto Garcia <[email protected]>Reviewed-by Max Reitz <[email protected]>--- block/qcow2.c | 19 ++++++++++++------- 1 file changed, 12 insertions(+), 7 deletions(-)Should this be hoisted earlier in the series, before 28/31?
I can do that if I call qcow2_calc_prealloc_size() with extended_l2 always set to false (because there would be no BLOCK_OPT_EXTL2 that the caller could use). Maybe it's not a bad idea.
Quoted 1 line
Should there be iotest coverage?
There are already, in the last patch.
Berto
Re: [PATCH v5 19/31] qcow2: Add subcluster support to calculate_l2_meta()
In reply to Eric BlakeQuoted 4 lines · Eric Blake
In fact, if we rely on 20/31 checking for invalid subclusters when
computingnb_clusters, we could probably assert that the start and end cluster in this function are not invalid, instead of adding the fail:
label.
I think you're right with that, good catch! There's no need to return an error code in this function.
Berto
Re: [PATCH v5 19/31] qcow2: Add subcluster support to calculate_l2_meta()
Quoted 8 lines · Alberto Garcia
Quoted 4 lines · Eric Blake
In fact, if we rely on 20/31 checking for invalid subclusters when
computingnb_clusters, we could probably assert that the start and end cluster in this function are not invalid, instead of adding the fail:
label.I think you're right with that, good catch! There's no need to return an error code in this function.
No, wait, I got confused.
Patch 20/31 updates qcow2_get_host_offset(), and that's used for reading.
The caller of calculate_l2_meta() is qcow2_alloc_cluster_offset() (indirectly), which is used for writing.
nb_clusters here is calculated with cluster_needs_new_alloc(), but that doesn't check whether a cluster is valid or not, and certainly doesn't check if every single subcluster is valid.
Thinking about it, there are probably faster ways to check for the validity of extended L2 entries, for example:
- For QCOW2_CLUSTER_NORMAL, (l2_bitmap >> 32) & l2_bitmap should be 0.
- For QCOW2_CLUSTER_UNALLOCATED, l2_bitmap & QCOW_L2_BITMAP_ALL_ALLOC should be 0.
That's enough to cover all cases of QCOW2_SUBCLUSTER_INVALID that we have at the moment.
Berto
Re: [PATCH v5 20/31] qcow2: Add subcluster support to qcow2_get_host_offset()
In reply to Eric BlakeQuoted 8 lines · Eric Blake
Quoted 4 lines · Alberto Garcia
The logic of this function remains pretty much the same, except that it uses
count_contiguous_subclusters(), which combines the logic ofcount_contiguous_clusters()/count_contiguous_clusters_unallocated()and checks individual subclusters.Maybe mention that
qcow2_cluster_to_subcluster_type()is now inlined into its lone remaining caller.
Ok.
Quoted 5 lines
Quoted 4 lines
block/qcow2-cluster.c +3
-0+static int count_contiguous_subclusters (BlockDriverState *bs,int nb_clusters, +unsigned sc_index,uint64_t *l2_slice, +int l2_index) {
Quoted 9 lines
block/qcow2-cluster.c fail: · line 407
Quoted 7 lines
block/qcow2-cluster.c +7
-0+ +assert (type !=QCOW2_SUBCLUSTER_INVALID );/* The caller should check this */ +assert (l2_index + nb_clusters <= s->l2_size); + +if (type ==QCOW2_SUBCLUSTER_COMPRESSED ) { +/* Compressed clusters are always processed one by one */ +return s->subclusters_per_cluster - sc_index;Should this
assert(sc_index == 0)?
No. The documentation of the function says "Compressed clusters are always processed one by one but for the purpose of this count they are treated as if they were divided into subclusters of size s->subcluster_size".
Let's say we have a compressed cluster at offset 0 (size 64k) and we perform a read request with offset=32k, size=8k.
qcow2_co_preadv_part() calls qcow2_get_host_offset() and asks "How many bytes up to 8k can we read in one go at offset 32k?".
The offset is 32k so the first subcluster is #16. And this function (count_contiguous_subclusters()) is asked "how many contiguous subclusters do we have starting at subcluster #16?" and the answer is 32 - 16 = 16 subclusters.
qcow2_get_host_offset() only needs 8k/2k = 4 subclusters, so it tells the original caller (qcow2_co_preadv_part()) "you can read all 8k in one go and the subcluster type is _COMPRESSED".
Quoted 16 lines
Quoted 5 lines
for (i = 0; i < nb_clusters; i++) {block/qcow2-cluster.c +0
-4-uint64_t entry =get_l2_entry (s, l2_slice, l2_index + i); -QCow2ClusterType type =qcow2_get_cluster_type (bs, entry); - -if (type != wanted_type) {block/qcow2-cluster.c fail: · line 424
Quoted 10 lines
block/qcow2-cluster.c +9
-1-break ; + l2_entry =get_l2_entry (s, l2_slice, l2_index + i); + l2_bitmap =get_l2_bitmap (s, l2_slice, l2_index + i); +if (check_offset && expected_offset != (l2_entry &L2E_OFFSET_MASK )) { +return count; + } +for (j = (i ==0 ) ? sc_index :0 ; j < s->subclusters_per_cluster; j++) { +if (qcow2_get_subcluster_type (bs, l2_entry, l2_bitmap, j) != type) { +return count; + }
Quoted 1 line
This really is checking that sub-clusters have the exact same type.
Correct.
Quoted 9 lines
Quoted 9 lines
block/qcow2-cluster.c +0
-3@@ -604,24 +604,17 @@ int qcow2_get_host_offset(BlockDriverState *bs, uint64_t offset, ret = -EIO ; goto fail; } -/* Compressed clusters can only be processed one by one */ - c =1 ; *host_offset = l2_entry &L2E_COMPRESSED_OFFSET_SIZE_MASK ;break ; -case QCOW2_CLUSTER_ZERO_PLAIN :
Quoted 8 lines
block/qcow2-cluster.c int qcow2_get_host_offset(BlockDriverState *bs, uint64_t offset, · line 615
Quoted 4 lines
block/qcow2-cluster.c +0
-4-case QCOW2_CLUSTER_UNALLOCATED : -/* how many empty clusters ? */ - c =count_contiguous_clusters_unallocated (bs, nb_clusters, - l2_slice, l2_index, type);The old code was counting how many contiguous clusters has similar types, coalescing ranges of two different cluster types into one
nb_clustersresult.
Not really. The old code had three different cases in the switch() block:
- Compressed clusters: return always 1.
- Unallocated / zero_plain: count the number of clusters of the exact same type (one of the parameters was 'wanted_type').
- Normal / zero_alloc: count the number of clusters of type normal or zero_alloc that are contiguous on the image file **but stop** if the QCOW_OFLAG_ZERO flag changes. In other words, count contiguous clusters of the same type.
The new code simply merges all three cases in the same function. It could be done even without having subclusters.
Plus, the old function was also returning the cluster type, so it had to be the same one for the whole region.
Quoted 7 lines
Quoted 7 lines
block/qcow2-cluster.c +0
-0if (offset_into_cluster (s, host_cluster_offset)) {qcow2_signal_corruption (bs, true,-1 ,-1 , "Cluster allocation offset %#"@@ -647,9 +640,11 @@ int qcow2_get_host_offset(BlockDriverState *bs, uint64_t offset,abort (); }
Quoted 11 lines
block/qcow2-cluster.c int qcow2_get_host_offset(BlockDriverState *bs, uint64_t offset, · line 644
Quoted 2 lines
block/qcow2-cluster.c +2
-0+ sc =count_contiguous_subclusters (bs, nb_clusters, sc_index, + l2_slice, l2_index);But the new code is stopping at the first different subcluster type, rather than trying to coalesce as many compatible types into one larger
nb_clusters. When coupled with patch 19, that factors into my concern over whether patch 19 needed to check for INVALID clusters in the middle, or whether its fail: label was unreachable. But it also means that you are potentially fragmenting the write in more places (every time a subcluster status changes) rather than coalescing similar status, the way the old code used to operate.
Note that the functions in this patch that you're reviewing are concerned with read requests, not write requests.
Berto
Hi, Berto
Excuse me, I'd like to test v5, but I failed to apply the series to master branch. Which commit can I use?
Thanks.
Regards,
Derek
Quoted 174 lines · Alberto Garcia
Hi,
here's the new version of the patches to add subcluster allocation support to qcow2.
Please refer to the cover letter of the first version for a full description of the patches:
https://lists.gnu.org/archive/html/qemu-block/2019-10/msg00983.htmlImportant changes here:
- I fixed hopefully all of the issues mentioned in the previous review. Thanks to everyone who contributed.
- There's now support for partial zeroing of clusters (i.e. at the subcluster level).
- Many more tests.
-
QCOW_OFLAG_ZEROis simply ignored now and not considered a sign of a corrupt image anymore. I hesitated about this, but we could still add that check later. I think there's a case for adding a newQCOW2_CLUSTER_INVALIDtype and include this and other scenarios that we already consider corrupt (for example: clusters with unaligned offsets). We would need to see if for 'qemu-img check' addingQCOW2_CLUSTER_INVALIDcomplicates things or not. But I think that all is material for its own series.And I think that's all. See below for the detailed list of changes, and thanks again for the feedback.
Berto
v5:
- Patch 01: Fix indentation [Max], add trace event [Vladimir]
- Patch 02: Addhost_cluster_offsetvariable [Vladirmir]
- Patch 05: Have separatel2_entryandcluster_offsetvariables [Vladimir]
- Patch 06: Only context changes due to patch 05
- Patch 11: New patch
- Patch 13: Change documentation ofget_l2_entry()
- Patch 14: Add QCOW_OFLAG_SUB_{ALLOC,ZERO}_RANGE [Eric] and rewrite the other macros.
IgnoreQCOW_OFLAG_ZEROon images with subclusters (i.e. don't treat them as corrupted).
- Patch 15: New patch
- Patch 19: Optimize cow by skipping all leading and trailing zero and unallocated subclusters [Vladimir]
Return 0 on success [Vladimir]
Squash patch that updatedhandle_dependencies()[Vladirmir]
- Patch 20: Callcount_contiguous_subclusters()after the main switch inqcow2_get_host_offset()[Vladimir]
Add assertion and remove goto statement [Vladimir]
- Patch 21: Rewrite algorithm.
- Patch 22: Rewrite algorithm.
- Patch 24: Replace loop with the_RANGEmacros from patch 14 [Eric]
- Patch 27: New patch
- Patch 28: Update version number and expected output from tests.
- Patch 31: Add many more new testsv4: https://lists.gnu.org/archive/html/qemu-block/2020-03/msg00966.html
v3: https://lists.gnu.org/archive/html/qemu-block/2019-12/msg00587.html
v2: https://lists.gnu.org/archive/html/qemu-block/2019-10/msg01642.html
v1: https://lists.gnu.org/archive/html/qemu-block/2019-10/msg00983.htmlOutput of git backport-diff against v4:
Key:
[----] : patches are identical
[####] : number of functional differences between upstream/downstream patch [down] : patch is downstream-only
The flags [FC] indicate (F)unctional and (C)ontextual differences, respectively001/31:[0005] [FC] 'qcow2: Make Qcow2AioTask store the full host offset' 002/31:[0018] [FC] 'qcow2: Convert
qcow2_get_cluster_offset()intoqcow2_get_host_offset()' 003/31:[----] [--] 'qcow2: Addcalculate_l2_meta()'
004/31:[----] [--] 'qcow2: Splitcluster_needs_cow()out ofcount_cow_clusters()' 005/31:[0038] [FC] 'qcow2: ProcessQCOW2_CLUSTER_ZERO_ALLOCclusters inhandle_copied()' 006/31:[0004] [FC] 'qcow2: Addget_l2_entry()andset_l2_entry()'
007/31:[----] [--] 'qcow2: Document the Extended L2 Entries feature' 008/31:[----] [--] 'qcow2: Add dummyhas_subclusters()function'
009/31:[----] [--] 'qcow2: Add subcluster-related fields to BDRVQcow2State' 010/31:[----] [--] 'qcow2: Addoffset_to_sc_index()'
011/31:[down] 'qcow2: Addoffset_into_subcluster()andsize_to_subclusters()' 012/31:[----] [--] 'qcow2: Addl2_entry_size()'
013/31:[0003] [FC] 'qcow2: Update get/set_l2_entry() and add get/set_l2_bitmap()' 014/31:[0023] [FC] 'qcow2: Add QCow2SubclusterType andqcow2_get_subcluster_type()' 015/31:[down] 'qcow2: Addqcow2_cluster_is_allocated()'
016/31:[----] [--] 'qcow2: Add cluster type parameter toqcow2_get_host_offset()' 017/31:[----] [--] 'qcow2: Replace QCOW2_CLUSTER_* with QCOW2_SUBCLUSTER_*' 018/31:[----] [--] 'qcow2: HandleQCOW2_SUBCLUSTER_UNALLOCATED_ALLOC' 019/31:[0066] [FC] 'qcow2: Add subcluster support tocalculate_l2_meta()' 020/31:[0022] [FC] 'qcow2: Add subcluster support toqcow2_get_host_offset()' 021/31:[0040] [FC] 'qcow2: Add subcluster support tozero_in_l2_slice()' 022/31:[0061] [FC] 'qcow2: Add subcluster support todiscard_in_l2_slice()' 023/31:[----] [--] 'qcow2: Add subcluster support tocheck_refcounts_l2()' 024/31:[0019] [FC] 'qcow2: Update L2 bitmap inqcow2_alloc_cluster_link_l2()' 025/31:[----] [--] 'qcow2: Clear the L2 bitmap when allocating a compressed cluster' 026/31:[----] [--] 'qcow2: Add subcluster support tohandle_alloc_space()' 027/31:[down] 'qcow2: Add subcluster support toqcow2_co_pwrite_zeroes()' 028/31:[0105] [FC] 'qcow2: Add the 'extended_l2' option and theQCOW2_INCOMPAT_EXTL2bit' 029/31:[----] [-C] 'qcow2: Assert thatexpand_zero_clusters_in_l1()does not support subclusters' 030/31:[----] [--] 'qcow2: Add subcluster support toqcow2_measure()' 031/31:[0694] [FC] 'iotests: Add tests for qcow2 images with extended L2 entries'Alberto Garcia (31):
qcow2: Make Qcow2AioTask store the full host offset
qcow2: Convertqcow2_get_cluster_offset()intoqcow2_get_host_offset()
qcow2: Addcalculate_l2_meta()
qcow2: Splitcluster_needs_cow()out ofcount_cow_clusters()
qcow2: ProcessQCOW2_CLUSTER_ZERO_ALLOCclusters inhandle_copied()
qcow2: Addget_l2_entry()andset_l2_entry()
qcow2: Document the Extended L2 Entries feature
qcow2: Add dummyhas_subclusters()function
qcow2: Add subcluster-related fields to BDRVQcow2State
qcow2: Addoffset_to_sc_index()
qcow2: Addoffset_into_subcluster()andsize_to_subclusters()
qcow2: Addl2_entry_size()
qcow2: Update get/set_l2_entry() and add get/set_l2_bitmap()
qcow2: Add QCow2SubclusterType andqcow2_get_subcluster_type()
qcow2: Addqcow2_cluster_is_allocated()
qcow2: Add cluster type parameter toqcow2_get_host_offset()
qcow2: Replace QCOW2_CLUSTER_* with QCOW2_SUBCLUSTER_*
qcow2: HandleQCOW2_SUBCLUSTER_UNALLOCATED_ALLOC
qcow2: Add subcluster support tocalculate_l2_meta()
qcow2: Add subcluster support toqcow2_get_host_offset()
qcow2: Add subcluster support tozero_in_l2_slice()
qcow2: Add subcluster support todiscard_in_l2_slice()
qcow2: Add subcluster support tocheck_refcounts_l2()
qcow2: Update L2 bitmap inqcow2_alloc_cluster_link_l2()
qcow2: Clear the L2 bitmap when allocating a compressed cluster
qcow2: Add subcluster support tohandle_alloc_space()
qcow2: Add subcluster support toqcow2_co_pwrite_zeroes()
qcow2: Add the 'extended_l2' option and theQCOW2_INCOMPAT_EXTL2bit
qcow2: Assert thatexpand_zero_clusters_in_l1()does not support
subclusters
qcow2: Add subcluster support toqcow2_measure()
iotests: Add tests for qcow2 images with extended L2 entriesdocs/interop/qcow2.txt | 68 ++- docs/qcow2-cache.txt | 19 +- qapi/block-core.json | 7 + block/qcow2.h | 204 ++++++- include/block/block_int.h | 1 + block/qcow2-cluster.c | 892 ++++++++++++++++++++----------- block/qcow2-refcount.c | 38 +- block/qcow2.c | 283 ++++++---- block/trace-events | 2 +- tests/qemu-iotests/031.out | 8 +- tests/qemu-iotests/036.out | 4 +- tests/qemu-iotests/049.out | 102 ++-- tests/qemu-iotests/060.out | 1 + tests/qemu-iotests/061 | 6 + tests/qemu-iotests/061.out | 25 +- tests/qemu-iotests/065 | 18 +- tests/qemu-iotests/082.out | 48 +- tests/qemu-iotests/085.out | 38 +- tests/qemu-iotests/144.out | 4 +- tests/qemu-iotests/182.out | 2 +- tests/qemu-iotests/185.out | 8 +- tests/qemu-iotests/198.out | 2 + tests/qemu-iotests/206.out | 4 + tests/qemu-iotests/242.out | 5 + tests/qemu-iotests/255.out | 8 +- tests/qemu-iotests/271 | 664 +++++++++++++++++++++++ tests/qemu-iotests/271.out | 519 ++++++++++++++++++ tests/qemu-iotests/274.out | 49 +- tests/qemu-iotests/280.out | 2 +- tests/qemu-iotests/common.filter | 1 + tests/qemu-iotests/group | 1 + 31 files changed, 2459 insertions(+), 574 deletions(-)create mode 100755 tests/qemu-iotests/271
create mode 100644 tests/qemu-iotests/271.out
Quoted 4 lines · Derek Su
Hi, Berto
Excuse me, I'd like to test v5, but I failed to apply the series to master branch. Which commit can I use?
Try applying the patches on top of commit e4d7019e1a
Berto