block.h 17.5 KB
Newer Older
P
pbrook 已提交
1 2 3
#ifndef BLOCK_H
#define BLOCK_H

4
#include "qemu-aio.h"
5
#include "qemu-common.h"
6
#include "qemu-option.h"
K
Kevin Wolf 已提交
7
#include "qemu-coroutine.h"
8
#include "qobject.h"
9

P
pbrook 已提交
10 11 12 13 14 15 16 17
/* block.c */
typedef struct BlockDriver BlockDriver;

typedef struct BlockDriverInfo {
    /* in bytes, 0 if irrelevant */
    int cluster_size;
    /* offset at which the VM state can be saved (0 if not possible) */
    int64_t vm_state_offset;
D
Dong Xu Wang 已提交
18
    bool is_dirty;
P
pbrook 已提交
19 20
} BlockDriverInfo;

21 22 23 24 25 26
typedef struct BlockFragInfo {
    uint64_t allocated_clusters;
    uint64_t total_clusters;
    uint64_t fragmented_clusters;
} BlockFragInfo;

P
pbrook 已提交
27 28 29 30
typedef struct QEMUSnapshotInfo {
    char id_str[128]; /* unique snapshot id */
    /* the following fields are informative. They are not needed for
       the consistency of the snapshot */
31
    char name[256]; /* user chosen name */
K
Kevin Wolf 已提交
32
    uint64_t vm_state_size; /* VM state info size */
P
pbrook 已提交
33 34 35 36 37
    uint32_t date_sec; /* UTC date of the snapshot */
    uint32_t date_nsec;
    uint64_t vm_clock_nsec; /* VM clock relative to boot */
} QEMUSnapshotInfo;

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 44
     * Beware: doesn't run when a host device's physical media
     * 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);
P
Paolo Bonzini 已提交
48 49 50 51 52 53 54 55 56
    /*
     * Runs when an eject request is issued from the monitor, the tray
     * is closed, and the medium is locked.
     * Device models that do not implement is_medium_locked will not need
     * this callback.  Device models that can lock the medium or tray might
     * want to implement the callback and unlock the tray when "force" is
     * true, even if they do not support eject requests.
     */
    void (*eject_request_cb)(void *opaque, bool force);
57 58 59 60 61
    /*
     * Is the virtual tray open?
     * Device models implement this only when the device has a tray.
     */
    bool (*is_tray_open)(void *opaque);
62 63 64 65 66
    /*
     * Is the virtual medium locked into the device?
     * Device models implement this only when device has such a lock.
     */
    bool (*is_medium_locked)(void *opaque);
67 68 69 70
    /*
     * Runs when the size changed (e.g. monitor command block_resize)
     */
    void (*resize_cb)(void *opaque);
71 72
} BlockDevOps;

P
pbrook 已提交
73 74
#define BDRV_O_RDWR        0x0002
#define BDRV_O_SNAPSHOT    0x0008 /* open the file read only and save writes in a snapshot */
75 76
#define BDRV_O_NOCACHE     0x0020 /* do not use the host page cache */
#define BDRV_O_CACHE_WB    0x0040 /* use write-back caching */
77
#define BDRV_O_NATIVE_AIO  0x0080 /* use native AIO instead of the thread pool */
K
Kevin Wolf 已提交
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 */
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 */
82

K
Kevin Wolf 已提交
83
#define BDRV_O_CACHE_MASK  (BDRV_O_NOCACHE | BDRV_O_CACHE_WB | BDRV_O_NO_FLUSH)
P
pbrook 已提交
84

J
Jan Kiszka 已提交
85
#define BDRV_SECTOR_BITS   9
86
#define BDRV_SECTOR_SIZE   (1ULL << BDRV_SECTOR_BITS)
87
#define BDRV_SECTOR_MASK   ~(BDRV_SECTOR_SIZE - 1)
J
Jan Kiszka 已提交
88

