From 2e86e4a584cd9054a99d6bb8d3d4d7e8878bff4a Mon Sep 17 00:00:00 2001

From: Kevin Wolf <kwolf@redhat.com>

Date: Mon, 9 Sep 2013 14:28:00 +0200

Subject: [PATCH 09/38] qcow2: Add refcount update reason to all callers

RH-Author: Kevin Wolf <kwolf@redhat.com>

Message-id: <1378736903-18489-10-git-send-email-kwolf@redhat.com>

Patchwork-id: 54198

O-Subject: [RHEL-7.0 qemu-kvm PATCH 09/32] qcow2: Add refcount update reason to all callers

Bugzilla: 1005818

RH-Acked-by: Fam Zheng <famz@redhat.com>

RH-Acked-by: Max Reitz <mreitz@redhat.com>

RH-Acked-by: Miroslav Rezanina <mrezanin@redhat.com>

Bugzilla: 1005818

This adds a refcount update reason to all callers of update_refcounts(),

so that a follow-up patch can use this information to decide whether

clusters that reach a refcount of 0 should be discarded in the image

file.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>

(cherry picked from commit 6cfcb9b8b91d303ab51b78623f2299b5288d2d51)

Signed-off-by: Kevin Wolf <kwolf@redhat.com>

---

 block/qcow2-cluster.c  | 19 +++++++++++------

 block/qcow2-refcount.c | 55 +++++++++++++++++++++++++++++++-------------------

 block/qcow2-snapshot.c |  6 ++++--

 block/qcow2.c          |  3 ++-

 block/qcow2.h          | 16 ++++++++++++---

 5 files changed, 66 insertions(+), 33 deletions(-)

Signed-off-by: Miroslav Rezanina <mrezanin@redhat.com>

---

 block/qcow2-cluster.c  |   19 +++++++++++-----

 block/qcow2-refcount.c |   55 +++++++++++++++++++++++++++++------------------

 block/qcow2-snapshot.c |    6 +++-

 block/qcow2.c          |    3 +-

 block/qcow2.h          |   16 +++++++++++--

 5 files changed, 66 insertions(+), 33 deletions(-)

diff --git a/block/qcow2-cluster.c b/block/qcow2-cluster.c

index 76f30e5..3191d6b 100644

--- a/block/qcow2-cluster.c

+++ b/block/qcow2-cluster.c

@@ -98,14 +98,16 @@ int qcow2_grow_l1_table(BlockDriverState *bs, uint64_t min_size,

         goto fail;

     }

     g_free(s->l1_table);

-    qcow2_free_clusters(bs, s->l1_table_offset, s->l1_size * sizeof(uint64_t));

+    qcow2_free_clusters(bs, s->l1_table_offset, s->l1_size * sizeof(uint64_t),

+                        QCOW2_DISCARD_OTHER);

     s->l1_table_offset = new_l1_table_offset;

     s->l1_table = new_l1_table;

     s->l1_size = new_l1_size;

     return 0;

  fail:

     g_free(new_l1_table);

-    qcow2_free_clusters(bs, new_l1_table_offset, new_l1_size2);

+    qcow2_free_clusters(bs, new_l1_table_offset, new_l1_size2,

+                        QCOW2_DISCARD_OTHER);

     return ret;

 }

@@ -548,7 +550,8 @@ static int get_cluster_table(BlockDriverState *bs, uint64_t offset,

         /* Then decrease the refcount of the old table */

         if (l2_offset) {

-            qcow2_free_clusters(bs, l2_offset, s->l2_size * sizeof(uint64_t));

+            qcow2_free_clusters(bs, l2_offset, s->l2_size * sizeof(uint64_t),

+                                QCOW2_DISCARD_OTHER);

         }

     }

@@ -715,10 +718,14 @@ int qcow2_alloc_cluster_link_l2(BlockDriverState *bs, QCowL2Meta *m)

     /*

      * If this was a COW, we need to decrease the refcount of the old cluster.

      * Also flush bs->file to get the right order for L2 and refcount update.

+     *

+     * Don't discard clusters that reach a refcount of 0 (e.g. compressed

+     * clusters), the next write will reuse them anyway.

      */

     if (j != 0) {

         for (i = 0; i < j; i++) {

-            qcow2_free_any_clusters(bs, be64_to_cpu(old_cluster[i]), 1);

+            qcow2_free_any_clusters(bs, be64_to_cpu(old_cluster[i]), 1,

+                                    QCOW2_DISCARD_NEVER);

         }

     }

