Statistics
| Branch: | Revision:

root / block.h @ 7d0d6950

History | View | Annotate | Download (10.5 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_NOCACHE     0x0020 /* do not use the host page cache */
33
#define BDRV_O_CACHE_WB    0x0040 /* use write-back caching */
34
#define BDRV_O_NATIVE_AIO  0x0080 /* use native AIO instead of the thread pool */
35
#define BDRV_O_NO_BACKING  0x0100 /* don't open the backing file */
36
#define BDRV_O_NO_FLUSH    0x0200 /* disable flushing on this disk */
37

    
38
#define BDRV_O_CACHE_MASK  (BDRV_O_NOCACHE | BDRV_O_CACHE_WB)
39

    
40
#define BDRV_SECTOR_BITS   9
41
#define BDRV_SECTOR_SIZE   (1ULL << BDRV_SECTOR_BITS)
42
#define BDRV_SECTOR_MASK   ~(BDRV_SECTOR_SIZE - 1)
43

    
44
typedef enum {
45
    BLOCK_ERR_REPORT, BLOCK_ERR_IGNORE, BLOCK_ERR_STOP_ENOSPC,
46
    BLOCK_ERR_STOP_ANY
47
} BlockErrorAction;
48

    
49
typedef enum {
50
    BDRV_ACTION_REPORT, BDRV_ACTION_IGNORE, BDRV_ACTION_STOP
51
} BlockMonEventAction;
52

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

    
60
void bdrv_init(void);
61
void bdrv_init_with_whitelist(void);
62
BlockDriver *bdrv_find_protocol(const char *filename);
63
BlockDriver *bdrv_find_format(const char *format_name);
64
BlockDriver *bdrv_find_whitelisted_format(const char *format_name);
65
int bdrv_create(BlockDriver *drv, const char* filename,
66
    QEMUOptionParameter *options);
67
int bdrv_create_file(const char* filename, QEMUOptionParameter *options);
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_attach(BlockDriverState *bs, DeviceState *qdev);
75
void bdrv_detach(BlockDriverState *bs, DeviceState *qdev);
76
DeviceState *bdrv_get_attached(BlockDriverState *bs);
77
int bdrv_check(BlockDriverState *bs);
78
int bdrv_read(BlockDriverState *bs, int64_t sector_num,
79
              uint8_t *buf, int nb_sectors);
80
int bdrv_write(BlockDriverState *bs, int64_t sector_num,
81
               const uint8_t *buf, int nb_sectors);
82
int bdrv_pread(BlockDriverState *bs, int64_t offset,
83
               void *buf, int count);
84
int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
85
                const void *buf, int count);
86
int bdrv_pwrite_sync(BlockDriverState *bs, int64_t offset,
87
    const void *buf, int count);
88
int bdrv_write_sync(BlockDriverState *bs, int64_t sector_num,
89
    const uint8_t *buf, int nb_sectors);
90
int bdrv_truncate(BlockDriverState *bs, int64_t offset);
91
int64_t bdrv_getlength(BlockDriverState *bs);
92
void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr);
93
void bdrv_guess_geometry(BlockDriverState *bs, int *pcyls, int *pheads, int *psecs);
94
int bdrv_commit(BlockDriverState *bs);
95
void bdrv_commit_all(void);
96
int bdrv_change_backing_file(BlockDriverState *bs,
97
    const char *backing_file, const char *backing_fmt);
98
void bdrv_register(BlockDriver *bdrv);
99

    
100
/* async block I/O */
101
typedef struct BlockDriverAIOCB BlockDriverAIOCB;
102
typedef void BlockDriverCompletionFunc(void *opaque, int ret);
103
typedef void BlockDriverDirtyHandler(BlockDriverState *bs, int64_t sector,
104
                                     int sector_num);
105
BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
106
                                 QEMUIOVector *iov, int nb_sectors,
107
                                 BlockDriverCompletionFunc *cb, void *opaque);
108
BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
109
                                  QEMUIOVector *iov, int nb_sectors,
