Revision a55eb92c block.c
| b/block.c | ||
|---|---|---|
| 643 | 643 |
} |
| 644 | 644 |
|
| 645 | 645 |
static void set_dirty_bitmap(BlockDriverState *bs, int64_t sector_num, |
| 646 |
int nb_sectors, int dirty)
|
|
| 646 |
int nb_sectors, int dirty)
|
|
| 647 | 647 |
{
|
| 648 | 648 |
int64_t start, end; |
| 649 |
|
|
| 649 | 650 |
start = sector_num / SECTORS_PER_DIRTY_CHUNK; |
| 650 | 651 |
end = (sector_num + nb_sectors) / SECTORS_PER_DIRTY_CHUNK; |
| 651 |
|
|
| 652 |
for(; start <= end; start++) {
|
|
| 652 |
|
|
| 653 |
for (; start <= end; start++) {
|
|
| 653 | 654 |
bs->dirty_bitmap[start] = dirty; |
| 654 | 655 |
} |
| 655 | 656 |
} |
| ... | ... | |
| 670 | 671 |
return -EACCES; |
| 671 | 672 |
if (bdrv_check_request(bs, sector_num, nb_sectors)) |
| 672 | 673 |
return -EIO; |
| 673 |
|
|
| 674 |
if(bs->dirty_tracking) {
|
|
| 674 |
|
|
| 675 |
if (bs->dirty_tracking) {
|
|
| 675 | 676 |
set_dirty_bitmap(bs, sector_num, nb_sectors, 1); |
| 676 | 677 |
} |
| 677 |
|
|
| 678 |
|
|
| 678 | 679 |
return drv->bdrv_write(bs, sector_num, buf, nb_sectors); |
| 679 | 680 |
} |
| 680 | 681 |
|
| ... | ... | |
| 1220 | 1221 |
return -ENOTSUP; |
| 1221 | 1222 |
if (bdrv_check_request(bs, sector_num, nb_sectors)) |
| 1222 | 1223 |
return -EIO; |
| 1223 |
|
|
| 1224 |
if(bs->dirty_tracking) {
|
|
| 1224 |
|
|
| 1225 |
if (bs->dirty_tracking) {
|
|
| 1225 | 1226 |
set_dirty_bitmap(bs, sector_num, nb_sectors, 1); |
| 1226 | 1227 |
} |
| 1227 |
|
|
| 1228 |
|
|
| 1228 | 1229 |
return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors); |
| 1229 | 1230 |
} |
| 1230 | 1231 |
|
| ... | ... | |
| 1422 | 1423 |
if (bdrv_check_request(bs, sector_num, nb_sectors)) |
| 1423 | 1424 |
return NULL; |
| 1424 | 1425 |
|
| 1425 |
if(bs->dirty_tracking) {
|
|
| 1426 |
if (bs->dirty_tracking) {
|
|
| 1426 | 1427 |
set_dirty_bitmap(bs, sector_num, nb_sectors, 1); |
| 1427 | 1428 |
} |
| 1428 |
|
|
| 1429 |
|
|
| 1429 | 1430 |
ret = drv->bdrv_aio_writev(bs, sector_num, qiov, nb_sectors, |
| 1430 | 1431 |
cb, opaque); |
| 1431 | 1432 |
|
| ... | ... | |
| 1966 | 1967 |
void bdrv_set_dirty_tracking(BlockDriverState *bs, int enable) |
| 1967 | 1968 |
{
|
| 1968 | 1969 |
int64_t bitmap_size; |
| 1969 |
if(enable) {
|
|
| 1970 |
if(bs->dirty_tracking == 0) {
|
|
| 1970 |
|
|
| 1971 |
if (enable) {
|
|
| 1972 |
if (bs->dirty_tracking == 0) {
|
|
| 1971 | 1973 |
int64_t i; |
| 1972 | 1974 |
uint8_t test; |
| 1975 |
|
|
| 1973 | 1976 |
bitmap_size = (bdrv_getlength(bs) >> SECTOR_BITS); |
| 1974 | 1977 |
bitmap_size /= SECTORS_PER_DIRTY_CHUNK; |
| 1975 | 1978 |
bitmap_size++; |
| 1976 |
|
|
| 1979 |
|
|
| 1977 | 1980 |
bs->dirty_bitmap = qemu_mallocz(bitmap_size); |
| 1978 |
|
|
| 1981 |
|
|
| 1979 | 1982 |
bs->dirty_tracking = enable; |
| 1980 | 1983 |
for(i = 0; i < bitmap_size; i++) test = bs->dirty_bitmap[i]; |
| 1981 |
}
|
|
| 1984 |
}
|
|
| 1982 | 1985 |
} else {
|
| 1983 |
if(bs->dirty_tracking != 0) {
|
|
| 1986 |
if (bs->dirty_tracking != 0) {
|
|
| 1984 | 1987 |
qemu_free(bs->dirty_bitmap); |
| 1985 | 1988 |
bs->dirty_tracking = enable; |
| 1986 |
}
|
|
| 1989 |
}
|
|
| 1987 | 1990 |
} |
| 1988 | 1991 |
} |
| 1989 | 1992 |
|
| 1990 | 1993 |
int bdrv_get_dirty(BlockDriverState *bs, int64_t sector) |
| 1991 | 1994 |
{
|
| 1992 | 1995 |
int64_t chunk = sector / (int64_t)SECTORS_PER_DIRTY_CHUNK; |
| 1993 |
|
|
| 1994 |
if(bs->dirty_bitmap != NULL &&
|
|
| 1995 |
(sector << SECTOR_BITS) <= bdrv_getlength(bs)) {
|
|
| 1996 |
|
|
| 1997 |
if (bs->dirty_bitmap != NULL &&
|
|
| 1998 |
(sector << SECTOR_BITS) <= bdrv_getlength(bs)) {
|
|
| 1996 | 1999 |
return bs->dirty_bitmap[chunk]; |
| 1997 | 2000 |
} else {
|
| 1998 | 2001 |
return 0; |
| 1999 | 2002 |
} |
| 2000 | 2003 |
} |
| 2001 | 2004 |
|
| 2002 |
void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector,
|
|
| 2003 |
int nr_sectors)
|
|
| 2005 |
void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector, |
|
| 2006 |
int nr_sectors)
|
|
| 2004 | 2007 |
{
|
| 2005 | 2008 |
set_dirty_bitmap(bs, cur_sector, nr_sectors, 0); |
| 2006 | 2009 |
} |
Also available in: Unified diff