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 "qapi/qmp/qerror.h"
18 #include "qemu/ratelimit.h"
22 * Size of data buffer for populating the image file. This should be large
23 * enough to process multiple clusters in a single call, so that populating
24 * contiguous regions of the image is efficient.
26 STREAM_BUFFER_SIZE
= 512 * 1024, /* in bytes */
29 #define SLICE_TIME 100000000ULL /* ns */
31 typedef struct StreamBlockJob
{
34 BlockDriverState
*base
;
35 BlockdevOnError on_error
;
36 char *backing_file_str
;
39 static int coroutine_fn
stream_populate(BlockDriverState
*bs
,
40 int64_t sector_num
, int nb_sectors
,
45 .iov_len
= nb_sectors
* BDRV_SECTOR_SIZE
,
49 qemu_iovec_init_external(&qiov
, &iov
, 1);
51 /* Copy-on-read the unallocated clusters */
52 return bdrv_co_copy_on_readv(bs
, sector_num
, nb_sectors
, &qiov
);
55 static void close_unused_images(BlockDriverState
*top
, BlockDriverState
*base
,
58 BlockDriverState
*intermediate
;
59 intermediate
= backing_bs(top
);
61 /* Must assign before bdrv_delete() to prevent traversing dangling pointer
62 * while we delete backing image instances.
64 bdrv_set_backing_hd(top
, base
);
66 while (intermediate
) {
67 BlockDriverState
*unused
;
70 if (intermediate
== base
) {
74 unused
= intermediate
;
75 intermediate
= backing_bs(intermediate
);
76 bdrv_set_backing_hd(unused
, NULL
);
80 bdrv_refresh_limits(top
, NULL
);
88 static void stream_complete(BlockJob
*job
, void *opaque
)
90 StreamBlockJob
*s
= container_of(job
, StreamBlockJob
, common
);
91 StreamCompleteData
*data
= opaque
;
92 BlockDriverState
*base
= s
->base
;
94 if (!block_job_is_cancelled(&s
->common
) && data
->reached_end
&&
96 const char *base_id
= NULL
, *base_fmt
= NULL
;
98 base_id
= s
->backing_file_str
;
100 base_fmt
= base
->drv
->format_name
;
103 data
->ret
= bdrv_change_backing_file(job
->bs
, base_id
, base_fmt
);
104 close_unused_images(job
->bs
, base
, base_id
);
107 g_free(s
->backing_file_str
);
108 block_job_completed(&s
->common
, data
->ret
);
112 static void coroutine_fn
stream_run(void *opaque
)
114 StreamBlockJob
*s
= opaque
;
115 StreamCompleteData
*data
;
116 BlockDriverState
*bs
= s
->common
.bs
;
117 BlockDriverState
*base
= s
->base
;
118 int64_t sector_num
, end
;
125 block_job_completed(&s
->common
, 0);
129 s
->common
.len
= bdrv_getlength(bs
);
130 if (s
->common
.len
< 0) {
131 block_job_completed(&s
->common
, s
->common
.len
);
135 end
= s
->common
.len
>> BDRV_SECTOR_BITS
;
136 buf
= qemu_blockalign(bs
, STREAM_BUFFER_SIZE
);
138 /* Turn on copy-on-read for the whole block device so that guest read
139 * requests help us make progress. Only do this when copying the entire
140 * backing chain since the copy-on-read operation does not take base into
144 bdrv_enable_copy_on_read(bs
);
147 for (sector_num
= 0; sector_num
< end
; sector_num
+= n
) {
148 uint64_t delay_ns
= 0;
152 /* Note that even when no rate limit is applied we need to yield
153 * with no pending I/O here so that bdrv_drain_all() returns.
155 block_job_sleep_ns(&s
->common
, QEMU_CLOCK_REALTIME
, delay_ns
);
156 if (block_job_is_cancelled(&s
->common
)) {
162 ret
= bdrv_is_allocated(bs
, sector_num
,
163 STREAM_BUFFER_SIZE
/ BDRV_SECTOR_SIZE
, &n
);
165 /* Allocated in the top, no need to copy. */
166 } else if (ret
>= 0) {
167 /* Copy if allocated in the intermediate images. Limit to the
168 * known-unallocated area [sector_num, sector_num+n). */
169 ret
= bdrv_is_allocated_above(backing_bs(bs
), base
,
172 /* Finish early if end of backing file has been reached */
173 if (ret
== 0 && n
== 0) {
174 n
= end
- sector_num
;
179 trace_stream_one_iteration(s
, sector_num
, n
, ret
);
181 if (s
->common
.speed
) {
182 delay_ns
= ratelimit_calculate_delay(&s
->limit
, n
);
187 ret
= stream_populate(bs
, sector_num
, n
, buf
);
190 BlockErrorAction action
=
191 block_job_error_action(&s
->common
, s
->common
.bs
, s
->on_error
,
193 if (action
== BLOCK_ERROR_ACTION_STOP
) {
200 if (action
== BLOCK_ERROR_ACTION_REPORT
) {
206 /* Publish progress */
207 s
->common
.offset
+= n
* BDRV_SECTOR_SIZE
;
211 bdrv_disable_copy_on_read(bs
);
214 /* Do not remove the backing file if an error was there but ignored. */
219 /* Modify backing chain and close BDSes in main loop */
220 data
= g_malloc(sizeof(*data
));
222 data
->reached_end
= sector_num
== end
;
223 block_job_defer_to_main_loop(&s
->common
, stream_complete
, data
);
226 static void stream_set_speed(BlockJob
*job
, int64_t speed
, Error
**errp
)
228 StreamBlockJob
*s
= container_of(job
, StreamBlockJob
, common
);
231 error_setg(errp
, QERR_INVALID_PARAMETER
, "speed");
234 ratelimit_set_speed(&s
->limit
, speed
/ BDRV_SECTOR_SIZE
, SLICE_TIME
);
237 static const BlockJobDriver stream_job_driver
= {
238 .instance_size
= sizeof(StreamBlockJob
),
239 .job_type
= BLOCK_JOB_TYPE_STREAM
,
240 .set_speed
= stream_set_speed
,
243 void stream_start(BlockDriverState
*bs
, BlockDriverState
*base
,
244 const char *backing_file_str
, int64_t speed
,
245 BlockdevOnError on_error
,
246 BlockCompletionFunc
*cb
,
247 void *opaque
, Error
**errp
)
251 if ((on_error
== BLOCKDEV_ON_ERROR_STOP
||
252 on_error
== BLOCKDEV_ON_ERROR_ENOSPC
) &&
253 !bdrv_iostatus_is_enabled(bs
)) {
254 error_setg(errp
, QERR_INVALID_PARAMETER
, "on-error");
258 s
= block_job_create(&stream_job_driver
, bs
, speed
, cb
, opaque
, errp
);
264 s
->backing_file_str
= g_strdup(backing_file_str
);
266 s
->on_error
= on_error
;
267 s
->common
.co
= qemu_coroutine_create(stream_run
);
268 trace_stream_start(bs
, base
, s
, s
->common
.co
, opaque
);
269 qemu_coroutine_enter(s
->common
.co
, s
);