2009-04-05 21:14:04 +02: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.
|
|
|
|
*/
|
2018-02-01 12:18:39 +01:00
|
|
|
|
2016-01-18 19:01:42 +01:00
|
|
|
#include "qemu/osdep.h"
|
2009-04-05 21:14:04 +02:00
|
|
|
#include <getopt.h>
|
2009-08-31 22:16:16 +02:00
|
|
|
#include <libgen.h>
|
2018-02-12 19:48:49 +01:00
|
|
|
#ifndef _WIN32
|
|
|
|
#include <termios.h>
|
|
|
|
#endif
|
2009-04-05 21:14:04 +02:00
|
|
|
|
2019-05-23 16:35:08 +02:00
|
|
|
#include "qemu-common.h"
|
include/qemu/osdep.h: Don't include qapi/error.h
Commit 57cb38b included qapi/error.h into qemu/osdep.h to get the
Error typedef. Since then, we've moved to include qemu/osdep.h
everywhere. Its file comment explains: "To avoid getting into
possible circular include dependencies, this file should not include
any other QEMU headers, with the exceptions of config-host.h,
compiler.h, os-posix.h and os-win32.h, all of which are doing a
similar job to this file and are under similar constraints."
qapi/error.h doesn't do a similar job, and it doesn't adhere to
similar constraints: it includes qapi-types.h. That's in excess of
100KiB of crap most .c files don't actually need.
Add the typedef to qemu/typedefs.h, and include that instead of
qapi/error.h. Include qapi/error.h in .c files that need it and don't
get it now. Include qapi-types.h in qom/object.h for uint16List.
Update scripts/clean-includes accordingly. Update it further to match
reality: replace config.h by config-target.h, add sysemu/os-posix.h,
sysemu/os-win32.h. Update the list of includes in the qemu/osdep.h
comment quoted above similarly.
This reduces the number of objects depending on qapi/error.h from "all
of them" to less than a third. Unfortunately, the number depending on
qapi-types.h shrinks only a little. More work is needed for that one.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
[Fix compilation without the spice devel packages. - Paolo]
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2016-03-14 09:01:28 +01:00
|
|
|
#include "qapi/error.h"
|
2013-06-05 14:19:39 +02:00
|
|
|
#include "qemu-io.h"
|
2015-03-17 18:29:20 +01:00
|
|
|
#include "qemu/error-report.h"
|
2012-12-17 18:20:00 +01:00
|
|
|
#include "qemu/main-loop.h"
|
2019-05-23 16:35:07 +02:00
|
|
|
#include "qemu/module.h"
|
2013-10-11 14:02:10 +02:00
|
|
|
#include "qemu/option.h"
|
|
|
|
#include "qemu/config-file.h"
|
2013-11-14 11:54:17 +01:00
|
|
|
#include "qemu/readline.h"
|
2016-06-17 16:44:11 +02:00
|
|
|
#include "qemu/log.h"
|
2020-08-25 12:38:48 +02:00
|
|
|
#include "qemu/sockets.h"
|
2015-03-17 18:29:20 +01:00
|
|
|
#include "qapi/qmp/qstring.h"
|
2018-02-01 12:18:39 +01:00
|
|
|
#include "qapi/qmp/qdict.h"
|
2016-02-17 11:10:16 +01:00
|
|
|
#include "qom/object_interfaces.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 13:59:04 +02:00
|
|
|
#include "sysemu/block-backend.h"
|
2012-12-17 18:19:44 +01:00
|
|
|
#include "block/block_int.h"
|
2012-03-12 17:36:07 +01:00
|
|
|
#include "trace/control.h"
|
2016-04-06 13:12:06 +02:00
|
|
|
#include "crypto/init.h"
|
2017-08-03 18:33:51 +02:00
|
|
|
#include "qemu-version.h"
|
2009-04-05 21:14:04 +02:00
|
|
|
|
2011-07-11 17:22:16 +02:00
|
|
|
#define CMD_NOFILE_OK 0x01
|
2009-04-05 21:14:04 +02: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 13:59:04 +02:00
|
|
|
static BlockBackend *qemuio_blk;
|
2018-05-09 21:42:58 +02:00
|
|
|
static bool quit_qemu_io;
|
2010-09-16 13:18:08 +02:00
|
|
|
|
2013-06-05 14:19:37 +02:00
|
|
|
/* qemu-io commands passed using -c */
|
|
|
|
static int ncmdline;
|
|
|
|
static char **cmdline;
|
2016-02-17 11:10:18 +01:00
|
|
|
static bool imageOpts;
|
2013-06-05 14:19:37 +02:00
|
|
|
|
2013-11-14 11:54:17 +01:00
|
|
|
static ReadLineState *readline_state;
|
|
|
|
|
2018-02-12 19:48:49 +01:00
|
|
|
static int ttyEOF;
|
|
|
|
|
|
|
|
static int get_eof_char(void)
|
|
|
|
{
|
|
|
|
#ifdef _WIN32
|
|
|
|
return 0x4; /* Ctrl-D */
|
|
|
|
#else
|
|
|
|
struct termios tty;
|
|
|
|
if (tcgetattr(STDIN_FILENO, &tty) != 0) {
|
|
|
|
if (errno == ENOTTY) {
|
|
|
|
return 0x0; /* just expect read() == 0 */
|
|
|
|
} else {
|
|
|
|
return 0x4; /* Ctrl-D */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return tty.c_cc[VEOF];
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2018-05-09 21:42:59 +02:00
|
|
|
static int close_f(BlockBackend *blk, int argc, char **argv)
|
2009-04-05 21:14:04 +02: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 13:59:04 +02:00
|
|
|
blk_unref(qemuio_blk);
|
|
|
|
qemuio_blk = NULL;
|
2018-05-09 21:42:59 +02:00
|
|
|
return 0;
|
2009-04-05 21:14:04 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static const cmdinfo_t close_cmd = {
|
2011-07-11 17:22:16 +02:00
|
|
|
.name = "close",
|
|
|
|
.altname = "c",
|
|
|
|
.cfunc = close_f,
|
|
|
|
.oneline = "close the current open file",
|
2009-04-05 21:14:04 +02:00
|
|
|
};
|
|
|
|
|
2017-05-02 18:35:41 +02:00
|
|
|
static int openfile(char *name, int flags, bool writethrough, bool force_share,
|
|
|
|
QDict *opts)
|
2009-04-05 21:14:04 +02:00
|
|
|
{
|
2013-09-05 14:45:29 +02:00
|
|
|
Error *local_err = NULL;
|
|
|
|
|
2015-02-05 19:58:20 +01:00
|
|
|
if (qemuio_blk) {
|
2015-12-18 16:35:18 +01:00
|
|
|
error_report("file open already, try 'help close'");
|
2018-04-19 17:01:43 +02:00
|
|
|
qobject_unref(opts);
|
2011-07-11 17:22:16 +02:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2017-05-02 18:35:41 +02:00
|
|
|
if (force_share) {
|
|
|
|
if (!opts) {
|
|
|
|
opts = qdict_new();
|
|
|
|
}
|
|
|
|
if (qdict_haskey(opts, BDRV_OPT_FORCE_SHARE)
|
qemu-io: Use purely string blockdev options
Currently, qemu-io only uses string-valued blockdev options (as all are
converted directly from QemuOpts) -- with one exception: -U adds the
force-share option as a boolean. This in itself is already a bit
questionable, but a real issue is that it also assumes the value already
existing in the options QDict would be a boolean, which is wrong.
That has the following effect:
$ ./qemu-io -r -U --image-opts \
driver=file,filename=/dev/null,force-share=off
[1] 15200 segmentation fault (core dumped) ./qemu-io -r -U
--image-opts driver=file,filename=/dev/null,force-share=off
Since @opts is converted from QemuOpts, the value must be a string, and
we have to compare it as such. Consequently, it makes sense to also set
it as a string instead of a boolean.
Cc: qemu-stable@nongnu.org
Signed-off-by: Max Reitz <mreitz@redhat.com>
Message-id: 20180502202051.15493-2-mreitz@redhat.com
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
2018-05-02 22:20:49 +02:00
|
|
|
&& strcmp(qdict_get_str(opts, BDRV_OPT_FORCE_SHARE), "on")) {
|
2017-05-02 18:35:41 +02:00
|
|
|
error_report("-U conflicts with image options");
|
2018-04-19 17:01:43 +02:00
|
|
|
qobject_unref(opts);
|
2017-05-02 18:35:41 +02:00
|
|
|
return 1;
|
|
|
|
}
|
qemu-io: Use purely string blockdev options
Currently, qemu-io only uses string-valued blockdev options (as all are
converted directly from QemuOpts) -- with one exception: -U adds the
force-share option as a boolean. This in itself is already a bit
questionable, but a real issue is that it also assumes the value already
existing in the options QDict would be a boolean, which is wrong.
That has the following effect:
$ ./qemu-io -r -U --image-opts \
driver=file,filename=/dev/null,force-share=off
[1] 15200 segmentation fault (core dumped) ./qemu-io -r -U
--image-opts driver=file,filename=/dev/null,force-share=off
Since @opts is converted from QemuOpts, the value must be a string, and
we have to compare it as such. Consequently, it makes sense to also set
it as a string instead of a boolean.
Cc: qemu-stable@nongnu.org
Signed-off-by: Max Reitz <mreitz@redhat.com>
Message-id: 20180502202051.15493-2-mreitz@redhat.com
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
2018-05-02 22:20:49 +02:00
|
|
|
qdict_put_str(opts, BDRV_OPT_FORCE_SHARE, "on");
|
2017-05-02 18:35:41 +02:00
|
|
|
}
|
2016-03-16 19:54:38 +01:00
|
|
|
qemuio_blk = blk_new_open(name, NULL, opts, flags, &local_err);
|
2015-02-05 19:58:20 +01:00
|
|
|
if (!qemuio_blk) {
|
2015-12-18 16:35:18 +01:00
|
|
|
error_reportf_err(local_err, "can't open%s%s: ",
|
|
|
|
name ? " device " : "", name ?: "");
|
2014-09-08 18:50:58 +02:00
|
|
|
return 1;
|
2011-07-11 17:22:16 +02:00
|
|
|
}
|
|
|
|
|
2016-03-15 12:52:30 +01:00
|
|
|
blk_set_enable_write_cache(qemuio_blk, !writethrough);
|
2015-05-12 18:09:21 +02:00
|
|
|
|
2011-07-11 17:22:16 +02:00
|
|
|
return 0;
|
2009-04-05 21:14:04 +02:00
|
|
|
}
|
|
|
|
|
2011-07-11 17:22:16 +02:00
|
|
|
static void open_help(void)
|
2009-04-05 21:14:04 +02:00
|
|
|
{
|
2011-07-11 17:22:16 +02:00
|
|
|
printf(
|
2009-04-05 21:14:04 +02:00
|
|
|
"\n"
|
|
|
|
" opens a new file in the requested mode\n"
|
|
|
|
"\n"
|
|
|
|
" Example:\n"
|
2016-05-08 05:16:40 +02:00
|
|
|
" 'open -n -o driver=raw /tmp/data' - opens raw data file read-write, uncached\n"
|
2009-04-05 21:14:04 +02:00
|
|
|
"\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"
|
2017-10-05 21:02:43 +02:00
|
|
|
" -C, -- use copy-on-read\n"
|
2016-05-08 05:16:41 +02:00
|
|
|
" -n, -- disable host cache, short for -t none\n"
|
2017-05-02 18:35:41 +02:00
|
|
|
" -U, -- force shared permissions\n"
|
2020-01-20 15:18:54 +01:00
|
|
|
" -k, -- use kernel AIO implementation (Linux only, prefer use of -i)\n"
|
|
|
|
" -i, -- use AIO mode (threads, native or io_uring)\n"
|
2016-05-08 05:16:41 +02:00
|
|
|
" -t, -- use the given cache mode for the image\n"
|
|
|
|
" -d, -- use the given discard mode for the image\n"
|
2013-10-11 14:02:10 +02:00
|
|
|
" -o, -- options to be given to the block driver"
|
2009-04-05 21:14:04 +02:00
|
|
|
"\n");
|
|
|
|
}
|
|
|
|
|
2018-05-09 21:42:59 +02:00
|
|
|
static int open_f(BlockBackend *blk, int argc, char **argv);
|
2009-11-21 10:06:46 +01:00
|
|
|
|
|
|
|
static const cmdinfo_t open_cmd = {
|
2011-07-11 17:22:16 +02:00
|
|
|
.name = "open",
|
|
|
|
.altname = "o",
|
|
|
|
.cfunc = open_f,
|
|
|
|
.argmin = 1,
|
|
|
|
.argmax = -1,
|
|
|
|
.flags = CMD_NOFILE_OK,
|
2017-10-05 21:02:43 +02:00
|
|
|
.args = "[-rsCnkU] [-t cache] [-d discard] [-o options] [path]",
|
2011-07-11 17:22:16 +02:00
|
|
|
.oneline = "open the file specified by path",
|
|
|
|
.help = open_help,
|
2009-11-21 10:06:46 +01:00
|
|
|
};
|
2009-04-05 21:14:04 +02:00
|
|
|
|
2013-10-11 14:02:10 +02:00
|
|
|
static QemuOptsList empty_opts = {
|
|
|
|
.name = "drive",
|
2014-05-28 11:16:58 +02:00
|
|
|
.merge_lists = true,
|
2013-10-11 14:02:10 +02:00
|
|
|
.head = QTAILQ_HEAD_INITIALIZER(empty_opts.head),
|
|
|
|
.desc = {
|
|
|
|
/* no elements => accept any params */
|
|
|
|
{ /* end of list */ }
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2018-05-09 21:42:59 +02:00
|
|
|
static int open_f(BlockBackend *blk, int argc, char **argv)
|
2009-04-05 21:14:04 +02:00
|
|
|
{
|
2016-05-08 05:16:41 +02:00
|
|
|
int flags = BDRV_O_UNMAP;
|
2011-07-11 17:22:16 +02:00
|
|
|
int readonly = 0;
|
2016-03-15 12:52:30 +01:00
|
|
|
bool writethrough = true;
|
2011-07-11 17:22:16 +02:00
|
|
|
int c;
|
2018-05-09 21:42:59 +02:00
|
|
|
int ret;
|
2013-10-11 14:02:10 +02:00
|
|
|
QemuOpts *qopts;
|
2014-05-28 11:16:58 +02:00
|
|
|
QDict *opts;
|
2017-05-02 18:35:41 +02:00
|
|
|
bool force_share = false;
|
2011-07-11 17:22:16 +02:00
|
|
|
|
2020-01-20 15:18:54 +01:00
|
|
|
while ((c = getopt(argc, argv, "snCro:ki:t:d:U")) != -1) {
|
2011-07-11 17:22:16 +02:00
|
|
|
switch (c) {
|
|
|
|
case 's':
|
|
|
|
flags |= BDRV_O_SNAPSHOT;
|
|
|
|
break;
|
|
|
|
case 'n':
|
2016-03-15 12:52:30 +01:00
|
|
|
flags |= BDRV_O_NOCACHE;
|
|
|
|
writethrough = false;
|
2011-07-11 17:22:16 +02:00
|
|
|
break;
|
2017-10-05 21:02:43 +02:00
|
|
|
case 'C':
|
|
|
|
flags |= BDRV_O_COPY_ON_READ;
|
|
|
|
break;
|
2011-07-11 17:22:16 +02:00
|
|
|
case 'r':
|
|
|
|
readonly = 1;
|
|
|
|
break;
|
2016-05-08 05:16:41 +02:00
|
|
|
case 'k':
|
|
|
|
flags |= BDRV_O_NATIVE_AIO;
|
|
|
|
break;
|
|
|
|
case 't':
|
|
|
|
if (bdrv_parse_cache_mode(optarg, &flags, &writethrough) < 0) {
|
|
|
|
error_report("Invalid cache option: %s", optarg);
|
|
|
|
qemu_opts_reset(&empty_opts);
|
2018-05-09 21:42:59 +02:00
|
|
|
return -EINVAL;
|
2016-05-08 05:16:41 +02:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 'd':
|
|
|
|
if (bdrv_parse_discard_flags(optarg, &flags) < 0) {
|
|
|
|
error_report("Invalid discard option: %s", optarg);
|
|
|
|
qemu_opts_reset(&empty_opts);
|
2018-05-09 21:42:59 +02:00
|
|
|
return -EINVAL;
|
2016-05-08 05:16:41 +02:00
|
|
|
}
|
|
|
|
break;
|
2020-01-20 15:18:54 +01:00
|
|
|
case 'i':
|
|
|
|
if (bdrv_parse_aio(optarg, &flags) < 0) {
|
|
|
|
error_report("Invalid aio option: %s", optarg);
|
|
|
|
qemu_opts_reset(&empty_opts);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
break;
|
2013-10-11 14:02:10 +02:00
|
|
|
case 'o':
|
2016-02-17 11:10:18 +01:00
|
|
|
if (imageOpts) {
|
|
|
|
printf("--image-opts and 'open -o' are mutually exclusive\n");
|
2016-05-08 05:16:41 +02:00
|
|
|
qemu_opts_reset(&empty_opts);
|
2018-05-09 21:42:59 +02:00
|
|
|
return -EINVAL;
|
2016-02-17 11:10:18 +01:00
|
|
|
}
|
QemuOpts: Wean off qerror_report_err()
qerror_report_err() is a transitional interface to help with
converting existing monitor commands to QMP. It should not be used
elsewhere.
The only remaining user in qemu-option.c is qemu_opts_parse(). Is it
used in QMP context? If not, we can simply replace
qerror_report_err() by error_report_err().
The uses in qemu-img.c, qemu-io.c, qemu-nbd.c and under tests/ are
clearly not in QMP context.
The uses in vl.c aren't either, because the only QMP command handlers
there are qmp_query_status() and qmp_query_machines(), and they don't
call it.
Remaining uses:
* drive_def(): Command line -drive and such, HMP drive_add and pci_add
* hmp_chardev_add(): HMP chardev-add
* monitor_parse_command(): HMP core
* tmp_config_parse(): Command line -tpmdev
* net_host_device_add(): HMP host_net_add
* net_client_parse(): Command line -net and -netdev
* qemu_global_option(): Command line -global
* vnc_parse_func(): Command line -display, -vnc, default display, HMP
change, QMP change. Bummer.
* qemu_pci_hot_add_nic(): HMP pci_add
* usb_net_init(): Command line -usbdevice, HMP usb_add
Propagate errors through qemu_opts_parse(). Create a convenience
function qemu_opts_parse_noisily() that passes errors to
error_report_err(). Switch all non-QMP users outside tests to it.
That leaves vnc_parse_func(). Propagate errors through it. Since I'm
touching it anyway, rename it to vnc_parse().
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Luiz Capitulino <lcapitulino@redhat.com>
2015-02-13 12:50:26 +01:00
|
|
|
if (!qemu_opts_parse_noisily(&empty_opts, optarg, false)) {
|
2014-05-28 11:16:58 +02:00
|
|
|
qemu_opts_reset(&empty_opts);
|
2018-05-09 21:42:59 +02:00
|
|
|
return -EINVAL;
|
2013-10-11 14:02:10 +02:00
|
|
|
}
|
|
|
|
break;
|
2017-05-02 18:35:41 +02:00
|
|
|
case 'U':
|
|
|
|
force_share = true;
|
|
|
|
break;
|
2011-07-11 17:22:16 +02:00
|
|
|
default:
|
2014-05-28 11:16:58 +02:00
|
|
|
qemu_opts_reset(&empty_opts);
|
2018-05-09 21:42:58 +02:00
|
|
|
qemuio_command_usage(&open_cmd);
|
2018-05-09 21:42:59 +02:00
|
|
|
return -EINVAL;
|
2010-01-17 15:48:13 +01:00
|
|
|
}
|
2011-07-11 17:22:16 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!readonly) {
|
|
|
|
flags |= BDRV_O_RDWR;
|
|
|
|
}
|
2009-04-05 21:14:04 +02:00
|
|
|
|
2016-02-17 11:10:18 +01:00
|
|
|
if (imageOpts && (optind == argc - 1)) {
|
|
|
|
if (!qemu_opts_parse_noisily(&empty_opts, argv[optind], false)) {
|
|
|
|
qemu_opts_reset(&empty_opts);
|
2018-05-09 21:42:59 +02:00
|
|
|
return -EINVAL;
|
2016-02-17 11:10:18 +01:00
|
|
|
}
|
|
|
|
optind++;
|
|
|
|
}
|
|
|
|
|
2014-05-28 11:16:58 +02:00
|
|
|
qopts = qemu_opts_find(&empty_opts, NULL);
|
|
|
|
opts = qopts ? qemu_opts_to_qdict(qopts, NULL) : NULL;
|
|
|
|
qemu_opts_reset(&empty_opts);
|
|
|
|
|
2013-12-20 19:28:20 +01:00
|
|
|
if (optind == argc - 1) {
|
2018-05-09 21:42:59 +02:00
|
|
|
ret = openfile(argv[optind], flags, writethrough, force_share, opts);
|
2013-12-20 19:28:20 +01:00
|
|
|
} else if (optind == argc) {
|
2018-05-09 21:42:59 +02:00
|
|
|
ret = openfile(NULL, flags, writethrough, force_share, opts);
|
2013-12-20 19:28:20 +01:00
|
|
|
} else {
|
2018-04-19 17:01:43 +02:00
|
|
|
qobject_unref(opts);
|
qemu-io: Don't die on second open
Most callback commands in qemu-io return 0 to keep the interpreter
loop running, or 1 to quit immediately. However, open_f() just
passed through the return value of openfile(), which has different
semantics of returning 0 if a file was opened, or 1 on any failure.
As a result of mixing the return semantics, we are forcing the
qemu-io interpreter to exit early on any failures, which is rather
annoying when some of the failures are obviously trying to give
the user a hint of how to proceed (if we didn't then kill qemu-io
out from under the user's feet):
$ qemu-io
qemu-io> open foo
qemu-io> open foo
file open already, try 'help close'
$ echo $?
0
In general, we WANT openfile() to report failures, since it is the
function used in the form 'qemu-io -c "$something" no_such_file'
for performing one or more -c options on a single file, and it is
not worth attempting $something if the file itself cannot be opened.
So the solution is to fix open_f() to always return 0 (when we are
in interactive mode, even failure to open should not end the
session), and save the return value of openfile() for command line
use in main().
Note, however, that we do have some qemu-iotests that do 'qemu-io
-c "open file" -c "$something"'; such tests will now proceed to
attempt $something whether or not the open succeeded, the same way
as if the two commands had been attempted in interactive mode. As
such, the expected output for those tests has to be modified. But it
also means that it is now possible to use -c close and have a single
qemu-io command line operate on more than one file even without
using interactive mode. Although the '-c open' action is a subtle
change in behavior, remember that qemu-io is for debugging purposes,
so as long as it serves the needs of qemu-iotests while still being
reasonable for interactive use, it should not be a problem that we
are changing tests to the new behavior.
This has been awkward since at least as far back as commit
e3aff4f, in 2009.
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2017-06-05 22:38:42 +02:00
|
|
|
qemuio_command_usage(&open_cmd);
|
2018-05-09 21:42:59 +02:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ret) {
|
|
|
|
return -EINVAL;
|
2011-07-11 17:22:16 +02:00
|
|
|
}
|
2018-05-09 21:42:59 +02:00
|
|
|
|
|
|
|
return 0;
|
2009-04-05 21:14:04 +02:00
|
|
|
}
|
|
|
|
|
2018-05-09 21:42:59 +02:00
|
|
|
static int quit_f(BlockBackend *blk, int argc, char **argv)
|
2013-06-05 14:19:34 +02:00
|
|
|
{
|
2018-05-09 21:42:58 +02:00
|
|
|
quit_qemu_io = true;
|
2018-05-09 21:42:59 +02:00
|
|
|
return 0;
|
2013-06-05 14:19:34 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
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-05 21:14:04 +02:00
|
|
|
static void usage(const char *name)
|
|
|
|
{
|
2011-07-11 17:22:16 +02:00
|
|
|
printf(
|
2016-05-08 05:16:40 +02:00
|
|
|
"Usage: %s [OPTIONS]... [-c STRING]... [file]\n"
|
2009-06-22 15:08:47 +02:00
|
|
|
"QEMU Disk exerciser\n"
|
2009-04-05 21:14:04 +02:00
|
|
|
"\n"
|
2016-02-17 11:10:16 +01:00
|
|
|
" --object OBJECTDEF define an object such as 'secret' for\n"
|
|
|
|
" passwords and/or encryption keys\n"
|
2016-05-08 05:16:40 +02:00
|
|
|
" --image-opts treat file as option string\n"
|
2014-03-18 06:59:19 +01:00
|
|
|
" -c, --cmd STRING execute command with its arguments\n"
|
|
|
|
" from the given string\n"
|
2014-11-20 16:27:06 +01:00
|
|
|
" -f, --format FMT specifies the block driver to use\n"
|
2009-04-05 21:14:04 +02:00
|
|
|
" -r, --read-only export read-only\n"
|
|
|
|
" -s, --snapshot use snapshot file\n"
|
2016-05-08 05:16:40 +02:00
|
|
|
" -n, --nocache disable host cache, short for -t none\n"
|
2017-10-05 21:02:43 +02:00
|
|
|
" -C, --copy-on-read enable copy-on-read\n"
|
2009-04-05 21:14:04 +02:00
|
|
|
" -m, --misalign misalign allocations for O_DIRECT\n"
|
2020-01-20 15:18:54 +01:00
|
|
|
" -k, --native-aio use kernel AIO implementation\n"
|
|
|
|
" (Linux only, prefer use of -i)\n"
|
|
|
|
" -i, --aio=MODE use AIO mode (threads, native or io_uring)\n"
|
2012-04-18 12:07:39 +02:00
|
|
|
" -t, --cache=MODE use the given cache mode for the image\n"
|
2016-05-08 05:16:40 +02:00
|
|
|
" -d, --discard=MODE use the given discard mode for the image\n"
|
2016-06-17 16:44:11 +02:00
|
|
|
" -T, --trace [[enable=]<pattern>][,events=<file>][,file=<file>]\n"
|
|
|
|
" specify tracing options\n"
|
|
|
|
" see qemu-img(1) man page for full description\n"
|
2017-05-02 18:35:41 +02:00
|
|
|
" -U, --force-share force shared permissions\n"
|
2009-04-05 21:14:04 +02:00
|
|
|
" -h, --help display this help and exit\n"
|
|
|
|
" -V, --version output version information and exit\n"
|
2014-03-18 06:59:19 +01:00
|
|
|
"\n"
|
2017-08-03 18:33:53 +02:00
|
|
|
"See '%s -c help' for information on available commands.\n"
|
|
|
|
"\n"
|
|
|
|
QEMU_HELP_BOTTOM "\n",
|
2014-03-18 06:59:19 +01:00
|
|
|
name, name);
|
2009-04-05 21:14:04 +02:00
|
|
|
}
|
|
|
|
|
2013-06-05 14:19:37 +02:00
|
|
|
static char *get_prompt(void)
|
|
|
|
{
|
|
|
|
static char prompt[FILENAME_MAX + 2 /*"> "*/ + 1 /*"\0"*/ ];
|
|
|
|
|
|
|
|
if (!prompt[0]) {
|
2019-01-31 17:46:13 +01:00
|
|
|
snprintf(prompt, sizeof(prompt), "%s> ", error_get_progname());
|
2013-06-05 14:19:37 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return prompt;
|
|
|
|
}
|
|
|
|
|
2014-01-25 18:18:23 +01:00
|
|
|
static void GCC_FMT_ATTR(2, 3) readline_printf_func(void *opaque,
|
|
|
|
const char *fmt, ...)
|
2013-06-05 14:19:37 +02:00
|
|
|
{
|
2013-11-14 11:54:17 +01:00
|
|
|
va_list ap;
|
|
|
|
va_start(ap, fmt);
|
|
|
|
vprintf(fmt, ap);
|
|
|
|
va_end(ap);
|
2013-06-05 14:19:37 +02:00
|
|
|
}
|
2013-11-14 11:54:17 +01:00
|
|
|
|
|
|
|
static void readline_flush_func(void *opaque)
|
2013-06-05 14:19:37 +02:00
|
|
|
{
|
2013-11-14 11:54:17 +01:00
|
|
|
fflush(stdout);
|
2013-06-05 14:19:37 +02:00
|
|
|
}
|
|
|
|
|
2013-11-14 11:54:17 +01:00
|
|
|
static void readline_func(void *opaque, const char *str, void *readline_opaque)
|
2013-06-05 14:19:37 +02:00
|
|
|
{
|
2013-11-14 11:54:17 +01:00
|
|
|
char **line = readline_opaque;
|
|
|
|
*line = g_strdup(str);
|
|
|
|
}
|
|
|
|
|
2013-11-14 11:54:18 +01:00
|
|
|
static void completion_match(const char *cmd, void *opaque)
|
|
|
|
{
|
|
|
|
readline_add_completion(readline_state, cmd);
|
|
|
|
}
|
|
|
|
|
2013-11-14 11:54:17 +01:00
|
|
|
static void readline_completion_func(void *opaque, const char *str)
|
|
|
|
{
|
2013-11-14 11:54:18 +01:00
|
|
|
readline_set_completion_index(readline_state, strlen(str));
|
|
|
|
qemuio_complete_command(str, completion_match, NULL);
|
2013-11-14 11:54:17 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static char *fetchline_readline(void)
|
|
|
|
{
|
|
|
|
char *line = NULL;
|
|
|
|
|
|
|
|
readline_start(readline_state, get_prompt(), 0, readline_func, &line);
|
|
|
|
while (!line) {
|
|
|
|
int ch = getchar();
|
2018-02-12 19:48:49 +01:00
|
|
|
if (ttyEOF != 0x0 && ch == ttyEOF) {
|
|
|
|
printf("\n");
|
2013-11-14 11:54:17 +01:00
|
|
|
break;
|
2013-06-05 14:19:37 +02:00
|
|
|
}
|
2013-11-14 11:54:17 +01:00
|
|
|
readline_handle_byte(readline_state, ch);
|
2013-06-05 14:19:37 +02:00
|
|
|
}
|
|
|
|
return line;
|
|
|
|
}
|
2013-11-14 11:54:17 +01:00
|
|
|
|
|
|
|
#define MAXREADLINESZ 1024
|
|
|
|
static char *fetchline_fgets(void)
|
2013-06-05 14:19:37 +02: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 11:54:17 +01:00
|
|
|
|
|
|
|
static char *fetchline(void)
|
|
|
|
{
|
|
|
|
if (readline_state) {
|
|
|
|
return fetchline_readline();
|
|
|
|
} else {
|
|
|
|
return fetchline_fgets();
|
|
|
|
}
|
|
|
|
}
|
2013-06-05 14:19:37 +02:00
|
|
|
|
|
|
|
static void prep_fetchline(void *opaque)
|
|
|
|
{
|
|
|
|
int *fetchable = opaque;
|
|
|
|
|
|
|
|
qemu_set_fd_handler(STDIN_FILENO, NULL, NULL, NULL);
|
|
|
|
*fetchable= 1;
|
|
|
|
}
|
|
|
|
|
2018-05-09 21:43:00 +02:00
|
|
|
static int command_loop(void)
|
2013-06-05 14:19:37 +02:00
|
|
|
{
|
2018-05-09 21:42:58 +02:00
|
|
|
int i, fetchable = 0, prompted = 0;
|
2018-05-09 21:43:00 +02:00
|
|
|
int ret, last_error = 0;
|
2013-06-05 14:19:37 +02:00
|
|
|
char *input;
|
|
|
|
|
2018-05-09 21:42:58 +02:00
|
|
|
for (i = 0; !quit_qemu_io && i < ncmdline; i++) {
|
2018-05-09 21:43:00 +02:00
|
|
|
ret = qemuio_command(qemuio_blk, cmdline[i]);
|
|
|
|
if (ret < 0) {
|
|
|
|
last_error = ret;
|
|
|
|
}
|
2013-06-05 14:19:37 +02:00
|
|
|
}
|
|
|
|
if (cmdline) {
|
|
|
|
g_free(cmdline);
|
2018-05-09 21:43:00 +02:00
|
|
|
return last_error;
|
2013-06-05 14:19:37 +02:00
|
|
|
}
|
|
|
|
|
2018-05-09 21:42:58 +02:00
|
|
|
while (!quit_qemu_io) {
|
2013-06-05 14:19:37 +02:00
|
|
|
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;
|
|
|
|
}
|
2018-05-09 21:43:00 +02:00
|
|
|
ret = qemuio_command(qemuio_blk, input);
|
2013-06-05 14:19:37 +02:00
|
|
|
g_free(input);
|
|
|
|
|
2018-05-09 21:43:00 +02:00
|
|
|
if (ret < 0) {
|
|
|
|
last_error = ret;
|
|
|
|
}
|
|
|
|
|
2013-06-05 14:19:37 +02:00
|
|
|
prompted = 0;
|
|
|
|
fetchable = 0;
|
|
|
|
}
|
|
|
|
qemu_set_fd_handler(STDIN_FILENO, NULL, NULL, NULL);
|
2018-05-09 21:43:00 +02:00
|
|
|
|
|
|
|
return last_error;
|
2013-06-05 14:19:37 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
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 10:31:08 +02:00
|
|
|
cmdline = g_renew(char *, cmdline, ++ncmdline);
|
2013-06-05 14:19:37 +02:00
|
|
|
cmdline[ncmdline-1] = optarg;
|
|
|
|
}
|
|
|
|
|
2013-11-14 11:54:17 +01:00
|
|
|
static void reenable_tty_echo(void)
|
|
|
|
{
|
|
|
|
qemu_set_tty_echo(STDIN_FILENO, true);
|
|
|
|
}
|
|
|
|
|
2016-02-17 11:10:16 +01:00
|
|
|
enum {
|
|
|
|
OPTION_OBJECT = 256,
|
2016-02-17 11:10:18 +01:00
|
|
|
OPTION_IMAGE_OPTS = 257,
|
2016-02-17 11:10:16 +01:00
|
|
|
};
|
|
|
|
|
2016-02-17 11:10:18 +01:00
|
|
|
static QemuOptsList file_opts = {
|
|
|
|
.name = "file",
|
|
|
|
.implied_opt_name = "file",
|
|
|
|
.head = QTAILQ_HEAD_INITIALIZER(file_opts.head),
|
|
|
|
.desc = {
|
|
|
|
/* no elements => accept any params */
|
|
|
|
{ /* end of list */ }
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2009-04-05 21:14:04 +02:00
|
|
|
int main(int argc, char **argv)
|
|
|
|
{
|
2011-07-11 17:22:16 +02:00
|
|
|
int readonly = 0;
|
2020-01-20 15:18:54 +01:00
|
|
|
const char *sopt = "hVc:d:f:rsnCmki:t:T:U";
|
2011-07-11 17:22:16 +02:00
|
|
|
const struct option lopt[] = {
|
2016-02-17 11:10:23 +01:00
|
|
|
{ "help", no_argument, NULL, 'h' },
|
|
|
|
{ "version", no_argument, NULL, 'V' },
|
|
|
|
{ "cmd", required_argument, NULL, 'c' },
|
|
|
|
{ "format", required_argument, NULL, 'f' },
|
|
|
|
{ "read-only", no_argument, NULL, 'r' },
|
|
|
|
{ "snapshot", no_argument, NULL, 's' },
|
|
|
|
{ "nocache", no_argument, NULL, 'n' },
|
2017-10-05 21:02:43 +02:00
|
|
|
{ "copy-on-read", no_argument, NULL, 'C' },
|
2016-02-17 11:10:23 +01:00
|
|
|
{ "misalign", no_argument, NULL, 'm' },
|
|
|
|
{ "native-aio", no_argument, NULL, 'k' },
|
2020-01-20 15:18:54 +01:00
|
|
|
{ "aio", required_argument, NULL, 'i' },
|
2016-02-17 11:10:23 +01:00
|
|
|
{ "discard", required_argument, NULL, 'd' },
|
|
|
|
{ "cache", required_argument, NULL, 't' },
|
|
|
|
{ "trace", required_argument, NULL, 'T' },
|
|
|
|
{ "object", required_argument, NULL, OPTION_OBJECT },
|
|
|
|
{ "image-opts", no_argument, NULL, OPTION_IMAGE_OPTS },
|
2017-05-02 18:35:41 +02:00
|
|
|
{ "force-share", no_argument, 0, 'U'},
|
2011-07-11 17:22:16 +02:00
|
|
|
{ NULL, 0, NULL, 0 }
|
|
|
|
};
|
|
|
|
int c;
|
|
|
|
int opt_index = 0;
|
2013-02-08 14:06:11 +01:00
|
|
|
int flags = BDRV_O_UNMAP;
|
2018-05-09 21:43:00 +02:00
|
|
|
int ret;
|
2016-03-15 12:52:30 +01:00
|
|
|
bool writethrough = true;
|
2014-09-18 13:30:49 +02:00
|
|
|
Error *local_error = NULL;
|
2015-02-05 19:58:20 +01:00
|
|
|
QDict *opts = NULL;
|
2016-02-17 11:10:18 +01:00
|
|
|
const char *format = NULL;
|
2017-05-02 18:35:41 +02:00
|
|
|
bool force_share = false;
|
2011-07-11 17:22:16 +02:00
|
|
|
|
2013-07-23 10:30:11 +02:00
|
|
|
#ifdef CONFIG_POSIX
|
|
|
|
signal(SIGPIPE, SIG_IGN);
|
|
|
|
#endif
|
|
|
|
|
2020-08-25 12:38:48 +02:00
|
|
|
socket_init();
|
log: Make glib logging go through QEMU
This commit adds a error_init() helper which calls
g_log_set_default_handler() so that glib logs (g_log, g_warning, ...)
are handled similarly to other QEMU logs. This means they will get a
timestamp if timestamps are enabled, and they will go through the
HMP monitor if one is configured.
This commit also adds a call to error_init() to the binaries
installed by QEMU. Since error_init() also calls error_set_progname(),
this means that *-linux-user, *-bsd-user and qemu-pr-helper messages
output with error_report, info_report, ... will slightly change: they
will be prefixed by the binary name.
glib debug messages are enabled through G_MESSAGES_DEBUG similarly to
the glib default log handler.
At the moment, this change will mostly impact SPICE logging if your
spice version is >= 0.14.1. With older spice versions, this is not going
to work as expected, but will not have any ill effect, so this call is
not conditional on the SPICE version.
Signed-off-by: Christophe Fergeau <cfergeau@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-Id: <20190131164614.19209-3-cfergeau@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2019-01-31 17:46:14 +01:00
|
|
|
error_init(argv[0]);
|
2016-10-04 15:35:52 +02:00
|
|
|
module_call_init(MODULE_INIT_TRACE);
|
2014-02-10 07:48:51 +01:00
|
|
|
qemu_init_exec_dir(argv[0]);
|
2011-07-11 17:22:16 +02:00
|
|
|
|
2016-05-12 16:10:04 +02:00
|
|
|
qcrypto_init(&error_fatal);
|
2016-04-06 13:12:06 +02:00
|
|
|
|
2016-02-10 19:41:01 +01:00
|
|
|
module_call_init(MODULE_INIT_QOM);
|
2016-06-17 16:44:11 +02:00
|
|
|
qemu_add_opts(&qemu_trace_opts);
|
2014-11-20 16:27:06 +01:00
|
|
|
bdrv_init();
|
|
|
|
|
2011-07-11 17:22:16 +02:00
|
|
|
while ((c = getopt_long(argc, argv, sopt, lopt, &opt_index)) != -1) {
|
|
|
|
switch (c) {
|
|
|
|
case 's':
|
|
|
|
flags |= BDRV_O_SNAPSHOT;
|
|
|
|
break;
|
|
|
|
case 'n':
|
2016-03-15 12:52:30 +01:00
|
|
|
flags |= BDRV_O_NOCACHE;
|
|
|
|
writethrough = false;
|
2011-07-11 17:22:16 +02:00
|
|
|
break;
|
2017-10-05 21:02:43 +02:00
|
|
|
case 'C':
|
|
|
|
flags |= BDRV_O_COPY_ON_READ;
|
|
|
|
break;
|
2013-02-08 14:06:11 +01:00
|
|
|
case 'd':
|
|
|
|
if (bdrv_parse_discard_flags(optarg, &flags) < 0) {
|
|
|
|
error_report("Invalid discard option: %s", optarg);
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
break;
|
2014-11-20 16:27:06 +01:00
|
|
|
case 'f':
|
2016-02-17 11:10:18 +01:00
|
|
|
format = optarg;
|
2014-11-20 16:27:06 +01:00
|
|
|
break;
|
2011-07-11 17:22:16 +02:00
|
|
|
case 'c':
|
|
|
|
add_user_command(optarg);
|
|
|
|
break;
|
|
|
|
case 'r':
|
|
|
|
readonly = 1;
|
|
|
|
break;
|
|
|
|
case 'm':
|
2014-03-05 22:23:00 +01:00
|
|
|
qemuio_misalign = true;
|
2011-07-11 17:22:16 +02:00
|
|
|
break;
|
|
|
|
case 'k':
|
|
|
|
flags |= BDRV_O_NATIVE_AIO;
|
|
|
|
break;
|
2020-01-20 15:18:54 +01:00
|
|
|
case 'i':
|
|
|
|
if (bdrv_parse_aio(optarg, &flags) < 0) {
|
|
|
|
error_report("Invalid aio option: %s", optarg);
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
break;
|
2012-04-18 12:07:39 +02:00
|
|
|
case 't':
|
2016-03-15 12:52:30 +01:00
|
|
|
if (bdrv_parse_cache_mode(optarg, &flags, &writethrough) < 0) {
|
2012-04-18 12:07:39 +02:00
|
|
|
error_report("Invalid cache option: %s", optarg);
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
break;
|
2012-03-12 17:36:07 +01:00
|
|
|
case 'T':
|
2020-11-02 12:58:41 +01:00
|
|
|
trace_opt_parse(optarg);
|
2012-03-12 17:36:07 +01:00
|
|
|
break;
|
2011-07-11 17:22:16 +02:00
|
|
|
case 'V':
|
2018-02-15 12:06:47 +01:00
|
|
|
printf("%s version " QEMU_FULL_VERSION "\n"
|
2019-01-31 17:46:13 +01:00
|
|
|
QEMU_COPYRIGHT "\n", error_get_progname());
|
2011-07-11 17:22:16 +02:00
|
|
|
exit(0);
|
|
|
|
case 'h':
|
2019-01-31 17:46:13 +01:00
|
|
|
usage(error_get_progname());
|
2011-07-11 17:22:16 +02:00
|
|
|
exit(0);
|
2017-05-02 18:35:41 +02:00
|
|
|
case 'U':
|
|
|
|
force_share = true;
|
|
|
|
break;
|
2021-02-17 12:56:45 +01:00
|
|
|
case OPTION_OBJECT:
|
|
|
|
user_creatable_process_cmdline(optarg);
|
|
|
|
break;
|
2016-02-17 11:10:18 +01:00
|
|
|
case OPTION_IMAGE_OPTS:
|
|
|
|
imageOpts = true;
|
|
|
|
break;
|
2011-07-11 17:22:16 +02:00
|
|
|
default:
|
2019-01-31 17:46:13 +01:00
|
|
|
usage(error_get_progname());
|
2011-07-11 17:22:16 +02:00
|
|
|
exit(1);
|
2010-01-17 15:48:13 +01:00
|
|
|
}
|
2011-07-11 17:22:16 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if ((argc - optind) > 1) {
|
2019-01-31 17:46:13 +01:00
|
|
|
usage(error_get_progname());
|
2011-07-11 17:22:16 +02:00
|
|
|
exit(1);
|
|
|
|
}
|
2009-04-05 21:14:04 +02:00
|
|
|
|
2016-02-17 11:10:18 +01:00
|
|
|
if (format && imageOpts) {
|
|
|
|
error_report("--image-opts and -f are mutually exclusive");
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
2014-09-18 13:30:49 +02:00
|
|
|
if (qemu_init_main_loop(&local_error)) {
|
2015-02-12 13:55:05 +01:00
|
|
|
error_report_err(local_error);
|
2014-09-18 13:30:49 +02:00
|
|
|
exit(1);
|
|
|
|
}
|
2012-02-19 15:24:59 +01:00
|
|
|
|
2016-06-17 16:44:11 +02:00
|
|
|
if (!trace_init_backends()) {
|
|
|
|
exit(1);
|
|
|
|
}
|
2020-11-02 12:58:41 +01:00
|
|
|
trace_init_file();
|
2016-06-17 16:44:11 +02:00
|
|
|
qemu_set_log(LOG_TRACE);
|
|
|
|
|
2011-07-11 17:22:16 +02:00
|
|
|
/* initialize commands */
|
2013-06-05 14:19:36 +02:00
|
|
|
qemuio_add_command(&quit_cmd);
|
|
|
|
qemuio_add_command(&open_cmd);
|
|
|
|
qemuio_add_command(&close_cmd);
|
2011-07-11 17:22:16 +02:00
|
|
|
|
2013-11-14 11:54:17 +01:00
|
|
|
if (isatty(STDIN_FILENO)) {
|
2018-02-12 19:48:49 +01:00
|
|
|
ttyEOF = get_eof_char();
|
2013-11-14 11:54:17 +01:00
|
|
|
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 17:22:16 +02:00
|
|
|
/* open the device */
|
|
|
|
if (!readonly) {
|
|
|
|
flags |= BDRV_O_RDWR;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((argc - optind) == 1) {
|
2016-02-17 11:10:18 +01:00
|
|
|
if (imageOpts) {
|
|
|
|
QemuOpts *qopts = NULL;
|
|
|
|
qopts = qemu_opts_parse_noisily(&file_opts, argv[optind], false);
|
|
|
|
if (!qopts) {
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
opts = qemu_opts_to_qdict(qopts, NULL);
|
2017-05-02 18:35:41 +02:00
|
|
|
if (openfile(NULL, flags, writethrough, force_share, opts)) {
|
2017-02-01 01:31:18 +01:00
|
|
|
exit(1);
|
|
|
|
}
|
2016-02-17 11:10:18 +01:00
|
|
|
} else {
|
|
|
|
if (format) {
|
|
|
|
opts = qdict_new();
|
2017-04-27 23:58:17 +02:00
|
|
|
qdict_put_str(opts, "driver", format);
|
2016-02-17 11:10:18 +01:00
|
|
|
}
|
2017-05-02 18:35:41 +02:00
|
|
|
if (openfile(argv[optind], flags, writethrough,
|
|
|
|
force_share, opts)) {
|
2017-02-01 01:31:18 +01:00
|
|
|
exit(1);
|
|
|
|
}
|
2016-02-17 11:10:18 +01:00
|
|
|
}
|
2011-07-11 17:22:16 +02:00
|
|
|
}
|
2018-05-09 21:43:00 +02:00
|
|
|
ret = command_loop();
|
2009-04-05 21:14:04 +02:00
|
|
|
|
2011-07-11 17:22:16 +02:00
|
|
|
/*
|
2011-11-30 13:23:43 +01:00
|
|
|
* Make sure all outstanding requests complete before the program exits.
|
2011-07-11 17:22:16 +02:00
|
|
|
*/
|
2011-11-30 13:23:43 +01:00
|
|
|
bdrv_drain_all();
|
2009-06-20 21:10:44 +02: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 13:59:04 +02:00
|
|
|
blk_unref(qemuio_blk);
|
2013-11-14 11:54:17 +01:00
|
|
|
g_free(readline_state);
|
2018-05-09 21:43:00 +02:00
|
|
|
|
|
|
|
if (ret < 0) {
|
|
|
|
return 1;
|
|
|
|
} else {
|
|
|
|
return 0;
|
|
|
|
}
|
2009-04-05 21:14:04 +02:00
|
|
|
}
|