2013-06-24 19:13:11 +04:00
|
|
|
/*
|
|
|
|
* QEMU backup
|
|
|
|
*
|
|
|
|
* Copyright (C) 2013 Proxmox Server Solutions
|
|
|
|
*
|
|
|
|
* Authors:
|
|
|
|
* Dietmar Maurer (dietmar@proxmox.com)
|
|
|
|
*
|
|
|
|
* This work is licensed under the terms of the GNU GPL, version 2 or later.
|
|
|
|
* See the COPYING file in the top-level directory.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2016-01-18 21:01:42 +03:00
|
|
|
#include "qemu/osdep.h"
|
2013-06-24 19:13:11 +04:00
|
|
|
|
|
|
|
#include "trace.h"
|
|
|
|
#include "block/block.h"
|
|
|
|
#include "block/block_int.h"
|
2016-10-27 19:07:00 +03:00
|
|
|
#include "block/blockjob_int.h"
|
2016-07-27 10:01:43 +03:00
|
|
|
#include "block/block_backup.h"
|
include/qemu/osdep.h: Don't include qapi/error.h
Commit 57cb38b included qapi/error.h into qemu/osdep.h to get the
Error typedef. Since then, we've moved to include qemu/osdep.h
everywhere. Its file comment explains: "To avoid getting into
possible circular include dependencies, this file should not include
any other QEMU headers, with the exceptions of config-host.h,
compiler.h, os-posix.h and os-win32.h, all of which are doing a
similar job to this file and are under similar constraints."
qapi/error.h doesn't do a similar job, and it doesn't adhere to
similar constraints: it includes qapi-types.h. That's in excess of
100KiB of crap most .c files don't actually need.
Add the typedef to qemu/typedefs.h, and include that instead of
qapi/error.h. Include qapi/error.h in .c files that need it and don't
get it now. Include qapi-types.h in qom/object.h for uint16List.
Update scripts/clean-includes accordingly. Update it further to match
reality: replace config.h by config-target.h, add sysemu/os-posix.h,
sysemu/os-win32.h. Update the list of includes in the qemu/osdep.h
comment quoted above similarly.
This reduces the number of objects depending on qapi/error.h from "all
of them" to less than a third. Unfortunately, the number depending on
qapi-types.h shrinks only a little. More work is needed for that one.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
[Fix compilation without the spice devel packages. - Paolo]
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2016-03-14 11:01:28 +03:00
|
|
|
#include "qapi/error.h"
|
2015-03-17 19:22:46 +03:00
|
|
|
#include "qapi/qmp/qerror.h"
|
2013-06-24 19:13:11 +04:00
|
|
|
#include "qemu/ratelimit.h"
|
2016-03-20 20:16:19 +03:00
|
|
|
#include "qemu/cutils.h"
|
2015-10-19 18:53:22 +03:00
|
|
|
#include "sysemu/block-backend.h"
|
2016-03-08 07:44:52 +03:00
|
|
|
#include "qemu/bitmap.h"
|
2017-02-28 22:33:40 +03:00
|
|
|
#include "qemu/error-report.h"
|
2013-06-24 19:13:11 +04:00
|
|
|
|
2016-02-25 23:58:29 +03:00
|
|
|
#define BACKUP_CLUSTER_SIZE_DEFAULT (1 << 16)
|
2013-06-24 19:13:11 +04:00
|
|
|
|
2018-09-19 15:43:43 +03:00
|
|
|
typedef struct CowRequest {
|
|
|
|
int64_t start_byte;
|
|
|
|
int64_t end_byte;
|
|
|
|
QLIST_ENTRY(CowRequest) list;
|
|
|
|
CoQueue wait_queue; /* coroutines blocked on this request */
|
|
|
|
} CowRequest;
|
|
|
|
|
2013-06-24 19:13:11 +04:00
|
|
|
typedef struct BackupBlockJob {
|
|
|
|
BlockJob common;
|
2016-04-14 14:09:53 +03:00
|
|
|
BlockBackend *target;
|
2015-06-05 03:20:34 +03:00
|
|
|
/* bitmap for sync=incremental */
|
2015-04-18 02:49:58 +03:00
|
|
|
BdrvDirtyBitmap *sync_bitmap;
|
2013-07-26 22:39:04 +04:00
|
|
|
MirrorSyncMode sync_mode;
|
2013-06-24 19:13:11 +04:00
|
|
|
BlockdevOnError on_source_error;
|
|
|
|
BlockdevOnError on_target_error;
|
|
|
|
CoRwlock flush_rwlock;
|
2018-01-18 20:08:22 +03:00
|
|
|
uint64_t len;
|
2017-07-07 15:44:53 +03:00
|
|
|
uint64_t bytes_read;
|
2016-02-25 23:58:29 +03:00
|
|
|
int64_t cluster_size;
|
2016-07-22 11:17:52 +03:00
|
|
|
bool compress;
|
2016-01-27 02:54:58 +03:00
|
|
|
NotifierWithReturn before_write;
|
2013-06-24 19:13:11 +04:00
|
|
|
QLIST_HEAD(, CowRequest) inflight_reqs;
|
2017-10-12 16:53:10 +03:00
|
|
|
|
|
|
|
HBitmap *copy_bitmap;
|
2018-07-03 05:37:58 +03:00
|
|
|
bool use_copy_range;
|
|
|
|
int64_t copy_range_size;
|
block/backup: fix fleecing scheme: use serialized writes
Fleecing scheme works as follows: we want a kind of temporary snapshot
of active drive A. We create temporary image B, with B->backing = A.
Then we start backup(sync=none) from A to B. From this point, B reads
as point-in-time snapshot of A (A continues to be active drive,
accepting guest IO).
This scheme needs some additional synchronization between reads from B
and backup COW operations, otherwise, the following situation is
theoretically possible:
(assume B is qcow2, client is NBD client, reading from B)
1. client starts reading and take qcow2 mutex in qcow2_co_preadv, and
goes up to l2 table loading (assume cache miss)
2) guest write => backup COW => qcow2 write =>
try to take qcow2 mutex => waiting
3. l2 table loaded, we see that cluster is UNALLOCATED, go to
"case QCOW2_CLUSTER_UNALLOCATED" and unlock mutex before
bdrv_co_preadv(bs->backing, ...)
4) aha, mutex unlocked, backup COW continues, and we finally finish
guest write and change cluster in our active disk A
5. actually, do bdrv_co_preadv(bs->backing, ...) and read
_new updated_ data.
To avoid this, let's make backup writes serializing, to not intersect
with reads from B.
Note: we expand range of handled cases from (sync=none and
B->backing = A) to just (A in backing chain of B), to finally allow
safe reading from B during backup for all cases when A in backing chain
of B, i.e. B formally looks like point-in-time snapshot of A.
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2018-07-09 19:37:19 +03:00
|
|
|
|
|
|
|
bool serialize_target_writes;
|
2013-06-24 19:13:11 +04:00
|
|
|
} BackupBlockJob;
|
|
|
|
|
2018-01-19 17:54:40 +03:00
|
|
|
static const BlockJobDriver backup_job_driver;
|
|
|
|
|
2013-06-24 19:13:11 +04:00
|
|
|
/* See if in-flight requests overlap and wait for them to complete */
|
|
|
|
static void coroutine_fn wait_for_overlapping_requests(BackupBlockJob *job,
|
|
|
|
int64_t start,
|
|
|
|
int64_t end)
|
|
|
|
{
|
|
|
|
CowRequest *req;
|
|
|
|
bool retry;
|
|
|
|
|
|
|
|
do {
|
|
|
|
retry = false;
|
|
|
|
QLIST_FOREACH(req, &job->inflight_reqs, list) {
|
2017-07-07 15:44:54 +03:00
|
|
|
if (end > req->start_byte && start < req->end_byte) {
|
2017-02-13 21:12:43 +03:00
|
|
|
qemu_co_queue_wait(&req->wait_queue, NULL);
|
2013-06-24 19:13:11 +04:00
|
|
|
retry = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} while (retry);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Keep track of an in-flight request */
|
|
|
|
static void cow_request_begin(CowRequest *req, BackupBlockJob *job,
|
2017-07-07 15:44:54 +03:00
|
|
|
int64_t start, int64_t end)
|
2013-06-24 19:13:11 +04:00
|
|
|
{
|
2017-07-07 15:44:54 +03:00
|
|
|
req->start_byte = start;
|
|
|
|
req->end_byte = end;
|
2013-06-24 19:13:11 +04:00
|
|
|
qemu_co_queue_init(&req->wait_queue);
|
|
|
|
QLIST_INSERT_HEAD(&job->inflight_reqs, req, list);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Forget about a completed request */
|
|
|
|
static void cow_request_end(CowRequest *req)
|
|
|
|
{
|
|
|
|
QLIST_REMOVE(req, list);
|
|
|
|
qemu_co_queue_restart_all(&req->wait_queue);
|
|
|
|
}
|
|
|
|
|
2018-07-03 05:37:58 +03:00
|
|
|
/* Copy range to target with a bounce buffer and return the bytes copied. If
|
2018-07-12 22:51:20 +03:00
|
|
|
* error occurred, return a negative error number */
|
2018-07-03 05:37:58 +03:00
|
|
|
static int coroutine_fn backup_cow_with_bounce_buffer(BackupBlockJob *job,
|
|
|
|
int64_t start,
|
|
|
|
int64_t end,
|
|
|
|
bool is_write_notifier,
|
|
|
|
bool *error_is_read,
|
|
|
|
void **bounce_buffer)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
BlockBackend *blk = job->common.blk;
|
|
|
|
int nbytes;
|
block/backup: fix fleecing scheme: use serialized writes
Fleecing scheme works as follows: we want a kind of temporary snapshot
of active drive A. We create temporary image B, with B->backing = A.
Then we start backup(sync=none) from A to B. From this point, B reads
as point-in-time snapshot of A (A continues to be active drive,
accepting guest IO).
This scheme needs some additional synchronization between reads from B
and backup COW operations, otherwise, the following situation is
theoretically possible:
(assume B is qcow2, client is NBD client, reading from B)
1. client starts reading and take qcow2 mutex in qcow2_co_preadv, and
goes up to l2 table loading (assume cache miss)
2) guest write => backup COW => qcow2 write =>
try to take qcow2 mutex => waiting
3. l2 table loaded, we see that cluster is UNALLOCATED, go to
"case QCOW2_CLUSTER_UNALLOCATED" and unlock mutex before
bdrv_co_preadv(bs->backing, ...)
4) aha, mutex unlocked, backup COW continues, and we finally finish
guest write and change cluster in our active disk A
5. actually, do bdrv_co_preadv(bs->backing, ...) and read
_new updated_ data.
To avoid this, let's make backup writes serializing, to not intersect
with reads from B.
Note: we expand range of handled cases from (sync=none and
B->backing = A) to just (A in backing chain of B), to finally allow
safe reading from B during backup for all cases when A in backing chain
of B, i.e. B formally looks like point-in-time snapshot of A.
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2018-07-09 19:37:19 +03:00
|
|
|
int read_flags = is_write_notifier ? BDRV_REQ_NO_SERIALISING : 0;
|
|
|
|
int write_flags = job->serialize_target_writes ? BDRV_REQ_SERIALISING : 0;
|
2018-07-03 05:37:58 +03:00
|
|
|
|
|
|
|
hbitmap_reset(job->copy_bitmap, start / job->cluster_size, 1);
|
|
|
|
nbytes = MIN(job->cluster_size, job->len - start);
|
|
|
|
if (!*bounce_buffer) {
|
|
|
|
*bounce_buffer = blk_blockalign(blk, job->cluster_size);
|
|
|
|
}
|
|
|
|
|
2019-04-22 17:58:35 +03:00
|
|
|
ret = blk_co_pread(blk, start, nbytes, *bounce_buffer, read_flags);
|
2018-07-03 05:37:58 +03:00
|
|
|
if (ret < 0) {
|
|
|
|
trace_backup_do_cow_read_fail(job, start, ret);
|
|
|
|
if (error_is_read) {
|
|
|
|
*error_is_read = true;
|
|
|
|
}
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2019-04-22 17:58:35 +03:00
|
|
|
if (buffer_is_zero(*bounce_buffer, nbytes)) {
|
2018-07-03 05:37:58 +03:00
|
|
|
ret = blk_co_pwrite_zeroes(job->target, start,
|
2019-04-22 17:58:35 +03:00
|
|
|
nbytes, write_flags | BDRV_REQ_MAY_UNMAP);
|
2018-07-03 05:37:58 +03:00
|
|
|
} else {
|
2019-04-22 17:58:35 +03:00
|
|
|
ret = blk_co_pwrite(job->target, start,
|
|
|
|
nbytes, *bounce_buffer, write_flags |
|
|
|
|
(job->compress ? BDRV_REQ_WRITE_COMPRESSED : 0));
|
2018-07-03 05:37:58 +03:00
|
|
|
}
|
|
|
|
if (ret < 0) {
|
|
|
|
trace_backup_do_cow_write_fail(job, start, ret);
|
|
|
|
if (error_is_read) {
|
|
|
|
*error_is_read = false;
|
|
|
|
}
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
return nbytes;
|
|
|
|
fail:
|
|
|
|
hbitmap_set(job->copy_bitmap, start / job->cluster_size, 1);
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2018-07-12 22:51:20 +03:00
|
|
|
/* Copy range to target and return the bytes copied. If error occurred, return a
|
2018-07-03 05:37:58 +03:00
|
|
|
* negative error number. */
|
|
|
|
static int coroutine_fn backup_cow_with_offload(BackupBlockJob *job,
|
|
|
|
int64_t start,
|
|
|
|
int64_t end,
|
|
|
|
bool is_write_notifier)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
int nr_clusters;
|
|
|
|
BlockBackend *blk = job->common.blk;
|
|
|
|
int nbytes;
|
block/backup: fix fleecing scheme: use serialized writes
Fleecing scheme works as follows: we want a kind of temporary snapshot
of active drive A. We create temporary image B, with B->backing = A.
Then we start backup(sync=none) from A to B. From this point, B reads
as point-in-time snapshot of A (A continues to be active drive,
accepting guest IO).
This scheme needs some additional synchronization between reads from B
and backup COW operations, otherwise, the following situation is
theoretically possible:
(assume B is qcow2, client is NBD client, reading from B)
1. client starts reading and take qcow2 mutex in qcow2_co_preadv, and
goes up to l2 table loading (assume cache miss)
2) guest write => backup COW => qcow2 write =>
try to take qcow2 mutex => waiting
3. l2 table loaded, we see that cluster is UNALLOCATED, go to
"case QCOW2_CLUSTER_UNALLOCATED" and unlock mutex before
bdrv_co_preadv(bs->backing, ...)
4) aha, mutex unlocked, backup COW continues, and we finally finish
guest write and change cluster in our active disk A
5. actually, do bdrv_co_preadv(bs->backing, ...) and read
_new updated_ data.
To avoid this, let's make backup writes serializing, to not intersect
with reads from B.
Note: we expand range of handled cases from (sync=none and
B->backing = A) to just (A in backing chain of B), to finally allow
safe reading from B during backup for all cases when A in backing chain
of B, i.e. B formally looks like point-in-time snapshot of A.
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2018-07-09 19:37:19 +03:00
|
|
|
int read_flags = is_write_notifier ? BDRV_REQ_NO_SERIALISING : 0;
|
|
|
|
int write_flags = job->serialize_target_writes ? BDRV_REQ_SERIALISING : 0;
|
2018-07-03 05:37:58 +03:00
|
|
|
|
|
|
|
assert(QEMU_IS_ALIGNED(job->copy_range_size, job->cluster_size));
|
|
|
|
nbytes = MIN(job->copy_range_size, end - start);
|
|
|
|
nr_clusters = DIV_ROUND_UP(nbytes, job->cluster_size);
|
|
|
|
hbitmap_reset(job->copy_bitmap, start / job->cluster_size,
|
|
|
|
nr_clusters);
|
|
|
|
ret = blk_co_copy_range(blk, start, job->target, start, nbytes,
|
block/backup: fix fleecing scheme: use serialized writes
Fleecing scheme works as follows: we want a kind of temporary snapshot
of active drive A. We create temporary image B, with B->backing = A.
Then we start backup(sync=none) from A to B. From this point, B reads
as point-in-time snapshot of A (A continues to be active drive,
accepting guest IO).
This scheme needs some additional synchronization between reads from B
and backup COW operations, otherwise, the following situation is
theoretically possible:
(assume B is qcow2, client is NBD client, reading from B)
1. client starts reading and take qcow2 mutex in qcow2_co_preadv, and
goes up to l2 table loading (assume cache miss)
2) guest write => backup COW => qcow2 write =>
try to take qcow2 mutex => waiting
3. l2 table loaded, we see that cluster is UNALLOCATED, go to
"case QCOW2_CLUSTER_UNALLOCATED" and unlock mutex before
bdrv_co_preadv(bs->backing, ...)
4) aha, mutex unlocked, backup COW continues, and we finally finish
guest write and change cluster in our active disk A
5. actually, do bdrv_co_preadv(bs->backing, ...) and read
_new updated_ data.
To avoid this, let's make backup writes serializing, to not intersect
with reads from B.
Note: we expand range of handled cases from (sync=none and
B->backing = A) to just (A in backing chain of B), to finally allow
safe reading from B during backup for all cases when A in backing chain
of B, i.e. B formally looks like point-in-time snapshot of A.
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2018-07-09 19:37:19 +03:00
|
|
|
read_flags, write_flags);
|
2018-07-03 05:37:58 +03:00
|
|
|
if (ret < 0) {
|
|
|
|
trace_backup_do_cow_copy_range_fail(job, start, ret);
|
|
|
|
hbitmap_set(job->copy_bitmap, start / job->cluster_size,
|
|
|
|
nr_clusters);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return nbytes;
|
|
|
|
}
|
|
|
|
|
2016-04-14 16:56:02 +03:00
|
|
|
static int coroutine_fn backup_do_cow(BackupBlockJob *job,
|
2017-07-07 15:44:55 +03:00
|
|
|
int64_t offset, uint64_t bytes,
|
2015-09-08 06:28:33 +03:00
|
|
|
bool *error_is_read,
|
|
|
|
bool is_write_notifier)
|
2013-06-24 19:13:11 +04:00
|
|
|
{
|
|
|
|
CowRequest cow_request;
|
|
|
|
int ret = 0;
|
2017-07-07 15:44:55 +03:00
|
|
|
int64_t start, end; /* bytes */
|
2018-07-03 05:37:58 +03:00
|
|
|
void *bounce_buffer = NULL;
|
2013-06-24 19:13:11 +04:00
|
|
|
|
|
|
|
qemu_co_rwlock_rdlock(&job->flush_rwlock);
|
|
|
|
|
2017-07-07 15:44:55 +03:00
|
|
|
start = QEMU_ALIGN_DOWN(offset, job->cluster_size);
|
|
|
|
end = QEMU_ALIGN_UP(bytes + offset, job->cluster_size);
|
2013-06-24 19:13:11 +04:00
|
|
|
|
2017-07-07 15:44:55 +03:00
|
|
|
trace_backup_do_cow_enter(job, start, offset, bytes);
|
2013-06-24 19:13:11 +04:00
|
|
|
|
2017-07-07 15:44:55 +03:00
|
|
|
wait_for_overlapping_requests(job, start, end);
|
|
|
|
cow_request_begin(&cow_request, job, start, end);
|
2013-06-24 19:13:11 +04:00
|
|
|
|
2018-07-03 05:37:58 +03:00
|
|
|
while (start < end) {
|
2017-10-12 16:53:10 +03:00
|
|
|
if (!hbitmap_get(job->copy_bitmap, start / job->cluster_size)) {
|
2017-07-07 15:44:55 +03:00
|
|
|
trace_backup_do_cow_skip(job, start);
|
2018-07-03 05:37:58 +03:00
|
|
|
start += job->cluster_size;
|
2013-06-24 19:13:11 +04:00
|
|
|
continue; /* already copied */
|
|
|
|
}
|
|
|
|
|
2017-07-07 15:44:55 +03:00
|
|
|
trace_backup_do_cow_process(job, start);
|
2013-06-24 19:13:11 +04:00
|
|
|
|
2018-07-03 05:37:58 +03:00
|
|
|
if (job->use_copy_range) {
|
|
|
|
ret = backup_cow_with_offload(job, start, end, is_write_notifier);
|
|
|
|
if (ret < 0) {
|
|
|
|
job->use_copy_range = false;
|
2013-06-24 19:13:11 +04:00
|
|
|
}
|
|
|
|
}
|
2018-07-03 05:37:58 +03:00
|
|
|
if (!job->use_copy_range) {
|
|
|
|
ret = backup_cow_with_bounce_buffer(job, start, end, is_write_notifier,
|
|
|
|
error_is_read, &bounce_buffer);
|
2013-06-24 19:13:11 +04:00
|
|
|
}
|
|
|
|
if (ret < 0) {
|
2018-07-03 05:37:58 +03:00
|
|
|
break;
|
2013-06-24 19:13:11 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Publish progress, guest I/O counts as progress too. Note that the
|
|
|
|
* offset field is an opaque progress value, it is not a disk offset.
|
|
|
|
*/
|
2018-07-03 05:37:58 +03:00
|
|
|
start += ret;
|
|
|
|
job->bytes_read += ret;
|
|
|
|
job_progress_update(&job->common.job, ret);
|
|
|
|
ret = 0;
|
2013-06-24 19:13:11 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
if (bounce_buffer) {
|
|
|
|
qemu_vfree(bounce_buffer);
|
|
|
|
}
|
|
|
|
|
|
|
|
cow_request_end(&cow_request);
|
|
|
|
|
2017-07-07 15:44:55 +03:00
|
|
|
trace_backup_do_cow_return(job, offset, bytes, ret);
|
2013-06-24 19:13:11 +04:00
|
|
|
|
|
|
|
qemu_co_rwlock_unlock(&job->flush_rwlock);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int coroutine_fn backup_before_write_notify(
|
|
|
|
NotifierWithReturn *notifier,
|
|
|
|
void *opaque)
|
|
|
|
{
|
2016-01-27 02:54:58 +03:00
|
|
|
BackupBlockJob *job = container_of(notifier, BackupBlockJob, before_write);
|
2013-06-24 19:13:11 +04:00
|
|
|
BdrvTrackedRequest *req = opaque;
|
|
|
|
|
2016-04-14 14:09:53 +03:00
|
|
|
assert(req->bs == blk_bs(job->common.blk));
|
2017-07-07 15:44:55 +03:00
|
|
|
assert(QEMU_IS_ALIGNED(req->offset, BDRV_SECTOR_SIZE));
|
|
|
|
assert(QEMU_IS_ALIGNED(req->bytes, BDRV_SECTOR_SIZE));
|
2013-12-03 18:31:25 +04:00
|
|
|
|
2017-07-07 15:44:55 +03:00
|
|
|
return backup_do_cow(job, req->offset, req->bytes, NULL, true);
|
2013-06-24 19:13:11 +04:00
|
|
|
}
|
|
|
|
|
2015-11-06 02:13:10 +03:00
|
|
|
static void backup_cleanup_sync_bitmap(BackupBlockJob *job, int ret)
|
|
|
|
{
|
|
|
|
BdrvDirtyBitmap *bm;
|
2016-04-14 14:09:53 +03:00
|
|
|
BlockDriverState *bs = blk_bs(job->common.blk);
|
2015-11-06 02:13:10 +03:00
|
|
|
|
2018-03-10 11:27:37 +03:00
|
|
|
if (ret < 0) {
|
2015-11-06 02:13:10 +03:00
|
|
|
/* Merge the successor back into the parent, delete nothing. */
|
|
|
|
bm = bdrv_reclaim_dirty_bitmap(bs, job->sync_bitmap, NULL);
|
|
|
|
assert(bm);
|
|
|
|
} else {
|
|
|
|
/* Everything is fine, delete this bitmap and install the backup. */
|
|
|
|
bm = bdrv_dirty_bitmap_abdicate(bs, job->sync_bitmap, NULL);
|
|
|
|
assert(bm);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-04-19 18:30:16 +03:00
|
|
|
static void backup_commit(Job *job)
|
2015-11-06 02:13:16 +03:00
|
|
|
{
|
2018-04-19 18:30:16 +03:00
|
|
|
BackupBlockJob *s = container_of(job, BackupBlockJob, common.job);
|
2015-11-06 02:13:16 +03:00
|
|
|
if (s->sync_bitmap) {
|
|
|
|
backup_cleanup_sync_bitmap(s, 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-04-19 18:30:16 +03:00
|
|
|
static void backup_abort(Job *job)
|
2015-11-06 02:13:16 +03:00
|
|
|
{
|
2018-04-19 18:30:16 +03:00
|
|
|
BackupBlockJob *s = container_of(job, BackupBlockJob, common.job);
|
2015-11-06 02:13:16 +03:00
|
|
|
if (s->sync_bitmap) {
|
|
|
|
backup_cleanup_sync_bitmap(s, -1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-04-19 18:30:16 +03:00
|
|
|
static void backup_clean(Job *job)
|
blockjob: add .clean property
Cleaning up after we have deferred to the main thread but before the
transaction has converged can be dangerous and result in deadlocks
if the job cleanup invokes any BH polling loops.
A job may attempt to begin cleaning up, but may induce another job to
enter its cleanup routine. The second job, part of our same transaction,
will block waiting for the first job to finish, so neither job may now
make progress.
To rectify this, allow jobs to register a cleanup operation that will
always run regardless of if the job was in a transaction or not, and
if the transaction job group completed successfully or not.
Move sensitive cleanup to this callback instead which is guaranteed to
be run only after the transaction has converged, which removes sensitive
timing constraints from said cleanup.
Furthermore, in future patches these cleanup operations will be performed
regardless of whether or not we actually started the job. Therefore,
cleanup callbacks should essentially confine themselves to undoing create
operations, e.g. setup actions taken in what is now backup_start.
Reported-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Signed-off-by: John Snow <jsnow@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Message-id: 1478587839-9834-3-git-send-email-jsnow@redhat.com
Signed-off-by: Jeff Cody <jcody@redhat.com>
2016-11-08 09:50:35 +03:00
|
|
|
{
|
2018-04-19 18:30:16 +03:00
|
|
|
BackupBlockJob *s = container_of(job, BackupBlockJob, common.job);
|
blockjob: add .clean property
Cleaning up after we have deferred to the main thread but before the
transaction has converged can be dangerous and result in deadlocks
if the job cleanup invokes any BH polling loops.
A job may attempt to begin cleaning up, but may induce another job to
enter its cleanup routine. The second job, part of our same transaction,
will block waiting for the first job to finish, so neither job may now
make progress.
To rectify this, allow jobs to register a cleanup operation that will
always run regardless of if the job was in a transaction or not, and
if the transaction job group completed successfully or not.
Move sensitive cleanup to this callback instead which is guaranteed to
be run only after the transaction has converged, which removes sensitive
timing constraints from said cleanup.
Furthermore, in future patches these cleanup operations will be performed
regardless of whether or not we actually started the job. Therefore,
cleanup callbacks should essentially confine themselves to undoing create
operations, e.g. setup actions taken in what is now backup_start.
Reported-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Signed-off-by: John Snow <jsnow@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Message-id: 1478587839-9834-3-git-send-email-jsnow@redhat.com
Signed-off-by: Jeff Cody <jcody@redhat.com>
2016-11-08 09:50:35 +03:00
|
|
|
assert(s->target);
|
|
|
|
blk_unref(s->target);
|
|
|
|
s->target = NULL;
|
|
|
|
}
|
|
|
|
|
2016-06-16 19:56:29 +03:00
|
|
|
static void backup_attached_aio_context(BlockJob *job, AioContext *aio_context)
|
|
|
|
{
|
|
|
|
BackupBlockJob *s = container_of(job, BackupBlockJob, common);
|
|
|
|
|
|
|
|
blk_set_aio_context(s->target, aio_context);
|
|
|
|
}
|
|
|
|
|
2016-07-27 10:01:43 +03:00
|
|
|
void backup_do_checkpoint(BlockJob *job, Error **errp)
|
|
|
|
{
|
|
|
|
BackupBlockJob *backup_job = container_of(job, BackupBlockJob, common);
|
|
|
|
int64_t len;
|
|
|
|
|
2018-01-19 17:54:40 +03:00
|
|
|
assert(block_job_driver(job) == &backup_job_driver);
|
2016-07-27 10:01:43 +03:00
|
|
|
|
|
|
|
if (backup_job->sync_mode != MIRROR_SYNC_MODE_NONE) {
|
|
|
|
error_setg(errp, "The backup job only supports block checkpoint in"
|
|
|
|
" sync=none mode");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-01-18 20:08:22 +03:00
|
|
|
len = DIV_ROUND_UP(backup_job->len, backup_job->cluster_size);
|
2017-10-12 16:53:10 +03:00
|
|
|
hbitmap_set(backup_job->copy_bitmap, 0, len);
|
2016-07-27 10:01:43 +03:00
|
|
|
}
|
|
|
|
|
2016-10-27 13:48:50 +03:00
|
|
|
static void backup_drain(BlockJob *job)
|
|
|
|
{
|
|
|
|
BackupBlockJob *s = container_of(job, BackupBlockJob, common);
|
|
|
|
|
|
|
|
/* Need to keep a reference in case blk_drain triggers execution
|
|
|
|
* of backup_complete...
|
|
|
|
*/
|
|
|
|
if (s->target) {
|
|
|
|
BlockBackend *target = s->target;
|
|
|
|
blk_ref(target);
|
|
|
|
blk_drain(target);
|
|
|
|
blk_unref(target);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-06-24 19:13:11 +04:00
|
|
|
static BlockErrorAction backup_error_action(BackupBlockJob *job,
|
|
|
|
bool read, int error)
|
|
|
|
{
|
|
|
|
if (read) {
|
2016-04-18 12:36:38 +03:00
|
|
|
return block_job_error_action(&job->common, job->on_source_error,
|
|
|
|
true, error);
|
2013-06-24 19:13:11 +04:00
|
|
|
} else {
|
2016-04-18 12:36:38 +03:00
|
|
|
return block_job_error_action(&job->common, job->on_target_error,
|
|
|
|
false, error);
|
2013-06-24 19:13:11 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-04-18 02:49:58 +03:00
|
|
|
static bool coroutine_fn yield_and_check(BackupBlockJob *job)
|
|
|
|
{
|
2018-01-18 23:19:38 +03:00
|
|
|
uint64_t delay_ns;
|
|
|
|
|
2018-04-17 13:56:07 +03:00
|
|
|
if (job_is_cancelled(&job->common.job)) {
|
2015-04-18 02:49:58 +03:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2018-01-18 23:19:38 +03:00
|
|
|
/* We need to yield even for delay_ns = 0 so that bdrv_drain_all() can
|
|
|
|
* return. Without a yield, the VM would not reboot. */
|
|
|
|
delay_ns = block_job_ratelimit_get_delay(&job->common, job->bytes_read);
|
|
|
|
job->bytes_read = 0;
|
2018-04-18 17:32:20 +03:00
|
|
|
job_sleep_ns(&job->common.job, delay_ns);
|
2015-04-18 02:49:58 +03:00
|
|
|
|
2018-04-17 13:56:07 +03:00
|
|
|
if (job_is_cancelled(&job->common.job)) {
|
2015-04-18 02:49:58 +03:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int coroutine_fn backup_run_incremental(BackupBlockJob *job)
|
|
|
|
{
|
2017-10-12 16:53:13 +03:00
|
|
|
int ret;
|
2015-04-18 02:49:58 +03:00
|
|
|
bool error_is_read;
|
|
|
|
int64_t cluster;
|
2017-10-12 16:53:13 +03:00
|
|
|
HBitmapIter hbi;
|
2015-04-18 02:49:58 +03:00
|
|
|
|
2017-10-12 16:53:13 +03:00
|
|
|
hbitmap_iter_init(&hbi, job->copy_bitmap, 0);
|
2019-01-16 02:26:50 +03:00
|
|
|
while ((cluster = hbitmap_iter_next(&hbi)) != -1) {
|
2017-10-12 16:53:13 +03:00
|
|
|
do {
|
|
|
|
if (yield_and_check(job)) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
ret = backup_do_cow(job, cluster * job->cluster_size,
|
|
|
|
job->cluster_size, &error_is_read, false);
|
|
|
|
if (ret < 0 && backup_error_action(job, error_is_read, -ret) ==
|
|
|
|
BLOCK_ERROR_ACTION_REPORT)
|
|
|
|
{
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
} while (ret < 0);
|
2015-04-18 02:49:58 +03:00
|
|
|
}
|
|
|
|
|
2017-10-12 16:53:13 +03:00
|
|
|
return 0;
|
2015-04-18 02:49:58 +03:00
|
|
|
}
|
|
|
|
|
2017-10-12 16:53:11 +03:00
|
|
|
/* init copy_bitmap from sync_bitmap */
|
|
|
|
static void backup_incremental_init_copy_bitmap(BackupBlockJob *job)
|
|
|
|
{
|
|
|
|
BdrvDirtyBitmapIter *dbi;
|
|
|
|
int64_t offset;
|
|
|
|
int64_t end = DIV_ROUND_UP(bdrv_dirty_bitmap_size(job->sync_bitmap),
|
|
|
|
job->cluster_size);
|
|
|
|
|
|
|
|
dbi = bdrv_dirty_iter_new(job->sync_bitmap);
|
|
|
|
while ((offset = bdrv_dirty_iter_next(dbi)) != -1) {
|
|
|
|
int64_t cluster = offset / job->cluster_size;
|
|
|
|
int64_t next_cluster;
|
|
|
|
|
|
|
|
offset += bdrv_dirty_bitmap_granularity(job->sync_bitmap);
|
|
|
|
if (offset >= bdrv_dirty_bitmap_size(job->sync_bitmap)) {
|
|
|
|
hbitmap_set(job->copy_bitmap, cluster, end - cluster);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2019-01-16 02:26:49 +03:00
|
|
|
offset = bdrv_dirty_bitmap_next_zero(job->sync_bitmap, offset,
|
|
|
|
UINT64_MAX);
|
2017-10-12 16:53:11 +03:00
|
|
|
if (offset == -1) {
|
|
|
|
hbitmap_set(job->copy_bitmap, cluster, end - cluster);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
next_cluster = DIV_ROUND_UP(offset, job->cluster_size);
|
|
|
|
hbitmap_set(job->copy_bitmap, cluster, next_cluster - cluster);
|
|
|
|
if (next_cluster >= end) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
bdrv_set_dirty_iter(dbi, next_cluster * job->cluster_size);
|
|
|
|
}
|
|
|
|
|
2018-05-04 13:17:20 +03:00
|
|
|
/* TODO job_progress_set_remaining() would make more sense */
|
|
|
|
job_progress_update(&job->common.job,
|
2018-01-18 20:08:22 +03:00
|
|
|
job->len - hbitmap_count(job->copy_bitmap) * job->cluster_size);
|
2017-10-12 16:53:12 +03:00
|
|
|
|
2017-10-12 16:53:11 +03:00
|
|
|
bdrv_dirty_iter_free(dbi);
|
|
|
|
}
|
|
|
|
|
2018-08-30 04:57:32 +03:00
|
|
|
static int coroutine_fn backup_run(Job *job, Error **errp)
|
2013-06-24 19:13:11 +04:00
|
|
|
{
|
2018-08-30 04:57:32 +03:00
|
|
|
BackupBlockJob *s = container_of(job, BackupBlockJob, common.job);
|
|
|
|
BlockDriverState *bs = blk_bs(s->common.blk);
|
2017-10-12 16:53:10 +03:00
|
|
|
int64_t offset, nb_clusters;
|
2013-06-24 19:13:11 +04:00
|
|
|
int ret = 0;
|
|
|
|
|
2018-08-30 04:57:32 +03:00
|
|
|
QLIST_INIT(&s->inflight_reqs);
|
|
|
|
qemu_co_rwlock_init(&s->flush_rwlock);
|
2013-06-24 19:13:11 +04:00
|
|
|
|
2018-08-30 04:57:32 +03:00
|
|
|
nb_clusters = DIV_ROUND_UP(s->len, s->cluster_size);
|
|
|
|
job_progress_set_remaining(job, s->len);
|
2018-01-18 20:08:22 +03:00
|
|
|
|
2018-08-30 04:57:32 +03:00
|
|
|
s->copy_bitmap = hbitmap_alloc(nb_clusters, 0);
|
|
|
|
if (s->sync_mode == MIRROR_SYNC_MODE_INCREMENTAL) {
|
|
|
|
backup_incremental_init_copy_bitmap(s);
|
2017-10-12 16:53:11 +03:00
|
|
|
} else {
|
2018-08-30 04:57:32 +03:00
|
|
|
hbitmap_set(s->copy_bitmap, 0, nb_clusters);
|
2017-10-12 16:53:11 +03:00
|
|
|
}
|
|
|
|
|
2013-06-24 19:13:11 +04:00
|
|
|
|
2018-08-30 04:57:32 +03:00
|
|
|
s->before_write.notify = backup_before_write_notify;
|
|
|
|
bdrv_add_before_write_notifier(bs, &s->before_write);
|
2013-06-24 19:13:11 +04:00
|
|
|
|
2018-08-30 04:57:32 +03:00
|
|
|
if (s->sync_mode == MIRROR_SYNC_MODE_NONE) {
|
2017-10-12 16:53:10 +03:00
|
|
|
/* All bits are set in copy_bitmap to allow any cluster to be copied.
|
|
|
|
* This does not actually require them to be copied. */
|
2018-08-30 04:57:32 +03:00
|
|
|
while (!job_is_cancelled(job)) {
|
2013-07-26 22:39:04 +04:00
|
|
|
/* Yield until the job is cancelled. We just let our before_write
|
|
|
|
* notify callback service CoW requests. */
|
2018-08-30 04:57:32 +03:00
|
|
|
job_yield(job);
|
2013-06-24 19:13:11 +04:00
|
|
|
}
|
2018-08-30 04:57:32 +03:00
|
|
|
} else if (s->sync_mode == MIRROR_SYNC_MODE_INCREMENTAL) {
|
|
|
|
ret = backup_run_incremental(s);
|
2013-07-26 22:39:04 +04:00
|
|
|
} else {
|
|
|
|
/* Both FULL and TOP SYNC_MODE's require copying.. */
|
2018-08-30 04:57:32 +03:00
|
|
|
for (offset = 0; offset < s->len;
|
|
|
|
offset += s->cluster_size) {
|
2013-07-26 22:39:04 +04:00
|
|
|
bool error_is_read;
|
2017-03-09 00:34:27 +03:00
|
|
|
int alloced = 0;
|
|
|
|
|
2018-08-30 04:57:32 +03:00
|
|
|
if (yield_and_check(s)) {
|
2013-06-24 19:13:11 +04:00
|
|
|
break;
|
2013-07-26 22:39:04 +04:00
|
|
|
}
|
|
|
|
|
2018-08-30 04:57:32 +03:00
|
|
|
if (s->sync_mode == MIRROR_SYNC_MODE_TOP) {
|
block: Make bdrv_is_allocated() byte-based
We are gradually moving away from sector-based interfaces, towards
byte-based. In the common case, allocation is unlikely to ever use
values that are not naturally sector-aligned, but it is possible
that byte-based values will let us be more precise about allocation
at the end of an unaligned file that can do byte-based access.
Changing the signature of the function to use int64_t *pnum ensures
that the compiler enforces that all callers are updated. For now,
the io.c layer still assert()s that all callers are sector-aligned
on input and that *pnum is sector-aligned on return to the caller,
but that can be relaxed when a later patch implements byte-based
block status. Therefore, this code adds usages like
DIV_ROUND_UP(,BDRV_SECTOR_SIZE) to callers that still want aligned
values, where the call might reasonbly give non-aligned results
in the future; on the other hand, no rounding is needed for callers
that should just continue to work with byte alignment.
For the most part this patch is just the addition of scaling at the
callers followed by inverse scaling at bdrv_is_allocated(). But
some code, particularly bdrv_commit(), gets a lot simpler because it
no longer has to mess with sectors; also, it is now possible to pass
NULL if the caller does not care how much of the image is allocated
beyond the initial offset. Leave comments where we can further
simplify once a later patch eliminates the need for sector-aligned
requests through bdrv_is_allocated().
For ease of review, bdrv_is_allocated_above() will be tackled
separately.
Signed-off-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2017-07-07 15:44:57 +03:00
|
|
|
int i;
|
|
|
|
int64_t n;
|
2013-07-26 22:39:04 +04:00
|
|
|
|
|
|
|
/* Check to see if these blocks are already in the
|
|
|
|
* backing file. */
|
|
|
|
|
2018-08-30 04:57:32 +03:00
|
|
|
for (i = 0; i < s->cluster_size;) {
|
2013-09-04 21:00:22 +04:00
|
|
|
/* bdrv_is_allocated() only returns true/false based
|
2013-08-18 21:40:06 +04:00
|
|
|
* on the first set of sectors it comes across that
|
2013-07-26 22:39:04 +04:00
|
|
|
* are are all in the same state.
|
|
|
|
* For that reason we must verify each sector in the
|
|
|
|
* backup cluster length. We end up copying more than
|
|
|
|
* needed but at some point that is always the case. */
|
|
|
|
alloced =
|
block: Make bdrv_is_allocated() byte-based
We are gradually moving away from sector-based interfaces, towards
byte-based. In the common case, allocation is unlikely to ever use
values that are not naturally sector-aligned, but it is possible
that byte-based values will let us be more precise about allocation
at the end of an unaligned file that can do byte-based access.
Changing the signature of the function to use int64_t *pnum ensures
that the compiler enforces that all callers are updated. For now,
the io.c layer still assert()s that all callers are sector-aligned
on input and that *pnum is sector-aligned on return to the caller,
but that can be relaxed when a later patch implements byte-based
block status. Therefore, this code adds usages like
DIV_ROUND_UP(,BDRV_SECTOR_SIZE) to callers that still want aligned
values, where the call might reasonbly give non-aligned results
in the future; on the other hand, no rounding is needed for callers
that should just continue to work with byte alignment.
For the most part this patch is just the addition of scaling at the
callers followed by inverse scaling at bdrv_is_allocated(). But
some code, particularly bdrv_commit(), gets a lot simpler because it
no longer has to mess with sectors; also, it is now possible to pass
NULL if the caller does not care how much of the image is allocated
beyond the initial offset. Leave comments where we can further
simplify once a later patch eliminates the need for sector-aligned
requests through bdrv_is_allocated().
For ease of review, bdrv_is_allocated_above() will be tackled
separately.
Signed-off-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2017-07-07 15:44:57 +03:00
|
|
|
bdrv_is_allocated(bs, offset + i,
|
2018-08-30 04:57:32 +03:00
|
|
|
s->cluster_size - i, &n);
|
2013-07-26 22:39:04 +04:00
|
|
|
i += n;
|
|
|
|
|
2017-03-09 00:34:27 +03:00
|
|
|
if (alloced || n == 0) {
|
2013-07-26 22:39:04 +04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If the above loop never found any sectors that are in
|
|
|
|
* the topmost image, skip this backup. */
|
|
|
|
if (alloced == 0) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* FULL sync mode we copy the whole drive. */
|
2017-03-09 00:34:27 +03:00
|
|
|
if (alloced < 0) {
|
|
|
|
ret = alloced;
|
|
|
|
} else {
|
2018-08-30 04:57:32 +03:00
|
|
|
ret = backup_do_cow(s, offset, s->cluster_size,
|
2017-07-07 15:44:56 +03:00
|
|
|
&error_is_read, false);
|
2017-03-09 00:34:27 +03:00
|
|
|
}
|
2013-07-26 22:39:04 +04:00
|
|
|
if (ret < 0) {
|
|
|
|
/* Depending on error action, fail now or retry cluster */
|
|
|
|
BlockErrorAction action =
|
2018-08-30 04:57:32 +03:00
|
|
|
backup_error_action(s, error_is_read, -ret);
|
2014-06-18 10:43:30 +04:00
|
|
|
if (action == BLOCK_ERROR_ACTION_REPORT) {
|
2013-07-26 22:39:04 +04:00
|
|
|
break;
|
|
|
|
} else {
|
2018-08-30 04:57:32 +03:00
|
|
|
offset -= s->cluster_size;
|
2013-07-26 22:39:04 +04:00
|
|
|
continue;
|
|
|
|
}
|
2013-06-24 19:13:11 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-08-30 04:57:32 +03:00
|
|
|
notifier_with_return_remove(&s->before_write);
|
2013-06-24 19:13:11 +04:00
|
|
|
|
|
|
|
/* wait until pending backup_do_cow() calls have completed */
|
2018-08-30 04:57:32 +03:00
|
|
|
qemu_co_rwlock_wrlock(&s->flush_rwlock);
|
|
|
|
qemu_co_rwlock_unlock(&s->flush_rwlock);
|
|
|
|
hbitmap_free(s->copy_bitmap);
|
2013-06-24 19:13:11 +04:00
|
|
|
|
2018-08-30 04:57:26 +03:00
|
|
|
return ret;
|
2013-06-24 19:13:11 +04:00
|
|
|
}
|
|
|
|
|
2016-11-08 09:50:36 +03:00
|
|
|
static const BlockJobDriver backup_job_driver = {
|
2018-04-12 18:29:59 +03:00
|
|
|
.job_driver = {
|
|
|
|
.instance_size = sizeof(BackupBlockJob),
|
2018-04-12 18:57:08 +03:00
|
|
|
.job_type = JOB_TYPE_BACKUP,
|
2018-04-13 19:50:05 +03:00
|
|
|
.free = block_job_free,
|
2018-04-18 18:10:26 +03:00
|
|
|
.user_resume = block_job_user_resume,
|
2018-04-20 18:00:29 +03:00
|
|
|
.drain = block_job_drain,
|
2018-08-30 04:57:26 +03:00
|
|
|
.run = backup_run,
|
2018-04-19 18:30:16 +03:00
|
|
|
.commit = backup_commit,
|
|
|
|
.abort = backup_abort,
|
|
|
|
.clean = backup_clean,
|
2018-04-12 18:29:59 +03:00
|
|
|
},
|
2016-11-08 09:50:36 +03:00
|
|
|
.attached_aio_context = backup_attached_aio_context,
|
|
|
|
.drain = backup_drain,
|
|
|
|
};
|
|
|
|
|
2016-11-08 09:50:38 +03:00
|
|
|
BlockJob *backup_job_create(const char *job_id, BlockDriverState *bs,
|
2016-07-05 17:28:58 +03:00
|
|
|
BlockDriverState *target, int64_t speed,
|
|
|
|
MirrorSyncMode sync_mode, BdrvDirtyBitmap *sync_bitmap,
|
2016-07-22 11:17:52 +03:00
|
|
|
bool compress,
|
2013-06-24 19:13:11 +04:00
|
|
|
BlockdevOnError on_source_error,
|
|
|
|
BlockdevOnError on_target_error,
|
2016-10-27 19:06:57 +03:00
|
|
|
int creation_flags,
|
2014-10-07 15:59:15 +04:00
|
|
|
BlockCompletionFunc *cb, void *opaque,
|
2018-04-19 17:09:52 +03:00
|
|
|
JobTxn *txn, Error **errp)
|
2013-06-24 19:13:11 +04:00
|
|
|
{
|
|
|
|
int64_t len;
|
block/backup: avoid copying less than full target clusters
During incremental backups, if the target has a cluster size that is
larger than the backup cluster size and we are backing up to a target
that cannot (for whichever reason) pull clusters up from a backing image,
we may inadvertantly create unusable incremental backup images.
For example:
If the bitmap tracks changes at a 64KB granularity and we transmit 64KB
of data at a time but the target uses a 128KB cluster size, it is
possible that only half of a target cluster will be recognized as dirty
by the backup block job. When the cluster is allocated on the target
image but only half populated with data, we lose the ability to
distinguish between zero padding and uninitialized data.
This does not happen if the target image has a backing file that points
to the last known good backup.
Even if we have a backing file, though, it's likely going to be faster
to just buffer the redundant data ourselves from the live image than
fetching it from the backing file, so let's just always round up to the
target granularity.
The same logic applies to backup modes top, none, and full. Copying
fractional clusters without the guarantee of COW is dangerous, but even
if we can rely on COW, it's likely better to just re-copy the data.
Reported-by: Fam Zheng <famz@redhat.com>
Signed-off-by: John Snow <jsnow@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Message-id: 1456433911-24718-3-git-send-email-jsnow@redhat.com
Signed-off-by: Jeff Cody <jcody@redhat.com>
2016-02-25 23:58:30 +03:00
|
|
|
BlockDriverInfo bdi;
|
2016-04-14 13:59:55 +03:00
|
|
|
BackupBlockJob *job = NULL;
|
block/backup: avoid copying less than full target clusters
During incremental backups, if the target has a cluster size that is
larger than the backup cluster size and we are backing up to a target
that cannot (for whichever reason) pull clusters up from a backing image,
we may inadvertantly create unusable incremental backup images.
For example:
If the bitmap tracks changes at a 64KB granularity and we transmit 64KB
of data at a time but the target uses a 128KB cluster size, it is
possible that only half of a target cluster will be recognized as dirty
by the backup block job. When the cluster is allocated on the target
image but only half populated with data, we lose the ability to
distinguish between zero padding and uninitialized data.
This does not happen if the target image has a backing file that points
to the last known good backup.
Even if we have a backing file, though, it's likely going to be faster
to just buffer the redundant data ourselves from the live image than
fetching it from the backing file, so let's just always round up to the
target granularity.
The same logic applies to backup modes top, none, and full. Copying
fractional clusters without the guarantee of COW is dangerous, but even
if we can rely on COW, it's likely better to just re-copy the data.
Reported-by: Fam Zheng <famz@redhat.com>
Signed-off-by: John Snow <jsnow@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Message-id: 1456433911-24718-3-git-send-email-jsnow@redhat.com
Signed-off-by: Jeff Cody <jcody@redhat.com>
2016-02-25 23:58:30 +03:00
|
|
|
int ret;
|
2013-06-24 19:13:11 +04:00
|
|
|
|
|
|
|
assert(bs);
|
|
|
|
assert(target);
|
|
|
|
|
2014-12-18 13:37:05 +03:00
|
|
|
if (bs == target) {
|
|
|
|
error_setg(errp, "Source and target cannot be the same");
|
2016-11-08 09:50:38 +03:00
|
|
|
return NULL;
|
2014-12-18 13:37:05 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!bdrv_is_inserted(bs)) {
|
|
|
|
error_setg(errp, "Device is not inserted: %s",
|
|
|
|
bdrv_get_device_name(bs));
|
2016-11-08 09:50:38 +03:00
|
|
|
return NULL;
|
2014-12-18 13:37:05 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!bdrv_is_inserted(target)) {
|
|
|
|
error_setg(errp, "Device is not inserted: %s",
|
|
|
|
bdrv_get_device_name(target));
|
2016-11-08 09:50:38 +03:00
|
|
|
return NULL;
|
2014-12-18 13:37:05 +03:00
|
|
|
}
|
|
|
|
|
2016-07-22 11:17:52 +03:00
|
|
|
if (compress && target->drv->bdrv_co_pwritev_compressed == NULL) {
|
|
|
|
error_setg(errp, "Compression is not supported for this drive %s",
|
|
|
|
bdrv_get_device_name(target));
|
2016-11-08 09:50:38 +03:00
|
|
|
return NULL;
|
2016-07-22 11:17:52 +03:00
|
|
|
}
|
|
|
|
|
2014-12-18 13:37:05 +03:00
|
|
|
if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_BACKUP_SOURCE, errp)) {
|
2016-11-08 09:50:38 +03:00
|
|
|
return NULL;
|
2014-12-18 13:37:05 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
if (bdrv_op_is_blocked(target, BLOCK_OP_TYPE_BACKUP_TARGET, errp)) {
|
2016-11-08 09:50:38 +03:00
|
|
|
return NULL;
|
2014-12-18 13:37:05 +03:00
|
|
|
}
|
|
|
|
|
2015-06-05 03:20:34 +03:00
|
|
|
if (sync_mode == MIRROR_SYNC_MODE_INCREMENTAL) {
|
2015-04-18 02:49:58 +03:00
|
|
|
if (!sync_bitmap) {
|
|
|
|
error_setg(errp, "must provide a valid bitmap name for "
|
2015-06-05 03:20:34 +03:00
|
|
|
"\"incremental\" sync mode");
|
2016-11-08 09:50:38 +03:00
|
|
|
return NULL;
|
2015-04-18 02:49:58 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Create a new bitmap, and freeze/disable this one. */
|
|
|
|
if (bdrv_dirty_bitmap_create_successor(bs, sync_bitmap, errp) < 0) {
|
2016-11-08 09:50:38 +03:00
|
|
|
return NULL;
|
2015-04-18 02:49:58 +03:00
|
|
|
}
|
|
|
|
} else if (sync_bitmap) {
|
|
|
|
error_setg(errp,
|
|
|
|
"a sync_bitmap was provided to backup_run, "
|
|
|
|
"but received an incompatible sync_mode (%s)",
|
2017-08-24 11:46:08 +03:00
|
|
|
MirrorSyncMode_str(sync_mode));
|
2016-11-08 09:50:38 +03:00
|
|
|
return NULL;
|
2015-04-18 02:49:58 +03:00
|
|
|
}
|
|
|
|
|
2013-06-24 19:13:11 +04:00
|
|
|
len = bdrv_getlength(bs);
|
|
|
|
if (len < 0) {
|
|
|
|
error_setg_errno(errp, -len, "unable to get length for '%s'",
|
|
|
|
bdrv_get_device_name(bs));
|
2015-04-18 02:49:58 +03:00
|
|
|
goto error;
|
2013-06-24 19:13:11 +04:00
|
|
|
}
|
|
|
|
|
2018-01-18 20:08:22 +03:00
|
|
|
/* job->len is fixed, so we can't allow resize */
|
2018-03-10 11:27:27 +03:00
|
|
|
job = block_job_create(job_id, &backup_job_driver, txn, bs,
|
2017-01-25 13:39:04 +03:00
|
|
|
BLK_PERM_CONSISTENT_READ,
|
|
|
|
BLK_PERM_CONSISTENT_READ | BLK_PERM_WRITE |
|
|
|
|
BLK_PERM_WRITE_UNCHANGED | BLK_PERM_GRAPH_MOD,
|
2017-01-16 19:18:09 +03:00
|
|
|
speed, creation_flags, cb, opaque, errp);
|
2013-06-24 19:13:11 +04:00
|
|
|
if (!job) {
|
2015-04-18 02:49:58 +03:00
|
|
|
goto error;
|
2013-06-24 19:13:11 +04:00
|
|
|
}
|
|
|
|
|
2017-01-25 13:39:04 +03:00
|
|
|
/* The target must match the source in size, so no resize here either */
|
|
|
|
job->target = blk_new(BLK_PERM_WRITE,
|
|
|
|
BLK_PERM_CONSISTENT_READ | BLK_PERM_WRITE |
|
|
|
|
BLK_PERM_WRITE_UNCHANGED | BLK_PERM_GRAPH_MOD);
|
2017-01-13 21:02:32 +03:00
|
|
|
ret = blk_insert_bs(job->target, target, errp);
|
|
|
|
if (ret < 0) {
|
|
|
|
goto error;
|
|
|
|
}
|
2016-04-14 14:09:53 +03:00
|
|
|
|
2013-06-24 19:13:11 +04:00
|
|
|
job->on_source_error = on_source_error;
|
|
|
|
job->on_target_error = on_target_error;
|
2013-07-26 22:39:04 +04:00
|
|
|
job->sync_mode = sync_mode;
|
2015-06-05 03:20:34 +03:00
|
|
|
job->sync_bitmap = sync_mode == MIRROR_SYNC_MODE_INCREMENTAL ?
|
2015-04-18 02:49:58 +03:00
|
|
|
sync_bitmap : NULL;
|
2016-07-22 11:17:52 +03:00
|
|
|
job->compress = compress;
|
block/backup: avoid copying less than full target clusters
During incremental backups, if the target has a cluster size that is
larger than the backup cluster size and we are backing up to a target
that cannot (for whichever reason) pull clusters up from a backing image,
we may inadvertantly create unusable incremental backup images.
For example:
If the bitmap tracks changes at a 64KB granularity and we transmit 64KB
of data at a time but the target uses a 128KB cluster size, it is
possible that only half of a target cluster will be recognized as dirty
by the backup block job. When the cluster is allocated on the target
image but only half populated with data, we lose the ability to
distinguish between zero padding and uninitialized data.
This does not happen if the target image has a backing file that points
to the last known good backup.
Even if we have a backing file, though, it's likely going to be faster
to just buffer the redundant data ourselves from the live image than
fetching it from the backing file, so let's just always round up to the
target granularity.
The same logic applies to backup modes top, none, and full. Copying
fractional clusters without the guarantee of COW is dangerous, but even
if we can rely on COW, it's likely better to just re-copy the data.
Reported-by: Fam Zheng <famz@redhat.com>
Signed-off-by: John Snow <jsnow@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Message-id: 1456433911-24718-3-git-send-email-jsnow@redhat.com
Signed-off-by: Jeff Cody <jcody@redhat.com>
2016-02-25 23:58:30 +03:00
|
|
|
|
block/backup: fix fleecing scheme: use serialized writes
Fleecing scheme works as follows: we want a kind of temporary snapshot
of active drive A. We create temporary image B, with B->backing = A.
Then we start backup(sync=none) from A to B. From this point, B reads
as point-in-time snapshot of A (A continues to be active drive,
accepting guest IO).
This scheme needs some additional synchronization between reads from B
and backup COW operations, otherwise, the following situation is
theoretically possible:
(assume B is qcow2, client is NBD client, reading from B)
1. client starts reading and take qcow2 mutex in qcow2_co_preadv, and
goes up to l2 table loading (assume cache miss)
2) guest write => backup COW => qcow2 write =>
try to take qcow2 mutex => waiting
3. l2 table loaded, we see that cluster is UNALLOCATED, go to
"case QCOW2_CLUSTER_UNALLOCATED" and unlock mutex before
bdrv_co_preadv(bs->backing, ...)
4) aha, mutex unlocked, backup COW continues, and we finally finish
guest write and change cluster in our active disk A
5. actually, do bdrv_co_preadv(bs->backing, ...) and read
_new updated_ data.
To avoid this, let's make backup writes serializing, to not intersect
with reads from B.
Note: we expand range of handled cases from (sync=none and
B->backing = A) to just (A in backing chain of B), to finally allow
safe reading from B during backup for all cases when A in backing chain
of B, i.e. B formally looks like point-in-time snapshot of A.
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2018-07-09 19:37:19 +03:00
|
|
|
/* Detect image-fleecing (and similar) schemes */
|
|
|
|
job->serialize_target_writes = bdrv_chain_contains(target, bs);
|
|
|
|
|
block/backup: avoid copying less than full target clusters
During incremental backups, if the target has a cluster size that is
larger than the backup cluster size and we are backing up to a target
that cannot (for whichever reason) pull clusters up from a backing image,
we may inadvertantly create unusable incremental backup images.
For example:
If the bitmap tracks changes at a 64KB granularity and we transmit 64KB
of data at a time but the target uses a 128KB cluster size, it is
possible that only half of a target cluster will be recognized as dirty
by the backup block job. When the cluster is allocated on the target
image but only half populated with data, we lose the ability to
distinguish between zero padding and uninitialized data.
This does not happen if the target image has a backing file that points
to the last known good backup.
Even if we have a backing file, though, it's likely going to be faster
to just buffer the redundant data ourselves from the live image than
fetching it from the backing file, so let's just always round up to the
target granularity.
The same logic applies to backup modes top, none, and full. Copying
fractional clusters without the guarantee of COW is dangerous, but even
if we can rely on COW, it's likely better to just re-copy the data.
Reported-by: Fam Zheng <famz@redhat.com>
Signed-off-by: John Snow <jsnow@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Message-id: 1456433911-24718-3-git-send-email-jsnow@redhat.com
Signed-off-by: Jeff Cody <jcody@redhat.com>
2016-02-25 23:58:30 +03:00
|
|
|
/* If there is no backing file on the target, we cannot rely on COW if our
|
|
|
|
* backup cluster size is smaller than the target cluster size. Even for
|
|
|
|
* targets with a backing file, try to avoid COW if possible. */
|
2016-04-14 14:09:53 +03:00
|
|
|
ret = bdrv_get_info(target, &bdi);
|
2017-02-28 22:33:40 +03:00
|
|
|
if (ret == -ENOTSUP && !target->backing) {
|
|
|
|
/* Cluster size is not defined */
|
2017-07-12 16:57:41 +03:00
|
|
|
warn_report("The target block device doesn't provide "
|
|
|
|
"information about the block size and it doesn't have a "
|
|
|
|
"backing file. The default block size of %u bytes is "
|
|
|
|
"used. If the actual block size of the target exceeds "
|
|
|
|
"this default, the backup may be unusable",
|
|
|
|
BACKUP_CLUSTER_SIZE_DEFAULT);
|
2017-02-28 22:33:40 +03:00
|
|
|
job->cluster_size = BACKUP_CLUSTER_SIZE_DEFAULT;
|
|
|
|
} else if (ret < 0 && !target->backing) {
|
block/backup: avoid copying less than full target clusters
During incremental backups, if the target has a cluster size that is
larger than the backup cluster size and we are backing up to a target
that cannot (for whichever reason) pull clusters up from a backing image,
we may inadvertantly create unusable incremental backup images.
For example:
If the bitmap tracks changes at a 64KB granularity and we transmit 64KB
of data at a time but the target uses a 128KB cluster size, it is
possible that only half of a target cluster will be recognized as dirty
by the backup block job. When the cluster is allocated on the target
image but only half populated with data, we lose the ability to
distinguish between zero padding and uninitialized data.
This does not happen if the target image has a backing file that points
to the last known good backup.
Even if we have a backing file, though, it's likely going to be faster
to just buffer the redundant data ourselves from the live image than
fetching it from the backing file, so let's just always round up to the
target granularity.
The same logic applies to backup modes top, none, and full. Copying
fractional clusters without the guarantee of COW is dangerous, but even
if we can rely on COW, it's likely better to just re-copy the data.
Reported-by: Fam Zheng <famz@redhat.com>
Signed-off-by: John Snow <jsnow@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Message-id: 1456433911-24718-3-git-send-email-jsnow@redhat.com
Signed-off-by: Jeff Cody <jcody@redhat.com>
2016-02-25 23:58:30 +03:00
|
|
|
error_setg_errno(errp, -ret,
|
|
|
|
"Couldn't determine the cluster size of the target image, "
|
|
|
|
"which has no backing file");
|
|
|
|
error_append_hint(errp,
|
|
|
|
"Aborting, since this may create an unusable destination image\n");
|
|
|
|
goto error;
|
|
|
|
} else if (ret < 0 && target->backing) {
|
|
|
|
/* Not fatal; just trudge on ahead. */
|
|
|
|
job->cluster_size = BACKUP_CLUSTER_SIZE_DEFAULT;
|
|
|
|
} else {
|
|
|
|
job->cluster_size = MAX(BACKUP_CLUSTER_SIZE_DEFAULT, bdi.cluster_size);
|
|
|
|
}
|
2018-07-03 05:37:58 +03:00
|
|
|
job->use_copy_range = true;
|
|
|
|
job->copy_range_size = MIN_NON_ZERO(blk_get_max_transfer(job->common.blk),
|
|
|
|
blk_get_max_transfer(job->target));
|
|
|
|
job->copy_range_size = MAX(job->cluster_size,
|
|
|
|
QEMU_ALIGN_UP(job->copy_range_size,
|
|
|
|
job->cluster_size));
|
block/backup: avoid copying less than full target clusters
During incremental backups, if the target has a cluster size that is
larger than the backup cluster size and we are backing up to a target
that cannot (for whichever reason) pull clusters up from a backing image,
we may inadvertantly create unusable incremental backup images.
For example:
If the bitmap tracks changes at a 64KB granularity and we transmit 64KB
of data at a time but the target uses a 128KB cluster size, it is
possible that only half of a target cluster will be recognized as dirty
by the backup block job. When the cluster is allocated on the target
image but only half populated with data, we lose the ability to
distinguish between zero padding and uninitialized data.
This does not happen if the target image has a backing file that points
to the last known good backup.
Even if we have a backing file, though, it's likely going to be faster
to just buffer the redundant data ourselves from the live image than
fetching it from the backing file, so let's just always round up to the
target granularity.
The same logic applies to backup modes top, none, and full. Copying
fractional clusters without the guarantee of COW is dangerous, but even
if we can rely on COW, it's likely better to just re-copy the data.
Reported-by: Fam Zheng <famz@redhat.com>
Signed-off-by: John Snow <jsnow@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Message-id: 1456433911-24718-3-git-send-email-jsnow@redhat.com
Signed-off-by: Jeff Cody <jcody@redhat.com>
2016-02-25 23:58:30 +03:00
|
|
|
|
2017-01-25 13:39:04 +03:00
|
|
|
/* Required permissions are already taken with target's blk_new() */
|
2017-01-17 13:56:42 +03:00
|
|
|
block_job_add_bdrv(&job->common, "target", target, 0, BLK_PERM_ALL,
|
|
|
|
&error_abort);
|
2018-01-18 20:08:22 +03:00
|
|
|
job->len = len;
|
2016-11-08 09:50:38 +03:00
|
|
|
|
|
|
|
return &job->common;
|
2015-04-18 02:49:58 +03:00
|
|
|
|
|
|
|
error:
|
|
|
|
if (sync_bitmap) {
|
|
|
|
bdrv_reclaim_dirty_bitmap(bs, sync_bitmap, NULL);
|
|
|
|
}
|
2016-04-14 13:59:55 +03:00
|
|
|
if (job) {
|
2018-04-19 18:30:16 +03:00
|
|
|
backup_clean(&job->common.job);
|
|
|
|
job_early_fail(&job->common.job);
|
2016-04-14 13:59:55 +03:00
|
|
|
}
|
2016-11-08 09:50:38 +03:00
|
|
|
|
|
|
|
return NULL;
|
2013-06-24 19:13:11 +04:00
|
|
|
}
|