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

block migration: Rework constants API 

Instead of duplicating the definition of constants or introducing
trivial retrieval functions move the SECTOR constants into the public
block API. This also obsoletes sector_per_block in BlkMigState.

Signed-off-by: Jan Kiszka <jan.kiszka@siemens.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
This commit is contained in:
Jan Kiszka 2009-11-30 18:21:19 +01:00 committed by Anthony Liguori
parent a55eb92c22
commit 6ea44308b0
3 changed files with 58 additions and 72 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

63
block-migration.c
View File

@ -17,11 +17,7 @@
#include "block-migration.h" #include "block-migration.h"
#include <assert.h> #include <assert.h>
#define SECTOR_BITS 9 #define BLOCK_SIZE (BDRV_SECTORS_PER_DIRTY_CHUNK << BDRV_SECTOR_BITS)
#define SECTOR_SIZE (1 << SECTOR_BITS)
#define SECTOR_MASK ~(SECTOR_SIZE - 1);
#define BLOCK_SIZE (block_mig_state->sectors_per_block << SECTOR_BITS)
#define BLK_MIG_FLAG_DEVICE_BLOCK 0x01 #define BLK_MIG_FLAG_DEVICE_BLOCK 0x01
#define BLK_MIG_FLAG_EOS 0x02 #define BLK_MIG_FLAG_EOS 0x02
@ -69,7 +65,6 @@ typedef struct BlkMigState {
int no_dirty; int no_dirty;
QEMUFile *load_file; QEMUFile *load_file;
BlkMigDevState *bmds_first; BlkMigDevState *bmds_first;
int sectors_per_block;
BlkMigBlock *first_blk; BlkMigBlock *first_blk;
BlkMigBlock *last_blk; BlkMigBlock *last_blk;
int submitted; int submitted;
@ -111,7 +106,7 @@ static int mig_read_device_bulk(QEMUFile *f, BlkMigDevState *bms)
blk->buf = qemu_malloc(BLOCK_SIZE); blk->buf = qemu_malloc(BLOCK_SIZE);
cur_sector = bms->cur_sector; cur_sector = bms->cur_sector;
total_sectors = bdrv_getlength(bs) >> SECTOR_BITS; total_sectors = bdrv_getlength(bs) >> BDRV_SECTOR_BITS;
if (bms->shared_base) { if (bms->shared_base) {
while (cur_sector < bms->total_sectors && while (cur_sector < bms->total_sectors &&
@ -132,15 +127,15 @@ static int mig_read_device_bulk(QEMUFile *f, BlkMigDevState *bms)
printf("Completed %" PRId64 " %%\r", cur_sector * 100 / total_sectors); printf("Completed %" PRId64 " %%\r", cur_sector * 100 / total_sectors);
fflush(stdout); fflush(stdout);
block_mig_state->print_completion += block_mig_state->print_completion +=
(block_mig_state->sectors_per_block * 10000); (BDRV_SECTORS_PER_DIRTY_CHUNK * 10000);
} }
/* we going to transfder BLOCK_SIZE any way even if it is not allocated */ /* we are going to transfer a full block even if it is not allocated */
nr_sectors = block_mig_state->sectors_per_block; nr_sectors = BDRV_SECTORS_PER_DIRTY_CHUNK;
cur_sector &= ~((int64_t)block_mig_state->sectors_per_block -1); cur_sector &= ~((int64_t)BDRV_SECTORS_PER_DIRTY_CHUNK - 1);
if (total_sectors - cur_sector < block_mig_state->sectors_per_block) { if (total_sectors - cur_sector < BDRV_SECTORS_PER_DIRTY_CHUNK) {
nr_sectors = (total_sectors - cur_sector); nr_sectors = (total_sectors - cur_sector);
} }
@ -150,7 +145,7 @@ static int mig_read_device_bulk(QEMUFile *f, BlkMigDevState *bms)
blk->next = NULL; blk->next = NULL;
blk->iov.iov_base = blk->buf; blk->iov.iov_base = blk->buf;
blk->iov.iov_len = nr_sectors * SECTOR_SIZE; blk->iov.iov_len = nr_sectors * BDRV_SECTOR_SIZE;
qemu_iovec_init_external(&blk->qiov, &blk->iov, 1); qemu_iovec_init_external(&blk->qiov, &blk->iov, 1);
blk->aiocb = bdrv_aio_readv(bs, cur_sector, &blk->qiov, blk->aiocb = bdrv_aio_readv(bs, cur_sector, &blk->qiov,
@ -198,15 +193,15 @@ static int mig_save_device_bulk(QEMUFile *f, BlkMigDevState *bmds)
printf("Completed %" PRId64 " %%\r", cur_sector * 100 / total_sectors); printf("Completed %" PRId64 " %%\r", cur_sector * 100 / total_sectors);
fflush(stdout); fflush(stdout);
block_mig_state->print_completion += block_mig_state->print_completion +=
(block_mig_state->sectors_per_block * 10000); (BDRV_SECTORS_PER_DIRTY_CHUNK * 10000);
} }
cur_sector &= ~((int64_t)block_mig_state->sectors_per_block -1); cur_sector &= ~((int64_t)BDRV_SECTORS_PER_DIRTY_CHUNK - 1);
/* we going to transfer BLOCK_SIZE any way even if it is not allocated */ /* we are going to transfer a full block even if it is not allocated */
nr_sectors = block_mig_state->sectors_per_block; nr_sectors = BDRV_SECTORS_PER_DIRTY_CHUNK;
if (total_sectors - cur_sector < block_mig_state->sectors_per_block) { if (total_sectors - cur_sector < BDRV_SECTORS_PER_DIRTY_CHUNK) {
nr_sectors = (total_sectors - cur_sector); nr_sectors = (total_sectors - cur_sector);
} }
@ -217,7 +212,8 @@ static int mig_save_device_bulk(QEMUFile *f, BlkMigDevState *bmds)
bdrv_reset_dirty(bs, cur_sector, nr_sectors); bdrv_reset_dirty(bs, cur_sector, nr_sectors);
/* sector number and flags */ /* sector number and flags */
qemu_put_be64(f, (cur_sector << SECTOR_BITS) | BLK_MIG_FLAG_DEVICE_BLOCK); qemu_put_be64(f, (cur_sector << BDRV_SECTOR_BITS)
| BLK_MIG_FLAG_DEVICE_BLOCK);
/* device name */ /* device name */
len = strlen(bs->device_name); len = strlen(bs->device_name);
@ -226,7 +222,7 @@ static int mig_save_device_bulk(QEMUFile *f, BlkMigDevState *bmds)
qemu_put_buffer(f, tmp_buf, BLOCK_SIZE); qemu_put_buffer(f, tmp_buf, BLOCK_SIZE);
bmds->cur_sector = cur_sector + block_mig_state->sectors_per_block; bmds->cur_sector = cur_sector + BDRV_SECTORS_PER_DIRTY_CHUNK;
qemu_free(tmp_buf); qemu_free(tmp_buf);
@ -238,7 +234,8 @@ static void send_blk(QEMUFile *f, BlkMigBlock * blk)
int len; int len;
/* sector number and flags */ /* sector number and flags */
qemu_put_be64(f, (blk->sector << SECTOR_BITS) | BLK_MIG_FLAG_DEVICE_BLOCK); qemu_put_be64(f, (blk->sector << BDRV_SECTOR_BITS)
| BLK_MIG_FLAG_DEVICE_BLOCK);
/* device name */ /* device name */
len = strlen(blk->bmds->bs->device_name); len = strlen(blk->bmds->bs->device_name);
@ -270,7 +267,7 @@ static void init_blk_migration(QEMUFile *f)
bmds = qemu_mallocz(sizeof(BlkMigDevState)); bmds = qemu_mallocz(sizeof(BlkMigDevState));
bmds->bs = bs; bmds->bs = bs;
bmds->bulk_completed = 0; bmds->bulk_completed = 0;
bmds->total_sectors = bdrv_getlength(bs) >> SECTOR_BITS; bmds->total_sectors = bdrv_getlength(bs) >> BDRV_SECTOR_BITS;
bmds->shared_base = block_mig_state->shared_base; bmds->shared_base = block_mig_state->shared_base;
if (bmds->shared_base) { if (bmds->shared_base) {
@ -290,8 +287,6 @@ static void init_blk_migration(QEMUFile *f)
blk_mig_save_dev_info(f, bmds); blk_mig_save_dev_info(f, bmds);
} }
} }
block_mig_state->sectors_per_block = bdrv_get_sectors_per_chunk();
} }
static int blk_mig_save_bulked_block(QEMUFile *f, int is_async) static int blk_mig_save_bulked_block(QEMUFile *f, int is_async)
@ -334,12 +329,12 @@ static void blk_mig_save_dirty_blocks(QEMUFile *f)
for (sector = 0; sector < bmds->cur_sector;) { for (sector = 0; sector < bmds->cur_sector;) {
if (bdrv_get_dirty(bmds->bs, sector)) { if (bdrv_get_dirty(bmds->bs, sector)) {
if (bdrv_read(bmds->bs, sector, buf, if (bdrv_read(bmds->bs, sector, buf,
block_mig_state->sectors_per_block) < 0) { BDRV_SECTORS_PER_DIRTY_CHUNK) < 0) {
/* FIXME: add error handling */ /* FIXME: add error handling */
} }
/* sector number and flags */ /* sector number and flags */
qemu_put_be64(f, (sector << SECTOR_BITS) qemu_put_be64(f, (sector << BDRV_SECTOR_BITS)
| BLK_MIG_FLAG_DEVICE_BLOCK); | BLK_MIG_FLAG_DEVICE_BLOCK);
/* device name */ /* device name */
@ -347,14 +342,12 @@ static void blk_mig_save_dirty_blocks(QEMUFile *f)
qemu_put_byte(f, len); qemu_put_byte(f, len);
qemu_put_buffer(f, (uint8_t *)bmds->bs->device_name, len); qemu_put_buffer(f, (uint8_t *)bmds->bs->device_name, len);
qemu_put_buffer(f, buf, qemu_put_buffer(f, buf, BLOCK_SIZE);
(block_mig_state->sectors_per_block *
SECTOR_SIZE));
bdrv_reset_dirty(bmds->bs, sector, bdrv_reset_dirty(bmds->bs, sector,
block_mig_state->sectors_per_block); BDRV_SECTORS_PER_DIRTY_CHUNK);
} }
sector += block_mig_state->sectors_per_block; sector += BDRV_SECTORS_PER_DIRTY_CHUNK;
} }
} }
} }
@ -465,14 +458,13 @@ static int block_load(QEMUFile *f, void *opaque, int version_id)
BlockDriverState *bs; BlockDriverState *bs;
uint8_t *buf; uint8_t *buf;
block_mig_state->sectors_per_block = bdrv_get_sectors_per_chunk();
buf = qemu_malloc(BLOCK_SIZE); buf = qemu_malloc(BLOCK_SIZE);
do { do {
addr = qemu_get_be64(f); addr = qemu_get_be64(f);
flags = addr & ~SECTOR_MASK; flags = addr & ~BDRV_SECTOR_MASK;
addr &= SECTOR_MASK; addr >>= BDRV_SECTOR_BITS;
if (flags & BLK_MIG_FLAG_DEVICE_BLOCK) { if (flags & BLK_MIG_FLAG_DEVICE_BLOCK) {
/* get device name */ /* get device name */
@ -485,8 +477,7 @@ static int block_load(QEMUFile *f, void *opaque, int version_id)
qemu_get_buffer(f, buf, BLOCK_SIZE); qemu_get_buffer(f, buf, BLOCK_SIZE);
if (bs != NULL) { if (bs != NULL) {
bdrv_write(bs, (addr >> SECTOR_BITS), bdrv_write(bs, addr, buf, BDRV_SECTORS_PER_DIRTY_CHUNK);
buf, block_mig_state->sectors_per_block);
} else { } else {
printf("Error unknown block device %s\n", device_name); printf("Error unknown block device %s\n", device_name);
/* FIXME: add error handling */ /* FIXME: add error handling */

60
block.c
View File

@ -41,10 +41,6 @@
#include <windows.h> #include <windows.h>
#endif #endif
#define SECTOR_BITS 9
#define SECTOR_SIZE (1 << SECTOR_BITS)
#define SECTORS_PER_DIRTY_CHUNK 8
static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs, static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
BlockDriverCompletionFunc *cb, void *opaque); BlockDriverCompletionFunc *cb, void *opaque);
@ -386,7 +382,7 @@ int bdrv_open2(BlockDriverState *bs, const char *filename, int flags,
bdrv_delete(bs1); bdrv_delete(bs1);
return ret; return ret;
} }
total_size = bdrv_getlength(bs1) >> SECTOR_BITS; total_size = bdrv_getlength(bs1) >> BDRV_SECTOR_BITS;
if (bs1->drv && bs1->drv->protocol_name) if (bs1->drv && bs1->drv->protocol_name)
is_protocol = 1; is_protocol = 1;
@ -473,7 +469,7 @@ int bdrv_open2(BlockDriverState *bs, const char *filename, int flags,
return ret; return ret;
} }
if (drv->bdrv_getlength) { if (drv->bdrv_getlength) {
bs->total_sectors = bdrv_getlength(bs) >> SECTOR_BITS; bs->total_sectors = bdrv_getlength(bs) >> BDRV_SECTOR_BITS;
} }
#ifndef _WIN32 #ifndef _WIN32
if (bs->is_temporary) { if (bs->is_temporary) {
@ -576,7 +572,7 @@ int bdrv_commit(BlockDriverState *bs)
return -ENOTSUP; return -ENOTSUP;
} }
total_sectors = bdrv_getlength(bs) >> SECTOR_BITS; total_sectors = bdrv_getlength(bs) >> BDRV_SECTOR_BITS;
for (i = 0; i < total_sectors;) { for (i = 0; i < total_sectors;) {
if (drv->bdrv_is_allocated(bs, i, 65536, &n)) { if (drv->bdrv_is_allocated(bs, i, 65536, &n)) {
for(j = 0; j < n; j++) { for(j = 0; j < n; j++) {
@ -647,8 +643,8 @@ static void set_dirty_bitmap(BlockDriverState *bs, int64_t sector_num,
{ {
int64_t start, end; int64_t start, end;
start = sector_num / SECTORS_PER_DIRTY_CHUNK; start = sector_num / BDRV_SECTORS_PER_DIRTY_CHUNK;
end = (sector_num + nb_sectors) / SECTORS_PER_DIRTY_CHUNK; end = (sector_num + nb_sectors) / BDRV_SECTORS_PER_DIRTY_CHUNK;
for (; start <= end; start++) { for (; start <= end; start++) {
bs->dirty_bitmap[start] = dirty; bs->dirty_bitmap[start] = dirty;
@ -682,20 +678,20 @@ int bdrv_write(BlockDriverState *bs, int64_t sector_num,
int bdrv_pread(BlockDriverState *bs, int64_t offset, int bdrv_pread(BlockDriverState *bs, int64_t offset,
void *buf, int count1) void *buf, int count1)
{ {
uint8_t tmp_buf[SECTOR_SIZE]; uint8_t tmp_buf[BDRV_SECTOR_SIZE];
int len, nb_sectors, count; int len, nb_sectors, count;
int64_t sector_num; int64_t sector_num;
count = count1; count = count1;
/* first read to align to sector start */ /* first read to align to sector start */
len = (SECTOR_SIZE - offset) & (SECTOR_SIZE - 1); len = (BDRV_SECTOR_SIZE - offset) & (BDRV_SECTOR_SIZE - 1);
if (len > count) if (len > count)
len = count; len = count;
sector_num = offset >> SECTOR_BITS; sector_num = offset >> BDRV_SECTOR_BITS;
if (len > 0) { if (len > 0) {
if (bdrv_read(bs, sector_num, tmp_buf, 1) < 0) if (bdrv_read(bs, sector_num, tmp_buf, 1) < 0)
return -EIO; return -EIO;
memcpy(buf, tmp_buf + (offset & (SECTOR_SIZE - 1)), len); memcpy(buf, tmp_buf + (offset & (BDRV_SECTOR_SIZE - 1)), len);
count -= len; count -= len;
if (count == 0) if (count == 0)
return count1; return count1;
@ -704,12 +700,12 @@ int bdrv_pread(BlockDriverState *bs, int64_t offset,
} }
/* read the sectors "in place" */ /* read the sectors "in place" */
nb_sectors = count >> SECTOR_BITS; nb_sectors = count >> BDRV_SECTOR_BITS;
if (nb_sectors > 0) { if (nb_sectors > 0) {
if (bdrv_read(bs, sector_num, buf, nb_sectors) < 0) if (bdrv_read(bs, sector_num, buf, nb_sectors) < 0)
return -EIO; return -EIO;
sector_num += nb_sectors; sector_num += nb_sectors;
len = nb_sectors << SECTOR_BITS; len = nb_sectors << BDRV_SECTOR_BITS;
buf += len; buf += len;
count -= len; count -= len;
} }
@ -726,20 +722,20 @@ int bdrv_pread(BlockDriverState *bs, int64_t offset,
int bdrv_pwrite(BlockDriverState *bs, int64_t offset, int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
const void *buf, int count1) const void *buf, int count1)
{ {
uint8_t tmp_buf[SECTOR_SIZE]; uint8_t tmp_buf[BDRV_SECTOR_SIZE];
int len, nb_sectors, count; int len, nb_sectors, count;
int64_t sector_num; int64_t sector_num;
count = count1; count = count1;
/* first write to align to sector start */ /* first write to align to sector start */
len = (SECTOR_SIZE - offset) & (SECTOR_SIZE - 1); len = (BDRV_SECTOR_SIZE - offset) & (BDRV_SECTOR_SIZE - 1);
if (len > count) if (len > count)
len = count; len = count;
sector_num = offset >> SECTOR_BITS; sector_num = offset >> BDRV_SECTOR_BITS;
if (len > 0) { if (len > 0) {
if (bdrv_read(bs, sector_num, tmp_buf, 1) < 0) if (bdrv_read(bs, sector_num, tmp_buf, 1) < 0)
return -EIO; return -EIO;
memcpy(tmp_buf + (offset & (SECTOR_SIZE - 1)), buf, len); memcpy(tmp_buf + (offset & (BDRV_SECTOR_SIZE - 1)), buf, len);
if (bdrv_write(bs, sector_num, tmp_buf, 1) < 0) if (bdrv_write(bs, sector_num, tmp_buf, 1) < 0)
return -EIO; return -EIO;
count -= len; count -= len;
@ -750,12 +746,12 @@ int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
} }
/* write the sectors "in place" */ /* write the sectors "in place" */
nb_sectors = count >> SECTOR_BITS; nb_sectors = count >> BDRV_SECTOR_BITS;
if (nb_sectors > 0) { if (nb_sectors > 0) {
if (bdrv_write(bs, sector_num, buf, nb_sectors) < 0) if (bdrv_write(bs, sector_num, buf, nb_sectors) < 0)
return -EIO; return -EIO;
sector_num += nb_sectors; sector_num += nb_sectors;
len = nb_sectors << SECTOR_BITS; len = nb_sectors << BDRV_SECTOR_BITS;
buf += len; buf += len;
count -= len; count -= len;
} }
@ -796,7 +792,7 @@ int64_t bdrv_getlength(BlockDriverState *bs)
return -ENOMEDIUM; return -ENOMEDIUM;
if (!drv->bdrv_getlength) { if (!drv->bdrv_getlength) {
/* legacy mode */ /* legacy mode */
return bs->total_sectors * SECTOR_SIZE; return bs->total_sectors * BDRV_SECTOR_SIZE;
} }
return drv->bdrv_getlength(bs); return drv->bdrv_getlength(bs);
} }
@ -809,7 +805,7 @@ void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
if (length < 0) if (length < 0)
length = 0; length = 0;
else else
length = length >> SECTOR_BITS; length = length >> BDRV_SECTOR_BITS;
*nb_sectors_ptr = length; *nb_sectors_ptr = length;
} }
@ -1402,7 +1398,7 @@ BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
if (ret) { if (ret) {
/* Update stats even though technically transfer has not happened. */ /* Update stats even though technically transfer has not happened. */
bs->rd_bytes += (unsigned) nb_sectors * SECTOR_SIZE; bs->rd_bytes += (unsigned) nb_sectors * BDRV_SECTOR_SIZE;
bs->rd_ops ++; bs->rd_ops ++;
} }
@ -1432,7 +1428,7 @@ BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
if (ret) { if (ret) {
/* Update stats even though technically transfer has not happened. */ /* Update stats even though technically transfer has not happened. */
bs->wr_bytes += (unsigned) nb_sectors * SECTOR_SIZE; bs->wr_bytes += (unsigned) nb_sectors * BDRV_SECTOR_SIZE;
bs->wr_ops ++; bs->wr_ops ++;
} }
@ -1973,8 +1969,8 @@ void bdrv_set_dirty_tracking(BlockDriverState *bs, int enable)
int64_t i; int64_t i;
uint8_t test; uint8_t test;
bitmap_size = (bdrv_getlength(bs) >> SECTOR_BITS); bitmap_size = (bdrv_getlength(bs) >> BDRV_SECTOR_BITS);
bitmap_size /= SECTORS_PER_DIRTY_CHUNK; bitmap_size /= BDRV_SECTORS_PER_DIRTY_CHUNK;
bitmap_size++; bitmap_size++;
bs->dirty_bitmap = qemu_mallocz(bitmap_size); bs->dirty_bitmap = qemu_mallocz(bitmap_size);
@ -1992,10 +1988,10 @@ void bdrv_set_dirty_tracking(BlockDriverState *bs, int enable)
int bdrv_get_dirty(BlockDriverState *bs, int64_t sector) int bdrv_get_dirty(BlockDriverState *bs, int64_t sector)
{ {
int64_t chunk = sector / (int64_t)SECTORS_PER_DIRTY_CHUNK; int64_t chunk = sector / (int64_t)BDRV_SECTORS_PER_DIRTY_CHUNK;
if (bs->dirty_bitmap != NULL && if (bs->dirty_bitmap != NULL &&
(sector << SECTOR_BITS) <= bdrv_getlength(bs)) { (sector << BDRV_SECTOR_BITS) <= bdrv_getlength(bs)) {
return bs->dirty_bitmap[chunk]; return bs->dirty_bitmap[chunk];
} else { } else {
return 0; return 0;
@ -2007,9 +2003,3 @@ void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector,
{ {
set_dirty_bitmap(bs, cur_sector, nr_sectors, 0); set_dirty_bitmap(bs, cur_sector, nr_sectors, 0);
} }
int bdrv_get_sectors_per_chunk(void)
{
/* size must be 2^x */
return SECTORS_PER_DIRTY_CHUNK;
}

7
block.h
View File

@ -41,6 +41,10 @@ typedef struct QEMUSnapshotInfo {
#define BDRV_O_CACHE_MASK (BDRV_O_NOCACHE | BDRV_O_CACHE_WB) #define BDRV_O_CACHE_MASK (BDRV_O_NOCACHE | BDRV_O_CACHE_WB)
#define BDRV_SECTOR_BITS 9
#define BDRV_SECTOR_SIZE (1 << BDRV_SECTOR_BITS)
#define BDRV_SECTOR_MASK ~(BDRV_SECTOR_SIZE - 1);
void bdrv_info(Monitor *mon); void bdrv_info(Monitor *mon);
void bdrv_info_stats(Monitor *mon); void bdrv_info_stats(Monitor *mon);
@ -188,9 +192,10 @@ int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf, int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,
int64_t pos, int size); int64_t pos, int size);
#define BDRV_SECTORS_PER_DIRTY_CHUNK 8
void bdrv_set_dirty_tracking(BlockDriverState *bs, int enable); void bdrv_set_dirty_tracking(BlockDriverState *bs, int enable);
int bdrv_get_dirty(BlockDriverState *bs, int64_t sector); int bdrv_get_dirty(BlockDriverState *bs, int64_t sector);
void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector, void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector,
int nr_sectors); int nr_sectors);
int bdrv_get_sectors_per_chunk(void);
#endif #endif