1#ifndef BLOCK_H
2#define BLOCK_H
3
4#include "block/aio.h"
5#include "qemu/iov.h"
6#include "qemu/option.h"
7#include "qemu/coroutine.h"
8#include "block/accounting.h"
9#include "block/dirty-bitmap.h"
10#include "block/blockjob.h"
11#include "qapi/qmp/qobject.h"
12#include "qapi-types.h"
13#include "qemu/hbitmap.h"
14
15
16typedef struct BlockDriver BlockDriver;
17typedef struct BdrvChild BdrvChild;
18typedef struct BdrvChildRole BdrvChildRole;
19
20typedef struct BlockDriverInfo {
21
22 int cluster_size;
23
24 int64_t vm_state_offset;
25 bool is_dirty;
26
27
28
29
30 bool unallocated_blocks_are_zero;
31
32
33
34
35
36
37
38
39
40
41 bool can_write_zeroes_with_unmap;
42
43
44
45 bool needs_compressed_writes;
46} BlockDriverInfo;
47
48typedef struct BlockFragInfo {
49 uint64_t allocated_clusters;
50 uint64_t total_clusters;
51 uint64_t fragmented_clusters;
52 uint64_t compressed_clusters;
53} BlockFragInfo;
54
55typedef enum {
56 BDRV_REQ_COPY_ON_READ = 0x1,
57 BDRV_REQ_ZERO_WRITE = 0x2,
58
59
60
61
62
63
64 BDRV_REQ_MAY_UNMAP = 0x4,
65 BDRV_REQ_NO_SERIALISING = 0x8,
66 BDRV_REQ_FUA = 0x10,
67 BDRV_REQ_WRITE_COMPRESSED = 0x20,
68
69
70 BDRV_REQ_MASK = 0x3f,
71} BdrvRequestFlags;
72
73typedef struct BlockSizes {
74 uint32_t phys;
75 uint32_t log;
76} BlockSizes;
77
78typedef struct HDGeometry {
79 uint32_t heads;
80 uint32_t sectors;
81 uint32_t cylinders;
82} HDGeometry;
83
84#define BDRV_O_RDWR 0x0002
85#define BDRV_O_RESIZE 0x0004
86#define BDRV_O_SNAPSHOT 0x0008
87#define BDRV_O_TEMPORARY 0x0010
88#define BDRV_O_NOCACHE 0x0020
89#define BDRV_O_NATIVE_AIO 0x0080
90#define BDRV_O_NO_BACKING 0x0100
91#define BDRV_O_NO_FLUSH 0x0200
92#define BDRV_O_COPY_ON_READ 0x0400
93#define BDRV_O_INACTIVE 0x0800
94#define BDRV_O_CHECK 0x1000
95#define BDRV_O_ALLOW_RDWR 0x2000
96#define BDRV_O_UNMAP 0x4000
97#define BDRV_O_PROTOCOL 0x8000
98
99
100#define BDRV_O_NO_IO 0x10000
101
102#define BDRV_O_CACHE_MASK (BDRV_O_NOCACHE | BDRV_O_NO_FLUSH)
103
104
105
106
107#define BDRV_OPT_CACHE_WB "cache.writeback"
108#define BDRV_OPT_CACHE_DIRECT "cache.direct"
109#define BDRV_OPT_CACHE_NO_FLUSH "cache.no-flush"
110#define BDRV_OPT_READ_ONLY "read-only"
111#define BDRV_OPT_DISCARD "discard"
112#define BDRV_OPT_FORCE_SHARE "force-share"
113
114
115#define BDRV_SECTOR_BITS 9
116#define BDRV_SECTOR_SIZE (1ULL << BDRV_SECTOR_BITS)
117#define BDRV_SECTOR_MASK ~(BDRV_SECTOR_SIZE - 1)
118
119#define BDRV_REQUEST_MAX_SECTORS MIN(SIZE_MAX >> BDRV_SECTOR_BITS, \
120 INT_MAX >> BDRV_SECTOR_BITS)
121#define BDRV_REQUEST_MAX_BYTES (BDRV_REQUEST_MAX_SECTORS << BDRV_SECTOR_BITS)
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156#define BDRV_BLOCK_DATA 0x01
157#define BDRV_BLOCK_ZERO 0x02
158#define BDRV_BLOCK_OFFSET_VALID 0x04
159#define BDRV_BLOCK_RAW 0x08
160#define BDRV_BLOCK_ALLOCATED 0x10
161#define BDRV_BLOCK_EOF 0x20
162#define BDRV_BLOCK_OFFSET_MASK BDRV_SECTOR_MASK
163
164typedef QSIMPLEQ_HEAD(BlockReopenQueue, BlockReopenQueueEntry) BlockReopenQueue;
165
166typedef struct BDRVReopenState {
167 BlockDriverState *bs;
168 int flags;
169 QDict *options;
170 QDict *explicit_options;
171 void *opaque;
172} BDRVReopenState;
173
174
175
176
177typedef enum BlockOpType {
178 BLOCK_OP_TYPE_BACKUP_SOURCE,
179 BLOCK_OP_TYPE_BACKUP_TARGET,
180 BLOCK_OP_TYPE_CHANGE,
181 BLOCK_OP_TYPE_COMMIT_SOURCE,
182 BLOCK_OP_TYPE_COMMIT_TARGET,
183 BLOCK_OP_TYPE_DATAPLANE,
184 BLOCK_OP_TYPE_DRIVE_DEL,
185 BLOCK_OP_TYPE_EJECT,
186 BLOCK_OP_TYPE_EXTERNAL_SNAPSHOT,
187 BLOCK_OP_TYPE_INTERNAL_SNAPSHOT,
188 BLOCK_OP_TYPE_INTERNAL_SNAPSHOT_DELETE,
189 BLOCK_OP_TYPE_MIRROR_SOURCE,
190 BLOCK_OP_TYPE_MIRROR_TARGET,
191 BLOCK_OP_TYPE_RESIZE,
192 BLOCK_OP_TYPE_STREAM,
193 BLOCK_OP_TYPE_REPLACE,
194 BLOCK_OP_TYPE_MAX,
195} BlockOpType;
196
197
198enum {
199
200
201
202
203
204
205
206
207
208
209 BLK_PERM_CONSISTENT_READ = 0x01,
210
211
212 BLK_PERM_WRITE = 0x02,
213
214
215
216
217
218
219 BLK_PERM_WRITE_UNCHANGED = 0x04,
220
221
222 BLK_PERM_RESIZE = 0x08,
223
224
225
226
227
228 BLK_PERM_GRAPH_MOD = 0x10,
229
230 BLK_PERM_ALL = 0x1f,
231};
232
233char *bdrv_perm_names(uint64_t perm);
234
235
236void bdrv_init(void);
237void bdrv_init_with_whitelist(void);
238bool bdrv_uses_whitelist(void);
239BlockDriver *bdrv_find_protocol(const char *filename,
240 bool allow_protocol_prefix,
241 Error **errp);
242BlockDriver *bdrv_find_format(const char *format_name);
243int bdrv_create(BlockDriver *drv, const char* filename,
244 QemuOpts *opts, Error **errp);
245int bdrv_create_file(const char *filename, QemuOpts *opts, Error **errp);
246BlockDriverState *bdrv_new(void);
247void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top,
248 Error **errp);
249void bdrv_replace_node(BlockDriverState *from, BlockDriverState *to,
250 Error **errp);
251
252int bdrv_parse_cache_mode(const char *mode, int *flags, bool *writethrough);
253int bdrv_parse_discard_flags(const char *mode, int *flags);
254BdrvChild *bdrv_open_child(const char *filename,
255 QDict *options, const char *bdref_key,
256 BlockDriverState* parent,
257 const BdrvChildRole *child_role,
258 bool allow_none, Error **errp);
259void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd,
260 Error **errp);
261int bdrv_open_backing_file(BlockDriverState *bs, QDict *parent_options,
262 const char *bdref_key, Error **errp);
263BlockDriverState *bdrv_open(const char *filename, const char *reference,
264 QDict *options, int flags, Error **errp);
265BlockDriverState *bdrv_new_open_driver(BlockDriver *drv, const char *node_name,
266 int flags, Error **errp);
267BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
268 BlockDriverState *bs,
269 QDict *options, int flags);
270int bdrv_reopen_multiple(AioContext *ctx, BlockReopenQueue *bs_queue, Error **errp);
271int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp);
272int bdrv_reopen_prepare(BDRVReopenState *reopen_state,
273 BlockReopenQueue *queue, Error **errp);
274void bdrv_reopen_commit(BDRVReopenState *reopen_state);
275void bdrv_reopen_abort(BDRVReopenState *reopen_state);
276int bdrv_read(BdrvChild *child, int64_t sector_num,
277 uint8_t *buf, int nb_sectors);
278int bdrv_write(BdrvChild *child, int64_t sector_num,
279 const uint8_t *buf, int nb_sectors);
280int bdrv_pwrite_zeroes(BdrvChild *child, int64_t offset,
281 int bytes, BdrvRequestFlags flags);
282int bdrv_make_zero(BdrvChild *child, BdrvRequestFlags flags);
283int bdrv_pread(BdrvChild *child, int64_t offset, void *buf, int bytes);
284int bdrv_preadv(BdrvChild *child, int64_t offset, QEMUIOVector *qiov);
285int bdrv_pwrite(BdrvChild *child, int64_t offset, const void *buf, int bytes);
286int bdrv_pwritev(BdrvChild *child, int64_t offset, QEMUIOVector *qiov);
287int bdrv_pwrite_sync(BdrvChild *child, int64_t offset,
288 const void *buf, int count);
289int coroutine_fn bdrv_co_readv(BdrvChild *child, int64_t sector_num,
290 int nb_sectors, QEMUIOVector *qiov);
291int coroutine_fn bdrv_co_writev(BdrvChild *child, int64_t sector_num,
292 int nb_sectors, QEMUIOVector *qiov);
293
294
295
296
297
298
299int coroutine_fn bdrv_co_pwrite_zeroes(BdrvChild *child, int64_t offset,
300 int bytes, BdrvRequestFlags flags);
301BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
302 const char *backing_file);
303void bdrv_refresh_filename(BlockDriverState *bs);
304int bdrv_truncate(BdrvChild *child, int64_t offset, PreallocMode prealloc,
305 Error **errp);
306int64_t bdrv_nb_sectors(BlockDriverState *bs);
307int64_t bdrv_getlength(BlockDriverState *bs);
308int64_t bdrv_get_allocated_file_size(BlockDriverState *bs);
309BlockMeasureInfo *bdrv_measure(BlockDriver *drv, QemuOpts *opts,
310 BlockDriverState *in_bs, Error **errp);
311void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr);
312void bdrv_refresh_limits(BlockDriverState *bs, Error **errp);
313int bdrv_commit(BlockDriverState *bs);
314int bdrv_change_backing_file(BlockDriverState *bs,
315 const char *backing_file, const char *backing_fmt);
316void bdrv_register(BlockDriver *bdrv);
317int bdrv_drop_intermediate(BlockDriverState *active, BlockDriverState *top,
318 BlockDriverState *base,
319 const char *backing_file_str);
320BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
321 BlockDriverState *bs);
322BlockDriverState *bdrv_find_base(BlockDriverState *bs);
323
324
325typedef struct BdrvCheckResult {
326 int corruptions;
327 int leaks;
328 int check_errors;
329 int corruptions_fixed;
330 int leaks_fixed;
331 int64_t image_end_offset;
332 BlockFragInfo bfi;
333} BdrvCheckResult;
334
335typedef enum {
336 BDRV_FIX_LEAKS = 1,
337 BDRV_FIX_ERRORS = 2,
338} BdrvCheckMode;
339
340int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix);
341
342
343
344
345typedef void BlockDriverAmendStatusCB(BlockDriverState *bs, int64_t offset,
346 int64_t total_work_size, void *opaque);
347int bdrv_amend_options(BlockDriverState *bs_new, QemuOpts *opts,
348 BlockDriverAmendStatusCB *status_cb, void *cb_opaque);
349
350
351bool bdrv_recurse_is_first_non_filter(BlockDriverState *bs,
352 BlockDriverState *candidate);
353bool bdrv_is_first_non_filter(BlockDriverState *candidate);
354
355
356BlockDriverState *check_to_replace_node(BlockDriverState *parent_bs,
357 const char *node_name, Error **errp);
358
359
360void bdrv_aio_cancel(BlockAIOCB *acb);
361void bdrv_aio_cancel_async(BlockAIOCB *acb);
362
363
364int bdrv_co_ioctl(BlockDriverState *bs, int req, void *buf);
365
366
367void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp);
368void bdrv_invalidate_cache_all(Error **errp);
369int bdrv_inactivate_all(void);
370
371
372int bdrv_flush(BlockDriverState *bs);
373int coroutine_fn bdrv_co_flush(BlockDriverState *bs);
374int bdrv_flush_all(void);
375void bdrv_close_all(void);
376void bdrv_drain(BlockDriverState *bs);
377void coroutine_fn bdrv_co_drain(BlockDriverState *bs);
378void bdrv_drain_all_begin(void);
379void bdrv_drain_all_end(void);
380void bdrv_drain_all(void);
381
382#define BDRV_POLL_WHILE(bs, cond) ({ \
383 bool waited_ = false; \
384 bool busy_ = true; \
385 BlockDriverState *bs_ = (bs); \
386 AioContext *ctx_ = bdrv_get_aio_context(bs_); \
387 if (aio_context_in_iothread(ctx_)) { \
388 while ((cond) || busy_) { \
389 busy_ = aio_poll(ctx_, (cond)); \
390 waited_ |= !!(cond) | busy_; \
391 } \
392 } else { \
393 assert(qemu_get_current_aio_context() == \
394 qemu_get_aio_context()); \
395
396
397
398
399 \
400 assert(!bs_->wakeup); \
401 \
402 atomic_mb_set(&bs_->wakeup, true); \
403 while (busy_) { \
404 if ((cond)) { \
405 waited_ = busy_ = true; \
406 aio_context_release(ctx_); \
407 aio_poll(qemu_get_aio_context(), true); \
408 aio_context_acquire(ctx_); \
409 } else { \
410 busy_ = aio_poll(ctx_, false); \
411 waited_ |= busy_; \
412 } \
413 } \
414 atomic_set(&bs_->wakeup, false); \
415 } \
416 waited_; })
417
418int bdrv_pdiscard(BlockDriverState *bs, int64_t offset, int bytes);
419int bdrv_co_pdiscard(BlockDriverState *bs, int64_t offset, int bytes);
420int bdrv_has_zero_init_1(BlockDriverState *bs);
421int bdrv_has_zero_init(BlockDriverState *bs);
422bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs);
423bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs);
424int64_t bdrv_get_block_status(BlockDriverState *bs, int64_t sector_num,
425 int nb_sectors, int *pnum,
426 BlockDriverState **file);
427int64_t bdrv_get_block_status_above(BlockDriverState *bs,
428 BlockDriverState *base,
429 int64_t sector_num,
430 int nb_sectors, int *pnum,
431 BlockDriverState **file);
432int bdrv_is_allocated(BlockDriverState *bs, int64_t offset, int64_t bytes,
433 int64_t *pnum);
434int bdrv_is_allocated_above(BlockDriverState *top, BlockDriverState *base,
435 int64_t offset, int64_t bytes, int64_t *pnum);
436
437bool bdrv_is_read_only(BlockDriverState *bs);
438bool bdrv_is_writable(BlockDriverState *bs);
439int bdrv_can_set_read_only(BlockDriverState *bs, bool read_only,
440 bool ignore_allow_rdw, Error **errp);
441int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp);
442bool bdrv_is_sg(BlockDriverState *bs);
443bool bdrv_is_inserted(BlockDriverState *bs);
444int bdrv_media_changed(BlockDriverState *bs);
445void bdrv_lock_medium(BlockDriverState *bs, bool locked);
446void bdrv_eject(BlockDriverState *bs, bool eject_flag);
447const char *bdrv_get_format_name(BlockDriverState *bs);
448BlockDriverState *bdrv_find_node(const char *node_name);
449BlockDeviceInfoList *bdrv_named_nodes_list(Error **errp);
450BlockDriverState *bdrv_lookup_bs(const char *device,
451 const char *node_name,
452 Error **errp);
453bool bdrv_chain_contains(BlockDriverState *top, BlockDriverState *base);
454BlockDriverState *bdrv_next_node(BlockDriverState *bs);
455
456typedef struct BdrvNextIterator {
457 enum {
458 BDRV_NEXT_BACKEND_ROOTS,
459 BDRV_NEXT_MONITOR_OWNED,
460 } phase;
461 BlockBackend *blk;
462 BlockDriverState *bs;
463} BdrvNextIterator;
464
465BlockDriverState *bdrv_first(BdrvNextIterator *it);
466BlockDriverState *bdrv_next(BdrvNextIterator *it);
467
468BlockDriverState *bdrv_next_monitor_owned(BlockDriverState *bs);
469bool bdrv_is_encrypted(BlockDriverState *bs);
470void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
471 void *opaque);
472const char *bdrv_get_node_name(const BlockDriverState *bs);
473const char *bdrv_get_device_name(const BlockDriverState *bs);
474const char *bdrv_get_device_or_node_name(const BlockDriverState *bs);
475int bdrv_get_flags(BlockDriverState *bs);
476int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi);
477ImageInfoSpecific *bdrv_get_specific_info(BlockDriverState *bs);
478void bdrv_round_to_clusters(BlockDriverState *bs,
479 int64_t offset, unsigned int bytes,
480 int64_t *cluster_offset,
481 unsigned int *cluster_bytes);
482
483const char *bdrv_get_encrypted_filename(BlockDriverState *bs);
484void bdrv_get_backing_filename(BlockDriverState *bs,
485 char *filename, int filename_size);
486void bdrv_get_full_backing_filename(BlockDriverState *bs,
487 char *dest, size_t sz, Error **errp);
488void bdrv_get_full_backing_filename_from_filename(const char *backed,
489 const char *backing,
490 char *dest, size_t sz,
491 Error **errp);
492
493int path_has_protocol(const char *path);
494int path_is_absolute(const char *path);
495void path_combine(char *dest, int dest_size,
496 const char *base_path,
497 const char *filename);
498
499int bdrv_readv_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos);
500int bdrv_writev_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos);
501int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
502 int64_t pos, int size);
503
504int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,
505 int64_t pos, int size);
506
507void bdrv_img_create(const char *filename, const char *fmt,
508 const char *base_filename, const char *base_fmt,
509 char *options, uint64_t img_size, int flags,
510 bool quiet, Error **errp);
511
512
513
514size_t bdrv_min_mem_align(BlockDriverState *bs);
515
516size_t bdrv_opt_mem_align(BlockDriverState *bs);
517void *qemu_blockalign(BlockDriverState *bs, size_t size);
518void *qemu_blockalign0(BlockDriverState *bs, size_t size);
519void *qemu_try_blockalign(BlockDriverState *bs, size_t size);
520void *qemu_try_blockalign0(BlockDriverState *bs, size_t size);
521bool bdrv_qiov_is_aligned(BlockDriverState *bs, QEMUIOVector *qiov);
522
523void bdrv_enable_copy_on_read(BlockDriverState *bs);
524void bdrv_disable_copy_on_read(BlockDriverState *bs);
525
526void bdrv_ref(BlockDriverState *bs);
527void bdrv_unref(BlockDriverState *bs);
528void bdrv_unref_child(BlockDriverState *parent, BdrvChild *child);
529BdrvChild *bdrv_attach_child(BlockDriverState *parent_bs,
530 BlockDriverState *child_bs,
531 const char *child_name,
532 const BdrvChildRole *child_role,
533 Error **errp);
534
535bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp);
536void bdrv_op_block(BlockDriverState *bs, BlockOpType op, Error *reason);
537void bdrv_op_unblock(BlockDriverState *bs, BlockOpType op, Error *reason);
538void bdrv_op_block_all(BlockDriverState *bs, Error *reason);
539void bdrv_op_unblock_all(BlockDriverState *bs, Error *reason);
540bool bdrv_op_blocker_is_empty(BlockDriverState *bs);
541
542#define BLKDBG_EVENT(child, evt) \
543 do { \
544 if (child) { \
545 bdrv_debug_event(child->bs, evt); \
546 } \
547 } while (0)
548
549void bdrv_debug_event(BlockDriverState *bs, BlkdebugEvent event);
550
551int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event,
552 const char *tag);
553int bdrv_debug_remove_breakpoint(BlockDriverState *bs, const char *tag);
554int bdrv_debug_resume(BlockDriverState *bs, const char *tag);
555bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag);
556
557
558
559
560
561
562AioContext *bdrv_get_aio_context(BlockDriverState *bs);
563
564
565
566
567void bdrv_coroutine_enter(BlockDriverState *bs, Coroutine *co);
568
569
570
571
572
573
574
575
576
577void bdrv_set_aio_context(BlockDriverState *bs, AioContext *new_context);
578int bdrv_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz);
579int bdrv_probe_geometry(BlockDriverState *bs, HDGeometry *geo);
580
581void bdrv_io_plug(BlockDriverState *bs);
582void bdrv_io_unplug(BlockDriverState *bs);
583
584
585
586
587
588
589
590void bdrv_parent_drained_begin(BlockDriverState *bs);
591
592
593
594
595
596
597
598void bdrv_parent_drained_end(BlockDriverState *bs);
599
600
601
602
603
604
605
606
607
608
609
610void bdrv_drained_begin(BlockDriverState *bs);
611
612
613
614
615
616
617void bdrv_drained_end(BlockDriverState *bs);
618
619void bdrv_add_child(BlockDriverState *parent, BlockDriverState *child,
620 Error **errp);
621void bdrv_del_child(BlockDriverState *parent, BdrvChild *child, Error **errp);
622
623bool bdrv_can_store_new_dirty_bitmap(BlockDriverState *bs, const char *name,
624 uint32_t granularity, Error **errp);
625
626#endif
627