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 "sysemu/blockdev.h"
19 #include "sysemu/sysemu.h"
20 #include "qapi/error.h"
21 #include "qapi/qapi-events-block.h"
23 #include "qemu/option.h"
25 #include "migration/misc.h"
27 /* Number of coroutines to reserve per attached device model */
28 #define COROUTINE_POOL_RESERVATION 64
30 #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
32 static AioContext
*blk_aiocb_get_aio_context(BlockAIOCB
*acb
);
34 typedef struct BlockBackendAioNotifier
{
35 void (*attached_aio_context
)(AioContext
*new_context
, void *opaque
);
36 void (*detach_aio_context
)(void *opaque
);
38 QLIST_ENTRY(BlockBackendAioNotifier
) list
;
39 } BlockBackendAioNotifier
;
45 DriveInfo
*legacy_dinfo
; /* null unless created by drive_new() */
46 QTAILQ_ENTRY(BlockBackend
) link
; /* for block_backends */
47 QTAILQ_ENTRY(BlockBackend
) monitor_link
; /* for monitor_block_backends */
48 BlockBackendPublic
public;
50 void *dev
; /* attached device model, if any */
51 bool legacy_dev
; /* true if dev is not a DeviceState */
52 /* TODO change to DeviceState when all users are qdevified */
53 const BlockDevOps
*dev_ops
;
56 /* the block size for which the guest device expects atomicity */
59 /* If the BDS tree is removed, some of its options are stored here (which
60 * can be used to restore those options in the new BDS on insert) */
61 BlockBackendRootState root_state
;
63 bool enable_write_cache
;
65 /* I/O stats (display with "info blockstats"). */
68 BlockdevOnError on_read_error
, on_write_error
;
69 bool iostatus_enabled
;
70 BlockDeviceIoStatus iostatus
;
76 bool allow_write_beyond_eof
;
78 NotifierList remove_bs_notifiers
, insert_bs_notifiers
;
79 QLIST_HEAD(, BlockBackendAioNotifier
) aio_notifiers
;
82 VMChangeStateEntry
*vmsh
;
83 bool force_allow_inactivate
;
85 /* Number of in-flight aio requests. BlockDriverState also counts
86 * in-flight requests but aio requests can exist even when blk->root is
87 * NULL, so we cannot rely on its counter for that case.
88 * Accessed with atomic ops.
90 unsigned int in_flight
;
93 typedef struct BlockBackendAIOCB
{
99 static const AIOCBInfo block_backend_aiocb_info
= {
100 .get_aio_context
= blk_aiocb_get_aio_context
,
101 .aiocb_size
= sizeof(BlockBackendAIOCB
),
104 static void drive_info_del(DriveInfo
*dinfo
);
105 static BlockBackend
*bdrv_first_blk(BlockDriverState
*bs
);
107 /* All BlockBackends */
108 static QTAILQ_HEAD(, BlockBackend
) block_backends
=
109 QTAILQ_HEAD_INITIALIZER(block_backends
);
111 /* All BlockBackends referenced by the monitor and which are iterated through by
113 static QTAILQ_HEAD(, BlockBackend
) monitor_block_backends
=
114 QTAILQ_HEAD_INITIALIZER(monitor_block_backends
);
116 static void blk_root_inherit_options(int *child_flags
, QDict
*child_options
,
117 int parent_flags
, QDict
*parent_options
)
119 /* We're not supposed to call this function for root nodes */
122 static void blk_root_drained_begin(BdrvChild
*child
);
123 static bool blk_root_drained_poll(BdrvChild
*child
);
124 static void blk_root_drained_end(BdrvChild
*child
);
126 static void blk_root_change_media(BdrvChild
*child
, bool load
);
127 static void blk_root_resize(BdrvChild
*child
);
129 static char *blk_root_get_parent_desc(BdrvChild
*child
)
131 BlockBackend
*blk
= child
->opaque
;
135 return g_strdup(blk
->name
);
138 dev_id
= blk_get_attached_dev_id(blk
);
142 /* TODO Callback into the BB owner for something more detailed */
144 return g_strdup("a block device");
148 static const char *blk_root_get_name(BdrvChild
*child
)
150 return blk_name(child
->opaque
);
153 static void blk_vm_state_changed(void *opaque
, int running
, RunState state
)
155 Error
*local_err
= NULL
;
156 BlockBackend
*blk
= opaque
;
158 if (state
== RUN_STATE_INMIGRATE
) {
162 qemu_del_vm_change_state_handler(blk
->vmsh
);
164 blk_set_perm(blk
, blk
->perm
, blk
->shared_perm
, &local_err
);
166 error_report_err(local_err
);
171 * Notifies the user of the BlockBackend that migration has completed. qdev
172 * devices can tighten their permissions in response (specifically revoke
173 * shared write permissions that we needed for storage migration).
175 * If an error is returned, the VM cannot be allowed to be resumed.
177 static void blk_root_activate(BdrvChild
*child
, Error
**errp
)
179 BlockBackend
*blk
= child
->opaque
;
180 Error
*local_err
= NULL
;
182 if (!blk
->disable_perm
) {
186 blk
->disable_perm
= false;
188 blk_set_perm(blk
, blk
->perm
, BLK_PERM_ALL
, &local_err
);
190 error_propagate(errp
, local_err
);
191 blk
->disable_perm
= true;
195 if (runstate_check(RUN_STATE_INMIGRATE
)) {
196 /* Activation can happen when migration process is still active, for
197 * example when nbd_server_add is called during non-shared storage
198 * migration. Defer the shared_perm update to migration completion. */
200 blk
->vmsh
= qemu_add_vm_change_state_handler(blk_vm_state_changed
,
206 blk_set_perm(blk
, blk
->perm
, blk
->shared_perm
, &local_err
);
208 error_propagate(errp
, local_err
);
209 blk
->disable_perm
= true;
214 void blk_set_force_allow_inactivate(BlockBackend
*blk
)
216 blk
->force_allow_inactivate
= true;
219 static bool blk_can_inactivate(BlockBackend
*blk
)
221 /* If it is a guest device, inactivate is ok. */
222 if (blk
->dev
|| blk_name(blk
)[0]) {
226 /* Inactivating means no more writes to the image can be done,
227 * even if those writes would be changes invisible to the
228 * guest. For block job BBs that satisfy this, we can just allow
229 * it. This is the case for mirror job source, which is required
230 * by libvirt non-shared block migration. */
231 if (!(blk
->perm
& (BLK_PERM_WRITE
| BLK_PERM_WRITE_UNCHANGED
))) {
235 return blk
->force_allow_inactivate
;
238 static int blk_root_inactivate(BdrvChild
*child
)
240 BlockBackend
*blk
= child
->opaque
;
242 if (blk
->disable_perm
) {
246 if (!blk_can_inactivate(blk
)) {
250 blk
->disable_perm
= true;
252 bdrv_child_try_set_perm(blk
->root
, 0, BLK_PERM_ALL
, &error_abort
);
258 static void blk_root_attach(BdrvChild
*child
)
260 BlockBackend
*blk
= child
->opaque
;
261 BlockBackendAioNotifier
*notifier
;
263 trace_blk_root_attach(child
, blk
, child
->bs
);
265 QLIST_FOREACH(notifier
, &blk
->aio_notifiers
, list
) {
266 bdrv_add_aio_context_notifier(child
->bs
,
267 notifier
->attached_aio_context
,
268 notifier
->detach_aio_context
,
273 static void blk_root_detach(BdrvChild
*child
)
275 BlockBackend
*blk
= child
->opaque
;
276 BlockBackendAioNotifier
*notifier
;
278 trace_blk_root_detach(child
, blk
, child
->bs
);
280 QLIST_FOREACH(notifier
, &blk
->aio_notifiers
, list
) {
281 bdrv_remove_aio_context_notifier(child
->bs
,
282 notifier
->attached_aio_context
,
283 notifier
->detach_aio_context
,
288 static const BdrvChildRole child_root
= {
289 .inherit_options
= blk_root_inherit_options
,
291 .change_media
= blk_root_change_media
,
292 .resize
= blk_root_resize
,
293 .get_name
= blk_root_get_name
,
294 .get_parent_desc
= blk_root_get_parent_desc
,
296 .drained_begin
= blk_root_drained_begin
,
297 .drained_poll
= blk_root_drained_poll
,
298 .drained_end
= blk_root_drained_end
,
300 .activate
= blk_root_activate
,
301 .inactivate
= blk_root_inactivate
,
303 .attach
= blk_root_attach
,
304 .detach
= blk_root_detach
,
308 * Create a new BlockBackend with a reference count of one.
310 * @perm is a bitmasks of BLK_PERM_* constants which describes the permissions
311 * to request for a block driver node that is attached to this BlockBackend.
312 * @shared_perm is a bitmask which describes which permissions may be granted
313 * to other users of the attached node.
314 * Both sets of permissions can be changed later using blk_set_perm().
316 * Return the new BlockBackend on success, null on failure.
318 BlockBackend
*blk_new(uint64_t perm
, uint64_t shared_perm
)
322 blk
= g_new0(BlockBackend
, 1);
325 blk
->shared_perm
= shared_perm
;
326 blk_set_enable_write_cache(blk
, true);
328 blk
->on_read_error
= BLOCKDEV_ON_ERROR_REPORT
;
329 blk
->on_write_error
= BLOCKDEV_ON_ERROR_ENOSPC
;
331 block_acct_init(&blk
->stats
);
333 notifier_list_init(&blk
->remove_bs_notifiers
);
334 notifier_list_init(&blk
->insert_bs_notifiers
);
335 QLIST_INIT(&blk
->aio_notifiers
);
337 QTAILQ_INSERT_TAIL(&block_backends
, blk
, link
);
342 * Creates a new BlockBackend, opens a new BlockDriverState, and connects both.
344 * Just as with bdrv_open(), after having called this function the reference to
345 * @options belongs to the block layer (even on failure).
347 * TODO: Remove @filename and @flags; it should be possible to specify a whole
348 * BDS tree just by specifying the @options QDict (or @reference,
349 * alternatively). At the time of adding this function, this is not possible,
350 * though, so callers of this function have to be able to specify @filename and
353 BlockBackend
*blk_new_open(const char *filename
, const char *reference
,
354 QDict
*options
, int flags
, Error
**errp
)
357 BlockDriverState
*bs
;
360 /* blk_new_open() is mainly used in .bdrv_create implementations and the
361 * tools where sharing isn't a concern because the BDS stays private, so we
362 * just request permission according to the flags.
364 * The exceptions are xen_disk and blockdev_init(); in these cases, the
365 * caller of blk_new_open() doesn't make use of the permissions, but they
366 * shouldn't hurt either. We can still share everything here because the
367 * guest devices will add their own blockers if they can't share. */
368 if ((flags
& BDRV_O_NO_IO
) == 0) {
369 perm
|= BLK_PERM_CONSISTENT_READ
;
370 if (flags
& BDRV_O_RDWR
) {
371 perm
|= BLK_PERM_WRITE
;
374 if (flags
& BDRV_O_RESIZE
) {
375 perm
|= BLK_PERM_RESIZE
;
378 blk
= blk_new(perm
, BLK_PERM_ALL
);
379 bs
= bdrv_open(filename
, reference
, options
, flags
, errp
);
385 blk
->root
= bdrv_root_attach_child(bs
, "root", &child_root
,
386 perm
, BLK_PERM_ALL
, blk
, errp
);
396 static void blk_delete(BlockBackend
*blk
)
398 assert(!blk
->refcnt
);
401 if (blk
->public.throttle_group_member
.throttle_state
) {
402 blk_io_limits_disable(blk
);
408 qemu_del_vm_change_state_handler(blk
->vmsh
);
411 assert(QLIST_EMPTY(&blk
->remove_bs_notifiers
.notifiers
));
412 assert(QLIST_EMPTY(&blk
->insert_bs_notifiers
.notifiers
));
413 assert(QLIST_EMPTY(&blk
->aio_notifiers
));
414 QTAILQ_REMOVE(&block_backends
, blk
, link
);
415 drive_info_del(blk
->legacy_dinfo
);
416 block_acct_cleanup(&blk
->stats
);
420 static void drive_info_del(DriveInfo
*dinfo
)
425 qemu_opts_del(dinfo
->opts
);
429 int blk_get_refcnt(BlockBackend
*blk
)
431 return blk
? blk
->refcnt
: 0;
435 * Increment @blk's reference count.
436 * @blk must not be null.
438 void blk_ref(BlockBackend
*blk
)
440 assert(blk
->refcnt
> 0);
445 * Decrement @blk's reference count.
446 * If this drops it to zero, destroy @blk.
447 * For convenience, do nothing if @blk is null.
449 void blk_unref(BlockBackend
*blk
)
452 assert(blk
->refcnt
> 0);
453 if (blk
->refcnt
> 1) {
457 /* blk_drain() cannot resurrect blk, nobody held a reference */
458 assert(blk
->refcnt
== 1);
466 * Behaves similarly to blk_next() but iterates over all BlockBackends, even the
467 * ones which are hidden (i.e. are not referenced by the monitor).
469 BlockBackend
*blk_all_next(BlockBackend
*blk
)
471 return blk
? QTAILQ_NEXT(blk
, link
)
472 : QTAILQ_FIRST(&block_backends
);
475 void blk_remove_all_bs(void)
477 BlockBackend
*blk
= NULL
;
479 while ((blk
= blk_all_next(blk
)) != NULL
) {
480 AioContext
*ctx
= blk_get_aio_context(blk
);
482 aio_context_acquire(ctx
);
486 aio_context_release(ctx
);
491 * Return the monitor-owned BlockBackend after @blk.
492 * If @blk is null, return the first one.
493 * Else, return @blk's next sibling, which may be null.
495 * To iterate over all BlockBackends, do
496 * for (blk = blk_next(NULL); blk; blk = blk_next(blk)) {
500 BlockBackend
*blk_next(BlockBackend
*blk
)
502 return blk
? QTAILQ_NEXT(blk
, monitor_link
)
503 : QTAILQ_FIRST(&monitor_block_backends
);
506 /* Iterates over all top-level BlockDriverStates, i.e. BDSs that are owned by
507 * the monitor or attached to a BlockBackend */
508 BlockDriverState
*bdrv_next(BdrvNextIterator
*it
)
510 BlockDriverState
*bs
, *old_bs
;
512 /* Must be called from the main loop */
513 assert(qemu_get_current_aio_context() == qemu_get_aio_context());
515 /* First, return all root nodes of BlockBackends. In order to avoid
516 * returning a BDS twice when multiple BBs refer to it, we only return it
517 * if the BB is the first one in the parent list of the BDS. */
518 if (it
->phase
== BDRV_NEXT_BACKEND_ROOTS
) {
519 BlockBackend
*old_blk
= it
->blk
;
521 old_bs
= old_blk
? blk_bs(old_blk
) : NULL
;
524 it
->blk
= blk_all_next(it
->blk
);
525 bs
= it
->blk
? blk_bs(it
->blk
) : NULL
;
526 } while (it
->blk
&& (bs
== NULL
|| bdrv_first_blk(bs
) != it
->blk
));
538 it
->phase
= BDRV_NEXT_MONITOR_OWNED
;
543 /* Then return the monitor-owned BDSes without a BB attached. Ignore all
544 * BDSes that are attached to a BlockBackend here; they have been handled
545 * by the above block already */
547 it
->bs
= bdrv_next_monitor_owned(it
->bs
);
549 } while (bs
&& bdrv_has_blk(bs
));
559 static void bdrv_next_reset(BdrvNextIterator
*it
)
561 *it
= (BdrvNextIterator
) {
562 .phase
= BDRV_NEXT_BACKEND_ROOTS
,
566 BlockDriverState
*bdrv_first(BdrvNextIterator
*it
)
569 return bdrv_next(it
);
572 /* Must be called when aborting a bdrv_next() iteration before
573 * bdrv_next() returns NULL */
574 void bdrv_next_cleanup(BdrvNextIterator
*it
)
576 /* Must be called from the main loop */
577 assert(qemu_get_current_aio_context() == qemu_get_aio_context());
579 if (it
->phase
== BDRV_NEXT_BACKEND_ROOTS
) {
581 bdrv_unref(blk_bs(it
->blk
));
592 * Add a BlockBackend into the list of backends referenced by the monitor, with
593 * the given @name acting as the handle for the monitor.
594 * Strictly for use by blockdev.c.
596 * @name must not be null or empty.
598 * Returns true on success and false on failure. In the latter case, an Error
599 * object is returned through @errp.
601 bool monitor_add_blk(BlockBackend
*blk
, const char *name
, Error
**errp
)
604 assert(name
&& name
[0]);
606 if (!id_wellformed(name
)) {
607 error_setg(errp
, "Invalid device name");
610 if (blk_by_name(name
)) {
611 error_setg(errp
, "Device with id '%s' already exists", name
);
614 if (bdrv_find_node(name
)) {
616 "Device name '%s' conflicts with an existing node name",
621 blk
->name
= g_strdup(name
);
622 QTAILQ_INSERT_TAIL(&monitor_block_backends
, blk
, monitor_link
);
627 * Remove a BlockBackend from the list of backends referenced by the monitor.
628 * Strictly for use by blockdev.c.
630 void monitor_remove_blk(BlockBackend
*blk
)
636 QTAILQ_REMOVE(&monitor_block_backends
, blk
, monitor_link
);
642 * Return @blk's name, a non-null string.
643 * Returns an empty string iff @blk is not referenced by the monitor.
645 const char *blk_name(const BlockBackend
*blk
)
647 return blk
->name
?: "";
651 * Return the BlockBackend with name @name if it exists, else null.
652 * @name must not be null.
654 BlockBackend
*blk_by_name(const char *name
)
656 BlockBackend
*blk
= NULL
;
659 while ((blk
= blk_next(blk
)) != NULL
) {
660 if (!strcmp(name
, blk
->name
)) {
668 * Return the BlockDriverState attached to @blk if any, else null.
670 BlockDriverState
*blk_bs(BlockBackend
*blk
)
672 return blk
->root
? blk
->root
->bs
: NULL
;
675 static BlockBackend
*bdrv_first_blk(BlockDriverState
*bs
)
678 QLIST_FOREACH(child
, &bs
->parents
, next_parent
) {
679 if (child
->role
== &child_root
) {
680 return child
->opaque
;
688 * Returns true if @bs has an associated BlockBackend.
690 bool bdrv_has_blk(BlockDriverState
*bs
)
692 return bdrv_first_blk(bs
) != NULL
;
696 * Returns true if @bs has only BlockBackends as parents.
698 bool bdrv_is_root_node(BlockDriverState
*bs
)
702 QLIST_FOREACH(c
, &bs
->parents
, next_parent
) {
703 if (c
->role
!= &child_root
) {
712 * Return @blk's DriveInfo if any, else null.
714 DriveInfo
*blk_legacy_dinfo(BlockBackend
*blk
)
716 return blk
->legacy_dinfo
;
720 * Set @blk's DriveInfo to @dinfo, and return it.
721 * @blk must not have a DriveInfo set already.
722 * No other BlockBackend may have the same DriveInfo set.
724 DriveInfo
*blk_set_legacy_dinfo(BlockBackend
*blk
, DriveInfo
*dinfo
)
726 assert(!blk
->legacy_dinfo
);
727 return blk
->legacy_dinfo
= dinfo
;
731 * Return the BlockBackend with DriveInfo @dinfo.
734 BlockBackend
*blk_by_legacy_dinfo(DriveInfo
*dinfo
)
736 BlockBackend
*blk
= NULL
;
738 while ((blk
= blk_next(blk
)) != NULL
) {
739 if (blk
->legacy_dinfo
== dinfo
) {
747 * Returns a pointer to the publicly accessible fields of @blk.
749 BlockBackendPublic
*blk_get_public(BlockBackend
*blk
)
755 * Returns a BlockBackend given the associated @public fields.
757 BlockBackend
*blk_by_public(BlockBackendPublic
*public)
759 return container_of(public, BlockBackend
, public);
763 * Disassociates the currently associated BlockDriverState from @blk.
765 void blk_remove_bs(BlockBackend
*blk
)
767 ThrottleGroupMember
*tgm
= &blk
->public.throttle_group_member
;
768 BlockDriverState
*bs
;
770 notifier_list_notify(&blk
->remove_bs_notifiers
, blk
);
771 if (tgm
->throttle_state
) {
773 bdrv_drained_begin(bs
);
774 throttle_group_detach_aio_context(tgm
);
775 throttle_group_attach_aio_context(tgm
, qemu_get_aio_context());
776 bdrv_drained_end(bs
);
779 blk_update_root_state(blk
);
781 /* bdrv_root_unref_child() will cause blk->root to become stale and may
782 * switch to a completion coroutine later on. Let's drain all I/O here
783 * to avoid that and a potential QEMU crash.
786 bdrv_root_unref_child(blk
->root
);
791 * Associates a new BlockDriverState with @blk.
793 int blk_insert_bs(BlockBackend
*blk
, BlockDriverState
*bs
, Error
**errp
)
795 ThrottleGroupMember
*tgm
= &blk
->public.throttle_group_member
;
796 blk
->root
= bdrv_root_attach_child(bs
, "root", &child_root
,
797 blk
->perm
, blk
->shared_perm
, blk
, errp
);
798 if (blk
->root
== NULL
) {
803 notifier_list_notify(&blk
->insert_bs_notifiers
, blk
);
804 if (tgm
->throttle_state
) {
805 throttle_group_detach_aio_context(tgm
);
806 throttle_group_attach_aio_context(tgm
, bdrv_get_aio_context(bs
));
813 * Sets the permission bitmasks that the user of the BlockBackend needs.
815 int blk_set_perm(BlockBackend
*blk
, uint64_t perm
, uint64_t shared_perm
,
820 if (blk
->root
&& !blk
->disable_perm
) {
821 ret
= bdrv_child_try_set_perm(blk
->root
, perm
, shared_perm
, errp
);
828 blk
->shared_perm
= shared_perm
;
833 void blk_get_perm(BlockBackend
*blk
, uint64_t *perm
, uint64_t *shared_perm
)
836 *shared_perm
= blk
->shared_perm
;
839 static int blk_do_attach_dev(BlockBackend
*blk
, void *dev
)
845 /* While migration is still incoming, we don't need to apply the
846 * permissions of guest device BlockBackends. We might still have a block
847 * job or NBD server writing to the image for storage migration. */
848 if (runstate_check(RUN_STATE_INMIGRATE
)) {
849 blk
->disable_perm
= true;
854 blk
->legacy_dev
= false;
855 blk_iostatus_reset(blk
);
861 * Attach device model @dev to @blk.
862 * Return 0 on success, -EBUSY when a device model is attached already.
864 int blk_attach_dev(BlockBackend
*blk
, DeviceState
*dev
)
866 return blk_do_attach_dev(blk
, dev
);
870 * Attach device model @dev to @blk.
871 * @blk must not have a device model attached already.
872 * TODO qdevified devices don't use this, remove when devices are qdevified
874 void blk_attach_dev_legacy(BlockBackend
*blk
, void *dev
)
876 if (blk_do_attach_dev(blk
, dev
) < 0) {
879 blk
->legacy_dev
= true;
883 * Detach device model @dev from @blk.
884 * @dev must be currently attached to @blk.
886 void blk_detach_dev(BlockBackend
*blk
, void *dev
)
887 /* TODO change to DeviceState *dev when all users are qdevified */
889 assert(blk
->dev
== dev
);
892 blk
->dev_opaque
= NULL
;
893 blk
->guest_block_size
= 512;
894 blk_set_perm(blk
, 0, BLK_PERM_ALL
, &error_abort
);
899 * Return the device model attached to @blk if any, else null.
901 void *blk_get_attached_dev(BlockBackend
*blk
)
902 /* TODO change to return DeviceState * when all users are qdevified */
907 /* Return the qdev ID, or if no ID is assigned the QOM path, of the block
908 * device attached to the BlockBackend. */
909 char *blk_get_attached_dev_id(BlockBackend
*blk
)
913 assert(!blk
->legacy_dev
);
918 } else if (dev
->id
) {
919 return g_strdup(dev
->id
);
922 return object_get_canonical_path(OBJECT(dev
)) ?: g_strdup("");
926 * Return the BlockBackend which has the device model @dev attached if it
929 * @dev must not be null.
931 BlockBackend
*blk_by_dev(void *dev
)
933 BlockBackend
*blk
= NULL
;
936 while ((blk
= blk_all_next(blk
)) != NULL
) {
937 if (blk
->dev
== dev
) {
945 * Set @blk's device model callbacks to @ops.
946 * @opaque is the opaque argument to pass to the callbacks.
947 * This is for use by device models.
949 void blk_set_dev_ops(BlockBackend
*blk
, const BlockDevOps
*ops
,
952 /* All drivers that use blk_set_dev_ops() are qdevified and we want to keep
953 * it that way, so we can assume blk->dev, if present, is a DeviceState if
954 * blk->dev_ops is set. Non-device users may use dev_ops without device. */
955 assert(!blk
->legacy_dev
);
958 blk
->dev_opaque
= opaque
;
960 /* Are we currently quiesced? Should we enforce this right now? */
961 if (blk
->quiesce_counter
&& ops
->drained_begin
) {
962 ops
->drained_begin(opaque
);
967 * Notify @blk's attached device model of media change.
969 * If @load is true, notify of media load. This action can fail, meaning that
970 * the medium cannot be loaded. @errp is set then.
972 * If @load is false, notify of media eject. This can never fail.
974 * Also send DEVICE_TRAY_MOVED events as appropriate.
976 void blk_dev_change_media_cb(BlockBackend
*blk
, bool load
, Error
**errp
)
978 if (blk
->dev_ops
&& blk
->dev_ops
->change_media_cb
) {
979 bool tray_was_open
, tray_is_open
;
980 Error
*local_err
= NULL
;
982 assert(!blk
->legacy_dev
);
984 tray_was_open
= blk_dev_is_tray_open(blk
);
985 blk
->dev_ops
->change_media_cb(blk
->dev_opaque
, load
, &local_err
);
987 assert(load
== true);
988 error_propagate(errp
, local_err
);
991 tray_is_open
= blk_dev_is_tray_open(blk
);
993 if (tray_was_open
!= tray_is_open
) {
994 char *id
= blk_get_attached_dev_id(blk
);
995 qapi_event_send_device_tray_moved(blk_name(blk
), id
, tray_is_open
);
1001 static void blk_root_change_media(BdrvChild
*child
, bool load
)
1003 blk_dev_change_media_cb(child
->opaque
, load
, NULL
);
1007 * Does @blk's attached device model have removable media?
1008 * %true if no device model is attached.
1010 bool blk_dev_has_removable_media(BlockBackend
*blk
)
1012 return !blk
->dev
|| (blk
->dev_ops
&& blk
->dev_ops
->change_media_cb
);
1016 * Does @blk's attached device model have a tray?
1018 bool blk_dev_has_tray(BlockBackend
*blk
)
1020 return blk
->dev_ops
&& blk
->dev_ops
->is_tray_open
;
1024 * Notify @blk's attached device model of a media eject request.
1025 * If @force is true, the medium is about to be yanked out forcefully.
1027 void blk_dev_eject_request(BlockBackend
*blk
, bool force
)
1029 if (blk
->dev_ops
&& blk
->dev_ops
->eject_request_cb
) {
1030 blk
->dev_ops
->eject_request_cb(blk
->dev_opaque
, force
);
1035 * Does @blk's attached device model have a tray, and is it open?
1037 bool blk_dev_is_tray_open(BlockBackend
*blk
)
1039 if (blk_dev_has_tray(blk
)) {
1040 return blk
->dev_ops
->is_tray_open(blk
->dev_opaque
);
1046 * Does @blk's attached device model have the medium locked?
1047 * %false if the device model has no such lock.
1049 bool blk_dev_is_medium_locked(BlockBackend
*blk
)
1051 if (blk
->dev_ops
&& blk
->dev_ops
->is_medium_locked
) {
1052 return blk
->dev_ops
->is_medium_locked(blk
->dev_opaque
);
1058 * Notify @blk's attached device model of a backend size change.
1060 static void blk_root_resize(BdrvChild
*child
)
1062 BlockBackend
*blk
= child
->opaque
;
1064 if (blk
->dev_ops
&& blk
->dev_ops
->resize_cb
) {
1065 blk
->dev_ops
->resize_cb(blk
->dev_opaque
);
1069 void blk_iostatus_enable(BlockBackend
*blk
)
1071 blk
->iostatus_enabled
= true;
1072 blk
->iostatus
= BLOCK_DEVICE_IO_STATUS_OK
;
1075 /* The I/O status is only enabled if the drive explicitly
1076 * enables it _and_ the VM is configured to stop on errors */
1077 bool blk_iostatus_is_enabled(const BlockBackend
*blk
)
1079 return (blk
->iostatus_enabled
&&
1080 (blk
->on_write_error
== BLOCKDEV_ON_ERROR_ENOSPC
||
1081 blk
->on_write_error
== BLOCKDEV_ON_ERROR_STOP
||
1082 blk
->on_read_error
== BLOCKDEV_ON_ERROR_STOP
));
1085 BlockDeviceIoStatus
blk_iostatus(const BlockBackend
*blk
)
1087 return blk
->iostatus
;
1090 void blk_iostatus_disable(BlockBackend
*blk
)
1092 blk
->iostatus_enabled
= false;
1095 void blk_iostatus_reset(BlockBackend
*blk
)
1097 if (blk_iostatus_is_enabled(blk
)) {
1098 BlockDriverState
*bs
= blk_bs(blk
);
1099 blk
->iostatus
= BLOCK_DEVICE_IO_STATUS_OK
;
1100 if (bs
&& bs
->job
) {
1101 block_job_iostatus_reset(bs
->job
);
1106 void blk_iostatus_set_err(BlockBackend
*blk
, int error
)
1108 assert(blk_iostatus_is_enabled(blk
));
1109 if (blk
->iostatus
== BLOCK_DEVICE_IO_STATUS_OK
) {
1110 blk
->iostatus
= error
== ENOSPC
? BLOCK_DEVICE_IO_STATUS_NOSPACE
:
1111 BLOCK_DEVICE_IO_STATUS_FAILED
;
1115 void blk_set_allow_write_beyond_eof(BlockBackend
*blk
, bool allow
)
1117 blk
->allow_write_beyond_eof
= allow
;
1120 static int blk_check_byte_request(BlockBackend
*blk
, int64_t offset
,
1125 if (size
> INT_MAX
) {
1129 if (!blk_is_available(blk
)) {
1137 if (!blk
->allow_write_beyond_eof
) {
1138 len
= blk_getlength(blk
);
1143 if (offset
> len
|| len
- offset
< size
) {
1151 int coroutine_fn
blk_co_preadv(BlockBackend
*blk
, int64_t offset
,
1152 unsigned int bytes
, QEMUIOVector
*qiov
,
1153 BdrvRequestFlags flags
)
1156 BlockDriverState
*bs
= blk_bs(blk
);
1158 trace_blk_co_preadv(blk
, bs
, offset
, bytes
, flags
);
1160 ret
= blk_check_byte_request(blk
, offset
, bytes
);
1165 bdrv_inc_in_flight(bs
);
1167 /* throttling disk I/O */
1168 if (blk
->public.throttle_group_member
.throttle_state
) {
1169 throttle_group_co_io_limits_intercept(&blk
->public.throttle_group_member
,
1173 ret
= bdrv_co_preadv(blk
->root
, offset
, bytes
, qiov
, flags
);
1174 bdrv_dec_in_flight(bs
);
1178 int coroutine_fn
blk_co_pwritev(BlockBackend
*blk
, int64_t offset
,
1179 unsigned int bytes
, QEMUIOVector
*qiov
,
1180 BdrvRequestFlags flags
)
1183 BlockDriverState
*bs
= blk_bs(blk
);
1185 trace_blk_co_pwritev(blk
, bs
, offset
, bytes
, flags
);
1187 ret
= blk_check_byte_request(blk
, offset
, bytes
);
1192 bdrv_inc_in_flight(bs
);
1193 /* throttling disk I/O */
1194 if (blk
->public.throttle_group_member
.throttle_state
) {
1195 throttle_group_co_io_limits_intercept(&blk
->public.throttle_group_member
,
1199 if (!blk
->enable_write_cache
) {
1200 flags
|= BDRV_REQ_FUA
;
1203 ret
= bdrv_co_pwritev(blk
->root
, offset
, bytes
, qiov
, flags
);
1204 bdrv_dec_in_flight(bs
);
1208 typedef struct BlkRwCo
{
1213 BdrvRequestFlags flags
;
1216 static void blk_read_entry(void *opaque
)
1218 BlkRwCo
*rwco
= opaque
;
1219 QEMUIOVector
*qiov
= rwco
->iobuf
;
1221 rwco
->ret
= blk_co_preadv(rwco
->blk
, rwco
->offset
, qiov
->size
,
1226 static void blk_write_entry(void *opaque
)
1228 BlkRwCo
*rwco
= opaque
;
1229 QEMUIOVector
*qiov
= rwco
->iobuf
;
1231 rwco
->ret
= blk_co_pwritev(rwco
->blk
, rwco
->offset
, qiov
->size
,
1236 static int blk_prw(BlockBackend
*blk
, int64_t offset
, uint8_t *buf
,
1237 int64_t bytes
, CoroutineEntry co_entry
,
1238 BdrvRequestFlags flags
)
1244 iov
= (struct iovec
) {
1248 qemu_iovec_init_external(&qiov
, &iov
, 1);
1258 if (qemu_in_coroutine()) {
1259 /* Fast-path if already in coroutine context */
1262 Coroutine
*co
= qemu_coroutine_create(co_entry
, &rwco
);
1263 bdrv_coroutine_enter(blk_bs(blk
), co
);
1264 BDRV_POLL_WHILE(blk_bs(blk
), rwco
.ret
== NOT_DONE
);
1270 int blk_pread_unthrottled(BlockBackend
*blk
, int64_t offset
, uint8_t *buf
,
1275 ret
= blk_check_byte_request(blk
, offset
, count
);
1280 blk_root_drained_begin(blk
->root
);
1281 ret
= blk_pread(blk
, offset
, buf
, count
);
1282 blk_root_drained_end(blk
->root
);
1286 int blk_pwrite_zeroes(BlockBackend
*blk
, int64_t offset
,
1287 int bytes
, BdrvRequestFlags flags
)
1289 return blk_prw(blk
, offset
, NULL
, bytes
, blk_write_entry
,
1290 flags
| BDRV_REQ_ZERO_WRITE
);
1293 int blk_make_zero(BlockBackend
*blk
, BdrvRequestFlags flags
)
1295 return bdrv_make_zero(blk
->root
, flags
);
1298 static void blk_inc_in_flight(BlockBackend
*blk
)
1300 atomic_inc(&blk
->in_flight
);
1303 static void blk_dec_in_flight(BlockBackend
*blk
)
1305 atomic_dec(&blk
->in_flight
);
1309 static void error_callback_bh(void *opaque
)
1311 struct BlockBackendAIOCB
*acb
= opaque
;
1313 blk_dec_in_flight(acb
->blk
);
1314 acb
->common
.cb(acb
->common
.opaque
, acb
->ret
);
1315 qemu_aio_unref(acb
);
1318 BlockAIOCB
*blk_abort_aio_request(BlockBackend
*blk
,
1319 BlockCompletionFunc
*cb
,
1320 void *opaque
, int ret
)
1322 struct BlockBackendAIOCB
*acb
;
1324 blk_inc_in_flight(blk
);
1325 acb
= blk_aio_get(&block_backend_aiocb_info
, blk
, cb
, opaque
);
1329 aio_bh_schedule_oneshot(blk_get_aio_context(blk
), error_callback_bh
, acb
);
1330 return &acb
->common
;
1333 typedef struct BlkAioEmAIOCB
{
1340 static const AIOCBInfo blk_aio_em_aiocb_info
= {
1341 .aiocb_size
= sizeof(BlkAioEmAIOCB
),
1344 static void blk_aio_complete(BlkAioEmAIOCB
*acb
)
1346 if (acb
->has_returned
) {
1347 acb
->common
.cb(acb
->common
.opaque
, acb
->rwco
.ret
);
1348 blk_dec_in_flight(acb
->rwco
.blk
);
1349 qemu_aio_unref(acb
);
1353 static void blk_aio_complete_bh(void *opaque
)
1355 BlkAioEmAIOCB
*acb
= opaque
;
1356 assert(acb
->has_returned
);
1357 blk_aio_complete(acb
);
1360 static BlockAIOCB
*blk_aio_prwv(BlockBackend
*blk
, int64_t offset
, int bytes
,
1361 void *iobuf
, CoroutineEntry co_entry
,
1362 BdrvRequestFlags flags
,
1363 BlockCompletionFunc
*cb
, void *opaque
)
1368 blk_inc_in_flight(blk
);
1369 acb
= blk_aio_get(&blk_aio_em_aiocb_info
, blk
, cb
, opaque
);
1370 acb
->rwco
= (BlkRwCo
) {
1378 acb
->has_returned
= false;
1380 co
= qemu_coroutine_create(co_entry
, acb
);
1381 bdrv_coroutine_enter(blk_bs(blk
), co
);
1383 acb
->has_returned
= true;
1384 if (acb
->rwco
.ret
!= NOT_DONE
) {
1385 aio_bh_schedule_oneshot(blk_get_aio_context(blk
),
1386 blk_aio_complete_bh
, acb
);
1389 return &acb
->common
;
1392 static void blk_aio_read_entry(void *opaque
)
1394 BlkAioEmAIOCB
*acb
= opaque
;
1395 BlkRwCo
*rwco
= &acb
->rwco
;
1396 QEMUIOVector
*qiov
= rwco
->iobuf
;
1398 assert(qiov
->size
== acb
->bytes
);
1399 rwco
->ret
= blk_co_preadv(rwco
->blk
, rwco
->offset
, acb
->bytes
,
1401 blk_aio_complete(acb
);
1404 static void blk_aio_write_entry(void *opaque
)
1406 BlkAioEmAIOCB
*acb
= opaque
;
1407 BlkRwCo
*rwco
= &acb
->rwco
;
1408 QEMUIOVector
*qiov
= rwco
->iobuf
;
1410 assert(!qiov
|| qiov
->size
== acb
->bytes
);
1411 rwco
->ret
= blk_co_pwritev(rwco
->blk
, rwco
->offset
, acb
->bytes
,
1413 blk_aio_complete(acb
);
1416 BlockAIOCB
*blk_aio_pwrite_zeroes(BlockBackend
*blk
, int64_t offset
,
1417 int count
, BdrvRequestFlags flags
,
1418 BlockCompletionFunc
*cb
, void *opaque
)
1420 return blk_aio_prwv(blk
, offset
, count
, NULL
, blk_aio_write_entry
,
1421 flags
| BDRV_REQ_ZERO_WRITE
, cb
, opaque
);
1424 int blk_pread(BlockBackend
*blk
, int64_t offset
, void *buf
, int count
)
1426 int ret
= blk_prw(blk
, offset
, buf
, count
, blk_read_entry
, 0);
1433 int blk_pwrite(BlockBackend
*blk
, int64_t offset
, const void *buf
, int count
,
1434 BdrvRequestFlags flags
)
1436 int ret
= blk_prw(blk
, offset
, (void *) buf
, count
, blk_write_entry
,
1444 int64_t blk_getlength(BlockBackend
*blk
)
1446 if (!blk_is_available(blk
)) {
1450 return bdrv_getlength(blk_bs(blk
));
1453 void blk_get_geometry(BlockBackend
*blk
, uint64_t *nb_sectors_ptr
)
1456 *nb_sectors_ptr
= 0;
1458 bdrv_get_geometry(blk_bs(blk
), nb_sectors_ptr
);
1462 int64_t blk_nb_sectors(BlockBackend
*blk
)
1464 if (!blk_is_available(blk
)) {
1468 return bdrv_nb_sectors(blk_bs(blk
));
1471 BlockAIOCB
*blk_aio_preadv(BlockBackend
*blk
, int64_t offset
,
1472 QEMUIOVector
*qiov
, BdrvRequestFlags flags
,
1473 BlockCompletionFunc
*cb
, void *opaque
)
1475 return blk_aio_prwv(blk
, offset
, qiov
->size
, qiov
,
1476 blk_aio_read_entry
, flags
, cb
, opaque
);
1479 BlockAIOCB
*blk_aio_pwritev(BlockBackend
*blk
, int64_t offset
,
1480 QEMUIOVector
*qiov
, BdrvRequestFlags flags
,
1481 BlockCompletionFunc
*cb
, void *opaque
)
1483 return blk_aio_prwv(blk
, offset
, qiov
->size
, qiov
,
1484 blk_aio_write_entry
, flags
, cb
, opaque
);
1487 static void blk_aio_flush_entry(void *opaque
)
1489 BlkAioEmAIOCB
*acb
= opaque
;
1490 BlkRwCo
*rwco
= &acb
->rwco
;
1492 rwco
->ret
= blk_co_flush(rwco
->blk
);
1493 blk_aio_complete(acb
);
1496 BlockAIOCB
*blk_aio_flush(BlockBackend
*blk
,
1497 BlockCompletionFunc
*cb
, void *opaque
)
1499 return blk_aio_prwv(blk
, 0, 0, NULL
, blk_aio_flush_entry
, 0, cb
, opaque
);
1502 static void blk_aio_pdiscard_entry(void *opaque
)
1504 BlkAioEmAIOCB
*acb
= opaque
;
1505 BlkRwCo
*rwco
= &acb
->rwco
;
1507 rwco
->ret
= blk_co_pdiscard(rwco
->blk
, rwco
->offset
, acb
->bytes
);
1508 blk_aio_complete(acb
);
1511 BlockAIOCB
*blk_aio_pdiscard(BlockBackend
*blk
,
1512 int64_t offset
, int bytes
,
1513 BlockCompletionFunc
*cb
, void *opaque
)
1515 return blk_aio_prwv(blk
, offset
, bytes
, NULL
, blk_aio_pdiscard_entry
, 0,
1519 void blk_aio_cancel(BlockAIOCB
*acb
)
1521 bdrv_aio_cancel(acb
);
1524 void blk_aio_cancel_async(BlockAIOCB
*acb
)
1526 bdrv_aio_cancel_async(acb
);
1529 int blk_co_ioctl(BlockBackend
*blk
, unsigned long int req
, void *buf
)
1531 if (!blk_is_available(blk
)) {
1535 return bdrv_co_ioctl(blk_bs(blk
), req
, buf
);
1538 static void blk_ioctl_entry(void *opaque
)
1540 BlkRwCo
*rwco
= opaque
;
1541 QEMUIOVector
*qiov
= rwco
->iobuf
;
1543 rwco
->ret
= blk_co_ioctl(rwco
->blk
, rwco
->offset
,
1544 qiov
->iov
[0].iov_base
);
1548 int blk_ioctl(BlockBackend
*blk
, unsigned long int req
, void *buf
)
1550 return blk_prw(blk
, req
, buf
, 0, blk_ioctl_entry
, 0);
1553 static void blk_aio_ioctl_entry(void *opaque
)
1555 BlkAioEmAIOCB
*acb
= opaque
;
1556 BlkRwCo
*rwco
= &acb
->rwco
;
1558 rwco
->ret
= blk_co_ioctl(rwco
->blk
, rwco
->offset
, rwco
->iobuf
);
1560 blk_aio_complete(acb
);
1563 BlockAIOCB
*blk_aio_ioctl(BlockBackend
*blk
, unsigned long int req
, void *buf
,
1564 BlockCompletionFunc
*cb
, void *opaque
)
1566 return blk_aio_prwv(blk
, req
, 0, buf
, blk_aio_ioctl_entry
, 0, cb
, opaque
);
1569 int blk_co_pdiscard(BlockBackend
*blk
, int64_t offset
, int bytes
)
1571 int ret
= blk_check_byte_request(blk
, offset
, bytes
);
1576 return bdrv_co_pdiscard(blk
->root
, offset
, bytes
);
1579 int blk_co_flush(BlockBackend
*blk
)
1581 if (!blk_is_available(blk
)) {
1585 return bdrv_co_flush(blk_bs(blk
));
1588 static void blk_flush_entry(void *opaque
)
1590 BlkRwCo
*rwco
= opaque
;
1591 rwco
->ret
= blk_co_flush(rwco
->blk
);
1595 int blk_flush(BlockBackend
*blk
)
1597 return blk_prw(blk
, 0, NULL
, 0, blk_flush_entry
, 0);
1600 void blk_drain(BlockBackend
*blk
)
1602 BlockDriverState
*bs
= blk_bs(blk
);
1605 bdrv_drained_begin(bs
);
1608 /* We may have -ENOMEDIUM completions in flight */
1609 AIO_WAIT_WHILE(blk_get_aio_context(blk
),
1610 atomic_mb_read(&blk
->in_flight
) > 0);
1613 bdrv_drained_end(bs
);
1617 void blk_drain_all(void)
1619 BlockBackend
*blk
= NULL
;
1621 bdrv_drain_all_begin();
1623 while ((blk
= blk_all_next(blk
)) != NULL
) {
1624 AioContext
*ctx
= blk_get_aio_context(blk
);
1626 aio_context_acquire(ctx
);
1628 /* We may have -ENOMEDIUM completions in flight */
1629 AIO_WAIT_WHILE(ctx
, atomic_mb_read(&blk
->in_flight
) > 0);
1631 aio_context_release(ctx
);
1634 bdrv_drain_all_end();
1637 void blk_set_on_error(BlockBackend
*blk
, BlockdevOnError on_read_error
,
1638 BlockdevOnError on_write_error
)
1640 blk
->on_read_error
= on_read_error
;
1641 blk
->on_write_error
= on_write_error
;
1644 BlockdevOnError
blk_get_on_error(BlockBackend
*blk
, bool is_read
)
1646 return is_read
? blk
->on_read_error
: blk
->on_write_error
;
1649 BlockErrorAction
blk_get_error_action(BlockBackend
*blk
, bool is_read
,
1652 BlockdevOnError on_err
= blk_get_on_error(blk
, is_read
);
1655 case BLOCKDEV_ON_ERROR_ENOSPC
:
1656 return (error
== ENOSPC
) ?
1657 BLOCK_ERROR_ACTION_STOP
: BLOCK_ERROR_ACTION_REPORT
;
1658 case BLOCKDEV_ON_ERROR_STOP
:
1659 return BLOCK_ERROR_ACTION_STOP
;
1660 case BLOCKDEV_ON_ERROR_REPORT
:
1661 return BLOCK_ERROR_ACTION_REPORT
;
1662 case BLOCKDEV_ON_ERROR_IGNORE
:
1663 return BLOCK_ERROR_ACTION_IGNORE
;
1664 case BLOCKDEV_ON_ERROR_AUTO
:
1670 static void send_qmp_error_event(BlockBackend
*blk
,
1671 BlockErrorAction action
,
1672 bool is_read
, int error
)
1674 IoOperationType optype
;
1675 BlockDriverState
*bs
= blk_bs(blk
);
1677 optype
= is_read
? IO_OPERATION_TYPE_READ
: IO_OPERATION_TYPE_WRITE
;
1678 qapi_event_send_block_io_error(blk_name(blk
), !!bs
,
1679 bs
? bdrv_get_node_name(bs
) : NULL
, optype
,
1680 action
, blk_iostatus_is_enabled(blk
),
1681 error
== ENOSPC
, strerror(error
));
1684 /* This is done by device models because, while the block layer knows
1685 * about the error, it does not know whether an operation comes from
1686 * the device or the block layer (from a job, for example).
1688 void blk_error_action(BlockBackend
*blk
, BlockErrorAction action
,
1689 bool is_read
, int error
)
1693 if (action
== BLOCK_ERROR_ACTION_STOP
) {
1694 /* First set the iostatus, so that "info block" returns an iostatus
1695 * that matches the events raised so far (an additional error iostatus
1696 * is fine, but not a lost one).
1698 blk_iostatus_set_err(blk
, error
);
1700 /* Then raise the request to stop the VM and the event.
1701 * qemu_system_vmstop_request_prepare has two effects. First,
1702 * it ensures that the STOP event always comes after the
1703 * BLOCK_IO_ERROR event. Second, it ensures that even if management
1704 * can observe the STOP event and do a "cont" before the STOP
1705 * event is issued, the VM will not stop. In this case, vm_start()
1706 * also ensures that the STOP/RESUME pair of events is emitted.
1708 qemu_system_vmstop_request_prepare();
1709 send_qmp_error_event(blk
, action
, is_read
, error
);
1710 qemu_system_vmstop_request(RUN_STATE_IO_ERROR
);
1712 send_qmp_error_event(blk
, action
, is_read
, error
);
1716 bool blk_is_read_only(BlockBackend
*blk
)
1718 BlockDriverState
*bs
= blk_bs(blk
);
1721 return bdrv_is_read_only(bs
);
1723 return blk
->root_state
.read_only
;
1727 bool blk_is_sg(BlockBackend
*blk
)
1729 BlockDriverState
*bs
= blk_bs(blk
);
1735 return bdrv_is_sg(bs
);
1738 bool blk_enable_write_cache(BlockBackend
*blk
)
1740 return blk
->enable_write_cache
;
1743 void blk_set_enable_write_cache(BlockBackend
*blk
, bool wce
)
1745 blk
->enable_write_cache
= wce
;
1748 void blk_invalidate_cache(BlockBackend
*blk
, Error
**errp
)
1750 BlockDriverState
*bs
= blk_bs(blk
);
1753 error_setg(errp
, "Device '%s' has no medium", blk
->name
);
1757 bdrv_invalidate_cache(bs
, errp
);
1760 bool blk_is_inserted(BlockBackend
*blk
)
1762 BlockDriverState
*bs
= blk_bs(blk
);
1764 return bs
&& bdrv_is_inserted(bs
);
1767 bool blk_is_available(BlockBackend
*blk
)
1769 return blk_is_inserted(blk
) && !blk_dev_is_tray_open(blk
);
1772 void blk_lock_medium(BlockBackend
*blk
, bool locked
)
1774 BlockDriverState
*bs
= blk_bs(blk
);
1777 bdrv_lock_medium(bs
, locked
);
1781 void blk_eject(BlockBackend
*blk
, bool eject_flag
)
1783 BlockDriverState
*bs
= blk_bs(blk
);
1786 /* blk_eject is only called by qdevified devices */
1787 assert(!blk
->legacy_dev
);
1790 bdrv_eject(bs
, eject_flag
);
1793 /* Whether or not we ejected on the backend,
1794 * the frontend experienced a tray event. */
1795 id
= blk_get_attached_dev_id(blk
);
1796 qapi_event_send_device_tray_moved(blk_name(blk
), id
,
1801 int blk_get_flags(BlockBackend
*blk
)
1803 BlockDriverState
*bs
= blk_bs(blk
);
1806 return bdrv_get_flags(bs
);
1808 return blk
->root_state
.open_flags
;
1812 /* Returns the maximum transfer length, in bytes; guaranteed nonzero */
1813 uint32_t blk_get_max_transfer(BlockBackend
*blk
)
1815 BlockDriverState
*bs
= blk_bs(blk
);
1819 max
= bs
->bl
.max_transfer
;
1821 return MIN_NON_ZERO(max
, INT_MAX
);
1824 int blk_get_max_iov(BlockBackend
*blk
)
1826 return blk
->root
->bs
->bl
.max_iov
;
1829 void blk_set_guest_block_size(BlockBackend
*blk
, int align
)
1831 blk
->guest_block_size
= align
;
1834 void *blk_try_blockalign(BlockBackend
*blk
, size_t size
)
1836 return qemu_try_blockalign(blk
? blk_bs(blk
) : NULL
, size
);
1839 void *blk_blockalign(BlockBackend
*blk
, size_t size
)
1841 return qemu_blockalign(blk
? blk_bs(blk
) : NULL
, size
);
1844 bool blk_op_is_blocked(BlockBackend
*blk
, BlockOpType op
, Error
**errp
)
1846 BlockDriverState
*bs
= blk_bs(blk
);
1852 return bdrv_op_is_blocked(bs
, op
, errp
);
1855 void blk_op_unblock(BlockBackend
*blk
, BlockOpType op
, Error
*reason
)
1857 BlockDriverState
*bs
= blk_bs(blk
);
1860 bdrv_op_unblock(bs
, op
, reason
);
1864 void blk_op_block_all(BlockBackend
*blk
, Error
*reason
)
1866 BlockDriverState
*bs
= blk_bs(blk
);
1869 bdrv_op_block_all(bs
, reason
);
1873 void blk_op_unblock_all(BlockBackend
*blk
, Error
*reason
)
1875 BlockDriverState
*bs
= blk_bs(blk
);
1878 bdrv_op_unblock_all(bs
, reason
);
1882 AioContext
*blk_get_aio_context(BlockBackend
*blk
)
1884 return bdrv_get_aio_context(blk_bs(blk
));
1887 static AioContext
*blk_aiocb_get_aio_context(BlockAIOCB
*acb
)
1889 BlockBackendAIOCB
*blk_acb
= DO_UPCAST(BlockBackendAIOCB
, common
, acb
);
1890 return blk_get_aio_context(blk_acb
->blk
);
1893 void blk_set_aio_context(BlockBackend
*blk
, AioContext
*new_context
)
1895 BlockDriverState
*bs
= blk_bs(blk
);
1896 ThrottleGroupMember
*tgm
= &blk
->public.throttle_group_member
;
1899 if (tgm
->throttle_state
) {
1900 bdrv_drained_begin(bs
);
1901 throttle_group_detach_aio_context(tgm
);
1902 throttle_group_attach_aio_context(tgm
, new_context
);
1903 bdrv_drained_end(bs
);
1905 bdrv_set_aio_context(bs
, new_context
);
1909 void blk_add_aio_context_notifier(BlockBackend
*blk
,
1910 void (*attached_aio_context
)(AioContext
*new_context
, void *opaque
),
1911 void (*detach_aio_context
)(void *opaque
), void *opaque
)
1913 BlockBackendAioNotifier
*notifier
;
1914 BlockDriverState
*bs
= blk_bs(blk
);
1916 notifier
= g_new(BlockBackendAioNotifier
, 1);
1917 notifier
->attached_aio_context
= attached_aio_context
;
1918 notifier
->detach_aio_context
= detach_aio_context
;
1919 notifier
->opaque
= opaque
;
1920 QLIST_INSERT_HEAD(&blk
->aio_notifiers
, notifier
, list
);
1923 bdrv_add_aio_context_notifier(bs
, attached_aio_context
,
1924 detach_aio_context
, opaque
);
1928 void blk_remove_aio_context_notifier(BlockBackend
*blk
,
1929 void (*attached_aio_context
)(AioContext
*,
1931 void (*detach_aio_context
)(void *),
1934 BlockBackendAioNotifier
*notifier
;
1935 BlockDriverState
*bs
= blk_bs(blk
);
1938 bdrv_remove_aio_context_notifier(bs
, attached_aio_context
,
1939 detach_aio_context
, opaque
);
1942 QLIST_FOREACH(notifier
, &blk
->aio_notifiers
, list
) {
1943 if (notifier
->attached_aio_context
== attached_aio_context
&&
1944 notifier
->detach_aio_context
== detach_aio_context
&&
1945 notifier
->opaque
== opaque
) {
1946 QLIST_REMOVE(notifier
, list
);
1955 void blk_add_remove_bs_notifier(BlockBackend
*blk
, Notifier
*notify
)
1957 notifier_list_add(&blk
->remove_bs_notifiers
, notify
);
1960 void blk_add_insert_bs_notifier(BlockBackend
*blk
, Notifier
*notify
)
1962 notifier_list_add(&blk
->insert_bs_notifiers
, notify
);
1965 void blk_io_plug(BlockBackend
*blk
)
1967 BlockDriverState
*bs
= blk_bs(blk
);
1974 void blk_io_unplug(BlockBackend
*blk
)
1976 BlockDriverState
*bs
= blk_bs(blk
);
1983 BlockAcctStats
*blk_get_stats(BlockBackend
*blk
)
1988 void *blk_aio_get(const AIOCBInfo
*aiocb_info
, BlockBackend
*blk
,
1989 BlockCompletionFunc
*cb
, void *opaque
)
1991 return qemu_aio_get(aiocb_info
, blk_bs(blk
), cb
, opaque
);
1994 int coroutine_fn
blk_co_pwrite_zeroes(BlockBackend
*blk
, int64_t offset
,
1995 int bytes
, BdrvRequestFlags flags
)
1997 return blk_co_pwritev(blk
, offset
, bytes
, NULL
,
1998 flags
| BDRV_REQ_ZERO_WRITE
);
2001 int blk_pwrite_compressed(BlockBackend
*blk
, int64_t offset
, const void *buf
,
2004 return blk_prw(blk
, offset
, (void *) buf
, count
, blk_write_entry
,
2005 BDRV_REQ_WRITE_COMPRESSED
);
2008 int blk_truncate(BlockBackend
*blk
, int64_t offset
, PreallocMode prealloc
,
2011 if (!blk_is_available(blk
)) {
2012 error_setg(errp
, "No medium inserted");
2016 return bdrv_truncate(blk
->root
, offset
, prealloc
, errp
);
2019 static void blk_pdiscard_entry(void *opaque
)
2021 BlkRwCo
*rwco
= opaque
;
2022 QEMUIOVector
*qiov
= rwco
->iobuf
;
2024 rwco
->ret
= blk_co_pdiscard(rwco
->blk
, rwco
->offset
, qiov
->size
);
2028 int blk_pdiscard(BlockBackend
*blk
, int64_t offset
, int bytes
)
2030 return blk_prw(blk
, offset
, NULL
, bytes
, blk_pdiscard_entry
, 0);
2033 int blk_save_vmstate(BlockBackend
*blk
, const uint8_t *buf
,
2034 int64_t pos
, int size
)
2038 if (!blk_is_available(blk
)) {
2042 ret
= bdrv_save_vmstate(blk_bs(blk
), buf
, pos
, size
);
2047 if (ret
== size
&& !blk
->enable_write_cache
) {
2048 ret
= bdrv_flush(blk_bs(blk
));
2051 return ret
< 0 ? ret
: size
;
2054 int blk_load_vmstate(BlockBackend
*blk
, uint8_t *buf
, int64_t pos
, int size
)
2056 if (!blk_is_available(blk
)) {
2060 return bdrv_load_vmstate(blk_bs(blk
), buf
, pos
, size
);
2063 int blk_probe_blocksizes(BlockBackend
*blk
, BlockSizes
*bsz
)
2065 if (!blk_is_available(blk
)) {
2069 return bdrv_probe_blocksizes(blk_bs(blk
), bsz
);
2072 int blk_probe_geometry(BlockBackend
*blk
, HDGeometry
*geo
)
2074 if (!blk_is_available(blk
)) {
2078 return bdrv_probe_geometry(blk_bs(blk
), geo
);
2082 * Updates the BlockBackendRootState object with data from the currently
2083 * attached BlockDriverState.
2085 void blk_update_root_state(BlockBackend
*blk
)
2089 blk
->root_state
.open_flags
= blk
->root
->bs
->open_flags
;
2090 blk
->root_state
.read_only
= blk
->root
->bs
->read_only
;
2091 blk
->root_state
.detect_zeroes
= blk
->root
->bs
->detect_zeroes
;
2095 * Returns the detect-zeroes setting to be used for bdrv_open() of a
2096 * BlockDriverState which is supposed to inherit the root state.
2098 bool blk_get_detect_zeroes_from_root_state(BlockBackend
*blk
)
2100 return blk
->root_state
.detect_zeroes
;
2104 * Returns the flags to be used for bdrv_open() of a BlockDriverState which is
2105 * supposed to inherit the root state.
2107 int blk_get_open_flags_from_root_state(BlockBackend
*blk
)
2111 bs_flags
= blk
->root_state
.read_only
? 0 : BDRV_O_RDWR
;
2112 bs_flags
|= blk
->root_state
.open_flags
& ~BDRV_O_RDWR
;
2117 BlockBackendRootState
*blk_get_root_state(BlockBackend
*blk
)
2119 return &blk
->root_state
;
2122 int blk_commit_all(void)
2124 BlockBackend
*blk
= NULL
;
2126 while ((blk
= blk_all_next(blk
)) != NULL
) {
2127 AioContext
*aio_context
= blk_get_aio_context(blk
);
2129 aio_context_acquire(aio_context
);
2130 if (blk_is_inserted(blk
) && blk
->root
->bs
->backing
) {
2131 int ret
= bdrv_commit(blk
->root
->bs
);
2133 aio_context_release(aio_context
);
2137 aio_context_release(aio_context
);
2143 /* throttling disk I/O limits */
2144 void blk_set_io_limits(BlockBackend
*blk
, ThrottleConfig
*cfg
)
2146 throttle_group_config(&blk
->public.throttle_group_member
, cfg
);
2149 void blk_io_limits_disable(BlockBackend
*blk
)
2151 BlockDriverState
*bs
= blk_bs(blk
);
2152 ThrottleGroupMember
*tgm
= &blk
->public.throttle_group_member
;
2153 assert(tgm
->throttle_state
);
2155 bdrv_drained_begin(bs
);
2157 throttle_group_unregister_tgm(tgm
);
2159 bdrv_drained_end(bs
);
2163 /* should be called before blk_set_io_limits if a limit is set */
2164 void blk_io_limits_enable(BlockBackend
*blk
, const char *group
)
2166 assert(!blk
->public.throttle_group_member
.throttle_state
);
2167 throttle_group_register_tgm(&blk
->public.throttle_group_member
,
2168 group
, blk_get_aio_context(blk
));
2171 void blk_io_limits_update_group(BlockBackend
*blk
, const char *group
)
2173 /* this BB is not part of any group */
2174 if (!blk
->public.throttle_group_member
.throttle_state
) {
2178 /* this BB is a part of the same group than the one we want */
2179 if (!g_strcmp0(throttle_group_get_name(&blk
->public.throttle_group_member
),
2184 /* need to change the group this bs belong to */
2185 blk_io_limits_disable(blk
);
2186 blk_io_limits_enable(blk
, group
);
2189 static void blk_root_drained_begin(BdrvChild
*child
)
2191 BlockBackend
*blk
= child
->opaque
;
2193 if (++blk
->quiesce_counter
== 1) {
2194 if (blk
->dev_ops
&& blk
->dev_ops
->drained_begin
) {
2195 blk
->dev_ops
->drained_begin(blk
->dev_opaque
);
2199 /* Note that blk->root may not be accessible here yet if we are just
2200 * attaching to a BlockDriverState that is drained. Use child instead. */
2202 if (atomic_fetch_inc(&blk
->public.throttle_group_member
.io_limits_disabled
) == 0) {
2203 throttle_group_restart_tgm(&blk
->public.throttle_group_member
);
2207 static bool blk_root_drained_poll(BdrvChild
*child
)
2209 BlockBackend
*blk
= child
->opaque
;
2210 assert(blk
->quiesce_counter
);
2211 return !!blk
->in_flight
;
2214 static void blk_root_drained_end(BdrvChild
*child
)
2216 BlockBackend
*blk
= child
->opaque
;
2217 assert(blk
->quiesce_counter
);
2219 assert(blk
->public.throttle_group_member
.io_limits_disabled
);
2220 atomic_dec(&blk
->public.throttle_group_member
.io_limits_disabled
);
2222 if (--blk
->quiesce_counter
== 0) {
2223 if (blk
->dev_ops
&& blk
->dev_ops
->drained_end
) {
2224 blk
->dev_ops
->drained_end(blk
->dev_opaque
);
2229 void blk_register_buf(BlockBackend
*blk
, void *host
, size_t size
)
2231 bdrv_register_buf(blk_bs(blk
), host
, size
);
2234 void blk_unregister_buf(BlockBackend
*blk
, void *host
)
2236 bdrv_unregister_buf(blk_bs(blk
), host
);
2239 int coroutine_fn
blk_co_copy_range(BlockBackend
*blk_in
, int64_t off_in
,
2240 BlockBackend
*blk_out
, int64_t off_out
,
2241 int bytes
, BdrvRequestFlags read_flags
,
2242 BdrvRequestFlags write_flags
)
2245 r
= blk_check_byte_request(blk_in
, off_in
, bytes
);
2249 r
= blk_check_byte_request(blk_out
, off_out
, bytes
);
2253 return bdrv_co_copy_range(blk_in
->root
, off_in
,
2254 blk_out
->root
, off_out
,
2255 bytes
, read_flags
, write_flags
);
2258 const BdrvChild
*blk_root(BlockBackend
*blk
)