block: Support BDRV_REQ_WRITE_UNCHANGED in filters

[qemu.git] / block / qcow2-cache.c

diff --git a/block/qcow2-cache.c b/block/qcow2-cache.c
index 0fe8edae41192b95ba034886af572823ff0e905e..d9dafa31e53ac8c8285707ab18fa528828cb7f20 100644 (file)
--- a/block/qcow2-cache.c
+++ b/block/qcow2-cache.c
@@ -22,13 +22,7 @@
  * THE SOFTWARE.
  */
 
  * THE SOFTWARE.
  */
 

-/* Needed for CONFIG_MADVISE */

 #include "qemu/osdep.h"
 #include "qemu/osdep.h"

-
-#if defined(CONFIG_MADVISE) || defined(CONFIG_POSIX_MADVISE)
-#include <sys/mman.h>
-#endif
-

 #include "block/block_int.h"
 #include "qemu-common.h"
 #include "qcow2.h"
 #include "block/block_int.h"
 #include "qemu-common.h"
 #include "qcow2.h"


@@ -45,41 +39,49 @@ struct Qcow2Cache {
     Qcow2CachedTable       *entries;
     struct Qcow2Cache      *depends;
     int                     size;
     Qcow2CachedTable       *entries;
     struct Qcow2Cache      *depends;
     int                     size;

+    int                     table_size;

     bool                    depends_on_flush;
     void                   *table_array;
     uint64_t                lru_counter;
     uint64_t                cache_clean_lru_counter;
 };
 
     bool                    depends_on_flush;
     void                   *table_array;
     uint64_t                lru_counter;
     uint64_t                cache_clean_lru_counter;
 };
 

-static inline void *qcow2_cache_get_table_addr(BlockDriverState *bs,
-                    Qcow2Cache *c, int table)
+static inline void *qcow2_cache_get_table_addr(Qcow2Cache *c, int table)

 {
 {

-    BDRVQcow2State *s = bs->opaque;
-    return (uint8_t *) c->table_array + (size_t) table * s->cluster_size;
+    return (uint8_t *) c->table_array + (size_t) table * c->table_size;

 }
 
 }
 

-static inline int qcow2_cache_get_table_idx(BlockDriverState *bs,
-                  Qcow2Cache *c, void *table)
+static inline int qcow2_cache_get_table_idx(Qcow2Cache *c, void *table)

 {
 {

-    BDRVQcow2State *s = bs->opaque;

     ptrdiff_t table_offset = (uint8_t *) table - (uint8_t *) c->table_array;
     ptrdiff_t table_offset = (uint8_t *) table - (uint8_t *) c->table_array;

-    int idx = table_offset / s->cluster_size;
-    assert(idx >= 0 && idx < c->size && table_offset % s->cluster_size == 0);
+    int idx = table_offset / c->table_size;
+    assert(idx >= 0 && idx < c->size && table_offset % c->table_size == 0);

     return idx;
 }
 
     return idx;
 }
 

-static void qcow2_cache_table_release(BlockDriverState *bs, Qcow2Cache *c,
-                                      int i, int num_tables)
+static inline const char *qcow2_cache_get_name(BDRVQcow2State *s, Qcow2Cache *c)

 {
 {

-#if QEMU_MADV_DONTNEED != QEMU_MADV_INVALID
-    BDRVQcow2State *s = bs->opaque;
-    void *t = qcow2_cache_get_table_addr(bs, c, i);
+    if (c == s->refcount_block_cache) {
+        return "refcount block";
+    } else if (c == s->l2_table_cache) {
+        return "L2 table";
+    } else {
+        /* Do not abort, because this is not critical */
+        return "unknown";
+    }
+}
+
+static void qcow2_cache_table_release(Qcow2Cache *c, int i, int num_tables)
+{
+/* Using MADV_DONTNEED to discard memory is a Linux-specific feature */
+#ifdef CONFIG_LINUX
+    void *t = qcow2_cache_get_table_addr(c, i);

     int align = getpagesize();
     int align = getpagesize();

-    size_t mem_size = (size_t) s->cluster_size * num_tables;
+    size_t mem_size = (size_t) c->table_size * num_tables;

     size_t offset = QEMU_ALIGN_UP((uintptr_t) t, align) - (uintptr_t) t;
     size_t length = QEMU_ALIGN_DOWN(mem_size - offset, align);
     size_t offset = QEMU_ALIGN_UP((uintptr_t) t, align) - (uintptr_t) t;
     size_t length = QEMU_ALIGN_DOWN(mem_size - offset, align);

-    if (length > 0) {
-        qemu_madvise((uint8_t *) t + offset, length, QEMU_MADV_DONTNEED);
+    if (mem_size > offset && length > 0) {
+        madvise((uint8_t *) t + offset, length, MADV_DONTNEED);

     }
 #endif
 }
     }
 #endif
 }


