4 * Copyright Red Hat, Inc. 2012
7 * Jeff Cody <jcody@redhat.com>
8 * Based on stream.c by Stefan Hajnoczi
10 * This work is licensed under the terms of the GNU LGPL, version 2 or later.
11 * See the COPYING.LIB file in the top-level directory.
15 #include "qemu/osdep.h"
16 #include "qemu/cutils.h"
18 #include "block/block_int.h"
19 #include "block/blockjob_int.h"
20 #include "qapi/error.h"
21 #include "qemu/ratelimit.h"
22 #include "qemu/memalign.h"
23 #include "sysemu/block-backend.h"
27 * Size of data buffer for populating the image file. This should be large
28 * enough to process multiple clusters in a single call, so that populating
29 * contiguous regions of the image is efficient.
31 COMMIT_BUFFER_SIZE
= 512 * 1024, /* in bytes */
34 typedef struct CommitBlockJob
{
36 BlockDriverState
*commit_top_bs
;
39 BlockDriverState
*base_bs
;
40 BlockDriverState
*base_overlay
;
41 BlockdevOnError on_error
;
44 char *backing_file_str
;
47 static int commit_prepare(Job
*job
)
49 CommitBlockJob
*s
= container_of(job
, CommitBlockJob
, common
.job
);
51 bdrv_graph_rdlock_main_loop();
52 bdrv_unfreeze_backing_chain(s
->commit_top_bs
, s
->base_bs
);
53 s
->chain_frozen
= false;
54 bdrv_graph_rdunlock_main_loop();
56 /* Remove base node parent that still uses BLK_PERM_WRITE/RESIZE before
57 * the normal backing chain can be restored. */
61 /* FIXME: bdrv_drop_intermediate treats total failures and partial failures
62 * identically. Further work is needed to disambiguate these cases. */
63 return bdrv_drop_intermediate(s
->commit_top_bs
, s
->base_bs
,
67 static void commit_abort(Job
*job
)
69 CommitBlockJob
*s
= container_of(job
, CommitBlockJob
, common
.job
);
70 BlockDriverState
*top_bs
= blk_bs(s
->top
);
72 if (s
->chain_frozen
) {
73 bdrv_graph_rdlock_main_loop();
74 bdrv_unfreeze_backing_chain(s
->commit_top_bs
, s
->base_bs
);
75 bdrv_graph_rdunlock_main_loop();
78 /* Make sure commit_top_bs and top stay around until bdrv_replace_node() */
80 bdrv_ref(s
->commit_top_bs
);
86 /* free the blockers on the intermediate nodes so that bdrv_replace_nodes
88 block_job_remove_all_bdrv(&s
->common
);
90 /* If bdrv_drop_intermediate() failed (or was not invoked), remove the
91 * commit filter driver from the backing chain now. Do this as the final
92 * step so that the 'consistent read' permission can be granted.
94 * XXX Can (or should) we somehow keep 'consistent read' blocked even
95 * after the failed/cancelled commit job is gone? If we already wrote
96 * something to base, the intermediate images aren't valid any more. */
97 bdrv_replace_node(s
->commit_top_bs
, s
->commit_top_bs
->backing
->bs
,
100 bdrv_unref(s
->commit_top_bs
);
104 static void commit_clean(Job
*job
)
106 CommitBlockJob
*s
= container_of(job
, CommitBlockJob
, common
.job
);
108 /* restore base open flags here if appropriate (e.g., change the base back
109 * to r/o). These reopens do not need to be atomic, since we won't abort
110 * even on failure here */
111 if (s
->base_read_only
) {
112 bdrv_reopen_set_read_only(s
->base_bs
, true, NULL
);
115 g_free(s
->backing_file_str
);
119 static int coroutine_fn
commit_run(Job
*job
, Error
**errp
)
121 CommitBlockJob
*s
= container_of(job
, CommitBlockJob
, common
.job
);
124 int64_t n
= 0; /* bytes */
125 QEMU_AUTO_VFREE
void *buf
= NULL
;
126 int64_t len
, base_len
;
128 len
= blk_co_getlength(s
->top
);
132 job_progress_set_remaining(&s
->common
.job
, len
);
134 base_len
= blk_co_getlength(s
->base
);
139 if (base_len
< len
) {
140 ret
= blk_co_truncate(s
->base
, len
, false, PREALLOC_MODE_OFF
, 0, NULL
);
146 buf
= blk_blockalign(s
->top
, COMMIT_BUFFER_SIZE
);
148 for (offset
= 0; offset
< len
; offset
+= n
) {
150 bool error_in_source
= true;
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_ratelimit_sleep(&s
->common
);
156 if (job_is_cancelled(&s
->common
.job
)) {
159 /* Copy if allocated above the base */
160 ret
= blk_co_is_allocated_above(s
->top
, s
->base_overlay
, true,
161 offset
, COMMIT_BUFFER_SIZE
, &n
);
163 trace_commit_one_iteration(s
, offset
, n
, ret
);
165 assert(n
< SIZE_MAX
);
167 ret
= blk_co_pread(s
->top
, offset
, n
, buf
, 0);
169 ret
= blk_co_pwrite(s
->base
, offset
, n
, buf
, 0);
171 error_in_source
= false;
176 BlockErrorAction action
=
177 block_job_error_action(&s
->common
, s
->on_error
,
178 error_in_source
, -ret
);
179 if (action
== BLOCK_ERROR_ACTION_REPORT
) {
186 /* Publish progress */
187 job_progress_update(&s
->common
.job
, n
);
190 block_job_ratelimit_processed_bytes(&s
->common
, n
);
197 static const BlockJobDriver commit_job_driver
= {
199 .instance_size
= sizeof(CommitBlockJob
),
200 .job_type
= JOB_TYPE_COMMIT
,
201 .free
= block_job_free
,
202 .user_resume
= block_job_user_resume
,
204 .prepare
= commit_prepare
,
205 .abort
= commit_abort
,
206 .clean
= commit_clean
210 static int coroutine_fn GRAPH_RDLOCK
211 bdrv_commit_top_preadv(BlockDriverState
*bs
, int64_t offset
, int64_t bytes
,
212 QEMUIOVector
*qiov
, BdrvRequestFlags flags
)
214 return bdrv_co_preadv(bs
->backing
, offset
, bytes
, qiov
, flags
);
217 static void bdrv_commit_top_refresh_filename(BlockDriverState
*bs
)
219 pstrcpy(bs
->exact_filename
, sizeof(bs
->exact_filename
),
220 bs
->backing
->bs
->filename
);
223 static void bdrv_commit_top_child_perm(BlockDriverState
*bs
, BdrvChild
*c
,
225 BlockReopenQueue
*reopen_queue
,
226 uint64_t perm
, uint64_t shared
,
227 uint64_t *nperm
, uint64_t *nshared
)
230 *nshared
= BLK_PERM_ALL
;
233 /* Dummy node that provides consistent read to its users without requiring it
234 * from its backing file and that allows writes on the backing file chain. */
235 static BlockDriver bdrv_commit_top
= {
236 .format_name
= "commit_top",
237 .bdrv_co_preadv
= bdrv_commit_top_preadv
,
238 .bdrv_refresh_filename
= bdrv_commit_top_refresh_filename
,
239 .bdrv_child_perm
= bdrv_commit_top_child_perm
,
242 .filtered_child_is_backing
= true,
245 void commit_start(const char *job_id
, BlockDriverState
*bs
,
246 BlockDriverState
*base
, BlockDriverState
*top
,
247 int creation_flags
, int64_t speed
,
248 BlockdevOnError on_error
, const char *backing_file_str
,
249 const char *filter_node_name
, Error
**errp
)
252 BlockDriverState
*iter
;
253 BlockDriverState
*commit_top_bs
= NULL
;
254 BlockDriverState
*filtered_base
;
255 int64_t base_size
, top_size
;
256 uint64_t base_perms
, iter_shared_perms
;
262 bdrv_graph_rdlock_main_loop();
263 if (bdrv_skip_filters(top
) == bdrv_skip_filters(base
)) {
264 error_setg(errp
, "Invalid files for merge: top and base are the same");
265 bdrv_graph_rdunlock_main_loop();
268 bdrv_graph_rdunlock_main_loop();
270 base_size
= bdrv_getlength(base
);
272 error_setg_errno(errp
, -base_size
, "Could not inquire base image size");
276 top_size
= bdrv_getlength(top
);
278 error_setg_errno(errp
, -top_size
, "Could not inquire top image size");
282 base_perms
= BLK_PERM_CONSISTENT_READ
| BLK_PERM_WRITE
;
283 if (base_size
< top_size
) {
284 base_perms
|= BLK_PERM_RESIZE
;
287 s
= block_job_create(job_id
, &commit_job_driver
, NULL
, bs
, 0, BLK_PERM_ALL
,
288 speed
, creation_flags
, NULL
, NULL
, errp
);
293 /* convert base to r/w, if necessary */
294 s
->base_read_only
= bdrv_is_read_only(base
);
295 if (s
->base_read_only
) {
296 if (bdrv_reopen_set_read_only(base
, false, errp
) != 0) {
301 /* Insert commit_top block node above top, so we can block consistent read
302 * on the backing chain below it */
303 commit_top_bs
= bdrv_new_open_driver(&bdrv_commit_top
, filter_node_name
, 0,
305 if (commit_top_bs
== NULL
) {
308 if (!filter_node_name
) {
309 commit_top_bs
->implicit
= true;
312 /* So that we can always drop this node */
313 commit_top_bs
->never_freeze
= true;
315 commit_top_bs
->total_sectors
= top
->total_sectors
;
317 ret
= bdrv_append(commit_top_bs
, top
, errp
);
318 bdrv_unref(commit_top_bs
); /* referenced by new parents or failed */
320 commit_top_bs
= NULL
;
324 s
->commit_top_bs
= commit_top_bs
;
327 * Block all nodes between top and base, because they will
328 * disappear from the chain after this operation.
329 * Note that this assumes that the user is fine with removing all
330 * nodes (including R/W filters) between top and base. Assuring
331 * this is the responsibility of the interface (i.e. whoever calls
334 bdrv_graph_wrlock(top
);
335 s
->base_overlay
= bdrv_find_overlay(top
, base
);
336 assert(s
->base_overlay
);
339 * The topmost node with
340 * bdrv_skip_filters(filtered_base) == bdrv_skip_filters(base)
342 filtered_base
= bdrv_cow_bs(s
->base_overlay
);
343 assert(bdrv_skip_filters(filtered_base
) == bdrv_skip_filters(base
));
346 * XXX BLK_PERM_WRITE needs to be allowed so we don't block ourselves
347 * at s->base (if writes are blocked for a node, they are also blocked
348 * for its backing file). The other options would be a second filter
349 * driver above s->base.
351 iter_shared_perms
= BLK_PERM_WRITE_UNCHANGED
| BLK_PERM_WRITE
;
353 for (iter
= top
; iter
!= base
; iter
= bdrv_filter_or_cow_bs(iter
)) {
354 if (iter
== filtered_base
) {
356 * From here on, all nodes are filters on the base. This
357 * allows us to share BLK_PERM_CONSISTENT_READ.
359 iter_shared_perms
|= BLK_PERM_CONSISTENT_READ
;
362 ret
= block_job_add_bdrv(&s
->common
, "intermediate node", iter
, 0,
363 iter_shared_perms
, errp
);
365 bdrv_graph_wrunlock();
370 if (bdrv_freeze_backing_chain(commit_top_bs
, base
, errp
) < 0) {
371 bdrv_graph_wrunlock();
374 s
->chain_frozen
= true;
376 ret
= block_job_add_bdrv(&s
->common
, "base", base
, 0, BLK_PERM_ALL
, errp
);
377 bdrv_graph_wrunlock();
383 s
->base
= blk_new(s
->common
.job
.aio_context
,
385 BLK_PERM_CONSISTENT_READ
386 | BLK_PERM_WRITE_UNCHANGED
);
387 ret
= blk_insert_bs(s
->base
, base
, errp
);
391 blk_set_disable_request_queuing(s
->base
, true);
394 /* Required permissions are already taken with block_job_add_bdrv() */
395 s
->top
= blk_new(s
->common
.job
.aio_context
, 0, BLK_PERM_ALL
);
396 ret
= blk_insert_bs(s
->top
, top
, errp
);
400 blk_set_disable_request_queuing(s
->top
, true);
402 s
->backing_file_str
= g_strdup(backing_file_str
);
403 s
->on_error
= on_error
;
405 trace_commit_start(bs
, base
, top
, s
);
406 job_start(&s
->common
.job
);
410 if (s
->chain_frozen
) {
411 bdrv_graph_rdlock_main_loop();
412 bdrv_unfreeze_backing_chain(commit_top_bs
, base
);
413 bdrv_graph_rdunlock_main_loop();
421 if (s
->base_read_only
) {
422 bdrv_reopen_set_read_only(base
, true, NULL
);
424 job_early_fail(&s
->common
.job
);
425 /* commit_top_bs has to be replaced after deleting the block job,
426 * otherwise this would fail because of lack of permissions. */
428 bdrv_replace_node(commit_top_bs
, top
, &error_abort
);
433 #define COMMIT_BUF_SIZE (2048 * BDRV_SECTOR_SIZE)
435 /* commit COW file into the raw image */
436 int bdrv_commit(BlockDriverState
*bs
)
438 BlockBackend
*src
, *backing
;
439 BlockDriverState
*backing_file_bs
= NULL
;
440 BlockDriverState
*commit_top_bs
= NULL
;
441 BlockDriver
*drv
= bs
->drv
;
443 int64_t offset
, length
, backing_length
;
447 QEMU_AUTO_VFREE
uint8_t *buf
= NULL
;
448 Error
*local_err
= NULL
;
451 GRAPH_RDLOCK_GUARD_MAINLOOP();
456 backing_file_bs
= bdrv_cow_bs(bs
);
458 if (!backing_file_bs
) {
462 if (bdrv_op_is_blocked(bs
, BLOCK_OP_TYPE_COMMIT_SOURCE
, NULL
) ||
463 bdrv_op_is_blocked(backing_file_bs
, BLOCK_OP_TYPE_COMMIT_TARGET
, NULL
))
468 ro
= bdrv_is_read_only(backing_file_bs
);
471 if (bdrv_reopen_set_read_only(backing_file_bs
, false, NULL
)) {
476 ctx
= bdrv_get_aio_context(bs
);
477 /* WRITE_UNCHANGED is required for bdrv_make_empty() */
478 src
= blk_new(ctx
, BLK_PERM_CONSISTENT_READ
| BLK_PERM_WRITE_UNCHANGED
,
480 backing
= blk_new(ctx
, BLK_PERM_WRITE
| BLK_PERM_RESIZE
, BLK_PERM_ALL
);
482 ret
= blk_insert_bs(src
, bs
, &local_err
);
484 error_report_err(local_err
);
488 /* Insert commit_top block node above backing, so we can write to it */
489 commit_top_bs
= bdrv_new_open_driver(&bdrv_commit_top
, NULL
, BDRV_O_RDWR
,
491 if (commit_top_bs
== NULL
) {
492 error_report_err(local_err
);
496 bdrv_set_backing_hd(commit_top_bs
, backing_file_bs
, &error_abort
);
497 bdrv_set_backing_hd(bs
, commit_top_bs
, &error_abort
);
499 ret
= blk_insert_bs(backing
, backing_file_bs
, &local_err
);
501 error_report_err(local_err
);
505 length
= blk_getlength(src
);
511 backing_length
= blk_getlength(backing
);
512 if (backing_length
< 0) {
513 ret
= backing_length
;
517 /* If our top snapshot is larger than the backing file image,
518 * grow the backing file image if possible. If not possible,
519 * we must return an error */
520 if (length
> backing_length
) {
521 ret
= blk_truncate(backing
, length
, false, PREALLOC_MODE_OFF
, 0,
524 error_report_err(local_err
);
529 /* blk_try_blockalign() for src will choose an alignment that works for
530 * backing as well, so no need to compare the alignment manually. */
531 buf
= blk_try_blockalign(src
, COMMIT_BUF_SIZE
);
537 for (offset
= 0; offset
< length
; offset
+= n
) {
538 ret
= bdrv_is_allocated(bs
, offset
, COMMIT_BUF_SIZE
, &n
);
543 ret
= blk_pread(src
, offset
, n
, buf
, 0);
548 ret
= blk_pwrite(backing
, offset
, n
, buf
, 0);
555 ret
= blk_make_empty(src
, NULL
);
556 /* Ignore -ENOTSUP */
557 if (ret
< 0 && ret
!= -ENOTSUP
) {
564 * Make sure all data we wrote to the backing device is actually
572 if (bdrv_cow_bs(bs
) != backing_file_bs
) {
573 bdrv_set_backing_hd(bs
, backing_file_bs
, &error_abort
);
575 bdrv_unref(commit_top_bs
);
579 /* ignoring error return here */
580 bdrv_reopen_set_read_only(backing_file_bs
, true, NULL
);