110
                                  BlockDriverCompletionFunc *cb, void *opaque);
111
BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs,
112
                                 BlockDriverCompletionFunc *cb, void *opaque);
113
void bdrv_aio_cancel(BlockDriverAIOCB *acb);
114

    
115
typedef struct BlockRequest {
116
    /* Fields to be filled by multiwrite caller */
117
    int64_t sector;
118
    int nb_sectors;
119
    QEMUIOVector *qiov;
120
    BlockDriverCompletionFunc *cb;
121
    void *opaque;
122

    
123
    /* Filled by multiwrite implementation */
124
    int error;
125
} BlockRequest;
126

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

    
130
/* sg packet commands */
131
int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf);
132
BlockDriverAIOCB *bdrv_aio_ioctl(BlockDriverState *bs,
133
        unsigned long int req, void *buf,
134
        BlockDriverCompletionFunc *cb, void *opaque);
135

    
136
/* Ensure contents are flushed to disk.  */
137
void bdrv_flush(BlockDriverState *bs);
138
void bdrv_flush_all(void);
139
void bdrv_close_all(void);
140

    
141
int bdrv_has_zero_init(BlockDriverState *bs);
142
int bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
143
        int *pnum);
144

    
145
#define BDRV_TYPE_HD     0
146
#define BDRV_TYPE_CDROM  1
147
#define BDRV_TYPE_FLOPPY 2
148
#define BIOS_ATA_TRANSLATION_AUTO   0
149
#define BIOS_ATA_TRANSLATION_NONE   1
150
#define BIOS_ATA_TRANSLATION_LBA    2
151
#define BIOS_ATA_TRANSLATION_LARGE  3
152
#define BIOS_ATA_TRANSLATION_RECHS  4
153

    
154
void bdrv_set_geometry_hint(BlockDriverState *bs,
155
                            int cyls, int heads, int secs);
156
void bdrv_set_type_hint(BlockDriverState *bs, int type);
157
void bdrv_set_translation_hint(BlockDriverState *bs, int translation);
158
void bdrv_get_geometry_hint(BlockDriverState *bs,
159
                            int *pcyls, int *pheads, int *psecs);
160
int bdrv_get_type_hint(BlockDriverState *bs);
161
int bdrv_get_translation_hint(BlockDriverState *bs);
162
void bdrv_set_on_error(BlockDriverState *bs, BlockErrorAction on_read_error,
163
                       BlockErrorAction on_write_error);
164
BlockErrorAction bdrv_get_on_error(BlockDriverState *bs, int is_read);
165
void bdrv_set_removable(BlockDriverState *bs, int removable);
166
int bdrv_is_removable(BlockDriverState *bs);
167
int bdrv_is_read_only(BlockDriverState *bs);
168
int bdrv_is_sg(BlockDriverState *bs);
169
int bdrv_enable_write_cache(BlockDriverState *bs);
170
int bdrv_is_inserted(BlockDriverState *bs);
171
int bdrv_media_changed(BlockDriverState *bs);
172
int bdrv_is_locked(BlockDriverState *bs);
173
void bdrv_set_locked(BlockDriverState *bs, int locked);
174
int bdrv_eject(BlockDriverState *bs, int eject_flag);
175
void bdrv_set_change_cb(BlockDriverState *bs,
176
                        void (*change_cb)(void *opaque), void *opaque);
177
void bdrv_get_format(BlockDriverState *bs, char *buf, int buf_size);
178
BlockDriverState *bdrv_find(const char *name);
179
BlockDriverState *bdrv_next(BlockDriverState *bs);
180
void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs),
181
                  void *opaque);
182
int bdrv_is_encrypted(BlockDriverState *bs);
183
int bdrv_key_required(BlockDriverState *bs);
184
int bdrv_set_key(BlockDriverState *bs, const char *key);
185
int bdrv_query_missing_keys(void);
186
void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
187
                         void *opaque);
188
const char *bdrv_get_device_name(BlockDriverState *bs);
189
int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
190
                          const uint8_t *buf, int nb_sectors);