89 90 91 92 93
typedef enum {
    BLOCK_ERR_REPORT, BLOCK_ERR_IGNORE, BLOCK_ERR_STOP_ENOSPC,
    BLOCK_ERR_STOP_ANY
} BlockErrorAction;

94 95
typedef enum {
    BDRV_ACTION_REPORT, BDRV_ACTION_IGNORE, BDRV_ACTION_STOP
96
} BlockQMPEventAction;
97

98 99 100 101 102
void bdrv_iostatus_enable(BlockDriverState *bs);
void bdrv_iostatus_reset(BlockDriverState *bs);
void bdrv_iostatus_disable(BlockDriverState *bs);
bool bdrv_iostatus_is_enabled(const BlockDriverState *bs);
void bdrv_iostatus_set_err(BlockDriverState *bs, int error);
103 104
void bdrv_emit_qmp_error_event(const BlockDriverState *bdrv,
                               BlockQMPEventAction action, int is_read);
105 106
void bdrv_info_print(Monitor *mon, const QObject *data);
void bdrv_info(Monitor *mon, QObject **ret_data);
107 108
void bdrv_stats_print(Monitor *mon, const QObject *data);
void bdrv_info_stats(Monitor *mon, QObject **ret_data);
P
pbrook 已提交
109

110 111
/* disk I/O throttling */
void bdrv_io_limits_enable(BlockDriverState *bs);
Z
Zhi Yong Wu 已提交
112
void bdrv_io_limits_disable(BlockDriverState *bs);
113 114
bool bdrv_io_limits_enabled(BlockDriverState *bs);

P
pbrook 已提交
115
void bdrv_init(void);
116
void bdrv_init_with_whitelist(void);
117
BlockDriver *bdrv_find_protocol(const char *filename);
P
pbrook 已提交
118
BlockDriver *bdrv_find_format(const char *format_name);
119
BlockDriver *bdrv_find_whitelisted_format(const char *format_name);
120 121
int bdrv_create(BlockDriver *drv, const char* filename,
    QEMUOptionParameter *options);
122
int bdrv_create_file(const char* filename, QEMUOptionParameter *options);
P
pbrook 已提交
123
BlockDriverState *bdrv_new(const char *device_name);
124
void bdrv_make_anon(BlockDriverState *bs);
125
void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top);
P
pbrook 已提交
126
void bdrv_delete(BlockDriverState *bs);
127
int bdrv_parse_cache_flags(const char *mode, int *flags);
P
pbrook 已提交
128
int bdrv_file_open(BlockDriverState **pbs, const char *filename, int flags);
K
Kevin Wolf 已提交
129 130
int bdrv_open(BlockDriverState *bs, const char *filename, int flags,
              BlockDriver *drv);
P
pbrook 已提交
131
void bdrv_close(BlockDriverState *bs);
132 133 134 135
int bdrv_attach_dev(BlockDriverState *bs, void *dev);
void bdrv_attach_dev_nofail(BlockDriverState *bs, void *dev);
void bdrv_detach_dev(BlockDriverState *bs, void *dev);
void *bdrv_get_attached_dev(BlockDriverState *bs);
136 137
void bdrv_set_dev_ops(BlockDriverState *bs, const BlockDevOps *ops,
                      void *opaque);
P
Paolo Bonzini 已提交
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);
P
pbrook 已提交
142 143 144 145 146 147 148 149
int bdrv_read(BlockDriverState *bs, int64_t sector_num,
              uint8_t *buf, int nb_sectors);
int bdrv_write(BlockDriverState *bs, int64_t sector_num,
               const uint8_t *buf, int nb_sectors);
int bdrv_pread(BlockDriverState *bs, int64_t offset,
               void *buf, int count);
int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
                const void *buf, int count);
K
Kevin Wolf 已提交
150 151
int bdrv_pwrite_sync(BlockDriverState *bs, int64_t offset,
    const void *buf, int count);
