← Back to branch summary

~ahs3/+junk/cq-qemu

« back to all changes in this revision

Viewing changes to block_int.h

  • Committer: Al Stone
  • Date: 2012-02-09 01:17:20 UTC
  • Revision ID: albert.stone@canonical.com-20120209011720-tztl7ik3qayz80p4
first commit to bzr for qemu

Show diffs side-by-side

added added

removed removed

Lines of Context:
block_int.h
 
1
/*
 
2
 * QEMU System Emulator block driver
 
3
 *
 
4
 * Copyright (c) 2003 Fabrice Bellard
 
5
 *
 
6
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 
7
 * of this software and associated documentation files (the "Software"), to deal
 
8
 * in the Software without restriction, including without limitation the rights
 
9
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 
10
 * copies of the Software, and to permit persons to whom the Software is
 
11
 * furnished to do so, subject to the following conditions:
 
12
 *
 
13
 * The above copyright notice and this permission notice shall be included in
 
14
 * all copies or substantial portions of the Software.
 
15
 *
 
16
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 
17
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 
18
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 
19
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 
20
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 
21
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 
22
 * THE SOFTWARE.
 
23
 */
 
24
#ifndef BLOCK_INT_H
 
25
#define BLOCK_INT_H
 
26
 
 
27
#include "block.h"
 
28
#include "qemu-option.h"
 
29
#include "qemu-queue.h"
 
30
#include "qemu-coroutine.h"
 
31
#include "qemu-timer.h"
 
32
#include "qapi-types.h"
 
33
 
 
34
#define BLOCK_FLAG_ENCRYPT      1
 
35
#define BLOCK_FLAG_COMPAT6      4
 
36
 
 
37
#define BLOCK_OPT_SIZE          "size"
 
38
#define BLOCK_OPT_ENCRYPT       "encryption"
 
39
#define BLOCK_OPT_COMPAT6       "compat6"
 
40
#define BLOCK_OPT_BACKING_FILE  "backing_file"
 
41
#define BLOCK_OPT_BACKING_FMT   "backing_fmt"
 
42
#define BLOCK_OPT_CLUSTER_SIZE  "cluster_size"
 
43
#define BLOCK_OPT_TABLE_SIZE    "table_size"
 
44
#define BLOCK_OPT_PREALLOC      "preallocation"
 
45
#define BLOCK_OPT_SUBFMT        "subformat"
 
46
 
 
47
typedef struct AIOPool {
 
48
    void (*cancel)(BlockDriverAIOCB *acb);
 
49
    int aiocb_size;
 
50
    BlockDriverAIOCB *free_aiocb;
 
51
} AIOPool;
 
