1#ifndef BLOCK_H
2#define BLOCK_H
3
4#include "block/aio.h"
5#include "block/aio-wait.h"
6#include "qemu/iov.h"
7#include "qemu/coroutine.h"
8#include "block/accounting.h"
9#include "block/dirty-bitmap.h"
10#include "block/blockjob.h"
11#include "qemu/hbitmap.h"
12
13
14
15
16
17
18
19
20
21#define generated_co_wrapper
22
23
24typedef struct BlockDriver BlockDriver;
25typedef struct BdrvChild BdrvChild;
26typedef struct BdrvChildClass BdrvChildClass;
27
28typedef struct BlockDriverInfo {
29
30 int cluster_size;
31
32 int64_t vm_state_offset;
33 bool is_dirty;
34
35
36
37 bool needs_compressed_writes;
38} BlockDriverInfo;
39
40typedef struct BlockFragInfo {
41 uint64_t allocated_clusters;
42 uint64_t total_clusters;
43 uint64_t fragmented_clusters;
44 uint64_t compressed_clusters;
45} BlockFragInfo;
46
47typedef enum {
48 BDRV_REQ_COPY_ON_READ = 0x1,
49 BDRV_REQ_ZERO_WRITE = 0x2,
50
51
52
53
54
55
56
57 BDRV_REQ_MAY_UNMAP = 0x4,
58
59 BDRV_REQ_FUA = 0x10,
60 BDRV_REQ_WRITE_COMPRESSED = 0x20,
61
62
63
64 BDRV_REQ_WRITE_UNCHANGED = 0x40,
65
66
67 BDRV_REQ_SERIALISING = 0x80,
68
69
70
71
72 BDRV_REQ_NO_FALLBACK = 0x100,
73
74
75
76
77
78
79
80
81 BDRV_REQ_PREFETCH = 0x200,
82
83
84
85
86
87 BDRV_REQ_NO_WAIT = 0x400,
88
89
90 BDRV_REQ_MASK = 0x7ff,
91} BdrvRequestFlags;
92
93typedef struct BlockSizes {
94 uint32_t phys;
95 uint32_t log;
96} BlockSizes;
97
98typedef struct HDGeometry {
99 uint32_t heads;
100 uint32_t sectors;
101 uint32_t cylinders;
102} HDGeometry;
103
104#define BDRV_O_RDWR 0x0002
105#define BDRV_O_RESIZE 0x0004
106#define BDRV_O_SNAPSHOT 0x0008
107#define BDRV_O_TEMPORARY 0x0010
108#define BDRV_O_NOCACHE 0x0020
109#define BDRV_O_NATIVE_AIO 0x0080
110#define BDRV_O_NO_BACKING 0x0100
111#define BDRV_O_NO_FLUSH 0x0200
112#define BDRV_O_COPY_ON_READ 0x0400
113#define BDRV_O_INACTIVE 0x0800
114#define BDRV_O_CHECK 0x1000
115#define BDRV_O_ALLOW_RDWR 0x2000
116#define BDRV_O_UNMAP 0x4000
117#define BDRV_O_PROTOCOL 0x8000
118
119
120#define BDRV_O_NO_IO 0x10000
121#define BDRV_O_AUTO_RDONLY 0x20000
122#define BDRV_O_IO_URING 0x40000
123
124#define BDRV_O_CACHE_MASK (BDRV_O_NOCACHE | BDRV_O_NO_FLUSH)
125
126
127
128
129#define BDRV_OPT_CACHE_WB "cache.writeback"
130#define BDRV_OPT_CACHE_DIRECT "cache.direct"
131#define BDRV_OPT_CACHE_NO_FLUSH "cache.no-flush"
132#define BDRV_OPT_READ_ONLY "read-only"
133#define BDRV_OPT_AUTO_READ_ONLY "auto-read-only"
134#define BDRV_OPT_DISCARD "discard"
135#define BDRV_OPT_FORCE_SHARE "force-share"
136
137
138#define BDRV_SECTOR_BITS 9
139#define BDRV_SECTOR_SIZE (1ULL << BDRV_SECTOR_BITS)
140
141#define BDRV_REQUEST_MAX_SECTORS MIN_CONST(SIZE_MAX >> BDRV_SECTOR_BITS, \
142 INT_MAX >> BDRV_SECTOR_BITS)
143#define BDRV_REQUEST_MAX_BYTES (BDRV_REQUEST_MAX_SECTORS << BDRV_SECTOR_BITS)
144
145
146
147
148
149
150
151
152#define BDRV_MAX_ALIGNMENT (1L << 30)
153#define BDRV_MAX_LENGTH (QEMU_ALIGN_DOWN(INT64_MAX, BDRV_MAX_ALIGNMENT))
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194#define BDRV_BLOCK_DATA 0x01
195#define BDRV_BLOCK_ZERO 0x02
196#define BDRV_BLOCK_OFFSET_VALID 0x04
197#define BDRV_BLOCK_RAW 0x08
198#define BDRV_BLOCK_ALLOCATED 0x10
199#define BDRV_BLOCK_EOF 0x20
200#define BDRV_BLOCK_RECURSE 0x40
201
202typedef QTAILQ_HEAD(BlockReopenQueue, BlockReopenQueueEntry) BlockReopenQueue;
203
204typedef struct BDRVReopenState {
205 BlockDriverState *bs;
206 int flags;
207 BlockdevDetectZeroesOptions detect_zeroes;
208 bool backing_missing;
209 bool replace_backing_bs;
210 BlockDriverState *new_backing_bs;
211 uint64_t perm, shared_perm;
212 QDict *options;
213 QDict *explicit_options;
214 void *opaque;
215} BDRVReopenState;
216
217
218
219
220typedef enum BlockOpType {
221 BLOCK_OP_TYPE_BACKUP_SOURCE,
222 BLOCK_OP_TYPE_BACKUP_TARGET,
223 BLOCK_OP_TYPE_CHANGE,
224 BLOCK_OP_TYPE_COMMIT_SOURCE,
225 BLOCK_OP_TYPE_COMMIT_TARGET,
226 BLOCK_OP_TYPE_DATAPLANE,
227 BLOCK_OP_TYPE_DRIVE_DEL,
228 BLOCK_OP_TYPE_EJECT,
229 BLOCK_OP_TYPE_EXTERNAL_SNAPSHOT,
230 BLOCK_OP_TYPE_INTERNAL_SNAPSHOT,
231 BLOCK_OP_TYPE_INTERNAL_SNAPSHOT_DELETE,
232 BLOCK_OP_TYPE_MIRROR_SOURCE,
233 BLOCK_OP_TYPE_MIRROR_TARGET,
234 BLOCK_OP_TYPE_RESIZE,
235 BLOCK_OP_TYPE_STREAM,
236 BLOCK_OP_TYPE_REPLACE,
237 BLOCK_OP_TYPE_MAX,
238} BlockOpType;
239
240
241enum {
242
243
244
245
246
247
248
249
250
251
252 BLK_PERM_CONSISTENT_READ = 0x01,
253
254
255 BLK_PERM_WRITE = 0x02,
256
257
258
259
260
261
262
263
264
265 BLK_PERM_WRITE_UNCHANGED = 0x04,
266
267
268 BLK_PERM_RESIZE = 0x08,
269
270
271
272
273
274 BLK_PERM_GRAPH_MOD = 0x10,
275
276 BLK_PERM_ALL = 0x1f,
277
278 DEFAULT_PERM_PASSTHROUGH = BLK_PERM_CONSISTENT_READ
279 | BLK_PERM_WRITE
280 | BLK_PERM_WRITE_UNCHANGED
281 | BLK_PERM_RESIZE,
282
283 DEFAULT_PERM_UNCHANGED = BLK_PERM_ALL & ~DEFAULT_PERM_PASSTHROUGH,
284};
285
286
287
288
289
290
291
292
293enum BdrvChildRoleBits {
294
295
296
297
298 BDRV_CHILD_DATA = (1 << 0),
299
300
301
302
303
304
305 BDRV_CHILD_METADATA = (1 << 1),
306
307
308
309
310
311
312
313
314 BDRV_CHILD_FILTERED = (1 << 2),
315
316
317
318
319
320
321
322
323
324 BDRV_CHILD_COW = (1 << 3),
325
326
327
328
329
330
331 BDRV_CHILD_PRIMARY = (1 << 4),
332
333
334 BDRV_CHILD_IMAGE = BDRV_CHILD_DATA
335 | BDRV_CHILD_METADATA
336 | BDRV_CHILD_PRIMARY,
337};
338
339
340typedef unsigned int BdrvChildRole;
341
342char *bdrv_perm_names(uint64_t perm);
343uint64_t bdrv_qapi_perm_to_blk_perm(BlockPermission qapi_perm);
344
345
346void bdrv_init(void);
347void bdrv_init_with_whitelist(void);
348bool bdrv_uses_whitelist(void);
349int bdrv_is_whitelisted(BlockDriver *drv, bool read_only);
350BlockDriver *bdrv_find_protocol(const char *filename,
351 bool allow_protocol_prefix,
352 Error **errp);
353BlockDriver *bdrv_find_format(const char *format_name);
354int bdrv_create(BlockDriver *drv, const char* filename,
355 QemuOpts *opts, Error **errp);
356int bdrv_create_file(const char *filename, QemuOpts *opts, Error **errp);
357
358BlockDriverState *bdrv_new(void);
359int bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top,
360 Error **errp);
361int bdrv_replace_node(BlockDriverState *from, BlockDriverState *to,
362 Error **errp);
363BlockDriverState *bdrv_insert_node(BlockDriverState *bs, QDict *node_options,
364 int flags, Error **errp);
365
366int bdrv_parse_aio(const char *mode, int *flags);
367int bdrv_parse_cache_mode(const char *mode, int *flags, bool *writethrough);
368int bdrv_parse_discard_flags(const char *mode, int *flags);
369BdrvChild *bdrv_open_child(const char *filename,
370 QDict *options, const char *bdref_key,
371 BlockDriverState* parent,
372 const BdrvChildClass *child_class,
373 BdrvChildRole child_role,
374 bool allow_none, Error **errp);
375BlockDriverState *bdrv_open_blockdev_ref(BlockdevRef *ref, Error **errp);
376int bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd,
377 Error **errp);
378int bdrv_open_backing_file(BlockDriverState *bs, QDict *parent_options,
379 const char *bdref_key, Error **errp);
380BlockDriverState *bdrv_open(const char *filename, const char *reference,
381 QDict *options, int flags, Error **errp);
382BlockDriverState *bdrv_new_open_driver(BlockDriver *drv, const char *node_name,
383 int flags, Error **errp);
384BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
385 BlockDriverState *bs, QDict *options,
386 bool keep_old_opts);
387int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp);
388int bdrv_reopen_set_read_only(BlockDriverState *bs, bool read_only,
389 Error **errp);
390int bdrv_reopen_prepare(BDRVReopenState *reopen_state,
391 BlockReopenQueue *queue, Error **errp);
392void bdrv_reopen_commit(BDRVReopenState *reopen_state);
393void bdrv_reopen_abort(BDRVReopenState *reopen_state);
394int bdrv_pwrite_zeroes(BdrvChild *child, int64_t offset,
395 int64_t bytes, BdrvRequestFlags flags);
396int bdrv_make_zero(BdrvChild *child, BdrvRequestFlags flags);
397int bdrv_pread(BdrvChild *child, int64_t offset, void *buf, int64_t bytes);
398int bdrv_pwrite(BdrvChild *child, int64_t offset, const void *buf,
399 int64_t bytes);
400int bdrv_pwrite_sync(BdrvChild *child, int64_t offset,
401 const void *buf, int64_t bytes);
402
403
404
405
406
407
408int coroutine_fn bdrv_co_pwrite_zeroes(BdrvChild *child, int64_t offset,
409 int64_t bytes, BdrvRequestFlags flags);
410BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
411 const char *backing_file);
412void bdrv_refresh_filename(BlockDriverState *bs);
413
414int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact,
415 PreallocMode prealloc, BdrvRequestFlags flags,
416 Error **errp);
417int generated_co_wrapper
418bdrv_truncate(BdrvChild *child, int64_t offset, bool exact,
419 PreallocMode prealloc, BdrvRequestFlags flags, Error **errp);
420
421int64_t bdrv_nb_sectors(BlockDriverState *bs);
422int64_t bdrv_getlength(BlockDriverState *bs);
423int64_t bdrv_get_allocated_file_size(BlockDriverState *bs);
424BlockMeasureInfo *bdrv_measure(BlockDriver *drv, QemuOpts *opts,
425 BlockDriverState *in_bs, Error **errp);
426void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr);
427void bdrv_refresh_limits(BlockDriverState *bs, Error **errp);
428int bdrv_commit(BlockDriverState *bs);
429int bdrv_make_empty(BdrvChild *c, Error **errp);
430int bdrv_change_backing_file(BlockDriverState *bs, const char *backing_file,
431 const char *backing_fmt, bool warn);
432void bdrv_register(BlockDriver *bdrv);
433int bdrv_drop_intermediate(BlockDriverState *top, BlockDriverState *base,
434 const char *backing_file_str);
435BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
436 BlockDriverState *bs);
437BlockDriverState *bdrv_find_base(BlockDriverState *bs);
438bool bdrv_is_backing_chain_frozen(BlockDriverState *bs, BlockDriverState *base,
439 Error **errp);
440int bdrv_freeze_backing_chain(BlockDriverState *bs, BlockDriverState *base,
441 Error **errp);
442void bdrv_unfreeze_backing_chain(BlockDriverState *bs, BlockDriverState *base);
443int coroutine_fn bdrv_co_delete_file(BlockDriverState *bs, Error **errp);
444void coroutine_fn bdrv_co_delete_file_noerr(BlockDriverState *bs);
445
446
447typedef struct BdrvCheckResult {
448 int corruptions;
449 int leaks;
450 int check_errors;
451 int corruptions_fixed;
452 int leaks_fixed;
453 int64_t image_end_offset;
454 BlockFragInfo bfi;
455} BdrvCheckResult;
456
457typedef enum {
458 BDRV_FIX_LEAKS = 1,
459 BDRV_FIX_ERRORS = 2,
460} BdrvCheckMode;
461
462int generated_co_wrapper bdrv_check(BlockDriverState *bs, BdrvCheckResult *res,
463 BdrvCheckMode fix);
464
465
466
467
468typedef void BlockDriverAmendStatusCB(BlockDriverState *bs, int64_t offset,
469 int64_t total_work_size, void *opaque);
470int bdrv_amend_options(BlockDriverState *bs_new, QemuOpts *opts,
471 BlockDriverAmendStatusCB *status_cb, void *cb_opaque,
472 bool force,
473 Error **errp);
474
475
476BlockDriverState *check_to_replace_node(BlockDriverState *parent_bs,
477 const char *node_name, Error **errp);
478
479
480void bdrv_aio_cancel(BlockAIOCB *acb);
481void bdrv_aio_cancel_async(BlockAIOCB *acb);
482
483
484int bdrv_co_ioctl(BlockDriverState *bs, int req, void *buf);
485
486
487int generated_co_wrapper bdrv_invalidate_cache(BlockDriverState *bs,
488 Error **errp);
489void bdrv_invalidate_cache_all(Error **errp);
490int bdrv_inactivate_all(void);
491
492
493int generated_co_wrapper bdrv_flush(BlockDriverState *bs);
494int coroutine_fn bdrv_co_flush(BlockDriverState *bs);
495int bdrv_flush_all(void);
496void bdrv_close_all(void);
497void bdrv_drain(BlockDriverState *bs);
498void coroutine_fn bdrv_co_drain(BlockDriverState *bs);
499void bdrv_drain_all_begin(void);
500void bdrv_drain_all_end(void);
501void bdrv_drain_all(void);
502
503#define BDRV_POLL_WHILE(bs, cond) ({ \
504 BlockDriverState *bs_ = (bs); \
505 AIO_WAIT_WHILE(bdrv_get_aio_context(bs_), \
506 cond); })
507
508int generated_co_wrapper bdrv_pdiscard(BdrvChild *child, int64_t offset,
509 int64_t bytes);
510int bdrv_co_pdiscard(BdrvChild *child, int64_t offset, int64_t bytes);
511int bdrv_has_zero_init_1(BlockDriverState *bs);
512int bdrv_has_zero_init(BlockDriverState *bs);
513bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs);
514int bdrv_block_status(BlockDriverState *bs, int64_t offset,
515 int64_t bytes, int64_t *pnum, int64_t *map,
516 BlockDriverState **file);
517int bdrv_block_status_above(BlockDriverState *bs, BlockDriverState *base,
518 int64_t offset, int64_t bytes, int64_t *pnum,
519 int64_t *map, BlockDriverState **file);
520int bdrv_is_allocated(BlockDriverState *bs, int64_t offset, int64_t bytes,
521 int64_t *pnum);
522int bdrv_is_allocated_above(BlockDriverState *top, BlockDriverState *base,
523 bool include_base, int64_t offset, int64_t bytes,
524 int64_t *pnum);
525int coroutine_fn bdrv_co_is_zero_fast(BlockDriverState *bs, int64_t offset,
526 int64_t bytes);
527
528bool bdrv_is_read_only(BlockDriverState *bs);
529int bdrv_can_set_read_only(BlockDriverState *bs, bool read_only,
530 bool ignore_allow_rdw, Error **errp);
531int bdrv_apply_auto_read_only(BlockDriverState *bs, const char *errmsg,
532 Error **errp);
533bool bdrv_is_writable(BlockDriverState *bs);
534bool bdrv_is_sg(BlockDriverState *bs);
535bool bdrv_is_inserted(BlockDriverState *bs);
536void bdrv_lock_medium(BlockDriverState *bs, bool locked);
537void bdrv_eject(BlockDriverState *bs, bool eject_flag);
538const char *bdrv_get_format_name(BlockDriverState *bs);
539BlockDriverState *bdrv_find_node(const char *node_name);
540BlockDeviceInfoList *bdrv_named_nodes_list(bool flat, Error **errp);
541XDbgBlockGraph *bdrv_get_xdbg_block_graph(Error **errp);
542BlockDriverState *bdrv_lookup_bs(const char *device,
543 const char *node_name,
544 Error **errp);
545bool bdrv_chain_contains(BlockDriverState *top, BlockDriverState *base);
546BlockDriverState *bdrv_next_node(BlockDriverState *bs);
547BlockDriverState *bdrv_next_all_states(BlockDriverState *bs);
548
549typedef struct BdrvNextIterator {
550 enum {
551 BDRV_NEXT_BACKEND_ROOTS,
552 BDRV_NEXT_MONITOR_OWNED,
553 } phase;
554 BlockBackend *blk;
555 BlockDriverState *bs;
556} BdrvNextIterator;
557
558BlockDriverState *bdrv_first(BdrvNextIterator *it);
559BlockDriverState *bdrv_next(BdrvNextIterator *it);
560void bdrv_next_cleanup(BdrvNextIterator *it);
561
562BlockDriverState *bdrv_next_monitor_owned(BlockDriverState *bs);
563bool bdrv_supports_compressed_writes(BlockDriverState *bs);
564void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
565 void *opaque, bool read_only);
566const char *bdrv_get_node_name(const BlockDriverState *bs);
567const char *bdrv_get_device_name(const BlockDriverState *bs);
568const char *bdrv_get_device_or_node_name(const BlockDriverState *bs);
569int bdrv_get_flags(BlockDriverState *bs);
570int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi);
571ImageInfoSpecific *bdrv_get_specific_info(BlockDriverState *bs,
572 Error **errp);
573BlockStatsSpecific *bdrv_get_specific_stats(BlockDriverState *bs);
574void bdrv_round_to_clusters(BlockDriverState *bs,
575 int64_t offset, int64_t bytes,
576 int64_t *cluster_offset,
577 int64_t *cluster_bytes);
578
579void bdrv_get_backing_filename(BlockDriverState *bs,
580 char *filename, int filename_size);
581char *bdrv_get_full_backing_filename(BlockDriverState *bs, Error **errp);
582char *bdrv_get_full_backing_filename_from_filename(const char *backed,
583 const char *backing,
584 Error **errp);
585char *bdrv_dirname(BlockDriverState *bs, Error **errp);
586
587int path_has_protocol(const char *path);
588int path_is_absolute(const char *path);
589char *path_combine(const char *base_path, const char *filename);
590
591int generated_co_wrapper
592bdrv_readv_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos);
593int generated_co_wrapper
594bdrv_writev_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos);
595int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
596 int64_t pos, int size);
597
598int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,
599 int64_t pos, int size);
600
601void bdrv_img_create(const char *filename, const char *fmt,
602 const char *base_filename, const char *base_fmt,
603 char *options, uint64_t img_size, int flags,
604 bool quiet, Error **errp);
605
606
607
608size_t bdrv_min_mem_align(BlockDriverState *bs);
609
610size_t bdrv_opt_mem_align(BlockDriverState *bs);
611void *qemu_blockalign(BlockDriverState *bs, size_t size);
612void *qemu_blockalign0(BlockDriverState *bs, size_t size);
613void *qemu_try_blockalign(BlockDriverState *bs, size_t size);
614void *qemu_try_blockalign0(BlockDriverState *bs, size_t size);
615bool bdrv_qiov_is_aligned(BlockDriverState *bs, QEMUIOVector *qiov);
616
617void bdrv_enable_copy_on_read(BlockDriverState *bs);
618void bdrv_disable_copy_on_read(BlockDriverState *bs);
619
620void bdrv_ref(BlockDriverState *bs);
621void bdrv_unref(BlockDriverState *bs);
622void bdrv_unref_child(BlockDriverState *parent, BdrvChild *child);
623BdrvChild *bdrv_attach_child(BlockDriverState *parent_bs,
624 BlockDriverState *child_bs,
625 const char *child_name,
626 const BdrvChildClass *child_class,
627 BdrvChildRole child_role,
628 Error **errp);
629
630bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp);
631void bdrv_op_block(BlockDriverState *bs, BlockOpType op, Error *reason);
632void bdrv_op_unblock(BlockDriverState *bs, BlockOpType op, Error *reason);
633void bdrv_op_block_all(BlockDriverState *bs, Error *reason);
634void bdrv_op_unblock_all(BlockDriverState *bs, Error *reason);
635bool bdrv_op_blocker_is_empty(BlockDriverState *bs);
636
637#define BLKDBG_EVENT(child, evt) \
638 do { \
639 if (child) { \
640 bdrv_debug_event(child->bs, evt); \
641 } \
642 } while (0)
643
644void bdrv_debug_event(BlockDriverState *bs, BlkdebugEvent event);
645
646int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event,
647 const char *tag);
648int bdrv_debug_remove_breakpoint(BlockDriverState *bs, const char *tag);
649int bdrv_debug_resume(BlockDriverState *bs, const char *tag);
650bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag);
651
652
653
654
655
656
657AioContext *bdrv_get_aio_context(BlockDriverState *bs);
658
659
660
661
662
663
664
665
666
667
668AioContext *coroutine_fn bdrv_co_enter(BlockDriverState *bs);
669
670
671
672
673
674void coroutine_fn bdrv_co_leave(BlockDriverState *bs, AioContext *old_ctx);
675
676
677
678
679
680
681
682
683void coroutine_fn bdrv_co_lock(BlockDriverState *bs);
684
685
686
687
688void coroutine_fn bdrv_co_unlock(BlockDriverState *bs);
689
690
691
692
693void bdrv_coroutine_enter(BlockDriverState *bs, Coroutine *co);
694
695void bdrv_set_aio_context_ignore(BlockDriverState *bs,
696 AioContext *new_context, GSList **ignore);
697int bdrv_try_set_aio_context(BlockDriverState *bs, AioContext *ctx,
698 Error **errp);
699int bdrv_child_try_set_aio_context(BlockDriverState *bs, AioContext *ctx,
700 BdrvChild *ignore_child, Error **errp);
701bool bdrv_child_can_set_aio_context(BdrvChild *c, AioContext *ctx,
702 GSList **ignore, Error **errp);
703bool bdrv_can_set_aio_context(BlockDriverState *bs, AioContext *ctx,
704 GSList **ignore, Error **errp);
705int bdrv_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz);
706int bdrv_probe_geometry(BlockDriverState *bs, HDGeometry *geo);
707
708void bdrv_io_plug(BlockDriverState *bs);
709void bdrv_io_unplug(BlockDriverState *bs);
710
711
712
713
714
715
716
717void bdrv_parent_drained_begin_single(BdrvChild *c, bool poll);
718
719
720
721
722
723
724
725
726
727void bdrv_parent_drained_end_single(BdrvChild *c);
728
729
730
731
732
733
734
735
736
737
738
739
740
741bool bdrv_drain_poll(BlockDriverState *bs, bool recursive,
742 BdrvChild *ignore_parent, bool ignore_bds_parents);
743
744
745
746
747
748
749
750
751
752
753
754void bdrv_drained_begin(BlockDriverState *bs);
755
756
757
758
759
760
761
762void bdrv_do_drained_begin_quiesce(BlockDriverState *bs,
763 BdrvChild *parent, bool ignore_bds_parents);
764
765
766
767
768
769void bdrv_subtree_drained_begin(BlockDriverState *bs);
770
771
772
773
774
775
776
777
778
779
780
781
782void bdrv_drained_end(BlockDriverState *bs);
783
784
785
786
787
788
789
790
791
792
793
794
795
796void bdrv_drained_end_no_poll(BlockDriverState *bs, int *drained_end_counter);
797
798
799
800
801void bdrv_subtree_drained_end(BlockDriverState *bs);
802
803void bdrv_add_child(BlockDriverState *parent, BlockDriverState *child,
804 Error **errp);
805void bdrv_del_child(BlockDriverState *parent, BdrvChild *child, Error **errp);
806
807bool bdrv_can_store_new_dirty_bitmap(BlockDriverState *bs, const char *name,
808 uint32_t granularity, Error **errp);
809
810
811
812
813
814
815
816
817void bdrv_register_buf(BlockDriverState *bs, void *host, size_t size);
818void bdrv_unregister_buf(BlockDriverState *bs, void *host);
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849int coroutine_fn bdrv_co_copy_range(BdrvChild *src, int64_t src_offset,
850 BdrvChild *dst, int64_t dst_offset,
851 int64_t bytes, BdrvRequestFlags read_flags,
852 BdrvRequestFlags write_flags);
853
854void bdrv_cancel_in_flight(BlockDriverState *bs);
855
856#endif
857