K
Kevin Wolf 已提交
152 153
int coroutine_fn bdrv_co_readv(BlockDriverState *bs, int64_t sector_num,
    int nb_sectors, QEMUIOVector *qiov);
154 155
int coroutine_fn bdrv_co_copy_on_readv(BlockDriverState *bs,
    int64_t sector_num, int nb_sectors, QEMUIOVector *qiov);
K
Kevin Wolf 已提交
156 157
int coroutine_fn bdrv_co_writev(BlockDriverState *bs, int64_t sector_num,
    int nb_sectors, QEMUIOVector *qiov);
158 159 160 161 162 163 164 165
/*
 * Efficiently zero a region of the disk image.  Note that this is a regular
 * I/O request like read or write and should have a reasonable size.  This
 * function is not suitable for zeroing the entire image in a single request
 * because it may allocate memory for the entire region.
 */
int coroutine_fn bdrv_co_write_zeroes(BlockDriverState *bs, int64_t sector_num,
    int nb_sectors);
166 167
int coroutine_fn bdrv_co_is_allocated(BlockDriverState *bs, int64_t sector_num,
    int nb_sectors, int *pnum);
168 169
BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
    const char *backing_file);
P
pbrook 已提交
170 171
int bdrv_truncate(BlockDriverState *bs, int64_t offset);
int64_t bdrv_getlength(BlockDriverState *bs);
172
int64_t bdrv_get_allocated_file_size(BlockDriverState *bs);
173
void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr);
174
void bdrv_guess_geometry(BlockDriverState *bs, int *pcyls, int *pheads, int *psecs);
P
pbrook 已提交
175
int bdrv_commit(BlockDriverState *bs);
176
int bdrv_commit_all(void);
K
Kevin Wolf 已提交
177 178
int bdrv_change_backing_file(BlockDriverState *bs,
    const char *backing_file, const char *backing_fmt);
179 180
void bdrv_register(BlockDriver *bdrv);

181 182 183 184 185

typedef struct BdrvCheckResult {
    int corruptions;
    int leaks;
    int check_errors;
186
    BlockFragInfo bfi;
187 188 189 190
} BdrvCheckResult;

int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res);

P
pbrook 已提交
191
/* async block I/O */
192
typedef void BlockDriverDirtyHandler(BlockDriverState *bs, int64_t sector,
193
                                     int sector_num);
194 195 196 197 198 199
BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
                                 QEMUIOVector *iov, int nb_sectors,
                                 BlockDriverCompletionFunc *cb, void *opaque);
BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
                                  QEMUIOVector *iov, int nb_sectors,
                                  BlockDriverCompletionFunc *cb, void *opaque);
200
BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs,
201
                                 BlockDriverCompletionFunc *cb, void *opaque);
202 203 204
BlockDriverAIOCB *bdrv_aio_discard(BlockDriverState *bs,
                                   int64_t sector_num, int nb_sectors,
                                   BlockDriverCompletionFunc *cb, void *opaque);
P
pbrook 已提交
205 206
void bdrv_aio_cancel(BlockDriverAIOCB *acb);

K
Kevin Wolf 已提交
207 208 209 210 211 212 213 214 215 216 217 218 219 220 221
typedef struct BlockRequest {
    /* Fields to be filled by multiwrite caller */
    int64_t sector;
    int nb_sectors;
    QEMUIOVector *qiov;
    BlockDriverCompletionFunc *cb;
    void *opaque;

    /* Filled by multiwrite implementation */
    int error;
} BlockRequest;

int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs,
    int num_reqs);

222
/* sg packet commands */
223 224 225 226
int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf);
BlockDriverAIOCB *bdrv_aio_ioctl(BlockDriverState *bs,
        unsigned long int req, void *buf,
        BlockDriverCompletionFunc *cb, void *opaque);
227

228 229 230 231
/* Invalidate any cached metadata used by image formats */
void bdrv_invalidate_cache(BlockDriverState *bs);
void bdrv_invalidate_cache_all(void);

