block: New BlockBackend
A block device consists of a frontend device model and a backend.
A block backend has a tree of block drivers doing the actual work.
The tree is managed by the block layer.
We currently use a single abstraction BlockDriverState both for tree
nodes and the backend as a whole. Drawbacks:
* Its API includes both stuff that makes sense only at the block
backend level (root of the tree) and stuff that's only for use
within the block layer. This makes the API bigger and more complex
than necessary. Moreover, it's not obvious which interfaces are
meant for device models, and which really aren't.
* Since device models keep a reference to their backend, the backend
object can't just be destroyed. But for media change, we need to
replace the tree. Our solution is to make the BlockDriverState
generic, with actual driver state in a separate object, pointed to
by member opaque. That lets us replace the tree by deinitializing
and reinitializing its root. This special need of the root makes
the data structure awkward everywhere in the tree.
The general plan is to separate the APIs into "block backend", for use
by device models, monitor and whatever other code dealing with block
backends, and "block driver", for use by the block layer and whatever
other code (if any) dealing with trees and tree nodes.
Code dealing with block backends, device models in particular, should
become completely oblivious of BlockDriverState. This should let us
clean up both APIs, and the tree data structures.
This commit is a first step. It creates a minimal "block backend"
API: type BlockBackend and functions to create, destroy and find them.
BlockBackend objects are created and destroyed exactly when root
BlockDriverState objects are created and destroyed. "Root" in the
sense of "in bdrv_states". They're not yet used for anything; that'll
come shortly.
A root BlockDriverState is created with bdrv_new_root(), so where to
create a BlockBackend is obvious. Where these roots get destroyed
isn't always as obvious.
It is obvious in qemu-img.c, qemu-io.c and qemu-nbd.c, and in error
paths of blockdev_init(), blk_connect(). That leaves destruction of
objects successfully created by blockdev_init() and blk_connect().
blockdev_init() is used only by drive_new() and qmp_blockdev_add().
Objects created by the latter are currently indestructible (see commit
48f364d "blockdev: Refuse to drive_del something added with
blockdev-add" and commit 2d246f0 "blockdev: Introduce
DriveInfo.enable_auto_del"). Objects created by the former get
destroyed by drive_del().
Objects created by blk_connect() get destroyed by blk_disconnect().
BlockBackend is reference-counted. Its reference count never exceeds
one so far, but that's going to change.
In drive_del(), the BB's reference count is surely one now. The BDS's
reference count is greater than one when something else is holding a
reference, such as a block job. In this case, the BB is destroyed
right away, but the BDS lives on until all extra references get
dropped.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2014-10-07 15:59:04 +04:00
|
|
|
/*
|
|
|
|
|
* QEMU Block backends
|
|
|
|
|
*
|
|
|
|
|
* Copyright (C) 2014 Red Hat, Inc.
|
|
|
|
|
*
|
|
|
|
|
* Authors:
|
|
|
|
|
* Markus Armbruster <armbru@redhat.com>,
|
|
|
|
|
*
|
|
|
|
|
* This work is licensed under the terms of the GNU LGPL, version 2.1
|
|
|
|
|
* or later. See the COPYING.LIB file in the top-level directory.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#ifndef BLOCK_BACKEND_H
|
|
|
|
|
#define BLOCK_BACKEND_H
|
|
|
|
|
|
|
|
|
|
#include "qemu/typedefs.h"
|
|
|
|
|
|
2014-10-07 15:59:18 +04:00
|
|
|
/*
|
|
|
|
|
* TODO Have to include block/block.h for a bunch of block layer
|
|
|
|
|
* types. Unfortunately, this pulls in the whole BlockDriverState
|
|
|
|
|
* API, which we don't want used by many BlockBackend users. Some of
|
|
|
|
|
* the types belong here, and the rest should be split into a common
|
|
|
|
|
* header and one for the BlockDriverState API.
|
|
|
|
|
*/
|
|
|
|
|
#include "block/block.h"
|
|
|
|
|
|
2014-10-07 15:59:25 +04:00
|
|
|
/* Callbacks for block device models */
|
|
|
|
|
typedef struct BlockDevOps {
|
|
|
|
|
/*
|
|
|
|
|
* Runs when virtual media changed (monitor commands eject, change)
|
|
|
|
|
* Argument load is true on load and false on eject.
|
|
|
|
|
* Beware: doesn't run when a host device's physical media
|
|
|
|
|
* changes. Sure would be useful if it did.
|
|
|
|
|
* Device models with removable media must implement this callback.
|
|
|
|
|
*/
|
|
|
|
|
void (*change_media_cb)(void *opaque, bool load);
|
|
|
|
|
/*
|
|
|
|
|
* Runs when an eject request is issued from the monitor, the tray
|
|
|
|
|
* is closed, and the medium is locked.
|
|
|
|
|
* Device models that do not implement is_medium_locked will not need
|
|
|
|
|
* this callback. Device models that can lock the medium or tray might
|
|
|
|
|
* want to implement the callback and unlock the tray when "force" is
|
|
|
|
|
* true, even if they do not support eject requests.
|
|
|
|
|
*/
|
|
|
|
|
void (*eject_request_cb)(void *opaque, bool force);
|
|
|
|
|
/*
|
|
|
|
|
* Is the virtual tray open?
|
|
|
|
|
* Device models implement this only when the device has a tray.
|
|
|
|
|
*/
|
|
|
|
|
bool (*is_tray_open)(void *opaque);
|
|
|
|
|
/*
|
|
|
|
|
* Is the virtual medium locked into the device?
|
|
|
|
|
* Device models implement this only when device has such a lock.
|
|
|
|
|
*/
|
|
|
|
|
bool (*is_medium_locked)(void *opaque);
|
|
|
|
|
/*
|
|
|
|
|
* Runs when the size changed (e.g. monitor command block_resize)
|
|
|
|
|
*/
|
|
|
|
|
void (*resize_cb)(void *opaque);
|
|
|
|
|
} BlockDevOps;
|
|
|
|
|
|
block: New BlockBackend
A block device consists of a frontend device model and a backend.
A block backend has a tree of block drivers doing the actual work.
The tree is managed by the block layer.
We currently use a single abstraction BlockDriverState both for tree
nodes and the backend as a whole. Drawbacks:
* Its API includes both stuff that makes sense only at the block
backend level (root of the tree) and stuff that's only for use
within the block layer. This makes the API bigger and more complex
than necessary. Moreover, it's not obvious which interfaces are
meant for device models, and which really aren't.
* Since device models keep a reference to their backend, the backend
object can't just be destroyed. But for media change, we need to
replace the tree. Our solution is to make the BlockDriverState
generic, with actual driver state in a separate object, pointed to
by member opaque. That lets us replace the tree by deinitializing
and reinitializing its root. This special need of the root makes
the data structure awkward everywhere in the tree.
The general plan is to separate the APIs into "block backend", for use
by device models, monitor and whatever other code dealing with block
backends, and "block driver", for use by the block layer and whatever
other code (if any) dealing with trees and tree nodes.
Code dealing with block backends, device models in particular, should
become completely oblivious of BlockDriverState. This should let us
clean up both APIs, and the tree data structures.
This commit is a first step. It creates a minimal "block backend"
API: type BlockBackend and functions to create, destroy and find them.
BlockBackend objects are created and destroyed exactly when root
BlockDriverState objects are created and destroyed. "Root" in the
sense of "in bdrv_states". They're not yet used for anything; that'll
come shortly.
A root BlockDriverState is created with bdrv_new_root(), so where to
create a BlockBackend is obvious. Where these roots get destroyed
isn't always as obvious.
It is obvious in qemu-img.c, qemu-io.c and qemu-nbd.c, and in error
paths of blockdev_init(), blk_connect(). That leaves destruction of
objects successfully created by blockdev_init() and blk_connect().
blockdev_init() is used only by drive_new() and qmp_blockdev_add().
Objects created by the latter are currently indestructible (see commit
48f364d "blockdev: Refuse to drive_del something added with
blockdev-add" and commit 2d246f0 "blockdev: Introduce
DriveInfo.enable_auto_del"). Objects created by the former get
destroyed by drive_del().
Objects created by blk_connect() get destroyed by blk_disconnect().
BlockBackend is reference-counted. Its reference count never exceeds
one so far, but that's going to change.
In drive_del(), the BB's reference count is surely one now. The BDS's
reference count is greater than one when something else is holding a
reference, such as a block job. In this case, the BB is destroyed
right away, but the BDS lives on until all extra references get
dropped.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2014-10-07 15:59:04 +04:00
|
|
|
BlockBackend *blk_new(const char *name, Error **errp);
|
2014-10-07 15:59:05 +04:00
|
|
|
BlockBackend *blk_new_with_bs(const char *name, Error **errp);
|
2015-02-05 21:58:11 +03:00
|
|
|
BlockBackend *blk_new_open(const char *name, const char *filename,
|
|
|
|
|
const char *reference, QDict *options, int flags,
|
|
|
|
|
Error **errp);
|
2015-11-02 17:51:54 +03:00
|
|
|
int blk_get_refcnt(BlockBackend *blk);
|
block: New BlockBackend
A block device consists of a frontend device model and a backend.
A block backend has a tree of block drivers doing the actual work.
The tree is managed by the block layer.
We currently use a single abstraction BlockDriverState both for tree
nodes and the backend as a whole. Drawbacks:
* Its API includes both stuff that makes sense only at the block
backend level (root of the tree) and stuff that's only for use
within the block layer. This makes the API bigger and more complex
than necessary. Moreover, it's not obvious which interfaces are
meant for device models, and which really aren't.
* Since device models keep a reference to their backend, the backend
object can't just be destroyed. But for media change, we need to
replace the tree. Our solution is to make the BlockDriverState
generic, with actual driver state in a separate object, pointed to
by member opaque. That lets us replace the tree by deinitializing
and reinitializing its root. This special need of the root makes
the data structure awkward everywhere in the tree.
The general plan is to separate the APIs into "block backend", for use
by device models, monitor and whatever other code dealing with block
backends, and "block driver", for use by the block layer and whatever
other code (if any) dealing with trees and tree nodes.
Code dealing with block backends, device models in particular, should
become completely oblivious of BlockDriverState. This should let us
clean up both APIs, and the tree data structures.
This commit is a first step. It creates a minimal "block backend"
API: type BlockBackend and functions to create, destroy and find them.
BlockBackend objects are created and destroyed exactly when root
BlockDriverState objects are created and destroyed. "Root" in the
sense of "in bdrv_states". They're not yet used for anything; that'll
come shortly.
A root BlockDriverState is created with bdrv_new_root(), so where to
create a BlockBackend is obvious. Where these roots get destroyed
isn't always as obvious.
It is obvious in qemu-img.c, qemu-io.c and qemu-nbd.c, and in error
paths of blockdev_init(), blk_connect(). That leaves destruction of
objects successfully created by blockdev_init() and blk_connect().
blockdev_init() is used only by drive_new() and qmp_blockdev_add().
Objects created by the latter are currently indestructible (see commit
48f364d "blockdev: Refuse to drive_del something added with
blockdev-add" and commit 2d246f0 "blockdev: Introduce
DriveInfo.enable_auto_del"). Objects created by the former get
destroyed by drive_del().
Objects created by blk_connect() get destroyed by blk_disconnect().
BlockBackend is reference-counted. Its reference count never exceeds
one so far, but that's going to change.
In drive_del(), the BB's reference count is surely one now. The BDS's
reference count is greater than one when something else is holding a
reference, such as a block job. In this case, the BB is destroyed
right away, but the BDS lives on until all extra references get
dropped.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2014-10-07 15:59:04 +04:00
|
|
|
void blk_ref(BlockBackend *blk);
|
|
|
|
|
void blk_unref(BlockBackend *blk);
|
2016-01-29 18:36:13 +03:00
|
|
|
void blk_remove_all_bs(void);
|
block: New BlockBackend
A block device consists of a frontend device model and a backend.
A block backend has a tree of block drivers doing the actual work.
The tree is managed by the block layer.
We currently use a single abstraction BlockDriverState both for tree
nodes and the backend as a whole. Drawbacks:
* Its API includes both stuff that makes sense only at the block
backend level (root of the tree) and stuff that's only for use
within the block layer. This makes the API bigger and more complex
than necessary. Moreover, it's not obvious which interfaces are
meant for device models, and which really aren't.
* Since device models keep a reference to their backend, the backend
object can't just be destroyed. But for media change, we need to
replace the tree. Our solution is to make the BlockDriverState
generic, with actual driver state in a separate object, pointed to
by member opaque. That lets us replace the tree by deinitializing
and reinitializing its root. This special need of the root makes
the data structure awkward everywhere in the tree.
The general plan is to separate the APIs into "block backend", for use
by device models, monitor and whatever other code dealing with block
backends, and "block driver", for use by the block layer and whatever
other code (if any) dealing with trees and tree nodes.
Code dealing with block backends, device models in particular, should
become completely oblivious of BlockDriverState. This should let us
clean up both APIs, and the tree data structures.
This commit is a first step. It creates a minimal "block backend"
API: type BlockBackend and functions to create, destroy and find them.
BlockBackend objects are created and destroyed exactly when root
BlockDriverState objects are created and destroyed. "Root" in the
sense of "in bdrv_states". They're not yet used for anything; that'll
come shortly.
A root BlockDriverState is created with bdrv_new_root(), so where to
create a BlockBackend is obvious. Where these roots get destroyed
isn't always as obvious.
It is obvious in qemu-img.c, qemu-io.c and qemu-nbd.c, and in error
paths of blockdev_init(), blk_connect(). That leaves destruction of
objects successfully created by blockdev_init() and blk_connect().
blockdev_init() is used only by drive_new() and qmp_blockdev_add().
Objects created by the latter are currently indestructible (see commit
48f364d "blockdev: Refuse to drive_del something added with
blockdev-add" and commit 2d246f0 "blockdev: Introduce
DriveInfo.enable_auto_del"). Objects created by the former get
destroyed by drive_del().
Objects created by blk_connect() get destroyed by blk_disconnect().
BlockBackend is reference-counted. Its reference count never exceeds
one so far, but that's going to change.
In drive_del(), the BB's reference count is surely one now. The BDS's
reference count is greater than one when something else is holding a
reference, such as a block job. In this case, the BB is destroyed
right away, but the BDS lives on until all extra references get
dropped.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2014-10-07 15:59:04 +04:00
|
|
|
const char *blk_name(BlockBackend *blk);
|
|
|
|
|
BlockBackend *blk_by_name(const char *name);
|
|
|
|
|
BlockBackend *blk_next(BlockBackend *blk);
|
|
|
|
|
|
2014-10-07 15:59:05 +04:00
|
|
|
BlockDriverState *blk_bs(BlockBackend *blk);
|
2015-10-26 23:39:05 +03:00
|
|
|
void blk_remove_bs(BlockBackend *blk);
|
2015-10-19 18:53:28 +03:00
|
|
|
void blk_insert_bs(BlockBackend *blk, BlockDriverState *bs);
|
2014-10-07 15:59:05 +04:00
|
|
|
|
hmp: Name HMP command handler functions hmp_COMMAND()
Some are called do_COMMAND() (old ones, usually), some hmp_COMMAND(),
and sometimes COMMAND pointlessly differs in spelling.
Normalize to hmp_COMMAND(), where COMMAND is exactly the command name
with '-' replaced by '_'.
Exceptions:
* do_device_add() and client_migrate_info() *not* renamed to
hmp_device_add(), hmp_client_migrate_info(), because they're also
QMP handlers. They still need to be converted to QAPI.
* do_memory_dump(), do_physical_memory_dump(), do_ioport_read(),
do_ioport_write() renamed do hmp_* instead of hmp_x(), hmp_xp(),
hmp_i(), hmp_o(), because those names are too cryptic for my taste.
* do_info_help() renamed to hmp_info_help() instead of hmp_info(),
because it only covers help.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2015-02-06 15:55:43 +03:00
|
|
|
void blk_hide_on_behalf_of_hmp_drive_del(BlockBackend *blk);
|
2014-10-07 15:59:05 +04:00
|
|
|
|
2016-03-08 18:39:49 +03:00
|
|
|
void blk_set_allow_write_beyond_eof(BlockBackend *blk, bool allow);
|
2014-10-07 15:59:18 +04:00
|
|
|
void blk_iostatus_enable(BlockBackend *blk);
|
2015-10-19 18:53:22 +03:00
|
|
|
bool blk_iostatus_is_enabled(const BlockBackend *blk);
|
|
|
|
|
BlockDeviceIoStatus blk_iostatus(const BlockBackend *blk);
|
|
|
|
|
void blk_iostatus_disable(BlockBackend *blk);
|
|
|
|
|
void blk_iostatus_reset(BlockBackend *blk);
|
|
|
|
|
void blk_iostatus_set_err(BlockBackend *blk, int error);
|
2014-10-07 15:59:18 +04:00
|
|
|
int blk_attach_dev(BlockBackend *blk, void *dev);
|
|
|
|
|
void blk_attach_dev_nofail(BlockBackend *blk, void *dev);
|
|
|
|
|
void blk_detach_dev(BlockBackend *blk, void *dev);
|
|
|
|
|
void *blk_get_attached_dev(BlockBackend *blk);
|
|
|
|
|
void blk_set_dev_ops(BlockBackend *blk, const BlockDevOps *ops, void *opaque);
|
|
|
|
|
int blk_read(BlockBackend *blk, int64_t sector_num, uint8_t *buf,
|
|
|
|
|
int nb_sectors);
|
|
|
|
|
int blk_read_unthrottled(BlockBackend *blk, int64_t sector_num, uint8_t *buf,
|
|
|
|
|
int nb_sectors);
|
|
|
|
|
int blk_write(BlockBackend *blk, int64_t sector_num, const uint8_t *buf,
|
|
|
|
|
int nb_sectors);
|
2015-03-19 15:33:31 +03:00
|
|
|
int blk_write_zeroes(BlockBackend *blk, int64_t sector_num,
|
|
|
|
|
int nb_sectors, BdrvRequestFlags flags);
|
2014-10-07 15:59:18 +04:00
|
|
|
BlockAIOCB *blk_aio_write_zeroes(BlockBackend *blk, int64_t sector_num,
|
|
|
|
|
int nb_sectors, BdrvRequestFlags flags,
|
|
|
|
|
BlockCompletionFunc *cb, void *opaque);
|
|
|
|
|
int blk_pread(BlockBackend *blk, int64_t offset, void *buf, int count);
|
|
|
|
|
int blk_pwrite(BlockBackend *blk, int64_t offset, const void *buf, int count);
|
|
|
|
|
int64_t blk_getlength(BlockBackend *blk);
|
|
|
|
|
void blk_get_geometry(BlockBackend *blk, uint64_t *nb_sectors_ptr);
|
2015-02-05 21:58:10 +03:00
|
|
|
int64_t blk_nb_sectors(BlockBackend *blk);
|
2014-10-07 15:59:18 +04:00
|
|
|
BlockAIOCB *blk_aio_readv(BlockBackend *blk, int64_t sector_num,
|
|
|
|
|
QEMUIOVector *iov, int nb_sectors,
|
|
|
|
|
BlockCompletionFunc *cb, void *opaque);
|
|
|
|
|
BlockAIOCB *blk_aio_writev(BlockBackend *blk, int64_t sector_num,
|
|
|
|
|
QEMUIOVector *iov, int nb_sectors,
|
|
|
|
|
BlockCompletionFunc *cb, void *opaque);
|
|
|
|
|
BlockAIOCB *blk_aio_flush(BlockBackend *blk,
|
|
|
|
|
BlockCompletionFunc *cb, void *opaque);
|
|
|
|
|
BlockAIOCB *blk_aio_discard(BlockBackend *blk,
|
|
|
|
|
int64_t sector_num, int nb_sectors,
|
|
|
|
|
BlockCompletionFunc *cb, void *opaque);
|
|
|
|
|
void blk_aio_cancel(BlockAIOCB *acb);
|
|
|
|
|
void blk_aio_cancel_async(BlockAIOCB *acb);
|
|
|
|
|
int blk_aio_multiwrite(BlockBackend *blk, BlockRequest *reqs, int num_reqs);
|
|
|
|
|
int blk_ioctl(BlockBackend *blk, unsigned long int req, void *buf);
|
|
|
|
|
BlockAIOCB *blk_aio_ioctl(BlockBackend *blk, unsigned long int req, void *buf,
|
|
|
|
|
BlockCompletionFunc *cb, void *opaque);
|
2014-11-18 14:21:14 +03:00
|
|
|
int blk_co_discard(BlockBackend *blk, int64_t sector_num, int nb_sectors);
|
|
|
|
|
int blk_co_flush(BlockBackend *blk);
|
2014-10-07 15:59:18 +04:00
|
|
|
int blk_flush(BlockBackend *blk);
|
|
|
|
|
int blk_flush_all(void);
|
2016-03-16 21:54:31 +03:00
|
|
|
int blk_commit_all(void);
|
2015-06-17 13:37:19 +03:00
|
|
|
void blk_drain(BlockBackend *blk);
|
2014-10-07 15:59:18 +04:00
|
|
|
void blk_drain_all(void);
|
2015-10-19 18:53:22 +03:00
|
|
|
void blk_set_on_error(BlockBackend *blk, BlockdevOnError on_read_error,
|
|
|
|
|
BlockdevOnError on_write_error);
|
2014-10-07 15:59:18 +04:00
|
|
|
BlockdevOnError blk_get_on_error(BlockBackend *blk, bool is_read);
|
|
|
|
|
BlockErrorAction blk_get_error_action(BlockBackend *blk, bool is_read,
|
|
|
|
|
int error);
|
|
|
|
|
void blk_error_action(BlockBackend *blk, BlockErrorAction action,
|
|
|
|
|
bool is_read, int error);
|
|
|
|
|
int blk_is_read_only(BlockBackend *blk);
|
|
|
|
|
int blk_is_sg(BlockBackend *blk);
|
|
|
|
|
int blk_enable_write_cache(BlockBackend *blk);
|
|
|
|
|
void blk_set_enable_write_cache(BlockBackend *blk, bool wce);
|
2014-11-18 14:21:14 +03:00
|
|
|
void blk_invalidate_cache(BlockBackend *blk, Error **errp);
|
2015-10-19 18:53:11 +03:00
|
|
|
bool blk_is_inserted(BlockBackend *blk);
|
2015-10-19 18:53:12 +03:00
|
|
|
bool blk_is_available(BlockBackend *blk);
|
2014-10-07 15:59:18 +04:00
|
|
|
void blk_lock_medium(BlockBackend *blk, bool locked);
|
|
|
|
|
void blk_eject(BlockBackend *blk, bool eject_flag);
|
|
|
|
|
int blk_get_flags(BlockBackend *blk);
|
2015-02-02 16:52:20 +03:00
|
|
|
int blk_get_max_transfer_length(BlockBackend *blk);
|
2015-07-09 12:56:45 +03:00
|
|
|
int blk_get_max_iov(BlockBackend *blk);
|
2014-10-07 15:59:18 +04:00
|
|
|
void blk_set_guest_block_size(BlockBackend *blk, int align);
|
2016-01-07 16:34:13 +03:00
|
|
|
void *blk_try_blockalign(BlockBackend *blk, size_t size);
|
2014-10-07 15:59:18 +04:00
|
|
|
void *blk_blockalign(BlockBackend *blk, size_t size);
|
|
|
|
|
bool blk_op_is_blocked(BlockBackend *blk, BlockOpType op, Error **errp);
|
|
|
|
|
void blk_op_unblock(BlockBackend *blk, BlockOpType op, Error *reason);
|
|
|
|
|
void blk_op_block_all(BlockBackend *blk, Error *reason);
|
|
|
|
|
void blk_op_unblock_all(BlockBackend *blk, Error *reason);
|
|
|
|
|
AioContext *blk_get_aio_context(BlockBackend *blk);
|
|
|
|
|
void blk_set_aio_context(BlockBackend *blk, AioContext *new_context);
|
2014-11-18 14:21:15 +03:00
|
|
|
void blk_add_aio_context_notifier(BlockBackend *blk,
|
|
|
|
|
void (*attached_aio_context)(AioContext *new_context, void *opaque),
|
|
|
|
|
void (*detach_aio_context)(void *opaque), void *opaque);
|
|
|
|
|
void blk_remove_aio_context_notifier(BlockBackend *blk,
|
|
|
|
|
void (*attached_aio_context)(AioContext *,
|
|
|
|
|
void *),
|
|
|
|
|
void (*detach_aio_context)(void *),
|
|
|
|
|
void *opaque);
|
2016-01-29 18:36:03 +03:00
|
|
|
void blk_add_remove_bs_notifier(BlockBackend *blk, Notifier *notify);
|
|
|
|
|
void blk_add_insert_bs_notifier(BlockBackend *blk, Notifier *notify);
|
2014-10-07 15:59:18 +04:00
|
|
|
void blk_io_plug(BlockBackend *blk);
|
|
|
|
|
void blk_io_unplug(BlockBackend *blk);
|
|
|
|
|
BlockAcctStats *blk_get_stats(BlockBackend *blk);
|
2015-10-19 18:53:24 +03:00
|
|
|
BlockBackendRootState *blk_get_root_state(BlockBackend *blk);
|
|
|
|
|
void blk_update_root_state(BlockBackend *blk);
|
2015-10-26 23:39:07 +03:00
|
|
|
void blk_apply_root_state(BlockBackend *blk, BlockDriverState *bs);
|
|
|
|
|
int blk_get_open_flags_from_root_state(BlockBackend *blk);
|
2014-10-07 15:59:18 +04:00
|
|
|
|
|
|
|
|
void *blk_aio_get(const AIOCBInfo *aiocb_info, BlockBackend *blk,
|
|
|
|
|
BlockCompletionFunc *cb, void *opaque);
|
2015-02-05 21:58:10 +03:00
|
|
|
int coroutine_fn blk_co_write_zeroes(BlockBackend *blk, int64_t sector_num,
|
|
|
|
|
int nb_sectors, BdrvRequestFlags flags);
|
|
|
|
|
int blk_write_compressed(BlockBackend *blk, int64_t sector_num,
|
|
|
|
|
const uint8_t *buf, int nb_sectors);
|
|
|
|
|
int blk_truncate(BlockBackend *blk, int64_t offset);
|
|
|
|
|
int blk_discard(BlockBackend *blk, int64_t sector_num, int nb_sectors);
|
|
|
|
|
int blk_save_vmstate(BlockBackend *blk, const uint8_t *buf,
|
|
|
|
|
int64_t pos, int size);
|
|
|
|
|
int blk_load_vmstate(BlockBackend *blk, uint8_t *buf, int64_t pos, int size);
|
2015-02-16 14:47:57 +03:00
|
|
|
int blk_probe_blocksizes(BlockBackend *blk, BlockSizes *bsz);
|
|
|
|
|
int blk_probe_geometry(BlockBackend *blk, HDGeometry *geo);
|
2015-11-17 23:06:21 +03:00
|
|
|
BlockAIOCB *blk_abort_aio_request(BlockBackend *blk,
|
|
|
|
|
BlockCompletionFunc *cb,
|
|
|
|
|
void *opaque, int ret);
|
2014-10-07 15:59:18 +04:00
|
|
|
|
block: New BlockBackend
A block device consists of a frontend device model and a backend.
A block backend has a tree of block drivers doing the actual work.
The tree is managed by the block layer.
We currently use a single abstraction BlockDriverState both for tree
nodes and the backend as a whole. Drawbacks:
* Its API includes both stuff that makes sense only at the block
backend level (root of the tree) and stuff that's only for use
within the block layer. This makes the API bigger and more complex
than necessary. Moreover, it's not obvious which interfaces are
meant for device models, and which really aren't.
* Since device models keep a reference to their backend, the backend
object can't just be destroyed. But for media change, we need to
replace the tree. Our solution is to make the BlockDriverState
generic, with actual driver state in a separate object, pointed to
by member opaque. That lets us replace the tree by deinitializing
and reinitializing its root. This special need of the root makes
the data structure awkward everywhere in the tree.
The general plan is to separate the APIs into "block backend", for use
by device models, monitor and whatever other code dealing with block
backends, and "block driver", for use by the block layer and whatever
other code (if any) dealing with trees and tree nodes.
Code dealing with block backends, device models in particular, should
become completely oblivious of BlockDriverState. This should let us
clean up both APIs, and the tree data structures.
This commit is a first step. It creates a minimal "block backend"
API: type BlockBackend and functions to create, destroy and find them.
BlockBackend objects are created and destroyed exactly when root
BlockDriverState objects are created and destroyed. "Root" in the
sense of "in bdrv_states". They're not yet used for anything; that'll
come shortly.
A root BlockDriverState is created with bdrv_new_root(), so where to
create a BlockBackend is obvious. Where these roots get destroyed
isn't always as obvious.
It is obvious in qemu-img.c, qemu-io.c and qemu-nbd.c, and in error
paths of blockdev_init(), blk_connect(). That leaves destruction of
objects successfully created by blockdev_init() and blk_connect().
blockdev_init() is used only by drive_new() and qmp_blockdev_add().
Objects created by the latter are currently indestructible (see commit
48f364d "blockdev: Refuse to drive_del something added with
blockdev-add" and commit 2d246f0 "blockdev: Introduce
DriveInfo.enable_auto_del"). Objects created by the former get
destroyed by drive_del().
Objects created by blk_connect() get destroyed by blk_disconnect().
BlockBackend is reference-counted. Its reference count never exceeds
one so far, but that's going to change.
In drive_del(), the BB's reference count is surely one now. The BDS's
reference count is greater than one when something else is holding a
reference, such as a block job. In this case, the BB is destroyed
right away, but the BDS lives on until all extra references get
dropped.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2014-10-07 15:59:04 +04:00
|
|
|
#endif
|