Statistics
| Branch: | Revision:

root / block.h @ d6e9098e

History | View | Annotate | Download (9.8 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
#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_RDWR        0x0002
31
#define BDRV_O_SNAPSHOT    0x0008 /* open the file read only and save writes in a snapshot */
32
#define BDRV_O_FILE        0x0010 /* open as a raw file (do not try to
33
                                     use a disk image format on top of
34
                                     it (default for
35
                                     bdrv_file_open()) */
36
#define BDRV_O_NOCACHE     0x0020 /* do not use the host page cache */
37
#define BDRV_O_CACHE_WB    0x0040 /* use write-back caching */
38
#define BDRV_O_NATIVE_AIO  0x0080 /* use native AIO instead of the thread pool */
39
#define BDRV_O_NO_BACKING  0x0100 /* don't open the backing file */
40

    
41
#define BDRV_O_CACHE_MASK  (BDRV_O_NOCACHE | BDRV_O_CACHE_WB)
42

    
43
#define BDRV_SECTOR_BITS   9
44
#define BDRV_SECTOR_SIZE   (1 << BDRV_SECTOR_BITS)
45
#define BDRV_SECTOR_MASK   ~(BDRV_SECTOR_SIZE - 1);
46

    
47
typedef enum {
48
    BDRV_ACTION_REPORT, BDRV_ACTION_IGNORE, BDRV_ACTION_STOP
49
} BlockMonEventAction;
50

    
51
void bdrv_mon_event(const BlockDriverState *bdrv,
52
                    BlockMonEventAction action, int is_read);
53
void bdrv_info_print(Monitor *mon, const QObject *data);
54
void bdrv_info(Monitor *mon, QObject **ret_data);
55
void bdrv_stats_print(Monitor *mon, const QObject *data);
56
void bdrv_info_stats(Monitor *mon, QObject **ret_data);
57

    
58
void bdrv_init(void);
59
void bdrv_init_with_whitelist(void);
60
BlockDriver *bdrv_find_format(const char *format_name);
61
BlockDriver *bdrv_find_whitelisted_format(const char *format_name);
62
int bdrv_create(BlockDriver *drv, const char* filename,
63
    QEMUOptionParameter *options);
64
int bdrv_create2(BlockDriver *drv,
65
                 const char *filename, int64_t size_in_sectors,
66
                 const char *backing_file, const char *backing_format,
67
                 int flags);
68
BlockDriverState *bdrv_new(const char *device_name);
69
void bdrv_delete(BlockDriverState *bs);
70
int bdrv_file_open(BlockDriverState **pbs, const char *filename, int flags);
71
int bdrv_open(BlockDriverState *bs, const char *filename, int flags,
72
              BlockDriver *drv);
73
void bdrv_close(BlockDriverState *bs);
74
int bdrv_check(BlockDriverState *bs);
75
int bdrv_read(BlockDriverState *bs, int64_t sector_num,
76
              uint8_t *buf, int nb_sectors);
77
int bdrv_write(BlockDriverState *bs, int64_t sector_num,
78
               const uint8_t *buf, int nb_sectors);
79
int bdrv_pread(BlockDriverState *bs, int64_t offset,
80
               void *buf, int count);
81
int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
82
                const void *buf, int count);
83
int bdrv_truncate(BlockDriverState *bs, int64_t offset);
84
int64_t bdrv_getlength(BlockDriverState *bs);
85
void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr);
86
void bdrv_guess_geometry(BlockDriverState *bs, int *pcyls, int *pheads, int *psecs);
87
int bdrv_commit(BlockDriverState *bs);
88
int bdrv_change_backing_file(BlockDriverState *bs,
89
    const char *backing_file, const char *backing_fmt);
90
void bdrv_register(BlockDriver *bdrv);
91

    
92
/* async block I/O */
93
typedef struct BlockDriverAIOCB BlockDriverAIOCB;
94
typedef void BlockDriverCompletionFunc(void *opaque, int ret);
95
typedef void BlockDriverDirtyHandler(BlockDriverState *bs, int64_t sector,
96
                                     int sector_num);