@@ -1339,7 +1346,7 @@ static int discard_single_l2(BlockDriverState *bs, uint64_t offset,

         l2_table[l2_index + i] = cpu_to_be64(0);

         /* Then decrease the refcount */

-        qcow2_free_any_clusters(bs, old_offset, 1);

+        qcow2_free_any_clusters(bs, old_offset, 1, QCOW2_DISCARD_REQUEST);

     }

     ret = qcow2_cache_put(bs, s->l2_table_cache, (void**) &l2_table);

@@ -1415,7 +1422,7 @@ static int zero_single_l2(BlockDriverState *bs, uint64_t offset,

         qcow2_cache_entry_mark_dirty(s->l2_table_cache, l2_table);

         if (old_offset & QCOW_OFLAG_COMPRESSED) {

             l2_table[l2_index + i] = cpu_to_be64(QCOW_OFLAG_ZERO);

-            qcow2_free_any_clusters(bs, old_offset, 1);

+            qcow2_free_any_clusters(bs, old_offset, 1, QCOW2_DISCARD_REQUEST);

         } else {

             l2_table[l2_index + i] |= cpu_to_be64(QCOW_OFLAG_ZERO);

         }

diff --git a/block/qcow2-refcount.c b/block/qcow2-refcount.c

index b32738f..6d35e49 100644

--- a/block/qcow2-refcount.c

+++ b/block/qcow2-refcount.c

@@ -29,7 +29,7 @@

 static int64_t alloc_clusters_noref(BlockDriverState *bs, int64_t size);

 static int QEMU_WARN_UNUSED_RESULT update_refcount(BlockDriverState *bs,

                             int64_t offset, int64_t length,

-                            int addend);

+                            int addend, enum qcow2_discard_type type);

 /*********************************************************/

