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