File:  [Qemu by Fabrice Bellard] / qemu / block.h
Revision 1.1.1.6 (vendor branch): download - view: text, annotated - select for diffs
Tue Apr 24 17:34:49 2018 UTC (2 years, 1 month ago) by root
Branches: qemu, MAIN
CVS tags: qemu0124, qemu0123, qemu0122, qemu0121, qemu0120, HEAD
qemu 0.12.0

    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_RDONLY      0x0000
   31: #define BDRV_O_RDWR        0x0002
   32: #define BDRV_O_ACCESS      0x0003
   33: #define BDRV_O_CREAT       0x0004 /* create an empty file */
   34: #define BDRV_O_SNAPSHOT    0x0008 /* open the file read only and save writes in a snapshot */
   35: #define BDRV_O_FILE        0x0010 /* open as a raw file (do not try to
   36:                                      use a disk image format on top of
   37:                                      it (default for
   38:                                      bdrv_file_open()) */
   39: #define BDRV_O_NOCACHE     0x0020 /* do not use the host page cache */
   40: #define BDRV_O_CACHE_WB    0x0040 /* use write-back caching */
   41: #define BDRV_O_NATIVE_AIO  0x0080 /* use native AIO instead of the thread pool */
   42: 
   43: #define BDRV_O_CACHE_MASK  (BDRV_O_NOCACHE | BDRV_O_CACHE_WB)
   44: 
   45: #define BDRV_SECTOR_BITS   9
   46: #define BDRV_SECTOR_SIZE   (1 << BDRV_SECTOR_BITS)
   47: #define BDRV_SECTOR_MASK   ~(BDRV_SECTOR_SIZE - 1);
   48: 
   49: void bdrv_info_print(Monitor *mon, const QObject *data);
   50: void bdrv_info(Monitor *mon, QObject **ret_data);
   51: void bdrv_stats_print(Monitor *mon, const QObject *data);
   52: void bdrv_info_stats(Monitor *mon, QObject **ret_data);
   53: 
   54: void bdrv_init(void);
   55: void bdrv_init_with_whitelist(void);
   56: BlockDriver *bdrv_find_format(const char *format_name);
   57: BlockDriver *bdrv_find_whitelisted_format(const char *format_name);
   58: int bdrv_create(BlockDriver *drv, const char* filename,
   59:     QEMUOptionParameter *options);
   60: int bdrv_create2(BlockDriver *drv,
   61:                  const char *filename, int64_t size_in_sectors,
   62:                  const char *backing_file, const char *backing_format,
   63:                  int flags);
   64: BlockDriverState *bdrv_new(const char *device_name);
   65: void bdrv_delete(BlockDriverState *bs);
   66: int bdrv_file_open(BlockDriverState **pbs, const char *filename, int flags);
   67: int bdrv_open(BlockDriverState *bs, const char *filename, int flags);
   68: int bdrv_open2(BlockDriverState *bs, const char *filename, int flags,
   69:                BlockDriver *drv);
   70: void bdrv_close(BlockDriverState *bs);
   71: int bdrv_check(BlockDriverState *bs);
   72: int bdrv_read(BlockDriverState *bs, int64_t sector_num,
   73:               uint8_t *buf, int nb_sectors);
   74: int bdrv_write(BlockDriverState *bs, int64_t sector_num,
   75:                const uint8_t *buf, int nb_sectors);
   76: int bdrv_pread(BlockDriverState *bs, int64_t offset,
   77:                void *buf, int count);
   78: int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
   79:                 const void *buf, int count);
   80: int bdrv_truncate(BlockDriverState *bs, int64_t offset);
   81: int64_t bdrv_getlength(BlockDriverState *bs);
   82: void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr);
   83: void bdrv_guess_geometry(BlockDriverState *bs, int *pcyls, int *pheads, int *psecs);
   84: int bdrv_commit(BlockDriverState *bs);
   85: void bdrv_register(BlockDriver *bdrv);
   86: 
   87: /* async block I/O */
   88: typedef struct BlockDriverAIOCB BlockDriverAIOCB;
   89: typedef void BlockDriverCompletionFunc(void *opaque, int ret);
   90: typedef void BlockDriverDirtyHandler(BlockDriverState *bs, int64_t sector,
   91: 				     int sector_num);
   92: BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
   93:                                  QEMUIOVector *iov, int nb_sectors,
   94:                                  BlockDriverCompletionFunc *cb, void *opaque);
   95: BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
   96:                                   QEMUIOVector *iov, int nb_sectors,
   97:                                   BlockDriverCompletionFunc *cb, void *opaque);
   98: BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs,
   99: 				 BlockDriverCompletionFunc *cb, void *opaque);
  100: void bdrv_aio_cancel(BlockDriverAIOCB *acb);
  101: 
  102: typedef struct BlockRequest {
  103:     /* Fields to be filled by multiwrite caller */
  104:     int64_t sector;
  105:     int nb_sectors;
  106:     QEMUIOVector *qiov;
  107:     BlockDriverCompletionFunc *cb;
  108:     void *opaque;
  109: 
  110:     /* Filled by multiwrite implementation */
  111:     int error;
  112: } BlockRequest;
  113: 
  114: int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs,
  115:     int num_reqs);
  116: 
  117: /* sg packet commands */
  118: int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf);
  119: BlockDriverAIOCB *bdrv_aio_ioctl(BlockDriverState *bs,
  120:         unsigned long int req, void *buf,
  121:         BlockDriverCompletionFunc *cb, void *opaque);
  122: 
  123: /* Ensure contents are flushed to disk.  */
  124: void bdrv_flush(BlockDriverState *bs);
  125: void bdrv_flush_all(void);
  126: 
  127: int bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
  128: 	int *pnum);
  129: 
  130: #define BDRV_TYPE_HD     0
  131: #define BDRV_TYPE_CDROM  1
  132: #define BDRV_TYPE_FLOPPY 2
  133: #define BIOS_ATA_TRANSLATION_AUTO   0
  134: #define BIOS_ATA_TRANSLATION_NONE   1
  135: #define BIOS_ATA_TRANSLATION_LBA    2
  136: #define BIOS_ATA_TRANSLATION_LARGE  3
  137: #define BIOS_ATA_TRANSLATION_RECHS  4
  138: 
  139: void bdrv_set_geometry_hint(BlockDriverState *bs,
  140:                             int cyls, int heads, int secs);
  141: void bdrv_set_type_hint(BlockDriverState *bs, int type);
  142: void bdrv_set_translation_hint(BlockDriverState *bs, int translation);
  143: void bdrv_get_geometry_hint(BlockDriverState *bs,
  144:                             int *pcyls, int *pheads, int *psecs);
  145: int bdrv_get_type_hint(BlockDriverState *bs);
  146: int bdrv_get_translation_hint(BlockDriverState *bs);
  147: int bdrv_is_removable(BlockDriverState *bs);
  148: int bdrv_is_read_only(BlockDriverState *bs);
  149: int bdrv_set_read_only(BlockDriverState *bs, int read_only);
  150: int bdrv_is_sg(BlockDriverState *bs);
  151: int bdrv_enable_write_cache(BlockDriverState *bs);
  152: int bdrv_is_inserted(BlockDriverState *bs);
  153: int bdrv_media_changed(BlockDriverState *bs);
  154: int bdrv_is_locked(BlockDriverState *bs);
  155: void bdrv_set_locked(BlockDriverState *bs, int locked);
  156: int bdrv_eject(BlockDriverState *bs, int eject_flag);
  157: void bdrv_set_change_cb(BlockDriverState *bs,
  158:                         void (*change_cb)(void *opaque), void *opaque);
  159: void bdrv_get_format(BlockDriverState *bs, char *buf, int buf_size);
  160: BlockDriverState *bdrv_find(const char *name);
  161: void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs),
  162:                   void *opaque);
  163: int bdrv_is_encrypted(BlockDriverState *bs);
  164: int bdrv_key_required(BlockDriverState *bs);
  165: int bdrv_set_key(BlockDriverState *bs, const char *key);
  166: int bdrv_query_missing_keys(void);
  167: void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
  168:                          void *opaque);
  169: const char *bdrv_get_device_name(BlockDriverState *bs);
  170: int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
  171:                           const uint8_t *buf, int nb_sectors);
  172: int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi);
  173: 
  174: const char *bdrv_get_encrypted_filename(BlockDriverState *bs);
  175: void bdrv_get_backing_filename(BlockDriverState *bs,
  176:                                char *filename, int filename_size);
  177: int bdrv_snapshot_create(BlockDriverState *bs,
  178:                          QEMUSnapshotInfo *sn_info);
  179: int bdrv_snapshot_goto(BlockDriverState *bs,
  180:                        const char *snapshot_id);
  181: int bdrv_snapshot_delete(BlockDriverState *bs, const char *snapshot_id);
  182: int bdrv_snapshot_list(BlockDriverState *bs,
  183:                        QEMUSnapshotInfo **psn_info);
  184: char *bdrv_snapshot_dump(char *buf, int buf_size, QEMUSnapshotInfo *sn);
  185: 
  186: char *get_human_readable_size(char *buf, int buf_size, int64_t size);
  187: int path_is_absolute(const char *path);
  188: void path_combine(char *dest, int dest_size,
  189:                   const char *base_path,
  190:                   const char *filename);
  191: 
  192: int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
  193:                       int64_t pos, int size);
  194: 
  195: int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,
  196:                       int64_t pos, int size);
  197: 
  198: #define BDRV_SECTORS_PER_DIRTY_CHUNK 2048
  199: 
  200: void bdrv_set_dirty_tracking(BlockDriverState *bs, int enable);
  201: int bdrv_get_dirty(BlockDriverState *bs, int64_t sector);
  202: void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector,
  203:                       int nr_sectors);
  204: #endif

unix.superglobalmegacorp.com