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"
24 /* Number of coroutines to reserve per attached device model */
25 #define COROUTINE_POOL_RESERVATION 64
27 #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
29 static AioContext
*blk_aiocb_get_aio_context(BlockAIOCB
*acb
);
35 DriveInfo
*legacy_dinfo
; /* null unless created by drive_new() */
36 QTAILQ_ENTRY(BlockBackend
) link
; /* for block_backends */
37 QTAILQ_ENTRY(BlockBackend
) monitor_link
; /* for monitor_block_backends */
38 BlockBackendPublic
public;
40 void *dev
; /* attached device model, if any */
41 bool legacy_dev
; /* true if dev is not a DeviceState */
42 /* TODO change to DeviceState when all users are qdevified */
43 const BlockDevOps
*dev_ops
;
46 /* the block size for which the guest device expects atomicity */
49 /* If the BDS tree is removed, some of its options are stored here (which
50 * can be used to restore those options in the new BDS on insert) */
51 BlockBackendRootState root_state
;
53 bool enable_write_cache
;
55 /* I/O stats (display with "info blockstats"). */
58 BlockdevOnError on_read_error
, on_write_error
;
59 bool iostatus_enabled
;
60 BlockDeviceIoStatus iostatus
;
65 bool allow_write_beyond_eof
;
67 NotifierList remove_bs_notifiers
, insert_bs_notifiers
;
70 typedef struct BlockBackendAIOCB
{
76 static const AIOCBInfo block_backend_aiocb_info
= {
77 .get_aio_context
= blk_aiocb_get_aio_context
,
78 .aiocb_size
= sizeof(BlockBackendAIOCB
),
81 static void drive_info_del(DriveInfo
*dinfo
);
82 static BlockBackend
*bdrv_first_blk(BlockDriverState
*bs
);
84 /* All BlockBackends */
85 static QTAILQ_HEAD(, BlockBackend
) block_backends
=
86 QTAILQ_HEAD_INITIALIZER(block_backends
);
88 /* All BlockBackends referenced by the monitor and which are iterated through by
90 static QTAILQ_HEAD(, BlockBackend
) monitor_block_backends
=
91 QTAILQ_HEAD_INITIALIZER(monitor_block_backends
);
93 static void blk_root_inherit_options(int *child_flags
, QDict
*child_options
,
94 int parent_flags
, QDict
*parent_options
)
96 /* We're not supposed to call this function for root nodes */
99 static void blk_root_drained_begin(BdrvChild
*child
);
100 static void blk_root_drained_end(BdrvChild
*child
);
102 static void blk_root_change_media(BdrvChild
*child
, bool load
);
103 static void blk_root_resize(BdrvChild
*child
);
105 static const char *blk_root_get_name(BdrvChild
*child
)
107 return blk_name(child
->opaque
);
110 static const BdrvChildRole child_root
= {
111 .inherit_options
= blk_root_inherit_options
,
113 .change_media
= blk_root_change_media
,
114 .resize
= blk_root_resize
,
115 .get_name
= blk_root_get_name
,
117 .drained_begin
= blk_root_drained_begin
,
118 .drained_end
= blk_root_drained_end
,
122 * Create a new BlockBackend with a reference count of one.
124 * @perm is a bitmasks of BLK_PERM_* constants which describes the permissions
125 * to request for a block driver node that is attached to this BlockBackend.
126 * @shared_perm is a bitmask which describes which permissions may be granted
127 * to other users of the attached node.
128 * Both sets of permissions can be changed later using blk_set_perm().
130 * Return the new BlockBackend on success, null on failure.
132 BlockBackend
*blk_new(uint64_t perm
, uint64_t shared_perm
)
136 blk
= g_new0(BlockBackend
, 1);
139 blk
->shared_perm
= shared_perm
;
140 blk_set_enable_write_cache(blk
, true);
142 qemu_co_queue_init(&blk
->public.throttled_reqs
[0]);
143 qemu_co_queue_init(&blk
->public.throttled_reqs
[1]);
145 notifier_list_init(&blk
->remove_bs_notifiers
);
146 notifier_list_init(&blk
->insert_bs_notifiers
);
148 QTAILQ_INSERT_TAIL(&block_backends
, blk
, link
);
153 * Creates a new BlockBackend, opens a new BlockDriverState, and connects both.
155 * Just as with bdrv_open(), after having called this function the reference to
156 * @options belongs to the block layer (even on failure).
158 * TODO: Remove @filename and @flags; it should be possible to specify a whole
159 * BDS tree just by specifying the @options QDict (or @reference,
160 * alternatively). At the time of adding this function, this is not possible,
161 * though, so callers of this function have to be able to specify @filename and
164 BlockBackend
*blk_new_open(const char *filename
, const char *reference
,
165 QDict
*options
, int flags
, Error
**errp
)
168 BlockDriverState
*bs
;
170 blk
= blk_new(0, BLK_PERM_ALL
);
171 bs
= bdrv_open(filename
, reference
, options
, flags
, errp
);
177 /* FIXME Use real permissions */
178 blk
->root
= bdrv_root_attach_child(bs
, "root", &child_root
,
179 0, BLK_PERM_ALL
, blk
, &error_abort
);
184 static void blk_delete(BlockBackend
*blk
)
186 assert(!blk
->refcnt
);
192 assert(QLIST_EMPTY(&blk
->remove_bs_notifiers
.notifiers
));
193 assert(QLIST_EMPTY(&blk
->insert_bs_notifiers
.notifiers
));
194 QTAILQ_REMOVE(&block_backends
, blk
, link
);
195 drive_info_del(blk
->legacy_dinfo
);
196 block_acct_cleanup(&blk
->stats
);
200 static void drive_info_del(DriveInfo
*dinfo
)
205 qemu_opts_del(dinfo
->opts
);
206 g_free(dinfo
->serial
);
210 int blk_get_refcnt(BlockBackend
*blk
)
212 return blk
? blk
->refcnt
: 0;
216 * Increment @blk's reference count.
217 * @blk must not be null.
219 void blk_ref(BlockBackend
*blk
)
225 * Decrement @blk's reference count.
226 * If this drops it to zero, destroy @blk.
227 * For convenience, do nothing if @blk is null.
229 void blk_unref(BlockBackend
*blk
)
232 assert(blk
->refcnt
> 0);
233 if (!--blk
->refcnt
) {
240 * Behaves similarly to blk_next() but iterates over all BlockBackends, even the
241 * ones which are hidden (i.e. are not referenced by the monitor).
243 static BlockBackend
*blk_all_next(BlockBackend
*blk
)
245 return blk
? QTAILQ_NEXT(blk
, link
)
246 : QTAILQ_FIRST(&block_backends
);
249 void blk_remove_all_bs(void)
251 BlockBackend
*blk
= NULL
;
253 while ((blk
= blk_all_next(blk
)) != NULL
) {
254 AioContext
*ctx
= blk_get_aio_context(blk
);
256 aio_context_acquire(ctx
);
260 aio_context_release(ctx
);
265 * Return the monitor-owned BlockBackend after @blk.
266 * If @blk is null, return the first one.
267 * Else, return @blk's next sibling, which may be null.
269 * To iterate over all BlockBackends, do
270 * for (blk = blk_next(NULL); blk; blk = blk_next(blk)) {
274 BlockBackend
*blk_next(BlockBackend
*blk
)
276 return blk
? QTAILQ_NEXT(blk
, monitor_link
)
277 : QTAILQ_FIRST(&monitor_block_backends
);
280 /* Iterates over all top-level BlockDriverStates, i.e. BDSs that are owned by
281 * the monitor or attached to a BlockBackend */
282 BlockDriverState
*bdrv_next(BdrvNextIterator
*it
)
284 BlockDriverState
*bs
;
286 /* First, return all root nodes of BlockBackends. In order to avoid
287 * returning a BDS twice when multiple BBs refer to it, we only return it
288 * if the BB is the first one in the parent list of the BDS. */
289 if (it
->phase
== BDRV_NEXT_BACKEND_ROOTS
) {
291 it
->blk
= blk_all_next(it
->blk
);
292 bs
= it
->blk
? blk_bs(it
->blk
) : NULL
;
293 } while (it
->blk
&& (bs
== NULL
|| bdrv_first_blk(bs
) != it
->blk
));
298 it
->phase
= BDRV_NEXT_MONITOR_OWNED
;
301 /* Then return the monitor-owned BDSes without a BB attached. Ignore all
302 * BDSes that are attached to a BlockBackend here; they have been handled
303 * by the above block already */
305 it
->bs
= bdrv_next_monitor_owned(it
->bs
);
307 } while (bs
&& bdrv_has_blk(bs
));
312 BlockDriverState
*bdrv_first(BdrvNextIterator
*it
)
314 *it
= (BdrvNextIterator
) {
315 .phase
= BDRV_NEXT_BACKEND_ROOTS
,
318 return bdrv_next(it
);
322 * Add a BlockBackend into the list of backends referenced by the monitor, with
323 * the given @name acting as the handle for the monitor.
324 * Strictly for use by blockdev.c.
326 * @name must not be null or empty.
328 * Returns true on success and false on failure. In the latter case, an Error
329 * object is returned through @errp.
331 bool monitor_add_blk(BlockBackend
*blk
, const char *name
, Error
**errp
)
334 assert(name
&& name
[0]);
336 if (!id_wellformed(name
)) {
337 error_setg(errp
, "Invalid device name");
340 if (blk_by_name(name
)) {
341 error_setg(errp
, "Device with id '%s' already exists", name
);
344 if (bdrv_find_node(name
)) {
346 "Device name '%s' conflicts with an existing node name",
351 blk
->name
= g_strdup(name
);
352 QTAILQ_INSERT_TAIL(&monitor_block_backends
, blk
, monitor_link
);
357 * Remove a BlockBackend from the list of backends referenced by the monitor.
358 * Strictly for use by blockdev.c.
360 void monitor_remove_blk(BlockBackend
*blk
)
366 QTAILQ_REMOVE(&monitor_block_backends
, blk
, monitor_link
);
372 * Return @blk's name, a non-null string.
373 * Returns an empty string iff @blk is not referenced by the monitor.
375 const char *blk_name(BlockBackend
*blk
)
377 return blk
->name
?: "";
381 * Return the BlockBackend with name @name if it exists, else null.
382 * @name must not be null.
384 BlockBackend
*blk_by_name(const char *name
)
386 BlockBackend
*blk
= NULL
;
389 while ((blk
= blk_next(blk
)) != NULL
) {
390 if (!strcmp(name
, blk
->name
)) {
398 * Return the BlockDriverState attached to @blk if any, else null.
400 BlockDriverState
*blk_bs(BlockBackend
*blk
)
402 return blk
->root
? blk
->root
->bs
: NULL
;
405 static BlockBackend
*bdrv_first_blk(BlockDriverState
*bs
)
408 QLIST_FOREACH(child
, &bs
->parents
, next_parent
) {
409 if (child
->role
== &child_root
) {
410 return child
->opaque
;
418 * Returns true if @bs has an associated BlockBackend.
420 bool bdrv_has_blk(BlockDriverState
*bs
)
422 return bdrv_first_blk(bs
) != NULL
;
426 * Returns true if @bs has only BlockBackends as parents.
428 bool bdrv_is_root_node(BlockDriverState
*bs
)
432 QLIST_FOREACH(c
, &bs
->parents
, next_parent
) {
433 if (c
->role
!= &child_root
) {
442 * Return @blk's DriveInfo if any, else null.
444 DriveInfo
*blk_legacy_dinfo(BlockBackend
*blk
)
446 return blk
->legacy_dinfo
;
450 * Set @blk's DriveInfo to @dinfo, and return it.
451 * @blk must not have a DriveInfo set already.
452 * No other BlockBackend may have the same DriveInfo set.
454 DriveInfo
*blk_set_legacy_dinfo(BlockBackend
*blk
, DriveInfo
*dinfo
)
456 assert(!blk
->legacy_dinfo
);
457 return blk
->legacy_dinfo
= dinfo
;
461 * Return the BlockBackend with DriveInfo @dinfo.
464 BlockBackend
*blk_by_legacy_dinfo(DriveInfo
*dinfo
)
466 BlockBackend
*blk
= NULL
;
468 while ((blk
= blk_next(blk
)) != NULL
) {
469 if (blk
->legacy_dinfo
== dinfo
) {
477 * Returns a pointer to the publicly accessible fields of @blk.
479 BlockBackendPublic
*blk_get_public(BlockBackend
*blk
)
485 * Returns a BlockBackend given the associated @public fields.
487 BlockBackend
*blk_by_public(BlockBackendPublic
*public)
489 return container_of(public, BlockBackend
, public);
493 * Disassociates the currently associated BlockDriverState from @blk.
495 void blk_remove_bs(BlockBackend
*blk
)
497 notifier_list_notify(&blk
->remove_bs_notifiers
, blk
);
498 if (blk
->public.throttle_state
) {
499 throttle_timers_detach_aio_context(&blk
->public.throttle_timers
);
502 blk_update_root_state(blk
);
504 bdrv_root_unref_child(blk
->root
);
509 * Associates a new BlockDriverState with @blk.
511 void blk_insert_bs(BlockBackend
*blk
, BlockDriverState
*bs
)
514 /* FIXME Error handling */
515 blk
->root
= bdrv_root_attach_child(bs
, "root", &child_root
,
516 blk
->perm
, blk
->shared_perm
, blk
,
519 notifier_list_notify(&blk
->insert_bs_notifiers
, blk
);
520 if (blk
->public.throttle_state
) {
521 throttle_timers_attach_aio_context(
522 &blk
->public.throttle_timers
, bdrv_get_aio_context(bs
));
527 * Sets the permission bitmasks that the user of the BlockBackend needs.
529 int blk_set_perm(BlockBackend
*blk
, uint64_t perm
, uint64_t shared_perm
,
535 ret
= bdrv_child_try_set_perm(blk
->root
, perm
, shared_perm
, errp
);
542 blk
->shared_perm
= shared_perm
;
547 static int blk_do_attach_dev(BlockBackend
*blk
, void *dev
)
554 blk
->legacy_dev
= false;
555 blk_iostatus_reset(blk
);
560 * Attach device model @dev to @blk.
561 * Return 0 on success, -EBUSY when a device model is attached already.
563 int blk_attach_dev(BlockBackend
*blk
, DeviceState
*dev
)
565 return blk_do_attach_dev(blk
, dev
);
569 * Attach device model @dev to @blk.
570 * @blk must not have a device model attached already.
571 * TODO qdevified devices don't use this, remove when devices are qdevified
573 void blk_attach_dev_legacy(BlockBackend
*blk
, void *dev
)
575 if (blk_do_attach_dev(blk
, dev
) < 0) {
578 blk
->legacy_dev
= true;
582 * Detach device model @dev from @blk.
583 * @dev must be currently attached to @blk.
585 void blk_detach_dev(BlockBackend
*blk
, void *dev
)
586 /* TODO change to DeviceState *dev when all users are qdevified */
588 assert(blk
->dev
== dev
);
591 blk
->dev_opaque
= NULL
;
592 blk
->guest_block_size
= 512;
593 blk_set_perm(blk
, 0, BLK_PERM_ALL
, &error_abort
);
598 * Return the device model attached to @blk if any, else null.
600 void *blk_get_attached_dev(BlockBackend
*blk
)
601 /* TODO change to return DeviceState * when all users are qdevified */
606 /* Return the qdev ID, or if no ID is assigned the QOM path, of the block
607 * device attached to the BlockBackend. */
608 static char *blk_get_attached_dev_id(BlockBackend
*blk
)
612 assert(!blk
->legacy_dev
);
617 } else if (dev
->id
) {
618 return g_strdup(dev
->id
);
620 return object_get_canonical_path(OBJECT(dev
));
624 * Return the BlockBackend which has the device model @dev attached if it
627 * @dev must not be null.
629 BlockBackend
*blk_by_dev(void *dev
)
631 BlockBackend
*blk
= NULL
;
634 while ((blk
= blk_all_next(blk
)) != NULL
) {
635 if (blk
->dev
== dev
) {
643 * Set @blk's device model callbacks to @ops.
644 * @opaque is the opaque argument to pass to the callbacks.
645 * This is for use by device models.
647 void blk_set_dev_ops(BlockBackend
*blk
, const BlockDevOps
*ops
,
650 /* All drivers that use blk_set_dev_ops() are qdevified and we want to keep
651 * it that way, so we can assume blk->dev is a DeviceState if blk->dev_ops
653 assert(!blk
->legacy_dev
);
656 blk
->dev_opaque
= opaque
;
660 * Notify @blk's attached device model of media change.
661 * If @load is true, notify of media load.
662 * Else, notify of media eject.
663 * Also send DEVICE_TRAY_MOVED events as appropriate.
665 void blk_dev_change_media_cb(BlockBackend
*blk
, bool load
)
667 if (blk
->dev_ops
&& blk
->dev_ops
->change_media_cb
) {
668 bool tray_was_open
, tray_is_open
;
670 assert(!blk
->legacy_dev
);
672 tray_was_open
= blk_dev_is_tray_open(blk
);
673 blk
->dev_ops
->change_media_cb(blk
->dev_opaque
, load
);
674 tray_is_open
= blk_dev_is_tray_open(blk
);
676 if (tray_was_open
!= tray_is_open
) {
677 char *id
= blk_get_attached_dev_id(blk
);
678 qapi_event_send_device_tray_moved(blk_name(blk
), id
, tray_is_open
,
685 static void blk_root_change_media(BdrvChild
*child
, bool load
)
687 blk_dev_change_media_cb(child
->opaque
, load
);
691 * Does @blk's attached device model have removable media?
692 * %true if no device model is attached.
694 bool blk_dev_has_removable_media(BlockBackend
*blk
)
696 return !blk
->dev
|| (blk
->dev_ops
&& blk
->dev_ops
->change_media_cb
);
700 * Does @blk's attached device model have a tray?
702 bool blk_dev_has_tray(BlockBackend
*blk
)
704 return blk
->dev_ops
&& blk
->dev_ops
->is_tray_open
;
708 * Notify @blk's attached device model of a media eject request.
709 * If @force is true, the medium is about to be yanked out forcefully.
711 void blk_dev_eject_request(BlockBackend
*blk
, bool force
)
713 if (blk
->dev_ops
&& blk
->dev_ops
->eject_request_cb
) {
714 blk
->dev_ops
->eject_request_cb(blk
->dev_opaque
, force
);
719 * Does @blk's attached device model have a tray, and is it open?
721 bool blk_dev_is_tray_open(BlockBackend
*blk
)
723 if (blk_dev_has_tray(blk
)) {
724 return blk
->dev_ops
->is_tray_open(blk
->dev_opaque
);
730 * Does @blk's attached device model have the medium locked?
731 * %false if the device model has no such lock.
733 bool blk_dev_is_medium_locked(BlockBackend
*blk
)
735 if (blk
->dev_ops
&& blk
->dev_ops
->is_medium_locked
) {
736 return blk
->dev_ops
->is_medium_locked(blk
->dev_opaque
);
742 * Notify @blk's attached device model of a backend size change.
744 static void blk_root_resize(BdrvChild
*child
)
746 BlockBackend
*blk
= child
->opaque
;
748 if (blk
->dev_ops
&& blk
->dev_ops
->resize_cb
) {
749 blk
->dev_ops
->resize_cb(blk
->dev_opaque
);
753 void blk_iostatus_enable(BlockBackend
*blk
)
755 blk
->iostatus_enabled
= true;
756 blk
->iostatus
= BLOCK_DEVICE_IO_STATUS_OK
;
759 /* The I/O status is only enabled if the drive explicitly
760 * enables it _and_ the VM is configured to stop on errors */
761 bool blk_iostatus_is_enabled(const BlockBackend
*blk
)
763 return (blk
->iostatus_enabled
&&
764 (blk
->on_write_error
== BLOCKDEV_ON_ERROR_ENOSPC
||
765 blk
->on_write_error
== BLOCKDEV_ON_ERROR_STOP
||
766 blk
->on_read_error
== BLOCKDEV_ON_ERROR_STOP
));
769 BlockDeviceIoStatus
blk_iostatus(const BlockBackend
*blk
)
771 return blk
->iostatus
;
774 void blk_iostatus_disable(BlockBackend
*blk
)
776 blk
->iostatus_enabled
= false;
779 void blk_iostatus_reset(BlockBackend
*blk
)
781 if (blk_iostatus_is_enabled(blk
)) {
782 BlockDriverState
*bs
= blk_bs(blk
);
783 blk
->iostatus
= BLOCK_DEVICE_IO_STATUS_OK
;
785 block_job_iostatus_reset(bs
->job
);
790 void blk_iostatus_set_err(BlockBackend
*blk
, int error
)
792 assert(blk_iostatus_is_enabled(blk
));
793 if (blk
->iostatus
== BLOCK_DEVICE_IO_STATUS_OK
) {
794 blk
->iostatus
= error
== ENOSPC
? BLOCK_DEVICE_IO_STATUS_NOSPACE
:
795 BLOCK_DEVICE_IO_STATUS_FAILED
;
799 void blk_set_allow_write_beyond_eof(BlockBackend
*blk
, bool allow
)
801 blk
->allow_write_beyond_eof
= allow
;
804 static int blk_check_byte_request(BlockBackend
*blk
, int64_t offset
,
809 if (size
> INT_MAX
) {
813 if (!blk_is_available(blk
)) {
821 if (!blk
->allow_write_beyond_eof
) {
822 len
= blk_getlength(blk
);
827 if (offset
> len
|| len
- offset
< size
) {
835 int coroutine_fn
blk_co_preadv(BlockBackend
*blk
, int64_t offset
,
836 unsigned int bytes
, QEMUIOVector
*qiov
,
837 BdrvRequestFlags flags
)
840 BlockDriverState
*bs
= blk_bs(blk
);
842 trace_blk_co_preadv(blk
, bs
, offset
, bytes
, flags
);
844 ret
= blk_check_byte_request(blk
, offset
, bytes
);
849 bdrv_inc_in_flight(bs
);
851 /* throttling disk I/O */
852 if (blk
->public.throttle_state
) {
853 throttle_group_co_io_limits_intercept(blk
, bytes
, false);
856 ret
= bdrv_co_preadv(blk
->root
, offset
, bytes
, qiov
, flags
);
857 bdrv_dec_in_flight(bs
);
861 int coroutine_fn
blk_co_pwritev(BlockBackend
*blk
, int64_t offset
,
862 unsigned int bytes
, QEMUIOVector
*qiov
,
863 BdrvRequestFlags flags
)
866 BlockDriverState
*bs
= blk_bs(blk
);
868 trace_blk_co_pwritev(blk
, bs
, offset
, bytes
, flags
);
870 ret
= blk_check_byte_request(blk
, offset
, bytes
);
875 bdrv_inc_in_flight(bs
);
877 /* throttling disk I/O */
878 if (blk
->public.throttle_state
) {
879 throttle_group_co_io_limits_intercept(blk
, bytes
, true);
882 if (!blk
->enable_write_cache
) {
883 flags
|= BDRV_REQ_FUA
;
886 ret
= bdrv_co_pwritev(blk
->root
, offset
, bytes
, qiov
, flags
);
887 bdrv_dec_in_flight(bs
);
891 typedef struct BlkRwCo
{
896 BdrvRequestFlags flags
;
899 static void blk_read_entry(void *opaque
)
901 BlkRwCo
*rwco
= opaque
;
903 rwco
->ret
= blk_co_preadv(rwco
->blk
, rwco
->offset
, rwco
->qiov
->size
,
904 rwco
->qiov
, rwco
->flags
);
907 static void blk_write_entry(void *opaque
)
909 BlkRwCo
*rwco
= opaque
;
911 rwco
->ret
= blk_co_pwritev(rwco
->blk
, rwco
->offset
, rwco
->qiov
->size
,
912 rwco
->qiov
, rwco
->flags
);
915 static int blk_prw(BlockBackend
*blk
, int64_t offset
, uint8_t *buf
,
916 int64_t bytes
, CoroutineEntry co_entry
,
917 BdrvRequestFlags flags
)
923 iov
= (struct iovec
) {
927 qemu_iovec_init_external(&qiov
, &iov
, 1);
937 if (qemu_in_coroutine()) {
938 /* Fast-path if already in coroutine context */
941 Coroutine
*co
= qemu_coroutine_create(co_entry
, &rwco
);
942 qemu_coroutine_enter(co
);
943 BDRV_POLL_WHILE(blk_bs(blk
), rwco
.ret
== NOT_DONE
);
949 int blk_pread_unthrottled(BlockBackend
*blk
, int64_t offset
, uint8_t *buf
,
954 ret
= blk_check_byte_request(blk
, offset
, count
);
959 blk_root_drained_begin(blk
->root
);
960 ret
= blk_pread(blk
, offset
, buf
, count
);
961 blk_root_drained_end(blk
->root
);
965 int blk_pwrite_zeroes(BlockBackend
*blk
, int64_t offset
,
966 int count
, BdrvRequestFlags flags
)
968 return blk_prw(blk
, offset
, NULL
, count
, blk_write_entry
,
969 flags
| BDRV_REQ_ZERO_WRITE
);
972 int blk_make_zero(BlockBackend
*blk
, BdrvRequestFlags flags
)
974 return bdrv_make_zero(blk
->root
, flags
);
977 static void error_callback_bh(void *opaque
)
979 struct BlockBackendAIOCB
*acb
= opaque
;
981 bdrv_dec_in_flight(acb
->common
.bs
);
982 acb
->common
.cb(acb
->common
.opaque
, acb
->ret
);
986 BlockAIOCB
*blk_abort_aio_request(BlockBackend
*blk
,
987 BlockCompletionFunc
*cb
,
988 void *opaque
, int ret
)
990 struct BlockBackendAIOCB
*acb
;
992 bdrv_inc_in_flight(blk_bs(blk
));
993 acb
= blk_aio_get(&block_backend_aiocb_info
, blk
, cb
, opaque
);
997 aio_bh_schedule_oneshot(blk_get_aio_context(blk
), error_callback_bh
, acb
);
1001 typedef struct BlkAioEmAIOCB
{
1008 static const AIOCBInfo blk_aio_em_aiocb_info
= {
1009 .aiocb_size
= sizeof(BlkAioEmAIOCB
),
1012 static void blk_aio_complete(BlkAioEmAIOCB
*acb
)
1014 if (acb
->has_returned
) {
1015 bdrv_dec_in_flight(acb
->common
.bs
);
1016 acb
->common
.cb(acb
->common
.opaque
, acb
->rwco
.ret
);
1017 qemu_aio_unref(acb
);
1021 static void blk_aio_complete_bh(void *opaque
)
1023 BlkAioEmAIOCB
*acb
= opaque
;
1024 assert(acb
->has_returned
);
1025 blk_aio_complete(acb
);
1028 static BlockAIOCB
*blk_aio_prwv(BlockBackend
*blk
, int64_t offset
, int bytes
,
1029 QEMUIOVector
*qiov
, CoroutineEntry co_entry
,
1030 BdrvRequestFlags flags
,
1031 BlockCompletionFunc
*cb
, void *opaque
)
1036 bdrv_inc_in_flight(blk_bs(blk
));
1037 acb
= blk_aio_get(&blk_aio_em_aiocb_info
, blk
, cb
, opaque
);
1038 acb
->rwco
= (BlkRwCo
) {
1046 acb
->has_returned
= false;
1048 co
= qemu_coroutine_create(co_entry
, acb
);
1049 qemu_coroutine_enter(co
);
1051 acb
->has_returned
= true;
1052 if (acb
->rwco
.ret
!= NOT_DONE
) {
1053 aio_bh_schedule_oneshot(blk_get_aio_context(blk
),
1054 blk_aio_complete_bh
, acb
);
1057 return &acb
->common
;
1060 static void blk_aio_read_entry(void *opaque
)
1062 BlkAioEmAIOCB
*acb
= opaque
;
1063 BlkRwCo
*rwco
= &acb
->rwco
;
1065 assert(rwco
->qiov
->size
== acb
->bytes
);
1066 rwco
->ret
= blk_co_preadv(rwco
->blk
, rwco
->offset
, acb
->bytes
,
1067 rwco
->qiov
, rwco
->flags
);
1068 blk_aio_complete(acb
);
1071 static void blk_aio_write_entry(void *opaque
)
1073 BlkAioEmAIOCB
*acb
= opaque
;
1074 BlkRwCo
*rwco
= &acb
->rwco
;
1076 assert(!rwco
->qiov
|| rwco
->qiov
->size
== acb
->bytes
);
1077 rwco
->ret
= blk_co_pwritev(rwco
->blk
, rwco
->offset
, acb
->bytes
,
1078 rwco
->qiov
, rwco
->flags
);
1079 blk_aio_complete(acb
);
1082 BlockAIOCB
*blk_aio_pwrite_zeroes(BlockBackend
*blk
, int64_t offset
,
1083 int count
, BdrvRequestFlags flags
,
1084 BlockCompletionFunc
*cb
, void *opaque
)
1086 return blk_aio_prwv(blk
, offset
, count
, NULL
, blk_aio_write_entry
,
1087 flags
| BDRV_REQ_ZERO_WRITE
, cb
, opaque
);
1090 int blk_pread(BlockBackend
*blk
, int64_t offset
, void *buf
, int count
)
1092 int ret
= blk_prw(blk
, offset
, buf
, count
, blk_read_entry
, 0);
1099 int blk_pwrite(BlockBackend
*blk
, int64_t offset
, const void *buf
, int count
,
1100 BdrvRequestFlags flags
)
1102 int ret
= blk_prw(blk
, offset
, (void *) buf
, count
, blk_write_entry
,
1110 int64_t blk_getlength(BlockBackend
*blk
)
1112 if (!blk_is_available(blk
)) {
1116 return bdrv_getlength(blk_bs(blk
));
1119 void blk_get_geometry(BlockBackend
*blk
, uint64_t *nb_sectors_ptr
)
1122 *nb_sectors_ptr
= 0;
1124 bdrv_get_geometry(blk_bs(blk
), nb_sectors_ptr
);
1128 int64_t blk_nb_sectors(BlockBackend
*blk
)
1130 if (!blk_is_available(blk
)) {
1134 return bdrv_nb_sectors(blk_bs(blk
));
1137 BlockAIOCB
*blk_aio_preadv(BlockBackend
*blk
, int64_t offset
,
1138 QEMUIOVector
*qiov
, BdrvRequestFlags flags
,
1139 BlockCompletionFunc
*cb
, void *opaque
)
1141 return blk_aio_prwv(blk
, offset
, qiov
->size
, qiov
,
1142 blk_aio_read_entry
, flags
, cb
, opaque
);
1145 BlockAIOCB
*blk_aio_pwritev(BlockBackend
*blk
, int64_t offset
,
1146 QEMUIOVector
*qiov
, BdrvRequestFlags flags
,
1147 BlockCompletionFunc
*cb
, void *opaque
)
1149 return blk_aio_prwv(blk
, offset
, qiov
->size
, qiov
,
1150 blk_aio_write_entry
, flags
, cb
, opaque
);
1153 static void blk_aio_flush_entry(void *opaque
)
1155 BlkAioEmAIOCB
*acb
= opaque
;
1156 BlkRwCo
*rwco
= &acb
->rwco
;
1158 rwco
->ret
= blk_co_flush(rwco
->blk
);
1159 blk_aio_complete(acb
);
1162 BlockAIOCB
*blk_aio_flush(BlockBackend
*blk
,
1163 BlockCompletionFunc
*cb
, void *opaque
)
1165 return blk_aio_prwv(blk
, 0, 0, NULL
, blk_aio_flush_entry
, 0, cb
, opaque
);
1168 static void blk_aio_pdiscard_entry(void *opaque
)
1170 BlkAioEmAIOCB
*acb
= opaque
;
1171 BlkRwCo
*rwco
= &acb
->rwco
;
1173 rwco
->ret
= blk_co_pdiscard(rwco
->blk
, rwco
->offset
, acb
->bytes
);
1174 blk_aio_complete(acb
);
1177 BlockAIOCB
*blk_aio_pdiscard(BlockBackend
*blk
,
1178 int64_t offset
, int count
,
1179 BlockCompletionFunc
*cb
, void *opaque
)
1181 return blk_aio_prwv(blk
, offset
, count
, NULL
, blk_aio_pdiscard_entry
, 0,
1185 void blk_aio_cancel(BlockAIOCB
*acb
)
1187 bdrv_aio_cancel(acb
);
1190 void blk_aio_cancel_async(BlockAIOCB
*acb
)
1192 bdrv_aio_cancel_async(acb
);
1195 int blk_co_ioctl(BlockBackend
*blk
, unsigned long int req
, void *buf
)
1197 if (!blk_is_available(blk
)) {
1201 return bdrv_co_ioctl(blk_bs(blk
), req
, buf
);
1204 static void blk_ioctl_entry(void *opaque
)
1206 BlkRwCo
*rwco
= opaque
;
1207 rwco
->ret
= blk_co_ioctl(rwco
->blk
, rwco
->offset
,
1208 rwco
->qiov
->iov
[0].iov_base
);
1211 int blk_ioctl(BlockBackend
*blk
, unsigned long int req
, void *buf
)
1213 return blk_prw(blk
, req
, buf
, 0, blk_ioctl_entry
, 0);
1216 static void blk_aio_ioctl_entry(void *opaque
)
1218 BlkAioEmAIOCB
*acb
= opaque
;
1219 BlkRwCo
*rwco
= &acb
->rwco
;
1221 rwco
->ret
= blk_co_ioctl(rwco
->blk
, rwco
->offset
,
1222 rwco
->qiov
->iov
[0].iov_base
);
1223 blk_aio_complete(acb
);
1226 BlockAIOCB
*blk_aio_ioctl(BlockBackend
*blk
, unsigned long int req
, void *buf
,
1227 BlockCompletionFunc
*cb
, void *opaque
)
1232 iov
= (struct iovec
) {
1236 qemu_iovec_init_external(&qiov
, &iov
, 1);
1238 return blk_aio_prwv(blk
, req
, 0, &qiov
, blk_aio_ioctl_entry
, 0, cb
, opaque
);
1241 int blk_co_pdiscard(BlockBackend
*blk
, int64_t offset
, int count
)
1243 int ret
= blk_check_byte_request(blk
, offset
, count
);
1248 return bdrv_co_pdiscard(blk_bs(blk
), offset
, count
);
1251 int blk_co_flush(BlockBackend
*blk
)
1253 if (!blk_is_available(blk
)) {
1257 return bdrv_co_flush(blk_bs(blk
));
1260 static void blk_flush_entry(void *opaque
)
1262 BlkRwCo
*rwco
= opaque
;
1263 rwco
->ret
= blk_co_flush(rwco
->blk
);
1266 int blk_flush(BlockBackend
*blk
)
1268 return blk_prw(blk
, 0, NULL
, 0, blk_flush_entry
, 0);
1271 void blk_drain(BlockBackend
*blk
)
1274 bdrv_drain(blk_bs(blk
));
1278 void blk_drain_all(void)
1283 void blk_set_on_error(BlockBackend
*blk
, BlockdevOnError on_read_error
,
1284 BlockdevOnError on_write_error
)
1286 blk
->on_read_error
= on_read_error
;
1287 blk
->on_write_error
= on_write_error
;
1290 BlockdevOnError
blk_get_on_error(BlockBackend
*blk
, bool is_read
)
1292 return is_read
? blk
->on_read_error
: blk
->on_write_error
;
1295 BlockErrorAction
blk_get_error_action(BlockBackend
*blk
, bool is_read
,
1298 BlockdevOnError on_err
= blk_get_on_error(blk
, is_read
);
1301 case BLOCKDEV_ON_ERROR_ENOSPC
:
1302 return (error
== ENOSPC
) ?
1303 BLOCK_ERROR_ACTION_STOP
: BLOCK_ERROR_ACTION_REPORT
;
1304 case BLOCKDEV_ON_ERROR_STOP
:
1305 return BLOCK_ERROR_ACTION_STOP
;
1306 case BLOCKDEV_ON_ERROR_REPORT
:
1307 return BLOCK_ERROR_ACTION_REPORT
;
1308 case BLOCKDEV_ON_ERROR_IGNORE
:
1309 return BLOCK_ERROR_ACTION_IGNORE
;
1310 case BLOCKDEV_ON_ERROR_AUTO
:
1316 static void send_qmp_error_event(BlockBackend
*blk
,
1317 BlockErrorAction action
,
1318 bool is_read
, int error
)
1320 IoOperationType optype
;
1322 optype
= is_read
? IO_OPERATION_TYPE_READ
: IO_OPERATION_TYPE_WRITE
;
1323 qapi_event_send_block_io_error(blk_name(blk
),
1324 bdrv_get_node_name(blk_bs(blk
)), optype
,
1325 action
, blk_iostatus_is_enabled(blk
),
1326 error
== ENOSPC
, strerror(error
),
1330 /* This is done by device models because, while the block layer knows
1331 * about the error, it does not know whether an operation comes from
1332 * the device or the block layer (from a job, for example).
1334 void blk_error_action(BlockBackend
*blk
, BlockErrorAction action
,
1335 bool is_read
, int error
)
1339 if (action
== BLOCK_ERROR_ACTION_STOP
) {
1340 /* First set the iostatus, so that "info block" returns an iostatus
1341 * that matches the events raised so far (an additional error iostatus
1342 * is fine, but not a lost one).
1344 blk_iostatus_set_err(blk
, error
);
1346 /* Then raise the request to stop the VM and the event.
1347 * qemu_system_vmstop_request_prepare has two effects. First,
1348 * it ensures that the STOP event always comes after the
1349 * BLOCK_IO_ERROR event. Second, it ensures that even if management
1350 * can observe the STOP event and do a "cont" before the STOP
1351 * event is issued, the VM will not stop. In this case, vm_start()
1352 * also ensures that the STOP/RESUME pair of events is emitted.
1354 qemu_system_vmstop_request_prepare();
1355 send_qmp_error_event(blk
, action
, is_read
, error
);
1356 qemu_system_vmstop_request(RUN_STATE_IO_ERROR
);
1358 send_qmp_error_event(blk
, action
, is_read
, error
);
1362 int blk_is_read_only(BlockBackend
*blk
)
1364 BlockDriverState
*bs
= blk_bs(blk
);
1367 return bdrv_is_read_only(bs
);
1369 return blk
->root_state
.read_only
;
1373 int blk_is_sg(BlockBackend
*blk
)
1375 BlockDriverState
*bs
= blk_bs(blk
);
1381 return bdrv_is_sg(bs
);
1384 int blk_enable_write_cache(BlockBackend
*blk
)
1386 return blk
->enable_write_cache
;
1389 void blk_set_enable_write_cache(BlockBackend
*blk
, bool wce
)
1391 blk
->enable_write_cache
= wce
;
1394 void blk_invalidate_cache(BlockBackend
*blk
, Error
**errp
)
1396 BlockDriverState
*bs
= blk_bs(blk
);
1399 error_setg(errp
, "Device '%s' has no medium", blk
->name
);
1403 bdrv_invalidate_cache(bs
, errp
);
1406 bool blk_is_inserted(BlockBackend
*blk
)
1408 BlockDriverState
*bs
= blk_bs(blk
);
1410 return bs
&& bdrv_is_inserted(bs
);
1413 bool blk_is_available(BlockBackend
*blk
)
1415 return blk_is_inserted(blk
) && !blk_dev_is_tray_open(blk
);
1418 void blk_lock_medium(BlockBackend
*blk
, bool locked
)
1420 BlockDriverState
*bs
= blk_bs(blk
);
1423 bdrv_lock_medium(bs
, locked
);
1427 void blk_eject(BlockBackend
*blk
, bool eject_flag
)
1429 BlockDriverState
*bs
= blk_bs(blk
);
1432 /* blk_eject is only called by qdevified devices */
1433 assert(!blk
->legacy_dev
);
1436 bdrv_eject(bs
, eject_flag
);
1439 /* Whether or not we ejected on the backend,
1440 * the frontend experienced a tray event. */
1441 id
= blk_get_attached_dev_id(blk
);
1442 qapi_event_send_device_tray_moved(blk_name(blk
), id
,
1443 eject_flag
, &error_abort
);
1447 int blk_get_flags(BlockBackend
*blk
)
1449 BlockDriverState
*bs
= blk_bs(blk
);
1452 return bdrv_get_flags(bs
);
1454 return blk
->root_state
.open_flags
;
1458 /* Returns the maximum transfer length, in bytes; guaranteed nonzero */
1459 uint32_t blk_get_max_transfer(BlockBackend
*blk
)
1461 BlockDriverState
*bs
= blk_bs(blk
);
1465 max
= bs
->bl
.max_transfer
;
1467 return MIN_NON_ZERO(max
, INT_MAX
);
1470 int blk_get_max_iov(BlockBackend
*blk
)
1472 return blk
->root
->bs
->bl
.max_iov
;
1475 void blk_set_guest_block_size(BlockBackend
*blk
, int align
)
1477 blk
->guest_block_size
= align
;
1480 void *blk_try_blockalign(BlockBackend
*blk
, size_t size
)
1482 return qemu_try_blockalign(blk
? blk_bs(blk
) : NULL
, size
);
1485 void *blk_blockalign(BlockBackend
*blk
, size_t size
)
1487 return qemu_blockalign(blk
? blk_bs(blk
) : NULL
, size
);
1490 bool blk_op_is_blocked(BlockBackend
*blk
, BlockOpType op
, Error
**errp
)
1492 BlockDriverState
*bs
= blk_bs(blk
);
1498 return bdrv_op_is_blocked(bs
, op
, errp
);
1501 void blk_op_unblock(BlockBackend
*blk
, BlockOpType op
, Error
*reason
)
1503 BlockDriverState
*bs
= blk_bs(blk
);
1506 bdrv_op_unblock(bs
, op
, reason
);
1510 void blk_op_block_all(BlockBackend
*blk
, Error
*reason
)
1512 BlockDriverState
*bs
= blk_bs(blk
);
1515 bdrv_op_block_all(bs
, reason
);
1519 void blk_op_unblock_all(BlockBackend
*blk
, Error
*reason
)
1521 BlockDriverState
*bs
= blk_bs(blk
);
1524 bdrv_op_unblock_all(bs
, reason
);
1528 AioContext
*blk_get_aio_context(BlockBackend
*blk
)
1530 BlockDriverState
*bs
= blk_bs(blk
);
1533 return bdrv_get_aio_context(bs
);
1535 return qemu_get_aio_context();
1539 static AioContext
*blk_aiocb_get_aio_context(BlockAIOCB
*acb
)
1541 BlockBackendAIOCB
*blk_acb
= DO_UPCAST(BlockBackendAIOCB
, common
, acb
);
1542 return blk_get_aio_context(blk_acb
->blk
);
1545 void blk_set_aio_context(BlockBackend
*blk
, AioContext
*new_context
)
1547 BlockDriverState
*bs
= blk_bs(blk
);
1550 if (blk
->public.throttle_state
) {
1551 throttle_timers_detach_aio_context(&blk
->public.throttle_timers
);
1553 bdrv_set_aio_context(bs
, new_context
);
1554 if (blk
->public.throttle_state
) {
1555 throttle_timers_attach_aio_context(&blk
->public.throttle_timers
,
1561 void blk_add_aio_context_notifier(BlockBackend
*blk
,
1562 void (*attached_aio_context
)(AioContext
*new_context
, void *opaque
),
1563 void (*detach_aio_context
)(void *opaque
), void *opaque
)
1565 BlockDriverState
*bs
= blk_bs(blk
);
1568 bdrv_add_aio_context_notifier(bs
, attached_aio_context
,
1569 detach_aio_context
, opaque
);
1573 void blk_remove_aio_context_notifier(BlockBackend
*blk
,
1574 void (*attached_aio_context
)(AioContext
*,
1576 void (*detach_aio_context
)(void *),
1579 BlockDriverState
*bs
= blk_bs(blk
);
1582 bdrv_remove_aio_context_notifier(bs
, attached_aio_context
,
1583 detach_aio_context
, opaque
);
1587 void blk_add_remove_bs_notifier(BlockBackend
*blk
, Notifier
*notify
)
1589 notifier_list_add(&blk
->remove_bs_notifiers
, notify
);
1592 void blk_add_insert_bs_notifier(BlockBackend
*blk
, Notifier
*notify
)
1594 notifier_list_add(&blk
->insert_bs_notifiers
, notify
);
1597 void blk_io_plug(BlockBackend
*blk
)
1599 BlockDriverState
*bs
= blk_bs(blk
);
1606 void blk_io_unplug(BlockBackend
*blk
)
1608 BlockDriverState
*bs
= blk_bs(blk
);
1615 BlockAcctStats
*blk_get_stats(BlockBackend
*blk
)
1620 void *blk_aio_get(const AIOCBInfo
*aiocb_info
, BlockBackend
*blk
,
1621 BlockCompletionFunc
*cb
, void *opaque
)
1623 return qemu_aio_get(aiocb_info
, blk_bs(blk
), cb
, opaque
);
1626 int coroutine_fn
blk_co_pwrite_zeroes(BlockBackend
*blk
, int64_t offset
,
1627 int count
, BdrvRequestFlags flags
)
1629 return blk_co_pwritev(blk
, offset
, count
, NULL
,
1630 flags
| BDRV_REQ_ZERO_WRITE
);
1633 int blk_pwrite_compressed(BlockBackend
*blk
, int64_t offset
, const void *buf
,
1636 return blk_prw(blk
, offset
, (void *) buf
, count
, blk_write_entry
,
1637 BDRV_REQ_WRITE_COMPRESSED
);
1640 int blk_truncate(BlockBackend
*blk
, int64_t offset
)
1642 if (!blk_is_available(blk
)) {
1646 return bdrv_truncate(blk
->root
, offset
);
1649 static void blk_pdiscard_entry(void *opaque
)
1651 BlkRwCo
*rwco
= opaque
;
1652 rwco
->ret
= blk_co_pdiscard(rwco
->blk
, rwco
->offset
, rwco
->qiov
->size
);
1655 int blk_pdiscard(BlockBackend
*blk
, int64_t offset
, int count
)
1657 return blk_prw(blk
, offset
, NULL
, count
, blk_pdiscard_entry
, 0);
1660 int blk_save_vmstate(BlockBackend
*blk
, const uint8_t *buf
,
1661 int64_t pos
, int size
)
1665 if (!blk_is_available(blk
)) {
1669 ret
= bdrv_save_vmstate(blk_bs(blk
), buf
, pos
, size
);
1674 if (ret
== size
&& !blk
->enable_write_cache
) {
1675 ret
= bdrv_flush(blk_bs(blk
));
1678 return ret
< 0 ? ret
: size
;
1681 int blk_load_vmstate(BlockBackend
*blk
, uint8_t *buf
, int64_t pos
, int size
)
1683 if (!blk_is_available(blk
)) {
1687 return bdrv_load_vmstate(blk_bs(blk
), buf
, pos
, size
);
1690 int blk_probe_blocksizes(BlockBackend
*blk
, BlockSizes
*bsz
)
1692 if (!blk_is_available(blk
)) {
1696 return bdrv_probe_blocksizes(blk_bs(blk
), bsz
);
1699 int blk_probe_geometry(BlockBackend
*blk
, HDGeometry
*geo
)
1701 if (!blk_is_available(blk
)) {
1705 return bdrv_probe_geometry(blk_bs(blk
), geo
);
1709 * Updates the BlockBackendRootState object with data from the currently
1710 * attached BlockDriverState.
1712 void blk_update_root_state(BlockBackend
*blk
)
1716 blk
->root_state
.open_flags
= blk
->root
->bs
->open_flags
;
1717 blk
->root_state
.read_only
= blk
->root
->bs
->read_only
;
1718 blk
->root_state
.detect_zeroes
= blk
->root
->bs
->detect_zeroes
;
1722 * Returns the detect-zeroes setting to be used for bdrv_open() of a
1723 * BlockDriverState which is supposed to inherit the root state.
1725 bool blk_get_detect_zeroes_from_root_state(BlockBackend
*blk
)
1727 return blk
->root_state
.detect_zeroes
;
1731 * Returns the flags to be used for bdrv_open() of a BlockDriverState which is
1732 * supposed to inherit the root state.
1734 int blk_get_open_flags_from_root_state(BlockBackend
*blk
)
1738 bs_flags
= blk
->root_state
.read_only
? 0 : BDRV_O_RDWR
;
1739 bs_flags
|= blk
->root_state
.open_flags
& ~BDRV_O_RDWR
;
1744 BlockBackendRootState
*blk_get_root_state(BlockBackend
*blk
)
1746 return &blk
->root_state
;
1749 int blk_commit_all(void)
1751 BlockBackend
*blk
= NULL
;
1753 while ((blk
= blk_all_next(blk
)) != NULL
) {
1754 AioContext
*aio_context
= blk_get_aio_context(blk
);
1756 aio_context_acquire(aio_context
);
1757 if (blk_is_inserted(blk
) && blk
->root
->bs
->backing
) {
1758 int ret
= bdrv_commit(blk
->root
->bs
);
1760 aio_context_release(aio_context
);
1764 aio_context_release(aio_context
);
1770 /* throttling disk I/O limits */
1771 void blk_set_io_limits(BlockBackend
*blk
, ThrottleConfig
*cfg
)
1773 throttle_group_config(blk
, cfg
);
1776 void blk_io_limits_disable(BlockBackend
*blk
)
1778 assert(blk
->public.throttle_state
);
1779 bdrv_drained_begin(blk_bs(blk
));
1780 throttle_group_unregister_blk(blk
);
1781 bdrv_drained_end(blk_bs(blk
));
1784 /* should be called before blk_set_io_limits if a limit is set */
1785 void blk_io_limits_enable(BlockBackend
*blk
, const char *group
)
1787 assert(!blk
->public.throttle_state
);
1788 throttle_group_register_blk(blk
, group
);
1791 void blk_io_limits_update_group(BlockBackend
*blk
, const char *group
)
1793 /* this BB is not part of any group */
1794 if (!blk
->public.throttle_state
) {
1798 /* this BB is a part of the same group than the one we want */
1799 if (!g_strcmp0(throttle_group_get_name(blk
), group
)) {
1803 /* need to change the group this bs belong to */
1804 blk_io_limits_disable(blk
);
1805 blk_io_limits_enable(blk
, group
);
1808 static void blk_root_drained_begin(BdrvChild
*child
)
1810 BlockBackend
*blk
= child
->opaque
;
1812 /* Note that blk->root may not be accessible here yet if we are just
1813 * attaching to a BlockDriverState that is drained. Use child instead. */
1815 if (blk
->public.io_limits_disabled
++ == 0) {
1816 throttle_group_restart_blk(blk
);
1820 static void blk_root_drained_end(BdrvChild
*child
)
1822 BlockBackend
*blk
= child
->opaque
;
1824 assert(blk
->public.io_limits_disabled
);
1825 --blk
->public.io_limits_disabled
;