2 * QEMU host block devices
4 * Copyright (c) 2003-2008 Fabrice Bellard
6 * This work is licensed under the terms of the GNU GPL, version 2 or
7 * later. See the COPYING file in the top-level directory.
9 * This file incorporates work covered by the following copyright and
12 * Copyright (c) 2003-2008 Fabrice Bellard
14 * Permission is hereby granted, free of charge, to any person obtaining a copy
15 * of this software and associated documentation files (the "Software"), to deal
16 * in the Software without restriction, including without limitation the rights
17 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
18 * copies of the Software, and to permit persons to whom the Software is
19 * furnished to do so, subject to the following conditions:
21 * The above copyright notice and this permission notice shall be included in
22 * all copies or substantial portions of the Software.
24 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
25 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
26 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
27 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
28 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
29 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
33 #include "qemu/osdep.h"
34 #include "sysemu/block-backend.h"
35 #include "sysemu/blockdev.h"
36 #include "hw/block/block.h"
37 #include "block/blockjob.h"
38 #include "block/qdict.h"
39 #include "block/throttle-groups.h"
40 #include "monitor/monitor.h"
41 #include "qemu/error-report.h"
42 #include "qemu/option.h"
43 #include "qemu/qemu-print.h"
44 #include "qemu/config-file.h"
45 #include "qapi/qapi-commands-block.h"
46 #include "qapi/qapi-commands-transaction.h"
47 #include "qapi/qapi-visit-block-core.h"
48 #include "qapi/qmp/qdict.h"
49 #include "qapi/qmp/qnum.h"
50 #include "qapi/qmp/qstring.h"
51 #include "qapi/error.h"
52 #include "qapi/qmp/qerror.h"
53 #include "qapi/qmp/qlist.h"
54 #include "qapi/qobject-output-visitor.h"
55 #include "sysemu/sysemu.h"
56 #include "sysemu/iothread.h"
57 #include "block/block_int.h"
58 #include "block/trace.h"
59 #include "sysemu/runstate.h"
60 #include "sysemu/replay.h"
61 #include "qemu/cutils.h"
62 #include "qemu/help_option.h"
63 #include "qemu/main-loop.h"
64 #include "qemu/throttle-options.h"
66 QTAILQ_HEAD(, BlockDriverState
) monitor_bdrv_states
=
67 QTAILQ_HEAD_INITIALIZER(monitor_bdrv_states
);
69 void bdrv_set_monitor_owned(BlockDriverState
*bs
)
71 QTAILQ_INSERT_TAIL(&monitor_bdrv_states
, bs
, monitor_list
);
74 static const char *const if_name
[IF_COUNT
] = {
78 [IF_FLOPPY
] = "floppy",
79 [IF_PFLASH
] = "pflash",
82 [IF_VIRTIO
] = "virtio",
86 static int if_max_devs
[IF_COUNT
] = {
88 * Do not change these numbers! They govern how drive option
89 * index maps to unit and bus. That mapping is ABI.
91 * All controllers used to implement if=T drives need to support
92 * if_max_devs[T] units, for any T with if_max_devs[T] != 0.
93 * Otherwise, some index values map to "impossible" bus, unit
96 * For instance, if you change [IF_SCSI] to 255, -drive
97 * if=scsi,index=12 no longer means bus=1,unit=5, but
98 * bus=0,unit=12. With an lsi53c895a controller (7 units max),
99 * the drive can't be set up. Regression.
106 * Boards may call this to offer board-by-board overrides
107 * of the default, global values.
109 void override_max_devs(BlockInterfaceType type
, int max_devs
)
118 for (blk
= blk_next(NULL
); blk
; blk
= blk_next(blk
)) {
119 dinfo
= blk_legacy_dinfo(blk
);
120 if (dinfo
->type
== type
) {
121 fprintf(stderr
, "Cannot override units-per-bus property of"
122 " the %s interface, because a drive of that type has"
123 " already been added.\n", if_name
[type
]);
124 g_assert_not_reached();
128 if_max_devs
[type
] = max_devs
;
132 * We automatically delete the drive when a device using it gets
133 * unplugged. Questionable feature, but we can't just drop it.
134 * Device models call blockdev_mark_auto_del() to schedule the
135 * automatic deletion, and generic qdev code calls blockdev_auto_del()
136 * when deletion is actually safe.
138 void blockdev_mark_auto_del(BlockBackend
*blk
)
140 DriveInfo
*dinfo
= blk_legacy_dinfo(blk
);
147 for (job
= block_job_next(NULL
); job
; job
= block_job_next(job
)) {
148 if (block_job_has_bdrv(job
, blk_bs(blk
))) {
149 AioContext
*aio_context
= job
->job
.aio_context
;
150 aio_context_acquire(aio_context
);
152 job_cancel(&job
->job
, false);
154 aio_context_release(aio_context
);
161 void blockdev_auto_del(BlockBackend
*blk
)
163 DriveInfo
*dinfo
= blk_legacy_dinfo(blk
);
165 if (dinfo
&& dinfo
->auto_del
) {
166 monitor_remove_blk(blk
);
171 static int drive_index_to_bus_id(BlockInterfaceType type
, int index
)
173 int max_devs
= if_max_devs
[type
];
174 return max_devs
? index
/ max_devs
: 0;
177 static int drive_index_to_unit_id(BlockInterfaceType type
, int index
)
179 int max_devs
= if_max_devs
[type
];
180 return max_devs
? index
% max_devs
: index
;
183 QemuOpts
*drive_add(BlockInterfaceType type
, int index
, const char *file
,
188 opts
= qemu_opts_parse_noisily(qemu_find_opts("drive"), optstr
, false);
192 if (type
!= IF_DEFAULT
) {
193 qemu_opt_set(opts
, "if", if_name
[type
], &error_abort
);
196 qemu_opt_set_number(opts
, "index", index
, &error_abort
);
199 qemu_opt_set(opts
, "file", file
, &error_abort
);
203 DriveInfo
*drive_get(BlockInterfaceType type
, int bus
, int unit
)
208 for (blk
= blk_next(NULL
); blk
; blk
= blk_next(blk
)) {
209 dinfo
= blk_legacy_dinfo(blk
);
210 if (dinfo
&& dinfo
->type
== type
211 && dinfo
->bus
== bus
&& dinfo
->unit
== unit
) {
220 * Check board claimed all -drive that are meant to be claimed.
221 * Fatal error if any remain unclaimed.
223 void drive_check_orphaned(void)
228 bool orphans
= false;
230 for (blk
= blk_next(NULL
); blk
; blk
= blk_next(blk
)) {
231 dinfo
= blk_legacy_dinfo(blk
);
233 * Ignore default drives, because we create certain default
234 * drives unconditionally, then leave them unclaimed. Not the
236 * Ignore IF_VIRTIO, because it gets desugared into -device,
237 * so we can leave failing to -device.
238 * Ignore IF_NONE, because leaving unclaimed IF_NONE remains
239 * available for device_add is a feature.
241 if (dinfo
->is_default
|| dinfo
->type
== IF_VIRTIO
242 || dinfo
->type
== IF_NONE
) {
245 if (!blk_get_attached_dev(blk
)) {
247 qemu_opts_loc_restore(dinfo
->opts
);
248 error_report("machine type does not support"
249 " if=%s,bus=%d,unit=%d",
250 if_name
[dinfo
->type
], dinfo
->bus
, dinfo
->unit
);
261 DriveInfo
*drive_get_by_index(BlockInterfaceType type
, int index
)
263 return drive_get(type
,
264 drive_index_to_bus_id(type
, index
),
265 drive_index_to_unit_id(type
, index
));
268 int drive_get_max_bus(BlockInterfaceType type
)
275 for (blk
= blk_next(NULL
); blk
; blk
= blk_next(blk
)) {
276 dinfo
= blk_legacy_dinfo(blk
);
277 if (dinfo
&& dinfo
->type
== type
&& dinfo
->bus
> max_bus
) {
278 max_bus
= dinfo
->bus
;
284 static void bdrv_format_print(void *opaque
, const char *name
)
286 qemu_printf(" %s", name
);
291 BlockDriverState
*bs
;
294 static int parse_block_error_action(const char *buf
, bool is_read
, Error
**errp
)
296 if (!strcmp(buf
, "ignore")) {
297 return BLOCKDEV_ON_ERROR_IGNORE
;
298 } else if (!is_read
&& !strcmp(buf
, "enospc")) {
299 return BLOCKDEV_ON_ERROR_ENOSPC
;
300 } else if (!strcmp(buf
, "stop")) {
301 return BLOCKDEV_ON_ERROR_STOP
;
302 } else if (!strcmp(buf
, "report")) {
303 return BLOCKDEV_ON_ERROR_REPORT
;
305 error_setg(errp
, "'%s' invalid %s error action",
306 buf
, is_read
? "read" : "write");
311 static bool parse_stats_intervals(BlockAcctStats
*stats
, QList
*intervals
,
314 const QListEntry
*entry
;
315 for (entry
= qlist_first(intervals
); entry
; entry
= qlist_next(entry
)) {
316 switch (qobject_type(entry
->value
)) {
318 case QTYPE_QSTRING
: {
319 unsigned long long length
;
320 const char *str
= qstring_get_str(qobject_to(QString
,
322 if (parse_uint_full(str
, &length
, 10) == 0 &&
323 length
> 0 && length
<= UINT_MAX
) {
324 block_acct_add_interval(stats
, (unsigned) length
);
326 error_setg(errp
, "Invalid interval length: %s", str
);
333 int64_t length
= qnum_get_int(qobject_to(QNum
, entry
->value
));
335 if (length
> 0 && length
<= UINT_MAX
) {
336 block_acct_add_interval(stats
, (unsigned) length
);
338 error_setg(errp
, "Invalid interval length: %" PRId64
, length
);
345 error_setg(errp
, "The specification of stats-intervals is invalid");
352 typedef enum { MEDIA_DISK
, MEDIA_CDROM
} DriveMediaType
;
354 /* All parameters but @opts are optional and may be set to NULL. */
355 static void extract_common_blockdev_options(QemuOpts
*opts
, int *bdrv_flags
,
356 const char **throttling_group
, ThrottleConfig
*throttle_cfg
,
357 BlockdevDetectZeroesOptions
*detect_zeroes
, Error
**errp
)
359 Error
*local_error
= NULL
;
363 if (qemu_opt_get_bool(opts
, "copy-on-read", false)) {
364 *bdrv_flags
|= BDRV_O_COPY_ON_READ
;
367 if ((aio
= qemu_opt_get(opts
, "aio")) != NULL
) {
368 if (bdrv_parse_aio(aio
, bdrv_flags
) < 0) {
369 error_setg(errp
, "invalid aio option");
375 /* disk I/O throttling */
376 if (throttling_group
) {
377 *throttling_group
= qemu_opt_get(opts
, "throttling.group");
381 throttle_config_init(throttle_cfg
);
382 throttle_cfg
->buckets
[THROTTLE_BPS_TOTAL
].avg
=
383 qemu_opt_get_number(opts
, "throttling.bps-total", 0);
384 throttle_cfg
->buckets
[THROTTLE_BPS_READ
].avg
=
385 qemu_opt_get_number(opts
, "throttling.bps-read", 0);
386 throttle_cfg
->buckets
[THROTTLE_BPS_WRITE
].avg
=
387 qemu_opt_get_number(opts
, "throttling.bps-write", 0);
388 throttle_cfg
->buckets
[THROTTLE_OPS_TOTAL
].avg
=
389 qemu_opt_get_number(opts
, "throttling.iops-total", 0);
390 throttle_cfg
->buckets
[THROTTLE_OPS_READ
].avg
=
391 qemu_opt_get_number(opts
, "throttling.iops-read", 0);
392 throttle_cfg
->buckets
[THROTTLE_OPS_WRITE
].avg
=
393 qemu_opt_get_number(opts
, "throttling.iops-write", 0);
395 throttle_cfg
->buckets
[THROTTLE_BPS_TOTAL
].max
=
396 qemu_opt_get_number(opts
, "throttling.bps-total-max", 0);
397 throttle_cfg
->buckets
[THROTTLE_BPS_READ
].max
=
398 qemu_opt_get_number(opts
, "throttling.bps-read-max", 0);
399 throttle_cfg
->buckets
[THROTTLE_BPS_WRITE
].max
=
400 qemu_opt_get_number(opts
, "throttling.bps-write-max", 0);
401 throttle_cfg
->buckets
[THROTTLE_OPS_TOTAL
].max
=
402 qemu_opt_get_number(opts
, "throttling.iops-total-max", 0);
403 throttle_cfg
->buckets
[THROTTLE_OPS_READ
].max
=
404 qemu_opt_get_number(opts
, "throttling.iops-read-max", 0);
405 throttle_cfg
->buckets
[THROTTLE_OPS_WRITE
].max
=
406 qemu_opt_get_number(opts
, "throttling.iops-write-max", 0);
408 throttle_cfg
->buckets
[THROTTLE_BPS_TOTAL
].burst_length
=
409 qemu_opt_get_number(opts
, "throttling.bps-total-max-length", 1);
410 throttle_cfg
->buckets
[THROTTLE_BPS_READ
].burst_length
=
411 qemu_opt_get_number(opts
, "throttling.bps-read-max-length", 1);
412 throttle_cfg
->buckets
[THROTTLE_BPS_WRITE
].burst_length
=
413 qemu_opt_get_number(opts
, "throttling.bps-write-max-length", 1);
414 throttle_cfg
->buckets
[THROTTLE_OPS_TOTAL
].burst_length
=
415 qemu_opt_get_number(opts
, "throttling.iops-total-max-length", 1);
416 throttle_cfg
->buckets
[THROTTLE_OPS_READ
].burst_length
=
417 qemu_opt_get_number(opts
, "throttling.iops-read-max-length", 1);
418 throttle_cfg
->buckets
[THROTTLE_OPS_WRITE
].burst_length
=
419 qemu_opt_get_number(opts
, "throttling.iops-write-max-length", 1);
421 throttle_cfg
->op_size
=
422 qemu_opt_get_number(opts
, "throttling.iops-size", 0);
424 if (!throttle_is_valid(throttle_cfg
, errp
)) {
431 qapi_enum_parse(&BlockdevDetectZeroesOptions_lookup
,
432 qemu_opt_get(opts
, "detect-zeroes"),
433 BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF
,
436 error_propagate(errp
, local_error
);
442 /* Takes the ownership of bs_opts */
443 static BlockBackend
*blockdev_init(const char *file
, QDict
*bs_opts
,
448 int on_read_error
, on_write_error
;
449 bool account_invalid
, account_failed
;
450 bool writethrough
, read_only
;
452 BlockDriverState
*bs
;
457 QDict
*interval_dict
= NULL
;
458 QList
*interval_list
= NULL
;
460 BlockdevDetectZeroesOptions detect_zeroes
=
461 BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF
;
462 const char *throttling_group
= NULL
;
464 /* Check common options by copying from bs_opts to opts, all other options
465 * stay in bs_opts for processing by bdrv_open(). */
466 id
= qdict_get_try_str(bs_opts
, "id");
467 opts
= qemu_opts_create(&qemu_common_drive_opts
, id
, 1, errp
);
472 if (!qemu_opts_absorb_qdict(opts
, bs_opts
, errp
)) {
477 qdict_del(bs_opts
, "id");
480 /* extract parameters */
481 snapshot
= qemu_opt_get_bool(opts
, "snapshot", 0);
483 account_invalid
= qemu_opt_get_bool(opts
, "stats-account-invalid", true);
484 account_failed
= qemu_opt_get_bool(opts
, "stats-account-failed", true);
486 writethrough
= !qemu_opt_get_bool(opts
, BDRV_OPT_CACHE_WB
, true);
488 id
= qemu_opts_id(opts
);
490 qdict_extract_subqdict(bs_opts
, &interval_dict
, "stats-intervals.");
491 qdict_array_split(interval_dict
, &interval_list
);
493 if (qdict_size(interval_dict
) != 0) {
494 error_setg(errp
, "Invalid option stats-intervals.%s",
495 qdict_first(interval_dict
)->key
);
499 extract_common_blockdev_options(opts
, &bdrv_flags
, &throttling_group
, &cfg
,
500 &detect_zeroes
, &error
);
502 error_propagate(errp
, error
);
506 if ((buf
= qemu_opt_get(opts
, "format")) != NULL
) {
507 if (is_help_option(buf
)) {
508 qemu_printf("Supported formats:");
509 bdrv_iterate_format(bdrv_format_print
, NULL
, false);
510 qemu_printf("\nSupported formats (read-only):");
511 bdrv_iterate_format(bdrv_format_print
, NULL
, true);
516 if (qdict_haskey(bs_opts
, "driver")) {
517 error_setg(errp
, "Cannot specify both 'driver' and 'format'");
520 qdict_put_str(bs_opts
, "driver", buf
);
523 on_write_error
= BLOCKDEV_ON_ERROR_ENOSPC
;
524 if ((buf
= qemu_opt_get(opts
, "werror")) != NULL
) {
525 on_write_error
= parse_block_error_action(buf
, 0, &error
);
527 error_propagate(errp
, error
);
532 on_read_error
= BLOCKDEV_ON_ERROR_REPORT
;
533 if ((buf
= qemu_opt_get(opts
, "rerror")) != NULL
) {
534 on_read_error
= parse_block_error_action(buf
, 1, &error
);
536 error_propagate(errp
, error
);
542 bdrv_flags
|= BDRV_O_SNAPSHOT
;
545 read_only
= qemu_opt_get_bool(opts
, BDRV_OPT_READ_ONLY
, false);
548 if ((!file
|| !*file
) && !qdict_size(bs_opts
)) {
549 BlockBackendRootState
*blk_rs
;
551 blk
= blk_new(qemu_get_aio_context(), 0, BLK_PERM_ALL
);
552 blk_rs
= blk_get_root_state(blk
);
553 blk_rs
->open_flags
= bdrv_flags
| (read_only
? 0 : BDRV_O_RDWR
);
554 blk_rs
->detect_zeroes
= detect_zeroes
;
556 qobject_unref(bs_opts
);
558 if (file
&& !*file
) {
562 /* bdrv_open() defaults to the values in bdrv_flags (for compatibility
563 * with other callers) rather than what we want as the real defaults.
564 * Apply the defaults here instead. */
565 qdict_set_default_str(bs_opts
, BDRV_OPT_CACHE_DIRECT
, "off");
566 qdict_set_default_str(bs_opts
, BDRV_OPT_CACHE_NO_FLUSH
, "off");
567 qdict_set_default_str(bs_opts
, BDRV_OPT_READ_ONLY
,
568 read_only
? "on" : "off");
569 qdict_set_default_str(bs_opts
, BDRV_OPT_AUTO_READ_ONLY
, "on");
570 assert((bdrv_flags
& BDRV_O_CACHE_MASK
) == 0);
572 if (runstate_check(RUN_STATE_INMIGRATE
)) {
573 bdrv_flags
|= BDRV_O_INACTIVE
;
576 blk
= blk_new_open(file
, NULL
, bs_opts
, bdrv_flags
, errp
);
582 bs
->detect_zeroes
= detect_zeroes
;
584 block_acct_setup(blk_get_stats(blk
), account_invalid
, account_failed
);
586 if (!parse_stats_intervals(blk_get_stats(blk
), interval_list
, errp
)) {
593 /* disk I/O throttling */
594 if (throttle_enabled(&cfg
)) {
595 if (!throttling_group
) {
596 throttling_group
= id
;
598 blk_io_limits_enable(blk
, throttling_group
);
599 blk_set_io_limits(blk
, &cfg
);
602 blk_set_enable_write_cache(blk
, !writethrough
);
603 blk_set_on_error(blk
, on_read_error
, on_write_error
);
605 if (!monitor_add_blk(blk
, id
, errp
)) {
613 qobject_unref(interval_dict
);
614 qobject_unref(interval_list
);
619 qobject_unref(interval_dict
);
620 qobject_unref(interval_list
);
622 qobject_unref(bs_opts
);
626 /* Takes the ownership of bs_opts */
627 BlockDriverState
*bds_tree_init(QDict
*bs_opts
, Error
**errp
)
631 /* bdrv_open() defaults to the values in bdrv_flags (for compatibility
632 * with other callers) rather than what we want as the real defaults.
633 * Apply the defaults here instead. */
634 qdict_set_default_str(bs_opts
, BDRV_OPT_CACHE_DIRECT
, "off");
635 qdict_set_default_str(bs_opts
, BDRV_OPT_CACHE_NO_FLUSH
, "off");
636 qdict_set_default_str(bs_opts
, BDRV_OPT_READ_ONLY
, "off");
638 if (runstate_check(RUN_STATE_INMIGRATE
)) {
639 bdrv_flags
|= BDRV_O_INACTIVE
;
642 return bdrv_open(NULL
, NULL
, bs_opts
, bdrv_flags
, errp
);
645 void blockdev_close_all_bdrv_states(void)
647 BlockDriverState
*bs
, *next_bs
;
649 QTAILQ_FOREACH_SAFE(bs
, &monitor_bdrv_states
, monitor_list
, next_bs
) {
650 AioContext
*ctx
= bdrv_get_aio_context(bs
);
652 aio_context_acquire(ctx
);
654 aio_context_release(ctx
);
658 /* Iterates over the list of monitor-owned BlockDriverStates */
659 BlockDriverState
*bdrv_next_monitor_owned(BlockDriverState
*bs
)
662 return bs
? QTAILQ_NEXT(bs
, monitor_list
)
663 : QTAILQ_FIRST(&monitor_bdrv_states
);
666 static bool qemu_opt_rename(QemuOpts
*opts
, const char *from
, const char *to
,
671 value
= qemu_opt_get(opts
, from
);
673 if (qemu_opt_find(opts
, to
)) {
674 error_setg(errp
, "'%s' and its alias '%s' can't be used at the "
675 "same time", to
, from
);
680 /* rename all items in opts */
681 while ((value
= qemu_opt_get(opts
, from
))) {
682 qemu_opt_set(opts
, to
, value
, &error_abort
);
683 qemu_opt_unset(opts
, from
);
688 QemuOptsList qemu_legacy_drive_opts
= {
690 .head
= QTAILQ_HEAD_INITIALIZER(qemu_legacy_drive_opts
.head
),
694 .type
= QEMU_OPT_NUMBER
,
695 .help
= "bus number",
698 .type
= QEMU_OPT_NUMBER
,
699 .help
= "unit number (i.e. lun for scsi)",
702 .type
= QEMU_OPT_NUMBER
,
703 .help
= "index number",
706 .type
= QEMU_OPT_STRING
,
707 .help
= "media type (disk, cdrom)",
710 .type
= QEMU_OPT_STRING
,
711 .help
= "interface (ide, scsi, sd, mtd, floppy, pflash, virtio)",
714 .type
= QEMU_OPT_STRING
,
718 /* Options that are passed on, but have special semantics with -drive */
720 .name
= BDRV_OPT_READ_ONLY
,
721 .type
= QEMU_OPT_BOOL
,
722 .help
= "open drive file as read-only",
725 .type
= QEMU_OPT_STRING
,
726 .help
= "read error action",
729 .type
= QEMU_OPT_STRING
,
730 .help
= "write error action",
732 .name
= "copy-on-read",
733 .type
= QEMU_OPT_BOOL
,
734 .help
= "copy read data from backing file into image file",
737 { /* end of list */ }
741 DriveInfo
*drive_new(QemuOpts
*all_opts
, BlockInterfaceType block_default_type
,
746 DriveInfo
*dinfo
= NULL
;
748 QemuOpts
*legacy_opts
;
749 DriveMediaType media
= MEDIA_DISK
;
750 BlockInterfaceType type
;
751 int max_devs
, bus_id
, unit_id
, index
;
752 const char *werror
, *rerror
;
753 bool read_only
= false;
755 const char *filename
;
758 /* Change legacy command line options into QMP ones */
759 static const struct {
763 { "iops", "throttling.iops-total" },
764 { "iops_rd", "throttling.iops-read" },
765 { "iops_wr", "throttling.iops-write" },
767 { "bps", "throttling.bps-total" },
768 { "bps_rd", "throttling.bps-read" },
769 { "bps_wr", "throttling.bps-write" },
771 { "iops_max", "throttling.iops-total-max" },
772 { "iops_rd_max", "throttling.iops-read-max" },
773 { "iops_wr_max", "throttling.iops-write-max" },
775 { "bps_max", "throttling.bps-total-max" },
776 { "bps_rd_max", "throttling.bps-read-max" },
777 { "bps_wr_max", "throttling.bps-write-max" },
779 { "iops_size", "throttling.iops-size" },
781 { "group", "throttling.group" },
783 { "readonly", BDRV_OPT_READ_ONLY
},
786 for (i
= 0; i
< ARRAY_SIZE(opt_renames
); i
++) {
787 if (!qemu_opt_rename(all_opts
, opt_renames
[i
].from
,
788 opt_renames
[i
].to
, errp
)) {
793 value
= qemu_opt_get(all_opts
, "cache");
798 if (bdrv_parse_cache_mode(value
, &flags
, &writethrough
) != 0) {
799 error_setg(errp
, "invalid cache option");
803 /* Specific options take precedence */
804 if (!qemu_opt_get(all_opts
, BDRV_OPT_CACHE_WB
)) {
805 qemu_opt_set_bool(all_opts
, BDRV_OPT_CACHE_WB
,
806 !writethrough
, &error_abort
);
808 if (!qemu_opt_get(all_opts
, BDRV_OPT_CACHE_DIRECT
)) {
809 qemu_opt_set_bool(all_opts
, BDRV_OPT_CACHE_DIRECT
,
810 !!(flags
& BDRV_O_NOCACHE
), &error_abort
);
812 if (!qemu_opt_get(all_opts
, BDRV_OPT_CACHE_NO_FLUSH
)) {
813 qemu_opt_set_bool(all_opts
, BDRV_OPT_CACHE_NO_FLUSH
,
814 !!(flags
& BDRV_O_NO_FLUSH
), &error_abort
);
816 qemu_opt_unset(all_opts
, "cache");
819 /* Get a QDict for processing the options */
820 bs_opts
= qdict_new();
821 qemu_opts_to_qdict(all_opts
, bs_opts
);
823 legacy_opts
= qemu_opts_create(&qemu_legacy_drive_opts
, NULL
, 0,
825 if (!qemu_opts_absorb_qdict(legacy_opts
, bs_opts
, errp
)) {
830 value
= qemu_opt_get(legacy_opts
, "media");
832 if (!strcmp(value
, "disk")) {
834 } else if (!strcmp(value
, "cdrom")) {
838 error_setg(errp
, "'%s' invalid media", value
);
843 /* copy-on-read is disabled with a warning for read-only devices */
844 read_only
|= qemu_opt_get_bool(legacy_opts
, BDRV_OPT_READ_ONLY
, false);
845 copy_on_read
= qemu_opt_get_bool(legacy_opts
, "copy-on-read", false);
847 if (read_only
&& copy_on_read
) {
848 warn_report("disabling copy-on-read on read-only drive");
849 copy_on_read
= false;
852 qdict_put_str(bs_opts
, BDRV_OPT_READ_ONLY
, read_only
? "on" : "off");
853 qdict_put_str(bs_opts
, "copy-on-read", copy_on_read
? "on" : "off");
855 /* Controller type */
856 value
= qemu_opt_get(legacy_opts
, "if");
859 type
< IF_COUNT
&& strcmp(value
, if_name
[type
]);
862 if (type
== IF_COUNT
) {
863 error_setg(errp
, "unsupported bus type '%s'", value
);
867 type
= block_default_type
;
870 /* Device address specified by bus/unit or index.
871 * If none was specified, try to find the first free one. */
872 bus_id
= qemu_opt_get_number(legacy_opts
, "bus", 0);
873 unit_id
= qemu_opt_get_number(legacy_opts
, "unit", -1);
874 index
= qemu_opt_get_number(legacy_opts
, "index", -1);
876 max_devs
= if_max_devs
[type
];
879 if (bus_id
!= 0 || unit_id
!= -1) {
880 error_setg(errp
, "index cannot be used with bus and unit");
883 bus_id
= drive_index_to_bus_id(type
, index
);
884 unit_id
= drive_index_to_unit_id(type
, index
);
889 while (drive_get(type
, bus_id
, unit_id
) != NULL
) {
891 if (max_devs
&& unit_id
>= max_devs
) {
898 if (max_devs
&& unit_id
>= max_devs
) {
899 error_setg(errp
, "unit %d too big (max is %d)", unit_id
, max_devs
- 1);
903 if (drive_get(type
, bus_id
, unit_id
) != NULL
) {
904 error_setg(errp
, "drive with bus=%d, unit=%d (index=%d) exists",
905 bus_id
, unit_id
, index
);
909 /* no id supplied -> create one */
910 if (qemu_opts_id(all_opts
) == NULL
) {
912 const char *mediastr
= "";
913 if (type
== IF_IDE
|| type
== IF_SCSI
) {
914 mediastr
= (media
== MEDIA_CDROM
) ? "-cd" : "-hd";
917 new_id
= g_strdup_printf("%s%i%s%i", if_name
[type
], bus_id
,
920 new_id
= g_strdup_printf("%s%s%i", if_name
[type
],
923 qdict_put_str(bs_opts
, "id", new_id
);
927 /* Add virtio block device */
928 if (type
== IF_VIRTIO
) {
930 devopts
= qemu_opts_create(qemu_find_opts("device"), NULL
, 0,
932 qemu_opt_set(devopts
, "driver", "virtio-blk", &error_abort
);
933 qemu_opt_set(devopts
, "drive", qdict_get_str(bs_opts
, "id"),
937 filename
= qemu_opt_get(legacy_opts
, "file");
939 /* Check werror/rerror compatibility with if=... */
940 werror
= qemu_opt_get(legacy_opts
, "werror");
941 if (werror
!= NULL
) {
942 if (type
!= IF_IDE
&& type
!= IF_SCSI
&& type
!= IF_VIRTIO
&&
944 error_setg(errp
, "werror is not supported by this bus type");
947 qdict_put_str(bs_opts
, "werror", werror
);
950 rerror
= qemu_opt_get(legacy_opts
, "rerror");
951 if (rerror
!= NULL
) {
952 if (type
!= IF_IDE
&& type
!= IF_VIRTIO
&& type
!= IF_SCSI
&&
954 error_setg(errp
, "rerror is not supported by this bus type");
957 qdict_put_str(bs_opts
, "rerror", rerror
);
960 /* Actual block device init: Functionality shared with blockdev-add */
961 blk
= blockdev_init(filename
, bs_opts
, errp
);
967 /* Create legacy DriveInfo */
968 dinfo
= g_malloc0(sizeof(*dinfo
));
969 dinfo
->opts
= all_opts
;
973 dinfo
->unit
= unit_id
;
975 blk_set_legacy_dinfo(blk
, dinfo
);
982 dinfo
->media_cd
= media
== MEDIA_CDROM
;
989 qemu_opts_del(legacy_opts
);
990 qobject_unref(bs_opts
);
994 static BlockDriverState
*qmp_get_root_bs(const char *name
, Error
**errp
)
996 BlockDriverState
*bs
;
998 bs
= bdrv_lookup_bs(name
, name
, errp
);
1003 if (!bdrv_is_root_node(bs
)) {
1004 error_setg(errp
, "Need a root block node");
1008 if (!bdrv_is_inserted(bs
)) {
1009 error_setg(errp
, "Device has no medium");
1016 static void blockdev_do_action(TransactionAction
*action
, Error
**errp
)
1018 TransactionActionList list
;
1020 list
.value
= action
;
1022 qmp_transaction(&list
, false, NULL
, errp
);
1025 void qmp_blockdev_snapshot_sync(bool has_device
, const char *device
,
1026 bool has_node_name
, const char *node_name
,
1027 const char *snapshot_file
,
1028 bool has_snapshot_node_name
,
1029 const char *snapshot_node_name
,
1030 bool has_format
, const char *format
,
1031 bool has_mode
, NewImageMode mode
, Error
**errp
)
1033 BlockdevSnapshotSync snapshot
= {
1034 .has_device
= has_device
,
1035 .device
= (char *) device
,
1036 .has_node_name
= has_node_name
,
1037 .node_name
= (char *) node_name
,
1038 .snapshot_file
= (char *) snapshot_file
,
1039 .has_snapshot_node_name
= has_snapshot_node_name
,
1040 .snapshot_node_name
= (char *) snapshot_node_name
,
1041 .has_format
= has_format
,
1042 .format
= (char *) format
,
1043 .has_mode
= has_mode
,
1046 TransactionAction action
= {
1047 .type
= TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_SYNC
,
1048 .u
.blockdev_snapshot_sync
.data
= &snapshot
,
1050 blockdev_do_action(&action
, errp
);
1053 void qmp_blockdev_snapshot(const char *node
, const char *overlay
,
1056 BlockdevSnapshot snapshot_data
= {
1057 .node
= (char *) node
,
1058 .overlay
= (char *) overlay
1060 TransactionAction action
= {
1061 .type
= TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT
,
1062 .u
.blockdev_snapshot
.data
= &snapshot_data
,
1064 blockdev_do_action(&action
, errp
);
1067 void qmp_blockdev_snapshot_internal_sync(const char *device
,
1071 BlockdevSnapshotInternal snapshot
= {
1072 .device
= (char *) device
,
1073 .name
= (char *) name
1075 TransactionAction action
= {
1076 .type
= TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_INTERNAL_SYNC
,
1077 .u
.blockdev_snapshot_internal_sync
.data
= &snapshot
,
1079 blockdev_do_action(&action
, errp
);
1082 SnapshotInfo
*qmp_blockdev_snapshot_delete_internal_sync(const char *device
,
1089 BlockDriverState
*bs
;
1090 AioContext
*aio_context
;
1091 QEMUSnapshotInfo sn
;
1092 Error
*local_err
= NULL
;
1093 SnapshotInfo
*info
= NULL
;
1096 bs
= qmp_get_root_bs(device
, errp
);
1100 aio_context
= bdrv_get_aio_context(bs
);
1101 aio_context_acquire(aio_context
);
1112 error_setg(errp
, "Name or id must be provided");
1113 goto out_aio_context
;
1116 if (bdrv_op_is_blocked(bs
, BLOCK_OP_TYPE_INTERNAL_SNAPSHOT_DELETE
, errp
)) {
1117 goto out_aio_context
;
1120 ret
= bdrv_snapshot_find_by_id_and_name(bs
, id
, name
, &sn
, &local_err
);
1122 error_propagate(errp
, local_err
);
1123 goto out_aio_context
;
1127 "Snapshot with id '%s' and name '%s' does not exist on "
1129 STR_OR_NULL(id
), STR_OR_NULL(name
), device
);
1130 goto out_aio_context
;
1133 bdrv_snapshot_delete(bs
, id
, name
, &local_err
);
1135 error_propagate(errp
, local_err
);
1136 goto out_aio_context
;
1139 aio_context_release(aio_context
);
1141 info
= g_new0(SnapshotInfo
, 1);
1142 info
->id
= g_strdup(sn
.id_str
);
1143 info
->name
= g_strdup(sn
.name
);
1144 info
->date_nsec
= sn
.date_nsec
;
1145 info
->date_sec
= sn
.date_sec
;
1146 info
->vm_state_size
= sn
.vm_state_size
;
1147 info
->vm_clock_nsec
= sn
.vm_clock_nsec
% 1000000000;
1148 info
->vm_clock_sec
= sn
.vm_clock_nsec
/ 1000000000;
1149 if (sn
.icount
!= -1ULL) {
1150 info
->icount
= sn
.icount
;
1151 info
->has_icount
= true;
1157 aio_context_release(aio_context
);
1161 /* New and old BlockDriverState structs for atomic group operations */
1163 typedef struct BlkActionState BlkActionState
;
1167 * Table of operations that define an Action.
1169 * @instance_size: Size of state struct, in bytes.
1170 * @prepare: Prepare the work, must NOT be NULL.
1171 * @commit: Commit the changes, can be NULL.
1172 * @abort: Abort the changes on fail, can be NULL.
1173 * @clean: Clean up resources after all transaction actions have called
1174 * commit() or abort(). Can be NULL.
1176 * Only prepare() may fail. In a single transaction, only one of commit() or
1177 * abort() will be called. clean() will always be called if it is present.
1179 typedef struct BlkActionOps
{
1180 size_t instance_size
;
1181 void (*prepare
)(BlkActionState
*common
, Error
**errp
);
1182 void (*commit
)(BlkActionState
*common
);
1183 void (*abort
)(BlkActionState
*common
);
1184 void (*clean
)(BlkActionState
*common
);
1189 * Describes one Action's state within a Transaction.
1191 * @action: QAPI-defined enum identifying which Action to perform.
1192 * @ops: Table of ActionOps this Action can perform.
1193 * @block_job_txn: Transaction which this action belongs to.
1194 * @entry: List membership for all Actions in this Transaction.
1196 * This structure must be arranged as first member in a subclassed type,
1197 * assuming that the compiler will also arrange it to the same offsets as the
1200 struct BlkActionState
{
1201 TransactionAction
*action
;
1202 const BlkActionOps
*ops
;
1203 JobTxn
*block_job_txn
;
1204 TransactionProperties
*txn_props
;
1205 QTAILQ_ENTRY(BlkActionState
) entry
;
1208 /* internal snapshot private data */
1209 typedef struct InternalSnapshotState
{
1210 BlkActionState common
;
1211 BlockDriverState
*bs
;
1212 QEMUSnapshotInfo sn
;
1214 } InternalSnapshotState
;
1217 static int action_check_completion_mode(BlkActionState
*s
, Error
**errp
)
1219 if (s
->txn_props
->completion_mode
!= ACTION_COMPLETION_MODE_INDIVIDUAL
) {
1221 "Action '%s' does not support Transaction property "
1222 "completion-mode = %s",
1223 TransactionActionKind_str(s
->action
->type
),
1224 ActionCompletionMode_str(s
->txn_props
->completion_mode
));
1230 static void internal_snapshot_prepare(BlkActionState
*common
,
1233 Error
*local_err
= NULL
;
1236 BlockDriverState
*bs
;
1237 QEMUSnapshotInfo old_sn
, *sn
;
1240 BlockdevSnapshotInternal
*internal
;
1241 InternalSnapshotState
*state
;
1242 AioContext
*aio_context
;
1245 g_assert(common
->action
->type
==
1246 TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_INTERNAL_SYNC
);
1247 internal
= common
->action
->u
.blockdev_snapshot_internal_sync
.data
;
1248 state
= DO_UPCAST(InternalSnapshotState
, common
, common
);
1250 /* 1. parse input */
1251 device
= internal
->device
;
1252 name
= internal
->name
;
1254 /* 2. check for validation */
1255 if (action_check_completion_mode(common
, errp
) < 0) {
1259 bs
= qmp_get_root_bs(device
, errp
);
1264 aio_context
= bdrv_get_aio_context(bs
);
1265 aio_context_acquire(aio_context
);
1269 /* Paired with .clean() */
1270 bdrv_drained_begin(bs
);
1272 if (bdrv_op_is_blocked(bs
, BLOCK_OP_TYPE_INTERNAL_SNAPSHOT
, errp
)) {
1276 if (bdrv_is_read_only(bs
)) {
1277 error_setg(errp
, "Device '%s' is read only", device
);
1281 if (!bdrv_can_snapshot(bs
)) {
1282 error_setg(errp
, "Block format '%s' used by device '%s' "
1283 "does not support internal snapshots",
1284 bs
->drv
->format_name
, device
);
1288 if (!strlen(name
)) {
1289 error_setg(errp
, "Name is empty");
1293 /* check whether a snapshot with name exist */
1294 ret
= bdrv_snapshot_find_by_id_and_name(bs
, NULL
, name
, &old_sn
,
1297 error_propagate(errp
, local_err
);
1301 "Snapshot with name '%s' already exists on device '%s'",
1306 /* 3. take the snapshot */
1308 pstrcpy(sn
->name
, sizeof(sn
->name
), name
);
1309 qemu_gettimeofday(&tv
);
1310 sn
->date_sec
= tv
.tv_sec
;
1311 sn
->date_nsec
= tv
.tv_usec
* 1000;
1312 sn
->vm_clock_nsec
= qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
);
1313 if (replay_mode
!= REPLAY_MODE_NONE
) {
1314 sn
->icount
= replay_get_current_icount();
1319 ret1
= bdrv_snapshot_create(bs
, sn
);
1321 error_setg_errno(errp
, -ret1
,
1322 "Failed to create snapshot '%s' on device '%s'",
1327 /* 4. succeed, mark a snapshot is created */
1328 state
->created
= true;
1331 aio_context_release(aio_context
);
1334 static void internal_snapshot_abort(BlkActionState
*common
)
1336 InternalSnapshotState
*state
=
1337 DO_UPCAST(InternalSnapshotState
, common
, common
);
1338 BlockDriverState
*bs
= state
->bs
;
1339 QEMUSnapshotInfo
*sn
= &state
->sn
;
1340 AioContext
*aio_context
;
1341 Error
*local_error
= NULL
;
1343 if (!state
->created
) {
1347 aio_context
= bdrv_get_aio_context(state
->bs
);
1348 aio_context_acquire(aio_context
);
1350 if (bdrv_snapshot_delete(bs
, sn
->id_str
, sn
->name
, &local_error
) < 0) {
1351 error_reportf_err(local_error
,
1352 "Failed to delete snapshot with id '%s' and "
1353 "name '%s' on device '%s' in abort: ",
1354 sn
->id_str
, sn
->name
,
1355 bdrv_get_device_name(bs
));
1358 aio_context_release(aio_context
);
1361 static void internal_snapshot_clean(BlkActionState
*common
)
1363 InternalSnapshotState
*state
= DO_UPCAST(InternalSnapshotState
,
1365 AioContext
*aio_context
;
1371 aio_context
= bdrv_get_aio_context(state
->bs
);
1372 aio_context_acquire(aio_context
);
1374 bdrv_drained_end(state
->bs
);
1376 aio_context_release(aio_context
);
1379 /* external snapshot private data */
1380 typedef struct ExternalSnapshotState
{
1381 BlkActionState common
;
1382 BlockDriverState
*old_bs
;
1383 BlockDriverState
*new_bs
;
1384 bool overlay_appended
;
1385 } ExternalSnapshotState
;
1387 static void external_snapshot_prepare(BlkActionState
*common
,
1392 QDict
*options
= NULL
;
1393 Error
*local_err
= NULL
;
1394 /* Device and node name of the image to generate the snapshot from */
1396 const char *node_name
;
1397 /* Reference to the new image (for 'blockdev-snapshot') */
1398 const char *snapshot_ref
;
1399 /* File name of the new image (for 'blockdev-snapshot-sync') */
1400 const char *new_image_file
;
1401 ExternalSnapshotState
*state
=
1402 DO_UPCAST(ExternalSnapshotState
, common
, common
);
1403 TransactionAction
*action
= common
->action
;
1404 AioContext
*aio_context
;
1405 uint64_t perm
, shared
;
1407 /* 'blockdev-snapshot' and 'blockdev-snapshot-sync' have similar
1408 * purpose but a different set of parameters */
1409 switch (action
->type
) {
1410 case TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT
:
1412 BlockdevSnapshot
*s
= action
->u
.blockdev_snapshot
.data
;
1414 node_name
= s
->node
;
1415 new_image_file
= NULL
;
1416 snapshot_ref
= s
->overlay
;
1419 case TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_SYNC
:
1421 BlockdevSnapshotSync
*s
= action
->u
.blockdev_snapshot_sync
.data
;
1422 device
= s
->has_device
? s
->device
: NULL
;
1423 node_name
= s
->has_node_name
? s
->node_name
: NULL
;
1424 new_image_file
= s
->snapshot_file
;
1425 snapshot_ref
= NULL
;
1429 g_assert_not_reached();
1432 /* start processing */
1433 if (action_check_completion_mode(common
, errp
) < 0) {
1437 state
->old_bs
= bdrv_lookup_bs(device
, node_name
, errp
);
1438 if (!state
->old_bs
) {
1442 aio_context
= bdrv_get_aio_context(state
->old_bs
);
1443 aio_context_acquire(aio_context
);
1445 /* Paired with .clean() */
1446 bdrv_drained_begin(state
->old_bs
);
1448 if (!bdrv_is_inserted(state
->old_bs
)) {
1449 error_setg(errp
, QERR_DEVICE_HAS_NO_MEDIUM
, device
);
1453 if (bdrv_op_is_blocked(state
->old_bs
,
1454 BLOCK_OP_TYPE_EXTERNAL_SNAPSHOT
, errp
)) {
1458 if (!bdrv_is_read_only(state
->old_bs
)) {
1459 if (bdrv_flush(state
->old_bs
)) {
1460 error_setg(errp
, QERR_IO_ERROR
);
1465 if (action
->type
== TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_SYNC
) {
1466 BlockdevSnapshotSync
*s
= action
->u
.blockdev_snapshot_sync
.data
;
1467 const char *format
= s
->has_format
? s
->format
: "qcow2";
1468 enum NewImageMode mode
;
1469 const char *snapshot_node_name
=
1470 s
->has_snapshot_node_name
? s
->snapshot_node_name
: NULL
;
1472 if (node_name
&& !snapshot_node_name
) {
1473 error_setg(errp
, "New overlay node-name missing");
1477 if (snapshot_node_name
&&
1478 bdrv_lookup_bs(snapshot_node_name
, snapshot_node_name
, NULL
)) {
1479 error_setg(errp
, "New overlay node-name already in use");
1483 flags
= state
->old_bs
->open_flags
;
1484 flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_COPY_ON_READ
);
1485 flags
|= BDRV_O_NO_BACKING
;
1487 /* create new image w/backing file */
1488 mode
= s
->has_mode
? s
->mode
: NEW_IMAGE_MODE_ABSOLUTE_PATHS
;
1489 if (mode
!= NEW_IMAGE_MODE_EXISTING
) {
1490 int64_t size
= bdrv_getlength(state
->old_bs
);
1492 error_setg_errno(errp
, -size
, "bdrv_getlength failed");
1495 bdrv_refresh_filename(state
->old_bs
);
1496 bdrv_img_create(new_image_file
, format
,
1497 state
->old_bs
->filename
,
1498 state
->old_bs
->drv
->format_name
,
1499 NULL
, size
, flags
, false, &local_err
);
1501 error_propagate(errp
, local_err
);
1506 options
= qdict_new();
1507 if (snapshot_node_name
) {
1508 qdict_put_str(options
, "node-name", snapshot_node_name
);
1510 qdict_put_str(options
, "driver", format
);
1513 state
->new_bs
= bdrv_open(new_image_file
, snapshot_ref
, options
, flags
,
1515 /* We will manually add the backing_hd field to the bs later */
1516 if (!state
->new_bs
) {
1521 * Allow attaching a backing file to an overlay that's already in use only
1522 * if the parents don't assume that they are already seeing a valid image.
1523 * (Specifically, allow it as a mirror target, which is write-only access.)
1525 bdrv_get_cumulative_perm(state
->new_bs
, &perm
, &shared
);
1526 if (perm
& BLK_PERM_CONSISTENT_READ
) {
1527 error_setg(errp
, "The overlay is already in use");
1531 if (state
->new_bs
->drv
->is_filter
) {
1532 error_setg(errp
, "Filters cannot be used as overlays");
1536 if (bdrv_cow_child(state
->new_bs
)) {
1537 error_setg(errp
, "The overlay already has a backing image");
1541 if (!state
->new_bs
->drv
->supports_backing
) {
1542 error_setg(errp
, "The overlay does not support backing images");
1546 ret
= bdrv_append(state
->new_bs
, state
->old_bs
, errp
);
1550 state
->overlay_appended
= true;
1553 aio_context_release(aio_context
);
1556 static void external_snapshot_commit(BlkActionState
*common
)
1558 ExternalSnapshotState
*state
=
1559 DO_UPCAST(ExternalSnapshotState
, common
, common
);
1560 AioContext
*aio_context
;
1562 aio_context
= bdrv_get_aio_context(state
->old_bs
);
1563 aio_context_acquire(aio_context
);
1565 /* We don't need (or want) to use the transactional
1566 * bdrv_reopen_multiple() across all the entries at once, because we
1567 * don't want to abort all of them if one of them fails the reopen */
1568 if (!qatomic_read(&state
->old_bs
->copy_on_read
)) {
1569 bdrv_reopen_set_read_only(state
->old_bs
, true, NULL
);
1572 aio_context_release(aio_context
);
1575 static void external_snapshot_abort(BlkActionState
*common
)
1577 ExternalSnapshotState
*state
=
1578 DO_UPCAST(ExternalSnapshotState
, common
, common
);
1579 if (state
->new_bs
) {
1580 if (state
->overlay_appended
) {
1581 AioContext
*aio_context
;
1582 AioContext
*tmp_context
;
1585 aio_context
= bdrv_get_aio_context(state
->old_bs
);
1586 aio_context_acquire(aio_context
);
1588 bdrv_ref(state
->old_bs
); /* we can't let bdrv_set_backind_hd()
1589 close state->old_bs; we need it */
1590 bdrv_set_backing_hd(state
->new_bs
, NULL
, &error_abort
);
1593 * The call to bdrv_set_backing_hd() above returns state->old_bs to
1594 * the main AioContext. As we're still going to be using it, return
1595 * it to the AioContext it was before.
1597 tmp_context
= bdrv_get_aio_context(state
->old_bs
);
1598 if (aio_context
!= tmp_context
) {
1599 aio_context_release(aio_context
);
1600 aio_context_acquire(tmp_context
);
1602 ret
= bdrv_try_set_aio_context(state
->old_bs
,
1606 aio_context_release(tmp_context
);
1607 aio_context_acquire(aio_context
);
1610 bdrv_replace_node(state
->new_bs
, state
->old_bs
, &error_abort
);
1611 bdrv_unref(state
->old_bs
); /* bdrv_replace_node() ref'ed old_bs */
1613 aio_context_release(aio_context
);
1618 static void external_snapshot_clean(BlkActionState
*common
)
1620 ExternalSnapshotState
*state
=
1621 DO_UPCAST(ExternalSnapshotState
, common
, common
);
1622 AioContext
*aio_context
;
1624 if (!state
->old_bs
) {
1628 aio_context
= bdrv_get_aio_context(state
->old_bs
);
1629 aio_context_acquire(aio_context
);
1631 bdrv_drained_end(state
->old_bs
);
1632 bdrv_unref(state
->new_bs
);
1634 aio_context_release(aio_context
);
1637 typedef struct DriveBackupState
{
1638 BlkActionState common
;
1639 BlockDriverState
*bs
;
1643 static BlockJob
*do_backup_common(BackupCommon
*backup
,
1644 BlockDriverState
*bs
,
1645 BlockDriverState
*target_bs
,
1646 AioContext
*aio_context
,
1647 JobTxn
*txn
, Error
**errp
);
1649 static void drive_backup_prepare(BlkActionState
*common
, Error
**errp
)
1651 DriveBackupState
*state
= DO_UPCAST(DriveBackupState
, common
, common
);
1652 DriveBackup
*backup
;
1653 BlockDriverState
*bs
;
1654 BlockDriverState
*target_bs
;
1655 BlockDriverState
*source
= NULL
;
1656 AioContext
*aio_context
;
1657 AioContext
*old_context
;
1659 Error
*local_err
= NULL
;
1662 bool set_backing_hd
= false;
1665 assert(common
->action
->type
== TRANSACTION_ACTION_KIND_DRIVE_BACKUP
);
1666 backup
= common
->action
->u
.drive_backup
.data
;
1668 if (!backup
->has_mode
) {
1669 backup
->mode
= NEW_IMAGE_MODE_ABSOLUTE_PATHS
;
1672 bs
= bdrv_lookup_bs(backup
->device
, backup
->device
, errp
);
1678 error_setg(errp
, "Device has no medium");
1682 aio_context
= bdrv_get_aio_context(bs
);
1683 aio_context_acquire(aio_context
);
1686 /* Paired with .clean() */
1687 bdrv_drained_begin(bs
);
1689 if (!backup
->has_format
) {
1690 backup
->format
= backup
->mode
== NEW_IMAGE_MODE_EXISTING
?
1691 NULL
: (char *) bs
->drv
->format_name
;
1694 /* Early check to avoid creating target */
1695 if (bdrv_op_is_blocked(bs
, BLOCK_OP_TYPE_BACKUP_SOURCE
, errp
)) {
1699 flags
= bs
->open_flags
| BDRV_O_RDWR
;
1702 * See if we have a backing HD we can use to create our new image
1705 if (backup
->sync
== MIRROR_SYNC_MODE_TOP
) {
1707 * Backup will not replace the source by the target, so none
1708 * of the filters skipped here will be removed (in contrast to
1709 * mirror). Therefore, we can skip all of them when looking
1710 * for the first COW relationship.
1712 source
= bdrv_cow_bs(bdrv_skip_filters(bs
));
1714 backup
->sync
= MIRROR_SYNC_MODE_FULL
;
1717 if (backup
->sync
== MIRROR_SYNC_MODE_NONE
) {
1719 flags
|= BDRV_O_NO_BACKING
;
1720 set_backing_hd
= true;
1723 size
= bdrv_getlength(bs
);
1725 error_setg_errno(errp
, -size
, "bdrv_getlength failed");
1729 if (backup
->mode
!= NEW_IMAGE_MODE_EXISTING
) {
1730 assert(backup
->format
);
1732 /* Implicit filters should not appear in the filename */
1733 BlockDriverState
*explicit_backing
=
1734 bdrv_skip_implicit_filters(source
);
1736 bdrv_refresh_filename(explicit_backing
);
1737 bdrv_img_create(backup
->target
, backup
->format
,
1738 explicit_backing
->filename
,
1739 explicit_backing
->drv
->format_name
, NULL
,
1740 size
, flags
, false, &local_err
);
1742 bdrv_img_create(backup
->target
, backup
->format
, NULL
, NULL
, NULL
,
1743 size
, flags
, false, &local_err
);
1748 error_propagate(errp
, local_err
);
1752 options
= qdict_new();
1753 qdict_put_str(options
, "discard", "unmap");
1754 qdict_put_str(options
, "detect-zeroes", "unmap");
1755 if (backup
->format
) {
1756 qdict_put_str(options
, "driver", backup
->format
);
1759 target_bs
= bdrv_open(backup
->target
, NULL
, options
, flags
, errp
);
1764 /* Honor bdrv_try_set_aio_context() context acquisition requirements. */
1765 old_context
= bdrv_get_aio_context(target_bs
);
1766 aio_context_release(aio_context
);
1767 aio_context_acquire(old_context
);
1769 ret
= bdrv_try_set_aio_context(target_bs
, aio_context
, errp
);
1771 bdrv_unref(target_bs
);
1772 aio_context_release(old_context
);
1776 aio_context_release(old_context
);
1777 aio_context_acquire(aio_context
);
1779 if (set_backing_hd
) {
1780 if (bdrv_set_backing_hd(target_bs
, source
, errp
) < 0) {
1785 state
->job
= do_backup_common(qapi_DriveBackup_base(backup
),
1786 bs
, target_bs
, aio_context
,
1787 common
->block_job_txn
, errp
);
1790 bdrv_unref(target_bs
);
1792 aio_context_release(aio_context
);
1795 static void drive_backup_commit(BlkActionState
*common
)
1797 DriveBackupState
*state
= DO_UPCAST(DriveBackupState
, common
, common
);
1798 AioContext
*aio_context
;
1800 aio_context
= bdrv_get_aio_context(state
->bs
);
1801 aio_context_acquire(aio_context
);
1804 job_start(&state
->job
->job
);
1806 aio_context_release(aio_context
);
1809 static void drive_backup_abort(BlkActionState
*common
)
1811 DriveBackupState
*state
= DO_UPCAST(DriveBackupState
, common
, common
);
1814 AioContext
*aio_context
;
1816 aio_context
= bdrv_get_aio_context(state
->bs
);
1817 aio_context_acquire(aio_context
);
1819 job_cancel_sync(&state
->job
->job
, true);
1821 aio_context_release(aio_context
);
1825 static void drive_backup_clean(BlkActionState
*common
)
1827 DriveBackupState
*state
= DO_UPCAST(DriveBackupState
, common
, common
);
1828 AioContext
*aio_context
;
1834 aio_context
= bdrv_get_aio_context(state
->bs
);
1835 aio_context_acquire(aio_context
);
1837 bdrv_drained_end(state
->bs
);
1839 aio_context_release(aio_context
);
1842 typedef struct BlockdevBackupState
{
1843 BlkActionState common
;
1844 BlockDriverState
*bs
;
1846 } BlockdevBackupState
;
1848 static void blockdev_backup_prepare(BlkActionState
*common
, Error
**errp
)
1850 BlockdevBackupState
*state
= DO_UPCAST(BlockdevBackupState
, common
, common
);
1851 BlockdevBackup
*backup
;
1852 BlockDriverState
*bs
;
1853 BlockDriverState
*target_bs
;
1854 AioContext
*aio_context
;
1855 AioContext
*old_context
;
1858 assert(common
->action
->type
== TRANSACTION_ACTION_KIND_BLOCKDEV_BACKUP
);
1859 backup
= common
->action
->u
.blockdev_backup
.data
;
1861 bs
= bdrv_lookup_bs(backup
->device
, backup
->device
, errp
);
1866 target_bs
= bdrv_lookup_bs(backup
->target
, backup
->target
, errp
);
1871 /* Honor bdrv_try_set_aio_context() context acquisition requirements. */
1872 aio_context
= bdrv_get_aio_context(bs
);
1873 old_context
= bdrv_get_aio_context(target_bs
);
1874 aio_context_acquire(old_context
);
1876 ret
= bdrv_try_set_aio_context(target_bs
, aio_context
, errp
);
1878 aio_context_release(old_context
);
1882 aio_context_release(old_context
);
1883 aio_context_acquire(aio_context
);
1886 /* Paired with .clean() */
1887 bdrv_drained_begin(state
->bs
);
1889 state
->job
= do_backup_common(qapi_BlockdevBackup_base(backup
),
1890 bs
, target_bs
, aio_context
,
1891 common
->block_job_txn
, errp
);
1893 aio_context_release(aio_context
);
1896 static void blockdev_backup_commit(BlkActionState
*common
)
1898 BlockdevBackupState
*state
= DO_UPCAST(BlockdevBackupState
, common
, common
);
1899 AioContext
*aio_context
;
1901 aio_context
= bdrv_get_aio_context(state
->bs
);
1902 aio_context_acquire(aio_context
);
1905 job_start(&state
->job
->job
);
1907 aio_context_release(aio_context
);
1910 static void blockdev_backup_abort(BlkActionState
*common
)
1912 BlockdevBackupState
*state
= DO_UPCAST(BlockdevBackupState
, common
, common
);
1915 AioContext
*aio_context
;
1917 aio_context
= bdrv_get_aio_context(state
->bs
);
1918 aio_context_acquire(aio_context
);
1920 job_cancel_sync(&state
->job
->job
, true);
1922 aio_context_release(aio_context
);
1926 static void blockdev_backup_clean(BlkActionState
*common
)
1928 BlockdevBackupState
*state
= DO_UPCAST(BlockdevBackupState
, common
, common
);
1929 AioContext
*aio_context
;
1935 aio_context
= bdrv_get_aio_context(state
->bs
);
1936 aio_context_acquire(aio_context
);
1938 bdrv_drained_end(state
->bs
);
1940 aio_context_release(aio_context
);
1943 typedef struct BlockDirtyBitmapState
{
1944 BlkActionState common
;
1945 BdrvDirtyBitmap
*bitmap
;
1946 BlockDriverState
*bs
;
1950 } BlockDirtyBitmapState
;
1952 static void block_dirty_bitmap_add_prepare(BlkActionState
*common
,
1955 Error
*local_err
= NULL
;
1956 BlockDirtyBitmapAdd
*action
;
1957 BlockDirtyBitmapState
*state
= DO_UPCAST(BlockDirtyBitmapState
,
1960 if (action_check_completion_mode(common
, errp
) < 0) {
1964 action
= common
->action
->u
.block_dirty_bitmap_add
.data
;
1965 /* AIO context taken and released within qmp_block_dirty_bitmap_add */
1966 qmp_block_dirty_bitmap_add(action
->node
, action
->name
,
1967 action
->has_granularity
, action
->granularity
,
1968 action
->has_persistent
, action
->persistent
,
1969 action
->has_disabled
, action
->disabled
,
1973 state
->prepared
= true;
1975 error_propagate(errp
, local_err
);
1979 static void block_dirty_bitmap_add_abort(BlkActionState
*common
)
1981 BlockDirtyBitmapAdd
*action
;
1982 BlockDirtyBitmapState
*state
= DO_UPCAST(BlockDirtyBitmapState
,
1985 action
= common
->action
->u
.block_dirty_bitmap_add
.data
;
1986 /* Should not be able to fail: IF the bitmap was added via .prepare(),
1987 * then the node reference and bitmap name must have been valid.
1989 if (state
->prepared
) {
1990 qmp_block_dirty_bitmap_remove(action
->node
, action
->name
, &error_abort
);
1994 static void block_dirty_bitmap_clear_prepare(BlkActionState
*common
,
1997 BlockDirtyBitmapState
*state
= DO_UPCAST(BlockDirtyBitmapState
,
1999 BlockDirtyBitmap
*action
;
2001 if (action_check_completion_mode(common
, errp
) < 0) {
2005 action
= common
->action
->u
.block_dirty_bitmap_clear
.data
;
2006 state
->bitmap
= block_dirty_bitmap_lookup(action
->node
,
2010 if (!state
->bitmap
) {
2014 if (bdrv_dirty_bitmap_check(state
->bitmap
, BDRV_BITMAP_DEFAULT
, errp
)) {
2018 bdrv_clear_dirty_bitmap(state
->bitmap
, &state
->backup
);
2021 static void block_dirty_bitmap_restore(BlkActionState
*common
)
2023 BlockDirtyBitmapState
*state
= DO_UPCAST(BlockDirtyBitmapState
,
2026 if (state
->backup
) {
2027 bdrv_restore_dirty_bitmap(state
->bitmap
, state
->backup
);
2031 static void block_dirty_bitmap_free_backup(BlkActionState
*common
)
2033 BlockDirtyBitmapState
*state
= DO_UPCAST(BlockDirtyBitmapState
,
2036 hbitmap_free(state
->backup
);
2039 static void block_dirty_bitmap_enable_prepare(BlkActionState
*common
,
2042 BlockDirtyBitmap
*action
;
2043 BlockDirtyBitmapState
*state
= DO_UPCAST(BlockDirtyBitmapState
,
2046 if (action_check_completion_mode(common
, errp
) < 0) {
2050 action
= common
->action
->u
.block_dirty_bitmap_enable
.data
;
2051 state
->bitmap
= block_dirty_bitmap_lookup(action
->node
,
2055 if (!state
->bitmap
) {
2059 if (bdrv_dirty_bitmap_check(state
->bitmap
, BDRV_BITMAP_ALLOW_RO
, errp
)) {
2063 state
->was_enabled
= bdrv_dirty_bitmap_enabled(state
->bitmap
);
2064 bdrv_enable_dirty_bitmap(state
->bitmap
);
2067 static void block_dirty_bitmap_enable_abort(BlkActionState
*common
)
2069 BlockDirtyBitmapState
*state
= DO_UPCAST(BlockDirtyBitmapState
,
2072 if (!state
->was_enabled
) {
2073 bdrv_disable_dirty_bitmap(state
->bitmap
);
2077 static void block_dirty_bitmap_disable_prepare(BlkActionState
*common
,
2080 BlockDirtyBitmap
*action
;
2081 BlockDirtyBitmapState
*state
= DO_UPCAST(BlockDirtyBitmapState
,
2084 if (action_check_completion_mode(common
, errp
) < 0) {
2088 action
= common
->action
->u
.block_dirty_bitmap_disable
.data
;
2089 state
->bitmap
= block_dirty_bitmap_lookup(action
->node
,
2093 if (!state
->bitmap
) {
2097 if (bdrv_dirty_bitmap_check(state
->bitmap
, BDRV_BITMAP_ALLOW_RO
, errp
)) {
2101 state
->was_enabled
= bdrv_dirty_bitmap_enabled(state
->bitmap
);
2102 bdrv_disable_dirty_bitmap(state
->bitmap
);
2105 static void block_dirty_bitmap_disable_abort(BlkActionState
*common
)
2107 BlockDirtyBitmapState
*state
= DO_UPCAST(BlockDirtyBitmapState
,
2110 if (state
->was_enabled
) {
2111 bdrv_enable_dirty_bitmap(state
->bitmap
);
2115 static void block_dirty_bitmap_merge_prepare(BlkActionState
*common
,
2118 BlockDirtyBitmapMerge
*action
;
2119 BlockDirtyBitmapState
*state
= DO_UPCAST(BlockDirtyBitmapState
,
2122 if (action_check_completion_mode(common
, errp
) < 0) {
2126 action
= common
->action
->u
.block_dirty_bitmap_merge
.data
;
2128 state
->bitmap
= block_dirty_bitmap_merge(action
->node
, action
->target
,
2129 action
->bitmaps
, &state
->backup
,
2133 static void block_dirty_bitmap_remove_prepare(BlkActionState
*common
,
2136 BlockDirtyBitmap
*action
;
2137 BlockDirtyBitmapState
*state
= DO_UPCAST(BlockDirtyBitmapState
,
2140 if (action_check_completion_mode(common
, errp
) < 0) {
2144 action
= common
->action
->u
.block_dirty_bitmap_remove
.data
;
2146 state
->bitmap
= block_dirty_bitmap_remove(action
->node
, action
->name
,
2147 false, &state
->bs
, errp
);
2148 if (state
->bitmap
) {
2149 bdrv_dirty_bitmap_skip_store(state
->bitmap
, true);
2150 bdrv_dirty_bitmap_set_busy(state
->bitmap
, true);
2154 static void block_dirty_bitmap_remove_abort(BlkActionState
*common
)
2156 BlockDirtyBitmapState
*state
= DO_UPCAST(BlockDirtyBitmapState
,
2159 if (state
->bitmap
) {
2160 bdrv_dirty_bitmap_skip_store(state
->bitmap
, false);
2161 bdrv_dirty_bitmap_set_busy(state
->bitmap
, false);
2165 static void block_dirty_bitmap_remove_commit(BlkActionState
*common
)
2167 BlockDirtyBitmapState
*state
= DO_UPCAST(BlockDirtyBitmapState
,
2170 bdrv_dirty_bitmap_set_busy(state
->bitmap
, false);
2171 bdrv_release_dirty_bitmap(state
->bitmap
);
2174 static void abort_prepare(BlkActionState
*common
, Error
**errp
)
2176 error_setg(errp
, "Transaction aborted using Abort action");
2179 static void abort_commit(BlkActionState
*common
)
2181 g_assert_not_reached(); /* this action never succeeds */
2184 static const BlkActionOps actions
[] = {
2185 [TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT
] = {
2186 .instance_size
= sizeof(ExternalSnapshotState
),
2187 .prepare
= external_snapshot_prepare
,
2188 .commit
= external_snapshot_commit
,
2189 .abort
= external_snapshot_abort
,
2190 .clean
= external_snapshot_clean
,
2192 [TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_SYNC
] = {
2193 .instance_size
= sizeof(ExternalSnapshotState
),
2194 .prepare
= external_snapshot_prepare
,
2195 .commit
= external_snapshot_commit
,
2196 .abort
= external_snapshot_abort
,
2197 .clean
= external_snapshot_clean
,
2199 [TRANSACTION_ACTION_KIND_DRIVE_BACKUP
] = {
2200 .instance_size
= sizeof(DriveBackupState
),
2201 .prepare
= drive_backup_prepare
,
2202 .commit
= drive_backup_commit
,
2203 .abort
= drive_backup_abort
,
2204 .clean
= drive_backup_clean
,
2206 [TRANSACTION_ACTION_KIND_BLOCKDEV_BACKUP
] = {
2207 .instance_size
= sizeof(BlockdevBackupState
),
2208 .prepare
= blockdev_backup_prepare
,
2209 .commit
= blockdev_backup_commit
,
2210 .abort
= blockdev_backup_abort
,
2211 .clean
= blockdev_backup_clean
,
2213 [TRANSACTION_ACTION_KIND_ABORT
] = {
2214 .instance_size
= sizeof(BlkActionState
),
2215 .prepare
= abort_prepare
,
2216 .commit
= abort_commit
,
2218 [TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_INTERNAL_SYNC
] = {
2219 .instance_size
= sizeof(InternalSnapshotState
),
2220 .prepare
= internal_snapshot_prepare
,
2221 .abort
= internal_snapshot_abort
,
2222 .clean
= internal_snapshot_clean
,
2224 [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_ADD
] = {
2225 .instance_size
= sizeof(BlockDirtyBitmapState
),
2226 .prepare
= block_dirty_bitmap_add_prepare
,
2227 .abort
= block_dirty_bitmap_add_abort
,
2229 [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_CLEAR
] = {
2230 .instance_size
= sizeof(BlockDirtyBitmapState
),
2231 .prepare
= block_dirty_bitmap_clear_prepare
,
2232 .commit
= block_dirty_bitmap_free_backup
,
2233 .abort
= block_dirty_bitmap_restore
,
2235 [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_ENABLE
] = {
2236 .instance_size
= sizeof(BlockDirtyBitmapState
),
2237 .prepare
= block_dirty_bitmap_enable_prepare
,
2238 .abort
= block_dirty_bitmap_enable_abort
,
2240 [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_DISABLE
] = {
2241 .instance_size
= sizeof(BlockDirtyBitmapState
),
2242 .prepare
= block_dirty_bitmap_disable_prepare
,
2243 .abort
= block_dirty_bitmap_disable_abort
,
2245 [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_MERGE
] = {
2246 .instance_size
= sizeof(BlockDirtyBitmapState
),
2247 .prepare
= block_dirty_bitmap_merge_prepare
,
2248 .commit
= block_dirty_bitmap_free_backup
,
2249 .abort
= block_dirty_bitmap_restore
,
2251 [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_REMOVE
] = {
2252 .instance_size
= sizeof(BlockDirtyBitmapState
),
2253 .prepare
= block_dirty_bitmap_remove_prepare
,
2254 .commit
= block_dirty_bitmap_remove_commit
,
2255 .abort
= block_dirty_bitmap_remove_abort
,
2257 /* Where are transactions for MIRROR, COMMIT and STREAM?
2258 * Although these blockjobs use transaction callbacks like the backup job,
2259 * these jobs do not necessarily adhere to transaction semantics.
2260 * These jobs may not fully undo all of their actions on abort, nor do they
2261 * necessarily work in transactions with more than one job in them.
2266 * Allocate a TransactionProperties structure if necessary, and fill
2267 * that structure with desired defaults if they are unset.
2269 static TransactionProperties
*get_transaction_properties(
2270 TransactionProperties
*props
)
2273 props
= g_new0(TransactionProperties
, 1);
2276 if (!props
->has_completion_mode
) {
2277 props
->has_completion_mode
= true;
2278 props
->completion_mode
= ACTION_COMPLETION_MODE_INDIVIDUAL
;
2285 * 'Atomic' group operations. The operations are performed as a set, and if
2286 * any fail then we roll back all operations in the group.
2288 void qmp_transaction(TransactionActionList
*dev_list
,
2290 struct TransactionProperties
*props
,
2293 TransactionActionList
*dev_entry
= dev_list
;
2294 JobTxn
*block_job_txn
= NULL
;
2295 BlkActionState
*state
, *next
;
2296 Error
*local_err
= NULL
;
2298 QTAILQ_HEAD(, BlkActionState
) snap_bdrv_states
;
2299 QTAILQ_INIT(&snap_bdrv_states
);
2301 /* Does this transaction get canceled as a group on failure?
2302 * If not, we don't really need to make a JobTxn.
2304 props
= get_transaction_properties(props
);
2305 if (props
->completion_mode
!= ACTION_COMPLETION_MODE_INDIVIDUAL
) {
2306 block_job_txn
= job_txn_new();
2309 /* drain all i/o before any operations */
2312 /* We don't do anything in this loop that commits us to the operations */
2313 while (NULL
!= dev_entry
) {
2314 TransactionAction
*dev_info
= NULL
;
2315 const BlkActionOps
*ops
;
2317 dev_info
= dev_entry
->value
;
2318 dev_entry
= dev_entry
->next
;
2320 assert(dev_info
->type
< ARRAY_SIZE(actions
));
2322 ops
= &actions
[dev_info
->type
];
2323 assert(ops
->instance_size
> 0);
2325 state
= g_malloc0(ops
->instance_size
);
2327 state
->action
= dev_info
;
2328 state
->block_job_txn
= block_job_txn
;
2329 state
->txn_props
= props
;
2330 QTAILQ_INSERT_TAIL(&snap_bdrv_states
, state
, entry
);
2332 state
->ops
->prepare(state
, &local_err
);
2334 error_propagate(errp
, local_err
);
2335 goto delete_and_fail
;
2339 QTAILQ_FOREACH(state
, &snap_bdrv_states
, entry
) {
2340 if (state
->ops
->commit
) {
2341 state
->ops
->commit(state
);
2349 /* failure, and it is all-or-none; roll back all operations */
2350 QTAILQ_FOREACH_REVERSE(state
, &snap_bdrv_states
, entry
) {
2351 if (state
->ops
->abort
) {
2352 state
->ops
->abort(state
);
2356 QTAILQ_FOREACH_SAFE(state
, &snap_bdrv_states
, entry
, next
) {
2357 if (state
->ops
->clean
) {
2358 state
->ops
->clean(state
);
2363 qapi_free_TransactionProperties(props
);
2365 job_txn_unref(block_job_txn
);
2368 BlockDirtyBitmapSha256
*qmp_x_debug_block_dirty_bitmap_sha256(const char *node
,
2372 BdrvDirtyBitmap
*bitmap
;
2373 BlockDriverState
*bs
;
2374 BlockDirtyBitmapSha256
*ret
= NULL
;
2377 bitmap
= block_dirty_bitmap_lookup(node
, name
, &bs
, errp
);
2378 if (!bitmap
|| !bs
) {
2382 sha256
= bdrv_dirty_bitmap_sha256(bitmap
, errp
);
2383 if (sha256
== NULL
) {
2387 ret
= g_new(BlockDirtyBitmapSha256
, 1);
2388 ret
->sha256
= sha256
;
2393 void coroutine_fn
qmp_block_resize(bool has_device
, const char *device
,
2394 bool has_node_name
, const char *node_name
,
2395 int64_t size
, Error
**errp
)
2397 Error
*local_err
= NULL
;
2399 BlockDriverState
*bs
;
2400 AioContext
*old_ctx
;
2402 bs
= bdrv_lookup_bs(has_device
? device
: NULL
,
2403 has_node_name
? node_name
: NULL
,
2406 error_propagate(errp
, local_err
);
2411 error_setg(errp
, QERR_INVALID_PARAMETER_VALUE
, "size", "a >0 size");
2415 if (bdrv_op_is_blocked(bs
, BLOCK_OP_TYPE_RESIZE
, NULL
)) {
2416 error_setg(errp
, QERR_DEVICE_IN_USE
, device
);
2420 blk
= blk_new_with_bs(bs
, BLK_PERM_RESIZE
, BLK_PERM_ALL
, errp
);
2426 bdrv_drained_begin(bs
);
2429 old_ctx
= bdrv_co_enter(bs
);
2430 blk_truncate(blk
, size
, false, PREALLOC_MODE_OFF
, 0, errp
);
2431 bdrv_co_leave(bs
, old_ctx
);
2434 bdrv_drained_end(bs
);
2439 void qmp_block_stream(bool has_job_id
, const char *job_id
, const char *device
,
2440 bool has_base
, const char *base
,
2441 bool has_base_node
, const char *base_node
,
2442 bool has_backing_file
, const char *backing_file
,
2443 bool has_bottom
, const char *bottom
,
2444 bool has_speed
, int64_t speed
,
2445 bool has_on_error
, BlockdevOnError on_error
,
2446 bool has_filter_node_name
, const char *filter_node_name
,
2447 bool has_auto_finalize
, bool auto_finalize
,
2448 bool has_auto_dismiss
, bool auto_dismiss
,
2451 BlockDriverState
*bs
, *iter
, *iter_end
;
2452 BlockDriverState
*base_bs
= NULL
;
2453 BlockDriverState
*bottom_bs
= NULL
;
2454 AioContext
*aio_context
;
2455 Error
*local_err
= NULL
;
2456 int job_flags
= JOB_DEFAULT
;
2458 if (has_base
&& has_base_node
) {
2459 error_setg(errp
, "'base' and 'base-node' cannot be specified "
2460 "at the same time");
2464 if (has_base
&& has_bottom
) {
2465 error_setg(errp
, "'base' and 'bottom' cannot be specified "
2466 "at the same time");
2470 if (has_bottom
&& has_base_node
) {
2471 error_setg(errp
, "'bottom' and 'base-node' cannot be specified "
2472 "at the same time");
2476 if (!has_on_error
) {
2477 on_error
= BLOCKDEV_ON_ERROR_REPORT
;
2480 bs
= bdrv_lookup_bs(device
, device
, errp
);
2485 aio_context
= bdrv_get_aio_context(bs
);
2486 aio_context_acquire(aio_context
);
2489 base_bs
= bdrv_find_backing_image(bs
, base
);
2490 if (base_bs
== NULL
) {
2491 error_setg(errp
, "Can't find '%s' in the backing chain", base
);
2494 assert(bdrv_get_aio_context(base_bs
) == aio_context
);
2497 if (has_base_node
) {
2498 base_bs
= bdrv_lookup_bs(NULL
, base_node
, errp
);
2502 if (bs
== base_bs
|| !bdrv_chain_contains(bs
, base_bs
)) {
2503 error_setg(errp
, "Node '%s' is not a backing image of '%s'",
2507 assert(bdrv_get_aio_context(base_bs
) == aio_context
);
2508 bdrv_refresh_filename(base_bs
);
2512 bottom_bs
= bdrv_lookup_bs(NULL
, bottom
, errp
);
2516 if (!bottom_bs
->drv
) {
2517 error_setg(errp
, "Node '%s' is not open", bottom
);
2520 if (bottom_bs
->drv
->is_filter
) {
2521 error_setg(errp
, "Node '%s' is a filter, use a non-filter node "
2522 "as 'bottom'", bottom
);
2525 if (!bdrv_chain_contains(bs
, bottom_bs
)) {
2526 error_setg(errp
, "Node '%s' is not in a chain starting from '%s'",
2530 assert(bdrv_get_aio_context(bottom_bs
) == aio_context
);
2534 * Check for op blockers in the whole chain between bs and base (or bottom)
2536 iter_end
= has_bottom
? bdrv_filter_or_cow_bs(bottom_bs
) : base_bs
;
2537 for (iter
= bs
; iter
&& iter
!= iter_end
;
2538 iter
= bdrv_filter_or_cow_bs(iter
))
2540 if (bdrv_op_is_blocked(iter
, BLOCK_OP_TYPE_STREAM
, errp
)) {
2545 /* if we are streaming the entire chain, the result will have no backing
2546 * file, and specifying one is therefore an error */
2547 if (base_bs
== NULL
&& has_backing_file
) {
2548 error_setg(errp
, "backing file specified, but streaming the "
2553 if (has_auto_finalize
&& !auto_finalize
) {
2554 job_flags
|= JOB_MANUAL_FINALIZE
;
2556 if (has_auto_dismiss
&& !auto_dismiss
) {
2557 job_flags
|= JOB_MANUAL_DISMISS
;
2560 stream_start(has_job_id
? job_id
: NULL
, bs
, base_bs
, backing_file
,
2561 bottom_bs
, job_flags
, has_speed
? speed
: 0, on_error
,
2562 filter_node_name
, &local_err
);
2564 error_propagate(errp
, local_err
);
2568 trace_qmp_block_stream(bs
);
2571 aio_context_release(aio_context
);
2574 void qmp_block_commit(bool has_job_id
, const char *job_id
, const char *device
,
2575 bool has_base_node
, const char *base_node
,
2576 bool has_base
, const char *base
,
2577 bool has_top_node
, const char *top_node
,
2578 bool has_top
, const char *top
,
2579 bool has_backing_file
, const char *backing_file
,
2580 bool has_speed
, int64_t speed
,
2581 bool has_on_error
, BlockdevOnError on_error
,
2582 bool has_filter_node_name
, const char *filter_node_name
,
2583 bool has_auto_finalize
, bool auto_finalize
,
2584 bool has_auto_dismiss
, bool auto_dismiss
,
2587 BlockDriverState
*bs
;
2588 BlockDriverState
*iter
;
2589 BlockDriverState
*base_bs
, *top_bs
;
2590 AioContext
*aio_context
;
2591 Error
*local_err
= NULL
;
2592 int job_flags
= JOB_DEFAULT
;
2593 uint64_t top_perm
, top_shared
;
2598 if (!has_on_error
) {
2599 on_error
= BLOCKDEV_ON_ERROR_REPORT
;
2601 if (!has_filter_node_name
) {
2602 filter_node_name
= NULL
;
2604 if (has_auto_finalize
&& !auto_finalize
) {
2605 job_flags
|= JOB_MANUAL_FINALIZE
;
2607 if (has_auto_dismiss
&& !auto_dismiss
) {
2608 job_flags
|= JOB_MANUAL_DISMISS
;
2612 * libvirt relies on the DeviceNotFound error class in order to probe for
2613 * live commit feature versions; for this to work, we must make sure to
2614 * perform the device lookup before any generic errors that may occur in a
2615 * scenario in which all optional arguments are omitted. */
2616 bs
= qmp_get_root_bs(device
, &local_err
);
2618 bs
= bdrv_lookup_bs(device
, device
, NULL
);
2620 error_free(local_err
);
2621 error_set(errp
, ERROR_CLASS_DEVICE_NOT_FOUND
,
2622 "Device '%s' not found", device
);
2624 error_propagate(errp
, local_err
);
2629 aio_context
= bdrv_get_aio_context(bs
);
2630 aio_context_acquire(aio_context
);
2632 if (bdrv_op_is_blocked(bs
, BLOCK_OP_TYPE_COMMIT_SOURCE
, errp
)) {
2636 /* default top_bs is the active layer */
2639 if (has_top_node
&& has_top
) {
2640 error_setg(errp
, "'top-node' and 'top' are mutually exclusive");
2642 } else if (has_top_node
) {
2643 top_bs
= bdrv_lookup_bs(NULL
, top_node
, errp
);
2644 if (top_bs
== NULL
) {
2647 if (!bdrv_chain_contains(bs
, top_bs
)) {
2648 error_setg(errp
, "'%s' is not in this backing file chain",
2652 } else if (has_top
&& top
) {
2653 /* This strcmp() is just a shortcut, there is no need to
2654 * refresh @bs's filename. If it mismatches,
2655 * bdrv_find_backing_image() will do the refresh and may still
2657 if (strcmp(bs
->filename
, top
) != 0) {
2658 top_bs
= bdrv_find_backing_image(bs
, top
);
2662 if (top_bs
== NULL
) {
2663 error_setg(errp
, "Top image file %s not found", top
? top
: "NULL");
2667 assert(bdrv_get_aio_context(top_bs
) == aio_context
);
2669 if (has_base_node
&& has_base
) {
2670 error_setg(errp
, "'base-node' and 'base' are mutually exclusive");
2672 } else if (has_base_node
) {
2673 base_bs
= bdrv_lookup_bs(NULL
, base_node
, errp
);
2674 if (base_bs
== NULL
) {
2677 if (!bdrv_chain_contains(top_bs
, base_bs
)) {
2678 error_setg(errp
, "'%s' is not in this backing file chain",
2682 } else if (has_base
&& base
) {
2683 base_bs
= bdrv_find_backing_image(top_bs
, base
);
2684 if (base_bs
== NULL
) {
2685 error_setg(errp
, "Can't find '%s' in the backing chain", base
);
2689 base_bs
= bdrv_find_base(top_bs
);
2690 if (base_bs
== NULL
) {
2691 error_setg(errp
, "There is no backimg image");
2696 assert(bdrv_get_aio_context(base_bs
) == aio_context
);
2698 for (iter
= top_bs
; iter
!= bdrv_filter_or_cow_bs(base_bs
);
2699 iter
= bdrv_filter_or_cow_bs(iter
))
2701 if (bdrv_op_is_blocked(iter
, BLOCK_OP_TYPE_COMMIT_TARGET
, errp
)) {
2706 /* Do not allow attempts to commit an image into itself */
2707 if (top_bs
== base_bs
) {
2708 error_setg(errp
, "cannot commit an image into itself");
2713 * Active commit is required if and only if someone has taken a
2714 * WRITE permission on the top node. Historically, we have always
2715 * used active commit for top nodes, so continue that practice
2716 * lest we possibly break clients that rely on this behavior, e.g.
2717 * to later attach this node to a writing parent.
2718 * (Active commit is never really wrong.)
2720 bdrv_get_cumulative_perm(top_bs
, &top_perm
, &top_shared
);
2721 if (top_perm
& BLK_PERM_WRITE
||
2722 bdrv_skip_filters(top_bs
) == bdrv_skip_filters(bs
))
2724 if (has_backing_file
) {
2725 if (bdrv_skip_filters(top_bs
) == bdrv_skip_filters(bs
)) {
2726 error_setg(errp
, "'backing-file' specified,"
2727 " but 'top' is the active layer");
2729 error_setg(errp
, "'backing-file' specified, but 'top' has a "
2736 * Emulate here what block_job_create() does, because it
2737 * is possible that @bs != @top_bs (the block job should
2738 * be named after @bs, even if @top_bs is the actual
2741 job_id
= bdrv_get_device_name(bs
);
2743 commit_active_start(job_id
, top_bs
, base_bs
, job_flags
, speed
, on_error
,
2744 filter_node_name
, NULL
, NULL
, false, &local_err
);
2746 BlockDriverState
*overlay_bs
= bdrv_find_overlay(bs
, top_bs
);
2747 if (bdrv_op_is_blocked(overlay_bs
, BLOCK_OP_TYPE_COMMIT_TARGET
, errp
)) {
2750 commit_start(has_job_id
? job_id
: NULL
, bs
, base_bs
, top_bs
, job_flags
,
2751 speed
, on_error
, has_backing_file
? backing_file
: NULL
,
2752 filter_node_name
, &local_err
);
2754 if (local_err
!= NULL
) {
2755 error_propagate(errp
, local_err
);
2760 aio_context_release(aio_context
);
2763 /* Common QMP interface for drive-backup and blockdev-backup */
2764 static BlockJob
*do_backup_common(BackupCommon
*backup
,
2765 BlockDriverState
*bs
,
2766 BlockDriverState
*target_bs
,
2767 AioContext
*aio_context
,
2768 JobTxn
*txn
, Error
**errp
)
2770 BlockJob
*job
= NULL
;
2771 BdrvDirtyBitmap
*bmap
= NULL
;
2772 BackupPerf perf
= { .max_workers
= 64 };
2773 int job_flags
= JOB_DEFAULT
;
2775 if (!backup
->has_speed
) {
2778 if (!backup
->has_on_source_error
) {
2779 backup
->on_source_error
= BLOCKDEV_ON_ERROR_REPORT
;
2781 if (!backup
->has_on_target_error
) {
2782 backup
->on_target_error
= BLOCKDEV_ON_ERROR_REPORT
;
2784 if (!backup
->has_job_id
) {
2785 backup
->job_id
= NULL
;
2787 if (!backup
->has_auto_finalize
) {
2788 backup
->auto_finalize
= true;
2790 if (!backup
->has_auto_dismiss
) {
2791 backup
->auto_dismiss
= true;
2793 if (!backup
->has_compress
) {
2794 backup
->compress
= false;
2797 if (backup
->x_perf
) {
2798 if (backup
->x_perf
->has_use_copy_range
) {
2799 perf
.use_copy_range
= backup
->x_perf
->use_copy_range
;
2801 if (backup
->x_perf
->has_max_workers
) {
2802 perf
.max_workers
= backup
->x_perf
->max_workers
;
2804 if (backup
->x_perf
->has_max_chunk
) {
2805 perf
.max_chunk
= backup
->x_perf
->max_chunk
;
2809 if ((backup
->sync
== MIRROR_SYNC_MODE_BITMAP
) ||
2810 (backup
->sync
== MIRROR_SYNC_MODE_INCREMENTAL
)) {
2811 /* done before desugaring 'incremental' to print the right message */
2812 if (!backup
->has_bitmap
) {
2813 error_setg(errp
, "must provide a valid bitmap name for "
2814 "'%s' sync mode", MirrorSyncMode_str(backup
->sync
));
2819 if (backup
->sync
== MIRROR_SYNC_MODE_INCREMENTAL
) {
2820 if (backup
->has_bitmap_mode
&&
2821 backup
->bitmap_mode
!= BITMAP_SYNC_MODE_ON_SUCCESS
) {
2822 error_setg(errp
, "Bitmap sync mode must be '%s' "
2823 "when using sync mode '%s'",
2824 BitmapSyncMode_str(BITMAP_SYNC_MODE_ON_SUCCESS
),
2825 MirrorSyncMode_str(backup
->sync
));
2828 backup
->has_bitmap_mode
= true;
2829 backup
->sync
= MIRROR_SYNC_MODE_BITMAP
;
2830 backup
->bitmap_mode
= BITMAP_SYNC_MODE_ON_SUCCESS
;
2833 if (backup
->has_bitmap
) {
2834 bmap
= bdrv_find_dirty_bitmap(bs
, backup
->bitmap
);
2836 error_setg(errp
, "Bitmap '%s' could not be found", backup
->bitmap
);
2839 if (!backup
->has_bitmap_mode
) {
2840 error_setg(errp
, "Bitmap sync mode must be given "
2841 "when providing a bitmap");
2844 if (bdrv_dirty_bitmap_check(bmap
, BDRV_BITMAP_ALLOW_RO
, errp
)) {
2848 /* This does not produce a useful bitmap artifact: */
2849 if (backup
->sync
== MIRROR_SYNC_MODE_NONE
) {
2850 error_setg(errp
, "sync mode '%s' does not produce meaningful bitmap"
2851 " outputs", MirrorSyncMode_str(backup
->sync
));
2855 /* If the bitmap isn't used for input or output, this is useless: */
2856 if (backup
->bitmap_mode
== BITMAP_SYNC_MODE_NEVER
&&
2857 backup
->sync
!= MIRROR_SYNC_MODE_BITMAP
) {
2858 error_setg(errp
, "Bitmap sync mode '%s' has no meaningful effect"
2859 " when combined with sync mode '%s'",
2860 BitmapSyncMode_str(backup
->bitmap_mode
),
2861 MirrorSyncMode_str(backup
->sync
));
2866 if (!backup
->has_bitmap
&& backup
->has_bitmap_mode
) {
2867 error_setg(errp
, "Cannot specify bitmap sync mode without a bitmap");
2871 if (!backup
->auto_finalize
) {
2872 job_flags
|= JOB_MANUAL_FINALIZE
;
2874 if (!backup
->auto_dismiss
) {
2875 job_flags
|= JOB_MANUAL_DISMISS
;
2878 job
= backup_job_create(backup
->job_id
, bs
, target_bs
, backup
->speed
,
2879 backup
->sync
, bmap
, backup
->bitmap_mode
,
2881 backup
->filter_node_name
,
2883 backup
->on_source_error
,
2884 backup
->on_target_error
,
2885 job_flags
, NULL
, NULL
, txn
, errp
);
2889 void qmp_drive_backup(DriveBackup
*backup
, Error
**errp
)
2891 TransactionAction action
= {
2892 .type
= TRANSACTION_ACTION_KIND_DRIVE_BACKUP
,
2893 .u
.drive_backup
.data
= backup
,
2895 blockdev_do_action(&action
, errp
);
2898 BlockDeviceInfoList
*qmp_query_named_block_nodes(bool has_flat
,
2902 bool return_flat
= has_flat
&& flat
;
2904 return bdrv_named_nodes_list(return_flat
, errp
);
2907 XDbgBlockGraph
*qmp_x_debug_query_block_graph(Error
**errp
)
2909 return bdrv_get_xdbg_block_graph(errp
);
2912 void qmp_blockdev_backup(BlockdevBackup
*backup
, Error
**errp
)
2914 TransactionAction action
= {
2915 .type
= TRANSACTION_ACTION_KIND_BLOCKDEV_BACKUP
,
2916 .u
.blockdev_backup
.data
= backup
,
2918 blockdev_do_action(&action
, errp
);
2921 /* Parameter check and block job starting for drive mirroring.
2922 * Caller should hold @device and @target's aio context (must be the same).
2924 static void blockdev_mirror_common(const char *job_id
, BlockDriverState
*bs
,
2925 BlockDriverState
*target
,
2926 bool has_replaces
, const char *replaces
,
2927 enum MirrorSyncMode sync
,
2928 BlockMirrorBackingMode backing_mode
,
2930 bool has_speed
, int64_t speed
,
2931 bool has_granularity
, uint32_t granularity
,
2932 bool has_buf_size
, int64_t buf_size
,
2933 bool has_on_source_error
,
2934 BlockdevOnError on_source_error
,
2935 bool has_on_target_error
,
2936 BlockdevOnError on_target_error
,
2937 bool has_unmap
, bool unmap
,
2938 bool has_filter_node_name
,
2939 const char *filter_node_name
,
2940 bool has_copy_mode
, MirrorCopyMode copy_mode
,
2941 bool has_auto_finalize
, bool auto_finalize
,
2942 bool has_auto_dismiss
, bool auto_dismiss
,
2945 BlockDriverState
*unfiltered_bs
;
2946 int job_flags
= JOB_DEFAULT
;
2951 if (!has_on_source_error
) {
2952 on_source_error
= BLOCKDEV_ON_ERROR_REPORT
;
2954 if (!has_on_target_error
) {
2955 on_target_error
= BLOCKDEV_ON_ERROR_REPORT
;
2957 if (!has_granularity
) {
2960 if (!has_buf_size
) {
2966 if (!has_filter_node_name
) {
2967 filter_node_name
= NULL
;
2969 if (!has_copy_mode
) {
2970 copy_mode
= MIRROR_COPY_MODE_BACKGROUND
;
2972 if (has_auto_finalize
&& !auto_finalize
) {
2973 job_flags
|= JOB_MANUAL_FINALIZE
;
2975 if (has_auto_dismiss
&& !auto_dismiss
) {
2976 job_flags
|= JOB_MANUAL_DISMISS
;
2979 if (granularity
!= 0 && (granularity
< 512 || granularity
> 1048576 * 64)) {
2980 error_setg(errp
, QERR_INVALID_PARAMETER_VALUE
, "granularity",
2981 "a value in range [512B, 64MB]");
2984 if (granularity
& (granularity
- 1)) {
2985 error_setg(errp
, QERR_INVALID_PARAMETER_VALUE
, "granularity",
2990 if (bdrv_op_is_blocked(bs
, BLOCK_OP_TYPE_MIRROR_SOURCE
, errp
)) {
2993 if (bdrv_op_is_blocked(target
, BLOCK_OP_TYPE_MIRROR_TARGET
, errp
)) {
2997 if (!bdrv_backing_chain_next(bs
) && sync
== MIRROR_SYNC_MODE_TOP
) {
2998 sync
= MIRROR_SYNC_MODE_FULL
;
3001 if (!has_replaces
) {
3002 /* We want to mirror from @bs, but keep implicit filters on top */
3003 unfiltered_bs
= bdrv_skip_implicit_filters(bs
);
3004 if (unfiltered_bs
!= bs
) {
3005 replaces
= unfiltered_bs
->node_name
;
3006 has_replaces
= true;
3011 BlockDriverState
*to_replace_bs
;
3012 AioContext
*replace_aio_context
;
3013 int64_t bs_size
, replace_size
;
3015 bs_size
= bdrv_getlength(bs
);
3017 error_setg_errno(errp
, -bs_size
, "Failed to query device's size");
3021 to_replace_bs
= check_to_replace_node(bs
, replaces
, errp
);
3022 if (!to_replace_bs
) {
3026 replace_aio_context
= bdrv_get_aio_context(to_replace_bs
);
3027 aio_context_acquire(replace_aio_context
);
3028 replace_size
= bdrv_getlength(to_replace_bs
);
3029 aio_context_release(replace_aio_context
);
3031 if (replace_size
< 0) {
3032 error_setg_errno(errp
, -replace_size
,
3033 "Failed to query the replacement node's size");
3036 if (bs_size
!= replace_size
) {
3037 error_setg(errp
, "cannot replace image with a mirror image of "
3043 /* pass the node name to replace to mirror start since it's loose coupling
3044 * and will allow to check whether the node still exist at mirror completion
3046 mirror_start(job_id
, bs
, target
,
3047 has_replaces
? replaces
: NULL
, job_flags
,
3048 speed
, granularity
, buf_size
, sync
, backing_mode
, zero_target
,
3049 on_source_error
, on_target_error
, unmap
, filter_node_name
,
3053 void qmp_drive_mirror(DriveMirror
*arg
, Error
**errp
)
3055 BlockDriverState
*bs
;
3056 BlockDriverState
*target_backing_bs
, *target_bs
;
3057 AioContext
*aio_context
;
3058 AioContext
*old_context
;
3059 BlockMirrorBackingMode backing_mode
;
3060 Error
*local_err
= NULL
;
3061 QDict
*options
= NULL
;
3064 const char *format
= arg
->format
;
3068 bs
= qmp_get_root_bs(arg
->device
, errp
);
3073 /* Early check to avoid creating target */
3074 if (bdrv_op_is_blocked(bs
, BLOCK_OP_TYPE_MIRROR_SOURCE
, errp
)) {
3078 aio_context
= bdrv_get_aio_context(bs
);
3079 aio_context_acquire(aio_context
);
3081 if (!arg
->has_mode
) {
3082 arg
->mode
= NEW_IMAGE_MODE_ABSOLUTE_PATHS
;
3085 if (!arg
->has_format
) {
3086 format
= (arg
->mode
== NEW_IMAGE_MODE_EXISTING
3087 ? NULL
: bs
->drv
->format_name
);
3090 flags
= bs
->open_flags
| BDRV_O_RDWR
;
3091 target_backing_bs
= bdrv_cow_bs(bdrv_skip_filters(bs
));
3092 if (!target_backing_bs
&& arg
->sync
== MIRROR_SYNC_MODE_TOP
) {
3093 arg
->sync
= MIRROR_SYNC_MODE_FULL
;
3095 if (arg
->sync
== MIRROR_SYNC_MODE_NONE
) {
3096 target_backing_bs
= bs
;
3099 size
= bdrv_getlength(bs
);
3101 error_setg_errno(errp
, -size
, "bdrv_getlength failed");
3105 if (arg
->has_replaces
) {
3106 if (!arg
->has_node_name
) {
3107 error_setg(errp
, "a node-name must be provided when replacing a"
3108 " named node of the graph");
3113 if (arg
->mode
== NEW_IMAGE_MODE_ABSOLUTE_PATHS
) {
3114 backing_mode
= MIRROR_SOURCE_BACKING_CHAIN
;
3116 backing_mode
= MIRROR_OPEN_BACKING_CHAIN
;
3119 /* Don't open backing image in create() */
3120 flags
|= BDRV_O_NO_BACKING
;
3122 if ((arg
->sync
== MIRROR_SYNC_MODE_FULL
|| !target_backing_bs
)
3123 && arg
->mode
!= NEW_IMAGE_MODE_EXISTING
)
3125 /* create new image w/o backing file */
3127 bdrv_img_create(arg
->target
, format
,
3128 NULL
, NULL
, NULL
, size
, flags
, false, &local_err
);
3130 /* Implicit filters should not appear in the filename */
3131 BlockDriverState
*explicit_backing
=
3132 bdrv_skip_implicit_filters(target_backing_bs
);
3134 switch (arg
->mode
) {
3135 case NEW_IMAGE_MODE_EXISTING
:
3137 case NEW_IMAGE_MODE_ABSOLUTE_PATHS
:
3138 /* create new image with backing file */
3139 bdrv_refresh_filename(explicit_backing
);
3140 bdrv_img_create(arg
->target
, format
,
3141 explicit_backing
->filename
,
3142 explicit_backing
->drv
->format_name
,
3143 NULL
, size
, flags
, false, &local_err
);
3151 error_propagate(errp
, local_err
);
3155 options
= qdict_new();
3156 if (arg
->has_node_name
) {
3157 qdict_put_str(options
, "node-name", arg
->node_name
);
3160 qdict_put_str(options
, "driver", format
);
3163 /* Mirroring takes care of copy-on-write using the source's backing
3166 target_bs
= bdrv_open(arg
->target
, NULL
, options
, flags
, errp
);
3171 zero_target
= (arg
->sync
== MIRROR_SYNC_MODE_FULL
&&
3172 (arg
->mode
== NEW_IMAGE_MODE_EXISTING
||
3173 !bdrv_has_zero_init(target_bs
)));
3176 /* Honor bdrv_try_set_aio_context() context acquisition requirements. */
3177 old_context
= bdrv_get_aio_context(target_bs
);
3178 aio_context_release(aio_context
);
3179 aio_context_acquire(old_context
);
3181 ret
= bdrv_try_set_aio_context(target_bs
, aio_context
, errp
);
3183 bdrv_unref(target_bs
);
3184 aio_context_release(old_context
);
3188 aio_context_release(old_context
);
3189 aio_context_acquire(aio_context
);
3191 blockdev_mirror_common(arg
->has_job_id
? arg
->job_id
: NULL
, bs
, target_bs
,
3192 arg
->has_replaces
, arg
->replaces
, arg
->sync
,
3193 backing_mode
, zero_target
,
3194 arg
->has_speed
, arg
->speed
,
3195 arg
->has_granularity
, arg
->granularity
,
3196 arg
->has_buf_size
, arg
->buf_size
,
3197 arg
->has_on_source_error
, arg
->on_source_error
,
3198 arg
->has_on_target_error
, arg
->on_target_error
,
3199 arg
->has_unmap
, arg
->unmap
,
3201 arg
->has_copy_mode
, arg
->copy_mode
,
3202 arg
->has_auto_finalize
, arg
->auto_finalize
,
3203 arg
->has_auto_dismiss
, arg
->auto_dismiss
,
3205 bdrv_unref(target_bs
);
3207 aio_context_release(aio_context
);
3210 void qmp_blockdev_mirror(bool has_job_id
, const char *job_id
,
3211 const char *device
, const char *target
,
3212 bool has_replaces
, const char *replaces
,
3213 MirrorSyncMode sync
,
3214 bool has_speed
, int64_t speed
,
3215 bool has_granularity
, uint32_t granularity
,
3216 bool has_buf_size
, int64_t buf_size
,
3217 bool has_on_source_error
,
3218 BlockdevOnError on_source_error
,
3219 bool has_on_target_error
,
3220 BlockdevOnError on_target_error
,
3221 bool has_filter_node_name
,
3222 const char *filter_node_name
,
3223 bool has_copy_mode
, MirrorCopyMode copy_mode
,
3224 bool has_auto_finalize
, bool auto_finalize
,
3225 bool has_auto_dismiss
, bool auto_dismiss
,
3228 BlockDriverState
*bs
;
3229 BlockDriverState
*target_bs
;
3230 AioContext
*aio_context
;
3231 AioContext
*old_context
;
3232 BlockMirrorBackingMode backing_mode
= MIRROR_LEAVE_BACKING_CHAIN
;
3236 bs
= qmp_get_root_bs(device
, errp
);
3241 target_bs
= bdrv_lookup_bs(target
, target
, errp
);
3246 zero_target
= (sync
== MIRROR_SYNC_MODE_FULL
);
3248 /* Honor bdrv_try_set_aio_context() context acquisition requirements. */
3249 old_context
= bdrv_get_aio_context(target_bs
);
3250 aio_context
= bdrv_get_aio_context(bs
);
3251 aio_context_acquire(old_context
);
3253 ret
= bdrv_try_set_aio_context(target_bs
, aio_context
, errp
);
3255 aio_context_release(old_context
);
3256 aio_context_acquire(aio_context
);
3262 blockdev_mirror_common(has_job_id
? job_id
: NULL
, bs
, target_bs
,
3263 has_replaces
, replaces
, sync
, backing_mode
,
3264 zero_target
, has_speed
, speed
,
3265 has_granularity
, granularity
,
3266 has_buf_size
, buf_size
,
3267 has_on_source_error
, on_source_error
,
3268 has_on_target_error
, on_target_error
,
3270 has_filter_node_name
, filter_node_name
,
3271 has_copy_mode
, copy_mode
,
3272 has_auto_finalize
, auto_finalize
,
3273 has_auto_dismiss
, auto_dismiss
,
3276 aio_context_release(aio_context
);
3279 /* Get a block job using its ID and acquire its AioContext */
3280 static BlockJob
*find_block_job(const char *id
, AioContext
**aio_context
,
3287 *aio_context
= NULL
;
3289 job
= block_job_get(id
);
3292 error_set(errp
, ERROR_CLASS_DEVICE_NOT_ACTIVE
,
3293 "Block job '%s' not found", id
);
3297 *aio_context
= block_job_get_aio_context(job
);
3298 aio_context_acquire(*aio_context
);
3303 void qmp_block_job_set_speed(const char *device
, int64_t speed
, Error
**errp
)
3305 AioContext
*aio_context
;
3306 BlockJob
*job
= find_block_job(device
, &aio_context
, errp
);
3312 block_job_set_speed(job
, speed
, errp
);
3313 aio_context_release(aio_context
);
3316 void qmp_block_job_cancel(const char *device
,
3317 bool has_force
, bool force
, Error
**errp
)
3319 AioContext
*aio_context
;
3320 BlockJob
*job
= find_block_job(device
, &aio_context
, errp
);
3330 if (job_user_paused(&job
->job
) && !force
) {
3331 error_setg(errp
, "The block job for device '%s' is currently paused",
3336 trace_qmp_block_job_cancel(job
);
3337 job_user_cancel(&job
->job
, force
, errp
);
3339 aio_context_release(aio_context
);
3342 void qmp_block_job_pause(const char *device
, Error
**errp
)
3344 AioContext
*aio_context
;
3345 BlockJob
*job
= find_block_job(device
, &aio_context
, errp
);
3351 trace_qmp_block_job_pause(job
);
3352 job_user_pause(&job
->job
, errp
);
3353 aio_context_release(aio_context
);
3356 void qmp_block_job_resume(const char *device
, Error
**errp
)
3358 AioContext
*aio_context
;
3359 BlockJob
*job
= find_block_job(device
, &aio_context
, errp
);
3365 trace_qmp_block_job_resume(job
);
3366 job_user_resume(&job
->job
, errp
);
3367 aio_context_release(aio_context
);
3370 void qmp_block_job_complete(const char *device
, Error
**errp
)
3372 AioContext
*aio_context
;
3373 BlockJob
*job
= find_block_job(device
, &aio_context
, errp
);
3379 trace_qmp_block_job_complete(job
);
3380 job_complete(&job
->job
, errp
);
3381 aio_context_release(aio_context
);
3384 void qmp_block_job_finalize(const char *id
, Error
**errp
)
3386 AioContext
*aio_context
;
3387 BlockJob
*job
= find_block_job(id
, &aio_context
, errp
);
3393 trace_qmp_block_job_finalize(job
);
3395 job_finalize(&job
->job
, errp
);
3398 * Job's context might have changed via job_finalize (and job_txn_apply
3399 * automatically acquires the new one), so make sure we release the correct
3402 aio_context
= block_job_get_aio_context(job
);
3403 job_unref(&job
->job
);
3404 aio_context_release(aio_context
);
3407 void qmp_block_job_dismiss(const char *id
, Error
**errp
)
3409 AioContext
*aio_context
;
3410 BlockJob
*bjob
= find_block_job(id
, &aio_context
, errp
);
3417 trace_qmp_block_job_dismiss(bjob
);
3419 job_dismiss(&job
, errp
);
3420 aio_context_release(aio_context
);
3423 void qmp_change_backing_file(const char *device
,
3424 const char *image_node_name
,
3425 const char *backing_file
,
3428 BlockDriverState
*bs
= NULL
;
3429 AioContext
*aio_context
;
3430 BlockDriverState
*image_bs
= NULL
;
3431 Error
*local_err
= NULL
;
3435 bs
= qmp_get_root_bs(device
, errp
);
3440 aio_context
= bdrv_get_aio_context(bs
);
3441 aio_context_acquire(aio_context
);
3443 image_bs
= bdrv_lookup_bs(NULL
, image_node_name
, &local_err
);
3445 error_propagate(errp
, local_err
);
3450 error_setg(errp
, "image file not found");
3454 if (bdrv_find_base(image_bs
) == image_bs
) {
3455 error_setg(errp
, "not allowing backing file change on an image "
3456 "without a backing file");
3460 /* even though we are not necessarily operating on bs, we need it to
3461 * determine if block ops are currently prohibited on the chain */
3462 if (bdrv_op_is_blocked(bs
, BLOCK_OP_TYPE_CHANGE
, errp
)) {
3466 /* final sanity check */
3467 if (!bdrv_chain_contains(bs
, image_bs
)) {
3468 error_setg(errp
, "'%s' and image file are not in the same chain",
3473 /* if not r/w, reopen to make r/w */
3474 ro
= bdrv_is_read_only(image_bs
);
3477 if (bdrv_reopen_set_read_only(image_bs
, false, errp
) != 0) {
3482 ret
= bdrv_change_backing_file(image_bs
, backing_file
,
3483 image_bs
->drv
? image_bs
->drv
->format_name
: "",
3487 error_setg_errno(errp
, -ret
, "Could not change backing file to '%s'",
3489 /* don't exit here, so we can try to restore open flags if
3494 bdrv_reopen_set_read_only(image_bs
, true, errp
);
3498 aio_context_release(aio_context
);
3501 void qmp_blockdev_add(BlockdevOptions
*options
, Error
**errp
)
3503 BlockDriverState
*bs
;
3505 Visitor
*v
= qobject_output_visitor_new(&obj
);
3508 visit_type_BlockdevOptions(v
, NULL
, &options
, &error_abort
);
3509 visit_complete(v
, &obj
);
3510 qdict
= qobject_to(QDict
, obj
);
3512 qdict_flatten(qdict
);
3514 if (!qdict_get_try_str(qdict
, "node-name")) {
3515 error_setg(errp
, "'node-name' must be specified for the root node");
3519 bs
= bds_tree_init(qdict
, errp
);
3524 bdrv_set_monitor_owned(bs
);
3530 void qmp_blockdev_reopen(BlockdevOptionsList
*reopen_list
, Error
**errp
)
3532 BlockReopenQueue
*queue
= NULL
;
3533 GSList
*drained
= NULL
;
3536 /* Add each one of the BDS that we want to reopen to the queue */
3537 for (; reopen_list
!= NULL
; reopen_list
= reopen_list
->next
) {
3538 BlockdevOptions
*options
= reopen_list
->value
;
3539 BlockDriverState
*bs
;
3545 /* Check for the selected node name */
3546 if (!options
->has_node_name
) {
3547 error_setg(errp
, "node-name not specified");
3551 bs
= bdrv_find_node(options
->node_name
);
3553 error_setg(errp
, "Failed to find node with node-name='%s'",
3554 options
->node_name
);
3558 /* Put all options in a QDict and flatten it */
3559 v
= qobject_output_visitor_new(&obj
);
3560 visit_type_BlockdevOptions(v
, NULL
, &options
, &error_abort
);
3561 visit_complete(v
, &obj
);
3564 qdict
= qobject_to(QDict
, obj
);
3566 qdict_flatten(qdict
);
3568 ctx
= bdrv_get_aio_context(bs
);
3569 aio_context_acquire(ctx
);
3571 bdrv_subtree_drained_begin(bs
);
3572 queue
= bdrv_reopen_queue(queue
, bs
, qdict
, false);
3573 drained
= g_slist_prepend(drained
, bs
);
3575 aio_context_release(ctx
);
3578 /* Perform the reopen operation */
3579 bdrv_reopen_multiple(queue
, errp
);
3583 bdrv_reopen_queue_free(queue
);
3584 for (p
= drained
; p
; p
= p
->next
) {
3585 BlockDriverState
*bs
= p
->data
;
3586 AioContext
*ctx
= bdrv_get_aio_context(bs
);
3588 aio_context_acquire(ctx
);
3589 bdrv_subtree_drained_end(bs
);
3590 aio_context_release(ctx
);
3592 g_slist_free(drained
);
3595 void qmp_blockdev_del(const char *node_name
, Error
**errp
)
3597 AioContext
*aio_context
;
3598 BlockDriverState
*bs
;
3600 bs
= bdrv_find_node(node_name
);
3602 error_setg(errp
, "Failed to find node with node-name='%s'", node_name
);
3605 if (bdrv_has_blk(bs
)) {
3606 error_setg(errp
, "Node %s is in use", node_name
);
3609 aio_context
= bdrv_get_aio_context(bs
);
3610 aio_context_acquire(aio_context
);
3612 if (bdrv_op_is_blocked(bs
, BLOCK_OP_TYPE_DRIVE_DEL
, errp
)) {
3616 if (!QTAILQ_IN_USE(bs
, monitor_list
)) {
3617 error_setg(errp
, "Node %s is not owned by the monitor",
3622 if (bs
->refcnt
> 1) {
3623 error_setg(errp
, "Block device %s is in use",
3624 bdrv_get_device_or_node_name(bs
));
3628 QTAILQ_REMOVE(&monitor_bdrv_states
, bs
, monitor_list
);
3632 aio_context_release(aio_context
);
3635 static BdrvChild
*bdrv_find_child(BlockDriverState
*parent_bs
,
3636 const char *child_name
)
3640 QLIST_FOREACH(child
, &parent_bs
->children
, next
) {
3641 if (strcmp(child
->name
, child_name
) == 0) {
3649 void qmp_x_blockdev_change(const char *parent
, bool has_child
,
3650 const char *child
, bool has_node
,
3651 const char *node
, Error
**errp
)
3653 BlockDriverState
*parent_bs
, *new_bs
= NULL
;
3656 parent_bs
= bdrv_lookup_bs(parent
, parent
, errp
);
3661 if (has_child
== has_node
) {
3663 error_setg(errp
, "The parameters child and node are in conflict");
3665 error_setg(errp
, "Either child or node must be specified");
3671 p_child
= bdrv_find_child(parent_bs
, child
);
3673 error_setg(errp
, "Node '%s' does not have child '%s'",
3677 bdrv_del_child(parent_bs
, p_child
, errp
);
3681 new_bs
= bdrv_find_node(node
);
3683 error_setg(errp
, "Node '%s' not found", node
);
3686 bdrv_add_child(parent_bs
, new_bs
, errp
);
3690 BlockJobInfoList
*qmp_query_block_jobs(Error
**errp
)
3692 BlockJobInfoList
*head
= NULL
, **tail
= &head
;
3695 for (job
= block_job_next(NULL
); job
; job
= block_job_next(job
)) {
3696 BlockJobInfo
*value
;
3697 AioContext
*aio_context
;
3699 if (block_job_is_internal(job
)) {
3702 aio_context
= block_job_get_aio_context(job
);
3703 aio_context_acquire(aio_context
);
3704 value
= block_job_query(job
, errp
);
3705 aio_context_release(aio_context
);
3707 qapi_free_BlockJobInfoList(head
);
3710 QAPI_LIST_APPEND(tail
, value
);
3716 void qmp_x_blockdev_set_iothread(const char *node_name
, StrOrNull
*iothread
,
3717 bool has_force
, bool force
, Error
**errp
)
3719 AioContext
*old_context
;
3720 AioContext
*new_context
;
3721 BlockDriverState
*bs
;
3723 bs
= bdrv_find_node(node_name
);
3725 error_setg(errp
, "Failed to find node with node-name='%s'", node_name
);
3729 /* Protects against accidents. */
3730 if (!(has_force
&& force
) && bdrv_has_blk(bs
)) {
3731 error_setg(errp
, "Node %s is associated with a BlockBackend and could "
3732 "be in use (use force=true to override this check)",
3737 if (iothread
->type
== QTYPE_QSTRING
) {
3738 IOThread
*obj
= iothread_by_id(iothread
->u
.s
);
3740 error_setg(errp
, "Cannot find iothread %s", iothread
->u
.s
);
3744 new_context
= iothread_get_aio_context(obj
);
3746 new_context
= qemu_get_aio_context();
3749 old_context
= bdrv_get_aio_context(bs
);
3750 aio_context_acquire(old_context
);
3752 bdrv_try_set_aio_context(bs
, new_context
, errp
);
3754 aio_context_release(old_context
);
3757 QemuOptsList qemu_common_drive_opts
= {
3759 .head
= QTAILQ_HEAD_INITIALIZER(qemu_common_drive_opts
.head
),
3763 .type
= QEMU_OPT_BOOL
,
3764 .help
= "enable/disable snapshot mode",
3767 .type
= QEMU_OPT_STRING
,
3768 .help
= "host AIO implementation (threads, native, io_uring)",
3770 .name
= BDRV_OPT_CACHE_WB
,
3771 .type
= QEMU_OPT_BOOL
,
3772 .help
= "Enable writeback mode",
3775 .type
= QEMU_OPT_STRING
,
3776 .help
= "disk format (raw, qcow2, ...)",
3779 .type
= QEMU_OPT_STRING
,
3780 .help
= "read error action",
3783 .type
= QEMU_OPT_STRING
,
3784 .help
= "write error action",
3786 .name
= BDRV_OPT_READ_ONLY
,
3787 .type
= QEMU_OPT_BOOL
,
3788 .help
= "open drive file as read-only",
3794 .name
= "throttling.group",
3795 .type
= QEMU_OPT_STRING
,
3796 .help
= "name of the block throttling group",
3798 .name
= "copy-on-read",
3799 .type
= QEMU_OPT_BOOL
,
3800 .help
= "copy read data from backing file into image file",
3802 .name
= "detect-zeroes",
3803 .type
= QEMU_OPT_STRING
,
3804 .help
= "try to optimize zero writes (off, on, unmap)",
3806 .name
= "stats-account-invalid",
3807 .type
= QEMU_OPT_BOOL
,
3808 .help
= "whether to account for invalid I/O operations "
3809 "in the statistics",
3811 .name
= "stats-account-failed",
3812 .type
= QEMU_OPT_BOOL
,
3813 .help
= "whether to account for failed I/O operations "
3814 "in the statistics",
3816 { /* end of list */ }
3820 QemuOptsList qemu_drive_opts
= {
3822 .head
= QTAILQ_HEAD_INITIALIZER(qemu_drive_opts
.head
),
3825 * no elements => accept any params
3826 * validation will happen later
3828 { /* end of list */ }