[mirror_qemu.git] / include / block / block-global-state.h

/*
 * QEMU System Emulator block driver
 *
 * Copyright (c) 2003 Fabrice Bellard
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
#ifndef BLOCK_GLOBAL_STATE_H
#define BLOCK_GLOBAL_STATE_H

#include "block/block-common.h"
#include "qemu/coroutine.h"
#include "qemu/transactions.h"

/*
 * Global state (GS) API. These functions run under the BQL.
 *
 * If a function modifies the graph, it also uses drain and/or
 * aio_context_acquire/release to be sure it has unique access.
 * aio_context locking is needed together with BQL because of
 * the thread-safe I/O API that concurrently runs and accesses
 * the graph without the BQL.
 *
 * It is important to note that not all of these functions are
 * necessarily limited to running under the BQL, but they would
 * require additional auditing and many small thread-safety changes
 * to move them into the I/O API. Often it's not worth doing that
 * work since the APIs are only used with the BQL held at the
 * moment, so they have been placed in the GS API (for now).
 *
 * These functions can call any function from this and other categories
 * (I/O, "I/O or GS", Common), but must be invoked only by other GS APIs.
 *
 * All functions in this header must use the macro
 * GLOBAL_STATE_CODE();
 * to catch when they are accidentally called without the BQL.
 */

void bdrv_init(void);
BlockDriver *bdrv_find_protocol(const char *filename,
                                bool allow_protocol_prefix,
                                Error **errp);
BlockDriver *bdrv_find_format(const char *format_name);

int coroutine_fn bdrv_co_create(BlockDriver *drv, const char *filename,
                                QemuOpts *opts, Error **errp);
int co_wrapper bdrv_create(BlockDriver *drv, const char *filename,
                           QemuOpts *opts, Error **errp);

int coroutine_fn bdrv_co_create_file(const char *filename, QemuOpts *opts,
                                     Error **errp);

BlockDriverState *bdrv_new(void);
int bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top,
                Error **errp);
int bdrv_replace_node(BlockDriverState *from, BlockDriverState *to,
                      Error **errp);
int bdrv_replace_child_bs(BdrvChild *child, BlockDriverState *new_bs,
                          Error **errp);
BlockDriverState *bdrv_insert_node(BlockDriverState *bs, QDict *node_options,
                                   int flags, Error **errp);
int bdrv_drop_filter(BlockDriverState *bs, Error **errp);

BdrvChild *bdrv_open_child(const char *filename,
                           QDict *options, const char *bdref_key,
                           BlockDriverState *parent,
                           const BdrvChildClass *child_class,
                           BdrvChildRole child_role,
                           bool allow_none, Error **errp);
int bdrv_open_file_child(const char *filename,
                         QDict *options, const char *bdref_key,
                         BlockDriverState *parent, Error **errp);
BlockDriverState *bdrv_open_blockdev_ref(BlockdevRef *ref, Error **errp);
int bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd,
                        Error **errp);
int bdrv_set_backing_hd_drained(BlockDriverState *bs,
                                BlockDriverState *backing_hd,
                                Error **errp);
int bdrv_open_backing_file(BlockDriverState *bs, QDict *parent_options,
                           const char *bdref_key, Error **errp);
BlockDriverState *bdrv_open(const char *filename, const char *reference,
                            QDict *options, int flags, Error **errp);
BlockDriverState *bdrv_new_open_driver_opts(BlockDriver *drv,
                                            const char *node_name,
                                            QDict *options, int flags,
                                            Error **errp);
BlockDriverState *bdrv_new_open_driver(BlockDriver *drv, const char *node_name,
                                       int flags, Error **errp);
BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
                                    BlockDriverState *bs, QDict *options,
                                    bool keep_old_opts);
void bdrv_reopen_queue_free(BlockReopenQueue *bs_queue);
int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp);
int bdrv_reopen(BlockDriverState *bs, QDict *opts, bool keep_old_opts,
                Error **errp);
int bdrv_reopen_set_read_only(BlockDriverState *bs, bool read_only,
                              Error **errp);
BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
                                          const char *backing_file);
void bdrv_refresh_filename(BlockDriverState *bs);
void bdrv_refresh_limits(BlockDriverState *bs, Transaction *tran, Error **errp);
int bdrv_commit(BlockDriverState *bs);
int bdrv_make_empty(BdrvChild *c, Error **errp);
int bdrv_change_backing_file(BlockDriverState *bs, const char *backing_file,
                             const char *backing_fmt, bool warn);
