block: Rename blk_write_zeroes()
[qemu.git] / block / block-backend.c
1 /*
2 * QEMU Block backends
3 *
4 * Copyright (C) 2014-2016 Red Hat, Inc.
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
13 #include "qemu/osdep.h"
14 #include "sysemu/block-backend.h"
15 #include "block/block_int.h"
16 #include "block/blockjob.h"
17 #include "block/throttle-groups.h"
18 #include "sysemu/blockdev.h"
19 #include "sysemu/sysemu.h"
20 #include "qapi-event.h"
21 #include "qemu/id.h"
22
23 /* Number of coroutines to reserve per attached device model */
24 #define COROUTINE_POOL_RESERVATION 64
25
26 #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
27
28 static AioContext *blk_aiocb_get_aio_context(BlockAIOCB *acb);
29
30 struct BlockBackend {
31 char *name;
32 int refcnt;
33 BdrvChild *root;
34 DriveInfo *legacy_dinfo; /* null unless created by drive_new() */
35 QTAILQ_ENTRY(BlockBackend) link; /* for block_backends */
36 QTAILQ_ENTRY(BlockBackend) monitor_link; /* for monitor_block_backends */
37 BlockBackendPublic public;
38
39 void *dev; /* attached device model, if any */
40 /* TODO change to DeviceState when all users are qdevified */
41 const BlockDevOps *dev_ops;
42 void *dev_opaque;
43
44 /* the block size for which the guest device expects atomicity */
45 int guest_block_size;
46
47 /* If the BDS tree is removed, some of its options are stored here (which
48 * can be used to restore those options in the new BDS on insert) */
49 BlockBackendRootState root_state;
50
51 bool enable_write_cache;
52
53 /* I/O stats (display with "info blockstats"). */
54 BlockAcctStats stats;
55
56 BlockdevOnError on_read_error, on_write_error;
57 bool iostatus_enabled;
58 BlockDeviceIoStatus iostatus;
59
60 bool allow_write_beyond_eof;
61
62 NotifierList remove_bs_notifiers, insert_bs_notifiers;
63 };
64
65 typedef struct BlockBackendAIOCB {
66 BlockAIOCB common;
67 QEMUBH *bh;
68 BlockBackend *blk;
69 int ret;
70 } BlockBackendAIOCB;
71
72 static const AIOCBInfo block_backend_aiocb_info = {
73 .get_aio_context = blk_aiocb_get_aio_context,
74 .aiocb_size = sizeof(BlockBackendAIOCB),
75 };
76
77 static void drive_info_del(DriveInfo *dinfo);
78 static BlockBackend *bdrv_first_blk(BlockDriverState *bs);
79
80 /* All BlockBackends */
81 static QTAILQ_HEAD(, BlockBackend) block_backends =
82 QTAILQ_HEAD_INITIALIZER(block_backends);
83
84 /* All BlockBackends referenced by the monitor and which are iterated through by
85 * blk_next() */
86 static QTAILQ_HEAD(, BlockBackend) monitor_block_backends =
87 QTAILQ_HEAD_INITIALIZER(monitor_block_backends);
88
89 static void blk_root_inherit_options(int *child_flags, QDict *child_options,
90 int parent_flags, QDict *parent_options)
91 {
92 /* We're not supposed to call this function for root nodes */
93 abort();
94 }
95 static void blk_root_drained_begin(BdrvChild *child);
96 static void blk_root_drained_end(BdrvChild *child);
97
98 static void blk_root_change_media(BdrvChild *child, bool load);
99 static void blk_root_resize(BdrvChild *child);
100
101 static const char *blk_root_get_name(BdrvChild *child)
102 {
103 return blk_name(child->opaque);
104 }
105
106 static const BdrvChildRole child_root = {
107 .inherit_options = blk_root_inherit_options,
108
109 .change_media = blk_root_change_media,
110 .resize = blk_root_resize,
111 .get_name = blk_root_get_name,
112
113 .drained_begin = blk_root_drained_begin,
114 .drained_end = blk_root_drained_end,
115 };
116
117 /*
118 * Create a new BlockBackend with a reference count of one.
119 * Store an error through @errp on failure, unless it's null.
120 * Return the new BlockBackend on success, null on failure.
121 */
122 BlockBackend *blk_new(void)
123 {
124 BlockBackend *blk;
125
126 blk = g_new0(BlockBackend, 1);
127 blk->refcnt = 1;
128 qemu_co_queue_init(&blk->public.throttled_reqs[0]);
129 qemu_co_queue_init(&blk->public.throttled_reqs[1]);
130
131 notifier_list_init(&blk->remove_bs_notifiers);
132 notifier_list_init(&blk->insert_bs_notifiers);
133
134 QTAILQ_INSERT_TAIL(&block_backends, blk, link);
135 return blk;
136 }
137
138 /*
139 * Creates a new BlockBackend, opens a new BlockDriverState, and connects both.
140 *
141 * Just as with bdrv_open(), after having called this function the reference to
142 * @options belongs to the block layer (even on failure).
143 *
144 * TODO: Remove @filename and @flags; it should be possible to specify a whole
145 * BDS tree just by specifying the @options QDict (or @reference,
146 * alternatively). At the time of adding this function, this is not possible,
147 * though, so callers of this function have to be able to specify @filename and
148 * @flags.
149 */
150 BlockBackend *blk_new_open(const char *filename, const char *reference,
151 QDict *options, int flags, Error **errp)
152 {
153 BlockBackend *blk;
154 BlockDriverState *bs;
155
156 blk = blk_new();
157 bs = bdrv_open(filename, reference, options, flags, errp);
158 if (!bs) {
159 blk_unref(blk);
160 return NULL;
161 }
162
163 blk_set_enable_write_cache(blk, true);
164 blk->root = bdrv_root_attach_child(bs, "root", &child_root, blk);
165
166 return blk;
167 }
168
169 static void blk_delete(BlockBackend *blk)
170 {
171 assert(!blk->refcnt);
172 assert(!blk->name);
173 assert(!blk->dev);
174 if (blk->root) {
175 blk_remove_bs(blk);
176 }
177 assert(QLIST_EMPTY(&blk->remove_bs_notifiers.notifiers));
178 assert(QLIST_EMPTY(&blk->insert_bs_notifiers.notifiers));
179 QTAILQ_REMOVE(&block_backends, blk, link);
180 drive_info_del(blk->legacy_dinfo);
181 block_acct_cleanup(&blk->stats);
182 g_free(blk);
183 }
184
185 static void drive_info_del(DriveInfo *dinfo)
186 {
187 if (!dinfo) {
188 return;
189 }
190 qemu_opts_del(dinfo->opts);
191 g_free(dinfo->serial);
192 g_free(dinfo);
193 }
194
195 int blk_get_refcnt(BlockBackend *blk)
196 {
197 return blk ? blk->refcnt : 0;
198 }
199
200 /*
201 * Increment @blk's reference count.
202 * @blk must not be null.
203 */
204 void blk_ref(BlockBackend *blk)
205 {
206 blk->refcnt++;
207 }
208
209 /*
210 * Decrement @blk's reference count.
211 * If this drops it to zero, destroy @blk.
212 * For convenience, do nothing if @blk is null.
213 */
214 void blk_unref(BlockBackend *blk)
215 {
216 if (blk) {
217 assert(blk->refcnt > 0);
218 if (!--blk->refcnt) {
219 blk_delete(blk);
220 }
221 }
222 }
223
224 /*
225 * Behaves similarly to blk_next() but iterates over all BlockBackends, even the
226 * ones which are hidden (i.e. are not referenced by the monitor).
227 */
228 static BlockBackend *blk_all_next(BlockBackend *blk)
229 {
230 return blk ? QTAILQ_NEXT(blk, link)
231 : QTAILQ_FIRST(&block_backends);
232 }
233
234 void blk_remove_all_bs(void)
235 {
236 BlockBackend *blk = NULL;
237
238 while ((blk = blk_all_next(blk)) != NULL) {
239 AioContext *ctx = blk_get_aio_context(blk);
240
241 aio_context_acquire(ctx);
242 if (blk->root) {
243 blk_remove_bs(blk);
244 }
245 aio_context_release(ctx);
246 }
247 }
248
249 /*
250 * Return the monitor-owned BlockBackend after @blk.
251 * If @blk is null, return the first one.
252 * Else, return @blk's next sibling, which may be null.
253 *
254 * To iterate over all BlockBackends, do
255 * for (blk = blk_next(NULL); blk; blk = blk_next(blk)) {
256 * ...
257 * }
258 */
259 BlockBackend *blk_next(BlockBackend *blk)
260 {
261 return blk ? QTAILQ_NEXT(blk, monitor_link)
262 : QTAILQ_FIRST(&monitor_block_backends);
263 }
264
265 /* Iterates over all top-level BlockDriverStates, i.e. BDSs that are owned by
266 * the monitor or attached to a BlockBackend */
267 BlockDriverState *bdrv_next(BdrvNextIterator *it)
268 {
269 BlockDriverState *bs;
270
271 /* First, return all root nodes of BlockBackends. In order to avoid
272 * returning a BDS twice when multiple BBs refer to it, we only return it
273 * if the BB is the first one in the parent list of the BDS. */
274 if (it->phase == BDRV_NEXT_BACKEND_ROOTS) {
275 do {
276 it->blk = blk_all_next(it->blk);
277 bs = it->blk ? blk_bs(it->blk) : NULL;
278 } while (it->blk && (bs == NULL || bdrv_first_blk(bs) != it->blk));
279
280 if (bs) {
281 return bs;
282 }
283 it->phase = BDRV_NEXT_MONITOR_OWNED;
284 }
285
286 /* Then return the monitor-owned BDSes without a BB attached. Ignore all
287 * BDSes that are attached to a BlockBackend here; they have been handled
288 * by the above block already */
289 do {
290 it->bs = bdrv_next_monitor_owned(it->bs);
291 bs = it->bs;
292 } while (bs && bdrv_has_blk(bs));
293
294 return bs;
295 }
296
297 BlockDriverState *bdrv_first(BdrvNextIterator *it)
298 {
299 *it = (BdrvNextIterator) {
300 .phase = BDRV_NEXT_BACKEND_ROOTS,
301 };
302
303 return bdrv_next(it);
304 }
305
306 /*
307 * Add a BlockBackend into the list of backends referenced by the monitor, with
308 * the given @name acting as the handle for the monitor.
309 * Strictly for use by blockdev.c.
310 *
311 * @name must not be null or empty.
312 *
313 * Returns true on success and false on failure. In the latter case, an Error
314 * object is returned through @errp.
315 */
316 bool monitor_add_blk(BlockBackend *blk, const char *name, Error **errp)
317 {
318 assert(!blk->name);
319 assert(name && name[0]);
320
321 if (!id_wellformed(name)) {
322 error_setg(errp, "Invalid device name");
323 return false;
324 }
325 if (blk_by_name(name)) {
326 error_setg(errp, "Device with id '%s' already exists", name);
327 return false;
328 }
329 if (bdrv_find_node(name)) {
330 error_setg(errp,
331 "Device name '%s' conflicts with an existing node name",
332 name);
333 return false;
334 }
335
336 blk->name = g_strdup(name);
337 QTAILQ_INSERT_TAIL(&monitor_block_backends, blk, monitor_link);
338 return true;
339 }
340
341 /*
342 * Remove a BlockBackend from the list of backends referenced by the monitor.
343 * Strictly for use by blockdev.c.
344 */
345 void monitor_remove_blk(BlockBackend *blk)
346 {
347 if (!blk->name) {
348 return;
349 }
350
351 QTAILQ_REMOVE(&monitor_block_backends, blk, monitor_link);
352 g_free(blk->name);
353 blk->name = NULL;
354 }
355
356 /*
357 * Return @blk's name, a non-null string.
358 * Returns an empty string iff @blk is not referenced by the monitor.
359 */
360 const char *blk_name(BlockBackend *blk)
361 {
362 return blk->name ?: "";
363 }
364
365 /*
366 * Return the BlockBackend with name @name if it exists, else null.
367 * @name must not be null.
368 */
369 BlockBackend *blk_by_name(const char *name)
370 {
371 BlockBackend *blk = NULL;
372
373 assert(name);
374 while ((blk = blk_next(blk)) != NULL) {
375 if (!strcmp(name, blk->name)) {
376 return blk;
377 }
378 }
379 return NULL;
380 }
381
382 /*
383 * Return the BlockDriverState attached to @blk if any, else null.
384 */
385 BlockDriverState *blk_bs(BlockBackend *blk)
386 {
387 return blk->root ? blk->root->bs : NULL;
388 }
389
390 static BlockBackend *bdrv_first_blk(BlockDriverState *bs)
391 {
392 BdrvChild *child;
393 QLIST_FOREACH(child, &bs->parents, next_parent) {
394 if (child->role == &child_root) {
395 return child->opaque;
396 }
397 }
398
399 return NULL;
400 }
401
402 /*
403 * Returns true if @bs has an associated BlockBackend.
404 */
405 bool bdrv_has_blk(BlockDriverState *bs)
406 {
407 return bdrv_first_blk(bs) != NULL;
408 }
409
410 /*
411 * Return @blk's DriveInfo if any, else null.
412 */
413 DriveInfo *blk_legacy_dinfo(BlockBackend *blk)
414 {
415 return blk->legacy_dinfo;
416 }
417
418 /*
419 * Set @blk's DriveInfo to @dinfo, and return it.
420 * @blk must not have a DriveInfo set already.
421 * No other BlockBackend may have the same DriveInfo set.
422 */
423 DriveInfo *blk_set_legacy_dinfo(BlockBackend *blk, DriveInfo *dinfo)
424 {
425 assert(!blk->legacy_dinfo);
426 return blk->legacy_dinfo = dinfo;
427 }
428
429 /*
430 * Return the BlockBackend with DriveInfo @dinfo.
431 * It must exist.
432 */
433 BlockBackend *blk_by_legacy_dinfo(DriveInfo *dinfo)
434 {
435 BlockBackend *blk = NULL;
436
437 while ((blk = blk_next(blk)) != NULL) {
438 if (blk->legacy_dinfo == dinfo) {
439 return blk;
440 }
441 }
442 abort();
443 }
444
445 /*
446 * Returns a pointer to the publicly accessible fields of @blk.
447 */
448 BlockBackendPublic *blk_get_public(BlockBackend *blk)
449 {
450 return &blk->public;
451 }
452
453 /*
454 * Returns a BlockBackend given the associated @public fields.
455 */
456 BlockBackend *blk_by_public(BlockBackendPublic *public)
457 {
458 return container_of(public, BlockBackend, public);
459 }
460
461 /*
462 * Disassociates the currently associated BlockDriverState from @blk.
463 */
464 void blk_remove_bs(BlockBackend *blk)
465 {
466 notifier_list_notify(&blk->remove_bs_notifiers, blk);
467 if (blk->public.throttle_state) {
468 throttle_timers_detach_aio_context(&blk->public.throttle_timers);
469 }
470
471 blk_update_root_state(blk);
472
473 bdrv_root_unref_child(blk->root);
474 blk->root = NULL;
475 }
476
477 /*
478 * Associates a new BlockDriverState with @blk.
479 */
480 void blk_insert_bs(BlockBackend *blk, BlockDriverState *bs)
481 {
482 bdrv_ref(bs);
483 blk->root = bdrv_root_attach_child(bs, "root", &child_root, blk);
484
485 notifier_list_notify(&blk->insert_bs_notifiers, blk);
486 if (blk->public.throttle_state) {
487 throttle_timers_attach_aio_context(
488 &blk->public.throttle_timers, bdrv_get_aio_context(bs));
489 }
490 }
491
492 /*
493 * Attach device model @dev to @blk.
494 * Return 0 on success, -EBUSY when a device model is attached already.
495 */
496 int blk_attach_dev(BlockBackend *blk, void *dev)
497 /* TODO change to DeviceState *dev when all users are qdevified */
498 {
499 if (blk->dev) {
500 return -EBUSY;
501 }
502 blk_ref(blk);
503 blk->dev = dev;
504 blk_iostatus_reset(blk);
505 return 0;
506 }
507
508 /*
509 * Attach device model @dev to @blk.
510 * @blk must not have a device model attached already.
511 * TODO qdevified devices don't use this, remove when devices are qdevified
512 */
513 void blk_attach_dev_nofail(BlockBackend *blk, void *dev)
514 {
515 if (blk_attach_dev(blk, dev) < 0) {
516 abort();
517 }
518 }
519
520 /*
521 * Detach device model @dev from @blk.
522 * @dev must be currently attached to @blk.
523 */
524 void blk_detach_dev(BlockBackend *blk, void *dev)
525 /* TODO change to DeviceState *dev when all users are qdevified */
526 {
527 assert(blk->dev == dev);
528 blk->dev = NULL;
529 blk->dev_ops = NULL;
530 blk->dev_opaque = NULL;
531 blk->guest_block_size = 512;
532 blk_unref(blk);
533 }
534
535 /*
536 * Return the device model attached to @blk if any, else null.
537 */
538 void *blk_get_attached_dev(BlockBackend *blk)
539 /* TODO change to return DeviceState * when all users are qdevified */
540 {
541 return blk->dev;
542 }
543
544 /*
545 * Set @blk's device model callbacks to @ops.
546 * @opaque is the opaque argument to pass to the callbacks.
547 * This is for use by device models.
548 */
549 void blk_set_dev_ops(BlockBackend *blk, const BlockDevOps *ops,
550 void *opaque)
551 {
552 blk->dev_ops = ops;
553 blk->dev_opaque = opaque;
554 }
555
556 /*
557 * Notify @blk's attached device model of media change.
558 * If @load is true, notify of media load.
559 * Else, notify of media eject.
560 * Also send DEVICE_TRAY_MOVED events as appropriate.
561 */
562 void blk_dev_change_media_cb(BlockBackend *blk, bool load)
563 {
564 if (blk->dev_ops && blk->dev_ops->change_media_cb) {
565 bool tray_was_open, tray_is_open;
566
567 tray_was_open = blk_dev_is_tray_open(blk);
568 blk->dev_ops->change_media_cb(blk->dev_opaque, load);
569 tray_is_open = blk_dev_is_tray_open(blk);
570
571 if (tray_was_open != tray_is_open) {
572 qapi_event_send_device_tray_moved(blk_name(blk), tray_is_open,
573 &error_abort);
574 }
575 }
576 }
577
578 static void blk_root_change_media(BdrvChild *child, bool load)
579 {
580 blk_dev_change_media_cb(child->opaque, load);
581 }
582
583 /*
584 * Does @blk's attached device model have removable media?
585 * %true if no device model is attached.
586 */
587 bool blk_dev_has_removable_media(BlockBackend *blk)
588 {
589 return !blk->dev || (blk->dev_ops && blk->dev_ops->change_media_cb);
590 }
591
592 /*
593 * Does @blk's attached device model have a tray?
594 */
595 bool blk_dev_has_tray(BlockBackend *blk)
596 {
597 return blk->dev_ops && blk->dev_ops->is_tray_open;
598 }
599
600 /*
601 * Notify @blk's attached device model of a media eject request.
602 * If @force is true, the medium is about to be yanked out forcefully.
603 */
604 void blk_dev_eject_request(BlockBackend *blk, bool force)
605 {
606 if (blk->dev_ops && blk->dev_ops->eject_request_cb) {
607 blk->dev_ops->eject_request_cb(blk->dev_opaque, force);
608 }
609 }
610
611 /*
612 * Does @blk's attached device model have a tray, and is it open?
613 */
614 bool blk_dev_is_tray_open(BlockBackend *blk)
615 {
616 if (blk_dev_has_tray(blk)) {
617 return blk->dev_ops->is_tray_open(blk->dev_opaque);
618 }
619 return false;
620 }
621
622 /*
623 * Does @blk's attached device model have the medium locked?
624 * %false if the device model has no such lock.
625 */
626 bool blk_dev_is_medium_locked(BlockBackend *blk)
627 {
628 if (blk->dev_ops && blk->dev_ops->is_medium_locked) {
629 return blk->dev_ops->is_medium_locked(blk->dev_opaque);
630 }
631 return false;
632 }
633
634 /*
635 * Notify @blk's attached device model of a backend size change.
636 */
637 static void blk_root_resize(BdrvChild *child)
638 {
639 BlockBackend *blk = child->opaque;
640
641 if (blk->dev_ops && blk->dev_ops->resize_cb) {
642 blk->dev_ops->resize_cb(blk->dev_opaque);
643 }
644 }
645
646 void blk_iostatus_enable(BlockBackend *blk)
647 {
648 blk->iostatus_enabled = true;
649 blk->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
650 }
651
652 /* The I/O status is only enabled if the drive explicitly
653 * enables it _and_ the VM is configured to stop on errors */
654 bool blk_iostatus_is_enabled(const BlockBackend *blk)
655 {
656 return (blk->iostatus_enabled &&
657 (blk->on_write_error == BLOCKDEV_ON_ERROR_ENOSPC ||
658 blk->on_write_error == BLOCKDEV_ON_ERROR_STOP ||
659 blk->on_read_error == BLOCKDEV_ON_ERROR_STOP));
660 }
661
662 BlockDeviceIoStatus blk_iostatus(const BlockBackend *blk)
663 {
664 return blk->iostatus;
665 }
666
667 void blk_iostatus_disable(BlockBackend *blk)
668 {
669 blk->iostatus_enabled = false;
670 }
671
672 void blk_iostatus_reset(BlockBackend *blk)
673 {
674 if (blk_iostatus_is_enabled(blk)) {
675 BlockDriverState *bs = blk_bs(blk);
676 blk->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
677 if (bs && bs->job) {
678 block_job_iostatus_reset(bs->job);
679 }
680 }
681 }
682
683 void blk_iostatus_set_err(BlockBackend *blk, int error)
684 {
685 assert(blk_iostatus_is_enabled(blk));
686 if (blk->iostatus == BLOCK_DEVICE_IO_STATUS_OK) {
687 blk->iostatus = error == ENOSPC ? BLOCK_DEVICE_IO_STATUS_NOSPACE :
688 BLOCK_DEVICE_IO_STATUS_FAILED;
689 }
690 }
691
692 void blk_set_allow_write_beyond_eof(BlockBackend *blk, bool allow)
693 {
694 blk->allow_write_beyond_eof = allow;
695 }
696
697 static int blk_check_byte_request(BlockBackend *blk, int64_t offset,
698 size_t size)
699 {
700 int64_t len;
701
702 if (size > INT_MAX) {
703 return -EIO;
704 }
705
706 if (!blk_is_available(blk)) {
707 return -ENOMEDIUM;
708 }
709
710 if (offset < 0) {
711 return -EIO;
712 }
713
714 if (!blk->allow_write_beyond_eof) {
715 len = blk_getlength(blk);
716 if (len < 0) {
717 return len;
718 }
719
720 if (offset > len || len - offset < size) {
721 return -EIO;
722 }
723 }
724
725 return 0;
726 }
727
728 static int blk_check_request(BlockBackend *blk, int64_t sector_num,
729 int nb_sectors)
730 {
731 if (sector_num < 0 || sector_num > INT64_MAX / BDRV_SECTOR_SIZE) {
732 return -EIO;
733 }
734
735 if (nb_sectors < 0 || nb_sectors > INT_MAX / BDRV_SECTOR_SIZE) {
736 return -EIO;
737 }
738
739 return blk_check_byte_request(blk, sector_num * BDRV_SECTOR_SIZE,
740 nb_sectors * BDRV_SECTOR_SIZE);
741 }
742
743 static int coroutine_fn blk_co_preadv(BlockBackend *blk, int64_t offset,
744 unsigned int bytes, QEMUIOVector *qiov,
745 BdrvRequestFlags flags)
746 {
747 int ret = blk_check_byte_request(blk, offset, bytes);
748 if (ret < 0) {
749 return ret;
750 }
751
752 /* throttling disk I/O */
753 if (blk->public.throttle_state) {
754 throttle_group_co_io_limits_intercept(blk, bytes, false);
755 }
756
757 return bdrv_co_preadv(blk_bs(blk), offset, bytes, qiov, flags);
758 }
759
760 static int coroutine_fn blk_co_pwritev(BlockBackend *blk, int64_t offset,
761 unsigned int bytes, QEMUIOVector *qiov,
762 BdrvRequestFlags flags)
763 {
764 int ret;
765
766 ret = blk_check_byte_request(blk, offset, bytes);
767 if (ret < 0) {
768 return ret;
769 }
770
771 /* throttling disk I/O */
772 if (blk->public.throttle_state) {
773 throttle_group_co_io_limits_intercept(blk, bytes, true);
774 }
775
776 if (!blk->enable_write_cache) {
777 flags |= BDRV_REQ_FUA;
778 }
779
780 return bdrv_co_pwritev(blk_bs(blk), offset, bytes, qiov, flags);
781 }
782
783 typedef struct BlkRwCo {
784 BlockBackend *blk;
785 int64_t offset;
786 QEMUIOVector *qiov;
787 int ret;
788 BdrvRequestFlags flags;
789 } BlkRwCo;
790
791 static void blk_read_entry(void *opaque)
792 {
793 BlkRwCo *rwco = opaque;
794
795 rwco->ret = blk_co_preadv(rwco->blk, rwco->offset, rwco->qiov->size,
796 rwco->qiov, rwco->flags);
797 }
798
799 static void blk_write_entry(void *opaque)
800 {
801 BlkRwCo *rwco = opaque;
802
803 rwco->ret = blk_co_pwritev(rwco->blk, rwco->offset, rwco->qiov->size,
804 rwco->qiov, rwco->flags);
805 }
806
807 static int blk_prw(BlockBackend *blk, int64_t offset, uint8_t *buf,
808 int64_t bytes, CoroutineEntry co_entry,
809 BdrvRequestFlags flags)
810 {
811 AioContext *aio_context;
812 QEMUIOVector qiov;
813 struct iovec iov;
814 Coroutine *co;
815 BlkRwCo rwco;
816
817 iov = (struct iovec) {
818 .iov_base = buf,
819 .iov_len = bytes,
820 };
821 qemu_iovec_init_external(&qiov, &iov, 1);
822
823 rwco = (BlkRwCo) {
824 .blk = blk,
825 .offset = offset,
826 .qiov = &qiov,
827 .flags = flags,
828 .ret = NOT_DONE,
829 };
830
831 co = qemu_coroutine_create(co_entry);
832 qemu_coroutine_enter(co, &rwco);
833
834 aio_context = blk_get_aio_context(blk);
835 while (rwco.ret == NOT_DONE) {
836 aio_poll(aio_context, true);
837 }
838
839 return rwco.ret;
840 }
841
842 int blk_pread_unthrottled(BlockBackend *blk, int64_t offset, uint8_t *buf,
843 int count)
844 {
845 int ret;
846
847 ret = blk_check_byte_request(blk, offset, count);
848 if (ret < 0) {
849 return ret;
850 }
851
852 blk_root_drained_begin(blk->root);
853 ret = blk_pread(blk, offset, buf, count);
854 blk_root_drained_end(blk->root);
855 return ret;
856 }
857
858 int blk_pwrite_zeroes(BlockBackend *blk, int64_t offset,
859 int count, BdrvRequestFlags flags)
860 {
861 return blk_prw(blk, offset, NULL, count, blk_write_entry,
862 flags | BDRV_REQ_ZERO_WRITE);
863 }
864
865 static void error_callback_bh(void *opaque)
866 {
867 struct BlockBackendAIOCB *acb = opaque;
868 qemu_bh_delete(acb->bh);
869 acb->common.cb(acb->common.opaque, acb->ret);
870 qemu_aio_unref(acb);
871 }
872
873 BlockAIOCB *blk_abort_aio_request(BlockBackend *blk,
874 BlockCompletionFunc *cb,
875 void *opaque, int ret)
876 {
877 struct BlockBackendAIOCB *acb;
878 QEMUBH *bh;
879
880 acb = blk_aio_get(&block_backend_aiocb_info, blk, cb, opaque);
881 acb->blk = blk;
882 acb->ret = ret;
883
884 bh = aio_bh_new(blk_get_aio_context(blk), error_callback_bh, acb);
885 acb->bh = bh;
886 qemu_bh_schedule(bh);
887
888 return &acb->common;
889 }
890
891 typedef struct BlkAioEmAIOCB {
892 BlockAIOCB common;
893 BlkRwCo rwco;
894 int bytes;
895 bool has_returned;
896 QEMUBH* bh;
897 } BlkAioEmAIOCB;
898
899 static const AIOCBInfo blk_aio_em_aiocb_info = {
900 .aiocb_size = sizeof(BlkAioEmAIOCB),
901 };
902
903 static void blk_aio_complete(BlkAioEmAIOCB *acb)
904 {
905 if (acb->bh) {
906 assert(acb->has_returned);
907 qemu_bh_delete(acb->bh);
908 }
909 if (acb->has_returned) {
910 acb->common.cb(acb->common.opaque, acb->rwco.ret);
911 qemu_aio_unref(acb);
912 }
913 }
914
915 static void blk_aio_complete_bh(void *opaque)
916 {
917 blk_aio_complete(opaque);
918 }
919
920 static BlockAIOCB *blk_aio_prwv(BlockBackend *blk, int64_t offset, int bytes,
921 QEMUIOVector *qiov, CoroutineEntry co_entry,
922 BdrvRequestFlags flags,
923 BlockCompletionFunc *cb, void *opaque)
924 {
925 BlkAioEmAIOCB *acb;
926 Coroutine *co;
927
928 acb = blk_aio_get(&blk_aio_em_aiocb_info, blk, cb, opaque);
929 acb->rwco = (BlkRwCo) {
930 .blk = blk,
931 .offset = offset,
932 .qiov = qiov,
933 .flags = flags,
934 .ret = NOT_DONE,
935 };
936 acb->bytes = bytes;
937 acb->bh = NULL;
938 acb->has_returned = false;
939
940 co = qemu_coroutine_create(co_entry);
941 qemu_coroutine_enter(co, acb);
942
943 acb->has_returned = true;
944 if (acb->rwco.ret != NOT_DONE) {
945 acb->bh = aio_bh_new(blk_get_aio_context(blk), blk_aio_complete_bh, acb);
946 qemu_bh_schedule(acb->bh);
947 }
948
949 return &acb->common;
950 }
951
952 static void blk_aio_read_entry(void *opaque)
953 {
954 BlkAioEmAIOCB *acb = opaque;
955 BlkRwCo *rwco = &acb->rwco;
956
957 assert(rwco->qiov->size == acb->bytes);
958 rwco->ret = blk_co_preadv(rwco->blk, rwco->offset, acb->bytes,
959 rwco->qiov, rwco->flags);
960 blk_aio_complete(acb);
961 }
962
963 static void blk_aio_write_entry(void *opaque)
964 {
965 BlkAioEmAIOCB *acb = opaque;
966 BlkRwCo *rwco = &acb->rwco;
967
968 assert(!rwco->qiov || rwco->qiov->size == acb->bytes);
969 rwco->ret = blk_co_pwritev(rwco->blk, rwco->offset, acb->bytes,
970 rwco->qiov, rwco->flags);
971 blk_aio_complete(acb);
972 }
973
974 BlockAIOCB *blk_aio_pwrite_zeroes(BlockBackend *blk, int64_t offset,
975 int count, BdrvRequestFlags flags,
976 BlockCompletionFunc *cb, void *opaque)
977 {
978 return blk_aio_prwv(blk, offset, count, NULL, blk_aio_write_entry,
979 flags | BDRV_REQ_ZERO_WRITE, cb, opaque);
980 }
981
982 int blk_pread(BlockBackend *blk, int64_t offset, void *buf, int count)
983 {
984 int ret = blk_prw(blk, offset, buf, count, blk_read_entry, 0);
985 if (ret < 0) {
986 return ret;
987 }
988 return count;
989 }
990
991 int blk_pwrite(BlockBackend *blk, int64_t offset, const void *buf, int count,
992 BdrvRequestFlags flags)
993 {
994 int ret = blk_prw(blk, offset, (void *) buf, count, blk_write_entry,
995 flags);
996 if (ret < 0) {
997 return ret;
998 }
999 return count;
1000 }
1001
1002 int64_t blk_getlength(BlockBackend *blk)
1003 {
1004 if (!blk_is_available(blk)) {
1005 return -ENOMEDIUM;
1006 }
1007
1008 return bdrv_getlength(blk_bs(blk));
1009 }
1010
1011 void blk_get_geometry(BlockBackend *blk, uint64_t *nb_sectors_ptr)
1012 {
1013 if (!blk_bs(blk)) {
1014 *nb_sectors_ptr = 0;
1015 } else {
1016 bdrv_get_geometry(blk_bs(blk), nb_sectors_ptr);
1017 }
1018 }
1019
1020 int64_t blk_nb_sectors(BlockBackend *blk)
1021 {
1022 if (!blk_is_available(blk)) {
1023 return -ENOMEDIUM;
1024 }
1025
1026 return bdrv_nb_sectors(blk_bs(blk));
1027 }
1028
1029 BlockAIOCB *blk_aio_preadv(BlockBackend *blk, int64_t offset,
1030 QEMUIOVector *qiov, BdrvRequestFlags flags,
1031 BlockCompletionFunc *cb, void *opaque)
1032 {
1033 return blk_aio_prwv(blk, offset, qiov->size, qiov,
1034 blk_aio_read_entry, flags, cb, opaque);
1035 }
1036
1037 BlockAIOCB *blk_aio_pwritev(BlockBackend *blk, int64_t offset,
1038 QEMUIOVector *qiov, BdrvRequestFlags flags,
1039 BlockCompletionFunc *cb, void *opaque)
1040 {
1041 return blk_aio_prwv(blk, offset, qiov->size, qiov,
1042 blk_aio_write_entry, flags, cb, opaque);
1043 }
1044
1045 BlockAIOCB *blk_aio_flush(BlockBackend *blk,
1046 BlockCompletionFunc *cb, void *opaque)
1047 {
1048 if (!blk_is_available(blk)) {
1049 return blk_abort_aio_request(blk, cb, opaque, -ENOMEDIUM);
1050 }
1051
1052 return bdrv_aio_flush(blk_bs(blk), cb, opaque);
1053 }
1054
1055 BlockAIOCB *blk_aio_discard(BlockBackend *blk,
1056 int64_t sector_num, int nb_sectors,
1057 BlockCompletionFunc *cb, void *opaque)
1058 {
1059 int ret = blk_check_request(blk, sector_num, nb_sectors);
1060 if (ret < 0) {
1061 return blk_abort_aio_request(blk, cb, opaque, ret);
1062 }
1063
1064 return bdrv_aio_discard(blk_bs(blk), sector_num, nb_sectors, cb, opaque);
1065 }
1066
1067 void blk_aio_cancel(BlockAIOCB *acb)
1068 {
1069 bdrv_aio_cancel(acb);
1070 }
1071
1072 void blk_aio_cancel_async(BlockAIOCB *acb)
1073 {
1074 bdrv_aio_cancel_async(acb);
1075 }
1076
1077 int blk_ioctl(BlockBackend *blk, unsigned long int req, void *buf)
1078 {
1079 if (!blk_is_available(blk)) {
1080 return -ENOMEDIUM;
1081 }
1082
1083 return bdrv_ioctl(blk_bs(blk), req, buf);
1084 }
1085
1086 BlockAIOCB *blk_aio_ioctl(BlockBackend *blk, unsigned long int req, void *buf,
1087 BlockCompletionFunc *cb, void *opaque)
1088 {
1089 if (!blk_is_available(blk)) {
1090 return blk_abort_aio_request(blk, cb, opaque, -ENOMEDIUM);
1091 }
1092
1093 return bdrv_aio_ioctl(blk_bs(blk), req, buf, cb, opaque);
1094 }
1095
1096 int blk_co_discard(BlockBackend *blk, int64_t sector_num, int nb_sectors)
1097 {
1098 int ret = blk_check_request(blk, sector_num, nb_sectors);
1099 if (ret < 0) {
1100 return ret;
1101 }
1102
1103 return bdrv_co_discard(blk_bs(blk), sector_num, nb_sectors);
1104 }
1105
1106 int blk_co_flush(BlockBackend *blk)
1107 {
1108 if (!blk_is_available(blk)) {
1109 return -ENOMEDIUM;
1110 }
1111
1112 return bdrv_co_flush(blk_bs(blk));
1113 }
1114
1115 int blk_flush(BlockBackend *blk)
1116 {
1117 if (!blk_is_available(blk)) {
1118 return -ENOMEDIUM;
1119 }
1120
1121 return bdrv_flush(blk_bs(blk));
1122 }
1123
1124 void blk_drain(BlockBackend *blk)
1125 {
1126 if (blk_bs(blk)) {
1127 bdrv_drain(blk_bs(blk));
1128 }
1129 }
1130
1131 void blk_drain_all(void)
1132 {
1133 bdrv_drain_all();
1134 }
1135
1136 void blk_set_on_error(BlockBackend *blk, BlockdevOnError on_read_error,
1137 BlockdevOnError on_write_error)
1138 {
1139 blk->on_read_error = on_read_error;
1140 blk->on_write_error = on_write_error;
1141 }
1142
1143 BlockdevOnError blk_get_on_error(BlockBackend *blk, bool is_read)
1144 {
1145 return is_read ? blk->on_read_error : blk->on_write_error;
1146 }
1147
1148 BlockErrorAction blk_get_error_action(BlockBackend *blk, bool is_read,
1149 int error)
1150 {
1151 BlockdevOnError on_err = blk_get_on_error(blk, is_read);
1152
1153 switch (on_err) {
1154 case BLOCKDEV_ON_ERROR_ENOSPC:
1155 return (error == ENOSPC) ?
1156 BLOCK_ERROR_ACTION_STOP : BLOCK_ERROR_ACTION_REPORT;
1157 case BLOCKDEV_ON_ERROR_STOP:
1158 return BLOCK_ERROR_ACTION_STOP;
1159 case BLOCKDEV_ON_ERROR_REPORT:
1160 return BLOCK_ERROR_ACTION_REPORT;
1161 case BLOCKDEV_ON_ERROR_IGNORE:
1162 return BLOCK_ERROR_ACTION_IGNORE;
1163 default:
1164 abort();
1165 }
1166 }
1167
1168 static void send_qmp_error_event(BlockBackend *blk,
1169 BlockErrorAction action,
1170 bool is_read, int error)
1171 {
1172 IoOperationType optype;
1173
1174 optype = is_read ? IO_OPERATION_TYPE_READ : IO_OPERATION_TYPE_WRITE;
1175 qapi_event_send_block_io_error(blk_name(blk), optype, action,
1176 blk_iostatus_is_enabled(blk),
1177 error == ENOSPC, strerror(error),
1178 &error_abort);
1179 }
1180
1181 /* This is done by device models because, while the block layer knows
1182 * about the error, it does not know whether an operation comes from
1183 * the device or the block layer (from a job, for example).
1184 */
1185 void blk_error_action(BlockBackend *blk, BlockErrorAction action,
1186 bool is_read, int error)
1187 {
1188 assert(error >= 0);
1189
1190 if (action == BLOCK_ERROR_ACTION_STOP) {
1191 /* First set the iostatus, so that "info block" returns an iostatus
1192 * that matches the events raised so far (an additional error iostatus
1193 * is fine, but not a lost one).
1194 */
1195 blk_iostatus_set_err(blk, error);
1196
1197 /* Then raise the request to stop the VM and the event.
1198 * qemu_system_vmstop_request_prepare has two effects. First,
1199 * it ensures that the STOP event always comes after the
1200 * BLOCK_IO_ERROR event. Second, it ensures that even if management
1201 * can observe the STOP event and do a "cont" before the STOP
1202 * event is issued, the VM will not stop. In this case, vm_start()
1203 * also ensures that the STOP/RESUME pair of events is emitted.
1204 */
1205 qemu_system_vmstop_request_prepare();
1206 send_qmp_error_event(blk, action, is_read, error);
1207 qemu_system_vmstop_request(RUN_STATE_IO_ERROR);
1208 } else {
1209 send_qmp_error_event(blk, action, is_read, error);
1210 }
1211 }
1212
1213 int blk_is_read_only(BlockBackend *blk)
1214 {
1215 BlockDriverState *bs = blk_bs(blk);
1216
1217 if (bs) {
1218 return bdrv_is_read_only(bs);
1219 } else {
1220 return blk->root_state.read_only;
1221 }
1222 }
1223
1224 int blk_is_sg(BlockBackend *blk)
1225 {
1226 BlockDriverState *bs = blk_bs(blk);
1227
1228 if (!bs) {
1229 return 0;
1230 }
1231
1232 return bdrv_is_sg(bs);
1233 }
1234
1235 int blk_enable_write_cache(BlockBackend *blk)
1236 {
1237 return blk->enable_write_cache;
1238 }
1239
1240 void blk_set_enable_write_cache(BlockBackend *blk, bool wce)
1241 {
1242 blk->enable_write_cache = wce;
1243 }
1244
1245 void blk_invalidate_cache(BlockBackend *blk, Error **errp)
1246 {
1247 BlockDriverState *bs = blk_bs(blk);
1248
1249 if (!bs) {
1250 error_setg(errp, "Device '%s' has no medium", blk->name);
1251 return;
1252 }
1253
1254 bdrv_invalidate_cache(bs, errp);
1255 }
1256
1257 bool blk_is_inserted(BlockBackend *blk)
1258 {
1259 BlockDriverState *bs = blk_bs(blk);
1260
1261 return bs && bdrv_is_inserted(bs);
1262 }
1263
1264 bool blk_is_available(BlockBackend *blk)
1265 {
1266 return blk_is_inserted(blk) && !blk_dev_is_tray_open(blk);
1267 }
1268
1269 void blk_lock_medium(BlockBackend *blk, bool locked)
1270 {
1271 BlockDriverState *bs = blk_bs(blk);
1272
1273 if (bs) {
1274 bdrv_lock_medium(bs, locked);
1275 }
1276 }
1277
1278 void blk_eject(BlockBackend *blk, bool eject_flag)
1279 {
1280 BlockDriverState *bs = blk_bs(blk);
1281
1282 if (bs) {
1283 bdrv_eject(bs, eject_flag);
1284 }
1285 }
1286
1287 int blk_get_flags(BlockBackend *blk)
1288 {
1289 BlockDriverState *bs = blk_bs(blk);
1290
1291 if (bs) {
1292 return bdrv_get_flags(bs);
1293 } else {
1294 return blk->root_state.open_flags;
1295 }
1296 }
1297
1298 int blk_get_max_transfer_length(BlockBackend *blk)
1299 {
1300 BlockDriverState *bs = blk_bs(blk);
1301
1302 if (bs) {
1303 return bs->bl.max_transfer_length;
1304 } else {
1305 return 0;
1306 }
1307 }
1308
1309 int blk_get_max_iov(BlockBackend *blk)
1310 {
1311 return blk->root->bs->bl.max_iov;
1312 }
1313
1314 void blk_set_guest_block_size(BlockBackend *blk, int align)
1315 {
1316 blk->guest_block_size = align;
1317 }
1318
1319 void *blk_try_blockalign(BlockBackend *blk, size_t size)
1320 {
1321 return qemu_try_blockalign(blk ? blk_bs(blk) : NULL, size);
1322 }
1323
1324 void *blk_blockalign(BlockBackend *blk, size_t size)
1325 {
1326 return qemu_blockalign(blk ? blk_bs(blk) : NULL, size);
1327 }
1328
1329 bool blk_op_is_blocked(BlockBackend *blk, BlockOpType op, Error **errp)
1330 {
1331 BlockDriverState *bs = blk_bs(blk);
1332
1333 if (!bs) {
1334 return false;
1335 }
1336
1337 return bdrv_op_is_blocked(bs, op, errp);
1338 }
1339
1340 void blk_op_unblock(BlockBackend *blk, BlockOpType op, Error *reason)
1341 {
1342 BlockDriverState *bs = blk_bs(blk);
1343
1344 if (bs) {
1345 bdrv_op_unblock(bs, op, reason);
1346 }
1347 }
1348
1349 void blk_op_block_all(BlockBackend *blk, Error *reason)
1350 {
1351 BlockDriverState *bs = blk_bs(blk);
1352
1353 if (bs) {
1354 bdrv_op_block_all(bs, reason);
1355 }
1356 }
1357
1358 void blk_op_unblock_all(BlockBackend *blk, Error *reason)
1359 {
1360 BlockDriverState *bs = blk_bs(blk);
1361
1362 if (bs) {
1363 bdrv_op_unblock_all(bs, reason);
1364 }
1365 }
1366
1367 AioContext *blk_get_aio_context(BlockBackend *blk)
1368 {
1369 BlockDriverState *bs = blk_bs(blk);
1370
1371 if (bs) {
1372 return bdrv_get_aio_context(bs);
1373 } else {
1374 return qemu_get_aio_context();
1375 }
1376 }
1377
1378 static AioContext *blk_aiocb_get_aio_context(BlockAIOCB *acb)
1379 {
1380 BlockBackendAIOCB *blk_acb = DO_UPCAST(BlockBackendAIOCB, common, acb);
1381 return blk_get_aio_context(blk_acb->blk);
1382 }
1383
1384 void blk_set_aio_context(BlockBackend *blk, AioContext *new_context)
1385 {
1386 BlockDriverState *bs = blk_bs(blk);
1387
1388 if (bs) {
1389 if (blk->public.throttle_state) {
1390 throttle_timers_detach_aio_context(&blk->public.throttle_timers);
1391 }
1392 bdrv_set_aio_context(bs, new_context);
1393 if (blk->public.throttle_state) {
1394 throttle_timers_attach_aio_context(&blk->public.throttle_timers,
1395 new_context);
1396 }
1397 }
1398 }
1399
1400 void blk_add_aio_context_notifier(BlockBackend *blk,
1401 void (*attached_aio_context)(AioContext *new_context, void *opaque),
1402 void (*detach_aio_context)(void *opaque), void *opaque)
1403 {
1404 BlockDriverState *bs = blk_bs(blk);
1405
1406 if (bs) {
1407 bdrv_add_aio_context_notifier(bs, attached_aio_context,
1408 detach_aio_context, opaque);
1409 }
1410 }
1411
1412 void blk_remove_aio_context_notifier(BlockBackend *blk,
1413 void (*attached_aio_context)(AioContext *,
1414 void *),
1415 void (*detach_aio_context)(void *),
1416 void *opaque)
1417 {
1418 BlockDriverState *bs = blk_bs(blk);
1419
1420 if (bs) {
1421 bdrv_remove_aio_context_notifier(bs, attached_aio_context,
1422 detach_aio_context, opaque);
1423 }
1424 }
1425
1426 void blk_add_remove_bs_notifier(BlockBackend *blk, Notifier *notify)
1427 {
1428 notifier_list_add(&blk->remove_bs_notifiers, notify);
1429 }
1430
1431 void blk_add_insert_bs_notifier(BlockBackend *blk, Notifier *notify)
1432 {
1433 notifier_list_add(&blk->insert_bs_notifiers, notify);
1434 }
1435
1436 void blk_io_plug(BlockBackend *blk)
1437 {
1438 BlockDriverState *bs = blk_bs(blk);
1439
1440 if (bs) {
1441 bdrv_io_plug(bs);
1442 }
1443 }
1444
1445 void blk_io_unplug(BlockBackend *blk)
1446 {
1447 BlockDriverState *bs = blk_bs(blk);
1448
1449 if (bs) {
1450 bdrv_io_unplug(bs);
1451 }
1452 }
1453
1454 BlockAcctStats *blk_get_stats(BlockBackend *blk)
1455 {
1456 return &blk->stats;
1457 }
1458
1459 void *blk_aio_get(const AIOCBInfo *aiocb_info, BlockBackend *blk,
1460 BlockCompletionFunc *cb, void *opaque)
1461 {
1462 return qemu_aio_get(aiocb_info, blk_bs(blk), cb, opaque);
1463 }
1464
1465 int coroutine_fn blk_co_pwrite_zeroes(BlockBackend *blk, int64_t offset,
1466 int count, BdrvRequestFlags flags)
1467 {
1468 return blk_co_pwritev(blk, offset, count, NULL,
1469 flags | BDRV_REQ_ZERO_WRITE);
1470 }
1471
1472 int blk_write_compressed(BlockBackend *blk, int64_t sector_num,
1473 const uint8_t *buf, int nb_sectors)
1474 {
1475 int ret = blk_check_request(blk, sector_num, nb_sectors);
1476 if (ret < 0) {
1477 return ret;
1478 }
1479
1480 return bdrv_write_compressed(blk_bs(blk), sector_num, buf, nb_sectors);
1481 }
1482
1483 int blk_truncate(BlockBackend *blk, int64_t offset)
1484 {
1485 if (!blk_is_available(blk)) {
1486 return -ENOMEDIUM;
1487 }
1488
1489 return bdrv_truncate(blk_bs(blk), offset);
1490 }
1491
1492 int blk_discard(BlockBackend *blk, int64_t sector_num, int nb_sectors)
1493 {
1494 int ret = blk_check_request(blk, sector_num, nb_sectors);
1495 if (ret < 0) {
1496 return ret;
1497 }
1498
1499 return bdrv_discard(blk_bs(blk), sector_num, nb_sectors);
1500 }
1501
1502 int blk_save_vmstate(BlockBackend *blk, const uint8_t *buf,
1503 int64_t pos, int size)
1504 {
1505 int ret;
1506
1507 if (!blk_is_available(blk)) {
1508 return -ENOMEDIUM;
1509 }
1510
1511 ret = bdrv_save_vmstate(blk_bs(blk), buf, pos, size);
1512 if (ret < 0) {
1513 return ret;
1514 }
1515
1516 if (ret == size && !blk->enable_write_cache) {
1517 ret = bdrv_flush(blk_bs(blk));
1518 }
1519
1520 return ret < 0 ? ret : size;
1521 }
1522
1523 int blk_load_vmstate(BlockBackend *blk, uint8_t *buf, int64_t pos, int size)
1524 {
1525 if (!blk_is_available(blk)) {
1526 return -ENOMEDIUM;
1527 }
1528
1529 return bdrv_load_vmstate(blk_bs(blk), buf, pos, size);
1530 }
1531
1532 int blk_probe_blocksizes(BlockBackend *blk, BlockSizes *bsz)
1533 {
1534 if (!blk_is_available(blk)) {
1535 return -ENOMEDIUM;
1536 }
1537
1538 return bdrv_probe_blocksizes(blk_bs(blk), bsz);
1539 }
1540
1541 int blk_probe_geometry(BlockBackend *blk, HDGeometry *geo)
1542 {
1543 if (!blk_is_available(blk)) {
1544 return -ENOMEDIUM;
1545 }
1546
1547 return bdrv_probe_geometry(blk_bs(blk), geo);
1548 }
1549
1550 /*
1551 * Updates the BlockBackendRootState object with data from the currently
1552 * attached BlockDriverState.
1553 */
1554 void blk_update_root_state(BlockBackend *blk)
1555 {
1556 assert(blk->root);
1557
1558 blk->root_state.open_flags = blk->root->bs->open_flags;
1559 blk->root_state.read_only = blk->root->bs->read_only;
1560 blk->root_state.detect_zeroes = blk->root->bs->detect_zeroes;
1561 }
1562
1563 /*
1564 * Applies the information in the root state to the given BlockDriverState. This
1565 * does not include the flags which have to be specified for bdrv_open(), use
1566 * blk_get_open_flags_from_root_state() to inquire them.
1567 */
1568 void blk_apply_root_state(BlockBackend *blk, BlockDriverState *bs)
1569 {
1570 bs->detect_zeroes = blk->root_state.detect_zeroes;
1571 }
1572
1573 /*
1574 * Returns the flags to be used for bdrv_open() of a BlockDriverState which is
1575 * supposed to inherit the root state.
1576 */
1577 int blk_get_open_flags_from_root_state(BlockBackend *blk)
1578 {
1579 int bs_flags;
1580
1581 bs_flags = blk->root_state.read_only ? 0 : BDRV_O_RDWR;
1582 bs_flags |= blk->root_state.open_flags & ~BDRV_O_RDWR;
1583
1584 return bs_flags;
1585 }
1586
1587 BlockBackendRootState *blk_get_root_state(BlockBackend *blk)
1588 {
1589 return &blk->root_state;
1590 }
1591
1592 int blk_commit_all(void)
1593 {
1594 BlockBackend *blk = NULL;
1595
1596 while ((blk = blk_all_next(blk)) != NULL) {
1597 AioContext *aio_context = blk_get_aio_context(blk);
1598
1599 aio_context_acquire(aio_context);
1600 if (blk_is_inserted(blk) && blk->root->bs->backing) {
1601 int ret = bdrv_commit(blk->root->bs);
1602 if (ret < 0) {
1603 aio_context_release(aio_context);
1604 return ret;
1605 }
1606 }
1607 aio_context_release(aio_context);
1608 }
1609 return 0;
1610 }
1611
1612 int blk_flush_all(void)
1613 {
1614 BlockBackend *blk = NULL;
1615 int result = 0;
1616
1617 while ((blk = blk_all_next(blk)) != NULL) {
1618 AioContext *aio_context = blk_get_aio_context(blk);
1619 int ret;
1620
1621 aio_context_acquire(aio_context);
1622 if (blk_is_inserted(blk)) {
1623 ret = blk_flush(blk);
1624 if (ret < 0 && !result) {
1625 result = ret;
1626 }
1627 }
1628 aio_context_release(aio_context);
1629 }
1630
1631 return result;
1632 }
1633
1634
1635 /* throttling disk I/O limits */
1636 void blk_set_io_limits(BlockBackend *blk, ThrottleConfig *cfg)
1637 {
1638 throttle_group_config(blk, cfg);
1639 }
1640
1641 void blk_io_limits_disable(BlockBackend *blk)
1642 {
1643 assert(blk->public.throttle_state);
1644 bdrv_drained_begin(blk_bs(blk));
1645 throttle_group_unregister_blk(blk);
1646 bdrv_drained_end(blk_bs(blk));
1647 }
1648
1649 /* should be called before blk_set_io_limits if a limit is set */
1650 void blk_io_limits_enable(BlockBackend *blk, const char *group)
1651 {
1652 assert(!blk->public.throttle_state);
1653 throttle_group_register_blk(blk, group);
1654 }
1655
1656 void blk_io_limits_update_group(BlockBackend *blk, const char *group)
1657 {
1658 /* this BB is not part of any group */
1659 if (!blk->public.throttle_state) {
1660 return;
1661 }
1662
1663 /* this BB is a part of the same group than the one we want */
1664 if (!g_strcmp0(throttle_group_get_name(blk), group)) {
1665 return;
1666 }
1667
1668 /* need to change the group this bs belong to */
1669 blk_io_limits_disable(blk);
1670 blk_io_limits_enable(blk, group);
1671 }
1672
1673 static void blk_root_drained_begin(BdrvChild *child)
1674 {
1675 BlockBackend *blk = child->opaque;
1676
1677 /* Note that blk->root may not be accessible here yet if we are just
1678 * attaching to a BlockDriverState that is drained. Use child instead. */
1679
1680 if (blk->public.io_limits_disabled++ == 0) {
1681 throttle_group_restart_blk(blk);
1682 }
1683 }
1684
1685 static void blk_root_drained_end(BdrvChild *child)
1686 {
1687 BlockBackend *blk = child->opaque;
1688
1689 assert(blk->public.io_limits_disabled);
1690 --blk->public.io_limits_disabled;
1691 }