Commit 67f17e23 authored by Peter Maydell's avatar Peter Maydell
Browse files

Merge remote-tracking branch 'remotes/kevin/tags/for-upstream' into staging 



Block layer patches:

- Add qemu-storage-daemon (still experimental)
- rbd: Add support for ceph namespaces
- Fix bdrv_reopen() with backing file in different AioContext
- qcow2: Fix read-write reopen with persistent dirty bitmaps
- qcow2: Fix alloc_cluster_abort() for pre-existing clusters

# gpg: Signature made Fri 06 Mar 2020 17:12:31 GMT
# gpg:                using RSA key 7F09B272C88F2FD6
# gpg: Good signature from "Kevin Wolf <kwolf@redhat.com>" [full]
# Primary key fingerprint: DC3D EB15 9A9A F95D 3D74  56FE 7F09 B272 C88F 2FD6

* remotes/kevin/tags/for-upstream: (29 commits)
  block: bdrv_reopen() with backing file in different AioContext
  iotests: Refactor blockdev-reopen test for iothreads
  block/rbd: Add support for ceph namespaces
  qemu-storage-daemon: Add --monitor option
  monitor: Add allow_hmp parameter to monitor_init()
  hmp: Fail gracefully if chardev is already in use
  qmp: Fail gracefully if chardev is already in use
  monitor: Create QAPIfied monitor_init()
  qapi: Create 'pragma' module
  stubs: Update monitor stubs for qemu-storage-daemon
  qemu-storage-daemon: Add --chardev option
  qemu-storage-daemon: Add main loop
  qemu-storage-daemon: Add --export option
  blockdev-nbd: Boxed argument type for nbd-server-add
  qemu-storage-daemon: Add --nbd-server option
  qemu-storage-daemon: Add --object option
  qapi: Flatten object-add
  qemu-storage-daemon: Add --blockdev option
  block: Move sysemu QMP commands to QAPI block module
  block: Move common QMP commands to block-core QAPI module
  ...

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents c2058285 1de6b45f

Makefile

+37 −0
Original line number Diff line number Diff line
@@ -128,7 +128,28 @@ GENERATED_QAPI_FILES += $(QAPI_MODULES:%=qapi/qapi-events-%.c) 
GENERATED_QAPI_FILES += qapi/qapi-introspect.c qapi/qapi-introspect.h

GENERATED_QAPI_FILES += qapi/qapi-doc.texi



# The following list considers only the storage daemon main module. All other

# modules are currently shared with the main schema, so we don't actually

# generate additional files.



GENERATED_STORAGE_DAEMON_QAPI_FILES = storage-daemon/qapi/qapi-commands.h

GENERATED_STORAGE_DAEMON_QAPI_FILES += storage-daemon/qapi/qapi-commands.c

GENERATED_STORAGE_DAEMON_QAPI_FILES += storage-daemon/qapi/qapi-emit-events.h

GENERATED_STORAGE_DAEMON_QAPI_FILES += storage-daemon/qapi/qapi-emit-events.c

GENERATED_STORAGE_DAEMON_QAPI_FILES += storage-daemon/qapi/qapi-events.h

GENERATED_STORAGE_DAEMON_QAPI_FILES += storage-daemon/qapi/qapi-events.c

GENERATED_STORAGE_DAEMON_QAPI_FILES += storage-daemon/qapi/qapi-init-commands.h

GENERATED_STORAGE_DAEMON_QAPI_FILES += storage-daemon/qapi/qapi-init-commands.c

GENERATED_STORAGE_DAEMON_QAPI_FILES += storage-daemon/qapi/qapi-introspect.h

GENERATED_STORAGE_DAEMON_QAPI_FILES += storage-daemon/qapi/qapi-introspect.c

GENERATED_STORAGE_DAEMON_QAPI_FILES += storage-daemon/qapi/qapi-types.h

