Statistics
| Branch: | Revision:

root / block.h @ 0aa217e4

History | View | Annotate | Download (7.2 kB)

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

    
8
/* block.c */
9
typedef struct BlockDriver BlockDriver;
10

    
11
typedef struct BlockDriverInfo {
12
    /* in bytes, 0 if irrelevant */
13
    int cluster_size;
14
    /* offset at which the VM state can be saved (0 if not possible) */
15
    int64_t vm_state_offset;
16
} BlockDriverInfo;
17

    
18
typedef struct QEMUSnapshotInfo {
19
    char id_str[128]; /* unique snapshot id */
20
    /* the following fields are informative. They are not needed for
21
       the consistency of the snapshot */
22
    char name[256]; /* user choosen name */
23
    uint32_t vm_state_size; /* VM state info size */
24
    uint32_t date_sec; /* UTC date of the snapshot */
25
    uint32_t date_nsec;
26
    uint64_t vm_clock_nsec; /* VM clock relative to boot */
27
} QEMUSnapshotInfo;
28

    
29
#define BDRV_O_RDONLY      0x0000
30
#define BDRV_O_RDWR        0x0002
31
#define BDRV_O_ACCESS      0x0003
32
#define BDRV_O_CREAT       0x0004 /* create an empty file */
33
#define BDRV_O_SNAPSHOT    0x0008 /* open the file read only and save writes in a snapshot */
34
#define BDRV_O_FILE        0x0010 /* open as a raw file (do not try to
35
                                     use a disk image format on top of
36
                                     it (default for
37
                                     bdrv_file_open()) */
38
#define BDRV_O_NOCACHE     0x0020 /* do not use the host page cache */
39
#define BDRV_O_CACHE_WB    0x0040 /* use write-back caching */
40

    
41
#define BDRV_O_CACHE_MASK  (BDRV_O_NOCACHE | BDRV_O_CACHE_WB)
42

    
43
void bdrv_info(Monitor *mon);
44
void bdrv_info_stats(Monitor *mon);
45

    
46
void bdrv_init(void);
47
BlockDriver *bdrv_find_format(const char *format_name);
48
int bdrv_create(BlockDriver *drv, const char* filename,
49
    QEMUOptionParameter *options);
50
int bdrv_create2(BlockDriver *drv,
51
                 const char *filename, int64_t size_in_sectors,
52
                 const char *backing_file, const char *backing_format,
53
                 int flags);
54
BlockDriverState *bdrv_new(const char *device_name);
55
void bdrv_delete(BlockDriverState *bs);
56
int bdrv_file_open(BlockDriverState **pbs, const char *filename, int flags);
57
int bdrv_open(BlockDriverState *bs, const char *filename, int flags);
58
int bdrv_open2(BlockDriverState *bs, const char *filename, int flags,
59
               BlockDriver *drv);
60
int bdrv_open3(BlockDriverState *bs, const char *filename, int flags,
61
               BlockDriver *drv);
62
void bdrv_close(BlockDriverState *bs);
63
int bdrv_check(BlockDriverState *bs);
64
int bdrv_read(BlockDriverState *bs, int64_t sector_num,
65
              uint8_t *buf, int nb_sectors);
66
int bdrv_write(BlockDriverState *bs, int64_t sector_num,
67
               const uint8_t *buf, int nb_sectors);
68
int bdrv_pread(BlockDriverState *bs, int64_t offset,
69
               void *buf, int count);
70
int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
71
                const void *buf, int count);
72
int bdrv_truncate(BlockDriverState *bs, int64_t offset);
73
int64_t bdrv_getlength(BlockDriverState *bs);
74
void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr);
75
void bdrv_guess_geometry(BlockDriverState *bs, int *pcyls, int *pheads, int *psecs);
76
int bdrv_commit(BlockDriverState *bs);
77
void bdrv_register(BlockDriver *bdrv);
78

    
79
/* async block I/O */
80
typedef struct BlockDriverAIOCB BlockDriverAIOCB;
81
typedef void BlockDriverCompletionFunc(void *opaque, int ret);
82

    
83
BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
84
                                 QEMUIOVector *iov, int nb_sectors,
85
                                 BlockDriverCompletionFunc *cb, void *opaque);
86
BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
87
                                  QEMUIOVector *iov, int nb_sectors,
