Merge tag 'qemu-macppc-20230206' of https://github.com/mcayland/qemu into staging
[qemu.git] / block / block-backend.c
blobef512f7c4837015ddd6177b0680ef2412cc77c92
1 /*
2 * QEMU Block backends
4 * Copyright (C) 2014-2016 Red Hat, Inc.
6 * Authors:
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/coroutines.h"
18 #include "block/throttle-groups.h"
19 #include "hw/qdev-core.h"
20 #include "sysemu/blockdev.h"
21 #include "sysemu/runstate.h"
22 #include "sysemu/replay.h"
23 #include "qapi/error.h"
24 #include "qapi/qapi-events-block.h"
25 #include "qemu/id.h"
26 #include "qemu/main-loop.h"
27 #include "qemu/option.h"
28 #include "trace.h"
29 #include "migration/misc.h"
31 /* Number of coroutines to reserve per attached device model */
32 #define COROUTINE_POOL_RESERVATION 64
34 #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
36 static AioContext *blk_aiocb_get_aio_context(BlockAIOCB *acb);
38 typedef struct BlockBackendAioNotifier {
39 void (*attached_aio_context)(AioContext *new_context, void *opaque);
40 void (*detach_aio_context)(void *opaque);
41 void *opaque;
42 QLIST_ENTRY(BlockBackendAioNotifier) list;
43 } BlockBackendAioNotifier;
45 struct BlockBackend {
46 char *name;
47 int refcnt;
48 BdrvChild *root;
49 AioContext *ctx;
50 DriveInfo *legacy_dinfo; /* null unless created by drive_new() */
51 QTAILQ_ENTRY(BlockBackend) link; /* for block_backends */
52 QTAILQ_ENTRY(BlockBackend) monitor_link; /* for monitor_block_backends */
53 BlockBackendPublic public;
55 DeviceState *dev; /* attached device model, if any */
56 const BlockDevOps *dev_ops;
57 void *dev_opaque;
59 /* If the BDS tree is removed, some of its options are stored here (which
60 * can be used to restore those options in the new BDS on insert) */
61 BlockBackendRootState root_state;
63 bool enable_write_cache;
65 /* I/O stats (display with "info blockstats"). */
66 BlockAcctStats stats;
68 BlockdevOnError on_read_error, on_write_error;
69 bool iostatus_enabled;
70 BlockDeviceIoStatus iostatus;
72 uint64_t perm;
73 uint64_t shared_perm;
74 bool disable_perm;
76 bool allow_aio_context_change;
77 bool allow_write_beyond_eof;
79 /* Protected by BQL */
80 NotifierList remove_bs_notifiers, insert_bs_notifiers;
81 QLIST_HEAD(, BlockBackendAioNotifier) aio_notifiers;
83 int quiesce_counter;
84 CoQueue queued_requests;
85 bool disable_request_queuing;
87 VMChangeStateEntry *vmsh;
88 bool force_allow_inactivate;
90 /* Number of in-flight aio requests. BlockDriverState also counts
91 * in-flight requests but aio requests can exist even when blk->root is
92 * NULL, so we cannot rely on its counter for that case.
93 * Accessed with atomic ops.
95 unsigned int in_flight;
98 typedef struct BlockBackendAIOCB {
99 BlockAIOCB common;
100 BlockBackend *blk;
101 int ret;
102 } BlockBackendAIOCB;
104 static const AIOCBInfo block_backend_aiocb_info = {
105 .get_aio_context = blk_aiocb_get_aio_context,
106 .aiocb_size = sizeof(BlockBackendAIOCB),
109 static void drive_info_del(DriveInfo *dinfo);
110 static BlockBackend *bdrv_first_blk(BlockDriverState *bs);
112 /* All BlockBackends. Protected by BQL. */
113 static QTAILQ_HEAD(, BlockBackend) block_backends =
114 QTAILQ_HEAD_INITIALIZER(block_backends);
117 * All BlockBackends referenced by the monitor and which are iterated through by
118 * blk_next(). Protected by BQL.
120 static QTAILQ_HEAD(, BlockBackend) monitor_block_backends =
121 QTAILQ_HEAD_INITIALIZER(monitor_block_backends);
123 static void blk_root_inherit_options(BdrvChildRole role, bool parent_is_format,
124 int *child_flags, QDict *child_options,
125 int parent_flags, QDict *parent_options)
127 /* We're not supposed to call this function for root nodes */
128 abort();
130 static void blk_root_drained_begin(BdrvChild *child);
131 static bool blk_root_drained_poll(BdrvChild *child);
132 static void blk_root_drained_end(BdrvChild *child);
134 static void blk_root_change_media(BdrvChild *child, bool load);
135 static void blk_root_resize(BdrvChild *child);
137 static bool blk_root_change_aio_ctx(BdrvChild *child, AioContext *ctx,
138 GHashTable *visited, Transaction *tran,
139 Error **errp);
141 static char *blk_root_get_parent_desc(BdrvChild *child)
143 BlockBackend *blk = child->opaque;
144 g_autofree char *dev_id = NULL;
146 if (blk->name) {
147 return g_strdup_printf("block device '%s'", blk->name);
150 dev_id = blk_get_attached_dev_id(blk);
151 if (*dev_id) {
152 return g_strdup_printf("block device '%s'", dev_id);
153 } else {
154 /* TODO Callback into the BB owner for something more detailed */
155 return g_strdup("an unnamed block device");
159 static const char *blk_root_get_name(BdrvChild *child)
161 return blk_name(child->opaque);
164 static void blk_vm_state_changed(void *opaque, bool running, RunState state)
166 Error *local_err = NULL;
167 BlockBackend *blk = opaque;
169 if (state == RUN_STATE_INMIGRATE) {
170 return;
173 qemu_del_vm_change_state_handler(blk->vmsh);
174 blk->vmsh = NULL;
175 blk_set_perm(blk, blk->perm, blk->shared_perm, &local_err);
176 if (local_err) {
177 error_report_err(local_err);
182 * Notifies the user of the BlockBackend that migration has completed. qdev
183 * devices can tighten their permissions in response (specifically revoke
184 * shared write permissions that we needed for storage migration).
186 * If an error is returned, the VM cannot be allowed to be resumed.
188 static void blk_root_activate(BdrvChild *child, Error **errp)
190 BlockBackend *blk = child->opaque;
191 Error *local_err = NULL;
192 uint64_t saved_shared_perm;
194 if (!blk->disable_perm) {
195 return;
198 blk->disable_perm = false;
201 * blk->shared_perm contains the permissions we want to share once
202 * migration is really completely done. For now, we need to share
203 * all; but we also need to retain blk->shared_perm, which is
204 * overwritten by a successful blk_set_perm() call. Save it and
205 * restore it below.
207 saved_shared_perm = blk->shared_perm;
209 blk_set_perm(blk, blk->perm, BLK_PERM_ALL, &local_err);
210 if (local_err) {
211 error_propagate(errp, local_err);
212 blk->disable_perm = true;
213 return;
215 blk->shared_perm = saved_shared_perm;
217 if (runstate_check(RUN_STATE_INMIGRATE)) {
218 /* Activation can happen when migration process is still active, for
219 * example when nbd_server_add is called during non-shared storage
220 * migration. Defer the shared_perm update to migration completion. */
221 if (!blk->vmsh) {
222 blk->vmsh = qemu_add_vm_change_state_handler(blk_vm_state_changed,
223 blk);
225 return;
228 blk_set_perm(blk, blk->perm, blk->shared_perm, &local_err);
229 if (local_err) {
230 error_propagate(errp, local_err);
231 blk->disable_perm = true;
232 return;
236 void blk_set_force_allow_inactivate(BlockBackend *blk)
238 GLOBAL_STATE_CODE();
239 blk->force_allow_inactivate = true;
242 static bool blk_can_inactivate(BlockBackend *blk)
244 /* If it is a guest device, inactivate is ok. */
245 if (blk->dev || blk_name(blk)[0]) {
246 return true;
249 /* Inactivating means no more writes to the image can be done,
250 * even if those writes would be changes invisible to the
251 * guest. For block job BBs that satisfy this, we can just allow
252 * it. This is the case for mirror job source, which is required
253 * by libvirt non-shared block migration. */
254 if (!(blk->perm & (BLK_PERM_WRITE | BLK_PERM_WRITE_UNCHANGED))) {
255 return true;
258 return blk->force_allow_inactivate;
261 static int blk_root_inactivate(BdrvChild *child)
263 BlockBackend *blk = child->opaque;
265 if (blk->disable_perm) {
266 return 0;
269 if (!blk_can_inactivate(blk)) {
270 return -EPERM;
273 blk->disable_perm = true;
274 if (blk->root) {
275 bdrv_child_try_set_perm(blk->root, 0, BLK_PERM_ALL, &error_abort);
278 return 0;
281 static void blk_root_attach(BdrvChild *child)
283 BlockBackend *blk = child->opaque;
284 BlockBackendAioNotifier *notifier;
286 trace_blk_root_attach(child, blk, child->bs);
288 QLIST_FOREACH(notifier, &blk->aio_notifiers, list) {
289 bdrv_add_aio_context_notifier(child->bs,
290 notifier->attached_aio_context,
291 notifier->detach_aio_context,
292 notifier->opaque);
296 static void blk_root_detach(BdrvChild *child)
298 BlockBackend *blk = child->opaque;
299 BlockBackendAioNotifier *notifier;
301 trace_blk_root_detach(child, blk, child->bs);
303 QLIST_FOREACH(notifier, &blk->aio_notifiers, list) {
304 bdrv_remove_aio_context_notifier(child->bs,
305 notifier->attached_aio_context,
306 notifier->detach_aio_context,
307 notifier->opaque);
311 static AioContext *blk_root_get_parent_aio_context(BdrvChild *c)
313 BlockBackend *blk = c->opaque;
314 IO_CODE();
316 return blk_get_aio_context(blk);
319 static const BdrvChildClass child_root = {
320 .inherit_options = blk_root_inherit_options,
322 .change_media = blk_root_change_media,
323 .resize = blk_root_resize,
324 .get_name = blk_root_get_name,
325 .get_parent_desc = blk_root_get_parent_desc,
327 .drained_begin = blk_root_drained_begin,
328 .drained_poll = blk_root_drained_poll,
329 .drained_end = blk_root_drained_end,
331 .activate = blk_root_activate,
332 .inactivate = blk_root_inactivate,
334 .attach = blk_root_attach,
335 .detach = blk_root_detach,
337 .change_aio_ctx = blk_root_change_aio_ctx,
339 .get_parent_aio_context = blk_root_get_parent_aio_context,
343 * Create a new BlockBackend with a reference count of one.
345 * @perm is a bitmasks of BLK_PERM_* constants which describes the permissions
346 * to request for a block driver node that is attached to this BlockBackend.
347 * @shared_perm is a bitmask which describes which permissions may be granted
348 * to other users of the attached node.
349 * Both sets of permissions can be changed later using blk_set_perm().
351 * Return the new BlockBackend on success, null on failure.
353 BlockBackend *blk_new(AioContext *ctx, uint64_t perm, uint64_t shared_perm)
355 BlockBackend *blk;
357 GLOBAL_STATE_CODE();
359 blk = g_new0(BlockBackend, 1);
360 blk->refcnt = 1;
361 blk->ctx = ctx;
362 blk->perm = perm;
363 blk->shared_perm = shared_perm;
364 blk_set_enable_write_cache(blk, true);
366 blk->on_read_error = BLOCKDEV_ON_ERROR_REPORT;
367 blk->on_write_error = BLOCKDEV_ON_ERROR_ENOSPC;
369 block_acct_init(&blk->stats);
371 qemu_co_queue_init(&blk->queued_requests);
372 notifier_list_init(&blk->remove_bs_notifiers);
373 notifier_list_init(&blk->insert_bs_notifiers);
374 QLIST_INIT(&blk->aio_notifiers);
376 QTAILQ_INSERT_TAIL(&block_backends, blk, link);
377 return blk;
381 * Create a new BlockBackend connected to an existing BlockDriverState.
383 * @perm is a bitmasks of BLK_PERM_* constants which describes the
384 * permissions to request for @bs that is attached to this
385 * BlockBackend. @shared_perm is a bitmask which describes which
386 * permissions may be granted to other users of the attached node.
387 * Both sets of permissions can be changed later using blk_set_perm().
389 * Return the new BlockBackend on success, null on failure.
391 BlockBackend *blk_new_with_bs(BlockDriverState *bs, uint64_t perm,
392 uint64_t shared_perm, Error **errp)
394 BlockBackend *blk = blk_new(bdrv_get_aio_context(bs), perm, shared_perm);
396 GLOBAL_STATE_CODE();
398 if (blk_insert_bs(blk, bs, errp) < 0) {
399 blk_unref(blk);
400 return NULL;
402 return blk;
406 * Creates a new BlockBackend, opens a new BlockDriverState, and connects both.
407 * The new BlockBackend is in the main AioContext.
409 * Just as with bdrv_open(), after having called this function the reference to
410 * @options belongs to the block layer (even on failure).
412 * TODO: Remove @filename and @flags; it should be possible to specify a whole
413 * BDS tree just by specifying the @options QDict (or @reference,
414 * alternatively). At the time of adding this function, this is not possible,
415 * though, so callers of this function have to be able to specify @filename and
416 * @flags.
418 BlockBackend *blk_new_open(const char *filename, const char *reference,
419 QDict *options, int flags, Error **errp)
421 BlockBackend *blk;
422 BlockDriverState *bs;
423 uint64_t perm = 0;
424 uint64_t shared = BLK_PERM_ALL;
426 GLOBAL_STATE_CODE();
429 * blk_new_open() is mainly used in .bdrv_create implementations and the
430 * tools where sharing isn't a major concern because the BDS stays private
431 * and the file is generally not supposed to be used by a second process,
432 * so we just request permission according to the flags.
434 * The exceptions are xen_disk and blockdev_init(); in these cases, the
435 * caller of blk_new_open() doesn't make use of the permissions, but they
436 * shouldn't hurt either. We can still share everything here because the
437 * guest devices will add their own blockers if they can't share.
439 if ((flags & BDRV_O_NO_IO) == 0) {
440 perm |= BLK_PERM_CONSISTENT_READ;
441 if (flags & BDRV_O_RDWR) {
442 perm |= BLK_PERM_WRITE;
445 if (flags & BDRV_O_RESIZE) {
446 perm |= BLK_PERM_RESIZE;
448 if (flags & BDRV_O_NO_SHARE) {
449 shared = BLK_PERM_CONSISTENT_READ | BLK_PERM_WRITE_UNCHANGED;
452 blk = blk_new(qemu_get_aio_context(), perm, shared);
453 bs = bdrv_open(filename, reference, options, flags, errp);
454 if (!bs) {
455 blk_unref(blk);
456 return NULL;
459 blk->root = bdrv_root_attach_child(bs, "root", &child_root,
460 BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY,
461 perm, shared, blk, errp);
462 if (!blk->root) {
463 blk_unref(blk);
464 return NULL;
467 return blk;
470 static void blk_delete(BlockBackend *blk)
472 assert(!blk->refcnt);
473 assert(!blk->name);
474 assert(!blk->dev);
475 if (blk->public.throttle_group_member.throttle_state) {
476 blk_io_limits_disable(blk);
478 if (blk->root) {
479 blk_remove_bs(blk);
481 if (blk->vmsh) {
482 qemu_del_vm_change_state_handler(blk->vmsh);
483 blk->vmsh = NULL;
485 assert(QLIST_EMPTY(&blk->remove_bs_notifiers.notifiers));
486 assert(QLIST_EMPTY(&blk->insert_bs_notifiers.notifiers));
487 assert(QLIST_EMPTY(&blk->aio_notifiers));
488 QTAILQ_REMOVE(&block_backends, blk, link);
489 drive_info_del(blk->legacy_dinfo);
490 block_acct_cleanup(&blk->stats);
491 g_free(blk);
494 static void drive_info_del(DriveInfo *dinfo)
496 if (!dinfo) {
497 return;
499 qemu_opts_del(dinfo->opts);
500 g_free(dinfo);
503 int blk_get_refcnt(BlockBackend *blk)
505 GLOBAL_STATE_CODE();
506 return blk ? blk->refcnt : 0;
510 * Increment @blk's reference count.
511 * @blk must not be null.
513 void blk_ref(BlockBackend *blk)
515 assert(blk->refcnt > 0);
516 GLOBAL_STATE_CODE();
517 blk->refcnt++;
521 * Decrement @blk's reference count.
522 * If this drops it to zero, destroy @blk.
523 * For convenience, do nothing if @blk is null.
525 void blk_unref(BlockBackend *blk)
527 GLOBAL_STATE_CODE();
528 if (blk) {
529 assert(blk->refcnt > 0);
530 if (blk->refcnt > 1) {
531 blk->refcnt--;
532 } else {
533 blk_drain(blk);
534 /* blk_drain() cannot resurrect blk, nobody held a reference */
535 assert(blk->refcnt == 1);
536 blk->refcnt = 0;
537 blk_delete(blk);
543 * Behaves similarly to blk_next() but iterates over all BlockBackends, even the
544 * ones which are hidden (i.e. are not referenced by the monitor).
546 BlockBackend *blk_all_next(BlockBackend *blk)
548 GLOBAL_STATE_CODE();
549 return blk ? QTAILQ_NEXT(blk, link)
550 : QTAILQ_FIRST(&block_backends);
553 void blk_remove_all_bs(void)
555 BlockBackend *blk = NULL;
557 GLOBAL_STATE_CODE();
559 while ((blk = blk_all_next(blk)) != NULL) {
560 AioContext *ctx = blk_get_aio_context(blk);
562 aio_context_acquire(ctx);
563 if (blk->root) {
564 blk_remove_bs(blk);
566 aio_context_release(ctx);
571 * Return the monitor-owned BlockBackend after @blk.
572 * If @blk is null, return the first one.
573 * Else, return @blk's next sibling, which may be null.
575 * To iterate over all BlockBackends, do
576 * for (blk = blk_next(NULL); blk; blk = blk_next(blk)) {
577 * ...
580 BlockBackend *blk_next(BlockBackend *blk)
582 GLOBAL_STATE_CODE();
583 return blk ? QTAILQ_NEXT(blk, monitor_link)
584 : QTAILQ_FIRST(&monitor_block_backends);
587 /* Iterates over all top-level BlockDriverStates, i.e. BDSs that are owned by
588 * the monitor or attached to a BlockBackend */
589 BlockDriverState *bdrv_next(BdrvNextIterator *it)
591 BlockDriverState *bs, *old_bs;
593 /* Must be called from the main loop */
594 assert(qemu_get_current_aio_context() == qemu_get_aio_context());
596 /* First, return all root nodes of BlockBackends. In order to avoid
597 * returning a BDS twice when multiple BBs refer to it, we only return it
598 * if the BB is the first one in the parent list of the BDS. */
599 if (it->phase == BDRV_NEXT_BACKEND_ROOTS) {
600 BlockBackend *old_blk = it->blk;
602 old_bs = old_blk ? blk_bs(old_blk) : NULL;
604 do {
605 it->blk = blk_all_next(it->blk);
606 bs = it->blk ? blk_bs(it->blk) : NULL;
607 } while (it->blk && (bs == NULL || bdrv_first_blk(bs) != it->blk));
609 if (it->blk) {
610 blk_ref(it->blk);
612 blk_unref(old_blk);
614 if (bs) {
615 bdrv_ref(bs);
616 bdrv_unref(old_bs);
617 return bs;
619 it->phase = BDRV_NEXT_MONITOR_OWNED;
620 } else {
621 old_bs = it->bs;
624 /* Then return the monitor-owned BDSes without a BB attached. Ignore all
625 * BDSes that are attached to a BlockBackend here; they have been handled
626 * by the above block already */
627 do {
628 it->bs = bdrv_next_monitor_owned(it->bs);
629 bs = it->bs;
630 } while (bs && bdrv_has_blk(bs));
632 if (bs) {
633 bdrv_ref(bs);
635 bdrv_unref(old_bs);
637 return bs;
640 static void bdrv_next_reset(BdrvNextIterator *it)
642 *it = (BdrvNextIterator) {
643 .phase = BDRV_NEXT_BACKEND_ROOTS,
647 BlockDriverState *bdrv_first(BdrvNextIterator *it)
649 GLOBAL_STATE_CODE();
650 bdrv_next_reset(it);
651 return bdrv_next(it);
654 /* Must be called when aborting a bdrv_next() iteration before
655 * bdrv_next() returns NULL */
656 void bdrv_next_cleanup(BdrvNextIterator *it)
658 /* Must be called from the main loop */
659 assert(qemu_get_current_aio_context() == qemu_get_aio_context());
661 if (it->phase == BDRV_NEXT_BACKEND_ROOTS) {
662 if (it->blk) {
663 bdrv_unref(blk_bs(it->blk));
664 blk_unref(it->blk);
666 } else {
667 bdrv_unref(it->bs);
670 bdrv_next_reset(it);
674 * Add a BlockBackend into the list of backends referenced by the monitor, with
675 * the given @name acting as the handle for the monitor.
676 * Strictly for use by blockdev.c.
678 * @name must not be null or empty.
680 * Returns true on success and false on failure. In the latter case, an Error
681 * object is returned through @errp.
683 bool monitor_add_blk(BlockBackend *blk, const char *name, Error **errp)
685 assert(!blk->name);
686 assert(name && name[0]);
687 GLOBAL_STATE_CODE();
689 if (!id_wellformed(name)) {
690 error_setg(errp, "Invalid device name");
691 return false;
693 if (blk_by_name(name)) {
694 error_setg(errp, "Device with id '%s' already exists", name);
695 return false;
697 if (bdrv_find_node(name)) {
698 error_setg(errp,
699 "Device name '%s' conflicts with an existing node name",
700 name);
701 return false;
704 blk->name = g_strdup(name);
705 QTAILQ_INSERT_TAIL(&monitor_block_backends, blk, monitor_link);
706 return true;
710 * Remove a BlockBackend from the list of backends referenced by the monitor.
711 * Strictly for use by blockdev.c.
713 void monitor_remove_blk(BlockBackend *blk)
715 GLOBAL_STATE_CODE();
717 if (!blk->name) {
718 return;
721 QTAILQ_REMOVE(&monitor_block_backends, blk, monitor_link);
722 g_free(blk->name);
723 blk->name = NULL;
727 * Return @blk's name, a non-null string.
728 * Returns an empty string iff @blk is not referenced by the monitor.
730 const char *blk_name(const BlockBackend *blk)
732 IO_CODE();
733 return blk->name ?: "";
737 * Return the BlockBackend with name @name if it exists, else null.
738 * @name must not be null.
740 BlockBackend *blk_by_name(const char *name)
742 BlockBackend *blk = NULL;
744 GLOBAL_STATE_CODE();
745 assert(name);
746 while ((blk = blk_next(blk)) != NULL) {
747 if (!strcmp(name, blk->name)) {
748 return blk;
751 return NULL;
755 * Return the BlockDriverState attached to @blk if any, else null.
757 BlockDriverState *blk_bs(BlockBackend *blk)
759 IO_CODE();
760 return blk->root ? blk->root->bs : NULL;
763 static BlockBackend *bdrv_first_blk(BlockDriverState *bs)
765 BdrvChild *child;
767 GLOBAL_STATE_CODE();
769 QLIST_FOREACH(child, &bs->parents, next_parent) {
770 if (child->klass == &child_root) {
771 return child->opaque;
775 return NULL;
779 * Returns true if @bs has an associated BlockBackend.
781 bool bdrv_has_blk(BlockDriverState *bs)
783 GLOBAL_STATE_CODE();
784 return bdrv_first_blk(bs) != NULL;
788 * Returns true if @bs has only BlockBackends as parents.
790 bool bdrv_is_root_node(BlockDriverState *bs)
792 BdrvChild *c;
794 GLOBAL_STATE_CODE();
795 QLIST_FOREACH(c, &bs->parents, next_parent) {
796 if (c->klass != &child_root) {
797 return false;
801 return true;
805 * Return @blk's DriveInfo if any, else null.
807 DriveInfo *blk_legacy_dinfo(BlockBackend *blk)
809 GLOBAL_STATE_CODE();
810 return blk->legacy_dinfo;
814 * Set @blk's DriveInfo to @dinfo, and return it.
815 * @blk must not have a DriveInfo set already.
816 * No other BlockBackend may have the same DriveInfo set.
818 DriveInfo *blk_set_legacy_dinfo(BlockBackend *blk, DriveInfo *dinfo)
820 assert(!blk->legacy_dinfo);
821 GLOBAL_STATE_CODE();
822 return blk->legacy_dinfo = dinfo;
826 * Return the BlockBackend with DriveInfo @dinfo.
827 * It must exist.
829 BlockBackend *blk_by_legacy_dinfo(DriveInfo *dinfo)
831 BlockBackend *blk = NULL;
832 GLOBAL_STATE_CODE();
834 while ((blk = blk_next(blk)) != NULL) {
835 if (blk->legacy_dinfo == dinfo) {
836 return blk;
839 abort();
843 * Returns a pointer to the publicly accessible fields of @blk.
845 BlockBackendPublic *blk_get_public(BlockBackend *blk)
847 GLOBAL_STATE_CODE();
848 return &blk->public;
852 * Returns a BlockBackend given the associated @public fields.
854 BlockBackend *blk_by_public(BlockBackendPublic *public)
856 GLOBAL_STATE_CODE();
857 return container_of(public, BlockBackend, public);
861 * Disassociates the currently associated BlockDriverState from @blk.
863 void blk_remove_bs(BlockBackend *blk)
865 ThrottleGroupMember *tgm = &blk->public.throttle_group_member;
866 BdrvChild *root;
868 GLOBAL_STATE_CODE();
870 notifier_list_notify(&blk->remove_bs_notifiers, blk);
871 if (tgm->throttle_state) {
872 BlockDriverState *bs = blk_bs(blk);
875 * Take a ref in case blk_bs() changes across bdrv_drained_begin(), for
876 * example, if a temporary filter node is removed by a blockjob.
878 bdrv_ref(bs);
879 bdrv_drained_begin(bs);
880 throttle_group_detach_aio_context(tgm);
881 throttle_group_attach_aio_context(tgm, qemu_get_aio_context());
882 bdrv_drained_end(bs);
883 bdrv_unref(bs);
886 blk_update_root_state(blk);
888 /* bdrv_root_unref_child() will cause blk->root to become stale and may
889 * switch to a completion coroutine later on. Let's drain all I/O here
890 * to avoid that and a potential QEMU crash.
892 blk_drain(blk);
893 root = blk->root;
894 blk->root = NULL;
895 bdrv_root_unref_child(root);
899 * Associates a new BlockDriverState with @blk.
901 int blk_insert_bs(BlockBackend *blk, BlockDriverState *bs, Error **errp)
903 ThrottleGroupMember *tgm = &blk->public.throttle_group_member;
904 GLOBAL_STATE_CODE();
905 bdrv_ref(bs);
906 blk->root = bdrv_root_attach_child(bs, "root", &child_root,
907 BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY,
908 blk->perm, blk->shared_perm,
909 blk, errp);
910 if (blk->root == NULL) {
911 return -EPERM;
914 notifier_list_notify(&blk->insert_bs_notifiers, blk);
915 if (tgm->throttle_state) {
916 throttle_group_detach_aio_context(tgm);
917 throttle_group_attach_aio_context(tgm, bdrv_get_aio_context(bs));
920 return 0;
924 * Change BlockDriverState associated with @blk.
926 int blk_replace_bs(BlockBackend *blk, BlockDriverState *new_bs, Error **errp)
928 GLOBAL_STATE_CODE();
929 return bdrv_replace_child_bs(blk->root, new_bs, errp);
933 * Sets the permission bitmasks that the user of the BlockBackend needs.
935 int blk_set_perm(BlockBackend *blk, uint64_t perm, uint64_t shared_perm,
936 Error **errp)
938 int ret;
939 GLOBAL_STATE_CODE();
941 if (blk->root && !blk->disable_perm) {
942 ret = bdrv_child_try_set_perm(blk->root, perm, shared_perm, errp);
943 if (ret < 0) {
944 return ret;
948 blk->perm = perm;
949 blk->shared_perm = shared_perm;
951 return 0;
954 void blk_get_perm(BlockBackend *blk, uint64_t *perm, uint64_t *shared_perm)
956 GLOBAL_STATE_CODE();
957 *perm = blk->perm;
958 *shared_perm = blk->shared_perm;
962 * Attach device model @dev to @blk.
963 * Return 0 on success, -EBUSY when a device model is attached already.
965 int blk_attach_dev(BlockBackend *blk, DeviceState *dev)
967 GLOBAL_STATE_CODE();
968 if (blk->dev) {
969 return -EBUSY;
972 /* While migration is still incoming, we don't need to apply the
973 * permissions of guest device BlockBackends. We might still have a block
974 * job or NBD server writing to the image for storage migration. */
975 if (runstate_check(RUN_STATE_INMIGRATE)) {
976 blk->disable_perm = true;
979 blk_ref(blk);
980 blk->dev = dev;
981 blk_iostatus_reset(blk);
983 return 0;
987 * Detach device model @dev from @blk.
988 * @dev must be currently attached to @blk.
990 void blk_detach_dev(BlockBackend *blk, DeviceState *dev)
992 assert(blk->dev == dev);
993 GLOBAL_STATE_CODE();
994 blk->dev = NULL;
995 blk->dev_ops = NULL;
996 blk->dev_opaque = NULL;
997 blk_set_perm(blk, 0, BLK_PERM_ALL, &error_abort);
998 blk_unref(blk);
1002 * Return the device model attached to @blk if any, else null.
1004 DeviceState *blk_get_attached_dev(BlockBackend *blk)
1006 GLOBAL_STATE_CODE();
1007 return blk->dev;
1010 /* Return the qdev ID, or if no ID is assigned the QOM path, of the block
1011 * device attached to the BlockBackend. */
1012 char *blk_get_attached_dev_id(BlockBackend *blk)
1014 DeviceState *dev = blk->dev;
1015 IO_CODE();
1017 if (!dev) {
1018 return g_strdup("");
1019 } else if (dev->id) {
1020 return g_strdup(dev->id);
1023 return object_get_canonical_path(OBJECT(dev)) ?: g_strdup("");
1027 * Return the BlockBackend which has the device model @dev attached if it
1028 * exists, else null.
1030 * @dev must not be null.
1032 BlockBackend *blk_by_dev(void *dev)
1034 BlockBackend *blk = NULL;
1036 GLOBAL_STATE_CODE();
1038 assert(dev != NULL);
1039 while ((blk = blk_all_next(blk)) != NULL) {
1040 if (blk->dev == dev) {
1041 return blk;
1044 return NULL;
1048 * Set @blk's device model callbacks to @ops.
1049 * @opaque is the opaque argument to pass to the callbacks.
1050 * This is for use by device models.
1052 void blk_set_dev_ops(BlockBackend *blk, const BlockDevOps *ops,
1053 void *opaque)
1055 GLOBAL_STATE_CODE();
1056 blk->dev_ops = ops;
1057 blk->dev_opaque = opaque;
1059 /* Are we currently quiesced? Should we enforce this right now? */
1060 if (blk->quiesce_counter && ops && ops->drained_begin) {
1061 ops->drained_begin(opaque);
1066 * Notify @blk's attached device model of media change.
1068 * If @load is true, notify of media load. This action can fail, meaning that
1069 * the medium cannot be loaded. @errp is set then.
1071 * If @load is false, notify of media eject. This can never fail.
1073 * Also send DEVICE_TRAY_MOVED events as appropriate.
1075 void blk_dev_change_media_cb(BlockBackend *blk, bool load, Error **errp)
1077 GLOBAL_STATE_CODE();
1078 if (blk->dev_ops && blk->dev_ops->change_media_cb) {
1079 bool tray_was_open, tray_is_open;
1080 Error *local_err = NULL;
1082 tray_was_open = blk_dev_is_tray_open(blk);
1083 blk->dev_ops->change_media_cb(blk->dev_opaque, load, &local_err);
1084 if (local_err) {
1085 assert(load == true);
1086 error_propagate(errp, local_err);
1087 return;
1089 tray_is_open = blk_dev_is_tray_open(blk);
1091 if (tray_was_open != tray_is_open) {
1092 char *id = blk_get_attached_dev_id(blk);
1093 qapi_event_send_device_tray_moved(blk_name(blk), id, tray_is_open);
1094 g_free(id);
1099 static void blk_root_change_media(BdrvChild *child, bool load)
1101 blk_dev_change_media_cb(child->opaque, load, NULL);
1105 * Does @blk's attached device model have removable media?
1106 * %true if no device model is attached.
1108 bool blk_dev_has_removable_media(BlockBackend *blk)
1110 GLOBAL_STATE_CODE();
1111 return !blk->dev || (blk->dev_ops && blk->dev_ops->change_media_cb);
1115 * Does @blk's attached device model have a tray?
1117 bool blk_dev_has_tray(BlockBackend *blk)
1119 IO_CODE();
1120 return blk->dev_ops && blk->dev_ops->is_tray_open;
1124 * Notify @blk's attached device model of a media eject request.
1125 * If @force is true, the medium is about to be yanked out forcefully.
1127 void blk_dev_eject_request(BlockBackend *blk, bool force)
1129 GLOBAL_STATE_CODE();
1130 if (blk->dev_ops && blk->dev_ops->eject_request_cb) {
1131 blk->dev_ops->eject_request_cb(blk->dev_opaque, force);
1136 * Does @blk's attached device model have a tray, and is it open?
1138 bool blk_dev_is_tray_open(BlockBackend *blk)
1140 IO_CODE();
1141 if (blk_dev_has_tray(blk)) {
1142 return blk->dev_ops->is_tray_open(blk->dev_opaque);
1144 return false;
1148 * Does @blk's attached device model have the medium locked?
1149 * %false if the device model has no such lock.
1151 bool blk_dev_is_medium_locked(BlockBackend *blk)
1153 GLOBAL_STATE_CODE();
1154 if (blk->dev_ops && blk->dev_ops->is_medium_locked) {
1155 return blk->dev_ops->is_medium_locked(blk->dev_opaque);
1157 return false;
1161 * Notify @blk's attached device model of a backend size change.
1163 static void blk_root_resize(BdrvChild *child)
1165 BlockBackend *blk = child->opaque;
1167 if (blk->dev_ops && blk->dev_ops->resize_cb) {
1168 blk->dev_ops->resize_cb(blk->dev_opaque);
1172 void blk_iostatus_enable(BlockBackend *blk)
1174 GLOBAL_STATE_CODE();
1175 blk->iostatus_enabled = true;
1176 blk->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
1179 /* The I/O status is only enabled if the drive explicitly
1180 * enables it _and_ the VM is configured to stop on errors */
1181 bool blk_iostatus_is_enabled(const BlockBackend *blk)
1183 IO_CODE();
1184 return (blk->iostatus_enabled &&
1185 (blk->on_write_error == BLOCKDEV_ON_ERROR_ENOSPC ||
1186 blk->on_write_error == BLOCKDEV_ON_ERROR_STOP ||
1187 blk->on_read_error == BLOCKDEV_ON_ERROR_STOP));
1190 BlockDeviceIoStatus blk_iostatus(const BlockBackend *blk)
1192 GLOBAL_STATE_CODE();
1193 return blk->iostatus;
1196 void blk_iostatus_disable(BlockBackend *blk)
1198 GLOBAL_STATE_CODE();
1199 blk->iostatus_enabled = false;
1202 void blk_iostatus_reset(BlockBackend *blk)
1204 GLOBAL_STATE_CODE();
1205 if (blk_iostatus_is_enabled(blk)) {
1206 blk->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
1210 void blk_iostatus_set_err(BlockBackend *blk, int error)
1212 IO_CODE();
1213 assert(blk_iostatus_is_enabled(blk));
1214 if (blk->iostatus == BLOCK_DEVICE_IO_STATUS_OK) {
1215 blk->iostatus = error == ENOSPC ? BLOCK_DEVICE_IO_STATUS_NOSPACE :
1216 BLOCK_DEVICE_IO_STATUS_FAILED;
1220 void blk_set_allow_write_beyond_eof(BlockBackend *blk, bool allow)
1222 IO_CODE();
1223 blk->allow_write_beyond_eof = allow;
1226 void blk_set_allow_aio_context_change(BlockBackend *blk, bool allow)
1228 IO_CODE();
1229 blk->allow_aio_context_change = allow;
1232 void blk_set_disable_request_queuing(BlockBackend *blk, bool disable)
1234 IO_CODE();
1235 blk->disable_request_queuing = disable;
1238 static coroutine_fn int blk_check_byte_request(BlockBackend *blk,
1239 int64_t offset, int64_t bytes)
1241 int64_t len;
1243 if (bytes < 0) {
1244 return -EIO;
1247 if (!blk_is_available(blk)) {
1248 return -ENOMEDIUM;
1251 if (offset < 0) {
1252 return -EIO;
1255 if (!blk->allow_write_beyond_eof) {
1256 len = bdrv_co_getlength(blk_bs(blk));
1257 if (len < 0) {
1258 return len;
1261 if (offset > len || len - offset < bytes) {
1262 return -EIO;
1266 return 0;
1269 /* To be called between exactly one pair of blk_inc/dec_in_flight() */
1270 static void coroutine_fn blk_wait_while_drained(BlockBackend *blk)
1272 assert(blk->in_flight > 0);
1274 if (blk->quiesce_counter && !blk->disable_request_queuing) {
1275 blk_dec_in_flight(blk);
1276 qemu_co_queue_wait(&blk->queued_requests, NULL);
1277 blk_inc_in_flight(blk);
1281 /* To be called between exactly one pair of blk_inc/dec_in_flight() */
1282 static int coroutine_fn
1283 blk_co_do_preadv_part(BlockBackend *blk, int64_t offset, int64_t bytes,
1284 QEMUIOVector *qiov, size_t qiov_offset,
1285 BdrvRequestFlags flags)
1287 int ret;
1288 BlockDriverState *bs;
1289 IO_CODE();
1291 blk_wait_while_drained(blk);
1293 /* Call blk_bs() only after waiting, the graph may have changed */
1294 bs = blk_bs(blk);
1295 trace_blk_co_preadv(blk, bs, offset, bytes, flags);
1297 ret = blk_check_byte_request(blk, offset, bytes);
1298 if (ret < 0) {
1299 return ret;
1302 bdrv_inc_in_flight(bs);
1304 /* throttling disk I/O */
1305 if (blk->public.throttle_group_member.throttle_state) {
1306 throttle_group_co_io_limits_intercept(&blk->public.throttle_group_member,
1307 bytes, false);
1310 ret = bdrv_co_preadv_part(blk->root, offset, bytes, qiov, qiov_offset,
1311 flags);
1312 bdrv_dec_in_flight(bs);
1313 return ret;
1316 int coroutine_fn blk_co_pread(BlockBackend *blk, int64_t offset, int64_t bytes,
1317 void *buf, BdrvRequestFlags flags)
1319 QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
1320 IO_OR_GS_CODE();
1322 assert(bytes <= SIZE_MAX);
1324 return blk_co_preadv(blk, offset, bytes, &qiov, flags);
1327 int coroutine_fn blk_co_preadv(BlockBackend *blk, int64_t offset,
1328 int64_t bytes, QEMUIOVector *qiov,
1329 BdrvRequestFlags flags)
1331 int ret;
1332 IO_OR_GS_CODE();
1334 blk_inc_in_flight(blk);
1335 ret = blk_co_do_preadv_part(blk, offset, bytes, qiov, 0, flags);
1336 blk_dec_in_flight(blk);
1338 return ret;
1341 int coroutine_fn blk_co_preadv_part(BlockBackend *blk, int64_t offset,
1342 int64_t bytes, QEMUIOVector *qiov,
1343 size_t qiov_offset, BdrvRequestFlags flags)
1345 int ret;
1346 IO_OR_GS_CODE();
1348 blk_inc_in_flight(blk);
1349 ret = blk_co_do_preadv_part(blk, offset, bytes, qiov, qiov_offset, flags);
1350 blk_dec_in_flight(blk);
1352 return ret;
1355 /* To be called between exactly one pair of blk_inc/dec_in_flight() */
1356 static int coroutine_fn
1357 blk_co_do_pwritev_part(BlockBackend *blk, int64_t offset, int64_t bytes,
1358 QEMUIOVector *qiov, size_t qiov_offset,
1359 BdrvRequestFlags flags)
1361 int ret;
1362 BlockDriverState *bs;
1363 IO_CODE();
1365 blk_wait_while_drained(blk);
1367 /* Call blk_bs() only after waiting, the graph may have changed */
1368 bs = blk_bs(blk);
1369 trace_blk_co_pwritev(blk, bs, offset, bytes, flags);
1371 ret = blk_check_byte_request(blk, offset, bytes);
1372 if (ret < 0) {
1373 return ret;
1376 bdrv_inc_in_flight(bs);
1377 /* throttling disk I/O */
1378 if (blk->public.throttle_group_member.throttle_state) {
1379 throttle_group_co_io_limits_intercept(&blk->public.throttle_group_member,
1380 bytes, true);
1383 if (!blk->enable_write_cache) {
1384 flags |= BDRV_REQ_FUA;
1387 ret = bdrv_co_pwritev_part(blk->root, offset, bytes, qiov, qiov_offset,
1388 flags);
1389 bdrv_dec_in_flight(bs);
1390 return ret;
1393 int coroutine_fn blk_co_pwritev_part(BlockBackend *blk, int64_t offset,
1394 int64_t bytes,
1395 QEMUIOVector *qiov, size_t qiov_offset,
1396 BdrvRequestFlags flags)
1398 int ret;
1399 IO_OR_GS_CODE();
1401 blk_inc_in_flight(blk);
1402 ret = blk_co_do_pwritev_part(blk, offset, bytes, qiov, qiov_offset, flags);
1403 blk_dec_in_flight(blk);
1405 return ret;
1408 int coroutine_fn blk_co_pwrite(BlockBackend *blk, int64_t offset, int64_t bytes,
1409 const void *buf, BdrvRequestFlags flags)
1411 QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
1412 IO_OR_GS_CODE();
1414 assert(bytes <= SIZE_MAX);
1416 return blk_co_pwritev(blk, offset, bytes, &qiov, flags);
1419 int coroutine_fn blk_co_pwritev(BlockBackend *blk, int64_t offset,
1420 int64_t bytes, QEMUIOVector *qiov,
1421 BdrvRequestFlags flags)
1423 IO_OR_GS_CODE();
1424 return blk_co_pwritev_part(blk, offset, bytes, qiov, 0, flags);
1427 int coroutine_fn blk_co_block_status_above(BlockBackend *blk,
1428 BlockDriverState *base,
1429 int64_t offset, int64_t bytes,
1430 int64_t *pnum, int64_t *map,
1431 BlockDriverState **file)
1433 IO_CODE();
1434 return bdrv_co_block_status_above(blk_bs(blk), base, offset, bytes, pnum,
1435 map, file);
1438 int coroutine_fn blk_co_is_allocated_above(BlockBackend *blk,
1439 BlockDriverState *base,
1440 bool include_base, int64_t offset,
1441 int64_t bytes, int64_t *pnum)
1443 IO_CODE();
1444 return bdrv_co_is_allocated_above(blk_bs(blk), base, include_base, offset,
1445 bytes, pnum);
1448 typedef struct BlkRwCo {
1449 BlockBackend *blk;
1450 int64_t offset;
1451 void *iobuf;
1452 int ret;
1453 BdrvRequestFlags flags;
1454 } BlkRwCo;
1456 int blk_make_zero(BlockBackend *blk, BdrvRequestFlags flags)
1458 GLOBAL_STATE_CODE();
1459 return bdrv_make_zero(blk->root, flags);
1462 void blk_inc_in_flight(BlockBackend *blk)
1464 IO_CODE();
1465 qatomic_inc(&blk->in_flight);
1468 void blk_dec_in_flight(BlockBackend *blk)
1470 IO_CODE();
1471 qatomic_dec(&blk->in_flight);
1472 aio_wait_kick();
1475 static void error_callback_bh(void *opaque)
1477 struct BlockBackendAIOCB *acb = opaque;
1479 blk_dec_in_flight(acb->blk);
1480 acb->common.cb(acb->common.opaque, acb->ret);
1481 qemu_aio_unref(acb);
1484 BlockAIOCB *blk_abort_aio_request(BlockBackend *blk,
1485 BlockCompletionFunc *cb,
1486 void *opaque, int ret)
1488 struct BlockBackendAIOCB *acb;
1489 IO_CODE();
1491 blk_inc_in_flight(blk);
1492 acb = blk_aio_get(&block_backend_aiocb_info, blk, cb, opaque);
1493 acb->blk = blk;
1494 acb->ret = ret;
1496 replay_bh_schedule_oneshot_event(blk_get_aio_context(blk),
1497 error_callback_bh, acb);
1498 return &acb->common;
1501 typedef struct BlkAioEmAIOCB {
1502 BlockAIOCB common;
1503 BlkRwCo rwco;
1504 int64_t bytes;
1505 bool has_returned;
1506 } BlkAioEmAIOCB;
1508 static AioContext *blk_aio_em_aiocb_get_aio_context(BlockAIOCB *acb_)
1510 BlkAioEmAIOCB *acb = container_of(acb_, BlkAioEmAIOCB, common);
1512 return blk_get_aio_context(acb->rwco.blk);
1515 static const AIOCBInfo blk_aio_em_aiocb_info = {
1516 .aiocb_size = sizeof(BlkAioEmAIOCB),
1517 .get_aio_context = blk_aio_em_aiocb_get_aio_context,
1520 static void blk_aio_complete(BlkAioEmAIOCB *acb)
1522 if (acb->has_returned) {
1523 acb->common.cb(acb->common.opaque, acb->rwco.ret);
1524 blk_dec_in_flight(acb->rwco.blk);
1525 qemu_aio_unref(acb);
1529 static void blk_aio_complete_bh(void *opaque)
1531 BlkAioEmAIOCB *acb = opaque;
1532 assert(acb->has_returned);
1533 blk_aio_complete(acb);
1536 static BlockAIOCB *blk_aio_prwv(BlockBackend *blk, int64_t offset,
1537 int64_t bytes,
1538 void *iobuf, CoroutineEntry co_entry,
1539 BdrvRequestFlags flags,
1540 BlockCompletionFunc *cb, void *opaque)
1542 BlkAioEmAIOCB *acb;
1543 Coroutine *co;
1545 blk_inc_in_flight(blk);
1546 acb = blk_aio_get(&blk_aio_em_aiocb_info, blk, cb, opaque);
1547 acb->rwco = (BlkRwCo) {
1548 .blk = blk,
1549 .offset = offset,
1550 .iobuf = iobuf,
1551 .flags = flags,
1552 .ret = NOT_DONE,
1554 acb->bytes = bytes;
1555 acb->has_returned = false;
1557 co = qemu_coroutine_create(co_entry, acb);
1558 aio_co_enter(blk_get_aio_context(blk), co);
1560 acb->has_returned = true;
1561 if (acb->rwco.ret != NOT_DONE) {
1562 replay_bh_schedule_oneshot_event(blk_get_aio_context(blk),
1563 blk_aio_complete_bh, acb);
1566 return &acb->common;
1569 static void coroutine_fn blk_aio_read_entry(void *opaque)
1571 BlkAioEmAIOCB *acb = opaque;
1572 BlkRwCo *rwco = &acb->rwco;
1573 QEMUIOVector *qiov = rwco->iobuf;
1575 assert(qiov->size == acb->bytes);
1576 rwco->ret = blk_co_do_preadv_part(rwco->blk, rwco->offset, acb->bytes, qiov,
1577 0, rwco->flags);
1578 blk_aio_complete(acb);
1581 static void coroutine_fn blk_aio_write_entry(void *opaque)
1583 BlkAioEmAIOCB *acb = opaque;
1584 BlkRwCo *rwco = &acb->rwco;
1585 QEMUIOVector *qiov = rwco->iobuf;
1587 assert(!qiov || qiov->size == acb->bytes);
1588 rwco->ret = blk_co_do_pwritev_part(rwco->blk, rwco->offset, acb->bytes,
1589 qiov, 0, rwco->flags);
1590 blk_aio_complete(acb);
1593 BlockAIOCB *blk_aio_pwrite_zeroes(BlockBackend *blk, int64_t offset,
1594 int64_t bytes, BdrvRequestFlags flags,
1595 BlockCompletionFunc *cb, void *opaque)
1597 IO_CODE();
1598 return blk_aio_prwv(blk, offset, bytes, NULL, blk_aio_write_entry,
1599 flags | BDRV_REQ_ZERO_WRITE, cb, opaque);
1602 int64_t coroutine_fn blk_co_getlength(BlockBackend *blk)
1604 IO_CODE();
1606 if (!blk_is_available(blk)) {
1607 return -ENOMEDIUM;
1610 return bdrv_co_getlength(blk_bs(blk));
1613 void blk_get_geometry(BlockBackend *blk, uint64_t *nb_sectors_ptr)
1615 IO_CODE();
1616 if (!blk_bs(blk)) {
1617 *nb_sectors_ptr = 0;
1618 } else {
1619 bdrv_get_geometry(blk_bs(blk), nb_sectors_ptr);
1623 int64_t coroutine_fn blk_co_nb_sectors(BlockBackend *blk)
1625 IO_CODE();
1627 if (!blk_is_available(blk)) {
1628 return -ENOMEDIUM;
1631 return bdrv_co_nb_sectors(blk_bs(blk));
1634 BlockAIOCB *blk_aio_preadv(BlockBackend *blk, int64_t offset,
1635 QEMUIOVector *qiov, BdrvRequestFlags flags,
1636 BlockCompletionFunc *cb, void *opaque)
1638 IO_CODE();
1639 assert((uint64_t)qiov->size <= INT64_MAX);
1640 return blk_aio_prwv(blk, offset, qiov->size, qiov,
1641 blk_aio_read_entry, flags, cb, opaque);
1644 BlockAIOCB *blk_aio_pwritev(BlockBackend *blk, int64_t offset,
1645 QEMUIOVector *qiov, BdrvRequestFlags flags,
1646 BlockCompletionFunc *cb, void *opaque)
1648 IO_CODE();
1649 assert((uint64_t)qiov->size <= INT64_MAX);
1650 return blk_aio_prwv(blk, offset, qiov->size, qiov,
1651 blk_aio_write_entry, flags, cb, opaque);
1654 void blk_aio_cancel(BlockAIOCB *acb)
1656 GLOBAL_STATE_CODE();
1657 bdrv_aio_cancel(acb);
1660 void blk_aio_cancel_async(BlockAIOCB *acb)
1662 IO_CODE();
1663 bdrv_aio_cancel_async(acb);
1666 /* To be called between exactly one pair of blk_inc/dec_in_flight() */
1667 static int coroutine_fn
1668 blk_co_do_ioctl(BlockBackend *blk, unsigned long int req, void *buf)
1670 IO_CODE();
1672 blk_wait_while_drained(blk);
1674 if (!blk_is_available(blk)) {
1675 return -ENOMEDIUM;
1678 return bdrv_co_ioctl(blk_bs(blk), req, buf);
1681 int coroutine_fn blk_co_ioctl(BlockBackend *blk, unsigned long int req,
1682 void *buf)
1684 int ret;
1685 IO_OR_GS_CODE();
1687 blk_inc_in_flight(blk);
1688 ret = blk_co_do_ioctl(blk, req, buf);
1689 blk_dec_in_flight(blk);
1691 return ret;
1694 static void coroutine_fn blk_aio_ioctl_entry(void *opaque)
1696 BlkAioEmAIOCB *acb = opaque;
1697 BlkRwCo *rwco = &acb->rwco;
1699 rwco->ret = blk_co_do_ioctl(rwco->blk, rwco->offset, rwco->iobuf);
1701 blk_aio_complete(acb);
1704 BlockAIOCB *blk_aio_ioctl(BlockBackend *blk, unsigned long int req, void *buf,
1705 BlockCompletionFunc *cb, void *opaque)
1707 IO_CODE();
1708 return blk_aio_prwv(blk, req, 0, buf, blk_aio_ioctl_entry, 0, cb, opaque);
1711 /* To be called between exactly one pair of blk_inc/dec_in_flight() */
1712 static int coroutine_fn
1713 blk_co_do_pdiscard(BlockBackend *blk, int64_t offset, int64_t bytes)
1715 int ret;
1716 IO_CODE();
1718 blk_wait_while_drained(blk);
1720 ret = blk_check_byte_request(blk, offset, bytes);
1721 if (ret < 0) {
1722 return ret;
1725 return bdrv_co_pdiscard(blk->root, offset, bytes);
1728 static void coroutine_fn blk_aio_pdiscard_entry(void *opaque)
1730 BlkAioEmAIOCB *acb = opaque;
1731 BlkRwCo *rwco = &acb->rwco;
1733 rwco->ret = blk_co_do_pdiscard(rwco->blk, rwco->offset, acb->bytes);
1734 blk_aio_complete(acb);
1737 BlockAIOCB *blk_aio_pdiscard(BlockBackend *blk,
1738 int64_t offset, int64_t bytes,
1739 BlockCompletionFunc *cb, void *opaque)
1741 IO_CODE();
1742 return blk_aio_prwv(blk, offset, bytes, NULL, blk_aio_pdiscard_entry, 0,
1743 cb, opaque);
1746 int coroutine_fn blk_co_pdiscard(BlockBackend *blk, int64_t offset,
1747 int64_t bytes)
1749 int ret;
1750 IO_OR_GS_CODE();
1752 blk_inc_in_flight(blk);
1753 ret = blk_co_do_pdiscard(blk, offset, bytes);
1754 blk_dec_in_flight(blk);
1756 return ret;
1759 /* To be called between exactly one pair of blk_inc/dec_in_flight() */
1760 static int coroutine_fn blk_co_do_flush(BlockBackend *blk)
1762 blk_wait_while_drained(blk);
1763 IO_CODE();
1765 if (!blk_is_available(blk)) {
1766 return -ENOMEDIUM;
1769 return bdrv_co_flush(blk_bs(blk));
1772 static void coroutine_fn blk_aio_flush_entry(void *opaque)
1774 BlkAioEmAIOCB *acb = opaque;
1775 BlkRwCo *rwco = &acb->rwco;
1777 rwco->ret = blk_co_do_flush(rwco->blk);
1778 blk_aio_complete(acb);
1781 BlockAIOCB *blk_aio_flush(BlockBackend *blk,
1782 BlockCompletionFunc *cb, void *opaque)
1784 IO_CODE();
1785 return blk_aio_prwv(blk, 0, 0, NULL, blk_aio_flush_entry, 0, cb, opaque);
1788 int coroutine_fn blk_co_flush(BlockBackend *blk)
1790 int ret;
1791 IO_OR_GS_CODE();
1793 blk_inc_in_flight(blk);
1794 ret = blk_co_do_flush(blk);
1795 blk_dec_in_flight(blk);
1797 return ret;
1800 void blk_drain(BlockBackend *blk)
1802 BlockDriverState *bs = blk_bs(blk);
1803 GLOBAL_STATE_CODE();
1805 if (bs) {
1806 bdrv_ref(bs);
1807 bdrv_drained_begin(bs);
1810 /* We may have -ENOMEDIUM completions in flight */
1811 AIO_WAIT_WHILE(blk_get_aio_context(blk),
1812 qatomic_mb_read(&blk->in_flight) > 0);
1814 if (bs) {
1815 bdrv_drained_end(bs);
1816 bdrv_unref(bs);
1820 void blk_drain_all(void)
1822 BlockBackend *blk = NULL;
1824 GLOBAL_STATE_CODE();
1826 bdrv_drain_all_begin();
1828 while ((blk = blk_all_next(blk)) != NULL) {
1829 AioContext *ctx = blk_get_aio_context(blk);
1831 aio_context_acquire(ctx);
1833 /* We may have -ENOMEDIUM completions in flight */
1834 AIO_WAIT_WHILE(ctx, qatomic_mb_read(&blk->in_flight) > 0);
1836 aio_context_release(ctx);
1839 bdrv_drain_all_end();
1842 void blk_set_on_error(BlockBackend *blk, BlockdevOnError on_read_error,
1843 BlockdevOnError on_write_error)
1845 GLOBAL_STATE_CODE();
1846 blk->on_read_error = on_read_error;
1847 blk->on_write_error = on_write_error;
1850 BlockdevOnError blk_get_on_error(BlockBackend *blk, bool is_read)
1852 IO_CODE();
1853 return is_read ? blk->on_read_error : blk->on_write_error;
1856 BlockErrorAction blk_get_error_action(BlockBackend *blk, bool is_read,
1857 int error)
1859 BlockdevOnError on_err = blk_get_on_error(blk, is_read);
1860 IO_CODE();
1862 switch (on_err) {
1863 case BLOCKDEV_ON_ERROR_ENOSPC:
1864 return (error == ENOSPC) ?
1865 BLOCK_ERROR_ACTION_STOP : BLOCK_ERROR_ACTION_REPORT;
1866 case BLOCKDEV_ON_ERROR_STOP:
1867 return BLOCK_ERROR_ACTION_STOP;
1868 case BLOCKDEV_ON_ERROR_REPORT:
1869 return BLOCK_ERROR_ACTION_REPORT;
1870 case BLOCKDEV_ON_ERROR_IGNORE:
1871 return BLOCK_ERROR_ACTION_IGNORE;
1872 case BLOCKDEV_ON_ERROR_AUTO:
1873 default:
1874 abort();
1878 static void send_qmp_error_event(BlockBackend *blk,
1879 BlockErrorAction action,
1880 bool is_read, int error)
1882 IoOperationType optype;
1883 BlockDriverState *bs = blk_bs(blk);
1885 optype = is_read ? IO_OPERATION_TYPE_READ : IO_OPERATION_TYPE_WRITE;
1886 qapi_event_send_block_io_error(blk_name(blk),
1887 bs ? bdrv_get_node_name(bs) : NULL, optype,
1888 action, blk_iostatus_is_enabled(blk),
1889 error == ENOSPC, strerror(error));
1892 /* This is done by device models because, while the block layer knows
1893 * about the error, it does not know whether an operation comes from
1894 * the device or the block layer (from a job, for example).
1896 void blk_error_action(BlockBackend *blk, BlockErrorAction action,
1897 bool is_read, int error)
1899 assert(error >= 0);
1900 IO_CODE();
1902 if (action == BLOCK_ERROR_ACTION_STOP) {
1903 /* First set the iostatus, so that "info block" returns an iostatus
1904 * that matches the events raised so far (an additional error iostatus
1905 * is fine, but not a lost one).
1907 blk_iostatus_set_err(blk, error);
1909 /* Then raise the request to stop the VM and the event.
1910 * qemu_system_vmstop_request_prepare has two effects. First,
1911 * it ensures that the STOP event always comes after the
1912 * BLOCK_IO_ERROR event. Second, it ensures that even if management
1913 * can observe the STOP event and do a "cont" before the STOP
1914 * event is issued, the VM will not stop. In this case, vm_start()
1915 * also ensures that the STOP/RESUME pair of events is emitted.
1917 qemu_system_vmstop_request_prepare();
1918 send_qmp_error_event(blk, action, is_read, error);
1919 qemu_system_vmstop_request(RUN_STATE_IO_ERROR);
1920 } else {
1921 send_qmp_error_event(blk, action, is_read, error);
1926 * Returns true if the BlockBackend can support taking write permissions
1927 * (because its root node is not read-only).
1929 bool blk_supports_write_perm(BlockBackend *blk)
1931 BlockDriverState *bs = blk_bs(blk);
1932 GLOBAL_STATE_CODE();
1934 if (bs) {
1935 return !bdrv_is_read_only(bs);
1936 } else {
1937 return blk->root_state.open_flags & BDRV_O_RDWR;
1942 * Returns true if the BlockBackend can be written to in its current
1943 * configuration (i.e. if write permission have been requested)
1945 bool blk_is_writable(BlockBackend *blk)
1947 IO_CODE();
1948 return blk->perm & BLK_PERM_WRITE;
1951 bool blk_is_sg(BlockBackend *blk)
1953 BlockDriverState *bs = blk_bs(blk);
1954 GLOBAL_STATE_CODE();
1956 if (!bs) {
1957 return false;
1960 return bdrv_is_sg(bs);
1963 bool blk_enable_write_cache(BlockBackend *blk)
1965 IO_CODE();
1966 return blk->enable_write_cache;
1969 void blk_set_enable_write_cache(BlockBackend *blk, bool wce)
1971 IO_CODE();
1972 blk->enable_write_cache = wce;
1975 void blk_activate(BlockBackend *blk, Error **errp)
1977 BlockDriverState *bs = blk_bs(blk);
1978 GLOBAL_STATE_CODE();
1980 if (!bs) {
1981 error_setg(errp, "Device '%s' has no medium", blk->name);
1982 return;
1985 bdrv_activate(bs, errp);
1988 bool coroutine_fn blk_co_is_inserted(BlockBackend *blk)
1990 BlockDriverState *bs = blk_bs(blk);
1991 IO_CODE();
1993 return bs && bdrv_co_is_inserted(bs);
1996 bool blk_is_available(BlockBackend *blk)
1998 IO_CODE();
1999 return blk_is_inserted(blk) && !blk_dev_is_tray_open(blk);
2002 void coroutine_fn blk_co_lock_medium(BlockBackend *blk, bool locked)
2004 BlockDriverState *bs = blk_bs(blk);
2005 IO_CODE();
2007 if (bs) {
2008 bdrv_co_lock_medium(bs, locked);
2012 void coroutine_fn blk_co_eject(BlockBackend *blk, bool eject_flag)
2014 BlockDriverState *bs = blk_bs(blk);
2015 char *id;
2016 IO_CODE();
2018 if (bs) {
2019 bdrv_co_eject(bs, eject_flag);
2022 /* Whether or not we ejected on the backend,
2023 * the frontend experienced a tray event. */
2024 id = blk_get_attached_dev_id(blk);
2025 qapi_event_send_device_tray_moved(blk_name(blk), id,
2026 eject_flag);
2027 g_free(id);
2030 int blk_get_flags(BlockBackend *blk)
2032 BlockDriverState *bs = blk_bs(blk);
2033 GLOBAL_STATE_CODE();
2035 if (bs) {
2036 return bdrv_get_flags(bs);
2037 } else {
2038 return blk->root_state.open_flags;
2042 /* Returns the minimum request alignment, in bytes; guaranteed nonzero */
2043 uint32_t blk_get_request_alignment(BlockBackend *blk)
2045 BlockDriverState *bs = blk_bs(blk);
2046 IO_CODE();
2047 return bs ? bs->bl.request_alignment : BDRV_SECTOR_SIZE;
2050 /* Returns the maximum hardware transfer length, in bytes; guaranteed nonzero */
2051 uint64_t blk_get_max_hw_transfer(BlockBackend *blk)
2053 BlockDriverState *bs = blk_bs(blk);
2054 uint64_t max = INT_MAX;
2055 IO_CODE();
2057 if (bs) {
2058 max = MIN_NON_ZERO(max, bs->bl.max_hw_transfer);
2059 max = MIN_NON_ZERO(max, bs->bl.max_transfer);
2061 return ROUND_DOWN(max, blk_get_request_alignment(blk));
2064 /* Returns the maximum transfer length, in bytes; guaranteed nonzero */
2065 uint32_t blk_get_max_transfer(BlockBackend *blk)
2067 BlockDriverState *bs = blk_bs(blk);
2068 uint32_t max = INT_MAX;
2069 IO_CODE();
2071 if (bs) {
2072 max = MIN_NON_ZERO(max, bs->bl.max_transfer);
2074 return ROUND_DOWN(max, blk_get_request_alignment(blk));
2077 int blk_get_max_hw_iov(BlockBackend *blk)
2079 IO_CODE();
2080 return MIN_NON_ZERO(blk->root->bs->bl.max_hw_iov,
2081 blk->root->bs->bl.max_iov);
2084 int blk_get_max_iov(BlockBackend *blk)
2086 IO_CODE();
2087 return blk->root->bs->bl.max_iov;
2090 void *blk_try_blockalign(BlockBackend *blk, size_t size)
2092 IO_CODE();
2093 return qemu_try_blockalign(blk ? blk_bs(blk) : NULL, size);
2096 void *blk_blockalign(BlockBackend *blk, size_t size)
2098 IO_CODE();
2099 return qemu_blockalign(blk ? blk_bs(blk) : NULL, size);
2102 bool blk_op_is_blocked(BlockBackend *blk, BlockOpType op, Error **errp)
2104 BlockDriverState *bs = blk_bs(blk);
2105 GLOBAL_STATE_CODE();
2107 if (!bs) {
2108 return false;
2111 return bdrv_op_is_blocked(bs, op, errp);
2114 void blk_op_unblock(BlockBackend *blk, BlockOpType op, Error *reason)
2116 BlockDriverState *bs = blk_bs(blk);
2117 GLOBAL_STATE_CODE();
2119 if (bs) {
2120 bdrv_op_unblock(bs, op, reason);
2124 void blk_op_block_all(BlockBackend *blk, Error *reason)
2126 BlockDriverState *bs = blk_bs(blk);
2127 GLOBAL_STATE_CODE();
2129 if (bs) {
2130 bdrv_op_block_all(bs, reason);
2134 void blk_op_unblock_all(BlockBackend *blk, Error *reason)
2136 BlockDriverState *bs = blk_bs(blk);
2137 GLOBAL_STATE_CODE();
2139 if (bs) {
2140 bdrv_op_unblock_all(bs, reason);
2144 AioContext *blk_get_aio_context(BlockBackend *blk)
2146 BlockDriverState *bs = blk_bs(blk);
2147 IO_CODE();
2149 if (bs) {
2150 AioContext *ctx = bdrv_get_aio_context(blk_bs(blk));
2151 assert(ctx == blk->ctx);
2154 return blk->ctx;
2157 static AioContext *blk_aiocb_get_aio_context(BlockAIOCB *acb)
2159 BlockBackendAIOCB *blk_acb = DO_UPCAST(BlockBackendAIOCB, common, acb);
2160 return blk_get_aio_context(blk_acb->blk);
2163 static int blk_do_set_aio_context(BlockBackend *blk, AioContext *new_context,
2164 bool update_root_node, Error **errp)
2166 BlockDriverState *bs = blk_bs(blk);
2167 ThrottleGroupMember *tgm = &blk->public.throttle_group_member;
2168 int ret;
2170 if (bs) {
2171 bdrv_ref(bs);
2173 if (update_root_node) {
2175 * update_root_node MUST be false for blk_root_set_aio_ctx_commit(),
2176 * as we are already in the commit function of a transaction.
2178 ret = bdrv_try_change_aio_context(bs, new_context, blk->root, errp);
2179 if (ret < 0) {
2180 bdrv_unref(bs);
2181 return ret;
2185 * Make blk->ctx consistent with the root node before we invoke any
2186 * other operations like drain that might inquire blk->ctx
2188 blk->ctx = new_context;
2189 if (tgm->throttle_state) {
2190 bdrv_drained_begin(bs);
2191 throttle_group_detach_aio_context(tgm);
2192 throttle_group_attach_aio_context(tgm, new_context);
2193 bdrv_drained_end(bs);
2196 bdrv_unref(bs);
2197 } else {
2198 blk->ctx = new_context;
2201 return 0;
2204 int blk_set_aio_context(BlockBackend *blk, AioContext *new_context,
2205 Error **errp)
2207 GLOBAL_STATE_CODE();
2208 return blk_do_set_aio_context(blk, new_context, true, errp);
2211 typedef struct BdrvStateBlkRootContext {
2212 AioContext *new_ctx;
2213 BlockBackend *blk;
2214 } BdrvStateBlkRootContext;
2216 static void blk_root_set_aio_ctx_commit(void *opaque)
2218 BdrvStateBlkRootContext *s = opaque;
2219 BlockBackend *blk = s->blk;
2221 blk_do_set_aio_context(blk, s->new_ctx, false, &error_abort);
2224 static TransactionActionDrv set_blk_root_context = {
2225 .commit = blk_root_set_aio_ctx_commit,
2226 .clean = g_free,
2229 static bool blk_root_change_aio_ctx(BdrvChild *child, AioContext *ctx,
2230 GHashTable *visited, Transaction *tran,
2231 Error **errp)
2233 BlockBackend *blk = child->opaque;
2234 BdrvStateBlkRootContext *s;
2236 if (!blk->allow_aio_context_change) {
2238 * Manually created BlockBackends (those with a name) that are not
2239 * attached to anything can change their AioContext without updating
2240 * their user; return an error for others.
2242 if (!blk->name || blk->dev) {
2243 /* TODO Add BB name/QOM path */
2244 error_setg(errp, "Cannot change iothread of active block backend");
2245 return false;
2249 s = g_new(BdrvStateBlkRootContext, 1);
2250 *s = (BdrvStateBlkRootContext) {
2251 .new_ctx = ctx,
2252 .blk = blk,
2255 tran_add(tran, &set_blk_root_context, s);
2256 return true;
2259 void blk_add_aio_context_notifier(BlockBackend *blk,
2260 void (*attached_aio_context)(AioContext *new_context, void *opaque),
2261 void (*detach_aio_context)(void *opaque), void *opaque)
2263 BlockBackendAioNotifier *notifier;
2264 BlockDriverState *bs = blk_bs(blk);
2265 GLOBAL_STATE_CODE();
2267 notifier = g_new(BlockBackendAioNotifier, 1);
2268 notifier->attached_aio_context = attached_aio_context;
2269 notifier->detach_aio_context = detach_aio_context;
2270 notifier->opaque = opaque;
2271 QLIST_INSERT_HEAD(&blk->aio_notifiers, notifier, list);
2273 if (bs) {
2274 bdrv_add_aio_context_notifier(bs, attached_aio_context,
2275 detach_aio_context, opaque);
2279 void blk_remove_aio_context_notifier(BlockBackend *blk,
2280 void (*attached_aio_context)(AioContext *,
2281 void *),
2282 void (*detach_aio_context)(void *),
2283 void *opaque)
2285 BlockBackendAioNotifier *notifier;
2286 BlockDriverState *bs = blk_bs(blk);
2288 GLOBAL_STATE_CODE();
2290 if (bs) {
2291 bdrv_remove_aio_context_notifier(bs, attached_aio_context,
2292 detach_aio_context, opaque);
2295 QLIST_FOREACH(notifier, &blk->aio_notifiers, list) {
2296 if (notifier->attached_aio_context == attached_aio_context &&
2297 notifier->detach_aio_context == detach_aio_context &&
2298 notifier->opaque == opaque) {
2299 QLIST_REMOVE(notifier, list);
2300 g_free(notifier);
2301 return;
2305 abort();
2308 void blk_add_remove_bs_notifier(BlockBackend *blk, Notifier *notify)
2310 GLOBAL_STATE_CODE();
2311 notifier_list_add(&blk->remove_bs_notifiers, notify);
2314 void blk_add_insert_bs_notifier(BlockBackend *blk, Notifier *notify)
2316 GLOBAL_STATE_CODE();
2317 notifier_list_add(&blk->insert_bs_notifiers, notify);
2320 void coroutine_fn blk_co_io_plug(BlockBackend *blk)
2322 BlockDriverState *bs = blk_bs(blk);
2323 IO_CODE();
2325 if (bs) {
2326 bdrv_co_io_plug(bs);
2330 void coroutine_fn blk_co_io_unplug(BlockBackend *blk)
2332 BlockDriverState *bs = blk_bs(blk);
2333 IO_CODE();
2335 if (bs) {
2336 bdrv_co_io_unplug(bs);
2340 BlockAcctStats *blk_get_stats(BlockBackend *blk)
2342 IO_CODE();
2343 return &blk->stats;
2346 void *blk_aio_get(const AIOCBInfo *aiocb_info, BlockBackend *blk,
2347 BlockCompletionFunc *cb, void *opaque)
2349 IO_CODE();
2350 return qemu_aio_get(aiocb_info, blk_bs(blk), cb, opaque);
2353 int coroutine_fn blk_co_pwrite_zeroes(BlockBackend *blk, int64_t offset,
2354 int64_t bytes, BdrvRequestFlags flags)
2356 IO_OR_GS_CODE();
2357 return blk_co_pwritev(blk, offset, bytes, NULL,
2358 flags | BDRV_REQ_ZERO_WRITE);
2361 int coroutine_fn blk_co_pwrite_compressed(BlockBackend *blk, int64_t offset,
2362 int64_t bytes, const void *buf)
2364 QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
2365 IO_OR_GS_CODE();
2366 return blk_co_pwritev_part(blk, offset, bytes, &qiov, 0,
2367 BDRV_REQ_WRITE_COMPRESSED);
2370 int coroutine_fn blk_co_truncate(BlockBackend *blk, int64_t offset, bool exact,
2371 PreallocMode prealloc, BdrvRequestFlags flags,
2372 Error **errp)
2374 IO_OR_GS_CODE();
2375 if (!blk_is_available(blk)) {
2376 error_setg(errp, "No medium inserted");
2377 return -ENOMEDIUM;
2380 return bdrv_co_truncate(blk->root, offset, exact, prealloc, flags, errp);
2383 int blk_save_vmstate(BlockBackend *blk, const uint8_t *buf,
2384 int64_t pos, int size)
2386 int ret;
2387 GLOBAL_STATE_CODE();
2389 if (!blk_is_available(blk)) {
2390 return -ENOMEDIUM;
2393 ret = bdrv_save_vmstate(blk_bs(blk), buf, pos, size);
2394 if (ret < 0) {
2395 return ret;
2398 if (ret == size && !blk->enable_write_cache) {
2399 ret = bdrv_flush(blk_bs(blk));
2402 return ret < 0 ? ret : size;
2405 int blk_load_vmstate(BlockBackend *blk, uint8_t *buf, int64_t pos, int size)
2407 GLOBAL_STATE_CODE();
2408 if (!blk_is_available(blk)) {
2409 return -ENOMEDIUM;
2412 return bdrv_load_vmstate(blk_bs(blk), buf, pos, size);
2415 int blk_probe_blocksizes(BlockBackend *blk, BlockSizes *bsz)
2417 GLOBAL_STATE_CODE();
2418 if (!blk_is_available(blk)) {
2419 return -ENOMEDIUM;
2422 return bdrv_probe_blocksizes(blk_bs(blk), bsz);
2425 int blk_probe_geometry(BlockBackend *blk, HDGeometry *geo)
2427 GLOBAL_STATE_CODE();
2428 if (!blk_is_available(blk)) {
2429 return -ENOMEDIUM;
2432 return bdrv_probe_geometry(blk_bs(blk), geo);
2436 * Updates the BlockBackendRootState object with data from the currently
2437 * attached BlockDriverState.
2439 void blk_update_root_state(BlockBackend *blk)
2441 GLOBAL_STATE_CODE();
2442 assert(blk->root);
2444 blk->root_state.open_flags = blk->root->bs->open_flags;
2445 blk->root_state.detect_zeroes = blk->root->bs->detect_zeroes;
2449 * Returns the detect-zeroes setting to be used for bdrv_open() of a
2450 * BlockDriverState which is supposed to inherit the root state.
2452 bool blk_get_detect_zeroes_from_root_state(BlockBackend *blk)
2454 GLOBAL_STATE_CODE();
2455 return blk->root_state.detect_zeroes;
2459 * Returns the flags to be used for bdrv_open() of a BlockDriverState which is
2460 * supposed to inherit the root state.
2462 int blk_get_open_flags_from_root_state(BlockBackend *blk)
2464 GLOBAL_STATE_CODE();
2465 return blk->root_state.open_flags;
2468 BlockBackendRootState *blk_get_root_state(BlockBackend *blk)
2470 GLOBAL_STATE_CODE();
2471 return &blk->root_state;
2474 int blk_commit_all(void)
2476 BlockBackend *blk = NULL;
2477 GLOBAL_STATE_CODE();
2479 while ((blk = blk_all_next(blk)) != NULL) {
2480 AioContext *aio_context = blk_get_aio_context(blk);
2481 BlockDriverState *unfiltered_bs = bdrv_skip_filters(blk_bs(blk));
2483 aio_context_acquire(aio_context);
2484 if (blk_is_inserted(blk) && bdrv_cow_child(unfiltered_bs)) {
2485 int ret;
2487 ret = bdrv_commit(unfiltered_bs);
2488 if (ret < 0) {
2489 aio_context_release(aio_context);
2490 return ret;
2493 aio_context_release(aio_context);
2495 return 0;
2499 /* throttling disk I/O limits */
2500 void blk_set_io_limits(BlockBackend *blk, ThrottleConfig *cfg)
2502 GLOBAL_STATE_CODE();
2503 throttle_group_config(&blk->public.throttle_group_member, cfg);
2506 void blk_io_limits_disable(BlockBackend *blk)
2508 BlockDriverState *bs = blk_bs(blk);
2509 ThrottleGroupMember *tgm = &blk->public.throttle_group_member;
2510 assert(tgm->throttle_state);
2511 GLOBAL_STATE_CODE();
2512 if (bs) {
2513 bdrv_ref(bs);
2514 bdrv_drained_begin(bs);
2516 throttle_group_unregister_tgm(tgm);
2517 if (bs) {
2518 bdrv_drained_end(bs);
2519 bdrv_unref(bs);
2523 /* should be called before blk_set_io_limits if a limit is set */
2524 void blk_io_limits_enable(BlockBackend *blk, const char *group)
2526 assert(!blk->public.throttle_group_member.throttle_state);
2527 GLOBAL_STATE_CODE();
2528 throttle_group_register_tgm(&blk->public.throttle_group_member,
2529 group, blk_get_aio_context(blk));
2532 void blk_io_limits_update_group(BlockBackend *blk, const char *group)
2534 GLOBAL_STATE_CODE();
2535 /* this BB is not part of any group */
2536 if (!blk->public.throttle_group_member.throttle_state) {
2537 return;
2540 /* this BB is a part of the same group than the one we want */
2541 if (!g_strcmp0(throttle_group_get_name(&blk->public.throttle_group_member),
2542 group)) {
2543 return;
2546 /* need to change the group this bs belong to */
2547 blk_io_limits_disable(blk);
2548 blk_io_limits_enable(blk, group);
2551 static void blk_root_drained_begin(BdrvChild *child)
2553 BlockBackend *blk = child->opaque;
2554 ThrottleGroupMember *tgm = &blk->public.throttle_group_member;
2556 if (++blk->quiesce_counter == 1) {
2557 if (blk->dev_ops && blk->dev_ops->drained_begin) {
2558 blk->dev_ops->drained_begin(blk->dev_opaque);
2562 /* Note that blk->root may not be accessible here yet if we are just
2563 * attaching to a BlockDriverState that is drained. Use child instead. */
2565 if (qatomic_fetch_inc(&tgm->io_limits_disabled) == 0) {
2566 throttle_group_restart_tgm(tgm);
2570 static bool blk_root_drained_poll(BdrvChild *child)
2572 BlockBackend *blk = child->opaque;
2573 bool busy = false;
2574 assert(blk->quiesce_counter);
2576 if (blk->dev_ops && blk->dev_ops->drained_poll) {
2577 busy = blk->dev_ops->drained_poll(blk->dev_opaque);
2579 return busy || !!blk->in_flight;
2582 static void blk_root_drained_end(BdrvChild *child)
2584 BlockBackend *blk = child->opaque;
2585 assert(blk->quiesce_counter);
2587 assert(blk->public.throttle_group_member.io_limits_disabled);
2588 qatomic_dec(&blk->public.throttle_group_member.io_limits_disabled);
2590 if (--blk->quiesce_counter == 0) {
2591 if (blk->dev_ops && blk->dev_ops->drained_end) {
2592 blk->dev_ops->drained_end(blk->dev_opaque);
2594 while (qemu_co_enter_next(&blk->queued_requests, NULL)) {
2595 /* Resume all queued requests */
2600 bool blk_register_buf(BlockBackend *blk, void *host, size_t size, Error **errp)
2602 BlockDriverState *bs = blk_bs(blk);
2604 GLOBAL_STATE_CODE();
2606 if (bs) {
2607 return bdrv_register_buf(bs, host, size, errp);
2609 return true;
2612 void blk_unregister_buf(BlockBackend *blk, void *host, size_t size)
2614 BlockDriverState *bs = blk_bs(blk);
2616 GLOBAL_STATE_CODE();
2618 if (bs) {
2619 bdrv_unregister_buf(bs, host, size);
2623 int coroutine_fn blk_co_copy_range(BlockBackend *blk_in, int64_t off_in,
2624 BlockBackend *blk_out, int64_t off_out,
2625 int64_t bytes, BdrvRequestFlags read_flags,
2626 BdrvRequestFlags write_flags)
2628 int r;
2629 IO_CODE();
2631 r = blk_check_byte_request(blk_in, off_in, bytes);
2632 if (r) {
2633 return r;
2635 r = blk_check_byte_request(blk_out, off_out, bytes);
2636 if (r) {
2637 return r;
2639 return bdrv_co_copy_range(blk_in->root, off_in,
2640 blk_out->root, off_out,
2641 bytes, read_flags, write_flags);
2644 const BdrvChild *blk_root(BlockBackend *blk)
2646 GLOBAL_STATE_CODE();
2647 return blk->root;
2650 int blk_make_empty(BlockBackend *blk, Error **errp)
2652 GLOBAL_STATE_CODE();
2653 if (!blk_is_available(blk)) {
2654 error_setg(errp, "No medium inserted");
2655 return -ENOMEDIUM;
2658 return bdrv_make_empty(blk->root, errp);