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