blockdev: enable non-root nodes for transaction drive-backup source
[qemu.git] / blockdev.c
1 /*
2 * QEMU host block devices
3 *
4 * Copyright (c) 2003-2008 Fabrice Bellard
5 *
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.
8 *
9 * This file incorporates work covered by the following copyright and
10 * permission notice:
11 *
12 * Copyright (c) 2003-2008 Fabrice Bellard
13 *
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:
20 *
21 * The above copyright notice and this permission notice shall be included in
22 * all copies or substantial portions of the Software.
23 *
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
30 * THE SOFTWARE.
31 */
32
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 "qemu/cutils.h"
62 #include "qemu/help_option.h"
63 #include "qemu/throttle-options.h"
64
65 static QTAILQ_HEAD(, BlockDriverState) monitor_bdrv_states =
66 QTAILQ_HEAD_INITIALIZER(monitor_bdrv_states);
67
68 static int do_open_tray(const char *blk_name, const char *qdev_id,
69 bool force, Error **errp);
70 static void blockdev_remove_medium(bool has_device, const char *device,
71 bool has_id, const char *id, Error **errp);
72 static void blockdev_insert_medium(bool has_device, const char *device,
73 bool has_id, const char *id,
74 const char *node_name, Error **errp);
75
76 static const char *const if_name[IF_COUNT] = {
77 [IF_NONE] = "none",
78 [IF_IDE] = "ide",
79 [IF_SCSI] = "scsi",
80 [IF_FLOPPY] = "floppy",
81 [IF_PFLASH] = "pflash",
82 [IF_MTD] = "mtd",
83 [IF_SD] = "sd",
84 [IF_VIRTIO] = "virtio",
85 [IF_XEN] = "xen",
86 };
87
88 static int if_max_devs[IF_COUNT] = {
89 /*
90 * Do not change these numbers! They govern how drive option
91 * index maps to unit and bus. That mapping is ABI.
92 *
93 * All controllers used to implement if=T drives need to support
94 * if_max_devs[T] units, for any T with if_max_devs[T] != 0.
95 * Otherwise, some index values map to "impossible" bus, unit
96 * values.
97 *
98 * For instance, if you change [IF_SCSI] to 255, -drive
99 * if=scsi,index=12 no longer means bus=1,unit=5, but
100 * bus=0,unit=12. With an lsi53c895a controller (7 units max),
101 * the drive can't be set up. Regression.
102 */
103 [IF_IDE] = 2,
104 [IF_SCSI] = 7,
105 };
106
107 /**
108 * Boards may call this to offer board-by-board overrides
109 * of the default, global values.
110 */
111 void override_max_devs(BlockInterfaceType type, int max_devs)
112 {
113 BlockBackend *blk;
114 DriveInfo *dinfo;
115
116 if (max_devs <= 0) {
117 return;
118 }
119
120 for (blk = blk_next(NULL); blk; blk = blk_next(blk)) {
121 dinfo = blk_legacy_dinfo(blk);
122 if (dinfo->type == type) {
123 fprintf(stderr, "Cannot override units-per-bus property of"
124 " the %s interface, because a drive of that type has"
125 " already been added.\n", if_name[type]);
126 g_assert_not_reached();
127 }
128 }
129
130 if_max_devs[type] = max_devs;
131 }
132
133 /*
134 * We automatically delete the drive when a device using it gets
135 * unplugged. Questionable feature, but we can't just drop it.
136 * Device models call blockdev_mark_auto_del() to schedule the
137 * automatic deletion, and generic qdev code calls blockdev_auto_del()
138 * when deletion is actually safe.
139 */
140 void blockdev_mark_auto_del(BlockBackend *blk)
141 {
142 DriveInfo *dinfo = blk_legacy_dinfo(blk);
143 BlockJob *job;
144
145 if (!dinfo) {
146 return;
147 }
148
149 for (job = block_job_next(NULL); job; job = block_job_next(job)) {
150 if (block_job_has_bdrv(job, blk_bs(blk))) {
151 AioContext *aio_context = job->job.aio_context;
152 aio_context_acquire(aio_context);
153
154 job_cancel(&job->job, false);
155
156 aio_context_release(aio_context);
157 }
158 }
159
160 dinfo->auto_del = 1;
161 }
162
163 void blockdev_auto_del(BlockBackend *blk)
164 {
165 DriveInfo *dinfo = blk_legacy_dinfo(blk);
166
167 if (dinfo && dinfo->auto_del) {
168 monitor_remove_blk(blk);
169 blk_unref(blk);
170 }
171 }
172
173 /**
174 * Returns the current mapping of how many units per bus
175 * a particular interface can support.
176 *
177 * A positive integer indicates n units per bus.
178 * 0 implies the mapping has not been established.
179 * -1 indicates an invalid BlockInterfaceType was given.
180 */
181 int drive_get_max_devs(BlockInterfaceType type)
182 {
183 if (type >= IF_IDE && type < IF_COUNT) {
184 return if_max_devs[type];
185 }
186
187 return -1;
188 }
189
190 static int drive_index_to_bus_id(BlockInterfaceType type, int index)
191 {
192 int max_devs = if_max_devs[type];
193 return max_devs ? index / max_devs : 0;
194 }
195
196 static int drive_index_to_unit_id(BlockInterfaceType type, int index)
197 {
198 int max_devs = if_max_devs[type];
199 return max_devs ? index % max_devs : index;
200 }
201
202 QemuOpts *drive_def(const char *optstr)
203 {
204 return qemu_opts_parse_noisily(qemu_find_opts("drive"), optstr, false);
205 }
206
207 QemuOpts *drive_add(BlockInterfaceType type, int index, const char *file,
208 const char *optstr)
209 {
210 QemuOpts *opts;
211
212 opts = drive_def(optstr);
213 if (!opts) {
214 return NULL;
215 }
216 if (type != IF_DEFAULT) {
217 qemu_opt_set(opts, "if", if_name[type], &error_abort);
218 }
219 if (index >= 0) {
220 qemu_opt_set_number(opts, "index", index, &error_abort);
221 }
222 if (file)
223 qemu_opt_set(opts, "file", file, &error_abort);
224 return opts;
225 }
226
227 DriveInfo *drive_get(BlockInterfaceType type, int bus, int unit)
228 {
229 BlockBackend *blk;
230 DriveInfo *dinfo;
231
232 for (blk = blk_next(NULL); blk; blk = blk_next(blk)) {
233 dinfo = blk_legacy_dinfo(blk);
234 if (dinfo && dinfo->type == type
235 && dinfo->bus == bus && dinfo->unit == unit) {
236 return dinfo;
237 }
238 }
239
240 return NULL;
241 }
242
243 void drive_check_orphaned(void)
244 {
245 BlockBackend *blk;
246 DriveInfo *dinfo;
247 Location loc;
248 bool orphans = false;
249
250 for (blk = blk_next(NULL); blk; blk = blk_next(blk)) {
251 dinfo = blk_legacy_dinfo(blk);
252 if (!blk_get_attached_dev(blk) && !dinfo->is_default &&
253 dinfo->type != IF_NONE) {
254 loc_push_none(&loc);
255 qemu_opts_loc_restore(dinfo->opts);
256 error_report("machine type does not support"
257 " if=%s,bus=%d,unit=%d",
258 if_name[dinfo->type], dinfo->bus, dinfo->unit);
259 loc_pop(&loc);
260 orphans = true;
261 }
262 }
263
264 if (orphans) {
265 exit(1);
266 }
267 }
268
269 DriveInfo *drive_get_by_index(BlockInterfaceType type, int index)
270 {
271 return drive_get(type,
272 drive_index_to_bus_id(type, index),
273 drive_index_to_unit_id(type, index));
274 }
275
276 int drive_get_max_bus(BlockInterfaceType type)
277 {
278 int max_bus;
279 BlockBackend *blk;
280 DriveInfo *dinfo;
281
282 max_bus = -1;
283 for (blk = blk_next(NULL); blk; blk = blk_next(blk)) {
284 dinfo = blk_legacy_dinfo(blk);
285 if (dinfo && dinfo->type == type && dinfo->bus > max_bus) {
286 max_bus = dinfo->bus;
287 }
288 }
289 return max_bus;
290 }
291
292 /* Get a block device. This should only be used for single-drive devices
293 (e.g. SD/Floppy/MTD). Multi-disk devices (scsi/ide) should use the
294 appropriate bus. */
295 DriveInfo *drive_get_next(BlockInterfaceType type)
296 {
297 static int next_block_unit[IF_COUNT];
298
299 return drive_get(type, 0, next_block_unit[type]++);
300 }
301
302 static void bdrv_format_print(void *opaque, const char *name)
303 {
304 qemu_printf(" %s", name);
305 }
306
307 typedef struct {
308 QEMUBH *bh;
309 BlockDriverState *bs;
310 } BDRVPutRefBH;
311
312 static int parse_block_error_action(const char *buf, bool is_read, Error **errp)
313 {
314 if (!strcmp(buf, "ignore")) {
315 return BLOCKDEV_ON_ERROR_IGNORE;
316 } else if (!is_read && !strcmp(buf, "enospc")) {
317 return BLOCKDEV_ON_ERROR_ENOSPC;
318 } else if (!strcmp(buf, "stop")) {
319 return BLOCKDEV_ON_ERROR_STOP;
320 } else if (!strcmp(buf, "report")) {
321 return BLOCKDEV_ON_ERROR_REPORT;
322 } else {
323 error_setg(errp, "'%s' invalid %s error action",
324 buf, is_read ? "read" : "write");
325 return -1;
326 }
327 }
328
329 static bool parse_stats_intervals(BlockAcctStats *stats, QList *intervals,
330 Error **errp)
331 {
332 const QListEntry *entry;
333 for (entry = qlist_first(intervals); entry; entry = qlist_next(entry)) {
334 switch (qobject_type(entry->value)) {
335
336 case QTYPE_QSTRING: {
337 unsigned long long length;
338 const char *str = qstring_get_str(qobject_to(QString,
339 entry->value));
340 if (parse_uint_full(str, &length, 10) == 0 &&
341 length > 0 && length <= UINT_MAX) {
342 block_acct_add_interval(stats, (unsigned) length);
343 } else {
344 error_setg(errp, "Invalid interval length: %s", str);
345 return false;
346 }
347 break;
348 }
349
350 case QTYPE_QNUM: {
351 int64_t length = qnum_get_int(qobject_to(QNum, entry->value));
352
353 if (length > 0 && length <= UINT_MAX) {
354 block_acct_add_interval(stats, (unsigned) length);
355 } else {
356 error_setg(errp, "Invalid interval length: %" PRId64, length);
357 return false;
358 }
359 break;
360 }
361
362 default:
363 error_setg(errp, "The specification of stats-intervals is invalid");
364 return false;
365 }
366 }
367 return true;
368 }
369
370 typedef enum { MEDIA_DISK, MEDIA_CDROM } DriveMediaType;
371
372 /* All parameters but @opts are optional and may be set to NULL. */
373 static void extract_common_blockdev_options(QemuOpts *opts, int *bdrv_flags,
374 const char **throttling_group, ThrottleConfig *throttle_cfg,
375 BlockdevDetectZeroesOptions *detect_zeroes, Error **errp)
376 {
377 Error *local_error = NULL;
378 const char *aio;
379
380 if (bdrv_flags) {
381 if (qemu_opt_get_bool(opts, "copy-on-read", false)) {
382 *bdrv_flags |= BDRV_O_COPY_ON_READ;
383 }
384
385 if ((aio = qemu_opt_get(opts, "aio")) != NULL) {
386 if (!strcmp(aio, "native")) {
387 *bdrv_flags |= BDRV_O_NATIVE_AIO;
388 } else if (!strcmp(aio, "threads")) {
389 /* this is the default */
390 } else {
391 error_setg(errp, "invalid aio option");
392 return;
393 }
394 }
395 }
396
397 /* disk I/O throttling */
398 if (throttling_group) {
399 *throttling_group = qemu_opt_get(opts, "throttling.group");
400 }
401
402 if (throttle_cfg) {
403 throttle_config_init(throttle_cfg);
404 throttle_cfg->buckets[THROTTLE_BPS_TOTAL].avg =
405 qemu_opt_get_number(opts, "throttling.bps-total", 0);
406 throttle_cfg->buckets[THROTTLE_BPS_READ].avg =
407 qemu_opt_get_number(opts, "throttling.bps-read", 0);
408 throttle_cfg->buckets[THROTTLE_BPS_WRITE].avg =
409 qemu_opt_get_number(opts, "throttling.bps-write", 0);
410 throttle_cfg->buckets[THROTTLE_OPS_TOTAL].avg =
411 qemu_opt_get_number(opts, "throttling.iops-total", 0);
412 throttle_cfg->buckets[THROTTLE_OPS_READ].avg =
413 qemu_opt_get_number(opts, "throttling.iops-read", 0);
414 throttle_cfg->buckets[THROTTLE_OPS_WRITE].avg =
415 qemu_opt_get_number(opts, "throttling.iops-write", 0);
416
417 throttle_cfg->buckets[THROTTLE_BPS_TOTAL].max =
418 qemu_opt_get_number(opts, "throttling.bps-total-max", 0);
419 throttle_cfg->buckets[THROTTLE_BPS_READ].max =
420 qemu_opt_get_number(opts, "throttling.bps-read-max", 0);
421 throttle_cfg->buckets[THROTTLE_BPS_WRITE].max =
422 qemu_opt_get_number(opts, "throttling.bps-write-max", 0);
423 throttle_cfg->buckets[THROTTLE_OPS_TOTAL].max =
424 qemu_opt_get_number(opts, "throttling.iops-total-max", 0);
425 throttle_cfg->buckets[THROTTLE_OPS_READ].max =
426 qemu_opt_get_number(opts, "throttling.iops-read-max", 0);
427 throttle_cfg->buckets[THROTTLE_OPS_WRITE].max =
428 qemu_opt_get_number(opts, "throttling.iops-write-max", 0);
429
430 throttle_cfg->buckets[THROTTLE_BPS_TOTAL].burst_length =
431 qemu_opt_get_number(opts, "throttling.bps-total-max-length", 1);
432 throttle_cfg->buckets[THROTTLE_BPS_READ].burst_length =
433 qemu_opt_get_number(opts, "throttling.bps-read-max-length", 1);
434 throttle_cfg->buckets[THROTTLE_BPS_WRITE].burst_length =
435 qemu_opt_get_number(opts, "throttling.bps-write-max-length", 1);
436 throttle_cfg->buckets[THROTTLE_OPS_TOTAL].burst_length =
437 qemu_opt_get_number(opts, "throttling.iops-total-max-length", 1);
438 throttle_cfg->buckets[THROTTLE_OPS_READ].burst_length =
439 qemu_opt_get_number(opts, "throttling.iops-read-max-length", 1);
440 throttle_cfg->buckets[THROTTLE_OPS_WRITE].burst_length =
441 qemu_opt_get_number(opts, "throttling.iops-write-max-length", 1);
442
443 throttle_cfg->op_size =
444 qemu_opt_get_number(opts, "throttling.iops-size", 0);
445
446 if (!throttle_is_valid(throttle_cfg, errp)) {
447 return;
448 }
449 }
450
451 if (detect_zeroes) {
452 *detect_zeroes =
453 qapi_enum_parse(&BlockdevDetectZeroesOptions_lookup,
454 qemu_opt_get(opts, "detect-zeroes"),
455 BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF,
456 &local_error);
457 if (local_error) {
458 error_propagate(errp, local_error);
459 return;
460 }
461 }
462 }
463
464 /* Takes the ownership of bs_opts */
465 static BlockBackend *blockdev_init(const char *file, QDict *bs_opts,
466 Error **errp)
467 {
468 const char *buf;
469 int bdrv_flags = 0;
470 int on_read_error, on_write_error;
471 bool account_invalid, account_failed;
472 bool writethrough, read_only;
473 BlockBackend *blk;
474 BlockDriverState *bs;
475 ThrottleConfig cfg;
476 int snapshot = 0;
477 Error *error = NULL;
478 QemuOpts *opts;
479 QDict *interval_dict = NULL;
480 QList *interval_list = NULL;
481 const char *id;
482 BlockdevDetectZeroesOptions detect_zeroes =
483 BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF;
484 const char *throttling_group = NULL;
485
486 /* Check common options by copying from bs_opts to opts, all other options
487 * stay in bs_opts for processing by bdrv_open(). */
488 id = qdict_get_try_str(bs_opts, "id");
489 opts = qemu_opts_create(&qemu_common_drive_opts, id, 1, &error);
490 if (error) {
491 error_propagate(errp, error);
492 goto err_no_opts;
493 }
494
495 qemu_opts_absorb_qdict(opts, bs_opts, &error);
496 if (error) {
497 error_propagate(errp, error);
498 goto early_err;
499 }
500
501 if (id) {
502 qdict_del(bs_opts, "id");
503 }
504
505 /* extract parameters */
506 snapshot = qemu_opt_get_bool(opts, "snapshot", 0);
507
508 account_invalid = qemu_opt_get_bool(opts, "stats-account-invalid", true);
509 account_failed = qemu_opt_get_bool(opts, "stats-account-failed", true);
510
511 writethrough = !qemu_opt_get_bool(opts, BDRV_OPT_CACHE_WB, true);
512
513 id = qemu_opts_id(opts);
514
515 qdict_extract_subqdict(bs_opts, &interval_dict, "stats-intervals.");
516 qdict_array_split(interval_dict, &interval_list);
517
518 if (qdict_size(interval_dict) != 0) {
519 error_setg(errp, "Invalid option stats-intervals.%s",
520 qdict_first(interval_dict)->key);
521 goto early_err;
522 }
523
524 extract_common_blockdev_options(opts, &bdrv_flags, &throttling_group, &cfg,
525 &detect_zeroes, &error);
526 if (error) {
527 error_propagate(errp, error);
528 goto early_err;
529 }
530
531 if ((buf = qemu_opt_get(opts, "format")) != NULL) {
532 if (is_help_option(buf)) {
533 qemu_printf("Supported formats:");
534 bdrv_iterate_format(bdrv_format_print, NULL, false);
535 qemu_printf("\nSupported formats (read-only):");
536 bdrv_iterate_format(bdrv_format_print, NULL, true);
537 qemu_printf("\n");
538 goto early_err;
539 }
540
541 if (qdict_haskey(bs_opts, "driver")) {
542 error_setg(errp, "Cannot specify both 'driver' and 'format'");
543 goto early_err;
544 }
545 qdict_put_str(bs_opts, "driver", buf);
546 }
547
548 on_write_error = BLOCKDEV_ON_ERROR_ENOSPC;
549 if ((buf = qemu_opt_get(opts, "werror")) != NULL) {
550 on_write_error = parse_block_error_action(buf, 0, &error);
551 if (error) {
552 error_propagate(errp, error);
553 goto early_err;
554 }
555 }
556
557 on_read_error = BLOCKDEV_ON_ERROR_REPORT;
558 if ((buf = qemu_opt_get(opts, "rerror")) != NULL) {
559 on_read_error = parse_block_error_action(buf, 1, &error);
560 if (error) {
561 error_propagate(errp, error);
562 goto early_err;
563 }
564 }
565
566 if (snapshot) {
567 bdrv_flags |= BDRV_O_SNAPSHOT;
568 }
569
570 read_only = qemu_opt_get_bool(opts, BDRV_OPT_READ_ONLY, false);
571
572 /* init */
573 if ((!file || !*file) && !qdict_size(bs_opts)) {
574 BlockBackendRootState *blk_rs;
575
576 blk = blk_new(qemu_get_aio_context(), 0, BLK_PERM_ALL);
577 blk_rs = blk_get_root_state(blk);
578 blk_rs->open_flags = bdrv_flags;
579 blk_rs->read_only = read_only;
580 blk_rs->detect_zeroes = detect_zeroes;
581
582 qobject_unref(bs_opts);
583 } else {
584 if (file && !*file) {
585 file = NULL;
586 }
587
588 /* bdrv_open() defaults to the values in bdrv_flags (for compatibility
589 * with other callers) rather than what we want as the real defaults.
590 * Apply the defaults here instead. */
591 qdict_set_default_str(bs_opts, BDRV_OPT_CACHE_DIRECT, "off");
592 qdict_set_default_str(bs_opts, BDRV_OPT_CACHE_NO_FLUSH, "off");
593 qdict_set_default_str(bs_opts, BDRV_OPT_READ_ONLY,
594 read_only ? "on" : "off");
595 qdict_set_default_str(bs_opts, BDRV_OPT_AUTO_READ_ONLY, "on");
596 assert((bdrv_flags & BDRV_O_CACHE_MASK) == 0);
597
598 if (runstate_check(RUN_STATE_INMIGRATE)) {
599 bdrv_flags |= BDRV_O_INACTIVE;
600 }
601
602 blk = blk_new_open(file, NULL, bs_opts, bdrv_flags, errp);
603 if (!blk) {
604 goto err_no_bs_opts;
605 }
606 bs = blk_bs(blk);
607
608 bs->detect_zeroes = detect_zeroes;
609
610 block_acct_setup(blk_get_stats(blk), account_invalid, account_failed);
611
612 if (!parse_stats_intervals(blk_get_stats(blk), interval_list, errp)) {
613 blk_unref(blk);
614 blk = NULL;
615 goto err_no_bs_opts;
616 }
617 }
618
619 /* disk I/O throttling */
620 if (throttle_enabled(&cfg)) {
621 if (!throttling_group) {
622 throttling_group = id;
623 }
624 blk_io_limits_enable(blk, throttling_group);
625 blk_set_io_limits(blk, &cfg);
626 }
627
628 blk_set_enable_write_cache(blk, !writethrough);
629 blk_set_on_error(blk, on_read_error, on_write_error);
630
631 if (!monitor_add_blk(blk, id, errp)) {
632 blk_unref(blk);
633 blk = NULL;
634 goto err_no_bs_opts;
635 }
636
637 err_no_bs_opts:
638 qemu_opts_del(opts);
639 qobject_unref(interval_dict);
640 qobject_unref(interval_list);
641 return blk;
642
643 early_err:
644 qemu_opts_del(opts);
645 qobject_unref(interval_dict);
646 qobject_unref(interval_list);
647 err_no_opts:
648 qobject_unref(bs_opts);
649 return NULL;
650 }
651
652 /* Takes the ownership of bs_opts */
653 static BlockDriverState *bds_tree_init(QDict *bs_opts, Error **errp)
654 {
655 int bdrv_flags = 0;
656
657 /* bdrv_open() defaults to the values in bdrv_flags (for compatibility
658 * with other callers) rather than what we want as the real defaults.
659 * Apply the defaults here instead. */
660 qdict_set_default_str(bs_opts, BDRV_OPT_CACHE_DIRECT, "off");
661 qdict_set_default_str(bs_opts, BDRV_OPT_CACHE_NO_FLUSH, "off");
662 qdict_set_default_str(bs_opts, BDRV_OPT_READ_ONLY, "off");
663
664 if (runstate_check(RUN_STATE_INMIGRATE)) {
665 bdrv_flags |= BDRV_O_INACTIVE;
666 }
667
668 return bdrv_open(NULL, NULL, bs_opts, bdrv_flags, errp);
669 }
670
671 void blockdev_close_all_bdrv_states(void)
672 {
673 BlockDriverState *bs, *next_bs;
674
675 QTAILQ_FOREACH_SAFE(bs, &monitor_bdrv_states, monitor_list, next_bs) {
676 AioContext *ctx = bdrv_get_aio_context(bs);
677
678 aio_context_acquire(ctx);
679 bdrv_unref(bs);
680 aio_context_release(ctx);
681 }
682 }
683
684 /* Iterates over the list of monitor-owned BlockDriverStates */
685 BlockDriverState *bdrv_next_monitor_owned(BlockDriverState *bs)
686 {
687 return bs ? QTAILQ_NEXT(bs, monitor_list)
688 : QTAILQ_FIRST(&monitor_bdrv_states);
689 }
690
691 static void qemu_opt_rename(QemuOpts *opts, const char *from, const char *to,
692 Error **errp)
693 {
694 const char *value;
695
696 value = qemu_opt_get(opts, from);
697 if (value) {
698 if (qemu_opt_find(opts, to)) {
699 error_setg(errp, "'%s' and its alias '%s' can't be used at the "
700 "same time", to, from);
701 return;
702 }
703 }
704
705 /* rename all items in opts */
706 while ((value = qemu_opt_get(opts, from))) {
707 qemu_opt_set(opts, to, value, &error_abort);
708 qemu_opt_unset(opts, from);
709 }
710 }
711
712 QemuOptsList qemu_legacy_drive_opts = {
713 .name = "drive",
714 .head = QTAILQ_HEAD_INITIALIZER(qemu_legacy_drive_opts.head),
715 .desc = {
716 {
717 .name = "bus",
718 .type = QEMU_OPT_NUMBER,
719 .help = "bus number",
720 },{
721 .name = "unit",
722 .type = QEMU_OPT_NUMBER,
723 .help = "unit number (i.e. lun for scsi)",
724 },{
725 .name = "index",
726 .type = QEMU_OPT_NUMBER,
727 .help = "index number",
728 },{
729 .name = "media",
730 .type = QEMU_OPT_STRING,
731 .help = "media type (disk, cdrom)",
732 },{
733 .name = "if",
734 .type = QEMU_OPT_STRING,
735 .help = "interface (ide, scsi, sd, mtd, floppy, pflash, virtio)",
736 },{
737 .name = "file",
738 .type = QEMU_OPT_STRING,
739 .help = "file name",
740 },
741
742 /* Options that are passed on, but have special semantics with -drive */
743 {
744 .name = BDRV_OPT_READ_ONLY,
745 .type = QEMU_OPT_BOOL,
746 .help = "open drive file as read-only",
747 },{
748 .name = "rerror",
749 .type = QEMU_OPT_STRING,
750 .help = "read error action",
751 },{
752 .name = "werror",
753 .type = QEMU_OPT_STRING,
754 .help = "write error action",
755 },{
756 .name = "copy-on-read",
757 .type = QEMU_OPT_BOOL,
758 .help = "copy read data from backing file into image file",
759 },
760
761 { /* end of list */ }
762 },
763 };
764
765 DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type,
766 Error **errp)
767 {
768 const char *value;
769 BlockBackend *blk;
770 DriveInfo *dinfo = NULL;
771 QDict *bs_opts;
772 QemuOpts *legacy_opts;
773 DriveMediaType media = MEDIA_DISK;
774 BlockInterfaceType type;
775 int max_devs, bus_id, unit_id, index;
776 const char *werror, *rerror;
777 bool read_only = false;
778 bool copy_on_read;
779 const char *filename;
780 Error *local_err = NULL;
781 int i;
782
783 /* Change legacy command line options into QMP ones */
784 static const struct {
785 const char *from;
786 const char *to;
787 } opt_renames[] = {
788 { "iops", "throttling.iops-total" },
789 { "iops_rd", "throttling.iops-read" },
790 { "iops_wr", "throttling.iops-write" },
791
792 { "bps", "throttling.bps-total" },
793 { "bps_rd", "throttling.bps-read" },
794 { "bps_wr", "throttling.bps-write" },
795
796 { "iops_max", "throttling.iops-total-max" },
797 { "iops_rd_max", "throttling.iops-read-max" },
798 { "iops_wr_max", "throttling.iops-write-max" },
799
800 { "bps_max", "throttling.bps-total-max" },
801 { "bps_rd_max", "throttling.bps-read-max" },
802 { "bps_wr_max", "throttling.bps-write-max" },
803
804 { "iops_size", "throttling.iops-size" },
805
806 { "group", "throttling.group" },
807
808 { "readonly", BDRV_OPT_READ_ONLY },
809 };
810
811 for (i = 0; i < ARRAY_SIZE(opt_renames); i++) {
812 qemu_opt_rename(all_opts, opt_renames[i].from, opt_renames[i].to,
813 &local_err);
814 if (local_err) {
815 error_propagate(errp, local_err);
816 return NULL;
817 }
818 }
819
820 value = qemu_opt_get(all_opts, "cache");
821 if (value) {
822 int flags = 0;
823 bool writethrough;
824
825 if (bdrv_parse_cache_mode(value, &flags, &writethrough) != 0) {
826 error_setg(errp, "invalid cache option");
827 return NULL;
828 }
829
830 /* Specific options take precedence */
831 if (!qemu_opt_get(all_opts, BDRV_OPT_CACHE_WB)) {
832 qemu_opt_set_bool(all_opts, BDRV_OPT_CACHE_WB,
833 !writethrough, &error_abort);
834 }
835 if (!qemu_opt_get(all_opts, BDRV_OPT_CACHE_DIRECT)) {
836 qemu_opt_set_bool(all_opts, BDRV_OPT_CACHE_DIRECT,
837 !!(flags & BDRV_O_NOCACHE), &error_abort);
838 }
839 if (!qemu_opt_get(all_opts, BDRV_OPT_CACHE_NO_FLUSH)) {
840 qemu_opt_set_bool(all_opts, BDRV_OPT_CACHE_NO_FLUSH,
841 !!(flags & BDRV_O_NO_FLUSH), &error_abort);
842 }
843 qemu_opt_unset(all_opts, "cache");
844 }
845
846 /* Get a QDict for processing the options */
847 bs_opts = qdict_new();
848 qemu_opts_to_qdict(all_opts, bs_opts);
849
850 legacy_opts = qemu_opts_create(&qemu_legacy_drive_opts, NULL, 0,
851 &error_abort);
852 qemu_opts_absorb_qdict(legacy_opts, bs_opts, &local_err);
853 if (local_err) {
854 error_propagate(errp, local_err);
855 goto fail;
856 }
857
858 /* Media type */
859 value = qemu_opt_get(legacy_opts, "media");
860 if (value) {
861 if (!strcmp(value, "disk")) {
862 media = MEDIA_DISK;
863 } else if (!strcmp(value, "cdrom")) {
864 media = MEDIA_CDROM;
865 read_only = true;
866 } else {
867 error_setg(errp, "'%s' invalid media", value);
868 goto fail;
869 }
870 }
871
872 /* copy-on-read is disabled with a warning for read-only devices */
873 read_only |= qemu_opt_get_bool(legacy_opts, BDRV_OPT_READ_ONLY, false);
874 copy_on_read = qemu_opt_get_bool(legacy_opts, "copy-on-read", false);
875
876 if (read_only && copy_on_read) {
877 warn_report("disabling copy-on-read on read-only drive");
878 copy_on_read = false;
879 }
880
881 qdict_put_str(bs_opts, BDRV_OPT_READ_ONLY, read_only ? "on" : "off");
882 qdict_put_str(bs_opts, "copy-on-read", copy_on_read ? "on" : "off");
883
884 /* Controller type */
885 value = qemu_opt_get(legacy_opts, "if");
886 if (value) {
887 for (type = 0;
888 type < IF_COUNT && strcmp(value, if_name[type]);
889 type++) {
890 }
891 if (type == IF_COUNT) {
892 error_setg(errp, "unsupported bus type '%s'", value);
893 goto fail;
894 }
895 } else {
896 type = block_default_type;
897 }
898
899 /* Device address specified by bus/unit or index.
900 * If none was specified, try to find the first free one. */
901 bus_id = qemu_opt_get_number(legacy_opts, "bus", 0);
902 unit_id = qemu_opt_get_number(legacy_opts, "unit", -1);
903 index = qemu_opt_get_number(legacy_opts, "index", -1);
904
905 max_devs = if_max_devs[type];
906
907 if (index != -1) {
908 if (bus_id != 0 || unit_id != -1) {
909 error_setg(errp, "index cannot be used with bus and unit");
910 goto fail;
911 }
912 bus_id = drive_index_to_bus_id(type, index);
913 unit_id = drive_index_to_unit_id(type, index);
914 }
915
916 if (unit_id == -1) {
917 unit_id = 0;
918 while (drive_get(type, bus_id, unit_id) != NULL) {
919 unit_id++;
920 if (max_devs && unit_id >= max_devs) {
921 unit_id -= max_devs;
922 bus_id++;
923 }
924 }
925 }
926
927 if (max_devs && unit_id >= max_devs) {
928 error_setg(errp, "unit %d too big (max is %d)", unit_id, max_devs - 1);
929 goto fail;
930 }
931
932 if (drive_get(type, bus_id, unit_id) != NULL) {
933 error_setg(errp, "drive with bus=%d, unit=%d (index=%d) exists",
934 bus_id, unit_id, index);
935 goto fail;
936 }
937
938 /* no id supplied -> create one */
939 if (qemu_opts_id(all_opts) == NULL) {
940 char *new_id;
941 const char *mediastr = "";
942 if (type == IF_IDE || type == IF_SCSI) {
943 mediastr = (media == MEDIA_CDROM) ? "-cd" : "-hd";
944 }
945 if (max_devs) {
946 new_id = g_strdup_printf("%s%i%s%i", if_name[type], bus_id,
947 mediastr, unit_id);
948 } else {
949 new_id = g_strdup_printf("%s%s%i", if_name[type],
950 mediastr, unit_id);
951 }
952 qdict_put_str(bs_opts, "id", new_id);
953 g_free(new_id);
954 }
955
956 /* Add virtio block device */
957 if (type == IF_VIRTIO) {
958 QemuOpts *devopts;
959 devopts = qemu_opts_create(qemu_find_opts("device"), NULL, 0,
960 &error_abort);
961 if (arch_type == QEMU_ARCH_S390X) {
962 qemu_opt_set(devopts, "driver", "virtio-blk-ccw", &error_abort);
963 } else {
964 qemu_opt_set(devopts, "driver", "virtio-blk-pci", &error_abort);
965 }
966 qemu_opt_set(devopts, "drive", qdict_get_str(bs_opts, "id"),
967 &error_abort);
968 }
969
970 filename = qemu_opt_get(legacy_opts, "file");
971
972 /* Check werror/rerror compatibility with if=... */
973 werror = qemu_opt_get(legacy_opts, "werror");
974 if (werror != NULL) {
975 if (type != IF_IDE && type != IF_SCSI && type != IF_VIRTIO &&
976 type != IF_NONE) {
977 error_setg(errp, "werror is not supported by this bus type");
978 goto fail;
979 }
980 qdict_put_str(bs_opts, "werror", werror);
981 }
982
983 rerror = qemu_opt_get(legacy_opts, "rerror");
984 if (rerror != NULL) {
985 if (type != IF_IDE && type != IF_VIRTIO && type != IF_SCSI &&
986 type != IF_NONE) {
987 error_setg(errp, "rerror is not supported by this bus type");
988 goto fail;
989 }
990 qdict_put_str(bs_opts, "rerror", rerror);
991 }
992
993 /* Actual block device init: Functionality shared with blockdev-add */
994 blk = blockdev_init(filename, bs_opts, &local_err);
995 bs_opts = NULL;
996 if (!blk) {
997 error_propagate(errp, local_err);
998 goto fail;
999 } else {
1000 assert(!local_err);
1001 }
1002
1003 /* Create legacy DriveInfo */
1004 dinfo = g_malloc0(sizeof(*dinfo));
1005 dinfo->opts = all_opts;
1006
1007 dinfo->type = type;
1008 dinfo->bus = bus_id;
1009 dinfo->unit = unit_id;
1010
1011 blk_set_legacy_dinfo(blk, dinfo);
1012
1013 switch(type) {
1014 case IF_IDE:
1015 case IF_SCSI:
1016 case IF_XEN:
1017 case IF_NONE:
1018 dinfo->media_cd = media == MEDIA_CDROM;
1019 break;
1020 default:
1021 break;
1022 }
1023
1024 fail:
1025 qemu_opts_del(legacy_opts);
1026 qobject_unref(bs_opts);
1027 return dinfo;
1028 }
1029
1030 static BlockDriverState *qmp_get_root_bs(const char *name, Error **errp)
1031 {
1032 BlockDriverState *bs;
1033
1034 bs = bdrv_lookup_bs(name, name, errp);
1035 if (bs == NULL) {
1036 return NULL;
1037 }
1038
1039 if (!bdrv_is_root_node(bs)) {
1040 error_setg(errp, "Need a root block node");
1041 return NULL;
1042 }
1043
1044 if (!bdrv_is_inserted(bs)) {
1045 error_setg(errp, "Device has no medium");
1046 return NULL;
1047 }
1048
1049 return bs;
1050 }
1051
1052 static BlockBackend *qmp_get_blk(const char *blk_name, const char *qdev_id,
1053 Error **errp)
1054 {
1055 BlockBackend *blk;
1056
1057 if (!blk_name == !qdev_id) {
1058 error_setg(errp, "Need exactly one of 'device' and 'id'");
1059 return NULL;
1060 }
1061
1062 if (qdev_id) {
1063 blk = blk_by_qdev_id(qdev_id, errp);
1064 } else {
1065 blk = blk_by_name(blk_name);
1066 if (blk == NULL) {
1067 error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
1068 "Device '%s' not found", blk_name);
1069 }
1070 }
1071
1072 return blk;
1073 }
1074
1075 void hmp_commit(Monitor *mon, const QDict *qdict)
1076 {
1077 const char *device = qdict_get_str(qdict, "device");
1078 BlockBackend *blk;
1079 int ret;
1080
1081 if (!strcmp(device, "all")) {
1082 ret = blk_commit_all();
1083 } else {
1084 BlockDriverState *bs;
1085 AioContext *aio_context;
1086
1087 blk = blk_by_name(device);
1088 if (!blk) {
1089 monitor_printf(mon, "Device '%s' not found\n", device);
1090 return;
1091 }
1092 if (!blk_is_available(blk)) {
1093 monitor_printf(mon, "Device '%s' has no medium\n", device);
1094 return;
1095 }
1096
1097 bs = blk_bs(blk);
1098 aio_context = bdrv_get_aio_context(bs);
1099 aio_context_acquire(aio_context);
1100
1101 ret = bdrv_commit(bs);
1102
1103 aio_context_release(aio_context);
1104 }
1105 if (ret < 0) {
1106 monitor_printf(mon, "'commit' error for '%s': %s\n", device,
1107 strerror(-ret));
1108 }
1109 }
1110
1111 static void blockdev_do_action(TransactionAction *action, Error **errp)
1112 {
1113 TransactionActionList list;
1114
1115 list.value = action;
1116 list.next = NULL;
1117 qmp_transaction(&list, false, NULL, errp);
1118 }
1119
1120 void qmp_blockdev_snapshot_sync(bool has_device, const char *device,
1121 bool has_node_name, const char *node_name,
1122 const char *snapshot_file,
1123 bool has_snapshot_node_name,
1124 const char *snapshot_node_name,
1125 bool has_format, const char *format,
1126 bool has_mode, NewImageMode mode, Error **errp)
1127 {
1128 BlockdevSnapshotSync snapshot = {
1129 .has_device = has_device,
1130 .device = (char *) device,
1131 .has_node_name = has_node_name,
1132 .node_name = (char *) node_name,
1133 .snapshot_file = (char *) snapshot_file,
1134 .has_snapshot_node_name = has_snapshot_node_name,
1135 .snapshot_node_name = (char *) snapshot_node_name,
1136 .has_format = has_format,
1137 .format = (char *) format,
1138 .has_mode = has_mode,
1139 .mode = mode,
1140 };
1141 TransactionAction action = {
1142 .type = TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_SYNC,
1143 .u.blockdev_snapshot_sync.data = &snapshot,
1144 };
1145 blockdev_do_action(&action, errp);
1146 }
1147
1148 void qmp_blockdev_snapshot(const char *node, const char *overlay,
1149 Error **errp)
1150 {
1151 BlockdevSnapshot snapshot_data = {
1152 .node = (char *) node,
1153 .overlay = (char *) overlay
1154 };
1155 TransactionAction action = {
1156 .type = TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT,
1157 .u.blockdev_snapshot.data = &snapshot_data,
1158 };
1159 blockdev_do_action(&action, errp);
1160 }
1161
1162 void qmp_blockdev_snapshot_internal_sync(const char *device,
1163 const char *name,
1164 Error **errp)
1165 {
1166 BlockdevSnapshotInternal snapshot = {
1167 .device = (char *) device,
1168 .name = (char *) name
1169 };
1170 TransactionAction action = {
1171 .type = TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_INTERNAL_SYNC,
1172 .u.blockdev_snapshot_internal_sync.data = &snapshot,
1173 };
1174 blockdev_do_action(&action, errp);
1175 }
1176
1177 SnapshotInfo *qmp_blockdev_snapshot_delete_internal_sync(const char *device,
1178 bool has_id,
1179 const char *id,
1180 bool has_name,
1181 const char *name,
1182 Error **errp)
1183 {
1184 BlockDriverState *bs;
1185 AioContext *aio_context;
1186 QEMUSnapshotInfo sn;
1187 Error *local_err = NULL;
1188 SnapshotInfo *info = NULL;
1189 int ret;
1190
1191 bs = qmp_get_root_bs(device, errp);
1192 if (!bs) {
1193 return NULL;
1194 }
1195 aio_context = bdrv_get_aio_context(bs);
1196 aio_context_acquire(aio_context);
1197
1198 if (!has_id) {
1199 id = NULL;
1200 }
1201
1202 if (!has_name) {
1203 name = NULL;
1204 }
1205
1206 if (!id && !name) {
1207 error_setg(errp, "Name or id must be provided");
1208 goto out_aio_context;
1209 }
1210
1211 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_INTERNAL_SNAPSHOT_DELETE, errp)) {
1212 goto out_aio_context;
1213 }
1214
1215 ret = bdrv_snapshot_find_by_id_and_name(bs, id, name, &sn, &local_err);
1216 if (local_err) {
1217 error_propagate(errp, local_err);
1218 goto out_aio_context;
1219 }
1220 if (!ret) {
1221 error_setg(errp,
1222 "Snapshot with id '%s' and name '%s' does not exist on "
1223 "device '%s'",
1224 STR_OR_NULL(id), STR_OR_NULL(name), device);
1225 goto out_aio_context;
1226 }
1227
1228 bdrv_snapshot_delete(bs, id, name, &local_err);
1229 if (local_err) {
1230 error_propagate(errp, local_err);
1231 goto out_aio_context;
1232 }
1233
1234 aio_context_release(aio_context);
1235
1236 info = g_new0(SnapshotInfo, 1);
1237 info->id = g_strdup(sn.id_str);
1238 info->name = g_strdup(sn.name);
1239 info->date_nsec = sn.date_nsec;
1240 info->date_sec = sn.date_sec;
1241 info->vm_state_size = sn.vm_state_size;
1242 info->vm_clock_nsec = sn.vm_clock_nsec % 1000000000;
1243 info->vm_clock_sec = sn.vm_clock_nsec / 1000000000;
1244
1245 return info;
1246
1247 out_aio_context:
1248 aio_context_release(aio_context);
1249 return NULL;
1250 }
1251
1252 /**
1253 * block_dirty_bitmap_lookup:
1254 * Return a dirty bitmap (if present), after validating
1255 * the node reference and bitmap names.
1256 *
1257 * @node: The name of the BDS node to search for bitmaps
1258 * @name: The name of the bitmap to search for
1259 * @pbs: Output pointer for BDS lookup, if desired. Can be NULL.
1260 * @errp: Output pointer for error information. Can be NULL.
1261 *
1262 * @return: A bitmap object on success, or NULL on failure.
1263 */
1264 static BdrvDirtyBitmap *block_dirty_bitmap_lookup(const char *node,
1265 const char *name,
1266 BlockDriverState **pbs,
1267 Error **errp)
1268 {
1269 BlockDriverState *bs;
1270 BdrvDirtyBitmap *bitmap;
1271
1272 if (!node) {
1273 error_setg(errp, "Node cannot be NULL");
1274 return NULL;
1275 }
1276 if (!name) {
1277 error_setg(errp, "Bitmap name cannot be NULL");
1278 return NULL;
1279 }
1280 bs = bdrv_lookup_bs(node, node, NULL);
1281 if (!bs) {
1282 error_setg(errp, "Node '%s' not found", node);
1283 return NULL;
1284 }
1285
1286 bitmap = bdrv_find_dirty_bitmap(bs, name);
1287 if (!bitmap) {
1288 error_setg(errp, "Dirty bitmap '%s' not found", name);
1289 return NULL;
1290 }
1291
1292 if (pbs) {
1293 *pbs = bs;
1294 }
1295
1296 return bitmap;
1297 }
1298
1299 /* New and old BlockDriverState structs for atomic group operations */
1300
1301 typedef struct BlkActionState BlkActionState;
1302
1303 /**
1304 * BlkActionOps:
1305 * Table of operations that define an Action.
1306 *
1307 * @instance_size: Size of state struct, in bytes.
1308 * @prepare: Prepare the work, must NOT be NULL.
1309 * @commit: Commit the changes, can be NULL.
1310 * @abort: Abort the changes on fail, can be NULL.
1311 * @clean: Clean up resources after all transaction actions have called
1312 * commit() or abort(). Can be NULL.
1313 *
1314 * Only prepare() may fail. In a single transaction, only one of commit() or
1315 * abort() will be called. clean() will always be called if it is present.
1316 */
1317 typedef struct BlkActionOps {
1318 size_t instance_size;
1319 void (*prepare)(BlkActionState *common, Error **errp);
1320 void (*commit)(BlkActionState *common);
1321 void (*abort)(BlkActionState *common);
1322 void (*clean)(BlkActionState *common);
1323 } BlkActionOps;
1324
1325 /**
1326 * BlkActionState:
1327 * Describes one Action's state within a Transaction.
1328 *
1329 * @action: QAPI-defined enum identifying which Action to perform.
1330 * @ops: Table of ActionOps this Action can perform.
1331 * @block_job_txn: Transaction which this action belongs to.
1332 * @entry: List membership for all Actions in this Transaction.
1333 *
1334 * This structure must be arranged as first member in a subclassed type,
1335 * assuming that the compiler will also arrange it to the same offsets as the
1336 * base class.
1337 */
1338 struct BlkActionState {
1339 TransactionAction *action;
1340 const BlkActionOps *ops;
1341 JobTxn *block_job_txn;
1342 TransactionProperties *txn_props;
1343 QTAILQ_ENTRY(BlkActionState) entry;
1344 };
1345
1346 /* internal snapshot private data */
1347 typedef struct InternalSnapshotState {
1348 BlkActionState common;
1349 BlockDriverState *bs;
1350 QEMUSnapshotInfo sn;
1351 bool created;
1352 } InternalSnapshotState;
1353
1354
1355 static int action_check_completion_mode(BlkActionState *s, Error **errp)
1356 {
1357 if (s->txn_props->completion_mode != ACTION_COMPLETION_MODE_INDIVIDUAL) {
1358 error_setg(errp,
1359 "Action '%s' does not support Transaction property "
1360 "completion-mode = %s",
1361 TransactionActionKind_str(s->action->type),
1362 ActionCompletionMode_str(s->txn_props->completion_mode));
1363 return -1;
1364 }
1365 return 0;
1366 }
1367
1368 static void internal_snapshot_prepare(BlkActionState *common,
1369 Error **errp)
1370 {
1371 Error *local_err = NULL;
1372 const char *device;
1373 const char *name;
1374 BlockDriverState *bs;
1375 QEMUSnapshotInfo old_sn, *sn;
1376 bool ret;
1377 qemu_timeval tv;
1378 BlockdevSnapshotInternal *internal;
1379 InternalSnapshotState *state;
1380 AioContext *aio_context;
1381 int ret1;
1382
1383 g_assert(common->action->type ==
1384 TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_INTERNAL_SYNC);
1385 internal = common->action->u.blockdev_snapshot_internal_sync.data;
1386 state = DO_UPCAST(InternalSnapshotState, common, common);
1387
1388 /* 1. parse input */
1389 device = internal->device;
1390 name = internal->name;
1391
1392 /* 2. check for validation */
1393 if (action_check_completion_mode(common, errp) < 0) {
1394 return;
1395 }
1396
1397 bs = qmp_get_root_bs(device, errp);
1398 if (!bs) {
1399 return;
1400 }
1401
1402 aio_context = bdrv_get_aio_context(bs);
1403 aio_context_acquire(aio_context);
1404
1405 state->bs = bs;
1406
1407 /* Paired with .clean() */
1408 bdrv_drained_begin(bs);
1409
1410 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_INTERNAL_SNAPSHOT, errp)) {
1411 goto out;
1412 }
1413
1414 if (bdrv_is_read_only(bs)) {
1415 error_setg(errp, "Device '%s' is read only", device);
1416 goto out;
1417 }
1418
1419 if (!bdrv_can_snapshot(bs)) {
1420 error_setg(errp, "Block format '%s' used by device '%s' "
1421 "does not support internal snapshots",
1422 bs->drv->format_name, device);
1423 goto out;
1424 }
1425
1426 if (!strlen(name)) {
1427 error_setg(errp, "Name is empty");
1428 goto out;
1429 }
1430
1431 /* check whether a snapshot with name exist */
1432 ret = bdrv_snapshot_find_by_id_and_name(bs, NULL, name, &old_sn,
1433 &local_err);
1434 if (local_err) {
1435 error_propagate(errp, local_err);
1436 goto out;
1437 } else if (ret) {
1438 error_setg(errp,
1439 "Snapshot with name '%s' already exists on device '%s'",
1440 name, device);
1441 goto out;
1442 }
1443
1444 /* 3. take the snapshot */
1445 sn = &state->sn;
1446 pstrcpy(sn->name, sizeof(sn->name), name);
1447 qemu_gettimeofday(&tv);
1448 sn->date_sec = tv.tv_sec;
1449 sn->date_nsec = tv.tv_usec * 1000;
1450 sn->vm_clock_nsec = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
1451
1452 ret1 = bdrv_snapshot_create(bs, sn);
1453 if (ret1 < 0) {
1454 error_setg_errno(errp, -ret1,
1455 "Failed to create snapshot '%s' on device '%s'",
1456 name, device);
1457 goto out;
1458 }
1459
1460 /* 4. succeed, mark a snapshot is created */
1461 state->created = true;
1462
1463 out:
1464 aio_context_release(aio_context);
1465 }
1466
1467 static void internal_snapshot_abort(BlkActionState *common)
1468 {
1469 InternalSnapshotState *state =
1470 DO_UPCAST(InternalSnapshotState, common, common);
1471 BlockDriverState *bs = state->bs;
1472 QEMUSnapshotInfo *sn = &state->sn;
1473 AioContext *aio_context;
1474 Error *local_error = NULL;
1475
1476 if (!state->created) {
1477 return;
1478 }
1479
1480 aio_context = bdrv_get_aio_context(state->bs);
1481 aio_context_acquire(aio_context);
1482
1483 if (bdrv_snapshot_delete(bs, sn->id_str, sn->name, &local_error) < 0) {
1484 error_reportf_err(local_error,
1485 "Failed to delete snapshot with id '%s' and "
1486 "name '%s' on device '%s' in abort: ",
1487 sn->id_str, sn->name,
1488 bdrv_get_device_name(bs));
1489 }
1490
1491 aio_context_release(aio_context);
1492 }
1493
1494 static void internal_snapshot_clean(BlkActionState *common)
1495 {
1496 InternalSnapshotState *state = DO_UPCAST(InternalSnapshotState,
1497 common, common);
1498 AioContext *aio_context;
1499
1500 if (!state->bs) {
1501 return;
1502 }
1503
1504 aio_context = bdrv_get_aio_context(state->bs);
1505 aio_context_acquire(aio_context);
1506
1507 bdrv_drained_end(state->bs);
1508
1509 aio_context_release(aio_context);
1510 }
1511
1512 /* external snapshot private data */
1513 typedef struct ExternalSnapshotState {
1514 BlkActionState common;
1515 BlockDriverState *old_bs;
1516 BlockDriverState *new_bs;
1517 bool overlay_appended;
1518 } ExternalSnapshotState;
1519
1520 static void external_snapshot_prepare(BlkActionState *common,
1521 Error **errp)
1522 {
1523 int flags = 0;
1524 QDict *options = NULL;
1525 Error *local_err = NULL;
1526 /* Device and node name of the image to generate the snapshot from */
1527 const char *device;
1528 const char *node_name;
1529 /* Reference to the new image (for 'blockdev-snapshot') */
1530 const char *snapshot_ref;
1531 /* File name of the new image (for 'blockdev-snapshot-sync') */
1532 const char *new_image_file;
1533 ExternalSnapshotState *state =
1534 DO_UPCAST(ExternalSnapshotState, common, common);
1535 TransactionAction *action = common->action;
1536 AioContext *aio_context;
1537 int ret;
1538
1539 /* 'blockdev-snapshot' and 'blockdev-snapshot-sync' have similar
1540 * purpose but a different set of parameters */
1541 switch (action->type) {
1542 case TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT:
1543 {
1544 BlockdevSnapshot *s = action->u.blockdev_snapshot.data;
1545 device = s->node;
1546 node_name = s->node;
1547 new_image_file = NULL;
1548 snapshot_ref = s->overlay;
1549 }
1550 break;
1551 case TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_SYNC:
1552 {
1553 BlockdevSnapshotSync *s = action->u.blockdev_snapshot_sync.data;
1554 device = s->has_device ? s->device : NULL;
1555 node_name = s->has_node_name ? s->node_name : NULL;
1556 new_image_file = s->snapshot_file;
1557 snapshot_ref = NULL;
1558 }
1559 break;
1560 default:
1561 g_assert_not_reached();
1562 }
1563
1564 /* start processing */
1565 if (action_check_completion_mode(common, errp) < 0) {
1566 return;
1567 }
1568
1569 state->old_bs = bdrv_lookup_bs(device, node_name, errp);
1570 if (!state->old_bs) {
1571 return;
1572 }
1573
1574 aio_context = bdrv_get_aio_context(state->old_bs);
1575 aio_context_acquire(aio_context);
1576
1577 /* Paired with .clean() */
1578 bdrv_drained_begin(state->old_bs);
1579
1580 if (!bdrv_is_inserted(state->old_bs)) {
1581 error_setg(errp, QERR_DEVICE_HAS_NO_MEDIUM, device);
1582 goto out;
1583 }
1584
1585 if (bdrv_op_is_blocked(state->old_bs,
1586 BLOCK_OP_TYPE_EXTERNAL_SNAPSHOT, errp)) {
1587 goto out;
1588 }
1589
1590 if (!bdrv_is_read_only(state->old_bs)) {
1591 if (bdrv_flush(state->old_bs)) {
1592 error_setg(errp, QERR_IO_ERROR);
1593 goto out;
1594 }
1595 }
1596
1597 if (!bdrv_is_first_non_filter(state->old_bs)) {
1598 error_setg(errp, QERR_FEATURE_DISABLED, "snapshot");
1599 goto out;
1600 }
1601
1602 if (action->type == TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_SYNC) {
1603 BlockdevSnapshotSync *s = action->u.blockdev_snapshot_sync.data;
1604 const char *format = s->has_format ? s->format : "qcow2";
1605 enum NewImageMode mode;
1606 const char *snapshot_node_name =
1607 s->has_snapshot_node_name ? s->snapshot_node_name : NULL;
1608
1609 if (node_name && !snapshot_node_name) {
1610 error_setg(errp, "New overlay node name missing");
1611 goto out;
1612 }
1613
1614 if (snapshot_node_name &&
1615 bdrv_lookup_bs(snapshot_node_name, snapshot_node_name, NULL)) {
1616 error_setg(errp, "New overlay node name already in use");
1617 goto out;
1618 }
1619
1620 flags = state->old_bs->open_flags;
1621 flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_COPY_ON_READ);
1622 flags |= BDRV_O_NO_BACKING;
1623
1624 /* create new image w/backing file */
1625 mode = s->has_mode ? s->mode : NEW_IMAGE_MODE_ABSOLUTE_PATHS;
1626 if (mode != NEW_IMAGE_MODE_EXISTING) {
1627 int64_t size = bdrv_getlength(state->old_bs);
1628 if (size < 0) {
1629 error_setg_errno(errp, -size, "bdrv_getlength failed");
1630 goto out;
1631 }
1632 bdrv_refresh_filename(state->old_bs);
1633 bdrv_img_create(new_image_file, format,
1634 state->old_bs->filename,
1635 state->old_bs->drv->format_name,
1636 NULL, size, flags, false, &local_err);
1637 if (local_err) {
1638 error_propagate(errp, local_err);
1639 goto out;
1640 }
1641 }
1642
1643 options = qdict_new();
1644 if (snapshot_node_name) {
1645 qdict_put_str(options, "node-name", snapshot_node_name);
1646 }
1647 qdict_put_str(options, "driver", format);
1648 }
1649
1650 state->new_bs = bdrv_open(new_image_file, snapshot_ref, options, flags,
1651 errp);
1652 /* We will manually add the backing_hd field to the bs later */
1653 if (!state->new_bs) {
1654 goto out;
1655 }
1656
1657 if (bdrv_has_blk(state->new_bs)) {
1658 error_setg(errp, "The overlay is already in use");
1659 goto out;
1660 }
1661
1662 if (bdrv_op_is_blocked(state->new_bs, BLOCK_OP_TYPE_EXTERNAL_SNAPSHOT,
1663 errp)) {
1664 goto out;
1665 }
1666
1667 if (state->new_bs->backing != NULL) {
1668 error_setg(errp, "The overlay already has a backing image");
1669 goto out;
1670 }
1671
1672 if (!state->new_bs->drv->supports_backing) {
1673 error_setg(errp, "The overlay does not support backing images");
1674 goto out;
1675 }
1676
1677 ret = bdrv_try_set_aio_context(state->new_bs, aio_context, errp);
1678 if (ret < 0) {
1679 goto out;
1680 }
1681
1682 /* This removes our old bs and adds the new bs. This is an operation that
1683 * can fail, so we need to do it in .prepare; undoing it for abort is
1684 * always possible. */
1685 bdrv_ref(state->new_bs);
1686 bdrv_append(state->new_bs, state->old_bs, &local_err);
1687 if (local_err) {
1688 error_propagate(errp, local_err);
1689 goto out;
1690 }
1691 state->overlay_appended = true;
1692
1693 out:
1694 aio_context_release(aio_context);
1695 }
1696
1697 static void external_snapshot_commit(BlkActionState *common)
1698 {
1699 ExternalSnapshotState *state =
1700 DO_UPCAST(ExternalSnapshotState, common, common);
1701 AioContext *aio_context;
1702
1703 aio_context = bdrv_get_aio_context(state->old_bs);
1704 aio_context_acquire(aio_context);
1705
1706 /* We don't need (or want) to use the transactional
1707 * bdrv_reopen_multiple() across all the entries at once, because we
1708 * don't want to abort all of them if one of them fails the reopen */
1709 if (!atomic_read(&state->old_bs->copy_on_read)) {
1710 bdrv_reopen_set_read_only(state->old_bs, true, NULL);
1711 }
1712
1713 aio_context_release(aio_context);
1714 }
1715
1716 static void external_snapshot_abort(BlkActionState *common)
1717 {
1718 ExternalSnapshotState *state =
1719 DO_UPCAST(ExternalSnapshotState, common, common);
1720 if (state->new_bs) {
1721 if (state->overlay_appended) {
1722 AioContext *aio_context;
1723
1724 aio_context = bdrv_get_aio_context(state->old_bs);
1725 aio_context_acquire(aio_context);
1726
1727 bdrv_ref(state->old_bs); /* we can't let bdrv_set_backind_hd()
1728 close state->old_bs; we need it */
1729 bdrv_set_backing_hd(state->new_bs, NULL, &error_abort);
1730 bdrv_replace_node(state->new_bs, state->old_bs, &error_abort);
1731 bdrv_unref(state->old_bs); /* bdrv_replace_node() ref'ed old_bs */
1732
1733 aio_context_release(aio_context);
1734 }
1735 }
1736 }
1737
1738 static void external_snapshot_clean(BlkActionState *common)
1739 {
1740 ExternalSnapshotState *state =
1741 DO_UPCAST(ExternalSnapshotState, common, common);
1742 AioContext *aio_context;
1743
1744 if (!state->old_bs) {
1745 return;
1746 }
1747
1748 aio_context = bdrv_get_aio_context(state->old_bs);
1749 aio_context_acquire(aio_context);
1750
1751 bdrv_drained_end(state->old_bs);
1752 bdrv_unref(state->new_bs);
1753
1754 aio_context_release(aio_context);
1755 }
1756
1757 typedef struct DriveBackupState {
1758 BlkActionState common;
1759 BlockDriverState *bs;
1760 BlockJob *job;
1761 } DriveBackupState;
1762
1763 static BlockJob *do_drive_backup(DriveBackup *backup, JobTxn *txn,
1764 Error **errp);
1765
1766 static void drive_backup_prepare(BlkActionState *common, Error **errp)
1767 {
1768 DriveBackupState *state = DO_UPCAST(DriveBackupState, common, common);
1769 BlockDriverState *bs;
1770 DriveBackup *backup;
1771 AioContext *aio_context;
1772 Error *local_err = NULL;
1773
1774 assert(common->action->type == TRANSACTION_ACTION_KIND_DRIVE_BACKUP);
1775 backup = common->action->u.drive_backup.data;
1776
1777 bs = bdrv_lookup_bs(backup->device, backup->device, errp);
1778 if (!bs) {
1779 return;
1780 }
1781
1782 aio_context = bdrv_get_aio_context(bs);
1783 aio_context_acquire(aio_context);
1784
1785 /* Paired with .clean() */
1786 bdrv_drained_begin(bs);
1787
1788 state->bs = bs;
1789
1790 state->job = do_drive_backup(backup, common->block_job_txn, &local_err);
1791 if (local_err) {
1792 error_propagate(errp, local_err);
1793 goto out;
1794 }
1795
1796 out:
1797 aio_context_release(aio_context);
1798 }
1799
1800 static void drive_backup_commit(BlkActionState *common)
1801 {
1802 DriveBackupState *state = DO_UPCAST(DriveBackupState, common, common);
1803 AioContext *aio_context;
1804
1805 aio_context = bdrv_get_aio_context(state->bs);
1806 aio_context_acquire(aio_context);
1807
1808 assert(state->job);
1809 job_start(&state->job->job);
1810
1811 aio_context_release(aio_context);
1812 }
1813
1814 static void drive_backup_abort(BlkActionState *common)
1815 {
1816 DriveBackupState *state = DO_UPCAST(DriveBackupState, common, common);
1817
1818 if (state->job) {
1819 AioContext *aio_context;
1820
1821 aio_context = bdrv_get_aio_context(state->bs);
1822 aio_context_acquire(aio_context);
1823
1824 job_cancel_sync(&state->job->job);
1825
1826 aio_context_release(aio_context);
1827 }
1828 }
1829
1830 static void drive_backup_clean(BlkActionState *common)
1831 {
1832 DriveBackupState *state = DO_UPCAST(DriveBackupState, common, common);
1833 AioContext *aio_context;
1834
1835 if (!state->bs) {
1836 return;
1837 }
1838
1839 aio_context = bdrv_get_aio_context(state->bs);
1840 aio_context_acquire(aio_context);
1841
1842 bdrv_drained_end(state->bs);
1843
1844 aio_context_release(aio_context);
1845 }
1846
1847 typedef struct BlockdevBackupState {
1848 BlkActionState common;
1849 BlockDriverState *bs;
1850 BlockJob *job;
1851 } BlockdevBackupState;
1852
1853 static BlockJob *do_blockdev_backup(BlockdevBackup *backup, JobTxn *txn,
1854 Error **errp);
1855
1856 static void blockdev_backup_prepare(BlkActionState *common, Error **errp)
1857 {
1858 BlockdevBackupState *state = DO_UPCAST(BlockdevBackupState, common, common);
1859 BlockdevBackup *backup;
1860 BlockDriverState *bs, *target;
1861 AioContext *aio_context;
1862 Error *local_err = NULL;
1863
1864 assert(common->action->type == TRANSACTION_ACTION_KIND_BLOCKDEV_BACKUP);
1865 backup = common->action->u.blockdev_backup.data;
1866
1867 bs = bdrv_lookup_bs(backup->device, backup->device, errp);
1868 if (!bs) {
1869 return;
1870 }
1871
1872 target = bdrv_lookup_bs(backup->target, backup->target, errp);
1873 if (!target) {
1874 return;
1875 }
1876
1877 aio_context = bdrv_get_aio_context(bs);
1878 aio_context_acquire(aio_context);
1879 state->bs = bs;
1880
1881 /* Paired with .clean() */
1882 bdrv_drained_begin(state->bs);
1883
1884 state->job = do_blockdev_backup(backup, common->block_job_txn, &local_err);
1885 if (local_err) {
1886 error_propagate(errp, local_err);
1887 goto out;
1888 }
1889
1890 out:
1891 aio_context_release(aio_context);
1892 }
1893
1894 static void blockdev_backup_commit(BlkActionState *common)
1895 {
1896 BlockdevBackupState *state = DO_UPCAST(BlockdevBackupState, common, common);
1897 AioContext *aio_context;
1898
1899 aio_context = bdrv_get_aio_context(state->bs);
1900 aio_context_acquire(aio_context);
1901
1902 assert(state->job);
1903 job_start(&state->job->job);
1904
1905 aio_context_release(aio_context);
1906 }
1907
1908 static void blockdev_backup_abort(BlkActionState *common)
1909 {
1910 BlockdevBackupState *state = DO_UPCAST(BlockdevBackupState, common, common);
1911
1912 if (state->job) {
1913 AioContext *aio_context;
1914
1915 aio_context = bdrv_get_aio_context(state->bs);
1916 aio_context_acquire(aio_context);
1917
1918 job_cancel_sync(&state->job->job);
1919
1920 aio_context_release(aio_context);
1921 }
1922 }
1923
1924 static void blockdev_backup_clean(BlkActionState *common)
1925 {
1926 BlockdevBackupState *state = DO_UPCAST(BlockdevBackupState, common, common);
1927 AioContext *aio_context;
1928
1929 if (!state->bs) {
1930 return;
1931 }
1932
1933 aio_context = bdrv_get_aio_context(state->bs);
1934 aio_context_acquire(aio_context);
1935
1936 bdrv_drained_end(state->bs);
1937
1938 aio_context_release(aio_context);
1939 }
1940
1941 typedef struct BlockDirtyBitmapState {
1942 BlkActionState common;
1943 BdrvDirtyBitmap *bitmap;
1944 BlockDriverState *bs;
1945 HBitmap *backup;
1946 bool prepared;
1947 bool was_enabled;
1948 } BlockDirtyBitmapState;
1949
1950 static void block_dirty_bitmap_add_prepare(BlkActionState *common,
1951 Error **errp)
1952 {
1953 Error *local_err = NULL;
1954 BlockDirtyBitmapAdd *action;
1955 BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
1956 common, common);
1957
1958 if (action_check_completion_mode(common, errp) < 0) {
1959 return;
1960 }
1961
1962 action = common->action->u.block_dirty_bitmap_add.data;
1963 /* AIO context taken and released within qmp_block_dirty_bitmap_add */
1964 qmp_block_dirty_bitmap_add(action->node, action->name,
1965 action->has_granularity, action->granularity,
1966 action->has_persistent, action->persistent,
1967 action->has_autoload, action->autoload,
1968 action->has_disabled, action->disabled,
1969 &local_err);
1970
1971 if (!local_err) {
1972 state->prepared = true;
1973 } else {
1974 error_propagate(errp, local_err);
1975 }
1976 }
1977
1978 static void block_dirty_bitmap_add_abort(BlkActionState *common)
1979 {
1980 BlockDirtyBitmapAdd *action;
1981 BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
1982 common, common);
1983
1984 action = common->action->u.block_dirty_bitmap_add.data;
1985 /* Should not be able to fail: IF the bitmap was added via .prepare(),
1986 * then the node reference and bitmap name must have been valid.
1987 */
1988 if (state->prepared) {
1989 qmp_block_dirty_bitmap_remove(action->node, action->name, &error_abort);
1990 }
1991 }
1992
1993 static void block_dirty_bitmap_clear_prepare(BlkActionState *common,
1994 Error **errp)
1995 {
1996 BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
1997 common, common);
1998 BlockDirtyBitmap *action;
1999
2000 if (action_check_completion_mode(common, errp) < 0) {
2001 return;
2002 }
2003
2004 action = common->action->u.block_dirty_bitmap_clear.data;
2005 state->bitmap = block_dirty_bitmap_lookup(action->node,
2006 action->name,
2007 &state->bs,
2008 errp);
2009 if (!state->bitmap) {
2010 return;
2011 }
2012
2013 if (bdrv_dirty_bitmap_check(state->bitmap, BDRV_BITMAP_DEFAULT, errp)) {
2014 return;
2015 }
2016
2017 bdrv_clear_dirty_bitmap(state->bitmap, &state->backup);
2018 }
2019
2020 static void block_dirty_bitmap_restore(BlkActionState *common)
2021 {
2022 BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
2023 common, common);
2024
2025 if (state->backup) {
2026 bdrv_restore_dirty_bitmap(state->bitmap, state->backup);
2027 }
2028 }
2029
2030 static void block_dirty_bitmap_free_backup(BlkActionState *common)
2031 {
2032 BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
2033 common, common);
2034
2035 hbitmap_free(state->backup);
2036 }
2037
2038 static void block_dirty_bitmap_enable_prepare(BlkActionState *common,
2039 Error **errp)
2040 {
2041 BlockDirtyBitmap *action;
2042 BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
2043 common, common);
2044
2045 if (action_check_completion_mode(common, errp) < 0) {
2046 return;
2047 }
2048
2049 action = common->action->u.block_dirty_bitmap_enable.data;
2050 state->bitmap = block_dirty_bitmap_lookup(action->node,
2051 action->name,
2052 NULL,
2053 errp);
2054 if (!state->bitmap) {
2055 return;
2056 }
2057
2058 if (bdrv_dirty_bitmap_check(state->bitmap, BDRV_BITMAP_ALLOW_RO, errp)) {
2059 return;
2060 }
2061
2062 state->was_enabled = bdrv_dirty_bitmap_enabled(state->bitmap);
2063 bdrv_enable_dirty_bitmap(state->bitmap);
2064 }
2065
2066 static void block_dirty_bitmap_enable_abort(BlkActionState *common)
2067 {
2068 BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
2069 common, common);
2070
2071 if (!state->was_enabled) {
2072 bdrv_disable_dirty_bitmap(state->bitmap);
2073 }
2074 }
2075
2076 static void block_dirty_bitmap_disable_prepare(BlkActionState *common,
2077 Error **errp)
2078 {
2079 BlockDirtyBitmap *action;
2080 BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
2081 common, common);
2082
2083 if (action_check_completion_mode(common, errp) < 0) {
2084 return;
2085 }
2086
2087 action = common->action->u.block_dirty_bitmap_disable.data;
2088 state->bitmap = block_dirty_bitmap_lookup(action->node,
2089 action->name,
2090 NULL,
2091 errp);
2092 if (!state->bitmap) {
2093 return;
2094 }
2095
2096 if (bdrv_dirty_bitmap_check(state->bitmap, BDRV_BITMAP_ALLOW_RO, errp)) {
2097 return;
2098 }
2099
2100 state->was_enabled = bdrv_dirty_bitmap_enabled(state->bitmap);
2101 bdrv_disable_dirty_bitmap(state->bitmap);
2102 }
2103
2104 static void block_dirty_bitmap_disable_abort(BlkActionState *common)
2105 {
2106 BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
2107 common, common);
2108
2109 if (state->was_enabled) {
2110 bdrv_enable_dirty_bitmap(state->bitmap);
2111 }
2112 }
2113
2114 static BdrvDirtyBitmap *do_block_dirty_bitmap_merge(
2115 const char *node, const char *target,
2116 BlockDirtyBitmapMergeSourceList *bitmaps,
2117 HBitmap **backup, Error **errp);
2118
2119 static void block_dirty_bitmap_merge_prepare(BlkActionState *common,
2120 Error **errp)
2121 {
2122 BlockDirtyBitmapMerge *action;
2123 BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
2124 common, common);
2125
2126 if (action_check_completion_mode(common, errp) < 0) {
2127 return;
2128 }
2129
2130 action = common->action->u.block_dirty_bitmap_merge.data;
2131
2132 state->bitmap = do_block_dirty_bitmap_merge(action->node, action->target,
2133 action->bitmaps, &state->backup,
2134 errp);
2135 }
2136
2137 static void abort_prepare(BlkActionState *common, Error **errp)
2138 {
2139 error_setg(errp, "Transaction aborted using Abort action");
2140 }
2141
2142 static void abort_commit(BlkActionState *common)
2143 {
2144 g_assert_not_reached(); /* this action never succeeds */
2145 }
2146
2147 static const BlkActionOps actions[] = {
2148 [TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT] = {
2149 .instance_size = sizeof(ExternalSnapshotState),
2150 .prepare = external_snapshot_prepare,
2151 .commit = external_snapshot_commit,
2152 .abort = external_snapshot_abort,
2153 .clean = external_snapshot_clean,
2154 },
2155 [TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_SYNC] = {
2156 .instance_size = sizeof(ExternalSnapshotState),
2157 .prepare = external_snapshot_prepare,
2158 .commit = external_snapshot_commit,
2159 .abort = external_snapshot_abort,
2160 .clean = external_snapshot_clean,
2161 },
2162 [TRANSACTION_ACTION_KIND_DRIVE_BACKUP] = {
2163 .instance_size = sizeof(DriveBackupState),
2164 .prepare = drive_backup_prepare,
2165 .commit = drive_backup_commit,
2166 .abort = drive_backup_abort,
2167 .clean = drive_backup_clean,
2168 },
2169 [TRANSACTION_ACTION_KIND_BLOCKDEV_BACKUP] = {
2170 .instance_size = sizeof(BlockdevBackupState),
2171 .prepare = blockdev_backup_prepare,
2172 .commit = blockdev_backup_commit,
2173 .abort = blockdev_backup_abort,
2174 .clean = blockdev_backup_clean,
2175 },
2176 [TRANSACTION_ACTION_KIND_ABORT] = {
2177 .instance_size = sizeof(BlkActionState),
2178 .prepare = abort_prepare,
2179 .commit = abort_commit,
2180 },
2181 [TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_INTERNAL_SYNC] = {
2182 .instance_size = sizeof(InternalSnapshotState),
2183 .prepare = internal_snapshot_prepare,
2184 .abort = internal_snapshot_abort,
2185 .clean = internal_snapshot_clean,
2186 },
2187 [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_ADD] = {
2188 .instance_size = sizeof(BlockDirtyBitmapState),
2189 .prepare = block_dirty_bitmap_add_prepare,
2190 .abort = block_dirty_bitmap_add_abort,
2191 },
2192 [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_CLEAR] = {
2193 .instance_size = sizeof(BlockDirtyBitmapState),
2194 .prepare = block_dirty_bitmap_clear_prepare,
2195 .commit = block_dirty_bitmap_free_backup,
2196 .abort = block_dirty_bitmap_restore,
2197 },
2198 [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_ENABLE] = {
2199 .instance_size = sizeof(BlockDirtyBitmapState),
2200 .prepare = block_dirty_bitmap_enable_prepare,
2201 .abort = block_dirty_bitmap_enable_abort,
2202 },
2203 [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_DISABLE] = {
2204 .instance_size = sizeof(BlockDirtyBitmapState),
2205 .prepare = block_dirty_bitmap_disable_prepare,
2206 .abort = block_dirty_bitmap_disable_abort,
2207 },
2208 [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_MERGE] = {
2209 .instance_size = sizeof(BlockDirtyBitmapState),
2210 .prepare = block_dirty_bitmap_merge_prepare,
2211 .commit = block_dirty_bitmap_free_backup,
2212 .abort = block_dirty_bitmap_restore,
2213 },
2214 /* Where are transactions for MIRROR, COMMIT and STREAM?
2215 * Although these blockjobs use transaction callbacks like the backup job,
2216 * these jobs do not necessarily adhere to transaction semantics.
2217 * These jobs may not fully undo all of their actions on abort, nor do they
2218 * necessarily work in transactions with more than one job in them.
2219 */
2220 };
2221
2222 /**
2223 * Allocate a TransactionProperties structure if necessary, and fill
2224 * that structure with desired defaults if they are unset.
2225 */
2226 static TransactionProperties *get_transaction_properties(
2227 TransactionProperties *props)
2228 {
2229 if (!props) {
2230 props = g_new0(TransactionProperties, 1);
2231 }
2232
2233 if (!props->has_completion_mode) {
2234 props->has_completion_mode = true;
2235 props->completion_mode = ACTION_COMPLETION_MODE_INDIVIDUAL;
2236 }
2237
2238 return props;
2239 }
2240
2241 /*
2242 * 'Atomic' group operations. The operations are performed as a set, and if
2243 * any fail then we roll back all operations in the group.
2244 */
2245 void qmp_transaction(TransactionActionList *dev_list,
2246 bool has_props,
2247 struct TransactionProperties *props,
2248 Error **errp)
2249 {
2250 TransactionActionList *dev_entry = dev_list;
2251 JobTxn *block_job_txn = NULL;
2252 BlkActionState *state, *next;
2253 Error *local_err = NULL;
2254
2255 QTAILQ_HEAD(, BlkActionState) snap_bdrv_states;
2256 QTAILQ_INIT(&snap_bdrv_states);
2257
2258 /* Does this transaction get canceled as a group on failure?
2259 * If not, we don't really need to make a JobTxn.
2260 */
2261 props = get_transaction_properties(props);
2262 if (props->completion_mode != ACTION_COMPLETION_MODE_INDIVIDUAL) {
2263 block_job_txn = job_txn_new();
2264 }
2265
2266 /* drain all i/o before any operations */
2267 bdrv_drain_all();
2268
2269 /* We don't do anything in this loop that commits us to the operations */
2270 while (NULL != dev_entry) {
2271 TransactionAction *dev_info = NULL;
2272 const BlkActionOps *ops;
2273
2274 dev_info = dev_entry->value;
2275 dev_entry = dev_entry->next;
2276
2277 assert(dev_info->type < ARRAY_SIZE(actions));
2278
2279 ops = &actions[dev_info->type];
2280 assert(ops->instance_size > 0);
2281
2282 state = g_malloc0(ops->instance_size);
2283 state->ops = ops;
2284 state->action = dev_info;
2285 state->block_job_txn = block_job_txn;
2286 state->txn_props = props;
2287 QTAILQ_INSERT_TAIL(&snap_bdrv_states, state, entry);
2288
2289 state->ops->prepare(state, &local_err);
2290 if (local_err) {
2291 error_propagate(errp, local_err);
2292 goto delete_and_fail;
2293 }
2294 }
2295
2296 QTAILQ_FOREACH(state, &snap_bdrv_states, entry) {
2297 if (state->ops->commit) {
2298 state->ops->commit(state);
2299 }
2300 }
2301
2302 /* success */
2303 goto exit;
2304
2305 delete_and_fail:
2306 /* failure, and it is all-or-none; roll back all operations */
2307 QTAILQ_FOREACH_REVERSE(state, &snap_bdrv_states, entry) {
2308 if (state->ops->abort) {
2309 state->ops->abort(state);
2310 }
2311 }
2312 exit:
2313 QTAILQ_FOREACH_SAFE(state, &snap_bdrv_states, entry, next) {
2314 if (state->ops->clean) {
2315 state->ops->clean(state);
2316 }
2317 g_free(state);
2318 }
2319 if (!has_props) {
2320 qapi_free_TransactionProperties(props);
2321 }
2322 job_txn_unref(block_job_txn);
2323 }
2324
2325 void qmp_eject(bool has_device, const char *device,
2326 bool has_id, const char *id,
2327 bool has_force, bool force, Error **errp)
2328 {
2329 Error *local_err = NULL;
2330 int rc;
2331
2332 if (!has_force) {
2333 force = false;
2334 }
2335
2336 rc = do_open_tray(has_device ? device : NULL,
2337 has_id ? id : NULL,
2338 force, &local_err);
2339 if (rc && rc != -ENOSYS) {
2340 error_propagate(errp, local_err);
2341 return;
2342 }
2343 error_free(local_err);
2344
2345 blockdev_remove_medium(has_device, device, has_id, id, errp);
2346 }
2347
2348 void qmp_block_passwd(bool has_device, const char *device,
2349 bool has_node_name, const char *node_name,
2350 const char *password, Error **errp)
2351 {
2352 error_setg(errp,
2353 "Setting block passwords directly is no longer supported");
2354 }
2355
2356 /*
2357 * Attempt to open the tray of @device.
2358 * If @force, ignore its tray lock.
2359 * Else, if the tray is locked, don't open it, but ask the guest to open it.
2360 * On error, store an error through @errp and return -errno.
2361 * If @device does not exist, return -ENODEV.
2362 * If it has no removable media, return -ENOTSUP.
2363 * If it has no tray, return -ENOSYS.
2364 * If the guest was asked to open the tray, return -EINPROGRESS.
2365 * Else, return 0.
2366 */
2367 static int do_open_tray(const char *blk_name, const char *qdev_id,
2368 bool force, Error **errp)
2369 {
2370 BlockBackend *blk;
2371 const char *device = qdev_id ?: blk_name;
2372 bool locked;
2373
2374 blk = qmp_get_blk(blk_name, qdev_id, errp);
2375 if (!blk) {
2376 return -ENODEV;
2377 }
2378
2379 if (!blk_dev_has_removable_media(blk)) {
2380 error_setg(errp, "Device '%s' is not removable", device);
2381 return -ENOTSUP;
2382 }
2383
2384 if (!blk_dev_has_tray(blk)) {
2385 error_setg(errp, "Device '%s' does not have a tray", device);
2386 return -ENOSYS;
2387 }
2388
2389 if (blk_dev_is_tray_open(blk)) {
2390 return 0;
2391 }
2392
2393 locked = blk_dev_is_medium_locked(blk);
2394 if (locked) {
2395 blk_dev_eject_request(blk, force);
2396 }
2397
2398 if (!locked || force) {
2399 blk_dev_change_media_cb(blk, false, &error_abort);
2400 }
2401
2402 if (locked && !force) {
2403 error_setg(errp, "Device '%s' is locked and force was not specified, "
2404 "wait for tray to open and try again", device);
2405 return -EINPROGRESS;
2406 }
2407
2408 return 0;
2409 }
2410
2411 void qmp_blockdev_open_tray(bool has_device, const char *device,
2412 bool has_id, const char *id,
2413 bool has_force, bool force,
2414 Error **errp)
2415 {
2416 Error *local_err = NULL;
2417 int rc;
2418
2419 if (!has_force) {
2420 force = false;
2421 }
2422 rc = do_open_tray(has_device ? device : NULL,
2423 has_id ? id : NULL,
2424 force, &local_err);
2425 if (rc && rc != -ENOSYS && rc != -EINPROGRESS) {
2426 error_propagate(errp, local_err);
2427 return;
2428 }
2429 error_free(local_err);
2430 }
2431
2432 void qmp_blockdev_close_tray(bool has_device, const char *device,
2433 bool has_id, const char *id,
2434 Error **errp)
2435 {
2436 BlockBackend *blk;
2437 Error *local_err = NULL;
2438
2439 device = has_device ? device : NULL;
2440 id = has_id ? id : NULL;
2441
2442 blk = qmp_get_blk(device, id, errp);
2443 if (!blk) {
2444 return;
2445 }
2446
2447 if (!blk_dev_has_removable_media(blk)) {
2448 error_setg(errp, "Device '%s' is not removable", device ?: id);
2449 return;
2450 }
2451
2452 if (!blk_dev_has_tray(blk)) {
2453 /* Ignore this command on tray-less devices */
2454 return;
2455 }
2456
2457 if (!blk_dev_is_tray_open(blk)) {
2458 return;
2459 }
2460
2461 blk_dev_change_media_cb(blk, true, &local_err);
2462 if (local_err) {
2463 error_propagate(errp, local_err);
2464 return;
2465 }
2466 }
2467
2468 static void blockdev_remove_medium(bool has_device, const char *device,
2469 bool has_id, const char *id, Error **errp)
2470 {
2471 BlockBackend *blk;
2472 BlockDriverState *bs;
2473 AioContext *aio_context;
2474 bool has_attached_device;
2475
2476 device = has_device ? device : NULL;
2477 id = has_id ? id : NULL;
2478
2479 blk = qmp_get_blk(device, id, errp);
2480 if (!blk) {
2481 return;
2482 }
2483
2484 /* For BBs without a device, we can exchange the BDS tree at will */
2485 has_attached_device = blk_get_attached_dev(blk);
2486
2487 if (has_attached_device && !blk_dev_has_removable_media(blk)) {
2488 error_setg(errp, "Device '%s' is not removable", device ?: id);
2489 return;
2490 }
2491
2492 if (has_attached_device && blk_dev_has_tray(blk) &&
2493 !blk_dev_is_tray_open(blk))
2494 {
2495 error_setg(errp, "Tray of device '%s' is not open", device ?: id);
2496 return;
2497 }
2498
2499 bs = blk_bs(blk);
2500 if (!bs) {
2501 return;
2502 }
2503
2504 aio_context = bdrv_get_aio_context(bs);
2505 aio_context_acquire(aio_context);
2506
2507 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_EJECT, errp)) {
2508 goto out;
2509 }
2510
2511 blk_remove_bs(blk);
2512
2513 if (!blk_dev_has_tray(blk)) {
2514 /* For tray-less devices, blockdev-open-tray is a no-op (or may not be
2515 * called at all); therefore, the medium needs to be ejected here.
2516 * Do it after blk_remove_bs() so blk_is_inserted(blk) returns the @load
2517 * value passed here (i.e. false). */
2518 blk_dev_change_media_cb(blk, false, &error_abort);
2519 }
2520
2521 out:
2522 aio_context_release(aio_context);
2523 }
2524
2525 void qmp_blockdev_remove_medium(const char *id, Error **errp)
2526 {
2527 blockdev_remove_medium(false, NULL, true, id, errp);
2528 }
2529
2530 static void qmp_blockdev_insert_anon_medium(BlockBackend *blk,
2531 BlockDriverState *bs, Error **errp)
2532 {
2533 Error *local_err = NULL;
2534 bool has_device;
2535 int ret;
2536
2537 /* For BBs without a device, we can exchange the BDS tree at will */
2538 has_device = blk_get_attached_dev(blk);
2539
2540 if (has_device && !blk_dev_has_removable_media(blk)) {
2541 error_setg(errp, "Device is not removable");
2542 return;
2543 }
2544
2545 if (has_device && blk_dev_has_tray(blk) && !blk_dev_is_tray_open(blk)) {
2546 error_setg(errp, "Tray of the device is not open");
2547 return;
2548 }
2549
2550 if (blk_bs(blk)) {
2551 error_setg(errp, "There already is a medium in the device");
2552 return;
2553 }
2554
2555 ret = blk_insert_bs(blk, bs, errp);
2556 if (ret < 0) {
2557 return;
2558 }
2559
2560 if (!blk_dev_has_tray(blk)) {
2561 /* For tray-less devices, blockdev-close-tray is a no-op (or may not be
2562 * called at all); therefore, the medium needs to be pushed into the
2563 * slot here.
2564 * Do it after blk_insert_bs() so blk_is_inserted(blk) returns the @load
2565 * value passed here (i.e. true). */
2566 blk_dev_change_media_cb(blk, true, &local_err);
2567 if (local_err) {
2568 error_propagate(errp, local_err);
2569 blk_remove_bs(blk);
2570 return;
2571 }
2572 }
2573 }
2574
2575 static void blockdev_insert_medium(bool has_device, const char *device,
2576 bool has_id, const char *id,
2577 const char *node_name, Error **errp)
2578 {
2579 BlockBackend *blk;
2580 BlockDriverState *bs;
2581
2582 blk = qmp_get_blk(has_device ? device : NULL,
2583 has_id ? id : NULL,
2584 errp);
2585 if (!blk) {
2586 return;
2587 }
2588
2589 bs = bdrv_find_node(node_name);
2590 if (!bs) {
2591 error_setg(errp, "Node '%s' not found", node_name);
2592 return;
2593 }
2594
2595 if (bdrv_has_blk(bs)) {
2596 error_setg(errp, "Node '%s' is already in use", node_name);
2597 return;
2598 }
2599
2600 qmp_blockdev_insert_anon_medium(blk, bs, errp);
2601 }
2602
2603 void qmp_blockdev_insert_medium(const char *id, const char *node_name,
2604 Error **errp)
2605 {
2606 blockdev_insert_medium(false, NULL, true, id, node_name, errp);
2607 }
2608
2609 void qmp_blockdev_change_medium(bool has_device, const char *device,
2610 bool has_id, const char *id,
2611 const char *filename,
2612 bool has_format, const char *format,
2613 bool has_read_only,
2614 BlockdevChangeReadOnlyMode read_only,
2615 Error **errp)
2616 {
2617 BlockBackend *blk;
2618 BlockDriverState *medium_bs = NULL;
2619 int bdrv_flags;
2620 bool detect_zeroes;
2621 int rc;
2622 QDict *options = NULL;
2623 Error *err = NULL;
2624
2625 blk = qmp_get_blk(has_device ? device : NULL,
2626 has_id ? id : NULL,
2627 errp);
2628 if (!blk) {
2629 goto fail;
2630 }
2631
2632 if (blk_bs(blk)) {
2633 blk_update_root_state(blk);
2634 }
2635
2636 bdrv_flags = blk_get_open_flags_from_root_state(blk);
2637 bdrv_flags &= ~(BDRV_O_TEMPORARY | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING |
2638 BDRV_O_PROTOCOL | BDRV_O_AUTO_RDONLY);
2639
2640 if (!has_read_only) {
2641 read_only = BLOCKDEV_CHANGE_READ_ONLY_MODE_RETAIN;
2642 }
2643
2644 switch (read_only) {
2645 case BLOCKDEV_CHANGE_READ_ONLY_MODE_RETAIN:
2646 break;
2647
2648 case BLOCKDEV_CHANGE_READ_ONLY_MODE_READ_ONLY:
2649 bdrv_flags &= ~BDRV_O_RDWR;
2650 break;
2651
2652 case BLOCKDEV_CHANGE_READ_ONLY_MODE_READ_WRITE:
2653 bdrv_flags |= BDRV_O_RDWR;
2654 break;
2655
2656 default:
2657 abort();
2658 }
2659
2660 options = qdict_new();
2661 detect_zeroes = blk_get_detect_zeroes_from_root_state(blk);
2662 qdict_put_str(options, "detect-zeroes", detect_zeroes ? "on" : "off");
2663
2664 if (has_format) {
2665 qdict_put_str(options, "driver", format);
2666 }
2667
2668 medium_bs = bdrv_open(filename, NULL, options, bdrv_flags, errp);
2669 if (!medium_bs) {
2670 goto fail;
2671 }
2672
2673 rc = do_open_tray(has_device ? device : NULL,
2674 has_id ? id : NULL,
2675 false, &err);
2676 if (rc && rc != -ENOSYS) {
2677 error_propagate(errp, err);
2678 goto fail;
2679 }
2680 error_free(err);
2681 err = NULL;
2682
2683 blockdev_remove_medium(has_device, device, has_id, id, &err);
2684 if (err) {
2685 error_propagate(errp, err);
2686 goto fail;
2687 }
2688
2689 qmp_blockdev_insert_anon_medium(blk, medium_bs, &err);
2690 if (err) {
2691 error_propagate(errp, err);
2692 goto fail;
2693 }
2694
2695 qmp_blockdev_close_tray(has_device, device, has_id, id, errp);
2696
2697 fail:
2698 /* If the medium has been inserted, the device has its own reference, so
2699 * ours must be relinquished; and if it has not been inserted successfully,
2700 * the reference must be relinquished anyway */
2701 bdrv_unref(medium_bs);
2702 }
2703
2704 /* throttling disk I/O limits */
2705 void qmp_block_set_io_throttle(BlockIOThrottle *arg, Error **errp)
2706 {
2707 ThrottleConfig cfg;
2708 BlockDriverState *bs;
2709 BlockBackend *blk;
2710 AioContext *aio_context;
2711
2712 blk = qmp_get_blk(arg->has_device ? arg->device : NULL,
2713 arg->has_id ? arg->id : NULL,
2714 errp);
2715 if (!blk) {
2716 return;
2717 }
2718
2719 aio_context = blk_get_aio_context(blk);
2720 aio_context_acquire(aio_context);
2721
2722 bs = blk_bs(blk);
2723 if (!bs) {
2724 error_setg(errp, "Device has no medium");
2725 goto out;
2726 }
2727
2728 throttle_config_init(&cfg);
2729 cfg.buckets[THROTTLE_BPS_TOTAL].avg = arg->bps;
2730 cfg.buckets[THROTTLE_BPS_READ].avg = arg->bps_rd;
2731 cfg.buckets[THROTTLE_BPS_WRITE].avg = arg->bps_wr;
2732
2733 cfg.buckets[THROTTLE_OPS_TOTAL].avg = arg->iops;
2734 cfg.buckets[THROTTLE_OPS_READ].avg = arg->iops_rd;
2735 cfg.buckets[THROTTLE_OPS_WRITE].avg = arg->iops_wr;
2736
2737 if (arg->has_bps_max) {
2738 cfg.buckets[THROTTLE_BPS_TOTAL].max = arg->bps_max;
2739 }
2740 if (arg->has_bps_rd_max) {
2741 cfg.buckets[THROTTLE_BPS_READ].max = arg->bps_rd_max;
2742 }
2743 if (arg->has_bps_wr_max) {
2744 cfg.buckets[THROTTLE_BPS_WRITE].max = arg->bps_wr_max;
2745 }
2746 if (arg->has_iops_max) {
2747 cfg.buckets[THROTTLE_OPS_TOTAL].max = arg->iops_max;
2748 }
2749 if (arg->has_iops_rd_max) {
2750 cfg.buckets[THROTTLE_OPS_READ].max = arg->iops_rd_max;
2751 }
2752 if (arg->has_iops_wr_max) {
2753 cfg.buckets[THROTTLE_OPS_WRITE].max = arg->iops_wr_max;
2754 }
2755
2756 if (arg->has_bps_max_length) {
2757 cfg.buckets[THROTTLE_BPS_TOTAL].burst_length = arg->bps_max_length;
2758 }
2759 if (arg->has_bps_rd_max_length) {
2760 cfg.buckets[THROTTLE_BPS_READ].burst_length = arg->bps_rd_max_length;
2761 }
2762 if (arg->has_bps_wr_max_length) {
2763 cfg.buckets[THROTTLE_BPS_WRITE].burst_length = arg->bps_wr_max_length;
2764 }
2765 if (arg->has_iops_max_length) {
2766 cfg.buckets[THROTTLE_OPS_TOTAL].burst_length = arg->iops_max_length;
2767 }
2768 if (arg->has_iops_rd_max_length) {
2769 cfg.buckets[THROTTLE_OPS_READ].burst_length = arg->iops_rd_max_length;
2770 }
2771 if (arg->has_iops_wr_max_length) {
2772 cfg.buckets[THROTTLE_OPS_WRITE].burst_length = arg->iops_wr_max_length;
2773 }
2774
2775 if (arg->has_iops_size) {
2776 cfg.op_size = arg->iops_size;
2777 }
2778
2779 if (!throttle_is_valid(&cfg, errp)) {
2780 goto out;
2781 }
2782
2783 if (throttle_enabled(&cfg)) {
2784 /* Enable I/O limits if they're not enabled yet, otherwise
2785 * just update the throttling group. */
2786 if (!blk_get_public(blk)->throttle_group_member.throttle_state) {
2787 blk_io_limits_enable(blk,
2788 arg->has_group ? arg->group :
2789 arg->has_device ? arg->device :
2790 arg->id);
2791 } else if (arg->has_group) {
2792 blk_io_limits_update_group(blk, arg->group);
2793 }
2794 /* Set the new throttling configuration */
2795 blk_set_io_limits(blk, &cfg);
2796 } else if (blk_get_public(blk)->throttle_group_member.throttle_state) {
2797 /* If all throttling settings are set to 0, disable I/O limits */
2798 blk_io_limits_disable(blk);
2799 }
2800
2801 out:
2802 aio_context_release(aio_context);
2803 }
2804
2805 void qmp_block_dirty_bitmap_add(const char *node, const char *name,
2806 bool has_granularity, uint32_t granularity,
2807 bool has_persistent, bool persistent,
2808 bool has_autoload, bool autoload,
2809 bool has_disabled, bool disabled,
2810 Error **errp)
2811 {
2812 BlockDriverState *bs;
2813 BdrvDirtyBitmap *bitmap;
2814 AioContext *aio_context = NULL;
2815
2816 if (!name || name[0] == '\0') {
2817 error_setg(errp, "Bitmap name cannot be empty");
2818 return;
2819 }
2820
2821 bs = bdrv_lookup_bs(node, node, errp);
2822 if (!bs) {
2823 return;
2824 }
2825
2826 if (has_granularity) {
2827 if (granularity < 512 || !is_power_of_2(granularity)) {
2828 error_setg(errp, "Granularity must be power of 2 "
2829 "and at least 512");
2830 return;
2831 }
2832 } else {
2833 /* Default to cluster size, if available: */
2834 granularity = bdrv_get_default_bitmap_granularity(bs);
2835 }
2836
2837 if (!has_persistent) {
2838 persistent = false;
2839 }
2840
2841 if (has_autoload) {
2842 warn_report("Autoload option is deprecated and its value is ignored");
2843 }
2844
2845 if (!has_disabled) {
2846 disabled = false;
2847 }
2848
2849 if (persistent) {
2850 aio_context = bdrv_get_aio_context(bs);
2851 aio_context_acquire(aio_context);
2852 if (!bdrv_can_store_new_dirty_bitmap(bs, name, granularity, errp)) {
2853 goto out;
2854 }
2855 }
2856
2857 bitmap = bdrv_create_dirty_bitmap(bs, granularity, name, errp);
2858 if (bitmap == NULL) {
2859 goto out;
2860 }
2861
2862 if (disabled) {
2863 bdrv_disable_dirty_bitmap(bitmap);
2864 }
2865
2866 bdrv_dirty_bitmap_set_persistence(bitmap, persistent);
2867 out:
2868 if (aio_context) {
2869 aio_context_release(aio_context);
2870 }
2871 }
2872
2873 void qmp_block_dirty_bitmap_remove(const char *node, const char *name,
2874 Error **errp)
2875 {
2876 BlockDriverState *bs;
2877 BdrvDirtyBitmap *bitmap;
2878 Error *local_err = NULL;
2879 AioContext *aio_context = NULL;
2880
2881 bitmap = block_dirty_bitmap_lookup(node, name, &bs, errp);
2882 if (!bitmap || !bs) {
2883 return;
2884 }
2885
2886 if (bdrv_dirty_bitmap_check(bitmap, BDRV_BITMAP_BUSY | BDRV_BITMAP_RO,
2887 errp)) {
2888 return;
2889 }
2890
2891 if (bdrv_dirty_bitmap_get_persistence(bitmap)) {
2892 aio_context = bdrv_get_aio_context(bs);
2893 aio_context_acquire(aio_context);
2894 bdrv_remove_persistent_dirty_bitmap(bs, name, &local_err);
2895 if (local_err != NULL) {
2896 error_propagate(errp, local_err);
2897 goto out;
2898 }
2899 }
2900
2901 bdrv_release_dirty_bitmap(bs, bitmap);
2902 out:
2903 if (aio_context) {
2904 aio_context_release(aio_context);
2905 }
2906 }
2907
2908 /**
2909 * Completely clear a bitmap, for the purposes of synchronizing a bitmap
2910 * immediately after a full backup operation.
2911 */
2912 void qmp_block_dirty_bitmap_clear(const char *node, const char *name,
2913 Error **errp)
2914 {
2915 BdrvDirtyBitmap *bitmap;
2916 BlockDriverState *bs;
2917
2918 bitmap = block_dirty_bitmap_lookup(node, name, &bs, errp);
2919 if (!bitmap || !bs) {
2920 return;
2921 }
2922
2923 if (bdrv_dirty_bitmap_check(bitmap, BDRV_BITMAP_DEFAULT, errp)) {
2924 return;
2925 }
2926
2927 bdrv_clear_dirty_bitmap(bitmap, NULL);
2928 }
2929
2930 void qmp_block_dirty_bitmap_enable(const char *node, const char *name,
2931 Error **errp)
2932 {
2933 BlockDriverState *bs;
2934 BdrvDirtyBitmap *bitmap;
2935
2936 bitmap = block_dirty_bitmap_lookup(node, name, &bs, errp);
2937 if (!bitmap) {
2938 return;
2939 }
2940
2941 if (bdrv_dirty_bitmap_check(bitmap, BDRV_BITMAP_ALLOW_RO, errp)) {
2942 return;
2943 }
2944
2945 bdrv_enable_dirty_bitmap(bitmap);
2946 }
2947
2948 void qmp_block_dirty_bitmap_disable(const char *node, const char *name,
2949 Error **errp)
2950 {
2951 BlockDriverState *bs;
2952 BdrvDirtyBitmap *bitmap;
2953
2954 bitmap = block_dirty_bitmap_lookup(node, name, &bs, errp);
2955 if (!bitmap) {
2956 return;
2957 }
2958
2959 if (bdrv_dirty_bitmap_check(bitmap, BDRV_BITMAP_ALLOW_RO, errp)) {
2960 return;
2961 }
2962
2963 bdrv_disable_dirty_bitmap(bitmap);
2964 }
2965
2966 static BdrvDirtyBitmap *do_block_dirty_bitmap_merge(
2967 const char *node, const char *target,
2968 BlockDirtyBitmapMergeSourceList *bitmaps,
2969 HBitmap **backup, Error **errp)
2970 {
2971 BlockDriverState *bs;
2972 BdrvDirtyBitmap *dst, *src, *anon;
2973 BlockDirtyBitmapMergeSourceList *lst;
2974 Error *local_err = NULL;
2975
2976 dst = block_dirty_bitmap_lookup(node, target, &bs, errp);
2977 if (!dst) {
2978 return NULL;
2979 }
2980
2981 anon = bdrv_create_dirty_bitmap(bs, bdrv_dirty_bitmap_granularity(dst),
2982 NULL, errp);
2983 if (!anon) {
2984 return NULL;
2985 }
2986
2987 for (lst = bitmaps; lst; lst = lst->next) {
2988 switch (lst->value->type) {
2989 const char *name, *node;
2990 case QTYPE_QSTRING:
2991 name = lst->value->u.local;
2992 src = bdrv_find_dirty_bitmap(bs, name);
2993 if (!src) {
2994 error_setg(errp, "Dirty bitmap '%s' not found", name);
2995 dst = NULL;
2996 goto out;
2997 }
2998 break;
2999 case QTYPE_QDICT:
3000 node = lst->value->u.external.node;
3001 name = lst->value->u.external.name;
3002 src = block_dirty_bitmap_lookup(node, name, NULL, errp);
3003 if (!src) {
3004 dst = NULL;
3005 goto out;
3006 }
3007 break;
3008 default:
3009 abort();
3010 }
3011
3012 bdrv_merge_dirty_bitmap(anon, src, NULL, &local_err);
3013 if (local_err) {
3014 error_propagate(errp, local_err);
3015 dst = NULL;
3016 goto out;
3017 }
3018 }
3019
3020 /* Merge into dst; dst is unchanged on failure. */
3021 bdrv_merge_dirty_bitmap(dst, anon, backup, errp);
3022
3023 out:
3024 bdrv_release_dirty_bitmap(bs, anon);
3025 return dst;
3026 }
3027
3028 void qmp_block_dirty_bitmap_merge(const char *node, const char *target,
3029 BlockDirtyBitmapMergeSourceList *bitmaps,
3030 Error **errp)
3031 {
3032 do_block_dirty_bitmap_merge(node, target, bitmaps, NULL, errp);
3033 }
3034
3035 BlockDirtyBitmapSha256 *qmp_x_debug_block_dirty_bitmap_sha256(const char *node,
3036 const char *name,
3037 Error **errp)
3038 {
3039 BdrvDirtyBitmap *bitmap;
3040 BlockDriverState *bs;
3041 BlockDirtyBitmapSha256 *ret = NULL;
3042 char *sha256;
3043
3044 bitmap = block_dirty_bitmap_lookup(node, name, &bs, errp);
3045 if (!bitmap || !bs) {
3046 return NULL;
3047 }
3048
3049 sha256 = bdrv_dirty_bitmap_sha256(bitmap, errp);
3050 if (sha256 == NULL) {
3051 return NULL;
3052 }
3053
3054 ret = g_new(BlockDirtyBitmapSha256, 1);
3055 ret->sha256 = sha256;
3056
3057 return ret;
3058 }
3059
3060 void hmp_drive_del(Monitor *mon, const QDict *qdict)
3061 {
3062 const char *id = qdict_get_str(qdict, "id");
3063 BlockBackend *blk;
3064 BlockDriverState *bs;
3065 AioContext *aio_context;
3066 Error *local_err = NULL;
3067
3068 bs = bdrv_find_node(id);
3069 if (bs) {
3070 qmp_blockdev_del(id, &local_err);
3071 if (local_err) {
3072 error_report_err(local_err);
3073 }
3074 return;
3075 }
3076
3077 blk = blk_by_name(id);
3078 if (!blk) {
3079 error_report("Device '%s' not found", id);
3080 return;
3081 }
3082
3083 if (!blk_legacy_dinfo(blk)) {
3084 error_report("Deleting device added with blockdev-add"
3085 " is not supported");
3086 return;
3087 }
3088
3089 aio_context = blk_get_aio_context(blk);
3090 aio_context_acquire(aio_context);
3091
3092 bs = blk_bs(blk);
3093 if (bs) {
3094 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_DRIVE_DEL, &local_err)) {
3095 error_report_err(local_err);
3096 aio_context_release(aio_context);
3097 return;
3098 }
3099
3100 blk_remove_bs(blk);
3101 }
3102
3103 /* Make the BlockBackend and the attached BlockDriverState anonymous */
3104 monitor_remove_blk(blk);
3105
3106 /* If this BlockBackend has a device attached to it, its refcount will be
3107 * decremented when the device is removed; otherwise we have to do so here.
3108 */
3109 if (blk_get_attached_dev(blk)) {
3110 /* Further I/O must not pause the guest */
3111 blk_set_on_error(blk, BLOCKDEV_ON_ERROR_REPORT,
3112 BLOCKDEV_ON_ERROR_REPORT);
3113 } else {
3114 blk_unref(blk);
3115 }
3116
3117 aio_context_release(aio_context);
3118 }
3119
3120 void qmp_block_resize(bool has_device, const char *device,
3121 bool has_node_name, const char *node_name,
3122 int64_t size, Error **errp)
3123 {
3124 Error *local_err = NULL;
3125 BlockBackend *blk = NULL;
3126 BlockDriverState *bs;
3127 AioContext *aio_context;
3128 int ret;
3129
3130 bs = bdrv_lookup_bs(has_device ? device : NULL,
3131 has_node_name ? node_name : NULL,
3132 &local_err);
3133 if (local_err) {
3134 error_propagate(errp, local_err);
3135 return;
3136 }
3137
3138 aio_context = bdrv_get_aio_context(bs);
3139 aio_context_acquire(aio_context);
3140
3141 if (!bdrv_is_first_non_filter(bs)) {
3142 error_setg(errp, QERR_FEATURE_DISABLED, "resize");
3143 goto out;
3144 }
3145
3146 if (size < 0) {
3147 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "size", "a >0 size");
3148 goto out;
3149 }
3150
3151 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_RESIZE, NULL)) {
3152 error_setg(errp, QERR_DEVICE_IN_USE, device);
3153 goto out;
3154 }
3155
3156 blk = blk_new(bdrv_get_aio_context(bs), BLK_PERM_RESIZE, BLK_PERM_ALL);
3157 ret = blk_insert_bs(blk, bs, errp);
3158 if (ret < 0) {
3159 goto out;
3160 }
3161
3162 bdrv_drained_begin(bs);
3163 ret = blk_truncate(blk, size, PREALLOC_MODE_OFF, errp);
3164 bdrv_drained_end(bs);
3165
3166 out:
3167 blk_unref(blk);
3168 aio_context_release(aio_context);
3169 }
3170
3171 void qmp_block_stream(bool has_job_id, const char *job_id, const char *device,
3172 bool has_base, const char *base,
3173 bool has_base_node, const char *base_node,
3174 bool has_backing_file, const char *backing_file,
3175 bool has_speed, int64_t speed,
3176 bool has_on_error, BlockdevOnError on_error,
3177 bool has_auto_finalize, bool auto_finalize,
3178 bool has_auto_dismiss, bool auto_dismiss,
3179 Error **errp)
3180 {
3181 BlockDriverState *bs, *iter;
3182 BlockDriverState *base_bs = NULL;
3183 AioContext *aio_context;
3184 Error *local_err = NULL;
3185 const char *base_name = NULL;
3186 int job_flags = JOB_DEFAULT;
3187
3188 if (!has_on_error) {
3189 on_error = BLOCKDEV_ON_ERROR_REPORT;
3190 }
3191
3192 bs = bdrv_lookup_bs(device, device, errp);
3193 if (!bs) {
3194 return;
3195 }
3196
3197 aio_context = bdrv_get_aio_context(bs);
3198 aio_context_acquire(aio_context);
3199
3200 if (has_base && has_base_node) {
3201 error_setg(errp, "'base' and 'base-node' cannot be specified "
3202 "at the same time");
3203 goto out;
3204 }
3205
3206 if (has_base) {
3207 base_bs = bdrv_find_backing_image(bs, base);
3208 if (base_bs == NULL) {
3209 error_setg(errp, QERR_BASE_NOT_FOUND, base);
3210 goto out;
3211 }
3212 assert(bdrv_get_aio_context(base_bs) == aio_context);
3213 base_name = base;
3214 }
3215
3216 if (has_base_node) {
3217 base_bs = bdrv_lookup_bs(NULL, base_node, errp);
3218 if (!base_bs) {
3219 goto out;
3220 }
3221 if (bs == base_bs || !bdrv_chain_contains(bs, base_bs)) {
3222 error_setg(errp, "Node '%s' is not a backing image of '%s'",
3223 base_node, device);
3224 goto out;
3225 }
3226 assert(bdrv_get_aio_context(base_bs) == aio_context);
3227 bdrv_refresh_filename(base_bs);
3228 base_name = base_bs->filename;
3229 }
3230
3231 /* Check for op blockers in the whole chain between bs and base */
3232 for (iter = bs; iter && iter != base_bs; iter = backing_bs(iter)) {
3233 if (bdrv_op_is_blocked(iter, BLOCK_OP_TYPE_STREAM, errp)) {
3234 goto out;
3235 }
3236 }
3237
3238 /* if we are streaming the entire chain, the result will have no backing
3239 * file, and specifying one is therefore an error */
3240 if (base_bs == NULL && has_backing_file) {
3241 error_setg(errp, "backing file specified, but streaming the "
3242 "entire chain");
3243 goto out;
3244 }
3245
3246 /* backing_file string overrides base bs filename */
3247 base_name = has_backing_file ? backing_file : base_name;
3248
3249 if (has_auto_finalize && !auto_finalize) {
3250 job_flags |= JOB_MANUAL_FINALIZE;
3251 }
3252 if (has_auto_dismiss && !auto_dismiss) {
3253 job_flags |= JOB_MANUAL_DISMISS;
3254 }
3255
3256 stream_start(has_job_id ? job_id : NULL, bs, base_bs, base_name,
3257 job_flags, has_speed ? speed : 0, on_error, &local_err);
3258 if (local_err) {
3259 error_propagate(errp, local_err);
3260 goto out;
3261 }
3262
3263 trace_qmp_block_stream(bs);
3264
3265 out:
3266 aio_context_release(aio_context);
3267 }
3268
3269 void qmp_block_commit(bool has_job_id, const char *job_id, const char *device,
3270 bool has_base_node, const char *base_node,
3271 bool has_base, const char *base,
3272 bool has_top_node, const char *top_node,
3273 bool has_top, const char *top,
3274 bool has_backing_file, const char *backing_file,
3275 bool has_speed, int64_t speed,
3276 bool has_filter_node_name, const char *filter_node_name,
3277 bool has_auto_finalize, bool auto_finalize,
3278 bool has_auto_dismiss, bool auto_dismiss,
3279 Error **errp)
3280 {
3281 BlockDriverState *bs;
3282 BlockDriverState *iter;
3283 BlockDriverState *base_bs, *top_bs;
3284 AioContext *aio_context;
3285 Error *local_err = NULL;
3286 /* This will be part of the QMP command, if/when the
3287 * BlockdevOnError change for blkmirror makes it in
3288 */
3289 BlockdevOnError on_error = BLOCKDEV_ON_ERROR_REPORT;
3290 int job_flags = JOB_DEFAULT;
3291
3292 if (!has_speed) {
3293 speed = 0;
3294 }
3295 if (!has_filter_node_name) {
3296 filter_node_name = NULL;
3297 }
3298 if (has_auto_finalize && !auto_finalize) {
3299 job_flags |= JOB_MANUAL_FINALIZE;
3300 }
3301 if (has_auto_dismiss && !auto_dismiss) {
3302 job_flags |= JOB_MANUAL_DISMISS;
3303 }
3304
3305 /* Important Note:
3306 * libvirt relies on the DeviceNotFound error class in order to probe for
3307 * live commit feature versions; for this to work, we must make sure to
3308 * perform the device lookup before any generic errors that may occur in a
3309 * scenario in which all optional arguments are omitted. */
3310 bs = qmp_get_root_bs(device, &local_err);
3311 if (!bs) {
3312 bs = bdrv_lookup_bs(device, device, NULL);
3313 if (!bs) {
3314 error_free(local_err);
3315 error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
3316 "Device '%s' not found", device);
3317 } else {
3318 error_propagate(errp, local_err);
3319 }
3320 return;
3321 }
3322
3323 aio_context = bdrv_get_aio_context(bs);
3324 aio_context_acquire(aio_context);
3325
3326 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_COMMIT_SOURCE, errp)) {
3327 goto out;
3328 }
3329
3330 /* default top_bs is the active layer */
3331 top_bs = bs;
3332
3333 if (has_top_node && has_top) {
3334 error_setg(errp, "'top-node' and 'top' are mutually exclusive");
3335 goto out;
3336 } else if (has_top_node) {
3337 top_bs = bdrv_lookup_bs(NULL, top_node, errp);
3338 if (top_bs == NULL) {
3339 goto out;
3340 }
3341 if (!bdrv_chain_contains(bs, top_bs)) {
3342 error_setg(errp, "'%s' is not in this backing file chain",
3343 top_node);
3344 goto out;
3345 }
3346 } else if (has_top && top) {
3347 /* This strcmp() is just a shortcut, there is no need to
3348 * refresh @bs's filename. If it mismatches,
3349 * bdrv_find_backing_image() will do the refresh and may still
3350 * return @bs. */
3351 if (strcmp(bs->filename, top) != 0) {
3352 top_bs = bdrv_find_backing_image(bs, top);
3353 }
3354 }
3355
3356 if (top_bs == NULL) {
3357 error_setg(errp, "Top image file %s not found", top ? top : "NULL");
3358 goto out;
3359 }
3360
3361 assert(bdrv_get_aio_context(top_bs) == aio_context);
3362
3363 if (has_base_node && has_base) {
3364 error_setg(errp, "'base-node' and 'base' are mutually exclusive");
3365 goto out;
3366 } else if (has_base_node) {
3367 base_bs = bdrv_lookup_bs(NULL, base_node, errp);
3368 if (base_bs == NULL) {
3369 goto out;
3370 }
3371 if (!bdrv_chain_contains(top_bs, base_bs)) {
3372 error_setg(errp, "'%s' is not in this backing file chain",
3373 base_node);
3374 goto out;
3375 }
3376 } else if (has_base && base) {
3377 base_bs = bdrv_find_backing_image(top_bs, base);
3378 } else {
3379 base_bs = bdrv_find_base(top_bs);
3380 }
3381
3382 if (base_bs == NULL) {
3383 error_setg(errp, QERR_BASE_NOT_FOUND, base ? base : "NULL");
3384 goto out;
3385 }
3386
3387 assert(bdrv_get_aio_context(base_bs) == aio_context);
3388
3389 for (iter = top_bs; iter != backing_bs(base_bs); iter = backing_bs(iter)) {
3390 if (bdrv_op_is_blocked(iter, BLOCK_OP_TYPE_COMMIT_TARGET, errp)) {
3391 goto out;
3392 }
3393 }
3394
3395 /* Do not allow attempts to commit an image into itself */
3396 if (top_bs == base_bs) {
3397 error_setg(errp, "cannot commit an image into itself");
3398 goto out;
3399 }
3400
3401 if (top_bs == bs) {
3402 if (has_backing_file) {
3403 error_setg(errp, "'backing-file' specified,"
3404 " but 'top' is the active layer");
3405 goto out;
3406 }
3407 commit_active_start(has_job_id ? job_id : NULL, bs, base_bs,
3408 job_flags, speed, on_error,
3409 filter_node_name, NULL, NULL, false, &local_err);
3410 } else {
3411 BlockDriverState *overlay_bs = bdrv_find_overlay(bs, top_bs);
3412 if (bdrv_op_is_blocked(overlay_bs, BLOCK_OP_TYPE_COMMIT_TARGET, errp)) {
3413 goto out;
3414 }
3415 commit_start(has_job_id ? job_id : NULL, bs, base_bs, top_bs, job_flags,
3416 speed, on_error, has_backing_file ? backing_file : NULL,
3417 filter_node_name, &local_err);
3418 }
3419 if (local_err != NULL) {
3420 error_propagate(errp, local_err);
3421 goto out;
3422 }
3423
3424 out:
3425 aio_context_release(aio_context);
3426 }
3427
3428 static BlockJob *do_drive_backup(DriveBackup *backup, JobTxn *txn,
3429 Error **errp)
3430 {
3431 BlockDriverState *bs;
3432 BlockDriverState *target_bs;
3433 BlockDriverState *source = NULL;
3434 BlockJob *job = NULL;
3435 BdrvDirtyBitmap *bmap = NULL;
3436 AioContext *aio_context;
3437 QDict *options = NULL;
3438 Error *local_err = NULL;
3439 int flags, job_flags = JOB_DEFAULT;
3440 int64_t size;
3441 bool set_backing_hd = false;
3442 int ret;
3443
3444 if (!backup->has_speed) {
3445 backup->speed = 0;
3446 }
3447 if (!backup->has_on_source_error) {
3448 backup->on_source_error = BLOCKDEV_ON_ERROR_REPORT;
3449 }
3450 if (!backup->has_on_target_error) {
3451 backup->on_target_error = BLOCKDEV_ON_ERROR_REPORT;
3452 }
3453 if (!backup->has_mode) {
3454 backup->mode = NEW_IMAGE_MODE_ABSOLUTE_PATHS;
3455 }
3456 if (!backup->has_job_id) {
3457 backup->job_id = NULL;
3458 }
3459 if (!backup->has_auto_finalize) {
3460 backup->auto_finalize = true;
3461 }
3462 if (!backup->has_auto_dismiss) {
3463 backup->auto_dismiss = true;
3464 }
3465 if (!backup->has_compress) {
3466 backup->compress = false;
3467 }
3468
3469 bs = bdrv_lookup_bs(backup->device, backup->device, errp);
3470 if (!bs) {
3471 return NULL;
3472 }
3473
3474 if (!bs->drv) {
3475 error_setg(errp, "Device has no medium");
3476 return NULL;
3477 }
3478
3479 aio_context = bdrv_get_aio_context(bs);
3480 aio_context_acquire(aio_context);
3481
3482 if (!backup->has_format) {
3483 backup->format = backup->mode == NEW_IMAGE_MODE_EXISTING ?
3484 NULL : (char*) bs->drv->format_name;
3485 }
3486
3487 /* Early check to avoid creating target */
3488 if (