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