Merge remote-tracking branch 'remotes/kevin/tags/for-upstream' into staging
[qemu.git] / 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, QCOW2_OL_REFCOUNT_BLOCK,
119 c->entries[i].offset, s->cluster_size);
120 } else if (c == s->l2_table_cache) {
121 ret = qcow2_pre_write_overlap_check(bs, QCOW2_OL_ACTIVE_L2,
122 c->entries[i].offset, s->cluster_size);
123 } else {
124 ret = qcow2_pre_write_overlap_check(bs, 0,
125 c->entries[i].offset, s->cluster_size);
126 }
127
128 if (ret < 0) {
129 return ret;
130 }
131
132 if (c == s->refcount_block_cache) {
133 BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_UPDATE_PART);
134 } else if (c == s->l2_table_cache) {
135 BLKDBG_EVENT(bs->file, BLKDBG_L2_UPDATE);
136 }
137
138 ret = bdrv_pwrite(bs->file, c->entries[i].offset, c->entries[i].table,
139 s->cluster_size);
140 if (ret < 0) {
141 return ret;
142 }
143
144 c->entries[i].dirty = false;
145
146 return 0;
147 }
148
149 int qcow2_cache_flush(BlockDriverState *bs, Qcow2Cache *c)
150 {
151 BDRVQcowState *s = bs->opaque;
152 int result = 0;
153 int ret;
154 int i;
155
156 trace_qcow2_cache_flush(qemu_coroutine_self(), c == s->l2_table_cache);
157
158 for (i = 0; i < c->size; i++) {
159 ret = qcow2_cache_entry_flush(bs, c, i);
160 if (ret < 0 && result != -ENOSPC) {
161 result = ret;
162 }
163 }
164
165 if (result == 0) {
166 ret = bdrv_flush(bs->file);
167 if (ret < 0) {
168 result = ret;
169 }
170 }
171
172 return result;
173 }
174
175 int qcow2_cache_set_dependency(BlockDriverState *bs, Qcow2Cache *c,
176 Qcow2Cache *dependency)
177 {
178 int ret;
179
180 if (dependency->depends) {
181 ret = qcow2_cache_flush_dependency(bs, dependency);
182 if (ret < 0) {
183 return ret;
184 }
185 }
186
187 if (c->depends && (c->depends != dependency)) {
188 ret = qcow2_cache_flush_dependency(bs, c);
189 if (ret < 0) {
190 return ret;
191 }
192 }
193
194 c->depends = dependency;
195 return 0;
196 }
197
198 void qcow2_cache_depends_on_flush(Qcow2Cache *c)
199 {
200 c->depends_on_flush = true;
201 }
202
203 int qcow2_cache_empty(BlockDriverState *bs, Qcow2Cache *c)
204 {
205 int ret, i;
206
207 ret = qcow2_cache_flush(bs, c);
208 if (ret < 0) {
209 return ret;
210 }
211
212 for (i = 0; i < c->size; i++) {
213 assert(c->entries[i].ref == 0);
214 c->entries[i].offset = 0;
215 c->entries[i].cache_hits = 0;
216 }
217
218 return 0;
219 }
220
221 static int qcow2_cache_find_entry_to_replace(Qcow2Cache *c)
222 {
223 int i;
224 int min_count = INT_MAX;
225 int min_index = -1;
226
227
228 for (i = 0; i < c->size; i++) {
229 if (c->entries[i].ref) {
230 continue;
231 }
232
233 if (c->entries[i].cache_hits < min_count) {
234 min_index = i;
235 min_count = c->entries[i].cache_hits;
236 }
237
238 /* Give newer hits priority */
239 /* TODO Check how to optimize the replacement strategy */
240 c->entries[i].cache_hits /= 2;
241 }
242
243 if (min_index == -1) {
244 /* This can't happen in current synchronous code, but leave the check
245 * here as a reminder for whoever starts using AIO with the cache */
246 abort();
247 }
248 return min_index;
249 }
250
251 static int qcow2_cache_do_get(BlockDriverState *bs, Qcow2Cache *c,
252 uint64_t offset, void **table, bool read_from_disk)
253 {
254 BDRVQcowState *s = bs->opaque;
255 int i;
256 int ret;
257
258 trace_qcow2_cache_get(qemu_coroutine_self(), c == s->l2_table_cache,
259 offset, read_from_disk);
260
261 /* Check if the table is already cached */
262 for (i = 0; i < c->size; i++) {
263 if (c->entries[i].offset == offset) {
264 goto found;
265 }
266 }
267
268 /* If not, write a table back and replace it */
269 i = qcow2_cache_find_entry_to_replace(c);
270 trace_qcow2_cache_get_replace_entry(qemu_coroutine_self(),
271 c == s->l2_table_cache, i);
272 if (i < 0) {
273 return i;
274 }
275
276 ret = qcow2_cache_entry_flush(bs, c, i);
277 if (ret < 0) {
278 return ret;
279 }
280
281 trace_qcow2_cache_get_read(qemu_coroutine_self(),
282 c == s->l2_table_cache, i);
283 c->entries[i].offset = 0;
284 if (read_from_disk) {
285 if (c == s->l2_table_cache) {
286 BLKDBG_EVENT(bs->file, BLKDBG_L2_LOAD);
287 }
288
289 ret = bdrv_pread(bs->file, offset, c->entries[i].table, s->cluster_size);
290 if (ret < 0) {
291 return ret;
292 }
293 }
294
295 /* Give the table some hits for the start so that it won't be replaced
296 * immediately. The number 32 is completely arbitrary. */
297 c->entries[i].cache_hits = 32;
298 c->entries[i].offset = offset;
299
300 /* And return the right table */
301 found:
302 c->entries[i].cache_hits++;
303 c->entries[i].ref++;
304 *table = c->entries[i].table;
305
306 trace_qcow2_cache_get_done(qemu_coroutine_self(),
307 c == s->l2_table_cache, i);
308
309 return 0;
310 }
311
312 int qcow2_cache_get(BlockDriverState *bs, Qcow2Cache *c, uint64_t offset,
313 void **table)
314 {
315 return qcow2_cache_do_get(bs, c, offset, table, true);
316 }
317
318 int qcow2_cache_get_empty(BlockDriverState *bs, Qcow2Cache *c, uint64_t offset,
319 void **table)
320 {
321 return qcow2_cache_do_get(bs, c, offset, table, false);
322 }
323
324 int qcow2_cache_put(BlockDriverState *bs, Qcow2Cache *c, void **table)
325 {
326 int i;
327
328 for (i = 0; i < c->size; i++) {
329 if (c->entries[i].table == *table) {
330 goto found;
331 }
332 }
333 return -ENOENT;
334
335 found:
336 c->entries[i].ref--;
337 *table = NULL;
338
339 assert(c->entries[i].ref >= 0);
340 return 0;
341 }
342
343 void qcow2_cache_entry_mark_dirty(Qcow2Cache *c, void *table)
344 {
345 int i;
346
347 for (i = 0; i < c->size; i++) {
348 if (c->entries[i].table == table) {
349 goto found;
350 }
351 }
352 abort();
353
354 found:
355 c->entries[i].dirty = true;
356 }