]>
Commit | Line | Data |
---|---|---|
3b491a90 EGE |
1 | /* |
2 | * QEMU System Emulator block driver | |
3 | * | |
4 | * Copyright (c) 2003 Fabrice Bellard | |
5 | * | |
6 | * Permission is hereby granted, free of charge, to any person obtaining a copy | |
7 | * of this software and associated documentation files (the "Software"), to deal | |
8 | * in the Software without restriction, including without limitation the rights | |
9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
10 | * copies of the Software, and to permit persons to whom the Software is | |
11 | * furnished to do so, subject to the following conditions: | |
12 | * | |
13 | * The above copyright notice and this permission notice shall be included in | |
14 | * all copies or substantial portions of the Software. | |
15 | * | |
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | |
19 | * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
22 | * THE SOFTWARE. | |
23 | */ | |
24 | #ifndef BLOCK_GLOBAL_STATE_H | |
25 | #define BLOCK_GLOBAL_STATE_H | |
26 | ||
e2c1c34f MA |
27 | #include "block/block-common.h" |
28 | #include "qemu/coroutine.h" | |
29 | #include "qemu/transactions.h" | |
3b491a90 EGE |
30 | |
31 | /* | |
32 | * Global state (GS) API. These functions run under the BQL. | |
33 | * | |
34 | * If a function modifies the graph, it also uses drain and/or | |
35 | * aio_context_acquire/release to be sure it has unique access. | |
36 | * aio_context locking is needed together with BQL because of | |
37 | * the thread-safe I/O API that concurrently runs and accesses | |
38 | * the graph without the BQL. | |
39 | * | |
40 | * It is important to note that not all of these functions are | |
41 | * necessarily limited to running under the BQL, but they would | |
42 | * require additional auditing and many small thread-safety changes | |
43 | * to move them into the I/O API. Often it's not worth doing that | |
44 | * work since the APIs are only used with the BQL held at the | |
45 | * moment, so they have been placed in the GS API (for now). | |
46 | * | |
47 | * These functions can call any function from this and other categories | |
48 | * (I/O, "I/O or GS", Common), but must be invoked only by other GS APIs. | |
49 | * | |
50 | * All functions in this header must use the macro | |
51 | * GLOBAL_STATE_CODE(); | |
52 | * to catch when they are accidentally called without the BQL. | |
53 | */ | |
54 | ||
55 | void bdrv_init(void); | |
56 | BlockDriver *bdrv_find_protocol(const char *filename, | |
57 | bool allow_protocol_prefix, | |
58 | Error **errp); | |
59 | BlockDriver *bdrv_find_format(const char *format_name); | |
741443eb | 60 | |
4db7ba3b | 61 | int coroutine_fn GRAPH_UNLOCKED |
4ec8df01 KW |
62 | bdrv_co_create(BlockDriver *drv, const char *filename, QemuOpts *opts, |
63 | Error **errp); | |
741443eb | 64 | |
4db7ba3b KW |
65 | int co_wrapper bdrv_create(BlockDriver *drv, const char *filename, |
66 | QemuOpts *opts, Error **errp); | |
4ec8df01 | 67 | |
4db7ba3b | 68 | int coroutine_fn GRAPH_UNLOCKED |
4ec8df01 | 69 | bdrv_co_create_file(const char *filename, QemuOpts *opts, Error **errp); |
3b491a90 EGE |
70 | |
71 | BlockDriverState *bdrv_new(void); | |
72 | int bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top, | |
73 | Error **errp); | |
74 | int bdrv_replace_node(BlockDriverState *from, BlockDriverState *to, | |
75 | Error **errp); | |
76 | int bdrv_replace_child_bs(BdrvChild *child, BlockDriverState *new_bs, | |
77 | Error **errp); | |
78 | BlockDriverState *bdrv_insert_node(BlockDriverState *bs, QDict *node_options, | |
79 | int flags, Error **errp); | |
80 | int bdrv_drop_filter(BlockDriverState *bs, Error **errp); | |
81 | ||
4bee90e9 KW |
82 | BdrvChild * no_coroutine_fn |
83 | bdrv_open_child(const char *filename, QDict *options, const char *bdref_key, | |
84 | BlockDriverState *parent, const BdrvChildClass *child_class, | |
85 | BdrvChildRole child_role, bool allow_none, Error **errp); | |
86 | ||
87 | BdrvChild * coroutine_fn no_co_wrapper | |
88 | bdrv_co_open_child(const char *filename, QDict *options, const char *bdref_key, | |
89 | BlockDriverState *parent, const BdrvChildClass *child_class, | |
90 | BdrvChildRole child_role, bool allow_none, Error **errp); | |
91 | ||
83930780 VSO |
92 | int bdrv_open_file_child(const char *filename, |
93 | QDict *options, const char *bdref_key, | |
94 | BlockDriverState *parent, Error **errp); | |
4bee90e9 KW |
95 | |
96 | BlockDriverState * no_coroutine_fn | |
97 | bdrv_open_blockdev_ref(BlockdevRef *ref, Error **errp); | |
98 | ||
99 | BlockDriverState * coroutine_fn no_co_wrapper | |
100 | bdrv_co_open_blockdev_ref(BlockdevRef *ref, Error **errp); | |
101 | ||
3b491a90 EGE |
102 | int bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd, |
103 | Error **errp); | |
d0f9fd94 KW |
104 | int GRAPH_WRLOCK |
105 | bdrv_set_backing_hd_drained(BlockDriverState *bs, BlockDriverState *backing_hd, | |
106 | Error **errp); | |
107 | ||
3b491a90 EGE |
108 | int bdrv_open_backing_file(BlockDriverState *bs, QDict *parent_options, |
109 | const char *bdref_key, Error **errp); | |
4bee90e9 KW |
110 | |
111 | BlockDriverState * no_coroutine_fn | |
112 | bdrv_open(const char *filename, const char *reference, QDict *options, | |
113 | int flags, Error **errp); | |
114 | ||
115 | BlockDriverState * coroutine_fn no_co_wrapper | |
116 | bdrv_co_open(const char *filename, const char *reference, | |
117 | QDict *options, int flags, Error **errp); | |
118 | ||
3b491a90 EGE |
119 | BlockDriverState *bdrv_new_open_driver_opts(BlockDriver *drv, |
120 | const char *node_name, | |
121 | QDict *options, int flags, | |
122 | Error **errp); | |
123 | BlockDriverState *bdrv_new_open_driver(BlockDriver *drv, const char *node_name, | |
124 | int flags, Error **errp); | |
125 | BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue, | |
126 | BlockDriverState *bs, QDict *options, | |
127 | bool keep_old_opts); | |
128 | void bdrv_reopen_queue_free(BlockReopenQueue *bs_queue); | |
129 | int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp); | |
130 | int bdrv_reopen(BlockDriverState *bs, QDict *opts, bool keep_old_opts, | |
131 | Error **errp); | |
132 | int bdrv_reopen_set_read_only(BlockDriverState *bs, bool read_only, | |
133 | Error **errp); | |
134 | BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs, | |
135 | const char *backing_file); | |
b7cfc7d5 | 136 | void GRAPH_RDLOCK bdrv_refresh_filename(BlockDriverState *bs); |
e19b157f KW |
137 | |
138 | void GRAPH_RDLOCK | |
139 | bdrv_refresh_limits(BlockDriverState *bs, Transaction *tran, Error **errp); | |
140 | ||
3b491a90 | 141 | int bdrv_commit(BlockDriverState *bs); |
0bb79c97 | 142 | int GRAPH_RDLOCK bdrv_make_empty(BdrvChild *c, Error **errp); |
3b491a90 EGE |
143 | int bdrv_change_backing_file(BlockDriverState *bs, const char *backing_file, |
144 | const char *backing_fmt, bool warn); | |
145 | void bdrv_register(BlockDriver *bdrv); | |
146 | int bdrv_drop_intermediate(BlockDriverState *top, BlockDriverState *base, | |
147 | const char *backing_file_str); | |
ad74751f KW |
148 | |
149 | BlockDriverState * GRAPH_RDLOCK | |
150 | bdrv_find_overlay(BlockDriverState *active, BlockDriverState *bs); | |
151 | ||
152 | BlockDriverState * GRAPH_RDLOCK bdrv_find_base(BlockDriverState *bs); | |
9275fc72 KW |
153 | |
154 | int GRAPH_RDLOCK | |
155 | bdrv_freeze_backing_chain(BlockDriverState *bs, BlockDriverState *base, | |
156 | Error **errp); | |
157 | void GRAPH_RDLOCK | |
158 | bdrv_unfreeze_backing_chain(BlockDriverState *bs, BlockDriverState *base); | |
3b491a90 EGE |
159 | |
160 | /* | |
161 | * The units of offset and total_work_size may be chosen arbitrarily by the | |
162 | * block driver; total_work_size may change during the course of the amendment | |
163 | * operation | |
164 | */ | |
165 | typedef void BlockDriverAmendStatusCB(BlockDriverState *bs, int64_t offset, | |
166 | int64_t total_work_size, void *opaque); | |
bd131d67 KW |
167 | int GRAPH_RDLOCK |
168 | bdrv_amend_options(BlockDriverState *bs_new, QemuOpts *opts, | |
169 | BlockDriverAmendStatusCB *status_cb, void *cb_opaque, | |
170 | bool force, Error **errp); | |
3b491a90 EGE |
171 | |
172 | /* check if a named node can be replaced when doing drive-mirror */ | |
533c6e4e KW |
173 | BlockDriverState * GRAPH_RDLOCK |
174 | check_to_replace_node(BlockDriverState *parent_bs, const char *node_name, | |
175 | Error **errp); | |
3b491a90 | 176 | |
2b3912f1 KW |
177 | int no_coroutine_fn GRAPH_RDLOCK |
178 | bdrv_activate(BlockDriverState *bs, Error **errp); | |
da4afaff | 179 | |
2b3912f1 | 180 | int coroutine_fn no_co_wrapper_bdrv_rdlock |
da4afaff KW |
181 | bdrv_co_activate(BlockDriverState *bs, Error **errp); |
182 | ||
3b491a90 EGE |
183 | void bdrv_activate_all(Error **errp); |
184 | int bdrv_inactivate_all(void); | |
185 | ||
186 | int bdrv_flush_all(void); | |
187 | void bdrv_close_all(void); | |
188 | void bdrv_drain_all_begin(void); | |
da0bd744 | 189 | void bdrv_drain_all_begin_nopoll(void); |
3b491a90 EGE |
190 | void bdrv_drain_all_end(void); |
191 | void bdrv_drain_all(void); | |
192 | ||
652b0dd8 SH |
193 | void bdrv_aio_cancel(BlockAIOCB *acb); |
194 | ||
3b491a90 | 195 | int bdrv_has_zero_init_1(BlockDriverState *bs); |
06717986 | 196 | int coroutine_mixed_fn GRAPH_RDLOCK bdrv_has_zero_init(BlockDriverState *bs); |
3b491a90 EGE |
197 | BlockDriverState *bdrv_find_node(const char *node_name); |
198 | BlockDeviceInfoList *bdrv_named_nodes_list(bool flat, Error **errp); | |
15f3f1fe | 199 | XDbgBlockGraph * GRAPH_RDLOCK bdrv_get_xdbg_block_graph(Error **errp); |
3b491a90 EGE |
200 | BlockDriverState *bdrv_lookup_bs(const char *device, |
201 | const char *node_name, | |
202 | Error **errp); | |
79bb7627 KW |
203 | bool GRAPH_RDLOCK |
204 | bdrv_chain_contains(BlockDriverState *top, BlockDriverState *base); | |
205 | ||
3b491a90 EGE |
206 | BlockDriverState *bdrv_next_node(BlockDriverState *bs); |
207 | BlockDriverState *bdrv_next_all_states(BlockDriverState *bs); | |
208 | ||
209 | typedef struct BdrvNextIterator { | |
210 | enum { | |
211 | BDRV_NEXT_BACKEND_ROOTS, | |
212 | BDRV_NEXT_MONITOR_OWNED, | |
213 | } phase; | |
214 | BlockBackend *blk; | |
215 | BlockDriverState *bs; | |
216 | } BdrvNextIterator; | |
217 | ||
2b3912f1 KW |
218 | BlockDriverState * GRAPH_RDLOCK bdrv_first(BdrvNextIterator *it); |
219 | BlockDriverState * GRAPH_RDLOCK bdrv_next(BdrvNextIterator *it); | |
3b491a90 EGE |
220 | void bdrv_next_cleanup(BdrvNextIterator *it); |
221 | ||
222 | BlockDriverState *bdrv_next_monitor_owned(BlockDriverState *bs); | |
223 | void bdrv_iterate_format(void (*it)(void *opaque, const char *name), | |
224 | void *opaque, bool read_only); | |
b7cfc7d5 KW |
225 | |
226 | char * GRAPH_RDLOCK | |
227 | bdrv_get_full_backing_filename(BlockDriverState *bs, Error **errp); | |
228 | ||
229 | char * GRAPH_RDLOCK bdrv_dirname(BlockDriverState *bs, Error **errp); | |
3b491a90 EGE |
230 | |
231 | void bdrv_img_create(const char *filename, const char *fmt, | |
232 | const char *base_filename, const char *base_fmt, | |
233 | char *options, uint64_t img_size, int flags, | |
234 | bool quiet, Error **errp); | |
235 | ||
236 | void bdrv_ref(BlockDriverState *bs); | |
b2ab5f54 KW |
237 | void no_coroutine_fn bdrv_unref(BlockDriverState *bs); |
238 | void coroutine_fn no_co_wrapper bdrv_co_unref(BlockDriverState *bs); | |
ac2ae233 | 239 | void GRAPH_WRLOCK bdrv_schedule_unref(BlockDriverState *bs); |
32a8aba3 KW |
240 | |
241 | void GRAPH_WRLOCK | |
242 | bdrv_unref_child(BlockDriverState *parent, BdrvChild *child); | |
243 | ||
244 | void coroutine_fn no_co_wrapper_bdrv_wrlock | |
245 | bdrv_co_unref_child(BlockDriverState *parent, BdrvChild *child); | |
afdaeb9e KW |
246 | |
247 | BdrvChild * GRAPH_WRLOCK | |
248 | bdrv_attach_child(BlockDriverState *parent_bs, | |
249 | BlockDriverState *child_bs, | |
250 | const char *child_name, | |
251 | const BdrvChildClass *child_class, | |
252 | BdrvChildRole child_role, | |
253 | Error **errp); | |
3b491a90 | 254 | |
277f2007 KW |
255 | bool GRAPH_RDLOCK |
256 | bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp); | |
257 | ||
3b491a90 EGE |
258 | void bdrv_op_block(BlockDriverState *bs, BlockOpType op, Error *reason); |
259 | void bdrv_op_unblock(BlockDriverState *bs, BlockOpType op, Error *reason); | |
260 | void bdrv_op_block_all(BlockDriverState *bs, Error *reason); | |
261 | void bdrv_op_unblock_all(BlockDriverState *bs, Error *reason); | |
262 | bool bdrv_op_blocker_is_empty(BlockDriverState *bs); | |
263 | ||
264 | int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event, | |
265 | const char *tag); | |
266 | int bdrv_debug_remove_breakpoint(BlockDriverState *bs, const char *tag); | |
267 | int bdrv_debug_resume(BlockDriverState *bs, const char *tag); | |
268 | bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag); | |
269 | ||
270 | /** | |
271 | * Locks the AioContext of @bs if it's not the current AioContext. This avoids | |
272 | * double locking which could lead to deadlocks: This is a coroutine_fn, so we | |
273 | * know we already own the lock of the current AioContext. | |
274 | * | |
275 | * May only be called in the main thread. | |
276 | */ | |
277 | void coroutine_fn bdrv_co_lock(BlockDriverState *bs); | |
278 | ||
279 | /** | |
280 | * Unlocks the AioContext of @bs if it's not the current AioContext. | |
281 | */ | |
282 | void coroutine_fn bdrv_co_unlock(BlockDriverState *bs); | |
283 | ||
7e8c182f | 284 | bool bdrv_child_change_aio_context(BdrvChild *c, AioContext *ctx, |
e08cc001 | 285 | GHashTable *visited, Transaction *tran, |
7e8c182f | 286 | Error **errp); |
a41cfda1 EGE |
287 | int bdrv_try_change_aio_context(BlockDriverState *bs, AioContext *ctx, |
288 | BdrvChild *ignore_child, Error **errp); | |
3b491a90 | 289 | |
221caadc | 290 | int GRAPH_RDLOCK bdrv_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz); |
3b491a90 EGE |
291 | int bdrv_probe_geometry(BlockDriverState *bs, HDGeometry *geo); |
292 | ||
9def6082 KW |
293 | void GRAPH_WRLOCK |
294 | bdrv_add_child(BlockDriverState *parent, BlockDriverState *child, Error **errp); | |
295 | ||
296 | void GRAPH_WRLOCK | |
297 | bdrv_del_child(BlockDriverState *parent, BdrvChild *child, Error **errp); | |
3b491a90 EGE |
298 | |
299 | /** | |
300 | * | |
301 | * bdrv_register_buf/bdrv_unregister_buf: | |
302 | * | |
303 | * Register/unregister a buffer for I/O. For example, VFIO drivers are | |
304 | * interested to know the memory areas that would later be used for I/O, so | |
305 | * that they can prepare IOMMU mapping etc., to get better performance. | |
4f384011 SH |
306 | * |
307 | * Buffers must not overlap and they must be unregistered with the same <host, | |
308 | * size> values that they were registered with. | |
f4ec04ba SH |
309 | * |
310 | * Returns: true on success, false on failure | |
3b491a90 | 311 | */ |
f4ec04ba SH |
312 | bool bdrv_register_buf(BlockDriverState *bs, void *host, size_t size, |
313 | Error **errp); | |
4f384011 | 314 | void bdrv_unregister_buf(BlockDriverState *bs, void *host, size_t size); |
3b491a90 EGE |
315 | |
316 | void bdrv_cancel_in_flight(BlockDriverState *bs); | |
317 | ||
318 | #endif /* BLOCK_GLOBAL_STATE_H */ |