Skip to content

Commit

Permalink
block migration: Rework constants API
Browse files Browse the repository at this point in the history 
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>
  • Loading branch information
@jan-kiszka
jan-kiszka authored and Anthony Liguori committed Dec 3, 2009
1 parent a55eb92 commit 6ea4430
Show file tree
Hide file tree
Showing 3 changed files with 58 additions and 72 deletions.
63 changes: 27 additions & 36 deletions block-migration.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -17,11 +17,7 @@
#include "block-migration.h"
#include <assert.h>

#define SECTOR_BITS 9
#define SECTOR_SIZE (1 << SECTOR_BITS)
#define SECTOR_MASK ~(SECTOR_SIZE - 1);

#define BLOCK_SIZE (block_mig_state->sectors_per_block << SECTOR_BITS)
#define BLOCK_SIZE (BDRV_SECTORS_PER_DIRTY_CHUNK << BDRV_SECTOR_BITS)

#define BLK_MIG_FLAG_DEVICE_BLOCK 0x01
#define BLK_MIG_FLAG_EOS 0x02
Expand Down Expand Up @@ -69,7 +65,6 @@ typedef struct BlkMigState {
int no_dirty;
QEMUFile *load_file;
BlkMigDevState *bmds_first;
int sectors_per_block;
BlkMigBlock *first_blk;
BlkMigBlock *last_blk;
int submitted;
Expand Down Expand Up @@ -111,7 +106,7 @@ static int mig_read_device_bulk(QEMUFile *f, BlkMigDevState *bms)
blk->buf = qemu_malloc(BLOCK_SIZE);

cur_sector = bms->cur_sector;
total_sectors = bdrv_getlength(bs) >> SECTOR_BITS;
total_sectors = bdrv_getlength(bs) >> BDRV_SECTOR_BITS;

if (bms->shared_base) {
while (cur_sector < bms->total_sectors &&
Expand All @@ -132,15 +127,15 @@ static int mig_read_device_bulk(QEMUFile *f, BlkMigDevState *bms)
printf("Completed %" PRId64 " %%\r", cur_sector * 100 / total_sectors);
fflush(stdout);
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 */
nr_sectors = block_mig_state->sectors_per_block;
/* we are going to transfer a full block even if it is not allocated */
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);
}

Expand All @@ -150,7 +145,7 @@ static int mig_read_device_bulk(QEMUFile *f, BlkMigDevState *bms)
blk->next = NULL;

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);

blk->aiocb = bdrv_aio_readv(bs, cur_sector, &blk->qiov,
Expand Down Expand Up @@ -198,15 +193,15 @@ static int mig_save_device_bulk(QEMUFile *f, BlkMigDevState *bmds)
printf("Completed %" PRId64 " %%\r", cur_sector * 100 / total_sectors);
fflush(stdout);
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 */
nr_sectors = block_mig_state->sectors_per_block;
/* we are going to transfer a full block even if it is not allocated */
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);
}

Expand All @@ -217,7 +212,8 @@ static int mig_save_device_bulk(QEMUFile *f, BlkMigDevState *bmds)
bdrv_reset_dirty(bs, cur_sector, nr_sectors);

/* 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 */
len = strlen(bs->device_name);
Expand All @@ -226,7 +222,7 @@ static int mig_save_device_bulk(QEMUFile *f, BlkMigDevState *bmds)

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);

Expand All @@ -238,7 +234,8 @@ static void send_blk(QEMUFile *f, BlkMigBlock * blk)
int len;

/* 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 */
len = strlen(blk->bmds->bs->device_name);
Expand Down Expand Up @@ -270,7 +267,7 @@ static void init_blk_migration(QEMUFile *f)
bmds = qemu_mallocz(sizeof(BlkMigDevState));
bmds->bs = bs;
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;

