blob: 742fce5f7f8a35339fd94d7fa31356b6c101efb3 [file] [log] [blame]
pbrookfaf07962007-11-11 02:51:17 +00001#ifndef BLOCK_H
2#define BLOCK_H
3
Paolo Bonzini737e1502012-12-17 18:19:44 +01004#include "block/aio.h"
aliguori3b69e4b2009-01-22 16:59:24 +00005#include "qemu-common.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +01006#include "qemu/option.h"
Paolo Bonzini737e1502012-12-17 18:19:44 +01007#include "block/coroutine.h"
Paolo Bonzini7b1b5d12012-12-17 18:19:43 +01008#include "qapi/qmp/qobject.h"
Paolo Bonzini2f0c9fe2012-09-28 17:22:47 +02009#include "qapi-types.h"
aliguoria76bab42008-09-22 19:17:18 +000010
pbrookfaf07962007-11-11 02:51:17 +000011/* block.c */
pbrookfaf07962007-11-11 02:51:17 +000012typedef struct BlockDriver BlockDriver;
Paolo Bonzini2f0c9fe2012-09-28 17:22:47 +020013typedef struct BlockJob BlockJob;
pbrookfaf07962007-11-11 02:51:17 +000014
pbrookfaf07962007-11-11 02:51:17 +000015typedef struct BlockDriverInfo {
16 /* in bytes, 0 if irrelevant */
17 int cluster_size;
18 /* offset at which the VM state can be saved (0 if not possible) */
19 int64_t vm_state_offset;
Dong Xu Wang64c79162012-03-15 20:13:33 +080020 bool is_dirty;
pbrookfaf07962007-11-11 02:51:17 +000021} BlockDriverInfo;
22
Dong Xu Wangf8111c22012-03-15 20:13:31 +080023typedef struct BlockFragInfo {
24 uint64_t allocated_clusters;
25 uint64_t total_clusters;
26 uint64_t fragmented_clusters;
Stefan Hajnoczie6439d72013-02-07 17:15:04 +010027 uint64_t compressed_clusters;
Dong Xu Wangf8111c22012-03-15 20:13:31 +080028} BlockFragInfo;
29
Markus Armbruster145feb12011-08-03 15:07:42 +020030/* Callbacks for block device models */
Markus Armbruster0e49de52011-08-03 15:07:41 +020031typedef struct BlockDevOps {
Markus Armbruster145feb12011-08-03 15:07:42 +020032 /*
33 * Runs when virtual media changed (monitor commands eject, change)
Markus Armbruster7d4b4ba2011-09-06 18:58:59 +020034 * Argument load is true on load and false on eject.
Markus Armbruster145feb12011-08-03 15:07:42 +020035 * Beware: doesn't run when a host device's physical media
36 * changes. Sure would be useful if it did.
Markus Armbruster2c6942f2011-09-06 18:58:51 +020037 * Device models with removable media must implement this callback.
Markus Armbruster145feb12011-08-03 15:07:42 +020038 */
Markus Armbruster7d4b4ba2011-09-06 18:58:59 +020039 void (*change_media_cb)(void *opaque, bool load);
Markus Armbruster145feb12011-08-03 15:07:42 +020040 /*
Paolo Bonzini025ccaa2011-11-07 17:50:13 +010041 * Runs when an eject request is issued from the monitor, the tray
42 * is closed, and the medium is locked.
43 * Device models that do not implement is_medium_locked will not need
44 * this callback. Device models that can lock the medium or tray might
45 * want to implement the callback and unlock the tray when "force" is
46 * true, even if they do not support eject requests.
47 */
48 void (*eject_request_cb)(void *opaque, bool force);
49 /*
Markus Armbrustere4def802011-09-06 18:58:53 +020050 * Is the virtual tray open?
51 * Device models implement this only when the device has a tray.
52 */
53 bool (*is_tray_open)(void *opaque);
54 /*
Markus Armbrusterf1076392011-09-06 18:58:46 +020055 * Is the virtual medium locked into the device?
56 * Device models implement this only when device has such a lock.
57 */
58 bool (*is_medium_locked)(void *opaque);
59 /*
Markus Armbruster145feb12011-08-03 15:07:42 +020060 * Runs when the size changed (e.g. monitor command block_resize)
61 */
62 void (*resize_cb)(void *opaque);
Markus Armbruster0e49de52011-08-03 15:07:41 +020063} BlockDevOps;
64
pbrookfaf07962007-11-11 02:51:17 +000065#define BDRV_O_RDWR 0x0002
pbrookfaf07962007-11-11 02:51:17 +000066#define BDRV_O_SNAPSHOT 0x0008 /* open the file read only and save writes in a snapshot */
aliguori9f7965c2008-10-14 14:42:54 +000067#define BDRV_O_NOCACHE 0x0020 /* do not use the host page cache */
68#define BDRV_O_CACHE_WB 0x0040 /* use write-back caching */
Christoph Hellwig5c6c3a62009-08-20 16:58:35 +020069#define BDRV_O_NATIVE_AIO 0x0080 /* use native AIO instead of the thread pool */
Kevin Wolfb783e402010-01-12 12:55:16 +010070#define BDRV_O_NO_BACKING 0x0100 /* don't open the backing file */
Alexander Graf016f5cf2010-05-26 17:51:49 +020071#define BDRV_O_NO_FLUSH 0x0200 /* disable flushing on this disk */
Stefan Hajnoczi53fec9d2011-11-28 16:08:47 +000072#define BDRV_O_COPY_ON_READ 0x0400 /* copy read backing sectors into image */
BenoƮt Canetccb1f4a2012-03-23 08:36:48 +010073#define BDRV_O_INCOMING 0x0800 /* consistency hint for incoming migration */
Stefan Hajnoczi058f8f12012-08-09 13:05:56 +010074#define BDRV_O_CHECK 0x1000 /* open solely for consistency check */
Jeff Codybe028ad2012-09-20 15:13:17 -040075#define BDRV_O_ALLOW_RDWR 0x2000 /* allow reopen to change from r/o to r/w */
Paolo Bonzini9e8f1832013-02-08 14:06:11 +010076#define BDRV_O_UNMAP 0x4000 /* execute guest UNMAP/TRIM operations */
aliguori9f7965c2008-10-14 14:42:54 +000077
Kevin Wolfceb25e52010-08-31 15:08:03 +020078#define BDRV_O_CACHE_MASK (BDRV_O_NOCACHE | BDRV_O_CACHE_WB | BDRV_O_NO_FLUSH)
pbrookfaf07962007-11-11 02:51:17 +000079
Jan Kiszka6ea44302009-11-30 18:21:19 +010080#define BDRV_SECTOR_BITS 9
Jes Sorensenc63782c2010-05-27 15:46:55 +020081#define BDRV_SECTOR_SIZE (1ULL << BDRV_SECTOR_BITS)
Stefan Hajnoczi3abbc4d2010-05-01 07:23:32 +010082#define BDRV_SECTOR_MASK ~(BDRV_SECTOR_SIZE - 1)
Jan Kiszka6ea44302009-11-30 18:21:19 +010083
Luiz Capitulino2582bfe2010-02-03 12:41:01 -020084typedef enum {
85 BDRV_ACTION_REPORT, BDRV_ACTION_IGNORE, BDRV_ACTION_STOP
Paolo Bonziniff06f5f2012-09-28 17:22:54 +020086} BlockErrorAction;
Luiz Capitulino2582bfe2010-02-03 12:41:01 -020087
Jeff Codye971aa12012-09-20 15:13:19 -040088typedef QSIMPLEQ_HEAD(BlockReopenQueue, BlockReopenQueueEntry) BlockReopenQueue;
89
90typedef struct BDRVReopenState {
91 BlockDriverState *bs;
92 int flags;
93 void *opaque;
94} BDRVReopenState;
95
96
Luiz Capitulino28a72822011-09-26 17:43:50 -030097void bdrv_iostatus_enable(BlockDriverState *bs);
98void bdrv_iostatus_reset(BlockDriverState *bs);
99void bdrv_iostatus_disable(BlockDriverState *bs);
100bool bdrv_iostatus_is_enabled(const BlockDriverState *bs);
101void bdrv_iostatus_set_err(BlockDriverState *bs, int error);
Luiz Capitulinod15e5462009-12-10 17:16:06 -0200102void bdrv_info_print(Monitor *mon, const QObject *data);
103void bdrv_info(Monitor *mon, QObject **ret_data);
Luiz Capitulino218a5362009-12-10 17:16:07 -0200104void bdrv_stats_print(Monitor *mon, const QObject *data);
105void bdrv_info_stats(Monitor *mon, QObject **ret_data);
pbrookfaf07962007-11-11 02:51:17 +0000106
Zhi Yong Wu0563e192011-11-03 16:57:25 +0800107/* disk I/O throttling */
108void bdrv_io_limits_enable(BlockDriverState *bs);
Zhi Yong Wu98f90db2011-11-08 13:00:14 +0800109void bdrv_io_limits_disable(BlockDriverState *bs);
Zhi Yong Wu0563e192011-11-03 16:57:25 +0800110bool bdrv_io_limits_enabled(BlockDriverState *bs);
111
pbrookfaf07962007-11-11 02:51:17 +0000112void bdrv_init(void);
Markus Armbrustereb852012009-10-27 18:41:44 +0100113void bdrv_init_with_whitelist(void);
Kevin Wolf98289622013-07-10 15:47:39 +0200114BlockDriver *bdrv_find_protocol(const char *filename,
115 bool allow_protocol_prefix);
pbrookfaf07962007-11-11 02:51:17 +0000116BlockDriver *bdrv_find_format(const char *format_name);
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800117BlockDriver *bdrv_find_whitelisted_format(const char *format_name,
118 bool readonly);
Kevin Wolf0e7e1982009-05-18 16:42:10 +0200119int bdrv_create(BlockDriver *drv, const char* filename,
120 QEMUOptionParameter *options);
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200121int bdrv_create_file(const char* filename, QEMUOptionParameter *options);
pbrookfaf07962007-11-11 02:51:17 +0000122BlockDriverState *bdrv_new(const char *device_name);
Ryan Harperd22b2f42011-03-29 20:51:47 -0500123void bdrv_make_anon(BlockDriverState *bs);
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +0200124void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old);
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);
Paolo Bonzini9e8f1832013-02-08 14:06:11 +0100128int bdrv_parse_discard_flags(const char *mode, int *flags);
Kevin Wolf787e4a82013-03-06 11:52:48 +0100129int bdrv_file_open(BlockDriverState **pbs, const char *filename,
130 QDict *options, int flags);
Kevin Wolf31ca6d02013-03-28 15:29:24 +0100131int bdrv_open_backing_file(BlockDriverState *bs, QDict *options);
Kevin Wolfde9c0ce2013-03-15 10:35:02 +0100132int bdrv_open(BlockDriverState *bs, const char *filename, QDict *options,
133 int flags, BlockDriver *drv);
Jeff Codye971aa12012-09-20 15:13:19 -0400134BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
135 BlockDriverState *bs, int flags);
136int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp);
137int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp);
138int bdrv_reopen_prepare(BDRVReopenState *reopen_state,
139 BlockReopenQueue *queue, Error **errp);
140void bdrv_reopen_commit(BDRVReopenState *reopen_state);
141void bdrv_reopen_abort(BDRVReopenState *reopen_state);
pbrookfaf07962007-11-11 02:51:17 +0000142void bdrv_close(BlockDriverState *bs);
Paolo Bonzinid7d512f2012-08-23 11:20:36 +0200143void bdrv_add_close_notifier(BlockDriverState *bs, Notifier *notify);
Markus Armbrusterfa879d62011-08-03 15:07:40 +0200144int bdrv_attach_dev(BlockDriverState *bs, void *dev);
145void bdrv_attach_dev_nofail(BlockDriverState *bs, void *dev);
146void bdrv_detach_dev(BlockDriverState *bs, void *dev);
147void *bdrv_get_attached_dev(BlockDriverState *bs);
Markus Armbruster0e49de52011-08-03 15:07:41 +0200148void bdrv_set_dev_ops(BlockDriverState *bs, const BlockDevOps *ops,
149 void *opaque);
Paolo Bonzini025ccaa2011-11-07 17:50:13 +0100150void bdrv_dev_eject_request(BlockDriverState *bs, bool force);
Markus Armbruster2c6942f2011-09-06 18:58:51 +0200151bool bdrv_dev_has_removable_media(BlockDriverState *bs);
Markus Armbrustere4def802011-09-06 18:58:53 +0200152bool bdrv_dev_is_tray_open(BlockDriverState *bs);
Markus Armbrusterf1076392011-09-06 18:58:46 +0200153bool bdrv_dev_is_medium_locked(BlockDriverState *bs);
pbrookfaf07962007-11-11 02:51:17 +0000154int bdrv_read(BlockDriverState *bs, int64_t sector_num,
155 uint8_t *buf, int nb_sectors);
Markus Armbruster07d27a42012-06-29 17:34:29 +0200156int bdrv_read_unthrottled(BlockDriverState *bs, int64_t sector_num,
157 uint8_t *buf, int nb_sectors);
pbrookfaf07962007-11-11 02:51:17 +0000158int bdrv_write(BlockDriverState *bs, int64_t sector_num,
159 const uint8_t *buf, int nb_sectors);
Peter Lieven4105eaa2013-07-11 14:16:22 +0200160int bdrv_write_zeroes(BlockDriverState *bs, int64_t sector_num,
161 int nb_sectors);
Kevin Wolf8d3b1a22013-04-05 21:27:55 +0200162int bdrv_writev(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov);
pbrookfaf07962007-11-11 02:51:17 +0000163int bdrv_pread(BlockDriverState *bs, int64_t offset,
164 void *buf, int count);
165int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
166 const void *buf, int count);
Kevin Wolf8d3b1a22013-04-05 21:27:55 +0200167int bdrv_pwritev(BlockDriverState *bs, int64_t offset, QEMUIOVector *qiov);
Kevin Wolff08145f2010-06-16 16:38:15 +0200168int bdrv_pwrite_sync(BlockDriverState *bs, int64_t offset,
169 const void *buf, int count);
Kevin Wolfda1fa912011-07-14 17:27:13 +0200170int coroutine_fn bdrv_co_readv(BlockDriverState *bs, int64_t sector_num,
171 int nb_sectors, QEMUIOVector *qiov);
Stefan Hajnoczi470c0502012-01-18 14:40:42 +0000172int coroutine_fn bdrv_co_copy_on_readv(BlockDriverState *bs,
173 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov);
Kevin Wolfda1fa912011-07-14 17:27:13 +0200174int coroutine_fn bdrv_co_writev(BlockDriverState *bs, int64_t sector_num,
175 int nb_sectors, QEMUIOVector *qiov);
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +0000176/*
177 * Efficiently zero a region of the disk image. Note that this is a regular
178 * I/O request like read or write and should have a reasonable size. This
179 * function is not suitable for zeroing the entire image in a single request
180 * because it may allocate memory for the entire region.
181 */
182int coroutine_fn bdrv_co_write_zeroes(BlockDriverState *bs, int64_t sector_num,
183 int nb_sectors);
Stefan Hajnoczi060f51c2011-11-14 12:44:26 +0000184int coroutine_fn bdrv_co_is_allocated(BlockDriverState *bs, int64_t sector_num,
185 int nb_sectors, int *pnum);
Paolo Bonzini188a7bb2012-05-08 16:52:01 +0200186int coroutine_fn bdrv_co_is_allocated_above(BlockDriverState *top,
187 BlockDriverState *base,
188 int64_t sector_num,
189 int nb_sectors, int *pnum);
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +0000190BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
191 const char *backing_file);
BenoƮt Canetf198fd12012-08-02 10:22:47 +0200192int bdrv_get_backing_file_depth(BlockDriverState *bs);
pbrookfaf07962007-11-11 02:51:17 +0000193int bdrv_truncate(BlockDriverState *bs, int64_t offset);
194int64_t bdrv_getlength(BlockDriverState *bs);
Fam Zheng4a1d5e12011-07-12 19:56:39 +0800195int64_t bdrv_get_allocated_file_size(BlockDriverState *bs);
ths96b8f132007-12-17 01:35:20 +0000196void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr);
pbrookfaf07962007-11-11 02:51:17 +0000197int bdrv_commit(BlockDriverState *bs);
Stefan Hajnoczie8877492012-03-05 18:10:11 +0000198int bdrv_commit_all(void);
Kevin Wolf756e6732010-01-12 12:55:17 +0100199int bdrv_change_backing_file(BlockDriverState *bs,
200 const char *backing_file, const char *backing_fmt);
Anthony Liguori5efa9d52009-05-09 17:03:42 -0500201void bdrv_register(BlockDriver *bdrv);
Jeff Cody6ebdcee2012-09-27 13:29:12 -0400202int bdrv_drop_intermediate(BlockDriverState *active, BlockDriverState *top,
203 BlockDriverState *base);
204BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
205 BlockDriverState *bs);
Jeff Cody79fac562012-09-27 13:29:15 -0400206BlockDriverState *bdrv_find_base(BlockDriverState *bs);
Anthony Liguori5efa9d52009-05-09 17:03:42 -0500207
Kevin Wolfe076f332010-06-29 11:43:13 +0200208
209typedef struct BdrvCheckResult {
210 int corruptions;
211 int leaks;
212 int check_errors;
Kevin Wolfccf34712012-05-11 18:16:54 +0200213 int corruptions_fixed;
214 int leaks_fixed;
Federico Simoncellic6bb9ad2013-01-28 06:59:46 -0500215 int64_t image_end_offset;
Dong Xu Wangf8111c22012-03-15 20:13:31 +0800216 BlockFragInfo bfi;
Kevin Wolfe076f332010-06-29 11:43:13 +0200217} BdrvCheckResult;
218
Kevin Wolf4534ff52012-05-11 16:07:02 +0200219typedef enum {
220 BDRV_FIX_LEAKS = 1,
221 BDRV_FIX_ERRORS = 2,
222} BdrvCheckMode;
223
224int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix);
Kevin Wolfe076f332010-06-29 11:43:13 +0200225
pbrookfaf07962007-11-11 02:51:17 +0000226/* async block I/O */
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +0200227typedef void BlockDriverDirtyHandler(BlockDriverState *bs, int64_t sector,
Devin Nakamura39aa9a12011-06-09 01:06:43 -0400228 int sector_num);
aliguori3b69e4b2009-01-22 16:59:24 +0000229BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
230 QEMUIOVector *iov, int nb_sectors,
231 BlockDriverCompletionFunc *cb, void *opaque);
232BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
233 QEMUIOVector *iov, int nb_sectors,
234 BlockDriverCompletionFunc *cb, void *opaque);
Christoph Hellwigb2e12bc2009-09-04 19:01:49 +0200235BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs,
Devin Nakamura39aa9a12011-06-09 01:06:43 -0400236 BlockDriverCompletionFunc *cb, void *opaque);
Paolo Bonzini4265d622011-10-17 12:32:14 +0200237BlockDriverAIOCB *bdrv_aio_discard(BlockDriverState *bs,
238 int64_t sector_num, int nb_sectors,
239 BlockDriverCompletionFunc *cb, void *opaque);
pbrookfaf07962007-11-11 02:51:17 +0000240void bdrv_aio_cancel(BlockDriverAIOCB *acb);
241
Kevin Wolf40b4f532009-09-09 17:53:37 +0200242typedef struct BlockRequest {
243 /* Fields to be filled by multiwrite caller */
244 int64_t sector;
245 int nb_sectors;
246 QEMUIOVector *qiov;
247 BlockDriverCompletionFunc *cb;
248 void *opaque;
249
250 /* Filled by multiwrite implementation */
251 int error;
252} BlockRequest;
253
254int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs,
255 int num_reqs);
256
aliguori7d780662009-03-12 19:57:08 +0000257/* sg packet commands */
aliguori221f7152009-03-28 17:28:41 +0000258int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf);
259BlockDriverAIOCB *bdrv_aio_ioctl(BlockDriverState *bs,
260 unsigned long int req, void *buf,
261 BlockDriverCompletionFunc *cb, void *opaque);
aliguori7d780662009-03-12 19:57:08 +0000262
Anthony Liguori0f154232011-11-14 15:09:45 -0600263/* Invalidate any cached metadata used by image formats */
264void bdrv_invalidate_cache(BlockDriverState *bs);
265void bdrv_invalidate_cache_all(void);
266
BenoƮt Canet07789262012-03-23 08:36:49 +0100267void bdrv_clear_incoming_migration_all(void);
268
pbrookfaf07962007-11-11 02:51:17 +0000269/* Ensure contents are flushed to disk. */
Kevin Wolf205ef792010-10-21 16:43:43 +0200270int bdrv_flush(BlockDriverState *bs);
Paolo Bonzini07f07612011-10-17 12:32:12 +0200271int coroutine_fn bdrv_co_flush(BlockDriverState *bs);
Kevin Wolff0f0fdf2013-07-05 13:48:01 +0200272int bdrv_flush_all(void);
MORITA Kazutaka2bc93fe2010-05-28 11:44:57 +0900273void bdrv_close_all(void);
Stefan Hajnoczi922453b2011-11-30 12:23:43 +0000274void bdrv_drain_all(void);
aliguoric6ca28d2008-10-06 13:55:43 +0000275
Christoph Hellwigbb8bf762010-12-16 19:36:31 +0100276int bdrv_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors);
Paolo Bonzini4265d622011-10-17 12:32:14 +0200277int bdrv_co_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors);
Peter Lieven3ac21622013-06-28 12:47:42 +0200278int bdrv_has_zero_init_1(BlockDriverState *bs);
Kevin Wolff2feebb2010-04-14 17:30:35 +0200279int bdrv_has_zero_init(BlockDriverState *bs);
thsf58c7b32008-06-05 21:53:49 +0000280int bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
Devin Nakamura39aa9a12011-06-09 01:06:43 -0400281 int *pnum);
Miroslav Rezaninab35b2bb2013-02-13 09:09:39 +0100282int bdrv_is_allocated_above(BlockDriverState *top, BlockDriverState *base,
283 int64_t sector_num, int nb_sectors, int *pnum);
pbrookfaf07962007-11-11 02:51:17 +0000284
Paolo Bonziniff06f5f2012-09-28 17:22:54 +0200285void bdrv_set_on_error(BlockDriverState *bs, BlockdevOnError on_read_error,
286 BlockdevOnError on_write_error);
Paolo Bonzini1ceee0d2012-09-28 17:22:56 +0200287BlockdevOnError bdrv_get_on_error(BlockDriverState *bs, bool is_read);
Paolo Bonzini3e1caa52012-09-28 17:22:57 +0200288BlockErrorAction bdrv_get_error_action(BlockDriverState *bs, bool is_read, int error);
289void bdrv_error_action(BlockDriverState *bs, BlockErrorAction action,
290 bool is_read, int error);
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);
Paolo Bonzini343bded2013-01-21 17:09:42 +0100315void bdrv_round_to_clusters(BlockDriverState *bs,
316 int64_t sector_num, int nb_sectors,
317 int64_t *cluster_sector_num,
318 int *cluster_nb_sectors);
pbrookfaf07962007-11-11 02:51:17 +0000319
aliguori045df332009-03-05 23:00:48 +0000320const char *bdrv_get_encrypted_filename(BlockDriverState *bs);
pbrookfaf07962007-11-11 02:51:17 +0000321void bdrv_get_backing_filename(BlockDriverState *bs,
322 char *filename, int filename_size);
Paolo Bonzinidc5a1372012-05-08 16:51:50 +0200323void bdrv_get_full_backing_filename(BlockDriverState *bs,
324 char *dest, size_t sz);
Blue Swirl199630b2010-07-25 20:49:34 +0000325int bdrv_is_snapshot(BlockDriverState *bs);
pbrookfaf07962007-11-11 02:51:17 +0000326
pbrookfaf07962007-11-11 02:51:17 +0000327int path_is_absolute(const char *path);
328void path_combine(char *dest, int dest_size,
329 const char *base_path,
330 const char *filename);
331
Kevin Wolfcf8074b2013-04-05 21:27:53 +0200332int bdrv_writev_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos);
Christoph Hellwig45566e92009-07-10 23:11:57 +0200333int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
334 int64_t pos, int size);
aliguori178e08a2009-04-05 19:10:55 +0000335
Christoph Hellwig45566e92009-07-10 23:11:57 +0200336int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,
337 int64_t pos, int size);
aliguori178e08a2009-04-05 19:10:55 +0000338
Luiz Capitulinod92ada22012-11-30 10:52:09 -0200339void bdrv_img_create(const char *filename, const char *fmt,
340 const char *base_filename, const char *base_fmt,
Miroslav Rezaninaf382d432013-02-13 09:09:40 +0100341 char *options, uint64_t img_size, int flags,
342 Error **errp, bool quiet);
Jes Sorensenf88e1a42010-12-16 13:52:15 +0100343
Markus Armbruster7b6f9302011-09-06 18:58:56 +0200344void bdrv_set_buffer_alignment(BlockDriverState *bs, int align);
Markus Armbrusterba5b7ad2011-08-03 15:08:19 +0200345void *qemu_blockalign(BlockDriverState *bs, size_t size);
Stefan Hajnoczic53b1c52013-01-11 16:41:27 +0100346bool bdrv_qiov_is_aligned(BlockDriverState *bs, QEMUIOVector *qiov);
Markus Armbrusterba5b7ad2011-08-03 15:08:19 +0200347
Paolo Bonzini8f0720e2013-01-21 17:09:41 +0100348struct HBitmapIter;
Paolo Bonzini50717e92013-01-21 17:09:45 +0100349void bdrv_set_dirty_tracking(BlockDriverState *bs, int granularity);
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +0200350int bdrv_get_dirty(BlockDriverState *bs, int64_t sector);
Paolo Bonzini1755da12012-10-18 16:49:18 +0200351void bdrv_set_dirty(BlockDriverState *bs, int64_t cur_sector, int nr_sectors);
352void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector, int nr_sectors);
Paolo Bonzini8f0720e2013-01-21 17:09:41 +0100353void bdrv_dirty_iter_init(BlockDriverState *bs, struct HBitmapIter *hbi);
Liran Schouraaa0eb72010-01-26 10:31:48 +0200354int64_t bdrv_get_dirty_count(BlockDriverState *bs);
Kevin Wolf8b9b0cc2010-03-15 17:27:00 +0100355
Stefan Hajnoczi53fec9d2011-11-28 16:08:47 +0000356void bdrv_enable_copy_on_read(BlockDriverState *bs);
357void bdrv_disable_copy_on_read(BlockDriverState *bs);
358
Marcelo Tosattidb593f22011-01-26 12:12:34 -0200359void bdrv_set_in_use(BlockDriverState *bs, int in_use);
360int bdrv_in_use(BlockDriverState *bs);
Kevin Wolf8b9b0cc2010-03-15 17:27:00 +0100361
Stefan Hajnoczi40657422012-11-14 11:43:23 +0100362#ifdef CONFIG_LINUX_AIO
363int raw_get_aio_fd(BlockDriverState *bs);
364#else
365static inline int raw_get_aio_fd(BlockDriverState *bs)
366{
367 return -ENOTSUP;
368}
369#endif
370
Christoph Hellwiga597e792011-08-25 08:26:01 +0200371enum BlockAcctType {
372 BDRV_ACCT_READ,
373 BDRV_ACCT_WRITE,
374 BDRV_ACCT_FLUSH,
375 BDRV_MAX_IOTYPE,
376};
377
378typedef struct BlockAcctCookie {
379 int64_t bytes;
Christoph Hellwigc488c7f2011-08-25 08:26:10 +0200380 int64_t start_time_ns;
Christoph Hellwiga597e792011-08-25 08:26:01 +0200381 enum BlockAcctType type;
382} BlockAcctCookie;
383
384void bdrv_acct_start(BlockDriverState *bs, BlockAcctCookie *cookie,
385 int64_t bytes, enum BlockAcctType type);
386void bdrv_acct_done(BlockDriverState *bs, BlockAcctCookie *cookie);
387
Kevin Wolf8b9b0cc2010-03-15 17:27:00 +0100388typedef enum {
Kevin Wolf82522782010-03-15 17:38:05 +0100389 BLKDBG_L1_UPDATE,
390
391 BLKDBG_L1_GROW_ALLOC_TABLE,
392 BLKDBG_L1_GROW_WRITE_TABLE,
393 BLKDBG_L1_GROW_ACTIVATE_TABLE,
394
395 BLKDBG_L2_LOAD,
396 BLKDBG_L2_UPDATE,
397 BLKDBG_L2_UPDATE_COMPRESSED,
398 BLKDBG_L2_ALLOC_COW_READ,
399 BLKDBG_L2_ALLOC_WRITE,
400
Kevin Wolf82522782010-03-15 17:38:05 +0100401 BLKDBG_READ_AIO,
Kevin Wolf82522782010-03-15 17:38:05 +0100402 BLKDBG_READ_BACKING_AIO,
403 BLKDBG_READ_COMPRESSED,
404
405 BLKDBG_WRITE_AIO,
406 BLKDBG_WRITE_COMPRESSED,
407
408 BLKDBG_VMSTATE_LOAD,
409 BLKDBG_VMSTATE_SAVE,
410
411 BLKDBG_COW_READ,
412 BLKDBG_COW_WRITE,
413
414 BLKDBG_REFTABLE_LOAD,
415 BLKDBG_REFTABLE_GROW,
416
417 BLKDBG_REFBLOCK_LOAD,
418 BLKDBG_REFBLOCK_UPDATE,
419 BLKDBG_REFBLOCK_UPDATE_PART,
420 BLKDBG_REFBLOCK_ALLOC,
421 BLKDBG_REFBLOCK_ALLOC_HOOKUP,
422 BLKDBG_REFBLOCK_ALLOC_WRITE,
423 BLKDBG_REFBLOCK_ALLOC_WRITE_BLOCKS,
424 BLKDBG_REFBLOCK_ALLOC_WRITE_TABLE,
425 BLKDBG_REFBLOCK_ALLOC_SWITCH_TABLE,
426
427 BLKDBG_CLUSTER_ALLOC,
428 BLKDBG_CLUSTER_ALLOC_BYTES,
429 BLKDBG_CLUSTER_FREE,
430
Kevin Wolfbf736fe2013-06-05 15:17:55 +0200431 BLKDBG_FLUSH_TO_OS,
432 BLKDBG_FLUSH_TO_DISK,
433
Kevin Wolf8b9b0cc2010-03-15 17:27:00 +0100434 BLKDBG_EVENT_MAX,
435} BlkDebugEvent;
436
437#define BLKDBG_EVENT(bs, evt) bdrv_debug_event(bs, evt)
438void bdrv_debug_event(BlockDriverState *bs, BlkDebugEvent event);
439
Kevin Wolf41c695c2012-12-06 14:32:58 +0100440int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event,
441 const char *tag);
442int bdrv_debug_resume(BlockDriverState *bs, const char *tag);
443bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag);
444
Markus Armbruster8a4bc5a2012-07-10 11:12:40 +0200445#endif