block/qcow2: Image file option amendment
v5 cover block/qcow2: Image file option amendment
This series adds support to qemu-img, block and qcow2 for amending image options on existing image files.
Depends on:
- option: Add assigned flag to QEMUOptionParameter
- qcow2-refcount: Snapshot update for zero clusters (series, v3)
- Add metadata overlap checks (series, v5)
v5:
- added a new function for emptying a cache (patch 2)
- fixed rounding for the bitmap size in qcow2_expand_zero_clusters
- now empties the cache in qcow2_expand_zero_clusters instead of simply flushing it
- factored out assignment check in qcow2_amend_options
- fixed resizing by moving it to the end of qcow2_amend_options
- fixed expected test result for resizing in addition to a version upgrade
v4:
- rebased on the metadata overlap check series (and fit to it)
- split patch 2 into three distinct patches (2, 3 and 4)
- extended test for zero expansion on backed and inactive backed clusters (and fixed according to the metadata overlap check series (i.e., adjusted header length))
- fixed zero expansion with shared L2 tables
v3:
- deallocate non-preallocated zero clusters on non-backed images instead of zero expanding them
- qcow2 version downgrade: error out on refcount_order != 4
- implemented Eric's comments regarding the qemu-img amend and img_amend itself
v2:
- Generally implemented Kevin's comments, especially:
- Zero cluster expansion for inactive L2 tables
- Correct handling of preallocated zero clusters
- More test cases
Max Reitz (6):
block: Image file option amendment
qcow2-cache: Empty cache
qcow2-cluster: Expand zero clusters
qcow2: Save refcount order in BDRVQcowState
qcow2: Implement bdrv_amend_options
qemu-iotest: qcow2 image option amendment
block.c | 8 ++ block/qcow2-cache.c | 18 +++ block/qcow2-cluster.c | 233 ++++++++++++++++++++++++++++++ block/qcow2-refcount.c | 29 ++-- block/qcow2.c | 197 ++++++++++++++++++++++++- block/qcow2.h | 8 ++ include/block/block.h | 2 + include/block/block_int.h | 3 + qemu-img-cmds.hx | 6 + qemu-img.c | 84 +++++++++++ qemu-img.texi | 5 + tests/qemu-iotests/061 | 178 +++++++++++++++++++++++ tests/qemu-iotests/061.out | 349 +++++++++++++++++++++++++++++++++++++++++++++ tests/qemu-iotests/group | 1 + 14 files changed, 1106 insertions(+), 15 deletions(-) create mode 100755 tests/qemu-iotests/061 create mode 100644 tests/qemu-iotests/061.out
Signature · 1 line
1.8.3.1
PATCH v5 1/6 block: Image file option amendment
This patch adds the "amend" option to qemu-img which allows changing image options on existing image files. It also adds the generic bdrv implementation which is basically just a wrapper for the image format specific function.
--- block.c | 8 +++++ include/block/block.h | 2 ++ include/block/block_int.h | 3 ++ qemu-img-cmds.hx | 6 ++++ qemu-img.c | 84 +++++++++++++++++++++++++++++++++++++++++++++++ qemu-img.texi | 5 +++ 6 files changed, 108 insertions(+)
block.c +8 -0
@@ -4674,3 +4674,11 @@ void bdrv_add_before_write_notifier(BlockDriverState *bs, {notifier_with_return_list_add (&bs->before_write_notifiers, notifier); } + +int bdrv_amend_options (BlockDriverState *bs,QEMUOptionParameter *options) +{ +if (bs->drv->bdrv_amend_options ==NULL ) { +return -ENOTSUP ; + } +return bs->drv->bdrv_amend_options (bs, options); +}
include/block/block.h +2 -0
@@ -223,6 +223,8 @@ typedef enum {int bdrv_check (BlockDriverState *bs,BdrvCheckResult *res,BdrvCheckMode fix); +int bdrv_amend_options (BlockDriverState *bs_new,QEMUOptionParameter *options); +/* async block I/O */ typedef void BlockDriverDirtyHandler (BlockDriverState *bs,int64_t sector,int sector_num);
include/block/block_int.h +3 -0
@@ -205,6 +205,9 @@ struct BlockDriver {int (*bdrv_check)(BlockDriverState * bs,BdrvCheckResult *result,BdrvCheckMode fix); +int (*bdrv_amend_options)(BlockDriverState *bs, +QEMUOptionParameter *options); +void (*bdrv_debug_event)(BlockDriverState *bs,BlkDebugEvent event);/* TODO Better pass a option string/QDict/QemuOpts to add any rule? */
qemu-img-cmds.hx +6 -0
@@ -61,5 +61,11 @@ DEF("resize", img_resize, "resize [-q] filename [+ | -]size") STEXI @item resize [-q] @var{filename} [+ | -]@var{size} +ETEXI + +DEF("amend", img_amend, + "amend [-q] [-f fmt] -o options filename") +STEXI +@item amend [-q] [-f @var{fmt}] -o @var{options} @var{filename} @end table ETEXI
qemu-img.c +84 -0
90 lines not on this page · raw message
qemu-img.texi +5 -0
@@ -282,6 +282,11 @@ sizes accordingly. Failure to do so will result in data loss! After using this command to grow a disk image, you must use file system and partitioning tools inside the VM to actually begin using the new space on the device. + +@item amend [-f @var{fmt}] -o @var{options} @var{filename} + +Amends the image format specific @var{options} for the image file +@var{filename}. Not all file formats support this operation. @end table @c man end
Signature · 1 line
1.8.3.1
PATCH v5 2/6 qcow2-cache: Empty cache
In reply to Max ReitzAdd a function for emptying a cache, i.e., flushing it and marking all elements invalid.
--- block/qcow2-cache.c | 18 ++++++++++++++++++ block/qcow2.h | 2 ++ 2 files changed, 20 insertions(+)
block/qcow2-cache.c +18 -0
@@ -202,6 +202,24 @@ void qcow2_cache_depends_on_flush(Qcow2Cache *c) c->depends_on_flush = true; } +int qcow2_cache_empty (BlockDriverState *bs,Qcow2Cache *c) +{ +int ret, i; + + ret =qcow2_cache_flush (bs, c); +if (ret <0 ) { +return ret; + } + +for (i =0 ; i < c->size; i++) { +assert (c->entries[i].ref ==0 ); + c->entries[i].offset =0 ; + c->entries[i].cache_hits =0 ; + } + +return 0 ; +} +static int qcow2_cache_find_entry_to_replace (Qcow2Cache *c) {int i;
block/qcow2.h +2 -0
@@ -473,6 +473,8 @@ int qcow2_cache_set_dependency(BlockDriverState *bs, Qcow2Cache *c, Qcow2Cache *dependency);void qcow2_cache_depends_on_flush (Qcow2Cache *c); +int qcow2_cache_empty (BlockDriverState *bs,Qcow2Cache *c); +int qcow2_cache_get (BlockDriverState *bs,Qcow2Cache *c,uint64_t offset,void **table); int qcow2_cache_get_empty(BlockDriverState *bs, Qcow2Cache *c, uint64_t offset,
Signature · 1 line
1.8.3.1
PATCH v5 3/6 qcow2-cluster: Expand zero clusters
In reply to Max ReitzAdd functionality for expanding zero clusters. This is necessary for downgrading the image version to one without zero cluster support.
For non-backed images, this function may also just discard zero clusters instead of truly expanding them.
--- block/qcow2-cluster.c | 233 +++++++++++++++++++++++++++++++++++++++++++++++++ block/qcow2-refcount.c | 29 +++--- block/qcow2.h | 5 ++ 3 files changed, 253 insertions(+), 14 deletions(-)
block/qcow2-cluster.c +233 -0
@@ -1497,3 +1497,236 @@ fail:return ret; } + +/* +* Expands all zero clusters in a specific L1 table (or deallocates them, for +* non-backed non-pre-allocated zero clusters). +* +* expanded_clusters is a bitmap where every bit corresponds to one cluster in +* the image file; a bit gets set if the corresponding cluster has been used for +* zero expansion (i.e., has been filled with zeroes and is referenced from an +* L2 table). nb_clusters contains the total cluster count of the image file, +* i.e., the number of bits in expanded_clusters. +*/ +static int expand_zero_clusters_in_l1 (BlockDriverState *bs,uint64_t *l1_table, +int l1_size,uint8_t *expanded_clusters, +uint64_t nb_clusters) +{ +BDRVQcowState *s = bs->opaque; +bool is_active_l1 = (l1_table == s->l1_table); +uint64_t *l2_table =NULL ; +int ret; +int i, j; + +if (!is_active_l1) { +/* inactive L2 tables require a buffer to be stored in when loading +* them from disk */ + l2_table =qemu_blockalign (bs, s->cluster_size); + } + +for (i =0 ; i < l1_size; i++) { +uint64_t l2_offset = l1_table[i] &L1E_OFFSET_MASK ; +bool l2_dirty = false; + +if (!l2_offset) { +/* unallocated */ +continue ; + } + +if (is_active_l1) { +/* get active L2 tables from cache */ + ret =qcow2_cache_get (bs, s->l2_table_cache, l2_offset, + (void **)&l2_table); + }else { +/* load inactive L2 tables from disk */ + ret =bdrv_read (bs->file, l2_offset /BDRV_SECTOR_SIZE , + (void *)l2_table, s->cluster_sectors); + } +if (ret <0 ) { + goto fail; + } + +for (j =0 ; j < s->l2_size; j++) { +uint64_t l2_entry =be64_to_cpu (l2_table[j]); +int64_t offset = l2_entry &L2E_OFFSET_MASK , cluster_index; +int cluster_type =qcow2_get_cluster_type (l2_entry); + +if (cluster_type ==QCOW2_CLUSTER_NORMAL ) { + cluster_index = offset >> s->cluster_bits; +assert ((cluster_index >=0 ) && (cluster_index < nb_clusters)); +if (expanded_clusters[cluster_index /8 ] & + (1 << (cluster_index %8 ))) { +/* Probably a shared L2 table; this cluster was a zero +* cluster which has been expanded, its refcount +* therefore most likely requires an update. */ + ret =qcow2_update_cluster_refcount (bs, cluster_index,1 , +QCOW2_DISCARD_NEVER ); +if (ret <0 ) { + goto fail; + } +/* Since we just increased the refcount, the COPIED flag may +* no longer be set. */ + l2_table[j] =cpu_to_be64 (l2_entry & ~QCOW_OFLAG_COPIED ); + l2_dirty = true; + } +continue ; + } +else if (qcow2_get_cluster_type (l2_entry) !=QCOW2_CLUSTER_ZERO ) { +continue ; + } + +if (!offset) { +/* not preallocated */ +if (!bs->backing_hd) { +/* not backed; therefore we can simply deallocate the +* cluster */ + l2_table[j] =0 ; + l2_dirty = true; +continue ; + } + + offset =qcow2_alloc_clusters (bs, s->cluster_size); +if (offset <0 ) { + ret = offset; + goto fail; + } + } + + ret =qcow2_pre_write_overlap_check (bs,QCOW2_OL_DEFAULT , + offset, s->cluster_size); +if (ret <0 ) { +qcow2_free_clusters (bs, offset, s->cluster_size, +QCOW2_DISCARD_ALWAYS ); + goto fail; + } + + ret =bdrv_write_zeroes (bs->file, offset /BDRV_SECTOR_SIZE , + s->cluster_sectors); +if (ret <0 ) { +qcow2_free_clusters (bs, offset, s->cluster_size, +QCOW2_DISCARD_ALWAYS ); + goto fail; + } + + l2_table[j] =cpu_to_be64 (offset |QCOW_OFLAG_COPIED ); + l2_dirty = true; + + cluster_index = offset >> s->cluster_bits; +assert ((cluster_index >=0 ) && (cluster_index < nb_clusters)); + expanded_clusters[cluster_index /8 ] |=1 << (cluster_index %8 ); + } + +if (is_active_l1) { +if (l2_dirty) { +qcow2_cache_entry_mark_dirty (s->l2_table_cache, l2_table); +qcow2_cache_depends_on_flush (s->l2_table_cache); + } + ret =qcow2_cache_put (bs, s->l2_table_cache, (void **)&l2_table); +if (ret <0 ) { + l2_table =NULL ; + goto fail; + } + }else { +if (l2_dirty) { + ret =qcow2_pre_write_overlap_check (bs,QCOW2_OL_DEFAULT & + ~(QCOW2_OL_INACTIVE_L2 |QCOW2_OL_ACTIVE_L2 ), l2_offset, + s->cluster_size); +if (ret <0 ) { + goto fail; + } + + ret =bdrv_write (bs->file, l2_offset /BDRV_SECTOR_SIZE , + (void *)l2_table, s->cluster_sectors); +if (ret <0 ) { + goto fail; + } + } + } + } + + ret =0 ; + +fail: +if (l2_table) { +if (!is_active_l1) { +qemu_vfree (l2_table); + }else { +if (ret <0 ) { +qcow2_cache_put (bs, s->l2_table_cache, (void **)&l2_table); + }else { + ret =qcow2_cache_put (bs, s->l2_table_cache, + (void **)&l2_table); + } + } + } +return ret; +} + +/* +* For backed images, expands all zero clusters on the image. For non-backed +* images, deallocates all non-pre-allocated zero clusters (and claims the +* allocation for pre-allocated ones). This is important for downgrading to a +* qcow2 version which doesn't yet support metadata zero clusters. +*/ +int qcow2_expand_zero_clusters (BlockDriverState *bs) +{ +BDRVQcowState *s = bs->opaque; +uint64_t *l1_table =NULL ; +int cluster_to_sector_bits = s->cluster_bits -BDRV_SECTOR_BITS ; +uint64_t nb_clusters; +uint8_t *expanded_clusters; +int ret; +int i, j; + + nb_clusters = (bs->total_sectors + (1 << cluster_to_sector_bits) -1 ) + >> cluster_to_sector_bits; + expanded_clusters =g_malloc0 ((nb_clusters +7 ) /8 ); + + ret =expand_zero_clusters_in_l1 (bs, s->l1_table, s->l1_size, + expanded_clusters, nb_clusters); +if (ret <0 ) { + goto fail; + } + +/* Inactive L1 tables may point to active L2 tables - therefore it is +* necessary to flush the L2 table cache before trying to access the L2 +* tables pointed to by inactive L1 entries (else we might try to expand +* zero clusters that have already been expanded); furthermore, it is also +* necessary to empty the L2 table cache, since it may contain tables which +* are now going to be modified directly on disk, bypassing the cache. +* qcow2_cache_empty() does both for us. */ + ret =qcow2_cache_empty (bs, s->l2_table_cache); +if (ret <0 ) { + goto fail; + } + +for (i =0 ; i < s->nb_snapshots; i++) { +int l1_sectors = (s->snapshots[i].l1_size *sizeof (uint64_t ) + +BDRV_SECTOR_SIZE -1 ) /BDRV_SECTOR_SIZE ; + + l1_table =g_realloc (l1_table, l1_sectors *BDRV_SECTOR_SIZE ); + + ret =bdrv_read (bs->file, s->snapshots[i].l1_table_offset / +BDRV_SECTOR_SIZE , (void *)l1_table, l1_sectors); +if (ret <0 ) { + goto fail; + } + +for (j =0 ; j < s->snapshots[i].l1_size; j++) { +be64_to_cpus (&l1_table[j]); + } + + ret =expand_zero_clusters_in_l1 (bs, l1_table, s->snapshots[i].l1_size, + expanded_clusters, nb_clusters); +if (ret <0 ) { + goto fail; + } + } + + ret =0 ; + +fail: +g_free (expanded_clusters); +g_free (l1_table); +return ret; +}
block/qcow2-refcount.c +15 -14
@@ -601,10 +601,10 @@ fail:* If the return value is non-negative, it is the new refcount of the cluster. * If it is negative, it is -errno and indicates an error. */ -static int update_cluster_refcount (BlockDriverState *bs, -int64_t cluster_index, -int addend, -enum qcow2_discard_type type) +int qcow2_update_cluster_refcount (BlockDriverState *bs, +int64_t cluster_index, +int addend, +enum qcow2_discard_type type) {BDRVQcowState *s = bs->opaque;int ret;
@@ -733,8 +733,8 @@ int64_t qcow2_alloc_bytes(BlockDriverState *bs, int size)if (free_in_cluster ==0 ) s->free_byte_offset =0 ;if ((offset & (s->cluster_size -1 )) !=0 ) -update_cluster_refcount (bs, offset >> s->cluster_bits,1 , -QCOW2_DISCARD_NEVER ); +qcow2_update_cluster_refcount (bs, offset >> s->cluster_bits,1 , +QCOW2_DISCARD_NEVER ); }else { offset =qcow2_alloc_clusters (bs, s->cluster_size);if (offset <0 ) {
@@ -744,8 +744,8 @@ int64_t qcow2_alloc_bytes(BlockDriverState *bs, int size)if ((cluster_offset + s->cluster_size) == offset) {/* we are lucky: contiguous data */ offset = s->free_byte_offset; -update_cluster_refcount (bs, offset >> s->cluster_bits,1 , -QCOW2_DISCARD_NEVER ); +qcow2_update_cluster_refcount (bs, offset >> s->cluster_bits,1 , +QCOW2_DISCARD_NEVER ); s->free_byte_offset += size; }else { s->free_byte_offset = offset;
@@ -754,8 +754,8 @@ int64_t qcow2_alloc_bytes(BlockDriverState *bs, int size) }/* The cluster refcount was incremented, either by qcow2_alloc_clusters() -* or explicitly by update_cluster_refcount(). Refcount blocks must be -* flushed before the caller's L2 table updates. +* or explicitly by qcow2_update_cluster_refcount(). Refcount blocks must +* be flushed before the caller's L2 table updates. */ qcow2_cache_set_dependency (bs, s->l2_table_cache, s->refcount_block_cache);return offset;
@@ -896,8 +896,9 @@ int qcow2_update_snapshot_refcount(BlockDriverState *bs,break ; }if (addend !=0 ) { - refcount =update_cluster_refcount (bs, cluster_index, addend, -QCOW2_DISCARD_SNAPSHOT ); + refcount =qcow2_update_cluster_refcount (bs, + cluster_index, addend, +QCOW2_DISCARD_SNAPSHOT ); }else { refcount =get_refcount (bs, cluster_index); }
@@ -936,8 +937,8 @@ int qcow2_update_snapshot_refcount(BlockDriverState *bs,if (addend !=0 ) { - refcount =update_cluster_refcount (bs, l2_offset >> s->cluster_bits, addend, -QCOW2_DISCARD_SNAPSHOT ); + refcount =qcow2_update_cluster_refcount (bs, l2_offset >> + s->cluster_bits, addend,QCOW2_DISCARD_SNAPSHOT ); }else { refcount =get_refcount (bs, l2_offset >> s->cluster_bits); }
block/qcow2.h +5 -0
@@ -406,6 +406,9 @@ int qcow2_update_header(BlockDriverState *bs);int qcow2_refcount_init (BlockDriverState *bs);void qcow2_refcount_close (BlockDriverState *bs); +int qcow2_update_cluster_refcount (BlockDriverState *bs,int64_t cluster_index, +int addend,enum qcow2_discard_type type); +int64_t qcow2_alloc_clusters (BlockDriverState *bs,int64_t size);int qcow2_alloc_clusters_at (BlockDriverState *bs,uint64_t offset,int nb_clusters);
@@ -453,6 +456,8 @@ int qcow2_discard_clusters(BlockDriverState *bs, uint64_t offset, int nb_sectors);int qcow2_zero_clusters (BlockDriverState *bs,uint64_t offset,int nb_sectors); +int qcow2_expand_zero_clusters (BlockDriverState *bs); +/* qcow2-snapshot.c functions */ int qcow2_snapshot_create (BlockDriverState *bs,QEMUSnapshotInfo *sn_info);int qcow2_snapshot_goto (BlockDriverState *bs,const char *snapshot_id);
Signature · 1 line
1.8.3.1
PATCH v5 4/6 qcow2: Save refcount order in BDRVQcowState
In reply to Max ReitzSave the image refcount order in BDRVQcowState. This will be relevant for future code supporting different refcount orders than four and also for code that needs to verify a certain refcount order for an opened image.
--- block/qcow2.c | 3 ++- block/qcow2.h | 1 + 2 files changed, 3 insertions(+), 1 deletion(-)
block/qcow2.c +2 -1
@@ -455,6 +455,7 @@ static int qcow2_open(BlockDriverState *bs, QDict *options, int flags) ret = -ENOTSUP ; goto fail; } + s->refcount_order = header.refcount_order;if (header.cluster_bits <MIN_CLUSTER_BITS || header.cluster_bits >MAX_CLUSTER_BITS ) {
@@ -1133,7 +1134,7 @@ int qcow2_update_header(BlockDriverState *bs) .incompatible_features = cpu_to_be64(s->incompatible_features), .compatible_features = cpu_to_be64(s->compatible_features), .autoclear_features = cpu_to_be64(s->autoclear_features), - .refcount_order = cpu_to_be32(3 + REFCOUNT_SHIFT), + .refcount_order = cpu_to_be32(s->refcount_order), .header_length = cpu_to_be32(header_length), };
block/qcow2.h +1 -0
@@ -199,6 +199,7 @@ typedef struct BDRVQcowState {int flags;int qcow_version;bool use_lazy_refcounts; +int refcount_order;bool discard_passthrough[QCOW2_DISCARD_MAX ];
Signature · 1 line
1.8.3.1
PATCH v5 5/6 qcow2: Implement bdrv_amend_options
In reply to Max ReitzImplement bdrv_amend_options for compat, size, backing_file, backing_fmt and lazy_refcounts.
Downgrading images from compat=1.1 to compat=0.10 is achieved through handling all incompatible flags accordingly, clearing all compatible and autoclear flags and expanding all zero clusters.
--- block/qcow2.c | 194 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 194 insertions(+)
block/qcow2.c +194 -0
@@ -1813,6 +1813,199 @@ static int qcow2_load_vmstate(BlockDriverState *bs, uint8_t *buf,return ret; } +/* +* Downgrades an image's version. To achieve this, any incompatible features +* have to be removed. +*/ +static int qcow2_downgrade (BlockDriverState *bs,int target_version) +{ +BDRVQcowState *s = bs->opaque; +int current_version = s->qcow_version; +int ret; + +if (target_version == current_version) { +return 0 ; + }else if (target_version > current_version) { +return -EINVAL ; + }else if (target_version !=2 ) { +return -EINVAL ; + } + +if (s->refcount_order !=4 ) { +/* we would have to convert the image to a refcount_order == 4 image +* here; however, since qemu (at the time of writing this) does not +* support anything different than 4 anyway, there is no point in doing +* so right now; however, we should error out (if qemu supports this in +* the future and this code has not been adapted) */ +error_report ("qcow2_downgrade: Image refcount orders other than 4 are" +"currently not supported." ); +return -ENOTSUP ; + } + +/* clear incompatible features */ +if (s->incompatible_features &QCOW2_INCOMPAT_DIRTY ) { + ret =qcow2_mark_clean (bs); +if (ret <0 ) { +return ret; + } + } + +/* with QCOW2_INCOMPAT_CORRUPT, it is pretty much impossible to get here in +* the first place; if that happens nonetheless, returning -ENOTSUP is the +* best thing to do anyway */ + +if (s->incompatible_features) { +return -ENOTSUP ; + } + +/* since we can ignore compatible features, we can set them to 0 as well */ + s->compatible_features =0 ; +/* if lazy refcounts have been used, they have already been fixed through +* clearing the dirty flag */ + +/* clearing autoclear features is trivial */ + s->autoclear_features =0 ; + + ret =qcow2_expand_zero_clusters (bs); +if (ret <0 ) { +return ret; + } + + s->qcow_version = target_version; + ret =qcow2_update_header (bs); +if (ret <0 ) { + s->qcow_version = current_version; +return ret; + } +return 0 ; +} + +static int qcow2_amend_options (BlockDriverState *bs, +QEMUOptionParameter *options) +{ +BDRVQcowState *s = bs->opaque; +int old_version = s->qcow_version, new_version = old_version; +uint64_t new_size =0 ; +const char *backing_file =NULL , *backing_format =NULL ; +bool lazy_refcounts = s->use_lazy_refcounts; +int ret; +int i; + +for (i =0 ; options[i].name; i++) + { +if (!options[i].assigned) { +/* only change explicitly defined options */ +continue ; + } + +if (!strcmp (options[i].name,"compat" )) { +if (!options[i].value.s) { +/* preserve default */ + }else if (!strcmp (options[i].value.s,"0.10" )) { + new_version =2 ; + }else if (!strcmp (options[i].value.s,"1.1" )) { + new_version =3 ; + }else { +fprintf (stderr,"Unknown compatibility level %s.\n" , + options[i].value.s); +return -EINVAL ; + } + }else if (!strcmp (options[i].name,"preallocation" )) { +fprintf (stderr,"Cannot change preallocation mode.\n" ); +return -ENOTSUP ; + }else if (!strcmp (options[i].name,"size" )) { + new_size = options[i].value.n; + }else if (!strcmp (options[i].name,"backing_file" )) { + backing_file = options[i].value.s; + }else if (!strcmp (options[i].name,"backing_fmt" )) { + backing_format = options[i].value.s; + }else if (!strcmp (options[i].name,"encryption" )) { +if ((options[i].value.n != !!s->crypt_method)) { +fprintf (stderr,"Changing the encryption flag is not " +"supported.\n" ); +return -ENOTSUP ; + } + }else if (!strcmp (options[i].name,"cluster_size" )) { +if (options[i].value.n != s->cluster_size) { +fprintf (stderr,"Changing the cluster size is not " +"supported.\n" ); +return -ENOTSUP ; + } + }else if (!strcmp (options[i].name,"lazy_refcounts" )) { + lazy_refcounts = options[i].value.n; + }else { +/* if this assertion fails, this probably means a new option was +* added without having it covered here */ +assert (false); + } + } + +if (new_version != old_version) { +if (new_version > old_version) { +/* Upgrade */ + s->qcow_version = new_version; + ret =qcow2_update_header (bs); +if (ret <0 ) { + s->qcow_version = old_version; +return ret; + } + }else { + ret =qcow2_downgrade (bs, new_version); +if (ret <0 ) { +return ret; + } + } + } + +if (backing_file || backing_format) { + ret =qcow2_change_backing_file (bs, backing_file ?: bs->backing_file, + backing_format ?: bs->backing_format); +if (ret <0 ) { +return ret; + } + } + +if (s->use_lazy_refcounts != lazy_refcounts) { +if (lazy_refcounts) { +if (s->qcow_version <3 ) { +fprintf (stderr,"Lazy refcounts only supported with compatibility " +"level 1.1 and above (use compat=1.1 or greater)\n" ); +return -EINVAL ; + } + s->compatible_features |=QCOW2_COMPAT_LAZY_REFCOUNTS ; + ret =qcow2_update_header (bs); +if (ret <0 ) { + s->compatible_features &= ~QCOW2_COMPAT_LAZY_REFCOUNTS ; +return ret; + } + s->use_lazy_refcounts = true; + }else { +/* make image clean first */ + ret =qcow2_mark_clean (bs); +if (ret <0 ) { +return ret; + } +/* now disallow lazy refcounts */ + s->compatible_features &= ~QCOW2_COMPAT_LAZY_REFCOUNTS ; + ret =qcow2_update_header (bs); +if (ret <0 ) { + s->compatible_features |=QCOW2_COMPAT_LAZY_REFCOUNTS ; +return ret; + } + s->use_lazy_refcounts = false; + } + } + +if (new_size) { + ret =qcow2_truncate (bs, new_size); +if (ret <0 ) { +return ret; + } + } + +return 0 ; +} +static QEMUOptionParameter qcow2_create_options[] = { { .name =BLOCK_OPT_SIZE ,
@@ -1896,6 +2089,7 @@ static BlockDriver bdrv_qcow2 = { .create_options = qcow2_create_options, .bdrv_check = qcow2_check, + .bdrv_amend_options = qcow2_amend_options, };static void bdrv_qcow2_init (void )
Signature · 1 line
1.8.3.1
PATCH v5 6/6 qemu-iotest: qcow2 image option amendment
In reply to Max ReitzAdd tests for qemu-img amend on qcow2 image files.
--- tests/qemu-iotests/061 | 178 +++++++++++++++++++++++ tests/qemu-iotests/061.out | 349 +++++++++++++++++++++++++++++++++++++++++++++ tests/qemu-iotests/group | 1 + 3 files changed, 528 insertions(+) create mode 100755 tests/qemu-iotests/061 create mode 100644 tests/qemu-iotests/061.out
tests/qemu-iotests/061 new file +178 -0
@@ -0,0 +1,178 @@ +#!/bin/bash +# +# Test case for image option amendment in qcow2. +# +# Copyright (C) 2013 Red Hat, Inc. +# +# 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` +tmp=/tmp/$$ +status=1 # failure is the default! + +_cleanup() +{ + _cleanup_test_img +} +trap "_cleanup; exit \$status" 0 1 2 3 15 + +# get standard environment, filters and checks +. ./common.rc +. ./common.filter + +# This tests qocw2-specific low-level functionality +_supported_fmt qcow2 +_supported_proto generic +_supported_os Linux + +echo +echo "=== Testing version downgrade with zero expansion ===" +echo +IMGOPTS="compat=1.1,lazy_refcounts=on" _make_test_img 64M +$QEMU_IO -c "write -z 0 128k" "$TEST_IMG" | _filter_qemu_io +./qcow2.py "$TEST_IMG" dump-header +$QEMU_IMG amend -o "compat=0.10" "$TEST_IMG" +./qcow2.py "$TEST_IMG" dump-header +$QEMU_IO -c "read -P 0 0 128k" "$TEST_IMG" | _filter_qemu_io +_check_test_img + +echo +echo "=== Testing dirty version downgrade ===" +echo +IMGOPTS="compat=1.1,lazy_refcounts=on" _make_test_img 64M +$QEMU_IO -c "write -P 0x2a 0 128k" -c flush -c abort "$TEST_IMG" | _filter_qemu_io +./qcow2.py "$TEST_IMG" dump-header +$QEMU_IMG amend -o "compat=0.10" "$TEST_IMG" +./qcow2.py "$TEST_IMG" dump-header +$QEMU_IO -c "read -P 0x2a 0 128k" "$TEST_IMG" | _filter_qemu_io +_check_test_img + +echo +echo "=== Testing version downgrade with unknown compat/autoclear flags ===" +echo +IMGOPTS="compat=1.1" _make_test_img 64M +./qcow2.py "$TEST_IMG" set-feature-bit compatible 42 +./qcow2.py "$TEST_IMG" set-feature-bit autoclear 42 +./qcow2.py "$TEST_IMG" dump-header +$QEMU_IMG amend -o "compat=0.10" "$TEST_IMG" +./qcow2.py "$TEST_IMG" dump-header +_check_test_img + +echo +echo "=== Testing version upgrade and resize ===" +echo +IMGOPTS="compat=0.10" _make_test_img 64M +$QEMU_IO -c "write -P 0x2a 42M 64k" "$TEST_IMG" | _filter_qemu_io +./qcow2.py "$TEST_IMG" dump-header +$QEMU_IMG amend -o "compat=1.1,lazy_refcounts=on,size=128M" "$TEST_IMG" +./qcow2.py "$TEST_IMG" dump-header +$QEMU_IO -c "read -P 0x2a 42M 64k" "$TEST_IMG" | _filter_qemu_io +_check_test_img + +echo +echo "=== Testing dirty lazy_refcounts=off ===" +echo +IMGOPTS="compat=1.1,lazy_refcounts=on" _make_test_img 64M +$QEMU_IO -c "write -P 0x2a 0 128k" -c flush -c abort "$TEST_IMG" | _filter_qemu_io +./qcow2.py "$TEST_IMG" dump-header +$QEMU_IMG amend -o "lazy_refcounts=off" "$TEST_IMG" +./qcow2.py "$TEST_IMG" dump-header +$QEMU_IO -c "read -P 0x2a 0 128k" "$TEST_IMG" | _filter_qemu_io +_check_test_img + +echo +echo "=== Testing backing file ===" +echo +IMGOPTS="compat=1.1" _make_test_img 64M +IMGOPTS="compat=1.1" TEST_IMG="$TEST_IMG.base" _make_test_img 64M +$QEMU_IO -c "write -P 0x2a 0 128k" "$TEST_IMG.base" | _filter_qemu_io +$QEMU_IO -c "read -P 0 0 128k" "$TEST_IMG" | _filter_qemu_io +$QEMU_IMG amend -o "backing_file=$TEST_IMG.base,backing_fmt=qcow2" "$TEST_IMG" +$QEMU_IO -c "read -P 0x2a 0 128k" "$TEST_IMG" | _filter_qemu_io +_check_test_img + +echo +echo "=== Testing invalid configurations ===" +echo +IMGOPTS="compat=0.10" _make_test_img 64M +$QEMU_IMG amend -o "lazy_refcounts=on" "$TEST_IMG" +$QEMU_IMG amend -o "compat=1.1" "$TEST_IMG" # actually valid +$QEMU_IMG amend -o "compat=0.10,lazy_refcounts=on" "$TEST_IMG" +$QEMU_IMG amend -o "compat=0.42" "$TEST_IMG" +$QEMU_IMG amend -o "foo=bar" "$TEST_IMG" +$QEMU_IMG amend -o "cluster_size=1k" "$TEST_IMG" +$QEMU_IMG amend -o "encryption=on" "$TEST_IMG" +$QEMU_IMG amend -o "preallocation=on" "$TEST_IMG" + +echo +echo "=== Testing correct handling of unset value ===" +echo +IMGOPTS="compat=1.1,cluster_size=1k" _make_test_img 64M +echo "Should work:" +$QEMU_IMG amend -o "lazy_refcounts=on" "$TEST_IMG" +echo "Should not work:" # Just to know which of these tests actually fails +$QEMU_IMG amend -o "cluster_size=64k" "$TEST_IMG" + +echo +echo "=== Testing zero expansion on inactive clusters ===" +echo +IMGOPTS="compat=1.1" _make_test_img 64M +$QEMU_IO -c "write -z 0 128k" "$TEST_IMG" | _filter_qemu_io +$QEMU_IMG snapshot -c foo "$TEST_IMG" +$QEMU_IO -c "write -P 0x2a 0 128k" "$TEST_IMG" | _filter_qemu_io +$QEMU_IMG amend -o "compat=0.10" "$TEST_IMG" +_check_test_img +$QEMU_IO -c "read -P 0x2a 0 128k" "$TEST_IMG" | _filter_qemu_io +$QEMU_IMG snapshot -a foo "$TEST_IMG" +_check_test_img +$QEMU_IO -c "read -P 0 0 128k" "$TEST_IMG" | _filter_qemu_io + +echo +echo "=== Testing zero expansion on backed image ===" +echo +IMGOPTS="compat=1.1" TEST_IMG="$TEST_IMG.base" _make_test_img 64M +$QEMU_IO -c "write -P 0x2a 0 128k" "$TEST_IMG.base" | _filter_qemu_io +IMGOPTS="compat=1.1,backing_file=$TEST_IMG.base" _make_test_img 64M +$QEMU_IO -c "read -P 0x2a 0 128k" -c "write -z 0 64k" "$TEST_IMG" | _filter_qemu_io +$QEMU_IMG amend -o "compat=0.10" "$TEST_IMG" +_check_test_img +$QEMU_IO -c "read -P 0 0 64k" -c "read -P 0x2a 64k 64k" "$TEST_IMG" | _filter_qemu_io + +echo +echo "=== Testing zero expansion on backed inactive clusters ===" +echo +IMGOPTS="compat=1.1" TEST_IMG="$TEST_IMG.base" _make_test_img 64M +$QEMU_IO -c "write -P 0x2a 0 128k" "$TEST_IMG.base" | _filter_qemu_io +IMGOPTS="compat=1.1,backing_file=$TEST_IMG.base" _make_test_img 64M +$QEMU_IO -c "write -z 0 64k" "$TEST_IMG" | _filter_qemu_io +$QEMU_IMG snapshot -c foo "$TEST_IMG" +$QEMU_IO -c "write -P 0x42 0 128k" "$TEST_IMG" | _filter_qemu_io +$QEMU_IMG amend -o "compat=0.10" "$TEST_IMG" +_check_test_img +$QEMU_IO -c "read -P 0x42 0 128k" "$TEST_IMG" | _filter_qemu_io +$QEMU_IMG snapshot -a foo "$TEST_IMG" +_check_test_img +$QEMU_IO -c "read -P 0 0 64k" -c "read -P 0x2a 64k 64k" "$TEST_IMG" | _filter_qemu_io + +# success, all done +echo "*** done" +rm -f $seq.full +status=0
tests/qemu-iotests/061.out new file +349 -0
349 lines not on this page · raw message
tests/qemu-iotests/group +1 -0
@@ -65,4 +65,5 @@ 056 rw auto backing 059 rw auto 060 rw auto +061 rw auto 062 rw auto
Signature · 1 line
1.8.3.1
Am 03.09.2013 um 10:09 hat Max Reitz geschrieben:
Quoted 9 lines
This series adds support to qemu-img, block and qcow2 for amending image options on existing image files.
Depends on:
- option: Add assigned flag to QEMUOptionParameter
- qcow2-refcount: Snapshot update for zero clusters (series, v3)
- Add metadata overlap checks (series, v5)
Quoted 9 lines
v5:
- added a new function for emptying a cache (patch 2)
- fixed rounding for the bitmap size inqcow2_expand_zero_clusters
- now empties the cache inqcow2_expand_zero_clustersinstead of simply flushing it
- factored out assignment check inqcow2_amend_options
- fixed resizing by moving it to the end ofqcow2_amend_options
- fixed expected test result for resizing in addition to a version upgrade
There's still room for improvements on top, in particular the additional test cases I suggested in the v4 thread and the real qcow2_truncate() fix that is just worked around here by moving its call (it needs to update bs->total_sectors), but this looks good enough to be merged now.
Kevin Wolf
AppliedAm 03.09.2013 um 10:09 hat Max Reitz geschrieben:
Quoted 8 lines
This series adds support to qemu-img, block and qcow2 for amending image options on existing image files.
Depends on:
- option: Add assigned flag to QEMUOptionParameter
- qcow2-refcount: Snapshot update for zero clusters (series, v3)
- Add metadata overlap checks (series, v5)
Thanks, applied to the block branch with the following changes:
- Updated patch 5 with
[PATCH] block/qcow2: Use bdrv_truncate for size amend
- Resolved merge conflict in patch 1 (bdrv_delete -> bdrv_unref)
Kevin