[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Qemu-devel] [PATCH 12/17] qemu-img: add a "map" subcommand
From: |
Paolo Bonzini |
Subject: |
[Qemu-devel] [PATCH 12/17] qemu-img: add a "map" subcommand |
Date: |
Wed, 3 Jul 2013 16:34:26 +0200 |
This command dumps the metadata of an entire chain, in either tabular or JSON
format.
Signed-off-by: Paolo Bonzini <address@hidden>
---
qemu-img-cmds.hx | 6 ++
qemu-img.c | 186 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
2 files changed, 192 insertions(+)
diff --git a/qemu-img-cmds.hx b/qemu-img-cmds.hx
index 4ca7e95..acc3a1c 100644
--- a/qemu-img-cmds.hx
+++ b/qemu-img-cmds.hx
@@ -45,6 +45,12 @@ STEXI
@item info [-f @var{fmt}] address@hidden [--backing-chain] @var{filename}
ETEXI
+DEF("map", img_map,
+ "map [-f fmt] [--output=ofmt] filename")
+STEXI
address@hidden map [-f @var{fmt}] address@hidden filename
+ETEXI
+
DEF("snapshot", img_snapshot,
"snapshot [-q] [-l | -a snapshot | -c snapshot | -d snapshot] filename")
STEXI
diff --git a/qemu-img.c b/qemu-img.c
index 6461932..97392a5 100644
--- a/qemu-img.c
+++ b/qemu-img.c
@@ -1768,6 +1768,192 @@ static int img_info(int argc, char **argv)
return 0;
}
+
+typedef struct MapEntry {
+ int flags;
+ int depth;
+ int64_t start;
+ int64_t length;
+ int64_t offset;
+} 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|BDRV_BLOCK_ZERO)) == BDRV_BLOCK_DATA)
{
+ printf("%lld %lld %d %lld\n",
+ (long long) e->start, (long long) e->length,
+ e->depth, (long long) e->offset);
+ }
+ /* 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{ 'depth': %d, 'start': %lld, 'length': %lld, "
+ "'zero': %s, 'data': %s",
+ (e->start == 0 ? "[" : ",\n"),
+ e->depth, (long long) e->start, (long long) e->length,
+ (e->flags & BDRV_BLOCK_ZERO) ? "true" : "false",
+ (e->flags & BDRV_BLOCK_DATA) ? "true" : "false");
+ if (e->flags & BDRV_BLOCK_OFFSET_VALID) {
+ printf(", 'offset': %lld", (long long) e->offset);
+ }
+ putchar('}');
+
+ if (!next) {
+ printf("]\n");
+ }
+ break;
+ }
+}
+
+static int64_t get_block_status(BlockDriverState *bs, int64_t sector_num,
+ int *nb_sectors, int *depth)
+{
+ int64_t ret;
+
+ /* 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 (;;) {
+ int orig_nb_sectors = *nb_sectors;
+
+ if (bs == NULL) {
+ return 0;
+ }
+ ret = bdrv_get_block_status(bs, sector_num, *nb_sectors, nb_sectors);
+ if (ret < 0) {
+ return ret;
+ }
+
+ if (ret & (BDRV_BLOCK_ZERO|BDRV_BLOCK_DATA)) {
+ return ret;
+ }
+ if (!*nb_sectors) {
+ /* Beyond the end of this image (while presumably within the
+ * range of the BlockDriverState above this one). The extra
+ * data is read as zeroes.
+ */
+ *nb_sectors = orig_nb_sectors;
+ return BDRV_BLOCK_ZERO;
+ }
+
+ bs = bs->backing_hd;
+ (*depth)++;
+ }
+}
+
+static int img_map(int argc, char **argv)
+{
+ int c;
+ OutputFormat output_format = OFORMAT_HUMAN;
+ BlockDriverState *bs;
+ const char *filename, *fmt, *output;
+ int64_t length;
+ MapEntry curr = { .length = 0 }, next;
+
+ 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;
+ }
+ }
+ if (optind >= argc) {
+ help();
+ }
+ filename = argv[optind++];
+
+ 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;
+ }
+
+ bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS, true, false);
+ if (!bs) {
+ return 1;
+ }
+
+ length = bdrv_getlength(bs);
+ while (curr.start + curr.length < length) {
+ int64_t nsectors_left, ret;
+ int64_t sector_num;
+ int n, depth, flags;
+
+ /* Probe up to 1 G at a time. */
+ sector_num = (curr.start + curr.length) >> BDRV_SECTOR_BITS;
+ nsectors_left = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE) - sector_num;
+ n = MAX(1 << (30 - BDRV_SECTOR_BITS), nsectors_left);
+ ret = get_block_status(bs, sector_num, &n, &depth);
+
+ if (ret < 0) {
+ error_report("Could not read file metadata: %s", strerror(-ret));
+ return 1;
+ }
+ if ((ret & BDRV_BLOCK_DATA) &&
+ !(ret & BDRV_BLOCK_OFFSET_VALID)) {
+ error_report("File contains external or compressed clusters.");
+ return 1;
+ }
+
+ flags = ret & ~BDRV_BLOCK_OFFSET_MASK;
+ ret &= BDRV_BLOCK_OFFSET_MASK;
+ if (curr.length == 0 || curr.flags != flags || curr.depth != depth ||
+ ((curr.flags & BDRV_BLOCK_OFFSET_VALID) &&
+ curr.offset + curr.length != ret)) {
+ next.flags = flags;
+ next.depth = depth;
+ next.start = sector_num << BDRV_SECTOR_BITS;
+ next.offset = ret;
+ next.length = 0;
+ if (curr.length > 0) {
+ dump_map_entry(output_format, &curr, &next);
+ }
+ curr = next;
+ }
+ curr.length += n << BDRV_SECTOR_BITS;
+ }
+
+ dump_map_entry(output_format, &curr, NULL);
+ return 0;
+}
+
#define SNAPSHOT_LIST 1
#define SNAPSHOT_CREATE 2
#define SNAPSHOT_APPLY 3
--
1.8.2.1
- [Qemu-devel] [PATCH 06/17] block: expect errors from bdrv_co_is_allocated, (continued)
[Qemu-devel] [PATCH 12/17] qemu-img: add a "map" subcommand,
Paolo Bonzini <=
Re: [Qemu-devel] [PATCH 12/17] qemu-img: add a "map" subcommand, Stefan Hajnoczi, 2013/07/15
Re: [Qemu-devel] [PATCH 12/17] qemu-img: add a "map" subcommand, Eric Blake, 2013/07/18
[Qemu-devel] [PATCH 11/17] block: return get_block_status data and flags for formats, Paolo Bonzini, 2013/07/03