void bdrv_register(BlockDriver *bdrv);
int bdrv_drop_intermediate(BlockDriverState *top, BlockDriverState *base,
                           const char *backing_file_str);
BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
                                    BlockDriverState *bs);
BlockDriverState *bdrv_find_base(BlockDriverState *bs);
bool bdrv_is_backing_chain_frozen(BlockDriverState *bs, BlockDriverState *base,
                                  Error **errp);
int bdrv_freeze_backing_chain(BlockDriverState *bs, BlockDriverState *base,
                              Error **errp);
void bdrv_unfreeze_backing_chain(BlockDriverState *bs, BlockDriverState *base);

/*
 * The units of offset and total_work_size may be chosen arbitrarily by the
 * block driver; total_work_size may change during the course of the amendment
 * operation
 */
typedef void BlockDriverAmendStatusCB(BlockDriverState *bs, int64_t offset,
                                      int64_t total_work_size, void *opaque);
int bdrv_amend_options(BlockDriverState *bs_new, QemuOpts *opts,
                       BlockDriverAmendStatusCB *status_cb, void *cb_opaque,
                       bool force,
                       Error **errp);

/* check if a named node can be replaced when doing drive-mirror */
BlockDriverState *check_to_replace_node(BlockDriverState *parent_bs,
                                        const char *node_name, Error **errp);

int bdrv_activate(BlockDriverState *bs, Error **errp);
void bdrv_activate_all(Error **errp);
int bdrv_inactivate_all(void);

int bdrv_flush_all(void);
void bdrv_close_all(void);
void bdrv_drain_all_begin(void);
void bdrv_drain_all_begin_nopoll(void);
void bdrv_drain_all_end(void);
void bdrv_drain_all(void);

int bdrv_has_zero_init_1(BlockDriverState *bs);
int bdrv_has_zero_init(BlockDriverState *bs);
BlockDriverState *bdrv_find_node(const char *node_name);
BlockDeviceInfoList *bdrv_named_nodes_list(bool flat, Error **errp);
XDbgBlockGraph *bdrv_get_xdbg_block_graph(Error **errp);
BlockDriverState *bdrv_lookup_bs(const char *device,
                                 const char *node_name,
                                 Error **errp);
bool bdrv_chain_contains(BlockDriverState *top, BlockDriverState *base);
BlockDriverState *bdrv_next_node(BlockDriverState *bs);
BlockDriverState *bdrv_next_all_states(BlockDriverState *bs);

typedef struct BdrvNextIterator {
    enum {
        BDRV_NEXT_BACKEND_ROOTS,
        BDRV_NEXT_MONITOR_OWNED,
    } phase;
    BlockBackend *blk;
    BlockDriverState *bs;
} BdrvNextIterator;

BlockDriverState *bdrv_first(BdrvNextIterator *it);
BlockDriverState *bdrv_next(BdrvNextIterator *it);
void bdrv_next_cleanup(BdrvNextIterator *it);

BlockDriverState *bdrv_next_monitor_owned(BlockDriverState *bs);
void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
                         void *opaque, bool read_only);
char *bdrv_get_full_backing_filename(BlockDriverState *bs, Error **errp);
char *bdrv_dirname(BlockDriverState *bs, Error **errp);

void bdrv_img_create(const char *filename, const char *fmt,
                     const char *base_filename, const char *base_fmt,
                     char *options, uint64_t img_size, int flags,
                     bool quiet, Error **errp);

void bdrv_ref(BlockDriverState *bs);
void bdrv_unref(BlockDriverState *bs);
void bdrv_unref_child(BlockDriverState *parent, BdrvChild *child);
BdrvChild *bdrv_attach_child(BlockDriverState *parent_bs,
                             BlockDriverState *child_bs,
                             const char *child_name,
                             const BdrvChildClass *child_class,
                             BdrvChildRole child_role,
                             Error **errp);

bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp);
void bdrv_op_block(BlockDriverState *bs, BlockOpType op, Error *reason);
void bdrv_op_unblock(BlockDriverState *bs, BlockOpType op, Error *reason);
void bdrv_op_block_all(BlockDriverState *bs, Error *reason);
void bdrv_op_unblock_all(BlockDriverState *bs, Error *reason);
bool bdrv_op_blocker_is_empty(BlockDriverState *bs);

int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event,
                           const char *tag);
int bdrv_debug_remove_breakpoint(BlockDriverState *bs, const char *tag);
int bdrv_debug_resume(BlockDriverState *bs, const char *tag);
bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag);

