OpenE2K
/
qemu-e2k
13
4
Fork 0
Code Issues 4 Pull Requests Projects 2 Releases Activity

dirty-bitmap: Change bdrv_dirty_bitmap_*serialize*() to take bytes 

Right now, the dirty-bitmap code exposes the fact that we use
a scale of sector granularity in the underlying hbitmap to anything
that wants to serialize a dirty bitmap.  It's nicer to uniformly
expose bytes as our dirty-bitmap interface, matching the previous
change to bitmap size.  The only caller to serialization is currently
qcow2-cluster.c, which becomes a bit more verbose because it is still
tracking sectors for other reasons, but a later patch will fix that
to more uniformly use byte offsets everywhere.  Likewise, within
dirty-bitmap, we have to add more assertions that we are not
truncating incorrectly, which can go away once the internal hbitmap
is byte-based rather than sector-based.

Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
This commit is contained in:
Eric Blake 2017-09-25 09:55:14 -05:00 committed by Kevin Wolf
parent 993e6525bf
commit 86f6ae67e1
3 changed files with 45 additions and 28 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
block/dirty-bitmap.c
View File

@ -568,42 +568,53 @@ void bdrv_undo_clear_dirty_bitmap(BdrvDirtyBitmap *bitmap, HBitmap *in)
} }
uint64_t bdrv_dirty_bitmap_serialization_size(const BdrvDirtyBitmap *bitmap, uint64_t bdrv_dirty_bitmap_serialization_size(const BdrvDirtyBitmap *bitmap,
uint64_t start, uint64_t count) uint64_t offset, uint64_t bytes)
{ {
return hbitmap_serialization_size(bitmap->bitmap, start, count); assert(QEMU_IS_ALIGNED(offset | bytes, BDRV_SECTOR_SIZE));
return hbitmap_serialization_size(bitmap->bitmap,
offset >> BDRV_SECTOR_BITS,
bytes >> BDRV_SECTOR_BITS);
} }
uint64_t bdrv_dirty_bitmap_serialization_align(const BdrvDirtyBitmap *bitmap) uint64_t bdrv_dirty_bitmap_serialization_align(const BdrvDirtyBitmap *bitmap)
{ {
return hbitmap_serialization_align(bitmap->bitmap); return hbitmap_serialization_align(bitmap->bitmap) * BDRV_SECTOR_SIZE;
} }
void bdrv_dirty_bitmap_serialize_part(const BdrvDirtyBitmap *bitmap, void bdrv_dirty_bitmap_serialize_part(const BdrvDirtyBitmap *bitmap,
uint8_t *buf, uint64_t start, uint8_t *buf, uint64_t offset,
uint64_t count) uint64_t bytes)
{ {
hbitmap_serialize_part(bitmap->bitmap, buf, start, count); assert(QEMU_IS_ALIGNED(offset | bytes, BDRV_SECTOR_SIZE));
hbitmap_serialize_part(bitmap->bitmap, buf, offset >> BDRV_SECTOR_BITS,
bytes >> BDRV_SECTOR_BITS);
} }
void bdrv_dirty_bitmap_deserialize_part(BdrvDirtyBitmap *bitmap, void bdrv_dirty_bitmap_deserialize_part(BdrvDirtyBitmap *bitmap,
uint8_t *buf, uint64_t start, uint8_t *buf, uint64_t offset,
uint64_t count, bool finish) uint64_t bytes, bool finish)
{ {
hbitmap_deserialize_part(bitmap->bitmap, buf, start, count, finish); assert(QEMU_IS_ALIGNED(offset | bytes, BDRV_SECTOR_SIZE));
hbitmap_deserialize_part(bitmap->bitmap, buf, offset >> BDRV_SECTOR_BITS,
bytes >> BDRV_SECTOR_BITS, finish);
} }
void bdrv_dirty_bitmap_deserialize_zeroes(BdrvDirtyBitmap *bitmap, void bdrv_dirty_bitmap_deserialize_zeroes(BdrvDirtyBitmap *bitmap,
uint64_t start, uint64_t count, uint64_t offset, uint64_t bytes,
bool finish) bool finish)
{ {
hbitmap_deserialize_zeroes(bitmap->bitmap, start, count, finish); assert(QEMU_IS_ALIGNED(offset | bytes, BDRV_SECTOR_SIZE));
hbitmap_deserialize_zeroes(bitmap->bitmap, offset >> BDRV_SECTOR_BITS,
bytes >> BDRV_SECTOR_BITS, finish);
} }
void bdrv_dirty_bitmap_deserialize_ones(BdrvDirtyBitmap *bitmap, void bdrv_dirty_bitmap_deserialize_ones(BdrvDirtyBitmap *bitmap,
uint64_t start, uint64_t count, uint64_t offset, uint64_t bytes,
bool finish) bool finish)
{ {
hbitmap_deserialize_ones(bitmap->bitmap, start, count, finish); assert(QEMU_IS_ALIGNED(offset | bytes, BDRV_SECTOR_SIZE));
hbitmap_deserialize_ones(bitmap->bitmap, offset >> BDRV_SECTOR_BITS,
bytes >> BDRV_SECTOR_BITS, finish);
} }
void bdrv_dirty_bitmap_deserialize_finish(BdrvDirtyBitmap *bitmap) void bdrv_dirty_bitmap_deserialize_finish(BdrvDirtyBitmap *bitmap)