232 233
void bdrv_clear_incoming_migration_all(void);

P
pbrook 已提交
234
/* Ensure contents are flushed to disk.  */
235
int bdrv_flush(BlockDriverState *bs);
P
Paolo Bonzini 已提交
236
int coroutine_fn bdrv_co_flush(BlockDriverState *bs);
A
aliguori 已提交
237
void bdrv_flush_all(void);
238
void bdrv_close_all(void);
239
void bdrv_drain_all(void);
A
aliguori 已提交
240

C
Christoph Hellwig 已提交
241
int bdrv_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors);
242
int bdrv_co_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors);
K
Kevin Wolf 已提交
243
int bdrv_has_zero_init(BlockDriverState *bs);
244
int bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
245
                      int *pnum);
P
pbrook 已提交
246 247 248 249 250 251 252 253 254 255 256 257

#define BIOS_ATA_TRANSLATION_AUTO   0
#define BIOS_ATA_TRANSLATION_NONE   1
#define BIOS_ATA_TRANSLATION_LBA    2
#define BIOS_ATA_TRANSLATION_LARGE  3
#define BIOS_ATA_TRANSLATION_RECHS  4

void bdrv_set_geometry_hint(BlockDriverState *bs,
                            int cyls, int heads, int secs);
void bdrv_set_translation_hint(BlockDriverState *bs, int translation);
void bdrv_get_geometry_hint(BlockDriverState *bs,
                            int *pcyls, int *pheads, int *psecs);
258 259 260 261 262 263 264
typedef enum FDriveType {
    FDRIVE_DRV_144  = 0x00,   /* 1.44 MB 3"5 drive      */
    FDRIVE_DRV_288  = 0x01,   /* 2.88 MB 3"5 drive      */
    FDRIVE_DRV_120  = 0x02,   /* 1.2  MB 5"25 drive     */
    FDRIVE_DRV_NONE = 0x03,   /* No drive connected     */
} FDriveType;

265 266 267 268 269 270 271
typedef enum FDriveRate {
    FDRIVE_RATE_500K = 0x00,  /* 500 Kbps */
    FDRIVE_RATE_300K = 0x01,  /* 300 Kbps */
    FDRIVE_RATE_250K = 0x02,  /* 250 Kbps */
    FDRIVE_RATE_1M   = 0x03,  /*   1 Mbps */
} FDriveRate;

272 273
void bdrv_get_floppy_geometry_hint(BlockDriverState *bs, int *nb_heads,
                                   int *max_track, int *last_sect,
274 275
                                   FDriveType drive_in, FDriveType *drive,
                                   FDriveRate *rate);
P
pbrook 已提交
276
int bdrv_get_translation_hint(BlockDriverState *bs);
277 278 279
void bdrv_set_on_error(BlockDriverState *bs, BlockErrorAction on_read_error,
                       BlockErrorAction on_write_error);
BlockErrorAction bdrv_get_on_error(BlockDriverState *bs, int is_read);
P
pbrook 已提交
280
int bdrv_is_read_only(BlockDriverState *bs);
281
int bdrv_is_sg(BlockDriverState *bs);
282
int bdrv_enable_write_cache(BlockDriverState *bs);
P
pbrook 已提交
283 284
int bdrv_is_inserted(BlockDriverState *bs);
int bdrv_media_changed(BlockDriverState *bs);
285
void bdrv_lock_medium(BlockDriverState *bs, bool locked);
286
void bdrv_eject(BlockDriverState *bs, bool eject_flag);
P
pbrook 已提交
287 288
void bdrv_get_format(BlockDriverState *bs, char *buf, int buf_size);
BlockDriverState *bdrv_find(const char *name);
M
Markus Armbruster 已提交
289
BlockDriverState *bdrv_next(BlockDriverState *bs);
290 291
void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs),
                  void *opaque);