/**
 * Locks the AioContext of @bs if it's not the current AioContext. This avoids
 * double locking which could lead to deadlocks: This is a coroutine_fn, so we
 * know we already own the lock of the current AioContext.
 *
 * May only be called in the main thread.
 */
void coroutine_fn bdrv_co_lock(BlockDriverState *bs);

/**
 * Unlocks the AioContext of @bs if it's not the current AioContext.
 */
void coroutine_fn bdrv_co_unlock(BlockDriverState *bs);

bool bdrv_child_change_aio_context(BdrvChild *c, AioContext *ctx,
                                   GHashTable *visited, Transaction *tran,
                                   Error **errp);
int bdrv_try_change_aio_context(BlockDriverState *bs, AioContext *ctx,
                                BdrvChild *ignore_child, Error **errp);

int bdrv_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz);
int bdrv_probe_geometry(BlockDriverState *bs, HDGeometry *geo);

void bdrv_add_child(BlockDriverState *parent, BlockDriverState *child,
                    Error **errp);
void bdrv_del_child(BlockDriverState *parent, BdrvChild *child, Error **errp);

/**
 *
 * bdrv_register_buf/bdrv_unregister_buf:
 *
 * Register/unregister a buffer for I/O. For example, VFIO drivers are
 * interested to know the memory areas that would later be used for I/O, so
 * that they can prepare IOMMU mapping etc., to get better performance.
 *
 * Buffers must not overlap and they must be unregistered with the same <host,
 * size> values that they were registered with.
 *
 * Returns: true on success, false on failure
 */
bool bdrv_register_buf(BlockDriverState *bs, void *host, size_t size,
                       Error **errp);
void bdrv_unregister_buf(BlockDriverState *bs, void *host, size_t size);

void bdrv_cancel_in_flight(BlockDriverState *bs);

#endif /* BLOCK_GLOBAL_STATE_H */
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 EGE	60
	61	int coroutine_fn bdrv_co_create(BlockDriver drv, const char filename,
	62	QemuOpts opts, Error *errp);
	63	int co_wrapper bdrv_create(BlockDriver drv, const char filename,
	64	QemuOpts opts, Error *errp);
	65
2475a0d0 EGE	66	int coroutine_fn bdrv_co_create_file(const char filename, QemuOpts opts,
2475a0d0 EGE	67	Error **errp);
3b491a90 EGE	68
	69	BlockDriverState *bdrv_new(void);
	70	int bdrv_append(BlockDriverState bs_new, BlockDriverState bs_top,
	71	Error **errp);
	72	int bdrv_replace_node(BlockDriverState from, BlockDriverState to,
	73	Error **errp);
	74	int bdrv_replace_child_bs(BdrvChild child, BlockDriverState new_bs,
	75	Error **errp);
	76	BlockDriverState bdrv_insert_node(BlockDriverState bs, QDict *node_options,
	77	int flags, Error **errp);
	78	int bdrv_drop_filter(BlockDriverState bs, Error *errp);
	79
	80	BdrvChild bdrv_open_child(const char filename,
	81	QDict options, const char bdref_key,
	82	BlockDriverState *parent,
	83	const BdrvChildClass *child_class,
	84	BdrvChildRole child_role,
	85	bool allow_none, Error **errp);
83930780 VSO	86	int bdrv_open_file_child(const char *filename,
	87	QDict options, const char bdref_key,
	88	BlockDriverState parent, Error *errp);
3b491a90 EGE	89	BlockDriverState bdrv_open_blockdev_ref(BlockdevRef ref, Error **errp);
	90	int bdrv_set_backing_hd(BlockDriverState bs, BlockDriverState backing_hd,
	91	Error **errp);
92140b9f KW	92	int bdrv_set_backing_hd_drained(BlockDriverState *bs,
	93	BlockDriverState *backing_hd,
	94	Error **errp);
