motorhead/qemu
1
0
Fork 0
mirror of https://github.com/Motorhead1991/qemu.git synced 2025-08-22 09:32:40 -06:00
Code Issues Projects Releases Packages Wiki Activity Actions

qcow: Switch get_cluster_offset to be byte-based

Browse source 
We are gradually moving away from sector-based interfaces, towards
byte-based.  Make the change for the internal helper function
get_cluster_offset(), by changing n_start and n_end to be byte
offsets rather than sector indices within the cluster being
allocated.  However, assert that these values are still
sector-aligned (at least qcrypto_block_encrypt() still wants that).
For now we get that alignment for free because we still use
sector-based driver callbacks.

A later patch will then switch the qcow driver as a whole over
to byte-based operation; but will still leave things at sector
alignments as it is not worth auditing the qcow image format
to worry about sub-sector requests.

Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Jeff Cody <jcody@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
This commit is contained in:
Eric Blake 2018-06-28 15:15:19 -05:00 • committed by Kevin Wolf
parent d08c2a245f
commit 787993a543
1 changed files with 15 additions and 14 deletions
Download patch file Download diff file Expand all files Collapse all files

29
block/qcow.c
View file

@ -345,8 +345,8 @@ static int qcow_reopen_prepare(BDRVReopenState *state,
* *
* 0 to not allocate. * 0 to not allocate.
* *
* 1 to allocate a normal cluster (for sector indexes 'n_start' to * 1 to allocate a normal cluster (for sector-aligned byte offsets 'n_start'
* 'n_end') * to 'n_end' within the cluster)
* *
* 2 to allocate a compressed cluster of size * 2 to allocate a compressed cluster of size
* 'compressed_size'. 'compressed_size' must be > 0 and < * 'compressed_size'. 'compressed_size' must be > 0 and <
@ -440,9 +440,10 @@ static int get_cluster_offset(BlockDriverState *bs,
if (!allocate) if (!allocate)
return 0; return 0;
BLKDBG_EVENT(bs->file, BLKDBG_CLUSTER_ALLOC); BLKDBG_EVENT(bs->file, BLKDBG_CLUSTER_ALLOC);
assert(QEMU_IS_ALIGNED(n_start | n_end, BDRV_SECTOR_SIZE));
/* allocate a new cluster */ /* allocate a new cluster */
if ((cluster_offset & QCOW_OFLAG_COMPRESSED) && if ((cluster_offset & QCOW_OFLAG_COMPRESSED) &&
(n_end - n_start) < s->cluster_sectors) { (n_end - n_start) < s->cluster_size) {
/* if the cluster is already compressed, we must /* if the cluster is already compressed, we must
decompress it in the case it is not completely decompress it in the case it is not completely
overwritten */ overwritten */
@ -480,16 +481,15 @@ static int get_cluster_offset(BlockDriverState *bs,
/* if encrypted, we must initialize the cluster /* if encrypted, we must initialize the cluster
content which won't be written */ content which won't be written */
if (bs->encrypted && if (bs->encrypted &&
(n_end - n_start) < s->cluster_sectors) { (n_end - n_start) < s->cluster_size) {
uint64_t start_sect; uint64_t start_offset;
assert(s->crypto); assert(s->crypto);
start_sect = (offset & ~(s->cluster_size - 1)) >> 9; start_offset = offset & ~(s->cluster_size - 1);
for(i = 0; i < s->cluster_sectors; i++) { for (i = 0; i < s->cluster_size; i += BDRV_SECTOR_SIZE) {
if (i < n_start || i >= n_end) { if (i < n_start || i >= n_end) {
memset(s->cluster_data, 0x00, 512); memset(s->cluster_data, 0x00, BDRV_SECTOR_SIZE);
if (qcrypto_block_encrypt(s->crypto, if (qcrypto_block_encrypt(s->crypto,
(start_sect + i) * start_offset + i,
BDRV_SECTOR_SIZE,
s->cluster_data, s->cluster_data,
BDRV_SECTOR_SIZE, BDRV_SECTOR_SIZE,
NULL) < 0) { NULL) < 0) {
@ -497,8 +497,9 @@ static int get_cluster_offset(BlockDriverState *bs,
} }
BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO); BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);
ret = bdrv_pwrite(bs->file, ret = bdrv_pwrite(bs->file,
cluster_offset + i * 512, cluster_offset + i,
s->cluster_data, 512); s->cluster_data,
BDRV_SECTOR_SIZE);
if (ret < 0) { if (ret < 0) {
return ret; return ret;
} }
@ -758,8 +759,8 @@ static coroutine_fn int qcow_co_writev(BlockDriverState *bs, int64_t sector_num,
n = nb_sectors; n = nb_sectors;
} }
ret = get_cluster_offset(bs, sector_num << 9, 1, 0, ret = get_cluster_offset(bs, sector_num << 9, 1, 0,
index_in_cluster, index_in_cluster << 9,
index_in_cluster + n, &cluster_offset); (index_in_cluster + n) << 9, &cluster_offset);
if (ret < 0) { if (ret < 0) {
break; break;
} }