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 /* Number of coroutines to reserve per attached device model */
24 #define COROUTINE_POOL_RESERVATION 64
26 #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
28 static AioContext
*blk_aiocb_get_aio_context(BlockAIOCB
*acb
);
34 DriveInfo
*legacy_dinfo
; /* null unless created by drive_new() */
35 QTAILQ_ENTRY(BlockBackend
) link
; /* for block_backends */
36 QTAILQ_ENTRY(BlockBackend
) monitor_link
; /* for monitor_block_backends */
37 BlockBackendPublic
public;
39 void *dev
; /* attached device model, if any */
40 /* TODO change to DeviceState when all users are qdevified */
41 const BlockDevOps
*dev_ops
;
44 /* the block size for which the guest device expects atomicity */
47 /* If the BDS tree is removed, some of its options are stored here (which
48 * can be used to restore those options in the new BDS on insert) */
49 BlockBackendRootState root_state
;
51 bool enable_write_cache
;
53 /* I/O stats (display with "info blockstats"). */
56 BlockdevOnError on_read_error
, on_write_error
;
57 bool iostatus_enabled
;
58 BlockDeviceIoStatus iostatus
;
60 bool allow_write_beyond_eof
;
62 NotifierList remove_bs_notifiers
, insert_bs_notifiers
;
65 typedef struct BlockBackendAIOCB
{
72 static const AIOCBInfo block_backend_aiocb_info
= {
73 .get_aio_context
= blk_aiocb_get_aio_context
,
74 .aiocb_size
= sizeof(BlockBackendAIOCB
),
77 static void drive_info_del(DriveInfo
*dinfo
);
78 static BlockBackend
*bdrv_first_blk(BlockDriverState
*bs
);
80 /* All BlockBackends */
81 static QTAILQ_HEAD(, BlockBackend
) block_backends
=
82 QTAILQ_HEAD_INITIALIZER(block_backends
);
84 /* All BlockBackends referenced by the monitor and which are iterated through by
86 static QTAILQ_HEAD(, BlockBackend
) monitor_block_backends
=
87 QTAILQ_HEAD_INITIALIZER(monitor_block_backends
);
89 static void blk_root_inherit_options(int *child_flags
, QDict
*child_options
,
90 int parent_flags
, QDict
*parent_options
)
92 /* We're not supposed to call this function for root nodes */
95 static void blk_root_drained_begin(BdrvChild
*child
);
96 static void blk_root_drained_end(BdrvChild
*child
);
98 static void blk_root_change_media(BdrvChild
*child
, bool load
);
99 static void blk_root_resize(BdrvChild
*child
);
101 static const char *blk_root_get_name(BdrvChild
*child
)
103 return blk_name(child
->opaque
);
106 static const BdrvChildRole child_root
= {
107 .inherit_options
= blk_root_inherit_options
,
109 .change_media
= blk_root_change_media
,
110 .resize
= blk_root_resize
,
111 .get_name
= blk_root_get_name
,
113 .drained_begin
= blk_root_drained_begin
,
114 .drained_end
= blk_root_drained_end
,
118 * Create a new BlockBackend with a reference count of one.
119 * Store an error through @errp on failure, unless it's null.
120 * Return the new BlockBackend on success, null on failure.
122 BlockBackend
*blk_new(void)
126 blk
= g_new0(BlockBackend
, 1);
128 qemu_co_queue_init(&blk
->public.throttled_reqs
[0]);
129 qemu_co_queue_init(&blk
->public.throttled_reqs
[1]);
131 notifier_list_init(&blk
->remove_bs_notifiers
);
132 notifier_list_init(&blk
->insert_bs_notifiers
);
134 QTAILQ_INSERT_TAIL(&block_backends
, blk
, link
);
139 * Creates a new BlockBackend, opens a new BlockDriverState, and connects both.
141 * Just as with bdrv_open(), after having called this function the reference to
142 * @options belongs to the block layer (even on failure).
144 * TODO: Remove @filename and @flags; it should be possible to specify a whole
145 * BDS tree just by specifying the @options QDict (or @reference,
146 * alternatively). At the time of adding this function, this is not possible,
147 * though, so callers of this function have to be able to specify @filename and
150 BlockBackend
*blk_new_open(const char *filename
, const char *reference
,
151 QDict
*options
, int flags
, Error
**errp
)
154 BlockDriverState
*bs
;
157 bs
= bdrv_open(filename
, reference
, options
, flags
, errp
);
163 blk_set_enable_write_cache(blk
, true);
164 blk
->root
= bdrv_root_attach_child(bs
, "root", &child_root
, blk
);
169 static void blk_delete(BlockBackend
*blk
)
171 assert(!blk
->refcnt
);
177 assert(QLIST_EMPTY(&blk
->remove_bs_notifiers
.notifiers
));
178 assert(QLIST_EMPTY(&blk
->insert_bs_notifiers
.notifiers
));
179 QTAILQ_REMOVE(&block_backends
, blk
, link
);
180 drive_info_del(blk
->legacy_dinfo
);
181 block_acct_cleanup(&blk
->stats
);
185 static void drive_info_del(DriveInfo
*dinfo
)
190 qemu_opts_del(dinfo
->opts
);
191 g_free(dinfo
->serial
);
195 int blk_get_refcnt(BlockBackend
*blk
)
197 return blk
? blk
->refcnt
: 0;
201 * Increment @blk's reference count.
202 * @blk must not be null.
204 void blk_ref(BlockBackend
*blk
)
210 * Decrement @blk's reference count.
211 * If this drops it to zero, destroy @blk.
212 * For convenience, do nothing if @blk is null.
214 void blk_unref(BlockBackend
*blk
)
217 assert(blk
->refcnt
> 0);
218 if (!--blk
->refcnt
) {
225 * Behaves similarly to blk_next() but iterates over all BlockBackends, even the
226 * ones which are hidden (i.e. are not referenced by the monitor).
228 static BlockBackend
*blk_all_next(BlockBackend
*blk
)
230 return blk
? QTAILQ_NEXT(blk
, link
)
231 : QTAILQ_FIRST(&block_backends
);
234 void blk_remove_all_bs(void)
236 BlockBackend
*blk
= NULL
;
238 while ((blk
= blk_all_next(blk
)) != NULL
) {
239 AioContext
*ctx
= blk_get_aio_context(blk
);
241 aio_context_acquire(ctx
);
245 aio_context_release(ctx
);
250 * Return the monitor-owned BlockBackend after @blk.
251 * If @blk is null, return the first one.
252 * Else, return @blk's next sibling, which may be null.
254 * To iterate over all BlockBackends, do
255 * for (blk = blk_next(NULL); blk; blk = blk_next(blk)) {
259 BlockBackend
*blk_next(BlockBackend
*blk
)
261 return blk
? QTAILQ_NEXT(blk
, monitor_link
)
262 : QTAILQ_FIRST(&monitor_block_backends
);
265 /* Iterates over all top-level BlockDriverStates, i.e. BDSs that are owned by
266 * the monitor or attached to a BlockBackend */
267 BlockDriverState
*bdrv_next(BdrvNextIterator
*it
)
269 BlockDriverState
*bs
;
271 /* First, return all root nodes of BlockBackends. In order to avoid
272 * returning a BDS twice when multiple BBs refer to it, we only return it
273 * if the BB is the first one in the parent list of the BDS. */
274 if (it
->phase
== BDRV_NEXT_BACKEND_ROOTS
) {
276 it
->blk
= blk_all_next(it
->blk
);
277 bs
= it
->blk
? blk_bs(it
->blk
) : NULL
;
278 } while (it
->blk
&& (bs
== NULL
|| bdrv_first_blk(bs
) != it
->blk
));
283 it
->phase
= BDRV_NEXT_MONITOR_OWNED
;
286 /* Then return the monitor-owned BDSes without a BB attached. Ignore all
287 * BDSes that are attached to a BlockBackend here; they have been handled
288 * by the above block already */
290 it
->bs
= bdrv_next_monitor_owned(it
->bs
);
292 } while (bs
&& bdrv_has_blk(bs
));
297 BlockDriverState
*bdrv_first(BdrvNextIterator
*it
)
299 *it
= (BdrvNextIterator
) {
300 .phase
= BDRV_NEXT_BACKEND_ROOTS
,
303 return bdrv_next(it
);
307 * Add a BlockBackend into the list of backends referenced by the monitor, with
308 * the given @name acting as the handle for the monitor.
309 * Strictly for use by blockdev.c.
311 * @name must not be null or empty.
313 * Returns true on success and false on failure. In the latter case, an Error
314 * object is returned through @errp.
316 bool monitor_add_blk(BlockBackend
*blk
, const char *name
, Error
**errp
)
319 assert(name
&& name
[0]);
321 if (!id_wellformed(name
)) {
322 error_setg(errp
, "Invalid device name");
325 if (blk_by_name(name
)) {
326 error_setg(errp
, "Device with id '%s' already exists", name
);
329 if (bdrv_find_node(name
)) {
331 "Device name '%s' conflicts with an existing node name",
336 blk
->name
= g_strdup(name
);
337 QTAILQ_INSERT_TAIL(&monitor_block_backends
, blk
, monitor_link
);
342 * Remove a BlockBackend from the list of backends referenced by the monitor.
343 * Strictly for use by blockdev.c.
345 void monitor_remove_blk(BlockBackend
*blk
)
351 QTAILQ_REMOVE(&monitor_block_backends
, blk
, monitor_link
);
357 * Return @blk's name, a non-null string.
358 * Returns an empty string iff @blk is not referenced by the monitor.
360 const char *blk_name(BlockBackend
*blk
)
362 return blk
->name
?: "";
366 * Return the BlockBackend with name @name if it exists, else null.
367 * @name must not be null.
369 BlockBackend
*blk_by_name(const char *name
)
371 BlockBackend
*blk
= NULL
;
374 while ((blk
= blk_next(blk
)) != NULL
) {
375 if (!strcmp(name
, blk
->name
)) {
383 * Return the BlockDriverState attached to @blk if any, else null.
385 BlockDriverState
*blk_bs(BlockBackend
*blk
)
387 return blk
->root
? blk
->root
->bs
: NULL
;
390 static BlockBackend
*bdrv_first_blk(BlockDriverState
*bs
)
393 QLIST_FOREACH(child
, &bs
->parents
, next_parent
) {
394 if (child
->role
== &child_root
) {
395 return child
->opaque
;
403 * Returns true if @bs has an associated BlockBackend.
405 bool bdrv_has_blk(BlockDriverState
*bs
)
407 return bdrv_first_blk(bs
) != NULL
;
411 * Return @blk's DriveInfo if any, else null.
413 DriveInfo
*blk_legacy_dinfo(BlockBackend
*blk
)
415 return blk
->legacy_dinfo
;
419 * Set @blk's DriveInfo to @dinfo, and return it.
420 * @blk must not have a DriveInfo set already.
421 * No other BlockBackend may have the same DriveInfo set.
423 DriveInfo
*blk_set_legacy_dinfo(BlockBackend
*blk
, DriveInfo
*dinfo
)
425 assert(!blk
->legacy_dinfo
);
426 return blk
->legacy_dinfo
= dinfo
;
430 * Return the BlockBackend with DriveInfo @dinfo.
433 BlockBackend
*blk_by_legacy_dinfo(DriveInfo
*dinfo
)
435 BlockBackend
*blk
= NULL
;
437 while ((blk
= blk_next(blk
)) != NULL
) {
438 if (blk
->legacy_dinfo
== dinfo
) {
446 * Returns a pointer to the publicly accessible fields of @blk.
448 BlockBackendPublic
*blk_get_public(BlockBackend
*blk
)
454 * Returns a BlockBackend given the associated @public fields.
456 BlockBackend
*blk_by_public(BlockBackendPublic
*public)
458 return container_of(public, BlockBackend
, public);
462 * Disassociates the currently associated BlockDriverState from @blk.
464 void blk_remove_bs(BlockBackend
*blk
)
466 notifier_list_notify(&blk
->remove_bs_notifiers
, blk
);
467 if (blk
->public.throttle_state
) {
468 throttle_timers_detach_aio_context(&blk
->public.throttle_timers
);
471 blk_update_root_state(blk
);
473 bdrv_root_unref_child(blk
->root
);
478 * Associates a new BlockDriverState with @blk.
480 void blk_insert_bs(BlockBackend
*blk
, BlockDriverState
*bs
)
483 blk
->root
= bdrv_root_attach_child(bs
, "root", &child_root
, blk
);
485 notifier_list_notify(&blk
->insert_bs_notifiers
, blk
);
486 if (blk
->public.throttle_state
) {
487 throttle_timers_attach_aio_context(
488 &blk
->public.throttle_timers
, bdrv_get_aio_context(bs
));
493 * Attach device model @dev to @blk.
494 * Return 0 on success, -EBUSY when a device model is attached already.
496 int blk_attach_dev(BlockBackend
*blk
, void *dev
)
497 /* TODO change to DeviceState *dev when all users are qdevified */
504 blk_iostatus_reset(blk
);
509 * Attach device model @dev to @blk.
510 * @blk must not have a device model attached already.
511 * TODO qdevified devices don't use this, remove when devices are qdevified
513 void blk_attach_dev_nofail(BlockBackend
*blk
, void *dev
)
515 if (blk_attach_dev(blk
, dev
) < 0) {
521 * Detach device model @dev from @blk.
522 * @dev must be currently attached to @blk.
524 void blk_detach_dev(BlockBackend
*blk
, void *dev
)
525 /* TODO change to DeviceState *dev when all users are qdevified */
527 assert(blk
->dev
== dev
);
530 blk
->dev_opaque
= NULL
;
531 blk
->guest_block_size
= 512;
536 * Return the device model attached to @blk if any, else null.
538 void *blk_get_attached_dev(BlockBackend
*blk
)
539 /* TODO change to return DeviceState * when all users are qdevified */
545 * Set @blk's device model callbacks to @ops.
546 * @opaque is the opaque argument to pass to the callbacks.
547 * This is for use by device models.
549 void blk_set_dev_ops(BlockBackend
*blk
, const BlockDevOps
*ops
,
553 blk
->dev_opaque
= opaque
;
557 * Notify @blk's attached device model of media change.
558 * If @load is true, notify of media load.
559 * Else, notify of media eject.
560 * Also send DEVICE_TRAY_MOVED events as appropriate.
562 void blk_dev_change_media_cb(BlockBackend
*blk
, bool load
)
564 if (blk
->dev_ops
&& blk
->dev_ops
->change_media_cb
) {
565 bool tray_was_open
, tray_is_open
;
567 tray_was_open
= blk_dev_is_tray_open(blk
);
568 blk
->dev_ops
->change_media_cb(blk
->dev_opaque
, load
);
569 tray_is_open
= blk_dev_is_tray_open(blk
);
571 if (tray_was_open
!= tray_is_open
) {
572 qapi_event_send_device_tray_moved(blk_name(blk
), tray_is_open
,
578 static void blk_root_change_media(BdrvChild
*child
, bool load
)
580 blk_dev_change_media_cb(child
->opaque
, load
);
584 * Does @blk's attached device model have removable media?
585 * %true if no device model is attached.
587 bool blk_dev_has_removable_media(BlockBackend
*blk
)
589 return !blk
->dev
|| (blk
->dev_ops
&& blk
->dev_ops
->change_media_cb
);
593 * Does @blk's attached device model have a tray?
595 bool blk_dev_has_tray(BlockBackend
*blk
)
597 return blk
->dev_ops
&& blk
->dev_ops
->is_tray_open
;
601 * Notify @blk's attached device model of a media eject request.
602 * If @force is true, the medium is about to be yanked out forcefully.
604 void blk_dev_eject_request(BlockBackend
*blk
, bool force
)
606 if (blk
->dev_ops
&& blk
->dev_ops
->eject_request_cb
) {
607 blk
->dev_ops
->eject_request_cb(blk
->dev_opaque
, force
);
612 * Does @blk's attached device model have a tray, and is it open?
614 bool blk_dev_is_tray_open(BlockBackend
*blk
)
616 if (blk_dev_has_tray(blk
)) {
617 return blk
->dev_ops
->is_tray_open(blk
->dev_opaque
);
623 * Does @blk's attached device model have the medium locked?
624 * %false if the device model has no such lock.
626 bool blk_dev_is_medium_locked(BlockBackend
*blk
)
628 if (blk
->dev_ops
&& blk
->dev_ops
->is_medium_locked
) {
629 return blk
->dev_ops
->is_medium_locked(blk
->dev_opaque
);
635 * Notify @blk's attached device model of a backend size change.
637 static void blk_root_resize(BdrvChild
*child
)
639 BlockBackend
*blk
= child
->opaque
;
641 if (blk
->dev_ops
&& blk
->dev_ops
->resize_cb
) {
642 blk
->dev_ops
->resize_cb(blk
->dev_opaque
);
646 void blk_iostatus_enable(BlockBackend
*blk
)
648 blk
->iostatus_enabled
= true;
649 blk
->iostatus
= BLOCK_DEVICE_IO_STATUS_OK
;
652 /* The I/O status is only enabled if the drive explicitly
653 * enables it _and_ the VM is configured to stop on errors */
654 bool blk_iostatus_is_enabled(const BlockBackend
*blk
)
656 return (blk
->iostatus_enabled
&&
657 (blk
->on_write_error
== BLOCKDEV_ON_ERROR_ENOSPC
||
658 blk
->on_write_error
== BLOCKDEV_ON_ERROR_STOP
||
659 blk
->on_read_error
== BLOCKDEV_ON_ERROR_STOP
));
662 BlockDeviceIoStatus
blk_iostatus(const BlockBackend
*blk
)
664 return blk
->iostatus
;
667 void blk_iostatus_disable(BlockBackend
*blk
)
669 blk
->iostatus_enabled
= false;
672 void blk_iostatus_reset(BlockBackend
*blk
)
674 if (blk_iostatus_is_enabled(blk
)) {
675 BlockDriverState
*bs
= blk_bs(blk
);
676 blk
->iostatus
= BLOCK_DEVICE_IO_STATUS_OK
;
678 block_job_iostatus_reset(bs
->job
);
683 void blk_iostatus_set_err(BlockBackend
*blk
, int error
)
685 assert(blk_iostatus_is_enabled(blk
));
686 if (blk
->iostatus
== BLOCK_DEVICE_IO_STATUS_OK
) {
687 blk
->iostatus
= error
== ENOSPC
? BLOCK_DEVICE_IO_STATUS_NOSPACE
:
688 BLOCK_DEVICE_IO_STATUS_FAILED
;
692 void blk_set_allow_write_beyond_eof(BlockBackend
*blk
, bool allow
)
694 blk
->allow_write_beyond_eof
= allow
;
697 static int blk_check_byte_request(BlockBackend
*blk
, int64_t offset
,
702 if (size
> INT_MAX
) {
706 if (!blk_is_available(blk
)) {
714 if (!blk
->allow_write_beyond_eof
) {
715 len
= blk_getlength(blk
);
720 if (offset
> len
|| len
- offset
< size
) {
728 static int blk_check_request(BlockBackend
*blk
, int64_t sector_num
,
731 if (sector_num
< 0 || sector_num
> INT64_MAX
/ BDRV_SECTOR_SIZE
) {
735 if (nb_sectors
< 0 || nb_sectors
> INT_MAX
/ BDRV_SECTOR_SIZE
) {
739 return blk_check_byte_request(blk
, sector_num
* BDRV_SECTOR_SIZE
,
740 nb_sectors
* BDRV_SECTOR_SIZE
);
743 static int coroutine_fn
blk_co_preadv(BlockBackend
*blk
, int64_t offset
,
744 unsigned int bytes
, QEMUIOVector
*qiov
,
745 BdrvRequestFlags flags
)
747 int ret
= blk_check_byte_request(blk
, offset
, bytes
);
752 /* throttling disk I/O */
753 if (blk
->public.throttle_state
) {
754 throttle_group_co_io_limits_intercept(blk
, bytes
, false);
757 return bdrv_co_preadv(blk_bs(blk
), offset
, bytes
, qiov
, flags
);
760 static int coroutine_fn
blk_co_pwritev(BlockBackend
*blk
, int64_t offset
,
761 unsigned int bytes
, QEMUIOVector
*qiov
,
762 BdrvRequestFlags flags
)
766 ret
= blk_check_byte_request(blk
, offset
, bytes
);
771 /* throttling disk I/O */
772 if (blk
->public.throttle_state
) {
773 throttle_group_co_io_limits_intercept(blk
, bytes
, true);
776 if (!blk
->enable_write_cache
) {
777 flags
|= BDRV_REQ_FUA
;
780 return bdrv_co_pwritev(blk_bs(blk
), offset
, bytes
, qiov
, flags
);
783 typedef struct BlkRwCo
{
788 BdrvRequestFlags flags
;
791 static void blk_read_entry(void *opaque
)
793 BlkRwCo
*rwco
= opaque
;
795 rwco
->ret
= blk_co_preadv(rwco
->blk
, rwco
->offset
, rwco
->qiov
->size
,
796 rwco
->qiov
, rwco
->flags
);
799 static void blk_write_entry(void *opaque
)
801 BlkRwCo
*rwco
= opaque
;
803 rwco
->ret
= blk_co_pwritev(rwco
->blk
, rwco
->offset
, rwco
->qiov
->size
,
804 rwco
->qiov
, rwco
->flags
);
807 static int blk_prw(BlockBackend
*blk
, int64_t offset
, uint8_t *buf
,
808 int64_t bytes
, CoroutineEntry co_entry
,
809 BdrvRequestFlags flags
)
811 AioContext
*aio_context
;
817 iov
= (struct iovec
) {
821 qemu_iovec_init_external(&qiov
, &iov
, 1);
831 co
= qemu_coroutine_create(co_entry
);
832 qemu_coroutine_enter(co
, &rwco
);
834 aio_context
= blk_get_aio_context(blk
);
835 while (rwco
.ret
== NOT_DONE
) {
836 aio_poll(aio_context
, true);
842 int blk_pread_unthrottled(BlockBackend
*blk
, int64_t offset
, uint8_t *buf
,
847 ret
= blk_check_byte_request(blk
, offset
, count
);
852 blk_root_drained_begin(blk
->root
);
853 ret
= blk_pread(blk
, offset
, buf
, count
);
854 blk_root_drained_end(blk
->root
);
858 int blk_write_zeroes(BlockBackend
*blk
, int64_t offset
,
859 int count
, BdrvRequestFlags flags
)
861 return blk_prw(blk
, offset
, NULL
, count
, blk_write_entry
,
862 flags
| BDRV_REQ_ZERO_WRITE
);
865 static void error_callback_bh(void *opaque
)
867 struct BlockBackendAIOCB
*acb
= opaque
;
868 qemu_bh_delete(acb
->bh
);
869 acb
->common
.cb(acb
->common
.opaque
, acb
->ret
);
873 BlockAIOCB
*blk_abort_aio_request(BlockBackend
*blk
,
874 BlockCompletionFunc
*cb
,
875 void *opaque
, int ret
)
877 struct BlockBackendAIOCB
*acb
;
880 acb
= blk_aio_get(&block_backend_aiocb_info
, blk
, cb
, opaque
);
884 bh
= aio_bh_new(blk_get_aio_context(blk
), error_callback_bh
, acb
);
886 qemu_bh_schedule(bh
);
891 typedef struct BlkAioEmAIOCB
{
899 static const AIOCBInfo blk_aio_em_aiocb_info
= {
900 .aiocb_size
= sizeof(BlkAioEmAIOCB
),
903 static void blk_aio_complete(BlkAioEmAIOCB
*acb
)
906 assert(acb
->has_returned
);
907 qemu_bh_delete(acb
->bh
);
909 if (acb
->has_returned
) {
910 acb
->common
.cb(acb
->common
.opaque
, acb
->rwco
.ret
);
915 static void blk_aio_complete_bh(void *opaque
)
917 blk_aio_complete(opaque
);
920 static BlockAIOCB
*blk_aio_prwv(BlockBackend
*blk
, int64_t offset
, int bytes
,
921 QEMUIOVector
*qiov
, CoroutineEntry co_entry
,
922 BdrvRequestFlags flags
,
923 BlockCompletionFunc
*cb
, void *opaque
)
928 acb
= blk_aio_get(&blk_aio_em_aiocb_info
, blk
, cb
, opaque
);
929 acb
->rwco
= (BlkRwCo
) {
938 acb
->has_returned
= false;
940 co
= qemu_coroutine_create(co_entry
);
941 qemu_coroutine_enter(co
, acb
);
943 acb
->has_returned
= true;
944 if (acb
->rwco
.ret
!= NOT_DONE
) {
945 acb
->bh
= aio_bh_new(blk_get_aio_context(blk
), blk_aio_complete_bh
, acb
);
946 qemu_bh_schedule(acb
->bh
);
952 static void blk_aio_read_entry(void *opaque
)
954 BlkAioEmAIOCB
*acb
= opaque
;
955 BlkRwCo
*rwco
= &acb
->rwco
;
957 assert(rwco
->qiov
->size
== acb
->bytes
);
958 rwco
->ret
= blk_co_preadv(rwco
->blk
, rwco
->offset
, acb
->bytes
,
959 rwco
->qiov
, rwco
->flags
);
960 blk_aio_complete(acb
);
963 static void blk_aio_write_entry(void *opaque
)
965 BlkAioEmAIOCB
*acb
= opaque
;
966 BlkRwCo
*rwco
= &acb
->rwco
;
968 assert(!rwco
->qiov
|| rwco
->qiov
->size
== acb
->bytes
);
969 rwco
->ret
= blk_co_pwritev(rwco
->blk
, rwco
->offset
, acb
->bytes
,
970 rwco
->qiov
, rwco
->flags
);
971 blk_aio_complete(acb
);
974 BlockAIOCB
*blk_aio_write_zeroes(BlockBackend
*blk
, int64_t offset
,
975 int count
, BdrvRequestFlags flags
,
976 BlockCompletionFunc
*cb
, void *opaque
)
978 return blk_aio_prwv(blk
, offset
, count
, NULL
, blk_aio_write_entry
,
979 flags
| BDRV_REQ_ZERO_WRITE
, cb
, opaque
);
982 int blk_pread(BlockBackend
*blk
, int64_t offset
, void *buf
, int count
)
984 int ret
= blk_prw(blk
, offset
, buf
, count
, blk_read_entry
, 0);
991 int blk_pwrite(BlockBackend
*blk
, int64_t offset
, const void *buf
, int count
,
992 BdrvRequestFlags flags
)
994 int ret
= blk_prw(blk
, offset
, (void *) buf
, count
, blk_write_entry
,
1002 int64_t blk_getlength(BlockBackend
*blk
)
1004 if (!blk_is_available(blk
)) {
1008 return bdrv_getlength(blk_bs(blk
));
1011 void blk_get_geometry(BlockBackend
*blk
, uint64_t *nb_sectors_ptr
)
1014 *nb_sectors_ptr
= 0;
1016 bdrv_get_geometry(blk_bs(blk
), nb_sectors_ptr
);
1020 int64_t blk_nb_sectors(BlockBackend
*blk
)
1022 if (!blk_is_available(blk
)) {
1026 return bdrv_nb_sectors(blk_bs(blk
));
1029 BlockAIOCB
*blk_aio_preadv(BlockBackend
*blk
, int64_t offset
,
1030 QEMUIOVector
*qiov
, BdrvRequestFlags flags
,
1031 BlockCompletionFunc
*cb
, void *opaque
)
1033 return blk_aio_prwv(blk
, offset
, qiov
->size
, qiov
,
1034 blk_aio_read_entry
, flags
, cb
, opaque
);
1037 BlockAIOCB
*blk_aio_pwritev(BlockBackend
*blk
, int64_t offset
,
1038 QEMUIOVector
*qiov
, BdrvRequestFlags flags
,
1039 BlockCompletionFunc
*cb
, void *opaque
)
1041 return blk_aio_prwv(blk
, offset
, qiov
->size
, qiov
,
1042 blk_aio_write_entry
, flags
, cb
, opaque
);
1045 BlockAIOCB
*blk_aio_flush(BlockBackend
*blk
,
1046 BlockCompletionFunc
*cb
, void *opaque
)
1048 if (!blk_is_available(blk
)) {
1049 return blk_abort_aio_request(blk
, cb
, opaque
, -ENOMEDIUM
);
1052 return bdrv_aio_flush(blk_bs(blk
), cb
, opaque
);
1055 BlockAIOCB
*blk_aio_discard(BlockBackend
*blk
,
1056 int64_t sector_num
, int nb_sectors
,
1057 BlockCompletionFunc
*cb
, void *opaque
)
1059 int ret
= blk_check_request(blk
, sector_num
, nb_sectors
);
1061 return blk_abort_aio_request(blk
, cb
, opaque
, ret
);
1064 return bdrv_aio_discard(blk_bs(blk
), sector_num
, nb_sectors
, cb
, opaque
);
1067 void blk_aio_cancel(BlockAIOCB
*acb
)
1069 bdrv_aio_cancel(acb
);
1072 void blk_aio_cancel_async(BlockAIOCB
*acb
)
1074 bdrv_aio_cancel_async(acb
);
1077 int blk_ioctl(BlockBackend
*blk
, unsigned long int req
, void *buf
)
1079 if (!blk_is_available(blk
)) {
1083 return bdrv_ioctl(blk_bs(blk
), req
, buf
);
1086 BlockAIOCB
*blk_aio_ioctl(BlockBackend
*blk
, unsigned long int req
, void *buf
,
1087 BlockCompletionFunc
*cb
, void *opaque
)
1089 if (!blk_is_available(blk
)) {
1090 return blk_abort_aio_request(blk
, cb
, opaque
, -ENOMEDIUM
);
1093 return bdrv_aio_ioctl(blk_bs(blk
), req
, buf
, cb
, opaque
);
1096 int blk_co_discard(BlockBackend
*blk
, int64_t sector_num
, int nb_sectors
)
1098 int ret
= blk_check_request(blk
, sector_num
, nb_sectors
);
1103 return bdrv_co_discard(blk_bs(blk
), sector_num
, nb_sectors
);
1106 int blk_co_flush(BlockBackend
*blk
)
1108 if (!blk_is_available(blk
)) {
1112 return bdrv_co_flush(blk_bs(blk
));
1115 int blk_flush(BlockBackend
*blk
)
1117 if (!blk_is_available(blk
)) {
1121 return bdrv_flush(blk_bs(blk
));
1124 void blk_drain(BlockBackend
*blk
)
1127 bdrv_drain(blk_bs(blk
));
1131 void blk_drain_all(void)
1136 void blk_set_on_error(BlockBackend
*blk
, BlockdevOnError on_read_error
,
1137 BlockdevOnError on_write_error
)
1139 blk
->on_read_error
= on_read_error
;
1140 blk
->on_write_error
= on_write_error
;
1143 BlockdevOnError
blk_get_on_error(BlockBackend
*blk
, bool is_read
)
1145 return is_read
? blk
->on_read_error
: blk
->on_write_error
;
1148 BlockErrorAction
blk_get_error_action(BlockBackend
*blk
, bool is_read
,
1151 BlockdevOnError on_err
= blk_get_on_error(blk
, is_read
);
1154 case BLOCKDEV_ON_ERROR_ENOSPC
:
1155 return (error
== ENOSPC
) ?
1156 BLOCK_ERROR_ACTION_STOP
: BLOCK_ERROR_ACTION_REPORT
;
1157 case BLOCKDEV_ON_ERROR_STOP
:
1158 return BLOCK_ERROR_ACTION_STOP
;
1159 case BLOCKDEV_ON_ERROR_REPORT
:
1160 return BLOCK_ERROR_ACTION_REPORT
;
1161 case BLOCKDEV_ON_ERROR_IGNORE
:
1162 return BLOCK_ERROR_ACTION_IGNORE
;
1168 static void send_qmp_error_event(BlockBackend
*blk
,
1169 BlockErrorAction action
,
1170 bool is_read
, int error
)
1172 IoOperationType optype
;
1174 optype
= is_read
? IO_OPERATION_TYPE_READ
: IO_OPERATION_TYPE_WRITE
;
1175 qapi_event_send_block_io_error(blk_name(blk
), optype
, action
,
1176 blk_iostatus_is_enabled(blk
),
1177 error
== ENOSPC
, strerror(error
),
1181 /* This is done by device models because, while the block layer knows
1182 * about the error, it does not know whether an operation comes from
1183 * the device or the block layer (from a job, for example).
1185 void blk_error_action(BlockBackend
*blk
, BlockErrorAction action
,
1186 bool is_read
, int error
)
1190 if (action
== BLOCK_ERROR_ACTION_STOP
) {
1191 /* First set the iostatus, so that "info block" returns an iostatus
1192 * that matches the events raised so far (an additional error iostatus
1193 * is fine, but not a lost one).
1195 blk_iostatus_set_err(blk
, error
);
1197 /* Then raise the request to stop the VM and the event.
1198 * qemu_system_vmstop_request_prepare has two effects. First,
1199 * it ensures that the STOP event always comes after the
1200 * BLOCK_IO_ERROR event. Second, it ensures that even if management
1201 * can observe the STOP event and do a "cont" before the STOP
1202 * event is issued, the VM will not stop. In this case, vm_start()
1203 * also ensures that the STOP/RESUME pair of events is emitted.
1205 qemu_system_vmstop_request_prepare();
1206 send_qmp_error_event(blk
, action
, is_read
, error
);
1207 qemu_system_vmstop_request(RUN_STATE_IO_ERROR
);
1209 send_qmp_error_event(blk
, action
, is_read
, error
);
1213 int blk_is_read_only(BlockBackend
*blk
)
1215 BlockDriverState
*bs
= blk_bs(blk
);
1218 return bdrv_is_read_only(bs
);
1220 return blk
->root_state
.read_only
;
1224 int blk_is_sg(BlockBackend
*blk
)
1226 BlockDriverState
*bs
= blk_bs(blk
);
1232 return bdrv_is_sg(bs
);
1235 int blk_enable_write_cache(BlockBackend
*blk
)
1237 return blk
->enable_write_cache
;
1240 void blk_set_enable_write_cache(BlockBackend
*blk
, bool wce
)
1242 blk
->enable_write_cache
= wce
;
1245 void blk_invalidate_cache(BlockBackend
*blk
, Error
**errp
)
1247 BlockDriverState
*bs
= blk_bs(blk
);
1250 error_setg(errp
, "Device '%s' has no medium", blk
->name
);
1254 bdrv_invalidate_cache(bs
, errp
);
1257 bool blk_is_inserted(BlockBackend
*blk
)
1259 BlockDriverState
*bs
= blk_bs(blk
);
1261 return bs
&& bdrv_is_inserted(bs
);
1264 bool blk_is_available(BlockBackend
*blk
)
1266 return blk_is_inserted(blk
) && !blk_dev_is_tray_open(blk
);
1269 void blk_lock_medium(BlockBackend
*blk
, bool locked
)
1271 BlockDriverState
*bs
= blk_bs(blk
);
1274 bdrv_lock_medium(bs
, locked
);
1278 void blk_eject(BlockBackend
*blk
, bool eject_flag
)
1280 BlockDriverState
*bs
= blk_bs(blk
);
1283 bdrv_eject(bs
, eject_flag
);
1287 int blk_get_flags(BlockBackend
*blk
)
1289 BlockDriverState
*bs
= blk_bs(blk
);
1292 return bdrv_get_flags(bs
);
1294 return blk
->root_state
.open_flags
;
1298 int blk_get_max_transfer_length(BlockBackend
*blk
)
1300 BlockDriverState
*bs
= blk_bs(blk
);
1303 return bs
->bl
.max_transfer_length
;
1309 int blk_get_max_iov(BlockBackend
*blk
)
1311 return blk
->root
->bs
->bl
.max_iov
;
1314 void blk_set_guest_block_size(BlockBackend
*blk
, int align
)
1316 blk
->guest_block_size
= align
;
1319 void *blk_try_blockalign(BlockBackend
*blk
, size_t size
)
1321 return qemu_try_blockalign(blk
? blk_bs(blk
) : NULL
, size
);
1324 void *blk_blockalign(BlockBackend
*blk
, size_t size
)
1326 return qemu_blockalign(blk
? blk_bs(blk
) : NULL
, size
);
1329 bool blk_op_is_blocked(BlockBackend
*blk
, BlockOpType op
, Error
**errp
)
1331 BlockDriverState
*bs
= blk_bs(blk
);
1337 return bdrv_op_is_blocked(bs
, op
, errp
);
1340 void blk_op_unblock(BlockBackend
*blk
, BlockOpType op
, Error
*reason
)
1342 BlockDriverState
*bs
= blk_bs(blk
);
1345 bdrv_op_unblock(bs
, op
, reason
);
1349 void blk_op_block_all(BlockBackend
*blk
, Error
*reason
)
1351 BlockDriverState
*bs
= blk_bs(blk
);
1354 bdrv_op_block_all(bs
, reason
);
1358 void blk_op_unblock_all(BlockBackend
*blk
, Error
*reason
)
1360 BlockDriverState
*bs
= blk_bs(blk
);
1363 bdrv_op_unblock_all(bs
, reason
);
1367 AioContext
*blk_get_aio_context(BlockBackend
*blk
)
1369 BlockDriverState
*bs
= blk_bs(blk
);
1372 return bdrv_get_aio_context(bs
);
1374 return qemu_get_aio_context();
1378 static AioContext
*blk_aiocb_get_aio_context(BlockAIOCB
*acb
)
1380 BlockBackendAIOCB
*blk_acb
= DO_UPCAST(BlockBackendAIOCB
, common
, acb
);
1381 return blk_get_aio_context(blk_acb
->blk
);
1384 void blk_set_aio_context(BlockBackend
*blk
, AioContext
*new_context
)
1386 BlockDriverState
*bs
= blk_bs(blk
);
1389 if (blk
->public.throttle_state
) {
1390 throttle_timers_detach_aio_context(&blk
->public.throttle_timers
);
1392 bdrv_set_aio_context(bs
, new_context
);
1393 if (blk
->public.throttle_state
) {
1394 throttle_timers_attach_aio_context(&blk
->public.throttle_timers
,
1400 void blk_add_aio_context_notifier(BlockBackend
*blk
,
1401 void (*attached_aio_context
)(AioContext
*new_context
, void *opaque
),
1402 void (*detach_aio_context
)(void *opaque
), void *opaque
)
1404 BlockDriverState
*bs
= blk_bs(blk
);
1407 bdrv_add_aio_context_notifier(bs
, attached_aio_context
,
1408 detach_aio_context
, opaque
);
1412 void blk_remove_aio_context_notifier(BlockBackend
*blk
,
1413 void (*attached_aio_context
)(AioContext
*,
1415 void (*detach_aio_context
)(void *),
1418 BlockDriverState
*bs
= blk_bs(blk
);
1421 bdrv_remove_aio_context_notifier(bs
, attached_aio_context
,
1422 detach_aio_context
, opaque
);
1426 void blk_add_remove_bs_notifier(BlockBackend
*blk
, Notifier
*notify
)
1428 notifier_list_add(&blk
->remove_bs_notifiers
, notify
);
1431 void blk_add_insert_bs_notifier(BlockBackend
*blk
, Notifier
*notify
)
1433 notifier_list_add(&blk
->insert_bs_notifiers
, notify
);
1436 void blk_io_plug(BlockBackend
*blk
)
1438 BlockDriverState
*bs
= blk_bs(blk
);
1445 void blk_io_unplug(BlockBackend
*blk
)
1447 BlockDriverState
*bs
= blk_bs(blk
);
1454 BlockAcctStats
*blk_get_stats(BlockBackend
*blk
)
1459 void *blk_aio_get(const AIOCBInfo
*aiocb_info
, BlockBackend
*blk
,
1460 BlockCompletionFunc
*cb
, void *opaque
)
1462 return qemu_aio_get(aiocb_info
, blk_bs(blk
), cb
, opaque
);
1465 int coroutine_fn
blk_co_write_zeroes(BlockBackend
*blk
, int64_t offset
,
1466 int count
, BdrvRequestFlags flags
)
1468 return blk_co_pwritev(blk
, offset
, count
, NULL
,
1469 flags
| BDRV_REQ_ZERO_WRITE
);
1472 int blk_write_compressed(BlockBackend
*blk
, int64_t sector_num
,
1473 const uint8_t *buf
, int nb_sectors
)
1475 int ret
= blk_check_request(blk
, sector_num
, nb_sectors
);
1480 return bdrv_write_compressed(blk_bs(blk
), sector_num
, buf
, nb_sectors
);
1483 int blk_truncate(BlockBackend
*blk
, int64_t offset
)
1485 if (!blk_is_available(blk
)) {
1489 return bdrv_truncate(blk_bs(blk
), offset
);
1492 int blk_discard(BlockBackend
*blk
, int64_t sector_num
, int nb_sectors
)
1494 int ret
= blk_check_request(blk
, sector_num
, nb_sectors
);
1499 return bdrv_discard(blk_bs(blk
), sector_num
, nb_sectors
);
1502 int blk_save_vmstate(BlockBackend
*blk
, const uint8_t *buf
,
1503 int64_t pos
, int size
)
1507 if (!blk_is_available(blk
)) {
1511 ret
= bdrv_save_vmstate(blk_bs(blk
), buf
, pos
, size
);
1516 if (ret
== size
&& !blk
->enable_write_cache
) {
1517 ret
= bdrv_flush(blk_bs(blk
));
1520 return ret
< 0 ? ret
: size
;
1523 int blk_load_vmstate(BlockBackend
*blk
, uint8_t *buf
, int64_t pos
, int size
)
1525 if (!blk_is_available(blk
)) {
1529 return bdrv_load_vmstate(blk_bs(blk
), buf
, pos
, size
);
1532 int blk_probe_blocksizes(BlockBackend
*blk
, BlockSizes
*bsz
)
1534 if (!blk_is_available(blk
)) {
1538 return bdrv_probe_blocksizes(blk_bs(blk
), bsz
);
1541 int blk_probe_geometry(BlockBackend
*blk
, HDGeometry
*geo
)
1543 if (!blk_is_available(blk
)) {
1547 return bdrv_probe_geometry(blk_bs(blk
), geo
);
1551 * Updates the BlockBackendRootState object with data from the currently
1552 * attached BlockDriverState.
1554 void blk_update_root_state(BlockBackend
*blk
)
1558 blk
->root_state
.open_flags
= blk
->root
->bs
->open_flags
;
1559 blk
->root_state
.read_only
= blk
->root
->bs
->read_only
;
1560 blk
->root_state
.detect_zeroes
= blk
->root
->bs
->detect_zeroes
;
1564 * Applies the information in the root state to the given BlockDriverState. This
1565 * does not include the flags which have to be specified for bdrv_open(), use
1566 * blk_get_open_flags_from_root_state() to inquire them.
1568 void blk_apply_root_state(BlockBackend
*blk
, BlockDriverState
*bs
)
1570 bs
->detect_zeroes
= blk
->root_state
.detect_zeroes
;
1574 * Returns the flags to be used for bdrv_open() of a BlockDriverState which is
1575 * supposed to inherit the root state.
1577 int blk_get_open_flags_from_root_state(BlockBackend
*blk
)
1581 bs_flags
= blk
->root_state
.read_only
? 0 : BDRV_O_RDWR
;
1582 bs_flags
|= blk
->root_state
.open_flags
& ~BDRV_O_RDWR
;
1587 BlockBackendRootState
*blk_get_root_state(BlockBackend
*blk
)
1589 return &blk
->root_state
;
1592 int blk_commit_all(void)
1594 BlockBackend
*blk
= NULL
;
1596 while ((blk
= blk_all_next(blk
)) != NULL
) {
1597 AioContext
*aio_context
= blk_get_aio_context(blk
);
1599 aio_context_acquire(aio_context
);
1600 if (blk_is_inserted(blk
) && blk
->root
->bs
->backing
) {
1601 int ret
= bdrv_commit(blk
->root
->bs
);
1603 aio_context_release(aio_context
);
1607 aio_context_release(aio_context
);
1612 int blk_flush_all(void)
1614 BlockBackend
*blk
= NULL
;
1617 while ((blk
= blk_all_next(blk
)) != NULL
) {
1618 AioContext
*aio_context
= blk_get_aio_context(blk
);
1621 aio_context_acquire(aio_context
);
1622 if (blk_is_inserted(blk
)) {
1623 ret
= blk_flush(blk
);
1624 if (ret
< 0 && !result
) {
1628 aio_context_release(aio_context
);
1635 /* throttling disk I/O limits */
1636 void blk_set_io_limits(BlockBackend
*blk
, ThrottleConfig
*cfg
)
1638 throttle_group_config(blk
, cfg
);
1641 void blk_io_limits_disable(BlockBackend
*blk
)
1643 assert(blk
->public.throttle_state
);
1644 bdrv_drained_begin(blk_bs(blk
));
1645 throttle_group_unregister_blk(blk
);
1646 bdrv_drained_end(blk_bs(blk
));
1649 /* should be called before blk_set_io_limits if a limit is set */
1650 void blk_io_limits_enable(BlockBackend
*blk
, const char *group
)
1652 assert(!blk
->public.throttle_state
);
1653 throttle_group_register_blk(blk
, group
);
1656 void blk_io_limits_update_group(BlockBackend
*blk
, const char *group
)
1658 /* this BB is not part of any group */
1659 if (!blk
->public.throttle_state
) {
1663 /* this BB is a part of the same group than the one we want */
1664 if (!g_strcmp0(throttle_group_get_name(blk
), group
)) {
1668 /* need to change the group this bs belong to */
1669 blk_io_limits_disable(blk
);
1670 blk_io_limits_enable(blk
, group
);
1673 static void blk_root_drained_begin(BdrvChild
*child
)
1675 BlockBackend
*blk
= child
->opaque
;
1677 /* Note that blk->root may not be accessible here yet if we are just
1678 * attaching to a BlockDriverState that is drained. Use child instead. */
1680 if (blk
->public.io_limits_disabled
++ == 0) {
1681 throttle_group_restart_blk(blk
);
1685 static void blk_root_drained_end(BdrvChild
*child
)
1687 BlockBackend
*blk
= child
->opaque
;
1689 assert(blk
->public.io_limits_disabled
);
1690 --blk
->public.io_limits_disabled
;