stream.c 5.84 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
/*
 * Image streaming
 *
 * Copyright IBM, Corp. 2011
 *
 * Authors:
 *  Stefan Hajnoczi   <stefanha@linux.vnet.ibm.com>
 *
 * This work is licensed under the terms of the GNU LGPL, version 2 or later.
 * See the COPYING.LIB file in the top-level directory.
 *
 */

#include "trace.h"
#include "block_int.h"
16
#include "qemu/ratelimit.h"
17 18 19 20 21 22 23 24 25 26

enum {
    /*
     * Size of data buffer for populating the image file.  This should be large
     * enough to process multiple clusters in a single call, so that populating
     * contiguous regions of the image is efficient.
     */
    STREAM_BUFFER_SIZE = 512 * 1024, /* in bytes */
};

27 28
#define SLICE_TIME 100000000ULL /* ns */

29 30
typedef struct StreamBlockJob {
    BlockJob common;
31
    RateLimit limit;
32
    BlockDriverState *base;
33
    char backing_file_id[1024];
34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51
} StreamBlockJob;

static int coroutine_fn stream_populate(BlockDriverState *bs,
                                        int64_t sector_num, int nb_sectors,
                                        void *buf)
{
    struct iovec iov = {
        .iov_base = buf,
        .iov_len  = nb_sectors * BDRV_SECTOR_SIZE,
    };
    QEMUIOVector qiov;

    qemu_iovec_init_external(&qiov, &iov, 1);

    /* Copy-on-read the unallocated clusters */
    return bdrv_co_copy_on_readv(bs, sector_num, nb_sectors, &qiov);
}

52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73
static void close_unused_images(BlockDriverState *top, BlockDriverState *base,
                                const char *base_id)
{
    BlockDriverState *intermediate;
    intermediate = top->backing_hd;

    while (intermediate) {
        BlockDriverState *unused;

        /* reached base */
        if (intermediate == base) {
            break;
        }

        unused = intermediate;
        intermediate = intermediate->backing_hd;
        unused->backing_hd = NULL;
        bdrv_delete(unused);
    }
    top->backing_hd = base;
}

74 75 76 77
static void coroutine_fn stream_run(void *opaque)
{
    StreamBlockJob *s = opaque;
    BlockDriverState *bs = s->common.bs;
78
    BlockDriverState *base = s->base;
79 80
    int64_t sector_num, end;
    int ret = 0;
81
    int n = 0;
82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102
    void *buf;

    s->common.len = bdrv_getlength(bs);
    if (s->common.len < 0) {
        block_job_complete(&s->common, s->common.len);
        return;
    }

    end = s->common.len >> BDRV_SECTOR_BITS;
    buf = qemu_blockalign(bs, STREAM_BUFFER_SIZE);

    /* Turn on copy-on-read for the whole block device so that guest read
     * requests help us make progress.  Only do this when copying the entire
     * backing chain since the copy-on-read operation does not take base into
     * account.
     */
    if (!base) {
        bdrv_enable_copy_on_read(bs);
    }

    for (sector_num = 0; sector_num < end; sector_num += n) {
Paolo Bonzini's avatar
Paolo Bonzini committed
103
        uint64_t delay_ns = 0;
104
        bool copy;
Paolo Bonzini's avatar
Paolo Bonzini committed
105 106 107 108 109 110

wait:
        /* Note that even when no rate limit is applied we need to yield
         * with no pending I/O here so that qemu_aio_flush() returns.
         */
        block_job_sleep_ns(&s->common, rt_clock, delay_ns);
111 112 113 114
        if (block_job_is_cancelled(&s->common)) {
            break;
        }

115 116 117 118 119 120 121 122
        ret = bdrv_co_is_allocated(bs, sector_num,
                                   STREAM_BUFFER_SIZE / BDRV_SECTOR_SIZE, &n);
        if (ret == 1) {
            /* Allocated in the top, no need to copy.  */
            copy = false;
        } else {
            /* Copy if allocated in the intermediate images.  Limit to the
             * known-unallocated area [sector_num, sector_num+n).  */
123 124
            ret = bdrv_co_is_allocated_above(bs->backing_hd, base,
                                             sector_num, n, &n);
125 126 127 128 129 130

            /* Finish early if end of backing file has been reached */
            if (ret == 0 && n == 0) {
                n = end - sector_num;
            }

131 132
            copy = (ret == 1);
        }
133
        trace_stream_one_iteration(s, sector_num, n, ret);
134
        if (ret >= 0 && copy) {
135
            if (s->common.speed) {
Paolo Bonzini's avatar
Paolo Bonzini committed
136
                delay_ns = ratelimit_calculate_delay(&s->limit, n);
137
                if (delay_ns > 0) {
Paolo Bonzini's avatar
Paolo Bonzini committed
138
                    goto wait;
139 140
                }
            }
141 142 143 144 145
            ret = stream_populate(bs, sector_num, n, buf);
        }
        if (ret < 0) {
            break;
        }
146
        ret = 0;
147 148 149 150 151 152 153 154 155

        /* Publish progress */
        s->common.offset += n * BDRV_SECTOR_SIZE;
    }

    if (!base) {
        bdrv_disable_copy_on_read(bs);
    }

156
    if (!block_job_is_cancelled(&s->common) && sector_num == end && ret == 0) {
157
        const char *base_id = NULL, *base_fmt = NULL;
158 159
        if (base) {
            base_id = s->backing_file_id;
160 161 162
            if (base->drv) {
                base_fmt = base->drv->format_name;
            }
163
        }
164
        ret = bdrv_change_backing_file(bs, base_id, base_fmt);
165
        close_unused_images(bs, base, base_id);
166 167 168 169 170 171
    }

    qemu_vfree(buf);
    block_job_complete(&s->common, ret);
}

172
static void stream_set_speed(BlockJob *job, int64_t speed, Error **errp)
173 174 175
{
    StreamBlockJob *s = container_of(job, StreamBlockJob, common);

176 177
    if (speed < 0) {
        error_set(errp, QERR_INVALID_PARAMETER, "speed");
178
        return;
179
    }
180
    ratelimit_set_speed(&s->limit, speed / BDRV_SECTOR_SIZE, SLICE_TIME);
181 182
}

183 184 185
static BlockJobType stream_job_type = {
    .instance_size = sizeof(StreamBlockJob),
    .job_type      = "stream",
186
    .set_speed     = stream_set_speed,
187 188
};

189
void stream_start(BlockDriverState *bs, BlockDriverState *base,
190 191
                  const char *base_id, int64_t speed,
                  BlockDriverCompletionFunc *cb,
192
                  void *opaque, Error **errp)
193 194 195
{
    StreamBlockJob *s;

196
    s = block_job_create(&stream_job_type, bs, speed, cb, opaque, errp);
197
    if (!s) {
198
        return;
199 200 201
    }

    s->base = base;
202 203 204
    if (base_id) {
        pstrcpy(s->backing_file_id, sizeof(s->backing_file_id), base_id);
    }
205

206 207 208
    s->common.co = qemu_coroutine_create(stream_run);
    trace_stream_start(bs, base, s, s->common.co, opaque);
    qemu_coroutine_enter(s->common.co, s);
209
}