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 */
74 typedef struct BlockBackendPublic
{
75 /* throttled_reqs_lock protects the CoQueues for throttled requests. */
76 CoMutex throttled_reqs_lock
;
77 CoQueue throttled_reqs
[2];
79 /* Nonzero if the I/O limits are currently being ignored; generally
80 * it is zero. Accessed with atomic operations.
82 unsigned int io_limits_disabled
;
84 /* The following fields are protected by the ThrottleGroup lock.
85 * See the ThrottleGroup documentation for details.
86 * throttle_state tells us if I/O limits are configured. */
87 ThrottleState
*throttle_state
;
88 ThrottleTimers throttle_timers
;
89 unsigned pending_reqs
[2];
90 QLIST_ENTRY(BlockBackendPublic
) round_robin
;
93 BlockBackend
*blk_new(uint64_t perm
, uint64_t shared_perm
);
94 BlockBackend
*blk_new_open(const char *filename
, const char *reference
,
95 QDict
*options
, int flags
, Error
**errp
);
96 int blk_get_refcnt(BlockBackend
*blk
);
97 void blk_ref(BlockBackend
*blk
);
98 void blk_unref(BlockBackend
*blk
);
99 void blk_remove_all_bs(void);
100 const char *blk_name(const BlockBackend
*blk
);
101 BlockBackend
*blk_by_name(const char *name
);
102 BlockBackend
*blk_next(BlockBackend
*blk
);
103 BlockBackend
*blk_all_next(BlockBackend
*blk
);
104 bool monitor_add_blk(BlockBackend
*blk
, const char *name
, Error
**errp
);
105 void monitor_remove_blk(BlockBackend
*blk
);
107 BlockBackendPublic
*blk_get_public(BlockBackend
*blk
);
108 BlockBackend
*blk_by_public(BlockBackendPublic
*public);
110 BlockDriverState
*blk_bs(BlockBackend
*blk
);
111 void blk_remove_bs(BlockBackend
*blk
);
112 int blk_insert_bs(BlockBackend
*blk
, BlockDriverState
*bs
, Error
**errp
);
113 bool bdrv_has_blk(BlockDriverState
*bs
);
114 bool bdrv_is_root_node(BlockDriverState
*bs
);
115 int blk_set_perm(BlockBackend
*blk
, uint64_t perm
, uint64_t shared_perm
,
117 void blk_get_perm(BlockBackend
*blk
, uint64_t *perm
, uint64_t *shared_perm
);
119 void blk_set_allow_write_beyond_eof(BlockBackend
*blk
, bool allow
);
120 void blk_iostatus_enable(BlockBackend
*blk
);
121 bool blk_iostatus_is_enabled(const BlockBackend
*blk
);
122 BlockDeviceIoStatus
blk_iostatus(const BlockBackend
*blk
);
123 void blk_iostatus_disable(BlockBackend
*blk
);
124 void blk_iostatus_reset(BlockBackend
*blk
);
125 void blk_iostatus_set_err(BlockBackend
*blk
, int error
);
126 int blk_attach_dev(BlockBackend
*blk
, DeviceState
*dev
);
127 void blk_attach_dev_legacy(BlockBackend
*blk
, void *dev
);
128 void blk_detach_dev(BlockBackend
*blk
, void *dev
);
129 void *blk_get_attached_dev(BlockBackend
*blk
);
130 char *blk_get_attached_dev_id(BlockBackend
*blk
);
131 BlockBackend
*blk_by_dev(void *dev
);
132 BlockBackend
*blk_by_qdev_id(const char *id
, Error
**errp
);
133 void blk_set_dev_ops(BlockBackend
*blk
, const BlockDevOps
*ops
, void *opaque
);
134 int blk_pread_unthrottled(BlockBackend
*blk
, int64_t offset
, uint8_t *buf
,
136 int coroutine_fn
blk_co_preadv(BlockBackend
*blk
, int64_t offset
,
137 unsigned int bytes
, QEMUIOVector
*qiov
,
138 BdrvRequestFlags flags
);
139 int coroutine_fn
blk_co_pwritev(BlockBackend
*blk
, int64_t offset
,
140 unsigned int bytes
, QEMUIOVector
*qiov
,
141 BdrvRequestFlags flags
);
142 int blk_pwrite_zeroes(BlockBackend
*blk
, int64_t offset
,
143 int bytes
, BdrvRequestFlags flags
);
144 BlockAIOCB
*blk_aio_pwrite_zeroes(BlockBackend
*blk
, int64_t offset
,
145 int bytes
, BdrvRequestFlags flags
,
146 BlockCompletionFunc
*cb
, void *opaque
);
147 int blk_make_zero(BlockBackend
*blk
, BdrvRequestFlags flags
);
148 int blk_pread(BlockBackend
*blk
, int64_t offset
, void *buf
, int bytes
);
149 int blk_pwrite(BlockBackend
*blk
, int64_t offset
, const void *buf
, int bytes
,
150 BdrvRequestFlags flags
);
151 int64_t blk_getlength(BlockBackend
*blk
);
152 void blk_get_geometry(BlockBackend
*blk
, uint64_t *nb_sectors_ptr
);
153 int64_t blk_nb_sectors(BlockBackend
*blk
);
154 BlockAIOCB
*blk_aio_preadv(BlockBackend
*blk
, int64_t offset
,
155 QEMUIOVector
*qiov
, BdrvRequestFlags flags
,
156 BlockCompletionFunc
*cb
, void *opaque
);
157 BlockAIOCB
*blk_aio_pwritev(BlockBackend
*blk
, int64_t offset
,
158 QEMUIOVector
*qiov
, BdrvRequestFlags flags
,
159 BlockCompletionFunc
*cb
, void *opaque
);
160 BlockAIOCB
*blk_aio_flush(BlockBackend
*blk
,
161 BlockCompletionFunc
*cb
, void *opaque
);
162 BlockAIOCB
*blk_aio_pdiscard(BlockBackend
*blk
, int64_t offset
, int bytes
,
163 BlockCompletionFunc
*cb
, void *opaque
);
164 void blk_aio_cancel(BlockAIOCB
*acb
);
165 void blk_aio_cancel_async(BlockAIOCB
*acb
);
166 int blk_co_ioctl(BlockBackend
*blk
, unsigned long int req
, void *buf
);
167 int blk_ioctl(BlockBackend
*blk
, unsigned long int req
, void *buf
);
168 BlockAIOCB
*blk_aio_ioctl(BlockBackend
*blk
, unsigned long int req
, void *buf
,
169 BlockCompletionFunc
*cb
, void *opaque
);
170 int blk_co_pdiscard(BlockBackend
*blk
, int64_t offset
, int bytes
);
171 int blk_co_flush(BlockBackend
*blk
);
172 int blk_flush(BlockBackend
*blk
);
173 int blk_commit_all(void);
174 void blk_drain(BlockBackend
*blk
);
175 void blk_drain_all(void);
176 void blk_set_on_error(BlockBackend
*blk
, BlockdevOnError on_read_error
,
177 BlockdevOnError on_write_error
);
178 BlockdevOnError
blk_get_on_error(BlockBackend
*blk
, bool is_read
);
179 BlockErrorAction
blk_get_error_action(BlockBackend
*blk
, bool is_read
,
181 void blk_error_action(BlockBackend
*blk
, BlockErrorAction action
,
182 bool is_read
, int error
);
183 int blk_is_read_only(BlockBackend
*blk
);
184 int blk_is_sg(BlockBackend
*blk
);
185 int blk_enable_write_cache(BlockBackend
*blk
);
186 void blk_set_enable_write_cache(BlockBackend
*blk
, bool wce
);
187 void blk_invalidate_cache(BlockBackend
*blk
, Error
**errp
);
188 bool blk_is_inserted(BlockBackend
*blk
);
189 bool blk_is_available(BlockBackend
*blk
);
190 void blk_lock_medium(BlockBackend
*blk
, bool locked
);
191 void blk_eject(BlockBackend
*blk
, bool eject_flag
);
192 int blk_get_flags(BlockBackend
*blk
);
193 uint32_t blk_get_max_transfer(BlockBackend
*blk
);
194 int blk_get_max_iov(BlockBackend
*blk
);
195 void blk_set_guest_block_size(BlockBackend
*blk
, int align
);
196 void *blk_try_blockalign(BlockBackend
*blk
, size_t size
);
197 void *blk_blockalign(BlockBackend
*blk
, size_t size
);
198 bool blk_op_is_blocked(BlockBackend
*blk
, BlockOpType op
, Error
**errp
);
199 void blk_op_unblock(BlockBackend
*blk
, BlockOpType op
, Error
*reason
);
200 void blk_op_block_all(BlockBackend
*blk
, Error
*reason
);
201 void blk_op_unblock_all(BlockBackend
*blk
, Error
*reason
);
202 AioContext
*blk_get_aio_context(BlockBackend
*blk
);
203 void blk_set_aio_context(BlockBackend
*blk
, AioContext
*new_context
);
204 void blk_add_aio_context_notifier(BlockBackend
*blk
,
205 void (*attached_aio_context
)(AioContext
*new_context
, void *opaque
),
206 void (*detach_aio_context
)(void *opaque
), void *opaque
);
207 void blk_remove_aio_context_notifier(BlockBackend
*blk
,
208 void (*attached_aio_context
)(AioContext
*,
210 void (*detach_aio_context
)(void *),
212 void blk_add_remove_bs_notifier(BlockBackend
*blk
, Notifier
*notify
);
213 void blk_add_insert_bs_notifier(BlockBackend
*blk
, Notifier
*notify
);
214 void blk_io_plug(BlockBackend
*blk
);
215 void blk_io_unplug(BlockBackend
*blk
);
216 BlockAcctStats
*blk_get_stats(BlockBackend
*blk
);
217 BlockBackendRootState
*blk_get_root_state(BlockBackend
*blk
);
218 void blk_update_root_state(BlockBackend
*blk
);
219 bool blk_get_detect_zeroes_from_root_state(BlockBackend
*blk
);
220 int blk_get_open_flags_from_root_state(BlockBackend
*blk
);
222 void *blk_aio_get(const AIOCBInfo
*aiocb_info
, BlockBackend
*blk
,
223 BlockCompletionFunc
*cb
, void *opaque
);
224 int coroutine_fn
blk_co_pwrite_zeroes(BlockBackend
*blk
, int64_t offset
,
225 int bytes
, BdrvRequestFlags flags
);
226 int blk_pwrite_compressed(BlockBackend
*blk
, int64_t offset
, const void *buf
,
228 int blk_truncate(BlockBackend
*blk
, int64_t offset
, PreallocMode prealloc
,
230 int blk_pdiscard(BlockBackend
*blk
, int64_t offset
, int bytes
);
231 int blk_save_vmstate(BlockBackend
*blk
, const uint8_t *buf
,
232 int64_t pos
, int size
);
233 int blk_load_vmstate(BlockBackend
*blk
, uint8_t *buf
, int64_t pos
, int size
);
234 int blk_probe_blocksizes(BlockBackend
*blk
, BlockSizes
*bsz
);
235 int blk_probe_geometry(BlockBackend
*blk
, HDGeometry
*geo
);
236 BlockAIOCB
*blk_abort_aio_request(BlockBackend
*blk
,
237 BlockCompletionFunc
*cb
,
238 void *opaque
, int ret
);
240 void blk_set_io_limits(BlockBackend
*blk
, ThrottleConfig
*cfg
);
241 void blk_io_limits_disable(BlockBackend
*blk
);
242 void blk_io_limits_enable(BlockBackend
*blk
, const char *group
);
243 void blk_io_limits_update_group(BlockBackend
*blk
, const char *group
);