4 * Copyright (C) 2014-2016 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
17 #include "block/throttle-groups.h"
20 * TODO Have to include block/block.h for a bunch of block layer
21 * types. Unfortunately, this pulls in the whole BlockDriverState
22 * API, which we don't want used by many BlockBackend users. Some of
23 * the types belong here, and the rest should be split into a common
24 * header and one for the BlockDriverState API.
26 #include "block/block.h"
28 /* Callbacks for block device models */
29 typedef struct BlockDevOps
{
31 * Runs when virtual media changed (monitor commands eject, change)
32 * Argument load is true on load and false on eject.
33 * Beware: doesn't run when a host device's physical media
34 * changes. Sure would be useful if it did.
35 * Device models with removable media must implement this callback.
37 void (*change_media_cb
)(void *opaque
, bool load
, Error
**errp
);
39 * Runs when an eject request is issued from the monitor, the tray
40 * is closed, and the medium is locked.
41 * Device models that do not implement is_medium_locked will not need
42 * this callback. Device models that can lock the medium or tray might
43 * want to implement the callback and unlock the tray when "force" is
44 * true, even if they do not support eject requests.
46 void (*eject_request_cb
)(void *opaque
, bool force
);
48 * Is the virtual tray open?
49 * Device models implement this only when the device has a tray.
51 bool (*is_tray_open
)(void *opaque
);
53 * Is the virtual medium locked into the device?
54 * Device models implement this only when device has such a lock.
56 bool (*is_medium_locked
)(void *opaque
);
58 * Runs when the size changed (e.g. monitor command block_resize)
60 void (*resize_cb
)(void *opaque
);
62 * Runs when the backend receives a drain request.
64 void (*drained_begin
)(void *opaque
);
66 * Runs when the backend's last drain request ends.
68 void (*drained_end
)(void *opaque
);
70 * Is the device still busy?
72 bool (*drained_poll
)(void *opaque
);
75 /* This struct is embedded in (the private) BlockBackend struct and contains
76 * fields that must be public. This is in particular for QLIST_ENTRY() and
77 * friends so that BlockBackends can be kept in lists outside block-backend.c
79 typedef struct BlockBackendPublic
{
80 ThrottleGroupMember throttle_group_member
;
83 BlockBackend
*blk_new(AioContext
*ctx
, uint64_t perm
, uint64_t shared_perm
);
84 BlockBackend
*blk_new_with_bs(BlockDriverState
*bs
, uint64_t perm
,
85 uint64_t shared_perm
, Error
**errp
);
86 BlockBackend
*blk_new_open(const char *filename
, const char *reference
,
87 QDict
*options
, int flags
, Error
**errp
);
88 int blk_get_refcnt(BlockBackend
*blk
);
89 void blk_ref(BlockBackend
*blk
);
90 void blk_unref(BlockBackend
*blk
);
91 void blk_remove_all_bs(void);
92 const char *blk_name(const BlockBackend
*blk
);
93 BlockBackend
*blk_by_name(const char *name
);
94 BlockBackend
*blk_next(BlockBackend
*blk
);
95 BlockBackend
*blk_all_next(BlockBackend
*blk
);
96 bool monitor_add_blk(BlockBackend
*blk
, const char *name
, Error
**errp
);
97 void monitor_remove_blk(BlockBackend
*blk
);
99 BlockBackendPublic
*blk_get_public(BlockBackend
*blk
);
100 BlockBackend
*blk_by_public(BlockBackendPublic
*public);
102 BlockDriverState
*blk_bs(BlockBackend
*blk
);
103 void blk_remove_bs(BlockBackend
*blk
);
104 int blk_insert_bs(BlockBackend
*blk
, BlockDriverState
*bs
, Error
**errp
);
105 int blk_replace_bs(BlockBackend
*blk
, BlockDriverState
*new_bs
, Error
**errp
);
106 bool bdrv_has_blk(BlockDriverState
*bs
);
107 bool bdrv_is_root_node(BlockDriverState
*bs
);
108 int blk_set_perm(BlockBackend
*blk
, uint64_t perm
, uint64_t shared_perm
,
110 void blk_get_perm(BlockBackend
*blk
, uint64_t *perm
, uint64_t *shared_perm
);
112 void blk_set_allow_write_beyond_eof(BlockBackend
*blk
, bool allow
);
113 void blk_set_allow_aio_context_change(BlockBackend
*blk
, bool allow
);
114 void blk_set_disable_request_queuing(BlockBackend
*blk
, bool disable
);
115 void blk_iostatus_enable(BlockBackend
*blk
);
116 bool blk_iostatus_is_enabled(const BlockBackend
*blk
);
117 BlockDeviceIoStatus
blk_iostatus(const BlockBackend
*blk
);
118 void blk_iostatus_disable(BlockBackend
*blk
);
119 void blk_iostatus_reset(BlockBackend
*blk
);
120 void blk_iostatus_set_err(BlockBackend
*blk
, int error
);
121 int blk_attach_dev(BlockBackend
*blk
, DeviceState
*dev
);
122 void blk_detach_dev(BlockBackend
*blk
, DeviceState
*dev
);
123 DeviceState
*blk_get_attached_dev(BlockBackend
*blk
);
124 char *blk_get_attached_dev_id(BlockBackend
*blk
);
125 BlockBackend
*blk_by_dev(void *dev
);
126 BlockBackend
*blk_by_qdev_id(const char *id
, Error
**errp
);
127 void blk_set_dev_ops(BlockBackend
*blk
, const BlockDevOps
*ops
, void *opaque
);
128 int coroutine_fn
blk_co_preadv(BlockBackend
*blk
, int64_t offset
,
129 int64_t bytes
, QEMUIOVector
*qiov
,
130 BdrvRequestFlags flags
);
131 int coroutine_fn
blk_co_pwritev_part(BlockBackend
*blk
, int64_t offset
,
133 QEMUIOVector
*qiov
, size_t qiov_offset
,
134 BdrvRequestFlags flags
);
135 int coroutine_fn
blk_co_pwritev(BlockBackend
*blk
, int64_t offset
,
136 int64_t bytes
, QEMUIOVector
*qiov
,
137 BdrvRequestFlags flags
);
139 static inline int coroutine_fn
blk_co_pread(BlockBackend
*blk
, int64_t offset
,
140 int64_t bytes
, void *buf
,
141 BdrvRequestFlags flags
)
143 QEMUIOVector qiov
= QEMU_IOVEC_INIT_BUF(qiov
, buf
, bytes
);
145 assert(bytes
<= SIZE_MAX
);
147 return blk_co_preadv(blk
, offset
, bytes
, &qiov
, flags
);
150 static inline int coroutine_fn
blk_co_pwrite(BlockBackend
*blk
, int64_t offset
,
151 int64_t bytes
, void *buf
,
152 BdrvRequestFlags flags
)
154 QEMUIOVector qiov
= QEMU_IOVEC_INIT_BUF(qiov
, buf
, bytes
);
156 assert(bytes
<= SIZE_MAX
);
158 return blk_co_pwritev(blk
, offset
, bytes
, &qiov
, flags
);
161 int blk_pwrite_zeroes(BlockBackend
*blk
, int64_t offset
,
162 int64_t bytes
, BdrvRequestFlags flags
);
163 BlockAIOCB
*blk_aio_pwrite_zeroes(BlockBackend
*blk
, int64_t offset
,
164 int64_t bytes
, BdrvRequestFlags flags
,
165 BlockCompletionFunc
*cb
, void *opaque
);
166 int blk_make_zero(BlockBackend
*blk
, BdrvRequestFlags flags
);
167 int blk_pread(BlockBackend
*blk
, int64_t offset
, void *buf
, int bytes
);
168 int blk_pwrite(BlockBackend
*blk
, int64_t offset
, const void *buf
, int bytes
,
169 BdrvRequestFlags flags
);
170 int64_t blk_getlength(BlockBackend
*blk
);
171 void blk_get_geometry(BlockBackend
*blk
, uint64_t *nb_sectors_ptr
);
172 int64_t blk_nb_sectors(BlockBackend
*blk
);
173 BlockAIOCB
*blk_aio_preadv(BlockBackend
*blk
, int64_t offset
,
174 QEMUIOVector
*qiov
, BdrvRequestFlags flags
,
175 BlockCompletionFunc
*cb
, void *opaque
);
176 BlockAIOCB
*blk_aio_pwritev(BlockBackend
*blk
, int64_t offset
,
177 QEMUIOVector
*qiov
, BdrvRequestFlags flags
,
178 BlockCompletionFunc
*cb
, void *opaque
);
179 BlockAIOCB
*blk_aio_flush(BlockBackend
*blk
,
180 BlockCompletionFunc
*cb
, void *opaque
);
181 BlockAIOCB
*blk_aio_pdiscard(BlockBackend
*blk
, int64_t offset
, int64_t bytes
,
182 BlockCompletionFunc
*cb
, void *opaque
);
183 void blk_aio_cancel(BlockAIOCB
*acb
);
184 void blk_aio_cancel_async(BlockAIOCB
*acb
);
185 int blk_ioctl(BlockBackend
*blk
, unsigned long int req
, void *buf
);
186 BlockAIOCB
*blk_aio_ioctl(BlockBackend
*blk
, unsigned long int req
, void *buf
,
187 BlockCompletionFunc
*cb
, void *opaque
);
188 int coroutine_fn
blk_co_pdiscard(BlockBackend
*blk
, int64_t offset
,
190 int coroutine_fn
blk_co_flush(BlockBackend
*blk
);
191 int blk_flush(BlockBackend
*blk
);
192 int blk_commit_all(void);
193 void blk_inc_in_flight(BlockBackend
*blk
);
194 void blk_dec_in_flight(BlockBackend
*blk
);
195 void blk_drain(BlockBackend
*blk
);
196 void blk_drain_all(void);
197 void blk_set_on_error(BlockBackend
*blk
, BlockdevOnError on_read_error
,
198 BlockdevOnError on_write_error
);
199 BlockdevOnError
blk_get_on_error(BlockBackend
*blk
, bool is_read
);
200 BlockErrorAction
blk_get_error_action(BlockBackend
*blk
, bool is_read
,
202 void blk_error_action(BlockBackend
*blk
, BlockErrorAction action
,
203 bool is_read
, int error
);
204 bool blk_supports_write_perm(BlockBackend
*blk
);
205 bool blk_is_writable(BlockBackend
*blk
);
206 bool blk_is_sg(BlockBackend
*blk
);
207 bool blk_enable_write_cache(BlockBackend
*blk
);
208 void blk_set_enable_write_cache(BlockBackend
*blk
, bool wce
);
209 void blk_activate(BlockBackend
*blk
, Error
**errp
);
210 bool blk_is_inserted(BlockBackend
*blk
);
211 bool blk_is_available(BlockBackend
*blk
);
212 void blk_lock_medium(BlockBackend
*blk
, bool locked
);
213 void blk_eject(BlockBackend
*blk
, bool eject_flag
);
214 int blk_get_flags(BlockBackend
*blk
);
215 uint32_t blk_get_request_alignment(BlockBackend
*blk
);
216 uint32_t blk_get_max_transfer(BlockBackend
*blk
);
217 uint64_t blk_get_max_hw_transfer(BlockBackend
*blk
);
218 int blk_get_max_iov(BlockBackend
*blk
);
219 int blk_get_max_hw_iov(BlockBackend
*blk
);
220 void blk_set_guest_block_size(BlockBackend
*blk
, int align
);
221 void *blk_try_blockalign(BlockBackend
*blk
, size_t size
);
222 void *blk_blockalign(BlockBackend
*blk
, size_t size
);
223 bool blk_op_is_blocked(BlockBackend
*blk
, BlockOpType op
, Error
**errp
);
224 void blk_op_unblock(BlockBackend
*blk
, BlockOpType op
, Error
*reason
);
225 void blk_op_block_all(BlockBackend
*blk
, Error
*reason
);
226 void blk_op_unblock_all(BlockBackend
*blk
, Error
*reason
);
227 AioContext
*blk_get_aio_context(BlockBackend
*blk
);
228 int blk_set_aio_context(BlockBackend
*blk
, AioContext
*new_context
,
230 void blk_add_aio_context_notifier(BlockBackend
*blk
,
231 void (*attached_aio_context
)(AioContext
*new_context
, void *opaque
),
232 void (*detach_aio_context
)(void *opaque
), void *opaque
);
233 void blk_remove_aio_context_notifier(BlockBackend
*blk
,
234 void (*attached_aio_context
)(AioContext
*,
236 void (*detach_aio_context
)(void *),
238 void blk_add_remove_bs_notifier(BlockBackend
*blk
, Notifier
*notify
);
239 void blk_add_insert_bs_notifier(BlockBackend
*blk
, Notifier
*notify
);
240 void blk_io_plug(BlockBackend
*blk
);
241 void blk_io_unplug(BlockBackend
*blk
);
242 BlockAcctStats
*blk_get_stats(BlockBackend
*blk
);
243 BlockBackendRootState
*blk_get_root_state(BlockBackend
*blk
);
244 void blk_update_root_state(BlockBackend
*blk
);
245 bool blk_get_detect_zeroes_from_root_state(BlockBackend
*blk
);
246 int blk_get_open_flags_from_root_state(BlockBackend
*blk
);
248 void *blk_aio_get(const AIOCBInfo
*aiocb_info
, BlockBackend
*blk
,
249 BlockCompletionFunc
*cb
, void *opaque
);
250 int coroutine_fn
blk_co_pwrite_zeroes(BlockBackend
*blk
, int64_t offset
,
251 int64_t bytes
, BdrvRequestFlags flags
);
252 int blk_pwrite_compressed(BlockBackend
*blk
, int64_t offset
, const void *buf
,
254 int blk_truncate(BlockBackend
*blk
, int64_t offset
, bool exact
,
255 PreallocMode prealloc
, BdrvRequestFlags flags
, Error
**errp
);
256 int blk_pdiscard(BlockBackend
*blk
, int64_t offset
, int64_t bytes
);
257 int blk_save_vmstate(BlockBackend
*blk
, const uint8_t *buf
,
258 int64_t pos
, int size
);
259 int blk_load_vmstate(BlockBackend
*blk
, uint8_t *buf
, int64_t pos
, int size
);
260 int blk_probe_blocksizes(BlockBackend
*blk
, BlockSizes
*bsz
);
261 int blk_probe_geometry(BlockBackend
*blk
, HDGeometry
*geo
);
262 BlockAIOCB
*blk_abort_aio_request(BlockBackend
*blk
,
263 BlockCompletionFunc
*cb
,
264 void *opaque
, int ret
);
266 void blk_set_io_limits(BlockBackend
*blk
, ThrottleConfig
*cfg
);
267 void blk_io_limits_disable(BlockBackend
*blk
);
268 void blk_io_limits_enable(BlockBackend
*blk
, const char *group
);
269 void blk_io_limits_update_group(BlockBackend
*blk
, const char *group
);
270 void blk_set_force_allow_inactivate(BlockBackend
*blk
);
272 void blk_register_buf(BlockBackend
*blk
, void *host
, size_t size
);
273 void blk_unregister_buf(BlockBackend
*blk
, void *host
);
275 int coroutine_fn
blk_co_copy_range(BlockBackend
*blk_in
, int64_t off_in
,
276 BlockBackend
*blk_out
, int64_t off_out
,
277 int64_t bytes
, BdrvRequestFlags read_flags
,
278 BdrvRequestFlags write_flags
);
280 const BdrvChild
*blk_root(BlockBackend
*blk
);
282 int blk_make_empty(BlockBackend
*blk
, Error
**errp
);