52
 
 
53
struct BlockDriver {
 
54
    const char *format_name;
 
55
    int instance_size;
 
56
    int (*bdrv_probe)(const uint8_t *buf, int buf_size, const char *filename);
 
57
    int (*bdrv_probe_device)(const char *filename);
 
58
    int (*bdrv_open)(BlockDriverState *bs, int flags);
 
59
    int (*bdrv_file_open)(BlockDriverState *bs, const char *filename, int flags);
 
60
    int (*bdrv_read)(BlockDriverState *bs, int64_t sector_num,
 
61
                     uint8_t *buf, int nb_sectors);
 
62
    int (*bdrv_write)(BlockDriverState *bs, int64_t sector_num,
 
63
                      const uint8_t *buf, int nb_sectors);
 
64
    void (*bdrv_close)(BlockDriverState *bs);
 
65
    int (*bdrv_create)(const char *filename, QEMUOptionParameter *options);
 
66
    int (*bdrv_is_allocated)(BlockDriverState *bs, int64_t sector_num,
 
67
                             int nb_sectors, int *pnum);
 
68
    int (*bdrv_set_key)(BlockDriverState *bs, const char *key);
 
69
    int (*bdrv_make_empty)(BlockDriverState *bs);
 
70
    /* aio */
 
71
    BlockDriverAIOCB *(*bdrv_aio_readv)(BlockDriverState *bs,
 
72
        int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
 
73
        BlockDriverCompletionFunc *cb, void *opaque);
 
74
    BlockDriverAIOCB *(*bdrv_aio_writev)(BlockDriverState *bs,
 
75
        int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
 
76
        BlockDriverCompletionFunc *cb, void *opaque);
 
77
    BlockDriverAIOCB *(*bdrv_aio_flush)(BlockDriverState *bs,
 
78
        BlockDriverCompletionFunc *cb, void *opaque);
 
79
    BlockDriverAIOCB *(*bdrv_aio_discard)(BlockDriverState *bs,
 
80
        int64_t sector_num, int nb_sectors,
 
81
        BlockDriverCompletionFunc *cb, void *opaque);
 
82
 
 
83
    int coroutine_fn (*bdrv_co_readv)(BlockDriverState *bs,
 
84
        int64_t sector_num, int nb_sectors, QEMUIOVector *qiov);
 
85
    int coroutine_fn (*bdrv_co_writev)(BlockDriverState *bs,
 
86
        int64_t sector_num, int nb_sectors, QEMUIOVector *qiov);
 
87
    int coroutine_fn (*bdrv_co_discard)(BlockDriverState *bs,
 
88
        int64_t sector_num, int nb_sectors);
 
89
 
 
90
    /*
 
91
     * Invalidate any cached meta-data.
 
92
     */
 
93
    void (*bdrv_invalidate_cache)(BlockDriverState *bs);
 
94
 
 
95
    /*
 
96
     * Flushes all data that was already written to the OS all the way down to
 
97
     * the disk (for example raw-posix calls fsync()).
 
98
     */
 
99
    int coroutine_fn (*bdrv_co_flush_to_disk)(BlockDriverState *bs);
 
100
 
 
101
    /*
 
102
     * Flushes all internal caches to the OS. The data may still sit in a
 
103
     * writeback cache of the host OS, but it will survive a crash of the qemu
 
104
     * process.
 
105
     */
 
106
    int coroutine_fn (*bdrv_co_flush_to_os)(BlockDriverState *bs);
 
107
 
 
108
    int (*bdrv_aio_multiwrite)(BlockDriverState *bs, BlockRequest *reqs,
 
109
        int num_reqs);
 
110
    int (*bdrv_merge_requests)(BlockDriverState *bs, BlockRequest* a,
 
111
        BlockRequest *b);
 
112
 
 
113
 
 
114
    const char *protocol_name;
 
115
    int (*bdrv_truncate)(BlockDriverState *bs, int64_t offset);
 
116
    int64_t (*bdrv_getlength)(BlockDriverState *bs);
 
117
    int64_t (*bdrv_get_allocated_file_size)(BlockDriverState *bs);
 
118
    int (*bdrv_write_compressed)(BlockDriverState *bs, int64_t sector_num,
 
119
                                 const uint8_t *buf, int nb_sectors);
 
120
 
 
121
    int (*bdrv_snapshot_create)(BlockDriverState *bs,
 
122
                                QEMUSnapshotInfo *sn_info);
 
123
    int (*bdrv_snapshot_goto)(BlockDriverState *bs,
 
124
                              const char *snapshot_id);
 
125
    int (*bdrv_snapshot_delete)(BlockDriverState *bs, const char *snapshot_id);
 
126
    int (*bdrv_snapshot_list)(BlockDriverState *bs,
 
127
                              QEMUSnapshotInfo **psn_info);
 
128
    int (*bdrv_snapshot_load_tmp)(BlockDriverState *bs,
 
129
                                  const char *snapshot_name);
 
130
    int (*bdrv_get_info)(BlockDriverState *bs, BlockDriverInfo *bdi);
 
131
 
 
132
    int (*bdrv_save_vmstate)(BlockDriverState *bs, const uint8_t *buf,
 
133
                             int64_t pos, int size);
 
134
    int (*bdrv_load_vmstate)(BlockDriverState *bs, uint8_t *buf,
 
135
                             int64_t pos, int size);
 
136
 
 
137
    int (*bdrv_change_backing_file)(BlockDriverState *bs,
 
138
        const char *backing_file, const char *backing_fmt);
 
139
 
 
140
    /* removable device specific */
 
141
    int (*bdrv_is_inserted)(BlockDriverState *bs);
 
142
    int (*bdrv_media_changed)(BlockDriverState *bs);
 
143
    void (*bdrv_eject)(BlockDriverState *bs, int eject_flag);
 
144
    void (*bdrv_lock_medium)(BlockDriverState *bs, bool locked);
 
145
 
 
146
    /* to control generic scsi devices */
 
147
    int (*bdrv_ioctl)(BlockDriverState *bs, unsigned long int req, void *buf);
 
148
    BlockDriverAIOCB *(*bdrv_aio_ioctl)(BlockDriverState *bs,
 
149
        unsigned long int req, void *buf,
 
150
        BlockDriverCompletionFunc *cb, void *opaque);
 
151
 
 
152
    /* List of options for creating images, terminated by name == NULL */
 
153
    QEMUOptionParameter *create_options;
 
154
 
 
155
 
 
156
    /*
 
157
     * Returns 0 for completed check, -errno for internal errors.
 
158
     * The check results are stored in result.
 
159
     */
 
160
    int (*bdrv_check)(BlockDriverState* bs, BdrvCheckResult *result);
 
161
 
 
162
    void (*bdrv_debug_event)(BlockDriverState *bs, BlkDebugEvent event);
 
163
 
 
164
    /*
 
165
     * Returns 1 if newly created images are guaranteed to contain only
 
166
     * zeros, 0 otherwise.
 
167
     */
 
168
    int (*bdrv_has_zero_init)(BlockDriverState *bs);
 
169
 
 
170
    QLIST_ENTRY(BlockDriver) list;
 
171
};
 
