]> git.proxmox.com Git - mirror_qemu.git/blame - block.h
target-ppc: simplify NaN propagation for vector functions
[mirror_qemu.git] / block.h
CommitLineData
faf07963
PB
1#ifndef BLOCK_H
2#define BLOCK_H
3
a76bab49 4#include "qemu-aio.h"
3b69e4b9 5#include "qemu-common.h"
0e7e1989 6#include "qemu-option.h"
da1fa91d 7#include "qemu-coroutine.h"
d15e5465 8#include "qobject.h"
a76bab49 9
faf07963 10/* block.c */
faf07963
PB
11typedef struct BlockDriver BlockDriver;
12
faf07963
PB
13typedef struct BlockDriverInfo {
14 /* in bytes, 0 if irrelevant */
15 int cluster_size;
16 /* offset at which the VM state can be saved (0 if not possible) */
17 int64_t vm_state_offset;
64c79160 18 bool is_dirty;
faf07963
PB
19} BlockDriverInfo;
20
f8111c24
DXW
21typedef struct BlockFragInfo {
22 uint64_t allocated_clusters;
23 uint64_t total_clusters;
24 uint64_t fragmented_clusters;
25} BlockFragInfo;
26
faf07963
PB
27typedef struct QEMUSnapshotInfo {
28 char id_str[128]; /* unique snapshot id */
29 /* the following fields are informative. They are not needed for
30 the consistency of the snapshot */
e7d81004 31 char name[256]; /* user chosen name */
c2c9a466 32 uint64_t vm_state_size; /* VM state info size */
faf07963
PB
33 uint32_t date_sec; /* UTC date of the snapshot */
34 uint32_t date_nsec;
35 uint64_t vm_clock_nsec; /* VM clock relative to boot */
36} QEMUSnapshotInfo;
37
145feb17 38/* Callbacks for block device models */
0e49de52 39typedef struct BlockDevOps {
145feb17
MA
40 /*
41 * Runs when virtual media changed (monitor commands eject, change)
7d4b4ba5 42 * Argument load is true on load and false on eject.
145feb17
MA
43 * Beware: doesn't run when a host device's physical media
44 * changes. Sure would be useful if it did.
2c6942fa 45 * Device models with removable media must implement this callback.
145feb17 46 */
7d4b4ba5 47 void (*change_media_cb)(void *opaque, bool load);
025ccaa7
PB
48 /*
49 * Runs when an eject request is issued from the monitor, the tray
50 * is closed, and the medium is locked.
51 * Device models that do not implement is_medium_locked will not need
52 * this callback. Device models that can lock the medium or tray might
53 * want to implement the callback and unlock the tray when "force" is
54 * true, even if they do not support eject requests.
55 */
56 void (*eject_request_cb)(void *opaque, bool force);
e4def80b
MA
57 /*
58 * Is the virtual tray open?
59 * Device models implement this only when the device has a tray.
60 */
61 bool (*is_tray_open)(void *opaque);
f107639a
MA
62 /*
63 * Is the virtual medium locked into the device?
64 * Device models implement this only when device has such a lock.
65 */
66 bool (*is_medium_locked)(void *opaque);
145feb17
MA
67 /*
68 * Runs when the size changed (e.g. monitor command block_resize)
69 */
70 void (*resize_cb)(void *opaque);
0e49de52
MA
71} BlockDevOps;
72
faf07963 73#define BDRV_O_RDWR 0x0002
faf07963 74#define BDRV_O_SNAPSHOT 0x0008 /* open the file read only and save writes in a snapshot */
9f7965c7
AL
75#define BDRV_O_NOCACHE 0x0020 /* do not use the host page cache */
76#define BDRV_O_CACHE_WB 0x0040 /* use write-back caching */
5c6c3a6c 77#define BDRV_O_NATIVE_AIO 0x0080 /* use native AIO instead of the thread pool */
b783e409 78#define BDRV_O_NO_BACKING 0x0100 /* don't open the backing file */
016f5cf6 79#define BDRV_O_NO_FLUSH 0x0200 /* disable flushing on this disk */
53fec9d3 80#define BDRV_O_COPY_ON_READ 0x0400 /* copy read backing sectors into image */
ccb1f4a7 81#define BDRV_O_INCOMING 0x0800 /* consistency hint for incoming migration */
058f8f16 82#define BDRV_O_CHECK 0x1000 /* open solely for consistency check */
be028adc 83#define BDRV_O_ALLOW_RDWR 0x2000 /* allow reopen to change from r/o to r/w */
9f7965c7 84
ceb25e5c 85#define BDRV_O_CACHE_MASK (BDRV_O_NOCACHE | BDRV_O_CACHE_WB | BDRV_O_NO_FLUSH)
faf07963 86
6ea44308 87#define BDRV_SECTOR_BITS 9
c63782cb 88#define BDRV_SECTOR_SIZE (1ULL << BDRV_SECTOR_BITS)
3abbc4d9 89#define BDRV_SECTOR_MASK ~(BDRV_SECTOR_SIZE - 1)
6ea44308 90
abd7f68d
MA
91typedef enum {
92 BLOCK_ERR_REPORT, BLOCK_ERR_IGNORE, BLOCK_ERR_STOP_ENOSPC,
93 BLOCK_ERR_STOP_ANY
94} BlockErrorAction;
95
2582bfed
LC
96typedef enum {
97 BDRV_ACTION_REPORT, BDRV_ACTION_IGNORE, BDRV_ACTION_STOP
329c0a48 98} BlockQMPEventAction;
2582bfed 99
e971aa12
JC
100typedef QSIMPLEQ_HEAD(BlockReopenQueue, BlockReopenQueueEntry) BlockReopenQueue;
101
102typedef struct BDRVReopenState {
103 BlockDriverState *bs;
104 int flags;
105 void *opaque;
106} BDRVReopenState;
107
108
28a7282a
LC
109void bdrv_iostatus_enable(BlockDriverState *bs);
110void bdrv_iostatus_reset(BlockDriverState *bs);
111void bdrv_iostatus_disable(BlockDriverState *bs);
112bool bdrv_iostatus_is_enabled(const BlockDriverState *bs);
113void bdrv_iostatus_set_err(BlockDriverState *bs, int error);
329c0a48
LC
114void bdrv_emit_qmp_error_event(const BlockDriverState *bdrv,
115 BlockQMPEventAction action, int is_read);
d15e5465
LC
116void bdrv_info_print(Monitor *mon, const QObject *data);
117void bdrv_info(Monitor *mon, QObject **ret_data);
218a536a
LC
118void bdrv_stats_print(Monitor *mon, const QObject *data);
119void bdrv_info_stats(Monitor *mon, QObject **ret_data);
faf07963 120
0563e191
ZYW
121/* disk I/O throttling */
122void bdrv_io_limits_enable(BlockDriverState *bs);
98f90dba 123void bdrv_io_limits_disable(BlockDriverState *bs);
0563e191
ZYW
124bool bdrv_io_limits_enabled(BlockDriverState *bs);
125
faf07963 126void bdrv_init(void);
eb852011 127void bdrv_init_with_whitelist(void);
b50cbabc 128BlockDriver *bdrv_find_protocol(const char *filename);
faf07963 129BlockDriver *bdrv_find_format(const char *format_name);
eb852011 130BlockDriver *bdrv_find_whitelisted_format(const char *format_name);
0e7e1989
KW
131int bdrv_create(BlockDriver *drv, const char* filename,
132 QEMUOptionParameter *options);
84a12e66 133int bdrv_create_file(const char* filename, QEMUOptionParameter *options);
faf07963 134BlockDriverState *bdrv_new(const char *device_name);
d22b2f41 135void bdrv_make_anon(BlockDriverState *bs);
4ddc07ca 136void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old);
8802d1fd 137void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top);
faf07963 138void bdrv_delete(BlockDriverState *bs);
c3993cdc 139int bdrv_parse_cache_flags(const char *mode, int *flags);
faf07963 140int bdrv_file_open(BlockDriverState **pbs, const char *filename, int flags);
d6e9098e
KW
141int bdrv_open(BlockDriverState *bs, const char *filename, int flags,
142 BlockDriver *drv);
e971aa12
JC
143BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
144 BlockDriverState *bs, int flags);
145int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp);
146int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp);
147int bdrv_reopen_prepare(BDRVReopenState *reopen_state,
148 BlockReopenQueue *queue, Error **errp);
149void bdrv_reopen_commit(BDRVReopenState *reopen_state);
150void bdrv_reopen_abort(BDRVReopenState *reopen_state);
faf07963 151void bdrv_close(BlockDriverState *bs);
fa879d62
MA
152int bdrv_attach_dev(BlockDriverState *bs, void *dev);
153void bdrv_attach_dev_nofail(BlockDriverState *bs, void *dev);
154void bdrv_detach_dev(BlockDriverState *bs, void *dev);
155void *bdrv_get_attached_dev(BlockDriverState *bs);
0e49de52
MA
156void bdrv_set_dev_ops(BlockDriverState *bs, const BlockDevOps *ops,
157 void *opaque);
025ccaa7 158void bdrv_dev_eject_request(BlockDriverState *bs, bool force);
2c6942fa 159bool bdrv_dev_has_removable_media(BlockDriverState *bs);
e4def80b 160bool bdrv_dev_is_tray_open(BlockDriverState *bs);
f107639a 161bool bdrv_dev_is_medium_locked(BlockDriverState *bs);
faf07963
PB
162int bdrv_read(BlockDriverState *bs, int64_t sector_num,
163 uint8_t *buf, int nb_sectors);
07d27a44
MA
164int bdrv_read_unthrottled(BlockDriverState *bs, int64_t sector_num,
165 uint8_t *buf, int nb_sectors);
faf07963
PB
166int bdrv_write(BlockDriverState *bs, int64_t sector_num,
167 const uint8_t *buf, int nb_sectors);
168int bdrv_pread(BlockDriverState *bs, int64_t offset,
169 void *buf, int count);
170int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
171 const void *buf, int count);
f08145fe
KW
172int bdrv_pwrite_sync(BlockDriverState *bs, int64_t offset,
173 const void *buf, int count);
da1fa91d
KW
174int coroutine_fn bdrv_co_readv(BlockDriverState *bs, int64_t sector_num,
175 int nb_sectors, QEMUIOVector *qiov);
470c0504
SH
176int coroutine_fn bdrv_co_copy_on_readv(BlockDriverState *bs,
177 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov);
da1fa91d
KW
178int coroutine_fn bdrv_co_writev(BlockDriverState *bs, int64_t sector_num,
179 int nb_sectors, QEMUIOVector *qiov);
f08f2dda
SH
180/*
181 * Efficiently zero a region of the disk image. Note that this is a regular
182 * I/O request like read or write and should have a reasonable size. This
183 * function is not suitable for zeroing the entire image in a single request
184 * because it may allocate memory for the entire region.
185 */
186int coroutine_fn bdrv_co_write_zeroes(BlockDriverState *bs, int64_t sector_num,
187 int nb_sectors);
060f51c9
SH
188int coroutine_fn bdrv_co_is_allocated(BlockDriverState *bs, int64_t sector_num,
189 int nb_sectors, int *pnum);
188a7bbf
PB
190int coroutine_fn bdrv_co_is_allocated_above(BlockDriverState *top,
191 BlockDriverState *base,
192 int64_t sector_num,
193 int nb_sectors, int *pnum);
e8a6bb9c
MT
194BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
195 const char *backing_file);
f198fd1c 196int bdrv_get_backing_file_depth(BlockDriverState *bs);
faf07963
PB
197int bdrv_truncate(BlockDriverState *bs, int64_t offset);
198int64_t bdrv_getlength(BlockDriverState *bs);
4a1d5e1f 199int64_t bdrv_get_allocated_file_size(BlockDriverState *bs);
96b8f136 200void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr);
faf07963 201int bdrv_commit(BlockDriverState *bs);
e8877497 202int bdrv_commit_all(void);
756e6736
KW
203int bdrv_change_backing_file(BlockDriverState *bs,
204 const char *backing_file, const char *backing_fmt);
5efa9d5a
AL
205void bdrv_register(BlockDriver *bdrv);
206
e076f338
KW
207
208typedef struct BdrvCheckResult {
209 int corruptions;
210 int leaks;
211 int check_errors;
ccf34716
KW
212 int corruptions_fixed;
213 int leaks_fixed;
f8111c24 214 BlockFragInfo bfi;
e076f338
KW
215} BdrvCheckResult;
216
4534ff54
KW
217typedef enum {
218 BDRV_FIX_LEAKS = 1,
219 BDRV_FIX_ERRORS = 2,
220} BdrvCheckMode;
221
222int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix);
e076f338 223
faf07963 224/* async block I/O */
7cd1e32a 225typedef void BlockDriverDirtyHandler(BlockDriverState *bs, int64_t sector,
39aa9a12 226 int sector_num);
3b69e4b9
AL
227BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
228 QEMUIOVector *iov, int nb_sectors,
229 BlockDriverCompletionFunc *cb, void *opaque);
230BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
231 QEMUIOVector *iov, int nb_sectors,
232 BlockDriverCompletionFunc *cb, void *opaque);
b2e12bc6 233BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs,
39aa9a12 234 BlockDriverCompletionFunc *cb, void *opaque);
4265d620
PB
235BlockDriverAIOCB *bdrv_aio_discard(BlockDriverState *bs,
236 int64_t sector_num, int nb_sectors,
237 BlockDriverCompletionFunc *cb, void *opaque);
faf07963
PB
238void bdrv_aio_cancel(BlockDriverAIOCB *acb);
239
40b4f539
KW
240typedef struct BlockRequest {
241 /* Fields to be filled by multiwrite caller */
242 int64_t sector;
243 int nb_sectors;
244 QEMUIOVector *qiov;
245 BlockDriverCompletionFunc *cb;
246 void *opaque;
247
248 /* Filled by multiwrite implementation */
249 int error;
250} BlockRequest;
251
252int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs,
253 int num_reqs);
254
7d780669 255/* sg packet commands */
221f715d
AL
256int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf);
257BlockDriverAIOCB *bdrv_aio_ioctl(BlockDriverState *bs,
258 unsigned long int req, void *buf,
259 BlockDriverCompletionFunc *cb, void *opaque);
7d780669 260
0f15423c
AL
261/* Invalidate any cached metadata used by image formats */
262void bdrv_invalidate_cache(BlockDriverState *bs);
263void bdrv_invalidate_cache_all(void);
264
07789269
BC
265void bdrv_clear_incoming_migration_all(void);
266
faf07963 267/* Ensure contents are flushed to disk. */
205ef796 268int bdrv_flush(BlockDriverState *bs);
07f07615 269int coroutine_fn bdrv_co_flush(BlockDriverState *bs);
c6ca28d6 270void bdrv_flush_all(void);
2bc93fed 271void bdrv_close_all(void);
922453bc 272void bdrv_drain_all(void);
c6ca28d6 273
bb8bf76f 274int bdrv_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors);
4265d620 275int bdrv_co_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors);
f2feebbd 276int bdrv_has_zero_init(BlockDriverState *bs);
f58c7b35 277int bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
39aa9a12 278 int *pnum);
faf07963 279
abd7f68d
MA
280void bdrv_set_on_error(BlockDriverState *bs, BlockErrorAction on_read_error,
281 BlockErrorAction on_write_error);
282BlockErrorAction bdrv_get_on_error(BlockDriverState *bs, int is_read);
faf07963 283int bdrv_is_read_only(BlockDriverState *bs);
985a03b0 284int bdrv_is_sg(BlockDriverState *bs);
e900a7b7 285int bdrv_enable_write_cache(BlockDriverState *bs);
425b0148 286void bdrv_set_enable_write_cache(BlockDriverState *bs, bool wce);
faf07963
PB
287int bdrv_is_inserted(BlockDriverState *bs);
288int bdrv_media_changed(BlockDriverState *bs);
025e849a 289void bdrv_lock_medium(BlockDriverState *bs, bool locked);
f36f3949 290void bdrv_eject(BlockDriverState *bs, bool eject_flag);
f8d6bba1 291const char *bdrv_get_format_name(BlockDriverState *bs);
faf07963 292BlockDriverState *bdrv_find(const char *name);
2f399b0a 293BlockDriverState *bdrv_next(BlockDriverState *bs);
51de9760
AL
294void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs),
295 void *opaque);
faf07963 296int bdrv_is_encrypted(BlockDriverState *bs);
c0f4ce77 297int bdrv_key_required(BlockDriverState *bs);
faf07963 298int bdrv_set_key(BlockDriverState *bs, const char *key);
c0f4ce77 299int bdrv_query_missing_keys(void);
faf07963
PB
300void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
301 void *opaque);
302const char *bdrv_get_device_name(BlockDriverState *bs);
c8433287 303int bdrv_get_flags(BlockDriverState *bs);
faf07963
PB
304int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
305 const uint8_t *buf, int nb_sectors);
306int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi);
307
045df330 308const char *bdrv_get_encrypted_filename(BlockDriverState *bs);
faf07963
PB
309void bdrv_get_backing_filename(BlockDriverState *bs,
310 char *filename, int filename_size);
dc5a1371
PB
311void bdrv_get_full_backing_filename(BlockDriverState *bs,
312 char *dest, size_t sz);
feeee5ac 313int bdrv_can_snapshot(BlockDriverState *bs);
199630b6 314int bdrv_is_snapshot(BlockDriverState *bs);
f9092b10 315BlockDriverState *bdrv_snapshots(void);
faf07963
PB
316int bdrv_snapshot_create(BlockDriverState *bs,
317 QEMUSnapshotInfo *sn_info);
318int bdrv_snapshot_goto(BlockDriverState *bs,
319 const char *snapshot_id);
320int bdrv_snapshot_delete(BlockDriverState *bs, const char *snapshot_id);
321int bdrv_snapshot_list(BlockDriverState *bs,
322 QEMUSnapshotInfo **psn_info);
51ef6727 323int bdrv_snapshot_load_tmp(BlockDriverState *bs,
324 const char *snapshot_name);
faf07963
PB
325char *bdrv_snapshot_dump(char *buf, int buf_size, QEMUSnapshotInfo *sn);
326
327char *get_human_readable_size(char *buf, int buf_size, int64_t size);
328int path_is_absolute(const char *path);
329void path_combine(char *dest, int dest_size,
330 const char *base_path,
331 const char *filename);
332
45566e9c
CH
333int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
334 int64_t pos, int size);
178e08a5 335
45566e9c
CH
336int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,
337 int64_t pos, int size);
178e08a5 338
f88e1a42
JS
339int bdrv_img_create(const char *filename, const char *fmt,
340 const char *base_filename, const char *base_fmt,
341 char *options, uint64_t img_size, int flags);
342
7b6f9300 343void bdrv_set_buffer_alignment(BlockDriverState *bs, int align);
ba5b7ad4
MA
344void *qemu_blockalign(BlockDriverState *bs, size_t size);
345
23bd90d2 346#define BDRV_SECTORS_PER_DIRTY_CHUNK 2048
6ea44308 347
7cd1e32a
LS
348void bdrv_set_dirty_tracking(BlockDriverState *bs, int enable);
349int bdrv_get_dirty(BlockDriverState *bs, int64_t sector);
a55eb92c
JK
350void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector,
351 int nr_sectors);
aaa0eb75 352int64_t bdrv_get_dirty_count(BlockDriverState *bs);
8b9b0cc2 353
53fec9d3
SH
354void bdrv_enable_copy_on_read(BlockDriverState *bs);
355void bdrv_disable_copy_on_read(BlockDriverState *bs);
356
db593f25
MT
357void bdrv_set_in_use(BlockDriverState *bs, int in_use);
358int bdrv_in_use(BlockDriverState *bs);
8b9b0cc2 359
a597e79c
CH
360enum BlockAcctType {
361 BDRV_ACCT_READ,
362 BDRV_ACCT_WRITE,
363 BDRV_ACCT_FLUSH,
364 BDRV_MAX_IOTYPE,
365};
366
367typedef struct BlockAcctCookie {
368 int64_t bytes;
c488c7f6 369 int64_t start_time_ns;
a597e79c
CH
370 enum BlockAcctType type;
371} BlockAcctCookie;
372
373void bdrv_acct_start(BlockDriverState *bs, BlockAcctCookie *cookie,
374 int64_t bytes, enum BlockAcctType type);
375void bdrv_acct_done(BlockDriverState *bs, BlockAcctCookie *cookie);
376
8b9b0cc2 377typedef enum {
8252278a
KW
378 BLKDBG_L1_UPDATE,
379
380 BLKDBG_L1_GROW_ALLOC_TABLE,
381 BLKDBG_L1_GROW_WRITE_TABLE,
382 BLKDBG_L1_GROW_ACTIVATE_TABLE,
383
384 BLKDBG_L2_LOAD,
385 BLKDBG_L2_UPDATE,
386 BLKDBG_L2_UPDATE_COMPRESSED,
387 BLKDBG_L2_ALLOC_COW_READ,
388 BLKDBG_L2_ALLOC_WRITE,
389
8252278a 390 BLKDBG_READ_AIO,
8252278a
KW
391 BLKDBG_READ_BACKING_AIO,
392 BLKDBG_READ_COMPRESSED,
393
394 BLKDBG_WRITE_AIO,
395 BLKDBG_WRITE_COMPRESSED,
396
397 BLKDBG_VMSTATE_LOAD,
398 BLKDBG_VMSTATE_SAVE,
399
400 BLKDBG_COW_READ,
401 BLKDBG_COW_WRITE,
402
403 BLKDBG_REFTABLE_LOAD,
404 BLKDBG_REFTABLE_GROW,
405
406 BLKDBG_REFBLOCK_LOAD,
407 BLKDBG_REFBLOCK_UPDATE,
408 BLKDBG_REFBLOCK_UPDATE_PART,
409 BLKDBG_REFBLOCK_ALLOC,
410 BLKDBG_REFBLOCK_ALLOC_HOOKUP,
411 BLKDBG_REFBLOCK_ALLOC_WRITE,
412 BLKDBG_REFBLOCK_ALLOC_WRITE_BLOCKS,
413 BLKDBG_REFBLOCK_ALLOC_WRITE_TABLE,
414 BLKDBG_REFBLOCK_ALLOC_SWITCH_TABLE,
415
416 BLKDBG_CLUSTER_ALLOC,
417 BLKDBG_CLUSTER_ALLOC_BYTES,
418 BLKDBG_CLUSTER_FREE,
419
8b9b0cc2
KW
420 BLKDBG_EVENT_MAX,
421} BlkDebugEvent;
422
423#define BLKDBG_EVENT(bs, evt) bdrv_debug_event(bs, evt)
424void bdrv_debug_event(BlockDriverState *bs, BlkDebugEvent event);
425
8a4bc5aa 426#endif