backup performance: block_status + async
cover backup performance: block_status + async
Hi all!
These series does the following things:
1. bring block_status to block-copy, for efficient chunk sizes and handling ZERO clusters. (mirror does it)
2. bring aio-task-pool to block-copy, for parallel copying loop iteration. (mirror does it its own way)
4. add speed limit and cancelling possibility to block-copy (for 5.)
5. use block-copy in backup directly, to bring block_status and async. tasks into backup
6. add some python scripts to benchmark the results
The main theme is async handling of copying loop iterations, which already works and bring performance in mirror (in its own way) and in qcow2 (using aio-task-pool).
Here are the results:
---------- ------------- ----------------- ------------- ----------------- -------------
backup-old backup-old(no CR) backup-new backup-new(no CR) mirror
ssd -> ssd 9.88 +- 0.85 8.85 +- 0.48 5.39 +- 0.04 4.06 +- 0.01 4.15 +- 0.03
ssd -> hdd 10.90 +- 0.30 10.39 +- 0.41 9.36 +- 0.06 9.24 +- 0.06 9.00 +- 0.06
hdd -> hdd 20.09 +- 0.23 20.15 +- 0.07 48.65 +- 1.86 20.62 +- 0.08 19.82 +- 0.37
---------- ------------- ----------------- ------------- ----------------- ----------------------- ------------- ------------- -------------
backup-old backup-new mirror
nbd -> ssd 30.69 +- 0.23 9.02 +- 0.00 9.06 +- 0.03
ssd -> nbd 36.94 +- 0.01 11.50 +- 0.08 10.12 +- 0.05
---------- ------------- ------------- -------------Here:
"old" means "before series"
"new" means "after series"
"no CR" means "copy_range disabled"
nbd is nbd server on another node, running like "qemu-nbd --persistent --nocache -p 10810 ones1000M-source"
RFC.1
What I noticed, is that copy_range makes things worse.. Is there any case or benchmarking which shows that copy_range increases performance? Possibly we should disable it by default..
RFC.2
Last patch isn't for commit, possibly I should make some generic example, ideas are welcome
RFC.3
The series are big and splittable. The reason to send it alltogether is that I wanted to get the whole picture to benchmark.
Also, I keep in mind benchmarking backup to qcow2 with different levels of defragmentation and with/without compression.
Future plan is obvious: move block-commit and block-stream to use block-copy, which will unify code path and bring performance to commit and stream.
Vladimir Sementsov-Ogievskiy (24):
block/block-copy: specialcase first copy_range request block/block-copy: use block_status
block/block-copy: factor out block_copy_find_inflight_req block/block-copy: refactor interfaces to use bytes instead of end block/block-copy: rename start to offset in interfaces block/block-copy: reduce intersecting request lock block/block-copy: hide structure definitions block/block-copy: rename in-flight requests to tasks block/block-copy: alloc task on each iteration block/block-copy: add state pointer to BlockCopyTask block/block-copy: move task size initial calculation to _task_create block/block-copy: move block_copy_task_create down block/block-copy: use aio-task-pool API
block/block-copy: More explicit call_state block/block-copy: implement block_copy_async block/block-copy: add max_chunk and max_workers paramters block/block-copy: add ratelimit to block-copy block/block-copy: add block_copy_cancel
blockjob: add set_speed to BlockJobDriver
job: call job_enter from job_user_pause
backup: move to block-copy
python: add simplebench.py
python: add qemu/bench_block_job.py
python: benchmark new backup architecture
qapi/block-core.json | 9 +- include/block/block-copy.h | 90 ++--- include/block/block_int.h | 7 + include/block/blockjob_int.h | 2 + block/backup-top.c | 6 +- block/backup.c | 184 ++++++---- block/block-copy.c | 608 ++++++++++++++++++++++++++++----- block/replication.c | 1 + blockdev.c | 5 + blockjob.c | 6 + job.c | 1 + block/trace-events | 1 + python/bench-example.py | 93 +++++ python/qemu/bench_block_job.py | 114 +++++++ python/simplebench.py | 122 +++++++ tests/qemu-iotests/129 | 3 +- tests/qemu-iotests/185 | 3 +- tests/qemu-iotests/219 | 1 + tests/qemu-iotests/257 | 1 + tests/qemu-iotests/257.out | 306 ++++++++--------- 20 files changed, 1184 insertions(+), 379 deletions(-) create mode 100755 python/bench-example.py create mode 100755 python/qemu/bench_block_job.py create mode 100644 python/simplebench.py
Signature · 1 line
2.21.0
RFC 1/24 block/block-copy: specialcase first copy_range request
In block_copy_do_copy we fallback to read+write if copy_range failed. In this case copy_size is larger than defined for buffered IO, and there is corresponding commit. Still, backup copies data cluster by cluster, and most of requests are limited to one cluster anyway, so the only source of this one bad-limited request is copy-before-write operation.
Further patch will move backup to use block_copy directly, than for cases where copy_range is not supported, first request will be oversized in each backup. It's not good, let's change it now.
Fix is simple: just limit first copy_range request like buffer-based request. If it succeed, set larger copy_range limit.
--- block/block-copy.c | 41 ++++++++++++++++++++++++++++++----------- 1 file changed, 30 insertions(+), 11 deletions(-)
block/block-copy.c +30 -11
@@ -70,16 +70,19 @@ void block_copy_state_free(BlockCopyState *s)g_free (s); } +static uint32_t block_copy_max_transfer (BdrvChild *source,BdrvChild *target) +{ +return MIN_NON_ZERO (INT_MAX , +MIN_NON_ZERO (source->bs->bl.max_transfer, + target->bs->bl.max_transfer)); +} +BlockCopyState *block_copy_state_new (BdrvChild *source,BdrvChild *target,int64_t cluster_size,BdrvRequestFlags write_flags,Error **errp) {BlockCopyState *s;BdrvDirtyBitmap *copy_bitmap; -uint32_t max_transfer = -MIN_NON_ZERO (INT_MAX , -MIN_NON_ZERO (source->bs->bl.max_transfer, - target->bs->bl.max_transfer)); copy_bitmap =bdrv_create_dirty_bitmap (source->bs, cluster_size,NULL , errp);
@@ -99,7 +102,7 @@ BlockCopyState *block_copy_state_new(BdrvChild *source, BdrvChild *target, .mem = shres_create(BLOCK_COPY_MAX_MEM), }; -if (max_transfer < cluster_size) { +if (block_copy_max_transfer (source, target) < cluster_size) {/* * copy_range does not respect max_transfer. We don't want to bother * with requests smaller than block-copy cluster size, so fallback to
@@ -114,12 +117,11 @@ BlockCopyState *block_copy_state_new(BdrvChild *source, BdrvChild *target, s->copy_size = cluster_size; }else {/* -* copy_range does not respect max_transfer (it's a TODO), so we factor -* that in here. +* We enable copy-range, but keep small copy_size, until first +* successful copy_range (look at block_copy_do_copy). */ s->use_copy_range = true; - s->copy_size =MIN (MAX (cluster_size,BLOCK_COPY_MAX_COPY_RANGE ), -QEMU_ALIGN_DOWN (max_transfer, cluster_size)); + s->copy_size =MAX (s->cluster_size,BLOCK_COPY_MAX_BUFFER ); }QLIST_INIT (&s->inflight_reqs);
@@ -168,7 +170,21 @@ static int coroutine_fn block_copy_do_copy(BlockCopyState *s, s->use_copy_range = false; s->copy_size =MAX (s->cluster_size,BLOCK_COPY_MAX_BUFFER );/* Fallback to read+write with allocated buffer */ - }else { + }else if (s->use_copy_range) { +/* +* Successful copy-range. Now increase copy_size. +* copy_range does not respect max_transfer (it's a TODO), so we +* factor that in here. +* +* Note: we double-check s->use_copy_range for the case when +* parallel block-copy request unset it during previous +* bdrv_co_copy_range call. +*/ + s->copy_size = +MIN (MAX (s->cluster_size,BLOCK_COPY_MAX_COPY_RANGE ), +QEMU_ALIGN_DOWN (block_copy_max_transfer (s->source, + s->target), + s->cluster_size)); goto out; } }
@@ -176,7 +192,10 @@ static int coroutine_fn block_copy_do_copy(BlockCopyState *s,/* * In case of failed copy_range request above, we may proceed with buffered * request larger than BLOCK_COPY_MAX_BUFFER. Still, further requests will -* be properly limited, so don't care too much. +* be properly limited, so don't care too much. Moreover the most possible +* case (copy_range is unsupported for the configuration, so the very first +* copy_range request fails) is handled by setting large copy_size only +* after first successful copy_range. */ bounce_buffer =qemu_blockalign (s->source->bs, nbytes);
Signature · 1 line
2.21.0
RFC 2/24 block/block-copy: use block_status
In reply to Vladimir Sementsov-OgievskiyUse bdrv_block_status_above to chose effective chunk size and to handle zeroes effectively.
This substitutes checking for just being allocated or not, and drops old code path for it. Assistance by backup job is dropped too, as caching block-status information is more difficult than just caching is-allocated information in our dirty bitmap, and backup job is not good place for this caching anyway.
--- block/block-copy.c | 67 +++++++++++++++++++++++++++++++++++++--------- block/trace-events | 1 + 2 files changed, 55 insertions(+), 13 deletions(-)
block/block-copy.c +54 -13
@@ -152,7 +152,7 @@ void block_copy_set_callbacks(*/ static int coroutine_fn block_copy_do_copy(BlockCopyState *s,int64_t start,int64_t end, -bool *error_is_read) +bool zeroes,bool *error_is_read) {int ret;int nbytes =MIN (end, s->len) - start;
@@ -162,6 +162,18 @@ static int coroutine_fn block_copy_do_copy(BlockCopyState *s,assert (QEMU_IS_ALIGNED (end, s->cluster_size));assert (end < s->len || end ==QEMU_ALIGN_UP (s->len, s->cluster_size)); +if (zeroes) { + ret =bdrv_co_pwrite_zeroes (s->target, start, nbytes, s->write_flags & + ~BDRV_REQ_WRITE_COMPRESSED ); +if (ret <0 ) { +trace_block_copy_write_zeroes_fail (s, start, ret); +if (error_is_read) { + *error_is_read = false; + } + } +return ret; + } +if (s->use_copy_range) { ret =bdrv_co_copy_range (s->source, start, s->target, start, nbytes,0 , s->write_flags);
@@ -225,6 +237,34 @@ out:return ret; } +static int block_copy_block_status (BlockCopyState *s,int64_t offset, +int64_t bytes,int64_t *pnum) +{ +int64_t num; +BlockDriverState *base; +int ret; + +if (s->skip_unallocated && s->source->bs->backing) { + base = s->source->bs->backing->bs; + }else { + base =NULL ; + } + + ret =bdrv_block_status_above (s->source->bs, base, offset, bytes, &num, +NULL ,NULL ); +if (ret <0 || num < s->cluster_size) { + num = s->cluster_size; + ret =BDRV_BLOCK_ALLOCATED |BDRV_BLOCK_DATA ; + }else if (offset + num == s->len) { + num =QEMU_ALIGN_UP (num, s->cluster_size); + }else { + num =QEMU_ALIGN_DOWN (num, s->cluster_size); + } + + *pnum = num; +return ret; +} +/* * Check if the cluster starting at offset is allocated or not. * return via pnum the number of contiguous clusters sharing this allocation.
@@ -301,7 +341,6 @@ int coroutine_fn block_copy(BlockCopyState *s, {int ret =0 ;int64_t end = bytes + start;/* bytes */ -int64_t status_bytes;BlockCopyInFlightReq req;/*
@@ -318,7 +357,7 @@ int coroutine_fn block_copy(BlockCopyState *s,block_copy_inflight_req_begin (s, &req, start, end);while (start < end) { -int64_t next_zero, chunk_end; +int64_t next_zero, chunk_end, status_bytes;if (!bdrv_dirty_bitmap_get (s->copy_bitmap, start)) {trace_block_copy_skip (s, start);
@@ -336,23 +375,25 @@ int coroutine_fn block_copy(BlockCopyState *s, chunk_end = next_zero; } -if (s->skip_unallocated) { - ret =block_copy_reset_unallocated (s, start, &status_bytes); -if (ret ==0 ) { -trace_block_copy_skip_range (s, start, status_bytes); - start += status_bytes; -continue ; - } -/* Clamp to known allocated region */ - chunk_end =MIN (chunk_end, start + status_bytes); + ret =block_copy_block_status (s, start, chunk_end - start, + &status_bytes); +if (s->skip_unallocated && !(ret &BDRV_BLOCK_ALLOCATED )) { +bdrv_reset_dirty_bitmap (s->copy_bitmap, start, status_bytes); + s->progress_reset_callback (s->progress_opaque); +trace_block_copy_skip_range (s, start, status_bytes); + start += status_bytes; +continue ; } + chunk_end =MIN (chunk_end, start + status_bytes); +trace_block_copy_process (s, start);bdrv_reset_dirty_bitmap (s->copy_bitmap, start, chunk_end - start);co_get_from_shres (s->mem, chunk_end - start); - ret =block_copy_do_copy (s, start, chunk_end, error_is_read); + ret =block_copy_do_copy (s, start, chunk_end, ret &BDRV_BLOCK_ZERO , + error_is_read);co_put_to_shres (s->mem, chunk_end - start);if (ret <0 ) {bdrv_set_dirty_bitmap (s->copy_bitmap, start, chunk_end - start);
block/trace-events +1 -0
@@ -48,6 +48,7 @@ block_copy_process(void *bcs, int64_t start) "bcs %p start %"PRId64 block_copy_copy_range_fail(void *bcs, int64_t start, int ret) "bcs %p start %"PRId64" ret %d" block_copy_read_fail(void *bcs, int64_t start, int ret) "bcs %p start %"PRId64" ret %d" block_copy_write_fail(void *bcs, int64_t start, int ret) "bcs %p start %"PRId64" ret %d" +block_copy_write_zeroes_fail(void *bcs, int64_t start, int ret) "bcs %p start %"PRId64" ret %d" # ../blockdev.c qmp_block_job_cancel(void *job) "job %p"
Signature · 1 line
2.21.0
RFC 3/24 block/block-copy: factor out block_copy_find_inflight_req
In reply to Vladimir Sementsov-OgievskiySplit block_copy_find_inflight_req to be used in seprate.
--- block/block-copy.c | 31 +++++++++++++++++++------------ 1 file changed, 19 insertions(+), 12 deletions(-)
block/block-copy.c +19 -12
@@ -24,23 +24,30 @@#define BLOCK_COPY_MAX_BUFFER (1 * MiB)#define BLOCK_COPY_MAX_MEM (128 * MiB) +static BlockCopyInFlightReq *block_copy_find_inflight_req (BlockCopyState *s, +int64_t start, +int64_t end) +{ +BlockCopyInFlightReq *req; + + QLIST_FOREACH(req, &s->inflight_reqs, list) { +if (end > req->start_byte && start < req->end_byte) { +return req; + } + } + +return NULL ; +} + static void coroutine_fn block_copy_wait_inflight_reqs(BlockCopyState *s,int64_t start,int64_t end) {BlockCopyInFlightReq *req; -bool waited; - -do { - waited = false; - QLIST_FOREACH(req, &s->inflight_reqs, list) { -if (end > req->start_byte && start < req->end_byte) { -qemu_co_queue_wait (&req->wait_queue,NULL ); - waited = true; -break ; - } - } - }while (waited); + +while ((req =block_copy_find_inflight_req (s, start, end))) { +qemu_co_queue_wait (&req->wait_queue,NULL ); + } } static void block_copy_inflight_req_begin(BlockCopyState *s,
Signature · 1 line
2.21.0
RFC 4/24 block/block-copy: refactor interfaces to use bytes instead of end
In reply to Vladimir Sementsov-OgievskiyWe have a lot of "chunk_end - start" invocations, let's switch to bytes/cur_bytes scheme instead.
--- include/block/block-copy.h | 4 +-- block/block-copy.c | 68 ++++++++++++++++++++------------------ 2 files changed, 37 insertions(+), 35 deletions(-)
include/block/block-copy.h +2 -2
@@ -19,8 +19,8 @@#include "qemu/co-shared-resource.h" typedef struct BlockCopyInFlightReq { -int64_t start_byte; -int64_t end_byte; +int64_t start; +int64_t bytes;QLIST_ENTRY (BlockCopyInFlightReq) list;CoQueue wait_queue;/* coroutines blocked on this request */ }BlockCopyInFlightReq ;
block/block-copy.c +35 -33
157 lines not on this page · raw message
Signature · 1 line
2.21.0
RFC 5/24 block/block-copy: rename start to offset in interfaces
In reply to Vladimir Sementsov-Ogievskiyoffset/bytes pair is more usual naming in block layer, let's use it.
--- include/block/block-copy.h | 2 +- block/block-copy.c | 80 +++++++++++++++++++------------------- 2 files changed, 41 insertions(+), 41 deletions(-)
include/block/block-copy.h +1 -1
@@ -19,7 +19,7 @@#include "qemu/co-shared-resource.h" typedef struct BlockCopyInFlightReq { - int64_t start; + int64_t offset; int64_t bytes; QLIST_ENTRY(BlockCopyInFlightReq) list; CoQueue wait_queue; /* coroutines blocked on this request */
block/block-copy.c +40 -40
193 lines not on this page · raw message
Signature · 1 line
2.21.0
RFC 6/24 block/block-copy: reduce intersecting request lock
In reply to Vladimir Sementsov-OgievskiyCurrently, block_copy operation lock the whole requested region. But there is no reason to lock clusters, which are already copied, it will disturb other parallel block_copy requests for no reason.
Let's instead do the following:
Lock only sub-region, which we are going to operate on. Then, after copying all dirty sub-regions, we should wait for intersecting requests block-copy, if they failed, we should retry these new dirty clusters.
--- block/block-copy.c | 116 +++++++++++++++++++++++++++++++++++++-------- 1 file changed, 95 insertions(+), 21 deletions(-)
block/block-copy.c +95 -21
@@ -39,29 +39,62 @@ static BlockCopyInFlightReq *block_copy_find_inflight_req(BlockCopyState *s,return NULL ; } -static void coroutine_fn block_copy_wait_inflight_reqs(BlockCopyState *s, -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. +*/ +static bool coroutine_fn block_copy_wait_one(BlockCopyState *s, int64_t start, +int64_t end) { -BlockCopyInFlightReq *req; +BlockCopyInFlightReq *req =block_copy_find_inflight_req (s, start, end); -while ((req =block_copy_find_inflight_req (s, offset, bytes))) { -qemu_co_queue_wait (&req->wait_queue,NULL ); +if (!req) { +return false; } + +qemu_co_queue_wait (&req->wait_queue,NULL ); + +return true; } +/* Called only on full-dirty region */ static void block_copy_inflight_req_begin (BlockCopyState *s,BlockCopyInFlightReq *req,int64_t offset,int64_t bytes) { +assert (!block_copy_find_inflight_req (s, offset, bytes)); + +bdrv_reset_dirty_bitmap (s->copy_bitmap, offset, bytes); + req->offset = offset; req->bytes = bytes;qemu_co_queue_init (&req->wait_queue);QLIST_INSERT_HEAD (&s->inflight_reqs, req, list); } -static void coroutine_fn block_copy_inflight_req_end(BlockCopyInFlightReq *req) +static void coroutine_fn block_copy_inflight_req_shrink(BlockCopyState *s, +BlockCopyInFlightReq *req,int64_t new_bytes) { +if (new_bytes == req->bytes) { +return ; + } + +assert (new_bytes >0 && new_bytes < req->bytes); + +bdrv_set_dirty_bitmap (s->copy_bitmap, + req->offset + new_bytes, req->bytes - new_bytes); + + req->bytes = new_bytes; +qemu_co_queue_restart_all (&req->wait_queue); +} + +static void coroutine_fn block_copy_inflight_req_end(BlockCopyState *s, +BlockCopyInFlightReq *req, +int ret) +{ +if (ret <0 ) { +bdrv_set_dirty_bitmap (s->copy_bitmap, req->offset, req->bytes); + }QLIST_REMOVE (req, list);qemu_co_queue_restart_all (&req->wait_queue); }
@@ -344,12 +377,19 @@ int64_t block_copy_reset_unallocated(BlockCopyState *s,return ret; } -int coroutine_fn block_copy(BlockCopyState *s, -int64_t offset,uint64_t bytes, -bool *error_is_read) +/* +* block_copy_dirty_clusters +* +* Copy dirty clusters in @start/@bytes range. +* Returns 1 if dirty clusters found and successfully copied, 0 if no dirty +* clusters found and -errno on failure. +*/ +static int coroutine_fn block_copy_dirty_clusters(BlockCopyState *s, +int64_t offset,int64_t bytes, +bool *error_is_read) {int ret =0 ; -BlockCopyInFlightReq req; +bool found_dirty = false;/* * block_copy() user is responsible for keeping source and target in same
@@ -361,10 +401,8 @@ int coroutine_fn block_copy(BlockCopyState *s,assert (QEMU_IS_ALIGNED (offset, s->cluster_size));assert (QEMU_IS_ALIGNED (bytes, s->cluster_size)); -block_copy_wait_inflight_reqs (s, offset, bytes); -block_copy_inflight_req_begin (s, &req, offset, bytes); -while (bytes) { +BlockCopyInFlightReq req;int64_t next_zero, cur_bytes, status_bytes;if (!bdrv_dirty_bitmap_get (s->copy_bitmap, offset)) {
@@ -374,6 +412,8 @@ int coroutine_fn block_copy(BlockCopyState *s,continue ;/* already copied */ } + found_dirty = true; + cur_bytes =MIN (bytes, s->copy_size); next_zero = bdrv_dirty_bitmap_next_zero(s->copy_bitmap, offset,
@@ -383,10 +423,12 @@ int coroutine_fn block_copy(BlockCopyState *s,assert (next_zero < offset + cur_bytes);/* no need to do MIN() */ cur_bytes = next_zero - offset; } +block_copy_inflight_req_begin (s, &req, offset, cur_bytes); ret =block_copy_block_status (s, offset, cur_bytes, &status_bytes); +block_copy_inflight_req_shrink (s, &req, status_bytes);if (s->skip_unallocated && !(ret &BDRV_BLOCK_ALLOCATED )) { -bdrv_reset_dirty_bitmap (s->copy_bitmap, offset, status_bytes); +block_copy_inflight_req_end (s, &req,0 ); s->progress_reset_callback (s->progress_opaque);trace_block_copy_skip_range (s, offset, status_bytes); offset += status_bytes;
@@ -398,15 +440,13 @@ int coroutine_fn block_copy(BlockCopyState *s,trace_block_copy_process (s, offset); -bdrv_reset_dirty_bitmap (s->copy_bitmap, offset, cur_bytes); -co_get_from_shres (s->mem, cur_bytes); ret =block_copy_do_copy (s, offset, cur_bytes, ret &BDRV_BLOCK_ZERO , error_is_read);co_put_to_shres (s->mem, cur_bytes); +block_copy_inflight_req_end (s, &req, ret);if (ret <0 ) { -bdrv_set_dirty_bitmap (s->copy_bitmap, offset, cur_bytes); -break ; +return ret; } s->progress_bytes_callback (cur_bytes, s->progress_opaque);
@@ -414,7 +454,41 @@ int coroutine_fn block_copy(BlockCopyState *s, bytes -= cur_bytes; } -block_copy_inflight_req_end (&req); +return found_dirty; +} -return ret; +int coroutine_fn block_copy(BlockCopyState *s, int64_t start, uint64_t bytes, +bool *error_is_read) +{ +while (true) { +int ret =block_copy_dirty_clusters (s, start, bytes, error_is_read); + +if (ret <0 ) { +/* +* IO operation failed, which means the whole block_copy request +* failed. +*/ +return ret; + } +if (ret) { +/* +* Something was copied, which means that there were yield points +* and some new dirty bits may appered (due to failed parallel +* block-copy requests). +*/ +continue ; + } + +/* +* Here ret == 0, which means that there is no dirty clusters in +* requested region. +*/ + +if (!block_copy_wait_one (s, start, bytes)) { +/* No dirty bits and nothing to wait: the whole request is done */ +break ; + } + } + +return 0 ; }
Signature · 1 line
2.21.0
RFC 7/24 block/block-copy: hide structure definitions
In reply to Vladimir Sementsov-OgievskiyHide structure definitions and add explicit API instead, to keep an eye on the scope of the shared fields.
--- include/block/block-copy.h | 57 +++------------------------------ block/backup-top.c | 6 ++-- block/backup.c | 27 ++++++++-------- block/block-copy.c | 64 ++++++++++++++++++++++++++++++++++++++ 4 files changed, 86 insertions(+), 68 deletions(-)
include/block/block-copy.h +4 -53
@@ -18,61 +18,9 @@#include "block/block.h" #include "qemu/co-shared-resource.h" -typedef struct BlockCopyInFlightReq { -int64_t offset; -int64_t bytes; -QLIST_ENTRY (BlockCopyInFlightReq) list; -CoQueue wait_queue;/* coroutines blocked on this request */ -}BlockCopyInFlightReq ; -typedef void (*ProgressBytesCallbackFunc )(int64_t bytes,void *opaque);typedef void (*ProgressResetCallbackFunc )(void *opaque); -typedef struct BlockCopyState { -/* -* BdrvChild objects are not owned or managed by block-copy. They are -* provided by block-copy user and user is responsible for appropriate -* permissions on these children. -*/ -BdrvChild *source; -BdrvChild *target; -BdrvDirtyBitmap *copy_bitmap; -int64_t cluster_size; -bool use_copy_range; -int64_t copy_size; -uint64_t len; - QLIST_HEAD(, BlockCopyInFlightReq) inflight_reqs; - -BdrvRequestFlags write_flags; - -/* -* skip_unallocated: -* -* Used by sync=top jobs, which first scan the source node for unallocated -* areas and clear them in the copy_bitmap. During this process, the bitmap -* is thus not fully initialized: It may still have bits set for areas that -* are unallocated and should actually not be copied. -* -* This is indicated by skip_unallocated. -* -* In this case, block_copy() will query the source’s allocation status, -* skip unallocated regions, clear them in the copy_bitmap, and invoke -* block_copy_reset_unallocated() every time it does. -*/ -bool skip_unallocated; - -/* progress_bytes_callback: called when some copying progress is done. */ -ProgressBytesCallbackFunc progress_bytes_callback; - -/* -* progress_reset_callback: called when some bytes reset from copy_bitmap -* (see @skip_unallocated above). The callee is assumed to recalculate how -* many bytes remain based on the dirty bit count of copy_bitmap. -*/ -ProgressResetCallbackFunc progress_reset_callback; -void *progress_opaque; - -SharedResource *mem; -}BlockCopyState ; +typedef struct BlockCopyState BlockCopyState ; BlockCopyState *block_copy_state_new(BdrvChild *source, BdrvChild *target, int64_t cluster_size,
@@ -93,4 +41,7 @@ int64_t block_copy_reset_unallocated(BlockCopyState *s, int coroutine_fn block_copy(BlockCopyState *s, int64_t start, uint64_t bytes,bool *error_is_read); +BdrvDirtyBitmap *block_copy_dirty_bitmap (BlockCopyState *s); +void block_copy_set_skip_unallocated (BlockCopyState *s,bool skip); +#endif /* BLOCK_COPY_H */
block/backup-top.c +4 -2
@@ -38,6 +38,7 @@ typedef struct BDRVBackupTopState {BlockCopyState *bcs;BdrvChild *target;bool active; +int64_t cluster_size; } BDRVBackupTopState; static coroutine_fn int backup_top_co_preadv(
@@ -51,8 +52,8 @@ static coroutine_fn int backup_top_cbw(BlockDriverState *bs, uint64_t offset, uint64_t bytes) {BDRVBackupTopState *s = bs->opaque; -uint64_t end =QEMU_ALIGN_UP (offset + bytes, s->bcs->cluster_size); -uint64_t off =QEMU_ALIGN_DOWN (offset, s->bcs->cluster_size); +uint64_t end =QEMU_ALIGN_UP (offset + bytes, s->cluster_size); +uint64_t off =QEMU_ALIGN_DOWN (offset, s->cluster_size);return block_copy (s->bcs, off, end - off,NULL ); }
@@ -227,6 +228,7 @@ BlockDriverState *bdrv_backup_top_append(BlockDriverState *source, goto failed_after_append; } + state->cluster_size = cluster_size; state->bcs =block_copy_state_new (top->backing, state->target, cluster_size, write_flags, &local_err);if (local_err) {
block/backup.c +14 -13
@@ -48,6 +48,7 @@ typedef struct BackupBlockJob {int64_t cluster_size;BlockCopyState *bcs; +BdrvDirtyBitmap *bcs_bitmap; } BackupBlockJob;static const BlockJobDriver backup_job_driver;
@@ -63,7 +64,7 @@ static void backup_progress_bytes_callback(int64_t bytes, void *opaque)static void backup_progress_reset_callback (void *opaque) {BackupBlockJob *s = opaque; -uint64_t estimate =bdrv_get_dirty_count (s->bcs->copy_bitmap); +uint64_t estimate =bdrv_get_dirty_count (s->bcs_bitmap);job_progress_set_remaining (&s->common.job, estimate); }
@@ -111,8 +112,7 @@ static void backup_cleanup_sync_bitmap(BackupBlockJob *job, int ret)if (ret <0 && job->bitmap_mode ==BITMAP_SYNC_MODE_ALWAYS ) {/* If we failed and synced, merge in the bits we didn't copy: */ -bdrv_dirty_bitmap_merge_internal (bm, job->bcs->copy_bitmap, -NULL , true); +bdrv_dirty_bitmap_merge_internal (bm, job->bcs_bitmap,NULL , true); } }
@@ -151,7 +151,7 @@ void backup_do_checkpoint(BlockJob *job, Error **errp)return ; } -bdrv_set_dirty_bitmap (backup_job->bcs->copy_bitmap,0 , backup_job->len); +bdrv_set_dirty_bitmap (backup_job->bcs_bitmap,0 , backup_job->len); } static BlockErrorAction backup_error_action(BackupBlockJob *job,
@@ -196,7 +196,7 @@ static int coroutine_fn backup_loop(BackupBlockJob *job)BdrvDirtyBitmapIter *bdbi;int ret =0 ; - bdbi =bdrv_dirty_iter_new (job->bcs->copy_bitmap); + bdbi =bdrv_dirty_iter_new (job->bcs_bitmap);while ((offset =bdrv_dirty_iter_next (bdbi)) !=-1 ) { do { if (yield_and_check(job)) {
@@ -216,13 +216,13 @@ static int coroutine_fn backup_loop(BackupBlockJob *job)return ret; } -static void backup_init_copy_bitmap (BackupBlockJob *job) +static void backup_init_bcs_bitmap (BackupBlockJob *job) {bool ret;uint64_t estimate;if (job->sync_mode ==MIRROR_SYNC_MODE_BITMAP ) { - ret =bdrv_dirty_bitmap_merge_internal (job->bcs->copy_bitmap, + ret =bdrv_dirty_bitmap_merge_internal (job->bcs_bitmap, job->sync_bitmap,NULL , true);assert (ret);
@@ -232,12 +232,12 @@ static void backup_init_copy_bitmap(BackupBlockJob *job)* We can't hog the coroutine to initialize this thoroughly. * Set a flag and resume work when we are able to yield safely. */ - job->bcs->skip_unallocated = true; +block_copy_set_skip_unallocated (job->bcs, true); } -bdrv_set_dirty_bitmap (job->bcs->copy_bitmap,0 , job->len); +bdrv_set_dirty_bitmap (job->bcs_bitmap,0 , job->len); } - estimate =bdrv_get_dirty_count (job->bcs->copy_bitmap); + estimate =bdrv_get_dirty_count (job->bcs_bitmap);job_progress_set_remaining (&job->common.job, estimate); }
@@ -246,7 +246,7 @@ static int coroutine_fn backup_run(Job *job, Error **errp)BackupBlockJob *s =container_of (job, BackupBlockJob, common.job);int ret =0 ; -backup_init_copy_bitmap (s); +backup_init_bcs_bitmap (s);if (s->sync_mode ==MIRROR_SYNC_MODE_TOP ) {int64_t offset =0 ;
@@ -265,12 +265,12 @@ static int coroutine_fn backup_run(Job *job, Error **errp) offset += count; } - s->bcs->skip_unallocated = false; +block_copy_set_skip_unallocated (s->bcs, false); }if (s->sync_mode ==MIRROR_SYNC_MODE_NONE ) {/* -* All bits are set in copy_bitmap to allow any cluster to be copied. +* All bits are set in bcs_bitmap to allow any cluster to be copied. * This does not actually require them to be copied. */ while (!job_is_cancelled (job)) {
@@ -458,6 +458,7 @@ BlockJob *backup_job_create(const char *job_id, BlockDriverState *bs, job->sync_bitmap = sync_bitmap; job->bitmap_mode = bitmap_mode; job->bcs = bcs; + job->bcs_bitmap =block_copy_dirty_bitmap (bcs); job->cluster_size = cluster_size; job->len = len;
block/block-copy.c +64 -0
73 lines not on this page · raw message
Signature · 1 line
2.21.0
RFC 8/24 block/block-copy: rename in-flight requests to tasks
In reply to Vladimir Sementsov-OgievskiyWe are going to use aio-task-pool API and extend in-flight request structure to be a successor of AioTask, so rename things appropriately.
--- block/block-copy.c | 82 ++++++++++++++++++++++------------------------ 1 file changed, 40 insertions(+), 42 deletions(-)
block/block-copy.c +40 -42
@@ -24,12 +24,12 @@#define BLOCK_COPY_MAX_BUFFER (1 * MiB)#define BLOCK_COPY_MAX_MEM (128 * MiB) -typedef struct BlockCopyInFlightReq { +typedef struct BlockCopyTask {int64_t offset;int64_t bytes; -QLIST_ENTRY (BlockCopyInFlightReq) list; -CoQueue wait_queue;/* coroutines blocked on this request */ -}BlockCopyInFlightReq ; +QLIST_ENTRY (BlockCopyTask) list; +CoQueue wait_queue;/* coroutines blocked on this task */ +}BlockCopyTask ; typedef struct BlockCopyState { /*
@@ -44,7 +44,7 @@ typedef struct BlockCopyState {bool use_copy_range;int64_t copy_size;uint64_t len; - QLIST_HEAD(, BlockCopyInFlightReq) inflight_reqs; + QLIST_HEAD(, BlockCopyTask) tasks;BdrvRequestFlags write_flags;
@@ -78,15 +78,14 @@ typedef struct BlockCopyState {SharedResource *mem; } BlockCopyState; -static BlockCopyInFlightReq *block_copy_find_inflight_req (BlockCopyState *s, -int64_t offset, -int64_t bytes) +static BlockCopyTask *block_copy_find_task (BlockCopyState *s, +int64_t offset,int64_t bytes) { -BlockCopyInFlightReq *req; +BlockCopyTask *t; - QLIST_FOREACH(req, &s->inflight_reqs, list) { -if (offset + bytes > req->offset && offset < req->offset + req->bytes) { -return req; + QLIST_FOREACH(t, &s->tasks, list) { +if (offset + bytes > t->offset && offset < t->offset + t->bytes) { +return t; } }
@@ -100,57 +99,56 @@ static BlockCopyInFlightReq *block_copy_find_inflight_req(BlockCopyState *s, static bool coroutine_fn block_copy_wait_one(BlockCopyState *s, int64_t start,int64_t end) { -BlockCopyInFlightReq *req =block_copy_find_inflight_req (s, start, end); +BlockCopyTask *task =block_copy_find_task (s, start, end); -if (!req) { +if (!task) {return false; } -qemu_co_queue_wait (&req->wait_queue,NULL ); +qemu_co_queue_wait (&task->wait_queue,NULL );return true; }/* Called only on full-dirty region */ -static void block_copy_inflight_req_begin (BlockCopyState *s, -BlockCopyInFlightReq *req, -int64_t offset,int64_t bytes) +static void block_copy_task_begin (BlockCopyState *s,BlockCopyTask *task, +int64_t offset,int64_t bytes) { -assert (!block_copy_find_inflight_req (s, offset, bytes)); +assert (!block_copy_find_task (s, offset, bytes));bdrv_reset_dirty_bitmap (s->copy_bitmap, offset, bytes); - req->offset = offset; - req->bytes = bytes; -qemu_co_queue_init (&req->wait_queue); -QLIST_INSERT_HEAD (&s->inflight_reqs, req, list); + task->offset = offset; + task->bytes = bytes; +qemu_co_queue_init (&task->wait_queue); +QLIST_INSERT_HEAD (&s->tasks, task, list); } -static void coroutine_fn block_copy_inflight_req_shrink(BlockCopyState *s, -BlockCopyInFlightReq *req,int64_t new_bytes) +static void coroutine_fn block_copy_task_shrink(BlockCopyState *s, +BlockCopyTask *task, +int64_t new_bytes) { -if (new_bytes == req->bytes) { +if (new_bytes == task->bytes) {return ; } -assert (new_bytes >0 && new_bytes < req->bytes); +assert (new_bytes >0 && new_bytes < task->bytes);bdrv_set_dirty_bitmap (s->copy_bitmap, - req->offset + new_bytes, req->bytes - new_bytes); + task->offset + new_bytes, task->bytes - new_bytes); - req->bytes = new_bytes; -qemu_co_queue_restart_all (&req->wait_queue); + task->bytes = new_bytes; +qemu_co_queue_restart_all (&task->wait_queue); } -static void coroutine_fn block_copy_inflight_req_end(BlockCopyState *s, -BlockCopyInFlightReq *req, -int ret) +static void coroutine_fn block_copy_task_end(BlockCopyState *s, +BlockCopyTask *task,int ret) {if (ret <0 ) { -bdrv_set_dirty_bitmap (s->copy_bitmap, req->offset, req->bytes); +bdrv_set_dirty_bitmap (s->copy_bitmap, task->offset, task->bytes); } -QLIST_REMOVE (req, list); -qemu_co_queue_restart_all (&req->wait_queue); +QLIST_REMOVE (task, list); +qemu_co_queue_restart_all (&task->wait_queue); }void block_copy_state_free (BlockCopyState *s)
@@ -218,7 +216,7 @@ BlockCopyState *block_copy_state_new(BdrvChild *source, BdrvChild *target, s->copy_size =MAX (s->cluster_size,BLOCK_COPY_MAX_BUFFER ); } -QLIST_INIT (&s->inflight_reqs); +QLIST_INIT (&s->tasks);return s; }
@@ -456,7 +454,7 @@ static int coroutine_fn block_copy_dirty_clusters(BlockCopyState *s,assert (QEMU_IS_ALIGNED (bytes, s->cluster_size));while (bytes) { -BlockCopyInFlightReq req; +BlockCopyTask task;int64_t next_zero, cur_bytes, status_bytes;if (!bdrv_dirty_bitmap_get (s->copy_bitmap, offset)) {
@@ -477,12 +475,12 @@ static int coroutine_fn block_copy_dirty_clusters(BlockCopyState *s,assert (next_zero < offset + cur_bytes);/* no need to do MIN() */ cur_bytes = next_zero - offset; } -block_copy_inflight_req_begin (s, &req, offset, cur_bytes); +block_copy_task_begin (s, &task, offset, cur_bytes); ret =block_copy_block_status (s, offset, cur_bytes, &status_bytes); -block_copy_inflight_req_shrink (s, &req, status_bytes); +block_copy_task_shrink (s, &task, status_bytes);if (s->skip_unallocated && !(ret &BDRV_BLOCK_ALLOCATED )) { -block_copy_inflight_req_end (s, &req,0 ); +block_copy_task_end (s, &task,0 ); s->progress_reset_callback (s->progress_opaque);trace_block_copy_skip_range (s, offset, status_bytes); offset += status_bytes;
@@ -498,7 +496,7 @@ static int coroutine_fn block_copy_dirty_clusters(BlockCopyState *s, ret =block_copy_do_copy (s, offset, cur_bytes, ret &BDRV_BLOCK_ZERO , error_is_read);co_put_to_shres (s->mem, cur_bytes); -block_copy_inflight_req_end (s, &req, ret); +block_copy_task_end (s, &task, ret);if (ret <0 ) {return ret; }
Signature · 1 line
2.21.0
RFC 9/24 block/block-copy: alloc task on each iteration
In reply to Vladimir Sementsov-OgievskiyWe are going to use aio-task-pool API, so tasks will be handled in parallel. We need therefore separate allocated task on each iteration. Introduce this logic now.
--- block/block-copy.c | 18 +++++++++++------- 1 file changed, 11 insertions(+), 7 deletions(-)
block/block-copy.c +11 -7
@@ -111,9 +111,11 @@ static bool coroutine_fn block_copy_wait_one(BlockCopyState *s, int64_t start, }/* Called only on full-dirty region */ -static void block_copy_task_begin (BlockCopyState *s,BlockCopyTask *task, -int64_t offset,int64_t bytes) +static BlockCopyTask *block_copy_task_create (BlockCopyState *s, +int64_t offset,int64_t bytes) { +BlockCopyTask *task =g_new (BlockCopyTask,1 ); +assert (!block_copy_find_task (s, offset, bytes));bdrv_reset_dirty_bitmap (s->copy_bitmap, offset, bytes);
@@ -122,6 +124,8 @@ static void block_copy_task_begin(BlockCopyState *s, BlockCopyTask *task, task->bytes = bytes;qemu_co_queue_init (&task->wait_queue);QLIST_INSERT_HEAD (&s->tasks, task, list); + +return task; } static void coroutine_fn block_copy_task_shrink(BlockCopyState *s,
@@ -454,7 +458,7 @@ static int coroutine_fn block_copy_dirty_clusters(BlockCopyState *s,assert (QEMU_IS_ALIGNED (bytes, s->cluster_size));while (bytes) { -BlockCopyTask task; + g_autofree BlockCopyTask *task = NULL;int64_t next_zero, cur_bytes, status_bytes;if (!bdrv_dirty_bitmap_get (s->copy_bitmap, offset)) {
@@ -475,12 +479,12 @@ static int coroutine_fn block_copy_dirty_clusters(BlockCopyState *s,assert (next_zero < offset + cur_bytes);/* no need to do MIN() */ cur_bytes = next_zero - offset; } -block_copy_task_begin (s, &task, offset, cur_bytes); + task =block_copy_task_create (s, offset, cur_bytes); ret =block_copy_block_status (s, offset, cur_bytes, &status_bytes); -block_copy_task_shrink (s, &task, status_bytes); +block_copy_task_shrink (s, task, status_bytes);if (s->skip_unallocated && !(ret &BDRV_BLOCK_ALLOCATED )) { -block_copy_task_end (s, &task,0 ); +block_copy_task_end (s, task,0 ); s->progress_reset_callback (s->progress_opaque);trace_block_copy_skip_range (s, offset, status_bytes); offset += status_bytes;
@@ -496,7 +500,7 @@ static int coroutine_fn block_copy_dirty_clusters(BlockCopyState *s, ret =block_copy_do_copy (s, offset, cur_bytes, ret &BDRV_BLOCK_ZERO , error_is_read);co_put_to_shres (s->mem, cur_bytes); -block_copy_task_end (s, &task, ret); +block_copy_task_end (s, task, ret);if (ret <0 ) {return ret; }
Signature · 1 line
2.21.0
RFC 10/24 block/block-copy: add state pointer to BlockCopyTask
In reply to Vladimir Sementsov-OgievskiyWe are going to use aio-task-pool API, so we'll need state pointer in BlockCopyTask anyway. Add it now and use where possible.
--- block/block-copy.c | 24 +++++++++++++----------- 1 file changed, 13 insertions(+), 11 deletions(-)
block/block-copy.c +13 -11
@@ -25,6 +25,7 @@#define BLOCK_COPY_MAX_MEM (128 * MiB) typedef struct BlockCopyTask { + BlockCopyState *s; int64_t offset; int64_t bytes; QLIST_ENTRY(BlockCopyTask) list;
@@ -120,16 +121,18 @@ static BlockCopyTask *block_copy_task_create(BlockCopyState *s,bdrv_reset_dirty_bitmap (s->copy_bitmap, offset, bytes); - task->offset = offset; - task->bytes = bytes; + *task = (BlockCopyTask ) { + .s = s, + .offset = offset, + .bytes = bytes, + };qemu_co_queue_init (&task->wait_queue);QLIST_INSERT_HEAD (&s->tasks, task, list);return task; } -static void coroutine_fn block_copy_task_shrink(BlockCopyState *s, -BlockCopyTask *task, +static void coroutine_fn block_copy_task_shrink(BlockCopyTask *task,int64_t new_bytes) {if (new_bytes == task->bytes) {
@@ -138,18 +141,17 @@ static void coroutine_fn block_copy_task_shrink(BlockCopyState *s,assert (new_bytes >0 && new_bytes < task->bytes); -bdrv_set_dirty_bitmap (s->copy_bitmap, +bdrv_set_dirty_bitmap (task->s->copy_bitmap, task->offset + new_bytes, task->bytes - new_bytes); task->bytes = new_bytes;qemu_co_queue_restart_all (&task->wait_queue); } -static void coroutine_fn block_copy_task_end(BlockCopyState *s, -BlockCopyTask *task,int ret) +static void coroutine_fn block_copy_task_end(BlockCopyTask *task, int ret) {if (ret <0 ) { -bdrv_set_dirty_bitmap (s->copy_bitmap, task->offset, task->bytes); +bdrv_set_dirty_bitmap (task->s->copy_bitmap, task->offset, task->bytes); }QLIST_REMOVE (task, list);qemu_co_queue_restart_all (&task->wait_queue);
@@ -482,9 +484,9 @@ static int coroutine_fn block_copy_dirty_clusters(BlockCopyState *s, task =block_copy_task_create (s, offset, cur_bytes); ret =block_copy_block_status (s, offset, cur_bytes, &status_bytes); -block_copy_task_shrink (s, task, status_bytes); +block_copy_task_shrink (task, status_bytes);if (s->skip_unallocated && !(ret &BDRV_BLOCK_ALLOCATED )) { -block_copy_task_end (s, task,0 ); +block_copy_task_end (task,0 ); s->progress_reset_callback (s->progress_opaque);trace_block_copy_skip_range (s, offset, status_bytes); offset += status_bytes;
@@ -500,7 +502,7 @@ static int coroutine_fn block_copy_dirty_clusters(BlockCopyState *s, ret =block_copy_do_copy (s, offset, cur_bytes, ret &BDRV_BLOCK_ZERO , error_is_read);co_put_to_shres (s->mem, cur_bytes); -block_copy_task_end (s, task, ret); +block_copy_task_end (task, ret);if (ret <0 ) {return ret; }
Signature · 1 line
2.21.0
RFC 11/24 block/block-copy: move task size initial calculation to _task_create
In reply to Vladimir Sementsov-OgievskiyComment "Called only on full-dirty region" without corresponding assertion is a very unsafe thing. Adding assertion means call bdrv_dirty_bitmap_next_zero twice. Instead, let's move bdrv_dirty_bitmap_next_zero call to block_copy_task_create. It also allows to drop cur_bytes variable which partly duplicate task->bytes.
--- block/block-copy.c | 42 +++++++++++++++++++++--------------------- 1 file changed, 21 insertions(+), 21 deletions(-)
block/block-copy.c +21 -21
@@ -111,12 +111,23 @@ static bool coroutine_fn block_copy_wait_one(BlockCopyState *s, int64_t start,return true; } -/* Called only on full-dirty region */ static BlockCopyTask *block_copy_task_create (BlockCopyState *s,int64_t offset,int64_t bytes) { +int64_t next_zero;BlockCopyTask *task =g_new (BlockCopyTask,1 ); +assert (bdrv_dirty_bitmap_get (s->copy_bitmap, offset)); + + bytes =MIN (bytes, s->copy_size); + next_zero =bdrv_dirty_bitmap_next_zero (s->copy_bitmap, offset, bytes); +if (next_zero >=0 ) { +assert (next_zero > offset);/* offset is dirty */ +assert (next_zero < offset + bytes);/* no need to do MIN() */ + bytes = next_zero - offset; + } + +/* region is dirty, so no existent tasks possible in it */ assert (!block_copy_find_task (s, offset, bytes));bdrv_reset_dirty_bitmap (s->copy_bitmap, offset, bytes);
@@ -461,7 +472,7 @@ static int coroutine_fn block_copy_dirty_clusters(BlockCopyState *s,while (bytes) { g_autofree BlockCopyTask *task = NULL; -int64_t next_zero, cur_bytes, status_bytes; +int64_t status_bytes;if (!bdrv_dirty_bitmap_get (s->copy_bitmap, offset)) {trace_block_copy_skip (s, offset);
@@ -472,18 +483,9 @@ static int coroutine_fn block_copy_dirty_clusters(BlockCopyState *s, found_dirty = true; - cur_bytes =MIN (bytes, s->copy_size); + task =block_copy_task_create (s, offset, bytes); - next_zero =bdrv_dirty_bitmap_next_zero (s->copy_bitmap, offset, - cur_bytes); -if (next_zero >=0 ) { -assert (next_zero > offset);/* offset is dirty */ -assert (next_zero < offset + cur_bytes);/* no need to do MIN() */ - cur_bytes = next_zero - offset; - } - task =block_copy_task_create (s, offset, cur_bytes); - - ret =block_copy_block_status (s, offset, cur_bytes, &status_bytes); + ret =block_copy_block_status (s, offset, task->bytes, &status_bytes);block_copy_task_shrink (task, status_bytes);if (s->skip_unallocated && !(ret &BDRV_BLOCK_ALLOCATED )) {block_copy_task_end (task,0 );
@@ -494,22 +496,20 @@ static int coroutine_fn block_copy_dirty_clusters(BlockCopyState *s,continue ; } - cur_bytes =MIN (cur_bytes, status_bytes); -trace_block_copy_process (s, offset); -co_get_from_shres (s->mem, cur_bytes); - ret =block_copy_do_copy (s, offset, cur_bytes, ret &BDRV_BLOCK_ZERO , +co_get_from_shres (s->mem, task->bytes); + ret =block_copy_do_copy (s, offset, task->bytes, ret &BDRV_BLOCK_ZERO , error_is_read); -co_put_to_shres (s->mem, cur_bytes); +co_put_to_shres (s->mem, task->bytes);block_copy_task_end (task, ret);if (ret <0 ) {return ret; } - s->progress_bytes_callback (cur_bytes, s->progress_opaque); - offset += cur_bytes; - bytes -= cur_bytes; + s->progress_bytes_callback (task->bytes, s->progress_opaque); + offset += task->bytes; + bytes -= task->bytes; }return found_dirty;
Signature · 1 line
2.21.0
RFC 12/24 block/block-copy: move block_copy_task_create down
In reply to Vladimir Sementsov-OgievskiySimple movement without any change. It's needed for the following patch, as this function will need to use some staff which is currently below it.
--- block/block-copy.c | 64 +++++++++++++++++++++++----------------------- 1 file changed, 32 insertions(+), 32 deletions(-)
block/block-copy.c +32 -32
@@ -111,38 +111,6 @@ static bool coroutine_fn block_copy_wait_one(BlockCopyState *s, int64_t start,return true; } -static BlockCopyTask *block_copy_task_create (BlockCopyState *s, -int64_t offset,int64_t bytes) -{ -int64_t next_zero; -BlockCopyTask *task =g_new (BlockCopyTask,1 ); - -assert (bdrv_dirty_bitmap_get (s->copy_bitmap, offset)); - - bytes =MIN (bytes, s->copy_size); - next_zero =bdrv_dirty_bitmap_next_zero (s->copy_bitmap, offset, bytes); -if (next_zero >=0 ) { -assert (next_zero > offset);/* offset is dirty */ -assert (next_zero < offset + bytes);/* no need to do MIN() */ - bytes = next_zero - offset; - } - -/* region is dirty, so no existent tasks possible in it */ -assert (!block_copy_find_task (s, offset, bytes)); - -bdrv_reset_dirty_bitmap (s->copy_bitmap, offset, bytes); - - *task = (BlockCopyTask ) { - .s = s, - .offset = offset, - .bytes = bytes, - }; -qemu_co_queue_init (&task->wait_queue); -QLIST_INSERT_HEAD (&s->tasks, task, list); - -return task; -} - static void coroutine_fn block_copy_task_shrink(BlockCopyTask *task,int64_t new_bytes) {
@@ -348,6 +316,38 @@ out:return ret; } +static BlockCopyTask *block_copy_task_create (BlockCopyState *s, +int64_t offset,int64_t bytes) +{ +int64_t next_zero; +BlockCopyTask *task =g_new (BlockCopyTask,1 ); + +assert (bdrv_dirty_bitmap_get (s->copy_bitmap, offset)); + + bytes =MIN (bytes, s->copy_size); + next_zero =bdrv_dirty_bitmap_next_zero (s->copy_bitmap, offset, bytes); +if (next_zero >=0 ) { +assert (next_zero > offset);/* offset is dirty */ +assert (next_zero < offset + bytes);/* no need to do MIN() */ + bytes = next_zero - offset; + } + +/* region is dirty, so no existent tasks possible in it */ +assert (!block_copy_find_task (s, offset, bytes)); + +bdrv_reset_dirty_bitmap (s->copy_bitmap, offset, bytes); + + *task = (BlockCopyTask ) { + .s = s, + .offset = offset, + .bytes = bytes, + }; +qemu_co_queue_init (&task->wait_queue); +QLIST_INSERT_HEAD (&s->tasks, task, list); + +return task; +} +static int block_copy_block_status (BlockCopyState *s,int64_t offset,int64_t bytes,int64_t *pnum) {
Signature · 1 line
2.21.0
RFC 13/24 block/block-copy: use aio-task-pool API
In reply to Vladimir Sementsov-OgievskiyRun block_copy iterations in parallel in aio tasks.
--- block/block-copy.c | 102 +++++++++++++++++++++++++++++++++++++++------ 1 file changed, 90 insertions(+), 12 deletions(-)
block/block-copy.c +90 -12
@@ -19,15 +19,27 @@#include "block/block-copy.h" #include "sysemu/block-backend.h" #include "qemu/units.h" +#include "qemu/coroutine.h" +#include "block/aio_task.h" #define BLOCK_COPY_MAX_COPY_RANGE (16 * MiB)#define BLOCK_COPY_MAX_BUFFER (1 * MiB)#define BLOCK_COPY_MAX_MEM (128 * MiB) +#define BLOCK_COPY_MAX_WORKERS 64 + +typedef struct BlockCopyCallState { +bool failed; +bool error_is_read; +}BlockCopyCallState ;typedef struct BlockCopyTask { +AioTask task; +BlockCopyState *s; +BlockCopyCallState *call_state;int64_t offset;int64_t bytes; +bool zeroes;QLIST_ENTRY (BlockCopyTask) list;CoQueue wait_queue;/* coroutines blocked on this task */ }BlockCopyTask ;
@@ -217,6 +229,30 @@ void block_copy_set_callbacks( s->progress_opaque = progress_opaque; } +/* Takes ownership on @task */ +static coroutine_fn int block_copy_task_run(AioTaskPool *pool, +BlockCopyTask *task) +{ +if (!pool) { +int ret = task->task.func (&task->task); + +g_free (task); +return ret; + } + +aio_task_pool_wait_slot (pool); +if (aio_task_pool_status (pool) <0 ) { +co_put_to_shres (task->s->mem, task->bytes); +block_copy_task_end (task, -EAGAIN ); +g_free (task); +return aio_task_pool_status (pool); + } + +aio_task_pool_start_task (pool, &task->task); + +return 0 ; +} +/* * block_copy_do_copy *
@@ -316,8 +352,31 @@ out:return ret; } +static coroutine_fn int block_copy_task_entry(AioTask *task) +{ +BlockCopyTask *t =container_of (task, BlockCopyTask, task); +bool error_is_read; +int ret; + + ret =block_copy_do_copy (t->s, t->offset, t->bytes, t->zeroes, + &error_is_read); +if (ret <0 && !t->call_state->failed) { + t->call_state->failed = true; + t->call_state->error_is_read = error_is_read; + }else { + t->s->progress_bytes_callback (t->bytes, t->s->progress_opaque); + } +co_put_to_shres (t->s->mem, t->bytes); +block_copy_task_end (t, ret); + +return ret; +} + +/* Called only on full-dirty region */ static BlockCopyTask *block_copy_task_create (BlockCopyState *s, -int64_t offset,int64_t bytes) +BlockCopyCallState *call_state, +int64_t offset, +int64_t bytes) {int64_t next_zero;BlockCopyTask *task =g_new (BlockCopyTask,1 );
@@ -338,7 +397,9 @@ static BlockCopyTask *block_copy_task_create(BlockCopyState *s,bdrv_reset_dirty_bitmap (s->copy_bitmap, offset, bytes); *task = (BlockCopyTask ) { + .task.func = block_copy_task_entry, .s = s, + .call_state = call_state, .offset = offset, .bytes = bytes, };
@@ -459,6 +520,8 @@ static int coroutine_fn block_copy_dirty_clusters(BlockCopyState *s, {int ret =0 ;bool found_dirty = false; +AioTaskPool *aio =NULL ; +BlockCopyCallState call_state = {false, false};/* * block_copy() user is responsible for keeping source and target in same
@@ -470,8 +533,8 @@ static int coroutine_fn block_copy_dirty_clusters(BlockCopyState *s,assert (QEMU_IS_ALIGNED (offset, s->cluster_size));assert (QEMU_IS_ALIGNED (bytes, s->cluster_size)); -while (bytes) { - g_autofree BlockCopyTask *task = NULL; +while (bytes &&aio_task_pool_status (aio) ==0 ) { +BlockCopyTask *task;int64_t status_bytes;if (!bdrv_dirty_bitmap_get (s->copy_bitmap, offset)) {
@@ -483,36 +546,51 @@ static int coroutine_fn block_copy_dirty_clusters(BlockCopyState *s, found_dirty = true; - task =block_copy_task_create (s, offset, bytes); + task =block_copy_task_create (s, &call_state, offset, bytes); ret =block_copy_block_status (s, offset, task->bytes, &status_bytes);block_copy_task_shrink (task, status_bytes);if (s->skip_unallocated && !(ret &BDRV_BLOCK_ALLOCATED )) {block_copy_task_end (task,0 ); +g_free (task); s->progress_reset_callback (s->progress_opaque);trace_block_copy_skip_range (s, offset, status_bytes); offset += status_bytes; bytes -= status_bytes;continue ; } + task->zeroes = ret &BDRV_BLOCK_ZERO ;trace_block_copy_process (s, offset);co_get_from_shres (s->mem, task->bytes); - ret =block_copy_do_copy (s, offset, task->bytes, ret &BDRV_BLOCK_ZERO , - error_is_read); -co_put_to_shres (s->mem, task->bytes); -block_copy_task_end (task, ret); -if (ret <0 ) { -return ret; + +if (!aio && task->bytes != bytes) { + aio =aio_task_pool_new (BLOCK_COPY_MAX_WORKERS ); } - s->progress_bytes_callback (task->bytes, s->progress_opaque); offset += task->bytes; bytes -= task->bytes; + + ret =block_copy_task_run (aio, task); +if (ret <0 ) { + goto out; + } + } + +out: +if (aio) { +aio_task_pool_wait_all (aio); +if (ret ==0 ) { + ret =aio_task_pool_status (aio); + } +g_free (aio); + } +if (error_is_read && ret <0 ) { + *error_is_read = call_state.error_is_read; } -return found_dirty; +return ret <0 ? ret : found_dirty; } int coroutine_fn block_copy(BlockCopyState *s, int64_t start, uint64_t bytes,
Signature · 1 line
2.21.0
RFC 14/24 block/block-copy: More explicit call_state
In reply to Vladimir Sementsov-OgievskiyRefactor common path to use BlockCopyCallState pointer as parameter, to prepare it for use in asynchronous block-copy (at least, we'll need to run block-copy in a coroutine, passing the whole parameters as one pointer).
--- block/block-copy.c | 50 +++++++++++++++++++++++++++++++++++----------- 1 file changed, 38 insertions(+), 12 deletions(-)
block/block-copy.c +38 -12
@@ -28,7 +28,15 @@#define BLOCK_COPY_MAX_WORKERS 64typedef struct BlockCopyCallState { +/* IN parameters */ +BlockCopyState *s; +int64_t offset; +int64_t bytes; + +/* State */ bool failed; + +/* OUT parameters */ bool error_is_read; }BlockCopyCallState ;
@@ -514,14 +522,16 @@ int64_t block_copy_reset_unallocated(BlockCopyState *s,* Returns 1 if dirty clusters found and successfully copied, 0 if no dirty * clusters found and -errno on failure. */ -static int coroutine_fn block_copy_dirty_clusters(BlockCopyState *s, -int64_t offset,int64_t bytes, -bool *error_is_read) +static int coroutine_fn +block_copy_dirty_clusters (BlockCopyCallState *call_state) { +BlockCopyState *s = call_state->s; +int64_t offset = call_state->offset; +int64_t bytes = call_state->bytes; +int ret =0 ;bool found_dirty = false;AioTaskPool *aio =NULL ; -BlockCopyCallState call_state = {false, false};/* * block_copy() user is responsible for keeping source and target in same
@@ -546,7 +556,7 @@ static int coroutine_fn block_copy_dirty_clusters(BlockCopyState *s, found_dirty = true; - task =block_copy_task_create (s, &call_state, offset, bytes); + task =block_copy_task_create (s, call_state, offset, bytes); ret =block_copy_block_status (s, offset, task->bytes, &status_bytes);block_copy_task_shrink (task, status_bytes);
@@ -586,18 +596,14 @@ out: }g_free (aio); } -if (error_is_read && ret <0 ) { - *error_is_read = call_state.error_is_read; - }return ret <0 ? ret : found_dirty; } -int coroutine_fn block_copy(BlockCopyState *s, int64_t start, uint64_t bytes, -bool *error_is_read) +static int coroutine_fn block_copy_common(BlockCopyCallState *call_state) {while (true) { -int ret =block_copy_dirty_clusters (s, start, bytes, error_is_read); +int ret =block_copy_dirty_clusters (call_state);if (ret <0 ) {/*
@@ -620,7 +626,9 @@ int coroutine_fn block_copy(BlockCopyState *s, int64_t start, uint64_t bytes,* requested region. */ -if (!block_copy_wait_one (s, start, bytes)) { +if (!block_copy_wait_one (call_state->s, call_state->offset, + call_state->bytes)) + {/* No dirty bits and nothing to wait: the whole request is done */ break ; }
@@ -629,6 +637,24 @@ int coroutine_fn block_copy(BlockCopyState *s, int64_t start, uint64_t bytes,return 0 ; } +int coroutine_fn block_copy(BlockCopyState *s, int64_t start, uint64_t bytes, +bool *error_is_read) +{ +BlockCopyCallState call_state = { + .s = s, + .offset = start, + .bytes = bytes, + }; + +int ret =block_copy_common (&call_state); + +if (error_is_read && ret <0 ) { + *error_is_read = call_state.error_is_read; + } + +return ret; +} +BdrvDirtyBitmap *block_copy_dirty_bitmap (BlockCopyState *s) {return s->copy_bitmap;
Signature · 1 line
2.21.0
RFC 15/24 block/block-copy: implement block_copy_async
In reply to Vladimir Sementsov-OgievskiyWe'll need async block-copy invocation to use in backup directly.
--- include/block/block-copy.h | 13 +++++++++++ block/block-copy.c | 48 +++++++++++++++++++++++++++++++++++--- 2 files changed, 58 insertions(+), 3 deletions(-)
include/block/block-copy.h +13 -0
@@ -20,7 +20,10 @@typedef void (*ProgressBytesCallbackFunc )(int64_t bytes,void *opaque);typedef void (*ProgressResetCallbackFunc )(void *opaque); +typedef void (*BlockCopyAsyncCallbackFunc )(int ret,bool error_is_read, +void *opaque);typedef struct BlockCopyState BlockCopyState ; +typedef struct BlockCopyCallState BlockCopyCallState ; BlockCopyState *block_copy_state_new(BdrvChild *source, BdrvChild *target, int64_t cluster_size,
@@ -41,6 +44,16 @@ int64_t block_copy_reset_unallocated(BlockCopyState *s, int coroutine_fn block_copy(BlockCopyState *s, int64_t start, uint64_t bytes,bool *error_is_read); +/* +* Run block-copy in a coroutine, return state pointer. If finished early +* returns NULL (@cb is called anyway). +*/ +BlockCopyCallState *block_copy_async (BlockCopyState *s, +int64_t offset,int64_t bytes, +bool ratelimit,int max_workers, +int64_t max_chunk, +BlockCopyAsyncCallbackFunc cb); +BdrvDirtyBitmap *block_copy_dirty_bitmap (BlockCopyState *s);void block_copy_set_skip_unallocated (BlockCopyState *s,bool skip);
block/block-copy.c +45 -3
82 lines not on this page · raw message
Signature · 1 line
2.21.0
RFC 16/24 block/block-copy: add max_chunk and max_workers paramters
In reply to Vladimir Sementsov-OgievskiyThey will be used for backup.
--- include/block/block-copy.h | 5 +++++ block/block-copy.c | 9 +++++++-- 2 files changed, 12 insertions(+), 2 deletions(-)
include/block/block-copy.h +5 -0
@@ -47,6 +47,11 @@ int coroutine_fn block_copy(BlockCopyState *s, int64_t start, uint64_t bytes,/* * Run block-copy in a coroutine, return state pointer. If finished early * returns NULL (@cb is called anyway). +* +* @max_workers means maximum of parallel coroutines to execute sub-requests, +* must be > 0. +* +* @max_chunk means maximum length for one IO operation. Zero means unlimited. */ BlockCopyCallState *block_copy_async(BlockCopyState *s, int64_t offset, int64_t bytes,
block/block-copy.c +7 -2
@@ -32,6 +32,8 @@ typedef struct BlockCopyCallState {BlockCopyState *s;int64_t offset;int64_t bytes; +int max_workers; +int64_t max_chunk;BlockCopyAsyncCallbackFunc cb;/* State */
@@ -393,7 +395,7 @@ static BlockCopyTask *block_copy_task_create(BlockCopyState *s,assert (bdrv_dirty_bitmap_get (s->copy_bitmap, offset)); - bytes =MIN (bytes, s->copy_size); + bytes =MIN (bytes,MIN_NON_ZERO (s->copy_size, call_state->max_chunk)); next_zero =bdrv_dirty_bitmap_next_zero (s->copy_bitmap, offset, bytes);if (next_zero >=0 ) {assert (next_zero > offset);/* offset is dirty */
@@ -578,7 +580,7 @@ block_copy_dirty_clusters(BlockCopyCallState *call_state)co_get_from_shres (s->mem, task->bytes);if (!aio && task->bytes != bytes) { - aio =aio_task_pool_new (BLOCK_COPY_MAX_WORKERS ); + aio =aio_task_pool_new (call_state->max_workers); } offset += task->bytes;
@@ -655,6 +657,7 @@ int coroutine_fn block_copy(BlockCopyState *s, int64_t start, uint64_t bytes, .s = s, .offset = start, .bytes = bytes, + .max_workers = BLOCK_COPY_MAX_WORKERS, };int ret =block_copy_common (&call_state);
@@ -686,6 +689,8 @@ BlockCopyCallState *block_copy_async(BlockCopyState *s, .offset = offset, .bytes = bytes, .cb = cb, + .max_workers = max_workers ?: BLOCK_COPY_MAX_WORKERS, + .max_chunk = max_chunk, };qemu_coroutine_enter (co);
Signature · 1 line
2.21.0
RFC 17/24 block/block-copy: add ratelimit to block-copy
In reply to Vladimir Sementsov-OgievskiyWe are going to directly use one async block-copy operation for backup job, so we need rate limitator.
We want to maintain current backup behavior: only background copying is limited and copy-before-write operations only participate in limit calculation. Therefore we need one rate limitator for block-copy state and boolean flag for block-copy call state for actual limitation.
Note, that we can't just calculate each chunk in limitator after successful copying: it will not restring starting a lot of async sub-requests which will exceed limit too much. Instead let's use the following scheme on sub-request creation:
1. If at the moment limit is not exceeded, create the request and account it immediately.
2. If at the moment limit is already exceeded, drop create sub-request and handle limit instead (by sleep).
With this approach we'll never exceed the limit more than by one sub-request (which pretty much matches current backup behavior).
--- include/block/block-copy.h | 8 +++++++ block/block-copy.c | 44 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 52 insertions(+)
include/block/block-copy.h +8 -0
@@ -59,6 +59,14 @@ BlockCopyCallState *block_copy_async(BlockCopyState *s,int64_t max_chunk, BlockCopyAsyncCallbackFunc cb); +/* +* Set speed limit for block-copy instance. All block-copy operations related to +* this BlockCopyState will participate in speed calculation, but only +* block_copy_async calls with @ratelimit=true will be actually limited. +*/ +void block_copy_set_speed (BlockCopyState *s,BlockCopyCallState *call_state, +uint64_t speed); +BdrvDirtyBitmap *block_copy_dirty_bitmap (BlockCopyState *s);void block_copy_set_skip_unallocated (BlockCopyState *s,bool skip);
block/block-copy.c +44 -0
88 lines not on this page · raw message
Signature · 1 line
2.21.0
RFC 18/24 block/block-copy: add block_copy_cancel
In reply to Vladimir Sementsov-OgievskiyAdd function to cancel running async block-copy call. It will be used in backup.
--- include/block/block-copy.h | 7 +++++++ block/block-copy.c | 20 ++++++++++++++++++-- 2 files changed, 25 insertions(+), 2 deletions(-)
include/block/block-copy.h +7 -0
@@ -67,6 +67,13 @@ BlockCopyCallState *block_copy_async(BlockCopyState *s,void block_copy_set_speed (BlockCopyState *s,BlockCopyCallState *call_state,uint64_t speed); +/* +* Cancel running block-copy call. +* Cancel leaves block-copy state valid: dirty bits are correct and you may use +* cancel + <run block_copy with same parameters> to emulate pause/resume. +*/ +void block_copy_cancel (BlockCopyCallState *call_state); +BdrvDirtyBitmap *block_copy_dirty_bitmap (BlockCopyState *s);void block_copy_set_skip_unallocated (BlockCopyState *s,bool skip);
block/block-copy.c +18 -2
@@ -42,6 +42,8 @@ typedef struct BlockCopyCallState {bool failed;bool finished;QemuCoSleepState *sleep_state; +bool cancelled; +Coroutine *canceller;/* OUT parameters */ bool error_is_read;
@@ -553,7 +555,7 @@ block_copy_dirty_clusters(BlockCopyCallState *call_state)assert (QEMU_IS_ALIGNED (offset, s->cluster_size));assert (QEMU_IS_ALIGNED (bytes, s->cluster_size)); -while (bytes &&aio_task_pool_status (aio) ==0 ) { +while (bytes &&aio_task_pool_status (aio) ==0 && !call_state->cancelled) {BlockCopyTask *task;int64_t status_bytes;
@@ -639,7 +641,7 @@ static int coroutine_fn block_copy_common(BlockCopyCallState *call_state)while (true) { ret =block_copy_dirty_clusters (call_state); -if (ret <0 ) { +if (ret <0 || call_state->cancelled) {/* * IO operation failed, which means the whole block_copy request * failed.
@@ -673,6 +675,11 @@ static int coroutine_fn block_copy_common(BlockCopyCallState *call_state) call_state->s->progress_opaque); } +if (call_state->canceller) { +aio_co_wake (call_state->canceller); + call_state->canceller =NULL ; + } + call_state->finished = true;return ret;
@@ -731,6 +738,15 @@ BlockCopyCallState *block_copy_async(BlockCopyState *s,return call_state; } + +void block_copy_cancel (BlockCopyCallState *call_state) +{ + call_state->cancelled = true; + call_state->canceller =qemu_coroutine_self (); +block_copy_kick (call_state); +qemu_coroutine_yield (); +} +BdrvDirtyBitmap *block_copy_dirty_bitmap (BlockCopyState *s) {return s->copy_bitmap;
Signature · 1 line
2.21.0
RFC 19/24 blockjob: add set_speed to BlockJobDriver
In reply to Vladimir Sementsov-OgievskiyWe are going to use async block-copy call in backup, so we'll need to passthrough setting backup speed to block-copy call.
--- include/block/blockjob_int.h | 2 ++ blockjob.c | 6 ++++++ 2 files changed, 8 insertions(+)
include/block/blockjob_int.h +2 -0
@@ -52,6 +52,8 @@ struct BlockJobDriver {* besides job->blk to the new AioContext. */ void (*attached_aio_context)(BlockJob *job,AioContext *new_context); + +void (*set_speed)(BlockJob *job,int64_t speed); };/**
blockjob.c +6 -0
@@ -255,6 +255,7 @@ static bool job_timer_pending(Job *job)void block_job_set_speed (BlockJob *job,int64_t speed,Error **errp) { +const BlockJobDriver *drv =block_job_driver (job);int64_t old_speed = job->speed;if (job_apply_verb (&job->job,JOB_VERB_SET_SPEED , errp)) {
@@ -268,6 +269,11 @@ void block_job_set_speed(BlockJob *job, int64_t speed, Error **errp)ratelimit_set_speed (&job->limit, speed,BLOCK_JOB_SLICE_TIME ); job->speed = speed; + +if (drv->set_speed) { + drv->set_speed (job, speed); + } +if (speed && speed <= old_speed) {return ; }
Signature · 1 line
2.21.0
RFC 20/24 job: call job_enter from job_user_pause
In reply to Vladimir Sementsov-OgievskiyIf main job coroutine called job_yield (while some background process is in progress), we should give it a chance to call job_pause_point(). It will be used in backup, when moved on async block-copy.
--- job.c | 1 + 1 file changed, 1 insertion(+)
job.c +1 -0
@@ -557,6 +557,7 @@ void job_user_pause(Job *job, Error **errp) } job->user_paused = true;job_pause (job); +job_enter (job); }bool job_user_paused (Job *job)
Signature · 1 line
2.21.0
RFC 21/24 backup: move to block-copy
In reply to Vladimir Sementsov-OgievskiyThis brings async request handling and block-status driven chunk sizes to backup out of the box, which improves backup performance.
--- qapi/block-core.json | 9 +- include/block/block_int.h | 7 + block/backup.c | 159 +++++++++++-------- block/replication.c | 1 + blockdev.c | 5 + tests/qemu-iotests/129 | 3 +- tests/qemu-iotests/185 | 3 +- tests/qemu-iotests/219 | 1 + tests/qemu-iotests/257 | 1 + tests/qemu-iotests/257.out | 306 ++++++++++++++++++------------------- 10 files changed, 276 insertions(+), 219 deletions(-)
qapi/block-core.json +8 -1
@@ -1455,6 +1455,12 @@ # above node specified by @drive. If this option is not given, # a node name is autogenerated. (Since: 4.2) # +# @x-max-workers: maximum of parallel requests for static data backup. This +# doesn't influence copy-before-write operations. (Since: 4.3) +# +# @x-max-chunk: maximum chunk length for static data backup. This doesn't +# influence copy-before-write operations. (Since: 4.3) +# # Note: @on-source-error and @on-target-error only affect background # I/O. If an error occurs during a guest write request, the device's # rerror/werror actions will be used.
@@ -1469,7 +1475,8 @@ '*on-source-error': 'BlockdevOnError', '*on-target-error': 'BlockdevOnError', '*auto-finalize': 'bool', '*auto-dismiss': 'bool', - '*filter-node-name': 'str' } } + '*filter-node-name': 'str', '*x-max-workers': 'int', + '*x-max-chunk': 'int64' } } ## # @DriveBackup:
include/block/block_int.h +7 -0
@@ -1193,6 +1193,11 @@ void mirror_start(const char *job_id, BlockDriverState *bs,* @sync_mode: What parts of the disk image should be copied to the destination. * @sync_bitmap: The dirty bitmap if sync_mode is 'bitmap' or 'incremental' * @bitmap_mode: The bitmap synchronization policy to use. +* @max_workers: The limit for parallel requests for main backup loop. +* Must be >= 1. +* @max_chunk: The limit for one IO operation length in main backup loop. +* Must be not less than job cluster size or zero. Zero means no +* specific limit. * @on_source_error: The action to take upon error reading from the source. * @on_target_error: The action to take upon error writing to the target. * @creation_flags: Flags that control the behavior of the Job lifetime.
@@ -1211,6 +1216,8 @@ BlockJob *backup_job_create(const char *job_id, BlockDriverState *bs,BitmapSyncMode bitmap_mode, bool compress, const char *filter_node_name, + int max_workers, + int64_t max_chunk, BlockdevOnError on_source_error, BlockdevOnError on_target_error, int creation_flags,
block/backup.c +97 -62
243 lines not on this page · raw message
block/replication.c +1 -0
@@ -544,6 +544,7 @@ static void replication_start(ReplicationState *rs, ReplicationMode mode, s->backup_job =backup_job_create (NULL , s->secondary_disk->bs, s->hidden_disk->bs,0 ,MIRROR_SYNC_MODE_NONE ,NULL ,0 , false,NULL , +0 ,0 ,BLOCKDEV_ON_ERROR_REPORT ,BLOCKDEV_ON_ERROR_REPORT ,JOB_INTERNAL , backup_job_completed, bs,NULL , &local_err);
blockdev.c +5 -0
@@ -3502,6 +3502,9 @@ static BlockJob *do_backup_common(BackupCommon *backup,if (!backup->has_compress) { backup->compress = false; } +if (!backup->has_x_max_workers) { + backup->x_max_workers =64 ; + } ret =bdrv_try_set_aio_context (target_bs, aio_context, errp);if (ret <0 ) {
@@ -3581,6 +3584,8 @@ static BlockJob *do_backup_common(BackupCommon *backup, backup->sync, bmap, backup->bitmap_mode, backup->compress, backup->filter_node_name, + backup->x_max_workers, + backup->x_max_chunk, backup->on_source_error, backup->on_target_error, job_flags, NULL, NULL, txn, errp);
tests/qemu-iotests/129 +1 -2
@@ -66,7 +66,6 @@ class TestStopWithBlockJob(iotests.QMPTestCase): result = self.vm.qmp("stop") self.assert_qmp(result, 'return', {}) result = self.vm.qmp("query-block-jobs") - self.assert_qmp(result, 'return[0]/busy', True) self.assert_qmp(result, 'return[0]/ready', False) def test_drive_mirror(self):
@@ -77,7 +76,7 @@ class TestStopWithBlockJob(iotests.QMPTestCase): def test_drive_backup(self): self.do_test_stop("drive-backup", device="drive0", target=self.target_img, - sync="full") + sync="full", speed=1024) def test_block_commit(self): self.do_test_stop("block-commit", device="drive0")
tests/qemu-iotests/185 +2 -1
@@ -182,7 +182,8 @@ _send_qemu_cmd $h \ 'target': '$TEST_IMG.copy', 'format': '$IMGFMT', 'sync': 'full', - 'speed': 65536 } }" \ + 'speed': 65536, + 'x-max-chunk': 65536 } }" \ "return" # If we don't sleep here 'quit' command races with disk I/O
tests/qemu-iotests/219 +1 -0
@@ -223,6 +223,7 @@ with iotests.FilePath('disk.img') as disk_path, \ 'target': copy_path, 'sync': 'full', 'speed': 262144, + 'x-max-chunk': 65536, 'auto-finalize': auto_finalize, 'auto-dismiss': auto_dismiss, })
tests/qemu-iotests/257 +1 -0
@@ -191,6 +191,7 @@ def blockdev_backup(vm, device, target, sync, **kwargs): target=target, sync=sync, filter_node_name='backup-top', + x_max_workers=1, **kwargs) return result
tests/qemu-iotests/257.out +153 -153
1,043 lines not on this page · raw message
Signature · 1 line
2.21.0
Re: [RFC 21/24] backup: move to block-copy
Quoted 8 lines · Vladimir Sementsov-Ogievskiy
This brings async request handling and block-status driven chunk sizes to backup out of the box, which improves backup performance.
Signed-off-by Vladimir Sementsov-Ogievskiy <[email protected]>---
+++
b/qapi/block-core.json
qapi/block-core.json line 1462
Quoted 8 lines
qapi/block-core.json +5
-0@@ -1455,6 +1455,12 @@ # above node specified by @drive. If this option is not given, # a node name is autogenerated. (Since: 4.2) # +# @x-max-workers: maximum of parallel requests for static data backup. This +# doesn't influence copy-before-write operations. (Since: 4.3) +# +# @x-max-chunk: maximum chunk length for static data backup. This doesn't +# influence copy-before-write operations. (Since: 4.3)
The next release is 5.0, not 4.3.
Is there a reason to keep these experimental for a while? For example, are there potential changes to the interface that might affect how it gets used? Or should we drop the x- prefix and add this outright in 5.0?
Signature · 3 lines
Eric Blake, Principal Software Engineer Red Hat, Inc. +1-919-301-3226 Virtualization: qemu.org | libvirt.org
Re: [RFC 21/24] backup: move to block-copy
Quoted 20 lines · Eric Blake
Quoted 8 lines · Vladimir Sementsov-Ogievskiy
This brings async request handling and block-status driven chunk sizes to backup out of the box, which improves backup performance.
Signed-off-by Vladimir Sementsov-Ogievskiy <[email protected]>---
+++
b/qapi/block-core.jsonqapi/block-core.json line 1462
Quoted 8 lines
qapi/block-core.json +5
-0@@ -1455,6 +1455,12 @@ # above node specified by @drive. If this option is not given, # a node name is autogenerated. (Since: 4.2) # +# @x-max-workers: maximum of parallel requests for static data backup. This +# doesn't influence copy-before-write operations. (Since: 4.3) +# +# @x-max-chunk: maximum chunk length for static data backup. This doesn't +# influence copy-before-write operations. (Since: 4.3)The next release is 5.0, not 4.3.
Quoted 2 lines
Is there a reason to keep these experimental for a while? For example, are there potential changes to the interface that might affect how it gets used? Or should we drop the x- prefix and add this outright in 5.0?
Hmm, I added these options to satisfy some very conservative iotests. Still, they may be meaningful for user too.
The only real doubt is that actually they are options of block-copy, not backup job. And to not finish up with adding such parameters to each block-job, it may be better to combine them into a structure.. Or may be not.
Signature · 2 lines
Best regards, Vladimir
RFC 22/24 python: add simplebench.py
In reply to Vladimir Sementsov-OgievskiyAdd simple benchmark table creator.
--- python/simplebench.py | 122 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 122 insertions(+) create mode 100644 python/simplebench.py
python/simplebench.py new file +122 -0
@@ -0,0 +1,122 @@ +#!/usr/bin/env python +# +# Simple benchmarking framework +# +# Copyright (c) 2019 Virtuozzo International GmbH. +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see <http://www.gnu.org/licenses/>. +# + + +def bench_one(test_func, test_env, test_case, count=5, initial_run=True): + """Benchmark one test-case + + test_func -- benchmarking function with prototype + test_func(env, case), which takes test_env and test_case + arguments and returns {'seconds': int} (which is benchmark + result) on success and {'error': str} on error. Returned + dict may contain any other additional fields. + test_env -- test environment - opaque first argument for test_func + test_case -- test case - opaque second argument for test_func + count -- how many times to call test_func, to calculate average + initial_run -- do initial run of test_func, which don't get into result + + Returns dict with the following fields: + 'runs': list of test_func results + 'average': average seconds per run (exists only if at least one run + succeeded) + 'delta': maximum delta between test_func result and the average + (exists only if at least one run succeeded) + 'n-failed': number of failed runs (exists only if at least one run + failed) + """ + if initial_run: + test_func(test_env, test_case) + + runs = [test_func(test_env, test_case) for _ in range(count)] + + result = {'runs': runs} + + successed = [r for r in runs if ('seconds' in r)] + if successed: + avg = sum(r['seconds'] for r in successed) / len(successed) + result['average'] = avg + result['delta'] = max(abs(r['seconds'] - avg) for r in successed) + + if len(successed) < count: + result['n-failed'] = count - len(successed) + + return result + + +def ascii_one(result): + """Return ASCII representation of bench_one() returned dict.""" + if 'average' in result: + s = '{:.2f} +- {:.2f}'.format(result['average'], result['delta']) + if 'n-failed' in result: + s += '\n({} failed)'.format(result['n-failed']) + return s + else: + return 'FAILED' + + +def bench(test_func, test_envs, test_cases, *args, **vargs): + """Fill benchmark table + + test_func -- benchmarking function, see bench_one for description + test_envs -- list of test environments, see bench_one + test_cases -- list of test cases, see bench_one + args, vargs -- additional arguments for bench_one + + Returns dict with the following fields: + 'envs': test_envs + 'cases': test_cases + 'tab': filled 2D array, where cell [i][j] is bench_one result for + test_cases[i] for test_envs[j] (i.e., rows are test cases and + columns are test environments) + """ + tab = {} + results = { + 'envs': test_envs, + 'cases': test_cases, + 'tab': tab + } + n = 1 + n_tests = len(test_envs) * len(test_cases) + for env in test_envs: + for case in test_cases: + print('Testing {}/{}: {} :: {}'.format(n, n_tests, + env['id'], case['id'])) + if case['id'] not in tab: + tab[case['id']] = {} + tab[case['id']][env['id']] = bench_one(test_func, env, case, + *args, **vargs) + n += 1 + + print('Done') + return results + + +def ascii(results): + """Return ASCII representation of bench() returned dict.""" + from tabulate import tabulate + + tab = [[""] + [c['id'] for c in results['envs']]] + for case in results['cases']: + row = [case['id']] + for env in results['envs']: + row.append(ascii_one(results['tab'][case['id']][env['id']])) + tab.append(row) + + return tabulate(tab)
Signature · 1 line
2.21.0
RFC 23/24 python: add qemu/bench_block_job.py
In reply to Vladimir Sementsov-OgievskiyAdd block-job benchmarking helper functions.
--- python/qemu/bench_block_job.py | 114 +++++++++++++++++++++++++++++++++ 1 file changed, 114 insertions(+) create mode 100755 python/qemu/bench_block_job.py
python/qemu/bench_block_job.py new file +114 -0
@@ -0,0 +1,114 @@ +#!/usr/bin/env python +# +# Benchmark block jobs +# +# Copyright (c) 2019 Virtuozzo International GmbH. +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see <http://www.gnu.org/licenses/>. +# + + +import socket +import json +from .machine import QEMUMachine + + +def bench_block_job(cmd, cmd_args, qemu_args): + """Benchmark block-job + + cmd -- qmp command to run block-job (like blockdev-backup) + cmd_args -- dict of qmp command arguments + qemu_args -- list of Qemu command line arguments, including path to Qemu + binary + + Returns {'seconds': int} on success and {'error': str} on failure, dict may + contain addional 'vm-log' field. Return value is compatible with + simplebench lib. + """ + + vm = QEMUMachine(qemu_args[0], args=qemu_args[1:]) + + try: + vm.launch() + except OSError as e: + return {'error': 'popen failed: ' + str(e)} + except socket.timeout: + return {'error': 'qemu failed: ' + str(vm.get_log())} + + try: + res = vm.qmp(cmd, **cmd_args) + if res != {'return': {}}: + vm.shutdown() + return {'error': '"{}" command failed: {}'.format(cmd, str(res))} + + e = vm.event_wait('JOB_STATUS_CHANGE') + assert e['data']['status'] == 'created' + start_ms = e['timestamp']['seconds'] * 1000000 + \ + e['timestamp']['microseconds'] + + e = vm.events_wait((('BLOCK_JOB_READY', None), + ('BLOCK_JOB_COMPLETED', None), + ('BLOCK_JOB_FAILED', None)), timeout=True) + if e['event'] not in ('BLOCK_JOB_READY', 'BLOCK_JOB_COMPLETED'): + vm.shutdown() + return {'error': 'block-job failed: ' + str(e), + 'vm-log': vm.get_log()} + end_ms = e['timestamp']['seconds'] * 1000000 + \ + e['timestamp']['microseconds'] + finally: + vm.shutdown() + + return {'seconds': (end_ms - start_ms) / 1000000.0} + + +# Bench backup or mirror +def bench_block_copy(qemu_binary, cmd, source, target): + """Helper to run bench_block_job() for mirror or backup""" + assert cmd in ('blockdev-backup', 'blockdev-mirror') + + source['node-name'] = 'source' + target['node-name'] = 'target' + + return bench_block_job(cmd, + {'job-id': 'job0', 'device': 'source', + 'target': 'target', 'sync': 'full'}, + [qemu_binary, + '-blockdev', json.dumps(source), + '-blockdev', json.dumps(target)]) + + +def drv_file(filename): + return {'driver': 'file', 'filename': filename, + 'cache': {'direct': True}, 'aio': 'native'} + + +def drv_nbd(host, port): + return {'driver': 'nbd', + 'server': {'type': 'inet', 'host': host, 'port': port}} + + +if __name__ == '__main__': + import sys + + if len(sys.argv) < 4: + print('USAGE: {} <qmp block-job command name> ' + '<json string of arguments for the command> ' + '<qemu binary path and arguments>'.format(sys.argv[0])) + exit(1) + + res = bench_block_job(sys.argv[1], json.loads(sys.argv[2]), sys.argv[3:]) + if 'seconds' in res: + print('{:.2f}'.format(res['seconds'])) + else: + print(res)
Signature · 1 line
2.21.0
RFC 24/24 python: benchmark new backup architecture
In reply to Vladimir Sementsov-OgievskiyBenchmark test for the series. This patch is RFC, it would be strange to commit it as is.. On the other hand I feel that we should commit some example to show usage of simplebench and bench_block_job.
May be I should add some simple example to compare backup and mirror.. Any ideas?
Anyway, this patch is here to show, how I produced the table in the series cover-letter.
Note that all used images are 1000M files filled by ones, including images exported by two running NBD servers, and NBD servers are running as:
qemu-nbd --persistent --nocache -p 10810 ones1000M-source qemu-nbd --persistent --nocache -p 10809 ones1000M-target
--- python/bench-example.py | 93 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 93 insertions(+) create mode 100755 python/bench-example.py
python/bench-example.py new file +93 -0
@@ -0,0 +1,93 @@ +#!/usr/bin/env python3 + +import simplebench +from qemu.bench_block_job import bench_block_copy, drv_file, drv_nbd + + +def bench_func(env, case): + return bench_block_copy(env['qemu_binary'], env['cmd'], + case['source'], case['target']) + + +test_cases = [ + { + 'id': 'ssd -> ssd', + 'source': drv_file('/ssd/ones1000M-source'), + 'target': drv_file('/ssd/ones1000M-target') + }, + { + 'id': 'ssd -> hdd', + 'source': drv_file('/ssd/ones1000M-source'), + 'target': drv_file('/test-a/ones1000M-target') + }, + { + 'id': 'hdd -> hdd', + 'source': drv_file('/test-a/ones1000M-source'), + 'target': drv_file('/test-a/ones1000M-target') + } +] + +test_envs = [ + { + 'id': 'backup-old', + 'cmd': 'blockdev-backup', + 'qemu_binary': '/work/src/qemu/up-block-copy-block-status--before/x86_64-softmmu/qemu-system-x86_64' + }, + { + 'id': 'backup-old(no CR)', + 'cmd': 'blockdev-backup', + 'qemu_binary': '/work/src/qemu/up-block-copy-block-status--before--no-copy-range/x86_64-softmmu/qemu-system-x86_64' + }, + { + 'id': 'backup-new', + 'cmd': 'blockdev-backup', + 'qemu_binary': '/work/src/qemu/up-block-copy-block-status/x86_64-softmmu/qemu-system-x86_64' + }, + { + 'id': 'backup-new(no CR)', + 'cmd': 'blockdev-backup', + 'qemu_binary': '/work/src/qemu/up-block-copy-block-status--no-copy_range/x86_64-softmmu/qemu-system-x86_64' + }, + { + 'id': 'mirror', + 'cmd': 'blockdev-mirror', + 'qemu_binary': '/work/src/qemu/up-block-copy-block-status/x86_64-softmmu/qemu-system-x86_64' + } +] + +result = simplebench.bench(bench_func, test_envs, test_cases, count=3) +print(simplebench.ascii(result)) + +test_cases = [ + { + 'id': 'nbd -> ssd', + 'source': drv_nbd('172.16.24.200', '10810'), + 'target': drv_file('/ssd/ones1000M-target') + }, + { + 'id': 'ssd -> nbd', + 'source': drv_file('/ssd/ones1000M-target'), + 'target': drv_nbd('172.16.24.200', '10809') + }, +] + +test_envs = [ + { + 'id': 'backup-old', + 'cmd': 'blockdev-backup', + 'qemu_binary': '/work/src/qemu/up-block-copy-block-status--before/x86_64-softmmu/qemu-system-x86_64' + }, + { + 'id': 'backup-new', + 'cmd': 'blockdev-backup', + 'qemu_binary': '/work/src/qemu/up-block-copy-block-status/x86_64-softmmu/qemu-system-x86_64' + }, + { + 'id': 'mirror', + 'cmd': 'blockdev-mirror', + 'qemu_binary': '/work/src/qemu/up-block-copy-block-status/x86_64-softmmu/qemu-system-x86_64' + } +] + +result = simplebench.bench(bench_func, test_envs, test_cases, count=2) +print(simplebench.ascii(result))
Signature · 1 line
2.21.0
Patchew URL: https://patchew.org/QEMU/[email protected]/
Patchew URL: https://patchew.org/QEMU/[email protected]/
Hi,
This series seems to have some coding style problems. See output below for more information:
Subject: [RFC 00/24] backup performance: block_status + async
Type: series
Message-id: [email protected]
=== TEST SCRIPT BEGIN ===
#!/bin/bash
git rev-parse base > /dev/null || exit 0
git config --local diff.renamelimit 0
git config --local diff.renames True
git config --local diff.algorithm histogram./scripts/checkpatch.pl --mailback base..
=== TEST SCRIPT END ===
Updating 3c8cf5a9c21ff8782164d1def7f44bd888713384
Switched to a new branch 'test'
b3ea574 python: benchmark new backup architecture
899a413 python: add qemu/bench_block_job.py
46552d2 python: add simplebench.py
e20f1fb backup: move to block-copy
9b0e5f0 job: call job_enter from job_user_pause
fcc0a72 blockjob: add set_speed to BlockJobDriver
62d85a7 block/block-copy: add block_copy_cancel
19066cf block/block-copy: add ratelimit to block-copy
db53990 block/block-copy: add max_chunk and max_workers paramters 97fe936 block/block-copy: implement block_copy_async
feb18da block/block-copy: More explicit call_state
5f9fd94 block/block-copy: use aio-task-pool API
94a4f4f block/block-copy: move block_copy_task_create down 74bc1b1 block/block-copy: move task size initial calculation to _task_create aaf398c block/block-copy: add state pointer to BlockCopyTask 5c4dbd2 block/block-copy: alloc task on each iteration
44e698f block/block-copy: rename in-flight requests to tasks 6d78584 block/block-copy: hide structure definitions
4b541b5 block/block-copy: reduce intersecting request lock 33d4eb1 block/block-copy: rename start to offset in interfaces d74cc59 block/block-copy: refactor interfaces to use bytes instead of end bc4e836 block/block-copy: factor out block_copy_find_inflight_req f22200c block/block-copy: use block_status
5c23778 block/block-copy: specialcase first copy_range request
=== OUTPUT BEGIN ===
1/24 Checking commit 5c23778bb3f4 (block/block-copy: specialcase first copy_range request) 2/24 Checking commit f22200c5b50a (block/block-copy: use block_status)
3/24 Checking commit bc4e83640682 (block/block-copy: factor out block_copy_find_inflight_req) 4/24 Checking commit d74cc59b9921 (block/block-copy: refactor interfaces to use bytes instead of end) 5/24 Checking commit 33d4eb118fd6 (block/block-copy: rename start to offset in interfaces) 6/24 Checking commit 4b541b586cbf (block/block-copy: reduce intersecting request lock) 7/24 Checking commit 6d785845c236 (block/block-copy: hide structure definitions)
8/24 Checking commit 44e698fcabd9 (block/block-copy: rename in-flight requests to tasks) 9/24 Checking commit 5c4dbd281da7 (block/block-copy: alloc task on each iteration)
10/24 Checking commit aaf398c95343 (block/block-copy: add state pointer to BlockCopyTask) 11/24 Checking commit 74bc1b1a2719 (block/block-copy: move task size initial calculation to _task_create) 12/24 Checking commit 94a4f4fbaf78 (block/block-copy: move block_copy_task_create down) 13/24 Checking commit 5f9fd943c782 (block/block-copy: use aio-task-pool API)
14/24 Checking commit feb18da8d233 (block/block-copy: More explicit call_state)
15/24 Checking commit 97fe9366ea2b (block/block-copy: implement block_copy_async)
16/24 Checking commit db5399013d42 (block/block-copy: add max_chunk and max_workers paramters) 17/24 Checking commit 19066cfd3aeb (block/block-copy: add ratelimit to block-copy)
18/24 Checking commit 62d85a7434d8 (block/block-copy: add block_copy_cancel)
19/24 Checking commit fcc0a7228683 (blockjob: add set_speed to BlockJobDriver)
20/24 Checking commit 9b0e5f043396 (job: call job_enter from job_user_pause)
21/24 Checking commit e20f1fb84dd4 (backup: move to block-copy)
22/24 Checking commit 46552d28b459 (python: add simplebench.py)
WARNING: added, moved or deleted file(s), does MAINTAINERS need updating?
#13:
new file mode 100644
total: 0 errors, 1 warnings, 122 lines checked
Patch 22/24 has style problems, please review. If any of these errors are false positives report them to the maintainer, see CHECKPATCH in MAINTAINERS.
23/24 Checking commit 899a41312a82 (python: add qemu/bench_block_job.py)
WARNING: added, moved or deleted file(s), does MAINTAINERS need updating? #13:
new file mode 100755
total: 0 errors, 1 warnings, 114 lines checked
Patch 23/24 has style problems, please review. If any of these errors are false positives report them to the maintainer, see
CHECKPATCH in MAINTAINERS.
24/24 Checking commit b3ea574749ec (python: benchmark new backup architecture)
WARNING: added, moved or deleted file(s), does MAINTAINERS need updating? #28:
new file mode 100755
ERROR: line over 90 characters
#66: FILE: python/bench-example.py:34:
+ 'qemu_binary': '/work/src/qemu/up-block-copy-block-status--before/x86_64-softmmu/qemu-system-x86_64'
ERROR: line over 90 characters
#71: FILE: python/bench-example.py:39:
+ 'qemu_binary': '/work/src/qemu/up-block-copy-block-status--before--no-copy-range/x86_64-softmmu/qemu-system-x86_64'
ERROR: line over 90 characters
#76: FILE: python/bench-example.py:44:
+ 'qemu_binary': '/work/src/qemu/up-block-copy-block-status/x86_64-softmmu/qemu-system-x86_64'
ERROR: line over 90 characters
#81: FILE: python/bench-example.py:49:
+ 'qemu_binary': '/work/src/qemu/up-block-copy-block-status--no-copy_range/x86_64-softmmu/qemu-system-x86_64'
ERROR: line over 90 characters
#86: FILE: python/bench-example.py:54:
+ 'qemu_binary': '/work/src/qemu/up-block-copy-block-status/x86_64-softmmu/qemu-system-x86_64'
ERROR: line over 90 characters
#110: FILE: python/bench-example.py:78:
+ 'qemu_binary': '/work/src/qemu/up-block-copy-block-status--before/x86_64-softmmu/qemu-system-x86_64'
ERROR: line over 90 characters
#115: FILE: python/bench-example.py:83:
+ 'qemu_binary': '/work/src/qemu/up-block-copy-block-status/x86_64-softmmu/qemu-system-x86_64'
ERROR: line over 90 characters
#120: FILE: python/bench-example.py:88:
+ 'qemu_binary': '/work/src/qemu/up-block-copy-block-status/x86_64-softmmu/qemu-system-x86_64'
total: 8 errors, 1 warnings, 93 lines checked
Patch 24/24 has style problems, please review. If any of these errors are false positives report them to the maintainer, see CHECKPATCH in MAINTAINERS.
=== OUTPUT END ===
Test command exited with code: 1
The full log is available at
http://patchew.org/logs/[email protected]/testing.checkpatch/?type=message.
---
Email generated automatically by Patchew [https://patchew.org/].
Please send your feedback to [email protected]
Quoted 120 lines · 15.11.2019 20:30, [email protected] wrote:
Patchew URL: https://patchew.org/QEMU/[email protected]/
Hi,
This series seems to have some coding style problems. See output below for more information:
Subject: [RFC 00/24] backup performance:
block_status+ async
Type: series
Message-id: [email protected]=== TEST SCRIPT BEGIN ===
#!/bin/bash
git rev-parse base >/dev/null|| exit 0
git config --local diff.renamelimit 0
git config --local diff.renames True
git config --local diff.algorithm histogram./scripts/checkpatch.pl--mailback base..
=== TEST SCRIPT END ===Updating
3c8cf5a9c21ff8782164d1def7f44bd888713384
Switched to a new branch 'test'
b3ea574 python: benchmark new backup architecture
899a413 python: addqemu/bench_block_job.py
46552d2 python: addsimplebench.py
e20f1fb backup: move to block-copy
9b0e5f0 job: calljob_enterfromjob_user_pause
fcc0a72 blockjob: addset_speedto BlockJobDriver
62d85a7block/block-copy: addblock_copy_cancel
19066cfblock/block-copy: add ratelimit to block-copy
db53990block/block-copy: addmax_chunkandmax_workersparamters 97fe936block/block-copy: implementblock_copy_async
feb18dablock/block-copy: More explicitcall_state
5f9fd94block/block-copy: use aio-task-pool API
94a4f4fblock/block-copy: moveblock_copy_task_createdown 74bc1b1block/block-copy: move task size initial calculation to_task_createaaf398cblock/block-copy: add state pointer to BlockCopyTask 5c4dbd2block/block-copy: alloc task on each iteration
44e698fblock/block-copy: rename in-flight requests to tasks 6d78584block/block-copy: hide structure definitions
4b541b5block/block-copy: reduce intersecting request lock 33d4eb1block/block-copy: rename start to offset in interfaces d74cc59block/block-copy: refactor interfaces to use bytes instead of end bc4e836block/block-copy: factor outblock_copy_find_inflight_reqf22200cblock/block-copy: useblock_status
5c23778block/block-copy: specialcase firstcopy_rangerequest=== OUTPUT BEGIN ===
1/24 Checking commit5c23778bb3f4(block/block-copy: specialcase firstcopy_rangerequest) 2/24 Checking commitf22200c5b50a(block/block-copy: useblock_status)
3/24 Checking commitbc4e83640682(block/block-copy: factor outblock_copy_find_inflight_req) 4/24 Checking commitd74cc59b9921(block/block-copy: refactor interfaces to use bytes instead of end) 5/24 Checking commit33d4eb118fd6(block/block-copy: rename start to offset in interfaces) 6/24 Checking commit4b541b586cbf(block/block-copy: reduce intersecting request lock) 7/24 Checking commit6d785845c236(block/block-copy: hide structure definitions)
8/24 Checking commit44e698fcabd9(block/block-copy: rename in-flight requests to tasks) 9/24 Checking commit5c4dbd281da7(block/block-copy: alloc task on each iteration)
10/24 Checking commitaaf398c95343(block/block-copy: add state pointer to BlockCopyTask) 11/24 Checking commit74bc1b1a2719(block/block-copy: move task size initial calculation to_task_create) 12/24 Checking commit94a4f4fbaf78(block/block-copy: moveblock_copy_task_createdown) 13/24 Checking commit5f9fd943c782(block/block-copy: use aio-task-pool API)
14/24 Checking commitfeb18da8d233(block/block-copy: More explicitcall_state)
15/24 Checking commit97fe9366ea2b(block/block-copy: implementblock_copy_async)
16/24 Checking commitdb5399013d42(block/block-copy: addmax_chunkandmax_workersparamters) 17/24 Checking commit19066cfd3aeb(block/block-copy: add ratelimit to block-copy)
18/24 Checking commit62d85a7434d8(block/block-copy: addblock_copy_cancel)
19/24 Checking commitfcc0a7228683(blockjob: addset_speedto BlockJobDriver)
20/24 Checking commit9b0e5f043396(job: calljob_enterfromjob_user_pause)
21/24 Checking commite20f1fb84dd4(backup: move to block-copy)
22/24 Checking commit46552d28b459(python: addsimplebench.py)
WARNING: added, moved or deleted file(s), doesMAINTAINERSneed updating?
#13:
new file mode 100644total: 0 errors, 1 warnings, 122 lines checked
Patch 22/24 has style problems, please review. If any of these errors are false positives report them to the maintainer, see CHECKPATCH in
MAINTAINERS.
23/24 Checking commit899a41312a82(python: addqemu/bench_block_job.py)
WARNING: added, moved or deleted file(s), doesMAINTAINERSneed updating? #13:
new file mode 100755total: 0 errors, 1 warnings, 114 lines checked
Patch 23/24 has style problems, please review. If any of these errors are false positives report them to the maintainer, see
CHECKPATCH inMAINTAINERS.
24/24 Checking commitb3ea574749ec(python: benchmark new backup architecture)
WARNING: added, moved or deleted file(s), doesMAINTAINERSneed updating? #28:
new file mode 100755ERROR: line over 90 characters
#66: FILE:python/bench-example.py:34:
+ 'qemu_binary': '/work/src/qemu/up-block-copy-block-status--before/x86_64-softmmu/qemu-system-x86_64'ERROR: line over 90 characters
#71: FILE:python/bench-example.py:39:
+ 'qemu_binary': '/work/src/qemu/up-block-copy-block-status--before--no-copy-range/x86_64-softmmu/qemu-system-x86_64'ERROR: line over 90 characters
#76: FILE:python/bench-example.py:44:
+ 'qemu_binary': '/work/src/qemu/up-block-copy-block-status/x86_64-softmmu/qemu-system-x86_64'ERROR: line over 90 characters
#81: FILE:python/bench-example.py:49:
+ 'qemu_binary': '/work/src/qemu/up-block-copy-block-status--no-copy_range/x86_64-softmmu/qemu-system-x86_64'ERROR: line over 90 characters
#86: FILE:python/bench-example.py:54:
+ 'qemu_binary': '/work/src/qemu/up-block-copy-block-status/x86_64-softmmu/qemu-system-x86_64'ERROR: line over 90 characters
#110: FILE:python/bench-example.py:78:
+ 'qemu_binary': '/work/src/qemu/up-block-copy-block-status--before/x86_64-softmmu/qemu-system-x86_64'
Quoted 8 lines
ERROR: line over 90 characters
#115: FILE:python/bench-example.py:83:
+ 'qemu_binary': '/work/src/qemu/up-block-copy-block-status/x86_64-softmmu/qemu-system-x86_64'ERROR: line over 90 characters
#120: FILE:python/bench-example.py:88:
+ 'qemu_binary': '/work/src/qemu/up-block-copy-block-status/x86_64-softmmu/qemu-system-x86_64'
I know. still I decided to keep it as is, this patch is not for commit anyway.. My fs paths make sense only for me I think.
Quoted 17 lines
total: 8 errors, 1 warnings, 93 lines checked
Patch 24/24 has style problems, please review. If any of these errors are false positives report them to the maintainer, see CHECKPATCH in
MAINTAINERS.=== OUTPUT END ===
Test command exited with code: 1
The full log is available at
http://patchew.org/logs/[email protected]/testing.checkpatch/?type=message.
---
Email generated automatically by Patchew [https://patchew.org/].
Please send your feedback to [email protected]
Signature · 2 lines
Best regards, Vladimir