]> git.proxmox.com Git - mirror_qemu.git/blame - block/block-backend.c
Merge remote-tracking branch 'mreitz/tags/pull-block-2018-03-02' into queue-block
[mirror_qemu.git] / block / block-backend.c
CommitLineData
26f54e9a
MA
1/*
2 * QEMU Block backends
3 *
60cb2fa7 4 * Copyright (C) 2014-2016 Red Hat, Inc.
26f54e9a
MA
5 *
6 * Authors:
7 * Markus Armbruster <armbru@redhat.com>,
8 *
9 * This work is licensed under the terms of the GNU LGPL, version 2.1
10 * or later. See the COPYING.LIB file in the top-level directory.
11 */
12
80c71a24 13#include "qemu/osdep.h"
26f54e9a
MA
14#include "sysemu/block-backend.h"
15#include "block/block_int.h"
373340b2 16#include "block/blockjob.h"
281d22d8 17#include "block/throttle-groups.h"
18e46a03 18#include "sysemu/blockdev.h"
373340b2 19#include "sysemu/sysemu.h"
a7f53e26 20#include "qapi-event.h"
e688df6b 21#include "qapi/error.h"
f348b6d1 22#include "qemu/id.h"
922a01a0 23#include "qemu/option.h"
1e98fefd 24#include "trace.h"
5f7772c4 25#include "migration/misc.h"
a7f53e26
MA
26
27/* Number of coroutines to reserve per attached device model */
28#define COROUTINE_POOL_RESERVATION 64
26f54e9a 29
1bf1cbc9
KW
30#define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
31
4981bdec
HR
32static AioContext *blk_aiocb_get_aio_context(BlockAIOCB *acb);
33
26f54e9a
MA
34struct BlockBackend {
35 char *name;
36 int refcnt;
f21d96d0 37 BdrvChild *root;
26f8b3a8 38 DriveInfo *legacy_dinfo; /* null unless created by drive_new() */
2cf22d6a 39 QTAILQ_ENTRY(BlockBackend) link; /* for block_backends */
9492b0b9 40 QTAILQ_ENTRY(BlockBackend) monitor_link; /* for monitor_block_backends */
f2cd875d 41 BlockBackendPublic public;
a7f53e26
MA
42
43 void *dev; /* attached device model, if any */
bbc8ea98 44 bool legacy_dev; /* true if dev is not a DeviceState */
a7f53e26
MA
45 /* TODO change to DeviceState when all users are qdevified */
46 const BlockDevOps *dev_ops;
47 void *dev_opaque;
68e9ec01
HR
48
49 /* the block size for which the guest device expects atomicity */
50 int guest_block_size;
7f0e9da6 51
281d22d8
HR
52 /* If the BDS tree is removed, some of its options are stored here (which
53 * can be used to restore those options in the new BDS on insert) */
54 BlockBackendRootState root_state;
55
bfd18d1e
KW
56 bool enable_write_cache;
57
7f0e9da6
HR
58 /* I/O stats (display with "info blockstats"). */
59 BlockAcctStats stats;
373340b2
HR
60
61 BlockdevOnError on_read_error, on_write_error;
62 bool iostatus_enabled;
63 BlockDeviceIoStatus iostatus;
3301f6c6 64
981776b3
KW
65 uint64_t perm;
66 uint64_t shared_perm;
d35ff5e6 67 bool disable_perm;
981776b3 68
c10c9d96
KW
69 bool allow_write_beyond_eof;
70
3301f6c6 71 NotifierList remove_bs_notifiers, insert_bs_notifiers;
f4d9cc88
JS
72
73 int quiesce_counter;
5f7772c4 74 VMChangeStateEntry *vmsh;
ca2e2144 75 bool force_allow_inactivate;
33f2a757
SH
76
77 /* Number of in-flight aio requests. BlockDriverState also counts
78 * in-flight requests but aio requests can exist even when blk->root is
79 * NULL, so we cannot rely on its counter for that case.
80 * Accessed with atomic ops.
81 */
82 unsigned int in_flight;
83 AioWait wait;
26f54e9a
MA
84};
85
e7f7d676
HR
86typedef struct BlockBackendAIOCB {
87 BlockAIOCB common;
4981bdec 88 BlockBackend *blk;
e7f7d676
HR
89 int ret;
90} BlockBackendAIOCB;
91
92static const AIOCBInfo block_backend_aiocb_info = {
4981bdec 93 .get_aio_context = blk_aiocb_get_aio_context,
e7f7d676
HR
94 .aiocb_size = sizeof(BlockBackendAIOCB),
95};
96
8fb3c76c 97static void drive_info_del(DriveInfo *dinfo);
7c8eece4 98static BlockBackend *bdrv_first_blk(BlockDriverState *bs);
8fb3c76c 99
2cf22d6a
HR
100/* All BlockBackends */
101static QTAILQ_HEAD(, BlockBackend) block_backends =
102 QTAILQ_HEAD_INITIALIZER(block_backends);
103
9492b0b9
HR
104/* All BlockBackends referenced by the monitor and which are iterated through by
105 * blk_next() */
106static QTAILQ_HEAD(, BlockBackend) monitor_block_backends =
107 QTAILQ_HEAD_INITIALIZER(monitor_block_backends);
26f54e9a 108
f21d96d0
KW
109static void blk_root_inherit_options(int *child_flags, QDict *child_options,
110 int parent_flags, QDict *parent_options)
111{
112 /* We're not supposed to call this function for root nodes */
113 abort();
114}
c2066af0
KW
115static void blk_root_drained_begin(BdrvChild *child);
116static void blk_root_drained_end(BdrvChild *child);
f21d96d0 117
5c8cab48
KW
118static void blk_root_change_media(BdrvChild *child, bool load);
119static void blk_root_resize(BdrvChild *child);
120
b5411555
KW
121static char *blk_root_get_parent_desc(BdrvChild *child)
122{
123 BlockBackend *blk = child->opaque;
124 char *dev_id;
125
126 if (blk->name) {
127 return g_strdup(blk->name);
128 }
129
130 dev_id = blk_get_attached_dev_id(blk);
131 if (*dev_id) {
132 return dev_id;
133 } else {
134 /* TODO Callback into the BB owner for something more detailed */
135 g_free(dev_id);
136 return g_strdup("a block device");
137 }
138}
139
4c265bf9
KW
140static const char *blk_root_get_name(BdrvChild *child)
141{
142 return blk_name(child->opaque);
143}
144
5f7772c4
FZ
145static void blk_vm_state_changed(void *opaque, int running, RunState state)
146{
147 Error *local_err = NULL;
148 BlockBackend *blk = opaque;
149
150 if (state == RUN_STATE_INMIGRATE) {
151 return;
152 }
153
154 qemu_del_vm_change_state_handler(blk->vmsh);
155 blk->vmsh = NULL;
156 blk_set_perm(blk, blk->perm, blk->shared_perm, &local_err);
157 if (local_err) {
158 error_report_err(local_err);
159 }
160}
161
4417ab7a
KW
162/*
163 * Notifies the user of the BlockBackend that migration has completed. qdev
164 * devices can tighten their permissions in response (specifically revoke
165 * shared write permissions that we needed for storage migration).
166 *
167 * If an error is returned, the VM cannot be allowed to be resumed.
168 */
169static void blk_root_activate(BdrvChild *child, Error **errp)
170{
171 BlockBackend *blk = child->opaque;
172 Error *local_err = NULL;
173
174 if (!blk->disable_perm) {
175 return;
176 }
177
178 blk->disable_perm = false;
179
5f7772c4
FZ
180 blk_set_perm(blk, blk->perm, BLK_PERM_ALL, &local_err);
181 if (local_err) {
182 error_propagate(errp, local_err);
183 blk->disable_perm = true;
184 return;
185 }
186
187 if (runstate_check(RUN_STATE_INMIGRATE)) {
188 /* Activation can happen when migration process is still active, for
189 * example when nbd_server_add is called during non-shared storage
190 * migration. Defer the shared_perm update to migration completion. */
191 if (!blk->vmsh) {
192 blk->vmsh = qemu_add_vm_change_state_handler(blk_vm_state_changed,
193 blk);
194 }
195 return;
196 }
197
4417ab7a
KW
198 blk_set_perm(blk, blk->perm, blk->shared_perm, &local_err);
199 if (local_err) {
200 error_propagate(errp, local_err);
201 blk->disable_perm = true;
202 return;
203 }
204}
205
ca2e2144
FZ
206void blk_set_force_allow_inactivate(BlockBackend *blk)
207{
208 blk->force_allow_inactivate = true;
209}
210
c16de8f5
FZ
211static bool blk_can_inactivate(BlockBackend *blk)
212{
ca2e2144 213 /* If it is a guest device, inactivate is ok. */
c16de8f5
FZ
214 if (blk->dev || blk_name(blk)[0]) {
215 return true;
216 }
217
ca2e2144
FZ
218 /* Inactivating means no more writes to the image can be done,
219 * even if those writes would be changes invisible to the
220 * guest. For block job BBs that satisfy this, we can just allow
221 * it. This is the case for mirror job source, which is required
222 * by libvirt non-shared block migration. */
223 if (!(blk->perm & (BLK_PERM_WRITE | BLK_PERM_WRITE_UNCHANGED))) {
224 return true;
225 }
226
227 return blk->force_allow_inactivate;
c16de8f5
FZ
228}
229
cfa1a572
KW
230static int blk_root_inactivate(BdrvChild *child)
231{
232 BlockBackend *blk = child->opaque;
233
234 if (blk->disable_perm) {
235 return 0;
236 }
237
c16de8f5 238 if (!blk_can_inactivate(blk)) {
cfa1a572
KW
239 return -EPERM;
240 }
241
242 blk->disable_perm = true;
243 if (blk->root) {
244 bdrv_child_try_set_perm(blk->root, 0, BLK_PERM_ALL, &error_abort);
245 }
246
247 return 0;
248}
249
f21d96d0 250static const BdrvChildRole child_root = {
c2066af0
KW
251 .inherit_options = blk_root_inherit_options,
252
5c8cab48
KW
253 .change_media = blk_root_change_media,
254 .resize = blk_root_resize,
4c265bf9 255 .get_name = blk_root_get_name,
b5411555 256 .get_parent_desc = blk_root_get_parent_desc,
5c8cab48 257
c2066af0
KW
258 .drained_begin = blk_root_drained_begin,
259 .drained_end = blk_root_drained_end,
4417ab7a
KW
260
261 .activate = blk_root_activate,
cfa1a572 262 .inactivate = blk_root_inactivate,
f21d96d0
KW
263};
264
26f54e9a 265/*
efaa7c4e 266 * Create a new BlockBackend with a reference count of one.
6d0eb64d
KW
267 *
268 * @perm is a bitmasks of BLK_PERM_* constants which describes the permissions
269 * to request for a block driver node that is attached to this BlockBackend.
270 * @shared_perm is a bitmask which describes which permissions may be granted
271 * to other users of the attached node.
272 * Both sets of permissions can be changed later using blk_set_perm().
273 *
26f54e9a
MA
274 * Return the new BlockBackend on success, null on failure.
275 */
6d0eb64d 276BlockBackend *blk_new(uint64_t perm, uint64_t shared_perm)
26f54e9a
MA
277{
278 BlockBackend *blk;
279
26f54e9a 280 blk = g_new0(BlockBackend, 1);
26f54e9a 281 blk->refcnt = 1;
6d0eb64d
KW
282 blk->perm = perm;
283 blk->shared_perm = shared_perm;
0c3169df
KW
284 blk_set_enable_write_cache(blk, true);
285
9caa6f3d 286 block_acct_init(&blk->stats);
27ccdd52 287
3301f6c6
HR
288 notifier_list_init(&blk->remove_bs_notifiers);
289 notifier_list_init(&blk->insert_bs_notifiers);
27ccdd52 290
2cf22d6a 291 QTAILQ_INSERT_TAIL(&block_backends, blk, link);
26f54e9a
MA
292 return blk;
293}
294
7e7d56d9 295/*
28eb9b12 296 * Creates a new BlockBackend, opens a new BlockDriverState, and connects both.
ca49a4fd
HR
297 *
298 * Just as with bdrv_open(), after having called this function the reference to
299 * @options belongs to the block layer (even on failure).
300 *
301 * TODO: Remove @filename and @flags; it should be possible to specify a whole
302 * BDS tree just by specifying the @options QDict (or @reference,
303 * alternatively). At the time of adding this function, this is not possible,
304 * though, so callers of this function have to be able to specify @filename and
305 * @flags.
306 */
efaa7c4e
HR
307BlockBackend *blk_new_open(const char *filename, const char *reference,
308 QDict *options, int flags, Error **errp)
ca49a4fd
HR
309{
310 BlockBackend *blk;
28eb9b12 311 BlockDriverState *bs;
1f4ad7d3 312 uint64_t perm = 0;
c62d32f5
KW
313
314 /* blk_new_open() is mainly used in .bdrv_create implementations and the
315 * tools where sharing isn't a concern because the BDS stays private, so we
316 * just request permission according to the flags.
317 *
318 * The exceptions are xen_disk and blockdev_init(); in these cases, the
319 * caller of blk_new_open() doesn't make use of the permissions, but they
320 * shouldn't hurt either. We can still share everything here because the
321 * guest devices will add their own blockers if they can't share. */
1f4ad7d3
KW
322 if ((flags & BDRV_O_NO_IO) == 0) {
323 perm |= BLK_PERM_CONSISTENT_READ;
324 if (flags & BDRV_O_RDWR) {
325 perm |= BLK_PERM_WRITE;
326 }
c62d32f5
KW
327 }
328 if (flags & BDRV_O_RESIZE) {
329 perm |= BLK_PERM_RESIZE;
330 }
ca49a4fd 331
c62d32f5 332 blk = blk_new(perm, BLK_PERM_ALL);
5b363937
HR
333 bs = bdrv_open(filename, reference, options, flags, errp);
334 if (!bs) {
ca49a4fd
HR
335 blk_unref(blk);
336 return NULL;
337 }
338
d5e6f437 339 blk->root = bdrv_root_attach_child(bs, "root", &child_root,
50bfbe93
FZ
340 perm, BLK_PERM_ALL, blk, errp);
341 if (!blk->root) {
342 bdrv_unref(bs);
343 blk_unref(blk);
344 return NULL;
345 }
72e775c7 346
ca49a4fd
HR
347 return blk;
348}
349
26f54e9a
MA
350static void blk_delete(BlockBackend *blk)
351{
352 assert(!blk->refcnt);
e5e78550 353 assert(!blk->name);
a7f53e26 354 assert(!blk->dev);
022cdc9f 355 if (blk->public.throttle_group_member.throttle_state) {
1606e4cf
EB
356 blk_io_limits_disable(blk);
357 }
f21d96d0 358 if (blk->root) {
13855c6b 359 blk_remove_bs(blk);
7e7d56d9 360 }
5f7772c4
FZ
361 if (blk->vmsh) {
362 qemu_del_vm_change_state_handler(blk->vmsh);
363 blk->vmsh = NULL;
364 }
3301f6c6
HR
365 assert(QLIST_EMPTY(&blk->remove_bs_notifiers.notifiers));
366 assert(QLIST_EMPTY(&blk->insert_bs_notifiers.notifiers));
2cf22d6a 367 QTAILQ_REMOVE(&block_backends, blk, link);
18e46a03 368 drive_info_del(blk->legacy_dinfo);
979e9b03 369 block_acct_cleanup(&blk->stats);
26f54e9a
MA
370 g_free(blk);
371}
372
8fb3c76c
MA
373static void drive_info_del(DriveInfo *dinfo)
374{
375 if (!dinfo) {
376 return;
377 }
378 qemu_opts_del(dinfo->opts);
8fb3c76c
MA
379 g_free(dinfo->serial);
380 g_free(dinfo);
381}
382
f636ae85
AG
383int blk_get_refcnt(BlockBackend *blk)
384{
385 return blk ? blk->refcnt : 0;
386}
387
26f54e9a
MA
388/*
389 * Increment @blk's reference count.
390 * @blk must not be null.
391 */
392void blk_ref(BlockBackend *blk)
393{
394 blk->refcnt++;
395}
396
397/*
398 * Decrement @blk's reference count.
399 * If this drops it to zero, destroy @blk.
400 * For convenience, do nothing if @blk is null.
401 */
402void blk_unref(BlockBackend *blk)
403{
404 if (blk) {
405 assert(blk->refcnt > 0);
406 if (!--blk->refcnt) {
407 blk_delete(blk);
408 }
409 }
410}
411
2cf22d6a
HR
412/*
413 * Behaves similarly to blk_next() but iterates over all BlockBackends, even the
414 * ones which are hidden (i.e. are not referenced by the monitor).
415 */
a429b9b5 416BlockBackend *blk_all_next(BlockBackend *blk)
2cf22d6a
HR
417{
418 return blk ? QTAILQ_NEXT(blk, link)
419 : QTAILQ_FIRST(&block_backends);
420}
421
d8da3cef
HR
422void blk_remove_all_bs(void)
423{
74d1b8fc 424 BlockBackend *blk = NULL;
d8da3cef 425
2cf22d6a 426 while ((blk = blk_all_next(blk)) != NULL) {
d8da3cef
HR
427 AioContext *ctx = blk_get_aio_context(blk);
428
429 aio_context_acquire(ctx);
f21d96d0 430 if (blk->root) {
d8da3cef
HR
431 blk_remove_bs(blk);
432 }
433 aio_context_release(ctx);
434 }
435}
436
26f54e9a 437/*
9492b0b9 438 * Return the monitor-owned BlockBackend after @blk.
26f54e9a
MA
439 * If @blk is null, return the first one.
440 * Else, return @blk's next sibling, which may be null.
441 *
442 * To iterate over all BlockBackends, do
443 * for (blk = blk_next(NULL); blk; blk = blk_next(blk)) {
444 * ...
445 * }
446 */
447BlockBackend *blk_next(BlockBackend *blk)
448{
9492b0b9
HR
449 return blk ? QTAILQ_NEXT(blk, monitor_link)
450 : QTAILQ_FIRST(&monitor_block_backends);
26f54e9a
MA
451}
452
7c8eece4
KW
453/* Iterates over all top-level BlockDriverStates, i.e. BDSs that are owned by
454 * the monitor or attached to a BlockBackend */
88be7b4b 455BlockDriverState *bdrv_next(BdrvNextIterator *it)
7c8eece4 456{
5e003f17
HR
457 BlockDriverState *bs, *old_bs;
458
459 /* Must be called from the main loop */
460 assert(qemu_get_current_aio_context() == qemu_get_aio_context());
981f4f57 461
7c8eece4
KW
462 /* First, return all root nodes of BlockBackends. In order to avoid
463 * returning a BDS twice when multiple BBs refer to it, we only return it
464 * if the BB is the first one in the parent list of the BDS. */
465 if (it->phase == BDRV_NEXT_BACKEND_ROOTS) {
5e003f17
HR
466 BlockBackend *old_blk = it->blk;
467
468 old_bs = old_blk ? blk_bs(old_blk) : NULL;
469
7c8eece4
KW
470 do {
471 it->blk = blk_all_next(it->blk);
88be7b4b
KW
472 bs = it->blk ? blk_bs(it->blk) : NULL;
473 } while (it->blk && (bs == NULL || bdrv_first_blk(bs) != it->blk));
7c8eece4 474
5e003f17
HR
475 if (it->blk) {
476 blk_ref(it->blk);
477 }
478 blk_unref(old_blk);
479
88be7b4b 480 if (bs) {
5e003f17
HR
481 bdrv_ref(bs);
482 bdrv_unref(old_bs);
88be7b4b 483 return bs;
7c8eece4
KW
484 }
485 it->phase = BDRV_NEXT_MONITOR_OWNED;
5e003f17
HR
486 } else {
487 old_bs = it->bs;
7c8eece4
KW
488 }
489
490 /* Then return the monitor-owned BDSes without a BB attached. Ignore all
491 * BDSes that are attached to a BlockBackend here; they have been handled
492 * by the above block already */
981f4f57 493 do {
7c8eece4 494 it->bs = bdrv_next_monitor_owned(it->bs);
88be7b4b
KW
495 bs = it->bs;
496 } while (bs && bdrv_has_blk(bs));
497
5e003f17
HR
498 if (bs) {
499 bdrv_ref(bs);
500 }
501 bdrv_unref(old_bs);
502
88be7b4b
KW
503 return bs;
504}
505
5e003f17 506static void bdrv_next_reset(BdrvNextIterator *it)
88be7b4b
KW
507{
508 *it = (BdrvNextIterator) {
509 .phase = BDRV_NEXT_BACKEND_ROOTS,
510 };
5e003f17 511}
981f4f57 512
5e003f17
HR
513BlockDriverState *bdrv_first(BdrvNextIterator *it)
514{
515 bdrv_next_reset(it);
88be7b4b 516 return bdrv_next(it);
981f4f57
HR
517}
518
5e003f17
HR
519/* Must be called when aborting a bdrv_next() iteration before
520 * bdrv_next() returns NULL */
521void bdrv_next_cleanup(BdrvNextIterator *it)
522{
523 /* Must be called from the main loop */
524 assert(qemu_get_current_aio_context() == qemu_get_aio_context());
525
526 if (it->phase == BDRV_NEXT_BACKEND_ROOTS) {
527 if (it->blk) {
528 bdrv_unref(blk_bs(it->blk));
529 blk_unref(it->blk);
530 }
531 } else {
532 bdrv_unref(it->bs);
533 }
534
535 bdrv_next_reset(it);
536}
537
e5e78550
HR
538/*
539 * Add a BlockBackend into the list of backends referenced by the monitor, with
540 * the given @name acting as the handle for the monitor.
541 * Strictly for use by blockdev.c.
542 *
543 * @name must not be null or empty.
544 *
545 * Returns true on success and false on failure. In the latter case, an Error
546 * object is returned through @errp.
547 */
548bool monitor_add_blk(BlockBackend *blk, const char *name, Error **errp)
549{
550 assert(!blk->name);
551 assert(name && name[0]);
552
553 if (!id_wellformed(name)) {
554 error_setg(errp, "Invalid device name");
555 return false;
556 }
557 if (blk_by_name(name)) {
558 error_setg(errp, "Device with id '%s' already exists", name);
559 return false;
560 }
561 if (bdrv_find_node(name)) {
562 error_setg(errp,
563 "Device name '%s' conflicts with an existing node name",
564 name);
565 return false;
566 }
567
568 blk->name = g_strdup(name);
569 QTAILQ_INSERT_TAIL(&monitor_block_backends, blk, monitor_link);
570 return true;
571}
572
573/*
574 * Remove a BlockBackend from the list of backends referenced by the monitor.
575 * Strictly for use by blockdev.c.
576 */
577void monitor_remove_blk(BlockBackend *blk)
578{
579 if (!blk->name) {
580 return;
581 }
582
583 QTAILQ_REMOVE(&monitor_block_backends, blk, monitor_link);
584 g_free(blk->name);
585 blk->name = NULL;
586}
587
26f54e9a 588/*
7e7d56d9 589 * Return @blk's name, a non-null string.
e5e78550 590 * Returns an empty string iff @blk is not referenced by the monitor.
26f54e9a 591 */
0731a50f 592const char *blk_name(const BlockBackend *blk)
26f54e9a 593{
e5e78550 594 return blk->name ?: "";
26f54e9a
MA
595}
596
597/*
598 * Return the BlockBackend with name @name if it exists, else null.
599 * @name must not be null.
600 */
601BlockBackend *blk_by_name(const char *name)
602{
74d1b8fc 603 BlockBackend *blk = NULL;
26f54e9a
MA
604
605 assert(name);
74d1b8fc 606 while ((blk = blk_next(blk)) != NULL) {
26f54e9a
MA
607 if (!strcmp(name, blk->name)) {
608 return blk;
609 }
610 }
611 return NULL;
612}
7e7d56d9
MA
613
614/*
615 * Return the BlockDriverState attached to @blk if any, else null.
616 */
617BlockDriverState *blk_bs(BlockBackend *blk)
618{
f21d96d0 619 return blk->root ? blk->root->bs : NULL;
7e7d56d9
MA
620}
621
7c8eece4 622static BlockBackend *bdrv_first_blk(BlockDriverState *bs)
dde33812
KW
623{
624 BdrvChild *child;
625 QLIST_FOREACH(child, &bs->parents, next_parent) {
626 if (child->role == &child_root) {
7c8eece4 627 return child->opaque;
dde33812
KW
628 }
629 }
630
7c8eece4
KW
631 return NULL;
632}
633
634/*
635 * Returns true if @bs has an associated BlockBackend.
636 */
637bool bdrv_has_blk(BlockDriverState *bs)
638{
639 return bdrv_first_blk(bs) != NULL;
dde33812
KW
640}
641
b6c1bae5
KW
642/*
643 * Returns true if @bs has only BlockBackends as parents.
644 */
645bool bdrv_is_root_node(BlockDriverState *bs)
646{
647 BdrvChild *c;
648
649 QLIST_FOREACH(c, &bs->parents, next_parent) {
650 if (c->role != &child_root) {
651 return false;
652 }
653 }
654
655 return true;
656}
657
18e46a03
MA
658/*
659 * Return @blk's DriveInfo if any, else null.
660 */
661DriveInfo *blk_legacy_dinfo(BlockBackend *blk)
662{
663 return blk->legacy_dinfo;
664}
665
666/*
667 * Set @blk's DriveInfo to @dinfo, and return it.
668 * @blk must not have a DriveInfo set already.
669 * No other BlockBackend may have the same DriveInfo set.
670 */
671DriveInfo *blk_set_legacy_dinfo(BlockBackend *blk, DriveInfo *dinfo)
672{
673 assert(!blk->legacy_dinfo);
674 return blk->legacy_dinfo = dinfo;
675}
676
677/*
678 * Return the BlockBackend with DriveInfo @dinfo.
679 * It must exist.
680 */
681BlockBackend *blk_by_legacy_dinfo(DriveInfo *dinfo)
682{
74d1b8fc 683 BlockBackend *blk = NULL;
18e46a03 684
74d1b8fc 685 while ((blk = blk_next(blk)) != NULL) {
18e46a03
MA
686 if (blk->legacy_dinfo == dinfo) {
687 return blk;
688 }
689 }
690 abort();
691}
692
f2cd875d
KW
693/*
694 * Returns a pointer to the publicly accessible fields of @blk.
695 */
696BlockBackendPublic *blk_get_public(BlockBackend *blk)
697{
698 return &blk->public;
699}
700
701/*
702 * Returns a BlockBackend given the associated @public fields.
703 */
704BlockBackend *blk_by_public(BlockBackendPublic *public)
705{
706 return container_of(public, BlockBackend, public);
707}
708
1c95f7e1
HR
709/*
710 * Disassociates the currently associated BlockDriverState from @blk.
711 */
712void blk_remove_bs(BlockBackend *blk)
713{
c89bcf3a 714 ThrottleGroupMember *tgm = &blk->public.throttle_group_member;
632a7735 715 BlockDriverState *bs;
022cdc9f 716
3301f6c6 717 notifier_list_notify(&blk->remove_bs_notifiers, blk);
c89bcf3a 718 if (tgm->throttle_state) {
632a7735
ZL
719 bs = blk_bs(blk);
720 bdrv_drained_begin(bs);
c89bcf3a
AG
721 throttle_group_detach_aio_context(tgm);
722 throttle_group_attach_aio_context(tgm, qemu_get_aio_context());
632a7735 723 bdrv_drained_end(bs);
a5614993 724 }
1c95f7e1 725
7ca7f0f6
KW
726 blk_update_root_state(blk);
727
f21d96d0
KW
728 bdrv_root_unref_child(blk->root);
729 blk->root = NULL;
1c95f7e1
HR
730}
731
0c3c36d6
HR
732/*
733 * Associates a new BlockDriverState with @blk.
734 */
d7086422 735int blk_insert_bs(BlockBackend *blk, BlockDriverState *bs, Error **errp)
0c3c36d6 736{
c89bcf3a 737 ThrottleGroupMember *tgm = &blk->public.throttle_group_member;
d5e6f437 738 blk->root = bdrv_root_attach_child(bs, "root", &child_root,
d7086422
KW
739 blk->perm, blk->shared_perm, blk, errp);
740 if (blk->root == NULL) {
741 return -EPERM;
742 }
743 bdrv_ref(bs);
3301f6c6
HR
744
745 notifier_list_notify(&blk->insert_bs_notifiers, blk);
c89bcf3a
AG
746 if (tgm->throttle_state) {
747 throttle_group_detach_aio_context(tgm);
748 throttle_group_attach_aio_context(tgm, bdrv_get_aio_context(bs));
7ca7f0f6 749 }
d7086422
KW
750
751 return 0;
0c3c36d6
HR
752}
753
981776b3
KW
754/*
755 * Sets the permission bitmasks that the user of the BlockBackend needs.
756 */
757int blk_set_perm(BlockBackend *blk, uint64_t perm, uint64_t shared_perm,
758 Error **errp)
759{
760 int ret;
761
d35ff5e6 762 if (blk->root && !blk->disable_perm) {
981776b3
KW
763 ret = bdrv_child_try_set_perm(blk->root, perm, shared_perm, errp);
764 if (ret < 0) {
765 return ret;
766 }
767 }
768
769 blk->perm = perm;
770 blk->shared_perm = shared_perm;
771
772 return 0;
773}
774
887354bd
KW
775void blk_get_perm(BlockBackend *blk, uint64_t *perm, uint64_t *shared_perm)
776{
777 *perm = blk->perm;
778 *shared_perm = blk->shared_perm;
779}
780
bbc8ea98 781static int blk_do_attach_dev(BlockBackend *blk, void *dev)
4be74634 782{
a7f53e26
MA
783 if (blk->dev) {
784 return -EBUSY;
785 }
d35ff5e6
KW
786
787 /* While migration is still incoming, we don't need to apply the
788 * permissions of guest device BlockBackends. We might still have a block
789 * job or NBD server writing to the image for storage migration. */
790 if (runstate_check(RUN_STATE_INMIGRATE)) {
791 blk->disable_perm = true;
792 }
793
84ebe375 794 blk_ref(blk);
a7f53e26 795 blk->dev = dev;
bbc8ea98 796 blk->legacy_dev = false;
373340b2 797 blk_iostatus_reset(blk);
d35ff5e6 798
a7f53e26 799 return 0;
4be74634
MA
800}
801
bbc8ea98
KW
802/*
803 * Attach device model @dev to @blk.
804 * Return 0 on success, -EBUSY when a device model is attached already.
805 */
806int blk_attach_dev(BlockBackend *blk, DeviceState *dev)
807{
808 return blk_do_attach_dev(blk, dev);
809}
810
a7f53e26
MA
811/*
812 * Attach device model @dev to @blk.
813 * @blk must not have a device model attached already.
814 * TODO qdevified devices don't use this, remove when devices are qdevified
815 */
bbc8ea98 816void blk_attach_dev_legacy(BlockBackend *blk, void *dev)
4be74634 817{
bbc8ea98 818 if (blk_do_attach_dev(blk, dev) < 0) {
a7f53e26
MA
819 abort();
820 }
bbc8ea98 821 blk->legacy_dev = true;
4be74634
MA
822}
823
a7f53e26
MA
824/*
825 * Detach device model @dev from @blk.
826 * @dev must be currently attached to @blk.
827 */
4be74634 828void blk_detach_dev(BlockBackend *blk, void *dev)
a7f53e26 829/* TODO change to DeviceState *dev when all users are qdevified */
4be74634 830{
a7f53e26
MA
831 assert(blk->dev == dev);
832 blk->dev = NULL;
833 blk->dev_ops = NULL;
834 blk->dev_opaque = NULL;
68e9ec01 835 blk->guest_block_size = 512;
981776b3 836 blk_set_perm(blk, 0, BLK_PERM_ALL, &error_abort);
84ebe375 837 blk_unref(blk);
4be74634
MA
838}
839
a7f53e26
MA
840/*
841 * Return the device model attached to @blk if any, else null.
842 */
4be74634 843void *blk_get_attached_dev(BlockBackend *blk)
a7f53e26
MA
844/* TODO change to return DeviceState * when all users are qdevified */
845{
846 return blk->dev;
847}
848
2d76e724
KW
849/* Return the qdev ID, or if no ID is assigned the QOM path, of the block
850 * device attached to the BlockBackend. */
77beef83 851char *blk_get_attached_dev_id(BlockBackend *blk)
2d76e724
KW
852{
853 DeviceState *dev;
854
855 assert(!blk->legacy_dev);
856 dev = blk->dev;
857
858 if (!dev) {
859 return g_strdup("");
860 } else if (dev->id) {
861 return g_strdup(dev->id);
862 }
863 return object_get_canonical_path(OBJECT(dev));
864}
865
1c89e1fa
KW
866/*
867 * Return the BlockBackend which has the device model @dev attached if it
868 * exists, else null.
869 *
870 * @dev must not be null.
871 */
872BlockBackend *blk_by_dev(void *dev)
873{
874 BlockBackend *blk = NULL;
875
876 assert(dev != NULL);
877 while ((blk = blk_all_next(blk)) != NULL) {
878 if (blk->dev == dev) {
879 return blk;
880 }
881 }
882 return NULL;
883}
884
a7f53e26
MA
885/*
886 * Set @blk's device model callbacks to @ops.
887 * @opaque is the opaque argument to pass to the callbacks.
888 * This is for use by device models.
889 */
890void blk_set_dev_ops(BlockBackend *blk, const BlockDevOps *ops,
891 void *opaque)
892{
bbc8ea98 893 /* All drivers that use blk_set_dev_ops() are qdevified and we want to keep
f4d9cc88
JS
894 * it that way, so we can assume blk->dev, if present, is a DeviceState if
895 * blk->dev_ops is set. Non-device users may use dev_ops without device. */
bbc8ea98
KW
896 assert(!blk->legacy_dev);
897
a7f53e26
MA
898 blk->dev_ops = ops;
899 blk->dev_opaque = opaque;
f4d9cc88
JS
900
901 /* Are we currently quiesced? Should we enforce this right now? */
902 if (blk->quiesce_counter && ops->drained_begin) {
903 ops->drained_begin(opaque);
904 }
a7f53e26
MA
905}
906
907/*
908 * Notify @blk's attached device model of media change.
39829a01
KW
909 *
910 * If @load is true, notify of media load. This action can fail, meaning that
911 * the medium cannot be loaded. @errp is set then.
912 *
913 * If @load is false, notify of media eject. This can never fail.
914 *
a7f53e26
MA
915 * Also send DEVICE_TRAY_MOVED events as appropriate.
916 */
39829a01 917void blk_dev_change_media_cb(BlockBackend *blk, bool load, Error **errp)
a7f53e26
MA
918{
919 if (blk->dev_ops && blk->dev_ops->change_media_cb) {
f1f57066 920 bool tray_was_open, tray_is_open;
39829a01 921 Error *local_err = NULL;
a7f53e26 922
2d76e724
KW
923 assert(!blk->legacy_dev);
924
f1f57066 925 tray_was_open = blk_dev_is_tray_open(blk);
39829a01
KW
926 blk->dev_ops->change_media_cb(blk->dev_opaque, load, &local_err);
927 if (local_err) {
928 assert(load == true);
929 error_propagate(errp, local_err);
930 return;
931 }
f1f57066
HR
932 tray_is_open = blk_dev_is_tray_open(blk);
933
934 if (tray_was_open != tray_is_open) {
2d76e724
KW
935 char *id = blk_get_attached_dev_id(blk);
936 qapi_event_send_device_tray_moved(blk_name(blk), id, tray_is_open,
f1f57066 937 &error_abort);
2d76e724 938 g_free(id);
a7f53e26
MA
939 }
940 }
941}
942
5c8cab48
KW
943static void blk_root_change_media(BdrvChild *child, bool load)
944{
39829a01 945 blk_dev_change_media_cb(child->opaque, load, NULL);
5c8cab48
KW
946}
947
a7f53e26
MA
948/*
949 * Does @blk's attached device model have removable media?
950 * %true if no device model is attached.
951 */
952bool blk_dev_has_removable_media(BlockBackend *blk)
953{
954 return !blk->dev || (blk->dev_ops && blk->dev_ops->change_media_cb);
955}
956
8f3a73bc
HR
957/*
958 * Does @blk's attached device model have a tray?
959 */
960bool blk_dev_has_tray(BlockBackend *blk)
961{
962 return blk->dev_ops && blk->dev_ops->is_tray_open;
963}
964
a7f53e26
MA
965/*
966 * Notify @blk's attached device model of a media eject request.
967 * If @force is true, the medium is about to be yanked out forcefully.
968 */
969void blk_dev_eject_request(BlockBackend *blk, bool force)
4be74634 970{
a7f53e26
MA
971 if (blk->dev_ops && blk->dev_ops->eject_request_cb) {
972 blk->dev_ops->eject_request_cb(blk->dev_opaque, force);
973 }
4be74634
MA
974}
975
a7f53e26
MA
976/*
977 * Does @blk's attached device model have a tray, and is it open?
978 */
979bool blk_dev_is_tray_open(BlockBackend *blk)
4be74634 980{
8f3a73bc 981 if (blk_dev_has_tray(blk)) {
a7f53e26
MA
982 return blk->dev_ops->is_tray_open(blk->dev_opaque);
983 }
984 return false;
985}
986
987/*
988 * Does @blk's attached device model have the medium locked?
989 * %false if the device model has no such lock.
990 */
991bool blk_dev_is_medium_locked(BlockBackend *blk)
992{
993 if (blk->dev_ops && blk->dev_ops->is_medium_locked) {
994 return blk->dev_ops->is_medium_locked(blk->dev_opaque);
995 }
996 return false;
997}
998
999/*
1000 * Notify @blk's attached device model of a backend size change.
1001 */
5c8cab48 1002static void blk_root_resize(BdrvChild *child)
a7f53e26 1003{
5c8cab48
KW
1004 BlockBackend *blk = child->opaque;
1005
a7f53e26
MA
1006 if (blk->dev_ops && blk->dev_ops->resize_cb) {
1007 blk->dev_ops->resize_cb(blk->dev_opaque);
1008 }
1009}
1010
1011void blk_iostatus_enable(BlockBackend *blk)
1012{
373340b2
HR
1013 blk->iostatus_enabled = true;
1014 blk->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
1015}
1016
1017/* The I/O status is only enabled if the drive explicitly
1018 * enables it _and_ the VM is configured to stop on errors */
1019bool blk_iostatus_is_enabled(const BlockBackend *blk)
1020{
1021 return (blk->iostatus_enabled &&
1022 (blk->on_write_error == BLOCKDEV_ON_ERROR_ENOSPC ||
1023 blk->on_write_error == BLOCKDEV_ON_ERROR_STOP ||
1024 blk->on_read_error == BLOCKDEV_ON_ERROR_STOP));
1025}
1026
1027BlockDeviceIoStatus blk_iostatus(const BlockBackend *blk)
1028{
1029 return blk->iostatus;
1030}
1031
1032void blk_iostatus_disable(BlockBackend *blk)
1033{
1034 blk->iostatus_enabled = false;
1035}
1036
1037void blk_iostatus_reset(BlockBackend *blk)
1038{
1039 if (blk_iostatus_is_enabled(blk)) {
f21d96d0 1040 BlockDriverState *bs = blk_bs(blk);
373340b2 1041 blk->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
f21d96d0
KW
1042 if (bs && bs->job) {
1043 block_job_iostatus_reset(bs->job);
373340b2
HR
1044 }
1045 }
1046}
1047
1048void blk_iostatus_set_err(BlockBackend *blk, int error)
1049{
1050 assert(blk_iostatus_is_enabled(blk));
1051 if (blk->iostatus == BLOCK_DEVICE_IO_STATUS_OK) {
1052 blk->iostatus = error == ENOSPC ? BLOCK_DEVICE_IO_STATUS_NOSPACE :
1053 BLOCK_DEVICE_IO_STATUS_FAILED;
1054 }
4be74634
MA
1055}
1056
c10c9d96
KW
1057void blk_set_allow_write_beyond_eof(BlockBackend *blk, bool allow)
1058{
1059 blk->allow_write_beyond_eof = allow;
1060}
1061
e7f7d676
HR
1062static int blk_check_byte_request(BlockBackend *blk, int64_t offset,
1063 size_t size)
1064{
1065 int64_t len;
1066
1067 if (size > INT_MAX) {
1068 return -EIO;
1069 }
1070
c09ba36c 1071 if (!blk_is_available(blk)) {
e7f7d676
HR
1072 return -ENOMEDIUM;
1073 }
1074
e7f7d676
HR
1075 if (offset < 0) {
1076 return -EIO;
1077 }
1078
c10c9d96
KW
1079 if (!blk->allow_write_beyond_eof) {
1080 len = blk_getlength(blk);
1081 if (len < 0) {
1082 return len;
1083 }
1084
1085 if (offset > len || len - offset < size) {
1086 return -EIO;
1087 }
e7f7d676
HR
1088 }
1089
1090 return 0;
1091}
1092
1e98fefd
KW
1093int coroutine_fn blk_co_preadv(BlockBackend *blk, int64_t offset,
1094 unsigned int bytes, QEMUIOVector *qiov,
1095 BdrvRequestFlags flags)
4be74634 1096{
1e98fefd 1097 int ret;
99723548 1098 BlockDriverState *bs = blk_bs(blk);
1e98fefd 1099
99723548 1100 trace_blk_co_preadv(blk, bs, offset, bytes, flags);
1e98fefd
KW
1101
1102 ret = blk_check_byte_request(blk, offset, bytes);
e7f7d676
HR
1103 if (ret < 0) {
1104 return ret;
1105 }
1106
99723548
PB
1107 bdrv_inc_in_flight(bs);
1108
441565b2 1109 /* throttling disk I/O */
022cdc9f
MP
1110 if (blk->public.throttle_group_member.throttle_state) {
1111 throttle_group_co_io_limits_intercept(&blk->public.throttle_group_member,
1112 bytes, false);
441565b2
KW
1113 }
1114
99723548
PB
1115 ret = bdrv_co_preadv(blk->root, offset, bytes, qiov, flags);
1116 bdrv_dec_in_flight(bs);
1117 return ret;
1bf1cbc9
KW
1118}
1119
1e98fefd
KW
1120int coroutine_fn blk_co_pwritev(BlockBackend *blk, int64_t offset,
1121 unsigned int bytes, QEMUIOVector *qiov,
1122 BdrvRequestFlags flags)
a8823a3b 1123{
bfd18d1e 1124 int ret;
99723548 1125 BlockDriverState *bs = blk_bs(blk);
bfd18d1e 1126
99723548 1127 trace_blk_co_pwritev(blk, bs, offset, bytes, flags);
1e98fefd 1128
bfd18d1e 1129 ret = blk_check_byte_request(blk, offset, bytes);
a8823a3b
KW
1130 if (ret < 0) {
1131 return ret;
1132 }
1133
99723548 1134 bdrv_inc_in_flight(bs);
441565b2 1135 /* throttling disk I/O */
022cdc9f
MP
1136 if (blk->public.throttle_group_member.throttle_state) {
1137 throttle_group_co_io_limits_intercept(&blk->public.throttle_group_member,
1138 bytes, true);
441565b2
KW
1139 }
1140
bfd18d1e
KW
1141 if (!blk->enable_write_cache) {
1142 flags |= BDRV_REQ_FUA;
1143 }
1144
99723548
PB
1145 ret = bdrv_co_pwritev(blk->root, offset, bytes, qiov, flags);
1146 bdrv_dec_in_flight(bs);
1147 return ret;
a8823a3b
KW
1148}
1149
1bf1cbc9
KW
1150typedef struct BlkRwCo {
1151 BlockBackend *blk;
1152 int64_t offset;
1153 QEMUIOVector *qiov;
1154 int ret;
1155 BdrvRequestFlags flags;
1156} BlkRwCo;
1157
1158static void blk_read_entry(void *opaque)
1159{
1160 BlkRwCo *rwco = opaque;
1161
1162 rwco->ret = blk_co_preadv(rwco->blk, rwco->offset, rwco->qiov->size,
1163 rwco->qiov, rwco->flags);
1164}
1165
a8823a3b
KW
1166static void blk_write_entry(void *opaque)
1167{
1168 BlkRwCo *rwco = opaque;
1169
1170 rwco->ret = blk_co_pwritev(rwco->blk, rwco->offset, rwco->qiov->size,
1171 rwco->qiov, rwco->flags);
1172}
1173
a55d3fba
KW
1174static int blk_prw(BlockBackend *blk, int64_t offset, uint8_t *buf,
1175 int64_t bytes, CoroutineEntry co_entry,
1176 BdrvRequestFlags flags)
1bf1cbc9 1177{
1bf1cbc9
KW
1178 QEMUIOVector qiov;
1179 struct iovec iov;
1bf1cbc9
KW
1180 BlkRwCo rwco;
1181
1bf1cbc9
KW
1182 iov = (struct iovec) {
1183 .iov_base = buf,
a55d3fba 1184 .iov_len = bytes,
1bf1cbc9
KW
1185 };
1186 qemu_iovec_init_external(&qiov, &iov, 1);
1187
1188 rwco = (BlkRwCo) {
1189 .blk = blk,
a55d3fba 1190 .offset = offset,
1bf1cbc9 1191 .qiov = &qiov,
fc1453cd 1192 .flags = flags,
1bf1cbc9
KW
1193 .ret = NOT_DONE,
1194 };
1195
35f106e6
PB
1196 if (qemu_in_coroutine()) {
1197 /* Fast-path if already in coroutine context */
1198 co_entry(&rwco);
1199 } else {
1200 Coroutine *co = qemu_coroutine_create(co_entry, &rwco);
e92f0e19 1201 bdrv_coroutine_enter(blk_bs(blk), co);
35f106e6
PB
1202 BDRV_POLL_WHILE(blk_bs(blk), rwco.ret == NOT_DONE);
1203 }
1bf1cbc9
KW
1204
1205 return rwco.ret;
4be74634
MA
1206}
1207
b7d17f9f
EB
1208int blk_pread_unthrottled(BlockBackend *blk, int64_t offset, uint8_t *buf,
1209 int count)
4be74634 1210{
5bd51196
KW
1211 int ret;
1212
b7d17f9f 1213 ret = blk_check_byte_request(blk, offset, count);
e7f7d676
HR
1214 if (ret < 0) {
1215 return ret;
1216 }
1217
c2066af0 1218 blk_root_drained_begin(blk->root);
b7d17f9f 1219 ret = blk_pread(blk, offset, buf, count);
c2066af0 1220 blk_root_drained_end(blk->root);
5bd51196 1221 return ret;
4be74634
MA
1222}
1223
d004bd52 1224int blk_pwrite_zeroes(BlockBackend *blk, int64_t offset,
f5a5ca79 1225 int bytes, BdrvRequestFlags flags)
0df89e8e 1226{
f5a5ca79 1227 return blk_prw(blk, offset, NULL, bytes, blk_write_entry,
983a1600 1228 flags | BDRV_REQ_ZERO_WRITE);
0df89e8e
KW
1229}
1230
720ff280
KW
1231int blk_make_zero(BlockBackend *blk, BdrvRequestFlags flags)
1232{
1233 return bdrv_make_zero(blk->root, flags);
1234}
1235
33f2a757
SH
1236static void blk_inc_in_flight(BlockBackend *blk)
1237{
1238 atomic_inc(&blk->in_flight);
1239}
1240
1241static void blk_dec_in_flight(BlockBackend *blk)
1242{
1243 atomic_dec(&blk->in_flight);
1244 aio_wait_kick(&blk->wait);
1245}
1246
e7f7d676
HR
1247static void error_callback_bh(void *opaque)
1248{
1249 struct BlockBackendAIOCB *acb = opaque;
99723548 1250
33f2a757 1251 blk_dec_in_flight(acb->blk);
e7f7d676
HR
1252 acb->common.cb(acb->common.opaque, acb->ret);
1253 qemu_aio_unref(acb);
1254}
1255
ca78ecfa
PL
1256BlockAIOCB *blk_abort_aio_request(BlockBackend *blk,
1257 BlockCompletionFunc *cb,
1258 void *opaque, int ret)
e7f7d676
HR
1259{
1260 struct BlockBackendAIOCB *acb;
e7f7d676 1261
33f2a757 1262 blk_inc_in_flight(blk);
e7f7d676 1263 acb = blk_aio_get(&block_backend_aiocb_info, blk, cb, opaque);
4981bdec 1264 acb->blk = blk;
e7f7d676
HR
1265 acb->ret = ret;
1266
fffb6e12 1267 aio_bh_schedule_oneshot(blk_get_aio_context(blk), error_callback_bh, acb);
e7f7d676
HR
1268 return &acb->common;
1269}
1270
57d6a428
KW
1271typedef struct BlkAioEmAIOCB {
1272 BlockAIOCB common;
1273 BlkRwCo rwco;
7fa84cd8 1274 int bytes;
57d6a428 1275 bool has_returned;
57d6a428
KW
1276} BlkAioEmAIOCB;
1277
1278static const AIOCBInfo blk_aio_em_aiocb_info = {
1279 .aiocb_size = sizeof(BlkAioEmAIOCB),
1280};
1281
1282static void blk_aio_complete(BlkAioEmAIOCB *acb)
1283{
57d6a428 1284 if (acb->has_returned) {
33f2a757 1285 blk_dec_in_flight(acb->rwco.blk);
57d6a428
KW
1286 acb->common.cb(acb->common.opaque, acb->rwco.ret);
1287 qemu_aio_unref(acb);
1288 }
1289}
1290
1291static void blk_aio_complete_bh(void *opaque)
1292{
fffb6e12 1293 BlkAioEmAIOCB *acb = opaque;
fffb6e12
PB
1294 assert(acb->has_returned);
1295 blk_aio_complete(acb);
57d6a428
KW
1296}
1297
7fa84cd8 1298static BlockAIOCB *blk_aio_prwv(BlockBackend *blk, int64_t offset, int bytes,
57d6a428
KW
1299 QEMUIOVector *qiov, CoroutineEntry co_entry,
1300 BdrvRequestFlags flags,
1301 BlockCompletionFunc *cb, void *opaque)
1302{
1303 BlkAioEmAIOCB *acb;
1304 Coroutine *co;
1305
33f2a757 1306 blk_inc_in_flight(blk);
57d6a428
KW
1307 acb = blk_aio_get(&blk_aio_em_aiocb_info, blk, cb, opaque);
1308 acb->rwco = (BlkRwCo) {
1309 .blk = blk,
1310 .offset = offset,
1311 .qiov = qiov,
1312 .flags = flags,
1313 .ret = NOT_DONE,
1314 };
7fa84cd8 1315 acb->bytes = bytes;
57d6a428
KW
1316 acb->has_returned = false;
1317
0b8b8753 1318 co = qemu_coroutine_create(co_entry, acb);
e92f0e19 1319 bdrv_coroutine_enter(blk_bs(blk), co);
57d6a428
KW
1320
1321 acb->has_returned = true;
1322 if (acb->rwco.ret != NOT_DONE) {
fffb6e12
PB
1323 aio_bh_schedule_oneshot(blk_get_aio_context(blk),
1324 blk_aio_complete_bh, acb);
57d6a428
KW
1325 }
1326
1327 return &acb->common;
1328}
1329
1330static void blk_aio_read_entry(void *opaque)
1331{
1332 BlkAioEmAIOCB *acb = opaque;
1333 BlkRwCo *rwco = &acb->rwco;
1334
7fa84cd8
KW
1335 assert(rwco->qiov->size == acb->bytes);
1336 rwco->ret = blk_co_preadv(rwco->blk, rwco->offset, acb->bytes,
57d6a428
KW
1337 rwco->qiov, rwco->flags);
1338 blk_aio_complete(acb);
1339}
1340
1341static void blk_aio_write_entry(void *opaque)
1342{
1343 BlkAioEmAIOCB *acb = opaque;
1344 BlkRwCo *rwco = &acb->rwco;
1345
7fa84cd8
KW
1346 assert(!rwco->qiov || rwco->qiov->size == acb->bytes);
1347 rwco->ret = blk_co_pwritev(rwco->blk, rwco->offset, acb->bytes,
57d6a428
KW
1348 rwco->qiov, rwco->flags);
1349 blk_aio_complete(acb);
1350}
1351
d004bd52
EB
1352BlockAIOCB *blk_aio_pwrite_zeroes(BlockBackend *blk, int64_t offset,
1353 int count, BdrvRequestFlags flags,
1354 BlockCompletionFunc *cb, void *opaque)
4be74634 1355{
983a1600
EB
1356 return blk_aio_prwv(blk, offset, count, NULL, blk_aio_write_entry,
1357 flags | BDRV_REQ_ZERO_WRITE, cb, opaque);
4be74634
MA
1358}
1359
1360int blk_pread(BlockBackend *blk, int64_t offset, void *buf, int count)
1361{
a55d3fba 1362 int ret = blk_prw(blk, offset, buf, count, blk_read_entry, 0);
e7f7d676
HR
1363 if (ret < 0) {
1364 return ret;
1365 }
a55d3fba 1366 return count;
4be74634
MA
1367}
1368
8341f00d
EB
1369int blk_pwrite(BlockBackend *blk, int64_t offset, const void *buf, int count,
1370 BdrvRequestFlags flags)
4be74634 1371{
8341f00d
EB
1372 int ret = blk_prw(blk, offset, (void *) buf, count, blk_write_entry,
1373 flags);
e7f7d676
HR
1374 if (ret < 0) {
1375 return ret;
1376 }
a55d3fba 1377 return count;
4be74634
MA
1378}
1379
1380int64_t blk_getlength(BlockBackend *blk)
1381{
c09ba36c
HR
1382 if (!blk_is_available(blk)) {
1383 return -ENOMEDIUM;
1384 }
1385
f21d96d0 1386 return bdrv_getlength(blk_bs(blk));
4be74634
MA
1387}
1388
1389void blk_get_geometry(BlockBackend *blk, uint64_t *nb_sectors_ptr)
1390{
f21d96d0 1391 if (!blk_bs(blk)) {
a46fc9c9
HR
1392 *nb_sectors_ptr = 0;
1393 } else {
f21d96d0 1394 bdrv_get_geometry(blk_bs(blk), nb_sectors_ptr);
a46fc9c9 1395 }
4be74634
MA
1396}
1397
1ef01253
HR
1398int64_t blk_nb_sectors(BlockBackend *blk)
1399{
c09ba36c
HR
1400 if (!blk_is_available(blk)) {
1401 return -ENOMEDIUM;
1402 }
1403
f21d96d0 1404 return bdrv_nb_sectors(blk_bs(blk));
1ef01253
HR
1405}
1406
60cb2fa7
EB
1407BlockAIOCB *blk_aio_preadv(BlockBackend *blk, int64_t offset,
1408 QEMUIOVector *qiov, BdrvRequestFlags flags,
1409 BlockCompletionFunc *cb, void *opaque)
1410{
1411 return blk_aio_prwv(blk, offset, qiov->size, qiov,
1412 blk_aio_read_entry, flags, cb, opaque);
1413}
1414
60cb2fa7
EB
1415BlockAIOCB *blk_aio_pwritev(BlockBackend *blk, int64_t offset,
1416 QEMUIOVector *qiov, BdrvRequestFlags flags,
1417 BlockCompletionFunc *cb, void *opaque)
1418{
1419 return blk_aio_prwv(blk, offset, qiov->size, qiov,
1420 blk_aio_write_entry, flags, cb, opaque);
1421}
1422
be07a889
KW
1423static void blk_aio_flush_entry(void *opaque)
1424{
1425 BlkAioEmAIOCB *acb = opaque;
1426 BlkRwCo *rwco = &acb->rwco;
1427
1428 rwco->ret = blk_co_flush(rwco->blk);
1429 blk_aio_complete(acb);
1430}
1431
4be74634
MA
1432BlockAIOCB *blk_aio_flush(BlockBackend *blk,
1433 BlockCompletionFunc *cb, void *opaque)
1434{
be07a889 1435 return blk_aio_prwv(blk, 0, 0, NULL, blk_aio_flush_entry, 0, cb, opaque);
4be74634
MA
1436}
1437
8c2e3dd5
KW
1438static void blk_aio_pdiscard_entry(void *opaque)
1439{
1440 BlkAioEmAIOCB *acb = opaque;
1441 BlkRwCo *rwco = &acb->rwco;
1442
1443 rwco->ret = blk_co_pdiscard(rwco->blk, rwco->offset, acb->bytes);
1444 blk_aio_complete(acb);
1445}
1446
1c6c4bb7 1447BlockAIOCB *blk_aio_pdiscard(BlockBackend *blk,
f5a5ca79 1448 int64_t offset, int bytes,
1c6c4bb7 1449 BlockCompletionFunc *cb, void *opaque)
4be74634 1450{
f5a5ca79 1451 return blk_aio_prwv(blk, offset, bytes, NULL, blk_aio_pdiscard_entry, 0,
8c2e3dd5 1452 cb, opaque);
4be74634
MA
1453}
1454
1455void blk_aio_cancel(BlockAIOCB *acb)
1456{
1457 bdrv_aio_cancel(acb);
1458}
1459
1460void blk_aio_cancel_async(BlockAIOCB *acb)
1461{
1462 bdrv_aio_cancel_async(acb);
1463}
1464
48af776a 1465int blk_co_ioctl(BlockBackend *blk, unsigned long int req, void *buf)
4be74634 1466{
c09ba36c
HR
1467 if (!blk_is_available(blk)) {
1468 return -ENOMEDIUM;
1469 }
1470
48af776a
KW
1471 return bdrv_co_ioctl(blk_bs(blk), req, buf);
1472}
1473
1474static void blk_ioctl_entry(void *opaque)
1475{
1476 BlkRwCo *rwco = opaque;
1477 rwco->ret = blk_co_ioctl(rwco->blk, rwco->offset,
1478 rwco->qiov->iov[0].iov_base);
1479}
1480
1481int blk_ioctl(BlockBackend *blk, unsigned long int req, void *buf)
1482{
1483 return blk_prw(blk, req, buf, 0, blk_ioctl_entry, 0);
1484}
1485
1486static void blk_aio_ioctl_entry(void *opaque)
1487{
1488 BlkAioEmAIOCB *acb = opaque;
1489 BlkRwCo *rwco = &acb->rwco;
1490
1491 rwco->ret = blk_co_ioctl(rwco->blk, rwco->offset,
1492 rwco->qiov->iov[0].iov_base);
1493 blk_aio_complete(acb);
4be74634
MA
1494}
1495
1496BlockAIOCB *blk_aio_ioctl(BlockBackend *blk, unsigned long int req, void *buf,
1497 BlockCompletionFunc *cb, void *opaque)
1498{
48af776a
KW
1499 QEMUIOVector qiov;
1500 struct iovec iov;
1501
1502 iov = (struct iovec) {
1503 .iov_base = buf,
1504 .iov_len = 0,
1505 };
1506 qemu_iovec_init_external(&qiov, &iov, 1);
c09ba36c 1507
48af776a 1508 return blk_aio_prwv(blk, req, 0, &qiov, blk_aio_ioctl_entry, 0, cb, opaque);
4be74634
MA
1509}
1510
f5a5ca79 1511int blk_co_pdiscard(BlockBackend *blk, int64_t offset, int bytes)
2bb0dce7 1512{
f5a5ca79 1513 int ret = blk_check_byte_request(blk, offset, bytes);
e7f7d676
HR
1514 if (ret < 0) {
1515 return ret;
1516 }
1517
f5a5ca79 1518 return bdrv_co_pdiscard(blk_bs(blk), offset, bytes);
2bb0dce7
HR
1519}
1520
1521int blk_co_flush(BlockBackend *blk)
1522{
c09ba36c
HR
1523 if (!blk_is_available(blk)) {
1524 return -ENOMEDIUM;
1525 }
1526
f21d96d0 1527 return bdrv_co_flush(blk_bs(blk));
2bb0dce7
HR
1528}
1529
be07a889 1530static void blk_flush_entry(void *opaque)
4be74634 1531{
be07a889
KW
1532 BlkRwCo *rwco = opaque;
1533 rwco->ret = blk_co_flush(rwco->blk);
1534}
c09ba36c 1535
be07a889
KW
1536int blk_flush(BlockBackend *blk)
1537{
1538 return blk_prw(blk, 0, NULL, 0, blk_flush_entry, 0);
4be74634
MA
1539}
1540
97b0385a
AY
1541void blk_drain(BlockBackend *blk)
1542{
33f2a757
SH
1543 BlockDriverState *bs = blk_bs(blk);
1544
1545 if (bs) {
1546 bdrv_drained_begin(bs);
1547 }
1548
1549 /* We may have -ENOMEDIUM completions in flight */
1550 AIO_WAIT_WHILE(&blk->wait,
1551 blk_get_aio_context(blk),
1552 atomic_mb_read(&blk->in_flight) > 0);
1553
1554 if (bs) {
1555 bdrv_drained_end(bs);
a46fc9c9 1556 }
97b0385a
AY
1557}
1558
4be74634
MA
1559void blk_drain_all(void)
1560{
33f2a757
SH
1561 BlockBackend *blk = NULL;
1562
1563 bdrv_drain_all_begin();
1564
1565 while ((blk = blk_all_next(blk)) != NULL) {
1566 AioContext *ctx = blk_get_aio_context(blk);
1567
1568 aio_context_acquire(ctx);
1569
1570 /* We may have -ENOMEDIUM completions in flight */
1571 AIO_WAIT_WHILE(&blk->wait, ctx,
1572 atomic_mb_read(&blk->in_flight) > 0);
1573
1574 aio_context_release(ctx);
1575 }
1576
1577 bdrv_drain_all_end();
4be74634
MA
1578}
1579
373340b2
HR
1580void blk_set_on_error(BlockBackend *blk, BlockdevOnError on_read_error,
1581 BlockdevOnError on_write_error)
1582{
1583 blk->on_read_error = on_read_error;
1584 blk->on_write_error = on_write_error;
1585}
1586
4be74634
MA
1587BlockdevOnError blk_get_on_error(BlockBackend *blk, bool is_read)
1588{
373340b2 1589 return is_read ? blk->on_read_error : blk->on_write_error;
4be74634
MA
1590}
1591
1592BlockErrorAction blk_get_error_action(BlockBackend *blk, bool is_read,
1593 int error)
1594{
373340b2
HR
1595 BlockdevOnError on_err = blk_get_on_error(blk, is_read);
1596
1597 switch (on_err) {
1598 case BLOCKDEV_ON_ERROR_ENOSPC:
1599 return (error == ENOSPC) ?
1600 BLOCK_ERROR_ACTION_STOP : BLOCK_ERROR_ACTION_REPORT;
1601 case BLOCKDEV_ON_ERROR_STOP:
1602 return BLOCK_ERROR_ACTION_STOP;
1603 case BLOCKDEV_ON_ERROR_REPORT:
1604 return BLOCK_ERROR_ACTION_REPORT;
1605 case BLOCKDEV_ON_ERROR_IGNORE:
1606 return BLOCK_ERROR_ACTION_IGNORE;
8c398252 1607 case BLOCKDEV_ON_ERROR_AUTO:
373340b2
HR
1608 default:
1609 abort();
1610 }
4be74634
MA
1611}
1612
373340b2
HR
1613static void send_qmp_error_event(BlockBackend *blk,
1614 BlockErrorAction action,
1615 bool is_read, int error)
1616{
1617 IoOperationType optype;
1618
1619 optype = is_read ? IO_OPERATION_TYPE_READ : IO_OPERATION_TYPE_WRITE;
2bf7e10f
KW
1620 qapi_event_send_block_io_error(blk_name(blk),
1621 bdrv_get_node_name(blk_bs(blk)), optype,
1622 action, blk_iostatus_is_enabled(blk),
373340b2
HR
1623 error == ENOSPC, strerror(error),
1624 &error_abort);
1625}
1626
1627/* This is done by device models because, while the block layer knows
1628 * about the error, it does not know whether an operation comes from
1629 * the device or the block layer (from a job, for example).
1630 */
4be74634
MA
1631void blk_error_action(BlockBackend *blk, BlockErrorAction action,
1632 bool is_read, int error)
1633{
373340b2
HR
1634 assert(error >= 0);
1635
1636 if (action == BLOCK_ERROR_ACTION_STOP) {
1637 /* First set the iostatus, so that "info block" returns an iostatus
1638 * that matches the events raised so far (an additional error iostatus
1639 * is fine, but not a lost one).
1640 */
1641 blk_iostatus_set_err(blk, error);
1642
1643 /* Then raise the request to stop the VM and the event.
1644 * qemu_system_vmstop_request_prepare has two effects. First,
1645 * it ensures that the STOP event always comes after the
1646 * BLOCK_IO_ERROR event. Second, it ensures that even if management
1647 * can observe the STOP event and do a "cont" before the STOP
1648 * event is issued, the VM will not stop. In this case, vm_start()
1649 * also ensures that the STOP/RESUME pair of events is emitted.
1650 */
1651 qemu_system_vmstop_request_prepare();
1652 send_qmp_error_event(blk, action, is_read, error);
1653 qemu_system_vmstop_request(RUN_STATE_IO_ERROR);
1654 } else {
1655 send_qmp_error_event(blk, action, is_read, error);
1656 }
4be74634
MA
1657}
1658
1659int blk_is_read_only(BlockBackend *blk)
1660{
f21d96d0
KW
1661 BlockDriverState *bs = blk_bs(blk);
1662
1663 if (bs) {
1664 return bdrv_is_read_only(bs);
061959e8
HR
1665 } else {
1666 return blk->root_state.read_only;
1667 }
4be74634
MA
1668}
1669
1670int blk_is_sg(BlockBackend *blk)
1671{
f21d96d0
KW
1672 BlockDriverState *bs = blk_bs(blk);
1673
1674 if (!bs) {
a46fc9c9
HR
1675 return 0;
1676 }
1677
f21d96d0 1678 return bdrv_is_sg(bs);
4be74634
MA
1679}
1680
1681int blk_enable_write_cache(BlockBackend *blk)
1682{
bfd18d1e 1683 return blk->enable_write_cache;
4be74634
MA
1684}
1685
1686void blk_set_enable_write_cache(BlockBackend *blk, bool wce)
1687{
bfd18d1e 1688 blk->enable_write_cache = wce;
4be74634
MA
1689}
1690
2bb0dce7
HR
1691void blk_invalidate_cache(BlockBackend *blk, Error **errp)
1692{
f21d96d0
KW
1693 BlockDriverState *bs = blk_bs(blk);
1694
1695 if (!bs) {
c09ba36c
HR
1696 error_setg(errp, "Device '%s' has no medium", blk->name);
1697 return;
1698 }
1699
f21d96d0 1700 bdrv_invalidate_cache(bs, errp);
2bb0dce7
HR
1701}
1702
e031f750 1703bool blk_is_inserted(BlockBackend *blk)
4be74634 1704{
f21d96d0
KW
1705 BlockDriverState *bs = blk_bs(blk);
1706
1707 return bs && bdrv_is_inserted(bs);
db0284f8
HR
1708}
1709
1710bool blk_is_available(BlockBackend *blk)
1711{
1712 return blk_is_inserted(blk) && !blk_dev_is_tray_open(blk);
4be74634
MA
1713}
1714
1715void blk_lock_medium(BlockBackend *blk, bool locked)
1716{
f21d96d0
KW
1717 BlockDriverState *bs = blk_bs(blk);
1718
1719 if (bs) {
1720 bdrv_lock_medium(bs, locked);
a46fc9c9 1721 }
4be74634
MA
1722}
1723
1724void blk_eject(BlockBackend *blk, bool eject_flag)
1725{
f21d96d0 1726 BlockDriverState *bs = blk_bs(blk);
2d76e724
KW
1727 char *id;
1728
1729 /* blk_eject is only called by qdevified devices */
1730 assert(!blk->legacy_dev);
f21d96d0
KW
1731
1732 if (bs) {
1733 bdrv_eject(bs, eject_flag);
a46fc9c9 1734 }
c47ee043
JS
1735
1736 /* Whether or not we ejected on the backend,
1737 * the frontend experienced a tray event. */
1738 id = blk_get_attached_dev_id(blk);
1739 qapi_event_send_device_tray_moved(blk_name(blk), id,
1740 eject_flag, &error_abort);
1741 g_free(id);
4be74634
MA
1742}
1743
1744int blk_get_flags(BlockBackend *blk)
1745{
f21d96d0
KW
1746 BlockDriverState *bs = blk_bs(blk);
1747
1748 if (bs) {
1749 return bdrv_get_flags(bs);
061959e8
HR
1750 } else {
1751 return blk->root_state.open_flags;
1752 }
4be74634
MA
1753}
1754
5def6b80
EB
1755/* Returns the maximum transfer length, in bytes; guaranteed nonzero */
1756uint32_t blk_get_max_transfer(BlockBackend *blk)
454057b7 1757{
f21d96d0 1758 BlockDriverState *bs = blk_bs(blk);
5def6b80 1759 uint32_t max = 0;
f21d96d0
KW
1760
1761 if (bs) {
5def6b80 1762 max = bs->bl.max_transfer;
a46fc9c9 1763 }
5def6b80 1764 return MIN_NON_ZERO(max, INT_MAX);
454057b7
PL
1765}
1766
648296e0
SH
1767int blk_get_max_iov(BlockBackend *blk)
1768{
f21d96d0 1769 return blk->root->bs->bl.max_iov;
648296e0
SH
1770}
1771
4be74634
MA
1772void blk_set_guest_block_size(BlockBackend *blk, int align)
1773{
68e9ec01 1774 blk->guest_block_size = align;
4be74634
MA
1775}
1776
f1c17521
PB
1777void *blk_try_blockalign(BlockBackend *blk, size_t size)
1778{
f21d96d0 1779 return qemu_try_blockalign(blk ? blk_bs(blk) : NULL, size);
f1c17521
PB
1780}
1781
4be74634
MA
1782void *blk_blockalign(BlockBackend *blk, size_t size)
1783{
f21d96d0 1784 return qemu_blockalign(blk ? blk_bs(blk) : NULL, size);
4be74634
MA
1785}
1786
1787bool blk_op_is_blocked(BlockBackend *blk, BlockOpType op, Error **errp)
1788{
f21d96d0
KW
1789 BlockDriverState *bs = blk_bs(blk);
1790
1791 if (!bs) {
a46fc9c9
HR
1792 return false;
1793 }
1794
f21d96d0 1795 return bdrv_op_is_blocked(bs, op, errp);
4be74634
MA
1796}
1797
1798void blk_op_unblock(BlockBackend *blk, BlockOpType op, Error *reason)
1799{
f21d96d0
KW
1800 BlockDriverState *bs = blk_bs(blk);
1801
1802 if (bs) {
1803 bdrv_op_unblock(bs, op, reason);
a46fc9c9 1804 }
4be74634
MA
1805}
1806
1807void blk_op_block_all(BlockBackend *blk, Error *reason)
1808{
f21d96d0
KW
1809 BlockDriverState *bs = blk_bs(blk);
1810
1811 if (bs) {
1812 bdrv_op_block_all(bs, reason);
a46fc9c9 1813 }
4be74634
MA
1814}
1815
1816void blk_op_unblock_all(BlockBackend *blk, Error *reason)
1817{
f21d96d0
KW
1818 BlockDriverState *bs = blk_bs(blk);
1819
1820 if (bs) {
1821 bdrv_op_unblock_all(bs, reason);
a46fc9c9 1822 }
4be74634
MA
1823}
1824
1825AioContext *blk_get_aio_context(BlockBackend *blk)
1826{
f21d96d0
KW
1827 BlockDriverState *bs = blk_bs(blk);
1828
1829 if (bs) {
1830 return bdrv_get_aio_context(bs);
4981bdec
HR
1831 } else {
1832 return qemu_get_aio_context();
1833 }
1834}
1835
1836static AioContext *blk_aiocb_get_aio_context(BlockAIOCB *acb)
1837{
1838 BlockBackendAIOCB *blk_acb = DO_UPCAST(BlockBackendAIOCB, common, acb);
1839 return blk_get_aio_context(blk_acb->blk);
4be74634
MA
1840}
1841
1842void blk_set_aio_context(BlockBackend *blk, AioContext *new_context)
1843{
f21d96d0 1844 BlockDriverState *bs = blk_bs(blk);
c61791fc 1845 ThrottleGroupMember *tgm = &blk->public.throttle_group_member;
f21d96d0
KW
1846
1847 if (bs) {
c61791fc 1848 if (tgm->throttle_state) {
dc868fb0 1849 bdrv_drained_begin(bs);
c61791fc
MP
1850 throttle_group_detach_aio_context(tgm);
1851 throttle_group_attach_aio_context(tgm, new_context);
dc868fb0 1852 bdrv_drained_end(bs);
7ca7f0f6 1853 }
f21d96d0 1854 bdrv_set_aio_context(bs, new_context);
a46fc9c9 1855 }
4be74634
MA
1856}
1857
2019ba0a
HR
1858void blk_add_aio_context_notifier(BlockBackend *blk,
1859 void (*attached_aio_context)(AioContext *new_context, void *opaque),
1860 void (*detach_aio_context)(void *opaque), void *opaque)
1861{
f21d96d0
KW
1862 BlockDriverState *bs = blk_bs(blk);
1863
1864 if (bs) {
1865 bdrv_add_aio_context_notifier(bs, attached_aio_context,
a46fc9c9
HR
1866 detach_aio_context, opaque);
1867 }
2019ba0a
HR
1868}
1869
1870void blk_remove_aio_context_notifier(BlockBackend *blk,
1871 void (*attached_aio_context)(AioContext *,
1872 void *),
1873 void (*detach_aio_context)(void *),
1874 void *opaque)
1875{
f21d96d0
KW
1876 BlockDriverState *bs = blk_bs(blk);
1877
1878 if (bs) {
1879 bdrv_remove_aio_context_notifier(bs, attached_aio_context,
a46fc9c9
HR
1880 detach_aio_context, opaque);
1881 }
2019ba0a
HR
1882}
1883
3301f6c6
HR
1884void blk_add_remove_bs_notifier(BlockBackend *blk, Notifier *notify)
1885{
1886 notifier_list_add(&blk->remove_bs_notifiers, notify);
1887}
1888
1889void blk_add_insert_bs_notifier(BlockBackend *blk, Notifier *notify)
1890{
1891 notifier_list_add(&blk->insert_bs_notifiers, notify);
1892}
1893
4be74634
MA
1894void blk_io_plug(BlockBackend *blk)
1895{
f21d96d0
KW
1896 BlockDriverState *bs = blk_bs(blk);
1897
1898 if (bs) {
1899 bdrv_io_plug(bs);
a46fc9c9 1900 }
4be74634
MA
1901}
1902
1903void blk_io_unplug(BlockBackend *blk)
1904{
f21d96d0
KW
1905 BlockDriverState *bs = blk_bs(blk);
1906
1907 if (bs) {
1908 bdrv_io_unplug(bs);
a46fc9c9 1909 }
4be74634
MA
1910}
1911
1912BlockAcctStats *blk_get_stats(BlockBackend *blk)
1913{
7f0e9da6 1914 return &blk->stats;
4be74634
MA
1915}
1916
1917void *blk_aio_get(const AIOCBInfo *aiocb_info, BlockBackend *blk,
1918 BlockCompletionFunc *cb, void *opaque)
1919{
1920 return qemu_aio_get(aiocb_info, blk_bs(blk), cb, opaque);
1921}
1ef01253 1922
d004bd52 1923int coroutine_fn blk_co_pwrite_zeroes(BlockBackend *blk, int64_t offset,
f5a5ca79 1924 int bytes, BdrvRequestFlags flags)
1ef01253 1925{
f5a5ca79 1926 return blk_co_pwritev(blk, offset, bytes, NULL,
16aaf975 1927 flags | BDRV_REQ_ZERO_WRITE);
1ef01253
HR
1928}
1929
fe5c1355
PB
1930int blk_pwrite_compressed(BlockBackend *blk, int64_t offset, const void *buf,
1931 int count)
1ef01253 1932{
35fadca8
PB
1933 return blk_prw(blk, offset, (void *) buf, count, blk_write_entry,
1934 BDRV_REQ_WRITE_COMPRESSED);
1ef01253
HR
1935}
1936
3a691c50
HR
1937int blk_truncate(BlockBackend *blk, int64_t offset, PreallocMode prealloc,
1938 Error **errp)
1ef01253 1939{
c09ba36c 1940 if (!blk_is_available(blk)) {
ed3d2ec9 1941 error_setg(errp, "No medium inserted");
c09ba36c
HR
1942 return -ENOMEDIUM;
1943 }
1944
3a691c50 1945 return bdrv_truncate(blk->root, offset, prealloc, errp);
1ef01253
HR
1946}
1947
8c2e3dd5 1948static void blk_pdiscard_entry(void *opaque)
1ef01253 1949{
8c2e3dd5
KW
1950 BlkRwCo *rwco = opaque;
1951 rwco->ret = blk_co_pdiscard(rwco->blk, rwco->offset, rwco->qiov->size);
1952}
e7f7d676 1953
f5a5ca79 1954int blk_pdiscard(BlockBackend *blk, int64_t offset, int bytes)
8c2e3dd5 1955{
f5a5ca79 1956 return blk_prw(blk, offset, NULL, bytes, blk_pdiscard_entry, 0);
1ef01253
HR
1957}
1958
1959int blk_save_vmstate(BlockBackend *blk, const uint8_t *buf,
1960 int64_t pos, int size)
1961{
bfd18d1e
KW
1962 int ret;
1963
c09ba36c
HR
1964 if (!blk_is_available(blk)) {
1965 return -ENOMEDIUM;
1966 }
1967
bfd18d1e
KW
1968 ret = bdrv_save_vmstate(blk_bs(blk), buf, pos, size);
1969 if (ret < 0) {
1970 return ret;
1971 }
1972
1973 if (ret == size && !blk->enable_write_cache) {
1974 ret = bdrv_flush(blk_bs(blk));
1975 }
1976
1977 return ret < 0 ? ret : size;
1ef01253
HR
1978}
1979
1980int blk_load_vmstate(BlockBackend *blk, uint8_t *buf, int64_t pos, int size)
1981{
c09ba36c
HR
1982 if (!blk_is_available(blk)) {
1983 return -ENOMEDIUM;
1984 }
1985
f21d96d0 1986 return bdrv_load_vmstate(blk_bs(blk), buf, pos, size);
1ef01253 1987}
f0272c4d
ET
1988
1989int blk_probe_blocksizes(BlockBackend *blk, BlockSizes *bsz)
1990{
c09ba36c
HR
1991 if (!blk_is_available(blk)) {
1992 return -ENOMEDIUM;
1993 }
1994
f21d96d0 1995 return bdrv_probe_blocksizes(blk_bs(blk), bsz);
f0272c4d
ET
1996}
1997
1998int blk_probe_geometry(BlockBackend *blk, HDGeometry *geo)
1999{
c09ba36c
HR
2000 if (!blk_is_available(blk)) {
2001 return -ENOMEDIUM;
2002 }
2003
f21d96d0 2004 return bdrv_probe_geometry(blk_bs(blk), geo);
f0272c4d 2005}
281d22d8
HR
2006
2007/*
2008 * Updates the BlockBackendRootState object with data from the currently
2009 * attached BlockDriverState.
2010 */
2011void blk_update_root_state(BlockBackend *blk)
2012{
f21d96d0 2013 assert(blk->root);
281d22d8 2014
f21d96d0
KW
2015 blk->root_state.open_flags = blk->root->bs->open_flags;
2016 blk->root_state.read_only = blk->root->bs->read_only;
2017 blk->root_state.detect_zeroes = blk->root->bs->detect_zeroes;
281d22d8
HR
2018}
2019
38cb18f5 2020/*
b85114f8
KW
2021 * Returns the detect-zeroes setting to be used for bdrv_open() of a
2022 * BlockDriverState which is supposed to inherit the root state.
38cb18f5 2023 */
b85114f8 2024bool blk_get_detect_zeroes_from_root_state(BlockBackend *blk)
38cb18f5 2025{
b85114f8 2026 return blk->root_state.detect_zeroes;
38cb18f5
HR
2027}
2028
2029/*
2030 * Returns the flags to be used for bdrv_open() of a BlockDriverState which is
2031 * supposed to inherit the root state.
2032 */
2033int blk_get_open_flags_from_root_state(BlockBackend *blk)
2034{
2035 int bs_flags;
2036
2037 bs_flags = blk->root_state.read_only ? 0 : BDRV_O_RDWR;
2038 bs_flags |= blk->root_state.open_flags & ~BDRV_O_RDWR;
2039
2040 return bs_flags;
2041}
2042
281d22d8
HR
2043BlockBackendRootState *blk_get_root_state(BlockBackend *blk)
2044{
2045 return &blk->root_state;
2046}
1393f212
HR
2047
2048int blk_commit_all(void)
2049{
fe1a9cbc
HR
2050 BlockBackend *blk = NULL;
2051
2052 while ((blk = blk_all_next(blk)) != NULL) {
2053 AioContext *aio_context = blk_get_aio_context(blk);
2054
2055 aio_context_acquire(aio_context);
f21d96d0
KW
2056 if (blk_is_inserted(blk) && blk->root->bs->backing) {
2057 int ret = bdrv_commit(blk->root->bs);
fe1a9cbc
HR
2058 if (ret < 0) {
2059 aio_context_release(aio_context);
2060 return ret;
2061 }
2062 }
2063 aio_context_release(aio_context);
2064 }
2065 return 0;
2066}
2067
97148076
KW
2068
2069/* throttling disk I/O limits */
2070void blk_set_io_limits(BlockBackend *blk, ThrottleConfig *cfg)
2071{
022cdc9f 2072 throttle_group_config(&blk->public.throttle_group_member, cfg);
97148076
KW
2073}
2074
2075void blk_io_limits_disable(BlockBackend *blk)
2076{
48bf7ea8
AG
2077 BlockDriverState *bs = blk_bs(blk);
2078 ThrottleGroupMember *tgm = &blk->public.throttle_group_member;
2079 assert(tgm->throttle_state);
2080 if (bs) {
2081 bdrv_drained_begin(bs);
2082 }
2083 throttle_group_unregister_tgm(tgm);
2084 if (bs) {
2085 bdrv_drained_end(bs);
2086 }
97148076
KW
2087}
2088
2089/* should be called before blk_set_io_limits if a limit is set */
2090void blk_io_limits_enable(BlockBackend *blk, const char *group)
2091{
022cdc9f 2092 assert(!blk->public.throttle_group_member.throttle_state);
c61791fc
MP
2093 throttle_group_register_tgm(&blk->public.throttle_group_member,
2094 group, blk_get_aio_context(blk));
97148076
KW
2095}
2096
2097void blk_io_limits_update_group(BlockBackend *blk, const char *group)
2098{
2099 /* this BB is not part of any group */
022cdc9f 2100 if (!blk->public.throttle_group_member.throttle_state) {
97148076
KW
2101 return;
2102 }
2103
2104 /* this BB is a part of the same group than the one we want */
022cdc9f
MP
2105 if (!g_strcmp0(throttle_group_get_name(&blk->public.throttle_group_member),
2106 group)) {
97148076
KW
2107 return;
2108 }
2109
2110 /* need to change the group this bs belong to */
2111 blk_io_limits_disable(blk);
2112 blk_io_limits_enable(blk, group);
2113}
c2066af0
KW
2114
2115static void blk_root_drained_begin(BdrvChild *child)
2116{
2117 BlockBackend *blk = child->opaque;
2118
f4d9cc88
JS
2119 if (++blk->quiesce_counter == 1) {
2120 if (blk->dev_ops && blk->dev_ops->drained_begin) {
2121 blk->dev_ops->drained_begin(blk->dev_opaque);
2122 }
2123 }
2124
36fe1331
KW
2125 /* Note that blk->root may not be accessible here yet if we are just
2126 * attaching to a BlockDriverState that is drained. Use child instead. */
2127
022cdc9f
MP
2128 if (atomic_fetch_inc(&blk->public.throttle_group_member.io_limits_disabled) == 0) {
2129 throttle_group_restart_tgm(&blk->public.throttle_group_member);
c2066af0
KW
2130 }
2131}
2132
2133static void blk_root_drained_end(BdrvChild *child)
2134{
2135 BlockBackend *blk = child->opaque;
f4d9cc88 2136 assert(blk->quiesce_counter);
c2066af0 2137
022cdc9f
MP
2138 assert(blk->public.throttle_group_member.io_limits_disabled);
2139 atomic_dec(&blk->public.throttle_group_member.io_limits_disabled);
f4d9cc88
JS
2140
2141 if (--blk->quiesce_counter == 0) {
2142 if (blk->dev_ops && blk->dev_ops->drained_end) {
2143 blk->dev_ops->drained_end(blk->dev_opaque);
2144 }
2145 }
c2066af0 2146}
23d0ba93
FZ
2147
2148void blk_register_buf(BlockBackend *blk, void *host, size_t size)
2149{
2150 bdrv_register_buf(blk_bs(blk), host, size);
2151}
2152
2153void blk_unregister_buf(BlockBackend *blk, void *host)
2154{
2155 bdrv_unregister_buf(blk_bs(blk), host);
2156}