GENERATED_STORAGE_DAEMON_QAPI_FILES += storage-daemon/qapi/qapi-types.c

GENERATED_STORAGE_DAEMON_QAPI_FILES += storage-daemon/qapi/qapi-visit.h

GENERATED_STORAGE_DAEMON_QAPI_FILES += storage-daemon/qapi/qapi-visit.c

GENERATED_STORAGE_DAEMON_QAPI_FILES += storage-daemon/qapi/qapi-doc.texi



generated-files-y += $(GENERATED_QAPI_FILES)

generated-files-y += $(GENERATED_STORAGE_DAEMON_QAPI_FILES)



generated-files-y += trace/generated-tcg-tracers.h
@@ -450,6 +471,8 @@ dummy := $(call unnest-vars,, \ 
                qga-vss-dll-obj-y \

                block-obj-y \

                block-obj-m \

                storage-daemon-obj-y \

                storage-daemon-obj-m \

                crypto-obj-y \

                qom-obj-y \

                io-obj-y \
@@ -482,6 +505,7 @@ TARGET_DIRS_RULES := $(foreach t, all fuzz clean install, $(addsuffix /$(t), $(T 
SOFTMMU_ALL_RULES=$(filter %-softmmu/all, $(TARGET_DIRS_RULES))

$(SOFTMMU_ALL_RULES): $(authz-obj-y)

$(SOFTMMU_ALL_RULES): $(block-obj-y)

$(SOFTMMU_ALL_RULES): $(storage-daemon-obj-y)

$(SOFTMMU_ALL_RULES): $(chardev-obj-y)

$(SOFTMMU_ALL_RULES): $(crypto-obj-y)

$(SOFTMMU_ALL_RULES): $(io-obj-y)
@@ -586,6 +610,7 @@ 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) $(chardev-obj-y) $(io-obj-y) $(qom-obj-y) $(storage-daemon-obj-y) $(COMMON_LDADDS)



qemu-bridge-helper$(EXESUF): qemu-bridge-helper.o $(COMMON_LDADDS)
@@ -647,6 +672,17 @@ qapi-gen-timestamp: $(qapi-modules) $(qapi-py) 
		"GEN","$(@:%-timestamp=%)")

	@>$@



qapi-modules-storage-daemon = \

	$(SRC_PATH)/storage-daemon/qapi/qapi-schema.json \

    $(QAPI_MODULES_STORAGE_DAEMON:%=$(SRC_PATH)/qapi/%.json)



$(GENERATED_STORAGE_DAEMON_QAPI_FILES): storage-daemon/qapi/qapi-gen-timestamp ;

storage-daemon/qapi/qapi-gen-timestamp: $(qapi-modules-storage-daemon) $(qapi-py)

	$(call quiet-command,$(PYTHON) $(SRC_PATH)/scripts/qapi-gen.py \

		-o "storage-daemon/qapi" $<, \

		"GEN","$(@:%-timestamp=%)")

	@>$@



QGALIB_GEN=$(addprefix qga/qapi-generated/, qga-qapi-types.h qga-qapi-visit.h qga-qapi-commands.h qga-qapi-init-commands.h)

$(qga-obj-y): $(QGALIB_GEN)
@@ -745,6 +781,7 @@ clean: recurse-clean 
	rm -f trace/generated-tracers-dtrace.h*

	rm -f $(foreach f,$(generated-files-y),$(f) $(f)-timestamp)

	rm -f qapi-gen-timestamp

	rm -f storage-daemon/qapi/qapi-gen-timestamp

	rm -rf qga/qapi-generated

	rm -f config-all-devices.mak

Makefile.objs

+9 −0
Original line number Diff line number Diff line
@@ -27,6 +27,15 @@ io-obj-y = io/ 


endif # CONFIG_SOFTMMU or CONFIG_TOOLS



#######################################################################

# storage-daemon-obj-y is code used by qemu-storage-daemon (these objects are

# used for system emulation, too, but specified separately there)



storage-daemon-obj-y = block/ monitor/ qapi/ qom/ storage-daemon/

storage-daemon-obj-y += blockdev.o blockdev-nbd.o iothread.o job-qmp.o

storage-daemon-obj-$(CONFIG_WIN32) += os-win32.o

storage-daemon-obj-$(CONFIG_POSIX) += os-posix.o



######################################################################

# Target independent part of system emulation. The long term path is to

# suppress *all* target specific code in case of system emulation, i.e. a

block.c

+37 −7
Original line number Diff line number Diff line
@@ -600,7 +600,7 @@ 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;
@@ -623,6 +623,7 @@ 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,
@@ -3694,6 +3695,15 @@ cleanup_perm: 
            }

        }

    }



    if (ret == 0) {

        QTAILQ_FOREACH_REVERSE(bs_entry, bs_queue, entry) {

            BlockDriverState *bs = bs_entry->state.bs;



            if (bs->drv->bdrv_reopen_commit_post)

                bs->drv->bdrv_reopen_commit_post(&bs_entry->state);

        }

    }

