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