Merge remote-tracking branch 'remotes/armbru/tags/pull-qobject-2020-11-17' into staging
[qemu/ar7.git] / block / block-backend.c
blobce78d30794ade042fa9f1b8d2b68284f29ed5a15
1 /*
2 * QEMU Block backends
4 * Copyright (C) 2014-2016 Red Hat, Inc.
6 * Authors:
7 * Markus Armbruster <armbru@redhat.com>,
9 * This work is licensed under the terms of the GNU LGPL, version 2.1
10 * or later. See the COPYING.LIB file in the top-level directory.
13 #include "qemu/osdep.h"
14 #include "sysemu/block-backend.h"
15 #include "block/block_int.h"
16 #include "block/blockjob.h"
17 #include "block/throttle-groups.h"
18 #include "hw/qdev-core.h"
19 #include "sysemu/blockdev.h"
20 #include "sysemu/runstate.h"
21 #include "sysemu/sysemu.h"
22 #include "sysemu/replay.h"
23 #include "qapi/error.h"
24 #include "qapi/qapi-events-block.h"
25 #include "qemu/id.h"
26 #include "qemu/main-loop.h"
27 #include "qemu/option.h"
28 #include "trace.h"
29 #include "migration/misc.h"
31 /* Number of coroutines to reserve per attached device model */
32 #define COROUTINE_POOL_RESERVATION 64
34 #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
36 static AioContext *blk_aiocb_get_aio_context(BlockAIOCB *acb);
38 typedef struct BlockBackendAioNotifier {
39 void (*attached_aio_context)(AioContext *new_context, void *opaque);
40 void (*detach_aio_context)(void *opaque);
41 void *opaque;
42 QLIST_ENTRY(BlockBackendAioNotifier) list;
43 } BlockBackendAioNotifier;
45 struct BlockBackend {
46 char *name;
47 int refcnt;
48 BdrvChild *root;
49 AioContext *ctx;
50 DriveInfo *legacy_dinfo; /* null unless created by drive_new() */
51 QTAILQ_ENTRY(BlockBackend) link; /* for block_backends */
52 QTAILQ_ENTRY(BlockBackend) monitor_link; /* for monitor_block_backends */
53 BlockBackendPublic public;
55 DeviceState *dev; /* attached device model, if any */
56 const BlockDevOps *dev_ops;
57 void *dev_opaque;
59 /* the block size for which the guest device expects atomicity */
60 int guest_block_size;
62 /* If the BDS tree is removed, some of its options are stored here (which
63 * can be used to restore those options in the new BDS on insert) */
64 BlockBackendRootState root_state;
66 bool enable_write_cache;
68 /* I/O stats (display with "info blockstats"). */
69 BlockAcctStats stats;
71 BlockdevOnError on_read_error, on_write_error;
72 bool iostatus_enabled;
73 BlockDeviceIoStatus iostatus;
75 uint64_t perm;
76 uint64_t shared_perm;
77 bool disable_perm;
79 bool allow_aio_context_change;
80 bool allow_write_beyond_eof;
82 NotifierList remove_bs_notifiers, insert_bs_notifiers;
83 QLIST_HEAD(, BlockBackendAioNotifier) aio_notifiers;
85 int quiesce_counter;
86 CoQueue queued_requests;
87 bool disable_request_queuing;
89 VMChangeStateEntry *vmsh;
90 bool force_allow_inactivate;
92 /* Number of in-flight aio requests. BlockDriverState also counts
93 * in-flight requests but aio requests can exist even when blk->root is
94 * NULL, so we cannot rely on its counter for that case.
95 * Accessed with atomic ops.
97 unsigned int in_flight;
100 typedef struct BlockBackendAIOCB {
101 BlockAIOCB common;
102 BlockBackend *blk;
103 int ret;
104 } BlockBackendAIOCB;
106 static const AIOCBInfo block_backend_aiocb_info = {
107 .get_aio_context = blk_aiocb_get_aio_context,
108 .aiocb_size = sizeof(BlockBackendAIOCB),
111 static void drive_info_del(DriveInfo *dinfo);
112 static BlockBackend *bdrv_first_blk(BlockDriverState *bs);
114 /* All BlockBackends */
115 static QTAILQ_HEAD(, BlockBackend) block_backends =
116 QTAILQ_HEAD_INITIALIZER(block_backends);
118 /* All BlockBackends referenced by the monitor and which are iterated through by
119 * blk_next() */
120 static QTAILQ_HEAD(, BlockBackend) monitor_block_backends =
121 QTAILQ_HEAD_INITIALIZER(monitor_block_backends);
123 static void blk_root_inherit_options(BdrvChildRole role, bool parent_is_format,
124 int *child_flags, QDict *child_options,
125 int parent_flags, QDict *parent_options)
127 /* We're not supposed to call this function for root nodes */
128 abort();
130 static void blk_root_drained_begin(BdrvChild *child);
131 static bool blk_root_drained_poll(BdrvChild *child);
132 static void blk_root_drained_end(BdrvChild *child, int *drained_end_counter);
134 static void blk_root_change_media(BdrvChild *child, bool load);
135 static void blk_root_resize(BdrvChild *child);
137 static bool blk_root_can_set_aio_ctx(BdrvChild *child, AioContext *ctx,
138 GSList **ignore, Error **errp);
139 static void blk_root_set_aio_ctx(BdrvChild *child, AioContext *ctx,
140 GSList **ignore);
142 static char *blk_root_get_parent_desc(BdrvChild *child)
144 BlockBackend *blk = child->opaque;
145 char *dev_id;
147 if (blk->name) {
148 return g_strdup(blk->name);
151 dev_id = blk_get_attached_dev_id(blk);
152 if (*dev_id) {
153 return dev_id;
154 } else {
155 /* TODO Callback into the BB owner for something more detailed */
156 g_free(dev_id);
157 return g_strdup("a block device");
161 static const char *blk_root_get_name(BdrvChild *child)
163 return blk_name(child->opaque);
166 static void blk_vm_state_changed(void *opaque, int running, RunState state)
168 Error *local_err = NULL;
169 BlockBackend *blk = opaque;
171 if (state == RUN_STATE_INMIGRATE) {
172 return;
175 qemu_del_vm_change_state_handler(blk->vmsh);
176 blk->vmsh = NULL;
177 blk_set_perm(blk, blk->perm, blk->shared_perm, &local_err);
178 if (local_err) {
179 error_report_err(local_err);
184 * Notifies the user of the BlockBackend that migration has completed. qdev
185 * devices can tighten their permissions in response (specifically revoke
186 * shared write permissions that we needed for storage migration).
188 * If an error is returned, the VM cannot be allowed to be resumed.
190 static void blk_root_activate(BdrvChild *child, Error **errp)
192 BlockBackend *blk = child->opaque;
193 Error *local_err = NULL;
195 if (!blk->disable_perm) {
196 return;
199 blk->disable_perm = false;
201 blk_set_perm(blk, blk->perm, BLK_PERM_ALL, &local_err);
202 if (local_err) {
203 error_propagate(errp, local_err);
204 blk->disable_perm = true;
205 return;
208 if (runstate_check(RUN_STATE_INMIGRATE)) {
209 /* Activation can happen when migration process is still active, for
210 * example when nbd_server_add is called during non-shared storage
211 * migration. Defer the shared_perm update to migration completion. */
212 if (!blk->vmsh) {
213 blk->vmsh = qemu_add_vm_change_state_handler(blk_vm_state_changed,
214 blk);
216 return;
219 blk_set_perm(blk, blk->perm, blk->shared_perm, &local_err);
220 if (local_err) {
221 error_propagate(errp, local_err);
222 blk->disable_perm = true;
223 return;
227 void blk_set_force_allow_inactivate(BlockBackend *blk)
229 blk->force_allow_inactivate = true;
232 static bool blk_can_inactivate(BlockBackend *blk)
234 /* If it is a guest device, inactivate is ok. */
235 if (blk->dev || blk_name(blk)[0]) {
236 return true;
239 /* Inactivating means no more writes to the image can be done,
240 * even if those writes would be changes invisible to the
241 * guest. For block job BBs that satisfy this, we can just allow
242 * it. This is the case for mirror job source, which is required
243 * by libvirt non-shared block migration. */
244 if (!(blk->perm & (BLK_PERM_WRITE | BLK_PERM_WRITE_UNCHANGED))) {
245 return true;
248 return blk->force_allow_inactivate;
251 static int blk_root_inactivate(BdrvChild *child)
253 BlockBackend *blk = child->opaque;
255 if (blk->disable_perm) {
256 return 0;
259 if (!blk_can_inactivate(blk)) {
260 return -EPERM;
263 blk->disable_perm = true;
264 if (blk->root) {
265 bdrv_child_try_set_perm(blk->root, 0, BLK_PERM_ALL, &error_abort);
268 return 0;
271 static void blk_root_attach(BdrvChild *child)
273 BlockBackend *blk = child->opaque;
274 BlockBackendAioNotifier *notifier;
276 trace_blk_root_attach(child, blk, child->bs);
278 QLIST_FOREACH(notifier, &blk->aio_notifiers, list) {
279 bdrv_add_aio_context_notifier(child->bs,
280 notifier->attached_aio_context,
281 notifier->detach_aio_context,
282 notifier->opaque);
286 static void blk_root_detach(BdrvChild *child)
288 BlockBackend *blk = child->opaque;
289 BlockBackendAioNotifier *notifier;
291 trace_blk_root_detach(child, blk, child->bs);
293 QLIST_FOREACH(notifier, &blk->aio_notifiers, list) {
294 bdrv_remove_aio_context_notifier(child->bs,
295 notifier->attached_aio_context,
296 notifier->detach_aio_context,
297 notifier->opaque);
301 static const BdrvChildClass child_root = {
302 .inherit_options = blk_root_inherit_options,
304 .change_media = blk_root_change_media,
305 .resize = blk_root_resize,
306 .get_name = blk_root_get_name,
307 .get_parent_desc = blk_root_get_parent_desc,
309 .drained_begin = blk_root_drained_begin,
310 .drained_poll = blk_root_drained_poll,
311 .drained_end = blk_root_drained_end,
313 .activate = blk_root_activate,
314 .inactivate = blk_root_inactivate,
316 .attach = blk_root_attach,
317 .detach = blk_root_detach,
319 .can_set_aio_ctx = blk_root_can_set_aio_ctx,
320 .set_aio_ctx = blk_root_set_aio_ctx,
324 * Create a new BlockBackend with a reference count of one.
326 * @perm is a bitmasks of BLK_PERM_* constants which describes the permissions
327 * to request for a block driver node that is attached to this BlockBackend.
328 * @shared_perm is a bitmask which describes which permissions may be granted
329 * to other users of the attached node.
330 * Both sets of permissions can be changed later using blk_set_perm().
332 * Return the new BlockBackend on success, null on failure.
334 BlockBackend *blk_new(AioContext *ctx, uint64_t perm, uint64_t shared_perm)
336 BlockBackend *blk;
338 blk = g_new0(BlockBackend, 1);
339 blk->refcnt = 1;
340 blk->ctx = ctx;
341 blk->perm = perm;
342 blk->shared_perm = shared_perm;
343 blk_set_enable_write_cache(blk, true);
345 blk->on_read_error = BLOCKDEV_ON_ERROR_REPORT;
346 blk->on_write_error = BLOCKDEV_ON_ERROR_ENOSPC;
348 block_acct_init(&blk->stats);
350 qemu_co_queue_init(&blk->queued_requests);
351 notifier_list_init(&blk->remove_bs_notifiers);
352 notifier_list_init(&blk->insert_bs_notifiers);
353 QLIST_INIT(&blk->aio_notifiers);
355 QTAILQ_INSERT_TAIL(&block_backends, blk, link);
356 return blk;
360 * Create a new BlockBackend connected to an existing BlockDriverState.
362 * @perm is a bitmasks of BLK_PERM_* constants which describes the
363 * permissions to request for @bs that is attached to this
364 * BlockBackend. @shared_perm is a bitmask which describes which
365 * permissions may be granted to other users of the attached node.
366 * Both sets of permissions can be changed later using blk_set_perm().
368 * Return the new BlockBackend on success, null on failure.
370 BlockBackend *blk_new_with_bs(BlockDriverState *bs, uint64_t perm,
371 uint64_t shared_perm, Error **errp)
373 BlockBackend *blk = blk_new(bdrv_get_aio_context(bs), perm, shared_perm);
375 if (blk_insert_bs(blk, bs, errp) < 0) {
376 blk_unref(blk);
377 return NULL;
379 return blk;
383 * Creates a new BlockBackend, opens a new BlockDriverState, and connects both.
384 * The new BlockBackend is in the main AioContext.
386 * Just as with bdrv_open(), after having called this function the reference to
387 * @options belongs to the block layer (even on failure).
389 * TODO: Remove @filename and @flags; it should be possible to specify a whole
390 * BDS tree just by specifying the @options QDict (or @reference,
391 * alternatively). At the time of adding this function, this is not possible,
392 * though, so callers of this function have to be able to specify @filename and
393 * @flags.
395 BlockBackend *blk_new_open(const char *filename, const char *reference,
396 QDict *options, int flags, Error **errp)
398 BlockBackend *blk;
399 BlockDriverState *bs;
400 uint64_t perm = 0;
402 /* blk_new_open() is mainly used in .bdrv_create implementations and the
403 * tools where sharing isn't a concern because the BDS stays private, so we
404 * just request permission according to the flags.
406 * The exceptions are xen_disk and blockdev_init(); in these cases, the
407 * caller of blk_new_open() doesn't make use of the permissions, but they
408 * shouldn't hurt either. We can still share everything here because the
409 * guest devices will add their own blockers if they can't share. */
410 if ((flags & BDRV_O_NO_IO) == 0) {
411 perm |= BLK_PERM_CONSISTENT_READ;
412 if (flags & BDRV_O_RDWR) {
413 perm |= BLK_PERM_WRITE;
416 if (flags & BDRV_O_RESIZE) {
417 perm |= BLK_PERM_RESIZE;
420 blk = blk_new(qemu_get_aio_context(), perm, BLK_PERM_ALL);
421 bs = bdrv_open(filename, reference, options, flags, errp);
422 if (!bs) {
423 blk_unref(blk);
424 return NULL;
427 blk->root = bdrv_root_attach_child(bs, "root", &child_root,
428 BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY,
429 blk->ctx, perm, BLK_PERM_ALL, blk, errp);
430 if (!blk->root) {
431 blk_unref(blk);
432 return NULL;
435 return blk;
438 static void blk_delete(BlockBackend *blk)
440 assert(!blk->refcnt);
441 assert(!blk->name);
442 assert(!blk->dev);
443 if (blk->public.throttle_group_member.throttle_state) {
444 blk_io_limits_disable(blk);
446 if (blk->root) {
447 blk_remove_bs(blk);
449 if (blk->vmsh) {
450 qemu_del_vm_change_state_handler(blk->vmsh);
451 blk->vmsh = NULL;
453 assert(QLIST_EMPTY(&blk->remove_bs_notifiers.notifiers));
454 assert(QLIST_EMPTY(&blk->insert_bs_notifiers.notifiers));
455 assert(QLIST_EMPTY(&blk->aio_notifiers));
456 QTAILQ_REMOVE(&block_backends, blk, link);
457 drive_info_del(blk->legacy_dinfo);
458 block_acct_cleanup(&blk->stats);
459 g_free(blk);
462 static void drive_info_del(DriveInfo *dinfo)
464 if (!dinfo) {
465 return;
467 qemu_opts_del(dinfo->opts);
468 g_free(dinfo);
471 int blk_get_refcnt(BlockBackend *blk)
473 return blk ? blk->refcnt : 0;
477 * Increment @blk's reference count.
478 * @blk must not be null.
480 void blk_ref(BlockBackend *blk)
482 assert(blk->refcnt > 0);
483 blk->refcnt++;
487 * Decrement @blk's reference count.
488 * If this drops it to zero, destroy @blk.
489 * For convenience, do nothing if @blk is null.
491 void blk_unref(BlockBackend *blk)
493 if (blk) {
494 assert(blk->refcnt > 0);
495 if (blk->refcnt > 1) {
496 blk->refcnt--;
497 } else {
498 blk_drain(blk);
499 /* blk_drain() cannot resurrect blk, nobody held a reference */
500 assert(blk->refcnt == 1);
501 blk->refcnt = 0;
502 blk_delete(blk);
508 * Behaves similarly to blk_next() but iterates over all BlockBackends, even the
509 * ones which are hidden (i.e. are not referenced by the monitor).
511 BlockBackend *blk_all_next(BlockBackend *blk)
513 return blk ? QTAILQ_NEXT(blk, link)
514 : QTAILQ_FIRST(&block_backends);
517 void blk_remove_all_bs(void)
519 BlockBackend *blk = NULL;
521 while ((blk = blk_all_next(blk)) != NULL) {
522 AioContext *ctx = blk_get_aio_context(blk);
524 aio_context_acquire(ctx);
525 if (blk->root) {
526 blk_remove_bs(blk);
528 aio_context_release(ctx);
533 * Return the monitor-owned BlockBackend after @blk.
534 * If @blk is null, return the first one.
535 * Else, return @blk's next sibling, which may be null.
537 * To iterate over all BlockBackends, do
538 * for (blk = blk_next(NULL); blk; blk = blk_next(blk)) {
539 * ...
542 BlockBackend *blk_next(BlockBackend *blk)
544 return blk ? QTAILQ_NEXT(blk, monitor_link)
545 : QTAILQ_FIRST(&monitor_block_backends);
548 /* Iterates over all top-level BlockDriverStates, i.e. BDSs that are owned by
549 * the monitor or attached to a BlockBackend */
550 BlockDriverState *bdrv_next(BdrvNextIterator *it)
552 BlockDriverState *bs, *old_bs;
554 /* Must be called from the main loop */
555 assert(qemu_get_current_aio_context() == qemu_get_aio_context());
557 /* First, return all root nodes of BlockBackends. In order to avoid
558 * returning a BDS twice when multiple BBs refer to it, we only return it
559 * if the BB is the first one in the parent list of the BDS. */
560 if (it->phase == BDRV_NEXT_BACKEND_ROOTS) {
561 BlockBackend *old_blk = it->blk;
563 old_bs = old_blk ? blk_bs(old_blk) : NULL;
565 do {
566 it->blk = blk_all_next(it->blk);
567 bs = it->blk ? blk_bs(it->blk) : NULL;
568 } while (it->blk && (bs == NULL || bdrv_first_blk(bs) != it->blk));
570 if (it->blk) {
571 blk_ref(it->blk);
573 blk_unref(old_blk);
575 if (bs) {
576 bdrv_ref(bs);
577 bdrv_unref(old_bs);
578 return bs;
580 it->phase = BDRV_NEXT_MONITOR_OWNED;
581 } else {
582 old_bs = it->bs;
585 /* Then return the monitor-owned BDSes without a BB attached. Ignore all
586 * BDSes that are attached to a BlockBackend here; they have been handled
587 * by the above block already */
588 do {
589 it->bs = bdrv_next_monitor_owned(it->bs);
590 bs = it->bs;
591 } while (bs && bdrv_has_blk(bs));
593 if (bs) {
594 bdrv_ref(bs);
596 bdrv_unref(old_bs);
598 return bs;
601 static void bdrv_next_reset(BdrvNextIterator *it)
603 *it = (BdrvNextIterator) {
604 .phase = BDRV_NEXT_BACKEND_ROOTS,
608 BlockDriverState *bdrv_first(BdrvNextIterator *it)
610 bdrv_next_reset(it);
611 return bdrv_next(it);
614 /* Must be called when aborting a bdrv_next() iteration before
615 * bdrv_next() returns NULL */
616 void bdrv_next_cleanup(BdrvNextIterator *it)
618 /* Must be called from the main loop */
619 assert(qemu_get_current_aio_context() == qemu_get_aio_context());
621 if (it->phase == BDRV_NEXT_BACKEND_ROOTS) {
622 if (it->blk) {
623 bdrv_unref(blk_bs(it->blk));
624 blk_unref(it->blk);
626 } else {
627 bdrv_unref(it->bs);
630 bdrv_next_reset(it);
634 * Add a BlockBackend into the list of backends referenced by the monitor, with
635 * the given @name acting as the handle for the monitor.
636 * Strictly for use by blockdev.c.
638 * @name must not be null or empty.
640 * Returns true on success and false on failure. In the latter case, an Error
641 * object is returned through @errp.
643 bool monitor_add_blk(BlockBackend *blk, const char *name, Error **errp)
645 assert(!blk->name);
646 assert(name && name[0]);
648 if (!id_wellformed(name)) {
649 error_setg(errp, "Invalid device name");
650 return false;
652 if (blk_by_name(name)) {
653 error_setg(errp, "Device with id '%s' already exists", name);
654 return false;
656 if (bdrv_find_node(name)) {
657 error_setg(errp,
658 "Device name '%s' conflicts with an existing node name",
659 name);
660 return false;
663 blk->name = g_strdup(name);
664 QTAILQ_INSERT_TAIL(&monitor_block_backends, blk, monitor_link);
665 return true;
669 * Remove a BlockBackend from the list of backends referenced by the monitor.
670 * Strictly for use by blockdev.c.
672 void monitor_remove_blk(BlockBackend *blk)
674 if (!blk->name) {
675 return;
678 QTAILQ_REMOVE(&monitor_block_backends, blk, monitor_link);
679 g_free(blk->name);
680 blk->name = NULL;
684 * Return @blk's name, a non-null string.
685 * Returns an empty string iff @blk is not referenced by the monitor.
687 const char *blk_name(const BlockBackend *blk)
689 return blk->name ?: "";
693 * Return the BlockBackend with name @name if it exists, else null.
694 * @name must not be null.
696 BlockBackend *blk_by_name(const char *name)
698 BlockBackend *blk = NULL;
700 assert(name);
701 while ((blk = blk_next(blk)) != NULL) {
702 if (!strcmp(name, blk->name)) {
703 return blk;
706 return NULL;
710 * Return the BlockDriverState attached to @blk if any, else null.
712 BlockDriverState *blk_bs(BlockBackend *blk)
714 return blk->root ? blk->root->bs : NULL;
717 static BlockBackend *bdrv_first_blk(BlockDriverState *bs)
719 BdrvChild *child;
720 QLIST_FOREACH(child, &bs->parents, next_parent) {
721 if (child->klass == &child_root) {
722 return child->opaque;
726 return NULL;
730 * Returns true if @bs has an associated BlockBackend.
732 bool bdrv_has_blk(BlockDriverState *bs)
734 return bdrv_first_blk(bs) != NULL;
738 * Returns true if @bs has only BlockBackends as parents.
740 bool bdrv_is_root_node(BlockDriverState *bs)
742 BdrvChild *c;
744 QLIST_FOREACH(c, &bs->parents, next_parent) {
745 if (c->klass != &child_root) {
746 return false;
750 return true;
754 * Return @blk's DriveInfo if any, else null.
756 DriveInfo *blk_legacy_dinfo(BlockBackend *blk)
758 return blk->legacy_dinfo;
762 * Set @blk's DriveInfo to @dinfo, and return it.
763 * @blk must not have a DriveInfo set already.
764 * No other BlockBackend may have the same DriveInfo set.
766 DriveInfo *blk_set_legacy_dinfo(BlockBackend *blk, DriveInfo *dinfo)
768 assert(!blk->legacy_dinfo);
769 return blk->legacy_dinfo = dinfo;
773 * Return the BlockBackend with DriveInfo @dinfo.
774 * It must exist.
776 BlockBackend *blk_by_legacy_dinfo(DriveInfo *dinfo)
778 BlockBackend *blk = NULL;
780 while ((blk = blk_next(blk)) != NULL) {
781 if (blk->legacy_dinfo == dinfo) {
782 return blk;
785 abort();
789 * Returns a pointer to the publicly accessible fields of @blk.
791 BlockBackendPublic *blk_get_public(BlockBackend *blk)
793 return &blk->public;
797 * Returns a BlockBackend given the associated @public fields.
799 BlockBackend *blk_by_public(BlockBackendPublic *public)
801 return container_of(public, BlockBackend, public);
805 * Disassociates the currently associated BlockDriverState from @blk.
807 void blk_remove_bs(BlockBackend *blk)
809 ThrottleGroupMember *tgm = &blk->public.throttle_group_member;
810 BlockDriverState *bs;
811 BdrvChild *root;
813 notifier_list_notify(&blk->remove_bs_notifiers, blk);
814 if (tgm->throttle_state) {
815 bs = blk_bs(blk);
816 bdrv_drained_begin(bs);
817 throttle_group_detach_aio_context(tgm);
818 throttle_group_attach_aio_context(tgm, qemu_get_aio_context());
819 bdrv_drained_end(bs);
822 blk_update_root_state(blk);
824 /* bdrv_root_unref_child() will cause blk->root to become stale and may
825 * switch to a completion coroutine later on. Let's drain all I/O here
826 * to avoid that and a potential QEMU crash.
828 blk_drain(blk);
829 root = blk->root;
830 blk->root = NULL;
831 bdrv_root_unref_child(root);
835 * Associates a new BlockDriverState with @blk.
837 int blk_insert_bs(BlockBackend *blk, BlockDriverState *bs, Error **errp)
839 ThrottleGroupMember *tgm = &blk->public.throttle_group_member;
840 bdrv_ref(bs);
841 blk->root = bdrv_root_attach_child(bs, "root", &child_root,
842 BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY,
843 blk->ctx, blk->perm, blk->shared_perm,
844 blk, errp);
845 if (blk->root == NULL) {
846 return -EPERM;
849 notifier_list_notify(&blk->insert_bs_notifiers, blk);
850 if (tgm->throttle_state) {
851 throttle_group_detach_aio_context(tgm);
852 throttle_group_attach_aio_context(tgm, bdrv_get_aio_context(bs));
855 return 0;
859 * Sets the permission bitmasks that the user of the BlockBackend needs.
861 int blk_set_perm(BlockBackend *blk, uint64_t perm, uint64_t shared_perm,
862 Error **errp)
864 int ret;
866 if (blk->root && !blk->disable_perm) {
867 ret = bdrv_child_try_set_perm(blk->root, perm, shared_perm, errp);
868 if (ret < 0) {
869 return ret;
873 blk->perm = perm;
874 blk->shared_perm = shared_perm;
876 return 0;
879 void blk_get_perm(BlockBackend *blk, uint64_t *perm, uint64_t *shared_perm)
881 *perm = blk->perm;
882 *shared_perm = blk->shared_perm;
886 * Attach device model @dev to @blk.
887 * Return 0 on success, -EBUSY when a device model is attached already.
889 int blk_attach_dev(BlockBackend *blk, DeviceState *dev)
891 if (blk->dev) {
892 return -EBUSY;
895 /* While migration is still incoming, we don't need to apply the
896 * permissions of guest device BlockBackends. We might still have a block
897 * job or NBD server writing to the image for storage migration. */
898 if (runstate_check(RUN_STATE_INMIGRATE)) {
899 blk->disable_perm = true;
902 blk_ref(blk);
903 blk->dev = dev;
904 blk_iostatus_reset(blk);
906 return 0;
910 * Detach device model @dev from @blk.
911 * @dev must be currently attached to @blk.
913 void blk_detach_dev(BlockBackend *blk, DeviceState *dev)
915 assert(blk->dev == dev);
916 blk->dev = NULL;
917 blk->dev_ops = NULL;
918 blk->dev_opaque = NULL;
919 blk->guest_block_size = 512;
920 blk_set_perm(blk, 0, BLK_PERM_ALL, &error_abort);
921 blk_unref(blk);
925 * Return the device model attached to @blk if any, else null.
927 DeviceState *blk_get_attached_dev(BlockBackend *blk)
929 return blk->dev;
932 /* Return the qdev ID, or if no ID is assigned the QOM path, of the block
933 * device attached to the BlockBackend. */
934 char *blk_get_attached_dev_id(BlockBackend *blk)
936 DeviceState *dev = blk->dev;
938 if (!dev) {
939 return g_strdup("");
940 } else if (dev->id) {
941 return g_strdup(dev->id);
944 return object_get_canonical_path(OBJECT(dev)) ?: g_strdup("");
948 * Return the BlockBackend which has the device model @dev attached if it
949 * exists, else null.
951 * @dev must not be null.
953 BlockBackend *blk_by_dev(void *dev)
955 BlockBackend *blk = NULL;
957 assert(dev != NULL);
958 while ((blk = blk_all_next(blk)) != NULL) {
959 if (blk->dev == dev) {
960 return blk;
963 return NULL;
967 * Set @blk's device model callbacks to @ops.
968 * @opaque is the opaque argument to pass to the callbacks.
969 * This is for use by device models.
971 void blk_set_dev_ops(BlockBackend *blk, const BlockDevOps *ops,
972 void *opaque)
974 blk->dev_ops = ops;
975 blk->dev_opaque = opaque;
977 /* Are we currently quiesced? Should we enforce this right now? */
978 if (blk->quiesce_counter && ops->drained_begin) {
979 ops->drained_begin(opaque);
984 * Notify @blk's attached device model of media change.
986 * If @load is true, notify of media load. This action can fail, meaning that
987 * the medium cannot be loaded. @errp is set then.
989 * If @load is false, notify of media eject. This can never fail.
991 * Also send DEVICE_TRAY_MOVED events as appropriate.
993 void blk_dev_change_media_cb(BlockBackend *blk, bool load, Error **errp)
995 if (blk->dev_ops && blk->dev_ops->change_media_cb) {
996 bool tray_was_open, tray_is_open;
997 Error *local_err = NULL;
999 tray_was_open = blk_dev_is_tray_open(blk);
1000 blk->dev_ops->change_media_cb(blk->dev_opaque, load, &local_err);
1001 if (local_err) {
1002 assert(load == true);
1003 error_propagate(errp, local_err);
1004 return;
1006 tray_is_open = blk_dev_is_tray_open(blk);
1008 if (tray_was_open != tray_is_open) {
1009 char *id = blk_get_attached_dev_id(blk);
1010 qapi_event_send_device_tray_moved(blk_name(blk), id, tray_is_open);
1011 g_free(id);
1016 static void blk_root_change_media(BdrvChild *child, bool load)
1018 blk_dev_change_media_cb(child->opaque, load, NULL);
1022 * Does @blk's attached device model have removable media?
1023 * %true if no device model is attached.
1025 bool blk_dev_has_removable_media(BlockBackend *blk)
1027 return !blk->dev || (blk->dev_ops && blk->dev_ops->change_media_cb);
1031 * Does @blk's attached device model have a tray?
1033 bool blk_dev_has_tray(BlockBackend *blk)
1035 return blk->dev_ops && blk->dev_ops->is_tray_open;
1039 * Notify @blk's attached device model of a media eject request.
1040 * If @force is true, the medium is about to be yanked out forcefully.
1042 void blk_dev_eject_request(BlockBackend *blk, bool force)
1044 if (blk->dev_ops && blk->dev_ops->eject_request_cb) {
1045 blk->dev_ops->eject_request_cb(blk->dev_opaque, force);
1050 * Does @blk's attached device model have a tray, and is it open?
1052 bool blk_dev_is_tray_open(BlockBackend *blk)
1054 if (blk_dev_has_tray(blk)) {
1055 return blk->dev_ops->is_tray_open(blk->dev_opaque);
1057 return false;
1061 * Does @blk's attached device model have the medium locked?
1062 * %false if the device model has no such lock.
1064 bool blk_dev_is_medium_locked(BlockBackend *blk)
1066 if (blk->dev_ops && blk->dev_ops->is_medium_locked) {
1067 return blk->dev_ops->is_medium_locked(blk->dev_opaque);
1069 return false;
1073 * Notify @blk's attached device model of a backend size change.
1075 static void blk_root_resize(BdrvChild *child)
1077 BlockBackend *blk = child->opaque;
1079 if (blk->dev_ops && blk->dev_ops->resize_cb) {
1080 blk->dev_ops->resize_cb(blk->dev_opaque);
1084 void blk_iostatus_enable(BlockBackend *blk)
1086 blk->iostatus_enabled = true;
1087 blk->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
1090 /* The I/O status is only enabled if the drive explicitly
1091 * enables it _and_ the VM is configured to stop on errors */
1092 bool blk_iostatus_is_enabled(const BlockBackend *blk)
1094 return (blk->iostatus_enabled &&
1095 (blk->on_write_error == BLOCKDEV_ON_ERROR_ENOSPC ||
1096 blk->on_write_error == BLOCKDEV_ON_ERROR_STOP ||
1097 blk->on_read_error == BLOCKDEV_ON_ERROR_STOP));
1100 BlockDeviceIoStatus blk_iostatus(const BlockBackend *blk)
1102 return blk->iostatus;
1105 void blk_iostatus_disable(BlockBackend *blk)
1107 blk->iostatus_enabled = false;
1110 void blk_iostatus_reset(BlockBackend *blk)
1112 if (blk_iostatus_is_enabled(blk)) {
1113 blk->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
1117 void blk_iostatus_set_err(BlockBackend *blk, int error)
1119 assert(blk_iostatus_is_enabled(blk));
1120 if (blk->iostatus == BLOCK_DEVICE_IO_STATUS_OK) {
1121 blk->iostatus = error == ENOSPC ? BLOCK_DEVICE_IO_STATUS_NOSPACE :
1122 BLOCK_DEVICE_IO_STATUS_FAILED;
1126 void blk_set_allow_write_beyond_eof(BlockBackend *blk, bool allow)
1128 blk->allow_write_beyond_eof = allow;
1131 void blk_set_allow_aio_context_change(BlockBackend *blk, bool allow)
1133 blk->allow_aio_context_change = allow;
1136 void blk_set_disable_request_queuing(BlockBackend *blk, bool disable)
1138 blk->disable_request_queuing = disable;
1141 static int blk_check_byte_request(BlockBackend *blk, int64_t offset,
1142 size_t size)
1144 int64_t len;
1146 if (size > INT_MAX) {
1147 return -EIO;
1150 if (!blk_is_available(blk)) {
1151 return -ENOMEDIUM;
1154 if (offset < 0) {
1155 return -EIO;
1158 if (!blk->allow_write_beyond_eof) {
1159 len = blk_getlength(blk);
1160 if (len < 0) {
1161 return len;
1164 if (offset > len || len - offset < size) {
1165 return -EIO;
1169 return 0;
1172 /* To be called between exactly one pair of blk_inc/dec_in_flight() */
1173 static void coroutine_fn blk_wait_while_drained(BlockBackend *blk)
1175 assert(blk->in_flight > 0);
1177 if (blk->quiesce_counter && !blk->disable_request_queuing) {
1178 blk_dec_in_flight(blk);
1179 qemu_co_queue_wait(&blk->queued_requests, NULL);
1180 blk_inc_in_flight(blk);
1184 /* To be called between exactly one pair of blk_inc/dec_in_flight() */
1185 static int coroutine_fn
1186 blk_do_preadv(BlockBackend *blk, int64_t offset, unsigned int bytes,
1187 QEMUIOVector *qiov, BdrvRequestFlags flags)
1189 int ret;
1190 BlockDriverState *bs;
1192 blk_wait_while_drained(blk);
1194 /* Call blk_bs() only after waiting, the graph may have changed */
1195 bs = blk_bs(blk);
1196 trace_blk_co_preadv(blk, bs, offset, bytes, flags);
1198 ret = blk_check_byte_request(blk, offset, bytes);
1199 if (ret < 0) {
1200 return ret;
1203 bdrv_inc_in_flight(bs);
1205 /* throttling disk I/O */
1206 if (blk->public.throttle_group_member.throttle_state) {
1207 throttle_group_co_io_limits_intercept(&blk->public.throttle_group_member,
1208 bytes, false);
1211 ret = bdrv_co_preadv(blk->root, offset, bytes, qiov, flags);
1212 bdrv_dec_in_flight(bs);
1213 return ret;
1216 int coroutine_fn blk_co_preadv(BlockBackend *blk, int64_t offset,
1217 unsigned int bytes, QEMUIOVector *qiov,
1218 BdrvRequestFlags flags)
1220 int ret;
1222 blk_inc_in_flight(blk);
1223 ret = blk_do_preadv(blk, offset, bytes, qiov, flags);
1224 blk_dec_in_flight(blk);
1226 return ret;
1229 /* To be called between exactly one pair of blk_inc/dec_in_flight() */
1230 static int coroutine_fn
1231 blk_do_pwritev_part(BlockBackend *blk, int64_t offset, unsigned int bytes,
1232 QEMUIOVector *qiov, size_t qiov_offset,
1233 BdrvRequestFlags flags)
1235 int ret;
1236 BlockDriverState *bs;
1238 blk_wait_while_drained(blk);
1240 /* Call blk_bs() only after waiting, the graph may have changed */
1241 bs = blk_bs(blk);
1242 trace_blk_co_pwritev(blk, bs, offset, bytes, flags);
1244 ret = blk_check_byte_request(blk, offset, bytes);
1245 if (ret < 0) {
1246 return ret;
1249 bdrv_inc_in_flight(bs);
1250 /* throttling disk I/O */
1251 if (blk->public.throttle_group_member.throttle_state) {
1252 throttle_group_co_io_limits_intercept(&blk->public.throttle_group_member,
1253 bytes, true);
1256 if (!blk->enable_write_cache) {
1257 flags |= BDRV_REQ_FUA;
1260 ret = bdrv_co_pwritev_part(blk->root, offset, bytes, qiov, qiov_offset,
1261 flags);
1262 bdrv_dec_in_flight(bs);
1263 return ret;
1266 int coroutine_fn blk_co_pwritev_part(BlockBackend *blk, int64_t offset,
1267 unsigned int bytes,
1268 QEMUIOVector *qiov, size_t qiov_offset,
1269 BdrvRequestFlags flags)
1271 int ret;
1273 blk_inc_in_flight(blk);
1274 ret = blk_do_pwritev_part(blk, offset, bytes, qiov, qiov_offset, flags);
1275 blk_dec_in_flight(blk);
1277 return ret;
1280 int coroutine_fn blk_co_pwritev(BlockBackend *blk, int64_t offset,
1281 unsigned int bytes, QEMUIOVector *qiov,
1282 BdrvRequestFlags flags)
1284 return blk_co_pwritev_part(blk, offset, bytes, qiov, 0, flags);
1287 typedef struct BlkRwCo {
1288 BlockBackend *blk;
1289 int64_t offset;
1290 void *iobuf;
1291 int ret;
1292 BdrvRequestFlags flags;
1293 } BlkRwCo;
1295 static void blk_read_entry(void *opaque)
1297 BlkRwCo *rwco = opaque;
1298 QEMUIOVector *qiov = rwco->iobuf;
1300 rwco->ret = blk_do_preadv(rwco->blk, rwco->offset, qiov->size,
1301 qiov, rwco->flags);
1302 aio_wait_kick();
1305 static void blk_write_entry(void *opaque)
1307 BlkRwCo *rwco = opaque;
1308 QEMUIOVector *qiov = rwco->iobuf;
1310 rwco->ret = blk_do_pwritev_part(rwco->blk, rwco->offset, qiov->size,
1311 qiov, 0, rwco->flags);
1312 aio_wait_kick();
1315 static int blk_prw(BlockBackend *blk, int64_t offset, uint8_t *buf,
1316 int64_t bytes, CoroutineEntry co_entry,
1317 BdrvRequestFlags flags)
1319 QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
1320 BlkRwCo rwco = {
1321 .blk = blk,
1322 .offset = offset,
1323 .iobuf = &qiov,
1324 .flags = flags,
1325 .ret = NOT_DONE,
1328 blk_inc_in_flight(blk);
1329 if (qemu_in_coroutine()) {
1330 /* Fast-path if already in coroutine context */
1331 co_entry(&rwco);
1332 } else {
1333 Coroutine *co = qemu_coroutine_create(co_entry, &rwco);
1334 bdrv_coroutine_enter(blk_bs(blk), co);
1335 BDRV_POLL_WHILE(blk_bs(blk), rwco.ret == NOT_DONE);
1337 blk_dec_in_flight(blk);
1339 return rwco.ret;
1342 int blk_pwrite_zeroes(BlockBackend *blk, int64_t offset,
1343 int bytes, BdrvRequestFlags flags)
1345 return blk_prw(blk, offset, NULL, bytes, blk_write_entry,
1346 flags | BDRV_REQ_ZERO_WRITE);
1349 int blk_make_zero(BlockBackend *blk, BdrvRequestFlags flags)
1351 return bdrv_make_zero(blk->root, flags);
1354 void blk_inc_in_flight(BlockBackend *blk)
1356 qatomic_inc(&blk->in_flight);
1359 void blk_dec_in_flight(BlockBackend *blk)
1361 qatomic_dec(&blk->in_flight);
1362 aio_wait_kick();
1365 static void error_callback_bh(void *opaque)
1367 struct BlockBackendAIOCB *acb = opaque;
1369 blk_dec_in_flight(acb->blk);
1370 acb->common.cb(acb->common.opaque, acb->ret);
1371 qemu_aio_unref(acb);
1374 BlockAIOCB *blk_abort_aio_request(BlockBackend *blk,
1375 BlockCompletionFunc *cb,
1376 void *opaque, int ret)
1378 struct BlockBackendAIOCB *acb;
1380 blk_inc_in_flight(blk);
1381 acb = blk_aio_get(&block_backend_aiocb_info, blk, cb, opaque);
1382 acb->blk = blk;
1383 acb->ret = ret;
1385 replay_bh_schedule_oneshot_event(blk_get_aio_context(blk),
1386 error_callback_bh, acb);
1387 return &acb->common;
1390 typedef struct BlkAioEmAIOCB {
1391 BlockAIOCB common;
1392 BlkRwCo rwco;
1393 int bytes;
1394 bool has_returned;
1395 } BlkAioEmAIOCB;
1397 static AioContext *blk_aio_em_aiocb_get_aio_context(BlockAIOCB *acb_)
1399 BlkAioEmAIOCB *acb = container_of(acb_, BlkAioEmAIOCB, common);
1401 return blk_get_aio_context(acb->rwco.blk);
1404 static const AIOCBInfo blk_aio_em_aiocb_info = {
1405 .aiocb_size = sizeof(BlkAioEmAIOCB),
1406 .get_aio_context = blk_aio_em_aiocb_get_aio_context,
1409 static void blk_aio_complete(BlkAioEmAIOCB *acb)
1411 if (acb->has_returned) {
1412 acb->common.cb(acb->common.opaque, acb->rwco.ret);
1413 blk_dec_in_flight(acb->rwco.blk);
1414 qemu_aio_unref(acb);
1418 static void blk_aio_complete_bh(void *opaque)
1420 BlkAioEmAIOCB *acb = opaque;
1421 assert(acb->has_returned);
1422 blk_aio_complete(acb);
1425 static BlockAIOCB *blk_aio_prwv(BlockBackend *blk, int64_t offset, int bytes,
1426 void *iobuf, CoroutineEntry co_entry,
1427 BdrvRequestFlags flags,
1428 BlockCompletionFunc *cb, void *opaque)
1430 BlkAioEmAIOCB *acb;
1431 Coroutine *co;
1433 blk_inc_in_flight(blk);
1434 acb = blk_aio_get(&blk_aio_em_aiocb_info, blk, cb, opaque);
1435 acb->rwco = (BlkRwCo) {
1436 .blk = blk,
1437 .offset = offset,
1438 .iobuf = iobuf,
1439 .flags = flags,
1440 .ret = NOT_DONE,
1442 acb->bytes = bytes;
1443 acb->has_returned = false;
1445 co = qemu_coroutine_create(co_entry, acb);
1446 bdrv_coroutine_enter(blk_bs(blk), co);
1448 acb->has_returned = true;
1449 if (acb->rwco.ret != NOT_DONE) {
1450 replay_bh_schedule_oneshot_event(blk_get_aio_context(blk),
1451 blk_aio_complete_bh, acb);
1454 return &acb->common;
1457 static void blk_aio_read_entry(void *opaque)
1459 BlkAioEmAIOCB *acb = opaque;
1460 BlkRwCo *rwco = &acb->rwco;
1461 QEMUIOVector *qiov = rwco->iobuf;
1463 assert(qiov->size == acb->bytes);
1464 rwco->ret = blk_do_preadv(rwco->blk, rwco->offset, acb->bytes,
1465 qiov, rwco->flags);
1466 blk_aio_complete(acb);
1469 static void blk_aio_write_entry(void *opaque)
1471 BlkAioEmAIOCB *acb = opaque;
1472 BlkRwCo *rwco = &acb->rwco;
1473 QEMUIOVector *qiov = rwco->iobuf;
1475 assert(!qiov || qiov->size == acb->bytes);
1476 rwco->ret = blk_do_pwritev_part(rwco->blk, rwco->offset, acb->bytes,
1477 qiov, 0, rwco->flags);
1478 blk_aio_complete(acb);
1481 BlockAIOCB *blk_aio_pwrite_zeroes(BlockBackend *blk, int64_t offset,
1482 int count, BdrvRequestFlags flags,
1483 BlockCompletionFunc *cb, void *opaque)
1485 return blk_aio_prwv(blk, offset, count, NULL, blk_aio_write_entry,
1486 flags | BDRV_REQ_ZERO_WRITE, cb, opaque);
1489 int blk_pread(BlockBackend *blk, int64_t offset, void *buf, int count)
1491 int ret = blk_prw(blk, offset, buf, count, blk_read_entry, 0);
1492 if (ret < 0) {
1493 return ret;
1495 return count;
1498 int blk_pwrite(BlockBackend *blk, int64_t offset, const void *buf, int count,
1499 BdrvRequestFlags flags)
1501 int ret = blk_prw(blk, offset, (void *) buf, count, blk_write_entry,
1502 flags);
1503 if (ret < 0) {
1504 return ret;
1506 return count;
1509 int64_t blk_getlength(BlockBackend *blk)
1511 if (!blk_is_available(blk)) {
1512 return -ENOMEDIUM;
1515 return bdrv_getlength(blk_bs(blk));
1518 void blk_get_geometry(BlockBackend *blk, uint64_t *nb_sectors_ptr)
1520 if (!blk_bs(blk)) {
1521 *nb_sectors_ptr = 0;
1522 } else {
1523 bdrv_get_geometry(blk_bs(blk), nb_sectors_ptr);
1527 int64_t blk_nb_sectors(BlockBackend *blk)
1529 if (!blk_is_available(blk)) {
1530 return -ENOMEDIUM;
1533 return bdrv_nb_sectors(blk_bs(blk));
1536 BlockAIOCB *blk_aio_preadv(BlockBackend *blk, int64_t offset,
1537 QEMUIOVector *qiov, BdrvRequestFlags flags,
1538 BlockCompletionFunc *cb, void *opaque)
1540 return blk_aio_prwv(blk, offset, qiov->size, qiov,
1541 blk_aio_read_entry, flags, cb, opaque);
1544 BlockAIOCB *blk_aio_pwritev(BlockBackend *blk, int64_t offset,
1545 QEMUIOVector *qiov, BdrvRequestFlags flags,
1546 BlockCompletionFunc *cb, void *opaque)
1548 return blk_aio_prwv(blk, offset, qiov->size, qiov,
1549 blk_aio_write_entry, flags, cb, opaque);
1552 void blk_aio_cancel(BlockAIOCB *acb)
1554 bdrv_aio_cancel(acb);
1557 void blk_aio_cancel_async(BlockAIOCB *acb)
1559 bdrv_aio_cancel_async(acb);
1562 /* To be called between exactly one pair of blk_inc/dec_in_flight() */
1563 static int coroutine_fn
1564 blk_do_ioctl(BlockBackend *blk, unsigned long int req, void *buf)
1566 blk_wait_while_drained(blk);
1568 if (!blk_is_available(blk)) {
1569 return -ENOMEDIUM;
1572 return bdrv_co_ioctl(blk_bs(blk), req, buf);
1575 static void blk_ioctl_entry(void *opaque)
1577 BlkRwCo *rwco = opaque;
1578 QEMUIOVector *qiov = rwco->iobuf;
1580 rwco->ret = blk_do_ioctl(rwco->blk, rwco->offset, qiov->iov[0].iov_base);
1581 aio_wait_kick();
1584 int blk_ioctl(BlockBackend *blk, unsigned long int req, void *buf)
1586 return blk_prw(blk, req, buf, 0, blk_ioctl_entry, 0);
1589 static void blk_aio_ioctl_entry(void *opaque)
1591 BlkAioEmAIOCB *acb = opaque;
1592 BlkRwCo *rwco = &acb->rwco;
1594 rwco->ret = blk_do_ioctl(rwco->blk, rwco->offset, rwco->iobuf);
1596 blk_aio_complete(acb);
1599 BlockAIOCB *blk_aio_ioctl(BlockBackend *blk, unsigned long int req, void *buf,
1600 BlockCompletionFunc *cb, void *opaque)
1602 return blk_aio_prwv(blk, req, 0, buf, blk_aio_ioctl_entry, 0, cb, opaque);
1605 /* To be called between exactly one pair of blk_inc/dec_in_flight() */
1606 static int coroutine_fn
1607 blk_do_pdiscard(BlockBackend *blk, int64_t offset, int bytes)
1609 int ret;
1611 blk_wait_while_drained(blk);
1613 ret = blk_check_byte_request(blk, offset, bytes);
1614 if (ret < 0) {
1615 return ret;
1618 return bdrv_co_pdiscard(blk->root, offset, bytes);
1621 static void blk_aio_pdiscard_entry(void *opaque)
1623 BlkAioEmAIOCB *acb = opaque;
1624 BlkRwCo *rwco = &acb->rwco;
1626 rwco->ret = blk_do_pdiscard(rwco->blk, rwco->offset, acb->bytes);
1627 blk_aio_complete(acb);
1630 BlockAIOCB *blk_aio_pdiscard(BlockBackend *blk,
1631 int64_t offset, int bytes,
1632 BlockCompletionFunc *cb, void *opaque)
1634 return blk_aio_prwv(blk, offset, bytes, NULL, blk_aio_pdiscard_entry, 0,
1635 cb, opaque);
1638 int coroutine_fn blk_co_pdiscard(BlockBackend *blk, int64_t offset, int bytes)
1640 int ret;
1642 blk_inc_in_flight(blk);
1643 ret = blk_do_pdiscard(blk, offset, bytes);
1644 blk_dec_in_flight(blk);
1646 return ret;
1649 static void blk_pdiscard_entry(void *opaque)
1651 BlkRwCo *rwco = opaque;
1652 QEMUIOVector *qiov = rwco->iobuf;
1654 rwco->ret = blk_do_pdiscard(rwco->blk, rwco->offset, qiov->size);
1655 aio_wait_kick();
1658 int blk_pdiscard(BlockBackend *blk, int64_t offset, int bytes)
1660 return blk_prw(blk, offset, NULL, bytes, blk_pdiscard_entry, 0);
1663 /* To be called between exactly one pair of blk_inc/dec_in_flight() */
1664 static int coroutine_fn blk_do_flush(BlockBackend *blk)
1666 blk_wait_while_drained(blk);
1668 if (!blk_is_available(blk)) {
1669 return -ENOMEDIUM;
1672 return bdrv_co_flush(blk_bs(blk));
1675 static void blk_aio_flush_entry(void *opaque)
1677 BlkAioEmAIOCB *acb = opaque;
1678 BlkRwCo *rwco = &acb->rwco;
1680 rwco->ret = blk_do_flush(rwco->blk);
1681 blk_aio_complete(acb);
1684 BlockAIOCB *blk_aio_flush(BlockBackend *blk,
1685 BlockCompletionFunc *cb, void *opaque)
1687 return blk_aio_prwv(blk, 0, 0, NULL, blk_aio_flush_entry, 0, cb, opaque);
1690 int coroutine_fn blk_co_flush(BlockBackend *blk)
1692 int ret;
1694 blk_inc_in_flight(blk);
1695 ret = blk_do_flush(blk);
1696 blk_dec_in_flight(blk);
1698 return ret;
1701 static void blk_flush_entry(void *opaque)
1703 BlkRwCo *rwco = opaque;
1704 rwco->ret = blk_do_flush(rwco->blk);
1705 aio_wait_kick();
1708 int blk_flush(BlockBackend *blk)
1710 return blk_prw(blk, 0, NULL, 0, blk_flush_entry, 0);
1713 void blk_drain(BlockBackend *blk)
1715 BlockDriverState *bs = blk_bs(blk);
1717 if (bs) {
1718 bdrv_drained_begin(bs);
1721 /* We may have -ENOMEDIUM completions in flight */
1722 AIO_WAIT_WHILE(blk_get_aio_context(blk),
1723 qatomic_mb_read(&blk->in_flight) > 0);
1725 if (bs) {
1726 bdrv_drained_end(bs);
1730 void blk_drain_all(void)
1732 BlockBackend *blk = NULL;
1734 bdrv_drain_all_begin();
1736 while ((blk = blk_all_next(blk)) != NULL) {
1737 AioContext *ctx = blk_get_aio_context(blk);
1739 aio_context_acquire(ctx);
1741 /* We may have -ENOMEDIUM completions in flight */
1742 AIO_WAIT_WHILE(ctx, qatomic_mb_read(&blk->in_flight) > 0);
1744 aio_context_release(ctx);
1747 bdrv_drain_all_end();
1750 void blk_set_on_error(BlockBackend *blk, BlockdevOnError on_read_error,
1751 BlockdevOnError on_write_error)
1753 blk->on_read_error = on_read_error;
1754 blk->on_write_error = on_write_error;
1757 BlockdevOnError blk_get_on_error(BlockBackend *blk, bool is_read)
1759 return is_read ? blk->on_read_error : blk->on_write_error;
1762 BlockErrorAction blk_get_error_action(BlockBackend *blk, bool is_read,
1763 int error)
1765 BlockdevOnError on_err = blk_get_on_error(blk, is_read);
1767 switch (on_err) {
1768 case BLOCKDEV_ON_ERROR_ENOSPC:
1769 return (error == ENOSPC) ?
1770 BLOCK_ERROR_ACTION_STOP : BLOCK_ERROR_ACTION_REPORT;
1771 case BLOCKDEV_ON_ERROR_STOP:
1772 return BLOCK_ERROR_ACTION_STOP;
1773 case BLOCKDEV_ON_ERROR_REPORT:
1774 return BLOCK_ERROR_ACTION_REPORT;
1775 case BLOCKDEV_ON_ERROR_IGNORE:
1776 return BLOCK_ERROR_ACTION_IGNORE;
1777 case BLOCKDEV_ON_ERROR_AUTO:
1778 default:
1779 abort();
1783 static void send_qmp_error_event(BlockBackend *blk,
1784 BlockErrorAction action,
1785 bool is_read, int error)
1787 IoOperationType optype;
1788 BlockDriverState *bs = blk_bs(blk);
1790 optype = is_read ? IO_OPERATION_TYPE_READ : IO_OPERATION_TYPE_WRITE;
1791 qapi_event_send_block_io_error(blk_name(blk), !!bs,
1792 bs ? bdrv_get_node_name(bs) : NULL, optype,
1793 action, blk_iostatus_is_enabled(blk),
1794 error == ENOSPC, strerror(error));
1797 /* This is done by device models because, while the block layer knows
1798 * about the error, it does not know whether an operation comes from
1799 * the device or the block layer (from a job, for example).
1801 void blk_error_action(BlockBackend *blk, BlockErrorAction action,
1802 bool is_read, int error)
1804 assert(error >= 0);
1806 if (action == BLOCK_ERROR_ACTION_STOP) {
1807 /* First set the iostatus, so that "info block" returns an iostatus
1808 * that matches the events raised so far (an additional error iostatus
1809 * is fine, but not a lost one).
1811 blk_iostatus_set_err(blk, error);
1813 /* Then raise the request to stop the VM and the event.
1814 * qemu_system_vmstop_request_prepare has two effects. First,
1815 * it ensures that the STOP event always comes after the
1816 * BLOCK_IO_ERROR event. Second, it ensures that even if management
1817 * can observe the STOP event and do a "cont" before the STOP
1818 * event is issued, the VM will not stop. In this case, vm_start()
1819 * also ensures that the STOP/RESUME pair of events is emitted.
1821 qemu_system_vmstop_request_prepare();
1822 send_qmp_error_event(blk, action, is_read, error);
1823 qemu_system_vmstop_request(RUN_STATE_IO_ERROR);
1824 } else {
1825 send_qmp_error_event(blk, action, is_read, error);
1829 bool blk_is_read_only(BlockBackend *blk)
1831 BlockDriverState *bs = blk_bs(blk);
1833 if (bs) {
1834 return bdrv_is_read_only(bs);
1835 } else {
1836 return blk->root_state.read_only;
1840 bool blk_is_sg(BlockBackend *blk)
1842 BlockDriverState *bs = blk_bs(blk);
1844 if (!bs) {
1845 return false;
1848 return bdrv_is_sg(bs);
1851 bool blk_enable_write_cache(BlockBackend *blk)
1853 return blk->enable_write_cache;
1856 void blk_set_enable_write_cache(BlockBackend *blk, bool wce)
1858 blk->enable_write_cache = wce;
1861 void blk_invalidate_cache(BlockBackend *blk, Error **errp)
1863 BlockDriverState *bs = blk_bs(blk);
1865 if (!bs) {
1866 error_setg(errp, "Device '%s' has no medium", blk->name);
1867 return;
1870 bdrv_invalidate_cache(bs, errp);
1873 bool blk_is_inserted(BlockBackend *blk)
1875 BlockDriverState *bs = blk_bs(blk);
1877 return bs && bdrv_is_inserted(bs);
1880 bool blk_is_available(BlockBackend *blk)
1882 return blk_is_inserted(blk) && !blk_dev_is_tray_open(blk);
1885 void blk_lock_medium(BlockBackend *blk, bool locked)
1887 BlockDriverState *bs = blk_bs(blk);
1889 if (bs) {
1890 bdrv_lock_medium(bs, locked);
1894 void blk_eject(BlockBackend *blk, bool eject_flag)
1896 BlockDriverState *bs = blk_bs(blk);
1897 char *id;
1899 if (bs) {
1900 bdrv_eject(bs, eject_flag);
1903 /* Whether or not we ejected on the backend,
1904 * the frontend experienced a tray event. */
1905 id = blk_get_attached_dev_id(blk);
1906 qapi_event_send_device_tray_moved(blk_name(blk), id,
1907 eject_flag);
1908 g_free(id);
1911 int blk_get_flags(BlockBackend *blk)
1913 BlockDriverState *bs = blk_bs(blk);
1915 if (bs) {
1916 return bdrv_get_flags(bs);
1917 } else {
1918 return blk->root_state.open_flags;
1922 /* Returns the minimum request alignment, in bytes; guaranteed nonzero */
1923 uint32_t blk_get_request_alignment(BlockBackend *blk)
1925 BlockDriverState *bs = blk_bs(blk);
1926 return bs ? bs->bl.request_alignment : BDRV_SECTOR_SIZE;
1929 /* Returns the maximum transfer length, in bytes; guaranteed nonzero */
1930 uint32_t blk_get_max_transfer(BlockBackend *blk)
1932 BlockDriverState *bs = blk_bs(blk);
1933 uint32_t max = 0;
1935 if (bs) {
1936 max = bs->bl.max_transfer;
1938 return MIN_NON_ZERO(max, INT_MAX);
1941 int blk_get_max_iov(BlockBackend *blk)
1943 return blk->root->bs->bl.max_iov;
1946 void blk_set_guest_block_size(BlockBackend *blk, int align)
1948 blk->guest_block_size = align;
1951 void *blk_try_blockalign(BlockBackend *blk, size_t size)
1953 return qemu_try_blockalign(blk ? blk_bs(blk) : NULL, size);
1956 void *blk_blockalign(BlockBackend *blk, size_t size)
1958 return qemu_blockalign(blk ? blk_bs(blk) : NULL, size);
1961 bool blk_op_is_blocked(BlockBackend *blk, BlockOpType op, Error **errp)
1963 BlockDriverState *bs = blk_bs(blk);
1965 if (!bs) {
1966 return false;
1969 return bdrv_op_is_blocked(bs, op, errp);
1972 void blk_op_unblock(BlockBackend *blk, BlockOpType op, Error *reason)
1974 BlockDriverState *bs = blk_bs(blk);
1976 if (bs) {
1977 bdrv_op_unblock(bs, op, reason);
1981 void blk_op_block_all(BlockBackend *blk, Error *reason)
1983 BlockDriverState *bs = blk_bs(blk);
1985 if (bs) {
1986 bdrv_op_block_all(bs, reason);
1990 void blk_op_unblock_all(BlockBackend *blk, Error *reason)
1992 BlockDriverState *bs = blk_bs(blk);
1994 if (bs) {
1995 bdrv_op_unblock_all(bs, reason);
1999 AioContext *blk_get_aio_context(BlockBackend *blk)
2001 BlockDriverState *bs = blk_bs(blk);
2003 if (bs) {
2004 AioContext *ctx = bdrv_get_aio_context(blk_bs(blk));
2005 assert(ctx == blk->ctx);
2008 return blk->ctx;
2011 static AioContext *blk_aiocb_get_aio_context(BlockAIOCB *acb)
2013 BlockBackendAIOCB *blk_acb = DO_UPCAST(BlockBackendAIOCB, common, acb);
2014 return blk_get_aio_context(blk_acb->blk);
2017 static int blk_do_set_aio_context(BlockBackend *blk, AioContext *new_context,
2018 bool update_root_node, Error **errp)
2020 BlockDriverState *bs = blk_bs(blk);
2021 ThrottleGroupMember *tgm = &blk->public.throttle_group_member;
2022 int ret;
2024 if (bs) {
2025 if (update_root_node) {
2026 ret = bdrv_child_try_set_aio_context(bs, new_context, blk->root,
2027 errp);
2028 if (ret < 0) {
2029 return ret;
2032 if (tgm->throttle_state) {
2033 bdrv_drained_begin(bs);
2034 throttle_group_detach_aio_context(tgm);
2035 throttle_group_attach_aio_context(tgm, new_context);
2036 bdrv_drained_end(bs);
2040 blk->ctx = new_context;
2041 return 0;
2044 int blk_set_aio_context(BlockBackend *blk, AioContext *new_context,
2045 Error **errp)
2047 return blk_do_set_aio_context(blk, new_context, true, errp);
2050 static bool blk_root_can_set_aio_ctx(BdrvChild *child, AioContext *ctx,
2051 GSList **ignore, Error **errp)
2053 BlockBackend *blk = child->opaque;
2055 if (blk->allow_aio_context_change) {
2056 return true;
2059 /* Only manually created BlockBackends that are not attached to anything
2060 * can change their AioContext without updating their user. */
2061 if (!blk->name || blk->dev) {
2062 /* TODO Add BB name/QOM path */
2063 error_setg(errp, "Cannot change iothread of active block backend");
2064 return false;
2067 return true;
2070 static void blk_root_set_aio_ctx(BdrvChild *child, AioContext *ctx,
2071 GSList **ignore)
2073 BlockBackend *blk = child->opaque;
2074 blk_do_set_aio_context(blk, ctx, false, &error_abort);
2077 void blk_add_aio_context_notifier(BlockBackend *blk,
2078 void (*attached_aio_context)(AioContext *new_context, void *opaque),
2079 void (*detach_aio_context)(void *opaque), void *opaque)
2081 BlockBackendAioNotifier *notifier;
2082 BlockDriverState *bs = blk_bs(blk);
2084 notifier = g_new(BlockBackendAioNotifier, 1);
2085 notifier->attached_aio_context = attached_aio_context;
2086 notifier->detach_aio_context = detach_aio_context;
2087 notifier->opaque = opaque;
2088 QLIST_INSERT_HEAD(&blk->aio_notifiers, notifier, list);
2090 if (bs) {
2091 bdrv_add_aio_context_notifier(bs, attached_aio_context,
2092 detach_aio_context, opaque);
2096 void blk_remove_aio_context_notifier(BlockBackend *blk,
2097 void (*attached_aio_context)(AioContext *,
2098 void *),
2099 void (*detach_aio_context)(void *),
2100 void *opaque)
2102 BlockBackendAioNotifier *notifier;
2103 BlockDriverState *bs = blk_bs(blk);
2105 if (bs) {
2106 bdrv_remove_aio_context_notifier(bs, attached_aio_context,
2107 detach_aio_context, opaque);
2110 QLIST_FOREACH(notifier, &blk->aio_notifiers, list) {
2111 if (notifier->attached_aio_context == attached_aio_context &&
2112 notifier->detach_aio_context == detach_aio_context &&
2113 notifier->opaque == opaque) {
2114 QLIST_REMOVE(notifier, list);
2115 g_free(notifier);
2116 return;
2120 abort();
2123 void blk_add_remove_bs_notifier(BlockBackend *blk, Notifier *notify)
2125 notifier_list_add(&blk->remove_bs_notifiers, notify);
2128 void blk_add_insert_bs_notifier(BlockBackend *blk, Notifier *notify)
2130 notifier_list_add(&blk->insert_bs_notifiers, notify);
2133 void blk_io_plug(BlockBackend *blk)
2135 BlockDriverState *bs = blk_bs(blk);
2137 if (bs) {
2138 bdrv_io_plug(bs);
2142 void blk_io_unplug(BlockBackend *blk)
2144 BlockDriverState *bs = blk_bs(blk);
2146 if (bs) {
2147 bdrv_io_unplug(bs);
2151 BlockAcctStats *blk_get_stats(BlockBackend *blk)
2153 return &blk->stats;
2156 void *blk_aio_get(const AIOCBInfo *aiocb_info, BlockBackend *blk,
2157 BlockCompletionFunc *cb, void *opaque)
2159 return qemu_aio_get(aiocb_info, blk_bs(blk), cb, opaque);
2162 int coroutine_fn blk_co_pwrite_zeroes(BlockBackend *blk, int64_t offset,
2163 int bytes, BdrvRequestFlags flags)
2165 return blk_co_pwritev(blk, offset, bytes, NULL,
2166 flags | BDRV_REQ_ZERO_WRITE);
2169 int blk_pwrite_compressed(BlockBackend *blk, int64_t offset, const void *buf,
2170 int count)
2172 return blk_prw(blk, offset, (void *) buf, count, blk_write_entry,
2173 BDRV_REQ_WRITE_COMPRESSED);
2176 int blk_truncate(BlockBackend *blk, int64_t offset, bool exact,
2177 PreallocMode prealloc, BdrvRequestFlags flags, Error **errp)
2179 if (!blk_is_available(blk)) {
2180 error_setg(errp, "No medium inserted");
2181 return -ENOMEDIUM;
2184 return bdrv_truncate(blk->root, offset, exact, prealloc, flags, errp);
2187 int blk_save_vmstate(BlockBackend *blk, const uint8_t *buf,
2188 int64_t pos, int size)
2190 int ret;
2192 if (!blk_is_available(blk)) {
2193 return -ENOMEDIUM;
2196 ret = bdrv_save_vmstate(blk_bs(blk), buf, pos, size);
2197 if (ret < 0) {
2198 return ret;
2201 if (ret == size && !blk->enable_write_cache) {
2202 ret = bdrv_flush(blk_bs(blk));
2205 return ret < 0 ? ret : size;
2208 int blk_load_vmstate(BlockBackend *blk, uint8_t *buf, int64_t pos, int size)
2210 if (!blk_is_available(blk)) {
2211 return -ENOMEDIUM;
2214 return bdrv_load_vmstate(blk_bs(blk), buf, pos, size);
2217 int blk_probe_blocksizes(BlockBackend *blk, BlockSizes *bsz)
2219 if (!blk_is_available(blk)) {
2220 return -ENOMEDIUM;
2223 return bdrv_probe_blocksizes(blk_bs(blk), bsz);
2226 int blk_probe_geometry(BlockBackend *blk, HDGeometry *geo)
2228 if (!blk_is_available(blk)) {
2229 return -ENOMEDIUM;
2232 return bdrv_probe_geometry(blk_bs(blk), geo);
2236 * Updates the BlockBackendRootState object with data from the currently
2237 * attached BlockDriverState.
2239 void blk_update_root_state(BlockBackend *blk)
2241 assert(blk->root);
2243 blk->root_state.open_flags = blk->root->bs->open_flags;
2244 blk->root_state.read_only = blk->root->bs->read_only;
2245 blk->root_state.detect_zeroes = blk->root->bs->detect_zeroes;
2249 * Returns the detect-zeroes setting to be used for bdrv_open() of a
2250 * BlockDriverState which is supposed to inherit the root state.
2252 bool blk_get_detect_zeroes_from_root_state(BlockBackend *blk)
2254 return blk->root_state.detect_zeroes;
2258 * Returns the flags to be used for bdrv_open() of a BlockDriverState which is
2259 * supposed to inherit the root state.
2261 int blk_get_open_flags_from_root_state(BlockBackend *blk)
2263 int bs_flags;
2265 bs_flags = blk->root_state.read_only ? 0 : BDRV_O_RDWR;
2266 bs_flags |= blk->root_state.open_flags & ~BDRV_O_RDWR;
2268 return bs_flags;
2271 BlockBackendRootState *blk_get_root_state(BlockBackend *blk)
2273 return &blk->root_state;
2276 int blk_commit_all(void)
2278 BlockBackend *blk = NULL;
2280 while ((blk = blk_all_next(blk)) != NULL) {
2281 AioContext *aio_context = blk_get_aio_context(blk);
2282 BlockDriverState *unfiltered_bs = bdrv_skip_filters(blk_bs(blk));
2284 aio_context_acquire(aio_context);
2285 if (blk_is_inserted(blk) && bdrv_cow_child(unfiltered_bs)) {
2286 int ret;
2288 ret = bdrv_commit(unfiltered_bs);
2289 if (ret < 0) {
2290 aio_context_release(aio_context);
2291 return ret;
2294 aio_context_release(aio_context);
2296 return 0;
2300 /* throttling disk I/O limits */
2301 void blk_set_io_limits(BlockBackend *blk, ThrottleConfig *cfg)
2303 throttle_group_config(&blk->public.throttle_group_member, cfg);
2306 void blk_io_limits_disable(BlockBackend *blk)
2308 BlockDriverState *bs = blk_bs(blk);
2309 ThrottleGroupMember *tgm = &blk->public.throttle_group_member;
2310 assert(tgm->throttle_state);
2311 if (bs) {
2312 bdrv_drained_begin(bs);
2314 throttle_group_unregister_tgm(tgm);
2315 if (bs) {
2316 bdrv_drained_end(bs);
2320 /* should be called before blk_set_io_limits if a limit is set */
2321 void blk_io_limits_enable(BlockBackend *blk, const char *group)
2323 assert(!blk->public.throttle_group_member.throttle_state);
2324 throttle_group_register_tgm(&blk->public.throttle_group_member,
2325 group, blk_get_aio_context(blk));
2328 void blk_io_limits_update_group(BlockBackend *blk, const char *group)
2330 /* this BB is not part of any group */
2331 if (!blk->public.throttle_group_member.throttle_state) {
2332 return;
2335 /* this BB is a part of the same group than the one we want */
2336 if (!g_strcmp0(throttle_group_get_name(&blk->public.throttle_group_member),
2337 group)) {
2338 return;
2341 /* need to change the group this bs belong to */
2342 blk_io_limits_disable(blk);
2343 blk_io_limits_enable(blk, group);
2346 static void blk_root_drained_begin(BdrvChild *child)
2348 BlockBackend *blk = child->opaque;
2349 ThrottleGroupMember *tgm = &blk->public.throttle_group_member;
2351 if (++blk->quiesce_counter == 1) {
2352 if (blk->dev_ops && blk->dev_ops->drained_begin) {
2353 blk->dev_ops->drained_begin(blk->dev_opaque);
2357 /* Note that blk->root may not be accessible here yet if we are just
2358 * attaching to a BlockDriverState that is drained. Use child instead. */
2360 if (qatomic_fetch_inc(&tgm->io_limits_disabled) == 0) {
2361 throttle_group_restart_tgm(tgm);
2365 static bool blk_root_drained_poll(BdrvChild *child)
2367 BlockBackend *blk = child->opaque;
2368 assert(blk->quiesce_counter);
2369 return !!blk->in_flight;
2372 static void blk_root_drained_end(BdrvChild *child, int *drained_end_counter)
2374 BlockBackend *blk = child->opaque;
2375 assert(blk->quiesce_counter);
2377 assert(blk->public.throttle_group_member.io_limits_disabled);
2378 qatomic_dec(&blk->public.throttle_group_member.io_limits_disabled);
2380 if (--blk->quiesce_counter == 0) {
2381 if (blk->dev_ops && blk->dev_ops->drained_end) {
2382 blk->dev_ops->drained_end(blk->dev_opaque);
2384 while (qemu_co_enter_next(&blk->queued_requests, NULL)) {
2385 /* Resume all queued requests */
2390 void blk_register_buf(BlockBackend *blk, void *host, size_t size)
2392 bdrv_register_buf(blk_bs(blk), host, size);
2395 void blk_unregister_buf(BlockBackend *blk, void *host)
2397 bdrv_unregister_buf(blk_bs(blk), host);
2400 int coroutine_fn blk_co_copy_range(BlockBackend *blk_in, int64_t off_in,
2401 BlockBackend *blk_out, int64_t off_out,
2402 int bytes, BdrvRequestFlags read_flags,
2403 BdrvRequestFlags write_flags)
2405 int r;
2406 r = blk_check_byte_request(blk_in, off_in, bytes);
2407 if (r) {
2408 return r;
2410 r = blk_check_byte_request(blk_out, off_out, bytes);
2411 if (r) {
2412 return r;
2414 return bdrv_co_copy_range(blk_in->root, off_in,
2415 blk_out->root, off_out,
2416 bytes, read_flags, write_flags);
2419 const BdrvChild *blk_root(BlockBackend *blk)
2421 return blk->root;
2424 int blk_make_empty(BlockBackend *blk, Error **errp)
2426 if (!blk_is_available(blk)) {
2427 error_setg(errp, "No medium inserted");
2428 return -ENOMEDIUM;
2431 return bdrv_make_empty(blk->root, errp);