exec.c: Remove useless comment
[qemu/ar7.git] / block.h
blobe77988e49cddee78b6798bf1e7daab1125368c92
1 #ifndef BLOCK_H
2 #define BLOCK_H
4 #include "qemu-aio.h"
5 #include "qemu-common.h"
6 #include "qemu-option.h"
7 #include "qemu-coroutine.h"
8 #include "qobject.h"
10 /* block.c */
11 typedef struct BlockDriver BlockDriver;
13 typedef 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;
18 } BlockDriverInfo;
20 typedef struct QEMUSnapshotInfo {
21 char id_str[128]; /* unique snapshot id */
22 /* the following fields are informative. They are not needed for
23 the consistency of the snapshot */
24 char name[256]; /* user choosen name */
25 uint32_t vm_state_size; /* VM state info size */
26 uint32_t date_sec; /* UTC date of the snapshot */
27 uint32_t date_nsec;
28 uint64_t vm_clock_nsec; /* VM clock relative to boot */
29 } QEMUSnapshotInfo;
31 /* Callbacks for block device models */
32 typedef struct BlockDevOps {
34 * Runs when virtual media changed (monitor commands eject, change)
35 * Argument load is true on load and false on eject.
36 * Beware: doesn't run when a host device's physical media
37 * changes. Sure would be useful if it did.
38 * Device models with removable media must implement this callback.
40 void (*change_media_cb)(void *opaque, bool load);
42 * Is the virtual tray open?
43 * Device models implement this only when the device has a tray.
45 bool (*is_tray_open)(void *opaque);
47 * Is the virtual medium locked into the device?
48 * Device models implement this only when device has such a lock.
50 bool (*is_medium_locked)(void *opaque);
52 * Runs when the size changed (e.g. monitor command block_resize)
54 void (*resize_cb)(void *opaque);
55 } BlockDevOps;
57 #define BDRV_O_RDWR 0x0002
58 #define BDRV_O_SNAPSHOT 0x0008 /* open the file read only and save writes in a snapshot */
59 #define BDRV_O_NOCACHE 0x0020 /* do not use the host page cache */
60 #define BDRV_O_CACHE_WB 0x0040 /* use write-back caching */
61 #define BDRV_O_NATIVE_AIO 0x0080 /* use native AIO instead of the thread pool */
62 #define BDRV_O_NO_BACKING 0x0100 /* don't open the backing file */
63 #define BDRV_O_NO_FLUSH 0x0200 /* disable flushing on this disk */
65 #define BDRV_O_CACHE_MASK (BDRV_O_NOCACHE | BDRV_O_CACHE_WB | BDRV_O_NO_FLUSH)
67 #define BDRV_SECTOR_BITS 9
68 #define BDRV_SECTOR_SIZE (1ULL << BDRV_SECTOR_BITS)
69 #define BDRV_SECTOR_MASK ~(BDRV_SECTOR_SIZE - 1)
71 typedef enum {
72 BLOCK_ERR_REPORT, BLOCK_ERR_IGNORE, BLOCK_ERR_STOP_ENOSPC,
73 BLOCK_ERR_STOP_ANY
74 } BlockErrorAction;
76 typedef enum {
77 BDRV_ACTION_REPORT, BDRV_ACTION_IGNORE, BDRV_ACTION_STOP
78 } BlockMonEventAction;
80 typedef enum {
81 BDRV_IOS_INVAL, BDRV_IOS_OK, BDRV_IOS_FAILED, BDRV_IOS_ENOSPC,
82 BDRV_IOS_MAX
83 } BlockIOStatus;
85 void bdrv_iostatus_enable(BlockDriverState *bs);
86 void bdrv_iostatus_reset(BlockDriverState *bs);
87 void bdrv_iostatus_disable(BlockDriverState *bs);
88 bool bdrv_iostatus_is_enabled(const BlockDriverState *bs);
89 void bdrv_iostatus_set_err(BlockDriverState *bs, int error);
90 void bdrv_mon_event(const BlockDriverState *bdrv,
91 BlockMonEventAction action, int is_read);
92 void bdrv_info_print(Monitor *mon, const QObject *data);
93 void bdrv_info(Monitor *mon, QObject **ret_data);
94 void bdrv_stats_print(Monitor *mon, const QObject *data);
95 void bdrv_info_stats(Monitor *mon, QObject **ret_data);
97 void bdrv_init(void);
98 void bdrv_init_with_whitelist(void);
99 BlockDriver *bdrv_find_protocol(const char *filename);
100 BlockDriver *bdrv_find_format(const char *format_name);
101 BlockDriver *bdrv_find_whitelisted_format(const char *format_name);
102 int bdrv_create(BlockDriver *drv, const char* filename,
103 QEMUOptionParameter *options);
104 int bdrv_create_file(const char* filename, QEMUOptionParameter *options);
105 BlockDriverState *bdrv_new(const char *device_name);
106 void bdrv_make_anon(BlockDriverState *bs);
107 void bdrv_delete(BlockDriverState *bs);
108 int bdrv_parse_cache_flags(const char *mode, int *flags);
109 int bdrv_file_open(BlockDriverState **pbs, const char *filename, int flags);
110 int bdrv_open(BlockDriverState *bs, const char *filename, int flags,
111 BlockDriver *drv);
112 void bdrv_close(BlockDriverState *bs);
113 int bdrv_attach_dev(BlockDriverState *bs, void *dev);
114 void bdrv_attach_dev_nofail(BlockDriverState *bs, void *dev);
115 void bdrv_detach_dev(BlockDriverState *bs, void *dev);
116 void *bdrv_get_attached_dev(BlockDriverState *bs);
117 void bdrv_set_dev_ops(BlockDriverState *bs, const BlockDevOps *ops,
118 void *opaque);
119 bool bdrv_dev_has_removable_media(BlockDriverState *bs);
120 bool bdrv_dev_is_tray_open(BlockDriverState *bs);
121 bool bdrv_dev_is_medium_locked(BlockDriverState *bs);
122 int bdrv_read(BlockDriverState *bs, int64_t sector_num,
123 uint8_t *buf, int nb_sectors);
124 int bdrv_write(BlockDriverState *bs, int64_t sector_num,
125 const uint8_t *buf, int nb_sectors);
126 int bdrv_pread(BlockDriverState *bs, int64_t offset,
127 void *buf, int count);
128 int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
129 const void *buf, int count);
130 int bdrv_pwrite_sync(BlockDriverState *bs, int64_t offset,
131 const void *buf, int count);
132 int coroutine_fn bdrv_co_readv(BlockDriverState *bs, int64_t sector_num,
133 int nb_sectors, QEMUIOVector *qiov);
134 int coroutine_fn bdrv_co_writev(BlockDriverState *bs, int64_t sector_num,
135 int nb_sectors, QEMUIOVector *qiov);
136 int bdrv_truncate(BlockDriverState *bs, int64_t offset);
137 int64_t bdrv_getlength(BlockDriverState *bs);
138 int64_t bdrv_get_allocated_file_size(BlockDriverState *bs);
139 void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr);
140 void bdrv_guess_geometry(BlockDriverState *bs, int *pcyls, int *pheads, int *psecs);
141 int bdrv_commit(BlockDriverState *bs);
142 void bdrv_commit_all(void);
143 int bdrv_change_backing_file(BlockDriverState *bs,
144 const char *backing_file, const char *backing_fmt);
145 void bdrv_register(BlockDriver *bdrv);
148 typedef struct BdrvCheckResult {
149 int corruptions;
150 int leaks;
151 int check_errors;
152 } BdrvCheckResult;
154 int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res);
156 /* async block I/O */
157 typedef struct BlockDriverAIOCB BlockDriverAIOCB;
158 typedef void BlockDriverCompletionFunc(void *opaque, int ret);
159 typedef void BlockDriverDirtyHandler(BlockDriverState *bs, int64_t sector,
160 int sector_num);
161 BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
162 QEMUIOVector *iov, int nb_sectors,
163 BlockDriverCompletionFunc *cb, void *opaque);
164 BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
165 QEMUIOVector *iov, int nb_sectors,
166 BlockDriverCompletionFunc *cb, void *opaque);
167 BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs,
168 BlockDriverCompletionFunc *cb, void *opaque);
169 void bdrv_aio_cancel(BlockDriverAIOCB *acb);
171 typedef struct BlockRequest {
172 /* Fields to be filled by multiwrite caller */
173 int64_t sector;
174 int nb_sectors;
175 QEMUIOVector *qiov;
176 BlockDriverCompletionFunc *cb;
177 void *opaque;
179 /* Filled by multiwrite implementation */
180 int error;
181 } BlockRequest;
183 int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs,
184 int num_reqs);
186 /* sg packet commands */
187 int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf);
188 BlockDriverAIOCB *bdrv_aio_ioctl(BlockDriverState *bs,
189 unsigned long int req, void *buf,
190 BlockDriverCompletionFunc *cb, void *opaque);
192 /* Ensure contents are flushed to disk. */
193 int bdrv_flush(BlockDriverState *bs);
194 void bdrv_flush_all(void);
195 void bdrv_close_all(void);
197 int bdrv_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors);
198 int bdrv_has_zero_init(BlockDriverState *bs);
199 int bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
200 int *pnum);
202 #define BIOS_ATA_TRANSLATION_AUTO 0
203 #define BIOS_ATA_TRANSLATION_NONE 1
204 #define BIOS_ATA_TRANSLATION_LBA 2
205 #define BIOS_ATA_TRANSLATION_LARGE 3
206 #define BIOS_ATA_TRANSLATION_RECHS 4
208 void bdrv_set_geometry_hint(BlockDriverState *bs,
209 int cyls, int heads, int secs);
210 void bdrv_set_translation_hint(BlockDriverState *bs, int translation);
211 void bdrv_get_geometry_hint(BlockDriverState *bs,
212 int *pcyls, int *pheads, int *psecs);
213 typedef enum FDriveType {
214 FDRIVE_DRV_144 = 0x00, /* 1.44 MB 3"5 drive */
215 FDRIVE_DRV_288 = 0x01, /* 2.88 MB 3"5 drive */
216 FDRIVE_DRV_120 = 0x02, /* 1.2 MB 5"25 drive */
217 FDRIVE_DRV_NONE = 0x03, /* No drive connected */
218 } FDriveType;
220 void bdrv_get_floppy_geometry_hint(BlockDriverState *bs, int *nb_heads,
221 int *max_track, int *last_sect,
222 FDriveType drive_in, FDriveType *drive);
223 int bdrv_get_translation_hint(BlockDriverState *bs);
224 void bdrv_set_on_error(BlockDriverState *bs, BlockErrorAction on_read_error,
225 BlockErrorAction on_write_error);
226 BlockErrorAction bdrv_get_on_error(BlockDriverState *bs, int is_read);
227 int bdrv_is_read_only(BlockDriverState *bs);
228 int bdrv_is_sg(BlockDriverState *bs);
229 int bdrv_enable_write_cache(BlockDriverState *bs);
230 int bdrv_is_inserted(BlockDriverState *bs);
231 int bdrv_media_changed(BlockDriverState *bs);
232 void bdrv_lock_medium(BlockDriverState *bs, bool locked);
233 void bdrv_eject(BlockDriverState *bs, int eject_flag);
234 void bdrv_get_format(BlockDriverState *bs, char *buf, int buf_size);
235 BlockDriverState *bdrv_find(const char *name);
236 BlockDriverState *bdrv_next(BlockDriverState *bs);
237 void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs),
238 void *opaque);
239 int bdrv_is_encrypted(BlockDriverState *bs);
240 int bdrv_key_required(BlockDriverState *bs);
241 int bdrv_set_key(BlockDriverState *bs, const char *key);
242 int bdrv_query_missing_keys(void);
243 void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
244 void *opaque);
245 const char *bdrv_get_device_name(BlockDriverState *bs);
246 int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
247 const uint8_t *buf, int nb_sectors);
248 int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi);
250 const char *bdrv_get_encrypted_filename(BlockDriverState *bs);
251 void bdrv_get_backing_filename(BlockDriverState *bs,
252 char *filename, int filename_size);
253 int bdrv_can_snapshot(BlockDriverState *bs);
254 int bdrv_is_snapshot(BlockDriverState *bs);
255 BlockDriverState *bdrv_snapshots(void);
256 int bdrv_snapshot_create(BlockDriverState *bs,
257 QEMUSnapshotInfo *sn_info);
258 int bdrv_snapshot_goto(BlockDriverState *bs,
259 const char *snapshot_id);
260 int bdrv_snapshot_delete(BlockDriverState *bs, const char *snapshot_id);
261 int bdrv_snapshot_list(BlockDriverState *bs,
262 QEMUSnapshotInfo **psn_info);
263 int bdrv_snapshot_load_tmp(BlockDriverState *bs,
264 const char *snapshot_name);
265 char *bdrv_snapshot_dump(char *buf, int buf_size, QEMUSnapshotInfo *sn);
267 char *get_human_readable_size(char *buf, int buf_size, int64_t size);
268 int path_is_absolute(const char *path);
269 void path_combine(char *dest, int dest_size,
270 const char *base_path,
271 const char *filename);
273 int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
274 int64_t pos, int size);
276 int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,
277 int64_t pos, int size);
279 int bdrv_img_create(const char *filename, const char *fmt,
280 const char *base_filename, const char *base_fmt,
281 char *options, uint64_t img_size, int flags);
283 void bdrv_set_buffer_alignment(BlockDriverState *bs, int align);
284 void *qemu_blockalign(BlockDriverState *bs, size_t size);
286 #define BDRV_SECTORS_PER_DIRTY_CHUNK 2048
288 void bdrv_set_dirty_tracking(BlockDriverState *bs, int enable);
289 int bdrv_get_dirty(BlockDriverState *bs, int64_t sector);
290 void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector,
291 int nr_sectors);
292 int64_t bdrv_get_dirty_count(BlockDriverState *bs);
294 void bdrv_set_in_use(BlockDriverState *bs, int in_use);
295 int bdrv_in_use(BlockDriverState *bs);
297 enum BlockAcctType {
298 BDRV_ACCT_READ,
299 BDRV_ACCT_WRITE,
300 BDRV_ACCT_FLUSH,
301 BDRV_MAX_IOTYPE,
304 typedef struct BlockAcctCookie {
305 int64_t bytes;
306 int64_t start_time_ns;
307 enum BlockAcctType type;
308 } BlockAcctCookie;
310 void bdrv_acct_start(BlockDriverState *bs, BlockAcctCookie *cookie,
311 int64_t bytes, enum BlockAcctType type);
312 void bdrv_acct_done(BlockDriverState *bs, BlockAcctCookie *cookie);
314 typedef enum {
315 BLKDBG_L1_UPDATE,
317 BLKDBG_L1_GROW_ALLOC_TABLE,
318 BLKDBG_L1_GROW_WRITE_TABLE,
319 BLKDBG_L1_GROW_ACTIVATE_TABLE,
321 BLKDBG_L2_LOAD,
322 BLKDBG_L2_UPDATE,
323 BLKDBG_L2_UPDATE_COMPRESSED,
324 BLKDBG_L2_ALLOC_COW_READ,
325 BLKDBG_L2_ALLOC_WRITE,
327 BLKDBG_READ,
328 BLKDBG_READ_AIO,
329 BLKDBG_READ_BACKING,
330 BLKDBG_READ_BACKING_AIO,
331 BLKDBG_READ_COMPRESSED,
333 BLKDBG_WRITE_AIO,
334 BLKDBG_WRITE_COMPRESSED,
336 BLKDBG_VMSTATE_LOAD,
337 BLKDBG_VMSTATE_SAVE,
339 BLKDBG_COW_READ,
340 BLKDBG_COW_WRITE,
342 BLKDBG_REFTABLE_LOAD,
343 BLKDBG_REFTABLE_GROW,
345 BLKDBG_REFBLOCK_LOAD,
346 BLKDBG_REFBLOCK_UPDATE,
347 BLKDBG_REFBLOCK_UPDATE_PART,
348 BLKDBG_REFBLOCK_ALLOC,
349 BLKDBG_REFBLOCK_ALLOC_HOOKUP,
350 BLKDBG_REFBLOCK_ALLOC_WRITE,
351 BLKDBG_REFBLOCK_ALLOC_WRITE_BLOCKS,
352 BLKDBG_REFBLOCK_ALLOC_WRITE_TABLE,
353 BLKDBG_REFBLOCK_ALLOC_SWITCH_TABLE,
355 BLKDBG_CLUSTER_ALLOC,
356 BLKDBG_CLUSTER_ALLOC_BYTES,
357 BLKDBG_CLUSTER_FREE,
359 BLKDBG_EVENT_MAX,
360 } BlkDebugEvent;
362 #define BLKDBG_EVENT(bs, evt) bdrv_debug_event(bs, evt)
363 void bdrv_debug_event(BlockDriverState *bs, BlkDebugEvent event);
366 /* Convenience for block device models */
368 typedef struct BlockConf {
369 BlockDriverState *bs;
370 uint16_t physical_block_size;
371 uint16_t logical_block_size;
372 uint16_t min_io_size;
373 uint32_t opt_io_size;
374 int32_t bootindex;
375 uint32_t discard_granularity;
376 } BlockConf;
378 static inline unsigned int get_physical_block_exp(BlockConf *conf)
380 unsigned int exp = 0, size;
382 for (size = conf->physical_block_size;
383 size > conf->logical_block_size;
384 size >>= 1) {
385 exp++;
388 return exp;
391 #define DEFINE_BLOCK_PROPERTIES(_state, _conf) \
392 DEFINE_PROP_DRIVE("drive", _state, _conf.bs), \
393 DEFINE_PROP_UINT16("logical_block_size", _state, \
394 _conf.logical_block_size, 512), \
395 DEFINE_PROP_UINT16("physical_block_size", _state, \
396 _conf.physical_block_size, 512), \
397 DEFINE_PROP_UINT16("min_io_size", _state, _conf.min_io_size, 0), \
398 DEFINE_PROP_UINT32("opt_io_size", _state, _conf.opt_io_size, 0), \
399 DEFINE_PROP_INT32("bootindex", _state, _conf.bootindex, -1), \
400 DEFINE_PROP_UINT32("discard_granularity", _state, \
401 _conf.discard_granularity, 0)
403 #endif