qemu/block/backup.c
<<
>>
Prefs
   1/*
   2 * QEMU backup
   3 *
   4 * Copyright (C) 2013 Proxmox Server Solutions
   5 * Copyright (c) 2019 Virtuozzo International GmbH.
   6 *
   7 * Authors:
   8 *  Dietmar Maurer (dietmar@proxmox.com)
   9 *
  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.
  12 *
  13 */
  14
  15#include "qemu/osdep.h"
  16
  17#include "trace.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/cutils.h"
  26#include "sysemu/block-backend.h"
  27#include "qemu/bitmap.h"
  28#include "qemu/error-report.h"
  29
  30#include "block/copy-before-write.h"
  31
  32typedef struct BackupBlockJob {
  33    BlockJob common;
  34    BlockDriverState *cbw;
  35    BlockDriverState *source_bs;
  36    BlockDriverState *target_bs;
  37
  38    BdrvDirtyBitmap *sync_bitmap;
  39
  40    MirrorSyncMode sync_mode;
  41    BitmapSyncMode bitmap_mode;
  42    BlockdevOnError on_source_error;
  43    BlockdevOnError on_target_error;
  44    uint64_t len;
  45    int64_t cluster_size;
  46    BackupPerf perf;
  47
  48    BlockCopyState *bcs;
  49
  50    bool wait;
  51    BlockCopyCallState *bg_bcs_call;
  52} BackupBlockJob;
  53
  54static const BlockJobDriver backup_job_driver;
  55
  56static void backup_cleanup_sync_bitmap(BackupBlockJob *job, int ret)
  57{
  58    BdrvDirtyBitmap *bm;
  59    bool sync = (((ret == 0) || (job->bitmap_mode == BITMAP_SYNC_MODE_ALWAYS)) \
  60                 && (job->bitmap_mode != BITMAP_SYNC_MODE_NEVER));
  61
  62    if (sync) {
  63        /*
  64         * We succeeded, or we always intended to sync the bitmap.
  65         * Delete this bitmap and install the child.
  66         */
  67        bm = bdrv_dirty_bitmap_abdicate(job->sync_bitmap, NULL);
  68    } else {
  69        /*
  70         * We failed, or we never intended to sync the bitmap anyway.
  71         * Merge the successor back into the parent, keeping all data.
  72         */
  73        bm = bdrv_reclaim_dirty_bitmap(job->sync_bitmap, NULL);
  74    }
  75
  76    assert(bm);
  77
  78    if (ret < 0 && job->bitmap_mode == BITMAP_SYNC_MODE_ALWAYS) {
  79        /* If we failed and synced, merge in the bits we didn't copy: */
  80        bdrv_dirty_bitmap_merge_internal(bm, block_copy_dirty_bitmap(job->bcs),
  81                                         NULL, true);
  82    }
  83}
  84
  85static void backup_commit(Job *job)
  86{
  87    BackupBlockJob *s = container_of(job, BackupBlockJob, common.job);
  88    if (s->sync_bitmap) {
  89        backup_cleanup_sync_bitmap(s, 0);
  90    }
  91}
  92
  93static void backup_abort(Job *job)
  94{
  95    BackupBlockJob *s = container_of(job, BackupBlockJob, common.job);
  96    if (s->sync_bitmap) {
  97        backup_cleanup_sync_bitmap(s, -1);
  98    }
  99}
 100
 101static void backup_clean(Job *job)
 102{
 103    BackupBlockJob *s = container_of(job, BackupBlockJob, common.job);
 104    block_job_remove_all_bdrv(&s->common);
 105    bdrv_cbw_drop(s->cbw);
 106}
 107
 108void backup_do_checkpoint(BlockJob *job, Error **errp)
 109{
 110    BackupBlockJob *backup_job = container_of(job, BackupBlockJob, common);
 111
 112    assert(block_job_driver(job) == &backup_job_driver);
 113
 114    if (backup_job->sync_mode != MIRROR_SYNC_MODE_NONE) {
 115        error_setg(errp, "The backup job only supports block checkpoint in"
 116                   " sync=none mode");
 117        return;
 118    }
 119
 120    bdrv_set_dirty_bitmap(block_copy_dirty_bitmap(backup_job->bcs), 0,
 121                          backup_job->len);
 122}
 123
 124static BlockErrorAction backup_error_action(BackupBlockJob *job,
 125                                            bool read, int error)
 126{
 127    if (read) {
 128        return block_job_error_action(&job->common, job->on_source_error,
 129                                      true, error);
 130    } else {
 131        return block_job_error_action(&job->common, job->on_target_error,
 132                                      false, error);
 133    }
 134}
 135
 136static void coroutine_fn backup_block_copy_callback(void *opaque)
 137{
 138    BackupBlockJob *s = opaque;
 139
 140    if (s->wait) {
 141        s->wait = false;
 142        aio_co_wake(s->common.job.co);
 143    } else {
 144        job_enter(&s->common.job);
 145    }
 146}
 147
 148static int coroutine_fn backup_loop(BackupBlockJob *job)
 149{
 150    BlockCopyCallState *s = NULL;
 151    int ret = 0;
 152    bool error_is_read;
 153    BlockErrorAction act;
 154
 155    while (true) { /* retry loop */
 156        job->bg_bcs_call = s = block_copy_async(job->bcs, 0,
 157                QEMU_ALIGN_UP(job->len, job->cluster_size),
 158                job->perf.max_workers, job->perf.max_chunk,
 159                backup_block_copy_callback, job);
 160
 161        while (!block_copy_call_finished(s) &&
 162               !job_is_cancelled(&job->common.job))
 163        {
 164            job_yield(&job->common.job);
 165        }
 166
 167        if (!block_copy_call_finished(s)) {
 168            assert(job_is_cancelled(&job->common.job));
 169            /*
 170             * Note that we can't use job_yield() here, as it doesn't work for
 171             * cancelled job.
 172             */
 173            block_copy_call_cancel(s);
 174            job->wait = true;
 175            qemu_coroutine_yield();
 176            assert(block_copy_call_finished(s));
 177            ret = 0;
 178            goto out;
 179        }
 180
 181        if (job_is_cancelled(&job->common.job) ||
 182            block_copy_call_succeeded(s))
 183        {
 184            ret = 0;
 185            goto out;
 186        }
 187
 188        if (block_copy_call_cancelled(s)) {
 189            /*
 190             * Job is not cancelled but only block-copy call. This is possible
 191             * after job pause. Now the pause is finished, start new block-copy
 192             * iteration.
 193             */
 194            block_copy_call_free(s);
 195            continue;
 196        }
 197
 198        /* The only remaining case is failed block-copy call. */
 199        assert(block_copy_call_failed(s));
 200
 201        ret = block_copy_call_status(s, &error_is_read);
 202        act = backup_error_action(job, error_is_read, -ret);
 203        switch (act) {
 204        case BLOCK_ERROR_ACTION_REPORT:
 205            goto out;
 206        case BLOCK_ERROR_ACTION_STOP:
 207            /*
 208             * Go to pause prior to starting new block-copy call on the next
 209             * iteration.
 210             */
 211            job_pause_point(&job->common.job);
 212            break;
 213        case BLOCK_ERROR_ACTION_IGNORE:
 214            /* Proceed to new block-copy call to retry. */
 215            break;
 216        default:
 217            abort();
 218        }
 219
 220        block_copy_call_free(s);
 221    }
 222
 223out:
 224    block_copy_call_free(s);
 225    job->bg_bcs_call = NULL;
 226    return ret;
 227}
 228
 229static void backup_init_bcs_bitmap(BackupBlockJob *job)
 230{
 231    uint64_t estimate;
 232    BdrvDirtyBitmap *bcs_bitmap = block_copy_dirty_bitmap(job->bcs);
 233
 234    if (job->sync_mode == MIRROR_SYNC_MODE_BITMAP) {
 235        bdrv_clear_dirty_bitmap(bcs_bitmap, NULL);
 236        bdrv_dirty_bitmap_merge_internal(bcs_bitmap, job->sync_bitmap, NULL,
 237                                         true);
 238    } else if (job->sync_mode == MIRROR_SYNC_MODE_TOP) {
 239        /*
 240         * We can't hog the coroutine to initialize this thoroughly.
 241         * Set a flag and resume work when we are able to yield safely.
 242         */
 243        block_copy_set_skip_unallocated(job->bcs, true);
 244    }
 245
 246    estimate = bdrv_get_dirty_count(bcs_bitmap);
 247    job_progress_set_remaining(&job->common.job, estimate);
 248}
 249
 250static int coroutine_fn backup_run(Job *job, Error **errp)
 251{
 252    BackupBlockJob *s = container_of(job, BackupBlockJob, common.job);
 253    int ret;
 254
 255    backup_init_bcs_bitmap(s);
 256
 257    if (s->sync_mode == MIRROR_SYNC_MODE_TOP) {
 258        int64_t offset = 0;
 259        int64_t count;
 260
 261        for (offset = 0; offset < s->len; ) {
 262            if (job_is_cancelled(job)) {
 263                return -ECANCELED;
 264            }
 265
 266            job_pause_point(job);
 267
 268            if (job_is_cancelled(job)) {
 269                return -ECANCELED;
 270            }
 271
 272            ret = block_copy_reset_unallocated(s->bcs, offset, &count);
 273            if (ret < 0) {
 274                return ret;
 275            }
 276
 277            offset += count;
 278        }
 279        block_copy_set_skip_unallocated(s->bcs, false);
 280    }
 281
 282    if (s->sync_mode == MIRROR_SYNC_MODE_NONE) {
 283        /*
 284         * All bits are set in bcs bitmap to allow any cluster to be copied.
 285         * This does not actually require them to be copied.
 286         */
 287        while (!job_is_cancelled(job)) {
 288            /*
 289             * Yield until the job is cancelled.  We just let our before_write
 290             * notify callback service CoW requests.
 291             */
 292            job_yield(job);
 293        }
 294    } else {
 295        return backup_loop(s);
 296    }
 297
 298    return 0;
 299}
 300
 301static void coroutine_fn backup_pause(Job *job)
 302{
 303    BackupBlockJob *s = container_of(job, BackupBlockJob, common.job);
 304
 305    if (s->bg_bcs_call && !block_copy_call_finished(s->bg_bcs_call)) {
 306        block_copy_call_cancel(s->bg_bcs_call);
 307        s->wait = true;
 308        qemu_coroutine_yield();
 309    }
 310}
 311
 312static void backup_set_speed(BlockJob *job, int64_t speed)
 313{
 314    BackupBlockJob *s = container_of(job, BackupBlockJob, common);
 315
 316    /*
 317     * block_job_set_speed() is called first from block_job_create(), when we
 318     * don't yet have s->bcs.
 319     */
 320    if (s->bcs) {
 321        block_copy_set_speed(s->bcs, speed);
 322        if (s->bg_bcs_call) {
 323            block_copy_kick(s->bg_bcs_call);
 324        }
 325    }
 326}
 327
 328static bool backup_cancel(Job *job, bool force)
 329{
 330    BackupBlockJob *s = container_of(job, BackupBlockJob, common.job);
 331
 332    bdrv_cancel_in_flight(s->target_bs);
 333    return true;
 334}
 335
 336static const BlockJobDriver backup_job_driver = {
 337    .job_driver = {
 338        .instance_size          = sizeof(BackupBlockJob),
 339        .job_type               = JOB_TYPE_BACKUP,
 340        .free                   = block_job_free,
 341        .user_resume            = block_job_user_resume,
 342        .run                    = backup_run,
 343        .commit                 = backup_commit,
 344        .abort                  = backup_abort,
 345        .clean                  = backup_clean,
 346        .pause                  = backup_pause,
 347        .cancel                 = backup_cancel,
 348    },
 349    .set_speed = backup_set_speed,
 350};
 351
 352BlockJob *backup_job_create(const char *job_id, BlockDriverState *bs,
 353                  BlockDriverState *target, int64_t speed,
 354                  MirrorSyncMode sync_mode, BdrvDirtyBitmap *sync_bitmap,
 355                  BitmapSyncMode bitmap_mode,
 356                  bool compress,
 357                  const char *filter_node_name,
 358                  BackupPerf *perf,
 359                  BlockdevOnError on_source_error,
 360                  BlockdevOnError on_target_error,
 361                  int creation_flags,
 362                  BlockCompletionFunc *cb, void *opaque,
 363                  JobTxn *txn, Error **errp)
 364{
 365    int64_t len, target_len;
 366    BackupBlockJob *job = NULL;
 367    int64_t cluster_size;
 368    BlockDriverState *cbw = NULL;
 369    BlockCopyState *bcs = NULL;
 370
 371    assert(bs);
 372    assert(target);
 373    GLOBAL_STATE_CODE();
 374
 375    /* QMP interface protects us from these cases */
 376    assert(sync_mode != MIRROR_SYNC_MODE_INCREMENTAL);
 377    assert(sync_bitmap || sync_mode != MIRROR_SYNC_MODE_BITMAP);
 378
 379    if (bs == target) {
 380        error_setg(errp, "Source and target cannot be the same");
 381        return NULL;
 382    }
 383
 384    if (!bdrv_is_inserted(bs)) {
 385        error_setg(errp, "Device is not inserted: %s",
 386                   bdrv_get_device_name(bs));
 387        return NULL;
 388    }
 389
 390    if (!bdrv_is_inserted(target)) {
 391        error_setg(errp, "Device is not inserted: %s",
 392                   bdrv_get_device_name(target));
 393        return NULL;
 394    }
 395
 396    if (compress && !bdrv_supports_compressed_writes(target)) {
 397        error_setg(errp, "Compression is not supported for this drive %s",
 398                   bdrv_get_device_name(target));
 399        return NULL;
 400    }
 401
 402    if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_BACKUP_SOURCE, errp)) {
 403        return NULL;
 404    }
 405
 406    if (bdrv_op_is_blocked(target, BLOCK_OP_TYPE_BACKUP_TARGET, errp)) {
 407        return NULL;
 408    }
 409
 410    if (perf->max_workers < 1 || perf->max_workers > INT_MAX) {
 411        error_setg(errp, "max-workers must be between 1 and %d", INT_MAX);
 412        return NULL;
 413    }
 414
 415    if (perf->max_chunk < 0) {
 416        error_setg(errp, "max-chunk must be zero (which means no limit) or "
 417                   "positive");
 418        return NULL;
 419    }
 420
 421    if (sync_bitmap) {
 422        /* If we need to write to this bitmap, check that we can: */
 423        if (bitmap_mode != BITMAP_SYNC_MODE_NEVER &&
 424            bdrv_dirty_bitmap_check(sync_bitmap, BDRV_BITMAP_DEFAULT, errp)) {
 425            return NULL;
 426        }
 427
 428        /* Create a new bitmap, and freeze/disable this one. */
 429        if (bdrv_dirty_bitmap_create_successor(sync_bitmap, errp) < 0) {
 430            return NULL;
 431        }
 432    }
 433
 434    len = bdrv_getlength(bs);
 435    if (len < 0) {
 436        error_setg_errno(errp, -len, "Unable to get length for '%s'",
 437                         bdrv_get_device_or_node_name(bs));
 438        goto error;
 439    }
 440
 441    target_len = bdrv_getlength(target);
 442    if (target_len < 0) {
 443        error_setg_errno(errp, -target_len, "Unable to get length for '%s'",
 444                         bdrv_get_device_or_node_name(bs));
 445        goto error;
 446    }
 447
 448    if (target_len != len) {
 449        error_setg(errp, "Source and target image have different sizes");
 450        goto error;
 451    }
 452
 453    cbw = bdrv_cbw_append(bs, target, filter_node_name, &bcs, errp);
 454    if (!cbw) {
 455        goto error;
 456    }
 457
 458    cluster_size = block_copy_cluster_size(bcs);
 459
 460    if (perf->max_chunk && perf->max_chunk < cluster_size) {
 461        error_setg(errp, "Required max-chunk (%" PRIi64 ") is less than backup "
 462                   "cluster size (%" PRIi64 ")", perf->max_chunk, cluster_size);
 463        goto error;
 464    }
 465
 466    /* job->len is fixed, so we can't allow resize */
 467    job = block_job_create(job_id, &backup_job_driver, txn, cbw,
 468                           0, BLK_PERM_ALL,
 469                           speed, creation_flags, cb, opaque, errp);
 470    if (!job) {
 471        goto error;
 472    }
 473
 474    job->cbw = cbw;
 475    job->source_bs = bs;
 476    job->target_bs = target;
 477    job->on_source_error = on_source_error;
 478    job->on_target_error = on_target_error;
 479    job->sync_mode = sync_mode;
 480    job->sync_bitmap = sync_bitmap;
 481    job->bitmap_mode = bitmap_mode;
 482    job->bcs = bcs;
 483    job->cluster_size = cluster_size;
 484    job->len = len;
 485    job->perf = *perf;
 486
 487    block_copy_set_copy_opts(bcs, perf->use_copy_range, compress);
 488    block_copy_set_progress_meter(bcs, &job->common.job.progress);
 489    block_copy_set_speed(bcs, speed);
 490
 491    /* Required permissions are taken by copy-before-write filter target */
 492    block_job_add_bdrv(&job->common, "target", target, 0, BLK_PERM_ALL,
 493                       &error_abort);
 494
 495    return &job->common;
 496
 497 error:
 498    if (sync_bitmap) {
 499        bdrv_reclaim_dirty_bitmap(sync_bitmap, NULL);
 500    }
 501    if (cbw) {
 502        bdrv_cbw_drop(cbw);
 503    }
 504
 505    return NULL;
 506}
 507