| /* | |
| * QEMU backup | |
| * | |
| * Copyright (C) 2013 Proxmox Server Solutions | |
| * Copyright (c) 2019 Virtuozzo International GmbH. | |
| * | |
| * 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. | |
| * | |
| */ | |
| #include "qemu/osdep.h" | |
| #include "trace.h" | |
| #include "block/block.h" | |
| #include "block/block_int.h" | |
| #include "block/blockjob_int.h" | |
| #include "block/block_backup.h" | |
| #include "block/block-copy.h" | |
| #include "block/dirty-bitmap.h" | |
| #include "qapi/error.h" | |
| #include "qemu/cutils.h" | |
| #include "system/block-backend.h" | |
| #include "qemu/bitmap.h" | |
| #include "qemu/error-report.h" | |
| #include "block/copy-before-write.h" | |
| typedef struct BackupBlockJob { | |
| BlockJob common; | |
| BlockDriverState *cbw; | |
| BlockDriverState *source_bs; | |
| BlockDriverState *target_bs; | |
| BdrvDirtyBitmap *sync_bitmap; | |
| MirrorSyncMode sync_mode; | |
| BitmapSyncMode bitmap_mode; | |
| BlockdevOnError on_source_error; | |
| BlockdevOnError on_target_error; | |
| uint64_t len; | |
| int64_t cluster_size; | |
| BackupPerf perf; | |
| BlockCopyState *bcs; | |
| bool wait; | |
| BlockCopyCallState *bg_bcs_call; | |
| } BackupBlockJob; | |
| static const BlockJobDriver backup_job_driver; | |
| static void backup_cleanup_sync_bitmap(BackupBlockJob *job, int ret) | |
| { | |
| BdrvDirtyBitmap *bm; | |
| bool sync = (((ret == 0) || (job->bitmap_mode == BITMAP_SYNC_MODE_ALWAYS)) \ | |
| && (job->bitmap_mode != BITMAP_SYNC_MODE_NEVER)); | |
| if (sync) { | |
| /* | |
| * We succeeded, or we always intended to sync the bitmap. | |
| * Delete this bitmap and install the child. | |
| */ | |
| bm = bdrv_dirty_bitmap_abdicate(job->sync_bitmap, NULL); | |
| } else { | |
| /* | |
| * We failed, or we never intended to sync the bitmap anyway. | |
| * Merge the successor back into the parent, keeping all data. | |
| */ | |
| bm = bdrv_reclaim_dirty_bitmap(job->sync_bitmap, NULL); | |
| } | |
| assert(bm); | |
| 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, block_copy_dirty_bitmap(job->bcs), | |
| NULL, true); | |
| } | |
| } | |
| static void backup_commit(Job *job) | |
| { | |
| BackupBlockJob *s = container_of(job, BackupBlockJob, common.job); | |
| if (s->sync_bitmap) { | |
| backup_cleanup_sync_bitmap(s, 0); | |
| } | |
| } | |
| static void backup_abort(Job *job) | |
| { | |
| BackupBlockJob *s = container_of(job, BackupBlockJob, common.job); | |
| if (s->sync_bitmap) { | |
| backup_cleanup_sync_bitmap(s, -1); | |
| } | |
| } | |
| static void backup_clean(Job *job) | |
| { | |
| BackupBlockJob *s = container_of(job, BackupBlockJob, common.job); | |
| block_job_remove_all_bdrv(&s->common); | |
| bdrv_cbw_drop(s->cbw); | |
| } | |
| void backup_do_checkpoint(BlockJob *job, Error **errp) | |
| { | |
| BackupBlockJob *backup_job = container_of(job, BackupBlockJob, common); | |
| assert(block_job_driver(job) == &backup_job_driver); | |
| if (backup_job->sync_mode != MIRROR_SYNC_MODE_NONE) { | |
| error_setg(errp, "The backup job only supports block checkpoint in" | |
| " sync=none mode"); | |
| return; | |
| } | |
| bdrv_set_dirty_bitmap(block_copy_dirty_bitmap(backup_job->bcs), 0, | |
| backup_job->len); | |
| } | |
| static BlockErrorAction backup_error_action(BackupBlockJob *job, | |
| bool read, int error) | |
| { | |
| if (read) { | |
| return block_job_error_action(&job->common, job->on_source_error, | |
| true, error); | |
| } else { | |
| return block_job_error_action(&job->common, job->on_target_error, | |
| false, error); | |
| } | |
| } | |
| static void coroutine_fn backup_block_copy_callback(void *opaque) | |
| { | |
| BackupBlockJob *s = opaque; | |
| if (s->wait) { | |
| s->wait = false; | |
| aio_co_wake(s->common.job.co); | |
| } else { | |
| job_enter(&s->common.job); | |
| } | |
| } | |
| static int coroutine_fn backup_loop(BackupBlockJob *job) | |
| { | |
| BlockCopyCallState *s = NULL; | |
| int ret = 0; | |
| bool error_is_read; | |
| BlockErrorAction act; | |
| while (true) { /* retry loop */ | |
| job->bg_bcs_call = s = block_copy_async(job->bcs, 0, | |
| QEMU_ALIGN_UP(job->len, job->cluster_size), | |
| job->perf.max_workers, job->perf.max_chunk, | |
| backup_block_copy_callback, job); | |
| while (!block_copy_call_finished(s) && | |
| !job_is_cancelled(&job->common.job)) | |
| { | |
| job_yield(&job->common.job); | |
| } | |
| if (!block_copy_call_finished(s)) { | |
| assert(job_is_cancelled(&job->common.job)); | |
| /* | |
| * Note that we can't use job_yield() here, as it doesn't work for | |
| * cancelled job. | |
| */ | |
| block_copy_call_cancel(s); | |
| job->wait = true; | |
| qemu_coroutine_yield(); | |
| assert(block_copy_call_finished(s)); | |
| ret = 0; | |
| goto out; | |
| } | |
| if (job_is_cancelled(&job->common.job) || | |
| block_copy_call_succeeded(s)) | |
| { | |
| ret = 0; | |
| goto out; | |
| } | |
| if (block_copy_call_cancelled(s)) { | |
| /* | |
| * Job is not cancelled but only block-copy call. This is possible | |
| * after job pause. Now the pause is finished, start new block-copy | |
| * iteration. | |
| */ | |
| block_copy_call_free(s); | |
| continue; | |
| } | |
| /* The only remaining case is failed block-copy call. */ | |
| assert(block_copy_call_failed(s)); | |
| ret = block_copy_call_status(s, &error_is_read); | |
| act = backup_error_action(job, error_is_read, -ret); | |
| switch (act) { | |
| case BLOCK_ERROR_ACTION_REPORT: | |
| goto out; | |
| case BLOCK_ERROR_ACTION_STOP: | |
| /* | |
| * Go to pause prior to starting new block-copy call on the next | |
| * iteration. | |
| */ | |
| job_pause_point(&job->common.job); | |
| break; | |
| case BLOCK_ERROR_ACTION_IGNORE: | |
| /* Proceed to new block-copy call to retry. */ | |
| break; | |
| default: | |
| abort(); | |
| } | |
| block_copy_call_free(s); | |
| } | |
| out: | |
| block_copy_call_free(s); | |
| job->bg_bcs_call = NULL; | |
| return ret; | |
| } | |
| static void backup_init_bcs_bitmap(BackupBlockJob *job) | |
| { | |
| uint64_t estimate; | |
| BdrvDirtyBitmap *bcs_bitmap = block_copy_dirty_bitmap(job->bcs); | |
| if (job->sync_mode == MIRROR_SYNC_MODE_BITMAP) { | |
| bdrv_clear_dirty_bitmap(bcs_bitmap, NULL); | |
| bdrv_dirty_bitmap_merge_internal(bcs_bitmap, job->sync_bitmap, NULL, | |
| true); | |
| } else if (job->sync_mode == MIRROR_SYNC_MODE_TOP) { | |
| /* | |
| * We can't hog the coroutine to initialize this thoroughly. | |
| * Set a flag and resume work when we are able to yield safely. | |
| */ | |
| block_copy_set_skip_unallocated(job->bcs, true); | |
| } | |
| estimate = bdrv_get_dirty_count(bcs_bitmap); | |
| job_progress_set_remaining(&job->common.job, estimate); | |
| } | |
| static int coroutine_fn backup_run(Job *job, Error **errp) | |
| { | |
| BackupBlockJob *s = container_of(job, BackupBlockJob, common.job); | |
| int ret; | |
| backup_init_bcs_bitmap(s); | |
| if (s->sync_mode == MIRROR_SYNC_MODE_TOP) { | |
| int64_t offset = 0; | |
| int64_t count; | |
| for (offset = 0; offset < s->len; ) { | |
| if (job_is_cancelled(job)) { | |
| return -ECANCELED; | |
| } | |
| job_pause_point(job); | |
| if (job_is_cancelled(job)) { | |
| return -ECANCELED; | |
| } | |
| /* rdlock protects the subsequent call to bdrv_is_allocated() */ | |
| bdrv_graph_co_rdlock(); | |
| ret = block_copy_reset_unallocated(s->bcs, offset, &count); | |
| bdrv_graph_co_rdunlock(); | |
| if (ret < 0) { | |
| return ret; | |
| } | |
| offset += count; | |
| } | |
| block_copy_set_skip_unallocated(s->bcs, false); | |
| } | |
| if (s->sync_mode == MIRROR_SYNC_MODE_NONE) { | |
| /* | |
| * 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)) { | |
| /* | |
| * Yield until the job is cancelled. We just let our before_write | |
| * notify callback service CoW requests. | |
| */ | |
| job_yield(job); | |
| } | |
| } else { | |
| return backup_loop(s); | |
| } | |
| return 0; | |
| } | |
| static void coroutine_fn backup_pause(Job *job) | |
| { | |
| BackupBlockJob *s = container_of(job, BackupBlockJob, common.job); | |
| if (s->bg_bcs_call && !block_copy_call_finished(s->bg_bcs_call)) { | |
| block_copy_call_cancel(s->bg_bcs_call); | |
| s->wait = true; | |
| qemu_coroutine_yield(); | |
| } | |
| } | |
| static void backup_set_speed(BlockJob *job, int64_t speed) | |
| { | |
| BackupBlockJob *s = container_of(job, BackupBlockJob, common); | |
| /* | |
| * block_job_set_speed() is called first from block_job_create(), when we | |
| * don't yet have s->bcs. | |
| */ | |
| if (s->bcs) { | |
| block_copy_set_speed(s->bcs, speed); | |
| if (s->bg_bcs_call) { | |
| block_copy_kick(s->bg_bcs_call); | |
| } | |
| } | |
| } | |
| static bool backup_cancel(Job *job, bool force) | |
| { | |
| BackupBlockJob *s = container_of(job, BackupBlockJob, common.job); | |
| bdrv_cancel_in_flight(s->target_bs); | |
| return true; | |
| } | |
| static const BlockJobDriver backup_job_driver = { | |
| .job_driver = { | |
| .instance_size = sizeof(BackupBlockJob), | |
| .job_type = JOB_TYPE_BACKUP, | |
| .free = block_job_free, | |
| .user_resume = block_job_user_resume, | |
| .run = backup_run, | |
| .commit = backup_commit, | |
| .abort = backup_abort, | |
| .clean = backup_clean, | |
| .pause = backup_pause, | |
| .cancel = backup_cancel, | |
| }, | |
| .set_speed = backup_set_speed, | |
| }; | |
| BlockJob *backup_job_create(const char *job_id, BlockDriverState *bs, | |
| BlockDriverState *target, int64_t speed, | |
| MirrorSyncMode sync_mode, BdrvDirtyBitmap *sync_bitmap, | |
| BitmapSyncMode bitmap_mode, | |
| bool compress, bool discard_source, | |
| const char *filter_node_name, | |
| BackupPerf *perf, | |
| BlockdevOnError on_source_error, | |
| BlockdevOnError on_target_error, | |
| OnCbwError on_cbw_error, | |
| int creation_flags, | |
| BlockCompletionFunc *cb, void *opaque, | |
| JobTxn *txn, Error **errp) | |
| { | |
| int64_t len, target_len; | |
| BackupBlockJob *job = NULL; | |
| int64_t cluster_size; | |
| BlockDriverState *cbw = NULL; | |
| BlockCopyState *bcs = NULL; | |
| assert(bs); | |
| assert(target); | |
| GLOBAL_STATE_CODE(); | |
| /* QMP interface protects us from these cases */ | |
| assert(sync_mode != MIRROR_SYNC_MODE_INCREMENTAL); | |
| assert(sync_bitmap || sync_mode != MIRROR_SYNC_MODE_BITMAP); | |
| if (bs == target) { | |
| error_setg(errp, "Source and target cannot be the same"); | |
| return NULL; | |
| } | |
| bdrv_graph_rdlock_main_loop(); | |
| if (!bdrv_is_inserted(bs)) { | |
| error_setg(errp, "Device is not inserted: %s", | |
| bdrv_get_device_name(bs)); | |
| goto error_rdlock; | |
| } | |
| if (!bdrv_is_inserted(target)) { | |
| error_setg(errp, "Device is not inserted: %s", | |
| bdrv_get_device_name(target)); | |
| goto error_rdlock; | |
| } | |
| if (compress && !bdrv_supports_compressed_writes(target)) { | |
| error_setg(errp, "Compression is not supported for this drive %s", | |
| bdrv_get_device_name(target)); | |
| goto error_rdlock; | |
| } | |
| if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_BACKUP_SOURCE, errp)) { | |
| goto error_rdlock; | |
| } | |
| if (bdrv_op_is_blocked(target, BLOCK_OP_TYPE_BACKUP_TARGET, errp)) { | |
| goto error_rdlock; | |
| } | |
| bdrv_graph_rdunlock_main_loop(); | |
| if (perf->max_workers < 1 || perf->max_workers > INT_MAX) { | |
| error_setg(errp, "max-workers must be between 1 and %d", INT_MAX); | |
| return NULL; | |
| } | |
| if (perf->max_chunk < 0) { | |
| error_setg(errp, "max-chunk must be zero (which means no limit) or " | |
| "positive"); | |
| return NULL; | |
| } | |
| if (sync_bitmap) { | |
| /* If we need to write to this bitmap, check that we can: */ | |
| if (bitmap_mode != BITMAP_SYNC_MODE_NEVER && | |
| bdrv_dirty_bitmap_check(sync_bitmap, BDRV_BITMAP_DEFAULT, errp)) { | |
| return NULL; | |
| } | |
| /* Create a new bitmap, and freeze/disable this one. */ | |
| if (bdrv_dirty_bitmap_create_successor(sync_bitmap, errp) < 0) { | |
| return NULL; | |
| } | |
| } | |
| len = bdrv_getlength(bs); | |
| if (len < 0) { | |
| GRAPH_RDLOCK_GUARD_MAINLOOP(); | |
| error_setg_errno(errp, -len, "Unable to get length for '%s'", | |
| bdrv_get_device_or_node_name(bs)); | |
| goto error; | |
| } | |
| target_len = bdrv_getlength(target); | |
| if (target_len < 0) { | |
| GRAPH_RDLOCK_GUARD_MAINLOOP(); | |
| error_setg_errno(errp, -target_len, "Unable to get length for '%s'", | |
| bdrv_get_device_or_node_name(bs)); | |
| goto error; | |
| } | |
| if (target_len != len) { | |
| error_setg(errp, "Source and target image have different sizes"); | |
| goto error; | |
| } | |
| cbw = bdrv_cbw_append(bs, target, filter_node_name, discard_source, | |
| perf->min_cluster_size, &bcs, on_cbw_error, errp); | |
| if (!cbw) { | |
| goto error; | |
| } | |
| cluster_size = block_copy_cluster_size(bcs); | |
| if (perf->max_chunk && perf->max_chunk < cluster_size) { | |
| error_setg(errp, "Required max-chunk (%" PRIi64 ") is less than backup " | |
| "cluster size (%" PRIi64 ")", perf->max_chunk, cluster_size); | |
| goto error; | |
| } | |
| /* job->len is fixed, so we can't allow resize */ | |
| job = block_job_create(job_id, &backup_job_driver, txn, cbw, | |
| 0, BLK_PERM_ALL, | |
| speed, creation_flags, cb, opaque, errp); | |
| if (!job) { | |
| goto error; | |
| } | |
| job->cbw = cbw; | |
| job->source_bs = bs; | |
| job->target_bs = target; | |
| job->on_source_error = on_source_error; | |
| job->on_target_error = on_target_error; | |
| job->sync_mode = sync_mode; | |
| job->sync_bitmap = sync_bitmap; | |
| job->bitmap_mode = bitmap_mode; | |
| job->bcs = bcs; | |
| job->cluster_size = cluster_size; | |
| job->len = len; | |
| job->perf = *perf; | |
| block_copy_set_copy_opts(bcs, perf->use_copy_range, compress); | |
| block_copy_set_progress_meter(bcs, &job->common.job.progress); | |
| block_copy_set_speed(bcs, speed); | |
| /* Required permissions are taken by copy-before-write filter target */ | |
| bdrv_graph_wrlock_drained(); | |
| block_job_add_bdrv(&job->common, "target", target, 0, BLK_PERM_ALL, | |
| &error_abort); | |
| bdrv_graph_wrunlock(); | |
| return &job->common; | |
| error: | |
| if (sync_bitmap) { | |
| bdrv_reclaim_dirty_bitmap(sync_bitmap, NULL); | |
| } | |
| if (cbw) { | |
| bdrv_cbw_drop(cbw); | |
| } | |
| return NULL; | |
| error_rdlock: | |
| bdrv_graph_rdunlock_main_loop(); | |
| return NULL; | |
| } |