tests: virtio-9p: rename PCI configuration test
[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 "qemu/osdep.h"
26 #include "block/block_int.h"
27 #include "qemu-common.h"
28 #include "qcow2.h"
29 #include "trace.h"
30
31 typedef struct Qcow2CachedTable {
32 int64_t offset;
33 uint64_t lru_counter;
34 int ref;
35 bool dirty;
36 } Qcow2CachedTable;
37
38 struct Qcow2Cache {
39 Qcow2CachedTable *entries;
40 struct Qcow2Cache *depends;
41 int size;
42 bool depends_on_flush;
43 void *table_array;
44 uint64_t lru_counter;
45 uint64_t cache_clean_lru_counter;
46 };
47
48 static inline void *qcow2_cache_get_table_addr(BlockDriverState *bs,
49 Qcow2Cache *c, int table)
50 {
51 BDRVQcow2State *s = bs->opaque;
52 return (uint8_t *) c->table_array + (size_t) table * s->cluster_size;
53 }
54
55 static inline int qcow2_cache_get_table_idx(BlockDriverState *bs,
56 Qcow2Cache *c, void *table)
57 {
58 BDRVQcow2State *s = bs->opaque;
59 ptrdiff_t table_offset = (uint8_t *) table - (uint8_t *) c->table_array;
60 int idx = table_offset / s->cluster_size;
61 assert(idx >= 0 && idx < c->size && table_offset % s->cluster_size == 0);
62 return idx;
63 }
64
65 static void qcow2_cache_table_release(BlockDriverState *bs, Qcow2Cache *c,
66 int i, int num_tables)
67 {
68 /* Using MADV_DONTNEED to discard memory is a Linux-specific feature */
69 #ifdef CONFIG_LINUX
70 BDRVQcow2State *s = bs->opaque;
71 void *t = qcow2_cache_get_table_addr(bs, c, i);
72 int align = getpagesize();
73 size_t mem_size = (size_t) s->cluster_size * num_tables;
74 size_t offset = QEMU_ALIGN_UP((uintptr_t) t, align) - (uintptr_t) t;
75 size_t length = QEMU_ALIGN_DOWN(mem_size - offset, align);
76 if (length > 0) {
77 madvise((uint8_t *) t + offset, length, MADV_DONTNEED);
78 }
79 #endif
80 }
81
82 static inline bool can_clean_entry(Qcow2Cache *c, int i)
83 {
84 Qcow2CachedTable *t = &c->entries[i];
85 return t->ref == 0 && !t->dirty && t->offset != 0 &&
86 t->lru_counter <= c->cache_clean_lru_counter;
87 }
88
89 void qcow2_cache_clean_unused(BlockDriverState *bs, Qcow2Cache *c)
90 {
91 int i = 0;
92 while (i < c->size) {
93 int to_clean = 0;
94
95 /* Skip the entries that we don't need to clean */
96 while (i < c->size && !can_clean_entry(c, i)) {
97 i++;
98 }
99
100 /* And count how many we can clean in a row */
101 while (i < c->size && can_clean_entry(c, i)) {
102 c->entries[i].offset = 0;
103 c->entries[i].lru_counter = 0;
104 i++;
105 to_clean++;
106 }
107
108 if (to_clean > 0) {
109 qcow2_cache_table_release(bs, c, i - to_clean, to_clean);
110 }
111 }
112
113 c->cache_clean_lru_counter = c->lru_counter;
114 }
115
116 Qcow2Cache *qcow2_cache_create(BlockDriverState *bs, int num_tables)
117 {
118 BDRVQcow2State *s = bs->opaque;
119 Qcow2Cache *c;
120
121 c = g_new0(Qcow2Cache, 1);
122 c->size = num_tables;
123 c->entries = g_try_new0(Qcow2CachedTable, num_tables);
124 c->table_array = qemu_try_blockalign(bs->file->bs,
125 (size_t) num_tables * s->cluster_size);
126
127 if (!c->entries || !c->table_array) {
128 qemu_vfree(c->table_array);
129 g_free(c->entries);
130 g_free(c);
131 c = NULL;
132 }
133
134 return c;
135 }
136
137 int qcow2_cache_destroy(BlockDriverState *bs, Qcow2Cache *c)
138 {
139 int i;
140
141 for (i = 0; i < c->size; i++) {
142 assert(c->entries[i].ref == 0);
143 }
144
145 qemu_vfree(c->table_array);
146 g_free(c->entries);
147 g_free(c);
148
149 return 0;
150 }
151
152 static int qcow2_cache_flush_dependency(BlockDriverState *bs, Qcow2Cache *c)
153 {
154 int ret;
155
156 ret = qcow2_cache_flush(bs, c->depends);
157 if (ret < 0) {
158 return ret;
159 }
160
161 c->depends = NULL;
162 c->depends_on_flush = false;
163
164 return 0;
165 }
166
167 static int qcow2_cache_entry_flush(BlockDriverState *bs, Qcow2Cache *c, int i)
168 {
169 BDRVQcow2State *s = bs->opaque;
170 int ret = 0;
171
172 if (!c->entries[i].dirty || !c->entries[i].offset) {
173 return 0;
174 }
175
176 trace_qcow2_cache_entry_flush(qemu_coroutine_self(),
177 c == s->l2_table_cache, i);
178
179 if (c->depends) {
180 ret = qcow2_cache_flush_dependency(bs, c);
181 } else if (c->depends_on_flush) {
182 ret = bdrv_flush(bs->file->bs);
183 if (ret >= 0) {
184 c->depends_on_flush = false;
185 }
186 }
187
188 if (ret < 0) {
189 return ret;
190 }
191
192 if (c == s->refcount_block_cache) {
193 ret = qcow2_pre_write_overlap_check(bs, QCOW2_OL_REFCOUNT_BLOCK,
194 c->entries[i].offset, s->cluster_size);
195 } else if (c == s->l2_table_cache) {
196 ret = qcow2_pre_write_overlap_check(bs, QCOW2_OL_ACTIVE_L2,
197 c->entries[i].offset, s->cluster_size);
198 } else {
199 ret = qcow2_pre_write_overlap_check(bs, 0,
200 c->entries[i].offset, s->cluster_size);
201 }
202
203 if (ret < 0) {
204 return ret;
205 }
206
207 if (c == s->refcount_block_cache) {
208 BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_UPDATE_PART);
209 } else if (c == s->l2_table_cache) {
210 BLKDBG_EVENT(bs->file, BLKDBG_L2_UPDATE);
211 }
212
213 ret = bdrv_pwrite(bs->file, c->entries[i].offset,
214 qcow2_cache_get_table_addr(bs, c, i), s->cluster_size);
215 if (ret < 0) {
216 return ret;
217 }
218
219 c->entries[i].dirty = false;
220
221 return 0;
222 }
223
224 int qcow2_cache_write(BlockDriverState *bs, Qcow2Cache *c)
225 {
226 BDRVQcow2State *s = bs->opaque;
227 int result = 0;
228 int ret;
229 int i;
230
231 trace_qcow2_cache_flush(qemu_coroutine_self(), c == s->l2_table_cache);
232
233 for (i = 0; i < c->size; i++) {
234 ret = qcow2_cache_entry_flush(bs, c, i);
235 if (ret < 0 && result != -ENOSPC) {
236 result = ret;
237 }
238 }
239
240 return result;
241 }
242
243 int qcow2_cache_flush(BlockDriverState *bs, Qcow2Cache *c)
244 {
245 int result = qcow2_cache_write(bs, c);
246
247 if (result == 0) {
248 int ret = bdrv_flush(bs->file->bs);
249 if (ret < 0) {
250 result = ret;
251 }
252 }
253
254 return result;
255 }
256
257 int qcow2_cache_set_dependency(BlockDriverState *bs, Qcow2Cache *c,
258 Qcow2Cache *dependency)
259 {
260 int ret;
261
262 if (dependency->depends) {
263 ret = qcow2_cache_flush_dependency(bs, dependency);
264 if (ret < 0) {
265 return ret;
266 }
267 }
268
269 if (c->depends && (c->depends != dependency)) {
270 ret = qcow2_cache_flush_dependency(bs, c);
271 if (ret < 0) {
272 return ret;
273 }
274 }
275
276 c->depends = dependency;
277 return 0;
278 }
279
280 void qcow2_cache_depends_on_flush(Qcow2Cache *c)
281 {
282 c->depends_on_flush = true;
283 }
284
285 int qcow2_cache_empty(BlockDriverState *bs, Qcow2Cache *c)
286 {
287 int ret, i;
288
289 ret = qcow2_cache_flush(bs, c);
290 if (ret < 0) {
291 return ret;
292 }
293
294 for (i = 0; i < c->size; i++) {
295 assert(c->entries[i].ref == 0);
296 c->entries[i].offset = 0;
297 c->entries[i].lru_counter = 0;
298 }
299
300 qcow2_cache_table_release(bs, c, 0, c->size);
301
302 c->lru_counter = 0;
303
304 return 0;
305 }
306
307 static int qcow2_cache_do_get(BlockDriverState *bs, Qcow2Cache *c,
308 uint64_t offset, void **table, bool read_from_disk)
309 {
310 BDRVQcow2State *s = bs->opaque;
311 int i;
312 int ret;
313 int lookup_index;
314 uint64_t min_lru_counter = UINT64_MAX;
315 int min_lru_index = -1;
316
317 trace_qcow2_cache_get(qemu_coroutine_self(), c == s->l2_table_cache,
318 offset, read_from_disk);
319
320 /* Check if the table is already cached */
321 i = lookup_index = (offset / s->cluster_size * 4) % c->size;
322 do {
323 const Qcow2CachedTable *t = &c->entries[i];
324 if (t->offset == offset) {
325 goto found;
326 }
327 if (t->ref == 0 && t->lru_counter < min_lru_counter) {
328 min_lru_counter = t->lru_counter;
329 min_lru_index = i;
330 }
331 if (++i == c->size) {
332 i = 0;
333 }
334 } while (i != lookup_index);
335
336 if (min_lru_index == -1) {
337 /* This can't happen in current synchronous code, but leave the check
338 * here as a reminder for whoever starts using AIO with the cache */
339 abort();
340 }
341
342 /* Cache miss: write a table back and replace it */
343 i = min_lru_index;
344 trace_qcow2_cache_get_replace_entry(qemu_coroutine_self(),
345 c == s->l2_table_cache, i);
346
347 ret = qcow2_cache_entry_flush(bs, c, i);
348 if (ret < 0) {
349 return ret;
350 }
351
352 trace_qcow2_cache_get_read(qemu_coroutine_self(),
353 c == s->l2_table_cache, i);
354 c->entries[i].offset = 0;
355 if (read_from_disk) {
356 if (c == s->l2_table_cache) {
357 BLKDBG_EVENT(bs->file, BLKDBG_L2_LOAD);
358 }
359
360 ret = bdrv_pread(bs->file, offset,
361 qcow2_cache_get_table_addr(bs, c, i),
362 s->cluster_size);
363 if (ret < 0) {
364 return ret;
365 }
366 }
367
368 c->entries[i].offset = offset;
369
370 /* And return the right table */
371 found:
372 c->entries[i].ref++;
373 *table = qcow2_cache_get_table_addr(bs, c, i);
374
375 trace_qcow2_cache_get_done(qemu_coroutine_self(),
376 c == s->l2_table_cache, i);
377
378 return 0;
379 }
380
381 int qcow2_cache_get(BlockDriverState *bs, Qcow2Cache *c, uint64_t offset,
382 void **table)
383 {
384 return qcow2_cache_do_get(bs, c, offset, table, true);
385 }
386
387 int qcow2_cache_get_empty(BlockDriverState *bs, Qcow2Cache *c, uint64_t offset,
388 void **table)
389 {
390 return qcow2_cache_do_get(bs, c, offset, table, false);
391 }
392
393 void qcow2_cache_put(BlockDriverState *bs, Qcow2Cache *c, void **table)
394 {
395 int i = qcow2_cache_get_table_idx(bs, c, *table);
396
397 c->entries[i].ref--;
398 *table = NULL;
399
400 if (c->entries[i].ref == 0) {
401 c->entries[i].lru_counter = ++c->lru_counter;
402 }
403
404 assert(c->entries[i].ref >= 0);
405 }
406
407 void qcow2_cache_entry_mark_dirty(BlockDriverState *bs, Qcow2Cache *c,
408 void *table)
409 {
410 int i = qcow2_cache_get_table_idx(bs, c, table);
411 assert(c->entries[i].offset != 0);
412 c->entries[i].dirty = true;
413 }