From: Max Reitz <mreitz@redhat.com>

Test what happens when writing data to a preallocated zero cluster, but

the data write fails.

Signed-off-by: Max Reitz <mreitz@redhat.com>

Message-Id: <20200225143130.111267-3-mreitz@redhat.com>

Signed-off-by: Kevin Wolf <kwolf@redhat.com>

---

tests/qemu-iotests/026 | 21 +++++++++++++++++++++

tests/qemu-iotests/026.out | 10 ++++++++++

tests/qemu-iotests/026.out.nocache | 10 ++++++++++

3 files changed, 41 insertions(+)

diff --git a/tests/qemu-iotests/026 b/tests/qemu-iotests/026

index XXXXXXX..XXXXXXX 100755

--- a/tests/qemu-iotests/026

+++ b/tests/qemu-iotests/026

@@ -XXX,XX +XXX,XX @@ _make_test_img 64M

$QEMU_IO -c "write 0 1M" -c "write 0 1M" "$BLKDBG_TEST_IMG" | _filter_qemu_io

_check_test_img

+echo

+echo === Avoid freeing preallocated zero clusters on failure ===

+echo

+

+cat > "$TEST_DIR/blkdebug.conf" <<EOF

+[inject-error]

+event = "write_aio"

+errno = "5"

+once = "on"

+EOF

+

+_make_test_img $CLUSTER_SIZE

+# Create a preallocated zero cluster

+$QEMU_IO -c "write 0 $CLUSTER_SIZE" -c "write -z 0 $CLUSTER_SIZE" "$TEST_IMG" \

+ | _filter_qemu_io

+# Try to overwrite it (prompting an I/O error from blkdebug), thus

+# triggering the alloc abort code

+$QEMU_IO -c "write 0 $CLUSTER_SIZE" "$BLKDBG_TEST_IMG" | _filter_qemu_io

+

+_check_test_img

+

# success, all done

echo "*** done"

rm -f $seq.full

diff --git a/tests/qemu-iotests/026.out b/tests/qemu-iotests/026.out

index XXXXXXX..XXXXXXX 100644

--- a/tests/qemu-iotests/026.out

+++ b/tests/qemu-iotests/026.out

@@ -XXX,XX +XXX,XX @@ write failed: Input/output error

wrote 1048576/1048576 bytes at offset 0

1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

No errors were found on the image.

+

+=== Avoid freeing preallocated zero clusters on failure ===

+

+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1024

+wrote 1024/1024 bytes at offset 0

+1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

+wrote 1024/1024 bytes at offset 0

+1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

+write failed: Input/output error

+No errors were found on the image.

*** done

diff --git a/tests/qemu-iotests/026.out.nocache b/tests/qemu-iotests/026.out.nocache

index XXXXXXX..XXXXXXX 100644

--- a/tests/qemu-iotests/026.out.nocache

+++ b/tests/qemu-iotests/026.out.nocache

@@ -XXX,XX +XXX,XX @@ write failed: Input/output error

wrote 1048576/1048576 bytes at offset 0

1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

No errors were found on the image.

+

+=== Avoid freeing preallocated zero clusters on failure ===

+

+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1024

+wrote 1024/1024 bytes at offset 0

+1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

+wrote 1024/1024 bytes at offset 0

+1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

+write failed: Input/output error

+No errors were found on the image.

*** done

--

2.20.1

From: Max Reitz <mreitz@redhat.com>

Test what happens when writing data to an external data file, where the

write requires an L2 entry to be allocated, but the data write fails.

Signed-off-by: Max Reitz <mreitz@redhat.com>

Message-Id: <20200225143130.111267-4-mreitz@redhat.com>

Signed-off-by: Kevin Wolf <kwolf@redhat.com>

---

tests/qemu-iotests/026 | 32 ++++++++++++++++++++++++++++++

tests/qemu-iotests/026.out | 6 ++++++

tests/qemu-iotests/026.out.nocache | 6 ++++++

3 files changed, 44 insertions(+)

diff --git a/tests/qemu-iotests/026 b/tests/qemu-iotests/026

