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.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "sysemu/block-backend.h"
|
|
|
|
#include "block/block_int.h"
|
2014-10-07 15:59:06 +04:00
|
|
|
#include "sysemu/blockdev.h"
|
2014-10-07 15:59:25 +04:00
|
|
|
#include "qapi-event.h"
|
|
|
|
|
|
|
|
/* Number of coroutines to reserve per attached device model */
|
|
|
|
#define COROUTINE_POOL_RESERVATION 64
|
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
|
|
|
|
|
|
|
struct BlockBackend {
|
|
|
|
char *name;
|
|
|
|
int refcnt;
|
2014-10-07 15:59:05 +04:00
|
|
|
BlockDriverState *bs;
|
2014-10-07 15:59:22 +04:00
|
|
|
DriveInfo *legacy_dinfo; /* null unless created by drive_new() */
|
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
|
|
|
QTAILQ_ENTRY(BlockBackend) link; /* for blk_backends */
|
2014-10-07 15:59:25 +04:00
|
|
|
|
|
|
|
void *dev; /* attached device model, if any */
|
|
|
|
/* TODO change to DeviceState when all users are qdevified */
|
|
|
|
const BlockDevOps *dev_ops;
|
|
|
|
void *dev_opaque;
|
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
|
|
|
};
|
|
|
|
|
2015-02-05 21:58:23 +03:00
|
|
|
typedef struct BlockBackendAIOCB {
|
|
|
|
BlockAIOCB common;
|
|
|
|
QEMUBH *bh;
|
|
|
|
int ret;
|
|
|
|
} BlockBackendAIOCB;
|
|
|
|
|
|
|
|
static const AIOCBInfo block_backend_aiocb_info = {
|
|
|
|
.aiocb_size = sizeof(BlockBackendAIOCB),
|
|
|
|
};
|
|
|
|
|
2014-10-07 15:59:07 +04:00
|
|
|
static void drive_info_del(DriveInfo *dinfo);
|
|
|
|
|
2014-10-07 15:59:05 +04:00
|
|
|
/* All the BlockBackends (except for hidden ones) */
|
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
|
|
|
static QTAILQ_HEAD(, BlockBackend) blk_backends =
|
|
|
|
QTAILQ_HEAD_INITIALIZER(blk_backends);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Create a new BlockBackend with @name, with a reference count of one.
|
|
|
|
* @name must not be null or empty.
|
|
|
|
* Fail if a BlockBackend with this name already exists.
|
|
|
|
* Store an error through @errp on failure, unless it's null.
|
|
|
|
* Return the new BlockBackend on success, null on failure.
|
|
|
|
*/
|
|
|
|
BlockBackend *blk_new(const char *name, Error **errp)
|
|
|
|
{
|
|
|
|
BlockBackend *blk;
|
|
|
|
|
|
|
|
assert(name && name[0]);
|
2014-10-07 15:59:12 +04:00
|
|
|
if (!id_wellformed(name)) {
|
|
|
|
error_setg(errp, "Invalid device name");
|
|
|
|
return NULL;
|
|
|
|
}
|
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
|
|
|
if (blk_by_name(name)) {
|
|
|
|
error_setg(errp, "Device with id '%s' already exists", name);
|
|
|
|
return NULL;
|
|
|
|
}
|
2014-10-07 15:59:12 +04:00
|
|
|
if (bdrv_find_node(name)) {
|
|
|
|
error_setg(errp,
|
|
|
|
"Device name '%s' conflicts with an existing node name",
|
|
|
|
name);
|
|
|
|
return NULL;
|
|
|
|
}
|
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
|
|
|
|
|
|
|
blk = g_new0(BlockBackend, 1);
|
|
|
|
blk->name = g_strdup(name);
|
|
|
|
blk->refcnt = 1;
|
|
|
|
QTAILQ_INSERT_TAIL(&blk_backends, blk, link);
|
|
|
|
return blk;
|
|
|
|
}
|
|
|
|
|
2014-10-07 15:59:05 +04:00
|
|
|
/*
|
|
|
|
* Create a new BlockBackend with a new BlockDriverState attached.
|
|
|
|
* Otherwise just like blk_new(), which see.
|
|
|
|
*/
|
|
|
|
BlockBackend *blk_new_with_bs(const char *name, Error **errp)
|
|
|
|
{
|
|
|
|
BlockBackend *blk;
|
|
|
|
BlockDriverState *bs;
|
|
|
|
|
|
|
|
blk = blk_new(name, errp);
|
|
|
|
if (!blk) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2014-10-07 15:59:12 +04:00
|
|
|
bs = bdrv_new_root();
|
2014-10-07 15:59:05 +04:00
|
|
|
blk->bs = bs;
|
|
|
|
bs->blk = blk;
|
|
|
|
return blk;
|
|
|
|
}
|
|
|
|
|
2015-02-05 21:58:11 +03:00
|
|
|
/*
|
|
|
|
* Calls blk_new_with_bs() and then calls bdrv_open() on the BlockDriverState.
|
|
|
|
*
|
|
|
|
* Just as with bdrv_open(), after having called this function the reference to
|
|
|
|
* @options belongs to the block layer (even on failure).
|
|
|
|
*
|
|
|
|
* TODO: Remove @filename and @flags; it should be possible to specify a whole
|
|
|
|
* BDS tree just by specifying the @options QDict (or @reference,
|
|
|
|
* alternatively). At the time of adding this function, this is not possible,
|
|
|
|
* though, so callers of this function have to be able to specify @filename and
|
|
|
|
* @flags.
|
|
|
|
*/
|
|
|
|
BlockBackend *blk_new_open(const char *name, const char *filename,
|
|
|
|
const char *reference, QDict *options, int flags,
|
|
|
|
Error **errp)
|
|
|
|
{
|
|
|
|
BlockBackend *blk;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
blk = blk_new_with_bs(name, errp);
|
|
|
|
if (!blk) {
|
|
|
|
QDECREF(options);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = bdrv_open(&blk->bs, filename, reference, options, flags, NULL, errp);
|
|
|
|
if (ret < 0) {
|
|
|
|
blk_unref(blk);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 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
|
|
|
static void blk_delete(BlockBackend *blk)
|
|
|
|
{
|
|
|
|
assert(!blk->refcnt);
|
2014-10-07 15:59:25 +04:00
|
|
|
assert(!blk->dev);
|
2014-10-07 15:59:05 +04:00
|
|
|
if (blk->bs) {
|
2014-10-07 15:59:08 +04:00
|
|
|
assert(blk->bs->blk == blk);
|
2014-10-07 15:59:05 +04:00
|
|
|
blk->bs->blk = NULL;
|
2014-10-07 15:59:08 +04:00
|
|
|
bdrv_unref(blk->bs);
|
2014-10-07 15:59:05 +04:00
|
|
|
blk->bs = NULL;
|
|
|
|
}
|
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
|
|
|
/* Avoid double-remove after blk_hide_on_behalf_of_hmp_drive_del() */
|
2014-10-07 15:59:05 +04:00
|
|
|
if (blk->name[0]) {
|
|
|
|
QTAILQ_REMOVE(&blk_backends, blk, link);
|
|
|
|
}
|
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
|
|
|
g_free(blk->name);
|
2014-10-07 15:59:06 +04:00
|
|
|
drive_info_del(blk->legacy_dinfo);
|
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
|
|
|
g_free(blk);
|
|
|
|
}
|
|
|
|
|
2014-10-07 15:59:07 +04:00
|
|
|
static void drive_info_del(DriveInfo *dinfo)
|
|
|
|
{
|
|
|
|
if (!dinfo) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
qemu_opts_del(dinfo->opts);
|
|
|
|
g_free(dinfo->serial);
|
|
|
|
g_free(dinfo);
|
|
|
|
}
|
|
|
|
|
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
|
|
|
/*
|
|
|
|
* Increment @blk's reference count.
|
|
|
|
* @blk must not be null.
|
|
|
|
*/
|
|
|
|
void blk_ref(BlockBackend *blk)
|
|
|
|
{
|
|
|
|
blk->refcnt++;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Decrement @blk's reference count.
|
|
|
|
* If this drops it to zero, destroy @blk.
|
|
|
|
* For convenience, do nothing if @blk is null.
|
|
|
|
*/
|
|
|
|
void blk_unref(BlockBackend *blk)
|
|
|
|
{
|
|
|
|
if (blk) {
|
|
|
|
assert(blk->refcnt > 0);
|
|
|
|
if (!--blk->refcnt) {
|
|
|
|
blk_delete(blk);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Return the BlockBackend after @blk.
|
|
|
|
* If @blk is null, return the first one.
|
|
|
|
* Else, return @blk's next sibling, which may be null.
|
|
|
|
*
|
|
|
|
* To iterate over all BlockBackends, do
|
|
|
|
* for (blk = blk_next(NULL); blk; blk = blk_next(blk)) {
|
|
|
|
* ...
|
|
|
|
* }
|
|
|
|
*/
|
|
|
|
BlockBackend *blk_next(BlockBackend *blk)
|
|
|
|
{
|
|
|
|
return blk ? QTAILQ_NEXT(blk, link) : QTAILQ_FIRST(&blk_backends);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2014-10-07 15:59:05 +04:00
|
|
|
* Return @blk's name, a non-null string.
|
|
|
|
* Wart: the name is empty iff @blk has been hidden with
|
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
|
|
|
* blk_hide_on_behalf_of_hmp_drive_del().
|
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)
|
|
|
|
{
|
|
|
|
return blk->name;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Return the BlockBackend with name @name if it exists, else null.
|
|
|
|
* @name must not be null.
|
|
|
|
*/
|
|
|
|
BlockBackend *blk_by_name(const char *name)
|
|
|
|
{
|
|
|
|
BlockBackend *blk;
|
|
|
|
|
|
|
|
assert(name);
|
|
|
|
QTAILQ_FOREACH(blk, &blk_backends, link) {
|
|
|
|
if (!strcmp(name, blk->name)) {
|
|
|
|
return blk;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
2014-10-07 15:59:05 +04:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Return the BlockDriverState attached to @blk if any, else null.
|
|
|
|
*/
|
|
|
|
BlockDriverState *blk_bs(BlockBackend *blk)
|
|
|
|
{
|
|
|
|
return blk->bs;
|
|
|
|
}
|
|
|
|
|
2014-10-07 15:59:06 +04:00
|
|
|
/*
|
|
|
|
* Return @blk's DriveInfo if any, else null.
|
|
|
|
*/
|
|
|
|
DriveInfo *blk_legacy_dinfo(BlockBackend *blk)
|
|
|
|
{
|
|
|
|
return blk->legacy_dinfo;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set @blk's DriveInfo to @dinfo, and return it.
|
|
|
|
* @blk must not have a DriveInfo set already.
|
|
|
|
* No other BlockBackend may have the same DriveInfo set.
|
|
|
|
*/
|
|
|
|
DriveInfo *blk_set_legacy_dinfo(BlockBackend *blk, DriveInfo *dinfo)
|
|
|
|
{
|
|
|
|
assert(!blk->legacy_dinfo);
|
|
|
|
return blk->legacy_dinfo = dinfo;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Return the BlockBackend with DriveInfo @dinfo.
|
|
|
|
* It must exist.
|
|
|
|
*/
|
|
|
|
BlockBackend *blk_by_legacy_dinfo(DriveInfo *dinfo)
|
|
|
|
{
|
|
|
|
BlockBackend *blk;
|
|
|
|
|
|
|
|
QTAILQ_FOREACH(blk, &blk_backends, link) {
|
|
|
|
if (blk->legacy_dinfo == dinfo) {
|
|
|
|
return blk;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
|
2014-10-07 15:59:05 +04:00
|
|
|
/*
|
|
|
|
* Hide @blk.
|
|
|
|
* @blk must not have been hidden already.
|
|
|
|
* Make attached BlockDriverState, if any, anonymous.
|
|
|
|
* Once hidden, @blk is invisible to all functions that don't receive
|
|
|
|
* it as argument. For example, blk_by_name() won't return it.
|
|
|
|
* Strictly for use by do_drive_del().
|
|
|
|
* TODO get rid of it!
|
|
|
|
*/
|
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
|
|
|
{
|
|
|
|
QTAILQ_REMOVE(&blk_backends, blk, link);
|
|
|
|
blk->name[0] = 0;
|
|
|
|
if (blk->bs) {
|
|
|
|
bdrv_make_anon(blk->bs);
|
|
|
|
}
|
|
|
|
}
|
2014-10-07 15:59:18 +04:00
|
|
|
|
2014-10-07 15:59:25 +04:00
|
|
|
/*
|
|
|
|
* Attach device model @dev to @blk.
|
|
|
|
* Return 0 on success, -EBUSY when a device model is attached already.
|
|
|
|
*/
|
2014-10-07 15:59:18 +04:00
|
|
|
int blk_attach_dev(BlockBackend *blk, void *dev)
|
2014-10-07 15:59:25 +04:00
|
|
|
/* TODO change to DeviceState *dev when all users are qdevified */
|
2014-10-07 15:59:18 +04:00
|
|
|
{
|
2014-10-07 15:59:25 +04:00
|
|
|
if (blk->dev) {
|
|
|
|
return -EBUSY;
|
|
|
|
}
|
2014-10-07 15:59:26 +04:00
|
|
|
blk_ref(blk);
|
2014-10-07 15:59:25 +04:00
|
|
|
blk->dev = dev;
|
|
|
|
bdrv_iostatus_reset(blk->bs);
|
|
|
|
return 0;
|
2014-10-07 15:59:18 +04:00
|
|
|
}
|
|
|
|
|
2014-10-07 15:59:25 +04:00
|
|
|
/*
|
|
|
|
* Attach device model @dev to @blk.
|
|
|
|
* @blk must not have a device model attached already.
|
|
|
|
* TODO qdevified devices don't use this, remove when devices are qdevified
|
|
|
|
*/
|
2014-10-07 15:59:18 +04:00
|
|
|
void blk_attach_dev_nofail(BlockBackend *blk, void *dev)
|
|
|
|
{
|
2014-10-07 15:59:25 +04:00
|
|
|
if (blk_attach_dev(blk, dev) < 0) {
|
|
|
|
abort();
|
|
|
|
}
|
2014-10-07 15:59:18 +04:00
|
|
|
}
|
|
|
|
|
2014-10-07 15:59:25 +04:00
|
|
|
/*
|
|
|
|
* Detach device model @dev from @blk.
|
|
|
|
* @dev must be currently attached to @blk.
|
|
|
|
*/
|
2014-10-07 15:59:18 +04:00
|
|
|
void blk_detach_dev(BlockBackend *blk, void *dev)
|
2014-10-07 15:59:25 +04:00
|
|
|
/* TODO change to DeviceState *dev when all users are qdevified */
|
2014-10-07 15:59:18 +04:00
|
|
|
{
|
2014-10-07 15:59:25 +04:00
|
|
|
assert(blk->dev == dev);
|
|
|
|
blk->dev = NULL;
|
|
|
|
blk->dev_ops = NULL;
|
|
|
|
blk->dev_opaque = NULL;
|
|
|
|
bdrv_set_guest_block_size(blk->bs, 512);
|
2014-10-07 15:59:26 +04:00
|
|
|
blk_unref(blk);
|
2014-10-07 15:59:18 +04:00
|
|
|
}
|
|
|
|
|
2014-10-07 15:59:25 +04:00
|
|
|
/*
|
|
|
|
* Return the device model attached to @blk if any, else null.
|
|
|
|
*/
|
2014-10-07 15:59:18 +04:00
|
|
|
void *blk_get_attached_dev(BlockBackend *blk)
|
2014-10-07 15:59:25 +04:00
|
|
|
/* TODO change to return DeviceState * when all users are qdevified */
|
|
|
|
{
|
|
|
|
return blk->dev;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set @blk's device model callbacks to @ops.
|
|
|
|
* @opaque is the opaque argument to pass to the callbacks.
|
|
|
|
* This is for use by device models.
|
|
|
|
*/
|
|
|
|
void blk_set_dev_ops(BlockBackend *blk, const BlockDevOps *ops,
|
|
|
|
void *opaque)
|
|
|
|
{
|
|
|
|
blk->dev_ops = ops;
|
|
|
|
blk->dev_opaque = opaque;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Notify @blk's attached device model of media change.
|
|
|
|
* If @load is true, notify of media load.
|
|
|
|
* Else, notify of media eject.
|
|
|
|
* Also send DEVICE_TRAY_MOVED events as appropriate.
|
|
|
|
*/
|
|
|
|
void blk_dev_change_media_cb(BlockBackend *blk, bool load)
|
|
|
|
{
|
|
|
|
if (blk->dev_ops && blk->dev_ops->change_media_cb) {
|
|
|
|
bool tray_was_closed = !blk_dev_is_tray_open(blk);
|
|
|
|
|
|
|
|
blk->dev_ops->change_media_cb(blk->dev_opaque, load);
|
|
|
|
if (tray_was_closed) {
|
|
|
|
/* tray open */
|
|
|
|
qapi_event_send_device_tray_moved(blk_name(blk),
|
|
|
|
true, &error_abort);
|
|
|
|
}
|
|
|
|
if (load) {
|
|
|
|
/* tray close */
|
|
|
|
qapi_event_send_device_tray_moved(blk_name(blk),
|
|
|
|
false, &error_abort);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Does @blk's attached device model have removable media?
|
|
|
|
* %true if no device model is attached.
|
|
|
|
*/
|
|
|
|
bool blk_dev_has_removable_media(BlockBackend *blk)
|
|
|
|
{
|
|
|
|
return !blk->dev || (blk->dev_ops && blk->dev_ops->change_media_cb);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Notify @blk's attached device model of a media eject request.
|
|
|
|
* If @force is true, the medium is about to be yanked out forcefully.
|
|
|
|
*/
|
|
|
|
void blk_dev_eject_request(BlockBackend *blk, bool force)
|
2014-10-07 15:59:18 +04:00
|
|
|
{
|
2014-10-07 15:59:25 +04:00
|
|
|
if (blk->dev_ops && blk->dev_ops->eject_request_cb) {
|
|
|
|
blk->dev_ops->eject_request_cb(blk->dev_opaque, force);
|
|
|
|
}
|
2014-10-07 15:59:18 +04:00
|
|
|
}
|
|
|
|
|
2014-10-07 15:59:25 +04:00
|
|
|
/*
|
|
|
|
* Does @blk's attached device model have a tray, and is it open?
|
|
|
|
*/
|
|
|
|
bool blk_dev_is_tray_open(BlockBackend *blk)
|
2014-10-07 15:59:18 +04:00
|
|
|
{
|
2014-10-07 15:59:25 +04:00
|
|
|
if (blk->dev_ops && blk->dev_ops->is_tray_open) {
|
|
|
|
return blk->dev_ops->is_tray_open(blk->dev_opaque);
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Does @blk's attached device model have the medium locked?
|
|
|
|
* %false if the device model has no such lock.
|
|
|
|
*/
|
|
|
|
bool blk_dev_is_medium_locked(BlockBackend *blk)
|
|
|
|
{
|
|
|
|
if (blk->dev_ops && blk->dev_ops->is_medium_locked) {
|
|
|
|
return blk->dev_ops->is_medium_locked(blk->dev_opaque);
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Notify @blk's attached device model of a backend size change.
|
|
|
|
*/
|
|
|
|
void blk_dev_resize_cb(BlockBackend *blk)
|
|
|
|
{
|
|
|
|
if (blk->dev_ops && blk->dev_ops->resize_cb) {
|
|
|
|
blk->dev_ops->resize_cb(blk->dev_opaque);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void blk_iostatus_enable(BlockBackend *blk)
|
|
|
|
{
|
|
|
|
bdrv_iostatus_enable(blk->bs);
|
2014-10-07 15:59:18 +04:00
|
|
|
}
|
|
|
|
|
2015-02-05 21:58:23 +03:00
|
|
|
static int blk_check_byte_request(BlockBackend *blk, int64_t offset,
|
|
|
|
size_t size)
|
|
|
|
{
|
|
|
|
int64_t len;
|
|
|
|
|
|
|
|
if (size > INT_MAX) {
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!blk_is_inserted(blk)) {
|
|
|
|
return -ENOMEDIUM;
|
|
|
|
}
|
|
|
|
|
|
|
|
len = blk_getlength(blk);
|
|
|
|
if (len < 0) {
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (offset < 0) {
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (offset > len || len - offset < size) {
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int blk_check_request(BlockBackend *blk, int64_t sector_num,
|
|
|
|
int nb_sectors)
|
|
|
|
{
|
|
|
|
if (sector_num < 0 || sector_num > INT64_MAX / BDRV_SECTOR_SIZE) {
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (nb_sectors < 0 || nb_sectors > INT_MAX / BDRV_SECTOR_SIZE) {
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
return blk_check_byte_request(blk, sector_num * BDRV_SECTOR_SIZE,
|
|
|
|
nb_sectors * BDRV_SECTOR_SIZE);
|
|
|
|
}
|
|
|
|
|
2014-10-07 15:59:18 +04:00
|
|
|
int blk_read(BlockBackend *blk, int64_t sector_num, uint8_t *buf,
|
|
|
|
int nb_sectors)
|
|
|
|
{
|
2015-02-05 21:58:23 +03:00
|
|
|
int ret = blk_check_request(blk, sector_num, nb_sectors);
|
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-10-07 15:59:18 +04:00
|
|
|
return bdrv_read(blk->bs, sector_num, buf, nb_sectors);
|
|
|
|
}
|
|
|
|
|
|
|
|
int blk_read_unthrottled(BlockBackend *blk, int64_t sector_num, uint8_t *buf,
|
|
|
|
int nb_sectors)
|
|
|
|
{
|
2015-02-05 21:58:23 +03:00
|
|
|
int ret = blk_check_request(blk, sector_num, nb_sectors);
|
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-10-07 15:59:18 +04:00
|
|
|
return bdrv_read_unthrottled(blk->bs, sector_num, buf, nb_sectors);
|
|
|
|
}
|
|
|
|
|
|
|
|
int blk_write(BlockBackend *blk, int64_t sector_num, const uint8_t *buf,
|
|
|
|
int nb_sectors)
|
|
|
|
{
|
2015-02-05 21:58:23 +03:00
|
|
|
int ret = blk_check_request(blk, sector_num, nb_sectors);
|
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-10-07 15:59:18 +04:00
|
|
|
return bdrv_write(blk->bs, sector_num, buf, 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)
|
|
|
|
{
|
|
|
|
int ret = blk_check_request(blk, sector_num, nb_sectors);
|
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return bdrv_write_zeroes(blk->bs, sector_num, nb_sectors, flags);
|
|
|
|
}
|
|
|
|
|
2015-02-05 21:58:23 +03:00
|
|
|
static void error_callback_bh(void *opaque)
|
|
|
|
{
|
|
|
|
struct BlockBackendAIOCB *acb = opaque;
|
|
|
|
qemu_bh_delete(acb->bh);
|
|
|
|
acb->common.cb(acb->common.opaque, acb->ret);
|
|
|
|
qemu_aio_unref(acb);
|
|
|
|
}
|
|
|
|
|
|
|
|
static BlockAIOCB *abort_aio_request(BlockBackend *blk, BlockCompletionFunc *cb,
|
|
|
|
void *opaque, int ret)
|
|
|
|
{
|
|
|
|
struct BlockBackendAIOCB *acb;
|
|
|
|
QEMUBH *bh;
|
|
|
|
|
|
|
|
acb = blk_aio_get(&block_backend_aiocb_info, blk, cb, opaque);
|
|
|
|
acb->ret = ret;
|
|
|
|
|
|
|
|
bh = aio_bh_new(blk_get_aio_context(blk), error_callback_bh, acb);
|
|
|
|
acb->bh = bh;
|
|
|
|
qemu_bh_schedule(bh);
|
|
|
|
|
|
|
|
return &acb->common;
|
|
|
|
}
|
|
|
|
|
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)
|
|
|
|
{
|
2015-02-05 21:58:23 +03:00
|
|
|
int ret = blk_check_request(blk, sector_num, nb_sectors);
|
|
|
|
if (ret < 0) {
|
|
|
|
return abort_aio_request(blk, cb, opaque, ret);
|
|
|
|
}
|
|
|
|
|
2014-10-07 15:59:18 +04:00
|
|
|
return bdrv_aio_write_zeroes(blk->bs, sector_num, nb_sectors, flags,
|
|
|
|
cb, opaque);
|
|
|
|
}
|
|
|
|
|
|
|
|
int blk_pread(BlockBackend *blk, int64_t offset, void *buf, int count)
|
|
|
|
{
|
2015-02-05 21:58:23 +03:00
|
|
|
int ret = blk_check_byte_request(blk, offset, count);
|
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-10-07 15:59:18 +04:00
|
|
|
return bdrv_pread(blk->bs, offset, buf, count);
|
|
|
|
}
|
|
|
|
|
|
|
|
int blk_pwrite(BlockBackend *blk, int64_t offset, const void *buf, int count)
|
|
|
|
{
|
2015-02-05 21:58:23 +03:00
|
|
|
int ret = blk_check_byte_request(blk, offset, count);
|
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-10-07 15:59:18 +04:00
|
|
|
return bdrv_pwrite(blk->bs, offset, buf, count);
|
|
|
|
}
|
|
|
|
|
|
|
|
int64_t blk_getlength(BlockBackend *blk)
|
|
|
|
{
|
|
|
|
return bdrv_getlength(blk->bs);
|
|
|
|
}
|
|
|
|
|
|
|
|
void blk_get_geometry(BlockBackend *blk, uint64_t *nb_sectors_ptr)
|
|
|
|
{
|
|
|
|
bdrv_get_geometry(blk->bs, nb_sectors_ptr);
|
|
|
|
}
|
|
|
|
|
2015-02-05 21:58:10 +03:00
|
|
|
int64_t blk_nb_sectors(BlockBackend *blk)
|
|
|
|
{
|
|
|
|
return bdrv_nb_sectors(blk->bs);
|
|
|
|
}
|
|
|
|
|
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)
|
|
|
|
{
|
2015-02-05 21:58:23 +03:00
|
|
|
int ret = blk_check_request(blk, sector_num, nb_sectors);
|
|
|
|
if (ret < 0) {
|
|
|
|
return abort_aio_request(blk, cb, opaque, ret);
|
|
|
|
}
|
|
|
|
|
2014-10-07 15:59:18 +04:00
|
|
|
return bdrv_aio_readv(blk->bs, sector_num, iov, nb_sectors, cb, opaque);
|
|
|
|
}
|
|
|
|
|
|
|
|
BlockAIOCB *blk_aio_writev(BlockBackend *blk, int64_t sector_num,
|
|
|
|
QEMUIOVector *iov, int nb_sectors,
|
|
|
|
BlockCompletionFunc *cb, void *opaque)
|
|
|
|
{
|
2015-02-05 21:58:23 +03:00
|
|
|
int ret = blk_check_request(blk, sector_num, nb_sectors);
|
|
|
|
if (ret < 0) {
|
|
|
|
return abort_aio_request(blk, cb, opaque, ret);
|
|
|
|
}
|
|
|
|
|
2014-10-07 15:59:18 +04:00
|
|
|
return bdrv_aio_writev(blk->bs, sector_num, iov, nb_sectors, cb, opaque);
|
|
|
|
}
|
|
|
|
|
|
|
|
BlockAIOCB *blk_aio_flush(BlockBackend *blk,
|
|
|
|
BlockCompletionFunc *cb, void *opaque)
|
|
|
|
{
|
|
|
|
return bdrv_aio_flush(blk->bs, cb, opaque);
|
|
|
|
}
|
|
|
|
|
|
|
|
BlockAIOCB *blk_aio_discard(BlockBackend *blk,
|
|
|
|
int64_t sector_num, int nb_sectors,
|
|
|
|
BlockCompletionFunc *cb, void *opaque)
|
|
|
|
{
|
2015-02-05 21:58:23 +03:00
|
|
|
int ret = blk_check_request(blk, sector_num, nb_sectors);
|
|
|
|
if (ret < 0) {
|
|
|
|
return abort_aio_request(blk, cb, opaque, ret);
|
|
|
|
}
|
|
|
|
|
2014-10-07 15:59:18 +04:00
|
|
|
return bdrv_aio_discard(blk->bs, sector_num, nb_sectors, cb, opaque);
|
|
|
|
}
|
|
|
|
|
|
|
|
void blk_aio_cancel(BlockAIOCB *acb)
|
|
|
|
{
|
|
|
|
bdrv_aio_cancel(acb);
|
|
|
|
}
|
|
|
|
|
|
|
|
void blk_aio_cancel_async(BlockAIOCB *acb)
|
|
|
|
{
|
|
|
|
bdrv_aio_cancel_async(acb);
|
|
|
|
}
|
|
|
|
|
|
|
|
int blk_aio_multiwrite(BlockBackend *blk, BlockRequest *reqs, int num_reqs)
|
|
|
|
{
|
2015-02-05 21:58:23 +03:00
|
|
|
int i, ret;
|
|
|
|
|
|
|
|
for (i = 0; i < num_reqs; i++) {
|
|
|
|
ret = blk_check_request(blk, reqs[i].sector, reqs[i].nb_sectors);
|
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-10-07 15:59:18 +04:00
|
|
|
return bdrv_aio_multiwrite(blk->bs, reqs, num_reqs);
|
|
|
|
}
|
|
|
|
|
|
|
|
int blk_ioctl(BlockBackend *blk, unsigned long int req, void *buf)
|
|
|
|
{
|
|
|
|
return bdrv_ioctl(blk->bs, req, buf);
|
|
|
|
}
|
|
|
|
|
|
|
|
BlockAIOCB *blk_aio_ioctl(BlockBackend *blk, unsigned long int req, void *buf,
|
|
|
|
BlockCompletionFunc *cb, void *opaque)
|
|
|
|
{
|
|
|
|
return bdrv_aio_ioctl(blk->bs, req, buf, cb, opaque);
|
|
|
|
}
|
|
|
|
|
2014-11-18 14:21:14 +03:00
|
|
|
int blk_co_discard(BlockBackend *blk, int64_t sector_num, int nb_sectors)
|
|
|
|
{
|
2015-02-05 21:58:23 +03:00
|
|
|
int ret = blk_check_request(blk, sector_num, nb_sectors);
|
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-11-18 14:21:14 +03:00
|
|
|
return bdrv_co_discard(blk->bs, sector_num, nb_sectors);
|
|
|
|
}
|
|
|
|
|
|
|
|
int blk_co_flush(BlockBackend *blk)
|
|
|
|
{
|
|
|
|
return bdrv_co_flush(blk->bs);
|
|
|
|
}
|
|
|
|
|
2014-10-07 15:59:18 +04:00
|
|
|
int blk_flush(BlockBackend *blk)
|
|
|
|
{
|
|
|
|
return bdrv_flush(blk->bs);
|
|
|
|
}
|
|
|
|
|
|
|
|
int blk_flush_all(void)
|
|
|
|
{
|
|
|
|
return bdrv_flush_all();
|
|
|
|
}
|
|
|
|
|
|
|
|
void blk_drain_all(void)
|
|
|
|
{
|
|
|
|
bdrv_drain_all();
|
|
|
|
}
|
|
|
|
|
|
|
|
BlockdevOnError blk_get_on_error(BlockBackend *blk, bool is_read)
|
|
|
|
{
|
|
|
|
return bdrv_get_on_error(blk->bs, is_read);
|
|
|
|
}
|
|
|
|
|
|
|
|
BlockErrorAction blk_get_error_action(BlockBackend *blk, bool is_read,
|
|
|
|
int error)
|
|
|
|
{
|
|
|
|
return bdrv_get_error_action(blk->bs, is_read, error);
|
|
|
|
}
|
|
|
|
|
|
|
|
void blk_error_action(BlockBackend *blk, BlockErrorAction action,
|
|
|
|
bool is_read, int error)
|
|
|
|
{
|
|
|
|
bdrv_error_action(blk->bs, action, is_read, error);
|
|
|
|
}
|
|
|
|
|
|
|
|
int blk_is_read_only(BlockBackend *blk)
|
|
|
|
{
|
|
|
|
return bdrv_is_read_only(blk->bs);
|
|
|
|
}
|
|
|
|
|
|
|
|
int blk_is_sg(BlockBackend *blk)
|
|
|
|
{
|
|
|
|
return bdrv_is_sg(blk->bs);
|
|
|
|
}
|
|
|
|
|
|
|
|
int blk_enable_write_cache(BlockBackend *blk)
|
|
|
|
{
|
|
|
|
return bdrv_enable_write_cache(blk->bs);
|
|
|
|
}
|
|
|
|
|
|
|
|
void blk_set_enable_write_cache(BlockBackend *blk, bool wce)
|
|
|
|
{
|
|
|
|
bdrv_set_enable_write_cache(blk->bs, wce);
|
|
|
|
}
|
|
|
|
|
2014-11-18 14:21:14 +03:00
|
|
|
void blk_invalidate_cache(BlockBackend *blk, Error **errp)
|
|
|
|
{
|
|
|
|
bdrv_invalidate_cache(blk->bs, errp);
|
|
|
|
}
|
|
|
|
|
2014-10-07 15:59:18 +04:00
|
|
|
int blk_is_inserted(BlockBackend *blk)
|
|
|
|
{
|
|
|
|
return bdrv_is_inserted(blk->bs);
|
|
|
|
}
|
|
|
|
|
|
|
|
void blk_lock_medium(BlockBackend *blk, bool locked)
|
|
|
|
{
|
|
|
|
bdrv_lock_medium(blk->bs, locked);
|
|
|
|
}
|
|
|
|
|
|
|
|
void blk_eject(BlockBackend *blk, bool eject_flag)
|
|
|
|
{
|
|
|
|
bdrv_eject(blk->bs, eject_flag);
|
|
|
|
}
|
|
|
|
|
|
|
|
int blk_get_flags(BlockBackend *blk)
|
|
|
|
{
|
|
|
|
return bdrv_get_flags(blk->bs);
|
|
|
|
}
|
|
|
|
|
2015-02-02 16:52:20 +03:00
|
|
|
int blk_get_max_transfer_length(BlockBackend *blk)
|
|
|
|
{
|
|
|
|
return blk->bs->bl.max_transfer_length;
|
|
|
|
}
|
|
|
|
|
2014-10-07 15:59:18 +04:00
|
|
|
void blk_set_guest_block_size(BlockBackend *blk, int align)
|
|
|
|
{
|
|
|
|
bdrv_set_guest_block_size(blk->bs, align);
|
|
|
|
}
|
|
|
|
|
|
|
|
void *blk_blockalign(BlockBackend *blk, size_t size)
|
|
|
|
{
|
|
|
|
return qemu_blockalign(blk ? blk->bs : NULL, size);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool blk_op_is_blocked(BlockBackend *blk, BlockOpType op, Error **errp)
|
|
|
|
{
|
|
|
|
return bdrv_op_is_blocked(blk->bs, op, errp);
|
|
|
|
}
|
|
|
|
|
|
|
|
void blk_op_unblock(BlockBackend *blk, BlockOpType op, Error *reason)
|
|
|
|
{
|
|
|
|
bdrv_op_unblock(blk->bs, op, reason);
|
|
|
|
}
|
|
|
|
|
|
|
|
void blk_op_block_all(BlockBackend *blk, Error *reason)
|
|
|
|
{
|
|
|
|
bdrv_op_block_all(blk->bs, reason);
|
|
|
|
}
|
|
|
|
|
|
|
|
void blk_op_unblock_all(BlockBackend *blk, Error *reason)
|
|
|
|
{
|
|
|
|
bdrv_op_unblock_all(blk->bs, reason);
|
|
|
|
}
|
|
|
|
|
|
|
|
AioContext *blk_get_aio_context(BlockBackend *blk)
|
|
|
|
{
|
|
|
|
return bdrv_get_aio_context(blk->bs);
|
|
|
|
}
|
|
|
|
|
|
|
|
void blk_set_aio_context(BlockBackend *blk, AioContext *new_context)
|
|
|
|
{
|
|
|
|
bdrv_set_aio_context(blk->bs, 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)
|
|
|
|
{
|
|
|
|
bdrv_add_aio_context_notifier(blk->bs, attached_aio_context,
|
|
|
|
detach_aio_context, opaque);
|
|
|
|
}
|
|
|
|
|
|
|
|
void blk_remove_aio_context_notifier(BlockBackend *blk,
|
|
|
|
void (*attached_aio_context)(AioContext *,
|
|
|
|
void *),
|
|
|
|
void (*detach_aio_context)(void *),
|
|
|
|
void *opaque)
|
|
|
|
{
|
|
|
|
bdrv_remove_aio_context_notifier(blk->bs, attached_aio_context,
|
|
|
|
detach_aio_context, opaque);
|
|
|
|
}
|
|
|
|
|
2014-11-18 14:21:16 +03:00
|
|
|
void blk_add_close_notifier(BlockBackend *blk, Notifier *notify)
|
|
|
|
{
|
|
|
|
bdrv_add_close_notifier(blk->bs, notify);
|
|
|
|
}
|
|
|
|
|
2014-10-07 15:59:18 +04:00
|
|
|
void blk_io_plug(BlockBackend *blk)
|
|
|
|
{
|
|
|
|
bdrv_io_plug(blk->bs);
|
|
|
|
}
|
|
|
|
|
|
|
|
void blk_io_unplug(BlockBackend *blk)
|
|
|
|
{
|
|
|
|
bdrv_io_unplug(blk->bs);
|
|
|
|
}
|
|
|
|
|
|
|
|
BlockAcctStats *blk_get_stats(BlockBackend *blk)
|
|
|
|
{
|
|
|
|
return bdrv_get_stats(blk->bs);
|
|
|
|
}
|
|
|
|
|
|
|
|
void *blk_aio_get(const AIOCBInfo *aiocb_info, BlockBackend *blk,
|
|
|
|
BlockCompletionFunc *cb, void *opaque)
|
|
|
|
{
|
|
|
|
return qemu_aio_get(aiocb_info, blk_bs(blk), cb, 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)
|
|
|
|
{
|
2015-02-05 21:58:23 +03:00
|
|
|
int ret = blk_check_request(blk, sector_num, nb_sectors);
|
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-02-05 21:58:10 +03:00
|
|
|
return bdrv_co_write_zeroes(blk->bs, sector_num, nb_sectors, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
int blk_write_compressed(BlockBackend *blk, int64_t sector_num,
|
|
|
|
const uint8_t *buf, int nb_sectors)
|
|
|
|
{
|
2015-02-05 21:58:23 +03:00
|
|
|
int ret = blk_check_request(blk, sector_num, nb_sectors);
|
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-02-05 21:58:10 +03:00
|
|
|
return bdrv_write_compressed(blk->bs, sector_num, buf, nb_sectors);
|
|
|
|
}
|
|
|
|
|
|
|
|
int blk_truncate(BlockBackend *blk, int64_t offset)
|
|
|
|
{
|
|
|
|
return bdrv_truncate(blk->bs, offset);
|
|
|
|
}
|
|
|
|
|
|
|
|
int blk_discard(BlockBackend *blk, int64_t sector_num, int nb_sectors)
|
|
|
|
{
|
2015-02-05 21:58:23 +03:00
|
|
|
int ret = blk_check_request(blk, sector_num, nb_sectors);
|
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-02-05 21:58:10 +03:00
|
|
|
return bdrv_discard(blk->bs, sector_num, nb_sectors);
|
|
|
|
}
|
|
|
|
|
|
|
|
int blk_save_vmstate(BlockBackend *blk, const uint8_t *buf,
|
|
|
|
int64_t pos, int size)
|
|
|
|
{
|
|
|
|
return bdrv_save_vmstate(blk->bs, buf, pos, size);
|
|
|
|
}
|
|
|
|
|
|
|
|
int blk_load_vmstate(BlockBackend *blk, uint8_t *buf, int64_t pos, int size)
|
|
|
|
{
|
|
|
|
return bdrv_load_vmstate(blk->bs, buf, pos, size);
|
|
|
|
}
|
2015-02-16 14:47:57 +03:00
|
|
|
|
|
|
|
int blk_probe_blocksizes(BlockBackend *blk, BlockSizes *bsz)
|
|
|
|
{
|
|
|
|
return bdrv_probe_blocksizes(blk->bs, bsz);
|
|
|
|
}
|
|
|
|
|
|
|
|
int blk_probe_geometry(BlockBackend *blk, HDGeometry *geo)
|
|
|
|
{
|
|
|
|
return bdrv_probe_geometry(blk->bs, geo);
|
|
|
|
}
|