@@ -91,7 +93,7 @@ static inline bool can_clean_entry(Qcow2Cache *c, int i)
         t->lru_counter <= c->cache_clean_lru_counter;
 }
 
         t->lru_counter <= c->cache_clean_lru_counter;
 }
 

-void qcow2_cache_clean_unused(BlockDriverState *bs, Qcow2Cache *c)
+void qcow2_cache_clean_unused(Qcow2Cache *c)

 {
     int i = 0;
     while (i < c->size) {
 {
     int i = 0;
     while (i < c->size) {


@@ -111,23 +113,30 @@ void qcow2_cache_clean_unused(BlockDriverState *bs, Qcow2Cache *c)
         }
 
         if (to_clean > 0) {
         }
 
         if (to_clean > 0) {

-            qcow2_cache_table_release(bs, c, i - to_clean, to_clean);
+            qcow2_cache_table_release(c, i - to_clean, to_clean);

         }
     }
 
     c->cache_clean_lru_counter = c->lru_counter;
 }
 
         }
     }
 
     c->cache_clean_lru_counter = c->lru_counter;
 }
 

-Qcow2Cache *qcow2_cache_create(BlockDriverState *bs, int num_tables)
+Qcow2Cache *qcow2_cache_create(BlockDriverState *bs, int num_tables,
+                               unsigned table_size)

 {
     BDRVQcow2State *s = bs->opaque;
     Qcow2Cache *c;
 
 {
     BDRVQcow2State *s = bs->opaque;
     Qcow2Cache *c;
 

+    assert(num_tables > 0);
+    assert(is_power_of_2(table_size));
+    assert(table_size >= (1 << MIN_CLUSTER_BITS));
+    assert(table_size <= s->cluster_size);
+

     c = g_new0(Qcow2Cache, 1);
     c->size = num_tables;
     c = g_new0(Qcow2Cache, 1);
     c->size = num_tables;

+    c->table_size = table_size;

     c->entries = g_try_new0(Qcow2CachedTable, num_tables);
     c->table_array = qemu_try_blockalign(bs->file->bs,
     c->entries = g_try_new0(Qcow2CachedTable, num_tables);
     c->table_array = qemu_try_blockalign(bs->file->bs,

-                                         (size_t) num_tables * s->cluster_size);
+                                         (size_t) num_tables * c->table_size);

 
     if (!c->entries || !c->table_array) {
         qemu_vfree(c->table_array);
 
     if (!c->entries || !c->table_array) {
         qemu_vfree(c->table_array);


@@ -139,7 +148,7 @@ Qcow2Cache *qcow2_cache_create(BlockDriverState *bs, int num_tables)
     return c;
 }
 
     return c;
 }
 

-int qcow2_cache_destroy(BlockDriverState *bs, Qcow2Cache *c)
+int qcow2_cache_destroy(Qcow2Cache *c)

 {
     int i;
 
 {
     int i;
 


@@ -196,13 +205,13 @@ static int qcow2_cache_entry_flush(BlockDriverState *bs, Qcow2Cache *c, int i)
 
     if (c == s->refcount_block_cache) {
         ret = qcow2_pre_write_overlap_check(bs, QCOW2_OL_REFCOUNT_BLOCK,
 
     if (c == s->refcount_block_cache) {
         ret = qcow2_pre_write_overlap_check(bs, QCOW2_OL_REFCOUNT_BLOCK,

-                c->entries[i].offset, s->cluster_size);
+                c->entries[i].offset, c->table_size);

     } else if (c == s->l2_table_cache) {
         ret = qcow2_pre_write_overlap_check(bs, QCOW2_OL_ACTIVE_L2,
     } else if (c == s->l2_table_cache) {
         ret = qcow2_pre_write_overlap_check(bs, QCOW2_OL_ACTIVE_L2,

-                c->entries[i].offset, s->cluster_size);
+                c->entries[i].offset, c->table_size);

     } else {
         ret = qcow2_pre_write_overlap_check(bs, 0,
     } else {
         ret = qcow2_pre_write_overlap_check(bs, 0,

-                c->entries[i].offset, s->cluster_size);
+                c->entries[i].offset, c->table_size);

     }
 
     if (ret < 0) {
     }
 
     if (ret < 0) {


@@ -215,8 +224,8 @@ static int qcow2_cache_entry_flush(BlockDriverState *bs, Qcow2Cache *c, int i)
         BLKDBG_EVENT(bs->file, BLKDBG_L2_UPDATE);
     }
 
         BLKDBG_EVENT(bs->file, BLKDBG_L2_UPDATE);
     }
 

-    ret = bdrv_pwrite(bs->file->bs, c->entries[i].offset,
-                      qcow2_cache_get_table_addr(bs, c, i), s->cluster_size);
+    ret = bdrv_pwrite(bs->file, c->entries[i].offset,
+                      qcow2_cache_get_table_addr(c, i), c->table_size);

     if (ret < 0) {
         return ret;
     }
     if (ret < 0) {
         return ret;
     }


@@ -226,7 +235,7 @@ static int qcow2_cache_entry_flush(BlockDriverState *bs, Qcow2Cache *c, int i)
     return 0;
 }
 
     return 0;
 }
 

-int qcow2_cache_flush(BlockDriverState *bs, Qcow2Cache *c)
+int qcow2_cache_write(BlockDriverState *bs, Qcow2Cache *c)

 {
     BDRVQcow2State *s = bs->opaque;
     int result = 0;
 {
     BDRVQcow2State *s = bs->opaque;
     int result = 0;


@@ -242,8 +251,15 @@ int qcow2_cache_flush(BlockDriverState *bs, Qcow2Cache *c)
         }
     }
 
         }
     }
 