index XXXXXXX..XXXXXXX 100755

--- a/tests/qemu-iotests/026

+++ b/tests/qemu-iotests/026

@@ -XXX,XX +XXX,XX @@ _cleanup()

{

    _cleanup_test_img

rm "$TEST_DIR/blkdebug.conf"

+ rm -f "$TEST_IMG.data_file"

}

trap "_cleanup; exit \$status" 0 1 2 3 15

@@ -XXX,XX +XXX,XX @@ $QEMU_IO -c "write 0 $CLUSTER_SIZE" "$BLKDBG_TEST_IMG" | _filter_qemu_io

_check_test_img

+echo

+echo === Avoid freeing external data clusters on failure ===

+echo

+

+# Similar test as the last one, except we test what happens when there

+# is an error when writing to an external data file instead of when

+# writing to a preallocated zero cluster

+_make_test_img -o "data_file=$TEST_IMG.data_file" $CLUSTER_SIZE

+

+# Put blkdebug above the data-file, and a raw node on top of that so

+# that blkdebug will see a write_aio event and emit an error

+$QEMU_IO -c "write 0 $CLUSTER_SIZE" \

+ "json:{

+ 'driver': 'qcow2',

+ 'file': { 'driver': 'file', 'filename': '$TEST_IMG' },

+ 'data-file': {

+ 'driver': 'raw',

+ 'file': {

+ 'driver': 'blkdebug',

+ 'config': '$TEST_DIR/blkdebug.conf',

+ 'image': {

+ 'driver': 'file',

+ 'filename': '$TEST_IMG.data_file'

+ }

+ }

+ }

+ }" \

+ | _filter_qemu_io

+

+_check_test_img

+

# success, all done

echo "*** done"

rm -f $seq.full

diff --git a/tests/qemu-iotests/026.out b/tests/qemu-iotests/026.out

index XXXXXXX..XXXXXXX 100644

--- a/tests/qemu-iotests/026.out

+++ b/tests/qemu-iotests/026.out

@@ -XXX,XX +XXX,XX @@ wrote 1024/1024 bytes at offset 0

1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

write failed: Input/output error

No errors were found on the image.

+

+=== Avoid freeing external data clusters on failure ===

+

+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1024 data_file=TEST_DIR/t.IMGFMT.data_file

+write failed: Input/output error

+No errors were found on the image.

*** done

diff --git a/tests/qemu-iotests/026.out.nocache b/tests/qemu-iotests/026.out.nocache

index XXXXXXX..XXXXXXX 100644

--- a/tests/qemu-iotests/026.out.nocache

+++ b/tests/qemu-iotests/026.out.nocache

@@ -XXX,XX +XXX,XX @@ wrote 1024/1024 bytes at offset 0

1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

write failed: Input/output error

No errors were found on the image.

+

+=== Avoid freeing external data clusters on failure ===

+

+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1024 data_file=TEST_DIR/t.IMGFMT.data_file

+write failed: Input/output error

+No errors were found on the image.

*** done

--

2.20.1

From: Max Reitz <mreitz@redhat.com>

@options is leaked by the first two return statements in this function.

Note that blk_new_open() takes the reference to @options even on

failure, so all we need to do to fix the leak is to move the QDict

allocation down to where we actually need it.

Reported-by: Coverity (CID 1419884)

Fixes: fd17146cd93d1704cd96d7c2757b325fc7aac6fd

("block: Generic file creation fallback")

Signed-off-by: Max Reitz <mreitz@redhat.com>

Message-Id: <20200225155618.133412-1-mreitz@redhat.com>

Signed-off-by: Kevin Wolf <kwolf@redhat.com>

---

block.c | 3 ++-

1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/block.c b/block.c

index XXXXXXX..XXXXXXX 100644

--- a/block.c

+++ b/block.c

@@ -XXX,XX +XXX,XX @@ static int bdrv_create_file_fallback(const char *filename, BlockDriver *drv,

QemuOpts *opts, Error **errp)

