qemu/block/stream.c
<<
>>
Prefs
   1/*
   2 * Image streaming
   3 *
   4 * Copyright IBM, Corp. 2011
   5 *
   6 * Authors:
   7 *  Stefan Hajnoczi   <stefanha@linux.vnet.ibm.com>
   8 *
   9 * This work is licensed under the terms of the GNU LGPL, version 2 or later.
  10 * See the COPYING.LIB file in the top-level directory.
  11 *
  12 */
  13
  14#include "qemu/osdep.h"
  15#include "trace.h"
  16#include "block/block_int.h"
  17#include "block/blockjob_int.h"
  18#include "qapi/error.h"
  19#include "qapi/qmp/qerror.h"
  20#include "qemu/ratelimit.h"
  21#include "sysemu/block-backend.h"
  22
  23enum {
  24    /*
  25     * Maximum chunk size to feed to copy-on-read.  This should be
  26     * large enough to process multiple clusters in a single call, so
  27     * that populating contiguous regions of the image is efficient.
  28     */
  29    STREAM_CHUNK = 512 * 1024, /* in bytes */
  30};
  31
  32typedef struct StreamBlockJob {
  33    BlockJob common;
  34    BlockDriverState *bottom;
  35    BlockdevOnError on_error;
  36    char *backing_file_str;
  37    bool bs_read_only;
  38    bool chain_frozen;
  39} StreamBlockJob;
  40
  41static int coroutine_fn stream_populate(BlockBackend *blk,
  42                                        int64_t offset, uint64_t bytes)
  43{
  44    assert(bytes < SIZE_MAX);
  45
  46    return blk_co_preadv(blk, offset, bytes, NULL,
  47                         BDRV_REQ_COPY_ON_READ | BDRV_REQ_PREFETCH);
  48}
  49
  50static void stream_abort(Job *job)
  51{
  52    StreamBlockJob *s = container_of(job, StreamBlockJob, common.job);
  53
  54    if (s->chain_frozen) {
  55        BlockJob *bjob = &s->common;
  56        bdrv_unfreeze_backing_chain(blk_bs(bjob->blk), s->bottom);
  57    }
  58}
  59
  60static int stream_prepare(Job *job)
  61{
  62    StreamBlockJob *s = container_of(job, StreamBlockJob, common.job);
  63    BlockJob *bjob = &s->common;
  64    BlockDriverState *bs = blk_bs(bjob->blk);
  65    BlockDriverState *base = backing_bs(s->bottom);
  66    Error *local_err = NULL;
  67    int ret = 0;
  68
  69    bdrv_unfreeze_backing_chain(bs, s->bottom);
  70    s->chain_frozen = false;
  71
  72    if (bs->backing) {
  73        const char *base_id = NULL, *base_fmt = NULL;
  74        if (base) {
  75            base_id = s->backing_file_str;
  76            if (base->drv) {
  77                base_fmt = base->drv->format_name;
  78            }
  79        }
  80        bdrv_set_backing_hd(bs, base, &local_err);
  81        ret = bdrv_change_backing_file(bs, base_id, base_fmt);
  82        if (local_err) {
  83            error_report_err(local_err);
  84            return -EPERM;
  85        }
  86    }
  87
  88    return ret;
  89}
  90
  91static void stream_clean(Job *job)
  92{
  93    StreamBlockJob *s = container_of(job, StreamBlockJob, common.job);
  94    BlockJob *bjob = &s->common;
  95    BlockDriverState *bs = blk_bs(bjob->blk);
  96
  97    /* Reopen the image back in read-only mode if necessary */
  98    if (s->bs_read_only) {
  99        /* Give up write permissions before making it read-only */
 100        blk_set_perm(bjob->blk, 0, BLK_PERM_ALL, &error_abort);
 101        bdrv_reopen_set_read_only(bs, true, NULL);
 102    }
 103
 104    g_free(s->backing_file_str);
 105}
 106
 107static int coroutine_fn stream_run(Job *job, Error **errp)
 108{
 109    StreamBlockJob *s = container_of(job, StreamBlockJob, common.job);
 110    BlockBackend *blk = s->common.blk;
 111    BlockDriverState *bs = blk_bs(blk);
 112    bool enable_cor = !backing_bs(s->bottom);
 113    int64_t len;
 114    int64_t offset = 0;
 115    uint64_t delay_ns = 0;
 116    int error = 0;
 117    int64_t n = 0; /* bytes */
 118
 119    if (bs == s->bottom) {
 120        /* Nothing to stream */
 121        return 0;
 122    }
 123
 124    len = bdrv_getlength(bs);
 125    if (len < 0) {
 126        return len;
 127    }
 128    job_progress_set_remaining(&s->common.job, len);
 129
 130    /* Turn on copy-on-read for the whole block device so that guest read
 131     * requests help us make progress.  Only do this when copying the entire
 132     * backing chain since the copy-on-read operation does not take base into
 133     * account.
 134     */
 135    if (enable_cor) {
 136        bdrv_enable_copy_on_read(bs);
 137    }
 138
 139    for ( ; offset < len; offset += n) {
 140        bool copy;
 141        int ret;
 142
 143        /* Note that even when no rate limit is applied we need to yield
 144         * with no pending I/O here so that bdrv_drain_all() returns.
 145         */
 146        job_sleep_ns(&s->common.job, delay_ns);
 147        if (job_is_cancelled(&s->common.job)) {
 148            break;
 149        }
 150
 151        copy = false;
 152
 153        ret = bdrv_is_allocated(bs, offset, STREAM_CHUNK, &n);
 154        if (ret == 1) {
 155            /* Allocated in the top, no need to copy.  */
 156        } else if (ret >= 0) {
 157            /* Copy if allocated in the intermediate images.  Limit to the
 158             * known-unallocated area [offset, offset+n*BDRV_SECTOR_SIZE).  */
 159            ret = bdrv_is_allocated_above(backing_bs(bs), s->bottom, true,
 160                                          offset, n, &n);
 161            /* Finish early if end of backing file has been reached */
 162            if (ret == 0 && n == 0) {
 163                n = len - offset;
 164            }
 165
 166            copy = (ret == 1);
 167        }
 168        trace_stream_one_iteration(s, offset, n, ret);
 169        if (copy) {
 170            ret = stream_populate(blk, offset, n);
 171        }
 172        if (ret < 0) {
 173            BlockErrorAction action =
 174                block_job_error_action(&s->common, s->on_error, true, -ret);
 175            if (action == BLOCK_ERROR_ACTION_STOP) {
 176                n = 0;
 177                continue;
 178            }
 179            if (error == 0) {
 180                error = ret;
 181            }
 182            if (action == BLOCK_ERROR_ACTION_REPORT) {
 183                break;
 184            }
 185        }
 186
 187        /* Publish progress */
 188        job_progress_update(&s->common.job, n);
 189        if (copy) {
 190            delay_ns = block_job_ratelimit_get_delay(&s->common, n);
 191        } else {
 192            delay_ns = 0;
 193        }
 194    }
 195
 196    if (enable_cor) {
 197        bdrv_disable_copy_on_read(bs);
 198    }
 199
 200    /* Do not remove the backing file if an error was there but ignored. */
 201    return error;
 202}
 203
 204static const BlockJobDriver stream_job_driver = {
 205    .job_driver = {
 206        .instance_size = sizeof(StreamBlockJob),
 207        .job_type      = JOB_TYPE_STREAM,
 208        .free          = block_job_free,
 209        .run           = stream_run,
 210        .prepare       = stream_prepare,
 211        .abort         = stream_abort,
 212        .clean         = stream_clean,
 213        .user_resume   = block_job_user_resume,
 214    },
 215};
 216
 217void stream_start(const char *job_id, BlockDriverState *bs,
 218                  BlockDriverState *base, const char *backing_file_str,
 219                  int creation_flags, int64_t speed,
 220                  BlockdevOnError on_error, Error **errp)
 221{
 222    StreamBlockJob *s;
 223    BlockDriverState *iter;
 224    bool bs_read_only;
 225    int basic_flags = BLK_PERM_CONSISTENT_READ | BLK_PERM_WRITE_UNCHANGED;
 226    BlockDriverState *bottom = bdrv_find_overlay(bs, base);
 227
 228    if (bdrv_freeze_backing_chain(bs, bottom, errp) < 0) {
 229        return;
 230    }
 231
 232    /* Make sure that the image is opened in read-write mode */
 233    bs_read_only = bdrv_is_read_only(bs);
 234    if (bs_read_only) {
 235        if (bdrv_reopen_set_read_only(bs, false, errp) != 0) {
 236            bs_read_only = false;
 237            goto fail;
 238        }
 239    }
 240
 241    /* Prevent concurrent jobs trying to modify the graph structure here, we
 242     * already have our own plans. Also don't allow resize as the image size is
 243     * queried only at the job start and then cached. */
 244    s = block_job_create(job_id, &stream_job_driver, NULL, bs,
 245                         basic_flags | BLK_PERM_GRAPH_MOD,
 246                         basic_flags | BLK_PERM_WRITE,
 247                         speed, creation_flags, NULL, NULL, errp);
 248    if (!s) {
 249        goto fail;
 250    }
 251
 252    /* Block all intermediate nodes between bs and base, because they will
 253     * disappear from the chain after this operation. The streaming job reads
 254     * every block only once, assuming that it doesn't change, so forbid writes
 255     * and resizes. Reassign the base node pointer because the backing BS of the
 256     * bottom node might change after the call to bdrv_reopen_set_read_only()
 257     * due to parallel block jobs running.
 258     */
 259    base = backing_bs(bottom);
 260    for (iter = backing_bs(bs); iter && iter != base; iter = backing_bs(iter)) {
 261        block_job_add_bdrv(&s->common, "intermediate node", iter, 0,
 262                           basic_flags, &error_abort);
 263    }
 264
 265    s->bottom = bottom;
 266    s->backing_file_str = g_strdup(backing_file_str);
 267    s->bs_read_only = bs_read_only;
 268    s->chain_frozen = true;
 269
 270    s->on_error = on_error;
 271    trace_stream_start(bs, base, s);
 272    job_start(&s->common.job);
 273    return;
 274
 275fail:
 276    if (bs_read_only) {
 277        bdrv_reopen_set_read_only(bs, true, NULL);
 278    }
 279    bdrv_unfreeze_backing_chain(bs, bottom);
 280}
 281