P
pbrook 已提交
292
int bdrv_is_encrypted(BlockDriverState *bs);
293
int bdrv_key_required(BlockDriverState *bs);
P
pbrook 已提交
294
int bdrv_set_key(BlockDriverState *bs, const char *key);
295
int bdrv_query_missing_keys(void);
P
pbrook 已提交
296 297 298 299 300 301 302
void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
                         void *opaque);
const char *bdrv_get_device_name(BlockDriverState *bs);
int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
                          const uint8_t *buf, int nb_sectors);
int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi);

303
const char *bdrv_get_encrypted_filename(BlockDriverState *bs);
P
pbrook 已提交
304 305
void bdrv_get_backing_filename(BlockDriverState *bs,
                               char *filename, int filename_size);
306
int bdrv_can_snapshot(BlockDriverState *bs);
307
int bdrv_is_snapshot(BlockDriverState *bs);
308
BlockDriverState *bdrv_snapshots(void);
P
pbrook 已提交
309 310 311 312 313 314 315
int bdrv_snapshot_create(BlockDriverState *bs,
                         QEMUSnapshotInfo *sn_info);
int bdrv_snapshot_goto(BlockDriverState *bs,
                       const char *snapshot_id);
int bdrv_snapshot_delete(BlockDriverState *bs, const char *snapshot_id);
int bdrv_snapshot_list(BlockDriverState *bs,
                       QEMUSnapshotInfo **psn_info);
E
edison 已提交
316 317
int bdrv_snapshot_load_tmp(BlockDriverState *bs,
                           const char *snapshot_name);
P
pbrook 已提交
318 319 320 321 322 323 324 325
char *bdrv_snapshot_dump(char *buf, int buf_size, QEMUSnapshotInfo *sn);

char *get_human_readable_size(char *buf, int buf_size, int64_t size);
int path_is_absolute(const char *path);
void path_combine(char *dest, int dest_size,
                  const char *base_path,
                  const char *filename);

326 327
int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
                      int64_t pos, int size);
328

329 330
int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,
                      int64_t pos, int size);
331

J
Jes Sorensen 已提交
332 333 334 335
int bdrv_img_create(const char *filename, const char *fmt,
                    const char *base_filename, const char *base_fmt,
                    char *options, uint64_t img_size, int flags);

336
void bdrv_set_buffer_alignment(BlockDriverState *bs, int align);
337 338
void *qemu_blockalign(BlockDriverState *bs, size_t size);

339
#define BDRV_SECTORS_PER_DIRTY_CHUNK 2048
J
Jan Kiszka 已提交
340

341 342
void bdrv_set_dirty_tracking(BlockDriverState *bs, int enable);
int bdrv_get_dirty(BlockDriverState *bs, int64_t sector);
343 344
void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector,
                      int nr_sectors);
345
int64_t bdrv_get_dirty_count(BlockDriverState *bs);
K
Kevin Wolf 已提交
346

347 348 349
void bdrv_enable_copy_on_read(BlockDriverState *bs);
void bdrv_disable_copy_on_read(BlockDriverState *bs);

350 351
void bdrv_set_in_use(BlockDriverState *bs, int in_use);
int bdrv_in_use(BlockDriverState *bs);
K
Kevin Wolf 已提交
352

353 354 355 356 357 358 359 360 361
enum BlockAcctType {
    BDRV_ACCT_READ,
    BDRV_ACCT_WRITE,
    BDRV_ACCT_FLUSH,
    BDRV_MAX_IOTYPE,
};

typedef struct BlockAcctCookie {
    int64_t bytes;
C
Christoph Hellwig 已提交
362
    int64_t start_time_ns;
363 364 365 366 367 368 369
    enum BlockAcctType type;
} BlockAcctCookie;

void bdrv_acct_start(BlockDriverState *bs, BlockAcctCookie *cookie,
        int64_t bytes, enum BlockAcctType type);
void bdrv_acct_done(BlockDriverState *bs, BlockAcctCookie *cookie);

