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 "qapi/qmp/qerror.h"
22 #include "qemu/ratelimit.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 #define SLICE_TIME 100000000ULL /* ns */
36 typedef struct CommitBlockJob
{
39 BlockDriverState
*active
;
40 BlockDriverState
*commit_top_bs
;
43 BlockdevOnError on_error
;
45 int orig_overlay_flags
;
46 char *backing_file_str
;
49 static int coroutine_fn
commit_populate(BlockBackend
*bs
, BlockBackend
*base
,
50 int64_t sector_num
, int nb_sectors
,
57 .iov_len
= nb_sectors
* BDRV_SECTOR_SIZE
,
60 qemu_iovec_init_external(&qiov
, &iov
, 1);
62 ret
= blk_co_preadv(bs
, sector_num
* BDRV_SECTOR_SIZE
,
68 ret
= blk_co_pwritev(base
, sector_num
* BDRV_SECTOR_SIZE
,
81 static void commit_complete(BlockJob
*job
, void *opaque
)
83 CommitBlockJob
*s
= container_of(job
, CommitBlockJob
, common
);
84 CommitCompleteData
*data
= opaque
;
85 BlockDriverState
*active
= s
->active
;
86 BlockDriverState
*top
= blk_bs(s
->top
);
87 BlockDriverState
*base
= blk_bs(s
->base
);
88 BlockDriverState
*overlay_bs
= bdrv_find_overlay(active
, s
->commit_top_bs
);
90 bool remove_commit_top_bs
= false;
92 /* Make sure overlay_bs and top stay around until bdrv_set_backing_hd() */
98 /* Remove base node parent that still uses BLK_PERM_WRITE/RESIZE before
99 * the normal backing chain can be restored. */
102 if (!block_job_is_cancelled(&s
->common
) && ret
== 0) {
104 ret
= bdrv_drop_intermediate(active
, s
->commit_top_bs
, base
,
105 s
->backing_file_str
);
106 } else if (overlay_bs
) {
107 /* XXX Can (or should) we somehow keep 'consistent read' blocked even
108 * after the failed/cancelled commit job is gone? If we already wrote
109 * something to base, the intermediate images aren't valid any more. */
110 remove_commit_top_bs
= true;
113 /* restore base open flags here if appropriate (e.g., change the base back
114 * to r/o). These reopens do not need to be atomic, since we won't abort
115 * even on failure here */
116 if (s
->base_flags
!= bdrv_get_flags(base
)) {
117 bdrv_reopen(base
, s
->base_flags
, NULL
);
119 if (overlay_bs
&& s
->orig_overlay_flags
!= bdrv_get_flags(overlay_bs
)) {
120 bdrv_reopen(overlay_bs
, s
->orig_overlay_flags
, NULL
);
122 g_free(s
->backing_file_str
);
125 /* If there is more than one reference to the job (e.g. if called from
126 * block_job_finish_sync()), block_job_completed() won't free it and
127 * therefore the blockers on the intermediate nodes remain. This would
128 * cause bdrv_set_backing_hd() to fail. */
129 block_job_remove_all_bdrv(job
);
131 block_job_completed(&s
->common
, ret
);
134 /* If bdrv_drop_intermediate() didn't already do that, remove the commit
135 * filter driver from the backing chain. Do this as the final step so that
136 * the 'consistent read' permission can be granted. */
137 if (remove_commit_top_bs
) {
138 bdrv_set_backing_hd(overlay_bs
, top
, &error_abort
);
141 bdrv_unref(overlay_bs
);
145 static void coroutine_fn
commit_run(void *opaque
)
147 CommitBlockJob
*s
= opaque
;
148 CommitCompleteData
*data
;
149 int64_t sector_num
, end
;
150 uint64_t delay_ns
= 0;
154 int bytes_written
= 0;
157 ret
= s
->common
.len
= blk_getlength(s
->top
);
160 if (s
->common
.len
< 0) {
164 ret
= base_len
= blk_getlength(s
->base
);
169 if (base_len
< s
->common
.len
) {
170 ret
= blk_truncate(s
->base
, s
->common
.len
, NULL
);
176 end
= s
->common
.len
>> BDRV_SECTOR_BITS
;
177 buf
= blk_blockalign(s
->top
, COMMIT_BUFFER_SIZE
);
179 for (sector_num
= 0; sector_num
< end
; sector_num
+= n
) {
182 /* Note that even when no rate limit is applied we need to yield
183 * with no pending I/O here so that bdrv_drain_all() returns.
185 block_job_sleep_ns(&s
->common
, QEMU_CLOCK_REALTIME
, delay_ns
);
186 if (block_job_is_cancelled(&s
->common
)) {
189 /* Copy if allocated above the base */
190 ret
= bdrv_is_allocated_above(blk_bs(s
->top
), blk_bs(s
->base
),
192 COMMIT_BUFFER_SIZE
/ BDRV_SECTOR_SIZE
,
195 trace_commit_one_iteration(s
, sector_num
, n
, ret
);
197 ret
= commit_populate(s
->top
, s
->base
, sector_num
, n
, buf
);
198 bytes_written
+= n
* BDRV_SECTOR_SIZE
;
201 BlockErrorAction action
=
202 block_job_error_action(&s
->common
, false, s
->on_error
, -ret
);
203 if (action
== BLOCK_ERROR_ACTION_REPORT
) {
210 /* Publish progress */
211 s
->common
.offset
+= n
* BDRV_SECTOR_SIZE
;
213 if (copy
&& s
->common
.speed
) {
214 delay_ns
= ratelimit_calculate_delay(&s
->limit
, n
);
223 data
= g_malloc(sizeof(*data
));
225 block_job_defer_to_main_loop(&s
->common
, commit_complete
, data
);
228 static void commit_set_speed(BlockJob
*job
, int64_t speed
, Error
**errp
)
230 CommitBlockJob
*s
= container_of(job
, CommitBlockJob
, common
);
233 error_setg(errp
, QERR_INVALID_PARAMETER
, "speed");
236 ratelimit_set_speed(&s
->limit
, speed
/ BDRV_SECTOR_SIZE
, SLICE_TIME
);
239 static const BlockJobDriver commit_job_driver
= {
240 .instance_size
= sizeof(CommitBlockJob
),
241 .job_type
= BLOCK_JOB_TYPE_COMMIT
,
242 .set_speed
= commit_set_speed
,
246 static int coroutine_fn
bdrv_commit_top_preadv(BlockDriverState
*bs
,
247 uint64_t offset
, uint64_t bytes
, QEMUIOVector
*qiov
, int flags
)
249 return bdrv_co_preadv(bs
->backing
, offset
, bytes
, qiov
, flags
);
252 static int64_t coroutine_fn
bdrv_commit_top_get_block_status(
253 BlockDriverState
*bs
, int64_t sector_num
, int nb_sectors
, int *pnum
,
254 BlockDriverState
**file
)
257 *file
= bs
->backing
->bs
;
258 return BDRV_BLOCK_RAW
| BDRV_BLOCK_OFFSET_VALID
| BDRV_BLOCK_DATA
|
259 (sector_num
<< BDRV_SECTOR_BITS
);
262 static void bdrv_commit_top_refresh_filename(BlockDriverState
*bs
, QDict
*opts
)
264 bdrv_refresh_filename(bs
->backing
->bs
);
265 pstrcpy(bs
->exact_filename
, sizeof(bs
->exact_filename
),
266 bs
->backing
->bs
->filename
);
269 static void bdrv_commit_top_close(BlockDriverState
*bs
)
273 static void bdrv_commit_top_child_perm(BlockDriverState
*bs
, BdrvChild
*c
,
274 const BdrvChildRole
*role
,
275 uint64_t perm
, uint64_t shared
,
276 uint64_t *nperm
, uint64_t *nshared
)
279 *nshared
= BLK_PERM_ALL
;
282 /* Dummy node that provides consistent read to its users without requiring it
283 * from its backing file and that allows writes on the backing file chain. */
284 static BlockDriver bdrv_commit_top
= {
285 .format_name
= "commit_top",
286 .bdrv_co_preadv
= bdrv_commit_top_preadv
,
287 .bdrv_co_get_block_status
= bdrv_commit_top_get_block_status
,
288 .bdrv_refresh_filename
= bdrv_commit_top_refresh_filename
,
289 .bdrv_close
= bdrv_commit_top_close
,
290 .bdrv_child_perm
= bdrv_commit_top_child_perm
,
293 void commit_start(const char *job_id
, BlockDriverState
*bs
,
294 BlockDriverState
*base
, BlockDriverState
*top
, int64_t speed
,
295 BlockdevOnError on_error
, const char *backing_file_str
,
296 const char *filter_node_name
, Error
**errp
)
299 BlockReopenQueue
*reopen_queue
= NULL
;
300 int orig_overlay_flags
;
302 BlockDriverState
*iter
;
303 BlockDriverState
*overlay_bs
;
304 BlockDriverState
*commit_top_bs
= NULL
;
305 Error
*local_err
= NULL
;
310 error_setg(errp
, "Invalid files for merge: top and base are the same");
314 overlay_bs
= bdrv_find_overlay(bs
, top
);
316 if (overlay_bs
== NULL
) {
317 error_setg(errp
, "Could not find overlay image for %s:", top
->filename
);
321 s
= block_job_create(job_id
, &commit_job_driver
, bs
, 0, BLK_PERM_ALL
,
322 speed
, BLOCK_JOB_DEFAULT
, NULL
, NULL
, errp
);
327 orig_base_flags
= bdrv_get_flags(base
);
328 orig_overlay_flags
= bdrv_get_flags(overlay_bs
);
330 /* convert base & overlay_bs to r/w, if necessary */
331 if (!(orig_base_flags
& BDRV_O_RDWR
)) {
332 reopen_queue
= bdrv_reopen_queue(reopen_queue
, base
, NULL
,
333 orig_base_flags
| BDRV_O_RDWR
);
335 if (!(orig_overlay_flags
& BDRV_O_RDWR
)) {
336 reopen_queue
= bdrv_reopen_queue(reopen_queue
, overlay_bs
, NULL
,
337 orig_overlay_flags
| BDRV_O_RDWR
);
340 bdrv_reopen_multiple(bdrv_get_aio_context(bs
), reopen_queue
, &local_err
);
341 if (local_err
!= NULL
) {
342 error_propagate(errp
, local_err
);
347 /* Insert commit_top block node above top, so we can block consistent read
348 * on the backing chain below it */
349 commit_top_bs
= bdrv_new_open_driver(&bdrv_commit_top
, filter_node_name
, 0,
351 if (commit_top_bs
== NULL
) {
354 if (!filter_node_name
) {
355 commit_top_bs
->implicit
= true;
357 commit_top_bs
->total_sectors
= top
->total_sectors
;
358 bdrv_set_aio_context(commit_top_bs
, bdrv_get_aio_context(top
));
360 bdrv_set_backing_hd(commit_top_bs
, top
, &local_err
);
362 bdrv_unref(commit_top_bs
);
363 commit_top_bs
= NULL
;
364 error_propagate(errp
, local_err
);
367 bdrv_set_backing_hd(overlay_bs
, commit_top_bs
, &local_err
);
369 bdrv_unref(commit_top_bs
);
370 commit_top_bs
= NULL
;
371 error_propagate(errp
, local_err
);
375 s
->commit_top_bs
= commit_top_bs
;
376 bdrv_unref(commit_top_bs
);
378 /* Block all nodes between top and base, because they will
379 * disappear from the chain after this operation. */
380 assert(bdrv_chain_contains(top
, base
));
381 for (iter
= top
; iter
!= base
; iter
= backing_bs(iter
)) {
382 /* XXX BLK_PERM_WRITE needs to be allowed so we don't block ourselves
383 * at s->base (if writes are blocked for a node, they are also blocked
384 * for its backing file). The other options would be a second filter
385 * driver above s->base. */
386 ret
= block_job_add_bdrv(&s
->common
, "intermediate node", iter
, 0,
387 BLK_PERM_WRITE_UNCHANGED
| BLK_PERM_WRITE
,
394 ret
= block_job_add_bdrv(&s
->common
, "base", base
, 0, BLK_PERM_ALL
, errp
);
399 /* overlay_bs must be blocked because it needs to be modified to
400 * update the backing image string. */
401 ret
= block_job_add_bdrv(&s
->common
, "overlay of top", overlay_bs
,
402 BLK_PERM_GRAPH_MOD
, BLK_PERM_ALL
, errp
);
407 s
->base
= blk_new(BLK_PERM_CONSISTENT_READ
410 BLK_PERM_CONSISTENT_READ
412 | BLK_PERM_WRITE_UNCHANGED
);
413 ret
= blk_insert_bs(s
->base
, base
, errp
);
418 /* Required permissions are already taken with block_job_add_bdrv() */
419 s
->top
= blk_new(0, BLK_PERM_ALL
);
420 ret
= blk_insert_bs(s
->top
, top
, errp
);
427 s
->base_flags
= orig_base_flags
;
428 s
->orig_overlay_flags
= orig_overlay_flags
;
430 s
->backing_file_str
= g_strdup(backing_file_str
);
432 s
->on_error
= on_error
;
434 trace_commit_start(bs
, base
, top
, s
);
435 block_job_start(&s
->common
);
446 bdrv_set_backing_hd(overlay_bs
, top
, &error_abort
);
448 block_job_unref(&s
->common
);
452 #define COMMIT_BUF_SECTORS 2048
454 /* commit COW file into the raw image */
455 int bdrv_commit(BlockDriverState
*bs
)
457 BlockBackend
*src
, *backing
;
458 BlockDriverState
*backing_file_bs
= NULL
;
459 BlockDriverState
*commit_top_bs
= NULL
;
460 BlockDriver
*drv
= bs
->drv
;
461 int64_t sector
, total_sectors
, length
, backing_length
;
462 int n
, ro
, open_flags
;
465 Error
*local_err
= NULL
;
474 if (bdrv_op_is_blocked(bs
, BLOCK_OP_TYPE_COMMIT_SOURCE
, NULL
) ||
475 bdrv_op_is_blocked(bs
->backing
->bs
, BLOCK_OP_TYPE_COMMIT_TARGET
, NULL
)) {
479 ro
= bs
->backing
->bs
->read_only
;
480 open_flags
= bs
->backing
->bs
->open_flags
;
483 if (bdrv_reopen(bs
->backing
->bs
, open_flags
| BDRV_O_RDWR
, NULL
)) {
488 src
= blk_new(BLK_PERM_CONSISTENT_READ
, BLK_PERM_ALL
);
489 backing
= blk_new(BLK_PERM_WRITE
| BLK_PERM_RESIZE
, BLK_PERM_ALL
);
491 ret
= blk_insert_bs(src
, bs
, &local_err
);
493 error_report_err(local_err
);
497 /* Insert commit_top block node above backing, so we can write to it */
498 backing_file_bs
= backing_bs(bs
);
500 commit_top_bs
= bdrv_new_open_driver(&bdrv_commit_top
, NULL
, BDRV_O_RDWR
,
502 if (commit_top_bs
== NULL
) {
503 error_report_err(local_err
);
506 bdrv_set_aio_context(commit_top_bs
, bdrv_get_aio_context(backing_file_bs
));
508 bdrv_set_backing_hd(commit_top_bs
, backing_file_bs
, &error_abort
);
509 bdrv_set_backing_hd(bs
, commit_top_bs
, &error_abort
);
511 ret
= blk_insert_bs(backing
, backing_file_bs
, &local_err
);
513 error_report_err(local_err
);
517 length
= blk_getlength(src
);
523 backing_length
= blk_getlength(backing
);
524 if (backing_length
< 0) {
525 ret
= backing_length
;
529 /* If our top snapshot is larger than the backing file image,
530 * grow the backing file image if possible. If not possible,
531 * we must return an error */
532 if (length
> backing_length
) {
533 ret
= blk_truncate(backing
, length
, &local_err
);
535 error_report_err(local_err
);
540 total_sectors
= length
>> BDRV_SECTOR_BITS
;
542 /* blk_try_blockalign() for src will choose an alignment that works for
543 * backing as well, so no need to compare the alignment manually. */
544 buf
= blk_try_blockalign(src
, COMMIT_BUF_SECTORS
* BDRV_SECTOR_SIZE
);
550 for (sector
= 0; sector
< total_sectors
; sector
+= n
) {
551 ret
= bdrv_is_allocated(bs
, sector
, COMMIT_BUF_SECTORS
, &n
);
556 ret
= blk_pread(src
, sector
* BDRV_SECTOR_SIZE
, buf
,
557 n
* BDRV_SECTOR_SIZE
);
562 ret
= blk_pwrite(backing
, sector
* BDRV_SECTOR_SIZE
, buf
,
563 n
* BDRV_SECTOR_SIZE
, 0);
570 if (drv
->bdrv_make_empty
) {
571 ret
= drv
->bdrv_make_empty(bs
);
579 * Make sure all data we wrote to the backing device is actually
589 if (backing_file_bs
) {
590 bdrv_set_backing_hd(bs
, backing_file_bs
, &error_abort
);
592 bdrv_unref(commit_top_bs
);
596 /* ignoring error return here */
597 bdrv_reopen(bs
->backing
->bs
, open_flags
& ~BDRV_O_RDWR
, NULL
);