diff --git a/block/qcow2-refcount.c b/block/qcow2-refcount.c
index 5e3f915..692f3fb 100644
--- a/block/qcow2-refcount.c
+++ b/block/qcow2-refcount.c
@@ -27,9 +27,6 @@
 #include "block/qcow2.h"
 
 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);
 
 
 /*********************************************************/
@@ -188,10 +185,11 @@ static int alloc_refcount_block(BlockDriverState *bs,
      *   recursion. Instead we must place the refcount blocks in a way that
      *   they can describe them themselves.
      *
-     * - We need to consider that at this point we are inside update_refcounts
-     *   and doing the initial refcount increase. This means that some clusters
-     *   have already been allocated by the caller, but their refcount isn't
-     *   accurate yet. free_cluster_index tells us where this allocation ends
+     * - We need to consider that at this point we are inside
+     *   qcow2_update_refcounts and doing the initial refcount increase.
+     *   This means that some clusters have already been allocated by the
+     *   caller, but their refcount isn't accurate yet.
+     *   free_cluster_index tells us where this allocation ends
      *   as long as we don't overwrite it by freeing clusters.
      *
      * - alloc_clusters_noref and qcow2_free_clusters may load a different
@@ -232,7 +230,7 @@ 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 = qcow2_update_refcount(bs, new_block, s->cluster_size, 1);
         if (ret < 0) {
             goto fail_block;
         }
@@ -240,7 +238,7 @@ static int alloc_refcount_block(BlockDriverState *bs,
         bdrv_flush(bs->file);
 
         /* Initialize the new refcount block only after updating its refcount,
-         * update_refcount uses the refcount cache itself */
+         * qcow2_update_refcount uses the refcount cache itself */
         ret = qcow2_cache_get_empty(bs, s->refcount_block_cache, new_block,
             (void**) refcount_block);
         if (ret < 0) {
@@ -412,7 +410,7 @@ fail_block:
 }
 
 /* XXX: cache several refcount block clusters ? */
-static int QEMU_WARN_UNUSED_RESULT update_refcount(BlockDriverState *bs,
+int QEMU_WARN_UNUSED_RESULT qcow2_update_refcount(BlockDriverState *bs,
     int64_t offset, int64_t length, int addend)
 {
     BDRVQcowState *s = bs->opaque;
@@ -422,8 +420,8 @@ static int QEMU_WARN_UNUSED_RESULT update_refcount(BlockDriverState *bs,
     int ret;
 
 #ifdef DEBUG_ALLOC2
-    fprintf(stderr, "update_refcount: offset=%" PRId64 " size=%" PRId64 " addend=%d\n",
-           offset, length, addend);
+    fprintf(stderr, "qcow2_update_refcount: offset=%" PRId64
+           " size=%" PRId64 " addend=%d\n", offset, length, addend);
 #endif
     if (length < 0) {
         return -EINVAL;
@@ -499,7 +497,8 @@ fail:
      */
     if (ret < 0) {
         int dummy;
-        dummy = update_refcount(bs, offset, cluster_offset - offset, -addend);
+        dummy = qcow2_update_refcount(bs, offset,
+                                      cluster_offset - offset, -addend);
         (void)dummy;
     }
 
@@ -520,7 +519,8 @@ static int update_cluster_refcount(BlockDriverState *bs,
     BDRVQcowState *s = bs->opaque;
     int ret;
 
-    ret = update_refcount(bs, cluster_index << s->cluster_bits, 1, addend);
+    ret = qcow2_update_refcount(bs, cluster_index << s->cluster_bits,
+                                1, addend);
     if (ret < 0) {
         return ret;
     }
@@ -574,7 +574,7 @@ int64_t qcow2_alloc_clusters(BlockDriverState *bs, int64_t size)
         return offset;
     }
 
-    ret = update_refcount(bs, offset, size, 1);
+    ret = qcow2_update_refcount(bs, offset, size, 1);
     if (ret < 0) {
         return ret;
     }
@@ -606,7 +606,7 @@ 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 = qcow2_update_refcount(bs, offset, i << s->cluster_bits, 1);
     if (ret < 0) {
         return ret;
     }
@@ -672,7 +672,7 @@ void qcow2_free_clusters(BlockDriverState *bs,
     int ret;
 
     BLKDBG_EVENT(bs->file, BLKDBG_CLUSTER_FREE);
-    ret = update_refcount(bs, offset, size, -1);
+    ret = qcow2_update_refcount(bs, offset, size, -1);
     if (ret < 0) {
         fprintf(stderr, "qcow2_free_clusters failed: %s\n", strerror(-ret));
         /* TODO Remember the clusters to free them later and avoid leaking */
@@ -779,7 +779,7 @@ int qcow2_update_snapshot_refcount(BlockDriverState *bs,
                                        s->csize_mask) + 1;
                         if (addend != 0) {
                             int ret;
-                            ret = update_refcount(bs,
+                            ret = qcow2_update_refcount(bs,
                                 (offset & s->cluster_offset_mask) & ~511,
                                 nb_csectors * 512, addend);
                             if (ret < 0) {
@@ -1213,7 +1213,7 @@ int qcow2_check_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
                    i, refcount1, refcount2);
 
             if (num_fixed) {
-                ret = update_refcount(bs, i << s->cluster_bits, 1,
+                ret = qcow2_update_refcount(bs, i << s->cluster_bits, 1,
                                       refcount2 - refcount1);
                 if (ret >= 0) {
                     (*num_fixed)++;
diff --git a/block/qcow2.h b/block/qcow2.h
index 6e867c8..77c0f2b 100644
--- a/block/qcow2.h
+++ b/block/qcow2.h
@@ -292,7 +292,9 @@ int qcow2_update_header(BlockDriverState *bs);
 /* qcow2-refcount.c functions */
 int qcow2_refcount_init(BlockDriverState *bs);
 void qcow2_refcount_close(BlockDriverState *bs);
-
+int QEMU_WARN_UNUSED_RESULT qcow2_update_refcount(BlockDriverState *bs,
+                            int64_t offset, int64_t length,
+                            int addend);
 int64_t qcow2_alloc_clusters(BlockDriverState *bs, int64_t size);
 int qcow2_alloc_clusters_at(BlockDriverState *bs, uint64_t offset,
     int nb_clusters);