97
BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
98
                                 QEMUIOVector *iov, int nb_sectors,
99
                                 BlockDriverCompletionFunc *cb, void *opaque);
100
BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
101
                                  QEMUIOVector *iov, int nb_sectors,
102
                                  BlockDriverCompletionFunc *cb, void *opaque);
103
BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs,
104
                                 BlockDriverCompletionFunc *cb, void *opaque);
105
void bdrv_aio_cancel(BlockDriverAIOCB *acb);
106

    
107
typedef struct BlockRequest {
108
    /* Fields to be filled by multiwrite caller */
109
    int64_t sector;
110
    int nb_sectors;
111
    QEMUIOVector *qiov;
112
    BlockDriverCompletionFunc *cb;
113
    void *opaque;
114

    
115
    /* Filled by multiwrite implementation */
116
    int error;
117
} BlockRequest;
118

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

    
122
/* sg packet commands */
123
int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf);
124
BlockDriverAIOCB *bdrv_aio_ioctl(BlockDriverState *bs,
125
        unsigned long int req, void *buf,
126
        BlockDriverCompletionFunc *cb, void *opaque);
127

    
128
/* Ensure contents are flushed to disk.  */
129
void bdrv_flush(BlockDriverState *bs);
130
void bdrv_flush_all(void);
131

    
132
int bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
133
        int *pnum);
134

    
135
#define BDRV_TYPE_HD     0
136
#define BDRV_TYPE_CDROM  1
137
#define BDRV_TYPE_FLOPPY 2
138
#define BIOS_ATA_TRANSLATION_AUTO   0
139
#define BIOS_ATA_TRANSLATION_NONE   1
140
#define BIOS_ATA_TRANSLATION_LBA    2
141
#define BIOS_ATA_TRANSLATION_LARGE  3
142
#define BIOS_ATA_TRANSLATION_RECHS  4
143

    
144
void bdrv_set_geometry_hint(BlockDriverState *bs,
145
                            int cyls, int heads, int secs);
146
void bdrv_set_type_hint(BlockDriverState *bs, int type);
147
void bdrv_set_translation_hint(BlockDriverState *bs, int translation);
148
void bdrv_get_geometry_hint(BlockDriverState *bs,
149
                            int *pcyls, int *pheads, int *psecs);
150
int bdrv_get_type_hint(BlockDriverState *bs);
151
int bdrv_get_translation_hint(BlockDriverState *bs);
152
int bdrv_is_removable(BlockDriverState *bs);
153
int bdrv_is_read_only(BlockDriverState *bs);
154
int bdrv_is_sg(BlockDriverState *bs);
155
int bdrv_enable_write_cache(BlockDriverState *bs);
156
int bdrv_is_inserted(BlockDriverState *bs);
157
int bdrv_media_changed(BlockDriverState *bs);
158
int bdrv_is_locked(BlockDriverState *bs);
159
void bdrv_set_locked(BlockDriverState *bs, int locked);
160
int bdrv_eject(BlockDriverState *bs, int eject_flag);
161
void bdrv_set_change_cb(BlockDriverState *bs,
162
                        void (*change_cb)(void *opaque), void *opaque);
163
void bdrv_get_format(BlockDriverState *bs, char *buf, int buf_size);
164
BlockDriverState *bdrv_find(const char *name);
165
void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs),
166
                  void *opaque);
167
int bdrv_is_encrypted(BlockDriverState *bs);
168
int bdrv_key_required(BlockDriverState *bs);
169
int bdrv_set_key(BlockDriverState *bs, const char *key);
170
int bdrv_query_missing_keys(void);
171
void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
172
                         void *opaque);
173
const char *bdrv_get_device_name(BlockDriverState *bs);
174
int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
175
                          const uint8_t *buf, int nb_sectors);
