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

block/block-copy: allocate buffer in block_copy_with_bounce_buffer

Browse source 
Move bounce_buffer allocation block_copy_with_bounce_buffer. This
commit simplifies further work on implementing copying by larger chunks
(of different size) and further asynchronous handling of block_copy
iterations (with help of block/aio_task API).

Allocation works fast, a lot faster than disk io, so it's not a problem
that we now allocate/free bounce_buffer more times. And we anyway will
have to allocate several bounce_buffers for parallel execution of loop
iterations in future.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Message-id: 20191022111805.3432-2-vsementsov@virtuozzo.com
Signed-off-by: Max Reitz <mreitz@redhat.com>
This commit is contained in:
Vladimir Sementsov-Ogievskiy 2019-10-22 14:18:00 +03:00 • committed by Max Reitz
parent ecc47cb47c
commit 3816edd2cb
1 changed files with 8 additions and 13 deletions
Download patch file Download diff file Expand all files Collapse all files

21
block/block-copy.c
View file

@ -126,20 +126,17 @@ void block_copy_set_callbacks(
static int coroutine_fn block_copy_with_bounce_buffer(BlockCopyState *s, static int coroutine_fn block_copy_with_bounce_buffer(BlockCopyState *s,
int64_t start, int64_t start,
int64_t end, int64_t end,
bool *error_is_read, bool *error_is_read)
void **bounce_buffer)
{ {
int ret; int ret;
int nbytes; int nbytes;
void *bounce_buffer = qemu_blockalign(s->source->bs, s->cluster_size);
assert(QEMU_IS_ALIGNED(start, s->cluster_size)); assert(QEMU_IS_ALIGNED(start, s->cluster_size));
bdrv_reset_dirty_bitmap(s->copy_bitmap, start, s->cluster_size); bdrv_reset_dirty_bitmap(s->copy_bitmap, start, s->cluster_size);
nbytes = MIN(s->cluster_size, s->len - start); nbytes = MIN(s->cluster_size, s->len - start);
if (!*bounce_buffer) {
*bounce_buffer = qemu_blockalign(s->source->bs, s->cluster_size);
}
ret = bdrv_co_pread(s->source, start, nbytes, *bounce_buffer, 0); ret = bdrv_co_pread(s->source, start, nbytes, bounce_buffer, 0);
if (ret < 0) { if (ret < 0) {
trace_block_copy_with_bounce_buffer_read_fail(s, start, ret); trace_block_copy_with_bounce_buffer_read_fail(s, start, ret);
if (error_is_read) { if (error_is_read) {
@ -148,7 +145,7 @@ static int coroutine_fn block_copy_with_bounce_buffer(BlockCopyState *s,
goto fail; goto fail;
} }
ret = bdrv_co_pwrite(s->target, start, nbytes, *bounce_buffer, ret = bdrv_co_pwrite(s->target, start, nbytes, bounce_buffer,
s->write_flags); s->write_flags);
if (ret < 0) { if (ret < 0) {
trace_block_copy_with_bounce_buffer_write_fail(s, start, ret); trace_block_copy_with_bounce_buffer_write_fail(s, start, ret);
@ -158,8 +155,11 @@ static int coroutine_fn block_copy_with_bounce_buffer(BlockCopyState *s,
goto fail; goto fail;
} }
qemu_vfree(bounce_buffer);
return nbytes; return nbytes;
fail: fail:
qemu_vfree(bounce_buffer);
bdrv_set_dirty_bitmap(s->copy_bitmap, start, s->cluster_size); bdrv_set_dirty_bitmap(s->copy_bitmap, start, s->cluster_size);
return ret; return ret;
@ -271,7 +271,6 @@ int coroutine_fn block_copy(BlockCopyState *s,
{ {
int ret = 0; int ret = 0;
int64_t end = bytes + start; /* bytes */ int64_t end = bytes + start; /* bytes */
void *bounce_buffer = NULL;
int64_t status_bytes; int64_t status_bytes;
BlockCopyInFlightReq req; BlockCopyInFlightReq req;
@ -324,7 +323,7 @@ int coroutine_fn block_copy(BlockCopyState *s,
} }
if (!s->use_copy_range) { if (!s->use_copy_range) {
ret = block_copy_with_bounce_buffer(s, start, dirty_end, ret = block_copy_with_bounce_buffer(s, start, dirty_end,
error_is_read, &bounce_buffer); error_is_read);
} }
if (ret < 0) { if (ret < 0) {
break; break;
@ -335,10 +334,6 @@ int coroutine_fn block_copy(BlockCopyState *s,
ret = 0; ret = 0;
} }
if (bounce_buffer) {
qemu_vfree(bounce_buffer);
}
block_copy_inflight_req_end(&req); block_copy_inflight_req_end(&req);
return ret; return ret;