blob: d135652902a48fc77686cb9970ee7e7e0549c468 [file] [log] [blame]
pbrookfaf07962007-11-11 02:51:17 +00001#ifndef BLOCK_H
2#define BLOCK_H
3
aliguoria76bab42008-09-22 19:17:18 +00004#include "qemu-aio.h"
aliguori3b69e4b2009-01-22 16:59:24 +00005#include "qemu-common.h"
Kevin Wolf0e7e1982009-05-18 16:42:10 +02006#include "qemu-option.h"
Kevin Wolfda1fa912011-07-14 17:27:13 +02007#include "qemu-coroutine.h"
Luiz Capitulinod15e5462009-12-10 17:16:06 -02008#include "qobject.h"
aliguoria76bab42008-09-22 19:17:18 +00009
pbrookfaf07962007-11-11 02:51:17 +000010/* block.c */
pbrookfaf07962007-11-11 02:51:17 +000011typedef struct BlockDriver BlockDriver;
12
pbrookfaf07962007-11-11 02:51:17 +000013typedef struct BlockDriverInfo {
14 /* in bytes, 0 if irrelevant */
15 int cluster_size;
16 /* offset at which the VM state can be saved (0 if not possible) */
17 int64_t vm_state_offset;
Dong Xu Wang64c79162012-03-15 20:13:33 +080018 bool is_dirty;
pbrookfaf07962007-11-11 02:51:17 +000019} BlockDriverInfo;
20
Dong Xu Wangf8111c22012-03-15 20:13:31 +080021typedef struct BlockFragInfo {
22 uint64_t allocated_clusters;
23 uint64_t total_clusters;
24 uint64_t fragmented_clusters;
25} BlockFragInfo;
26
pbrookfaf07962007-11-11 02:51:17 +000027typedef struct QEMUSnapshotInfo {
28 char id_str[128]; /* unique snapshot id */
29 /* the following fields are informative. They are not needed for
30 the consistency of the snapshot */
Stefan Weile7d81002011-12-10 00:19:46 +010031 char name[256]; /* user chosen name */
Kevin Wolfc2c9a462011-11-16 11:35:54 +010032 uint64_t vm_state_size; /* VM state info size */
pbrookfaf07962007-11-11 02:51:17 +000033 uint32_t date_sec; /* UTC date of the snapshot */
34 uint32_t date_nsec;
35 uint64_t vm_clock_nsec; /* VM clock relative to boot */
36} QEMUSnapshotInfo;
37
Markus Armbruster145feb12011-08-03 15:07:42 +020038/* Callbacks for block device models */
Markus Armbruster0e49de52011-08-03 15:07:41 +020039typedef struct BlockDevOps {
Markus Armbruster145feb12011-08-03 15:07:42 +020040 /*
41 * Runs when virtual media changed (monitor commands eject, change)
Markus Armbruster7d4b4ba2011-09-06 18:58:59 +020042 * Argument load is true on load and false on eject.
Markus Armbruster145feb12011-08-03 15:07:42 +020043 * Beware: doesn't run when a host device's physical media
44 * changes. Sure would be useful if it did.
Markus Armbruster2c6942f2011-09-06 18:58:51 +020045 * Device models with removable media must implement this callback.
Markus Armbruster145feb12011-08-03 15:07:42 +020046 */
Markus Armbruster7d4b4ba2011-09-06 18:58:59 +020047 void (*change_media_cb)(void *opaque, bool load);
Markus Armbruster145feb12011-08-03 15:07:42 +020048 /*
Paolo Bonzini025ccaa2011-11-07 17:50:13 +010049 * Runs when an eject request is issued from the monitor, the tray
50 * is closed, and the medium is locked.
51 * Device models that do not implement is_medium_locked will not need
52 * this callback. Device models that can lock the medium or tray might
53 * want to implement the callback and unlock the tray when "force" is
54 * true, even if they do not support eject requests.
55 */
56 void (*eject_request_cb)(void *opaque, bool force);
57 /*
Markus Armbrustere4def802011-09-06 18:58:53 +020058 * Is the virtual tray open?
59 * Device models implement this only when the device has a tray.
60 */
61 bool (*is_tray_open)(void *opaque);
62 /*
Markus Armbrusterf1076392011-09-06 18:58:46 +020063 * Is the virtual medium locked into the device?
64 * Device models implement this only when device has such a lock.
65 */
66 bool (*is_medium_locked)(void *opaque);
67 /*
Markus Armbruster145feb12011-08-03 15:07:42 +020068 * Runs when the size changed (e.g. monitor command block_resize)
69 */
70 void (*resize_cb)(void *opaque);
Markus Armbruster0e49de52011-08-03 15:07:41 +020071} BlockDevOps;
72
pbrookfaf07962007-11-11 02:51:17 +000073#define BDRV_O_RDWR 0x0002
pbrookfaf07962007-11-11 02:51:17 +000074#define BDRV_O_SNAPSHOT 0x0008 /* open the file read only and save writes in a snapshot */
aliguori9f7965c2008-10-14 14:42:54 +000075#define BDRV_O_NOCACHE 0x0020 /* do not use the host page cache */
76#define BDRV_O_CACHE_WB 0x0040 /* use write-back caching */
Christoph Hellwig5c6c3a62009-08-20 16:58:35 +020077#define BDRV_O_NATIVE_AIO 0x0080 /* use native AIO instead of the thread pool */
Kevin Wolfb783e402010-01-12 12:55:16 +010078#define BDRV_O_NO_BACKING 0x0100 /* don't open the backing file */
Alexander Graf016f5cf2010-05-26 17:51:49 +020079#define BDRV_O_NO_FLUSH 0x0200 /* disable flushing on this disk */
Stefan Hajnoczi53fec9d2011-11-28 16:08:47 +000080#define BDRV_O_COPY_ON_READ 0x0400 /* copy read backing sectors into image */
BenoƮt Canetccb1f4a2012-03-23 08:36:48 +010081#define BDRV_O_INCOMING 0x0800 /* consistency hint for incoming migration */
aliguori9f7965c2008-10-14 14:42:54 +000082
Kevin Wolfceb25e52010-08-31 15:08:03 +020083#define BDRV_O_CACHE_MASK (BDRV_O_NOCACHE | BDRV_O_CACHE_WB | BDRV_O_NO_FLUSH)
pbrookfaf07962007-11-11 02:51:17 +000084
Jan Kiszka6ea44302009-11-30 18:21:19 +010085#define BDRV_SECTOR_BITS 9
Jes Sorensenc63782c2010-05-27 15:46:55 +020086#define BDRV_SECTOR_SIZE (1ULL << BDRV_SECTOR_BITS)
Stefan Hajnoczi3abbc4d2010-05-01 07:23:32 +010087#define BDRV_SECTOR_MASK ~(BDRV_SECTOR_SIZE - 1)
Jan Kiszka6ea44302009-11-30 18:21:19 +010088
Luiz Capitulino2582bfe2010-02-03 12:41:01 -020089typedef enum {
Markus Armbrusterabd7f682010-06-02 18:55:17 +020090 BLOCK_ERR_REPORT, BLOCK_ERR_IGNORE, BLOCK_ERR_STOP_ENOSPC,
91 BLOCK_ERR_STOP_ANY
92} BlockErrorAction;
93
94typedef enum {
Luiz Capitulino2582bfe2010-02-03 12:41:01 -020095 BDRV_ACTION_REPORT, BDRV_ACTION_IGNORE, BDRV_ACTION_STOP
Luiz Capitulino329c0a42012-01-25 16:59:43 -020096} BlockQMPEventAction;
Luiz Capitulino2582bfe2010-02-03 12:41:01 -020097
Luiz Capitulino28a72822011-09-26 17:43:50 -030098void bdrv_iostatus_enable(BlockDriverState *bs);
99void bdrv_iostatus_reset(BlockDriverState *bs);
100void bdrv_iostatus_disable(BlockDriverState *bs);
101bool bdrv_iostatus_is_enabled(const BlockDriverState *bs);
102void bdrv_iostatus_set_err(BlockDriverState *bs, int error);
Luiz Capitulino329c0a42012-01-25 16:59:43 -0200103void bdrv_emit_qmp_error_event(const BlockDriverState *bdrv,
104 BlockQMPEventAction action, int is_read);
Luiz Capitulinod15e5462009-12-10 17:16:06 -0200105void bdrv_info_print(Monitor *mon, const QObject *data);
106void bdrv_info(Monitor *mon, QObject **ret_data);
Luiz Capitulino218a5362009-12-10 17:16:07 -0200107void bdrv_stats_print(Monitor *mon, const QObject *data);
108void bdrv_info_stats(Monitor *mon, QObject **ret_data);
pbrookfaf07962007-11-11 02:51:17 +0000109
Zhi Yong Wu0563e192011-11-03 16:57:25 +0800110/* disk I/O throttling */
111void bdrv_io_limits_enable(BlockDriverState *bs);
Zhi Yong Wu98f90db2011-11-08 13:00:14 +0800112void bdrv_io_limits_disable(BlockDriverState *bs);
Zhi Yong Wu0563e192011-11-03 16:57:25 +0800113bool bdrv_io_limits_enabled(BlockDriverState *bs);
114
pbrookfaf07962007-11-11 02:51:17 +0000115void bdrv_init(void);
Markus Armbrustereb852012009-10-27 18:41:44 +0100116void bdrv_init_with_whitelist(void);
MORITA Kazutakab50cbab2010-05-26 11:35:36 +0900117BlockDriver *bdrv_find_protocol(const char *filename);
pbrookfaf07962007-11-11 02:51:17 +0000118BlockDriver *bdrv_find_format(const char *format_name);
Markus Armbrustereb852012009-10-27 18:41:44 +0100119BlockDriver *bdrv_find_whitelisted_format(const char *format_name);
Kevin Wolf0e7e1982009-05-18 16:42:10 +0200120int bdrv_create(BlockDriver *drv, const char* filename,
121 QEMUOptionParameter *options);
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200122int bdrv_create_file(const char* filename, QEMUOptionParameter *options);
pbrookfaf07962007-11-11 02:51:17 +0000123BlockDriverState *bdrv_new(const char *device_name);
Ryan Harperd22b2f42011-03-29 20:51:47 -0500124void bdrv_make_anon(BlockDriverState *bs);
Jeff Cody8802d1f2012-02-28 15:54:06 -0500125void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top);
pbrookfaf07962007-11-11 02:51:17 +0000126void bdrv_delete(BlockDriverState *bs);
Stefan Hajnoczic3993cd2011-08-04 12:26:51 +0100127int bdrv_parse_cache_flags(const char *mode, int *flags);
pbrookfaf07962007-11-11 02:51:17 +0000128int bdrv_file_open(BlockDriverState **pbs, const char *filename, int flags);
Kevin Wolfd6e90982010-03-31 14:40:27 +0200129int bdrv_open(BlockDriverState *bs, const char *filename, int flags,
130 BlockDriver *drv);
pbrookfaf07962007-11-11 02:51:17 +0000131void bdrv_close(BlockDriverState *bs);
Markus Armbrusterfa879d62011-08-03 15:07:40 +0200132int bdrv_attach_dev(BlockDriverState *bs, void *dev);
133void bdrv_attach_dev_nofail(BlockDriverState *bs, void *dev);
134void bdrv_detach_dev(BlockDriverState *bs, void *dev);
135void *bdrv_get_attached_dev(BlockDriverState *bs);
Markus Armbruster0e49de52011-08-03 15:07:41 +0200136void bdrv_set_dev_ops(BlockDriverState *bs, const BlockDevOps *ops,
137 void *opaque);
Paolo Bonzini025ccaa2011-11-07 17:50:13 +0100138void bdrv_dev_eject_request(BlockDriverState *bs, bool force);
Markus Armbruster2c6942f2011-09-06 18:58:51 +0200139bool bdrv_dev_has_removable_media(BlockDriverState *bs);
Markus Armbrustere4def802011-09-06 18:58:53 +0200140bool bdrv_dev_is_tray_open(BlockDriverState *bs);
Markus Armbrusterf1076392011-09-06 18:58:46 +0200141bool bdrv_dev_is_medium_locked(BlockDriverState *bs);
pbrookfaf07962007-11-11 02:51:17 +0000142int bdrv_read(BlockDriverState *bs, int64_t sector_num,
143 uint8_t *buf, int nb_sectors);
144int bdrv_write(BlockDriverState *bs, int64_t sector_num,
145 const uint8_t *buf, int nb_sectors);
146int bdrv_pread(BlockDriverState *bs, int64_t offset,
147 void *buf, int count);
148int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
149 const void *buf, int count);
Kevin Wolff08145f2010-06-16 16:38:15 +0200150int bdrv_pwrite_sync(BlockDriverState *bs, int64_t offset,
151 const void *buf, int count);
Kevin Wolfda1fa912011-07-14 17:27:13 +0200152int coroutine_fn bdrv_co_readv(BlockDriverState *bs, int64_t sector_num,
153 int nb_sectors, QEMUIOVector *qiov);
Stefan Hajnoczi470c0502012-01-18 14:40:42 +0000154int coroutine_fn bdrv_co_copy_on_readv(BlockDriverState *bs,
155 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov);
Kevin Wolfda1fa912011-07-14 17:27:13 +0200156int coroutine_fn bdrv_co_writev(BlockDriverState *bs, int64_t sector_num,
157 int nb_sectors, QEMUIOVector *qiov);
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +0000158/*
159 * Efficiently zero a region of the disk image. Note that this is a regular
160 * I/O request like read or write and should have a reasonable size. This
161 * function is not suitable for zeroing the entire image in a single request
162 * because it may allocate memory for the entire region.
163 */
164int coroutine_fn bdrv_co_write_zeroes(BlockDriverState *bs, int64_t sector_num,
165 int nb_sectors);
Stefan Hajnoczi060f51c2011-11-14 12:44:26 +0000166int coroutine_fn bdrv_co_is_allocated(BlockDriverState *bs, int64_t sector_num,
167 int nb_sectors, int *pnum);
Paolo Bonzini188a7bb2012-05-08 16:52:01 +0200168int coroutine_fn bdrv_co_is_allocated_above(BlockDriverState *top,
169 BlockDriverState *base,
170 int64_t sector_num,
171 int nb_sectors, int *pnum);
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +0000172BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
173 const char *backing_file);
pbrookfaf07962007-11-11 02:51:17 +0000174int bdrv_truncate(BlockDriverState *bs, int64_t offset);
175int64_t bdrv_getlength(BlockDriverState *bs);
Fam Zheng4a1d5e12011-07-12 19:56:39 +0800176int64_t bdrv_get_allocated_file_size(BlockDriverState *bs);
ths96b8f132007-12-17 01:35:20 +0000177void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr);
aliguorif3d54fc2008-11-25 21:50:24 +0000178void bdrv_guess_geometry(BlockDriverState *bs, int *pcyls, int *pheads, int *psecs);
pbrookfaf07962007-11-11 02:51:17 +0000179int bdrv_commit(BlockDriverState *bs);
Stefan Hajnoczie8877492012-03-05 18:10:11 +0000180int bdrv_commit_all(void);
Kevin Wolf756e6732010-01-12 12:55:17 +0100181int bdrv_change_backing_file(BlockDriverState *bs,
182 const char *backing_file, const char *backing_fmt);
Anthony Liguori5efa9d52009-05-09 17:03:42 -0500183void bdrv_register(BlockDriver *bdrv);
184
Kevin Wolfe076f332010-06-29 11:43:13 +0200185
186typedef struct BdrvCheckResult {
187 int corruptions;
188 int leaks;
189 int check_errors;
Kevin Wolfccf34712012-05-11 18:16:54 +0200190 int corruptions_fixed;
191 int leaks_fixed;
Dong Xu Wangf8111c22012-03-15 20:13:31 +0800192 BlockFragInfo bfi;
Kevin Wolfe076f332010-06-29 11:43:13 +0200193} BdrvCheckResult;
194
Kevin Wolf4534ff52012-05-11 16:07:02 +0200195typedef enum {
196 BDRV_FIX_LEAKS = 1,
197 BDRV_FIX_ERRORS = 2,
198} BdrvCheckMode;
199
200int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix);
Kevin Wolfe076f332010-06-29 11:43:13 +0200201
pbrookfaf07962007-11-11 02:51:17 +0000202/* async block I/O */
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +0200203typedef void BlockDriverDirtyHandler(BlockDriverState *bs, int64_t sector,
Devin Nakamura39aa9a12011-06-09 01:06:43 -0400204 int sector_num);
aliguori3b69e4b2009-01-22 16:59:24 +0000205BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
206 QEMUIOVector *iov, int nb_sectors,
207 BlockDriverCompletionFunc *cb, void *opaque);
208BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
209 QEMUIOVector *iov, int nb_sectors,
210 BlockDriverCompletionFunc *cb, void *opaque);
Christoph Hellwigb2e12bc2009-09-04 19:01:49 +0200211BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs,
Devin Nakamura39aa9a12011-06-09 01:06:43 -0400212 BlockDriverCompletionFunc *cb, void *opaque);
Paolo Bonzini4265d622011-10-17 12:32:14 +0200213BlockDriverAIOCB *bdrv_aio_discard(BlockDriverState *bs,
214 int64_t sector_num, int nb_sectors,
215 BlockDriverCompletionFunc *cb, void *opaque);
pbrookfaf07962007-11-11 02:51:17 +0000216void bdrv_aio_cancel(BlockDriverAIOCB *acb);
217
Kevin Wolf40b4f532009-09-09 17:53:37 +0200218typedef struct BlockRequest {
219 /* Fields to be filled by multiwrite caller */
220 int64_t sector;
221 int nb_sectors;
222 QEMUIOVector *qiov;
223 BlockDriverCompletionFunc *cb;
224 void *opaque;
225
226 /* Filled by multiwrite implementation */
227 int error;
228} BlockRequest;
229
230int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs,
231 int num_reqs);
232
aliguori7d780662009-03-12 19:57:08 +0000233/* sg packet commands */
aliguori221f7152009-03-28 17:28:41 +0000234int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf);
235BlockDriverAIOCB *bdrv_aio_ioctl(BlockDriverState *bs,
236 unsigned long int req, void *buf,
237 BlockDriverCompletionFunc *cb, void *opaque);
aliguori7d780662009-03-12 19:57:08 +0000238
Anthony Liguori0f154232011-11-14 15:09:45 -0600239/* Invalidate any cached metadata used by image formats */
240void bdrv_invalidate_cache(BlockDriverState *bs);
241void bdrv_invalidate_cache_all(void);
242
BenoƮt Canet07789262012-03-23 08:36:49 +0100243void bdrv_clear_incoming_migration_all(void);
244
pbrookfaf07962007-11-11 02:51:17 +0000245/* Ensure contents are flushed to disk. */
Kevin Wolf205ef792010-10-21 16:43:43 +0200246int bdrv_flush(BlockDriverState *bs);
Paolo Bonzini07f07612011-10-17 12:32:12 +0200247int coroutine_fn bdrv_co_flush(BlockDriverState *bs);
aliguoric6ca28d2008-10-06 13:55:43 +0000248void bdrv_flush_all(void);
MORITA Kazutaka2bc93fe2010-05-28 11:44:57 +0900249void bdrv_close_all(void);
Stefan Hajnoczi922453b2011-11-30 12:23:43 +0000250void bdrv_drain_all(void);
aliguoric6ca28d2008-10-06 13:55:43 +0000251
Christoph Hellwigbb8bf762010-12-16 19:36:31 +0100252int bdrv_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors);
Paolo Bonzini4265d622011-10-17 12:32:14 +0200253int bdrv_co_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors);
Kevin Wolff2feebb2010-04-14 17:30:35 +0200254int bdrv_has_zero_init(BlockDriverState *bs);
thsf58c7b32008-06-05 21:53:49 +0000255int bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
Devin Nakamura39aa9a12011-06-09 01:06:43 -0400256 int *pnum);
pbrookfaf07962007-11-11 02:51:17 +0000257
pbrookfaf07962007-11-11 02:51:17 +0000258#define BIOS_ATA_TRANSLATION_AUTO 0
259#define BIOS_ATA_TRANSLATION_NONE 1
260#define BIOS_ATA_TRANSLATION_LBA 2
261#define BIOS_ATA_TRANSLATION_LARGE 3
262#define BIOS_ATA_TRANSLATION_RECHS 4
263
264void bdrv_set_geometry_hint(BlockDriverState *bs,
265 int cyls, int heads, int secs);
pbrookfaf07962007-11-11 02:51:17 +0000266void bdrv_set_translation_hint(BlockDriverState *bs, int translation);
267void bdrv_get_geometry_hint(BlockDriverState *bs,
268 int *pcyls, int *pheads, int *psecs);
Blue Swirl5bbdbb42011-02-12 20:43:32 +0000269typedef enum FDriveType {
270 FDRIVE_DRV_144 = 0x00, /* 1.44 MB 3"5 drive */
271 FDRIVE_DRV_288 = 0x01, /* 2.88 MB 3"5 drive */
272 FDRIVE_DRV_120 = 0x02, /* 1.2 MB 5"25 drive */
273 FDRIVE_DRV_NONE = 0x03, /* No drive connected */
274} FDriveType;
275
HervƩ Poussineauf8d3d122012-02-06 22:29:07 +0100276typedef enum FDriveRate {
277 FDRIVE_RATE_500K = 0x00, /* 500 Kbps */
278 FDRIVE_RATE_300K = 0x01, /* 300 Kbps */
279 FDRIVE_RATE_250K = 0x02, /* 250 Kbps */
280 FDRIVE_RATE_1M = 0x03, /* 1 Mbps */
281} FDriveRate;
282
Blue Swirl5bbdbb42011-02-12 20:43:32 +0000283void bdrv_get_floppy_geometry_hint(BlockDriverState *bs, int *nb_heads,
284 int *max_track, int *last_sect,
HervƩ Poussineauf8d3d122012-02-06 22:29:07 +0100285 FDriveType drive_in, FDriveType *drive,
286 FDriveRate *rate);
pbrookfaf07962007-11-11 02:51:17 +0000287int bdrv_get_translation_hint(BlockDriverState *bs);
Markus Armbrusterabd7f682010-06-02 18:55:17 +0200288void bdrv_set_on_error(BlockDriverState *bs, BlockErrorAction on_read_error,
289 BlockErrorAction on_write_error);
290BlockErrorAction bdrv_get_on_error(BlockDriverState *bs, int is_read);
pbrookfaf07962007-11-11 02:51:17 +0000291int bdrv_is_read_only(BlockDriverState *bs);
ths985a03b2007-12-24 16:10:43 +0000292int bdrv_is_sg(BlockDriverState *bs);
Christoph Hellwige900a7b2009-09-04 19:01:15 +0200293int bdrv_enable_write_cache(BlockDriverState *bs);
Paolo Bonzini425b0142012-06-06 00:04:52 +0200294void bdrv_set_enable_write_cache(BlockDriverState *bs, bool wce);
pbrookfaf07962007-11-11 02:51:17 +0000295int bdrv_is_inserted(BlockDriverState *bs);
296int bdrv_media_changed(BlockDriverState *bs);
Markus Armbruster025e8492011-09-06 18:58:47 +0200297void bdrv_lock_medium(BlockDriverState *bs, bool locked);
Luiz Capitulinof36f3942012-02-03 16:24:53 -0200298void bdrv_eject(BlockDriverState *bs, bool eject_flag);
Markus Armbrusterf8d6bba2012-06-13 10:11:48 +0200299const char *bdrv_get_format_name(BlockDriverState *bs);
pbrookfaf07962007-11-11 02:51:17 +0000300BlockDriverState *bdrv_find(const char *name);
Markus Armbruster2f399b02010-06-02 18:55:20 +0200301BlockDriverState *bdrv_next(BlockDriverState *bs);
aliguori51de9762009-03-05 23:00:43 +0000302void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs),
303 void *opaque);
pbrookfaf07962007-11-11 02:51:17 +0000304int bdrv_is_encrypted(BlockDriverState *bs);
aliguoric0f4ce72009-03-05 23:01:01 +0000305int bdrv_key_required(BlockDriverState *bs);
pbrookfaf07962007-11-11 02:51:17 +0000306int bdrv_set_key(BlockDriverState *bs, const char *key);
aliguoric0f4ce72009-03-05 23:01:01 +0000307int bdrv_query_missing_keys(void);
pbrookfaf07962007-11-11 02:51:17 +0000308void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
309 void *opaque);
310const char *bdrv_get_device_name(BlockDriverState *bs);
Markus Armbrusterc8433282012-06-05 16:49:24 +0200311int bdrv_get_flags(BlockDriverState *bs);
pbrookfaf07962007-11-11 02:51:17 +0000312int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
313 const uint8_t *buf, int nb_sectors);
314int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi);
315
aliguori045df332009-03-05 23:00:48 +0000316const char *bdrv_get_encrypted_filename(BlockDriverState *bs);
pbrookfaf07962007-11-11 02:51:17 +0000317void bdrv_get_backing_filename(BlockDriverState *bs,
318 char *filename, int filename_size);
Paolo Bonzinidc5a1372012-05-08 16:51:50 +0200319void bdrv_get_full_backing_filename(BlockDriverState *bs,
320 char *dest, size_t sz);
Miguel Di Ciurcio Filhofeeee5a2010-06-08 10:40:55 -0300321int bdrv_can_snapshot(BlockDriverState *bs);
Blue Swirl199630b2010-07-25 20:49:34 +0000322int bdrv_is_snapshot(BlockDriverState *bs);
Markus Armbrusterf9092b12010-06-25 10:33:39 +0200323BlockDriverState *bdrv_snapshots(void);
pbrookfaf07962007-11-11 02:51:17 +0000324int bdrv_snapshot_create(BlockDriverState *bs,
325 QEMUSnapshotInfo *sn_info);
326int bdrv_snapshot_goto(BlockDriverState *bs,
327 const char *snapshot_id);
328int bdrv_snapshot_delete(BlockDriverState *bs, const char *snapshot_id);
329int bdrv_snapshot_list(BlockDriverState *bs,
330 QEMUSnapshotInfo **psn_info);
edison51ef6722010-09-21 19:58:41 -0700331int bdrv_snapshot_load_tmp(BlockDriverState *bs,
332 const char *snapshot_name);
pbrookfaf07962007-11-11 02:51:17 +0000333char *bdrv_snapshot_dump(char *buf, int buf_size, QEMUSnapshotInfo *sn);
pbrookfaf07962007-11-11 02:51:17 +0000334
335char *get_human_readable_size(char *buf, int buf_size, int64_t size);
336int path_is_absolute(const char *path);
337void path_combine(char *dest, int dest_size,
338 const char *base_path,
339 const char *filename);
340
Christoph Hellwig45566e92009-07-10 23:11:57 +0200341int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
342 int64_t pos, int size);
aliguori178e08a2009-04-05 19:10:55 +0000343
Christoph Hellwig45566e92009-07-10 23:11:57 +0200344int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,
345 int64_t pos, int size);
aliguori178e08a2009-04-05 19:10:55 +0000346
Jes Sorensenf88e1a42010-12-16 13:52:15 +0100347int bdrv_img_create(const char *filename, const char *fmt,
348 const char *base_filename, const char *base_fmt,
349 char *options, uint64_t img_size, int flags);
350
Markus Armbruster7b6f9302011-09-06 18:58:56 +0200351void bdrv_set_buffer_alignment(BlockDriverState *bs, int align);
Markus Armbrusterba5b7ad2011-08-03 15:08:19 +0200352void *qemu_blockalign(BlockDriverState *bs, size_t size);
353
Jan Kiszka23bd90d2009-11-30 18:21:22 +0100354#define BDRV_SECTORS_PER_DIRTY_CHUNK 2048
Jan Kiszka6ea44302009-11-30 18:21:19 +0100355
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +0200356void bdrv_set_dirty_tracking(BlockDriverState *bs, int enable);
357int bdrv_get_dirty(BlockDriverState *bs, int64_t sector);
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100358void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector,
359 int nr_sectors);
Liran Schouraaa0eb72010-01-26 10:31:48 +0200360int64_t bdrv_get_dirty_count(BlockDriverState *bs);
Kevin Wolf8b9b0cc2010-03-15 17:27:00 +0100361
Stefan Hajnoczi53fec9d2011-11-28 16:08:47 +0000362void bdrv_enable_copy_on_read(BlockDriverState *bs);
363void bdrv_disable_copy_on_read(BlockDriverState *bs);
364
Marcelo Tosattidb593f22011-01-26 12:12:34 -0200365void bdrv_set_in_use(BlockDriverState *bs, int in_use);
366int bdrv_in_use(BlockDriverState *bs);
Kevin Wolf8b9b0cc2010-03-15 17:27:00 +0100367
Christoph Hellwiga597e792011-08-25 08:26:01 +0200368enum BlockAcctType {
369 BDRV_ACCT_READ,
370 BDRV_ACCT_WRITE,
371 BDRV_ACCT_FLUSH,
372 BDRV_MAX_IOTYPE,
373};
374
375typedef struct BlockAcctCookie {
376 int64_t bytes;
Christoph Hellwigc488c7f2011-08-25 08:26:10 +0200377 int64_t start_time_ns;
Christoph Hellwiga597e792011-08-25 08:26:01 +0200378 enum BlockAcctType type;
379} BlockAcctCookie;
380
381void bdrv_acct_start(BlockDriverState *bs, BlockAcctCookie *cookie,
382 int64_t bytes, enum BlockAcctType type);
383void bdrv_acct_done(BlockDriverState *bs, BlockAcctCookie *cookie);
384
Kevin Wolf8b9b0cc2010-03-15 17:27:00 +0100385typedef enum {
Kevin Wolf82522782010-03-15 17:38:05 +0100386 BLKDBG_L1_UPDATE,
387
388 BLKDBG_L1_GROW_ALLOC_TABLE,
389 BLKDBG_L1_GROW_WRITE_TABLE,
390 BLKDBG_L1_GROW_ACTIVATE_TABLE,
391
392 BLKDBG_L2_LOAD,
393 BLKDBG_L2_UPDATE,
394 BLKDBG_L2_UPDATE_COMPRESSED,
395 BLKDBG_L2_ALLOC_COW_READ,
396 BLKDBG_L2_ALLOC_WRITE,
397
398 BLKDBG_READ,
399 BLKDBG_READ_AIO,
400 BLKDBG_READ_BACKING,
401 BLKDBG_READ_BACKING_AIO,
402 BLKDBG_READ_COMPRESSED,
403
404 BLKDBG_WRITE_AIO,
405 BLKDBG_WRITE_COMPRESSED,
406
407 BLKDBG_VMSTATE_LOAD,
408 BLKDBG_VMSTATE_SAVE,
409
410 BLKDBG_COW_READ,
411 BLKDBG_COW_WRITE,
412
413 BLKDBG_REFTABLE_LOAD,
414 BLKDBG_REFTABLE_GROW,
415
416 BLKDBG_REFBLOCK_LOAD,
417 BLKDBG_REFBLOCK_UPDATE,
418 BLKDBG_REFBLOCK_UPDATE_PART,
419 BLKDBG_REFBLOCK_ALLOC,
420 BLKDBG_REFBLOCK_ALLOC_HOOKUP,
421 BLKDBG_REFBLOCK_ALLOC_WRITE,
422 BLKDBG_REFBLOCK_ALLOC_WRITE_BLOCKS,
423 BLKDBG_REFBLOCK_ALLOC_WRITE_TABLE,
424 BLKDBG_REFBLOCK_ALLOC_SWITCH_TABLE,
425
426 BLKDBG_CLUSTER_ALLOC,
427 BLKDBG_CLUSTER_ALLOC_BYTES,
428 BLKDBG_CLUSTER_FREE,
429
Kevin Wolf8b9b0cc2010-03-15 17:27:00 +0100430 BLKDBG_EVENT_MAX,
431} BlkDebugEvent;
432
433#define BLKDBG_EVENT(bs, evt) bdrv_debug_event(bs, evt)
434void bdrv_debug_event(BlockDriverState *bs, BlkDebugEvent event);
435
Markus Armbrusterd1a07392011-09-06 18:58:54 +0200436
437/* Convenience for block device models */
438
439typedef struct BlockConf {
440 BlockDriverState *bs;
441 uint16_t physical_block_size;
442 uint16_t logical_block_size;
443 uint16_t min_io_size;
444 uint32_t opt_io_size;
445 int32_t bootindex;
446 uint32_t discard_granularity;
447} BlockConf;
448
449static inline unsigned int get_physical_block_exp(BlockConf *conf)
450{
451 unsigned int exp = 0, size;
452
453 for (size = conf->physical_block_size;
454 size > conf->logical_block_size;
455 size >>= 1) {
456 exp++;
457 }
458
459 return exp;
460}
461
462#define DEFINE_BLOCK_PROPERTIES(_state, _conf) \
463 DEFINE_PROP_DRIVE("drive", _state, _conf.bs), \
Stefan Hajnoczi1fc86bf2012-03-14 15:57:06 +0000464 DEFINE_PROP_BLOCKSIZE("logical_block_size", _state, \
465 _conf.logical_block_size, 512), \
466 DEFINE_PROP_BLOCKSIZE("physical_block_size", _state, \
467 _conf.physical_block_size, 512), \
Markus Armbrusterd1a07392011-09-06 18:58:54 +0200468 DEFINE_PROP_UINT16("min_io_size", _state, _conf.min_io_size, 0), \
469 DEFINE_PROP_UINT32("opt_io_size", _state, _conf.opt_io_size, 0), \
470 DEFINE_PROP_INT32("bootindex", _state, _conf.bootindex, -1), \
471 DEFINE_PROP_UINT32("discard_granularity", _state, \
472 _conf.discard_granularity, 0)
473
pbrookfaf07962007-11-11 02:51:17 +0000474#endif
Christoph Hellwiga597e792011-08-25 08:26:01 +0200475