3b491a90 EGE	95	int bdrv_open_backing_file(BlockDriverState bs, QDict parent_options,
	96	const char bdref_key, Error *errp);
	97	BlockDriverState bdrv_open(const char filename, const char *reference,
	98	QDict options, int flags, Error *errp);
	99	BlockDriverState bdrv_new_open_driver_opts(BlockDriver drv,
	100	const char *node_name,
	101	QDict *options, int flags,
	102	Error **errp);
	103	BlockDriverState bdrv_new_open_driver(BlockDriver drv, const char *node_name,
	104	int flags, Error **errp);
	105	BlockReopenQueue bdrv_reopen_queue(BlockReopenQueue bs_queue,
	106	BlockDriverState bs, QDict options,
	107	bool keep_old_opts);
	108	void bdrv_reopen_queue_free(BlockReopenQueue *bs_queue);
	109	int bdrv_reopen_multiple(BlockReopenQueue bs_queue, Error *errp);
	110	int bdrv_reopen(BlockDriverState bs, QDict opts, bool keep_old_opts,
	111	Error **errp);
	112	int bdrv_reopen_set_read_only(BlockDriverState *bs, bool read_only,
	113	Error **errp);
	114	BlockDriverState bdrv_find_backing_image(BlockDriverState bs,
	115	const char *backing_file);
	116	void bdrv_refresh_filename(BlockDriverState *bs);
	117	void bdrv_refresh_limits(BlockDriverState bs, Transaction tran, Error **errp);
	118	int bdrv_commit(BlockDriverState *bs);
	119	int bdrv_make_empty(BdrvChild c, Error *errp);
	120	int bdrv_change_backing_file(BlockDriverState bs, const char backing_file,
	121	const char *backing_fmt, bool warn);
	122	void bdrv_register(BlockDriver *bdrv);
	123	int bdrv_drop_intermediate(BlockDriverState top, BlockDriverState base,
	124	const char *backing_file_str);
	125	BlockDriverState bdrv_find_overlay(BlockDriverState active,
	126	BlockDriverState *bs);
	127	BlockDriverState bdrv_find_base(BlockDriverState bs);
	128	bool bdrv_is_backing_chain_frozen(BlockDriverState bs, BlockDriverState base,
	129	Error **errp);
	130	int bdrv_freeze_backing_chain(BlockDriverState bs, BlockDriverState base,
	131	Error **errp);
	132	void bdrv_unfreeze_backing_chain(BlockDriverState bs, BlockDriverState base);
	133
	134	/*
	135	* The units of offset and total_work_size may be chosen arbitrarily by the
	136	* block driver; total_work_size may change during the course of the amendment
	137	* operation
	138	*/
	139	typedef void BlockDriverAmendStatusCB(BlockDriverState *bs, int64_t offset,
	140	int64_t total_work_size, void *opaque);
	141	int bdrv_amend_options(BlockDriverState bs_new, QemuOpts opts,
	142	BlockDriverAmendStatusCB status_cb, void cb_opaque,
	143	bool force,
	144	Error **errp);
	145
	146	/* check if a named node can be replaced when doing drive-mirror */
	147	BlockDriverState check_to_replace_node(BlockDriverState parent_bs,
	148	const char node_name, Error *errp);
	149
	150	int bdrv_activate(BlockDriverState bs, Error *errp);
	151	void bdrv_activate_all(Error **errp);
	152	int bdrv_inactivate_all(void);
	153
	154	int bdrv_flush_all(void);
	155	void bdrv_close_all(void);
	156	void bdrv_drain_all_begin(void);
da0bd744	157	void bdrv_drain_all_begin_nopoll(void);
3b491a90 EGE	158	void bdrv_drain_all_end(void);
	159	void bdrv_drain_all(void);
	160
	161	int bdrv_has_zero_init_1(BlockDriverState *bs);
	162	int bdrv_has_zero_init(BlockDriverState *bs);
	163	BlockDriverState bdrv_find_node(const char node_name);
	164	BlockDeviceInfoList bdrv_named_nodes_list(bool flat, Error *errp);
	165	XDbgBlockGraph bdrv_get_xdbg_block_graph(Error *errp);
	166	BlockDriverState bdrv_lookup_bs(const char device,
	167	const char *node_name,
	168	Error **errp);
	169	bool bdrv_chain_contains(BlockDriverState top, BlockDriverState base);
	170	BlockDriverState bdrv_next_node(BlockDriverState bs);
	171	BlockDriverState bdrv_next_all_states(BlockDriverState bs);
	172
	173	typedef struct BdrvNextIterator {
	174	enum {
	175	BDRV_NEXT_BACKEND_ROOTS,
	176	BDRV_NEXT_MONITOR_OWNED,
	177	} phase;
	178	BlockBackend *blk;
	179	BlockDriverState *bs;
	180	} BdrvNextIterator;
	181
	182	BlockDriverState bdrv_first(BdrvNextIterator it);
	183	BlockDriverState bdrv_next(BdrvNextIterator it);
	184	void bdrv_next_cleanup(BdrvNextIterator *it);
	185
	186	BlockDriverState bdrv_next_monitor_owned(BlockDriverState bs);
	187	void bdrv_iterate_format(void (it)(void opaque, const char *name),
	188	void *opaque, bool read_only);
