mirrors/qemu
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

qcow2: Prepare expand_zero_clusters_in_l1() for adding L2 slice support

Browse Source 
Adding support for L2 slices to expand_zero_clusters_in_l1() needs
(among other things) an extra loop that iterates over all slices of
each L2 table.

Putting all changes in one patch would make it hard to read because
all semantic changes would be mixed with pure indentation changes.

To make things easier this patch simply creates a new block and
changes the indentation of all lines of code inside it. Thus, all
modifications in this patch are cosmetic. There are no semantic
changes and no variables are renamed yet. The next patch will take
care of that.

Signed-off-by: Alberto Garcia <berto@igalia.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Message-id: c2ae9f31ed5b6e591477ad4654448badd1c89d73.1517840877.git.berto@igalia.com
Signed-off-by: Max Reitz <mreitz@redhat.com>
This commit is contained in:
Alberto Garcia 2018-02-05 16:33:29 +02:00 committed by Max Reitz
parent 9b765486b7
commit 226494ff69
1 changed files with 103 additions and 98 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

201
block/qcow2-cluster.c
View File

@ -1904,118 +1904,123 @@ static int expand_zero_clusters_in_l1(BlockDriverState *bs, uint64_t *l1_table,
goto fail; goto fail;
} }
if (is_active_l1) { {
/* get active L2 tables from cache */ if (is_active_l1) {
ret = qcow2_cache_get(bs, s->l2_table_cache, l2_offset, /* get active L2 tables from cache */
(void **)&l2_table); ret = qcow2_cache_get(bs, s->l2_table_cache, l2_offset,
} else { (void **)&l2_table);
/* load inactive L2 tables from disk */ } else {
ret = bdrv_read(bs->file, l2_offset / BDRV_SECTOR_SIZE, /* load inactive L2 tables from disk */
(void *)l2_table, s->cluster_sectors); ret = bdrv_read(bs->file, l2_offset / BDRV_SECTOR_SIZE,
} (void *)l2_table, s->cluster_sectors);
if (ret < 0) { }
goto fail; 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;
QCow2ClusterType cluster_type = qcow2_get_cluster_type(l2_entry);
if (cluster_type != QCOW2_CLUSTER_ZERO_PLAIN &&
cluster_type != QCOW2_CLUSTER_ZERO_ALLOC) {
continue;
} }
if (cluster_type == QCOW2_CLUSTER_ZERO_PLAIN) { for (j = 0; j < s->l2_size; j++) {
if (!bs->backing) { uint64_t l2_entry = be64_to_cpu(l2_table[j]);
/* not backed; therefore we can simply deallocate the int64_t offset = l2_entry & L2E_OFFSET_MASK;
* cluster */ QCow2ClusterType cluster_type =
l2_table[j] = 0; qcow2_get_cluster_type(l2_entry);
l2_dirty = true;
if (cluster_type != QCOW2_CLUSTER_ZERO_PLAIN &&
cluster_type != QCOW2_CLUSTER_ZERO_ALLOC) {
continue; continue;
} }
offset = qcow2_alloc_clusters(bs, s->cluster_size); if (cluster_type == QCOW2_CLUSTER_ZERO_PLAIN) {
if (offset < 0) { if (!bs->backing) {
ret = offset; /* not backed; therefore we can simply deallocate the
goto fail; * cluster */
} l2_table[j] = 0;
l2_dirty = true;
continue;
}
if (l2_refcount > 1) { offset = qcow2_alloc_clusters(bs, s->cluster_size);
/* For shared L2 tables, set the refcount accordingly (it is if (offset < 0) {
* already 1 and needs to be l2_refcount) */ ret = offset;
ret = qcow2_update_cluster_refcount(bs,
offset >> s->cluster_bits,
refcount_diff(1, l2_refcount), false,
QCOW2_DISCARD_OTHER);
if (ret < 0) {
qcow2_free_clusters(bs, offset, s->cluster_size,
QCOW2_DISCARD_OTHER);
goto fail; goto fail;
} }
if (l2_refcount > 1) {
/* For shared L2 tables, set the refcount accordingly
* (it is already 1 and needs to be l2_refcount) */
ret = qcow2_update_cluster_refcount(
bs, offset >> s->cluster_bits,
refcount_diff(1, l2_refcount), false,
QCOW2_DISCARD_OTHER);
if (ret < 0) {
qcow2_free_clusters(bs, offset, s->cluster_size,
QCOW2_DISCARD_OTHER);
goto fail;
}
}
} }
if (offset_into_cluster(s, offset)) {
qcow2_signal_corruption(
bs, true, -1, -1,
"Cluster allocation offset "
"%#" PRIx64 " unaligned (L2 offset: %#"
PRIx64 ", L2 index: %#x)", offset,
l2_offset, j);
if (cluster_type == QCOW2_CLUSTER_ZERO_PLAIN) {
qcow2_free_clusters(bs, offset, s->cluster_size,
QCOW2_DISCARD_ALWAYS);
}
ret = -EIO;
goto fail;
}
ret = qcow2_pre_write_overlap_check(bs, 0, offset,
s->cluster_size);
if (ret < 0) {
if (cluster_type == QCOW2_CLUSTER_ZERO_PLAIN) {
qcow2_free_clusters(bs, offset, s->cluster_size,
QCOW2_DISCARD_ALWAYS);
}
goto fail;
}
ret = bdrv_pwrite_zeroes(bs->file, offset, s->cluster_size, 0);
if (ret < 0) {
if (cluster_type == QCOW2_CLUSTER_ZERO_PLAIN) {
qcow2_free_clusters(bs, offset, s->cluster_size,
QCOW2_DISCARD_ALWAYS);
}
goto fail;
}
if (l2_refcount == 1) {
l2_table[j] = cpu_to_be64(offset | QCOW_OFLAG_COPIED);
} else {
l2_table[j] = cpu_to_be64(offset);
}
l2_dirty = true;
} }
if (offset_into_cluster(s, offset)) { if (is_active_l1) {
qcow2_signal_corruption(bs, true, -1, -1, if (l2_dirty) {
"Cluster allocation offset " qcow2_cache_entry_mark_dirty(s->l2_table_cache, l2_table);
"%#" PRIx64 " unaligned (L2 offset: %#" qcow2_cache_depends_on_flush(s->l2_table_cache);
PRIx64 ", L2 index: %#x)", offset,
l2_offset, j);
if (cluster_type == QCOW2_CLUSTER_ZERO_PLAIN) {
qcow2_free_clusters(bs, offset, s->cluster_size,
QCOW2_DISCARD_ALWAYS);
} }
ret = -EIO; qcow2_cache_put(s->l2_table_cache, (void **) &l2_table);
goto fail;
}
ret = qcow2_pre_write_overlap_check(bs, 0, offset, s->cluster_size);
if (ret < 0) {
if (cluster_type == QCOW2_CLUSTER_ZERO_PLAIN) {
qcow2_free_clusters(bs, offset, s->cluster_size,
QCOW2_DISCARD_ALWAYS);
}
goto fail;
}
ret = bdrv_pwrite_zeroes(bs->file, offset, s->cluster_size, 0);
if (ret < 0) {
if (cluster_type == QCOW2_CLUSTER_ZERO_PLAIN) {
qcow2_free_clusters(bs, offset, s->cluster_size,
QCOW2_DISCARD_ALWAYS);
}
goto fail;
}
if (l2_refcount == 1) {
l2_table[j] = cpu_to_be64(offset | QCOW_OFLAG_COPIED);
} else { } else {
l2_table[j] = cpu_to_be64(offset); if (l2_dirty) {
} ret = qcow2_pre_write_overlap_check(
l2_dirty = true; bs, QCOW2_OL_INACTIVE_L2 | QCOW2_OL_ACTIVE_L2,
} l2_offset, s->cluster_size);
if (ret < 0) {
goto fail;
}
if (is_active_l1) { ret = bdrv_write(bs->file, l2_offset / BDRV_SECTOR_SIZE,
if (l2_dirty) { (void *)l2_table, s->cluster_sectors);
qcow2_cache_entry_mark_dirty(s->l2_table_cache, l2_table); if (ret < 0) {
qcow2_cache_depends_on_flush(s->l2_table_cache); goto fail;
} }
qcow2_cache_put(s->l2_table_cache, (void **) &l2_table);
} else {
if (l2_dirty) {
ret = qcow2_pre_write_overlap_check(bs,
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;
} }
} }
} }