2009-04-06 03:14:04 +08:00
|
|
|
/*
|
|
|
|
* Command line utility to exercise the QEMU I/O path.
|
|
|
|
*
|
|
|
|
* Copyright (C) 2009 Red Hat, Inc.
|
|
|
|
* Copyright (c) 2003-2005 Silicon Graphics, Inc.
|
|
|
|
*
|
|
|
|
* This work is licensed under the terms of the GNU GPL, version 2 or later.
|
|
|
|
* See the COPYING file in the top-level directory.
|
|
|
|
*/
|
2009-09-01 04:16:16 +08:00
|
|
|
#include <sys/time.h>
|
2009-04-06 03:14:04 +08:00
|
|
|
#include <sys/types.h>
|
|
|
|
#include <stdarg.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <getopt.h>
|
2009-09-01 04:16:16 +08:00
|
|
|
#include <libgen.h>
|
2009-04-06 03:14:04 +08:00
|
|
|
|
2013-06-05 20:19:39 +08:00
|
|
|
#include "qemu-io.h"
|
2012-12-18 01:20:00 +08:00
|
|
|
#include "qemu/main-loop.h"
|
2013-10-11 20:02:10 +08:00
|
|
|
#include "qemu/option.h"
|
|
|
|
#include "qemu/config-file.h"
|
2013-11-14 18:54:17 +08:00
|
|
|
#include "qemu/readline.h"
|
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 19:59:04 +08:00
|
|
|
#include "sysemu/block-backend.h"
|
2012-12-18 01:19:44 +08:00
|
|
|
#include "block/block_int.h"
|
2012-03-13 00:36:07 +08:00
|
|
|
#include "trace/control.h"
|
2009-04-06 03:14:04 +08:00
|
|
|
|
2011-07-11 23:22:16 +08:00
|
|
|
#define CMD_NOFILE_OK 0x01
|
2009-04-06 03:14:04 +08:00
|
|
|
|
2014-03-06 05:23:00 +08:00
|
|
|
static char *progname;
|
2009-04-06 03:14:04 +08: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 19:59:04 +08:00
|
|
|
static BlockBackend *qemuio_blk;
|
2014-03-06 05:23:00 +08:00
|
|
|
static BlockDriverState *qemuio_bs;
|
2010-09-16 19:18:08 +08:00
|
|
|
|
2013-06-05 20:19:37 +08:00
|
|
|
/* qemu-io commands passed using -c */
|
|
|
|
static int ncmdline;
|
|
|
|
static char **cmdline;
|
|
|
|
|
2013-11-14 18:54:17 +08:00
|
|
|
static ReadLineState *readline_state;
|
|
|
|
|
2013-06-05 20:19:30 +08:00
|
|
|
static int close_f(BlockDriverState *bs, int argc, char **argv)
|
2009-04-06 03:14:04 +08: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 19:59:04 +08:00
|
|
|
blk_unref(qemuio_blk);
|
2013-06-05 20:19:30 +08:00
|
|
|
qemuio_bs = 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 19:59:04 +08:00
|
|
|
qemuio_blk = NULL;
|
2011-07-11 23:22:16 +08:00
|
|
|
return 0;
|
2009-04-06 03:14:04 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static const cmdinfo_t close_cmd = {
|
2011-07-11 23:22:16 +08:00
|
|
|
.name = "close",
|
|
|
|
.altname = "c",
|
|
|
|
.cfunc = close_f,
|
|
|
|
.oneline = "close the current open file",
|
2009-04-06 03:14:04 +08:00
|
|
|
};
|
|
|
|
|
2013-10-11 20:02:10 +08:00
|
|
|
static int openfile(char *name, int flags, int growable, QDict *opts)
|
2009-04-06 03:14:04 +08:00
|
|
|
{
|
2013-09-05 20:45:29 +08:00
|
|
|
Error *local_err = NULL;
|
|
|
|
|
2013-06-05 20:19:30 +08:00
|
|
|
if (qemuio_bs) {
|
2011-07-11 23:22:16 +08:00
|
|
|
fprintf(stderr, "file open already, try 'help close'\n");
|
2014-05-28 17:16:59 +08:00
|
|
|
QDECREF(opts);
|
2011-07-11 23:22:16 +08:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2014-10-07 19:59:05 +08:00
|
|
|
qemuio_blk = blk_new_with_bs("hda", &error_abort);
|
|
|
|
qemuio_bs = blk_bs(qemuio_blk);
|
2014-09-09 00:50:58 +08:00
|
|
|
|
2011-07-11 23:22:16 +08:00
|
|
|
if (growable) {
|
2014-09-09 00:50:58 +08:00
|
|
|
flags |= BDRV_O_PROTOCOL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (bdrv_open(&qemuio_bs, name, NULL, opts, flags, NULL, &local_err) < 0) {
|
|
|
|
fprintf(stderr, "%s: can't open%s%s: %s\n", progname,
|
|
|
|
name ? " device " : "", name ?: "",
|
|
|
|
error_get_pretty(local_err));
|
|
|
|
error_free(local_err);
|
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 19:59:04 +08:00
|
|
|
blk_unref(qemuio_blk);
|
2014-09-09 00:50:58 +08:00
|
|
|
qemuio_bs = 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 19:59:04 +08:00
|
|
|
qemuio_blk = NULL;
|
2014-09-09 00:50:58 +08:00
|
|
|
return 1;
|
2011-07-11 23:22:16 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
2009-04-06 03:14:04 +08:00
|
|
|
}
|
|
|
|
|
2011-07-11 23:22:16 +08:00
|
|
|
static void open_help(void)
|
2009-04-06 03:14:04 +08:00
|
|
|
{
|
2011-07-11 23:22:16 +08:00
|
|
|
printf(
|
2009-04-06 03:14:04 +08:00
|
|
|
"\n"
|
|
|
|
" opens a new file in the requested mode\n"
|
|
|
|
"\n"
|
|
|
|
" Example:\n"
|
|
|
|
" 'open -Cn /tmp/data' - creates/opens data file read-write and uncached\n"
|
|
|
|
"\n"
|
|
|
|
" Opens a file for subsequent use by all of the other qemu-io commands.\n"
|
|
|
|
" -r, -- open file read-only\n"
|
|
|
|
" -s, -- use snapshot file\n"
|
|
|
|
" -n, -- disable host cache\n"
|
2013-10-11 20:02:10 +08:00
|
|
|
" -g, -- allow file to grow (only applies to protocols)\n"
|
|
|
|
" -o, -- options to be given to the block driver"
|
2009-04-06 03:14:04 +08:00
|
|
|
"\n");
|
|
|
|
}
|
|
|
|
|
2013-06-05 20:19:30 +08:00
|
|
|
static int open_f(BlockDriverState *bs, int argc, char **argv);
|
2009-11-21 17:06:46 +08:00
|
|
|
|
|
|
|
static const cmdinfo_t open_cmd = {
|
2011-07-11 23:22:16 +08:00
|
|
|
.name = "open",
|
|
|
|
.altname = "o",
|
|
|
|
.cfunc = open_f,
|
|
|
|
.argmin = 1,
|
|
|
|
.argmax = -1,
|
|
|
|
.flags = CMD_NOFILE_OK,
|
2013-10-11 20:02:10 +08:00
|
|
|
.args = "[-Crsn] [-o options] [path]",
|
2011-07-11 23:22:16 +08:00
|
|
|
.oneline = "open the file specified by path",
|
|
|
|
.help = open_help,
|
2009-11-21 17:06:46 +08:00
|
|
|
};
|
2009-04-06 03:14:04 +08:00
|
|
|
|
2013-10-11 20:02:10 +08:00
|
|
|
static QemuOptsList empty_opts = {
|
|
|
|
.name = "drive",
|
2014-05-28 17:16:58 +08:00
|
|
|
.merge_lists = true,
|
2013-10-11 20:02:10 +08:00
|
|
|
.head = QTAILQ_HEAD_INITIALIZER(empty_opts.head),
|
|
|
|
.desc = {
|
|
|
|
/* no elements => accept any params */
|
|
|
|
{ /* end of list */ }
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2013-06-05 20:19:30 +08:00
|
|
|
static int open_f(BlockDriverState *bs, int argc, char **argv)
|
2009-04-06 03:14:04 +08:00
|
|
|
{
|
2011-07-11 23:22:16 +08:00
|
|
|
int flags = 0;
|
|
|
|
int readonly = 0;
|
|
|
|
int growable = 0;
|
|
|
|
int c;
|
2013-10-11 20:02:10 +08:00
|
|
|
QemuOpts *qopts;
|
2014-05-28 17:16:58 +08:00
|
|
|
QDict *opts;
|
2011-07-11 23:22:16 +08:00
|
|
|
|
2013-10-11 20:02:10 +08:00
|
|
|
while ((c = getopt(argc, argv, "snrgo:")) != EOF) {
|
2011-07-11 23:22:16 +08:00
|
|
|
switch (c) {
|
|
|
|
case 's':
|
|
|
|
flags |= BDRV_O_SNAPSHOT;
|
|
|
|
break;
|
|
|
|
case 'n':
|
|
|
|
flags |= BDRV_O_NOCACHE | BDRV_O_CACHE_WB;
|
|
|
|
break;
|
|
|
|
case 'r':
|
|
|
|
readonly = 1;
|
|
|
|
break;
|
|
|
|
case 'g':
|
|
|
|
growable = 1;
|
|
|
|
break;
|
2013-10-11 20:02:10 +08:00
|
|
|
case 'o':
|
2014-05-28 17:16:58 +08:00
|
|
|
if (!qemu_opts_parse(&empty_opts, optarg, 0)) {
|
2013-10-11 20:02:10 +08:00
|
|
|
printf("could not parse option list -- %s\n", optarg);
|
2014-05-28 17:16:58 +08:00
|
|
|
qemu_opts_reset(&empty_opts);
|
2013-10-11 20:02:10 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
break;
|
2011-07-11 23:22:16 +08:00
|
|
|
default:
|
2014-05-28 17:16:58 +08:00
|
|
|
qemu_opts_reset(&empty_opts);
|
2013-06-05 20:19:36 +08:00
|
|
|
return qemuio_command_usage(&open_cmd);
|
2010-01-17 22:48:13 +08:00
|
|
|
}
|
2011-07-11 23:22:16 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!readonly) {
|
|
|
|
flags |= BDRV_O_RDWR;
|
|
|
|
}
|
2009-04-06 03:14:04 +08:00
|
|
|
|
2014-05-28 17:16:58 +08:00
|
|
|
qopts = qemu_opts_find(&empty_opts, NULL);
|
|
|
|
opts = qopts ? qemu_opts_to_qdict(qopts, NULL) : NULL;
|
|
|
|
qemu_opts_reset(&empty_opts);
|
|
|
|
|
2013-12-21 02:28:20 +08:00
|
|
|
if (optind == argc - 1) {
|
|
|
|
return openfile(argv[optind], flags, growable, opts);
|
|
|
|
} else if (optind == argc) {
|
|
|
|
return openfile(NULL, flags, growable, opts);
|
|
|
|
} else {
|
2014-05-28 17:16:59 +08:00
|
|
|
QDECREF(opts);
|
2013-06-05 20:19:36 +08:00
|
|
|
return qemuio_command_usage(&open_cmd);
|
2011-07-11 23:22:16 +08:00
|
|
|
}
|
2009-04-06 03:14:04 +08:00
|
|
|
}
|
|
|
|
|
2013-06-05 20:19:34 +08:00
|
|
|
static int quit_f(BlockDriverState *bs, int argc, char **argv)
|
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const cmdinfo_t quit_cmd = {
|
|
|
|
.name = "quit",
|
|
|
|
.altname = "q",
|
|
|
|
.cfunc = quit_f,
|
|
|
|
.argmin = -1,
|
|
|
|
.argmax = -1,
|
|
|
|
.flags = CMD_FLAG_GLOBAL,
|
|
|
|
.oneline = "exit the program",
|
|
|
|
};
|
|
|
|
|
2009-04-06 03:14:04 +08:00
|
|
|
static void usage(const char *name)
|
|
|
|
{
|
2011-07-11 23:22:16 +08:00
|
|
|
printf(
|
2014-03-18 13:59:19 +08:00
|
|
|
"Usage: %s [-h] [-V] [-rsnm] [-c STRING] ... [file]\n"
|
2009-06-22 21:08:47 +08:00
|
|
|
"QEMU Disk exerciser\n"
|
2009-04-06 03:14:04 +08:00
|
|
|
"\n"
|
2014-03-18 13:59:19 +08:00
|
|
|
" -c, --cmd STRING execute command with its arguments\n"
|
|
|
|
" from the given string\n"
|
2009-04-06 03:14:04 +08:00
|
|
|
" -r, --read-only export read-only\n"
|
|
|
|
" -s, --snapshot use snapshot file\n"
|
|
|
|
" -n, --nocache disable host cache\n"
|
2009-07-16 05:11:21 +08:00
|
|
|
" -g, --growable allow file to grow (only applies to protocols)\n"
|
2009-04-06 03:14:04 +08:00
|
|
|
" -m, --misalign misalign allocations for O_DIRECT\n"
|
2009-08-20 22:58:35 +08:00
|
|
|
" -k, --native-aio use kernel AIO implementation (on Linux only)\n"
|
2012-04-18 18:07:39 +08:00
|
|
|
" -t, --cache=MODE use the given cache mode for the image\n"
|
2012-03-13 00:36:07 +08:00
|
|
|
" -T, --trace FILE enable trace events listed in the given file\n"
|
2009-04-06 03:14:04 +08:00
|
|
|
" -h, --help display this help and exit\n"
|
|
|
|
" -V, --version output version information and exit\n"
|
2014-03-18 13:59:19 +08:00
|
|
|
"\n"
|
|
|
|
"See '%s -c help' for information on available commands."
|
2009-04-06 03:14:04 +08:00
|
|
|
"\n",
|
2014-03-18 13:59:19 +08:00
|
|
|
name, name);
|
2009-04-06 03:14:04 +08:00
|
|
|
}
|
|
|
|
|
2013-06-05 20:19:37 +08:00
|
|
|
static char *get_prompt(void)
|
|
|
|
{
|
|
|
|
static char prompt[FILENAME_MAX + 2 /*"> "*/ + 1 /*"\0"*/ ];
|
|
|
|
|
|
|
|
if (!prompt[0]) {
|
|
|
|
snprintf(prompt, sizeof(prompt), "%s> ", progname);
|
|
|
|
}
|
|
|
|
|
|
|
|
return prompt;
|
|
|
|
}
|
|
|
|
|
2014-01-26 01:18:23 +08:00
|
|
|
static void GCC_FMT_ATTR(2, 3) readline_printf_func(void *opaque,
|
|
|
|
const char *fmt, ...)
|
2013-06-05 20:19:37 +08:00
|
|
|
{
|
2013-11-14 18:54:17 +08:00
|
|
|
va_list ap;
|
|
|
|
va_start(ap, fmt);
|
|
|
|
vprintf(fmt, ap);
|
|
|
|
va_end(ap);
|
2013-06-05 20:19:37 +08:00
|
|
|
}
|
2013-11-14 18:54:17 +08:00
|
|
|
|
|
|
|
static void readline_flush_func(void *opaque)
|
2013-06-05 20:19:37 +08:00
|
|
|
{
|
2013-11-14 18:54:17 +08:00
|
|
|
fflush(stdout);
|
2013-06-05 20:19:37 +08:00
|
|
|
}
|
|
|
|
|
2013-11-14 18:54:17 +08:00
|
|
|
static void readline_func(void *opaque, const char *str, void *readline_opaque)
|
2013-06-05 20:19:37 +08:00
|
|
|
{
|
2013-11-14 18:54:17 +08:00
|
|
|
char **line = readline_opaque;
|
|
|
|
*line = g_strdup(str);
|
|
|
|
}
|
|
|
|
|
2013-11-14 18:54:18 +08:00
|
|
|
static void completion_match(const char *cmd, void *opaque)
|
|
|
|
{
|
|
|
|
readline_add_completion(readline_state, cmd);
|
|
|
|
}
|
|
|
|
|
2013-11-14 18:54:17 +08:00
|
|
|
static void readline_completion_func(void *opaque, const char *str)
|
|
|
|
{
|
2013-11-14 18:54:18 +08:00
|
|
|
readline_set_completion_index(readline_state, strlen(str));
|
|
|
|
qemuio_complete_command(str, completion_match, NULL);
|
2013-11-14 18:54:17 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static char *fetchline_readline(void)
|
|
|
|
{
|
|
|
|
char *line = NULL;
|
|
|
|
|
|
|
|
readline_start(readline_state, get_prompt(), 0, readline_func, &line);
|
|
|
|
while (!line) {
|
|
|
|
int ch = getchar();
|
|
|
|
if (ch == EOF) {
|
|
|
|
break;
|
2013-06-05 20:19:37 +08:00
|
|
|
}
|
2013-11-14 18:54:17 +08:00
|
|
|
readline_handle_byte(readline_state, ch);
|
2013-06-05 20:19:37 +08:00
|
|
|
}
|
|
|
|
return line;
|
|
|
|
}
|
2013-11-14 18:54:17 +08:00
|
|
|
|
|
|
|
#define MAXREADLINESZ 1024
|
|
|
|
static char *fetchline_fgets(void)
|
2013-06-05 20:19:37 +08:00
|
|
|
{
|
|
|
|
char *p, *line = g_malloc(MAXREADLINESZ);
|
|
|
|
|
|
|
|
if (!fgets(line, MAXREADLINESZ, stdin)) {
|
|
|
|
g_free(line);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
p = line + strlen(line);
|
|
|
|
if (p != line && p[-1] == '\n') {
|
|
|
|
p[-1] = '\0';
|
|
|
|
}
|
|
|
|
|
|
|
|
return line;
|
|
|
|
}
|
2013-11-14 18:54:17 +08:00
|
|
|
|
|
|
|
static char *fetchline(void)
|
|
|
|
{
|
|
|
|
if (readline_state) {
|
|
|
|
return fetchline_readline();
|
|
|
|
} else {
|
|
|
|
return fetchline_fgets();
|
|
|
|
}
|
|
|
|
}
|
2013-06-05 20:19:37 +08:00
|
|
|
|
|
|
|
static void prep_fetchline(void *opaque)
|
|
|
|
{
|
|
|
|
int *fetchable = opaque;
|
|
|
|
|
|
|
|
qemu_set_fd_handler(STDIN_FILENO, NULL, NULL, NULL);
|
|
|
|
*fetchable= 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void command_loop(void)
|
|
|
|
{
|
|
|
|
int i, done = 0, fetchable = 0, prompted = 0;
|
|
|
|
char *input;
|
|
|
|
|
|
|
|
for (i = 0; !done && i < ncmdline; i++) {
|
2013-06-05 20:19:39 +08:00
|
|
|
done = qemuio_command(qemuio_bs, cmdline[i]);
|
2013-06-05 20:19:37 +08:00
|
|
|
}
|
|
|
|
if (cmdline) {
|
|
|
|
g_free(cmdline);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
while (!done) {
|
|
|
|
if (!prompted) {
|
|
|
|
printf("%s", get_prompt());
|
|
|
|
fflush(stdout);
|
|
|
|
qemu_set_fd_handler(STDIN_FILENO, prep_fetchline, NULL, &fetchable);
|
|
|
|
prompted = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
main_loop_wait(false);
|
|
|
|
|
|
|
|
if (!fetchable) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
input = fetchline();
|
|
|
|
if (input == NULL) {
|
|
|
|
break;
|
|
|
|
}
|
2013-06-05 20:19:39 +08:00
|
|
|
done = qemuio_command(qemuio_bs, input);
|
2013-06-05 20:19:37 +08:00
|
|
|
g_free(input);
|
|
|
|
|
|
|
|
prompted = 0;
|
|
|
|
fetchable = 0;
|
|
|
|
}
|
|
|
|
qemu_set_fd_handler(STDIN_FILENO, NULL, NULL, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void add_user_command(char *optarg)
|
|
|
|
{
|
block: Use g_new() & friends where that makes obvious sense
g_new(T, n) is neater than g_malloc(sizeof(T) * n). It's also safer,
for two reasons. One, it catches multiplication overflowing size_t.
Two, it returns T * rather than void *, which lets the compiler catch
more type errors.
Patch created with Coccinelle, with two manual changes on top:
* Add const to bdrv_iterate_format() to keep the types straight
* Convert the allocation in bdrv_drop_intermediate(), which Coccinelle
inexplicably misses
Coccinelle semantic patch:
@@
type T;
@@
-g_malloc(sizeof(T))
+g_new(T, 1)
@@
type T;
@@
-g_try_malloc(sizeof(T))
+g_try_new(T, 1)
@@
type T;
@@
-g_malloc0(sizeof(T))
+g_new0(T, 1)
@@
type T;
@@
-g_try_malloc0(sizeof(T))
+g_try_new0(T, 1)
@@
type T;
expression n;
@@
-g_malloc(sizeof(T) * (n))
+g_new(T, n)
@@
type T;
expression n;
@@
-g_try_malloc(sizeof(T) * (n))
+g_try_new(T, n)
@@
type T;
expression n;
@@
-g_malloc0(sizeof(T) * (n))
+g_new0(T, n)
@@
type T;
expression n;
@@
-g_try_malloc0(sizeof(T) * (n))
+g_try_new0(T, n)
@@
type T;
expression p, n;
@@
-g_realloc(p, sizeof(T) * (n))
+g_renew(T, p, n)
@@
type T;
expression p, n;
@@
-g_try_realloc(p, sizeof(T) * (n))
+g_try_renew(T, p, n)
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Jeff Cody <jcody@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2014-08-19 16:31:08 +08:00
|
|
|
cmdline = g_renew(char *, cmdline, ++ncmdline);
|
2013-06-05 20:19:37 +08:00
|
|
|
cmdline[ncmdline-1] = optarg;
|
|
|
|
}
|
|
|
|
|
2013-11-14 18:54:17 +08:00
|
|
|
static void reenable_tty_echo(void)
|
|
|
|
{
|
|
|
|
qemu_set_tty_echo(STDIN_FILENO, true);
|
|
|
|
}
|
|
|
|
|
2009-04-06 03:14:04 +08:00
|
|
|
int main(int argc, char **argv)
|
|
|
|
{
|
2011-07-11 23:22:16 +08:00
|
|
|
int readonly = 0;
|
|
|
|
int growable = 0;
|
2013-02-08 21:06:11 +08:00
|
|
|
const char *sopt = "hVc:d:rsnmgkt:T:";
|
2011-07-11 23:22:16 +08:00
|
|
|
const struct option lopt[] = {
|
|
|
|
{ "help", 0, NULL, 'h' },
|
|
|
|
{ "version", 0, NULL, 'V' },
|
|
|
|
{ "offset", 1, NULL, 'o' },
|
|
|
|
{ "cmd", 1, NULL, 'c' },
|
|
|
|
{ "read-only", 0, NULL, 'r' },
|
|
|
|
{ "snapshot", 0, NULL, 's' },
|
|
|
|
{ "nocache", 0, NULL, 'n' },
|
|
|
|
{ "misalign", 0, NULL, 'm' },
|
|
|
|
{ "growable", 0, NULL, 'g' },
|
|
|
|
{ "native-aio", 0, NULL, 'k' },
|
2013-02-08 21:06:11 +08:00
|
|
|
{ "discard", 1, NULL, 'd' },
|
2012-04-18 18:07:39 +08:00
|
|
|
{ "cache", 1, NULL, 't' },
|
2012-03-13 00:36:07 +08:00
|
|
|
{ "trace", 1, NULL, 'T' },
|
2011-07-11 23:22:16 +08:00
|
|
|
{ NULL, 0, NULL, 0 }
|
|
|
|
};
|
|
|
|
int c;
|
|
|
|
int opt_index = 0;
|
2013-02-08 21:06:11 +08:00
|
|
|
int flags = BDRV_O_UNMAP;
|
2014-09-18 19:30:49 +08:00
|
|
|
Error *local_error = NULL;
|
2011-07-11 23:22:16 +08:00
|
|
|
|
2013-07-23 16:30:11 +08:00
|
|
|
#ifdef CONFIG_POSIX
|
|
|
|
signal(SIGPIPE, SIG_IGN);
|
|
|
|
#endif
|
|
|
|
|
2011-07-11 23:22:16 +08:00
|
|
|
progname = basename(argv[0]);
|
2014-02-10 14:48:51 +08:00
|
|
|
qemu_init_exec_dir(argv[0]);
|
2011-07-11 23:22:16 +08:00
|
|
|
|
|
|
|
while ((c = getopt_long(argc, argv, sopt, lopt, &opt_index)) != -1) {
|
|
|
|
switch (c) {
|
|
|
|
case 's':
|
|
|
|
flags |= BDRV_O_SNAPSHOT;
|
|
|
|
break;
|
|
|
|
case 'n':
|
|
|
|
flags |= BDRV_O_NOCACHE | BDRV_O_CACHE_WB;
|
|
|
|
break;
|
2013-02-08 21:06:11 +08:00
|
|
|
case 'd':
|
|
|
|
if (bdrv_parse_discard_flags(optarg, &flags) < 0) {
|
|
|
|
error_report("Invalid discard option: %s", optarg);
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
break;
|
2011-07-11 23:22:16 +08:00
|
|
|
case 'c':
|
|
|
|
add_user_command(optarg);
|
|
|
|
break;
|
|
|
|
case 'r':
|
|
|
|
readonly = 1;
|
|
|
|
break;
|
|
|
|
case 'm':
|
2014-03-06 05:23:00 +08:00
|
|
|
qemuio_misalign = true;
|
2011-07-11 23:22:16 +08:00
|
|
|
break;
|
|
|
|
case 'g':
|
|
|
|
growable = 1;
|
|
|
|
break;
|
|
|
|
case 'k':
|
|
|
|
flags |= BDRV_O_NATIVE_AIO;
|
|
|
|
break;
|
2012-04-18 18:07:39 +08:00
|
|
|
case 't':
|
|
|
|
if (bdrv_parse_cache_flags(optarg, &flags) < 0) {
|
|
|
|
error_report("Invalid cache option: %s", optarg);
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
break;
|
2012-03-13 00:36:07 +08:00
|
|
|
case 'T':
|
2014-05-27 21:02:14 +08:00
|
|
|
if (!trace_init_backends(optarg, NULL)) {
|
2012-03-13 00:36:07 +08:00
|
|
|
exit(1); /* error message will have been printed */
|
|
|
|
}
|
|
|
|
break;
|
2011-07-11 23:22:16 +08:00
|
|
|
case 'V':
|
2013-06-05 20:19:40 +08:00
|
|
|
printf("%s version %s\n", progname, QEMU_VERSION);
|
2011-07-11 23:22:16 +08:00
|
|
|
exit(0);
|
|
|
|
case 'h':
|
|
|
|
usage(progname);
|
|
|
|
exit(0);
|
|
|
|
default:
|
|
|
|
usage(progname);
|
|
|
|
exit(1);
|
2010-01-17 22:48:13 +08:00
|
|
|
}
|
2011-07-11 23:22:16 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if ((argc - optind) > 1) {
|
|
|
|
usage(progname);
|
|
|
|
exit(1);
|
|
|
|
}
|
2009-04-06 03:14:04 +08:00
|
|
|
|
2014-09-18 19:30:49 +08:00
|
|
|
if (qemu_init_main_loop(&local_error)) {
|
|
|
|
error_report("%s", error_get_pretty(local_error));
|
|
|
|
error_free(local_error);
|
|
|
|
exit(1);
|
|
|
|
}
|
2012-11-04 01:10:17 +08:00
|
|
|
bdrv_init();
|
2012-02-19 22:24:59 +08:00
|
|
|
|
2011-07-11 23:22:16 +08:00
|
|
|
/* initialize commands */
|
2013-06-05 20:19:36 +08:00
|
|
|
qemuio_add_command(&quit_cmd);
|
|
|
|
qemuio_add_command(&open_cmd);
|
|
|
|
qemuio_add_command(&close_cmd);
|
2011-07-11 23:22:16 +08:00
|
|
|
|
2013-11-14 18:54:17 +08:00
|
|
|
if (isatty(STDIN_FILENO)) {
|
|
|
|
readline_state = readline_init(readline_printf_func,
|
|
|
|
readline_flush_func,
|
|
|
|
NULL,
|
|
|
|
readline_completion_func);
|
|
|
|
qemu_set_tty_echo(STDIN_FILENO, false);
|
|
|
|
atexit(reenable_tty_echo);
|
|
|
|
}
|
|
|
|
|
2011-07-11 23:22:16 +08:00
|
|
|
/* open the device */
|
|
|
|
if (!readonly) {
|
|
|
|
flags |= BDRV_O_RDWR;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((argc - optind) == 1) {
|
2013-10-11 20:02:10 +08:00
|
|
|
openfile(argv[optind], flags, growable, NULL);
|
2011-07-11 23:22:16 +08:00
|
|
|
}
|
|
|
|
command_loop();
|
2009-04-06 03:14:04 +08:00
|
|
|
|
2011-07-11 23:22:16 +08:00
|
|
|
/*
|
2011-11-30 20:23:43 +08:00
|
|
|
* Make sure all outstanding requests complete before the program exits.
|
2011-07-11 23:22:16 +08:00
|
|
|
*/
|
2011-11-30 20:23:43 +08:00
|
|
|
bdrv_drain_all();
|
2009-06-21 03:10:44 +08: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 19:59:04 +08:00
|
|
|
blk_unref(qemuio_blk);
|
2013-11-14 18:54:17 +08:00
|
|
|
g_free(readline_state);
|
2011-07-11 23:22:16 +08:00
|
|
|
return 0;
|
2009-04-06 03:14:04 +08:00
|
|
|
}
|