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_SNAPSHOT 0x0008
86#define BDRV_O_TEMPORARY 0x0010
87#define BDRV_O_NOCACHE 0x0020
88#define BDRV_O_NATIVE_AIO 0x0080
89#define BDRV_O_NO_BACKING 0x0100
90#define BDRV_O_NO_FLUSH 0x0200
91#define BDRV_O_COPY_ON_READ 0x0400
92#define BDRV_O_INACTIVE 0x0800
93#define BDRV_O_CHECK 0x1000
94#define BDRV_O_ALLOW_RDWR 0x2000
95#define BDRV_O_UNMAP 0x4000
96#define BDRV_O_PROTOCOL 0x8000
97
98
99#define BDRV_O_NO_IO 0x10000
100
101#define BDRV_O_CACHE_MASK (BDRV_O_NOCACHE | BDRV_O_NO_FLUSH)
102
103
104
105
106#define BDRV_OPT_CACHE_WB "cache.writeback"
107#define BDRV_OPT_CACHE_DIRECT "cache.direct"
108#define BDRV_OPT_CACHE_NO_FLUSH "cache.no-flush"
109#define BDRV_OPT_READ_ONLY "read-only"
110#define BDRV_OPT_DISCARD "discard"
111
112
113#define BDRV_SECTOR_BITS 9
114#define BDRV_SECTOR_SIZE (1ULL << BDRV_SECTOR_BITS)
115#define BDRV_SECTOR_MASK ~(BDRV_SECTOR_SIZE - 1)
116
117#define BDRV_REQUEST_MAX_SECTORS MIN(SIZE_MAX >> BDRV_SECTOR_BITS, \
118 INT_MAX >> BDRV_SECTOR_BITS)
119
120
121
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#define BDRV_BLOCK_DATA 0x01
150#define BDRV_BLOCK_ZERO 0x02
151#define BDRV_BLOCK_OFFSET_VALID 0x04
152#define BDRV_BLOCK_RAW 0x08
153#define BDRV_BLOCK_ALLOCATED 0x10
154#define BDRV_BLOCK_OFFSET_MASK BDRV_SECTOR_MASK
155
156typedef QSIMPLEQ_HEAD(BlockReopenQueue, BlockReopenQueueEntry) BlockReopenQueue;
157
158typedef struct BDRVReopenState {
159 BlockDriverState *bs;
160 int flags;
161 QDict *options;
162 QDict *explicit_options;
163 void *opaque;
164} BDRVReopenState;
165
166
167
168
169typedef enum BlockOpType {
170 BLOCK_OP_TYPE_BACKUP_SOURCE,
171 BLOCK_OP_TYPE_BACKUP_TARGET,
172 BLOCK_OP_TYPE_CHANGE,
173 BLOCK_OP_TYPE_COMMIT_SOURCE,
174 BLOCK_OP_TYPE_COMMIT_TARGET,
175 BLOCK_OP_TYPE_DATAPLANE,
176 BLOCK_OP_TYPE_DRIVE_DEL,
177 BLOCK_OP_TYPE_EJECT,
178 BLOCK_OP_TYPE_EXTERNAL_SNAPSHOT,
179 BLOCK_OP_TYPE_INTERNAL_SNAPSHOT,
180 BLOCK_OP_TYPE_INTERNAL_SNAPSHOT_DELETE,
181 BLOCK_OP_TYPE_MIRROR_SOURCE,
182 BLOCK_OP_TYPE_MIRROR_TARGET,
183 BLOCK_OP_TYPE_RESIZE,
184 BLOCK_OP_TYPE_STREAM,
185 BLOCK_OP_TYPE_REPLACE,
186 BLOCK_OP_TYPE_MAX,
187} BlockOpType;
188
189
190void bdrv_init(void);
191void bdrv_init_with_whitelist(void);
192bool bdrv_uses_whitelist(void);
193BlockDriver *bdrv_find_protocol(const char *filename,
194 bool allow_protocol_prefix,
195 Error **errp);
196BlockDriver *bdrv_find_format(const char *format_name);
197int bdrv_create(BlockDriver *drv, const char* filename,
198 QemuOpts *opts, Error **errp);
199int bdrv_create_file(const char *filename, QemuOpts *opts, Error **errp);
200BlockDriverState *bdrv_new(void);
201void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top);
202void bdrv_replace_in_backing_chain(BlockDriverState *old,
203 BlockDriverState *new);
204
205int bdrv_parse_cache_mode(const char *mode, int *flags, bool *writethrough);
206int bdrv_parse_discard_flags(const char *mode, int *flags);
207BdrvChild *bdrv_open_child(const char *filename,
208 QDict *options, const char *bdref_key,
209 BlockDriverState* parent,
210 const BdrvChildRole *child_role,
211 bool allow_none, Error **errp);
212void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd);
213int bdrv_open_backing_file(BlockDriverState *bs, QDict *parent_options,
214 const char *bdref_key, Error **errp);
215BlockDriverState *bdrv_open(const char *filename, const char *reference,
216 QDict *options, int flags, Error **errp);
217BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
218 BlockDriverState *bs,
219 QDict *options, int flags);
220int bdrv_reopen_multiple(AioContext *ctx, BlockReopenQueue *bs_queue, Error **errp);
221int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp);
222int bdrv_reopen_prepare(BDRVReopenState *reopen_state,
223 BlockReopenQueue *queue, Error **errp);
224void bdrv_reopen_commit(BDRVReopenState *reopen_state);
225void bdrv_reopen_abort(BDRVReopenState *reopen_state);
226int bdrv_read(BdrvChild *child, int64_t sector_num,
227 uint8_t *buf, int nb_sectors);
228int bdrv_write(BdrvChild *child, int64_t sector_num,
229 const uint8_t *buf, int nb_sectors);
230int bdrv_pwrite_zeroes(BdrvChild *child, int64_t offset,
231 int count, BdrvRequestFlags flags);
232int bdrv_make_zero(BdrvChild *child, BdrvRequestFlags flags);
233int bdrv_pread(BdrvChild *child, int64_t offset, void *buf, int bytes);
234int bdrv_preadv(BdrvChild *child, int64_t offset, QEMUIOVector *qiov);
235int bdrv_pwrite(BdrvChild *child, int64_t offset, const void *buf, int bytes);
236int bdrv_pwritev(BdrvChild *child, int64_t offset, QEMUIOVector *qiov);
237int bdrv_pwrite_sync(BdrvChild *child, int64_t offset,
238 const void *buf, int count);
239int coroutine_fn bdrv_co_readv(BdrvChild *child, int64_t sector_num,
240 int nb_sectors, QEMUIOVector *qiov);
241int coroutine_fn bdrv_co_writev(BdrvChild *child, int64_t sector_num,
242 int nb_sectors, QEMUIOVector *qiov);
243
244
245
246
247
248
249int coroutine_fn bdrv_co_pwrite_zeroes(BdrvChild *child, int64_t offset,
250 int count, BdrvRequestFlags flags);
251BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
252 const char *backing_file);
253int bdrv_get_backing_file_depth(BlockDriverState *bs);
254void bdrv_refresh_filename(BlockDriverState *bs);
255int bdrv_truncate(BlockDriverState *bs, int64_t offset);
256int64_t bdrv_nb_sectors(BlockDriverState *bs);
257int64_t bdrv_getlength(BlockDriverState *bs);
258int64_t bdrv_get_allocated_file_size(BlockDriverState *bs);
259void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr);
260void bdrv_refresh_limits(BlockDriverState *bs, Error **errp);
261int bdrv_commit(BlockDriverState *bs);
262int bdrv_change_backing_file(BlockDriverState *bs,
263 const char *backing_file, const char *backing_fmt);
264void bdrv_register(BlockDriver *bdrv);
265int bdrv_drop_intermediate(BlockDriverState *active, BlockDriverState *top,
266 BlockDriverState *base,
267 const char *backing_file_str);
268BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
269 BlockDriverState *bs);
270BlockDriverState *bdrv_find_base(BlockDriverState *bs);
271
272
273typedef struct BdrvCheckResult {
274 int corruptions;
275 int leaks;
276 int check_errors;
277 int corruptions_fixed;
278 int leaks_fixed;
279 int64_t image_end_offset;
280 BlockFragInfo bfi;
281} BdrvCheckResult;
282
283typedef enum {
284 BDRV_FIX_LEAKS = 1,
285 BDRV_FIX_ERRORS = 2,
286} BdrvCheckMode;
287
288int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix);
289
290
291
292
293typedef void BlockDriverAmendStatusCB(BlockDriverState *bs, int64_t offset,
294 int64_t total_work_size, void *opaque);
295int bdrv_amend_options(BlockDriverState *bs_new, QemuOpts *opts,
296 BlockDriverAmendStatusCB *status_cb, void *cb_opaque);
297
298
299bool bdrv_recurse_is_first_non_filter(BlockDriverState *bs,
300 BlockDriverState *candidate);
301bool bdrv_is_first_non_filter(BlockDriverState *candidate);
302
303
304BlockDriverState *check_to_replace_node(BlockDriverState *parent_bs,
305 const char *node_name, Error **errp);
306
307
308BlockAIOCB *bdrv_aio_readv(BdrvChild *child, int64_t sector_num,
309 QEMUIOVector *iov, int nb_sectors,
310 BlockCompletionFunc *cb, void *opaque);
311BlockAIOCB *bdrv_aio_writev(BdrvChild *child, int64_t sector_num,
312 QEMUIOVector *iov, int nb_sectors,
313 BlockCompletionFunc *cb, void *opaque);
314BlockAIOCB *bdrv_aio_flush(BlockDriverState *bs,
315 BlockCompletionFunc *cb, void *opaque);
316void bdrv_aio_cancel(BlockAIOCB *acb);
317void bdrv_aio_cancel_async(BlockAIOCB *acb);
318
319
320int bdrv_co_ioctl(BlockDriverState *bs, int req, void *buf);
321
322
323void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp);
324void bdrv_invalidate_cache_all(Error **errp);
325int bdrv_inactivate_all(void);
326
327
328int bdrv_flush(BlockDriverState *bs);
329int coroutine_fn bdrv_co_flush(BlockDriverState *bs);
330int bdrv_flush_all(void);
331void bdrv_close_all(void);
332void bdrv_drain(BlockDriverState *bs);
333void coroutine_fn bdrv_co_drain(BlockDriverState *bs);
334void bdrv_drain_all_begin(void);
335void bdrv_drain_all_end(void);
336void bdrv_drain_all(void);
337
338#define BDRV_POLL_WHILE(bs, cond) ({ \
339 bool waited_ = false; \
340 BlockDriverState *bs_ = (bs); \
341 AioContext *ctx_ = bdrv_get_aio_context(bs_); \
342 if (aio_context_in_iothread(ctx_)) { \
343 while ((cond)) { \
344 aio_poll(ctx_, true); \
345 waited_ = true; \
346 } \
347 } else { \
348 assert(qemu_get_current_aio_context() == \
349 qemu_get_aio_context()); \
350
351
352
353
354 \
355 assert(!bs_->wakeup); \
356 bs_->wakeup = true; \
357 while ((cond)) { \
358 aio_context_release(ctx_); \
359 aio_poll(qemu_get_aio_context(), true); \
360 aio_context_acquire(ctx_); \
361 waited_ = true; \
362 } \
363 bs_->wakeup = false; \
364 } \
365 waited_; })
366
367int bdrv_pdiscard(BlockDriverState *bs, int64_t offset, int count);
368int bdrv_co_pdiscard(BlockDriverState *bs, int64_t offset, int count);
369int bdrv_has_zero_init_1(BlockDriverState *bs);
370int bdrv_has_zero_init(BlockDriverState *bs);
371bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs);
372bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs);
373int64_t bdrv_get_block_status(BlockDriverState *bs, int64_t sector_num,
374 int nb_sectors, int *pnum,
375 BlockDriverState **file);
376int64_t bdrv_get_block_status_above(BlockDriverState *bs,
377 BlockDriverState *base,
378 int64_t sector_num,
379 int nb_sectors, int *pnum,
380 BlockDriverState **file);
381int bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
382 int *pnum);
383int bdrv_is_allocated_above(BlockDriverState *top, BlockDriverState *base,
384 int64_t sector_num, int nb_sectors, int *pnum);
385
386bool bdrv_is_read_only(BlockDriverState *bs);
387bool bdrv_is_sg(BlockDriverState *bs);
388bool bdrv_is_inserted(BlockDriverState *bs);
389int bdrv_media_changed(BlockDriverState *bs);
390void bdrv_lock_medium(BlockDriverState *bs, bool locked);
391void bdrv_eject(BlockDriverState *bs, bool eject_flag);
392const char *bdrv_get_format_name(BlockDriverState *bs);
393BlockDriverState *bdrv_find_node(const char *node_name);
394BlockDeviceInfoList *bdrv_named_nodes_list(Error **errp);
395BlockDriverState *bdrv_lookup_bs(const char *device,
396 const char *node_name,
397 Error **errp);
398bool bdrv_chain_contains(BlockDriverState *top, BlockDriverState *base);
399BlockDriverState *bdrv_next_node(BlockDriverState *bs);
400
401typedef struct BdrvNextIterator {
402 enum {
403 BDRV_NEXT_BACKEND_ROOTS,
404 BDRV_NEXT_MONITOR_OWNED,
405 } phase;
406 BlockBackend *blk;
407 BlockDriverState *bs;
408} BdrvNextIterator;
409
410BlockDriverState *bdrv_first(BdrvNextIterator *it);
411BlockDriverState *bdrv_next(BdrvNextIterator *it);
412
413BlockDriverState *bdrv_next_monitor_owned(BlockDriverState *bs);
414bool bdrv_is_encrypted(BlockDriverState *bs);
415bool bdrv_key_required(BlockDriverState *bs);
416int bdrv_set_key(BlockDriverState *bs, const char *key);
417void bdrv_add_key(BlockDriverState *bs, const char *key, Error **errp);
418void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
419 void *opaque);
420const char *bdrv_get_node_name(const BlockDriverState *bs);
421const char *bdrv_get_device_name(const BlockDriverState *bs);
422const char *bdrv_get_device_or_node_name(const BlockDriverState *bs);
423int bdrv_get_flags(BlockDriverState *bs);
424int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi);
425ImageInfoSpecific *bdrv_get_specific_info(BlockDriverState *bs);
426void bdrv_round_sectors_to_clusters(BlockDriverState *bs,
427 int64_t sector_num, int nb_sectors,
428 int64_t *cluster_sector_num,
429 int *cluster_nb_sectors);
430void bdrv_round_to_clusters(BlockDriverState *bs,
431 int64_t offset, unsigned int bytes,
432 int64_t *cluster_offset,
433 unsigned int *cluster_bytes);
434
435const char *bdrv_get_encrypted_filename(BlockDriverState *bs);
436void bdrv_get_backing_filename(BlockDriverState *bs,
437 char *filename, int filename_size);
438void bdrv_get_full_backing_filename(BlockDriverState *bs,
439 char *dest, size_t sz, Error **errp);
440void bdrv_get_full_backing_filename_from_filename(const char *backed,
441 const char *backing,
442 char *dest, size_t sz,
443 Error **errp);
444
445int path_has_protocol(const char *path);
446int path_is_absolute(const char *path);
447void path_combine(char *dest, int dest_size,
448 const char *base_path,
449 const char *filename);
450
451int bdrv_readv_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos);
452int bdrv_writev_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos);
453int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
454 int64_t pos, int size);
455
456int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,
457 int64_t pos, int size);
458
459void bdrv_img_create(const char *filename, const char *fmt,
460 const char *base_filename, const char *base_fmt,
461 char *options, uint64_t img_size, int flags,
462 Error **errp, bool quiet);
463
464
465
466size_t bdrv_min_mem_align(BlockDriverState *bs);
467
468size_t bdrv_opt_mem_align(BlockDriverState *bs);
469void *qemu_blockalign(BlockDriverState *bs, size_t size);
470void *qemu_blockalign0(BlockDriverState *bs, size_t size);
471void *qemu_try_blockalign(BlockDriverState *bs, size_t size);
472void *qemu_try_blockalign0(BlockDriverState *bs, size_t size);
473bool bdrv_qiov_is_aligned(BlockDriverState *bs, QEMUIOVector *qiov);
474
475void bdrv_enable_copy_on_read(BlockDriverState *bs);
476void bdrv_disable_copy_on_read(BlockDriverState *bs);
477
478void bdrv_ref(BlockDriverState *bs);
479void bdrv_unref(BlockDriverState *bs);
480void bdrv_unref_child(BlockDriverState *parent, BdrvChild *child);
481BdrvChild *bdrv_attach_child(BlockDriverState *parent_bs,
482 BlockDriverState *child_bs,
483 const char *child_name,
484 const BdrvChildRole *child_role);
485
486bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp);
487void bdrv_op_block(BlockDriverState *bs, BlockOpType op, Error *reason);
488void bdrv_op_unblock(BlockDriverState *bs, BlockOpType op, Error *reason);
489void bdrv_op_block_all(BlockDriverState *bs, Error *reason);
490void bdrv_op_unblock_all(BlockDriverState *bs, Error *reason);
491bool bdrv_op_blocker_is_empty(BlockDriverState *bs);
492
493#define BLKDBG_EVENT(child, evt) \
494 do { \
495 if (child) { \
496 bdrv_debug_event(child->bs, evt); \
497 } \
498 } while (0)
499
500void bdrv_debug_event(BlockDriverState *bs, BlkdebugEvent event);
501
502int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event,
503 const char *tag);
504int bdrv_debug_remove_breakpoint(BlockDriverState *bs, const char *tag);
505int bdrv_debug_resume(BlockDriverState *bs, const char *tag);
506bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag);
507
508
509
510
511
512
513AioContext *bdrv_get_aio_context(BlockDriverState *bs);
514
515
516
517
518
519
520
521
522
523void bdrv_set_aio_context(BlockDriverState *bs, AioContext *new_context);
524int bdrv_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz);
525int bdrv_probe_geometry(BlockDriverState *bs, HDGeometry *geo);
526
527void bdrv_io_plug(BlockDriverState *bs);
528void bdrv_io_unplug(BlockDriverState *bs);
529void bdrv_io_unplugged_begin(BlockDriverState *bs);
530void bdrv_io_unplugged_end(BlockDriverState *bs);
531
532
533
534
535
536
537
538
539
540
541
542void bdrv_drained_begin(BlockDriverState *bs);
543
544
545
546
547
548
549void bdrv_drained_end(BlockDriverState *bs);
550
551void bdrv_add_child(BlockDriverState *parent, BlockDriverState *child,
552 Error **errp);
553void bdrv_del_child(BlockDriverState *parent, BdrvChild *child, Error **errp);
554
555#endif
556