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 "qapi/qmp/qobject.h"
11#include "qapi-types.h"
12#include "qemu/hbitmap.h"
13
14
15typedef struct BlockDriver BlockDriver;
16typedef struct BlockJob BlockJob;
17typedef struct BdrvChild BdrvChild;
18typedef struct BdrvChildRole BdrvChildRole;
19typedef struct BlockJobTxn BlockJobTxn;
20
21typedef struct BlockDriverInfo {
22
23 int cluster_size;
24
25 int64_t vm_state_offset;
26 bool is_dirty;
27
28
29
30
31 bool unallocated_blocks_are_zero;
32
33
34
35
36
37
38
39
40
41
42 bool can_write_zeroes_with_unmap;
43
44
45
46 bool needs_compressed_writes;
47} BlockDriverInfo;
48
49typedef struct BlockFragInfo {
50 uint64_t allocated_clusters;
51 uint64_t total_clusters;
52 uint64_t fragmented_clusters;
53 uint64_t compressed_clusters;
54} BlockFragInfo;
55
56typedef enum {
57 BDRV_REQ_COPY_ON_READ = 0x1,
58 BDRV_REQ_ZERO_WRITE = 0x2,
59
60
61
62
63
64
65 BDRV_REQ_MAY_UNMAP = 0x4,
66 BDRV_REQ_NO_SERIALISING = 0x8,
67 BDRV_REQ_FUA = 0x10,
68} BdrvRequestFlags;
69
70typedef struct BlockSizes {
71 uint32_t phys;
72 uint32_t log;
73} BlockSizes;
74
75typedef struct HDGeometry {
76 uint32_t heads;
77 uint32_t sectors;
78 uint32_t cylinders;
79} HDGeometry;
80
81#define BDRV_O_RDWR 0x0002
82#define BDRV_O_SNAPSHOT 0x0008
83#define BDRV_O_TEMPORARY 0x0010
84#define BDRV_O_NOCACHE 0x0020
85#define BDRV_O_NATIVE_AIO 0x0080
86#define BDRV_O_NO_BACKING 0x0100
87#define BDRV_O_NO_FLUSH 0x0200
88#define BDRV_O_COPY_ON_READ 0x0400
89#define BDRV_O_INACTIVE 0x0800
90#define BDRV_O_CHECK 0x1000
91#define BDRV_O_ALLOW_RDWR 0x2000
92#define BDRV_O_UNMAP 0x4000
93#define BDRV_O_PROTOCOL 0x8000
94
95
96#define BDRV_O_NO_IO 0x10000
97
98#define BDRV_O_CACHE_MASK (BDRV_O_NOCACHE | BDRV_O_NO_FLUSH)
99
100
101
102
103#define BDRV_OPT_CACHE_WB "cache.writeback"
104#define BDRV_OPT_CACHE_DIRECT "cache.direct"
105#define BDRV_OPT_CACHE_NO_FLUSH "cache.no-flush"
106
107
108#define BDRV_SECTOR_BITS 9
109#define BDRV_SECTOR_SIZE (1ULL << BDRV_SECTOR_BITS)
110#define BDRV_SECTOR_MASK ~(BDRV_SECTOR_SIZE - 1)
111
112#define BDRV_REQUEST_MAX_SECTORS MIN(SIZE_MAX >> BDRV_SECTOR_BITS, \
113 INT_MAX >> BDRV_SECTOR_BITS)
114
115
116
117
118
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#define BDRV_BLOCK_DATA 0x01
145#define BDRV_BLOCK_ZERO 0x02
146#define BDRV_BLOCK_OFFSET_VALID 0x04
147#define BDRV_BLOCK_RAW 0x08
148#define BDRV_BLOCK_ALLOCATED 0x10
149#define BDRV_BLOCK_OFFSET_MASK BDRV_SECTOR_MASK
150
151typedef QSIMPLEQ_HEAD(BlockReopenQueue, BlockReopenQueueEntry) BlockReopenQueue;
152
153typedef struct BDRVReopenState {
154 BlockDriverState *bs;
155 int flags;
156 QDict *options;
157 QDict *explicit_options;
158 void *opaque;
159} BDRVReopenState;
160
161
162
163
164typedef enum BlockOpType {
165 BLOCK_OP_TYPE_BACKUP_SOURCE,
166 BLOCK_OP_TYPE_BACKUP_TARGET,
167 BLOCK_OP_TYPE_CHANGE,
168 BLOCK_OP_TYPE_COMMIT_SOURCE,
169 BLOCK_OP_TYPE_COMMIT_TARGET,
170 BLOCK_OP_TYPE_DATAPLANE,
171 BLOCK_OP_TYPE_DRIVE_DEL,
172 BLOCK_OP_TYPE_EJECT,
173 BLOCK_OP_TYPE_EXTERNAL_SNAPSHOT,
174 BLOCK_OP_TYPE_INTERNAL_SNAPSHOT,
175 BLOCK_OP_TYPE_INTERNAL_SNAPSHOT_DELETE,
176 BLOCK_OP_TYPE_MIRROR_SOURCE,
177 BLOCK_OP_TYPE_MIRROR_TARGET,
178 BLOCK_OP_TYPE_RESIZE,
179 BLOCK_OP_TYPE_STREAM,
180 BLOCK_OP_TYPE_REPLACE,
181 BLOCK_OP_TYPE_MAX,
182} BlockOpType;
183
184void bdrv_info_print(Monitor *mon, const QObject *data);
185void bdrv_info(Monitor *mon, QObject **ret_data);
186void bdrv_stats_print(Monitor *mon, const QObject *data);
187void bdrv_info_stats(Monitor *mon, QObject **ret_data);
188
189
190void bdrv_io_limits_enable(BlockDriverState *bs, const char *group);
191void bdrv_io_limits_disable(BlockDriverState *bs);
192void bdrv_io_limits_update_group(BlockDriverState *bs, const char *group);
193
194void bdrv_init(void);
195void bdrv_init_with_whitelist(void);
196bool bdrv_uses_whitelist(void);
197BlockDriver *bdrv_find_protocol(const char *filename,
198 bool allow_protocol_prefix,
199 Error **errp);
200BlockDriver *bdrv_find_format(const char *format_name);
201int bdrv_create(BlockDriver *drv, const char* filename,
202 QemuOpts *opts, Error **errp);
203int bdrv_create_file(const char *filename, QemuOpts *opts, Error **errp);
204BlockDriverState *bdrv_new_root(void);
205BlockDriverState *bdrv_new(void);
206void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top);
207void bdrv_replace_in_backing_chain(BlockDriverState *old,
208 BlockDriverState *new);
209
210int bdrv_parse_cache_mode(const char *mode, int *flags, bool *writethrough);
211int bdrv_parse_discard_flags(const char *mode, int *flags);
212BdrvChild *bdrv_open_child(const char *filename,
213 QDict *options, const char *bdref_key,
214 BlockDriverState* parent,
215 const BdrvChildRole *child_role,
216 bool allow_none, Error **errp);
217void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd);
218int bdrv_open_backing_file(BlockDriverState *bs, QDict *parent_options,
219 const char *bdref_key, Error **errp);
220int bdrv_open(BlockDriverState **pbs, const char *filename,
221 const char *reference, QDict *options, int flags, Error **errp);
222BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
223 BlockDriverState *bs,
224 QDict *options, int flags);
225int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp);
226int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp);
227int bdrv_reopen_prepare(BDRVReopenState *reopen_state,
228 BlockReopenQueue *queue, Error **errp);
229void bdrv_reopen_commit(BDRVReopenState *reopen_state);
230void bdrv_reopen_abort(BDRVReopenState *reopen_state);
231int bdrv_read(BlockDriverState *bs, int64_t sector_num,
232 uint8_t *buf, int nb_sectors);
233int bdrv_write(BlockDriverState *bs, int64_t sector_num,
234 const uint8_t *buf, int nb_sectors);
235int bdrv_write_zeroes(BlockDriverState *bs, int64_t sector_num,
236 int nb_sectors, BdrvRequestFlags flags);
237BlockAIOCB *bdrv_aio_write_zeroes(BlockDriverState *bs, int64_t sector_num,
238 int nb_sectors, BdrvRequestFlags flags,
239 BlockCompletionFunc *cb, void *opaque);
240int bdrv_make_zero(BlockDriverState *bs, BdrvRequestFlags flags);
241int bdrv_pread(BlockDriverState *bs, int64_t offset,
242 void *buf, int count);
243int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
244 const void *buf, int count);
245int bdrv_pwritev(BlockDriverState *bs, int64_t offset, QEMUIOVector *qiov);
246int bdrv_pwrite_sync(BlockDriverState *bs, int64_t offset,
247 const void *buf, int count);
248int coroutine_fn bdrv_co_readv(BlockDriverState *bs, int64_t sector_num,
249 int nb_sectors, QEMUIOVector *qiov);
250int coroutine_fn bdrv_co_copy_on_readv(BlockDriverState *bs,
251 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov);
252int coroutine_fn bdrv_co_readv_no_serialising(BlockDriverState *bs,
253 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov);
254int coroutine_fn bdrv_co_writev(BlockDriverState *bs, int64_t sector_num,
255 int nb_sectors, QEMUIOVector *qiov);
256
257
258
259
260
261
262int coroutine_fn bdrv_co_write_zeroes(BlockDriverState *bs, int64_t sector_num,
263 int nb_sectors, BdrvRequestFlags flags);
264BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
265 const char *backing_file);
266int bdrv_get_backing_file_depth(BlockDriverState *bs);
267void bdrv_refresh_filename(BlockDriverState *bs);
268int bdrv_truncate(BlockDriverState *bs, int64_t offset);
269int64_t bdrv_nb_sectors(BlockDriverState *bs);
270int64_t bdrv_getlength(BlockDriverState *bs);
271int64_t bdrv_get_allocated_file_size(BlockDriverState *bs);
272void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr);
273void bdrv_refresh_limits(BlockDriverState *bs, Error **errp);
274int bdrv_commit(BlockDriverState *bs);
275int bdrv_change_backing_file(BlockDriverState *bs,
276 const char *backing_file, const char *backing_fmt);
277void bdrv_register(BlockDriver *bdrv);
278int bdrv_drop_intermediate(BlockDriverState *active, BlockDriverState *top,
279 BlockDriverState *base,
280 const char *backing_file_str);
281BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
282 BlockDriverState *bs);
283BlockDriverState *bdrv_find_base(BlockDriverState *bs);
284
285
286typedef struct BdrvCheckResult {
287 int corruptions;
288 int leaks;
289 int check_errors;
290 int corruptions_fixed;
291 int leaks_fixed;
292 int64_t image_end_offset;
293 BlockFragInfo bfi;
294} BdrvCheckResult;
295
296typedef enum {
297 BDRV_FIX_LEAKS = 1,
298 BDRV_FIX_ERRORS = 2,
299} BdrvCheckMode;
300
301int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix);
302
303
304
305
306typedef void BlockDriverAmendStatusCB(BlockDriverState *bs, int64_t offset,
307 int64_t total_work_size, void *opaque);
308int bdrv_amend_options(BlockDriverState *bs_new, QemuOpts *opts,
309 BlockDriverAmendStatusCB *status_cb, void *cb_opaque);
310
311
312bool bdrv_recurse_is_first_non_filter(BlockDriverState *bs,
313 BlockDriverState *candidate);
314bool bdrv_is_first_non_filter(BlockDriverState *candidate);
315
316
317BlockDriverState *check_to_replace_node(BlockDriverState *parent_bs,
318 const char *node_name, Error **errp);
319
320
321BlockAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
322 QEMUIOVector *iov, int nb_sectors,
323 BlockCompletionFunc *cb, void *opaque);
324BlockAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
325 QEMUIOVector *iov, int nb_sectors,
326 BlockCompletionFunc *cb, void *opaque);
327BlockAIOCB *bdrv_aio_flush(BlockDriverState *bs,
328 BlockCompletionFunc *cb, void *opaque);
329BlockAIOCB *bdrv_aio_discard(BlockDriverState *bs,
330 int64_t sector_num, int nb_sectors,
331 BlockCompletionFunc *cb, void *opaque);
332void bdrv_aio_cancel(BlockAIOCB *acb);
333void bdrv_aio_cancel_async(BlockAIOCB *acb);
334
335typedef struct BlockRequest {
336
337 union {
338 struct {
339 int64_t sector;
340 int nb_sectors;
341 int flags;
342 QEMUIOVector *qiov;
343 };
344 struct {
345 int req;
346 void *buf;
347 };
348 };
349 BlockCompletionFunc *cb;
350 void *opaque;
351
352
353 int error;
354} BlockRequest;
355
356int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs,
357 int num_reqs);
358
359
360int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf);
361BlockAIOCB *bdrv_aio_ioctl(BlockDriverState *bs,
362 unsigned long int req, void *buf,
363 BlockCompletionFunc *cb, void *opaque);
364
365
366void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp);
367void bdrv_invalidate_cache_all(Error **errp);
368int bdrv_inactivate_all(void);
369
370
371int bdrv_flush(BlockDriverState *bs);
372int coroutine_fn bdrv_co_flush(BlockDriverState *bs);
373void bdrv_close_all(void);
374void bdrv_drain(BlockDriverState *bs);
375void coroutine_fn bdrv_co_drain(BlockDriverState *bs);
376void bdrv_drain_all(void);
377
378int bdrv_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors);
379int bdrv_co_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors);
380int bdrv_has_zero_init_1(BlockDriverState *bs);
381int bdrv_has_zero_init(BlockDriverState *bs);
382bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs);
383bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs);
384int64_t bdrv_get_block_status(BlockDriverState *bs, int64_t sector_num,
385 int nb_sectors, int *pnum,
386 BlockDriverState **file);
387int64_t bdrv_get_block_status_above(BlockDriverState *bs,
388 BlockDriverState *base,
389 int64_t sector_num,
390 int nb_sectors, int *pnum,
391 BlockDriverState **file);
392int bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
393 int *pnum);
394int bdrv_is_allocated_above(BlockDriverState *top, BlockDriverState *base,
395 int64_t sector_num, int nb_sectors, int *pnum);
396
397int bdrv_is_read_only(BlockDriverState *bs);
398int bdrv_is_sg(BlockDriverState *bs);
399bool bdrv_is_inserted(BlockDriverState *bs);
400int bdrv_media_changed(BlockDriverState *bs);
401void bdrv_lock_medium(BlockDriverState *bs, bool locked);
402void bdrv_eject(BlockDriverState *bs, bool eject_flag);
403const char *bdrv_get_format_name(BlockDriverState *bs);
404BlockDriverState *bdrv_find_node(const char *node_name);
405BlockDeviceInfoList *bdrv_named_nodes_list(Error **errp);
406BlockDriverState *bdrv_lookup_bs(const char *device,
407 const char *node_name,
408 Error **errp);
409bool bdrv_chain_contains(BlockDriverState *top, BlockDriverState *base);
410BlockDriverState *bdrv_next_node(BlockDriverState *bs);
411BlockDriverState *bdrv_next(BlockDriverState *bs);
412BlockDriverState *bdrv_next_monitor_owned(BlockDriverState *bs);
413int bdrv_is_encrypted(BlockDriverState *bs);
414int bdrv_key_required(BlockDriverState *bs);
415int bdrv_set_key(BlockDriverState *bs, const char *key);
416void bdrv_add_key(BlockDriverState *bs, const char *key, Error **errp);
417int bdrv_query_missing_keys(void);
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_write_compressed(BlockDriverState *bs, int64_t sector_num,
425 const uint8_t *buf, int nb_sectors);
426int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi);
427ImageInfoSpecific *bdrv_get_specific_info(BlockDriverState *bs);
428void bdrv_round_to_clusters(BlockDriverState *bs,
429 int64_t sector_num, int nb_sectors,
430 int64_t *cluster_sector_num,
431 int *cluster_nb_sectors);
432
433const char *bdrv_get_encrypted_filename(BlockDriverState *bs);
434void bdrv_get_backing_filename(BlockDriverState *bs,
435 char *filename, int filename_size);
436void bdrv_get_full_backing_filename(BlockDriverState *bs,
437 char *dest, size_t sz, Error **errp);
438void bdrv_get_full_backing_filename_from_filename(const char *backed,
439 const char *backing,
440 char *dest, size_t sz,
441 Error **errp);
442int bdrv_is_snapshot(BlockDriverState *bs);
443
444int path_has_protocol(const char *path);
445int path_is_absolute(const char *path);
446void path_combine(char *dest, int dest_size,
447 const char *base_path,
448 const char *filename);
449
450int bdrv_writev_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos);
451int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
452 int64_t pos, int size);
453
454int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,
455 int64_t pos, int size);
456
457void bdrv_img_create(const char *filename, const char *fmt,
458 const char *base_filename, const char *base_fmt,
459 char *options, uint64_t img_size, int flags,
460 Error **errp, bool quiet);
461
462
463
464size_t bdrv_min_mem_align(BlockDriverState *bs);
465
466size_t bdrv_opt_mem_align(BlockDriverState *bs);
467void *qemu_blockalign(BlockDriverState *bs, size_t size);
468void *qemu_blockalign0(BlockDriverState *bs, size_t size);
469void *qemu_try_blockalign(BlockDriverState *bs, size_t size);
470void *qemu_try_blockalign0(BlockDriverState *bs, size_t size);
471bool bdrv_qiov_is_aligned(BlockDriverState *bs, QEMUIOVector *qiov);
472
473void bdrv_enable_copy_on_read(BlockDriverState *bs);
474void bdrv_disable_copy_on_read(BlockDriverState *bs);
475
476void bdrv_ref(BlockDriverState *bs);
477void bdrv_unref(BlockDriverState *bs);
478void bdrv_unref_child(BlockDriverState *parent, BdrvChild *child);
479
480bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp);
481void bdrv_op_block(BlockDriverState *bs, BlockOpType op, Error *reason);
482void bdrv_op_unblock(BlockDriverState *bs, BlockOpType op, Error *reason);
483void bdrv_op_block_all(BlockDriverState *bs, Error *reason);
484void bdrv_op_unblock_all(BlockDriverState *bs, Error *reason);
485bool bdrv_op_blocker_is_empty(BlockDriverState *bs);
486
487#define BLKDBG_EVENT(child, evt) \
488 do { \
489 if (child) { \
490 bdrv_debug_event(child->bs, evt); \
491 } \
492 } while (0)
493
494void bdrv_debug_event(BlockDriverState *bs, BlkdebugEvent event);
495
496int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event,
497 const char *tag);
498int bdrv_debug_remove_breakpoint(BlockDriverState *bs, const char *tag);
499int bdrv_debug_resume(BlockDriverState *bs, const char *tag);
500bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag);
501
502
503
504
505
506
507AioContext *bdrv_get_aio_context(BlockDriverState *bs);
508
509
510
511
512
513
514
515
516
517void bdrv_set_aio_context(BlockDriverState *bs, AioContext *new_context);
518int bdrv_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz);
519int bdrv_probe_geometry(BlockDriverState *bs, HDGeometry *geo);
520
521void bdrv_io_plug(BlockDriverState *bs);
522void bdrv_io_unplug(BlockDriverState *bs);
523void bdrv_flush_io_queue(BlockDriverState *bs);
524
525
526
527
528
529
530
531
532
533
534
535void bdrv_drained_begin(BlockDriverState *bs);
536
537
538
539
540
541
542void bdrv_drained_end(BlockDriverState *bs);
543
544#endif
545