+    return result;
+}
+
+int qcow2_cache_flush(BlockDriverState *bs, Qcow2Cache *c)
+{
+    int result = qcow2_cache_write(bs, c);
+

     if (result == 0) {
     if (result == 0) {

-        ret = bdrv_flush(bs->file->bs);
+        int ret = bdrv_flush(bs->file->bs);

         if (ret < 0) {
             result = ret;
         }
         if (ret < 0) {
             result = ret;
         }


@@ -295,7 +311,7 @@ int qcow2_cache_empty(BlockDriverState *bs, Qcow2Cache *c)
         c->entries[i].lru_counter = 0;
     }
 
         c->entries[i].lru_counter = 0;
     }
 

-    qcow2_cache_table_release(bs, c, 0, c->size);
+    qcow2_cache_table_release(c, 0, c->size);

 
     c->lru_counter = 0;
 
 
     c->lru_counter = 0;
 


@@ -312,11 +328,20 @@ static int qcow2_cache_do_get(BlockDriverState *bs, Qcow2Cache *c,
     uint64_t min_lru_counter = UINT64_MAX;
     int min_lru_index = -1;
 
     uint64_t min_lru_counter = UINT64_MAX;
     int min_lru_index = -1;
 

+    assert(offset != 0);
+

     trace_qcow2_cache_get(qemu_coroutine_self(), c == s->l2_table_cache,
                           offset, read_from_disk);
 
     trace_qcow2_cache_get(qemu_coroutine_self(), c == s->l2_table_cache,
                           offset, read_from_disk);
 

+    if (!QEMU_IS_ALIGNED(offset, c->table_size)) {
+        qcow2_signal_corruption(bs, true, -1, -1, "Cannot get entry from %s "
+                                "cache: Offset %#" PRIx64 " is unaligned",
+                                qcow2_cache_get_name(s, c), offset);
+        return -EIO;
+    }
+

     /* Check if the table is already cached */
     /* Check if the table is already cached */

-    i = lookup_index = (offset / s->cluster_size * 4) % c->size;
+    i = lookup_index = (offset / c->table_size * 4) % c->size;

     do {
         const Qcow2CachedTable *t = &c->entries[i];
         if (t->offset == offset) {
     do {
         const Qcow2CachedTable *t = &c->entries[i];
         if (t->offset == offset) {


@@ -355,9 +380,9 @@ static int qcow2_cache_do_get(BlockDriverState *bs, Qcow2Cache *c,
             BLKDBG_EVENT(bs->file, BLKDBG_L2_LOAD);
         }
 
             BLKDBG_EVENT(bs->file, BLKDBG_L2_LOAD);
         }
 

-        ret = bdrv_pread(bs->file->bs, offset,
-                         qcow2_cache_get_table_addr(bs, c, i),
-                         s->cluster_size);
+        ret = bdrv_pread(bs->file, offset,
+                         qcow2_cache_get_table_addr(c, i),
+                         c->table_size);

         if (ret < 0) {
             return ret;
         }
         if (ret < 0) {
             return ret;
         }


@@ -368,7 +393,7 @@ static int qcow2_cache_do_get(BlockDriverState *bs, Qcow2Cache *c,
     /* And return the right table */
 found:
     c->entries[i].ref++;
     /* And return the right table */
 found:
     c->entries[i].ref++;

-    *table = qcow2_cache_get_table_addr(bs, c, i);
+    *table = qcow2_cache_get_table_addr(c, i);

 
     trace_qcow2_cache_get_done(qemu_coroutine_self(),
                                c == s->l2_table_cache, i);
 
     trace_qcow2_cache_get_done(qemu_coroutine_self(),
                                c == s->l2_table_cache, i);


@@ -388,9 +413,9 @@ int qcow2_cache_get_empty(BlockDriverState *bs, Qcow2Cache *c, uint64_t offset,
     return qcow2_cache_do_get(bs, c, offset, table, false);
 }
 
     return qcow2_cache_do_get(bs, c, offset, table, false);
 }
 

-void qcow2_cache_put(BlockDriverState *bs, Qcow2Cache *c, void **table)
+void qcow2_cache_put(Qcow2Cache *c, void **table)

 {
 {

-    int i = qcow2_cache_get_table_idx(bs, c, *table);
+    int i = qcow2_cache_get_table_idx(c, *table);

 
     c->entries[i].ref--;
     *table = NULL;
 
     c->entries[i].ref--;
     *table = NULL;


@@ -402,10 +427,34 @@ void qcow2_cache_put(BlockDriverState *bs, Qcow2Cache *c, void **table)
     assert(c->entries[i].ref >= 0);
 }
 
     assert(c->entries[i].ref >= 0);
 }
 

-void qcow2_cache_entry_mark_dirty(BlockDriverState *bs, Qcow2Cache *c,
-     void *table)
+void qcow2_cache_entry_mark_dirty(Qcow2Cache *c, void *table)

 {
 {

-    int i = qcow2_cache_get_table_idx(bs, c, table);
+    int i = qcow2_cache_get_table_idx(c, table);

     assert(c->entries[i].offset != 0);
     c->entries[i].dirty = true;
 }
     assert(c->entries[i].offset != 0);
     c->entries[i].dirty = true;
 }

+
+void *qcow2_cache_is_table_offset(Qcow2Cache *c, uint64_t offset)
+{
+    int i;
+
+    for (i = 0; i < c->size; i++) {
+        if (c->entries[i].offset == offset) {
+            return qcow2_cache_get_table_addr(c, i);
+        }
+    }
+    return NULL;
+}
+
+void qcow2_cache_discard(Qcow2Cache *c, void *table)
+{
+    int i = qcow2_cache_get_table_idx(c, table);
+
+    assert(c->entries[i].ref == 0);
+
+    c->entries[i].offset = 0;
+    c->entries[i].lru_counter = 0;
+    c->entries[i].dirty = false;
+
+    qcow2_cache_table_release(c, i, 1);
+}