cleanup:

    QTAILQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) {

        if (ret) {
@@ -3777,6 +3787,29 @@ static void bdrv_reopen_perm(BlockReopenQueue *q, BlockDriverState *bs, 
    *shared = cumulative_shared_perms;

}



static bool bdrv_reopen_can_attach(BlockDriverState *parent,

                                   BdrvChild *child,

                                   BlockDriverState *new_child,

                                   Error **errp)

{

    AioContext *parent_ctx = bdrv_get_aio_context(parent);

    AioContext *child_ctx = bdrv_get_aio_context(new_child);

    GSList *ignore;

    bool ret;



    ignore = g_slist_prepend(NULL, child);

    ret = bdrv_can_set_aio_context(new_child, parent_ctx, &ignore, NULL);

    g_slist_free(ignore);

    if (ret) {

        return ret;

    }



    ignore = g_slist_prepend(NULL, child);

    ret = bdrv_can_set_aio_context(parent, child_ctx, &ignore, errp);

    g_slist_free(ignore);

    return ret;

}



/*

 * Take a BDRVReopenState and check if the value of 'backing' in the

 * reopen_state->options QDict is valid or not.
@@ -3828,14 +3861,11 @@ static int bdrv_reopen_parse_backing(BDRVReopenState *reopen_state, 
    }



    /*

     * TODO: before removing the x- prefix from x-blockdev-reopen we

     * should move the new backing file into the right AioContext

     * instead of returning an error.

     * Check AioContext compatibility so that the bdrv_set_backing_hd() call in

     * bdrv_reopen_commit() won't fail.

     */

    if (new_backing_bs) {

        if (bdrv_get_aio_context(new_backing_bs) != bdrv_get_aio_context(bs)) {

            error_setg(errp, "Cannot use a new backing file "

                       "with a different AioContext");

        if (!bdrv_reopen_can_attach(bs, bs->backing, new_backing_bs, errp)) {

            return -EINVAL;

        }

    }

block/Makefile.objs

+3 −1
Original line number Diff line number Diff line
@@ -46,7 +46,9 @@ block-obj-y += aio_task.o 
block-obj-y += backup-top.o

block-obj-y += filter-compress.o



common-obj-y += stream.o

block-obj-y += stream.o



common-obj-y += qapi-sysemu.o



nfs.o-libs         := $(LIBNFS_LIBS)

iscsi.o-cflags     := $(LIBISCSI_CFLAGS)

block/qapi-sysemu.c

0 → 100644
+590 −0
Original line number Diff line number Diff line 
/*

 * 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);

    if (!bs) {

        return;

    }



    aio_context = bdrv_get_aio_context(bs);

    aio_context_acquire(aio_context);



    if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_EJECT, errp)) {

        goto out;

    }



    blk_remove_bs(blk);



    if (!blk_dev_has_tray(blk)) {

        /* For tray-less devices, blockdev-open-tray is a no-op (or may not be

         * called at all); therefore, the medium needs to be ejected here.

         * Do it after blk_remove_bs() so blk_is_inserted(blk) returns the @load

         * value passed here (i.e. false). */

        blk_dev_change_media_cb(blk, false, &error_abort);

    }



out:

    aio_context_release(aio_context);

}



void qmp_blockdev_remove_medium(const char *id, Error **errp)

{

    blockdev_remove_medium(false, NULL, true, id, errp);

}



static void qmp_blockdev_insert_anon_medium(BlockBackend *blk,

                                            BlockDriverState *bs, Error **errp)

{

    Error *local_err = NULL;

    bool has_device;

    int ret;



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

    has_device = blk_get_attached_dev(blk);



    if (has_device && !blk_dev_has_removable_media(blk)) {

        error_setg(errp, "Device is not removable");

        return;

    }



    if (has_device && blk_dev_has_tray(blk) && !blk_dev_is_tray_open(blk)) {

        error_setg(errp, "Tray of the device is not open");

        return;

    }



    if (blk_bs(blk)) {

        error_setg(errp, "There already is a medium in the device");

        return;

    }



    ret = blk_insert_bs(blk, bs, errp);

    if (ret < 0) {

        return;

    }



    if (!blk_dev_has_tray(blk)) {

        /* For tray-less devices, blockdev-close-tray is a no-op (or may not be

         * called at all); therefore, the medium needs to be pushed into the

         * slot here.

         * Do it after blk_insert_bs() so blk_is_inserted(blk) returns the @load

         * value passed here (i.e. true). */

        blk_dev_change_media_cb(blk, true, &local_err);

        if (local_err) {

            error_propagate(errp, local_err);

            blk_remove_bs(blk);

            return;

        }

    }

}



static void blockdev_insert_medium(bool has_device, const char *device,

                                   bool has_id, const char *id,

                                   const char *node_name, Error **errp)

{

    BlockBackend *blk;

    BlockDriverState *bs;



    blk = qmp_get_blk(has_device ? device : NULL,

                      has_id ? id : NULL,

                      errp);

    if (!blk) {

        return;

    }



    bs = bdrv_find_node(node_name);

    if (!bs) {

        error_setg(errp, "Node '%s' not found", node_name);

        return;

    }



    if (bdrv_has_blk(bs)) {

        error_setg(errp, "Node '%s' is already in use", node_name);

        return;

    }



    qmp_blockdev_insert_anon_medium(blk, bs, errp);

}



void qmp_blockdev_insert_medium(const char *id, const char *node_name,

                                Error **errp)

{

    blockdev_insert_medium(false, NULL, true, id, node_name, errp);

}



void qmp_blockdev_change_medium(bool has_device, const char *device,

                                bool has_id, const char *id,

                                const char *filename,

                                bool has_format, const char *format,

                                bool has_read_only,

                                BlockdevChangeReadOnlyMode read_only,

                                Error **errp)

{

    BlockBackend *blk;

    BlockDriverState *medium_bs = NULL;

    int bdrv_flags;

    bool detect_zeroes;

    int rc;

    QDict *options = NULL;

    Error *err = NULL;



    blk = qmp_get_blk(has_device ? device : NULL,

                      has_id ? id : NULL,

                      errp);

    if (!blk) {

        goto fail;

    }



    if (blk_bs(blk)) {

        blk_update_root_state(blk);

    }



    bdrv_flags = blk_get_open_flags_from_root_state(blk);

    bdrv_flags &= ~(BDRV_O_TEMPORARY | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING |

        BDRV_O_PROTOCOL | BDRV_O_AUTO_RDONLY);



    if (!has_read_only) {

        read_only = BLOCKDEV_CHANGE_READ_ONLY_MODE_RETAIN;

    }



    switch (read_only) {

    case BLOCKDEV_CHANGE_READ_ONLY_MODE_RETAIN:

        break;



    case BLOCKDEV_CHANGE_READ_ONLY_MODE_READ_ONLY:

        bdrv_flags &= ~BDRV_O_RDWR;

        break;



    case BLOCKDEV_CHANGE_READ_ONLY_MODE_READ_WRITE:

        bdrv_flags |= BDRV_O_RDWR;

        break;



    default:

        abort();

    }



    options = qdict_new();

    detect_zeroes = blk_get_detect_zeroes_from_root_state(blk);

    qdict_put_str(options, "detect-zeroes", detect_zeroes ? "on" : "off");



    if (has_format) {

        qdict_put_str(options, "driver", format);

    }



    medium_bs = bdrv_open(filename, NULL, options, bdrv_flags, errp);

    if (!medium_bs) {

        goto fail;

    }



    rc = do_open_tray(has_device ? device : NULL,

                      has_id ? id : NULL,

                      false, &err);

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

        error_propagate(errp, err);

        goto fail;

    }

    error_free(err);

    err = NULL;



    blockdev_remove_medium(has_device, device, has_id, id, &err);

    if (err) {

        error_propagate(errp, err);

        goto fail;

    }



    qmp_blockdev_insert_anon_medium(blk, medium_bs, &err);

    if (err) {

        error_propagate(errp, err);

        goto fail;

    }



    qmp_blockdev_close_tray(has_device, device, has_id, id, errp);



fail:

    /* If the medium has been inserted, the device has its own reference, so

     * ours must be relinquished; and if it has not been inserted successfully,

     * the reference must be relinquished anyway */

    bdrv_unref(medium_bs);

}



