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 "sysemu/runstate.h"
62#include "qemu/cutils.h"
63#include "qemu/help_option.h"
64#include "qemu/main-loop.h"
65#include "qemu/throttle-options.h"
66
67static QTAILQ_HEAD(, BlockDriverState) monitor_bdrv_states =
68 QTAILQ_HEAD_INITIALIZER(monitor_bdrv_states);
69
70static int do_open_tray(const char *blk_name, const char *qdev_id,
71 bool force, Error **errp);
72static void blockdev_remove_medium(bool has_device, const char *device,
73 bool has_id, const char *id, Error **errp);
74static void blockdev_insert_medium(bool has_device, const char *device,
75 bool has_id, const char *id,
76 const char *node_name, Error **errp);
77
78static const char *const if_name[IF_COUNT] = {
79 [IF_NONE] = "none",
80 [IF_IDE] = "ide",
81 [IF_SCSI] = "scsi",
82 [IF_FLOPPY] = "floppy",
83 [IF_PFLASH] = "pflash",
84 [IF_MTD] = "mtd",
85 [IF_SD] = "sd",
86 [IF_VIRTIO] = "virtio",
87 [IF_XEN] = "xen",
88};
89
90static int if_max_devs[IF_COUNT] = {
91 /*
92 * Do not change these numbers! They govern how drive option
93 * index maps to unit and bus. That mapping is ABI.
94 *
95 * All controllers used to implement if=T drives need to support
96 * if_max_devs[T] units, for any T with if_max_devs[T] != 0.
97 * Otherwise, some index values map to "impossible" bus, unit
98 * values.
99 *
100 * For instance, if you change [IF_SCSI] to 255, -drive
101 * if=scsi,index=12 no longer means bus=1,unit=5, but
102 * bus=0,unit=12. With an lsi53c895a controller (7 units max),
103 * the drive can't be set up. Regression.
104 */
105 [IF_IDE] = 2,
106 [IF_SCSI] = 7,
107};
108
109/**
110 * Boards may call this to offer board-by-board overrides
111 * of the default, global values.
112 */
113void override_max_devs(BlockInterfaceType type, int max_devs)
114{
115 BlockBackend *blk;
116 DriveInfo *dinfo;
117
118 if (max_devs <= 0) {
119 return;
120 }
121
122 for (blk = blk_next(NULL); blk; blk = blk_next(blk)) {
123 dinfo = blk_legacy_dinfo(blk);
124 if (dinfo->type == type) {
125 fprintf(stderr, "Cannot override units-per-bus property of"
126 " the %s interface, because a drive of that type has"
127 " already been added.\n", if_name[type]);
128 g_assert_not_reached();
129 }
130 }
131
132 if_max_devs[type] = max_devs;
133}
134
135/*
136 * We automatically delete the drive when a device using it gets
137 * unplugged. Questionable feature, but we can't just drop it.
138 * Device models call blockdev_mark_auto_del() to schedule the
139 * automatic deletion, and generic qdev code calls blockdev_auto_del()
140 * when deletion is actually safe.
141 */
142void blockdev_mark_auto_del(BlockBackend *blk)
143{
144 DriveInfo *dinfo = blk_legacy_dinfo(blk);
145 BlockJob *job;
146
147 if (!dinfo) {
148 return;
149 }
150
151 for (job = block_job_next(NULL); job; job = block_job_next(job)) {
152 if (block_job_has_bdrv(job, blk_bs(blk))) {
153 AioContext *aio_context = job->job.aio_context;
154 aio_context_acquire(aio_context);
155
156 job_cancel(&job->job, false);
157
158 aio_context_release(aio_context);
159 }
160 }
161
162 dinfo->auto_del = 1;
163}
164
165void blockdev_auto_del(BlockBackend *blk)
166{
167 DriveInfo *dinfo = blk_legacy_dinfo(blk);
168
169 if (dinfo && dinfo->auto_del) {
170 monitor_remove_blk(blk);
171 blk_unref(blk);
172 }
173}
174
175/**
176 * Returns the current mapping of how many units per bus
177 * a particular interface can support.
178 *
179 * A positive integer indicates n units per bus.
180 * 0 implies the mapping has not been established.
181 * -1 indicates an invalid BlockInterfaceType was given.
182 */
183int drive_get_max_devs(BlockInterfaceType type)
184{
185 if (type >= IF_IDE && type < IF_COUNT) {
186 return if_max_devs[type];
187 }
188
189 return -1;
190}
191
192static int drive_index_to_bus_id(BlockInterfaceType type, int index)
193{
194 int max_devs = if_max_devs[type];
195 return max_devs ? index / max_devs : 0;
196}
197
198static int drive_index_to_unit_id(BlockInterfaceType type, int index)
199{
200 int max_devs = if_max_devs[type];
201 return max_devs ? index % max_devs : index;
202}
203
204QemuOpts *drive_def(const char *optstr)
205{
206 return qemu_opts_parse_noisily(qemu_find_opts("drive"), optstr, false);
207}
208
209QemuOpts *drive_add(BlockInterfaceType type, int index, const char *file,
210 const char *optstr)
211{
212 QemuOpts *opts;
213
214 opts = drive_def(optstr);
215 if (!opts) {
216 return NULL;
217 }
218 if (type != IF_DEFAULT) {
219 qemu_opt_set(opts, "if", if_name[type], &error_abort);
220 }
221 if (index >= 0) {
222 qemu_opt_set_number(opts, "index", index, &error_abort);
223 }
224 if (file)
225 qemu_opt_set(opts, "file", file, &error_abort);
226 return opts;
227}
228
229DriveInfo *drive_get(BlockInterfaceType type, int bus, int unit)
230{
231 BlockBackend *blk;
232 DriveInfo *dinfo;
233
234 for (blk = blk_next(NULL); blk; blk = blk_next(blk)) {
235 dinfo = blk_legacy_dinfo(blk);
236 if (dinfo && dinfo->type == type
237 && dinfo->bus == bus && dinfo->unit == unit) {
238 return dinfo;
239 }
240 }
241
242 return NULL;
243}
244
245void drive_check_orphaned(void)
246{
247 BlockBackend *blk;
248 DriveInfo *dinfo;
249 Location loc;
250 bool orphans = false;
251
252 for (blk = blk_next(NULL); blk; blk = blk_next(blk)) {
253 dinfo = blk_legacy_dinfo(blk);
254 if (!blk_get_attached_dev(blk) && !dinfo->is_default &&
255 dinfo->type != IF_NONE) {
256 loc_push_none(&loc);
257 qemu_opts_loc_restore(dinfo->opts);
258 error_report("machine type does not support"
259 " if=%s,bus=%d,unit=%d",
260 if_name[dinfo->type], dinfo->bus, dinfo->unit);
261 loc_pop(&loc);
262 orphans = true;
263 }
264 }
265
266 if (orphans) {
267 exit(1);
268 }
269}
270
271DriveInfo *drive_get_by_index(BlockInterfaceType type, int index)
272{
273 return drive_get(type,
274 drive_index_to_bus_id(type, index),
275 drive_index_to_unit_id(type, index));
276}
277
278int drive_get_max_bus(BlockInterfaceType type)
279{
280 int max_bus;
281 BlockBackend *blk;
282 DriveInfo *dinfo;
283
284 max_bus = -1;
285 for (blk = blk_next(NULL); blk; blk = blk_next(blk)) {
286 dinfo = blk_legacy_dinfo(blk);
287 if (dinfo && dinfo->type == type && dinfo->bus > max_bus) {
288 max_bus = dinfo->bus;
289 }
290 }
291 return max_bus;
292}
293
294/* Get a block device. This should only be used for single-drive devices
295 (e.g. SD/Floppy/MTD). Multi-disk devices (scsi/ide) should use the
296 appropriate bus. */
297DriveInfo *drive_get_next(BlockInterfaceType type)
298{
299 static int next_block_unit[IF_COUNT];
300
301 return drive_get(type, 0, next_block_unit[type]++);
302}
303
304static void bdrv_format_print(void *opaque, const char *name)
305{
306 qemu_printf(" %s", name);
307}
308
309typedef struct {
310 QEMUBH *bh;
311 BlockDriverState *bs;
312} BDRVPutRefBH;
313
314static int parse_block_error_action(const char *buf, bool is_read, Error **errp)
315{
316 if (!strcmp(buf, "ignore")) {
317 return BLOCKDEV_ON_ERROR_IGNORE;
318 } else if (!is_read && !strcmp(buf, "enospc")) {
319 return BLOCKDEV_ON_ERROR_ENOSPC;
320 } else if (!strcmp(buf, "stop")) {
321 return BLOCKDEV_ON_ERROR_STOP;
322 } else if (!strcmp(buf, "report")) {
323 return BLOCKDEV_ON_ERROR_REPORT;
324 } else {
325 error_setg(errp, "'%s' invalid %s error action",
326 buf, is_read ? "read" : "write");
327 return -1;
328 }
329}
330
331static bool parse_stats_intervals(BlockAcctStats *stats, QList *intervals,
332 Error **errp)
333{
334 const QListEntry *entry;
335 for (entry = qlist_first(intervals); entry; entry = qlist_next(entry)) {
336 switch (qobject_type(entry->value)) {
337
338 case QTYPE_QSTRING: {
339 unsigned long long length;
340 const char *str = qstring_get_str(qobject_to(QString,
341 entry->value));
342 if (parse_uint_full(str, &length, 10) == 0 &&
343 length > 0 && length <= UINT_MAX) {
344 block_acct_add_interval(stats, (unsigned) length);
345 } else {
346 error_setg(errp, "Invalid interval length: %s", str);
347 return false;
348 }
349 break;
350 }
351
352 case QTYPE_QNUM: {
353 int64_t length = qnum_get_int(qobject_to(QNum, entry->value));
354
355 if (length > 0 && length <= UINT_MAX) {
356 block_acct_add_interval(stats, (unsigned) length);
357 } else {
358 error_setg(errp, "Invalid interval length: %" PRId64, length);
359 return false;
360 }
361 break;
362 }
363
364 default:
365 error_setg(errp, "The specification of stats-intervals is invalid");
366 return false;
367 }
368 }
369 return true;
370}
371
372typedef enum { MEDIA_DISK, MEDIA_CDROM } DriveMediaType;
373
374/* All parameters but @opts are optional and may be set to NULL. */
375static void extract_common_blockdev_options(QemuOpts *opts, int *bdrv_flags,
376 const char **throttling_group, ThrottleConfig *throttle_cfg,
377 BlockdevDetectZeroesOptions *detect_zeroes, Error **errp)
378{
379 Error *local_error = NULL;
380 const char *aio;
381
382 if (bdrv_flags) {
383 if (qemu_opt_get_bool(opts, "copy-on-read", false)) {
384 *bdrv_flags |= BDRV_O_COPY_ON_READ;
385 }
386
387 if ((aio = qemu_opt_get(opts, "aio")) != NULL) {
388 if (!strcmp(aio, "native")) {
389 *bdrv_flags |= BDRV_O_NATIVE_AIO;
390 } else if (!strcmp(aio, "threads")) {
391 /* this is the default */
392 } else {
393 error_setg(errp, "invalid aio option");
394 return;
395 }
396 }
397 }
398
399 /* disk I/O throttling */
400 if (throttling_group) {
401 *throttling_group = qemu_opt_get(opts, "throttling.group");
402 }
403
404 if (throttle_cfg) {
405 throttle_config_init(throttle_cfg);
406 throttle_cfg->buckets[THROTTLE_BPS_TOTAL].avg =
407 qemu_opt_get_number(opts, "throttling.bps-total", 0);
408 throttle_cfg->buckets[THROTTLE_BPS_READ].avg =
409 qemu_opt_get_number(opts, "throttling.bps-read", 0);
410 throttle_cfg->buckets[THROTTLE_BPS_WRITE].avg =
411 qemu_opt_get_number(opts, "throttling.bps-write", 0);
412 throttle_cfg->buckets[THROTTLE_OPS_TOTAL].avg =
413 qemu_opt_get_number(opts, "throttling.iops-total", 0);
414 throttle_cfg->buckets[THROTTLE_OPS_READ].avg =
415 qemu_opt_get_number(opts, "throttling.iops-read", 0);
416 throttle_cfg->buckets[THROTTLE_OPS_WRITE].avg =
417 qemu_opt_get_number(opts, "throttling.iops-write", 0);
418
419 throttle_cfg->buckets[THROTTLE_BPS_TOTAL].max =
420 qemu_opt_get_number(opts, "throttling.bps-total-max", 0);
421 throttle_cfg->buckets[THROTTLE_BPS_READ].max =
422 qemu_opt_get_number(opts, "throttling.bps-read-max", 0);
423 throttle_cfg->buckets[THROTTLE_BPS_WRITE].max =
424 qemu_opt_get_number(opts, "throttling.bps-write-max", 0);
425 throttle_cfg->buckets[THROTTLE_OPS_TOTAL].max =
426 qemu_opt_get_number(opts, "throttling.iops-total-max", 0);
427 throttle_cfg->buckets[THROTTLE_OPS_READ].max =
428 qemu_opt_get_number(opts, "throttling.iops-read-max", 0);
429 throttle_cfg->buckets[THROTTLE_OPS_WRITE].max =
430 qemu_opt_get_number(opts, "throttling.iops-write-max", 0);
431
432 throttle_cfg->buckets[THROTTLE_BPS_TOTAL].burst_length =
433 qemu_opt_get_number(opts, "throttling.bps-total-max-length", 1);
434 throttle_cfg->buckets[THROTTLE_BPS_READ].burst_length =
435 qemu_opt_get_number(opts, "throttling.bps-read-max-length", 1);
436 throttle_cfg->buckets[THROTTLE_BPS_WRITE].burst_length =
437 qemu_opt_get_number(opts, "throttling.bps-write-max-length", 1);
438 throttle_cfg->buckets[THROTTLE_OPS_TOTAL].burst_length =
439 qemu_opt_get_number(opts, "throttling.iops-total-max-length", 1);
440 throttle_cfg->buckets[THROTTLE_OPS_READ].burst_length =
441 qemu_opt_get_number(opts, "throttling.iops-read-max-length", 1);
442 throttle_cfg->buckets[THROTTLE_OPS_WRITE].burst_length =
443 qemu_opt_get_number(opts, "throttling.iops-write-max-length", 1);
444
445 throttle_cfg->op_size =
446 qemu_opt_get_number(opts, "throttling.iops-size", 0);
447
448 if (!throttle_is_valid(throttle_cfg, errp)) {
449 return;
450 }
451 }
452
453 if (detect_zeroes) {
454 *detect_zeroes =
455 qapi_enum_parse(&BlockdevDetectZeroesOptions_lookup,
456 qemu_opt_get(opts, "detect-zeroes"),
457 BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF,
458 &local_error);
459 if (local_error) {
460 error_propagate(errp, local_error);
461 return;
462 }
463 }
464}
465
466/* Takes the ownership of bs_opts */
467static BlockBackend *blockdev_init(const char *file, QDict *bs_opts,
468 Error **errp)
469{
470 const char *buf;
471 int bdrv_flags = 0;
472 int on_read_error, on_write_error;
473 bool account_invalid, account_failed;
474 bool writethrough, read_only;
475 BlockBackend *blk;
476 BlockDriverState *bs;
477 ThrottleConfig cfg;
478 int snapshot = 0;
479 Error *error = NULL;
480 QemuOpts *opts;
481 QDict *interval_dict = NULL;
482 QList *interval_list = NULL;
483 const char *id;
484 BlockdevDetectZeroesOptions detect_zeroes =
485 BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF;
486 const char *throttling_group = NULL;
487
488 /* Check common options by copying from bs_opts to opts, all other options
489 * stay in bs_opts for processing by bdrv_open(). */
490 id = qdict_get_try_str(bs_opts, "id");
491 opts = qemu_opts_create(&qemu_common_drive_opts, id, 1, &error);
492 if (error) {
493 error_propagate(errp, error);
494 goto err_no_opts;
495 }
496
497 qemu_opts_absorb_qdict(opts, bs_opts, &error);
498 if (error) {
499 error_propagate(errp, error);
500 goto early_err;
501 }
502
503 if (id) {
504 qdict_del(bs_opts, "id");
505 }
506
507 /* extract parameters */
508 snapshot = qemu_opt_get_bool(opts, "snapshot", 0);
509
510 account_invalid = qemu_opt_get_bool(opts, "stats-account-invalid", true);
511 account_failed = qemu_opt_get_bool(opts, "stats-account-failed", true);
512
513 writethrough = !qemu_opt_get_bool(opts, BDRV_OPT_CACHE_WB, true);
514
515 id = qemu_opts_id(opts);
516
517 qdict_extract_subqdict(bs_opts, &interval_dict, "stats-intervals.");
518 qdict_array_split(interval_dict, &interval_list);
519
520 if (qdict_size(interval_dict) != 0) {
521 error_setg(errp, "Invalid option stats-intervals.%s",
522 qdict_first(interval_dict)->key);
523 goto early_err;
524 }
525
526 extract_common_blockdev_options(opts, &bdrv_flags, &throttling_group, &cfg,
527 &detect_zeroes, &error);
528 if (error) {
529 error_propagate(errp, error);
530 goto early_err;
531 }
532
533 if ((buf = qemu_opt_get(opts, "format")) != NULL) {
534 if (is_help_option(buf)) {
535 qemu_printf("Supported formats:");
536 bdrv_iterate_format(bdrv_format_print, NULL, false);
537 qemu_printf("\nSupported formats (read-only):");
538 bdrv_iterate_format(bdrv_format_print, NULL, true);
539 qemu_printf("\n");
540 goto early_err;
541 }
542
543 if (qdict_haskey(bs_opts, "driver")) {
544 error_setg(errp, "Cannot specify both 'driver' and 'format'");
545 goto early_err;
546 }
547 qdict_put_str(bs_opts, "driver", buf);
548 }
549
550 on_write_error = BLOCKDEV_ON_ERROR_ENOSPC;
551 if ((buf = qemu_opt_get(opts, "werror")) != NULL) {
552 on_write_error = parse_block_error_action(buf, 0, &error);
553 if (error) {
554 error_propagate(errp, error);
555 goto early_err;
556 }
557 }
558
559 on_read_error = BLOCKDEV_ON_ERROR_REPORT;
560 if ((buf = qemu_opt_get(opts, "rerror")) != NULL) {
561 on_read_error = parse_block_error_action(buf, 1, &error);
562 if (error) {
563 error_propagate(errp, error);
564 goto early_err;
565 }
566 }
567
568 if (snapshot) {
569 bdrv_flags |= BDRV_O_SNAPSHOT;
570 }
571
572 read_only = qemu_opt_get_bool(opts, BDRV_OPT_READ_ONLY, false);
573
574 /* init */
575 if ((!file || !*file) && !qdict_size(bs_opts)) {
576 BlockBackendRootState *blk_rs;
577
578 blk = blk_new(qemu_get_aio_context(), 0, BLK_PERM_ALL);
579 blk_rs = blk_get_root_state(blk);
580 blk_rs->open_flags = bdrv_flags;
581 blk_rs->read_only = read_only;
582 blk_rs->detect_zeroes = detect_zeroes;
583
584 qobject_unref(bs_opts);
585 } else {
586 if (file && !*file) {
587 file = NULL;
588 }
589
590 /* bdrv_open() defaults to the values in bdrv_flags (for compatibility
591 * with other callers) rather than what we want as the real defaults.
592 * Apply the defaults here instead. */
593 qdict_set_default_str(bs_opts, BDRV_OPT_CACHE_DIRECT, "off");
594 qdict_set_default_str(bs_opts, BDRV_OPT_CACHE_NO_FLUSH, "off");
595 qdict_set_default_str(bs_opts, BDRV_OPT_READ_ONLY,
596 read_only ? "on" : "off");
597 qdict_set_default_str(bs_opts, BDRV_OPT_AUTO_READ_ONLY, "on");
598 assert((bdrv_flags & BDRV_O_CACHE_MASK) == 0);
599
600 if (runstate_check(RUN_STATE_INMIGRATE)) {
601 bdrv_flags |= BDRV_O_INACTIVE;
602 }
603
604 blk = blk_new_open(file, NULL, bs_opts, bdrv_flags, errp);
605 if (!blk) {
606 goto err_no_bs_opts;
607 }
608 bs = blk_bs(blk);
609
610 bs->detect_zeroes = detect_zeroes;
611
612 block_acct_setup(blk_get_stats(blk), account_invalid, account_failed);
613
614 if (!parse_stats_intervals(blk_get_stats(blk), interval_list, errp)) {
615 blk_unref(blk);
616 blk = NULL;
617 goto err_no_bs_opts;
618 }
619 }
620
621 /* disk I/O throttling */
622 if (throttle_enabled(&cfg)) {
623 if (!throttling_group) {
624 throttling_group = id;
625 }
626 blk_io_limits_enable(blk, throttling_group);
627 blk_set_io_limits(blk, &cfg);
628 }
629
630 blk_set_enable_write_cache(blk, !writethrough);
631 blk_set_on_error(blk, on_read_error, on_write_error);
632
633 if (!monitor_add_blk(blk, id, errp)) {
634 blk_unref(blk);
635 blk = NULL;
636 goto err_no_bs_opts;
637 }
638
639err_no_bs_opts:
640 qemu_opts_del(opts);
641 qobject_unref(interval_dict);
642 qobject_unref(interval_list);
643 return blk;
644
645early_err:
646 qemu_opts_del(opts);
647 qobject_unref(interval_dict);
648 qobject_unref(interval_list);
649err_no_opts:
650 qobject_unref(bs_opts);
651 return NULL;
652}
653
654/* Takes the ownership of bs_opts */
655static BlockDriverState *bds_tree_init(QDict *bs_opts, Error **errp)
656{
657 int bdrv_flags = 0;
658
659 /* bdrv_open() defaults to the values in bdrv_flags (for compatibility
660 * with other callers) rather than what we want as the real defaults.
661 * Apply the defaults here instead. */
662 qdict_set_default_str(bs_opts, BDRV_OPT_CACHE_DIRECT, "off");
663 qdict_set_default_str(bs_opts, BDRV_OPT_CACHE_NO_FLUSH, "off");
664 qdict_set_default_str(bs_opts, BDRV_OPT_READ_ONLY, "off");
665
666 if (runstate_check(RUN_STATE_INMIGRATE)) {
667 bdrv_flags |= BDRV_O_INACTIVE;
668 }
669
670 return bdrv_open(NULL, NULL, bs_opts, bdrv_flags, errp);
671}
672
673void blockdev_close_all_bdrv_states(void)
674{
675 BlockDriverState *bs, *next_bs;
676
677 QTAILQ_FOREACH_SAFE(bs, &monitor_bdrv_states, monitor_list, next_bs) {
678 AioContext *ctx = bdrv_get_aio_context(bs);
679
680 aio_context_acquire(ctx);
681 bdrv_unref(bs);
682 aio_context_release(ctx);
683 }
684}
685
686/* Iterates over the list of monitor-owned BlockDriverStates */
687BlockDriverState *bdrv_next_monitor_owned(BlockDriverState *bs)
688{
689 return bs ? QTAILQ_NEXT(bs, monitor_list)
690 : QTAILQ_FIRST(&monitor_bdrv_states);
691}
692
693static void qemu_opt_rename(QemuOpts *opts, const char *from, const char *to,
694 Error **errp)
695{
696 const char *value;
697
698 value = qemu_opt_get(opts, from);
699 if (value) {
700 if (qemu_opt_find(opts, to)) {
701 error_setg(errp, "'%s' and its alias '%s' can't be used at the "
702 "same time", to, from);
703 return;
704 }
705 }
706
707 /* rename all items in opts */
708 while ((value = qemu_opt_get(opts, from))) {
709 qemu_opt_set(opts, to, value, &error_abort);
710 qemu_opt_unset(opts, from);
711 }
712}
713
714QemuOptsList qemu_legacy_drive_opts = {
715 .name = "drive",
716 .head = QTAILQ_HEAD_INITIALIZER(qemu_legacy_drive_opts.head),
717 .desc = {
718 {
719 .name = "bus",
720 .type = QEMU_OPT_NUMBER,
721 .help = "bus number",
722 },{
723 .name = "unit",
724 .type = QEMU_OPT_NUMBER,
725 .help = "unit number (i.e. lun for scsi)",
726 },{
727 .name = "index",
728 .type = QEMU_OPT_NUMBER,
729 .help = "index number",
730 },{
731 .name = "media",
732 .type = QEMU_OPT_STRING,
733 .help = "media type (disk, cdrom)",
734 },{
735 .name = "if",
736 .type = QEMU_OPT_STRING,
737 .help = "interface (ide, scsi, sd, mtd, floppy, pflash, virtio)",
738 },{
739 .name = "file",
740 .type = QEMU_OPT_STRING,
741 .help = "file name",
742 },
743
744 /* Options that are passed on, but have special semantics with -drive */
745 {
746 .name = BDRV_OPT_READ_ONLY,
747 .type = QEMU_OPT_BOOL,
748 .help = "open drive file as read-only",
749 },{
750 .name = "rerror",
751 .type = QEMU_OPT_STRING,
752 .help = "read error action",
753 },{
754 .name = "werror",
755 .type = QEMU_OPT_STRING,
756 .help = "write error action",
757 },{
758 .name = "copy-on-read",
759 .type = QEMU_OPT_BOOL,
760 .help = "copy read data from backing file into image file",
761 },
762
763 { /* end of list */ }
764 },
765};
766
767DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type,
768 Error **errp)
769{
770 const char *value;
771 BlockBackend *blk;
772 DriveInfo *dinfo = NULL;
773 QDict *bs_opts;
774 QemuOpts *legacy_opts;
775 DriveMediaType media = MEDIA_DISK;
776 BlockInterfaceType type;
777 int max_devs, bus_id, unit_id, index;
778 const char *werror, *rerror;
779 bool read_only = false;
780 bool copy_on_read;
781 const char *filename;
782 Error *local_err = NULL;
783 int i;
784
785 /* Change legacy command line options into QMP ones */
786 static const struct {
787 const char *from;
788 const char *to;
789 } opt_renames[] = {
790 { "iops", "throttling.iops-total" },
791 { "iops_rd", "throttling.iops-read" },
792 { "iops_wr", "throttling.iops-write" },
793
794 { "bps", "throttling.bps-total" },
795 { "bps_rd", "throttling.bps-read" },
796 { "bps_wr", "throttling.bps-write" },
797
798 { "iops_max", "throttling.iops-total-max" },
799 { "iops_rd_max", "throttling.iops-read-max" },
800 { "iops_wr_max", "throttling.iops-write-max" },
801
802 { "bps_max", "throttling.bps-total-max" },
803 { "bps_rd_max", "throttling.bps-read-max" },
804 { "bps_wr_max", "throttling.bps-write-max" },
805
806 { "iops_size", "throttling.iops-size" },
807
808 { "group", "throttling.group" },
809
810 { "readonly", BDRV_OPT_READ_ONLY },
811 };
812
813 for (i = 0; i < ARRAY_SIZE(opt_renames); i++) {
814 qemu_opt_rename(all_opts, opt_renames[i].from, opt_renames[i].to,
815 &local_err);
816 if (local_err) {
817 error_propagate(errp, local_err);
818 return NULL;
819 }
820 }
821
822 value = qemu_opt_get(all_opts, "cache");
823 if (value) {
824 int flags = 0;
825 bool writethrough;
826
827 if (bdrv_parse_cache_mode(value, &flags, &writethrough) != 0) {
828 error_setg(errp, "invalid cache option");
829 return NULL;
830 }
831
832 /* Specific options take precedence */
833 if (!qemu_opt_get(all_opts, BDRV_OPT_CACHE_WB)) {
834 qemu_opt_set_bool(all_opts, BDRV_OPT_CACHE_WB,
835 !writethrough, &error_abort);
836 }
837 if (!qemu_opt_get(all_opts, BDRV_OPT_CACHE_DIRECT)) {
838 qemu_opt_set_bool(all_opts, BDRV_OPT_CACHE_DIRECT,
839 !!(flags & BDRV_O_NOCACHE), &error_abort);
840 }
841 if (!qemu_opt_get(all_opts, BDRV_OPT_CACHE_NO_FLUSH)) {
842 qemu_opt_set_bool(all_opts, BDRV_OPT_CACHE_NO_FLUSH,
843 !!(flags & BDRV_O_NO_FLUSH), &error_abort);
844 }
845 qemu_opt_unset(all_opts, "cache");
846 }
847
848 /* Get a QDict for processing the options */
849 bs_opts = qdict_new();
850 qemu_opts_to_qdict(all_opts, bs_opts);
851
852 legacy_opts = qemu_opts_create(&qemu_legacy_drive_opts, NULL, 0,
853 &error_abort);
854 qemu_opts_absorb_qdict(legacy_opts, bs_opts, &local_err);
855 if (local_err) {
856 error_propagate(errp, local_err);
857 goto fail;
858 }
859
860 /* Media type */
861 value = qemu_opt_get(legacy_opts, "media");
862 if (value) {
863 if (!strcmp(value, "disk")) {
864 media = MEDIA_DISK;
865 } else if (!strcmp(value, "cdrom")) {
866 media = MEDIA_CDROM;
867 read_only = true;
868 } else {
869 error_setg(errp, "'%s' invalid media", value);
870 goto fail;
871 }
872 }
873
874 /* copy-on-read is disabled with a warning for read-only devices */
875 read_only |= qemu_opt_get_bool(legacy_opts, BDRV_OPT_READ_ONLY, false);
876 copy_on_read = qemu_opt_get_bool(legacy_opts, "copy-on-read", false);
877
878 if (read_only && copy_on_read) {
879 warn_report("disabling copy-on-read on read-only drive");
880 copy_on_read = false;
881 }
882
883 qdict_put_str(bs_opts, BDRV_OPT_READ_ONLY, read_only ? "on" : "off");
884 qdict_put_str(bs_opts, "copy-on-read", copy_on_read ? "on" : "off");
885
886 /* Controller type */
887 value = qemu_opt_get(legacy_opts, "if");
888 if (value) {
889 for (type = 0;
890 type < IF_COUNT && strcmp(value, if_name[type]);
891 type++) {
892 }
893 if (type == IF_COUNT) {
894 error_setg(errp, "unsupported bus type '%s'", value);
895 goto fail;
896 }
897 } else {
898 type = block_default_type;
899 }
900
901 /* Device address specified by bus/unit or index.
902 * If none was specified, try to find the first free one. */
903 bus_id = qemu_opt_get_number(legacy_opts, "bus", 0);
904 unit_id = qemu_opt_get_number(legacy_opts, "unit", -1);
905 index = qemu_opt_get_number(legacy_opts, "index", -1);
906
907 max_devs = if_max_devs[type];
908
909 if (index != -1) {
910 if (bus_id != 0 || unit_id != -1) {
911 error_setg(errp, "index cannot be used with bus and unit");
912 goto fail;
913 }
914 bus_id = drive_index_to_bus_id(type, index);
915 unit_id = drive_index_to_unit_id(type, index);
916 }
917
918 if (unit_id == -1) {
919 unit_id = 0;
920 while (drive_get(type, bus_id, unit_id) != NULL) {
921 unit_id++;
922 if (max_devs && unit_id >= max_devs) {
923 unit_id -= max_devs;
924 bus_id++;
925 }
926 }
927 }
928
929 if (max_devs && unit_id >= max_devs) {
930 error_setg(errp, "unit %d too big (max is %d)", unit_id, max_devs - 1);
931 goto fail;
932 }
933
934 if (drive_get(type, bus_id, unit_id) != NULL) {
935 error_setg(errp, "drive with bus=%d, unit=%d (index=%d) exists",
936 bus_id, unit_id, index);
937 goto fail;
938 }
939
940 /* no id supplied -> create one */
941 if (qemu_opts_id(all_opts) == NULL) {
942 char *new_id;
943 const char *mediastr = "";
944 if (type == IF_IDE || type == IF_SCSI) {
945 mediastr = (media == MEDIA_CDROM) ? "-cd" : "-hd";
946 }
947 if (max_devs) {
948 new_id = g_strdup_printf("%s%i%s%i", if_name[type], bus_id,
949 mediastr, unit_id);
950 } else {
951 new_id = g_strdup_printf("%s%s%i", if_name[type],
952 mediastr, unit_id);
953 }
954 qdict_put_str(bs_opts, "id", new_id);
955 g_free(new_id);
956 }
957
958 /* Add virtio block device */
959 if (type == IF_VIRTIO) {
960 QemuOpts *devopts;
961 devopts = qemu_opts_create(qemu_find_opts("device"), NULL, 0,
962 &error_abort);
963 if (arch_type == QEMU_ARCH_S390X) {
964 qemu_opt_set(devopts, "driver", "virtio-blk-ccw", &error_abort);
965 } else {
966 qemu_opt_set(devopts, "driver", "virtio-blk-pci", &error_abort);
967 }
968 qemu_opt_set(devopts, "drive", qdict_get_str(bs_opts, "id"),
969 &error_abort);
970 }
971
972 filename = qemu_opt_get(legacy_opts, "file");
973
974 /* Check werror/rerror compatibility with if=... */
975 werror = qemu_opt_get(legacy_opts, "werror");
976 if (werror != NULL) {
977 if (type != IF_IDE && type != IF_SCSI && type != IF_VIRTIO &&
978 type != IF_NONE) {
979 error_setg(errp, "werror is not supported by this bus type");
980 goto fail;
981 }
982 qdict_put_str(bs_opts, "werror", werror);
983 }
984
985 rerror = qemu_opt_get(legacy_opts, "rerror");
986 if (rerror != NULL) {
987 if (type != IF_IDE && type != IF_VIRTIO && type != IF_SCSI &&
988 type != IF_NONE) {
989 error_setg(errp, "rerror is not supported by this bus type");
990 goto fail;
991 }
992 qdict_put_str(bs_opts, "rerror", rerror);
993 }
994
995 /* Actual block device init: Functionality shared with blockdev-add */
996 blk = blockdev_init(filename, bs_opts, &local_err);
997 bs_opts = NULL;
998 if (!blk) {
999 error_propagate(errp, local_err);
1000 goto fail;
1001 } else {
1002 assert(!local_err);
1003 }
1004
1005 /* Create legacy DriveInfo */
1006 dinfo = g_malloc0(sizeof(*dinfo));
1007 dinfo->opts = all_opts;
1008
1009 dinfo->type = type;
1010 dinfo->bus = bus_id;
1011 dinfo->unit = unit_id;
1012
1013 blk_set_legacy_dinfo(blk, dinfo);
1014
1015 switch(type) {
1016 case IF_IDE:
1017 case IF_SCSI:
1018 case IF_XEN:
1019 case IF_NONE:
1020 dinfo->media_cd = media == MEDIA_CDROM;
1021 break;
1022 default:
1023 break;
1024 }
1025
1026fail:
1027 qemu_opts_del(legacy_opts);
1028 qobject_unref(bs_opts);
1029 return dinfo;
1030}
1031
1032static BlockDriverState *qmp_get_root_bs(const char *name, Error **errp)
1033{
1034 BlockDriverState *bs;
1035
1036 bs = bdrv_lookup_bs(name, name, errp);
1037 if (bs == NULL) {
1038 return NULL;
1039 }
1040
1041 if (!bdrv_is_root_node(bs)) {
1042 error_setg(errp, "Need a root block node");
1043 return NULL;
1044 }
1045
1046 if (!bdrv_is_inserted(bs)) {
1047 error_setg(errp, "Device has no medium");
1048 return NULL;
1049 }
1050
1051 return bs;
1052}
1053
1054static BlockBackend *qmp_get_blk(const char *blk_name, const char *qdev_id,
1055 Error **errp)
1056{
1057 BlockBackend *blk;
1058
1059 if (!blk_name == !qdev_id) {
1060 error_setg(errp, "Need exactly one of 'device' and 'id'");
1061 return NULL;
1062 }
1063
1064 if (qdev_id) {
1065 blk = blk_by_qdev_id(qdev_id, errp);
1066 } else {
1067 blk = blk_by_name(blk_name);
1068 if (blk == NULL) {
1069 error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
1070 "Device '%s' not found", blk_name);
1071 }
1072 }
1073
1074 return blk;
1075}
1076
1077void hmp_commit(Monitor *mon, const QDict *qdict)
1078{
1079 const char *device = qdict_get_str(qdict, "device");
1080 BlockBackend *blk;
1081 int ret;
1082
1083 if (!strcmp(device, "all")) {
1084 ret = blk_commit_all();
1085 } else {
1086 BlockDriverState *bs;
1087 AioContext *aio_context;
1088
1089 blk = blk_by_name(device);
1090 if (!blk) {
1091 monitor_printf(mon, "Device '%s' not found\n", device);
1092 return;
1093 }
1094 if (!blk_is_available(blk)) {
1095 monitor_printf(mon, "Device '%s' has no medium\n", device);
1096 return;
1097 }
1098
1099 bs = blk_bs(blk);
1100 aio_context = bdrv_get_aio_context(bs);
1101 aio_context_acquire(aio_context);
1102
1103 ret = bdrv_commit(bs);
1104
1105 aio_context_release(aio_context);
1106 }
1107 if (ret < 0) {
1108 monitor_printf(mon, "'commit' error for '%s': %s\n", device,
1109 strerror(-ret));
1110 }
1111}
1112
1113static void blockdev_do_action(TransactionAction *action, Error **errp)
1114{
1115 TransactionActionList list;
1116
1117 list.value = action;
1118 list.next = NULL;
1119 qmp_transaction(&list, false, NULL, errp);
1120}
1121
1122void qmp_blockdev_snapshot_sync(bool has_device, const char *device,
1123 bool has_node_name, const char *node_name,
1124 const char *snapshot_file,
1125 bool has_snapshot_node_name,
1126 const char *snapshot_node_name,
1127 bool has_format, const char *format,
1128 bool has_mode, NewImageMode mode, Error **errp)
1129{
1130 BlockdevSnapshotSync snapshot = {
1131 .has_device = has_device,
1132 .device = (char *) device,
1133 .has_node_name = has_node_name,
1134 .node_name = (char *) node_name,
1135 .snapshot_file = (char *) snapshot_file,
1136 .has_snapshot_node_name = has_snapshot_node_name,
1137 .snapshot_node_name = (char *) snapshot_node_name,
1138 .has_format = has_format,
1139 .format = (char *) format,
1140 .has_mode = has_mode,
1141 .mode = mode,
1142 };
1143 TransactionAction action = {
1144 .type = TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_SYNC,
1145 .u.blockdev_snapshot_sync.data = &snapshot,
1146 };
1147 blockdev_do_action(&action, errp);
1148}
1149
1150void qmp_blockdev_snapshot(const char *node, const char *overlay,
1151 Error **errp)
1152{
1153 BlockdevSnapshot snapshot_data = {
1154 .node = (char *) node,
1155 .overlay = (char *) overlay
1156 };
1157 TransactionAction action = {
1158 .type = TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT,
1159 .u.blockdev_snapshot.data = &snapshot_data,
1160 };
1161 blockdev_do_action(&action, errp);
1162}
1163
1164void qmp_blockdev_snapshot_internal_sync(const char *device,
1165 const char *name,
1166 Error **errp)
1167{
1168 BlockdevSnapshotInternal snapshot = {
1169 .device = (char *) device,
1170 .name = (char *) name
1171 };
1172 TransactionAction action = {
1173 .type = TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_INTERNAL_SYNC,
1174 .u.blockdev_snapshot_internal_sync.data = &snapshot,
1175 };
1176 blockdev_do_action(&action, errp);
1177}
1178
1179SnapshotInfo *qmp_blockdev_snapshot_delete_internal_sync(const char *device,
1180 bool has_id,
1181 const char *id,
1182 bool has_name,
1183 const char *name,
1184 Error **errp)
1185{
1186 BlockDriverState *bs;
1187 AioContext *aio_context;
1188 QEMUSnapshotInfo sn;
1189 Error *local_err = NULL;
1190 SnapshotInfo *info = NULL;
1191 int ret;
1192
1193 bs = qmp_get_root_bs(device, errp);
1194 if (!bs) {
1195 return NULL;
1196 }
1197 aio_context = bdrv_get_aio_context(bs);
1198 aio_context_acquire(aio_context);
1199
1200 if (!has_id) {
1201 id = NULL;
1202 }
1203
1204 if (!has_name) {
1205 name = NULL;
1206 }
1207
1208 if (!id && !name) {
1209 error_setg(errp, "Name or id must be provided");
1210 goto out_aio_context;
1211 }
1212
1213 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_INTERNAL_SNAPSHOT_DELETE, errp)) {
1214 goto out_aio_context;
1215 }
1216
1217 ret = bdrv_snapshot_find_by_id_and_name(bs, id, name, &sn, &local_err);
1218 if (local_err) {
1219 error_propagate(errp, local_err);
1220 goto out_aio_context;
1221 }
1222 if (!ret) {
1223 error_setg(errp,
1224 "Snapshot with id '%s' and name '%s' does not exist on "
1225 "device '%s'",
1226 STR_OR_NULL(id), STR_OR_NULL(name), device);
1227 goto out_aio_context;
1228 }
1229
1230 bdrv_snapshot_delete(bs, id, name, &local_err);
1231 if (local_err) {
1232 error_propagate(errp, local_err);
1233 goto out_aio_context;
1234 }
1235
1236 aio_context_release(aio_context);
1237
1238 info = g_new0(SnapshotInfo, 1);
1239 info->id = g_strdup(sn.id_str);
1240 info->name = g_strdup(sn.name);
1241 info->date_nsec = sn.date_nsec;
1242 info->date_sec = sn.date_sec;
1243 info->vm_state_size = sn.vm_state_size;
1244 info->vm_clock_nsec = sn.vm_clock_nsec % 1000000000;
1245 info->vm_clock_sec = sn.vm_clock_nsec / 1000000000;
1246
1247 return info;
1248
1249out_aio_context:
1250 aio_context_release(aio_context);
1251 return NULL;
1252}
1253
1254/**
1255 * block_dirty_bitmap_lookup:
1256 * Return a dirty bitmap (if present), after validating
1257 * the node reference and bitmap names.
1258 *
1259 * @node: The name of the BDS node to search for bitmaps
1260 * @name: The name of the bitmap to search for
1261 * @pbs: Output pointer for BDS lookup, if desired. Can be NULL.
1262 * @errp: Output pointer for error information. Can be NULL.
1263 *
1264 * @return: A bitmap object on success, or NULL on failure.
1265 */
1266static BdrvDirtyBitmap *block_dirty_bitmap_lookup(const char *node,
1267 const char *name,
1268 BlockDriverState **pbs,
1269 Error **errp)
1270{
1271 BlockDriverState *bs;
1272 BdrvDirtyBitmap *bitmap;
1273
1274 if (!node) {
1275 error_setg(errp, "Node cannot be NULL");
1276 return NULL;
1277 }
1278 if (!name) {
1279 error_setg(errp, "Bitmap name cannot be NULL");
1280 return NULL;
1281 }
1282 bs = bdrv_lookup_bs(node, node, NULL);
1283 if (!bs) {
1284 error_setg(errp, "Node '%s' not found", node);
1285 return NULL;
1286 }
1287
1288 bitmap = bdrv_find_dirty_bitmap(bs, name);
1289 if (!bitmap) {
1290 error_setg(errp, "Dirty bitmap '%s' not found", name);
1291 return NULL;
1292 }
1293
1294 if (pbs) {
1295 *pbs = bs;
1296 }
1297
1298 return bitmap;
1299}
1300
1301/* New and old BlockDriverState structs for atomic group operations */
1302
1303typedef struct BlkActionState BlkActionState;
1304
1305/**
1306 * BlkActionOps:
1307 * Table of operations that define an Action.
1308 *
1309 * @instance_size: Size of state struct, in bytes.
1310 * @prepare: Prepare the work, must NOT be NULL.
1311 * @commit: Commit the changes, can be NULL.
1312 * @abort: Abort the changes on fail, can be NULL.
1313 * @clean: Clean up resources after all transaction actions have called
1314 * commit() or abort(). Can be NULL.
1315 *
1316 * Only prepare() may fail. In a single transaction, only one of commit() or
1317 * abort() will be called. clean() will always be called if it is present.
1318 */
1319typedef struct BlkActionOps {
1320 size_t instance_size;
1321 void (*prepare)(BlkActionState *common, Error **errp);
1322 void (*commit)(BlkActionState *common);
1323 void (*abort)(BlkActionState *common);
1324 void (*clean)(BlkActionState *common);
1325} BlkActionOps;
1326
1327/**
1328 * BlkActionState:
1329 * Describes one Action's state within a Transaction.
1330 *
1331 * @action: QAPI-defined enum identifying which Action to perform.
1332 * @ops: Table of ActionOps this Action can perform.
1333 * @block_job_txn: Transaction which this action belongs to.
1334 * @entry: List membership for all Actions in this Transaction.
1335 *
1336 * This structure must be arranged as first member in a subclassed type,
1337 * assuming that the compiler will also arrange it to the same offsets as the
1338 * base class.
1339 */
1340struct BlkActionState {
1341 TransactionAction *action;
1342 const BlkActionOps *ops;
1343 JobTxn *block_job_txn;
1344 TransactionProperties *txn_props;
1345 QTAILQ_ENTRY(BlkActionState) entry;
1346};
1347
1348/* internal snapshot private data */
1349typedef struct InternalSnapshotState {
1350 BlkActionState common;
1351 BlockDriverState *bs;
1352 QEMUSnapshotInfo sn;
1353 bool created;
1354} InternalSnapshotState;
1355
1356
1357static int action_check_completion_mode(BlkActionState *s, Error **errp)
1358{
1359 if (s->txn_props->completion_mode != ACTION_COMPLETION_MODE_INDIVIDUAL) {
1360 error_setg(errp,
1361 "Action '%s' does not support Transaction property "
1362 "completion-mode = %s",
1363 TransactionActionKind_str(s->action->type),
1364 ActionCompletionMode_str(s->txn_props->completion_mode));
1365 return -1;
1366 }
1367 return 0;
1368}
1369
1370static void internal_snapshot_prepare(BlkActionState *common,
1371 Error **errp)
1372{
1373 Error *local_err = NULL;
1374 const char *device;
1375 const char *name;
1376 BlockDriverState *bs;
1377 QEMUSnapshotInfo old_sn, *sn;
1378 bool ret;
1379 qemu_timeval tv;
1380 BlockdevSnapshotInternal *internal;
1381 InternalSnapshotState *state;
1382 AioContext *aio_context;
1383 int ret1;
1384
1385 g_assert(common->action->type ==
1386 TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_INTERNAL_SYNC);
1387 internal = common->action->u.blockdev_snapshot_internal_sync.data;
1388 state = DO_UPCAST(InternalSnapshotState, common, common);
1389
1390 /* 1. parse input */
1391 device = internal->device;
1392 name = internal->name;
1393
1394 /* 2. check for validation */
1395 if (action_check_completion_mode(common, errp) < 0) {
1396 return;
1397 }
1398
1399 bs = qmp_get_root_bs(device, errp);
1400 if (!bs) {
1401 return;
1402 }
1403
1404 aio_context = bdrv_get_aio_context(bs);
1405 aio_context_acquire(aio_context);
1406
1407 state->bs = bs;
1408
1409 /* Paired with .clean() */
1410 bdrv_drained_begin(bs);
1411
1412 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_INTERNAL_SNAPSHOT, errp)) {
1413 goto out;
1414 }
1415
1416 if (bdrv_is_read_only(bs)) {
1417 error_setg(errp, "Device '%s' is read only", device);
1418 goto out;
1419 }
1420
1421 if (!bdrv_can_snapshot(bs)) {
1422 error_setg(errp, "Block format '%s' used by device '%s' "
1423 "does not support internal snapshots",
1424 bs->drv->format_name, device);
1425 goto out;
1426 }
1427
1428 if (!strlen(name)) {
1429 error_setg(errp, "Name is empty");
1430 goto out;
1431 }
1432
1433 /* check whether a snapshot with name exist */
1434 ret = bdrv_snapshot_find_by_id_and_name(bs, NULL, name, &old_sn,
1435 &local_err);
1436 if (local_err) {
1437 error_propagate(errp, local_err);
1438 goto out;
1439 } else if (ret) {
1440 error_setg(errp,
1441 "Snapshot with name '%s' already exists on device '%s'",
1442 name, device);
1443 goto out;
1444 }
1445
1446 /* 3. take the snapshot */
1447 sn = &state->sn;
1448 pstrcpy(sn->name, sizeof(sn->name), name);
1449 qemu_gettimeofday(&tv);
1450 sn->date_sec = tv.tv_sec;
1451 sn->date_nsec = tv.tv_usec * 1000;
1452 sn->vm_clock_nsec = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
1453
1454 ret1 = bdrv_snapshot_create(bs, sn);
1455 if (ret1 < 0) {
1456 error_setg_errno(errp, -ret1,
1457 "Failed to create snapshot '%s' on device '%s'",
1458 name, device);
1459 goto out;
1460 }
1461
1462 /* 4. succeed, mark a snapshot is created */
1463 state->created = true;
1464
1465out:
1466 aio_context_release(aio_context);
1467}
1468
1469static void internal_snapshot_abort(BlkActionState *common)
1470{
1471 InternalSnapshotState *state =
1472 DO_UPCAST(InternalSnapshotState, common, common);
1473 BlockDriverState *bs = state->bs;
1474 QEMUSnapshotInfo *sn = &state->sn;
1475 AioContext *aio_context;
1476 Error *local_error = NULL;
1477
1478 if (!state->created) {
1479 return;
1480 }
1481
1482 aio_context = bdrv_get_aio_context(state->bs);
1483 aio_context_acquire(aio_context);
1484
1485 if (bdrv_snapshot_delete(bs, sn->id_str, sn->name, &local_error) < 0) {
1486 error_reportf_err(local_error,
1487 "Failed to delete snapshot with id '%s' and "
1488 "name '%s' on device '%s' in abort: ",
1489 sn->id_str, sn->name,
1490 bdrv_get_device_name(bs));
1491 }
1492
1493 aio_context_release(aio_context);
1494}
1495
1496static void internal_snapshot_clean(BlkActionState *common)
1497{
1498 InternalSnapshotState *state = DO_UPCAST(InternalSnapshotState,
1499 common, common);
1500 AioContext *aio_context;
1501
1502 if (!state->bs) {
1503 return;
1504 }
1505
1506 aio_context = bdrv_get_aio_context(state->bs);
1507 aio_context_acquire(aio_context);
1508
1509 bdrv_drained_end(state->bs);
1510
1511 aio_context_release(aio_context);
1512}
1513
1514/* external snapshot private data */
1515typedef struct ExternalSnapshotState {
1516 BlkActionState common;
1517 BlockDriverState *old_bs;
1518 BlockDriverState *new_bs;
1519 bool overlay_appended;
1520} ExternalSnapshotState;
1521
1522static void external_snapshot_prepare(BlkActionState *common,
1523 Error **errp)
1524{
1525 int flags = 0;
1526 QDict *options = NULL;
1527 Error *local_err = NULL;
1528 /* Device and node name of the image to generate the snapshot from */
1529 const char *device;
1530 const char *node_name;
1531 /* Reference to the new image (for 'blockdev-snapshot') */
1532 const char *snapshot_ref;
1533 /* File name of the new image (for 'blockdev-snapshot-sync') */
1534 const char *new_image_file;
1535 ExternalSnapshotState *state =
1536 DO_UPCAST(ExternalSnapshotState, common, common);
1537 TransactionAction *action = common->action;
1538 AioContext *aio_context;
1539 int ret;
1540
1541 /* 'blockdev-snapshot' and 'blockdev-snapshot-sync' have similar
1542 * purpose but a different set of parameters */
1543 switch (action->type) {
1544 case TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT:
1545 {
1546 BlockdevSnapshot *s = action->u.blockdev_snapshot.data;
1547 device = s->node;
1548 node_name = s->node;
1549 new_image_file = NULL;
1550 snapshot_ref = s->overlay;
1551 }
1552 break;
1553 case TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_SYNC:
1554 {
1555 BlockdevSnapshotSync *s = action->u.blockdev_snapshot_sync.data;
1556 device = s->has_device ? s->device : NULL;
1557 node_name = s->has_node_name ? s->node_name : NULL;
1558 new_image_file = s->snapshot_file;
1559 snapshot_ref = NULL;
1560 }
1561 break;
1562 default:
1563 g_assert_not_reached();
1564 }
1565
1566 /* start processing */
1567 if (action_check_completion_mode(common, errp) < 0) {
1568 return;
1569 }
1570
1571 state->old_bs = bdrv_lookup_bs(device, node_name, errp);
1572 if (!state->old_bs) {
1573 return;
1574 }
1575
1576 aio_context = bdrv_get_aio_context(state->old_bs);
1577 aio_context_acquire(aio_context);
1578
1579 /* Paired with .clean() */
1580 bdrv_drained_begin(state->old_bs);
1581
1582 if (!bdrv_is_inserted(state->old_bs)) {
1583 error_setg(errp, QERR_DEVICE_HAS_NO_MEDIUM, device);
1584 goto out;
1585 }
1586
1587 if (bdrv_op_is_blocked(state->old_bs,
1588 BLOCK_OP_TYPE_EXTERNAL_SNAPSHOT, errp)) {
1589 goto out;
1590 }
1591
1592 if (!bdrv_is_read_only(state->old_bs)) {
1593 if (bdrv_flush(state->old_bs)) {
1594 error_setg(errp, QERR_IO_ERROR);
1595 goto out;
1596 }
1597 }
1598
1599 if (!bdrv_is_first_non_filter(state->old_bs)) {
1600 error_setg(errp, QERR_FEATURE_DISABLED, "snapshot");
1601 goto out;
1602 }
1603
1604 if (action->type == TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_SYNC) {
1605 BlockdevSnapshotSync *s = action->u.blockdev_snapshot_sync.data;
1606 const char *format = s->has_format ? s->format : "qcow2";
1607 enum NewImageMode mode;
1608 const char *snapshot_node_name =
1609 s->has_snapshot_node_name ? s->snapshot_node_name : NULL;
1610
1611 if (node_name && !snapshot_node_name) {
1612 error_setg(errp, "New overlay node name missing");
1613 goto out;
1614 }
1615
1616 if (snapshot_node_name &&
1617 bdrv_lookup_bs(snapshot_node_name, snapshot_node_name, NULL)) {
1618 error_setg(errp, "New overlay node name already in use");
1619 goto out;
1620 }
1621
1622 flags = state->old_bs->open_flags;
1623 flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_COPY_ON_READ);
1624 flags |= BDRV_O_NO_BACKING;
1625
1626 /* create new image w/backing file */
1627 mode = s->has_mode ? s->mode : NEW_IMAGE_MODE_ABSOLUTE_PATHS;
1628 if (mode != NEW_IMAGE_MODE_EXISTING) {
1629 int64_t size = bdrv_getlength(state->old_bs);
1630 if (size < 0) {
1631 error_setg_errno(errp, -size, "bdrv_getlength failed");
1632 goto out;
1633 }
1634 bdrv_refresh_filename(state->old_bs);
1635 bdrv_img_create(new_image_file, format,
1636 state->old_bs->filename,
1637 state->old_bs->drv->format_name,
1638 NULL, size, flags, false, &local_err);
1639 if (local_err) {
1640 error_propagate(errp, local_err);
1641 goto out;
1642 }
1643 }
1644
1645 options = qdict_new();
1646 if (snapshot_node_name) {
1647 qdict_put_str(options, "node-name", snapshot_node_name);
1648 }
1649 qdict_put_str(options, "driver", format);
1650 }
1651
1652 state->new_bs = bdrv_open(new_image_file, snapshot_ref, options, flags,
1653 errp);
1654 /* We will manually add the backing_hd field to the bs later */
1655 if (!state->new_bs) {
1656 goto out;
1657 }
1658
1659 if (bdrv_has_blk(state->new_bs)) {
1660 error_setg(errp, "The overlay is already in use");
1661 goto out;
1662 }
1663
1664 if (bdrv_op_is_blocked(state->new_bs, BLOCK_OP_TYPE_EXTERNAL_SNAPSHOT,
1665 errp)) {
1666 goto out;
1667 }
1668
1669 if (state->new_bs->backing != NULL) {
1670 error_setg(errp, "The overlay already has a backing image");
1671 goto out;
1672 }
1673
1674 if (!state->new_bs->drv->supports_backing) {
1675 error_setg(errp, "The overlay does not support backing images");
1676 goto out;
1677 }
1678
1679 ret = bdrv_try_set_aio_context(state->new_bs, aio_context, errp);
1680 if (ret < 0) {
1681 goto out;
1682 }
1683
1684 /* This removes our old bs and adds the new bs. This is an operation that
1685 * can fail, so we need to do it in .prepare; undoing it for abort is
1686 * always possible. */
1687 bdrv_ref(state->new_bs);
1688 bdrv_append(state->new_bs, state->old_bs, &local_err);
1689 if (local_err) {
1690 error_propagate(errp, local_err);
1691 goto out;
1692 }
1693 state->overlay_appended = true;
1694
1695out:
1696 aio_context_release(aio_context);
1697}
1698
1699static void external_snapshot_commit(BlkActionState *common)
1700{
1701 ExternalSnapshotState *state =
1702 DO_UPCAST(ExternalSnapshotState, common, common);
1703 AioContext *aio_context;
1704
1705 aio_context = bdrv_get_aio_context(state->old_bs);
1706 aio_context_acquire(aio_context);
1707
1708 /* We don't need (or want) to use the transactional
1709 * bdrv_reopen_multiple() across all the entries at once, because we
1710 * don't want to abort all of them if one of them fails the reopen */
1711 if (!atomic_read(&state->old_bs->copy_on_read)) {
1712 bdrv_reopen_set_read_only(state->old_bs, true, NULL);
1713 }
1714
1715 aio_context_release(aio_context);
1716}
1717
1718static void external_snapshot_abort(BlkActionState *common)
1719{
1720 ExternalSnapshotState *state =
1721 DO_UPCAST(ExternalSnapshotState, common, common);
1722 if (state->new_bs) {
1723 if (state->overlay_appended) {
1724 AioContext *aio_context;
1725
1726 aio_context = bdrv_get_aio_context(state->old_bs);
1727 aio_context_acquire(aio_context);
1728
1729 bdrv_ref(state->old_bs); /* we can't let bdrv_set_backind_hd()
1730 close state->old_bs; we need it */
1731 bdrv_set_backing_hd(state->new_bs, NULL, &error_abort);
1732 bdrv_replace_node(state->new_bs, state->old_bs, &error_abort);
1733 bdrv_unref(state->old_bs); /* bdrv_replace_node() ref'ed old_bs */
1734
1735 aio_context_release(aio_context);
1736 }
1737 }
1738}
1739
1740static void external_snapshot_clean(BlkActionState *common)
1741{
1742 ExternalSnapshotState *state =
1743 DO_UPCAST(ExternalSnapshotState, common, common);
1744 AioContext *aio_context;
1745
1746 if (!state->old_bs) {
1747 return;
1748 }
1749
1750 aio_context = bdrv_get_aio_context(state->old_bs);
1751 aio_context_acquire(aio_context);
1752
1753 bdrv_drained_end(state->old_bs);
1754 bdrv_unref(state->new_bs);
1755
1756 aio_context_release(aio_context);
1757}
1758
1759typedef struct DriveBackupState {
1760 BlkActionState common;
1761 BlockDriverState *bs;
1762 BlockJob *job;
1763} DriveBackupState;
1764
1765static BlockJob *do_drive_backup(DriveBackup *backup, JobTxn *txn,
1766 Error **errp);
1767
1768static void drive_backup_prepare(BlkActionState *common, Error **errp)
1769{
1770 DriveBackupState *state = DO_UPCAST(DriveBackupState, common, common);
1771 BlockDriverState *bs;
1772 DriveBackup *backup;
1773 AioContext *aio_context;
1774 Error *local_err = NULL;
1775
1776 assert(common->action->type == TRANSACTION_ACTION_KIND_DRIVE_BACKUP);
1777 backup = common->action->u.drive_backup.data;
1778
1779 bs = bdrv_lookup_bs(backup->device, backup->device, errp);
1780 if (!bs) {
1781 return;
1782 }
1783
1784 aio_context = bdrv_get_aio_context(bs);
1785 aio_context_acquire(aio_context);
1786
1787 /* Paired with .clean() */
1788 bdrv_drained_begin(bs);
1789
1790 state->bs = bs;
1791
1792 state->job = do_drive_backup(backup, common->block_job_txn, &local_err);
1793 if (local_err) {
1794 error_propagate(errp, local_err);
1795 goto out;
1796 }
1797
1798out:
1799 aio_context_release(aio_context);
1800}
1801
1802static void drive_backup_commit(BlkActionState *common)
1803{
1804 DriveBackupState *state = DO_UPCAST(DriveBackupState, common, common);
1805 AioContext *aio_context;
1806
1807 aio_context = bdrv_get_aio_context(state->bs);
1808 aio_context_acquire(aio_context);
1809
1810 assert(state->job);
1811 job_start(&state->job->job);
1812
1813 aio_context_release(aio_context);
1814}
1815
1816static void drive_backup_abort(BlkActionState *common)
1817{
1818 DriveBackupState *state = DO_UPCAST(DriveBackupState, common, common);
1819
1820 if (state->job) {
1821 AioContext *aio_context;
1822
1823 aio_context = bdrv_get_aio_context(state->bs);
1824 aio_context_acquire(aio_context);
1825
1826 job_cancel_sync(&state->job->job);
1827
1828 aio_context_release(aio_context);
1829 }
1830}
1831
1832static void drive_backup_clean(BlkActionState *common)
1833{
1834 DriveBackupState *state = DO_UPCAST(DriveBackupState, common, common);
1835 AioContext *aio_context;
1836
1837 if (!state->bs) {
1838 return;
1839 }
1840
1841 aio_context = bdrv_get_aio_context(state->bs);
1842 aio_context_acquire(aio_context);
1843
1844 bdrv_drained_end(state->bs);
1845
1846 aio_context_release(aio_context);
1847}
1848
1849typedef struct BlockdevBackupState {
1850 BlkActionState common;
1851 BlockDriverState *bs;
1852 BlockJob *job;
1853} BlockdevBackupState;
1854
1855static BlockJob *do_blockdev_backup(BlockdevBackup *backup, JobTxn *txn,
1856 Error **errp);
1857
1858static void blockdev_backup_prepare(BlkActionState *common, Error **errp)
1859{
1860 BlockdevBackupState *state = DO_UPCAST(BlockdevBackupState, common, common);
1861 BlockdevBackup *backup;
1862 BlockDriverState *bs, *target;
1863 AioContext *aio_context;
1864 Error *local_err = NULL;
1865
1866 assert(common->action->type == TRANSACTION_ACTION_KIND_BLOCKDEV_BACKUP);
1867 backup = common->action->u.blockdev_backup.data;
1868
1869 bs = bdrv_lookup_bs(backup->device, backup->device, errp);
1870 if (!bs) {
1871 return;
1872 }
1873
1874 target = bdrv_lookup_bs(backup->target, backup->target, errp);
1875 if (!target) {
1876 return;
1877 }
1878
1879 aio_context = bdrv_get_aio_context(bs);
1880 aio_context_acquire(aio_context);
1881 state->bs = bs;
1882
1883 /* Paired with .clean() */
1884 bdrv_drained_begin(state->bs);
1885
1886 state->job = do_blockdev_backup(backup, common->block_job_txn, &local_err);
1887 if (local_err) {
1888 error_propagate(errp, local_err);
1889 goto out;
1890 }
1891
1892out:
1893 aio_context_release(aio_context);
1894}
1895
1896static void blockdev_backup_commit(BlkActionState *common)
1897{
1898 BlockdevBackupState *state = DO_UPCAST(BlockdevBackupState, common, common);
1899 AioContext *aio_context;
1900
1901 aio_context = bdrv_get_aio_context(state->bs);
1902 aio_context_acquire(aio_context);
1903
1904 assert(state->job);
1905 job_start(&state->job->job);
1906
1907 aio_context_release(aio_context);
1908}
1909
1910static void blockdev_backup_abort(BlkActionState *common)
1911{
1912 BlockdevBackupState *state = DO_UPCAST(BlockdevBackupState, common, common);
1913
1914 if (state->job) {
1915 AioContext *aio_context;
1916
1917 aio_context = bdrv_get_aio_context(state->bs);
1918 aio_context_acquire(aio_context);
1919
1920 job_cancel_sync(&state->job->job);
1921
1922 aio_context_release(aio_context);
1923 }
1924}
1925
1926static void blockdev_backup_clean(BlkActionState *common)
1927{
1928 BlockdevBackupState *state = DO_UPCAST(BlockdevBackupState, common, common);
1929 AioContext *aio_context;
1930
1931 if (!state->bs) {
1932 return;
1933 }
1934
1935 aio_context = bdrv_get_aio_context(state->bs);
1936 aio_context_acquire(aio_context);
1937
1938 bdrv_drained_end(state->bs);
1939
1940 aio_context_release(aio_context);
1941}
1942
1943typedef struct BlockDirtyBitmapState {
1944 BlkActionState common;
1945 BdrvDirtyBitmap *bitmap;
1946 BlockDriverState *bs;
1947 HBitmap *backup;
1948 bool prepared;
1949 bool was_enabled;
1950} BlockDirtyBitmapState;
1951
1952static void block_dirty_bitmap_add_prepare(BlkActionState *common,
1953 Error **errp)
1954{
1955 Error *local_err = NULL;
1956 BlockDirtyBitmapAdd *action;
1957 BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
1958 common, common);
1959
1960 if (action_check_completion_mode(common, errp) < 0) {
1961 return;
1962 }
1963
1964 action = common->action->u.block_dirty_bitmap_add.data;
1965 /* AIO context taken and released within qmp_block_dirty_bitmap_add */
1966 qmp_block_dirty_bitmap_add(action->node, action->name,
1967 action->has_granularity, action->granularity,
1968 action->has_persistent, action->persistent,
1969 action->has_autoload, action->autoload,
1970 action->has_disabled, action->disabled,
1971 &local_err);
1972
1973 if (!local_err) {
1974 state->prepared = true;
1975 } else {
1976 error_propagate(errp, local_err);
1977 }
1978}
1979
1980static void block_dirty_bitmap_add_abort(BlkActionState *common)
1981{
1982 BlockDirtyBitmapAdd *action;
1983 BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
1984 common, common);
1985
1986 action = common->action->u.block_dirty_bitmap_add.data;
1987 /* Should not be able to fail: IF the bitmap was added via .prepare(),
1988 * then the node reference and bitmap name must have been valid.
1989 */
1990 if (state->prepared) {
1991 qmp_block_dirty_bitmap_remove(action->node, action->name, &error_abort);
1992 }
1993}
1994
1995static void block_dirty_bitmap_clear_prepare(BlkActionState *common,
1996 Error **errp)
1997{
1998 BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
1999 common, common);
2000 BlockDirtyBitmap *action;
2001
2002 if (action_check_completion_mode(common, errp) < 0) {
2003 return;
2004 }
2005
2006 action = common->action->u.block_dirty_bitmap_clear.data;
2007 state->bitmap = block_dirty_bitmap_lookup(action->node,
2008 action->name,
2009 &state->bs,
2010 errp);
2011 if (!state->bitmap) {
2012 return;
2013 }
2014
2015 if (bdrv_dirty_bitmap_check(state->bitmap, BDRV_BITMAP_DEFAULT, errp)) {
2016 return;
2017 }
2018
2019 bdrv_clear_dirty_bitmap(state->bitmap, &state->backup);
2020}
2021
2022static void block_dirty_bitmap_restore(BlkActionState *common)
2023{
2024 BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
2025 common, common);
2026
2027 if (state->backup) {
2028 bdrv_restore_dirty_bitmap(state->bitmap, state->backup);
2029 }
2030}
2031
2032static void block_dirty_bitmap_free_backup(BlkActionState *common)
2033{
2034 BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
2035 common, common);
2036
2037 hbitmap_free(state->backup);
2038}
2039
2040static void block_dirty_bitmap_enable_prepare(BlkActionState *common,
2041 Error **errp)
2042{
2043 BlockDirtyBitmap *action;
2044 BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
2045 common, common);
2046
2047 if (action_check_completion_mode(common, errp) < 0) {
2048 return;
2049 }
2050
2051 action = common->action->u.block_dirty_bitmap_enable.data;
2052 state->bitmap = block_dirty_bitmap_lookup(action->node,
2053 action->name,
2054 NULL,
2055 errp);
2056 if (!state->bitmap) {
2057 return;
2058 }
2059
2060 if (bdrv_dirty_bitmap_check(state->bitmap, BDRV_BITMAP_ALLOW_RO, errp)) {
2061 return;
2062 }
2063
2064 state->was_enabled = bdrv_dirty_bitmap_enabled(state->bitmap);
2065 bdrv_enable_dirty_bitmap(state->bitmap);
2066}
2067
2068static void block_dirty_bitmap_enable_abort(BlkActionState *common)
2069{
2070 BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
2071 common, common);
2072
2073 if (!state->was_enabled) {
2074 bdrv_disable_dirty_bitmap(state->bitmap);
2075 }
2076}
2077
2078static void block_dirty_bitmap_disable_prepare(BlkActionState *common,
2079 Error **errp)
2080{
2081 BlockDirtyBitmap *action;
2082 BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
2083 common, common);
2084
2085 if (action_check_completion_mode(common, errp) < 0) {
2086 return;
2087 }
2088
2089 action = common->action->u.block_dirty_bitmap_disable.data;
2090 state->bitmap = block_dirty_bitmap_lookup(action->node,
2091 action->name,
2092 NULL,
2093 errp);
2094 if (!state->bitmap) {
2095 return;
2096 }
2097
2098 if (bdrv_dirty_bitmap_check(state->bitmap, BDRV_BITMAP_ALLOW_RO, errp)) {
2099 return;
2100 }
2101
2102 state->was_enabled = bdrv_dirty_bitmap_enabled(state->bitmap);
2103 bdrv_disable_dirty_bitmap(state->bitmap);
2104}
2105
2106static void block_dirty_bitmap_disable_abort(BlkActionState *common)
2107{
2108 BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
2109 common, common);
2110
2111 if (state->was_enabled) {
2112 bdrv_enable_dirty_bitmap(state->bitmap);
2113 }
2114}
2115
2116static BdrvDirtyBitmap *do_block_dirty_bitmap_merge(
2117 const char *node, const char *target,
2118 BlockDirtyBitmapMergeSourceList *bitmaps,
2119 HBitmap **backup, Error **errp);
2120
2121static void block_dirty_bitmap_merge_prepare(BlkActionState *common,
2122 Error **errp)
2123{
2124 BlockDirtyBitmapMerge *action;
2125 BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
2126 common, common);
2127
2128 if (action_check_completion_mode(common, errp) < 0) {
2129 return;
2130 }
2131
2132 action = common->action->u.block_dirty_bitmap_merge.data;
2133
2134 state->bitmap = do_block_dirty_bitmap_merge(action->node, action->target,
2135 action->bitmaps, &state->backup,
2136 errp);
2137}
2138
2139static BdrvDirtyBitmap *do_block_dirty_bitmap_remove(
2140 const char *node, const char *name, bool release,
2141 BlockDriverState **bitmap_bs, Error **errp);
2142
2143static void block_dirty_bitmap_remove_prepare(BlkActionState *common,
2144 Error **errp)
2145{
2146 BlockDirtyBitmap *action;
2147 BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
2148 common, common);
2149
2150 if (action_check_completion_mode(common, errp) < 0) {
2151 return;
2152 }
2153
2154 action = common->action->u.block_dirty_bitmap_remove.data;
2155
2156 state->bitmap = do_block_dirty_bitmap_remove(action->node, action->name,
2157 false, &state->bs, errp);
2158 if (state->bitmap) {
2159 bdrv_dirty_bitmap_skip_store(state->bitmap, true);
2160 bdrv_dirty_bitmap_set_busy(state->bitmap, true);
2161 }
2162}
2163
2164static void block_dirty_bitmap_remove_abort(BlkActionState *common)
2165{
2166 BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
2167 common, common);
2168
2169 if (state->bitmap) {
2170 bdrv_dirty_bitmap_skip_store(state->bitmap, false);
2171 bdrv_dirty_bitmap_set_busy(state->bitmap, false);
2172 }
2173}
2174
2175static void block_dirty_bitmap_remove_commit(BlkActionState *common)
2176{
2177 BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
2178 common, common);
2179
2180 bdrv_dirty_bitmap_set_busy(state->bitmap, false);
2181 bdrv_release_dirty_bitmap(state->bs, state->bitmap);
2182}
2183
2184static void abort_prepare(BlkActionState *common, Error **errp)
2185{
2186 error_setg(errp, "Transaction aborted using Abort action");
2187}
2188
2189static void abort_commit(BlkActionState *common)
2190{
2191 g_assert_not_reached(); /* this action never succeeds */
2192}
2193
2194static const BlkActionOps actions[] = {
2195 [TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT] = {
2196 .instance_size = sizeof(ExternalSnapshotState),
2197 .prepare = external_snapshot_prepare,
2198 .commit = external_snapshot_commit,
2199 .abort = external_snapshot_abort,
2200 .clean = external_snapshot_clean,
2201 },
2202 [TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_SYNC] = {
2203 .instance_size = sizeof(ExternalSnapshotState),
2204 .prepare = external_snapshot_prepare,
2205 .commit = external_snapshot_commit,
2206 .abort = external_snapshot_abort,
2207 .clean = external_snapshot_clean,
2208 },
2209 [TRANSACTION_ACTION_KIND_DRIVE_BACKUP] = {
2210 .instance_size = sizeof(DriveBackupState),
2211 .prepare = drive_backup_prepare,
2212 .commit = drive_backup_commit,
2213 .abort = drive_backup_abort,
2214 .clean = drive_backup_clean,
2215 },
2216 [TRANSACTION_ACTION_KIND_BLOCKDEV_BACKUP] = {
2217 .instance_size = sizeof(BlockdevBackupState),
2218 .prepare = blockdev_backup_prepare,
2219 .commit = blockdev_backup_commit,
2220 .abort = blockdev_backup_abort,
2221 .clean = blockdev_backup_clean,
2222 },
2223 [TRANSACTION_ACTION_KIND_ABORT] = {
2224 .instance_size = sizeof(BlkActionState),
2225 .prepare = abort_prepare,
2226 .commit = abort_commit,
2227 },
2228 [TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_INTERNAL_SYNC] = {
2229 .instance_size = sizeof(InternalSnapshotState),
2230 .prepare = internal_snapshot_prepare,
2231 .abort = internal_snapshot_abort,
2232 .clean = internal_snapshot_clean,
2233 },
2234 [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_ADD] = {
2235 .instance_size = sizeof(BlockDirtyBitmapState),
2236 .prepare = block_dirty_bitmap_add_prepare,
2237 .abort = block_dirty_bitmap_add_abort,
2238 },
2239 [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_CLEAR] = {
2240 .instance_size = sizeof(BlockDirtyBitmapState),
2241 .prepare = block_dirty_bitmap_clear_prepare,
2242 .commit = block_dirty_bitmap_free_backup,
2243 .abort = block_dirty_bitmap_restore,
2244 },
2245 [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_ENABLE] = {
2246 .instance_size = sizeof(BlockDirtyBitmapState),
2247 .prepare = block_dirty_bitmap_enable_prepare,
2248 .abort = block_dirty_bitmap_enable_abort,
2249 },
2250 [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_DISABLE] = {
2251 .instance_size = sizeof(BlockDirtyBitmapState),
2252 .prepare = block_dirty_bitmap_disable_prepare,
2253 .abort = block_dirty_bitmap_disable_abort,
2254 },
2255 [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_MERGE] = {
2256 .instance_size = sizeof(BlockDirtyBitmapState),
2257 .prepare = block_dirty_bitmap_merge_prepare,
2258 .commit = block_dirty_bitmap_free_backup,
2259 .abort = block_dirty_bitmap_restore,
2260 },
2261 [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_REMOVE] = {
2262 .instance_size = sizeof(BlockDirtyBitmapState),
2263 .prepare = block_dirty_bitmap_remove_prepare,
2264 .commit = block_dirty_bitmap_remove_commit,
2265 .abort = block_dirty_bitmap_remove_abort,
2266 },
2267 /* Where are transactions for MIRROR, COMMIT and STREAM?
2268 * Although these blockjobs use transaction callbacks like the backup job,
2269 * these jobs do not necessarily adhere to transaction semantics.
2270 * These jobs may not fully undo all of their actions on abort, nor do they
2271 * necessarily work in transactions with more than one job in them.
2272 */
2273};
2274
2275/**
2276 * Allocate a TransactionProperties structure if necessary, and fill
2277 * that structure with desired defaults if they are unset.
2278 */
2279static TransactionProperties *get_transaction_properties(
2280 TransactionProperties *props)
2281{
2282 if (!props) {
2283 props = g_new0(TransactionProperties, 1);
2284 }
2285
2286 if (!props->has_completion_mode) {
2287 props->has_completion_mode = true;
2288 props->completion_mode = ACTION_COMPLETION_MODE_INDIVIDUAL;
2289 }
2290
2291 return props;
2292}
2293
2294/*
2295 * 'Atomic' group operations. The operations are performed as a set, and if
2296 * any fail then we roll back all operations in the group.
2297 */
2298void qmp_transaction(TransactionActionList *dev_list,
2299 bool has_props,
2300 struct TransactionProperties *props,
2301 Error **errp)
2302{
2303 TransactionActionList *dev_entry = dev_list;
2304 JobTxn *block_job_txn = NULL;
2305 BlkActionState *state, *next;
2306 Error *local_err = NULL;
2307
2308 QTAILQ_HEAD(, BlkActionState) snap_bdrv_states;
2309 QTAILQ_INIT(&snap_bdrv_states);
2310
2311 /* Does this transaction get canceled as a group on failure?
2312 * If not, we don't really need to make a JobTxn.
2313 */
2314 props = get_transaction_properties(props);
2315 if (props->completion_mode != ACTION_COMPLETION_MODE_INDIVIDUAL) {
2316 block_job_txn = job_txn_new();
2317 }
2318
2319 /* drain all i/o before any operations */
2320 bdrv_drain_all();
2321
2322 /* We don't do anything in this loop that commits us to the operations */
2323 while (NULL != dev_entry) {
2324 TransactionAction *dev_info = NULL;
2325 const BlkActionOps *ops;
2326
2327 dev_info = dev_entry->value;
2328 dev_entry = dev_entry->next;
2329
2330 assert(dev_info->type < ARRAY_SIZE(actions));
2331
2332 ops = &actions[dev_info->type];
2333 assert(ops->instance_size > 0);
2334
2335 state = g_malloc0(ops->instance_size);
2336 state->ops = ops;
2337 state->action = dev_info;
2338 state->block_job_txn = block_job_txn;
2339 state->txn_props = props;
2340 QTAILQ_INSERT_TAIL(&snap_bdrv_states, state, entry);
2341
2342 state->ops->prepare(state, &local_err);
2343 if (local_err) {
2344 error_propagate(errp, local_err);
2345 goto delete_and_fail;
2346 }
2347 }
2348
2349 QTAILQ_FOREACH(state, &snap_bdrv_states, entry) {
2350 if (state->ops->commit) {
2351 state->ops->commit(state);
2352 }
2353 }
2354
2355 /* success */
2356 goto exit;
2357
2358delete_and_fail:
2359 /* failure, and it is all-or-none; roll back all operations */
2360 QTAILQ_FOREACH_REVERSE(state, &snap_bdrv_states, entry) {
2361 if (state->ops->abort) {
2362 state->ops->abort(state);
2363 }
2364 }
2365exit:
2366 QTAILQ_FOREACH_SAFE(state, &snap_bdrv_states, entry, next) {
2367 if (state->ops->clean) {
2368 state->ops->clean(state);
2369 }
2370 g_free(state);
2371 }
2372 if (!has_props) {
2373 qapi_free_TransactionProperties(props);
2374 }
2375 job_txn_unref(block_job_txn);
2376}
2377
2378void qmp_eject(bool has_device, const char *device,
2379 bool has_id, const char *id,
2380 bool has_force, bool force, Error **errp)
2381{
2382 Error *local_err = NULL;
2383 int rc;
2384
2385 if (!has_force) {
2386 force = false;
2387 }
2388
2389 rc = do_open_tray(has_device ? device : NULL,
2390 has_id ? id : NULL,
2391 force, &local_err);
2392 if (rc && rc != -ENOSYS) {
2393 error_propagate(errp, local_err);
2394 return;
2395 }
2396 error_free(local_err);
2397
2398 blockdev_remove_medium(has_device, device, has_id, id, errp);
2399}
2400
2401void qmp_block_passwd(bool has_device, const char *device,
2402 bool has_node_name, const char *node_name,
2403 const char *password, Error **errp)
2404{
2405 error_setg(errp,
2406 "Setting block passwords directly is no longer supported");
2407}
2408
2409/*
2410 * Attempt to open the tray of @device.
2411 * If @force, ignore its tray lock.
2412 * Else, if the tray is locked, don't open it, but ask the guest to open it.
2413 * On error, store an error through @errp and return -errno.
2414 * If @device does not exist, return -ENODEV.
2415 * If it has no removable media, return -ENOTSUP.
2416 * If it has no tray, return -ENOSYS.
2417 * If the guest was asked to open the tray, return -EINPROGRESS.
2418 * Else, return 0.
2419 */
2420static int do_open_tray(const char *blk_name, const char *qdev_id,
2421 bool force, Error **errp)
2422{
2423 BlockBackend *blk;
2424 const char *device = qdev_id ?: blk_name;
2425 bool locked;
2426
2427 blk = qmp_get_blk(blk_name, qdev_id, errp);
2428 if (!blk) {
2429 return -ENODEV;
2430 }
2431
2432 if (!blk_dev_has_removable_media(blk)) {
2433 error_setg(errp, "Device '%s' is not removable", device);
2434 return -ENOTSUP;
2435 }
2436
2437 if (!blk_dev_has_tray(blk)) {
2438 error_setg(errp, "Device '%s' does not have a tray", device);
2439 return -ENOSYS;
2440 }
2441
2442 if (blk_dev_is_tray_open(blk)) {
2443 return 0;
2444 }
2445
2446 locked = blk_dev_is_medium_locked(blk);
2447 if (locked) {
2448 blk_dev_eject_request(blk, force);
2449 }
2450
2451 if (!locked || force) {
2452 blk_dev_change_media_cb(blk, false, &error_abort);
2453 }
2454
2455 if (locked && !force) {
2456 error_setg(errp, "Device '%s' is locked and force was not specified, "
2457 "wait for tray to open and try again", device);
2458 return -EINPROGRESS;
2459 }
2460
2461 return 0;
2462}
2463
2464void qmp_blockdev_open_tray(bool has_device, const char *device,
2465 bool has_id, const char *id,
2466 bool has_force, bool force,
2467 Error **errp)
2468{
2469 Error *local_err = NULL;
2470 int rc;
2471
2472 if (!has_force) {
2473 force = false;
2474 }
2475 rc = do_open_tray(has_device ? device : NULL,
2476 has_id ? id : NULL,
2477 force, &local_err);
2478 if (rc && rc != -ENOSYS && rc != -EINPROGRESS) {
2479 error_propagate(errp, local_err);
2480 return;
2481 }
2482 error_free(local_err);
2483}
2484
2485void qmp_blockdev_close_tray(bool has_device, const char *device,
2486 bool has_id, const char *id,
2487 Error **errp)
2488{
2489 BlockBackend *blk;
2490 Error *local_err = NULL;
2491
2492 device = has_device ? device : NULL;
2493 id = has_id ? id : NULL;
2494
2495 blk = qmp_get_blk(device, id, errp);
2496 if (!blk) {
2497 return;
2498 }
2499
2500 if (!blk_dev_has_removable_media(blk)) {
2501 error_setg(errp, "Device '%s' is not removable", device ?: id);
2502 return;
2503 }
2504
2505 if (!blk_dev_has_tray(blk)) {
2506 /* Ignore this command on tray-less devices */
2507 return;
2508 }
2509
2510 if (!blk_dev_is_tray_open(blk)) {
2511 return;
2512 }
2513
2514 blk_dev_change_media_cb(blk, true, &local_err);
2515 if (local_err) {
2516 error_propagate(errp, local_err);
2517 return;
2518 }
2519}
2520
2521static void blockdev_remove_medium(bool has_device, const char *device,
2522 bool has_id, const char *id, Error **errp)
2523{
2524 BlockBackend *blk;
2525 BlockDriverState *bs;
2526 AioContext *aio_context;
2527 bool has_attached_device;
2528
2529 device = has_device ? device : NULL;
2530 id = has_id ? id : NULL;
2531
2532 blk = qmp_get_blk(device, id, errp);
2533 if (!blk) {
2534 return;
2535 }
2536
2537 /* For BBs without a device, we can exchange the BDS tree at will */
2538 has_attached_device = blk_get_attached_dev(blk);
2539
2540 if (has_attached_device && !blk_dev_has_removable_media(blk)) {
2541 error_setg(errp, "Device '%s' is not removable", device ?: id);
2542 return;
2543 }
2544
2545 if (has_attached_device && blk_dev_has_tray(blk) &&
2546 !blk_dev_is_tray_open(blk))
2547 {
2548 error_setg(errp, "Tray of device '%s' is not open", device ?: id);
2549 return;
2550 }
2551
2552 bs = blk_bs(blk);
2553 if (!bs) {
2554 return;
2555 }
2556
2557 aio_context = bdrv_get_aio_context(bs);
2558 aio_context_acquire(aio_context);
2559
2560 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_EJECT, errp)) {
2561 goto out;
2562 }
2563
2564 blk_remove_bs(blk);
2565
2566 if (!blk_dev_has_tray(blk)) {
2567 /* For tray-less devices, blockdev-open-tray is a no-op (or may not be
2568 * called at all); therefore, the medium needs to be ejected here.
2569 * Do it after blk_remove_bs() so blk_is_inserted(blk) returns the @load
2570 * value passed here (i.e. false). */
2571 blk_dev_change_media_cb(blk, false, &error_abort);
2572 }
2573
2574out:
2575 aio_context_release(aio_context);
2576}
2577
2578void qmp_blockdev_remove_medium(const char *id, Error **errp)
2579{
2580 blockdev_remove_medium(false, NULL, true, id, errp);
2581}
2582
2583static void qmp_blockdev_insert_anon_medium(BlockBackend *blk,
2584 BlockDriverState *bs, Error **errp)
2585{
2586 Error *local_err = NULL;
2587 bool has_device;
2588 int ret;
2589
2590 /* For BBs without a device, we can exchange the BDS tree at will */
2591 has_device = blk_get_attached_dev(blk);
2592
2593 if (has_device && !blk_dev_has_removable_media(blk)) {
2594 error_setg(errp, "Device is not removable");
2595 return;
2596 }
2597
2598 if (has_device && blk_dev_has_tray(blk) && !blk_dev_is_tray_open(blk)) {
2599 error_setg(errp, "Tray of the device is not open");
2600 return;
2601 }
2602
2603 if (blk_bs(blk)) {
2604 error_setg(errp, "There already is a medium in the device");
2605 return;
2606 }
2607
2608 ret = blk_insert_bs(blk, bs, errp);
2609 if (ret < 0) {
2610 return;
2611 }
2612
2613 if (!blk_dev_has_tray(blk)) {
2614 /* For tray-less devices, blockdev-close-tray is a no-op (or may not be
2615 * called at all); therefore, the medium needs to be pushed into the
2616 * slot here.
2617 * Do it after blk_insert_bs() so blk_is_inserted(blk) returns the @load
2618 * value passed here (i.e. true). */
2619 blk_dev_change_media_cb(blk, true, &local_err);
2620 if (local_err) {
2621 error_propagate(errp, local_err);
2622 blk_remove_bs(blk);
2623 return;
2624 }
2625 }
2626}
2627
2628static void blockdev_insert_medium(bool has_device, const char *device,
2629 bool has_id, const char *id,
2630 const char *node_name, Error **errp)
2631{
2632 BlockBackend *blk;
2633 BlockDriverState *bs;
2634
2635 blk = qmp_get_blk(has_device ? device : NULL,
2636 has_id ? id : NULL,
2637 errp);
2638 if (!blk) {
2639 return;
2640 }
2641
2642 bs = bdrv_find_node(node_name);
2643 if (!bs) {
2644 error_setg(errp, "Node '%s' not found", node_name);
2645 return;
2646 }
2647
2648 if (bdrv_has_blk(bs)) {
2649 error_setg(errp, "Node '%s' is already in use", node_name);
2650 return;
2651 }
2652
2653 qmp_blockdev_insert_anon_medium(blk, bs, errp);
2654}
2655
2656void qmp_blockdev_insert_medium(const char *id, const char *node_name,
2657 Error **errp)
2658{
2659 blockdev_insert_medium(false, NULL, true, id, node_name, errp);
2660}
2661
2662void qmp_blockdev_change_medium(bool has_device, const char *device,
2663 bool has_id, const char *id,
2664 const char *filename,
2665 bool has_format, const char *format,
2666 bool has_read_only,
2667 BlockdevChangeReadOnlyMode read_only,
2668 Error **errp)
2669{
2670 BlockBackend *blk;
2671 BlockDriverState *medium_bs = NULL;
2672 int bdrv_flags;
2673 bool detect_zeroes;
2674 int rc;
2675 QDict *options = NULL;
2676 Error *err = NULL;
2677
2678 blk = qmp_get_blk(has_device ? device : NULL,
2679 has_id ? id : NULL,
2680 errp);
2681 if (!blk) {
2682 goto fail;
2683 }
2684
2685 if (blk_bs(blk)) {
2686 blk_update_root_state(blk);
2687 }
2688
2689 bdrv_flags = blk_get_open_flags_from_root_state(blk);
2690 bdrv_flags &= ~(BDRV_O_TEMPORARY | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING |
2691 BDRV_O_PROTOCOL | BDRV_O_AUTO_RDONLY);
2692
2693 if (!has_read_only) {
2694 read_only = BLOCKDEV_CHANGE_READ_ONLY_MODE_RETAIN;
2695 }
2696
2697 switch (read_only) {
2698 case BLOCKDEV_CHANGE_READ_ONLY_MODE_RETAIN:
2699 break;
2700
2701 case BLOCKDEV_CHANGE_READ_ONLY_MODE_READ_ONLY:
2702 bdrv_flags &= ~BDRV_O_RDWR;
2703 break;
2704
2705 case BLOCKDEV_CHANGE_READ_ONLY_MODE_READ_WRITE:
2706 bdrv_flags |= BDRV_O_RDWR;
2707 break;
2708
2709 default:
2710 abort();
2711 }
2712
2713 options = qdict_new();
2714 detect_zeroes = blk_get_detect_zeroes_from_root_state(blk);
2715 qdict_put_str(options, "detect-zeroes", detect_zeroes ? "on" : "off");
2716
2717 if (has_format) {
2718 qdict_put_str(options, "driver", format);
2719 }
2720
2721 medium_bs = bdrv_open(filename, NULL, options, bdrv_flags, errp);
2722 if (!medium_bs) {
2723 goto fail;
2724 }
2725
2726 rc = do_open_tray(has_device ? device : NULL,
2727 has_id ? id : NULL,
2728 false, &err);
2729 if (rc && rc != -ENOSYS) {
2730 error_propagate(errp, err);
2731 goto fail;
2732 }
2733 error_free(err);
2734 err = NULL;
2735
2736 blockdev_remove_medium(has_device, device, has_id, id, &err);
2737 if (err) {
2738 error_propagate(errp, err);
2739 goto fail;
2740 }
2741
2742 qmp_blockdev_insert_anon_medium(blk, medium_bs, &err);
2743 if (err) {
2744 error_propagate(errp, err);
2745 goto fail;
2746 }
2747
2748 qmp_blockdev_close_tray(has_device, device, has_id, id, errp);
2749
2750fail:
2751 /* If the medium has been inserted, the device has its own reference, so
2752 * ours must be relinquished; and if it has not been inserted successfully,
2753 * the reference must be relinquished anyway */
2754 bdrv_unref(medium_bs);
2755}
2756
2757/* throttling disk I/O limits */
2758void qmp_block_set_io_throttle(BlockIOThrottle *arg, Error **errp)
2759{
2760 ThrottleConfig cfg;
2761 BlockDriverState *bs;
2762 BlockBackend *blk;
2763 AioContext *aio_context;
2764
2765 blk = qmp_get_blk(arg->has_device ? arg->device : NULL,
2766 arg->has_id ? arg->id : NULL,
2767 errp);
2768 if (!blk) {
2769 return;
2770 }
2771
2772 aio_context = blk_get_aio_context(blk);
2773 aio_context_acquire(aio_context);
2774
2775 bs = blk_bs(blk);
2776 if (!bs) {
2777 error_setg(errp, "Device has no medium");
2778 goto out;
2779 }
2780
2781 throttle_config_init(&cfg);
2782 cfg.buckets[THROTTLE_BPS_TOTAL].avg = arg->bps;
2783 cfg.buckets[THROTTLE_BPS_READ].avg = arg->bps_rd;
2784 cfg.buckets[THROTTLE_BPS_WRITE].avg = arg->bps_wr;
2785
2786 cfg.buckets[THROTTLE_OPS_TOTAL].avg = arg->iops;
2787 cfg.buckets[THROTTLE_OPS_READ].avg = arg->iops_rd;
2788 cfg.buckets[THROTTLE_OPS_WRITE].avg = arg->iops_wr;
2789
2790 if (arg->has_bps_max) {
2791 cfg.buckets[THROTTLE_BPS_TOTAL].max = arg->bps_max;
2792 }
2793 if (arg->has_bps_rd_max) {
2794 cfg.buckets[THROTTLE_BPS_READ].max = arg->bps_rd_max;
2795 }
2796 if (arg->has_bps_wr_max) {
2797 cfg.buckets[THROTTLE_BPS_WRITE].max = arg->bps_wr_max;
2798 }
2799 if (arg->has_iops_max) {
2800 cfg.buckets[THROTTLE_OPS_TOTAL].max = arg->iops_max;
2801 }
2802 if (arg->has_iops_rd_max) {
2803 cfg.buckets[THROTTLE_OPS_READ].max = arg->iops_rd_max;
2804 }
2805 if (arg->has_iops_wr_max) {
2806 cfg.buckets[THROTTLE_OPS_WRITE].max = arg->iops_wr_max;
2807 }
2808
2809 if (arg->has_bps_max_length) {
2810 cfg.buckets[THROTTLE_BPS_TOTAL].burst_length = arg->bps_max_length;
2811 }
2812 if (arg->has_bps_rd_max_length) {
2813 cfg.buckets[THROTTLE_BPS_READ].burst_length = arg->bps_rd_max_length;
2814 }
2815 if (arg->has_bps_wr_max_length) {
2816 cfg.buckets[THROTTLE_BPS_WRITE].burst_length = arg->bps_wr_max_length;
2817 }
2818 if (arg->has_iops_max_length) {
2819 cfg.buckets[THROTTLE_OPS_TOTAL].burst_length = arg->iops_max_length;
2820 }
2821 if (arg->has_iops_rd_max_length) {
2822 cfg.buckets[THROTTLE_OPS_READ].burst_length = arg->iops_rd_max_length;
2823 }
2824 if (arg->has_iops_wr_max_length) {
2825 cfg.buckets[THROTTLE_OPS_WRITE].burst_length = arg->iops_wr_max_length;
2826 }
2827
2828 if (arg->has_iops_size) {
2829 cfg.op_size = arg->iops_size;
2830 }
2831
2832 if (!throttle_is_valid(&cfg, errp)) {
2833 goto out;
2834 }
2835
2836 if (throttle_enabled(&cfg)) {
2837 /* Enable I/O limits if they're not enabled yet, otherwise
2838 * just update the throttling group. */
2839 if (!blk_get_public(blk)->throttle_group_member.throttle_state) {
2840 blk_io_limits_enable(blk,
2841 arg->has_group ? arg->group :
2842 arg->has_device ? arg->device :
2843 arg->id);
2844 } else if (arg->has_group) {
2845 blk_io_limits_update_group(blk, arg->group);
2846 }
2847 /* Set the new throttling configuration */
2848 blk_set_io_limits(blk, &cfg);
2849 } else if (blk_get_public(blk)->throttle_group_member.throttle_state) {
2850 /* If all throttling settings are set to 0, disable I/O limits */
2851 blk_io_limits_disable(blk);
2852 }
2853
2854out:
2855 aio_context_release(aio_context);
2856}
2857
2858void qmp_block_dirty_bitmap_add(const char *node, const char *name,
2859 bool has_granularity, uint32_t granularity,
2860 bool has_persistent, bool persistent,
2861 bool has_autoload, bool autoload,
2862 bool has_disabled, bool disabled,
2863 Error **errp)
2864{
2865 BlockDriverState *bs;
2866 BdrvDirtyBitmap *bitmap;
2867
2868 if (!name || name[0] == '\0') {
2869 error_setg(errp, "Bitmap name cannot be empty");
2870 return;
2871 }
2872
2873 bs = bdrv_lookup_bs(node, node, errp);
2874 if (!bs) {
2875 return;
2876 }
2877
2878 if (has_granularity) {
2879 if (granularity < 512 || !is_power_of_2(granularity)) {
2880 error_setg(errp, "Granularity must be power of 2 "
2881 "and at least 512");
2882 return;
2883 }
2884 } else {
2885 /* Default to cluster size, if available: */
2886 granularity = bdrv_get_default_bitmap_granularity(bs);
2887 }
2888
2889 if (!has_persistent) {
2890 persistent = false;
2891 }
2892
2893 if (has_autoload) {
2894 warn_report("Autoload option is deprecated and its value is ignored");
2895 }
2896
2897 if (!has_disabled) {
2898 disabled = false;
2899 }
2900
2901 if (persistent) {
2902 AioContext *aio_context = bdrv_get_aio_context(bs);
2903 bool ok;
2904
2905 aio_context_acquire(aio_context);
2906 ok = bdrv_can_store_new_dirty_bitmap(bs, name, granularity, errp);
2907 aio_context_release(aio_context);
2908 if (!ok) {
2909 return;
2910 }
2911 }
2912
2913 bitmap = bdrv_create_dirty_bitmap(bs, granularity, name, errp);
2914 if (bitmap == NULL) {
2915 return;
2916 }
2917
2918 if (disabled) {
2919 bdrv_disable_dirty_bitmap(bitmap);
2920 }
2921
2922 bdrv_dirty_bitmap_set_persistence(bitmap, persistent);
2923}
2924
2925static BdrvDirtyBitmap *do_block_dirty_bitmap_remove(
2926 const char *node, const char *name, bool release,
2927 BlockDriverState **bitmap_bs, Error **errp)
2928{
2929 BlockDriverState *bs;
2930 BdrvDirtyBitmap *bitmap;
2931
2932 bitmap = block_dirty_bitmap_lookup(node, name, &bs, errp);
2933 if (!bitmap || !bs) {
2934 return NULL;
2935 }
2936
2937 if (bdrv_dirty_bitmap_check(bitmap, BDRV_BITMAP_BUSY | BDRV_BITMAP_RO,
2938 errp)) {
2939 return NULL;
2940 }
2941
2942 if (bdrv_dirty_bitmap_get_persistence(bitmap)) {
2943 AioContext *aio_context = bdrv_get_aio_context(bs);
2944 Error *local_err = NULL;
2945
2946 aio_context_acquire(aio_context);
2947 bdrv_remove_persistent_dirty_bitmap(bs, name, &local_err);
2948 aio_context_release(aio_context);
2949
2950 if (local_err != NULL) {
2951 error_propagate(errp, local_err);
2952 return NULL;
2953 }
2954 }
2955
2956 if (release) {
2957 bdrv_release_dirty_bitmap(bs, bitmap);
2958 }
2959
2960 if (bitmap_bs) {
2961 *bitmap_bs = bs;
2962 }
2963
2964 return release ? NULL : bitmap;
2965}
2966
2967void qmp_block_dirty_bitmap_remove(const char *node, const char *name,
2968 Error **errp)
2969{
2970 do_block_dirty_bitmap_remove(node, name, true, NULL, errp);
2971}
2972
2973/**
2974 * Completely clear a bitmap, for the purposes of synchronizing a bitmap
2975 * immediately after a full backup operation.
2976 */
2977void qmp_block_dirty_bitmap_clear(const char *node, const char *name,
2978 Error **errp)
2979{
2980 BdrvDirtyBitmap *bitmap;
2981 BlockDriverState *bs;
2982
2983 bitmap = block_dirty_bitmap_lookup(node, name, &bs, errp);
2984 if (!bitmap || !bs) {
2985 return;
2986 }
2987
2988 if (bdrv_dirty_bitmap_check(bitmap, BDRV_BITMAP_DEFAULT, errp)) {
2989 return;
2990 }
2991
2992 bdrv_clear_dirty_bitmap(bitmap, NULL);
2993}
2994
2995void qmp_block_dirty_bitmap_enable(const char *node, const char *name,
2996 Error **errp)
2997{
2998 BlockDriverState *bs;
2999 BdrvDirtyBitmap *bitmap;
3000
3001 bitmap = block_dirty_bitmap_lookup(node, name, &bs, errp);
3002 if (!bitmap) {
3003 return;
3004 }
3005
3006 if (bdrv_dirty_bitmap_check(bitmap, BDRV_BITMAP_ALLOW_RO, errp)) {
3007 return;
3008 }
3009
3010 bdrv_enable_dirty_bitmap(bitmap);
3011}
3012
3013void qmp_block_dirty_bitmap_disable(const char *node, const char *name,
3014 Error **errp)
3015{
3016 BlockDriverState *bs;
3017 BdrvDirtyBitmap *bitmap;
3018
3019 bitmap = block_dirty_bitmap_lookup(node, name, &bs, errp);
3020 if (!bitmap) {
3021 return;
3022 }
3023
3024 if (bdrv_dirty_bitmap_check(bitmap, BDRV_BITMAP_ALLOW_RO, errp)) {
3025 return;
3026 }
3027
3028 bdrv_disable_dirty_bitmap(bitmap);
3029}
3030
3031static BdrvDirtyBitmap *do_block_dirty_bitmap_merge(
3032 const char *node, const char *target,
3033 BlockDirtyBitmapMergeSourceList *bitmaps,
3034 HBitmap **backup, Error **errp)
3035{
3036 BlockDriverState *bs;
3037 BdrvDirtyBitmap *dst, *src, *anon;
3038 BlockDirtyBitmapMergeSourceList *lst;
3039 Error *local_err = NULL;
3040
3041 dst = block_dirty_bitmap_lookup(node, target, &bs, errp);
3042 if (!dst) {
3043 return NULL;
3044 }
3045
3046 anon = bdrv_create_dirty_bitmap(bs, bdrv_dirty_bitmap_granularity(dst),
3047 NULL, errp);
3048 if (!anon) {
3049 return NULL;
3050 }
3051
3052 for (lst = bitmaps; lst; lst = lst->next) {
3053 switch (lst->value->type) {
3054 const char *name, *node;
3055 case QTYPE_QSTRING:
3056 name = lst->value->u.local;
3057 src = bdrv_find_dirty_bitmap(bs, name);
3058 if (!src) {
3059 error_setg(errp, "Dirty bitmap '%s' not found", name);
3060 dst = NULL;
3061 goto out;
3062 }
3063 break;
3064 case QTYPE_QDICT:
3065 node = lst->value->u.external.node;
3066 name = lst->value->u.external.name;
3067 src = block_dirty_bitmap_lookup(node, name, NULL, errp);
3068 if (!src) {
3069 dst = NULL;
3070 goto out;
3071 }
3072 break;
3073 default:
3074 abort();
3075 }
3076
3077 bdrv_merge_dirty_bitmap(anon, src, NULL, &local_err);
3078 if (local_err) {
3079 error_propagate(errp, local_err);
3080 dst = NULL;
3081 goto out;
3082 }
3083 }
3084
3085 /* Merge into dst; dst is unchanged on failure. */
3086 bdrv_merge_dirty_bitmap(dst, anon, backup, errp);
3087
3088 out:
3089 bdrv_release_dirty_bitmap(bs, anon);
3090 return dst;
3091}
3092
3093void qmp_block_dirty_bitmap_merge(const char *node, const char *target,
3094 BlockDirtyBitmapMergeSourceList *bitmaps,
3095 Error **errp)
3096{
3097 do_block_dirty_bitmap_merge(node, target, bitmaps, NULL, errp);
3098}
3099
3100BlockDirtyBitmapSha256 *qmp_x_debug_block_dirty_bitmap_sha256(const char *node,
3101 const char *name,
3102 Error **errp)
3103{
3104 BdrvDirtyBitmap *bitmap;
3105 BlockDriverState *bs;
3106 BlockDirtyBitmapSha256 *ret = NULL;
3107 char *sha256;
3108
3109 bitmap = block_dirty_bitmap_lookup(node, name, &bs, errp);
3110 if (!bitmap || !bs) {
3111 return NULL;
3112 }
3113
3114 sha256 = bdrv_dirty_bitmap_sha256(bitmap, errp);
3115 if (sha256 == NULL) {
3116 return NULL;
3117 }
3118
3119 ret = g_new(BlockDirtyBitmapSha256, 1);
3120 ret->sha256 = sha256;
3121
3122 return ret;
3123}
3124
3125void hmp_drive_del(Monitor *mon, const QDict *qdict)
3126{
3127 const char *id = qdict_get_str(qdict, "id");
3128 BlockBackend *blk;
3129 BlockDriverState *bs;
3130 AioContext *aio_context;
3131 Error *local_err = NULL;
3132
3133 bs = bdrv_find_node(id);
3134 if (bs) {
3135 qmp_blockdev_del(id, &local_err);
3136 if (local_err) {
3137 error_report_err(local_err);
3138 }
3139 return;
3140 }
3141
3142 blk = blk_by_name(id);
3143 if (!blk) {
3144 error_report("Device '%s' not found", id);
3145 return;
3146 }
3147
3148 if (!blk_legacy_dinfo(blk)) {
3149 error_report("Deleting device added with blockdev-add"
3150 " is not supported");
3151 return;
3152 }
3153
3154 aio_context = blk_get_aio_context(blk);
3155 aio_context_acquire(aio_context);
3156
3157 bs = blk_bs(blk);
3158 if (bs) {
3159 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_DRIVE_DEL, &local_err)) {
3160 error_report_err(local_err);
3161 aio_context_release(aio_context);
3162 return;
3163 }
3164
3165 blk_remove_bs(blk);
3166 }
3167
3168 /* Make the BlockBackend and the attached BlockDriverState anonymous */
3169 monitor_remove_blk(blk);
3170
3171 /* If this BlockBackend has a device attached to it, its refcount will be
3172 * decremented when the device is removed; otherwise we have to do so here.
3173 */
3174 if (blk_get_attached_dev(blk)) {
3175 /* Further I/O must not pause the guest */
3176 blk_set_on_error(blk, BLOCKDEV_ON_ERROR_REPORT,
3177 BLOCKDEV_ON_ERROR_REPORT);
3178 } else {
3179 blk_unref(blk);
3180 }
3181
3182 aio_context_release(aio_context);
3183}
3184
3185void qmp_block_resize(bool has_device, const char *device,
3186 bool has_node_name, const char *node_name,
3187 int64_t size, Error **errp)
3188{
3189 Error *local_err = NULL;
3190 BlockBackend *blk = NULL;
3191 BlockDriverState *bs;
3192 AioContext *aio_context;
3193 int ret;
3194
3195 bs = bdrv_lookup_bs(has_device ? device : NULL,
3196 has_node_name ? node_name : NULL,
3197 &local_err);
3198 if (local_err) {
3199 error_propagate(errp, local_err);
3200 return;
3201 }
3202
3203 aio_context = bdrv_get_aio_context(bs);
3204 aio_context_acquire(aio_context);
3205
3206 if (!bdrv_is_first_non_filter(bs)) {
3207 error_setg(errp, QERR_FEATURE_DISABLED, "resize");
3208 goto out;
3209 }
3210
3211 if (size < 0) {
3212 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "size", "a >0 size");
3213 goto out;
3214 }
3215
3216 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_RESIZE, NULL)) {
3217 error_setg(errp, QERR_DEVICE_IN_USE, device);
3218 goto out;
3219 }
3220
3221 blk = blk_new(bdrv_get_aio_context(bs), BLK_PERM_RESIZE, BLK_PERM_ALL);
3222 ret = blk_insert_bs(blk, bs, errp);
3223 if (ret < 0) {
3224 goto out;
3225 }
3226
3227 bdrv_drained_begin(bs);
3228 ret = blk_truncate(blk, size, PREALLOC_MODE_OFF, errp);
3229 bdrv_drained_end(bs);
3230
3231out:
3232 blk_unref(blk);
3233 aio_context_release(aio_context);
3234}
3235
3236void qmp_block_stream(bool has_job_id, const char *job_id, const char *device,
3237 bool has_base, const char *base,
3238 bool has_base_node, const char *base_node,
3239 bool has_backing_file, const char *backing_file,
3240 bool has_speed, int64_t speed,
3241 bool has_on_error, BlockdevOnError on_error,
3242 bool has_auto_finalize, bool auto_finalize,
3243 bool has_auto_dismiss, bool auto_dismiss,
3244 Error **errp)
3245{
3246 BlockDriverState *bs, *iter;
3247 BlockDriverState *base_bs = NULL;
3248 AioContext *aio_context;
3249 Error *local_err = NULL;
3250 const char *base_name = NULL;
3251 int job_flags = JOB_DEFAULT;
3252
3253 if (!has_on_error) {
3254 on_error = BLOCKDEV_ON_ERROR_REPORT;
3255 }
3256
3257 bs = bdrv_lookup_bs(device, device, errp);
3258 if (!bs) {
3259 return;
3260 }
3261
3262 aio_context = bdrv_get_aio_context(bs);
3263 aio_context_acquire(aio_context);
3264
3265 if (has_base && has_base_node) {
3266 error_setg(errp, "'base' and 'base-node' cannot be specified "
3267 "at the same time");
3268 goto out;
3269 }
3270
3271 if (has_base) {
3272 base_bs = bdrv_find_backing_image(bs, base);
3273 if (base_bs == NULL) {
3274 error_setg(errp, QERR_BASE_NOT_FOUND, base);
3275 goto out;
3276 }
3277 assert(bdrv_get_aio_context(base_bs) == aio_context);
3278 base_name = base;
3279 }
3280
3281 if (has_base_node) {
3282 base_bs = bdrv_lookup_bs(NULL, base_node, errp);
3283 if (!base_bs) {
3284 goto out;
3285 }
3286 if (bs == base_bs || !bdrv_chain_contains(bs, base_bs)) {
3287 error_setg(errp, "Node '%s' is not a backing image of '%s'",
3288 base_node, device);
3289 goto out;
3290 }
3291 assert(bdrv_get_aio_context(base_bs) == aio_context);
3292 bdrv_refresh_filename(base_bs);
3293 base_name = base_bs->filename;
3294 }
3295
3296 /* Check for op blockers in the whole chain between bs and base */
3297 for (iter = bs; iter && iter != base_bs; iter = backing_bs(iter)) {
3298 if (bdrv_op_is_blocked(iter, BLOCK_OP_TYPE_STREAM, errp)) {
3299 goto out;
3300 }
3301 }
3302
3303 /* if we are streaming the entire chain, the result will have no backing
3304 * file, and specifying one is therefore an error */
3305 if (base_bs == NULL && has_backing_file) {
3306 error_setg(errp, "backing file specified, but streaming the "
3307 "entire chain");
3308 goto out;
3309 }
3310
3311 /* backing_file string overrides base bs filename */
3312 base_name = has_backing_file ? backing_file : base_name;
3313
3314 if (has_auto_finalize && !auto_finalize) {
3315 job_flags |= JOB_MANUAL_FINALIZE;
3316 }
3317 if (has_auto_dismiss && !auto_dismiss) {
3318 job_flags |= JOB_MANUAL_DISMISS;
3319 }
3320
3321 stream_start(has_job_id ? job_id : NULL, bs, base_bs, base_name,
3322 job_flags, has_speed ? speed : 0, on_error, &local_err);
3323 if (local_err) {
3324 error_propagate(errp, local_err);
3325 goto out;
3326 }
3327
3328 trace_qmp_block_stream(bs);
3329
3330out:
3331 aio_context_release(aio_context);
3332}
3333
3334void qmp_block_commit(bool has_job_id, const char *job_id, const char *device,
3335 bool has_base_node, const char *base_node,
3336 bool has_base, const char *base,
3337 bool has_top_node, const char *top_node,
3338 bool has_top, const char *top,
3339 bool has_backing_file, const char *backing_file,
3340 bool has_speed, int64_t speed,
3341 bool has_filter_node_name, const char *filter_node_name,
3342 bool has_auto_finalize, bool auto_finalize,
3343 bool has_auto_dismiss, bool auto_dismiss,
3344 Error **errp)
3345{
3346 BlockDriverState *bs;
3347 BlockDriverState *iter;
3348 BlockDriverState *base_bs, *top_bs;
3349 AioContext *aio_context;
3350 Error *local_err = NULL;
3351 /* This will be part of the QMP command, if/when the
3352 * BlockdevOnError change for blkmirror makes it in
3353 */
3354 BlockdevOnError on_error = BLOCKDEV_ON_ERROR_REPORT;
3355 int job_flags = JOB_DEFAULT;
3356
3357 if (!has_speed) {
3358 speed = 0;
3359 }
3360 if (!has_filter_node_name) {
3361 filter_node_name = NULL;
3362 }
3363 if (has_auto_finalize && !auto_finalize) {
3364 job_flags |= JOB_MANUAL_FINALIZE;
3365 }
3366 if (has_auto_dismiss && !auto_dismiss) {
3367 job_flags |= JOB_MANUAL_DISMISS;
3368 }
3369
3370 /* Important Note:
3371 * libvirt relies on the DeviceNotFound error class in order to probe for
3372 * live commit feature versions; for this to work, we must make sure to
3373 * perform the device lookup before any generic errors that may occur in a
3374 * scenario in which all optional arguments are omitted. */
3375 bs = qmp_get_root_bs(device, &local_err);
3376 if (!bs) {
3377 bs = bdrv_lookup_bs(device, device, NULL);
3378 if (!bs) {
3379 error_free(local_err);
3380 error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
3381 "Device '%s' not found", device);
3382 } else {
3383 error_propagate(errp, local_err);
3384 }
3385 return;
3386 }
3387
3388 aio_context = bdrv_get_aio_context(bs);
3389 aio_context_acquire(aio_context);
3390
3391 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_COMMIT_SOURCE, errp)) {
3392 goto out;
3393 }
3394
3395 /* default top_bs is the active layer */
3396 top_bs = bs;
3397
3398 if (has_top_node && has_top) {
3399 error_setg(errp, "'top-node' and 'top' are mutually exclusive");
3400 goto out;
3401 } else if (has_top_node) {
3402 top_bs = bdrv_lookup_bs(NULL, top_node, errp);
3403 if (top_bs == NULL) {
3404 goto out;
3405 }
3406 if (!bdrv_chain_contains(bs, top_bs)) {
3407 error_setg(errp, "'%s' is not in this backing file chain",
3408 top_node);
3409 goto out;
3410 }
3411 } else if (has_top && top) {
3412 /* This strcmp() is just a shortcut, there is no need to
3413 * refresh @bs's filename. If it mismatches,
3414 * bdrv_find_backing_image() will do the refresh and may still
3415 * return @bs. */
3416 if (strcmp(bs->filename, top) != 0) {
3417 top_bs = bdrv_find_backing_image(bs, top);
3418 }
3419 }
3420
3421 if (top_bs == NULL) {
3422 error_setg(errp, "Top image file %s not found", top ? top : "NULL");
3423 goto out;
3424 }
3425
3426 assert(bdrv_get_aio_context(top_bs) == aio_context);
3427
3428 if (has_base_node && has_base) {
3429 error_setg(errp, "'base-node' and 'base' are mutually exclusive");
3430 goto out;
3431 } else if (has_base_node) {
3432 base_bs = bdrv_lookup_bs(NULL, base_node, errp);
3433 if (base_bs == NULL) {
3434 goto out;
3435 }
3436 if (!bdrv_chain_contains(top_bs, base_bs)) {
3437 error_setg(errp, "'%s' is not in this backing file chain",
3438 base_node);
3439 goto out;
3440 }
3441 } else if (has_base && base) {
3442 base_bs = bdrv_find_backing_image(top_bs, base);
3443 } else {
3444 base_bs = bdrv_find_base(top_bs);
3445 }
3446
3447 if (base_bs == NULL) {
3448 error_setg(errp, QERR_BASE_NOT_FOUND, base ? base : "NULL");
3449 goto out;
3450 }
3451
3452 assert(bdrv_get_aio_context(base_bs) == aio_context);
3453
3454 for (iter = top_bs; iter != backing_bs(base_bs); iter = backing_bs(iter)) {
3455 if (bdrv_op_is_blocked(iter, BLOCK_OP_TYPE_COMMIT_TARGET, errp)) {
3456 goto out;
3457 }
3458 }
3459
3460 /* Do not allow attempts to commit an image into itself */
3461 if (top_bs == base_bs) {
3462 error_setg(errp, "cannot commit an image into itself");
3463 goto out;
3464 }
3465
3466 if (top_bs == bs) {
3467 if (has_backing_file) {
3468 error_setg(errp, "'backing-file' specified,"
3469 " but 'top' is the active layer");
3470 goto out;
3471 }
3472 commit_active_start(has_job_id ? job_id : NULL, bs, base_bs,
3473 job_flags, speed, on_error,
3474 filter_node_name, NULL, NULL, false, &local_err);
3475 } else {
3476 BlockDriverState *overlay_bs = bdrv_find_overlay(bs, top_bs);
3477 if (bdrv_op_is_blocked(overlay_bs, BLOCK_OP_TYPE_COMMIT_TARGET, errp)) {
3478 goto out;
3479 }
3480 commit_start(has_job_id ? job_id : NULL, bs, base_bs, top_bs, job_flags,
3481 speed, on_error, has_backing_file ? backing_file : NULL,
3482 filter_node_name, &local_err);
3483 }
3484 if (local_err != NULL) {
3485 error_propagate(errp, local_err);
3486 goto out;
3487 }
3488
3489out:
3490 aio_context_release(aio_context);
3491}
3492
3493/* Common QMP interface for drive-backup and blockdev-backup */
3494static BlockJob *do_backup_common(BackupCommon *backup,
3495 BlockDriverState *bs,
3496 BlockDriverState *target_bs,
3497 AioContext *aio_context,
3498 JobTxn *txn, Error **errp)
3499{
3500 BlockJob *job = NULL;
3501 BdrvDirtyBitmap *bmap = NULL;
3502 int job_flags = JOB_DEFAULT;
3503 int ret;
3504
3505 if (!backup->has_speed) {
3506 backup->speed = 0;
3507 }
3508 if (!backup->has_on_source_error) {
3509 backup->on_source_error = BLOCKDEV_ON_ERROR_REPORT;
3510 }
3511 if (!backup->has_on_target_error) {
3512 backup->on_target_error = BLOCKDEV_ON_ERROR_REPORT;
3513 }
3514 if (!backup->has_job_id) {
3515 backup->job_id = NULL;
3516 }
3517 if (!backup->has_auto_finalize) {
3518 backup->auto_finalize = true;
3519 }
3520 if (!backup->has_auto_dismiss) {
3521 backup->auto_dismiss = true;
3522 }
3523 if (!backup->has_compress) {
3524 backup->compress = false;
3525 }
3526
3527 ret = bdrv_try_set_aio_context(target_bs, aio_context, errp);
3528 if (ret < 0) {
3529 return NULL;
3530 }
3531
3532 if ((backup->sync == MIRROR_SYNC_MODE_BITMAP) ||
3533 (backup->sync == MIRROR_SYNC_MODE_INCREMENTAL)) {
3534 /* done before desugaring 'incremental' to print the right message */
3535 if (!backup->has_bitmap) {
3536 error_setg(errp, "must provide a valid bitmap name for "
3537 "'%s' sync mode", MirrorSyncMode_str(backup->sync));
3538 return NULL;
3539 }
3540 }
3541
3542 if (backup->sync == MIRROR_SYNC_MODE_INCREMENTAL) {
3543 if (backup->has_bitmap_mode &&
3544 backup->bitmap_mode != BITMAP_SYNC_MODE_ON_SUCCESS) {
3545 error_setg(errp, "Bitmap sync mode must be '%s' "
3546 "when using sync mode '%s'",
3547 BitmapSyncMode_str(BITMAP_SYNC_MODE_ON_SUCCESS),
3548 MirrorSyncMode_str(backup->sync));
3549 return NULL;
3550 }
3551 backup->has_bitmap_mode = true;
3552 backup->sync = MIRROR_SYNC_MODE_BITMAP;
3553 backup->bitmap_mode = BITMAP_SYNC_MODE_ON_SUCCESS;
3554 }
3555
3556 if (backup->has_bitmap) {
3557 bmap = bdrv_find_dirty_bitmap(bs, backup->bitmap);
3558 if (!bmap) {
3559 error_setg(errp, "Bitmap '%s' could not be found", backup->bitmap);
3560 return NULL;
3561 }
3562 if (!backup->has_bitmap_mode) {
3563 error_setg(errp, "Bitmap sync mode must be given "
3564 "when providing a bitmap");
3565 return NULL;
3566 }
3567 if (bdrv_dirty_bitmap_check(bmap, BDRV_BITMAP_ALLOW_RO, errp)) {
3568 return NULL;
3569 }
3570
3571 /* This does not produce a useful bitmap artifact: */
3572 if (backup->sync == MIRROR_SYNC_MODE_NONE) {
3573 error_setg(errp, "sync mode '%s' does not produce meaningful bitmap"
3574 " outputs", MirrorSyncMode_str(backup->sync));
3575 return NULL;
3576 }
3577
3578 /* If the bitmap isn't used for input or output, this is useless: */
3579 if (backup->bitmap_mode == BITMAP_SYNC_MODE_NEVER &&
3580 backup->sync != MIRROR_SYNC_MODE_BITMAP) {
3581 error_setg(errp, "Bitmap sync mode '%s' has no meaningful effect"
3582 " when combined with sync mode '%s'",
3583 BitmapSyncMode_str(backup->bitmap_mode),
3584 MirrorSyncMode_str(backup->sync));
3585 return NULL;
3586 }
3587 }
3588
3589 if (!backup->has_bitmap && backup->has_bitmap_mode) {
3590 error_setg(errp, "Cannot specify bitmap sync mode without a bitmap");
3591 return NULL;
3592 }
3593
3594 if (!backup->auto_finalize) {
3595 job_flags |= JOB_MANUAL_FINALIZE;
3596 }
3597 if (!backup->auto_dismiss) {
3598 job_flags |= JOB_MANUAL_DISMISS;
3599 }
3600
3601 job = backup_job_create(backup->job_id, bs, target_bs, backup->speed,
3602 backup->sync, bmap, backup->bitmap_mode,
3603 backup->compress,
3604 backup->on_source_error,
3605 backup->on_target_error,
3606 job_flags, NULL, NULL, txn, errp);
3607 return job;
3608}
3609
3610static BlockJob *do_drive_backup(DriveBackup *backup, JobTxn *txn,
3611 Error **errp)
3612{
3613 BlockDriverState *bs;
3614 BlockDriverState *target_bs;
3615 BlockDriverState *source = NULL;
3616 BlockJob *job = NULL;
3617 AioContext *aio_context;
3618 QDict *options;
3619 Error *local_err = NULL;
3620 int flags;
3621 int64_t size;
3622 bool set_backing_hd = false;
3623
3624 if (!backup->has_mode) {
3625 backup->mode = NEW_IMAGE_MODE_ABSOLUTE_PATHS;
3626 }
3627
3628 bs = bdrv_lookup_bs(backup->device, backup->device, errp);
3629 if (!bs) {
3630 return NULL;
3631 }
3632
3633 if (!bs->drv) {
3634 error_setg(errp, "Device has no medium");
3635 return NULL;
3636 }
3637
3638 aio_context = bdrv_get_aio_context(bs);
3639 aio_context_acquire(aio_context);
3640
3641 if (!backup->has_format) {
3642 backup->format = backup->mode == NEW_IMAGE_MODE_EXISTING ?
3643 NULL : (char*) bs->drv->format_name;
3644 }
3645
3646 /* Early check to avoid creating target */
3647 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_BACKUP_SOURCE, errp)) {
3648 goto out;
3649 }
3650
3651 flags = bs->open_flags | BDRV_O_RDWR;
3652
3653 /* See if we have a backing HD we can use to create our new image
3654 * on top of. */
3655 if (backup->sync == MIRROR_SYNC_MODE_TOP) {
3656 source = backing_bs(bs);
3657 if (!source) {
3658 backup->sync = MIRROR_SYNC_MODE_FULL;
3659 }
3660 }
3661 if (backup->sync == MIRROR_SYNC_MODE_NONE) {
3662 source = bs;
3663 flags |= BDRV_O_NO_BACKING;
3664 set_backing_hd = true;
3665 }
3666
3667 size = bdrv_getlength(bs);
3668 if (size < 0) {
3669 error_setg_errno(errp, -size, "bdrv_getlength failed");
3670 goto out;
3671 }
3672
3673 if (backup->mode != NEW_IMAGE_MODE_EXISTING) {
3674 assert(backup->format);
3675 if (source) {
3676 bdrv_refresh_filename(source);
3677 bdrv_img_create(backup->target, backup->format, source->filename,
3678 source->drv->format_name, NULL,
3679 size, flags, false, &local_err);
3680 } else {
3681 bdrv_img_create(backup->target, backup->format, NULL, NULL, NULL,
3682 size, flags, false, &local_err);
3683 }
3684 }
3685
3686 if (local_err) {
3687 error_propagate(errp, local_err);
3688 goto out;
3689 }
3690
3691 options = qdict_new();
3692 qdict_put_str(options, "discard", "unmap");
3693 qdict_put_str(options, "detect-zeroes", "unmap");
3694 if (backup->format) {
3695 qdict_put_str(options, "driver", backup->format);
3696 }
3697
3698 target_bs = bdrv_open(backup->target, NULL, options, flags, errp);
3699 if (!target_bs) {
3700 goto out;
3701 }
3702
3703 if (set_backing_hd) {
3704 bdrv_set_backing_hd(target_bs, source, &local_err);
3705 if (local_err) {
3706 goto unref;
3707 }
3708 }
3709
3710 job = do_backup_common(qapi_DriveBackup_base(backup),
3711 bs, target_bs, aio_context, txn, errp);
3712
3713unref:
3714 bdrv_unref(target_bs);
3715out:
3716 aio_context_release(aio_context);
3717 return job;
3718}
3719
3720void qmp_drive_backup(DriveBackup *arg, Error **errp)
3721{
3722
3723 BlockJob *job;
3724 job = do_drive_backup(arg, NULL, errp);
3725 if (job) {
3726 job_start(&job->job);
3727 }
3728}
3729
3730BlockDeviceInfoList *qmp_query_named_block_nodes(Error **errp)
3731{
3732 return bdrv_named_nodes_list(errp);
3733}
3734
3735XDbgBlockGraph *qmp_x_debug_query_block_graph(Error **errp)
3736{
3737 return bdrv_get_xdbg_block_graph(errp);
3738}
3739
3740BlockJob *do_blockdev_backup(BlockdevBackup *backup, JobTxn *txn,
3741 Error **errp)
3742{
3743 BlockDriverState *bs;
3744 BlockDriverState *target_bs;
3745 AioContext *aio_context;
3746 BlockJob *job;
3747
3748 bs = bdrv_lookup_bs(backup->device, backup->device, errp);
3749 if (!bs) {
3750 return NULL;
3751 }
3752
3753 target_bs = bdrv_lookup_bs(backup->target, backup->target, errp);
3754 if (!target_bs) {
3755 return NULL;
3756 }
3757
3758 aio_context = bdrv_get_aio_context(bs);
3759 aio_context_acquire(aio_context);
3760
3761 job = do_backup_common(qapi_BlockdevBackup_base(backup),
3762 bs, target_bs, aio_context, txn, errp);
3763
3764 aio_context_release(aio_context);
3765 return job;
3766}
3767
3768void qmp_blockdev_backup(BlockdevBackup *arg, Error **errp)
3769{
3770 BlockJob *job;
3771 job = do_blockdev_backup(arg, NULL, errp);
3772 if (job) {
3773 job_start(&job->job);
3774 }
3775}
3776
3777/* Parameter check and block job starting for drive mirroring.
3778 * Caller should hold @device and @target's aio context (must be the same).
3779 **/
3780static void blockdev_mirror_common(const char *job_id, BlockDriverState *bs,
3781 BlockDriverState *target,
3782 bool has_replaces, const char *replaces,
3783 enum MirrorSyncMode sync,
3784 BlockMirrorBackingMode backing_mode,
3785 bool zero_target,
3786 bool has_speed, int64_t speed,
3787 bool has_granularity, uint32_t granularity,
3788 bool has_buf_size, int64_t buf_size,
3789 bool has_on_source_error,
3790 BlockdevOnError on_source_error,
3791 bool has_on_target_error,
3792 BlockdevOnError on_target_error,
3793 bool has_unmap, bool unmap,
3794 bool has_filter_node_name,
3795 const char *filter_node_name,
3796 bool has_copy_mode, MirrorCopyMode copy_mode,
3797 bool has_auto_finalize, bool auto_finalize,
3798 bool has_auto_dismiss, bool auto_dismiss,
3799 Error **errp)
3800{
3801 int job_flags = JOB_DEFAULT;
3802
3803 if (!has_speed) {
3804 speed = 0;
3805 }
3806 if (!has_on_source_error) {
3807 on_source_error = BLOCKDEV_ON_ERROR_REPORT;
3808 }
3809 if (!has_on_target_error) {
3810 on_target_error = BLOCKDEV_ON_ERROR_REPORT;
3811 }
3812 if (!has_granularity) {
3813 granularity = 0;
3814 }
3815 if (!has_buf_size) {
3816 buf_size = 0;
3817 }
3818 if (!has_unmap) {
3819 unmap = true;
3820 }
3821 if (!has_filter_node_name) {
3822 filter_node_name = NULL;
3823 }
3824 if (!has_copy_mode) {
3825 copy_mode = MIRROR_COPY_MODE_BACKGROUND;
3826 }
3827 if (has_auto_finalize && !auto_finalize) {
3828 job_flags |= JOB_MANUAL_FINALIZE;
3829 }
3830 if (has_auto_dismiss && !auto_dismiss) {
3831 job_flags |= JOB_MANUAL_DISMISS;
3832 }
3833
3834 if (granularity != 0 && (granularity < 512 || granularity > 1048576 * 64)) {
3835 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "granularity",
3836 "a value in range [512B, 64MB]");
3837 return;
3838 }
3839 if (granularity & (granularity - 1)) {
3840 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "granularity",
3841 "power of 2");
3842 return;
3843 }
3844
3845 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_MIRROR_SOURCE, errp)) {
3846 return;
3847 }
3848 if (bdrv_op_is_blocked(target, BLOCK_OP_TYPE_MIRROR_TARGET, errp)) {
3849 return;
3850 }
3851
3852 if (!bs->backing && sync == MIRROR_SYNC_MODE_TOP) {
3853 sync = MIRROR_SYNC_MODE_FULL;
3854 }
3855
3856 if (has_replaces) {
3857 BlockDriverState *to_replace_bs;
3858 AioContext *replace_aio_context;
3859 int64_t bs_size, replace_size;
3860
3861 bs_size = bdrv_getlength(bs);
3862 if (bs_size < 0) {
3863 error_setg_errno(errp, -bs_size, "Failed to query device's size");
3864 return;
3865 }
3866
3867 to_replace_bs = check_to_replace_node(bs, replaces, errp);
3868 if (!to_replace_bs) {
3869 return;
3870 }
3871
3872 replace_aio_context = bdrv_get_aio_context(to_replace_bs);
3873 aio_context_acquire(replace_aio_context);
3874 replace_size = bdrv_getlength(to_replace_bs);
3875 aio_context_release(replace_aio_context);
3876
3877 if (replace_size < 0) {
3878 error_setg_errno(errp, -replace_size,
3879 "Failed to query the replacement node's size");
3880 return;
3881 }
3882 if (bs_size != replace_size) {
3883 error_setg(errp, "cannot replace image with a mirror image of "
3884 "different size");
3885 return;
3886 }
3887 }
3888
3889 /* pass the node name to replace to mirror start since it's loose coupling
3890 * and will allow to check whether the node still exist at mirror completion
3891 */
3892 mirror_start(job_id, bs, target,
3893 has_replaces ? replaces : NULL, job_flags,
3894 speed, granularity, buf_size, sync, backing_mode, zero_target,
3895 on_source_error, on_target_error, unmap, filter_node_name,
3896 copy_mode, errp);
3897}
3898
3899void qmp_drive_mirror(DriveMirror *arg, Error **errp)
3900{
3901 BlockDriverState *bs;
3902 BlockDriverState *source, *target_bs;
3903 AioContext *aio_context;
3904 BlockMirrorBackingMode backing_mode;
3905 Error *local_err = NULL;
3906 QDict *options = NULL;
3907 int flags;
3908 int64_t size;
3909 const char *format = arg->format;
3910 bool zero_target;
3911 int ret;
3912
3913 bs = qmp_get_root_bs(arg->device, errp);
3914 if (!bs) {
3915 return;
3916 }
3917
3918 /* Early check to avoid creating target */
3919 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_MIRROR_SOURCE, errp)) {
3920 return;
3921 }
3922
3923 aio_context = bdrv_get_aio_context(bs);
3924 aio_context_acquire(aio_context);
3925
3926 if (!arg->has_mode) {
3927 arg->mode = NEW_IMAGE_MODE_ABSOLUTE_PATHS;
3928 }
3929
3930 if (!arg->has_format) {
3931 format = (arg->mode == NEW_IMAGE_MODE_EXISTING
3932 ? NULL : bs->drv->format_name);
3933 }
3934
3935 flags = bs->open_flags | BDRV_O_RDWR;
3936 source = backing_bs(bs);
3937 if (!source && arg->sync == MIRROR_SYNC_MODE_TOP) {
3938 arg->sync = MIRROR_SYNC_MODE_FULL;
3939 }
3940 if (arg->sync == MIRROR_SYNC_MODE_NONE) {
3941 source = bs;
3942 }
3943
3944 size = bdrv_getlength(bs);
3945 if (size < 0) {
3946 error_setg_errno(errp, -size, "bdrv_getlength failed");
3947 goto out;
3948 }
3949
3950 if (arg->has_replaces) {
3951 if (!arg->has_node_name) {
3952 error_setg(errp, "a node-name must be provided when replacing a"
3953 " named node of the graph");
3954 goto out;
3955 }
3956 }
3957
3958 if (arg->mode == NEW_IMAGE_MODE_ABSOLUTE_PATHS) {
3959 backing_mode = MIRROR_SOURCE_BACKING_CHAIN;
3960 } else {
3961 backing_mode = MIRROR_OPEN_BACKING_CHAIN;
3962 }
3963
3964 /* Don't open backing image in create() */
3965 flags |= BDRV_O_NO_BACKING;
3966
3967 if ((arg->sync == MIRROR_SYNC_MODE_FULL || !source)
3968 && arg->mode != NEW_IMAGE_MODE_EXISTING)
3969 {
3970 /* create new image w/o backing file */
3971 assert(format);
3972 bdrv_img_create(arg->target, format,
3973 NULL, NULL, NULL, size, flags, false, &local_err);
3974 } else {
3975 switch (arg->mode) {
3976 case NEW_IMAGE_MODE_EXISTING:
3977 break;
3978 case NEW_IMAGE_MODE_ABSOLUTE_PATHS:
3979 /* create new image with backing file */
3980 bdrv_refresh_filename(source);
3981 bdrv_img_create(arg->target, format,
3982 source->filename,
3983 source->drv->format_name,
3984 NULL, size, flags, false, &local_err);
3985 break;
3986 default:
3987 abort();
3988 }
3989 }
3990
3991 if (local_err) {
3992 error_propagate(errp, local_err);
3993 goto out;
3994 }
3995
3996 options = qdict_new();
3997 if (arg->has_node_name) {
3998 qdict_put_str(options, "node-name", arg->node_name);
3999 }
4000 if (format) {
4001 qdict_put_str(options, "driver", format);
4002 }
4003
4004 /* Mirroring takes care of copy-on-write using the source's backing
4005 * file.
4006 */
4007 target_bs = bdrv_open(arg->target, NULL, options, flags, errp);
4008 if (!target_bs) {
4009 goto out;
4010 }
4011
4012 zero_target = (arg->sync == MIRROR_SYNC_MODE_FULL &&
4013 (arg->mode == NEW_IMAGE_MODE_EXISTING ||
4014 !bdrv_has_zero_init(target_bs)));
4015
4016 ret = bdrv_try_set_aio_context(target_bs, aio_context, errp);
4017 if (ret < 0) {
4018 bdrv_unref(target_bs);
4019 goto out;
4020 }
4021
4022 blockdev_mirror_common(arg->has_job_id ? arg->job_id : NULL, bs, target_bs,
4023 arg->has_replaces, arg->replaces, arg->sync,
4024 backing_mode, zero_target,
4025 arg->has_speed, arg->speed,
4026 arg->has_granularity, arg->granularity,
4027 arg->has_buf_size, arg->buf_size,
4028 arg->has_on_source_error, arg->on_source_error,
4029 arg->has_on_target_error, arg->on_target_error,
4030 arg->has_unmap, arg->unmap,
4031 false, NULL,
4032 arg->has_copy_mode, arg->copy_mode,
4033 arg->has_auto_finalize, arg->auto_finalize,
4034 arg->has_auto_dismiss, arg->auto_dismiss,
4035 &local_err);
4036 bdrv_unref(target_bs);
4037 error_propagate(errp, local_err);
4038out:
4039 aio_context_release(aio_context);
4040}
4041
4042void qmp_blockdev_mirror(bool has_job_id, const char *job_id,
4043 const char *device, const char *target,
4044 bool has_replaces, const char *replaces,
4045 MirrorSyncMode sync,
4046 bool has_speed, int64_t speed,
4047 bool has_granularity, uint32_t granularity,
4048 bool has_buf_size, int64_t buf_size,
4049 bool has_on_source_error,
4050 BlockdevOnError on_source_error,
4051 bool has_on_target_error,
4052 BlockdevOnError on_target_error,
4053 bool has_filter_node_name,
4054 const char *filter_node_name,
4055 bool has_copy_mode, MirrorCopyMode copy_mode,
4056 bool has_auto_finalize, bool auto_finalize,
4057 bool has_auto_dismiss, bool auto_dismiss,
4058 Error **errp)
4059{
4060 BlockDriverState *bs;
4061 BlockDriverState *target_bs;
4062 AioContext *aio_context;
4063 BlockMirrorBackingMode backing_mode = MIRROR_LEAVE_BACKING_CHAIN;
4064 Error *local_err = NULL;
4065 bool zero_target;
4066 int ret;
4067
4068 bs = qmp_get_root_bs(device, errp);
4069 if (!bs) {
4070 return;
4071 }
4072
4073 target_bs = bdrv_lookup_bs(target, target, errp);
4074 if (!target_bs) {
4075 return;
4076 }
4077
4078 zero_target = (sync == MIRROR_SYNC_MODE_FULL);
4079
4080 aio_context = bdrv_get_aio_context(bs);
4081 aio_context_acquire(aio_context);
4082
4083 ret = bdrv_try_set_aio_context(target_bs, aio_context, errp);
4084 if (ret < 0) {
4085 goto out;
4086 }
4087
4088 blockdev_mirror_common(has_job_id ? job_id : NULL, bs, target_bs,
4089 has_replaces, replaces, sync, backing_mode,
4090 zero_target, has_speed, speed,
4091 has_granularity, granularity,
4092 has_buf_size, buf_size,
4093 has_on_source_error, on_source_error,
4094 has_on_target_error, on_target_error,
4095 true, true,
4096 has_filter_node_name, filter_node_name,
4097 has_copy_mode, copy_mode,
4098 has_auto_finalize, auto_finalize,
4099 has_auto_dismiss, auto_dismiss,
4100 &local_err);
4101 error_propagate(errp, local_err);
4102out:
4103 aio_context_release(aio_context);
4104}
4105
4106/* Get a block job using its ID and acquire its AioContext */
4107static BlockJob *find_block_job(const char *id, AioContext **aio_context,
4108 Error **errp)
4109{
4110 BlockJob *job;
4111
4112 assert(id != NULL);
4113
4114 *aio_context = NULL;
4115
4116 job = block_job_get(id);
4117
4118 if (!job) {
4119 error_set(errp, ERROR_CLASS_DEVICE_NOT_ACTIVE,
4120 "Block job '%s' not found", id);
4121 return NULL;
4122 }
4123
4124 *aio_context = blk_get_aio_context(job->blk);
4125 aio_context_acquire(*aio_context);
4126
4127 return job;
4128}
4129
4130void qmp_block_job_set_speed(const char *device, int64_t speed, Error **errp)
4131{
4132 AioContext *aio_context;
4133 BlockJob *job = find_block_job(device, &aio_context, errp);
4134
4135 if (!job) {
4136 return;
4137 }
4138
4139 block_job_set_speed(job, speed, errp);
4140 aio_context_release(aio_context);
4141}
4142
4143void qmp_block_job_cancel(const char *device,
4144 bool has_force, bool force, Error **errp)
4145{
4146 AioContext *aio_context;
4147 BlockJob *job = find_block_job(device, &aio_context, errp);
4148
4149 if (!job) {
4150 return;
4151 }
4152
4153 if (!has_force) {
4154 force = false;
4155 }
4156
4157 if (job_user_paused(&job->job) && !force) {
4158 error_setg(errp, "The block job for device '%s' is currently paused",
4159 device);
4160 goto out;
4161 }
4162
4163 trace_qmp_block_job_cancel(job);
4164 job_user_cancel(&job->job, force, errp);
4165out:
4166 aio_context_release(aio_context);
4167}
4168
4169void qmp_block_job_pause(const char *device, Error **errp)
4170{
4171 AioContext *aio_context;
4172 BlockJob *job = find_block_job(device, &aio_context, errp);
4173
4174 if (!job) {
4175 return;
4176 }
4177
4178 trace_qmp_block_job_pause(job);
4179 job_user_pause(&job->job, errp);
4180 aio_context_release(aio_context);
4181}
4182
4183void qmp_block_job_resume(const char *device, Error **errp)
4184{
4185 AioContext *aio_context;
4186 BlockJob *job = find_block_job(device, &aio_context, errp);
4187
4188 if (!job) {
4189 return;
4190 }
4191
4192 trace_qmp_block_job_resume(job);
4193 job_user_resume(&job->job, errp);
4194 aio_context_release(aio_context);
4195}
4196
4197void qmp_block_job_complete(const char *device, Error **errp)
4198{
4199 AioContext *aio_context;
4200 BlockJob *job = find_block_job(device, &aio_context, errp);
4201
4202 if (!job) {
4203 return;
4204 }
4205
4206 trace_qmp_block_job_complete(job);
4207 job_complete(&job->job, errp);
4208 aio_context_release(aio_context);
4209}
4210
4211void qmp_block_job_finalize(const char *id, Error **errp)
4212{
4213 AioContext *aio_context;
4214 BlockJob *job = find_block_job(id, &aio_context, errp);
4215
4216 if (!job) {
4217 return;
4218 }
4219
4220 trace_qmp_block_job_finalize(job);
4221 job_finalize(&job->job, errp);
4222 aio_context_release(aio_context);
4223}
4224
4225void qmp_block_job_dismiss(const char *id, Error **errp)
4226{
4227 AioContext *aio_context;
4228 BlockJob *bjob = find_block_job(id, &aio_context, errp);
4229 Job *job;
4230
4231 if (!bjob) {
4232 return;
4233 }
4234
4235 trace_qmp_block_job_dismiss(bjob);
4236 job = &bjob->job;
4237 job_dismiss(&job, errp);
4238 aio_context_release(aio_context);
4239}
4240
4241void qmp_change_backing_file(const char *device,
4242 const char *image_node_name,
4243 const char *backing_file,
4244 Error **errp)
4245{
4246 BlockDriverState *bs = NULL;
4247 AioContext *aio_context;
4248 BlockDriverState *image_bs = NULL;
4249 Error *local_err = NULL;
4250 bool ro;
4251 int ret;
4252
4253 bs = qmp_get_root_bs(device, errp);
4254 if (!bs) {
4255 return;
4256 }
4257
4258 aio_context = bdrv_get_aio_context(bs);
4259 aio_context_acquire(aio_context);
4260
4261 image_bs = bdrv_lookup_bs(NULL, image_node_name, &local_err);
4262 if (local_err) {
4263 error_propagate(errp, local_err);
4264 goto out;
4265 }
4266
4267 if (!image_bs) {
4268 error_setg(errp, "image file not found");
4269 goto out;
4270 }
4271
4272 if (bdrv_find_base(image_bs) == image_bs) {
4273 error_setg(errp, "not allowing backing file change on an image "
4274 "without a backing file");
4275 goto out;
4276 }
4277
4278 /* even though we are not necessarily operating on bs, we need it to
4279 * determine if block ops are currently prohibited on the chain */
4280 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_CHANGE, errp)) {
4281 goto out;
4282 }
4283
4284 /* final sanity check */
4285 if (!bdrv_chain_contains(bs, image_bs)) {
4286 error_setg(errp, "'%s' and image file are not in the same chain",
4287 device);
4288 goto out;
4289 }
4290
4291 /* if not r/w, reopen to make r/w */
4292 ro = bdrv_is_read_only(image_bs);
4293
4294 if (ro) {
4295 if (bdrv_reopen_set_read_only(image_bs, false, errp) != 0) {
4296 goto out;
4297 }
4298 }
4299
4300 ret = bdrv_change_backing_file(image_bs, backing_file,
4301 image_bs->drv ? image_bs->drv->format_name : "");
4302
4303 if (ret < 0) {
4304 error_setg_errno(errp, -ret, "Could not change backing file to '%s'",
4305 backing_file);
4306 /* don't exit here, so we can try to restore open flags if
4307 * appropriate */
4308 }
4309
4310 if (ro) {
4311 bdrv_reopen_set_read_only(image_bs, true, &local_err);
4312 error_propagate(errp, local_err);
4313 }
4314
4315out:
4316 aio_context_release(aio_context);
4317}
4318
4319void hmp_drive_add_node(Monitor *mon, const char *optstr)
4320{
4321 QemuOpts *opts;
4322 QDict *qdict;
4323 Error *local_err = NULL;
4324
4325 opts = qemu_opts_parse_noisily(&qemu_drive_opts, optstr, false);
4326 if (!opts) {
4327 return;
4328 }
4329
4330 qdict = qemu_opts_to_qdict(opts, NULL);
4331
4332 if (!qdict_get_try_str(qdict, "node-name")) {
4333 qobject_unref(qdict);
4334 error_report("'node-name' needs to be specified");
4335 goto out;
4336 }
4337
4338 BlockDriverState *bs = bds_tree_init(qdict, &local_err);
4339 if (!bs) {
4340 error_report_err(local_err);
4341 goto out;
4342 }
4343
4344 QTAILQ_INSERT_TAIL(&monitor_bdrv_states, bs, monitor_list);
4345
4346out:
4347 qemu_opts_del(opts);
4348}
4349
4350void qmp_blockdev_add(BlockdevOptions *options, Error **errp)
4351{
4352 BlockDriverState *bs;
4353 QObject *obj;
4354 Visitor *v = qobject_output_visitor_new(&obj);
4355 QDict *qdict;
4356 Error *local_err = NULL;
4357
4358 visit_type_BlockdevOptions(v, NULL, &options, &local_err);
4359 if (local_err) {
4360 error_propagate(errp, local_err);
4361 goto fail;
4362 }
4363
4364 visit_complete(v, &obj);
4365 qdict = qobject_to(QDict, obj);
4366
4367 qdict_flatten(qdict);
4368
4369 if (!qdict_get_try_str(qdict, "node-name")) {
4370 error_setg(errp, "'node-name' must be specified for the root node");
4371 goto fail;
4372 }
4373
4374 bs = bds_tree_init(qdict, errp);
4375 if (!bs) {
4376 goto fail;
4377 }
4378
4379 QTAILQ_INSERT_TAIL(&monitor_bdrv_states, bs, monitor_list);
4380
4381fail:
4382 visit_free(v);
4383}
4384
4385void qmp_x_blockdev_reopen(BlockdevOptions *options, Error **errp)
4386{
4387 BlockDriverState *bs;
4388 AioContext *ctx;
4389 QObject *obj;
4390 Visitor *v = qobject_output_visitor_new(&obj);
4391 Error *local_err = NULL;
4392 BlockReopenQueue *queue;
4393 QDict *qdict;
4394
4395 /* Check for the selected node name */
4396 if (!options->has_node_name) {
4397 error_setg(errp, "Node name not specified");
4398 goto fail;
4399 }
4400
4401 bs = bdrv_find_node(options->node_name);
4402 if (!bs) {
4403 error_setg(errp, "Cannot find node named '%s'", options->node_name);
4404 goto fail;
4405 }
4406
4407 /* Put all options in a QDict and flatten it */
4408 visit_type_BlockdevOptions(v, NULL, &options, &local_err);
4409 if (local_err) {
4410 error_propagate(errp, local_err);
4411 goto fail;
4412 }
4413
4414 visit_complete(v, &obj);
4415 qdict = qobject_to(QDict, obj);
4416
4417 qdict_flatten(qdict);
4418
4419 /* Perform the reopen operation */
4420 ctx = bdrv_get_aio_context(bs);
4421 aio_context_acquire(ctx);
4422 bdrv_subtree_drained_begin(bs);
4423 queue = bdrv_reopen_queue(NULL, bs, qdict, false);
4424 bdrv_reopen_multiple(queue, errp);
4425 bdrv_subtree_drained_end(bs);
4426 aio_context_release(ctx);
4427
4428fail:
4429 visit_free(v);
4430}
4431
4432void qmp_blockdev_del(const char *node_name, Error **errp)
4433{
4434 AioContext *aio_context;
4435 BlockDriverState *bs;
4436
4437 bs = bdrv_find_node(node_name);
4438 if (!bs) {
4439 error_setg(errp, "Cannot find node %s", node_name);
4440 return;
4441 }
4442 if (bdrv_has_blk(bs)) {
4443 error_setg(errp, "Node %s is in use", node_name);
4444 return;
4445 }
4446 aio_context = bdrv_get_aio_context(bs);
4447 aio_context_acquire(aio_context);
4448
4449 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_DRIVE_DEL, errp)) {
4450 goto out;
4451 }
4452
4453 if (!QTAILQ_IN_USE(bs, monitor_list)) {
4454 error_setg(errp, "Node %s is not owned by the monitor",
4455 bs->node_name);
4456 goto out;
4457 }
4458
4459 if (bs->refcnt > 1) {
4460 error_setg(errp, "Block device %s is in use",
4461 bdrv_get_device_or_node_name(bs));
4462 goto out;
4463 }
4464
4465 QTAILQ_REMOVE(&monitor_bdrv_states, bs, monitor_list);
4466 bdrv_unref(bs);
4467
4468out:
4469 aio_context_release(aio_context);
4470}
4471
4472static BdrvChild *bdrv_find_child(BlockDriverState *parent_bs,
4473 const char *child_name)
4474{
4475 BdrvChild *child;
4476
4477 QLIST_FOREACH(child, &parent_bs->children, next) {
4478 if (strcmp(child->name, child_name) == 0) {
4479 return child;
4480 }
4481 }
4482
4483 return NULL;
4484}
4485
4486void qmp_x_blockdev_change(const char *parent, bool has_child,
4487 const char *child, bool has_node,
4488 const char *node, Error **errp)
4489{
4490 BlockDriverState *parent_bs, *new_bs = NULL;
4491 BdrvChild *p_child;
4492
4493 parent_bs = bdrv_lookup_bs(parent, parent, errp);
4494 if (!parent_bs) {
4495 return;
4496 }
4497
4498 if (has_child == has_node) {
4499 if (has_child) {
4500 error_setg(errp, "The parameters child and node are in conflict");
4501 } else {
4502 error_setg(errp, "Either child or node must be specified");
4503 }
4504 return;
4505 }
4506
4507 if (has_child) {
4508 p_child = bdrv_find_child(parent_bs, child);
4509 if (!p_child) {
4510 error_setg(errp, "Node '%s' does not have child '%s'",
4511 parent, child);
4512 return;
4513 }
4514 bdrv_del_child(parent_bs, p_child, errp);
4515 }
4516
4517 if (has_node) {
4518 new_bs = bdrv_find_node(node);
4519 if (!new_bs) {
4520 error_setg(errp, "Node '%s' not found", node);
4521 return;
4522 }
4523 bdrv_add_child(parent_bs, new_bs, errp);
4524 }
4525}
4526
4527BlockJobInfoList *qmp_query_block_jobs(Error **errp)
4528{
4529 BlockJobInfoList *head = NULL, **p_next = &head;
4530 BlockJob *job;
4531
4532 for (job = block_job_next(NULL); job; job = block_job_next(job)) {
4533 BlockJobInfoList *elem;
4534 AioContext *aio_context;
4535
4536 if (block_job_is_internal(job)) {
4537 continue;
4538 }
4539 elem = g_new0(BlockJobInfoList, 1);
4540 aio_context = blk_get_aio_context(job->blk);
4541 aio_context_acquire(aio_context);
4542 elem->value = block_job_query(job, errp);
4543 aio_context_release(aio_context);
4544 if (!elem->value) {
4545 g_free(elem);
4546 qapi_free_BlockJobInfoList(head);
4547 return NULL;
4548 }
4549 *p_next = elem;
4550 p_next = &elem->next;
4551 }
4552
4553 return head;
4554}
4555
4556void qmp_x_blockdev_set_iothread(const char *node_name, StrOrNull *iothread,
4557 bool has_force, bool force, Error **errp)
4558{
4559 AioContext *old_context;
4560 AioContext *new_context;
4561 BlockDriverState *bs;
4562
4563 bs = bdrv_find_node(node_name);
4564 if (!bs) {
4565 error_setg(errp, "Cannot find node %s", node_name);
4566 return;
4567 }
4568
4569 /* Protects against accidents. */
4570 if (!(has_force && force) && bdrv_has_blk(bs)) {
4571 error_setg(errp, "Node %s is associated with a BlockBackend and could "
4572 "be in use (use force=true to override this check)",
4573 node_name);
4574 return;
4575 }
4576
4577 if (iothread->type == QTYPE_QSTRING) {
4578 IOThread *obj = iothread_by_id(iothread->u.s);
4579 if (!obj) {
4580 error_setg(errp, "Cannot find iothread %s", iothread->u.s);
4581 return;
4582 }
4583
4584 new_context = iothread_get_aio_context(obj);
4585 } else {
4586 new_context = qemu_get_aio_context();
4587 }
4588
4589 old_context = bdrv_get_aio_context(bs);
4590 aio_context_acquire(old_context);
4591
4592 bdrv_try_set_aio_context(bs, new_context, errp);
4593
4594 aio_context_release(old_context);
4595}
4596
4597void qmp_block_latency_histogram_set(
4598 const char *id,
4599 bool has_boundaries, uint64List *boundaries,
4600 bool has_boundaries_read, uint64List *boundaries_read,
4601 bool has_boundaries_write, uint64List *boundaries_write,
4602 bool has_boundaries_flush, uint64List *boundaries_flush,
4603 Error **errp)
4604{
4605 BlockBackend *blk = qmp_get_blk(NULL, id, errp);
4606 BlockAcctStats *stats;
4607 int ret;
4608
4609 if (!blk) {
4610 return;
4611 }
4612
4613 stats = blk_get_stats(blk);
4614
4615 if (!has_boundaries && !has_boundaries_read && !has_boundaries_write &&
4616 !has_boundaries_flush)
4617 {
4618 block_latency_histograms_clear(stats);
4619 return;
4620 }
4621
4622 if (has_boundaries || has_boundaries_read) {
4623 ret = block_latency_histogram_set(
4624 stats, BLOCK_ACCT_READ,
4625 has_boundaries_read ? boundaries_read : boundaries);
4626 if (ret) {
4627 error_setg(errp, "Device '%s' set read boundaries fail", id);
4628 return;
4629 }
4630 }
4631
4632 if (has_boundaries || has_boundaries_write) {
4633 ret = block_latency_histogram_set(
4634 stats, BLOCK_ACCT_WRITE,
4635 has_boundaries_write ? boundaries_write : boundaries);
4636 if (ret) {
4637 error_setg(errp, "Device '%s' set write boundaries fail", id);
4638 return;
4639 }
4640 }
4641
4642 if (has_boundaries || has_boundaries_flush) {
4643 ret = block_latency_histogram_set(
4644 stats, BLOCK_ACCT_FLUSH,
4645 has_boundaries_flush ? boundaries_flush : boundaries);
4646 if (ret) {
4647 error_setg(errp, "Device '%s' set flush boundaries fail", id);
4648 return;
4649 }
4650 }
4651}
4652
4653QemuOptsList qemu_common_drive_opts = {
4654 .name = "drive",
4655 .head = QTAILQ_HEAD_INITIALIZER(qemu_common_drive_opts.head),
4656 .desc = {
4657 {
4658 .name = "snapshot",
4659 .type = QEMU_OPT_BOOL,
4660 .help = "enable/disable snapshot mode",
4661 },{
4662 .name = "aio",
4663 .type = QEMU_OPT_STRING,
4664 .help = "host AIO implementation (threads, native)",
4665 },{
4666 .name = BDRV_OPT_CACHE_WB,
4667 .type = QEMU_OPT_BOOL,
4668 .help = "Enable writeback mode",
4669 },{
4670 .name = "format",
4671 .type = QEMU_OPT_STRING,
4672 .help = "disk format (raw, qcow2, ...)",
4673 },{
4674 .name = "rerror",
4675 .type = QEMU_OPT_STRING,
4676 .help = "read error action",
4677 },{
4678 .name = "werror",
4679 .type = QEMU_OPT_STRING,
4680 .help = "write error action",
4681 },{
4682 .name = BDRV_OPT_READ_ONLY,
4683 .type = QEMU_OPT_BOOL,
4684 .help = "open drive file as read-only",
4685 },
4686
4687 THROTTLE_OPTS,
4688
4689 {
4690 .name = "throttling.group",
4691 .type = QEMU_OPT_STRING,
4692 .help = "name of the block throttling group",
4693 },{
4694 .name = "copy-on-read",
4695 .type = QEMU_OPT_BOOL,
4696 .help = "copy read data from backing file into image file",
4697 },{
4698 .name = "detect-zeroes",
4699 .type = QEMU_OPT_STRING,
4700 .help = "try to optimize zero writes (off, on, unmap)",
4701 },{
4702 .name = "stats-account-invalid",
4703 .type = QEMU_OPT_BOOL,
4704 .help = "whether to account for invalid I/O operations "
4705 "in the statistics",
4706 },{
4707 .name = "stats-account-failed",
4708 .type = QEMU_OPT_BOOL,
4709 .help = "whether to account for failed I/O operations "
4710 "in the statistics",
4711 },
4712 { /* end of list */ }
4713 },
4714};
4715
4716QemuOptsList qemu_drive_opts = {
4717 .name = "drive",
4718 .head = QTAILQ_HEAD_INITIALIZER(qemu_drive_opts.head),
4719 .desc = {
4720 /*
4721 * no elements => accept any params
4722 * validation will happen later
4723 */
4724 { /* end of list */ }
4725 },
4726};
4727