1 #ifndef BLOCK_H 2 #define BLOCK_H 3 4 #include "qemu-aio.h" 5 #include "qemu-common.h" 6 #include "qemu-option.h" 7 #include "qobject.h" 8 9 /* block.c */ 10 typedef struct BlockDriver BlockDriver; 11 12 typedef struct BlockDriverInfo { 13 /* in bytes, 0 if irrelevant */ 14 int cluster_size; 15 /* offset at which the VM state can be saved (0 if not possible) */ 16 int64_t vm_state_offset; 17 } BlockDriverInfo; 18 19 typedef struct QEMUSnapshotInfo { 20 char id_str[128]; /* unique snapshot id */ 21 /* the following fields are informative. They are not needed for 22 the consistency of the snapshot */ 23 char name[256]; /* user choosen name */ 24 uint32_t vm_state_size; /* VM state info size */ 25 uint32_t date_sec; /* UTC date of the snapshot */ 26 uint32_t date_nsec; 27 uint64_t vm_clock_nsec; /* VM clock relative to boot */ 28 } QEMUSnapshotInfo; 29 30 #define BDRV_O_RDWR 0x0002 31 #define BDRV_O_SNAPSHOT 0x0008 /* open the file read only and save writes in a snapshot */ 32 #define BDRV_O_NOCACHE 0x0020 /* do not use the host page cache */ 33 #define BDRV_O_CACHE_WB 0x0040 /* use write-back caching */ 34 #define BDRV_O_NATIVE_AIO 0x0080 /* use native AIO instead of the thread pool */ 35 #define BDRV_O_NO_BACKING 0x0100 /* don't open the backing file */ 36 #define BDRV_O_NO_FLUSH 0x0200 /* disable flushing on this disk */ 37 38 #define BDRV_O_CACHE_MASK (BDRV_O_NOCACHE | BDRV_O_CACHE_WB) 39 40 #define BDRV_SECTOR_BITS 9 41 #define BDRV_SECTOR_SIZE (1ULL << BDRV_SECTOR_BITS) 42 #define BDRV_SECTOR_MASK ~(BDRV_SECTOR_SIZE - 1) 43 44 typedef enum { 45 BLOCK_ERR_REPORT, BLOCK_ERR_IGNORE, BLOCK_ERR_STOP_ENOSPC, 46 BLOCK_ERR_STOP_ANY 47 } BlockErrorAction; 48 49 typedef enum { 50 BDRV_ACTION_REPORT, BDRV_ACTION_IGNORE, BDRV_ACTION_STOP 51 } BlockMonEventAction; 52 53 void bdrv_mon_event(const BlockDriverState *bdrv, 54 BlockMonEventAction action, int is_read); 55 void bdrv_info_print(Monitor *mon, const QObject *data); 56 void bdrv_info(Monitor *mon, QObject **ret_data); 57 void bdrv_stats_print(Monitor *mon, const QObject *data); 58 void bdrv_info_stats(Monitor *mon, QObject **ret_data); 59 60 void bdrv_init(void); 61 void bdrv_init_with_whitelist(void); 62 BlockDriver *bdrv_find_protocol(const char *filename); 63 BlockDriver *bdrv_find_format(const char *format_name); 64 BlockDriver *bdrv_find_whitelisted_format(const char *format_name); 65 int bdrv_create(BlockDriver *drv, const char* filename, 66 QEMUOptionParameter *options); 67 int bdrv_create_file(const char* filename, QEMUOptionParameter *options); 68 BlockDriverState *bdrv_new(const char *device_name); 69 void bdrv_delete(BlockDriverState *bs); 70 int bdrv_file_open(BlockDriverState **pbs, const char *filename, int flags); 71 int bdrv_open(BlockDriverState *bs, const char *filename, int flags, 72 BlockDriver *drv); 73 void bdrv_close(BlockDriverState *bs); 74 int bdrv_attach(BlockDriverState *bs, DeviceState *qdev); 75 void bdrv_detach(BlockDriverState *bs, DeviceState *qdev); 76 DeviceState *bdrv_get_attached(BlockDriverState *bs); 77 int bdrv_read(BlockDriverState *bs, int64_t sector_num, 78 uint8_t *buf, int nb_sectors); 79 int bdrv_write(BlockDriverState *bs, int64_t sector_num, 80 const uint8_t *buf, int nb_sectors); 81 int bdrv_pread(BlockDriverState *bs, int64_t offset, 82 void *buf, int count); 83 int bdrv_pwrite(BlockDriverState *bs, int64_t offset, 84 const void *buf, int count); 85 int bdrv_pwrite_sync(BlockDriverState *bs, int64_t offset, 86 const void *buf, int count); 87 int bdrv_write_sync(BlockDriverState *bs, int64_t sector_num, 88 const uint8_t *buf, int nb_sectors); 89 int bdrv_truncate(BlockDriverState *bs, int64_t offset); 90 int64_t bdrv_getlength(BlockDriverState *bs); 91 void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr); 92 void bdrv_guess_geometry(BlockDriverState *bs, int *pcyls, int *pheads, int *psecs); 93 int bdrv_commit(BlockDriverState *bs); 94 void bdrv_commit_all(void); 95 int bdrv_change_backing_file(BlockDriverState *bs, 96 const char *backing_file, const char *backing_fmt); 97 void bdrv_register(BlockDriver *bdrv); 98 99 100 typedef struct BdrvCheckResult { 101 int corruptions; 102 int leaks; 103 int check_errors; 104 } BdrvCheckResult; 105 106 int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res); 107 108 /* async block I/O */ 109 typedef struct BlockDriverAIOCB BlockDriverAIOCB; 110 typedef void BlockDriverCompletionFunc(void *opaque, int ret); 111 typedef void BlockDriverDirtyHandler(BlockDriverState *bs, int64_t sector, 112 int sector_num); 113 BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num, 114 QEMUIOVector *iov, int nb_sectors, 115 BlockDriverCompletionFunc *cb, void *opaque); 116 BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num, 117 QEMUIOVector *iov, int nb_sectors, 118 BlockDriverCompletionFunc *cb, void *opaque); 119 BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs, 120 BlockDriverCompletionFunc *cb, void *opaque); 121 void bdrv_aio_cancel(BlockDriverAIOCB *acb); 122 123 typedef struct BlockRequest { 124 /* Fields to be filled by multiwrite caller */ 125 int64_t sector; 126 int nb_sectors; 127 QEMUIOVector *qiov; 128 BlockDriverCompletionFunc *cb; 129 void *opaque; 130 131 /* Filled by multiwrite implementation */ 132 int error; 133 } BlockRequest; 134 135 int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs, 136 int num_reqs); 137 138 /* sg packet commands */ 139 int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf); 140 BlockDriverAIOCB *bdrv_aio_ioctl(BlockDriverState *bs, 141 unsigned long int req, void *buf, 142 BlockDriverCompletionFunc *cb, void *opaque); 143 144 /* Ensure contents are flushed to disk. */ 145 void bdrv_flush(BlockDriverState *bs); 146 void bdrv_flush_all(void); 147 void bdrv_close_all(void); 148 149 int bdrv_has_zero_init(BlockDriverState *bs); 150 int bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num, int nb_sectors, 151 int *pnum); 152 153 #define BDRV_TYPE_HD 0 154 #define BDRV_TYPE_CDROM 1 155 #define BDRV_TYPE_FLOPPY 2 156 #define BIOS_ATA_TRANSLATION_AUTO 0 157 #define BIOS_ATA_TRANSLATION_NONE 1 158 #define BIOS_ATA_TRANSLATION_LBA 2 159 #define BIOS_ATA_TRANSLATION_LARGE 3 160 #define BIOS_ATA_TRANSLATION_RECHS 4 161 162 void bdrv_set_geometry_hint(BlockDriverState *bs, 163 int cyls, int heads, int secs); 164 void bdrv_set_type_hint(BlockDriverState *bs, int type); 165 void bdrv_set_translation_hint(BlockDriverState *bs, int translation); 166 void bdrv_get_geometry_hint(BlockDriverState *bs, 167 int *pcyls, int *pheads, int *psecs); 168 int bdrv_get_type_hint(BlockDriverState *bs); 169 int bdrv_get_translation_hint(BlockDriverState *bs); 170 void bdrv_set_on_error(BlockDriverState *bs, BlockErrorAction on_read_error, 171 BlockErrorAction on_write_error); 172 BlockErrorAction bdrv_get_on_error(BlockDriverState *bs, int is_read); 173 void bdrv_set_removable(BlockDriverState *bs, int removable); 174 int bdrv_is_removable(BlockDriverState *bs); 175 int bdrv_is_read_only(BlockDriverState *bs); 176 int bdrv_is_sg(BlockDriverState *bs); 177 int bdrv_enable_write_cache(BlockDriverState *bs); 178 int bdrv_is_inserted(BlockDriverState *bs); 179 int bdrv_media_changed(BlockDriverState *bs); 180 int bdrv_is_locked(BlockDriverState *bs); 181 void bdrv_set_locked(BlockDriverState *bs, int locked); 182 int bdrv_eject(BlockDriverState *bs, int eject_flag); 183 void bdrv_set_change_cb(BlockDriverState *bs, 184 void (*change_cb)(void *opaque), void *opaque); 185 void bdrv_get_format(BlockDriverState *bs, char *buf, int buf_size); 186 BlockDriverState *bdrv_find(const char *name); 187 BlockDriverState *bdrv_next(BlockDriverState *bs); 188 void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs), 189 void *opaque); 190 int bdrv_is_encrypted(BlockDriverState *bs); 191 int bdrv_key_required(BlockDriverState *bs); 192 int bdrv_set_key(BlockDriverState *bs, const char *key); 193 int bdrv_query_missing_keys(void); 194 void bdrv_iterate_format(void (*it)(void *opaque, const char *name), 195 void *opaque); 196 const char *bdrv_get_device_name(BlockDriverState *bs); 197 int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num, 198 const uint8_t *buf, int nb_sectors); 199 int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi); 200 201 const char *bdrv_get_encrypted_filename(BlockDriverState *bs); 202 void bdrv_get_backing_filename(BlockDriverState *bs, 203 char *filename, int filename_size); 204 int bdrv_can_snapshot(BlockDriverState *bs); 205 int bdrv_is_snapshot(BlockDriverState *bs); 206 BlockDriverState *bdrv_snapshots(void); 207 int bdrv_snapshot_create(BlockDriverState *bs, 208 QEMUSnapshotInfo *sn_info); 209 int bdrv_snapshot_goto(BlockDriverState *bs, 210 const char *snapshot_id); 211 int bdrv_snapshot_delete(BlockDriverState *bs, const char *snapshot_id); 212 int bdrv_snapshot_list(BlockDriverState *bs, 213 QEMUSnapshotInfo **psn_info); 214 char *bdrv_snapshot_dump(char *buf, int buf_size, QEMUSnapshotInfo *sn); 215 216 char *get_human_readable_size(char *buf, int buf_size, int64_t size); 217 int path_is_absolute(const char *path); 218 void path_combine(char *dest, int dest_size, 219 const char *base_path, 220 const char *filename); 221 222 int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf, 223 int64_t pos, int size); 224 225 int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf, 226 int64_t pos, int size); 227 228 #define BDRV_SECTORS_PER_DIRTY_CHUNK 2048 229 230 void bdrv_set_dirty_tracking(BlockDriverState *bs, int enable); 231 int bdrv_get_dirty(BlockDriverState *bs, int64_t sector); 232 void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector, 233 int nr_sectors); 234 int64_t bdrv_get_dirty_count(BlockDriverState *bs); 235 236 237 typedef enum { 238 BLKDBG_L1_UPDATE, 239 240 BLKDBG_L1_GROW_ALLOC_TABLE, 241 BLKDBG_L1_GROW_WRITE_TABLE, 242 BLKDBG_L1_GROW_ACTIVATE_TABLE, 243 244 BLKDBG_L2_LOAD, 245 BLKDBG_L2_UPDATE, 246 BLKDBG_L2_UPDATE_COMPRESSED, 247 BLKDBG_L2_ALLOC_COW_READ, 248 BLKDBG_L2_ALLOC_WRITE, 249 250 BLKDBG_READ, 251 BLKDBG_READ_AIO, 252 BLKDBG_READ_BACKING, 253 BLKDBG_READ_BACKING_AIO, 254 BLKDBG_READ_COMPRESSED, 255 256 BLKDBG_WRITE_AIO, 257 BLKDBG_WRITE_COMPRESSED, 258 259 BLKDBG_VMSTATE_LOAD, 260 BLKDBG_VMSTATE_SAVE, 261 262 BLKDBG_COW_READ, 263 BLKDBG_COW_WRITE, 264 265 BLKDBG_REFTABLE_LOAD, 266 BLKDBG_REFTABLE_GROW, 267 268 BLKDBG_REFBLOCK_LOAD, 269 BLKDBG_REFBLOCK_UPDATE, 270 BLKDBG_REFBLOCK_UPDATE_PART, 271 BLKDBG_REFBLOCK_ALLOC, 272 BLKDBG_REFBLOCK_ALLOC_HOOKUP, 273 BLKDBG_REFBLOCK_ALLOC_WRITE, 274 BLKDBG_REFBLOCK_ALLOC_WRITE_BLOCKS, 275 BLKDBG_REFBLOCK_ALLOC_WRITE_TABLE, 276 BLKDBG_REFBLOCK_ALLOC_SWITCH_TABLE, 277 278 BLKDBG_CLUSTER_ALLOC, 279 BLKDBG_CLUSTER_ALLOC_BYTES, 280 BLKDBG_CLUSTER_FREE, 281 282 BLKDBG_EVENT_MAX, 283 } BlkDebugEvent; 284 285 #define BLKDBG_EVENT(bs, evt) bdrv_debug_event(bs, evt) 286 void bdrv_debug_event(BlockDriverState *bs, BlkDebugEvent event); 287 288 #endif 289