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-event.h"
23 #include "migration/misc.h"
25 /* Number of coroutines to reserve per attached device model */
26 #define COROUTINE_POOL_RESERVATION 64
28 #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
30 static AioContext
*blk_aiocb_get_aio_context(BlockAIOCB
*acb
);
36 DriveInfo
*legacy_dinfo
; /* null unless created by drive_new() */
37 QTAILQ_ENTRY(BlockBackend
) link
; /* for block_backends */
38 QTAILQ_ENTRY(BlockBackend
) monitor_link
; /* for monitor_block_backends */
39 BlockBackendPublic
public;
41 void *dev
; /* attached device model, if any */
42 bool legacy_dev
; /* true if dev is not a DeviceState */
43 /* TODO change to DeviceState when all users are qdevified */
44 const BlockDevOps
*dev_ops
;
47 /* the block size for which the guest device expects atomicity */
50 /* If the BDS tree is removed, some of its options are stored here (which
51 * can be used to restore those options in the new BDS on insert) */
52 BlockBackendRootState root_state
;
54 bool enable_write_cache
;
56 /* I/O stats (display with "info blockstats"). */
59 BlockdevOnError on_read_error
, on_write_error
;
60 bool iostatus_enabled
;
61 BlockDeviceIoStatus iostatus
;
67 bool allow_write_beyond_eof
;
69 NotifierList remove_bs_notifiers
, insert_bs_notifiers
;
72 VMChangeStateEntry
*vmsh
;
75 typedef struct BlockBackendAIOCB
{
81 static const AIOCBInfo block_backend_aiocb_info
= {
82 .get_aio_context
= blk_aiocb_get_aio_context
,
83 .aiocb_size
= sizeof(BlockBackendAIOCB
),
86 static void drive_info_del(DriveInfo
*dinfo
);
87 static BlockBackend
*bdrv_first_blk(BlockDriverState
*bs
);
89 /* All BlockBackends */
90 static QTAILQ_HEAD(, BlockBackend
) block_backends
=
91 QTAILQ_HEAD_INITIALIZER(block_backends
);
93 /* All BlockBackends referenced by the monitor and which are iterated through by
95 static QTAILQ_HEAD(, BlockBackend
) monitor_block_backends
=
96 QTAILQ_HEAD_INITIALIZER(monitor_block_backends
);
98 static void blk_root_inherit_options(int *child_flags
, QDict
*child_options
,
99 int parent_flags
, QDict
*parent_options
)
101 /* We're not supposed to call this function for root nodes */
104 static void blk_root_drained_begin(BdrvChild
*child
);
105 static void blk_root_drained_end(BdrvChild
*child
);
107 static void blk_root_change_media(BdrvChild
*child
, bool load
);
108 static void blk_root_resize(BdrvChild
*child
);
110 static char *blk_root_get_parent_desc(BdrvChild
*child
)
112 BlockBackend
*blk
= child
->opaque
;
116 return g_strdup(blk
->name
);
119 dev_id
= blk_get_attached_dev_id(blk
);
123 /* TODO Callback into the BB owner for something more detailed */
125 return g_strdup("a block device");
129 static const char *blk_root_get_name(BdrvChild
*child
)
131 return blk_name(child
->opaque
);
134 static void blk_vm_state_changed(void *opaque
, int running
, RunState state
)
136 Error
*local_err
= NULL
;
137 BlockBackend
*blk
= opaque
;
139 if (state
== RUN_STATE_INMIGRATE
) {
143 qemu_del_vm_change_state_handler(blk
->vmsh
);
145 blk_set_perm(blk
, blk
->perm
, blk
->shared_perm
, &local_err
);
147 error_report_err(local_err
);
152 * Notifies the user of the BlockBackend that migration has completed. qdev
153 * devices can tighten their permissions in response (specifically revoke
154 * shared write permissions that we needed for storage migration).
156 * If an error is returned, the VM cannot be allowed to be resumed.
158 static void blk_root_activate(BdrvChild
*child
, Error
**errp
)
160 BlockBackend
*blk
= child
->opaque
;
161 Error
*local_err
= NULL
;
163 if (!blk
->disable_perm
) {
167 blk
->disable_perm
= false;
169 blk_set_perm(blk
, blk
->perm
, BLK_PERM_ALL
, &local_err
);
171 error_propagate(errp
, local_err
);
172 blk
->disable_perm
= true;
176 if (runstate_check(RUN_STATE_INMIGRATE
)) {
177 /* Activation can happen when migration process is still active, for
178 * example when nbd_server_add is called during non-shared storage
179 * migration. Defer the shared_perm update to migration completion. */
181 blk
->vmsh
= qemu_add_vm_change_state_handler(blk_vm_state_changed
,
187 blk_set_perm(blk
, blk
->perm
, blk
->shared_perm
, &local_err
);
189 error_propagate(errp
, local_err
);
190 blk
->disable_perm
= true;
195 static int blk_root_inactivate(BdrvChild
*child
)
197 BlockBackend
*blk
= child
->opaque
;
199 if (blk
->disable_perm
) {
203 /* Only inactivate BlockBackends for guest devices (which are inactive at
204 * this point because the VM is stopped) and unattached monitor-owned
205 * BlockBackends. If there is still any other user like a block job, then
206 * we simply can't inactivate the image. */
207 if (!blk
->dev
&& !blk_name(blk
)[0]) {
211 blk
->disable_perm
= true;
213 bdrv_child_try_set_perm(blk
->root
, 0, BLK_PERM_ALL
, &error_abort
);
219 static const BdrvChildRole child_root
= {
220 .inherit_options
= blk_root_inherit_options
,
222 .change_media
= blk_root_change_media
,
223 .resize
= blk_root_resize
,
224 .get_name
= blk_root_get_name
,
225 .get_parent_desc
= blk_root_get_parent_desc
,
227 .drained_begin
= blk_root_drained_begin
,
228 .drained_end
= blk_root_drained_end
,
230 .activate
= blk_root_activate
,
231 .inactivate
= blk_root_inactivate
,
235 * Create a new BlockBackend with a reference count of one.
237 * @perm is a bitmasks of BLK_PERM_* constants which describes the permissions
238 * to request for a block driver node that is attached to this BlockBackend.
239 * @shared_perm is a bitmask which describes which permissions may be granted
240 * to other users of the attached node.
241 * Both sets of permissions can be changed later using blk_set_perm().
243 * Return the new BlockBackend on success, null on failure.
245 BlockBackend
*blk_new(uint64_t perm
, uint64_t shared_perm
)
249 blk
= g_new0(BlockBackend
, 1);
252 blk
->shared_perm
= shared_perm
;
253 blk_set_enable_write_cache(blk
, true);
255 qemu_co_mutex_init(&blk
->public.throttled_reqs_lock
);
256 qemu_co_queue_init(&blk
->public.throttled_reqs
[0]);
257 qemu_co_queue_init(&blk
->public.throttled_reqs
[1]);
258 block_acct_init(&blk
->stats
);
260 notifier_list_init(&blk
->remove_bs_notifiers
);
261 notifier_list_init(&blk
->insert_bs_notifiers
);
263 QTAILQ_INSERT_TAIL(&block_backends
, blk
, link
);
268 * Creates a new BlockBackend, opens a new BlockDriverState, and connects both.
270 * Just as with bdrv_open(), after having called this function the reference to
271 * @options belongs to the block layer (even on failure).
273 * TODO: Remove @filename and @flags; it should be possible to specify a whole
274 * BDS tree just by specifying the @options QDict (or @reference,
275 * alternatively). At the time of adding this function, this is not possible,
276 * though, so callers of this function have to be able to specify @filename and
279 BlockBackend
*blk_new_open(const char *filename
, const char *reference
,
280 QDict
*options
, int flags
, Error
**errp
)
283 BlockDriverState
*bs
;
286 /* blk_new_open() is mainly used in .bdrv_create implementations and the
287 * tools where sharing isn't a concern because the BDS stays private, so we
288 * just request permission according to the flags.
290 * The exceptions are xen_disk and blockdev_init(); in these cases, the
291 * caller of blk_new_open() doesn't make use of the permissions, but they
292 * shouldn't hurt either. We can still share everything here because the
293 * guest devices will add their own blockers if they can't share. */
294 perm
= BLK_PERM_CONSISTENT_READ
;
295 if (flags
& BDRV_O_RDWR
) {
296 perm
|= BLK_PERM_WRITE
;
298 if (flags
& BDRV_O_RESIZE
) {
299 perm
|= BLK_PERM_RESIZE
;
302 blk
= blk_new(perm
, BLK_PERM_ALL
);
303 bs
= bdrv_open(filename
, reference
, options
, flags
, errp
);
309 blk
->root
= bdrv_root_attach_child(bs
, "root", &child_root
,
310 perm
, BLK_PERM_ALL
, blk
, errp
);
320 static void blk_delete(BlockBackend
*blk
)
322 assert(!blk
->refcnt
);
325 if (blk
->public.throttle_state
) {
326 blk_io_limits_disable(blk
);
332 qemu_del_vm_change_state_handler(blk
->vmsh
);
335 assert(QLIST_EMPTY(&blk
->remove_bs_notifiers
.notifiers
));
336 assert(QLIST_EMPTY(&blk
->insert_bs_notifiers
.notifiers
));
337 QTAILQ_REMOVE(&block_backends
, blk
, link
);
338 drive_info_del(blk
->legacy_dinfo
);
339 block_acct_cleanup(&blk
->stats
);
343 static void drive_info_del(DriveInfo
*dinfo
)
348 qemu_opts_del(dinfo
->opts
);
349 g_free(dinfo
->serial
);
353 int blk_get_refcnt(BlockBackend
*blk
)
355 return blk
? blk
->refcnt
: 0;
359 * Increment @blk's reference count.
360 * @blk must not be null.
362 void blk_ref(BlockBackend
*blk
)
368 * Decrement @blk's reference count.
369 * If this drops it to zero, destroy @blk.
370 * For convenience, do nothing if @blk is null.
372 void blk_unref(BlockBackend
*blk
)
375 assert(blk
->refcnt
> 0);
376 if (!--blk
->refcnt
) {
383 * Behaves similarly to blk_next() but iterates over all BlockBackends, even the
384 * ones which are hidden (i.e. are not referenced by the monitor).
386 BlockBackend
*blk_all_next(BlockBackend
*blk
)
388 return blk
? QTAILQ_NEXT(blk
, link
)
389 : QTAILQ_FIRST(&block_backends
);
392 void blk_remove_all_bs(void)
394 BlockBackend
*blk
= NULL
;
396 while ((blk
= blk_all_next(blk
)) != NULL
) {
397 AioContext
*ctx
= blk_get_aio_context(blk
);
399 aio_context_acquire(ctx
);
403 aio_context_release(ctx
);
408 * Return the monitor-owned BlockBackend after @blk.
409 * If @blk is null, return the first one.
410 * Else, return @blk's next sibling, which may be null.
412 * To iterate over all BlockBackends, do
413 * for (blk = blk_next(NULL); blk; blk = blk_next(blk)) {
417 BlockBackend
*blk_next(BlockBackend
*blk
)
419 return blk
? QTAILQ_NEXT(blk
, monitor_link
)
420 : QTAILQ_FIRST(&monitor_block_backends
);
423 /* Iterates over all top-level BlockDriverStates, i.e. BDSs that are owned by
424 * the monitor or attached to a BlockBackend */
425 BlockDriverState
*bdrv_next(BdrvNextIterator
*it
)
427 BlockDriverState
*bs
;
429 /* First, return all root nodes of BlockBackends. In order to avoid
430 * returning a BDS twice when multiple BBs refer to it, we only return it
431 * if the BB is the first one in the parent list of the BDS. */
432 if (it
->phase
== BDRV_NEXT_BACKEND_ROOTS
) {
434 it
->blk
= blk_all_next(it
->blk
);
435 bs
= it
->blk
? blk_bs(it
->blk
) : NULL
;
436 } while (it
->blk
&& (bs
== NULL
|| bdrv_first_blk(bs
) != it
->blk
));
441 it
->phase
= BDRV_NEXT_MONITOR_OWNED
;
444 /* Then return the monitor-owned BDSes without a BB attached. Ignore all
445 * BDSes that are attached to a BlockBackend here; they have been handled
446 * by the above block already */
448 it
->bs
= bdrv_next_monitor_owned(it
->bs
);
450 } while (bs
&& bdrv_has_blk(bs
));
455 BlockDriverState
*bdrv_first(BdrvNextIterator
*it
)
457 *it
= (BdrvNextIterator
) {
458 .phase
= BDRV_NEXT_BACKEND_ROOTS
,
461 return bdrv_next(it
);
465 * Add a BlockBackend into the list of backends referenced by the monitor, with
466 * the given @name acting as the handle for the monitor.
467 * Strictly for use by blockdev.c.
469 * @name must not be null or empty.
471 * Returns true on success and false on failure. In the latter case, an Error
472 * object is returned through @errp.
474 bool monitor_add_blk(BlockBackend
*blk
, const char *name
, Error
**errp
)
477 assert(name
&& name
[0]);
479 if (!id_wellformed(name
)) {
480 error_setg(errp
, "Invalid device name");
483 if (blk_by_name(name
)) {
484 error_setg(errp
, "Device with id '%s' already exists", name
);
487 if (bdrv_find_node(name
)) {
489 "Device name '%s' conflicts with an existing node name",
494 blk
->name
= g_strdup(name
);
495 QTAILQ_INSERT_TAIL(&monitor_block_backends
, blk
, monitor_link
);
500 * Remove a BlockBackend from the list of backends referenced by the monitor.
501 * Strictly for use by blockdev.c.
503 void monitor_remove_blk(BlockBackend
*blk
)
509 QTAILQ_REMOVE(&monitor_block_backends
, blk
, monitor_link
);
515 * Return @blk's name, a non-null string.
516 * Returns an empty string iff @blk is not referenced by the monitor.
518 const char *blk_name(const BlockBackend
*blk
)
520 return blk
->name
?: "";
524 * Return the BlockBackend with name @name if it exists, else null.
525 * @name must not be null.
527 BlockBackend
*blk_by_name(const char *name
)
529 BlockBackend
*blk
= NULL
;
532 while ((blk
= blk_next(blk
)) != NULL
) {
533 if (!strcmp(name
, blk
->name
)) {
541 * Return the BlockDriverState attached to @blk if any, else null.
543 BlockDriverState
*blk_bs(BlockBackend
*blk
)
545 return blk
->root
? blk
->root
->bs
: NULL
;
548 static BlockBackend
*bdrv_first_blk(BlockDriverState
*bs
)
551 QLIST_FOREACH(child
, &bs
->parents
, next_parent
) {
552 if (child
->role
== &child_root
) {
553 return child
->opaque
;
561 * Returns true if @bs has an associated BlockBackend.
563 bool bdrv_has_blk(BlockDriverState
*bs
)
565 return bdrv_first_blk(bs
) != NULL
;
569 * Returns true if @bs has only BlockBackends as parents.
571 bool bdrv_is_root_node(BlockDriverState
*bs
)
575 QLIST_FOREACH(c
, &bs
->parents
, next_parent
) {
576 if (c
->role
!= &child_root
) {
585 * Return @blk's DriveInfo if any, else null.
587 DriveInfo
*blk_legacy_dinfo(BlockBackend
*blk
)
589 return blk
->legacy_dinfo
;
593 * Set @blk's DriveInfo to @dinfo, and return it.
594 * @blk must not have a DriveInfo set already.
595 * No other BlockBackend may have the same DriveInfo set.
597 DriveInfo
*blk_set_legacy_dinfo(BlockBackend
*blk
, DriveInfo
*dinfo
)
599 assert(!blk
->legacy_dinfo
);
600 return blk
->legacy_dinfo
= dinfo
;
604 * Return the BlockBackend with DriveInfo @dinfo.
607 BlockBackend
*blk_by_legacy_dinfo(DriveInfo
*dinfo
)
609 BlockBackend
*blk
= NULL
;
611 while ((blk
= blk_next(blk
)) != NULL
) {
612 if (blk
->legacy_dinfo
== dinfo
) {
620 * Returns a pointer to the publicly accessible fields of @blk.
622 BlockBackendPublic
*blk_get_public(BlockBackend
*blk
)
628 * Returns a BlockBackend given the associated @public fields.
630 BlockBackend
*blk_by_public(BlockBackendPublic
*public)
632 return container_of(public, BlockBackend
, public);
636 * Disassociates the currently associated BlockDriverState from @blk.
638 void blk_remove_bs(BlockBackend
*blk
)
640 notifier_list_notify(&blk
->remove_bs_notifiers
, blk
);
641 if (blk
->public.throttle_state
) {
642 throttle_timers_detach_aio_context(&blk
->public.throttle_timers
);
645 blk_update_root_state(blk
);
647 bdrv_root_unref_child(blk
->root
);
652 * Associates a new BlockDriverState with @blk.
654 int blk_insert_bs(BlockBackend
*blk
, BlockDriverState
*bs
, Error
**errp
)
656 blk
->root
= bdrv_root_attach_child(bs
, "root", &child_root
,
657 blk
->perm
, blk
->shared_perm
, blk
, errp
);
658 if (blk
->root
== NULL
) {
663 notifier_list_notify(&blk
->insert_bs_notifiers
, blk
);
664 if (blk
->public.throttle_state
) {
665 throttle_timers_attach_aio_context(
666 &blk
->public.throttle_timers
, bdrv_get_aio_context(bs
));
673 * Sets the permission bitmasks that the user of the BlockBackend needs.
675 int blk_set_perm(BlockBackend
*blk
, uint64_t perm
, uint64_t shared_perm
,
680 if (blk
->root
&& !blk
->disable_perm
) {
681 ret
= bdrv_child_try_set_perm(blk
->root
, perm
, shared_perm
, errp
);
688 blk
->shared_perm
= shared_perm
;
693 void blk_get_perm(BlockBackend
*blk
, uint64_t *perm
, uint64_t *shared_perm
)
696 *shared_perm
= blk
->shared_perm
;
699 static int blk_do_attach_dev(BlockBackend
*blk
, void *dev
)
705 /* While migration is still incoming, we don't need to apply the
706 * permissions of guest device BlockBackends. We might still have a block
707 * job or NBD server writing to the image for storage migration. */
708 if (runstate_check(RUN_STATE_INMIGRATE
)) {
709 blk
->disable_perm
= true;
714 blk
->legacy_dev
= false;
715 blk_iostatus_reset(blk
);
721 * Attach device model @dev to @blk.
722 * Return 0 on success, -EBUSY when a device model is attached already.
724 int blk_attach_dev(BlockBackend
*blk
, DeviceState
*dev
)
726 return blk_do_attach_dev(blk
, dev
);
730 * Attach device model @dev to @blk.
731 * @blk must not have a device model attached already.
732 * TODO qdevified devices don't use this, remove when devices are qdevified
734 void blk_attach_dev_legacy(BlockBackend
*blk
, void *dev
)
736 if (blk_do_attach_dev(blk
, dev
) < 0) {
739 blk
->legacy_dev
= true;
743 * Detach device model @dev from @blk.
744 * @dev must be currently attached to @blk.
746 void blk_detach_dev(BlockBackend
*blk
, void *dev
)
747 /* TODO change to DeviceState *dev when all users are qdevified */
749 assert(blk
->dev
== dev
);
752 blk
->dev_opaque
= NULL
;
753 blk
->guest_block_size
= 512;
754 blk_set_perm(blk
, 0, BLK_PERM_ALL
, &error_abort
);
759 * Return the device model attached to @blk if any, else null.
761 void *blk_get_attached_dev(BlockBackend
*blk
)
762 /* TODO change to return DeviceState * when all users are qdevified */
767 /* Return the qdev ID, or if no ID is assigned the QOM path, of the block
768 * device attached to the BlockBackend. */
769 char *blk_get_attached_dev_id(BlockBackend
*blk
)
773 assert(!blk
->legacy_dev
);
778 } else if (dev
->id
) {
779 return g_strdup(dev
->id
);
781 return object_get_canonical_path(OBJECT(dev
));
785 * Return the BlockBackend which has the device model @dev attached if it
788 * @dev must not be null.
790 BlockBackend
*blk_by_dev(void *dev
)
792 BlockBackend
*blk
= NULL
;
795 while ((blk
= blk_all_next(blk
)) != NULL
) {
796 if (blk
->dev
== dev
) {
804 * Set @blk's device model callbacks to @ops.
805 * @opaque is the opaque argument to pass to the callbacks.
806 * This is for use by device models.
808 void blk_set_dev_ops(BlockBackend
*blk
, const BlockDevOps
*ops
,
811 /* All drivers that use blk_set_dev_ops() are qdevified and we want to keep
812 * it that way, so we can assume blk->dev, if present, is a DeviceState if
813 * blk->dev_ops is set. Non-device users may use dev_ops without device. */
814 assert(!blk
->legacy_dev
);
817 blk
->dev_opaque
= opaque
;
819 /* Are we currently quiesced? Should we enforce this right now? */
820 if (blk
->quiesce_counter
&& ops
->drained_begin
) {
821 ops
->drained_begin(opaque
);
826 * Notify @blk's attached device model of media change.
828 * If @load is true, notify of media load. This action can fail, meaning that
829 * the medium cannot be loaded. @errp is set then.
831 * If @load is false, notify of media eject. This can never fail.
833 * Also send DEVICE_TRAY_MOVED events as appropriate.
835 void blk_dev_change_media_cb(BlockBackend
*blk
, bool load
, Error
**errp
)
837 if (blk
->dev_ops
&& blk
->dev_ops
->change_media_cb
) {
838 bool tray_was_open
, tray_is_open
;
839 Error
*local_err
= NULL
;
841 assert(!blk
->legacy_dev
);
843 tray_was_open
= blk_dev_is_tray_open(blk
);
844 blk
->dev_ops
->change_media_cb(blk
->dev_opaque
, load
, &local_err
);
846 assert(load
== true);
847 error_propagate(errp
, local_err
);
850 tray_is_open
= blk_dev_is_tray_open(blk
);
852 if (tray_was_open
!= tray_is_open
) {
853 char *id
= blk_get_attached_dev_id(blk
);
854 qapi_event_send_device_tray_moved(blk_name(blk
), id
, tray_is_open
,
861 static void blk_root_change_media(BdrvChild
*child
, bool load
)
863 blk_dev_change_media_cb(child
->opaque
, load
, NULL
);
867 * Does @blk's attached device model have removable media?
868 * %true if no device model is attached.
870 bool blk_dev_has_removable_media(BlockBackend
*blk
)
872 return !blk
->dev
|| (blk
->dev_ops
&& blk
->dev_ops
->change_media_cb
);
876 * Does @blk's attached device model have a tray?
878 bool blk_dev_has_tray(BlockBackend
*blk
)
880 return blk
->dev_ops
&& blk
->dev_ops
->is_tray_open
;
884 * Notify @blk's attached device model of a media eject request.
885 * If @force is true, the medium is about to be yanked out forcefully.
887 void blk_dev_eject_request(BlockBackend
*blk
, bool force
)
889 if (blk
->dev_ops
&& blk
->dev_ops
->eject_request_cb
) {
890 blk
->dev_ops
->eject_request_cb(blk
->dev_opaque
, force
);
895 * Does @blk's attached device model have a tray, and is it open?
897 bool blk_dev_is_tray_open(BlockBackend
*blk
)
899 if (blk_dev_has_tray(blk
)) {
900 return blk
->dev_ops
->is_tray_open(blk
->dev_opaque
);
906 * Does @blk's attached device model have the medium locked?
907 * %false if the device model has no such lock.
909 bool blk_dev_is_medium_locked(BlockBackend
*blk
)
911 if (blk
->dev_ops
&& blk
->dev_ops
->is_medium_locked
) {
912 return blk
->dev_ops
->is_medium_locked(blk
->dev_opaque
);
918 * Notify @blk's attached device model of a backend size change.
920 static void blk_root_resize(BdrvChild
*child
)
922 BlockBackend
*blk
= child
->opaque
;
924 if (blk
->dev_ops
&& blk
->dev_ops
->resize_cb
) {
925 blk
->dev_ops
->resize_cb(blk
->dev_opaque
);
929 void blk_iostatus_enable(BlockBackend
*blk
)
931 blk
->iostatus_enabled
= true;
932 blk
->iostatus
= BLOCK_DEVICE_IO_STATUS_OK
;
935 /* The I/O status is only enabled if the drive explicitly
936 * enables it _and_ the VM is configured to stop on errors */
937 bool blk_iostatus_is_enabled(const BlockBackend
*blk
)
939 return (blk
->iostatus_enabled
&&
940 (blk
->on_write_error
== BLOCKDEV_ON_ERROR_ENOSPC
||
941 blk
->on_write_error
== BLOCKDEV_ON_ERROR_STOP
||
942 blk
->on_read_error
== BLOCKDEV_ON_ERROR_STOP
));
945 BlockDeviceIoStatus
blk_iostatus(const BlockBackend
*blk
)
947 return blk
->iostatus
;
950 void blk_iostatus_disable(BlockBackend
*blk
)
952 blk
->iostatus_enabled
= false;
955 void blk_iostatus_reset(BlockBackend
*blk
)
957 if (blk_iostatus_is_enabled(blk
)) {
958 BlockDriverState
*bs
= blk_bs(blk
);
959 blk
->iostatus
= BLOCK_DEVICE_IO_STATUS_OK
;
961 block_job_iostatus_reset(bs
->job
);
966 void blk_iostatus_set_err(BlockBackend
*blk
, int error
)
968 assert(blk_iostatus_is_enabled(blk
));
969 if (blk
->iostatus
== BLOCK_DEVICE_IO_STATUS_OK
) {
970 blk
->iostatus
= error
== ENOSPC
? BLOCK_DEVICE_IO_STATUS_NOSPACE
:
971 BLOCK_DEVICE_IO_STATUS_FAILED
;
975 void blk_set_allow_write_beyond_eof(BlockBackend
*blk
, bool allow
)
977 blk
->allow_write_beyond_eof
= allow
;
980 static int blk_check_byte_request(BlockBackend
*blk
, int64_t offset
,
985 if (size
> INT_MAX
) {
989 if (!blk_is_available(blk
)) {
997 if (!blk
->allow_write_beyond_eof
) {
998 len
= blk_getlength(blk
);
1003 if (offset
> len
|| len
- offset
< size
) {
1011 int coroutine_fn
blk_co_preadv(BlockBackend
*blk
, int64_t offset
,
1012 unsigned int bytes
, QEMUIOVector
*qiov
,
1013 BdrvRequestFlags flags
)
1016 BlockDriverState
*bs
= blk_bs(blk
);
1018 trace_blk_co_preadv(blk
, bs
, offset
, bytes
, flags
);
1020 ret
= blk_check_byte_request(blk
, offset
, bytes
);
1025 bdrv_inc_in_flight(bs
);
1027 /* throttling disk I/O */
1028 if (blk
->public.throttle_state
) {
1029 throttle_group_co_io_limits_intercept(blk
, bytes
, false);
1032 ret
= bdrv_co_preadv(blk
->root
, offset
, bytes
, qiov
, flags
);
1033 bdrv_dec_in_flight(bs
);
1037 int coroutine_fn
blk_co_pwritev(BlockBackend
*blk
, int64_t offset
,
1038 unsigned int bytes
, QEMUIOVector
*qiov
,
1039 BdrvRequestFlags flags
)
1042 BlockDriverState
*bs
= blk_bs(blk
);
1044 trace_blk_co_pwritev(blk
, bs
, offset
, bytes
, flags
);
1046 ret
= blk_check_byte_request(blk
, offset
, bytes
);
1051 bdrv_inc_in_flight(bs
);
1053 /* throttling disk I/O */
1054 if (blk
->public.throttle_state
) {
1055 throttle_group_co_io_limits_intercept(blk
, bytes
, true);
1058 if (!blk
->enable_write_cache
) {
1059 flags
|= BDRV_REQ_FUA
;
1062 ret
= bdrv_co_pwritev(blk
->root
, offset
, bytes
, qiov
, flags
);
1063 bdrv_dec_in_flight(bs
);
1067 typedef struct BlkRwCo
{
1072 BdrvRequestFlags flags
;
1075 static void blk_read_entry(void *opaque
)
1077 BlkRwCo
*rwco
= opaque
;
1079 rwco
->ret
= blk_co_preadv(rwco
->blk
, rwco
->offset
, rwco
->qiov
->size
,
1080 rwco
->qiov
, rwco
->flags
);
1083 static void blk_write_entry(void *opaque
)
1085 BlkRwCo
*rwco
= opaque
;
1087 rwco
->ret
= blk_co_pwritev(rwco
->blk
, rwco
->offset
, rwco
->qiov
->size
,
1088 rwco
->qiov
, rwco
->flags
);
1091 static int blk_prw(BlockBackend
*blk
, int64_t offset
, uint8_t *buf
,
1092 int64_t bytes
, CoroutineEntry co_entry
,
1093 BdrvRequestFlags flags
)
1099 iov
= (struct iovec
) {
1103 qemu_iovec_init_external(&qiov
, &iov
, 1);
1113 if (qemu_in_coroutine()) {
1114 /* Fast-path if already in coroutine context */
1117 Coroutine
*co
= qemu_coroutine_create(co_entry
, &rwco
);
1118 bdrv_coroutine_enter(blk_bs(blk
), co
);
1119 BDRV_POLL_WHILE(blk_bs(blk
), rwco
.ret
== NOT_DONE
);
1125 int blk_pread_unthrottled(BlockBackend
*blk
, int64_t offset
, uint8_t *buf
,
1130 ret
= blk_check_byte_request(blk
, offset
, count
);
1135 blk_root_drained_begin(blk
->root
);
1136 ret
= blk_pread(blk
, offset
, buf
, count
);
1137 blk_root_drained_end(blk
->root
);
1141 int blk_pwrite_zeroes(BlockBackend
*blk
, int64_t offset
,
1142 int bytes
, BdrvRequestFlags flags
)
1144 return blk_prw(blk
, offset
, NULL
, bytes
, blk_write_entry
,
1145 flags
| BDRV_REQ_ZERO_WRITE
);
1148 int blk_make_zero(BlockBackend
*blk
, BdrvRequestFlags flags
)
1150 return bdrv_make_zero(blk
->root
, flags
);
1153 static void error_callback_bh(void *opaque
)
1155 struct BlockBackendAIOCB
*acb
= opaque
;
1157 bdrv_dec_in_flight(acb
->common
.bs
);
1158 acb
->common
.cb(acb
->common
.opaque
, acb
->ret
);
1159 qemu_aio_unref(acb
);
1162 BlockAIOCB
*blk_abort_aio_request(BlockBackend
*blk
,
1163 BlockCompletionFunc
*cb
,
1164 void *opaque
, int ret
)
1166 struct BlockBackendAIOCB
*acb
;
1168 bdrv_inc_in_flight(blk_bs(blk
));
1169 acb
= blk_aio_get(&block_backend_aiocb_info
, blk
, cb
, opaque
);
1173 aio_bh_schedule_oneshot(blk_get_aio_context(blk
), error_callback_bh
, acb
);
1174 return &acb
->common
;
1177 typedef struct BlkAioEmAIOCB
{
1184 static const AIOCBInfo blk_aio_em_aiocb_info
= {
1185 .aiocb_size
= sizeof(BlkAioEmAIOCB
),
1188 static void blk_aio_complete(BlkAioEmAIOCB
*acb
)
1190 if (acb
->has_returned
) {
1191 bdrv_dec_in_flight(acb
->common
.bs
);
1192 acb
->common
.cb(acb
->common
.opaque
, acb
->rwco
.ret
);
1193 qemu_aio_unref(acb
);
1197 static void blk_aio_complete_bh(void *opaque
)
1199 BlkAioEmAIOCB
*acb
= opaque
;
1200 assert(acb
->has_returned
);
1201 blk_aio_complete(acb
);
1204 static BlockAIOCB
*blk_aio_prwv(BlockBackend
*blk
, int64_t offset
, int bytes
,
1205 QEMUIOVector
*qiov
, CoroutineEntry co_entry
,
1206 BdrvRequestFlags flags
,
1207 BlockCompletionFunc
*cb
, void *opaque
)
1212 bdrv_inc_in_flight(blk_bs(blk
));
1213 acb
= blk_aio_get(&blk_aio_em_aiocb_info
, blk
, cb
, opaque
);
1214 acb
->rwco
= (BlkRwCo
) {
1222 acb
->has_returned
= false;
1224 co
= qemu_coroutine_create(co_entry
, acb
);
1225 bdrv_coroutine_enter(blk_bs(blk
), co
);
1227 acb
->has_returned
= true;
1228 if (acb
->rwco
.ret
!= NOT_DONE
) {
1229 aio_bh_schedule_oneshot(blk_get_aio_context(blk
),
1230 blk_aio_complete_bh
, acb
);
1233 return &acb
->common
;
1236 static void blk_aio_read_entry(void *opaque
)
1238 BlkAioEmAIOCB
*acb
= opaque
;
1239 BlkRwCo
*rwco
= &acb
->rwco
;
1241 assert(rwco
->qiov
->size
== acb
->bytes
);
1242 rwco
->ret
= blk_co_preadv(rwco
->blk
, rwco
->offset
, acb
->bytes
,
1243 rwco
->qiov
, rwco
->flags
);
1244 blk_aio_complete(acb
);
1247 static void blk_aio_write_entry(void *opaque
)
1249 BlkAioEmAIOCB
*acb
= opaque
;
1250 BlkRwCo
*rwco
= &acb
->rwco
;
1252 assert(!rwco
->qiov
|| rwco
->qiov
->size
== acb
->bytes
);
1253 rwco
->ret
= blk_co_pwritev(rwco
->blk
, rwco
->offset
, acb
->bytes
,
1254 rwco
->qiov
, rwco
->flags
);
1255 blk_aio_complete(acb
);
1258 BlockAIOCB
*blk_aio_pwrite_zeroes(BlockBackend
*blk
, int64_t offset
,
1259 int count
, BdrvRequestFlags flags
,
1260 BlockCompletionFunc
*cb
, void *opaque
)
1262 return blk_aio_prwv(blk
, offset
, count
, NULL
, blk_aio_write_entry
,
1263 flags
| BDRV_REQ_ZERO_WRITE
, cb
, opaque
);
1266 int blk_pread(BlockBackend
*blk
, int64_t offset
, void *buf
, int count
)
1268 int ret
= blk_prw(blk
, offset
, buf
, count
, blk_read_entry
, 0);
1275 int blk_pwrite(BlockBackend
*blk
, int64_t offset
, const void *buf
, int count
,
1276 BdrvRequestFlags flags
)
1278 int ret
= blk_prw(blk
, offset
, (void *) buf
, count
, blk_write_entry
,
1286 int64_t blk_getlength(BlockBackend
*blk
)
1288 if (!blk_is_available(blk
)) {
1292 return bdrv_getlength(blk_bs(blk
));
1295 void blk_get_geometry(BlockBackend
*blk
, uint64_t *nb_sectors_ptr
)
1298 *nb_sectors_ptr
= 0;
1300 bdrv_get_geometry(blk_bs(blk
), nb_sectors_ptr
);
1304 int64_t blk_nb_sectors(BlockBackend
*blk
)
1306 if (!blk_is_available(blk
)) {
1310 return bdrv_nb_sectors(blk_bs(blk
));
1313 BlockAIOCB
*blk_aio_preadv(BlockBackend
*blk
, int64_t offset
,
1314 QEMUIOVector
*qiov
, BdrvRequestFlags flags
,
1315 BlockCompletionFunc
*cb
, void *opaque
)
1317 return blk_aio_prwv(blk
, offset
, qiov
->size
, qiov
,
1318 blk_aio_read_entry
, flags
, cb
, opaque
);
1321 BlockAIOCB
*blk_aio_pwritev(BlockBackend
*blk
, int64_t offset
,
1322 QEMUIOVector
*qiov
, BdrvRequestFlags flags
,
1323 BlockCompletionFunc
*cb
, void *opaque
)
1325 return blk_aio_prwv(blk
, offset
, qiov
->size
, qiov
,
1326 blk_aio_write_entry
, flags
, cb
, opaque
);
1329 static void blk_aio_flush_entry(void *opaque
)
1331 BlkAioEmAIOCB
*acb
= opaque
;
1332 BlkRwCo
*rwco
= &acb
->rwco
;
1334 rwco
->ret
= blk_co_flush(rwco
->blk
);
1335 blk_aio_complete(acb
);
1338 BlockAIOCB
*blk_aio_flush(BlockBackend
*blk
,
1339 BlockCompletionFunc
*cb
, void *opaque
)
1341 return blk_aio_prwv(blk
, 0, 0, NULL
, blk_aio_flush_entry
, 0, cb
, opaque
);
1344 static void blk_aio_pdiscard_entry(void *opaque
)
1346 BlkAioEmAIOCB
*acb
= opaque
;
1347 BlkRwCo
*rwco
= &acb
->rwco
;
1349 rwco
->ret
= blk_co_pdiscard(rwco
->blk
, rwco
->offset
, acb
->bytes
);
1350 blk_aio_complete(acb
);
1353 BlockAIOCB
*blk_aio_pdiscard(BlockBackend
*blk
,
1354 int64_t offset
, int bytes
,
1355 BlockCompletionFunc
*cb
, void *opaque
)
1357 return blk_aio_prwv(blk
, offset
, bytes
, NULL
, blk_aio_pdiscard_entry
, 0,
1361 void blk_aio_cancel(BlockAIOCB
*acb
)
1363 bdrv_aio_cancel(acb
);
1366 void blk_aio_cancel_async(BlockAIOCB
*acb
)
1368 bdrv_aio_cancel_async(acb
);
1371 int blk_co_ioctl(BlockBackend
*blk
, unsigned long int req
, void *buf
)
1373 if (!blk_is_available(blk
)) {
1377 return bdrv_co_ioctl(blk_bs(blk
), req
, buf
);
1380 static void blk_ioctl_entry(void *opaque
)
1382 BlkRwCo
*rwco
= opaque
;
1383 rwco
->ret
= blk_co_ioctl(rwco
->blk
, rwco
->offset
,
1384 rwco
->qiov
->iov
[0].iov_base
);
1387 int blk_ioctl(BlockBackend
*blk
, unsigned long int req
, void *buf
)
1389 return blk_prw(blk
, req
, buf
, 0, blk_ioctl_entry
, 0);
1392 static void blk_aio_ioctl_entry(void *opaque
)
1394 BlkAioEmAIOCB
*acb
= opaque
;
1395 BlkRwCo
*rwco
= &acb
->rwco
;
1397 rwco
->ret
= blk_co_ioctl(rwco
->blk
, rwco
->offset
,
1398 rwco
->qiov
->iov
[0].iov_base
);
1399 blk_aio_complete(acb
);
1402 BlockAIOCB
*blk_aio_ioctl(BlockBackend
*blk
, unsigned long int req
, void *buf
,
1403 BlockCompletionFunc
*cb
, void *opaque
)
1408 iov
= (struct iovec
) {
1412 qemu_iovec_init_external(&qiov
, &iov
, 1);
1414 return blk_aio_prwv(blk
, req
, 0, &qiov
, blk_aio_ioctl_entry
, 0, cb
, opaque
);
1417 int blk_co_pdiscard(BlockBackend
*blk
, int64_t offset
, int bytes
)
1419 int ret
= blk_check_byte_request(blk
, offset
, bytes
);
1424 return bdrv_co_pdiscard(blk_bs(blk
), offset
, bytes
);
1427 int blk_co_flush(BlockBackend
*blk
)
1429 if (!blk_is_available(blk
)) {
1433 return bdrv_co_flush(blk_bs(blk
));
1436 static void blk_flush_entry(void *opaque
)
1438 BlkRwCo
*rwco
= opaque
;
1439 rwco
->ret
= blk_co_flush(rwco
->blk
);
1442 int blk_flush(BlockBackend
*blk
)
1444 return blk_prw(blk
, 0, NULL
, 0, blk_flush_entry
, 0);
1447 void blk_drain(BlockBackend
*blk
)
1450 bdrv_drain(blk_bs(blk
));
1454 void blk_drain_all(void)
1459 void blk_set_on_error(BlockBackend
*blk
, BlockdevOnError on_read_error
,
1460 BlockdevOnError on_write_error
)
1462 blk
->on_read_error
= on_read_error
;
1463 blk
->on_write_error
= on_write_error
;
1466 BlockdevOnError
blk_get_on_error(BlockBackend
*blk
, bool is_read
)
1468 return is_read
? blk
->on_read_error
: blk
->on_write_error
;
1471 BlockErrorAction
blk_get_error_action(BlockBackend
*blk
, bool is_read
,
1474 BlockdevOnError on_err
= blk_get_on_error(blk
, is_read
);
1477 case BLOCKDEV_ON_ERROR_ENOSPC
:
1478 return (error
== ENOSPC
) ?
1479 BLOCK_ERROR_ACTION_STOP
: BLOCK_ERROR_ACTION_REPORT
;
1480 case BLOCKDEV_ON_ERROR_STOP
:
1481 return BLOCK_ERROR_ACTION_STOP
;
1482 case BLOCKDEV_ON_ERROR_REPORT
:
1483 return BLOCK_ERROR_ACTION_REPORT
;
1484 case BLOCKDEV_ON_ERROR_IGNORE
:
1485 return BLOCK_ERROR_ACTION_IGNORE
;
1486 case BLOCKDEV_ON_ERROR_AUTO
:
1492 static void send_qmp_error_event(BlockBackend
*blk
,
1493 BlockErrorAction action
,
1494 bool is_read
, int error
)
1496 IoOperationType optype
;
1498 optype
= is_read
? IO_OPERATION_TYPE_READ
: IO_OPERATION_TYPE_WRITE
;
1499 qapi_event_send_block_io_error(blk_name(blk
),
1500 bdrv_get_node_name(blk_bs(blk
)), optype
,
1501 action
, blk_iostatus_is_enabled(blk
),
1502 error
== ENOSPC
, strerror(error
),
1506 /* This is done by device models because, while the block layer knows
1507 * about the error, it does not know whether an operation comes from
1508 * the device or the block layer (from a job, for example).
1510 void blk_error_action(BlockBackend
*blk
, BlockErrorAction action
,
1511 bool is_read
, int error
)
1515 if (action
== BLOCK_ERROR_ACTION_STOP
) {
1516 /* First set the iostatus, so that "info block" returns an iostatus
1517 * that matches the events raised so far (an additional error iostatus
1518 * is fine, but not a lost one).
1520 blk_iostatus_set_err(blk
, error
);
1522 /* Then raise the request to stop the VM and the event.
1523 * qemu_system_vmstop_request_prepare has two effects. First,
1524 * it ensures that the STOP event always comes after the
1525 * BLOCK_IO_ERROR event. Second, it ensures that even if management
1526 * can observe the STOP event and do a "cont" before the STOP
1527 * event is issued, the VM will not stop. In this case, vm_start()
1528 * also ensures that the STOP/RESUME pair of events is emitted.
1530 qemu_system_vmstop_request_prepare();
1531 send_qmp_error_event(blk
, action
, is_read
, error
);
1532 qemu_system_vmstop_request(RUN_STATE_IO_ERROR
);
1534 send_qmp_error_event(blk
, action
, is_read
, error
);
1538 int blk_is_read_only(BlockBackend
*blk
)
1540 BlockDriverState
*bs
= blk_bs(blk
);
1543 return bdrv_is_read_only(bs
);
1545 return blk
->root_state
.read_only
;
1549 int blk_is_sg(BlockBackend
*blk
)
1551 BlockDriverState
*bs
= blk_bs(blk
);
1557 return bdrv_is_sg(bs
);
1560 int blk_enable_write_cache(BlockBackend
*blk
)
1562 return blk
->enable_write_cache
;
1565 void blk_set_enable_write_cache(BlockBackend
*blk
, bool wce
)
1567 blk
->enable_write_cache
= wce
;
1570 void blk_invalidate_cache(BlockBackend
*blk
, Error
**errp
)
1572 BlockDriverState
*bs
= blk_bs(blk
);
1575 error_setg(errp
, "Device '%s' has no medium", blk
->name
);
1579 bdrv_invalidate_cache(bs
, errp
);
1582 bool blk_is_inserted(BlockBackend
*blk
)
1584 BlockDriverState
*bs
= blk_bs(blk
);
1586 return bs
&& bdrv_is_inserted(bs
);
1589 bool blk_is_available(BlockBackend
*blk
)
1591 return blk_is_inserted(blk
) && !blk_dev_is_tray_open(blk
);
1594 void blk_lock_medium(BlockBackend
*blk
, bool locked
)
1596 BlockDriverState
*bs
= blk_bs(blk
);
1599 bdrv_lock_medium(bs
, locked
);
1603 void blk_eject(BlockBackend
*blk
, bool eject_flag
)
1605 BlockDriverState
*bs
= blk_bs(blk
);
1608 /* blk_eject is only called by qdevified devices */
1609 assert(!blk
->legacy_dev
);
1612 bdrv_eject(bs
, eject_flag
);
1615 /* Whether or not we ejected on the backend,
1616 * the frontend experienced a tray event. */
1617 id
= blk_get_attached_dev_id(blk
);
1618 qapi_event_send_device_tray_moved(blk_name(blk
), id
,
1619 eject_flag
, &error_abort
);
1623 int blk_get_flags(BlockBackend
*blk
)
1625 BlockDriverState
*bs
= blk_bs(blk
);
1628 return bdrv_get_flags(bs
);
1630 return blk
->root_state
.open_flags
;
1634 /* Returns the maximum transfer length, in bytes; guaranteed nonzero */
1635 uint32_t blk_get_max_transfer(BlockBackend
*blk
)
1637 BlockDriverState
*bs
= blk_bs(blk
);
1641 max
= bs
->bl
.max_transfer
;
1643 return MIN_NON_ZERO(max
, INT_MAX
);
1646 int blk_get_max_iov(BlockBackend
*blk
)
1648 return blk
->root
->bs
->bl
.max_iov
;
1651 void blk_set_guest_block_size(BlockBackend
*blk
, int align
)
1653 blk
->guest_block_size
= align
;
1656 void *blk_try_blockalign(BlockBackend
*blk
, size_t size
)
1658 return qemu_try_blockalign(blk
? blk_bs(blk
) : NULL
, size
);
1661 void *blk_blockalign(BlockBackend
*blk
, size_t size
)
1663 return qemu_blockalign(blk
? blk_bs(blk
) : NULL
, size
);
1666 bool blk_op_is_blocked(BlockBackend
*blk
, BlockOpType op
, Error
**errp
)
1668 BlockDriverState
*bs
= blk_bs(blk
);
1674 return bdrv_op_is_blocked(bs
, op
, errp
);
1677 void blk_op_unblock(BlockBackend
*blk
, BlockOpType op
, Error
*reason
)
1679 BlockDriverState
*bs
= blk_bs(blk
);
1682 bdrv_op_unblock(bs
, op
, reason
);
1686 void blk_op_block_all(BlockBackend
*blk
, Error
*reason
)
1688 BlockDriverState
*bs
= blk_bs(blk
);
1691 bdrv_op_block_all(bs
, reason
);
1695 void blk_op_unblock_all(BlockBackend
*blk
, Error
*reason
)
1697 BlockDriverState
*bs
= blk_bs(blk
);
1700 bdrv_op_unblock_all(bs
, reason
);
1704 AioContext
*blk_get_aio_context(BlockBackend
*blk
)
1706 BlockDriverState
*bs
= blk_bs(blk
);
1709 return bdrv_get_aio_context(bs
);
1711 return qemu_get_aio_context();
1715 static AioContext
*blk_aiocb_get_aio_context(BlockAIOCB
*acb
)
1717 BlockBackendAIOCB
*blk_acb
= DO_UPCAST(BlockBackendAIOCB
, common
, acb
);
1718 return blk_get_aio_context(blk_acb
->blk
);
1721 void blk_set_aio_context(BlockBackend
*blk
, AioContext
*new_context
)
1723 BlockDriverState
*bs
= blk_bs(blk
);
1726 if (blk
->public.throttle_state
) {
1727 throttle_timers_detach_aio_context(&blk
->public.throttle_timers
);
1729 bdrv_set_aio_context(bs
, new_context
);
1730 if (blk
->public.throttle_state
) {
1731 throttle_timers_attach_aio_context(&blk
->public.throttle_timers
,
1737 void blk_add_aio_context_notifier(BlockBackend
*blk
,
1738 void (*attached_aio_context
)(AioContext
*new_context
, void *opaque
),
1739 void (*detach_aio_context
)(void *opaque
), void *opaque
)
1741 BlockDriverState
*bs
= blk_bs(blk
);
1744 bdrv_add_aio_context_notifier(bs
, attached_aio_context
,
1745 detach_aio_context
, opaque
);
1749 void blk_remove_aio_context_notifier(BlockBackend
*blk
,
1750 void (*attached_aio_context
)(AioContext
*,
1752 void (*detach_aio_context
)(void *),
1755 BlockDriverState
*bs
= blk_bs(blk
);
1758 bdrv_remove_aio_context_notifier(bs
, attached_aio_context
,
1759 detach_aio_context
, opaque
);
1763 void blk_add_remove_bs_notifier(BlockBackend
*blk
, Notifier
*notify
)
1765 notifier_list_add(&blk
->remove_bs_notifiers
, notify
);
1768 void blk_add_insert_bs_notifier(BlockBackend
*blk
, Notifier
*notify
)
1770 notifier_list_add(&blk
->insert_bs_notifiers
, notify
);
1773 void blk_io_plug(BlockBackend
*blk
)
1775 BlockDriverState
*bs
= blk_bs(blk
);
1782 void blk_io_unplug(BlockBackend
*blk
)
1784 BlockDriverState
*bs
= blk_bs(blk
);
1791 BlockAcctStats
*blk_get_stats(BlockBackend
*blk
)
1796 void *blk_aio_get(const AIOCBInfo
*aiocb_info
, BlockBackend
*blk
,
1797 BlockCompletionFunc
*cb
, void *opaque
)
1799 return qemu_aio_get(aiocb_info
, blk_bs(blk
), cb
, opaque
);
1802 int coroutine_fn
blk_co_pwrite_zeroes(BlockBackend
*blk
, int64_t offset
,
1803 int bytes
, BdrvRequestFlags flags
)
1805 return blk_co_pwritev(blk
, offset
, bytes
, NULL
,
1806 flags
| BDRV_REQ_ZERO_WRITE
);
1809 int blk_pwrite_compressed(BlockBackend
*blk
, int64_t offset
, const void *buf
,
1812 return blk_prw(blk
, offset
, (void *) buf
, count
, blk_write_entry
,
1813 BDRV_REQ_WRITE_COMPRESSED
);
1816 int blk_truncate(BlockBackend
*blk
, int64_t offset
, PreallocMode prealloc
,
1819 if (!blk_is_available(blk
)) {
1820 error_setg(errp
, "No medium inserted");
1824 return bdrv_truncate(blk
->root
, offset
, prealloc
, errp
);
1827 static void blk_pdiscard_entry(void *opaque
)
1829 BlkRwCo
*rwco
= opaque
;
1830 rwco
->ret
= blk_co_pdiscard(rwco
->blk
, rwco
->offset
, rwco
->qiov
->size
);
1833 int blk_pdiscard(BlockBackend
*blk
, int64_t offset
, int bytes
)
1835 return blk_prw(blk
, offset
, NULL
, bytes
, blk_pdiscard_entry
, 0);
1838 int blk_save_vmstate(BlockBackend
*blk
, const uint8_t *buf
,
1839 int64_t pos
, int size
)
1843 if (!blk_is_available(blk
)) {
1847 ret
= bdrv_save_vmstate(blk_bs(blk
), buf
, pos
, size
);
1852 if (ret
== size
&& !blk
->enable_write_cache
) {
1853 ret
= bdrv_flush(blk_bs(blk
));
1856 return ret
< 0 ? ret
: size
;
1859 int blk_load_vmstate(BlockBackend
*blk
, uint8_t *buf
, int64_t pos
, int size
)
1861 if (!blk_is_available(blk
)) {
1865 return bdrv_load_vmstate(blk_bs(blk
), buf
, pos
, size
);
1868 int blk_probe_blocksizes(BlockBackend
*blk
, BlockSizes
*bsz
)
1870 if (!blk_is_available(blk
)) {
1874 return bdrv_probe_blocksizes(blk_bs(blk
), bsz
);
1877 int blk_probe_geometry(BlockBackend
*blk
, HDGeometry
*geo
)
1879 if (!blk_is_available(blk
)) {
1883 return bdrv_probe_geometry(blk_bs(blk
), geo
);
1887 * Updates the BlockBackendRootState object with data from the currently
1888 * attached BlockDriverState.
1890 void blk_update_root_state(BlockBackend
*blk
)
1894 blk
->root_state
.open_flags
= blk
->root
->bs
->open_flags
;
1895 blk
->root_state
.read_only
= blk
->root
->bs
->read_only
;
1896 blk
->root_state
.detect_zeroes
= blk
->root
->bs
->detect_zeroes
;
1900 * Returns the detect-zeroes setting to be used for bdrv_open() of a
1901 * BlockDriverState which is supposed to inherit the root state.
1903 bool blk_get_detect_zeroes_from_root_state(BlockBackend
*blk
)
1905 return blk
->root_state
.detect_zeroes
;
1909 * Returns the flags to be used for bdrv_open() of a BlockDriverState which is
1910 * supposed to inherit the root state.
1912 int blk_get_open_flags_from_root_state(BlockBackend
*blk
)
1916 bs_flags
= blk
->root_state
.read_only
? 0 : BDRV_O_RDWR
;
1917 bs_flags
|= blk
->root_state
.open_flags
& ~BDRV_O_RDWR
;
1922 BlockBackendRootState
*blk_get_root_state(BlockBackend
*blk
)
1924 return &blk
->root_state
;
1927 int blk_commit_all(void)
1929 BlockBackend
*blk
= NULL
;
1931 while ((blk
= blk_all_next(blk
)) != NULL
) {
1932 AioContext
*aio_context
= blk_get_aio_context(blk
);
1934 aio_context_acquire(aio_context
);
1935 if (blk_is_inserted(blk
) && blk
->root
->bs
->backing
) {
1936 int ret
= bdrv_commit(blk
->root
->bs
);
1938 aio_context_release(aio_context
);
1942 aio_context_release(aio_context
);
1948 /* throttling disk I/O limits */
1949 void blk_set_io_limits(BlockBackend
*blk
, ThrottleConfig
*cfg
)
1951 throttle_group_config(blk
, cfg
);
1954 void blk_io_limits_disable(BlockBackend
*blk
)
1956 assert(blk
->public.throttle_state
);
1957 bdrv_drained_begin(blk_bs(blk
));
1958 throttle_group_unregister_blk(blk
);
1959 bdrv_drained_end(blk_bs(blk
));
1962 /* should be called before blk_set_io_limits if a limit is set */
1963 void blk_io_limits_enable(BlockBackend
*blk
, const char *group
)
1965 assert(!blk
->public.throttle_state
);
1966 throttle_group_register_blk(blk
, group
);
1969 void blk_io_limits_update_group(BlockBackend
*blk
, const char *group
)
1971 /* this BB is not part of any group */
1972 if (!blk
->public.throttle_state
) {
1976 /* this BB is a part of the same group than the one we want */
1977 if (!g_strcmp0(throttle_group_get_name(blk
), group
)) {
1981 /* need to change the group this bs belong to */
1982 blk_io_limits_disable(blk
);
1983 blk_io_limits_enable(blk
, group
);
1986 static void blk_root_drained_begin(BdrvChild
*child
)
1988 BlockBackend
*blk
= child
->opaque
;
1990 if (++blk
->quiesce_counter
== 1) {
1991 if (blk
->dev_ops
&& blk
->dev_ops
->drained_begin
) {
1992 blk
->dev_ops
->drained_begin(blk
->dev_opaque
);
1996 /* Note that blk->root may not be accessible here yet if we are just
1997 * attaching to a BlockDriverState that is drained. Use child instead. */
1999 if (atomic_fetch_inc(&blk
->public.io_limits_disabled
) == 0) {
2000 throttle_group_restart_blk(blk
);
2004 static void blk_root_drained_end(BdrvChild
*child
)
2006 BlockBackend
*blk
= child
->opaque
;
2007 assert(blk
->quiesce_counter
);
2009 assert(blk
->public.io_limits_disabled
);
2010 atomic_dec(&blk
->public.io_limits_disabled
);
2012 if (--blk
->quiesce_counter
== 0) {
2013 if (blk
->dev_ops
&& blk
->dev_ops
->drained_end
) {
2014 blk
->dev_ops
->drained_end(blk
->dev_opaque
);