* [PATCH v2 0/2] Dump QCOW2 metadata
@ 2020-01-13 15:55 Andrey Shinkevich
2020-01-13 15:55 ` [PATCH v2 1/2] qcow2: introduce Qcow2Metadata structure Andrey Shinkevich
2020-01-13 15:55 ` [PATCH v2 2/2] qcow2: dump QCOW2 metadata Andrey Shinkevich
0 siblings, 2 replies; 3+ messages in thread
From: Andrey Shinkevich @ 2020-01-13 15:55 UTC (permalink / raw)
To: qemu-block
Cc: kwolf, vsementsov, armbru, qemu-devel, andrey.shinkevich, den, mreitz
The information about QCOW2 metadata allocations in an image ELF-file is
helpful for finding issues with the image data integrity.
v2: Descriptions of the new key option were added and the names of identifiers
were amended (suggested by Eric). Discussed in the email thread with ID
<1577447039-400109-1-git-send-email-andrey.shinkevich@virtuozzo.com>
Snapshots dump example:
$ sudo ./qemu-img check /.../.../harddisk.hdd -M --output=json
{
"image-end-offset": 24820842496,
"total-clusters": 153600,
"check-errors": 0,
"viscera": {
"refcount-table": {
"location": {
"offset": 3845128192,
"size": 1048576
}
},
"active-l1": {
"name": "L1 active table",
"location": {
"offset": 4194304,
"size": 16
},
"l2-list": [
{
"offset": 619708416,
"size": 1048576
},
{
"offset": 1156579328,
"size": 1048576
}
]
},
"qcow2-header": {
"location": {
"offset": 0,
"size": 1048576
},
"version": 3
},
"snapshot-table": {
"location": {
"offset": 648019968,
"size": 191
},
"l1-list": [
{
"name": "{3036f6c5-3a1f-44cb-af1f-653cc87fba04}",
"location": {
"offset": 14680064,
"size": 16
},
"l2-list": [
{
"offset": 3957325824,
"size": 1048576
},
{
"offset": 7025459200,
"size": 1048576
}
]
},
{
"name": "{0aa1a7d6-16ee-4b44-a515-b5ecc571c959}",
"location": {
"offset": 638582784,
"size": 16
},
"l2-list": [
{
"offset": 3957325824,
"size": 1048576
},
{
"offset": 7025459200,
"size": 1048576
}
]
}
]
}
},
"allocated-clusters": 22485,
"filename": "/.../.../harddisk.hdd",
"format": "qcow2",
"fragmented-clusters": 3549
}
Bitmaps dump example:
$ ./qemu-img check /home/disk -M --output=json
{
"image-end-offset": 1441792,
"total-clusters": 16,
"check-errors": 0,
"viscera": {
"refcount-table": {
"location": {
"offset": 65536,
"size": 65536
}
},
"active-l1": {
"name": "L1 active table",
"location": {
"offset": 196608,
"size": 8
},
"l2-list": [
{
"offset": 262144,
"size": 65536
}
]
},
"bitmaps": {
"bitmap-dir": {
"location": {
"offset": 1048576,
"size": 64
},
"dir-entries": [
{
"bitmap-table": {
"location": {
"offset": 589824,
"size": 8
},
"table-entries": [
{
"type": "all-zeros"
}
]
},
"bitmap-name": "bitmap-1"
},
{
"bitmap-table": {
"location": {
"offset": 983040,
"size": 8
},
"table-entries": [
{
"cluster": {
"offset": 655360,
"size": 65536
},
"type": "serialized"
}
]
},
"bitmap-name": "bitmap-2"
}
]
},
"nb-bitmaps": 2
},
"qcow2-header": {
"location": {
"offset": 0,
"size": 65536
},
"version": 3
}
},
"allocated-clusters": 12,
"filename": "/home/disk",
"format": "qcow2",
"fragmented-clusters": 2
}
Andrey Shinkevich (2):
qcow2: introduce Qcow2Metadata structure
qcow2: dump QCOW2 metadata
block/qcow2-bitmap.c | 54 ++++++++++++-
block/qcow2-refcount.c | 84 ++++++++++++++++----
block/qcow2.c | 30 +++++++
block/qcow2.h | 6 +-
include/block/block.h | 3 +-
qapi/block-core.json | 209 ++++++++++++++++++++++++++++++++++++++++++++++++-
qemu-img.c | 30 ++++++-
qemu-img.texi | 6 +-
8 files changed, 397 insertions(+), 25 deletions(-)
--
1.8.3.1
^ permalink raw reply [flat|nested] 3+ messages in thread
* [PATCH v2 1/2] qcow2: introduce Qcow2Metadata structure
2020-01-13 15:55 [PATCH v2 0/2] Dump QCOW2 metadata Andrey Shinkevich
@ 2020-01-13 15:55 ` Andrey Shinkevich
2020-01-13 15:55 ` [PATCH v2 2/2] qcow2: dump QCOW2 metadata Andrey Shinkevich
1 sibling, 0 replies; 3+ messages in thread
From: Andrey Shinkevich @ 2020-01-13 15:55 UTC (permalink / raw)
To: qemu-block
Cc: kwolf, vsementsov, armbru, qemu-devel, andrey.shinkevich, den, mreitz
The preliminary patch to provide an extendable structure for dumping
QCOW2 metadata allocations in image. The command line optional key is
introduced in the patch that follows.
Suggested-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Signed-off-by: Andrey Shinkevich <andrey.shinkevich@virtuozzo.com>
---
qapi/block-core.json | 209 ++++++++++++++++++++++++++++++++++++++++++++++++++-
1 file changed, 208 insertions(+), 1 deletion(-)
diff --git a/qapi/block-core.json b/qapi/block-core.json
index 7ff5e5e..fab7435 100644
--- a/qapi/block-core.json
+++ b/qapi/block-core.json
@@ -176,6 +176,209 @@
'*backing-image': 'ImageInfo',
'*format-specific': 'ImageInfoSpecific' } }
+
+##
+# @Qcow2Metadata:
+#
+# Encapsulates QCOW2 metadata information
+#
+# @qcow2-header: QCOW2 header info
+#
+# @active-l1: L1 active table info
+#
+# @refcount-table: refcount table info
+#
+# @crypt-header: encryption header info
+#
+# @bitmaps: bitmap tables info
+#
+# @snapshot-table: snapshot tables info
+#
+# Since: 5.0
+##
+{ 'struct': 'Qcow2Metadata',
+ 'data': { 'qcow2-header': 'Qcow2Header',
+ 'refcount-table': 'Qcow2RefcountTable',
+ 'active-l1': 'Qcow2L1Table',
+ '*crypt-header': 'Qcow2EncryptionHeader',
+ '*bitmaps': 'Qcow2Bitmaps',
+ '*snapshot-table': 'Qcow2SnapshotsTable' } }
+
+##
+# @Qcow2Header:
+#
+# QCOW2 header information
+#
+# @version: version number
+#
+# @location: header offset and size in image
+#
+# Since: 5.0
+##
+{ 'struct': 'Qcow2Header',
+ 'data': {'version': 'int',
+ 'location': 'Qcow2Allocation' } }
+
+##
+# @Qcow2EncryptionHeader:
+#
+# QCOW2 encryption header information
+#
+# @location: header offset and size in image
+#
+# Since: 5.0
+##
+{ 'struct': 'Qcow2EncryptionHeader',
+ 'data': {'location': 'Qcow2Allocation' } }
+
+##
+# @Qcow2RefcountTable:
+#
+# QCOW2 refcount table information
+#
+# @location: refcount table offset and size in image
+#
+# Since: 5.0
+##
+{ 'struct': 'Qcow2RefcountTable',
+ 'data': {'location': 'Qcow2Allocation' } }
+
+##
+# @Qcow2L1Table:
+#
+# L1 table information
+#
+# @l2-list: list of L2 table locations
+#
+# @location: L1 table offset and size in image
+#
+# @name: entity name the table relates to
+#
+# Since: 5.0
+##
+{ 'struct': 'Qcow2L1Table',
+ 'data': {'l2-list': ['Qcow2Allocation'],
+ 'location': 'Qcow2Allocation',
+ 'name': 'str'} }
+
+##
+# @Qcow2Allocation:
+#
+# QCOW2 data location in image
+#
+# @offset: data offset
+#
+# @size: data size
+#
+# Since: 5.0
+##
+{ 'struct': 'Qcow2Allocation',
+ 'data': {'offset': 'uint64', 'size': 'uint64' } }
+
+##
+# @Qcow2Bitmaps:
+#
+# QCOW2 bitmaps information
+#
+# @nb-bitmaps: the number of bitmaps contained in the image
+#
+# @bitmap-dir: bitmap directory information
+#
+# Since: 5.0
+##
+{ 'struct': 'Qcow2Bitmaps',
+ 'data': {'nb-bitmaps': 'int',
+ 'bitmap-dir': 'Qcow2BitmapDir' } }
+
+##
+# @Qcow2BitmapDir:
+#
+# QCOW2 bitmap directory information
+#
+# @dir-entries: list of bitmap directory entries
+#
+# @location: bitmap directory offset and size in image
+#
+# Since: 5.0
+##
+{ 'struct': 'Qcow2BitmapDir',
+ 'data': {'dir-entries': ['Qcow2BitmapDirectoryEntry'],
+ 'location': 'Qcow2Allocation' } }
+
+##
+# @Qcow2BitmapDirectoryEntry:
+#
+# QCOW2 bitmap directory entry information
+#
+# @bitmap-table: bitmap table offset and size in image
+#
+# Since: 5.0
+##
+{ 'struct': 'Qcow2BitmapDirectoryEntry',
+ 'data': {'bitmap-table': 'Qcow2BitmapTableInfo',
+ 'bitmap-name': 'str' } }
+
+##
+# @Qcow2BitmapTableInfo:
+#
+# QCOW2 bitmap table information
+#
+# @table-entries: list of bitmap table entries
+#
+# @location: bitmap table offset and size in image
+#
+# Since: 5.0
+##
+{ 'struct': 'Qcow2BitmapTableInfo',
+ 'data': {'table-entries': ['Qcow2BitmapTableInfoEntry'],
+ 'location': 'Qcow2Allocation' } }
+
+##
+# @Qcow2BitmapTableInfoEntry:
+#
+# QCOW2 bitmap table entry information
+#
+# @type: bitmap table entry type
+#
+# @cluster: bitmap table entry offset and size in image
+#
+# Since: 5.0
+##
+{ 'struct': 'Qcow2BitmapTableInfoEntry',
+ 'data': {'type': 'Qcow2BitmapTableInfoEntryType',
+ '*cluster': 'Qcow2Allocation' } }
+
+##
+# @Qcow2BitmapTableInfoEntryType:
+#
+# An enumeration of cluster types in bitmap table
+#
+# @all-zeroes: cluster should be read as all zeroes
+#
+# @all-ones: cluster should be read as all ones
+#
+# @serialized: cluster data are written on disk
+#
+# Since: 5.0
+##
+{ 'enum': 'Qcow2BitmapTableInfoEntryType',
+ 'data': ['all-zeroes', 'all-ones', 'serialized'] }
+
+##
+# @Qcow2SnapshotsTable:
+#
+# Snapshots table location in image file.
+#
+# @location: offset and size of snapshot table
+#
+# @l1-list: list of snapshots L1 tables
+#
+# Since: 5.0
+##
+{ 'struct': 'Qcow2SnapshotsTable',
+ 'data': {'location': 'Qcow2Allocation',
+ 'l1-list': ['Qcow2L1Table'] } }
+
##
# @ImageCheck:
#
@@ -215,6 +418,9 @@
# field is present if the driver for the image format
# supports it
#
+# @metadata: encapsulates QCOW2 tables allocation information (default: none,
+# turned on with the command line optional key; since 5.0)
+#
# Since: 1.4
#
##
@@ -223,7 +429,8 @@
'*image-end-offset': 'int', '*corruptions': 'int', '*leaks': 'int',
'*corruptions-fixed': 'int', '*leaks-fixed': 'int',
'*total-clusters': 'int', '*allocated-clusters': 'int',
- '*fragmented-clusters': 'int', '*compressed-clusters': 'int' } }
+ '*fragmented-clusters': 'int', '*compressed-clusters': 'int',
+ '*metadata': 'Qcow2Metadata' } }
##
# @MapEntry:
--
1.8.3.1
^ permalink raw reply related [flat|nested] 3+ messages in thread
* [PATCH v2 2/2] qcow2: dump QCOW2 metadata
2020-01-13 15:55 [PATCH v2 0/2] Dump QCOW2 metadata Andrey Shinkevich
2020-01-13 15:55 ` [PATCH v2 1/2] qcow2: introduce Qcow2Metadata structure Andrey Shinkevich
@ 2020-01-13 15:55 ` Andrey Shinkevich
1 sibling, 0 replies; 3+ messages in thread
From: Andrey Shinkevich @ 2020-01-13 15:55 UTC (permalink / raw)
To: qemu-block
Cc: kwolf, vsementsov, armbru, qemu-devel, andrey.shinkevich, den, mreitz
Let QEMU-IMG CHECK command show QCOW2 structure to inform a user about
metadata allocations on disk. Introduce '-M'('--dump-meta') key option.
Suggested-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Signed-off-by: Andrey Shinkevich <andrey.shinkevich@virtuozzo.com>
---
block/qcow2-bitmap.c | 54 +++++++++++++++++++++++++++++---
block/qcow2-refcount.c | 84 +++++++++++++++++++++++++++++++++++++++++---------
block/qcow2.c | 30 ++++++++++++++++++
block/qcow2.h | 6 ++--
include/block/block.h | 3 +-
qemu-img.c | 30 +++++++++++++++++-
qemu-img.texi | 6 +++-
7 files changed, 189 insertions(+), 24 deletions(-)
diff --git a/block/qcow2-bitmap.c b/block/qcow2-bitmap.c
index d41f5d0..15e035a 100644
--- a/block/qcow2-bitmap.c
+++ b/block/qcow2-bitmap.c
@@ -659,20 +659,29 @@ fail:
int qcow2_check_bitmaps_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
void **refcount_table,
- int64_t *refcount_table_size)
+ int64_t *refcount_table_size,
+ Qcow2Bitmaps *bitmaps)
{
int ret;
BDRVQcow2State *s = bs->opaque;
Qcow2BitmapList *bm_list;
Qcow2Bitmap *bm;
+ Qcow2BitmapDirectoryEntryList **pp_dir =
+ bitmaps ? &bitmaps->bitmap_dir->dir_entries : NULL;
if (s->nb_bitmaps == 0) {
return 0;
}
+ if (bitmaps) {
+ bitmaps->nb_bitmaps = s->nb_bitmaps;
+ }
+
ret = qcow2_inc_refcounts_imrt(bs, res, refcount_table, refcount_table_size,
s->bitmap_directory_offset,
- s->bitmap_directory_size);
+ s->bitmap_directory_size,
+ bitmaps ? bitmaps->bitmap_dir->location
+ : NULL);
if (ret < 0) {
return ret;
}
@@ -686,12 +695,28 @@ int qcow2_check_bitmaps_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
QSIMPLEQ_FOREACH(bm, bm_list, entry) {
uint64_t *bitmap_table = NULL;
+ Qcow2BitmapTableInfoEntryList **pp_table;
int i;
+ Qcow2BitmapDirectoryEntry *bmde = NULL;
+ if (bitmaps) {
+ bmde = g_new0(Qcow2BitmapDirectoryEntry, 1);
+ bmde->bitmap_name = g_strdup(bm->name);
+ bmde->bitmap_table = g_new0(Qcow2BitmapTableInfo, 1);
+ bmde->bitmap_table->location = g_new0(Qcow2Allocation, 1);
+ Qcow2BitmapDirectoryEntryList *obj =
+ g_new0(Qcow2BitmapDirectoryEntryList, 1);
+ obj->value = bmde;
+ *pp_dir = obj;
+ pp_dir = &obj->next;
+ }
+
ret = qcow2_inc_refcounts_imrt(bs, res,
refcount_table, refcount_table_size,
bm->table.offset,
- bm->table.size * sizeof(uint64_t));
+ bm->table.size * sizeof(uint64_t),
+ bmde ? bmde->bitmap_table->location
+ : NULL);
if (ret < 0) {
goto out;
}
@@ -702,6 +727,8 @@ int qcow2_check_bitmaps_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
goto out;
}
+ pp_table = bmde ? &bmde->bitmap_table->table_entries : NULL;
+
for (i = 0; i < bm->table.size; ++i) {
uint64_t entry = bitmap_table[i];
uint64_t offset = entry & BME_TABLE_ENTRY_OFFSET_MASK;
@@ -711,13 +738,32 @@ int qcow2_check_bitmaps_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
continue;
}
+ Qcow2BitmapTableInfoEntry *bmte = NULL;
+ if (bmde) {
+ bmte = g_new0(Qcow2BitmapTableInfoEntry, 1);
+ bmte->type = offset ?
+ QCOW2_BITMAP_TABLE_INFO_ENTRY_TYPE_SERIALIZED :
+ entry & BME_TABLE_ENTRY_FLAG_ALL_ONES;
+ if (offset) {
+ bmte->cluster = g_new0(Qcow2Allocation, 1);
+ }
+ bmte->has_cluster = !!(bmte->cluster);
+ Qcow2BitmapTableInfoEntryList *elem =
+ g_new0(Qcow2BitmapTableInfoEntryList, 1);
+ elem->value = bmte;
+ *pp_table = elem;
+ pp_table = &elem->next;
+ }
+
if (offset == 0) {
continue;
}
ret = qcow2_inc_refcounts_imrt(bs, res,
refcount_table, refcount_table_size,
- offset, s->cluster_size);
+ offset, s->cluster_size,
+ bmte && bmte->cluster ? bmte->cluster
+ : NULL);
if (ret < 0) {
g_free(bitmap_table);
goto out;
diff --git a/block/qcow2-refcount.c b/block/qcow2-refcount.c
index f67ac6b..f5444fc 100644
--- a/block/qcow2-refcount.c
+++ b/block/qcow2-refcount.c
@@ -1521,7 +1521,8 @@ static int realloc_refcount_array(BDRVQcow2State *s, void **array,
int qcow2_inc_refcounts_imrt(BlockDriverState *bs, BdrvCheckResult *res,
void **refcount_table,
int64_t *refcount_table_size,
- int64_t offset, int64_t size)
+ int64_t offset, int64_t size,
+ Qcow2Allocation *qcow2_alloc)
{
BDRVQcow2State *s = bs->opaque;
uint64_t start, last, cluster_offset, k, refcount;
@@ -1550,6 +1551,11 @@ int qcow2_inc_refcounts_imrt(BlockDriverState *bs, BdrvCheckResult *res,
return 0;
}
+ if (qcow2_alloc) {
+ qcow2_alloc->offset = offset;
+ qcow2_alloc->size = size;
+ }
+
start = start_of_cluster(s, offset);
last = start_of_cluster(s, offset + size - 1);
for(cluster_offset = start; cluster_offset <= last;
@@ -1643,7 +1649,7 @@ static int check_refcounts_l2(BlockDriverState *bs, BdrvCheckResult *res,
ret = qcow2_inc_refcounts_imrt(
bs, res, refcount_table, refcount_table_size,
l2_entry & QCOW2_COMPRESSED_SECTOR_MASK,
- nb_csectors * QCOW2_COMPRESSED_SECTOR_SIZE);
+ nb_csectors * QCOW2_COMPRESSED_SECTOR_SIZE, NULL);
if (ret < 0) {
goto fail;
}
@@ -1731,7 +1737,7 @@ static int check_refcounts_l2(BlockDriverState *bs, BdrvCheckResult *res,
if (!has_data_file(bs)) {
ret = qcow2_inc_refcounts_imrt(bs, res, refcount_table,
refcount_table_size,
- offset, s->cluster_size);
+ offset, s->cluster_size, NULL);
if (ret < 0) {
goto fail;
}
@@ -1769,17 +1775,20 @@ static int check_refcounts_l1(BlockDriverState *bs,
void **refcount_table,
int64_t *refcount_table_size,
int64_t l1_table_offset, int l1_size,
- int flags, BdrvCheckMode fix, bool active)
+ int flags, BdrvCheckMode fix, bool active,
+ Qcow2L1Table *l1t)
{
BDRVQcow2State *s = bs->opaque;
uint64_t *l1_table = NULL, l2_offset, l1_size2;
+ Qcow2AllocationList **plist = l1t ? &l1t->l2_list : NULL;
int i, ret;
l1_size2 = l1_size * sizeof(uint64_t);
/* Mark L1 table as used */
ret = qcow2_inc_refcounts_imrt(bs, res, refcount_table, refcount_table_size,
- l1_table_offset, l1_size2);
+ l1_table_offset, l1_size2,
+ l1t ? l1t->location : NULL);
if (ret < 0) {
goto fail;
}
@@ -1808,9 +1817,19 @@ static int check_refcounts_l1(BlockDriverState *bs,
if (l2_offset) {
/* Mark L2 table as used */
l2_offset &= L1E_OFFSET_MASK;
+
+ Qcow2Allocation *l2t = NULL;
+ if (l1t) {
+ l2t = g_new0(Qcow2Allocation, 1);
+ Qcow2AllocationList *obj = g_new0(Qcow2AllocationList, 1);
+ obj->value = l2t;
+ *plist = obj;
+ plist = &obj->next;
+ }
+
ret = qcow2_inc_refcounts_imrt(bs, res,
refcount_table, refcount_table_size,
- l2_offset, s->cluster_size);
+ l2_offset, s->cluster_size, l2t);
if (ret < 0) {
goto fail;
}
@@ -2047,7 +2066,7 @@ static int check_refblocks(BlockDriverState *bs, BdrvCheckResult *res,
res->corruptions_fixed++;
ret = qcow2_inc_refcounts_imrt(bs, res,
refcount_table, nb_clusters,
- offset, s->cluster_size);
+ offset, s->cluster_size, NULL);
if (ret < 0) {
return ret;
}
@@ -2066,7 +2085,7 @@ resize_fail:
if (offset != 0) {
ret = qcow2_inc_refcounts_imrt(bs, res, refcount_table, nb_clusters,
- offset, s->cluster_size);
+ offset, s->cluster_size, NULL);
if (ret < 0) {
return ret;
}
@@ -2093,6 +2112,9 @@ static int calculate_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
BDRVQcow2State *s = bs->opaque;
int64_t i;
QCowSnapshot *sn;
+ bool has_snapshots = res->metadata && res->metadata->snapshot_table;
+ Qcow2L1TableList **plist = has_snapshots ?
+ &res->metadata->snapshot_table->l1_list : NULL;
int ret;
if (!*refcount_table) {
@@ -2106,16 +2128,25 @@ static int calculate_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
}
/* header */
+ if (res->metadata) {
+ res->metadata->qcow2_header->version = s->qcow_version;
+ }
ret = qcow2_inc_refcounts_imrt(bs, res, refcount_table, nb_clusters,
- 0, s->cluster_size);
+ 0, s->cluster_size,
+ res->metadata ?
+ res->metadata->qcow2_header->location : NULL);
if (ret < 0) {
return ret;
}
/* current L1 table */
+ if (res->metadata) {
+ res->metadata->active_l1->name = g_strdup("L1 active table");
+ }
ret = check_refcounts_l1(bs, res, refcount_table, nb_clusters,
s->l1_table_offset, s->l1_size, CHECK_FRAG_INFO,
- fix, true);
+ fix, true,
+ res->metadata ? res->metadata->active_l1 : NULL);
if (ret < 0) {
return ret;
}
@@ -2143,15 +2174,30 @@ static int calculate_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
res->corruptions++;
continue;
}
+
+ Qcow2L1Table *l1t = NULL;
+ if (has_snapshots) {
+ l1t = g_new0(Qcow2L1Table, 1);
+ l1t->location = g_new0(Qcow2Allocation, 1);
+ l1t->name = g_strdup(sn->name);
+ Qcow2L1TableList *obj = g_new0(Qcow2L1TableList, 1);
+ obj->value = l1t;
+ *plist = obj;
+ plist = &obj->next;
+ }
+
ret = check_refcounts_l1(bs, res, refcount_table, nb_clusters,
sn->l1_table_offset, sn->l1_size, 0, fix,
- false);
+ false, l1t);
if (ret < 0) {
return ret;
}
}
ret = qcow2_inc_refcounts_imrt(bs, res, refcount_table, nb_clusters,
- s->snapshots_offset, s->snapshots_size);
+ s->snapshots_offset, s->snapshots_size,
+ has_snapshots ?
+ res->metadata->snapshot_table->location
+ : NULL);
if (ret < 0) {
return ret;
}
@@ -2159,7 +2205,10 @@ static int calculate_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
/* refcount data */
ret = qcow2_inc_refcounts_imrt(bs, res, refcount_table, nb_clusters,
s->refcount_table_offset,
- s->refcount_table_size * sizeof(uint64_t));
+ s->refcount_table_size * sizeof(uint64_t),
+ res->metadata ?
+ res->metadata->refcount_table->location
+ : NULL);
if (ret < 0) {
return ret;
}
@@ -2168,14 +2217,19 @@ static int calculate_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
if (s->crypto_header.length) {
ret = qcow2_inc_refcounts_imrt(bs, res, refcount_table, nb_clusters,
s->crypto_header.offset,
- s->crypto_header.length);
+ s->crypto_header.length,
+ res->metadata ?
+ res->metadata->crypt_header->location
+ : NULL);
if (ret < 0) {
return ret;
}
}
/* bitmaps */
- ret = qcow2_check_bitmaps_refcounts(bs, res, refcount_table, nb_clusters);
+ ret = qcow2_check_bitmaps_refcounts(bs, res, refcount_table, nb_clusters,
+ res->metadata ? res->metadata->bitmaps
+ : NULL);
if (ret < 0) {
return ret;
}
diff --git a/block/qcow2.c b/block/qcow2.c
index cef9d72..634b642 100644
--- a/block/qcow2.c
+++ b/block/qcow2.c
@@ -590,6 +590,7 @@ static int coroutine_fn qcow2_co_check_locked(BlockDriverState *bs,
BdrvCheckResult *result,
BdrvCheckMode fix)
{
+ BDRVQcow2State *s = bs->opaque;
BdrvCheckResult snapshot_res = {};
BdrvCheckResult refcount_res = {};
int ret;
@@ -602,6 +603,35 @@ static int coroutine_fn qcow2_co_check_locked(BlockDriverState *bs,
return ret;
}
+ if (fix & BDRV_DUMP_META) {
+ result->metadata = g_new0(Qcow2Metadata, 1);
+ result->metadata->qcow2_header = g_new0(Qcow2Header, 1);
+ result->metadata->qcow2_header->location = g_new0(Qcow2Allocation, 1);
+ result->metadata->active_l1 = g_new0(Qcow2L1Table, 1);
+ result->metadata->active_l1->location = g_new0(Qcow2Allocation, 1);
+ result->metadata->refcount_table = g_new0(Qcow2RefcountTable, 1);
+ result->metadata->refcount_table->location = g_new0(Qcow2Allocation, 1);
+
+ refcount_res.metadata = result->metadata;
+
+ if (s->crypto_header.length) {
+ result->metadata->crypt_header = g_new0(Qcow2EncryptionHeader, 1);
+ result->metadata->crypt_header->location =
+ g_new0(Qcow2Allocation, 1);
+ }
+ if (s->nb_bitmaps) {
+ result->metadata->bitmaps = g_new0(Qcow2Bitmaps, 1);
+ result->metadata->bitmaps->bitmap_dir = g_new0(Qcow2BitmapDir, 1);
+ result->metadata->bitmaps->bitmap_dir->location =
+ g_new0(Qcow2Allocation, 1);
+ }
+ if (s->nb_snapshots) {
+ result->metadata->snapshot_table = g_new0(Qcow2SnapshotsTable, 1);
+ result->metadata->snapshot_table->location =
+ g_new0(Qcow2Allocation, 1);
+ }
+ }
+
ret = qcow2_check_refcounts(bs, &refcount_res, fix);
qcow2_add_check_result(result, &refcount_res, true);
if (ret < 0) {
diff --git a/block/qcow2.h b/block/qcow2.h
index 0942126..8d615e2 100644
--- a/block/qcow2.h
+++ b/block/qcow2.h
@@ -662,7 +662,8 @@ int qcow2_pre_write_overlap_check(BlockDriverState *bs, int ign, int64_t offset,
int qcow2_inc_refcounts_imrt(BlockDriverState *bs, BdrvCheckResult *res,
void **refcount_table,
int64_t *refcount_table_size,
- int64_t offset, int64_t size);
+ int64_t offset, int64_t size,
+ Qcow2Allocation *qcow2_alloc);
int qcow2_change_refcount_order(BlockDriverState *bs, int refcount_order,
BlockDriverAmendStatusCB *status_cb,
@@ -751,7 +752,8 @@ void qcow2_cache_discard(Qcow2Cache *c, void *table);
/* qcow2-bitmap.c functions */
int qcow2_check_bitmaps_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
void **refcount_table,
- int64_t *refcount_table_size);
+ int64_t *refcount_table_size,
+ Qcow2Bitmaps *bitmaps);
bool qcow2_load_dirty_bitmaps(BlockDriverState *bs, Error **errp);
Qcow2BitmapInfoList *qcow2_get_bitmap_info_list(BlockDriverState *bs,
Error **errp);
diff --git a/include/block/block.h b/include/block/block.h
index e9dcfef..cfc9d68 100644
--- a/include/block/block.h
+++ b/include/block/block.h
@@ -374,7 +374,6 @@ int bdrv_freeze_backing_chain(BlockDriverState *bs, BlockDriverState *base,
Error **errp);
void bdrv_unfreeze_backing_chain(BlockDriverState *bs, BlockDriverState *base);
-
typedef struct BdrvCheckResult {
int corruptions;
int leaks;
@@ -383,11 +382,13 @@ typedef struct BdrvCheckResult {
int leaks_fixed;
int64_t image_end_offset;
BlockFragInfo bfi;
+ Qcow2Metadata *metadata;
} BdrvCheckResult;
typedef enum {
BDRV_FIX_LEAKS = 1,
BDRV_FIX_ERRORS = 2,
+ BDRV_DUMP_META = 4,
} BdrvCheckMode;
int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix);
diff --git a/qemu-img.c b/qemu-img.c
index 6233b8c..84e9f56 100644
--- a/qemu-img.c
+++ b/qemu-img.c
@@ -173,6 +173,7 @@ static void QEMU_NORETURN help(void)
" '-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"
" hiding corruption that has already occurred.\n"
+ " '-M' Dump qcow2 metadata to stdout in JSON format.\n"
"\n"
"Parameters to convert subcommand:\n"
" '-m' specifies how many coroutines work in parallel during the convert\n"
@@ -659,6 +660,15 @@ static int collect_image_check(BlockDriverState *bs,
check->has_fragmented_clusters = result.bfi.fragmented_clusters != 0;
check->compressed_clusters = result.bfi.compressed_clusters;
check->has_compressed_clusters = result.bfi.compressed_clusters != 0;
+ check->metadata = result.metadata;
+ check->has_metadata = !!(result.metadata);
+
+ if (check->has_metadata) {
+ check->metadata->has_crypt_header = !!(check->metadata->crypt_header);
+ check->metadata->has_bitmaps = !!(check->metadata->bitmaps);
+ check->metadata->has_snapshot_table =
+ !!(check->metadata->snapshot_table);
+ }
return 0;
}
@@ -701,9 +711,10 @@ static int img_check(int argc, char **argv)
{"object", required_argument, 0, OPTION_OBJECT},
{"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
{"force-share", no_argument, 0, 'U'},
+ {"dump-meta", no_argument, 0, 'M'},
{0, 0, 0, 0}
};
- c = getopt_long(argc, argv, ":hf:r:T:qU",
+ c = getopt_long(argc, argv, ":hf:Mr:T:qU",
long_options, &option_index);
if (c == -1) {
break;
@@ -721,6 +732,9 @@ static int img_check(int argc, char **argv)
case 'f':
fmt = optarg;
break;
+ case 'M':
+ fix |= BDRV_DUMP_META;
+ break;
case 'r':
flags |= BDRV_O_RDWR;
@@ -772,6 +786,11 @@ static int img_check(int argc, char **argv)
return 1;
}
+ if ((fix & BDRV_DUMP_META) && output_format != OFORMAT_JSON) {
+ error_report("Metadata output is in JSON format only");
+ return 1;
+ }
+
if (qemu_opts_foreach(&qemu_object_opts,
user_creatable_add_opts_foreach,
qemu_img_object_print_help, &error_fatal)) {
@@ -792,6 +811,15 @@ static int img_check(int argc, char **argv)
bs = blk_bs(blk);
check = g_new0(ImageCheck, 1);
+
+ if (fix & BDRV_DUMP_META) {
+ if (strcmp(bs->drv->format_name, "qcow2")) {
+ error_report("Metadata output supported for QCOW2 format only");
+ ret = -ENOTSUP;
+ goto fail;
+ }
+ }
+
ret = collect_image_check(bs, check, filename, fmt, fix);
if (ret == -ENOTSUP) {
diff --git a/qemu-img.texi b/qemu-img.texi
index b5156d6..080e46a 100644
--- a/qemu-img.texi
+++ b/qemu-img.texi
@@ -230,7 +230,7 @@ specified as well.
For write tests, by default a buffer filled with zeros is written. This can be
overridden with a pattern byte specified by @var{pattern}.
-@item check [--object @var{objectdef}] [--image-opts] [-q] [-f @var{fmt}] [--output=@var{ofmt}] [-r [leaks | all]] [-T @var{src_cache}] [-U] @var{filename}
+@item check [--object @var{objectdef}] [--image-opts] [-M] [-q] [-f @var{fmt}] [--output=@var{ofmt}] [-r [leaks | all]] [-T @var{src_cache}] [-U] @var{filename}
Perform a consistency check on the disk image @var{filename}. The command can
output in the format @var{ofmt} which is either @code{human} or @code{json}.
@@ -241,6 +241,10 @@ during the check. @code{-r leaks} repairs only cluster leaks, whereas
@code{-r all} fixes all kinds of errors, with a higher risk of choosing the
wrong fix or hiding corruption that has already occurred.
+If @code{-M} is specified, qemu-img dumps metadata allocations in the image.
+This option works with @code{json} format output and is effective for the
+@code{qcow2} format only.
+
Only the formats @code{qcow2}, @code{qed} and @code{vdi} support
consistency checks.
--
1.8.3.1
^ permalink raw reply related [flat|nested] 3+ messages in thread
end of thread, other threads:[~2020-01-13 15:58 UTC | newest]
Thread overview: 3+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2020-01-13 15:55 [PATCH v2 0/2] Dump QCOW2 metadata Andrey Shinkevich
2020-01-13 15:55 ` [PATCH v2 1/2] qcow2: introduce Qcow2Metadata structure Andrey Shinkevich
2020-01-13 15:55 ` [PATCH v2 2/2] qcow2: dump QCOW2 metadata Andrey Shinkevich
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.