ShuriZma
/
xemu
mirror of https://github.com/xemu-project/xemu.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

block: intoduce reqlist 

Split intersecting-requests functionality out of block-copy to be
reused in copy-before-write filter.

Note: while being here, fix tiny typo in MAINTAINERS.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Hanna Reitz <hreitz@redhat.com>
Message-Id: <20220303194349.2304213-7-vsementsov@virtuozzo.com>
Signed-off-by: Hanna Reitz <hreitz@redhat.com>
This commit is contained in:
Vladimir Sementsov-Ogievskiy 2022-03-03 20:43:39 +01:00 committed by Hanna Reitz
parent 177541e671
commit d088e6a48a
5 changed files with 184 additions and 80 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
MAINTAINERS
View File

@ -2515,7 +2515,9 @@ F: block/stream.c
F: block/mirror.c
F: qapi/job.json
F: block/block-copy.c
F: include/block/block-copy.c
F: include/block/block-copy.h
F: block/reqlist.c
F: include/block/reqlist.h
F: block/copy-before-write.h
F: block/copy-before-write.c
F: include/block/aio_task.h

116
block/block-copy.c
View File

@ -17,6 +17,7 @@
#include "trace.h"
#include "qapi/error.h"
#include "block/block-copy.h"
#include "block/reqlist.h"
#include "sysemu/block-backend.h"
#include "qemu/units.h"
#include "qemu/coroutine.h"
@ -83,7 +84,6 @@ typedef struct BlockCopyTask {
*/
BlockCopyState *s;
BlockCopyCallState *call_state;
int64_t offset;
/*
* @method can also be set again in the while loop of
* block_copy_dirty_clusters(), but it is never accessed concurrently
@ -94,21 +94,17 @@ typedef struct BlockCopyTask {
BlockCopyMethod method;
/*
* Fields whose state changes throughout the execution
* Protected by lock in BlockCopyState.
* Generally, req is protected by lock in BlockCopyState, Still req.offset
* is only set on task creation, so may be read concurrently after creation.
* req.bytes is changed at most once, and need only protecting the case of
* parallel read while updating @bytes value in block_copy_task_shrink().
*/
CoQueue wait_queue; /* coroutines blocked on this task */
/*
* Only protect the case of parallel read while updating @bytes
* value in block_copy_task_shrink().
*/
int64_t bytes;
QLIST_ENTRY(BlockCopyTask) list;
BlockReq req;
} BlockCopyTask;
static int64_t task_end(BlockCopyTask *task)
{
return task->offset + task->bytes;
return task->req.offset + task->req.bytes;
}
typedef struct BlockCopyState {
@ -136,7 +132,7 @@ typedef struct BlockCopyState {
CoMutex lock;
int64_t in_flight_bytes;
BlockCopyMethod method;
QLIST_HEAD(, BlockCopyTask) tasks; /* All tasks from all block-copy calls */
BlockReqList reqs;
QLIST_HEAD(, BlockCopyCallState) calls;
/*
* skip_unallocated:
@ -160,42 +156,6 @@ typedef struct BlockCopyState {
RateLimit rate_limit;
} BlockCopyState;
/* Called with lock held */
static BlockCopyTask *find_conflicting_task(BlockCopyState *s,
int64_t offset, int64_t bytes)
{
BlockCopyTask *t;
QLIST_FOREACH(t, &s->tasks, list) {
if (offset + bytes > t->offset && offset < t->offset + t->bytes) {
return t;
}
}
return NULL;
}
/*
* If there are no intersecting tasks return false. Otherwise, wait for the
* first found intersecting tasks to finish and return true.
*
* Called with lock held. May temporary release the lock.
* Return value of 0 proves that lock was NOT released.
*/
static bool coroutine_fn block_copy_wait_one(BlockCopyState *s, int64_t offset,
int64_t bytes)
{
BlockCopyTask *task = find_conflicting_task(s, offset, bytes);
if (!task) {
return false;
}
qemu_co_queue_wait(&task->wait_queue, &s->lock);
return true;
}
/* Called with lock held */
static int64_t block_copy_chunk_size(BlockCopyState *s)
{
@ -239,7 +199,7 @@ block_copy_task_create(BlockCopyState *s, BlockCopyCallState *call_state,
bytes = QEMU_ALIGN_UP(bytes, s->cluster_size);
/* region is dirty, so no existent tasks possible in it */
assert(!find_conflicting_task(s, offset, bytes));
assert(!reqlist_find_conflict(&s->reqs, offset, bytes));
bdrv_reset_dirty_bitmap(s->copy_bitmap, offset, bytes);
s->in_flight_bytes += bytes;
@ -249,12 +209,9 @@ block_copy_task_create(BlockCopyState *s, BlockCopyCallState *call_state,
.task.func = block_copy_task_entry,
.s = s,
.call_state = call_state,
.offset = offset,
.bytes = bytes,
.method = s->method,
};
qemu_co_queue_init(&task->wait_queue);
QLIST_INSERT_HEAD(&s->tasks, task, list);
reqlist_init_req(&s->reqs, &task->req, offset, bytes);
return task;
}
@ -270,34 +227,34 @@ static void coroutine_fn block_copy_task_shrink(BlockCopyTask *task,
int64_t new_bytes)
{
QEMU_LOCK_GUARD(&task->s->lock);
if (new_bytes == task->bytes) {
if (new_bytes == task->req.bytes) {
return;
}
assert(new_bytes > 0 && new_bytes < task->bytes);
assert(new_bytes > 0 && new_bytes < task->req.bytes);
task->s->in_flight_bytes -= task->bytes - new_bytes;
task->s->in_flight_bytes -= task->req.bytes - new_bytes;
bdrv_set_dirty_bitmap(task->s->copy_bitmap,
task->offset + new_bytes, task->bytes - new_bytes);
task->req.offset + new_bytes,
task->req.bytes - new_bytes);
task->bytes = new_bytes;
qemu_co_queue_restart_all(&task->wait_queue);
reqlist_shrink_req(&task->req, new_bytes);
}
static void coroutine_fn block_copy_task_end(BlockCopyTask *task, int ret)
{
QEMU_LOCK_GUARD(&task->s->lock);
task->s->in_flight_bytes -= task->bytes;
task->s->in_flight_bytes -= task->req.bytes;
if (ret < 0) {
bdrv_set_dirty_bitmap(task->s->copy_bitmap, task->offset, task->bytes);
bdrv_set_dirty_bitmap(task->s->copy_bitmap, task->req.offset,
task->req.bytes);
}
QLIST_REMOVE(task, list);
if (task->s->progress) {
progress_set_remaining(task->s->progress,
bdrv_get_dirty_count(task->s->copy_bitmap) +
task->s->in_flight_bytes);
}
qemu_co_queue_restart_all(&task->wait_queue);
reqlist_remove_req(&task->req);
}
void block_copy_state_free(BlockCopyState *s)
@ -450,7 +407,7 @@ BlockCopyState *block_copy_state_new(BdrvChild *source, BdrvChild *target,
ratelimit_init(&s->rate_limit);
qemu_co_mutex_init(&s->lock);
QLIST_INIT(&s->tasks);
QLIST_INIT(&s->reqs);
QLIST_INIT(&s->calls);
return s;
@ -483,7 +440,7 @@ static coroutine_fn int block_copy_task_run(AioTaskPool *pool,
aio_task_pool_wait_slot(pool);
if (aio_task_pool_status(pool) < 0) {
co_put_to_shres(task->s->mem, task->bytes);
co_put_to_shres(task->s->mem, task->req.bytes);
block_copy_task_end(task, -ECANCELED);
g_free(task);
return -ECANCELED;
@ -596,7 +553,8 @@ static coroutine_fn int block_copy_task_entry(AioTask *task)
BlockCopyMethod method = t->method;
int ret;
ret = block_copy_do_copy(s, t->offset, t->bytes, &method, &error_is_read);
ret = block_copy_do_copy(s, t->req.offset, t->req.bytes, &method,
&error_is_read);
WITH_QEMU_LOCK_GUARD(&s->lock) {
if (s->method == t->method) {
@ -609,10 +567,10 @@ static coroutine_fn int block_copy_task_entry(AioTask *task)
t->call_state->error_is_read = error_is_read;
}
} else if (s->progress) {
progress_work_done(s->progress, t->bytes);
progress_work_done(s->progress, t->req.bytes);
}
}
co_put_to_shres(s->mem, t->bytes);
co_put_to_shres(s->mem, t->req.bytes);
block_copy_task_end(t, ret);
return ret;
@ -771,22 +729,22 @@ block_copy_dirty_clusters(BlockCopyCallState *call_state)
trace_block_copy_skip_range(s, offset, bytes);
break;
}
if (task->offset > offset) {
trace_block_copy_skip_range(s, offset, task->offset - offset);
if (task->req.offset > offset) {
trace_block_copy_skip_range(s, offset, task->req.offset - offset);
}
found_dirty = true;
ret = block_copy_block_status(s, task->offset, task->bytes,
ret = block_copy_block_status(s, task->req.offset, task->req.bytes,
&status_bytes);
assert(ret >= 0); /* never fail */
if (status_bytes < task->bytes) {
if (status_bytes < task->req.bytes) {
block_copy_task_shrink(task, status_bytes);
}
if (qatomic_read(&s->skip_unallocated) &&
!(ret & BDRV_BLOCK_ALLOCATED)) {
block_copy_task_end(task, 0);
trace_block_copy_skip_range(s, task->offset, task->bytes);
trace_block_copy_skip_range(s, task->req.offset, task->req.bytes);
offset = task_end(task);
bytes = end - offset;
g_free(task);
@ -807,11 +765,11 @@ block_copy_dirty_clusters(BlockCopyCallState *call_state)
}
}
ratelimit_calculate_delay(&s->rate_limit, task->bytes);
ratelimit_calculate_delay(&s->rate_limit, task->req.bytes);
trace_block_copy_process(s, task->offset);
trace_block_copy_process(s, task->req.offset);
co_get_from_shres(s->mem, task->bytes);
co_get_from_shres(s->mem, task->req.bytes);
offset = task_end(task);
bytes = end - offset;
@ -879,8 +837,8 @@ static int coroutine_fn block_copy_common(BlockCopyCallState *call_state)
* Check that there is no task we still need to
* wait to complete
*/
ret = block_copy_wait_one(s, call_state->offset,
call_state->bytes);
ret = reqlist_wait_one(&s->reqs, call_state->offset,
call_state->bytes, &s->lock);
if (ret == 0) {
/*
* No pending tasks, but check again the bitmap in this
@ -888,7 +846,7 @@ static int coroutine_fn block_copy_common(BlockCopyCallState *call_state)
* between this and the critical section in
* block_copy_dirty_clusters().
*
* block_copy_wait_one return value 0 also means that it
* reqlist_wait_one return value 0 also means that it
* didn't release the lock. So, we are still in the same
* critical section, not interrupted by any concurrent
* access to state.

1
block/meson.build
View File

@ -32,6 +32,7 @@ block_ss.add(files(
'qcow2.c',
'quorum.c',
'raw-format.c',
'reqlist.c',
'snapshot.c',
'throttle-groups.c',
'throttle.c',

76
block/reqlist.c Normal file
View File

@ -0,0 +1,76 @@
/*
* reqlist API
*
* Copyright (C) 2013 Proxmox Server Solutions
* Copyright (c) 2021 Virtuozzo International GmbH.
*
* Authors:
* Dietmar Maurer (dietmar@proxmox.com)
* Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
*
* This work is licensed under the terms of the GNU GPL, version 2 or later.
* See the COPYING file in the top-level directory.
*/
#include "qemu/osdep.h"
#include "block/reqlist.h"
void reqlist_init_req(BlockReqList *reqs, BlockReq *req, int64_t offset,
int64_t bytes)
{
assert(!reqlist_find_conflict(reqs, offset, bytes));
*req = (BlockReq) {
.offset = offset,
.bytes = bytes,
};
qemu_co_queue_init(&req->wait_queue);
QLIST_INSERT_HEAD(reqs, req, list);
}
BlockReq *reqlist_find_conflict(BlockReqList *reqs, int64_t offset,
int64_t bytes)
{
BlockReq *r;
QLIST_FOREACH(r, reqs, list) {
if (offset + bytes > r->offset && offset < r->offset + r->bytes) {
return r;
}
}
return NULL;
}
bool coroutine_fn reqlist_wait_one(BlockReqList *reqs, int64_t offset,
int64_t bytes, CoMutex *lock)
{
BlockReq *r = reqlist_find_conflict(reqs, offset, bytes);
if (!r) {
return false;
}
qemu_co_queue_wait(&r->wait_queue, lock);
return true;
}
void coroutine_fn reqlist_shrink_req(BlockReq *req, int64_t new_bytes)
{
if (new_bytes == req->bytes) {
return;
}
assert(new_bytes > 0 && new_bytes < req->bytes);
req->bytes = new_bytes;
qemu_co_queue_restart_all(&req->wait_queue);
}
void coroutine_fn reqlist_remove_req(BlockReq *req)
{
QLIST_REMOVE(req, list);
qemu_co_queue_restart_all(&req->wait_queue);
}

67
include/block/reqlist.h Normal file
View File

@ -0,0 +1,67 @@
/*
* reqlist API
*
* Copyright (C) 2013 Proxmox Server Solutions
* Copyright (c) 2021 Virtuozzo International GmbH.
*
* Authors:
* Dietmar Maurer (dietmar@proxmox.com)
* Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
*
* This work is licensed under the terms of the GNU GPL, version 2 or later.
* See the COPYING file in the top-level directory.
*/
#ifndef REQLIST_H
#define REQLIST_H
#include "qemu/coroutine.h"
/*
* The API is not thread-safe and shouldn't be. The struct is public to be part
* of other structures and protected by third-party locks, see
* block/block-copy.c for example.
*/
typedef struct BlockReq {
int64_t offset;
int64_t bytes;
CoQueue wait_queue; /* coroutines blocked on this req */
QLIST_ENTRY(BlockReq) list;
} BlockReq;
typedef QLIST_HEAD(, BlockReq) BlockReqList;
/*
* Initialize new request and add it to the list. Caller must be sure that
* there are no conflicting requests in the list.
*/
void reqlist_init_req(BlockReqList *reqs, BlockReq *req, int64_t offset,
int64_t bytes);
/* Search for request in the list intersecting with @offset/@bytes area. */
BlockReq *reqlist_find_conflict(BlockReqList *reqs, int64_t offset,
int64_t bytes);
/*
* If there are no intersecting requests return false. Otherwise, wait for the
* first found intersecting request to finish and return true.
*
* @lock is passed to qemu_co_queue_wait()
* False return value proves that lock was released at no point.
*/
bool coroutine_fn reqlist_wait_one(BlockReqList *reqs, int64_t offset,
int64_t bytes, CoMutex *lock);
/*
* Shrink request and wake all waiting coroutines (maybe some of them are not
* intersecting with shrunk request).
*/
void coroutine_fn reqlist_shrink_req(BlockReq *req, int64_t new_bytes);
/*
* Remove request and wake all waiting coroutines. Do not release any memory.
*/
void coroutine_fn reqlist_remove_req(BlockReq *req);
#endif /* REQLIST_H */