Annotation of qemu/block.h, revision 1.1.1.13
1.1 root 1: #ifndef BLOCK_H
2: #define BLOCK_H
3:
1.1.1.2 root 4: #include "qemu-aio.h"
5: #include "qemu-common.h"
1.1.1.5 root 6: #include "qemu-option.h"
1.1.1.12 root 7: #include "qemu-coroutine.h"
1.1.1.6 root 8: #include "qobject.h"
1.1.1.2 root 9:
1.1 root 10: /* block.c */
11: typedef struct BlockDriver BlockDriver;
12:
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;
1.1.1.13! root 18: bool is_dirty;
1.1 root 19: } BlockDriverInfo;
20:
1.1.1.13! root 21: typedef struct BlockFragInfo {
! 22: uint64_t allocated_clusters;
! 23: uint64_t total_clusters;
! 24: uint64_t fragmented_clusters;
! 25: } BlockFragInfo;
! 26:
1.1 root 27: typedef 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 */
1.1.1.13! root 31: char name[256]; /* user chosen name */
! 32: uint64_t vm_state_size; /* VM state info size */
1.1 root 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:
1.1.1.12 root 38: /* Callbacks for block device models */
39: typedef struct BlockDevOps {
40: /*
41: * Runs when virtual media changed (monitor commands eject, change)
42: * Argument load is true on load and false on eject.
43: * Beware: doesn't run when a host device's physical media
44: * changes. Sure would be useful if it did.
45: * Device models with removable media must implement this callback.
46: */
47: void (*change_media_cb)(void *opaque, bool load);
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);
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);
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);
67: /*
68: * Runs when the size changed (e.g. monitor command block_resize)
69: */
70: void (*resize_cb)(void *opaque);
71: } BlockDevOps;
72:
1.1 root 73: #define BDRV_O_RDWR 0x0002
74: #define BDRV_O_SNAPSHOT 0x0008 /* open the file read only and save writes in a snapshot */
1.1.1.2 root 75: #define BDRV_O_NOCACHE 0x0020 /* do not use the host page cache */
76: #define BDRV_O_CACHE_WB 0x0040 /* use write-back caching */
1.1.1.6 root 77: #define BDRV_O_NATIVE_AIO 0x0080 /* use native AIO instead of the thread pool */
1.1.1.8 root 78: #define BDRV_O_NO_BACKING 0x0100 /* don't open the backing file */
79: #define BDRV_O_NO_FLUSH 0x0200 /* disable flushing on this disk */
1.1.1.13! root 80: #define BDRV_O_COPY_ON_READ 0x0400 /* copy read backing sectors into image */
! 81: #define BDRV_O_INCOMING 0x0800 /* consistency hint for incoming migration */
1.1.1.2 root 82:
1.1.1.8 root 83: #define BDRV_O_CACHE_MASK (BDRV_O_NOCACHE | BDRV_O_CACHE_WB | BDRV_O_NO_FLUSH)
1.1 root 84:
1.1.1.6 root 85: #define BDRV_SECTOR_BITS 9
1.1.1.8 root 86: #define BDRV_SECTOR_SIZE (1ULL << BDRV_SECTOR_BITS)
87: #define BDRV_SECTOR_MASK ~(BDRV_SECTOR_SIZE - 1)
1.1.1.6 root 88:
1.1.1.8 root 89: typedef enum {
90: BLOCK_ERR_REPORT, BLOCK_ERR_IGNORE, BLOCK_ERR_STOP_ENOSPC,
91: BLOCK_ERR_STOP_ANY
92: } BlockErrorAction;
93:
94: typedef enum {
95: BDRV_ACTION_REPORT, BDRV_ACTION_IGNORE, BDRV_ACTION_STOP
1.1.1.13! root 96: } BlockQMPEventAction;
1.1.1.8 root 97:
1.1.1.12 root 98: void bdrv_iostatus_enable(BlockDriverState *bs);
99: void bdrv_iostatus_reset(BlockDriverState *bs);
100: void bdrv_iostatus_disable(BlockDriverState *bs);
101: bool bdrv_iostatus_is_enabled(const BlockDriverState *bs);
102: void bdrv_iostatus_set_err(BlockDriverState *bs, int error);
1.1.1.13! root 103: void bdrv_emit_qmp_error_event(const BlockDriverState *bdrv,
! 104: BlockQMPEventAction action, int is_read);
1.1.1.6 root 105: void bdrv_info_print(Monitor *mon, const QObject *data);
106: void bdrv_info(Monitor *mon, QObject **ret_data);
107: void bdrv_stats_print(Monitor *mon, const QObject *data);
108: void bdrv_info_stats(Monitor *mon, QObject **ret_data);
1.1 root 109:
1.1.1.13! root 110: /* disk I/O throttling */
! 111: void bdrv_io_limits_enable(BlockDriverState *bs);
! 112: void bdrv_io_limits_disable(BlockDriverState *bs);
! 113: bool bdrv_io_limits_enabled(BlockDriverState *bs);
! 114:
1.1 root 115: void bdrv_init(void);
1.1.1.6 root 116: void bdrv_init_with_whitelist(void);
1.1.1.8 root 117: BlockDriver *bdrv_find_protocol(const char *filename);
1.1 root 118: BlockDriver *bdrv_find_format(const char *format_name);
1.1.1.6 root 119: BlockDriver *bdrv_find_whitelisted_format(const char *format_name);
1.1.1.5 root 120: int bdrv_create(BlockDriver *drv, const char* filename,
121: QEMUOptionParameter *options);
1.1.1.8 root 122: int bdrv_create_file(const char* filename, QEMUOptionParameter *options);
1.1 root 123: BlockDriverState *bdrv_new(const char *device_name);
1.1.1.10 root 124: void bdrv_make_anon(BlockDriverState *bs);
1.1.1.13! root 125: void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top);
1.1 root 126: void bdrv_delete(BlockDriverState *bs);
1.1.1.12 root 127: int bdrv_parse_cache_flags(const char *mode, int *flags);
1.1 root 128: int bdrv_file_open(BlockDriverState **pbs, const char *filename, int flags);
1.1.1.8 root 129: int bdrv_open(BlockDriverState *bs, const char *filename, int flags,
130: BlockDriver *drv);
1.1 root 131: void bdrv_close(BlockDriverState *bs);
1.1.1.12 root 132: int bdrv_attach_dev(BlockDriverState *bs, void *dev);
133: void bdrv_attach_dev_nofail(BlockDriverState *bs, void *dev);
134: void bdrv_detach_dev(BlockDriverState *bs, void *dev);
135: void *bdrv_get_attached_dev(BlockDriverState *bs);
136: void bdrv_set_dev_ops(BlockDriverState *bs, const BlockDevOps *ops,
137: void *opaque);
138: void bdrv_dev_eject_request(BlockDriverState *bs, bool force);
139: bool bdrv_dev_has_removable_media(BlockDriverState *bs);
140: bool bdrv_dev_is_tray_open(BlockDriverState *bs);
141: bool bdrv_dev_is_medium_locked(BlockDriverState *bs);
1.1 root 142: int bdrv_read(BlockDriverState *bs, int64_t sector_num,
143: uint8_t *buf, int nb_sectors);
144: int bdrv_write(BlockDriverState *bs, int64_t sector_num,
145: const uint8_t *buf, int nb_sectors);
146: int bdrv_pread(BlockDriverState *bs, int64_t offset,
147: void *buf, int count);
148: int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
149: const void *buf, int count);
1.1.1.7 root 150: int bdrv_pwrite_sync(BlockDriverState *bs, int64_t offset,
151: const void *buf, int count);
1.1.1.12 root 152: int coroutine_fn bdrv_co_readv(BlockDriverState *bs, int64_t sector_num,
153: int nb_sectors, QEMUIOVector *qiov);
1.1.1.13! root 154: int coroutine_fn bdrv_co_copy_on_readv(BlockDriverState *bs,
! 155: int64_t sector_num, int nb_sectors, QEMUIOVector *qiov);
1.1.1.12 root 156: int coroutine_fn bdrv_co_writev(BlockDriverState *bs, int64_t sector_num,
157: int nb_sectors, QEMUIOVector *qiov);
1.1.1.13! root 158: /*
! 159: * Efficiently zero a region of the disk image. Note that this is a regular
! 160: * I/O request like read or write and should have a reasonable size. This
! 161: * function is not suitable for zeroing the entire image in a single request
! 162: * because it may allocate memory for the entire region.
! 163: */
! 164: int coroutine_fn bdrv_co_write_zeroes(BlockDriverState *bs, int64_t sector_num,
! 165: int nb_sectors);
! 166: int coroutine_fn bdrv_co_is_allocated(BlockDriverState *bs, int64_t sector_num,
! 167: int nb_sectors, int *pnum);
! 168: BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
! 169: const char *backing_file);
1.1 root 170: int bdrv_truncate(BlockDriverState *bs, int64_t offset);
171: int64_t bdrv_getlength(BlockDriverState *bs);
1.1.1.11 root 172: int64_t bdrv_get_allocated_file_size(BlockDriverState *bs);
1.1 root 173: void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr);
1.1.1.2 root 174: void bdrv_guess_geometry(BlockDriverState *bs, int *pcyls, int *pheads, int *psecs);
1.1 root 175: int bdrv_commit(BlockDriverState *bs);
1.1.1.13! root 176: int bdrv_commit_all(void);
1.1.1.8 root 177: int bdrv_change_backing_file(BlockDriverState *bs,
178: const char *backing_file, const char *backing_fmt);
1.1.1.5 root 179: void bdrv_register(BlockDriver *bdrv);
180:
1.1.1.8 root 181:
182: typedef struct BdrvCheckResult {
183: int corruptions;
184: int leaks;
185: int check_errors;
1.1.1.13! root 186: BlockFragInfo bfi;
1.1.1.8 root 187: } BdrvCheckResult;
188:
189: int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res);
190:
1.1 root 191: /* async block I/O */
1.1.1.6 root 192: typedef void BlockDriverDirtyHandler(BlockDriverState *bs, int64_t sector,
1.1.1.11 root 193: int sector_num);
1.1.1.2 root 194: BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
195: QEMUIOVector *iov, int nb_sectors,
196: BlockDriverCompletionFunc *cb, void *opaque);
197: BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
198: QEMUIOVector *iov, int nb_sectors,
199: BlockDriverCompletionFunc *cb, void *opaque);
1.1.1.6 root 200: BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs,
1.1.1.11 root 201: BlockDriverCompletionFunc *cb, void *opaque);
1.1.1.12 root 202: BlockDriverAIOCB *bdrv_aio_discard(BlockDriverState *bs,
203: int64_t sector_num, int nb_sectors,
204: BlockDriverCompletionFunc *cb, void *opaque);
1.1 root 205: void bdrv_aio_cancel(BlockDriverAIOCB *acb);
206:
1.1.1.6 root 207: typedef struct BlockRequest {
208: /* Fields to be filled by multiwrite caller */
209: int64_t sector;
210: int nb_sectors;
211: QEMUIOVector *qiov;
212: BlockDriverCompletionFunc *cb;
213: void *opaque;
214:
215: /* Filled by multiwrite implementation */
216: int error;
217: } BlockRequest;
218:
219: int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs,
220: int num_reqs);
221:
1.1.1.5 root 222: /* sg packet commands */
223: int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf);
224: BlockDriverAIOCB *bdrv_aio_ioctl(BlockDriverState *bs,
225: unsigned long int req, void *buf,
226: BlockDriverCompletionFunc *cb, void *opaque);
227:
1.1.1.12 root 228: /* Invalidate any cached metadata used by image formats */
229: void bdrv_invalidate_cache(BlockDriverState *bs);
230: void bdrv_invalidate_cache_all(void);
231:
1.1.1.13! root 232: void bdrv_clear_incoming_migration_all(void);
! 233:
1.1 root 234: /* Ensure contents are flushed to disk. */
1.1.1.9 root 235: int bdrv_flush(BlockDriverState *bs);
1.1.1.12 root 236: int coroutine_fn bdrv_co_flush(BlockDriverState *bs);
1.1.1.2 root 237: void bdrv_flush_all(void);
1.1.1.8 root 238: void bdrv_close_all(void);
1.1.1.13! root 239: void bdrv_drain_all(void);
1.1.1.2 root 240:
1.1.1.9 root 241: int bdrv_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors);
1.1.1.12 root 242: int bdrv_co_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors);
1.1.1.8 root 243: int bdrv_has_zero_init(BlockDriverState *bs);
1.1.1.2 root 244: int bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
1.1.1.11 root 245: int *pnum);
1.1 root 246:
247: #define BIOS_ATA_TRANSLATION_AUTO 0
248: #define BIOS_ATA_TRANSLATION_NONE 1
249: #define BIOS_ATA_TRANSLATION_LBA 2
250: #define BIOS_ATA_TRANSLATION_LARGE 3
251: #define BIOS_ATA_TRANSLATION_RECHS 4
252:
253: void bdrv_set_geometry_hint(BlockDriverState *bs,
254: int cyls, int heads, int secs);
255: void bdrv_set_translation_hint(BlockDriverState *bs, int translation);
256: void bdrv_get_geometry_hint(BlockDriverState *bs,
257: int *pcyls, int *pheads, int *psecs);
1.1.1.11 root 258: typedef enum FDriveType {
259: FDRIVE_DRV_144 = 0x00, /* 1.44 MB 3"5 drive */
260: FDRIVE_DRV_288 = 0x01, /* 2.88 MB 3"5 drive */
261: FDRIVE_DRV_120 = 0x02, /* 1.2 MB 5"25 drive */
262: FDRIVE_DRV_NONE = 0x03, /* No drive connected */
263: } FDriveType;
264:
1.1.1.13! root 265: typedef enum FDriveRate {
! 266: FDRIVE_RATE_500K = 0x00, /* 500 Kbps */
! 267: FDRIVE_RATE_300K = 0x01, /* 300 Kbps */
! 268: FDRIVE_RATE_250K = 0x02, /* 250 Kbps */
! 269: FDRIVE_RATE_1M = 0x03, /* 1 Mbps */
! 270: } FDriveRate;
! 271:
1.1.1.11 root 272: void bdrv_get_floppy_geometry_hint(BlockDriverState *bs, int *nb_heads,
273: int *max_track, int *last_sect,
1.1.1.13! root 274: FDriveType drive_in, FDriveType *drive,
! 275: FDriveRate *rate);
1.1 root 276: int bdrv_get_translation_hint(BlockDriverState *bs);
1.1.1.8 root 277: void bdrv_set_on_error(BlockDriverState *bs, BlockErrorAction on_read_error,
278: BlockErrorAction on_write_error);
279: BlockErrorAction bdrv_get_on_error(BlockDriverState *bs, int is_read);
1.1 root 280: int bdrv_is_read_only(BlockDriverState *bs);
281: int bdrv_is_sg(BlockDriverState *bs);
1.1.1.6 root 282: int bdrv_enable_write_cache(BlockDriverState *bs);
1.1 root 283: int bdrv_is_inserted(BlockDriverState *bs);
284: int bdrv_media_changed(BlockDriverState *bs);
1.1.1.12 root 285: void bdrv_lock_medium(BlockDriverState *bs, bool locked);
1.1.1.13! root 286: void bdrv_eject(BlockDriverState *bs, bool eject_flag);
1.1 root 287: void bdrv_get_format(BlockDriverState *bs, char *buf, int buf_size);
288: BlockDriverState *bdrv_find(const char *name);
1.1.1.8 root 289: BlockDriverState *bdrv_next(BlockDriverState *bs);
1.1.1.3 root 290: void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs),
291: void *opaque);
1.1 root 292: int bdrv_is_encrypted(BlockDriverState *bs);
1.1.1.3 root 293: int bdrv_key_required(BlockDriverState *bs);
1.1 root 294: int bdrv_set_key(BlockDriverState *bs, const char *key);
1.1.1.3 root 295: int bdrv_query_missing_keys(void);
1.1 root 296: void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
297: void *opaque);
298: const char *bdrv_get_device_name(BlockDriverState *bs);
299: int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
300: const uint8_t *buf, int nb_sectors);
301: int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi);
302:
1.1.1.3 root 303: const char *bdrv_get_encrypted_filename(BlockDriverState *bs);
1.1 root 304: void bdrv_get_backing_filename(BlockDriverState *bs,
305: char *filename, int filename_size);
1.1.1.13! root 306: void bdrv_get_full_backing_filename(BlockDriverState *bs,
! 307: char *dest, size_t sz);
1.1.1.8 root 308: int bdrv_can_snapshot(BlockDriverState *bs);
309: int bdrv_is_snapshot(BlockDriverState *bs);
310: BlockDriverState *bdrv_snapshots(void);
1.1 root 311: int bdrv_snapshot_create(BlockDriverState *bs,
312: QEMUSnapshotInfo *sn_info);
313: int bdrv_snapshot_goto(BlockDriverState *bs,
314: const char *snapshot_id);
315: int bdrv_snapshot_delete(BlockDriverState *bs, const char *snapshot_id);
316: int bdrv_snapshot_list(BlockDriverState *bs,
317: QEMUSnapshotInfo **psn_info);
1.1.1.9 root 318: int bdrv_snapshot_load_tmp(BlockDriverState *bs,
319: const char *snapshot_name);
1.1 root 320: char *bdrv_snapshot_dump(char *buf, int buf_size, QEMUSnapshotInfo *sn);
321:
322: char *get_human_readable_size(char *buf, int buf_size, int64_t size);
323: int path_is_absolute(const char *path);
324: void path_combine(char *dest, int dest_size,
325: const char *base_path,
326: const char *filename);
327:
1.1.1.5 root 328: int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
329: int64_t pos, int size);
1.1.1.4 root 330:
1.1.1.5 root 331: int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,
332: int64_t pos, int size);
1.1.1.4 root 333:
1.1.1.9 root 334: int bdrv_img_create(const char *filename, const char *fmt,
335: const char *base_filename, const char *base_fmt,
336: char *options, uint64_t img_size, int flags);
337:
1.1.1.12 root 338: void bdrv_set_buffer_alignment(BlockDriverState *bs, int align);
339: void *qemu_blockalign(BlockDriverState *bs, size_t size);
340:
1.1.1.6 root 341: #define BDRV_SECTORS_PER_DIRTY_CHUNK 2048
342:
343: void bdrv_set_dirty_tracking(BlockDriverState *bs, int enable);
344: int bdrv_get_dirty(BlockDriverState *bs, int64_t sector);
345: void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector,
346: int nr_sectors);
1.1.1.8 root 347: int64_t bdrv_get_dirty_count(BlockDriverState *bs);
348:
1.1.1.13! root 349: void bdrv_enable_copy_on_read(BlockDriverState *bs);
! 350: void bdrv_disable_copy_on_read(BlockDriverState *bs);
! 351:
1.1.1.9 root 352: void bdrv_set_in_use(BlockDriverState *bs, int in_use);
353: int bdrv_in_use(BlockDriverState *bs);
1.1.1.8 root 354:
1.1.1.12 root 355: enum BlockAcctType {
356: BDRV_ACCT_READ,
357: BDRV_ACCT_WRITE,
358: BDRV_ACCT_FLUSH,
359: BDRV_MAX_IOTYPE,
360: };
361:
362: typedef struct BlockAcctCookie {
363: int64_t bytes;
364: int64_t start_time_ns;
365: enum BlockAcctType type;
366: } BlockAcctCookie;
367:
368: void bdrv_acct_start(BlockDriverState *bs, BlockAcctCookie *cookie,
369: int64_t bytes, enum BlockAcctType type);
370: void bdrv_acct_done(BlockDriverState *bs, BlockAcctCookie *cookie);
371:
1.1.1.8 root 372: typedef enum {
373: BLKDBG_L1_UPDATE,
374:
375: BLKDBG_L1_GROW_ALLOC_TABLE,
376: BLKDBG_L1_GROW_WRITE_TABLE,
377: BLKDBG_L1_GROW_ACTIVATE_TABLE,
378:
379: BLKDBG_L2_LOAD,
380: BLKDBG_L2_UPDATE,
381: BLKDBG_L2_UPDATE_COMPRESSED,
382: BLKDBG_L2_ALLOC_COW_READ,
383: BLKDBG_L2_ALLOC_WRITE,
384:
385: BLKDBG_READ,
386: BLKDBG_READ_AIO,
387: BLKDBG_READ_BACKING,
388: BLKDBG_READ_BACKING_AIO,
389: BLKDBG_READ_COMPRESSED,
390:
391: BLKDBG_WRITE_AIO,
392: BLKDBG_WRITE_COMPRESSED,
393:
394: BLKDBG_VMSTATE_LOAD,
395: BLKDBG_VMSTATE_SAVE,
396:
397: BLKDBG_COW_READ,
398: BLKDBG_COW_WRITE,
399:
400: BLKDBG_REFTABLE_LOAD,
401: BLKDBG_REFTABLE_GROW,
402:
403: BLKDBG_REFBLOCK_LOAD,
404: BLKDBG_REFBLOCK_UPDATE,
405: BLKDBG_REFBLOCK_UPDATE_PART,
406: BLKDBG_REFBLOCK_ALLOC,
407: BLKDBG_REFBLOCK_ALLOC_HOOKUP,
408: BLKDBG_REFBLOCK_ALLOC_WRITE,
409: BLKDBG_REFBLOCK_ALLOC_WRITE_BLOCKS,
410: BLKDBG_REFBLOCK_ALLOC_WRITE_TABLE,
411: BLKDBG_REFBLOCK_ALLOC_SWITCH_TABLE,
412:
413: BLKDBG_CLUSTER_ALLOC,
414: BLKDBG_CLUSTER_ALLOC_BYTES,
415: BLKDBG_CLUSTER_FREE,
416:
417: BLKDBG_EVENT_MAX,
418: } BlkDebugEvent;
419:
420: #define BLKDBG_EVENT(bs, evt) bdrv_debug_event(bs, evt)
421: void bdrv_debug_event(BlockDriverState *bs, BlkDebugEvent event);
422:
1.1.1.12 root 423:
424: /* Convenience for block device models */
425:
426: typedef struct BlockConf {
427: BlockDriverState *bs;
428: uint16_t physical_block_size;
429: uint16_t logical_block_size;
430: uint16_t min_io_size;
431: uint32_t opt_io_size;
432: int32_t bootindex;
433: uint32_t discard_granularity;
434: } BlockConf;
435:
436: static inline unsigned int get_physical_block_exp(BlockConf *conf)
437: {
438: unsigned int exp = 0, size;
439:
440: for (size = conf->physical_block_size;
441: size > conf->logical_block_size;
442: size >>= 1) {
443: exp++;
444: }
445:
446: return exp;
447: }
448:
449: #define DEFINE_BLOCK_PROPERTIES(_state, _conf) \
450: DEFINE_PROP_DRIVE("drive", _state, _conf.bs), \
1.1.1.13! root 451: DEFINE_PROP_BLOCKSIZE("logical_block_size", _state, \
! 452: _conf.logical_block_size, 512), \
! 453: DEFINE_PROP_BLOCKSIZE("physical_block_size", _state, \
! 454: _conf.physical_block_size, 512), \
1.1.1.12 root 455: DEFINE_PROP_UINT16("min_io_size", _state, _conf.min_io_size, 0), \
456: DEFINE_PROP_UINT32("opt_io_size", _state, _conf.opt_io_size, 0), \
457: DEFINE_PROP_INT32("bootindex", _state, _conf.bootindex, -1), \
458: DEFINE_PROP_UINT32("discard_granularity", _state, \
459: _conf.discard_granularity, 0)
460:
1.1 root 461: #endif
1.1.1.12 root 462:
unix.superglobalmegacorp.com
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to block.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu