126f54e9aSMarkus Armbruster /*
226f54e9aSMarkus Armbruster * QEMU Block backends
326f54e9aSMarkus Armbruster *
460cb2fa7SEric Blake * Copyright (C) 2014-2016 Red Hat, Inc.
526f54e9aSMarkus Armbruster *
626f54e9aSMarkus Armbruster * Authors:
726f54e9aSMarkus Armbruster * Markus Armbruster <armbru@redhat.com>,
826f54e9aSMarkus Armbruster *
926f54e9aSMarkus Armbruster * This work is licensed under the terms of the GNU LGPL, version 2.1
1026f54e9aSMarkus Armbruster * or later. See the COPYING.LIB file in the top-level directory.
1126f54e9aSMarkus Armbruster */
1226f54e9aSMarkus Armbruster
1380c71a24SPeter Maydell #include "qemu/osdep.h"
1426f54e9aSMarkus Armbruster #include "sysemu/block-backend.h"
1526f54e9aSMarkus Armbruster #include "block/block_int.h"
16373340b2SMax Reitz #include "block/blockjob.h"
1716d36e29SVladimir Sementsov-Ogievskiy #include "block/coroutines.h"
18281d22d8SMax Reitz #include "block/throttle-groups.h"
1913d4ff07SMarkus Armbruster #include "hw/qdev-core.h"
2018e46a03SMarkus Armbruster #include "sysemu/blockdev.h"
2154d31236SMarkus Armbruster #include "sysemu/runstate.h"
22e4ec5ad4SPavel Dovgalyuk #include "sysemu/replay.h"
23e688df6bSMarkus Armbruster #include "qapi/error.h"
249af23989SMarkus Armbruster #include "qapi/qapi-events-block.h"
25f348b6d1SVeronia Bahaa #include "qemu/id.h"
26db725815SMarkus Armbruster #include "qemu/main-loop.h"
27922a01a0SMarkus Armbruster #include "qemu/option.h"
281e98fefdSKevin Wolf #include "trace.h"
295f7772c4SFam Zheng #include "migration/misc.h"
30a7f53e26SMarkus Armbruster
31a7f53e26SMarkus Armbruster /* Number of coroutines to reserve per attached device model */
32a7f53e26SMarkus Armbruster #define COROUTINE_POOL_RESERVATION 64
3326f54e9aSMarkus Armbruster
341bf1cbc9SKevin Wolf #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
351bf1cbc9SKevin Wolf
36d03654eaSStefan Hajnoczi typedef struct BlockBackendAioNotifier {
37d03654eaSStefan Hajnoczi void (*attached_aio_context)(AioContext *new_context, void *opaque);
38d03654eaSStefan Hajnoczi void (*detach_aio_context)(void *opaque);
39d03654eaSStefan Hajnoczi void *opaque;
40d03654eaSStefan Hajnoczi QLIST_ENTRY(BlockBackendAioNotifier) list;
41d03654eaSStefan Hajnoczi } BlockBackendAioNotifier;
42d03654eaSStefan Hajnoczi
4326f54e9aSMarkus Armbruster struct BlockBackend {
4426f54e9aSMarkus Armbruster char *name;
4526f54e9aSMarkus Armbruster int refcnt;
46f21d96d0SKevin Wolf BdrvChild *root;
47ad893672SHanna Czenczek AioContext *ctx; /* access with atomic operations only */
4826f8b3a8SMarkus Armbruster DriveInfo *legacy_dinfo; /* null unless created by drive_new() */
492cf22d6aSMax Reitz QTAILQ_ENTRY(BlockBackend) link; /* for block_backends */
509492b0b9SMax Reitz QTAILQ_ENTRY(BlockBackend) monitor_link; /* for monitor_block_backends */
51f2cd875dSKevin Wolf BlockBackendPublic public;
52a7f53e26SMarkus Armbruster
53d09ea2d2SThomas Huth DeviceState *dev; /* attached device model, if any */
54a7f53e26SMarkus Armbruster const BlockDevOps *dev_ops;
55a7f53e26SMarkus Armbruster void *dev_opaque;
5668e9ec01SMax Reitz
57281d22d8SMax Reitz /* If the BDS tree is removed, some of its options are stored here (which
58281d22d8SMax Reitz * can be used to restore those options in the new BDS on insert) */
59281d22d8SMax Reitz BlockBackendRootState root_state;
60281d22d8SMax Reitz
61bfd18d1eSKevin Wolf bool enable_write_cache;
62bfd18d1eSKevin Wolf
637f0e9da6SMax Reitz /* I/O stats (display with "info blockstats"). */
647f0e9da6SMax Reitz BlockAcctStats stats;
65373340b2SMax Reitz
66373340b2SMax Reitz BlockdevOnError on_read_error, on_write_error;
67373340b2SMax Reitz bool iostatus_enabled;
68373340b2SMax Reitz BlockDeviceIoStatus iostatus;
693301f6c6SMax Reitz
70981776b3SKevin Wolf uint64_t perm;
71981776b3SKevin Wolf uint64_t shared_perm;
72d35ff5e6SKevin Wolf bool disable_perm;
73981776b3SKevin Wolf
74980b0f94SKevin Wolf bool allow_aio_context_change;
75c10c9d96SKevin Wolf bool allow_write_beyond_eof;
76c10c9d96SKevin Wolf
77a2c4c3b1SEmanuele Giuseppe Esposito /* Protected by BQL */
783301f6c6SMax Reitz NotifierList remove_bs_notifiers, insert_bs_notifiers;
79d03654eaSStefan Hajnoczi QLIST_HEAD(, BlockBackendAioNotifier) aio_notifiers;
80f4d9cc88SJohn Snow
81c4d5bf99SStefan Hajnoczi int quiesce_counter; /* atomic: written under BQL, read by other threads */
82407ae2aeSStefan Hajnoczi QemuMutex queued_requests_lock; /* protects queued_requests */
83cf312932SKevin Wolf CoQueue queued_requests;
84ef80ec50SStefan Hajnoczi bool disable_request_queuing; /* atomic */
85cf312932SKevin Wolf
865f7772c4SFam Zheng VMChangeStateEntry *vmsh;
87ca2e2144SFam Zheng bool force_allow_inactivate;
8833f2a757SStefan Hajnoczi
8933f2a757SStefan Hajnoczi /* Number of in-flight aio requests. BlockDriverState also counts
9033f2a757SStefan Hajnoczi * in-flight requests but aio requests can exist even when blk->root is
9133f2a757SStefan Hajnoczi * NULL, so we cannot rely on its counter for that case.
9233f2a757SStefan Hajnoczi * Accessed with atomic ops.
9333f2a757SStefan Hajnoczi */
9433f2a757SStefan Hajnoczi unsigned int in_flight;
9526f54e9aSMarkus Armbruster };
9626f54e9aSMarkus Armbruster
97e7f7d676SMax Reitz typedef struct BlockBackendAIOCB {
98e7f7d676SMax Reitz BlockAIOCB common;
994981bdecSMax Reitz BlockBackend *blk;
100e7f7d676SMax Reitz int ret;
101e7f7d676SMax Reitz } BlockBackendAIOCB;
102e7f7d676SMax Reitz
103e7f7d676SMax Reitz static const AIOCBInfo block_backend_aiocb_info = {
104e7f7d676SMax Reitz .aiocb_size = sizeof(BlockBackendAIOCB),
105e7f7d676SMax Reitz };
106e7f7d676SMax Reitz
1078fb3c76cSMarkus Armbruster static void drive_info_del(DriveInfo *dinfo);
1087c8eece4SKevin Wolf static BlockBackend *bdrv_first_blk(BlockDriverState *bs);
1098fb3c76cSMarkus Armbruster
110a2c4c3b1SEmanuele Giuseppe Esposito /* All BlockBackends. Protected by BQL. */
1112cf22d6aSMax Reitz static QTAILQ_HEAD(, BlockBackend) block_backends =
1122cf22d6aSMax Reitz QTAILQ_HEAD_INITIALIZER(block_backends);
1132cf22d6aSMax Reitz
114a2c4c3b1SEmanuele Giuseppe Esposito /*
115a2c4c3b1SEmanuele Giuseppe Esposito * All BlockBackends referenced by the monitor and which are iterated through by
116a2c4c3b1SEmanuele Giuseppe Esposito * blk_next(). Protected by BQL.
117a2c4c3b1SEmanuele Giuseppe Esposito */
1189492b0b9SMax Reitz static QTAILQ_HEAD(, BlockBackend) monitor_block_backends =
1199492b0b9SMax Reitz QTAILQ_HEAD_INITIALIZER(monitor_block_backends);
12026f54e9aSMarkus Armbruster
1213804e3cfSKevin Wolf static int coroutine_mixed_fn GRAPH_RDLOCK
1223804e3cfSKevin Wolf blk_set_perm_locked(BlockBackend *blk, uint64_t perm, uint64_t shared_perm,
1233804e3cfSKevin Wolf Error **errp);
1243804e3cfSKevin Wolf
blk_root_inherit_options(BdrvChildRole role,bool parent_is_format,int * child_flags,QDict * child_options,int parent_flags,QDict * parent_options)1253cdc69d3SMax Reitz static void blk_root_inherit_options(BdrvChildRole role, bool parent_is_format,
126272c02eaSMax Reitz int *child_flags, QDict *child_options,
127f21d96d0SKevin Wolf int parent_flags, QDict *parent_options)
128f21d96d0SKevin Wolf {
129f21d96d0SKevin Wolf /* We're not supposed to call this function for root nodes */
130f21d96d0SKevin Wolf abort();
131f21d96d0SKevin Wolf }
132c2066af0SKevin Wolf static void blk_root_drained_begin(BdrvChild *child);
133fe5258a5SKevin Wolf static bool blk_root_drained_poll(BdrvChild *child);
1342f65df6eSKevin Wolf static void blk_root_drained_end(BdrvChild *child);
135f21d96d0SKevin Wolf
1365c8cab48SKevin Wolf static void blk_root_change_media(BdrvChild *child, bool load);
1375c8cab48SKevin Wolf static void blk_root_resize(BdrvChild *child);
1385c8cab48SKevin Wolf
13933949396SEmanuele Giuseppe Esposito static bool blk_root_change_aio_ctx(BdrvChild *child, AioContext *ctx,
14033949396SEmanuele Giuseppe Esposito GHashTable *visited, Transaction *tran,
14133949396SEmanuele Giuseppe Esposito Error **errp);
14238475269SKevin Wolf
blk_root_get_parent_desc(BdrvChild * child)143b5411555SKevin Wolf static char *blk_root_get_parent_desc(BdrvChild *child)
144b5411555SKevin Wolf {
145b5411555SKevin Wolf BlockBackend *blk = child->opaque;
146fd240a18SVladimir Sementsov-Ogievskiy g_autofree char *dev_id = NULL;
147b5411555SKevin Wolf
148b5411555SKevin Wolf if (blk->name) {
149fd240a18SVladimir Sementsov-Ogievskiy return g_strdup_printf("block device '%s'", blk->name);
150b5411555SKevin Wolf }
151b5411555SKevin Wolf
152b5411555SKevin Wolf dev_id = blk_get_attached_dev_id(blk);
153b5411555SKevin Wolf if (*dev_id) {
154fd240a18SVladimir Sementsov-Ogievskiy return g_strdup_printf("block device '%s'", dev_id);
155b5411555SKevin Wolf } else {
156b5411555SKevin Wolf /* TODO Callback into the BB owner for something more detailed */
157fd240a18SVladimir Sementsov-Ogievskiy return g_strdup("an unnamed block device");
158b5411555SKevin Wolf }
159b5411555SKevin Wolf }
160b5411555SKevin Wolf
blk_root_get_name(BdrvChild * child)1614c265bf9SKevin Wolf static const char *blk_root_get_name(BdrvChild *child)
1624c265bf9SKevin Wolf {
1634c265bf9SKevin Wolf return blk_name(child->opaque);
1644c265bf9SKevin Wolf }
1654c265bf9SKevin Wolf
blk_vm_state_changed(void * opaque,bool running,RunState state)166538f0497SPhilippe Mathieu-Daudé static void blk_vm_state_changed(void *opaque, bool running, RunState state)
1675f7772c4SFam Zheng {
1685f7772c4SFam Zheng Error *local_err = NULL;
1695f7772c4SFam Zheng BlockBackend *blk = opaque;
1705f7772c4SFam Zheng
1715f7772c4SFam Zheng if (state == RUN_STATE_INMIGRATE) {
1725f7772c4SFam Zheng return;
1735f7772c4SFam Zheng }
1745f7772c4SFam Zheng
1755f7772c4SFam Zheng qemu_del_vm_change_state_handler(blk->vmsh);
1765f7772c4SFam Zheng blk->vmsh = NULL;
1775f7772c4SFam Zheng blk_set_perm(blk, blk->perm, blk->shared_perm, &local_err);
1785f7772c4SFam Zheng if (local_err) {
1795f7772c4SFam Zheng error_report_err(local_err);
1805f7772c4SFam Zheng }
1815f7772c4SFam Zheng }
1825f7772c4SFam Zheng
1834417ab7aSKevin Wolf /*
1844417ab7aSKevin Wolf * Notifies the user of the BlockBackend that migration has completed. qdev
1854417ab7aSKevin Wolf * devices can tighten their permissions in response (specifically revoke
1864417ab7aSKevin Wolf * shared write permissions that we needed for storage migration).
1874417ab7aSKevin Wolf *
1884417ab7aSKevin Wolf * If an error is returned, the VM cannot be allowed to be resumed.
1894417ab7aSKevin Wolf */
blk_root_activate(BdrvChild * child,Error ** errp)1903804e3cfSKevin Wolf static void GRAPH_RDLOCK blk_root_activate(BdrvChild *child, Error **errp)
1914417ab7aSKevin Wolf {
1924417ab7aSKevin Wolf BlockBackend *blk = child->opaque;
1934417ab7aSKevin Wolf Error *local_err = NULL;
194492a1196SHanna Reitz uint64_t saved_shared_perm;
1954417ab7aSKevin Wolf
1964417ab7aSKevin Wolf if (!blk->disable_perm) {
1974417ab7aSKevin Wolf return;
1984417ab7aSKevin Wolf }
1994417ab7aSKevin Wolf
2004417ab7aSKevin Wolf blk->disable_perm = false;
2014417ab7aSKevin Wolf
202492a1196SHanna Reitz /*
203492a1196SHanna Reitz * blk->shared_perm contains the permissions we want to share once
204492a1196SHanna Reitz * migration is really completely done. For now, we need to share
205492a1196SHanna Reitz * all; but we also need to retain blk->shared_perm, which is
206492a1196SHanna Reitz * overwritten by a successful blk_set_perm() call. Save it and
207492a1196SHanna Reitz * restore it below.
208492a1196SHanna Reitz */
209492a1196SHanna Reitz saved_shared_perm = blk->shared_perm;
210492a1196SHanna Reitz
2113804e3cfSKevin Wolf blk_set_perm_locked(blk, blk->perm, BLK_PERM_ALL, &local_err);
2125f7772c4SFam Zheng if (local_err) {
2135f7772c4SFam Zheng error_propagate(errp, local_err);
2145f7772c4SFam Zheng blk->disable_perm = true;
2155f7772c4SFam Zheng return;
2165f7772c4SFam Zheng }
217492a1196SHanna Reitz blk->shared_perm = saved_shared_perm;
2185f7772c4SFam Zheng
2195f7772c4SFam Zheng if (runstate_check(RUN_STATE_INMIGRATE)) {
2205f7772c4SFam Zheng /* Activation can happen when migration process is still active, for
2215f7772c4SFam Zheng * example when nbd_server_add is called during non-shared storage
2225f7772c4SFam Zheng * migration. Defer the shared_perm update to migration completion. */
2235f7772c4SFam Zheng if (!blk->vmsh) {
2245f7772c4SFam Zheng blk->vmsh = qemu_add_vm_change_state_handler(blk_vm_state_changed,
2255f7772c4SFam Zheng blk);
2265f7772c4SFam Zheng }
2275f7772c4SFam Zheng return;
2285f7772c4SFam Zheng }
2295f7772c4SFam Zheng
2303804e3cfSKevin Wolf blk_set_perm_locked(blk, blk->perm, blk->shared_perm, &local_err);
2314417ab7aSKevin Wolf if (local_err) {
2324417ab7aSKevin Wolf error_propagate(errp, local_err);
2334417ab7aSKevin Wolf blk->disable_perm = true;
2344417ab7aSKevin Wolf return;
2354417ab7aSKevin Wolf }
2364417ab7aSKevin Wolf }
2374417ab7aSKevin Wolf
blk_set_force_allow_inactivate(BlockBackend * blk)238ca2e2144SFam Zheng void blk_set_force_allow_inactivate(BlockBackend *blk)
239ca2e2144SFam Zheng {
2400439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
241ca2e2144SFam Zheng blk->force_allow_inactivate = true;
242ca2e2144SFam Zheng }
243ca2e2144SFam Zheng
blk_can_inactivate(BlockBackend * blk)244c16de8f5SFam Zheng static bool blk_can_inactivate(BlockBackend *blk)
245c16de8f5SFam Zheng {
246ca2e2144SFam Zheng /* If it is a guest device, inactivate is ok. */
247c16de8f5SFam Zheng if (blk->dev || blk_name(blk)[0]) {
248c16de8f5SFam Zheng return true;
249c16de8f5SFam Zheng }
250c16de8f5SFam Zheng
251ca2e2144SFam Zheng /* Inactivating means no more writes to the image can be done,
252ca2e2144SFam Zheng * even if those writes would be changes invisible to the
253ca2e2144SFam Zheng * guest. For block job BBs that satisfy this, we can just allow
254ca2e2144SFam Zheng * it. This is the case for mirror job source, which is required
255ca2e2144SFam Zheng * by libvirt non-shared block migration. */
256ca2e2144SFam Zheng if (!(blk->perm & (BLK_PERM_WRITE | BLK_PERM_WRITE_UNCHANGED))) {
257ca2e2144SFam Zheng return true;
258ca2e2144SFam Zheng }
259ca2e2144SFam Zheng
260ca2e2144SFam Zheng return blk->force_allow_inactivate;
261c16de8f5SFam Zheng }
262c16de8f5SFam Zheng
blk_root_inactivate(BdrvChild * child)2633804e3cfSKevin Wolf static int GRAPH_RDLOCK blk_root_inactivate(BdrvChild *child)
264cfa1a572SKevin Wolf {
265cfa1a572SKevin Wolf BlockBackend *blk = child->opaque;
266cfa1a572SKevin Wolf
267cfa1a572SKevin Wolf if (blk->disable_perm) {
268cfa1a572SKevin Wolf return 0;
269cfa1a572SKevin Wolf }
270cfa1a572SKevin Wolf
271c16de8f5SFam Zheng if (!blk_can_inactivate(blk)) {
272cfa1a572SKevin Wolf return -EPERM;
273cfa1a572SKevin Wolf }
274cfa1a572SKevin Wolf
275cfa1a572SKevin Wolf blk->disable_perm = true;
276cfa1a572SKevin Wolf if (blk->root) {
277cfa1a572SKevin Wolf bdrv_child_try_set_perm(blk->root, 0, BLK_PERM_ALL, &error_abort);
278cfa1a572SKevin Wolf }
279cfa1a572SKevin Wolf
280cfa1a572SKevin Wolf return 0;
281cfa1a572SKevin Wolf }
282cfa1a572SKevin Wolf
blk_root_attach(BdrvChild * child)283d03654eaSStefan Hajnoczi static void blk_root_attach(BdrvChild *child)
284d03654eaSStefan Hajnoczi {
285d03654eaSStefan Hajnoczi BlockBackend *blk = child->opaque;
286d03654eaSStefan Hajnoczi BlockBackendAioNotifier *notifier;
287d03654eaSStefan Hajnoczi
288d03654eaSStefan Hajnoczi trace_blk_root_attach(child, blk, child->bs);
289d03654eaSStefan Hajnoczi
290d03654eaSStefan Hajnoczi QLIST_FOREACH(notifier, &blk->aio_notifiers, list) {
291d03654eaSStefan Hajnoczi bdrv_add_aio_context_notifier(child->bs,
292d03654eaSStefan Hajnoczi notifier->attached_aio_context,
293d03654eaSStefan Hajnoczi notifier->detach_aio_context,
294d03654eaSStefan Hajnoczi notifier->opaque);
295d03654eaSStefan Hajnoczi }
296d03654eaSStefan Hajnoczi }
297d03654eaSStefan Hajnoczi
blk_root_detach(BdrvChild * child)298d03654eaSStefan Hajnoczi static void blk_root_detach(BdrvChild *child)
299d03654eaSStefan Hajnoczi {
300d03654eaSStefan Hajnoczi BlockBackend *blk = child->opaque;
301d03654eaSStefan Hajnoczi BlockBackendAioNotifier *notifier;
302d03654eaSStefan Hajnoczi
303d03654eaSStefan Hajnoczi trace_blk_root_detach(child, blk, child->bs);
304d03654eaSStefan Hajnoczi
305d03654eaSStefan Hajnoczi QLIST_FOREACH(notifier, &blk->aio_notifiers, list) {
306d03654eaSStefan Hajnoczi bdrv_remove_aio_context_notifier(child->bs,
307d03654eaSStefan Hajnoczi notifier->attached_aio_context,
308d03654eaSStefan Hajnoczi notifier->detach_aio_context,
309d03654eaSStefan Hajnoczi notifier->opaque);
310d03654eaSStefan Hajnoczi }
311d03654eaSStefan Hajnoczi }
312d03654eaSStefan Hajnoczi
blk_root_get_parent_aio_context(BdrvChild * c)3133ca1f322SVladimir Sementsov-Ogievskiy static AioContext *blk_root_get_parent_aio_context(BdrvChild *c)
3143ca1f322SVladimir Sementsov-Ogievskiy {
3153ca1f322SVladimir Sementsov-Ogievskiy BlockBackend *blk = c->opaque;
316d5f8d79cSHanna Reitz IO_CODE();
3173ca1f322SVladimir Sementsov-Ogievskiy
3183ca1f322SVladimir Sementsov-Ogievskiy return blk_get_aio_context(blk);
3193ca1f322SVladimir Sementsov-Ogievskiy }
3203ca1f322SVladimir Sementsov-Ogievskiy
321bd86fb99SMax Reitz static const BdrvChildClass child_root = {
322f21d96d0SKevin Wolf .inherit_options = blk_root_inherit_options,
323c2066af0SKevin Wolf
3245c8cab48SKevin Wolf .change_media = blk_root_change_media,
3255c8cab48SKevin Wolf .resize = blk_root_resize,
3264c265bf9SKevin Wolf .get_name = blk_root_get_name,
327b5411555SKevin Wolf .get_parent_desc = blk_root_get_parent_desc,
3285c8cab48SKevin Wolf
329c2066af0SKevin Wolf .drained_begin = blk_root_drained_begin,
330fe5258a5SKevin Wolf .drained_poll = blk_root_drained_poll,
331c2066af0SKevin Wolf .drained_end = blk_root_drained_end,
3324417ab7aSKevin Wolf
3334417ab7aSKevin Wolf .activate = blk_root_activate,
334cfa1a572SKevin Wolf .inactivate = blk_root_inactivate,
335d03654eaSStefan Hajnoczi
336d03654eaSStefan Hajnoczi .attach = blk_root_attach,
337d03654eaSStefan Hajnoczi .detach = blk_root_detach,
33838475269SKevin Wolf
33933949396SEmanuele Giuseppe Esposito .change_aio_ctx = blk_root_change_aio_ctx,
3403ca1f322SVladimir Sementsov-Ogievskiy
3413ca1f322SVladimir Sementsov-Ogievskiy .get_parent_aio_context = blk_root_get_parent_aio_context,
342f21d96d0SKevin Wolf };
343f21d96d0SKevin Wolf
34426f54e9aSMarkus Armbruster /*
345efaa7c4eSMax Reitz * Create a new BlockBackend with a reference count of one.
3466d0eb64dSKevin Wolf *
3476d0eb64dSKevin Wolf * @perm is a bitmasks of BLK_PERM_* constants which describes the permissions
3486d0eb64dSKevin Wolf * to request for a block driver node that is attached to this BlockBackend.
3496d0eb64dSKevin Wolf * @shared_perm is a bitmask which describes which permissions may be granted
3506d0eb64dSKevin Wolf * to other users of the attached node.
3516d0eb64dSKevin Wolf * Both sets of permissions can be changed later using blk_set_perm().
3526d0eb64dSKevin Wolf *
35326f54e9aSMarkus Armbruster * Return the new BlockBackend on success, null on failure.
35426f54e9aSMarkus Armbruster */
blk_new(AioContext * ctx,uint64_t perm,uint64_t shared_perm)355d861ab3aSKevin Wolf BlockBackend *blk_new(AioContext *ctx, uint64_t perm, uint64_t shared_perm)
35626f54e9aSMarkus Armbruster {
35726f54e9aSMarkus Armbruster BlockBackend *blk;
35826f54e9aSMarkus Armbruster
3590439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
3600439c5a4SEmanuele Giuseppe Esposito
36126f54e9aSMarkus Armbruster blk = g_new0(BlockBackend, 1);
36226f54e9aSMarkus Armbruster blk->refcnt = 1;
363d861ab3aSKevin Wolf blk->ctx = ctx;
3646d0eb64dSKevin Wolf blk->perm = perm;
3656d0eb64dSKevin Wolf blk->shared_perm = shared_perm;
3660c3169dfSKevin Wolf blk_set_enable_write_cache(blk, true);
3670c3169dfSKevin Wolf
368cb53460bSKevin Wolf blk->on_read_error = BLOCKDEV_ON_ERROR_REPORT;
369cb53460bSKevin Wolf blk->on_write_error = BLOCKDEV_ON_ERROR_ENOSPC;
370cb53460bSKevin Wolf
3719caa6f3dSPaolo Bonzini block_acct_init(&blk->stats);
37227ccdd52SKevin Wolf
373407ae2aeSStefan Hajnoczi qemu_mutex_init(&blk->queued_requests_lock);
374cf312932SKevin Wolf qemu_co_queue_init(&blk->queued_requests);
3753301f6c6SMax Reitz notifier_list_init(&blk->remove_bs_notifiers);
3763301f6c6SMax Reitz notifier_list_init(&blk->insert_bs_notifiers);
377d03654eaSStefan Hajnoczi QLIST_INIT(&blk->aio_notifiers);
37827ccdd52SKevin Wolf
3792cf22d6aSMax Reitz QTAILQ_INSERT_TAIL(&block_backends, blk, link);
38026f54e9aSMarkus Armbruster return blk;
38126f54e9aSMarkus Armbruster }
38226f54e9aSMarkus Armbruster
3837e7d56d9SMarkus Armbruster /*
384a3aeeab5SEric Blake * Create a new BlockBackend connected to an existing BlockDriverState.
385a3aeeab5SEric Blake *
386a3aeeab5SEric Blake * @perm is a bitmasks of BLK_PERM_* constants which describes the
387a3aeeab5SEric Blake * permissions to request for @bs that is attached to this
388a3aeeab5SEric Blake * BlockBackend. @shared_perm is a bitmask which describes which
389a3aeeab5SEric Blake * permissions may be granted to other users of the attached node.
390a3aeeab5SEric Blake * Both sets of permissions can be changed later using blk_set_perm().
391a3aeeab5SEric Blake *
392a3aeeab5SEric Blake * Return the new BlockBackend on success, null on failure.
393a3aeeab5SEric Blake */
blk_new_with_bs(BlockDriverState * bs,uint64_t perm,uint64_t shared_perm,Error ** errp)394a3aeeab5SEric Blake BlockBackend *blk_new_with_bs(BlockDriverState *bs, uint64_t perm,
395a3aeeab5SEric Blake uint64_t shared_perm, Error **errp)
396a3aeeab5SEric Blake {
397a3aeeab5SEric Blake BlockBackend *blk = blk_new(bdrv_get_aio_context(bs), perm, shared_perm);
398a3aeeab5SEric Blake
3990439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
4000439c5a4SEmanuele Giuseppe Esposito
401a3aeeab5SEric Blake if (blk_insert_bs(blk, bs, errp) < 0) {
402a3aeeab5SEric Blake blk_unref(blk);
403a3aeeab5SEric Blake return NULL;
404a3aeeab5SEric Blake }
405a3aeeab5SEric Blake return blk;
406a3aeeab5SEric Blake }
407a3aeeab5SEric Blake
408a3aeeab5SEric Blake /*
40928eb9b12SMax Reitz * Creates a new BlockBackend, opens a new BlockDriverState, and connects both.
4104c20dd24SKevin Wolf * By default, the new BlockBackend is in the main AioContext, but if the
4114c20dd24SKevin Wolf * parameters connect it with any existing node in a different AioContext, it
4124c20dd24SKevin Wolf * may end up there instead.
413ca49a4fdSMax Reitz *
414ca49a4fdSMax Reitz * Just as with bdrv_open(), after having called this function the reference to
415ca49a4fdSMax Reitz * @options belongs to the block layer (even on failure).
416ca49a4fdSMax Reitz *
417ca49a4fdSMax Reitz * TODO: Remove @filename and @flags; it should be possible to specify a whole
418ca49a4fdSMax Reitz * BDS tree just by specifying the @options QDict (or @reference,
419ca49a4fdSMax Reitz * alternatively). At the time of adding this function, this is not possible,
420ca49a4fdSMax Reitz * though, so callers of this function have to be able to specify @filename and
421ca49a4fdSMax Reitz * @flags.
422ca49a4fdSMax Reitz */
blk_new_open(const char * filename,const char * reference,QDict * options,int flags,Error ** errp)423efaa7c4eSMax Reitz BlockBackend *blk_new_open(const char *filename, const char *reference,
424efaa7c4eSMax Reitz QDict *options, int flags, Error **errp)
425ca49a4fdSMax Reitz {
426ca49a4fdSMax Reitz BlockBackend *blk;
42728eb9b12SMax Reitz BlockDriverState *bs;
4281f4ad7d3SKevin Wolf uint64_t perm = 0;
42935b7f4abSKevin Wolf uint64_t shared = BLK_PERM_ALL;
430ca49a4fdSMax Reitz
4310439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
4320439c5a4SEmanuele Giuseppe Esposito
43335b7f4abSKevin Wolf /*
43435b7f4abSKevin Wolf * blk_new_open() is mainly used in .bdrv_create implementations and the
43535b7f4abSKevin Wolf * tools where sharing isn't a major concern because the BDS stays private
43635b7f4abSKevin Wolf * and the file is generally not supposed to be used by a second process,
43735b7f4abSKevin Wolf * so we just request permission according to the flags.
438c62d32f5SKevin Wolf *
439c62d32f5SKevin Wolf * The exceptions are xen_disk and blockdev_init(); in these cases, the
440c62d32f5SKevin Wolf * caller of blk_new_open() doesn't make use of the permissions, but they
441c62d32f5SKevin Wolf * shouldn't hurt either. We can still share everything here because the
44235b7f4abSKevin Wolf * guest devices will add their own blockers if they can't share.
44335b7f4abSKevin Wolf */
4441f4ad7d3SKevin Wolf if ((flags & BDRV_O_NO_IO) == 0) {
4451f4ad7d3SKevin Wolf perm |= BLK_PERM_CONSISTENT_READ;
446c62d32f5SKevin Wolf if (flags & BDRV_O_RDWR) {
447c62d32f5SKevin Wolf perm |= BLK_PERM_WRITE;
448c62d32f5SKevin Wolf }
4491f4ad7d3SKevin Wolf }
450c62d32f5SKevin Wolf if (flags & BDRV_O_RESIZE) {
451c62d32f5SKevin Wolf perm |= BLK_PERM_RESIZE;
452c62d32f5SKevin Wolf }
45335b7f4abSKevin Wolf if (flags & BDRV_O_NO_SHARE) {
45435b7f4abSKevin Wolf shared = BLK_PERM_CONSISTENT_READ | BLK_PERM_WRITE_UNCHANGED;
45535b7f4abSKevin Wolf }
456c62d32f5SKevin Wolf
4575b363937SMax Reitz bs = bdrv_open(filename, reference, options, flags, errp);
4585b363937SMax Reitz if (!bs) {
459ca49a4fdSMax Reitz return NULL;
460ca49a4fdSMax Reitz }
461ca49a4fdSMax Reitz
4624c20dd24SKevin Wolf /* bdrv_open() could have moved bs to a different AioContext */
4634c20dd24SKevin Wolf blk = blk_new(bdrv_get_aio_context(bs), perm, shared);
4644c20dd24SKevin Wolf blk->perm = perm;
4654c20dd24SKevin Wolf blk->shared_perm = shared;
4664c20dd24SKevin Wolf
4674c20dd24SKevin Wolf blk_insert_bs(blk, bs, errp);
4684c20dd24SKevin Wolf bdrv_unref(bs);
4694c20dd24SKevin Wolf
47050bfbe93SFam Zheng if (!blk->root) {
47150bfbe93SFam Zheng blk_unref(blk);
47250bfbe93SFam Zheng return NULL;
47350bfbe93SFam Zheng }
47472e775c7SKevin Wolf
475ca49a4fdSMax Reitz return blk;
476ca49a4fdSMax Reitz }
477ca49a4fdSMax Reitz
blk_delete(BlockBackend * blk)47826f54e9aSMarkus Armbruster static void blk_delete(BlockBackend *blk)
47926f54e9aSMarkus Armbruster {
48026f54e9aSMarkus Armbruster assert(!blk->refcnt);
481e5e78550SMax Reitz assert(!blk->name);
482a7f53e26SMarkus Armbruster assert(!blk->dev);
483022cdc9fSManos Pitsidianakis if (blk->public.throttle_group_member.throttle_state) {
4841606e4cfSEric Blake blk_io_limits_disable(blk);
4851606e4cfSEric Blake }
486f21d96d0SKevin Wolf if (blk->root) {
48713855c6bSMax Reitz blk_remove_bs(blk);
4887e7d56d9SMarkus Armbruster }
4895f7772c4SFam Zheng if (blk->vmsh) {
4905f7772c4SFam Zheng qemu_del_vm_change_state_handler(blk->vmsh);
4915f7772c4SFam Zheng blk->vmsh = NULL;
4925f7772c4SFam Zheng }
4933301f6c6SMax Reitz assert(QLIST_EMPTY(&blk->remove_bs_notifiers.notifiers));
4943301f6c6SMax Reitz assert(QLIST_EMPTY(&blk->insert_bs_notifiers.notifiers));
495d03654eaSStefan Hajnoczi assert(QLIST_EMPTY(&blk->aio_notifiers));
496407ae2aeSStefan Hajnoczi assert(qemu_co_queue_empty(&blk->queued_requests));
497407ae2aeSStefan Hajnoczi qemu_mutex_destroy(&blk->queued_requests_lock);
4982cf22d6aSMax Reitz QTAILQ_REMOVE(&block_backends, blk, link);
49918e46a03SMarkus Armbruster drive_info_del(blk->legacy_dinfo);
500979e9b03SAlberto Garcia block_acct_cleanup(&blk->stats);
50126f54e9aSMarkus Armbruster g_free(blk);
50226f54e9aSMarkus Armbruster }
50326f54e9aSMarkus Armbruster
drive_info_del(DriveInfo * dinfo)5048fb3c76cSMarkus Armbruster static void drive_info_del(DriveInfo *dinfo)
5058fb3c76cSMarkus Armbruster {
5068fb3c76cSMarkus Armbruster if (!dinfo) {
5078fb3c76cSMarkus Armbruster return;
5088fb3c76cSMarkus Armbruster }
5098fb3c76cSMarkus Armbruster qemu_opts_del(dinfo->opts);
5108fb3c76cSMarkus Armbruster g_free(dinfo);
5118fb3c76cSMarkus Armbruster }
5128fb3c76cSMarkus Armbruster
blk_get_refcnt(BlockBackend * blk)513f636ae85SAlberto Garcia int blk_get_refcnt(BlockBackend *blk)
514f636ae85SAlberto Garcia {
5150439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
516f636ae85SAlberto Garcia return blk ? blk->refcnt : 0;
517f636ae85SAlberto Garcia }
518f636ae85SAlberto Garcia
51926f54e9aSMarkus Armbruster /*
52026f54e9aSMarkus Armbruster * Increment @blk's reference count.
52126f54e9aSMarkus Armbruster * @blk must not be null.
52226f54e9aSMarkus Armbruster */
blk_ref(BlockBackend * blk)52326f54e9aSMarkus Armbruster void blk_ref(BlockBackend *blk)
52426f54e9aSMarkus Armbruster {
5255ca9d21bSKevin Wolf assert(blk->refcnt > 0);
5260439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
52726f54e9aSMarkus Armbruster blk->refcnt++;
52826f54e9aSMarkus Armbruster }
52926f54e9aSMarkus Armbruster
53026f54e9aSMarkus Armbruster /*
53126f54e9aSMarkus Armbruster * Decrement @blk's reference count.
53226f54e9aSMarkus Armbruster * If this drops it to zero, destroy @blk.
53326f54e9aSMarkus Armbruster * For convenience, do nothing if @blk is null.
53426f54e9aSMarkus Armbruster */
blk_unref(BlockBackend * blk)53526f54e9aSMarkus Armbruster void blk_unref(BlockBackend *blk)
53626f54e9aSMarkus Armbruster {
5370439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
53826f54e9aSMarkus Armbruster if (blk) {
53926f54e9aSMarkus Armbruster assert(blk->refcnt > 0);
5405ca9d21bSKevin Wolf if (blk->refcnt > 1) {
5415ca9d21bSKevin Wolf blk->refcnt--;
5425ca9d21bSKevin Wolf } else {
5435ca9d21bSKevin Wolf blk_drain(blk);
5445ca9d21bSKevin Wolf /* blk_drain() cannot resurrect blk, nobody held a reference */
5455ca9d21bSKevin Wolf assert(blk->refcnt == 1);
5465ca9d21bSKevin Wolf blk->refcnt = 0;
54726f54e9aSMarkus Armbruster blk_delete(blk);
54826f54e9aSMarkus Armbruster }
54926f54e9aSMarkus Armbruster }
55026f54e9aSMarkus Armbruster }
55126f54e9aSMarkus Armbruster
5522cf22d6aSMax Reitz /*
5532cf22d6aSMax Reitz * Behaves similarly to blk_next() but iterates over all BlockBackends, even the
5542cf22d6aSMax Reitz * ones which are hidden (i.e. are not referenced by the monitor).
5552cf22d6aSMax Reitz */
blk_all_next(BlockBackend * blk)556a429b9b5SKevin Wolf BlockBackend *blk_all_next(BlockBackend *blk)
5572cf22d6aSMax Reitz {
5580439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
5592cf22d6aSMax Reitz return blk ? QTAILQ_NEXT(blk, link)
5602cf22d6aSMax Reitz : QTAILQ_FIRST(&block_backends);
5612cf22d6aSMax Reitz }
5622cf22d6aSMax Reitz
blk_remove_all_bs(void)563d8da3cefSMax Reitz void blk_remove_all_bs(void)
564d8da3cefSMax Reitz {
56574d1b8fcSMax Reitz BlockBackend *blk = NULL;
566d8da3cefSMax Reitz
5670439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
5680439c5a4SEmanuele Giuseppe Esposito
5692cf22d6aSMax Reitz while ((blk = blk_all_next(blk)) != NULL) {
570f21d96d0SKevin Wolf if (blk->root) {
571d8da3cefSMax Reitz blk_remove_bs(blk);
572d8da3cefSMax Reitz }
573d8da3cefSMax Reitz }
574d8da3cefSMax Reitz }
575d8da3cefSMax Reitz
57626f54e9aSMarkus Armbruster /*
5779492b0b9SMax Reitz * Return the monitor-owned BlockBackend after @blk.
57826f54e9aSMarkus Armbruster * If @blk is null, return the first one.
57926f54e9aSMarkus Armbruster * Else, return @blk's next sibling, which may be null.
58026f54e9aSMarkus Armbruster *
58126f54e9aSMarkus Armbruster * To iterate over all BlockBackends, do
58226f54e9aSMarkus Armbruster * for (blk = blk_next(NULL); blk; blk = blk_next(blk)) {
58326f54e9aSMarkus Armbruster * ...
58426f54e9aSMarkus Armbruster * }
58526f54e9aSMarkus Armbruster */
blk_next(BlockBackend * blk)58626f54e9aSMarkus Armbruster BlockBackend *blk_next(BlockBackend *blk)
58726f54e9aSMarkus Armbruster {
5880439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
5899492b0b9SMax Reitz return blk ? QTAILQ_NEXT(blk, monitor_link)
5909492b0b9SMax Reitz : QTAILQ_FIRST(&monitor_block_backends);
59126f54e9aSMarkus Armbruster }
59226f54e9aSMarkus Armbruster
5937c8eece4SKevin Wolf /* Iterates over all top-level BlockDriverStates, i.e. BDSs that are owned by
5947c8eece4SKevin Wolf * the monitor or attached to a BlockBackend */
bdrv_next(BdrvNextIterator * it)59588be7b4bSKevin Wolf BlockDriverState *bdrv_next(BdrvNextIterator *it)
5967c8eece4SKevin Wolf {
5975e003f17SMax Reitz BlockDriverState *bs, *old_bs;
5985e003f17SMax Reitz
5995e003f17SMax Reitz /* Must be called from the main loop */
6005e003f17SMax Reitz assert(qemu_get_current_aio_context() == qemu_get_aio_context());
601981f4f57SMax Reitz
602f6d38c9fSFiona Ebner old_bs = it->bs;
603f6d38c9fSFiona Ebner
6047c8eece4SKevin Wolf /* First, return all root nodes of BlockBackends. In order to avoid
6057c8eece4SKevin Wolf * returning a BDS twice when multiple BBs refer to it, we only return it
6067c8eece4SKevin Wolf * if the BB is the first one in the parent list of the BDS. */
6077c8eece4SKevin Wolf if (it->phase == BDRV_NEXT_BACKEND_ROOTS) {
6085e003f17SMax Reitz BlockBackend *old_blk = it->blk;
6095e003f17SMax Reitz
610981f4f57SMax Reitz do {
6117c8eece4SKevin Wolf it->blk = blk_all_next(it->blk);
61288be7b4bSKevin Wolf bs = it->blk ? blk_bs(it->blk) : NULL;
61388be7b4bSKevin Wolf } while (it->blk && (bs == NULL || bdrv_first_blk(bs) != it->blk));
614981f4f57SMax Reitz
6155e003f17SMax Reitz if (it->blk) {
6165e003f17SMax Reitz blk_ref(it->blk);
6175e003f17SMax Reitz }
6185e003f17SMax Reitz blk_unref(old_blk);
6195e003f17SMax Reitz
62088be7b4bSKevin Wolf if (bs) {
6215e003f17SMax Reitz bdrv_ref(bs);
6225e003f17SMax Reitz bdrv_unref(old_bs);
623f6d38c9fSFiona Ebner it->bs = bs;
62488be7b4bSKevin Wolf return bs;
6257c8eece4SKevin Wolf }
6267c8eece4SKevin Wolf it->phase = BDRV_NEXT_MONITOR_OWNED;
6277c8eece4SKevin Wolf }
6287c8eece4SKevin Wolf
6297c8eece4SKevin Wolf /* Then return the monitor-owned BDSes without a BB attached. Ignore all
6307c8eece4SKevin Wolf * BDSes that are attached to a BlockBackend here; they have been handled
6317c8eece4SKevin Wolf * by the above block already */
6327c8eece4SKevin Wolf do {
6337c8eece4SKevin Wolf it->bs = bdrv_next_monitor_owned(it->bs);
63488be7b4bSKevin Wolf bs = it->bs;
63588be7b4bSKevin Wolf } while (bs && bdrv_has_blk(bs));
6367c8eece4SKevin Wolf
6375e003f17SMax Reitz if (bs) {
6385e003f17SMax Reitz bdrv_ref(bs);
6395e003f17SMax Reitz }
6405e003f17SMax Reitz bdrv_unref(old_bs);
6415e003f17SMax Reitz
64288be7b4bSKevin Wolf return bs;
64388be7b4bSKevin Wolf }
64488be7b4bSKevin Wolf
bdrv_next_reset(BdrvNextIterator * it)6455e003f17SMax Reitz static void bdrv_next_reset(BdrvNextIterator *it)
64688be7b4bSKevin Wolf {
64788be7b4bSKevin Wolf *it = (BdrvNextIterator) {
64888be7b4bSKevin Wolf .phase = BDRV_NEXT_BACKEND_ROOTS,
64988be7b4bSKevin Wolf };
6505e003f17SMax Reitz }
65188be7b4bSKevin Wolf
bdrv_first(BdrvNextIterator * it)6525e003f17SMax Reitz BlockDriverState *bdrv_first(BdrvNextIterator *it)
6535e003f17SMax Reitz {
6540439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
6555e003f17SMax Reitz bdrv_next_reset(it);
65688be7b4bSKevin Wolf return bdrv_next(it);
657981f4f57SMax Reitz }
658981f4f57SMax Reitz
6595e003f17SMax Reitz /* Must be called when aborting a bdrv_next() iteration before
6605e003f17SMax Reitz * bdrv_next() returns NULL */
bdrv_next_cleanup(BdrvNextIterator * it)6615e003f17SMax Reitz void bdrv_next_cleanup(BdrvNextIterator *it)
6625e003f17SMax Reitz {
6635e003f17SMax Reitz /* Must be called from the main loop */
6645e003f17SMax Reitz assert(qemu_get_current_aio_context() == qemu_get_aio_context());
6655e003f17SMax Reitz
6665e003f17SMax Reitz bdrv_unref(it->bs);
667*bac09b09SFiona Ebner
668*bac09b09SFiona Ebner if (it->phase == BDRV_NEXT_BACKEND_ROOTS && it->blk) {
669*bac09b09SFiona Ebner blk_unref(it->blk);
6705e003f17SMax Reitz }
6715e003f17SMax Reitz
6725e003f17SMax Reitz bdrv_next_reset(it);
6735e003f17SMax Reitz }
6745e003f17SMax Reitz
675981f4f57SMax Reitz /*
676e5e78550SMax Reitz * Add a BlockBackend into the list of backends referenced by the monitor, with
677e5e78550SMax Reitz * the given @name acting as the handle for the monitor.
678e5e78550SMax Reitz * Strictly for use by blockdev.c.
679e5e78550SMax Reitz *
680e5e78550SMax Reitz * @name must not be null or empty.
681e5e78550SMax Reitz *
682e5e78550SMax Reitz * Returns true on success and false on failure. In the latter case, an Error
683e5e78550SMax Reitz * object is returned through @errp.
684e5e78550SMax Reitz */
monitor_add_blk(BlockBackend * blk,const char * name,Error ** errp)685e5e78550SMax Reitz bool monitor_add_blk(BlockBackend *blk, const char *name, Error **errp)
686e5e78550SMax Reitz {
687e5e78550SMax Reitz assert(!blk->name);
688e5e78550SMax Reitz assert(name && name[0]);
6890439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
690e5e78550SMax Reitz
691e5e78550SMax Reitz if (!id_wellformed(name)) {
692e5e78550SMax Reitz error_setg(errp, "Invalid device name");
693e5e78550SMax Reitz return false;
694e5e78550SMax Reitz }
695e5e78550SMax Reitz if (blk_by_name(name)) {
696e5e78550SMax Reitz error_setg(errp, "Device with id '%s' already exists", name);
697e5e78550SMax Reitz return false;
698e5e78550SMax Reitz }
699e5e78550SMax Reitz if (bdrv_find_node(name)) {
700e5e78550SMax Reitz error_setg(errp,
701e5e78550SMax Reitz "Device name '%s' conflicts with an existing node name",
702e5e78550SMax Reitz name);
703e5e78550SMax Reitz return false;
704e5e78550SMax Reitz }
705e5e78550SMax Reitz
706e5e78550SMax Reitz blk->name = g_strdup(name);
707e5e78550SMax Reitz QTAILQ_INSERT_TAIL(&monitor_block_backends, blk, monitor_link);
708e5e78550SMax Reitz return true;
709e5e78550SMax Reitz }
710e5e78550SMax Reitz
711e5e78550SMax Reitz /*
712e5e78550SMax Reitz * Remove a BlockBackend from the list of backends referenced by the monitor.
713e5e78550SMax Reitz * Strictly for use by blockdev.c.
714e5e78550SMax Reitz */
monitor_remove_blk(BlockBackend * blk)715e5e78550SMax Reitz void monitor_remove_blk(BlockBackend *blk)
716e5e78550SMax Reitz {
7170439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
7180439c5a4SEmanuele Giuseppe Esposito
719e5e78550SMax Reitz if (!blk->name) {
720e5e78550SMax Reitz return;
721e5e78550SMax Reitz }
722e5e78550SMax Reitz
723e5e78550SMax Reitz QTAILQ_REMOVE(&monitor_block_backends, blk, monitor_link);
724e5e78550SMax Reitz g_free(blk->name);
725e5e78550SMax Reitz blk->name = NULL;
726e5e78550SMax Reitz }
727e5e78550SMax Reitz
728e5e78550SMax Reitz /*
7297e7d56d9SMarkus Armbruster * Return @blk's name, a non-null string.
730e5e78550SMax Reitz * Returns an empty string iff @blk is not referenced by the monitor.
73126f54e9aSMarkus Armbruster */
blk_name(const BlockBackend * blk)7320731a50fSKrzysztof Kozlowski const char *blk_name(const BlockBackend *blk)
73326f54e9aSMarkus Armbruster {
73437868b2aSEmanuele Giuseppe Esposito IO_CODE();
735e5e78550SMax Reitz return blk->name ?: "";
73626f54e9aSMarkus Armbruster }
73726f54e9aSMarkus Armbruster
73826f54e9aSMarkus Armbruster /*
73926f54e9aSMarkus Armbruster * Return the BlockBackend with name @name if it exists, else null.
74026f54e9aSMarkus Armbruster * @name must not be null.
74126f54e9aSMarkus Armbruster */
blk_by_name(const char * name)74226f54e9aSMarkus Armbruster BlockBackend *blk_by_name(const char *name)
74326f54e9aSMarkus Armbruster {
74474d1b8fcSMax Reitz BlockBackend *blk = NULL;
74526f54e9aSMarkus Armbruster
7460439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
74726f54e9aSMarkus Armbruster assert(name);
74874d1b8fcSMax Reitz while ((blk = blk_next(blk)) != NULL) {
74926f54e9aSMarkus Armbruster if (!strcmp(name, blk->name)) {
75026f54e9aSMarkus Armbruster return blk;
75126f54e9aSMarkus Armbruster }
75226f54e9aSMarkus Armbruster }
75326f54e9aSMarkus Armbruster return NULL;
75426f54e9aSMarkus Armbruster }
7557e7d56d9SMarkus Armbruster
7567e7d56d9SMarkus Armbruster /*
7577e7d56d9SMarkus Armbruster * Return the BlockDriverState attached to @blk if any, else null.
7587e7d56d9SMarkus Armbruster */
blk_bs(BlockBackend * blk)7597e7d56d9SMarkus Armbruster BlockDriverState *blk_bs(BlockBackend *blk)
7607e7d56d9SMarkus Armbruster {
76137868b2aSEmanuele Giuseppe Esposito IO_CODE();
762f21d96d0SKevin Wolf return blk->root ? blk->root->bs : NULL;
7637e7d56d9SMarkus Armbruster }
7647e7d56d9SMarkus Armbruster
bdrv_first_blk(BlockDriverState * bs)7652b3912f1SKevin Wolf static BlockBackend * GRAPH_RDLOCK bdrv_first_blk(BlockDriverState *bs)
766dde33812SKevin Wolf {
767dde33812SKevin Wolf BdrvChild *child;
768bdb73476SEmanuele Giuseppe Esposito
769bdb73476SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
7702b3912f1SKevin Wolf assert_bdrv_graph_readable();
771bdb73476SEmanuele Giuseppe Esposito
772dde33812SKevin Wolf QLIST_FOREACH(child, &bs->parents, next_parent) {
773bd86fb99SMax Reitz if (child->klass == &child_root) {
7747c8eece4SKevin Wolf return child->opaque;
775dde33812SKevin Wolf }
776dde33812SKevin Wolf }
777dde33812SKevin Wolf
7787c8eece4SKevin Wolf return NULL;
7797c8eece4SKevin Wolf }
7807c8eece4SKevin Wolf
7817c8eece4SKevin Wolf /*
7827c8eece4SKevin Wolf * Returns true if @bs has an associated BlockBackend.
7837c8eece4SKevin Wolf */
bdrv_has_blk(BlockDriverState * bs)7847c8eece4SKevin Wolf bool bdrv_has_blk(BlockDriverState *bs)
7857c8eece4SKevin Wolf {
7860439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
7877c8eece4SKevin Wolf return bdrv_first_blk(bs) != NULL;
788dde33812SKevin Wolf }
789dde33812SKevin Wolf
790dde33812SKevin Wolf /*
791b6c1bae5SKevin Wolf * Returns true if @bs has only BlockBackends as parents.
792b6c1bae5SKevin Wolf */
bdrv_is_root_node(BlockDriverState * bs)793b6c1bae5SKevin Wolf bool bdrv_is_root_node(BlockDriverState *bs)
794b6c1bae5SKevin Wolf {
795b6c1bae5SKevin Wolf BdrvChild *c;
796b6c1bae5SKevin Wolf
7970439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
7982b3912f1SKevin Wolf assert_bdrv_graph_readable();
7992b3912f1SKevin Wolf
800b6c1bae5SKevin Wolf QLIST_FOREACH(c, &bs->parents, next_parent) {
801bd86fb99SMax Reitz if (c->klass != &child_root) {
802b6c1bae5SKevin Wolf return false;
803b6c1bae5SKevin Wolf }
804b6c1bae5SKevin Wolf }
805b6c1bae5SKevin Wolf
806b6c1bae5SKevin Wolf return true;
807b6c1bae5SKevin Wolf }
808b6c1bae5SKevin Wolf
809b6c1bae5SKevin Wolf /*
81018e46a03SMarkus Armbruster * Return @blk's DriveInfo if any, else null.
81118e46a03SMarkus Armbruster */
blk_legacy_dinfo(BlockBackend * blk)81218e46a03SMarkus Armbruster DriveInfo *blk_legacy_dinfo(BlockBackend *blk)
81318e46a03SMarkus Armbruster {
814c5be7445SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
81518e46a03SMarkus Armbruster return blk->legacy_dinfo;
81618e46a03SMarkus Armbruster }
81718e46a03SMarkus Armbruster
81818e46a03SMarkus Armbruster /*
81918e46a03SMarkus Armbruster * Set @blk's DriveInfo to @dinfo, and return it.
82018e46a03SMarkus Armbruster * @blk must not have a DriveInfo set already.
82118e46a03SMarkus Armbruster * No other BlockBackend may have the same DriveInfo set.
82218e46a03SMarkus Armbruster */
blk_set_legacy_dinfo(BlockBackend * blk,DriveInfo * dinfo)82318e46a03SMarkus Armbruster DriveInfo *blk_set_legacy_dinfo(BlockBackend *blk, DriveInfo *dinfo)
82418e46a03SMarkus Armbruster {
82518e46a03SMarkus Armbruster assert(!blk->legacy_dinfo);
826c5be7445SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
82718e46a03SMarkus Armbruster return blk->legacy_dinfo = dinfo;
82818e46a03SMarkus Armbruster }
82918e46a03SMarkus Armbruster
83018e46a03SMarkus Armbruster /*
83118e46a03SMarkus Armbruster * Return the BlockBackend with DriveInfo @dinfo.
83218e46a03SMarkus Armbruster * It must exist.
83318e46a03SMarkus Armbruster */
blk_by_legacy_dinfo(DriveInfo * dinfo)83418e46a03SMarkus Armbruster BlockBackend *blk_by_legacy_dinfo(DriveInfo *dinfo)
83518e46a03SMarkus Armbruster {
83674d1b8fcSMax Reitz BlockBackend *blk = NULL;
837c5be7445SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
83818e46a03SMarkus Armbruster
83974d1b8fcSMax Reitz while ((blk = blk_next(blk)) != NULL) {
84018e46a03SMarkus Armbruster if (blk->legacy_dinfo == dinfo) {
84118e46a03SMarkus Armbruster return blk;
84218e46a03SMarkus Armbruster }
84318e46a03SMarkus Armbruster }
84418e46a03SMarkus Armbruster abort();
84518e46a03SMarkus Armbruster }
84618e46a03SMarkus Armbruster
84718e46a03SMarkus Armbruster /*
848f2cd875dSKevin Wolf * Returns a pointer to the publicly accessible fields of @blk.
849f2cd875dSKevin Wolf */
blk_get_public(BlockBackend * blk)850f2cd875dSKevin Wolf BlockBackendPublic *blk_get_public(BlockBackend *blk)
851f2cd875dSKevin Wolf {
8520439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
853f2cd875dSKevin Wolf return &blk->public;
854f2cd875dSKevin Wolf }
855f2cd875dSKevin Wolf
856f2cd875dSKevin Wolf /*
857f2cd875dSKevin Wolf * Returns a BlockBackend given the associated @public fields.
858f2cd875dSKevin Wolf */
blk_by_public(BlockBackendPublic * public)859f2cd875dSKevin Wolf BlockBackend *blk_by_public(BlockBackendPublic *public)
860f2cd875dSKevin Wolf {
8610439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
862f2cd875dSKevin Wolf return container_of(public, BlockBackend, public);
863f2cd875dSKevin Wolf }
864f2cd875dSKevin Wolf
865f2cd875dSKevin Wolf /*
8661c95f7e1SMax Reitz * Disassociates the currently associated BlockDriverState from @blk.
8671c95f7e1SMax Reitz */
blk_remove_bs(BlockBackend * blk)8681c95f7e1SMax Reitz void blk_remove_bs(BlockBackend *blk)
8691c95f7e1SMax Reitz {
870c89bcf3aSAlberto Garcia ThrottleGroupMember *tgm = &blk->public.throttle_group_member;
871e6cada92SGreg Kurz BdrvChild *root;
872022cdc9fSManos Pitsidianakis
8730439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
8740439c5a4SEmanuele Giuseppe Esposito
8753301f6c6SMax Reitz notifier_list_notify(&blk->remove_bs_notifiers, blk);
876c89bcf3aSAlberto Garcia if (tgm->throttle_state) {
8771e3552dbSStefan Hajnoczi BlockDriverState *bs = blk_bs(blk);
8781e3552dbSStefan Hajnoczi
8791e3552dbSStefan Hajnoczi /*
8801e3552dbSStefan Hajnoczi * Take a ref in case blk_bs() changes across bdrv_drained_begin(), for
8811e3552dbSStefan Hajnoczi * example, if a temporary filter node is removed by a blockjob.
8821e3552dbSStefan Hajnoczi */
8831e3552dbSStefan Hajnoczi bdrv_ref(bs);
884632a7735SZhengui bdrv_drained_begin(bs);
885c89bcf3aSAlberto Garcia throttle_group_detach_aio_context(tgm);
886c89bcf3aSAlberto Garcia throttle_group_attach_aio_context(tgm, qemu_get_aio_context());
887632a7735SZhengui bdrv_drained_end(bs);
8881e3552dbSStefan Hajnoczi bdrv_unref(bs);
8897ca7f0f6SKevin Wolf }
8903301f6c6SMax Reitz
8911c95f7e1SMax Reitz blk_update_root_state(blk);
8921c95f7e1SMax Reitz
893f45280cbSGreg Kurz /* bdrv_root_unref_child() will cause blk->root to become stale and may
894f45280cbSGreg Kurz * switch to a completion coroutine later on. Let's drain all I/O here
895f45280cbSGreg Kurz * to avoid that and a potential QEMU crash.
896f45280cbSGreg Kurz */
897f45280cbSGreg Kurz blk_drain(blk);
898e6cada92SGreg Kurz root = blk->root;
899f21d96d0SKevin Wolf blk->root = NULL;
900ede01e46SKevin Wolf
9016bc30f19SStefan Hajnoczi bdrv_graph_wrlock();
902e6cada92SGreg Kurz bdrv_root_unref_child(root);
9036bc30f19SStefan Hajnoczi bdrv_graph_wrunlock();
9041c95f7e1SMax Reitz }
9051c95f7e1SMax Reitz
9061c95f7e1SMax Reitz /*
9070c3c36d6SMax Reitz * Associates a new BlockDriverState with @blk.
9080c3c36d6SMax Reitz */
blk_insert_bs(BlockBackend * blk,BlockDriverState * bs,Error ** errp)909d7086422SKevin Wolf int blk_insert_bs(BlockBackend *blk, BlockDriverState *bs, Error **errp)
9100c3c36d6SMax Reitz {
911c89bcf3aSAlberto Garcia ThrottleGroupMember *tgm = &blk->public.throttle_group_member;
9126bc0bcc8SKevin Wolf
9130439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
914b441dc71SAlberto Garcia bdrv_ref(bs);
9156bc30f19SStefan Hajnoczi bdrv_graph_wrlock();
9161f38f04eSMax Reitz blk->root = bdrv_root_attach_child(bs, "root", &child_root,
9171f38f04eSMax Reitz BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY,
918228ca37eSVladimir Sementsov-Ogievskiy blk->perm, blk->shared_perm,
9191f38f04eSMax Reitz blk, errp);
9206bc30f19SStefan Hajnoczi bdrv_graph_wrunlock();
921d7086422SKevin Wolf if (blk->root == NULL) {
922d7086422SKevin Wolf return -EPERM;
923d7086422SKevin Wolf }
9243301f6c6SMax Reitz
9253301f6c6SMax Reitz notifier_list_notify(&blk->insert_bs_notifiers, blk);
926c89bcf3aSAlberto Garcia if (tgm->throttle_state) {
927c89bcf3aSAlberto Garcia throttle_group_detach_aio_context(tgm);
928c89bcf3aSAlberto Garcia throttle_group_attach_aio_context(tgm, bdrv_get_aio_context(bs));
9297ca7f0f6SKevin Wolf }
930d7086422SKevin Wolf
931d7086422SKevin Wolf return 0;
9320c3c36d6SMax Reitz }
9330c3c36d6SMax Reitz
934981776b3SKevin Wolf /*
935ed089506SVladimir Sementsov-Ogievskiy * Change BlockDriverState associated with @blk.
936ed089506SVladimir Sementsov-Ogievskiy */
blk_replace_bs(BlockBackend * blk,BlockDriverState * new_bs,Error ** errp)937ed089506SVladimir Sementsov-Ogievskiy int blk_replace_bs(BlockBackend *blk, BlockDriverState *new_bs, Error **errp)
938ed089506SVladimir Sementsov-Ogievskiy {
9390439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
940ed089506SVladimir Sementsov-Ogievskiy return bdrv_replace_child_bs(blk->root, new_bs, errp);
941ed089506SVladimir Sementsov-Ogievskiy }
942ed089506SVladimir Sementsov-Ogievskiy
943ed089506SVladimir Sementsov-Ogievskiy /*
944981776b3SKevin Wolf * Sets the permission bitmasks that the user of the BlockBackend needs.
945981776b3SKevin Wolf */
9463804e3cfSKevin Wolf static int coroutine_mixed_fn GRAPH_RDLOCK
blk_set_perm_locked(BlockBackend * blk,uint64_t perm,uint64_t shared_perm,Error ** errp)9473804e3cfSKevin Wolf blk_set_perm_locked(BlockBackend *blk, uint64_t perm, uint64_t shared_perm,
948981776b3SKevin Wolf Error **errp)
949981776b3SKevin Wolf {
950981776b3SKevin Wolf int ret;
9510439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
952981776b3SKevin Wolf
953d35ff5e6SKevin Wolf if (blk->root && !blk->disable_perm) {
954981776b3SKevin Wolf ret = bdrv_child_try_set_perm(blk->root, perm, shared_perm, errp);
955981776b3SKevin Wolf if (ret < 0) {
956981776b3SKevin Wolf return ret;
957981776b3SKevin Wolf }
958981776b3SKevin Wolf }
959981776b3SKevin Wolf
960981776b3SKevin Wolf blk->perm = perm;
961981776b3SKevin Wolf blk->shared_perm = shared_perm;
962981776b3SKevin Wolf
963981776b3SKevin Wolf return 0;
964981776b3SKevin Wolf }
965981776b3SKevin Wolf
blk_set_perm(BlockBackend * blk,uint64_t perm,uint64_t shared_perm,Error ** errp)9663804e3cfSKevin Wolf int blk_set_perm(BlockBackend *blk, uint64_t perm, uint64_t shared_perm,
9673804e3cfSKevin Wolf Error **errp)
9683804e3cfSKevin Wolf {
9693804e3cfSKevin Wolf GLOBAL_STATE_CODE();
9703804e3cfSKevin Wolf GRAPH_RDLOCK_GUARD_MAINLOOP();
9713804e3cfSKevin Wolf
9723804e3cfSKevin Wolf return blk_set_perm_locked(blk, perm, shared_perm, errp);
9733804e3cfSKevin Wolf }
9743804e3cfSKevin Wolf
blk_get_perm(BlockBackend * blk,uint64_t * perm,uint64_t * shared_perm)975887354bdSKevin Wolf void blk_get_perm(BlockBackend *blk, uint64_t *perm, uint64_t *shared_perm)
976887354bdSKevin Wolf {
9770439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
978887354bdSKevin Wolf *perm = blk->perm;
979887354bdSKevin Wolf *shared_perm = blk->shared_perm;
980887354bdSKevin Wolf }
981887354bdSKevin Wolf
982d09ea2d2SThomas Huth /*
983d09ea2d2SThomas Huth * Attach device model @dev to @blk.
984d09ea2d2SThomas Huth * Return 0 on success, -EBUSY when a device model is attached already.
985d09ea2d2SThomas Huth */
blk_attach_dev(BlockBackend * blk,DeviceState * dev)986d09ea2d2SThomas Huth int blk_attach_dev(BlockBackend *blk, DeviceState *dev)
987a7f53e26SMarkus Armbruster {
9880439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
989a7f53e26SMarkus Armbruster if (blk->dev) {
990a7f53e26SMarkus Armbruster return -EBUSY;
991a7f53e26SMarkus Armbruster }
992d35ff5e6SKevin Wolf
993d35ff5e6SKevin Wolf /* While migration is still incoming, we don't need to apply the
994d35ff5e6SKevin Wolf * permissions of guest device BlockBackends. We might still have a block
995d35ff5e6SKevin Wolf * job or NBD server writing to the image for storage migration. */
996d35ff5e6SKevin Wolf if (runstate_check(RUN_STATE_INMIGRATE)) {
997d35ff5e6SKevin Wolf blk->disable_perm = true;
998d35ff5e6SKevin Wolf }
999d35ff5e6SKevin Wolf
100084ebe375SMarkus Armbruster blk_ref(blk);
1001a7f53e26SMarkus Armbruster blk->dev = dev;
1002373340b2SMax Reitz blk_iostatus_reset(blk);
1003d35ff5e6SKevin Wolf
1004a7f53e26SMarkus Armbruster return 0;
1005a7f53e26SMarkus Armbruster }
1006a7f53e26SMarkus Armbruster
1007a7f53e26SMarkus Armbruster /*
1008a7f53e26SMarkus Armbruster * Detach device model @dev from @blk.
1009a7f53e26SMarkus Armbruster * @dev must be currently attached to @blk.
1010a7f53e26SMarkus Armbruster */
blk_detach_dev(BlockBackend * blk,DeviceState * dev)1011d09ea2d2SThomas Huth void blk_detach_dev(BlockBackend *blk, DeviceState *dev)
1012a7f53e26SMarkus Armbruster {
1013a7f53e26SMarkus Armbruster assert(blk->dev == dev);
10140439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
1015a7f53e26SMarkus Armbruster blk->dev = NULL;
1016a7f53e26SMarkus Armbruster blk->dev_ops = NULL;
1017a7f53e26SMarkus Armbruster blk->dev_opaque = NULL;
1018981776b3SKevin Wolf blk_set_perm(blk, 0, BLK_PERM_ALL, &error_abort);
101984ebe375SMarkus Armbruster blk_unref(blk);
1020a7f53e26SMarkus Armbruster }
1021a7f53e26SMarkus Armbruster
1022a7f53e26SMarkus Armbruster /*
1023a7f53e26SMarkus Armbruster * Return the device model attached to @blk if any, else null.
1024a7f53e26SMarkus Armbruster */
blk_get_attached_dev(BlockBackend * blk)1025d09ea2d2SThomas Huth DeviceState *blk_get_attached_dev(BlockBackend *blk)
1026a7f53e26SMarkus Armbruster {
10270439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
1028a7f53e26SMarkus Armbruster return blk->dev;
1029a7f53e26SMarkus Armbruster }
1030a7f53e26SMarkus Armbruster
10312d76e724SKevin Wolf /* Return the qdev ID, or if no ID is assigned the QOM path, of the block
10322d76e724SKevin Wolf * device attached to the BlockBackend. */
blk_get_attached_dev_id(BlockBackend * blk)103377beef83SKevin Wolf char *blk_get_attached_dev_id(BlockBackend *blk)
10342d76e724SKevin Wolf {
1035d09ea2d2SThomas Huth DeviceState *dev = blk->dev;
103637868b2aSEmanuele Giuseppe Esposito IO_CODE();
10372d76e724SKevin Wolf
10382d76e724SKevin Wolf if (!dev) {
10392d76e724SKevin Wolf return g_strdup("");
10402d76e724SKevin Wolf } else if (dev->id) {
10412d76e724SKevin Wolf return g_strdup(dev->id);
10422d76e724SKevin Wolf }
1043602414d1SLiam Merwick
1044602414d1SLiam Merwick return object_get_canonical_path(OBJECT(dev)) ?: g_strdup("");
10452d76e724SKevin Wolf }
10462d76e724SKevin Wolf
1047a7f53e26SMarkus Armbruster /*
10481c89e1faSKevin Wolf * Return the BlockBackend which has the device model @dev attached if it
10491c89e1faSKevin Wolf * exists, else null.
10501c89e1faSKevin Wolf *
10511c89e1faSKevin Wolf * @dev must not be null.
10521c89e1faSKevin Wolf */
blk_by_dev(void * dev)10531c89e1faSKevin Wolf BlockBackend *blk_by_dev(void *dev)
10541c89e1faSKevin Wolf {
10551c89e1faSKevin Wolf BlockBackend *blk = NULL;
10561c89e1faSKevin Wolf
10570439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
10580439c5a4SEmanuele Giuseppe Esposito
10591c89e1faSKevin Wolf assert(dev != NULL);
10601c89e1faSKevin Wolf while ((blk = blk_all_next(blk)) != NULL) {
10611c89e1faSKevin Wolf if (blk->dev == dev) {
10621c89e1faSKevin Wolf return blk;
10631c89e1faSKevin Wolf }
10641c89e1faSKevin Wolf }
10651c89e1faSKevin Wolf return NULL;
10661c89e1faSKevin Wolf }
10671c89e1faSKevin Wolf
10681c89e1faSKevin Wolf /*
1069a7f53e26SMarkus Armbruster * Set @blk's device model callbacks to @ops.
1070a7f53e26SMarkus Armbruster * @opaque is the opaque argument to pass to the callbacks.
1071a7f53e26SMarkus Armbruster * This is for use by device models.
1072a7f53e26SMarkus Armbruster */
blk_set_dev_ops(BlockBackend * blk,const BlockDevOps * ops,void * opaque)1073a7f53e26SMarkus Armbruster void blk_set_dev_ops(BlockBackend *blk, const BlockDevOps *ops,
1074a7f53e26SMarkus Armbruster void *opaque)
1075a7f53e26SMarkus Armbruster {
10760439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
1077a7f53e26SMarkus Armbruster blk->dev_ops = ops;
1078a7f53e26SMarkus Armbruster blk->dev_opaque = opaque;
1079f4d9cc88SJohn Snow
1080f4d9cc88SJohn Snow /* Are we currently quiesced? Should we enforce this right now? */
1081c4d5bf99SStefan Hajnoczi if (qatomic_read(&blk->quiesce_counter) && ops && ops->drained_begin) {
1082f4d9cc88SJohn Snow ops->drained_begin(opaque);
1083f4d9cc88SJohn Snow }
1084a7f53e26SMarkus Armbruster }
1085a7f53e26SMarkus Armbruster
1086a7f53e26SMarkus Armbruster /*
1087a7f53e26SMarkus Armbruster * Notify @blk's attached device model of media change.
108839829a01SKevin Wolf *
108939829a01SKevin Wolf * If @load is true, notify of media load. This action can fail, meaning that
109039829a01SKevin Wolf * the medium cannot be loaded. @errp is set then.
109139829a01SKevin Wolf *
109239829a01SKevin Wolf * If @load is false, notify of media eject. This can never fail.
109339829a01SKevin Wolf *
1094a7f53e26SMarkus Armbruster * Also send DEVICE_TRAY_MOVED events as appropriate.
1095a7f53e26SMarkus Armbruster */
blk_dev_change_media_cb(BlockBackend * blk,bool load,Error ** errp)109639829a01SKevin Wolf void blk_dev_change_media_cb(BlockBackend *blk, bool load, Error **errp)
1097a7f53e26SMarkus Armbruster {
10980439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
1099a7f53e26SMarkus Armbruster if (blk->dev_ops && blk->dev_ops->change_media_cb) {
1100f1f57066SMax Reitz bool tray_was_open, tray_is_open;
110139829a01SKevin Wolf Error *local_err = NULL;
1102a7f53e26SMarkus Armbruster
1103f1f57066SMax Reitz tray_was_open = blk_dev_is_tray_open(blk);
110439829a01SKevin Wolf blk->dev_ops->change_media_cb(blk->dev_opaque, load, &local_err);
110539829a01SKevin Wolf if (local_err) {
110639829a01SKevin Wolf assert(load == true);
110739829a01SKevin Wolf error_propagate(errp, local_err);
110839829a01SKevin Wolf return;
110939829a01SKevin Wolf }
1110f1f57066SMax Reitz tray_is_open = blk_dev_is_tray_open(blk);
1111f1f57066SMax Reitz
1112f1f57066SMax Reitz if (tray_was_open != tray_is_open) {
11132d76e724SKevin Wolf char *id = blk_get_attached_dev_id(blk);
11143ab72385SPeter Xu qapi_event_send_device_tray_moved(blk_name(blk), id, tray_is_open);
11152d76e724SKevin Wolf g_free(id);
1116a7f53e26SMarkus Armbruster }
1117a7f53e26SMarkus Armbruster }
1118a7f53e26SMarkus Armbruster }
1119a7f53e26SMarkus Armbruster
blk_root_change_media(BdrvChild * child,bool load)11205c8cab48SKevin Wolf static void blk_root_change_media(BdrvChild *child, bool load)
11215c8cab48SKevin Wolf {
112239829a01SKevin Wolf blk_dev_change_media_cb(child->opaque, load, NULL);
11235c8cab48SKevin Wolf }
11245c8cab48SKevin Wolf
1125a7f53e26SMarkus Armbruster /*
1126a7f53e26SMarkus Armbruster * Does @blk's attached device model have removable media?
1127a7f53e26SMarkus Armbruster * %true if no device model is attached.
1128a7f53e26SMarkus Armbruster */
blk_dev_has_removable_media(BlockBackend * blk)1129a7f53e26SMarkus Armbruster bool blk_dev_has_removable_media(BlockBackend *blk)
1130a7f53e26SMarkus Armbruster {
1131b4ad82aaSEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
1132a7f53e26SMarkus Armbruster return !blk->dev || (blk->dev_ops && blk->dev_ops->change_media_cb);
1133a7f53e26SMarkus Armbruster }
1134a7f53e26SMarkus Armbruster
1135a7f53e26SMarkus Armbruster /*
11368f3a73bcSMax Reitz * Does @blk's attached device model have a tray?
11378f3a73bcSMax Reitz */
blk_dev_has_tray(BlockBackend * blk)11388f3a73bcSMax Reitz bool blk_dev_has_tray(BlockBackend *blk)
11398f3a73bcSMax Reitz {
1140967d7905SEmanuele Giuseppe Esposito IO_CODE();
11418f3a73bcSMax Reitz return blk->dev_ops && blk->dev_ops->is_tray_open;
11428f3a73bcSMax Reitz }
11438f3a73bcSMax Reitz
11448f3a73bcSMax Reitz /*
1145a7f53e26SMarkus Armbruster * Notify @blk's attached device model of a media eject request.
1146a7f53e26SMarkus Armbruster * If @force is true, the medium is about to be yanked out forcefully.
1147a7f53e26SMarkus Armbruster */
blk_dev_eject_request(BlockBackend * blk,bool force)1148a7f53e26SMarkus Armbruster void blk_dev_eject_request(BlockBackend *blk, bool force)
1149a7f53e26SMarkus Armbruster {
1150b4ad82aaSEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
1151a7f53e26SMarkus Armbruster if (blk->dev_ops && blk->dev_ops->eject_request_cb) {
1152a7f53e26SMarkus Armbruster blk->dev_ops->eject_request_cb(blk->dev_opaque, force);
1153a7f53e26SMarkus Armbruster }
1154a7f53e26SMarkus Armbruster }
1155a7f53e26SMarkus Armbruster
1156a7f53e26SMarkus Armbruster /*
1157a7f53e26SMarkus Armbruster * Does @blk's attached device model have a tray, and is it open?
1158a7f53e26SMarkus Armbruster */
blk_dev_is_tray_open(BlockBackend * blk)1159a7f53e26SMarkus Armbruster bool blk_dev_is_tray_open(BlockBackend *blk)
1160a7f53e26SMarkus Armbruster {
1161967d7905SEmanuele Giuseppe Esposito IO_CODE();
11628f3a73bcSMax Reitz if (blk_dev_has_tray(blk)) {
1163a7f53e26SMarkus Armbruster return blk->dev_ops->is_tray_open(blk->dev_opaque);
1164a7f53e26SMarkus Armbruster }
1165a7f53e26SMarkus Armbruster return false;
1166a7f53e26SMarkus Armbruster }
1167a7f53e26SMarkus Armbruster
1168a7f53e26SMarkus Armbruster /*
1169a7f53e26SMarkus Armbruster * Does @blk's attached device model have the medium locked?
1170a7f53e26SMarkus Armbruster * %false if the device model has no such lock.
1171a7f53e26SMarkus Armbruster */
blk_dev_is_medium_locked(BlockBackend * blk)1172a7f53e26SMarkus Armbruster bool blk_dev_is_medium_locked(BlockBackend *blk)
1173a7f53e26SMarkus Armbruster {
1174b4ad82aaSEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
1175a7f53e26SMarkus Armbruster if (blk->dev_ops && blk->dev_ops->is_medium_locked) {
1176a7f53e26SMarkus Armbruster return blk->dev_ops->is_medium_locked(blk->dev_opaque);
1177a7f53e26SMarkus Armbruster }
1178a7f53e26SMarkus Armbruster return false;
1179a7f53e26SMarkus Armbruster }
1180a7f53e26SMarkus Armbruster
1181a7f53e26SMarkus Armbruster /*
1182a7f53e26SMarkus Armbruster * Notify @blk's attached device model of a backend size change.
1183a7f53e26SMarkus Armbruster */
blk_root_resize(BdrvChild * child)11845c8cab48SKevin Wolf static void blk_root_resize(BdrvChild *child)
1185a7f53e26SMarkus Armbruster {
11865c8cab48SKevin Wolf BlockBackend *blk = child->opaque;
11875c8cab48SKevin Wolf
1188a7f53e26SMarkus Armbruster if (blk->dev_ops && blk->dev_ops->resize_cb) {
1189a7f53e26SMarkus Armbruster blk->dev_ops->resize_cb(blk->dev_opaque);
1190a7f53e26SMarkus Armbruster }
1191a7f53e26SMarkus Armbruster }
1192a7f53e26SMarkus Armbruster
blk_iostatus_enable(BlockBackend * blk)11934be74634SMarkus Armbruster void blk_iostatus_enable(BlockBackend *blk)
11944be74634SMarkus Armbruster {
11950439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
1196373340b2SMax Reitz blk->iostatus_enabled = true;
1197373340b2SMax Reitz blk->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
1198373340b2SMax Reitz }
1199373340b2SMax Reitz
1200373340b2SMax Reitz /* The I/O status is only enabled if the drive explicitly
1201373340b2SMax Reitz * enables it _and_ the VM is configured to stop on errors */
blk_iostatus_is_enabled(const BlockBackend * blk)1202373340b2SMax Reitz bool blk_iostatus_is_enabled(const BlockBackend *blk)
1203373340b2SMax Reitz {
120437868b2aSEmanuele Giuseppe Esposito IO_CODE();
1205373340b2SMax Reitz return (blk->iostatus_enabled &&
1206373340b2SMax Reitz (blk->on_write_error == BLOCKDEV_ON_ERROR_ENOSPC ||
1207373340b2SMax Reitz blk->on_write_error == BLOCKDEV_ON_ERROR_STOP ||
1208373340b2SMax Reitz blk->on_read_error == BLOCKDEV_ON_ERROR_STOP));
1209373340b2SMax Reitz }
1210373340b2SMax Reitz
blk_iostatus(const BlockBackend * blk)1211373340b2SMax Reitz BlockDeviceIoStatus blk_iostatus(const BlockBackend *blk)
1212373340b2SMax Reitz {
12130439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
1214373340b2SMax Reitz return blk->iostatus;
1215373340b2SMax Reitz }
1216373340b2SMax Reitz
blk_iostatus_disable(BlockBackend * blk)1217373340b2SMax Reitz void blk_iostatus_disable(BlockBackend *blk)
1218373340b2SMax Reitz {
12190439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
1220373340b2SMax Reitz blk->iostatus_enabled = false;
1221373340b2SMax Reitz }
1222373340b2SMax Reitz
blk_iostatus_reset(BlockBackend * blk)1223373340b2SMax Reitz void blk_iostatus_reset(BlockBackend *blk)
1224373340b2SMax Reitz {
12250439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
1226373340b2SMax Reitz if (blk_iostatus_is_enabled(blk)) {
1227373340b2SMax Reitz blk->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
1228373340b2SMax Reitz }
1229373340b2SMax Reitz }
1230373340b2SMax Reitz
blk_iostatus_set_err(BlockBackend * blk,int error)1231373340b2SMax Reitz void blk_iostatus_set_err(BlockBackend *blk, int error)
1232373340b2SMax Reitz {
123337868b2aSEmanuele Giuseppe Esposito IO_CODE();
1234373340b2SMax Reitz assert(blk_iostatus_is_enabled(blk));
1235373340b2SMax Reitz if (blk->iostatus == BLOCK_DEVICE_IO_STATUS_OK) {
1236373340b2SMax Reitz blk->iostatus = error == ENOSPC ? BLOCK_DEVICE_IO_STATUS_NOSPACE :
1237373340b2SMax Reitz BLOCK_DEVICE_IO_STATUS_FAILED;
1238373340b2SMax Reitz }
12394be74634SMarkus Armbruster }
12404be74634SMarkus Armbruster
blk_set_allow_write_beyond_eof(BlockBackend * blk,bool allow)1241c10c9d96SKevin Wolf void blk_set_allow_write_beyond_eof(BlockBackend *blk, bool allow)
1242c10c9d96SKevin Wolf {
124337868b2aSEmanuele Giuseppe Esposito IO_CODE();
1244c10c9d96SKevin Wolf blk->allow_write_beyond_eof = allow;
1245c10c9d96SKevin Wolf }
1246c10c9d96SKevin Wolf
blk_set_allow_aio_context_change(BlockBackend * blk,bool allow)1247980b0f94SKevin Wolf void blk_set_allow_aio_context_change(BlockBackend *blk, bool allow)
1248980b0f94SKevin Wolf {
124937868b2aSEmanuele Giuseppe Esposito IO_CODE();
1250980b0f94SKevin Wolf blk->allow_aio_context_change = allow;
1251980b0f94SKevin Wolf }
1252980b0f94SKevin Wolf
blk_set_disable_request_queuing(BlockBackend * blk,bool disable)1253cf312932SKevin Wolf void blk_set_disable_request_queuing(BlockBackend *blk, bool disable)
1254cf312932SKevin Wolf {
125537868b2aSEmanuele Giuseppe Esposito IO_CODE();
1256ef80ec50SStefan Hajnoczi qatomic_set(&blk->disable_request_queuing, disable);
1257cf312932SKevin Wolf }
1258cf312932SKevin Wolf
1259c73ff92cSEmanuele Giuseppe Esposito static int coroutine_fn GRAPH_RDLOCK
blk_check_byte_request(BlockBackend * blk,int64_t offset,int64_t bytes)1260c73ff92cSEmanuele Giuseppe Esposito blk_check_byte_request(BlockBackend *blk, int64_t offset, int64_t bytes)
1261e7f7d676SMax Reitz {
1262e7f7d676SMax Reitz int64_t len;
1263e7f7d676SMax Reitz
1264aa78b825SVladimir Sementsov-Ogievskiy if (bytes < 0) {
1265e7f7d676SMax Reitz return -EIO;
1266e7f7d676SMax Reitz }
1267e7f7d676SMax Reitz
1268c73ff92cSEmanuele Giuseppe Esposito if (!blk_co_is_available(blk)) {
1269e7f7d676SMax Reitz return -ENOMEDIUM;
1270e7f7d676SMax Reitz }
1271e7f7d676SMax Reitz
1272c10c9d96SKevin Wolf if (offset < 0) {
1273c10c9d96SKevin Wolf return -EIO;
1274c10c9d96SKevin Wolf }
1275c10c9d96SKevin Wolf
1276c10c9d96SKevin Wolf if (!blk->allow_write_beyond_eof) {
1277bd53086eSEmanuele Giuseppe Esposito len = bdrv_co_getlength(blk_bs(blk));
1278e7f7d676SMax Reitz if (len < 0) {
1279e7f7d676SMax Reitz return len;
1280e7f7d676SMax Reitz }
1281e7f7d676SMax Reitz
12827242db63SVladimir Sementsov-Ogievskiy if (offset > len || len - offset < bytes) {
1283e7f7d676SMax Reitz return -EIO;
1284e7f7d676SMax Reitz }
1285c10c9d96SKevin Wolf }
1286e7f7d676SMax Reitz
1287e7f7d676SMax Reitz return 0;
1288e7f7d676SMax Reitz }
1289e7f7d676SMax Reitz
1290ff82b783SStefan Hajnoczi /* Are we currently in a drained section? */
blk_in_drain(BlockBackend * blk)1291ff82b783SStefan Hajnoczi bool blk_in_drain(BlockBackend *blk)
1292ff82b783SStefan Hajnoczi {
1293ff82b783SStefan Hajnoczi GLOBAL_STATE_CODE(); /* change to IO_OR_GS_CODE(), if necessary */
1294ff82b783SStefan Hajnoczi return qatomic_read(&blk->quiesce_counter);
1295ff82b783SStefan Hajnoczi }
1296ff82b783SStefan Hajnoczi
12977f16476fSKevin Wolf /* To be called between exactly one pair of blk_inc/dec_in_flight() */
blk_wait_while_drained(BlockBackend * blk)1298cf312932SKevin Wolf static void coroutine_fn blk_wait_while_drained(BlockBackend *blk)
1299cf312932SKevin Wolf {
13007f16476fSKevin Wolf assert(blk->in_flight > 0);
13017f16476fSKevin Wolf
1302ef80ec50SStefan Hajnoczi if (qatomic_read(&blk->quiesce_counter) &&
1303ef80ec50SStefan Hajnoczi !qatomic_read(&blk->disable_request_queuing)) {
1304407ae2aeSStefan Hajnoczi /*
1305407ae2aeSStefan Hajnoczi * Take lock before decrementing in flight counter so main loop thread
1306407ae2aeSStefan Hajnoczi * waits for us to enqueue ourselves before it can leave the drained
1307407ae2aeSStefan Hajnoczi * section.
1308407ae2aeSStefan Hajnoczi */
1309407ae2aeSStefan Hajnoczi qemu_mutex_lock(&blk->queued_requests_lock);
13107f16476fSKevin Wolf blk_dec_in_flight(blk);
1311407ae2aeSStefan Hajnoczi qemu_co_queue_wait(&blk->queued_requests, &blk->queued_requests_lock);
13127f16476fSKevin Wolf blk_inc_in_flight(blk);
1313407ae2aeSStefan Hajnoczi qemu_mutex_unlock(&blk->queued_requests_lock);
1314cf312932SKevin Wolf }
1315cf312932SKevin Wolf }
1316cf312932SKevin Wolf
1317fbb92b67SKevin Wolf /* To be called between exactly one pair of blk_inc/dec_in_flight() */
1318d1d3fc3dSAlberto Faria static int coroutine_fn
blk_co_do_preadv_part(BlockBackend * blk,int64_t offset,int64_t bytes,QEMUIOVector * qiov,size_t qiov_offset,BdrvRequestFlags flags)1319d1d3fc3dSAlberto Faria blk_co_do_preadv_part(BlockBackend *blk, int64_t offset, int64_t bytes,
1320d1d3fc3dSAlberto Faria QEMUIOVector *qiov, size_t qiov_offset,
1321d1d3fc3dSAlberto Faria BdrvRequestFlags flags)
13224be74634SMarkus Armbruster {
13231e98fefdSKevin Wolf int ret;
1324cf312932SKevin Wolf BlockDriverState *bs;
13251581a70dSEmanuele Giuseppe Esposito IO_CODE();
13261e98fefdSKevin Wolf
1327cf312932SKevin Wolf blk_wait_while_drained(blk);
1328b9b10c35SKevin Wolf GRAPH_RDLOCK_GUARD();
1329cf312932SKevin Wolf
1330cf312932SKevin Wolf /* Call blk_bs() only after waiting, the graph may have changed */
1331cf312932SKevin Wolf bs = blk_bs(blk);
133299723548SPaolo Bonzini trace_blk_co_preadv(blk, bs, offset, bytes, flags);
13331e98fefdSKevin Wolf
13341e98fefdSKevin Wolf ret = blk_check_byte_request(blk, offset, bytes);
1335e7f7d676SMax Reitz if (ret < 0) {
1336e7f7d676SMax Reitz return ret;
1337e7f7d676SMax Reitz }
1338e7f7d676SMax Reitz
133999723548SPaolo Bonzini bdrv_inc_in_flight(bs);
134099723548SPaolo Bonzini
1341441565b2SKevin Wolf /* throttling disk I/O */
1342022cdc9fSManos Pitsidianakis if (blk->public.throttle_group_member.throttle_state) {
1343022cdc9fSManos Pitsidianakis throttle_group_co_io_limits_intercept(&blk->public.throttle_group_member,
13443b2337efSzhenwei pi bytes, THROTTLE_READ);
1345441565b2SKevin Wolf }
1346441565b2SKevin Wolf
1347d1d3fc3dSAlberto Faria ret = bdrv_co_preadv_part(blk->root, offset, bytes, qiov, qiov_offset,
1348d1d3fc3dSAlberto Faria flags);
134999723548SPaolo Bonzini bdrv_dec_in_flight(bs);
135099723548SPaolo Bonzini return ret;
13511bf1cbc9SKevin Wolf }
13521bf1cbc9SKevin Wolf
blk_co_pread(BlockBackend * blk,int64_t offset,int64_t bytes,void * buf,BdrvRequestFlags flags)13536f675c93SAlberto Faria int coroutine_fn blk_co_pread(BlockBackend *blk, int64_t offset, int64_t bytes,
13546f675c93SAlberto Faria void *buf, BdrvRequestFlags flags)
13556f675c93SAlberto Faria {
13566f675c93SAlberto Faria QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
13576f675c93SAlberto Faria IO_OR_GS_CODE();
13586f675c93SAlberto Faria
13596f675c93SAlberto Faria assert(bytes <= SIZE_MAX);
13606f675c93SAlberto Faria
13616f675c93SAlberto Faria return blk_co_preadv(blk, offset, bytes, &qiov, flags);
13626f675c93SAlberto Faria }
13636f675c93SAlberto Faria
blk_co_preadv(BlockBackend * blk,int64_t offset,int64_t bytes,QEMUIOVector * qiov,BdrvRequestFlags flags)1364fbb92b67SKevin Wolf int coroutine_fn blk_co_preadv(BlockBackend *blk, int64_t offset,
136595479077SVladimir Sementsov-Ogievskiy int64_t bytes, QEMUIOVector *qiov,
1366fbb92b67SKevin Wolf BdrvRequestFlags flags)
1367fbb92b67SKevin Wolf {
1368fbb92b67SKevin Wolf int ret;
136937868b2aSEmanuele Giuseppe Esposito IO_OR_GS_CODE();
1370fbb92b67SKevin Wolf
1371fbb92b67SKevin Wolf blk_inc_in_flight(blk);
1372d1d3fc3dSAlberto Faria ret = blk_co_do_preadv_part(blk, offset, bytes, qiov, 0, flags);
1373d1d3fc3dSAlberto Faria blk_dec_in_flight(blk);
1374d1d3fc3dSAlberto Faria
1375d1d3fc3dSAlberto Faria return ret;
1376d1d3fc3dSAlberto Faria }
1377d1d3fc3dSAlberto Faria
blk_co_preadv_part(BlockBackend * blk,int64_t offset,int64_t bytes,QEMUIOVector * qiov,size_t qiov_offset,BdrvRequestFlags flags)1378d1d3fc3dSAlberto Faria int coroutine_fn blk_co_preadv_part(BlockBackend *blk, int64_t offset,
1379d1d3fc3dSAlberto Faria int64_t bytes, QEMUIOVector *qiov,
1380d1d3fc3dSAlberto Faria size_t qiov_offset, BdrvRequestFlags flags)
1381d1d3fc3dSAlberto Faria {
1382d1d3fc3dSAlberto Faria int ret;
1383d1d3fc3dSAlberto Faria IO_OR_GS_CODE();
1384d1d3fc3dSAlberto Faria
1385d1d3fc3dSAlberto Faria blk_inc_in_flight(blk);
1386d1d3fc3dSAlberto Faria ret = blk_co_do_preadv_part(blk, offset, bytes, qiov, qiov_offset, flags);
1387fbb92b67SKevin Wolf blk_dec_in_flight(blk);
1388fbb92b67SKevin Wolf
1389fbb92b67SKevin Wolf return ret;
1390fbb92b67SKevin Wolf }
1391fbb92b67SKevin Wolf
1392fbb92b67SKevin Wolf /* To be called between exactly one pair of blk_inc/dec_in_flight() */
139307a64aa4SAlberto Faria static int coroutine_fn
blk_co_do_pwritev_part(BlockBackend * blk,int64_t offset,int64_t bytes,QEMUIOVector * qiov,size_t qiov_offset,BdrvRequestFlags flags)139470e8775eSVladimir Sementsov-Ogievskiy blk_co_do_pwritev_part(BlockBackend *blk, int64_t offset, int64_t bytes,
1395b3016864SVladimir Sementsov-Ogievskiy QEMUIOVector *qiov, size_t qiov_offset,
1396a8823a3bSKevin Wolf BdrvRequestFlags flags)
1397a8823a3bSKevin Wolf {
1398bfd18d1eSKevin Wolf int ret;
1399cf312932SKevin Wolf BlockDriverState *bs;
14001581a70dSEmanuele Giuseppe Esposito IO_CODE();
1401bfd18d1eSKevin Wolf
1402cf312932SKevin Wolf blk_wait_while_drained(blk);
1403b9b10c35SKevin Wolf GRAPH_RDLOCK_GUARD();
1404cf312932SKevin Wolf
1405cf312932SKevin Wolf /* Call blk_bs() only after waiting, the graph may have changed */
1406cf312932SKevin Wolf bs = blk_bs(blk);
140799723548SPaolo Bonzini trace_blk_co_pwritev(blk, bs, offset, bytes, flags);
14081e98fefdSKevin Wolf
1409bfd18d1eSKevin Wolf ret = blk_check_byte_request(blk, offset, bytes);
1410a8823a3bSKevin Wolf if (ret < 0) {
1411a8823a3bSKevin Wolf return ret;
1412a8823a3bSKevin Wolf }
1413a8823a3bSKevin Wolf
141499723548SPaolo Bonzini bdrv_inc_in_flight(bs);
1415441565b2SKevin Wolf /* throttling disk I/O */
1416022cdc9fSManos Pitsidianakis if (blk->public.throttle_group_member.throttle_state) {
1417022cdc9fSManos Pitsidianakis throttle_group_co_io_limits_intercept(&blk->public.throttle_group_member,
14183b2337efSzhenwei pi bytes, THROTTLE_WRITE);
1419441565b2SKevin Wolf }
1420441565b2SKevin Wolf
1421bfd18d1eSKevin Wolf if (!blk->enable_write_cache) {
1422bfd18d1eSKevin Wolf flags |= BDRV_REQ_FUA;
1423bfd18d1eSKevin Wolf }
1424bfd18d1eSKevin Wolf
1425b3016864SVladimir Sementsov-Ogievskiy ret = bdrv_co_pwritev_part(blk->root, offset, bytes, qiov, qiov_offset,
1426b3016864SVladimir Sementsov-Ogievskiy flags);
142799723548SPaolo Bonzini bdrv_dec_in_flight(bs);
142899723548SPaolo Bonzini return ret;
1429a8823a3bSKevin Wolf }
1430a8823a3bSKevin Wolf
blk_co_pwritev_part(BlockBackend * blk,int64_t offset,int64_t bytes,QEMUIOVector * qiov,size_t qiov_offset,BdrvRequestFlags flags)1431fbb92b67SKevin Wolf int coroutine_fn blk_co_pwritev_part(BlockBackend *blk, int64_t offset,
143234460febSVladimir Sementsov-Ogievskiy int64_t bytes,
1433fbb92b67SKevin Wolf QEMUIOVector *qiov, size_t qiov_offset,
1434fbb92b67SKevin Wolf BdrvRequestFlags flags)
1435fbb92b67SKevin Wolf {
1436fbb92b67SKevin Wolf int ret;
143737868b2aSEmanuele Giuseppe Esposito IO_OR_GS_CODE();
1438fbb92b67SKevin Wolf
1439fbb92b67SKevin Wolf blk_inc_in_flight(blk);
144070e8775eSVladimir Sementsov-Ogievskiy ret = blk_co_do_pwritev_part(blk, offset, bytes, qiov, qiov_offset, flags);
1441fbb92b67SKevin Wolf blk_dec_in_flight(blk);
1442fbb92b67SKevin Wolf
1443fbb92b67SKevin Wolf return ret;
1444fbb92b67SKevin Wolf }
1445fbb92b67SKevin Wolf
blk_co_pwrite(BlockBackend * blk,int64_t offset,int64_t bytes,const void * buf,BdrvRequestFlags flags)14466f675c93SAlberto Faria int coroutine_fn blk_co_pwrite(BlockBackend *blk, int64_t offset, int64_t bytes,
14476f675c93SAlberto Faria const void *buf, BdrvRequestFlags flags)
14486f675c93SAlberto Faria {
14496f675c93SAlberto Faria QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
14506f675c93SAlberto Faria IO_OR_GS_CODE();
14516f675c93SAlberto Faria
14526f675c93SAlberto Faria assert(bytes <= SIZE_MAX);
14536f675c93SAlberto Faria
14546f675c93SAlberto Faria return blk_co_pwritev(blk, offset, bytes, &qiov, flags);
14556f675c93SAlberto Faria }
14566f675c93SAlberto Faria
blk_co_pwritev(BlockBackend * blk,int64_t offset,int64_t bytes,QEMUIOVector * qiov,BdrvRequestFlags flags)1457b3016864SVladimir Sementsov-Ogievskiy int coroutine_fn blk_co_pwritev(BlockBackend *blk, int64_t offset,
145834460febSVladimir Sementsov-Ogievskiy int64_t bytes, QEMUIOVector *qiov,
1459b3016864SVladimir Sementsov-Ogievskiy BdrvRequestFlags flags)
1460b3016864SVladimir Sementsov-Ogievskiy {
146137868b2aSEmanuele Giuseppe Esposito IO_OR_GS_CODE();
1462b3016864SVladimir Sementsov-Ogievskiy return blk_co_pwritev_part(blk, offset, bytes, qiov, 0, flags);
1463b3016864SVladimir Sementsov-Ogievskiy }
1464b3016864SVladimir Sementsov-Ogievskiy
blk_co_block_status_above(BlockBackend * blk,BlockDriverState * base,int64_t offset,int64_t bytes,int64_t * pnum,int64_t * map,BlockDriverState ** file)1465ff7e261bSEmanuele Giuseppe Esposito int coroutine_fn blk_co_block_status_above(BlockBackend *blk,
1466ff7e261bSEmanuele Giuseppe Esposito BlockDriverState *base,
1467ff7e261bSEmanuele Giuseppe Esposito int64_t offset, int64_t bytes,
1468ff7e261bSEmanuele Giuseppe Esposito int64_t *pnum, int64_t *map,
1469ff7e261bSEmanuele Giuseppe Esposito BlockDriverState **file)
1470ff7e261bSEmanuele Giuseppe Esposito {
1471ff7e261bSEmanuele Giuseppe Esposito IO_CODE();
14727ff9579eSKevin Wolf GRAPH_RDLOCK_GUARD();
1473ff7e261bSEmanuele Giuseppe Esposito return bdrv_co_block_status_above(blk_bs(blk), base, offset, bytes, pnum,
1474ff7e261bSEmanuele Giuseppe Esposito map, file);
1475ff7e261bSEmanuele Giuseppe Esposito }
1476ff7e261bSEmanuele Giuseppe Esposito
blk_co_is_allocated_above(BlockBackend * blk,BlockDriverState * base,bool include_base,int64_t offset,int64_t bytes,int64_t * pnum)1477ff7e261bSEmanuele Giuseppe Esposito int coroutine_fn blk_co_is_allocated_above(BlockBackend *blk,
1478ff7e261bSEmanuele Giuseppe Esposito BlockDriverState *base,
1479ff7e261bSEmanuele Giuseppe Esposito bool include_base, int64_t offset,
1480ff7e261bSEmanuele Giuseppe Esposito int64_t bytes, int64_t *pnum)
1481ff7e261bSEmanuele Giuseppe Esposito {
1482ff7e261bSEmanuele Giuseppe Esposito IO_CODE();
14837ff9579eSKevin Wolf GRAPH_RDLOCK_GUARD();
1484ff7e261bSEmanuele Giuseppe Esposito return bdrv_co_is_allocated_above(blk_bs(blk), base, include_base, offset,
1485ff7e261bSEmanuele Giuseppe Esposito bytes, pnum);
1486ff7e261bSEmanuele Giuseppe Esposito }
1487ff7e261bSEmanuele Giuseppe Esposito
14881bf1cbc9SKevin Wolf typedef struct BlkRwCo {
14891bf1cbc9SKevin Wolf BlockBackend *blk;
14901bf1cbc9SKevin Wolf int64_t offset;
1491c060332cSDeepa Srinivasan void *iobuf;
14921bf1cbc9SKevin Wolf int ret;
14931bf1cbc9SKevin Wolf BdrvRequestFlags flags;
14941bf1cbc9SKevin Wolf } BlkRwCo;
14951bf1cbc9SKevin Wolf
blk_make_zero(BlockBackend * blk,BdrvRequestFlags flags)1496720ff280SKevin Wolf int blk_make_zero(BlockBackend *blk, BdrvRequestFlags flags)
1497720ff280SKevin Wolf {
14980439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
1499720ff280SKevin Wolf return bdrv_make_zero(blk->root, flags);
1500720ff280SKevin Wolf }
1501720ff280SKevin Wolf
blk_inc_in_flight(BlockBackend * blk)1502c90e2a9cSKevin Wolf void blk_inc_in_flight(BlockBackend *blk)
150333f2a757SStefan Hajnoczi {
150437868b2aSEmanuele Giuseppe Esposito IO_CODE();
1505d73415a3SStefan Hajnoczi qatomic_inc(&blk->in_flight);
150633f2a757SStefan Hajnoczi }
150733f2a757SStefan Hajnoczi
blk_dec_in_flight(BlockBackend * blk)1508c90e2a9cSKevin Wolf void blk_dec_in_flight(BlockBackend *blk)
150933f2a757SStefan Hajnoczi {
151037868b2aSEmanuele Giuseppe Esposito IO_CODE();
1511d73415a3SStefan Hajnoczi qatomic_dec(&blk->in_flight);
1512cfe29d82SKevin Wolf aio_wait_kick();
151333f2a757SStefan Hajnoczi }
151433f2a757SStefan Hajnoczi
error_callback_bh(void * opaque)1515e7f7d676SMax Reitz static void error_callback_bh(void *opaque)
1516e7f7d676SMax Reitz {
1517e7f7d676SMax Reitz struct BlockBackendAIOCB *acb = opaque;
151899723548SPaolo Bonzini
151933f2a757SStefan Hajnoczi blk_dec_in_flight(acb->blk);
1520e7f7d676SMax Reitz acb->common.cb(acb->common.opaque, acb->ret);
1521e7f7d676SMax Reitz qemu_aio_unref(acb);
1522e7f7d676SMax Reitz }
1523e7f7d676SMax Reitz
blk_abort_aio_request(BlockBackend * blk,BlockCompletionFunc * cb,void * opaque,int ret)1524ca78ecfaSPeter Lieven BlockAIOCB *blk_abort_aio_request(BlockBackend *blk,
1525ca78ecfaSPeter Lieven BlockCompletionFunc *cb,
1526e7f7d676SMax Reitz void *opaque, int ret)
1527e7f7d676SMax Reitz {
1528e7f7d676SMax Reitz struct BlockBackendAIOCB *acb;
152937868b2aSEmanuele Giuseppe Esposito IO_CODE();
1530e7f7d676SMax Reitz
153133f2a757SStefan Hajnoczi blk_inc_in_flight(blk);
1532e7f7d676SMax Reitz acb = blk_aio_get(&block_backend_aiocb_info, blk, cb, opaque);
15334981bdecSMax Reitz acb->blk = blk;
1534e7f7d676SMax Reitz acb->ret = ret;
1535e7f7d676SMax Reitz
153646eb6e86SStefan Hajnoczi replay_bh_schedule_oneshot_event(qemu_get_current_aio_context(),
1537e4ec5ad4SPavel Dovgalyuk error_callback_bh, acb);
1538e7f7d676SMax Reitz return &acb->common;
1539e7f7d676SMax Reitz }
1540e7f7d676SMax Reitz
154157d6a428SKevin Wolf typedef struct BlkAioEmAIOCB {
154257d6a428SKevin Wolf BlockAIOCB common;
154357d6a428SKevin Wolf BlkRwCo rwco;
1544a93d81c8SVladimir Sementsov-Ogievskiy int64_t bytes;
154557d6a428SKevin Wolf bool has_returned;
154657d6a428SKevin Wolf } BlkAioEmAIOCB;
154757d6a428SKevin Wolf
154857d6a428SKevin Wolf static const AIOCBInfo blk_aio_em_aiocb_info = {
154957d6a428SKevin Wolf .aiocb_size = sizeof(BlkAioEmAIOCB),
155057d6a428SKevin Wolf };
155157d6a428SKevin Wolf
blk_aio_complete(BlkAioEmAIOCB * acb)155257d6a428SKevin Wolf static void blk_aio_complete(BlkAioEmAIOCB *acb)
155357d6a428SKevin Wolf {
155457d6a428SKevin Wolf if (acb->has_returned) {
155557d6a428SKevin Wolf acb->common.cb(acb->common.opaque, acb->rwco.ret);
155646aaf2a5SKevin Wolf blk_dec_in_flight(acb->rwco.blk);
155757d6a428SKevin Wolf qemu_aio_unref(acb);
155857d6a428SKevin Wolf }
155957d6a428SKevin Wolf }
156057d6a428SKevin Wolf
blk_aio_complete_bh(void * opaque)156157d6a428SKevin Wolf static void blk_aio_complete_bh(void *opaque)
156257d6a428SKevin Wolf {
1563fffb6e12SPaolo Bonzini BlkAioEmAIOCB *acb = opaque;
1564fffb6e12SPaolo Bonzini assert(acb->has_returned);
1565fffb6e12SPaolo Bonzini blk_aio_complete(acb);
156657d6a428SKevin Wolf }
156757d6a428SKevin Wolf
blk_aio_prwv(BlockBackend * blk,int64_t offset,int64_t bytes,void * iobuf,CoroutineEntry co_entry,BdrvRequestFlags flags,BlockCompletionFunc * cb,void * opaque)1568a93d81c8SVladimir Sementsov-Ogievskiy static BlockAIOCB *blk_aio_prwv(BlockBackend *blk, int64_t offset,
1569a93d81c8SVladimir Sementsov-Ogievskiy int64_t bytes,
1570c060332cSDeepa Srinivasan void *iobuf, CoroutineEntry co_entry,
157157d6a428SKevin Wolf BdrvRequestFlags flags,
157257d6a428SKevin Wolf BlockCompletionFunc *cb, void *opaque)
157357d6a428SKevin Wolf {
157457d6a428SKevin Wolf BlkAioEmAIOCB *acb;
157557d6a428SKevin Wolf Coroutine *co;
157657d6a428SKevin Wolf
157733f2a757SStefan Hajnoczi blk_inc_in_flight(blk);
157857d6a428SKevin Wolf acb = blk_aio_get(&blk_aio_em_aiocb_info, blk, cb, opaque);
157957d6a428SKevin Wolf acb->rwco = (BlkRwCo) {
158057d6a428SKevin Wolf .blk = blk,
158157d6a428SKevin Wolf .offset = offset,
1582c060332cSDeepa Srinivasan .iobuf = iobuf,
158357d6a428SKevin Wolf .flags = flags,
158457d6a428SKevin Wolf .ret = NOT_DONE,
158557d6a428SKevin Wolf };
15867fa84cd8SKevin Wolf acb->bytes = bytes;
158757d6a428SKevin Wolf acb->has_returned = false;
158857d6a428SKevin Wolf
15890b8b8753SPaolo Bonzini co = qemu_coroutine_create(co_entry, acb);
159046eb6e86SStefan Hajnoczi aio_co_enter(qemu_get_current_aio_context(), co);
159157d6a428SKevin Wolf
159257d6a428SKevin Wolf acb->has_returned = true;
159357d6a428SKevin Wolf if (acb->rwco.ret != NOT_DONE) {
159446eb6e86SStefan Hajnoczi replay_bh_schedule_oneshot_event(qemu_get_current_aio_context(),
1595fffb6e12SPaolo Bonzini blk_aio_complete_bh, acb);
159657d6a428SKevin Wolf }
159757d6a428SKevin Wolf
159857d6a428SKevin Wolf return &acb->common;
159957d6a428SKevin Wolf }
160057d6a428SKevin Wolf
blk_aio_read_entry(void * opaque)1601881a4c55SPaolo Bonzini static void coroutine_fn blk_aio_read_entry(void *opaque)
160257d6a428SKevin Wolf {
160357d6a428SKevin Wolf BlkAioEmAIOCB *acb = opaque;
160457d6a428SKevin Wolf BlkRwCo *rwco = &acb->rwco;
1605c060332cSDeepa Srinivasan QEMUIOVector *qiov = rwco->iobuf;
160657d6a428SKevin Wolf
1607c060332cSDeepa Srinivasan assert(qiov->size == acb->bytes);
1608d1d3fc3dSAlberto Faria rwco->ret = blk_co_do_preadv_part(rwco->blk, rwco->offset, acb->bytes, qiov,
1609d1d3fc3dSAlberto Faria 0, rwco->flags);
161057d6a428SKevin Wolf blk_aio_complete(acb);
161157d6a428SKevin Wolf }
161257d6a428SKevin Wolf
blk_aio_write_entry(void * opaque)1613881a4c55SPaolo Bonzini static void coroutine_fn blk_aio_write_entry(void *opaque)
161457d6a428SKevin Wolf {
161557d6a428SKevin Wolf BlkAioEmAIOCB *acb = opaque;
161657d6a428SKevin Wolf BlkRwCo *rwco = &acb->rwco;
1617c060332cSDeepa Srinivasan QEMUIOVector *qiov = rwco->iobuf;
161857d6a428SKevin Wolf
1619c060332cSDeepa Srinivasan assert(!qiov || qiov->size == acb->bytes);
162070e8775eSVladimir Sementsov-Ogievskiy rwco->ret = blk_co_do_pwritev_part(rwco->blk, rwco->offset, acb->bytes,
1621fbb92b67SKevin Wolf qiov, 0, rwco->flags);
162257d6a428SKevin Wolf blk_aio_complete(acb);
162357d6a428SKevin Wolf }
162457d6a428SKevin Wolf
blk_aio_pwrite_zeroes(BlockBackend * blk,int64_t offset,int64_t bytes,BdrvRequestFlags flags,BlockCompletionFunc * cb,void * opaque)1625d004bd52SEric Blake BlockAIOCB *blk_aio_pwrite_zeroes(BlockBackend *blk, int64_t offset,
1626a93d81c8SVladimir Sementsov-Ogievskiy int64_t bytes, BdrvRequestFlags flags,
16274be74634SMarkus Armbruster BlockCompletionFunc *cb, void *opaque)
16284be74634SMarkus Armbruster {
162937868b2aSEmanuele Giuseppe Esposito IO_CODE();
1630a93d81c8SVladimir Sementsov-Ogievskiy return blk_aio_prwv(blk, offset, bytes, NULL, blk_aio_write_entry,
1631983a1600SEric Blake flags | BDRV_REQ_ZERO_WRITE, cb, opaque);
16324be74634SMarkus Armbruster }
16334be74634SMarkus Armbruster
blk_co_getlength(BlockBackend * blk)1634c86422c5SEmanuele Giuseppe Esposito int64_t coroutine_fn blk_co_getlength(BlockBackend *blk)
16354be74634SMarkus Armbruster {
163637868b2aSEmanuele Giuseppe Esposito IO_CODE();
1637c73ff92cSEmanuele Giuseppe Esposito GRAPH_RDLOCK_GUARD();
1638c86422c5SEmanuele Giuseppe Esposito
1639c73ff92cSEmanuele Giuseppe Esposito if (!blk_co_is_available(blk)) {
1640c09ba36cSMax Reitz return -ENOMEDIUM;
1641c09ba36cSMax Reitz }
1642c09ba36cSMax Reitz
1643c86422c5SEmanuele Giuseppe Esposito return bdrv_co_getlength(blk_bs(blk));
16444be74634SMarkus Armbruster }
16454be74634SMarkus Armbruster
blk_co_nb_sectors(BlockBackend * blk)16469ed98caeSPaolo Bonzini int64_t coroutine_fn blk_co_nb_sectors(BlockBackend *blk)
16474be74634SMarkus Armbruster {
1648e5203a3bSPaolo Bonzini BlockDriverState *bs = blk_bs(blk);
1649e5203a3bSPaolo Bonzini
165037868b2aSEmanuele Giuseppe Esposito IO_CODE();
1651d8fbf9aaSKevin Wolf GRAPH_RDLOCK_GUARD();
1652d8fbf9aaSKevin Wolf
1653e5203a3bSPaolo Bonzini if (!bs) {
1654c09ba36cSMax Reitz return -ENOMEDIUM;
16559ed98caeSPaolo Bonzini } else {
16569ed98caeSPaolo Bonzini return bdrv_co_nb_sectors(bs);
16579ed98caeSPaolo Bonzini }
1658c09ba36cSMax Reitz }
1659c09ba36cSMax Reitz
166081f730d4SPaolo Bonzini /*
166181f730d4SPaolo Bonzini * This wrapper is written by hand because this function is in the hot I/O path,
166281f730d4SPaolo Bonzini * via blk_get_geometry.
166381f730d4SPaolo Bonzini */
blk_nb_sectors(BlockBackend * blk)166481f730d4SPaolo Bonzini int64_t coroutine_mixed_fn blk_nb_sectors(BlockBackend *blk)
166581f730d4SPaolo Bonzini {
166681f730d4SPaolo Bonzini BlockDriverState *bs = blk_bs(blk);
166781f730d4SPaolo Bonzini
166881f730d4SPaolo Bonzini IO_CODE();
166981f730d4SPaolo Bonzini
167081f730d4SPaolo Bonzini if (!bs) {
167181f730d4SPaolo Bonzini return -ENOMEDIUM;
167281f730d4SPaolo Bonzini } else {
167381f730d4SPaolo Bonzini return bdrv_nb_sectors(bs);
167481f730d4SPaolo Bonzini }
167581f730d4SPaolo Bonzini }
167681f730d4SPaolo Bonzini
16779ed98caeSPaolo Bonzini /* return 0 as number of sectors if no device present or error */
blk_co_get_geometry(BlockBackend * blk,uint64_t * nb_sectors_ptr)16789ed98caeSPaolo Bonzini void coroutine_fn blk_co_get_geometry(BlockBackend *blk,
16799ed98caeSPaolo Bonzini uint64_t *nb_sectors_ptr)
16809ed98caeSPaolo Bonzini {
16819ed98caeSPaolo Bonzini int64_t ret = blk_co_nb_sectors(blk);
16829ed98caeSPaolo Bonzini *nb_sectors_ptr = ret < 0 ? 0 : ret;
16831ef01253SMax Reitz }
16841ef01253SMax Reitz
168581f730d4SPaolo Bonzini /*
168681f730d4SPaolo Bonzini * This wrapper is written by hand because this function is in the hot I/O path.
168781f730d4SPaolo Bonzini */
blk_get_geometry(BlockBackend * blk,uint64_t * nb_sectors_ptr)168881f730d4SPaolo Bonzini void coroutine_mixed_fn blk_get_geometry(BlockBackend *blk,
168981f730d4SPaolo Bonzini uint64_t *nb_sectors_ptr)
169081f730d4SPaolo Bonzini {
169181f730d4SPaolo Bonzini int64_t ret = blk_nb_sectors(blk);
169281f730d4SPaolo Bonzini *nb_sectors_ptr = ret < 0 ? 0 : ret;
169381f730d4SPaolo Bonzini }
169481f730d4SPaolo Bonzini
blk_aio_preadv(BlockBackend * blk,int64_t offset,QEMUIOVector * qiov,BdrvRequestFlags flags,BlockCompletionFunc * cb,void * opaque)169560cb2fa7SEric Blake BlockAIOCB *blk_aio_preadv(BlockBackend *blk, int64_t offset,
169660cb2fa7SEric Blake QEMUIOVector *qiov, BdrvRequestFlags flags,
169760cb2fa7SEric Blake BlockCompletionFunc *cb, void *opaque)
169860cb2fa7SEric Blake {
169937868b2aSEmanuele Giuseppe Esposito IO_CODE();
1700a93d81c8SVladimir Sementsov-Ogievskiy assert((uint64_t)qiov->size <= INT64_MAX);
170160cb2fa7SEric Blake return blk_aio_prwv(blk, offset, qiov->size, qiov,
170260cb2fa7SEric Blake blk_aio_read_entry, flags, cb, opaque);
170360cb2fa7SEric Blake }
170460cb2fa7SEric Blake
blk_aio_pwritev(BlockBackend * blk,int64_t offset,QEMUIOVector * qiov,BdrvRequestFlags flags,BlockCompletionFunc * cb,void * opaque)170560cb2fa7SEric Blake BlockAIOCB *blk_aio_pwritev(BlockBackend *blk, int64_t offset,
170660cb2fa7SEric Blake QEMUIOVector *qiov, BdrvRequestFlags flags,
170760cb2fa7SEric Blake BlockCompletionFunc *cb, void *opaque)
170860cb2fa7SEric Blake {
170937868b2aSEmanuele Giuseppe Esposito IO_CODE();
171073d4a113SHanna Reitz assert((uint64_t)qiov->size <= INT64_MAX);
171160cb2fa7SEric Blake return blk_aio_prwv(blk, offset, qiov->size, qiov,
171260cb2fa7SEric Blake blk_aio_write_entry, flags, cb, opaque);
171360cb2fa7SEric Blake }
171460cb2fa7SEric Blake
blk_aio_cancel(BlockAIOCB * acb)17154be74634SMarkus Armbruster void blk_aio_cancel(BlockAIOCB *acb)
17164be74634SMarkus Armbruster {
17170439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
17184be74634SMarkus Armbruster bdrv_aio_cancel(acb);
17194be74634SMarkus Armbruster }
17204be74634SMarkus Armbruster
blk_aio_cancel_async(BlockAIOCB * acb)17214be74634SMarkus Armbruster void blk_aio_cancel_async(BlockAIOCB *acb)
17224be74634SMarkus Armbruster {
172337868b2aSEmanuele Giuseppe Esposito IO_CODE();
17244be74634SMarkus Armbruster bdrv_aio_cancel_async(acb);
17254be74634SMarkus Armbruster }
17264be74634SMarkus Armbruster
1727fbb92b67SKevin Wolf /* To be called between exactly one pair of blk_inc/dec_in_flight() */
1728df02da00SAlberto Faria static int coroutine_fn
blk_co_do_ioctl(BlockBackend * blk,unsigned long int req,void * buf)172970e8775eSVladimir Sementsov-Ogievskiy blk_co_do_ioctl(BlockBackend *blk, unsigned long int req, void *buf)
17304be74634SMarkus Armbruster {
17311581a70dSEmanuele Giuseppe Esposito IO_CODE();
17321581a70dSEmanuele Giuseppe Esposito
1733cf312932SKevin Wolf blk_wait_while_drained(blk);
173426c518abSKevin Wolf GRAPH_RDLOCK_GUARD();
1735cf312932SKevin Wolf
1736c73ff92cSEmanuele Giuseppe Esposito if (!blk_co_is_available(blk)) {
1737c09ba36cSMax Reitz return -ENOMEDIUM;
1738c09ba36cSMax Reitz }
1739c09ba36cSMax Reitz
174048af776aSKevin Wolf return bdrv_co_ioctl(blk_bs(blk), req, buf);
174148af776aSKevin Wolf }
174248af776aSKevin Wolf
blk_co_ioctl(BlockBackend * blk,unsigned long int req,void * buf)1743df02da00SAlberto Faria int coroutine_fn blk_co_ioctl(BlockBackend *blk, unsigned long int req,
1744df02da00SAlberto Faria void *buf)
174548af776aSKevin Wolf {
174616d36e29SVladimir Sementsov-Ogievskiy int ret;
174737868b2aSEmanuele Giuseppe Esposito IO_OR_GS_CODE();
174816d36e29SVladimir Sementsov-Ogievskiy
174916d36e29SVladimir Sementsov-Ogievskiy blk_inc_in_flight(blk);
1750df02da00SAlberto Faria ret = blk_co_do_ioctl(blk, req, buf);
175116d36e29SVladimir Sementsov-Ogievskiy blk_dec_in_flight(blk);
175216d36e29SVladimir Sementsov-Ogievskiy
175316d36e29SVladimir Sementsov-Ogievskiy return ret;
175448af776aSKevin Wolf }
175548af776aSKevin Wolf
blk_aio_ioctl_entry(void * opaque)1756881a4c55SPaolo Bonzini static void coroutine_fn blk_aio_ioctl_entry(void *opaque)
175748af776aSKevin Wolf {
175848af776aSKevin Wolf BlkAioEmAIOCB *acb = opaque;
175948af776aSKevin Wolf BlkRwCo *rwco = &acb->rwco;
176048af776aSKevin Wolf
176170e8775eSVladimir Sementsov-Ogievskiy rwco->ret = blk_co_do_ioctl(rwco->blk, rwco->offset, rwco->iobuf);
1762c060332cSDeepa Srinivasan
176348af776aSKevin Wolf blk_aio_complete(acb);
17644be74634SMarkus Armbruster }
17654be74634SMarkus Armbruster
blk_aio_ioctl(BlockBackend * blk,unsigned long int req,void * buf,BlockCompletionFunc * cb,void * opaque)17664be74634SMarkus Armbruster BlockAIOCB *blk_aio_ioctl(BlockBackend *blk, unsigned long int req, void *buf,
17674be74634SMarkus Armbruster BlockCompletionFunc *cb, void *opaque)
17684be74634SMarkus Armbruster {
176937868b2aSEmanuele Giuseppe Esposito IO_CODE();
1770c060332cSDeepa Srinivasan return blk_aio_prwv(blk, req, 0, buf, blk_aio_ioctl_entry, 0, cb, opaque);
17714be74634SMarkus Armbruster }
17724be74634SMarkus Armbruster
1773fbb92b67SKevin Wolf /* To be called between exactly one pair of blk_inc/dec_in_flight() */
177407a64aa4SAlberto Faria static int coroutine_fn
blk_co_do_pdiscard(BlockBackend * blk,int64_t offset,int64_t bytes)177570e8775eSVladimir Sementsov-Ogievskiy blk_co_do_pdiscard(BlockBackend *blk, int64_t offset, int64_t bytes)
17762bb0dce7SMax Reitz {
1777cf312932SKevin Wolf int ret;
17781581a70dSEmanuele Giuseppe Esposito IO_CODE();
1779cf312932SKevin Wolf
1780cf312932SKevin Wolf blk_wait_while_drained(blk);
17819a5a1c62SEmanuele Giuseppe Esposito GRAPH_RDLOCK_GUARD();
1782cf312932SKevin Wolf
1783cf312932SKevin Wolf ret = blk_check_byte_request(blk, offset, bytes);
1784e7f7d676SMax Reitz if (ret < 0) {
1785e7f7d676SMax Reitz return ret;
1786e7f7d676SMax Reitz }
1787e7f7d676SMax Reitz
17880b9fd3f4SFam Zheng return bdrv_co_pdiscard(blk->root, offset, bytes);
17892bb0dce7SMax Reitz }
17902bb0dce7SMax Reitz
blk_aio_pdiscard_entry(void * opaque)1791881a4c55SPaolo Bonzini static void coroutine_fn blk_aio_pdiscard_entry(void *opaque)
1792564806c5SKevin Wolf {
1793564806c5SKevin Wolf BlkAioEmAIOCB *acb = opaque;
1794564806c5SKevin Wolf BlkRwCo *rwco = &acb->rwco;
1795564806c5SKevin Wolf
179670e8775eSVladimir Sementsov-Ogievskiy rwco->ret = blk_co_do_pdiscard(rwco->blk, rwco->offset, acb->bytes);
1797564806c5SKevin Wolf blk_aio_complete(acb);
1798564806c5SKevin Wolf }
1799564806c5SKevin Wolf
blk_aio_pdiscard(BlockBackend * blk,int64_t offset,int64_t bytes,BlockCompletionFunc * cb,void * opaque)1800564806c5SKevin Wolf BlockAIOCB *blk_aio_pdiscard(BlockBackend *blk,
1801a93d81c8SVladimir Sementsov-Ogievskiy int64_t offset, int64_t bytes,
1802564806c5SKevin Wolf BlockCompletionFunc *cb, void *opaque)
1803564806c5SKevin Wolf {
180437868b2aSEmanuele Giuseppe Esposito IO_CODE();
1805564806c5SKevin Wolf return blk_aio_prwv(blk, offset, bytes, NULL, blk_aio_pdiscard_entry, 0,
1806564806c5SKevin Wolf cb, opaque);
1807564806c5SKevin Wolf }
1808564806c5SKevin Wolf
blk_co_pdiscard(BlockBackend * blk,int64_t offset,int64_t bytes)18092800637aSVladimir Sementsov-Ogievskiy int coroutine_fn blk_co_pdiscard(BlockBackend *blk, int64_t offset,
18102800637aSVladimir Sementsov-Ogievskiy int64_t bytes)
1811fbb92b67SKevin Wolf {
1812fbb92b67SKevin Wolf int ret;
181337868b2aSEmanuele Giuseppe Esposito IO_OR_GS_CODE();
1814fbb92b67SKevin Wolf
1815fbb92b67SKevin Wolf blk_inc_in_flight(blk);
181670e8775eSVladimir Sementsov-Ogievskiy ret = blk_co_do_pdiscard(blk, offset, bytes);
1817fbb92b67SKevin Wolf blk_dec_in_flight(blk);
1818fbb92b67SKevin Wolf
1819fbb92b67SKevin Wolf return ret;
1820fbb92b67SKevin Wolf }
1821fbb92b67SKevin Wolf
1822fbb92b67SKevin Wolf /* To be called between exactly one pair of blk_inc/dec_in_flight() */
blk_co_do_flush(BlockBackend * blk)182307a64aa4SAlberto Faria static int coroutine_fn blk_co_do_flush(BlockBackend *blk)
18242bb0dce7SMax Reitz {
18251581a70dSEmanuele Giuseppe Esposito IO_CODE();
182688095349SEmanuele Giuseppe Esposito blk_wait_while_drained(blk);
182788095349SEmanuele Giuseppe Esposito GRAPH_RDLOCK_GUARD();
1828cf312932SKevin Wolf
1829c73ff92cSEmanuele Giuseppe Esposito if (!blk_co_is_available(blk)) {
1830c09ba36cSMax Reitz return -ENOMEDIUM;
1831c09ba36cSMax Reitz }
1832c09ba36cSMax Reitz
1833f21d96d0SKevin Wolf return bdrv_co_flush(blk_bs(blk));
18342bb0dce7SMax Reitz }
18352bb0dce7SMax Reitz
blk_aio_flush_entry(void * opaque)1836881a4c55SPaolo Bonzini static void coroutine_fn blk_aio_flush_entry(void *opaque)
1837564806c5SKevin Wolf {
1838564806c5SKevin Wolf BlkAioEmAIOCB *acb = opaque;
1839564806c5SKevin Wolf BlkRwCo *rwco = &acb->rwco;
1840564806c5SKevin Wolf
184170e8775eSVladimir Sementsov-Ogievskiy rwco->ret = blk_co_do_flush(rwco->blk);
1842564806c5SKevin Wolf blk_aio_complete(acb);
1843564806c5SKevin Wolf }
1844564806c5SKevin Wolf
blk_aio_flush(BlockBackend * blk,BlockCompletionFunc * cb,void * opaque)1845564806c5SKevin Wolf BlockAIOCB *blk_aio_flush(BlockBackend *blk,
1846564806c5SKevin Wolf BlockCompletionFunc *cb, void *opaque)
1847564806c5SKevin Wolf {
184837868b2aSEmanuele Giuseppe Esposito IO_CODE();
1849564806c5SKevin Wolf return blk_aio_prwv(blk, 0, 0, NULL, blk_aio_flush_entry, 0, cb, opaque);
1850564806c5SKevin Wolf }
1851564806c5SKevin Wolf
blk_co_flush(BlockBackend * blk)1852fbb92b67SKevin Wolf int coroutine_fn blk_co_flush(BlockBackend *blk)
1853fbb92b67SKevin Wolf {
1854fbb92b67SKevin Wolf int ret;
185537868b2aSEmanuele Giuseppe Esposito IO_OR_GS_CODE();
1856fbb92b67SKevin Wolf
1857fbb92b67SKevin Wolf blk_inc_in_flight(blk);
185870e8775eSVladimir Sementsov-Ogievskiy ret = blk_co_do_flush(blk);
1859fbb92b67SKevin Wolf blk_dec_in_flight(blk);
1860fbb92b67SKevin Wolf
1861fbb92b67SKevin Wolf return ret;
1862fbb92b67SKevin Wolf }
1863fbb92b67SKevin Wolf
blk_aio_zone_report_entry(void * opaque)18646d43eaa3SSam Li static void coroutine_fn blk_aio_zone_report_entry(void *opaque)
18656d43eaa3SSam Li {
18666d43eaa3SSam Li BlkAioEmAIOCB *acb = opaque;
18676d43eaa3SSam Li BlkRwCo *rwco = &acb->rwco;
18686d43eaa3SSam Li
18696d43eaa3SSam Li rwco->ret = blk_co_zone_report(rwco->blk, rwco->offset,
18706d43eaa3SSam Li (unsigned int*)(uintptr_t)acb->bytes,
18716d43eaa3SSam Li rwco->iobuf);
18726d43eaa3SSam Li blk_aio_complete(acb);
18736d43eaa3SSam Li }
18746d43eaa3SSam Li
blk_aio_zone_report(BlockBackend * blk,int64_t offset,unsigned int * nr_zones,BlockZoneDescriptor * zones,BlockCompletionFunc * cb,void * opaque)18756d43eaa3SSam Li BlockAIOCB *blk_aio_zone_report(BlockBackend *blk, int64_t offset,
18766d43eaa3SSam Li unsigned int *nr_zones,
18776d43eaa3SSam Li BlockZoneDescriptor *zones,
18786d43eaa3SSam Li BlockCompletionFunc *cb, void *opaque)
18796d43eaa3SSam Li {
18806d43eaa3SSam Li BlkAioEmAIOCB *acb;
18816d43eaa3SSam Li Coroutine *co;
18826d43eaa3SSam Li IO_CODE();
18836d43eaa3SSam Li
18846d43eaa3SSam Li blk_inc_in_flight(blk);
18856d43eaa3SSam Li acb = blk_aio_get(&blk_aio_em_aiocb_info, blk, cb, opaque);
18866d43eaa3SSam Li acb->rwco = (BlkRwCo) {
18876d43eaa3SSam Li .blk = blk,
18886d43eaa3SSam Li .offset = offset,
18896d43eaa3SSam Li .iobuf = zones,
18906d43eaa3SSam Li .ret = NOT_DONE,
18916d43eaa3SSam Li };
18926d43eaa3SSam Li acb->bytes = (int64_t)(uintptr_t)nr_zones,
18936d43eaa3SSam Li acb->has_returned = false;
18946d43eaa3SSam Li
18956d43eaa3SSam Li co = qemu_coroutine_create(blk_aio_zone_report_entry, acb);
18960f86afdeSStefan Hajnoczi aio_co_enter(qemu_get_current_aio_context(), co);
18976d43eaa3SSam Li
18986d43eaa3SSam Li acb->has_returned = true;
18996d43eaa3SSam Li if (acb->rwco.ret != NOT_DONE) {
19000f86afdeSStefan Hajnoczi replay_bh_schedule_oneshot_event(qemu_get_current_aio_context(),
19016d43eaa3SSam Li blk_aio_complete_bh, acb);
19026d43eaa3SSam Li }
19036d43eaa3SSam Li
19046d43eaa3SSam Li return &acb->common;
19056d43eaa3SSam Li }
19066d43eaa3SSam Li
blk_aio_zone_mgmt_entry(void * opaque)19076d43eaa3SSam Li static void coroutine_fn blk_aio_zone_mgmt_entry(void *opaque)
19086d43eaa3SSam Li {
19096d43eaa3SSam Li BlkAioEmAIOCB *acb = opaque;
19106d43eaa3SSam Li BlkRwCo *rwco = &acb->rwco;
19116d43eaa3SSam Li
19126d43eaa3SSam Li rwco->ret = blk_co_zone_mgmt(rwco->blk,
19136d43eaa3SSam Li (BlockZoneOp)(uintptr_t)rwco->iobuf,
19146d43eaa3SSam Li rwco->offset, acb->bytes);
19156d43eaa3SSam Li blk_aio_complete(acb);
19166d43eaa3SSam Li }
19176d43eaa3SSam Li
blk_aio_zone_mgmt(BlockBackend * blk,BlockZoneOp op,int64_t offset,int64_t len,BlockCompletionFunc * cb,void * opaque)19186d43eaa3SSam Li BlockAIOCB *blk_aio_zone_mgmt(BlockBackend *blk, BlockZoneOp op,
19196d43eaa3SSam Li int64_t offset, int64_t len,
19206d43eaa3SSam Li BlockCompletionFunc *cb, void *opaque) {
19216d43eaa3SSam Li BlkAioEmAIOCB *acb;
19226d43eaa3SSam Li Coroutine *co;
19236d43eaa3SSam Li IO_CODE();
19246d43eaa3SSam Li
19256d43eaa3SSam Li blk_inc_in_flight(blk);
19266d43eaa3SSam Li acb = blk_aio_get(&blk_aio_em_aiocb_info, blk, cb, opaque);
19276d43eaa3SSam Li acb->rwco = (BlkRwCo) {
19286d43eaa3SSam Li .blk = blk,
19296d43eaa3SSam Li .offset = offset,
19306d43eaa3SSam Li .iobuf = (void *)(uintptr_t)op,
19316d43eaa3SSam Li .ret = NOT_DONE,
19326d43eaa3SSam Li };
19336d43eaa3SSam Li acb->bytes = len;
19346d43eaa3SSam Li acb->has_returned = false;
19356d43eaa3SSam Li
19366d43eaa3SSam Li co = qemu_coroutine_create(blk_aio_zone_mgmt_entry, acb);
19370f86afdeSStefan Hajnoczi aio_co_enter(qemu_get_current_aio_context(), co);
19386d43eaa3SSam Li
19396d43eaa3SSam Li acb->has_returned = true;
19406d43eaa3SSam Li if (acb->rwco.ret != NOT_DONE) {
19410f86afdeSStefan Hajnoczi replay_bh_schedule_oneshot_event(qemu_get_current_aio_context(),
19426d43eaa3SSam Li blk_aio_complete_bh, acb);
19436d43eaa3SSam Li }
19446d43eaa3SSam Li
19456d43eaa3SSam Li return &acb->common;
19466d43eaa3SSam Li }
19476d43eaa3SSam Li
blk_aio_zone_append_entry(void * opaque)19484751d09aSSam Li static void coroutine_fn blk_aio_zone_append_entry(void *opaque)
19494751d09aSSam Li {
19504751d09aSSam Li BlkAioEmAIOCB *acb = opaque;
19514751d09aSSam Li BlkRwCo *rwco = &acb->rwco;
19524751d09aSSam Li
19534751d09aSSam Li rwco->ret = blk_co_zone_append(rwco->blk, (int64_t *)(uintptr_t)acb->bytes,
19544751d09aSSam Li rwco->iobuf, rwco->flags);
19554751d09aSSam Li blk_aio_complete(acb);
19564751d09aSSam Li }
19574751d09aSSam Li
blk_aio_zone_append(BlockBackend * blk,int64_t * offset,QEMUIOVector * qiov,BdrvRequestFlags flags,BlockCompletionFunc * cb,void * opaque)19584751d09aSSam Li BlockAIOCB *blk_aio_zone_append(BlockBackend *blk, int64_t *offset,
19594751d09aSSam Li QEMUIOVector *qiov, BdrvRequestFlags flags,
19604751d09aSSam Li BlockCompletionFunc *cb, void *opaque) {
19614751d09aSSam Li BlkAioEmAIOCB *acb;
19624751d09aSSam Li Coroutine *co;
19634751d09aSSam Li IO_CODE();
19644751d09aSSam Li
19654751d09aSSam Li blk_inc_in_flight(blk);
19664751d09aSSam Li acb = blk_aio_get(&blk_aio_em_aiocb_info, blk, cb, opaque);
19674751d09aSSam Li acb->rwco = (BlkRwCo) {
19684751d09aSSam Li .blk = blk,
19694751d09aSSam Li .ret = NOT_DONE,
19704751d09aSSam Li .flags = flags,
19714751d09aSSam Li .iobuf = qiov,
19724751d09aSSam Li };
19734751d09aSSam Li acb->bytes = (int64_t)(uintptr_t)offset;
19744751d09aSSam Li acb->has_returned = false;
19754751d09aSSam Li
19764751d09aSSam Li co = qemu_coroutine_create(blk_aio_zone_append_entry, acb);
19770f86afdeSStefan Hajnoczi aio_co_enter(qemu_get_current_aio_context(), co);
19784751d09aSSam Li acb->has_returned = true;
19794751d09aSSam Li if (acb->rwco.ret != NOT_DONE) {
19800f86afdeSStefan Hajnoczi replay_bh_schedule_oneshot_event(qemu_get_current_aio_context(),
19814751d09aSSam Li blk_aio_complete_bh, acb);
19824751d09aSSam Li }
19834751d09aSSam Li
19844751d09aSSam Li return &acb->common;
19854751d09aSSam Li }
19864751d09aSSam Li
19876d43eaa3SSam Li /*
19886d43eaa3SSam Li * Send a zone_report command.
19896d43eaa3SSam Li * offset is a byte offset from the start of the device. No alignment
19906d43eaa3SSam Li * required for offset.
19916d43eaa3SSam Li * nr_zones represents IN maximum and OUT actual.
19926d43eaa3SSam Li */
blk_co_zone_report(BlockBackend * blk,int64_t offset,unsigned int * nr_zones,BlockZoneDescriptor * zones)19936d43eaa3SSam Li int coroutine_fn blk_co_zone_report(BlockBackend *blk, int64_t offset,
19946d43eaa3SSam Li unsigned int *nr_zones,
19956d43eaa3SSam Li BlockZoneDescriptor *zones)
19966d43eaa3SSam Li {
19976d43eaa3SSam Li int ret;
19986d43eaa3SSam Li IO_CODE();
19996d43eaa3SSam Li
20006d43eaa3SSam Li blk_inc_in_flight(blk); /* increase before waiting */
20016d43eaa3SSam Li blk_wait_while_drained(blk);
20026d43eaa3SSam Li GRAPH_RDLOCK_GUARD();
20036d43eaa3SSam Li if (!blk_is_available(blk)) {
20046d43eaa3SSam Li blk_dec_in_flight(blk);
20056d43eaa3SSam Li return -ENOMEDIUM;
20066d43eaa3SSam Li }
20076d43eaa3SSam Li ret = bdrv_co_zone_report(blk_bs(blk), offset, nr_zones, zones);
20086d43eaa3SSam Li blk_dec_in_flight(blk);
20096d43eaa3SSam Li return ret;
20106d43eaa3SSam Li }
20116d43eaa3SSam Li
20126d43eaa3SSam Li /*
20136d43eaa3SSam Li * Send a zone_management command.
20146d43eaa3SSam Li * op is the zone operation;
20156d43eaa3SSam Li * offset is the byte offset from the start of the zoned device;
20166d43eaa3SSam Li * len is the maximum number of bytes the command should operate on. It
20176d43eaa3SSam Li * should be aligned with the device zone size.
20186d43eaa3SSam Li */
blk_co_zone_mgmt(BlockBackend * blk,BlockZoneOp op,int64_t offset,int64_t len)20196d43eaa3SSam Li int coroutine_fn blk_co_zone_mgmt(BlockBackend *blk, BlockZoneOp op,
20206d43eaa3SSam Li int64_t offset, int64_t len)
20216d43eaa3SSam Li {
20226d43eaa3SSam Li int ret;
20236d43eaa3SSam Li IO_CODE();
20246d43eaa3SSam Li
20256d43eaa3SSam Li blk_inc_in_flight(blk);
20266d43eaa3SSam Li blk_wait_while_drained(blk);
20276d43eaa3SSam Li GRAPH_RDLOCK_GUARD();
20286d43eaa3SSam Li
20296d43eaa3SSam Li ret = blk_check_byte_request(blk, offset, len);
20306d43eaa3SSam Li if (ret < 0) {
20316d43eaa3SSam Li blk_dec_in_flight(blk);
20326d43eaa3SSam Li return ret;
20336d43eaa3SSam Li }
20346d43eaa3SSam Li
20356d43eaa3SSam Li ret = bdrv_co_zone_mgmt(blk_bs(blk), op, offset, len);
20366d43eaa3SSam Li blk_dec_in_flight(blk);
20376d43eaa3SSam Li return ret;
20386d43eaa3SSam Li }
20396d43eaa3SSam Li
20404751d09aSSam Li /*
20414751d09aSSam Li * Send a zone_append command.
20424751d09aSSam Li */
blk_co_zone_append(BlockBackend * blk,int64_t * offset,QEMUIOVector * qiov,BdrvRequestFlags flags)20434751d09aSSam Li int coroutine_fn blk_co_zone_append(BlockBackend *blk, int64_t *offset,
20444751d09aSSam Li QEMUIOVector *qiov, BdrvRequestFlags flags)
20454751d09aSSam Li {
20464751d09aSSam Li int ret;
20474751d09aSSam Li IO_CODE();
20484751d09aSSam Li
20494751d09aSSam Li blk_inc_in_flight(blk);
20504751d09aSSam Li blk_wait_while_drained(blk);
20514751d09aSSam Li GRAPH_RDLOCK_GUARD();
20524751d09aSSam Li if (!blk_is_available(blk)) {
20534751d09aSSam Li blk_dec_in_flight(blk);
20544751d09aSSam Li return -ENOMEDIUM;
20554751d09aSSam Li }
20564751d09aSSam Li
20574751d09aSSam Li ret = bdrv_co_zone_append(blk_bs(blk), offset, qiov, flags);
20584751d09aSSam Li blk_dec_in_flight(blk);
20594751d09aSSam Li return ret;
20604751d09aSSam Li }
20614751d09aSSam Li
blk_drain(BlockBackend * blk)206297b0385aSAlexander Yarygin void blk_drain(BlockBackend *blk)
206397b0385aSAlexander Yarygin {
206433f2a757SStefan Hajnoczi BlockDriverState *bs = blk_bs(blk);
20650439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
206633f2a757SStefan Hajnoczi
206733f2a757SStefan Hajnoczi if (bs) {
20681e3552dbSStefan Hajnoczi bdrv_ref(bs);
206933f2a757SStefan Hajnoczi bdrv_drained_begin(bs);
207033f2a757SStefan Hajnoczi }
207133f2a757SStefan Hajnoczi
207233f2a757SStefan Hajnoczi /* We may have -ENOMEDIUM completions in flight */
2073cfe29d82SKevin Wolf AIO_WAIT_WHILE(blk_get_aio_context(blk),
20746a8a98a0SPaolo Bonzini qatomic_read(&blk->in_flight) > 0);
207533f2a757SStefan Hajnoczi
207633f2a757SStefan Hajnoczi if (bs) {
207733f2a757SStefan Hajnoczi bdrv_drained_end(bs);
20781e3552dbSStefan Hajnoczi bdrv_unref(bs);
207997b0385aSAlexander Yarygin }
2080a46fc9c9SMax Reitz }
208197b0385aSAlexander Yarygin
blk_drain_all(void)20824be74634SMarkus Armbruster void blk_drain_all(void)
20834be74634SMarkus Armbruster {
208433f2a757SStefan Hajnoczi BlockBackend *blk = NULL;
208533f2a757SStefan Hajnoczi
20860439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
20870439c5a4SEmanuele Giuseppe Esposito
208833f2a757SStefan Hajnoczi bdrv_drain_all_begin();
208933f2a757SStefan Hajnoczi
209033f2a757SStefan Hajnoczi while ((blk = blk_all_next(blk)) != NULL) {
209133f2a757SStefan Hajnoczi /* We may have -ENOMEDIUM completions in flight */
2092d5eab432SStefan Hajnoczi AIO_WAIT_WHILE_UNLOCKED(NULL, qatomic_read(&blk->in_flight) > 0);
209333f2a757SStefan Hajnoczi }
209433f2a757SStefan Hajnoczi
209533f2a757SStefan Hajnoczi bdrv_drain_all_end();
20964be74634SMarkus Armbruster }
20974be74634SMarkus Armbruster
blk_set_on_error(BlockBackend * blk,BlockdevOnError on_read_error,BlockdevOnError on_write_error)2098373340b2SMax Reitz void blk_set_on_error(BlockBackend *blk, BlockdevOnError on_read_error,
2099373340b2SMax Reitz BlockdevOnError on_write_error)
2100373340b2SMax Reitz {
21010439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
2102373340b2SMax Reitz blk->on_read_error = on_read_error;
2103373340b2SMax Reitz blk->on_write_error = on_write_error;
2104373340b2SMax Reitz }
2105373340b2SMax Reitz
blk_get_on_error(BlockBackend * blk,bool is_read)21064be74634SMarkus Armbruster BlockdevOnError blk_get_on_error(BlockBackend *blk, bool is_read)
21074be74634SMarkus Armbruster {
210837868b2aSEmanuele Giuseppe Esposito IO_CODE();
2109373340b2SMax Reitz return is_read ? blk->on_read_error : blk->on_write_error;
21104be74634SMarkus Armbruster }
21114be74634SMarkus Armbruster
blk_get_error_action(BlockBackend * blk,bool is_read,int error)21124be74634SMarkus Armbruster BlockErrorAction blk_get_error_action(BlockBackend *blk, bool is_read,
21134be74634SMarkus Armbruster int error)
21144be74634SMarkus Armbruster {
2115373340b2SMax Reitz BlockdevOnError on_err = blk_get_on_error(blk, is_read);
211637868b2aSEmanuele Giuseppe Esposito IO_CODE();
2117373340b2SMax Reitz
2118373340b2SMax Reitz switch (on_err) {
2119373340b2SMax Reitz case BLOCKDEV_ON_ERROR_ENOSPC:
2120373340b2SMax Reitz return (error == ENOSPC) ?
2121373340b2SMax Reitz BLOCK_ERROR_ACTION_STOP : BLOCK_ERROR_ACTION_REPORT;
2122373340b2SMax Reitz case BLOCKDEV_ON_ERROR_STOP:
2123373340b2SMax Reitz return BLOCK_ERROR_ACTION_STOP;
2124373340b2SMax Reitz case BLOCKDEV_ON_ERROR_REPORT:
2125373340b2SMax Reitz return BLOCK_ERROR_ACTION_REPORT;
2126373340b2SMax Reitz case BLOCKDEV_ON_ERROR_IGNORE:
2127373340b2SMax Reitz return BLOCK_ERROR_ACTION_IGNORE;
21288c398252SKevin Wolf case BLOCKDEV_ON_ERROR_AUTO:
2129373340b2SMax Reitz default:
2130373340b2SMax Reitz abort();
2131373340b2SMax Reitz }
21324be74634SMarkus Armbruster }
21334be74634SMarkus Armbruster
send_qmp_error_event(BlockBackend * blk,BlockErrorAction action,bool is_read,int error)2134373340b2SMax Reitz static void send_qmp_error_event(BlockBackend *blk,
2135373340b2SMax Reitz BlockErrorAction action,
2136373340b2SMax Reitz bool is_read, int error)
2137373340b2SMax Reitz {
2138373340b2SMax Reitz IoOperationType optype;
2139bfe1a14cSKevin Wolf BlockDriverState *bs = blk_bs(blk);
2140373340b2SMax Reitz
2141373340b2SMax Reitz optype = is_read ? IO_OPERATION_TYPE_READ : IO_OPERATION_TYPE_WRITE;
214254fde4ffSMarkus Armbruster qapi_event_send_block_io_error(blk_name(blk),
2143bfe1a14cSKevin Wolf bs ? bdrv_get_node_name(bs) : NULL, optype,
21442bf7e10fSKevin Wolf action, blk_iostatus_is_enabled(blk),
21453ab72385SPeter Xu error == ENOSPC, strerror(error));
2146373340b2SMax Reitz }
2147373340b2SMax Reitz
2148373340b2SMax Reitz /* This is done by device models because, while the block layer knows
2149373340b2SMax Reitz * about the error, it does not know whether an operation comes from
2150373340b2SMax Reitz * the device or the block layer (from a job, for example).
2151373340b2SMax Reitz */
blk_error_action(BlockBackend * blk,BlockErrorAction action,bool is_read,int error)21524be74634SMarkus Armbruster void blk_error_action(BlockBackend *blk, BlockErrorAction action,
21534be74634SMarkus Armbruster bool is_read, int error)
21544be74634SMarkus Armbruster {
2155373340b2SMax Reitz assert(error >= 0);
215637868b2aSEmanuele Giuseppe Esposito IO_CODE();
2157373340b2SMax Reitz
2158373340b2SMax Reitz if (action == BLOCK_ERROR_ACTION_STOP) {
2159373340b2SMax Reitz /* First set the iostatus, so that "info block" returns an iostatus
2160373340b2SMax Reitz * that matches the events raised so far (an additional error iostatus
2161373340b2SMax Reitz * is fine, but not a lost one).
2162373340b2SMax Reitz */
2163373340b2SMax Reitz blk_iostatus_set_err(blk, error);
2164373340b2SMax Reitz
2165373340b2SMax Reitz /* Then raise the request to stop the VM and the event.
2166373340b2SMax Reitz * qemu_system_vmstop_request_prepare has two effects. First,
2167373340b2SMax Reitz * it ensures that the STOP event always comes after the
2168373340b2SMax Reitz * BLOCK_IO_ERROR event. Second, it ensures that even if management
2169373340b2SMax Reitz * can observe the STOP event and do a "cont" before the STOP
2170373340b2SMax Reitz * event is issued, the VM will not stop. In this case, vm_start()
2171373340b2SMax Reitz * also ensures that the STOP/RESUME pair of events is emitted.
2172373340b2SMax Reitz */
2173373340b2SMax Reitz qemu_system_vmstop_request_prepare();
2174373340b2SMax Reitz send_qmp_error_event(blk, action, is_read, error);
2175373340b2SMax Reitz qemu_system_vmstop_request(RUN_STATE_IO_ERROR);
2176373340b2SMax Reitz } else {
2177373340b2SMax Reitz send_qmp_error_event(blk, action, is_read, error);
2178373340b2SMax Reitz }
21794be74634SMarkus Armbruster }
21804be74634SMarkus Armbruster
218186b1cf32SKevin Wolf /*
218286b1cf32SKevin Wolf * Returns true if the BlockBackend can support taking write permissions
218386b1cf32SKevin Wolf * (because its root node is not read-only).
218486b1cf32SKevin Wolf */
blk_supports_write_perm(BlockBackend * blk)218586b1cf32SKevin Wolf bool blk_supports_write_perm(BlockBackend *blk)
21864be74634SMarkus Armbruster {
2187f21d96d0SKevin Wolf BlockDriverState *bs = blk_bs(blk);
21880439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
2189f21d96d0SKevin Wolf
2190f21d96d0SKevin Wolf if (bs) {
219186b1cf32SKevin Wolf return !bdrv_is_read_only(bs);
2192061959e8SMax Reitz } else {
2193260242a8SVladimir Sementsov-Ogievskiy return blk->root_state.open_flags & BDRV_O_RDWR;
2194061959e8SMax Reitz }
21954be74634SMarkus Armbruster }
21964be74634SMarkus Armbruster
219786b1cf32SKevin Wolf /*
219886b1cf32SKevin Wolf * Returns true if the BlockBackend can be written to in its current
219986b1cf32SKevin Wolf * configuration (i.e. if write permission have been requested)
220086b1cf32SKevin Wolf */
blk_is_writable(BlockBackend * blk)220186b1cf32SKevin Wolf bool blk_is_writable(BlockBackend *blk)
220286b1cf32SKevin Wolf {
220337868b2aSEmanuele Giuseppe Esposito IO_CODE();
220486b1cf32SKevin Wolf return blk->perm & BLK_PERM_WRITE;
220586b1cf32SKevin Wolf }
220686b1cf32SKevin Wolf
blk_is_sg(BlockBackend * blk)220796710565SLi Qiang bool blk_is_sg(BlockBackend *blk)
22084be74634SMarkus Armbruster {
2209f21d96d0SKevin Wolf BlockDriverState *bs = blk_bs(blk);
22100439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
2211f21d96d0SKevin Wolf
2212f21d96d0SKevin Wolf if (!bs) {
221396710565SLi Qiang return false;
2214a46fc9c9SMax Reitz }
2215a46fc9c9SMax Reitz
2216f21d96d0SKevin Wolf return bdrv_is_sg(bs);
22174be74634SMarkus Armbruster }
22184be74634SMarkus Armbruster
blk_enable_write_cache(BlockBackend * blk)221996710565SLi Qiang bool blk_enable_write_cache(BlockBackend *blk)
22204be74634SMarkus Armbruster {
222137868b2aSEmanuele Giuseppe Esposito IO_CODE();
2222bfd18d1eSKevin Wolf return blk->enable_write_cache;
22234be74634SMarkus Armbruster }
22244be74634SMarkus Armbruster
blk_set_enable_write_cache(BlockBackend * blk,bool wce)22254be74634SMarkus Armbruster void blk_set_enable_write_cache(BlockBackend *blk, bool wce)
22264be74634SMarkus Armbruster {
2227be8da05bSEmanuele Giuseppe Esposito IO_CODE();
2228bfd18d1eSKevin Wolf blk->enable_write_cache = wce;
22294be74634SMarkus Armbruster }
22304be74634SMarkus Armbruster
blk_activate(BlockBackend * blk,Error ** errp)22313b717194SEmanuele Giuseppe Esposito void blk_activate(BlockBackend *blk, Error **errp)
22322bb0dce7SMax Reitz {
2233f21d96d0SKevin Wolf BlockDriverState *bs = blk_bs(blk);
22340439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
2235f21d96d0SKevin Wolf
2236f21d96d0SKevin Wolf if (!bs) {
2237c09ba36cSMax Reitz error_setg(errp, "Device '%s' has no medium", blk->name);
2238c09ba36cSMax Reitz return;
2239c09ba36cSMax Reitz }
2240c09ba36cSMax Reitz
2241da4afaffSKevin Wolf /*
2242da4afaffSKevin Wolf * Migration code can call this function in coroutine context, so leave
2243da4afaffSKevin Wolf * coroutine context if necessary.
2244da4afaffSKevin Wolf */
2245da4afaffSKevin Wolf if (qemu_in_coroutine()) {
2246da4afaffSKevin Wolf bdrv_co_activate(bs, errp);
2247da4afaffSKevin Wolf } else {
22482b3912f1SKevin Wolf GRAPH_RDLOCK_GUARD_MAINLOOP();
2249a94750d9SEmanuele Giuseppe Esposito bdrv_activate(bs, errp);
22502bb0dce7SMax Reitz }
2251da4afaffSKevin Wolf }
22522bb0dce7SMax Reitz
blk_co_is_inserted(BlockBackend * blk)22531e97be91SEmanuele Giuseppe Esposito bool coroutine_fn blk_co_is_inserted(BlockBackend *blk)
22544be74634SMarkus Armbruster {
2255f21d96d0SKevin Wolf BlockDriverState *bs = blk_bs(blk);
225637868b2aSEmanuele Giuseppe Esposito IO_CODE();
2257c73ff92cSEmanuele Giuseppe Esposito assert_bdrv_graph_readable();
2258f21d96d0SKevin Wolf
22591e97be91SEmanuele Giuseppe Esposito return bs && bdrv_co_is_inserted(bs);
2260db0284f8SMax Reitz }
2261db0284f8SMax Reitz
blk_co_is_available(BlockBackend * blk)2262c73ff92cSEmanuele Giuseppe Esposito bool coroutine_fn blk_co_is_available(BlockBackend *blk)
2263db0284f8SMax Reitz {
226437868b2aSEmanuele Giuseppe Esposito IO_CODE();
2265c73ff92cSEmanuele Giuseppe Esposito return blk_co_is_inserted(blk) && !blk_dev_is_tray_open(blk);
22664be74634SMarkus Armbruster }
22674be74634SMarkus Armbruster
blk_co_lock_medium(BlockBackend * blk,bool locked)22682c75261cSEmanuele Giuseppe Esposito void coroutine_fn blk_co_lock_medium(BlockBackend *blk, bool locked)
22694be74634SMarkus Armbruster {
2270f21d96d0SKevin Wolf BlockDriverState *bs = blk_bs(blk);
227137868b2aSEmanuele Giuseppe Esposito IO_CODE();
227279a292e5SKevin Wolf GRAPH_RDLOCK_GUARD();
2273f21d96d0SKevin Wolf
2274f21d96d0SKevin Wolf if (bs) {
22752c75261cSEmanuele Giuseppe Esposito bdrv_co_lock_medium(bs, locked);
22764be74634SMarkus Armbruster }
2277a46fc9c9SMax Reitz }
22784be74634SMarkus Armbruster
blk_co_eject(BlockBackend * blk,bool eject_flag)22792531b390SEmanuele Giuseppe Esposito void coroutine_fn blk_co_eject(BlockBackend *blk, bool eject_flag)
22804be74634SMarkus Armbruster {
2281f21d96d0SKevin Wolf BlockDriverState *bs = blk_bs(blk);
22822d76e724SKevin Wolf char *id;
228337868b2aSEmanuele Giuseppe Esposito IO_CODE();
228479a292e5SKevin Wolf GRAPH_RDLOCK_GUARD();
22852d76e724SKevin Wolf
2286f21d96d0SKevin Wolf if (bs) {
22872531b390SEmanuele Giuseppe Esposito bdrv_co_eject(bs, eject_flag);
2288c47ee043SJohn Snow }
22892d76e724SKevin Wolf
2290c47ee043SJohn Snow /* Whether or not we ejected on the backend,
2291c47ee043SJohn Snow * the frontend experienced a tray event. */
22922d76e724SKevin Wolf id = blk_get_attached_dev_id(blk);
22932d76e724SKevin Wolf qapi_event_send_device_tray_moved(blk_name(blk), id,
22943ab72385SPeter Xu eject_flag);
22952d76e724SKevin Wolf g_free(id);
2296a46fc9c9SMax Reitz }
22974be74634SMarkus Armbruster
blk_get_flags(BlockBackend * blk)22984be74634SMarkus Armbruster int blk_get_flags(BlockBackend *blk)
22994be74634SMarkus Armbruster {
2300f21d96d0SKevin Wolf BlockDriverState *bs = blk_bs(blk);
23010439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
2302f21d96d0SKevin Wolf
2303f21d96d0SKevin Wolf if (bs) {
2304f21d96d0SKevin Wolf return bdrv_get_flags(bs);
2305061959e8SMax Reitz } else {
2306061959e8SMax Reitz return blk->root_state.open_flags;
2307061959e8SMax Reitz }
23084be74634SMarkus Armbruster }
23094be74634SMarkus Armbruster
23104841211eSEric Blake /* Returns the minimum request alignment, in bytes; guaranteed nonzero */
blk_get_request_alignment(BlockBackend * blk)23114841211eSEric Blake uint32_t blk_get_request_alignment(BlockBackend *blk)
23124841211eSEric Blake {
23134841211eSEric Blake BlockDriverState *bs = blk_bs(blk);
231437868b2aSEmanuele Giuseppe Esposito IO_CODE();
23154841211eSEric Blake return bs ? bs->bl.request_alignment : BDRV_SECTOR_SIZE;
23164841211eSEric Blake }
23174841211eSEric Blake
231824b36e98SPaolo Bonzini /* Returns the maximum hardware transfer length, in bytes; guaranteed nonzero */
blk_get_max_hw_transfer(BlockBackend * blk)231924b36e98SPaolo Bonzini uint64_t blk_get_max_hw_transfer(BlockBackend *blk)
232024b36e98SPaolo Bonzini {
232124b36e98SPaolo Bonzini BlockDriverState *bs = blk_bs(blk);
232224b36e98SPaolo Bonzini uint64_t max = INT_MAX;
232337868b2aSEmanuele Giuseppe Esposito IO_CODE();
232424b36e98SPaolo Bonzini
232524b36e98SPaolo Bonzini if (bs) {
232624b36e98SPaolo Bonzini max = MIN_NON_ZERO(max, bs->bl.max_hw_transfer);
232724b36e98SPaolo Bonzini max = MIN_NON_ZERO(max, bs->bl.max_transfer);
232824b36e98SPaolo Bonzini }
232924b36e98SPaolo Bonzini return ROUND_DOWN(max, blk_get_request_alignment(blk));
233024b36e98SPaolo Bonzini }
233124b36e98SPaolo Bonzini
23325def6b80SEric Blake /* Returns the maximum transfer length, in bytes; guaranteed nonzero */
blk_get_max_transfer(BlockBackend * blk)23335def6b80SEric Blake uint32_t blk_get_max_transfer(BlockBackend *blk)
2334454057b7SPeter Lieven {
2335f21d96d0SKevin Wolf BlockDriverState *bs = blk_bs(blk);
2336b99f7fa0SPaolo Bonzini uint32_t max = INT_MAX;
233737868b2aSEmanuele Giuseppe Esposito IO_CODE();
2338f21d96d0SKevin Wolf
2339f21d96d0SKevin Wolf if (bs) {
2340b99f7fa0SPaolo Bonzini max = MIN_NON_ZERO(max, bs->bl.max_transfer);
2341a46fc9c9SMax Reitz }
2342b99f7fa0SPaolo Bonzini return ROUND_DOWN(max, blk_get_request_alignment(blk));
2343454057b7SPeter Lieven }
2344454057b7SPeter Lieven
blk_get_max_hw_iov(BlockBackend * blk)2345cc071629SPaolo Bonzini int blk_get_max_hw_iov(BlockBackend *blk)
2346cc071629SPaolo Bonzini {
234737868b2aSEmanuele Giuseppe Esposito IO_CODE();
2348cc071629SPaolo Bonzini return MIN_NON_ZERO(blk->root->bs->bl.max_hw_iov,
2349cc071629SPaolo Bonzini blk->root->bs->bl.max_iov);
2350cc071629SPaolo Bonzini }
2351cc071629SPaolo Bonzini
blk_get_max_iov(BlockBackend * blk)2352648296e0SStefan Hajnoczi int blk_get_max_iov(BlockBackend *blk)
2353648296e0SStefan Hajnoczi {
235437868b2aSEmanuele Giuseppe Esposito IO_CODE();
2355f21d96d0SKevin Wolf return blk->root->bs->bl.max_iov;
2356648296e0SStefan Hajnoczi }
2357648296e0SStefan Hajnoczi
blk_try_blockalign(BlockBackend * blk,size_t size)2358f1c17521SPaolo Bonzini void *blk_try_blockalign(BlockBackend *blk, size_t size)
2359f1c17521SPaolo Bonzini {
236037868b2aSEmanuele Giuseppe Esposito IO_CODE();
2361f21d96d0SKevin Wolf return qemu_try_blockalign(blk ? blk_bs(blk) : NULL, size);
2362f1c17521SPaolo Bonzini }
2363f1c17521SPaolo Bonzini
blk_blockalign(BlockBackend * blk,size_t size)23644be74634SMarkus Armbruster void *blk_blockalign(BlockBackend *blk, size_t size)
23654be74634SMarkus Armbruster {
236637868b2aSEmanuele Giuseppe Esposito IO_CODE();
2367f21d96d0SKevin Wolf return qemu_blockalign(blk ? blk_bs(blk) : NULL, size);
23684be74634SMarkus Armbruster }
23694be74634SMarkus Armbruster
blk_op_is_blocked(BlockBackend * blk,BlockOpType op,Error ** errp)23704be74634SMarkus Armbruster bool blk_op_is_blocked(BlockBackend *blk, BlockOpType op, Error **errp)
23714be74634SMarkus Armbruster {
2372f21d96d0SKevin Wolf BlockDriverState *bs = blk_bs(blk);
23730439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
2374277f2007SKevin Wolf GRAPH_RDLOCK_GUARD_MAINLOOP();
2375f21d96d0SKevin Wolf
2376f21d96d0SKevin Wolf if (!bs) {
2377a46fc9c9SMax Reitz return false;
2378a46fc9c9SMax Reitz }
2379a46fc9c9SMax Reitz
2380f21d96d0SKevin Wolf return bdrv_op_is_blocked(bs, op, errp);
23814be74634SMarkus Armbruster }
23824be74634SMarkus Armbruster
blk_op_unblock(BlockBackend * blk,BlockOpType op,Error * reason)23834be74634SMarkus Armbruster void blk_op_unblock(BlockBackend *blk, BlockOpType op, Error *reason)
23844be74634SMarkus Armbruster {
2385f21d96d0SKevin Wolf BlockDriverState *bs = blk_bs(blk);
23860439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
2387f21d96d0SKevin Wolf
2388f21d96d0SKevin Wolf if (bs) {
2389f21d96d0SKevin Wolf bdrv_op_unblock(bs, op, reason);
23904be74634SMarkus Armbruster }
2391a46fc9c9SMax Reitz }
23924be74634SMarkus Armbruster
blk_op_block_all(BlockBackend * blk,Error * reason)23934be74634SMarkus Armbruster void blk_op_block_all(BlockBackend *blk, Error *reason)
23944be74634SMarkus Armbruster {
2395f21d96d0SKevin Wolf BlockDriverState *bs = blk_bs(blk);
23960439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
2397f21d96d0SKevin Wolf
2398f21d96d0SKevin Wolf if (bs) {
2399f21d96d0SKevin Wolf bdrv_op_block_all(bs, reason);
24004be74634SMarkus Armbruster }
2401a46fc9c9SMax Reitz }
24024be74634SMarkus Armbruster
blk_op_unblock_all(BlockBackend * blk,Error * reason)24034be74634SMarkus Armbruster void blk_op_unblock_all(BlockBackend *blk, Error *reason)
24044be74634SMarkus Armbruster {
2405f21d96d0SKevin Wolf BlockDriverState *bs = blk_bs(blk);
24060439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
2407f21d96d0SKevin Wolf
2408f21d96d0SKevin Wolf if (bs) {
2409f21d96d0SKevin Wolf bdrv_op_unblock_all(bs, reason);
24104be74634SMarkus Armbruster }
2411a46fc9c9SMax Reitz }
24124be74634SMarkus Armbruster
2413ad893672SHanna Czenczek /**
2414ad893672SHanna Czenczek * Return BB's current AioContext. Note that this context may change
2415ad893672SHanna Czenczek * concurrently at any time, with one exception: If the BB has a root node
2416ad893672SHanna Czenczek * attached, its context will only change through bdrv_try_change_aio_context(),
2417ad893672SHanna Czenczek * which creates a drained section. Therefore, incrementing such a BB's
2418ad893672SHanna Czenczek * in-flight counter will prevent its context from changing.
2419ad893672SHanna Czenczek */
blk_get_aio_context(BlockBackend * blk)24204be74634SMarkus Armbruster AioContext *blk_get_aio_context(BlockBackend *blk)
24214be74634SMarkus Armbruster {
242237868b2aSEmanuele Giuseppe Esposito IO_CODE();
2423d861ab3aSKevin Wolf
2424dea97c1fSKevin Wolf if (!blk) {
2425dea97c1fSKevin Wolf return qemu_get_aio_context();
2426dea97c1fSKevin Wolf }
2427dea97c1fSKevin Wolf
2428ad893672SHanna Czenczek return qatomic_read(&blk->ctx);
2429d861ab3aSKevin Wolf }
2430d861ab3aSKevin Wolf
blk_set_aio_context(BlockBackend * blk,AioContext * new_context,Error ** errp)243197896a48SKevin Wolf int blk_set_aio_context(BlockBackend *blk, AioContext *new_context,
243297896a48SKevin Wolf Error **errp)
243338475269SKevin Wolf {
24342d196295SStefan Hajnoczi bool old_allow_change;
24352d196295SStefan Hajnoczi BlockDriverState *bs = blk_bs(blk);
24362d196295SStefan Hajnoczi int ret;
24372d196295SStefan Hajnoczi
24380439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
24392d196295SStefan Hajnoczi
24402d196295SStefan Hajnoczi if (!bs) {
2441ad893672SHanna Czenczek qatomic_set(&blk->ctx, new_context);
24422d196295SStefan Hajnoczi return 0;
24432d196295SStefan Hajnoczi }
24442d196295SStefan Hajnoczi
24452d196295SStefan Hajnoczi bdrv_ref(bs);
24462d196295SStefan Hajnoczi
24472d196295SStefan Hajnoczi old_allow_change = blk->allow_aio_context_change;
24482d196295SStefan Hajnoczi blk->allow_aio_context_change = true;
24492d196295SStefan Hajnoczi
24502d196295SStefan Hajnoczi ret = bdrv_try_change_aio_context(bs, new_context, NULL, errp);
24512d196295SStefan Hajnoczi
24522d196295SStefan Hajnoczi blk->allow_aio_context_change = old_allow_change;
24532d196295SStefan Hajnoczi
24542d196295SStefan Hajnoczi bdrv_unref(bs);
24552d196295SStefan Hajnoczi return ret;
245638475269SKevin Wolf }
245738475269SKevin Wolf
245833949396SEmanuele Giuseppe Esposito typedef struct BdrvStateBlkRootContext {
245933949396SEmanuele Giuseppe Esposito AioContext *new_ctx;
246033949396SEmanuele Giuseppe Esposito BlockBackend *blk;
246133949396SEmanuele Giuseppe Esposito } BdrvStateBlkRootContext;
246238475269SKevin Wolf
blk_root_set_aio_ctx_commit(void * opaque)246333949396SEmanuele Giuseppe Esposito static void blk_root_set_aio_ctx_commit(void *opaque)
246433949396SEmanuele Giuseppe Esposito {
246533949396SEmanuele Giuseppe Esposito BdrvStateBlkRootContext *s = opaque;
246633949396SEmanuele Giuseppe Esposito BlockBackend *blk = s->blk;
24672d196295SStefan Hajnoczi AioContext *new_context = s->new_ctx;
24682d196295SStefan Hajnoczi ThrottleGroupMember *tgm = &blk->public.throttle_group_member;
246933949396SEmanuele Giuseppe Esposito
2470ad893672SHanna Czenczek qatomic_set(&blk->ctx, new_context);
24712d196295SStefan Hajnoczi if (tgm->throttle_state) {
24722d196295SStefan Hajnoczi throttle_group_detach_aio_context(tgm);
24732d196295SStefan Hajnoczi throttle_group_attach_aio_context(tgm, new_context);
24742d196295SStefan Hajnoczi }
2475980b0f94SKevin Wolf }
2476980b0f94SKevin Wolf
247733949396SEmanuele Giuseppe Esposito static TransactionActionDrv set_blk_root_context = {
247833949396SEmanuele Giuseppe Esposito .commit = blk_root_set_aio_ctx_commit,
247933949396SEmanuele Giuseppe Esposito .clean = g_free,
248033949396SEmanuele Giuseppe Esposito };
248133949396SEmanuele Giuseppe Esposito
blk_root_change_aio_ctx(BdrvChild * child,AioContext * ctx,GHashTable * visited,Transaction * tran,Error ** errp)248233949396SEmanuele Giuseppe Esposito static bool blk_root_change_aio_ctx(BdrvChild *child, AioContext *ctx,
248333949396SEmanuele Giuseppe Esposito GHashTable *visited, Transaction *tran,
248433949396SEmanuele Giuseppe Esposito Error **errp)
248533949396SEmanuele Giuseppe Esposito {
248633949396SEmanuele Giuseppe Esposito BlockBackend *blk = child->opaque;
248733949396SEmanuele Giuseppe Esposito BdrvStateBlkRootContext *s;
248833949396SEmanuele Giuseppe Esposito
248933949396SEmanuele Giuseppe Esposito if (!blk->allow_aio_context_change) {
249033949396SEmanuele Giuseppe Esposito /*
249133949396SEmanuele Giuseppe Esposito * Manually created BlockBackends (those with a name) that are not
249233949396SEmanuele Giuseppe Esposito * attached to anything can change their AioContext without updating
249333949396SEmanuele Giuseppe Esposito * their user; return an error for others.
249433949396SEmanuele Giuseppe Esposito */
249538475269SKevin Wolf if (!blk->name || blk->dev) {
249638475269SKevin Wolf /* TODO Add BB name/QOM path */
249738475269SKevin Wolf error_setg(errp, "Cannot change iothread of active block backend");
249838475269SKevin Wolf return false;
249938475269SKevin Wolf }
250038475269SKevin Wolf }
250138475269SKevin Wolf
250233949396SEmanuele Giuseppe Esposito s = g_new(BdrvStateBlkRootContext, 1);
250333949396SEmanuele Giuseppe Esposito *s = (BdrvStateBlkRootContext) {
250433949396SEmanuele Giuseppe Esposito .new_ctx = ctx,
250533949396SEmanuele Giuseppe Esposito .blk = blk,
250633949396SEmanuele Giuseppe Esposito };
250733949396SEmanuele Giuseppe Esposito
250833949396SEmanuele Giuseppe Esposito tran_add(tran, &set_blk_root_context, s);
250933949396SEmanuele Giuseppe Esposito return true;
251038475269SKevin Wolf }
25114be74634SMarkus Armbruster
blk_add_aio_context_notifier(BlockBackend * blk,void (* attached_aio_context)(AioContext * new_context,void * opaque),void (* detach_aio_context)(void * opaque),void * opaque)25122019ba0aSMax Reitz void blk_add_aio_context_notifier(BlockBackend *blk,
25132019ba0aSMax Reitz void (*attached_aio_context)(AioContext *new_context, void *opaque),
25142019ba0aSMax Reitz void (*detach_aio_context)(void *opaque), void *opaque)
25152019ba0aSMax Reitz {
2516d03654eaSStefan Hajnoczi BlockBackendAioNotifier *notifier;
2517f21d96d0SKevin Wolf BlockDriverState *bs = blk_bs(blk);
25180439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
2519f21d96d0SKevin Wolf
2520d03654eaSStefan Hajnoczi notifier = g_new(BlockBackendAioNotifier, 1);
2521d03654eaSStefan Hajnoczi notifier->attached_aio_context = attached_aio_context;
2522d03654eaSStefan Hajnoczi notifier->detach_aio_context = detach_aio_context;
2523d03654eaSStefan Hajnoczi notifier->opaque = opaque;
2524d03654eaSStefan Hajnoczi QLIST_INSERT_HEAD(&blk->aio_notifiers, notifier, list);
2525d03654eaSStefan Hajnoczi
2526f21d96d0SKevin Wolf if (bs) {
2527f21d96d0SKevin Wolf bdrv_add_aio_context_notifier(bs, attached_aio_context,
25282019ba0aSMax Reitz detach_aio_context, opaque);
25292019ba0aSMax Reitz }
2530a46fc9c9SMax Reitz }
25312019ba0aSMax Reitz
blk_remove_aio_context_notifier(BlockBackend * blk,void (* attached_aio_context)(AioContext *,void *),void (* detach_aio_context)(void *),void * opaque)25322019ba0aSMax Reitz void blk_remove_aio_context_notifier(BlockBackend *blk,
25332019ba0aSMax Reitz void (*attached_aio_context)(AioContext *,
25342019ba0aSMax Reitz void *),
25352019ba0aSMax Reitz void (*detach_aio_context)(void *),
25362019ba0aSMax Reitz void *opaque)
25372019ba0aSMax Reitz {
2538d03654eaSStefan Hajnoczi BlockBackendAioNotifier *notifier;
2539f21d96d0SKevin Wolf BlockDriverState *bs = blk_bs(blk);
2540f21d96d0SKevin Wolf
25410439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
25420439c5a4SEmanuele Giuseppe Esposito
2543f21d96d0SKevin Wolf if (bs) {
2544f21d96d0SKevin Wolf bdrv_remove_aio_context_notifier(bs, attached_aio_context,
25452019ba0aSMax Reitz detach_aio_context, opaque);
25462019ba0aSMax Reitz }
2547d03654eaSStefan Hajnoczi
2548d03654eaSStefan Hajnoczi QLIST_FOREACH(notifier, &blk->aio_notifiers, list) {
2549d03654eaSStefan Hajnoczi if (notifier->attached_aio_context == attached_aio_context &&
2550d03654eaSStefan Hajnoczi notifier->detach_aio_context == detach_aio_context &&
2551d03654eaSStefan Hajnoczi notifier->opaque == opaque) {
2552d03654eaSStefan Hajnoczi QLIST_REMOVE(notifier, list);
2553d03654eaSStefan Hajnoczi g_free(notifier);
2554d03654eaSStefan Hajnoczi return;
2555d03654eaSStefan Hajnoczi }
2556d03654eaSStefan Hajnoczi }
2557d03654eaSStefan Hajnoczi
2558d03654eaSStefan Hajnoczi abort();
2559a46fc9c9SMax Reitz }
25602019ba0aSMax Reitz
blk_add_remove_bs_notifier(BlockBackend * blk,Notifier * notify)25613301f6c6SMax Reitz void blk_add_remove_bs_notifier(BlockBackend *blk, Notifier *notify)
25623301f6c6SMax Reitz {
25630439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
25643301f6c6SMax Reitz notifier_list_add(&blk->remove_bs_notifiers, notify);
25653301f6c6SMax Reitz }
25663301f6c6SMax Reitz
blk_add_insert_bs_notifier(BlockBackend * blk,Notifier * notify)25673301f6c6SMax Reitz void blk_add_insert_bs_notifier(BlockBackend *blk, Notifier *notify)
25683301f6c6SMax Reitz {
25690439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
25703301f6c6SMax Reitz notifier_list_add(&blk->insert_bs_notifiers, notify);
25713301f6c6SMax Reitz }
25723301f6c6SMax Reitz
blk_get_stats(BlockBackend * blk)25734be74634SMarkus Armbruster BlockAcctStats *blk_get_stats(BlockBackend *blk)
25744be74634SMarkus Armbruster {
257537868b2aSEmanuele Giuseppe Esposito IO_CODE();
25767f0e9da6SMax Reitz return &blk->stats;
25774be74634SMarkus Armbruster }
25784be74634SMarkus Armbruster
blk_aio_get(const AIOCBInfo * aiocb_info,BlockBackend * blk,BlockCompletionFunc * cb,void * opaque)25794be74634SMarkus Armbruster void *blk_aio_get(const AIOCBInfo *aiocb_info, BlockBackend *blk,
25804be74634SMarkus Armbruster BlockCompletionFunc *cb, void *opaque)
25814be74634SMarkus Armbruster {
258237868b2aSEmanuele Giuseppe Esposito IO_CODE();
25834be74634SMarkus Armbruster return qemu_aio_get(aiocb_info, blk_bs(blk), cb, opaque);
25844be74634SMarkus Armbruster }
25851ef01253SMax Reitz
blk_co_pwrite_zeroes(BlockBackend * blk,int64_t offset,int64_t bytes,BdrvRequestFlags flags)2586d004bd52SEric Blake int coroutine_fn blk_co_pwrite_zeroes(BlockBackend *blk, int64_t offset,
258734460febSVladimir Sementsov-Ogievskiy int64_t bytes, BdrvRequestFlags flags)
25881ef01253SMax Reitz {
258937868b2aSEmanuele Giuseppe Esposito IO_OR_GS_CODE();
2590f5a5ca79SManos Pitsidianakis return blk_co_pwritev(blk, offset, bytes, NULL,
259116aaf975SKevin Wolf flags | BDRV_REQ_ZERO_WRITE);
25921ef01253SMax Reitz }
25931ef01253SMax Reitz
blk_co_pwrite_compressed(BlockBackend * blk,int64_t offset,int64_t bytes,const void * buf)25942c9715faSAlberto Faria int coroutine_fn blk_co_pwrite_compressed(BlockBackend *blk, int64_t offset,
25952c9715faSAlberto Faria int64_t bytes, const void *buf)
25961ef01253SMax Reitz {
259706f0325cSVladimir Sementsov-Ogievskiy QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
259837868b2aSEmanuele Giuseppe Esposito IO_OR_GS_CODE();
25992c9715faSAlberto Faria return blk_co_pwritev_part(blk, offset, bytes, &qiov, 0,
260035fadca8SPavel Butsykin BDRV_REQ_WRITE_COMPRESSED);
26011ef01253SMax Reitz }
26021ef01253SMax Reitz
blk_co_truncate(BlockBackend * blk,int64_t offset,bool exact,PreallocMode prealloc,BdrvRequestFlags flags,Error ** errp)2603015ed252SAlberto Faria int coroutine_fn blk_co_truncate(BlockBackend *blk, int64_t offset, bool exact,
2604015ed252SAlberto Faria PreallocMode prealloc, BdrvRequestFlags flags,
2605015ed252SAlberto Faria Error **errp)
26061ef01253SMax Reitz {
260737868b2aSEmanuele Giuseppe Esposito IO_OR_GS_CODE();
2608c2b8e315SKevin Wolf GRAPH_RDLOCK_GUARD();
2609c73ff92cSEmanuele Giuseppe Esposito if (!blk_co_is_available(blk)) {
2610ed3d2ec9SMax Reitz error_setg(errp, "No medium inserted");
2611c09ba36cSMax Reitz return -ENOMEDIUM;
2612c09ba36cSMax Reitz }
2613c09ba36cSMax Reitz
2614015ed252SAlberto Faria return bdrv_co_truncate(blk->root, offset, exact, prealloc, flags, errp);
26151ef01253SMax Reitz }
26161ef01253SMax Reitz
blk_save_vmstate(BlockBackend * blk,const uint8_t * buf,int64_t pos,int size)26171ef01253SMax Reitz int blk_save_vmstate(BlockBackend *blk, const uint8_t *buf,
26181ef01253SMax Reitz int64_t pos, int size)
26191ef01253SMax Reitz {
2620bfd18d1eSKevin Wolf int ret;
26210439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
2622bfd18d1eSKevin Wolf
2623c09ba36cSMax Reitz if (!blk_is_available(blk)) {
2624c09ba36cSMax Reitz return -ENOMEDIUM;
2625c09ba36cSMax Reitz }
2626c09ba36cSMax Reitz
2627bfd18d1eSKevin Wolf ret = bdrv_save_vmstate(blk_bs(blk), buf, pos, size);
2628bfd18d1eSKevin Wolf if (ret < 0) {
2629bfd18d1eSKevin Wolf return ret;
2630bfd18d1eSKevin Wolf }
2631bfd18d1eSKevin Wolf
2632bfd18d1eSKevin Wolf if (ret == size && !blk->enable_write_cache) {
2633bfd18d1eSKevin Wolf ret = bdrv_flush(blk_bs(blk));
2634bfd18d1eSKevin Wolf }
2635bfd18d1eSKevin Wolf
2636bfd18d1eSKevin Wolf return ret < 0 ? ret : size;
26371ef01253SMax Reitz }
26381ef01253SMax Reitz
blk_load_vmstate(BlockBackend * blk,uint8_t * buf,int64_t pos,int size)26391ef01253SMax Reitz int blk_load_vmstate(BlockBackend *blk, uint8_t *buf, int64_t pos, int size)
26401ef01253SMax Reitz {
26410439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
2642c09ba36cSMax Reitz if (!blk_is_available(blk)) {
2643c09ba36cSMax Reitz return -ENOMEDIUM;
2644c09ba36cSMax Reitz }
2645c09ba36cSMax Reitz
2646f21d96d0SKevin Wolf return bdrv_load_vmstate(blk_bs(blk), buf, pos, size);
26471ef01253SMax Reitz }
2648f0272c4dSEkaterina Tumanova
blk_probe_blocksizes(BlockBackend * blk,BlockSizes * bsz)2649f0272c4dSEkaterina Tumanova int blk_probe_blocksizes(BlockBackend *blk, BlockSizes *bsz)
2650f0272c4dSEkaterina Tumanova {
26510439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
2652221caadcSKevin Wolf GRAPH_RDLOCK_GUARD_MAINLOOP();
2653221caadcSKevin Wolf
2654c09ba36cSMax Reitz if (!blk_is_available(blk)) {
2655c09ba36cSMax Reitz return -ENOMEDIUM;
2656c09ba36cSMax Reitz }
2657c09ba36cSMax Reitz
2658f21d96d0SKevin Wolf return bdrv_probe_blocksizes(blk_bs(blk), bsz);
2659f0272c4dSEkaterina Tumanova }
2660f0272c4dSEkaterina Tumanova
blk_probe_geometry(BlockBackend * blk,HDGeometry * geo)2661f0272c4dSEkaterina Tumanova int blk_probe_geometry(BlockBackend *blk, HDGeometry *geo)
2662f0272c4dSEkaterina Tumanova {
26630439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
2664c09ba36cSMax Reitz if (!blk_is_available(blk)) {
2665c09ba36cSMax Reitz return -ENOMEDIUM;
2666c09ba36cSMax Reitz }
2667c09ba36cSMax Reitz
2668f21d96d0SKevin Wolf return bdrv_probe_geometry(blk_bs(blk), geo);
2669f0272c4dSEkaterina Tumanova }
2670281d22d8SMax Reitz
2671281d22d8SMax Reitz /*
2672281d22d8SMax Reitz * Updates the BlockBackendRootState object with data from the currently
2673281d22d8SMax Reitz * attached BlockDriverState.
2674281d22d8SMax Reitz */
blk_update_root_state(BlockBackend * blk)2675281d22d8SMax Reitz void blk_update_root_state(BlockBackend *blk)
2676281d22d8SMax Reitz {
26770439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
2678f21d96d0SKevin Wolf assert(blk->root);
2679281d22d8SMax Reitz
2680f21d96d0SKevin Wolf blk->root_state.open_flags = blk->root->bs->open_flags;
2681f21d96d0SKevin Wolf blk->root_state.detect_zeroes = blk->root->bs->detect_zeroes;
2682281d22d8SMax Reitz }
2683281d22d8SMax Reitz
268438cb18f5SMax Reitz /*
2685b85114f8SKevin Wolf * Returns the detect-zeroes setting to be used for bdrv_open() of a
2686b85114f8SKevin Wolf * BlockDriverState which is supposed to inherit the root state.
268738cb18f5SMax Reitz */
blk_get_detect_zeroes_from_root_state(BlockBackend * blk)2688b85114f8SKevin Wolf bool blk_get_detect_zeroes_from_root_state(BlockBackend *blk)
268938cb18f5SMax Reitz {
26900439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
2691b85114f8SKevin Wolf return blk->root_state.detect_zeroes;
269238cb18f5SMax Reitz }
269338cb18f5SMax Reitz
269438cb18f5SMax Reitz /*
269538cb18f5SMax Reitz * Returns the flags to be used for bdrv_open() of a BlockDriverState which is
269638cb18f5SMax Reitz * supposed to inherit the root state.
269738cb18f5SMax Reitz */
blk_get_open_flags_from_root_state(BlockBackend * blk)269838cb18f5SMax Reitz int blk_get_open_flags_from_root_state(BlockBackend *blk)
269938cb18f5SMax Reitz {
27000439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
2701260242a8SVladimir Sementsov-Ogievskiy return blk->root_state.open_flags;
270238cb18f5SMax Reitz }
270338cb18f5SMax Reitz
blk_get_root_state(BlockBackend * blk)2704281d22d8SMax Reitz BlockBackendRootState *blk_get_root_state(BlockBackend *blk)
2705281d22d8SMax Reitz {
27060439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
2707281d22d8SMax Reitz return &blk->root_state;
2708281d22d8SMax Reitz }
27091393f212SMax Reitz
blk_commit_all(void)27101393f212SMax Reitz int blk_commit_all(void)
27111393f212SMax Reitz {
2712fe1a9cbcSMax Reitz BlockBackend *blk = NULL;
27130439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
2714ad74751fSKevin Wolf GRAPH_RDLOCK_GUARD_MAINLOOP();
2715fe1a9cbcSMax Reitz
2716fe1a9cbcSMax Reitz while ((blk = blk_all_next(blk)) != NULL) {
27179a71b9deSMax Reitz BlockDriverState *unfiltered_bs = bdrv_skip_filters(blk_bs(blk));
2718fe1a9cbcSMax Reitz
27199a71b9deSMax Reitz if (blk_is_inserted(blk) && bdrv_cow_child(unfiltered_bs)) {
27209a71b9deSMax Reitz int ret;
27219a71b9deSMax Reitz
27229a71b9deSMax Reitz ret = bdrv_commit(unfiltered_bs);
2723fe1a9cbcSMax Reitz if (ret < 0) {
2724fe1a9cbcSMax Reitz return ret;
2725fe1a9cbcSMax Reitz }
2726fe1a9cbcSMax Reitz }
2727fe1a9cbcSMax Reitz }
2728fe1a9cbcSMax Reitz return 0;
2729fe1a9cbcSMax Reitz }
2730fe1a9cbcSMax Reitz
273197148076SKevin Wolf
273297148076SKevin Wolf /* throttling disk I/O limits */
blk_set_io_limits(BlockBackend * blk,ThrottleConfig * cfg)273397148076SKevin Wolf void blk_set_io_limits(BlockBackend *blk, ThrottleConfig *cfg)
273497148076SKevin Wolf {
27350439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
2736022cdc9fSManos Pitsidianakis throttle_group_config(&blk->public.throttle_group_member, cfg);
273797148076SKevin Wolf }
273897148076SKevin Wolf
blk_io_limits_disable(BlockBackend * blk)273997148076SKevin Wolf void blk_io_limits_disable(BlockBackend *blk)
274097148076SKevin Wolf {
274148bf7ea8SAlberto Garcia BlockDriverState *bs = blk_bs(blk);
274248bf7ea8SAlberto Garcia ThrottleGroupMember *tgm = &blk->public.throttle_group_member;
274348bf7ea8SAlberto Garcia assert(tgm->throttle_state);
27440439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
274548bf7ea8SAlberto Garcia if (bs) {
27461e3552dbSStefan Hajnoczi bdrv_ref(bs);
274748bf7ea8SAlberto Garcia bdrv_drained_begin(bs);
274848bf7ea8SAlberto Garcia }
274948bf7ea8SAlberto Garcia throttle_group_unregister_tgm(tgm);
275048bf7ea8SAlberto Garcia if (bs) {
275148bf7ea8SAlberto Garcia bdrv_drained_end(bs);
27521e3552dbSStefan Hajnoczi bdrv_unref(bs);
275348bf7ea8SAlberto Garcia }
275497148076SKevin Wolf }
275597148076SKevin Wolf
275697148076SKevin Wolf /* should be called before blk_set_io_limits if a limit is set */
blk_io_limits_enable(BlockBackend * blk,const char * group)275797148076SKevin Wolf void blk_io_limits_enable(BlockBackend *blk, const char *group)
275897148076SKevin Wolf {
2759022cdc9fSManos Pitsidianakis assert(!blk->public.throttle_group_member.throttle_state);
27600439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
2761c61791fcSManos Pitsidianakis throttle_group_register_tgm(&blk->public.throttle_group_member,
2762c61791fcSManos Pitsidianakis group, blk_get_aio_context(blk));
276397148076SKevin Wolf }
276497148076SKevin Wolf
blk_io_limits_update_group(BlockBackend * blk,const char * group)276597148076SKevin Wolf void blk_io_limits_update_group(BlockBackend *blk, const char *group)
276697148076SKevin Wolf {
27670439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
276897148076SKevin Wolf /* this BB is not part of any group */
2769022cdc9fSManos Pitsidianakis if (!blk->public.throttle_group_member.throttle_state) {
277097148076SKevin Wolf return;
277197148076SKevin Wolf }
277297148076SKevin Wolf
277397148076SKevin Wolf /* this BB is a part of the same group than the one we want */
2774022cdc9fSManos Pitsidianakis if (!g_strcmp0(throttle_group_get_name(&blk->public.throttle_group_member),
2775022cdc9fSManos Pitsidianakis group)) {
277697148076SKevin Wolf return;
277797148076SKevin Wolf }
277897148076SKevin Wolf
277997148076SKevin Wolf /* need to change the group this bs belong to */
278097148076SKevin Wolf blk_io_limits_disable(blk);
278197148076SKevin Wolf blk_io_limits_enable(blk, group);
278297148076SKevin Wolf }
2783c2066af0SKevin Wolf
blk_root_drained_begin(BdrvChild * child)2784c2066af0SKevin Wolf static void blk_root_drained_begin(BdrvChild *child)
2785c2066af0SKevin Wolf {
2786c2066af0SKevin Wolf BlockBackend *blk = child->opaque;
2787d73415a3SStefan Hajnoczi ThrottleGroupMember *tgm = &blk->public.throttle_group_member;
2788c2066af0SKevin Wolf
2789c4d5bf99SStefan Hajnoczi if (qatomic_fetch_inc(&blk->quiesce_counter) == 0) {
2790f4d9cc88SJohn Snow if (blk->dev_ops && blk->dev_ops->drained_begin) {
2791f4d9cc88SJohn Snow blk->dev_ops->drained_begin(blk->dev_opaque);
2792f4d9cc88SJohn Snow }
2793f4d9cc88SJohn Snow }
2794f4d9cc88SJohn Snow
279536fe1331SKevin Wolf /* Note that blk->root may not be accessible here yet if we are just
279636fe1331SKevin Wolf * attaching to a BlockDriverState that is drained. Use child instead. */
279736fe1331SKevin Wolf
2798d73415a3SStefan Hajnoczi if (qatomic_fetch_inc(&tgm->io_limits_disabled) == 0) {
2799d73415a3SStefan Hajnoczi throttle_group_restart_tgm(tgm);
2800c2066af0SKevin Wolf }
2801c2066af0SKevin Wolf }
2802c2066af0SKevin Wolf
blk_root_drained_poll(BdrvChild * child)2803fe5258a5SKevin Wolf static bool blk_root_drained_poll(BdrvChild *child)
2804fe5258a5SKevin Wolf {
2805fe5258a5SKevin Wolf BlockBackend *blk = child->opaque;
2806095cc4d0SSergio Lopez bool busy = false;
2807c4d5bf99SStefan Hajnoczi assert(qatomic_read(&blk->quiesce_counter));
2808095cc4d0SSergio Lopez
2809095cc4d0SSergio Lopez if (blk->dev_ops && blk->dev_ops->drained_poll) {
2810095cc4d0SSergio Lopez busy = blk->dev_ops->drained_poll(blk->dev_opaque);
2811095cc4d0SSergio Lopez }
2812095cc4d0SSergio Lopez return busy || !!blk->in_flight;
2813fe5258a5SKevin Wolf }
2814fe5258a5SKevin Wolf
blk_root_drained_end(BdrvChild * child)28152f65df6eSKevin Wolf static void blk_root_drained_end(BdrvChild *child)
2816c2066af0SKevin Wolf {
2817c2066af0SKevin Wolf BlockBackend *blk = child->opaque;
2818c4d5bf99SStefan Hajnoczi assert(qatomic_read(&blk->quiesce_counter));
2819c2066af0SKevin Wolf
2820022cdc9fSManos Pitsidianakis assert(blk->public.throttle_group_member.io_limits_disabled);
2821d73415a3SStefan Hajnoczi qatomic_dec(&blk->public.throttle_group_member.io_limits_disabled);
2822f4d9cc88SJohn Snow
2823c4d5bf99SStefan Hajnoczi if (qatomic_fetch_dec(&blk->quiesce_counter) == 1) {
2824f4d9cc88SJohn Snow if (blk->dev_ops && blk->dev_ops->drained_end) {
2825f4d9cc88SJohn Snow blk->dev_ops->drained_end(blk->dev_opaque);
2826f4d9cc88SJohn Snow }
2827407ae2aeSStefan Hajnoczi qemu_mutex_lock(&blk->queued_requests_lock);
2828407ae2aeSStefan Hajnoczi while (qemu_co_enter_next(&blk->queued_requests,
2829407ae2aeSStefan Hajnoczi &blk->queued_requests_lock)) {
2830cf312932SKevin Wolf /* Resume all queued requests */
2831cf312932SKevin Wolf }
2832407ae2aeSStefan Hajnoczi qemu_mutex_unlock(&blk->queued_requests_lock);
2833f4d9cc88SJohn Snow }
2834c2066af0SKevin Wolf }
283523d0ba93SFam Zheng
blk_register_buf(BlockBackend * blk,void * host,size_t size,Error ** errp)2836f4ec04baSStefan Hajnoczi bool blk_register_buf(BlockBackend *blk, void *host, size_t size, Error **errp)
283723d0ba93SFam Zheng {
283871038951SStefan Hajnoczi BlockDriverState *bs = blk_bs(blk);
283971038951SStefan Hajnoczi
28400439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
284171038951SStefan Hajnoczi
284271038951SStefan Hajnoczi if (bs) {
284371038951SStefan Hajnoczi return bdrv_register_buf(bs, host, size, errp);
284471038951SStefan Hajnoczi }
284571038951SStefan Hajnoczi return true;
284623d0ba93SFam Zheng }
284723d0ba93SFam Zheng
blk_unregister_buf(BlockBackend * blk,void * host,size_t size)28484f384011SStefan Hajnoczi void blk_unregister_buf(BlockBackend *blk, void *host, size_t size)
284923d0ba93SFam Zheng {
285071038951SStefan Hajnoczi BlockDriverState *bs = blk_bs(blk);
285171038951SStefan Hajnoczi
28520439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
285371038951SStefan Hajnoczi
285471038951SStefan Hajnoczi if (bs) {
285571038951SStefan Hajnoczi bdrv_unregister_buf(bs, host, size);
285671038951SStefan Hajnoczi }
285723d0ba93SFam Zheng }
2858b5679fa4SFam Zheng
blk_co_copy_range(BlockBackend * blk_in,int64_t off_in,BlockBackend * blk_out,int64_t off_out,int64_t bytes,BdrvRequestFlags read_flags,BdrvRequestFlags write_flags)2859b5679fa4SFam Zheng int coroutine_fn blk_co_copy_range(BlockBackend *blk_in, int64_t off_in,
2860b5679fa4SFam Zheng BlockBackend *blk_out, int64_t off_out,
2861e192179bSVladimir Sementsov-Ogievskiy int64_t bytes, BdrvRequestFlags read_flags,
286267b51fb9SVladimir Sementsov-Ogievskiy BdrvRequestFlags write_flags)
2863b5679fa4SFam Zheng {
2864b5679fa4SFam Zheng int r;
286537868b2aSEmanuele Giuseppe Esposito IO_CODE();
2866c73ff92cSEmanuele Giuseppe Esposito GRAPH_RDLOCK_GUARD();
286737868b2aSEmanuele Giuseppe Esposito
2868b5679fa4SFam Zheng r = blk_check_byte_request(blk_in, off_in, bytes);
2869b5679fa4SFam Zheng if (r) {
2870b5679fa4SFam Zheng return r;
2871b5679fa4SFam Zheng }
2872b5679fa4SFam Zheng r = blk_check_byte_request(blk_out, off_out, bytes);
2873b5679fa4SFam Zheng if (r) {
2874b5679fa4SFam Zheng return r;
2875b5679fa4SFam Zheng }
2876742bf09bSEmanuele Giuseppe Esposito
2877b5679fa4SFam Zheng return bdrv_co_copy_range(blk_in->root, off_in,
2878b5679fa4SFam Zheng blk_out->root, off_out,
287967b51fb9SVladimir Sementsov-Ogievskiy bytes, read_flags, write_flags);
2880b5679fa4SFam Zheng }
28815d3b4e99SVladimir Sementsov-Ogievskiy
blk_root(BlockBackend * blk)28825d3b4e99SVladimir Sementsov-Ogievskiy const BdrvChild *blk_root(BlockBackend *blk)
28835d3b4e99SVladimir Sementsov-Ogievskiy {
28840439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
28855d3b4e99SVladimir Sementsov-Ogievskiy return blk->root;
28865d3b4e99SVladimir Sementsov-Ogievskiy }
28872b7bbdbdSMax Reitz
blk_make_empty(BlockBackend * blk,Error ** errp)28882b7bbdbdSMax Reitz int blk_make_empty(BlockBackend *blk, Error **errp)
28892b7bbdbdSMax Reitz {
28900439c5a4SEmanuele Giuseppe Esposito GLOBAL_STATE_CODE();
28910bb79c97SKevin Wolf GRAPH_RDLOCK_GUARD_MAINLOOP();
28920bb79c97SKevin Wolf
28932b7bbdbdSMax Reitz if (!blk_is_available(blk)) {
28942b7bbdbdSMax Reitz error_setg(errp, "No medium inserted");
28952b7bbdbdSMax Reitz return -ENOMEDIUM;
28962b7bbdbdSMax Reitz }
28972b7bbdbdSMax Reitz
28982b7bbdbdSMax Reitz return bdrv_make_empty(blk->root, errp);
28992b7bbdbdSMax Reitz }
2900