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 "trace.h"
  16 #include "block/block_int.h"
  17 #include "block/blockjob.h"
  18 #include "qapi/qmp/qerror.h"
  19 #include "qemu/ratelimit.h"
  20
  21 enum {
  22     /*
  23      * Size of data buffer for populating the image file.  This should be large
  24      * enough to process multiple clusters in a single call, so that populating
  25      * contiguous regions of the image is efficient.
  26      */
  27     COMMIT_BUFFER_SIZE = 512 * 1024, /* in bytes */
  28 };
  29
  30 #define SLICE_TIME 100000000ULL /* ns */
  31
  32 typedef struct CommitBlockJob {
  33     BlockJob common;
  34     RateLimit limit;
  35     BlockDriverState *active;
  36     BlockDriverState *top;
  37     BlockDriverState *base;
  38     BlockdevOnError on_error;
  39     int base_flags;
  40     int orig_overlay_flags;
  41     char *backing_file_str;
  42 } CommitBlockJob;
  43
  44 static int coroutine_fn commit_populate(BlockDriverState *bs,
  45                                         BlockDriverState *base,
  46                                         int64_t sector_num, int nb_sectors,
  47                                         void *buf)
  48 {
  49     int ret = 0;
  50
  51     ret = bdrv_read(bs, sector_num, buf, nb_sectors);
  52     if (ret) {
  53         return ret;
  54     }
  55
  56     ret = bdrv_write(base, sector_num, buf, nb_sectors);
  57     if (ret) {
  58         return ret;
  59     }
  60
  61     return 0;
  62 }
  63
  64 typedef struct {
  65     int ret;
  66 } CommitCompleteData;
  67
  68 static void commit_complete(BlockJob *job, void *opaque)
  69 {
  70     CommitBlockJob *s = container_of(job, CommitBlockJob, common);
  71     CommitCompleteData *data = opaque;
  72     BlockDriverState *active = s->active;
  73     BlockDriverState *top = s->top;
  74     BlockDriverState *base = s->base;
  75     BlockDriverState *overlay_bs;
  76     int ret = data->ret;
  77
  78     if (!block_job_is_cancelled(&s->common) && ret == 0) {
  79         /* success */
  80         ret = bdrv_drop_intermediate(active, top, base, s->backing_file_str);
  81     }
  82
  83     /* restore base open flags here if appropriate (e.g., change the base back
  84      * to r/o). These reopens do not need to be atomic, since we won't abort
  85      * even on failure here */
  86     if (s->base_flags != bdrv_get_flags(base)) {
  87         bdrv_reopen(base, s->base_flags, NULL);
  88     }
  89     overlay_bs = bdrv_find_overlay(active, top);
  90     if (overlay_bs && s->orig_overlay_flags != bdrv_get_flags(overlay_bs)) {
  91         bdrv_reopen(overlay_bs, s->orig_overlay_flags, NULL);
  92     }
  93     g_free(s->backing_file_str);
  94     block_job_completed(&s->common, ret);
  95     g_free(data);
  96 }
  97
  98 static void coroutine_fn commit_run(void *opaque)
  99 {
 100     CommitBlockJob *s = opaque;
 101     CommitCompleteData *data;
 102     BlockDriverState *top = s->top;
 103     BlockDriverState *base = s->base;
 104     int64_t sector_num, end;
 105     int ret = 0;
 106     int n = 0;
 107     void *buf = NULL;
 108     int bytes_written = 0;
 109     int64_t base_len;
 110
 111     ret = s->common.len = bdrv_getlength(top);
 112
 113
 114     if (s->common.len < 0) {
 115         goto out;
 116     }
 117
 118     ret = base_len = bdrv_getlength(base);
 119     if (base_len < 0) {
 120         goto out;
 121     }
 122
 123     if (base_len < s->common.len) {
 124         ret = bdrv_truncate(base, s->common.len);
 125         if (ret) {
 126             goto out;
 127         }
 128     }
 129
 130     end = s->common.len >> BDRV_SECTOR_BITS;
 131     buf = qemu_blockalign(top, COMMIT_BUFFER_SIZE);
 132
 133     for (sector_num = 0; sector_num < end; sector_num += n) {
 134         uint64_t delay_ns = 0;
 135         bool copy;
 136
 137 wait:
 138         /* Note that even when no rate limit is applied we need to yield
 139          * with no pending I/O here so that bdrv_drain_all() returns.
 140          */
 141         block_job_sleep_ns(&s->common, QEMU_CLOCK_REALTIME, delay_ns);
 142         if (block_job_is_cancelled(&s->common)) {
 143             break;
 144         }
 145         /* Copy if allocated above the base */
 146         ret = bdrv_is_allocated_above(top, base, sector_num,
 147                                       COMMIT_BUFFER_SIZE / BDRV_SECTOR_SIZE,
 148                                       &n);
 149         copy = (ret == 1);
 150         trace_commit_one_iteration(s, sector_num, n, ret);
 151         if (copy) {
 152             if (s->common.speed) {
 153                 delay_ns = ratelimit_calculate_delay(&s->limit, n);
 154                 if (delay_ns > 0) {
 155                     goto wait;
 156                 }
 157             }
 158             ret = commit_populate(top, base, sector_num, n, buf);
 159             bytes_written += n * BDRV_SECTOR_SIZE;
 160         }
 161         if (ret < 0) {
 162             if (s->on_error == BLOCKDEV_ON_ERROR_STOP ||
 163                 s->on_error == BLOCKDEV_ON_ERROR_REPORT||
 164                 (s->on_error == BLOCKDEV_ON_ERROR_ENOSPC && ret == -ENOSPC)) {
 165                 goto out;
 166             } else {
 167                 n = 0;
 168                 continue;
 169             }
 170         }
 171         /* Publish progress */
 172         s->common.offset += n * BDRV_SECTOR_SIZE;
 173     }
 174
 175     ret = 0;
 176
 177 out:
 178     qemu_vfree(buf);
 179
 180     data = g_malloc(sizeof(*data));
 181     data->ret = ret;
 182     block_job_defer_to_main_loop(&s->common, commit_complete, data);
 183 }
 184
 185 static void commit_set_speed(BlockJob *job, int64_t speed, Error **errp)
 186 {
 187     CommitBlockJob *s = container_of(job, CommitBlockJob, common);
 188
 189     if (speed < 0) {
 190         error_setg(errp, QERR_INVALID_PARAMETER, "speed");
 191         return;
 192     }
 193     ratelimit_set_speed(&s->limit, speed / BDRV_SECTOR_SIZE, SLICE_TIME);
 194 }
 195
 196 static const BlockJobDriver commit_job_driver = {
 197     .instance_size = sizeof(CommitBlockJob),
 198     .job_type      = BLOCK_JOB_TYPE_COMMIT,
 199     .set_speed     = commit_set_speed,
 200 };
 201
 202 void commit_start(BlockDriverState *bs, BlockDriverState *base,
 203                   BlockDriverState *top, int64_t speed,
 204                   BlockdevOnError on_error, BlockCompletionFunc *cb,
 205                   void *opaque, const char *backing_file_str, Error **errp)
 206 {
 207     CommitBlockJob *s;
 208     BlockReopenQueue *reopen_queue = NULL;
 209     int orig_overlay_flags;
 210     int orig_base_flags;
 211     BlockDriverState *overlay_bs;
 212     Error *local_err = NULL;
 213
 214     if ((on_error == BLOCKDEV_ON_ERROR_STOP ||
 215          on_error == BLOCKDEV_ON_ERROR_ENOSPC) &&
 216         !bdrv_iostatus_is_enabled(bs)) {
 217         error_setg(errp, "Invalid parameter combination");
 218         return;
 219     }
 220
 221     assert(top != bs);
 222     if (top == base) {
 223         error_setg(errp, "Invalid files for merge: top and base are the same");
 224         return;
 225     }
 226
 227     overlay_bs = bdrv_find_overlay(bs, top);
 228
 229     if (overlay_bs == NULL) {
 230         error_setg(errp, "Could not find overlay image for %s:", top->filename);
 231         return;
 232     }
 233
 234     orig_base_flags    = bdrv_get_flags(base);
 235     orig_overlay_flags = bdrv_get_flags(overlay_bs);
 236
 237     /* convert base & overlay_bs to r/w, if necessary */
 238     if (!(orig_base_flags & BDRV_O_RDWR)) {
 239         reopen_queue = bdrv_reopen_queue(reopen_queue, base, NULL,
 240                                          orig_base_flags | BDRV_O_RDWR);
 241     }
 242     if (!(orig_overlay_flags & BDRV_O_RDWR)) {
 243         reopen_queue = bdrv_reopen_queue(reopen_queue, overlay_bs, NULL,
 244                                          orig_overlay_flags | BDRV_O_RDWR);
 245     }
 246     if (reopen_queue) {
 247         bdrv_reopen_multiple(reopen_queue, &local_err);
 248         if (local_err != NULL) {
 249             error_propagate(errp, local_err);
 250             return;
 251         }
 252     }
 253
 254
 255     s = block_job_create(&commit_job_driver, bs, speed, cb, opaque, errp);
 256     if (!s) {
 257         return;
 258     }
 259
 260     s->base   = base;
 261     s->top    = top;
 262     s->active = bs;
 263
 264     s->base_flags          = orig_base_flags;
 265     s->orig_overlay_flags  = orig_overlay_flags;
 266
 267     s->backing_file_str = g_strdup(backing_file_str);
 268
 269     s->on_error = on_error;
 270     s->common.co = qemu_coroutine_create(commit_run);
 271
 272     trace_commit_start(bs, base, top, s, s->common.co, opaque);
 273     qemu_coroutine_enter(s->common.co, s);
 274 }