191
int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi);
192

    
193
const char *bdrv_get_encrypted_filename(BlockDriverState *bs);
194
void bdrv_get_backing_filename(BlockDriverState *bs,
195
                               char *filename, int filename_size);
196
int bdrv_can_snapshot(BlockDriverState *bs);
197
BlockDriverState *bdrv_snapshots(void);
198
int bdrv_snapshot_create(BlockDriverState *bs,
199
                         QEMUSnapshotInfo *sn_info);
200
int bdrv_snapshot_goto(BlockDriverState *bs,
201
                       const char *snapshot_id);
202
int bdrv_snapshot_delete(BlockDriverState *bs, const char *snapshot_id);
203
int bdrv_snapshot_list(BlockDriverState *bs,
204
                       QEMUSnapshotInfo **psn_info);
205
char *bdrv_snapshot_dump(char *buf, int buf_size, QEMUSnapshotInfo *sn);
206

    
207
char *get_human_readable_size(char *buf, int buf_size, int64_t size);
208
int path_is_absolute(const char *path);
209
void path_combine(char *dest, int dest_size,
210
                  const char *base_path,
211
                  const char *filename);
212

    
213
int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
214
                      int64_t pos, int size);
215

    
216
int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,
217
                      int64_t pos, int size);
218

    
219
#define BDRV_SECTORS_PER_DIRTY_CHUNK 2048
220

    
221
void bdrv_set_dirty_tracking(BlockDriverState *bs, int enable);
222
int bdrv_get_dirty(BlockDriverState *bs, int64_t sector);
223
void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector,
224
                      int nr_sectors);
225
int64_t bdrv_get_dirty_count(BlockDriverState *bs);
226

    
227

    
228
typedef enum {
229
    BLKDBG_L1_UPDATE,
230

    
231
    BLKDBG_L1_GROW_ALLOC_TABLE,
232
    BLKDBG_L1_GROW_WRITE_TABLE,
233
    BLKDBG_L1_GROW_ACTIVATE_TABLE,
234

    
235
    BLKDBG_L2_LOAD,
236
    BLKDBG_L2_UPDATE,
237
    BLKDBG_L2_UPDATE_COMPRESSED,
238
    BLKDBG_L2_ALLOC_COW_READ,
239
    BLKDBG_L2_ALLOC_WRITE,
240

    
241
    BLKDBG_READ,
242
    BLKDBG_READ_AIO,
243
    BLKDBG_READ_BACKING,
244
    BLKDBG_READ_BACKING_AIO,
245
    BLKDBG_READ_COMPRESSED,
246

    
247
    BLKDBG_WRITE_AIO,
248
    BLKDBG_WRITE_COMPRESSED,
249

    
250
    BLKDBG_VMSTATE_LOAD,
251
    BLKDBG_VMSTATE_SAVE,
252

    
253
    BLKDBG_COW_READ,
254
    BLKDBG_COW_WRITE,
255

    
256
    BLKDBG_REFTABLE_LOAD,
257
    BLKDBG_REFTABLE_GROW,
258

    
259
    BLKDBG_REFBLOCK_LOAD,
260
    BLKDBG_REFBLOCK_UPDATE,
261
    BLKDBG_REFBLOCK_UPDATE_PART,
262
    BLKDBG_REFBLOCK_ALLOC,
263
    BLKDBG_REFBLOCK_ALLOC_HOOKUP,
264
    BLKDBG_REFBLOCK_ALLOC_WRITE,
265
    BLKDBG_REFBLOCK_ALLOC_WRITE_BLOCKS,
266
    BLKDBG_REFBLOCK_ALLOC_WRITE_TABLE,
267
    BLKDBG_REFBLOCK_ALLOC_SWITCH_TABLE,
268

    
269
    BLKDBG_CLUSTER_ALLOC,
270
    BLKDBG_CLUSTER_ALLOC_BYTES,
271
    BLKDBG_CLUSTER_FREE,
272

    
273
    BLKDBG_EVENT_MAX,
274
} BlkDebugEvent;
275

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

    
279
#endif