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