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 } 351