?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
linux-user,mips: move content of mips_syscall_args
[qemu/ar7.git] / blockdev.c
blob3e44fa766b8f4d41783e0fde4fdef420660d11b1
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 void hmp_commit(Monitor *mon, const QDict *qdict)
1043 {
1044 const char *device = qdict_get_str(qdict, "device");
1045 BlockBackend *blk;
1046 int ret;
1047
1048 if (!strcmp(device, "all")) {
1049 ret = blk_commit_all();
1050 } else {
1051 BlockDriverState *bs;
1052 AioContext *aio_context;
1053
1054 blk = blk_by_name(device);
1055 if (!blk) {
1056 error_report("Device '%s' not found", device);
1057 return;
1058 }
1059 if (!blk_is_available(blk)) {
1060 error_report("Device '%s' has no medium", device);
1061 return;
1062 }
1063
1064 bs = blk_bs(blk);
1065 aio_context = bdrv_get_aio_context(bs);
1066 aio_context_acquire(aio_context);
1067
1068 ret = bdrv_commit(bs);
1069
1070 aio_context_release(aio_context);
1071 }
1072 if (ret < 0) {
1073 error_report("'commit' error for '%s': %s", device, strerror(-ret));
1074 }
1075 }
1076
1077 static void blockdev_do_action(TransactionAction *action, Error **errp)
1078 {
1079 TransactionActionList list;
1080
1081 list.value = action;
1082 list.next = NULL;
1083 qmp_transaction(&list, false, NULL, errp);
1084 }
1085
1086 void qmp_blockdev_snapshot_sync(bool has_device, const char *device,
1087 bool has_node_name, const char *node_name,
1088 const char *snapshot_file,
1089 bool has_snapshot_node_name,
1090 const char *snapshot_node_name,
1091 bool has_format, const char *format,
1092 bool has_mode, NewImageMode mode, Error **errp)
1093 {
1094 BlockdevSnapshotSync snapshot = {
1095 .has_device = has_device,
1096 .device = (char *) device,
1097 .has_node_name = has_node_name,
1098 .node_name = (char *) node_name,
1099 .snapshot_file = (char *) snapshot_file,
1100 .has_snapshot_node_name = has_snapshot_node_name,
1101 .snapshot_node_name = (char *) snapshot_node_name,
1102 .has_format = has_format,
1103 .format = (char *) format,
1104 .has_mode = has_mode,
1105 .mode = mode,
1106 };
1107 TransactionAction action = {
1108 .type = TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_SYNC,
1109 .u.blockdev_snapshot_sync.data = &snapshot,
1110 };
1111 blockdev_do_action(&action, errp);
1112 }
1113
1114 void qmp_blockdev_snapshot(const char *node, const char *overlay,
1115 Error **errp)
1116 {
1117 BlockdevSnapshot snapshot_data = {
1118 .node = (char *) node,
1119 .overlay = (char *) overlay
1120 };
1121 TransactionAction action = {
1122 .type = TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT,
1123 .u.blockdev_snapshot.data = &snapshot_data,
1124 };
1125 blockdev_do_action(&action, errp);
1126 }
1127
1128 void qmp_blockdev_snapshot_internal_sync(const char *device,
1129 const char *name,
1130 Error **errp)
1131 {
1132 BlockdevSnapshotInternal snapshot = {
1133 .device = (char *) device,
1134 .name = (char *) name
1135 };
1136 TransactionAction action = {
1137 .type = TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_INTERNAL_SYNC,
1138 .u.blockdev_snapshot_internal_sync.data = &snapshot,
1139 };
1140 blockdev_do_action(&action, errp);
1141 }
1142
1143 SnapshotInfo *qmp_blockdev_snapshot_delete_internal_sync(const char *device,
1144 bool has_id,
1145 const char *id,
1146 bool has_name,
1147 const char *name,
1148 Error **errp)
1149 {
1150 BlockDriverState *bs;
1151 AioContext *aio_context;
1152 QEMUSnapshotInfo sn;
1153 Error *local_err = NULL;
1154 SnapshotInfo *info = NULL;
1155 int ret;
1156
1157 bs = qmp_get_root_bs(device, errp);
1158 if (!bs) {
1159 return NULL;
1160 }
1161 aio_context = bdrv_get_aio_context(bs);
1162 aio_context_acquire(aio_context);
1163
1164 if (!has_id) {
1165 id = NULL;
1166 }
1167
1168 if (!has_name) {
1169 name = NULL;
1170 }
1171
1172 if (!id && !name) {
1173 error_setg(errp, "Name or id must be provided");
1174 goto out_aio_context;
1175 }
1176
1177 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_INTERNAL_SNAPSHOT_DELETE, errp)) {
1178 goto out_aio_context;
1179 }
1180
1181 ret = bdrv_snapshot_find_by_id_and_name(bs, id, name, &sn, &local_err);
1182 if (local_err) {
1183 error_propagate(errp, local_err);
1184 goto out_aio_context;
1185 }
1186 if (!ret) {
1187 error_setg(errp,
1188 "Snapshot with id '%s' and name '%s' does not exist on "
1189 "device '%s'",
1190 STR_OR_NULL(id), STR_OR_NULL(name), device);
1191 goto out_aio_context;
1192 }
1193
1194 bdrv_snapshot_delete(bs, id, name, &local_err);
1195 if (local_err) {
1196 error_propagate(errp, local_err);
1197 goto out_aio_context;
1198 }
1199
1200 aio_context_release(aio_context);
1201
1202 info = g_new0(SnapshotInfo, 1);
1203 info->id = g_strdup(sn.id_str);
1204 info->name = g_strdup(sn.name);
1205 info->date_nsec = sn.date_nsec;
1206 info->date_sec = sn.date_sec;
1207 info->vm_state_size = sn.vm_state_size;
1208 info->vm_clock_nsec = sn.vm_clock_nsec % 1000000000;
1209 info->vm_clock_sec = sn.vm_clock_nsec / 1000000000;
1210
1211 return info;
1212
1213 out_aio_context:
1214 aio_context_release(aio_context);
1215 return NULL;
1216 }
1217
1218 /**
1219 * block_dirty_bitmap_lookup:
1220 * Return a dirty bitmap (if present), after validating
1221 * the node reference and bitmap names.
1222 *
1223 * @node: The name of the BDS node to search for bitmaps
1224 * @name: The name of the bitmap to search for
1225 * @pbs: Output pointer for BDS lookup, if desired. Can be NULL.
1226 * @errp: Output pointer for error information. Can be NULL.
1227 *
1228 * @return: A bitmap object on success, or NULL on failure.
1229 */
1230 static BdrvDirtyBitmap *block_dirty_bitmap_lookup(const char *node,
1231 const char *name,
1232 BlockDriverState **pbs,
1233 Error **errp)
1234 {
1235 BlockDriverState *bs;
1236 BdrvDirtyBitmap *bitmap;
1237
1238 if (!node) {
1239 error_setg(errp, "Node cannot be NULL");
1240 return NULL;
1241 }
1242 if (!name) {
1243 error_setg(errp, "Bitmap name cannot be NULL");
1244 return NULL;
1245 }
1246 bs = bdrv_lookup_bs(node, node, NULL);
1247 if (!bs) {
1248 error_setg(errp, "Node '%s' not found", node);
1249 return NULL;
1250 }
1251
1252 bitmap = bdrv_find_dirty_bitmap(bs, name);
1253 if (!bitmap) {
1254 error_setg(errp, "Dirty bitmap '%s' not found", name);
1255 return NULL;
1256 }
1257
1258 if (pbs) {
1259 *pbs = bs;
1260 }
1261
1262 return bitmap;
1263 }
1264
1265 /* New and old BlockDriverState structs for atomic group operations */
1266
1267 typedef struct BlkActionState BlkActionState;
1268
1269 /**
1270 * BlkActionOps:
1271 * Table of operations that define an Action.
1272 *
1273 * @instance_size: Size of state struct, in bytes.
1274 * @prepare: Prepare the work, must NOT be NULL.
1275 * @commit: Commit the changes, can be NULL.
1276 * @abort: Abort the changes on fail, can be NULL.
1277 * @clean: Clean up resources after all transaction actions have called
1278 * commit() or abort(). Can be NULL.
1279 *
1280 * Only prepare() may fail. In a single transaction, only one of commit() or
1281 * abort() will be called. clean() will always be called if it is present.
1282 */
1283 typedef struct BlkActionOps {
1284 size_t instance_size;
1285 void (*prepare)(BlkActionState *common, Error **errp);
1286 void (*commit)(BlkActionState *common);
1287 void (*abort)(BlkActionState *common);
1288 void (*clean)(BlkActionState *common);
1289 } BlkActionOps;
1290
1291 /**
1292 * BlkActionState:
1293 * Describes one Action's state within a Transaction.
1294 *
1295 * @action: QAPI-defined enum identifying which Action to perform.
1296 * @ops: Table of ActionOps this Action can perform.
1297 * @block_job_txn: Transaction which this action belongs to.
1298 * @entry: List membership for all Actions in this Transaction.
1299 *
1300 * This structure must be arranged as first member in a subclassed type,
1301 * assuming that the compiler will also arrange it to the same offsets as the
1302 * base class.
1303 */
1304 struct BlkActionState {
1305 TransactionAction *action;
1306 const BlkActionOps *ops;
1307 JobTxn *block_job_txn;
1308 TransactionProperties *txn_props;
1309 QTAILQ_ENTRY(BlkActionState) entry;
1310 };
1311
1312 /* internal snapshot private data */
1313 typedef struct InternalSnapshotState {
1314 BlkActionState common;
1315 BlockDriverState *bs;
1316 QEMUSnapshotInfo sn;
1317 bool created;
1318 } InternalSnapshotState;
1319
1320
1321 static int action_check_completion_mode(BlkActionState *s, Error **errp)
1322 {
1323 if (s->txn_props->completion_mode != ACTION_COMPLETION_MODE_INDIVIDUAL) {
1324 error_setg(errp,
1325 "Action '%s' does not support Transaction property "
1326 "completion-mode = %s",
1327 TransactionActionKind_str(s->action->type),
1328 ActionCompletionMode_str(s->txn_props->completion_mode));
1329 return -1;
1330 }
1331 return 0;
1332 }
1333
1334 static void internal_snapshot_prepare(BlkActionState *common,
1335 Error **errp)
1336 {
1337 Error *local_err = NULL;
1338 const char *device;
1339 const char *name;
1340 BlockDriverState *bs;
1341 QEMUSnapshotInfo old_sn, *sn;
1342 bool ret;
1343 qemu_timeval tv;
1344 BlockdevSnapshotInternal *internal;
1345 InternalSnapshotState *state;
1346 AioContext *aio_context;
1347 int ret1;
1348
1349 g_assert(common->action->type ==
1350 TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_INTERNAL_SYNC);
1351 internal = common->action->u.blockdev_snapshot_internal_sync.data;
1352 state = DO_UPCAST(InternalSnapshotState, common, common);
1353
1354 /* 1. parse input */
1355 device = internal->device;
1356 name = internal->name;
1357
1358 /* 2. check for validation */
1359 if (action_check_completion_mode(common, errp) < 0) {
1360 return;
1361 }
1362
1363 bs = qmp_get_root_bs(device, errp);
1364 if (!bs) {
1365 return;
1366 }
1367
1368 aio_context = bdrv_get_aio_context(bs);
1369 aio_context_acquire(aio_context);
1370
1371 state->bs = bs;
1372
1373 /* Paired with .clean() */
1374 bdrv_drained_begin(bs);
1375
1376 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_INTERNAL_SNAPSHOT, errp)) {
1377 goto out;
1378 }
1379
1380 if (bdrv_is_read_only(bs)) {
1381 error_setg(errp, "Device '%s' is read only", device);
1382 goto out;
1383 }
1384
1385 if (!bdrv_can_snapshot(bs)) {
1386 error_setg(errp, "Block format '%s' used by device '%s' "
1387 "does not support internal snapshots",
1388 bs->drv->format_name, device);
1389 goto out;
1390 }
1391
1392 if (!strlen(name)) {
1393 error_setg(errp, "Name is empty");
1394 goto out;
1395 }
1396
1397 /* check whether a snapshot with name exist */
1398 ret = bdrv_snapshot_find_by_id_and_name(bs, NULL, name, &old_sn,
1399 &local_err);
1400 if (local_err) {
1401 error_propagate(errp, local_err);
1402 goto out;
1403 } else if (ret) {
1404 error_setg(errp,
1405 "Snapshot with name '%s' already exists on device '%s'",
1406 name, device);
1407 goto out;
1408 }
1409
1410 /* 3. take the snapshot */
1411 sn = &state->sn;
1412 pstrcpy(sn->name, sizeof(sn->name), name);
1413 qemu_gettimeofday(&tv);
1414 sn->date_sec = tv.tv_sec;
1415 sn->date_nsec = tv.tv_usec * 1000;
1416 sn->vm_clock_nsec = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
1417
1418 ret1 = bdrv_snapshot_create(bs, sn);
1419 if (ret1 < 0) {
1420 error_setg_errno(errp, -ret1,
1421 "Failed to create snapshot '%s' on device '%s'",
1422 name, device);
1423 goto out;
1424 }
1425
1426 /* 4. succeed, mark a snapshot is created */
1427 state->created = true;
1428
1429 out:
1430 aio_context_release(aio_context);
1431 }
1432
1433 static void internal_snapshot_abort(BlkActionState *common)
1434 {
1435 InternalSnapshotState *state =
1436 DO_UPCAST(InternalSnapshotState, common, common);
1437 BlockDriverState *bs = state->bs;
1438 QEMUSnapshotInfo *sn = &state->sn;
1439 AioContext *aio_context;
1440 Error *local_error = NULL;
1441
1442 if (!state->created) {
1443 return;
1444 }
1445
1446 aio_context = bdrv_get_aio_context(state->bs);
1447 aio_context_acquire(aio_context);
1448
1449 if (bdrv_snapshot_delete(bs, sn->id_str, sn->name, &local_error) < 0) {
1450 error_reportf_err(local_error,
1451 "Failed to delete snapshot with id '%s' and "
1452 "name '%s' on device '%s' in abort: ",
1453 sn->id_str, sn->name,
1454 bdrv_get_device_name(bs));
1455 }
1456
1457 aio_context_release(aio_context);
1458 }
1459
1460 static void internal_snapshot_clean(BlkActionState *common)
1461 {
1462 InternalSnapshotState *state = DO_UPCAST(InternalSnapshotState,
1463 common, common);
1464 AioContext *aio_context;
1465
1466 if (!state->bs) {
1467 return;
1468 }
1469
1470 aio_context = bdrv_get_aio_context(state->bs);
1471 aio_context_acquire(aio_context);
1472
1473 bdrv_drained_end(state->bs);
1474
1475 aio_context_release(aio_context);
1476 }
1477
1478 /* external snapshot private data */
1479 typedef struct ExternalSnapshotState {
1480 BlkActionState common;
1481 BlockDriverState *old_bs;
1482 BlockDriverState *new_bs;
1483 bool overlay_appended;
1484 } ExternalSnapshotState;
1485
1486 static void external_snapshot_prepare(BlkActionState *common,
1487 Error **errp)
1488 {
1489 int flags = 0;
1490 QDict *options = NULL;
1491 Error *local_err = NULL;
1492 /* Device and node name of the image to generate the snapshot from */
1493 const char *device;
1494 const char *node_name;
1495 /* Reference to the new image (for 'blockdev-snapshot') */
1496 const char *snapshot_ref;
1497 /* File name of the new image (for 'blockdev-snapshot-sync') */
1498 const char *new_image_file;
1499 ExternalSnapshotState *state =
1500 DO_UPCAST(ExternalSnapshotState, common, common);
1501 TransactionAction *action = common->action;
1502 AioContext *aio_context;
1503 AioContext *old_context;
1504 int ret;
1505
1506 /* 'blockdev-snapshot' and 'blockdev-snapshot-sync' have similar
1507 * purpose but a different set of parameters */
1508 switch (action->type) {
1509 case TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT:
1510 {
1511 BlockdevSnapshot *s = action->u.blockdev_snapshot.data;
1512 device = s->node;
1513 node_name = s->node;
1514 new_image_file = NULL;
1515 snapshot_ref = s->overlay;
1516 }
1517 break;
1518 case TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_SYNC:
1519 {
1520 BlockdevSnapshotSync *s = action->u.blockdev_snapshot_sync.data;
1521 device = s->has_device ? s->device : NULL;
1522 node_name = s->has_node_name ? s->node_name : NULL;
1523 new_image_file = s->snapshot_file;
1524 snapshot_ref = NULL;
1525 }
1526 break;
1527 default:
1528 g_assert_not_reached();
1529 }
1530
1531 /* start processing */
1532 if (action_check_completion_mode(common, errp) < 0) {
1533 return;
1534 }
1535
1536 state->old_bs = bdrv_lookup_bs(device, node_name, errp);
1537 if (!state->old_bs) {
1538 return;
1539 }
1540
1541 aio_context = bdrv_get_aio_context(state->old_bs);
1542 aio_context_acquire(aio_context);
1543
1544 /* Paired with .clean() */
1545 bdrv_drained_begin(state->old_bs);
1546
1547 if (!bdrv_is_inserted(state->old_bs)) {
1548 error_setg(errp, QERR_DEVICE_HAS_NO_MEDIUM, device);
1549 goto out;
1550 }
1551
1552 if (bdrv_op_is_blocked(state->old_bs,
1553 BLOCK_OP_TYPE_EXTERNAL_SNAPSHOT, errp)) {
1554 goto out;
1555 }
1556
1557 if (!bdrv_is_read_only(state->old_bs)) {
1558 if (bdrv_flush(state->old_bs)) {
1559 error_setg(errp, QERR_IO_ERROR);
1560 goto out;
1561 }
1562 }
1563
1564 if (action->type == TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_SYNC) {
1565 BlockdevSnapshotSync *s = action->u.blockdev_snapshot_sync.data;
1566 const char *format = s->has_format ? s->format : "qcow2";
1567 enum NewImageMode mode;
1568 const char *snapshot_node_name =
1569 s->has_snapshot_node_name ? s->snapshot_node_name : NULL;
1570
1571 if (node_name && !snapshot_node_name) {
1572 error_setg(errp, "New overlay node name missing");
1573 goto out;
1574 }
1575
1576 if (snapshot_node_name &&
1577 bdrv_lookup_bs(snapshot_node_name, snapshot_node_name, NULL)) {
1578 error_setg(errp, "New overlay node name already in use");
1579 goto out;
1580 }
1581
1582 flags = state->old_bs->open_flags;
1583 flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_COPY_ON_READ);
1584 flags |= BDRV_O_NO_BACKING;
1585
1586 /* create new image w/backing file */
1587 mode = s->has_mode ? s->mode : NEW_IMAGE_MODE_ABSOLUTE_PATHS;
1588 if (mode != NEW_IMAGE_MODE_EXISTING) {
1589 int64_t size = bdrv_getlength(state->old_bs);
1590 if (size < 0) {
1591 error_setg_errno(errp, -size, "bdrv_getlength failed");
1592 goto out;
1593 }
1594 bdrv_refresh_filename(state->old_bs);
1595 bdrv_img_create(new_image_file, format,
1596 state->old_bs->filename,
1597 state->old_bs->drv->format_name,
1598 NULL, size, flags, false, &local_err);
1599 if (local_err) {
1600 error_propagate(errp, local_err);
1601 goto out;
1602 }
1603 }
1604
1605 options = qdict_new();
1606 if (snapshot_node_name) {
1607 qdict_put_str(options, "node-name", snapshot_node_name);
1608 }
1609 qdict_put_str(options, "driver", format);
1610 }
1611
1612 state->new_bs = bdrv_open(new_image_file, snapshot_ref, options, flags,
1613 errp);
1614 /* We will manually add the backing_hd field to the bs later */
1615 if (!state->new_bs) {
1616 goto out;
1617 }
1618
1619 if (bdrv_has_blk(state->new_bs)) {
1620 error_setg(errp, "The overlay is already in use");
1621 goto out;
1622 }
1623
1624 if (bdrv_op_is_blocked(state->new_bs, BLOCK_OP_TYPE_EXTERNAL_SNAPSHOT,
1625 errp)) {
1626 goto out;
1627 }
1628
1629 if (state->new_bs->backing != NULL) {
1630 error_setg(errp, "The overlay already has a backing image");
1631 goto out;
1632 }
1633
1634 if (!state->new_bs->drv->supports_backing) {
1635 error_setg(errp, "The overlay does not support backing images");
1636 goto out;
1637 }
1638
1639 /* Honor bdrv_try_set_aio_context() context acquisition requirements. */
1640 old_context = bdrv_get_aio_context(state->new_bs);
1641 aio_context_release(aio_context);
1642 aio_context_acquire(old_context);
1643
1644 ret = bdrv_try_set_aio_context(state->new_bs, aio_context, errp);
1645
1646 aio_context_release(old_context);
1647 aio_context_acquire(aio_context);
1648
1649 if (ret < 0) {
1650 goto out;
1651 }
1652
1653 /* This removes our old bs and adds the new bs. This is an operation that
1654 * can fail, so we need to do it in .prepare; undoing it for abort is
1655 * always possible. */
1656 bdrv_ref(state->new_bs);
1657 bdrv_append(state->new_bs, state->old_bs, &local_err);
1658 if (local_err) {
1659 error_propagate(errp, local_err);
1660 goto out;
1661 }
1662 state->overlay_appended = true;
1663
1664 out:
1665 aio_context_release(aio_context);
1666 }
1667
1668 static void external_snapshot_commit(BlkActionState *common)
1669 {
1670 ExternalSnapshotState *state =
1671 DO_UPCAST(ExternalSnapshotState, common, common);
1672 AioContext *aio_context;
1673
1674 aio_context = bdrv_get_aio_context(state->old_bs);
1675 aio_context_acquire(aio_context);
1676
1677 /* We don't need (or want) to use the transactional
1678 * bdrv_reopen_multiple() across all the entries at once, because we
1679 * don't want to abort all of them if one of them fails the reopen */
1680 if (!atomic_read(&state->old_bs->copy_on_read)) {
1681 bdrv_reopen_set_read_only(state->old_bs, true, NULL);
1682 }
1683
1684 aio_context_release(aio_context);
1685 }
1686
1687 static void external_snapshot_abort(BlkActionState *common)
1688 {
1689 ExternalSnapshotState *state =
1690 DO_UPCAST(ExternalSnapshotState, common, common);
1691 if (state->new_bs) {
1692 if (state->overlay_appended) {
1693 AioContext *aio_context;
1694 AioContext *tmp_context;
1695 int ret;
1696
1697 aio_context = bdrv_get_aio_context(state->old_bs);
1698 aio_context_acquire(aio_context);
1699
1700 bdrv_ref(state->old_bs); /* we can't let bdrv_set_backind_hd()
1701 close state->old_bs; we need it */
1702 bdrv_set_backing_hd(state->new_bs, NULL, &error_abort);
1703
1704 /*
1705 * The call to bdrv_set_backing_hd() above returns state->old_bs to
1706 * the main AioContext. As we're still going to be using it, return
1707 * it to the AioContext it was before.
1708 */
1709 tmp_context = bdrv_get_aio_context(state->old_bs);
1710 if (aio_context != tmp_context) {
1711 aio_context_release(aio_context);
1712 aio_context_acquire(tmp_context);
1713
1714 ret = bdrv_try_set_aio_context(state->old_bs,
1715 aio_context, NULL);
1716 assert(ret == 0);
1717
1718 aio_context_release(tmp_context);
1719 aio_context_acquire(aio_context);
1720 }
1721
1722 bdrv_replace_node(state->new_bs, state->old_bs, &error_abort);
1723 bdrv_unref(state->old_bs); /* bdrv_replace_node() ref'ed old_bs */
1724
1725 aio_context_release(aio_context);
1726 }
1727 }
1728 }
1729
1730 static void external_snapshot_clean(BlkActionState *common)
1731 {
1732 ExternalSnapshotState *state =
1733 DO_UPCAST(ExternalSnapshotState, common, common);
1734 AioContext *aio_context;
1735
1736 if (!state->old_bs) {
1737 return;
1738 }
1739
1740 aio_context = bdrv_get_aio_context(state->old_bs);
1741 aio_context_acquire(aio_context);
1742
1743 bdrv_drained_end(state->old_bs);
1744 bdrv_unref(state->new_bs);
1745
1746 aio_context_release(aio_context);
1747 }
1748
1749 typedef struct DriveBackupState {
1750 BlkActionState common;
1751 BlockDriverState *bs;
1752 BlockJob *job;
1753 } DriveBackupState;
1754
1755 static BlockJob *do_backup_common(BackupCommon *backup,
1756 BlockDriverState *bs,
1757 BlockDriverState *target_bs,
1758 AioContext *aio_context,
1759 JobTxn *txn, Error **errp);
1760
1761 static void drive_backup_prepare(BlkActionState *common, Error **errp)
1762 {
1763 DriveBackupState *state = DO_UPCAST(DriveBackupState, common, common);
1764 DriveBackup *backup;
1765 BlockDriverState *bs;
1766 BlockDriverState *target_bs;
1767 BlockDriverState *source = NULL;
1768 AioContext *aio_context;
1769 AioContext *old_context;
1770 QDict *options;
1771 Error *local_err = NULL;
1772 int flags;
1773 int64_t size;
1774 bool set_backing_hd = false;
1775 int ret;
1776
1777 assert(common->action->type == TRANSACTION_ACTION_KIND_DRIVE_BACKUP);
1778 backup = common->action->u.drive_backup.data;
1779
1780 if (!backup->has_mode) {
1781 backup->mode = NEW_IMAGE_MODE_ABSOLUTE_PATHS;
1782 }
1783
1784 bs = bdrv_lookup_bs(backup->device, backup->device, errp);
1785 if (!bs) {
1786 return;
1787 }
1788
1789 if (!bs->drv) {
1790 error_setg(errp, "Device has no medium");
1791 return;
1792 }
1793
1794 aio_context = bdrv_get_aio_context(bs);
1795 aio_context_acquire(aio_context);
1796
1797 /* Paired with .clean() */
1798 bdrv_drained_begin(bs);
1799
1800 if (!backup->has_format) {
1801 backup->format = backup->mode == NEW_IMAGE_MODE_EXISTING ?
1802 NULL : (char *) bs->drv->format_name;
1803 }
1804
1805 /* Early check to avoid creating target */
1806 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_BACKUP_SOURCE, errp)) {
1807 goto out;
1808 }
1809
1810 flags = bs->open_flags | BDRV_O_RDWR;
1811
1812 /*
1813 * See if we have a backing HD we can use to create our new image
1814 * on top of.
1815 */
1816 if (backup->sync == MIRROR_SYNC_MODE_TOP) {
1817 source = backing_bs(bs);
1818 if (!source) {
1819 backup->sync = MIRROR_SYNC_MODE_FULL;
1820 }
1821 }
1822 if (backup->sync == MIRROR_SYNC_MODE_NONE) {
1823 source = bs;
1824 flags |= BDRV_O_NO_BACKING;
1825 set_backing_hd = true;
1826 }
1827
1828 size = bdrv_getlength(bs);
1829 if (size < 0) {
1830 error_setg_errno(errp, -size, "bdrv_getlength failed");
1831 goto out;
1832 }
1833
1834 if (backup->mode != NEW_IMAGE_MODE_EXISTING) {
1835 assert(backup->format);
1836 if (source) {
1837 bdrv_refresh_filename(source);
1838 bdrv_img_create(backup->target, backup->format, source->filename,
1839 source->drv->format_name, NULL,
1840 size, flags, false, &local_err);
1841 } else {
1842 bdrv_img_create(backup->target, backup->format, NULL, NULL, NULL,
1843 size, flags, false, &local_err);
1844 }
1845 }
1846
1847 if (local_err) {
1848 error_propagate(errp, local_err);
1849 goto out;
1850 }
1851
1852 options = qdict_new();
1853 qdict_put_str(options, "discard", "unmap");
1854 qdict_put_str(options, "detect-zeroes", "unmap");
1855 if (backup->format) {
1856 qdict_put_str(options, "driver", backup->format);
1857 }
1858
1859 target_bs = bdrv_open(backup->target, NULL, options, flags, errp);
1860 if (!target_bs) {
1861 goto out;
1862 }
1863
1864 /* Honor bdrv_try_set_aio_context() context acquisition requirements. */
1865 old_context = bdrv_get_aio_context(target_bs);
1866 aio_context_release(aio_context);
1867 aio_context_acquire(old_context);
1868
1869 ret = bdrv_try_set_aio_context(target_bs, aio_context, errp);
1870 if (ret < 0) {
1871 bdrv_unref(target_bs);
1872 aio_context_release(old_context);
1873 return;
1874 }
1875
1876 aio_context_release(old_context);
1877 aio_context_acquire(aio_context);
1878
1879 if (set_backing_hd) {
1880 bdrv_set_backing_hd(target_bs, source, &local_err);
1881 if (local_err) {
1882 goto unref;
1883 }
1884 }
1885
1886 state->bs = bs;
1887
1888 state->job = do_backup_common(qapi_DriveBackup_base(backup),
1889 bs, target_bs, aio_context,
1890 common->block_job_txn, errp);
1891
1892 unref:
1893 bdrv_unref(target_bs);
1894 out:
1895 aio_context_release(aio_context);
1896 }
1897
1898 static void drive_backup_commit(BlkActionState *common)
1899 {
1900 DriveBackupState *state = DO_UPCAST(DriveBackupState, common, common);
1901 AioContext *aio_context;
1902
1903 aio_context = bdrv_get_aio_context(state->bs);
1904 aio_context_acquire(aio_context);
1905
1906 assert(state->job);
1907 job_start(&state->job->job);
1908
1909 aio_context_release(aio_context);
1910 }
1911
1912 static void drive_backup_abort(BlkActionState *common)
1913 {
1914 DriveBackupState *state = DO_UPCAST(DriveBackupState, common, common);
1915
1916 if (state->job) {
1917 AioContext *aio_context;
1918
1919 aio_context = bdrv_get_aio_context(state->bs);
1920 aio_context_acquire(aio_context);
1921
1922 job_cancel_sync(&state->job->job);
1923
1924 aio_context_release(aio_context);
1925 }
1926 }
1927
1928 static void drive_backup_clean(BlkActionState *common)
1929 {
1930 DriveBackupState *state = DO_UPCAST(DriveBackupState, common, common);
1931 AioContext *aio_context;
1932
1933 if (!state->bs) {
1934 return;
1935 }
1936
1937 aio_context = bdrv_get_aio_context(state->bs);
1938 aio_context_acquire(aio_context);
1939
1940 bdrv_drained_end(state->bs);
1941
1942 aio_context_release(aio_context);
1943 }
1944
1945 typedef struct BlockdevBackupState {
1946 BlkActionState common;
1947 BlockDriverState *bs;
1948 BlockJob *job;
1949 } BlockdevBackupState;
1950
1951 static void blockdev_backup_prepare(BlkActionState *common, Error **errp)
1952 {
1953 BlockdevBackupState *state = DO_UPCAST(BlockdevBackupState, common, common);
1954 BlockdevBackup *backup;
1955 BlockDriverState *bs;
1956 BlockDriverState *target_bs;
1957 AioContext *aio_context;
1958 AioContext *old_context;
1959 int ret;
1960
1961 assert(common->action->type == TRANSACTION_ACTION_KIND_BLOCKDEV_BACKUP);
1962 backup = common->action->u.blockdev_backup.data;
1963
1964 bs = bdrv_lookup_bs(backup->device, backup->device, errp);
1965 if (!bs) {
1966 return;
1967 }
1968
1969 target_bs = bdrv_lookup_bs(backup->target, backup->target, errp);
1970 if (!target_bs) {
1971 return;
1972 }
1973
1974 /* Honor bdrv_try_set_aio_context() context acquisition requirements. */
1975 aio_context = bdrv_get_aio_context(bs);
1976 old_context = bdrv_get_aio_context(target_bs);
1977 aio_context_acquire(old_context);
1978
1979 ret = bdrv_try_set_aio_context(target_bs, aio_context, errp);
1980 if (ret < 0) {
1981 aio_context_release(old_context);
1982 return;
1983 }
1984
1985 aio_context_release(old_context);
1986 aio_context_acquire(aio_context);
1987 state->bs = bs;
1988
1989 /* Paired with .clean() */
1990 bdrv_drained_begin(state->bs);
1991
1992 state->job = do_backup_common(qapi_BlockdevBackup_base(backup),
1993 bs, target_bs, aio_context,
1994 common->block_job_txn, errp);
1995
1996 aio_context_release(aio_context);
1997 }
1998
1999 static void blockdev_backup_commit(BlkActionState *common)
2000 {
2001 BlockdevBackupState *state = DO_UPCAST(BlockdevBackupState, common, common);
2002 AioContext *aio_context;
2003
2004 aio_context = bdrv_get_aio_context(state->bs);
2005 aio_context_acquire(aio_context);
2006
2007 assert(state->job);
2008 job_start(&state->job->job);
2009
2010 aio_context_release(aio_context);
2011 }
2012
2013 static void blockdev_backup_abort(BlkActionState *common)
2014 {
2015 BlockdevBackupState *state = DO_UPCAST(BlockdevBackupState, common, common);
2016
2017 if (state->job) {
2018 AioContext *aio_context;
2019
2020 aio_context = bdrv_get_aio_context(state->bs);
2021 aio_context_acquire(aio_context);
2022
2023 job_cancel_sync(&state->job->job);
2024
2025 aio_context_release(aio_context);
2026 }
2027 }
2028
2029 static void blockdev_backup_clean(BlkActionState *common)
2030 {
2031 BlockdevBackupState *state = DO_UPCAST(BlockdevBackupState, common, common);
2032 AioContext *aio_context;
2033
2034 if (!state->bs) {
2035 return;
2036 }
2037
2038 aio_context = bdrv_get_aio_context(state->bs);
2039 aio_context_acquire(aio_context);
2040
2041 bdrv_drained_end(state->bs);
2042
2043 aio_context_release(aio_context);
2044 }
2045
2046 typedef struct BlockDirtyBitmapState {
2047 BlkActionState common;
2048 BdrvDirtyBitmap *bitmap;
2049 BlockDriverState *bs;
2050 HBitmap *backup;
2051 bool prepared;
2052 bool was_enabled;
2053 } BlockDirtyBitmapState;
2054
2055 static void block_dirty_bitmap_add_prepare(BlkActionState *common,
2056 Error **errp)
2057 {
2058 Error *local_err = NULL;
2059 BlockDirtyBitmapAdd *action;
2060 BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
2061 common, common);
2062
2063 if (action_check_completion_mode(common, errp) < 0) {
2064 return;
2065 }
2066
2067 action = common->action->u.block_dirty_bitmap_add.data;
2068 /* AIO context taken and released within qmp_block_dirty_bitmap_add */
2069 qmp_block_dirty_bitmap_add(action->node, action->name,
2070 action->has_granularity, action->granularity,
2071 action->has_persistent, action->persistent,
2072 action->has_disabled, action->disabled,
2073 &local_err);
2074
2075 if (!local_err) {
2076 state->prepared = true;
2077 } else {
2078 error_propagate(errp, local_err);
2079 }
2080 }
2081
2082 static void block_dirty_bitmap_add_abort(BlkActionState *common)
2083 {
2084 BlockDirtyBitmapAdd *action;
2085 BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
2086 common, common);
2087
2088 action = common->action->u.block_dirty_bitmap_add.data;
2089 /* Should not be able to fail: IF the bitmap was added via .prepare(),
2090 * then the node reference and bitmap name must have been valid.
2091 */
2092 if (state->prepared) {
2093 qmp_block_dirty_bitmap_remove(action->node, action->name, &error_abort);
2094 }
2095 }
2096
2097 static void block_dirty_bitmap_clear_prepare(BlkActionState *common,
2098 Error **errp)
2099 {
2100 BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
2101 common, common);
2102 BlockDirtyBitmap *action;
2103
2104 if (action_check_completion_mode(common, errp) < 0) {
2105 return;
2106 }
2107
2108 action = common->action->u.block_dirty_bitmap_clear.data;
2109 state->bitmap = block_dirty_bitmap_lookup(action->node,
2110 action->name,
2111 &state->bs,
2112 errp);
2113 if (!state->bitmap) {
2114 return;
2115 }
2116
2117 if (bdrv_dirty_bitmap_check(state->bitmap, BDRV_BITMAP_DEFAULT, errp)) {
2118 return;
2119 }
2120
2121 bdrv_clear_dirty_bitmap(state->bitmap, &state->backup);
2122 }
2123
2124 static void block_dirty_bitmap_restore(BlkActionState *common)
2125 {
2126 BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
2127 common, common);
2128
2129 if (state->backup) {
2130 bdrv_restore_dirty_bitmap(state->bitmap, state->backup);
2131 }
2132 }
2133
2134 static void block_dirty_bitmap_free_backup(BlkActionState *common)
2135 {
2136 BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
2137 common, common);
2138
2139 hbitmap_free(state->backup);
2140 }
2141
2142 static void block_dirty_bitmap_enable_prepare(BlkActionState *common,
2143 Error **errp)
2144 {
2145 BlockDirtyBitmap *action;
2146 BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
2147 common, common);
2148
2149 if (action_check_completion_mode(common, errp) < 0) {
2150 return;
2151 }
2152
2153 action = common->action->u.block_dirty_bitmap_enable.data;
2154 state->bitmap = block_dirty_bitmap_lookup(action->node,
2155 action->name,
2156 NULL,
2157 errp);
2158 if (!state->bitmap) {
2159 return;
2160 }
2161
2162 if (bdrv_dirty_bitmap_check(state->bitmap, BDRV_BITMAP_ALLOW_RO, errp)) {
2163 return;
2164 }
2165
2166 state->was_enabled = bdrv_dirty_bitmap_enabled(state->bitmap);
2167 bdrv_enable_dirty_bitmap(state->bitmap);
2168 }
2169
2170 static void block_dirty_bitmap_enable_abort(BlkActionState *common)
2171 {
2172 BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
2173 common, common);
2174
2175 if (!state->was_enabled) {
2176 bdrv_disable_dirty_bitmap(state->bitmap);
2177 }
2178 }
2179
2180 static void block_dirty_bitmap_disable_prepare(BlkActionState *common,
2181 Error **errp)
2182 {
2183 BlockDirtyBitmap *action;
2184 BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
2185 common, common);
2186
2187 if (action_check_completion_mode(common, errp) < 0) {
2188 return;
2189 }
2190
2191 action = common->action->u.block_dirty_bitmap_disable.data;
2192 state->bitmap = block_dirty_bitmap_lookup(action->node,
2193 action->name,
2194 NULL,
2195 errp);
2196 if (!state->bitmap) {
2197 return;
2198 }
2199
2200 if (bdrv_dirty_bitmap_check(state->bitmap, BDRV_BITMAP_ALLOW_RO, errp)) {
2201 return;
2202 }
2203
2204 state->was_enabled = bdrv_dirty_bitmap_enabled(state->bitmap);
2205 bdrv_disable_dirty_bitmap(state->bitmap);
2206 }
2207
2208 static void block_dirty_bitmap_disable_abort(BlkActionState *common)
2209 {
2210 BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
2211 common, common);
2212
2213 if (state->was_enabled) {
2214 bdrv_enable_dirty_bitmap(state->bitmap);
2215 }
2216 }
2217
2218 static BdrvDirtyBitmap *do_block_dirty_bitmap_merge(
2219 const char *node, const char *target,
2220 BlockDirtyBitmapMergeSourceList *bitmaps,
2221 HBitmap **backup, Error **errp);
2222
2223 static void block_dirty_bitmap_merge_prepare(BlkActionState *common,
2224 Error **errp)
2225 {
2226 BlockDirtyBitmapMerge *action;
2227 BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
2228 common, common);
2229
2230 if (action_check_completion_mode(common, errp) < 0) {
2231 return;
2232 }
2233
2234 action = common->action->u.block_dirty_bitmap_merge.data;
2235
2236 state->bitmap = do_block_dirty_bitmap_merge(action->node, action->target,
2237 action->bitmaps, &state->backup,
2238 errp);
2239 }
2240
2241 static BdrvDirtyBitmap *do_block_dirty_bitmap_remove(
2242 const char *node, const char *name, bool release,
2243 BlockDriverState **bitmap_bs, Error **errp);
2244
2245 static void block_dirty_bitmap_remove_prepare(BlkActionState *common,
2246 Error **errp)
2247 {
2248 BlockDirtyBitmap *action;
2249 BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
2250 common, common);
2251
2252 if (action_check_completion_mode(common, errp) < 0) {
2253 return;
2254 }
2255
2256 action = common->action->u.block_dirty_bitmap_remove.data;
2257
2258 state->bitmap = do_block_dirty_bitmap_remove(action->node, action->name,
2259 false, &state->bs, errp);
2260 if (state->bitmap) {
2261 bdrv_dirty_bitmap_skip_store(state->bitmap, true);
2262 bdrv_dirty_bitmap_set_busy(state->bitmap, true);
2263 }
2264 }
2265
2266 static void block_dirty_bitmap_remove_abort(BlkActionState *common)
2267 {
2268 BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
2269 common, common);
2270
2271 if (state->bitmap) {
2272 bdrv_dirty_bitmap_skip_store(state->bitmap, false);
2273 bdrv_dirty_bitmap_set_busy(state->bitmap, false);
2274 }
2275 }
2276
2277 static void block_dirty_bitmap_remove_commit(BlkActionState *common)
2278 {
2279 BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
2280 common, common);
2281
2282 bdrv_dirty_bitmap_set_busy(state->bitmap, false);
2283 bdrv_release_dirty_bitmap(state->bitmap);
2284 }
2285
2286 static void abort_prepare(BlkActionState *common, Error **errp)
2287 {
2288 error_setg(errp, "Transaction aborted using Abort action");
2289 }
2290
2291 static void abort_commit(BlkActionState *common)
2292 {
2293 g_assert_not_reached(); /* this action never succeeds */
2294 }
2295
2296 static const BlkActionOps actions[] = {
2297 [TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT] = {
2298 .instance_size = sizeof(ExternalSnapshotState),
2299 .prepare = external_snapshot_prepare,
2300 .commit = external_snapshot_commit,
2301 .abort = external_snapshot_abort,
2302 .clean = external_snapshot_clean,
2303 },
2304 [TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_SYNC] = {
2305 .instance_size = sizeof(ExternalSnapshotState),
2306 .prepare = external_snapshot_prepare,
2307 .commit = external_snapshot_commit,
2308 .abort = external_snapshot_abort,
2309 .clean = external_snapshot_clean,
2310 },
2311 [TRANSACTION_ACTION_KIND_DRIVE_BACKUP] = {
2312 .instance_size = sizeof(DriveBackupState),
2313 .prepare = drive_backup_prepare,
2314 .commit = drive_backup_commit,
2315 .abort = drive_backup_abort,
2316 .clean = drive_backup_clean,
2317 },
2318 [TRANSACTION_ACTION_KIND_BLOCKDEV_BACKUP] = {
2319 .instance_size = sizeof(BlockdevBackupState),
2320 .prepare = blockdev_backup_prepare,
2321 .commit = blockdev_backup_commit,
2322 .abort = blockdev_backup_abort,
2323 .clean = blockdev_backup_clean,
2324 },
2325 [TRANSACTION_ACTION_KIND_ABORT] = {
2326 .instance_size = sizeof(BlkActionState),
2327 .prepare = abort_prepare,
2328 .commit = abort_commit,
2329 },
2330 [TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_INTERNAL_SYNC] = {
2331 .instance_size = sizeof(InternalSnapshotState),
2332 .prepare = internal_snapshot_prepare,
2333 .abort = internal_snapshot_abort,
2334 .clean = internal_snapshot_clean,
2335 },
2336 [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_ADD] = {
2337 .instance_size = sizeof(BlockDirtyBitmapState),
2338 .prepare = block_dirty_bitmap_add_prepare,
2339 .abort = block_dirty_bitmap_add_abort,
2340 },
2341 [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_CLEAR] = {
2342 .instance_size = sizeof(BlockDirtyBitmapState),
2343 .prepare = block_dirty_bitmap_clear_prepare,
2344 .commit = block_dirty_bitmap_free_backup,
2345 .abort = block_dirty_bitmap_restore,
2346 },
2347 [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_ENABLE] = {
2348 .instance_size = sizeof(BlockDirtyBitmapState),
2349 .prepare = block_dirty_bitmap_enable_prepare,
2350 .abort = block_dirty_bitmap_enable_abort,
2351 },
2352 [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_DISABLE] = {
2353 .instance_size = sizeof(BlockDirtyBitmapState),
2354 .prepare = block_dirty_bitmap_disable_prepare,
2355 .abort = block_dirty_bitmap_disable_abort,
2356 },
2357 [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_MERGE] = {
2358 .instance_size = sizeof(BlockDirtyBitmapState),
2359 .prepare = block_dirty_bitmap_merge_prepare,
2360 .commit = block_dirty_bitmap_free_backup,
2361 .abort = block_dirty_bitmap_restore,
2362 },
2363 [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_REMOVE] = {
2364 .instance_size = sizeof(BlockDirtyBitmapState),
2365 .prepare = block_dirty_bitmap_remove_prepare,
2366 .commit = block_dirty_bitmap_remove_commit,
2367 .abort = block_dirty_bitmap_remove_abort,
2368 },
2369 /* Where are transactions for MIRROR, COMMIT and STREAM?
2370 * Although these blockjobs use transaction callbacks like the backup job,
2371 * these jobs do not necessarily adhere to transaction semantics.
2372 * These jobs may not fully undo all of their actions on abort, nor do they
2373 * necessarily work in transactions with more than one job in them.
2374 */
2375 };
2376
2377 /**
2378 * Allocate a TransactionProperties structure if necessary, and fill
2379 * that structure with desired defaults if they are unset.
2380 */
2381 static TransactionProperties *get_transaction_properties(
2382 TransactionProperties *props)
2383 {
2384 if (!props) {
2385 props = g_new0(TransactionProperties, 1);
2386 }
2387
2388 if (!props->has_completion_mode) {
2389 props->has_completion_mode = true;
2390 props->completion_mode = ACTION_COMPLETION_MODE_INDIVIDUAL;
2391 }
2392
2393 return props;
2394 }
2395
2396 /*
2397 * 'Atomic' group operations. The operations are performed as a set, and if
2398 * any fail then we roll back all operations in the group.
2399 */
2400 void qmp_transaction(TransactionActionList *dev_list,
2401 bool has_props,
2402 struct TransactionProperties *props,
2403 Error **errp)
2404 {
2405 TransactionActionList *dev_entry = dev_list;
2406 JobTxn *block_job_txn = NULL;
2407 BlkActionState *state, *next;
2408 Error *local_err = NULL;
2409
2410 QTAILQ_HEAD(, BlkActionState) snap_bdrv_states;
2411 QTAILQ_INIT(&snap_bdrv_states);
2412
2413 /* Does this transaction get canceled as a group on failure?
2414 * If not, we don't really need to make a JobTxn.
2415 */
2416 props = get_transaction_properties(props);
2417 if (props->completion_mode != ACTION_COMPLETION_MODE_INDIVIDUAL) {
2418 block_job_txn = job_txn_new();
2419 }
2420
2421 /* drain all i/o before any operations */
2422 bdrv_drain_all();
2423
2424 /* We don't do anything in this loop that commits us to the operations */
2425 while (NULL != dev_entry) {
2426 TransactionAction *dev_info = NULL;
2427 const BlkActionOps *ops;
2428
2429 dev_info = dev_entry->value;
2430 dev_entry = dev_entry->next;
2431
2432 assert(dev_info->type < ARRAY_SIZE(actions));
2433
2434 ops = &actions[dev_info->type];
2435 assert(ops->instance_size > 0);
2436
2437 state = g_malloc0(ops->instance_size);
2438 state->ops = ops;
2439 state->action = dev_info;
2440 state->block_job_txn = block_job_txn;
2441 state->txn_props = props;
2442 QTAILQ_INSERT_TAIL(&snap_bdrv_states, state, entry);
2443
2444 state->ops->prepare(state, &local_err);
2445 if (local_err) {
2446 error_propagate(errp, local_err);
2447 goto delete_and_fail;
2448 }
2449 }
2450
2451 QTAILQ_FOREACH(state, &snap_bdrv_states, entry) {
2452 if (state->ops->commit) {
2453 state->ops->commit(state);
2454 }
2455 }
2456
2457 /* success */
2458 goto exit;
2459
2460 delete_and_fail:
2461 /* failure, and it is all-or-none; roll back all operations */
2462 QTAILQ_FOREACH_REVERSE(state, &snap_bdrv_states, entry) {
2463 if (state->ops->abort) {
2464 state->ops->abort(state);
2465 }
2466 }
2467 exit:
2468 QTAILQ_FOREACH_SAFE(state, &snap_bdrv_states, entry, next) {
2469 if (state->ops->clean) {
2470 state->ops->clean(state);
2471 }
2472 g_free(state);
2473 }
2474 if (!has_props) {
2475 qapi_free_TransactionProperties(props);
2476 }
2477 job_txn_unref(block_job_txn);
2478 }
2479
2480 void qmp_block_passwd(bool has_device, const char *device,
2481 bool has_node_name, const char *node_name,
2482 const char *password, Error **errp)
2483 {
2484 error_setg(errp,
2485 "Setting block passwords directly is no longer supported");
2486 }
2487
2488 void qmp_block_dirty_bitmap_add(const char *node, const char *name,
2489 bool has_granularity, uint32_t granularity,
2490 bool has_persistent, bool persistent,
2491 bool has_disabled, bool disabled,
2492 Error **errp)
2493 {
2494 BlockDriverState *bs;
2495 BdrvDirtyBitmap *bitmap;
2496 AioContext *aio_context;
2497
2498 if (!name || name[0] == '\0') {
2499 error_setg(errp, "Bitmap name cannot be empty");
2500 return;
2501 }
2502
2503 bs = bdrv_lookup_bs(node, node, errp);
2504 if (!bs) {
2505 return;
2506 }
2507
2508 aio_context = bdrv_get_aio_context(bs);
2509 aio_context_acquire(aio_context);
2510
2511 if (has_granularity) {
2512 if (granularity < 512 || !is_power_of_2(granularity)) {
2513 error_setg(errp, "Granularity must be power of 2 "
2514 "and at least 512");
2515 goto out;
2516 }
2517 } else {
2518 /* Default to cluster size, if available: */
2519 granularity = bdrv_get_default_bitmap_granularity(bs);
2520 }
2521
2522 if (!has_persistent) {
2523 persistent = false;
2524 }
2525
2526 if (!has_disabled) {
2527 disabled = false;
2528 }
2529
2530 if (persistent &&
2531 !bdrv_can_store_new_dirty_bitmap(bs, name, granularity, errp))
2532 {
2533 goto out;
2534 }
2535
2536 bitmap = bdrv_create_dirty_bitmap(bs, granularity, name, errp);
2537 if (bitmap == NULL) {
2538 goto out;
2539 }
2540
2541 if (disabled) {
2542 bdrv_disable_dirty_bitmap(bitmap);
2543 }
2544
2545 bdrv_dirty_bitmap_set_persistence(bitmap, persistent);
2546
2547 out:
2548 aio_context_release(aio_context);
2549 }
2550
2551 static BdrvDirtyBitmap *do_block_dirty_bitmap_remove(
2552 const char *node, const char *name, bool release,
2553 BlockDriverState **bitmap_bs, Error **errp)
2554 {
2555 BlockDriverState *bs;
2556 BdrvDirtyBitmap *bitmap;
2557 AioContext *aio_context;
2558
2559 bitmap = block_dirty_bitmap_lookup(node, name, &bs, errp);
2560 if (!bitmap || !bs) {
2561 return NULL;
2562 }
2563
2564 aio_context = bdrv_get_aio_context(bs);
2565 aio_context_acquire(aio_context);
2566
2567 if (bdrv_dirty_bitmap_check(bitmap, BDRV_BITMAP_BUSY | BDRV_BITMAP_RO,
2568 errp)) {
2569 aio_context_release(aio_context);
2570 return NULL;
2571 }
2572
2573 if (bdrv_dirty_bitmap_get_persistence(bitmap) &&
2574 bdrv_remove_persistent_dirty_bitmap(bs, name, errp) < 0)
2575 {
2576 aio_context_release(aio_context);
2577 return NULL;
2578 }
2579
2580 if (release) {
2581 bdrv_release_dirty_bitmap(bitmap);
2582 }
2583
2584 if (bitmap_bs) {
2585 *bitmap_bs = bs;
2586 }
2587
2588 aio_context_release(aio_context);
2589 return release ? NULL : bitmap;
2590 }
2591
2592 void qmp_block_dirty_bitmap_remove(const char *node, const char *name,
2593 Error **errp)
2594 {
2595 do_block_dirty_bitmap_remove(node, name, true, NULL, errp);
2596 }
2597
2598 /**
2599 * Completely clear a bitmap, for the purposes of synchronizing a bitmap
2600 * immediately after a full backup operation.
2601 */
2602 void qmp_block_dirty_bitmap_clear(const char *node, const char *name,
2603 Error **errp)
2604 {
2605 BdrvDirtyBitmap *bitmap;
2606 BlockDriverState *bs;
2607
2608 bitmap = block_dirty_bitmap_lookup(node, name, &bs, errp);
2609 if (!bitmap || !bs) {
2610 return;
2611 }
2612
2613 if (bdrv_dirty_bitmap_check(bitmap, BDRV_BITMAP_DEFAULT, errp)) {
2614 return;
2615 }
2616
2617 bdrv_clear_dirty_bitmap(bitmap, NULL);
2618 }
2619
2620 void qmp_block_dirty_bitmap_enable(const char *node, const char *name,
2621 Error **errp)
2622 {
2623 BlockDriverState *bs;
2624 BdrvDirtyBitmap *bitmap;
2625
2626 bitmap = block_dirty_bitmap_lookup(node, name, &bs, errp);
2627 if (!bitmap) {
2628 return;
2629 }
2630
2631 if (bdrv_dirty_bitmap_check(bitmap, BDRV_BITMAP_ALLOW_RO, errp)) {
2632 return;
2633 }
2634
2635 bdrv_enable_dirty_bitmap(bitmap);
2636 }
2637
2638 void qmp_block_dirty_bitmap_disable(const char *node, const char *name,
2639 Error **errp)
2640 {
2641 BlockDriverState *bs;
2642 BdrvDirtyBitmap *bitmap;
2643
2644 bitmap = block_dirty_bitmap_lookup(node, name, &bs, errp);
2645 if (!bitmap) {
2646 return;
2647 }
2648
2649 if (bdrv_dirty_bitmap_check(bitmap, BDRV_BITMAP_ALLOW_RO, errp)) {
2650 return;
2651 }
2652
2653 bdrv_disable_dirty_bitmap(bitmap);
2654 }
2655
2656 static BdrvDirtyBitmap *do_block_dirty_bitmap_merge(
2657 const char *node, const char *target,
2658 BlockDirtyBitmapMergeSourceList *bitmaps,
2659 HBitmap **backup, Error **errp)
2660 {
2661 BlockDriverState *bs;
2662 BdrvDirtyBitmap *dst, *src, *anon;
2663 BlockDirtyBitmapMergeSourceList *lst;
2664 Error *local_err = NULL;
2665
2666 dst = block_dirty_bitmap_lookup(node, target, &bs, errp);
2667 if (!dst) {
2668 return NULL;
2669 }
2670
2671 anon = bdrv_create_dirty_bitmap(bs, bdrv_dirty_bitmap_granularity(dst),
2672 NULL, errp);
2673 if (!anon) {
2674 return NULL;
2675 }
2676
2677 for (lst = bitmaps; lst; lst = lst->next) {
2678 switch (lst->value->type) {
2679 const char *name, *node;
2680 case QTYPE_QSTRING:
2681 name = lst->value->u.local;
2682 src = bdrv_find_dirty_bitmap(bs, name);
2683 if (!src) {
2684 error_setg(errp, "Dirty bitmap '%s' not found", name);
2685 dst = NULL;
2686 goto out;
2687 }
2688 break;
2689 case QTYPE_QDICT:
2690 node = lst->value->u.external.node;
2691 name = lst->value->u.external.name;
2692 src = block_dirty_bitmap_lookup(node, name, NULL, errp);
2693 if (!src) {
2694 dst = NULL;
2695 goto out;
2696 }
2697 break;
2698 default:
2699 abort();
2700 }
2701
2702 bdrv_merge_dirty_bitmap(anon, src, NULL, &local_err);
2703 if (local_err) {
2704 error_propagate(errp, local_err);
2705 dst = NULL;
2706 goto out;
2707 }
2708 }
2709
2710 /* Merge into dst; dst is unchanged on failure. */
2711 bdrv_merge_dirty_bitmap(dst, anon, backup, errp);
2712
2713 out:
2714 bdrv_release_dirty_bitmap(anon);
2715 return dst;
2716 }
2717
2718 void qmp_block_dirty_bitmap_merge(const char *node, const char *target,
2719 BlockDirtyBitmapMergeSourceList *bitmaps,
2720 Error **errp)
2721 {
2722 do_block_dirty_bitmap_merge(node, target, bitmaps, NULL, errp);
2723 }
2724
2725 BlockDirtyBitmapSha256 *qmp_x_debug_block_dirty_bitmap_sha256(const char *node,
2726 const char *name,
2727 Error **errp)
2728 {
2729 BdrvDirtyBitmap *bitmap;
2730 BlockDriverState *bs;
2731 BlockDirtyBitmapSha256 *ret = NULL;
2732 char *sha256;
2733
2734 bitmap = block_dirty_bitmap_lookup(node, name, &bs, errp);
2735 if (!bitmap || !bs) {
2736 return NULL;
2737 }
2738
2739 sha256 = bdrv_dirty_bitmap_sha256(bitmap, errp);
2740 if (sha256 == NULL) {
2741 return NULL;
2742 }
2743
2744 ret = g_new(BlockDirtyBitmapSha256, 1);
2745 ret->sha256 = sha256;
2746
2747 return ret;
2748 }
2749
2750 void hmp_drive_del(Monitor *mon, const QDict *qdict)
2751 {
2752 const char *id = qdict_get_str(qdict, "id");
2753 BlockBackend *blk;
2754 BlockDriverState *bs;
2755 AioContext *aio_context;
2756 Error *local_err = NULL;
2757
2758 bs = bdrv_find_node(id);
2759 if (bs) {
2760 qmp_blockdev_del(id, &local_err);
2761 if (local_err) {
2762 error_report_err(local_err);
2763 }
2764 return;
2765 }
2766
2767 blk = blk_by_name(id);
2768 if (!blk) {
2769 error_report("Device '%s' not found", id);
2770 return;
2771 }
2772
2773 if (!blk_legacy_dinfo(blk)) {
2774 error_report("Deleting device added with blockdev-add"
2775 " is not supported");
2776 return;
2777 }
2778
2779 aio_context = blk_get_aio_context(blk);
2780 aio_context_acquire(aio_context);
2781
2782 bs = blk_bs(blk);
2783 if (bs) {
2784 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_DRIVE_DEL, &local_err)) {
2785 error_report_err(local_err);
2786 aio_context_release(aio_context);
2787 return;
2788 }
2789
2790 blk_remove_bs(blk);
2791 }
2792
2793 /* Make the BlockBackend and the attached BlockDriverState anonymous */
2794 monitor_remove_blk(blk);
2795
2796 /* If this BlockBackend has a device attached to it, its refcount will be
2797 * decremented when the device is removed; otherwise we have to do so here.
2798 */
2799 if (blk_get_attached_dev(blk)) {
2800 /* Further I/O must not pause the guest */
2801 blk_set_on_error(blk, BLOCKDEV_ON_ERROR_REPORT,
2802 BLOCKDEV_ON_ERROR_REPORT);
2803 } else {
2804 blk_unref(blk);
2805 }
2806
2807 aio_context_release(aio_context);
2808 }
2809
2810 void qmp_block_resize(bool has_device, const char *device,
2811 bool has_node_name, const char *node_name,
2812 int64_t size, Error **errp)
2813 {
2814 Error *local_err = NULL;
2815 BlockBackend *blk = NULL;
2816 BlockDriverState *bs;
2817 AioContext *aio_context;
2818 int ret;
2819
2820 bs = bdrv_lookup_bs(has_device ? device : NULL,
2821 has_node_name ? node_name : NULL,
2822 &local_err);
2823 if (local_err) {
2824 error_propagate(errp, local_err);
2825 return;
2826 }
2827
2828 aio_context = bdrv_get_aio_context(bs);
2829 aio_context_acquire(aio_context);
2830
2831 if (size < 0) {
2832 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "size", "a >0 size");
2833 goto out;
2834 }
2835
2836 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_RESIZE, NULL)) {
2837 error_setg(errp, QERR_DEVICE_IN_USE, device);
2838 goto out;
2839 }
2840
2841 blk = blk_new(bdrv_get_aio_context(bs), BLK_PERM_RESIZE, BLK_PERM_ALL);
2842 ret = blk_insert_bs(blk, bs, errp);
2843 if (ret < 0) {
2844 goto out;
2845 }
2846
2847 bdrv_drained_begin(bs);
2848 ret = blk_truncate(blk, size, false, PREALLOC_MODE_OFF, errp);
2849 bdrv_drained_end(bs);
2850
2851 out:
2852 blk_unref(blk);
2853 aio_context_release(aio_context);
2854 }
2855
2856 void qmp_block_stream(bool has_job_id, const char *job_id, const char *device,
2857 bool has_base, const char *base,
2858 bool has_base_node, const char *base_node,
2859 bool has_backing_file, const char *backing_file,
2860 bool has_speed, int64_t speed,
2861 bool has_on_error, BlockdevOnError on_error,
2862 bool has_auto_finalize, bool auto_finalize,
2863 bool has_auto_dismiss, bool auto_dismiss,
2864 Error **errp)
2865 {
2866 BlockDriverState *bs, *iter;
2867 BlockDriverState *base_bs = NULL;
2868 AioContext *aio_context;
2869 Error *local_err = NULL;
2870 const char *base_name = NULL;
2871 int job_flags = JOB_DEFAULT;
2872
2873 if (!has_on_error) {
2874 on_error = BLOCKDEV_ON_ERROR_REPORT;
2875 }
2876
2877 bs = bdrv_lookup_bs(device, device, errp);
2878 if (!bs) {
2879 return;
2880 }
2881
2882 aio_context = bdrv_get_aio_context(bs);
2883 aio_context_acquire(aio_context);
2884
2885 if (has_base && has_base_node) {
2886 error_setg(errp, "'base' and 'base-node' cannot be specified "
2887 "at the same time");
2888 goto out;
2889 }
2890
2891 if (has_base) {
2892 base_bs = bdrv_find_backing_image(bs, base);
2893 if (base_bs == NULL) {
2894 error_setg(errp, QERR_BASE_NOT_FOUND, base);
2895 goto out;
2896 }
2897 assert(bdrv_get_aio_context(base_bs) == aio_context);
2898 base_name = base;
2899 }
2900
2901 if (has_base_node) {
2902 base_bs = bdrv_lookup_bs(NULL, base_node, errp);
2903 if (!base_bs) {
2904 goto out;
2905 }
2906 if (bs == base_bs || !bdrv_chain_contains(bs, base_bs)) {
2907 error_setg(errp, "Node '%s' is not a backing image of '%s'",
2908 base_node, device);
2909 goto out;
2910 }
2911 assert(bdrv_get_aio_context(base_bs) == aio_context);
2912 bdrv_refresh_filename(base_bs);
2913 base_name = base_bs->filename;
2914 }
2915
2916 /* Check for op blockers in the whole chain between bs and base */
2917 for (iter = bs; iter && iter != base_bs; iter = backing_bs(iter)) {
2918 if (bdrv_op_is_blocked(iter, BLOCK_OP_TYPE_STREAM, errp)) {
2919 goto out;
2920 }
2921 }
2922
2923 /* if we are streaming the entire chain, the result will have no backing
2924 * file, and specifying one is therefore an error */
2925 if (base_bs == NULL && has_backing_file) {
2926 error_setg(errp, "backing file specified, but streaming the "
2927 "entire chain");
2928 goto out;
2929 }
2930
2931 /* backing_file string overrides base bs filename */
2932 base_name = has_backing_file ? backing_file : base_name;
2933
2934 if (has_auto_finalize && !auto_finalize) {
2935 job_flags |= JOB_MANUAL_FINALIZE;
2936 }
2937 if (has_auto_dismiss && !auto_dismiss) {
2938 job_flags |= JOB_MANUAL_DISMISS;
2939 }
2940
2941 stream_start(has_job_id ? job_id : NULL, bs, base_bs, base_name,
2942 job_flags, has_speed ? speed : 0, on_error, &local_err);
2943 if (local_err) {
2944 error_propagate(errp, local_err);
2945 goto out;
2946 }
2947
2948 trace_qmp_block_stream(bs);
2949
2950 out:
2951 aio_context_release(aio_context);
2952 }
2953
2954 void qmp_block_commit(bool has_job_id, const char *job_id, const char *device,
2955 bool has_base_node, const char *base_node,
2956 bool has_base, const char *base,
2957 bool has_top_node, const char *top_node,
2958 bool has_top, const char *top,
2959 bool has_backing_file, const char *backing_file,
2960 bool has_speed, int64_t speed,
2961 bool has_on_error, BlockdevOnError on_error,
2962 bool has_filter_node_name, const char *filter_node_name,
2963 bool has_auto_finalize, bool auto_finalize,
2964 bool has_auto_dismiss, bool auto_dismiss,
2965 Error **errp)
2966 {
2967 BlockDriverState *bs;
2968 BlockDriverState *iter;
2969 BlockDriverState *base_bs, *top_bs;
2970 AioContext *aio_context;
2971 Error *local_err = NULL;
2972 int job_flags = JOB_DEFAULT;
2973
2974 if (!has_speed) {
2975 speed = 0;
2976 }
2977 if (!has_on_error) {
2978 on_error = BLOCKDEV_ON_ERROR_REPORT;
2979 }
2980 if (!has_filter_node_name) {
2981 filter_node_name = NULL;
2982 }
2983 if (has_auto_finalize && !auto_finalize) {
2984 job_flags |= JOB_MANUAL_FINALIZE;
2985 }
2986 if (has_auto_dismiss && !auto_dismiss) {
2987 job_flags |= JOB_MANUAL_DISMISS;
2988 }
2989
2990 /* Important Note:
2991 * libvirt relies on the DeviceNotFound error class in order to probe for
2992 * live commit feature versions; for this to work, we must make sure to
2993 * perform the device lookup before any generic errors that may occur in a
2994 * scenario in which all optional arguments are omitted. */
2995 bs = qmp_get_root_bs(device, &local_err);
2996 if (!bs) {
2997 bs = bdrv_lookup_bs(device, device, NULL);
2998 if (!bs) {
2999 error_free(local_err);
3000 error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
3001 "Device '%s' not found", device);
3002 } else {
3003 error_propagate(errp, local_err);
3004 }
3005 return;
3006 }
3007
3008 aio_context = bdrv_get_aio_context(bs);
3009 aio_context_acquire(aio_context);
3010
3011 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_COMMIT_SOURCE, errp)) {
3012 goto out;
3013 }
3014
3015 /* default top_bs is the active layer */
3016 top_bs = bs;
3017
3018 if (has_top_node && has_top) {
3019 error_setg(errp, "'top-node' and 'top' are mutually exclusive");
3020 goto out;
3021 } else if (has_top_node) {
3022 top_bs = bdrv_lookup_bs(NULL, top_node, errp);
3023 if (top_bs == NULL) {
3024 goto out;
3025 }
3026 if (!bdrv_chain_contains(bs, top_bs)) {
3027 error_setg(errp, "'%s' is not in this backing file chain",
3028 top_node);
3029 goto out;
3030 }
3031 } else if (has_top && top) {
3032 /* This strcmp() is just a shortcut, there is no need to
3033 * refresh @bs's filename. If it mismatches,
3034 * bdrv_find_backing_image() will do the refresh and may still
3035 * return @bs. */
3036 if (strcmp(bs->filename, top) != 0) {
3037 top_bs = bdrv_find_backing_image(bs, top);
3038 }
3039 }
3040
3041 if (top_bs == NULL) {
3042 error_setg(errp, "Top image file %s not found", top ? top : "NULL");
3043 goto out;
3044 }
3045
3046 assert(bdrv_get_aio_context(top_bs) == aio_context);
3047
3048 if (has_base_node && has_base) {
3049 error_setg(errp, "'base-node' and 'base' are mutually exclusive");
3050 goto out;
3051 } else if (has_base_node) {
3052 base_bs = bdrv_lookup_bs(NULL, base_node, errp);
3053 if (base_bs == NULL) {
3054 goto out;
3055 }
3056 if (!bdrv_chain_contains(top_bs, base_bs)) {
3057 error_setg(errp, "'%s' is not in this backing file chain",
3058 base_node);
3059 goto out;
3060 }
3061 } else if (has_base && base) {
3062 base_bs = bdrv_find_backing_image(top_bs, base);
3063 } else {
3064 base_bs = bdrv_find_base(top_bs);
3065 }
3066
3067 if (base_bs == NULL) {
3068 error_setg(errp, QERR_BASE_NOT_FOUND, base ? base : "NULL");
3069 goto out;
3070 }
3071
3072 assert(bdrv_get_aio_context(base_bs) == aio_context);
3073
3074 for (iter = top_bs; iter != backing_bs(base_bs); iter = backing_bs(iter)) {
3075 if (bdrv_op_is_blocked(iter, BLOCK_OP_TYPE_COMMIT_TARGET, errp)) {
3076 goto out;
3077 }
3078 }
3079
3080 /* Do not allow attempts to commit an image into itself */
3081 if (top_bs == base_bs) {
3082 error_setg(errp, "cannot commit an image into itself");
3083 goto out;
3084 }
3085
3086 if (top_bs == bs) {
3087 if (has_backing_file) {
3088 error_setg(errp, "'backing-file' specified,"
3089 " but 'top' is the active layer");
3090 goto out;
3091 }
3092 commit_active_start(has_job_id ? job_id : NULL, bs, base_bs,
3093 job_flags, speed, on_error,
3094 filter_node_name, NULL, NULL, false, &local_err);
3095 } else {
3096 BlockDriverState *overlay_bs = bdrv_find_overlay(bs, top_bs);
3097 if (bdrv_op_is_blocked(overlay_bs, BLOCK_OP_TYPE_COMMIT_TARGET, errp)) {
3098 goto out;
3099 }
3100 commit_start(has_job_id ? job_id : NULL, bs, base_bs, top_bs, job_flags,
3101 speed, on_error, has_backing_file ? backing_file : NULL,
3102 filter_node_name, &local_err);
3103 }
3104 if (local_err != NULL) {
3105 error_propagate(errp, local_err);
3106 goto out;
3107 }
3108
3109 out:
3110 aio_context_release(aio_context);
3111 }
3112
3113 /* Common QMP interface for drive-backup and blockdev-backup */
3114 static BlockJob *do_backup_common(BackupCommon *backup,
3115 BlockDriverState *bs,
3116 BlockDriverState *target_bs,
3117 AioContext *aio_context,
3118 JobTxn *txn, Error **errp)
3119 {
3120 BlockJob *job = NULL;
3121 BdrvDirtyBitmap *bmap = NULL;
3122 int job_flags = JOB_DEFAULT;
3123
3124 if (!backup->has_speed) {
3125 backup->speed = 0;
3126 }
3127 if (!backup->has_on_source_error) {
3128 backup->on_source_error = BLOCKDEV_ON_ERROR_REPORT;
3129 }
3130 if (!backup->has_on_target_error) {
3131 backup->on_target_error = BLOCKDEV_ON_ERROR_REPORT;
3132 }
3133 if (!backup->has_job_id) {
3134 backup->job_id = NULL;
3135 }
3136 if (!backup->has_auto_finalize) {
3137 backup->auto_finalize = true;
3138 }
3139 if (!backup->has_auto_dismiss) {
3140 backup->auto_dismiss = true;
3141 }
3142 if (!backup->has_compress) {
3143 backup->compress = false;
3144 }
3145
3146 if ((backup->sync == MIRROR_SYNC_MODE_BITMAP) ||
3147 (backup->sync == MIRROR_SYNC_MODE_INCREMENTAL)) {
3148 /* done before desugaring 'incremental' to print the right message */
3149 if (!backup->has_bitmap) {
3150 error_setg(errp, "must provide a valid bitmap name for "
3151 "'%s' sync mode", MirrorSyncMode_str(backup->sync));
3152 return NULL;
3153 }
3154 }
3155
3156 if (backup->sync == MIRROR_SYNC_MODE_INCREMENTAL) {
3157 if (backup->has_bitmap_mode &&
3158 backup->bitmap_mode != BITMAP_SYNC_MODE_ON_SUCCESS) {
3159 error_setg(errp, "Bitmap sync mode must be '%s' "
3160 "when using sync mode '%s'",
3161 BitmapSyncMode_str(BITMAP_SYNC_MODE_ON_SUCCESS),
3162 MirrorSyncMode_str(backup->sync));
3163 return NULL;
3164 }
3165 backup->has_bitmap_mode = true;
3166 backup->sync = MIRROR_SYNC_MODE_BITMAP;
3167 backup->bitmap_mode = BITMAP_SYNC_MODE_ON_SUCCESS;
3168 }
3169
3170 if (backup->has_bitmap) {
3171 bmap = bdrv_find_dirty_bitmap(bs, backup->bitmap);
3172 if (!bmap) {
3173 error_setg(errp, "Bitmap '%s' could not be found", backup->bitmap);
3174 return NULL;
3175 }
3176 if (!backup->has_bitmap_mode) {
3177 error_setg(errp, "Bitmap sync mode must be given "
3178 "when providing a bitmap");
3179 return NULL;
3180 }
3181 if (bdrv_dirty_bitmap_check(bmap, BDRV_BITMAP_ALLOW_RO, errp)) {
3182 return NULL;
3183 }
3184
3185 /* This does not produce a useful bitmap artifact: */
3186 if (backup->sync == MIRROR_SYNC_MODE_NONE) {
3187 error_setg(errp, "sync mode '%s' does not produce meaningful bitmap"
3188 " outputs", MirrorSyncMode_str(backup->sync));
3189 return NULL;
3190 }
3191
3192 /* If the bitmap isn't used for input or output, this is useless: */
3193 if (backup->bitmap_mode == BITMAP_SYNC_MODE_NEVER &&
3194 backup->sync != MIRROR_SYNC_MODE_BITMAP) {
3195 error_setg(errp, "Bitmap sync mode '%s' has no meaningful effect"
3196 " when combined with sync mode '%s'",
3197 BitmapSyncMode_str(backup->bitmap_mode),
3198 MirrorSyncMode_str(backup->sync));
3199 return NULL;
3200 }
3201 }
3202
3203 if (!backup->has_bitmap && backup->has_bitmap_mode) {
3204 error_setg(errp, "Cannot specify bitmap sync mode without a bitmap");
3205 return NULL;
3206 }
3207
3208 if (!backup->auto_finalize) {
3209 job_flags |= JOB_MANUAL_FINALIZE;
3210 }
3211 if (!backup->auto_dismiss) {
3212 job_flags |= JOB_MANUAL_DISMISS;
3213 }
3214
3215 job = backup_job_create(backup->job_id, bs, target_bs, backup->speed,
3216 backup->sync, bmap, backup->bitmap_mode,
3217 backup->compress,
3218 backup->filter_node_name,
3219 backup->on_source_error,
3220 backup->on_target_error,
3221 job_flags, NULL, NULL, txn, errp);
3222 return job;
3223 }
3224
3225 void qmp_drive_backup(DriveBackup *backup, Error **errp)
3226 {
3227 TransactionAction action = {
3228 .type = TRANSACTION_ACTION_KIND_DRIVE_BACKUP,
3229 .u.drive_backup.data = backup,
3230 };
3231 blockdev_do_action(&action, errp);
3232 }
3233
3234 BlockDeviceInfoList *qmp_query_named_block_nodes(bool has_flat,
3235 bool flat,
3236 Error **errp)
3237 {
3238 bool return_flat = has_flat && flat;
3239
3240 return bdrv_named_nodes_list(return_flat, errp);
3241 }
3242
3243 XDbgBlockGraph *qmp_x_debug_query_block_graph(Error **errp)
3244 {
3245 return bdrv_get_xdbg_block_graph(errp);
3246 }
3247
3248 void qmp_blockdev_backup(BlockdevBackup *backup, Error **errp)
3249 {
3250 TransactionAction action = {
3251 .type = TRANSACTION_ACTION_KIND_BLOCKDEV_BACKUP,
3252 .u.blockdev_backup.data = backup,
3253 };
3254 blockdev_do_action(&action, errp);
3255 }
3256
3257 /* Parameter check and block job starting for drive mirroring.
3258 * Caller should hold @device and @target's aio context (must be the same).
3259 **/
3260 static void blockdev_mirror_common(const char *job_id, BlockDriverState *bs,
3261 BlockDriverState *target,
3262 bool has_replaces, const char *replaces,
3263 enum MirrorSyncMode sync,
3264 BlockMirrorBackingMode backing_mode,
3265 bool zero_target,
3266 bool has_speed, int64_t speed,
3267 bool has_granularity, uint32_t granularity,
3268 bool has_buf_size, int64_t buf_size,
3269 bool has_on_source_error,
3270 BlockdevOnError on_source_error,
3271 bool has_on_target_error,
3272 BlockdevOnError on_target_error,
3273 bool has_unmap, bool unmap,
3274 bool has_filter_node_name,
3275 const char *filter_node_name,
3276 bool has_copy_mode, MirrorCopyMode copy_mode,
3277 bool has_auto_finalize, bool auto_finalize,
3278 bool has_auto_dismiss, bool auto_dismiss,
3279 Error **errp)
3280 {
3281 int job_flags = JOB_DEFAULT;
3282
3283 if (!has_speed) {
3284 speed = 0;
3285 }
3286 if (!has_on_source_error) {
3287 on_source_error = BLOCKDEV_ON_ERROR_REPORT;
3288 }
3289 if (!has_on_target_error) {
3290 on_target_error = BLOCKDEV_ON_ERROR_REPORT;
3291 }
3292 if (!has_granularity) {
3293 granularity = 0;
3294 }
3295 if (!has_buf_size) {
3296 buf_size = 0;
3297 }
3298 if (!has_unmap) {
3299 unmap = true;
3300 }
3301 if (!has_filter_node_name) {
3302 filter_node_name = NULL;
3303 }
3304 if (!has_copy_mode) {
3305 copy_mode = MIRROR_COPY_MODE_BACKGROUND;
3306 }
3307 if (has_auto_finalize && !auto_finalize) {
3308 job_flags |= JOB_MANUAL_FINALIZE;
3309 }
3310 if (has_auto_dismiss && !auto_dismiss) {
3311 job_flags |= JOB_MANUAL_DISMISS;
3312 }
3313
3314 if (granularity != 0 && (granularity < 512 || granularity > 1048576 * 64)) {
3315 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "granularity",
3316 "a value in range [512B, 64MB]");
3317 return;
3318 }
3319 if (granularity & (granularity - 1)) {
3320 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "granularity",
3321 "power of 2");
3322 return;
3323 }
3324
3325 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_MIRROR_SOURCE, errp)) {
3326 return;
3327 }
3328 if (bdrv_op_is_blocked(target, BLOCK_OP_TYPE_MIRROR_TARGET, errp)) {
3329 return;
3330 }
3331
3332 if (!bs->backing && sync == MIRROR_SYNC_MODE_TOP) {
3333 sync = MIRROR_SYNC_MODE_FULL;
3334 }
3335
3336 if (has_replaces) {
3337 BlockDriverState *to_replace_bs;
3338 AioContext *replace_aio_context;
3339 int64_t bs_size, replace_size;
3340
3341 bs_size = bdrv_getlength(bs);
3342 if (bs_size < 0) {
3343 error_setg_errno(errp, -bs_size, "Failed to query device's size");
3344 return;
3345 }
3346
3347 to_replace_bs = check_to_replace_node(bs, replaces, errp);
3348 if (!to_replace_bs) {
3349 return;
3350 }
3351
3352 replace_aio_context = bdrv_get_aio_context(to_replace_bs);
3353 aio_context_acquire(replace_aio_context);
3354 replace_size = bdrv_getlength(to_replace_bs);
3355 aio_context_release(replace_aio_context);
3356
3357 if (replace_size < 0) {
3358 error_setg_errno(errp, -replace_size,
3359 "Failed to query the replacement node's size");
3360 return;
3361 }
3362 if (bs_size != replace_size) {
3363 error_setg(errp, "cannot replace image with a mirror image of "
3364 "different size");
3365 return;
3366 }
3367 }
3368
3369 /* pass the node name to replace to mirror start since it's loose coupling
3370 * and will allow to check whether the node still exist at mirror completion
3371 */
3372 mirror_start(job_id, bs, target,
3373 has_replaces ? replaces : NULL, job_flags,
3374 speed, granularity, buf_size, sync, backing_mode, zero_target,
3375 on_source_error, on_target_error, unmap, filter_node_name,
3376 copy_mode, errp);
3377 }
3378
3379 void qmp_drive_mirror(DriveMirror *arg, Error **errp)
3380 {
3381 BlockDriverState *bs;
3382 BlockDriverState *source, *target_bs;
3383 AioContext *aio_context;
3384 AioContext *old_context;
3385 BlockMirrorBackingMode backing_mode;
3386 Error *local_err = NULL;
3387 QDict *options = NULL;
3388 int flags;
3389 int64_t size;
3390 const char *format = arg->format;
3391 bool zero_target;
3392 int ret;
3393
3394 bs = qmp_get_root_bs(arg->device, errp);
3395 if (!bs) {
3396 return;
3397 }
3398
3399 /* Early check to avoid creating target */
3400 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_MIRROR_SOURCE, errp)) {
3401 return;
3402 }
3403
3404 aio_context = bdrv_get_aio_context(bs);
3405 aio_context_acquire(aio_context);
3406
3407 if (!arg->has_mode) {
3408 arg->mode = NEW_IMAGE_MODE_ABSOLUTE_PATHS;
3409 }
3410
3411 if (!arg->has_format) {
3412 format = (arg->mode == NEW_IMAGE_MODE_EXISTING
3413 ? NULL : bs->drv->format_name);
3414 }
3415
3416 flags = bs->open_flags | BDRV_O_RDWR;
3417 source = backing_bs(bs);
3418 if (!source && arg->sync == MIRROR_SYNC_MODE_TOP) {
3419 arg->sync = MIRROR_SYNC_MODE_FULL;
3420 }
3421 if (arg->sync == MIRROR_SYNC_MODE_NONE) {
3422 source = bs;
3423 }
3424
3425 size = bdrv_getlength(bs);
3426 if (size < 0) {
3427 error_setg_errno(errp, -size, "bdrv_getlength failed");
3428 goto out;
3429 }
3430
3431 if (arg->has_replaces) {
3432 if (!arg->has_node_name) {
3433 error_setg(errp, "a node-name must be provided when replacing a"
3434 " named node of the graph");
3435 goto out;
3436 }
3437 }
3438
3439 if (arg->mode == NEW_IMAGE_MODE_ABSOLUTE_PATHS) {
3440 backing_mode = MIRROR_SOURCE_BACKING_CHAIN;
3441 } else {
3442 backing_mode = MIRROR_OPEN_BACKING_CHAIN;
3443 }
3444
3445 /* Don't open backing image in create() */
3446 flags |= BDRV_O_NO_BACKING;
3447
3448 if ((arg->sync == MIRROR_SYNC_MODE_FULL || !source)
3449 && arg->mode != NEW_IMAGE_MODE_EXISTING)
3450 {
3451 /* create new image w/o backing file */
3452 assert(format);
3453 bdrv_img_create(arg->target, format,
3454 NULL, NULL, NULL, size, flags, false, &local_err);
3455 } else {
3456 switch (arg->mode) {
3457 case NEW_IMAGE_MODE_EXISTING:
3458 break;
3459 case NEW_IMAGE_MODE_ABSOLUTE_PATHS:
3460 /* create new image with backing file */
3461 bdrv_refresh_filename(source);
3462 bdrv_img_create(arg->target, format,
3463 source->filename,
3464 source->drv->format_name,
3465 NULL, size, flags, false, &local_err);
3466 break;
3467 default:
3468 abort();
3469 }
3470 }
3471
3472 if (local_err) {
3473 error_propagate(errp, local_err);
3474 goto out;
3475 }
3476
3477 options = qdict_new();
3478 if (arg->has_node_name) {
3479 qdict_put_str(options, "node-name", arg->node_name);
3480 }
3481 if (format) {
3482 qdict_put_str(options, "driver", format);
3483 }
3484
3485 /* Mirroring takes care of copy-on-write using the source's backing
3486 * file.
3487 */
3488 target_bs = bdrv_open(arg->target, NULL, options, flags, errp);
3489 if (!target_bs) {
3490 goto out;
3491 }
3492
3493 zero_target = (arg->sync == MIRROR_SYNC_MODE_FULL &&
3494 (arg->mode == NEW_IMAGE_MODE_EXISTING ||
3495 !bdrv_has_zero_init(target_bs)));
3496
3497
3498 /* Honor bdrv_try_set_aio_context() context acquisition requirements. */
3499 old_context = bdrv_get_aio_context(target_bs);
3500 aio_context_release(aio_context);
3501 aio_context_acquire(old_context);
3502
3503 ret = bdrv_try_set_aio_context(target_bs, aio_context, errp);
3504 if (ret < 0) {
3505 bdrv_unref(target_bs);
3506 aio_context_release(old_context);
3507 return;
3508 }
3509
3510 aio_context_release(old_context);
3511 aio_context_acquire(aio_context);
3512
3513 blockdev_mirror_common(arg->has_job_id ? arg->job_id : NULL, bs, target_bs,
3514 arg->has_replaces, arg->replaces, arg->sync,
3515 backing_mode, zero_target,
3516 arg->has_speed, arg->speed,
3517 arg->has_granularity, arg->granularity,
3518 arg->has_buf_size, arg->buf_size,
3519 arg->has_on_source_error, arg->on_source_error,
3520 arg->has_on_target_error, arg->on_target_error,
3521 arg->has_unmap, arg->unmap,
3522 false, NULL,
3523 arg->has_copy_mode, arg->copy_mode,
3524 arg->has_auto_finalize, arg->auto_finalize,
3525 arg->has_auto_dismiss, arg->auto_dismiss,
3526 &local_err);
3527 bdrv_unref(target_bs);
3528 error_propagate(errp, local_err);
3529 out:
3530 aio_context_release(aio_context);
3531 }
3532
3533 void qmp_blockdev_mirror(bool has_job_id, const char *job_id,
3534 const char *device, const char *target,
3535 bool has_replaces, const char *replaces,
3536 MirrorSyncMode sync,
3537 bool has_speed, int64_t speed,
3538 bool has_granularity, uint32_t granularity,
3539 bool has_buf_size, int64_t buf_size,
3540 bool has_on_source_error,
3541 BlockdevOnError on_source_error,
3542 bool has_on_target_error,
3543 BlockdevOnError on_target_error,
3544 bool has_filter_node_name,
3545 const char *filter_node_name,
3546 bool has_copy_mode, MirrorCopyMode copy_mode,
3547 bool has_auto_finalize, bool auto_finalize,
3548 bool has_auto_dismiss, bool auto_dismiss,
3549 Error **errp)
3550 {
3551 BlockDriverState *bs;
3552 BlockDriverState *target_bs;
3553 AioContext *aio_context;
3554 AioContext *old_context;
3555 BlockMirrorBackingMode backing_mode = MIRROR_LEAVE_BACKING_CHAIN;
3556 Error *local_err = NULL;
3557 bool zero_target;
3558 int ret;
3559
3560 bs = qmp_get_root_bs(device, errp);
3561 if (!bs) {
3562 return;
3563 }
3564
3565 target_bs = bdrv_lookup_bs(target, target, errp);
3566 if (!target_bs) {
3567 return;
3568 }
3569
3570 zero_target = (sync == MIRROR_SYNC_MODE_FULL);
3571
3572 /* Honor bdrv_try_set_aio_context() context acquisition requirements. */
3573 old_context = bdrv_get_aio_context(target_bs);
3574 aio_context = bdrv_get_aio_context(bs);
3575 aio_context_acquire(old_context);
3576
3577 ret = bdrv_try_set_aio_context(target_bs, aio_context, errp);
3578
3579 aio_context_release(old_context);
3580 aio_context_acquire(aio_context);
3581
3582 if (ret < 0) {
3583 goto out;
3584 }
3585
3586 blockdev_mirror_common(has_job_id ? job_id : NULL, bs, target_bs,
3587 has_replaces, replaces, sync, backing_mode,
3588 zero_target, has_speed, speed,
3589 has_granularity, granularity,
3590 has_buf_size, buf_size,
3591 has_on_source_error, on_source_error,
3592 has_on_target_error, on_target_error,
3593 true, true,
3594 has_filter_node_name, filter_node_name,
3595 has_copy_mode, copy_mode,
3596 has_auto_finalize, auto_finalize,
3597 has_auto_dismiss, auto_dismiss,
3598 &local_err);
3599 error_propagate(errp, local_err);
3600 out:
3601 aio_context_release(aio_context);
3602 }
3603
3604 /* Get a block job using its ID and acquire its AioContext */
3605 static BlockJob *find_block_job(const char *id, AioContext **aio_context,
3606 Error **errp)
3607 {
3608 BlockJob *job;
3609
3610 assert(id != NULL);
3611
3612 *aio_context = NULL;
3613
3614 job = block_job_get(id);
3615
3616 if (!job) {
3617 error_set(errp, ERROR_CLASS_DEVICE_NOT_ACTIVE,
3618 "Block job '%s' not found", id);
3619 return NULL;
3620 }
3621
3622 *aio_context = blk_get_aio_context(job->blk);
3623 aio_context_acquire(*aio_context);
3624
3625 return job;
3626 }
3627
3628 void qmp_block_job_set_speed(const char *device, int64_t speed, Error **errp)
3629 {
3630 AioContext *aio_context;
3631 BlockJob *job = find_block_job(device, &aio_context, errp);
3632
3633 if (!job) {
3634 return;
3635 }
3636
3637 block_job_set_speed(job, speed, errp);
3638 aio_context_release(aio_context);
3639 }
3640
3641 void qmp_block_job_cancel(const char *device,
3642 bool has_force, bool force, Error **errp)
3643 {
3644 AioContext *aio_context;
3645 BlockJob *job = find_block_job(device, &aio_context, errp);
3646
3647 if (!job) {
3648 return;
3649 }
3650
3651 if (!has_force) {
3652 force = false;
3653 }
3654
3655 if (job_user_paused(&job->job) && !force) {
3656 error_setg(errp, "The block job for device '%s' is currently paused",
3657 device);
3658 goto out;
3659 }
3660
3661 trace_qmp_block_job_cancel(job);
3662 job_user_cancel(&job->job, force, errp);
3663 out:
3664 aio_context_release(aio_context);
3665 }
3666
3667 void qmp_block_job_pause(const char *device, Error **errp)
3668 {
3669 AioContext *aio_context;
3670 BlockJob *job = find_block_job(device, &aio_context, errp);
3671
3672 if (!job) {
3673 return;
3674 }
3675
3676 trace_qmp_block_job_pause(job);
3677 job_user_pause(&job->job, errp);
3678 aio_context_release(aio_context);
3679 }
3680
3681 void qmp_block_job_resume(const char *device, Error **errp)
3682 {
3683 AioContext *aio_context;
3684 BlockJob *job = find_block_job(device, &aio_context, errp);
3685
3686 if (!job) {
3687 return;
3688 }
3689
3690 trace_qmp_block_job_resume(job);
3691 job_user_resume(&job->job, errp);
3692 aio_context_release(aio_context);
3693 }
3694
3695 void qmp_block_job_complete(const char *device, Error **errp)
3696 {
3697 AioContext *aio_context;
3698 BlockJob *job = find_block_job(device, &aio_context, errp);
3699
3700 if (!job) {
3701 return;
3702 }
3703
3704 trace_qmp_block_job_complete(job);
3705 job_complete(&job->job, errp);
3706 aio_context_release(aio_context);
3707 }
3708
3709 void qmp_block_job_finalize(const char *id, Error **errp)
3710 {
3711 AioContext *aio_context;
3712 BlockJob *job = find_block_job(id, &aio_context, errp);
3713
3714 if (!job) {
3715 return;
3716 }
3717
3718 trace_qmp_block_job_finalize(job);
3719 job_finalize(&job->job, errp);
3720 aio_context_release(aio_context);
3721 }
3722
3723 void qmp_block_job_dismiss(const char *id, Error **errp)
3724 {
3725 AioContext *aio_context;
3726 BlockJob *bjob = find_block_job(id, &aio_context, errp);
3727 Job *job;
3728
3729 if (!bjob) {
3730 return;
3731 }
3732
3733 trace_qmp_block_job_dismiss(bjob);
3734 job = &bjob->job;
3735 job_dismiss(&job, errp);
3736 aio_context_release(aio_context);
3737 }
3738
3739 void qmp_change_backing_file(const char *device,
3740 const char *image_node_name,
3741 const char *backing_file,
3742 Error **errp)
3743 {
3744 BlockDriverState *bs = NULL;
3745 AioContext *aio_context;
3746 BlockDriverState *image_bs = NULL;
3747 Error *local_err = NULL;
3748 bool ro;
3749 int ret;
3750
3751 bs = qmp_get_root_bs(device, errp);
3752 if (!bs) {
3753 return;
3754 }
3755
3756 aio_context = bdrv_get_aio_context(bs);
3757 aio_context_acquire(aio_context);
3758
3759 image_bs = bdrv_lookup_bs(NULL, image_node_name, &local_err);
3760 if (local_err) {
3761 error_propagate(errp, local_err);
3762 goto out;
3763 }
3764
3765 if (!image_bs) {
3766 error_setg(errp, "image file not found");
3767 goto out;
3768 }
3769
3770 if (bdrv_find_base(image_bs) == image_bs) {
3771 error_setg(errp, "not allowing backing file change on an image "
3772 "without a backing file");
3773 goto out;
3774 }
3775
3776 /* even though we are not necessarily operating on bs, we need it to
3777 * determine if block ops are currently prohibited on the chain */
3778 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_CHANGE, errp)) {
3779 goto out;
3780 }
3781
3782 /* final sanity check */
3783 if (!bdrv_chain_contains(bs, image_bs)) {
3784 error_setg(errp, "'%s' and image file are not in the same chain",
3785 device);
3786 goto out;
3787 }
3788
3789 /* if not r/w, reopen to make r/w */
3790 ro = bdrv_is_read_only(image_bs);
3791
3792 if (ro) {
3793 if (bdrv_reopen_set_read_only(image_bs, false, errp) != 0) {
3794 goto out;
3795 }
3796 }
3797
3798 ret = bdrv_change_backing_file(image_bs, backing_file,
3799 image_bs->drv ? image_bs->drv->format_name : "");
3800
3801 if (ret < 0) {
3802 error_setg_errno(errp, -ret, "Could not change backing file to '%s'",
3803 backing_file);
3804 /* don't exit here, so we can try to restore open flags if
3805 * appropriate */
3806 }
3807
3808 if (ro) {
3809 bdrv_reopen_set_read_only(image_bs, true, &local_err);
3810 error_propagate(errp, local_err);
3811 }
3812
3813 out:
3814 aio_context_release(aio_context);
3815 }
3816
3817 void hmp_drive_add_node(Monitor *mon, const char *optstr)
3818 {
3819 QemuOpts *opts;
3820 QDict *qdict;
3821 Error *local_err = NULL;
3822
3823 opts = qemu_opts_parse_noisily(&qemu_drive_opts, optstr, false);
3824 if (!opts) {
3825 return;
3826 }
3827
3828 qdict = qemu_opts_to_qdict(opts, NULL);
3829
3830 if (!qdict_get_try_str(qdict, "node-name")) {
3831 qobject_unref(qdict);
3832 error_report("'node-name' needs to be specified");
3833 goto out;
3834 }
3835
3836 BlockDriverState *bs = bds_tree_init(qdict, &local_err);
3837 if (!bs) {
3838 error_report_err(local_err);
3839 goto out;
3840 }
3841
3842 QTAILQ_INSERT_TAIL(&monitor_bdrv_states, bs, monitor_list);
3843
3844 out:
3845 qemu_opts_del(opts);
3846 }
3847
3848 void qmp_blockdev_add(BlockdevOptions *options, Error **errp)
3849 {
3850 BlockDriverState *bs;
3851 QObject *obj;
3852 Visitor *v = qobject_output_visitor_new(&obj);
3853 QDict *qdict;
3854 Error *local_err = NULL;
3855
3856 visit_type_BlockdevOptions(v, NULL, &options, &local_err);
3857 if (local_err) {
3858 error_propagate(errp, local_err);
3859 goto fail;
3860 }
3861
3862 visit_complete(v, &obj);
3863 qdict = qobject_to(QDict, obj);
3864
3865 qdict_flatten(qdict);
3866
3867 if (!qdict_get_try_str(qdict, "node-name")) {
3868 error_setg(errp, "'node-name' must be specified for the root node");
3869 goto fail;
3870 }
3871
3872 bs = bds_tree_init(qdict, errp);
3873 if (!bs) {
3874 goto fail;
3875 }
3876
3877 QTAILQ_INSERT_TAIL(&monitor_bdrv_states, bs, monitor_list);
3878
3879 fail:
3880 visit_free(v);
3881 }
3882
3883 void qmp_x_blockdev_reopen(BlockdevOptions *options, Error **errp)
3884 {
3885 BlockDriverState *bs;
3886 AioContext *ctx;
3887 QObject *obj;
3888 Visitor *v = qobject_output_visitor_new(&obj);
3889 Error *local_err = NULL;
3890 BlockReopenQueue *queue;
3891 QDict *qdict;
3892
3893 /* Check for the selected node name */
3894 if (!options->has_node_name) {
3895 error_setg(errp, "Node name not specified");
3896 goto fail;
3897 }
3898
3899 bs = bdrv_find_node(options->node_name);
3900 if (!bs) {
3901 error_setg(errp, "Cannot find node named '%s'", options->node_name);
3902 goto fail;
3903 }
3904
3905 /* Put all options in a QDict and flatten it */
3906 visit_type_BlockdevOptions(v, NULL, &options, &local_err);
3907 if (local_err) {
3908 error_propagate(errp, local_err);
3909 goto fail;
3910 }
3911
3912 visit_complete(v, &obj);
3913 qdict = qobject_to(QDict, obj);
3914
3915 qdict_flatten(qdict);
3916
3917 /* Perform the reopen operation */
3918 ctx = bdrv_get_aio_context(bs);
3919 aio_context_acquire(ctx);
3920 bdrv_subtree_drained_begin(bs);
3921 queue = bdrv_reopen_queue(NULL, bs, qdict, false);
3922 bdrv_reopen_multiple(queue, errp);
3923 bdrv_subtree_drained_end(bs);
3924 aio_context_release(ctx);
3925
3926 fail:
3927 visit_free(v);
3928 }
3929
3930 void qmp_blockdev_del(const char *node_name, Error **errp)
3931 {
3932 AioContext *aio_context;
3933 BlockDriverState *bs;
3934
3935 bs = bdrv_find_node(node_name);
3936 if (!bs) {
3937 error_setg(errp, "Cannot find node %s", node_name);
3938 return;
3939 }
3940 if (bdrv_has_blk(bs)) {
3941 error_setg(errp, "Node %s is in use", node_name);
3942 return;
3943 }
3944 aio_context = bdrv_get_aio_context(bs);
3945 aio_context_acquire(aio_context);
3946
3947 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_DRIVE_DEL, errp)) {
3948 goto out;
3949 }
3950
3951 if (!QTAILQ_IN_USE(bs, monitor_list)) {
3952 error_setg(errp, "Node %s is not owned by the monitor",
3953 bs->node_name);
3954 goto out;
3955 }
3956
3957 if (bs->refcnt > 1) {
3958 error_setg(errp, "Block device %s is in use",
3959 bdrv_get_device_or_node_name(bs));
3960 goto out;
3961 }
3962
3963 QTAILQ_REMOVE(&monitor_bdrv_states, bs, monitor_list);
3964 bdrv_unref(bs);
3965
3966 out:
3967 aio_context_release(aio_context);
3968 }
3969
3970 static BdrvChild *bdrv_find_child(BlockDriverState *parent_bs,
3971 const char *child_name)
3972 {
3973 BdrvChild *child;
3974
3975 QLIST_FOREACH(child, &parent_bs->children, next) {
3976 if (strcmp(child->name, child_name) == 0) {
3977 return child;
3978 }
3979 }
3980
3981 return NULL;
3982 }
3983
3984 void qmp_x_blockdev_change(const char *parent, bool has_child,
3985 const char *child, bool has_node,
3986 const char *node, Error **errp)
3987 {
3988 BlockDriverState *parent_bs, *new_bs = NULL;
3989 BdrvChild *p_child;
3990
3991 parent_bs = bdrv_lookup_bs(parent, parent, errp);
3992 if (!parent_bs) {
3993 return;
3994 }
3995
3996 if (has_child == has_node) {
3997 if (has_child) {
3998 error_setg(errp, "The parameters child and node are in conflict");
3999 } else {
4000 error_setg(errp, "Either child or node must be specified");
4001 }
4002 return;
4003 }
4004
4005 if (has_child) {
4006 p_child = bdrv_find_child(parent_bs, child);
4007 if (!p_child) {
4008 error_setg(errp, "Node '%s' does not have child '%s'",
4009 parent, child);
4010 return;
4011 }
4012 bdrv_del_child(parent_bs, p_child, errp);
4013 }
4014
4015 if (has_node) {
4016 new_bs = bdrv_find_node(node);
4017 if (!new_bs) {
4018 error_setg(errp, "Node '%s' not found", node);
4019 return;
4020 }
4021 bdrv_add_child(parent_bs, new_bs, errp);
4022 }
4023 }
4024
4025 BlockJobInfoList *qmp_query_block_jobs(Error **errp)
4026 {
4027 BlockJobInfoList *head = NULL, **p_next = &head;
4028 BlockJob *job;
4029
4030 for (job = block_job_next(NULL); job; job = block_job_next(job)) {
4031 BlockJobInfoList *elem;
4032 AioContext *aio_context;
4033
4034 if (block_job_is_internal(job)) {
4035 continue;
4036 }
4037 elem = g_new0(BlockJobInfoList, 1);
4038 aio_context = blk_get_aio_context(job->blk);
4039 aio_context_acquire(aio_context);
4040 elem->value = block_job_query(job, errp);
4041 aio_context_release(aio_context);
4042 if (!elem->value) {
4043 g_free(elem);
4044 qapi_free_BlockJobInfoList(head);
4045 return NULL;
4046 }
4047 *p_next = elem;
4048 p_next = &elem->next;
4049 }
4050
4051 return head;
4052 }
4053
4054 void qmp_x_blockdev_set_iothread(const char *node_name, StrOrNull *iothread,
4055 bool has_force, bool force, Error **errp)
4056 {
4057 AioContext *old_context;
4058 AioContext *new_context;
4059 BlockDriverState *bs;
4060
4061 bs = bdrv_find_node(node_name);
4062 if (!bs) {
4063 error_setg(errp, "Cannot find node %s", node_name);
4064 return;
4065 }
4066
4067 /* Protects against accidents. */
4068 if (!(has_force && force) && bdrv_has_blk(bs)) {
4069 error_setg(errp, "Node %s is associated with a BlockBackend and could "
4070 "be in use (use force=true to override this check)",
4071 node_name);
4072 return;
4073 }
4074
4075 if (iothread->type == QTYPE_QSTRING) {
4076 IOThread *obj = iothread_by_id(iothread->u.s);
4077 if (!obj) {
4078 error_setg(errp, "Cannot find iothread %s", iothread->u.s);
4079 return;
4080 }
4081
4082 new_context = iothread_get_aio_context(obj);
4083 } else {
4084 new_context = qemu_get_aio_context();
4085 }
4086
4087 old_context = bdrv_get_aio_context(bs);
4088 aio_context_acquire(old_context);
4089
4090 bdrv_try_set_aio_context(bs, new_context, errp);
4091
4092 aio_context_release(old_context);
4093 }
4094
4095 QemuOptsList qemu_common_drive_opts = {
4096 .name = "drive",
4097 .head = QTAILQ_HEAD_INITIALIZER(qemu_common_drive_opts.head),
4098 .desc = {
4099 {
4100 .name = "snapshot",
4101 .type = QEMU_OPT_BOOL,
4102 .help = "enable/disable snapshot mode",
4103 },{
4104 .name = "aio",
4105 .type = QEMU_OPT_STRING,
4106 .help = "host AIO implementation (threads, native, io_uring)",
4107 },{
4108 .name = BDRV_OPT_CACHE_WB,
4109 .type = QEMU_OPT_BOOL,
4110 .help = "Enable writeback mode",
4111 },{
4112 .name = "format",
4113 .type = QEMU_OPT_STRING,
4114 .help = "disk format (raw, qcow2, ...)",
4115 },{
4116 .name = "rerror",
4117 .type = QEMU_OPT_STRING,
4118 .help = "read error action",
4119 },{
4120 .name = "werror",
4121 .type = QEMU_OPT_STRING,
4122 .help = "write error action",
4123 },{
4124 .name = BDRV_OPT_READ_ONLY,
4125 .type = QEMU_OPT_BOOL,
4126 .help = "open drive file as read-only",
4127 },
4128
4129 THROTTLE_OPTS,
4130
4131 {
4132 .name = "throttling.group",
4133 .type = QEMU_OPT_STRING,
4134 .help = "name of the block throttling group",
4135 },{
4136 .name = "copy-on-read",
4137 .type = QEMU_OPT_BOOL,
4138 .help = "copy read data from backing file into image file",
4139 },{
4140 .name = "detect-zeroes",
4141 .type = QEMU_OPT_STRING,
4142 .help = "try to optimize zero writes (off, on, unmap)",
4143 },{
4144 .name = "stats-account-invalid",
4145 .type = QEMU_OPT_BOOL,
4146 .help = "whether to account for invalid I/O operations "
4147 "in the statistics",
4148 },{
4149 .name = "stats-account-failed",
4150 .type = QEMU_OPT_BOOL,
4151 .help = "whether to account for failed I/O operations "
4152 "in the statistics",
4153 },
4154 { /* end of list */ }
4155 },
4156 };
4157
4158 QemuOptsList qemu_drive_opts = {
4159 .name = "drive",
4160 .head = QTAILQ_HEAD_INITIALIZER(qemu_drive_opts.head),
4161 .desc = {
4162 /*
4163 * no elements => accept any params
4164 * validation will happen later
4165 */
4166 { /* end of list */ }
4167 },
4168 };
AR7 emulation for QEMU