@@ -235,7 +235,8 @@ static int alloc_refcount_block(BlockDriverState *bs,

     } else {

         /* Described somewhere else. This can recurse at most twice before we

          * arrive at a block that describes itself. */

-        ret = update_refcount(bs, new_block, s->cluster_size, 1);

+        ret = update_refcount(bs, new_block, s->cluster_size, 1,

+                              QCOW2_DISCARD_NEVER);

         if (ret < 0) {

             goto fail_block;

         }

@@ -399,7 +400,8 @@ static int alloc_refcount_block(BlockDriverState *bs,

     /* Free old table. Remember, we must not change free_cluster_index */

     uint64_t old_free_cluster_index = s->free_cluster_index;

-    qcow2_free_clusters(bs, old_table_offset, old_table_size * sizeof(uint64_t));

+    qcow2_free_clusters(bs, old_table_offset, old_table_size * sizeof(uint64_t),

+                        QCOW2_DISCARD_OTHER);

     s->free_cluster_index = old_free_cluster_index;

     ret = load_refcount_block(bs, new_block, (void**) refcount_block);

@@ -420,7 +422,7 @@ fail_block:

 /* XXX: cache several refcount block clusters ? */

 static int QEMU_WARN_UNUSED_RESULT update_refcount(BlockDriverState *bs,

-    int64_t offset, int64_t length, int addend)

+    int64_t offset, int64_t length, int addend, enum qcow2_discard_type type)

 {

     BDRVQcowState *s = bs->opaque;

     int64_t start, last, cluster_offset;

@@ -506,7 +508,8 @@ fail:

      */

     if (ret < 0) {

         int dummy;

-        dummy = update_refcount(bs, offset, cluster_offset - offset, -addend);

+        dummy = update_refcount(bs, offset, cluster_offset - offset, -addend,

+                                QCOW2_DISCARD_NEVER);

         (void)dummy;

     }

@@ -522,12 +525,14 @@ fail:

  */

 static int update_cluster_refcount(BlockDriverState *bs,

                                    int64_t cluster_index,

-                                   int addend)

+                                   int addend,

+                                   enum qcow2_discard_type type)

 {

     BDRVQcowState *s = bs->opaque;

     int ret;

-    ret = update_refcount(bs, cluster_index << s->cluster_bits, 1, addend);

+    ret = update_refcount(bs, cluster_index << s->cluster_bits, 1, addend,

+                          type);

     if (ret < 0) {

         return ret;

     }

@@ -579,7 +584,7 @@ int64_t qcow2_alloc_clusters(BlockDriverState *bs, int64_t size)

         return offset;

     }

-    ret = update_refcount(bs, offset, size, 1);

+    ret = update_refcount(bs, offset, size, 1, QCOW2_DISCARD_NEVER);

     if (ret < 0) {

         return ret;

     }

@@ -611,7 +616,8 @@ int qcow2_alloc_clusters_at(BlockDriverState *bs, uint64_t offset,

     old_free_cluster_index = s->free_cluster_index;

     s->free_cluster_index = cluster_index + i;

-    ret = update_refcount(bs, offset, i << s->cluster_bits, 1);

+    ret = update_refcount(bs, offset, i << s->cluster_bits, 1,

+                          QCOW2_DISCARD_NEVER);

     if (ret < 0) {

         return ret;

     }

@@ -649,7 +655,8 @@ int64_t qcow2_alloc_bytes(BlockDriverState *bs, int size)

         if (free_in_cluster == 0)

             s->free_byte_offset = 0;

         if ((offset & (s->cluster_size - 1)) != 0)

-            update_cluster_refcount(bs, offset >> s->cluster_bits, 1);

+            update_cluster_refcount(bs, offset >> s->cluster_bits, 1,

+                                    QCOW2_DISCARD_NEVER);

     } else {

         offset = qcow2_alloc_clusters(bs, s->cluster_size);

         if (offset < 0) {

@@ -659,7 +666,8 @@ int64_t qcow2_alloc_bytes(BlockDriverState *bs, int size)

         if ((cluster_offset + s->cluster_size) == offset) {

             /* we are lucky: contiguous data */

             offset = s->free_byte_offset;

-            update_cluster_refcount(bs, offset >> s->cluster_bits, 1);

+            update_cluster_refcount(bs, offset >> s->cluster_bits, 1,

+                                    QCOW2_DISCARD_NEVER);

             s->free_byte_offset += size;

         } else {

             s->free_byte_offset = offset;

@@ -676,12 +684,13 @@ int64_t qcow2_alloc_bytes(BlockDriverState *bs, int size)

 }

 void qcow2_free_clusters(BlockDriverState *bs,

-                          int64_t offset, int64_t size)

+                          int64_t offset, int64_t size,

+                          enum qcow2_discard_type type)

 {

     int ret;

     BLKDBG_EVENT(bs->file, BLKDBG_CLUSTER_FREE);

-    ret = update_refcount(bs, offset, size, -1);

+    ret = update_refcount(bs, offset, size, -1, type);

     if (ret < 0) {

         fprintf(stderr, "qcow2_free_clusters failed: %s\n", strerror(-ret));

         /* TODO Remember the clusters to free them later and avoid leaking */

@@ -692,8 +701,8 @@ void qcow2_free_clusters(BlockDriverState *bs,

  * Free a cluster using its L2 entry (handles clusters of all types, e.g.

  * normal cluster, compressed cluster, etc.)

  */

-void qcow2_free_any_clusters(BlockDriverState *bs,

-    uint64_t l2_entry, int nb_clusters)

+void qcow2_free_any_clusters(BlockDriverState *bs, uint64_t l2_entry,

+                             int nb_clusters, enum qcow2_discard_type type)

 {

     BDRVQcowState *s = bs->opaque;

@@ -705,12 +714,12 @@ void qcow2_free_any_clusters(BlockDriverState *bs,

                            s->csize_mask) + 1;

             qcow2_free_clusters(bs,

                 (l2_entry & s->cluster_offset_mask) & ~511,

-                nb_csectors * 512);

+                nb_csectors * 512, type);

         }

         break;

     case QCOW2_CLUSTER_NORMAL:

         qcow2_free_clusters(bs, l2_entry & L2E_OFFSET_MASK,

-                            nb_clusters << s->cluster_bits);

+                            nb_clusters << s->cluster_bits, type);

         break;

     case QCOW2_CLUSTER_UNALLOCATED:

     case QCOW2_CLUSTER_ZERO:

@@ -785,7 +794,8 @@ int qcow2_update_snapshot_refcount(BlockDriverState *bs,

                             int ret;

                             ret = update_refcount(bs,

                                 (offset & s->cluster_offset_mask) & ~511,

-                                nb_csectors * 512, addend);

+                                nb_csectors * 512, addend,

+                                QCOW2_DISCARD_SNAPSHOT);

                             if (ret < 0) {

                                 goto fail;

                             }

@@ -795,7 +805,8 @@ int qcow2_update_snapshot_refcount(BlockDriverState *bs,

                     } else {

                         uint64_t cluster_index = (offset & L2E_OFFSET_MASK) >> s->cluster_bits;

                         if (addend != 0) {

-                            refcount = update_cluster_refcount(bs, cluster_index, addend);

+                            refcount = update_cluster_refcount(bs, cluster_index, addend,

+                                                               QCOW2_DISCARD_SNAPSHOT);

                         } else {

                             refcount = get_refcount(bs, cluster_index);

                         }

@@ -827,7 +838,8 @@ int qcow2_update_snapshot_refcount(BlockDriverState *bs,

             if (addend != 0) {

-                refcount = update_cluster_refcount(bs, l2_offset >> s->cluster_bits, addend);

+                refcount = update_cluster_refcount(bs, l2_offset >> s->cluster_bits, addend,

+                                                   QCOW2_DISCARD_SNAPSHOT);

             } else {

                 refcount = get_refcount(bs, l2_offset >> s->cluster_bits);

             }

@@ -1253,7 +1265,8 @@ int qcow2_check_refcounts(BlockDriverState *bs, BdrvCheckResult *res,

             if (num_fixed) {

                 ret = update_refcount(bs, i << s->cluster_bits, 1,

-                                      refcount2 - refcount1);

+                                      refcount2 - refcount1,

+                                      QCOW2_DISCARD_ALWAYS);

                 if (ret >= 0) {

                     (*num_fixed)++;

                     continue;

diff --git a/block/qcow2-snapshot.c b/block/qcow2-snapshot.c

index 992a5c8..0caac90 100644

--- a/block/qcow2-snapshot.c

+++ b/block/qcow2-snapshot.c

@@ -262,7 +262,8 @@ static int qcow2_write_snapshots(BlockDriverState *bs)

     }

     /* free the old snapshot table */

-    qcow2_free_clusters(bs, s->snapshots_offset, s->snapshots_size);

+    qcow2_free_clusters(bs, s->snapshots_offset, s->snapshots_size,

+                        QCOW2_DISCARD_SNAPSHOT);

     s->snapshots_offset = snapshots_offset;

     s->snapshots_size = snapshots_size;

     return 0;

@@ -569,7 +570,8 @@ int qcow2_snapshot_delete(BlockDriverState *bs, const char *snapshot_id)

     if (ret < 0) {

         return ret;

     }

-    qcow2_free_clusters(bs, sn.l1_table_offset, sn.l1_size * sizeof(uint64_t));

+    qcow2_free_clusters(bs, sn.l1_table_offset, sn.l1_size * sizeof(uint64_t),

+                        QCOW2_DISCARD_SNAPSHOT);

     /* must update the copied flag on the current cluster offsets */

     ret = qcow2_update_snapshot_refcount(bs, s->l1_table_offset, s->l1_size, 0);

diff --git a/block/qcow2.c b/block/qcow2.c

index 0fa5cb2..e28ea47 100644

--- a/block/qcow2.c

+++ b/block/qcow2.c

@@ -1196,7 +1196,8 @@ static int preallocate(BlockDriverState *bs)

         ret = qcow2_alloc_cluster_link_l2(bs, meta);

         if (ret < 0) {

-            qcow2_free_any_clusters(bs, meta->alloc_offset, meta->nb_clusters);

+            qcow2_free_any_clusters(bs, meta->alloc_offset, meta->nb_clusters,

+                                    QCOW2_DISCARD_NEVER);

             return ret;

         }

diff --git a/block/qcow2.h b/block/qcow2.h

index 6959c6a..64a6479 100644

--- a/block/qcow2.h

+++ b/block/qcow2.h

@@ -129,6 +129,15 @@ enum {

     QCOW2_COMPAT_FEAT_MASK            = QCOW2_COMPAT_LAZY_REFCOUNTS,

 };

+enum qcow2_discard_type {

+    QCOW2_DISCARD_NEVER = 0,

+    QCOW2_DISCARD_ALWAYS,

+    QCOW2_DISCARD_REQUEST,

+    QCOW2_DISCARD_SNAPSHOT,

+    QCOW2_DISCARD_OTHER,

+    QCOW2_DISCARD_MAX

+};

+

 typedef struct Qcow2Feature {

     uint8_t type;

     uint8_t bit;

@@ -349,9 +358,10 @@ int qcow2_alloc_clusters_at(BlockDriverState *bs, uint64_t offset,

     int nb_clusters);

 int64_t qcow2_alloc_bytes(BlockDriverState *bs, int size);

 void qcow2_free_clusters(BlockDriverState *bs,

-    int64_t offset, int64_t size);

-void qcow2_free_any_clusters(BlockDriverState *bs,

-    uint64_t cluster_offset, int nb_clusters);

+                          int64_t offset, int64_t size,

+                          enum qcow2_discard_type type);

+void qcow2_free_any_clusters(BlockDriverState *bs, uint64_t l2_entry,

+                             int nb_clusters, enum qcow2_discard_type type);

 int qcow2_update_snapshot_refcount(BlockDriverState *bs,

     int64_t l1_table_offset, int l1_size, int addend);

-- 

1.7.1