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