[RFC,V3,17/24] qcow2: Behave correctly when refcount reach 0 or 2^16.

Submitted by Benoît Canet on Nov. 26, 2012, 1:05 p.m.

Details

Message ID 1353935123-24199-18-git-send-email-benoit@irqsave.net
State New
Headers show

Commit Message

Benoît Canet Nov. 26, 2012, 1:05 p.m.
When refcount reach zero we destroy the hash on disk and remove it from GTree.
When refcount is at it's maximum value we mark the hash so it won't be loaded
at next startup and remove it from GTree.

Signed-off-by: Benoit Canet <benoit@irqsave.net>
---
 block/qcow2-dedup.c    |   46 ++++++++++++++++++++++++++++++++++++++++++++--
 block/qcow2-refcount.c |    6 ++++++
 block/qcow2.h          |    6 ++++++
 3 files changed, 56 insertions(+), 2 deletions(-)

Patch hide | download patch | download mbox

diff --git a/block/qcow2-dedup.c b/block/qcow2-dedup.c
index 80e9477..097d71b 100644
--- a/block/qcow2-dedup.c
+++ b/block/qcow2-dedup.c
@@ -743,8 +743,9 @@  void coroutine_fn qcow2_co_load_dedup_hashes(void *opaque)
             error_report("Failed to load deduplication hash.");
         }
 
-        /* if the hash is not null load it into the tree */
-        if (memcmp(hash, null_hash, HASH_LENGTH)) {
+        /* if the hash is not null load it into red black tree */
+        if (memcmp(hash, null_hash, HASH_LENGTH) &&
+            !(first_logical_offset & QCOW_FLAG_MAX_REFCOUNT)) {
             hash_node = qcow2_dedup_build_qcow_hash_node(hash,
                                                          i * s->cluster_sectors,
                                                          first_logical_offset);
@@ -809,3 +810,44 @@  void qcow2_dedup_close(BlockDriverState *bs)
     BDRVQcowState *s = bs->opaque;
     g_free(s->dedup_table);
 }
+
+static void qcow2_dedup_refcount_limit_reached(BlockDriverState *bs,
+                                        uint64_t cluster_index,
+                                        bool bottom)
+{
+    BDRVQcowState *s = bs->opaque;
+    QCowHashNode *hash_node;
+    uint64_t offset = cluster_index * s->cluster_sectors;
+
+    hash_node =  g_tree_lookup(s->dedup_tree_by_offset, &offset);
+    if (!hash_node) {
+        return;
+    }
+
+    if (bottom) {
+        /* clear the hash from disk */
+        memset(hash_node->hash, 0, HASH_LENGTH);
+    } else {
+        /* mark this hash so we won't load it anymore at startup */
+        hash_node->first_logical_offset |= QCOW_FLAG_MAX_REFCOUNT;
+    }
+    qcow2_dedup_read_write_hash(bs,
+                                &hash_node->hash,
+                                &hash_node->first_logical_offset,
+                                hash_node->offset,
+                                true);
+    g_tree_remove(s->dedup_tree_by_offset, &hash_node->offset);
+    g_tree_remove(s->dedup_tree_by_hash, hash_node->hash);
+}
+
+void qcow2_dedup_refcount_zero_reached(BlockDriverState *bs,
+                                      uint64_t cluster_index)
+{
+    qcow2_dedup_refcount_limit_reached(bs, cluster_index, true);
+}
+
+void qcow2_dedup_refcount_max_reached(BlockDriverState *bs,
+                                      uint64_t cluster_index)
+{
+    qcow2_dedup_refcount_limit_reached(bs, cluster_index, false);
+}
diff --git a/block/qcow2-refcount.c b/block/qcow2-refcount.c
index 7681001..efc1179 100644
--- a/block/qcow2-refcount.c
+++ b/block/qcow2-refcount.c
@@ -492,6 +492,12 @@  static int QEMU_WARN_UNUSED_RESULT update_refcount(BlockDriverState *bs,
             ret = -EINVAL;
             goto fail;
         }
+        if (s->has_dedup && refcount == 0) {
+            qcow2_dedup_refcount_zero_reached(bs, cluster_index);
+        }
+        if (s->has_dedup && refcount == 0xffff) {
+            qcow2_dedup_refcount_max_reached(bs, cluster_index);
+        }
         if (refcount == 0 && cluster_index < s->free_cluster_index) {
             s->free_cluster_index = cluster_index;
         }
diff --git a/block/qcow2.h b/block/qcow2.h
index 90dcdd9..8852696 100644
--- a/block/qcow2.h
+++ b/block/qcow2.h
@@ -60,6 +60,8 @@ 
 
 #define DEFAULT_CLUSTER_SIZE 65536
 
+/* indicate that this cluster refcount has reached its maximum value */
+#define QCOW_FLAG_MAX_REFCOUNT (1LL << 61)
 /* indicate that the hash structure is empty and miss offset */
 #define QCOW_FLAG_EMPTY   (1LL << 62)
 /* indicate that the cluster for this hash has QCOW_OFLAG_COPIED on disk */
@@ -409,5 +411,9 @@  int qcow2_dedup_grow_table(BlockDriverState *bs,
                            bool exact_size);
 int qcow2_dedup_init(BlockDriverState *bs);
 void qcow2_dedup_close(BlockDriverState *bs);
+void qcow2_dedup_refcount_zero_reached(BlockDriverState *bs,
+                                       uint64_t cluster_index);
+void qcow2_dedup_refcount_max_reached(BlockDriverState *bs,
+                                      uint64_t cluster_index);
 
 #endif