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/arch_init.h"
60 #include "sysemu/qtest.h"
61 #include "sysemu/runstate.h"
62 #include "qemu/cutils.h"
63 #include "qemu/help_option.h"
64 #include "qemu/main-loop.h"
65 #include "qemu/throttle-options.h"
67 QTAILQ_HEAD(, BlockDriverState
) monitor_bdrv_states
=
68 QTAILQ_HEAD_INITIALIZER(monitor_bdrv_states
);
70 void bdrv_set_monitor_owned(BlockDriverState
*bs
)
72 QTAILQ_INSERT_TAIL(&monitor_bdrv_states
, bs
, monitor_list
);
75 static const char *const if_name
[IF_COUNT
] = {
79 [IF_FLOPPY
] = "floppy",
80 [IF_PFLASH
] = "pflash",
83 [IF_VIRTIO
] = "virtio",
87 static int if_max_devs
[IF_COUNT
] = {
89 * Do not change these numbers! They govern how drive option
90 * index maps to unit and bus. That mapping is ABI.
92 * All controllers used to implement if=T drives need to support
93 * if_max_devs[T] units, for any T with if_max_devs[T] != 0.
94 * Otherwise, some index values map to "impossible" bus, unit
97 * For instance, if you change [IF_SCSI] to 255, -drive
98 * if=scsi,index=12 no longer means bus=1,unit=5, but
99 * bus=0,unit=12. With an lsi53c895a controller (7 units max),
100 * the drive can't be set up. Regression.
107 * Boards may call this to offer board-by-board overrides
108 * of the default, global values.
110 void override_max_devs(BlockInterfaceType type
, int max_devs
)
119 for (blk
= blk_next(NULL
); blk
; blk
= blk_next(blk
)) {
120 dinfo
= blk_legacy_dinfo(blk
);
121 if (dinfo
->type
== type
) {
122 fprintf(stderr
, "Cannot override units-per-bus property of"
123 " the %s interface, because a drive of that type has"
124 " already been added.\n", if_name
[type
]);
125 g_assert_not_reached();
129 if_max_devs
[type
] = max_devs
;
133 * We automatically delete the drive when a device using it gets
134 * unplugged. Questionable feature, but we can't just drop it.
135 * Device models call blockdev_mark_auto_del() to schedule the
136 * automatic deletion, and generic qdev code calls blockdev_auto_del()
137 * when deletion is actually safe.
139 void blockdev_mark_auto_del(BlockBackend
*blk
)
141 DriveInfo
*dinfo
= blk_legacy_dinfo(blk
);
148 for (job
= block_job_next(NULL
); job
; job
= block_job_next(job
)) {
149 if (block_job_has_bdrv(job
, blk_bs(blk
))) {
150 AioContext
*aio_context
= job
->job
.aio_context
;
151 aio_context_acquire(aio_context
);
153 job_cancel(&job
->job
, false);
155 aio_context_release(aio_context
);
162 void blockdev_auto_del(BlockBackend
*blk
)
164 DriveInfo
*dinfo
= blk_legacy_dinfo(blk
);
166 if (dinfo
&& dinfo
->auto_del
) {
167 monitor_remove_blk(blk
);
173 * Returns the current mapping of how many units per bus
174 * a particular interface can support.
176 * A positive integer indicates n units per bus.
177 * 0 implies the mapping has not been established.
178 * -1 indicates an invalid BlockInterfaceType was given.
180 int drive_get_max_devs(BlockInterfaceType type
)
182 if (type
>= IF_IDE
&& type
< IF_COUNT
) {
183 return if_max_devs
[type
];
189 static int drive_index_to_bus_id(BlockInterfaceType type
, int index
)
191 int max_devs
= if_max_devs
[type
];
192 return max_devs
? index
/ max_devs
: 0;
195 static int drive_index_to_unit_id(BlockInterfaceType type
, int index
)
197 int max_devs
= if_max_devs
[type
];
198 return max_devs
? index
% max_devs
: index
;
201 QemuOpts
*drive_def(const char *optstr
)
203 return qemu_opts_parse_noisily(qemu_find_opts("drive"), optstr
, false);
206 QemuOpts
*drive_add(BlockInterfaceType type
, int index
, const char *file
,
211 opts
= drive_def(optstr
);
215 if (type
!= IF_DEFAULT
) {
216 qemu_opt_set(opts
, "if", if_name
[type
], &error_abort
);
219 qemu_opt_set_number(opts
, "index", index
, &error_abort
);
222 qemu_opt_set(opts
, "file", file
, &error_abort
);
226 DriveInfo
*drive_get(BlockInterfaceType type
, int bus
, int unit
)
231 for (blk
= blk_next(NULL
); blk
; blk
= blk_next(blk
)) {
232 dinfo
= blk_legacy_dinfo(blk
);
233 if (dinfo
&& dinfo
->type
== type
234 && dinfo
->bus
== bus
&& dinfo
->unit
== unit
) {
242 void drive_mark_claimed_by_board(void)
247 for (blk
= blk_next(NULL
); blk
; blk
= blk_next(blk
)) {
248 dinfo
= blk_legacy_dinfo(blk
);
249 if (dinfo
&& blk_get_attached_dev(blk
)) {
250 dinfo
->claimed_by_board
= true;
255 void drive_check_orphaned(void)
260 bool orphans
= false;
262 for (blk
= blk_next(NULL
); blk
; blk
= blk_next(blk
)) {
263 dinfo
= blk_legacy_dinfo(blk
);
264 if (dinfo
->is_default
|| dinfo
->type
== IF_NONE
) {
267 if (!blk_get_attached_dev(blk
)) {
269 qemu_opts_loc_restore(dinfo
->opts
);
270 error_report("machine type does not support"
271 " if=%s,bus=%d,unit=%d",
272 if_name
[dinfo
->type
], dinfo
->bus
, dinfo
->unit
);
277 if (!dinfo
->claimed_by_board
&& dinfo
->type
!= IF_VIRTIO
) {
279 qemu_opts_loc_restore(dinfo
->opts
);
280 warn_report("bogus if=%s is deprecated, use if=none",
281 if_name
[dinfo
->type
]);
291 DriveInfo
*drive_get_by_index(BlockInterfaceType type
, int index
)
293 return drive_get(type
,
294 drive_index_to_bus_id(type
, index
),
295 drive_index_to_unit_id(type
, index
));
298 int drive_get_max_bus(BlockInterfaceType type
)
305 for (blk
= blk_next(NULL
); blk
; blk
= blk_next(blk
)) {
306 dinfo
= blk_legacy_dinfo(blk
);
307 if (dinfo
&& dinfo
->type
== type
&& dinfo
->bus
> max_bus
) {
308 max_bus
= dinfo
->bus
;
314 /* Get a block device. This should only be used for single-drive devices
315 (e.g. SD/Floppy/MTD). Multi-disk devices (scsi/ide) should use the
317 DriveInfo
*drive_get_next(BlockInterfaceType type
)
319 static int next_block_unit
[IF_COUNT
];
321 return drive_get(type
, 0, next_block_unit
[type
]++);
324 static void bdrv_format_print(void *opaque
, const char *name
)
326 qemu_printf(" %s", name
);
331 BlockDriverState
*bs
;
334 static int parse_block_error_action(const char *buf
, bool is_read
, Error
**errp
)
336 if (!strcmp(buf
, "ignore")) {
337 return BLOCKDEV_ON_ERROR_IGNORE
;
338 } else if (!is_read
&& !strcmp(buf
, "enospc")) {
339 return BLOCKDEV_ON_ERROR_ENOSPC
;
340 } else if (!strcmp(buf
, "stop")) {
341 return BLOCKDEV_ON_ERROR_STOP
;
342 } else if (!strcmp(buf
, "report")) {
343 return BLOCKDEV_ON_ERROR_REPORT
;
345 error_setg(errp
, "'%s' invalid %s error action",
346 buf
, is_read
? "read" : "write");
351 static bool parse_stats_intervals(BlockAcctStats
*stats
, QList
*intervals
,
354 const QListEntry
*entry
;
355 for (entry
= qlist_first(intervals
); entry
; entry
= qlist_next(entry
)) {
356 switch (qobject_type(entry
->value
)) {
358 case QTYPE_QSTRING
: {
359 unsigned long long length
;
360 const char *str
= qstring_get_str(qobject_to(QString
,
362 if (parse_uint_full(str
, &length
, 10) == 0 &&
363 length
> 0 && length
<= UINT_MAX
) {
364 block_acct_add_interval(stats
, (unsigned) length
);
366 error_setg(errp
, "Invalid interval length: %s", str
);
373 int64_t length
= qnum_get_int(qobject_to(QNum
, entry
->value
));
375 if (length
> 0 && length
<= UINT_MAX
) {
376 block_acct_add_interval(stats
, (unsigned) length
);
378 error_setg(errp
, "Invalid interval length: %" PRId64
, length
);
385 error_setg(errp
, "The specification of stats-intervals is invalid");
392 typedef enum { MEDIA_DISK
, MEDIA_CDROM
} DriveMediaType
;
394 /* All parameters but @opts are optional and may be set to NULL. */
395 static void extract_common_blockdev_options(QemuOpts
*opts
, int *bdrv_flags
,
396 const char **throttling_group
, ThrottleConfig
*throttle_cfg
,
397 BlockdevDetectZeroesOptions
*detect_zeroes
, Error
**errp
)
399 Error
*local_error
= NULL
;
403 if (qemu_opt_get_bool(opts
, "copy-on-read", false)) {
404 *bdrv_flags
|= BDRV_O_COPY_ON_READ
;
407 if ((aio
= qemu_opt_get(opts
, "aio")) != NULL
) {
408 if (bdrv_parse_aio(aio
, bdrv_flags
) < 0) {
409 error_setg(errp
, "invalid aio option");
415 /* disk I/O throttling */
416 if (throttling_group
) {
417 *throttling_group
= qemu_opt_get(opts
, "throttling.group");
421 throttle_config_init(throttle_cfg
);
422 throttle_cfg
->buckets
[THROTTLE_BPS_TOTAL
].avg
=
423 qemu_opt_get_number(opts
, "throttling.bps-total", 0);
424 throttle_cfg
->buckets
[THROTTLE_BPS_READ
].avg
=
425 qemu_opt_get_number(opts
, "throttling.bps-read", 0);
426 throttle_cfg
->buckets
[THROTTLE_BPS_WRITE
].avg
=
427 qemu_opt_get_number(opts
, "throttling.bps-write", 0);
428 throttle_cfg
->buckets
[THROTTLE_OPS_TOTAL
].avg
=
429 qemu_opt_get_number(opts
, "throttling.iops-total", 0);
430 throttle_cfg
->buckets
[THROTTLE_OPS_READ
].avg
=
431 qemu_opt_get_number(opts
, "throttling.iops-read", 0);
432 throttle_cfg
->buckets
[THROTTLE_OPS_WRITE
].avg
=
433 qemu_opt_get_number(opts
, "throttling.iops-write", 0);
435 throttle_cfg
->buckets
[THROTTLE_BPS_TOTAL
].max
=
436 qemu_opt_get_number(opts
, "throttling.bps-total-max", 0);
437 throttle_cfg
->buckets
[THROTTLE_BPS_READ
].max
=
438 qemu_opt_get_number(opts
, "throttling.bps-read-max", 0);
439 throttle_cfg
->buckets
[THROTTLE_BPS_WRITE
].max
=
440 qemu_opt_get_number(opts
, "throttling.bps-write-max", 0);
441 throttle_cfg
->buckets
[THROTTLE_OPS_TOTAL
].max
=
442 qemu_opt_get_number(opts
, "throttling.iops-total-max", 0);
443 throttle_cfg
->buckets
[THROTTLE_OPS_READ
].max
=
444 qemu_opt_get_number(opts
, "throttling.iops-read-max", 0);
445 throttle_cfg
->buckets
[THROTTLE_OPS_WRITE
].max
=
446 qemu_opt_get_number(opts
, "throttling.iops-write-max", 0);
448 throttle_cfg
->buckets
[THROTTLE_BPS_TOTAL
].burst_length
=
449 qemu_opt_get_number(opts
, "throttling.bps-total-max-length", 1);
450 throttle_cfg
->buckets
[THROTTLE_BPS_READ
].burst_length
=
451 qemu_opt_get_number(opts
, "throttling.bps-read-max-length", 1);
452 throttle_cfg
->buckets
[THROTTLE_BPS_WRITE
].burst_length
=
453 qemu_opt_get_number(opts
, "throttling.bps-write-max-length", 1);
454 throttle_cfg
->buckets
[THROTTLE_OPS_TOTAL
].burst_length
=
455 qemu_opt_get_number(opts
, "throttling.iops-total-max-length", 1);
456 throttle_cfg
->buckets
[THROTTLE_OPS_READ
].burst_length
=
457 qemu_opt_get_number(opts
, "throttling.iops-read-max-length", 1);
458 throttle_cfg
->buckets
[THROTTLE_OPS_WRITE
].burst_length
=
459 qemu_opt_get_number(opts
, "throttling.iops-write-max-length", 1);
461 throttle_cfg
->op_size
=
462 qemu_opt_get_number(opts
, "throttling.iops-size", 0);
464 if (!throttle_is_valid(throttle_cfg
, errp
)) {
471 qapi_enum_parse(&BlockdevDetectZeroesOptions_lookup
,
472 qemu_opt_get(opts
, "detect-zeroes"),
473 BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF
,
476 error_propagate(errp
, local_error
);
482 /* Takes the ownership of bs_opts */
483 static BlockBackend
*blockdev_init(const char *file
, QDict
*bs_opts
,
488 int on_read_error
, on_write_error
;
489 bool account_invalid
, account_failed
;
490 bool writethrough
, read_only
;
492 BlockDriverState
*bs
;
497 QDict
*interval_dict
= NULL
;
498 QList
*interval_list
= NULL
;
500 BlockdevDetectZeroesOptions detect_zeroes
=
501 BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF
;
502 const char *throttling_group
= NULL
;
504 /* Check common options by copying from bs_opts to opts, all other options
505 * stay in bs_opts for processing by bdrv_open(). */
506 id
= qdict_get_try_str(bs_opts
, "id");
507 opts
= qemu_opts_create(&qemu_common_drive_opts
, id
, 1, errp
);
512 if (!qemu_opts_absorb_qdict(opts
, bs_opts
, errp
)) {
517 qdict_del(bs_opts
, "id");
520 /* extract parameters */
521 snapshot
= qemu_opt_get_bool(opts
, "snapshot", 0);
523 account_invalid
= qemu_opt_get_bool(opts
, "stats-account-invalid", true);
524 account_failed
= qemu_opt_get_bool(opts
, "stats-account-failed", true);
526 writethrough
= !qemu_opt_get_bool(opts
, BDRV_OPT_CACHE_WB
, true);
528 id
= qemu_opts_id(opts
);
530 qdict_extract_subqdict(bs_opts
, &interval_dict
, "stats-intervals.");
531 qdict_array_split(interval_dict
, &interval_list
);
533 if (qdict_size(interval_dict
) != 0) {
534 error_setg(errp
, "Invalid option stats-intervals.%s",
535 qdict_first(interval_dict
)->key
);
539 extract_common_blockdev_options(opts
, &bdrv_flags
, &throttling_group
, &cfg
,
540 &detect_zeroes
, &error
);
542 error_propagate(errp
, error
);
546 if ((buf
= qemu_opt_get(opts
, "format")) != NULL
) {
547 if (is_help_option(buf
)) {
548 qemu_printf("Supported formats:");
549 bdrv_iterate_format(bdrv_format_print
, NULL
, false);
550 qemu_printf("\nSupported formats (read-only):");
551 bdrv_iterate_format(bdrv_format_print
, NULL
, true);
556 if (qdict_haskey(bs_opts
, "driver")) {
557 error_setg(errp
, "Cannot specify both 'driver' and 'format'");
560 qdict_put_str(bs_opts
, "driver", buf
);
563 on_write_error
= BLOCKDEV_ON_ERROR_ENOSPC
;
564 if ((buf
= qemu_opt_get(opts
, "werror")) != NULL
) {
565 on_write_error
= parse_block_error_action(buf
, 0, &error
);
567 error_propagate(errp
, error
);
572 on_read_error
= BLOCKDEV_ON_ERROR_REPORT
;
573 if ((buf
= qemu_opt_get(opts
, "rerror")) != NULL
) {
574 on_read_error
= parse_block_error_action(buf
, 1, &error
);
576 error_propagate(errp
, error
);
582 bdrv_flags
|= BDRV_O_SNAPSHOT
;
585 read_only
= qemu_opt_get_bool(opts
, BDRV_OPT_READ_ONLY
, false);
588 if ((!file
|| !*file
) && !qdict_size(bs_opts
)) {
589 BlockBackendRootState
*blk_rs
;
591 blk
= blk_new(qemu_get_aio_context(), 0, BLK_PERM_ALL
);
592 blk_rs
= blk_get_root_state(blk
);
593 blk_rs
->open_flags
= bdrv_flags
;
594 blk_rs
->read_only
= read_only
;
595 blk_rs
->detect_zeroes
= detect_zeroes
;
597 qobject_unref(bs_opts
);
599 if (file
&& !*file
) {
603 /* bdrv_open() defaults to the values in bdrv_flags (for compatibility
604 * with other callers) rather than what we want as the real defaults.
605 * Apply the defaults here instead. */
606 qdict_set_default_str(bs_opts
, BDRV_OPT_CACHE_DIRECT
, "off");
607 qdict_set_default_str(bs_opts
, BDRV_OPT_CACHE_NO_FLUSH
, "off");
608 qdict_set_default_str(bs_opts
, BDRV_OPT_READ_ONLY
,
609 read_only
? "on" : "off");
610 qdict_set_default_str(bs_opts
, BDRV_OPT_AUTO_READ_ONLY
, "on");
611 assert((bdrv_flags
& BDRV_O_CACHE_MASK
) == 0);
613 if (runstate_check(RUN_STATE_INMIGRATE
)) {
614 bdrv_flags
|= BDRV_O_INACTIVE
;
617 blk
= blk_new_open(file
, NULL
, bs_opts
, bdrv_flags
, errp
);
623 bs
->detect_zeroes
= detect_zeroes
;
625 block_acct_setup(blk_get_stats(blk
), account_invalid
, account_failed
);
627 if (!parse_stats_intervals(blk_get_stats(blk
), interval_list
, errp
)) {
634 /* disk I/O throttling */
635 if (throttle_enabled(&cfg
)) {
636 if (!throttling_group
) {
637 throttling_group
= id
;
639 blk_io_limits_enable(blk
, throttling_group
);
640 blk_set_io_limits(blk
, &cfg
);
643 blk_set_enable_write_cache(blk
, !writethrough
);
644 blk_set_on_error(blk
, on_read_error
, on_write_error
);
646 if (!monitor_add_blk(blk
, id
, errp
)) {
654 qobject_unref(interval_dict
);
655 qobject_unref(interval_list
);
660 qobject_unref(interval_dict
);
661 qobject_unref(interval_list
);
663 qobject_unref(bs_opts
);
667 /* Takes the ownership of bs_opts */
668 BlockDriverState
*bds_tree_init(QDict
*bs_opts
, Error
**errp
)
672 /* bdrv_open() defaults to the values in bdrv_flags (for compatibility
673 * with other callers) rather than what we want as the real defaults.
674 * Apply the defaults here instead. */
675 qdict_set_default_str(bs_opts
, BDRV_OPT_CACHE_DIRECT
, "off");
676 qdict_set_default_str(bs_opts
, BDRV_OPT_CACHE_NO_FLUSH
, "off");
677 qdict_set_default_str(bs_opts
, BDRV_OPT_READ_ONLY
, "off");
679 if (runstate_check(RUN_STATE_INMIGRATE
)) {
680 bdrv_flags
|= BDRV_O_INACTIVE
;
683 return bdrv_open(NULL
, NULL
, bs_opts
, bdrv_flags
, errp
);
686 void blockdev_close_all_bdrv_states(void)
688 BlockDriverState
*bs
, *next_bs
;
690 QTAILQ_FOREACH_SAFE(bs
, &monitor_bdrv_states
, monitor_list
, next_bs
) {
691 AioContext
*ctx
= bdrv_get_aio_context(bs
);
693 aio_context_acquire(ctx
);
695 aio_context_release(ctx
);
699 /* Iterates over the list of monitor-owned BlockDriverStates */
700 BlockDriverState
*bdrv_next_monitor_owned(BlockDriverState
*bs
)
702 return bs
? QTAILQ_NEXT(bs
, monitor_list
)
703 : QTAILQ_FIRST(&monitor_bdrv_states
);
706 static bool qemu_opt_rename(QemuOpts
*opts
, const char *from
, const char *to
,
711 value
= qemu_opt_get(opts
, from
);
713 if (qemu_opt_find(opts
, to
)) {
714 error_setg(errp
, "'%s' and its alias '%s' can't be used at the "
715 "same time", to
, from
);
720 /* rename all items in opts */
721 while ((value
= qemu_opt_get(opts
, from
))) {
722 qemu_opt_set(opts
, to
, value
, &error_abort
);
723 qemu_opt_unset(opts
, from
);
728 QemuOptsList qemu_legacy_drive_opts
= {
730 .head
= QTAILQ_HEAD_INITIALIZER(qemu_legacy_drive_opts
.head
),
734 .type
= QEMU_OPT_NUMBER
,
735 .help
= "bus number",
738 .type
= QEMU_OPT_NUMBER
,
739 .help
= "unit number (i.e. lun for scsi)",
742 .type
= QEMU_OPT_NUMBER
,
743 .help
= "index number",
746 .type
= QEMU_OPT_STRING
,
747 .help
= "media type (disk, cdrom)",
750 .type
= QEMU_OPT_STRING
,
751 .help
= "interface (ide, scsi, sd, mtd, floppy, pflash, virtio)",
754 .type
= QEMU_OPT_STRING
,
758 /* Options that are passed on, but have special semantics with -drive */
760 .name
= BDRV_OPT_READ_ONLY
,
761 .type
= QEMU_OPT_BOOL
,
762 .help
= "open drive file as read-only",
765 .type
= QEMU_OPT_STRING
,
766 .help
= "read error action",
769 .type
= QEMU_OPT_STRING
,
770 .help
= "write error action",
772 .name
= "copy-on-read",
773 .type
= QEMU_OPT_BOOL
,
774 .help
= "copy read data from backing file into image file",
777 { /* end of list */ }
781 DriveInfo
*drive_new(QemuOpts
*all_opts
, BlockInterfaceType block_default_type
,
786 DriveInfo
*dinfo
= NULL
;
788 QemuOpts
*legacy_opts
;
789 DriveMediaType media
= MEDIA_DISK
;
790 BlockInterfaceType type
;
791 int max_devs
, bus_id
, unit_id
, index
;
792 const char *werror
, *rerror
;
793 bool read_only
= false;
795 const char *filename
;
798 /* Change legacy command line options into QMP ones */
799 static const struct {
803 { "iops", "throttling.iops-total" },
804 { "iops_rd", "throttling.iops-read" },
805 { "iops_wr", "throttling.iops-write" },
807 { "bps", "throttling.bps-total" },
808 { "bps_rd", "throttling.bps-read" },
809 { "bps_wr", "throttling.bps-write" },
811 { "iops_max", "throttling.iops-total-max" },
812 { "iops_rd_max", "throttling.iops-read-max" },
813 { "iops_wr_max", "throttling.iops-write-max" },
815 { "bps_max", "throttling.bps-total-max" },
816 { "bps_rd_max", "throttling.bps-read-max" },
817 { "bps_wr_max", "throttling.bps-write-max" },
819 { "iops_size", "throttling.iops-size" },
821 { "group", "throttling.group" },
823 { "readonly", BDRV_OPT_READ_ONLY
},
826 for (i
= 0; i
< ARRAY_SIZE(opt_renames
); i
++) {
827 if (!qemu_opt_rename(all_opts
, opt_renames
[i
].from
,
828 opt_renames
[i
].to
, errp
)) {
833 value
= qemu_opt_get(all_opts
, "cache");
838 if (bdrv_parse_cache_mode(value
, &flags
, &writethrough
) != 0) {
839 error_setg(errp
, "invalid cache option");
843 /* Specific options take precedence */
844 if (!qemu_opt_get(all_opts
, BDRV_OPT_CACHE_WB
)) {
845 qemu_opt_set_bool(all_opts
, BDRV_OPT_CACHE_WB
,
846 !writethrough
, &error_abort
);
848 if (!qemu_opt_get(all_opts
, BDRV_OPT_CACHE_DIRECT
)) {
849 qemu_opt_set_bool(all_opts
, BDRV_OPT_CACHE_DIRECT
,
850 !!(flags
& BDRV_O_NOCACHE
), &error_abort
);
852 if (!qemu_opt_get(all_opts
, BDRV_OPT_CACHE_NO_FLUSH
)) {
853 qemu_opt_set_bool(all_opts
, BDRV_OPT_CACHE_NO_FLUSH
,
854 !!(flags
& BDRV_O_NO_FLUSH
), &error_abort
);
856 qemu_opt_unset(all_opts
, "cache");
859 /* Get a QDict for processing the options */
860 bs_opts
= qdict_new();
861 qemu_opts_to_qdict(all_opts
, bs_opts
);
863 legacy_opts
= qemu_opts_create(&qemu_legacy_drive_opts
, NULL
, 0,
865 if (!qemu_opts_absorb_qdict(legacy_opts
, bs_opts
, errp
)) {
870 value
= qemu_opt_get(legacy_opts
, "media");
872 if (!strcmp(value
, "disk")) {
874 } else if (!strcmp(value
, "cdrom")) {
878 error_setg(errp
, "'%s' invalid media", value
);
883 /* copy-on-read is disabled with a warning for read-only devices */
884 read_only
|= qemu_opt_get_bool(legacy_opts
, BDRV_OPT_READ_ONLY
, false);
885 copy_on_read
= qemu_opt_get_bool(legacy_opts
, "copy-on-read", false);
887 if (read_only
&& copy_on_read
) {
888 warn_report("disabling copy-on-read on read-only drive");
889 copy_on_read
= false;
892 qdict_put_str(bs_opts
, BDRV_OPT_READ_ONLY
, read_only
? "on" : "off");
893 qdict_put_str(bs_opts
, "copy-on-read", copy_on_read
? "on" : "off");
895 /* Controller type */
896 value
= qemu_opt_get(legacy_opts
, "if");
899 type
< IF_COUNT
&& strcmp(value
, if_name
[type
]);
902 if (type
== IF_COUNT
) {
903 error_setg(errp
, "unsupported bus type '%s'", value
);
907 type
= block_default_type
;
910 /* Device address specified by bus/unit or index.
911 * If none was specified, try to find the first free one. */
912 bus_id
= qemu_opt_get_number(legacy_opts
, "bus", 0);
913 unit_id
= qemu_opt_get_number(legacy_opts
, "unit", -1);
914 index
= qemu_opt_get_number(legacy_opts
, "index", -1);
916 max_devs
= if_max_devs
[type
];
919 if (bus_id
!= 0 || unit_id
!= -1) {
920 error_setg(errp
, "index cannot be used with bus and unit");
923 bus_id
= drive_index_to_bus_id(type
, index
);
924 unit_id
= drive_index_to_unit_id(type
, index
);
929 while (drive_get(type
, bus_id
, unit_id
) != NULL
) {
931 if (max_devs
&& unit_id
>= max_devs
) {
938 if (max_devs
&& unit_id
>= max_devs
) {
939 error_setg(errp
, "unit %d too big (max is %d)", unit_id
, max_devs
- 1);
943 if (drive_get(type
, bus_id
, unit_id
) != NULL
) {
944 error_setg(errp
, "drive with bus=%d, unit=%d (index=%d) exists",
945 bus_id
, unit_id
, index
);
949 /* no id supplied -> create one */
950 if (qemu_opts_id(all_opts
) == NULL
) {
952 const char *mediastr
= "";
953 if (type
== IF_IDE
|| type
== IF_SCSI
) {
954 mediastr
= (media
== MEDIA_CDROM
) ? "-cd" : "-hd";
957 new_id
= g_strdup_printf("%s%i%s%i", if_name
[type
], bus_id
,
960 new_id
= g_strdup_printf("%s%s%i", if_name
[type
],
963 qdict_put_str(bs_opts
, "id", new_id
);
967 /* Add virtio block device */
968 if (type
== IF_VIRTIO
) {
970 devopts
= qemu_opts_create(qemu_find_opts("device"), NULL
, 0,
972 if (arch_type
== QEMU_ARCH_S390X
) {
973 qemu_opt_set(devopts
, "driver", "virtio-blk-ccw", &error_abort
);
975 qemu_opt_set(devopts
, "driver", "virtio-blk-pci", &error_abort
);
977 qemu_opt_set(devopts
, "drive", qdict_get_str(bs_opts
, "id"),
981 filename
= qemu_opt_get(legacy_opts
, "file");
983 /* Check werror/rerror compatibility with if=... */
984 werror
= qemu_opt_get(legacy_opts
, "werror");
985 if (werror
!= NULL
) {
986 if (type
!= IF_IDE
&& type
!= IF_SCSI
&& type
!= IF_VIRTIO
&&
988 error_setg(errp
, "werror is not supported by this bus type");
991 qdict_put_str(bs_opts
, "werror", werror
);
994 rerror
= qemu_opt_get(legacy_opts
, "rerror");
995 if (rerror
!= NULL
) {
996 if (type
!= IF_IDE
&& type
!= IF_VIRTIO
&& type
!= IF_SCSI
&&
998 error_setg(errp
, "rerror is not supported by this bus type");
1001 qdict_put_str(bs_opts
, "rerror", rerror
);
1004 /* Actual block device init: Functionality shared with blockdev-add */
1005 blk
= blockdev_init(filename
, bs_opts
, errp
);
1011 /* Create legacy DriveInfo */
1012 dinfo
= g_malloc0(sizeof(*dinfo
));
1013 dinfo
->opts
= all_opts
;
1016 dinfo
->bus
= bus_id
;
1017 dinfo
->unit
= unit_id
;
1019 blk_set_legacy_dinfo(blk
, dinfo
);
1026 dinfo
->media_cd
= media
== MEDIA_CDROM
;
1033 qemu_opts_del(legacy_opts
);
1034 qobject_unref(bs_opts
);
1038 static BlockDriverState
*qmp_get_root_bs(const char *name
, Error
**errp
)
1040 BlockDriverState
*bs
;
1042 bs
= bdrv_lookup_bs(name
, name
, errp
);
1047 if (!bdrv_is_root_node(bs
)) {
1048 error_setg(errp
, "Need a root block node");
1052 if (!bdrv_is_inserted(bs
)) {
1053 error_setg(errp
, "Device has no medium");
1060 static void blockdev_do_action(TransactionAction
*action
, Error
**errp
)
1062 TransactionActionList list
;
1064 list
.value
= action
;
1066 qmp_transaction(&list
, false, NULL
, errp
);
1069 void qmp_blockdev_snapshot_sync(bool has_device
, const char *device
,
1070 bool has_node_name
, const char *node_name
,
1071 const char *snapshot_file
,
1072 bool has_snapshot_node_name
,
1073 const char *snapshot_node_name
,
1074 bool has_format
, const char *format
,
1075 bool has_mode
, NewImageMode mode
, Error
**errp
)
1077 BlockdevSnapshotSync snapshot
= {
1078 .has_device
= has_device
,
1079 .device
= (char *) device
,
1080 .has_node_name
= has_node_name
,
1081 .node_name
= (char *) node_name
,
1082 .snapshot_file
= (char *) snapshot_file
,
1083 .has_snapshot_node_name
= has_snapshot_node_name
,
1084 .snapshot_node_name
= (char *) snapshot_node_name
,
1085 .has_format
= has_format
,
1086 .format
= (char *) format
,
1087 .has_mode
= has_mode
,
1090 TransactionAction action
= {
1091 .type
= TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_SYNC
,
1092 .u
.blockdev_snapshot_sync
.data
= &snapshot
,
1094 blockdev_do_action(&action
, errp
);
1097 void qmp_blockdev_snapshot(const char *node
, const char *overlay
,
1100 BlockdevSnapshot snapshot_data
= {
1101 .node
= (char *) node
,
1102 .overlay
= (char *) overlay
1104 TransactionAction action
= {
1105 .type
= TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT
,
1106 .u
.blockdev_snapshot
.data
= &snapshot_data
,
1108 blockdev_do_action(&action
, errp
);
1111 void qmp_blockdev_snapshot_internal_sync(const char *device
,
1115 BlockdevSnapshotInternal snapshot
= {
1116 .device
= (char *) device
,
1117 .name
= (char *) name
1119 TransactionAction action
= {
1120 .type
= TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_INTERNAL_SYNC
,
1121 .u
.blockdev_snapshot_internal_sync
.data
= &snapshot
,
1123 blockdev_do_action(&action
, errp
);
1126 SnapshotInfo
*qmp_blockdev_snapshot_delete_internal_sync(const char *device
,
1133 BlockDriverState
*bs
;
1134 AioContext
*aio_context
;
1135 QEMUSnapshotInfo sn
;
1136 Error
*local_err
= NULL
;
1137 SnapshotInfo
*info
= NULL
;
1140 bs
= qmp_get_root_bs(device
, errp
);
1144 aio_context
= bdrv_get_aio_context(bs
);
1145 aio_context_acquire(aio_context
);
1156 error_setg(errp
, "Name or id must be provided");
1157 goto out_aio_context
;
1160 if (bdrv_op_is_blocked(bs
, BLOCK_OP_TYPE_INTERNAL_SNAPSHOT_DELETE
, errp
)) {
1161 goto out_aio_context
;
1164 ret
= bdrv_snapshot_find_by_id_and_name(bs
, id
, name
, &sn
, &local_err
);
1166 error_propagate(errp
, local_err
);
1167 goto out_aio_context
;
1171 "Snapshot with id '%s' and name '%s' does not exist on "
1173 STR_OR_NULL(id
), STR_OR_NULL(name
), device
);
1174 goto out_aio_context
;
1177 bdrv_snapshot_delete(bs
, id
, name
, &local_err
);
1179 error_propagate(errp
, local_err
);
1180 goto out_aio_context
;
1183 aio_context_release(aio_context
);
1185 info
= g_new0(SnapshotInfo
, 1);
1186 info
->id
= g_strdup(sn
.id_str
);
1187 info
->name
= g_strdup(sn
.name
);
1188 info
->date_nsec
= sn
.date_nsec
;
1189 info
->date_sec
= sn
.date_sec
;
1190 info
->vm_state_size
= sn
.vm_state_size
;
1191 info
->vm_clock_nsec
= sn
.vm_clock_nsec
% 1000000000;
1192 info
->vm_clock_sec
= sn
.vm_clock_nsec
/ 1000000000;
1197 aio_context_release(aio_context
);
1201 /* New and old BlockDriverState structs for atomic group operations */
1203 typedef struct BlkActionState BlkActionState
;
1207 * Table of operations that define an Action.
1209 * @instance_size: Size of state struct, in bytes.
1210 * @prepare: Prepare the work, must NOT be NULL.
1211 * @commit: Commit the changes, can be NULL.
1212 * @abort: Abort the changes on fail, can be NULL.
1213 * @clean: Clean up resources after all transaction actions have called
1214 * commit() or abort(). Can be NULL.
1216 * Only prepare() may fail. In a single transaction, only one of commit() or
1217 * abort() will be called. clean() will always be called if it is present.
1219 typedef struct BlkActionOps
{
1220 size_t instance_size
;
1221 void (*prepare
)(BlkActionState
*common
, Error
**errp
);
1222 void (*commit
)(BlkActionState
*common
);
1223 void (*abort
)(BlkActionState
*common
);
1224 void (*clean
)(BlkActionState
*common
);
1229 * Describes one Action's state within a Transaction.
1231 * @action: QAPI-defined enum identifying which Action to perform.
1232 * @ops: Table of ActionOps this Action can perform.
1233 * @block_job_txn: Transaction which this action belongs to.
1234 * @entry: List membership for all Actions in this Transaction.
1236 * This structure must be arranged as first member in a subclassed type,
1237 * assuming that the compiler will also arrange it to the same offsets as the
1240 struct BlkActionState
{
1241 TransactionAction
*action
;
1242 const BlkActionOps
*ops
;
1243 JobTxn
*block_job_txn
;
1244 TransactionProperties
*txn_props
;
1245 QTAILQ_ENTRY(BlkActionState
) entry
;
1248 /* internal snapshot private data */
1249 typedef struct InternalSnapshotState
{
1250 BlkActionState common
;
1251 BlockDriverState
*bs
;
1252 QEMUSnapshotInfo sn
;
1254 } InternalSnapshotState
;
1257 static int action_check_completion_mode(BlkActionState
*s
, Error
**errp
)
1259 if (s
->txn_props
->completion_mode
!= ACTION_COMPLETION_MODE_INDIVIDUAL
) {
1261 "Action '%s' does not support Transaction property "
1262 "completion-mode = %s",
1263 TransactionActionKind_str(s
->action
->type
),
1264 ActionCompletionMode_str(s
->txn_props
->completion_mode
));
1270 static void internal_snapshot_prepare(BlkActionState
*common
,
1273 Error
*local_err
= NULL
;
1276 BlockDriverState
*bs
;
1277 QEMUSnapshotInfo old_sn
, *sn
;
1280 BlockdevSnapshotInternal
*internal
;
1281 InternalSnapshotState
*state
;
1282 AioContext
*aio_context
;
1285 g_assert(common
->action
->type
==
1286 TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_INTERNAL_SYNC
);
1287 internal
= common
->action
->u
.blockdev_snapshot_internal_sync
.data
;
1288 state
= DO_UPCAST(InternalSnapshotState
, common
, common
);
1290 /* 1. parse input */
1291 device
= internal
->device
;
1292 name
= internal
->name
;
1294 /* 2. check for validation */
1295 if (action_check_completion_mode(common
, errp
) < 0) {
1299 bs
= qmp_get_root_bs(device
, errp
);
1304 aio_context
= bdrv_get_aio_context(bs
);
1305 aio_context_acquire(aio_context
);
1309 /* Paired with .clean() */
1310 bdrv_drained_begin(bs
);
1312 if (bdrv_op_is_blocked(bs
, BLOCK_OP_TYPE_INTERNAL_SNAPSHOT
, errp
)) {
1316 if (bdrv_is_read_only(bs
)) {
1317 error_setg(errp
, "Device '%s' is read only", device
);
1321 if (!bdrv_can_snapshot(bs
)) {
1322 error_setg(errp
, "Block format '%s' used by device '%s' "
1323 "does not support internal snapshots",
1324 bs
->drv
->format_name
, device
);
1328 if (!strlen(name
)) {
1329 error_setg(errp
, "Name is empty");
1333 /* check whether a snapshot with name exist */
1334 ret
= bdrv_snapshot_find_by_id_and_name(bs
, NULL
, name
, &old_sn
,
1337 error_propagate(errp
, local_err
);
1341 "Snapshot with name '%s' already exists on device '%s'",
1346 /* 3. take the snapshot */
1348 pstrcpy(sn
->name
, sizeof(sn
->name
), name
);
1349 qemu_gettimeofday(&tv
);
1350 sn
->date_sec
= tv
.tv_sec
;
1351 sn
->date_nsec
= tv
.tv_usec
* 1000;
1352 sn
->vm_clock_nsec
= qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
);
1354 ret1
= bdrv_snapshot_create(bs
, sn
);
1356 error_setg_errno(errp
, -ret1
,
1357 "Failed to create snapshot '%s' on device '%s'",
1362 /* 4. succeed, mark a snapshot is created */
1363 state
->created
= true;
1366 aio_context_release(aio_context
);
1369 static void internal_snapshot_abort(BlkActionState
*common
)
1371 InternalSnapshotState
*state
=
1372 DO_UPCAST(InternalSnapshotState
, common
, common
);
1373 BlockDriverState
*bs
= state
->bs
;
1374 QEMUSnapshotInfo
*sn
= &state
->sn
;
1375 AioContext
*aio_context
;
1376 Error
*local_error
= NULL
;
1378 if (!state
->created
) {
1382 aio_context
= bdrv_get_aio_context(state
->bs
);
1383 aio_context_acquire(aio_context
);
1385 if (bdrv_snapshot_delete(bs
, sn
->id_str
, sn
->name
, &local_error
) < 0) {
1386 error_reportf_err(local_error
,
1387 "Failed to delete snapshot with id '%s' and "
1388 "name '%s' on device '%s' in abort: ",
1389 sn
->id_str
, sn
->name
,
1390 bdrv_get_device_name(bs
));
1393 aio_context_release(aio_context
);
1396 static void internal_snapshot_clean(BlkActionState
*common
)
1398 InternalSnapshotState
*state
= DO_UPCAST(InternalSnapshotState
,
1400 AioContext
*aio_context
;
1406 aio_context
= bdrv_get_aio_context(state
->bs
);
1407 aio_context_acquire(aio_context
);
1409 bdrv_drained_end(state
->bs
);
1411 aio_context_release(aio_context
);
1414 /* external snapshot private data */
1415 typedef struct ExternalSnapshotState
{
1416 BlkActionState common
;
1417 BlockDriverState
*old_bs
;
1418 BlockDriverState
*new_bs
;
1419 bool overlay_appended
;
1420 } ExternalSnapshotState
;
1422 static void external_snapshot_prepare(BlkActionState
*common
,
1426 QDict
*options
= NULL
;
1427 Error
*local_err
= NULL
;
1428 /* Device and node name of the image to generate the snapshot from */
1430 const char *node_name
;
1431 /* Reference to the new image (for 'blockdev-snapshot') */
1432 const char *snapshot_ref
;
1433 /* File name of the new image (for 'blockdev-snapshot-sync') */
1434 const char *new_image_file
;
1435 ExternalSnapshotState
*state
=
1436 DO_UPCAST(ExternalSnapshotState
, common
, common
);
1437 TransactionAction
*action
= common
->action
;
1438 AioContext
*aio_context
;
1439 uint64_t perm
, shared
;
1441 /* 'blockdev-snapshot' and 'blockdev-snapshot-sync' have similar
1442 * purpose but a different set of parameters */
1443 switch (action
->type
) {
1444 case TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT
:
1446 BlockdevSnapshot
*s
= action
->u
.blockdev_snapshot
.data
;
1448 node_name
= s
->node
;
1449 new_image_file
= NULL
;
1450 snapshot_ref
= s
->overlay
;
1453 case TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_SYNC
:
1455 BlockdevSnapshotSync
*s
= action
->u
.blockdev_snapshot_sync
.data
;
1456 device
= s
->has_device
? s
->device
: NULL
;
1457 node_name
= s
->has_node_name
? s
->node_name
: NULL
;
1458 new_image_file
= s
->snapshot_file
;
1459 snapshot_ref
= NULL
;
1463 g_assert_not_reached();
1466 /* start processing */
1467 if (action_check_completion_mode(common
, errp
) < 0) {
1471 state
->old_bs
= bdrv_lookup_bs(device
, node_name
, errp
);
1472 if (!state
->old_bs
) {
1476 aio_context
= bdrv_get_aio_context(state
->old_bs
);
1477 aio_context_acquire(aio_context
);
1479 /* Paired with .clean() */
1480 bdrv_drained_begin(state
->old_bs
);
1482 if (!bdrv_is_inserted(state
->old_bs
)) {
1483 error_setg(errp
, QERR_DEVICE_HAS_NO_MEDIUM
, device
);
1487 if (bdrv_op_is_blocked(state
->old_bs
,
1488 BLOCK_OP_TYPE_EXTERNAL_SNAPSHOT
, errp
)) {
1492 if (!bdrv_is_read_only(state
->old_bs
)) {
1493 if (bdrv_flush(state
->old_bs
)) {
1494 error_setg(errp
, QERR_IO_ERROR
);
1499 if (action
->type
== TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_SYNC
) {
1500 BlockdevSnapshotSync
*s
= action
->u
.blockdev_snapshot_sync
.data
;
1501 const char *format
= s
->has_format
? s
->format
: "qcow2";
1502 enum NewImageMode mode
;
1503 const char *snapshot_node_name
=
1504 s
->has_snapshot_node_name
? s
->snapshot_node_name
: NULL
;
1506 if (node_name
&& !snapshot_node_name
) {
1507 error_setg(errp
, "New overlay node name missing");
1511 if (snapshot_node_name
&&
1512 bdrv_lookup_bs(snapshot_node_name
, snapshot_node_name
, NULL
)) {
1513 error_setg(errp
, "New overlay node name already in use");
1517 flags
= state
->old_bs
->open_flags
;
1518 flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_COPY_ON_READ
);
1519 flags
|= BDRV_O_NO_BACKING
;
1521 /* create new image w/backing file */
1522 mode
= s
->has_mode
? s
->mode
: NEW_IMAGE_MODE_ABSOLUTE_PATHS
;
1523 if (mode
!= NEW_IMAGE_MODE_EXISTING
) {
1524 int64_t size
= bdrv_getlength(state
->old_bs
);
1526 error_setg_errno(errp
, -size
, "bdrv_getlength failed");
1529 bdrv_refresh_filename(state
->old_bs
);
1530 bdrv_img_create(new_image_file
, format
,
1531 state
->old_bs
->filename
,
1532 state
->old_bs
->drv
->format_name
,
1533 NULL
, size
, flags
, false, &local_err
);
1535 error_propagate(errp
, local_err
);
1540 options
= qdict_new();
1541 if (snapshot_node_name
) {
1542 qdict_put_str(options
, "node-name", snapshot_node_name
);
1544 qdict_put_str(options
, "driver", format
);
1547 state
->new_bs
= bdrv_open(new_image_file
, snapshot_ref
, options
, flags
,
1549 /* We will manually add the backing_hd field to the bs later */
1550 if (!state
->new_bs
) {
1555 * Allow attaching a backing file to an overlay that's already in use only
1556 * if the parents don't assume that they are already seeing a valid image.
1557 * (Specifically, allow it as a mirror target, which is write-only access.)
1559 bdrv_get_cumulative_perm(state
->new_bs
, &perm
, &shared
);
1560 if (perm
& BLK_PERM_CONSISTENT_READ
) {
1561 error_setg(errp
, "The overlay is already in use");
1565 if (state
->new_bs
->drv
->is_filter
) {
1566 error_setg(errp
, "Filters cannot be used as overlays");
1570 if (bdrv_cow_child(state
->new_bs
)) {
1571 error_setg(errp
, "The overlay already has a backing image");
1575 if (!state
->new_bs
->drv
->supports_backing
) {
1576 error_setg(errp
, "The overlay does not support backing images");
1580 /* This removes our old bs and adds the new bs. This is an operation that
1581 * can fail, so we need to do it in .prepare; undoing it for abort is
1582 * always possible. */
1583 bdrv_ref(state
->new_bs
);
1584 bdrv_append(state
->new_bs
, state
->old_bs
, &local_err
);
1586 error_propagate(errp
, local_err
);
1589 state
->overlay_appended
= true;
1592 aio_context_release(aio_context
);
1595 static void external_snapshot_commit(BlkActionState
*common
)
1597 ExternalSnapshotState
*state
=
1598 DO_UPCAST(ExternalSnapshotState
, common
, common
);
1599 AioContext
*aio_context
;
1601 aio_context
= bdrv_get_aio_context(state
->old_bs
);
1602 aio_context_acquire(aio_context
);
1604 /* We don't need (or want) to use the transactional
1605 * bdrv_reopen_multiple() across all the entries at once, because we
1606 * don't want to abort all of them if one of them fails the reopen */
1607 if (!atomic_read(&state
->old_bs
->copy_on_read
)) {
1608 bdrv_reopen_set_read_only(state
->old_bs
, true, NULL
);
1611 aio_context_release(aio_context
);
1614 static void external_snapshot_abort(BlkActionState
*common
)
1616 ExternalSnapshotState
*state
=
1617 DO_UPCAST(ExternalSnapshotState
, common
, common
);
1618 if (state
->new_bs
) {
1619 if (state
->overlay_appended
) {
1620 AioContext
*aio_context
;
1621 AioContext
*tmp_context
;
1624 aio_context
= bdrv_get_aio_context(state
->old_bs
);
1625 aio_context_acquire(aio_context
);
1627 bdrv_ref(state
->old_bs
); /* we can't let bdrv_set_backind_hd()
1628 close state->old_bs; we need it */
1629 bdrv_set_backing_hd(state
->new_bs
, NULL
, &error_abort
);
1632 * The call to bdrv_set_backing_hd() above returns state->old_bs to
1633 * the main AioContext. As we're still going to be using it, return
1634 * it to the AioContext it was before.
1636 tmp_context
= bdrv_get_aio_context(state
->old_bs
);
1637 if (aio_context
!= tmp_context
) {
1638 aio_context_release(aio_context
);
1639 aio_context_acquire(tmp_context
);
1641 ret
= bdrv_try_set_aio_context(state
->old_bs
,
1645 aio_context_release(tmp_context
);
1646 aio_context_acquire(aio_context
);
1649 bdrv_replace_node(state
->new_bs
, state
->old_bs
, &error_abort
);
1650 bdrv_unref(state
->old_bs
); /* bdrv_replace_node() ref'ed old_bs */
1652 aio_context_release(aio_context
);
1657 static void external_snapshot_clean(BlkActionState
*common
)
1659 ExternalSnapshotState
*state
=
1660 DO_UPCAST(ExternalSnapshotState
, common
, common
);
1661 AioContext
*aio_context
;
1663 if (!state
->old_bs
) {
1667 aio_context
= bdrv_get_aio_context(state
->old_bs
);
1668 aio_context_acquire(aio_context
);
1670 bdrv_drained_end(state
->old_bs
);
1671 bdrv_unref(state
->new_bs
);
1673 aio_context_release(aio_context
);
1676 typedef struct DriveBackupState
{
1677 BlkActionState common
;
1678 BlockDriverState
*bs
;
1682 static BlockJob
*do_backup_common(BackupCommon
*backup
,
1683 BlockDriverState
*bs
,
1684 BlockDriverState
*target_bs
,
1685 AioContext
*aio_context
,
1686 JobTxn
*txn
, Error
**errp
);
1688 static void drive_backup_prepare(BlkActionState
*common
, Error
**errp
)
1690 DriveBackupState
*state
= DO_UPCAST(DriveBackupState
, common
, common
);
1691 DriveBackup
*backup
;
1692 BlockDriverState
*bs
;
1693 BlockDriverState
*target_bs
;
1694 BlockDriverState
*source
= NULL
;
1695 AioContext
*aio_context
;
1696 AioContext
*old_context
;
1698 Error
*local_err
= NULL
;
1701 bool set_backing_hd
= false;
1704 assert(common
->action
->type
== TRANSACTION_ACTION_KIND_DRIVE_BACKUP
);
1705 backup
= common
->action
->u
.drive_backup
.data
;
1707 if (!backup
->has_mode
) {
1708 backup
->mode
= NEW_IMAGE_MODE_ABSOLUTE_PATHS
;
1711 bs
= bdrv_lookup_bs(backup
->device
, backup
->device
, errp
);
1717 error_setg(errp
, "Device has no medium");
1721 aio_context
= bdrv_get_aio_context(bs
);
1722 aio_context_acquire(aio_context
);
1724 /* Paired with .clean() */
1725 bdrv_drained_begin(bs
);
1727 if (!backup
->has_format
) {
1728 backup
->format
= backup
->mode
== NEW_IMAGE_MODE_EXISTING
?
1729 NULL
: (char *) bs
->drv
->format_name
;
1732 /* Early check to avoid creating target */
1733 if (bdrv_op_is_blocked(bs
, BLOCK_OP_TYPE_BACKUP_SOURCE
, errp
)) {
1737 flags
= bs
->open_flags
| BDRV_O_RDWR
;
1740 * See if we have a backing HD we can use to create our new image
1743 if (backup
->sync
== MIRROR_SYNC_MODE_TOP
) {
1744 source
= backing_bs(bs
);
1746 backup
->sync
= MIRROR_SYNC_MODE_FULL
;
1749 if (backup
->sync
== MIRROR_SYNC_MODE_NONE
) {
1751 flags
|= BDRV_O_NO_BACKING
;
1752 set_backing_hd
= true;
1755 size
= bdrv_getlength(bs
);
1757 error_setg_errno(errp
, -size
, "bdrv_getlength failed");
1761 if (backup
->mode
!= NEW_IMAGE_MODE_EXISTING
) {
1762 assert(backup
->format
);
1764 bdrv_refresh_filename(source
);
1765 bdrv_img_create(backup
->target
, backup
->format
, source
->filename
,
1766 source
->drv
->format_name
, NULL
,
1767 size
, flags
, false, &local_err
);
1769 bdrv_img_create(backup
->target
, backup
->format
, NULL
, NULL
, NULL
,
1770 size
, flags
, false, &local_err
);
1775 error_propagate(errp
, local_err
);
1779 options
= qdict_new();
1780 qdict_put_str(options
, "discard", "unmap");
1781 qdict_put_str(options
, "detect-zeroes", "unmap");
1782 if (backup
->format
) {
1783 qdict_put_str(options
, "driver", backup
->format
);
1786 target_bs
= bdrv_open(backup
->target
, NULL
, options
, flags
, errp
);
1791 /* Honor bdrv_try_set_aio_context() context acquisition requirements. */
1792 old_context
= bdrv_get_aio_context(target_bs
);
1793 aio_context_release(aio_context
);
1794 aio_context_acquire(old_context
);
1796 ret
= bdrv_try_set_aio_context(target_bs
, aio_context
, errp
);
1798 bdrv_unref(target_bs
);
1799 aio_context_release(old_context
);
1803 aio_context_release(old_context
);
1804 aio_context_acquire(aio_context
);
1806 if (set_backing_hd
) {
1807 bdrv_set_backing_hd(target_bs
, source
, &local_err
);
1815 state
->job
= do_backup_common(qapi_DriveBackup_base(backup
),
1816 bs
, target_bs
, aio_context
,
1817 common
->block_job_txn
, errp
);
1820 bdrv_unref(target_bs
);
1822 aio_context_release(aio_context
);
1825 static void drive_backup_commit(BlkActionState
*common
)
1827 DriveBackupState
*state
= DO_UPCAST(DriveBackupState
, common
, common
);
1828 AioContext
*aio_context
;
1830 aio_context
= bdrv_get_aio_context(state
->bs
);
1831 aio_context_acquire(aio_context
);
1834 job_start(&state
->job
->job
);
1836 aio_context_release(aio_context
);
1839 static void drive_backup_abort(BlkActionState
*common
)
1841 DriveBackupState
*state
= DO_UPCAST(DriveBackupState
, common
, common
);
1844 AioContext
*aio_context
;
1846 aio_context
= bdrv_get_aio_context(state
->bs
);
1847 aio_context_acquire(aio_context
);
1849 job_cancel_sync(&state
->job
->job
);
1851 aio_context_release(aio_context
);
1855 static void drive_backup_clean(BlkActionState
*common
)
1857 DriveBackupState
*state
= DO_UPCAST(DriveBackupState
, common
, common
);
1858 AioContext
*aio_context
;
1864 aio_context
= bdrv_get_aio_context(state
->bs
);
1865 aio_context_acquire(aio_context
);
1867 bdrv_drained_end(state
->bs
);
1869 aio_context_release(aio_context
);
1872 typedef struct BlockdevBackupState
{
1873 BlkActionState common
;
1874 BlockDriverState
*bs
;
1876 } BlockdevBackupState
;
1878 static void blockdev_backup_prepare(BlkActionState
*common
, Error
**errp
)
1880 BlockdevBackupState
*state
= DO_UPCAST(BlockdevBackupState
, common
, common
);
1881 BlockdevBackup
*backup
;
1882 BlockDriverState
*bs
;
1883 BlockDriverState
*target_bs
;
1884 AioContext
*aio_context
;
1885 AioContext
*old_context
;
1888 assert(common
->action
->type
== TRANSACTION_ACTION_KIND_BLOCKDEV_BACKUP
);
1889 backup
= common
->action
->u
.blockdev_backup
.data
;
1891 bs
= bdrv_lookup_bs(backup
->device
, backup
->device
, errp
);
1896 target_bs
= bdrv_lookup_bs(backup
->target
, backup
->target
, errp
);
1901 /* Honor bdrv_try_set_aio_context() context acquisition requirements. */
1902 aio_context
= bdrv_get_aio_context(bs
);
1903 old_context
= bdrv_get_aio_context(target_bs
);
1904 aio_context_acquire(old_context
);
1906 ret
= bdrv_try_set_aio_context(target_bs
, aio_context
, errp
);
1908 aio_context_release(old_context
);
1912 aio_context_release(old_context
);
1913 aio_context_acquire(aio_context
);
1916 /* Paired with .clean() */
1917 bdrv_drained_begin(state
->bs
);
1919 state
->job
= do_backup_common(qapi_BlockdevBackup_base(backup
),
1920 bs
, target_bs
, aio_context
,
1921 common
->block_job_txn
, errp
);
1923 aio_context_release(aio_context
);
1926 static void blockdev_backup_commit(BlkActionState
*common
)
1928 BlockdevBackupState
*state
= DO_UPCAST(BlockdevBackupState
, common
, common
);
1929 AioContext
*aio_context
;
1931 aio_context
= bdrv_get_aio_context(state
->bs
);
1932 aio_context_acquire(aio_context
);
1935 job_start(&state
->job
->job
);
1937 aio_context_release(aio_context
);
1940 static void blockdev_backup_abort(BlkActionState
*common
)
1942 BlockdevBackupState
*state
= DO_UPCAST(BlockdevBackupState
, common
, common
);
1945 AioContext
*aio_context
;
1947 aio_context
= bdrv_get_aio_context(state
->bs
);
1948 aio_context_acquire(aio_context
);
1950 job_cancel_sync(&state
->job
->job
);
1952 aio_context_release(aio_context
);
1956 static void blockdev_backup_clean(BlkActionState
*common
)
1958 BlockdevBackupState
*state
= DO_UPCAST(BlockdevBackupState
, common
, common
);
1959 AioContext
*aio_context
;
1965 aio_context
= bdrv_get_aio_context(state
->bs
);
1966 aio_context_acquire(aio_context
);
1968 bdrv_drained_end(state
->bs
);
1970 aio_context_release(aio_context
);
1973 typedef struct BlockDirtyBitmapState
{
1974 BlkActionState common
;
1975 BdrvDirtyBitmap
*bitmap
;
1976 BlockDriverState
*bs
;
1980 } BlockDirtyBitmapState
;
1982 static void block_dirty_bitmap_add_prepare(BlkActionState
*common
,
1985 Error
*local_err
= NULL
;
1986 BlockDirtyBitmapAdd
*action
;
1987 BlockDirtyBitmapState
*state
= DO_UPCAST(BlockDirtyBitmapState
,
1990 if (action_check_completion_mode(common
, errp
) < 0) {
1994 action
= common
->action
->u
.block_dirty_bitmap_add
.data
;
1995 /* AIO context taken and released within qmp_block_dirty_bitmap_add */
1996 qmp_block_dirty_bitmap_add(action
->node
, action
->name
,
1997 action
->has_granularity
, action
->granularity
,
1998 action
->has_persistent
, action
->persistent
,
1999 action
->has_disabled
, action
->disabled
,
2003 state
->prepared
= true;
2005 error_propagate(errp
, local_err
);
2009 static void block_dirty_bitmap_add_abort(BlkActionState
*common
)
2011 BlockDirtyBitmapAdd
*action
;
2012 BlockDirtyBitmapState
*state
= DO_UPCAST(BlockDirtyBitmapState
,
2015 action
= common
->action
->u
.block_dirty_bitmap_add
.data
;
2016 /* Should not be able to fail: IF the bitmap was added via .prepare(),
2017 * then the node reference and bitmap name must have been valid.
2019 if (state
->prepared
) {
2020 qmp_block_dirty_bitmap_remove(action
->node
, action
->name
, &error_abort
);
2024 static void block_dirty_bitmap_clear_prepare(BlkActionState
*common
,
2027 BlockDirtyBitmapState
*state
= DO_UPCAST(BlockDirtyBitmapState
,
2029 BlockDirtyBitmap
*action
;
2031 if (action_check_completion_mode(common
, errp
) < 0) {
2035 action
= common
->action
->u
.block_dirty_bitmap_clear
.data
;
2036 state
->bitmap
= block_dirty_bitmap_lookup(action
->node
,
2040 if (!state
->bitmap
) {
2044 if (bdrv_dirty_bitmap_check(state
->bitmap
, BDRV_BITMAP_DEFAULT
, errp
)) {
2048 bdrv_clear_dirty_bitmap(state
->bitmap
, &state
->backup
);
2051 static void block_dirty_bitmap_restore(BlkActionState
*common
)
2053 BlockDirtyBitmapState
*state
= DO_UPCAST(BlockDirtyBitmapState
,
2056 if (state
->backup
) {
2057 bdrv_restore_dirty_bitmap(state
->bitmap
, state
->backup
);
2061 static void block_dirty_bitmap_free_backup(BlkActionState
*common
)
2063 BlockDirtyBitmapState
*state
= DO_UPCAST(BlockDirtyBitmapState
,
2066 hbitmap_free(state
->backup
);
2069 static void block_dirty_bitmap_enable_prepare(BlkActionState
*common
,
2072 BlockDirtyBitmap
*action
;
2073 BlockDirtyBitmapState
*state
= DO_UPCAST(BlockDirtyBitmapState
,
2076 if (action_check_completion_mode(common
, errp
) < 0) {
2080 action
= common
->action
->u
.block_dirty_bitmap_enable
.data
;
2081 state
->bitmap
= block_dirty_bitmap_lookup(action
->node
,
2085 if (!state
->bitmap
) {
2089 if (bdrv_dirty_bitmap_check(state
->bitmap
, BDRV_BITMAP_ALLOW_RO
, errp
)) {
2093 state
->was_enabled
= bdrv_dirty_bitmap_enabled(state
->bitmap
);
2094 bdrv_enable_dirty_bitmap(state
->bitmap
);
2097 static void block_dirty_bitmap_enable_abort(BlkActionState
*common
)
2099 BlockDirtyBitmapState
*state
= DO_UPCAST(BlockDirtyBitmapState
,
2102 if (!state
->was_enabled
) {
2103 bdrv_disable_dirty_bitmap(state
->bitmap
);
2107 static void block_dirty_bitmap_disable_prepare(BlkActionState
*common
,
2110 BlockDirtyBitmap
*action
;
2111 BlockDirtyBitmapState
*state
= DO_UPCAST(BlockDirtyBitmapState
,
2114 if (action_check_completion_mode(common
, errp
) < 0) {
2118 action
= common
->action
->u
.block_dirty_bitmap_disable
.data
;
2119 state
->bitmap
= block_dirty_bitmap_lookup(action
->node
,
2123 if (!state
->bitmap
) {
2127 if (bdrv_dirty_bitmap_check(state
->bitmap
, BDRV_BITMAP_ALLOW_RO
, errp
)) {
2131 state
->was_enabled
= bdrv_dirty_bitmap_enabled(state
->bitmap
);
2132 bdrv_disable_dirty_bitmap(state
->bitmap
);
2135 static void block_dirty_bitmap_disable_abort(BlkActionState
*common
)
2137 BlockDirtyBitmapState
*state
= DO_UPCAST(BlockDirtyBitmapState
,
2140 if (state
->was_enabled
) {
2141 bdrv_enable_dirty_bitmap(state
->bitmap
);
2145 static void block_dirty_bitmap_merge_prepare(BlkActionState
*common
,
2148 BlockDirtyBitmapMerge
*action
;
2149 BlockDirtyBitmapState
*state
= DO_UPCAST(BlockDirtyBitmapState
,
2152 if (action_check_completion_mode(common
, errp
) < 0) {
2156 action
= common
->action
->u
.block_dirty_bitmap_merge
.data
;
2158 state
->bitmap
= block_dirty_bitmap_merge(action
->node
, action
->target
,
2159 action
->bitmaps
, &state
->backup
,
2163 static void block_dirty_bitmap_remove_prepare(BlkActionState
*common
,
2166 BlockDirtyBitmap
*action
;
2167 BlockDirtyBitmapState
*state
= DO_UPCAST(BlockDirtyBitmapState
,
2170 if (action_check_completion_mode(common
, errp
) < 0) {
2174 action
= common
->action
->u
.block_dirty_bitmap_remove
.data
;
2176 state
->bitmap
= block_dirty_bitmap_remove(action
->node
, action
->name
,
2177 false, &state
->bs
, errp
);
2178 if (state
->bitmap
) {
2179 bdrv_dirty_bitmap_skip_store(state
->bitmap
, true);
2180 bdrv_dirty_bitmap_set_busy(state
->bitmap
, true);
2184 static void block_dirty_bitmap_remove_abort(BlkActionState
*common
)
2186 BlockDirtyBitmapState
*state
= DO_UPCAST(BlockDirtyBitmapState
,
2189 if (state
->bitmap
) {
2190 bdrv_dirty_bitmap_skip_store(state
->bitmap
, false);
2191 bdrv_dirty_bitmap_set_busy(state
->bitmap
, false);
2195 static void block_dirty_bitmap_remove_commit(BlkActionState
*common
)
2197 BlockDirtyBitmapState
*state
= DO_UPCAST(BlockDirtyBitmapState
,
2200 bdrv_dirty_bitmap_set_busy(state
->bitmap
, false);
2201 bdrv_release_dirty_bitmap(state
->bitmap
);
2204 static void abort_prepare(BlkActionState
*common
, Error
**errp
)
2206 error_setg(errp
, "Transaction aborted using Abort action");
2209 static void abort_commit(BlkActionState
*common
)
2211 g_assert_not_reached(); /* this action never succeeds */
2214 static const BlkActionOps actions
[] = {
2215 [TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT
] = {
2216 .instance_size
= sizeof(ExternalSnapshotState
),
2217 .prepare
= external_snapshot_prepare
,
2218 .commit
= external_snapshot_commit
,
2219 .abort
= external_snapshot_abort
,
2220 .clean
= external_snapshot_clean
,
2222 [TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_SYNC
] = {
2223 .instance_size
= sizeof(ExternalSnapshotState
),
2224 .prepare
= external_snapshot_prepare
,
2225 .commit
= external_snapshot_commit
,
2226 .abort
= external_snapshot_abort
,
2227 .clean
= external_snapshot_clean
,
2229 [TRANSACTION_ACTION_KIND_DRIVE_BACKUP
] = {
2230 .instance_size
= sizeof(DriveBackupState
),
2231 .prepare
= drive_backup_prepare
,
2232 .commit
= drive_backup_commit
,
2233 .abort
= drive_backup_abort
,
2234 .clean
= drive_backup_clean
,
2236 [TRANSACTION_ACTION_KIND_BLOCKDEV_BACKUP
] = {
2237 .instance_size
= sizeof(BlockdevBackupState
),
2238 .prepare
= blockdev_backup_prepare
,
2239 .commit
= blockdev_backup_commit
,
2240 .abort
= blockdev_backup_abort
,
2241 .clean
= blockdev_backup_clean
,
2243 [TRANSACTION_ACTION_KIND_ABORT
] = {
2244 .instance_size
= sizeof(BlkActionState
),
2245 .prepare
= abort_prepare
,
2246 .commit
= abort_commit
,
2248 [TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_INTERNAL_SYNC
] = {
2249 .instance_size
= sizeof(InternalSnapshotState
),
2250 .prepare
= internal_snapshot_prepare
,
2251 .abort
= internal_snapshot_abort
,
2252 .clean
= internal_snapshot_clean
,
2254 [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_ADD
] = {
2255 .instance_size
= sizeof(BlockDirtyBitmapState
),
2256 .prepare
= block_dirty_bitmap_add_prepare
,
2257 .abort
= block_dirty_bitmap_add_abort
,
2259 [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_CLEAR
] = {
2260 .instance_size
= sizeof(BlockDirtyBitmapState
),
2261 .prepare
= block_dirty_bitmap_clear_prepare
,
2262 .commit
= block_dirty_bitmap_free_backup
,
2263 .abort
= block_dirty_bitmap_restore
,
2265 [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_ENABLE
] = {
2266 .instance_size
= sizeof(BlockDirtyBitmapState
),
2267 .prepare
= block_dirty_bitmap_enable_prepare
,
2268 .abort
= block_dirty_bitmap_enable_abort
,
2270 [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_DISABLE
] = {
2271 .instance_size
= sizeof(BlockDirtyBitmapState
),
2272 .prepare
= block_dirty_bitmap_disable_prepare
,
2273 .abort
= block_dirty_bitmap_disable_abort
,
2275 [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_MERGE
] = {
2276 .instance_size
= sizeof(BlockDirtyBitmapState
),
2277 .prepare
= block_dirty_bitmap_merge_prepare
,
2278 .commit
= block_dirty_bitmap_free_backup
,
2279 .abort
= block_dirty_bitmap_restore
,
2281 [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_REMOVE
] = {
2282 .instance_size
= sizeof(BlockDirtyBitmapState
),
2283 .prepare
= block_dirty_bitmap_remove_prepare
,
2284 .commit
= block_dirty_bitmap_remove_commit
,
2285 .abort
= block_dirty_bitmap_remove_abort
,
2287 /* Where are transactions for MIRROR, COMMIT and STREAM?
2288 * Although these blockjobs use transaction callbacks like the backup job,
2289 * these jobs do not necessarily adhere to transaction semantics.
2290 * These jobs may not fully undo all of their actions on abort, nor do they
2291 * necessarily work in transactions with more than one job in them.
2296 * Allocate a TransactionProperties structure if necessary, and fill
2297 * that structure with desired defaults if they are unset.
2299 static TransactionProperties
*get_transaction_properties(
2300 TransactionProperties
*props
)
2303 props
= g_new0(TransactionProperties
, 1);
2306 if (!props
->has_completion_mode
) {
2307 props
->has_completion_mode
= true;
2308 props
->completion_mode
= ACTION_COMPLETION_MODE_INDIVIDUAL
;
2315 * 'Atomic' group operations. The operations are performed as a set, and if
2316 * any fail then we roll back all operations in the group.
2318 void qmp_transaction(TransactionActionList
*dev_list
,
2320 struct TransactionProperties
*props
,
2323 TransactionActionList
*dev_entry
= dev_list
;
2324 JobTxn
*block_job_txn
= NULL
;
2325 BlkActionState
*state
, *next
;
2326 Error
*local_err
= NULL
;
2328 QTAILQ_HEAD(, BlkActionState
) snap_bdrv_states
;
2329 QTAILQ_INIT(&snap_bdrv_states
);
2331 /* Does this transaction get canceled as a group on failure?
2332 * If not, we don't really need to make a JobTxn.
2334 props
= get_transaction_properties(props
);
2335 if (props
->completion_mode
!= ACTION_COMPLETION_MODE_INDIVIDUAL
) {
2336 block_job_txn
= job_txn_new();
2339 /* drain all i/o before any operations */
2342 /* We don't do anything in this loop that commits us to the operations */
2343 while (NULL
!= dev_entry
) {
2344 TransactionAction
*dev_info
= NULL
;
2345 const BlkActionOps
*ops
;
2347 dev_info
= dev_entry
->value
;
2348 dev_entry
= dev_entry
->next
;
2350 assert(dev_info
->type
< ARRAY_SIZE(actions
));
2352 ops
= &actions
[dev_info
->type
];
2353 assert(ops
->instance_size
> 0);
2355 state
= g_malloc0(ops
->instance_size
);
2357 state
->action
= dev_info
;
2358 state
->block_job_txn
= block_job_txn
;
2359 state
->txn_props
= props
;
2360 QTAILQ_INSERT_TAIL(&snap_bdrv_states
, state
, entry
);
2362 state
->ops
->prepare(state
, &local_err
);
2364 error_propagate(errp
, local_err
);
2365 goto delete_and_fail
;
2369 QTAILQ_FOREACH(state
, &snap_bdrv_states
, entry
) {
2370 if (state
->ops
->commit
) {
2371 state
->ops
->commit(state
);
2379 /* failure, and it is all-or-none; roll back all operations */
2380 QTAILQ_FOREACH_REVERSE(state
, &snap_bdrv_states
, entry
) {
2381 if (state
->ops
->abort
) {
2382 state
->ops
->abort(state
);
2386 QTAILQ_FOREACH_SAFE(state
, &snap_bdrv_states
, entry
, next
) {
2387 if (state
->ops
->clean
) {
2388 state
->ops
->clean(state
);
2393 qapi_free_TransactionProperties(props
);
2395 job_txn_unref(block_job_txn
);
2398 void qmp_block_passwd(bool has_device
, const char *device
,
2399 bool has_node_name
, const char *node_name
,
2400 const char *password
, Error
**errp
)
2403 "Setting block passwords directly is no longer supported");
2406 BlockDirtyBitmapSha256
*qmp_x_debug_block_dirty_bitmap_sha256(const char *node
,
2410 BdrvDirtyBitmap
*bitmap
;
2411 BlockDriverState
*bs
;
2412 BlockDirtyBitmapSha256
*ret
= NULL
;
2415 bitmap
= block_dirty_bitmap_lookup(node
, name
, &bs
, errp
);
2416 if (!bitmap
|| !bs
) {
2420 sha256
= bdrv_dirty_bitmap_sha256(bitmap
, errp
);
2421 if (sha256
== NULL
) {
2425 ret
= g_new(BlockDirtyBitmapSha256
, 1);
2426 ret
->sha256
= sha256
;
2431 void qmp_block_resize(bool has_device
, const char *device
,
2432 bool has_node_name
, const char *node_name
,
2433 int64_t size
, Error
**errp
)
2435 Error
*local_err
= NULL
;
2436 BlockBackend
*blk
= NULL
;
2437 BlockDriverState
*bs
;
2438 AioContext
*aio_context
;
2440 bs
= bdrv_lookup_bs(has_device
? device
: NULL
,
2441 has_node_name
? node_name
: NULL
,
2444 error_propagate(errp
, local_err
);
2448 aio_context
= bdrv_get_aio_context(bs
);
2449 aio_context_acquire(aio_context
);
2452 error_setg(errp
, QERR_INVALID_PARAMETER_VALUE
, "size", "a >0 size");
2456 if (bdrv_op_is_blocked(bs
, BLOCK_OP_TYPE_RESIZE
, NULL
)) {
2457 error_setg(errp
, QERR_DEVICE_IN_USE
, device
);
2461 blk
= blk_new_with_bs(bs
, BLK_PERM_RESIZE
, BLK_PERM_ALL
, errp
);
2466 bdrv_drained_begin(bs
);
2467 blk_truncate(blk
, size
, false, PREALLOC_MODE_OFF
, 0, errp
);
2468 bdrv_drained_end(bs
);
2472 aio_context_release(aio_context
);
2475 void qmp_block_stream(bool has_job_id
, const char *job_id
, const char *device
,
2476 bool has_base
, const char *base
,
2477 bool has_base_node
, const char *base_node
,
2478 bool has_backing_file
, const char *backing_file
,
2479 bool has_speed
, int64_t speed
,
2480 bool has_on_error
, BlockdevOnError on_error
,
2481 bool has_auto_finalize
, bool auto_finalize
,
2482 bool has_auto_dismiss
, bool auto_dismiss
,
2485 BlockDriverState
*bs
, *iter
;
2486 BlockDriverState
*base_bs
= NULL
;
2487 AioContext
*aio_context
;
2488 Error
*local_err
= NULL
;
2489 const char *base_name
= NULL
;
2490 int job_flags
= JOB_DEFAULT
;
2492 if (!has_on_error
) {
2493 on_error
= BLOCKDEV_ON_ERROR_REPORT
;
2496 bs
= bdrv_lookup_bs(device
, device
, errp
);
2501 aio_context
= bdrv_get_aio_context(bs
);
2502 aio_context_acquire(aio_context
);
2504 if (has_base
&& has_base_node
) {
2505 error_setg(errp
, "'base' and 'base-node' cannot be specified "
2506 "at the same time");
2511 base_bs
= bdrv_find_backing_image(bs
, base
);
2512 if (base_bs
== NULL
) {
2513 error_setg(errp
, QERR_BASE_NOT_FOUND
, base
);
2516 assert(bdrv_get_aio_context(base_bs
) == aio_context
);
2520 if (has_base_node
) {
2521 base_bs
= bdrv_lookup_bs(NULL
, base_node
, errp
);
2525 if (bs
== base_bs
|| !bdrv_chain_contains(bs
, base_bs
)) {
2526 error_setg(errp
, "Node '%s' is not a backing image of '%s'",
2530 assert(bdrv_get_aio_context(base_bs
) == aio_context
);
2531 bdrv_refresh_filename(base_bs
);
2532 base_name
= base_bs
->filename
;
2535 /* Check for op blockers in the whole chain between bs and base */
2536 for (iter
= bs
; iter
&& iter
!= base_bs
;
2537 iter
= bdrv_filter_or_cow_bs(iter
))
2539 if (bdrv_op_is_blocked(iter
, BLOCK_OP_TYPE_STREAM
, errp
)) {
2544 /* if we are streaming the entire chain, the result will have no backing
2545 * file, and specifying one is therefore an error */
2546 if (base_bs
== NULL
&& has_backing_file
) {
2547 error_setg(errp
, "backing file specified, but streaming the "
2552 /* backing_file string overrides base bs filename */
2553 base_name
= has_backing_file
? backing_file
: base_name
;
2555 if (has_auto_finalize
&& !auto_finalize
) {
2556 job_flags
|= JOB_MANUAL_FINALIZE
;
2558 if (has_auto_dismiss
&& !auto_dismiss
) {
2559 job_flags
|= JOB_MANUAL_DISMISS
;
2562 stream_start(has_job_id
? job_id
: NULL
, bs
, base_bs
, base_name
,
2563 job_flags
, has_speed
? speed
: 0, on_error
, &local_err
);
2565 error_propagate(errp
, local_err
);
2569 trace_qmp_block_stream(bs
);
2572 aio_context_release(aio_context
);
2575 void qmp_block_commit(bool has_job_id
, const char *job_id
, const char *device
,
2576 bool has_base_node
, const char *base_node
,
2577 bool has_base
, const char *base
,
2578 bool has_top_node
, const char *top_node
,
2579 bool has_top
, const char *top
,
2580 bool has_backing_file
, const char *backing_file
,
2581 bool has_speed
, int64_t speed
,
2582 bool has_on_error
, BlockdevOnError on_error
,
2583 bool has_filter_node_name
, const char *filter_node_name
,
2584 bool has_auto_finalize
, bool auto_finalize
,
2585 bool has_auto_dismiss
, bool auto_dismiss
,
2588 BlockDriverState
*bs
;
2589 BlockDriverState
*iter
;
2590 BlockDriverState
*base_bs
, *top_bs
;
2591 AioContext
*aio_context
;
2592 Error
*local_err
= NULL
;
2593 int job_flags
= JOB_DEFAULT
;
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
);
2685 base_bs
= bdrv_find_base(top_bs
);
2688 if (base_bs
== NULL
) {
2689 error_setg(errp
, QERR_BASE_NOT_FOUND
, base
? base
: "NULL");
2693 assert(bdrv_get_aio_context(base_bs
) == aio_context
);
2695 for (iter
= top_bs
; iter
!= backing_bs(base_bs
); iter
= backing_bs(iter
)) {
2696 if (bdrv_op_is_blocked(iter
, BLOCK_OP_TYPE_COMMIT_TARGET
, errp
)) {
2701 /* Do not allow attempts to commit an image into itself */
2702 if (top_bs
== base_bs
) {
2703 error_setg(errp
, "cannot commit an image into itself");
2708 if (has_backing_file
) {
2709 error_setg(errp
, "'backing-file' specified,"
2710 " but 'top' is the active layer");
2713 commit_active_start(has_job_id
? job_id
: NULL
, bs
, base_bs
,
2714 job_flags
, speed
, on_error
,
2715 filter_node_name
, NULL
, NULL
, false, &local_err
);
2717 BlockDriverState
*overlay_bs
= bdrv_find_overlay(bs
, top_bs
);
2718 if (bdrv_op_is_blocked(overlay_bs
, BLOCK_OP_TYPE_COMMIT_TARGET
, errp
)) {
2721 commit_start(has_job_id
? job_id
: NULL
, bs
, base_bs
, top_bs
, job_flags
,
2722 speed
, on_error
, has_backing_file
? backing_file
: NULL
,
2723 filter_node_name
, &local_err
);
2725 if (local_err
!= NULL
) {
2726 error_propagate(errp
, local_err
);
2731 aio_context_release(aio_context
);
2734 /* Common QMP interface for drive-backup and blockdev-backup */
2735 static BlockJob
*do_backup_common(BackupCommon
*backup
,
2736 BlockDriverState
*bs
,
2737 BlockDriverState
*target_bs
,
2738 AioContext
*aio_context
,
2739 JobTxn
*txn
, Error
**errp
)
2741 BlockJob
*job
= NULL
;
2742 BdrvDirtyBitmap
*bmap
= NULL
;
2743 int job_flags
= JOB_DEFAULT
;
2745 if (!backup
->has_speed
) {
2748 if (!backup
->has_on_source_error
) {
2749 backup
->on_source_error
= BLOCKDEV_ON_ERROR_REPORT
;
2751 if (!backup
->has_on_target_error
) {
2752 backup
->on_target_error
= BLOCKDEV_ON_ERROR_REPORT
;
2754 if (!backup
->has_job_id
) {
2755 backup
->job_id
= NULL
;
2757 if (!backup
->has_auto_finalize
) {
2758 backup
->auto_finalize
= true;
2760 if (!backup
->has_auto_dismiss
) {
2761 backup
->auto_dismiss
= true;
2763 if (!backup
->has_compress
) {
2764 backup
->compress
= false;
2767 if ((backup
->sync
== MIRROR_SYNC_MODE_BITMAP
) ||
2768 (backup
->sync
== MIRROR_SYNC_MODE_INCREMENTAL
)) {
2769 /* done before desugaring 'incremental' to print the right message */
2770 if (!backup
->has_bitmap
) {
2771 error_setg(errp
, "must provide a valid bitmap name for "
2772 "'%s' sync mode", MirrorSyncMode_str(backup
->sync
));
2777 if (backup
->sync
== MIRROR_SYNC_MODE_INCREMENTAL
) {
2778 if (backup
->has_bitmap_mode
&&
2779 backup
->bitmap_mode
!= BITMAP_SYNC_MODE_ON_SUCCESS
) {
2780 error_setg(errp
, "Bitmap sync mode must be '%s' "
2781 "when using sync mode '%s'",
2782 BitmapSyncMode_str(BITMAP_SYNC_MODE_ON_SUCCESS
),
2783 MirrorSyncMode_str(backup
->sync
));
2786 backup
->has_bitmap_mode
= true;
2787 backup
->sync
= MIRROR_SYNC_MODE_BITMAP
;
2788 backup
->bitmap_mode
= BITMAP_SYNC_MODE_ON_SUCCESS
;
2791 if (backup
->has_bitmap
) {
2792 bmap
= bdrv_find_dirty_bitmap(bs
, backup
->bitmap
);
2794 error_setg(errp
, "Bitmap '%s' could not be found", backup
->bitmap
);
2797 if (!backup
->has_bitmap_mode
) {
2798 error_setg(errp
, "Bitmap sync mode must be given "
2799 "when providing a bitmap");
2802 if (bdrv_dirty_bitmap_check(bmap
, BDRV_BITMAP_ALLOW_RO
, errp
)) {
2806 /* This does not produce a useful bitmap artifact: */
2807 if (backup
->sync
== MIRROR_SYNC_MODE_NONE
) {
2808 error_setg(errp
, "sync mode '%s' does not produce meaningful bitmap"
2809 " outputs", MirrorSyncMode_str(backup
->sync
));
2813 /* If the bitmap isn't used for input or output, this is useless: */
2814 if (backup
->bitmap_mode
== BITMAP_SYNC_MODE_NEVER
&&
2815 backup
->sync
!= MIRROR_SYNC_MODE_BITMAP
) {
2816 error_setg(errp
, "Bitmap sync mode '%s' has no meaningful effect"
2817 " when combined with sync mode '%s'",
2818 BitmapSyncMode_str(backup
->bitmap_mode
),
2819 MirrorSyncMode_str(backup
->sync
));
2824 if (!backup
->has_bitmap
&& backup
->has_bitmap_mode
) {
2825 error_setg(errp
, "Cannot specify bitmap sync mode without a bitmap");
2829 if (!backup
->auto_finalize
) {
2830 job_flags
|= JOB_MANUAL_FINALIZE
;
2832 if (!backup
->auto_dismiss
) {
2833 job_flags
|= JOB_MANUAL_DISMISS
;
2836 job
= backup_job_create(backup
->job_id
, bs
, target_bs
, backup
->speed
,
2837 backup
->sync
, bmap
, backup
->bitmap_mode
,
2839 backup
->filter_node_name
,
2840 backup
->on_source_error
,
2841 backup
->on_target_error
,
2842 job_flags
, NULL
, NULL
, txn
, errp
);
2846 void qmp_drive_backup(DriveBackup
*backup
, Error
**errp
)
2848 TransactionAction action
= {
2849 .type
= TRANSACTION_ACTION_KIND_DRIVE_BACKUP
,
2850 .u
.drive_backup
.data
= backup
,
2852 blockdev_do_action(&action
, errp
);
2855 BlockDeviceInfoList
*qmp_query_named_block_nodes(bool has_flat
,
2859 bool return_flat
= has_flat
&& flat
;
2861 return bdrv_named_nodes_list(return_flat
, errp
);
2864 XDbgBlockGraph
*qmp_x_debug_query_block_graph(Error
**errp
)
2866 return bdrv_get_xdbg_block_graph(errp
);
2869 void qmp_blockdev_backup(BlockdevBackup
*backup
, Error
**errp
)
2871 TransactionAction action
= {
2872 .type
= TRANSACTION_ACTION_KIND_BLOCKDEV_BACKUP
,
2873 .u
.blockdev_backup
.data
= backup
,
2875 blockdev_do_action(&action
, errp
);
2878 /* Parameter check and block job starting for drive mirroring.
2879 * Caller should hold @device and @target's aio context (must be the same).
2881 static void blockdev_mirror_common(const char *job_id
, BlockDriverState
*bs
,
2882 BlockDriverState
*target
,
2883 bool has_replaces
, const char *replaces
,
2884 enum MirrorSyncMode sync
,
2885 BlockMirrorBackingMode backing_mode
,
2887 bool has_speed
, int64_t speed
,
2888 bool has_granularity
, uint32_t granularity
,
2889 bool has_buf_size
, int64_t buf_size
,
2890 bool has_on_source_error
,
2891 BlockdevOnError on_source_error
,
2892 bool has_on_target_error
,
2893 BlockdevOnError on_target_error
,
2894 bool has_unmap
, bool unmap
,
2895 bool has_filter_node_name
,
2896 const char *filter_node_name
,
2897 bool has_copy_mode
, MirrorCopyMode copy_mode
,
2898 bool has_auto_finalize
, bool auto_finalize
,
2899 bool has_auto_dismiss
, bool auto_dismiss
,
2902 BlockDriverState
*unfiltered_bs
;
2903 int job_flags
= JOB_DEFAULT
;
2908 if (!has_on_source_error
) {
2909 on_source_error
= BLOCKDEV_ON_ERROR_REPORT
;
2911 if (!has_on_target_error
) {
2912 on_target_error
= BLOCKDEV_ON_ERROR_REPORT
;
2914 if (!has_granularity
) {
2917 if (!has_buf_size
) {
2923 if (!has_filter_node_name
) {
2924 filter_node_name
= NULL
;
2926 if (!has_copy_mode
) {
2927 copy_mode
= MIRROR_COPY_MODE_BACKGROUND
;
2929 if (has_auto_finalize
&& !auto_finalize
) {
2930 job_flags
|= JOB_MANUAL_FINALIZE
;
2932 if (has_auto_dismiss
&& !auto_dismiss
) {
2933 job_flags
|= JOB_MANUAL_DISMISS
;
2936 if (granularity
!= 0 && (granularity
< 512 || granularity
> 1048576 * 64)) {
2937 error_setg(errp
, QERR_INVALID_PARAMETER_VALUE
, "granularity",
2938 "a value in range [512B, 64MB]");
2941 if (granularity
& (granularity
- 1)) {
2942 error_setg(errp
, QERR_INVALID_PARAMETER_VALUE
, "granularity",
2947 if (bdrv_op_is_blocked(bs
, BLOCK_OP_TYPE_MIRROR_SOURCE
, errp
)) {
2950 if (bdrv_op_is_blocked(target
, BLOCK_OP_TYPE_MIRROR_TARGET
, errp
)) {
2954 if (!bdrv_backing_chain_next(bs
) && sync
== MIRROR_SYNC_MODE_TOP
) {
2955 sync
= MIRROR_SYNC_MODE_FULL
;
2958 if (!has_replaces
) {
2959 /* We want to mirror from @bs, but keep implicit filters on top */
2960 unfiltered_bs
= bdrv_skip_implicit_filters(bs
);
2961 if (unfiltered_bs
!= bs
) {
2962 replaces
= unfiltered_bs
->node_name
;
2963 has_replaces
= true;
2968 BlockDriverState
*to_replace_bs
;
2969 AioContext
*replace_aio_context
;
2970 int64_t bs_size
, replace_size
;
2972 bs_size
= bdrv_getlength(bs
);
2974 error_setg_errno(errp
, -bs_size
, "Failed to query device's size");
2978 to_replace_bs
= check_to_replace_node(bs
, replaces
, errp
);
2979 if (!to_replace_bs
) {
2983 replace_aio_context
= bdrv_get_aio_context(to_replace_bs
);
2984 aio_context_acquire(replace_aio_context
);
2985 replace_size
= bdrv_getlength(to_replace_bs
);
2986 aio_context_release(replace_aio_context
);
2988 if (replace_size
< 0) {
2989 error_setg_errno(errp
, -replace_size
,
2990 "Failed to query the replacement node's size");
2993 if (bs_size
!= replace_size
) {
2994 error_setg(errp
, "cannot replace image with a mirror image of "
3000 /* pass the node name to replace to mirror start since it's loose coupling
3001 * and will allow to check whether the node still exist at mirror completion
3003 mirror_start(job_id
, bs
, target
,
3004 has_replaces
? replaces
: NULL
, job_flags
,
3005 speed
, granularity
, buf_size
, sync
, backing_mode
, zero_target
,
3006 on_source_error
, on_target_error
, unmap
, filter_node_name
,
3010 void qmp_drive_mirror(DriveMirror
*arg
, Error
**errp
)
3012 BlockDriverState
*bs
;
3013 BlockDriverState
*target_backing_bs
, *target_bs
;
3014 AioContext
*aio_context
;
3015 AioContext
*old_context
;
3016 BlockMirrorBackingMode backing_mode
;
3017 Error
*local_err
= NULL
;
3018 QDict
*options
= NULL
;
3021 const char *format
= arg
->format
;
3025 bs
= qmp_get_root_bs(arg
->device
, errp
);
3030 /* Early check to avoid creating target */
3031 if (bdrv_op_is_blocked(bs
, BLOCK_OP_TYPE_MIRROR_SOURCE
, errp
)) {
3035 aio_context
= bdrv_get_aio_context(bs
);
3036 aio_context_acquire(aio_context
);
3038 if (!arg
->has_mode
) {
3039 arg
->mode
= NEW_IMAGE_MODE_ABSOLUTE_PATHS
;
3042 if (!arg
->has_format
) {
3043 format
= (arg
->mode
== NEW_IMAGE_MODE_EXISTING
3044 ? NULL
: bs
->drv
->format_name
);
3047 flags
= bs
->open_flags
| BDRV_O_RDWR
;
3048 target_backing_bs
= bdrv_cow_bs(bdrv_skip_filters(bs
));
3049 if (!target_backing_bs
&& arg
->sync
== MIRROR_SYNC_MODE_TOP
) {
3050 arg
->sync
= MIRROR_SYNC_MODE_FULL
;
3052 if (arg
->sync
== MIRROR_SYNC_MODE_NONE
) {
3053 target_backing_bs
= bs
;
3056 size
= bdrv_getlength(bs
);
3058 error_setg_errno(errp
, -size
, "bdrv_getlength failed");
3062 if (arg
->has_replaces
) {
3063 if (!arg
->has_node_name
) {
3064 error_setg(errp
, "a node-name must be provided when replacing a"
3065 " named node of the graph");
3070 if (arg
->mode
== NEW_IMAGE_MODE_ABSOLUTE_PATHS
) {
3071 backing_mode
= MIRROR_SOURCE_BACKING_CHAIN
;
3073 backing_mode
= MIRROR_OPEN_BACKING_CHAIN
;
3076 /* Don't open backing image in create() */
3077 flags
|= BDRV_O_NO_BACKING
;
3079 if ((arg
->sync
== MIRROR_SYNC_MODE_FULL
|| !target_backing_bs
)
3080 && arg
->mode
!= NEW_IMAGE_MODE_EXISTING
)
3082 /* create new image w/o backing file */
3084 bdrv_img_create(arg
->target
, format
,
3085 NULL
, NULL
, NULL
, size
, flags
, false, &local_err
);
3087 /* Implicit filters should not appear in the filename */
3088 BlockDriverState
*explicit_backing
=
3089 bdrv_skip_implicit_filters(target_backing_bs
);
3091 switch (arg
->mode
) {
3092 case NEW_IMAGE_MODE_EXISTING
:
3094 case NEW_IMAGE_MODE_ABSOLUTE_PATHS
:
3095 /* create new image with backing file */
3096 bdrv_refresh_filename(explicit_backing
);
3097 bdrv_img_create(arg
->target
, format
,
3098 explicit_backing
->filename
,
3099 explicit_backing
->drv
->format_name
,
3100 NULL
, size
, flags
, false, &local_err
);
3108 error_propagate(errp
, local_err
);
3112 options
= qdict_new();
3113 if (arg
->has_node_name
) {
3114 qdict_put_str(options
, "node-name", arg
->node_name
);
3117 qdict_put_str(options
, "driver", format
);
3120 /* Mirroring takes care of copy-on-write using the source's backing
3123 target_bs
= bdrv_open(arg
->target
, NULL
, options
, flags
, errp
);
3128 zero_target
= (arg
->sync
== MIRROR_SYNC_MODE_FULL
&&
3129 (arg
->mode
== NEW_IMAGE_MODE_EXISTING
||
3130 !bdrv_has_zero_init(target_bs
)));
3133 /* Honor bdrv_try_set_aio_context() context acquisition requirements. */
3134 old_context
= bdrv_get_aio_context(target_bs
);
3135 aio_context_release(aio_context
);
3136 aio_context_acquire(old_context
);
3138 ret
= bdrv_try_set_aio_context(target_bs
, aio_context
, errp
);
3140 bdrv_unref(target_bs
);
3141 aio_context_release(old_context
);
3145 aio_context_release(old_context
);
3146 aio_context_acquire(aio_context
);
3148 blockdev_mirror_common(arg
->has_job_id
? arg
->job_id
: NULL
, bs
, target_bs
,
3149 arg
->has_replaces
, arg
->replaces
, arg
->sync
,
3150 backing_mode
, zero_target
,
3151 arg
->has_speed
, arg
->speed
,
3152 arg
->has_granularity
, arg
->granularity
,
3153 arg
->has_buf_size
, arg
->buf_size
,
3154 arg
->has_on_source_error
, arg
->on_source_error
,
3155 arg
->has_on_target_error
, arg
->on_target_error
,
3156 arg
->has_unmap
, arg
->unmap
,
3158 arg
->has_copy_mode
, arg
->copy_mode
,
3159 arg
->has_auto_finalize
, arg
->auto_finalize
,
3160 arg
->has_auto_dismiss
, arg
->auto_dismiss
,
3162 bdrv_unref(target_bs
);
3164 aio_context_release(aio_context
);
3167 void qmp_blockdev_mirror(bool has_job_id
, const char *job_id
,
3168 const char *device
, const char *target
,
3169 bool has_replaces
, const char *replaces
,
3170 MirrorSyncMode sync
,
3171 bool has_speed
, int64_t speed
,
3172 bool has_granularity
, uint32_t granularity
,
3173 bool has_buf_size
, int64_t buf_size
,
3174 bool has_on_source_error
,
3175 BlockdevOnError on_source_error
,
3176 bool has_on_target_error
,
3177 BlockdevOnError on_target_error
,
3178 bool has_filter_node_name
,
3179 const char *filter_node_name
,
3180 bool has_copy_mode
, MirrorCopyMode copy_mode
,
3181 bool has_auto_finalize
, bool auto_finalize
,
3182 bool has_auto_dismiss
, bool auto_dismiss
,
3185 BlockDriverState
*bs
;
3186 BlockDriverState
*target_bs
;
3187 AioContext
*aio_context
;
3188 AioContext
*old_context
;
3189 BlockMirrorBackingMode backing_mode
= MIRROR_LEAVE_BACKING_CHAIN
;
3193 bs
= qmp_get_root_bs(device
, errp
);
3198 target_bs
= bdrv_lookup_bs(target
, target
, errp
);
3203 zero_target
= (sync
== MIRROR_SYNC_MODE_FULL
);
3205 /* Honor bdrv_try_set_aio_context() context acquisition requirements. */
3206 old_context
= bdrv_get_aio_context(target_bs
);
3207 aio_context
= bdrv_get_aio_context(bs
);
3208 aio_context_acquire(old_context
);
3210 ret
= bdrv_try_set_aio_context(target_bs
, aio_context
, errp
);
3212 aio_context_release(old_context
);
3213 aio_context_acquire(aio_context
);
3219 blockdev_mirror_common(has_job_id
? job_id
: NULL
, bs
, target_bs
,
3220 has_replaces
, replaces
, sync
, backing_mode
,
3221 zero_target
, has_speed
, speed
,
3222 has_granularity
, granularity
,
3223 has_buf_size
, buf_size
,
3224 has_on_source_error
, on_source_error
,
3225 has_on_target_error
, on_target_error
,
3227 has_filter_node_name
, filter_node_name
,
3228 has_copy_mode
, copy_mode
,
3229 has_auto_finalize
, auto_finalize
,
3230 has_auto_dismiss
, auto_dismiss
,
3233 aio_context_release(aio_context
);
3236 /* Get a block job using its ID and acquire its AioContext */
3237 static BlockJob
*find_block_job(const char *id
, AioContext
**aio_context
,
3244 *aio_context
= NULL
;
3246 job
= block_job_get(id
);
3249 error_set(errp
, ERROR_CLASS_DEVICE_NOT_ACTIVE
,
3250 "Block job '%s' not found", id
);
3254 *aio_context
= blk_get_aio_context(job
->blk
);
3255 aio_context_acquire(*aio_context
);
3260 void qmp_block_job_set_speed(const char *device
, int64_t speed
, Error
**errp
)
3262 AioContext
*aio_context
;
3263 BlockJob
*job
= find_block_job(device
, &aio_context
, errp
);
3269 block_job_set_speed(job
, speed
, errp
);
3270 aio_context_release(aio_context
);
3273 void qmp_block_job_cancel(const char *device
,
3274 bool has_force
, bool force
, Error
**errp
)
3276 AioContext
*aio_context
;
3277 BlockJob
*job
= find_block_job(device
, &aio_context
, errp
);
3287 if (job_user_paused(&job
->job
) && !force
) {
3288 error_setg(errp
, "The block job for device '%s' is currently paused",
3293 trace_qmp_block_job_cancel(job
);
3294 job_user_cancel(&job
->job
, force
, errp
);
3296 aio_context_release(aio_context
);
3299 void qmp_block_job_pause(const char *device
, Error
**errp
)
3301 AioContext
*aio_context
;
3302 BlockJob
*job
= find_block_job(device
, &aio_context
, errp
);
3308 trace_qmp_block_job_pause(job
);
3309 job_user_pause(&job
->job
, errp
);
3310 aio_context_release(aio_context
);
3313 void qmp_block_job_resume(const char *device
, Error
**errp
)
3315 AioContext
*aio_context
;
3316 BlockJob
*job
= find_block_job(device
, &aio_context
, errp
);
3322 trace_qmp_block_job_resume(job
);
3323 job_user_resume(&job
->job
, errp
);
3324 aio_context_release(aio_context
);
3327 void qmp_block_job_complete(const char *device
, Error
**errp
)
3329 AioContext
*aio_context
;
3330 BlockJob
*job
= find_block_job(device
, &aio_context
, errp
);
3336 trace_qmp_block_job_complete(job
);
3337 job_complete(&job
->job
, errp
);
3338 aio_context_release(aio_context
);
3341 void qmp_block_job_finalize(const char *id
, Error
**errp
)
3343 AioContext
*aio_context
;
3344 BlockJob
*job
= find_block_job(id
, &aio_context
, errp
);
3350 trace_qmp_block_job_finalize(job
);
3352 job_finalize(&job
->job
, errp
);
3355 * Job's context might have changed via job_finalize (and job_txn_apply
3356 * automatically acquires the new one), so make sure we release the correct
3359 aio_context
= blk_get_aio_context(job
->blk
);
3360 job_unref(&job
->job
);
3361 aio_context_release(aio_context
);
3364 void qmp_block_job_dismiss(const char *id
, Error
**errp
)
3366 AioContext
*aio_context
;
3367 BlockJob
*bjob
= find_block_job(id
, &aio_context
, errp
);
3374 trace_qmp_block_job_dismiss(bjob
);
3376 job_dismiss(&job
, errp
);
3377 aio_context_release(aio_context
);
3380 void qmp_change_backing_file(const char *device
,
3381 const char *image_node_name
,
3382 const char *backing_file
,
3385 BlockDriverState
*bs
= NULL
;
3386 AioContext
*aio_context
;
3387 BlockDriverState
*image_bs
= NULL
;
3388 Error
*local_err
= NULL
;
3392 bs
= qmp_get_root_bs(device
, errp
);
3397 aio_context
= bdrv_get_aio_context(bs
);
3398 aio_context_acquire(aio_context
);
3400 image_bs
= bdrv_lookup_bs(NULL
, image_node_name
, &local_err
);
3402 error_propagate(errp
, local_err
);
3407 error_setg(errp
, "image file not found");
3411 if (bdrv_find_base(image_bs
) == image_bs
) {
3412 error_setg(errp
, "not allowing backing file change on an image "
3413 "without a backing file");
3417 /* even though we are not necessarily operating on bs, we need it to
3418 * determine if block ops are currently prohibited on the chain */
3419 if (bdrv_op_is_blocked(bs
, BLOCK_OP_TYPE_CHANGE
, errp
)) {
3423 /* final sanity check */
3424 if (!bdrv_chain_contains(bs
, image_bs
)) {
3425 error_setg(errp
, "'%s' and image file are not in the same chain",
3430 /* if not r/w, reopen to make r/w */
3431 ro
= bdrv_is_read_only(image_bs
);
3434 if (bdrv_reopen_set_read_only(image_bs
, false, errp
) != 0) {
3439 ret
= bdrv_change_backing_file(image_bs
, backing_file
,
3440 image_bs
->drv
? image_bs
->drv
->format_name
: "",
3444 error_setg_errno(errp
, -ret
, "Could not change backing file to '%s'",
3446 /* don't exit here, so we can try to restore open flags if
3451 bdrv_reopen_set_read_only(image_bs
, true, errp
);
3455 aio_context_release(aio_context
);
3458 void qmp_blockdev_add(BlockdevOptions
*options
, Error
**errp
)
3460 BlockDriverState
*bs
;
3462 Visitor
*v
= qobject_output_visitor_new(&obj
);
3465 visit_type_BlockdevOptions(v
, NULL
, &options
, &error_abort
);
3466 visit_complete(v
, &obj
);
3467 qdict
= qobject_to(QDict
, obj
);
3469 qdict_flatten(qdict
);
3471 if (!qdict_get_try_str(qdict
, "node-name")) {
3472 error_setg(errp
, "'node-name' must be specified for the root node");
3476 bs
= bds_tree_init(qdict
, errp
);
3481 bdrv_set_monitor_owned(bs
);
3487 void qmp_x_blockdev_reopen(BlockdevOptions
*options
, Error
**errp
)
3489 BlockDriverState
*bs
;
3492 Visitor
*v
= qobject_output_visitor_new(&obj
);
3493 BlockReopenQueue
*queue
;
3496 /* Check for the selected node name */
3497 if (!options
->has_node_name
) {
3498 error_setg(errp
, "Node name not specified");
3502 bs
= bdrv_find_node(options
->node_name
);
3504 error_setg(errp
, "Cannot find node named '%s'", options
->node_name
);
3508 /* Put all options in a QDict and flatten it */
3509 visit_type_BlockdevOptions(v
, NULL
, &options
, &error_abort
);
3510 visit_complete(v
, &obj
);
3511 qdict
= qobject_to(QDict
, obj
);
3513 qdict_flatten(qdict
);
3515 /* Perform the reopen operation */
3516 ctx
= bdrv_get_aio_context(bs
);
3517 aio_context_acquire(ctx
);
3518 bdrv_subtree_drained_begin(bs
);
3519 queue
= bdrv_reopen_queue(NULL
, bs
, qdict
, false);
3520 bdrv_reopen_multiple(queue
, errp
);
3521 bdrv_subtree_drained_end(bs
);
3522 aio_context_release(ctx
);
3528 void qmp_blockdev_del(const char *node_name
, Error
**errp
)
3530 AioContext
*aio_context
;
3531 BlockDriverState
*bs
;
3533 bs
= bdrv_find_node(node_name
);
3535 error_setg(errp
, "Cannot find node %s", node_name
);
3538 if (bdrv_has_blk(bs
)) {
3539 error_setg(errp
, "Node %s is in use", node_name
);
3542 aio_context
= bdrv_get_aio_context(bs
);
3543 aio_context_acquire(aio_context
);
3545 if (bdrv_op_is_blocked(bs
, BLOCK_OP_TYPE_DRIVE_DEL
, errp
)) {
3549 if (!QTAILQ_IN_USE(bs
, monitor_list
)) {
3550 error_setg(errp
, "Node %s is not owned by the monitor",
3555 if (bs
->refcnt
> 1) {
3556 error_setg(errp
, "Block device %s is in use",
3557 bdrv_get_device_or_node_name(bs
));
3561 QTAILQ_REMOVE(&monitor_bdrv_states
, bs
, monitor_list
);
3565 aio_context_release(aio_context
);
3568 static BdrvChild
*bdrv_find_child(BlockDriverState
*parent_bs
,
3569 const char *child_name
)
3573 QLIST_FOREACH(child
, &parent_bs
->children
, next
) {
3574 if (strcmp(child
->name
, child_name
) == 0) {
3582 void qmp_x_blockdev_change(const char *parent
, bool has_child
,
3583 const char *child
, bool has_node
,
3584 const char *node
, Error
**errp
)
3586 BlockDriverState
*parent_bs
, *new_bs
= NULL
;
3589 parent_bs
= bdrv_lookup_bs(parent
, parent
, errp
);
3594 if (has_child
== has_node
) {
3596 error_setg(errp
, "The parameters child and node are in conflict");
3598 error_setg(errp
, "Either child or node must be specified");
3604 p_child
= bdrv_find_child(parent_bs
, child
);
3606 error_setg(errp
, "Node '%s' does not have child '%s'",
3610 bdrv_del_child(parent_bs
, p_child
, errp
);
3614 new_bs
= bdrv_find_node(node
);
3616 error_setg(errp
, "Node '%s' not found", node
);
3619 bdrv_add_child(parent_bs
, new_bs
, errp
);
3623 BlockJobInfoList
*qmp_query_block_jobs(Error
**errp
)
3625 BlockJobInfoList
*head
= NULL
, **p_next
= &head
;
3628 for (job
= block_job_next(NULL
); job
; job
= block_job_next(job
)) {
3629 BlockJobInfoList
*elem
;
3630 AioContext
*aio_context
;
3632 if (block_job_is_internal(job
)) {
3635 elem
= g_new0(BlockJobInfoList
, 1);
3636 aio_context
= blk_get_aio_context(job
->blk
);
3637 aio_context_acquire(aio_context
);
3638 elem
->value
= block_job_query(job
, errp
);
3639 aio_context_release(aio_context
);
3642 qapi_free_BlockJobInfoList(head
);
3646 p_next
= &elem
->next
;
3652 void qmp_x_blockdev_set_iothread(const char *node_name
, StrOrNull
*iothread
,
3653 bool has_force
, bool force
, Error
**errp
)
3655 AioContext
*old_context
;
3656 AioContext
*new_context
;
3657 BlockDriverState
*bs
;
3659 bs
= bdrv_find_node(node_name
);
3661 error_setg(errp
, "Cannot find node %s", node_name
);
3665 /* Protects against accidents. */
3666 if (!(has_force
&& force
) && bdrv_has_blk(bs
)) {
3667 error_setg(errp
, "Node %s is associated with a BlockBackend and could "
3668 "be in use (use force=true to override this check)",
3673 if (iothread
->type
== QTYPE_QSTRING
) {
3674 IOThread
*obj
= iothread_by_id(iothread
->u
.s
);
3676 error_setg(errp
, "Cannot find iothread %s", iothread
->u
.s
);
3680 new_context
= iothread_get_aio_context(obj
);
3682 new_context
= qemu_get_aio_context();
3685 old_context
= bdrv_get_aio_context(bs
);
3686 aio_context_acquire(old_context
);
3688 bdrv_try_set_aio_context(bs
, new_context
, errp
);
3690 aio_context_release(old_context
);
3693 QemuOptsList qemu_common_drive_opts
= {
3695 .head
= QTAILQ_HEAD_INITIALIZER(qemu_common_drive_opts
.head
),
3699 .type
= QEMU_OPT_BOOL
,
3700 .help
= "enable/disable snapshot mode",
3703 .type
= QEMU_OPT_STRING
,
3704 .help
= "host AIO implementation (threads, native, io_uring)",
3706 .name
= BDRV_OPT_CACHE_WB
,
3707 .type
= QEMU_OPT_BOOL
,
3708 .help
= "Enable writeback mode",
3711 .type
= QEMU_OPT_STRING
,
3712 .help
= "disk format (raw, qcow2, ...)",
3715 .type
= QEMU_OPT_STRING
,
3716 .help
= "read error action",
3719 .type
= QEMU_OPT_STRING
,
3720 .help
= "write error action",
3722 .name
= BDRV_OPT_READ_ONLY
,
3723 .type
= QEMU_OPT_BOOL
,
3724 .help
= "open drive file as read-only",
3730 .name
= "throttling.group",
3731 .type
= QEMU_OPT_STRING
,
3732 .help
= "name of the block throttling group",
3734 .name
= "copy-on-read",
3735 .type
= QEMU_OPT_BOOL
,
3736 .help
= "copy read data from backing file into image file",
3738 .name
= "detect-zeroes",
3739 .type
= QEMU_OPT_STRING
,
3740 .help
= "try to optimize zero writes (off, on, unmap)",
3742 .name
= "stats-account-invalid",
3743 .type
= QEMU_OPT_BOOL
,
3744 .help
= "whether to account for invalid I/O operations "
3745 "in the statistics",
3747 .name
= "stats-account-failed",
3748 .type
= QEMU_OPT_BOOL
,
3749 .help
= "whether to account for failed I/O operations "
3750 "in the statistics",
3752 { /* end of list */ }
3756 QemuOptsList qemu_drive_opts
= {
3758 .head
= QTAILQ_HEAD_INITIALIZER(qemu_drive_opts
.head
),
3761 * no elements => accept any params
3762 * validation will happen later
3764 { /* end of list */ }