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);
 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                   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, NULL, 0, errp);
 314     if (commit_top_bs == NULL) {
 315         goto fail;
 316     }
 317
 318     bdrv_set_backing_hd(commit_top_bs, top);
 319     bdrv_set_backing_hd(overlay_bs, commit_top_bs);
 320
 321     s->commit_top_bs = commit_top_bs;
 322     bdrv_unref(commit_top_bs);
 323
 324     /* Block all nodes between top and base, because they will
 325      * disappear from the chain after this operation. */
 326     assert(bdrv_chain_contains(top, base));
 327     for (iter = top; iter != base; iter = backing_bs(iter)) {
 328         /* XXX BLK_PERM_WRITE needs to be allowed so we don't block ourselves
 329          * at s->base (if writes are blocked for a node, they are also blocked
 330          * for its backing file). The other options would be a second filter
 331          * driver above s->base. */
 332         ret = block_job_add_bdrv(&s->common, "intermediate node", iter, 0,
 333                                  BLK_PERM_WRITE_UNCHANGED | BLK_PERM_WRITE,
 334                                  errp);
 335         if (ret < 0) {
 336             goto fail;
 337         }
 338     }
 339
 340     ret = block_job_add_bdrv(&s->common, "base", base, 0, BLK_PERM_ALL, errp);
 341     if (ret < 0) {
 342         goto fail;
 343     }
 344
 345     /* overlay_bs must be blocked because it needs to be modified to
 346      * update the backing image string. */
 347     ret = block_job_add_bdrv(&s->common, "overlay of top", overlay_bs,
 348                              BLK_PERM_GRAPH_MOD, BLK_PERM_ALL, errp);
 349     if (ret < 0) {
 350         goto fail;
 351     }
 352
 353     s->base = blk_new(BLK_PERM_CONSISTENT_READ
 354                       | BLK_PERM_WRITE
 355                       | BLK_PERM_RESIZE,
 356                       BLK_PERM_CONSISTENT_READ
 357                       | BLK_PERM_GRAPH_MOD
 358                       | BLK_PERM_WRITE_UNCHANGED);
 359     ret = blk_insert_bs(s->base, base, errp);
 360     if (ret < 0) {
 361         goto fail;
 362     }
 363
 364     /* Required permissions are already taken with block_job_add_bdrv() */
 365     s->top = blk_new(0, BLK_PERM_ALL);
 366     blk_insert_bs(s->top, top, errp);
 367     if (ret < 0) {
 368         goto fail;
 369     }
 370
 371     s->active = bs;
 372
 373     s->base_flags          = orig_base_flags;
 374     s->orig_overlay_flags  = orig_overlay_flags;
 375
 376     s->backing_file_str = g_strdup(backing_file_str);
 377
 378     s->on_error = on_error;
 379
 380     trace_commit_start(bs, base, top, s);
 381     block_job_start(&s->common);
 382     return;
 383
 384 fail:
 385     if (s->base) {
 386         blk_unref(s->base);
 387     }
 388     if (s->top) {
 389         blk_unref(s->top);
 390     }
 391     if (commit_top_bs) {
 392         bdrv_set_backing_hd(overlay_bs, top);
 393     }
 394     block_job_unref(&s->common);
 395 }
 396
 397
 398 #define COMMIT_BUF_SECTORS 2048
 399
 400 /* commit COW file into the raw image */
 401 int bdrv_commit(BlockDriverState *bs)
 402 {
 403     BlockBackend *src, *backing;
 404     BlockDriver *drv = bs->drv;
 405     int64_t sector, total_sectors, length, backing_length;
 406     int n, ro, open_flags;
 407     int ret = 0;
 408     uint8_t *buf = NULL;
 409
 410     if (!drv)
 411         return -ENOMEDIUM;
 412
 413     if (!bs->backing) {
 414         return -ENOTSUP;
 415     }
 416
 417     if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_COMMIT_SOURCE, NULL) ||
 418         bdrv_op_is_blocked(bs->backing->bs, BLOCK_OP_TYPE_COMMIT_TARGET, NULL)) {
 419         return -EBUSY;
 420     }
 421
 422     ro = bs->backing->bs->read_only;
 423     open_flags =  bs->backing->bs->open_flags;
 424
 425     if (ro) {
 426         if (bdrv_reopen(bs->backing->bs, open_flags | BDRV_O_RDWR, NULL)) {
 427             return -EACCES;
 428         }
 429     }
 430
 431     /* FIXME Use real permissions */
 432     src = blk_new(0, BLK_PERM_ALL);
 433     backing = blk_new(0, BLK_PERM_ALL);
 434
 435     ret = blk_insert_bs(src, bs, NULL);
 436     if (ret < 0) {
 437         goto ro_cleanup;
 438     }
 439
 440     ret = blk_insert_bs(backing, bs->backing->bs, NULL);
 441     if (ret < 0) {
 442         goto ro_cleanup;
 443     }
 444
 445     length = blk_getlength(src);
 446     if (length < 0) {
 447         ret = length;
 448         goto ro_cleanup;
 449     }
 450
 451     backing_length = blk_getlength(backing);
 452     if (backing_length < 0) {
 453         ret = backing_length;
 454         goto ro_cleanup;
 455     }
 456
 457     /* If our top snapshot is larger than the backing file image,
 458      * grow the backing file image if possible.  If not possible,
 459      * we must return an error */
 460     if (length > backing_length) {
 461         ret = blk_truncate(backing, length);
 462         if (ret < 0) {
 463             goto ro_cleanup;
 464         }
 465     }
 466
 467     total_sectors = length >> BDRV_SECTOR_BITS;
 468
 469     /* blk_try_blockalign() for src will choose an alignment that works for
 470      * backing as well, so no need to compare the alignment manually. */
 471     buf = blk_try_blockalign(src, COMMIT_BUF_SECTORS * BDRV_SECTOR_SIZE);
 472     if (buf == NULL) {
 473         ret = -ENOMEM;
 474         goto ro_cleanup;
 475     }
 476
 477     for (sector = 0; sector < total_sectors; sector += n) {
 478         ret = bdrv_is_allocated(bs, sector, COMMIT_BUF_SECTORS, &n);
 479         if (ret < 0) {
 480             goto ro_cleanup;
 481         }
 482         if (ret) {
 483             ret = blk_pread(src, sector * BDRV_SECTOR_SIZE, buf,
 484                             n * BDRV_SECTOR_SIZE);
 485             if (ret < 0) {
 486                 goto ro_cleanup;
 487             }
 488
 489             ret = blk_pwrite(backing, sector * BDRV_SECTOR_SIZE, buf,
 490                              n * BDRV_SECTOR_SIZE, 0);
 491             if (ret < 0) {
 492                 goto ro_cleanup;
 493             }
 494         }
 495     }
 496
 497     if (drv->bdrv_make_empty) {
 498         ret = drv->bdrv_make_empty(bs);
 499         if (ret < 0) {
 500             goto ro_cleanup;
 501         }
 502         blk_flush(src);
 503     }
 504
 505     /*
 506      * Make sure all data we wrote to the backing device is actually
 507      * stable on disk.
 508      */
 509     blk_flush(backing);
 510
 511     ret = 0;
 512 ro_cleanup:
 513     qemu_vfree(buf);
 514
 515     blk_unref(src);
 516     blk_unref(backing);
 517
 518     if (ro) {
 519         /* ignoring error return here */
 520         bdrv_reopen(bs->backing->bs, open_flags & ~BDRV_O_RDWR, NULL);
 521     }
 522
 523     return ret;
 524 }