block/qcow2-cache.c

   1 /*
   2  * L2/refcount table cache for the QCOW2 format
   3  *
   4  * Copyright (c) 2010 Kevin Wolf <kwolf@redhat.com>
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  */
  24
  25 #include "block/block_int.h"
  26 #include "qemu-common.h"
  27 #include "qcow2.h"
  28 #include "trace.h"
  29
  30 typedef struct Qcow2CachedTable {
  31     void*   table;
  32     int64_t offset;
  33     bool    dirty;
  34     int     cache_hits;
  35     int     ref;
  36 } Qcow2CachedTable;
  37
  38 struct Qcow2Cache {
  39     Qcow2CachedTable*       entries;
  40     struct Qcow2Cache*      depends;
  41     int                     size;
  42     bool                    depends_on_flush;
  43 };
  44
  45 Qcow2Cache *qcow2_cache_create(BlockDriverState *bs, int num_tables)
  46 {
  47     BDRVQcowState *s = bs->opaque;
  48     Qcow2Cache *c;
  49     int i;
  50
  51     c = g_malloc0(sizeof(*c));
  52     c->size = num_tables;
  53     c->entries = g_malloc0(sizeof(*c->entries) * num_tables);
  54
  55     for (i = 0; i < c->size; i++) {
  56         c->entries[i].table = qemu_blockalign(bs, s->cluster_size);
  57     }
  58
  59     return c;
  60 }
  61
  62 int qcow2_cache_destroy(BlockDriverState* bs, Qcow2Cache *c)
  63 {
  64     int i;
  65
  66     for (i = 0; i < c->size; i++) {
  67         assert(c->entries[i].ref == 0);
  68         qemu_vfree(c->entries[i].table);
  69     }
  70
  71     g_free(c->entries);
  72     g_free(c);
  73
  74     return 0;
  75 }
  76
  77 static int qcow2_cache_flush_dependency(BlockDriverState *bs, Qcow2Cache *c)
  78 {
  79     int ret;
  80
  81     ret = qcow2_cache_flush(bs, c->depends);
  82     if (ret < 0) {
  83         return ret;
  84     }
  85
  86     c->depends = NULL;
  87     c->depends_on_flush = false;
  88
  89     return 0;
  90 }
  91
  92 static int qcow2_cache_entry_flush(BlockDriverState *bs, Qcow2Cache *c, int i)
  93 {
  94     BDRVQcowState *s = bs->opaque;
  95     int ret = 0;
  96
  97     if (!c->entries[i].dirty || !c->entries[i].offset) {
  98         return 0;
  99     }
 100
 101     trace_qcow2_cache_entry_flush(qemu_coroutine_self(),
 102                                   c == s->l2_table_cache, i);
 103
 104     if (c->depends) {
 105         ret = qcow2_cache_flush_dependency(bs, c);
 106     } else if (c->depends_on_flush) {
 107         ret = bdrv_flush(bs->file);
 108         if (ret >= 0) {
 109             c->depends_on_flush = false;
 110         }
 111     }
 112
 113     if (ret < 0) {
 114         return ret;
 115     }
 116
 117     if (c == s->refcount_block_cache) {
 118         ret = qcow2_pre_write_overlap_check(bs,
 119                 QCOW2_OL_DEFAULT & ~QCOW2_OL_REFCOUNT_BLOCK,
 120                 c->entries[i].offset, s->cluster_size);
 121     } else if (c == s->l2_table_cache) {
 122         ret = qcow2_pre_write_overlap_check(bs,
 123                 QCOW2_OL_DEFAULT & ~QCOW2_OL_ACTIVE_L2,
 124                 c->entries[i].offset, s->cluster_size);
 125     } else {
 126         ret = qcow2_pre_write_overlap_check(bs, QCOW2_OL_DEFAULT,
 127                 c->entries[i].offset, s->cluster_size);
 128     }
 129
 130     if (ret < 0) {
 131         return ret;
 132     }
 133
 134     if (c == s->refcount_block_cache) {
 135         BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_UPDATE_PART);
 136     } else if (c == s->l2_table_cache) {
 137         BLKDBG_EVENT(bs->file, BLKDBG_L2_UPDATE);
 138     }
 139
 140     ret = bdrv_pwrite(bs->file, c->entries[i].offset, c->entries[i].table,
 141         s->cluster_size);
 142     if (ret < 0) {
 143         return ret;
 144     }
 145
 146     c->entries[i].dirty = false;
 147
 148     return 0;
 149 }
 150
 151 int qcow2_cache_flush(BlockDriverState *bs, Qcow2Cache *c)
 152 {
 153     BDRVQcowState *s = bs->opaque;
 154     int result = 0;
 155     int ret;
 156     int i;
 157
 158     trace_qcow2_cache_flush(qemu_coroutine_self(), c == s->l2_table_cache);
 159
 160     for (i = 0; i < c->size; i++) {
 161         ret = qcow2_cache_entry_flush(bs, c, i);
 162         if (ret < 0 && result != -ENOSPC) {
 163             result = ret;
 164         }
 165     }
 166
 167     if (result == 0) {
 168         ret = bdrv_flush(bs->file);
 169         if (ret < 0) {
 170             result = ret;
 171         }
 172     }
 173
 174     return result;
 175 }
 176
 177 int qcow2_cache_set_dependency(BlockDriverState *bs, Qcow2Cache *c,
 178     Qcow2Cache *dependency)
 179 {
 180     int ret;
 181
 182     if (dependency->depends) {
 183         ret = qcow2_cache_flush_dependency(bs, dependency);
 184         if (ret < 0) {
 185             return ret;
 186         }
 187     }
 188
 189     if (c->depends && (c->depends != dependency)) {
 190         ret = qcow2_cache_flush_dependency(bs, c);
 191         if (ret < 0) {
 192             return ret;
 193         }
 194     }
 195
 196     c->depends = dependency;
 197     return 0;
 198 }
 199
 200 void qcow2_cache_depends_on_flush(Qcow2Cache *c)
 201 {
 202     c->depends_on_flush = true;
 203 }
 204
 205 static int qcow2_cache_find_entry_to_replace(Qcow2Cache *c)
 206 {
 207     int i;
 208     int min_count = INT_MAX;
 209     int min_index = -1;
 210
 211
 212     for (i = 0; i < c->size; i++) {
 213         if (c->entries[i].ref) {
 214             continue;
 215         }
 216
 217         if (c->entries[i].cache_hits < min_count) {
 218             min_index = i;
 219             min_count = c->entries[i].cache_hits;
 220         }
 221
 222         /* Give newer hits priority */
 223         /* TODO Check how to optimize the replacement strategy */
 224         c->entries[i].cache_hits /= 2;
 225     }
 226
 227     if (min_index == -1) {
 228         /* This can't happen in current synchronous code, but leave the check
 229          * here as a reminder for whoever starts using AIO with the cache */
 230         abort();
 231     }
 232     return min_index;
 233 }
 234
 235 static int qcow2_cache_do_get(BlockDriverState *bs, Qcow2Cache *c,
 236     uint64_t offset, void **table, bool read_from_disk)
 237 {
 238     BDRVQcowState *s = bs->opaque;
 239     int i;
 240     int ret;
 241
 242     trace_qcow2_cache_get(qemu_coroutine_self(), c == s->l2_table_cache,
 243                           offset, read_from_disk);
 244
 245     /* Check if the table is already cached */
 246     for (i = 0; i < c->size; i++) {
 247         if (c->entries[i].offset == offset) {
 248             goto found;
 249         }
 250     }
 251
 252     /* If not, write a table back and replace it */
 253     i = qcow2_cache_find_entry_to_replace(c);
 254     trace_qcow2_cache_get_replace_entry(qemu_coroutine_self(),
 255                                         c == s->l2_table_cache, i);
 256     if (i < 0) {
 257         return i;
 258     }
 259
 260     ret = qcow2_cache_entry_flush(bs, c, i);
 261     if (ret < 0) {
 262         return ret;
 263     }
 264
 265     trace_qcow2_cache_get_read(qemu_coroutine_self(),
 266                                c == s->l2_table_cache, i);
 267     c->entries[i].offset = 0;
 268     if (read_from_disk) {
 269         if (c == s->l2_table_cache) {
 270             BLKDBG_EVENT(bs->file, BLKDBG_L2_LOAD);
 271         }
 272
 273         ret = bdrv_pread(bs->file, offset, c->entries[i].table, s->cluster_size);
 274         if (ret < 0) {
 275             return ret;
 276         }
 277     }
 278
 279     /* Give the table some hits for the start so that it won't be replaced
 280      * immediately. The number 32 is completely arbitrary. */
 281     c->entries[i].cache_hits = 32;
 282     c->entries[i].offset = offset;
 283
 284     /* And return the right table */
 285 found:
 286     c->entries[i].cache_hits++;
 287     c->entries[i].ref++;
 288     *table = c->entries[i].table;
 289
 290     trace_qcow2_cache_get_done(qemu_coroutine_self(),
 291                                c == s->l2_table_cache, i);
 292
 293     return 0;
 294 }
 295
 296 int qcow2_cache_get(BlockDriverState *bs, Qcow2Cache *c, uint64_t offset,
 297     void **table)
 298 {
 299     return qcow2_cache_do_get(bs, c, offset, table, true);
 300 }
 301
 302 int qcow2_cache_get_empty(BlockDriverState *bs, Qcow2Cache *c, uint64_t offset,
 303     void **table)
 304 {
 305     return qcow2_cache_do_get(bs, c, offset, table, false);
 306 }
 307
 308 int qcow2_cache_put(BlockDriverState *bs, Qcow2Cache *c, void **table)
 309 {
 310     int i;
 311
 312     for (i = 0; i < c->size; i++) {
 313         if (c->entries[i].table == *table) {
 314             goto found;
 315         }
 316     }
 317     return -ENOENT;
 318
 319 found:
 320     c->entries[i].ref--;
 321     *table = NULL;
 322
 323     assert(c->entries[i].ref >= 0);
 324     return 0;
 325 }
 326
 327 void qcow2_cache_entry_mark_dirty(Qcow2Cache *c, void *table)
 328 {
 329     int i;
 330
 331     for (i = 0; i < c->size; i++) {
 332         if (c->entries[i].table == table) {
 333             goto found;
 334         }
 335     }
 336     abort();
 337
 338 found:
 339     c->entries[i].dirty = true;
 340 }