88
                                  BlockDriverCompletionFunc *cb, void *opaque);
89
void bdrv_aio_cancel(BlockDriverAIOCB *acb);
90

    
91
/* sg packet commands */
92
int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf);
93
BlockDriverAIOCB *bdrv_aio_ioctl(BlockDriverState *bs,
94
        unsigned long int req, void *buf,
95
        BlockDriverCompletionFunc *cb, void *opaque);
96

    
97
/* Ensure contents are flushed to disk.  */
98
void bdrv_flush(BlockDriverState *bs);
99
void bdrv_flush_all(void);
100

    
101
int bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
102
        int *pnum);
103

    
104
#define BDRV_TYPE_HD     0
105
#define BDRV_TYPE_CDROM  1
106
#define BDRV_TYPE_FLOPPY 2
107
#define BIOS_ATA_TRANSLATION_AUTO   0
108
#define BIOS_ATA_TRANSLATION_NONE   1
109
#define BIOS_ATA_TRANSLATION_LBA    2
110
#define BIOS_ATA_TRANSLATION_LARGE  3
111
#define BIOS_ATA_TRANSLATION_RECHS  4
112

    
113
void bdrv_set_geometry_hint(BlockDriverState *bs,
114
                            int cyls, int heads, int secs);
115
void bdrv_set_type_hint(BlockDriverState *bs, int type);
116
void bdrv_set_translation_hint(BlockDriverState *bs, int translation);
117
void bdrv_get_geometry_hint(BlockDriverState *bs,
118
                            int *pcyls, int *pheads, int *psecs);
119
int bdrv_get_type_hint(BlockDriverState *bs);
120
int bdrv_get_translation_hint(BlockDriverState *bs);
121
int bdrv_is_removable(BlockDriverState *bs);
122
int bdrv_is_read_only(BlockDriverState *bs);
123
int bdrv_is_sg(BlockDriverState *bs);
124
int bdrv_is_inserted(BlockDriverState *bs);
125
int bdrv_media_changed(BlockDriverState *bs);
126
int bdrv_is_locked(BlockDriverState *bs);
127
void bdrv_set_locked(BlockDriverState *bs, int locked);
128
int bdrv_eject(BlockDriverState *bs, int eject_flag);
129
void bdrv_set_change_cb(BlockDriverState *bs,
130
                        void (*change_cb)(void *opaque), void *opaque);
131
void bdrv_get_format(BlockDriverState *bs, char *buf, int buf_size);
132
BlockDriverState *bdrv_find(const char *name);
133
void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs),
134
                  void *opaque);
135
int bdrv_is_encrypted(BlockDriverState *bs);
136
int bdrv_key_required(BlockDriverState *bs);
137
int bdrv_set_key(BlockDriverState *bs, const char *key);
138
int bdrv_query_missing_keys(void);
139
void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
140
                         void *opaque);
141
const char *bdrv_get_device_name(BlockDriverState *bs);
142
int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
143
                          const uint8_t *buf, int nb_sectors);
144
int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi);
145

    
146
const char *bdrv_get_encrypted_filename(BlockDriverState *bs);
147
void bdrv_get_backing_filename(BlockDriverState *bs,
148
                               char *filename, int filename_size);
149
int bdrv_snapshot_create(BlockDriverState *bs,
150
                         QEMUSnapshotInfo *sn_info);
151
int bdrv_snapshot_goto(BlockDriverState *bs,
152
                       const char *snapshot_id);
153
int bdrv_snapshot_delete(BlockDriverState *bs, const char *snapshot_id);
154
int bdrv_snapshot_list(BlockDriverState *bs,
155
                       QEMUSnapshotInfo **psn_info);
156
char *bdrv_snapshot_dump(char *buf, int buf_size, QEMUSnapshotInfo *sn);
157

    
158
char *get_human_readable_size(char *buf, int buf_size, int64_t size);
159
int path_is_absolute(const char *path);
160
void path_combine(char *dest, int dest_size,
161
                  const char *base_path,
162
                  const char *filename);
163

    
164
int bdrv_put_buffer(BlockDriverState *bs, const uint8_t *buf,
165
                    int64_t pos, int size);
166

    
167
int bdrv_get_buffer(BlockDriverState *bs, uint8_t *buf, int64_t pos, int size);
168

    
169
#endif