K
Kevin Wolf 已提交
370
typedef enum {
K
Kevin Wolf 已提交
371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414
    BLKDBG_L1_UPDATE,

    BLKDBG_L1_GROW_ALLOC_TABLE,
    BLKDBG_L1_GROW_WRITE_TABLE,
    BLKDBG_L1_GROW_ACTIVATE_TABLE,

    BLKDBG_L2_LOAD,
    BLKDBG_L2_UPDATE,
    BLKDBG_L2_UPDATE_COMPRESSED,
    BLKDBG_L2_ALLOC_COW_READ,
    BLKDBG_L2_ALLOC_WRITE,

    BLKDBG_READ,
    BLKDBG_READ_AIO,
    BLKDBG_READ_BACKING,
    BLKDBG_READ_BACKING_AIO,
    BLKDBG_READ_COMPRESSED,

    BLKDBG_WRITE_AIO,
    BLKDBG_WRITE_COMPRESSED,

    BLKDBG_VMSTATE_LOAD,
    BLKDBG_VMSTATE_SAVE,

    BLKDBG_COW_READ,
    BLKDBG_COW_WRITE,

    BLKDBG_REFTABLE_LOAD,
    BLKDBG_REFTABLE_GROW,

    BLKDBG_REFBLOCK_LOAD,
    BLKDBG_REFBLOCK_UPDATE,
    BLKDBG_REFBLOCK_UPDATE_PART,
    BLKDBG_REFBLOCK_ALLOC,
    BLKDBG_REFBLOCK_ALLOC_HOOKUP,
    BLKDBG_REFBLOCK_ALLOC_WRITE,
    BLKDBG_REFBLOCK_ALLOC_WRITE_BLOCKS,
    BLKDBG_REFBLOCK_ALLOC_WRITE_TABLE,
    BLKDBG_REFBLOCK_ALLOC_SWITCH_TABLE,

    BLKDBG_CLUSTER_ALLOC,
    BLKDBG_CLUSTER_ALLOC_BYTES,
    BLKDBG_CLUSTER_FREE,

K
Kevin Wolf 已提交
415 416 417 418 419 420
    BLKDBG_EVENT_MAX,
} BlkDebugEvent;

#define BLKDBG_EVENT(bs, evt) bdrv_debug_event(bs, evt)
void bdrv_debug_event(BlockDriverState *bs, BlkDebugEvent event);

421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448

/* Convenience for block device models */

typedef struct BlockConf {
    BlockDriverState *bs;
    uint16_t physical_block_size;
    uint16_t logical_block_size;
    uint16_t min_io_size;
    uint32_t opt_io_size;
    int32_t bootindex;
    uint32_t discard_granularity;
} BlockConf;

static inline unsigned int get_physical_block_exp(BlockConf *conf)
{
    unsigned int exp = 0, size;

    for (size = conf->physical_block_size;
        size > conf->logical_block_size;
        size >>= 1) {
        exp++;
    }

    return exp;
}

#define DEFINE_BLOCK_PROPERTIES(_state, _conf)                          \
    DEFINE_PROP_DRIVE("drive", _state, _conf.bs),                       \
449 450 451 452
    DEFINE_PROP_BLOCKSIZE("logical_block_size", _state,                 \
                          _conf.logical_block_size, 512),               \
    DEFINE_PROP_BLOCKSIZE("physical_block_size", _state,                \
                          _conf.physical_block_size, 512),              \
453 454 455 456 457 458
    DEFINE_PROP_UINT16("min_io_size", _state, _conf.min_io_size, 0),  \
    DEFINE_PROP_UINT32("opt_io_size", _state, _conf.opt_io_size, 0),    \
    DEFINE_PROP_INT32("bootindex", _state, _conf.bootindex, -1),        \
    DEFINE_PROP_UINT32("discard_granularity", _state, \
                       _conf.discard_granularity, 0)

P
pbrook 已提交
459
#endif
460