void qmp_eject(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) {

        error_propagate(errp, local_err);

        return;

    }

    error_free(local_err);



    blockdev_remove_medium(has_device, device, has_id, id, errp);

}



/* throttling disk I/O limits */

void qmp_block_set_io_throttle(BlockIOThrottle *arg, Error **errp)

{

    ThrottleConfig cfg;

    BlockDriverState *bs;

    BlockBackend *blk;

    AioContext *aio_context;



    blk = qmp_get_blk(arg->has_device ? arg->device : NULL,

                      arg->has_id ? arg->id : NULL,

                      errp);

    if (!blk) {

        return;

    }



    aio_context = blk_get_aio_context(blk);

    aio_context_acquire(aio_context);



    bs = blk_bs(blk);

    if (!bs) {

        error_setg(errp, "Device has no medium");

        goto out;

    }



    throttle_config_init(&cfg);

    cfg.buckets[THROTTLE_BPS_TOTAL].avg = arg->bps;

    cfg.buckets[THROTTLE_BPS_READ].avg  = arg->bps_rd;

    cfg.buckets[THROTTLE_BPS_WRITE].avg = arg->bps_wr;



    cfg.buckets[THROTTLE_OPS_TOTAL].avg = arg->iops;

    cfg.buckets[THROTTLE_OPS_READ].avg  = arg->iops_rd;

    cfg.buckets[THROTTLE_OPS_WRITE].avg = arg->iops_wr;



    if (arg->has_bps_max) {

        cfg.buckets[THROTTLE_BPS_TOTAL].max = arg->bps_max;

    }

    if (arg->has_bps_rd_max) {

        cfg.buckets[THROTTLE_BPS_READ].max = arg->bps_rd_max;

    }

    if (arg->has_bps_wr_max) {

        cfg.buckets[THROTTLE_BPS_WRITE].max = arg->bps_wr_max;

    }

    if (arg->has_iops_max) {

        cfg.buckets[THROTTLE_OPS_TOTAL].max = arg->iops_max;

    }

    if (arg->has_iops_rd_max) {

        cfg.buckets[THROTTLE_OPS_READ].max = arg->iops_rd_max;

    }

    if (arg->has_iops_wr_max) {

        cfg.buckets[THROTTLE_OPS_WRITE].max = arg->iops_wr_max;

    }



    if (arg->has_bps_max_length) {

        cfg.buckets[THROTTLE_BPS_TOTAL].burst_length = arg->bps_max_length;

    }

    if (arg->has_bps_rd_max_length) {

        cfg.buckets[THROTTLE_BPS_READ].burst_length = arg->bps_rd_max_length;

    }

    if (arg->has_bps_wr_max_length) {

        cfg.buckets[THROTTLE_BPS_WRITE].burst_length = arg->bps_wr_max_length;

    }

    if (arg->has_iops_max_length) {

        cfg.buckets[THROTTLE_OPS_TOTAL].burst_length = arg->iops_max_length;

    }

    if (arg->has_iops_rd_max_length) {

        cfg.buckets[THROTTLE_OPS_READ].burst_length = arg->iops_rd_max_length;

    }

    if (arg->has_iops_wr_max_length) {

        cfg.buckets[THROTTLE_OPS_WRITE].burst_length = arg->iops_wr_max_length;

    }



    if (arg->has_iops_size) {

        cfg.op_size = arg->iops_size;

    }



    if (!throttle_is_valid(&cfg, errp)) {

        goto out;

    }



    if (throttle_enabled(&cfg)) {

        /* Enable I/O limits if they're not enabled yet, otherwise

         * just update the throttling group. */

        if (!blk_get_public(blk)->throttle_group_member.throttle_state) {

            blk_io_limits_enable(blk,

                                 arg->has_group ? arg->group :

                                 arg->has_device ? arg->device :

                                 arg->id);

        } else if (arg->has_group) {

            blk_io_limits_update_group(blk, arg->group);

        }

        /* Set the new throttling configuration */

        blk_set_io_limits(blk, &cfg);

    } else if (blk_get_public(blk)->throttle_group_member.throttle_state) {

        /* If all throttling settings are set to 0, disable I/O limits */

        blk_io_limits_disable(blk);

    }



out:

    aio_context_release(aio_context);

}



