ShuriZma
/
xemu
mirror of https://github.com/xemu-project/xemu.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

qcow2: Pass bs to qcow2_get_cluster_type() 

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
This commit is contained in:
Kevin Wolf 2019-01-17 18:42:40 +01:00
parent 93c2493646
commit 808c2bb4c4
3 changed files with 26 additions and 24 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
block/qcow2-cluster.c
View File

@ -380,8 +380,8 @@ fail:
* as contiguous. (This allows it, for example, to stop at the first compressed * as contiguous. (This allows it, for example, to stop at the first compressed
* cluster which may require a different handling) * cluster which may require a different handling)
*/ */
static int count_contiguous_clusters(int nb_clusters, int cluster_size, static int count_contiguous_clusters(BlockDriverState *bs, int nb_clusters,
uint64_t *l2_slice, uint64_t stop_flags) int cluster_size, uint64_t *l2_slice, uint64_t stop_flags)
{ {
int i; int i;
QCow2ClusterType first_cluster_type; QCow2ClusterType first_cluster_type;
@ -394,7 +394,7 @@ static int count_contiguous_clusters(int nb_clusters, int cluster_size,
} }
/* must be allocated */ /* must be allocated */
first_cluster_type = qcow2_get_cluster_type(first_entry); first_cluster_type = qcow2_get_cluster_type(bs, first_entry);
assert(first_cluster_type == QCOW2_CLUSTER_NORMAL || assert(first_cluster_type == QCOW2_CLUSTER_NORMAL ||
first_cluster_type == QCOW2_CLUSTER_ZERO_ALLOC); first_cluster_type == QCOW2_CLUSTER_ZERO_ALLOC);
@ -412,7 +412,8 @@ static int count_contiguous_clusters(int nb_clusters, int cluster_size,
* Checks how many consecutive unallocated clusters in a given L2 * Checks how many consecutive unallocated clusters in a given L2
* slice have the same cluster type. * slice have the same cluster type.
*/ */
static int count_contiguous_clusters_unallocated(int nb_clusters, static int count_contiguous_clusters_unallocated(BlockDriverState *bs,
int nb_clusters,
uint64_t *l2_slice, uint64_t *l2_slice,
QCow2ClusterType wanted_type) QCow2ClusterType wanted_type)
{ {
@ -422,7 +423,7 @@ static int count_contiguous_clusters_unallocated(int nb_clusters,
wanted_type == QCOW2_CLUSTER_UNALLOCATED); wanted_type == QCOW2_CLUSTER_UNALLOCATED);
for (i = 0; i < nb_clusters; i++) { for (i = 0; i < nb_clusters; i++) {
uint64_t entry = be64_to_cpu(l2_slice[i]); uint64_t entry = be64_to_cpu(l2_slice[i]);
QCow2ClusterType type = qcow2_get_cluster_type(entry); QCow2ClusterType type = qcow2_get_cluster_type(bs, entry);
if (type != wanted_type) { if (type != wanted_type) {
break; break;
@ -595,7 +596,7 @@ int qcow2_get_cluster_offset(BlockDriverState *bs, uint64_t offset,
* true */ * true */
assert(nb_clusters <= INT_MAX); assert(nb_clusters <= INT_MAX);
type = qcow2_get_cluster_type(*cluster_offset); type = qcow2_get_cluster_type(bs, *cluster_offset);
if (s->qcow_version < 3 && (type == QCOW2_CLUSTER_ZERO_PLAIN || if (s->qcow_version < 3 && (type == QCOW2_CLUSTER_ZERO_PLAIN ||
type == QCOW2_CLUSTER_ZERO_ALLOC)) { type == QCOW2_CLUSTER_ZERO_ALLOC)) {
qcow2_signal_corruption(bs, true, -1, -1, "Zero cluster entry found" qcow2_signal_corruption(bs, true, -1, -1, "Zero cluster entry found"
@ -613,14 +614,14 @@ int qcow2_get_cluster_offset(BlockDriverState *bs, uint64_t offset,
case QCOW2_CLUSTER_ZERO_PLAIN: case QCOW2_CLUSTER_ZERO_PLAIN:
case QCOW2_CLUSTER_UNALLOCATED: case QCOW2_CLUSTER_UNALLOCATED:
/* how many empty clusters ? */ /* how many empty clusters ? */
c = count_contiguous_clusters_unallocated(nb_clusters, c = count_contiguous_clusters_unallocated(bs, nb_clusters,
&l2_slice[l2_index], type); &l2_slice[l2_index], type);
*cluster_offset = 0; *cluster_offset = 0;
break; break;
case QCOW2_CLUSTER_ZERO_ALLOC: case QCOW2_CLUSTER_ZERO_ALLOC:
case QCOW2_CLUSTER_NORMAL: case QCOW2_CLUSTER_NORMAL:
/* how many allocated clusters ? */ /* how many allocated clusters ? */
c = count_contiguous_clusters(nb_clusters, s->cluster_size, c = count_contiguous_clusters(bs, nb_clusters, s->cluster_size,
&l2_slice[l2_index], QCOW_OFLAG_ZERO); &l2_slice[l2_index], QCOW_OFLAG_ZERO);
*cluster_offset &= L2E_OFFSET_MASK; *cluster_offset &= L2E_OFFSET_MASK;
if (offset_into_cluster(s, *cluster_offset)) { if (offset_into_cluster(s, *cluster_offset)) {
@ -1013,14 +1014,14 @@ void qcow2_alloc_cluster_abort(BlockDriverState *bs, QCowL2Meta *m)
* write, but require COW to be performed (this includes yet unallocated space, * write, but require COW to be performed (this includes yet unallocated space,
* which must copy from the backing file) * which must copy from the backing file)
*/ */
static int count_cow_clusters(BDRVQcow2State *s, int nb_clusters, static int count_cow_clusters(BlockDriverState *bs, int nb_clusters,
uint64_t *l2_slice, int l2_index) uint64_t *l2_slice, int l2_index)
{ {
int i; int i;
for (i = 0; i < nb_clusters; i++) { for (i = 0; i < nb_clusters; i++) {
uint64_t l2_entry = be64_to_cpu(l2_slice[l2_index + i]); uint64_t l2_entry = be64_to_cpu(l2_slice[l2_index + i]);
QCow2ClusterType cluster_type = qcow2_get_cluster_type(l2_entry); QCow2ClusterType cluster_type = qcow2_get_cluster_type(bs, l2_entry);
switch(cluster_type) { switch(cluster_type) {
case QCOW2_CLUSTER_NORMAL: case QCOW2_CLUSTER_NORMAL:
@ -1165,7 +1166,7 @@ static int handle_copied(BlockDriverState *bs, uint64_t guest_offset,
cluster_offset = be64_to_cpu(l2_slice[l2_index]); cluster_offset = be64_to_cpu(l2_slice[l2_index]);
/* Check how many clusters are already allocated and don't need COW */ /* Check how many clusters are already allocated and don't need COW */
if (qcow2_get_cluster_type(cluster_offset) == QCOW2_CLUSTER_NORMAL if (qcow2_get_cluster_type(bs, cluster_offset) == QCOW2_CLUSTER_NORMAL
&& (cluster_offset & QCOW_OFLAG_COPIED)) && (cluster_offset & QCOW_OFLAG_COPIED))
{ {
/* If a specific host_offset is required, check it */ /* If a specific host_offset is required, check it */
@ -1189,7 +1190,7 @@ static int handle_copied(BlockDriverState *bs, uint64_t guest_offset,
/* We keep all QCOW_OFLAG_COPIED clusters */ /* We keep all QCOW_OFLAG_COPIED clusters */
keep_clusters = keep_clusters =
count_contiguous_clusters(nb_clusters, s->cluster_size, count_contiguous_clusters(bs, nb_clusters, s->cluster_size,
&l2_slice[l2_index], &l2_slice[l2_index],
QCOW_OFLAG_COPIED | QCOW_OFLAG_ZERO); QCOW_OFLAG_COPIED | QCOW_OFLAG_ZERO);
assert(keep_clusters <= nb_clusters); assert(keep_clusters <= nb_clusters);
@ -1324,7 +1325,7 @@ static int handle_alloc(BlockDriverState *bs, uint64_t guest_offset,
if (entry & QCOW_OFLAG_COMPRESSED) { if (entry & QCOW_OFLAG_COMPRESSED) {
nb_clusters = 1; nb_clusters = 1;
} else { } else {
nb_clusters = count_cow_clusters(s, nb_clusters, l2_slice, l2_index); nb_clusters = count_cow_clusters(bs, nb_clusters, l2_slice, l2_index);
} }
/* This function is only called when there were no non-COW clusters, so if /* This function is only called when there were no non-COW clusters, so if
@ -1332,7 +1333,7 @@ static int handle_alloc(BlockDriverState *bs, uint64_t guest_offset,
* wrong with our code. */ * wrong with our code. */
assert(nb_clusters > 0); assert(nb_clusters > 0);
if (qcow2_get_cluster_type(entry) == QCOW2_CLUSTER_ZERO_ALLOC && if (qcow2_get_cluster_type(bs, entry) == QCOW2_CLUSTER_ZERO_ALLOC &&
(entry & QCOW_OFLAG_COPIED) && (entry & QCOW_OFLAG_COPIED) &&
(!*host_offset || (!*host_offset ||
start_of_cluster(s, *host_offset) == (entry & L2E_OFFSET_MASK))) start_of_cluster(s, *host_offset) == (entry & L2E_OFFSET_MASK)))
@ -1352,7 +1353,7 @@ static int handle_alloc(BlockDriverState *bs, uint64_t guest_offset,
* would be fine, too, but count_cow_clusters() above has limited * would be fine, too, but count_cow_clusters() above has limited
* nb_clusters already to a range of COW clusters */ * nb_clusters already to a range of COW clusters */
preallocated_nb_clusters = preallocated_nb_clusters =
count_contiguous_clusters(nb_clusters, s->cluster_size, count_contiguous_clusters(bs, nb_clusters, s->cluster_size,
&l2_slice[l2_index], QCOW_OFLAG_COPIED); &l2_slice[l2_index], QCOW_OFLAG_COPIED);
assert(preallocated_nb_clusters > 0); assert(preallocated_nb_clusters > 0);
@ -1616,7 +1617,7 @@ static int discard_in_l2_slice(BlockDriverState *bs, uint64_t offset,
* If full_discard is true, the sector should not read back as zeroes, * If full_discard is true, the sector should not read back as zeroes,
* but rather fall through to the backing file. * but rather fall through to the backing file.
*/ */
switch (qcow2_get_cluster_type(old_l2_entry)) { switch (qcow2_get_cluster_type(bs, old_l2_entry)) {
case QCOW2_CLUSTER_UNALLOCATED: case QCOW2_CLUSTER_UNALLOCATED:
if (full_discard || !bs->backing) { if (full_discard || !bs->backing) {
continue; continue;
@ -1729,7 +1730,7 @@ static int zero_in_l2_slice(BlockDriverState *bs, uint64_t offset,
* Minimize L2 changes if the cluster already reads back as * Minimize L2 changes if the cluster already reads back as
* zeroes with correct allocation. * zeroes with correct allocation.
*/ */
cluster_type = qcow2_get_cluster_type(old_offset); cluster_type = qcow2_get_cluster_type(bs, old_offset);
if (cluster_type == QCOW2_CLUSTER_ZERO_PLAIN || if (cluster_type == QCOW2_CLUSTER_ZERO_PLAIN ||
(cluster_type == QCOW2_CLUSTER_ZERO_ALLOC && !unmap)) { (cluster_type == QCOW2_CLUSTER_ZERO_ALLOC && !unmap)) {
continue; continue;
@ -1871,7 +1872,7 @@ static int expand_zero_clusters_in_l1(BlockDriverState *bs, uint64_t *l1_table,
uint64_t l2_entry = be64_to_cpu(l2_slice[j]); uint64_t l2_entry = be64_to_cpu(l2_slice[j]);
int64_t offset = l2_entry & L2E_OFFSET_MASK; int64_t offset = l2_entry & L2E_OFFSET_MASK;
QCow2ClusterType cluster_type = QCow2ClusterType cluster_type =
qcow2_get_cluster_type(l2_entry); qcow2_get_cluster_type(bs, l2_entry);
if (cluster_type != QCOW2_CLUSTER_ZERO_PLAIN && if (cluster_type != QCOW2_CLUSTER_ZERO_PLAIN &&
cluster_type != QCOW2_CLUSTER_ZERO_ALLOC) { cluster_type != QCOW2_CLUSTER_ZERO_ALLOC) {

10
block/qcow2-refcount.c
View File

@ -1157,7 +1157,7 @@ void qcow2_free_any_clusters(BlockDriverState *bs, uint64_t l2_entry,
{ {
BDRVQcow2State *s = bs->opaque; BDRVQcow2State *s = bs->opaque;
switch (qcow2_get_cluster_type(l2_entry)) { switch (qcow2_get_cluster_type(bs, l2_entry)) {
case QCOW2_CLUSTER_COMPRESSED: case QCOW2_CLUSTER_COMPRESSED:
{ {
int nb_csectors; int nb_csectors;
@ -1300,7 +1300,7 @@ int qcow2_update_snapshot_refcount(BlockDriverState *bs,
entry &= ~QCOW_OFLAG_COPIED; entry &= ~QCOW_OFLAG_COPIED;
offset = entry & L2E_OFFSET_MASK; offset = entry & L2E_OFFSET_MASK;
switch (qcow2_get_cluster_type(entry)) { switch (qcow2_get_cluster_type(bs, entry)) {
case QCOW2_CLUSTER_COMPRESSED: case QCOW2_CLUSTER_COMPRESSED:
nb_csectors = ((entry >> s->csize_shift) & nb_csectors = ((entry >> s->csize_shift) &
s->csize_mask) + 1; s->csize_mask) + 1;
@ -1582,7 +1582,7 @@ static int check_refcounts_l2(BlockDriverState *bs, BdrvCheckResult *res,
for(i = 0; i < s->l2_size; i++) { for(i = 0; i < s->l2_size; i++) {
l2_entry = be64_to_cpu(l2_table[i]); l2_entry = be64_to_cpu(l2_table[i]);
switch (qcow2_get_cluster_type(l2_entry)) { switch (qcow2_get_cluster_type(bs, l2_entry)) {
case QCOW2_CLUSTER_COMPRESSED: case QCOW2_CLUSTER_COMPRESSED:
/* Compressed clusters don't have QCOW_OFLAG_COPIED */ /* Compressed clusters don't have QCOW_OFLAG_COPIED */
if (l2_entry & QCOW_OFLAG_COPIED) { if (l2_entry & QCOW_OFLAG_COPIED) {
@ -1633,7 +1633,7 @@ static int check_refcounts_l2(BlockDriverState *bs, BdrvCheckResult *res,
/* Correct offsets are cluster aligned */ /* Correct offsets are cluster aligned */
if (offset_into_cluster(s, offset)) { if (offset_into_cluster(s, offset)) {
if (qcow2_get_cluster_type(l2_entry) == if (qcow2_get_cluster_type(bs, l2_entry) ==
QCOW2_CLUSTER_ZERO_ALLOC) QCOW2_CLUSTER_ZERO_ALLOC)
{ {
fprintf(stderr, "%s offset=%" PRIx64 ": Preallocated zero " fprintf(stderr, "%s offset=%" PRIx64 ": Preallocated zero "
@ -1868,7 +1868,7 @@ static int check_oflag_copied(BlockDriverState *bs, BdrvCheckResult *res,
for (j = 0; j < s->l2_size; j++) { for (j = 0; j < s->l2_size; j++) {
uint64_t l2_entry = be64_to_cpu(l2_table[j]); uint64_t l2_entry = be64_to_cpu(l2_table[j]);
uint64_t data_offset = l2_entry & L2E_OFFSET_MASK; uint64_t data_offset = l2_entry & L2E_OFFSET_MASK;
QCow2ClusterType cluster_type = qcow2_get_cluster_type(l2_entry); QCow2ClusterType cluster_type = qcow2_get_cluster_type(bs, l2_entry);
if (cluster_type == QCOW2_CLUSTER_NORMAL || if (cluster_type == QCOW2_CLUSTER_NORMAL ||
cluster_type == QCOW2_CLUSTER_ZERO_ALLOC) { cluster_type == QCOW2_CLUSTER_ZERO_ALLOC) {

3
block/qcow2.h
View File

@ -510,7 +510,8 @@ static inline int64_t qcow2_vm_state_offset(BDRVQcow2State *s)
return (int64_t)s->l1_vm_state_index << (s->cluster_bits + s->l2_bits); return (int64_t)s->l1_vm_state_index << (s->cluster_bits + s->l2_bits);
} }
static inline QCow2ClusterType qcow2_get_cluster_type(uint64_t l2_entry) static inline QCow2ClusterType qcow2_get_cluster_type(BlockDriverState *bs,
uint64_t l2_entry)
{ {
if (l2_entry & QCOW_OFLAG_COMPRESSED) { if (l2_entry & QCOW_OFLAG_COMPRESSED) {
return QCOW2_CLUSTER_COMPRESSED; return QCOW2_CLUSTER_COMPRESSED;