4 * Copyright (C) 2014 Red Hat, Inc.
7 * Markus Armbruster <armbru@redhat.com>,
9 * This work is licensed under the terms of the GNU LGPL, version 2.1
10 * or later. See the COPYING.LIB file in the top-level directory.
13 #ifndef BLOCK_BACKEND_H
14 #define BLOCK_BACKEND_H
19 * TODO Have to include block/block.h for a bunch of block layer
20 * types. Unfortunately, this pulls in the whole BlockDriverState
21 * API, which we don't want used by many BlockBackend users. Some of
22 * the types belong here, and the rest should be split into a common
23 * header and one for the BlockDriverState API.
25 #include "block/block.h"
27 /* Callbacks for block device models */
28 typedef struct BlockDevOps
{
30 * Runs when virtual media changed (monitor commands eject, change)
31 * Argument load is true on load and false on eject.
32 * Beware: doesn't run when a host device's physical media
33 * changes. Sure would be useful if it did.
34 * Device models with removable media must implement this callback.
36 void (*change_media_cb
)(void *opaque
, bool load
);
38 * Runs when an eject request is issued from the monitor, the tray
39 * is closed, and the medium is locked.
40 * Device models that do not implement is_medium_locked will not need
41 * this callback. Device models that can lock the medium or tray might
42 * want to implement the callback and unlock the tray when "force" is
43 * true, even if they do not support eject requests.
45 void (*eject_request_cb
)(void *opaque
, bool force
);
47 * Is the virtual tray open?
48 * Device models implement this only when the device has a tray.
50 bool (*is_tray_open
)(void *opaque
);
52 * Is the virtual medium locked into the device?
53 * Device models implement this only when device has such a lock.
55 bool (*is_medium_locked
)(void *opaque
);
57 * Runs when the size changed (e.g. monitor command block_resize)
59 void (*resize_cb
)(void *opaque
);
62 BlockBackend
*blk_new(Error
**errp
);
63 BlockBackend
*blk_new_with_bs(Error
**errp
);
64 BlockBackend
*blk_new_open(const char *filename
, const char *reference
,
65 QDict
*options
, int flags
, Error
**errp
);
66 int blk_get_refcnt(BlockBackend
*blk
);
67 void blk_ref(BlockBackend
*blk
);
68 void blk_unref(BlockBackend
*blk
);
69 void blk_remove_all_bs(void);
70 const char *blk_name(BlockBackend
*blk
);
71 BlockBackend
*blk_by_name(const char *name
);
72 BlockBackend
*blk_next(BlockBackend
*blk
);
73 BlockDriverState
*blk_next_root_bs(BlockDriverState
*bs
);
74 bool monitor_add_blk(BlockBackend
*blk
, const char *name
, Error
**errp
);
75 void monitor_remove_blk(BlockBackend
*blk
);
77 BlockDriverState
*blk_bs(BlockBackend
*blk
);
78 void blk_remove_bs(BlockBackend
*blk
);
79 void blk_insert_bs(BlockBackend
*blk
, BlockDriverState
*bs
);
81 void blk_set_allow_write_beyond_eof(BlockBackend
*blk
, bool allow
);
82 void blk_iostatus_enable(BlockBackend
*blk
);
83 bool blk_iostatus_is_enabled(const BlockBackend
*blk
);
84 BlockDeviceIoStatus
blk_iostatus(const BlockBackend
*blk
);
85 void blk_iostatus_disable(BlockBackend
*blk
);
86 void blk_iostatus_reset(BlockBackend
*blk
);
87 void blk_iostatus_set_err(BlockBackend
*blk
, int error
);
88 int blk_attach_dev(BlockBackend
*blk
, void *dev
);
89 void blk_attach_dev_nofail(BlockBackend
*blk
, void *dev
);
90 void blk_detach_dev(BlockBackend
*blk
, void *dev
);
91 void *blk_get_attached_dev(BlockBackend
*blk
);
92 void blk_set_dev_ops(BlockBackend
*blk
, const BlockDevOps
*ops
, void *opaque
);
93 int blk_read(BlockBackend
*blk
, int64_t sector_num
, uint8_t *buf
,
95 int blk_read_unthrottled(BlockBackend
*blk
, int64_t sector_num
, uint8_t *buf
,
97 int blk_write(BlockBackend
*blk
, int64_t sector_num
, const uint8_t *buf
,
99 int blk_write_zeroes(BlockBackend
*blk
, int64_t sector_num
,
100 int nb_sectors
, BdrvRequestFlags flags
);
101 BlockAIOCB
*blk_aio_write_zeroes(BlockBackend
*blk
, int64_t sector_num
,
102 int nb_sectors
, BdrvRequestFlags flags
,
103 BlockCompletionFunc
*cb
, void *opaque
);
104 int blk_pread(BlockBackend
*blk
, int64_t offset
, void *buf
, int count
);
105 int blk_pwrite(BlockBackend
*blk
, int64_t offset
, const void *buf
, int count
,
106 BdrvRequestFlags flags
);
107 int64_t blk_getlength(BlockBackend
*blk
);
108 void blk_get_geometry(BlockBackend
*blk
, uint64_t *nb_sectors_ptr
);
109 int64_t blk_nb_sectors(BlockBackend
*blk
);
110 BlockAIOCB
*blk_aio_readv(BlockBackend
*blk
, int64_t sector_num
,
111 QEMUIOVector
*iov
, int nb_sectors
,
112 BlockCompletionFunc
*cb
, void *opaque
);
113 BlockAIOCB
*blk_aio_writev(BlockBackend
*blk
, int64_t sector_num
,
114 QEMUIOVector
*iov
, int nb_sectors
,
115 BlockCompletionFunc
*cb
, void *opaque
);
116 BlockAIOCB
*blk_aio_flush(BlockBackend
*blk
,
117 BlockCompletionFunc
*cb
, void *opaque
);
118 BlockAIOCB
*blk_aio_discard(BlockBackend
*blk
,
119 int64_t sector_num
, int nb_sectors
,
120 BlockCompletionFunc
*cb
, void *opaque
);
121 void blk_aio_cancel(BlockAIOCB
*acb
);
122 void blk_aio_cancel_async(BlockAIOCB
*acb
);
123 int blk_aio_multiwrite(BlockBackend
*blk
, BlockRequest
*reqs
, int num_reqs
);
124 int blk_ioctl(BlockBackend
*blk
, unsigned long int req
, void *buf
);
125 BlockAIOCB
*blk_aio_ioctl(BlockBackend
*blk
, unsigned long int req
, void *buf
,
126 BlockCompletionFunc
*cb
, void *opaque
);
127 int blk_co_discard(BlockBackend
*blk
, int64_t sector_num
, int nb_sectors
);
128 int blk_co_flush(BlockBackend
*blk
);
129 int blk_flush(BlockBackend
*blk
);
130 int blk_flush_all(void);
131 int blk_commit_all(void);
132 void blk_drain(BlockBackend
*blk
);
133 void blk_drain_all(void);
134 void blk_set_on_error(BlockBackend
*blk
, BlockdevOnError on_read_error
,
135 BlockdevOnError on_write_error
);
136 BlockdevOnError
blk_get_on_error(BlockBackend
*blk
, bool is_read
);
137 BlockErrorAction
blk_get_error_action(BlockBackend
*blk
, bool is_read
,
139 void blk_error_action(BlockBackend
*blk
, BlockErrorAction action
,
140 bool is_read
, int error
);
141 int blk_is_read_only(BlockBackend
*blk
);
142 int blk_is_sg(BlockBackend
*blk
);
143 int blk_enable_write_cache(BlockBackend
*blk
);
144 void blk_set_enable_write_cache(BlockBackend
*blk
, bool wce
);
145 void blk_invalidate_cache(BlockBackend
*blk
, Error
**errp
);
146 bool blk_is_inserted(BlockBackend
*blk
);
147 bool blk_is_available(BlockBackend
*blk
);
148 void blk_lock_medium(BlockBackend
*blk
, bool locked
);
149 void blk_eject(BlockBackend
*blk
, bool eject_flag
);
150 int blk_get_flags(BlockBackend
*blk
);
151 int blk_get_max_transfer_length(BlockBackend
*blk
);
152 int blk_get_max_iov(BlockBackend
*blk
);
153 void blk_set_guest_block_size(BlockBackend
*blk
, int align
);
154 void *blk_try_blockalign(BlockBackend
*blk
, size_t size
);
155 void *blk_blockalign(BlockBackend
*blk
, size_t size
);
156 bool blk_op_is_blocked(BlockBackend
*blk
, BlockOpType op
, Error
**errp
);
157 void blk_op_unblock(BlockBackend
*blk
, BlockOpType op
, Error
*reason
);
158 void blk_op_block_all(BlockBackend
*blk
, Error
*reason
);
159 void blk_op_unblock_all(BlockBackend
*blk
, Error
*reason
);
160 AioContext
*blk_get_aio_context(BlockBackend
*blk
);
161 void blk_set_aio_context(BlockBackend
*blk
, AioContext
*new_context
);
162 void blk_add_aio_context_notifier(BlockBackend
*blk
,
163 void (*attached_aio_context
)(AioContext
*new_context
, void *opaque
),
164 void (*detach_aio_context
)(void *opaque
), void *opaque
);
165 void blk_remove_aio_context_notifier(BlockBackend
*blk
,
166 void (*attached_aio_context
)(AioContext
*,
168 void (*detach_aio_context
)(void *),
170 void blk_add_remove_bs_notifier(BlockBackend
*blk
, Notifier
*notify
);
171 void blk_add_insert_bs_notifier(BlockBackend
*blk
, Notifier
*notify
);
172 void blk_io_plug(BlockBackend
*blk
);
173 void blk_io_unplug(BlockBackend
*blk
);
174 BlockAcctStats
*blk_get_stats(BlockBackend
*blk
);
175 BlockBackendRootState
*blk_get_root_state(BlockBackend
*blk
);
176 void blk_update_root_state(BlockBackend
*blk
);
177 void blk_apply_root_state(BlockBackend
*blk
, BlockDriverState
*bs
);
178 int blk_get_open_flags_from_root_state(BlockBackend
*blk
);
180 void *blk_aio_get(const AIOCBInfo
*aiocb_info
, BlockBackend
*blk
,
181 BlockCompletionFunc
*cb
, void *opaque
);
182 int coroutine_fn
blk_co_write_zeroes(BlockBackend
*blk
, int64_t sector_num
,
183 int nb_sectors
, BdrvRequestFlags flags
);
184 int blk_write_compressed(BlockBackend
*blk
, int64_t sector_num
,
185 const uint8_t *buf
, int nb_sectors
);
186 int blk_truncate(BlockBackend
*blk
, int64_t offset
);
187 int blk_discard(BlockBackend
*blk
, int64_t sector_num
, int nb_sectors
);
188 int blk_save_vmstate(BlockBackend
*blk
, const uint8_t *buf
,
189 int64_t pos
, int size
);
190 int blk_load_vmstate(BlockBackend
*blk
, uint8_t *buf
, int64_t pos
, int size
);
191 int blk_probe_blocksizes(BlockBackend
*blk
, BlockSizes
*bsz
);
192 int blk_probe_geometry(BlockBackend
*blk
, HDGeometry
*geo
);
193 BlockAIOCB
*blk_abort_aio_request(BlockBackend
*blk
,
194 BlockCompletionFunc
*cb
,
195 void *opaque
, int ret
);