gdbstub: Constify GdbCmdParseEntry
[qemu/ar7.git] / block / block-backend.c
blobde5496af66fcd1c57076e38ce66ce9a33128280f
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/throttle-groups.h"
18 #include "hw/qdev-core.h"
19 #include "sysemu/blockdev.h"
20 #include "sysemu/runstate.h"
21 #include "sysemu/replay.h"
22 #include "qapi/error.h"
23 #include "qapi/qapi-events-block.h"
24 #include "qemu/id.h"
25 #include "qemu/main-loop.h"
26 #include "qemu/option.h"
27 #include "trace.h"
28 #include "migration/misc.h"
30 /* Number of coroutines to reserve per attached device model */
31 #define COROUTINE_POOL_RESERVATION 64
33 #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
35 static AioContext *blk_aiocb_get_aio_context(BlockAIOCB *acb);
37 typedef struct BlockBackendAioNotifier {
38 void (*attached_aio_context)(AioContext *new_context, void *opaque);
39 void (*detach_aio_context)(void *opaque);
40 void *opaque;
41 QLIST_ENTRY(BlockBackendAioNotifier) list;
42 } BlockBackendAioNotifier;
44 struct BlockBackend {
45 char *name;
46 int refcnt;
47 BdrvChild *root;
48 AioContext *ctx;
49 DriveInfo *legacy_dinfo; /* null unless created by drive_new() */
50 QTAILQ_ENTRY(BlockBackend) link; /* for block_backends */
51 QTAILQ_ENTRY(BlockBackend) monitor_link; /* for monitor_block_backends */
52 BlockBackendPublic public;
54 DeviceState *dev; /* attached device model, if any */
55 const BlockDevOps *dev_ops;
56 void *dev_opaque;
58 /* the block size for which the guest device expects atomicity */
59 int guest_block_size;
61 /* If the BDS tree is removed, some of its options are stored here (which
62 * can be used to restore those options in the new BDS on insert) */
63 BlockBackendRootState root_state;
65 bool enable_write_cache;
67 /* I/O stats (display with "info blockstats"). */
68 BlockAcctStats stats;
70 BlockdevOnError on_read_error, on_write_error;
71 bool iostatus_enabled;
72 BlockDeviceIoStatus iostatus;
74 uint64_t perm;
75 uint64_t shared_perm;
76 bool disable_perm;
78 bool allow_aio_context_change;
79 bool allow_write_beyond_eof;
81 NotifierList remove_bs_notifiers, insert_bs_notifiers;
82 QLIST_HEAD(, BlockBackendAioNotifier) aio_notifiers;
84 int quiesce_counter;
85 CoQueue queued_requests;
86 bool disable_request_queuing;
88 VMChangeStateEntry *vmsh;
89 bool force_allow_inactivate;
91 /* Number of in-flight aio requests. BlockDriverState also counts
92 * in-flight requests but aio requests can exist even when blk->root is
93 * NULL, so we cannot rely on its counter for that case.
94 * Accessed with atomic ops.
96 unsigned int in_flight;
99 typedef struct BlockBackendAIOCB {
100 BlockAIOCB common;
101 BlockBackend *blk;
102 int ret;
103 } BlockBackendAIOCB;
105 static const AIOCBInfo block_backend_aiocb_info = {
106 .get_aio_context = blk_aiocb_get_aio_context,
107 .aiocb_size = sizeof(BlockBackendAIOCB),
110 static void drive_info_del(DriveInfo *dinfo);
111 static BlockBackend *bdrv_first_blk(BlockDriverState *bs);
113 /* All BlockBackends */
114 static QTAILQ_HEAD(, BlockBackend) block_backends =
115 QTAILQ_HEAD_INITIALIZER(block_backends);
117 /* All BlockBackends referenced by the monitor and which are iterated through by
118 * blk_next() */
119 static QTAILQ_HEAD(, BlockBackend) monitor_block_backends =
120 QTAILQ_HEAD_INITIALIZER(monitor_block_backends);
122 static void blk_root_inherit_options(BdrvChildRole role, bool parent_is_format,
123 int *child_flags, QDict *child_options,
124 int parent_flags, QDict *parent_options)
126 /* We're not supposed to call this function for root nodes */
127 abort();
129 static void blk_root_drained_begin(BdrvChild *child);
130 static bool blk_root_drained_poll(BdrvChild *child);
131 static void blk_root_drained_end(BdrvChild *child, int *drained_end_counter);
133 static void blk_root_change_media(BdrvChild *child, bool load);
134 static void blk_root_resize(BdrvChild *child);
136 static bool blk_root_can_set_aio_ctx(BdrvChild *child, AioContext *ctx,
137 GSList **ignore, Error **errp);
138 static void blk_root_set_aio_ctx(BdrvChild *child, AioContext *ctx,
139 GSList **ignore);
141 static char *blk_root_get_parent_desc(BdrvChild *child)
143 BlockBackend *blk = child->opaque;
144 char *dev_id;
146 if (blk->name) {
147 return g_strdup(blk->name);
150 dev_id = blk_get_attached_dev_id(blk);
151 if (*dev_id) {
152 return dev_id;
153 } else {
154 /* TODO Callback into the BB owner for something more detailed */
155 g_free(dev_id);
156 return g_strdup("a 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;
194 if (!blk->disable_perm) {
195 return;
198 blk->disable_perm = false;
200 blk_set_perm(blk, blk->perm, BLK_PERM_ALL, &local_err);
201 if (local_err) {
202 error_propagate(errp, local_err);
203 blk->disable_perm = true;
204 return;
207 if (runstate_check(RUN_STATE_INMIGRATE)) {
208 /* Activation can happen when migration process is still active, for
209 * example when nbd_server_add is called during non-shared storage
210 * migration. Defer the shared_perm update to migration completion. */
211 if (!blk->vmsh) {
212 blk->vmsh = qemu_add_vm_change_state_handler(blk_vm_state_changed,
213 blk);
215 return;
218 blk_set_perm(blk, blk->perm, blk->shared_perm, &local_err);
219 if (local_err) {
220 error_propagate(errp, local_err);
221 blk->disable_perm = true;
222 return;
226 void blk_set_force_allow_inactivate(BlockBackend *blk)
228 blk->force_allow_inactivate = true;
231 static bool blk_can_inactivate(BlockBackend *blk)
233 /* If it is a guest device, inactivate is ok. */
234 if (blk->dev || blk_name(blk)[0]) {
235 return true;
238 /* Inactivating means no more writes to the image can be done,
239 * even if those writes would be changes invisible to the
240 * guest. For block job BBs that satisfy this, we can just allow
241 * it. This is the case for mirror job source, which is required
242 * by libvirt non-shared block migration. */
243 if (!(blk->perm & (BLK_PERM_WRITE | BLK_PERM_WRITE_UNCHANGED))) {
244 return true;
247 return blk->force_allow_inactivate;
250 static int blk_root_inactivate(BdrvChild *child)
252 BlockBackend *blk = child->opaque;
254 if (blk->disable_perm) {
255 return 0;
258 if (!blk_can_inactivate(blk)) {
259 return -EPERM;
262 blk->disable_perm = true;
263 if (blk->root) {
264 bdrv_child_try_set_perm(blk->root, 0, BLK_PERM_ALL, &error_abort);
267 return 0;
270 static void blk_root_attach(BdrvChild *child)
272 BlockBackend *blk = child->opaque;
273 BlockBackendAioNotifier *notifier;
275 trace_blk_root_attach(child, blk, child->bs);
277 QLIST_FOREACH(notifier, &blk->aio_notifiers, list) {
278 bdrv_add_aio_context_notifier(child->bs,
279 notifier->attached_aio_context,
280 notifier->detach_aio_context,
281 notifier->opaque);
285 static void blk_root_detach(BdrvChild *child)
287 BlockBackend *blk = child->opaque;
288 BlockBackendAioNotifier *notifier;
290 trace_blk_root_detach(child, blk, child->bs);
292 QLIST_FOREACH(notifier, &blk->aio_notifiers, list) {
293 bdrv_remove_aio_context_notifier(child->bs,
294 notifier->attached_aio_context,
295 notifier->detach_aio_context,
296 notifier->opaque);
300 static AioContext *blk_root_get_parent_aio_context(BdrvChild *c)
302 BlockBackend *blk = c->opaque;
304 return blk_get_aio_context(blk);
307 static const BdrvChildClass child_root = {
308 .inherit_options = blk_root_inherit_options,
310 .change_media = blk_root_change_media,
311 .resize = blk_root_resize,
312 .get_name = blk_root_get_name,
313 .get_parent_desc = blk_root_get_parent_desc,
315 .drained_begin = blk_root_drained_begin,
316 .drained_poll = blk_root_drained_poll,
317 .drained_end = blk_root_drained_end,
319 .activate = blk_root_activate,
320 .inactivate = blk_root_inactivate,
322 .attach = blk_root_attach,
323 .detach = blk_root_detach,
325 .can_set_aio_ctx = blk_root_can_set_aio_ctx,
326 .set_aio_ctx = blk_root_set_aio_ctx,
328 .get_parent_aio_context = blk_root_get_parent_aio_context,
332 * Create a new BlockBackend with a reference count of one.
334 * @perm is a bitmasks of BLK_PERM_* constants which describes the permissions
335 * to request for a block driver node that is attached to this BlockBackend.
336 * @shared_perm is a bitmask which describes which permissions may be granted
337 * to other users of the attached node.
338 * Both sets of permissions can be changed later using blk_set_perm().
340 * Return the new BlockBackend on success, null on failure.
342 BlockBackend *blk_new(AioContext *ctx, uint64_t perm, uint64_t shared_perm)
344 BlockBackend *blk;
346 blk = g_new0(BlockBackend, 1);
347 blk->refcnt = 1;
348 blk->ctx = ctx;
349 blk->perm = perm;
350 blk->shared_perm = shared_perm;
351 blk_set_enable_write_cache(blk, true);
353 blk->on_read_error = BLOCKDEV_ON_ERROR_REPORT;
354 blk->on_write_error = BLOCKDEV_ON_ERROR_ENOSPC;
356 block_acct_init(&blk->stats);
358 qemu_co_queue_init(&blk->queued_requests);
359 notifier_list_init(&blk->remove_bs_notifiers);
360 notifier_list_init(&blk->insert_bs_notifiers);
361 QLIST_INIT(&blk->aio_notifiers);
363 QTAILQ_INSERT_TAIL(&block_backends, blk, link);
364 return blk;
368 * Create a new BlockBackend connected to an existing BlockDriverState.
370 * @perm is a bitmasks of BLK_PERM_* constants which describes the
371 * permissions to request for @bs that is attached to this
372 * BlockBackend. @shared_perm is a bitmask which describes which
373 * permissions may be granted to other users of the attached node.
374 * Both sets of permissions can be changed later using blk_set_perm().
376 * Return the new BlockBackend on success, null on failure.
378 BlockBackend *blk_new_with_bs(BlockDriverState *bs, uint64_t perm,
379 uint64_t shared_perm, Error **errp)
381 BlockBackend *blk = blk_new(bdrv_get_aio_context(bs), perm, shared_perm);
383 if (blk_insert_bs(blk, bs, errp) < 0) {
384 blk_unref(blk);
385 return NULL;
387 return blk;
391 * Creates a new BlockBackend, opens a new BlockDriverState, and connects both.
392 * The new BlockBackend is in the main AioContext.
394 * Just as with bdrv_open(), after having called this function the reference to
395 * @options belongs to the block layer (even on failure).
397 * TODO: Remove @filename and @flags; it should be possible to specify a whole
398 * BDS tree just by specifying the @options QDict (or @reference,
399 * alternatively). At the time of adding this function, this is not possible,
400 * though, so callers of this function have to be able to specify @filename and
401 * @flags.
403 BlockBackend *blk_new_open(const char *filename, const char *reference,
404 QDict *options, int flags, Error **errp)
406 BlockBackend *blk;
407 BlockDriverState *bs;
408 uint64_t perm = 0;
409 uint64_t shared = BLK_PERM_ALL;
412 * blk_new_open() is mainly used in .bdrv_create implementations and the
413 * tools where sharing isn't a major concern because the BDS stays private
414 * and the file is generally not supposed to be used by a second process,
415 * so we just request permission according to the flags.
417 * The exceptions are xen_disk and blockdev_init(); in these cases, the
418 * caller of blk_new_open() doesn't make use of the permissions, but they
419 * shouldn't hurt either. We can still share everything here because the
420 * guest devices will add their own blockers if they can't share.
422 if ((flags & BDRV_O_NO_IO) == 0) {
423 perm |= BLK_PERM_CONSISTENT_READ;
424 if (flags & BDRV_O_RDWR) {
425 perm |= BLK_PERM_WRITE;
428 if (flags & BDRV_O_RESIZE) {
429 perm |= BLK_PERM_RESIZE;
431 if (flags & BDRV_O_NO_SHARE) {
432 shared = BLK_PERM_CONSISTENT_READ | BLK_PERM_WRITE_UNCHANGED;
435 blk = blk_new(qemu_get_aio_context(), perm, shared);
436 bs = bdrv_open(filename, reference, options, flags, errp);
437 if (!bs) {
438 blk_unref(blk);
439 return NULL;
442 blk->root = bdrv_root_attach_child(bs, "root", &child_root,
443 BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY,
444 perm, shared, blk, errp);
445 if (!blk->root) {
446 blk_unref(blk);
447 return NULL;
450 return blk;
453 static void blk_delete(BlockBackend *blk)
455 assert(!blk->refcnt);
456 assert(!blk->name);
457 assert(!blk->dev);
458 if (blk->public.throttle_group_member.throttle_state) {
459 blk_io_limits_disable(blk);
461 if (blk->root) {
462 blk_remove_bs(blk);
464 if (blk->vmsh) {
465 qemu_del_vm_change_state_handler(blk->vmsh);
466 blk->vmsh = NULL;
468 assert(QLIST_EMPTY(&blk->remove_bs_notifiers.notifiers));
469 assert(QLIST_EMPTY(&blk->insert_bs_notifiers.notifiers));
470 assert(QLIST_EMPTY(&blk->aio_notifiers));
471 QTAILQ_REMOVE(&block_backends, blk, link);
472 drive_info_del(blk->legacy_dinfo);
473 block_acct_cleanup(&blk->stats);
474 g_free(blk);
477 static void drive_info_del(DriveInfo *dinfo)
479 if (!dinfo) {
480 return;
482 qemu_opts_del(dinfo->opts);
483 g_free(dinfo);
486 int blk_get_refcnt(BlockBackend *blk)
488 return blk ? blk->refcnt : 0;
492 * Increment @blk's reference count.
493 * @blk must not be null.
495 void blk_ref(BlockBackend *blk)
497 assert(blk->refcnt > 0);
498 blk->refcnt++;
502 * Decrement @blk's reference count.
503 * If this drops it to zero, destroy @blk.
504 * For convenience, do nothing if @blk is null.
506 void blk_unref(BlockBackend *blk)
508 if (blk) {
509 assert(blk->refcnt > 0);
510 if (blk->refcnt > 1) {
511 blk->refcnt--;
512 } else {
513 blk_drain(blk);
514 /* blk_drain() cannot resurrect blk, nobody held a reference */
515 assert(blk->refcnt == 1);
516 blk->refcnt = 0;
517 blk_delete(blk);
523 * Behaves similarly to blk_next() but iterates over all BlockBackends, even the
524 * ones which are hidden (i.e. are not referenced by the monitor).
526 BlockBackend *blk_all_next(BlockBackend *blk)
528 return blk ? QTAILQ_NEXT(blk, link)
529 : QTAILQ_FIRST(&block_backends);
532 void blk_remove_all_bs(void)
534 BlockBackend *blk = NULL;
536 while ((blk = blk_all_next(blk)) != NULL) {
537 AioContext *ctx = blk_get_aio_context(blk);
539 aio_context_acquire(ctx);
540 if (blk->root) {
541 blk_remove_bs(blk);
543 aio_context_release(ctx);
548 * Return the monitor-owned BlockBackend after @blk.
549 * If @blk is null, return the first one.
550 * Else, return @blk's next sibling, which may be null.
552 * To iterate over all BlockBackends, do
553 * for (blk = blk_next(NULL); blk; blk = blk_next(blk)) {
554 * ...
557 BlockBackend *blk_next(BlockBackend *blk)
559 return blk ? QTAILQ_NEXT(blk, monitor_link)
560 : QTAILQ_FIRST(&monitor_block_backends);
563 /* Iterates over all top-level BlockDriverStates, i.e. BDSs that are owned by
564 * the monitor or attached to a BlockBackend */
565 BlockDriverState *bdrv_next(BdrvNextIterator *it)
567 BlockDriverState *bs, *old_bs;
569 /* Must be called from the main loop */
570 assert(qemu_get_current_aio_context() == qemu_get_aio_context());
572 /* First, return all root nodes of BlockBackends. In order to avoid
573 * returning a BDS twice when multiple BBs refer to it, we only return it
574 * if the BB is the first one in the parent list of the BDS. */
575 if (it->phase == BDRV_NEXT_BACKEND_ROOTS) {
576 BlockBackend *old_blk = it->blk;
578 old_bs = old_blk ? blk_bs(old_blk) : NULL;
580 do {
581 it->blk = blk_all_next(it->blk);
582 bs = it->blk ? blk_bs(it->blk) : NULL;
583 } while (it->blk && (bs == NULL || bdrv_first_blk(bs) != it->blk));
585 if (it->blk) {
586 blk_ref(it->blk);
588 blk_unref(old_blk);
590 if (bs) {
591 bdrv_ref(bs);
592 bdrv_unref(old_bs);
593 return bs;
595 it->phase = BDRV_NEXT_MONITOR_OWNED;
596 } else {
597 old_bs = it->bs;
600 /* Then return the monitor-owned BDSes without a BB attached. Ignore all
601 * BDSes that are attached to a BlockBackend here; they have been handled
602 * by the above block already */
603 do {
604 it->bs = bdrv_next_monitor_owned(it->bs);
605 bs = it->bs;
606 } while (bs && bdrv_has_blk(bs));
608 if (bs) {
609 bdrv_ref(bs);
611 bdrv_unref(old_bs);
613 return bs;
616 static void bdrv_next_reset(BdrvNextIterator *it)
618 *it = (BdrvNextIterator) {
619 .phase = BDRV_NEXT_BACKEND_ROOTS,
623 BlockDriverState *bdrv_first(BdrvNextIterator *it)
625 bdrv_next_reset(it);
626 return bdrv_next(it);
629 /* Must be called when aborting a bdrv_next() iteration before
630 * bdrv_next() returns NULL */
631 void bdrv_next_cleanup(BdrvNextIterator *it)
633 /* Must be called from the main loop */
634 assert(qemu_get_current_aio_context() == qemu_get_aio_context());
636 if (it->phase == BDRV_NEXT_BACKEND_ROOTS) {
637 if (it->blk) {
638 bdrv_unref(blk_bs(it->blk));
639 blk_unref(it->blk);
641 } else {
642 bdrv_unref(it->bs);
645 bdrv_next_reset(it);
649 * Add a BlockBackend into the list of backends referenced by the monitor, with
650 * the given @name acting as the handle for the monitor.
651 * Strictly for use by blockdev.c.
653 * @name must not be null or empty.
655 * Returns true on success and false on failure. In the latter case, an Error
656 * object is returned through @errp.
658 bool monitor_add_blk(BlockBackend *blk, const char *name, Error **errp)
660 assert(!blk->name);
661 assert(name && name[0]);
663 if (!id_wellformed(name)) {
664 error_setg(errp, "Invalid device name");
665 return false;
667 if (blk_by_name(name)) {
668 error_setg(errp, "Device with id '%s' already exists", name);
669 return false;
671 if (bdrv_find_node(name)) {
672 error_setg(errp,
673 "Device name '%s' conflicts with an existing node name",
674 name);
675 return false;
678 blk->name = g_strdup(name);
679 QTAILQ_INSERT_TAIL(&monitor_block_backends, blk, monitor_link);
680 return true;
684 * Remove a BlockBackend from the list of backends referenced by the monitor.
685 * Strictly for use by blockdev.c.
687 void monitor_remove_blk(BlockBackend *blk)
689 if (!blk->name) {
690 return;
693 QTAILQ_REMOVE(&monitor_block_backends, blk, monitor_link);
694 g_free(blk->name);
695 blk->name = NULL;
699 * Return @blk's name, a non-null string.
700 * Returns an empty string iff @blk is not referenced by the monitor.
702 const char *blk_name(const BlockBackend *blk)
704 return blk->name ?: "";
708 * Return the BlockBackend with name @name if it exists, else null.
709 * @name must not be null.
711 BlockBackend *blk_by_name(const char *name)
713 BlockBackend *blk = NULL;
715 assert(name);
716 while ((blk = blk_next(blk)) != NULL) {
717 if (!strcmp(name, blk->name)) {
718 return blk;
721 return NULL;
725 * Return the BlockDriverState attached to @blk if any, else null.
727 BlockDriverState *blk_bs(BlockBackend *blk)
729 return blk->root ? blk->root->bs : NULL;
732 static BlockBackend *bdrv_first_blk(BlockDriverState *bs)
734 BdrvChild *child;
735 QLIST_FOREACH(child, &bs->parents, next_parent) {
736 if (child->klass == &child_root) {
737 return child->opaque;
741 return NULL;
745 * Returns true if @bs has an associated BlockBackend.
747 bool bdrv_has_blk(BlockDriverState *bs)
749 return bdrv_first_blk(bs) != NULL;
753 * Returns true if @bs has only BlockBackends as parents.
755 bool bdrv_is_root_node(BlockDriverState *bs)
757 BdrvChild *c;
759 QLIST_FOREACH(c, &bs->parents, next_parent) {
760 if (c->klass != &child_root) {
761 return false;
765 return true;
769 * Return @blk's DriveInfo if any, else null.
771 DriveInfo *blk_legacy_dinfo(BlockBackend *blk)
773 return blk->legacy_dinfo;
777 * Set @blk's DriveInfo to @dinfo, and return it.
778 * @blk must not have a DriveInfo set already.
779 * No other BlockBackend may have the same DriveInfo set.
781 DriveInfo *blk_set_legacy_dinfo(BlockBackend *blk, DriveInfo *dinfo)
783 assert(!blk->legacy_dinfo);
784 return blk->legacy_dinfo = dinfo;
788 * Return the BlockBackend with DriveInfo @dinfo.
789 * It must exist.
791 BlockBackend *blk_by_legacy_dinfo(DriveInfo *dinfo)
793 BlockBackend *blk = NULL;
795 while ((blk = blk_next(blk)) != NULL) {
796 if (blk->legacy_dinfo == dinfo) {
797 return blk;
800 abort();
804 * Returns a pointer to the publicly accessible fields of @blk.
806 BlockBackendPublic *blk_get_public(BlockBackend *blk)
808 return &blk->public;
812 * Returns a BlockBackend given the associated @public fields.
814 BlockBackend *blk_by_public(BlockBackendPublic *public)
816 return container_of(public, BlockBackend, public);
820 * Disassociates the currently associated BlockDriverState from @blk.
822 void blk_remove_bs(BlockBackend *blk)
824 ThrottleGroupMember *tgm = &blk->public.throttle_group_member;
825 BlockDriverState *bs;
826 BdrvChild *root;
828 notifier_list_notify(&blk->remove_bs_notifiers, blk);
829 if (tgm->throttle_state) {
830 bs = blk_bs(blk);
831 bdrv_drained_begin(bs);
832 throttle_group_detach_aio_context(tgm);
833 throttle_group_attach_aio_context(tgm, qemu_get_aio_context());
834 bdrv_drained_end(bs);
837 blk_update_root_state(blk);
839 /* bdrv_root_unref_child() will cause blk->root to become stale and may
840 * switch to a completion coroutine later on. Let's drain all I/O here
841 * to avoid that and a potential QEMU crash.
843 blk_drain(blk);
844 root = blk->root;
845 blk->root = NULL;
846 bdrv_root_unref_child(root);
850 * Associates a new BlockDriverState with @blk.
852 int blk_insert_bs(BlockBackend *blk, BlockDriverState *bs, Error **errp)
854 ThrottleGroupMember *tgm = &blk->public.throttle_group_member;
855 bdrv_ref(bs);
856 blk->root = bdrv_root_attach_child(bs, "root", &child_root,
857 BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY,
858 blk->perm, blk->shared_perm,
859 blk, errp);
860 if (blk->root == NULL) {
861 return -EPERM;
864 notifier_list_notify(&blk->insert_bs_notifiers, blk);
865 if (tgm->throttle_state) {
866 throttle_group_detach_aio_context(tgm);
867 throttle_group_attach_aio_context(tgm, bdrv_get_aio_context(bs));
870 return 0;
874 * Sets the permission bitmasks that the user of the BlockBackend needs.
876 int blk_set_perm(BlockBackend *blk, uint64_t perm, uint64_t shared_perm,
877 Error **errp)
879 int ret;
881 if (blk->root && !blk->disable_perm) {
882 ret = bdrv_child_try_set_perm(blk->root, perm, shared_perm, errp);
883 if (ret < 0) {
884 return ret;
888 blk->perm = perm;
889 blk->shared_perm = shared_perm;
891 return 0;
894 void blk_get_perm(BlockBackend *blk, uint64_t *perm, uint64_t *shared_perm)
896 *perm = blk->perm;
897 *shared_perm = blk->shared_perm;
901 * Attach device model @dev to @blk.
902 * Return 0 on success, -EBUSY when a device model is attached already.
904 int blk_attach_dev(BlockBackend *blk, DeviceState *dev)
906 if (blk->dev) {
907 return -EBUSY;
910 /* While migration is still incoming, we don't need to apply the
911 * permissions of guest device BlockBackends. We might still have a block
912 * job or NBD server writing to the image for storage migration. */
913 if (runstate_check(RUN_STATE_INMIGRATE)) {
914 blk->disable_perm = true;
917 blk_ref(blk);
918 blk->dev = dev;
919 blk_iostatus_reset(blk);
921 return 0;
925 * Detach device model @dev from @blk.
926 * @dev must be currently attached to @blk.
928 void blk_detach_dev(BlockBackend *blk, DeviceState *dev)
930 assert(blk->dev == dev);
931 blk->dev = NULL;
932 blk->dev_ops = NULL;
933 blk->dev_opaque = NULL;
934 blk->guest_block_size = 512;
935 blk_set_perm(blk, 0, BLK_PERM_ALL, &error_abort);
936 blk_unref(blk);
940 * Return the device model attached to @blk if any, else null.
942 DeviceState *blk_get_attached_dev(BlockBackend *blk)
944 return blk->dev;
947 /* Return the qdev ID, or if no ID is assigned the QOM path, of the block
948 * device attached to the BlockBackend. */
949 char *blk_get_attached_dev_id(BlockBackend *blk)
951 DeviceState *dev = blk->dev;
953 if (!dev) {
954 return g_strdup("");
955 } else if (dev->id) {
956 return g_strdup(dev->id);
959 return object_get_canonical_path(OBJECT(dev)) ?: g_strdup("");
963 * Return the BlockBackend which has the device model @dev attached if it
964 * exists, else null.
966 * @dev must not be null.
968 BlockBackend *blk_by_dev(void *dev)
970 BlockBackend *blk = NULL;
972 assert(dev != NULL);
973 while ((blk = blk_all_next(blk)) != NULL) {
974 if (blk->dev == dev) {
975 return blk;
978 return NULL;
982 * Set @blk's device model callbacks to @ops.
983 * @opaque is the opaque argument to pass to the callbacks.
984 * This is for use by device models.
986 void blk_set_dev_ops(BlockBackend *blk, const BlockDevOps *ops,
987 void *opaque)
989 blk->dev_ops = ops;
990 blk->dev_opaque = opaque;
992 /* Are we currently quiesced? Should we enforce this right now? */
993 if (blk->quiesce_counter && ops->drained_begin) {
994 ops->drained_begin(opaque);
999 * Notify @blk's attached device model of media change.
1001 * If @load is true, notify of media load. This action can fail, meaning that
1002 * the medium cannot be loaded. @errp is set then.
1004 * If @load is false, notify of media eject. This can never fail.
1006 * Also send DEVICE_TRAY_MOVED events as appropriate.
1008 void blk_dev_change_media_cb(BlockBackend *blk, bool load, Error **errp)
1010 if (blk->dev_ops && blk->dev_ops->change_media_cb) {
1011 bool tray_was_open, tray_is_open;
1012 Error *local_err = NULL;
1014 tray_was_open = blk_dev_is_tray_open(blk);
1015 blk->dev_ops->change_media_cb(blk->dev_opaque, load, &local_err);
1016 if (local_err) {
1017 assert(load == true);
1018 error_propagate(errp, local_err);
1019 return;
1021 tray_is_open = blk_dev_is_tray_open(blk);
1023 if (tray_was_open != tray_is_open) {
1024 char *id = blk_get_attached_dev_id(blk);
1025 qapi_event_send_device_tray_moved(blk_name(blk), id, tray_is_open);
1026 g_free(id);
1031 static void blk_root_change_media(BdrvChild *child, bool load)
1033 blk_dev_change_media_cb(child->opaque, load, NULL);
1037 * Does @blk's attached device model have removable media?
1038 * %true if no device model is attached.
1040 bool blk_dev_has_removable_media(BlockBackend *blk)
1042 return !blk->dev || (blk->dev_ops && blk->dev_ops->change_media_cb);
1046 * Does @blk's attached device model have a tray?
1048 bool blk_dev_has_tray(BlockBackend *blk)
1050 return blk->dev_ops && blk->dev_ops->is_tray_open;
1054 * Notify @blk's attached device model of a media eject request.
1055 * If @force is true, the medium is about to be yanked out forcefully.
1057 void blk_dev_eject_request(BlockBackend *blk, bool force)
1059 if (blk->dev_ops && blk->dev_ops->eject_request_cb) {
1060 blk->dev_ops->eject_request_cb(blk->dev_opaque, force);
1065 * Does @blk's attached device model have a tray, and is it open?
1067 bool blk_dev_is_tray_open(BlockBackend *blk)
1069 if (blk_dev_has_tray(blk)) {
1070 return blk->dev_ops->is_tray_open(blk->dev_opaque);
1072 return false;
1076 * Does @blk's attached device model have the medium locked?
1077 * %false if the device model has no such lock.
1079 bool blk_dev_is_medium_locked(BlockBackend *blk)
1081 if (blk->dev_ops && blk->dev_ops->is_medium_locked) {
1082 return blk->dev_ops->is_medium_locked(blk->dev_opaque);
1084 return false;
1088 * Notify @blk's attached device model of a backend size change.
1090 static void blk_root_resize(BdrvChild *child)
1092 BlockBackend *blk = child->opaque;
1094 if (blk->dev_ops && blk->dev_ops->resize_cb) {
1095 blk->dev_ops->resize_cb(blk->dev_opaque);
1099 void blk_iostatus_enable(BlockBackend *blk)
1101 blk->iostatus_enabled = true;
1102 blk->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
1105 /* The I/O status is only enabled if the drive explicitly
1106 * enables it _and_ the VM is configured to stop on errors */
1107 bool blk_iostatus_is_enabled(const BlockBackend *blk)
1109 return (blk->iostatus_enabled &&
1110 (blk->on_write_error == BLOCKDEV_ON_ERROR_ENOSPC ||
1111 blk->on_write_error == BLOCKDEV_ON_ERROR_STOP ||
1112 blk->on_read_error == BLOCKDEV_ON_ERROR_STOP));
1115 BlockDeviceIoStatus blk_iostatus(const BlockBackend *blk)
1117 return blk->iostatus;
1120 void blk_iostatus_disable(BlockBackend *blk)
1122 blk->iostatus_enabled = false;
1125 void blk_iostatus_reset(BlockBackend *blk)
1127 if (blk_iostatus_is_enabled(blk)) {
1128 blk->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
1132 void blk_iostatus_set_err(BlockBackend *blk, int error)
1134 assert(blk_iostatus_is_enabled(blk));
1135 if (blk->iostatus == BLOCK_DEVICE_IO_STATUS_OK) {
1136 blk->iostatus = error == ENOSPC ? BLOCK_DEVICE_IO_STATUS_NOSPACE :
1137 BLOCK_DEVICE_IO_STATUS_FAILED;
1141 void blk_set_allow_write_beyond_eof(BlockBackend *blk, bool allow)
1143 blk->allow_write_beyond_eof = allow;
1146 void blk_set_allow_aio_context_change(BlockBackend *blk, bool allow)
1148 blk->allow_aio_context_change = allow;
1151 void blk_set_disable_request_queuing(BlockBackend *blk, bool disable)
1153 blk->disable_request_queuing = disable;
1156 static int blk_check_byte_request(BlockBackend *blk, int64_t offset,
1157 size_t size)
1159 int64_t len;
1161 if (size > INT_MAX) {
1162 return -EIO;
1165 if (!blk_is_available(blk)) {
1166 return -ENOMEDIUM;
1169 if (offset < 0) {
1170 return -EIO;
1173 if (!blk->allow_write_beyond_eof) {
1174 len = blk_getlength(blk);
1175 if (len < 0) {
1176 return len;
1179 if (offset > len || len - offset < size) {
1180 return -EIO;
1184 return 0;
1187 /* To be called between exactly one pair of blk_inc/dec_in_flight() */
1188 static void coroutine_fn blk_wait_while_drained(BlockBackend *blk)
1190 assert(blk->in_flight > 0);
1192 if (blk->quiesce_counter && !blk->disable_request_queuing) {
1193 blk_dec_in_flight(blk);
1194 qemu_co_queue_wait(&blk->queued_requests, NULL);
1195 blk_inc_in_flight(blk);
1199 /* To be called between exactly one pair of blk_inc/dec_in_flight() */
1200 static int coroutine_fn
1201 blk_do_preadv(BlockBackend *blk, int64_t offset, unsigned int bytes,
1202 QEMUIOVector *qiov, BdrvRequestFlags flags)
1204 int ret;
1205 BlockDriverState *bs;
1207 blk_wait_while_drained(blk);
1209 /* Call blk_bs() only after waiting, the graph may have changed */
1210 bs = blk_bs(blk);
1211 trace_blk_co_preadv(blk, bs, offset, bytes, flags);
1213 ret = blk_check_byte_request(blk, offset, bytes);
1214 if (ret < 0) {
1215 return ret;
1218 bdrv_inc_in_flight(bs);
1220 /* throttling disk I/O */
1221 if (blk->public.throttle_group_member.throttle_state) {
1222 throttle_group_co_io_limits_intercept(&blk->public.throttle_group_member,
1223 bytes, false);
1226 ret = bdrv_co_preadv(blk->root, offset, bytes, qiov, flags);
1227 bdrv_dec_in_flight(bs);
1228 return ret;
1231 int coroutine_fn blk_co_preadv(BlockBackend *blk, int64_t offset,
1232 unsigned int bytes, QEMUIOVector *qiov,
1233 BdrvRequestFlags flags)
1235 int ret;
1237 blk_inc_in_flight(blk);
1238 ret = blk_do_preadv(blk, offset, bytes, qiov, flags);
1239 blk_dec_in_flight(blk);
1241 return ret;
1244 /* To be called between exactly one pair of blk_inc/dec_in_flight() */
1245 static int coroutine_fn
1246 blk_do_pwritev_part(BlockBackend *blk, int64_t offset, unsigned int bytes,
1247 QEMUIOVector *qiov, size_t qiov_offset,
1248 BdrvRequestFlags flags)
1250 int ret;
1251 BlockDriverState *bs;
1253 blk_wait_while_drained(blk);
1255 /* Call blk_bs() only after waiting, the graph may have changed */
1256 bs = blk_bs(blk);
1257 trace_blk_co_pwritev(blk, bs, offset, bytes, flags);
1259 ret = blk_check_byte_request(blk, offset, bytes);
1260 if (ret < 0) {
1261 return ret;
1264 bdrv_inc_in_flight(bs);
1265 /* throttling disk I/O */
1266 if (blk->public.throttle_group_member.throttle_state) {
1267 throttle_group_co_io_limits_intercept(&blk->public.throttle_group_member,
1268 bytes, true);
1271 if (!blk->enable_write_cache) {
1272 flags |= BDRV_REQ_FUA;
1275 ret = bdrv_co_pwritev_part(blk->root, offset, bytes, qiov, qiov_offset,
1276 flags);
1277 bdrv_dec_in_flight(bs);
1278 return ret;
1281 int coroutine_fn blk_co_pwritev_part(BlockBackend *blk, int64_t offset,
1282 unsigned int bytes,
1283 QEMUIOVector *qiov, size_t qiov_offset,
1284 BdrvRequestFlags flags)
1286 int ret;
1288 blk_inc_in_flight(blk);
1289 ret = blk_do_pwritev_part(blk, offset, bytes, qiov, qiov_offset, flags);
1290 blk_dec_in_flight(blk);
1292 return ret;
1295 int coroutine_fn blk_co_pwritev(BlockBackend *blk, int64_t offset,
1296 unsigned int bytes, QEMUIOVector *qiov,
1297 BdrvRequestFlags flags)
1299 return blk_co_pwritev_part(blk, offset, bytes, qiov, 0, flags);
1302 typedef struct BlkRwCo {
1303 BlockBackend *blk;
1304 int64_t offset;
1305 void *iobuf;
1306 int ret;
1307 BdrvRequestFlags flags;
1308 } BlkRwCo;
1310 static void blk_read_entry(void *opaque)
1312 BlkRwCo *rwco = opaque;
1313 QEMUIOVector *qiov = rwco->iobuf;
1315 rwco->ret = blk_do_preadv(rwco->blk, rwco->offset, qiov->size,
1316 qiov, rwco->flags);
1317 aio_wait_kick();
1320 static void blk_write_entry(void *opaque)
1322 BlkRwCo *rwco = opaque;
1323 QEMUIOVector *qiov = rwco->iobuf;
1325 rwco->ret = blk_do_pwritev_part(rwco->blk, rwco->offset, qiov->size,
1326 qiov, 0, rwco->flags);
1327 aio_wait_kick();
1330 static int blk_prw(BlockBackend *blk, int64_t offset, uint8_t *buf,
1331 int64_t bytes, CoroutineEntry co_entry,
1332 BdrvRequestFlags flags)
1334 QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
1335 BlkRwCo rwco = {
1336 .blk = blk,
1337 .offset = offset,
1338 .iobuf = &qiov,
1339 .flags = flags,
1340 .ret = NOT_DONE,
1343 blk_inc_in_flight(blk);
1344 if (qemu_in_coroutine()) {
1345 /* Fast-path if already in coroutine context */
1346 co_entry(&rwco);
1347 } else {
1348 Coroutine *co = qemu_coroutine_create(co_entry, &rwco);
1349 bdrv_coroutine_enter(blk_bs(blk), co);
1350 BDRV_POLL_WHILE(blk_bs(blk), rwco.ret == NOT_DONE);
1352 blk_dec_in_flight(blk);
1354 return rwco.ret;
1357 int blk_pwrite_zeroes(BlockBackend *blk, int64_t offset,
1358 int bytes, BdrvRequestFlags flags)
1360 return blk_prw(blk, offset, NULL, bytes, blk_write_entry,
1361 flags | BDRV_REQ_ZERO_WRITE);
1364 int blk_make_zero(BlockBackend *blk, BdrvRequestFlags flags)
1366 return bdrv_make_zero(blk->root, flags);
1369 void blk_inc_in_flight(BlockBackend *blk)
1371 qatomic_inc(&blk->in_flight);
1374 void blk_dec_in_flight(BlockBackend *blk)
1376 qatomic_dec(&blk->in_flight);
1377 aio_wait_kick();
1380 static void error_callback_bh(void *opaque)
1382 struct BlockBackendAIOCB *acb = opaque;
1384 blk_dec_in_flight(acb->blk);
1385 acb->common.cb(acb->common.opaque, acb->ret);
1386 qemu_aio_unref(acb);
1389 BlockAIOCB *blk_abort_aio_request(BlockBackend *blk,
1390 BlockCompletionFunc *cb,
1391 void *opaque, int ret)
1393 struct BlockBackendAIOCB *acb;
1395 blk_inc_in_flight(blk);
1396 acb = blk_aio_get(&block_backend_aiocb_info, blk, cb, opaque);
1397 acb->blk = blk;
1398 acb->ret = ret;
1400 replay_bh_schedule_oneshot_event(blk_get_aio_context(blk),
1401 error_callback_bh, acb);
1402 return &acb->common;
1405 typedef struct BlkAioEmAIOCB {
1406 BlockAIOCB common;
1407 BlkRwCo rwco;
1408 int bytes;
1409 bool has_returned;
1410 } BlkAioEmAIOCB;
1412 static AioContext *blk_aio_em_aiocb_get_aio_context(BlockAIOCB *acb_)
1414 BlkAioEmAIOCB *acb = container_of(acb_, BlkAioEmAIOCB, common);
1416 return blk_get_aio_context(acb->rwco.blk);
1419 static const AIOCBInfo blk_aio_em_aiocb_info = {
1420 .aiocb_size = sizeof(BlkAioEmAIOCB),
1421 .get_aio_context = blk_aio_em_aiocb_get_aio_context,
1424 static void blk_aio_complete(BlkAioEmAIOCB *acb)
1426 if (acb->has_returned) {
1427 acb->common.cb(acb->common.opaque, acb->rwco.ret);
1428 blk_dec_in_flight(acb->rwco.blk);
1429 qemu_aio_unref(acb);
1433 static void blk_aio_complete_bh(void *opaque)
1435 BlkAioEmAIOCB *acb = opaque;
1436 assert(acb->has_returned);
1437 blk_aio_complete(acb);
1440 static BlockAIOCB *blk_aio_prwv(BlockBackend *blk, int64_t offset, int bytes,
1441 void *iobuf, CoroutineEntry co_entry,
1442 BdrvRequestFlags flags,
1443 BlockCompletionFunc *cb, void *opaque)
1445 BlkAioEmAIOCB *acb;
1446 Coroutine *co;
1448 blk_inc_in_flight(blk);
1449 acb = blk_aio_get(&blk_aio_em_aiocb_info, blk, cb, opaque);
1450 acb->rwco = (BlkRwCo) {
1451 .blk = blk,
1452 .offset = offset,
1453 .iobuf = iobuf,
1454 .flags = flags,
1455 .ret = NOT_DONE,
1457 acb->bytes = bytes;
1458 acb->has_returned = false;
1460 co = qemu_coroutine_create(co_entry, acb);
1461 bdrv_coroutine_enter(blk_bs(blk), co);
1463 acb->has_returned = true;
1464 if (acb->rwco.ret != NOT_DONE) {
1465 replay_bh_schedule_oneshot_event(blk_get_aio_context(blk),
1466 blk_aio_complete_bh, acb);
1469 return &acb->common;
1472 static void blk_aio_read_entry(void *opaque)
1474 BlkAioEmAIOCB *acb = opaque;
1475 BlkRwCo *rwco = &acb->rwco;
1476 QEMUIOVector *qiov = rwco->iobuf;
1478 assert(qiov->size == acb->bytes);
1479 rwco->ret = blk_do_preadv(rwco->blk, rwco->offset, acb->bytes,
1480 qiov, rwco->flags);
1481 blk_aio_complete(acb);
1484 static void blk_aio_write_entry(void *opaque)
1486 BlkAioEmAIOCB *acb = opaque;
1487 BlkRwCo *rwco = &acb->rwco;
1488 QEMUIOVector *qiov = rwco->iobuf;
1490 assert(!qiov || qiov->size == acb->bytes);
1491 rwco->ret = blk_do_pwritev_part(rwco->blk, rwco->offset, acb->bytes,
1492 qiov, 0, rwco->flags);
1493 blk_aio_complete(acb);
1496 BlockAIOCB *blk_aio_pwrite_zeroes(BlockBackend *blk, int64_t offset,
1497 int count, BdrvRequestFlags flags,
1498 BlockCompletionFunc *cb, void *opaque)
1500 return blk_aio_prwv(blk, offset, count, NULL, blk_aio_write_entry,
1501 flags | BDRV_REQ_ZERO_WRITE, cb, opaque);
1504 int blk_pread(BlockBackend *blk, int64_t offset, void *buf, int count)
1506 int ret = blk_prw(blk, offset, buf, count, blk_read_entry, 0);
1507 if (ret < 0) {
1508 return ret;
1510 return count;
1513 int blk_pwrite(BlockBackend *blk, int64_t offset, const void *buf, int count,
1514 BdrvRequestFlags flags)
1516 int ret = blk_prw(blk, offset, (void *) buf, count, blk_write_entry,
1517 flags);
1518 if (ret < 0) {
1519 return ret;
1521 return count;
1524 int64_t blk_getlength(BlockBackend *blk)
1526 if (!blk_is_available(blk)) {
1527 return -ENOMEDIUM;
1530 return bdrv_getlength(blk_bs(blk));
1533 void blk_get_geometry(BlockBackend *blk, uint64_t *nb_sectors_ptr)
1535 if (!blk_bs(blk)) {
1536 *nb_sectors_ptr = 0;
1537 } else {
1538 bdrv_get_geometry(blk_bs(blk), nb_sectors_ptr);
1542 int64_t blk_nb_sectors(BlockBackend *blk)
1544 if (!blk_is_available(blk)) {
1545 return -ENOMEDIUM;
1548 return bdrv_nb_sectors(blk_bs(blk));
1551 BlockAIOCB *blk_aio_preadv(BlockBackend *blk, int64_t offset,
1552 QEMUIOVector *qiov, BdrvRequestFlags flags,
1553 BlockCompletionFunc *cb, void *opaque)
1555 return blk_aio_prwv(blk, offset, qiov->size, qiov,
1556 blk_aio_read_entry, flags, cb, opaque);
1559 BlockAIOCB *blk_aio_pwritev(BlockBackend *blk, int64_t offset,
1560 QEMUIOVector *qiov, BdrvRequestFlags flags,
1561 BlockCompletionFunc *cb, void *opaque)
1563 return blk_aio_prwv(blk, offset, qiov->size, qiov,
1564 blk_aio_write_entry, flags, cb, opaque);
1567 void blk_aio_cancel(BlockAIOCB *acb)
1569 bdrv_aio_cancel(acb);
1572 void blk_aio_cancel_async(BlockAIOCB *acb)
1574 bdrv_aio_cancel_async(acb);
1577 /* To be called between exactly one pair of blk_inc/dec_in_flight() */
1578 static int coroutine_fn
1579 blk_do_ioctl(BlockBackend *blk, unsigned long int req, void *buf)
1581 blk_wait_while_drained(blk);
1583 if (!blk_is_available(blk)) {
1584 return -ENOMEDIUM;
1587 return bdrv_co_ioctl(blk_bs(blk), req, buf);
1590 static void blk_ioctl_entry(void *opaque)
1592 BlkRwCo *rwco = opaque;
1593 QEMUIOVector *qiov = rwco->iobuf;
1595 rwco->ret = blk_do_ioctl(rwco->blk, rwco->offset, qiov->iov[0].iov_base);
1596 aio_wait_kick();
1599 int blk_ioctl(BlockBackend *blk, unsigned long int req, void *buf)
1601 return blk_prw(blk, req, buf, 0, blk_ioctl_entry, 0);
1604 static void blk_aio_ioctl_entry(void *opaque)
1606 BlkAioEmAIOCB *acb = opaque;
1607 BlkRwCo *rwco = &acb->rwco;
1609 rwco->ret = blk_do_ioctl(rwco->blk, rwco->offset, rwco->iobuf);
1611 blk_aio_complete(acb);
1614 BlockAIOCB *blk_aio_ioctl(BlockBackend *blk, unsigned long int req, void *buf,
1615 BlockCompletionFunc *cb, void *opaque)
1617 return blk_aio_prwv(blk, req, 0, buf, blk_aio_ioctl_entry, 0, cb, opaque);
1620 /* To be called between exactly one pair of blk_inc/dec_in_flight() */
1621 static int coroutine_fn
1622 blk_do_pdiscard(BlockBackend *blk, int64_t offset, int bytes)
1624 int ret;
1626 blk_wait_while_drained(blk);
1628 ret = blk_check_byte_request(blk, offset, bytes);
1629 if (ret < 0) {
1630 return ret;
1633 return bdrv_co_pdiscard(blk->root, offset, bytes);
1636 static void blk_aio_pdiscard_entry(void *opaque)
1638 BlkAioEmAIOCB *acb = opaque;
1639 BlkRwCo *rwco = &acb->rwco;
1641 rwco->ret = blk_do_pdiscard(rwco->blk, rwco->offset, acb->bytes);
1642 blk_aio_complete(acb);
1645 BlockAIOCB *blk_aio_pdiscard(BlockBackend *blk,
1646 int64_t offset, int bytes,
1647 BlockCompletionFunc *cb, void *opaque)
1649 return blk_aio_prwv(blk, offset, bytes, NULL, blk_aio_pdiscard_entry, 0,
1650 cb, opaque);
1653 int coroutine_fn blk_co_pdiscard(BlockBackend *blk, int64_t offset, int bytes)
1655 int ret;
1657 blk_inc_in_flight(blk);
1658 ret = blk_do_pdiscard(blk, offset, bytes);
1659 blk_dec_in_flight(blk);
1661 return ret;
1664 static void blk_pdiscard_entry(void *opaque)
1666 BlkRwCo *rwco = opaque;
1667 QEMUIOVector *qiov = rwco->iobuf;
1669 rwco->ret = blk_do_pdiscard(rwco->blk, rwco->offset, qiov->size);
1670 aio_wait_kick();
1673 int blk_pdiscard(BlockBackend *blk, int64_t offset, int bytes)
1675 return blk_prw(blk, offset, NULL, bytes, blk_pdiscard_entry, 0);
1678 /* To be called between exactly one pair of blk_inc/dec_in_flight() */
1679 static int coroutine_fn blk_do_flush(BlockBackend *blk)
1681 blk_wait_while_drained(blk);
1683 if (!blk_is_available(blk)) {
1684 return -ENOMEDIUM;
1687 return bdrv_co_flush(blk_bs(blk));
1690 static void blk_aio_flush_entry(void *opaque)
1692 BlkAioEmAIOCB *acb = opaque;
1693 BlkRwCo *rwco = &acb->rwco;
1695 rwco->ret = blk_do_flush(rwco->blk);
1696 blk_aio_complete(acb);
1699 BlockAIOCB *blk_aio_flush(BlockBackend *blk,
1700 BlockCompletionFunc *cb, void *opaque)
1702 return blk_aio_prwv(blk, 0, 0, NULL, blk_aio_flush_entry, 0, cb, opaque);
1705 int coroutine_fn blk_co_flush(BlockBackend *blk)
1707 int ret;
1709 blk_inc_in_flight(blk);
1710 ret = blk_do_flush(blk);
1711 blk_dec_in_flight(blk);
1713 return ret;
1716 static void blk_flush_entry(void *opaque)
1718 BlkRwCo *rwco = opaque;
1719 rwco->ret = blk_do_flush(rwco->blk);
1720 aio_wait_kick();
1723 int blk_flush(BlockBackend *blk)
1725 return blk_prw(blk, 0, NULL, 0, blk_flush_entry, 0);
1728 void blk_drain(BlockBackend *blk)
1730 BlockDriverState *bs = blk_bs(blk);
1732 if (bs) {
1733 bdrv_drained_begin(bs);
1736 /* We may have -ENOMEDIUM completions in flight */
1737 AIO_WAIT_WHILE(blk_get_aio_context(blk),
1738 qatomic_mb_read(&blk->in_flight) > 0);
1740 if (bs) {
1741 bdrv_drained_end(bs);
1745 void blk_drain_all(void)
1747 BlockBackend *blk = NULL;
1749 bdrv_drain_all_begin();
1751 while ((blk = blk_all_next(blk)) != NULL) {
1752 AioContext *ctx = blk_get_aio_context(blk);
1754 aio_context_acquire(ctx);
1756 /* We may have -ENOMEDIUM completions in flight */
1757 AIO_WAIT_WHILE(ctx, qatomic_mb_read(&blk->in_flight) > 0);
1759 aio_context_release(ctx);
1762 bdrv_drain_all_end();
1765 void blk_set_on_error(BlockBackend *blk, BlockdevOnError on_read_error,
1766 BlockdevOnError on_write_error)
1768 blk->on_read_error = on_read_error;
1769 blk->on_write_error = on_write_error;
1772 BlockdevOnError blk_get_on_error(BlockBackend *blk, bool is_read)
1774 return is_read ? blk->on_read_error : blk->on_write_error;
1777 BlockErrorAction blk_get_error_action(BlockBackend *blk, bool is_read,
1778 int error)
1780 BlockdevOnError on_err = blk_get_on_error(blk, is_read);
1782 switch (on_err) {
1783 case BLOCKDEV_ON_ERROR_ENOSPC:
1784 return (error == ENOSPC) ?
1785 BLOCK_ERROR_ACTION_STOP : BLOCK_ERROR_ACTION_REPORT;
1786 case BLOCKDEV_ON_ERROR_STOP:
1787 return BLOCK_ERROR_ACTION_STOP;
1788 case BLOCKDEV_ON_ERROR_REPORT:
1789 return BLOCK_ERROR_ACTION_REPORT;
1790 case BLOCKDEV_ON_ERROR_IGNORE:
1791 return BLOCK_ERROR_ACTION_IGNORE;
1792 case BLOCKDEV_ON_ERROR_AUTO:
1793 default:
1794 abort();
1798 static void send_qmp_error_event(BlockBackend *blk,
1799 BlockErrorAction action,
1800 bool is_read, int error)
1802 IoOperationType optype;
1803 BlockDriverState *bs = blk_bs(blk);
1805 optype = is_read ? IO_OPERATION_TYPE_READ : IO_OPERATION_TYPE_WRITE;
1806 qapi_event_send_block_io_error(blk_name(blk), !!bs,
1807 bs ? bdrv_get_node_name(bs) : NULL, optype,
1808 action, blk_iostatus_is_enabled(blk),
1809 error == ENOSPC, strerror(error));
1812 /* This is done by device models because, while the block layer knows
1813 * about the error, it does not know whether an operation comes from
1814 * the device or the block layer (from a job, for example).
1816 void blk_error_action(BlockBackend *blk, BlockErrorAction action,
1817 bool is_read, int error)
1819 assert(error >= 0);
1821 if (action == BLOCK_ERROR_ACTION_STOP) {
1822 /* First set the iostatus, so that "info block" returns an iostatus
1823 * that matches the events raised so far (an additional error iostatus
1824 * is fine, but not a lost one).
1826 blk_iostatus_set_err(blk, error);
1828 /* Then raise the request to stop the VM and the event.
1829 * qemu_system_vmstop_request_prepare has two effects. First,
1830 * it ensures that the STOP event always comes after the
1831 * BLOCK_IO_ERROR event. Second, it ensures that even if management
1832 * can observe the STOP event and do a "cont" before the STOP
1833 * event is issued, the VM will not stop. In this case, vm_start()
1834 * also ensures that the STOP/RESUME pair of events is emitted.
1836 qemu_system_vmstop_request_prepare();
1837 send_qmp_error_event(blk, action, is_read, error);
1838 qemu_system_vmstop_request(RUN_STATE_IO_ERROR);
1839 } else {
1840 send_qmp_error_event(blk, action, is_read, error);
1845 * Returns true if the BlockBackend can support taking write permissions
1846 * (because its root node is not read-only).
1848 bool blk_supports_write_perm(BlockBackend *blk)
1850 BlockDriverState *bs = blk_bs(blk);
1852 if (bs) {
1853 return !bdrv_is_read_only(bs);
1854 } else {
1855 return !blk->root_state.read_only;
1860 * Returns true if the BlockBackend can be written to in its current
1861 * configuration (i.e. if write permission have been requested)
1863 bool blk_is_writable(BlockBackend *blk)
1865 return blk->perm & BLK_PERM_WRITE;
1868 bool blk_is_sg(BlockBackend *blk)
1870 BlockDriverState *bs = blk_bs(blk);
1872 if (!bs) {
1873 return false;
1876 return bdrv_is_sg(bs);
1879 bool blk_enable_write_cache(BlockBackend *blk)
1881 return blk->enable_write_cache;
1884 void blk_set_enable_write_cache(BlockBackend *blk, bool wce)
1886 blk->enable_write_cache = wce;
1889 void blk_invalidate_cache(BlockBackend *blk, Error **errp)
1891 BlockDriverState *bs = blk_bs(blk);
1893 if (!bs) {
1894 error_setg(errp, "Device '%s' has no medium", blk->name);
1895 return;
1898 bdrv_invalidate_cache(bs, errp);
1901 bool blk_is_inserted(BlockBackend *blk)
1903 BlockDriverState *bs = blk_bs(blk);
1905 return bs && bdrv_is_inserted(bs);
1908 bool blk_is_available(BlockBackend *blk)
1910 return blk_is_inserted(blk) && !blk_dev_is_tray_open(blk);
1913 void blk_lock_medium(BlockBackend *blk, bool locked)
1915 BlockDriverState *bs = blk_bs(blk);
1917 if (bs) {
1918 bdrv_lock_medium(bs, locked);
1922 void blk_eject(BlockBackend *blk, bool eject_flag)
1924 BlockDriverState *bs = blk_bs(blk);
1925 char *id;
1927 if (bs) {
1928 bdrv_eject(bs, eject_flag);
1931 /* Whether or not we ejected on the backend,
1932 * the frontend experienced a tray event. */
1933 id = blk_get_attached_dev_id(blk);
1934 qapi_event_send_device_tray_moved(blk_name(blk), id,
1935 eject_flag);
1936 g_free(id);
1939 int blk_get_flags(BlockBackend *blk)
1941 BlockDriverState *bs = blk_bs(blk);
1943 if (bs) {
1944 return bdrv_get_flags(bs);
1945 } else {
1946 return blk->root_state.open_flags;
1950 /* Returns the minimum request alignment, in bytes; guaranteed nonzero */
1951 uint32_t blk_get_request_alignment(BlockBackend *blk)
1953 BlockDriverState *bs = blk_bs(blk);
1954 return bs ? bs->bl.request_alignment : BDRV_SECTOR_SIZE;
1957 /* Returns the maximum transfer length, in bytes; guaranteed nonzero */
1958 uint32_t blk_get_max_transfer(BlockBackend *blk)
1960 BlockDriverState *bs = blk_bs(blk);
1961 uint32_t max = 0;
1963 if (bs) {
1964 max = bs->bl.max_transfer;
1966 return MIN_NON_ZERO(max, INT_MAX);
1969 int blk_get_max_iov(BlockBackend *blk)
1971 return blk->root->bs->bl.max_iov;
1974 void blk_set_guest_block_size(BlockBackend *blk, int align)
1976 blk->guest_block_size = align;
1979 void *blk_try_blockalign(BlockBackend *blk, size_t size)
1981 return qemu_try_blockalign(blk ? blk_bs(blk) : NULL, size);
1984 void *blk_blockalign(BlockBackend *blk, size_t size)
1986 return qemu_blockalign(blk ? blk_bs(blk) : NULL, size);
1989 bool blk_op_is_blocked(BlockBackend *blk, BlockOpType op, Error **errp)
1991 BlockDriverState *bs = blk_bs(blk);
1993 if (!bs) {
1994 return false;
1997 return bdrv_op_is_blocked(bs, op, errp);
2000 void blk_op_unblock(BlockBackend *blk, BlockOpType op, Error *reason)
2002 BlockDriverState *bs = blk_bs(blk);
2004 if (bs) {
2005 bdrv_op_unblock(bs, op, reason);
2009 void blk_op_block_all(BlockBackend *blk, Error *reason)
2011 BlockDriverState *bs = blk_bs(blk);
2013 if (bs) {
2014 bdrv_op_block_all(bs, reason);
2018 void blk_op_unblock_all(BlockBackend *blk, Error *reason)
2020 BlockDriverState *bs = blk_bs(blk);
2022 if (bs) {
2023 bdrv_op_unblock_all(bs, reason);
2027 AioContext *blk_get_aio_context(BlockBackend *blk)
2029 BlockDriverState *bs = blk_bs(blk);
2031 if (bs) {
2032 AioContext *ctx = bdrv_get_aio_context(blk_bs(blk));
2033 assert(ctx == blk->ctx);
2036 return blk->ctx;
2039 static AioContext *blk_aiocb_get_aio_context(BlockAIOCB *acb)
2041 BlockBackendAIOCB *blk_acb = DO_UPCAST(BlockBackendAIOCB, common, acb);
2042 return blk_get_aio_context(blk_acb->blk);
2045 static int blk_do_set_aio_context(BlockBackend *blk, AioContext *new_context,
2046 bool update_root_node, Error **errp)
2048 BlockDriverState *bs = blk_bs(blk);
2049 ThrottleGroupMember *tgm = &blk->public.throttle_group_member;
2050 int ret;
2052 if (bs) {
2053 if (update_root_node) {
2054 ret = bdrv_child_try_set_aio_context(bs, new_context, blk->root,
2055 errp);
2056 if (ret < 0) {
2057 return ret;
2060 if (tgm->throttle_state) {
2061 bdrv_drained_begin(bs);
2062 throttle_group_detach_aio_context(tgm);
2063 throttle_group_attach_aio_context(tgm, new_context);
2064 bdrv_drained_end(bs);
2068 blk->ctx = new_context;
2069 return 0;
2072 int blk_set_aio_context(BlockBackend *blk, AioContext *new_context,
2073 Error **errp)
2075 return blk_do_set_aio_context(blk, new_context, true, errp);
2078 static bool blk_root_can_set_aio_ctx(BdrvChild *child, AioContext *ctx,
2079 GSList **ignore, Error **errp)
2081 BlockBackend *blk = child->opaque;
2083 if (blk->allow_aio_context_change) {
2084 return true;
2087 /* Only manually created BlockBackends that are not attached to anything
2088 * can change their AioContext without updating their user. */
2089 if (!blk->name || blk->dev) {
2090 /* TODO Add BB name/QOM path */
2091 error_setg(errp, "Cannot change iothread of active block backend");
2092 return false;
2095 return true;
2098 static void blk_root_set_aio_ctx(BdrvChild *child, AioContext *ctx,
2099 GSList **ignore)
2101 BlockBackend *blk = child->opaque;
2102 blk_do_set_aio_context(blk, ctx, false, &error_abort);
2105 void blk_add_aio_context_notifier(BlockBackend *blk,
2106 void (*attached_aio_context)(AioContext *new_context, void *opaque),
2107 void (*detach_aio_context)(void *opaque), void *opaque)
2109 BlockBackendAioNotifier *notifier;
2110 BlockDriverState *bs = blk_bs(blk);
2112 notifier = g_new(BlockBackendAioNotifier, 1);
2113 notifier->attached_aio_context = attached_aio_context;
2114 notifier->detach_aio_context = detach_aio_context;
2115 notifier->opaque = opaque;
2116 QLIST_INSERT_HEAD(&blk->aio_notifiers, notifier, list);
2118 if (bs) {
2119 bdrv_add_aio_context_notifier(bs, attached_aio_context,
2120 detach_aio_context, opaque);
2124 void blk_remove_aio_context_notifier(BlockBackend *blk,
2125 void (*attached_aio_context)(AioContext *,
2126 void *),
2127 void (*detach_aio_context)(void *),
2128 void *opaque)
2130 BlockBackendAioNotifier *notifier;
2131 BlockDriverState *bs = blk_bs(blk);
2133 if (bs) {
2134 bdrv_remove_aio_context_notifier(bs, attached_aio_context,
2135 detach_aio_context, opaque);
2138 QLIST_FOREACH(notifier, &blk->aio_notifiers, list) {
2139 if (notifier->attached_aio_context == attached_aio_context &&
2140 notifier->detach_aio_context == detach_aio_context &&
2141 notifier->opaque == opaque) {
2142 QLIST_REMOVE(notifier, list);
2143 g_free(notifier);
2144 return;
2148 abort();
2151 void blk_add_remove_bs_notifier(BlockBackend *blk, Notifier *notify)
2153 notifier_list_add(&blk->remove_bs_notifiers, notify);
2156 void blk_add_insert_bs_notifier(BlockBackend *blk, Notifier *notify)
2158 notifier_list_add(&blk->insert_bs_notifiers, notify);
2161 void blk_io_plug(BlockBackend *blk)
2163 BlockDriverState *bs = blk_bs(blk);
2165 if (bs) {
2166 bdrv_io_plug(bs);
2170 void blk_io_unplug(BlockBackend *blk)
2172 BlockDriverState *bs = blk_bs(blk);
2174 if (bs) {
2175 bdrv_io_unplug(bs);
2179 BlockAcctStats *blk_get_stats(BlockBackend *blk)
2181 return &blk->stats;
2184 void *blk_aio_get(const AIOCBInfo *aiocb_info, BlockBackend *blk,
2185 BlockCompletionFunc *cb, void *opaque)
2187 return qemu_aio_get(aiocb_info, blk_bs(blk), cb, opaque);
2190 int coroutine_fn blk_co_pwrite_zeroes(BlockBackend *blk, int64_t offset,
2191 int bytes, BdrvRequestFlags flags)
2193 return blk_co_pwritev(blk, offset, bytes, NULL,
2194 flags | BDRV_REQ_ZERO_WRITE);
2197 int blk_pwrite_compressed(BlockBackend *blk, int64_t offset, const void *buf,
2198 int count)
2200 return blk_prw(blk, offset, (void *) buf, count, blk_write_entry,
2201 BDRV_REQ_WRITE_COMPRESSED);
2204 int blk_truncate(BlockBackend *blk, int64_t offset, bool exact,
2205 PreallocMode prealloc, BdrvRequestFlags flags, Error **errp)
2207 if (!blk_is_available(blk)) {
2208 error_setg(errp, "No medium inserted");
2209 return -ENOMEDIUM;
2212 return bdrv_truncate(blk->root, offset, exact, prealloc, flags, errp);
2215 int blk_save_vmstate(BlockBackend *blk, const uint8_t *buf,
2216 int64_t pos, int size)
2218 int ret;
2220 if (!blk_is_available(blk)) {
2221 return -ENOMEDIUM;
2224 ret = bdrv_save_vmstate(blk_bs(blk), buf, pos, size);
2225 if (ret < 0) {
2226 return ret;
2229 if (ret == size && !blk->enable_write_cache) {
2230 ret = bdrv_flush(blk_bs(blk));
2233 return ret < 0 ? ret : size;
2236 int blk_load_vmstate(BlockBackend *blk, uint8_t *buf, int64_t pos, int size)
2238 if (!blk_is_available(blk)) {
2239 return -ENOMEDIUM;
2242 return bdrv_load_vmstate(blk_bs(blk), buf, pos, size);
2245 int blk_probe_blocksizes(BlockBackend *blk, BlockSizes *bsz)
2247 if (!blk_is_available(blk)) {
2248 return -ENOMEDIUM;
2251 return bdrv_probe_blocksizes(blk_bs(blk), bsz);
2254 int blk_probe_geometry(BlockBackend *blk, HDGeometry *geo)
2256 if (!blk_is_available(blk)) {
2257 return -ENOMEDIUM;
2260 return bdrv_probe_geometry(blk_bs(blk), geo);
2264 * Updates the BlockBackendRootState object with data from the currently
2265 * attached BlockDriverState.
2267 void blk_update_root_state(BlockBackend *blk)
2269 assert(blk->root);
2271 blk->root_state.open_flags = blk->root->bs->open_flags;
2272 blk->root_state.read_only = blk->root->bs->read_only;
2273 blk->root_state.detect_zeroes = blk->root->bs->detect_zeroes;
2277 * Returns the detect-zeroes setting to be used for bdrv_open() of a
2278 * BlockDriverState which is supposed to inherit the root state.
2280 bool blk_get_detect_zeroes_from_root_state(BlockBackend *blk)
2282 return blk->root_state.detect_zeroes;
2286 * Returns the flags to be used for bdrv_open() of a BlockDriverState which is
2287 * supposed to inherit the root state.
2289 int blk_get_open_flags_from_root_state(BlockBackend *blk)
2291 int bs_flags;
2293 bs_flags = blk->root_state.read_only ? 0 : BDRV_O_RDWR;
2294 bs_flags |= blk->root_state.open_flags & ~BDRV_O_RDWR;
2296 return bs_flags;
2299 BlockBackendRootState *blk_get_root_state(BlockBackend *blk)
2301 return &blk->root_state;
2304 int blk_commit_all(void)
2306 BlockBackend *blk = NULL;
2308 while ((blk = blk_all_next(blk)) != NULL) {
2309 AioContext *aio_context = blk_get_aio_context(blk);
2310 BlockDriverState *unfiltered_bs = bdrv_skip_filters(blk_bs(blk));
2312 aio_context_acquire(aio_context);
2313 if (blk_is_inserted(blk) && bdrv_cow_child(unfiltered_bs)) {
2314 int ret;
2316 ret = bdrv_commit(unfiltered_bs);
2317 if (ret < 0) {
2318 aio_context_release(aio_context);
2319 return ret;
2322 aio_context_release(aio_context);
2324 return 0;
2328 /* throttling disk I/O limits */
2329 void blk_set_io_limits(BlockBackend *blk, ThrottleConfig *cfg)
2331 throttle_group_config(&blk->public.throttle_group_member, cfg);
2334 void blk_io_limits_disable(BlockBackend *blk)
2336 BlockDriverState *bs = blk_bs(blk);
2337 ThrottleGroupMember *tgm = &blk->public.throttle_group_member;
2338 assert(tgm->throttle_state);
2339 if (bs) {
2340 bdrv_drained_begin(bs);
2342 throttle_group_unregister_tgm(tgm);
2343 if (bs) {
2344 bdrv_drained_end(bs);
2348 /* should be called before blk_set_io_limits if a limit is set */
2349 void blk_io_limits_enable(BlockBackend *blk, const char *group)
2351 assert(!blk->public.throttle_group_member.throttle_state);
2352 throttle_group_register_tgm(&blk->public.throttle_group_member,
2353 group, blk_get_aio_context(blk));
2356 void blk_io_limits_update_group(BlockBackend *blk, const char *group)
2358 /* this BB is not part of any group */
2359 if (!blk->public.throttle_group_member.throttle_state) {
2360 return;
2363 /* this BB is a part of the same group than the one we want */
2364 if (!g_strcmp0(throttle_group_get_name(&blk->public.throttle_group_member),
2365 group)) {
2366 return;
2369 /* need to change the group this bs belong to */
2370 blk_io_limits_disable(blk);
2371 blk_io_limits_enable(blk, group);
2374 static void blk_root_drained_begin(BdrvChild *child)
2376 BlockBackend *blk = child->opaque;
2377 ThrottleGroupMember *tgm = &blk->public.throttle_group_member;
2379 if (++blk->quiesce_counter == 1) {
2380 if (blk->dev_ops && blk->dev_ops->drained_begin) {
2381 blk->dev_ops->drained_begin(blk->dev_opaque);
2385 /* Note that blk->root may not be accessible here yet if we are just
2386 * attaching to a BlockDriverState that is drained. Use child instead. */
2388 if (qatomic_fetch_inc(&tgm->io_limits_disabled) == 0) {
2389 throttle_group_restart_tgm(tgm);
2393 static bool blk_root_drained_poll(BdrvChild *child)
2395 BlockBackend *blk = child->opaque;
2396 assert(blk->quiesce_counter);
2397 return !!blk->in_flight;
2400 static void blk_root_drained_end(BdrvChild *child, int *drained_end_counter)
2402 BlockBackend *blk = child->opaque;
2403 assert(blk->quiesce_counter);
2405 assert(blk->public.throttle_group_member.io_limits_disabled);
2406 qatomic_dec(&blk->public.throttle_group_member.io_limits_disabled);
2408 if (--blk->quiesce_counter == 0) {
2409 if (blk->dev_ops && blk->dev_ops->drained_end) {
2410 blk->dev_ops->drained_end(blk->dev_opaque);
2412 while (qemu_co_enter_next(&blk->queued_requests, NULL)) {
2413 /* Resume all queued requests */
2418 void blk_register_buf(BlockBackend *blk, void *host, size_t size)
2420 bdrv_register_buf(blk_bs(blk), host, size);
2423 void blk_unregister_buf(BlockBackend *blk, void *host)
2425 bdrv_unregister_buf(blk_bs(blk), host);
2428 int coroutine_fn blk_co_copy_range(BlockBackend *blk_in, int64_t off_in,
2429 BlockBackend *blk_out, int64_t off_out,
2430 int bytes, BdrvRequestFlags read_flags,
2431 BdrvRequestFlags write_flags)
2433 int r;
2434 r = blk_check_byte_request(blk_in, off_in, bytes);
2435 if (r) {
2436 return r;
2438 r = blk_check_byte_request(blk_out, off_out, bytes);
2439 if (r) {
2440 return r;
2442 return bdrv_co_copy_range(blk_in->root, off_in,
2443 blk_out->root, off_out,
2444 bytes, read_flags, write_flags);
2447 const BdrvChild *blk_root(BlockBackend *blk)
2449 return blk->root;
2452 int blk_make_empty(BlockBackend *blk, Error **errp)
2454 if (!blk_is_available(blk)) {
2455 error_setg(errp, "No medium inserted");
2456 return -ENOMEDIUM;
2459 return bdrv_make_empty(blk->root, errp);