if (bmds->shared_base) {
Expand All @@ -290,8 +287,6 @@ static void init_blk_migration(QEMUFile *f)
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)
Expand Down Expand Up @@ -334,27 +329,25 @@ static void blk_mig_save_dirty_blocks(QEMUFile *f)
for (sector = 0; sector < bmds->cur_sector;) {
if (bdrv_get_dirty(bmds->bs, sector)) {
if (bdrv_read(bmds->bs, sector, buf,
block_mig_state->sectors_per_block) < 0) {
BDRV_SECTORS_PER_DIRTY_CHUNK) < 0) {
/* FIXME: add error handling */
}

/* sector number and flags */
qemu_put_be64(f, (sector << SECTOR_BITS)
qemu_put_be64(f, (sector << BDRV_SECTOR_BITS)
| BLK_MIG_FLAG_DEVICE_BLOCK);

/* device name */
len = strlen(bmds->bs->device_name);
qemu_put_byte(f, len);
qemu_put_buffer(f, (uint8_t *)bmds->bs->device_name, len);

qemu_put_buffer(f, buf,
(block_mig_state->sectors_per_block *
SECTOR_SIZE));
qemu_put_buffer(f, buf, BLOCK_SIZE);

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;
}
}
}
Expand Down Expand Up @@ -465,14 +458,13 @@ static int block_load(QEMUFile *f, void *opaque, int version_id)
BlockDriverState *bs;
uint8_t *buf;

block_mig_state->sectors_per_block = bdrv_get_sectors_per_chunk();
buf = qemu_malloc(BLOCK_SIZE);