{

BlockBackend *blk;

- QDict *options = qdict_new();

+ QDict *options;

int64_t size = 0;

char *buf = NULL;

PreallocMode prealloc;

@@ -XXX,XX +XXX,XX @@ static int bdrv_create_file_fallback(const char *filename, BlockDriver *drv,

return -ENOTSUP;

}

+ options = qdict_new();

qdict_put_str(options, "driver", drv->format_name);

blk = blk_new_open(filename, NULL, options,

--

2.20.1

This adds a new binary qemu-storage-daemon that doesn't yet do more than

some typical initialisation for tools and parsing the basic command

options --version, --help and --trace.

Even though this doesn't add any options yet that create things (like

--object or --blockdev), already document that we're planning to process

them in the order they are given on the command line rather than trying

(and failing, like vl.c) to resolve dependencies between options

automatically.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>

Message-Id: <20200224143008.13362-2-kwolf@redhat.com>

Acked-by: Stefan Hajnoczi <stefanha@redhat.com>

Signed-off-by: Kevin Wolf <kwolf@redhat.com>

---

configure | 2 +-

qemu-storage-daemon.c | 127 ++++++++++++++++++++++++++++++++++++++++++

Makefile | 1 +

3 files changed, 129 insertions(+), 1 deletion(-)

create mode 100644 qemu-storage-daemon.c

diff --git a/configure b/configure

index XXXXXXX..XXXXXXX 100755

--- a/configure

+++ b/configure

@@ -XXX,XX +XXX,XX @@ tools=""

if test "$want_tools" = "yes" ; then

tools="qemu-img\$(EXESUF) qemu-io\$(EXESUF) qemu-edid\$(EXESUF) $tools"

if [ "$linux" = "yes" -o "$bsd" = "yes" -o "$solaris" = "yes" ] ; then

- tools="qemu-nbd\$(EXESUF) $tools"

+ tools="qemu-nbd\$(EXESUF) qemu-storage-daemon\$(EXESUF) $tools"

fi

if [ "$ivshmem" = "yes" ]; then

tools="ivshmem-client\$(EXESUF) ivshmem-server\$(EXESUF) $tools"

diff --git a/qemu-storage-daemon.c b/qemu-storage-daemon.c

new file mode 100644

index XXXXXXX..XXXXXXX

--- /dev/null

+++ b/qemu-storage-daemon.c

@@ -XXX,XX +XXX,XX @@

+/*

+ * QEMU storage daemon

+ *

+ * Copyright (c) 2003-2008 Fabrice Bellard

+ * Copyright (c) 2019 Kevin Wolf <kwolf@redhat.com>

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to deal

+ * in the Software without restriction, including without limitation the rights

+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

+ * copies of the Software, and to permit persons to whom the Software is

+ * furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in

+ * all copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

+ * THE SOFTWARE.

+ */

+

+#include "qemu/osdep.h"

+

+#include <getopt.h>

+

+#include "block/block.h"

+#include "crypto/init.h"

+

+#include "qapi/error.h"

+#include "qemu-common.h"

+#include "qemu-version.h"

+#include "qemu/config-file.h"

+#include "qemu/error-report.h"

+#include "qemu/log.h"

+#include "qemu/main-loop.h"

+#include "qemu/module.h"

+

+#include "trace/control.h"

+

+static void help(void)

+{

+ printf(

+"Usage: %s [options]\n"

+"QEMU storage daemon\n"

+"\n"

+" -h, --help display this help and exit\n"

+" -T, --trace [[enable=]<pattern>][,events=<file>][,file=<file>]\n"

+" specify tracing options\n"

+" -V, --version output version information and exit\n"

+"\n"

+QEMU_HELP_BOTTOM "\n",

+ error_get_progname());

+}

+

+static void process_options(int argc, char *argv[])

+{

+ int c;

+

+ static const struct option long_options[] = {

+ {"help", no_argument, NULL, 'h'},

+ {"trace", required_argument, NULL, 'T'},

+ {"version", no_argument, NULL, 'V'},

+ {0, 0, 0, 0}

+ };

+

+ /*

+ * In contrast to the system emulator, options are processed in the order

+ * they are given on the command lines. This means that things must be

+ * defined first before they can be referenced in another option.

+ */

+ while ((c = getopt_long(argc, argv, "hT:V", long_options, NULL)) != -1) {

+ switch (c) {

+ case '?':

+ exit(EXIT_FAILURE);

+ case 'h':

+ help();

+ exit(EXIT_SUCCESS);

+ case 'T':

+ {

+ char *trace_file = trace_opt_parse(optarg);

+ trace_init_file(trace_file);

+ g_free(trace_file);

+ break;

+ }

+ case 'V':

+ printf("qemu-storage-daemon version "

+ QEMU_FULL_VERSION "\n" QEMU_COPYRIGHT "\n");

+ exit(EXIT_SUCCESS);

+ default:

+ g_assert_not_reached();

+ }

+ }

+ if (optind != argc) {

+ error_report("Unexpected argument: %s", argv[optind]);

+ exit(EXIT_FAILURE);

+ }

+}

+

+int main(int argc, char *argv[])

+{

+#ifdef CONFIG_POSIX

+ signal(SIGPIPE, SIG_IGN);

+#endif

+

+ error_init(argv[0]);

+ qemu_init_exec_dir(argv[0]);

+

+ module_call_init(MODULE_INIT_QOM);

+ module_call_init(MODULE_INIT_TRACE);

+ qemu_add_opts(&qemu_trace_opts);

+ qcrypto_init(&error_fatal);

+ bdrv_init();

+

+ if (!trace_init_backends()) {

+ return EXIT_FAILURE;

+ }

+ qemu_set_log(LOG_TRACE);

+

+ qemu_init_main_loop(&error_fatal);

+ process_options(argc, argv);

+

+ return EXIT_SUCCESS;

+}

diff --git a/Makefile b/Makefile

index XXXXXXX..XXXXXXX 100644

--- a/Makefile

+++ b/Makefile

@@ -XXX,XX +XXX,XX @@ qemu-img.o: qemu-img-cmds.h

qemu-img$(EXESUF): qemu-img.o $(authz-obj-y) $(block-obj-y) $(crypto-obj-y) $(io-obj-y) $(qom-obj-y) $(COMMON_LDADDS)

qemu-nbd$(EXESUF): qemu-nbd.o $(authz-obj-y) $(block-obj-y) $(crypto-obj-y) $(io-obj-y) $(qom-obj-y) $(COMMON_LDADDS)

qemu-io$(EXESUF): qemu-io.o $(authz-obj-y) $(block-obj-y) $(crypto-obj-y) $(io-obj-y) $(qom-obj-y) $(COMMON_LDADDS)

+qemu-storage-daemon$(EXESUF): qemu-storage-daemon.o $(authz-obj-y) $(block-obj-y) $(crypto-obj-y) $(io-obj-y) $(qom-obj-y) $(COMMON_LDADDS)

qemu-bridge-helper$(EXESUF): qemu-bridge-helper.o $(COMMON_LDADDS)

--

2.20.1

blockdev.c uses the arch_type constant, so before we can use the file in

tools (i.e. outside of the system emulator), we need to add a stub for

it. A new QEMU_ARCH_NONE is introduced for this case.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>

Message-Id: <20200224143008.13362-3-kwolf@redhat.com>

Acked-by: Stefan Hajnoczi <stefanha@redhat.com>

Signed-off-by: Kevin Wolf <kwolf@redhat.com>

---

include/sysemu/arch_init.h | 2 ++

stubs/arch_type.c | 4 ++++

stubs/Makefile.objs | 1 +

3 files changed, 7 insertions(+)

create mode 100644 stubs/arch_type.c

diff --git a/include/sysemu/arch_init.h b/include/sysemu/arch_init.h

index XXXXXXX..XXXXXXX 100644

--- a/include/sysemu/arch_init.h

+++ b/include/sysemu/arch_init.h

@@ -XXX,XX +XXX,XX @@ enum {

QEMU_ARCH_NIOS2 = (1 << 17),

QEMU_ARCH_HPPA = (1 << 18),

QEMU_ARCH_RISCV = (1 << 19),

+

+ QEMU_ARCH_NONE = (1 << 31),

};

extern const uint32_t arch_type;

diff --git a/stubs/arch_type.c b/stubs/arch_type.c

new file mode 100644

index XXXXXXX..XXXXXXX

--- /dev/null

+++ b/stubs/arch_type.c

@@ -XXX,XX +XXX,XX @@

+#include "qemu/osdep.h"

+#include "sysemu/arch_init.h"

+

+const uint32_t arch_type = QEMU_ARCH_NONE;

diff --git a/stubs/Makefile.objs b/stubs/Makefile.objs

index XXXXXXX..XXXXXXX 100644

--- a/stubs/Makefile.objs

+++ b/stubs/Makefile.objs

@@ -XXX,XX +XXX,XX @@

+stub-obj-y += arch_type.o

stub-obj-y += bdrv-next-monitor-owned.o

stub-obj-y += blk-commit-all.o

stub-obj-y += blockdev-close-all-bdrv-states.o

--

2.20.1

These commands make only sense for system emulators and their

implementations call functions that don't exist in tools (e.g. to

resolve qdev IDs). Move them out so that blockdev.c can be linked to

