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
);
71 /* This struct is embedded in (the private) BlockBackend struct and contains
72 * fields that must be public. This is in particular for QLIST_ENTRY() and
73 * friends so that BlockBackends can be kept in lists outside block-backend.c
75 typedef struct BlockBackendPublic
{
76 ThrottleGroupMember throttle_group_member
;
79 BlockBackend
*blk_new(AioContext
*ctx
, uint64_t perm
, uint64_t shared_perm
);
80 BlockBackend
*blk_new_with_bs(BlockDriverState
*bs
, uint64_t perm
,
81 uint64_t shared_perm
, Error
**errp
);
82 BlockBackend
*blk_new_open(const char *filename
, const char *reference
,
83 QDict
*options
, int flags
, Error
**errp
);
84 int blk_get_refcnt(BlockBackend
*blk
);
85 void blk_ref(BlockBackend
*blk
);
86 void blk_unref(BlockBackend
*blk
);
87 void blk_remove_all_bs(void);
88 const char *blk_name(const BlockBackend
*blk
);
89 BlockBackend
*blk_by_name(const char *name
);
90 BlockBackend
*blk_next(BlockBackend
*blk
);
91 BlockBackend
*blk_all_next(BlockBackend
*blk
);
92 bool monitor_add_blk(BlockBackend
*blk
, const char *name
, Error
**errp
);
93 void monitor_remove_blk(BlockBackend
*blk
);
95 BlockBackendPublic
*blk_get_public(BlockBackend
*blk
);
96 BlockBackend
*blk_by_public(BlockBackendPublic
*public);
98 BlockDriverState
*blk_bs(BlockBackend
*blk
);
99 void blk_remove_bs(BlockBackend
*blk
);
100 int blk_insert_bs(BlockBackend
*blk
, BlockDriverState
*bs
, Error
**errp
);
101 bool bdrv_has_blk(BlockDriverState
*bs
);
102 bool bdrv_is_root_node(BlockDriverState
*bs
);
103 int blk_set_perm(BlockBackend
*blk
, uint64_t perm
, uint64_t shared_perm
,
105 void blk_get_perm(BlockBackend
*blk
, uint64_t *perm
, uint64_t *shared_perm
);
107 void blk_set_allow_write_beyond_eof(BlockBackend
*blk
, bool allow
);
108 void blk_set_allow_aio_context_change(BlockBackend
*blk
, bool allow
);
109 void blk_set_disable_request_queuing(BlockBackend
*blk
, bool disable
);
110 void blk_iostatus_enable(BlockBackend
*blk
);
111 bool blk_iostatus_is_enabled(const BlockBackend
*blk
);
112 BlockDeviceIoStatus
blk_iostatus(const BlockBackend
*blk
);
113 void blk_iostatus_disable(BlockBackend
*blk
);
114 void blk_iostatus_reset(BlockBackend
*blk
);
115 void blk_iostatus_set_err(BlockBackend
*blk
, int error
);
116 int blk_attach_dev(BlockBackend
*blk
, DeviceState
*dev
);
117 void blk_detach_dev(BlockBackend
*blk
, DeviceState
*dev
);
118 DeviceState
*blk_get_attached_dev(BlockBackend
*blk
);
119 char *blk_get_attached_dev_id(BlockBackend
*blk
);
120 BlockBackend
*blk_by_dev(void *dev
);
121 BlockBackend
*blk_by_qdev_id(const char *id
, Error
**errp
);
122 void blk_set_dev_ops(BlockBackend
*blk
, const BlockDevOps
*ops
, void *opaque
);
123 int coroutine_fn
blk_co_preadv(BlockBackend
*blk
, int64_t offset
,
124 unsigned int bytes
, QEMUIOVector
*qiov
,
125 BdrvRequestFlags flags
);
126 int coroutine_fn
blk_co_pwritev_part(BlockBackend
*blk
, int64_t offset
,
128 QEMUIOVector
*qiov
, size_t qiov_offset
,
129 BdrvRequestFlags flags
);
130 int coroutine_fn
blk_co_pwritev(BlockBackend
*blk
, int64_t offset
,
131 unsigned int bytes
, QEMUIOVector
*qiov
,
132 BdrvRequestFlags flags
);
134 static inline int coroutine_fn
blk_co_pread(BlockBackend
*blk
, int64_t offset
,
135 unsigned int bytes
, void *buf
,
136 BdrvRequestFlags flags
)
138 QEMUIOVector qiov
= QEMU_IOVEC_INIT_BUF(qiov
, buf
, bytes
);
140 return blk_co_preadv(blk
, offset
, bytes
, &qiov
, flags
);
143 static inline int coroutine_fn
blk_co_pwrite(BlockBackend
*blk
, int64_t offset
,
144 unsigned int bytes
, void *buf
,
145 BdrvRequestFlags flags
)
147 QEMUIOVector qiov
= QEMU_IOVEC_INIT_BUF(qiov
, buf
, bytes
);
149 return blk_co_pwritev(blk
, offset
, bytes
, &qiov
, flags
);
152 int blk_pwrite_zeroes(BlockBackend
*blk
, int64_t offset
,
153 int bytes
, BdrvRequestFlags flags
);
154 BlockAIOCB
*blk_aio_pwrite_zeroes(BlockBackend
*blk
, int64_t offset
,
155 int bytes
, BdrvRequestFlags flags
,
156 BlockCompletionFunc
*cb
, void *opaque
);
157 int blk_make_zero(BlockBackend
*blk
, BdrvRequestFlags flags
);
158 int blk_pread(BlockBackend
*blk
, int64_t offset
, void *buf
, int bytes
);
159 int blk_pwrite(BlockBackend
*blk
, int64_t offset
, const void *buf
, int bytes
,
160 BdrvRequestFlags flags
);
161 int64_t blk_getlength(BlockBackend
*blk
);
162 void blk_get_geometry(BlockBackend
*blk
, uint64_t *nb_sectors_ptr
);
163 int64_t blk_nb_sectors(BlockBackend
*blk
);
164 BlockAIOCB
*blk_aio_preadv(BlockBackend
*blk
, int64_t offset
,
165 QEMUIOVector
*qiov
, BdrvRequestFlags flags
,
166 BlockCompletionFunc
*cb
, void *opaque
);
167 BlockAIOCB
*blk_aio_pwritev(BlockBackend
*blk
, int64_t offset
,
168 QEMUIOVector
*qiov
, BdrvRequestFlags flags
,
169 BlockCompletionFunc
*cb
, void *opaque
);
170 BlockAIOCB
*blk_aio_flush(BlockBackend
*blk
,
171 BlockCompletionFunc
*cb
, void *opaque
);
172 BlockAIOCB
*blk_aio_pdiscard(BlockBackend
*blk
, int64_t offset
, int bytes
,
173 BlockCompletionFunc
*cb
, void *opaque
);
174 void blk_aio_cancel(BlockAIOCB
*acb
);
175 void blk_aio_cancel_async(BlockAIOCB
*acb
);
176 int blk_ioctl(BlockBackend
*blk
, unsigned long int req
, void *buf
);
177 BlockAIOCB
*blk_aio_ioctl(BlockBackend
*blk
, unsigned long int req
, void *buf
,
178 BlockCompletionFunc
*cb
, void *opaque
);
179 int blk_co_pdiscard(BlockBackend
*blk
, int64_t offset
, int bytes
);
180 int blk_co_flush(BlockBackend
*blk
);
181 int blk_flush(BlockBackend
*blk
);
182 int blk_commit_all(void);
183 void blk_inc_in_flight(BlockBackend
*blk
);
184 void blk_dec_in_flight(BlockBackend
*blk
);
185 void blk_drain(BlockBackend
*blk
);
186 void blk_drain_all(void);
187 void blk_set_on_error(BlockBackend
*blk
, BlockdevOnError on_read_error
,
188 BlockdevOnError on_write_error
);
189 BlockdevOnError
blk_get_on_error(BlockBackend
*blk
, bool is_read
);
190 BlockErrorAction
blk_get_error_action(BlockBackend
*blk
, bool is_read
,
192 void blk_error_action(BlockBackend
*blk
, BlockErrorAction action
,
193 bool is_read
, int error
);
194 bool blk_is_read_only(BlockBackend
*blk
);
195 bool blk_is_sg(BlockBackend
*blk
);
196 bool blk_enable_write_cache(BlockBackend
*blk
);
197 void blk_set_enable_write_cache(BlockBackend
*blk
, bool wce
);
198 void blk_invalidate_cache(BlockBackend
*blk
, Error
**errp
);
199 bool blk_is_inserted(BlockBackend
*blk
);
200 bool blk_is_available(BlockBackend
*blk
);
201 void blk_lock_medium(BlockBackend
*blk
, bool locked
);
202 void blk_eject(BlockBackend
*blk
, bool eject_flag
);
203 int blk_get_flags(BlockBackend
*blk
);
204 uint32_t blk_get_request_alignment(BlockBackend
*blk
);
205 uint32_t blk_get_max_transfer(BlockBackend
*blk
);
206 int blk_get_max_iov(BlockBackend
*blk
);
207 void blk_set_guest_block_size(BlockBackend
*blk
, int align
);
208 void *blk_try_blockalign(BlockBackend
*blk
, size_t size
);
209 void *blk_blockalign(BlockBackend
*blk
, size_t size
);
210 bool blk_op_is_blocked(BlockBackend
*blk
, BlockOpType op
, Error
**errp
);
211 void blk_op_unblock(BlockBackend
*blk
, BlockOpType op
, Error
*reason
);
212 void blk_op_block_all(BlockBackend
*blk
, Error
*reason
);
213 void blk_op_unblock_all(BlockBackend
*blk
, Error
*reason
);
214 AioContext
*blk_get_aio_context(BlockBackend
*blk
);
215 int blk_set_aio_context(BlockBackend
*blk
, AioContext
*new_context
,
217 void blk_add_aio_context_notifier(BlockBackend
*blk
,
218 void (*attached_aio_context
)(AioContext
*new_context
, void *opaque
),
219 void (*detach_aio_context
)(void *opaque
), void *opaque
);
220 void blk_remove_aio_context_notifier(BlockBackend
*blk
,
221 void (*attached_aio_context
)(AioContext
*,
223 void (*detach_aio_context
)(void *),
225 void blk_add_remove_bs_notifier(BlockBackend
*blk
, Notifier
*notify
);
226 void blk_add_insert_bs_notifier(BlockBackend
*blk
, Notifier
*notify
);
227 void blk_io_plug(BlockBackend
*blk
);
228 void blk_io_unplug(BlockBackend
*blk
);
229 BlockAcctStats
*blk_get_stats(BlockBackend
*blk
);
230 BlockBackendRootState
*blk_get_root_state(BlockBackend
*blk
);
231 void blk_update_root_state(BlockBackend
*blk
);
232 bool blk_get_detect_zeroes_from_root_state(BlockBackend
*blk
);
233 int blk_get_open_flags_from_root_state(BlockBackend
*blk
);
235 void *blk_aio_get(const AIOCBInfo
*aiocb_info
, BlockBackend
*blk
,
236 BlockCompletionFunc
*cb
, void *opaque
);
237 int coroutine_fn
blk_co_pwrite_zeroes(BlockBackend
*blk
, int64_t offset
,
238 int bytes
, BdrvRequestFlags flags
);
239 int blk_pwrite_compressed(BlockBackend
*blk
, int64_t offset
, const void *buf
,
241 int blk_truncate(BlockBackend
*blk
, int64_t offset
, bool exact
,
242 PreallocMode prealloc
, BdrvRequestFlags flags
, Error
**errp
);
243 int blk_pdiscard(BlockBackend
*blk
, int64_t offset
, int bytes
);
244 int blk_save_vmstate(BlockBackend
*blk
, const uint8_t *buf
,
245 int64_t pos
, int size
);
246 int blk_load_vmstate(BlockBackend
*blk
, uint8_t *buf
, int64_t pos
, int size
);
247 int blk_probe_blocksizes(BlockBackend
*blk
, BlockSizes
*bsz
);
248 int blk_probe_geometry(BlockBackend
*blk
, HDGeometry
*geo
);
249 BlockAIOCB
*blk_abort_aio_request(BlockBackend
*blk
,
250 BlockCompletionFunc
*cb
,
251 void *opaque
, int ret
);
253 void blk_set_io_limits(BlockBackend
*blk
, ThrottleConfig
*cfg
);
254 void blk_io_limits_disable(BlockBackend
*blk
);
255 void blk_io_limits_enable(BlockBackend
*blk
, const char *group
);
256 void blk_io_limits_update_group(BlockBackend
*blk
, const char *group
);
257 void blk_set_force_allow_inactivate(BlockBackend
*blk
);
259 void blk_register_buf(BlockBackend
*blk
, void *host
, size_t size
);
260 void blk_unregister_buf(BlockBackend
*blk
, void *host
);
262 int coroutine_fn
blk_co_copy_range(BlockBackend
*blk_in
, int64_t off_in
,
263 BlockBackend
*blk_out
, int64_t off_out
,
264 int bytes
, BdrvRequestFlags read_flags
,
265 BdrvRequestFlags write_flags
);
267 const BdrvChild
*blk_root(BlockBackend
*blk
);
269 int blk_make_empty(BlockBackend
*blk
, Error
**errp
);