]> git.proxmox.com Git - mirror_qemu.git/blame - blockdev.c
tcg: rework liveness analysis
[mirror_qemu.git] / blockdev.c
CommitLineData
666daa68
MA
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
666daa68 10#include "blockdev.h"
2b584959 11#include "hw/block-common.h"
2f0c9fe6 12#include "blockjob.h"
666daa68
MA
13#include "monitor.h"
14#include "qerror.h"
15#include "qemu-option.h"
16#include "qemu-config.h"
12bd451f 17#include "qemu-objects.h"
666daa68 18#include "sysemu.h"
9063f814 19#include "block_int.h"
a4dea8a9 20#include "qmp-commands.h"
12bd451f 21#include "trace.h"
c9344f22 22#include "arch_init.h"
666daa68 23
c9b62a7e 24static QTAILQ_HEAD(drivelist, DriveInfo) drives = QTAILQ_HEAD_INITIALIZER(drives);
666daa68 25
1960966d
MA
26static const char *const if_name[IF_COUNT] = {
27 [IF_NONE] = "none",
28 [IF_IDE] = "ide",
29 [IF_SCSI] = "scsi",
30 [IF_FLOPPY] = "floppy",
31 [IF_PFLASH] = "pflash",
32 [IF_MTD] = "mtd",
33 [IF_SD] = "sd",
34 [IF_VIRTIO] = "virtio",
35 [IF_XEN] = "xen",
36};
37
38static const int if_max_devs[IF_COUNT] = {
27d6bf40
MA
39 /*
40 * Do not change these numbers! They govern how drive option
41 * index maps to unit and bus. That mapping is ABI.
42 *
43 * All controllers used to imlement if=T drives need to support
44 * if_max_devs[T] units, for any T with if_max_devs[T] != 0.
45 * Otherwise, some index values map to "impossible" bus, unit
46 * values.
47 *
48 * For instance, if you change [IF_SCSI] to 255, -drive
49 * if=scsi,index=12 no longer means bus=1,unit=5, but
50 * bus=0,unit=12. With an lsi53c895a controller (7 units max),
51 * the drive can't be set up. Regression.
52 */
53 [IF_IDE] = 2,
54 [IF_SCSI] = 7,
1960966d
MA
55};
56
14bafc54
MA
57/*
58 * We automatically delete the drive when a device using it gets
59 * unplugged. Questionable feature, but we can't just drop it.
60 * Device models call blockdev_mark_auto_del() to schedule the
61 * automatic deletion, and generic qdev code calls blockdev_auto_del()
62 * when deletion is actually safe.
63 */
64void blockdev_mark_auto_del(BlockDriverState *bs)
65{
66 DriveInfo *dinfo = drive_get_by_blockdev(bs);
67
12bde0ee
PB
68 if (bs->job) {
69 block_job_cancel(bs->job);
70 }
0fc0f1fa
RH
71 if (dinfo) {
72 dinfo->auto_del = 1;
73 }
14bafc54
MA
74}
75
76void blockdev_auto_del(BlockDriverState *bs)
77{
78 DriveInfo *dinfo = drive_get_by_blockdev(bs);
79
0fc0f1fa 80 if (dinfo && dinfo->auto_del) {
84fb3925 81 drive_put_ref(dinfo);
14bafc54
MA
82 }
83}
84
505a7fb1
MA
85static int drive_index_to_bus_id(BlockInterfaceType type, int index)
86{
87 int max_devs = if_max_devs[type];
88 return max_devs ? index / max_devs : 0;
89}
90
91static int drive_index_to_unit_id(BlockInterfaceType type, int index)
92{
93 int max_devs = if_max_devs[type];
94 return max_devs ? index % max_devs : index;
95}
96
2292ddae
MA
97QemuOpts *drive_def(const char *optstr)
98{
99 return qemu_opts_parse(qemu_find_opts("drive"), optstr, 0);
100}
101
102QemuOpts *drive_add(BlockInterfaceType type, int index, const char *file,
5645b0f4 103 const char *optstr)
666daa68 104{
666daa68 105 QemuOpts *opts;
2292ddae 106 char buf[32];
666daa68 107
2292ddae 108 opts = drive_def(optstr);
666daa68
MA
109 if (!opts) {
110 return NULL;
111 }
2292ddae
MA
112 if (type != IF_DEFAULT) {
113 qemu_opt_set(opts, "if", if_name[type]);
114 }
115 if (index >= 0) {
116 snprintf(buf, sizeof(buf), "%d", index);
117 qemu_opt_set(opts, "index", buf);
118 }
666daa68
MA
119 if (file)
120 qemu_opt_set(opts, "file", file);
121 return opts;
122}
123
124DriveInfo *drive_get(BlockInterfaceType type, int bus, int unit)
125{
126 DriveInfo *dinfo;
127
128 /* seek interface, bus and unit */
129
130 QTAILQ_FOREACH(dinfo, &drives, next) {
131 if (dinfo->type == type &&
132 dinfo->bus == bus &&
133 dinfo->unit == unit)
134 return dinfo;
135 }
136
137 return NULL;
138}
139
f1bd51ac
MA
140DriveInfo *drive_get_by_index(BlockInterfaceType type, int index)
141{
142 return drive_get(type,
143 drive_index_to_bus_id(type, index),
144 drive_index_to_unit_id(type, index));
145}
146
666daa68
MA
147int drive_get_max_bus(BlockInterfaceType type)
148{
149 int max_bus;
150 DriveInfo *dinfo;
151
152 max_bus = -1;
153 QTAILQ_FOREACH(dinfo, &drives, next) {
154 if(dinfo->type == type &&
155 dinfo->bus > max_bus)
156 max_bus = dinfo->bus;
157 }
158 return max_bus;
159}
160
13839974
MA
161/* Get a block device. This should only be used for single-drive devices
162 (e.g. SD/Floppy/MTD). Multi-disk devices (scsi/ide) should use the
163 appropriate bus. */
164DriveInfo *drive_get_next(BlockInterfaceType type)
165{
166 static int next_block_unit[IF_COUNT];
167
168 return drive_get(type, 0, next_block_unit[type]++);
169}
170
e4700e59 171DriveInfo *drive_get_by_blockdev(BlockDriverState *bs)
666daa68
MA
172{
173 DriveInfo *dinfo;
174
175 QTAILQ_FOREACH(dinfo, &drives, next) {
e4700e59
MA
176 if (dinfo->bdrv == bs) {
177 return dinfo;
178 }
666daa68 179 }
e4700e59 180 return NULL;
666daa68
MA
181}
182
666daa68
MA
183static void bdrv_format_print(void *opaque, const char *name)
184{
807105a7 185 error_printf(" %s", name);
666daa68
MA
186}
187
84fb3925 188static void drive_uninit(DriveInfo *dinfo)
666daa68
MA
189{
190 qemu_opts_del(dinfo->opts);
191 bdrv_delete(dinfo->bdrv);
7267c094 192 g_free(dinfo->id);
666daa68 193 QTAILQ_REMOVE(&drives, dinfo, next);
7267c094 194 g_free(dinfo);
666daa68
MA
195}
196
84fb3925
MT
197void drive_put_ref(DriveInfo *dinfo)
198{
199 assert(dinfo->refcount);
200 if (--dinfo->refcount == 0) {
201 drive_uninit(dinfo);
202 }
203}
204
205void drive_get_ref(DriveInfo *dinfo)
206{
207 dinfo->refcount++;
208}
209
aa398a5c
SH
210typedef struct {
211 QEMUBH *bh;
212 DriveInfo *dinfo;
213} DrivePutRefBH;
214
215static void drive_put_ref_bh(void *opaque)
216{
217 DrivePutRefBH *s = opaque;
218
219 drive_put_ref(s->dinfo);
220 qemu_bh_delete(s->bh);
221 g_free(s);
222}
223
224/*
225 * Release a drive reference in a BH
226 *
227 * It is not possible to use drive_put_ref() from a callback function when the
228 * callers still need the drive. In such cases we schedule a BH to release the
229 * reference.
230 */
231static void drive_put_ref_bh_schedule(DriveInfo *dinfo)
232{
233 DrivePutRefBH *s;
234
235 s = g_new(DrivePutRefBH, 1);
236 s->bh = qemu_bh_new(drive_put_ref_bh, s);
237 s->dinfo = dinfo;
238 qemu_bh_schedule(s->bh);
239}
240
1ceee0d5 241static int parse_block_error_action(const char *buf, bool is_read)
666daa68
MA
242{
243 if (!strcmp(buf, "ignore")) {
92aa5c6d 244 return BLOCKDEV_ON_ERROR_IGNORE;
666daa68 245 } else if (!is_read && !strcmp(buf, "enospc")) {
92aa5c6d 246 return BLOCKDEV_ON_ERROR_ENOSPC;
666daa68 247 } else if (!strcmp(buf, "stop")) {
92aa5c6d 248 return BLOCKDEV_ON_ERROR_STOP;
666daa68 249 } else if (!strcmp(buf, "report")) {
92aa5c6d 250 return BLOCKDEV_ON_ERROR_REPORT;
666daa68 251 } else {
807105a7
MA
252 error_report("'%s' invalid %s error action",
253 buf, is_read ? "read" : "write");
666daa68
MA
254 return -1;
255 }
256}
257
0563e191
ZYW
258static bool do_check_io_limits(BlockIOLimit *io_limits)
259{
260 bool bps_flag;
261 bool iops_flag;
262
263 assert(io_limits);
264
265 bps_flag = (io_limits->bps[BLOCK_IO_LIMIT_TOTAL] != 0)
266 && ((io_limits->bps[BLOCK_IO_LIMIT_READ] != 0)
267 || (io_limits->bps[BLOCK_IO_LIMIT_WRITE] != 0));
268 iops_flag = (io_limits->iops[BLOCK_IO_LIMIT_TOTAL] != 0)
269 && ((io_limits->iops[BLOCK_IO_LIMIT_READ] != 0)
270 || (io_limits->iops[BLOCK_IO_LIMIT_WRITE] != 0));
271 if (bps_flag || iops_flag) {
272 return false;
273 }
274
275 return true;
276}
277
319ae529 278DriveInfo *drive_init(QemuOpts *opts, int default_to_scsi)
666daa68
MA
279{
280 const char *buf;
281 const char *file = NULL;
666daa68
MA
282 const char *serial;
283 const char *mediastr = "";
284 BlockInterfaceType type;
285 enum { MEDIA_DISK, MEDIA_CDROM } media;
286 int bus_id, unit_id;
287 int cyls, heads, secs, translation;
288 BlockDriver *drv = NULL;
289 int max_devs;
290 int index;
291 int ro = 0;
292 int bdrv_flags = 0;
293 int on_read_error, on_write_error;
294 const char *devaddr;
295 DriveInfo *dinfo;
0563e191 296 BlockIOLimit io_limits;
666daa68 297 int snapshot = 0;
fb0490f6 298 bool copy_on_read;
666daa68
MA
299 int ret;
300
666daa68 301 translation = BIOS_ATA_TRANSLATION_AUTO;
666daa68
MA
302 media = MEDIA_DISK;
303
304 /* extract parameters */
305 bus_id = qemu_opt_get_number(opts, "bus", 0);
306 unit_id = qemu_opt_get_number(opts, "unit", -1);
307 index = qemu_opt_get_number(opts, "index", -1);
308
309 cyls = qemu_opt_get_number(opts, "cyls", 0);
310 heads = qemu_opt_get_number(opts, "heads", 0);
311 secs = qemu_opt_get_number(opts, "secs", 0);
312
313 snapshot = qemu_opt_get_bool(opts, "snapshot", 0);
314 ro = qemu_opt_get_bool(opts, "readonly", 0);
fb0490f6 315 copy_on_read = qemu_opt_get_bool(opts, "copy-on-read", false);
666daa68
MA
316
317 file = qemu_opt_get(opts, "file");
318 serial = qemu_opt_get(opts, "serial");
319
320 if ((buf = qemu_opt_get(opts, "if")) != NULL) {
1960966d
MA
321 for (type = 0; type < IF_COUNT && strcmp(buf, if_name[type]); type++)
322 ;
323 if (type == IF_COUNT) {
807105a7 324 error_report("unsupported bus type '%s'", buf);
666daa68
MA
325 return NULL;
326 }
2d3999fe
LC
327 } else {
328 type = default_to_scsi ? IF_SCSI : IF_IDE;
666daa68 329 }
2d3999fe 330
1960966d 331 max_devs = if_max_devs[type];
666daa68
MA
332
333 if (cyls || heads || secs) {
aaea3f36 334 if (cyls < 1) {
807105a7 335 error_report("invalid physical cyls number");
666daa68
MA
336 return NULL;
337 }
aaea3f36 338 if (heads < 1) {
807105a7 339 error_report("invalid physical heads number");
666daa68
MA
340 return NULL;
341 }
aaea3f36 342 if (secs < 1) {
807105a7 343 error_report("invalid physical secs number");
666daa68
MA
344 return NULL;
345 }
346 }
347
348 if ((buf = qemu_opt_get(opts, "trans")) != NULL) {
349 if (!cyls) {
e4080f9b 350 error_report("'%s' trans must be used with cyls, heads and secs",
807105a7 351 buf);
666daa68
MA
352 return NULL;
353 }
354 if (!strcmp(buf, "none"))
355 translation = BIOS_ATA_TRANSLATION_NONE;
356 else if (!strcmp(buf, "lba"))
357 translation = BIOS_ATA_TRANSLATION_LBA;
358 else if (!strcmp(buf, "auto"))
359 translation = BIOS_ATA_TRANSLATION_AUTO;
360 else {
807105a7 361 error_report("'%s' invalid translation type", buf);
666daa68
MA
362 return NULL;
363 }
364 }
365
366 if ((buf = qemu_opt_get(opts, "media")) != NULL) {
367 if (!strcmp(buf, "disk")) {
368 media = MEDIA_DISK;
369 } else if (!strcmp(buf, "cdrom")) {
370 if (cyls || secs || heads) {
e7ff8f0e 371 error_report("CHS can't be set with media=%s", buf);
666daa68
MA
372 return NULL;
373 }
374 media = MEDIA_CDROM;
375 } else {
807105a7 376 error_report("'%s' invalid media", buf);
666daa68
MA
377 return NULL;
378 }
379 }
380
1f212b9d 381 bdrv_flags |= BDRV_O_CACHE_WB;
666daa68 382 if ((buf = qemu_opt_get(opts, "cache")) != NULL) {
c3993cdc
SH
383 if (bdrv_parse_cache_flags(buf, &bdrv_flags) != 0) {
384 error_report("invalid cache option");
385 return NULL;
666daa68
MA
386 }
387 }
388
389#ifdef CONFIG_LINUX_AIO
390 if ((buf = qemu_opt_get(opts, "aio")) != NULL) {
391 if (!strcmp(buf, "native")) {
392 bdrv_flags |= BDRV_O_NATIVE_AIO;
393 } else if (!strcmp(buf, "threads")) {
394 /* this is the default */
395 } else {
807105a7 396 error_report("invalid aio option");
666daa68
MA
397 return NULL;
398 }
399 }
400#endif
401
402 if ((buf = qemu_opt_get(opts, "format")) != NULL) {
c8057f95
PM
403 if (is_help_option(buf)) {
404 error_printf("Supported formats:");
405 bdrv_iterate_format(bdrv_format_print, NULL);
406 error_printf("\n");
407 return NULL;
666daa68
MA
408 }
409 drv = bdrv_find_whitelisted_format(buf);
410 if (!drv) {
807105a7 411 error_report("'%s' invalid format", buf);
666daa68
MA
412 return NULL;
413 }
414 }
415
0563e191
ZYW
416 /* disk I/O throttling */
417 io_limits.bps[BLOCK_IO_LIMIT_TOTAL] =
418 qemu_opt_get_number(opts, "bps", 0);
419 io_limits.bps[BLOCK_IO_LIMIT_READ] =
420 qemu_opt_get_number(opts, "bps_rd", 0);
421 io_limits.bps[BLOCK_IO_LIMIT_WRITE] =
422 qemu_opt_get_number(opts, "bps_wr", 0);
423 io_limits.iops[BLOCK_IO_LIMIT_TOTAL] =
424 qemu_opt_get_number(opts, "iops", 0);
425 io_limits.iops[BLOCK_IO_LIMIT_READ] =
426 qemu_opt_get_number(opts, "iops_rd", 0);
427 io_limits.iops[BLOCK_IO_LIMIT_WRITE] =
428 qemu_opt_get_number(opts, "iops_wr", 0);
429
430 if (!do_check_io_limits(&io_limits)) {
431 error_report("bps(iops) and bps_rd/bps_wr(iops_rd/iops_wr) "
432 "cannot be used at the same time");
433 return NULL;
434 }
435
92aa5c6d 436 on_write_error = BLOCKDEV_ON_ERROR_ENOSPC;
666daa68
MA
437 if ((buf = qemu_opt_get(opts, "werror")) != NULL) {
438 if (type != IF_IDE && type != IF_SCSI && type != IF_VIRTIO && type != IF_NONE) {
807105a7 439 error_report("werror is not supported by this bus type");
666daa68
MA
440 return NULL;
441 }
442
443 on_write_error = parse_block_error_action(buf, 0);
444 if (on_write_error < 0) {
445 return NULL;
446 }
447 }
448
92aa5c6d 449 on_read_error = BLOCKDEV_ON_ERROR_REPORT;
666daa68 450 if ((buf = qemu_opt_get(opts, "rerror")) != NULL) {
5dba48a8 451 if (type != IF_IDE && type != IF_VIRTIO && type != IF_SCSI && type != IF_NONE) {
807105a7 452 error_report("rerror is not supported by this bus type");
666daa68
MA
453 return NULL;
454 }
455
456 on_read_error = parse_block_error_action(buf, 1);
457 if (on_read_error < 0) {
458 return NULL;
459 }
460 }
461
462 if ((devaddr = qemu_opt_get(opts, "addr")) != NULL) {
463 if (type != IF_VIRTIO) {
807105a7 464 error_report("addr is not supported by this bus type");
666daa68
MA
465 return NULL;
466 }
467 }
468
469 /* compute bus and unit according index */
470
471 if (index != -1) {
472 if (bus_id != 0 || unit_id != -1) {
807105a7 473 error_report("index cannot be used with bus and unit");
666daa68
MA
474 return NULL;
475 }
505a7fb1
MA
476 bus_id = drive_index_to_bus_id(type, index);
477 unit_id = drive_index_to_unit_id(type, index);
666daa68
MA
478 }
479
480 /* if user doesn't specify a unit_id,
481 * try to find the first free
482 */
483
484 if (unit_id == -1) {
485 unit_id = 0;
486 while (drive_get(type, bus_id, unit_id) != NULL) {
487 unit_id++;
488 if (max_devs && unit_id >= max_devs) {
489 unit_id -= max_devs;
490 bus_id++;
491 }
492 }
493 }
494
495 /* check unit id */
496
497 if (max_devs && unit_id >= max_devs) {
807105a7
MA
498 error_report("unit %d too big (max is %d)",
499 unit_id, max_devs - 1);
666daa68
MA
500 return NULL;
501 }
502
503 /*
4e5d9b57 504 * catch multiple definitions
666daa68
MA
505 */
506
507 if (drive_get(type, bus_id, unit_id) != NULL) {
4e5d9b57
MA
508 error_report("drive with bus=%d, unit=%d (index=%d) exists",
509 bus_id, unit_id, index);
666daa68
MA
510 return NULL;
511 }
512
513 /* init */
514
7267c094 515 dinfo = g_malloc0(sizeof(*dinfo));
666daa68 516 if ((buf = qemu_opts_id(opts)) != NULL) {
7267c094 517 dinfo->id = g_strdup(buf);
666daa68
MA
518 } else {
519 /* no id supplied -> create one */
7267c094 520 dinfo->id = g_malloc0(32);
666daa68
MA
521 if (type == IF_IDE || type == IF_SCSI)
522 mediastr = (media == MEDIA_CDROM) ? "-cd" : "-hd";
523 if (max_devs)
524 snprintf(dinfo->id, 32, "%s%i%s%i",
79d21d5b 525 if_name[type], bus_id, mediastr, unit_id);
666daa68
MA
526 else
527 snprintf(dinfo->id, 32, "%s%s%i",
79d21d5b 528 if_name[type], mediastr, unit_id);
666daa68
MA
529 }
530 dinfo->bdrv = bdrv_new(dinfo->id);
80dd1aae
KS
531 dinfo->bdrv->open_flags = snapshot ? BDRV_O_SNAPSHOT : 0;
532 dinfo->bdrv->read_only = ro;
666daa68
MA
533 dinfo->devaddr = devaddr;
534 dinfo->type = type;
535 dinfo->bus = bus_id;
536 dinfo->unit = unit_id;
317bb412
MA
537 dinfo->cyls = cyls;
538 dinfo->heads = heads;
539 dinfo->secs = secs;
540 dinfo->trans = translation;
666daa68 541 dinfo->opts = opts;
84fb3925 542 dinfo->refcount = 1;
577d0a38 543 dinfo->serial = serial;
666daa68
MA
544 QTAILQ_INSERT_TAIL(&drives, dinfo, next);
545
abd7f68d
MA
546 bdrv_set_on_error(dinfo->bdrv, on_read_error, on_write_error);
547
0563e191
ZYW
548 /* disk I/O throttling */
549 bdrv_set_io_limits(dinfo->bdrv, &io_limits);
550
666daa68
MA
551 switch(type) {
552 case IF_IDE:
553 case IF_SCSI:
554 case IF_XEN:
555 case IF_NONE:
2b584959 556 dinfo->media_cd = media == MEDIA_CDROM;
666daa68
MA
557 break;
558 case IF_SD:
666daa68 559 case IF_FLOPPY:
666daa68
MA
560 case IF_PFLASH:
561 case IF_MTD:
562 break;
563 case IF_VIRTIO:
564 /* add virtio block device */
8be7e7e4 565 opts = qemu_opts_create(qemu_find_opts("device"), NULL, 0, NULL);
eeb9c1b5
AL
566 if (arch_type == QEMU_ARCH_S390X) {
567 qemu_opt_set(opts, "driver", "virtio-blk-s390");
568 } else {
569 qemu_opt_set(opts, "driver", "virtio-blk-pci");
570 }
666daa68
MA
571 qemu_opt_set(opts, "drive", dinfo->id);
572 if (devaddr)
573 qemu_opt_set(opts, "addr", devaddr);
574 break;
2292ddae 575 default:
666daa68
MA
576 abort();
577 }
dd5b0d71 578 if (!file || !*file) {
319ae529 579 return dinfo;
666daa68
MA
580 }
581 if (snapshot) {
582 /* always use cache=unsafe with snapshot */
583 bdrv_flags &= ~BDRV_O_CACHE_MASK;
584 bdrv_flags |= (BDRV_O_SNAPSHOT|BDRV_O_CACHE_WB|BDRV_O_NO_FLUSH);
585 }
586
fb0490f6
SH
587 if (copy_on_read) {
588 bdrv_flags |= BDRV_O_COPY_ON_READ;
589 }
590
ed9d4205
BC
591 if (runstate_check(RUN_STATE_INMIGRATE)) {
592 bdrv_flags |= BDRV_O_INCOMING;
593 }
594
666daa68
MA
595 if (media == MEDIA_CDROM) {
596 /* CDROM is fine for any interface, don't check. */
597 ro = 1;
598 } else if (ro == 1) {
1e9eb78a
JJ
599 if (type != IF_SCSI && type != IF_VIRTIO && type != IF_FLOPPY &&
600 type != IF_NONE && type != IF_PFLASH) {
807105a7 601 error_report("readonly not supported by this bus type");
a9ae2bff 602 goto err;
666daa68
MA
603 }
604 }
605
606 bdrv_flags |= ro ? 0 : BDRV_O_RDWR;
607
04d4abe9
SH
608 if (ro && copy_on_read) {
609 error_report("warning: disabling copy_on_read on readonly drive");
610 }
611
666daa68
MA
612 ret = bdrv_open(dinfo->bdrv, file, bdrv_flags, drv);
613 if (ret < 0) {
807105a7
MA
614 error_report("could not open disk image %s: %s",
615 file, strerror(-ret));
a9ae2bff 616 goto err;
666daa68
MA
617 }
618
619 if (bdrv_key_required(dinfo->bdrv))
620 autostart = 0;
666daa68 621 return dinfo;
a9ae2bff
MA
622
623err:
624 bdrv_delete(dinfo->bdrv);
7267c094 625 g_free(dinfo->id);
a9ae2bff 626 QTAILQ_REMOVE(&drives, dinfo, next);
7267c094 627 g_free(dinfo);
a9ae2bff 628 return NULL;
666daa68
MA
629}
630
631void do_commit(Monitor *mon, const QDict *qdict)
632{
666daa68 633 const char *device = qdict_get_str(qdict, "device");
6ab4b5ab 634 BlockDriverState *bs;
e8877497 635 int ret;
666daa68 636
6ab4b5ab 637 if (!strcmp(device, "all")) {
e8877497
SH
638 ret = bdrv_commit_all();
639 if (ret == -EBUSY) {
640 qerror_report(QERR_DEVICE_IN_USE, device);
641 return;
642 }
6ab4b5ab
MA
643 } else {
644 bs = bdrv_find(device);
ac59eb95
MA
645 if (!bs) {
646 qerror_report(QERR_DEVICE_NOT_FOUND, device);
647 return;
6ab4b5ab 648 }
2d3735d3
SH
649 ret = bdrv_commit(bs);
650 if (ret == -EBUSY) {
651 qerror_report(QERR_DEVICE_IN_USE, device);
652 return;
653 }
666daa68
MA
654 }
655}
656
6cc2a415
PB
657static void blockdev_do_action(int kind, void *data, Error **errp)
658{
659 BlockdevAction action;
660 BlockdevActionList list;
661
662 action.kind = kind;
663 action.data = data;
664 list.value = &action;
665 list.next = NULL;
666 qmp_transaction(&list, errp);
667}
668
6106e249
LC
669void qmp_blockdev_snapshot_sync(const char *device, const char *snapshot_file,
670 bool has_format, const char *format,
6cc2a415 671 bool has_mode, enum NewImageMode mode,
6106e249 672 Error **errp)
f8882568 673{
6cc2a415
PB
674 BlockdevSnapshot snapshot = {
675 .device = (char *) device,
676 .snapshot_file = (char *) snapshot_file,
677 .has_format = has_format,
678 .format = (char *) format,
679 .has_mode = has_mode,
680 .mode = mode,
681 };
682 blockdev_do_action(BLOCKDEV_ACTION_KIND_BLOCKDEV_SNAPSHOT_SYNC, &snapshot,
683 errp);
f8882568
JS
684}
685
8802d1fd
JC
686
687/* New and old BlockDriverState structs for group snapshots */
52e7c241 688typedef struct BlkTransactionStates {
8802d1fd
JC
689 BlockDriverState *old_bs;
690 BlockDriverState *new_bs;
52e7c241
PB
691 QSIMPLEQ_ENTRY(BlkTransactionStates) entry;
692} BlkTransactionStates;
8802d1fd
JC
693
694/*
695 * 'Atomic' group snapshots. The snapshots are taken as a set, and if any fail
696 * then we do not pivot any of the devices in the group, and abandon the
697 * snapshots
698 */
52e7c241 699void qmp_transaction(BlockdevActionList *dev_list, Error **errp)
8802d1fd
JC
700{
701 int ret = 0;
52e7c241
PB
702 BlockdevActionList *dev_entry = dev_list;
703 BlkTransactionStates *states, *next;
8802d1fd 704
52e7c241 705 QSIMPLEQ_HEAD(snap_bdrv_states, BlkTransactionStates) snap_bdrv_states;
8802d1fd
JC
706 QSIMPLEQ_INIT(&snap_bdrv_states);
707
708 /* drain all i/o before any snapshots */
709 bdrv_drain_all();
710
711 /* We don't do anything in this loop that commits us to the snapshot */
712 while (NULL != dev_entry) {
52e7c241
PB
713 BlockdevAction *dev_info = NULL;
714 BlockDriver *proto_drv;
715 BlockDriver *drv;
716 int flags;
bc8b094f
PB
717 enum NewImageMode mode;
718 const char *new_image_file;
52e7c241
PB
719 const char *device;
720 const char *format = "qcow2";
52e7c241 721
8802d1fd
JC
722 dev_info = dev_entry->value;
723 dev_entry = dev_entry->next;
724
52e7c241 725 states = g_malloc0(sizeof(BlkTransactionStates));
8802d1fd
JC
726 QSIMPLEQ_INSERT_TAIL(&snap_bdrv_states, states, entry);
727
52e7c241
PB
728 switch (dev_info->kind) {
729 case BLOCKDEV_ACTION_KIND_BLOCKDEV_SNAPSHOT_SYNC:
730 device = dev_info->blockdev_snapshot_sync->device;
bc8b094f
PB
731 if (!dev_info->blockdev_snapshot_sync->has_mode) {
732 dev_info->blockdev_snapshot_sync->mode = NEW_IMAGE_MODE_ABSOLUTE_PATHS;
733 }
734 new_image_file = dev_info->blockdev_snapshot_sync->snapshot_file;
52e7c241
PB
735 if (dev_info->blockdev_snapshot_sync->has_format) {
736 format = dev_info->blockdev_snapshot_sync->format;
737 }
bc8b094f 738 mode = dev_info->blockdev_snapshot_sync->mode;
52e7c241
PB
739 break;
740 default:
741 abort();
742 }
8802d1fd 743
52e7c241
PB
744 drv = bdrv_find_format(format);
745 if (!drv) {
746 error_set(errp, QERR_INVALID_BLOCK_FORMAT, format);
747 goto delete_and_fail;
748 }
749
750 states->old_bs = bdrv_find(device);
8802d1fd 751 if (!states->old_bs) {
52e7c241 752 error_set(errp, QERR_DEVICE_NOT_FOUND, device);
8802d1fd
JC
753 goto delete_and_fail;
754 }
755
e86fe18a
PB
756 if (!bdrv_is_inserted(states->old_bs)) {
757 error_set(errp, QERR_DEVICE_HAS_NO_MEDIUM, device);
758 goto delete_and_fail;
759 }
760
8802d1fd 761 if (bdrv_in_use(states->old_bs)) {
52e7c241 762 error_set(errp, QERR_DEVICE_IN_USE, device);
8802d1fd
JC
763 goto delete_and_fail;
764 }
765
e86fe18a 766 if (!bdrv_is_read_only(states->old_bs)) {
8802d1fd
JC
767 if (bdrv_flush(states->old_bs)) {
768 error_set(errp, QERR_IO_ERROR);
769 goto delete_and_fail;
770 }
771 }
772
8802d1fd
JC
773 flags = states->old_bs->open_flags;
774
52e7c241 775 proto_drv = bdrv_find_protocol(new_image_file);
8802d1fd
JC
776 if (!proto_drv) {
777 error_set(errp, QERR_INVALID_BLOCK_FORMAT, format);
778 goto delete_and_fail;
779 }
780
781 /* create new image w/backing file */
bc8b094f
PB
782 if (mode != NEW_IMAGE_MODE_EXISTING) {
783 ret = bdrv_img_create(new_image_file, format,
784 states->old_bs->filename,
785 states->old_bs->drv->format_name,
786 NULL, -1, flags);
787 if (ret) {
788 error_set(errp, QERR_OPEN_FILE_FAILED, new_image_file);
789 goto delete_and_fail;
790 }
8802d1fd
JC
791 }
792
793 /* We will manually add the backing_hd field to the bs later */
794 states->new_bs = bdrv_new("");
52e7c241 795 ret = bdrv_open(states->new_bs, new_image_file,
8802d1fd
JC
796 flags | BDRV_O_NO_BACKING, drv);
797 if (ret != 0) {
52e7c241 798 error_set(errp, QERR_OPEN_FILE_FAILED, new_image_file);
8802d1fd
JC
799 goto delete_and_fail;
800 }
801 }
802
803
804 /* Now we are going to do the actual pivot. Everything up to this point
805 * is reversible, but we are committed at this point */
806 QSIMPLEQ_FOREACH(states, &snap_bdrv_states, entry) {
807 /* This removes our old bs from the bdrv_states, and adds the new bs */
808 bdrv_append(states->new_bs, states->old_bs);
870f5681
JC
809 /* We don't need (or want) to use the transactional
810 * bdrv_reopen_multiple() across all the entries at once, because we
811 * don't want to abort all of them if one of them fails the reopen */
812 bdrv_reopen(states->new_bs, states->new_bs->open_flags & ~BDRV_O_RDWR,
813 NULL);
8802d1fd
JC
814 }
815
816 /* success */
817 goto exit;
818
819delete_and_fail:
820 /*
821 * failure, and it is all-or-none; abandon each new bs, and keep using
822 * the original bs for all images
823 */
824 QSIMPLEQ_FOREACH(states, &snap_bdrv_states, entry) {
825 if (states->new_bs) {
826 bdrv_delete(states->new_bs);
827 }
828 }
829exit:
622d2419 830 QSIMPLEQ_FOREACH_SAFE(states, &snap_bdrv_states, entry, next) {
8802d1fd
JC
831 g_free(states);
832 }
8802d1fd
JC
833}
834
835
92d48558 836static void eject_device(BlockDriverState *bs, int force, Error **errp)
666daa68 837{
2d3735d3
SH
838 if (bdrv_in_use(bs)) {
839 error_set(errp, QERR_DEVICE_IN_USE, bdrv_get_device_name(bs));
840 return;
841 }
2c6942fa 842 if (!bdrv_dev_has_removable_media(bs)) {
92d48558
LC
843 error_set(errp, QERR_DEVICE_NOT_REMOVABLE, bdrv_get_device_name(bs));
844 return;
ea8f942f 845 }
92d48558 846
025ccaa7
PB
847 if (bdrv_dev_is_medium_locked(bs) && !bdrv_dev_is_tray_open(bs)) {
848 bdrv_dev_eject_request(bs, force);
849 if (!force) {
92d48558
LC
850 error_set(errp, QERR_DEVICE_LOCKED, bdrv_get_device_name(bs));
851 return;
025ccaa7 852 }
666daa68 853 }
92d48558 854
3b5276b5 855 bdrv_close(bs);
666daa68
MA
856}
857
c245b6a3 858void qmp_eject(const char *device, bool has_force, bool force, Error **errp)
666daa68
MA
859{
860 BlockDriverState *bs;
666daa68 861
c245b6a3 862 bs = bdrv_find(device);
666daa68 863 if (!bs) {
c245b6a3
LC
864 error_set(errp, QERR_DEVICE_NOT_FOUND, device);
865 return;
92d48558
LC
866 }
867
c245b6a3 868 eject_device(bs, force, errp);
666daa68
MA
869}
870
a4dea8a9 871void qmp_block_passwd(const char *device, const char *password, Error **errp)
666daa68
MA
872{
873 BlockDriverState *bs;
874 int err;
875
a4dea8a9 876 bs = bdrv_find(device);
666daa68 877 if (!bs) {
a4dea8a9
LC
878 error_set(errp, QERR_DEVICE_NOT_FOUND, device);
879 return;
666daa68
MA
880 }
881
a4dea8a9 882 err = bdrv_set_key(bs, password);
666daa68 883 if (err == -EINVAL) {
a4dea8a9
LC
884 error_set(errp, QERR_DEVICE_NOT_ENCRYPTED, bdrv_get_device_name(bs));
885 return;
666daa68 886 } else if (err < 0) {
a4dea8a9
LC
887 error_set(errp, QERR_INVALID_PASSWORD);
888 return;
666daa68 889 }
666daa68
MA
890}
891
333a96ec
LC
892static void qmp_bdrv_open_encrypted(BlockDriverState *bs, const char *filename,
893 int bdrv_flags, BlockDriver *drv,
894 const char *password, Error **errp)
895{
896 if (bdrv_open(bs, filename, bdrv_flags, drv) < 0) {
897 error_set(errp, QERR_OPEN_FILE_FAILED, filename);
898 return;
899 }
900
901 if (bdrv_key_required(bs)) {
902 if (password) {
903 if (bdrv_set_key(bs, password) < 0) {
904 error_set(errp, QERR_INVALID_PASSWORD);
905 }
906 } else {
907 error_set(errp, QERR_DEVICE_ENCRYPTED, bdrv_get_device_name(bs),
908 bdrv_get_encrypted_filename(bs));
909 }
910 } else if (password) {
911 error_set(errp, QERR_DEVICE_NOT_ENCRYPTED, bdrv_get_device_name(bs));
912 }
913}
914
915void qmp_change_blockdev(const char *device, const char *filename,
916 bool has_format, const char *format, Error **errp)
666daa68
MA
917{
918 BlockDriverState *bs;
919 BlockDriver *drv = NULL;
920 int bdrv_flags;
92d48558 921 Error *err = NULL;
666daa68
MA
922
923 bs = bdrv_find(device);
924 if (!bs) {
333a96ec
LC
925 error_set(errp, QERR_DEVICE_NOT_FOUND, device);
926 return;
666daa68 927 }
333a96ec
LC
928
929 if (format) {
930 drv = bdrv_find_whitelisted_format(format);
666daa68 931 if (!drv) {
333a96ec
LC
932 error_set(errp, QERR_INVALID_BLOCK_FORMAT, format);
933 return;
666daa68
MA
934 }
935 }
333a96ec 936
92d48558
LC
937 eject_device(bs, 0, &err);
938 if (error_is_set(&err)) {
333a96ec
LC
939 error_propagate(errp, err);
940 return;
666daa68 941 }
333a96ec 942
528f7663 943 bdrv_flags = bdrv_is_read_only(bs) ? 0 : BDRV_O_RDWR;
199630b6 944 bdrv_flags |= bdrv_is_snapshot(bs) ? BDRV_O_SNAPSHOT : 0;
333a96ec
LC
945
946 qmp_bdrv_open_encrypted(bs, filename, bdrv_flags, drv, NULL, errp);
666daa68 947}
9063f814 948
727f005e 949/* throttling disk I/O limits */
80047da5
LC
950void qmp_block_set_io_throttle(const char *device, int64_t bps, int64_t bps_rd,
951 int64_t bps_wr, int64_t iops, int64_t iops_rd,
952 int64_t iops_wr, Error **errp)
727f005e
ZYW
953{
954 BlockIOLimit io_limits;
727f005e
ZYW
955 BlockDriverState *bs;
956
80047da5 957 bs = bdrv_find(device);
727f005e 958 if (!bs) {
80047da5
LC
959 error_set(errp, QERR_DEVICE_NOT_FOUND, device);
960 return;
727f005e
ZYW
961 }
962
80047da5
LC
963 io_limits.bps[BLOCK_IO_LIMIT_TOTAL] = bps;
964 io_limits.bps[BLOCK_IO_LIMIT_READ] = bps_rd;
965 io_limits.bps[BLOCK_IO_LIMIT_WRITE] = bps_wr;
966 io_limits.iops[BLOCK_IO_LIMIT_TOTAL]= iops;
967 io_limits.iops[BLOCK_IO_LIMIT_READ] = iops_rd;
968 io_limits.iops[BLOCK_IO_LIMIT_WRITE]= iops_wr;
727f005e
ZYW
969
970 if (!do_check_io_limits(&io_limits)) {
80047da5
LC
971 error_set(errp, QERR_INVALID_PARAMETER_COMBINATION);
972 return;
727f005e
ZYW
973 }
974
975 bs->io_limits = io_limits;
976 bs->slice_time = BLOCK_IO_SLICE_TIME;
977
978 if (!bs->io_limits_enabled && bdrv_io_limits_enabled(bs)) {
979 bdrv_io_limits_enable(bs);
980 } else if (bs->io_limits_enabled && !bdrv_io_limits_enabled(bs)) {
981 bdrv_io_limits_disable(bs);
982 } else {
983 if (bs->block_timer) {
984 qemu_mod_timer(bs->block_timer, qemu_get_clock_ns(vm_clock));
985 }
986 }
727f005e
ZYW
987}
988
9063f814
RH
989int do_drive_del(Monitor *mon, const QDict *qdict, QObject **ret_data)
990{
991 const char *id = qdict_get_str(qdict, "id");
992 BlockDriverState *bs;
9063f814
RH
993
994 bs = bdrv_find(id);
995 if (!bs) {
996 qerror_report(QERR_DEVICE_NOT_FOUND, id);
997 return -1;
998 }
8591675f
MT
999 if (bdrv_in_use(bs)) {
1000 qerror_report(QERR_DEVICE_IN_USE, id);
1001 return -1;
1002 }
9063f814
RH
1003
1004 /* quiesce block driver; prevent further io */
922453bc 1005 bdrv_drain_all();
9063f814
RH
1006 bdrv_flush(bs);
1007 bdrv_close(bs);
1008
fa879d62 1009 /* if we have a device attached to this BlockDriverState
d22b2f41
RH
1010 * then we need to make the drive anonymous until the device
1011 * can be removed. If this is a drive with no device backing
1012 * then we can just get rid of the block driver state right here.
1013 */
fa879d62 1014 if (bdrv_get_attached_dev(bs)) {
d22b2f41
RH
1015 bdrv_make_anon(bs);
1016 } else {
1017 drive_uninit(drive_get_by_blockdev(bs));
9063f814
RH
1018 }
1019
9063f814
RH
1020 return 0;
1021}
6d4a2b3a 1022
5e7caacb 1023void qmp_block_resize(const char *device, int64_t size, Error **errp)
6d4a2b3a 1024{
6d4a2b3a
CH
1025 BlockDriverState *bs;
1026
1027 bs = bdrv_find(device);
1028 if (!bs) {
5e7caacb
LC
1029 error_set(errp, QERR_DEVICE_NOT_FOUND, device);
1030 return;
6d4a2b3a
CH
1031 }
1032
1033 if (size < 0) {
939a1cc3 1034 error_set(errp, QERR_INVALID_PARAMETER_VALUE, "size", "a >0 size");
5e7caacb 1035 return;
6d4a2b3a
CH
1036 }
1037
939a1cc3
SH
1038 switch (bdrv_truncate(bs, size)) {
1039 case 0:
1040 break;
1041 case -ENOMEDIUM:
1042 error_set(errp, QERR_DEVICE_HAS_NO_MEDIUM, device);
1043 break;
1044 case -ENOTSUP:
1045 error_set(errp, QERR_UNSUPPORTED);
1046 break;
1047 case -EACCES:
1048 error_set(errp, QERR_DEVICE_IS_READ_ONLY, device);
1049 break;
1050 case -EBUSY:
1051 error_set(errp, QERR_DEVICE_IN_USE, device);
1052 break;
1053 default:
5e7caacb 1054 error_set(errp, QERR_UNDEFINED_ERROR);
939a1cc3 1055 break;
6d4a2b3a 1056 }
6d4a2b3a 1057}
12bd451f
SH
1058
1059static QObject *qobject_from_block_job(BlockJob *job)
1060{
1061 return qobject_from_jsonf("{ 'type': %s,"
1062 "'device': %s,"
1063 "'len': %" PRId64 ","
1064 "'offset': %" PRId64 ","
1065 "'speed': %" PRId64 " }",
1066 job->job_type->job_type,
1067 bdrv_get_device_name(job->bs),
1068 job->len,
1069 job->offset,
1070 job->speed);
1071}
1072
9abf2dba 1073static void block_job_cb(void *opaque, int ret)
12bd451f
SH
1074{
1075 BlockDriverState *bs = opaque;
1076 QObject *obj;
1077
9abf2dba 1078 trace_block_job_cb(bs, bs->job, ret);
12bd451f
SH
1079
1080 assert(bs->job);
1081 obj = qobject_from_block_job(bs->job);
1082 if (ret < 0) {
1083 QDict *dict = qobject_to_qdict(obj);
1084 qdict_put(dict, "error", qstring_from_str(strerror(-ret)));
1085 }
1086
370521a1
SH
1087 if (block_job_is_cancelled(bs->job)) {
1088 monitor_protocol_event(QEVENT_BLOCK_JOB_CANCELLED, obj);
1089 } else {
1090 monitor_protocol_event(QEVENT_BLOCK_JOB_COMPLETED, obj);
1091 }
12bd451f 1092 qobject_decref(obj);
aa398a5c
SH
1093
1094 drive_put_ref_bh_schedule(drive_get_by_blockdev(bs));
12bd451f
SH
1095}
1096
1097void qmp_block_stream(const char *device, bool has_base,
1d809098
PB
1098 const char *base, bool has_speed, int64_t speed,
1099 bool has_on_error, BlockdevOnError on_error,
1100 Error **errp)
12bd451f
SH
1101{
1102 BlockDriverState *bs;
c8c3080f 1103 BlockDriverState *base_bs = NULL;
fd7f8c65 1104 Error *local_err = NULL;
12bd451f 1105
1d809098
PB
1106 if (!has_on_error) {
1107 on_error = BLOCKDEV_ON_ERROR_REPORT;
1108 }
1109
12bd451f
SH
1110 bs = bdrv_find(device);
1111 if (!bs) {
1112 error_set(errp, QERR_DEVICE_NOT_FOUND, device);
1113 return;
1114 }
1115
12bd451f 1116 if (base) {
c8c3080f
MT
1117 base_bs = bdrv_find_backing_image(bs, base);
1118 if (base_bs == NULL) {
1119 error_set(errp, QERR_BASE_NOT_FOUND, base);
1120 return;
1121 }
12bd451f
SH
1122 }
1123
c83c66c3 1124 stream_start(bs, base_bs, base, has_speed ? speed : 0,
1d809098 1125 on_error, block_job_cb, bs, &local_err);
fd7f8c65
SH
1126 if (error_is_set(&local_err)) {
1127 error_propagate(errp, local_err);
1128 return;
12bd451f
SH
1129 }
1130
aa398a5c
SH
1131 /* Grab a reference so hotplug does not delete the BlockDriverState from
1132 * underneath us.
1133 */
1134 drive_get_ref(drive_get_by_blockdev(bs));
1135
12bd451f
SH
1136 trace_qmp_block_stream(bs, bs->job);
1137}
2d47c6e9 1138
ed61fc10
JC
1139void qmp_block_commit(const char *device,
1140 bool has_base, const char *base, const char *top,
1141 bool has_speed, int64_t speed,
1142 Error **errp)
1143{
1144 BlockDriverState *bs;
1145 BlockDriverState *base_bs, *top_bs;
1146 Error *local_err = NULL;
1147 /* This will be part of the QMP command, if/when the
1148 * BlockdevOnError change for blkmirror makes it in
1149 */
92aa5c6d 1150 BlockdevOnError on_error = BLOCKDEV_ON_ERROR_REPORT;
ed61fc10
JC
1151
1152 /* drain all i/o before commits */
1153 bdrv_drain_all();
1154
1155 bs = bdrv_find(device);
1156 if (!bs) {
1157 error_set(errp, QERR_DEVICE_NOT_FOUND, device);
1158 return;
1159 }
1160 if (base && has_base) {
1161 base_bs = bdrv_find_backing_image(bs, base);
1162 } else {
1163 base_bs = bdrv_find_base(bs);
1164 }
1165
1166 if (base_bs == NULL) {
1167 error_set(errp, QERR_BASE_NOT_FOUND, base ? base : "NULL");
1168 return;
1169 }
1170
1171 /* default top_bs is the active layer */
1172 top_bs = bs;
1173
1174 if (top) {
1175 if (strcmp(bs->filename, top) != 0) {
1176 top_bs = bdrv_find_backing_image(bs, top);
1177 }
1178 }
1179
1180 if (top_bs == NULL) {
1181 error_setg(errp, "Top image file %s not found", top ? top : "NULL");
1182 return;
1183 }
1184
1185 commit_start(bs, base_bs, top_bs, speed, on_error, block_job_cb, bs,
1186 &local_err);
1187 if (local_err != NULL) {
1188 error_propagate(errp, local_err);
1189 return;
1190 }
1191 /* Grab a reference so hotplug does not delete the BlockDriverState from
1192 * underneath us.
1193 */
1194 drive_get_ref(drive_get_by_blockdev(bs));
1195}
1196
2d47c6e9
SH
1197static BlockJob *find_block_job(const char *device)
1198{
1199 BlockDriverState *bs;
1200
1201 bs = bdrv_find(device);
1202 if (!bs || !bs->job) {
1203 return NULL;
1204 }
1205 return bs->job;
1206}
1207
882ec7ce 1208void qmp_block_job_set_speed(const char *device, int64_t speed, Error **errp)
2d47c6e9
SH
1209{
1210 BlockJob *job = find_block_job(device);
1211
1212 if (!job) {
7ef15070 1213 error_set(errp, QERR_BLOCK_JOB_NOT_ACTIVE, device);
2d47c6e9
SH
1214 return;
1215 }
1216
882ec7ce 1217 block_job_set_speed(job, speed, errp);
2d47c6e9 1218}
370521a1 1219
6e37fb81
PB
1220void qmp_block_job_cancel(const char *device,
1221 bool has_force, bool force, Error **errp)
370521a1
SH
1222{
1223 BlockJob *job = find_block_job(device);
1224
6e37fb81
PB
1225 if (!has_force) {
1226 force = false;
1227 }
1228
370521a1 1229 if (!job) {
7ef15070 1230 error_set(errp, QERR_BLOCK_JOB_NOT_ACTIVE, device);
370521a1
SH
1231 return;
1232 }
6e37fb81 1233 if (job->paused && !force) {
8acc72a4
PB
1234 error_set(errp, QERR_BLOCK_JOB_PAUSED, device);
1235 return;
1236 }
370521a1
SH
1237
1238 trace_qmp_block_job_cancel(job);
1239 block_job_cancel(job);
1240}
fb5458cd 1241
6e37fb81
PB
1242void qmp_block_job_pause(const char *device, Error **errp)
1243{
1244 BlockJob *job = find_block_job(device);
1245
1246 if (!job) {
1247 error_set(errp, QERR_BLOCK_JOB_NOT_ACTIVE, device);
1248 return;
1249 }
1250
1251 trace_qmp_block_job_pause(job);
1252 block_job_pause(job);
1253}
1254
1255void qmp_block_job_resume(const char *device, Error **errp)
1256{
1257 BlockJob *job = find_block_job(device);
1258
1259 if (!job) {
1260 error_set(errp, QERR_BLOCK_JOB_NOT_ACTIVE, device);
1261 return;
1262 }
1263
1264 trace_qmp_block_job_resume(job);
1265 block_job_resume(job);
1266}
1267
fb5458cd
SH
1268static void do_qmp_query_block_jobs_one(void *opaque, BlockDriverState *bs)
1269{
1270 BlockJobInfoList **prev = opaque;
1271 BlockJob *job = bs->job;
1272
1273 if (job) {
30e628b7
PB
1274 BlockJobInfoList *elem = g_new0(BlockJobInfoList, 1);
1275 elem->value = block_job_query(bs->job);
fb5458cd
SH
1276 (*prev)->next = elem;
1277 *prev = elem;
1278 }
1279}
1280
1281BlockJobInfoList *qmp_query_block_jobs(Error **errp)
1282{
1283 /* Dummy is a fake list element for holding the head pointer */
1284 BlockJobInfoList dummy = {};
1285 BlockJobInfoList *prev = &dummy;
1286 bdrv_iterate(do_qmp_query_block_jobs_one, &prev);
1287 return dummy.next;
1288}