172
 
 
173
struct BlockDriverState {
 
174
    int64_t total_sectors; /* if we are reading a disk image, give its
 
175
                              size in sectors */
 
176
    int read_only; /* if true, the media is read only */
 
177
    int keep_read_only; /* if true, the media was requested to stay read only */
 
178
    int open_flags; /* flags used to open the file, re-used for re-open */
 
179
    int encrypted; /* if true, the media is encrypted */
 
180
    int valid_key; /* if true, a valid encryption key has been set */
 
181
    int sg;        /* if true, the device is a /dev/sg* */
 
182
 
 
183
    BlockDriver *drv; /* NULL means no media */
 
184
    void *opaque;
 
185
 
 
186
    void *dev;                  /* attached device model, if any */
 
187
    /* TODO change to DeviceState when all users are qdevified */
 
188
    const BlockDevOps *dev_ops;
 
189
    void *dev_opaque;
 
190
 
 
191
    char filename[1024];
 
192
    char backing_file[1024]; /* if non zero, the image is a diff of
 
193
                                this file image */
 
194
    char backing_format[16]; /* if non-zero and backing_file exists */
 
195
    int is_temporary;
 
196
 
 
197
    BlockDriverState *backing_hd;
 
198
    BlockDriverState *file;
 
199
 
 
200
    /* async read/write emulation */
 
201
 
 
202
    void *sync_aiocb;
 
203
 
 
204
    /* I/O stats (display with "info blockstats"). */
 
205
    uint64_t nr_bytes[BDRV_MAX_IOTYPE];
 
206
    uint64_t nr_ops[BDRV_MAX_IOTYPE];
 
207
    uint64_t total_time_ns[BDRV_MAX_IOTYPE];
 
208
    uint64_t wr_highest_sector;
 
209
 
 
210
    /* Whether the disk can expand beyond total_sectors */
 
211
    int growable;
 
212
 
 
213
    /* the memory alignment required for the buffers handled by this driver */
 
214
    int buffer_alignment;
 
215
 
 
216
    /* do we need to tell the quest if we have a volatile write cache? */
 
217
    int enable_write_cache;
 
218
 
 
219
    /* NOTE: the following infos are only hints for real hardware
 
220
       drivers. They are not used by the block driver */
 
221
    int cyls, heads, secs, translation;
 
222
    BlockErrorAction on_read_error, on_write_error;
 
223
    bool iostatus_enabled;
 
224
    BlockDeviceIoStatus iostatus;
 
225
    char device_name[32];
 
226
    unsigned long *dirty_bitmap;
 
227
    int64_t dirty_count;
 
228
    int in_use; /* users other than guest access, eg. block migration */
 
229
    QTAILQ_ENTRY(BlockDriverState) list;
 
230
    void *private;
 
231
};
 
232
 
 
233
struct BlockDriverAIOCB {
 
234
    AIOPool *pool;
 
235
    BlockDriverState *bs;
 
236
    BlockDriverCompletionFunc *cb;
 
237
    void *opaque;
 
238
    BlockDriverAIOCB *next;
 
239
};
 
240
 
 
241
void get_tmp_filename(char *filename, int size);
 
242
 
 
243
void *qemu_aio_get(AIOPool *pool, BlockDriverState *bs,
 
244
                   BlockDriverCompletionFunc *cb, void *opaque);
 
245
void qemu_aio_release(void *p);
 
246
 
 
247
#ifdef _WIN32
 
248
int is_windows_drive(const char *filename);
 
249
#endif
 
250
 
 
251
#endif /* BLOCK_INT_H */