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