4 * Copyright (C) 2013 Proxmox Server Solutions
5 * Copyright (c) 2019 Virtuozzo International GmbH.
8 * Dietmar Maurer (dietmar@proxmox.com)
10 * This work is licensed under the terms of the GNU GPL, version 2 or later.
11 * See the COPYING file in the top-level directory.
15 #include "qemu/osdep.h"
18 #include "block/block.h"
19 #include "block/block_int.h"
20 #include "block/blockjob_int.h"
21 #include "block/block_backup.h"
22 #include "block/block-copy.h"
23 #include "qapi/error.h"
24 #include "qapi/qmp/qerror.h"
25 #include "qemu/ratelimit.h"
26 #include "qemu/cutils.h"
27 #include "sysemu/block-backend.h"
28 #include "qemu/bitmap.h"
29 #include "qemu/error-report.h"
31 #include "block/backup-top.h"
33 #define BACKUP_CLUSTER_SIZE_DEFAULT (1 << 16)
35 typedef struct BackupBlockJob {
37 BlockDriverState *backup_top;
38 BlockDriverState *source_bs;
40 BdrvDirtyBitmap *sync_bitmap;
42 MirrorSyncMode sync_mode;
43 BitmapSyncMode bitmap_mode;
44 BlockdevOnError on_source_error;
45 BlockdevOnError on_target_error;
53 static const BlockJobDriver backup_job_driver;
55 static void backup_progress_bytes_callback(int64_t bytes, void *opaque)
57 BackupBlockJob *s = opaque;
59 s->bytes_read += bytes;
62 static int coroutine_fn backup_do_cow(BackupBlockJob *job,
63 int64_t offset, uint64_t bytes,
67 int64_t start, end; /* bytes */
69 start = QEMU_ALIGN_DOWN(offset, job->cluster_size);
70 end = QEMU_ALIGN_UP(bytes + offset, job->cluster_size);
72 trace_backup_do_cow_enter(job, start, offset, bytes);
74 ret = block_copy(job->bcs, start, end - start, error_is_read);
76 trace_backup_do_cow_return(job, offset, bytes, ret);
81 static void backup_cleanup_sync_bitmap(BackupBlockJob *job, int ret)
84 bool sync = (((ret == 0) || (job->bitmap_mode == BITMAP_SYNC_MODE_ALWAYS)) \
85 && (job->bitmap_mode != BITMAP_SYNC_MODE_NEVER));
89 * We succeeded, or we always intended to sync the bitmap.
90 * Delete this bitmap and install the child.
92 bm = bdrv_dirty_bitmap_abdicate(job->sync_bitmap, NULL);
95 * We failed, or we never intended to sync the bitmap anyway.
96 * Merge the successor back into the parent, keeping all data.
98 bm = bdrv_reclaim_dirty_bitmap(job->sync_bitmap, NULL);
103 if (ret < 0 && job->bitmap_mode == BITMAP_SYNC_MODE_ALWAYS) {
104 /* If we failed and synced, merge in the bits we didn't copy: */
105 bdrv_dirty_bitmap_merge_internal(bm, block_copy_dirty_bitmap(job->bcs),
110 static void backup_commit(Job *job)
112 BackupBlockJob *s = container_of(job, BackupBlockJob, common.job);
113 if (s->sync_bitmap) {
114 backup_cleanup_sync_bitmap(s, 0);
118 static void backup_abort(Job *job)
120 BackupBlockJob *s = container_of(job, BackupBlockJob, common.job);
121 if (s->sync_bitmap) {
122 backup_cleanup_sync_bitmap(s, -1);
126 static void backup_clean(Job *job)
128 BackupBlockJob *s = container_of(job, BackupBlockJob, common.job);
129 bdrv_backup_top_drop(s->backup_top);
132 void backup_do_checkpoint(BlockJob *job, Error **errp)
134 BackupBlockJob *backup_job = container_of(job, BackupBlockJob, common);
136 assert(block_job_driver(job) == &backup_job_driver);
138 if (backup_job->sync_mode != MIRROR_SYNC_MODE_NONE) {
139 error_setg(errp, "The backup job only supports block checkpoint in"
144 bdrv_set_dirty_bitmap(block_copy_dirty_bitmap(backup_job->bcs), 0,
148 static BlockErrorAction backup_error_action(BackupBlockJob *job,
149 bool read, int error)
152 return block_job_error_action(&job->common, job->on_source_error,
155 return block_job_error_action(&job->common, job->on_target_error,
160 static bool coroutine_fn yield_and_check(BackupBlockJob *job)
164 if (job_is_cancelled(&job->common.job)) {
169 * We need to yield even for delay_ns = 0 so that bdrv_drain_all() can
170 * return. Without a yield, the VM would not reboot.
172 delay_ns = block_job_ratelimit_get_delay(&job->common, job->bytes_read);
174 job_sleep_ns(&job->common.job, delay_ns);
176 if (job_is_cancelled(&job->common.job)) {
183 static int coroutine_fn backup_loop(BackupBlockJob *job)
187 BdrvDirtyBitmapIter *bdbi;
190 bdbi = bdrv_dirty_iter_new(block_copy_dirty_bitmap(job->bcs));
191 while ((offset = bdrv_dirty_iter_next(bdbi)) != -1) {
193 if (yield_and_check(job)) {
196 ret = backup_do_cow(job, offset, job->cluster_size, &error_is_read);
197 if (ret < 0 && backup_error_action(job, error_is_read, -ret) ==
198 BLOCK_ERROR_ACTION_REPORT)
206 bdrv_dirty_iter_free(bdbi);
210 static void backup_init_bcs_bitmap(BackupBlockJob *job)
214 BdrvDirtyBitmap *bcs_bitmap = block_copy_dirty_bitmap(job->bcs);
216 if (job->sync_mode == MIRROR_SYNC_MODE_BITMAP) {
217 ret = bdrv_dirty_bitmap_merge_internal(bcs_bitmap, job->sync_bitmap,
221 if (job->sync_mode == MIRROR_SYNC_MODE_TOP) {
223 * We can't hog the coroutine to initialize this thoroughly.
224 * Set a flag and resume work when we are able to yield safely.
226 block_copy_set_skip_unallocated(job->bcs, true);
228 bdrv_set_dirty_bitmap(bcs_bitmap, 0, job->len);
231 estimate = bdrv_get_dirty_count(bcs_bitmap);
232 job_progress_set_remaining(&job->common.job, estimate);
235 static int coroutine_fn backup_run(Job *job, Error **errp)
237 BackupBlockJob *s = container_of(job, BackupBlockJob, common.job);
240 backup_init_bcs_bitmap(s);
242 if (s->sync_mode == MIRROR_SYNC_MODE_TOP) {
246 for (offset = 0; offset < s->len; ) {
247 if (yield_and_check(s)) {
252 ret = block_copy_reset_unallocated(s->bcs, offset, &count);
259 block_copy_set_skip_unallocated(s->bcs, false);
262 if (s->sync_mode == MIRROR_SYNC_MODE_NONE) {
264 * All bits are set in bcs bitmap to allow any cluster to be copied.
265 * This does not actually require them to be copied.
267 while (!job_is_cancelled(job)) {
269 * Yield until the job is cancelled. We just let our before_write
270 * notify callback service CoW requests.
275 ret = backup_loop(s);
282 static const BlockJobDriver backup_job_driver = {
284 .instance_size = sizeof(BackupBlockJob),
285 .job_type = JOB_TYPE_BACKUP,
286 .free = block_job_free,
287 .user_resume = block_job_user_resume,
289 .commit = backup_commit,
290 .abort = backup_abort,
291 .clean = backup_clean,
295 static int64_t backup_calculate_cluster_size(BlockDriverState *target,
302 * If there is no backing file on the target, we cannot rely on COW if our
303 * backup cluster size is smaller than the target cluster size. Even for
304 * targets with a backing file, try to avoid COW if possible.
306 ret = bdrv_get_info(target, &bdi);
307 if (ret == -ENOTSUP && !target->backing) {
308 /* Cluster size is not defined */
309 warn_report("The target block device doesn't provide "
310 "information about the block size and it doesn't have a "
311 "backing file. The default block size of %u bytes is "
312 "used. If the actual block size of the target exceeds "
313 "this default, the backup may be unusable",
314 BACKUP_CLUSTER_SIZE_DEFAULT);
315 return BACKUP_CLUSTER_SIZE_DEFAULT;
316 } else if (ret < 0 && !target->backing) {
317 error_setg_errno(errp, -ret,
318 "Couldn't determine the cluster size of the target image, "
319 "which has no backing file");
320 error_append_hint(errp,
321 "Aborting, since this may create an unusable destination image\n");
323 } else if (ret < 0 && target->backing) {
324 /* Not fatal; just trudge on ahead. */
325 return BACKUP_CLUSTER_SIZE_DEFAULT;
328 return MAX(BACKUP_CLUSTER_SIZE_DEFAULT, bdi.cluster_size);
331 BlockJob *backup_job_create(const char *job_id, BlockDriverState *bs,
332 BlockDriverState *target, int64_t speed,
333 MirrorSyncMode sync_mode, BdrvDirtyBitmap *sync_bitmap,
334 BitmapSyncMode bitmap_mode,
336 const char *filter_node_name,
337 BlockdevOnError on_source_error,
338 BlockdevOnError on_target_error,
340 BlockCompletionFunc *cb, void *opaque,
341 JobTxn *txn, Error **errp)
344 BackupBlockJob *job = NULL;
345 int64_t cluster_size;
346 BdrvRequestFlags write_flags;
347 BlockDriverState *backup_top = NULL;
348 BlockCopyState *bcs = NULL;
353 /* QMP interface protects us from these cases */
354 assert(sync_mode != MIRROR_SYNC_MODE_INCREMENTAL);
355 assert(sync_bitmap || sync_mode != MIRROR_SYNC_MODE_BITMAP);
358 error_setg(errp, "Source and target cannot be the same");
362 if (!bdrv_is_inserted(bs)) {
363 error_setg(errp, "Device is not inserted: %s",
364 bdrv_get_device_name(bs));
368 if (!bdrv_is_inserted(target)) {
369 error_setg(errp, "Device is not inserted: %s",
370 bdrv_get_device_name(target));
374 if (compress && !block_driver_can_compress(target->drv)) {
375 error_setg(errp, "Compression is not supported for this drive %s",
376 bdrv_get_device_name(target));
380 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_BACKUP_SOURCE, errp)) {
384 if (bdrv_op_is_blocked(target, BLOCK_OP_TYPE_BACKUP_TARGET, errp)) {
389 /* If we need to write to this bitmap, check that we can: */
390 if (bitmap_mode != BITMAP_SYNC_MODE_NEVER &&
391 bdrv_dirty_bitmap_check(sync_bitmap, BDRV_BITMAP_DEFAULT, errp)) {
395 /* Create a new bitmap, and freeze/disable this one. */
396 if (bdrv_dirty_bitmap_create_successor(sync_bitmap, errp) < 0) {
401 len = bdrv_getlength(bs);
403 error_setg_errno(errp, -len, "unable to get length for '%s'",
404 bdrv_get_device_name(bs));
408 cluster_size = backup_calculate_cluster_size(target, errp);
409 if (cluster_size < 0) {
414 * If source is in backing chain of target assume that target is going to be
415 * used for "image fleecing", i.e. it should represent a kind of snapshot of
416 * source at backup-start point in time. And target is going to be read by
417 * somebody (for example, used as NBD export) during backup job.
419 * In this case, we need to add BDRV_REQ_SERIALISING write flag to avoid
420 * intersection of backup writes and third party reads from target,
421 * otherwise reading from target we may occasionally read already updated by
424 * For more information see commit f8d59dfb40bb and test
425 * tests/qemu-iotests/222
427 write_flags = (bdrv_chain_contains(target, bs) ? BDRV_REQ_SERIALISING : 0) |
428 (compress ? BDRV_REQ_WRITE_COMPRESSED : 0),
430 backup_top = bdrv_backup_top_append(bs, target, filter_node_name,
431 cluster_size, write_flags, &bcs, errp);
436 /* job->len is fixed, so we can't allow resize */
437 job = block_job_create(job_id, &backup_job_driver, txn, backup_top,
439 speed, creation_flags, cb, opaque, errp);
444 job->backup_top = backup_top;
446 job->on_source_error = on_source_error;
447 job->on_target_error = on_target_error;
448 job->sync_mode = sync_mode;
449 job->sync_bitmap = sync_bitmap;
450 job->bitmap_mode = bitmap_mode;
452 job->cluster_size = cluster_size;
455 block_copy_set_progress_callback(bcs, backup_progress_bytes_callback, job);
456 block_copy_set_progress_meter(bcs, &job->common.job.progress);
458 /* Required permissions are already taken by backup-top target */
459 block_job_add_bdrv(&job->common, "target", target, 0, BLK_PERM_ALL,
466 bdrv_reclaim_dirty_bitmap(sync_bitmap, NULL);
469 bdrv_backup_top_drop(backup_top);