1
2
3
4
5
6
7
8
9
10
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 "qapi/qmp/qdict.h"
21#include "qemu/ratelimit.h"
22#include "sysemu/block-backend.h"
23#include "block/copy-on-read.h"
24
25enum {
26
27
28
29
30
31 STREAM_CHUNK = 512 * 1024,
32};
33
34typedef struct StreamBlockJob {
35 BlockJob common;
36 BlockBackend *blk;
37 BlockDriverState *base_overlay;
38 BlockDriverState *above_base;
39 BlockDriverState *cor_filter_bs;
40 BlockDriverState *target_bs;
41 BlockdevOnError on_error;
42 char *backing_file_str;
43 bool bs_read_only;
44} StreamBlockJob;
45
46static int coroutine_fn stream_populate(BlockBackend *blk,
47 int64_t offset, uint64_t bytes)
48{
49 assert(bytes < SIZE_MAX);
50
51 return blk_co_preadv(blk, offset, bytes, NULL, BDRV_REQ_PREFETCH);
52}
53
54static int stream_prepare(Job *job)
55{
56 StreamBlockJob *s = container_of(job, StreamBlockJob, common.job);
57 BlockDriverState *unfiltered_bs = bdrv_skip_filters(s->target_bs);
58 BlockDriverState *base;
59 BlockDriverState *unfiltered_base;
60 Error *local_err = NULL;
61 int ret = 0;
62
63
64 bdrv_cor_filter_drop(s->cor_filter_bs);
65 s->cor_filter_bs = NULL;
66
67 bdrv_subtree_drained_begin(s->above_base);
68
69 base = bdrv_filter_or_cow_bs(s->above_base);
70 if (base) {
71 bdrv_ref(base);
72 }
73
74 unfiltered_base = bdrv_skip_filters(base);
75
76 if (bdrv_cow_child(unfiltered_bs)) {
77 const char *base_id = NULL, *base_fmt = NULL;
78 if (unfiltered_base) {
79 base_id = s->backing_file_str ?: unfiltered_base->filename;
80 if (unfiltered_base->drv) {
81 base_fmt = unfiltered_base->drv->format_name;
82 }
83 }
84
85 bdrv_set_backing_hd(unfiltered_bs, base, &local_err);
86 ret = bdrv_change_backing_file(unfiltered_bs, base_id, base_fmt, false);
87 if (local_err) {
88 error_report_err(local_err);
89 ret = -EPERM;
90 goto out;
91 }
92 }
93
94out:
95 if (base) {
96 bdrv_unref(base);
97 }
98 bdrv_subtree_drained_end(s->above_base);
99 return ret;
100}
101
102static void stream_clean(Job *job)
103{
104 StreamBlockJob *s = container_of(job, StreamBlockJob, common.job);
105
106 if (s->cor_filter_bs) {
107 bdrv_cor_filter_drop(s->cor_filter_bs);
108 s->cor_filter_bs = NULL;
109 }
110
111 blk_unref(s->blk);
112 s->blk = NULL;
113
114
115 if (s->bs_read_only) {
116
117 bdrv_reopen_set_read_only(s->target_bs, true, NULL);
118 }
119
120 g_free(s->backing_file_str);
121}
122
123static int coroutine_fn stream_run(Job *job, Error **errp)
124{
125 StreamBlockJob *s = container_of(job, StreamBlockJob, common.job);
126 BlockDriverState *unfiltered_bs = bdrv_skip_filters(s->target_bs);
127 int64_t len;
128 int64_t offset = 0;
129 uint64_t delay_ns = 0;
130 int error = 0;
131 int64_t n = 0;
132
133 if (unfiltered_bs == s->base_overlay) {
134
135 return 0;
136 }
137
138 len = bdrv_getlength(s->target_bs);
139 if (len < 0) {
140 return len;
141 }
142 job_progress_set_remaining(&s->common.job, len);
143
144 for ( ; offset < len; offset += n) {
145 bool copy;
146 int ret;
147
148
149
150
151 job_sleep_ns(&s->common.job, delay_ns);
152 if (job_is_cancelled(&s->common.job)) {
153 break;
154 }
155
156 copy = false;
157
158 ret = bdrv_is_allocated(unfiltered_bs, offset, STREAM_CHUNK, &n);
159 if (ret == 1) {
160
161 } else if (ret >= 0) {
162
163
164 ret = bdrv_is_allocated_above(bdrv_cow_bs(unfiltered_bs),
165 s->base_overlay, true,
166 offset, n, &n);
167
168 if (ret == 0 && n == 0) {
169 n = len - offset;
170 }
171
172 copy = (ret > 0);
173 }
174 trace_stream_one_iteration(s, offset, n, ret);
175 if (copy) {
176 ret = stream_populate(s->blk, offset, n);
177 }
178 if (ret < 0) {
179 BlockErrorAction action =
180 block_job_error_action(&s->common, s->on_error, true, -ret);
181 if (action == BLOCK_ERROR_ACTION_STOP) {
182 n = 0;
183 continue;
184 }
185 if (error == 0) {
186 error = ret;
187 }
188 if (action == BLOCK_ERROR_ACTION_REPORT) {
189 break;
190 }
191 }
192
193
194 job_progress_update(&s->common.job, n);
195 if (copy) {
196 delay_ns = block_job_ratelimit_get_delay(&s->common, n);
197 } else {
198 delay_ns = 0;
199 }
200 }
201
202
203 return error;
204}
205
206static const BlockJobDriver stream_job_driver = {
207 .job_driver = {
208 .instance_size = sizeof(StreamBlockJob),
209 .job_type = JOB_TYPE_STREAM,
210 .free = block_job_free,
211 .run = stream_run,
212 .prepare = stream_prepare,
213 .clean = stream_clean,
214 .user_resume = block_job_user_resume,
215 },
216};
217
218void stream_start(const char *job_id, BlockDriverState *bs,
219 BlockDriverState *base, const char *backing_file_str,
220 BlockDriverState *bottom,
221 int creation_flags, int64_t speed,
222 BlockdevOnError on_error,
223 const char *filter_node_name,
224 Error **errp)
225{
226 StreamBlockJob *s = NULL;
227 BlockDriverState *iter;
228 bool bs_read_only;
229 int basic_flags = BLK_PERM_CONSISTENT_READ | BLK_PERM_WRITE_UNCHANGED;
230 BlockDriverState *base_overlay;
231 BlockDriverState *cor_filter_bs = NULL;
232 BlockDriverState *above_base;
233 QDict *opts;
234 int ret;
235
236 GLOBAL_STATE_CODE();
237
238 assert(!(base && bottom));
239 assert(!(backing_file_str && bottom));
240
241 if (bottom) {
242
243
244
245
246
247
248
249
250 assert(!bottom->drv->is_filter);
251 base_overlay = above_base = bottom;
252 } else {
253 base_overlay = bdrv_find_overlay(bs, base);
254 if (!base_overlay) {
255 error_setg(errp, "'%s' is not in the backing chain of '%s'",
256 base->node_name, bs->node_name);
257 return;
258 }
259
260
261
262
263
264
265 above_base = base_overlay;
266 if (bdrv_cow_bs(above_base) != base) {
267 above_base = bdrv_cow_bs(above_base);
268 while (bdrv_filter_bs(above_base) != base) {
269 above_base = bdrv_filter_bs(above_base);
270 }
271 }
272 }
273
274
275 bs_read_only = bdrv_is_read_only(bs);
276 if (bs_read_only) {
277 int ret;
278
279 if (bdrv_freeze_backing_chain(bs, above_base, errp) < 0) {
280 return;
281 }
282
283 ret = bdrv_reopen_set_read_only(bs, false, errp);
284
285
286 bdrv_unfreeze_backing_chain(bs, above_base);
287
288 if (ret < 0) {
289 return;
290 }
291 }
292
293 opts = qdict_new();
294
295 qdict_put_str(opts, "driver", "copy-on-read");
296 qdict_put_str(opts, "file", bdrv_get_node_name(bs));
297
298 qdict_put_str(opts, "bottom", base_overlay->node_name);
299 if (filter_node_name) {
300 qdict_put_str(opts, "node-name", filter_node_name);
301 }
302
303 cor_filter_bs = bdrv_insert_node(bs, opts, BDRV_O_RDWR, errp);
304 if (!cor_filter_bs) {
305 goto fail;
306 }
307
308 if (!filter_node_name) {
309 cor_filter_bs->implicit = true;
310 }
311
312 s = block_job_create(job_id, &stream_job_driver, NULL, cor_filter_bs,
313 0, BLK_PERM_ALL,
314 speed, creation_flags, NULL, NULL, errp);
315 if (!s) {
316 goto fail;
317 }
318
319 s->blk = blk_new_with_bs(cor_filter_bs, BLK_PERM_CONSISTENT_READ,
320 basic_flags | BLK_PERM_WRITE, errp);
321 if (!s->blk) {
322 goto fail;
323 }
324
325
326
327
328 blk_set_disable_request_queuing(s->blk, true);
329 blk_set_allow_aio_context_change(s->blk, true);
330
331
332
333
334
335
336 if (block_job_add_bdrv(&s->common, "active node", bs, 0,
337 basic_flags | BLK_PERM_WRITE, errp)) {
338 goto fail;
339 }
340
341
342
343
344
345
346
347
348
349
350 base = bdrv_filter_or_cow_bs(above_base);
351 for (iter = bdrv_filter_or_cow_bs(bs); iter != base;
352 iter = bdrv_filter_or_cow_bs(iter))
353 {
354 ret = block_job_add_bdrv(&s->common, "intermediate node", iter, 0,
355 basic_flags, errp);
356 if (ret < 0) {
357 goto fail;
358 }
359 }
360
361 s->base_overlay = base_overlay;
362 s->above_base = above_base;
363 s->backing_file_str = g_strdup(backing_file_str);
364 s->cor_filter_bs = cor_filter_bs;
365 s->target_bs = bs;
366 s->bs_read_only = bs_read_only;
367
368 s->on_error = on_error;
369 trace_stream_start(bs, base, s);
370 job_start(&s->common.job);
371 return;
372
373fail:
374 if (s) {
375 job_early_fail(&s->common.job);
376 }
377 if (cor_filter_bs) {
378 bdrv_cor_filter_drop(cor_filter_bs);
379 }
380 if (bs_read_only) {
381 bdrv_reopen_set_read_only(bs, true, NULL);
382 }
383}
384