| /* | |
| * L2/refcount table cache for the QCOW2 format | |
| * | |
| * Copyright (c) 2010 Kevin Wolf <kwolf@redhat.com> | |
| * | |
| * Permission is hereby granted, free of charge, to any person obtaining a copy | |
| * of this software and associated documentation files (the "Software"), to deal | |
| * in the Software without restriction, including without limitation the rights | |
| * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
| * copies of the Software, and to permit persons to whom the Software is | |
| * furnished to do so, subject to the following conditions: | |
| * | |
| * The above copyright notice and this permission notice shall be included in | |
| * all copies or substantial portions of the Software. | |
| * | |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | |
| * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
| * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
| * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
| * THE SOFTWARE. | |
| */ | |
| #include "qemu/osdep.h" | |
| #include "block/block-io.h" | |
| #include "qemu/memalign.h" | |
| #include "qcow2.h" | |
| #include "trace.h" | |
| typedef struct Qcow2CachedTable { | |
| int64_t offset; | |
| uint64_t lru_counter; | |
| int ref; | |
| bool dirty; | |
| } Qcow2CachedTable; | |
| struct Qcow2Cache { | |
| Qcow2CachedTable *entries; | |
| struct Qcow2Cache *depends; | |
| int size; | |
| int table_size; | |
| bool depends_on_flush; | |
| void *table_array; | |
| uint64_t lru_counter; | |
| uint64_t cache_clean_lru_counter; | |
| }; | |
| static inline void *qcow2_cache_get_table_addr(Qcow2Cache *c, int table) | |
| { | |
| return (uint8_t *) c->table_array + (size_t) table * c->table_size; | |
| } | |
| static inline int qcow2_cache_get_table_idx(Qcow2Cache *c, void *table) | |
| { | |
| ptrdiff_t table_offset = (uint8_t *) table - (uint8_t *) c->table_array; | |
| int idx = table_offset / c->table_size; | |
| assert(idx >= 0 && idx < c->size && table_offset % c->table_size == 0); | |
| return idx; | |
| } | |
| static inline const char *qcow2_cache_get_name(BDRVQcow2State *s, Qcow2Cache *c) | |
| { | |
| if (c == s->refcount_block_cache) { | |
| return "refcount block"; | |
| } else if (c == s->l2_table_cache) { | |
| return "L2 table"; | |
| } else { | |
| /* Do not abort, because this is not critical */ | |
| return "unknown"; | |
| } | |
| } | |
| static void qcow2_cache_table_release(Qcow2Cache *c, int i, int num_tables) | |
| { | |
| /* Using MADV_DONTNEED to discard memory is a Linux-specific feature */ | |
| #ifdef CONFIG_LINUX | |
| void *t = qcow2_cache_get_table_addr(c, i); | |
| int align = qemu_real_host_page_size(); | |
| size_t mem_size = (size_t) c->table_size * num_tables; | |
| size_t offset = QEMU_ALIGN_UP((uintptr_t) t, align) - (uintptr_t) t; | |
| size_t length = QEMU_ALIGN_DOWN(mem_size - offset, align); | |
| if (mem_size > offset && length > 0) { | |
| madvise((uint8_t *) t + offset, length, MADV_DONTNEED); | |
| } | |
| #endif | |
| } | |
| static inline bool can_clean_entry(Qcow2Cache *c, int i) | |
| { | |
| Qcow2CachedTable *t = &c->entries[i]; | |
| return t->ref == 0 && !t->dirty && t->offset != 0 && | |
| t->lru_counter <= c->cache_clean_lru_counter; | |
| } | |
| void qcow2_cache_clean_unused(Qcow2Cache *c) | |
| { | |
| int i = 0; | |
| while (i < c->size) { | |
| int to_clean = 0; | |
| /* Skip the entries that we don't need to clean */ | |
| while (i < c->size && !can_clean_entry(c, i)) { | |
| i++; | |
| } | |
| /* And count how many we can clean in a row */ | |
| while (i < c->size && can_clean_entry(c, i)) { | |
| c->entries[i].offset = 0; | |
| c->entries[i].lru_counter = 0; | |
| i++; | |
| to_clean++; | |
| } | |
| if (to_clean > 0) { | |
| qcow2_cache_table_release(c, i - to_clean, to_clean); | |
| } | |
| } | |
| c->cache_clean_lru_counter = c->lru_counter; | |
| } | |
| Qcow2Cache *qcow2_cache_create(BlockDriverState *bs, int num_tables, | |
| unsigned table_size) | |
| { | |
| BDRVQcow2State *s = bs->opaque; | |
| Qcow2Cache *c; | |
| assert(num_tables > 0); | |
| assert(is_power_of_2(table_size)); | |
| assert(table_size >= (1 << MIN_CLUSTER_BITS)); | |
| assert(table_size <= s->cluster_size); | |
| c = g_new0(Qcow2Cache, 1); | |
| c->size = num_tables; | |
| c->table_size = table_size; | |
| c->entries = g_try_new0(Qcow2CachedTable, num_tables); | |
| c->table_array = qemu_try_blockalign(bs->file->bs, | |
| (size_t) num_tables * c->table_size); | |
| if (!c->entries || !c->table_array) { | |
| qemu_vfree(c->table_array); | |
| g_free(c->entries); | |
| g_free(c); | |
| c = NULL; | |
| } | |
| return c; | |
| } | |
| int qcow2_cache_destroy(Qcow2Cache *c) | |
| { | |
| int i; | |
| for (i = 0; i < c->size; i++) { | |
| assert(c->entries[i].ref == 0); | |
| } | |
| qemu_vfree(c->table_array); | |
| g_free(c->entries); | |
| g_free(c); | |
| return 0; | |
| } | |
| static int GRAPH_RDLOCK | |
| qcow2_cache_flush_dependency(BlockDriverState *bs, Qcow2Cache *c) | |
| { | |
| int ret; | |
| ret = qcow2_cache_flush(bs, c->depends); | |
| if (ret < 0) { | |
| return ret; | |
| } | |
| c->depends = NULL; | |
| c->depends_on_flush = false; | |
| return 0; | |
| } | |
| static int GRAPH_RDLOCK | |
| qcow2_cache_entry_flush(BlockDriverState *bs, Qcow2Cache *c, int i) | |
| { | |
| BDRVQcow2State *s = bs->opaque; | |
| int ret = 0; | |
| if (!c->entries[i].dirty || !c->entries[i].offset) { | |
| return 0; | |
| } | |
| trace_qcow2_cache_entry_flush(qemu_coroutine_self(), | |
| c == s->l2_table_cache, i); | |
| if (c->depends) { | |
| ret = qcow2_cache_flush_dependency(bs, c); | |
| } else if (c->depends_on_flush) { | |
| ret = bdrv_flush(bs->file->bs); | |
| if (ret >= 0) { | |
| c->depends_on_flush = false; | |
| } | |
| } | |
| if (ret < 0) { | |
| return ret; | |
| } | |
| if (c == s->refcount_block_cache) { | |
| ret = qcow2_pre_write_overlap_check(bs, QCOW2_OL_REFCOUNT_BLOCK, | |
| c->entries[i].offset, c->table_size, false); | |
| } else if (c == s->l2_table_cache) { | |
| ret = qcow2_pre_write_overlap_check(bs, QCOW2_OL_ACTIVE_L2, | |
| c->entries[i].offset, c->table_size, false); | |
| } else { | |
| ret = qcow2_pre_write_overlap_check(bs, 0, | |
| c->entries[i].offset, c->table_size, false); | |
| } | |
| if (ret < 0) { | |
| return ret; | |
| } | |
| if (c == s->refcount_block_cache) { | |
| BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_UPDATE_PART); | |
| } else if (c == s->l2_table_cache) { | |
| BLKDBG_EVENT(bs->file, BLKDBG_L2_UPDATE); | |
| } | |
| ret = bdrv_pwrite(bs->file, c->entries[i].offset, c->table_size, | |
| qcow2_cache_get_table_addr(c, i), 0); | |
| if (ret < 0) { | |
| return ret; | |
| } | |
| c->entries[i].dirty = false; | |
| return 0; | |
| } | |
| int qcow2_cache_write(BlockDriverState *bs, Qcow2Cache *c) | |
| { | |
| BDRVQcow2State *s = bs->opaque; | |
| int result = 0; | |
| int ret; | |
| int i; | |
| trace_qcow2_cache_flush(qemu_coroutine_self(), c == s->l2_table_cache); | |
| for (i = 0; i < c->size; i++) { | |
| ret = qcow2_cache_entry_flush(bs, c, i); | |
| if (ret < 0 && result != -ENOSPC) { | |
| result = ret; | |
| } | |
| } | |
| return result; | |
| } | |
| int qcow2_cache_flush(BlockDriverState *bs, Qcow2Cache *c) | |
| { | |
| int result = qcow2_cache_write(bs, c); | |
| if (result == 0) { | |
| int ret = bdrv_flush(bs->file->bs); | |
| if (ret < 0) { | |
| result = ret; | |
| } | |
| } | |
| return result; | |
| } | |
| int qcow2_cache_set_dependency(BlockDriverState *bs, Qcow2Cache *c, | |
| Qcow2Cache *dependency) | |
| { | |
| int ret; | |
| if (dependency->depends) { | |
| ret = qcow2_cache_flush_dependency(bs, dependency); | |
| if (ret < 0) { | |
| return ret; | |
| } | |
| } | |
| if (c->depends && (c->depends != dependency)) { | |
| ret = qcow2_cache_flush_dependency(bs, c); | |
| if (ret < 0) { | |
| return ret; | |
| } | |
| } | |
| c->depends = dependency; | |
| return 0; | |
| } | |
| void qcow2_cache_depends_on_flush(Qcow2Cache *c) | |
| { | |
| c->depends_on_flush = true; | |
| } | |
| int qcow2_cache_empty(BlockDriverState *bs, Qcow2Cache *c) | |
| { | |
| int ret, i; | |
| ret = qcow2_cache_flush(bs, c); | |
| if (ret < 0) { | |
| return ret; | |
| } | |
| for (i = 0; i < c->size; i++) { | |
| assert(c->entries[i].ref == 0); | |
| c->entries[i].offset = 0; | |
| c->entries[i].lru_counter = 0; | |
| } | |
| qcow2_cache_table_release(c, 0, c->size); | |
| c->lru_counter = 0; | |
| return 0; | |
| } | |
| static int GRAPH_RDLOCK | |
| qcow2_cache_do_get(BlockDriverState *bs, Qcow2Cache *c, uint64_t offset, | |
| void **table, bool read_from_disk) | |
| { | |
| BDRVQcow2State *s = bs->opaque; | |
| int i; | |
| int ret; | |
| int lookup_index; | |
| uint64_t min_lru_counter = UINT64_MAX; | |
| int min_lru_index = -1; | |
| assert(offset != 0); | |
| trace_qcow2_cache_get(qemu_coroutine_self(), c == s->l2_table_cache, | |
| offset, read_from_disk); | |
| if (!QEMU_IS_ALIGNED(offset, c->table_size)) { | |
| qcow2_signal_corruption(bs, true, -1, -1, "Cannot get entry from %s " | |
| "cache: Offset %#" PRIx64 " is unaligned", | |
| qcow2_cache_get_name(s, c), offset); | |
| return -EIO; | |
| } | |
| /* Check if the table is already cached */ | |
| i = lookup_index = (offset / c->table_size * 4) % c->size; | |
| do { | |
| const Qcow2CachedTable *t = &c->entries[i]; | |
| if (t->offset == offset) { | |
| goto found; | |
| } | |
| if (t->ref == 0 && t->lru_counter < min_lru_counter) { | |
| min_lru_counter = t->lru_counter; | |
| min_lru_index = i; | |
| } | |
| if (++i == c->size) { | |
| i = 0; | |
| } | |
| } while (i != lookup_index); | |
| if (min_lru_index == -1) { | |
| /* This can't happen in current synchronous code, but leave the check | |
| * here as a reminder for whoever starts using AIO with the cache */ | |
| abort(); | |
| } | |
| /* Cache miss: write a table back and replace it */ | |
| i = min_lru_index; | |
| trace_qcow2_cache_get_replace_entry(qemu_coroutine_self(), | |
| c == s->l2_table_cache, i); | |
| ret = qcow2_cache_entry_flush(bs, c, i); | |
| if (ret < 0) { | |
| return ret; | |
| } | |
| trace_qcow2_cache_get_read(qemu_coroutine_self(), | |
| c == s->l2_table_cache, i); | |
| c->entries[i].offset = 0; | |
| if (read_from_disk) { | |
| if (c == s->l2_table_cache) { | |
| BLKDBG_EVENT(bs->file, BLKDBG_L2_LOAD); | |
| } | |
| ret = bdrv_pread(bs->file, offset, c->table_size, | |
| qcow2_cache_get_table_addr(c, i), 0); | |
| if (ret < 0) { | |
| return ret; | |
| } | |
| } | |
| c->entries[i].offset = offset; | |
| /* And return the right table */ | |
| found: | |
| c->entries[i].ref++; | |
| *table = qcow2_cache_get_table_addr(c, i); | |
| trace_qcow2_cache_get_done(qemu_coroutine_self(), | |
| c == s->l2_table_cache, i); | |
| return 0; | |
| } | |
| int qcow2_cache_get(BlockDriverState *bs, Qcow2Cache *c, uint64_t offset, | |
| void **table) | |
| { | |
| return qcow2_cache_do_get(bs, c, offset, table, true); | |
| } | |
| int qcow2_cache_get_empty(BlockDriverState *bs, Qcow2Cache *c, uint64_t offset, | |
| void **table) | |
| { | |
| return qcow2_cache_do_get(bs, c, offset, table, false); | |
| } | |
| void qcow2_cache_put(Qcow2Cache *c, void **table) | |
| { | |
| int i = qcow2_cache_get_table_idx(c, *table); | |
| c->entries[i].ref--; | |
| *table = NULL; | |
| if (c->entries[i].ref == 0) { | |
| c->entries[i].lru_counter = ++c->lru_counter; | |
| } | |
| assert(c->entries[i].ref >= 0); | |
| } | |
| void qcow2_cache_entry_mark_dirty(Qcow2Cache *c, void *table) | |
| { | |
| int i = qcow2_cache_get_table_idx(c, table); | |
| assert(c->entries[i].offset != 0); | |
| c->entries[i].dirty = true; | |
| } | |
| void *qcow2_cache_is_table_offset(Qcow2Cache *c, uint64_t offset) | |
| { | |
| int i; | |
| for (i = 0; i < c->size; i++) { | |
| if (c->entries[i].offset == offset) { | |
| return qcow2_cache_get_table_addr(c, i); | |
| } | |
| } | |
| return NULL; | |
| } | |
| void qcow2_cache_discard(Qcow2Cache *c, void *table) | |
| { | |
| int i = qcow2_cache_get_table_idx(c, table); | |
| assert(c->entries[i].ref == 0); | |
| c->entries[i].offset = 0; | |
| c->entries[i].lru_counter = 0; | |
| c->entries[i].dirty = false; | |
| qcow2_cache_table_release(c, i, 1); | |
| } |