]> git.proxmox.com Git - mirror_qemu.git/blame - include/block/block.h
Open 2.0 development tree
[mirror_qemu.git] / include / block / block.h
CommitLineData
faf07963
PB
1#ifndef BLOCK_H
2#define BLOCK_H
3
737e150e 4#include "block/aio.h"
3b69e4b9 5#include "qemu-common.h"
1de7afc9 6#include "qemu/option.h"
737e150e 7#include "block/coroutine.h"
7b1b5d19 8#include "qapi/qmp/qobject.h"
2f0c9fe6 9#include "qapi-types.h"
a76bab49 10
faf07963 11/* block.c */
faf07963 12typedef struct BlockDriver BlockDriver;
2f0c9fe6 13typedef struct BlockJob BlockJob;
faf07963 14
faf07963
PB
15typedef struct BlockDriverInfo {
16 /* in bytes, 0 if irrelevant */
17 int cluster_size;
18 /* offset at which the VM state can be saved (0 if not possible) */
19 int64_t vm_state_offset;
64c79160 20 bool is_dirty;
faf07963
PB
21} BlockDriverInfo;
22
f8111c24
DXW
23typedef struct BlockFragInfo {
24 uint64_t allocated_clusters;
25 uint64_t total_clusters;
26 uint64_t fragmented_clusters;
e6439d78 27 uint64_t compressed_clusters;
f8111c24
DXW
28} BlockFragInfo;
29
145feb17 30/* Callbacks for block device models */
0e49de52 31typedef struct BlockDevOps {
145feb17
MA
32 /*
33 * Runs when virtual media changed (monitor commands eject, change)
7d4b4ba5 34 * Argument load is true on load and false on eject.
145feb17
MA
35 * Beware: doesn't run when a host device's physical media
36 * changes. Sure would be useful if it did.
2c6942fa 37 * Device models with removable media must implement this callback.
145feb17 38 */
7d4b4ba5 39 void (*change_media_cb)(void *opaque, bool load);
025ccaa7
PB
40 /*
41 * Runs when an eject request is issued from the monitor, the tray
42 * is closed, and the medium is locked.
43 * Device models that do not implement is_medium_locked will not need
44 * this callback. Device models that can lock the medium or tray might
45 * want to implement the callback and unlock the tray when "force" is
46 * true, even if they do not support eject requests.
47 */
48 void (*eject_request_cb)(void *opaque, bool force);
e4def80b
MA
49 /*
50 * Is the virtual tray open?
51 * Device models implement this only when the device has a tray.
52 */
53 bool (*is_tray_open)(void *opaque);
f107639a
MA
54 /*
55 * Is the virtual medium locked into the device?
56 * Device models implement this only when device has such a lock.
57 */
58 bool (*is_medium_locked)(void *opaque);
145feb17
MA
59 /*
60 * Runs when the size changed (e.g. monitor command block_resize)
61 */
62 void (*resize_cb)(void *opaque);
0e49de52
MA
63} BlockDevOps;
64
faf07963 65#define BDRV_O_RDWR 0x0002
faf07963 66#define BDRV_O_SNAPSHOT 0x0008 /* open the file read only and save writes in a snapshot */
9f7965c7
AL
67#define BDRV_O_NOCACHE 0x0020 /* do not use the host page cache */
68#define BDRV_O_CACHE_WB 0x0040 /* use write-back caching */
5c6c3a6c 69#define BDRV_O_NATIVE_AIO 0x0080 /* use native AIO instead of the thread pool */
b783e409 70#define BDRV_O_NO_BACKING 0x0100 /* don't open the backing file */
016f5cf6 71#define BDRV_O_NO_FLUSH 0x0200 /* disable flushing on this disk */
53fec9d3 72#define BDRV_O_COPY_ON_READ 0x0400 /* copy read backing sectors into image */
ccb1f4a7 73#define BDRV_O_INCOMING 0x0800 /* consistency hint for incoming migration */
058f8f16 74#define BDRV_O_CHECK 0x1000 /* open solely for consistency check */
be028adc 75#define BDRV_O_ALLOW_RDWR 0x2000 /* allow reopen to change from r/o to r/w */
9e8f1835 76#define BDRV_O_UNMAP 0x4000 /* execute guest UNMAP/TRIM operations */
9f7965c7 77
ceb25e5c 78#define BDRV_O_CACHE_MASK (BDRV_O_NOCACHE | BDRV_O_CACHE_WB | BDRV_O_NO_FLUSH)
faf07963 79
6ea44308 80#define BDRV_SECTOR_BITS 9
c63782cb 81#define BDRV_SECTOR_SIZE (1ULL << BDRV_SECTOR_BITS)
3abbc4d9 82#define BDRV_SECTOR_MASK ~(BDRV_SECTOR_SIZE - 1)
6ea44308 83
4333bb71
PB
84/* BDRV_BLOCK_DATA: data is read from bs->file or another file
85 * BDRV_BLOCK_ZERO: sectors read as zero
86 * BDRV_BLOCK_OFFSET_VALID: sector stored in bs->file as raw data
92bc50a5
PL
87 * BDRV_BLOCK_RAW: used internally to indicate that the request
88 * was answered by the raw driver and that one
89 * should look in bs->file directly.
4333bb71
PB
90 *
91 * If BDRV_BLOCK_OFFSET_VALID is set, bits 9-62 represent the offset in
92 * bs->file where sector data can be read from as raw data.
93 *
94 * DATA == 0 && ZERO == 0 means that data is read from backing_hd if present.
95 *
96 * DATA ZERO OFFSET_VALID
97 * t t t sectors read as zero, bs->file is zero at offset
98 * t f t sectors read as valid from bs->file at offset
99 * f t t sectors preallocated, read as zero, bs->file not
100 * necessarily zero at offset
101 * f f t sectors preallocated but read from backing_hd,
102 * bs->file contains garbage at offset
103 * t t f sectors preallocated, read as zero, unknown offset
104 * t f f sectors read from unknown file or offset
105 * f t f not allocated or unknown offset, read as zero
106 * f f f not allocated or unknown offset, read from backing_hd
107 */
108#define BDRV_BLOCK_DATA 1
109#define BDRV_BLOCK_ZERO 2
110#define BDRV_BLOCK_OFFSET_VALID 4
92bc50a5 111#define BDRV_BLOCK_RAW 8
4333bb71
PB
112#define BDRV_BLOCK_OFFSET_MASK BDRV_SECTOR_MASK
113
2582bfed
LC
114typedef enum {
115 BDRV_ACTION_REPORT, BDRV_ACTION_IGNORE, BDRV_ACTION_STOP
ff06f5f3 116} BlockErrorAction;
2582bfed 117
e971aa12
JC
118typedef QSIMPLEQ_HEAD(BlockReopenQueue, BlockReopenQueueEntry) BlockReopenQueue;
119
120typedef struct BDRVReopenState {
121 BlockDriverState *bs;
122 int flags;
123 void *opaque;
124} BDRVReopenState;
125
126
28a7282a
LC
127void bdrv_iostatus_enable(BlockDriverState *bs);
128void bdrv_iostatus_reset(BlockDriverState *bs);
129void bdrv_iostatus_disable(BlockDriverState *bs);
130bool bdrv_iostatus_is_enabled(const BlockDriverState *bs);
131void bdrv_iostatus_set_err(BlockDriverState *bs, int error);
d15e5465
LC
132void bdrv_info_print(Monitor *mon, const QObject *data);
133void bdrv_info(Monitor *mon, QObject **ret_data);
218a536a
LC
134void bdrv_stats_print(Monitor *mon, const QObject *data);
135void bdrv_info_stats(Monitor *mon, QObject **ret_data);
faf07963 136
0563e191
ZYW
137/* disk I/O throttling */
138void bdrv_io_limits_enable(BlockDriverState *bs);
98f90dba 139void bdrv_io_limits_disable(BlockDriverState *bs);
0563e191 140
faf07963 141void bdrv_init(void);
eb852011 142void bdrv_init_with_whitelist(void);
98289620
KW
143BlockDriver *bdrv_find_protocol(const char *filename,
144 bool allow_protocol_prefix);
faf07963 145BlockDriver *bdrv_find_format(const char *format_name);
b64ec4e4
FZ
146BlockDriver *bdrv_find_whitelisted_format(const char *format_name,
147 bool readonly);
0e7e1989 148int bdrv_create(BlockDriver *drv, const char* filename,
cc84d90f
HR
149 QEMUOptionParameter *options, Error **errp);
150int bdrv_create_file(const char* filename, QEMUOptionParameter *options,
151 Error **errp);
faf07963 152BlockDriverState *bdrv_new(const char *device_name);
d22b2f41 153void bdrv_make_anon(BlockDriverState *bs);
4ddc07ca 154void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old);
8802d1fd 155void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top);
c3993cdc 156int bdrv_parse_cache_flags(const char *mode, int *flags);
9e8f1835 157int bdrv_parse_discard_flags(const char *mode, int *flags);
787e4a85 158int bdrv_file_open(BlockDriverState **pbs, const char *filename,
34b5d2c6
HR
159 QDict *options, int flags, Error **errp);
160int bdrv_open_backing_file(BlockDriverState *bs, QDict *options, Error **errp);
de9c0cec 161int bdrv_open(BlockDriverState *bs, const char *filename, QDict *options,
34b5d2c6 162 int flags, BlockDriver *drv, Error **errp);
e971aa12
JC
163BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
164 BlockDriverState *bs, int flags);
165int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp);
166int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp);
167int bdrv_reopen_prepare(BDRVReopenState *reopen_state,
168 BlockReopenQueue *queue, Error **errp);
169void bdrv_reopen_commit(BDRVReopenState *reopen_state);
170void bdrv_reopen_abort(BDRVReopenState *reopen_state);
faf07963 171void bdrv_close(BlockDriverState *bs);
d7d512f6 172void bdrv_add_close_notifier(BlockDriverState *bs, Notifier *notify);
fa879d62
MA
173int bdrv_attach_dev(BlockDriverState *bs, void *dev);
174void bdrv_attach_dev_nofail(BlockDriverState *bs, void *dev);
175void bdrv_detach_dev(BlockDriverState *bs, void *dev);
176void *bdrv_get_attached_dev(BlockDriverState *bs);
0e49de52
MA
177void bdrv_set_dev_ops(BlockDriverState *bs, const BlockDevOps *ops,
178 void *opaque);
025ccaa7 179void bdrv_dev_eject_request(BlockDriverState *bs, bool force);
2c6942fa 180bool bdrv_dev_has_removable_media(BlockDriverState *bs);
e4def80b 181bool bdrv_dev_is_tray_open(BlockDriverState *bs);
f107639a 182bool bdrv_dev_is_medium_locked(BlockDriverState *bs);
faf07963
PB
183int bdrv_read(BlockDriverState *bs, int64_t sector_num,
184 uint8_t *buf, int nb_sectors);
07d27a44
MA
185int bdrv_read_unthrottled(BlockDriverState *bs, int64_t sector_num,
186 uint8_t *buf, int nb_sectors);
faf07963
PB
187int bdrv_write(BlockDriverState *bs, int64_t sector_num,
188 const uint8_t *buf, int nb_sectors);
4105eaaa
PL
189int bdrv_write_zeroes(BlockDriverState *bs, int64_t sector_num,
190 int nb_sectors);
8d3b1a2d 191int bdrv_writev(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov);
faf07963
PB
192int bdrv_pread(BlockDriverState *bs, int64_t offset,
193 void *buf, int count);
194int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
195 const void *buf, int count);
8d3b1a2d 196int bdrv_pwritev(BlockDriverState *bs, int64_t offset, QEMUIOVector *qiov);
f08145fe
KW
197int bdrv_pwrite_sync(BlockDriverState *bs, int64_t offset,
198 const void *buf, int count);
da1fa91d
KW
199int coroutine_fn bdrv_co_readv(BlockDriverState *bs, int64_t sector_num,
200 int nb_sectors, QEMUIOVector *qiov);
470c0504
SH
201int coroutine_fn bdrv_co_copy_on_readv(BlockDriverState *bs,
202 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov);
da1fa91d
KW
203int coroutine_fn bdrv_co_writev(BlockDriverState *bs, int64_t sector_num,
204 int nb_sectors, QEMUIOVector *qiov);
f08f2dda
SH
205/*
206 * Efficiently zero a region of the disk image. Note that this is a regular
207 * I/O request like read or write and should have a reasonable size. This
208 * function is not suitable for zeroing the entire image in a single request
209 * because it may allocate memory for the entire region.
210 */
211int coroutine_fn bdrv_co_write_zeroes(BlockDriverState *bs, int64_t sector_num,
212 int nb_sectors);
e8a6bb9c
MT
213BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
214 const char *backing_file);
f198fd1c 215int bdrv_get_backing_file_depth(BlockDriverState *bs);
faf07963
PB
216int bdrv_truncate(BlockDriverState *bs, int64_t offset);
217int64_t bdrv_getlength(BlockDriverState *bs);
4a1d5e1f 218int64_t bdrv_get_allocated_file_size(BlockDriverState *bs);
96b8f136 219void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr);
faf07963 220int bdrv_commit(BlockDriverState *bs);
e8877497 221int bdrv_commit_all(void);
756e6736
KW
222int bdrv_change_backing_file(BlockDriverState *bs,
223 const char *backing_file, const char *backing_fmt);
5efa9d5a 224void bdrv_register(BlockDriver *bdrv);
6ebdcee2
JC
225int bdrv_drop_intermediate(BlockDriverState *active, BlockDriverState *top,
226 BlockDriverState *base);
227BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
228 BlockDriverState *bs);
79fac568 229BlockDriverState *bdrv_find_base(BlockDriverState *bs);
5efa9d5a 230
e076f338
KW
231
232typedef struct BdrvCheckResult {
233 int corruptions;
234 int leaks;
235 int check_errors;
ccf34716
KW
236 int corruptions_fixed;
237 int leaks_fixed;
c6bb9ad1 238 int64_t image_end_offset;
f8111c24 239 BlockFragInfo bfi;
e076f338
KW
240} BdrvCheckResult;
241
4534ff54
KW
242typedef enum {
243 BDRV_FIX_LEAKS = 1,
244 BDRV_FIX_ERRORS = 2,
245} BdrvCheckMode;
246
247int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix);
e076f338 248
6f176b48
HR
249int bdrv_amend_options(BlockDriverState *bs_new, QEMUOptionParameter *options);
250
f6186f49
BC
251/* external snapshots */
252
253typedef enum {
254 EXT_SNAPSHOT_ALLOWED,
255 EXT_SNAPSHOT_FORBIDDEN,
256} ExtSnapshotPerm;
257
258/* return EXT_SNAPSHOT_ALLOWED if external snapshot is allowed
259 * return EXT_SNAPSHOT_FORBIDDEN if external snapshot is forbidden
260 */
261ExtSnapshotPerm bdrv_check_ext_snapshot(BlockDriverState *bs);
262/* helper used to forbid external snapshots like in blkverify */
263ExtSnapshotPerm bdrv_check_ext_snapshot_forbidden(BlockDriverState *bs);
264
faf07963 265/* async block I/O */
7cd1e32a 266typedef void BlockDriverDirtyHandler(BlockDriverState *bs, int64_t sector,
39aa9a12 267 int sector_num);
3b69e4b9
AL
268BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
269 QEMUIOVector *iov, int nb_sectors,
270 BlockDriverCompletionFunc *cb, void *opaque);
271BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
272 QEMUIOVector *iov, int nb_sectors,
273 BlockDriverCompletionFunc *cb, void *opaque);
b2e12bc6 274BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs,
39aa9a12 275 BlockDriverCompletionFunc *cb, void *opaque);
4265d620
PB
276BlockDriverAIOCB *bdrv_aio_discard(BlockDriverState *bs,
277 int64_t sector_num, int nb_sectors,
278 BlockDriverCompletionFunc *cb, void *opaque);
faf07963
PB
279void bdrv_aio_cancel(BlockDriverAIOCB *acb);
280
40b4f539
KW
281typedef struct BlockRequest {
282 /* Fields to be filled by multiwrite caller */
283 int64_t sector;
284 int nb_sectors;
285 QEMUIOVector *qiov;
286 BlockDriverCompletionFunc *cb;
287 void *opaque;
288
289 /* Filled by multiwrite implementation */
290 int error;
291} BlockRequest;
292
293int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs,
294 int num_reqs);
295
7d780669 296/* sg packet commands */
221f715d
AL
297int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf);
298BlockDriverAIOCB *bdrv_aio_ioctl(BlockDriverState *bs,
299 unsigned long int req, void *buf,
300 BlockDriverCompletionFunc *cb, void *opaque);
7d780669 301
0f15423c
AL
302/* Invalidate any cached metadata used by image formats */
303void bdrv_invalidate_cache(BlockDriverState *bs);
304void bdrv_invalidate_cache_all(void);
305
07789269
BC
306void bdrv_clear_incoming_migration_all(void);
307
faf07963 308/* Ensure contents are flushed to disk. */
205ef796 309int bdrv_flush(BlockDriverState *bs);
07f07615 310int coroutine_fn bdrv_co_flush(BlockDriverState *bs);
f0f0fdfe 311int bdrv_flush_all(void);
2bc93fed 312void bdrv_close_all(void);
922453bc 313void bdrv_drain_all(void);
c6ca28d6 314
bb8bf76f 315int bdrv_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors);
4265d620 316int bdrv_co_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors);
3ac21627 317int bdrv_has_zero_init_1(BlockDriverState *bs);
f2feebbd 318int bdrv_has_zero_init(BlockDriverState *bs);
b6b8a333
PB
319int64_t bdrv_get_block_status(BlockDriverState *bs, int64_t sector_num,
320 int nb_sectors, int *pnum);
f58c7b35 321int bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
39aa9a12 322 int *pnum);
b35b2bba
MR
323int bdrv_is_allocated_above(BlockDriverState *top, BlockDriverState *base,
324 int64_t sector_num, int nb_sectors, int *pnum);
faf07963 325
ff06f5f3
PB
326void bdrv_set_on_error(BlockDriverState *bs, BlockdevOnError on_read_error,
327 BlockdevOnError on_write_error);
1ceee0d5 328BlockdevOnError bdrv_get_on_error(BlockDriverState *bs, bool is_read);
3e1caa5f
PB
329BlockErrorAction bdrv_get_error_action(BlockDriverState *bs, bool is_read, int error);
330void bdrv_error_action(BlockDriverState *bs, BlockErrorAction action,
331 bool is_read, int error);
faf07963 332int bdrv_is_read_only(BlockDriverState *bs);
985a03b0 333int bdrv_is_sg(BlockDriverState *bs);
e900a7b7 334int bdrv_enable_write_cache(BlockDriverState *bs);
425b0148 335void bdrv_set_enable_write_cache(BlockDriverState *bs, bool wce);
faf07963
PB
336int bdrv_is_inserted(BlockDriverState *bs);
337int bdrv_media_changed(BlockDriverState *bs);
025e849a 338void bdrv_lock_medium(BlockDriverState *bs, bool locked);
f36f3949 339void bdrv_eject(BlockDriverState *bs, bool eject_flag);
f8d6bba1 340const char *bdrv_get_format_name(BlockDriverState *bs);
faf07963 341BlockDriverState *bdrv_find(const char *name);
2f399b0a 342BlockDriverState *bdrv_next(BlockDriverState *bs);
51de9760
AL
343void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs),
344 void *opaque);
faf07963 345int bdrv_is_encrypted(BlockDriverState *bs);
c0f4ce77 346int bdrv_key_required(BlockDriverState *bs);
faf07963 347int bdrv_set_key(BlockDriverState *bs, const char *key);
c0f4ce77 348int bdrv_query_missing_keys(void);
faf07963
PB
349void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
350 void *opaque);
351const char *bdrv_get_device_name(BlockDriverState *bs);
c8433287 352int bdrv_get_flags(BlockDriverState *bs);
faf07963
PB
353int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
354 const uint8_t *buf, int nb_sectors);
355int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi);
eae041fe 356ImageInfoSpecific *bdrv_get_specific_info(BlockDriverState *bs);
343bded4
PB
357void bdrv_round_to_clusters(BlockDriverState *bs,
358 int64_t sector_num, int nb_sectors,
359 int64_t *cluster_sector_num,
360 int *cluster_nb_sectors);
faf07963 361
045df330 362const char *bdrv_get_encrypted_filename(BlockDriverState *bs);
faf07963
PB
363void bdrv_get_backing_filename(BlockDriverState *bs,
364 char *filename, int filename_size);
dc5a1371
PB
365void bdrv_get_full_backing_filename(BlockDriverState *bs,
366 char *dest, size_t sz);
199630b6 367int bdrv_is_snapshot(BlockDriverState *bs);
faf07963 368
faf07963
PB
369int path_is_absolute(const char *path);
370void path_combine(char *dest, int dest_size,
371 const char *base_path,
372 const char *filename);
373
cf8074b3 374int bdrv_writev_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos);
45566e9c
CH
375int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
376 int64_t pos, int size);
178e08a5 377
45566e9c
CH
378int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,
379 int64_t pos, int size);
178e08a5 380
d92ada22
LC
381void bdrv_img_create(const char *filename, const char *fmt,
382 const char *base_filename, const char *base_fmt,
f382d43a
MR
383 char *options, uint64_t img_size, int flags,
384 Error **errp, bool quiet);
f88e1a42 385
7b6f9300 386void bdrv_set_buffer_alignment(BlockDriverState *bs, int align);
ba5b7ad4 387void *qemu_blockalign(BlockDriverState *bs, size_t size);
c53b1c51 388bool bdrv_qiov_is_aligned(BlockDriverState *bs, QEMUIOVector *qiov);
ba5b7ad4 389
8f0720ec 390struct HBitmapIter;
50717e94 391void bdrv_set_dirty_tracking(BlockDriverState *bs, int granularity);
7cd1e32a 392int bdrv_get_dirty(BlockDriverState *bs, int64_t sector);
1755da16
PB
393void bdrv_set_dirty(BlockDriverState *bs, int64_t cur_sector, int nr_sectors);
394void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector, int nr_sectors);
8f0720ec 395void bdrv_dirty_iter_init(BlockDriverState *bs, struct HBitmapIter *hbi);
aaa0eb75 396int64_t bdrv_get_dirty_count(BlockDriverState *bs);
8b9b0cc2 397
53fec9d3
SH
398void bdrv_enable_copy_on_read(BlockDriverState *bs);
399void bdrv_disable_copy_on_read(BlockDriverState *bs);
400
9fcb0251
FZ
401void bdrv_ref(BlockDriverState *bs);
402void bdrv_unref(BlockDriverState *bs);
db593f25
MT
403void bdrv_set_in_use(BlockDriverState *bs, int in_use);
404int bdrv_in_use(BlockDriverState *bs);
8b9b0cc2 405
4065742a
SH
406#ifdef CONFIG_LINUX_AIO
407int raw_get_aio_fd(BlockDriverState *bs);
408#else
409static inline int raw_get_aio_fd(BlockDriverState *bs)
410{
411 return -ENOTSUP;
412}
413#endif
414
a597e79c
CH
415enum BlockAcctType {
416 BDRV_ACCT_READ,
417 BDRV_ACCT_WRITE,
418 BDRV_ACCT_FLUSH,
419 BDRV_MAX_IOTYPE,
420};
421
422typedef struct BlockAcctCookie {
423 int64_t bytes;
c488c7f6 424 int64_t start_time_ns;
a597e79c
CH
425 enum BlockAcctType type;
426} BlockAcctCookie;
427
428void bdrv_acct_start(BlockDriverState *bs, BlockAcctCookie *cookie,
429 int64_t bytes, enum BlockAcctType type);
430void bdrv_acct_done(BlockDriverState *bs, BlockAcctCookie *cookie);
431
8b9b0cc2 432typedef enum {
8252278a
KW
433 BLKDBG_L1_UPDATE,
434
435 BLKDBG_L1_GROW_ALLOC_TABLE,
436 BLKDBG_L1_GROW_WRITE_TABLE,
437 BLKDBG_L1_GROW_ACTIVATE_TABLE,
438
439 BLKDBG_L2_LOAD,
440 BLKDBG_L2_UPDATE,
441 BLKDBG_L2_UPDATE_COMPRESSED,
442 BLKDBG_L2_ALLOC_COW_READ,
443 BLKDBG_L2_ALLOC_WRITE,
444
8252278a 445 BLKDBG_READ_AIO,
8252278a
KW
446 BLKDBG_READ_BACKING_AIO,
447 BLKDBG_READ_COMPRESSED,
448
449 BLKDBG_WRITE_AIO,
450 BLKDBG_WRITE_COMPRESSED,
451
452 BLKDBG_VMSTATE_LOAD,
453 BLKDBG_VMSTATE_SAVE,
454
455 BLKDBG_COW_READ,
456 BLKDBG_COW_WRITE,
457
458 BLKDBG_REFTABLE_LOAD,
459 BLKDBG_REFTABLE_GROW,
afa50193 460 BLKDBG_REFTABLE_UPDATE,
8252278a
KW
461
462 BLKDBG_REFBLOCK_LOAD,
463 BLKDBG_REFBLOCK_UPDATE,
464 BLKDBG_REFBLOCK_UPDATE_PART,
465 BLKDBG_REFBLOCK_ALLOC,
466 BLKDBG_REFBLOCK_ALLOC_HOOKUP,
467 BLKDBG_REFBLOCK_ALLOC_WRITE,
468 BLKDBG_REFBLOCK_ALLOC_WRITE_BLOCKS,
469 BLKDBG_REFBLOCK_ALLOC_WRITE_TABLE,
470 BLKDBG_REFBLOCK_ALLOC_SWITCH_TABLE,
471
472 BLKDBG_CLUSTER_ALLOC,
473 BLKDBG_CLUSTER_ALLOC_BYTES,
474 BLKDBG_CLUSTER_FREE,
475
bf736fe3
KW
476 BLKDBG_FLUSH_TO_OS,
477 BLKDBG_FLUSH_TO_DISK,
478
8b9b0cc2
KW
479 BLKDBG_EVENT_MAX,
480} BlkDebugEvent;
481
482#define BLKDBG_EVENT(bs, evt) bdrv_debug_event(bs, evt)
483void bdrv_debug_event(BlockDriverState *bs, BlkDebugEvent event);
484
41c695c7
KW
485int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event,
486 const char *tag);
487int bdrv_debug_resume(BlockDriverState *bs, const char *tag);
488bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag);
489
8a4bc5aa 490#endif