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     int64_t  offset;
  32     bool     dirty;
  33     uint64_t lru_counter;
  34     int      ref;
  35 } Qcow2CachedTable;
  36
  37 struct Qcow2Cache {
  38     Qcow2CachedTable       *entries;
  39     struct Qcow2Cache      *depends;
  40     int                     size;
  41     bool                    depends_on_flush;
  42     void                   *table_array;
  43     uint64_t                lru_counter;
  44 };
  45
  46 static inline void *qcow2_cache_get_table_addr(BlockDriverState *bs,
  47                     Qcow2Cache *c, int table)
  48 {
  49     BDRVQcowState *s = bs->opaque;
  50     return (uint8_t *) c->table_array + (size_t) table * s->cluster_size;
  51 }
  52
  53 static inline int qcow2_cache_get_table_idx(BlockDriverState *bs,
  54                   Qcow2Cache *c, void *table)
  55 {
  56     BDRVQcowState *s = bs->opaque;
  57     ptrdiff_t table_offset = (uint8_t *) table - (uint8_t *) c->table_array;
  58     int idx = table_offset / s->cluster_size;
  59     assert(idx >= 0 && idx < c->size && table_offset % s->cluster_size == 0);
  60     return idx;
  61 }
  62
  63 Qcow2Cache *qcow2_cache_create(BlockDriverState *bs, int num_tables)
  64 {
  65     BDRVQcowState *s = bs->opaque;
  66     Qcow2Cache *c;
  67
  68     c = g_new0(Qcow2Cache, 1);
  69     c->size = num_tables;
  70     c->entries = g_try_new0(Qcow2CachedTable, num_tables);
  71     c->table_array = qemu_try_blockalign(bs->file,
  72                                          (size_t) num_tables * s->cluster_size);
  73
  74     if (!c->entries || !c->table_array) {
  75         qemu_vfree(c->table_array);
  76         g_free(c->entries);
  77         g_free(c);
  78         c = NULL;
  79     }
  80
  81     return c;
  82 }
  83
  84 int qcow2_cache_destroy(BlockDriverState *bs, Qcow2Cache *c)
  85 {
  86     int i;
  87
  88     for (i = 0; i < c->size; i++) {
  89         assert(c->entries[i].ref == 0);
  90     }
  91
  92     qemu_vfree(c->table_array);
  93     g_free(c->entries);
  94     g_free(c);
  95
  96     return 0;
  97 }
  98
  99 static int qcow2_cache_flush_dependency(BlockDriverState *bs, Qcow2Cache *c)
 100 {
 101     int ret;
 102
 103     ret = qcow2_cache_flush(bs, c->depends);
 104     if (ret < 0) {
 105         return ret;
 106     }
 107
 108     c->depends = NULL;
 109     c->depends_on_flush = false;
 110
 111     return 0;
 112 }
 113
 114 static int qcow2_cache_entry_flush(BlockDriverState *bs, Qcow2Cache *c, int i)
 115 {
 116     BDRVQcowState *s = bs->opaque;
 117     int ret = 0;
 118
 119     if (!c->entries[i].dirty || !c->entries[i].offset) {
 120         return 0;
 121     }
 122
 123     trace_qcow2_cache_entry_flush(qemu_coroutine_self(),
 124                                   c == s->l2_table_cache, i);
 125
 126     if (c->depends) {
 127         ret = qcow2_cache_flush_dependency(bs, c);
 128     } else if (c->depends_on_flush) {
 129         ret = bdrv_flush(bs->file);
 130         if (ret >= 0) {
 131             c->depends_on_flush = false;
 132         }
 133     }
 134
 135     if (ret < 0) {
 136         return ret;
 137     }
 138
 139     if (c == s->refcount_block_cache) {
 140         ret = qcow2_pre_write_overlap_check(bs, QCOW2_OL_REFCOUNT_BLOCK,
 141                 c->entries[i].offset, s->cluster_size);
 142     } else if (c == s->l2_table_cache) {
 143         ret = qcow2_pre_write_overlap_check(bs, QCOW2_OL_ACTIVE_L2,
 144                 c->entries[i].offset, s->cluster_size);
 145     } else {
 146         ret = qcow2_pre_write_overlap_check(bs, 0,
 147                 c->entries[i].offset, s->cluster_size);
 148     }
 149
 150     if (ret < 0) {
 151         return ret;
 152     }
 153
 154     if (c == s->refcount_block_cache) {
 155         BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_UPDATE_PART);
 156     } else if (c == s->l2_table_cache) {
 157         BLKDBG_EVENT(bs->file, BLKDBG_L2_UPDATE);
 158     }
 159
 160     ret = bdrv_pwrite(bs->file, c->entries[i].offset,
 161                       qcow2_cache_get_table_addr(bs, c, i), s->cluster_size);
 162     if (ret < 0) {
 163         return ret;
 164     }
 165
 166     c->entries[i].dirty = false;
 167
 168     return 0;
 169 }
 170
 171 int qcow2_cache_flush(BlockDriverState *bs, Qcow2Cache *c)
 172 {
 173     BDRVQcowState *s = bs->opaque;
 174     int result = 0;
 175     int ret;
 176     int i;
 177
 178     trace_qcow2_cache_flush(qemu_coroutine_self(), c == s->l2_table_cache);
 179
 180     for (i = 0; i < c->size; i++) {
 181         ret = qcow2_cache_entry_flush(bs, c, i);
 182         if (ret < 0 && result != -ENOSPC) {
 183             result = ret;
 184         }
 185     }
 186
 187     if (result == 0) {
 188         ret = bdrv_flush(bs->file);
 189         if (ret < 0) {
 190             result = ret;
 191         }
 192     }
 193
 194     return result;
 195 }
 196
 197 int qcow2_cache_set_dependency(BlockDriverState *bs, Qcow2Cache *c,
 198     Qcow2Cache *dependency)
 199 {
 200     int ret;
 201
 202     if (dependency->depends) {
 203         ret = qcow2_cache_flush_dependency(bs, dependency);
 204         if (ret < 0) {
 205             return ret;
 206         }
 207     }
 208
 209     if (c->depends && (c->depends != dependency)) {
 210         ret = qcow2_cache_flush_dependency(bs, c);
 211         if (ret < 0) {
 212             return ret;
 213         }
 214     }
 215
 216     c->depends = dependency;
 217     return 0;
 218 }
 219
 220 void qcow2_cache_depends_on_flush(Qcow2Cache *c)
 221 {
 222     c->depends_on_flush = true;
 223 }
 224
 225 int qcow2_cache_empty(BlockDriverState *bs, Qcow2Cache *c)
 226 {
 227     int ret, i;
 228
 229     ret = qcow2_cache_flush(bs, c);
 230     if (ret < 0) {
 231         return ret;
 232     }
 233
 234     for (i = 0; i < c->size; i++) {
 235         assert(c->entries[i].ref == 0);
 236         c->entries[i].offset = 0;
 237         c->entries[i].lru_counter = 0;
 238     }
 239
 240     c->lru_counter = 0;
 241
 242     return 0;
 243 }
 244
 245 static int qcow2_cache_do_get(BlockDriverState *bs, Qcow2Cache *c,
 246     uint64_t offset, void **table, bool read_from_disk)
 247 {
 248     BDRVQcowState *s = bs->opaque;
 249     int i;
 250     int ret;
 251     int lookup_index;
 252     uint64_t min_lru_counter = UINT64_MAX;
 253     int min_lru_index = -1;
 254
 255     trace_qcow2_cache_get(qemu_coroutine_self(), c == s->l2_table_cache,
 256                           offset, read_from_disk);
 257
 258     /* Check if the table is already cached */
 259     i = lookup_index = (offset / s->cluster_size * 4) % c->size;
 260     do {
 261         const Qcow2CachedTable *t = &c->entries[i];
 262         if (t->offset == offset) {
 263             goto found;
 264         }
 265         if (t->ref == 0 && t->lru_counter < min_lru_counter) {
 266             min_lru_counter = t->lru_counter;
 267             min_lru_index = i;
 268         }
 269         if (++i == c->size) {
 270             i = 0;
 271         }
 272     } while (i != lookup_index);
 273
 274     if (min_lru_index == -1) {
 275         /* This can't happen in current synchronous code, but leave the check
 276          * here as a reminder for whoever starts using AIO with the cache */
 277         abort();
 278     }
 279
 280     /* Cache miss: write a table back and replace it */
 281     i = min_lru_index;
 282     trace_qcow2_cache_get_replace_entry(qemu_coroutine_self(),
 283                                         c == s->l2_table_cache, i);
 284
 285     ret = qcow2_cache_entry_flush(bs, c, i);
 286     if (ret < 0) {
 287         return ret;
 288     }
 289
 290     trace_qcow2_cache_get_read(qemu_coroutine_self(),
 291                                c == s->l2_table_cache, i);
 292     c->entries[i].offset = 0;
 293     if (read_from_disk) {
 294         if (c == s->l2_table_cache) {
 295             BLKDBG_EVENT(bs->file, BLKDBG_L2_LOAD);
 296         }
 297
 298         ret = bdrv_pread(bs->file, offset, qcow2_cache_get_table_addr(bs, c, i),
 299                          s->cluster_size);
 300         if (ret < 0) {
 301             return ret;
 302         }
 303     }
 304
 305     c->entries[i].offset = offset;
 306
 307     /* And return the right table */
 308 found:
 309     c->entries[i].ref++;
 310     *table = qcow2_cache_get_table_addr(bs, c, i);
 311
 312     trace_qcow2_cache_get_done(qemu_coroutine_self(),
 313                                c == s->l2_table_cache, i);
 314
 315     return 0;
 316 }
 317
 318 int qcow2_cache_get(BlockDriverState *bs, Qcow2Cache *c, uint64_t offset,
 319     void **table)
 320 {
 321     return qcow2_cache_do_get(bs, c, offset, table, true);
 322 }
 323
 324 int qcow2_cache_get_empty(BlockDriverState *bs, Qcow2Cache *c, uint64_t offset,
 325     void **table)
 326 {
 327     return qcow2_cache_do_get(bs, c, offset, table, false);
 328 }
 329
 330 void qcow2_cache_put(BlockDriverState *bs, Qcow2Cache *c, void **table)
 331 {
 332     int i = qcow2_cache_get_table_idx(bs, c, *table);
 333
 334     c->entries[i].ref--;
 335     *table = NULL;
 336
 337     if (c->entries[i].ref == 0) {
 338         c->entries[i].lru_counter = ++c->lru_counter;
 339     }
 340
 341     assert(c->entries[i].ref >= 0);
 342 }
 343
 344 void qcow2_cache_entry_mark_dirty(BlockDriverState *bs, Qcow2Cache *c,
 345      void *table)
 346 {
 347     int i = qcow2_cache_get_table_idx(bs, c, table);
 348     assert(c->entries[i].offset != 0);
 349     c->entries[i].dirty = true;
 350 }