qemu-storage-daemon.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>

Message-Id: <20200224143008.13362-4-kwolf@redhat.com>

Acked-by: Stefan Hajnoczi <stefanha@redhat.com>

Signed-off-by: Kevin Wolf <kwolf@redhat.com>

---

block/qapi-sysemu.c | 590 ++++++++++++++++++++++++++++++++++++++++++++

blockdev.c | 559 -----------------------------------------

block/Makefile.objs | 2 +

3 files changed, 592 insertions(+), 559 deletions(-)

create mode 100644 block/qapi-sysemu.c

diff --git a/block/qapi-sysemu.c b/block/qapi-sysemu.c

new file mode 100644

index XXXXXXX..XXXXXXX

--- /dev/null

+++ b/block/qapi-sysemu.c

@@ -XXX,XX +XXX,XX @@

+/*

+ * QMP command handlers specific to the system emulators

+ *

+ * Copyright (c) 2003-2008 Fabrice Bellard

+ *

+ * This work is licensed under the terms of the GNU GPL, version 2 or

+ * later. See the COPYING file in the top-level directory.

+ *

+ * This file incorporates work covered by the following copyright and

+ * permission notice:

+ *

+ * Copyright (c) 2003-2008 Fabrice Bellard

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to deal

+ * in the Software without restriction, including without limitation the rights

+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

+ * copies of the Software, and to permit persons to whom the Software is

+ * furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in

+ * all copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

+ * THE SOFTWARE.

+ */