do {
addr = qemu_get_be64(f);

flags = addr & ~SECTOR_MASK;
addr &= SECTOR_MASK;
flags = addr & ~BDRV_SECTOR_MASK;
addr >>= BDRV_SECTOR_BITS;

if (flags & BLK_MIG_FLAG_DEVICE_BLOCK) {
/* get device name */
Expand All @@ -485,8 +477,7 @@ static int block_load(QEMUFile *f, void *opaque, int version_id)

qemu_get_buffer(f, buf, BLOCK_SIZE);
if (bs != NULL) {
bdrv_write(bs, (addr >> SECTOR_BITS),
buf, block_mig_state->sectors_per_block);
bdrv_write(bs, addr, buf, BDRV_SECTORS_PER_DIRTY_CHUNK);
} else {
printf("Error unknown block device %s\n", device_name);
/* FIXME: add error handling */
Expand Down
60 changes: 25 additions & 35 deletions block.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -41,10 +41,6 @@
#include <windows.h>
#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,
int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
BlockDriverCompletionFunc *cb, void *opaque);
Expand Down Expand Up @@ -386,7 +382,7 @@ int bdrv_open2(BlockDriverState *bs, const char *filename, int flags,
bdrv_delete(bs1);
return ret;
}
total_size = bdrv_getlength(bs1) >> SECTOR_BITS;
total_size = bdrv_getlength(bs1) >> BDRV_SECTOR_BITS;

if (bs1->drv && bs1->drv->protocol_name)
is_protocol = 1;
Expand Down Expand Up @@ -473,7 +469,7 @@ int bdrv_open2(BlockDriverState *bs, const char *filename, int flags,
return ret;
}
if (drv->bdrv_getlength) {
bs->total_sectors = bdrv_getlength(bs) >> SECTOR_BITS;
bs->total_sectors = bdrv_getlength(bs) >> BDRV_SECTOR_BITS;
}
#ifndef _WIN32
if (bs->is_temporary) {
Expand Down Expand Up @@ -576,7 +572,7 @@ int bdrv_commit(BlockDriverState *bs)
return -ENOTSUP;
}

total_sectors = bdrv_getlength(bs) >> SECTOR_BITS;
total_sectors = bdrv_getlength(bs) >> BDRV_SECTOR_BITS;
for (i = 0; i < total_sectors;) {
if (drv->bdrv_is_allocated(bs, i, 65536, &n)) {
for(j = 0; j < n; j++) {
Expand Down Expand Up @@ -647,8 +643,8 @@ static void set_dirty_bitmap(BlockDriverState *bs, int64_t sector_num,
{
int64_t start, end;

start = sector_num / SECTORS_PER_DIRTY_CHUNK;
end = (sector_num + nb_sectors) / SECTORS_PER_DIRTY_CHUNK;
start = sector_num / BDRV_SECTORS_PER_DIRTY_CHUNK;
end = (sector_num + nb_sectors) / BDRV_SECTORS_PER_DIRTY_CHUNK;

for (; start <= end; start++) {
bs->dirty_bitmap[start] = dirty;
Expand Down Expand Up @@ -682,20 +678,20 @@ int bdrv_write(BlockDriverState *bs, int64_t sector_num,
int bdrv_pread(BlockDriverState *bs, int64_t offset,
void *buf, int count1)
{
uint8_t tmp_buf[SECTOR_SIZE];
uint8_t tmp_buf[BDRV_SECTOR_SIZE];
int len, nb_sectors, count;
int64_t sector_num;

count = count1;
/* 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)
len = count;
sector_num = offset >> SECTOR_BITS;
sector_num = offset >> BDRV_SECTOR_BITS;
if (len > 0) {
if (bdrv_read(bs, sector_num, tmp_buf, 1) < 0)
return -EIO;
memcpy(buf, tmp_buf + (offset & (SECTOR_SIZE - 1)), len);
memcpy(buf, tmp_buf + (offset & (BDRV_SECTOR_SIZE - 1)), len);
count -= len;
if (count == 0)
return count1;
Expand All @@ -704,12 +700,12 @@ int bdrv_pread(BlockDriverState *bs, int64_t offset,
}

/* read the sectors "in place" */
nb_sectors = count >> SECTOR_BITS;
nb_sectors = count >> BDRV_SECTOR_BITS;
if (nb_sectors > 0) {
if (bdrv_read(bs, sector_num, buf, nb_sectors) < 0)
return -EIO;
sector_num += nb_sectors;
len = nb_sectors << SECTOR_BITS;
len = nb_sectors << BDRV_SECTOR_BITS;
buf += len;
count -= len;
}
Expand All @@ -726,20 +722,20 @@ int bdrv_pread(BlockDriverState *bs, int64_t offset,
int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
const void *buf, int count1)
{
uint8_t tmp_buf[SECTOR_SIZE];
uint8_t tmp_buf[BDRV_SECTOR_SIZE];
int len, nb_sectors, count;
int64_t sector_num;

count = count1;
/* 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)
len = count;
sector_num = offset >> SECTOR_BITS;
sector_num = offset >> BDRV_SECTOR_BITS;
if (len > 0) {
if (bdrv_read(bs, sector_num, tmp_buf, 1) < 0)
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)
return -EIO;
count -= len;
Expand All @@ -750,12 +746,12 @@ int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
}

/* write the sectors "in place" */
nb_sectors = count >> SECTOR_BITS;
nb_sectors = count >> BDRV_SECTOR_BITS;
if (nb_sectors > 0) {
if (bdrv_write(bs, sector_num, buf, nb_sectors) < 0)
return -EIO;
sector_num += nb_sectors;
len = nb_sectors << SECTOR_BITS;
len = nb_sectors << BDRV_SECTOR_BITS;
buf += len;
count -= len;
}
Expand Down Expand Up @@ -796,7 +792,7 @@ int64_t bdrv_getlength(BlockDriverState *bs)
return -ENOMEDIUM;
if (!drv->bdrv_getlength) {
/* legacy mode */
return bs->total_sectors * SECTOR_SIZE;
return bs->total_sectors * BDRV_SECTOR_SIZE;
}
return drv->bdrv_getlength(bs);
}
Expand All @@ -809,7 +805,7 @@ void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
if (length < 0)
length = 0;
else
length = length >> SECTOR_BITS;
length = length >> BDRV_SECTOR_BITS;
*nb_sectors_ptr = length;
}

Expand Down Expand Up @@ -1402,7 +1398,7 @@ BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,

if (ret) {
/* 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 ++;
}

Expand Down Expand Up @@ -1432,7 +1428,7 @@ BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,

if (ret) {
/* 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 ++;
}

Expand Down Expand Up @@ -1973,8 +1969,8 @@ void bdrv_set_dirty_tracking(BlockDriverState *bs, int enable)
int64_t i;
uint8_t test;

bitmap_size = (bdrv_getlength(bs) >> SECTOR_BITS);
bitmap_size /= SECTORS_PER_DIRTY_CHUNK;
bitmap_size = (bdrv_getlength(bs) >> BDRV_SECTOR_BITS);
bitmap_size /= BDRV_SECTORS_PER_DIRTY_CHUNK;
bitmap_size++;

bs->dirty_bitmap = qemu_mallocz(bitmap_size);
Expand All @@ -1992,10 +1988,10 @@ void bdrv_set_dirty_tracking(BlockDriverState *bs, int enable)

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 &&
(sector << SECTOR_BITS) <= bdrv_getlength(bs)) {
(sector << BDRV_SECTOR_BITS) <= bdrv_getlength(bs)) {
return bs->dirty_bitmap[chunk];
} else {
return 0;
Expand All @@ -2007,9 +2003,3 @@ void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector,
{
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;
}
Loading

0 comments on commit 6ea4430

Please sign in to comment.