1
2
3
4
5
6
7
8
9
10
11
12
13
14
15#include "qemu/osdep.h"
16#include "qemu/cutils.h"
17#include "trace.h"
18#include "block/block_int.h"
19#include "block/blockjob_int.h"
20#include "qapi/error.h"
21#include "qapi/qmp/qerror.h"
22#include "qemu/ratelimit.h"
23#include "sysemu/block-backend.h"
24
25enum {
26
27
28
29
30
31 COMMIT_BUFFER_SIZE = 512 * 1024,
32};
33
34typedef struct CommitBlockJob {
35 BlockJob common;
36 BlockDriverState *commit_top_bs;
37 BlockBackend *top;
38 BlockBackend *base;
39 BlockDriverState *base_bs;
40 BlockDriverState *base_overlay;
41 BlockdevOnError on_error;
42 bool base_read_only;
43 bool chain_frozen;
44 char *backing_file_str;
45} CommitBlockJob;
46
47static int commit_prepare(Job *job)
48{
49 CommitBlockJob *s = container_of(job, CommitBlockJob, common.job);
50
51 bdrv_unfreeze_backing_chain(s->commit_top_bs, s->base_bs);
52 s->chain_frozen = false;
53
54
55
56 blk_unref(s->base);
57 s->base = NULL;
58
59
60
61 return bdrv_drop_intermediate(s->commit_top_bs, s->base_bs,
62 s->backing_file_str);
63}
64
65static void commit_abort(Job *job)
66{
67 CommitBlockJob *s = container_of(job, CommitBlockJob, common.job);
68 BlockDriverState *top_bs = blk_bs(s->top);
69
70 if (s->chain_frozen) {
71 bdrv_unfreeze_backing_chain(s->commit_top_bs, s->base_bs);
72 }
73
74
75 bdrv_ref(top_bs);
76 bdrv_ref(s->commit_top_bs);
77
78 if (s->base) {
79 blk_unref(s->base);
80 }
81
82
83
84 block_job_remove_all_bdrv(&s->common);
85
86
87
88
89
90
91
92
93 bdrv_replace_node(s->commit_top_bs, s->commit_top_bs->backing->bs,
94 &error_abort);
95
96 bdrv_unref(s->commit_top_bs);
97 bdrv_unref(top_bs);
98}
99
100static void commit_clean(Job *job)
101{
102 CommitBlockJob *s = container_of(job, CommitBlockJob, common.job);
103
104
105
106
107 if (s->base_read_only) {
108 bdrv_reopen_set_read_only(s->base_bs, true, NULL);
109 }
110
111 g_free(s->backing_file_str);
112 blk_unref(s->top);
113}
114
115static int coroutine_fn commit_run(Job *job, Error **errp)
116{
117 CommitBlockJob *s = container_of(job, CommitBlockJob, common.job);
118 int64_t offset;
119 uint64_t delay_ns = 0;
120 int ret = 0;
121 int64_t n = 0;
122 QEMU_AUTO_VFREE void *buf = NULL;
123 int64_t len, base_len;
124
125 len = blk_getlength(s->top);
126 if (len < 0) {
127 return len;
128 }
129 job_progress_set_remaining(&s->common.job, len);
130
131 base_len = blk_getlength(s->base);
132 if (base_len < 0) {
133 return base_len;
134 }
135
136 if (base_len < len) {
137 ret = blk_truncate(s->base, len, false, PREALLOC_MODE_OFF, 0, NULL);
138 if (ret) {
139 return ret;
140 }
141 }
142
143 buf = blk_blockalign(s->top, COMMIT_BUFFER_SIZE);
144
145 for (offset = 0; offset < len; offset += n) {
146 bool copy;
147 bool error_in_source = true;
148
149
150
151
152 job_sleep_ns(&s->common.job, delay_ns);
153 if (job_is_cancelled(&s->common.job)) {
154 break;
155 }
156
157 ret = bdrv_is_allocated_above(blk_bs(s->top), s->base_overlay, true,
158 offset, COMMIT_BUFFER_SIZE, &n);
159 copy = (ret > 0);
160 trace_commit_one_iteration(s, offset, n, ret);
161 if (copy) {
162 assert(n < SIZE_MAX);
163
164 ret = blk_co_pread(s->top, offset, n, buf, 0);
165 if (ret >= 0) {
166 ret = blk_co_pwrite(s->base, offset, n, buf, 0);
167 if (ret < 0) {
168 error_in_source = false;
169 }
170 }
171 }
172 if (ret < 0) {
173 BlockErrorAction action =
174 block_job_error_action(&s->common, s->on_error,
175 error_in_source, -ret);
176 if (action == BLOCK_ERROR_ACTION_REPORT) {
177 return ret;
178 } else {
179 n = 0;
180 continue;
181 }
182 }
183
184 job_progress_update(&s->common.job, n);
185
186 if (copy) {
187 delay_ns = block_job_ratelimit_get_delay(&s->common, n);
188 } else {
189 delay_ns = 0;
190 }
191 }
192
193 return 0;
194}
195
196static const BlockJobDriver commit_job_driver = {
197 .job_driver = {
198 .instance_size = sizeof(CommitBlockJob),
199 .job_type = JOB_TYPE_COMMIT,
200 .free = block_job_free,
201 .user_resume = block_job_user_resume,
202 .run = commit_run,
203 .prepare = commit_prepare,
204 .abort = commit_abort,
205 .clean = commit_clean
206 },
207};
208
209static int coroutine_fn bdrv_commit_top_preadv(BlockDriverState *bs,
210 int64_t offset, int64_t bytes, QEMUIOVector *qiov, BdrvRequestFlags flags)
211{
212 return bdrv_co_preadv(bs->backing, offset, bytes, qiov, flags);
213}
214
215static void bdrv_commit_top_refresh_filename(BlockDriverState *bs)
216{
217 pstrcpy(bs->exact_filename, sizeof(bs->exact_filename),
218 bs->backing->bs->filename);
219}
220
221static void bdrv_commit_top_child_perm(BlockDriverState *bs, BdrvChild *c,
222 BdrvChildRole role,
223 BlockReopenQueue *reopen_queue,
224 uint64_t perm, uint64_t shared,
225 uint64_t *nperm, uint64_t *nshared)
226{
227 *nperm = 0;
228 *nshared = BLK_PERM_ALL;
229}
230
231
232
233static BlockDriver bdrv_commit_top = {
234 .format_name = "commit_top",
235 .bdrv_co_preadv = bdrv_commit_top_preadv,
236 .bdrv_refresh_filename = bdrv_commit_top_refresh_filename,
237 .bdrv_child_perm = bdrv_commit_top_child_perm,
238
239 .is_filter = true,
240};
241
242void commit_start(const char *job_id, BlockDriverState *bs,
243 BlockDriverState *base, BlockDriverState *top,
244 int creation_flags, int64_t speed,
245 BlockdevOnError on_error, const char *backing_file_str,
246 const char *filter_node_name, Error **errp)
247{
248 CommitBlockJob *s;
249 BlockDriverState *iter;
250 BlockDriverState *commit_top_bs = NULL;
251 BlockDriverState *filtered_base;
252 int64_t base_size, top_size;
253 uint64_t base_perms, iter_shared_perms;
254 int ret;
255
256 assert(top != bs);
257 if (bdrv_skip_filters(top) == bdrv_skip_filters(base)) {
258 error_setg(errp, "Invalid files for merge: top and base are the same");
259 return;
260 }
261
262 base_size = bdrv_getlength(base);
263 if (base_size < 0) {
264 error_setg_errno(errp, -base_size, "Could not inquire base image size");
265 return;
266 }
267
268 top_size = bdrv_getlength(top);
269 if (top_size < 0) {
270 error_setg_errno(errp, -top_size, "Could not inquire top image size");
271 return;
272 }
273
274 base_perms = BLK_PERM_CONSISTENT_READ | BLK_PERM_WRITE;
275 if (base_size < top_size) {
276 base_perms |= BLK_PERM_RESIZE;
277 }
278
279 s = block_job_create(job_id, &commit_job_driver, NULL, bs, 0, BLK_PERM_ALL,
280 speed, creation_flags, NULL, NULL, errp);
281 if (!s) {
282 return;
283 }
284
285
286 s->base_read_only = bdrv_is_read_only(base);
287 if (s->base_read_only) {
288 if (bdrv_reopen_set_read_only(base, false, errp) != 0) {
289 goto fail;
290 }
291 }
292
293
294
295 commit_top_bs = bdrv_new_open_driver(&bdrv_commit_top, filter_node_name, 0,
296 errp);
297 if (commit_top_bs == NULL) {
298 goto fail;
299 }
300 if (!filter_node_name) {
301 commit_top_bs->implicit = true;
302 }
303
304
305 commit_top_bs->never_freeze = true;
306
307 commit_top_bs->total_sectors = top->total_sectors;
308
309 ret = bdrv_append(commit_top_bs, top, errp);
310 bdrv_unref(commit_top_bs);
311 if (ret < 0) {
312 commit_top_bs = NULL;
313 goto fail;
314 }
315
316 s->commit_top_bs = commit_top_bs;
317
318
319
320
321
322
323
324
325
326 s->base_overlay = bdrv_find_overlay(top, base);
327 assert(s->base_overlay);
328
329
330
331
332
333 filtered_base = bdrv_cow_bs(s->base_overlay);
334 assert(bdrv_skip_filters(filtered_base) == bdrv_skip_filters(base));
335
336
337
338
339
340
341
342 iter_shared_perms = BLK_PERM_WRITE_UNCHANGED | BLK_PERM_WRITE;
343
344 for (iter = top; iter != base; iter = bdrv_filter_or_cow_bs(iter)) {
345 if (iter == filtered_base) {
346
347
348
349
350 iter_shared_perms |= BLK_PERM_CONSISTENT_READ;
351 }
352
353 ret = block_job_add_bdrv(&s->common, "intermediate node", iter, 0,
354 iter_shared_perms, errp);
355 if (ret < 0) {
356 goto fail;
357 }
358 }
359
360 if (bdrv_freeze_backing_chain(commit_top_bs, base, errp) < 0) {
361 goto fail;
362 }
363 s->chain_frozen = true;
364
365 ret = block_job_add_bdrv(&s->common, "base", base, 0, BLK_PERM_ALL, errp);
366 if (ret < 0) {
367 goto fail;
368 }
369
370 s->base = blk_new(s->common.job.aio_context,
371 base_perms,
372 BLK_PERM_CONSISTENT_READ
373 | BLK_PERM_GRAPH_MOD
374 | BLK_PERM_WRITE_UNCHANGED);
375 ret = blk_insert_bs(s->base, base, errp);
376 if (ret < 0) {
377 goto fail;
378 }
379 blk_set_disable_request_queuing(s->base, true);
380 s->base_bs = base;
381
382
383 s->top = blk_new(s->common.job.aio_context, 0, BLK_PERM_ALL);
384 ret = blk_insert_bs(s->top, top, errp);
385 if (ret < 0) {
386 goto fail;
387 }
388 blk_set_disable_request_queuing(s->top, true);
389
390 s->backing_file_str = g_strdup(backing_file_str);
391 s->on_error = on_error;
392
393 trace_commit_start(bs, base, top, s);
394 job_start(&s->common.job);
395 return;
396
397fail:
398 if (s->chain_frozen) {
399 bdrv_unfreeze_backing_chain(commit_top_bs, base);
400 }
401 if (s->base) {
402 blk_unref(s->base);
403 }
404 if (s->top) {
405 blk_unref(s->top);
406 }
407 if (s->base_read_only) {
408 bdrv_reopen_set_read_only(base, true, NULL);
409 }
410 job_early_fail(&s->common.job);
411
412
413 if (commit_top_bs) {
414 bdrv_replace_node(commit_top_bs, top, &error_abort);
415 }
416}
417
418
419#define COMMIT_BUF_SIZE (2048 * BDRV_SECTOR_SIZE)
420
421
422int bdrv_commit(BlockDriverState *bs)
423{
424 BlockBackend *src, *backing;
425 BlockDriverState *backing_file_bs = NULL;
426 BlockDriverState *commit_top_bs = NULL;
427 BlockDriver *drv = bs->drv;
428 AioContext *ctx;
429 int64_t offset, length, backing_length;
430 int ro;
431 int64_t n;
432 int ret = 0;
433 QEMU_AUTO_VFREE uint8_t *buf = NULL;
434 Error *local_err = NULL;
435
436 if (!drv)
437 return -ENOMEDIUM;
438
439 backing_file_bs = bdrv_cow_bs(bs);
440
441 if (!backing_file_bs) {
442 return -ENOTSUP;
443 }
444
445 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_COMMIT_SOURCE, NULL) ||
446 bdrv_op_is_blocked(backing_file_bs, BLOCK_OP_TYPE_COMMIT_TARGET, NULL))
447 {
448 return -EBUSY;
449 }
450
451 ro = bdrv_is_read_only(backing_file_bs);
452
453 if (ro) {
454 if (bdrv_reopen_set_read_only(backing_file_bs, false, NULL)) {
455 return -EACCES;
456 }
457 }
458
459 ctx = bdrv_get_aio_context(bs);
460
461 src = blk_new(ctx, BLK_PERM_CONSISTENT_READ | BLK_PERM_WRITE_UNCHANGED,
462 BLK_PERM_ALL);
463 backing = blk_new(ctx, BLK_PERM_WRITE | BLK_PERM_RESIZE, BLK_PERM_ALL);
464
465 ret = blk_insert_bs(src, bs, &local_err);
466 if (ret < 0) {
467 error_report_err(local_err);
468 goto ro_cleanup;
469 }
470
471
472 commit_top_bs = bdrv_new_open_driver(&bdrv_commit_top, NULL, BDRV_O_RDWR,
473 &local_err);
474 if (commit_top_bs == NULL) {
475 error_report_err(local_err);
476 goto ro_cleanup;
477 }
478
479 bdrv_set_backing_hd(commit_top_bs, backing_file_bs, &error_abort);
480 bdrv_set_backing_hd(bs, commit_top_bs, &error_abort);
481
482 ret = blk_insert_bs(backing, backing_file_bs, &local_err);
483 if (ret < 0) {
484 error_report_err(local_err);
485 goto ro_cleanup;
486 }
487
488 length = blk_getlength(src);
489 if (length < 0) {
490 ret = length;
491 goto ro_cleanup;
492 }
493
494 backing_length = blk_getlength(backing);
495 if (backing_length < 0) {
496 ret = backing_length;
497 goto ro_cleanup;
498 }
499
500
501
502
503 if (length > backing_length) {
504 ret = blk_truncate(backing, length, false, PREALLOC_MODE_OFF, 0,
505 &local_err);
506 if (ret < 0) {
507 error_report_err(local_err);
508 goto ro_cleanup;
509 }
510 }
511
512
513
514 buf = blk_try_blockalign(src, COMMIT_BUF_SIZE);
515 if (buf == NULL) {
516 ret = -ENOMEM;
517 goto ro_cleanup;
518 }
519
520 for (offset = 0; offset < length; offset += n) {
521 ret = bdrv_is_allocated(bs, offset, COMMIT_BUF_SIZE, &n);
522 if (ret < 0) {
523 goto ro_cleanup;
524 }
525 if (ret) {
526 ret = blk_pread(src, offset, buf, n);
527 if (ret < 0) {
528 goto ro_cleanup;
529 }
530
531 ret = blk_pwrite(backing, offset, buf, n, 0);
532 if (ret < 0) {
533 goto ro_cleanup;
534 }
535 }
536 }
537
538 ret = blk_make_empty(src, NULL);
539
540 if (ret < 0 && ret != -ENOTSUP) {
541 goto ro_cleanup;
542 }
543
544 blk_flush(src);
545
546
547
548
549
550 blk_flush(backing);
551
552 ret = 0;
553ro_cleanup:
554 blk_unref(backing);
555 if (bdrv_cow_bs(bs) != backing_file_bs) {
556 bdrv_set_backing_hd(bs, backing_file_bs, &error_abort);
557 }
558 bdrv_unref(commit_top_bs);
559 blk_unref(src);
560
561 if (ro) {
562
563 bdrv_reopen_set_read_only(backing_file_bs, true, NULL);
564 }
565
566 return ret;
567}
568