+

+#include "qemu/osdep.h"

+

+#include "qapi/error.h"

+#include "qapi/qapi-commands-block.h"

+#include "qapi/qmp/qdict.h"

+#include "sysemu/block-backend.h"

+#include "sysemu/blockdev.h"

+

+static BlockBackend *qmp_get_blk(const char *blk_name, const char *qdev_id,

+ Error **errp)

+{

+ BlockBackend *blk;

+

+ if (!blk_name == !qdev_id) {

+ error_setg(errp, "Need exactly one of 'device' and 'id'");

+ return NULL;

+ }

+

+ if (qdev_id) {

+ blk = blk_by_qdev_id(qdev_id, errp);

+ } else {

+ blk = blk_by_name(blk_name);

+ if (blk == NULL) {

+ error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,

+ "Device '%s' not found", blk_name);

+ }

+ }

+

+ return blk;

+}

+

+/*

+ * Attempt to open the tray of @device.

+ * If @force, ignore its tray lock.

+ * Else, if the tray is locked, don't open it, but ask the guest to open it.

+ * On error, store an error through @errp and return -errno.

+ * If @device does not exist, return -ENODEV.

+ * If it has no removable media, return -ENOTSUP.

+ * If it has no tray, return -ENOSYS.

+ * If the guest was asked to open the tray, return -EINPROGRESS.

+ * Else, return 0.

+ */

