4
* Copyright IBM, Corp. 2011
7
* Stefan Hajnoczi <stefanha@linux.vnet.ibm.com>
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.
15
#include "block/block_int.h"
16
#include "block/blockjob.h"
17
#include "qemu/ratelimit.h"
21
* Size of data buffer for populating the image file. This should be large
22
* enough to process multiple clusters in a single call, so that populating
23
* contiguous regions of the image is efficient.
25
STREAM_BUFFER_SIZE = 512 * 1024, /* in bytes */
28
#define SLICE_TIME 100000000ULL /* ns */
30
typedef struct StreamBlockJob {
33
BlockDriverState *base;
34
BlockdevOnError on_error;
35
char backing_file_id[1024];
38
static int coroutine_fn stream_populate(BlockDriverState *bs,
39
int64_t sector_num, int nb_sectors,
44
.iov_len = nb_sectors * BDRV_SECTOR_SIZE,
48
qemu_iovec_init_external(&qiov, &iov, 1);
50
/* Copy-on-read the unallocated clusters */
51
return bdrv_co_copy_on_readv(bs, sector_num, nb_sectors, &qiov);
54
static void close_unused_images(BlockDriverState *top, BlockDriverState *base,
57
BlockDriverState *intermediate;
58
intermediate = top->backing_hd;
60
while (intermediate) {
61
BlockDriverState *unused;
64
if (intermediate == base) {
68
unused = intermediate;
69
intermediate = intermediate->backing_hd;
70
unused->backing_hd = NULL;
73
top->backing_hd = base;
76
static void coroutine_fn stream_run(void *opaque)
78
StreamBlockJob *s = opaque;
79
BlockDriverState *bs = s->common.bs;
80
BlockDriverState *base = s->base;
81
int64_t sector_num, end;
87
s->common.len = bdrv_getlength(bs);
88
if (s->common.len < 0) {
89
block_job_completed(&s->common, s->common.len);
93
end = s->common.len >> BDRV_SECTOR_BITS;
94
buf = qemu_blockalign(bs, STREAM_BUFFER_SIZE);
96
/* Turn on copy-on-read for the whole block device so that guest read
97
* requests help us make progress. Only do this when copying the entire
98
* backing chain since the copy-on-read operation does not take base into
102
bdrv_enable_copy_on_read(bs);
105
for (sector_num = 0; sector_num < end; sector_num += n) {
106
uint64_t delay_ns = 0;
110
/* Note that even when no rate limit is applied we need to yield
111
* with no pending I/O here so that bdrv_drain_all() returns.
113
block_job_sleep_ns(&s->common, rt_clock, delay_ns);
114
if (block_job_is_cancelled(&s->common)) {
118
ret = bdrv_co_is_allocated(bs, sector_num,
119
STREAM_BUFFER_SIZE / BDRV_SECTOR_SIZE, &n);
121
/* Allocated in the top, no need to copy. */
124
/* Copy if allocated in the intermediate images. Limit to the
125
* known-unallocated area [sector_num, sector_num+n). */
126
ret = bdrv_co_is_allocated_above(bs->backing_hd, base,
129
/* Finish early if end of backing file has been reached */
130
if (ret == 0 && n == 0) {
131
n = end - sector_num;
136
trace_stream_one_iteration(s, sector_num, n, ret);
137
if (ret >= 0 && copy) {
138
if (s->common.speed) {
139
delay_ns = ratelimit_calculate_delay(&s->limit, n);
144
ret = stream_populate(bs, sector_num, n, buf);
147
BlockErrorAction action =
148
block_job_error_action(&s->common, s->common.bs, s->on_error,
150
if (action == BDRV_ACTION_STOP) {
157
if (action == BDRV_ACTION_REPORT) {
163
/* Publish progress */
164
s->common.offset += n * BDRV_SECTOR_SIZE;
168
bdrv_disable_copy_on_read(bs);
171
/* Do not remove the backing file if an error was there but ignored. */
174
if (!block_job_is_cancelled(&s->common) && sector_num == end && ret == 0) {
175
const char *base_id = NULL, *base_fmt = NULL;
177
base_id = s->backing_file_id;
179
base_fmt = base->drv->format_name;
182
ret = bdrv_change_backing_file(bs, base_id, base_fmt);
183
close_unused_images(bs, base, base_id);
187
block_job_completed(&s->common, ret);
190
static void stream_set_speed(BlockJob *job, int64_t speed, Error **errp)
192
StreamBlockJob *s = container_of(job, StreamBlockJob, common);
195
error_set(errp, QERR_INVALID_PARAMETER, "speed");
198
ratelimit_set_speed(&s->limit, speed / BDRV_SECTOR_SIZE, SLICE_TIME);
201
static const BlockJobType stream_job_type = {
202
.instance_size = sizeof(StreamBlockJob),
203
.job_type = "stream",
204
.set_speed = stream_set_speed,
207
void stream_start(BlockDriverState *bs, BlockDriverState *base,
208
const char *base_id, int64_t speed,
209
BlockdevOnError on_error,
210
BlockDriverCompletionFunc *cb,
211
void *opaque, Error **errp)
215
if ((on_error == BLOCKDEV_ON_ERROR_STOP ||
216
on_error == BLOCKDEV_ON_ERROR_ENOSPC) &&
217
!bdrv_iostatus_is_enabled(bs)) {
218
error_set(errp, QERR_INVALID_PARAMETER, "on-error");
222
s = block_job_create(&stream_job_type, bs, speed, cb, opaque, errp);
229
pstrcpy(s->backing_file_id, sizeof(s->backing_file_id), base_id);
232
s->on_error = on_error;
233
s->common.co = qemu_coroutine_create(stream_run);
234
trace_stream_start(bs, base, s, s->common.co, opaque);
235
qemu_coroutine_enter(s->common.co, s);