![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to qcow2-cache.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / block|
Return to qcow2-cache.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / block |
1.1 root 1: /*
2: * L2/refcount table cache for the QCOW2 format
3: *
4: * Copyright (c) 2010 Kevin Wolf <[email protected]>
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_int.h"
26: #include "qemu-common.h"
27: #include "qcow2.h"
1.1.1.4 ! root 28: #include "trace.h"
1.1 root 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: bool writethrough;
44: };
45:
46: Qcow2Cache *qcow2_cache_create(BlockDriverState *bs, int num_tables,
47: bool writethrough)
48: {
49: BDRVQcowState *s = bs->opaque;
50: Qcow2Cache *c;
51: int i;
52:
1.1.1.3 root 53: c = g_malloc0(sizeof(*c));
1.1 root 54: c->size = num_tables;
1.1.1.3 root 55: c->entries = g_malloc0(sizeof(*c->entries) * num_tables);
1.1 root 56: c->writethrough = writethrough;
57:
58: for (i = 0; i < c->size; i++) {
59: c->entries[i].table = qemu_blockalign(bs, s->cluster_size);
60: }
61:
62: return c;
63: }
64:
65: int qcow2_cache_destroy(BlockDriverState* bs, Qcow2Cache *c)
66: {
67: int i;
68:
69: for (i = 0; i < c->size; i++) {
70: assert(c->entries[i].ref == 0);
71: qemu_vfree(c->entries[i].table);
72: }
73:
1.1.1.3 root 74: g_free(c->entries);
75: g_free(c);
1.1 root 76:
77: return 0;
78: }
79:
80: static int qcow2_cache_flush_dependency(BlockDriverState *bs, Qcow2Cache *c)
81: {
82: int ret;
83:
84: ret = qcow2_cache_flush(bs, c->depends);
85: if (ret < 0) {
86: return ret;
87: }
88:
89: c->depends = NULL;
90: c->depends_on_flush = false;
91:
92: return 0;
93: }
94:
95: static int qcow2_cache_entry_flush(BlockDriverState *bs, Qcow2Cache *c, int i)
96: {
97: BDRVQcowState *s = bs->opaque;
98: int ret = 0;
99:
100: if (!c->entries[i].dirty || !c->entries[i].offset) {
101: return 0;
102: }
103:
1.1.1.4 ! root 104: trace_qcow2_cache_entry_flush(qemu_coroutine_self(),
! 105: c == s->l2_table_cache, i);
! 106:
1.1 root 107: if (c->depends) {
108: ret = qcow2_cache_flush_dependency(bs, c);
109: } else if (c->depends_on_flush) {
110: ret = bdrv_flush(bs->file);
111: if (ret >= 0) {
112: c->depends_on_flush = false;
113: }
114: }
115:
116: if (ret < 0) {
117: return ret;
118: }
119:
120: if (c == s->refcount_block_cache) {
121: BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_UPDATE_PART);
122: } else if (c == s->l2_table_cache) {
123: BLKDBG_EVENT(bs->file, BLKDBG_L2_UPDATE);
124: }
125:
126: ret = bdrv_pwrite(bs->file, c->entries[i].offset, c->entries[i].table,
127: s->cluster_size);
128: if (ret < 0) {
129: return ret;
130: }
131:
132: c->entries[i].dirty = false;
133:
134: return 0;
135: }
136:
137: int qcow2_cache_flush(BlockDriverState *bs, Qcow2Cache *c)
138: {
1.1.1.4 ! root 139: BDRVQcowState *s = bs->opaque;
1.1 root 140: int result = 0;
141: int ret;
142: int i;
143:
1.1.1.4 ! root 144: trace_qcow2_cache_flush(qemu_coroutine_self(), c == s->l2_table_cache);
! 145:
1.1 root 146: for (i = 0; i < c->size; i++) {
147: ret = qcow2_cache_entry_flush(bs, c, i);
148: if (ret < 0 && result != -ENOSPC) {
149: result = ret;
150: }
151: }
152:
153: if (result == 0) {
154: ret = bdrv_flush(bs->file);
155: if (ret < 0) {
156: result = ret;
157: }
158: }
159:
160: return result;
161: }
162:
163: int qcow2_cache_set_dependency(BlockDriverState *bs, Qcow2Cache *c,
164: Qcow2Cache *dependency)
165: {
166: int ret;
167:
168: if (dependency->depends) {
169: ret = qcow2_cache_flush_dependency(bs, dependency);
170: if (ret < 0) {
171: return ret;
172: }
173: }
174:
175: if (c->depends && (c->depends != dependency)) {
176: ret = qcow2_cache_flush_dependency(bs, c);
177: if (ret < 0) {
178: return ret;
179: }
180: }
181:
182: c->depends = dependency;
183: return 0;
184: }
185:
186: void qcow2_cache_depends_on_flush(Qcow2Cache *c)
187: {
188: c->depends_on_flush = true;
189: }
190:
191: static int qcow2_cache_find_entry_to_replace(Qcow2Cache *c)
192: {
193: int i;
194: int min_count = INT_MAX;
195: int min_index = -1;
196:
197:
198: for (i = 0; i < c->size; i++) {
199: if (c->entries[i].ref) {
200: continue;
201: }
202:
203: if (c->entries[i].cache_hits < min_count) {
204: min_index = i;
205: min_count = c->entries[i].cache_hits;
206: }
207:
208: /* Give newer hits priority */
209: /* TODO Check how to optimize the replacement strategy */
210: c->entries[i].cache_hits /= 2;
211: }
212:
213: if (min_index == -1) {
214: /* This can't happen in current synchronous code, but leave the check
215: * here as a reminder for whoever starts using AIO with the cache */
216: abort();
217: }
218: return min_index;
219: }
220:
221: static int qcow2_cache_do_get(BlockDriverState *bs, Qcow2Cache *c,
222: uint64_t offset, void **table, bool read_from_disk)
223: {
224: BDRVQcowState *s = bs->opaque;
225: int i;
226: int ret;
227:
1.1.1.4 ! root 228: trace_qcow2_cache_get(qemu_coroutine_self(), c == s->l2_table_cache,
! 229: offset, read_from_disk);
! 230:
1.1 root 231: /* Check if the table is already cached */
232: for (i = 0; i < c->size; i++) {
233: if (c->entries[i].offset == offset) {
234: goto found;
235: }
236: }
237:
238: /* If not, write a table back and replace it */
239: i = qcow2_cache_find_entry_to_replace(c);
1.1.1.4 ! root 240: trace_qcow2_cache_get_replace_entry(qemu_coroutine_self(),
! 241: c == s->l2_table_cache, i);
1.1 root 242: if (i < 0) {
243: return i;
244: }
245:
246: ret = qcow2_cache_entry_flush(bs, c, i);
247: if (ret < 0) {
248: return ret;
249: }
250:
1.1.1.4 ! root 251: trace_qcow2_cache_get_read(qemu_coroutine_self(),
! 252: c == s->l2_table_cache, i);
1.1 root 253: c->entries[i].offset = 0;
254: if (read_from_disk) {
255: if (c == s->l2_table_cache) {
256: BLKDBG_EVENT(bs->file, BLKDBG_L2_LOAD);
257: }
258:
259: ret = bdrv_pread(bs->file, offset, c->entries[i].table, s->cluster_size);
260: if (ret < 0) {
261: return ret;
262: }
263: }
264:
265: /* Give the table some hits for the start so that it won't be replaced
266: * immediately. The number 32 is completely arbitrary. */
267: c->entries[i].cache_hits = 32;
268: c->entries[i].offset = offset;
269:
270: /* And return the right table */
271: found:
272: c->entries[i].cache_hits++;
273: c->entries[i].ref++;
274: *table = c->entries[i].table;
1.1.1.4 ! root 275:
! 276: trace_qcow2_cache_get_done(qemu_coroutine_self(),
! 277: c == s->l2_table_cache, i);
! 278:
1.1 root 279: return 0;
280: }
281:
282: int qcow2_cache_get(BlockDriverState *bs, Qcow2Cache *c, uint64_t offset,
283: void **table)
284: {
285: return qcow2_cache_do_get(bs, c, offset, table, true);
286: }
287:
288: int qcow2_cache_get_empty(BlockDriverState *bs, Qcow2Cache *c, uint64_t offset,
289: void **table)
290: {
291: return qcow2_cache_do_get(bs, c, offset, table, false);
292: }
293:
294: int qcow2_cache_put(BlockDriverState *bs, Qcow2Cache *c, void **table)
295: {
296: int i;
297:
298: for (i = 0; i < c->size; i++) {
299: if (c->entries[i].table == *table) {
300: goto found;
301: }
302: }
303: return -ENOENT;
304:
305: found:
306: c->entries[i].ref--;
307: *table = NULL;
308:
309: assert(c->entries[i].ref >= 0);
310:
311: if (c->writethrough) {
312: return qcow2_cache_entry_flush(bs, c, i);
313: } else {
314: return 0;
315: }
316: }
317:
318: void qcow2_cache_entry_mark_dirty(Qcow2Cache *c, void *table)
319: {
320: int i;
321:
322: for (i = 0; i < c->size; i++) {
323: if (c->entries[i].table == table) {
324: goto found;
325: }
326: }
327: abort();
328:
329: found:
330: c->entries[i].dirty = true;
331: }
332:
1.1.1.2 root 333: bool qcow2_cache_set_writethrough(BlockDriverState *bs, Qcow2Cache *c,
334: bool enable)
335: {
336: bool old = c->writethrough;
337:
338: if (!old && enable) {
339: qcow2_cache_flush(bs, c);
340: }
341:
342: c->writethrough = enable;
343: return old;
344: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.