virtio-blk: Drop redundant VirtIOBlock member conf
[qemu.git] / block / qcow2-cache.c
blob904f6b1f44d8d7571e0693a3c6eb0e35554ffafe
1 /*
2 * L2/refcount table cache for the QCOW2 format
4 * Copyright (c) 2010 Kevin Wolf <kwolf@redhat.com>
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:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
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.
25 #include "block/block_int.h"
26 #include "qemu-common.h"
27 #include "qcow2.h"
28 #include "trace.h"
30 typedef struct Qcow2CachedTable {
31 void* table;
32 int64_t offset;
33 bool dirty;
34 int cache_hits;
35 int ref;
36 } Qcow2CachedTable;
38 struct Qcow2Cache {
39 Qcow2CachedTable* entries;
40 struct Qcow2Cache* depends;
41 int size;
42 bool depends_on_flush;
45 Qcow2Cache *qcow2_cache_create(BlockDriverState *bs, int num_tables)
47 BDRVQcowState *s = bs->opaque;
48 Qcow2Cache *c;
49 int i;
51 c = g_new0(Qcow2Cache, 1);
52 c->size = num_tables;
53 c->entries = g_try_new0(Qcow2CachedTable, num_tables);
54 if (!c->entries) {
55 goto fail;
58 for (i = 0; i < c->size; i++) {
59 c->entries[i].table = qemu_try_blockalign(bs->file, s->cluster_size);
60 if (c->entries[i].table == NULL) {
61 goto fail;
65 return c;
67 fail:
68 if (c->entries) {
69 for (i = 0; i < c->size; i++) {
70 qemu_vfree(c->entries[i].table);
73 g_free(c->entries);
74 g_free(c);
75 return NULL;
78 int qcow2_cache_destroy(BlockDriverState* bs, Qcow2Cache *c)
80 int i;
82 for (i = 0; i < c->size; i++) {
83 assert(c->entries[i].ref == 0);
84 qemu_vfree(c->entries[i].table);
87 g_free(c->entries);
88 g_free(c);
90 return 0;
93 static int qcow2_cache_flush_dependency(BlockDriverState *bs, Qcow2Cache *c)
95 int ret;
97 ret = qcow2_cache_flush(bs, c->depends);
98 if (ret < 0) {
99 return ret;
102 c->depends = NULL;
103 c->depends_on_flush = false;
105 return 0;
108 static int qcow2_cache_entry_flush(BlockDriverState *bs, Qcow2Cache *c, int i)
110 BDRVQcowState *s = bs->opaque;
111 int ret = 0;
113 if (!c->entries[i].dirty || !c->entries[i].offset) {
114 return 0;
117 trace_qcow2_cache_entry_flush(qemu_coroutine_self(),
118 c == s->l2_table_cache, i);
120 if (c->depends) {
121 ret = qcow2_cache_flush_dependency(bs, c);
122 } else if (c->depends_on_flush) {
123 ret = bdrv_flush(bs->file);
124 if (ret >= 0) {
125 c->depends_on_flush = false;
129 if (ret < 0) {
130 return ret;
133 if (c == s->refcount_block_cache) {
134 ret = qcow2_pre_write_overlap_check(bs, QCOW2_OL_REFCOUNT_BLOCK,
135 c->entries[i].offset, s->cluster_size);
136 } else if (c == s->l2_table_cache) {
137 ret = qcow2_pre_write_overlap_check(bs, QCOW2_OL_ACTIVE_L2,
138 c->entries[i].offset, s->cluster_size);
139 } else {
140 ret = qcow2_pre_write_overlap_check(bs, 0,
141 c->entries[i].offset, s->cluster_size);
144 if (ret < 0) {
145 return ret;
148 if (c == s->refcount_block_cache) {
149 BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_UPDATE_PART);
150 } else if (c == s->l2_table_cache) {
151 BLKDBG_EVENT(bs->file, BLKDBG_L2_UPDATE);
154 ret = bdrv_pwrite(bs->file, c->entries[i].offset, c->entries[i].table,
155 s->cluster_size);
156 if (ret < 0) {
157 return ret;
160 c->entries[i].dirty = false;
162 return 0;
165 int qcow2_cache_flush(BlockDriverState *bs, Qcow2Cache *c)
167 BDRVQcowState *s = bs->opaque;
168 int result = 0;
169 int ret;
170 int i;
172 trace_qcow2_cache_flush(qemu_coroutine_self(), c == s->l2_table_cache);
174 for (i = 0; i < c->size; i++) {
175 ret = qcow2_cache_entry_flush(bs, c, i);
176 if (ret < 0 && result != -ENOSPC) {
177 result = ret;
181 if (result == 0) {
182 ret = bdrv_flush(bs->file);
183 if (ret < 0) {
184 result = ret;
188 return result;
191 int qcow2_cache_set_dependency(BlockDriverState *bs, Qcow2Cache *c,
192 Qcow2Cache *dependency)
194 int ret;
196 if (dependency->depends) {
197 ret = qcow2_cache_flush_dependency(bs, dependency);
198 if (ret < 0) {
199 return ret;
203 if (c->depends && (c->depends != dependency)) {
204 ret = qcow2_cache_flush_dependency(bs, c);
205 if (ret < 0) {
206 return ret;
210 c->depends = dependency;
211 return 0;
214 void qcow2_cache_depends_on_flush(Qcow2Cache *c)
216 c->depends_on_flush = true;
219 int qcow2_cache_empty(BlockDriverState *bs, Qcow2Cache *c)
221 int ret, i;
223 ret = qcow2_cache_flush(bs, c);
224 if (ret < 0) {
225 return ret;
228 for (i = 0; i < c->size; i++) {
229 assert(c->entries[i].ref == 0);
230 c->entries[i].offset = 0;
231 c->entries[i].cache_hits = 0;
234 return 0;
237 static int qcow2_cache_find_entry_to_replace(Qcow2Cache *c)
239 int i;
240 int min_count = INT_MAX;
241 int min_index = -1;
244 for (i = 0; i < c->size; i++) {
245 if (c->entries[i].ref) {
246 continue;
249 if (c->entries[i].cache_hits < min_count) {
250 min_index = i;
251 min_count = c->entries[i].cache_hits;
254 /* Give newer hits priority */
255 /* TODO Check how to optimize the replacement strategy */
256 c->entries[i].cache_hits /= 2;
259 if (min_index == -1) {
260 /* This can't happen in current synchronous code, but leave the check
261 * here as a reminder for whoever starts using AIO with the cache */
262 abort();
264 return min_index;
267 static int qcow2_cache_do_get(BlockDriverState *bs, Qcow2Cache *c,
268 uint64_t offset, void **table, bool read_from_disk)
270 BDRVQcowState *s = bs->opaque;
271 int i;
272 int ret;
274 trace_qcow2_cache_get(qemu_coroutine_self(), c == s->l2_table_cache,
275 offset, read_from_disk);
277 /* Check if the table is already cached */
278 for (i = 0; i < c->size; i++) {
279 if (c->entries[i].offset == offset) {
280 goto found;
284 /* If not, write a table back and replace it */
285 i = qcow2_cache_find_entry_to_replace(c);
286 trace_qcow2_cache_get_replace_entry(qemu_coroutine_self(),
287 c == s->l2_table_cache, i);
288 if (i < 0) {
289 return i;
292 ret = qcow2_cache_entry_flush(bs, c, i);
293 if (ret < 0) {
294 return ret;
297 trace_qcow2_cache_get_read(qemu_coroutine_self(),
298 c == s->l2_table_cache, i);
299 c->entries[i].offset = 0;
300 if (read_from_disk) {
301 if (c == s->l2_table_cache) {
302 BLKDBG_EVENT(bs->file, BLKDBG_L2_LOAD);
305 ret = bdrv_pread(bs->file, offset, c->entries[i].table, s->cluster_size);
306 if (ret < 0) {
307 return ret;
311 /* Give the table some hits for the start so that it won't be replaced
312 * immediately. The number 32 is completely arbitrary. */
313 c->entries[i].cache_hits = 32;
314 c->entries[i].offset = offset;
316 /* And return the right table */
317 found:
318 c->entries[i].cache_hits++;
319 c->entries[i].ref++;
320 *table = c->entries[i].table;
322 trace_qcow2_cache_get_done(qemu_coroutine_self(),
323 c == s->l2_table_cache, i);
325 return 0;
328 int qcow2_cache_get(BlockDriverState *bs, Qcow2Cache *c, uint64_t offset,
329 void **table)
331 return qcow2_cache_do_get(bs, c, offset, table, true);
334 int qcow2_cache_get_empty(BlockDriverState *bs, Qcow2Cache *c, uint64_t offset,
335 void **table)
337 return qcow2_cache_do_get(bs, c, offset, table, false);
340 int qcow2_cache_put(BlockDriverState *bs, Qcow2Cache *c, void **table)
342 int i;
344 for (i = 0; i < c->size; i++) {
345 if (c->entries[i].table == *table) {
346 goto found;
349 return -ENOENT;
351 found:
352 c->entries[i].ref--;
353 *table = NULL;
355 assert(c->entries[i].ref >= 0);
356 return 0;
359 void qcow2_cache_entry_mark_dirty(Qcow2Cache *c, void *table)
361 int i;
363 for (i = 0; i < c->size; i++) {
364 if (c->entries[i].table == table) {
365 goto found;
368 abort();
370 found:
371 c->entries[i].dirty = true;