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: block_copy(): add timeout_ns parameter

Browse source 
Add possibility to limit block_copy() call in time. To be used in the
next commit.

As timed-out block_copy() call will continue in background anyway (we
can't immediately cancel IO operation), it's important also give user a
possibility to pass a callback, to do some additional actions on
block-copy call finish.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@openvz.org>
Reviewed-by: Hanna Reitz <hreitz@redhat.com>
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
This commit is contained in:
Vladimir Sementsov-Ogievskiy 2022-04-07 16:27:24 +03:00 • committed by Vladimir Sementsov-Ogievskiy
parent e1878eb5f0
commit 15df6e6987
3 changed files with 31 additions and 10 deletions
Download patch file Download diff file Expand all files Collapse all files

35
block/block-copy.c
View file

@ -883,23 +883,42 @@ static int coroutine_fn block_copy_common(BlockCopyCallState *call_state)
return ret; return ret;
} }
int coroutine_fn block_copy(BlockCopyState *s, int64_t start, int64_t bytes, static void coroutine_fn block_copy_async_co_entry(void *opaque)
bool ignore_ratelimit)
{ {
BlockCopyCallState call_state = { block_copy_common(opaque);
}
int coroutine_fn block_copy(BlockCopyState *s, int64_t start, int64_t bytes,
bool ignore_ratelimit, uint64_t timeout_ns,
BlockCopyAsyncCallbackFunc cb,
void *cb_opaque)
{
int ret;
BlockCopyCallState *call_state = g_new(BlockCopyCallState, 1);
*call_state = (BlockCopyCallState) {
.s = s, .s = s,
.offset = start, .offset = start,
.bytes = bytes, .bytes = bytes,
.ignore_ratelimit = ignore_ratelimit, .ignore_ratelimit = ignore_ratelimit,
.max_workers = BLOCK_COPY_MAX_WORKERS, .max_workers = BLOCK_COPY_MAX_WORKERS,
.cb = cb,
.cb_opaque = cb_opaque,
}; };
return block_copy_common(&call_state); ret = qemu_co_timeout(block_copy_async_co_entry, call_state, timeout_ns,
} g_free);
if (ret < 0) {
assert(ret == -ETIMEDOUT);
block_copy_call_cancel(call_state);
/* call_state will be freed by running coroutine. */
return ret;
}
static void coroutine_fn block_copy_async_co_entry(void *opaque) ret = call_state->ret;
{ g_free(call_state);
block_copy_common(opaque);
return ret;
} }
BlockCopyCallState *block_copy_async(BlockCopyState *s, BlockCopyCallState *block_copy_async(BlockCopyState *s,

2
block/copy-before-write.c
View file

@ -111,7 +111,7 @@ static coroutine_fn int cbw_do_copy_before_write(BlockDriverState *bs,
off = QEMU_ALIGN_DOWN(offset, cluster_size); off = QEMU_ALIGN_DOWN(offset, cluster_size);
end = QEMU_ALIGN_UP(offset + bytes, cluster_size); end = QEMU_ALIGN_UP(offset + bytes, cluster_size);
ret = block_copy(s->bcs, off, end - off, true); ret = block_copy(s->bcs, off, end - off, true, 0, NULL, NULL);
if (ret < 0 && s->on_cbw_error == ON_CBW_ERROR_BREAK_GUEST_WRITE) { if (ret < 0 && s->on_cbw_error == ON_CBW_ERROR_BREAK_GUEST_WRITE) {
return ret; return ret;
} }

4
include/block/block-copy.h
View file

@ -40,7 +40,9 @@ int64_t block_copy_reset_unallocated(BlockCopyState *s,
int64_t offset, int64_t *count); int64_t offset, int64_t *count);
int coroutine_fn block_copy(BlockCopyState *s, int64_t offset, int64_t bytes, int coroutine_fn block_copy(BlockCopyState *s, int64_t offset, int64_t bytes,
bool ignore_ratelimit); bool ignore_ratelimit, uint64_t timeout_ns,
BlockCopyAsyncCallbackFunc cb,
void *cb_opaque);
/* /*
* Run block-copy in a coroutine, create corresponding BlockCopyCallState * Run block-copy in a coroutine, create corresponding BlockCopyCallState