2004-08-01 21:59:26 +00:00
|
|
|
/*
|
2006-08-07 21:34:46 +00:00
|
|
|
* QEMU disk image utility
|
2007-09-16 21:08:06 +00:00
|
|
|
*
|
2008-01-06 17:21:48 +00:00
|
|
|
* Copyright (c) 2003-2008 Fabrice Bellard
|
2007-09-16 21:08:06 +00:00
|
|
|
*
|
2004-08-01 21:59:26 +00:00
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
|
|
* in the Software without restriction, including without limitation the rights
|
|
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
|
|
* furnished to do so, subject to the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice shall be included in
|
|
|
|
* all copies or substantial portions of the Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
|
|
* THE SOFTWARE.
|
|
|
|
*/
|
qemu-img: Add json output option to the info command.
This option --output=[human|json] make qemu-img info output on
human or JSON representation at the choice of the user.
example:
{
"snapshots": [
{
"vm-clock-nsec": 637102488,
"name": "vm-20120821145509",
"date-sec": 1345553709,
"date-nsec": 220289000,
"vm-clock-sec": 20,
"id": "1",
"vm-state-size": 96522745
},
{
"vm-clock-nsec": 28210866,
"name": "vm-20120821154059",
"date-sec": 1345556459,
"date-nsec": 171392000,
"vm-clock-sec": 46,
"id": "2",
"vm-state-size": 101208714
}
],
"virtual-size": 1073741824,
"filename": "snap.qcow2",
"cluster-size": 65536,
"format": "qcow2",
"actual-size": 985587712,
"dirty-flag": false
}
Signed-off-by: Benoit Canet <benoit@irqsave.net>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2012-09-05 11:09:02 +00:00
|
|
|
#include "qapi-visit.h"
|
|
|
|
#include "qapi/qmp-output-visitor.h"
|
2015-03-17 16:22:46 +00:00
|
|
|
#include "qapi/qmp/qerror.h"
|
2012-12-17 17:19:43 +00:00
|
|
|
#include "qapi/qmp/qjson.h"
|
2007-11-11 02:51:17 +00:00
|
|
|
#include "qemu-common.h"
|
2012-12-17 17:20:00 +00:00
|
|
|
#include "qemu/option.h"
|
|
|
|
#include "qemu/error-report.h"
|
|
|
|
#include "qemu/osdep.h"
|
2012-12-17 17:20:04 +00:00
|
|
|
#include "sysemu/sysemu.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 11:59:04 +00:00
|
|
|
#include "sysemu/block-backend.h"
|
2012-12-17 17:19:44 +00:00
|
|
|
#include "block/block_int.h"
|
2014-10-24 13:57:37 +00:00
|
|
|
#include "block/blockjob.h"
|
2013-05-25 03:09:44 +00:00
|
|
|
#include "block/qapi.h"
|
qemu-img: Add json output option to the info command.
This option --output=[human|json] make qemu-img info output on
human or JSON representation at the choice of the user.
example:
{
"snapshots": [
{
"vm-clock-nsec": 637102488,
"name": "vm-20120821145509",
"date-sec": 1345553709,
"date-nsec": 220289000,
"vm-clock-sec": 20,
"id": "1",
"vm-state-size": 96522745
},
{
"vm-clock-nsec": 28210866,
"name": "vm-20120821154059",
"date-sec": 1345556459,
"date-nsec": 171392000,
"vm-clock-sec": 46,
"id": "2",
"vm-state-size": 101208714
}
],
"virtual-size": 1073741824,
"filename": "snap.qcow2",
"cluster-size": 65536,
"format": "qcow2",
"actual-size": 985587712,
"dirty-flag": false
}
Signed-off-by: Benoit Canet <benoit@irqsave.net>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2012-09-05 11:09:02 +00:00
|
|
|
#include <getopt.h>
|
2006-06-14 15:32:10 +00:00
|
|
|
|
2015-01-09 15:17:35 +00:00
|
|
|
#define QEMU_IMG_VERSION "qemu-img version " QEMU_VERSION QEMU_PKGVERSION \
|
2014-04-28 18:37:18 +00:00
|
|
|
", Copyright (c) 2004-2008 Fabrice Bellard\n"
|
|
|
|
|
2009-10-01 21:12:16 +00:00
|
|
|
typedef struct img_cmd_t {
|
2009-06-06 23:42:17 +00:00
|
|
|
const char *name;
|
|
|
|
int (*handler)(int argc, char **argv);
|
2009-10-01 21:12:16 +00:00
|
|
|
} img_cmd_t;
|
2009-06-06 23:42:17 +00:00
|
|
|
|
2013-01-28 11:59:47 +00:00
|
|
|
enum {
|
|
|
|
OPTION_OUTPUT = 256,
|
|
|
|
OPTION_BACKING_CHAIN = 257,
|
|
|
|
};
|
|
|
|
|
|
|
|
typedef enum OutputFormat {
|
|
|
|
OFORMAT_JSON,
|
|
|
|
OFORMAT_HUMAN,
|
|
|
|
} OutputFormat;
|
|
|
|
|
2008-11-30 19:12:49 +00:00
|
|
|
/* Default to cache=writeback as data integrity is not important for qemu-tcg. */
|
2010-04-13 09:29:35 +00:00
|
|
|
#define BDRV_O_FLAGS BDRV_O_CACHE_WB
|
2011-06-20 16:48:19 +00:00
|
|
|
#define BDRV_DEFAULT_CACHE "writeback"
|
2008-11-30 19:12:49 +00:00
|
|
|
|
2014-08-27 11:08:56 +00:00
|
|
|
static void format_print(void *opaque, const char *name)
|
2004-08-01 21:59:26 +00:00
|
|
|
{
|
2014-08-27 11:08:56 +00:00
|
|
|
printf(" %s", name);
|
2004-08-01 21:59:26 +00:00
|
|
|
}
|
|
|
|
|
2014-04-22 05:36:11 +00:00
|
|
|
static void QEMU_NORETURN GCC_FMT_ATTR(1, 2) error_exit(const char *fmt, ...)
|
|
|
|
{
|
|
|
|
va_list ap;
|
|
|
|
|
|
|
|
error_printf("qemu-img: ");
|
|
|
|
|
|
|
|
va_start(ap, fmt);
|
|
|
|
error_vprintf(fmt, ap);
|
|
|
|
va_end(ap);
|
|
|
|
|
|
|
|
error_printf("\nTry 'qemu-img --help' for more information\n");
|
|
|
|
exit(EXIT_FAILURE);
|
|
|
|
}
|
|
|
|
|
2009-01-24 18:19:25 +00:00
|
|
|
/* Please keep in synch with qemu-img.texi */
|
2014-04-22 05:36:11 +00:00
|
|
|
static void QEMU_NORETURN help(void)
|
2004-08-01 21:59:26 +00:00
|
|
|
{
|
2010-02-04 15:49:56 +00:00
|
|
|
const char *help_msg =
|
2014-04-28 18:37:18 +00:00
|
|
|
QEMU_IMG_VERSION
|
2010-02-08 09:04:56 +00:00
|
|
|
"usage: qemu-img command [command options]\n"
|
|
|
|
"QEMU disk image utility\n"
|
|
|
|
"\n"
|
|
|
|
"Command syntax:\n"
|
2009-06-06 23:42:17 +00:00
|
|
|
#define DEF(option, callback, arg_string) \
|
|
|
|
" " arg_string "\n"
|
|
|
|
#include "qemu-img-cmds.h"
|
|
|
|
#undef DEF
|
|
|
|
#undef GEN_DOCS
|
2010-02-08 09:04:56 +00:00
|
|
|
"\n"
|
|
|
|
"Command parameters:\n"
|
|
|
|
" 'filename' is a disk image filename\n"
|
|
|
|
" 'fmt' is the disk image format. It is guessed automatically in most cases\n"
|
2011-06-20 16:48:19 +00:00
|
|
|
" 'cache' is the cache mode used to write the output disk image, the valid\n"
|
2012-04-20 09:10:56 +00:00
|
|
|
" options are: 'none', 'writeback' (default, except for convert), 'writethrough',\n"
|
|
|
|
" 'directsync' and 'unsafe' (default for convert)\n"
|
2014-09-02 10:01:02 +00:00
|
|
|
" 'src_cache' is the cache mode used to read input disk images, the valid\n"
|
|
|
|
" options are the same as for the 'cache' option\n"
|
2010-02-08 09:04:56 +00:00
|
|
|
" 'size' is the disk image size in bytes. Optional suffixes\n"
|
2013-06-05 12:19:27 +00:00
|
|
|
" 'k' or 'K' (kilobyte, 1024), 'M' (megabyte, 1024k), 'G' (gigabyte, 1024M),\n"
|
|
|
|
" 'T' (terabyte, 1024G), 'P' (petabyte, 1024T) and 'E' (exabyte, 1024P) are\n"
|
|
|
|
" supported. 'b' is ignored.\n"
|
2010-02-08 09:04:56 +00:00
|
|
|
" 'output_filename' is the destination disk image filename\n"
|
|
|
|
" 'output_fmt' is the destination format\n"
|
|
|
|
" 'options' is a comma separated list of format specific options in a\n"
|
|
|
|
" name=value format. Use -o ? for an overview of the options supported by the\n"
|
|
|
|
" used format\n"
|
2013-12-04 09:10:57 +00:00
|
|
|
" 'snapshot_param' is param used for internal snapshot, format\n"
|
|
|
|
" is 'snapshot.id=[ID],snapshot.name=[NAME]', or\n"
|
|
|
|
" '[ID_OR_NAME]'\n"
|
|
|
|
" 'snapshot_id_or_name' is deprecated, use 'snapshot_param'\n"
|
|
|
|
" instead\n"
|
2010-02-08 09:04:56 +00:00
|
|
|
" '-c' indicates that target image must be compressed (qcow format only)\n"
|
|
|
|
" '-u' enables unsafe rebasing. It is assumed that old and new backing file\n"
|
|
|
|
" match exactly. The image doesn't need a working backing file before\n"
|
|
|
|
" rebasing in this case (useful for renaming the backing file)\n"
|
|
|
|
" '-h' with or without a command shows this help and lists the supported formats\n"
|
2011-03-30 12:16:25 +00:00
|
|
|
" '-p' show progress of command (only certain commands)\n"
|
2013-02-13 08:09:40 +00:00
|
|
|
" '-q' use Quiet mode - do not print any output (except errors)\n"
|
2013-10-24 10:07:05 +00:00
|
|
|
" '-S' indicates the consecutive number of bytes (defaults to 4k) that must\n"
|
|
|
|
" contain only zeros for qemu-img to create a sparse image during\n"
|
|
|
|
" conversion. If the number of bytes is 0, the source will not be scanned for\n"
|
|
|
|
" unallocated or zero sectors, and the destination image will always be\n"
|
|
|
|
" fully allocated\n"
|
qemu-img: Add json output option to the info command.
This option --output=[human|json] make qemu-img info output on
human or JSON representation at the choice of the user.
example:
{
"snapshots": [
{
"vm-clock-nsec": 637102488,
"name": "vm-20120821145509",
"date-sec": 1345553709,
"date-nsec": 220289000,
"vm-clock-sec": 20,
"id": "1",
"vm-state-size": 96522745
},
{
"vm-clock-nsec": 28210866,
"name": "vm-20120821154059",
"date-sec": 1345556459,
"date-nsec": 171392000,
"vm-clock-sec": 46,
"id": "2",
"vm-state-size": 101208714
}
],
"virtual-size": 1073741824,
"filename": "snap.qcow2",
"cluster-size": 65536,
"format": "qcow2",
"actual-size": 985587712,
"dirty-flag": false
}
Signed-off-by: Benoit Canet <benoit@irqsave.net>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2012-09-05 11:09:02 +00:00
|
|
|
" '--output' takes the format in which the output must be done (human or json)\n"
|
2013-09-02 18:07:24 +00:00
|
|
|
" '-n' skips the target volume creation (useful if the volume is created\n"
|
|
|
|
" prior to running qemu-img)\n"
|
2010-02-08 09:04:56 +00:00
|
|
|
"\n"
|
2012-05-11 14:07:02 +00:00
|
|
|
"Parameters to check subcommand:\n"
|
|
|
|
" '-r' tries to repair any inconsistencies that are found during the check.\n"
|
|
|
|
" '-r leaks' repairs only cluster leaks, whereas '-r all' fixes all\n"
|
|
|
|
" kinds of errors, with a higher risk of choosing the wrong fix or\n"
|
2012-08-10 20:03:25 +00:00
|
|
|
" hiding corruption that has already occurred.\n"
|
2012-05-11 14:07:02 +00:00
|
|
|
"\n"
|
2010-02-08 09:04:56 +00:00
|
|
|
"Parameters to snapshot subcommand:\n"
|
|
|
|
" 'snapshot' is the name of the snapshot to create, apply or delete\n"
|
|
|
|
" '-a' applies a snapshot (revert disk to saved state)\n"
|
|
|
|
" '-c' creates a snapshot\n"
|
|
|
|
" '-d' deletes a snapshot\n"
|
2013-02-13 08:09:41 +00:00
|
|
|
" '-l' lists all snapshots in the given image\n"
|
|
|
|
"\n"
|
|
|
|
"Parameters to compare subcommand:\n"
|
|
|
|
" '-f' first image format\n"
|
|
|
|
" '-F' second image format\n"
|
|
|
|
" '-s' run in Strict mode - fail on different image size or sector allocation\n";
|
2010-02-04 15:49:56 +00:00
|
|
|
|
|
|
|
printf("%s\nSupported formats:", help_msg);
|
2014-08-27 11:08:56 +00:00
|
|
|
bdrv_iterate_format(format_print, NULL);
|
2004-08-01 21:59:26 +00:00
|
|
|
printf("\n");
|
2014-04-22 05:36:11 +00:00
|
|
|
exit(EXIT_SUCCESS);
|
2004-08-01 21:59:26 +00:00
|
|
|
}
|
|
|
|
|
2013-06-16 15:01:05 +00:00
|
|
|
static int GCC_FMT_ATTR(2, 3) qprintf(bool quiet, const char *fmt, ...)
|
2013-02-13 08:09:40 +00:00
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
if (!quiet) {
|
|
|
|
va_list args;
|
|
|
|
va_start(args, fmt);
|
|
|
|
ret = vprintf(fmt, args);
|
|
|
|
va_end(args);
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2004-08-01 21:59:26 +00:00
|
|
|
|
2010-12-06 14:25:38 +00:00
|
|
|
static int print_block_option_help(const char *filename, const char *fmt)
|
|
|
|
{
|
|
|
|
BlockDriver *drv, *proto_drv;
|
2014-06-05 09:20:51 +00:00
|
|
|
QemuOptsList *create_opts = NULL;
|
2015-02-05 18:58:12 +00:00
|
|
|
Error *local_err = NULL;
|
2010-12-06 14:25:38 +00:00
|
|
|
|
|
|
|
/* Find driver and parse its options */
|
|
|
|
drv = bdrv_find_format(fmt);
|
|
|
|
if (!drv) {
|
2010-12-16 13:31:53 +00:00
|
|
|
error_report("Unknown file format '%s'", fmt);
|
2010-12-06 14:25:38 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2014-06-05 09:21:11 +00:00
|
|
|
create_opts = qemu_opts_append(create_opts, drv->create_opts);
|
2014-02-21 15:24:07 +00:00
|
|
|
if (filename) {
|
2015-02-05 18:58:12 +00:00
|
|
|
proto_drv = bdrv_find_protocol(filename, true, &local_err);
|
2014-02-21 15:24:07 +00:00
|
|
|
if (!proto_drv) {
|
2015-03-12 15:08:02 +00:00
|
|
|
error_report_err(local_err);
|
2014-06-05 09:20:51 +00:00
|
|
|
qemu_opts_free(create_opts);
|
2014-02-21 15:24:07 +00:00
|
|
|
return 1;
|
|
|
|
}
|
2014-06-05 09:21:11 +00:00
|
|
|
create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
|
2014-02-21 15:24:07 +00:00
|
|
|
}
|
|
|
|
|
2014-06-05 09:20:51 +00:00
|
|
|
qemu_opts_print_help(create_opts);
|
|
|
|
qemu_opts_free(create_opts);
|
2010-12-06 14:25:38 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-10-07 11:59:05 +00:00
|
|
|
static BlockBackend *img_open(const char *id, const char *filename,
|
|
|
|
const char *fmt, int flags,
|
|
|
|
bool require_io, bool quiet)
|
2004-08-27 21:28:58 +00:00
|
|
|
{
|
2014-10-07 11:59:05 +00:00
|
|
|
BlockBackend *blk;
|
2004-08-27 21:28:58 +00:00
|
|
|
BlockDriverState *bs;
|
|
|
|
char password[256];
|
2013-09-05 12:45:29 +00:00
|
|
|
Error *local_err = NULL;
|
2015-02-05 18:58:16 +00:00
|
|
|
QDict *options = NULL;
|
2010-12-16 14:37:41 +00:00
|
|
|
|
2004-08-27 21:28:58 +00:00
|
|
|
if (fmt) {
|
2015-02-05 18:58:16 +00:00
|
|
|
options = qdict_new();
|
|
|
|
qdict_put(options, "driver", qstring_from_str(fmt));
|
2004-08-27 21:28:58 +00:00
|
|
|
}
|
2011-02-09 10:25:53 +00:00
|
|
|
|
2015-02-05 18:58:16 +00:00
|
|
|
blk = blk_new_open(id, filename, NULL, options, flags, &local_err);
|
|
|
|
if (!blk) {
|
2013-09-05 12:45:29 +00:00
|
|
|
error_report("Could not open '%s': %s", filename,
|
|
|
|
error_get_pretty(local_err));
|
|
|
|
error_free(local_err);
|
2010-06-20 19:26:35 +00:00
|
|
|
goto fail;
|
2004-08-27 21:28:58 +00:00
|
|
|
}
|
2011-02-09 10:25:53 +00:00
|
|
|
|
2015-02-05 18:58:16 +00:00
|
|
|
bs = blk_bs(blk);
|
2012-09-10 11:11:31 +00:00
|
|
|
if (bdrv_is_encrypted(bs) && require_io) {
|
2013-02-13 08:09:40 +00:00
|
|
|
qprintf(quiet, "Disk image '%s' is encrypted.\n", filename);
|
2015-05-12 16:09:19 +00:00
|
|
|
if (qemu_read_password(password, sizeof(password)) < 0) {
|
2010-12-16 13:31:53 +00:00
|
|
|
error_report("No password given");
|
2010-06-20 19:26:35 +00:00
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
if (bdrv_set_key(bs, password) < 0) {
|
2010-12-16 13:31:53 +00:00
|
|
|
error_report("invalid password");
|
2010-06-20 19:26:35 +00:00
|
|
|
goto fail;
|
|
|
|
}
|
2004-08-27 21:28:58 +00:00
|
|
|
}
|
2014-10-07 11:59:05 +00:00
|
|
|
return blk;
|
2010-06-20 19:26:35 +00:00
|
|
|
fail:
|
2014-10-07 11:59:05 +00:00
|
|
|
blk_unref(blk);
|
2010-06-20 19:26:35 +00:00
|
|
|
return NULL;
|
2004-08-27 21:28:58 +00:00
|
|
|
}
|
|
|
|
|
2014-06-05 09:20:51 +00:00
|
|
|
static int add_old_style_options(const char *fmt, QemuOpts *opts,
|
2010-12-07 16:44:34 +00:00
|
|
|
const char *base_filename,
|
|
|
|
const char *base_fmt)
|
2009-05-18 14:42:12 +00:00
|
|
|
{
|
2015-02-12 16:43:08 +00:00
|
|
|
Error *err = NULL;
|
|
|
|
|
2009-05-18 14:42:12 +00:00
|
|
|
if (base_filename) {
|
2015-02-12 16:52:20 +00:00
|
|
|
qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename, &err);
|
2015-02-12 16:43:08 +00:00
|
|
|
if (err) {
|
2010-12-16 13:31:53 +00:00
|
|
|
error_report("Backing file not supported for file format '%s'",
|
|
|
|
fmt);
|
2015-02-12 16:43:08 +00:00
|
|
|
error_free(err);
|
2010-06-20 19:26:35 +00:00
|
|
|
return -1;
|
2009-05-18 14:42:12 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (base_fmt) {
|
2015-02-12 16:52:20 +00:00
|
|
|
qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt, &err);
|
2015-02-12 16:43:08 +00:00
|
|
|
if (err) {
|
2010-12-16 13:31:53 +00:00
|
|
|
error_report("Backing file format not supported for file "
|
|
|
|
"format '%s'", fmt);
|
2015-02-12 16:43:08 +00:00
|
|
|
error_free(err);
|
2010-06-20 19:26:35 +00:00
|
|
|
return -1;
|
2009-05-18 14:42:12 +00:00
|
|
|
}
|
|
|
|
}
|
2010-06-20 19:26:35 +00:00
|
|
|
return 0;
|
2009-05-18 14:42:12 +00:00
|
|
|
}
|
|
|
|
|
2004-08-01 21:59:26 +00:00
|
|
|
static int img_create(int argc, char **argv)
|
|
|
|
{
|
2012-11-30 12:52:06 +00:00
|
|
|
int c;
|
2010-12-09 13:17:25 +00:00
|
|
|
uint64_t img_size = -1;
|
2004-08-01 21:59:26 +00:00
|
|
|
const char *fmt = "raw";
|
2009-03-28 17:55:19 +00:00
|
|
|
const char *base_fmt = NULL;
|
2004-08-01 21:59:26 +00:00
|
|
|
const char *filename;
|
|
|
|
const char *base_filename = NULL;
|
2009-05-18 14:42:11 +00:00
|
|
|
char *options = NULL;
|
2012-11-30 12:52:05 +00:00
|
|
|
Error *local_err = NULL;
|
2013-02-13 08:09:40 +00:00
|
|
|
bool quiet = false;
|
2007-09-17 08:09:54 +00:00
|
|
|
|
2004-08-01 21:59:26 +00:00
|
|
|
for(;;) {
|
2013-02-13 08:09:40 +00:00
|
|
|
c = getopt(argc, argv, "F:b:f:he6o:q");
|
2010-12-06 14:25:39 +00:00
|
|
|
if (c == -1) {
|
2004-08-01 21:59:26 +00:00
|
|
|
break;
|
2010-12-06 14:25:39 +00:00
|
|
|
}
|
2004-08-01 21:59:26 +00:00
|
|
|
switch(c) {
|
2010-12-06 14:25:40 +00:00
|
|
|
case '?':
|
2004-08-01 21:59:26 +00:00
|
|
|
case 'h':
|
|
|
|
help();
|
|
|
|
break;
|
2009-03-28 17:55:19 +00:00
|
|
|
case 'F':
|
|
|
|
base_fmt = optarg;
|
|
|
|
break;
|
2004-08-01 21:59:26 +00:00
|
|
|
case 'b':
|
|
|
|
base_filename = optarg;
|
|
|
|
break;
|
|
|
|
case 'f':
|
|
|
|
fmt = optarg;
|
|
|
|
break;
|
|
|
|
case 'e':
|
2011-06-22 12:03:55 +00:00
|
|
|
error_report("option -e is deprecated, please use \'-o "
|
2010-12-07 16:44:34 +00:00
|
|
|
"encryption\' instead!");
|
2014-02-21 15:24:04 +00:00
|
|
|
goto fail;
|
2007-10-24 16:11:42 +00:00
|
|
|
case '6':
|
2011-06-22 12:03:55 +00:00
|
|
|
error_report("option -6 is deprecated, please use \'-o "
|
2010-12-07 16:44:34 +00:00
|
|
|
"compat6\' instead!");
|
2014-02-21 15:24:04 +00:00
|
|
|
goto fail;
|
2009-05-18 14:42:11 +00:00
|
|
|
case 'o':
|
2014-02-21 15:24:04 +00:00
|
|
|
if (!is_valid_option_list(optarg)) {
|
|
|
|
error_report("Invalid option list: %s", optarg);
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
if (!options) {
|
|
|
|
options = g_strdup(optarg);
|
|
|
|
} else {
|
|
|
|
char *old_options = options;
|
|
|
|
options = g_strdup_printf("%s,%s", options, optarg);
|
|
|
|
g_free(old_options);
|
|
|
|
}
|
2009-05-18 14:42:11 +00:00
|
|
|
break;
|
2013-02-13 08:09:40 +00:00
|
|
|
case 'q':
|
|
|
|
quiet = true;
|
|
|
|
break;
|
2004-08-01 21:59:26 +00:00
|
|
|
}
|
|
|
|
}
|
2009-03-28 17:55:19 +00:00
|
|
|
|
2010-05-26 02:35:36 +00:00
|
|
|
/* Get the filename */
|
2014-02-21 15:24:07 +00:00
|
|
|
filename = (optind < argc) ? argv[optind] : NULL;
|
|
|
|
if (options && has_help_option(options)) {
|
|
|
|
g_free(options);
|
|
|
|
return print_block_option_help(filename, fmt);
|
|
|
|
}
|
|
|
|
|
2010-12-06 14:25:39 +00:00
|
|
|
if (optind >= argc) {
|
2014-04-22 05:36:11 +00:00
|
|
|
error_exit("Expecting image file name");
|
2010-12-06 14:25:39 +00:00
|
|
|
}
|
2014-02-21 15:24:07 +00:00
|
|
|
optind++;
|
2010-05-26 02:35:36 +00:00
|
|
|
|
2010-12-09 13:17:25 +00:00
|
|
|
/* Get image size, if specified */
|
|
|
|
if (optind < argc) {
|
2011-01-05 10:41:02 +00:00
|
|
|
int64_t sval;
|
2011-11-22 08:46:05 +00:00
|
|
|
char *end;
|
2015-09-16 16:02:56 +00:00
|
|
|
sval = qemu_strtosz_suffix(argv[optind++], &end,
|
|
|
|
QEMU_STRTOSZ_DEFSUFFIX_B);
|
2011-11-22 08:46:05 +00:00
|
|
|
if (sval < 0 || *end) {
|
2012-12-17 01:49:23 +00:00
|
|
|
if (sval == -ERANGE) {
|
|
|
|
error_report("Image size must be less than 8 EiB!");
|
|
|
|
} else {
|
|
|
|
error_report("Invalid image size specified! You may use k, M, "
|
2013-06-05 12:19:27 +00:00
|
|
|
"G, T, P or E suffixes for ");
|
|
|
|
error_report("kilobytes, megabytes, gigabytes, terabytes, "
|
|
|
|
"petabytes and exabytes.");
|
2012-12-17 01:49:23 +00:00
|
|
|
}
|
2014-02-21 15:24:04 +00:00
|
|
|
goto fail;
|
2010-12-09 13:17:25 +00:00
|
|
|
}
|
|
|
|
img_size = (uint64_t)sval;
|
|
|
|
}
|
2013-08-05 08:53:04 +00:00
|
|
|
if (optind != argc) {
|
2014-04-22 05:36:11 +00:00
|
|
|
error_exit("Unexpected argument: %s", argv[optind]);
|
2013-08-05 08:53:04 +00:00
|
|
|
}
|
2010-12-09 13:17:25 +00:00
|
|
|
|
2012-11-30 12:52:05 +00:00
|
|
|
bdrv_img_create(filename, fmt, base_filename, base_fmt,
|
2013-02-13 08:09:40 +00:00
|
|
|
options, img_size, BDRV_O_FLAGS, &local_err, quiet);
|
2014-01-30 14:07:28 +00:00
|
|
|
if (local_err) {
|
2013-09-06 14:51:03 +00:00
|
|
|
error_report("%s: %s", filename, error_get_pretty(local_err));
|
2012-11-30 12:52:05 +00:00
|
|
|
error_free(local_err);
|
2014-02-21 15:24:04 +00:00
|
|
|
goto fail;
|
2010-06-20 19:26:35 +00:00
|
|
|
}
|
2012-11-30 12:52:06 +00:00
|
|
|
|
2014-02-21 15:24:04 +00:00
|
|
|
g_free(options);
|
2004-08-01 21:59:26 +00:00
|
|
|
return 0;
|
2014-02-21 15:24:04 +00:00
|
|
|
|
|
|
|
fail:
|
|
|
|
g_free(options);
|
|
|
|
return 1;
|
2004-08-01 21:59:26 +00:00
|
|
|
}
|
|
|
|
|
2013-02-13 08:09:40 +00:00
|
|
|
static void dump_json_image_check(ImageCheck *check, bool quiet)
|
2013-01-28 11:59:47 +00:00
|
|
|
{
|
2014-04-25 14:50:32 +00:00
|
|
|
Error *local_err = NULL;
|
2013-01-28 11:59:47 +00:00
|
|
|
QString *str;
|
|
|
|
QmpOutputVisitor *ov = qmp_output_visitor_new();
|
|
|
|
QObject *obj;
|
|
|
|
visit_type_ImageCheck(qmp_output_get_visitor(ov),
|
2014-04-25 14:50:32 +00:00
|
|
|
&check, NULL, &local_err);
|
2013-01-28 11:59:47 +00:00
|
|
|
obj = qmp_output_get_qobject(ov);
|
|
|
|
str = qobject_to_json_pretty(obj);
|
|
|
|
assert(str != NULL);
|
2013-02-13 08:09:40 +00:00
|
|
|
qprintf(quiet, "%s\n", qstring_get_str(str));
|
2013-01-28 11:59:47 +00:00
|
|
|
qobject_decref(obj);
|
|
|
|
qmp_output_visitor_cleanup(ov);
|
|
|
|
QDECREF(str);
|
|
|
|
}
|
|
|
|
|
2013-02-13 08:09:40 +00:00
|
|
|
static void dump_human_image_check(ImageCheck *check, bool quiet)
|
2013-01-28 11:59:47 +00:00
|
|
|
{
|
|
|
|
if (!(check->corruptions || check->leaks || check->check_errors)) {
|
2013-02-13 08:09:40 +00:00
|
|
|
qprintf(quiet, "No errors were found on the image.\n");
|
2013-01-28 11:59:47 +00:00
|
|
|
} else {
|
|
|
|
if (check->corruptions) {
|
2013-02-13 08:09:40 +00:00
|
|
|
qprintf(quiet, "\n%" PRId64 " errors were found on the image.\n"
|
|
|
|
"Data may be corrupted, or further writes to the image "
|
|
|
|
"may corrupt it.\n",
|
|
|
|
check->corruptions);
|
2013-01-28 11:59:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (check->leaks) {
|
2013-02-13 08:09:40 +00:00
|
|
|
qprintf(quiet,
|
|
|
|
"\n%" PRId64 " leaked clusters were found on the image.\n"
|
|
|
|
"This means waste of disk space, but no harm to data.\n",
|
|
|
|
check->leaks);
|
2013-01-28 11:59:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (check->check_errors) {
|
2013-02-13 08:09:40 +00:00
|
|
|
qprintf(quiet,
|
|
|
|
"\n%" PRId64
|
|
|
|
" internal errors have occurred during the check.\n",
|
|
|
|
check->check_errors);
|
2013-01-28 11:59:47 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (check->total_clusters != 0 && check->allocated_clusters != 0) {
|
2013-02-13 08:09:40 +00:00
|
|
|
qprintf(quiet, "%" PRId64 "/%" PRId64 " = %0.2f%% allocated, "
|
|
|
|
"%0.2f%% fragmented, %0.2f%% compressed clusters\n",
|
|
|
|
check->allocated_clusters, check->total_clusters,
|
|
|
|
check->allocated_clusters * 100.0 / check->total_clusters,
|
|
|
|
check->fragmented_clusters * 100.0 / check->allocated_clusters,
|
|
|
|
check->compressed_clusters * 100.0 /
|
|
|
|
check->allocated_clusters);
|
2013-01-28 11:59:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (check->image_end_offset) {
|
2013-02-13 08:09:40 +00:00
|
|
|
qprintf(quiet,
|
|
|
|
"Image end offset: %" PRId64 "\n", check->image_end_offset);
|
2013-01-28 11:59:47 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int collect_image_check(BlockDriverState *bs,
|
|
|
|
ImageCheck *check,
|
|
|
|
const char *filename,
|
|
|
|
const char *fmt,
|
|
|
|
int fix)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
BdrvCheckResult result;
|
|
|
|
|
|
|
|
ret = bdrv_check(bs, &result, fix);
|
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
check->filename = g_strdup(filename);
|
|
|
|
check->format = g_strdup(bdrv_get_format_name(bs));
|
|
|
|
check->check_errors = result.check_errors;
|
|
|
|
check->corruptions = result.corruptions;
|
|
|
|
check->has_corruptions = result.corruptions != 0;
|
|
|
|
check->leaks = result.leaks;
|
|
|
|
check->has_leaks = result.leaks != 0;
|
|
|
|
check->corruptions_fixed = result.corruptions_fixed;
|
|
|
|
check->has_corruptions_fixed = result.corruptions != 0;
|
|
|
|
check->leaks_fixed = result.leaks_fixed;
|
|
|
|
check->has_leaks_fixed = result.leaks != 0;
|
|
|
|
check->image_end_offset = result.image_end_offset;
|
|
|
|
check->has_image_end_offset = result.image_end_offset != 0;
|
|
|
|
check->total_clusters = result.bfi.total_clusters;
|
|
|
|
check->has_total_clusters = result.bfi.total_clusters != 0;
|
|
|
|
check->allocated_clusters = result.bfi.allocated_clusters;
|
|
|
|
check->has_allocated_clusters = result.bfi.allocated_clusters != 0;
|
|
|
|
check->fragmented_clusters = result.bfi.fragmented_clusters;
|
|
|
|
check->has_fragmented_clusters = result.bfi.fragmented_clusters != 0;
|
2013-02-07 16:15:04 +00:00
|
|
|
check->compressed_clusters = result.bfi.compressed_clusters;
|
|
|
|
check->has_compressed_clusters = result.bfi.compressed_clusters != 0;
|
2013-01-28 11:59:47 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-06-29 09:43:13 +00:00
|
|
|
/*
|
|
|
|
* Checks an image for consistency. Exit codes:
|
|
|
|
*
|
2014-06-02 20:15:21 +00:00
|
|
|
* 0 - Check completed, image is good
|
|
|
|
* 1 - Check not completed because of internal errors
|
|
|
|
* 2 - Check completed, image is corrupted
|
|
|
|
* 3 - Check completed, image has leaked clusters, but is good otherwise
|
|
|
|
* 63 - Checks are not supported by the image format
|
2010-06-29 09:43:13 +00:00
|
|
|
*/
|
2009-04-21 23:11:53 +00:00
|
|
|
static int img_check(int argc, char **argv)
|
|
|
|
{
|
|
|
|
int c, ret;
|
2013-01-28 11:59:47 +00:00
|
|
|
OutputFormat output_format = OFORMAT_HUMAN;
|
2014-07-22 20:58:42 +00:00
|
|
|
const char *filename, *fmt, *output, *cache;
|
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 11:59:04 +00:00
|
|
|
BlockBackend *blk;
|
2009-04-21 23:11:53 +00:00
|
|
|
BlockDriverState *bs;
|
2012-05-11 14:07:02 +00:00
|
|
|
int fix = 0;
|
2012-08-09 12:05:56 +00:00
|
|
|
int flags = BDRV_O_FLAGS | BDRV_O_CHECK;
|
2014-10-07 11:59:05 +00:00
|
|
|
ImageCheck *check;
|
2013-02-13 08:09:40 +00:00
|
|
|
bool quiet = false;
|
2009-04-21 23:11:53 +00:00
|
|
|
|
|
|
|
fmt = NULL;
|
2013-01-28 11:59:47 +00:00
|
|
|
output = NULL;
|
2014-07-22 20:58:42 +00:00
|
|
|
cache = BDRV_DEFAULT_CACHE;
|
2009-04-21 23:11:53 +00:00
|
|
|
for(;;) {
|
2013-01-28 11:59:47 +00:00
|
|
|
int option_index = 0;
|
|
|
|
static const struct option long_options[] = {
|
|
|
|
{"help", no_argument, 0, 'h'},
|
|
|
|
{"format", required_argument, 0, 'f'},
|
2014-03-24 18:38:54 +00:00
|
|
|
{"repair", required_argument, 0, 'r'},
|
2013-01-28 11:59:47 +00:00
|
|
|
{"output", required_argument, 0, OPTION_OUTPUT},
|
|
|
|
{0, 0, 0, 0}
|
|
|
|
};
|
2014-07-22 20:58:42 +00:00
|
|
|
c = getopt_long(argc, argv, "hf:r:T:q",
|
2013-01-28 11:59:47 +00:00
|
|
|
long_options, &option_index);
|
2010-12-06 14:25:39 +00:00
|
|
|
if (c == -1) {
|
2009-04-21 23:11:53 +00:00
|
|
|
break;
|
2010-12-06 14:25:39 +00:00
|
|
|
}
|
2009-04-21 23:11:53 +00:00
|
|
|
switch(c) {
|
2010-12-06 14:25:40 +00:00
|
|
|
case '?':
|
2009-04-21 23:11:53 +00:00
|
|
|
case 'h':
|
|
|
|
help();
|
|
|
|
break;
|
|
|
|
case 'f':
|
|
|
|
fmt = optarg;
|
|
|
|
break;
|
2012-05-11 14:07:02 +00:00
|
|
|
case 'r':
|
|
|
|
flags |= BDRV_O_RDWR;
|
|
|
|
|
|
|
|
if (!strcmp(optarg, "leaks")) {
|
|
|
|
fix = BDRV_FIX_LEAKS;
|
|
|
|
} else if (!strcmp(optarg, "all")) {
|
|
|
|
fix = BDRV_FIX_LEAKS | BDRV_FIX_ERRORS;
|
|
|
|
} else {
|
2014-04-22 05:36:11 +00:00
|
|
|
error_exit("Unknown option value for -r "
|
|
|
|
"(expecting 'leaks' or 'all'): %s", optarg);
|
2012-05-11 14:07:02 +00:00
|
|
|
}
|
|
|
|
break;
|
2013-01-28 11:59:47 +00:00
|
|
|
case OPTION_OUTPUT:
|
|
|
|
output = optarg;
|
|
|
|
break;
|
2014-07-22 20:58:42 +00:00
|
|
|
case 'T':
|
|
|
|
cache = optarg;
|
|
|
|
break;
|
2013-02-13 08:09:40 +00:00
|
|
|
case 'q':
|
|
|
|
quiet = true;
|
|
|
|
break;
|
2009-04-21 23:11:53 +00:00
|
|
|
}
|
|
|
|
}
|
2013-08-05 08:53:04 +00:00
|
|
|
if (optind != argc - 1) {
|
2014-04-22 05:36:11 +00:00
|
|
|
error_exit("Expecting one image file name");
|
2010-12-06 14:25:39 +00:00
|
|
|
}
|
2009-04-21 23:11:53 +00:00
|
|
|
filename = argv[optind++];
|
|
|
|
|
2013-01-28 11:59:47 +00:00
|
|
|
if (output && !strcmp(output, "json")) {
|
|
|
|
output_format = OFORMAT_JSON;
|
|
|
|
} else if (output && !strcmp(output, "human")) {
|
|
|
|
output_format = OFORMAT_HUMAN;
|
|
|
|
} else if (output) {
|
|
|
|
error_report("--output must be used with human or json as argument.");
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2014-07-22 20:58:42 +00:00
|
|
|
ret = bdrv_parse_cache_flags(cache, &flags);
|
|
|
|
if (ret < 0) {
|
|
|
|
error_report("Invalid source cache option: %s", cache);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2014-10-07 11:59:05 +00:00
|
|
|
blk = img_open("image", filename, fmt, flags, true, quiet);
|
|
|
|
if (!blk) {
|
|
|
|
return 1;
|
2010-06-20 19:26:35 +00:00
|
|
|
}
|
2014-10-07 11:59:05 +00:00
|
|
|
bs = blk_bs(blk);
|
2013-01-28 11:59:47 +00:00
|
|
|
|
|
|
|
check = g_new0(ImageCheck, 1);
|
|
|
|
ret = collect_image_check(bs, check, filename, fmt, fix);
|
2010-06-29 09:43:13 +00:00
|
|
|
|
|
|
|
if (ret == -ENOTSUP) {
|
2014-05-31 19:33:30 +00:00
|
|
|
error_report("This image format does not support checks");
|
2013-10-24 06:53:34 +00:00
|
|
|
ret = 63;
|
2013-01-28 11:59:47 +00:00
|
|
|
goto fail;
|
2010-06-29 09:43:13 +00:00
|
|
|
}
|
|
|
|
|
2013-01-28 11:59:47 +00:00
|
|
|
if (check->corruptions_fixed || check->leaks_fixed) {
|
|
|
|
int corruptions_fixed, leaks_fixed;
|
2012-05-11 16:16:54 +00:00
|
|
|
|
2013-01-28 11:59:47 +00:00
|
|
|
leaks_fixed = check->leaks_fixed;
|
|
|
|
corruptions_fixed = check->corruptions_fixed;
|
2010-06-29 09:43:13 +00:00
|
|
|
|
2013-01-28 11:59:47 +00:00
|
|
|
if (output_format == OFORMAT_HUMAN) {
|
2013-02-13 08:09:40 +00:00
|
|
|
qprintf(quiet,
|
|
|
|
"The following inconsistencies were found and repaired:\n\n"
|
|
|
|
" %" PRId64 " leaked clusters\n"
|
|
|
|
" %" PRId64 " corruptions\n\n"
|
|
|
|
"Double checking the fixed image now...\n",
|
|
|
|
check->leaks_fixed,
|
|
|
|
check->corruptions_fixed);
|
2010-06-29 09:43:13 +00:00
|
|
|
}
|
|
|
|
|
2013-01-28 11:59:47 +00:00
|
|
|
ret = collect_image_check(bs, check, filename, fmt, 0);
|
2009-04-21 23:11:53 +00:00
|
|
|
|
2013-01-28 11:59:47 +00:00
|
|
|
check->leaks_fixed = leaks_fixed;
|
|
|
|
check->corruptions_fixed = corruptions_fixed;
|
2012-03-15 12:13:31 +00:00
|
|
|
}
|
|
|
|
|
2014-10-23 13:29:12 +00:00
|
|
|
if (!ret) {
|
|
|
|
switch (output_format) {
|
|
|
|
case OFORMAT_HUMAN:
|
|
|
|
dump_human_image_check(check, quiet);
|
|
|
|
break;
|
|
|
|
case OFORMAT_JSON:
|
|
|
|
dump_json_image_check(check, quiet);
|
|
|
|
break;
|
|
|
|
}
|
2013-01-28 11:59:46 +00:00
|
|
|
}
|
|
|
|
|
2013-01-28 11:59:47 +00:00
|
|
|
if (ret || check->check_errors) {
|
2014-10-23 13:29:12 +00:00
|
|
|
if (ret) {
|
|
|
|
error_report("Check failed: %s", strerror(-ret));
|
|
|
|
} else {
|
|
|
|
error_report("Check failed");
|
|
|
|
}
|
2013-01-28 11:59:47 +00:00
|
|
|
ret = 1;
|
|
|
|
goto fail;
|
2010-06-20 19:26:35 +00:00
|
|
|
}
|
2010-06-29 09:43:13 +00:00
|
|
|
|
2013-01-28 11:59:47 +00:00
|
|
|
if (check->corruptions) {
|
|
|
|
ret = 2;
|
|
|
|
} else if (check->leaks) {
|
|
|
|
ret = 3;
|
2010-06-29 09:43:13 +00:00
|
|
|
} else {
|
2013-01-28 11:59:47 +00:00
|
|
|
ret = 0;
|
2010-06-29 09:43:13 +00:00
|
|
|
}
|
2013-01-28 11:59:47 +00:00
|
|
|
|
|
|
|
fail:
|
|
|
|
qapi_free_ImageCheck(check);
|
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 11:59:04 +00:00
|
|
|
blk_unref(blk);
|
2013-01-28 11:59:47 +00:00
|
|
|
return ret;
|
2009-04-21 23:11:53 +00:00
|
|
|
}
|
|
|
|
|
2014-10-24 13:57:37 +00:00
|
|
|
typedef struct CommonBlockJobCBInfo {
|
|
|
|
BlockDriverState *bs;
|
|
|
|
Error **errp;
|
|
|
|
} CommonBlockJobCBInfo;
|
|
|
|
|
|
|
|
static void common_block_job_cb(void *opaque, int ret)
|
|
|
|
{
|
|
|
|
CommonBlockJobCBInfo *cbi = opaque;
|
|
|
|
|
|
|
|
if (ret < 0) {
|
|
|
|
error_setg_errno(cbi->errp, -ret, "Block job failed");
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Drop this block job's reference */
|
|
|
|
bdrv_unref(cbi->bs);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void run_block_job(BlockJob *job, Error **errp)
|
|
|
|
{
|
|
|
|
AioContext *aio_context = bdrv_get_aio_context(job->bs);
|
|
|
|
|
|
|
|
do {
|
|
|
|
aio_poll(aio_context, true);
|
2014-10-24 13:57:39 +00:00
|
|
|
qemu_progress_print((float)job->offset / job->len * 100.f, 0);
|
2014-10-24 13:57:37 +00:00
|
|
|
} while (!job->ready);
|
|
|
|
|
|
|
|
block_job_complete_sync(job, errp);
|
2014-10-24 13:57:39 +00:00
|
|
|
|
|
|
|
/* A block job may finish instantaneously without publishing any progress,
|
|
|
|
* so just signal completion here */
|
|
|
|
qemu_progress_print(100.f, 0);
|
2014-10-24 13:57:37 +00:00
|
|
|
}
|
|
|
|
|
2004-08-01 21:59:26 +00:00
|
|
|
static int img_commit(int argc, char **argv)
|
|
|
|
{
|
2011-06-20 16:48:19 +00:00
|
|
|
int c, ret, flags;
|
2014-10-24 13:57:40 +00:00
|
|
|
const char *filename, *fmt, *cache, *base;
|
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 11:59:04 +00:00
|
|
|
BlockBackend *blk;
|
2014-10-24 13:57:37 +00:00
|
|
|
BlockDriverState *bs, *base_bs;
|
2014-10-24 13:57:39 +00:00
|
|
|
bool progress = false, quiet = false, drop = false;
|
2014-10-24 13:57:37 +00:00
|
|
|
Error *local_err = NULL;
|
|
|
|
CommonBlockJobCBInfo cbi;
|
2004-08-01 21:59:26 +00:00
|
|
|
|
|
|
|
fmt = NULL;
|
2011-06-20 16:48:19 +00:00
|
|
|
cache = BDRV_DEFAULT_CACHE;
|
2014-10-24 13:57:40 +00:00
|
|
|
base = NULL;
|
2004-08-01 21:59:26 +00:00
|
|
|
for(;;) {
|
2014-10-24 13:57:40 +00:00
|
|
|
c = getopt(argc, argv, "f:ht:b:dpq");
|
2010-12-06 14:25:39 +00:00
|
|
|
if (c == -1) {
|
2004-08-01 21:59:26 +00:00
|
|
|
break;
|
2010-12-06 14:25:39 +00:00
|
|
|
}
|
2004-08-01 21:59:26 +00:00
|
|
|
switch(c) {
|
2010-12-06 14:25:40 +00:00
|
|
|
case '?':
|
2004-08-01 21:59:26 +00:00
|
|
|
case 'h':
|
|
|
|
help();
|
|
|
|
break;
|
|
|
|
case 'f':
|
|
|
|
fmt = optarg;
|
|
|
|
break;
|
2011-06-20 16:48:19 +00:00
|
|
|
case 't':
|
|
|
|
cache = optarg;
|
|
|
|
break;
|
2014-10-24 13:57:40 +00:00
|
|
|
case 'b':
|
|
|
|
base = optarg;
|
|
|
|
/* -b implies -d */
|
|
|
|
drop = true;
|
|
|
|
break;
|
2014-10-24 13:57:38 +00:00
|
|
|
case 'd':
|
|
|
|
drop = true;
|
|
|
|
break;
|
2014-10-24 13:57:39 +00:00
|
|
|
case 'p':
|
|
|
|
progress = true;
|
|
|
|
break;
|
2013-02-13 08:09:40 +00:00
|
|
|
case 'q':
|
|
|
|
quiet = true;
|
|
|
|
break;
|
2004-08-01 21:59:26 +00:00
|
|
|
}
|
|
|
|
}
|
2014-10-24 13:57:39 +00:00
|
|
|
|
|
|
|
/* Progress is not shown in Quiet mode */
|
|
|
|
if (quiet) {
|
|
|
|
progress = false;
|
|
|
|
}
|
|
|
|
|
2013-08-05 08:53:04 +00:00
|
|
|
if (optind != argc - 1) {
|
2014-04-22 05:36:11 +00:00
|
|
|
error_exit("Expecting one image file name");
|
2010-12-06 14:25:39 +00:00
|
|
|
}
|
2004-08-01 21:59:26 +00:00
|
|
|
filename = argv[optind++];
|
|
|
|
|
2014-10-24 13:57:38 +00:00
|
|
|
flags = BDRV_O_RDWR | BDRV_O_UNMAP;
|
2011-08-04 11:26:51 +00:00
|
|
|
ret = bdrv_parse_cache_flags(cache, &flags);
|
2011-06-20 16:48:19 +00:00
|
|
|
if (ret < 0) {
|
|
|
|
error_report("Invalid cache option: %s", cache);
|
2014-08-26 18:17:54 +00:00
|
|
|
return 1;
|
2011-06-20 16:48:19 +00:00
|
|
|
}
|
|
|
|
|
2014-10-07 11:59:05 +00:00
|
|
|
blk = img_open("image", filename, fmt, flags, true, quiet);
|
|
|
|
if (!blk) {
|
|
|
|
return 1;
|
2010-06-20 19:26:35 +00:00
|
|
|
}
|
2014-10-07 11:59:05 +00:00
|
|
|
bs = blk_bs(blk);
|
|
|
|
|
2014-10-24 13:57:39 +00:00
|
|
|
qemu_progress_init(progress, 1.f);
|
|
|
|
qemu_progress_print(0.f, 100);
|
|
|
|
|
2014-10-24 13:57:40 +00:00
|
|
|
if (base) {
|
|
|
|
base_bs = bdrv_find_backing_image(bs, base);
|
|
|
|
if (!base_bs) {
|
2015-03-17 10:54:50 +00:00
|
|
|
error_setg(&local_err, QERR_BASE_NOT_FOUND, base);
|
2014-10-24 13:57:40 +00:00
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* This is different from QMP, which by default uses the deepest file in
|
|
|
|
* the backing chain (i.e., the very base); however, the traditional
|
|
|
|
* behavior of qemu-img commit is using the immediate backing file. */
|
2015-06-17 12:55:21 +00:00
|
|
|
base_bs = backing_bs(bs);
|
2014-10-24 13:57:40 +00:00
|
|
|
if (!base_bs) {
|
|
|
|
error_setg(&local_err, "Image does not have a backing file");
|
|
|
|
goto done;
|
|
|
|
}
|
2014-10-24 13:57:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
cbi = (CommonBlockJobCBInfo){
|
|
|
|
.errp = &local_err,
|
|
|
|
.bs = bs,
|
|
|
|
};
|
|
|
|
|
|
|
|
commit_active_start(bs, base_bs, 0, BLOCKDEV_ON_ERROR_REPORT,
|
|
|
|
common_block_job_cb, &cbi, &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
goto done;
|
2004-08-01 21:59:26 +00:00
|
|
|
}
|
|
|
|
|
2014-10-24 13:57:38 +00:00
|
|
|
/* The block job will swap base_bs and bs (which is not what we really want
|
|
|
|
* here, but okay) and unref base_bs (after the swap, i.e., the old top
|
|
|
|
* image). In order to still be able to empty that top image afterwards,
|
|
|
|
* increment the reference counter here preemptively. */
|
|
|
|
if (!drop) {
|
|
|
|
bdrv_ref(base_bs);
|
|
|
|
}
|
|
|
|
|
2014-10-24 13:57:37 +00:00
|
|
|
run_block_job(bs->job, &local_err);
|
2014-10-24 13:57:38 +00:00
|
|
|
if (local_err) {
|
|
|
|
goto unref_backing;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!drop && base_bs->drv->bdrv_make_empty) {
|
|
|
|
ret = base_bs->drv->bdrv_make_empty(base_bs);
|
|
|
|
if (ret) {
|
|
|
|
error_setg_errno(&local_err, -ret, "Could not empty %s",
|
|
|
|
filename);
|
|
|
|
goto unref_backing;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
unref_backing:
|
|
|
|
if (!drop) {
|
|
|
|
bdrv_unref(base_bs);
|
|
|
|
}
|
2014-10-24 13:57:37 +00:00
|
|
|
|
|
|
|
done:
|
2014-10-24 13:57:39 +00:00
|
|
|
qemu_progress_end();
|
|
|
|
|
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 11:59:04 +00:00
|
|
|
blk_unref(blk);
|
2014-10-24 13:57:37 +00:00
|
|
|
|
|
|
|
if (local_err) {
|
2015-02-10 14:14:02 +00:00
|
|
|
error_report_err(local_err);
|
2010-06-20 19:26:35 +00:00
|
|
|
return 1;
|
|
|
|
}
|
2014-10-24 13:57:37 +00:00
|
|
|
|
|
|
|
qprintf(quiet, "Image committed.\n");
|
2004-08-01 21:59:26 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-06-05 21:53:49 +00:00
|
|
|
/*
|
|
|
|
* Returns true iff the first sector pointed to by 'buf' contains at least
|
|
|
|
* a non-NUL byte.
|
|
|
|
*
|
|
|
|
* 'pnum' is set to the number of sectors (including and immediately following
|
|
|
|
* the first one) that are known to be in the same allocated/unallocated state.
|
|
|
|
*/
|
2004-08-01 21:59:26 +00:00
|
|
|
static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum)
|
|
|
|
{
|
2012-02-07 13:27:24 +00:00
|
|
|
bool is_zero;
|
|
|
|
int i;
|
2004-08-01 21:59:26 +00:00
|
|
|
|
|
|
|
if (n <= 0) {
|
|
|
|
*pnum = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
2012-02-07 13:27:24 +00:00
|
|
|
is_zero = buffer_is_zero(buf, 512);
|
2004-08-01 21:59:26 +00:00
|
|
|
for(i = 1; i < n; i++) {
|
|
|
|
buf += 512;
|
2012-02-07 13:27:24 +00:00
|
|
|
if (is_zero != buffer_is_zero(buf, 512)) {
|
2004-08-01 21:59:26 +00:00
|
|
|
break;
|
2012-02-07 13:27:24 +00:00
|
|
|
}
|
2004-08-01 21:59:26 +00:00
|
|
|
}
|
|
|
|
*pnum = i;
|
2012-02-07 13:27:24 +00:00
|
|
|
return !is_zero;
|
2004-08-01 21:59:26 +00:00
|
|
|
}
|
|
|
|
|
2011-08-26 13:27:13 +00:00
|
|
|
/*
|
|
|
|
* Like is_allocated_sectors, but if the buffer starts with a used sector,
|
|
|
|
* up to 'min' consecutive sectors containing zeros are ignored. This avoids
|
|
|
|
* breaking up write requests for only small sparse areas.
|
|
|
|
*/
|
|
|
|
static int is_allocated_sectors_min(const uint8_t *buf, int n, int *pnum,
|
|
|
|
int min)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
int num_checked, num_used;
|
|
|
|
|
|
|
|
if (n < min) {
|
|
|
|
min = n;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = is_allocated_sectors(buf, n, pnum);
|
|
|
|
if (!ret) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
num_used = *pnum;
|
|
|
|
buf += BDRV_SECTOR_SIZE * *pnum;
|
|
|
|
n -= *pnum;
|
|
|
|
num_checked = num_used;
|
|
|
|
|
|
|
|
while (n > 0) {
|
|
|
|
ret = is_allocated_sectors(buf, n, pnum);
|
|
|
|
|
|
|
|
buf += BDRV_SECTOR_SIZE * *pnum;
|
|
|
|
n -= *pnum;
|
|
|
|
num_checked += *pnum;
|
|
|
|
if (ret) {
|
|
|
|
num_used = num_checked;
|
|
|
|
} else if (*pnum >= min) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
*pnum = num_used;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2010-01-12 11:55:18 +00:00
|
|
|
/*
|
|
|
|
* Compares two buffers sector by sector. Returns 0 if the first sector of both
|
|
|
|
* buffers matches, non-zero otherwise.
|
|
|
|
*
|
|
|
|
* pnum is set to the number of sectors (including and immediately following
|
|
|
|
* the first one) that are known to have the same comparison result
|
|
|
|
*/
|
|
|
|
static int compare_sectors(const uint8_t *buf1, const uint8_t *buf2, int n,
|
|
|
|
int *pnum)
|
|
|
|
{
|
2015-02-20 16:06:15 +00:00
|
|
|
bool res;
|
|
|
|
int i;
|
2010-01-12 11:55:18 +00:00
|
|
|
|
|
|
|
if (n <= 0) {
|
|
|
|
*pnum = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
res = !!memcmp(buf1, buf2, 512);
|
|
|
|
for(i = 1; i < n; i++) {
|
|
|
|
buf1 += 512;
|
|
|
|
buf2 += 512;
|
|
|
|
|
|
|
|
if (!!memcmp(buf1, buf2, 512) != res) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
*pnum = i;
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2009-09-15 10:30:43 +00:00
|
|
|
#define IO_BUF_SIZE (2 * 1024 * 1024)
|
2004-08-01 21:59:26 +00:00
|
|
|
|
2013-02-13 08:09:41 +00:00
|
|
|
static int64_t sectors_to_bytes(int64_t sectors)
|
|
|
|
{
|
|
|
|
return sectors << BDRV_SECTOR_BITS;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int64_t sectors_to_process(int64_t total, int64_t from)
|
|
|
|
{
|
|
|
|
return MIN(total - from, IO_BUF_SIZE >> BDRV_SECTOR_BITS);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check if passed sectors are empty (not allocated or contain only 0 bytes)
|
|
|
|
*
|
|
|
|
* Returns 0 in case sectors are filled with 0, 1 if sectors contain non-zero
|
|
|
|
* data and negative value on error.
|
|
|
|
*
|
2015-02-05 18:58:18 +00:00
|
|
|
* @param blk: BlockBackend for the image
|
2013-02-13 08:09:41 +00:00
|
|
|
* @param sect_num: Number of first sector to check
|
|
|
|
* @param sect_count: Number of sectors to check
|
|
|
|
* @param filename: Name of disk file we are checking (logging purpose)
|
|
|
|
* @param buffer: Allocated buffer for storing read data
|
|
|
|
* @param quiet: Flag for quiet mode
|
|
|
|
*/
|
2015-02-05 18:58:18 +00:00
|
|
|
static int check_empty_sectors(BlockBackend *blk, int64_t sect_num,
|
2013-02-13 08:09:41 +00:00
|
|
|
int sect_count, const char *filename,
|
|
|
|
uint8_t *buffer, bool quiet)
|
|
|
|
{
|
|
|
|
int pnum, ret = 0;
|
2015-02-05 18:58:18 +00:00
|
|
|
ret = blk_read(blk, sect_num, buffer, sect_count);
|
2013-02-13 08:09:41 +00:00
|
|
|
if (ret < 0) {
|
|
|
|
error_report("Error while reading offset %" PRId64 " of %s: %s",
|
|
|
|
sectors_to_bytes(sect_num), filename, strerror(-ret));
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
ret = is_allocated_sectors(buffer, sect_count, &pnum);
|
|
|
|
if (ret || pnum != sect_count) {
|
|
|
|
qprintf(quiet, "Content mismatch at offset %" PRId64 "!\n",
|
|
|
|
sectors_to_bytes(ret ? sect_num : sect_num + pnum));
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Compares two images. Exit codes:
|
|
|
|
*
|
|
|
|
* 0 - Images are identical
|
|
|
|
* 1 - Images differ
|
|
|
|
* >1 - Error occurred
|
|
|
|
*/
|
|
|
|
static int img_compare(int argc, char **argv)
|
|
|
|
{
|
2014-07-22 20:58:42 +00:00
|
|
|
const char *fmt1 = NULL, *fmt2 = NULL, *cache, *filename1, *filename2;
|
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 11:59:04 +00:00
|
|
|
BlockBackend *blk1, *blk2;
|
2013-02-13 08:09:41 +00:00
|
|
|
BlockDriverState *bs1, *bs2;
|
|
|
|
int64_t total_sectors1, total_sectors2;
|
|
|
|
uint8_t *buf1 = NULL, *buf2 = NULL;
|
|
|
|
int pnum1, pnum2;
|
|
|
|
int allocated1, allocated2;
|
|
|
|
int ret = 0; /* return value - 0 Ident, 1 Different, >1 Error */
|
|
|
|
bool progress = false, quiet = false, strict = false;
|
2014-07-22 20:58:42 +00:00
|
|
|
int flags;
|
2013-02-13 08:09:41 +00:00
|
|
|
int64_t total_sectors;
|
|
|
|
int64_t sector_num = 0;
|
|
|
|
int64_t nb_sectors;
|
|
|
|
int c, pnum;
|
|
|
|
uint64_t progress_base;
|
|
|
|
|
2014-07-22 20:58:42 +00:00
|
|
|
cache = BDRV_DEFAULT_CACHE;
|
2013-02-13 08:09:41 +00:00
|
|
|
for (;;) {
|
2014-07-22 20:58:42 +00:00
|
|
|
c = getopt(argc, argv, "hf:F:T:pqs");
|
2013-02-13 08:09:41 +00:00
|
|
|
if (c == -1) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
switch (c) {
|
|
|
|
case '?':
|
|
|
|
case 'h':
|
|
|
|
help();
|
|
|
|
break;
|
|
|
|
case 'f':
|
|
|
|
fmt1 = optarg;
|
|
|
|
break;
|
|
|
|
case 'F':
|
|
|
|
fmt2 = optarg;
|
|
|
|
break;
|
2014-07-22 20:58:42 +00:00
|
|
|
case 'T':
|
|
|
|
cache = optarg;
|
|
|
|
break;
|
2013-02-13 08:09:41 +00:00
|
|
|
case 'p':
|
|
|
|
progress = true;
|
|
|
|
break;
|
|
|
|
case 'q':
|
|
|
|
quiet = true;
|
|
|
|
break;
|
|
|
|
case 's':
|
|
|
|
strict = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Progress is not shown in Quiet mode */
|
|
|
|
if (quiet) {
|
|
|
|
progress = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-08-05 08:53:04 +00:00
|
|
|
if (optind != argc - 2) {
|
2014-04-22 05:36:11 +00:00
|
|
|
error_exit("Expecting two image file names");
|
2013-02-13 08:09:41 +00:00
|
|
|
}
|
|
|
|
filename1 = argv[optind++];
|
|
|
|
filename2 = argv[optind++];
|
|
|
|
|
2014-08-26 18:17:55 +00:00
|
|
|
/* Initialize before goto out */
|
|
|
|
qemu_progress_init(progress, 2.0);
|
|
|
|
|
2014-07-22 20:58:42 +00:00
|
|
|
flags = BDRV_O_FLAGS;
|
|
|
|
ret = bdrv_parse_cache_flags(cache, &flags);
|
|
|
|
if (ret < 0) {
|
|
|
|
error_report("Invalid source cache option: %s", cache);
|
|
|
|
ret = 2;
|
|
|
|
goto out3;
|
|
|
|
}
|
|
|
|
|
2014-10-07 11:59:05 +00:00
|
|
|
blk1 = img_open("image_1", filename1, fmt1, flags, true, quiet);
|
|
|
|
if (!blk1) {
|
2013-02-13 08:09:41 +00:00
|
|
|
ret = 2;
|
2014-10-07 11:59:05 +00:00
|
|
|
goto out3;
|
2013-02-13 08:09:41 +00:00
|
|
|
}
|
2014-10-07 11:59:05 +00:00
|
|
|
bs1 = blk_bs(blk1);
|
2013-02-13 08:09:41 +00:00
|
|
|
|
2014-10-07 11:59:05 +00:00
|
|
|
blk2 = img_open("image_2", filename2, fmt2, flags, true, quiet);
|
|
|
|
if (!blk2) {
|
2013-02-13 08:09:41 +00:00
|
|
|
ret = 2;
|
2014-10-07 11:59:05 +00:00
|
|
|
goto out2;
|
2013-02-13 08:09:41 +00:00
|
|
|
}
|
2014-10-07 11:59:05 +00:00
|
|
|
bs2 = blk_bs(blk2);
|
2013-02-13 08:09:41 +00:00
|
|
|
|
2015-02-05 18:58:18 +00:00
|
|
|
buf1 = blk_blockalign(blk1, IO_BUF_SIZE);
|
|
|
|
buf2 = blk_blockalign(blk2, IO_BUF_SIZE);
|
|
|
|
total_sectors1 = blk_nb_sectors(blk1);
|
2014-06-26 11:23:25 +00:00
|
|
|
if (total_sectors1 < 0) {
|
|
|
|
error_report("Can't get size of %s: %s",
|
|
|
|
filename1, strerror(-total_sectors1));
|
|
|
|
ret = 4;
|
|
|
|
goto out;
|
|
|
|
}
|
2015-02-05 18:58:18 +00:00
|
|
|
total_sectors2 = blk_nb_sectors(blk2);
|
2014-06-26 11:23:25 +00:00
|
|
|
if (total_sectors2 < 0) {
|
|
|
|
error_report("Can't get size of %s: %s",
|
|
|
|
filename2, strerror(-total_sectors2));
|
|
|
|
ret = 4;
|
|
|
|
goto out;
|
|
|
|
}
|
2013-02-13 08:09:41 +00:00
|
|
|
total_sectors = MIN(total_sectors1, total_sectors2);
|
|
|
|
progress_base = MAX(total_sectors1, total_sectors2);
|
|
|
|
|
|
|
|
qemu_progress_print(0, 100);
|
|
|
|
|
|
|
|
if (strict && total_sectors1 != total_sectors2) {
|
|
|
|
ret = 1;
|
|
|
|
qprintf(quiet, "Strict mode: Image size mismatch!\n");
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
nb_sectors = sectors_to_process(total_sectors, sector_num);
|
|
|
|
if (nb_sectors <= 0) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
allocated1 = bdrv_is_allocated_above(bs1, NULL, sector_num, nb_sectors,
|
|
|
|
&pnum1);
|
|
|
|
if (allocated1 < 0) {
|
|
|
|
ret = 3;
|
|
|
|
error_report("Sector allocation test failed for %s", filename1);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
allocated2 = bdrv_is_allocated_above(bs2, NULL, sector_num, nb_sectors,
|
|
|
|
&pnum2);
|
|
|
|
if (allocated2 < 0) {
|
|
|
|
ret = 3;
|
|
|
|
error_report("Sector allocation test failed for %s", filename2);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
nb_sectors = MIN(pnum1, pnum2);
|
|
|
|
|
|
|
|
if (allocated1 == allocated2) {
|
|
|
|
if (allocated1) {
|
2015-02-05 18:58:18 +00:00
|
|
|
ret = blk_read(blk1, sector_num, buf1, nb_sectors);
|
2013-02-13 08:09:41 +00:00
|
|
|
if (ret < 0) {
|
|
|
|
error_report("Error while reading offset %" PRId64 " of %s:"
|
|
|
|
" %s", sectors_to_bytes(sector_num), filename1,
|
|
|
|
strerror(-ret));
|
|
|
|
ret = 4;
|
|
|
|
goto out;
|
|
|
|
}
|
2015-02-05 18:58:18 +00:00
|
|
|
ret = blk_read(blk2, sector_num, buf2, nb_sectors);
|
2013-02-13 08:09:41 +00:00
|
|
|
if (ret < 0) {
|
|
|
|
error_report("Error while reading offset %" PRId64
|
|
|
|
" of %s: %s", sectors_to_bytes(sector_num),
|
|
|
|
filename2, strerror(-ret));
|
|
|
|
ret = 4;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
ret = compare_sectors(buf1, buf2, nb_sectors, &pnum);
|
|
|
|
if (ret || pnum != nb_sectors) {
|
|
|
|
qprintf(quiet, "Content mismatch at offset %" PRId64 "!\n",
|
|
|
|
sectors_to_bytes(
|
|
|
|
ret ? sector_num : sector_num + pnum));
|
2013-11-13 12:26:49 +00:00
|
|
|
ret = 1;
|
2013-02-13 08:09:41 +00:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (strict) {
|
|
|
|
ret = 1;
|
|
|
|
qprintf(quiet, "Strict mode: Offset %" PRId64
|
|
|
|
" allocation mismatch!\n",
|
|
|
|
sectors_to_bytes(sector_num));
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (allocated1) {
|
2015-02-05 18:58:18 +00:00
|
|
|
ret = check_empty_sectors(blk1, sector_num, nb_sectors,
|
2013-02-13 08:09:41 +00:00
|
|
|
filename1, buf1, quiet);
|
|
|
|
} else {
|
2015-02-05 18:58:18 +00:00
|
|
|
ret = check_empty_sectors(blk2, sector_num, nb_sectors,
|
2013-02-13 08:09:41 +00:00
|
|
|
filename2, buf1, quiet);
|
|
|
|
}
|
|
|
|
if (ret) {
|
|
|
|
if (ret < 0) {
|
|
|
|
error_report("Error while reading offset %" PRId64 ": %s",
|
|
|
|
sectors_to_bytes(sector_num), strerror(-ret));
|
2013-11-13 12:26:49 +00:00
|
|
|
ret = 4;
|
2013-02-13 08:09:41 +00:00
|
|
|
}
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
sector_num += nb_sectors;
|
|
|
|
qemu_progress_print(((float) nb_sectors / progress_base)*100, 100);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (total_sectors1 != total_sectors2) {
|
2015-02-05 18:58:18 +00:00
|
|
|
BlockBackend *blk_over;
|
2013-02-13 08:09:41 +00:00
|
|
|
int64_t total_sectors_over;
|
|
|
|
const char *filename_over;
|
|
|
|
|
|
|
|
qprintf(quiet, "Warning: Image size mismatch!\n");
|
|
|
|
if (total_sectors1 > total_sectors2) {
|
|
|
|
total_sectors_over = total_sectors1;
|
2015-02-05 18:58:18 +00:00
|
|
|
blk_over = blk1;
|
2013-02-13 08:09:41 +00:00
|
|
|
filename_over = filename1;
|
|
|
|
} else {
|
|
|
|
total_sectors_over = total_sectors2;
|
2015-02-05 18:58:18 +00:00
|
|
|
blk_over = blk2;
|
2013-02-13 08:09:41 +00:00
|
|
|
filename_over = filename2;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
nb_sectors = sectors_to_process(total_sectors_over, sector_num);
|
|
|
|
if (nb_sectors <= 0) {
|
|
|
|
break;
|
|
|
|
}
|
2015-02-05 18:58:18 +00:00
|
|
|
ret = bdrv_is_allocated_above(blk_bs(blk_over), NULL, sector_num,
|
2013-02-13 08:09:41 +00:00
|
|
|
nb_sectors, &pnum);
|
|
|
|
if (ret < 0) {
|
|
|
|
ret = 3;
|
|
|
|
error_report("Sector allocation test failed for %s",
|
|
|
|
filename_over);
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
}
|
|
|
|
nb_sectors = pnum;
|
|
|
|
if (ret) {
|
2015-02-05 18:58:18 +00:00
|
|
|
ret = check_empty_sectors(blk_over, sector_num, nb_sectors,
|
2013-02-13 08:09:41 +00:00
|
|
|
filename_over, buf1, quiet);
|
|
|
|
if (ret) {
|
|
|
|
if (ret < 0) {
|
|
|
|
error_report("Error while reading offset %" PRId64
|
|
|
|
" of %s: %s", sectors_to_bytes(sector_num),
|
|
|
|
filename_over, strerror(-ret));
|
2013-11-13 12:26:49 +00:00
|
|
|
ret = 4;
|
2013-02-13 08:09:41 +00:00
|
|
|
}
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
sector_num += nb_sectors;
|
|
|
|
qemu_progress_print(((float) nb_sectors / progress_base)*100, 100);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
qprintf(quiet, "Images are identical.\n");
|
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
out:
|
|
|
|
qemu_vfree(buf1);
|
|
|
|
qemu_vfree(buf2);
|
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 11:59:04 +00:00
|
|
|
blk_unref(blk2);
|
2013-02-13 08:09:41 +00:00
|
|
|
out2:
|
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 11:59:04 +00:00
|
|
|
blk_unref(blk1);
|
2013-02-13 08:09:41 +00:00
|
|
|
out3:
|
|
|
|
qemu_progress_end();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
qemu-img convert: Rewrite copying logic
The implementation of qemu-img convert is (a) messy, (b) buggy, and
(c) less efficient than possible. The changes required to beat some
sense into it are massive enough that incremental changes would only
make my and the reviewers' life harder. So throw it away and reimplement
it from scratch.
Let me give some examples what I mean by messy, buggy and inefficient:
(a) The copying logic of qemu-img convert has two separate branches for
compressed and normal target images, which roughly do the same -
except for a little code that handles actual differences between
compressed and uncompressed images, and much more code that
implements just a different set of optimisations and bugs. This is
unnecessary code duplication, and makes the code for compressed
output (unsurprisingly) suffer from bitrot.
The code for uncompressed ouput is run twice to count the the total
length for the progress bar. In the first run it just takes a
shortcut and runs only half the loop, and when it's done, it toggles
a boolean, jumps out of the loop with a backwards goto and starts
over. Works, but pretty is something different.
(b) Converting while keeping a backing file (-B option) is broken in
several ways. This includes not writing to the image file if the
input has zero clusters or data filled with zeros (ignoring that the
backing file will be visible instead).
It also doesn't correctly limit every iteration of the copy loop to
sectors of the same status so that too many sectors may be copied to
in the target image. For -B this gives an unexpected result, for
other images it just does more work than necessary.
Conversion with a compressed target completely ignores any target
backing file.
(c) qemu-img convert skips reading and writing an area if it knows from
metadata that copying isn't needed (except for the bug mentioned
above that ignores a status change in some cases). It does, however,
read from the source even if it knows that it will read zeros, and
then search for non-zero bytes in the read buffer, if it's possible
that a write might be needed.
This reimplementation of the copying core reorganises the code to remove
the duplication and have a much more obvious code flow, by essentially
splitting the copy iteration loop into three parts:
1. Find the number of contiguous sectors of the same status at the
current offset (This can also be called in a separate loop before the
copying loop in order to determine the total sectors for the progress
bar.)
2. Read sectors. If the status implies that there is no data there to
read (zero or unallocated cluster), don't do anything.
3. Write sectors depending on the status. If it's data, write it. If
we want the backing file to be visible (with -B), don't write it. If
it's zeroed, skip it if you can, otherwise use bdrv_write_zeroes() to
optimise the write at least where possible.
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
2015-03-19 12:33:32 +00:00
|
|
|
enum ImgConvertBlockStatus {
|
|
|
|
BLK_DATA,
|
|
|
|
BLK_ZERO,
|
|
|
|
BLK_BACKING_FILE,
|
|
|
|
};
|
|
|
|
|
|
|
|
typedef struct ImgConvertState {
|
|
|
|
BlockBackend **src;
|
|
|
|
int64_t *src_sectors;
|
|
|
|
int src_cur, src_num;
|
|
|
|
int64_t src_cur_offset;
|
|
|
|
int64_t total_sectors;
|
|
|
|
int64_t allocated_sectors;
|
|
|
|
enum ImgConvertBlockStatus status;
|
|
|
|
int64_t sector_next_status;
|
|
|
|
BlockBackend *target;
|
|
|
|
bool has_zero_init;
|
|
|
|
bool compressed;
|
|
|
|
bool target_has_backing;
|
|
|
|
int min_sparse;
|
|
|
|
size_t cluster_sectors;
|
|
|
|
size_t buf_sectors;
|
|
|
|
} ImgConvertState;
|
|
|
|
|
|
|
|
static void convert_select_part(ImgConvertState *s, int64_t sector_num)
|
|
|
|
{
|
|
|
|
assert(sector_num >= s->src_cur_offset);
|
|
|
|
while (sector_num - s->src_cur_offset >= s->src_sectors[s->src_cur]) {
|
|
|
|
s->src_cur_offset += s->src_sectors[s->src_cur];
|
|
|
|
s->src_cur++;
|
|
|
|
assert(s->src_cur < s->src_num);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int convert_iteration_sectors(ImgConvertState *s, int64_t sector_num)
|
|
|
|
{
|
|
|
|
int64_t ret;
|
|
|
|
int n;
|
|
|
|
|
|
|
|
convert_select_part(s, sector_num);
|
|
|
|
|
|
|
|
assert(s->total_sectors > sector_num);
|
|
|
|
n = MIN(s->total_sectors - sector_num, BDRV_REQUEST_MAX_SECTORS);
|
|
|
|
|
|
|
|
if (s->sector_next_status <= sector_num) {
|
|
|
|
ret = bdrv_get_block_status(blk_bs(s->src[s->src_cur]),
|
|
|
|
sector_num - s->src_cur_offset,
|
|
|
|
n, &n);
|
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ret & BDRV_BLOCK_ZERO) {
|
|
|
|
s->status = BLK_ZERO;
|
|
|
|
} else if (ret & BDRV_BLOCK_DATA) {
|
|
|
|
s->status = BLK_DATA;
|
|
|
|
} else if (!s->target_has_backing) {
|
|
|
|
/* Without a target backing file we must copy over the contents of
|
|
|
|
* the backing file as well. */
|
|
|
|
/* TODO Check block status of the backing file chain to avoid
|
|
|
|
* needlessly reading zeroes and limiting the iteration to the
|
|
|
|
* buffer size */
|
|
|
|
s->status = BLK_DATA;
|
|
|
|
} else {
|
|
|
|
s->status = BLK_BACKING_FILE;
|
|
|
|
}
|
|
|
|
|
|
|
|
s->sector_next_status = sector_num + n;
|
|
|
|
}
|
|
|
|
|
|
|
|
n = MIN(n, s->sector_next_status - sector_num);
|
|
|
|
if (s->status == BLK_DATA) {
|
|
|
|
n = MIN(n, s->buf_sectors);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* We need to write complete clusters for compressed images, so if an
|
|
|
|
* unallocated area is shorter than that, we must consider the whole
|
|
|
|
* cluster allocated. */
|
|
|
|
if (s->compressed) {
|
|
|
|
if (n < s->cluster_sectors) {
|
|
|
|
n = MIN(s->cluster_sectors, s->total_sectors - sector_num);
|
|
|
|
s->status = BLK_DATA;
|
|
|
|
} else {
|
|
|
|
n = QEMU_ALIGN_DOWN(n, s->cluster_sectors);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int convert_read(ImgConvertState *s, int64_t sector_num, int nb_sectors,
|
|
|
|
uint8_t *buf)
|
|
|
|
{
|
|
|
|
int n;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (s->status == BLK_ZERO || s->status == BLK_BACKING_FILE) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
assert(nb_sectors <= s->buf_sectors);
|
|
|
|
while (nb_sectors > 0) {
|
|
|
|
BlockBackend *blk;
|
|
|
|
int64_t bs_sectors;
|
|
|
|
|
|
|
|
/* In the case of compression with multiple source files, we can get a
|
|
|
|
* nb_sectors that spreads into the next part. So we must be able to
|
|
|
|
* read across multiple BDSes for one convert_read() call. */
|
|
|
|
convert_select_part(s, sector_num);
|
|
|
|
blk = s->src[s->src_cur];
|
|
|
|
bs_sectors = s->src_sectors[s->src_cur];
|
|
|
|
|
|
|
|
n = MIN(nb_sectors, bs_sectors - (sector_num - s->src_cur_offset));
|
|
|
|
ret = blk_read(blk, sector_num - s->src_cur_offset, buf, n);
|
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
sector_num += n;
|
|
|
|
nb_sectors -= n;
|
|
|
|
buf += n * BDRV_SECTOR_SIZE;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int convert_write(ImgConvertState *s, int64_t sector_num, int nb_sectors,
|
|
|
|
const uint8_t *buf)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
while (nb_sectors > 0) {
|
|
|
|
int n = nb_sectors;
|
|
|
|
|
|
|
|
switch (s->status) {
|
|
|
|
case BLK_BACKING_FILE:
|
|
|
|
/* If we have a backing file, leave clusters unallocated that are
|
|
|
|
* unallocated in the source image, so that the backing file is
|
|
|
|
* visible at the respective offset. */
|
|
|
|
assert(s->target_has_backing);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case BLK_DATA:
|
|
|
|
/* We must always write compressed clusters as a whole, so don't
|
|
|
|
* try to find zeroed parts in the buffer. We can only save the
|
|
|
|
* write if the buffer is completely zeroed and we're allowed to
|
|
|
|
* keep the target sparse. */
|
|
|
|
if (s->compressed) {
|
|
|
|
if (s->has_zero_init && s->min_sparse &&
|
|
|
|
buffer_is_zero(buf, n * BDRV_SECTOR_SIZE))
|
|
|
|
{
|
|
|
|
assert(!s->target_has_backing);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = blk_write_compressed(s->target, sector_num, buf, n);
|
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If there is real non-zero data or we're told to keep the target
|
|
|
|
* fully allocated (-S 0), we must write it. Otherwise we can treat
|
|
|
|
* it as zero sectors. */
|
|
|
|
if (!s->min_sparse ||
|
|
|
|
is_allocated_sectors_min(buf, n, &n, s->min_sparse))
|
|
|
|
{
|
|
|
|
ret = blk_write(s->target, sector_num, buf, n);
|
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* fall-through */
|
|
|
|
|
|
|
|
case BLK_ZERO:
|
|
|
|
if (s->has_zero_init) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
ret = blk_write_zeroes(s->target, sector_num, n, 0);
|
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
sector_num += n;
|
|
|
|
nb_sectors -= n;
|
|
|
|
buf += n * BDRV_SECTOR_SIZE;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int convert_do_copy(ImgConvertState *s)
|
|
|
|
{
|
|
|
|
uint8_t *buf = NULL;
|
|
|
|
int64_t sector_num, allocated_done;
|
|
|
|
int ret;
|
|
|
|
int n;
|
|
|
|
|
|
|
|
/* Check whether we have zero initialisation or can get it efficiently */
|
|
|
|
s->has_zero_init = s->min_sparse && !s->target_has_backing
|
|
|
|
? bdrv_has_zero_init(blk_bs(s->target))
|
|
|
|
: false;
|
|
|
|
|
|
|
|
if (!s->has_zero_init && !s->target_has_backing &&
|
|
|
|
bdrv_can_write_zeroes_with_unmap(blk_bs(s->target)))
|
|
|
|
{
|
|
|
|
ret = bdrv_make_zero(blk_bs(s->target), BDRV_REQ_MAY_UNMAP);
|
|
|
|
if (ret == 0) {
|
|
|
|
s->has_zero_init = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Allocate buffer for copied data. For compressed images, only one cluster
|
|
|
|
* can be copied at a time. */
|
|
|
|
if (s->compressed) {
|
|
|
|
if (s->cluster_sectors <= 0 || s->cluster_sectors > s->buf_sectors) {
|
|
|
|
error_report("invalid cluster size");
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
s->buf_sectors = s->cluster_sectors;
|
|
|
|
}
|
|
|
|
buf = blk_blockalign(s->target, s->buf_sectors * BDRV_SECTOR_SIZE);
|
|
|
|
|
|
|
|
/* Calculate allocated sectors for progress */
|
|
|
|
s->allocated_sectors = 0;
|
|
|
|
sector_num = 0;
|
|
|
|
while (sector_num < s->total_sectors) {
|
|
|
|
n = convert_iteration_sectors(s, sector_num);
|
|
|
|
if (n < 0) {
|
|
|
|
ret = n;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
if (s->status == BLK_DATA) {
|
|
|
|
s->allocated_sectors += n;
|
|
|
|
}
|
|
|
|
sector_num += n;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Do the copy */
|
|
|
|
s->src_cur = 0;
|
|
|
|
s->src_cur_offset = 0;
|
|
|
|
s->sector_next_status = 0;
|
|
|
|
|
|
|
|
sector_num = 0;
|
|
|
|
allocated_done = 0;
|
|
|
|
|
|
|
|
while (sector_num < s->total_sectors) {
|
|
|
|
n = convert_iteration_sectors(s, sector_num);
|
|
|
|
if (n < 0) {
|
|
|
|
ret = n;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
if (s->status == BLK_DATA) {
|
|
|
|
allocated_done += n;
|
|
|
|
qemu_progress_print(100.0 * allocated_done / s->allocated_sectors,
|
|
|
|
0);
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = convert_read(s, sector_num, n, buf);
|
|
|
|
if (ret < 0) {
|
|
|
|
error_report("error while reading sector %" PRId64
|
|
|
|
": %s", sector_num, strerror(-ret));
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = convert_write(s, sector_num, n, buf);
|
|
|
|
if (ret < 0) {
|
|
|
|
error_report("error while writing sector %" PRId64
|
|
|
|
": %s", sector_num, strerror(-ret));
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
sector_num += n;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (s->compressed) {
|
|
|
|
/* signal EOF to align */
|
|
|
|
ret = blk_write_compressed(s->target, 0, NULL, 0);
|
|
|
|
if (ret < 0) {
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
fail:
|
|
|
|
qemu_vfree(buf);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2004-08-01 21:59:26 +00:00
|
|
|
static int img_convert(int argc, char **argv)
|
|
|
|
{
|
qemu-img convert: Rewrite copying logic
The implementation of qemu-img convert is (a) messy, (b) buggy, and
(c) less efficient than possible. The changes required to beat some
sense into it are massive enough that incremental changes would only
make my and the reviewers' life harder. So throw it away and reimplement
it from scratch.
Let me give some examples what I mean by messy, buggy and inefficient:
(a) The copying logic of qemu-img convert has two separate branches for
compressed and normal target images, which roughly do the same -
except for a little code that handles actual differences between
compressed and uncompressed images, and much more code that
implements just a different set of optimisations and bugs. This is
unnecessary code duplication, and makes the code for compressed
output (unsurprisingly) suffer from bitrot.
The code for uncompressed ouput is run twice to count the the total
length for the progress bar. In the first run it just takes a
shortcut and runs only half the loop, and when it's done, it toggles
a boolean, jumps out of the loop with a backwards goto and starts
over. Works, but pretty is something different.
(b) Converting while keeping a backing file (-B option) is broken in
several ways. This includes not writing to the image file if the
input has zero clusters or data filled with zeros (ignoring that the
backing file will be visible instead).
It also doesn't correctly limit every iteration of the copy loop to
sectors of the same status so that too many sectors may be copied to
in the target image. For -B this gives an unexpected result, for
other images it just does more work than necessary.
Conversion with a compressed target completely ignores any target
backing file.
(c) qemu-img convert skips reading and writing an area if it knows from
metadata that copying isn't needed (except for the bug mentioned
above that ignores a status change in some cases). It does, however,
read from the source even if it knows that it will read zeros, and
then search for non-zero bytes in the read buffer, if it's possible
that a write might be needed.
This reimplementation of the copying core reorganises the code to remove
the duplication and have a much more obvious code flow, by essentially
splitting the copy iteration loop into three parts:
1. Find the number of contiguous sectors of the same status at the
current offset (This can also be called in a separate loop before the
copying loop in order to determine the total sectors for the progress
bar.)
2. Read sectors. If the status implies that there is no data there to
read (zero or unallocated cluster), don't do anything.
3. Write sectors depending on the status. If it's data, write it. If
we want the backing file to be visible (with -B), don't write it. If
it's zeroed, skip it if you can, otherwise use bdrv_write_zeroes() to
optimise the write at least where possible.
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
2015-03-19 12:33:32 +00:00
|
|
|
int c, bs_n, bs_i, compress, cluster_sectors, skip_create;
|
2013-11-27 10:07:01 +00:00
|
|
|
int64_t ret = 0;
|
2014-07-22 20:58:42 +00:00
|
|
|
int progress = 0, flags, src_flags;
|
|
|
|
const char *fmt, *out_fmt, *cache, *src_cache, *out_baseimg, *out_filename;
|
2010-05-26 02:35:36 +00:00
|
|
|
BlockDriver *drv, *proto_drv;
|
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 11:59:04 +00:00
|
|
|
BlockBackend **blk = NULL, *out_blk = NULL;
|
2010-06-20 19:26:35 +00:00
|
|
|
BlockDriverState **bs = NULL, *out_bs = NULL;
|
qemu-img convert: Rewrite copying logic
The implementation of qemu-img convert is (a) messy, (b) buggy, and
(c) less efficient than possible. The changes required to beat some
sense into it are massive enough that incremental changes would only
make my and the reviewers' life harder. So throw it away and reimplement
it from scratch.
Let me give some examples what I mean by messy, buggy and inefficient:
(a) The copying logic of qemu-img convert has two separate branches for
compressed and normal target images, which roughly do the same -
except for a little code that handles actual differences between
compressed and uncompressed images, and much more code that
implements just a different set of optimisations and bugs. This is
unnecessary code duplication, and makes the code for compressed
output (unsurprisingly) suffer from bitrot.
The code for uncompressed ouput is run twice to count the the total
length for the progress bar. In the first run it just takes a
shortcut and runs only half the loop, and when it's done, it toggles
a boolean, jumps out of the loop with a backwards goto and starts
over. Works, but pretty is something different.
(b) Converting while keeping a backing file (-B option) is broken in
several ways. This includes not writing to the image file if the
input has zero clusters or data filled with zeros (ignoring that the
backing file will be visible instead).
It also doesn't correctly limit every iteration of the copy loop to
sectors of the same status so that too many sectors may be copied to
in the target image. For -B this gives an unexpected result, for
other images it just does more work than necessary.
Conversion with a compressed target completely ignores any target
backing file.
(c) qemu-img convert skips reading and writing an area if it knows from
metadata that copying isn't needed (except for the bug mentioned
above that ignores a status change in some cases). It does, however,
read from the source even if it knows that it will read zeros, and
then search for non-zero bytes in the read buffer, if it's possible
that a write might be needed.
This reimplementation of the copying core reorganises the code to remove
the duplication and have a much more obvious code flow, by essentially
splitting the copy iteration loop into three parts:
1. Find the number of contiguous sectors of the same status at the
current offset (This can also be called in a separate loop before the
copying loop in order to determine the total sectors for the progress
bar.)
2. Read sectors. If the status implies that there is no data there to
read (zero or unallocated cluster), don't do anything.
3. Write sectors depending on the status. If it's data, write it. If
we want the backing file to be visible (with -B), don't write it. If
it's zeroed, skip it if you can, otherwise use bdrv_write_zeroes() to
optimise the write at least where possible.
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
2015-03-19 12:33:32 +00:00
|
|
|
int64_t total_sectors;
|
2014-06-26 11:23:25 +00:00
|
|
|
int64_t *bs_sectors = NULL;
|
2013-11-27 10:07:06 +00:00
|
|
|
size_t bufsectors = IO_BUF_SIZE / BDRV_SECTOR_SIZE;
|
2006-08-05 21:31:00 +00:00
|
|
|
BlockDriverInfo bdi;
|
2014-06-05 09:20:51 +00:00
|
|
|
QemuOpts *opts = NULL;
|
|
|
|
QemuOptsList *create_opts = NULL;
|
|
|
|
const char *out_baseimg_param;
|
2009-05-18 14:42:12 +00:00
|
|
|
char *options = NULL;
|
2010-09-22 02:58:41 +00:00
|
|
|
const char *snapshot_name = NULL;
|
2011-08-26 13:27:13 +00:00
|
|
|
int min_sparse = 8; /* Need at least 4k of zeros for sparse detection */
|
2013-02-13 08:09:40 +00:00
|
|
|
bool quiet = false;
|
2013-09-06 15:14:26 +00:00
|
|
|
Error *local_err = NULL;
|
2013-12-04 09:10:57 +00:00
|
|
|
QemuOpts *sn_opts = NULL;
|
qemu-img convert: Rewrite copying logic
The implementation of qemu-img convert is (a) messy, (b) buggy, and
(c) less efficient than possible. The changes required to beat some
sense into it are massive enough that incremental changes would only
make my and the reviewers' life harder. So throw it away and reimplement
it from scratch.
Let me give some examples what I mean by messy, buggy and inefficient:
(a) The copying logic of qemu-img convert has two separate branches for
compressed and normal target images, which roughly do the same -
except for a little code that handles actual differences between
compressed and uncompressed images, and much more code that
implements just a different set of optimisations and bugs. This is
unnecessary code duplication, and makes the code for compressed
output (unsurprisingly) suffer from bitrot.
The code for uncompressed ouput is run twice to count the the total
length for the progress bar. In the first run it just takes a
shortcut and runs only half the loop, and when it's done, it toggles
a boolean, jumps out of the loop with a backwards goto and starts
over. Works, but pretty is something different.
(b) Converting while keeping a backing file (-B option) is broken in
several ways. This includes not writing to the image file if the
input has zero clusters or data filled with zeros (ignoring that the
backing file will be visible instead).
It also doesn't correctly limit every iteration of the copy loop to
sectors of the same status so that too many sectors may be copied to
in the target image. For -B this gives an unexpected result, for
other images it just does more work than necessary.
Conversion with a compressed target completely ignores any target
backing file.
(c) qemu-img convert skips reading and writing an area if it knows from
metadata that copying isn't needed (except for the bug mentioned
above that ignores a status change in some cases). It does, however,
read from the source even if it knows that it will read zeros, and
then search for non-zero bytes in the read buffer, if it's possible
that a write might be needed.
This reimplementation of the copying core reorganises the code to remove
the duplication and have a much more obvious code flow, by essentially
splitting the copy iteration loop into three parts:
1. Find the number of contiguous sectors of the same status at the
current offset (This can also be called in a separate loop before the
copying loop in order to determine the total sectors for the progress
bar.)
2. Read sectors. If the status implies that there is no data there to
read (zero or unallocated cluster), don't do anything.
3. Write sectors depending on the status. If it's data, write it. If
we want the backing file to be visible (with -B), don't write it. If
it's zeroed, skip it if you can, otherwise use bdrv_write_zeroes() to
optimise the write at least where possible.
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
2015-03-19 12:33:32 +00:00
|
|
|
ImgConvertState state;
|
2004-08-01 21:59:26 +00:00
|
|
|
|
|
|
|
fmt = NULL;
|
|
|
|
out_fmt = "raw";
|
2011-06-20 16:48:19 +00:00
|
|
|
cache = "unsafe";
|
2014-07-22 20:58:42 +00:00
|
|
|
src_cache = BDRV_DEFAULT_CACHE;
|
2008-06-05 21:53:49 +00:00
|
|
|
out_baseimg = NULL;
|
2010-12-07 16:44:34 +00:00
|
|
|
compress = 0;
|
2013-09-02 18:07:24 +00:00
|
|
|
skip_create = 0;
|
2004-08-01 21:59:26 +00:00
|
|
|
for(;;) {
|
2014-07-22 20:58:42 +00:00
|
|
|
c = getopt(argc, argv, "hf:O:B:ce6o:s:l:S:pt:T:qn");
|
2010-12-06 14:25:39 +00:00
|
|
|
if (c == -1) {
|
2004-08-01 21:59:26 +00:00
|
|
|
break;
|
2010-12-06 14:25:39 +00:00
|
|
|
}
|
2004-08-01 21:59:26 +00:00
|
|
|
switch(c) {
|
2010-12-06 14:25:40 +00:00
|
|
|
case '?':
|
2004-08-01 21:59:26 +00:00
|
|
|
case 'h':
|
|
|
|
help();
|
|
|
|
break;
|
|
|
|
case 'f':
|
|
|
|
fmt = optarg;
|
|
|
|
break;
|
|
|
|
case 'O':
|
|
|
|
out_fmt = optarg;
|
|
|
|
break;
|
2008-06-05 21:53:49 +00:00
|
|
|
case 'B':
|
|
|
|
out_baseimg = optarg;
|
|
|
|
break;
|
2004-08-01 21:59:26 +00:00
|
|
|
case 'c':
|
2010-12-07 16:44:34 +00:00
|
|
|
compress = 1;
|
2004-08-01 21:59:26 +00:00
|
|
|
break;
|
|
|
|
case 'e':
|
2011-06-22 12:03:55 +00:00
|
|
|
error_report("option -e is deprecated, please use \'-o "
|
2010-12-07 16:44:34 +00:00
|
|
|
"encryption\' instead!");
|
2014-02-21 15:24:05 +00:00
|
|
|
ret = -1;
|
2014-03-03 13:54:07 +00:00
|
|
|
goto fail_getopt;
|
2007-09-16 21:59:02 +00:00
|
|
|
case '6':
|
2011-06-22 12:03:55 +00:00
|
|
|
error_report("option -6 is deprecated, please use \'-o "
|
2010-12-07 16:44:34 +00:00
|
|
|
"compat6\' instead!");
|
2014-02-21 15:24:05 +00:00
|
|
|
ret = -1;
|
2014-03-03 13:54:07 +00:00
|
|
|
goto fail_getopt;
|
2009-05-18 14:42:12 +00:00
|
|
|
case 'o':
|
2014-02-21 15:24:05 +00:00
|
|
|
if (!is_valid_option_list(optarg)) {
|
|
|
|
error_report("Invalid option list: %s", optarg);
|
|
|
|
ret = -1;
|
2014-03-03 13:54:07 +00:00
|
|
|
goto fail_getopt;
|
2014-02-21 15:24:05 +00:00
|
|
|
}
|
|
|
|
if (!options) {
|
|
|
|
options = g_strdup(optarg);
|
|
|
|
} else {
|
|
|
|
char *old_options = options;
|
|
|
|
options = g_strdup_printf("%s,%s", options, optarg);
|
|
|
|
g_free(old_options);
|
|
|
|
}
|
2009-05-18 14:42:12 +00:00
|
|
|
break;
|
2010-09-22 02:58:41 +00:00
|
|
|
case 's':
|
|
|
|
snapshot_name = optarg;
|
|
|
|
break;
|
2013-12-04 09:10:57 +00:00
|
|
|
case 'l':
|
|
|
|
if (strstart(optarg, SNAPSHOT_OPT_BASE, NULL)) {
|
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 11:50:26 +00:00
|
|
|
sn_opts = qemu_opts_parse_noisily(&internal_snapshot_opts,
|
|
|
|
optarg, false);
|
2013-12-04 09:10:57 +00:00
|
|
|
if (!sn_opts) {
|
|
|
|
error_report("Failed in parsing snapshot param '%s'",
|
|
|
|
optarg);
|
2014-02-21 15:24:05 +00:00
|
|
|
ret = -1;
|
2014-03-03 13:54:07 +00:00
|
|
|
goto fail_getopt;
|
2013-12-04 09:10:57 +00:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
snapshot_name = optarg;
|
|
|
|
}
|
|
|
|
break;
|
2011-08-26 13:27:13 +00:00
|
|
|
case 'S':
|
|
|
|
{
|
|
|
|
int64_t sval;
|
2011-11-22 08:46:05 +00:00
|
|
|
char *end;
|
2015-09-16 16:02:56 +00:00
|
|
|
sval = qemu_strtosz_suffix(optarg, &end, QEMU_STRTOSZ_DEFSUFFIX_B);
|
2011-11-22 08:46:05 +00:00
|
|
|
if (sval < 0 || *end) {
|
2011-08-26 13:27:13 +00:00
|
|
|
error_report("Invalid minimum zero buffer size for sparse output specified");
|
2014-02-21 15:24:05 +00:00
|
|
|
ret = -1;
|
2014-03-03 13:54:07 +00:00
|
|
|
goto fail_getopt;
|
2011-08-26 13:27:13 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
min_sparse = sval / BDRV_SECTOR_SIZE;
|
|
|
|
break;
|
|
|
|
}
|
2011-03-30 12:16:25 +00:00
|
|
|
case 'p':
|
|
|
|
progress = 1;
|
|
|
|
break;
|
2011-06-20 16:48:19 +00:00
|
|
|
case 't':
|
|
|
|
cache = optarg;
|
|
|
|
break;
|
2014-07-22 20:58:42 +00:00
|
|
|
case 'T':
|
|
|
|
src_cache = optarg;
|
|
|
|
break;
|
2013-02-13 08:09:40 +00:00
|
|
|
case 'q':
|
|
|
|
quiet = true;
|
|
|
|
break;
|
2013-09-02 18:07:24 +00:00
|
|
|
case 'n':
|
|
|
|
skip_create = 1;
|
|
|
|
break;
|
2004-08-01 21:59:26 +00:00
|
|
|
}
|
|
|
|
}
|
2007-09-17 08:09:54 +00:00
|
|
|
|
2014-03-03 13:54:07 +00:00
|
|
|
/* Initialize before goto out */
|
2013-02-13 08:09:40 +00:00
|
|
|
if (quiet) {
|
|
|
|
progress = 0;
|
|
|
|
}
|
2014-03-03 13:54:07 +00:00
|
|
|
qemu_progress_init(progress, 1.0);
|
|
|
|
|
2013-02-13 08:09:40 +00:00
|
|
|
|
2007-10-31 01:11:44 +00:00
|
|
|
bs_n = argc - optind - 1;
|
2014-02-21 15:24:07 +00:00
|
|
|
out_filename = bs_n >= 1 ? argv[argc - 1] : NULL;
|
2008-06-05 21:53:49 +00:00
|
|
|
|
2014-02-21 15:24:05 +00:00
|
|
|
if (options && has_help_option(options)) {
|
2010-12-06 14:25:38 +00:00
|
|
|
ret = print_block_option_help(out_filename, out_fmt);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2014-02-21 15:24:07 +00:00
|
|
|
if (bs_n < 1) {
|
2014-04-22 05:36:11 +00:00
|
|
|
error_exit("Must specify image file name");
|
2014-02-21 15:24:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-06-20 19:26:35 +00:00
|
|
|
if (bs_n > 1 && out_baseimg) {
|
2010-12-16 13:31:53 +00:00
|
|
|
error_report("-B makes no sense when concatenating multiple input "
|
|
|
|
"images");
|
2010-12-06 14:25:36 +00:00
|
|
|
ret = -1;
|
|
|
|
goto out;
|
2010-06-20 19:26:35 +00:00
|
|
|
}
|
2012-03-15 12:13:31 +00:00
|
|
|
|
2014-07-22 20:58:42 +00:00
|
|
|
src_flags = BDRV_O_FLAGS;
|
|
|
|
ret = bdrv_parse_cache_flags(src_cache, &src_flags);
|
|
|
|
if (ret < 0) {
|
|
|
|
error_report("Invalid source cache option: %s", src_cache);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2011-03-30 12:16:25 +00:00
|
|
|
qemu_progress_print(0, 100);
|
|
|
|
|
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 11:59:04 +00:00
|
|
|
blk = g_new0(BlockBackend *, bs_n);
|
2014-06-26 11:23:24 +00:00
|
|
|
bs = g_new0(BlockDriverState *, bs_n);
|
2014-06-26 11:23:25 +00:00
|
|
|
bs_sectors = g_new(int64_t, bs_n);
|
2007-10-31 01:11:44 +00:00
|
|
|
|
|
|
|
total_sectors = 0;
|
|
|
|
for (bs_i = 0; bs_i < bs_n; bs_i++) {
|
2014-09-25 07:54:02 +00:00
|
|
|
char *id = bs_n > 1 ? g_strdup_printf("source_%d", bs_i)
|
2014-04-17 14:57:13 +00:00
|
|
|
: g_strdup("source");
|
2014-10-07 11:59:05 +00:00
|
|
|
blk[bs_i] = img_open(id, argv[optind + bs_i], fmt, src_flags,
|
|
|
|
true, quiet);
|
2014-04-17 14:57:13 +00:00
|
|
|
g_free(id);
|
2014-10-07 11:59:05 +00:00
|
|
|
if (!blk[bs_i]) {
|
2010-06-20 19:26:35 +00:00
|
|
|
ret = -1;
|
|
|
|
goto out;
|
|
|
|
}
|
2014-10-07 11:59:05 +00:00
|
|
|
bs[bs_i] = blk_bs(blk[bs_i]);
|
2015-02-05 18:58:18 +00:00
|
|
|
bs_sectors[bs_i] = blk_nb_sectors(blk[bs_i]);
|
2014-06-26 11:23:25 +00:00
|
|
|
if (bs_sectors[bs_i] < 0) {
|
|
|
|
error_report("Could not get size of %s: %s",
|
|
|
|
argv[optind + bs_i], strerror(-bs_sectors[bs_i]));
|
|
|
|
ret = -1;
|
|
|
|
goto out;
|
|
|
|
}
|
2014-06-26 11:23:24 +00:00
|
|
|
total_sectors += bs_sectors[bs_i];
|
2007-10-31 01:11:44 +00:00
|
|
|
}
|
2004-08-01 21:59:26 +00:00
|
|
|
|
2013-12-04 09:10:57 +00:00
|
|
|
if (sn_opts) {
|
|
|
|
ret = bdrv_snapshot_load_tmp(bs[0],
|
|
|
|
qemu_opt_get(sn_opts, SNAPSHOT_OPT_ID),
|
|
|
|
qemu_opt_get(sn_opts, SNAPSHOT_OPT_NAME),
|
|
|
|
&local_err);
|
|
|
|
} else if (snapshot_name != NULL) {
|
2010-09-22 02:58:41 +00:00
|
|
|
if (bs_n > 1) {
|
2011-06-22 12:03:54 +00:00
|
|
|
error_report("No support for concatenating multiple snapshot");
|
2010-09-22 02:58:41 +00:00
|
|
|
ret = -1;
|
|
|
|
goto out;
|
|
|
|
}
|
2013-12-04 09:10:54 +00:00
|
|
|
|
|
|
|
bdrv_snapshot_load_tmp_by_id_or_name(bs[0], snapshot_name, &local_err);
|
2013-12-04 09:10:57 +00:00
|
|
|
}
|
2014-01-30 14:07:28 +00:00
|
|
|
if (local_err) {
|
2013-12-04 09:10:57 +00:00
|
|
|
error_report("Failed to load snapshot: %s",
|
|
|
|
error_get_pretty(local_err));
|
|
|
|
error_free(local_err);
|
|
|
|
ret = -1;
|
|
|
|
goto out;
|
2010-09-22 02:58:41 +00:00
|
|
|
}
|
|
|
|
|
2009-05-18 14:42:12 +00:00
|
|
|
/* Find driver and parse its options */
|
2004-08-01 21:59:26 +00:00
|
|
|
drv = bdrv_find_format(out_fmt);
|
2010-06-20 19:26:35 +00:00
|
|
|
if (!drv) {
|
2010-12-16 13:31:53 +00:00
|
|
|
error_report("Unknown file format '%s'", out_fmt);
|
2010-06-20 19:26:35 +00:00
|
|
|
ret = -1;
|
|
|
|
goto out;
|
|
|
|
}
|
2009-05-18 14:42:12 +00:00
|
|
|
|
2015-02-05 18:58:12 +00:00
|
|
|
proto_drv = bdrv_find_protocol(out_filename, true, &local_err);
|
2010-06-20 19:26:35 +00:00
|
|
|
if (!proto_drv) {
|
2015-03-12 15:08:02 +00:00
|
|
|
error_report_err(local_err);
|
2010-06-20 19:26:35 +00:00
|
|
|
ret = -1;
|
|
|
|
goto out;
|
|
|
|
}
|
2010-05-26 02:35:36 +00:00
|
|
|
|
2015-02-11 14:58:46 +00:00
|
|
|
if (!skip_create) {
|
|
|
|
if (!drv->create_opts) {
|
|
|
|
error_report("Format driver '%s' does not support image creation",
|
|
|
|
drv->format_name);
|
|
|
|
ret = -1;
|
|
|
|
goto out;
|
|
|
|
}
|
2014-12-02 17:32:46 +00:00
|
|
|
|
2015-02-11 14:58:46 +00:00
|
|
|
if (!proto_drv->create_opts) {
|
|
|
|
error_report("Protocol driver '%s' does not support image creation",
|
|
|
|
proto_drv->format_name);
|
|
|
|
ret = -1;
|
|
|
|
goto out;
|
|
|
|
}
|
2014-12-02 17:32:46 +00:00
|
|
|
|
2015-02-11 14:58:46 +00:00
|
|
|
create_opts = qemu_opts_append(create_opts, drv->create_opts);
|
|
|
|
create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
|
2009-06-04 13:39:38 +00:00
|
|
|
|
2015-02-11 14:58:46 +00:00
|
|
|
opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
|
2015-02-12 17:37:11 +00:00
|
|
|
if (options) {
|
|
|
|
qemu_opts_do_parse(opts, options, NULL, &local_err);
|
|
|
|
if (local_err) {
|
2015-03-14 09:23:15 +00:00
|
|
|
error_report_err(local_err);
|
2015-02-12 17:37:11 +00:00
|
|
|
ret = -1;
|
|
|
|
goto out;
|
|
|
|
}
|
2015-02-11 14:58:46 +00:00
|
|
|
}
|
2009-05-18 14:42:12 +00:00
|
|
|
|
2015-02-12 15:46:36 +00:00
|
|
|
qemu_opt_set_number(opts, BLOCK_OPT_SIZE, total_sectors * 512,
|
|
|
|
&error_abort);
|
2015-02-11 14:58:46 +00:00
|
|
|
ret = add_old_style_options(out_fmt, opts, out_baseimg, NULL);
|
|
|
|
if (ret < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
2010-06-20 19:26:35 +00:00
|
|
|
}
|
2009-05-18 14:42:12 +00:00
|
|
|
|
2010-10-14 13:46:04 +00:00
|
|
|
/* Get backing file name if -o backing_file was used */
|
2014-06-05 09:20:51 +00:00
|
|
|
out_baseimg_param = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
|
2010-10-14 13:46:04 +00:00
|
|
|
if (out_baseimg_param) {
|
2014-06-05 09:20:51 +00:00
|
|
|
out_baseimg = out_baseimg_param;
|
2010-10-14 13:46:04 +00:00
|
|
|
}
|
|
|
|
|
2009-05-18 14:42:12 +00:00
|
|
|
/* Check if compression is supported */
|
2010-12-07 16:44:34 +00:00
|
|
|
if (compress) {
|
2014-06-05 09:20:51 +00:00
|
|
|
bool encryption =
|
|
|
|
qemu_opt_get_bool(opts, BLOCK_OPT_ENCRYPT, false);
|
|
|
|
const char *preallocation =
|
|
|
|
qemu_opt_get(opts, BLOCK_OPT_PREALLOC);
|
2009-05-18 14:42:12 +00:00
|
|
|
|
|
|
|
if (!drv->bdrv_write_compressed) {
|
2010-12-16 13:31:53 +00:00
|
|
|
error_report("Compression not supported for this file format");
|
2010-06-20 19:26:35 +00:00
|
|
|
ret = -1;
|
|
|
|
goto out;
|
2009-05-18 14:42:12 +00:00
|
|
|
}
|
|
|
|
|
2014-06-05 09:20:51 +00:00
|
|
|
if (encryption) {
|
2010-12-16 13:31:53 +00:00
|
|
|
error_report("Compression and encryption not supported at "
|
|
|
|
"the same time");
|
2010-06-20 19:26:35 +00:00
|
|
|
ret = -1;
|
|
|
|
goto out;
|
2009-05-18 14:42:12 +00:00
|
|
|
}
|
2011-10-18 14:19:42 +00:00
|
|
|
|
2014-06-05 09:20:51 +00:00
|
|
|
if (preallocation
|
|
|
|
&& strcmp(preallocation, "off"))
|
2011-10-18 14:19:42 +00:00
|
|
|
{
|
|
|
|
error_report("Compression and preallocation not supported at "
|
|
|
|
"the same time");
|
|
|
|
ret = -1;
|
|
|
|
goto out;
|
|
|
|
}
|
2009-05-18 14:42:12 +00:00
|
|
|
}
|
|
|
|
|
2013-09-02 18:07:24 +00:00
|
|
|
if (!skip_create) {
|
|
|
|
/* Create the new image */
|
2014-06-05 09:21:11 +00:00
|
|
|
ret = bdrv_create(drv, out_filename, opts, &local_err);
|
2013-09-02 18:07:24 +00:00
|
|
|
if (ret < 0) {
|
2013-09-06 15:14:26 +00:00
|
|
|
error_report("%s: error while converting %s: %s",
|
|
|
|
out_filename, out_fmt, error_get_pretty(local_err));
|
|
|
|
error_free(local_err);
|
2013-09-02 18:07:24 +00:00
|
|
|
goto out;
|
2004-08-01 21:59:26 +00:00
|
|
|
}
|
|
|
|
}
|
2007-09-17 08:09:54 +00:00
|
|
|
|
2013-10-24 10:07:06 +00:00
|
|
|
flags = min_sparse ? (BDRV_O_RDWR | BDRV_O_UNMAP) : BDRV_O_RDWR;
|
2011-08-04 11:26:51 +00:00
|
|
|
ret = bdrv_parse_cache_flags(cache, &flags);
|
2011-06-20 16:48:19 +00:00
|
|
|
if (ret < 0) {
|
|
|
|
error_report("Invalid cache option: %s", cache);
|
2014-05-28 09:17:07 +00:00
|
|
|
goto out;
|
2011-06-20 16:48:19 +00:00
|
|
|
}
|
|
|
|
|
2014-10-07 11:59:05 +00:00
|
|
|
out_blk = img_open("target", out_filename, out_fmt, flags, true, quiet);
|
|
|
|
if (!out_blk) {
|
2010-06-20 19:26:35 +00:00
|
|
|
ret = -1;
|
|
|
|
goto out;
|
|
|
|
}
|
2014-10-07 11:59:05 +00:00
|
|
|
out_bs = blk_bs(out_blk);
|
2004-08-01 21:59:26 +00:00
|
|
|
|
2013-11-27 10:07:06 +00:00
|
|
|
/* increase bufsectors from the default 4096 (2M) if opt_transfer_length
|
|
|
|
* or discard_alignment of the out_bs is greater. Limit to 32768 (16MB)
|
|
|
|
* as maximum. */
|
|
|
|
bufsectors = MIN(32768,
|
|
|
|
MAX(bufsectors, MAX(out_bs->bl.opt_transfer_length,
|
|
|
|
out_bs->bl.discard_alignment))
|
|
|
|
);
|
|
|
|
|
2013-09-02 18:07:24 +00:00
|
|
|
if (skip_create) {
|
2015-02-05 18:58:18 +00:00
|
|
|
int64_t output_sectors = blk_nb_sectors(out_blk);
|
2014-06-26 11:23:21 +00:00
|
|
|
if (output_sectors < 0) {
|
2015-02-25 04:22:27 +00:00
|
|
|
error_report("unable to get output image length: %s",
|
2014-06-26 11:23:21 +00:00
|
|
|
strerror(-output_sectors));
|
2013-09-02 18:07:24 +00:00
|
|
|
ret = -1;
|
|
|
|
goto out;
|
2014-06-26 11:23:21 +00:00
|
|
|
} else if (output_sectors < total_sectors) {
|
2013-09-02 18:07:24 +00:00
|
|
|
error_report("output file is smaller than input file");
|
|
|
|
ret = -1;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-11-27 10:07:07 +00:00
|
|
|
cluster_sectors = 0;
|
|
|
|
ret = bdrv_get_info(out_bs, &bdi);
|
|
|
|
if (ret < 0) {
|
|
|
|
if (compress) {
|
2010-12-16 13:31:53 +00:00
|
|
|
error_report("could not get block driver info");
|
2010-06-20 19:26:35 +00:00
|
|
|
goto out;
|
|
|
|
}
|
2013-11-27 10:07:07 +00:00
|
|
|
} else {
|
2014-05-06 13:08:43 +00:00
|
|
|
compress = compress || bdi.needs_compressed_writes;
|
2013-11-27 10:07:07 +00:00
|
|
|
cluster_sectors = bdi.cluster_size / BDRV_SECTOR_SIZE;
|
|
|
|
}
|
|
|
|
|
qemu-img convert: Rewrite copying logic
The implementation of qemu-img convert is (a) messy, (b) buggy, and
(c) less efficient than possible. The changes required to beat some
sense into it are massive enough that incremental changes would only
make my and the reviewers' life harder. So throw it away and reimplement
it from scratch.
Let me give some examples what I mean by messy, buggy and inefficient:
(a) The copying logic of qemu-img convert has two separate branches for
compressed and normal target images, which roughly do the same -
except for a little code that handles actual differences between
compressed and uncompressed images, and much more code that
implements just a different set of optimisations and bugs. This is
unnecessary code duplication, and makes the code for compressed
output (unsurprisingly) suffer from bitrot.
The code for uncompressed ouput is run twice to count the the total
length for the progress bar. In the first run it just takes a
shortcut and runs only half the loop, and when it's done, it toggles
a boolean, jumps out of the loop with a backwards goto and starts
over. Works, but pretty is something different.
(b) Converting while keeping a backing file (-B option) is broken in
several ways. This includes not writing to the image file if the
input has zero clusters or data filled with zeros (ignoring that the
backing file will be visible instead).
It also doesn't correctly limit every iteration of the copy loop to
sectors of the same status so that too many sectors may be copied to
in the target image. For -B this gives an unexpected result, for
other images it just does more work than necessary.
Conversion with a compressed target completely ignores any target
backing file.
(c) qemu-img convert skips reading and writing an area if it knows from
metadata that copying isn't needed (except for the bug mentioned
above that ignores a status change in some cases). It does, however,
read from the source even if it knows that it will read zeros, and
then search for non-zero bytes in the read buffer, if it's possible
that a write might be needed.
This reimplementation of the copying core reorganises the code to remove
the duplication and have a much more obvious code flow, by essentially
splitting the copy iteration loop into three parts:
1. Find the number of contiguous sectors of the same status at the
current offset (This can also be called in a separate loop before the
copying loop in order to determine the total sectors for the progress
bar.)
2. Read sectors. If the status implies that there is no data there to
read (zero or unallocated cluster), don't do anything.
3. Write sectors depending on the status. If it's data, write it. If
we want the backing file to be visible (with -B), don't write it. If
it's zeroed, skip it if you can, otherwise use bdrv_write_zeroes() to
optimise the write at least where possible.
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
2015-03-19 12:33:32 +00:00
|
|
|
state = (ImgConvertState) {
|
|
|
|
.src = blk,
|
|
|
|
.src_sectors = bs_sectors,
|
|
|
|
.src_num = bs_n,
|
|
|
|
.total_sectors = total_sectors,
|
|
|
|
.target = out_blk,
|
|
|
|
.compressed = compress,
|
|
|
|
.target_has_backing = (bool) out_baseimg,
|
|
|
|
.min_sparse = min_sparse,
|
|
|
|
.cluster_sectors = cluster_sectors,
|
|
|
|
.buf_sectors = bufsectors,
|
|
|
|
};
|
|
|
|
ret = convert_do_copy(&state);
|
2013-12-05 14:54:53 +00:00
|
|
|
|
2010-06-20 19:26:35 +00:00
|
|
|
out:
|
2013-11-27 10:07:01 +00:00
|
|
|
if (!ret) {
|
|
|
|
qemu_progress_print(100, 0);
|
|
|
|
}
|
2011-03-30 12:16:25 +00:00
|
|
|
qemu_progress_end();
|
2014-06-05 09:20:51 +00:00
|
|
|
qemu_opts_del(opts);
|
|
|
|
qemu_opts_free(create_opts);
|
2014-09-29 14:07:55 +00:00
|
|
|
qemu_opts_del(sn_opts);
|
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 11:59:04 +00:00
|
|
|
blk_unref(out_blk);
|
2014-10-07 11:59:08 +00:00
|
|
|
g_free(bs);
|
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 11:59:04 +00:00
|
|
|
if (blk) {
|
|
|
|
for (bs_i = 0; bs_i < bs_n; bs_i++) {
|
|
|
|
blk_unref(blk[bs_i]);
|
|
|
|
}
|
|
|
|
g_free(blk);
|
|
|
|
}
|
2014-06-26 11:23:24 +00:00
|
|
|
g_free(bs_sectors);
|
2014-03-03 13:54:07 +00:00
|
|
|
fail_getopt:
|
|
|
|
g_free(options);
|
|
|
|
|
2010-06-20 19:26:35 +00:00
|
|
|
if (ret) {
|
|
|
|
return 1;
|
|
|
|
}
|
2004-08-01 21:59:26 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2004-08-03 21:15:11 +00:00
|
|
|
|
2006-08-05 21:31:00 +00:00
|
|
|
static void dump_snapshots(BlockDriverState *bs)
|
|
|
|
{
|
|
|
|
QEMUSnapshotInfo *sn_tab, *sn;
|
|
|
|
int nb_sns, i;
|
|
|
|
|
|
|
|
nb_sns = bdrv_snapshot_list(bs, &sn_tab);
|
|
|
|
if (nb_sns <= 0)
|
|
|
|
return;
|
|
|
|
printf("Snapshot list:\n");
|
2013-05-25 03:09:45 +00:00
|
|
|
bdrv_snapshot_dump(fprintf, stdout, NULL);
|
|
|
|
printf("\n");
|
2006-08-05 21:31:00 +00:00
|
|
|
for(i = 0; i < nb_sns; i++) {
|
|
|
|
sn = &sn_tab[i];
|
2013-05-25 03:09:45 +00:00
|
|
|
bdrv_snapshot_dump(fprintf, stdout, sn);
|
|
|
|
printf("\n");
|
2006-08-05 21:31:00 +00:00
|
|
|
}
|
2011-08-21 03:09:37 +00:00
|
|
|
g_free(sn_tab);
|
2006-08-05 21:31:00 +00:00
|
|
|
}
|
|
|
|
|
2012-10-17 12:02:31 +00:00
|
|
|
static void dump_json_image_info_list(ImageInfoList *list)
|
|
|
|
{
|
2014-04-25 14:50:32 +00:00
|
|
|
Error *local_err = NULL;
|
2012-10-17 12:02:31 +00:00
|
|
|
QString *str;
|
|
|
|
QmpOutputVisitor *ov = qmp_output_visitor_new();
|
|
|
|
QObject *obj;
|
|
|
|
visit_type_ImageInfoList(qmp_output_get_visitor(ov),
|
2014-04-25 14:50:32 +00:00
|
|
|
&list, NULL, &local_err);
|
2012-10-17 12:02:31 +00:00
|
|
|
obj = qmp_output_get_qobject(ov);
|
|
|
|
str = qobject_to_json_pretty(obj);
|
|
|
|
assert(str != NULL);
|
|
|
|
printf("%s\n", qstring_get_str(str));
|
|
|
|
qobject_decref(obj);
|
|
|
|
qmp_output_visitor_cleanup(ov);
|
|
|
|
QDECREF(str);
|
|
|
|
}
|
|
|
|
|
qemu-img: Add json output option to the info command.
This option --output=[human|json] make qemu-img info output on
human or JSON representation at the choice of the user.
example:
{
"snapshots": [
{
"vm-clock-nsec": 637102488,
"name": "vm-20120821145509",
"date-sec": 1345553709,
"date-nsec": 220289000,
"vm-clock-sec": 20,
"id": "1",
"vm-state-size": 96522745
},
{
"vm-clock-nsec": 28210866,
"name": "vm-20120821154059",
"date-sec": 1345556459,
"date-nsec": 171392000,
"vm-clock-sec": 46,
"id": "2",
"vm-state-size": 101208714
}
],
"virtual-size": 1073741824,
"filename": "snap.qcow2",
"cluster-size": 65536,
"format": "qcow2",
"actual-size": 985587712,
"dirty-flag": false
}
Signed-off-by: Benoit Canet <benoit@irqsave.net>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2012-09-05 11:09:02 +00:00
|
|
|
static void dump_json_image_info(ImageInfo *info)
|
|
|
|
{
|
2014-04-25 14:50:32 +00:00
|
|
|
Error *local_err = NULL;
|
qemu-img: Add json output option to the info command.
This option --output=[human|json] make qemu-img info output on
human or JSON representation at the choice of the user.
example:
{
"snapshots": [
{
"vm-clock-nsec": 637102488,
"name": "vm-20120821145509",
"date-sec": 1345553709,
"date-nsec": 220289000,
"vm-clock-sec": 20,
"id": "1",
"vm-state-size": 96522745
},
{
"vm-clock-nsec": 28210866,
"name": "vm-20120821154059",
"date-sec": 1345556459,
"date-nsec": 171392000,
"vm-clock-sec": 46,
"id": "2",
"vm-state-size": 101208714
}
],
"virtual-size": 1073741824,
"filename": "snap.qcow2",
"cluster-size": 65536,
"format": "qcow2",
"actual-size": 985587712,
"dirty-flag": false
}
Signed-off-by: Benoit Canet <benoit@irqsave.net>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2012-09-05 11:09:02 +00:00
|
|
|
QString *str;
|
|
|
|
QmpOutputVisitor *ov = qmp_output_visitor_new();
|
|
|
|
QObject *obj;
|
|
|
|
visit_type_ImageInfo(qmp_output_get_visitor(ov),
|
2014-04-25 14:50:32 +00:00
|
|
|
&info, NULL, &local_err);
|
qemu-img: Add json output option to the info command.
This option --output=[human|json] make qemu-img info output on
human or JSON representation at the choice of the user.
example:
{
"snapshots": [
{
"vm-clock-nsec": 637102488,
"name": "vm-20120821145509",
"date-sec": 1345553709,
"date-nsec": 220289000,
"vm-clock-sec": 20,
"id": "1",
"vm-state-size": 96522745
},
{
"vm-clock-nsec": 28210866,
"name": "vm-20120821154059",
"date-sec": 1345556459,
"date-nsec": 171392000,
"vm-clock-sec": 46,
"id": "2",
"vm-state-size": 101208714
}
],
"virtual-size": 1073741824,
"filename": "snap.qcow2",
"cluster-size": 65536,
"format": "qcow2",
"actual-size": 985587712,
"dirty-flag": false
}
Signed-off-by: Benoit Canet <benoit@irqsave.net>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2012-09-05 11:09:02 +00:00
|
|
|
obj = qmp_output_get_qobject(ov);
|
|
|
|
str = qobject_to_json_pretty(obj);
|
|
|
|
assert(str != NULL);
|
|
|
|
printf("%s\n", qstring_get_str(str));
|
|
|
|
qobject_decref(obj);
|
|
|
|
qmp_output_visitor_cleanup(ov);
|
|
|
|
QDECREF(str);
|
|
|
|
}
|
|
|
|
|
2012-10-17 12:02:31 +00:00
|
|
|
static void dump_human_image_info_list(ImageInfoList *list)
|
|
|
|
{
|
|
|
|
ImageInfoList *elem;
|
|
|
|
bool delim = false;
|
|
|
|
|
|
|
|
for (elem = list; elem; elem = elem->next) {
|
|
|
|
if (delim) {
|
|
|
|
printf("\n");
|
|
|
|
}
|
|
|
|
delim = true;
|
|
|
|
|
2013-05-25 03:09:45 +00:00
|
|
|
bdrv_image_info_dump(fprintf, stdout, elem->value);
|
2012-10-17 12:02:31 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static gboolean str_equal_func(gconstpointer a, gconstpointer b)
|
|
|
|
{
|
|
|
|
return strcmp(a, b) == 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Open an image file chain and return an ImageInfoList
|
|
|
|
*
|
|
|
|
* @filename: topmost image filename
|
|
|
|
* @fmt: topmost image format (may be NULL to autodetect)
|
|
|
|
* @chain: true - enumerate entire backing file chain
|
|
|
|
* false - only topmost image file
|
|
|
|
*
|
|
|
|
* Returns a list of ImageInfo objects or NULL if there was an error opening an
|
|
|
|
* image file. If there was an error a message will have been printed to
|
|
|
|
* stderr.
|
|
|
|
*/
|
|
|
|
static ImageInfoList *collect_image_info_list(const char *filename,
|
|
|
|
const char *fmt,
|
|
|
|
bool chain)
|
|
|
|
{
|
|
|
|
ImageInfoList *head = NULL;
|
|
|
|
ImageInfoList **last = &head;
|
|
|
|
GHashTable *filenames;
|
2013-06-06 04:27:58 +00:00
|
|
|
Error *err = NULL;
|
2012-10-17 12:02:31 +00:00
|
|
|
|
|
|
|
filenames = g_hash_table_new_full(g_str_hash, str_equal_func, NULL, NULL);
|
|
|
|
|
|
|
|
while (filename) {
|
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 11:59:04 +00:00
|
|
|
BlockBackend *blk;
|
2012-10-17 12:02:31 +00:00
|
|
|
BlockDriverState *bs;
|
|
|
|
ImageInfo *info;
|
|
|
|
ImageInfoList *elem;
|
|
|
|
|
|
|
|
if (g_hash_table_lookup_extended(filenames, filename, NULL, NULL)) {
|
|
|
|
error_report("Backing file '%s' creates an infinite loop.",
|
|
|
|
filename);
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
g_hash_table_insert(filenames, (gpointer)filename, NULL);
|
|
|
|
|
2014-10-07 11:59:05 +00:00
|
|
|
blk = img_open("image", filename, fmt,
|
|
|
|
BDRV_O_FLAGS | BDRV_O_NO_BACKING, false, false);
|
|
|
|
if (!blk) {
|
2012-10-17 12:02:31 +00:00
|
|
|
goto err;
|
|
|
|
}
|
2014-10-07 11:59:05 +00:00
|
|
|
bs = blk_bs(blk);
|
2012-10-17 12:02:31 +00:00
|
|
|
|
2013-06-06 04:27:58 +00:00
|
|
|
bdrv_query_image_info(bs, &info, &err);
|
2014-01-30 14:07:28 +00:00
|
|
|
if (err) {
|
2015-02-12 12:55:05 +00:00
|
|
|
error_report_err(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 11:59:04 +00:00
|
|
|
blk_unref(blk);
|
2013-06-06 04:27:58 +00:00
|
|
|
goto err;
|
2013-06-06 04:27:57 +00:00
|
|
|
}
|
2012-10-17 12:02:31 +00:00
|
|
|
|
|
|
|
elem = g_new0(ImageInfoList, 1);
|
|
|
|
elem->value = info;
|
|
|
|
*last = elem;
|
|
|
|
last = &elem->next;
|
|
|
|
|
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 11:59:04 +00:00
|
|
|
blk_unref(blk);
|
2012-10-17 12:02:31 +00:00
|
|
|
|
|
|
|
filename = fmt = NULL;
|
|
|
|
if (chain) {
|
|
|
|
if (info->has_full_backing_filename) {
|
|
|
|
filename = info->full_backing_filename;
|
|
|
|
} else if (info->has_backing_filename) {
|
|
|
|
filename = info->backing_filename;
|
|
|
|
}
|
|
|
|
if (info->has_backing_filename_format) {
|
|
|
|
fmt = info->backing_filename_format;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
g_hash_table_destroy(filenames);
|
|
|
|
return head;
|
|
|
|
|
|
|
|
err:
|
|
|
|
qapi_free_ImageInfoList(head);
|
|
|
|
g_hash_table_destroy(filenames);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
qemu-img: Add json output option to the info command.
This option --output=[human|json] make qemu-img info output on
human or JSON representation at the choice of the user.
example:
{
"snapshots": [
{
"vm-clock-nsec": 637102488,
"name": "vm-20120821145509",
"date-sec": 1345553709,
"date-nsec": 220289000,
"vm-clock-sec": 20,
"id": "1",
"vm-state-size": 96522745
},
{
"vm-clock-nsec": 28210866,
"name": "vm-20120821154059",
"date-sec": 1345556459,
"date-nsec": 171392000,
"vm-clock-sec": 46,
"id": "2",
"vm-state-size": 101208714
}
],
"virtual-size": 1073741824,
"filename": "snap.qcow2",
"cluster-size": 65536,
"format": "qcow2",
"actual-size": 985587712,
"dirty-flag": false
}
Signed-off-by: Benoit Canet <benoit@irqsave.net>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2012-09-05 11:09:02 +00:00
|
|
|
static int img_info(int argc, char **argv)
|
|
|
|
{
|
|
|
|
int c;
|
|
|
|
OutputFormat output_format = OFORMAT_HUMAN;
|
2012-10-17 12:02:31 +00:00
|
|
|
bool chain = false;
|
qemu-img: Add json output option to the info command.
This option --output=[human|json] make qemu-img info output on
human or JSON representation at the choice of the user.
example:
{
"snapshots": [
{
"vm-clock-nsec": 637102488,
"name": "vm-20120821145509",
"date-sec": 1345553709,
"date-nsec": 220289000,
"vm-clock-sec": 20,
"id": "1",
"vm-state-size": 96522745
},
{
"vm-clock-nsec": 28210866,
"name": "vm-20120821154059",
"date-sec": 1345556459,
"date-nsec": 171392000,
"vm-clock-sec": 46,
"id": "2",
"vm-state-size": 101208714
}
],
"virtual-size": 1073741824,
"filename": "snap.qcow2",
"cluster-size": 65536,
"format": "qcow2",
"actual-size": 985587712,
"dirty-flag": false
}
Signed-off-by: Benoit Canet <benoit@irqsave.net>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2012-09-05 11:09:02 +00:00
|
|
|
const char *filename, *fmt, *output;
|
2012-10-17 12:02:31 +00:00
|
|
|
ImageInfoList *list;
|
qemu-img: Add json output option to the info command.
This option --output=[human|json] make qemu-img info output on
human or JSON representation at the choice of the user.
example:
{
"snapshots": [
{
"vm-clock-nsec": 637102488,
"name": "vm-20120821145509",
"date-sec": 1345553709,
"date-nsec": 220289000,
"vm-clock-sec": 20,
"id": "1",
"vm-state-size": 96522745
},
{
"vm-clock-nsec": 28210866,
"name": "vm-20120821154059",
"date-sec": 1345556459,
"date-nsec": 171392000,
"vm-clock-sec": 46,
"id": "2",
"vm-state-size": 101208714
}
],
"virtual-size": 1073741824,
"filename": "snap.qcow2",
"cluster-size": 65536,
"format": "qcow2",
"actual-size": 985587712,
"dirty-flag": false
}
Signed-off-by: Benoit Canet <benoit@irqsave.net>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2012-09-05 11:09:02 +00:00
|
|
|
|
2004-08-01 21:59:26 +00:00
|
|
|
fmt = NULL;
|
qemu-img: Add json output option to the info command.
This option --output=[human|json] make qemu-img info output on
human or JSON representation at the choice of the user.
example:
{
"snapshots": [
{
"vm-clock-nsec": 637102488,
"name": "vm-20120821145509",
"date-sec": 1345553709,
"date-nsec": 220289000,
"vm-clock-sec": 20,
"id": "1",
"vm-state-size": 96522745
},
{
"vm-clock-nsec": 28210866,
"name": "vm-20120821154059",
"date-sec": 1345556459,
"date-nsec": 171392000,
"vm-clock-sec": 46,
"id": "2",
"vm-state-size": 101208714
}
],
"virtual-size": 1073741824,
"filename": "snap.qcow2",
"cluster-size": 65536,
"format": "qcow2",
"actual-size": 985587712,
"dirty-flag": false
}
Signed-off-by: Benoit Canet <benoit@irqsave.net>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2012-09-05 11:09:02 +00:00
|
|
|
output = NULL;
|
2004-08-01 21:59:26 +00:00
|
|
|
for(;;) {
|
qemu-img: Add json output option to the info command.
This option --output=[human|json] make qemu-img info output on
human or JSON representation at the choice of the user.
example:
{
"snapshots": [
{
"vm-clock-nsec": 637102488,
"name": "vm-20120821145509",
"date-sec": 1345553709,
"date-nsec": 220289000,
"vm-clock-sec": 20,
"id": "1",
"vm-state-size": 96522745
},
{
"vm-clock-nsec": 28210866,
"name": "vm-20120821154059",
"date-sec": 1345556459,
"date-nsec": 171392000,
"vm-clock-sec": 46,
"id": "2",
"vm-state-size": 101208714
}
],
"virtual-size": 1073741824,
"filename": "snap.qcow2",
"cluster-size": 65536,
"format": "qcow2",
"actual-size": 985587712,
"dirty-flag": false
}
Signed-off-by: Benoit Canet <benoit@irqsave.net>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2012-09-05 11:09:02 +00:00
|
|
|
int option_index = 0;
|
|
|
|
static const struct option long_options[] = {
|
|
|
|
{"help", no_argument, 0, 'h'},
|
|
|
|
{"format", required_argument, 0, 'f'},
|
|
|
|
{"output", required_argument, 0, OPTION_OUTPUT},
|
2012-10-17 12:02:31 +00:00
|
|
|
{"backing-chain", no_argument, 0, OPTION_BACKING_CHAIN},
|
qemu-img: Add json output option to the info command.
This option --output=[human|json] make qemu-img info output on
human or JSON representation at the choice of the user.
example:
{
"snapshots": [
{
"vm-clock-nsec": 637102488,
"name": "vm-20120821145509",
"date-sec": 1345553709,
"date-nsec": 220289000,
"vm-clock-sec": 20,
"id": "1",
"vm-state-size": 96522745
},
{
"vm-clock-nsec": 28210866,
"name": "vm-20120821154059",
"date-sec": 1345556459,
"date-nsec": 171392000,
"vm-clock-sec": 46,
"id": "2",
"vm-state-size": 101208714
}
],
"virtual-size": 1073741824,
"filename": "snap.qcow2",
"cluster-size": 65536,
"format": "qcow2",
"actual-size": 985587712,
"dirty-flag": false
}
Signed-off-by: Benoit Canet <benoit@irqsave.net>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2012-09-05 11:09:02 +00:00
|
|
|
{0, 0, 0, 0}
|
|
|
|
};
|
|
|
|
c = getopt_long(argc, argv, "f:h",
|
|
|
|
long_options, &option_index);
|
2010-12-06 14:25:39 +00:00
|
|
|
if (c == -1) {
|
2004-08-01 21:59:26 +00:00
|
|
|
break;
|
2010-12-06 14:25:39 +00:00
|
|
|
}
|
2004-08-01 21:59:26 +00:00
|
|
|
switch(c) {
|
2010-12-06 14:25:40 +00:00
|
|
|
case '?':
|
2004-08-01 21:59:26 +00:00
|
|
|
case 'h':
|
|
|
|
help();
|
|
|
|
break;
|
|
|
|
case 'f':
|
|
|
|
fmt = optarg;
|
|
|
|
break;
|
qemu-img: Add json output option to the info command.
This option --output=[human|json] make qemu-img info output on
human or JSON representation at the choice of the user.
example:
{
"snapshots": [
{
"vm-clock-nsec": 637102488,
"name": "vm-20120821145509",
"date-sec": 1345553709,
"date-nsec": 220289000,
"vm-clock-sec": 20,
"id": "1",
"vm-state-size": 96522745
},
{
"vm-clock-nsec": 28210866,
"name": "vm-20120821154059",
"date-sec": 1345556459,
"date-nsec": 171392000,
"vm-clock-sec": 46,
"id": "2",
"vm-state-size": 101208714
}
],
"virtual-size": 1073741824,
"filename": "snap.qcow2",
"cluster-size": 65536,
"format": "qcow2",
"actual-size": 985587712,
"dirty-flag": false
}
Signed-off-by: Benoit Canet <benoit@irqsave.net>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2012-09-05 11:09:02 +00:00
|
|
|
case OPTION_OUTPUT:
|
|
|
|
output = optarg;
|
|
|
|
break;
|
2012-10-17 12:02:31 +00:00
|
|
|
case OPTION_BACKING_CHAIN:
|
|
|
|
chain = true;
|
|
|
|
break;
|
2004-08-01 21:59:26 +00:00
|
|
|
}
|
|
|
|
}
|
2013-08-05 08:53:04 +00:00
|
|
|
if (optind != argc - 1) {
|
2014-04-22 05:36:11 +00:00
|
|
|
error_exit("Expecting one image file name");
|
2010-12-06 14:25:39 +00:00
|
|
|
}
|
2004-08-01 21:59:26 +00:00
|
|
|
filename = argv[optind++];
|
|
|
|
|
qemu-img: Add json output option to the info command.
This option --output=[human|json] make qemu-img info output on
human or JSON representation at the choice of the user.
example:
{
"snapshots": [
{
"vm-clock-nsec": 637102488,
"name": "vm-20120821145509",
"date-sec": 1345553709,
"date-nsec": 220289000,
"vm-clock-sec": 20,
"id": "1",
"vm-state-size": 96522745
},
{
"vm-clock-nsec": 28210866,
"name": "vm-20120821154059",
"date-sec": 1345556459,
"date-nsec": 171392000,
"vm-clock-sec": 46,
"id": "2",
"vm-state-size": 101208714
}
],
"virtual-size": 1073741824,
"filename": "snap.qcow2",
"cluster-size": 65536,
"format": "qcow2",
"actual-size": 985587712,
"dirty-flag": false
}
Signed-off-by: Benoit Canet <benoit@irqsave.net>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2012-09-05 11:09:02 +00:00
|
|
|
if (output && !strcmp(output, "json")) {
|
|
|
|
output_format = OFORMAT_JSON;
|
|
|
|
} else if (output && !strcmp(output, "human")) {
|
|
|
|
output_format = OFORMAT_HUMAN;
|
|
|
|
} else if (output) {
|
|
|
|
error_report("--output must be used with human or json as argument.");
|
2010-06-20 19:26:35 +00:00
|
|
|
return 1;
|
|
|
|
}
|
qemu-img: Add json output option to the info command.
This option --output=[human|json] make qemu-img info output on
human or JSON representation at the choice of the user.
example:
{
"snapshots": [
{
"vm-clock-nsec": 637102488,
"name": "vm-20120821145509",
"date-sec": 1345553709,
"date-nsec": 220289000,
"vm-clock-sec": 20,
"id": "1",
"vm-state-size": 96522745
},
{
"vm-clock-nsec": 28210866,
"name": "vm-20120821154059",
"date-sec": 1345556459,
"date-nsec": 171392000,
"vm-clock-sec": 46,
"id": "2",
"vm-state-size": 101208714
}
],
"virtual-size": 1073741824,
"filename": "snap.qcow2",
"cluster-size": 65536,
"format": "qcow2",
"actual-size": 985587712,
"dirty-flag": false
}
Signed-off-by: Benoit Canet <benoit@irqsave.net>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2012-09-05 11:09:02 +00:00
|
|
|
|
2012-10-17 12:02:31 +00:00
|
|
|
list = collect_image_info_list(filename, fmt, chain);
|
|
|
|
if (!list) {
|
2010-06-20 19:26:35 +00:00
|
|
|
return 1;
|
2006-08-05 21:31:00 +00:00
|
|
|
}
|
qemu-img: Add json output option to the info command.
This option --output=[human|json] make qemu-img info output on
human or JSON representation at the choice of the user.
example:
{
"snapshots": [
{
"vm-clock-nsec": 637102488,
"name": "vm-20120821145509",
"date-sec": 1345553709,
"date-nsec": 220289000,
"vm-clock-sec": 20,
"id": "1",
"vm-state-size": 96522745
},
{
"vm-clock-nsec": 28210866,
"name": "vm-20120821154059",
"date-sec": 1345556459,
"date-nsec": 171392000,
"vm-clock-sec": 46,
"id": "2",
"vm-state-size": 101208714
}
],
"virtual-size": 1073741824,
"filename": "snap.qcow2",
"cluster-size": 65536,
"format": "qcow2",
"actual-size": 985587712,
"dirty-flag": false
}
Signed-off-by: Benoit Canet <benoit@irqsave.net>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2012-09-05 11:09:02 +00:00
|
|
|
|
|
|
|
switch (output_format) {
|
|
|
|
case OFORMAT_HUMAN:
|
2012-10-17 12:02:31 +00:00
|
|
|
dump_human_image_info_list(list);
|
qemu-img: Add json output option to the info command.
This option --output=[human|json] make qemu-img info output on
human or JSON representation at the choice of the user.
example:
{
"snapshots": [
{
"vm-clock-nsec": 637102488,
"name": "vm-20120821145509",
"date-sec": 1345553709,
"date-nsec": 220289000,
"vm-clock-sec": 20,
"id": "1",
"vm-state-size": 96522745
},
{
"vm-clock-nsec": 28210866,
"name": "vm-20120821154059",
"date-sec": 1345556459,
"date-nsec": 171392000,
"vm-clock-sec": 46,
"id": "2",
"vm-state-size": 101208714
}
],
"virtual-size": 1073741824,
"filename": "snap.qcow2",
"cluster-size": 65536,
"format": "qcow2",
"actual-size": 985587712,
"dirty-flag": false
}
Signed-off-by: Benoit Canet <benoit@irqsave.net>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2012-09-05 11:09:02 +00:00
|
|
|
break;
|
|
|
|
case OFORMAT_JSON:
|
2012-10-17 12:02:31 +00:00
|
|
|
if (chain) {
|
|
|
|
dump_json_image_info_list(list);
|
|
|
|
} else {
|
|
|
|
dump_json_image_info(list->value);
|
|
|
|
}
|
qemu-img: Add json output option to the info command.
This option --output=[human|json] make qemu-img info output on
human or JSON representation at the choice of the user.
example:
{
"snapshots": [
{
"vm-clock-nsec": 637102488,
"name": "vm-20120821145509",
"date-sec": 1345553709,
"date-nsec": 220289000,
"vm-clock-sec": 20,
"id": "1",
"vm-state-size": 96522745
},
{
"vm-clock-nsec": 28210866,
"name": "vm-20120821154059",
"date-sec": 1345556459,
"date-nsec": 171392000,
"vm-clock-sec": 46,
"id": "2",
"vm-state-size": 101208714
}
],
"virtual-size": 1073741824,
"filename": "snap.qcow2",
"cluster-size": 65536,
"format": "qcow2",
"actual-size": 985587712,
"dirty-flag": false
}
Signed-off-by: Benoit Canet <benoit@irqsave.net>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2012-09-05 11:09:02 +00:00
|
|
|
break;
|
2006-08-05 21:31:00 +00:00
|
|
|
}
|
qemu-img: Add json output option to the info command.
This option --output=[human|json] make qemu-img info output on
human or JSON representation at the choice of the user.
example:
{
"snapshots": [
{
"vm-clock-nsec": 637102488,
"name": "vm-20120821145509",
"date-sec": 1345553709,
"date-nsec": 220289000,
"vm-clock-sec": 20,
"id": "1",
"vm-state-size": 96522745
},
{
"vm-clock-nsec": 28210866,
"name": "vm-20120821154059",
"date-sec": 1345556459,
"date-nsec": 171392000,
"vm-clock-sec": 46,
"id": "2",
"vm-state-size": 101208714
}
],
"virtual-size": 1073741824,
"filename": "snap.qcow2",
"cluster-size": 65536,
"format": "qcow2",
"actual-size": 985587712,
"dirty-flag": false
}
Signed-off-by: Benoit Canet <benoit@irqsave.net>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2012-09-05 11:09:02 +00:00
|
|
|
|
2012-10-17 12:02:31 +00:00
|
|
|
qapi_free_ImageInfoList(list);
|
2004-08-01 21:59:26 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-09-04 17:00:33 +00:00
|
|
|
|
|
|
|
typedef struct MapEntry {
|
|
|
|
int flags;
|
|
|
|
int depth;
|
|
|
|
int64_t start;
|
|
|
|
int64_t length;
|
|
|
|
int64_t offset;
|
|
|
|
BlockDriverState *bs;
|
|
|
|
} MapEntry;
|
|
|
|
|
|
|
|
static void dump_map_entry(OutputFormat output_format, MapEntry *e,
|
|
|
|
MapEntry *next)
|
|
|
|
{
|
|
|
|
switch (output_format) {
|
|
|
|
case OFORMAT_HUMAN:
|
|
|
|
if ((e->flags & BDRV_BLOCK_DATA) &&
|
|
|
|
!(e->flags & BDRV_BLOCK_OFFSET_VALID)) {
|
|
|
|
error_report("File contains external, encrypted or compressed clusters.");
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
if ((e->flags & (BDRV_BLOCK_DATA|BDRV_BLOCK_ZERO)) == BDRV_BLOCK_DATA) {
|
|
|
|
printf("%#-16"PRIx64"%#-16"PRIx64"%#-16"PRIx64"%s\n",
|
|
|
|
e->start, e->length, e->offset, e->bs->filename);
|
|
|
|
}
|
|
|
|
/* This format ignores the distinction between 0, ZERO and ZERO|DATA.
|
|
|
|
* Modify the flags here to allow more coalescing.
|
|
|
|
*/
|
|
|
|
if (next &&
|
|
|
|
(next->flags & (BDRV_BLOCK_DATA|BDRV_BLOCK_ZERO)) != BDRV_BLOCK_DATA) {
|
|
|
|
next->flags &= ~BDRV_BLOCK_DATA;
|
|
|
|
next->flags |= BDRV_BLOCK_ZERO;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case OFORMAT_JSON:
|
|
|
|
printf("%s{ \"start\": %"PRId64", \"length\": %"PRId64", \"depth\": %d,"
|
|
|
|
" \"zero\": %s, \"data\": %s",
|
|
|
|
(e->start == 0 ? "[" : ",\n"),
|
|
|
|
e->start, e->length, e->depth,
|
|
|
|
(e->flags & BDRV_BLOCK_ZERO) ? "true" : "false",
|
|
|
|
(e->flags & BDRV_BLOCK_DATA) ? "true" : "false");
|
|
|
|
if (e->flags & BDRV_BLOCK_OFFSET_VALID) {
|
2013-09-11 16:47:52 +00:00
|
|
|
printf(", \"offset\": %"PRId64"", e->offset);
|
2013-09-04 17:00:33 +00:00
|
|
|
}
|
|
|
|
putchar('}');
|
|
|
|
|
|
|
|
if (!next) {
|
|
|
|
printf("]\n");
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int get_block_status(BlockDriverState *bs, int64_t sector_num,
|
|
|
|
int nb_sectors, MapEntry *e)
|
|
|
|
{
|
|
|
|
int64_t ret;
|
|
|
|
int depth;
|
|
|
|
|
|
|
|
/* As an optimization, we could cache the current range of unallocated
|
|
|
|
* clusters in each file of the chain, and avoid querying the same
|
|
|
|
* range repeatedly.
|
|
|
|
*/
|
|
|
|
|
|
|
|
depth = 0;
|
|
|
|
for (;;) {
|
|
|
|
ret = bdrv_get_block_status(bs, sector_num, nb_sectors, &nb_sectors);
|
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
assert(nb_sectors);
|
|
|
|
if (ret & (BDRV_BLOCK_ZERO|BDRV_BLOCK_DATA)) {
|
|
|
|
break;
|
|
|
|
}
|
2015-06-17 12:55:21 +00:00
|
|
|
bs = backing_bs(bs);
|
2013-09-04 17:00:33 +00:00
|
|
|
if (bs == NULL) {
|
|
|
|
ret = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
depth++;
|
|
|
|
}
|
|
|
|
|
|
|
|
e->start = sector_num * BDRV_SECTOR_SIZE;
|
|
|
|
e->length = nb_sectors * BDRV_SECTOR_SIZE;
|
|
|
|
e->flags = ret & ~BDRV_BLOCK_OFFSET_MASK;
|
|
|
|
e->offset = ret & BDRV_BLOCK_OFFSET_MASK;
|
|
|
|
e->depth = depth;
|
|
|
|
e->bs = bs;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int img_map(int argc, char **argv)
|
|
|
|
{
|
|
|
|
int c;
|
|
|
|
OutputFormat output_format = OFORMAT_HUMAN;
|
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 11:59:04 +00:00
|
|
|
BlockBackend *blk;
|
2013-09-04 17:00:33 +00:00
|
|
|
BlockDriverState *bs;
|
|
|
|
const char *filename, *fmt, *output;
|
|
|
|
int64_t length;
|
|
|
|
MapEntry curr = { .length = 0 }, next;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
fmt = NULL;
|
|
|
|
output = NULL;
|
|
|
|
for (;;) {
|
|
|
|
int option_index = 0;
|
|
|
|
static const struct option long_options[] = {
|
|
|
|
{"help", no_argument, 0, 'h'},
|
|
|
|
{"format", required_argument, 0, 'f'},
|
|
|
|
{"output", required_argument, 0, OPTION_OUTPUT},
|
|
|
|
{0, 0, 0, 0}
|
|
|
|
};
|
|
|
|
c = getopt_long(argc, argv, "f:h",
|
|
|
|
long_options, &option_index);
|
|
|
|
if (c == -1) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
switch (c) {
|
|
|
|
case '?':
|
|
|
|
case 'h':
|
|
|
|
help();
|
|
|
|
break;
|
|
|
|
case 'f':
|
|
|
|
fmt = optarg;
|
|
|
|
break;
|
|
|
|
case OPTION_OUTPUT:
|
|
|
|
output = optarg;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2014-04-22 05:36:11 +00:00
|
|
|
if (optind != argc - 1) {
|
|
|
|
error_exit("Expecting one image file name");
|
2013-09-04 17:00:33 +00:00
|
|
|
}
|
2014-04-22 05:36:11 +00:00
|
|
|
filename = argv[optind];
|
2013-09-04 17:00:33 +00:00
|
|
|
|
|
|
|
if (output && !strcmp(output, "json")) {
|
|
|
|
output_format = OFORMAT_JSON;
|
|
|
|
} else if (output && !strcmp(output, "human")) {
|
|
|
|
output_format = OFORMAT_HUMAN;
|
|
|
|
} else if (output) {
|
|
|
|
error_report("--output must be used with human or json as argument.");
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2014-10-07 11:59:05 +00:00
|
|
|
blk = img_open("image", filename, fmt, BDRV_O_FLAGS, true, false);
|
|
|
|
if (!blk) {
|
|
|
|
return 1;
|
2013-09-04 17:00:33 +00:00
|
|
|
}
|
2014-10-07 11:59:05 +00:00
|
|
|
bs = blk_bs(blk);
|
2013-09-04 17:00:33 +00:00
|
|
|
|
|
|
|
if (output_format == OFORMAT_HUMAN) {
|
|
|
|
printf("%-16s%-16s%-16s%s\n", "Offset", "Length", "Mapped to", "File");
|
|
|
|
}
|
|
|
|
|
2015-02-05 18:58:18 +00:00
|
|
|
length = blk_getlength(blk);
|
2013-09-04 17:00:33 +00:00
|
|
|
while (curr.start + curr.length < length) {
|
|
|
|
int64_t nsectors_left;
|
|
|
|
int64_t sector_num;
|
|
|
|
int n;
|
|
|
|
|
|
|
|
sector_num = (curr.start + curr.length) >> BDRV_SECTOR_BITS;
|
|
|
|
|
|
|
|
/* Probe up to 1 GiB at a time. */
|
|
|
|
nsectors_left = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE) - sector_num;
|
|
|
|
n = MIN(1 << (30 - BDRV_SECTOR_BITS), nsectors_left);
|
|
|
|
ret = get_block_status(bs, sector_num, n, &next);
|
|
|
|
|
|
|
|
if (ret < 0) {
|
|
|
|
error_report("Could not read file metadata: %s", strerror(-ret));
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (curr.length != 0 && curr.flags == next.flags &&
|
|
|
|
curr.depth == next.depth &&
|
|
|
|
((curr.flags & BDRV_BLOCK_OFFSET_VALID) == 0 ||
|
|
|
|
curr.offset + curr.length == next.offset)) {
|
|
|
|
curr.length += next.length;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (curr.length > 0) {
|
|
|
|
dump_map_entry(output_format, &curr, &next);
|
|
|
|
}
|
|
|
|
curr = next;
|
|
|
|
}
|
|
|
|
|
|
|
|
dump_map_entry(output_format, &curr, NULL);
|
|
|
|
|
|
|
|
out:
|
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 11:59:04 +00:00
|
|
|
blk_unref(blk);
|
2013-09-04 17:00:33 +00:00
|
|
|
return ret < 0;
|
|
|
|
}
|
|
|
|
|
2009-01-07 17:40:15 +00:00
|
|
|
#define SNAPSHOT_LIST 1
|
|
|
|
#define SNAPSHOT_CREATE 2
|
|
|
|
#define SNAPSHOT_APPLY 3
|
|
|
|
#define SNAPSHOT_DELETE 4
|
|
|
|
|
2009-06-06 23:42:17 +00:00
|
|
|
static int img_snapshot(int argc, char **argv)
|
2009-01-07 17:40:15 +00: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 11:59:04 +00:00
|
|
|
BlockBackend *blk;
|
2009-01-07 17:40:15 +00:00
|
|
|
BlockDriverState *bs;
|
|
|
|
QEMUSnapshotInfo sn;
|
|
|
|
char *filename, *snapshot_name = NULL;
|
2010-06-20 19:26:35 +00:00
|
|
|
int c, ret = 0, bdrv_oflags;
|
2009-01-07 17:40:15 +00:00
|
|
|
int action = 0;
|
|
|
|
qemu_timeval tv;
|
2013-02-13 08:09:40 +00:00
|
|
|
bool quiet = false;
|
snapshot: distinguish id and name in snapshot delete
Snapshot creation actually already distinguish id and name since it take
a structured parameter *sn, but delete can't. Later an accurate delete
is needed in qmp_transaction abort and blockdev-snapshot-delete-sync,
so change its prototype. Also *errp is added to tip error, but return
value is kepted to let caller check what kind of error happens. Existing
caller for it are savevm, delvm and qemu-img, they are not impacted by
introducing a new function bdrv_snapshot_delete_by_id_or_name(), which
check the return value and do the operation again.
Before this patch:
For qcow2, it search id first then name to find the one to delete.
For rbd, it search name.
For sheepdog, it does nothing.
After this patch:
For qcow2, logic is the same by call it twice in caller.
For rbd, it always fails in delete with id, but still search for name
in second try, no change to user.
Some code for *errp is based on Pavel's patch.
Signed-off-by: Wenchao Xia <xiawenc@linux.vnet.ibm.com>
Signed-off-by: Pavel Hrdina <phrdina@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2013-09-11 06:04:33 +00:00
|
|
|
Error *err = NULL;
|
2009-01-07 17:40:15 +00:00
|
|
|
|
2011-01-10 11:33:02 +00:00
|
|
|
bdrv_oflags = BDRV_O_FLAGS | BDRV_O_RDWR;
|
2009-01-07 17:40:15 +00:00
|
|
|
/* Parse commandline parameters */
|
|
|
|
for(;;) {
|
2013-02-13 08:09:40 +00:00
|
|
|
c = getopt(argc, argv, "la:c:d:hq");
|
2010-12-06 14:25:39 +00:00
|
|
|
if (c == -1) {
|
2009-01-07 17:40:15 +00:00
|
|
|
break;
|
2010-12-06 14:25:39 +00:00
|
|
|
}
|
2009-01-07 17:40:15 +00:00
|
|
|
switch(c) {
|
2010-12-06 14:25:40 +00:00
|
|
|
case '?':
|
2009-01-07 17:40:15 +00:00
|
|
|
case 'h':
|
|
|
|
help();
|
2009-06-06 23:42:17 +00:00
|
|
|
return 0;
|
2009-01-07 17:40:15 +00:00
|
|
|
case 'l':
|
|
|
|
if (action) {
|
2014-04-22 05:36:11 +00:00
|
|
|
error_exit("Cannot mix '-l', '-a', '-c', '-d'");
|
2009-06-06 23:42:17 +00:00
|
|
|
return 0;
|
2009-01-07 17:40:15 +00:00
|
|
|
}
|
|
|
|
action = SNAPSHOT_LIST;
|
2010-01-17 14:48:13 +00:00
|
|
|
bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */
|
2009-01-07 17:40:15 +00:00
|
|
|
break;
|
|
|
|
case 'a':
|
|
|
|
if (action) {
|
2014-04-22 05:36:11 +00:00
|
|
|
error_exit("Cannot mix '-l', '-a', '-c', '-d'");
|
2009-06-06 23:42:17 +00:00
|
|
|
return 0;
|
2009-01-07 17:40:15 +00:00
|
|
|
}
|
|
|
|
action = SNAPSHOT_APPLY;
|
|
|
|
snapshot_name = optarg;
|
|
|
|
break;
|
|
|
|
case 'c':
|
|
|
|
if (action) {
|
2014-04-22 05:36:11 +00:00
|
|
|
error_exit("Cannot mix '-l', '-a', '-c', '-d'");
|
2009-06-06 23:42:17 +00:00
|
|
|
return 0;
|
2009-01-07 17:40:15 +00:00
|
|
|
}
|
|
|
|
action = SNAPSHOT_CREATE;
|
|
|
|
snapshot_name = optarg;
|
|
|
|
break;
|
|
|
|
case 'd':
|
|
|
|
if (action) {
|
2014-04-22 05:36:11 +00:00
|
|
|
error_exit("Cannot mix '-l', '-a', '-c', '-d'");
|
2009-06-06 23:42:17 +00:00
|
|
|
return 0;
|
2009-01-07 17:40:15 +00:00
|
|
|
}
|
|
|
|
action = SNAPSHOT_DELETE;
|
|
|
|
snapshot_name = optarg;
|
|
|
|
break;
|
2013-02-13 08:09:40 +00:00
|
|
|
case 'q':
|
|
|
|
quiet = true;
|
|
|
|
break;
|
2009-01-07 17:40:15 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-08-05 08:53:04 +00:00
|
|
|
if (optind != argc - 1) {
|
2014-04-22 05:36:11 +00:00
|
|
|
error_exit("Expecting one image file name");
|
2010-12-06 14:25:39 +00:00
|
|
|
}
|
2009-01-07 17:40:15 +00:00
|
|
|
filename = argv[optind++];
|
|
|
|
|
|
|
|
/* Open the image */
|
2014-10-07 11:59:05 +00:00
|
|
|
blk = img_open("image", filename, NULL, bdrv_oflags, true, quiet);
|
|
|
|
if (!blk) {
|
|
|
|
return 1;
|
2010-06-20 19:26:35 +00:00
|
|
|
}
|
2014-10-07 11:59:05 +00:00
|
|
|
bs = blk_bs(blk);
|
2009-01-07 17:40:15 +00:00
|
|
|
|
|
|
|
/* Perform the requested action */
|
|
|
|
switch(action) {
|
|
|
|
case SNAPSHOT_LIST:
|
|
|
|
dump_snapshots(bs);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SNAPSHOT_CREATE:
|
|
|
|
memset(&sn, 0, sizeof(sn));
|
|
|
|
pstrcpy(sn.name, sizeof(sn.name), snapshot_name);
|
|
|
|
|
|
|
|
qemu_gettimeofday(&tv);
|
|
|
|
sn.date_sec = tv.tv_sec;
|
|
|
|
sn.date_nsec = tv.tv_usec * 1000;
|
|
|
|
|
|
|
|
ret = bdrv_snapshot_create(bs, &sn);
|
2010-12-06 14:25:39 +00:00
|
|
|
if (ret) {
|
2010-12-16 13:31:53 +00:00
|
|
|
error_report("Could not create snapshot '%s': %d (%s)",
|
2009-01-07 17:40:15 +00:00
|
|
|
snapshot_name, ret, strerror(-ret));
|
2010-12-06 14:25:39 +00:00
|
|
|
}
|
2009-01-07 17:40:15 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SNAPSHOT_APPLY:
|
|
|
|
ret = bdrv_snapshot_goto(bs, snapshot_name);
|
2010-12-06 14:25:39 +00:00
|
|
|
if (ret) {
|
2010-12-16 13:31:53 +00:00
|
|
|
error_report("Could not apply snapshot '%s': %d (%s)",
|
2009-01-07 17:40:15 +00:00
|
|
|
snapshot_name, ret, strerror(-ret));
|
2010-12-06 14:25:39 +00:00
|
|
|
}
|
2009-01-07 17:40:15 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SNAPSHOT_DELETE:
|
snapshot: distinguish id and name in snapshot delete
Snapshot creation actually already distinguish id and name since it take
a structured parameter *sn, but delete can't. Later an accurate delete
is needed in qmp_transaction abort and blockdev-snapshot-delete-sync,
so change its prototype. Also *errp is added to tip error, but return
value is kepted to let caller check what kind of error happens. Existing
caller for it are savevm, delvm and qemu-img, they are not impacted by
introducing a new function bdrv_snapshot_delete_by_id_or_name(), which
check the return value and do the operation again.
Before this patch:
For qcow2, it search id first then name to find the one to delete.
For rbd, it search name.
For sheepdog, it does nothing.
After this patch:
For qcow2, logic is the same by call it twice in caller.
For rbd, it always fails in delete with id, but still search for name
in second try, no change to user.
Some code for *errp is based on Pavel's patch.
Signed-off-by: Wenchao Xia <xiawenc@linux.vnet.ibm.com>
Signed-off-by: Pavel Hrdina <phrdina@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2013-09-11 06:04:33 +00:00
|
|
|
bdrv_snapshot_delete_by_id_or_name(bs, snapshot_name, &err);
|
2014-01-30 14:07:28 +00:00
|
|
|
if (err) {
|
snapshot: distinguish id and name in snapshot delete
Snapshot creation actually already distinguish id and name since it take
a structured parameter *sn, but delete can't. Later an accurate delete
is needed in qmp_transaction abort and blockdev-snapshot-delete-sync,
so change its prototype. Also *errp is added to tip error, but return
value is kepted to let caller check what kind of error happens. Existing
caller for it are savevm, delvm and qemu-img, they are not impacted by
introducing a new function bdrv_snapshot_delete_by_id_or_name(), which
check the return value and do the operation again.
Before this patch:
For qcow2, it search id first then name to find the one to delete.
For rbd, it search name.
For sheepdog, it does nothing.
After this patch:
For qcow2, logic is the same by call it twice in caller.
For rbd, it always fails in delete with id, but still search for name
in second try, no change to user.
Some code for *errp is based on Pavel's patch.
Signed-off-by: Wenchao Xia <xiawenc@linux.vnet.ibm.com>
Signed-off-by: Pavel Hrdina <phrdina@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2013-09-11 06:04:33 +00:00
|
|
|
error_report("Could not delete snapshot '%s': (%s)",
|
|
|
|
snapshot_name, error_get_pretty(err));
|
|
|
|
error_free(err);
|
|
|
|
ret = 1;
|
2010-12-06 14:25:39 +00:00
|
|
|
}
|
2009-01-07 17:40:15 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Cleanup */
|
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 11:59:04 +00:00
|
|
|
blk_unref(blk);
|
2010-06-20 19:26:35 +00:00
|
|
|
if (ret) {
|
|
|
|
return 1;
|
|
|
|
}
|
2009-06-06 23:42:17 +00:00
|
|
|
return 0;
|
2009-01-07 17:40:15 +00:00
|
|
|
}
|
|
|
|
|
2010-01-12 11:55:18 +00:00
|
|
|
static int img_rebase(int argc, char **argv)
|
|
|
|
{
|
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 11:59:04 +00:00
|
|
|
BlockBackend *blk = NULL, *blk_old_backing = NULL, *blk_new_backing = NULL;
|
2015-02-05 18:58:18 +00:00
|
|
|
BlockDriverState *bs = NULL;
|
2010-01-12 11:55:18 +00:00
|
|
|
char *filename;
|
2014-07-22 20:58:42 +00:00
|
|
|
const char *fmt, *cache, *src_cache, *out_basefmt, *out_baseimg;
|
|
|
|
int c, flags, src_flags, ret;
|
2010-01-12 11:55:18 +00:00
|
|
|
int unsafe = 0;
|
2011-03-30 12:16:25 +00:00
|
|
|
int progress = 0;
|
2013-02-13 08:09:40 +00:00
|
|
|
bool quiet = false;
|
2013-09-05 12:45:29 +00:00
|
|
|
Error *local_err = NULL;
|
2010-01-12 11:55:18 +00:00
|
|
|
|
|
|
|
/* Parse commandline parameters */
|
2010-03-02 11:14:31 +00:00
|
|
|
fmt = NULL;
|
2011-06-20 16:48:19 +00:00
|
|
|
cache = BDRV_DEFAULT_CACHE;
|
2014-07-22 20:58:42 +00:00
|
|
|
src_cache = BDRV_DEFAULT_CACHE;
|
2010-01-12 11:55:18 +00:00
|
|
|
out_baseimg = NULL;
|
|
|
|
out_basefmt = NULL;
|
|
|
|
for(;;) {
|
2014-07-22 20:58:42 +00:00
|
|
|
c = getopt(argc, argv, "hf:F:b:upt:T:q");
|
2010-12-06 14:25:39 +00:00
|
|
|
if (c == -1) {
|
2010-01-12 11:55:18 +00:00
|
|
|
break;
|
2010-12-06 14:25:39 +00:00
|
|
|
}
|
2010-01-12 11:55:18 +00:00
|
|
|
switch(c) {
|
2010-12-06 14:25:40 +00:00
|
|
|
case '?':
|
2010-01-12 11:55:18 +00:00
|
|
|
case 'h':
|
|
|
|
help();
|
|
|
|
return 0;
|
2010-03-02 11:14:31 +00:00
|
|
|
case 'f':
|
|
|
|
fmt = optarg;
|
|
|
|
break;
|
2010-01-12 11:55:18 +00:00
|
|
|
case 'F':
|
|
|
|
out_basefmt = optarg;
|
|
|
|
break;
|
|
|
|
case 'b':
|
|
|
|
out_baseimg = optarg;
|
|
|
|
break;
|
|
|
|
case 'u':
|
|
|
|
unsafe = 1;
|
|
|
|
break;
|
2011-03-30 12:16:25 +00:00
|
|
|
case 'p':
|
|
|
|
progress = 1;
|
|
|
|
break;
|
2011-06-20 16:48:19 +00:00
|
|
|
case 't':
|
|
|
|
cache = optarg;
|
|
|
|
break;
|
2014-07-22 20:58:42 +00:00
|
|
|
case 'T':
|
|
|
|
src_cache = optarg;
|
|
|
|
break;
|
2013-02-13 08:09:40 +00:00
|
|
|
case 'q':
|
|
|
|
quiet = true;
|
|
|
|
break;
|
2010-01-12 11:55:18 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-02-13 08:09:40 +00:00
|
|
|
if (quiet) {
|
|
|
|
progress = 0;
|
|
|
|
}
|
|
|
|
|
2014-04-22 05:36:11 +00:00
|
|
|
if (optind != argc - 1) {
|
|
|
|
error_exit("Expecting one image file name");
|
|
|
|
}
|
|
|
|
if (!unsafe && !out_baseimg) {
|
|
|
|
error_exit("Must specify backing file (-b) or use unsafe mode (-u)");
|
2010-12-06 14:25:39 +00:00
|
|
|
}
|
2010-01-12 11:55:18 +00:00
|
|
|
filename = argv[optind++];
|
|
|
|
|
2011-03-30 12:16:25 +00:00
|
|
|
qemu_progress_init(progress, 2.0);
|
|
|
|
qemu_progress_print(0, 100);
|
|
|
|
|
2011-06-20 16:48:19 +00:00
|
|
|
flags = BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0);
|
2011-08-04 11:26:51 +00:00
|
|
|
ret = bdrv_parse_cache_flags(cache, &flags);
|
2011-06-20 16:48:19 +00:00
|
|
|
if (ret < 0) {
|
|
|
|
error_report("Invalid cache option: %s", cache);
|
2014-08-26 18:17:56 +00:00
|
|
|
goto out;
|
2011-06-20 16:48:19 +00:00
|
|
|
}
|
|
|
|
|
2014-07-22 20:58:42 +00:00
|
|
|
src_flags = BDRV_O_FLAGS;
|
|
|
|
ret = bdrv_parse_cache_flags(src_cache, &src_flags);
|
|
|
|
if (ret < 0) {
|
|
|
|
error_report("Invalid source cache option: %s", src_cache);
|
2014-08-26 18:17:56 +00:00
|
|
|
goto out;
|
2014-07-22 20:58:42 +00:00
|
|
|
}
|
|
|
|
|
2010-01-12 11:55:18 +00:00
|
|
|
/*
|
|
|
|
* Open the images.
|
|
|
|
*
|
|
|
|
* Ignore the old backing file for unsafe rebase in case we want to correct
|
|
|
|
* the reference to a renamed or moved backing file.
|
|
|
|
*/
|
2014-10-07 11:59:05 +00:00
|
|
|
blk = img_open("image", filename, fmt, flags, true, quiet);
|
|
|
|
if (!blk) {
|
2014-08-26 18:17:56 +00:00
|
|
|
ret = -1;
|
|
|
|
goto out;
|
2010-06-20 19:26:35 +00:00
|
|
|
}
|
2014-10-07 11:59:05 +00:00
|
|
|
bs = blk_bs(blk);
|
2010-01-12 11:55:18 +00:00
|
|
|
|
|
|
|
if (out_basefmt != NULL) {
|
2015-02-05 18:58:17 +00:00
|
|
|
if (bdrv_find_format(out_basefmt) == NULL) {
|
2010-12-16 13:31:53 +00:00
|
|
|
error_report("Invalid format name: '%s'", out_basefmt);
|
2010-06-20 19:26:35 +00:00
|
|
|
ret = -1;
|
|
|
|
goto out;
|
2010-01-12 11:55:18 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* For safe rebasing we need to compare old and new backing file */
|
2014-08-26 18:17:56 +00:00
|
|
|
if (!unsafe) {
|
2015-01-22 13:03:30 +00:00
|
|
|
char backing_name[PATH_MAX];
|
2015-02-05 18:58:17 +00:00
|
|
|
QDict *options = NULL;
|
|
|
|
|
|
|
|
if (bs->backing_format[0] != '\0') {
|
|
|
|
options = qdict_new();
|
|
|
|
qdict_put(options, "driver", qstring_from_str(bs->backing_format));
|
|
|
|
}
|
2010-01-12 11:55:18 +00:00
|
|
|
|
|
|
|
bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
|
2015-02-05 18:58:17 +00:00
|
|
|
blk_old_backing = blk_new_open("old_backing", backing_name, NULL,
|
|
|
|
options, src_flags, &local_err);
|
|
|
|
if (!blk_old_backing) {
|
2013-09-05 12:45:29 +00:00
|
|
|
error_report("Could not open old backing file '%s': %s",
|
|
|
|
backing_name, error_get_pretty(local_err));
|
|
|
|
error_free(local_err);
|
2010-06-20 19:26:35 +00:00
|
|
|
goto out;
|
2010-01-12 11:55:18 +00:00
|
|
|
}
|
2015-02-05 18:58:17 +00:00
|
|
|
|
2012-10-16 12:46:18 +00:00
|
|
|
if (out_baseimg[0]) {
|
2015-02-05 18:58:17 +00:00
|
|
|
if (out_basefmt) {
|
|
|
|
options = qdict_new();
|
|
|
|
qdict_put(options, "driver", qstring_from_str(out_basefmt));
|
|
|
|
} else {
|
|
|
|
options = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
blk_new_backing = blk_new_open("new_backing", out_baseimg, NULL,
|
|
|
|
options, src_flags, &local_err);
|
|
|
|
if (!blk_new_backing) {
|
2013-09-05 12:45:29 +00:00
|
|
|
error_report("Could not open new backing file '%s': %s",
|
|
|
|
out_baseimg, error_get_pretty(local_err));
|
|
|
|
error_free(local_err);
|
2012-10-16 12:46:18 +00:00
|
|
|
goto out;
|
|
|
|
}
|
2010-01-12 11:55:18 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check each unallocated cluster in the COW file. If it is unallocated,
|
|
|
|
* accesses go to the backing file. We must therefore compare this cluster
|
|
|
|
* in the old and new backing file, and if they differ we need to copy it
|
|
|
|
* from the old backing file into the COW file.
|
|
|
|
*
|
|
|
|
* If qemu-img crashes during this step, no harm is done. The content of
|
|
|
|
* the image is the same as the original one at any time.
|
|
|
|
*/
|
|
|
|
if (!unsafe) {
|
2014-06-26 11:23:25 +00:00
|
|
|
int64_t num_sectors;
|
|
|
|
int64_t old_backing_num_sectors;
|
|
|
|
int64_t new_backing_num_sectors = 0;
|
2010-01-12 11:55:18 +00:00
|
|
|
uint64_t sector;
|
2010-04-29 12:47:48 +00:00
|
|
|
int n;
|
2010-02-08 08:20:00 +00:00
|
|
|
uint8_t * buf_old;
|
|
|
|
uint8_t * buf_new;
|
2012-10-12 12:29:18 +00:00
|
|
|
float local_progress = 0;
|
2010-02-08 08:20:00 +00:00
|
|
|
|
2015-02-05 18:58:18 +00:00
|
|
|
buf_old = blk_blockalign(blk, IO_BUF_SIZE);
|
|
|
|
buf_new = blk_blockalign(blk, IO_BUF_SIZE);
|
2010-01-12 11:55:18 +00:00
|
|
|
|
2015-02-05 18:58:18 +00:00
|
|
|
num_sectors = blk_nb_sectors(blk);
|
2014-06-26 11:23:25 +00:00
|
|
|
if (num_sectors < 0) {
|
|
|
|
error_report("Could not get size of '%s': %s",
|
|
|
|
filename, strerror(-num_sectors));
|
|
|
|
ret = -1;
|
|
|
|
goto out;
|
|
|
|
}
|
2015-02-05 18:58:18 +00:00
|
|
|
old_backing_num_sectors = blk_nb_sectors(blk_old_backing);
|
2014-06-26 11:23:25 +00:00
|
|
|
if (old_backing_num_sectors < 0) {
|
2015-01-22 13:03:30 +00:00
|
|
|
char backing_name[PATH_MAX];
|
2014-06-26 11:23:25 +00:00
|
|
|
|
|
|
|
bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
|
|
|
|
error_report("Could not get size of '%s': %s",
|
|
|
|
backing_name, strerror(-old_backing_num_sectors));
|
|
|
|
ret = -1;
|
|
|
|
goto out;
|
|
|
|
}
|
2015-02-05 18:58:18 +00:00
|
|
|
if (blk_new_backing) {
|
|
|
|
new_backing_num_sectors = blk_nb_sectors(blk_new_backing);
|
2014-06-26 11:23:25 +00:00
|
|
|
if (new_backing_num_sectors < 0) {
|
|
|
|
error_report("Could not get size of '%s': %s",
|
|
|
|
out_baseimg, strerror(-new_backing_num_sectors));
|
|
|
|
ret = -1;
|
|
|
|
goto out;
|
|
|
|
}
|
2012-10-16 12:46:18 +00:00
|
|
|
}
|
2010-01-12 11:55:18 +00:00
|
|
|
|
2012-10-12 12:29:18 +00:00
|
|
|
if (num_sectors != 0) {
|
|
|
|
local_progress = (float)100 /
|
|
|
|
(num_sectors / MIN(num_sectors, IO_BUF_SIZE / 512));
|
|
|
|
}
|
|
|
|
|
2010-01-12 11:55:18 +00:00
|
|
|
for (sector = 0; sector < num_sectors; sector += n) {
|
|
|
|
|
|
|
|
/* How many sectors can we handle with the next read? */
|
|
|
|
if (sector + (IO_BUF_SIZE / 512) <= num_sectors) {
|
|
|
|
n = (IO_BUF_SIZE / 512);
|
|
|
|
} else {
|
|
|
|
n = num_sectors - sector;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If the cluster is allocated, we don't need to take action */
|
2010-04-29 12:47:48 +00:00
|
|
|
ret = bdrv_is_allocated(bs, sector, n, &n);
|
2013-09-04 17:00:25 +00:00
|
|
|
if (ret < 0) {
|
|
|
|
error_report("error while reading image metadata: %s",
|
|
|
|
strerror(-ret));
|
|
|
|
goto out;
|
|
|
|
}
|
2010-04-29 12:47:48 +00:00
|
|
|
if (ret) {
|
2010-01-12 11:55:18 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2011-12-07 11:42:10 +00:00
|
|
|
/*
|
|
|
|
* Read old and new backing file and take into consideration that
|
|
|
|
* backing files may be smaller than the COW image.
|
|
|
|
*/
|
|
|
|
if (sector >= old_backing_num_sectors) {
|
|
|
|
memset(buf_old, 0, n * BDRV_SECTOR_SIZE);
|
|
|
|
} else {
|
|
|
|
if (sector + n > old_backing_num_sectors) {
|
|
|
|
n = old_backing_num_sectors - sector;
|
|
|
|
}
|
|
|
|
|
2015-02-05 18:58:18 +00:00
|
|
|
ret = blk_read(blk_old_backing, sector, buf_old, n);
|
2011-12-07 11:42:10 +00:00
|
|
|
if (ret < 0) {
|
|
|
|
error_report("error while reading from old backing file");
|
|
|
|
goto out;
|
|
|
|
}
|
2010-01-12 11:55:18 +00:00
|
|
|
}
|
2011-12-07 11:42:10 +00:00
|
|
|
|
2015-02-05 18:58:18 +00:00
|
|
|
if (sector >= new_backing_num_sectors || !blk_new_backing) {
|
2011-12-07 11:42:10 +00:00
|
|
|
memset(buf_new, 0, n * BDRV_SECTOR_SIZE);
|
|
|
|
} else {
|
|
|
|
if (sector + n > new_backing_num_sectors) {
|
|
|
|
n = new_backing_num_sectors - sector;
|
|
|
|
}
|
|
|
|
|
2015-02-05 18:58:18 +00:00
|
|
|
ret = blk_read(blk_new_backing, sector, buf_new, n);
|
2011-12-07 11:42:10 +00:00
|
|
|
if (ret < 0) {
|
|
|
|
error_report("error while reading from new backing file");
|
|
|
|
goto out;
|
|
|
|
}
|
2010-01-12 11:55:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* If they differ, we need to write to the COW file */
|
|
|
|
uint64_t written = 0;
|
|
|
|
|
|
|
|
while (written < n) {
|
|
|
|
int pnum;
|
|
|
|
|
|
|
|
if (compare_sectors(buf_old + written * 512,
|
2010-02-17 11:32:59 +00:00
|
|
|
buf_new + written * 512, n - written, &pnum))
|
2010-01-12 11:55:18 +00:00
|
|
|
{
|
2015-02-05 18:58:18 +00:00
|
|
|
ret = blk_write(blk, sector + written,
|
|
|
|
buf_old + written * 512, pnum);
|
2010-01-12 11:55:18 +00:00
|
|
|
if (ret < 0) {
|
2010-12-16 13:31:53 +00:00
|
|
|
error_report("Error while writing to COW image: %s",
|
2010-01-12 11:55:18 +00:00
|
|
|
strerror(-ret));
|
2010-06-20 19:26:35 +00:00
|
|
|
goto out;
|
2010-01-12 11:55:18 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
written += pnum;
|
|
|
|
}
|
2011-03-30 12:16:25 +00:00
|
|
|
qemu_progress_print(local_progress, 100);
|
2010-01-12 11:55:18 +00:00
|
|
|
}
|
2010-02-08 08:20:00 +00:00
|
|
|
|
2011-08-08 12:09:12 +00:00
|
|
|
qemu_vfree(buf_old);
|
|
|
|
qemu_vfree(buf_new);
|
2010-01-12 11:55:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Change the backing file. All clusters that are different from the old
|
|
|
|
* backing file are overwritten in the COW file now, so the visible content
|
|
|
|
* doesn't change when we switch the backing file.
|
|
|
|
*/
|
2012-10-16 12:46:18 +00:00
|
|
|
if (out_baseimg && *out_baseimg) {
|
|
|
|
ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt);
|
|
|
|
} else {
|
|
|
|
ret = bdrv_change_backing_file(bs, NULL, NULL);
|
|
|
|
}
|
|
|
|
|
2010-01-12 11:55:18 +00:00
|
|
|
if (ret == -ENOSPC) {
|
2010-12-16 13:31:53 +00:00
|
|
|
error_report("Could not change the backing file to '%s': No "
|
|
|
|
"space left in the file header", out_baseimg);
|
2010-01-12 11:55:18 +00:00
|
|
|
} else if (ret < 0) {
|
2010-12-16 13:31:53 +00:00
|
|
|
error_report("Could not change the backing file to '%s': %s",
|
2010-01-12 11:55:18 +00:00
|
|
|
out_baseimg, strerror(-ret));
|
|
|
|
}
|
|
|
|
|
2011-03-30 12:16:25 +00:00
|
|
|
qemu_progress_print(100, 0);
|
2010-01-12 11:55:18 +00:00
|
|
|
/*
|
|
|
|
* TODO At this point it is possible to check if any clusters that are
|
|
|
|
* allocated in the COW file are the same in the backing file. If so, they
|
|
|
|
* could be dropped from the COW file. Don't do this before switching the
|
|
|
|
* backing file, in case of a crash this would lead to corruption.
|
|
|
|
*/
|
2010-06-20 19:26:35 +00:00
|
|
|
out:
|
2011-03-30 12:16:25 +00:00
|
|
|
qemu_progress_end();
|
2010-01-12 11:55:18 +00:00
|
|
|
/* Cleanup */
|
|
|
|
if (!unsafe) {
|
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 11:59:04 +00:00
|
|
|
blk_unref(blk_old_backing);
|
|
|
|
blk_unref(blk_new_backing);
|
2010-01-12 11:55:18 +00: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 11:59:04 +00:00
|
|
|
blk_unref(blk);
|
2010-06-20 19:26:35 +00:00
|
|
|
if (ret) {
|
|
|
|
return 1;
|
|
|
|
}
|
2010-01-12 11:55:18 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-04-24 08:12:12 +00:00
|
|
|
static int img_resize(int argc, char **argv)
|
|
|
|
{
|
2015-02-12 16:43:08 +00:00
|
|
|
Error *err = NULL;
|
2010-04-24 08:12:12 +00:00
|
|
|
int c, ret, relative;
|
|
|
|
const char *filename, *fmt, *size;
|
|
|
|
int64_t n, total_size;
|
2013-02-13 08:09:40 +00:00
|
|
|
bool quiet = false;
|
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 11:59:04 +00:00
|
|
|
BlockBackend *blk = NULL;
|
2012-08-06 02:18:42 +00:00
|
|
|
QemuOpts *param;
|
|
|
|
static QemuOptsList resize_options = {
|
|
|
|
.name = "resize_options",
|
|
|
|
.head = QTAILQ_HEAD_INITIALIZER(resize_options.head),
|
|
|
|
.desc = {
|
|
|
|
{
|
|
|
|
.name = BLOCK_OPT_SIZE,
|
|
|
|
.type = QEMU_OPT_SIZE,
|
|
|
|
.help = "Virtual disk size"
|
|
|
|
}, {
|
|
|
|
/* end of list */
|
|
|
|
}
|
2010-04-24 08:12:12 +00:00
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2011-04-29 08:58:12 +00:00
|
|
|
/* Remove size from argv manually so that negative numbers are not treated
|
|
|
|
* as options by getopt. */
|
|
|
|
if (argc < 3) {
|
2014-04-22 05:36:11 +00:00
|
|
|
error_exit("Not enough arguments");
|
2011-04-29 08:58:12 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
size = argv[--argc];
|
|
|
|
|
|
|
|
/* Parse getopt arguments */
|
2010-04-24 08:12:12 +00:00
|
|
|
fmt = NULL;
|
|
|
|
for(;;) {
|
2013-02-13 08:09:40 +00:00
|
|
|
c = getopt(argc, argv, "f:hq");
|
2010-04-24 08:12:12 +00:00
|
|
|
if (c == -1) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
switch(c) {
|
2010-12-06 14:25:40 +00:00
|
|
|
case '?':
|
2010-04-24 08:12:12 +00:00
|
|
|
case 'h':
|
|
|
|
help();
|
|
|
|
break;
|
|
|
|
case 'f':
|
|
|
|
fmt = optarg;
|
|
|
|
break;
|
2013-02-13 08:09:40 +00:00
|
|
|
case 'q':
|
|
|
|
quiet = true;
|
|
|
|
break;
|
2010-04-24 08:12:12 +00:00
|
|
|
}
|
|
|
|
}
|
2013-08-05 08:53:04 +00:00
|
|
|
if (optind != argc - 1) {
|
2014-04-22 05:36:11 +00:00
|
|
|
error_exit("Expecting one image file name");
|
2010-04-24 08:12:12 +00:00
|
|
|
}
|
|
|
|
filename = argv[optind++];
|
|
|
|
|
|
|
|
/* Choose grow, shrink, or absolute resize mode */
|
|
|
|
switch (size[0]) {
|
|
|
|
case '+':
|
|
|
|
relative = 1;
|
|
|
|
size++;
|
|
|
|
break;
|
|
|
|
case '-':
|
|
|
|
relative = -1;
|
|
|
|
size++;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
relative = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Parse size */
|
2014-01-02 02:49:17 +00:00
|
|
|
param = qemu_opts_create(&resize_options, NULL, 0, &error_abort);
|
2015-02-12 16:52:20 +00:00
|
|
|
qemu_opt_set(param, BLOCK_OPT_SIZE, size, &err);
|
2015-02-12 16:43:08 +00:00
|
|
|
if (err) {
|
|
|
|
error_report_err(err);
|
2010-12-06 16:08:31 +00:00
|
|
|
ret = -1;
|
2012-08-06 02:18:42 +00:00
|
|
|
qemu_opts_del(param);
|
2010-12-06 16:08:31 +00:00
|
|
|
goto out;
|
2010-04-24 08:12:12 +00:00
|
|
|
}
|
2012-08-06 02:18:42 +00:00
|
|
|
n = qemu_opt_get_size(param, BLOCK_OPT_SIZE, 0);
|
|
|
|
qemu_opts_del(param);
|
2010-04-24 08:12:12 +00:00
|
|
|
|
2014-10-07 11:59:05 +00:00
|
|
|
blk = img_open("image", filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR,
|
|
|
|
true, quiet);
|
|
|
|
if (!blk) {
|
2010-12-06 16:08:31 +00:00
|
|
|
ret = -1;
|
|
|
|
goto out;
|
2010-06-20 19:26:35 +00:00
|
|
|
}
|
2010-04-24 08:12:12 +00:00
|
|
|
|
|
|
|
if (relative) {
|
2015-02-05 18:58:18 +00:00
|
|
|
total_size = blk_getlength(blk) + n * relative;
|
2010-04-24 08:12:12 +00:00
|
|
|
} else {
|
|
|
|
total_size = n;
|
|
|
|
}
|
|
|
|
if (total_size <= 0) {
|
2010-12-16 13:31:53 +00:00
|
|
|
error_report("New image size must be positive");
|
2010-06-20 19:26:35 +00:00
|
|
|
ret = -1;
|
|
|
|
goto out;
|
2010-04-24 08:12:12 +00:00
|
|
|
}
|
|
|
|
|
2015-02-05 18:58:18 +00:00
|
|
|
ret = blk_truncate(blk, total_size);
|
2010-04-24 08:12:12 +00:00
|
|
|
switch (ret) {
|
|
|
|
case 0:
|
2013-02-13 08:09:40 +00:00
|
|
|
qprintf(quiet, "Image resized.\n");
|
2010-04-24 08:12:12 +00:00
|
|
|
break;
|
|
|
|
case -ENOTSUP:
|
2012-03-06 11:44:45 +00:00
|
|
|
error_report("This image does not support resize");
|
2010-04-24 08:12:12 +00:00
|
|
|
break;
|
|
|
|
case -EACCES:
|
2010-12-16 13:31:53 +00:00
|
|
|
error_report("Image is read-only");
|
2010-04-24 08:12:12 +00:00
|
|
|
break;
|
|
|
|
default:
|
2010-12-16 13:31:53 +00:00
|
|
|
error_report("Error resizing image (%d)", -ret);
|
2010-04-24 08:12:12 +00:00
|
|
|
break;
|
|
|
|
}
|
2010-06-20 19:26:35 +00:00
|
|
|
out:
|
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 11:59:04 +00:00
|
|
|
blk_unref(blk);
|
2010-06-20 19:26:35 +00:00
|
|
|
if (ret) {
|
|
|
|
return 1;
|
|
|
|
}
|
2010-04-24 08:12:12 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-10-27 10:12:51 +00:00
|
|
|
static void amend_status_cb(BlockDriverState *bs,
|
|
|
|
int64_t offset, int64_t total_work_size)
|
|
|
|
{
|
|
|
|
qemu_progress_print(100.f * offset / total_work_size, 0);
|
|
|
|
}
|
|
|
|
|
2013-09-03 08:09:50 +00:00
|
|
|
static int img_amend(int argc, char **argv)
|
|
|
|
{
|
2015-02-12 17:37:11 +00:00
|
|
|
Error *err = NULL;
|
2013-09-03 08:09:50 +00:00
|
|
|
int c, ret = 0;
|
|
|
|
char *options = NULL;
|
2014-06-05 09:20:51 +00:00
|
|
|
QemuOptsList *create_opts = NULL;
|
|
|
|
QemuOpts *opts = NULL;
|
2014-07-22 20:58:43 +00:00
|
|
|
const char *fmt = NULL, *filename, *cache;
|
|
|
|
int flags;
|
2014-10-27 10:12:51 +00:00
|
|
|
bool quiet = false, progress = false;
|
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 11:59:04 +00:00
|
|
|
BlockBackend *blk = NULL;
|
2013-09-03 08:09:50 +00:00
|
|
|
BlockDriverState *bs = NULL;
|
|
|
|
|
2014-07-22 20:58:43 +00:00
|
|
|
cache = BDRV_DEFAULT_CACHE;
|
2013-09-03 08:09:50 +00:00
|
|
|
for (;;) {
|
2014-10-27 10:12:51 +00:00
|
|
|
c = getopt(argc, argv, "ho:f:t:pq");
|
2013-09-03 08:09:50 +00:00
|
|
|
if (c == -1) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (c) {
|
|
|
|
case 'h':
|
|
|
|
case '?':
|
|
|
|
help();
|
|
|
|
break;
|
|
|
|
case 'o':
|
2014-02-21 15:24:06 +00:00
|
|
|
if (!is_valid_option_list(optarg)) {
|
|
|
|
error_report("Invalid option list: %s", optarg);
|
|
|
|
ret = -1;
|
2015-08-20 23:00:38 +00:00
|
|
|
goto out_no_progress;
|
2014-02-21 15:24:06 +00:00
|
|
|
}
|
|
|
|
if (!options) {
|
|
|
|
options = g_strdup(optarg);
|
|
|
|
} else {
|
|
|
|
char *old_options = options;
|
|
|
|
options = g_strdup_printf("%s,%s", options, optarg);
|
|
|
|
g_free(old_options);
|
|
|
|
}
|
2013-09-03 08:09:50 +00:00
|
|
|
break;
|
|
|
|
case 'f':
|
|
|
|
fmt = optarg;
|
|
|
|
break;
|
2014-07-22 20:58:43 +00:00
|
|
|
case 't':
|
|
|
|
cache = optarg;
|
|
|
|
break;
|
2014-10-27 10:12:51 +00:00
|
|
|
case 'p':
|
|
|
|
progress = true;
|
|
|
|
break;
|
2013-09-03 08:09:50 +00:00
|
|
|
case 'q':
|
|
|
|
quiet = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-02-21 15:24:07 +00:00
|
|
|
if (!options) {
|
2014-04-22 05:36:11 +00:00
|
|
|
error_exit("Must specify options (-o)");
|
2013-09-03 08:09:50 +00:00
|
|
|
}
|
|
|
|
|
2014-10-27 10:12:51 +00:00
|
|
|
if (quiet) {
|
|
|
|
progress = false;
|
|
|
|
}
|
|
|
|
qemu_progress_init(progress, 1.0);
|
|
|
|
|
2014-02-21 15:24:07 +00:00
|
|
|
filename = (optind == argc - 1) ? argv[argc - 1] : NULL;
|
|
|
|
if (fmt && has_help_option(options)) {
|
|
|
|
/* If a format is explicitly specified (and possibly no filename is
|
|
|
|
* given), print option help here */
|
|
|
|
ret = print_block_option_help(filename, fmt);
|
|
|
|
goto out;
|
2013-09-03 08:09:50 +00:00
|
|
|
}
|
|
|
|
|
2014-02-21 15:24:07 +00:00
|
|
|
if (optind != argc - 1) {
|
2014-10-27 10:12:52 +00:00
|
|
|
error_report("Expecting one image file name");
|
|
|
|
ret = -1;
|
|
|
|
goto out;
|
2014-02-21 15:24:07 +00:00
|
|
|
}
|
2013-09-03 08:09:50 +00:00
|
|
|
|
2014-07-22 20:58:43 +00:00
|
|
|
flags = BDRV_O_FLAGS | BDRV_O_RDWR;
|
|
|
|
ret = bdrv_parse_cache_flags(cache, &flags);
|
|
|
|
if (ret < 0) {
|
|
|
|
error_report("Invalid cache option: %s", cache);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2014-10-07 11:59:05 +00:00
|
|
|
blk = img_open("image", filename, fmt, flags, true, quiet);
|
|
|
|
if (!blk) {
|
2013-09-03 08:09:50 +00:00
|
|
|
ret = -1;
|
|
|
|
goto out;
|
|
|
|
}
|
2014-10-07 11:59:05 +00:00
|
|
|
bs = blk_bs(blk);
|
2013-09-03 08:09:50 +00:00
|
|
|
|
|
|
|
fmt = bs->drv->format_name;
|
|
|
|
|
2014-02-21 15:24:06 +00:00
|
|
|
if (has_help_option(options)) {
|
2014-02-21 15:24:07 +00:00
|
|
|
/* If the format was auto-detected, print option help here */
|
2013-09-03 08:09:50 +00:00
|
|
|
ret = print_block_option_help(filename, fmt);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2014-12-02 17:32:47 +00:00
|
|
|
if (!bs->drv->create_opts) {
|
|
|
|
error_report("Format driver '%s' does not support any options to amend",
|
|
|
|
fmt);
|
|
|
|
ret = -1;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2014-06-05 09:21:11 +00:00
|
|
|
create_opts = qemu_opts_append(create_opts, bs->drv->create_opts);
|
2014-06-05 09:20:51 +00:00
|
|
|
opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
|
2015-02-12 17:37:11 +00:00
|
|
|
if (options) {
|
|
|
|
qemu_opts_do_parse(opts, options, NULL, &err);
|
|
|
|
if (err) {
|
2015-03-14 09:23:15 +00:00
|
|
|
error_report_err(err);
|
2015-02-12 17:37:11 +00:00
|
|
|
ret = -1;
|
|
|
|
goto out;
|
|
|
|
}
|
2013-09-03 08:09:50 +00:00
|
|
|
}
|
|
|
|
|
2014-10-27 10:12:51 +00:00
|
|
|
/* In case the driver does not call amend_status_cb() */
|
|
|
|
qemu_progress_print(0.f, 0);
|
|
|
|
ret = bdrv_amend_options(bs, opts, &amend_status_cb);
|
|
|
|
qemu_progress_print(100.f, 0);
|
2013-09-03 08:09:50 +00:00
|
|
|
if (ret < 0) {
|
|
|
|
error_report("Error while amending options: %s", strerror(-ret));
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
2014-10-27 10:12:51 +00:00
|
|
|
qemu_progress_end();
|
|
|
|
|
2015-08-20 23:00:38 +00:00
|
|
|
out_no_progress:
|
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 11:59:04 +00:00
|
|
|
blk_unref(blk);
|
2014-06-05 09:20:51 +00:00
|
|
|
qemu_opts_del(opts);
|
|
|
|
qemu_opts_free(create_opts);
|
2014-02-21 15:24:06 +00:00
|
|
|
g_free(options);
|
|
|
|
|
2013-09-03 08:09:50 +00:00
|
|
|
if (ret) {
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-10-01 21:12:16 +00:00
|
|
|
static const img_cmd_t img_cmds[] = {
|
2009-06-06 23:42:17 +00:00
|
|
|
#define DEF(option, callback, arg_string) \
|
|
|
|
{ option, callback },
|
|
|
|
#include "qemu-img-cmds.h"
|
|
|
|
#undef DEF
|
|
|
|
#undef GEN_DOCS
|
|
|
|
{ NULL, NULL, },
|
|
|
|
};
|
|
|
|
|
2004-08-01 21:59:26 +00:00
|
|
|
int main(int argc, char **argv)
|
|
|
|
{
|
2009-10-01 21:12:16 +00:00
|
|
|
const img_cmd_t *cmd;
|
2009-06-06 23:42:17 +00:00
|
|
|
const char *cmdname;
|
2014-09-18 11:30:49 +00:00
|
|
|
Error *local_error = NULL;
|
2014-04-25 21:02:32 +00:00
|
|
|
int c;
|
|
|
|
static const struct option long_options[] = {
|
|
|
|
{"help", no_argument, 0, 'h'},
|
2014-04-28 18:37:18 +00:00
|
|
|
{"version", no_argument, 0, 'v'},
|
2014-04-25 21:02:32 +00:00
|
|
|
{0, 0, 0, 0}
|
|
|
|
};
|
2004-08-01 21:59:26 +00:00
|
|
|
|
2013-07-23 08:30:11 +00:00
|
|
|
#ifdef CONFIG_POSIX
|
|
|
|
signal(SIGPIPE, SIG_IGN);
|
|
|
|
#endif
|
|
|
|
|
2010-12-16 14:10:32 +00:00
|
|
|
error_set_progname(argv[0]);
|
2014-02-10 06:48:51 +00:00
|
|
|
qemu_init_exec_dir(argv[0]);
|
2010-12-16 14:10:32 +00:00
|
|
|
|
2014-09-18 11:30:49 +00:00
|
|
|
if (qemu_init_main_loop(&local_error)) {
|
2015-02-12 12:55:05 +00:00
|
|
|
error_report_err(local_error);
|
2014-09-18 11:30:49 +00:00
|
|
|
exit(EXIT_FAILURE);
|
|
|
|
}
|
|
|
|
|
2004-08-01 21:59:26 +00:00
|
|
|
bdrv_init();
|
2014-04-22 05:36:11 +00:00
|
|
|
if (argc < 2) {
|
|
|
|
error_exit("Not enough arguments");
|
|
|
|
}
|
2009-06-06 23:42:17 +00:00
|
|
|
cmdname = argv[1];
|
|
|
|
|
|
|
|
/* find the command */
|
2014-04-28 18:37:18 +00:00
|
|
|
for (cmd = img_cmds; cmd->name != NULL; cmd++) {
|
2009-06-06 23:42:17 +00:00
|
|
|
if (!strcmp(cmdname, cmd->name)) {
|
2014-04-25 21:02:32 +00:00
|
|
|
return cmd->handler(argc - 1, argv + 1);
|
2009-06-06 23:42:17 +00:00
|
|
|
}
|
2004-08-01 21:59:26 +00:00
|
|
|
}
|
2009-06-06 23:42:17 +00:00
|
|
|
|
2014-04-28 18:37:18 +00:00
|
|
|
c = getopt_long(argc, argv, "h", long_options, NULL);
|
2014-04-25 21:02:32 +00:00
|
|
|
|
|
|
|
if (c == 'h') {
|
|
|
|
help();
|
|
|
|
}
|
2014-04-28 18:37:18 +00:00
|
|
|
if (c == 'v') {
|
|
|
|
printf(QEMU_IMG_VERSION);
|
|
|
|
return 0;
|
|
|
|
}
|
2014-04-25 21:02:32 +00:00
|
|
|
|
2009-06-06 23:42:17 +00:00
|
|
|
/* not found */
|
2014-04-22 05:36:11 +00:00
|
|
|
error_exit("Command not found: %s", cmdname);
|
2004-08-01 21:59:26 +00:00
|
|
|
}
|