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