22
block/qcow2-bitmap.c
View File

@ -278,7 +278,7 @@ static uint64_t sectors_covered_by_bitmap_cluster(const BDRVQcow2State *s,
bdrv_dirty_bitmap_granularity(bitmap) >> BDRV_SECTOR_BITS; bdrv_dirty_bitmap_granularity(bitmap) >> BDRV_SECTOR_BITS;
uint64_t sbc = sector_granularity * (s->cluster_size << 3); uint64_t sbc = sector_granularity * (s->cluster_size << 3);
assert(QEMU_IS_ALIGNED(sbc, assert(QEMU_IS_ALIGNED(sbc << BDRV_SECTOR_BITS,
bdrv_dirty_bitmap_serialization_align(bitmap))); bdrv_dirty_bitmap_serialization_align(bitmap)));
return sbc; return sbc;
} }
@ -299,7 +299,7 @@ static int load_bitmap_data(BlockDriverState *bs,
uint8_t *buf = NULL; uint8_t *buf = NULL;
uint64_t i, tab_size = uint64_t i, tab_size =
size_to_clusters(s, size_to_clusters(s,
bdrv_dirty_bitmap_serialization_size(bitmap, 0, bm_sectors)); bdrv_dirty_bitmap_serialization_size(bitmap, 0, bm_size));
if (tab_size != bitmap_table_size || tab_size > BME_MAX_TABLE_SIZE) { if (tab_size != bitmap_table_size || tab_size > BME_MAX_TABLE_SIZE) {
return -EINVAL; return -EINVAL;
@ -316,7 +316,9 @@ static int load_bitmap_data(BlockDriverState *bs,
if (offset == 0) { if (offset == 0) {
if (entry & BME_TABLE_ENTRY_FLAG_ALL_ONES) { if (entry & BME_TABLE_ENTRY_FLAG_ALL_ONES) {
bdrv_dirty_bitmap_deserialize_ones(bitmap, sector, count, bdrv_dirty_bitmap_deserialize_ones(bitmap,
sector * BDRV_SECTOR_SIZE,
count * BDRV_SECTOR_SIZE,
false); false);
} else { } else {
/* No need to deserialize zeros because the dirty bitmap is /* No need to deserialize zeros because the dirty bitmap is
@ -327,7 +329,9 @@ static int load_bitmap_data(BlockDriverState *bs,
if (ret < 0) { if (ret < 0) {
goto finish; goto finish;
} }
bdrv_dirty_bitmap_deserialize_part(bitmap, buf, sector, count, bdrv_dirty_bitmap_deserialize_part(bitmap, buf,
sector * BDRV_SECTOR_SIZE,
count * BDRV_SECTOR_SIZE,
false); false);
} }
} }
@ -1085,7 +1089,7 @@ static uint64_t *store_bitmap_data(BlockDriverState *bs,
uint64_t *tb; uint64_t *tb;
uint64_t tb_size = uint64_t tb_size =
size_to_clusters(s, size_to_clusters(s,
bdrv_dirty_bitmap_serialization_size(bitmap, 0, bm_sectors)); bdrv_dirty_bitmap_serialization_size(bitmap, 0, bm_size));
if (tb_size > BME_MAX_TABLE_SIZE || if (tb_size > BME_MAX_TABLE_SIZE ||
tb_size * s->cluster_size > BME_MAX_PHYS_SIZE) tb_size * s->cluster_size > BME_MAX_PHYS_SIZE)
@ -1112,8 +1116,8 @@ static uint64_t *store_bitmap_data(BlockDriverState *bs,
sector = cluster * sbc; sector = cluster * sbc;
end = MIN(bm_sectors, sector + sbc); end = MIN(bm_sectors, sector + sbc);
write_size = write_size = bdrv_dirty_bitmap_serialization_size(bitmap,
bdrv_dirty_bitmap_serialization_size(bitmap, sector, end - sector); sector * BDRV_SECTOR_SIZE, (end - sector) * BDRV_SECTOR_SIZE);
assert(write_size <= s->cluster_size); assert(write_size <= s->cluster_size);
off = qcow2_alloc_clusters(bs, s->cluster_size); off = qcow2_alloc_clusters(bs, s->cluster_size);
@ -1125,7 +1129,9 @@ static uint64_t *store_bitmap_data(BlockDriverState *bs,
} }
tb[cluster] = off; tb[cluster] = off;
bdrv_dirty_bitmap_serialize_part(bitmap, buf, sector, end - sector); bdrv_dirty_bitmap_serialize_part(bitmap, buf,
sector * BDRV_SECTOR_SIZE,
(end - sector) * BDRV_SECTOR_SIZE);
if (write_size < s->cluster_size) { if (write_size < s->cluster_size) {
memset(buf + write_size, 0, s->cluster_size - write_size); memset(buf + write_size, 0, s->cluster_size - write_size);
} }

14
include/block/dirty-bitmap.h
View File

@ -49,19 +49,19 @@ BdrvDirtyBitmapIter *bdrv_dirty_iter_new(BdrvDirtyBitmap *bitmap,
void bdrv_dirty_iter_free(BdrvDirtyBitmapIter *iter); void bdrv_dirty_iter_free(BdrvDirtyBitmapIter *iter);
uint64_t bdrv_dirty_bitmap_serialization_size(const BdrvDirtyBitmap *bitmap, uint64_t bdrv_dirty_bitmap_serialization_size(const BdrvDirtyBitmap *bitmap,
uint64_t start, uint64_t count); uint64_t offset, uint64_t bytes);
uint64_t bdrv_dirty_bitmap_serialization_align(const BdrvDirtyBitmap *bitmap); uint64_t bdrv_dirty_bitmap_serialization_align(const BdrvDirtyBitmap *bitmap);
void bdrv_dirty_bitmap_serialize_part(const BdrvDirtyBitmap *bitmap, void bdrv_dirty_bitmap_serialize_part(const BdrvDirtyBitmap *bitmap,
uint8_t *buf, uint64_t start, uint8_t *buf, uint64_t offset,
uint64_t count); uint64_t bytes);
void bdrv_dirty_bitmap_deserialize_part(BdrvDirtyBitmap *bitmap, void bdrv_dirty_bitmap_deserialize_part(BdrvDirtyBitmap *bitmap,
uint8_t *buf, uint64_t start, uint8_t *buf, uint64_t offset,
uint64_t count, bool finish); uint64_t bytes, bool finish);
void bdrv_dirty_bitmap_deserialize_zeroes(BdrvDirtyBitmap *bitmap, void bdrv_dirty_bitmap_deserialize_zeroes(BdrvDirtyBitmap *bitmap,
uint64_t start, uint64_t count, uint64_t offset, uint64_t bytes,
bool finish); bool finish);
void bdrv_dirty_bitmap_deserialize_ones(BdrvDirtyBitmap *bitmap, void bdrv_dirty_bitmap_deserialize_ones(BdrvDirtyBitmap *bitmap,
uint64_t start, uint64_t count, uint64_t offset, uint64_t bytes,
bool finish); bool finish);
void bdrv_dirty_bitmap_deserialize_finish(BdrvDirtyBitmap *bitmap); void bdrv_dirty_bitmap_deserialize_finish(BdrvDirtyBitmap *bitmap);