3b491a90 EGE	189	char bdrv_get_full_backing_filename(BlockDriverState bs, Error **errp);
	190	char bdrv_dirname(BlockDriverState bs, Error **errp);
	191
	192	void bdrv_img_create(const char filename, const char fmt,
	193	const char base_filename, const char base_fmt,
	194	char *options, uint64_t img_size, int flags,
	195	bool quiet, Error **errp);
	196
	197	void bdrv_ref(BlockDriverState *bs);
	198	void bdrv_unref(BlockDriverState *bs);
	199	void bdrv_unref_child(BlockDriverState parent, BdrvChild child);
	200	BdrvChild bdrv_attach_child(BlockDriverState parent_bs,
	201	BlockDriverState *child_bs,
	202	const char *child_name,
	203	const BdrvChildClass *child_class,
	204	BdrvChildRole child_role,
	205	Error **errp);
	206
	207	bool bdrv_op_is_blocked(BlockDriverState bs, BlockOpType op, Error *errp);
	208	void bdrv_op_block(BlockDriverState bs, BlockOpType op, Error reason);
	209	void bdrv_op_unblock(BlockDriverState bs, BlockOpType op, Error reason);
	210	void bdrv_op_block_all(BlockDriverState bs, Error reason);
	211	void bdrv_op_unblock_all(BlockDriverState bs, Error reason);
	212	bool bdrv_op_blocker_is_empty(BlockDriverState *bs);
	213
	214	int bdrv_debug_breakpoint(BlockDriverState bs, const char event,
	215	const char *tag);
	216	int bdrv_debug_remove_breakpoint(BlockDriverState bs, const char tag);
	217	int bdrv_debug_resume(BlockDriverState bs, const char tag);
	218	bool bdrv_debug_is_suspended(BlockDriverState bs, const char tag);
	219
	220	/**
	221	* Locks the AioContext of @bs if it's not the current AioContext. This avoids
	222	* double locking which could lead to deadlocks: This is a coroutine_fn, so we
	223	* know we already own the lock of the current AioContext.
	224	*
	225	* May only be called in the main thread.
	226	*/
	227	void coroutine_fn bdrv_co_lock(BlockDriverState *bs);
	228
	229	/**
	230	* Unlocks the AioContext of @bs if it's not the current AioContext.
	231	*/
	232	void coroutine_fn bdrv_co_unlock(BlockDriverState *bs);
	233
7e8c182f	234	bool bdrv_child_change_aio_context(BdrvChild c, AioContext ctx,
e08cc001	235	GHashTable visited, Transaction tran,
7e8c182f	236	Error **errp);
a41cfda1 EGE	237	int bdrv_try_change_aio_context(BlockDriverState bs, AioContext ctx,
a41cfda1 EGE	238	BdrvChild ignore_child, Error *errp);
3b491a90 EGE	239
	240	int bdrv_probe_blocksizes(BlockDriverState bs, BlockSizes bsz);
	241	int bdrv_probe_geometry(BlockDriverState bs, HDGeometry geo);
	242
	243	void bdrv_add_child(BlockDriverState parent, BlockDriverState child,
	244	Error **errp);
	245	void bdrv_del_child(BlockDriverState parent, BdrvChild child, Error **errp);
	246
	247	/**
	248	*
	249	* bdrv_register_buf/bdrv_unregister_buf:
	250	*
	251	* Register/unregister a buffer for I/O. For example, VFIO drivers are
	252	* interested to know the memory areas that would later be used for I/O, so
	253	* that they can prepare IOMMU mapping etc., to get better performance.
4f384011 SH	254	*
	255	* Buffers must not overlap and they must be unregistered with the same <host,
	256	* size> values that they were registered with.
f4ec04ba SH	257	*
f4ec04ba SH	258	* Returns: true on success, false on failure
3b491a90	259	*/
f4ec04ba SH	260	bool bdrv_register_buf(BlockDriverState bs, void host, size_t size,
f4ec04ba SH	261	Error **errp);
4f384011	262	void bdrv_unregister_buf(BlockDriverState bs, void host, size_t size);
3b491a90 EGE	263
	264	void bdrv_cancel_in_flight(BlockDriverState *bs);
	265
	266	#endif /* BLOCK_GLOBAL_STATE_H */