block/commit.c

   1 /*
   2  * Live block commit
   3  *
   4  * Copyright Red Hat, Inc. 2012
   5  *
   6  * Authors:
   7  *  Jeff Cody   <jcody@redhat.com>
   8  *  Based on stream.c by Stefan Hajnoczi
   9  *
  10  * This work is licensed under the terms of the GNU LGPL, version 2 or later.
  11  * See the COPYING.LIB file in the top-level directory.
  12  *
  13  */
  14
  15 #include "qemu/osdep.h"
  16 #include "trace.h"
  17 #include "block/block_int.h"
  18 #include "block/blockjob_int.h"
  19 #include "qapi/error.h"
  20 #include "qapi/qmp/qerror.h"
  21 #include "qemu/ratelimit.h"
  22 #include "sysemu/block-backend.h"
  23
  24 enum {
  25     /*
  26      * Size of data buffer for populating the image file.  This should be large
  27      * enough to process multiple clusters in a single call, so that populating
  28      * contiguous regions of the image is efficient.
  29      */
  30     COMMIT_BUFFER_SIZE = 512 * 1024, /* in bytes */
  31 };
  32
  33 #define SLICE_TIME 100000000ULL /* ns */
  34
  35 typedef struct CommitBlockJob {
  36     BlockJob common;
  37     RateLimit limit;
  38     BlockDriverState *active;
  39     BlockDriverState *commit_top_bs;
  40     BlockBackend *top;
  41     BlockBackend *base;
  42     BlockdevOnError on_error;
  43     int base_flags;
  44     int orig_overlay_flags;
  45     char *backing_file_str;
  46 } CommitBlockJob;
  47
  48 static int coroutine_fn commit_populate(BlockBackend *bs, BlockBackend *base,
  49                                         int64_t sector_num, int nb_sectors,
  50                                         void *buf)
  51 {
  52     int ret = 0;
  53     QEMUIOVector qiov;
  54     struct iovec iov = {
  55         .iov_base = buf,
  56         .iov_len = nb_sectors * BDRV_SECTOR_SIZE,
  57     };
  58
  59     qemu_iovec_init_external(&qiov, &iov, 1);
  60
  61     ret = blk_co_preadv(bs, sector_num * BDRV_SECTOR_SIZE,
  62                         qiov.size, &qiov, 0);
  63     if (ret < 0) {
  64         return ret;
  65     }
  66
  67     ret = blk_co_pwritev(base, sector_num * BDRV_SECTOR_SIZE,
  68                          qiov.size, &qiov, 0);
  69     if (ret < 0) {
  70         return ret;
  71     }
  72
  73     return 0;
  74 }
  75
  76 typedef struct {
  77     int ret;
  78 } CommitCompleteData;
  79
  80 static void commit_complete(BlockJob *job, void *opaque)
  81 {
  82     CommitBlockJob *s = container_of(job, CommitBlockJob, common);
  83     CommitCompleteData *data = opaque;
  84     BlockDriverState *active = s->active;
  85     BlockDriverState *top = blk_bs(s->top);
  86     BlockDriverState *base = blk_bs(s->base);
  87     BlockDriverState *overlay_bs = bdrv_find_overlay(active, s->commit_top_bs);
  88     int ret = data->ret;
  89     bool remove_commit_top_bs = false;
  90
  91     /* Remove base node parent that still uses BLK_PERM_WRITE/RESIZE before
  92      * the normal backing chain can be restored. */
  93     blk_unref(s->base);
  94
  95     if (!block_job_is_cancelled(&s->common) && ret == 0) {
  96         /* success */
  97         ret = bdrv_drop_intermediate(active, s->commit_top_bs, base,
  98                                      s->backing_file_str);
  99     } else if (overlay_bs) {
 100         /* XXX Can (or should) we somehow keep 'consistent read' blocked even
 101          * after the failed/cancelled commit job is gone? If we already wrote
 102          * something to base, the intermediate images aren't valid any more. */
 103         remove_commit_top_bs = true;
 104     }
 105
 106     /* restore base open flags here if appropriate (e.g., change the base back
 107      * to r/o). These reopens do not need to be atomic, since we won't abort
 108      * even on failure here */
 109     if (s->base_flags != bdrv_get_flags(base)) {
 110         bdrv_reopen(base, s->base_flags, NULL);
 111     }
 112     if (overlay_bs && s->orig_overlay_flags != bdrv_get_flags(overlay_bs)) {
 113         bdrv_reopen(overlay_bs, s->orig_overlay_flags, NULL);
 114     }
 115     g_free(s->backing_file_str);
 116     blk_unref(s->top);
 117     block_job_completed(&s->common, ret);
 118     g_free(data);
 119
 120     /* If bdrv_drop_intermediate() didn't already do that, remove the commit
 121      * filter driver from the backing chain. Do this as the final step so that
 122      * the 'consistent read' permission can be granted.  */
 123     if (remove_commit_top_bs) {
 124         bdrv_set_backing_hd(overlay_bs, top, &error_abort);
 125     }
 126 }
 127
 128 static void coroutine_fn commit_run(void *opaque)
 129 {
 130     CommitBlockJob *s = opaque;
 131     CommitCompleteData *data;
 132     int64_t sector_num, end;
 133     uint64_t delay_ns = 0;
 134     int ret = 0;
 135     int n = 0;
 136     void *buf = NULL;
 137     int bytes_written = 0;
 138     int64_t base_len;
 139
 140     ret = s->common.len = blk_getlength(s->top);
 141
 142
 143     if (s->common.len < 0) {
 144         goto out;
 145     }
 146
 147     ret = base_len = blk_getlength(s->base);
 148     if (base_len < 0) {
 149         goto out;
 150     }
 151
 152     if (base_len < s->common.len) {
 153         ret = blk_truncate(s->base, s->common.len);
 154         if (ret) {
 155             goto out;
 156         }
 157     }
 158
 159     end = s->common.len >> BDRV_SECTOR_BITS;
 160     buf = blk_blockalign(s->top, COMMIT_BUFFER_SIZE);
 161
 162     for (sector_num = 0; sector_num < end; sector_num += n) {
 163         bool copy;
 164
 165         /* Note that even when no rate limit is applied we need to yield
 166          * with no pending I/O here so that bdrv_drain_all() returns.
 167          */
 168         block_job_sleep_ns(&s->common, QEMU_CLOCK_REALTIME, delay_ns);
 169         if (block_job_is_cancelled(&s->common)) {
 170             break;
 171         }
 172         /* Copy if allocated above the base */
 173         ret = bdrv_is_allocated_above(blk_bs(s->top), blk_bs(s->base),
 174                                       sector_num,
 175                                       COMMIT_BUFFER_SIZE / BDRV_SECTOR_SIZE,
 176                                       &n);
 177         copy = (ret == 1);
 178         trace_commit_one_iteration(s, sector_num, n, ret);
 179         if (copy) {
 180             ret = commit_populate(s->top, s->base, sector_num, n, buf);
 181             bytes_written += n * BDRV_SECTOR_SIZE;
 182         }
 183         if (ret < 0) {
 184             BlockErrorAction action =
 185                 block_job_error_action(&s->common, false, s->on_error, -ret);
 186             if (action == BLOCK_ERROR_ACTION_REPORT) {
 187                 goto out;
 188             } else {
 189                 n = 0;
 190                 continue;
 191             }
 192         }
 193         /* Publish progress */
 194         s->common.offset += n * BDRV_SECTOR_SIZE;
 195
 196         if (copy && s->common.speed) {
 197             delay_ns = ratelimit_calculate_delay(&s->limit, n);
 198         }
 199     }
 200
 201     ret = 0;
 202
 203 out:
 204     qemu_vfree(buf);
 205
 206     data = g_malloc(sizeof(*data));
 207     data->ret = ret;
 208     block_job_defer_to_main_loop(&s->common, commit_complete, data);
 209 }
 210
 211 static void commit_set_speed(BlockJob *job, int64_t speed, Error **errp)
 212 {
 213     CommitBlockJob *s = container_of(job, CommitBlockJob, common);
 214
 215     if (speed < 0) {
 216         error_setg(errp, QERR_INVALID_PARAMETER, "speed");
 217         return;
 218     }
 219     ratelimit_set_speed(&s->limit, speed / BDRV_SECTOR_SIZE, SLICE_TIME);
 220 }
 221
 222 static const BlockJobDriver commit_job_driver = {
 223     .instance_size = sizeof(CommitBlockJob),
 224     .job_type      = BLOCK_JOB_TYPE_COMMIT,
 225     .set_speed     = commit_set_speed,
 226     .start         = commit_run,
 227 };
 228
 229 static int coroutine_fn bdrv_commit_top_preadv(BlockDriverState *bs,
 230     uint64_t offset, uint64_t bytes, QEMUIOVector *qiov, int flags)
 231 {
 232     return bdrv_co_preadv(bs->backing, offset, bytes, qiov, flags);
 233 }
 234
 235 static void bdrv_commit_top_close(BlockDriverState *bs)
 236 {
 237 }
 238
 239 static void bdrv_commit_top_child_perm(BlockDriverState *bs, BdrvChild *c,
 240                                        const BdrvChildRole *role,
 241                                        uint64_t perm, uint64_t shared,
 242                                        uint64_t *nperm, uint64_t *nshared)
 243 {
 244     *nperm = 0;
 245     *nshared = BLK_PERM_ALL;
 246 }
 247
 248 /* Dummy node that provides consistent read to its users without requiring it
 249  * from its backing file and that allows writes on the backing file chain. */
 250 static BlockDriver bdrv_commit_top = {
 251     .format_name        = "commit_top",
 252     .bdrv_co_preadv     = bdrv_commit_top_preadv,
 253     .bdrv_close         = bdrv_commit_top_close,
 254     .bdrv_child_perm    = bdrv_commit_top_child_perm,
 255 };
 256
 257 void commit_start(const char *job_id, BlockDriverState *bs,
 258                   BlockDriverState *base, BlockDriverState *top, int64_t speed,
 259                   BlockdevOnError on_error, const char *backing_file_str,
 260                   const char *filter_node_name, Error **errp)
 261 {
 262     CommitBlockJob *s;
 263     BlockReopenQueue *reopen_queue = NULL;
 264     int orig_overlay_flags;
 265     int orig_base_flags;
 266     BlockDriverState *iter;
 267     BlockDriverState *overlay_bs;
 268     BlockDriverState *commit_top_bs = NULL;
 269     Error *local_err = NULL;
 270     int ret;
 271
 272     assert(top != bs);
 273     if (top == base) {
 274         error_setg(errp, "Invalid files for merge: top and base are the same");
 275         return;
 276     }
 277
 278     overlay_bs = bdrv_find_overlay(bs, top);
 279
 280     if (overlay_bs == NULL) {
 281         error_setg(errp, "Could not find overlay image for %s:", top->filename);
 282         return;
 283     }
 284
 285     s = block_job_create(job_id, &commit_job_driver, bs, 0, BLK_PERM_ALL,
 286                          speed, BLOCK_JOB_DEFAULT, NULL, NULL, errp);
 287     if (!s) {
 288         return;
 289     }
 290
 291     orig_base_flags    = bdrv_get_flags(base);
 292     orig_overlay_flags = bdrv_get_flags(overlay_bs);
 293
 294     /* convert base & overlay_bs to r/w, if necessary */
 295     if (!(orig_base_flags & BDRV_O_RDWR)) {
 296         reopen_queue = bdrv_reopen_queue(reopen_queue, base, NULL,
 297                                          orig_base_flags | BDRV_O_RDWR);
 298     }
 299     if (!(orig_overlay_flags & BDRV_O_RDWR)) {
 300         reopen_queue = bdrv_reopen_queue(reopen_queue, overlay_bs, NULL,
 301                                          orig_overlay_flags | BDRV_O_RDWR);
 302     }
 303     if (reopen_queue) {
 304         bdrv_reopen_multiple(bdrv_get_aio_context(bs), reopen_queue, &local_err);
 305         if (local_err != NULL) {
 306             error_propagate(errp, local_err);
 307             goto fail;
 308         }
 309     }
 310
 311     /* Insert commit_top block node above top, so we can block consistent read
 312      * on the backing chain below it */
 313     commit_top_bs = bdrv_new_open_driver(&bdrv_commit_top, filter_node_name, 0,
 314                                          errp);
 315     if (commit_top_bs == NULL) {
 316         goto fail;
 317     }
 318
 319     bdrv_set_backing_hd(commit_top_bs, top, &local_err);
 320     if (local_err) {
 321         bdrv_unref(commit_top_bs);
 322         commit_top_bs = NULL;
 323         error_propagate(errp, local_err);
 324         goto fail;
 325     }
 326     bdrv_set_backing_hd(overlay_bs, commit_top_bs, &local_err);
 327     if (local_err) {
 328         bdrv_unref(commit_top_bs);
 329         commit_top_bs = NULL;
 330         error_propagate(errp, local_err);
 331         goto fail;
 332     }
 333
 334     s->commit_top_bs = commit_top_bs;
 335     bdrv_unref(commit_top_bs);
 336
 337     /* Block all nodes between top and base, because they will
 338      * disappear from the chain after this operation. */
 339     assert(bdrv_chain_contains(top, base));
 340     for (iter = top; iter != base; iter = backing_bs(iter)) {
 341         /* XXX BLK_PERM_WRITE needs to be allowed so we don't block ourselves
 342          * at s->base (if writes are blocked for a node, they are also blocked
 343          * for its backing file). The other options would be a second filter
 344          * driver above s->base. */
 345         ret = block_job_add_bdrv(&s->common, "intermediate node", iter, 0,
 346                                  BLK_PERM_WRITE_UNCHANGED | BLK_PERM_WRITE,
 347                                  errp);
 348         if (ret < 0) {
 349             goto fail;
 350         }
 351     }
 352
 353     ret = block_job_add_bdrv(&s->common, "base", base, 0, BLK_PERM_ALL, errp);
 354     if (ret < 0) {
 355         goto fail;
 356     }
 357
 358     /* overlay_bs must be blocked because it needs to be modified to
 359      * update the backing image string. */
 360     ret = block_job_add_bdrv(&s->common, "overlay of top", overlay_bs,
 361                              BLK_PERM_GRAPH_MOD, BLK_PERM_ALL, errp);
 362     if (ret < 0) {
 363         goto fail;
 364     }
 365
 366     s->base = blk_new(BLK_PERM_CONSISTENT_READ
 367                       | BLK_PERM_WRITE
 368                       | BLK_PERM_RESIZE,
 369                       BLK_PERM_CONSISTENT_READ
 370                       | BLK_PERM_GRAPH_MOD
 371                       | BLK_PERM_WRITE_UNCHANGED);
 372     ret = blk_insert_bs(s->base, base, errp);
 373     if (ret < 0) {
 374         goto fail;
 375     }
 376
 377     /* Required permissions are already taken with block_job_add_bdrv() */
 378     s->top = blk_new(0, BLK_PERM_ALL);
 379     ret = blk_insert_bs(s->top, top, errp);
 380     if (ret < 0) {
 381         goto fail;
 382     }
 383
 384     s->active = bs;
 385
 386     s->base_flags          = orig_base_flags;
 387     s->orig_overlay_flags  = orig_overlay_flags;
 388
 389     s->backing_file_str = g_strdup(backing_file_str);
 390
 391     s->on_error = on_error;
 392
 393     trace_commit_start(bs, base, top, s);
 394     block_job_start(&s->common);
 395     return;
 396
 397 fail:
 398     if (s->base) {
 399         blk_unref(s->base);
 400     }
 401     if (s->top) {
 402         blk_unref(s->top);
 403     }
 404     if (commit_top_bs) {
 405         bdrv_set_backing_hd(overlay_bs, top, &error_abort);
 406     }
 407     block_job_unref(&s->common);
 408 }
 409
 410
 411 #define COMMIT_BUF_SECTORS 2048
 412
 413 /* commit COW file into the raw image */
 414 int bdrv_commit(BlockDriverState *bs)
 415 {
 416     BlockBackend *src, *backing;
 417     BlockDriverState *backing_file_bs = NULL;
 418     BlockDriverState *commit_top_bs = NULL;
 419     BlockDriver *drv = bs->drv;
 420     int64_t sector, total_sectors, length, backing_length;
 421     int n, ro, open_flags;
 422     int ret = 0;
 423     uint8_t *buf = NULL;
 424     Error *local_err = NULL;
 425
 426     if (!drv)
 427         return -ENOMEDIUM;
 428
 429     if (!bs->backing) {
 430         return -ENOTSUP;
 431     }
 432
 433     if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_COMMIT_SOURCE, NULL) ||
 434         bdrv_op_is_blocked(bs->backing->bs, BLOCK_OP_TYPE_COMMIT_TARGET, NULL)) {
 435         return -EBUSY;
 436     }
 437
 438     ro = bs->backing->bs->read_only;
 439     open_flags =  bs->backing->bs->open_flags;
 440
 441     if (ro) {
 442         if (bdrv_reopen(bs->backing->bs, open_flags | BDRV_O_RDWR, NULL)) {
 443             return -EACCES;
 444         }
 445     }
 446
 447     src = blk_new(BLK_PERM_CONSISTENT_READ, BLK_PERM_ALL);
 448     backing = blk_new(BLK_PERM_WRITE | BLK_PERM_RESIZE, BLK_PERM_ALL);
 449
 450     ret = blk_insert_bs(src, bs, &local_err);
 451     if (ret < 0) {
 452         error_report_err(local_err);
 453         goto ro_cleanup;
 454     }
 455
 456     /* Insert commit_top block node above backing, so we can write to it */
 457     backing_file_bs = backing_bs(bs);
 458
 459     commit_top_bs = bdrv_new_open_driver(&bdrv_commit_top, NULL, BDRV_O_RDWR,
 460                                          &local_err);
 461     if (commit_top_bs == NULL) {
 462         error_report_err(local_err);
 463         goto ro_cleanup;
 464     }
 465
 466     bdrv_set_backing_hd(commit_top_bs, backing_file_bs, &error_abort);
 467     bdrv_set_backing_hd(bs, commit_top_bs, &error_abort);
 468
 469     ret = blk_insert_bs(backing, backing_file_bs, &local_err);
 470     if (ret < 0) {
 471         error_report_err(local_err);
 472         goto ro_cleanup;
 473     }
 474
 475     length = blk_getlength(src);
 476     if (length < 0) {
 477         ret = length;
 478         goto ro_cleanup;
 479     }
 480
 481     backing_length = blk_getlength(backing);
 482     if (backing_length < 0) {
 483         ret = backing_length;
 484         goto ro_cleanup;
 485     }
 486
 487     /* If our top snapshot is larger than the backing file image,
 488      * grow the backing file image if possible.  If not possible,
 489      * we must return an error */
 490     if (length > backing_length) {
 491         ret = blk_truncate(backing, length);
 492         if (ret < 0) {
 493             goto ro_cleanup;
 494         }
 495     }
 496
 497     total_sectors = length >> BDRV_SECTOR_BITS;
 498
 499     /* blk_try_blockalign() for src will choose an alignment that works for
 500      * backing as well, so no need to compare the alignment manually. */
 501     buf = blk_try_blockalign(src, COMMIT_BUF_SECTORS * BDRV_SECTOR_SIZE);
 502     if (buf == NULL) {
 503         ret = -ENOMEM;
 504         goto ro_cleanup;
 505     }
 506
 507     for (sector = 0; sector < total_sectors; sector += n) {
 508         ret = bdrv_is_allocated(bs, sector, COMMIT_BUF_SECTORS, &n);
 509         if (ret < 0) {
 510             goto ro_cleanup;
 511         }
 512         if (ret) {
 513             ret = blk_pread(src, sector * BDRV_SECTOR_SIZE, buf,
 514                             n * BDRV_SECTOR_SIZE);
 515             if (ret < 0) {
 516                 goto ro_cleanup;
 517             }
 518
 519             ret = blk_pwrite(backing, sector * BDRV_SECTOR_SIZE, buf,
 520                              n * BDRV_SECTOR_SIZE, 0);
 521             if (ret < 0) {
 522                 goto ro_cleanup;
 523             }
 524         }
 525     }
 526
 527     if (drv->bdrv_make_empty) {
 528         ret = drv->bdrv_make_empty(bs);
 529         if (ret < 0) {
 530             goto ro_cleanup;
 531         }
 532         blk_flush(src);
 533     }
 534
 535     /*
 536      * Make sure all data we wrote to the backing device is actually
 537      * stable on disk.
 538      */
 539     blk_flush(backing);
 540
 541     ret = 0;
 542 ro_cleanup:
 543     qemu_vfree(buf);
 544
 545     blk_unref(backing);
 546     if (backing_file_bs) {
 547         bdrv_set_backing_hd(bs, backing_file_bs, &error_abort);
 548     }
 549     bdrv_unref(commit_top_bs);
 550     blk_unref(src);
 551
 552     if (ro) {
 553         /* ignoring error return here */
 554         bdrv_reopen(bs->backing->bs, open_flags & ~BDRV_O_RDWR, NULL);
 555     }
 556
 557     return ret;
 558 }