block: Implement blk_flush() using generated_co_wrapper
[qemu/armbru.git] / block / block-backend.c
blob783a77cf6d10832f3471e604d0586cd174b266bc
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, int *drained_end_counter);
134 static void blk_root_change_media(BdrvChild *child, bool load);
135 static void blk_root_resize(BdrvChild *child);
137 static bool blk_root_can_set_aio_ctx(BdrvChild *child, AioContext *ctx,
138 GSList **ignore, Error **errp);
139 static void blk_root_set_aio_ctx(BdrvChild *child, AioContext *ctx,
140 GSList **ignore);
142 static char *blk_root_get_parent_desc(BdrvChild *child)
144 BlockBackend *blk = child->opaque;
145 g_autofree char *dev_id = NULL;
147 if (blk->name) {
148 return g_strdup_printf("block device '%s'", blk->name);
151 dev_id = blk_get_attached_dev_id(blk);
152 if (*dev_id) {
153 return g_strdup_printf("block device '%s'", dev_id);
154 } else {
155 /* TODO Callback into the BB owner for something more detailed */
156 return g_strdup("an unnamed block device");
160 static const char *blk_root_get_name(BdrvChild *child)
162 return blk_name(child->opaque);
165 static void blk_vm_state_changed(void *opaque, bool running, RunState state)
167 Error *local_err = NULL;
168 BlockBackend *blk = opaque;
170 if (state == RUN_STATE_INMIGRATE) {
171 return;
174 qemu_del_vm_change_state_handler(blk->vmsh);
175 blk->vmsh = NULL;
176 blk_set_perm(blk, blk->perm, blk->shared_perm, &local_err);
177 if (local_err) {
178 error_report_err(local_err);
183 * Notifies the user of the BlockBackend that migration has completed. qdev
184 * devices can tighten their permissions in response (specifically revoke
185 * shared write permissions that we needed for storage migration).
187 * If an error is returned, the VM cannot be allowed to be resumed.
189 static void blk_root_activate(BdrvChild *child, Error **errp)
191 BlockBackend *blk = child->opaque;
192 Error *local_err = NULL;
193 uint64_t saved_shared_perm;
195 if (!blk->disable_perm) {
196 return;
199 blk->disable_perm = false;
202 * blk->shared_perm contains the permissions we want to share once
203 * migration is really completely done. For now, we need to share
204 * all; but we also need to retain blk->shared_perm, which is
205 * overwritten by a successful blk_set_perm() call. Save it and
206 * restore it below.
208 saved_shared_perm = blk->shared_perm;
210 blk_set_perm(blk, blk->perm, BLK_PERM_ALL, &local_err);
211 if (local_err) {
212 error_propagate(errp, local_err);
213 blk->disable_perm = true;
214 return;
216 blk->shared_perm = saved_shared_perm;
218 if (runstate_check(RUN_STATE_INMIGRATE)) {
219 /* Activation can happen when migration process is still active, for
220 * example when nbd_server_add is called during non-shared storage
221 * migration. Defer the shared_perm update to migration completion. */
222 if (!blk->vmsh) {
223 blk->vmsh = qemu_add_vm_change_state_handler(blk_vm_state_changed,
224 blk);
226 return;
229 blk_set_perm(blk, blk->perm, blk->shared_perm, &local_err);
230 if (local_err) {
231 error_propagate(errp, local_err);
232 blk->disable_perm = true;
233 return;
237 void blk_set_force_allow_inactivate(BlockBackend *blk)
239 GLOBAL_STATE_CODE();
240 blk->force_allow_inactivate = true;
243 static bool blk_can_inactivate(BlockBackend *blk)
245 /* If it is a guest device, inactivate is ok. */
246 if (blk->dev || blk_name(blk)[0]) {
247 return true;
250 /* Inactivating means no more writes to the image can be done,
251 * even if those writes would be changes invisible to the
252 * guest. For block job BBs that satisfy this, we can just allow
253 * it. This is the case for mirror job source, which is required
254 * by libvirt non-shared block migration. */
255 if (!(blk->perm & (BLK_PERM_WRITE | BLK_PERM_WRITE_UNCHANGED))) {
256 return true;
259 return blk->force_allow_inactivate;
262 static int blk_root_inactivate(BdrvChild *child)
264 BlockBackend *blk = child->opaque;
266 if (blk->disable_perm) {
267 return 0;
270 if (!blk_can_inactivate(blk)) {
271 return -EPERM;
274 blk->disable_perm = true;
275 if (blk->root) {
276 bdrv_child_try_set_perm(blk->root, 0, BLK_PERM_ALL, &error_abort);
279 return 0;
282 static void blk_root_attach(BdrvChild *child)
284 BlockBackend *blk = child->opaque;
285 BlockBackendAioNotifier *notifier;
287 trace_blk_root_attach(child, blk, child->bs);
289 QLIST_FOREACH(notifier, &blk->aio_notifiers, list) {
290 bdrv_add_aio_context_notifier(child->bs,
291 notifier->attached_aio_context,
292 notifier->detach_aio_context,
293 notifier->opaque);
297 static void blk_root_detach(BdrvChild *child)
299 BlockBackend *blk = child->opaque;
300 BlockBackendAioNotifier *notifier;
302 trace_blk_root_detach(child, blk, child->bs);
304 QLIST_FOREACH(notifier, &blk->aio_notifiers, list) {
305 bdrv_remove_aio_context_notifier(child->bs,
306 notifier->attached_aio_context,
307 notifier->detach_aio_context,
308 notifier->opaque);
312 static AioContext *blk_root_get_parent_aio_context(BdrvChild *c)
314 BlockBackend *blk = c->opaque;
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 .can_set_aio_ctx = blk_root_can_set_aio_ctx,
338 .set_aio_ctx = blk_root_set_aio_ctx,
340 .get_parent_aio_context = blk_root_get_parent_aio_context,
344 * Create a new BlockBackend with a reference count of one.
346 * @perm is a bitmasks of BLK_PERM_* constants which describes the permissions
347 * to request for a block driver node that is attached to this BlockBackend.
348 * @shared_perm is a bitmask which describes which permissions may be granted
349 * to other users of the attached node.
350 * Both sets of permissions can be changed later using blk_set_perm().
352 * Return the new BlockBackend on success, null on failure.
354 BlockBackend *blk_new(AioContext *ctx, uint64_t perm, uint64_t shared_perm)
356 BlockBackend *blk;
358 GLOBAL_STATE_CODE();
360 blk = g_new0(BlockBackend, 1);
361 blk->refcnt = 1;
362 blk->ctx = ctx;
363 blk->perm = perm;
364 blk->shared_perm = shared_perm;
365 blk_set_enable_write_cache(blk, true);
367 blk->on_read_error = BLOCKDEV_ON_ERROR_REPORT;
368 blk->on_write_error = BLOCKDEV_ON_ERROR_ENOSPC;
370 block_acct_init(&blk->stats);
372 qemu_co_queue_init(&blk->queued_requests);
373 notifier_list_init(&blk->remove_bs_notifiers);
374 notifier_list_init(&blk->insert_bs_notifiers);
375 QLIST_INIT(&blk->aio_notifiers);
377 QTAILQ_INSERT_TAIL(&block_backends, blk, link);
378 return blk;
382 * Create a new BlockBackend connected to an existing BlockDriverState.
384 * @perm is a bitmasks of BLK_PERM_* constants which describes the
385 * permissions to request for @bs that is attached to this
386 * BlockBackend. @shared_perm is a bitmask which describes which
387 * permissions may be granted to other users of the attached node.
388 * Both sets of permissions can be changed later using blk_set_perm().
390 * Return the new BlockBackend on success, null on failure.
392 BlockBackend *blk_new_with_bs(BlockDriverState *bs, uint64_t perm,
393 uint64_t shared_perm, Error **errp)
395 BlockBackend *blk = blk_new(bdrv_get_aio_context(bs), perm, shared_perm);
397 GLOBAL_STATE_CODE();
399 if (blk_insert_bs(blk, bs, errp) < 0) {
400 blk_unref(blk);
401 return NULL;
403 return blk;
407 * Creates a new BlockBackend, opens a new BlockDriverState, and connects both.
408 * The new BlockBackend is in the main AioContext.
410 * Just as with bdrv_open(), after having called this function the reference to
411 * @options belongs to the block layer (even on failure).
413 * TODO: Remove @filename and @flags; it should be possible to specify a whole
414 * BDS tree just by specifying the @options QDict (or @reference,
415 * alternatively). At the time of adding this function, this is not possible,
416 * though, so callers of this function have to be able to specify @filename and
417 * @flags.
419 BlockBackend *blk_new_open(const char *filename, const char *reference,
420 QDict *options, int flags, Error **errp)
422 BlockBackend *blk;
423 BlockDriverState *bs;
424 uint64_t perm = 0;
425 uint64_t shared = BLK_PERM_ALL;
427 GLOBAL_STATE_CODE();
430 * blk_new_open() is mainly used in .bdrv_create implementations and the
431 * tools where sharing isn't a major concern because the BDS stays private
432 * and the file is generally not supposed to be used by a second process,
433 * so we just request permission according to the flags.
435 * The exceptions are xen_disk and blockdev_init(); in these cases, the
436 * caller of blk_new_open() doesn't make use of the permissions, but they
437 * shouldn't hurt either. We can still share everything here because the
438 * guest devices will add their own blockers if they can't share.
440 if ((flags & BDRV_O_NO_IO) == 0) {
441 perm |= BLK_PERM_CONSISTENT_READ;
442 if (flags & BDRV_O_RDWR) {
443 perm |= BLK_PERM_WRITE;
446 if (flags & BDRV_O_RESIZE) {
447 perm |= BLK_PERM_RESIZE;
449 if (flags & BDRV_O_NO_SHARE) {
450 shared = BLK_PERM_CONSISTENT_READ | BLK_PERM_WRITE_UNCHANGED;
453 blk = blk_new(qemu_get_aio_context(), perm, shared);
454 bs = bdrv_open(filename, reference, options, flags, errp);
455 if (!bs) {
456 blk_unref(blk);
457 return NULL;
460 blk->root = bdrv_root_attach_child(bs, "root", &child_root,
461 BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY,
462 perm, shared, blk, errp);
463 if (!blk->root) {
464 blk_unref(blk);
465 return NULL;
468 return blk;
471 static void blk_delete(BlockBackend *blk)
473 assert(!blk->refcnt);
474 assert(!blk->name);
475 assert(!blk->dev);
476 if (blk->public.throttle_group_member.throttle_state) {
477 blk_io_limits_disable(blk);
479 if (blk->root) {
480 blk_remove_bs(blk);
482 if (blk->vmsh) {
483 qemu_del_vm_change_state_handler(blk->vmsh);
484 blk->vmsh = NULL;
486 assert(QLIST_EMPTY(&blk->remove_bs_notifiers.notifiers));
487 assert(QLIST_EMPTY(&blk->insert_bs_notifiers.notifiers));
488 assert(QLIST_EMPTY(&blk->aio_notifiers));
489 QTAILQ_REMOVE(&block_backends, blk, link);
490 drive_info_del(blk->legacy_dinfo);
491 block_acct_cleanup(&blk->stats);
492 g_free(blk);
495 static void drive_info_del(DriveInfo *dinfo)
497 if (!dinfo) {
498 return;
500 qemu_opts_del(dinfo->opts);
501 g_free(dinfo);
504 int blk_get_refcnt(BlockBackend *blk)
506 GLOBAL_STATE_CODE();
507 return blk ? blk->refcnt : 0;
511 * Increment @blk's reference count.
512 * @blk must not be null.
514 void blk_ref(BlockBackend *blk)
516 assert(blk->refcnt > 0);
517 GLOBAL_STATE_CODE();
518 blk->refcnt++;
522 * Decrement @blk's reference count.
523 * If this drops it to zero, destroy @blk.
524 * For convenience, do nothing if @blk is null.
526 void blk_unref(BlockBackend *blk)
528 GLOBAL_STATE_CODE();
529 if (blk) {
530 assert(blk->refcnt > 0);
531 if (blk->refcnt > 1) {
532 blk->refcnt--;
533 } else {
534 blk_drain(blk);
535 /* blk_drain() cannot resurrect blk, nobody held a reference */
536 assert(blk->refcnt == 1);
537 blk->refcnt = 0;
538 blk_delete(blk);
544 * Behaves similarly to blk_next() but iterates over all BlockBackends, even the
545 * ones which are hidden (i.e. are not referenced by the monitor).
547 BlockBackend *blk_all_next(BlockBackend *blk)
549 GLOBAL_STATE_CODE();
550 return blk ? QTAILQ_NEXT(blk, link)
551 : QTAILQ_FIRST(&block_backends);
554 void blk_remove_all_bs(void)
556 BlockBackend *blk = NULL;
558 GLOBAL_STATE_CODE();
560 while ((blk = blk_all_next(blk)) != NULL) {
561 AioContext *ctx = blk_get_aio_context(blk);
563 aio_context_acquire(ctx);
564 if (blk->root) {
565 blk_remove_bs(blk);
567 aio_context_release(ctx);
572 * Return the monitor-owned BlockBackend after @blk.
573 * If @blk is null, return the first one.
574 * Else, return @blk's next sibling, which may be null.
576 * To iterate over all BlockBackends, do
577 * for (blk = blk_next(NULL); blk; blk = blk_next(blk)) {
578 * ...
581 BlockBackend *blk_next(BlockBackend *blk)
583 GLOBAL_STATE_CODE();
584 return blk ? QTAILQ_NEXT(blk, monitor_link)
585 : QTAILQ_FIRST(&monitor_block_backends);
588 /* Iterates over all top-level BlockDriverStates, i.e. BDSs that are owned by
589 * the monitor or attached to a BlockBackend */
590 BlockDriverState *bdrv_next(BdrvNextIterator *it)
592 BlockDriverState *bs, *old_bs;
594 /* Must be called from the main loop */
595 assert(qemu_get_current_aio_context() == qemu_get_aio_context());
597 /* First, return all root nodes of BlockBackends. In order to avoid
598 * returning a BDS twice when multiple BBs refer to it, we only return it
599 * if the BB is the first one in the parent list of the BDS. */
600 if (it->phase == BDRV_NEXT_BACKEND_ROOTS) {
601 BlockBackend *old_blk = it->blk;
603 old_bs = old_blk ? blk_bs(old_blk) : NULL;
605 do {
606 it->blk = blk_all_next(it->blk);
607 bs = it->blk ? blk_bs(it->blk) : NULL;
608 } while (it->blk && (bs == NULL || bdrv_first_blk(bs) != it->blk));
610 if (it->blk) {
611 blk_ref(it->blk);
613 blk_unref(old_blk);
615 if (bs) {
616 bdrv_ref(bs);
617 bdrv_unref(old_bs);
618 return bs;
620 it->phase = BDRV_NEXT_MONITOR_OWNED;
621 } else {
622 old_bs = it->bs;
625 /* Then return the monitor-owned BDSes without a BB attached. Ignore all
626 * BDSes that are attached to a BlockBackend here; they have been handled
627 * by the above block already */
628 do {
629 it->bs = bdrv_next_monitor_owned(it->bs);
630 bs = it->bs;
631 } while (bs && bdrv_has_blk(bs));
633 if (bs) {
634 bdrv_ref(bs);
636 bdrv_unref(old_bs);
638 return bs;
641 static void bdrv_next_reset(BdrvNextIterator *it)
643 *it = (BdrvNextIterator) {
644 .phase = BDRV_NEXT_BACKEND_ROOTS,
648 BlockDriverState *bdrv_first(BdrvNextIterator *it)
650 GLOBAL_STATE_CODE();
651 bdrv_next_reset(it);
652 return bdrv_next(it);
655 /* Must be called when aborting a bdrv_next() iteration before
656 * bdrv_next() returns NULL */
657 void bdrv_next_cleanup(BdrvNextIterator *it)
659 /* Must be called from the main loop */
660 assert(qemu_get_current_aio_context() == qemu_get_aio_context());
662 if (it->phase == BDRV_NEXT_BACKEND_ROOTS) {
663 if (it->blk) {
664 bdrv_unref(blk_bs(it->blk));
665 blk_unref(it->blk);
667 } else {
668 bdrv_unref(it->bs);
671 bdrv_next_reset(it);
675 * Add a BlockBackend into the list of backends referenced by the monitor, with
676 * the given @name acting as the handle for the monitor.
677 * Strictly for use by blockdev.c.
679 * @name must not be null or empty.
681 * Returns true on success and false on failure. In the latter case, an Error
682 * object is returned through @errp.
684 bool monitor_add_blk(BlockBackend *blk, const char *name, Error **errp)
686 assert(!blk->name);
687 assert(name && name[0]);
688 GLOBAL_STATE_CODE();
690 if (!id_wellformed(name)) {
691 error_setg(errp, "Invalid device name");
692 return false;
694 if (blk_by_name(name)) {
695 error_setg(errp, "Device with id '%s' already exists", name);
696 return false;
698 if (bdrv_find_node(name)) {
699 error_setg(errp,
700 "Device name '%s' conflicts with an existing node name",
701 name);
702 return false;
705 blk->name = g_strdup(name);
706 QTAILQ_INSERT_TAIL(&monitor_block_backends, blk, monitor_link);
707 return true;
711 * Remove a BlockBackend from the list of backends referenced by the monitor.
712 * Strictly for use by blockdev.c.
714 void monitor_remove_blk(BlockBackend *blk)
716 GLOBAL_STATE_CODE();
718 if (!blk->name) {
719 return;
722 QTAILQ_REMOVE(&monitor_block_backends, blk, monitor_link);
723 g_free(blk->name);
724 blk->name = NULL;
728 * Return @blk's name, a non-null string.
729 * Returns an empty string iff @blk is not referenced by the monitor.
731 const char *blk_name(const BlockBackend *blk)
733 IO_CODE();
734 return blk->name ?: "";
738 * Return the BlockBackend with name @name if it exists, else null.
739 * @name must not be null.
741 BlockBackend *blk_by_name(const char *name)
743 BlockBackend *blk = NULL;
745 GLOBAL_STATE_CODE();
746 assert(name);
747 while ((blk = blk_next(blk)) != NULL) {
748 if (!strcmp(name, blk->name)) {
749 return blk;
752 return NULL;
756 * Return the BlockDriverState attached to @blk if any, else null.
758 BlockDriverState *blk_bs(BlockBackend *blk)
760 IO_CODE();
761 return blk->root ? blk->root->bs : NULL;
764 static BlockBackend *bdrv_first_blk(BlockDriverState *bs)
766 BdrvChild *child;
768 GLOBAL_STATE_CODE();
770 QLIST_FOREACH(child, &bs->parents, next_parent) {
771 if (child->klass == &child_root) {
772 return child->opaque;
776 return NULL;
780 * Returns true if @bs has an associated BlockBackend.
782 bool bdrv_has_blk(BlockDriverState *bs)
784 GLOBAL_STATE_CODE();
785 return bdrv_first_blk(bs) != NULL;
789 * Returns true if @bs has only BlockBackends as parents.
791 bool bdrv_is_root_node(BlockDriverState *bs)
793 BdrvChild *c;
795 GLOBAL_STATE_CODE();
796 QLIST_FOREACH(c, &bs->parents, next_parent) {
797 if (c->klass != &child_root) {
798 return false;
802 return true;
806 * Return @blk's DriveInfo if any, else null.
808 DriveInfo *blk_legacy_dinfo(BlockBackend *blk)
810 GLOBAL_STATE_CODE();
811 return blk->legacy_dinfo;
815 * Set @blk's DriveInfo to @dinfo, and return it.
816 * @blk must not have a DriveInfo set already.
817 * No other BlockBackend may have the same DriveInfo set.
819 DriveInfo *blk_set_legacy_dinfo(BlockBackend *blk, DriveInfo *dinfo)
821 assert(!blk->legacy_dinfo);
822 GLOBAL_STATE_CODE();
823 return blk->legacy_dinfo = dinfo;
827 * Return the BlockBackend with DriveInfo @dinfo.
828 * It must exist.
830 BlockBackend *blk_by_legacy_dinfo(DriveInfo *dinfo)
832 BlockBackend *blk = NULL;
833 GLOBAL_STATE_CODE();
835 while ((blk = blk_next(blk)) != NULL) {
836 if (blk->legacy_dinfo == dinfo) {
837 return blk;
840 abort();
844 * Returns a pointer to the publicly accessible fields of @blk.
846 BlockBackendPublic *blk_get_public(BlockBackend *blk)
848 GLOBAL_STATE_CODE();
849 return &blk->public;
853 * Returns a BlockBackend given the associated @public fields.
855 BlockBackend *blk_by_public(BlockBackendPublic *public)
857 GLOBAL_STATE_CODE();
858 return container_of(public, BlockBackend, public);
862 * Disassociates the currently associated BlockDriverState from @blk.
864 void blk_remove_bs(BlockBackend *blk)
866 ThrottleGroupMember *tgm = &blk->public.throttle_group_member;
867 BdrvChild *root;
869 GLOBAL_STATE_CODE();
871 notifier_list_notify(&blk->remove_bs_notifiers, blk);
872 if (tgm->throttle_state) {
873 BlockDriverState *bs = blk_bs(blk);
876 * Take a ref in case blk_bs() changes across bdrv_drained_begin(), for
877 * example, if a temporary filter node is removed by a blockjob.
879 bdrv_ref(bs);
880 bdrv_drained_begin(bs);
881 throttle_group_detach_aio_context(tgm);
882 throttle_group_attach_aio_context(tgm, qemu_get_aio_context());
883 bdrv_drained_end(bs);
884 bdrv_unref(bs);
887 blk_update_root_state(blk);
889 /* bdrv_root_unref_child() will cause blk->root to become stale and may
890 * switch to a completion coroutine later on. Let's drain all I/O here
891 * to avoid that and a potential QEMU crash.
893 blk_drain(blk);
894 root = blk->root;
895 blk->root = NULL;
896 bdrv_root_unref_child(root);
900 * Associates a new BlockDriverState with @blk.
902 int blk_insert_bs(BlockBackend *blk, BlockDriverState *bs, Error **errp)
904 ThrottleGroupMember *tgm = &blk->public.throttle_group_member;
905 GLOBAL_STATE_CODE();
906 bdrv_ref(bs);
907 blk->root = bdrv_root_attach_child(bs, "root", &child_root,
908 BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY,
909 blk->perm, blk->shared_perm,
910 blk, errp);
911 if (blk->root == NULL) {
912 return -EPERM;
915 notifier_list_notify(&blk->insert_bs_notifiers, blk);
916 if (tgm->throttle_state) {
917 throttle_group_detach_aio_context(tgm);
918 throttle_group_attach_aio_context(tgm, bdrv_get_aio_context(bs));
921 return 0;
925 * Change BlockDriverState associated with @blk.
927 int blk_replace_bs(BlockBackend *blk, BlockDriverState *new_bs, Error **errp)
929 GLOBAL_STATE_CODE();
930 return bdrv_replace_child_bs(blk->root, new_bs, errp);
934 * Sets the permission bitmasks that the user of the BlockBackend needs.
936 int blk_set_perm(BlockBackend *blk, uint64_t perm, uint64_t shared_perm,
937 Error **errp)
939 int ret;
940 GLOBAL_STATE_CODE();
942 if (blk->root && !blk->disable_perm) {
943 ret = bdrv_child_try_set_perm(blk->root, perm, shared_perm, errp);
944 if (ret < 0) {
945 return ret;
949 blk->perm = perm;
950 blk->shared_perm = shared_perm;
952 return 0;
955 void blk_get_perm(BlockBackend *blk, uint64_t *perm, uint64_t *shared_perm)
957 GLOBAL_STATE_CODE();
958 *perm = blk->perm;
959 *shared_perm = blk->shared_perm;
963 * Attach device model @dev to @blk.
964 * Return 0 on success, -EBUSY when a device model is attached already.
966 int blk_attach_dev(BlockBackend *blk, DeviceState *dev)
968 GLOBAL_STATE_CODE();
969 if (blk->dev) {
970 return -EBUSY;
973 /* While migration is still incoming, we don't need to apply the
974 * permissions of guest device BlockBackends. We might still have a block
975 * job or NBD server writing to the image for storage migration. */
976 if (runstate_check(RUN_STATE_INMIGRATE)) {
977 blk->disable_perm = true;
980 blk_ref(blk);
981 blk->dev = dev;
982 blk_iostatus_reset(blk);
984 return 0;
988 * Detach device model @dev from @blk.
989 * @dev must be currently attached to @blk.
991 void blk_detach_dev(BlockBackend *blk, DeviceState *dev)
993 assert(blk->dev == dev);
994 GLOBAL_STATE_CODE();
995 blk->dev = NULL;
996 blk->dev_ops = NULL;
997 blk->dev_opaque = NULL;
998 blk_set_perm(blk, 0, BLK_PERM_ALL, &error_abort);
999 blk_unref(blk);
1003 * Return the device model attached to @blk if any, else null.
1005 DeviceState *blk_get_attached_dev(BlockBackend *blk)
1007 GLOBAL_STATE_CODE();
1008 return blk->dev;
1011 /* Return the qdev ID, or if no ID is assigned the QOM path, of the block
1012 * device attached to the BlockBackend. */
1013 char *blk_get_attached_dev_id(BlockBackend *blk)
1015 DeviceState *dev = blk->dev;
1016 IO_CODE();
1018 if (!dev) {
1019 return g_strdup("");
1020 } else if (dev->id) {
1021 return g_strdup(dev->id);
1024 return object_get_canonical_path(OBJECT(dev)) ?: g_strdup("");
1028 * Return the BlockBackend which has the device model @dev attached if it
1029 * exists, else null.
1031 * @dev must not be null.
1033 BlockBackend *blk_by_dev(void *dev)
1035 BlockBackend *blk = NULL;
1037 GLOBAL_STATE_CODE();
1039 assert(dev != NULL);
1040 while ((blk = blk_all_next(blk)) != NULL) {
1041 if (blk->dev == dev) {
1042 return blk;
1045 return NULL;
1049 * Set @blk's device model callbacks to @ops.
1050 * @opaque is the opaque argument to pass to the callbacks.
1051 * This is for use by device models.
1053 void blk_set_dev_ops(BlockBackend *blk, const BlockDevOps *ops,
1054 void *opaque)
1056 GLOBAL_STATE_CODE();
1057 blk->dev_ops = ops;
1058 blk->dev_opaque = opaque;
1060 /* Are we currently quiesced? Should we enforce this right now? */
1061 if (blk->quiesce_counter && ops && ops->drained_begin) {
1062 ops->drained_begin(opaque);
1067 * Notify @blk's attached device model of media change.
1069 * If @load is true, notify of media load. This action can fail, meaning that
1070 * the medium cannot be loaded. @errp is set then.
1072 * If @load is false, notify of media eject. This can never fail.
1074 * Also send DEVICE_TRAY_MOVED events as appropriate.
1076 void blk_dev_change_media_cb(BlockBackend *blk, bool load, Error **errp)
1078 GLOBAL_STATE_CODE();
1079 if (blk->dev_ops && blk->dev_ops->change_media_cb) {
1080 bool tray_was_open, tray_is_open;
1081 Error *local_err = NULL;
1083 tray_was_open = blk_dev_is_tray_open(blk);
1084 blk->dev_ops->change_media_cb(blk->dev_opaque, load, &local_err);
1085 if (local_err) {
1086 assert(load == true);
1087 error_propagate(errp, local_err);
1088 return;
1090 tray_is_open = blk_dev_is_tray_open(blk);
1092 if (tray_was_open != tray_is_open) {
1093 char *id = blk_get_attached_dev_id(blk);
1094 qapi_event_send_device_tray_moved(blk_name(blk), id, tray_is_open);
1095 g_free(id);
1100 static void blk_root_change_media(BdrvChild *child, bool load)
1102 blk_dev_change_media_cb(child->opaque, load, NULL);
1106 * Does @blk's attached device model have removable media?
1107 * %true if no device model is attached.
1109 bool blk_dev_has_removable_media(BlockBackend *blk)
1111 GLOBAL_STATE_CODE();
1112 return !blk->dev || (blk->dev_ops && blk->dev_ops->change_media_cb);
1116 * Does @blk's attached device model have a tray?
1118 bool blk_dev_has_tray(BlockBackend *blk)
1120 IO_CODE();
1121 return blk->dev_ops && blk->dev_ops->is_tray_open;
1125 * Notify @blk's attached device model of a media eject request.
1126 * If @force is true, the medium is about to be yanked out forcefully.
1128 void blk_dev_eject_request(BlockBackend *blk, bool force)
1130 GLOBAL_STATE_CODE();
1131 if (blk->dev_ops && blk->dev_ops->eject_request_cb) {
1132 blk->dev_ops->eject_request_cb(blk->dev_opaque, force);
1137 * Does @blk's attached device model have a tray, and is it open?
1139 bool blk_dev_is_tray_open(BlockBackend *blk)
1141 IO_CODE();
1142 if (blk_dev_has_tray(blk)) {
1143 return blk->dev_ops->is_tray_open(blk->dev_opaque);
1145 return false;
1149 * Does @blk's attached device model have the medium locked?
1150 * %false if the device model has no such lock.
1152 bool blk_dev_is_medium_locked(BlockBackend *blk)
1154 GLOBAL_STATE_CODE();
1155 if (blk->dev_ops && blk->dev_ops->is_medium_locked) {
1156 return blk->dev_ops->is_medium_locked(blk->dev_opaque);
1158 return false;
1162 * Notify @blk's attached device model of a backend size change.
1164 static void blk_root_resize(BdrvChild *child)
1166 BlockBackend *blk = child->opaque;
1168 if (blk->dev_ops && blk->dev_ops->resize_cb) {
1169 blk->dev_ops->resize_cb(blk->dev_opaque);
1173 void blk_iostatus_enable(BlockBackend *blk)
1175 GLOBAL_STATE_CODE();
1176 blk->iostatus_enabled = true;
1177 blk->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
1180 /* The I/O status is only enabled if the drive explicitly
1181 * enables it _and_ the VM is configured to stop on errors */
1182 bool blk_iostatus_is_enabled(const BlockBackend *blk)
1184 IO_CODE();
1185 return (blk->iostatus_enabled &&
1186 (blk->on_write_error == BLOCKDEV_ON_ERROR_ENOSPC ||
1187 blk->on_write_error == BLOCKDEV_ON_ERROR_STOP ||
1188 blk->on_read_error == BLOCKDEV_ON_ERROR_STOP));
1191 BlockDeviceIoStatus blk_iostatus(const BlockBackend *blk)
1193 GLOBAL_STATE_CODE();
1194 return blk->iostatus;
1197 void blk_iostatus_disable(BlockBackend *blk)
1199 GLOBAL_STATE_CODE();
1200 blk->iostatus_enabled = false;
1203 void blk_iostatus_reset(BlockBackend *blk)
1205 GLOBAL_STATE_CODE();
1206 if (blk_iostatus_is_enabled(blk)) {
1207 blk->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
1211 void blk_iostatus_set_err(BlockBackend *blk, int error)
1213 IO_CODE();
1214 assert(blk_iostatus_is_enabled(blk));
1215 if (blk->iostatus == BLOCK_DEVICE_IO_STATUS_OK) {
1216 blk->iostatus = error == ENOSPC ? BLOCK_DEVICE_IO_STATUS_NOSPACE :
1217 BLOCK_DEVICE_IO_STATUS_FAILED;
1221 void blk_set_allow_write_beyond_eof(BlockBackend *blk, bool allow)
1223 IO_CODE();
1224 blk->allow_write_beyond_eof = allow;
1227 void blk_set_allow_aio_context_change(BlockBackend *blk, bool allow)
1229 IO_CODE();
1230 blk->allow_aio_context_change = allow;
1233 void blk_set_disable_request_queuing(BlockBackend *blk, bool disable)
1235 IO_CODE();
1236 blk->disable_request_queuing = disable;
1239 static int blk_check_byte_request(BlockBackend *blk, int64_t offset,
1240 int64_t bytes)
1242 int64_t len;
1244 if (bytes < 0) {
1245 return -EIO;
1248 if (!blk_is_available(blk)) {
1249 return -ENOMEDIUM;
1252 if (offset < 0) {
1253 return -EIO;
1256 if (!blk->allow_write_beyond_eof) {
1257 len = blk_getlength(blk);
1258 if (len < 0) {
1259 return len;
1262 if (offset > len || len - offset < bytes) {
1263 return -EIO;
1267 return 0;
1270 /* To be called between exactly one pair of blk_inc/dec_in_flight() */
1271 static void coroutine_fn blk_wait_while_drained(BlockBackend *blk)
1273 assert(blk->in_flight > 0);
1275 if (blk->quiesce_counter && !blk->disable_request_queuing) {
1276 blk_dec_in_flight(blk);
1277 qemu_co_queue_wait(&blk->queued_requests, NULL);
1278 blk_inc_in_flight(blk);
1282 /* To be called between exactly one pair of blk_inc/dec_in_flight() */
1283 static int coroutine_fn
1284 blk_co_do_preadv_part(BlockBackend *blk, int64_t offset, int64_t bytes,
1285 QEMUIOVector *qiov, size_t qiov_offset,
1286 BdrvRequestFlags flags)
1288 int ret;
1289 BlockDriverState *bs;
1290 IO_CODE();
1292 blk_wait_while_drained(blk);
1294 /* Call blk_bs() only after waiting, the graph may have changed */
1295 bs = blk_bs(blk);
1296 trace_blk_co_preadv(blk, bs, offset, bytes, flags);
1298 ret = blk_check_byte_request(blk, offset, bytes);
1299 if (ret < 0) {
1300 return ret;
1303 bdrv_inc_in_flight(bs);
1305 /* throttling disk I/O */
1306 if (blk->public.throttle_group_member.throttle_state) {
1307 throttle_group_co_io_limits_intercept(&blk->public.throttle_group_member,
1308 bytes, false);
1311 ret = bdrv_co_preadv_part(blk->root, offset, bytes, qiov, qiov_offset,
1312 flags);
1313 bdrv_dec_in_flight(bs);
1314 return ret;
1317 int coroutine_fn blk_co_preadv(BlockBackend *blk, int64_t offset,
1318 int64_t bytes, QEMUIOVector *qiov,
1319 BdrvRequestFlags flags)
1321 int ret;
1322 IO_OR_GS_CODE();
1324 blk_inc_in_flight(blk);
1325 ret = blk_co_do_preadv_part(blk, offset, bytes, qiov, 0, flags);
1326 blk_dec_in_flight(blk);
1328 return ret;
1331 int coroutine_fn blk_co_preadv_part(BlockBackend *blk, int64_t offset,
1332 int64_t bytes, QEMUIOVector *qiov,
1333 size_t qiov_offset, BdrvRequestFlags flags)
1335 int ret;
1336 IO_OR_GS_CODE();
1338 blk_inc_in_flight(blk);
1339 ret = blk_co_do_preadv_part(blk, offset, bytes, qiov, qiov_offset, flags);
1340 blk_dec_in_flight(blk);
1342 return ret;
1345 /* To be called between exactly one pair of blk_inc/dec_in_flight() */
1346 int coroutine_fn
1347 blk_co_do_pwritev_part(BlockBackend *blk, int64_t offset, int64_t bytes,
1348 QEMUIOVector *qiov, size_t qiov_offset,
1349 BdrvRequestFlags flags)
1351 int ret;
1352 BlockDriverState *bs;
1353 IO_CODE();
1355 blk_wait_while_drained(blk);
1357 /* Call blk_bs() only after waiting, the graph may have changed */
1358 bs = blk_bs(blk);
1359 trace_blk_co_pwritev(blk, bs, offset, bytes, flags);
1361 ret = blk_check_byte_request(blk, offset, bytes);
1362 if (ret < 0) {
1363 return ret;
1366 bdrv_inc_in_flight(bs);
1367 /* throttling disk I/O */
1368 if (blk->public.throttle_group_member.throttle_state) {
1369 throttle_group_co_io_limits_intercept(&blk->public.throttle_group_member,
1370 bytes, true);
1373 if (!blk->enable_write_cache) {
1374 flags |= BDRV_REQ_FUA;
1377 ret = bdrv_co_pwritev_part(blk->root, offset, bytes, qiov, qiov_offset,
1378 flags);
1379 bdrv_dec_in_flight(bs);
1380 return ret;
1383 int coroutine_fn blk_co_pwritev_part(BlockBackend *blk, int64_t offset,
1384 int64_t bytes,
1385 QEMUIOVector *qiov, size_t qiov_offset,
1386 BdrvRequestFlags flags)
1388 int ret;
1389 IO_OR_GS_CODE();
1391 blk_inc_in_flight(blk);
1392 ret = blk_co_do_pwritev_part(blk, offset, bytes, qiov, qiov_offset, flags);
1393 blk_dec_in_flight(blk);
1395 return ret;
1398 int coroutine_fn blk_co_pwritev(BlockBackend *blk, int64_t offset,
1399 int64_t bytes, QEMUIOVector *qiov,
1400 BdrvRequestFlags flags)
1402 IO_OR_GS_CODE();
1403 return blk_co_pwritev_part(blk, offset, bytes, qiov, 0, flags);
1406 typedef struct BlkRwCo {
1407 BlockBackend *blk;
1408 int64_t offset;
1409 void *iobuf;
1410 int ret;
1411 BdrvRequestFlags flags;
1412 } BlkRwCo;
1414 int blk_make_zero(BlockBackend *blk, BdrvRequestFlags flags)
1416 GLOBAL_STATE_CODE();
1417 return bdrv_make_zero(blk->root, flags);
1420 void blk_inc_in_flight(BlockBackend *blk)
1422 IO_CODE();
1423 qatomic_inc(&blk->in_flight);
1426 void blk_dec_in_flight(BlockBackend *blk)
1428 IO_CODE();
1429 qatomic_dec(&blk->in_flight);
1430 aio_wait_kick();
1433 static void error_callback_bh(void *opaque)
1435 struct BlockBackendAIOCB *acb = opaque;
1437 blk_dec_in_flight(acb->blk);
1438 acb->common.cb(acb->common.opaque, acb->ret);
1439 qemu_aio_unref(acb);
1442 BlockAIOCB *blk_abort_aio_request(BlockBackend *blk,
1443 BlockCompletionFunc *cb,
1444 void *opaque, int ret)
1446 struct BlockBackendAIOCB *acb;
1447 IO_CODE();
1449 blk_inc_in_flight(blk);
1450 acb = blk_aio_get(&block_backend_aiocb_info, blk, cb, opaque);
1451 acb->blk = blk;
1452 acb->ret = ret;
1454 replay_bh_schedule_oneshot_event(blk_get_aio_context(blk),
1455 error_callback_bh, acb);
1456 return &acb->common;
1459 typedef struct BlkAioEmAIOCB {
1460 BlockAIOCB common;
1461 BlkRwCo rwco;
1462 int64_t bytes;
1463 bool has_returned;
1464 } BlkAioEmAIOCB;
1466 static AioContext *blk_aio_em_aiocb_get_aio_context(BlockAIOCB *acb_)
1468 BlkAioEmAIOCB *acb = container_of(acb_, BlkAioEmAIOCB, common);
1470 return blk_get_aio_context(acb->rwco.blk);
1473 static const AIOCBInfo blk_aio_em_aiocb_info = {
1474 .aiocb_size = sizeof(BlkAioEmAIOCB),
1475 .get_aio_context = blk_aio_em_aiocb_get_aio_context,
1478 static void blk_aio_complete(BlkAioEmAIOCB *acb)
1480 if (acb->has_returned) {
1481 acb->common.cb(acb->common.opaque, acb->rwco.ret);
1482 blk_dec_in_flight(acb->rwco.blk);
1483 qemu_aio_unref(acb);
1487 static void blk_aio_complete_bh(void *opaque)
1489 BlkAioEmAIOCB *acb = opaque;
1490 assert(acb->has_returned);
1491 blk_aio_complete(acb);
1494 static BlockAIOCB *blk_aio_prwv(BlockBackend *blk, int64_t offset,
1495 int64_t bytes,
1496 void *iobuf, CoroutineEntry co_entry,
1497 BdrvRequestFlags flags,
1498 BlockCompletionFunc *cb, void *opaque)
1500 BlkAioEmAIOCB *acb;
1501 Coroutine *co;
1503 blk_inc_in_flight(blk);
1504 acb = blk_aio_get(&blk_aio_em_aiocb_info, blk, cb, opaque);
1505 acb->rwco = (BlkRwCo) {
1506 .blk = blk,
1507 .offset = offset,
1508 .iobuf = iobuf,
1509 .flags = flags,
1510 .ret = NOT_DONE,
1512 acb->bytes = bytes;
1513 acb->has_returned = false;
1515 co = qemu_coroutine_create(co_entry, acb);
1516 bdrv_coroutine_enter(blk_bs(blk), co);
1518 acb->has_returned = true;
1519 if (acb->rwco.ret != NOT_DONE) {
1520 replay_bh_schedule_oneshot_event(blk_get_aio_context(blk),
1521 blk_aio_complete_bh, acb);
1524 return &acb->common;
1527 static void blk_aio_read_entry(void *opaque)
1529 BlkAioEmAIOCB *acb = opaque;
1530 BlkRwCo *rwco = &acb->rwco;
1531 QEMUIOVector *qiov = rwco->iobuf;
1533 assert(qiov->size == acb->bytes);
1534 rwco->ret = blk_co_do_preadv_part(rwco->blk, rwco->offset, acb->bytes, qiov,
1535 0, rwco->flags);
1536 blk_aio_complete(acb);
1539 static void blk_aio_write_entry(void *opaque)
1541 BlkAioEmAIOCB *acb = opaque;
1542 BlkRwCo *rwco = &acb->rwco;
1543 QEMUIOVector *qiov = rwco->iobuf;
1545 assert(!qiov || qiov->size == acb->bytes);
1546 rwco->ret = blk_co_do_pwritev_part(rwco->blk, rwco->offset, acb->bytes,
1547 qiov, 0, rwco->flags);
1548 blk_aio_complete(acb);
1551 BlockAIOCB *blk_aio_pwrite_zeroes(BlockBackend *blk, int64_t offset,
1552 int64_t bytes, BdrvRequestFlags flags,
1553 BlockCompletionFunc *cb, void *opaque)
1555 IO_CODE();
1556 return blk_aio_prwv(blk, offset, bytes, NULL, blk_aio_write_entry,
1557 flags | BDRV_REQ_ZERO_WRITE, cb, opaque);
1560 int64_t blk_getlength(BlockBackend *blk)
1562 IO_CODE();
1563 if (!blk_is_available(blk)) {
1564 return -ENOMEDIUM;
1567 return bdrv_getlength(blk_bs(blk));
1570 void blk_get_geometry(BlockBackend *blk, uint64_t *nb_sectors_ptr)
1572 IO_CODE();
1573 if (!blk_bs(blk)) {
1574 *nb_sectors_ptr = 0;
1575 } else {
1576 bdrv_get_geometry(blk_bs(blk), nb_sectors_ptr);
1580 int64_t blk_nb_sectors(BlockBackend *blk)
1582 IO_CODE();
1583 if (!blk_is_available(blk)) {
1584 return -ENOMEDIUM;
1587 return bdrv_nb_sectors(blk_bs(blk));
1590 BlockAIOCB *blk_aio_preadv(BlockBackend *blk, int64_t offset,
1591 QEMUIOVector *qiov, BdrvRequestFlags flags,
1592 BlockCompletionFunc *cb, void *opaque)
1594 IO_CODE();
1595 assert((uint64_t)qiov->size <= INT64_MAX);
1596 return blk_aio_prwv(blk, offset, qiov->size, qiov,
1597 blk_aio_read_entry, flags, cb, opaque);
1600 BlockAIOCB *blk_aio_pwritev(BlockBackend *blk, int64_t offset,
1601 QEMUIOVector *qiov, BdrvRequestFlags flags,
1602 BlockCompletionFunc *cb, void *opaque)
1604 IO_CODE();
1605 assert((uint64_t)qiov->size <= INT64_MAX);
1606 return blk_aio_prwv(blk, offset, qiov->size, qiov,
1607 blk_aio_write_entry, flags, cb, opaque);
1610 void blk_aio_cancel(BlockAIOCB *acb)
1612 GLOBAL_STATE_CODE();
1613 bdrv_aio_cancel(acb);
1616 void blk_aio_cancel_async(BlockAIOCB *acb)
1618 IO_CODE();
1619 bdrv_aio_cancel_async(acb);
1622 /* To be called between exactly one pair of blk_inc/dec_in_flight() */
1623 int coroutine_fn
1624 blk_co_do_ioctl(BlockBackend *blk, unsigned long int req, void *buf)
1626 IO_CODE();
1628 blk_wait_while_drained(blk);
1630 if (!blk_is_available(blk)) {
1631 return -ENOMEDIUM;
1634 return bdrv_co_ioctl(blk_bs(blk), req, buf);
1637 int blk_ioctl(BlockBackend *blk, unsigned long int req, void *buf)
1639 int ret;
1640 IO_OR_GS_CODE();
1642 blk_inc_in_flight(blk);
1643 ret = blk_do_ioctl(blk, req, buf);
1644 blk_dec_in_flight(blk);
1646 return ret;
1649 static void blk_aio_ioctl_entry(void *opaque)
1651 BlkAioEmAIOCB *acb = opaque;
1652 BlkRwCo *rwco = &acb->rwco;
1654 rwco->ret = blk_co_do_ioctl(rwco->blk, rwco->offset, rwco->iobuf);
1656 blk_aio_complete(acb);
1659 BlockAIOCB *blk_aio_ioctl(BlockBackend *blk, unsigned long int req, void *buf,
1660 BlockCompletionFunc *cb, void *opaque)
1662 IO_CODE();
1663 return blk_aio_prwv(blk, req, 0, buf, blk_aio_ioctl_entry, 0, cb, opaque);
1666 /* To be called between exactly one pair of blk_inc/dec_in_flight() */
1667 int coroutine_fn
1668 blk_co_do_pdiscard(BlockBackend *blk, int64_t offset, int64_t bytes)
1670 int ret;
1671 IO_CODE();
1673 blk_wait_while_drained(blk);
1675 ret = blk_check_byte_request(blk, offset, bytes);
1676 if (ret < 0) {
1677 return ret;
1680 return bdrv_co_pdiscard(blk->root, offset, bytes);
1683 static void blk_aio_pdiscard_entry(void *opaque)
1685 BlkAioEmAIOCB *acb = opaque;
1686 BlkRwCo *rwco = &acb->rwco;
1688 rwco->ret = blk_co_do_pdiscard(rwco->blk, rwco->offset, acb->bytes);
1689 blk_aio_complete(acb);
1692 BlockAIOCB *blk_aio_pdiscard(BlockBackend *blk,
1693 int64_t offset, int64_t bytes,
1694 BlockCompletionFunc *cb, void *opaque)
1696 IO_CODE();
1697 return blk_aio_prwv(blk, offset, bytes, NULL, blk_aio_pdiscard_entry, 0,
1698 cb, opaque);
1701 int coroutine_fn blk_co_pdiscard(BlockBackend *blk, int64_t offset,
1702 int64_t bytes)
1704 int ret;
1705 IO_OR_GS_CODE();
1707 blk_inc_in_flight(blk);
1708 ret = blk_co_do_pdiscard(blk, offset, bytes);
1709 blk_dec_in_flight(blk);
1711 return ret;
1714 /* To be called between exactly one pair of blk_inc/dec_in_flight() */
1715 int coroutine_fn blk_co_do_flush(BlockBackend *blk)
1717 blk_wait_while_drained(blk);
1718 IO_CODE();
1720 if (!blk_is_available(blk)) {
1721 return -ENOMEDIUM;
1724 return bdrv_co_flush(blk_bs(blk));
1727 static void blk_aio_flush_entry(void *opaque)
1729 BlkAioEmAIOCB *acb = opaque;
1730 BlkRwCo *rwco = &acb->rwco;
1732 rwco->ret = blk_co_do_flush(rwco->blk);
1733 blk_aio_complete(acb);
1736 BlockAIOCB *blk_aio_flush(BlockBackend *blk,
1737 BlockCompletionFunc *cb, void *opaque)
1739 IO_CODE();
1740 return blk_aio_prwv(blk, 0, 0, NULL, blk_aio_flush_entry, 0, cb, opaque);
1743 int coroutine_fn blk_co_flush(BlockBackend *blk)
1745 int ret;
1746 IO_OR_GS_CODE();
1748 blk_inc_in_flight(blk);
1749 ret = blk_co_do_flush(blk);
1750 blk_dec_in_flight(blk);
1752 return ret;
1755 void blk_drain(BlockBackend *blk)
1757 BlockDriverState *bs = blk_bs(blk);
1758 GLOBAL_STATE_CODE();
1760 if (bs) {
1761 bdrv_ref(bs);
1762 bdrv_drained_begin(bs);
1765 /* We may have -ENOMEDIUM completions in flight */
1766 AIO_WAIT_WHILE(blk_get_aio_context(blk),
1767 qatomic_mb_read(&blk->in_flight) > 0);
1769 if (bs) {
1770 bdrv_drained_end(bs);
1771 bdrv_unref(bs);
1775 void blk_drain_all(void)
1777 BlockBackend *blk = NULL;
1779 GLOBAL_STATE_CODE();
1781 bdrv_drain_all_begin();
1783 while ((blk = blk_all_next(blk)) != NULL) {
1784 AioContext *ctx = blk_get_aio_context(blk);
1786 aio_context_acquire(ctx);
1788 /* We may have -ENOMEDIUM completions in flight */
1789 AIO_WAIT_WHILE(ctx, qatomic_mb_read(&blk->in_flight) > 0);
1791 aio_context_release(ctx);
1794 bdrv_drain_all_end();
1797 void blk_set_on_error(BlockBackend *blk, BlockdevOnError on_read_error,
1798 BlockdevOnError on_write_error)
1800 GLOBAL_STATE_CODE();
1801 blk->on_read_error = on_read_error;
1802 blk->on_write_error = on_write_error;
1805 BlockdevOnError blk_get_on_error(BlockBackend *blk, bool is_read)
1807 IO_CODE();
1808 return is_read ? blk->on_read_error : blk->on_write_error;
1811 BlockErrorAction blk_get_error_action(BlockBackend *blk, bool is_read,
1812 int error)
1814 BlockdevOnError on_err = blk_get_on_error(blk, is_read);
1815 IO_CODE();
1817 switch (on_err) {
1818 case BLOCKDEV_ON_ERROR_ENOSPC:
1819 return (error == ENOSPC) ?
1820 BLOCK_ERROR_ACTION_STOP : BLOCK_ERROR_ACTION_REPORT;
1821 case BLOCKDEV_ON_ERROR_STOP:
1822 return BLOCK_ERROR_ACTION_STOP;
1823 case BLOCKDEV_ON_ERROR_REPORT:
1824 return BLOCK_ERROR_ACTION_REPORT;
1825 case BLOCKDEV_ON_ERROR_IGNORE:
1826 return BLOCK_ERROR_ACTION_IGNORE;
1827 case BLOCKDEV_ON_ERROR_AUTO:
1828 default:
1829 abort();
1833 static void send_qmp_error_event(BlockBackend *blk,
1834 BlockErrorAction action,
1835 bool is_read, int error)
1837 IoOperationType optype;
1838 BlockDriverState *bs = blk_bs(blk);
1840 optype = is_read ? IO_OPERATION_TYPE_READ : IO_OPERATION_TYPE_WRITE;
1841 qapi_event_send_block_io_error(blk_name(blk), !!bs,
1842 bs ? bdrv_get_node_name(bs) : NULL, optype,
1843 action, blk_iostatus_is_enabled(blk),
1844 error == ENOSPC, strerror(error));
1847 /* This is done by device models because, while the block layer knows
1848 * about the error, it does not know whether an operation comes from
1849 * the device or the block layer (from a job, for example).
1851 void blk_error_action(BlockBackend *blk, BlockErrorAction action,
1852 bool is_read, int error)
1854 assert(error >= 0);
1855 IO_CODE();
1857 if (action == BLOCK_ERROR_ACTION_STOP) {
1858 /* First set the iostatus, so that "info block" returns an iostatus
1859 * that matches the events raised so far (an additional error iostatus
1860 * is fine, but not a lost one).
1862 blk_iostatus_set_err(blk, error);
1864 /* Then raise the request to stop the VM and the event.
1865 * qemu_system_vmstop_request_prepare has two effects. First,
1866 * it ensures that the STOP event always comes after the
1867 * BLOCK_IO_ERROR event. Second, it ensures that even if management
1868 * can observe the STOP event and do a "cont" before the STOP
1869 * event is issued, the VM will not stop. In this case, vm_start()
1870 * also ensures that the STOP/RESUME pair of events is emitted.
1872 qemu_system_vmstop_request_prepare();
1873 send_qmp_error_event(blk, action, is_read, error);
1874 qemu_system_vmstop_request(RUN_STATE_IO_ERROR);
1875 } else {
1876 send_qmp_error_event(blk, action, is_read, error);
1881 * Returns true if the BlockBackend can support taking write permissions
1882 * (because its root node is not read-only).
1884 bool blk_supports_write_perm(BlockBackend *blk)
1886 BlockDriverState *bs = blk_bs(blk);
1887 GLOBAL_STATE_CODE();
1889 if (bs) {
1890 return !bdrv_is_read_only(bs);
1891 } else {
1892 return blk->root_state.open_flags & BDRV_O_RDWR;
1897 * Returns true if the BlockBackend can be written to in its current
1898 * configuration (i.e. if write permission have been requested)
1900 bool blk_is_writable(BlockBackend *blk)
1902 IO_CODE();
1903 return blk->perm & BLK_PERM_WRITE;
1906 bool blk_is_sg(BlockBackend *blk)
1908 BlockDriverState *bs = blk_bs(blk);
1909 GLOBAL_STATE_CODE();
1911 if (!bs) {
1912 return false;
1915 return bdrv_is_sg(bs);
1918 bool blk_enable_write_cache(BlockBackend *blk)
1920 IO_CODE();
1921 return blk->enable_write_cache;
1924 void blk_set_enable_write_cache(BlockBackend *blk, bool wce)
1926 GLOBAL_STATE_CODE();
1927 blk->enable_write_cache = wce;
1930 void blk_activate(BlockBackend *blk, Error **errp)
1932 BlockDriverState *bs = blk_bs(blk);
1933 GLOBAL_STATE_CODE();
1935 if (!bs) {
1936 error_setg(errp, "Device '%s' has no medium", blk->name);
1937 return;
1940 bdrv_activate(bs, errp);
1943 bool blk_is_inserted(BlockBackend *blk)
1945 BlockDriverState *bs = blk_bs(blk);
1946 IO_CODE();
1948 return bs && bdrv_is_inserted(bs);
1951 bool blk_is_available(BlockBackend *blk)
1953 IO_CODE();
1954 return blk_is_inserted(blk) && !blk_dev_is_tray_open(blk);
1957 void blk_lock_medium(BlockBackend *blk, bool locked)
1959 BlockDriverState *bs = blk_bs(blk);
1960 IO_CODE();
1962 if (bs) {
1963 bdrv_lock_medium(bs, locked);
1967 void blk_eject(BlockBackend *blk, bool eject_flag)
1969 BlockDriverState *bs = blk_bs(blk);
1970 char *id;
1971 IO_CODE();
1973 if (bs) {
1974 bdrv_eject(bs, eject_flag);
1977 /* Whether or not we ejected on the backend,
1978 * the frontend experienced a tray event. */
1979 id = blk_get_attached_dev_id(blk);
1980 qapi_event_send_device_tray_moved(blk_name(blk), id,
1981 eject_flag);
1982 g_free(id);
1985 int blk_get_flags(BlockBackend *blk)
1987 BlockDriverState *bs = blk_bs(blk);
1988 GLOBAL_STATE_CODE();
1990 if (bs) {
1991 return bdrv_get_flags(bs);
1992 } else {
1993 return blk->root_state.open_flags;
1997 /* Returns the minimum request alignment, in bytes; guaranteed nonzero */
1998 uint32_t blk_get_request_alignment(BlockBackend *blk)
2000 BlockDriverState *bs = blk_bs(blk);
2001 IO_CODE();
2002 return bs ? bs->bl.request_alignment : BDRV_SECTOR_SIZE;
2005 /* Returns the maximum hardware transfer length, in bytes; guaranteed nonzero */
2006 uint64_t blk_get_max_hw_transfer(BlockBackend *blk)
2008 BlockDriverState *bs = blk_bs(blk);
2009 uint64_t max = INT_MAX;
2010 IO_CODE();
2012 if (bs) {
2013 max = MIN_NON_ZERO(max, bs->bl.max_hw_transfer);
2014 max = MIN_NON_ZERO(max, bs->bl.max_transfer);
2016 return ROUND_DOWN(max, blk_get_request_alignment(blk));
2019 /* Returns the maximum transfer length, in bytes; guaranteed nonzero */
2020 uint32_t blk_get_max_transfer(BlockBackend *blk)
2022 BlockDriverState *bs = blk_bs(blk);
2023 uint32_t max = INT_MAX;
2024 IO_CODE();
2026 if (bs) {
2027 max = MIN_NON_ZERO(max, bs->bl.max_transfer);
2029 return ROUND_DOWN(max, blk_get_request_alignment(blk));
2032 int blk_get_max_hw_iov(BlockBackend *blk)
2034 IO_CODE();
2035 return MIN_NON_ZERO(blk->root->bs->bl.max_hw_iov,
2036 blk->root->bs->bl.max_iov);
2039 int blk_get_max_iov(BlockBackend *blk)
2041 IO_CODE();
2042 return blk->root->bs->bl.max_iov;
2045 void *blk_try_blockalign(BlockBackend *blk, size_t size)
2047 IO_CODE();
2048 return qemu_try_blockalign(blk ? blk_bs(blk) : NULL, size);
2051 void *blk_blockalign(BlockBackend *blk, size_t size)
2053 IO_CODE();
2054 return qemu_blockalign(blk ? blk_bs(blk) : NULL, size);
2057 bool blk_op_is_blocked(BlockBackend *blk, BlockOpType op, Error **errp)
2059 BlockDriverState *bs = blk_bs(blk);
2060 GLOBAL_STATE_CODE();
2062 if (!bs) {
2063 return false;
2066 return bdrv_op_is_blocked(bs, op, errp);
2069 void blk_op_unblock(BlockBackend *blk, BlockOpType op, Error *reason)
2071 BlockDriverState *bs = blk_bs(blk);
2072 GLOBAL_STATE_CODE();
2074 if (bs) {
2075 bdrv_op_unblock(bs, op, reason);
2079 void blk_op_block_all(BlockBackend *blk, Error *reason)
2081 BlockDriverState *bs = blk_bs(blk);
2082 GLOBAL_STATE_CODE();
2084 if (bs) {
2085 bdrv_op_block_all(bs, reason);
2089 void blk_op_unblock_all(BlockBackend *blk, Error *reason)
2091 BlockDriverState *bs = blk_bs(blk);
2092 GLOBAL_STATE_CODE();
2094 if (bs) {
2095 bdrv_op_unblock_all(bs, reason);
2099 AioContext *blk_get_aio_context(BlockBackend *blk)
2101 BlockDriverState *bs = blk_bs(blk);
2102 IO_CODE();
2104 if (bs) {
2105 AioContext *ctx = bdrv_get_aio_context(blk_bs(blk));
2106 assert(ctx == blk->ctx);
2109 return blk->ctx;
2112 static AioContext *blk_aiocb_get_aio_context(BlockAIOCB *acb)
2114 BlockBackendAIOCB *blk_acb = DO_UPCAST(BlockBackendAIOCB, common, acb);
2115 return blk_get_aio_context(blk_acb->blk);
2118 static int blk_do_set_aio_context(BlockBackend *blk, AioContext *new_context,
2119 bool update_root_node, Error **errp)
2121 BlockDriverState *bs = blk_bs(blk);
2122 ThrottleGroupMember *tgm = &blk->public.throttle_group_member;
2123 int ret;
2125 if (bs) {
2126 bdrv_ref(bs);
2128 if (update_root_node) {
2129 ret = bdrv_child_try_set_aio_context(bs, new_context, blk->root,
2130 errp);
2131 if (ret < 0) {
2132 bdrv_unref(bs);
2133 return ret;
2136 if (tgm->throttle_state) {
2137 bdrv_drained_begin(bs);
2138 throttle_group_detach_aio_context(tgm);
2139 throttle_group_attach_aio_context(tgm, new_context);
2140 bdrv_drained_end(bs);
2143 bdrv_unref(bs);
2146 blk->ctx = new_context;
2147 return 0;
2150 int blk_set_aio_context(BlockBackend *blk, AioContext *new_context,
2151 Error **errp)
2153 GLOBAL_STATE_CODE();
2154 return blk_do_set_aio_context(blk, new_context, true, errp);
2157 static bool blk_root_can_set_aio_ctx(BdrvChild *child, AioContext *ctx,
2158 GSList **ignore, Error **errp)
2160 BlockBackend *blk = child->opaque;
2162 if (blk->allow_aio_context_change) {
2163 return true;
2166 /* Only manually created BlockBackends that are not attached to anything
2167 * can change their AioContext without updating their user. */
2168 if (!blk->name || blk->dev) {
2169 /* TODO Add BB name/QOM path */
2170 error_setg(errp, "Cannot change iothread of active block backend");
2171 return false;
2174 return true;
2177 static void blk_root_set_aio_ctx(BdrvChild *child, AioContext *ctx,
2178 GSList **ignore)
2180 BlockBackend *blk = child->opaque;
2181 blk_do_set_aio_context(blk, ctx, false, &error_abort);
2184 void blk_add_aio_context_notifier(BlockBackend *blk,
2185 void (*attached_aio_context)(AioContext *new_context, void *opaque),
2186 void (*detach_aio_context)(void *opaque), void *opaque)
2188 BlockBackendAioNotifier *notifier;
2189 BlockDriverState *bs = blk_bs(blk);
2190 GLOBAL_STATE_CODE();
2192 notifier = g_new(BlockBackendAioNotifier, 1);
2193 notifier->attached_aio_context = attached_aio_context;
2194 notifier->detach_aio_context = detach_aio_context;
2195 notifier->opaque = opaque;
2196 QLIST_INSERT_HEAD(&blk->aio_notifiers, notifier, list);
2198 if (bs) {
2199 bdrv_add_aio_context_notifier(bs, attached_aio_context,
2200 detach_aio_context, opaque);
2204 void blk_remove_aio_context_notifier(BlockBackend *blk,
2205 void (*attached_aio_context)(AioContext *,
2206 void *),
2207 void (*detach_aio_context)(void *),
2208 void *opaque)
2210 BlockBackendAioNotifier *notifier;
2211 BlockDriverState *bs = blk_bs(blk);
2213 GLOBAL_STATE_CODE();
2215 if (bs) {
2216 bdrv_remove_aio_context_notifier(bs, attached_aio_context,
2217 detach_aio_context, opaque);
2220 QLIST_FOREACH(notifier, &blk->aio_notifiers, list) {
2221 if (notifier->attached_aio_context == attached_aio_context &&
2222 notifier->detach_aio_context == detach_aio_context &&
2223 notifier->opaque == opaque) {
2224 QLIST_REMOVE(notifier, list);
2225 g_free(notifier);
2226 return;
2230 abort();
2233 void blk_add_remove_bs_notifier(BlockBackend *blk, Notifier *notify)
2235 GLOBAL_STATE_CODE();
2236 notifier_list_add(&blk->remove_bs_notifiers, notify);
2239 void blk_add_insert_bs_notifier(BlockBackend *blk, Notifier *notify)
2241 GLOBAL_STATE_CODE();
2242 notifier_list_add(&blk->insert_bs_notifiers, notify);
2245 void blk_io_plug(BlockBackend *blk)
2247 BlockDriverState *bs = blk_bs(blk);
2248 IO_CODE();
2250 if (bs) {
2251 bdrv_io_plug(bs);
2255 void blk_io_unplug(BlockBackend *blk)
2257 BlockDriverState *bs = blk_bs(blk);
2258 IO_CODE();
2260 if (bs) {
2261 bdrv_io_unplug(bs);
2265 BlockAcctStats *blk_get_stats(BlockBackend *blk)
2267 IO_CODE();
2268 return &blk->stats;
2271 void *blk_aio_get(const AIOCBInfo *aiocb_info, BlockBackend *blk,
2272 BlockCompletionFunc *cb, void *opaque)
2274 IO_CODE();
2275 return qemu_aio_get(aiocb_info, blk_bs(blk), cb, opaque);
2278 int coroutine_fn blk_co_pwrite_zeroes(BlockBackend *blk, int64_t offset,
2279 int64_t bytes, BdrvRequestFlags flags)
2281 IO_OR_GS_CODE();
2282 return blk_co_pwritev(blk, offset, bytes, NULL,
2283 flags | BDRV_REQ_ZERO_WRITE);
2286 int coroutine_fn blk_co_pwrite_compressed(BlockBackend *blk, int64_t offset,
2287 int64_t bytes, const void *buf)
2289 QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
2290 IO_OR_GS_CODE();
2291 return blk_co_pwritev_part(blk, offset, bytes, &qiov, 0,
2292 BDRV_REQ_WRITE_COMPRESSED);
2295 int blk_truncate(BlockBackend *blk, int64_t offset, bool exact,
2296 PreallocMode prealloc, BdrvRequestFlags flags, Error **errp)
2298 IO_OR_GS_CODE();
2299 if (!blk_is_available(blk)) {
2300 error_setg(errp, "No medium inserted");
2301 return -ENOMEDIUM;
2304 return bdrv_truncate(blk->root, offset, exact, prealloc, flags, errp);
2307 int blk_save_vmstate(BlockBackend *blk, const uint8_t *buf,
2308 int64_t pos, int size)
2310 int ret;
2311 GLOBAL_STATE_CODE();
2313 if (!blk_is_available(blk)) {
2314 return -ENOMEDIUM;
2317 ret = bdrv_save_vmstate(blk_bs(blk), buf, pos, size);
2318 if (ret < 0) {
2319 return ret;
2322 if (ret == size && !blk->enable_write_cache) {
2323 ret = bdrv_flush(blk_bs(blk));
2326 return ret < 0 ? ret : size;
2329 int blk_load_vmstate(BlockBackend *blk, uint8_t *buf, int64_t pos, int size)
2331 GLOBAL_STATE_CODE();
2332 if (!blk_is_available(blk)) {
2333 return -ENOMEDIUM;
2336 return bdrv_load_vmstate(blk_bs(blk), buf, pos, size);
2339 int blk_probe_blocksizes(BlockBackend *blk, BlockSizes *bsz)
2341 GLOBAL_STATE_CODE();
2342 if (!blk_is_available(blk)) {
2343 return -ENOMEDIUM;
2346 return bdrv_probe_blocksizes(blk_bs(blk), bsz);
2349 int blk_probe_geometry(BlockBackend *blk, HDGeometry *geo)
2351 GLOBAL_STATE_CODE();
2352 if (!blk_is_available(blk)) {
2353 return -ENOMEDIUM;
2356 return bdrv_probe_geometry(blk_bs(blk), geo);
2360 * Updates the BlockBackendRootState object with data from the currently
2361 * attached BlockDriverState.
2363 void blk_update_root_state(BlockBackend *blk)
2365 GLOBAL_STATE_CODE();
2366 assert(blk->root);
2368 blk->root_state.open_flags = blk->root->bs->open_flags;
2369 blk->root_state.detect_zeroes = blk->root->bs->detect_zeroes;
2373 * Returns the detect-zeroes setting to be used for bdrv_open() of a
2374 * BlockDriverState which is supposed to inherit the root state.
2376 bool blk_get_detect_zeroes_from_root_state(BlockBackend *blk)
2378 GLOBAL_STATE_CODE();
2379 return blk->root_state.detect_zeroes;
2383 * Returns the flags to be used for bdrv_open() of a BlockDriverState which is
2384 * supposed to inherit the root state.
2386 int blk_get_open_flags_from_root_state(BlockBackend *blk)
2388 GLOBAL_STATE_CODE();
2389 return blk->root_state.open_flags;
2392 BlockBackendRootState *blk_get_root_state(BlockBackend *blk)
2394 GLOBAL_STATE_CODE();
2395 return &blk->root_state;
2398 int blk_commit_all(void)
2400 BlockBackend *blk = NULL;
2401 GLOBAL_STATE_CODE();
2403 while ((blk = blk_all_next(blk)) != NULL) {
2404 AioContext *aio_context = blk_get_aio_context(blk);
2405 BlockDriverState *unfiltered_bs = bdrv_skip_filters(blk_bs(blk));
2407 aio_context_acquire(aio_context);
2408 if (blk_is_inserted(blk) && bdrv_cow_child(unfiltered_bs)) {
2409 int ret;
2411 ret = bdrv_commit(unfiltered_bs);
2412 if (ret < 0) {
2413 aio_context_release(aio_context);
2414 return ret;
2417 aio_context_release(aio_context);
2419 return 0;
2423 /* throttling disk I/O limits */
2424 void blk_set_io_limits(BlockBackend *blk, ThrottleConfig *cfg)
2426 GLOBAL_STATE_CODE();
2427 throttle_group_config(&blk->public.throttle_group_member, cfg);
2430 void blk_io_limits_disable(BlockBackend *blk)
2432 BlockDriverState *bs = blk_bs(blk);
2433 ThrottleGroupMember *tgm = &blk->public.throttle_group_member;
2434 assert(tgm->throttle_state);
2435 GLOBAL_STATE_CODE();
2436 if (bs) {
2437 bdrv_ref(bs);
2438 bdrv_drained_begin(bs);
2440 throttle_group_unregister_tgm(tgm);
2441 if (bs) {
2442 bdrv_drained_end(bs);
2443 bdrv_unref(bs);
2447 /* should be called before blk_set_io_limits if a limit is set */
2448 void blk_io_limits_enable(BlockBackend *blk, const char *group)
2450 assert(!blk->public.throttle_group_member.throttle_state);
2451 GLOBAL_STATE_CODE();
2452 throttle_group_register_tgm(&blk->public.throttle_group_member,
2453 group, blk_get_aio_context(blk));
2456 void blk_io_limits_update_group(BlockBackend *blk, const char *group)
2458 GLOBAL_STATE_CODE();
2459 /* this BB is not part of any group */
2460 if (!blk->public.throttle_group_member.throttle_state) {
2461 return;
2464 /* this BB is a part of the same group than the one we want */
2465 if (!g_strcmp0(throttle_group_get_name(&blk->public.throttle_group_member),
2466 group)) {
2467 return;
2470 /* need to change the group this bs belong to */
2471 blk_io_limits_disable(blk);
2472 blk_io_limits_enable(blk, group);
2475 static void blk_root_drained_begin(BdrvChild *child)
2477 BlockBackend *blk = child->opaque;
2478 ThrottleGroupMember *tgm = &blk->public.throttle_group_member;
2480 if (++blk->quiesce_counter == 1) {
2481 if (blk->dev_ops && blk->dev_ops->drained_begin) {
2482 blk->dev_ops->drained_begin(blk->dev_opaque);
2486 /* Note that blk->root may not be accessible here yet if we are just
2487 * attaching to a BlockDriverState that is drained. Use child instead. */
2489 if (qatomic_fetch_inc(&tgm->io_limits_disabled) == 0) {
2490 throttle_group_restart_tgm(tgm);
2494 static bool blk_root_drained_poll(BdrvChild *child)
2496 BlockBackend *blk = child->opaque;
2497 bool busy = false;
2498 assert(blk->quiesce_counter);
2500 if (blk->dev_ops && blk->dev_ops->drained_poll) {
2501 busy = blk->dev_ops->drained_poll(blk->dev_opaque);
2503 return busy || !!blk->in_flight;
2506 static void blk_root_drained_end(BdrvChild *child, int *drained_end_counter)
2508 BlockBackend *blk = child->opaque;
2509 assert(blk->quiesce_counter);
2511 assert(blk->public.throttle_group_member.io_limits_disabled);
2512 qatomic_dec(&blk->public.throttle_group_member.io_limits_disabled);
2514 if (--blk->quiesce_counter == 0) {
2515 if (blk->dev_ops && blk->dev_ops->drained_end) {
2516 blk->dev_ops->drained_end(blk->dev_opaque);
2518 while (qemu_co_enter_next(&blk->queued_requests, NULL)) {
2519 /* Resume all queued requests */
2524 void blk_register_buf(BlockBackend *blk, void *host, size_t size)
2526 GLOBAL_STATE_CODE();
2527 bdrv_register_buf(blk_bs(blk), host, size);
2530 void blk_unregister_buf(BlockBackend *blk, void *host)
2532 GLOBAL_STATE_CODE();
2533 bdrv_unregister_buf(blk_bs(blk), host);
2536 int coroutine_fn blk_co_copy_range(BlockBackend *blk_in, int64_t off_in,
2537 BlockBackend *blk_out, int64_t off_out,
2538 int64_t bytes, BdrvRequestFlags read_flags,
2539 BdrvRequestFlags write_flags)
2541 int r;
2542 IO_CODE();
2544 r = blk_check_byte_request(blk_in, off_in, bytes);
2545 if (r) {
2546 return r;
2548 r = blk_check_byte_request(blk_out, off_out, bytes);
2549 if (r) {
2550 return r;
2552 return bdrv_co_copy_range(blk_in->root, off_in,
2553 blk_out->root, off_out,
2554 bytes, read_flags, write_flags);
2557 const BdrvChild *blk_root(BlockBackend *blk)
2559 GLOBAL_STATE_CODE();
2560 return blk->root;
2563 int blk_make_empty(BlockBackend *blk, Error **errp)
2565 GLOBAL_STATE_CODE();
2566 if (!blk_is_available(blk)) {
2567 error_setg(errp, "No medium inserted");
2568 return -ENOMEDIUM;
2571 return bdrv_make_empty(blk->root, errp);