void qmp_block_latency_histogram_set(

    const char *id,

    bool has_boundaries, uint64List *boundaries,

    bool has_boundaries_read, uint64List *boundaries_read,

    bool has_boundaries_write, uint64List *boundaries_write,

    bool has_boundaries_flush, uint64List *boundaries_flush,

    Error **errp)

{

    BlockBackend *blk = qmp_get_blk(NULL, id, errp);

    BlockAcctStats *stats;

    int ret;



    if (!blk) {

        return;

    }



    stats = blk_get_stats(blk);



    if (!has_boundaries && !has_boundaries_read && !has_boundaries_write &&

        !has_boundaries_flush)

    {

        block_latency_histograms_clear(stats);

        return;

    }



    if (has_boundaries || has_boundaries_read) {

        ret = block_latency_histogram_set(

            stats, BLOCK_ACCT_READ,

            has_boundaries_read ? boundaries_read : boundaries);

        if (ret) {

            error_setg(errp, "Device '%s' set read boundaries fail", id);

            return;

        }

    }



    if (has_boundaries || has_boundaries_write) {

        ret = block_latency_histogram_set(

            stats, BLOCK_ACCT_WRITE,

            has_boundaries_write ? boundaries_write : boundaries);

        if (ret) {

            error_setg(errp, "Device '%s' set write boundaries fail", id);

            return;

        }

    }



    if (has_boundaries || has_boundaries_flush) {

        ret = block_latency_histogram_set(

            stats, BLOCK_ACCT_FLUSH,

            has_boundaries_flush ? boundaries_flush : boundaries);

        if (ret) {

            error_setg(errp, "Device '%s' set flush boundaries fail", id);

            return;

        }

    }

}