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