1 #ifndef BLOCK_H

     2 #define BLOCK_H

     3 

     4 #include "qemu-aio.h"

     5 

     6 /* block.c */

     7 typedef struct BlockDriver BlockDriver;

     8 

     9 extern BlockDriver bdrv_raw;

    10 extern BlockDriver bdrv_host_device;

    11 extern BlockDriver bdrv_cow;

    12 extern BlockDriver bdrv_qcow;

    13 extern BlockDriver bdrv_vmdk;

    14 extern BlockDriver bdrv_cloop;

    15 extern BlockDriver bdrv_dmg;

    16 extern BlockDriver bdrv_bochs;

    17 extern BlockDriver bdrv_vpc;

    18 extern BlockDriver bdrv_vvfat;

    19 extern BlockDriver bdrv_qcow2;

    20 extern BlockDriver bdrv_parallels;

    21 extern BlockDriver bdrv_nbd;

    22 

    23 typedef struct BlockDriverInfo {

    24     /* in bytes, 0 if irrelevant */

    25     int cluster_size;

    26     /* offset at which the VM state can be saved (0 if not possible) */

    27     int64_t vm_state_offset;

    28 } BlockDriverInfo;

    29 

    30 typedef struct QEMUSnapshotInfo {

    31     char id_str[128]; /* unique snapshot id */

    32     /* the following fields are informative. They are not needed for

    33        the consistency of the snapshot */

    34     char name[256]; /* user choosen name */

    35     uint32_t vm_state_size; /* VM state info size */

    36     uint32_t date_sec; /* UTC date of the snapshot */

    37     uint32_t date_nsec;

    38     uint64_t vm_clock_nsec; /* VM clock relative to boot */

    39 } QEMUSnapshotInfo;

    40 

    41 #define BDRV_O_RDONLY      0x0000

    42 #define BDRV_O_RDWR        0x0002

    43 #define BDRV_O_ACCESS      0x0003

    44 #define BDRV_O_CREAT       0x0004 /* create an empty file */

    45 #define BDRV_O_SNAPSHOT    0x0008 /* open the file read only and save writes in a snapshot */

    46 #define BDRV_O_FILE        0x0010 /* open as a raw file (do not try to

    47                                      use a disk image format on top of

    48                                      it (default for

    49                                      bdrv_file_open()) */

    50 #define BDRV_O_NOCACHE     0x0020 /* do not use the host page cache */

    51 #define BDRV_O_CACHE_WB    0x0040 /* use write-back caching */

    52 #define BDRV_O_CACHE_DEF   0x0080 /* use default caching */

    53 

    54 #define BDRV_O_CACHE_MASK  (BDRV_O_NOCACHE | BDRV_O_CACHE_WB | BDRV_O_CACHE_DEF)

    55 

    56 void bdrv_info(void);

    57 void bdrv_info_stats(void);

    58 

    59 void bdrv_init(void);

    60 BlockDriver *bdrv_find_format(const char *format_name);

    61 int bdrv_create(BlockDriver *drv,

    62                 const char *filename, int64_t size_in_sectors,

    63                 const char *backing_file, 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_read(BlockDriverState *bs, int64_t sector_num,

    72               uint8_t *buf, int nb_sectors);

    73 int bdrv_write(BlockDriverState *bs, int64_t sector_num,

    74                const uint8_t *buf, int nb_sectors);

    75 int bdrv_pread(BlockDriverState *bs, int64_t offset,

    76                void *buf, int count);

    77 int bdrv_pwrite(BlockDriverState *bs, int64_t offset,

    78                 const void *buf, int count);

    79 int bdrv_truncate(BlockDriverState *bs, int64_t offset);

    80 int64_t bdrv_getlength(BlockDriverState *bs);

    81 void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr);

    82 void bdrv_guess_geometry(BlockDriverState *bs, int *pcyls, int *pheads, int *psecs);

    83 int bdrv_commit(BlockDriverState *bs);

    84 /* async block I/O */

    85 typedef struct BlockDriverAIOCB BlockDriverAIOCB;

    86 typedef void BlockDriverCompletionFunc(void *opaque, int ret);

    87 

    88 BlockDriverAIOCB *bdrv_aio_read(BlockDriverState *bs, int64_t sector_num,

    89                                 uint8_t *buf, int nb_sectors,

    90                                 BlockDriverCompletionFunc *cb, void *opaque);

    91 BlockDriverAIOCB *bdrv_aio_write(BlockDriverState *bs, int64_t sector_num,

    92                                  const uint8_t *buf, int nb_sectors,

    93                                  BlockDriverCompletionFunc *cb, void *opaque);

    94 void bdrv_aio_cancel(BlockDriverAIOCB *acb);

    95 

    96 int qemu_key_check(BlockDriverState *bs, const char *name);

    97 

    98 /* Ensure contents are flushed to disk.  */

    99 void bdrv_flush(BlockDriverState *bs);

   100 void bdrv_flush_all(void);

   101 

   102 int bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num, int nb_sectors,

   103 	int *pnum);

   104 

   105 #define BDRV_TYPE_HD     0

   106 #define BDRV_TYPE_CDROM  1

   107 #define BDRV_TYPE_FLOPPY 2

   108 #define BIOS_ATA_TRANSLATION_AUTO   0

   109 #define BIOS_ATA_TRANSLATION_NONE   1

   110 #define BIOS_ATA_TRANSLATION_LBA    2

   111 #define BIOS_ATA_TRANSLATION_LARGE  3

   112 #define BIOS_ATA_TRANSLATION_RECHS  4

   113 

   114 void bdrv_set_geometry_hint(BlockDriverState *bs,

   115                             int cyls, int heads, int secs);

   116 void bdrv_set_type_hint(BlockDriverState *bs, int type);

   117 void bdrv_set_translation_hint(BlockDriverState *bs, int translation);

   118 void bdrv_get_geometry_hint(BlockDriverState *bs,

   119                             int *pcyls, int *pheads, int *psecs);

   120 int bdrv_get_type_hint(BlockDriverState *bs);

   121 int bdrv_get_translation_hint(BlockDriverState *bs);

   122 int bdrv_is_removable(BlockDriverState *bs);

   123 int bdrv_is_read_only(BlockDriverState *bs);

   124 int bdrv_is_sg(BlockDriverState *bs);

   125 int bdrv_is_inserted(BlockDriverState *bs);

   126 int bdrv_media_changed(BlockDriverState *bs);

   127 int bdrv_is_locked(BlockDriverState *bs);

   128 void bdrv_set_locked(BlockDriverState *bs, int locked);

   129 void bdrv_eject(BlockDriverState *bs, int eject_flag);

   130 void bdrv_set_change_cb(BlockDriverState *bs,

   131                         void (*change_cb)(void *opaque), void *opaque);

   132 void bdrv_get_format(BlockDriverState *bs, char *buf, int buf_size);

   133 BlockDriverState *bdrv_find(const char *name);

   134 void bdrv_iterate(void (*it)(void *opaque, const char *name), void *opaque);

   135 int bdrv_is_encrypted(BlockDriverState *bs);

   136 int bdrv_set_key(BlockDriverState *bs, const char *key);

   137 void bdrv_iterate_format(void (*it)(void *opaque, const char *name),

   138                          void *opaque);

   139 const char *bdrv_get_device_name(BlockDriverState *bs);

   140 int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,

   141                           const uint8_t *buf, int nb_sectors);

   142 int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi);

   143 

   144 void bdrv_get_backing_filename(BlockDriverState *bs,

   145                                char *filename, int filename_size);

   146 int bdrv_snapshot_create(BlockDriverState *bs,

   147                          QEMUSnapshotInfo *sn_info);

   148 int bdrv_snapshot_goto(BlockDriverState *bs,

   149                        const char *snapshot_id);

   150 int bdrv_snapshot_delete(BlockDriverState *bs, const char *snapshot_id);

   151 int bdrv_snapshot_list(BlockDriverState *bs,

   152                        QEMUSnapshotInfo **psn_info);

   153 char *bdrv_snapshot_dump(char *buf, int buf_size, QEMUSnapshotInfo *sn);

   154 int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf);

   155 

   156 char *get_human_readable_size(char *buf, int buf_size, int64_t size);

   157 int path_is_absolute(const char *path);

   158 void path_combine(char *dest, int dest_size,

   159                   const char *base_path,

   160                   const char *filename);

   161 

   162 #endif