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/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"
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 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
);
42 QLIST_ENTRY(BlockBackendAioNotifier
) list
;
43 } BlockBackendAioNotifier
;
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
;
59 /* the block size for which the guest device expects atomicity */
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"). */
71 BlockdevOnError on_read_error
, on_write_error
;
72 bool iostatus_enabled
;
73 BlockDeviceIoStatus iostatus
;
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
;
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
{
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
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 */
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
,
142 static char *blk_root_get_parent_desc(BdrvChild
*child
)
144 BlockBackend
*blk
= child
->opaque
;
148 return g_strdup(blk
->name
);
151 dev_id
= blk_get_attached_dev_id(blk
);
155 /* TODO Callback into the BB owner for something more detailed */
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
) {
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 blk_root_activate(BdrvChild
*child
, Error
**errp
)
192 BlockBackend
*blk
= child
->opaque
;
193 Error
*local_err
= NULL
;
195 if (!blk
->disable_perm
) {
199 blk
->disable_perm
= false;
201 blk_set_perm(blk
, blk
->perm
, BLK_PERM_ALL
, &local_err
);
203 error_propagate(errp
, local_err
);
204 blk
->disable_perm
= true;
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. */
213 blk
->vmsh
= qemu_add_vm_change_state_handler(blk_vm_state_changed
,
219 blk_set_perm(blk
, blk
->perm
, blk
->shared_perm
, &local_err
);
221 error_propagate(errp
, local_err
);
222 blk
->disable_perm
= true;
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]) {
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
))) {
248 return blk
->force_allow_inactivate
;
251 static int blk_root_inactivate(BdrvChild
*child
)
253 BlockBackend
*blk
= child
->opaque
;
255 if (blk
->disable_perm
) {
259 if (!blk_can_inactivate(blk
)) {
263 blk
->disable_perm
= true;
265 bdrv_child_try_set_perm(blk
->root
, 0, BLK_PERM_ALL
, &error_abort
);
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
,
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
,
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
)
338 blk
= g_new0(BlockBackend
, 1);
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
);
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) {
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
395 BlockBackend
*blk_new_open(const char *filename
, const char *reference
,
396 QDict
*options
, int flags
, Error
**errp
)
399 BlockDriverState
*bs
;
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
);
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
);
438 static void blk_delete(BlockBackend
*blk
)
440 assert(!blk
->refcnt
);
443 if (blk
->public.throttle_group_member
.throttle_state
) {
444 blk_io_limits_disable(blk
);
450 qemu_del_vm_change_state_handler(blk
->vmsh
);
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
);
462 static void drive_info_del(DriveInfo
*dinfo
)
467 qemu_opts_del(dinfo
->opts
);
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);
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
)
494 assert(blk
->refcnt
> 0);
495 if (blk
->refcnt
> 1) {
499 /* blk_drain() cannot resurrect blk, nobody held a reference */
500 assert(blk
->refcnt
== 1);
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
);
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)) {
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
;
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
));
580 it
->phase
= BDRV_NEXT_MONITOR_OWNED
;
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 */
589 it
->bs
= bdrv_next_monitor_owned(it
->bs
);
591 } while (bs
&& bdrv_has_blk(bs
));
601 static void bdrv_next_reset(BdrvNextIterator
*it
)
603 *it
= (BdrvNextIterator
) {
604 .phase
= BDRV_NEXT_BACKEND_ROOTS
,
608 BlockDriverState
*bdrv_first(BdrvNextIterator
*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
) {
623 bdrv_unref(blk_bs(it
->blk
));
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
)
646 assert(name
&& name
[0]);
648 if (!id_wellformed(name
)) {
649 error_setg(errp
, "Invalid device name");
652 if (blk_by_name(name
)) {
653 error_setg(errp
, "Device with id '%s' already exists", name
);
656 if (bdrv_find_node(name
)) {
658 "Device name '%s' conflicts with an existing node name",
663 blk
->name
= g_strdup(name
);
664 QTAILQ_INSERT_TAIL(&monitor_block_backends
, blk
, monitor_link
);
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
)
678 QTAILQ_REMOVE(&monitor_block_backends
, blk
, monitor_link
);
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
;
701 while ((blk
= blk_next(blk
)) != NULL
) {
702 if (!strcmp(name
, blk
->name
)) {
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
)
720 QLIST_FOREACH(child
, &bs
->parents
, next_parent
) {
721 if (child
->klass
== &child_root
) {
722 return child
->opaque
;
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
)
744 QLIST_FOREACH(c
, &bs
->parents
, next_parent
) {
745 if (c
->klass
!= &child_root
) {
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.
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
) {
789 * Returns a pointer to the publicly accessible fields of @blk.
791 BlockBackendPublic
*blk_get_public(BlockBackend
*blk
)
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
;
812 notifier_list_notify(&blk
->remove_bs_notifiers
, blk
);
813 if (tgm
->throttle_state
) {
815 bdrv_drained_begin(bs
);
816 throttle_group_detach_aio_context(tgm
);
817 throttle_group_attach_aio_context(tgm
, qemu_get_aio_context());
818 bdrv_drained_end(bs
);
821 blk_update_root_state(blk
);
823 /* bdrv_root_unref_child() will cause blk->root to become stale and may
824 * switch to a completion coroutine later on. Let's drain all I/O here
825 * to avoid that and a potential QEMU crash.
828 bdrv_root_unref_child(blk
->root
);
833 * Associates a new BlockDriverState with @blk.
835 int blk_insert_bs(BlockBackend
*blk
, BlockDriverState
*bs
, Error
**errp
)
837 ThrottleGroupMember
*tgm
= &blk
->public.throttle_group_member
;
839 blk
->root
= bdrv_root_attach_child(bs
, "root", &child_root
,
840 BDRV_CHILD_FILTERED
| BDRV_CHILD_PRIMARY
,
841 blk
->ctx
, blk
->perm
, blk
->shared_perm
,
843 if (blk
->root
== NULL
) {
847 notifier_list_notify(&blk
->insert_bs_notifiers
, blk
);
848 if (tgm
->throttle_state
) {
849 throttle_group_detach_aio_context(tgm
);
850 throttle_group_attach_aio_context(tgm
, bdrv_get_aio_context(bs
));
857 * Sets the permission bitmasks that the user of the BlockBackend needs.
859 int blk_set_perm(BlockBackend
*blk
, uint64_t perm
, uint64_t shared_perm
,
864 if (blk
->root
&& !blk
->disable_perm
) {
865 ret
= bdrv_child_try_set_perm(blk
->root
, perm
, shared_perm
, errp
);
872 blk
->shared_perm
= shared_perm
;
877 void blk_get_perm(BlockBackend
*blk
, uint64_t *perm
, uint64_t *shared_perm
)
880 *shared_perm
= blk
->shared_perm
;
884 * Attach device model @dev to @blk.
885 * Return 0 on success, -EBUSY when a device model is attached already.
887 int blk_attach_dev(BlockBackend
*blk
, DeviceState
*dev
)
893 /* While migration is still incoming, we don't need to apply the
894 * permissions of guest device BlockBackends. We might still have a block
895 * job or NBD server writing to the image for storage migration. */
896 if (runstate_check(RUN_STATE_INMIGRATE
)) {
897 blk
->disable_perm
= true;
902 blk_iostatus_reset(blk
);
908 * Detach device model @dev from @blk.
909 * @dev must be currently attached to @blk.
911 void blk_detach_dev(BlockBackend
*blk
, DeviceState
*dev
)
913 assert(blk
->dev
== dev
);
916 blk
->dev_opaque
= NULL
;
917 blk
->guest_block_size
= 512;
918 blk_set_perm(blk
, 0, BLK_PERM_ALL
, &error_abort
);
923 * Return the device model attached to @blk if any, else null.
925 DeviceState
*blk_get_attached_dev(BlockBackend
*blk
)
930 /* Return the qdev ID, or if no ID is assigned the QOM path, of the block
931 * device attached to the BlockBackend. */
932 char *blk_get_attached_dev_id(BlockBackend
*blk
)
934 DeviceState
*dev
= blk
->dev
;
938 } else if (dev
->id
) {
939 return g_strdup(dev
->id
);
942 return object_get_canonical_path(OBJECT(dev
)) ?: g_strdup("");
946 * Return the BlockBackend which has the device model @dev attached if it
949 * @dev must not be null.
951 BlockBackend
*blk_by_dev(void *dev
)
953 BlockBackend
*blk
= NULL
;
956 while ((blk
= blk_all_next(blk
)) != NULL
) {
957 if (blk
->dev
== dev
) {
965 * Set @blk's device model callbacks to @ops.
966 * @opaque is the opaque argument to pass to the callbacks.
967 * This is for use by device models.
969 void blk_set_dev_ops(BlockBackend
*blk
, const BlockDevOps
*ops
,
973 blk
->dev_opaque
= opaque
;
975 /* Are we currently quiesced? Should we enforce this right now? */
976 if (blk
->quiesce_counter
&& ops
->drained_begin
) {
977 ops
->drained_begin(opaque
);
982 * Notify @blk's attached device model of media change.
984 * If @load is true, notify of media load. This action can fail, meaning that
985 * the medium cannot be loaded. @errp is set then.
987 * If @load is false, notify of media eject. This can never fail.
989 * Also send DEVICE_TRAY_MOVED events as appropriate.
991 void blk_dev_change_media_cb(BlockBackend
*blk
, bool load
, Error
**errp
)
993 if (blk
->dev_ops
&& blk
->dev_ops
->change_media_cb
) {
994 bool tray_was_open
, tray_is_open
;
995 Error
*local_err
= NULL
;
997 tray_was_open
= blk_dev_is_tray_open(blk
);
998 blk
->dev_ops
->change_media_cb(blk
->dev_opaque
, load
, &local_err
);
1000 assert(load
== true);
1001 error_propagate(errp
, local_err
);
1004 tray_is_open
= blk_dev_is_tray_open(blk
);
1006 if (tray_was_open
!= tray_is_open
) {
1007 char *id
= blk_get_attached_dev_id(blk
);
1008 qapi_event_send_device_tray_moved(blk_name(blk
), id
, tray_is_open
);
1014 static void blk_root_change_media(BdrvChild
*child
, bool load
)
1016 blk_dev_change_media_cb(child
->opaque
, load
, NULL
);
1020 * Does @blk's attached device model have removable media?
1021 * %true if no device model is attached.
1023 bool blk_dev_has_removable_media(BlockBackend
*blk
)
1025 return !blk
->dev
|| (blk
->dev_ops
&& blk
->dev_ops
->change_media_cb
);
1029 * Does @blk's attached device model have a tray?
1031 bool blk_dev_has_tray(BlockBackend
*blk
)
1033 return blk
->dev_ops
&& blk
->dev_ops
->is_tray_open
;
1037 * Notify @blk's attached device model of a media eject request.
1038 * If @force is true, the medium is about to be yanked out forcefully.
1040 void blk_dev_eject_request(BlockBackend
*blk
, bool force
)
1042 if (blk
->dev_ops
&& blk
->dev_ops
->eject_request_cb
) {
1043 blk
->dev_ops
->eject_request_cb(blk
->dev_opaque
, force
);
1048 * Does @blk's attached device model have a tray, and is it open?
1050 bool blk_dev_is_tray_open(BlockBackend
*blk
)
1052 if (blk_dev_has_tray(blk
)) {
1053 return blk
->dev_ops
->is_tray_open(blk
->dev_opaque
);
1059 * Does @blk's attached device model have the medium locked?
1060 * %false if the device model has no such lock.
1062 bool blk_dev_is_medium_locked(BlockBackend
*blk
)
1064 if (blk
->dev_ops
&& blk
->dev_ops
->is_medium_locked
) {
1065 return blk
->dev_ops
->is_medium_locked(blk
->dev_opaque
);
1071 * Notify @blk's attached device model of a backend size change.
1073 static void blk_root_resize(BdrvChild
*child
)
1075 BlockBackend
*blk
= child
->opaque
;
1077 if (blk
->dev_ops
&& blk
->dev_ops
->resize_cb
) {
1078 blk
->dev_ops
->resize_cb(blk
->dev_opaque
);
1082 void blk_iostatus_enable(BlockBackend
*blk
)
1084 blk
->iostatus_enabled
= true;
1085 blk
->iostatus
= BLOCK_DEVICE_IO_STATUS_OK
;
1088 /* The I/O status is only enabled if the drive explicitly
1089 * enables it _and_ the VM is configured to stop on errors */
1090 bool blk_iostatus_is_enabled(const BlockBackend
*blk
)
1092 return (blk
->iostatus_enabled
&&
1093 (blk
->on_write_error
== BLOCKDEV_ON_ERROR_ENOSPC
||
1094 blk
->on_write_error
== BLOCKDEV_ON_ERROR_STOP
||
1095 blk
->on_read_error
== BLOCKDEV_ON_ERROR_STOP
));
1098 BlockDeviceIoStatus
blk_iostatus(const BlockBackend
*blk
)
1100 return blk
->iostatus
;
1103 void blk_iostatus_disable(BlockBackend
*blk
)
1105 blk
->iostatus_enabled
= false;
1108 void blk_iostatus_reset(BlockBackend
*blk
)
1110 if (blk_iostatus_is_enabled(blk
)) {
1111 blk
->iostatus
= BLOCK_DEVICE_IO_STATUS_OK
;
1115 void blk_iostatus_set_err(BlockBackend
*blk
, int error
)
1117 assert(blk_iostatus_is_enabled(blk
));
1118 if (blk
->iostatus
== BLOCK_DEVICE_IO_STATUS_OK
) {
1119 blk
->iostatus
= error
== ENOSPC
? BLOCK_DEVICE_IO_STATUS_NOSPACE
:
1120 BLOCK_DEVICE_IO_STATUS_FAILED
;
1124 void blk_set_allow_write_beyond_eof(BlockBackend
*blk
, bool allow
)
1126 blk
->allow_write_beyond_eof
= allow
;
1129 void blk_set_allow_aio_context_change(BlockBackend
*blk
, bool allow
)
1131 blk
->allow_aio_context_change
= allow
;
1134 void blk_set_disable_request_queuing(BlockBackend
*blk
, bool disable
)
1136 blk
->disable_request_queuing
= disable
;
1139 static int blk_check_byte_request(BlockBackend
*blk
, int64_t offset
,
1144 if (size
> INT_MAX
) {
1148 if (!blk_is_available(blk
)) {
1156 if (!blk
->allow_write_beyond_eof
) {
1157 len
= blk_getlength(blk
);
1162 if (offset
> len
|| len
- offset
< size
) {
1170 /* To be called between exactly one pair of blk_inc/dec_in_flight() */
1171 static void coroutine_fn
blk_wait_while_drained(BlockBackend
*blk
)
1173 assert(blk
->in_flight
> 0);
1175 if (blk
->quiesce_counter
&& !blk
->disable_request_queuing
) {
1176 blk_dec_in_flight(blk
);
1177 qemu_co_queue_wait(&blk
->queued_requests
, NULL
);
1178 blk_inc_in_flight(blk
);
1182 /* To be called between exactly one pair of blk_inc/dec_in_flight() */
1183 static int coroutine_fn
1184 blk_do_preadv(BlockBackend
*blk
, int64_t offset
, unsigned int bytes
,
1185 QEMUIOVector
*qiov
, BdrvRequestFlags flags
)
1188 BlockDriverState
*bs
;
1190 blk_wait_while_drained(blk
);
1192 /* Call blk_bs() only after waiting, the graph may have changed */
1194 trace_blk_co_preadv(blk
, bs
, offset
, bytes
, flags
);
1196 ret
= blk_check_byte_request(blk
, offset
, bytes
);
1201 bdrv_inc_in_flight(bs
);
1203 /* throttling disk I/O */
1204 if (blk
->public.throttle_group_member
.throttle_state
) {
1205 throttle_group_co_io_limits_intercept(&blk
->public.throttle_group_member
,
1209 ret
= bdrv_co_preadv(blk
->root
, offset
, bytes
, qiov
, flags
);
1210 bdrv_dec_in_flight(bs
);
1214 int coroutine_fn
blk_co_preadv(BlockBackend
*blk
, int64_t offset
,
1215 unsigned int bytes
, QEMUIOVector
*qiov
,
1216 BdrvRequestFlags flags
)
1220 blk_inc_in_flight(blk
);
1221 ret
= blk_do_preadv(blk
, offset
, bytes
, qiov
, flags
);
1222 blk_dec_in_flight(blk
);
1227 /* To be called between exactly one pair of blk_inc/dec_in_flight() */
1228 static int coroutine_fn
1229 blk_do_pwritev_part(BlockBackend
*blk
, int64_t offset
, unsigned int bytes
,
1230 QEMUIOVector
*qiov
, size_t qiov_offset
,
1231 BdrvRequestFlags flags
)
1234 BlockDriverState
*bs
;
1236 blk_wait_while_drained(blk
);
1238 /* Call blk_bs() only after waiting, the graph may have changed */
1240 trace_blk_co_pwritev(blk
, bs
, offset
, bytes
, flags
);
1242 ret
= blk_check_byte_request(blk
, offset
, bytes
);
1247 bdrv_inc_in_flight(bs
);
1248 /* throttling disk I/O */
1249 if (blk
->public.throttle_group_member
.throttle_state
) {
1250 throttle_group_co_io_limits_intercept(&blk
->public.throttle_group_member
,
1254 if (!blk
->enable_write_cache
) {
1255 flags
|= BDRV_REQ_FUA
;
1258 ret
= bdrv_co_pwritev_part(blk
->root
, offset
, bytes
, qiov
, qiov_offset
,
1260 bdrv_dec_in_flight(bs
);
1264 int coroutine_fn
blk_co_pwritev_part(BlockBackend
*blk
, int64_t offset
,
1266 QEMUIOVector
*qiov
, size_t qiov_offset
,
1267 BdrvRequestFlags flags
)
1271 blk_inc_in_flight(blk
);
1272 ret
= blk_do_pwritev_part(blk
, offset
, bytes
, qiov
, qiov_offset
, flags
);
1273 blk_dec_in_flight(blk
);
1278 int coroutine_fn
blk_co_pwritev(BlockBackend
*blk
, int64_t offset
,
1279 unsigned int bytes
, QEMUIOVector
*qiov
,
1280 BdrvRequestFlags flags
)
1282 return blk_co_pwritev_part(blk
, offset
, bytes
, qiov
, 0, flags
);
1285 typedef struct BlkRwCo
{
1290 BdrvRequestFlags flags
;
1293 static void blk_read_entry(void *opaque
)
1295 BlkRwCo
*rwco
= opaque
;
1296 QEMUIOVector
*qiov
= rwco
->iobuf
;
1298 rwco
->ret
= blk_do_preadv(rwco
->blk
, rwco
->offset
, qiov
->size
,
1303 static void blk_write_entry(void *opaque
)
1305 BlkRwCo
*rwco
= opaque
;
1306 QEMUIOVector
*qiov
= rwco
->iobuf
;
1308 rwco
->ret
= blk_do_pwritev_part(rwco
->blk
, rwco
->offset
, qiov
->size
,
1309 qiov
, 0, rwco
->flags
);
1313 static int blk_prw(BlockBackend
*blk
, int64_t offset
, uint8_t *buf
,
1314 int64_t bytes
, CoroutineEntry co_entry
,
1315 BdrvRequestFlags flags
)
1317 QEMUIOVector qiov
= QEMU_IOVEC_INIT_BUF(qiov
, buf
, bytes
);
1326 blk_inc_in_flight(blk
);
1327 if (qemu_in_coroutine()) {
1328 /* Fast-path if already in coroutine context */
1331 Coroutine
*co
= qemu_coroutine_create(co_entry
, &rwco
);
1332 bdrv_coroutine_enter(blk_bs(blk
), co
);
1333 BDRV_POLL_WHILE(blk_bs(blk
), rwco
.ret
== NOT_DONE
);
1335 blk_dec_in_flight(blk
);
1340 int blk_pwrite_zeroes(BlockBackend
*blk
, int64_t offset
,
1341 int bytes
, BdrvRequestFlags flags
)
1343 return blk_prw(blk
, offset
, NULL
, bytes
, blk_write_entry
,
1344 flags
| BDRV_REQ_ZERO_WRITE
);
1347 int blk_make_zero(BlockBackend
*blk
, BdrvRequestFlags flags
)
1349 return bdrv_make_zero(blk
->root
, flags
);
1352 void blk_inc_in_flight(BlockBackend
*blk
)
1354 atomic_inc(&blk
->in_flight
);
1357 void blk_dec_in_flight(BlockBackend
*blk
)
1359 atomic_dec(&blk
->in_flight
);
1363 static void error_callback_bh(void *opaque
)
1365 struct BlockBackendAIOCB
*acb
= opaque
;
1367 blk_dec_in_flight(acb
->blk
);
1368 acb
->common
.cb(acb
->common
.opaque
, acb
->ret
);
1369 qemu_aio_unref(acb
);
1372 BlockAIOCB
*blk_abort_aio_request(BlockBackend
*blk
,
1373 BlockCompletionFunc
*cb
,
1374 void *opaque
, int ret
)
1376 struct BlockBackendAIOCB
*acb
;
1378 blk_inc_in_flight(blk
);
1379 acb
= blk_aio_get(&block_backend_aiocb_info
, blk
, cb
, opaque
);
1383 replay_bh_schedule_oneshot_event(blk_get_aio_context(blk
),
1384 error_callback_bh
, acb
);
1385 return &acb
->common
;
1388 typedef struct BlkAioEmAIOCB
{
1395 static const AIOCBInfo blk_aio_em_aiocb_info
= {
1396 .aiocb_size
= sizeof(BlkAioEmAIOCB
),
1399 static void blk_aio_complete(BlkAioEmAIOCB
*acb
)
1401 if (acb
->has_returned
) {
1402 acb
->common
.cb(acb
->common
.opaque
, acb
->rwco
.ret
);
1403 blk_dec_in_flight(acb
->rwco
.blk
);
1404 qemu_aio_unref(acb
);
1408 static void blk_aio_complete_bh(void *opaque
)
1410 BlkAioEmAIOCB
*acb
= opaque
;
1411 assert(acb
->has_returned
);
1412 blk_aio_complete(acb
);
1415 static BlockAIOCB
*blk_aio_prwv(BlockBackend
*blk
, int64_t offset
, int bytes
,
1416 void *iobuf
, CoroutineEntry co_entry
,
1417 BdrvRequestFlags flags
,
1418 BlockCompletionFunc
*cb
, void *opaque
)
1423 blk_inc_in_flight(blk
);
1424 acb
= blk_aio_get(&blk_aio_em_aiocb_info
, blk
, cb
, opaque
);
1425 acb
->rwco
= (BlkRwCo
) {
1433 acb
->has_returned
= false;
1435 co
= qemu_coroutine_create(co_entry
, acb
);
1436 bdrv_coroutine_enter(blk_bs(blk
), co
);
1438 acb
->has_returned
= true;
1439 if (acb
->rwco
.ret
!= NOT_DONE
) {
1440 replay_bh_schedule_oneshot_event(blk_get_aio_context(blk
),
1441 blk_aio_complete_bh
, acb
);
1444 return &acb
->common
;
1447 static void blk_aio_read_entry(void *opaque
)
1449 BlkAioEmAIOCB
*acb
= opaque
;
1450 BlkRwCo
*rwco
= &acb
->rwco
;
1451 QEMUIOVector
*qiov
= rwco
->iobuf
;
1453 assert(qiov
->size
== acb
->bytes
);
1454 rwco
->ret
= blk_do_preadv(rwco
->blk
, rwco
->offset
, acb
->bytes
,
1456 blk_aio_complete(acb
);
1459 static void blk_aio_write_entry(void *opaque
)
1461 BlkAioEmAIOCB
*acb
= opaque
;
1462 BlkRwCo
*rwco
= &acb
->rwco
;
1463 QEMUIOVector
*qiov
= rwco
->iobuf
;
1465 assert(!qiov
|| qiov
->size
== acb
->bytes
);
1466 rwco
->ret
= blk_do_pwritev_part(rwco
->blk
, rwco
->offset
, acb
->bytes
,
1467 qiov
, 0, rwco
->flags
);
1468 blk_aio_complete(acb
);
1471 BlockAIOCB
*blk_aio_pwrite_zeroes(BlockBackend
*blk
, int64_t offset
,
1472 int count
, BdrvRequestFlags flags
,
1473 BlockCompletionFunc
*cb
, void *opaque
)
1475 return blk_aio_prwv(blk
, offset
, count
, NULL
, blk_aio_write_entry
,
1476 flags
| BDRV_REQ_ZERO_WRITE
, cb
, opaque
);
1479 int blk_pread(BlockBackend
*blk
, int64_t offset
, void *buf
, int count
)
1481 int ret
= blk_prw(blk
, offset
, buf
, count
, blk_read_entry
, 0);
1488 int blk_pwrite(BlockBackend
*blk
, int64_t offset
, const void *buf
, int count
,
1489 BdrvRequestFlags flags
)
1491 int ret
= blk_prw(blk
, offset
, (void *) buf
, count
, blk_write_entry
,
1499 int64_t blk_getlength(BlockBackend
*blk
)
1501 if (!blk_is_available(blk
)) {
1505 return bdrv_getlength(blk_bs(blk
));
1508 void blk_get_geometry(BlockBackend
*blk
, uint64_t *nb_sectors_ptr
)
1511 *nb_sectors_ptr
= 0;
1513 bdrv_get_geometry(blk_bs(blk
), nb_sectors_ptr
);
1517 int64_t blk_nb_sectors(BlockBackend
*blk
)
1519 if (!blk_is_available(blk
)) {
1523 return bdrv_nb_sectors(blk_bs(blk
));
1526 BlockAIOCB
*blk_aio_preadv(BlockBackend
*blk
, int64_t offset
,
1527 QEMUIOVector
*qiov
, BdrvRequestFlags flags
,
1528 BlockCompletionFunc
*cb
, void *opaque
)
1530 return blk_aio_prwv(blk
, offset
, qiov
->size
, qiov
,
1531 blk_aio_read_entry
, flags
, cb
, opaque
);
1534 BlockAIOCB
*blk_aio_pwritev(BlockBackend
*blk
, int64_t offset
,
1535 QEMUIOVector
*qiov
, BdrvRequestFlags flags
,
1536 BlockCompletionFunc
*cb
, void *opaque
)
1538 return blk_aio_prwv(blk
, offset
, qiov
->size
, qiov
,
1539 blk_aio_write_entry
, flags
, cb
, opaque
);
1542 void blk_aio_cancel(BlockAIOCB
*acb
)
1544 bdrv_aio_cancel(acb
);
1547 void blk_aio_cancel_async(BlockAIOCB
*acb
)
1549 bdrv_aio_cancel_async(acb
);
1552 /* To be called between exactly one pair of blk_inc/dec_in_flight() */
1553 static int coroutine_fn
1554 blk_do_ioctl(BlockBackend
*blk
, unsigned long int req
, void *buf
)
1556 blk_wait_while_drained(blk
);
1558 if (!blk_is_available(blk
)) {
1562 return bdrv_co_ioctl(blk_bs(blk
), req
, buf
);
1565 static void blk_ioctl_entry(void *opaque
)
1567 BlkRwCo
*rwco
= opaque
;
1568 QEMUIOVector
*qiov
= rwco
->iobuf
;
1570 rwco
->ret
= blk_do_ioctl(rwco
->blk
, rwco
->offset
, qiov
->iov
[0].iov_base
);
1574 int blk_ioctl(BlockBackend
*blk
, unsigned long int req
, void *buf
)
1576 return blk_prw(blk
, req
, buf
, 0, blk_ioctl_entry
, 0);
1579 static void blk_aio_ioctl_entry(void *opaque
)
1581 BlkAioEmAIOCB
*acb
= opaque
;
1582 BlkRwCo
*rwco
= &acb
->rwco
;
1584 rwco
->ret
= blk_do_ioctl(rwco
->blk
, rwco
->offset
, rwco
->iobuf
);
1586 blk_aio_complete(acb
);
1589 BlockAIOCB
*blk_aio_ioctl(BlockBackend
*blk
, unsigned long int req
, void *buf
,
1590 BlockCompletionFunc
*cb
, void *opaque
)
1592 return blk_aio_prwv(blk
, req
, 0, buf
, blk_aio_ioctl_entry
, 0, cb
, opaque
);
1595 /* To be called between exactly one pair of blk_inc/dec_in_flight() */
1596 static int coroutine_fn
1597 blk_do_pdiscard(BlockBackend
*blk
, int64_t offset
, int bytes
)
1601 blk_wait_while_drained(blk
);
1603 ret
= blk_check_byte_request(blk
, offset
, bytes
);
1608 return bdrv_co_pdiscard(blk
->root
, offset
, bytes
);
1611 static void blk_aio_pdiscard_entry(void *opaque
)
1613 BlkAioEmAIOCB
*acb
= opaque
;
1614 BlkRwCo
*rwco
= &acb
->rwco
;
1616 rwco
->ret
= blk_do_pdiscard(rwco
->blk
, rwco
->offset
, acb
->bytes
);
1617 blk_aio_complete(acb
);
1620 BlockAIOCB
*blk_aio_pdiscard(BlockBackend
*blk
,
1621 int64_t offset
, int bytes
,
1622 BlockCompletionFunc
*cb
, void *opaque
)
1624 return blk_aio_prwv(blk
, offset
, bytes
, NULL
, blk_aio_pdiscard_entry
, 0,
1628 int coroutine_fn
blk_co_pdiscard(BlockBackend
*blk
, int64_t offset
, int bytes
)
1632 blk_inc_in_flight(blk
);
1633 ret
= blk_do_pdiscard(blk
, offset
, bytes
);
1634 blk_dec_in_flight(blk
);
1639 static void blk_pdiscard_entry(void *opaque
)
1641 BlkRwCo
*rwco
= opaque
;
1642 QEMUIOVector
*qiov
= rwco
->iobuf
;
1644 rwco
->ret
= blk_do_pdiscard(rwco
->blk
, rwco
->offset
, qiov
->size
);
1648 int blk_pdiscard(BlockBackend
*blk
, int64_t offset
, int bytes
)
1650 return blk_prw(blk
, offset
, NULL
, bytes
, blk_pdiscard_entry
, 0);
1653 /* To be called between exactly one pair of blk_inc/dec_in_flight() */
1654 static int coroutine_fn
blk_do_flush(BlockBackend
*blk
)
1656 blk_wait_while_drained(blk
);
1658 if (!blk_is_available(blk
)) {
1662 return bdrv_co_flush(blk_bs(blk
));
1665 static void blk_aio_flush_entry(void *opaque
)
1667 BlkAioEmAIOCB
*acb
= opaque
;
1668 BlkRwCo
*rwco
= &acb
->rwco
;
1670 rwco
->ret
= blk_do_flush(rwco
->blk
);
1671 blk_aio_complete(acb
);
1674 BlockAIOCB
*blk_aio_flush(BlockBackend
*blk
,
1675 BlockCompletionFunc
*cb
, void *opaque
)
1677 return blk_aio_prwv(blk
, 0, 0, NULL
, blk_aio_flush_entry
, 0, cb
, opaque
);
1680 int coroutine_fn
blk_co_flush(BlockBackend
*blk
)
1684 blk_inc_in_flight(blk
);
1685 ret
= blk_do_flush(blk
);
1686 blk_dec_in_flight(blk
);
1691 static void blk_flush_entry(void *opaque
)
1693 BlkRwCo
*rwco
= opaque
;
1694 rwco
->ret
= blk_do_flush(rwco
->blk
);
1698 int blk_flush(BlockBackend
*blk
)
1700 return blk_prw(blk
, 0, NULL
, 0, blk_flush_entry
, 0);
1703 void blk_drain(BlockBackend
*blk
)
1705 BlockDriverState
*bs
= blk_bs(blk
);
1708 bdrv_drained_begin(bs
);
1711 /* We may have -ENOMEDIUM completions in flight */
1712 AIO_WAIT_WHILE(blk_get_aio_context(blk
),
1713 atomic_mb_read(&blk
->in_flight
) > 0);
1716 bdrv_drained_end(bs
);
1720 void blk_drain_all(void)
1722 BlockBackend
*blk
= NULL
;
1724 bdrv_drain_all_begin();
1726 while ((blk
= blk_all_next(blk
)) != NULL
) {
1727 AioContext
*ctx
= blk_get_aio_context(blk
);
1729 aio_context_acquire(ctx
);
1731 /* We may have -ENOMEDIUM completions in flight */
1732 AIO_WAIT_WHILE(ctx
, atomic_mb_read(&blk
->in_flight
) > 0);
1734 aio_context_release(ctx
);
1737 bdrv_drain_all_end();
1740 void blk_set_on_error(BlockBackend
*blk
, BlockdevOnError on_read_error
,
1741 BlockdevOnError on_write_error
)
1743 blk
->on_read_error
= on_read_error
;
1744 blk
->on_write_error
= on_write_error
;
1747 BlockdevOnError
blk_get_on_error(BlockBackend
*blk
, bool is_read
)
1749 return is_read
? blk
->on_read_error
: blk
->on_write_error
;
1752 BlockErrorAction
blk_get_error_action(BlockBackend
*blk
, bool is_read
,
1755 BlockdevOnError on_err
= blk_get_on_error(blk
, is_read
);
1758 case BLOCKDEV_ON_ERROR_ENOSPC
:
1759 return (error
== ENOSPC
) ?
1760 BLOCK_ERROR_ACTION_STOP
: BLOCK_ERROR_ACTION_REPORT
;
1761 case BLOCKDEV_ON_ERROR_STOP
:
1762 return BLOCK_ERROR_ACTION_STOP
;
1763 case BLOCKDEV_ON_ERROR_REPORT
:
1764 return BLOCK_ERROR_ACTION_REPORT
;
1765 case BLOCKDEV_ON_ERROR_IGNORE
:
1766 return BLOCK_ERROR_ACTION_IGNORE
;
1767 case BLOCKDEV_ON_ERROR_AUTO
:
1773 static void send_qmp_error_event(BlockBackend
*blk
,
1774 BlockErrorAction action
,
1775 bool is_read
, int error
)
1777 IoOperationType optype
;
1778 BlockDriverState
*bs
= blk_bs(blk
);
1780 optype
= is_read
? IO_OPERATION_TYPE_READ
: IO_OPERATION_TYPE_WRITE
;
1781 qapi_event_send_block_io_error(blk_name(blk
), !!bs
,
1782 bs
? bdrv_get_node_name(bs
) : NULL
, optype
,
1783 action
, blk_iostatus_is_enabled(blk
),
1784 error
== ENOSPC
, strerror(error
));
1787 /* This is done by device models because, while the block layer knows
1788 * about the error, it does not know whether an operation comes from
1789 * the device or the block layer (from a job, for example).
1791 void blk_error_action(BlockBackend
*blk
, BlockErrorAction action
,
1792 bool is_read
, int error
)
1796 if (action
== BLOCK_ERROR_ACTION_STOP
) {
1797 /* First set the iostatus, so that "info block" returns an iostatus
1798 * that matches the events raised so far (an additional error iostatus
1799 * is fine, but not a lost one).
1801 blk_iostatus_set_err(blk
, error
);
1803 /* Then raise the request to stop the VM and the event.
1804 * qemu_system_vmstop_request_prepare has two effects. First,
1805 * it ensures that the STOP event always comes after the
1806 * BLOCK_IO_ERROR event. Second, it ensures that even if management
1807 * can observe the STOP event and do a "cont" before the STOP
1808 * event is issued, the VM will not stop. In this case, vm_start()
1809 * also ensures that the STOP/RESUME pair of events is emitted.
1811 qemu_system_vmstop_request_prepare();
1812 send_qmp_error_event(blk
, action
, is_read
, error
);
1813 qemu_system_vmstop_request(RUN_STATE_IO_ERROR
);
1815 send_qmp_error_event(blk
, action
, is_read
, error
);
1819 bool blk_is_read_only(BlockBackend
*blk
)
1821 BlockDriverState
*bs
= blk_bs(blk
);
1824 return bdrv_is_read_only(bs
);
1826 return blk
->root_state
.read_only
;
1830 bool blk_is_sg(BlockBackend
*blk
)
1832 BlockDriverState
*bs
= blk_bs(blk
);
1838 return bdrv_is_sg(bs
);
1841 bool blk_enable_write_cache(BlockBackend
*blk
)
1843 return blk
->enable_write_cache
;
1846 void blk_set_enable_write_cache(BlockBackend
*blk
, bool wce
)
1848 blk
->enable_write_cache
= wce
;
1851 void blk_invalidate_cache(BlockBackend
*blk
, Error
**errp
)
1853 BlockDriverState
*bs
= blk_bs(blk
);
1856 error_setg(errp
, "Device '%s' has no medium", blk
->name
);
1860 bdrv_invalidate_cache(bs
, errp
);
1863 bool blk_is_inserted(BlockBackend
*blk
)
1865 BlockDriverState
*bs
= blk_bs(blk
);
1867 return bs
&& bdrv_is_inserted(bs
);
1870 bool blk_is_available(BlockBackend
*blk
)
1872 return blk_is_inserted(blk
) && !blk_dev_is_tray_open(blk
);
1875 void blk_lock_medium(BlockBackend
*blk
, bool locked
)
1877 BlockDriverState
*bs
= blk_bs(blk
);
1880 bdrv_lock_medium(bs
, locked
);
1884 void blk_eject(BlockBackend
*blk
, bool eject_flag
)
1886 BlockDriverState
*bs
= blk_bs(blk
);
1890 bdrv_eject(bs
, eject_flag
);
1893 /* Whether or not we ejected on the backend,
1894 * the frontend experienced a tray event. */
1895 id
= blk_get_attached_dev_id(blk
);
1896 qapi_event_send_device_tray_moved(blk_name(blk
), id
,
1901 int blk_get_flags(BlockBackend
*blk
)
1903 BlockDriverState
*bs
= blk_bs(blk
);
1906 return bdrv_get_flags(bs
);
1908 return blk
->root_state
.open_flags
;
1912 /* Returns the minimum request alignment, in bytes; guaranteed nonzero */
1913 uint32_t blk_get_request_alignment(BlockBackend
*blk
)
1915 BlockDriverState
*bs
= blk_bs(blk
);
1916 return bs
? bs
->bl
.request_alignment
: BDRV_SECTOR_SIZE
;
1919 /* Returns the maximum transfer length, in bytes; guaranteed nonzero */
1920 uint32_t blk_get_max_transfer(BlockBackend
*blk
)
1922 BlockDriverState
*bs
= blk_bs(blk
);
1926 max
= bs
->bl
.max_transfer
;
1928 return MIN_NON_ZERO(max
, INT_MAX
);
1931 int blk_get_max_iov(BlockBackend
*blk
)
1933 return blk
->root
->bs
->bl
.max_iov
;
1936 void blk_set_guest_block_size(BlockBackend
*blk
, int align
)
1938 blk
->guest_block_size
= align
;
1941 void *blk_try_blockalign(BlockBackend
*blk
, size_t size
)
1943 return qemu_try_blockalign(blk
? blk_bs(blk
) : NULL
, size
);
1946 void *blk_blockalign(BlockBackend
*blk
, size_t size
)
1948 return qemu_blockalign(blk
? blk_bs(blk
) : NULL
, size
);
1951 bool blk_op_is_blocked(BlockBackend
*blk
, BlockOpType op
, Error
**errp
)
1953 BlockDriverState
*bs
= blk_bs(blk
);
1959 return bdrv_op_is_blocked(bs
, op
, errp
);
1962 void blk_op_unblock(BlockBackend
*blk
, BlockOpType op
, Error
*reason
)
1964 BlockDriverState
*bs
= blk_bs(blk
);
1967 bdrv_op_unblock(bs
, op
, reason
);
1971 void blk_op_block_all(BlockBackend
*blk
, Error
*reason
)
1973 BlockDriverState
*bs
= blk_bs(blk
);
1976 bdrv_op_block_all(bs
, reason
);
1980 void blk_op_unblock_all(BlockBackend
*blk
, Error
*reason
)
1982 BlockDriverState
*bs
= blk_bs(blk
);
1985 bdrv_op_unblock_all(bs
, reason
);
1989 AioContext
*blk_get_aio_context(BlockBackend
*blk
)
1991 BlockDriverState
*bs
= blk_bs(blk
);
1994 AioContext
*ctx
= bdrv_get_aio_context(blk_bs(blk
));
1995 assert(ctx
== blk
->ctx
);
2001 static AioContext
*blk_aiocb_get_aio_context(BlockAIOCB
*acb
)
2003 BlockBackendAIOCB
*blk_acb
= DO_UPCAST(BlockBackendAIOCB
, common
, acb
);
2004 return blk_get_aio_context(blk_acb
->blk
);
2007 static int blk_do_set_aio_context(BlockBackend
*blk
, AioContext
*new_context
,
2008 bool update_root_node
, Error
**errp
)
2010 BlockDriverState
*bs
= blk_bs(blk
);
2011 ThrottleGroupMember
*tgm
= &blk
->public.throttle_group_member
;
2015 if (update_root_node
) {
2016 ret
= bdrv_child_try_set_aio_context(bs
, new_context
, blk
->root
,
2022 if (tgm
->throttle_state
) {
2023 bdrv_drained_begin(bs
);
2024 throttle_group_detach_aio_context(tgm
);
2025 throttle_group_attach_aio_context(tgm
, new_context
);
2026 bdrv_drained_end(bs
);
2030 blk
->ctx
= new_context
;
2034 int blk_set_aio_context(BlockBackend
*blk
, AioContext
*new_context
,
2037 return blk_do_set_aio_context(blk
, new_context
, true, errp
);
2040 static bool blk_root_can_set_aio_ctx(BdrvChild
*child
, AioContext
*ctx
,
2041 GSList
**ignore
, Error
**errp
)
2043 BlockBackend
*blk
= child
->opaque
;
2045 if (blk
->allow_aio_context_change
) {
2049 /* Only manually created BlockBackends that are not attached to anything
2050 * can change their AioContext without updating their user. */
2051 if (!blk
->name
|| blk
->dev
) {
2052 /* TODO Add BB name/QOM path */
2053 error_setg(errp
, "Cannot change iothread of active block backend");
2060 static void blk_root_set_aio_ctx(BdrvChild
*child
, AioContext
*ctx
,
2063 BlockBackend
*blk
= child
->opaque
;
2064 blk_do_set_aio_context(blk
, ctx
, false, &error_abort
);
2067 void blk_add_aio_context_notifier(BlockBackend
*blk
,
2068 void (*attached_aio_context
)(AioContext
*new_context
, void *opaque
),
2069 void (*detach_aio_context
)(void *opaque
), void *opaque
)
2071 BlockBackendAioNotifier
*notifier
;
2072 BlockDriverState
*bs
= blk_bs(blk
);
2074 notifier
= g_new(BlockBackendAioNotifier
, 1);
2075 notifier
->attached_aio_context
= attached_aio_context
;
2076 notifier
->detach_aio_context
= detach_aio_context
;
2077 notifier
->opaque
= opaque
;
2078 QLIST_INSERT_HEAD(&blk
->aio_notifiers
, notifier
, list
);
2081 bdrv_add_aio_context_notifier(bs
, attached_aio_context
,
2082 detach_aio_context
, opaque
);
2086 void blk_remove_aio_context_notifier(BlockBackend
*blk
,
2087 void (*attached_aio_context
)(AioContext
*,
2089 void (*detach_aio_context
)(void *),
2092 BlockBackendAioNotifier
*notifier
;
2093 BlockDriverState
*bs
= blk_bs(blk
);
2096 bdrv_remove_aio_context_notifier(bs
, attached_aio_context
,
2097 detach_aio_context
, opaque
);
2100 QLIST_FOREACH(notifier
, &blk
->aio_notifiers
, list
) {
2101 if (notifier
->attached_aio_context
== attached_aio_context
&&
2102 notifier
->detach_aio_context
== detach_aio_context
&&
2103 notifier
->opaque
== opaque
) {
2104 QLIST_REMOVE(notifier
, list
);
2113 void blk_add_remove_bs_notifier(BlockBackend
*blk
, Notifier
*notify
)
2115 notifier_list_add(&blk
->remove_bs_notifiers
, notify
);
2118 void blk_add_insert_bs_notifier(BlockBackend
*blk
, Notifier
*notify
)
2120 notifier_list_add(&blk
->insert_bs_notifiers
, notify
);
2123 void blk_io_plug(BlockBackend
*blk
)
2125 BlockDriverState
*bs
= blk_bs(blk
);
2132 void blk_io_unplug(BlockBackend
*blk
)
2134 BlockDriverState
*bs
= blk_bs(blk
);
2141 BlockAcctStats
*blk_get_stats(BlockBackend
*blk
)
2146 void *blk_aio_get(const AIOCBInfo
*aiocb_info
, BlockBackend
*blk
,
2147 BlockCompletionFunc
*cb
, void *opaque
)
2149 return qemu_aio_get(aiocb_info
, blk_bs(blk
), cb
, opaque
);
2152 int coroutine_fn
blk_co_pwrite_zeroes(BlockBackend
*blk
, int64_t offset
,
2153 int bytes
, BdrvRequestFlags flags
)
2155 return blk_co_pwritev(blk
, offset
, bytes
, NULL
,
2156 flags
| BDRV_REQ_ZERO_WRITE
);
2159 int blk_pwrite_compressed(BlockBackend
*blk
, int64_t offset
, const void *buf
,
2162 return blk_prw(blk
, offset
, (void *) buf
, count
, blk_write_entry
,
2163 BDRV_REQ_WRITE_COMPRESSED
);
2166 int blk_truncate(BlockBackend
*blk
, int64_t offset
, bool exact
,
2167 PreallocMode prealloc
, BdrvRequestFlags flags
, Error
**errp
)
2169 if (!blk_is_available(blk
)) {
2170 error_setg(errp
, "No medium inserted");
2174 return bdrv_truncate(blk
->root
, offset
, exact
, prealloc
, flags
, errp
);
2177 int blk_save_vmstate(BlockBackend
*blk
, const uint8_t *buf
,
2178 int64_t pos
, int size
)
2182 if (!blk_is_available(blk
)) {
2186 ret
= bdrv_save_vmstate(blk_bs(blk
), buf
, pos
, size
);
2191 if (ret
== size
&& !blk
->enable_write_cache
) {
2192 ret
= bdrv_flush(blk_bs(blk
));
2195 return ret
< 0 ? ret
: size
;
2198 int blk_load_vmstate(BlockBackend
*blk
, uint8_t *buf
, int64_t pos
, int size
)
2200 if (!blk_is_available(blk
)) {
2204 return bdrv_load_vmstate(blk_bs(blk
), buf
, pos
, size
);
2207 int blk_probe_blocksizes(BlockBackend
*blk
, BlockSizes
*bsz
)
2209 if (!blk_is_available(blk
)) {
2213 return bdrv_probe_blocksizes(blk_bs(blk
), bsz
);
2216 int blk_probe_geometry(BlockBackend
*blk
, HDGeometry
*geo
)
2218 if (!blk_is_available(blk
)) {
2222 return bdrv_probe_geometry(blk_bs(blk
), geo
);
2226 * Updates the BlockBackendRootState object with data from the currently
2227 * attached BlockDriverState.
2229 void blk_update_root_state(BlockBackend
*blk
)
2233 blk
->root_state
.open_flags
= blk
->root
->bs
->open_flags
;
2234 blk
->root_state
.read_only
= blk
->root
->bs
->read_only
;
2235 blk
->root_state
.detect_zeroes
= blk
->root
->bs
->detect_zeroes
;
2239 * Returns the detect-zeroes setting to be used for bdrv_open() of a
2240 * BlockDriverState which is supposed to inherit the root state.
2242 bool blk_get_detect_zeroes_from_root_state(BlockBackend
*blk
)
2244 return blk
->root_state
.detect_zeroes
;
2248 * Returns the flags to be used for bdrv_open() of a BlockDriverState which is
2249 * supposed to inherit the root state.
2251 int blk_get_open_flags_from_root_state(BlockBackend
*blk
)
2255 bs_flags
= blk
->root_state
.read_only
? 0 : BDRV_O_RDWR
;
2256 bs_flags
|= blk
->root_state
.open_flags
& ~BDRV_O_RDWR
;
2261 BlockBackendRootState
*blk_get_root_state(BlockBackend
*blk
)
2263 return &blk
->root_state
;
2266 int blk_commit_all(void)
2268 BlockBackend
*blk
= NULL
;
2270 while ((blk
= blk_all_next(blk
)) != NULL
) {
2271 AioContext
*aio_context
= blk_get_aio_context(blk
);
2273 aio_context_acquire(aio_context
);
2274 if (blk_is_inserted(blk
) && blk
->root
->bs
->backing
) {
2275 int ret
= bdrv_commit(blk
->root
->bs
);
2277 aio_context_release(aio_context
);
2281 aio_context_release(aio_context
);
2287 /* throttling disk I/O limits */
2288 void blk_set_io_limits(BlockBackend
*blk
, ThrottleConfig
*cfg
)
2290 throttle_group_config(&blk
->public.throttle_group_member
, cfg
);
2293 void blk_io_limits_disable(BlockBackend
*blk
)
2295 BlockDriverState
*bs
= blk_bs(blk
);
2296 ThrottleGroupMember
*tgm
= &blk
->public.throttle_group_member
;
2297 assert(tgm
->throttle_state
);
2299 bdrv_drained_begin(bs
);
2301 throttle_group_unregister_tgm(tgm
);
2303 bdrv_drained_end(bs
);
2307 /* should be called before blk_set_io_limits if a limit is set */
2308 void blk_io_limits_enable(BlockBackend
*blk
, const char *group
)
2310 assert(!blk
->public.throttle_group_member
.throttle_state
);
2311 throttle_group_register_tgm(&blk
->public.throttle_group_member
,
2312 group
, blk_get_aio_context(blk
));
2315 void blk_io_limits_update_group(BlockBackend
*blk
, const char *group
)
2317 /* this BB is not part of any group */
2318 if (!blk
->public.throttle_group_member
.throttle_state
) {
2322 /* this BB is a part of the same group than the one we want */
2323 if (!g_strcmp0(throttle_group_get_name(&blk
->public.throttle_group_member
),
2328 /* need to change the group this bs belong to */
2329 blk_io_limits_disable(blk
);
2330 blk_io_limits_enable(blk
, group
);
2333 static void blk_root_drained_begin(BdrvChild
*child
)
2335 BlockBackend
*blk
= child
->opaque
;
2337 if (++blk
->quiesce_counter
== 1) {
2338 if (blk
->dev_ops
&& blk
->dev_ops
->drained_begin
) {
2339 blk
->dev_ops
->drained_begin(blk
->dev_opaque
);
2343 /* Note that blk->root may not be accessible here yet if we are just
2344 * attaching to a BlockDriverState that is drained. Use child instead. */
2346 if (atomic_fetch_inc(&blk
->public.throttle_group_member
.io_limits_disabled
) == 0) {
2347 throttle_group_restart_tgm(&blk
->public.throttle_group_member
);
2351 static bool blk_root_drained_poll(BdrvChild
*child
)
2353 BlockBackend
*blk
= child
->opaque
;
2354 assert(blk
->quiesce_counter
);
2355 return !!blk
->in_flight
;
2358 static void blk_root_drained_end(BdrvChild
*child
, int *drained_end_counter
)
2360 BlockBackend
*blk
= child
->opaque
;
2361 assert(blk
->quiesce_counter
);
2363 assert(blk
->public.throttle_group_member
.io_limits_disabled
);
2364 atomic_dec(&blk
->public.throttle_group_member
.io_limits_disabled
);
2366 if (--blk
->quiesce_counter
== 0) {
2367 if (blk
->dev_ops
&& blk
->dev_ops
->drained_end
) {
2368 blk
->dev_ops
->drained_end(blk
->dev_opaque
);
2370 while (qemu_co_enter_next(&blk
->queued_requests
, NULL
)) {
2371 /* Resume all queued requests */
2376 void blk_register_buf(BlockBackend
*blk
, void *host
, size_t size
)
2378 bdrv_register_buf(blk_bs(blk
), host
, size
);
2381 void blk_unregister_buf(BlockBackend
*blk
, void *host
)
2383 bdrv_unregister_buf(blk_bs(blk
), host
);
2386 int coroutine_fn
blk_co_copy_range(BlockBackend
*blk_in
, int64_t off_in
,
2387 BlockBackend
*blk_out
, int64_t off_out
,
2388 int bytes
, BdrvRequestFlags read_flags
,
2389 BdrvRequestFlags write_flags
)
2392 r
= blk_check_byte_request(blk_in
, off_in
, bytes
);
2396 r
= blk_check_byte_request(blk_out
, off_out
, bytes
);
2400 return bdrv_co_copy_range(blk_in
->root
, off_in
,
2401 blk_out
->root
, off_out
,
2402 bytes
, read_flags
, write_flags
);
2405 const BdrvChild
*blk_root(BlockBackend
*blk
)
2410 int blk_make_empty(BlockBackend
*blk
, Error
**errp
)
2412 if (!blk_is_available(blk
)) {
2413 error_setg(errp
, "No medium inserted");
2417 return bdrv_make_empty(blk
->root
, errp
);