+static int do_open_tray(const char *blk_name, const char *qdev_id,

+ bool force, Error **errp)

+{

+ BlockBackend *blk;

+ const char *device = qdev_id ?: blk_name;

+ bool locked;

+

+ blk = qmp_get_blk(blk_name, qdev_id, errp);

+ if (!blk) {

+ return -ENODEV;

+ }

+

+ if (!blk_dev_has_removable_media(blk)) {

+ error_setg(errp, "Device '%s' is not removable", device);

+ return -ENOTSUP;

+ }

+

+ if (!blk_dev_has_tray(blk)) {

+ error_setg(errp, "Device '%s' does not have a tray", device);

+ return -ENOSYS;

+ }

+

+ if (blk_dev_is_tray_open(blk)) {

+ return 0;

+ }

+

+ locked = blk_dev_is_medium_locked(blk);

+ if (locked) {

+ blk_dev_eject_request(blk, force);

+ }

+

+ if (!locked || force) {

+ blk_dev_change_media_cb(blk, false, &error_abort);

+ }

+

+ if (locked && !force) {

+ error_setg(errp, "Device '%s' is locked and force was not specified, "

+ "wait for tray to open and try again", device);

+ return -EINPROGRESS;

+ }

+

+ return 0;

+}

+

+void qmp_blockdev_open_tray(bool has_device, const char *device,

+ bool has_id, const char *id,

+ bool has_force, bool force,

+ Error **errp)

+{

+ Error *local_err = NULL;

+ int rc;

+

+ if (!has_force) {

+ force = false;

+ }

+ rc = do_open_tray(has_device ? device : NULL,

+ has_id ? id : NULL,

+ force, &local_err);

+ if (rc && rc != -ENOSYS && rc != -EINPROGRESS) {

+ error_propagate(errp, local_err);

+ return;

+ }

+ error_free(local_err);

+}

+

+void qmp_blockdev_close_tray(bool has_device, const char *device,

+ bool has_id, const char *id,

+ Error **errp)

+{

+ BlockBackend *blk;

+ Error *local_err = NULL;

+

+ device = has_device ? device : NULL;

+ id = has_id ? id : NULL;

+

+ blk = qmp_get_blk(device, id, errp);

+ if (!blk) {

+ return;

+ }

+

+ if (!blk_dev_has_removable_media(blk)) {

+ error_setg(errp, "Device '%s' is not removable", device ?: id);

+ return;

+ }

+

+ if (!blk_dev_has_tray(blk)) {

+ /* Ignore this command on tray-less devices */

+ return;

+ }

+

+ if (!blk_dev_is_tray_open(blk)) {

+ return;

+ }

+

+ blk_dev_change_media_cb(blk, true, &local_err);

+ if (local_err) {

+ error_propagate(errp, local_err);

+ return;

+ }

+}

+

+static void blockdev_remove_medium(bool has_device, const char *device,

+ bool has_id, const char *id, Error **errp)

+{

+ BlockBackend *blk;

+ BlockDriverState *bs;

+ AioContext *aio_context;

+ bool has_attached_device;

+

+ device = has_device ? device : NULL;

+ id = has_id ? id : NULL;

+

+ blk = qmp_get_blk(device, id, errp);

+ if (!blk) {

+ return;

+ }

+

+ /* For BBs without a device, we can exchange the BDS tree at will */

+ has_attached_device = blk_get_attached_dev(blk);

+

+ if (has_attached_device && !blk_dev_has_removable_media(blk)) {

+ error_setg(errp, "Device '%s' is not removable", device ?: id);

+ return;

+ }

+

+ if (has_attached_device && blk_dev_has_tray(blk) &&

+ !blk_dev_is_tray_open(blk))

+ {

+ error_setg(errp, "Tray of device '%s' is not open", device ?: id);

+ return;

+ }

+

+ bs = blk_bs(blk);