176
int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi);
177

    
178
const char *bdrv_get_encrypted_filename(BlockDriverState *bs);
179
void bdrv_get_backing_filename(BlockDriverState *bs,
180
                               char *filename, int filename_size);
181
int bdrv_snapshot_create(BlockDriverState *bs,
182
                         QEMUSnapshotInfo *sn_info);
183
int bdrv_snapshot_goto(BlockDriverState *bs,
184
                       const char *snapshot_id);
185
int bdrv_snapshot_delete(BlockDriverState *bs, const char *snapshot_id);
186
int bdrv_snapshot_list(BlockDriverState *bs,
187
                       QEMUSnapshotInfo **psn_info);
188
char *bdrv_snapshot_dump(char *buf, int buf_size, QEMUSnapshotInfo *sn);
189

    
190
char *get_human_readable_size(char *buf, int buf_size, int64_t size);
191
int path_is_absolute(const char *path);
192
void path_combine(char *dest, int dest_size,
193
                  const char *base_path,
194
                  const char *filename);
195

    
196
int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
197
                      int64_t pos, int size);
198

    
199
int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,
200
                      int64_t pos, int size);
201

    
202
#define BDRV_SECTORS_PER_DIRTY_CHUNK 2048
203

    
204
void bdrv_set_dirty_tracking(BlockDriverState *bs, int enable);
205
int bdrv_get_dirty(BlockDriverState *bs, int64_t sector);
206
void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector,
207
                      int nr_sectors);
208
int64_t bdrv_get_dirty_count(BlockDriverState *bs);
209

    
210

    
211
typedef enum {
212
    BLKDBG_L1_UPDATE,
213

    
214
    BLKDBG_L1_GROW_ALLOC_TABLE,
215
    BLKDBG_L1_GROW_WRITE_TABLE,
216
    BLKDBG_L1_GROW_ACTIVATE_TABLE,
217

    
218
    BLKDBG_L2_LOAD,
219
    BLKDBG_L2_UPDATE,
220
    BLKDBG_L2_UPDATE_COMPRESSED,
221
    BLKDBG_L2_ALLOC_COW_READ,
222
    BLKDBG_L2_ALLOC_WRITE,
223

    
224
    BLKDBG_READ,
225
    BLKDBG_READ_AIO,
226
    BLKDBG_READ_BACKING,
227
    BLKDBG_READ_BACKING_AIO,
228
    BLKDBG_READ_COMPRESSED,
229

    
230
    BLKDBG_WRITE_AIO,
231
    BLKDBG_WRITE_COMPRESSED,
232

    
233
    BLKDBG_VMSTATE_LOAD,
234
    BLKDBG_VMSTATE_SAVE,
235

    
236
    BLKDBG_COW_READ,
237
    BLKDBG_COW_WRITE,
238

    
239
    BLKDBG_REFTABLE_LOAD,
240
    BLKDBG_REFTABLE_GROW,
241

    
242
    BLKDBG_REFBLOCK_LOAD,
243
    BLKDBG_REFBLOCK_UPDATE,
244
    BLKDBG_REFBLOCK_UPDATE_PART,
245
    BLKDBG_REFBLOCK_ALLOC,
246
    BLKDBG_REFBLOCK_ALLOC_HOOKUP,
247
    BLKDBG_REFBLOCK_ALLOC_WRITE,
248
    BLKDBG_REFBLOCK_ALLOC_WRITE_BLOCKS,
249
    BLKDBG_REFBLOCK_ALLOC_WRITE_TABLE,
250
    BLKDBG_REFBLOCK_ALLOC_SWITCH_TABLE,
251

    
252
    BLKDBG_CLUSTER_ALLOC,
253
    BLKDBG_CLUSTER_ALLOC_BYTES,
254
    BLKDBG_CLUSTER_FREE,
255

    
256
    BLKDBG_EVENT_MAX,
257
} BlkDebugEvent;
258

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

    
262
#endif