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