motorhead/qemu
1
0
Fork 0
mirror of https://github.com/Motorhead1991/qemu.git synced 2025-08-11 03:24:58 -06:00
Code Issues Projects Releases Packages Wiki Activity Actions

vpc: Implement .bdrv_co_pwritev() interface

Browse source 
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
This commit is contained in:
Kevin Wolf 2016-04-26 16:24:46 +02:00
parent d46b7cc680
commit 513b0f026b
1 changed files with 49 additions and 49 deletions
Download patch file Download diff file Expand all files Collapse all files

98
block/vpc.c
View file

@ -518,7 +518,7 @@ static int rewrite_footer(BlockDriverState* bs)
* *
* Returns the sectors' offset in the image file on success and < 0 on error * Returns the sectors' offset in the image file on success and < 0 on error
*/ */
static int64_t alloc_block(BlockDriverState* bs, int64_t sector_num) static int64_t alloc_block(BlockDriverState* bs, int64_t offset)
{ {
BDRVVPCState *s = bs->opaque; BDRVVPCState *s = bs->opaque;
int64_t bat_offset; int64_t bat_offset;
@ -527,14 +527,13 @@ static int64_t alloc_block(BlockDriverState* bs, int64_t sector_num)
uint8_t bitmap[s->bitmap_size]; uint8_t bitmap[s->bitmap_size];
/* Check if sector_num is valid */ /* Check if sector_num is valid */
if ((sector_num < 0) || (sector_num > bs->total_sectors)) if ((offset < 0) || (offset > bs->total_sectors * BDRV_SECTOR_SIZE)) {
return -1; return -EINVAL;
}
/* Write entry into in-memory BAT */ /* Write entry into in-memory BAT */
index = (sector_num * 512) / s->block_size; index = offset / s->block_size;
if (s->pagetable[index] != 0xFFFFFFFF) assert(s->pagetable[index] == 0xFFFFFFFF);
return -1;
s->pagetable[index] = s->free_data_block_offset / 512; s->pagetable[index] = s->free_data_block_offset / 512;
/* Initialize the block's bitmap */ /* Initialize the block's bitmap */
@ -558,11 +557,11 @@ static int64_t alloc_block(BlockDriverState* bs, int64_t sector_num)
if (ret < 0) if (ret < 0)
goto fail; goto fail;
return get_sector_offset(bs, sector_num, 0); return get_image_offset(bs, offset, false);
fail: fail:
s->free_data_block_offset -= (s->block_size + s->bitmap_size); s->free_data_block_offset -= (s->block_size + s->bitmap_size);
return -1; return ret;
} }
static int vpc_get_info(BlockDriverState *bs, BlockDriverInfo *bdi) static int vpc_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
@ -627,55 +626,56 @@ fail:
return ret; return ret;
} }
static int vpc_write(BlockDriverState *bs, int64_t sector_num, static int coroutine_fn
const uint8_t *buf, int nb_sectors) vpc_co_pwritev(BlockDriverState *bs, uint64_t offset, uint64_t bytes,
QEMUIOVector *qiov, int flags)
{ {
BDRVVPCState *s = bs->opaque; BDRVVPCState *s = bs->opaque;
int64_t offset; int64_t image_offset;
int64_t sectors, sectors_per_block; int64_t n_bytes;
int64_t bytes_done = 0;
int ret; int ret;
VHDFooter *footer = (VHDFooter *) s->footer_buf; VHDFooter *footer = (VHDFooter *) s->footer_buf;
QEMUIOVector local_qiov;
if (be32_to_cpu(footer->type) == VHD_FIXED) { if (be32_to_cpu(footer->type) == VHD_FIXED) {
return bdrv_write(bs->file->bs, sector_num, buf, nb_sectors); return bdrv_co_pwritev(bs->file->bs, offset, bytes, qiov, 0);
}
while (nb_sectors > 0) {
offset = get_sector_offset(bs, sector_num, 1);
sectors_per_block = s->block_size >> BDRV_SECTOR_BITS;
sectors = sectors_per_block - (sector_num % sectors_per_block);
if (sectors > nb_sectors) {
sectors = nb_sectors;
}
if (offset == -1) {
offset = alloc_block(bs, sector_num);
if (offset < 0)
return -1;
}
ret = bdrv_pwrite(bs->file->bs, offset, buf,
sectors * BDRV_SECTOR_SIZE);
if (ret != sectors * BDRV_SECTOR_SIZE) {
return -1;
}
nb_sectors -= sectors;
sector_num += sectors;
buf += sectors * BDRV_SECTOR_SIZE;
} }
return 0;
}
static coroutine_fn int vpc_co_write(BlockDriverState *bs, int64_t sector_num,
const uint8_t *buf, int nb_sectors)
{
int ret;
BDRVVPCState *s = bs->opaque;
qemu_co_mutex_lock(&s->lock); qemu_co_mutex_lock(&s->lock);
ret = vpc_write(bs, sector_num, buf, nb_sectors); qemu_iovec_init(&local_qiov, qiov->niov);
while (bytes > 0) {
image_offset = get_image_offset(bs, offset, true);
n_bytes = MIN(bytes, s->block_size - (offset % s->block_size));
if (image_offset == -1) {
image_offset = alloc_block(bs, offset);
if (image_offset < 0) {
ret = image_offset;
goto fail;
}
}
qemu_iovec_reset(&local_qiov);
qemu_iovec_concat(&local_qiov, qiov, bytes_done, n_bytes);
ret = bdrv_co_pwritev(bs->file->bs, image_offset, n_bytes,
&local_qiov, 0);
if (ret < 0) {
goto fail;
}
bytes -= n_bytes;
offset += n_bytes;
bytes_done += n_bytes;
}
ret = 0;
fail:
qemu_iovec_destroy(&local_qiov);
qemu_co_mutex_unlock(&s->lock); qemu_co_mutex_unlock(&s->lock);
return ret; return ret;
} }
@ -1062,7 +1062,7 @@ static BlockDriver bdrv_vpc = {
.bdrv_create = vpc_create, .bdrv_create = vpc_create,
.bdrv_co_preadv = vpc_co_preadv, .bdrv_co_preadv = vpc_co_preadv,
.bdrv_write = vpc_co_write, .bdrv_co_pwritev = vpc_co_pwritev,
.bdrv_co_get_block_status = vpc_co_get_block_status, .bdrv_co_get_block_status = vpc_co_get_block_status,
.bdrv_get_info = vpc_get_info, .bdrv_get_info = vpc_get_info,