qemu-log: Add new log category for guest bugs
[qemu/pbrook.git] / block_int.h
blobf4bae044017773a6adc931450ea636c9b180659a
1 /*
2 * QEMU System Emulator block driver
4 * Copyright (c) 2003 Fabrice Bellard
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:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
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.
24 #ifndef BLOCK_INT_H
25 #define BLOCK_INT_H
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 #include "qerror.h"
34 #include "monitor.h"
36 #define BLOCK_FLAG_ENCRYPT 1
37 #define BLOCK_FLAG_COMPAT6 4
38 #define BLOCK_FLAG_LAZY_REFCOUNTS 8
40 #define BLOCK_IO_LIMIT_READ 0
41 #define BLOCK_IO_LIMIT_WRITE 1
42 #define BLOCK_IO_LIMIT_TOTAL 2
44 #define BLOCK_IO_SLICE_TIME 100000000
45 #define NANOSECONDS_PER_SECOND 1000000000.0
47 #define BLOCK_OPT_SIZE "size"
48 #define BLOCK_OPT_ENCRYPT "encryption"
49 #define BLOCK_OPT_COMPAT6 "compat6"
50 #define BLOCK_OPT_BACKING_FILE "backing_file"
51 #define BLOCK_OPT_BACKING_FMT "backing_fmt"
52 #define BLOCK_OPT_CLUSTER_SIZE "cluster_size"
53 #define BLOCK_OPT_TABLE_SIZE "table_size"
54 #define BLOCK_OPT_PREALLOC "preallocation"
55 #define BLOCK_OPT_SUBFMT "subformat"
56 #define BLOCK_OPT_COMPAT_LEVEL "compat"
57 #define BLOCK_OPT_LAZY_REFCOUNTS "lazy_refcounts"
59 typedef struct BdrvTrackedRequest BdrvTrackedRequest;
61 typedef struct BlockIOLimit {
62 int64_t bps[3];
63 int64_t iops[3];
64 } BlockIOLimit;
66 typedef struct BlockIOBaseValue {
67 uint64_t bytes[2];
68 uint64_t ios[2];
69 } BlockIOBaseValue;
71 struct BlockDriver {
72 const char *format_name;
73 int instance_size;
74 int (*bdrv_probe)(const uint8_t *buf, int buf_size, const char *filename);
75 int (*bdrv_probe_device)(const char *filename);
77 /* For handling image reopen for split or non-split files */
78 int (*bdrv_reopen_prepare)(BDRVReopenState *reopen_state,
79 BlockReopenQueue *queue, Error **errp);
80 void (*bdrv_reopen_commit)(BDRVReopenState *reopen_state);
81 void (*bdrv_reopen_abort)(BDRVReopenState *reopen_state);
83 int (*bdrv_open)(BlockDriverState *bs, int flags);
84 int (*bdrv_file_open)(BlockDriverState *bs, const char *filename, int flags);
85 int (*bdrv_read)(BlockDriverState *bs, int64_t sector_num,
86 uint8_t *buf, int nb_sectors);
87 int (*bdrv_write)(BlockDriverState *bs, int64_t sector_num,
88 const uint8_t *buf, int nb_sectors);
89 void (*bdrv_close)(BlockDriverState *bs);
90 void (*bdrv_rebind)(BlockDriverState *bs);
91 int (*bdrv_create)(const char *filename, QEMUOptionParameter *options);
92 int (*bdrv_set_key)(BlockDriverState *bs, const char *key);
93 int (*bdrv_make_empty)(BlockDriverState *bs);
94 /* aio */
95 BlockDriverAIOCB *(*bdrv_aio_readv)(BlockDriverState *bs,
96 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
97 BlockDriverCompletionFunc *cb, void *opaque);
98 BlockDriverAIOCB *(*bdrv_aio_writev)(BlockDriverState *bs,
99 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
100 BlockDriverCompletionFunc *cb, void *opaque);
101 BlockDriverAIOCB *(*bdrv_aio_flush)(BlockDriverState *bs,
102 BlockDriverCompletionFunc *cb, void *opaque);
103 BlockDriverAIOCB *(*bdrv_aio_discard)(BlockDriverState *bs,
104 int64_t sector_num, int nb_sectors,
105 BlockDriverCompletionFunc *cb, void *opaque);
107 int coroutine_fn (*bdrv_co_readv)(BlockDriverState *bs,
108 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov);
109 int coroutine_fn (*bdrv_co_writev)(BlockDriverState *bs,
110 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov);
112 * Efficiently zero a region of the disk image. Typically an image format
113 * would use a compact metadata representation to implement this. This
114 * function pointer may be NULL and .bdrv_co_writev() will be called
115 * instead.
117 int coroutine_fn (*bdrv_co_write_zeroes)(BlockDriverState *bs,
118 int64_t sector_num, int nb_sectors);
119 int coroutine_fn (*bdrv_co_discard)(BlockDriverState *bs,
120 int64_t sector_num, int nb_sectors);
121 int coroutine_fn (*bdrv_co_is_allocated)(BlockDriverState *bs,
122 int64_t sector_num, int nb_sectors, int *pnum);
125 * Invalidate any cached meta-data.
127 void (*bdrv_invalidate_cache)(BlockDriverState *bs);
130 * Flushes all data that was already written to the OS all the way down to
131 * the disk (for example raw-posix calls fsync()).
133 int coroutine_fn (*bdrv_co_flush_to_disk)(BlockDriverState *bs);
136 * Flushes all internal caches to the OS. The data may still sit in a
137 * writeback cache of the host OS, but it will survive a crash of the qemu
138 * process.
140 int coroutine_fn (*bdrv_co_flush_to_os)(BlockDriverState *bs);
142 const char *protocol_name;
143 int (*bdrv_truncate)(BlockDriverState *bs, int64_t offset);
144 int64_t (*bdrv_getlength)(BlockDriverState *bs);
145 int64_t (*bdrv_get_allocated_file_size)(BlockDriverState *bs);
146 int (*bdrv_write_compressed)(BlockDriverState *bs, int64_t sector_num,
147 const uint8_t *buf, int nb_sectors);
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 int (*bdrv_snapshot_load_tmp)(BlockDriverState *bs,
157 const char *snapshot_name);
158 int (*bdrv_get_info)(BlockDriverState *bs, BlockDriverInfo *bdi);
160 int (*bdrv_save_vmstate)(BlockDriverState *bs, const uint8_t *buf,
161 int64_t pos, int size);
162 int (*bdrv_load_vmstate)(BlockDriverState *bs, uint8_t *buf,
163 int64_t pos, int size);
165 int (*bdrv_change_backing_file)(BlockDriverState *bs,
166 const char *backing_file, const char *backing_fmt);
168 /* removable device specific */
169 int (*bdrv_is_inserted)(BlockDriverState *bs);
170 int (*bdrv_media_changed)(BlockDriverState *bs);
171 void (*bdrv_eject)(BlockDriverState *bs, bool eject_flag);
172 void (*bdrv_lock_medium)(BlockDriverState *bs, bool locked);
174 /* to control generic scsi devices */
175 int (*bdrv_ioctl)(BlockDriverState *bs, unsigned long int req, void *buf);
176 BlockDriverAIOCB *(*bdrv_aio_ioctl)(BlockDriverState *bs,
177 unsigned long int req, void *buf,
178 BlockDriverCompletionFunc *cb, void *opaque);
180 /* List of options for creating images, terminated by name == NULL */
181 QEMUOptionParameter *create_options;
185 * Returns 0 for completed check, -errno for internal errors.
186 * The check results are stored in result.
188 int (*bdrv_check)(BlockDriverState* bs, BdrvCheckResult *result,
189 BdrvCheckMode fix);
191 void (*bdrv_debug_event)(BlockDriverState *bs, BlkDebugEvent event);
194 * Returns 1 if newly created images are guaranteed to contain only
195 * zeros, 0 otherwise.
197 int (*bdrv_has_zero_init)(BlockDriverState *bs);
199 QLIST_ENTRY(BlockDriver) list;
203 * Note: the function bdrv_append() copies and swaps contents of
204 * BlockDriverStates, so if you add new fields to this struct, please
205 * inspect bdrv_append() to determine if the new fields need to be
206 * copied as well.
208 struct BlockDriverState {
209 int64_t total_sectors; /* if we are reading a disk image, give its
210 size in sectors */
211 int read_only; /* if true, the media is read only */
212 int open_flags; /* flags used to open the file, re-used for re-open */
213 int encrypted; /* if true, the media is encrypted */
214 int valid_key; /* if true, a valid encryption key has been set */
215 int sg; /* if true, the device is a /dev/sg* */
216 int copy_on_read; /* if true, copy read backing sectors into image
217 note this is a reference count */
219 BlockDriver *drv; /* NULL means no media */
220 void *opaque;
222 void *dev; /* attached device model, if any */
223 /* TODO change to DeviceState when all users are qdevified */
224 const BlockDevOps *dev_ops;
225 void *dev_opaque;
227 char filename[1024];
228 char backing_file[1024]; /* if non zero, the image is a diff of
229 this file image */
230 char backing_format[16]; /* if non-zero and backing_file exists */
231 int is_temporary;
233 BlockDriverState *backing_hd;
234 BlockDriverState *file;
236 /* number of in-flight copy-on-read requests */
237 unsigned int copy_on_read_in_flight;
239 /* the time for latest disk I/O */
240 int64_t slice_time;
241 int64_t slice_start;
242 int64_t slice_end;
243 BlockIOLimit io_limits;
244 BlockIOBaseValue io_base;
245 CoQueue throttled_reqs;
246 QEMUTimer *block_timer;
247 bool io_limits_enabled;
249 /* I/O stats (display with "info blockstats"). */
250 uint64_t nr_bytes[BDRV_MAX_IOTYPE];
251 uint64_t nr_ops[BDRV_MAX_IOTYPE];
252 uint64_t total_time_ns[BDRV_MAX_IOTYPE];
253 uint64_t wr_highest_sector;
255 /* Whether the disk can expand beyond total_sectors */
256 int growable;
258 /* the memory alignment required for the buffers handled by this driver */
259 int buffer_alignment;
261 /* do we need to tell the quest if we have a volatile write cache? */
262 int enable_write_cache;
264 /* NOTE: the following infos are only hints for real hardware
265 drivers. They are not used by the block driver */
266 BlockdevOnError on_read_error, on_write_error;
267 bool iostatus_enabled;
268 BlockDeviceIoStatus iostatus;
269 char device_name[32];
270 unsigned long *dirty_bitmap;
271 int64_t dirty_count;
272 int in_use; /* users other than guest access, eg. block migration */
273 QTAILQ_ENTRY(BlockDriverState) list;
275 QLIST_HEAD(, BdrvTrackedRequest) tracked_requests;
277 /* long-running background operation */
278 BlockJob *job;
282 int get_tmp_filename(char *filename, int size);
284 void bdrv_set_io_limits(BlockDriverState *bs,
285 BlockIOLimit *io_limits);
287 #ifdef _WIN32
288 int is_windows_drive(const char *filename);
289 #endif
290 void bdrv_emit_qmp_error_event(const BlockDriverState *bdrv,
291 enum MonitorEvent ev,
292 BlockErrorAction action, bool is_read);
295 * stream_start:
296 * @bs: Block device to operate on.
297 * @base: Block device that will become the new base, or %NULL to
298 * flatten the whole backing file chain onto @bs.
299 * @base_id: The file name that will be written to @bs as the new
300 * backing file if the job completes. Ignored if @base is %NULL.
301 * @speed: The maximum speed, in bytes per second, or 0 for unlimited.
302 * @on_error: The action to take upon error.
303 * @cb: Completion function for the job.
304 * @opaque: Opaque pointer value passed to @cb.
305 * @errp: Error object.
307 * Start a streaming operation on @bs. Clusters that are unallocated
308 * in @bs, but allocated in any image between @base and @bs (both
309 * exclusive) will be written to @bs. At the end of a successful
310 * streaming job, the backing file of @bs will be changed to
311 * @base_id in the written image and to @base in the live BlockDriverState.
313 void stream_start(BlockDriverState *bs, BlockDriverState *base,
314 const char *base_id, int64_t speed, BlockdevOnError on_error,
315 BlockDriverCompletionFunc *cb,
316 void *opaque, Error **errp);
319 * commit_start:
320 * @bs: Top Block device
321 * @base: Block device that will be written into, and become the new top
322 * @speed: The maximum speed, in bytes per second, or 0 for unlimited.
323 * @on_error: The action to take upon error.
324 * @cb: Completion function for the job.
325 * @opaque: Opaque pointer value passed to @cb.
326 * @errp: Error object.
329 void commit_start(BlockDriverState *bs, BlockDriverState *base,
330 BlockDriverState *top, int64_t speed,
331 BlockdevOnError on_error, BlockDriverCompletionFunc *cb,
332 void *opaque, Error **errp);
334 #endif /* BLOCK_INT_H */