4 * Copyright (C) 2014-2016 Red Hat, Inc.
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/coroutines.h"
18 #include "block/throttle-groups.h"
19 #include "hw/qdev-core.h"
20 #include "sysemu/blockdev.h"
21 #include "sysemu/runstate.h"
22 #include "sysemu/replay.h"
23 #include "qapi/error.h"
24 #include "qapi/qapi-events-block.h"
26 #include "qemu/main-loop.h"
27 #include "qemu/option.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 typedef struct BlockBackendAioNotifier {
37 void (*attached_aio_context)(AioContext *new_context, void *opaque);
38 void (*detach_aio_context)(void *opaque);
40 QLIST_ENTRY(BlockBackendAioNotifier) list;
41 } BlockBackendAioNotifier;
48 DriveInfo *legacy_dinfo; /* null unless created by drive_new() */
49 QTAILQ_ENTRY(BlockBackend) link; /* for block_backends */
50 QTAILQ_ENTRY(BlockBackend) monitor_link; /* for monitor_block_backends */
51 BlockBackendPublic public;
53 DeviceState *dev; /* attached device model, if any */
54 const BlockDevOps *dev_ops;
57 /* If the BDS tree is removed, some of its options are stored here (which
58 * can be used to restore those options in the new BDS on insert) */
59 BlockBackendRootState root_state;
61 bool enable_write_cache;
63 /* I/O stats (display with "info blockstats"). */
66 BlockdevOnError on_read_error, on_write_error;
67 bool iostatus_enabled;
68 BlockDeviceIoStatus iostatus;
74 bool allow_aio_context_change;
75 bool allow_write_beyond_eof;
77 /* Protected by BQL */
78 NotifierList remove_bs_notifiers, insert_bs_notifiers;
79 QLIST_HEAD(, BlockBackendAioNotifier) aio_notifiers;
81 int quiesce_counter; /* atomic: written under BQL, read by other threads */
82 QemuMutex queued_requests_lock; /* protects queued_requests */
83 CoQueue queued_requests;
84 bool disable_request_queuing; /* atomic */
86 VMChangeStateEntry *vmsh;
87 bool force_allow_inactivate;
89 /* Number of in-flight aio requests. BlockDriverState also counts
90 * in-flight requests but aio requests can exist even when blk->root is
91 * NULL, so we cannot rely on its counter for that case.
92 * Accessed with atomic ops.
94 unsigned int in_flight;
97 typedef struct BlockBackendAIOCB {
103 static const AIOCBInfo block_backend_aiocb_info = {
104 .aiocb_size = sizeof(BlockBackendAIOCB),
107 static void drive_info_del(DriveInfo *dinfo);
108 static BlockBackend *bdrv_first_blk(BlockDriverState *bs);
110 /* All BlockBackends. Protected by BQL. */
111 static QTAILQ_HEAD(, BlockBackend) block_backends =
112 QTAILQ_HEAD_INITIALIZER(block_backends);
115 * All BlockBackends referenced by the monitor and which are iterated through by
116 * blk_next(). Protected by BQL.
118 static QTAILQ_HEAD(, BlockBackend) monitor_block_backends =
119 QTAILQ_HEAD_INITIALIZER(monitor_block_backends);
121 static int coroutine_mixed_fn GRAPH_RDLOCK
122 blk_set_perm_locked(BlockBackend *blk, uint64_t perm, uint64_t shared_perm,
125 static void blk_root_inherit_options(BdrvChildRole role, bool parent_is_format,
126 int *child_flags, QDict *child_options,
127 int parent_flags, QDict *parent_options)
129 /* We're not supposed to call this function for root nodes */
132 static void blk_root_drained_begin(BdrvChild *child);
133 static bool blk_root_drained_poll(BdrvChild *child);
134 static void blk_root_drained_end(BdrvChild *child);
136 static void blk_root_change_media(BdrvChild *child, bool load);
137 static void blk_root_resize(BdrvChild *child);
139 static bool blk_root_change_aio_ctx(BdrvChild *child, AioContext *ctx,
140 GHashTable *visited, Transaction *tran,
143 static char *blk_root_get_parent_desc(BdrvChild *child)
145 BlockBackend *blk = child->opaque;
146 g_autofree char *dev_id = NULL;
149 return g_strdup_printf("block device '%s'", blk->name);
152 dev_id = blk_get_attached_dev_id(blk);
154 return g_strdup_printf("block device '%s'", dev_id);
156 /* TODO Callback into the BB owner for something more detailed */
157 return g_strdup("an unnamed 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, bool running, RunState state)
168 Error *local_err = NULL;
169 BlockBackend *blk = opaque;
171 if (state == RUN_STATE_INMIGRATE) {
175 qemu_del_vm_change_state_handler(blk->vmsh);
177 blk_set_perm(blk, blk->perm, blk->shared_perm, &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 GRAPH_RDLOCK blk_root_activate(BdrvChild *child, Error **errp)
192 BlockBackend *blk = child->opaque;
193 Error *local_err = NULL;
194 uint64_t saved_shared_perm;
196 if (!blk->disable_perm) {
200 blk->disable_perm = false;
203 * blk->shared_perm contains the permissions we want to share once
204 * migration is really completely done. For now, we need to share
205 * all; but we also need to retain blk->shared_perm, which is
206 * overwritten by a successful blk_set_perm() call. Save it and
209 saved_shared_perm = blk->shared_perm;
211 blk_set_perm_locked(blk, blk->perm, BLK_PERM_ALL, &local_err);
213 error_propagate(errp, local_err);
214 blk->disable_perm = true;
217 blk->shared_perm = saved_shared_perm;
219 if (runstate_check(RUN_STATE_INMIGRATE)) {
220 /* Activation can happen when migration process is still active, for
221 * example when nbd_server_add is called during non-shared storage
222 * migration. Defer the shared_perm update to migration completion. */
224 blk->vmsh = qemu_add_vm_change_state_handler(blk_vm_state_changed,
230 blk_set_perm_locked(blk, blk->perm, blk->shared_perm, &local_err);
232 error_propagate(errp, local_err);
233 blk->disable_perm = true;
238 void blk_set_force_allow_inactivate(BlockBackend *blk)
241 blk->force_allow_inactivate = true;
244 static bool blk_can_inactivate(BlockBackend *blk)
246 /* If it is a guest device, inactivate is ok. */
247 if (blk->dev || blk_name(blk)[0]) {
251 /* Inactivating means no more writes to the image can be done,
252 * even if those writes would be changes invisible to the
253 * guest. For block job BBs that satisfy this, we can just allow
254 * it. This is the case for mirror job source, which is required
255 * by libvirt non-shared block migration. */
256 if (!(blk->perm & (BLK_PERM_WRITE | BLK_PERM_WRITE_UNCHANGED))) {
260 return blk->force_allow_inactivate;
263 static int GRAPH_RDLOCK blk_root_inactivate(BdrvChild *child)
265 BlockBackend *blk = child->opaque;
267 if (blk->disable_perm) {
271 if (!blk_can_inactivate(blk)) {
275 blk->disable_perm = true;
277 bdrv_child_try_set_perm(blk->root, 0, BLK_PERM_ALL, &error_abort);
283 static void blk_root_attach(BdrvChild *child)
285 BlockBackend *blk = child->opaque;
286 BlockBackendAioNotifier *notifier;
288 trace_blk_root_attach(child, blk, child->bs);
290 QLIST_FOREACH(notifier, &blk->aio_notifiers, list) {
291 bdrv_add_aio_context_notifier(child->bs,
292 notifier->attached_aio_context,
293 notifier->detach_aio_context,
298 static void blk_root_detach(BdrvChild *child)
300 BlockBackend *blk = child->opaque;
301 BlockBackendAioNotifier *notifier;
303 trace_blk_root_detach(child, blk, child->bs);
305 QLIST_FOREACH(notifier, &blk->aio_notifiers, list) {
306 bdrv_remove_aio_context_notifier(child->bs,
307 notifier->attached_aio_context,
308 notifier->detach_aio_context,
313 static AioContext *blk_root_get_parent_aio_context(BdrvChild *c)
315 BlockBackend *blk = c->opaque;
318 return blk_get_aio_context(blk);
321 static const BdrvChildClass child_root = {
322 .inherit_options = blk_root_inherit_options,
324 .change_media = blk_root_change_media,
325 .resize = blk_root_resize,
326 .get_name = blk_root_get_name,
327 .get_parent_desc = blk_root_get_parent_desc,
329 .drained_begin = blk_root_drained_begin,
330 .drained_poll = blk_root_drained_poll,
331 .drained_end = blk_root_drained_end,
333 .activate = blk_root_activate,
334 .inactivate = blk_root_inactivate,
336 .attach = blk_root_attach,
337 .detach = blk_root_detach,
339 .change_aio_ctx = blk_root_change_aio_ctx,
341 .get_parent_aio_context = blk_root_get_parent_aio_context,
345 * Create a new BlockBackend with a reference count of one.
347 * @perm is a bitmasks of BLK_PERM_* constants which describes the permissions
348 * to request for a block driver node that is attached to this BlockBackend.
349 * @shared_perm is a bitmask which describes which permissions may be granted
350 * to other users of the attached node.
351 * Both sets of permissions can be changed later using blk_set_perm().
353 * Return the new BlockBackend on success, null on failure.
355 BlockBackend *blk_new(AioContext *ctx, uint64_t perm, uint64_t shared_perm)
361 blk = g_new0(BlockBackend, 1);
365 blk->shared_perm = shared_perm;
366 blk_set_enable_write_cache(blk, true);
368 blk->on_read_error = BLOCKDEV_ON_ERROR_REPORT;
369 blk->on_write_error = BLOCKDEV_ON_ERROR_ENOSPC;
371 block_acct_init(&blk->stats);
373 qemu_mutex_init(&blk->queued_requests_lock);
374 qemu_co_queue_init(&blk->queued_requests);
375 notifier_list_init(&blk->remove_bs_notifiers);
376 notifier_list_init(&blk->insert_bs_notifiers);
377 QLIST_INIT(&blk->aio_notifiers);
379 QTAILQ_INSERT_TAIL(&block_backends, blk, link);
384 * Create a new BlockBackend connected to an existing BlockDriverState.
386 * @perm is a bitmasks of BLK_PERM_* constants which describes the
387 * permissions to request for @bs that is attached to this
388 * BlockBackend. @shared_perm is a bitmask which describes which
389 * permissions may be granted to other users of the attached node.
390 * Both sets of permissions can be changed later using blk_set_perm().
392 * Return the new BlockBackend on success, null on failure.
394 * Callers must hold the AioContext lock of @bs.
396 BlockBackend *blk_new_with_bs(BlockDriverState *bs, uint64_t perm,
397 uint64_t shared_perm, Error **errp)
399 BlockBackend *blk = blk_new(bdrv_get_aio_context(bs), perm, shared_perm);
403 if (blk_insert_bs(blk, bs, errp) < 0) {
411 * Creates a new BlockBackend, opens a new BlockDriverState, and connects both.
412 * By default, the new BlockBackend is in the main AioContext, but if the
413 * parameters connect it with any existing node in a different AioContext, it
414 * may end up there instead.
416 * Just as with bdrv_open(), after having called this function the reference to
417 * @options belongs to the block layer (even on failure).
419 * Called without holding an AioContext lock.
421 * TODO: Remove @filename and @flags; it should be possible to specify a whole
422 * BDS tree just by specifying the @options QDict (or @reference,
423 * alternatively). At the time of adding this function, this is not possible,
424 * though, so callers of this function have to be able to specify @filename and
427 BlockBackend *blk_new_open(const char *filename, const char *reference,
428 QDict *options, int flags, Error **errp)
431 BlockDriverState *bs;
434 uint64_t shared = BLK_PERM_ALL;
439 * blk_new_open() is mainly used in .bdrv_create implementations and the
440 * tools where sharing isn't a major concern because the BDS stays private
441 * and the file is generally not supposed to be used by a second process,
442 * so we just request permission according to the flags.
444 * The exceptions are xen_disk and blockdev_init(); in these cases, the
445 * caller of blk_new_open() doesn't make use of the permissions, but they
446 * shouldn't hurt either. We can still share everything here because the
447 * guest devices will add their own blockers if they can't share.
449 if ((flags & BDRV_O_NO_IO) == 0) {
450 perm |= BLK_PERM_CONSISTENT_READ;
451 if (flags & BDRV_O_RDWR) {
452 perm |= BLK_PERM_WRITE;
455 if (flags & BDRV_O_RESIZE) {
456 perm |= BLK_PERM_RESIZE;
458 if (flags & BDRV_O_NO_SHARE) {
459 shared = BLK_PERM_CONSISTENT_READ | BLK_PERM_WRITE_UNCHANGED;
462 aio_context_acquire(qemu_get_aio_context());
463 bs = bdrv_open(filename, reference, options, flags, errp);
464 aio_context_release(qemu_get_aio_context());
469 /* bdrv_open() could have moved bs to a different AioContext */
470 ctx = bdrv_get_aio_context(bs);
471 blk = blk_new(bdrv_get_aio_context(bs), perm, shared);
473 blk->shared_perm = shared;
475 aio_context_acquire(ctx);
476 blk_insert_bs(blk, bs, errp);
478 aio_context_release(ctx);
488 static void blk_delete(BlockBackend *blk)
490 assert(!blk->refcnt);
493 if (blk->public.throttle_group_member.throttle_state) {
494 blk_io_limits_disable(blk);
500 qemu_del_vm_change_state_handler(blk->vmsh);
503 assert(QLIST_EMPTY(&blk->remove_bs_notifiers.notifiers));
504 assert(QLIST_EMPTY(&blk->insert_bs_notifiers.notifiers));
505 assert(QLIST_EMPTY(&blk->aio_notifiers));
506 assert(qemu_co_queue_empty(&blk->queued_requests));
507 qemu_mutex_destroy(&blk->queued_requests_lock);
508 QTAILQ_REMOVE(&block_backends, blk, link);
509 drive_info_del(blk->legacy_dinfo);
510 block_acct_cleanup(&blk->stats);
514 static void drive_info_del(DriveInfo *dinfo)
519 qemu_opts_del(dinfo->opts);
523 int blk_get_refcnt(BlockBackend *blk)
526 return blk ? blk->refcnt : 0;
530 * Increment @blk's reference count.
531 * @blk must not be null.
533 void blk_ref(BlockBackend *blk)
535 assert(blk->refcnt > 0);
541 * Decrement @blk's reference count.
542 * If this drops it to zero, destroy @blk.
543 * For convenience, do nothing if @blk is null.
545 void blk_unref(BlockBackend *blk)
549 assert(blk->refcnt > 0);
550 if (blk->refcnt > 1) {
554 /* blk_drain() cannot resurrect blk, nobody held a reference */
555 assert(blk->refcnt == 1);
563 * Behaves similarly to blk_next() but iterates over all BlockBackends, even the
564 * ones which are hidden (i.e. are not referenced by the monitor).
566 BlockBackend *blk_all_next(BlockBackend *blk)
569 return blk ? QTAILQ_NEXT(blk, link)
570 : QTAILQ_FIRST(&block_backends);
573 void blk_remove_all_bs(void)
575 BlockBackend *blk = NULL;
579 while ((blk = blk_all_next(blk)) != NULL) {
580 AioContext *ctx = blk_get_aio_context(blk);
582 aio_context_acquire(ctx);
586 aio_context_release(ctx);
591 * Return the monitor-owned BlockBackend after @blk.
592 * If @blk is null, return the first one.
593 * Else, return @blk's next sibling, which may be null.
595 * To iterate over all BlockBackends, do
596 * for (blk = blk_next(NULL); blk; blk = blk_next(blk)) {
600 BlockBackend *blk_next(BlockBackend *blk)
603 return blk ? QTAILQ_NEXT(blk, monitor_link)
604 : QTAILQ_FIRST(&monitor_block_backends);
607 /* Iterates over all top-level BlockDriverStates, i.e. BDSs that are owned by
608 * the monitor or attached to a BlockBackend */
609 BlockDriverState *bdrv_next(BdrvNextIterator *it)
611 BlockDriverState *bs, *old_bs;
613 /* Must be called from the main loop */
614 assert(qemu_get_current_aio_context() == qemu_get_aio_context());
616 /* First, return all root nodes of BlockBackends. In order to avoid
617 * returning a BDS twice when multiple BBs refer to it, we only return it
618 * if the BB is the first one in the parent list of the BDS. */
619 if (it->phase == BDRV_NEXT_BACKEND_ROOTS) {
620 BlockBackend *old_blk = it->blk;
622 old_bs = old_blk ? blk_bs(old_blk) : NULL;
625 it->blk = blk_all_next(it->blk);
626 bs = it->blk ? blk_bs(it->blk) : NULL;
627 } while (it->blk && (bs == NULL || bdrv_first_blk(bs) != it->blk));
639 it->phase = BDRV_NEXT_MONITOR_OWNED;
644 /* Then return the monitor-owned BDSes without a BB attached. Ignore all
645 * BDSes that are attached to a BlockBackend here; they have been handled
646 * by the above block already */
648 it->bs = bdrv_next_monitor_owned(it->bs);
650 } while (bs && bdrv_has_blk(bs));
660 static void bdrv_next_reset(BdrvNextIterator *it)
662 *it = (BdrvNextIterator) {
663 .phase = BDRV_NEXT_BACKEND_ROOTS,
667 BlockDriverState *bdrv_first(BdrvNextIterator *it)
671 return bdrv_next(it);
674 /* Must be called when aborting a bdrv_next() iteration before
675 * bdrv_next() returns NULL */
676 void bdrv_next_cleanup(BdrvNextIterator *it)
678 /* Must be called from the main loop */
679 assert(qemu_get_current_aio_context() == qemu_get_aio_context());
681 if (it->phase == BDRV_NEXT_BACKEND_ROOTS) {
683 bdrv_unref(blk_bs(it->blk));
694 * Add a BlockBackend into the list of backends referenced by the monitor, with
695 * the given @name acting as the handle for the monitor.
696 * Strictly for use by blockdev.c.
698 * @name must not be null or empty.
700 * Returns true on success and false on failure. In the latter case, an Error
701 * object is returned through @errp.
703 bool monitor_add_blk(BlockBackend *blk, const char *name, Error **errp)
706 assert(name && name[0]);
709 if (!id_wellformed(name)) {
710 error_setg(errp, "Invalid device name");
713 if (blk_by_name(name)) {
714 error_setg(errp, "Device with id '%s' already exists", name);
717 if (bdrv_find_node(name)) {
719 "Device name '%s' conflicts with an existing node name",
724 blk->name = g_strdup(name);
725 QTAILQ_INSERT_TAIL(&monitor_block_backends, blk, monitor_link);
730 * Remove a BlockBackend from the list of backends referenced by the monitor.
731 * Strictly for use by blockdev.c.
733 void monitor_remove_blk(BlockBackend *blk)
741 QTAILQ_REMOVE(&monitor_block_backends, blk, monitor_link);
747 * Return @blk's name, a non-null string.
748 * Returns an empty string iff @blk is not referenced by the monitor.
750 const char *blk_name(const BlockBackend *blk)
753 return blk->name ?: "";
757 * Return the BlockBackend with name @name if it exists, else null.
758 * @name must not be null.
760 BlockBackend *blk_by_name(const char *name)
762 BlockBackend *blk = NULL;
766 while ((blk = blk_next(blk)) != NULL) {
767 if (!strcmp(name, blk->name)) {
775 * Return the BlockDriverState attached to @blk if any, else null.
777 BlockDriverState *blk_bs(BlockBackend *blk)
780 return blk->root ? blk->root->bs : NULL;
783 static BlockBackend * GRAPH_RDLOCK bdrv_first_blk(BlockDriverState *bs)
788 assert_bdrv_graph_readable();
790 QLIST_FOREACH(child, &bs->parents, next_parent) {
791 if (child->klass == &child_root) {
792 return child->opaque;
800 * Returns true if @bs has an associated BlockBackend.
802 bool bdrv_has_blk(BlockDriverState *bs)
805 return bdrv_first_blk(bs) != NULL;
809 * Returns true if @bs has only BlockBackends as parents.
811 bool bdrv_is_root_node(BlockDriverState *bs)
816 assert_bdrv_graph_readable();
818 QLIST_FOREACH(c, &bs->parents, next_parent) {
819 if (c->klass != &child_root) {
828 * Return @blk's DriveInfo if any, else null.
830 DriveInfo *blk_legacy_dinfo(BlockBackend *blk)
833 return blk->legacy_dinfo;
837 * Set @blk's DriveInfo to @dinfo, and return it.
838 * @blk must not have a DriveInfo set already.
839 * No other BlockBackend may have the same DriveInfo set.
841 DriveInfo *blk_set_legacy_dinfo(BlockBackend *blk, DriveInfo *dinfo)
843 assert(!blk->legacy_dinfo);
845 return blk->legacy_dinfo = dinfo;
849 * Return the BlockBackend with DriveInfo @dinfo.
852 BlockBackend *blk_by_legacy_dinfo(DriveInfo *dinfo)
854 BlockBackend *blk = NULL;
857 while ((blk = blk_next(blk)) != NULL) {
858 if (blk->legacy_dinfo == dinfo) {
866 * Returns a pointer to the publicly accessible fields of @blk.
868 BlockBackendPublic *blk_get_public(BlockBackend *blk)
875 * Returns a BlockBackend given the associated @public fields.
877 BlockBackend *blk_by_public(BlockBackendPublic *public)
880 return container_of(public, BlockBackend, public);
884 * Disassociates the currently associated BlockDriverState from @blk.
886 void blk_remove_bs(BlockBackend *blk)
888 ThrottleGroupMember *tgm = &blk->public.throttle_group_member;
893 notifier_list_notify(&blk->remove_bs_notifiers, blk);
894 if (tgm->throttle_state) {
895 BlockDriverState *bs = blk_bs(blk);
898 * Take a ref in case blk_bs() changes across bdrv_drained_begin(), for
899 * example, if a temporary filter node is removed by a blockjob.
902 bdrv_drained_begin(bs);
903 throttle_group_detach_aio_context(tgm);
904 throttle_group_attach_aio_context(tgm, qemu_get_aio_context());
905 bdrv_drained_end(bs);
909 blk_update_root_state(blk);
911 /* bdrv_root_unref_child() will cause blk->root to become stale and may
912 * switch to a completion coroutine later on. Let's drain all I/O here
913 * to avoid that and a potential QEMU crash.
919 bdrv_graph_wrlock(NULL);
920 bdrv_root_unref_child(root);
921 bdrv_graph_wrunlock();
925 * Associates a new BlockDriverState with @blk.
927 * Callers must hold the AioContext lock of @bs.
929 int blk_insert_bs(BlockBackend *blk, BlockDriverState *bs, Error **errp)
931 ThrottleGroupMember *tgm = &blk->public.throttle_group_member;
934 blk->root = bdrv_root_attach_child(bs, "root", &child_root,
935 BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY,
936 blk->perm, blk->shared_perm,
938 if (blk->root == NULL) {
942 notifier_list_notify(&blk->insert_bs_notifiers, blk);
943 if (tgm->throttle_state) {
944 throttle_group_detach_aio_context(tgm);
945 throttle_group_attach_aio_context(tgm, bdrv_get_aio_context(bs));
952 * Change BlockDriverState associated with @blk.
954 int blk_replace_bs(BlockBackend *blk, BlockDriverState *new_bs, Error **errp)
957 return bdrv_replace_child_bs(blk->root, new_bs, errp);
961 * Sets the permission bitmasks that the user of the BlockBackend needs.
963 static int coroutine_mixed_fn GRAPH_RDLOCK
964 blk_set_perm_locked(BlockBackend *blk, uint64_t perm, uint64_t shared_perm,
970 if (blk->root && !blk->disable_perm) {
971 ret = bdrv_child_try_set_perm(blk->root, perm, shared_perm, errp);
978 blk->shared_perm = shared_perm;
983 int blk_set_perm(BlockBackend *blk, uint64_t perm, uint64_t shared_perm,
987 GRAPH_RDLOCK_GUARD_MAINLOOP();
989 return blk_set_perm_locked(blk, perm, shared_perm, errp);
992 void blk_get_perm(BlockBackend *blk, uint64_t *perm, uint64_t *shared_perm)
996 *shared_perm = blk->shared_perm;
1000 * Attach device model @dev to @blk.
1001 * Return 0 on success, -EBUSY when a device model is attached already.
1003 int blk_attach_dev(BlockBackend *blk, DeviceState *dev)
1005 GLOBAL_STATE_CODE();
1010 /* While migration is still incoming, we don't need to apply the
1011 * permissions of guest device BlockBackends. We might still have a block
1012 * job or NBD server writing to the image for storage migration. */
1013 if (runstate_check(RUN_STATE_INMIGRATE)) {
1014 blk->disable_perm = true;
1019 blk_iostatus_reset(blk);
1025 * Detach device model @dev from @blk.
1026 * @dev must be currently attached to @blk.
1028 void blk_detach_dev(BlockBackend *blk, DeviceState *dev)
1030 assert(blk->dev == dev);
1031 GLOBAL_STATE_CODE();
1033 blk->dev_ops = NULL;
1034 blk->dev_opaque = NULL;
1035 blk_set_perm(blk, 0, BLK_PERM_ALL, &error_abort);
1040 * Return the device model attached to @blk if any, else null.
1042 DeviceState *blk_get_attached_dev(BlockBackend *blk)
1044 GLOBAL_STATE_CODE();
1048 /* Return the qdev ID, or if no ID is assigned the QOM path, of the block
1049 * device attached to the BlockBackend. */
1050 char *blk_get_attached_dev_id(BlockBackend *blk)
1052 DeviceState *dev = blk->dev;
1056 return g_strdup("");
1057 } else if (dev->id) {
1058 return g_strdup(dev->id);
1061 return object_get_canonical_path(OBJECT(dev)) ?: g_strdup("");
1065 * Return the BlockBackend which has the device model @dev attached if it
1066 * exists, else null.
1068 * @dev must not be null.
1070 BlockBackend *blk_by_dev(void *dev)
1072 BlockBackend *blk = NULL;
1074 GLOBAL_STATE_CODE();
1076 assert(dev != NULL);
1077 while ((blk = blk_all_next(blk)) != NULL) {
1078 if (blk->dev == dev) {
1086 * Set @blk's device model callbacks to @ops.
1087 * @opaque is the opaque argument to pass to the callbacks.
1088 * This is for use by device models.
1090 void blk_set_dev_ops(BlockBackend *blk, const BlockDevOps *ops,
1093 GLOBAL_STATE_CODE();
1095 blk->dev_opaque = opaque;
1097 /* Are we currently quiesced? Should we enforce this right now? */
1098 if (qatomic_read(&blk->quiesce_counter) && ops && ops->drained_begin) {
1099 ops->drained_begin(opaque);
1104 * Notify @blk's attached device model of media change.
1106 * If @load is true, notify of media load. This action can fail, meaning that
1107 * the medium cannot be loaded. @errp is set then.
1109 * If @load is false, notify of media eject. This can never fail.
1111 * Also send DEVICE_TRAY_MOVED events as appropriate.
1113 void blk_dev_change_media_cb(BlockBackend *blk, bool load, Error **errp)
1115 GLOBAL_STATE_CODE();
1116 if (blk->dev_ops && blk->dev_ops->change_media_cb) {
1117 bool tray_was_open, tray_is_open;
1118 Error *local_err = NULL;
1120 tray_was_open = blk_dev_is_tray_open(blk);
1121 blk->dev_ops->change_media_cb(blk->dev_opaque, load, &local_err);
1123 assert(load == true);
1124 error_propagate(errp, local_err);
1127 tray_is_open = blk_dev_is_tray_open(blk);
1129 if (tray_was_open != tray_is_open) {
1130 char *id = blk_get_attached_dev_id(blk);
1131 qapi_event_send_device_tray_moved(blk_name(blk), id, tray_is_open);
1137 static void blk_root_change_media(BdrvChild *child, bool load)
1139 blk_dev_change_media_cb(child->opaque, load, NULL);
1143 * Does @blk's attached device model have removable media?
1144 * %true if no device model is attached.
1146 bool blk_dev_has_removable_media(BlockBackend *blk)
1148 GLOBAL_STATE_CODE();
1149 return !blk->dev || (blk->dev_ops && blk->dev_ops->change_media_cb);
1153 * Does @blk's attached device model have a tray?
1155 bool blk_dev_has_tray(BlockBackend *blk)
1158 return blk->dev_ops && blk->dev_ops->is_tray_open;
1162 * Notify @blk's attached device model of a media eject request.
1163 * If @force is true, the medium is about to be yanked out forcefully.
1165 void blk_dev_eject_request(BlockBackend *blk, bool force)
1167 GLOBAL_STATE_CODE();
1168 if (blk->dev_ops && blk->dev_ops->eject_request_cb) {
1169 blk->dev_ops->eject_request_cb(blk->dev_opaque, force);
1174 * Does @blk's attached device model have a tray, and is it open?
1176 bool blk_dev_is_tray_open(BlockBackend *blk)
1179 if (blk_dev_has_tray(blk)) {
1180 return blk->dev_ops->is_tray_open(blk->dev_opaque);
1186 * Does @blk's attached device model have the medium locked?
1187 * %false if the device model has no such lock.
1189 bool blk_dev_is_medium_locked(BlockBackend *blk)
1191 GLOBAL_STATE_CODE();
1192 if (blk->dev_ops && blk->dev_ops->is_medium_locked) {
1193 return blk->dev_ops->is_medium_locked(blk->dev_opaque);
1199 * Notify @blk's attached device model of a backend size change.
1201 static void blk_root_resize(BdrvChild *child)
1203 BlockBackend *blk = child->opaque;
1205 if (blk->dev_ops && blk->dev_ops->resize_cb) {
1206 blk->dev_ops->resize_cb(blk->dev_opaque);
1210 void blk_iostatus_enable(BlockBackend *blk)
1212 GLOBAL_STATE_CODE();
1213 blk->iostatus_enabled = true;
1214 blk->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
1217 /* The I/O status is only enabled if the drive explicitly
1218 * enables it _and_ the VM is configured to stop on errors */
1219 bool blk_iostatus_is_enabled(const BlockBackend *blk)
1222 return (blk->iostatus_enabled &&
1223 (blk->on_write_error == BLOCKDEV_ON_ERROR_ENOSPC ||
1224 blk->on_write_error == BLOCKDEV_ON_ERROR_STOP ||
1225 blk->on_read_error == BLOCKDEV_ON_ERROR_STOP));
1228 BlockDeviceIoStatus blk_iostatus(const BlockBackend *blk)
1230 GLOBAL_STATE_CODE();
1231 return blk->iostatus;
1234 void blk_iostatus_disable(BlockBackend *blk)
1236 GLOBAL_STATE_CODE();
1237 blk->iostatus_enabled = false;
1240 void blk_iostatus_reset(BlockBackend *blk)
1242 GLOBAL_STATE_CODE();
1243 if (blk_iostatus_is_enabled(blk)) {
1244 blk->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
1248 void blk_iostatus_set_err(BlockBackend *blk, int error)
1251 assert(blk_iostatus_is_enabled(blk));
1252 if (blk->iostatus == BLOCK_DEVICE_IO_STATUS_OK) {
1253 blk->iostatus = error == ENOSPC ? BLOCK_DEVICE_IO_STATUS_NOSPACE :
1254 BLOCK_DEVICE_IO_STATUS_FAILED;
1258 void blk_set_allow_write_beyond_eof(BlockBackend *blk, bool allow)
1261 blk->allow_write_beyond_eof = allow;
1264 void blk_set_allow_aio_context_change(BlockBackend *blk, bool allow)
1267 blk->allow_aio_context_change = allow;
1270 void blk_set_disable_request_queuing(BlockBackend *blk, bool disable)
1273 qatomic_set(&blk->disable_request_queuing, disable);
1276 static int coroutine_fn GRAPH_RDLOCK
1277 blk_check_byte_request(BlockBackend *blk, int64_t offset, int64_t bytes)
1285 if (!blk_co_is_available(blk)) {
1293 if (!blk->allow_write_beyond_eof) {
1294 len = bdrv_co_getlength(blk_bs(blk));
1299 if (offset > len || len - offset < bytes) {
1307 /* Are we currently in a drained section? */
1308 bool blk_in_drain(BlockBackend *blk)
1310 GLOBAL_STATE_CODE(); /* change to IO_OR_GS_CODE(), if necessary */
1311 return qatomic_read(&blk->quiesce_counter);
1314 /* To be called between exactly one pair of blk_inc/dec_in_flight() */
1315 static void coroutine_fn blk_wait_while_drained(BlockBackend *blk)
1317 assert(blk->in_flight > 0);
1319 if (qatomic_read(&blk->quiesce_counter) &&
1320 !qatomic_read(&blk->disable_request_queuing)) {
1322 * Take lock before decrementing in flight counter so main loop thread
1323 * waits for us to enqueue ourselves before it can leave the drained
1326 qemu_mutex_lock(&blk->queued_requests_lock);
1327 blk_dec_in_flight(blk);
1328 qemu_co_queue_wait(&blk->queued_requests, &blk->queued_requests_lock);
1329 blk_inc_in_flight(blk);
1330 qemu_mutex_unlock(&blk->queued_requests_lock);
1334 /* To be called between exactly one pair of blk_inc/dec_in_flight() */
1335 static int coroutine_fn
1336 blk_co_do_preadv_part(BlockBackend *blk, int64_t offset, int64_t bytes,
1337 QEMUIOVector *qiov, size_t qiov_offset,
1338 BdrvRequestFlags flags)
1341 BlockDriverState *bs;
1344 blk_wait_while_drained(blk);
1345 GRAPH_RDLOCK_GUARD();
1347 /* Call blk_bs() only after waiting, the graph may have changed */
1349 trace_blk_co_preadv(blk, bs, offset, bytes, flags);
1351 ret = blk_check_byte_request(blk, offset, bytes);
1356 bdrv_inc_in_flight(bs);
1358 /* throttling disk I/O */
1359 if (blk->public.throttle_group_member.throttle_state) {
1360 throttle_group_co_io_limits_intercept(&blk->public.throttle_group_member,
1361 bytes, THROTTLE_READ);
1364 ret = bdrv_co_preadv_part(blk->root, offset, bytes, qiov, qiov_offset,
1366 bdrv_dec_in_flight(bs);
1370 int coroutine_fn blk_co_pread(BlockBackend *blk, int64_t offset, int64_t bytes,
1371 void *buf, BdrvRequestFlags flags)
1373 QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
1376 assert(bytes <= SIZE_MAX);
1378 return blk_co_preadv(blk, offset, bytes, &qiov, flags);
1381 int coroutine_fn blk_co_preadv(BlockBackend *blk, int64_t offset,
1382 int64_t bytes, QEMUIOVector *qiov,
1383 BdrvRequestFlags flags)
1388 blk_inc_in_flight(blk);
1389 ret = blk_co_do_preadv_part(blk, offset, bytes, qiov, 0, flags);
1390 blk_dec_in_flight(blk);
1395 int coroutine_fn blk_co_preadv_part(BlockBackend *blk, int64_t offset,
1396 int64_t bytes, QEMUIOVector *qiov,
1397 size_t qiov_offset, BdrvRequestFlags flags)
1402 blk_inc_in_flight(blk);
1403 ret = blk_co_do_preadv_part(blk, offset, bytes, qiov, qiov_offset, flags);
1404 blk_dec_in_flight(blk);
1409 /* To be called between exactly one pair of blk_inc/dec_in_flight() */
1410 static int coroutine_fn
1411 blk_co_do_pwritev_part(BlockBackend *blk, int64_t offset, int64_t bytes,
1412 QEMUIOVector *qiov, size_t qiov_offset,
1413 BdrvRequestFlags flags)
1416 BlockDriverState *bs;
1419 blk_wait_while_drained(blk);
1420 GRAPH_RDLOCK_GUARD();
1422 /* Call blk_bs() only after waiting, the graph may have changed */
1424 trace_blk_co_pwritev(blk, bs, offset, bytes, flags);
1426 ret = blk_check_byte_request(blk, offset, bytes);
1431 bdrv_inc_in_flight(bs);
1432 /* throttling disk I/O */
1433 if (blk->public.throttle_group_member.throttle_state) {
1434 throttle_group_co_io_limits_intercept(&blk->public.throttle_group_member,
1435 bytes, THROTTLE_WRITE);
1438 if (!blk->enable_write_cache) {
1439 flags |= BDRV_REQ_FUA;
1442 ret = bdrv_co_pwritev_part(blk->root, offset, bytes, qiov, qiov_offset,
1444 bdrv_dec_in_flight(bs);
1448 int coroutine_fn blk_co_pwritev_part(BlockBackend *blk, int64_t offset,
1450 QEMUIOVector *qiov, size_t qiov_offset,
1451 BdrvRequestFlags flags)
1456 blk_inc_in_flight(blk);
1457 ret = blk_co_do_pwritev_part(blk, offset, bytes, qiov, qiov_offset, flags);
1458 blk_dec_in_flight(blk);
1463 int coroutine_fn blk_co_pwrite(BlockBackend *blk, int64_t offset, int64_t bytes,
1464 const void *buf, BdrvRequestFlags flags)
1466 QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
1469 assert(bytes <= SIZE_MAX);
1471 return blk_co_pwritev(blk, offset, bytes, &qiov, flags);
1474 int coroutine_fn blk_co_pwritev(BlockBackend *blk, int64_t offset,
1475 int64_t bytes, QEMUIOVector *qiov,
1476 BdrvRequestFlags flags)
1479 return blk_co_pwritev_part(blk, offset, bytes, qiov, 0, flags);
1482 int coroutine_fn blk_co_block_status_above(BlockBackend *blk,
1483 BlockDriverState *base,
1484 int64_t offset, int64_t bytes,
1485 int64_t *pnum, int64_t *map,
1486 BlockDriverState **file)
1489 GRAPH_RDLOCK_GUARD();
1490 return bdrv_co_block_status_above(blk_bs(blk), base, offset, bytes, pnum,
1494 int coroutine_fn blk_co_is_allocated_above(BlockBackend *blk,
1495 BlockDriverState *base,
1496 bool include_base, int64_t offset,
1497 int64_t bytes, int64_t *pnum)
1500 GRAPH_RDLOCK_GUARD();
1501 return bdrv_co_is_allocated_above(blk_bs(blk), base, include_base, offset,
1505 typedef struct BlkRwCo {
1510 BdrvRequestFlags flags;
1513 int blk_make_zero(BlockBackend *blk, BdrvRequestFlags flags)
1515 GLOBAL_STATE_CODE();
1516 return bdrv_make_zero(blk->root, flags);
1519 void blk_inc_in_flight(BlockBackend *blk)
1522 qatomic_inc(&blk->in_flight);
1525 void blk_dec_in_flight(BlockBackend *blk)
1528 qatomic_dec(&blk->in_flight);
1532 static void error_callback_bh(void *opaque)
1534 struct BlockBackendAIOCB *acb = opaque;
1536 blk_dec_in_flight(acb->blk);
1537 acb->common.cb(acb->common.opaque, acb->ret);
1538 qemu_aio_unref(acb);
1541 BlockAIOCB *blk_abort_aio_request(BlockBackend *blk,
1542 BlockCompletionFunc *cb,
1543 void *opaque, int ret)
1545 struct BlockBackendAIOCB *acb;
1548 blk_inc_in_flight(blk);
1549 acb = blk_aio_get(&block_backend_aiocb_info, blk, cb, opaque);
1553 replay_bh_schedule_oneshot_event(qemu_get_current_aio_context(),
1554 error_callback_bh, acb);
1555 return &acb->common;
1558 typedef struct BlkAioEmAIOCB {
1565 static const AIOCBInfo blk_aio_em_aiocb_info = {
1566 .aiocb_size = sizeof(BlkAioEmAIOCB),
1569 static void blk_aio_complete(BlkAioEmAIOCB *acb)
1571 if (acb->has_returned) {
1572 acb->common.cb(acb->common.opaque, acb->rwco.ret);
1573 blk_dec_in_flight(acb->rwco.blk);
1574 qemu_aio_unref(acb);
1578 static void blk_aio_complete_bh(void *opaque)
1580 BlkAioEmAIOCB *acb = opaque;
1581 assert(acb->has_returned);
1582 blk_aio_complete(acb);
1585 static BlockAIOCB *blk_aio_prwv(BlockBackend *blk, int64_t offset,
1587 void *iobuf, CoroutineEntry co_entry,
1588 BdrvRequestFlags flags,
1589 BlockCompletionFunc *cb, void *opaque)
1594 blk_inc_in_flight(blk);
1595 acb = blk_aio_get(&blk_aio_em_aiocb_info, blk, cb, opaque);
1596 acb->rwco = (BlkRwCo) {
1604 acb->has_returned = false;
1606 co = qemu_coroutine_create(co_entry, acb);
1607 aio_co_enter(qemu_get_current_aio_context(), co);
1609 acb->has_returned = true;
1610 if (acb->rwco.ret != NOT_DONE) {
1611 replay_bh_schedule_oneshot_event(qemu_get_current_aio_context(),
1612 blk_aio_complete_bh, acb);
1615 return &acb->common;
1618 static void coroutine_fn blk_aio_read_entry(void *opaque)
1620 BlkAioEmAIOCB *acb = opaque;
1621 BlkRwCo *rwco = &acb->rwco;
1622 QEMUIOVector *qiov = rwco->iobuf;
1624 assert(qiov->size == acb->bytes);
1625 rwco->ret = blk_co_do_preadv_part(rwco->blk, rwco->offset, acb->bytes, qiov,
1627 blk_aio_complete(acb);
1630 static void coroutine_fn blk_aio_write_entry(void *opaque)
1632 BlkAioEmAIOCB *acb = opaque;
1633 BlkRwCo *rwco = &acb->rwco;
1634 QEMUIOVector *qiov = rwco->iobuf;
1636 assert(!qiov || qiov->size == acb->bytes);
1637 rwco->ret = blk_co_do_pwritev_part(rwco->blk, rwco->offset, acb->bytes,
1638 qiov, 0, rwco->flags);
1639 blk_aio_complete(acb);
1642 BlockAIOCB *blk_aio_pwrite_zeroes(BlockBackend *blk, int64_t offset,
1643 int64_t bytes, BdrvRequestFlags flags,
1644 BlockCompletionFunc *cb, void *opaque)
1647 return blk_aio_prwv(blk, offset, bytes, NULL, blk_aio_write_entry,
1648 flags | BDRV_REQ_ZERO_WRITE, cb, opaque);
1651 int64_t coroutine_fn blk_co_getlength(BlockBackend *blk)
1654 GRAPH_RDLOCK_GUARD();
1656 if (!blk_co_is_available(blk)) {
1660 return bdrv_co_getlength(blk_bs(blk));
1663 int64_t coroutine_fn blk_co_nb_sectors(BlockBackend *blk)
1665 BlockDriverState *bs = blk_bs(blk);
1668 GRAPH_RDLOCK_GUARD();
1673 return bdrv_co_nb_sectors(bs);
1678 * This wrapper is written by hand because this function is in the hot I/O path,
1679 * via blk_get_geometry.
1681 int64_t coroutine_mixed_fn blk_nb_sectors(BlockBackend *blk)
1683 BlockDriverState *bs = blk_bs(blk);
1690 return bdrv_nb_sectors(bs);
1694 /* return 0 as number of sectors if no device present or error */
1695 void coroutine_fn blk_co_get_geometry(BlockBackend *blk,
1696 uint64_t *nb_sectors_ptr)
1698 int64_t ret = blk_co_nb_sectors(blk);
1699 *nb_sectors_ptr = ret < 0 ? 0 : ret;
1703 * This wrapper is written by hand because this function is in the hot I/O path.
1705 void coroutine_mixed_fn blk_get_geometry(BlockBackend *blk,
1706 uint64_t *nb_sectors_ptr)
1708 int64_t ret = blk_nb_sectors(blk);
1709 *nb_sectors_ptr = ret < 0 ? 0 : ret;
1712 BlockAIOCB *blk_aio_preadv(BlockBackend *blk, int64_t offset,
1713 QEMUIOVector *qiov, BdrvRequestFlags flags,
1714 BlockCompletionFunc *cb, void *opaque)
1717 assert((uint64_t)qiov->size <= INT64_MAX);
1718 return blk_aio_prwv(blk, offset, qiov->size, qiov,
1719 blk_aio_read_entry, flags, cb, opaque);
1722 BlockAIOCB *blk_aio_pwritev(BlockBackend *blk, int64_t offset,
1723 QEMUIOVector *qiov, BdrvRequestFlags flags,
1724 BlockCompletionFunc *cb, void *opaque)
1727 assert((uint64_t)qiov->size <= INT64_MAX);
1728 return blk_aio_prwv(blk, offset, qiov->size, qiov,
1729 blk_aio_write_entry, flags, cb, opaque);
1732 void blk_aio_cancel(BlockAIOCB *acb)
1734 GLOBAL_STATE_CODE();
1735 bdrv_aio_cancel(acb);
1738 void blk_aio_cancel_async(BlockAIOCB *acb)
1741 bdrv_aio_cancel_async(acb);
1744 /* To be called between exactly one pair of blk_inc/dec_in_flight() */
1745 static int coroutine_fn
1746 blk_co_do_ioctl(BlockBackend *blk, unsigned long int req, void *buf)
1750 blk_wait_while_drained(blk);
1751 GRAPH_RDLOCK_GUARD();
1753 if (!blk_co_is_available(blk)) {
1757 return bdrv_co_ioctl(blk_bs(blk), req, buf);
1760 int coroutine_fn blk_co_ioctl(BlockBackend *blk, unsigned long int req,
1766 blk_inc_in_flight(blk);
1767 ret = blk_co_do_ioctl(blk, req, buf);
1768 blk_dec_in_flight(blk);
1773 static void coroutine_fn blk_aio_ioctl_entry(void *opaque)
1775 BlkAioEmAIOCB *acb = opaque;
1776 BlkRwCo *rwco = &acb->rwco;
1778 rwco->ret = blk_co_do_ioctl(rwco->blk, rwco->offset, rwco->iobuf);
1780 blk_aio_complete(acb);
1783 BlockAIOCB *blk_aio_ioctl(BlockBackend *blk, unsigned long int req, void *buf,
1784 BlockCompletionFunc *cb, void *opaque)
1787 return blk_aio_prwv(blk, req, 0, buf, blk_aio_ioctl_entry, 0, cb, opaque);
1790 /* To be called between exactly one pair of blk_inc/dec_in_flight() */
1791 static int coroutine_fn
1792 blk_co_do_pdiscard(BlockBackend *blk, int64_t offset, int64_t bytes)
1797 blk_wait_while_drained(blk);
1798 GRAPH_RDLOCK_GUARD();
1800 ret = blk_check_byte_request(blk, offset, bytes);
1805 return bdrv_co_pdiscard(blk->root, offset, bytes);
1808 static void coroutine_fn blk_aio_pdiscard_entry(void *opaque)
1810 BlkAioEmAIOCB *acb = opaque;
1811 BlkRwCo *rwco = &acb->rwco;
1813 rwco->ret = blk_co_do_pdiscard(rwco->blk, rwco->offset, acb->bytes);
1814 blk_aio_complete(acb);
1817 BlockAIOCB *blk_aio_pdiscard(BlockBackend *blk,
1818 int64_t offset, int64_t bytes,
1819 BlockCompletionFunc *cb, void *opaque)
1822 return blk_aio_prwv(blk, offset, bytes, NULL, blk_aio_pdiscard_entry, 0,
1826 int coroutine_fn blk_co_pdiscard(BlockBackend *blk, int64_t offset,
1832 blk_inc_in_flight(blk);
1833 ret = blk_co_do_pdiscard(blk, offset, bytes);
1834 blk_dec_in_flight(blk);
1839 /* To be called between exactly one pair of blk_inc/dec_in_flight() */
1840 static int coroutine_fn blk_co_do_flush(BlockBackend *blk)
1843 blk_wait_while_drained(blk);
1844 GRAPH_RDLOCK_GUARD();
1846 if (!blk_co_is_available(blk)) {
1850 return bdrv_co_flush(blk_bs(blk));
1853 static void coroutine_fn blk_aio_flush_entry(void *opaque)
1855 BlkAioEmAIOCB *acb = opaque;
1856 BlkRwCo *rwco = &acb->rwco;
1858 rwco->ret = blk_co_do_flush(rwco->blk);
1859 blk_aio_complete(acb);
1862 BlockAIOCB *blk_aio_flush(BlockBackend *blk,
1863 BlockCompletionFunc *cb, void *opaque)
1866 return blk_aio_prwv(blk, 0, 0, NULL, blk_aio_flush_entry, 0, cb, opaque);
1869 int coroutine_fn blk_co_flush(BlockBackend *blk)
1874 blk_inc_in_flight(blk);
1875 ret = blk_co_do_flush(blk);
1876 blk_dec_in_flight(blk);
1881 static void coroutine_fn blk_aio_zone_report_entry(void *opaque)
1883 BlkAioEmAIOCB *acb = opaque;
1884 BlkRwCo *rwco = &acb->rwco;
1886 rwco->ret = blk_co_zone_report(rwco->blk, rwco->offset,
1887 (unsigned int*)(uintptr_t)acb->bytes,
1889 blk_aio_complete(acb);
1892 BlockAIOCB *blk_aio_zone_report(BlockBackend *blk, int64_t offset,
1893 unsigned int *nr_zones,
1894 BlockZoneDescriptor *zones,
1895 BlockCompletionFunc *cb, void *opaque)
1901 blk_inc_in_flight(blk);
1902 acb = blk_aio_get(&blk_aio_em_aiocb_info, blk, cb, opaque);
1903 acb->rwco = (BlkRwCo) {
1909 acb->bytes = (int64_t)(uintptr_t)nr_zones,
1910 acb->has_returned = false;
1912 co = qemu_coroutine_create(blk_aio_zone_report_entry, acb);
1913 aio_co_enter(qemu_get_current_aio_context(), co);
1915 acb->has_returned = true;
1916 if (acb->rwco.ret != NOT_DONE) {
1917 replay_bh_schedule_oneshot_event(qemu_get_current_aio_context(),
1918 blk_aio_complete_bh, acb);
1921 return &acb->common;
1924 static void coroutine_fn blk_aio_zone_mgmt_entry(void *opaque)
1926 BlkAioEmAIOCB *acb = opaque;
1927 BlkRwCo *rwco = &acb->rwco;
1929 rwco->ret = blk_co_zone_mgmt(rwco->blk,
1930 (BlockZoneOp)(uintptr_t)rwco->iobuf,
1931 rwco->offset, acb->bytes);
1932 blk_aio_complete(acb);
1935 BlockAIOCB *blk_aio_zone_mgmt(BlockBackend *blk, BlockZoneOp op,
1936 int64_t offset, int64_t len,
1937 BlockCompletionFunc *cb, void *opaque) {
1942 blk_inc_in_flight(blk);
1943 acb = blk_aio_get(&blk_aio_em_aiocb_info, blk, cb, opaque);
1944 acb->rwco = (BlkRwCo) {
1947 .iobuf = (void *)(uintptr_t)op,
1951 acb->has_returned = false;
1953 co = qemu_coroutine_create(blk_aio_zone_mgmt_entry, acb);
1954 aio_co_enter(qemu_get_current_aio_context(), co);
1956 acb->has_returned = true;
1957 if (acb->rwco.ret != NOT_DONE) {
1958 replay_bh_schedule_oneshot_event(qemu_get_current_aio_context(),
1959 blk_aio_complete_bh, acb);
1962 return &acb->common;
1965 static void coroutine_fn blk_aio_zone_append_entry(void *opaque)
1967 BlkAioEmAIOCB *acb = opaque;
1968 BlkRwCo *rwco = &acb->rwco;
1970 rwco->ret = blk_co_zone_append(rwco->blk, (int64_t *)(uintptr_t)acb->bytes,
1971 rwco->iobuf, rwco->flags);
1972 blk_aio_complete(acb);
1975 BlockAIOCB *blk_aio_zone_append(BlockBackend *blk, int64_t *offset,
1976 QEMUIOVector *qiov, BdrvRequestFlags flags,
1977 BlockCompletionFunc *cb, void *opaque) {
1982 blk_inc_in_flight(blk);
1983 acb = blk_aio_get(&blk_aio_em_aiocb_info, blk, cb, opaque);
1984 acb->rwco = (BlkRwCo) {
1990 acb->bytes = (int64_t)(uintptr_t)offset;
1991 acb->has_returned = false;
1993 co = qemu_coroutine_create(blk_aio_zone_append_entry, acb);
1994 aio_co_enter(qemu_get_current_aio_context(), co);
1995 acb->has_returned = true;
1996 if (acb->rwco.ret != NOT_DONE) {
1997 replay_bh_schedule_oneshot_event(qemu_get_current_aio_context(),
1998 blk_aio_complete_bh, acb);
2001 return &acb->common;
2005 * Send a zone_report command.
2006 * offset is a byte offset from the start of the device. No alignment
2007 * required for offset.
2008 * nr_zones represents IN maximum and OUT actual.
2010 int coroutine_fn blk_co_zone_report(BlockBackend *blk, int64_t offset,
2011 unsigned int *nr_zones,
2012 BlockZoneDescriptor *zones)
2017 blk_inc_in_flight(blk); /* increase before waiting */
2018 blk_wait_while_drained(blk);
2019 GRAPH_RDLOCK_GUARD();
2020 if (!blk_is_available(blk)) {
2021 blk_dec_in_flight(blk);
2024 ret = bdrv_co_zone_report(blk_bs(blk), offset, nr_zones, zones);
2025 blk_dec_in_flight(blk);
2030 * Send a zone_management command.
2031 * op is the zone operation;
2032 * offset is the byte offset from the start of the zoned device;
2033 * len is the maximum number of bytes the command should operate on. It
2034 * should be aligned with the device zone size.
2036 int coroutine_fn blk_co_zone_mgmt(BlockBackend *blk, BlockZoneOp op,
2037 int64_t offset, int64_t len)
2042 blk_inc_in_flight(blk);
2043 blk_wait_while_drained(blk);
2044 GRAPH_RDLOCK_GUARD();
2046 ret = blk_check_byte_request(blk, offset, len);
2048 blk_dec_in_flight(blk);
2052 ret = bdrv_co_zone_mgmt(blk_bs(blk), op, offset, len);
2053 blk_dec_in_flight(blk);
2058 * Send a zone_append command.
2060 int coroutine_fn blk_co_zone_append(BlockBackend *blk, int64_t *offset,
2061 QEMUIOVector *qiov, BdrvRequestFlags flags)
2066 blk_inc_in_flight(blk);
2067 blk_wait_while_drained(blk);
2068 GRAPH_RDLOCK_GUARD();
2069 if (!blk_is_available(blk)) {
2070 blk_dec_in_flight(blk);
2074 ret = bdrv_co_zone_append(blk_bs(blk), offset, qiov, flags);
2075 blk_dec_in_flight(blk);
2079 void blk_drain(BlockBackend *blk)
2081 BlockDriverState *bs = blk_bs(blk);
2082 GLOBAL_STATE_CODE();
2086 bdrv_drained_begin(bs);
2089 /* We may have -ENOMEDIUM completions in flight */
2090 AIO_WAIT_WHILE(blk_get_aio_context(blk),
2091 qatomic_read(&blk->in_flight) > 0);
2094 bdrv_drained_end(bs);
2099 void blk_drain_all(void)
2101 BlockBackend *blk = NULL;
2103 GLOBAL_STATE_CODE();
2105 bdrv_drain_all_begin();
2107 while ((blk = blk_all_next(blk)) != NULL) {
2108 /* We may have -ENOMEDIUM completions in flight */
2109 AIO_WAIT_WHILE_UNLOCKED(NULL, qatomic_read(&blk->in_flight) > 0);
2112 bdrv_drain_all_end();
2115 void blk_set_on_error(BlockBackend *blk, BlockdevOnError on_read_error,
2116 BlockdevOnError on_write_error)
2118 GLOBAL_STATE_CODE();
2119 blk->on_read_error = on_read_error;
2120 blk->on_write_error = on_write_error;
2123 BlockdevOnError blk_get_on_error(BlockBackend *blk, bool is_read)
2126 return is_read ? blk->on_read_error : blk->on_write_error;
2129 BlockErrorAction blk_get_error_action(BlockBackend *blk, bool is_read,
2132 BlockdevOnError on_err = blk_get_on_error(blk, is_read);
2136 case BLOCKDEV_ON_ERROR_ENOSPC:
2137 return (error == ENOSPC) ?
2138 BLOCK_ERROR_ACTION_STOP : BLOCK_ERROR_ACTION_REPORT;
2139 case BLOCKDEV_ON_ERROR_STOP:
2140 return BLOCK_ERROR_ACTION_STOP;
2141 case BLOCKDEV_ON_ERROR_REPORT:
2142 return BLOCK_ERROR_ACTION_REPORT;
2143 case BLOCKDEV_ON_ERROR_IGNORE:
2144 return BLOCK_ERROR_ACTION_IGNORE;
2145 case BLOCKDEV_ON_ERROR_AUTO:
2151 static void send_qmp_error_event(BlockBackend *blk,
2152 BlockErrorAction action,
2153 bool is_read, int error)
2155 IoOperationType optype;
2156 BlockDriverState *bs = blk_bs(blk);
2158 optype = is_read ? IO_OPERATION_TYPE_READ : IO_OPERATION_TYPE_WRITE;
2159 qapi_event_send_block_io_error(blk_name(blk),
2160 bs ? bdrv_get_node_name(bs) : NULL, optype,
2161 action, blk_iostatus_is_enabled(blk),
2162 error == ENOSPC, strerror(error));
2165 /* This is done by device models because, while the block layer knows
2166 * about the error, it does not know whether an operation comes from
2167 * the device or the block layer (from a job, for example).
2169 void blk_error_action(BlockBackend *blk, BlockErrorAction action,
2170 bool is_read, int error)
2175 if (action == BLOCK_ERROR_ACTION_STOP) {
2176 /* First set the iostatus, so that "info block" returns an iostatus
2177 * that matches the events raised so far (an additional error iostatus
2178 * is fine, but not a lost one).
2180 blk_iostatus_set_err(blk, error);
2182 /* Then raise the request to stop the VM and the event.
2183 * qemu_system_vmstop_request_prepare has two effects. First,
2184 * it ensures that the STOP event always comes after the
2185 * BLOCK_IO_ERROR event. Second, it ensures that even if management
2186 * can observe the STOP event and do a "cont" before the STOP
2187 * event is issued, the VM will not stop. In this case, vm_start()
2188 * also ensures that the STOP/RESUME pair of events is emitted.
2190 qemu_system_vmstop_request_prepare();
2191 send_qmp_error_event(blk, action, is_read, error);
2192 qemu_system_vmstop_request(RUN_STATE_IO_ERROR);
2194 send_qmp_error_event(blk, action, is_read, error);
2199 * Returns true if the BlockBackend can support taking write permissions
2200 * (because its root node is not read-only).
2202 bool blk_supports_write_perm(BlockBackend *blk)
2204 BlockDriverState *bs = blk_bs(blk);
2205 GLOBAL_STATE_CODE();
2208 return !bdrv_is_read_only(bs);
2210 return blk->root_state.open_flags & BDRV_O_RDWR;
2215 * Returns true if the BlockBackend can be written to in its current
2216 * configuration (i.e. if write permission have been requested)
2218 bool blk_is_writable(BlockBackend *blk)
2221 return blk->perm & BLK_PERM_WRITE;
2224 bool blk_is_sg(BlockBackend *blk)
2226 BlockDriverState *bs = blk_bs(blk);
2227 GLOBAL_STATE_CODE();
2233 return bdrv_is_sg(bs);
2236 bool blk_enable_write_cache(BlockBackend *blk)
2239 return blk->enable_write_cache;
2242 void blk_set_enable_write_cache(BlockBackend *blk, bool wce)
2245 blk->enable_write_cache = wce;
2248 void blk_activate(BlockBackend *blk, Error **errp)
2250 BlockDriverState *bs = blk_bs(blk);
2251 GLOBAL_STATE_CODE();
2254 error_setg(errp, "Device '%s' has no medium", blk->name);
2259 * Migration code can call this function in coroutine context, so leave
2260 * coroutine context if necessary.
2262 if (qemu_in_coroutine()) {
2263 bdrv_co_activate(bs, errp);
2265 GRAPH_RDLOCK_GUARD_MAINLOOP();
2266 bdrv_activate(bs, errp);
2270 bool coroutine_fn blk_co_is_inserted(BlockBackend *blk)
2272 BlockDriverState *bs = blk_bs(blk);
2274 assert_bdrv_graph_readable();
2276 return bs && bdrv_co_is_inserted(bs);
2279 bool coroutine_fn blk_co_is_available(BlockBackend *blk)
2282 return blk_co_is_inserted(blk) && !blk_dev_is_tray_open(blk);
2285 void coroutine_fn blk_co_lock_medium(BlockBackend *blk, bool locked)
2287 BlockDriverState *bs = blk_bs(blk);
2289 GRAPH_RDLOCK_GUARD();
2292 bdrv_co_lock_medium(bs, locked);
2296 void coroutine_fn blk_co_eject(BlockBackend *blk, bool eject_flag)
2298 BlockDriverState *bs = blk_bs(blk);
2301 GRAPH_RDLOCK_GUARD();
2304 bdrv_co_eject(bs, eject_flag);
2307 /* Whether or not we ejected on the backend,
2308 * the frontend experienced a tray event. */
2309 id = blk_get_attached_dev_id(blk);
2310 qapi_event_send_device_tray_moved(blk_name(blk), id,
2315 int blk_get_flags(BlockBackend *blk)
2317 BlockDriverState *bs = blk_bs(blk);
2318 GLOBAL_STATE_CODE();
2321 return bdrv_get_flags(bs);
2323 return blk->root_state.open_flags;
2327 /* Returns the minimum request alignment, in bytes; guaranteed nonzero */
2328 uint32_t blk_get_request_alignment(BlockBackend *blk)
2330 BlockDriverState *bs = blk_bs(blk);
2332 return bs ? bs->bl.request_alignment : BDRV_SECTOR_SIZE;
2335 /* Returns the maximum hardware transfer length, in bytes; guaranteed nonzero */
2336 uint64_t blk_get_max_hw_transfer(BlockBackend *blk)
2338 BlockDriverState *bs = blk_bs(blk);
2339 uint64_t max = INT_MAX;
2343 max = MIN_NON_ZERO(max, bs->bl.max_hw_transfer);
2344 max = MIN_NON_ZERO(max, bs->bl.max_transfer);
2346 return ROUND_DOWN(max, blk_get_request_alignment(blk));
2349 /* Returns the maximum transfer length, in bytes; guaranteed nonzero */
2350 uint32_t blk_get_max_transfer(BlockBackend *blk)
2352 BlockDriverState *bs = blk_bs(blk);
2353 uint32_t max = INT_MAX;
2357 max = MIN_NON_ZERO(max, bs->bl.max_transfer);
2359 return ROUND_DOWN(max, blk_get_request_alignment(blk));
2362 int blk_get_max_hw_iov(BlockBackend *blk)
2365 return MIN_NON_ZERO(blk->root->bs->bl.max_hw_iov,
2366 blk->root->bs->bl.max_iov);
2369 int blk_get_max_iov(BlockBackend *blk)
2372 return blk->root->bs->bl.max_iov;
2375 void *blk_try_blockalign(BlockBackend *blk, size_t size)
2378 return qemu_try_blockalign(blk ? blk_bs(blk) : NULL, size);
2381 void *blk_blockalign(BlockBackend *blk, size_t size)
2384 return qemu_blockalign(blk ? blk_bs(blk) : NULL, size);
2387 bool blk_op_is_blocked(BlockBackend *blk, BlockOpType op, Error **errp)
2389 BlockDriverState *bs = blk_bs(blk);
2390 GLOBAL_STATE_CODE();
2391 GRAPH_RDLOCK_GUARD_MAINLOOP();
2397 return bdrv_op_is_blocked(bs, op, errp);
2400 void blk_op_unblock(BlockBackend *blk, BlockOpType op, Error *reason)
2402 BlockDriverState *bs = blk_bs(blk);
2403 GLOBAL_STATE_CODE();
2406 bdrv_op_unblock(bs, op, reason);
2410 void blk_op_block_all(BlockBackend *blk, Error *reason)
2412 BlockDriverState *bs = blk_bs(blk);
2413 GLOBAL_STATE_CODE();
2416 bdrv_op_block_all(bs, reason);
2420 void blk_op_unblock_all(BlockBackend *blk, Error *reason)
2422 BlockDriverState *bs = blk_bs(blk);
2423 GLOBAL_STATE_CODE();
2426 bdrv_op_unblock_all(bs, reason);
2430 AioContext *blk_get_aio_context(BlockBackend *blk)
2432 BlockDriverState *bs;
2436 return qemu_get_aio_context();
2441 AioContext *ctx = bdrv_get_aio_context(blk_bs(blk));
2442 assert(ctx == blk->ctx);
2448 int blk_set_aio_context(BlockBackend *blk, AioContext *new_context,
2451 bool old_allow_change;
2452 BlockDriverState *bs = blk_bs(blk);
2455 GLOBAL_STATE_CODE();
2458 blk->ctx = new_context;
2464 old_allow_change = blk->allow_aio_context_change;
2465 blk->allow_aio_context_change = true;
2467 ret = bdrv_try_change_aio_context(bs, new_context, NULL, errp);
2469 blk->allow_aio_context_change = old_allow_change;
2475 typedef struct BdrvStateBlkRootContext {
2476 AioContext *new_ctx;
2478 } BdrvStateBlkRootContext;
2480 static void blk_root_set_aio_ctx_commit(void *opaque)
2482 BdrvStateBlkRootContext *s = opaque;
2483 BlockBackend *blk = s->blk;
2484 AioContext *new_context = s->new_ctx;
2485 ThrottleGroupMember *tgm = &blk->public.throttle_group_member;
2487 blk->ctx = new_context;
2488 if (tgm->throttle_state) {
2489 throttle_group_detach_aio_context(tgm);
2490 throttle_group_attach_aio_context(tgm, new_context);
2494 static TransactionActionDrv set_blk_root_context = {
2495 .commit = blk_root_set_aio_ctx_commit,
2499 static bool blk_root_change_aio_ctx(BdrvChild *child, AioContext *ctx,
2500 GHashTable *visited, Transaction *tran,
2503 BlockBackend *blk = child->opaque;
2504 BdrvStateBlkRootContext *s;
2506 if (!blk->allow_aio_context_change) {
2508 * Manually created BlockBackends (those with a name) that are not
2509 * attached to anything can change their AioContext without updating
2510 * their user; return an error for others.
2512 if (!blk->name || blk->dev) {
2513 /* TODO Add BB name/QOM path */
2514 error_setg(errp, "Cannot change iothread of active block backend");
2519 s = g_new(BdrvStateBlkRootContext, 1);
2520 *s = (BdrvStateBlkRootContext) {
2525 tran_add(tran, &set_blk_root_context, s);
2529 void blk_add_aio_context_notifier(BlockBackend *blk,
2530 void (*attached_aio_context)(AioContext *new_context, void *opaque),
2531 void (*detach_aio_context)(void *opaque), void *opaque)
2533 BlockBackendAioNotifier *notifier;
2534 BlockDriverState *bs = blk_bs(blk);
2535 GLOBAL_STATE_CODE();
2537 notifier = g_new(BlockBackendAioNotifier, 1);
2538 notifier->attached_aio_context = attached_aio_context;
2539 notifier->detach_aio_context = detach_aio_context;
2540 notifier->opaque = opaque;
2541 QLIST_INSERT_HEAD(&blk->aio_notifiers, notifier, list);
2544 bdrv_add_aio_context_notifier(bs, attached_aio_context,
2545 detach_aio_context, opaque);
2549 void blk_remove_aio_context_notifier(BlockBackend *blk,
2550 void (*attached_aio_context)(AioContext *,
2552 void (*detach_aio_context)(void *),
2555 BlockBackendAioNotifier *notifier;
2556 BlockDriverState *bs = blk_bs(blk);
2558 GLOBAL_STATE_CODE();
2561 bdrv_remove_aio_context_notifier(bs, attached_aio_context,
2562 detach_aio_context, opaque);
2565 QLIST_FOREACH(notifier, &blk->aio_notifiers, list) {
2566 if (notifier->attached_aio_context == attached_aio_context &&
2567 notifier->detach_aio_context == detach_aio_context &&
2568 notifier->opaque == opaque) {
2569 QLIST_REMOVE(notifier, list);
2578 void blk_add_remove_bs_notifier(BlockBackend *blk, Notifier *notify)
2580 GLOBAL_STATE_CODE();
2581 notifier_list_add(&blk->remove_bs_notifiers, notify);
2584 void blk_add_insert_bs_notifier(BlockBackend *blk, Notifier *notify)
2586 GLOBAL_STATE_CODE();
2587 notifier_list_add(&blk->insert_bs_notifiers, notify);
2590 BlockAcctStats *blk_get_stats(BlockBackend *blk)
2596 void *blk_aio_get(const AIOCBInfo *aiocb_info, BlockBackend *blk,
2597 BlockCompletionFunc *cb, void *opaque)
2600 return qemu_aio_get(aiocb_info, blk_bs(blk), cb, opaque);
2603 int coroutine_fn blk_co_pwrite_zeroes(BlockBackend *blk, int64_t offset,
2604 int64_t bytes, BdrvRequestFlags flags)
2607 return blk_co_pwritev(blk, offset, bytes, NULL,
2608 flags | BDRV_REQ_ZERO_WRITE);
2611 int coroutine_fn blk_co_pwrite_compressed(BlockBackend *blk, int64_t offset,
2612 int64_t bytes, const void *buf)
2614 QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
2616 return blk_co_pwritev_part(blk, offset, bytes, &qiov, 0,
2617 BDRV_REQ_WRITE_COMPRESSED);
2620 int coroutine_fn blk_co_truncate(BlockBackend *blk, int64_t offset, bool exact,
2621 PreallocMode prealloc, BdrvRequestFlags flags,
2625 GRAPH_RDLOCK_GUARD();
2626 if (!blk_co_is_available(blk)) {
2627 error_setg(errp, "No medium inserted");
2631 return bdrv_co_truncate(blk->root, offset, exact, prealloc, flags, errp);
2634 int blk_save_vmstate(BlockBackend *blk, const uint8_t *buf,
2635 int64_t pos, int size)
2638 GLOBAL_STATE_CODE();
2640 if (!blk_is_available(blk)) {
2644 ret = bdrv_save_vmstate(blk_bs(blk), buf, pos, size);
2649 if (ret == size && !blk->enable_write_cache) {
2650 ret = bdrv_flush(blk_bs(blk));
2653 return ret < 0 ? ret : size;
2656 int blk_load_vmstate(BlockBackend *blk, uint8_t *buf, int64_t pos, int size)
2658 GLOBAL_STATE_CODE();
2659 if (!blk_is_available(blk)) {
2663 return bdrv_load_vmstate(blk_bs(blk), buf, pos, size);
2666 int blk_probe_blocksizes(BlockBackend *blk, BlockSizes *bsz)
2668 GLOBAL_STATE_CODE();
2669 if (!blk_is_available(blk)) {
2673 return bdrv_probe_blocksizes(blk_bs(blk), bsz);
2676 int blk_probe_geometry(BlockBackend *blk, HDGeometry *geo)
2678 GLOBAL_STATE_CODE();
2679 if (!blk_is_available(blk)) {
2683 return bdrv_probe_geometry(blk_bs(blk), geo);
2687 * Updates the BlockBackendRootState object with data from the currently
2688 * attached BlockDriverState.
2690 void blk_update_root_state(BlockBackend *blk)
2692 GLOBAL_STATE_CODE();
2695 blk->root_state.open_flags = blk->root->bs->open_flags;
2696 blk->root_state.detect_zeroes = blk->root->bs->detect_zeroes;
2700 * Returns the detect-zeroes setting to be used for bdrv_open() of a
2701 * BlockDriverState which is supposed to inherit the root state.
2703 bool blk_get_detect_zeroes_from_root_state(BlockBackend *blk)
2705 GLOBAL_STATE_CODE();
2706 return blk->root_state.detect_zeroes;
2710 * Returns the flags to be used for bdrv_open() of a BlockDriverState which is
2711 * supposed to inherit the root state.
2713 int blk_get_open_flags_from_root_state(BlockBackend *blk)
2715 GLOBAL_STATE_CODE();
2716 return blk->root_state.open_flags;
2719 BlockBackendRootState *blk_get_root_state(BlockBackend *blk)
2721 GLOBAL_STATE_CODE();
2722 return &blk->root_state;
2725 int blk_commit_all(void)
2727 BlockBackend *blk = NULL;
2728 GLOBAL_STATE_CODE();
2730 while ((blk = blk_all_next(blk)) != NULL) {
2731 AioContext *aio_context = blk_get_aio_context(blk);
2732 BlockDriverState *unfiltered_bs = bdrv_skip_filters(blk_bs(blk));
2734 aio_context_acquire(aio_context);
2735 if (blk_is_inserted(blk) && bdrv_cow_child(unfiltered_bs)) {
2738 ret = bdrv_commit(unfiltered_bs);
2740 aio_context_release(aio_context);
2744 aio_context_release(aio_context);
2750 /* throttling disk I/O limits */
2751 void blk_set_io_limits(BlockBackend *blk, ThrottleConfig *cfg)
2753 GLOBAL_STATE_CODE();
2754 throttle_group_config(&blk->public.throttle_group_member, cfg);
2757 void blk_io_limits_disable(BlockBackend *blk)
2759 BlockDriverState *bs = blk_bs(blk);
2760 ThrottleGroupMember *tgm = &blk->public.throttle_group_member;
2761 assert(tgm->throttle_state);
2762 GLOBAL_STATE_CODE();
2765 bdrv_drained_begin(bs);
2767 throttle_group_unregister_tgm(tgm);
2769 bdrv_drained_end(bs);
2774 /* should be called before blk_set_io_limits if a limit is set */
2775 void blk_io_limits_enable(BlockBackend *blk, const char *group)
2777 assert(!blk->public.throttle_group_member.throttle_state);
2778 GLOBAL_STATE_CODE();
2779 throttle_group_register_tgm(&blk->public.throttle_group_member,
2780 group, blk_get_aio_context(blk));
2783 void blk_io_limits_update_group(BlockBackend *blk, const char *group)
2785 GLOBAL_STATE_CODE();
2786 /* this BB is not part of any group */
2787 if (!blk->public.throttle_group_member.throttle_state) {
2791 /* this BB is a part of the same group than the one we want */
2792 if (!g_strcmp0(throttle_group_get_name(&blk->public.throttle_group_member),
2797 /* need to change the group this bs belong to */
2798 blk_io_limits_disable(blk);
2799 blk_io_limits_enable(blk, group);
2802 static void blk_root_drained_begin(BdrvChild *child)
2804 BlockBackend *blk = child->opaque;
2805 ThrottleGroupMember *tgm = &blk->public.throttle_group_member;
2807 if (qatomic_fetch_inc(&blk->quiesce_counter) == 0) {
2808 if (blk->dev_ops && blk->dev_ops->drained_begin) {
2809 blk->dev_ops->drained_begin(blk->dev_opaque);
2813 /* Note that blk->root may not be accessible here yet if we are just
2814 * attaching to a BlockDriverState that is drained. Use child instead. */
2816 if (qatomic_fetch_inc(&tgm->io_limits_disabled) == 0) {
2817 throttle_group_restart_tgm(tgm);
2821 static bool blk_root_drained_poll(BdrvChild *child)
2823 BlockBackend *blk = child->opaque;
2825 assert(qatomic_read(&blk->quiesce_counter));
2827 if (blk->dev_ops && blk->dev_ops->drained_poll) {
2828 busy = blk->dev_ops->drained_poll(blk->dev_opaque);
2830 return busy || !!blk->in_flight;
2833 static void blk_root_drained_end(BdrvChild *child)
2835 BlockBackend *blk = child->opaque;
2836 assert(qatomic_read(&blk->quiesce_counter));
2838 assert(blk->public.throttle_group_member.io_limits_disabled);
2839 qatomic_dec(&blk->public.throttle_group_member.io_limits_disabled);
2841 if (qatomic_fetch_dec(&blk->quiesce_counter) == 1) {
2842 if (blk->dev_ops && blk->dev_ops->drained_end) {
2843 blk->dev_ops->drained_end(blk->dev_opaque);
2845 qemu_mutex_lock(&blk->queued_requests_lock);
2846 while (qemu_co_enter_next(&blk->queued_requests,
2847 &blk->queued_requests_lock)) {
2848 /* Resume all queued requests */
2850 qemu_mutex_unlock(&blk->queued_requests_lock);
2854 bool blk_register_buf(BlockBackend *blk, void *host, size_t size, Error **errp)
2856 BlockDriverState *bs = blk_bs(blk);
2858 GLOBAL_STATE_CODE();
2861 return bdrv_register_buf(bs, host, size, errp);
2866 void blk_unregister_buf(BlockBackend *blk, void *host, size_t size)
2868 BlockDriverState *bs = blk_bs(blk);
2870 GLOBAL_STATE_CODE();
2873 bdrv_unregister_buf(bs, host, size);
2877 int coroutine_fn blk_co_copy_range(BlockBackend *blk_in, int64_t off_in,
2878 BlockBackend *blk_out, int64_t off_out,
2879 int64_t bytes, BdrvRequestFlags read_flags,
2880 BdrvRequestFlags write_flags)
2884 GRAPH_RDLOCK_GUARD();
2886 r = blk_check_byte_request(blk_in, off_in, bytes);
2890 r = blk_check_byte_request(blk_out, off_out, bytes);
2895 return bdrv_co_copy_range(blk_in->root, off_in,
2896 blk_out->root, off_out,
2897 bytes, read_flags, write_flags);
2900 const BdrvChild *blk_root(BlockBackend *blk)
2902 GLOBAL_STATE_CODE();
2906 int blk_make_empty(BlockBackend *blk, Error **errp)
2908 GLOBAL_STATE_CODE();
2909 GRAPH_RDLOCK_GUARD_MAINLOOP();
2911 if (!blk_is_available(blk)) {
2912 error_setg(errp, "No medium inserted");
2916 return bdrv_make_empty(blk->root, errp);