bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Block driver for the QCOW version 2 format |
ths | 5fafdf2 | 2007-09-16 21:08:06 +0000 | [diff] [blame] | 3 | * |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 4 | * Copyright (c) 2004-2006 Fabrice Bellard |
ths | 5fafdf2 | 2007-09-16 21:08:06 +0000 | [diff] [blame] | 5 | * |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 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 | */ |
pbrook | faf0796 | 2007-11-11 02:51:17 +0000 | [diff] [blame] | 24 | #include "qemu-common.h" |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 25 | #include "block_int.h" |
Anthony Liguori | 5efa9d5 | 2009-05-09 17:03:42 -0500 | [diff] [blame] | 26 | #include "module.h" |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 27 | #include <zlib.h> |
| 28 | #include "aes.h" |
Kevin Wolf | f7d0fe0 | 2009-05-28 16:07:04 +0200 | [diff] [blame] | 29 | #include "block/qcow2.h" |
Kevin Wolf | a942073 | 2010-06-11 21:37:37 +0200 | [diff] [blame] | 30 | #include "qemu-error.h" |
Kevin Wolf | e8cdcec | 2011-02-09 11:11:07 +0100 | [diff] [blame] | 31 | #include "qerror.h" |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 32 | |
| 33 | /* |
| 34 | Differences with QCOW: |
| 35 | |
| 36 | - Support for multiple incremental snapshots. |
| 37 | - Memory management by reference counts. |
| 38 | - Clusters which have a reference count of one have the bit |
| 39 | QCOW_OFLAG_COPIED to optimize write performance. |
ths | 5fafdf2 | 2007-09-16 21:08:06 +0000 | [diff] [blame] | 40 | - Size of compressed clusters is stored in sectors to reduce bit usage |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 41 | in the cluster offsets. |
| 42 | - Support for storing additional data (such as the VM state) in the |
ths | 3b46e62 | 2007-09-17 08:09:54 +0000 | [diff] [blame] | 43 | snapshots. |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 44 | - If a backing store is used, the cluster size is not constrained |
| 45 | (could be backported to QCOW). |
| 46 | - L2 tables have always a size of one cluster. |
| 47 | */ |
| 48 | |
aliguori | 9b80ddf | 2009-03-28 17:55:06 +0000 | [diff] [blame] | 49 | |
| 50 | typedef struct { |
| 51 | uint32_t magic; |
| 52 | uint32_t len; |
| 53 | } QCowExtension; |
Jes Sorensen | 7c80ab3 | 2010-12-17 16:02:39 +0100 | [diff] [blame] | 54 | #define QCOW2_EXT_MAGIC_END 0 |
| 55 | #define QCOW2_EXT_MAGIC_BACKING_FORMAT 0xE2792ACA |
aliguori | 9b80ddf | 2009-03-28 17:55:06 +0000 | [diff] [blame] | 56 | |
Jes Sorensen | 7c80ab3 | 2010-12-17 16:02:39 +0100 | [diff] [blame] | 57 | static int qcow2_probe(const uint8_t *buf, int buf_size, const char *filename) |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 58 | { |
| 59 | const QCowHeader *cow_header = (const void *)buf; |
ths | 3b46e62 | 2007-09-17 08:09:54 +0000 | [diff] [blame] | 60 | |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 61 | if (buf_size >= sizeof(QCowHeader) && |
| 62 | be32_to_cpu(cow_header->magic) == QCOW_MAGIC && |
Kevin Wolf | e8cdcec | 2011-02-09 11:11:07 +0100 | [diff] [blame] | 63 | be32_to_cpu(cow_header->version) >= QCOW_VERSION) |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 64 | return 100; |
| 65 | else |
| 66 | return 0; |
| 67 | } |
| 68 | |
aliguori | 9b80ddf | 2009-03-28 17:55:06 +0000 | [diff] [blame] | 69 | |
| 70 | /* |
| 71 | * read qcow2 extension and fill bs |
| 72 | * start reading from start_offset |
| 73 | * finish reading upon magic of value 0 or when end_offset reached |
| 74 | * unknown magic is skipped (future extension this version knows nothing about) |
| 75 | * return 0 upon success, non-0 otherwise |
| 76 | */ |
Jes Sorensen | 7c80ab3 | 2010-12-17 16:02:39 +0100 | [diff] [blame] | 77 | static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset, |
| 78 | uint64_t end_offset) |
aliguori | 9b80ddf | 2009-03-28 17:55:06 +0000 | [diff] [blame] | 79 | { |
aliguori | 9b80ddf | 2009-03-28 17:55:06 +0000 | [diff] [blame] | 80 | QCowExtension ext; |
| 81 | uint64_t offset; |
| 82 | |
| 83 | #ifdef DEBUG_EXT |
Jes Sorensen | 7c80ab3 | 2010-12-17 16:02:39 +0100 | [diff] [blame] | 84 | printf("qcow2_read_extensions: start=%ld end=%ld\n", start_offset, end_offset); |
aliguori | 9b80ddf | 2009-03-28 17:55:06 +0000 | [diff] [blame] | 85 | #endif |
| 86 | offset = start_offset; |
| 87 | while (offset < end_offset) { |
| 88 | |
| 89 | #ifdef DEBUG_EXT |
| 90 | /* Sanity check */ |
| 91 | if (offset > s->cluster_size) |
Jes Sorensen | 7c80ab3 | 2010-12-17 16:02:39 +0100 | [diff] [blame] | 92 | printf("qcow2_read_extension: suspicious offset %lu\n", offset); |
aliguori | 9b80ddf | 2009-03-28 17:55:06 +0000 | [diff] [blame] | 93 | |
| 94 | printf("attemting to read extended header in offset %lu\n", offset); |
| 95 | #endif |
| 96 | |
Kevin Wolf | 66f82ce | 2010-04-14 14:17:38 +0200 | [diff] [blame] | 97 | if (bdrv_pread(bs->file, offset, &ext, sizeof(ext)) != sizeof(ext)) { |
Jes Sorensen | 7c80ab3 | 2010-12-17 16:02:39 +0100 | [diff] [blame] | 98 | fprintf(stderr, "qcow2_read_extension: ERROR: " |
Blue Swirl | 0bfcd59 | 2010-05-22 08:02:12 +0000 | [diff] [blame] | 99 | "pread fail from offset %" PRIu64 "\n", |
| 100 | offset); |
aliguori | 9b80ddf | 2009-03-28 17:55:06 +0000 | [diff] [blame] | 101 | return 1; |
| 102 | } |
| 103 | be32_to_cpus(&ext.magic); |
| 104 | be32_to_cpus(&ext.len); |
| 105 | offset += sizeof(ext); |
| 106 | #ifdef DEBUG_EXT |
| 107 | printf("ext.magic = 0x%x\n", ext.magic); |
| 108 | #endif |
| 109 | switch (ext.magic) { |
Jes Sorensen | 7c80ab3 | 2010-12-17 16:02:39 +0100 | [diff] [blame] | 110 | case QCOW2_EXT_MAGIC_END: |
aliguori | 9b80ddf | 2009-03-28 17:55:06 +0000 | [diff] [blame] | 111 | return 0; |
aliguori | f965509 | 2009-03-28 17:55:14 +0000 | [diff] [blame] | 112 | |
Jes Sorensen | 7c80ab3 | 2010-12-17 16:02:39 +0100 | [diff] [blame] | 113 | case QCOW2_EXT_MAGIC_BACKING_FORMAT: |
aliguori | f965509 | 2009-03-28 17:55:14 +0000 | [diff] [blame] | 114 | if (ext.len >= sizeof(bs->backing_format)) { |
| 115 | fprintf(stderr, "ERROR: ext_backing_format: len=%u too large" |
aliguori | 4c97807 | 2009-03-29 01:31:56 +0000 | [diff] [blame] | 116 | " (>=%zu)\n", |
aliguori | f965509 | 2009-03-28 17:55:14 +0000 | [diff] [blame] | 117 | ext.len, sizeof(bs->backing_format)); |
| 118 | return 2; |
| 119 | } |
Kevin Wolf | 66f82ce | 2010-04-14 14:17:38 +0200 | [diff] [blame] | 120 | if (bdrv_pread(bs->file, offset , bs->backing_format, |
aliguori | f965509 | 2009-03-28 17:55:14 +0000 | [diff] [blame] | 121 | ext.len) != ext.len) |
| 122 | return 3; |
| 123 | bs->backing_format[ext.len] = '\0'; |
| 124 | #ifdef DEBUG_EXT |
| 125 | printf("Qcow2: Got format extension %s\n", bs->backing_format); |
| 126 | #endif |
Kevin Wolf | e1c7f0e | 2009-11-26 14:03:42 +0100 | [diff] [blame] | 127 | offset = ((offset + ext.len + 7) & ~7); |
aliguori | f965509 | 2009-03-28 17:55:14 +0000 | [diff] [blame] | 128 | break; |
| 129 | |
aliguori | 9b80ddf | 2009-03-28 17:55:06 +0000 | [diff] [blame] | 130 | default: |
| 131 | /* unknown magic -- just skip it */ |
Kevin Wolf | e1c7f0e | 2009-11-26 14:03:42 +0100 | [diff] [blame] | 132 | offset = ((offset + ext.len + 7) & ~7); |
aliguori | 9b80ddf | 2009-03-28 17:55:06 +0000 | [diff] [blame] | 133 | break; |
| 134 | } |
| 135 | } |
| 136 | |
| 137 | return 0; |
| 138 | } |
| 139 | |
| 140 | |
Jes Sorensen | 7c80ab3 | 2010-12-17 16:02:39 +0100 | [diff] [blame] | 141 | static int qcow2_open(BlockDriverState *bs, int flags) |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 142 | { |
| 143 | BDRVQcowState *s = bs->opaque; |
Jes Sorensen | 6d85a57 | 2010-12-17 16:02:40 +0100 | [diff] [blame] | 144 | int len, i, ret = 0; |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 145 | QCowHeader header; |
aliguori | 9b80ddf | 2009-03-28 17:55:06 +0000 | [diff] [blame] | 146 | uint64_t ext_end; |
Kevin Wolf | 29c1a73 | 2011-01-10 17:17:28 +0100 | [diff] [blame] | 147 | bool writethrough; |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 148 | |
Jes Sorensen | 6d85a57 | 2010-12-17 16:02:40 +0100 | [diff] [blame] | 149 | ret = bdrv_pread(bs->file, 0, &header, sizeof(header)); |
| 150 | if (ret < 0) { |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 151 | goto fail; |
Jes Sorensen | 6d85a57 | 2010-12-17 16:02:40 +0100 | [diff] [blame] | 152 | } |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 153 | be32_to_cpus(&header.magic); |
| 154 | be32_to_cpus(&header.version); |
| 155 | be64_to_cpus(&header.backing_file_offset); |
| 156 | be32_to_cpus(&header.backing_file_size); |
| 157 | be64_to_cpus(&header.size); |
| 158 | be32_to_cpus(&header.cluster_bits); |
| 159 | be32_to_cpus(&header.crypt_method); |
| 160 | be64_to_cpus(&header.l1_table_offset); |
| 161 | be32_to_cpus(&header.l1_size); |
| 162 | be64_to_cpus(&header.refcount_table_offset); |
| 163 | be32_to_cpus(&header.refcount_table_clusters); |
| 164 | be64_to_cpus(&header.snapshots_offset); |
| 165 | be32_to_cpus(&header.nb_snapshots); |
ths | 3b46e62 | 2007-09-17 08:09:54 +0000 | [diff] [blame] | 166 | |
Kevin Wolf | e8cdcec | 2011-02-09 11:11:07 +0100 | [diff] [blame] | 167 | if (header.magic != QCOW_MAGIC) { |
Jes Sorensen | 6d85a57 | 2010-12-17 16:02:40 +0100 | [diff] [blame] | 168 | ret = -EINVAL; |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 169 | goto fail; |
Jes Sorensen | 6d85a57 | 2010-12-17 16:02:40 +0100 | [diff] [blame] | 170 | } |
Kevin Wolf | e8cdcec | 2011-02-09 11:11:07 +0100 | [diff] [blame] | 171 | if (header.version != QCOW_VERSION) { |
| 172 | char version[64]; |
| 173 | snprintf(version, sizeof(version), "QCOW version %d", header.version); |
| 174 | qerror_report(QERR_UNKNOWN_BLOCK_FORMAT_FEATURE, |
| 175 | bs->device_name, "qcow2", version); |
| 176 | ret = -ENOTSUP; |
| 177 | goto fail; |
| 178 | } |
Stefan Weil | d191d12 | 2009-10-26 16:11:16 +0100 | [diff] [blame] | 179 | if (header.cluster_bits < MIN_CLUSTER_BITS || |
Jes Sorensen | 6d85a57 | 2010-12-17 16:02:40 +0100 | [diff] [blame] | 180 | header.cluster_bits > MAX_CLUSTER_BITS) { |
| 181 | ret = -EINVAL; |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 182 | goto fail; |
Jes Sorensen | 6d85a57 | 2010-12-17 16:02:40 +0100 | [diff] [blame] | 183 | } |
| 184 | if (header.crypt_method > QCOW_CRYPT_AES) { |
| 185 | ret = -EINVAL; |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 186 | goto fail; |
Jes Sorensen | 6d85a57 | 2010-12-17 16:02:40 +0100 | [diff] [blame] | 187 | } |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 188 | s->crypt_method_header = header.crypt_method; |
Jes Sorensen | 6d85a57 | 2010-12-17 16:02:40 +0100 | [diff] [blame] | 189 | if (s->crypt_method_header) { |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 190 | bs->encrypted = 1; |
Jes Sorensen | 6d85a57 | 2010-12-17 16:02:40 +0100 | [diff] [blame] | 191 | } |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 192 | s->cluster_bits = header.cluster_bits; |
| 193 | s->cluster_size = 1 << s->cluster_bits; |
| 194 | s->cluster_sectors = 1 << (s->cluster_bits - 9); |
| 195 | s->l2_bits = s->cluster_bits - 3; /* L2 is always one cluster */ |
| 196 | s->l2_size = 1 << s->l2_bits; |
| 197 | bs->total_sectors = header.size / 512; |
| 198 | s->csize_shift = (62 - (s->cluster_bits - 8)); |
| 199 | s->csize_mask = (1 << (s->cluster_bits - 8)) - 1; |
| 200 | s->cluster_offset_mask = (1LL << s->csize_shift) - 1; |
| 201 | s->refcount_table_offset = header.refcount_table_offset; |
ths | 5fafdf2 | 2007-09-16 21:08:06 +0000 | [diff] [blame] | 202 | s->refcount_table_size = |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 203 | header.refcount_table_clusters << (s->cluster_bits - 3); |
| 204 | |
| 205 | s->snapshots_offset = header.snapshots_offset; |
| 206 | s->nb_snapshots = header.nb_snapshots; |
| 207 | |
| 208 | /* read the level 1 table */ |
| 209 | s->l1_size = header.l1_size; |
Stefan Hajnoczi | 419b19d | 2010-04-28 11:36:11 +0100 | [diff] [blame] | 210 | s->l1_vm_state_index = size_to_l1(s, header.size); |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 211 | /* the L1 table must contain at least enough entries to put |
| 212 | header.size bytes */ |
Jes Sorensen | 6d85a57 | 2010-12-17 16:02:40 +0100 | [diff] [blame] | 213 | if (s->l1_size < s->l1_vm_state_index) { |
| 214 | ret = -EINVAL; |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 215 | goto fail; |
Jes Sorensen | 6d85a57 | 2010-12-17 16:02:40 +0100 | [diff] [blame] | 216 | } |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 217 | s->l1_table_offset = header.l1_table_offset; |
Stefan Weil | d191d12 | 2009-10-26 16:11:16 +0100 | [diff] [blame] | 218 | if (s->l1_size > 0) { |
| 219 | s->l1_table = qemu_mallocz( |
| 220 | align_offset(s->l1_size * sizeof(uint64_t), 512)); |
Jes Sorensen | 6d85a57 | 2010-12-17 16:02:40 +0100 | [diff] [blame] | 221 | ret = bdrv_pread(bs->file, s->l1_table_offset, s->l1_table, |
| 222 | s->l1_size * sizeof(uint64_t)); |
| 223 | if (ret < 0) { |
Stefan Weil | d191d12 | 2009-10-26 16:11:16 +0100 | [diff] [blame] | 224 | goto fail; |
Jes Sorensen | 6d85a57 | 2010-12-17 16:02:40 +0100 | [diff] [blame] | 225 | } |
Stefan Weil | d191d12 | 2009-10-26 16:11:16 +0100 | [diff] [blame] | 226 | for(i = 0;i < s->l1_size; i++) { |
| 227 | be64_to_cpus(&s->l1_table[i]); |
| 228 | } |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 229 | } |
Kevin Wolf | 29c1a73 | 2011-01-10 17:17:28 +0100 | [diff] [blame] | 230 | |
| 231 | /* alloc L2 table/refcount block cache */ |
Christoph Hellwig | a659979 | 2011-05-17 18:04:06 +0200 | [diff] [blame] | 232 | writethrough = ((flags & BDRV_O_CACHE_WB) == 0); |
Kevin Wolf | 29c1a73 | 2011-01-10 17:17:28 +0100 | [diff] [blame] | 233 | s->l2_table_cache = qcow2_cache_create(bs, L2_CACHE_SIZE, writethrough); |
| 234 | s->refcount_block_cache = qcow2_cache_create(bs, REFCOUNT_CACHE_SIZE, |
| 235 | writethrough); |
| 236 | |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 237 | s->cluster_cache = qemu_malloc(s->cluster_size); |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 238 | /* one more sector for decompressed data alignment */ |
aliguori | 095a9c5 | 2008-08-14 18:10:28 +0000 | [diff] [blame] | 239 | s->cluster_data = qemu_malloc(QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size |
| 240 | + 512); |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 241 | s->cluster_cache_offset = -1; |
ths | 3b46e62 | 2007-09-17 08:09:54 +0000 | [diff] [blame] | 242 | |
Jes Sorensen | 6d85a57 | 2010-12-17 16:02:40 +0100 | [diff] [blame] | 243 | ret = qcow2_refcount_init(bs); |
| 244 | if (ret != 0) { |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 245 | goto fail; |
Jes Sorensen | 6d85a57 | 2010-12-17 16:02:40 +0100 | [diff] [blame] | 246 | } |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 247 | |
Blue Swirl | 72cf2d4 | 2009-09-12 07:36:22 +0000 | [diff] [blame] | 248 | QLIST_INIT(&s->cluster_allocs); |
Kevin Wolf | f214978 | 2009-08-31 16:48:49 +0200 | [diff] [blame] | 249 | |
aliguori | 9b80ddf | 2009-03-28 17:55:06 +0000 | [diff] [blame] | 250 | /* read qcow2 extensions */ |
Jes Sorensen | 6d85a57 | 2010-12-17 16:02:40 +0100 | [diff] [blame] | 251 | if (header.backing_file_offset) { |
aliguori | 9b80ddf | 2009-03-28 17:55:06 +0000 | [diff] [blame] | 252 | ext_end = header.backing_file_offset; |
Jes Sorensen | 6d85a57 | 2010-12-17 16:02:40 +0100 | [diff] [blame] | 253 | } else { |
aliguori | 9b80ddf | 2009-03-28 17:55:06 +0000 | [diff] [blame] | 254 | ext_end = s->cluster_size; |
Jes Sorensen | 6d85a57 | 2010-12-17 16:02:40 +0100 | [diff] [blame] | 255 | } |
| 256 | if (qcow2_read_extensions(bs, sizeof(header), ext_end)) { |
| 257 | ret = -EINVAL; |
aliguori | 9b80ddf | 2009-03-28 17:55:06 +0000 | [diff] [blame] | 258 | goto fail; |
Jes Sorensen | 6d85a57 | 2010-12-17 16:02:40 +0100 | [diff] [blame] | 259 | } |
aliguori | 9b80ddf | 2009-03-28 17:55:06 +0000 | [diff] [blame] | 260 | |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 261 | /* read the backing file name */ |
| 262 | if (header.backing_file_offset != 0) { |
| 263 | len = header.backing_file_size; |
Jes Sorensen | 6d85a57 | 2010-12-17 16:02:40 +0100 | [diff] [blame] | 264 | if (len > 1023) { |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 265 | len = 1023; |
Jes Sorensen | 6d85a57 | 2010-12-17 16:02:40 +0100 | [diff] [blame] | 266 | } |
| 267 | ret = bdrv_pread(bs->file, header.backing_file_offset, |
| 268 | bs->backing_file, len); |
| 269 | if (ret < 0) { |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 270 | goto fail; |
Jes Sorensen | 6d85a57 | 2010-12-17 16:02:40 +0100 | [diff] [blame] | 271 | } |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 272 | bs->backing_file[len] = '\0'; |
| 273 | } |
Jes Sorensen | 6d85a57 | 2010-12-17 16:02:40 +0100 | [diff] [blame] | 274 | if (qcow2_read_snapshots(bs) < 0) { |
| 275 | ret = -EINVAL; |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 276 | goto fail; |
Jes Sorensen | 6d85a57 | 2010-12-17 16:02:40 +0100 | [diff] [blame] | 277 | } |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 278 | |
| 279 | #ifdef DEBUG_ALLOC |
Filip Navara | 14899cd | 2009-06-23 19:17:30 -0500 | [diff] [blame] | 280 | qcow2_check_refcounts(bs); |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 281 | #endif |
Jes Sorensen | 6d85a57 | 2010-12-17 16:02:40 +0100 | [diff] [blame] | 282 | return ret; |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 283 | |
| 284 | fail: |
Kevin Wolf | ed6ccf0 | 2009-05-28 16:07:07 +0200 | [diff] [blame] | 285 | qcow2_free_snapshots(bs); |
| 286 | qcow2_refcount_close(bs); |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 287 | qemu_free(s->l1_table); |
Kevin Wolf | 29c1a73 | 2011-01-10 17:17:28 +0100 | [diff] [blame] | 288 | if (s->l2_table_cache) { |
| 289 | qcow2_cache_destroy(bs, s->l2_table_cache); |
| 290 | } |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 291 | qemu_free(s->cluster_cache); |
| 292 | qemu_free(s->cluster_data); |
Jes Sorensen | 6d85a57 | 2010-12-17 16:02:40 +0100 | [diff] [blame] | 293 | return ret; |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 294 | } |
| 295 | |
Jes Sorensen | 7c80ab3 | 2010-12-17 16:02:39 +0100 | [diff] [blame] | 296 | static int qcow2_set_key(BlockDriverState *bs, const char *key) |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 297 | { |
| 298 | BDRVQcowState *s = bs->opaque; |
| 299 | uint8_t keybuf[16]; |
| 300 | int len, i; |
ths | 3b46e62 | 2007-09-17 08:09:54 +0000 | [diff] [blame] | 301 | |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 302 | memset(keybuf, 0, 16); |
| 303 | len = strlen(key); |
| 304 | if (len > 16) |
| 305 | len = 16; |
| 306 | /* XXX: we could compress the chars to 7 bits to increase |
| 307 | entropy */ |
| 308 | for(i = 0;i < len;i++) { |
| 309 | keybuf[i] = key[i]; |
| 310 | } |
| 311 | s->crypt_method = s->crypt_method_header; |
| 312 | |
| 313 | if (AES_set_encrypt_key(keybuf, 128, &s->aes_encrypt_key) != 0) |
| 314 | return -1; |
| 315 | if (AES_set_decrypt_key(keybuf, 128, &s->aes_decrypt_key) != 0) |
| 316 | return -1; |
| 317 | #if 0 |
| 318 | /* test */ |
| 319 | { |
| 320 | uint8_t in[16]; |
| 321 | uint8_t out[16]; |
| 322 | uint8_t tmp[16]; |
| 323 | for(i=0;i<16;i++) |
| 324 | in[i] = i; |
| 325 | AES_encrypt(in, tmp, &s->aes_encrypt_key); |
| 326 | AES_decrypt(tmp, out, &s->aes_decrypt_key); |
| 327 | for(i = 0; i < 16; i++) |
| 328 | printf(" %02x", tmp[i]); |
| 329 | printf("\n"); |
| 330 | for(i = 0; i < 16; i++) |
| 331 | printf(" %02x", out[i]); |
| 332 | printf("\n"); |
| 333 | } |
| 334 | #endif |
| 335 | return 0; |
| 336 | } |
| 337 | |
Jes Sorensen | 7c80ab3 | 2010-12-17 16:02:39 +0100 | [diff] [blame] | 338 | static int qcow2_is_allocated(BlockDriverState *bs, int64_t sector_num, |
| 339 | int nb_sectors, int *pnum) |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 340 | { |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 341 | uint64_t cluster_offset; |
Kevin Wolf | 1c46efa | 2010-05-21 17:59:36 +0200 | [diff] [blame] | 342 | int ret; |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 343 | |
aliguori | 095a9c5 | 2008-08-14 18:10:28 +0000 | [diff] [blame] | 344 | *pnum = nb_sectors; |
Kevin Wolf | 1c46efa | 2010-05-21 17:59:36 +0200 | [diff] [blame] | 345 | /* FIXME We can get errors here, but the bdrv_is_allocated interface can't |
| 346 | * pass them on today */ |
| 347 | ret = qcow2_get_cluster_offset(bs, sector_num << 9, pnum, &cluster_offset); |
| 348 | if (ret < 0) { |
| 349 | *pnum = 0; |
| 350 | } |
aliguori | 095a9c5 | 2008-08-14 18:10:28 +0000 | [diff] [blame] | 351 | |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 352 | return (cluster_offset != 0); |
| 353 | } |
| 354 | |
bellard | a946592 | 2006-08-06 13:34:04 +0000 | [diff] [blame] | 355 | /* handle reading after the end of the backing file */ |
Kevin Wolf | bd28f83 | 2010-09-13 18:08:52 +0200 | [diff] [blame] | 356 | int qcow2_backing_read1(BlockDriverState *bs, QEMUIOVector *qiov, |
| 357 | int64_t sector_num, int nb_sectors) |
bellard | a946592 | 2006-08-06 13:34:04 +0000 | [diff] [blame] | 358 | { |
| 359 | int n1; |
| 360 | if ((sector_num + nb_sectors) <= bs->total_sectors) |
| 361 | return nb_sectors; |
| 362 | if (sector_num >= bs->total_sectors) |
| 363 | n1 = 0; |
| 364 | else |
| 365 | n1 = bs->total_sectors - sector_num; |
Kevin Wolf | bd28f83 | 2010-09-13 18:08:52 +0200 | [diff] [blame] | 366 | |
Chunqiang Tang | e0d9c6f | 2011-02-03 10:12:49 -0500 | [diff] [blame] | 367 | qemu_iovec_memset_skip(qiov, 0, 512 * (nb_sectors - n1), 512 * n1); |
Kevin Wolf | bd28f83 | 2010-09-13 18:08:52 +0200 | [diff] [blame] | 368 | |
bellard | a946592 | 2006-08-06 13:34:04 +0000 | [diff] [blame] | 369 | return n1; |
| 370 | } |
| 371 | |
pbrook | ce1a14d | 2006-08-07 02:38:06 +0000 | [diff] [blame] | 372 | typedef struct QCowAIOCB { |
| 373 | BlockDriverAIOCB common; |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 374 | int64_t sector_num; |
aliguori | f141eaf | 2009-04-07 18:43:24 +0000 | [diff] [blame] | 375 | QEMUIOVector *qiov; |
Christoph Hellwig | 7b88e48 | 2010-01-21 16:12:09 +0100 | [diff] [blame] | 376 | int remaining_sectors; |
| 377 | int cur_nr_sectors; /* number of sectors in current iteration */ |
Kevin Wolf | bd28f83 | 2010-09-13 18:08:52 +0200 | [diff] [blame] | 378 | uint64_t bytes_done; |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 379 | uint64_t cluster_offset; |
ths | 5fafdf2 | 2007-09-16 21:08:06 +0000 | [diff] [blame] | 380 | uint8_t *cluster_data; |
Kevin Wolf | 42496d6 | 2011-06-07 15:04:32 +0200 | [diff] [blame] | 381 | bool is_write; |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 382 | BlockDriverAIOCB *hd_aiocb; |
aliguori | c87c067 | 2009-04-07 18:43:20 +0000 | [diff] [blame] | 383 | QEMUIOVector hd_qiov; |
aliguori | 1490791 | 2008-10-31 17:28:00 +0000 | [diff] [blame] | 384 | QEMUBH *bh; |
aliguori | e976c6a | 2008-12-02 20:14:05 +0000 | [diff] [blame] | 385 | QCowL2Meta l2meta; |
Blue Swirl | 72cf2d4 | 2009-09-12 07:36:22 +0000 | [diff] [blame] | 386 | QLIST_ENTRY(QCowAIOCB) next_depend; |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 387 | } QCowAIOCB; |
| 388 | |
Jes Sorensen | 7c80ab3 | 2010-12-17 16:02:39 +0100 | [diff] [blame] | 389 | static void qcow2_aio_cancel(BlockDriverAIOCB *blockacb) |
Christoph Hellwig | c16b5a2 | 2009-05-25 12:37:32 +0200 | [diff] [blame] | 390 | { |
Kevin Wolf | b666d23 | 2010-05-05 11:44:39 +0200 | [diff] [blame] | 391 | QCowAIOCB *acb = container_of(blockacb, QCowAIOCB, common); |
Christoph Hellwig | c16b5a2 | 2009-05-25 12:37:32 +0200 | [diff] [blame] | 392 | if (acb->hd_aiocb) |
| 393 | bdrv_aio_cancel(acb->hd_aiocb); |
| 394 | qemu_aio_release(acb); |
| 395 | } |
| 396 | |
Jes Sorensen | 7c80ab3 | 2010-12-17 16:02:39 +0100 | [diff] [blame] | 397 | static AIOPool qcow2_aio_pool = { |
Christoph Hellwig | c16b5a2 | 2009-05-25 12:37:32 +0200 | [diff] [blame] | 398 | .aiocb_size = sizeof(QCowAIOCB), |
Jes Sorensen | 7c80ab3 | 2010-12-17 16:02:39 +0100 | [diff] [blame] | 399 | .cancel = qcow2_aio_cancel, |
Christoph Hellwig | c16b5a2 | 2009-05-25 12:37:32 +0200 | [diff] [blame] | 400 | }; |
| 401 | |
Jes Sorensen | 7c80ab3 | 2010-12-17 16:02:39 +0100 | [diff] [blame] | 402 | static void qcow2_aio_read_cb(void *opaque, int ret); |
Kevin Wolf | 42496d6 | 2011-06-07 15:04:32 +0200 | [diff] [blame] | 403 | static void qcow2_aio_write_cb(void *opaque, int ret); |
| 404 | |
| 405 | static void qcow2_aio_rw_bh(void *opaque) |
aliguori | 1490791 | 2008-10-31 17:28:00 +0000 | [diff] [blame] | 406 | { |
| 407 | QCowAIOCB *acb = opaque; |
| 408 | qemu_bh_delete(acb->bh); |
| 409 | acb->bh = NULL; |
Kevin Wolf | 42496d6 | 2011-06-07 15:04:32 +0200 | [diff] [blame] | 410 | |
| 411 | if (acb->is_write) { |
| 412 | qcow2_aio_write_cb(opaque, 0); |
| 413 | } else { |
| 414 | qcow2_aio_read_cb(opaque, 0); |
| 415 | } |
aliguori | 1490791 | 2008-10-31 17:28:00 +0000 | [diff] [blame] | 416 | } |
| 417 | |
Jes Sorensen | 7c80ab3 | 2010-12-17 16:02:39 +0100 | [diff] [blame] | 418 | static int qcow2_schedule_bh(QEMUBHFunc *cb, QCowAIOCB *acb) |
aliguori | a32ef78 | 2008-12-02 20:08:04 +0000 | [diff] [blame] | 419 | { |
| 420 | if (acb->bh) |
| 421 | return -EIO; |
| 422 | |
| 423 | acb->bh = qemu_bh_new(cb, acb); |
| 424 | if (!acb->bh) |
| 425 | return -EIO; |
| 426 | |
| 427 | qemu_bh_schedule(acb->bh); |
| 428 | |
| 429 | return 0; |
| 430 | } |
| 431 | |
Jes Sorensen | 7c80ab3 | 2010-12-17 16:02:39 +0100 | [diff] [blame] | 432 | static void qcow2_aio_read_cb(void *opaque, int ret) |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 433 | { |
pbrook | ce1a14d | 2006-08-07 02:38:06 +0000 | [diff] [blame] | 434 | QCowAIOCB *acb = opaque; |
| 435 | BlockDriverState *bs = acb->common.bs; |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 436 | BDRVQcowState *s = bs->opaque; |
bellard | a946592 | 2006-08-06 13:34:04 +0000 | [diff] [blame] | 437 | int index_in_cluster, n1; |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 438 | |
pbrook | ce1a14d | 2006-08-07 02:38:06 +0000 | [diff] [blame] | 439 | acb->hd_aiocb = NULL; |
aliguori | f141eaf | 2009-04-07 18:43:24 +0000 | [diff] [blame] | 440 | if (ret < 0) |
| 441 | goto done; |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 442 | |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 443 | /* post process the read buffer */ |
pbrook | ce1a14d | 2006-08-07 02:38:06 +0000 | [diff] [blame] | 444 | if (!acb->cluster_offset) { |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 445 | /* nothing to do */ |
pbrook | ce1a14d | 2006-08-07 02:38:06 +0000 | [diff] [blame] | 446 | } else if (acb->cluster_offset & QCOW_OFLAG_COMPRESSED) { |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 447 | /* nothing to do */ |
| 448 | } else { |
| 449 | if (s->crypt_method) { |
Kevin Wolf | bd28f83 | 2010-09-13 18:08:52 +0200 | [diff] [blame] | 450 | qcow2_encrypt_sectors(s, acb->sector_num, acb->cluster_data, |
| 451 | acb->cluster_data, acb->cur_nr_sectors, 0, &s->aes_decrypt_key); |
| 452 | qemu_iovec_reset(&acb->hd_qiov); |
| 453 | qemu_iovec_copy(&acb->hd_qiov, acb->qiov, acb->bytes_done, |
| 454 | acb->cur_nr_sectors * 512); |
| 455 | qemu_iovec_from_buffer(&acb->hd_qiov, acb->cluster_data, |
| 456 | 512 * acb->cur_nr_sectors); |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 457 | } |
| 458 | } |
| 459 | |
Christoph Hellwig | 7b88e48 | 2010-01-21 16:12:09 +0100 | [diff] [blame] | 460 | acb->remaining_sectors -= acb->cur_nr_sectors; |
| 461 | acb->sector_num += acb->cur_nr_sectors; |
Kevin Wolf | bd28f83 | 2010-09-13 18:08:52 +0200 | [diff] [blame] | 462 | acb->bytes_done += acb->cur_nr_sectors * 512; |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 463 | |
Christoph Hellwig | 7b88e48 | 2010-01-21 16:12:09 +0100 | [diff] [blame] | 464 | if (acb->remaining_sectors == 0) { |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 465 | /* request completed */ |
aliguori | f141eaf | 2009-04-07 18:43:24 +0000 | [diff] [blame] | 466 | ret = 0; |
| 467 | goto done; |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 468 | } |
ths | 3b46e62 | 2007-09-17 08:09:54 +0000 | [diff] [blame] | 469 | |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 470 | /* prepare next AIO request */ |
Christoph Hellwig | 7b88e48 | 2010-01-21 16:12:09 +0100 | [diff] [blame] | 471 | acb->cur_nr_sectors = acb->remaining_sectors; |
Kevin Wolf | bd28f83 | 2010-09-13 18:08:52 +0200 | [diff] [blame] | 472 | if (s->crypt_method) { |
| 473 | acb->cur_nr_sectors = MIN(acb->cur_nr_sectors, |
| 474 | QCOW_MAX_CRYPT_CLUSTERS * s->cluster_sectors); |
| 475 | } |
| 476 | |
Kevin Wolf | 1c46efa | 2010-05-21 17:59:36 +0200 | [diff] [blame] | 477 | ret = qcow2_get_cluster_offset(bs, acb->sector_num << 9, |
| 478 | &acb->cur_nr_sectors, &acb->cluster_offset); |
| 479 | if (ret < 0) { |
| 480 | goto done; |
| 481 | } |
| 482 | |
pbrook | ce1a14d | 2006-08-07 02:38:06 +0000 | [diff] [blame] | 483 | index_in_cluster = acb->sector_num & (s->cluster_sectors - 1); |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 484 | |
Kevin Wolf | bd28f83 | 2010-09-13 18:08:52 +0200 | [diff] [blame] | 485 | qemu_iovec_reset(&acb->hd_qiov); |
| 486 | qemu_iovec_copy(&acb->hd_qiov, acb->qiov, acb->bytes_done, |
| 487 | acb->cur_nr_sectors * 512); |
| 488 | |
pbrook | ce1a14d | 2006-08-07 02:38:06 +0000 | [diff] [blame] | 489 | if (!acb->cluster_offset) { |
Kevin Wolf | bd28f83 | 2010-09-13 18:08:52 +0200 | [diff] [blame] | 490 | |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 491 | if (bs->backing_hd) { |
| 492 | /* read from the base image */ |
Kevin Wolf | bd28f83 | 2010-09-13 18:08:52 +0200 | [diff] [blame] | 493 | n1 = qcow2_backing_read1(bs->backing_hd, &acb->hd_qiov, |
| 494 | acb->sector_num, acb->cur_nr_sectors); |
bellard | a946592 | 2006-08-06 13:34:04 +0000 | [diff] [blame] | 495 | if (n1 > 0) { |
Kevin Wolf | 66f82ce | 2010-04-14 14:17:38 +0200 | [diff] [blame] | 496 | BLKDBG_EVENT(bs->file, BLKDBG_READ_BACKING_AIO); |
aliguori | c87c067 | 2009-04-07 18:43:20 +0000 | [diff] [blame] | 497 | acb->hd_aiocb = bdrv_aio_readv(bs->backing_hd, acb->sector_num, |
Chunqiang Tang | e0d9c6f | 2011-02-03 10:12:49 -0500 | [diff] [blame] | 498 | &acb->hd_qiov, n1, qcow2_aio_read_cb, acb); |
Kevin Wolf | 3ab4c7e | 2011-02-08 18:12:35 +0100 | [diff] [blame] | 499 | if (acb->hd_aiocb == NULL) { |
| 500 | ret = -EIO; |
aliguori | f141eaf | 2009-04-07 18:43:24 +0000 | [diff] [blame] | 501 | goto done; |
Kevin Wolf | 3ab4c7e | 2011-02-08 18:12:35 +0100 | [diff] [blame] | 502 | } |
bellard | a946592 | 2006-08-06 13:34:04 +0000 | [diff] [blame] | 503 | } else { |
Kevin Wolf | 42496d6 | 2011-06-07 15:04:32 +0200 | [diff] [blame] | 504 | ret = qcow2_schedule_bh(qcow2_aio_rw_bh, acb); |
aliguori | a32ef78 | 2008-12-02 20:08:04 +0000 | [diff] [blame] | 505 | if (ret < 0) |
aliguori | f141eaf | 2009-04-07 18:43:24 +0000 | [diff] [blame] | 506 | goto done; |
bellard | a946592 | 2006-08-06 13:34:04 +0000 | [diff] [blame] | 507 | } |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 508 | } else { |
| 509 | /* Note: in this case, no need to wait */ |
Kevin Wolf | bd28f83 | 2010-09-13 18:08:52 +0200 | [diff] [blame] | 510 | qemu_iovec_memset(&acb->hd_qiov, 0, 512 * acb->cur_nr_sectors); |
Kevin Wolf | 42496d6 | 2011-06-07 15:04:32 +0200 | [diff] [blame] | 511 | ret = qcow2_schedule_bh(qcow2_aio_rw_bh, acb); |
aliguori | a32ef78 | 2008-12-02 20:08:04 +0000 | [diff] [blame] | 512 | if (ret < 0) |
aliguori | f141eaf | 2009-04-07 18:43:24 +0000 | [diff] [blame] | 513 | goto done; |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 514 | } |
pbrook | ce1a14d | 2006-08-07 02:38:06 +0000 | [diff] [blame] | 515 | } else if (acb->cluster_offset & QCOW_OFLAG_COMPRESSED) { |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 516 | /* add AIO support for compressed blocks ? */ |
Kevin Wolf | 8af3648 | 2011-02-09 10:26:06 +0100 | [diff] [blame] | 517 | ret = qcow2_decompress_cluster(bs, acb->cluster_offset); |
| 518 | if (ret < 0) { |
aliguori | f141eaf | 2009-04-07 18:43:24 +0000 | [diff] [blame] | 519 | goto done; |
Kevin Wolf | 8af3648 | 2011-02-09 10:26:06 +0100 | [diff] [blame] | 520 | } |
Kevin Wolf | bd28f83 | 2010-09-13 18:08:52 +0200 | [diff] [blame] | 521 | |
| 522 | qemu_iovec_from_buffer(&acb->hd_qiov, |
| 523 | s->cluster_cache + index_in_cluster * 512, |
| 524 | 512 * acb->cur_nr_sectors); |
| 525 | |
Kevin Wolf | 42496d6 | 2011-06-07 15:04:32 +0200 | [diff] [blame] | 526 | ret = qcow2_schedule_bh(qcow2_aio_rw_bh, acb); |
aliguori | a32ef78 | 2008-12-02 20:08:04 +0000 | [diff] [blame] | 527 | if (ret < 0) |
aliguori | f141eaf | 2009-04-07 18:43:24 +0000 | [diff] [blame] | 528 | goto done; |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 529 | } else { |
pbrook | ce1a14d | 2006-08-07 02:38:06 +0000 | [diff] [blame] | 530 | if ((acb->cluster_offset & 511) != 0) { |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 531 | ret = -EIO; |
aliguori | f141eaf | 2009-04-07 18:43:24 +0000 | [diff] [blame] | 532 | goto done; |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 533 | } |
aliguori | c87c067 | 2009-04-07 18:43:20 +0000 | [diff] [blame] | 534 | |
Kevin Wolf | bd28f83 | 2010-09-13 18:08:52 +0200 | [diff] [blame] | 535 | if (s->crypt_method) { |
| 536 | /* |
| 537 | * For encrypted images, read everything into a temporary |
| 538 | * contiguous buffer on which the AES functions can work. |
| 539 | */ |
| 540 | if (!acb->cluster_data) { |
| 541 | acb->cluster_data = |
| 542 | qemu_mallocz(QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size); |
| 543 | } |
| 544 | |
| 545 | assert(acb->cur_nr_sectors <= |
| 546 | QCOW_MAX_CRYPT_CLUSTERS * s->cluster_sectors); |
| 547 | qemu_iovec_reset(&acb->hd_qiov); |
| 548 | qemu_iovec_add(&acb->hd_qiov, acb->cluster_data, |
| 549 | 512 * acb->cur_nr_sectors); |
| 550 | } |
| 551 | |
Kevin Wolf | 66f82ce | 2010-04-14 14:17:38 +0200 | [diff] [blame] | 552 | BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO); |
| 553 | acb->hd_aiocb = bdrv_aio_readv(bs->file, |
ths | 5fafdf2 | 2007-09-16 21:08:06 +0000 | [diff] [blame] | 554 | (acb->cluster_offset >> 9) + index_in_cluster, |
Christoph Hellwig | 7b88e48 | 2010-01-21 16:12:09 +0100 | [diff] [blame] | 555 | &acb->hd_qiov, acb->cur_nr_sectors, |
Jes Sorensen | 7c80ab3 | 2010-12-17 16:02:39 +0100 | [diff] [blame] | 556 | qcow2_aio_read_cb, acb); |
Kevin Wolf | 171e3d6 | 2010-04-06 15:30:09 +0200 | [diff] [blame] | 557 | if (acb->hd_aiocb == NULL) { |
| 558 | ret = -EIO; |
aliguori | f141eaf | 2009-04-07 18:43:24 +0000 | [diff] [blame] | 559 | goto done; |
Kevin Wolf | 171e3d6 | 2010-04-06 15:30:09 +0200 | [diff] [blame] | 560 | } |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 561 | } |
aliguori | f141eaf | 2009-04-07 18:43:24 +0000 | [diff] [blame] | 562 | |
| 563 | return; |
| 564 | done: |
aliguori | f141eaf | 2009-04-07 18:43:24 +0000 | [diff] [blame] | 565 | acb->common.cb(acb->common.opaque, ret); |
Kevin Wolf | bd28f83 | 2010-09-13 18:08:52 +0200 | [diff] [blame] | 566 | qemu_iovec_destroy(&acb->hd_qiov); |
aliguori | f141eaf | 2009-04-07 18:43:24 +0000 | [diff] [blame] | 567 | qemu_aio_release(acb); |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 568 | } |
| 569 | |
Jes Sorensen | 7c80ab3 | 2010-12-17 16:02:39 +0100 | [diff] [blame] | 570 | static QCowAIOCB *qcow2_aio_setup(BlockDriverState *bs, int64_t sector_num, |
| 571 | QEMUIOVector *qiov, int nb_sectors, |
| 572 | BlockDriverCompletionFunc *cb, |
| 573 | void *opaque, int is_write) |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 574 | { |
pbrook | ce1a14d | 2006-08-07 02:38:06 +0000 | [diff] [blame] | 575 | QCowAIOCB *acb; |
| 576 | |
Jes Sorensen | 7c80ab3 | 2010-12-17 16:02:39 +0100 | [diff] [blame] | 577 | acb = qemu_aio_get(&qcow2_aio_pool, bs, cb, opaque); |
pbrook | ce1a14d | 2006-08-07 02:38:06 +0000 | [diff] [blame] | 578 | if (!acb) |
| 579 | return NULL; |
| 580 | acb->hd_aiocb = NULL; |
| 581 | acb->sector_num = sector_num; |
aliguori | f141eaf | 2009-04-07 18:43:24 +0000 | [diff] [blame] | 582 | acb->qiov = qiov; |
Kevin Wolf | 42496d6 | 2011-06-07 15:04:32 +0200 | [diff] [blame] | 583 | acb->is_write = is_write; |
Kevin Wolf | bd28f83 | 2010-09-13 18:08:52 +0200 | [diff] [blame] | 584 | |
Kevin Wolf | 6f5f060 | 2010-09-13 18:24:10 +0200 | [diff] [blame] | 585 | qemu_iovec_init(&acb->hd_qiov, qiov->niov); |
Kevin Wolf | bd28f83 | 2010-09-13 18:08:52 +0200 | [diff] [blame] | 586 | |
| 587 | acb->bytes_done = 0; |
Christoph Hellwig | 7b88e48 | 2010-01-21 16:12:09 +0100 | [diff] [blame] | 588 | acb->remaining_sectors = nb_sectors; |
| 589 | acb->cur_nr_sectors = 0; |
pbrook | ce1a14d | 2006-08-07 02:38:06 +0000 | [diff] [blame] | 590 | acb->cluster_offset = 0; |
aliguori | e976c6a | 2008-12-02 20:14:05 +0000 | [diff] [blame] | 591 | acb->l2meta.nb_clusters = 0; |
Blue Swirl | 72cf2d4 | 2009-09-12 07:36:22 +0000 | [diff] [blame] | 592 | QLIST_INIT(&acb->l2meta.dependent_requests); |
pbrook | ce1a14d | 2006-08-07 02:38:06 +0000 | [diff] [blame] | 593 | return acb; |
| 594 | } |
| 595 | |
Jes Sorensen | 7c80ab3 | 2010-12-17 16:02:39 +0100 | [diff] [blame] | 596 | static BlockDriverAIOCB *qcow2_aio_readv(BlockDriverState *bs, |
| 597 | int64_t sector_num, |
| 598 | QEMUIOVector *qiov, int nb_sectors, |
| 599 | BlockDriverCompletionFunc *cb, |
| 600 | void *opaque) |
pbrook | ce1a14d | 2006-08-07 02:38:06 +0000 | [diff] [blame] | 601 | { |
| 602 | QCowAIOCB *acb; |
Kevin Wolf | 42496d6 | 2011-06-07 15:04:32 +0200 | [diff] [blame] | 603 | int ret; |
pbrook | ce1a14d | 2006-08-07 02:38:06 +0000 | [diff] [blame] | 604 | |
Jes Sorensen | 7c80ab3 | 2010-12-17 16:02:39 +0100 | [diff] [blame] | 605 | acb = qcow2_aio_setup(bs, sector_num, qiov, nb_sectors, cb, opaque, 0); |
pbrook | ce1a14d | 2006-08-07 02:38:06 +0000 | [diff] [blame] | 606 | if (!acb) |
| 607 | return NULL; |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 608 | |
Kevin Wolf | 42496d6 | 2011-06-07 15:04:32 +0200 | [diff] [blame] | 609 | ret = qcow2_schedule_bh(qcow2_aio_rw_bh, acb); |
| 610 | if (ret < 0) { |
| 611 | qemu_iovec_destroy(&acb->hd_qiov); |
| 612 | qemu_aio_release(acb); |
| 613 | return NULL; |
| 614 | } |
| 615 | |
pbrook | ce1a14d | 2006-08-07 02:38:06 +0000 | [diff] [blame] | 616 | return &acb->common; |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 617 | } |
| 618 | |
Kevin Wolf | f214978 | 2009-08-31 16:48:49 +0200 | [diff] [blame] | 619 | static void run_dependent_requests(QCowL2Meta *m) |
| 620 | { |
| 621 | QCowAIOCB *req; |
| 622 | QCowAIOCB *next; |
| 623 | |
| 624 | /* Take the request off the list of running requests */ |
| 625 | if (m->nb_clusters != 0) { |
Blue Swirl | 72cf2d4 | 2009-09-12 07:36:22 +0000 | [diff] [blame] | 626 | QLIST_REMOVE(m, next_in_flight); |
Kevin Wolf | f214978 | 2009-08-31 16:48:49 +0200 | [diff] [blame] | 627 | } |
| 628 | |
Stefan Hajnoczi | d4c146f | 2010-04-15 14:11:35 +0100 | [diff] [blame] | 629 | /* Restart all dependent requests */ |
| 630 | QLIST_FOREACH_SAFE(req, &m->dependent_requests, next_depend, next) { |
Jes Sorensen | 7c80ab3 | 2010-12-17 16:02:39 +0100 | [diff] [blame] | 631 | qcow2_aio_write_cb(req, 0); |
Kevin Wolf | f214978 | 2009-08-31 16:48:49 +0200 | [diff] [blame] | 632 | } |
| 633 | |
| 634 | /* Empty the list for the next part of the request */ |
Blue Swirl | 72cf2d4 | 2009-09-12 07:36:22 +0000 | [diff] [blame] | 635 | QLIST_INIT(&m->dependent_requests); |
Kevin Wolf | f214978 | 2009-08-31 16:48:49 +0200 | [diff] [blame] | 636 | } |
| 637 | |
Jes Sorensen | 7c80ab3 | 2010-12-17 16:02:39 +0100 | [diff] [blame] | 638 | static void qcow2_aio_write_cb(void *opaque, int ret) |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 639 | { |
pbrook | ce1a14d | 2006-08-07 02:38:06 +0000 | [diff] [blame] | 640 | QCowAIOCB *acb = opaque; |
| 641 | BlockDriverState *bs = acb->common.bs; |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 642 | BDRVQcowState *s = bs->opaque; |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 643 | int index_in_cluster; |
aliguori | 095a9c5 | 2008-08-14 18:10:28 +0000 | [diff] [blame] | 644 | int n_end; |
pbrook | ce1a14d | 2006-08-07 02:38:06 +0000 | [diff] [blame] | 645 | |
| 646 | acb->hd_aiocb = NULL; |
| 647 | |
Kevin Wolf | f214978 | 2009-08-31 16:48:49 +0200 | [diff] [blame] | 648 | if (ret >= 0) { |
Kevin Wolf | 148da7e | 2010-01-20 15:03:01 +0100 | [diff] [blame] | 649 | ret = qcow2_alloc_cluster_link_l2(bs, &acb->l2meta); |
Kevin Wolf | f214978 | 2009-08-31 16:48:49 +0200 | [diff] [blame] | 650 | } |
| 651 | |
| 652 | run_dependent_requests(&acb->l2meta); |
| 653 | |
aliguori | f141eaf | 2009-04-07 18:43:24 +0000 | [diff] [blame] | 654 | if (ret < 0) |
| 655 | goto done; |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 656 | |
Christoph Hellwig | 7b88e48 | 2010-01-21 16:12:09 +0100 | [diff] [blame] | 657 | acb->remaining_sectors -= acb->cur_nr_sectors; |
| 658 | acb->sector_num += acb->cur_nr_sectors; |
Kevin Wolf | 6f5f060 | 2010-09-13 18:24:10 +0200 | [diff] [blame] | 659 | acb->bytes_done += acb->cur_nr_sectors * 512; |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 660 | |
Christoph Hellwig | 7b88e48 | 2010-01-21 16:12:09 +0100 | [diff] [blame] | 661 | if (acb->remaining_sectors == 0) { |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 662 | /* request completed */ |
aliguori | f141eaf | 2009-04-07 18:43:24 +0000 | [diff] [blame] | 663 | ret = 0; |
| 664 | goto done; |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 665 | } |
ths | 3b46e62 | 2007-09-17 08:09:54 +0000 | [diff] [blame] | 666 | |
pbrook | ce1a14d | 2006-08-07 02:38:06 +0000 | [diff] [blame] | 667 | index_in_cluster = acb->sector_num & (s->cluster_sectors - 1); |
Christoph Hellwig | 7b88e48 | 2010-01-21 16:12:09 +0100 | [diff] [blame] | 668 | n_end = index_in_cluster + acb->remaining_sectors; |
aliguori | 095a9c5 | 2008-08-14 18:10:28 +0000 | [diff] [blame] | 669 | if (s->crypt_method && |
| 670 | n_end > QCOW_MAX_CRYPT_CLUSTERS * s->cluster_sectors) |
| 671 | n_end = QCOW_MAX_CRYPT_CLUSTERS * s->cluster_sectors; |
| 672 | |
Kevin Wolf | 148da7e | 2010-01-20 15:03:01 +0100 | [diff] [blame] | 673 | ret = qcow2_alloc_cluster_offset(bs, acb->sector_num << 9, |
Christoph Hellwig | 7b88e48 | 2010-01-21 16:12:09 +0100 | [diff] [blame] | 674 | index_in_cluster, n_end, &acb->cur_nr_sectors, &acb->l2meta); |
Kevin Wolf | 148da7e | 2010-01-20 15:03:01 +0100 | [diff] [blame] | 675 | if (ret < 0) { |
| 676 | goto done; |
| 677 | } |
| 678 | |
| 679 | acb->cluster_offset = acb->l2meta.cluster_offset; |
Kevin Wolf | f214978 | 2009-08-31 16:48:49 +0200 | [diff] [blame] | 680 | |
| 681 | /* Need to wait for another request? If so, we are done for now. */ |
Kevin Wolf | 148da7e | 2010-01-20 15:03:01 +0100 | [diff] [blame] | 682 | if (acb->l2meta.nb_clusters == 0 && acb->l2meta.depends_on != NULL) { |
Blue Swirl | 72cf2d4 | 2009-09-12 07:36:22 +0000 | [diff] [blame] | 683 | QLIST_INSERT_HEAD(&acb->l2meta.depends_on->dependent_requests, |
Kevin Wolf | f214978 | 2009-08-31 16:48:49 +0200 | [diff] [blame] | 684 | acb, next_depend); |
| 685 | return; |
| 686 | } |
| 687 | |
Kevin Wolf | 148da7e | 2010-01-20 15:03:01 +0100 | [diff] [blame] | 688 | assert((acb->cluster_offset & 511) == 0); |
| 689 | |
Kevin Wolf | 6f5f060 | 2010-09-13 18:24:10 +0200 | [diff] [blame] | 690 | qemu_iovec_reset(&acb->hd_qiov); |
| 691 | qemu_iovec_copy(&acb->hd_qiov, acb->qiov, acb->bytes_done, |
| 692 | acb->cur_nr_sectors * 512); |
| 693 | |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 694 | if (s->crypt_method) { |
pbrook | ce1a14d | 2006-08-07 02:38:06 +0000 | [diff] [blame] | 695 | if (!acb->cluster_data) { |
aliguori | 095a9c5 | 2008-08-14 18:10:28 +0000 | [diff] [blame] | 696 | acb->cluster_data = qemu_mallocz(QCOW_MAX_CRYPT_CLUSTERS * |
| 697 | s->cluster_size); |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 698 | } |
Kevin Wolf | 6f5f060 | 2010-09-13 18:24:10 +0200 | [diff] [blame] | 699 | |
| 700 | assert(acb->hd_qiov.size <= QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size); |
| 701 | qemu_iovec_to_buffer(&acb->hd_qiov, acb->cluster_data); |
| 702 | |
| 703 | qcow2_encrypt_sectors(s, acb->sector_num, acb->cluster_data, |
| 704 | acb->cluster_data, acb->cur_nr_sectors, 1, &s->aes_encrypt_key); |
| 705 | |
| 706 | qemu_iovec_reset(&acb->hd_qiov); |
| 707 | qemu_iovec_add(&acb->hd_qiov, acb->cluster_data, |
| 708 | acb->cur_nr_sectors * 512); |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 709 | } |
Kevin Wolf | 6f5f060 | 2010-09-13 18:24:10 +0200 | [diff] [blame] | 710 | |
Kevin Wolf | 66f82ce | 2010-04-14 14:17:38 +0200 | [diff] [blame] | 711 | BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO); |
| 712 | acb->hd_aiocb = bdrv_aio_writev(bs->file, |
aliguori | c87c067 | 2009-04-07 18:43:20 +0000 | [diff] [blame] | 713 | (acb->cluster_offset >> 9) + index_in_cluster, |
Christoph Hellwig | 7b88e48 | 2010-01-21 16:12:09 +0100 | [diff] [blame] | 714 | &acb->hd_qiov, acb->cur_nr_sectors, |
Jes Sorensen | 7c80ab3 | 2010-12-17 16:02:39 +0100 | [diff] [blame] | 715 | qcow2_aio_write_cb, acb); |
Kevin Wolf | 171e3d6 | 2010-04-06 15:30:09 +0200 | [diff] [blame] | 716 | if (acb->hd_aiocb == NULL) { |
| 717 | ret = -EIO; |
Kevin Wolf | c644db3 | 2010-04-06 15:30:14 +0200 | [diff] [blame] | 718 | goto fail; |
Kevin Wolf | 171e3d6 | 2010-04-06 15:30:09 +0200 | [diff] [blame] | 719 | } |
aliguori | f141eaf | 2009-04-07 18:43:24 +0000 | [diff] [blame] | 720 | |
| 721 | return; |
| 722 | |
Kevin Wolf | c644db3 | 2010-04-06 15:30:14 +0200 | [diff] [blame] | 723 | fail: |
| 724 | if (acb->l2meta.nb_clusters != 0) { |
| 725 | QLIST_REMOVE(&acb->l2meta, next_in_flight); |
| 726 | } |
aliguori | f141eaf | 2009-04-07 18:43:24 +0000 | [diff] [blame] | 727 | done: |
aliguori | f141eaf | 2009-04-07 18:43:24 +0000 | [diff] [blame] | 728 | acb->common.cb(acb->common.opaque, ret); |
Kevin Wolf | 6f5f060 | 2010-09-13 18:24:10 +0200 | [diff] [blame] | 729 | qemu_iovec_destroy(&acb->hd_qiov); |
aliguori | f141eaf | 2009-04-07 18:43:24 +0000 | [diff] [blame] | 730 | qemu_aio_release(acb); |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 731 | } |
| 732 | |
Jes Sorensen | 7c80ab3 | 2010-12-17 16:02:39 +0100 | [diff] [blame] | 733 | static BlockDriverAIOCB *qcow2_aio_writev(BlockDriverState *bs, |
| 734 | int64_t sector_num, |
| 735 | QEMUIOVector *qiov, int nb_sectors, |
| 736 | BlockDriverCompletionFunc *cb, |
| 737 | void *opaque) |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 738 | { |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 739 | BDRVQcowState *s = bs->opaque; |
pbrook | ce1a14d | 2006-08-07 02:38:06 +0000 | [diff] [blame] | 740 | QCowAIOCB *acb; |
Kevin Wolf | 42496d6 | 2011-06-07 15:04:32 +0200 | [diff] [blame] | 741 | int ret; |
ths | 3b46e62 | 2007-09-17 08:09:54 +0000 | [diff] [blame] | 742 | |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 743 | s->cluster_cache_offset = -1; /* disable compressed cache */ |
| 744 | |
Jes Sorensen | 7c80ab3 | 2010-12-17 16:02:39 +0100 | [diff] [blame] | 745 | acb = qcow2_aio_setup(bs, sector_num, qiov, nb_sectors, cb, opaque, 1); |
pbrook | ce1a14d | 2006-08-07 02:38:06 +0000 | [diff] [blame] | 746 | if (!acb) |
| 747 | return NULL; |
ths | 3b46e62 | 2007-09-17 08:09:54 +0000 | [diff] [blame] | 748 | |
Kevin Wolf | 42496d6 | 2011-06-07 15:04:32 +0200 | [diff] [blame] | 749 | ret = qcow2_schedule_bh(qcow2_aio_rw_bh, acb); |
| 750 | if (ret < 0) { |
| 751 | qemu_iovec_destroy(&acb->hd_qiov); |
| 752 | qemu_aio_release(acb); |
| 753 | return NULL; |
| 754 | } |
| 755 | |
pbrook | ce1a14d | 2006-08-07 02:38:06 +0000 | [diff] [blame] | 756 | return &acb->common; |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 757 | } |
| 758 | |
Jes Sorensen | 7c80ab3 | 2010-12-17 16:02:39 +0100 | [diff] [blame] | 759 | static void qcow2_close(BlockDriverState *bs) |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 760 | { |
| 761 | BDRVQcowState *s = bs->opaque; |
| 762 | qemu_free(s->l1_table); |
Kevin Wolf | 29c1a73 | 2011-01-10 17:17:28 +0100 | [diff] [blame] | 763 | |
| 764 | qcow2_cache_flush(bs, s->l2_table_cache); |
| 765 | qcow2_cache_flush(bs, s->refcount_block_cache); |
| 766 | |
| 767 | qcow2_cache_destroy(bs, s->l2_table_cache); |
| 768 | qcow2_cache_destroy(bs, s->refcount_block_cache); |
| 769 | |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 770 | qemu_free(s->cluster_cache); |
| 771 | qemu_free(s->cluster_data); |
Kevin Wolf | ed6ccf0 | 2009-05-28 16:07:07 +0200 | [diff] [blame] | 772 | qcow2_refcount_close(bs); |
bellard | 585f858 | 2006-08-05 21:14:20 +0000 | [diff] [blame] | 773 | } |
| 774 | |
Kevin Wolf | 756e673 | 2010-01-12 12:55:17 +0100 | [diff] [blame] | 775 | /* |
| 776 | * Updates the variable length parts of the qcow2 header, i.e. the backing file |
| 777 | * name and all extensions. qcow2 was not designed to allow such changes, so if |
| 778 | * we run out of space (we can only use the first cluster) this function may |
| 779 | * fail. |
| 780 | * |
| 781 | * Returns 0 on success, -errno in error cases. |
| 782 | */ |
| 783 | static int qcow2_update_ext_header(BlockDriverState *bs, |
| 784 | const char *backing_file, const char *backing_fmt) |
| 785 | { |
| 786 | size_t backing_file_len = 0; |
| 787 | size_t backing_fmt_len = 0; |
| 788 | BDRVQcowState *s = bs->opaque; |
| 789 | QCowExtension ext_backing_fmt = {0, 0}; |
| 790 | int ret; |
| 791 | |
| 792 | /* Backing file format doesn't make sense without a backing file */ |
| 793 | if (backing_fmt && !backing_file) { |
| 794 | return -EINVAL; |
| 795 | } |
| 796 | |
| 797 | /* Prepare the backing file format extension if needed */ |
| 798 | if (backing_fmt) { |
| 799 | ext_backing_fmt.len = cpu_to_be32(strlen(backing_fmt)); |
Jes Sorensen | 7c80ab3 | 2010-12-17 16:02:39 +0100 | [diff] [blame] | 800 | ext_backing_fmt.magic = cpu_to_be32(QCOW2_EXT_MAGIC_BACKING_FORMAT); |
Kevin Wolf | 756e673 | 2010-01-12 12:55:17 +0100 | [diff] [blame] | 801 | backing_fmt_len = ((sizeof(ext_backing_fmt) |
| 802 | + strlen(backing_fmt) + 7) & ~7); |
| 803 | } |
| 804 | |
| 805 | /* Check if we can fit the new header into the first cluster */ |
| 806 | if (backing_file) { |
| 807 | backing_file_len = strlen(backing_file); |
| 808 | } |
| 809 | |
| 810 | size_t header_size = sizeof(QCowHeader) + backing_file_len |
| 811 | + backing_fmt_len; |
| 812 | |
| 813 | if (header_size > s->cluster_size) { |
| 814 | return -ENOSPC; |
| 815 | } |
| 816 | |
| 817 | /* Rewrite backing file name and qcow2 extensions */ |
| 818 | size_t ext_size = header_size - sizeof(QCowHeader); |
| 819 | uint8_t buf[ext_size]; |
| 820 | size_t offset = 0; |
| 821 | size_t backing_file_offset = 0; |
| 822 | |
| 823 | if (backing_file) { |
| 824 | if (backing_fmt) { |
| 825 | int padding = backing_fmt_len - |
| 826 | (sizeof(ext_backing_fmt) + strlen(backing_fmt)); |
| 827 | |
| 828 | memcpy(buf + offset, &ext_backing_fmt, sizeof(ext_backing_fmt)); |
| 829 | offset += sizeof(ext_backing_fmt); |
| 830 | |
| 831 | memcpy(buf + offset, backing_fmt, strlen(backing_fmt)); |
| 832 | offset += strlen(backing_fmt); |
| 833 | |
| 834 | memset(buf + offset, 0, padding); |
| 835 | offset += padding; |
| 836 | } |
| 837 | |
| 838 | memcpy(buf + offset, backing_file, backing_file_len); |
| 839 | backing_file_offset = sizeof(QCowHeader) + offset; |
| 840 | } |
| 841 | |
Kevin Wolf | 8b3b720 | 2010-06-16 17:44:35 +0200 | [diff] [blame] | 842 | ret = bdrv_pwrite_sync(bs->file, sizeof(QCowHeader), buf, ext_size); |
Kevin Wolf | 756e673 | 2010-01-12 12:55:17 +0100 | [diff] [blame] | 843 | if (ret < 0) { |
| 844 | goto fail; |
| 845 | } |
| 846 | |
| 847 | /* Update header fields */ |
| 848 | uint64_t be_backing_file_offset = cpu_to_be64(backing_file_offset); |
| 849 | uint32_t be_backing_file_size = cpu_to_be32(backing_file_len); |
| 850 | |
Kevin Wolf | 8b3b720 | 2010-06-16 17:44:35 +0200 | [diff] [blame] | 851 | ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, backing_file_offset), |
Kevin Wolf | 756e673 | 2010-01-12 12:55:17 +0100 | [diff] [blame] | 852 | &be_backing_file_offset, sizeof(uint64_t)); |
| 853 | if (ret < 0) { |
| 854 | goto fail; |
| 855 | } |
| 856 | |
Kevin Wolf | 8b3b720 | 2010-06-16 17:44:35 +0200 | [diff] [blame] | 857 | ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, backing_file_size), |
Kevin Wolf | 756e673 | 2010-01-12 12:55:17 +0100 | [diff] [blame] | 858 | &be_backing_file_size, sizeof(uint32_t)); |
| 859 | if (ret < 0) { |
| 860 | goto fail; |
| 861 | } |
| 862 | |
| 863 | ret = 0; |
| 864 | fail: |
| 865 | return ret; |
| 866 | } |
| 867 | |
| 868 | static int qcow2_change_backing_file(BlockDriverState *bs, |
| 869 | const char *backing_file, const char *backing_fmt) |
| 870 | { |
| 871 | return qcow2_update_ext_header(bs, backing_file, backing_fmt); |
| 872 | } |
| 873 | |
Kevin Wolf | a35e1c1 | 2009-08-17 15:50:10 +0200 | [diff] [blame] | 874 | static int preallocate(BlockDriverState *bs) |
| 875 | { |
Kevin Wolf | a35e1c1 | 2009-08-17 15:50:10 +0200 | [diff] [blame] | 876 | uint64_t nb_sectors; |
| 877 | uint64_t offset; |
| 878 | int num; |
Kevin Wolf | 148da7e | 2010-01-20 15:03:01 +0100 | [diff] [blame] | 879 | int ret; |
Kevin Wolf | a35e1c1 | 2009-08-17 15:50:10 +0200 | [diff] [blame] | 880 | QCowL2Meta meta; |
| 881 | |
| 882 | nb_sectors = bdrv_getlength(bs) >> 9; |
| 883 | offset = 0; |
Blue Swirl | 72cf2d4 | 2009-09-12 07:36:22 +0000 | [diff] [blame] | 884 | QLIST_INIT(&meta.dependent_requests); |
Kevin Wolf | 148da7e | 2010-01-20 15:03:01 +0100 | [diff] [blame] | 885 | meta.cluster_offset = 0; |
Kevin Wolf | a35e1c1 | 2009-08-17 15:50:10 +0200 | [diff] [blame] | 886 | |
| 887 | while (nb_sectors) { |
| 888 | num = MIN(nb_sectors, INT_MAX >> 9); |
Kevin Wolf | 148da7e | 2010-01-20 15:03:01 +0100 | [diff] [blame] | 889 | ret = qcow2_alloc_cluster_offset(bs, offset, 0, num, &num, &meta); |
Kevin Wolf | 148da7e | 2010-01-20 15:03:01 +0100 | [diff] [blame] | 890 | if (ret < 0) { |
Kevin Wolf | 19dbcbf | 2010-06-22 16:59:46 +0200 | [diff] [blame] | 891 | return ret; |
Kevin Wolf | a35e1c1 | 2009-08-17 15:50:10 +0200 | [diff] [blame] | 892 | } |
| 893 | |
Kevin Wolf | 19dbcbf | 2010-06-22 16:59:46 +0200 | [diff] [blame] | 894 | ret = qcow2_alloc_cluster_link_l2(bs, &meta); |
| 895 | if (ret < 0) { |
Kevin Wolf | 148da7e | 2010-01-20 15:03:01 +0100 | [diff] [blame] | 896 | qcow2_free_any_clusters(bs, meta.cluster_offset, meta.nb_clusters); |
Kevin Wolf | 19dbcbf | 2010-06-22 16:59:46 +0200 | [diff] [blame] | 897 | return ret; |
Kevin Wolf | a35e1c1 | 2009-08-17 15:50:10 +0200 | [diff] [blame] | 898 | } |
| 899 | |
Kevin Wolf | f214978 | 2009-08-31 16:48:49 +0200 | [diff] [blame] | 900 | /* There are no dependent requests, but we need to remove our request |
| 901 | * from the list of in-flight requests */ |
| 902 | run_dependent_requests(&meta); |
| 903 | |
Kevin Wolf | a35e1c1 | 2009-08-17 15:50:10 +0200 | [diff] [blame] | 904 | /* TODO Preallocate data if requested */ |
| 905 | |
| 906 | nb_sectors -= num; |
| 907 | offset += num << 9; |
| 908 | } |
| 909 | |
| 910 | /* |
| 911 | * It is expected that the image file is large enough to actually contain |
| 912 | * all of the allocated clusters (otherwise we get failing reads after |
| 913 | * EOF). Extend the image to the last allocated sector. |
| 914 | */ |
Kevin Wolf | 148da7e | 2010-01-20 15:03:01 +0100 | [diff] [blame] | 915 | if (meta.cluster_offset != 0) { |
Kevin Wolf | ea80b90 | 2009-08-31 12:26:57 +0200 | [diff] [blame] | 916 | uint8_t buf[512]; |
| 917 | memset(buf, 0, 512); |
Kevin Wolf | 19dbcbf | 2010-06-22 16:59:46 +0200 | [diff] [blame] | 918 | ret = bdrv_write(bs->file, (meta.cluster_offset >> 9) + num - 1, buf, 1); |
| 919 | if (ret < 0) { |
| 920 | return ret; |
| 921 | } |
Kevin Wolf | a35e1c1 | 2009-08-17 15:50:10 +0200 | [diff] [blame] | 922 | } |
| 923 | |
| 924 | return 0; |
| 925 | } |
| 926 | |
Jes Sorensen | 7c80ab3 | 2010-12-17 16:02:39 +0100 | [diff] [blame] | 927 | static int qcow2_create2(const char *filename, int64_t total_size, |
| 928 | const char *backing_file, const char *backing_format, |
| 929 | int flags, size_t cluster_size, int prealloc, |
| 930 | QEMUOptionParameter *options) |
Kevin Wolf | a942073 | 2010-06-11 21:37:37 +0200 | [diff] [blame] | 931 | { |
| 932 | /* Calulate cluster_bits */ |
| 933 | int cluster_bits; |
| 934 | cluster_bits = ffs(cluster_size) - 1; |
| 935 | if (cluster_bits < MIN_CLUSTER_BITS || cluster_bits > MAX_CLUSTER_BITS || |
| 936 | (1 << cluster_bits) != cluster_size) |
| 937 | { |
| 938 | error_report( |
Markus Armbruster | 6daf194 | 2011-06-22 14:03:54 +0200 | [diff] [blame] | 939 | "Cluster size must be a power of two between %d and %dk", |
Kevin Wolf | a942073 | 2010-06-11 21:37:37 +0200 | [diff] [blame] | 940 | 1 << MIN_CLUSTER_BITS, 1 << (MAX_CLUSTER_BITS - 10)); |
| 941 | return -EINVAL; |
| 942 | } |
| 943 | |
| 944 | /* |
| 945 | * Open the image file and write a minimal qcow2 header. |
| 946 | * |
| 947 | * We keep things simple and start with a zero-sized image. We also |
| 948 | * do without refcount blocks or a L1 table for now. We'll fix the |
| 949 | * inconsistency later. |
| 950 | * |
| 951 | * We do need a refcount table because growing the refcount table means |
| 952 | * allocating two new refcount blocks - the seconds of which would be at |
| 953 | * 2 GB for 64k clusters, and we don't want to have a 2 GB initial file |
| 954 | * size for any qcow2 image. |
| 955 | */ |
| 956 | BlockDriverState* bs; |
| 957 | QCowHeader header; |
| 958 | uint8_t* refcount_table; |
| 959 | int ret; |
| 960 | |
| 961 | ret = bdrv_create_file(filename, options); |
| 962 | if (ret < 0) { |
| 963 | return ret; |
| 964 | } |
| 965 | |
| 966 | ret = bdrv_file_open(&bs, filename, BDRV_O_RDWR); |
| 967 | if (ret < 0) { |
| 968 | return ret; |
| 969 | } |
| 970 | |
| 971 | /* Write the header */ |
| 972 | memset(&header, 0, sizeof(header)); |
| 973 | header.magic = cpu_to_be32(QCOW_MAGIC); |
| 974 | header.version = cpu_to_be32(QCOW_VERSION); |
| 975 | header.cluster_bits = cpu_to_be32(cluster_bits); |
| 976 | header.size = cpu_to_be64(0); |
| 977 | header.l1_table_offset = cpu_to_be64(0); |
| 978 | header.l1_size = cpu_to_be32(0); |
| 979 | header.refcount_table_offset = cpu_to_be64(cluster_size); |
| 980 | header.refcount_table_clusters = cpu_to_be32(1); |
| 981 | |
| 982 | if (flags & BLOCK_FLAG_ENCRYPT) { |
| 983 | header.crypt_method = cpu_to_be32(QCOW_CRYPT_AES); |
| 984 | } else { |
| 985 | header.crypt_method = cpu_to_be32(QCOW_CRYPT_NONE); |
| 986 | } |
| 987 | |
| 988 | ret = bdrv_pwrite(bs, 0, &header, sizeof(header)); |
| 989 | if (ret < 0) { |
| 990 | goto out; |
| 991 | } |
| 992 | |
| 993 | /* Write an empty refcount table */ |
| 994 | refcount_table = qemu_mallocz(cluster_size); |
| 995 | ret = bdrv_pwrite(bs, cluster_size, refcount_table, cluster_size); |
| 996 | qemu_free(refcount_table); |
| 997 | |
| 998 | if (ret < 0) { |
| 999 | goto out; |
| 1000 | } |
| 1001 | |
| 1002 | bdrv_close(bs); |
| 1003 | |
| 1004 | /* |
| 1005 | * And now open the image and make it consistent first (i.e. increase the |
| 1006 | * refcount of the cluster that is occupied by the header and the refcount |
| 1007 | * table) |
| 1008 | */ |
| 1009 | BlockDriver* drv = bdrv_find_format("qcow2"); |
| 1010 | assert(drv != NULL); |
Kevin Wolf | e1a7107 | 2011-01-27 16:46:01 +0100 | [diff] [blame] | 1011 | ret = bdrv_open(bs, filename, |
| 1012 | BDRV_O_RDWR | BDRV_O_CACHE_WB | BDRV_O_NO_FLUSH, drv); |
Kevin Wolf | a942073 | 2010-06-11 21:37:37 +0200 | [diff] [blame] | 1013 | if (ret < 0) { |
| 1014 | goto out; |
| 1015 | } |
| 1016 | |
| 1017 | ret = qcow2_alloc_clusters(bs, 2 * cluster_size); |
| 1018 | if (ret < 0) { |
| 1019 | goto out; |
| 1020 | |
| 1021 | } else if (ret != 0) { |
| 1022 | error_report("Huh, first cluster in empty image is already in use?"); |
| 1023 | abort(); |
| 1024 | } |
| 1025 | |
| 1026 | /* Okay, now that we have a valid image, let's give it the right size */ |
| 1027 | ret = bdrv_truncate(bs, total_size * BDRV_SECTOR_SIZE); |
| 1028 | if (ret < 0) { |
| 1029 | goto out; |
| 1030 | } |
| 1031 | |
| 1032 | /* Want a backing file? There you go.*/ |
| 1033 | if (backing_file) { |
| 1034 | ret = bdrv_change_backing_file(bs, backing_file, backing_format); |
| 1035 | if (ret < 0) { |
| 1036 | goto out; |
| 1037 | } |
| 1038 | } |
| 1039 | |
| 1040 | /* And if we're supposed to preallocate metadata, do that now */ |
| 1041 | if (prealloc) { |
| 1042 | ret = preallocate(bs); |
| 1043 | if (ret < 0) { |
| 1044 | goto out; |
| 1045 | } |
| 1046 | } |
| 1047 | |
| 1048 | ret = 0; |
| 1049 | out: |
| 1050 | bdrv_delete(bs); |
| 1051 | return ret; |
| 1052 | } |
Kevin Wolf | de5f3f4 | 2010-05-07 12:43:45 +0200 | [diff] [blame] | 1053 | |
Jes Sorensen | 7c80ab3 | 2010-12-17 16:02:39 +0100 | [diff] [blame] | 1054 | static int qcow2_create(const char *filename, QEMUOptionParameter *options) |
Kevin Wolf | de5f3f4 | 2010-05-07 12:43:45 +0200 | [diff] [blame] | 1055 | { |
| 1056 | const char *backing_file = NULL; |
| 1057 | const char *backing_fmt = NULL; |
| 1058 | uint64_t sectors = 0; |
| 1059 | int flags = 0; |
Kevin Wolf | 99cce9f | 2011-05-31 15:01:46 +0200 | [diff] [blame] | 1060 | size_t cluster_size = DEFAULT_CLUSTER_SIZE; |
Kevin Wolf | de5f3f4 | 2010-05-07 12:43:45 +0200 | [diff] [blame] | 1061 | int prealloc = 0; |
| 1062 | |
| 1063 | /* Read out options */ |
| 1064 | while (options && options->name) { |
| 1065 | if (!strcmp(options->name, BLOCK_OPT_SIZE)) { |
| 1066 | sectors = options->value.n / 512; |
| 1067 | } else if (!strcmp(options->name, BLOCK_OPT_BACKING_FILE)) { |
| 1068 | backing_file = options->value.s; |
| 1069 | } else if (!strcmp(options->name, BLOCK_OPT_BACKING_FMT)) { |
| 1070 | backing_fmt = options->value.s; |
| 1071 | } else if (!strcmp(options->name, BLOCK_OPT_ENCRYPT)) { |
| 1072 | flags |= options->value.n ? BLOCK_FLAG_ENCRYPT : 0; |
| 1073 | } else if (!strcmp(options->name, BLOCK_OPT_CLUSTER_SIZE)) { |
| 1074 | if (options->value.n) { |
| 1075 | cluster_size = options->value.n; |
| 1076 | } |
| 1077 | } else if (!strcmp(options->name, BLOCK_OPT_PREALLOC)) { |
| 1078 | if (!options->value.s || !strcmp(options->value.s, "off")) { |
| 1079 | prealloc = 0; |
| 1080 | } else if (!strcmp(options->value.s, "metadata")) { |
| 1081 | prealloc = 1; |
| 1082 | } else { |
| 1083 | fprintf(stderr, "Invalid preallocation mode: '%s'\n", |
| 1084 | options->value.s); |
| 1085 | return -EINVAL; |
| 1086 | } |
| 1087 | } |
| 1088 | options++; |
| 1089 | } |
| 1090 | |
| 1091 | if (backing_file && prealloc) { |
| 1092 | fprintf(stderr, "Backing file and preallocation cannot be used at " |
| 1093 | "the same time\n"); |
| 1094 | return -EINVAL; |
| 1095 | } |
| 1096 | |
Jes Sorensen | 7c80ab3 | 2010-12-17 16:02:39 +0100 | [diff] [blame] | 1097 | return qcow2_create2(filename, sectors, backing_file, backing_fmt, flags, |
| 1098 | cluster_size, prealloc, options); |
Kevin Wolf | de5f3f4 | 2010-05-07 12:43:45 +0200 | [diff] [blame] | 1099 | } |
| 1100 | |
Jes Sorensen | 7c80ab3 | 2010-12-17 16:02:39 +0100 | [diff] [blame] | 1101 | static int qcow2_make_empty(BlockDriverState *bs) |
Blue Swirl | 20d9735 | 2010-04-23 20:19:47 +0000 | [diff] [blame] | 1102 | { |
| 1103 | #if 0 |
| 1104 | /* XXX: not correct */ |
| 1105 | BDRVQcowState *s = bs->opaque; |
| 1106 | uint32_t l1_length = s->l1_size * sizeof(uint64_t); |
| 1107 | int ret; |
| 1108 | |
| 1109 | memset(s->l1_table, 0, l1_length); |
Kevin Wolf | 66f82ce | 2010-04-14 14:17:38 +0200 | [diff] [blame] | 1110 | if (bdrv_pwrite(bs->file, s->l1_table_offset, s->l1_table, l1_length) < 0) |
Blue Swirl | 20d9735 | 2010-04-23 20:19:47 +0000 | [diff] [blame] | 1111 | return -1; |
Kevin Wolf | 66f82ce | 2010-04-14 14:17:38 +0200 | [diff] [blame] | 1112 | ret = bdrv_truncate(bs->file, s->l1_table_offset + l1_length); |
Blue Swirl | 20d9735 | 2010-04-23 20:19:47 +0000 | [diff] [blame] | 1113 | if (ret < 0) |
| 1114 | return ret; |
| 1115 | |
| 1116 | l2_cache_reset(bs); |
| 1117 | #endif |
| 1118 | return 0; |
| 1119 | } |
| 1120 | |
Kevin Wolf | 5ea929e | 2011-01-26 16:56:48 +0100 | [diff] [blame] | 1121 | static int qcow2_discard(BlockDriverState *bs, int64_t sector_num, |
| 1122 | int nb_sectors) |
| 1123 | { |
| 1124 | return qcow2_discard_clusters(bs, sector_num << BDRV_SECTOR_BITS, |
| 1125 | nb_sectors); |
| 1126 | } |
| 1127 | |
Stefan Hajnoczi | 419b19d | 2010-04-28 11:36:11 +0100 | [diff] [blame] | 1128 | static int qcow2_truncate(BlockDriverState *bs, int64_t offset) |
| 1129 | { |
| 1130 | BDRVQcowState *s = bs->opaque; |
| 1131 | int ret, new_l1_size; |
| 1132 | |
| 1133 | if (offset & 511) { |
| 1134 | return -EINVAL; |
| 1135 | } |
| 1136 | |
| 1137 | /* cannot proceed if image has snapshots */ |
| 1138 | if (s->nb_snapshots) { |
| 1139 | return -ENOTSUP; |
| 1140 | } |
| 1141 | |
| 1142 | /* shrinking is currently not supported */ |
| 1143 | if (offset < bs->total_sectors * 512) { |
| 1144 | return -ENOTSUP; |
| 1145 | } |
| 1146 | |
| 1147 | new_l1_size = size_to_l1(s, offset); |
Stefan Hajnoczi | 7289375 | 2010-10-18 16:53:53 +0100 | [diff] [blame] | 1148 | ret = qcow2_grow_l1_table(bs, new_l1_size, true); |
Stefan Hajnoczi | 419b19d | 2010-04-28 11:36:11 +0100 | [diff] [blame] | 1149 | if (ret < 0) { |
| 1150 | return ret; |
| 1151 | } |
| 1152 | |
| 1153 | /* write updated header.size */ |
| 1154 | offset = cpu_to_be64(offset); |
Kevin Wolf | 8b3b720 | 2010-06-16 17:44:35 +0200 | [diff] [blame] | 1155 | ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, size), |
| 1156 | &offset, sizeof(uint64_t)); |
Stefan Hajnoczi | 419b19d | 2010-04-28 11:36:11 +0100 | [diff] [blame] | 1157 | if (ret < 0) { |
| 1158 | return ret; |
| 1159 | } |
| 1160 | |
| 1161 | s->l1_vm_state_index = new_l1_size; |
| 1162 | return 0; |
| 1163 | } |
| 1164 | |
Blue Swirl | 20d9735 | 2010-04-23 20:19:47 +0000 | [diff] [blame] | 1165 | /* XXX: put compressed sectors first, then all the cluster aligned |
| 1166 | tables to avoid losing bytes in alignment */ |
Jes Sorensen | 7c80ab3 | 2010-12-17 16:02:39 +0100 | [diff] [blame] | 1167 | static int qcow2_write_compressed(BlockDriverState *bs, int64_t sector_num, |
| 1168 | const uint8_t *buf, int nb_sectors) |
Blue Swirl | 20d9735 | 2010-04-23 20:19:47 +0000 | [diff] [blame] | 1169 | { |
| 1170 | BDRVQcowState *s = bs->opaque; |
| 1171 | z_stream strm; |
| 1172 | int ret, out_len; |
| 1173 | uint8_t *out_buf; |
| 1174 | uint64_t cluster_offset; |
| 1175 | |
| 1176 | if (nb_sectors == 0) { |
| 1177 | /* align end of file to a sector boundary to ease reading with |
| 1178 | sector based I/Os */ |
Kevin Wolf | 66f82ce | 2010-04-14 14:17:38 +0200 | [diff] [blame] | 1179 | cluster_offset = bdrv_getlength(bs->file); |
Blue Swirl | 20d9735 | 2010-04-23 20:19:47 +0000 | [diff] [blame] | 1180 | cluster_offset = (cluster_offset + 511) & ~511; |
Kevin Wolf | 66f82ce | 2010-04-14 14:17:38 +0200 | [diff] [blame] | 1181 | bdrv_truncate(bs->file, cluster_offset); |
Blue Swirl | 20d9735 | 2010-04-23 20:19:47 +0000 | [diff] [blame] | 1182 | return 0; |
| 1183 | } |
| 1184 | |
| 1185 | if (nb_sectors != s->cluster_sectors) |
| 1186 | return -EINVAL; |
| 1187 | |
| 1188 | out_buf = qemu_malloc(s->cluster_size + (s->cluster_size / 1000) + 128); |
| 1189 | |
| 1190 | /* best compression, small window, no zlib header */ |
| 1191 | memset(&strm, 0, sizeof(strm)); |
| 1192 | ret = deflateInit2(&strm, Z_DEFAULT_COMPRESSION, |
| 1193 | Z_DEFLATED, -12, |
| 1194 | 9, Z_DEFAULT_STRATEGY); |
| 1195 | if (ret != 0) { |
| 1196 | qemu_free(out_buf); |
| 1197 | return -1; |
| 1198 | } |
| 1199 | |
| 1200 | strm.avail_in = s->cluster_size; |
| 1201 | strm.next_in = (uint8_t *)buf; |
| 1202 | strm.avail_out = s->cluster_size; |
| 1203 | strm.next_out = out_buf; |
| 1204 | |
| 1205 | ret = deflate(&strm, Z_FINISH); |
| 1206 | if (ret != Z_STREAM_END && ret != Z_OK) { |
| 1207 | qemu_free(out_buf); |
| 1208 | deflateEnd(&strm); |
| 1209 | return -1; |
| 1210 | } |
| 1211 | out_len = strm.next_out - out_buf; |
| 1212 | |
| 1213 | deflateEnd(&strm); |
| 1214 | |
| 1215 | if (ret != Z_STREAM_END || out_len >= s->cluster_size) { |
| 1216 | /* could not compress: write normal cluster */ |
| 1217 | bdrv_write(bs, sector_num, buf, s->cluster_sectors); |
| 1218 | } else { |
| 1219 | cluster_offset = qcow2_alloc_compressed_cluster_offset(bs, |
| 1220 | sector_num << 9, out_len); |
| 1221 | if (!cluster_offset) |
| 1222 | return -1; |
| 1223 | cluster_offset &= s->cluster_offset_mask; |
Kevin Wolf | 66f82ce | 2010-04-14 14:17:38 +0200 | [diff] [blame] | 1224 | BLKDBG_EVENT(bs->file, BLKDBG_WRITE_COMPRESSED); |
| 1225 | if (bdrv_pwrite(bs->file, cluster_offset, out_buf, out_len) != out_len) { |
Blue Swirl | 20d9735 | 2010-04-23 20:19:47 +0000 | [diff] [blame] | 1226 | qemu_free(out_buf); |
| 1227 | return -1; |
| 1228 | } |
| 1229 | } |
| 1230 | |
| 1231 | qemu_free(out_buf); |
| 1232 | return 0; |
| 1233 | } |
| 1234 | |
Jes Sorensen | 7c80ab3 | 2010-12-17 16:02:39 +0100 | [diff] [blame] | 1235 | static int qcow2_flush(BlockDriverState *bs) |
Blue Swirl | 20d9735 | 2010-04-23 20:19:47 +0000 | [diff] [blame] | 1236 | { |
Kevin Wolf | 29c1a73 | 2011-01-10 17:17:28 +0100 | [diff] [blame] | 1237 | BDRVQcowState *s = bs->opaque; |
| 1238 | int ret; |
| 1239 | |
| 1240 | ret = qcow2_cache_flush(bs, s->l2_table_cache); |
| 1241 | if (ret < 0) { |
| 1242 | return ret; |
| 1243 | } |
| 1244 | |
| 1245 | ret = qcow2_cache_flush(bs, s->refcount_block_cache); |
| 1246 | if (ret < 0) { |
| 1247 | return ret; |
| 1248 | } |
| 1249 | |
Kevin Wolf | 205ef79 | 2010-10-21 16:43:43 +0200 | [diff] [blame] | 1250 | return bdrv_flush(bs->file); |
Blue Swirl | 20d9735 | 2010-04-23 20:19:47 +0000 | [diff] [blame] | 1251 | } |
| 1252 | |
Jes Sorensen | 7c80ab3 | 2010-12-17 16:02:39 +0100 | [diff] [blame] | 1253 | static BlockDriverAIOCB *qcow2_aio_flush(BlockDriverState *bs, |
| 1254 | BlockDriverCompletionFunc *cb, |
| 1255 | void *opaque) |
Blue Swirl | 20d9735 | 2010-04-23 20:19:47 +0000 | [diff] [blame] | 1256 | { |
Kevin Wolf | 29c1a73 | 2011-01-10 17:17:28 +0100 | [diff] [blame] | 1257 | BDRVQcowState *s = bs->opaque; |
| 1258 | int ret; |
| 1259 | |
| 1260 | ret = qcow2_cache_flush(bs, s->l2_table_cache); |
| 1261 | if (ret < 0) { |
| 1262 | return NULL; |
| 1263 | } |
| 1264 | |
| 1265 | ret = qcow2_cache_flush(bs, s->refcount_block_cache); |
| 1266 | if (ret < 0) { |
| 1267 | return NULL; |
| 1268 | } |
| 1269 | |
Kevin Wolf | 66f82ce | 2010-04-14 14:17:38 +0200 | [diff] [blame] | 1270 | return bdrv_aio_flush(bs->file, cb, opaque); |
Blue Swirl | 20d9735 | 2010-04-23 20:19:47 +0000 | [diff] [blame] | 1271 | } |
| 1272 | |
Jes Sorensen | 7c80ab3 | 2010-12-17 16:02:39 +0100 | [diff] [blame] | 1273 | static int64_t qcow2_vm_state_offset(BDRVQcowState *s) |
Blue Swirl | 20d9735 | 2010-04-23 20:19:47 +0000 | [diff] [blame] | 1274 | { |
| 1275 | return (int64_t)s->l1_vm_state_index << (s->cluster_bits + s->l2_bits); |
| 1276 | } |
| 1277 | |
Jes Sorensen | 7c80ab3 | 2010-12-17 16:02:39 +0100 | [diff] [blame] | 1278 | static int qcow2_get_info(BlockDriverState *bs, BlockDriverInfo *bdi) |
Blue Swirl | 20d9735 | 2010-04-23 20:19:47 +0000 | [diff] [blame] | 1279 | { |
| 1280 | BDRVQcowState *s = bs->opaque; |
| 1281 | bdi->cluster_size = s->cluster_size; |
Jes Sorensen | 7c80ab3 | 2010-12-17 16:02:39 +0100 | [diff] [blame] | 1282 | bdi->vm_state_offset = qcow2_vm_state_offset(s); |
Blue Swirl | 20d9735 | 2010-04-23 20:19:47 +0000 | [diff] [blame] | 1283 | return 0; |
| 1284 | } |
| 1285 | |
| 1286 | |
Jes Sorensen | 7c80ab3 | 2010-12-17 16:02:39 +0100 | [diff] [blame] | 1287 | static int qcow2_check(BlockDriverState *bs, BdrvCheckResult *result) |
Blue Swirl | 20d9735 | 2010-04-23 20:19:47 +0000 | [diff] [blame] | 1288 | { |
Kevin Wolf | 9ac228e | 2010-06-29 12:37:54 +0200 | [diff] [blame] | 1289 | return qcow2_check_refcounts(bs, result); |
Blue Swirl | 20d9735 | 2010-04-23 20:19:47 +0000 | [diff] [blame] | 1290 | } |
| 1291 | |
| 1292 | #if 0 |
| 1293 | static void dump_refcounts(BlockDriverState *bs) |
| 1294 | { |
| 1295 | BDRVQcowState *s = bs->opaque; |
| 1296 | int64_t nb_clusters, k, k1, size; |
| 1297 | int refcount; |
| 1298 | |
Kevin Wolf | 66f82ce | 2010-04-14 14:17:38 +0200 | [diff] [blame] | 1299 | size = bdrv_getlength(bs->file); |
Blue Swirl | 20d9735 | 2010-04-23 20:19:47 +0000 | [diff] [blame] | 1300 | nb_clusters = size_to_clusters(s, size); |
| 1301 | for(k = 0; k < nb_clusters;) { |
| 1302 | k1 = k; |
| 1303 | refcount = get_refcount(bs, k); |
| 1304 | k++; |
| 1305 | while (k < nb_clusters && get_refcount(bs, k) == refcount) |
| 1306 | k++; |
Blue Swirl | 0bfcd59 | 2010-05-22 08:02:12 +0000 | [diff] [blame] | 1307 | printf("%" PRId64 ": refcount=%d nb=%" PRId64 "\n", k, refcount, |
| 1308 | k - k1); |
Blue Swirl | 20d9735 | 2010-04-23 20:19:47 +0000 | [diff] [blame] | 1309 | } |
| 1310 | } |
| 1311 | #endif |
| 1312 | |
Jes Sorensen | 7c80ab3 | 2010-12-17 16:02:39 +0100 | [diff] [blame] | 1313 | static int qcow2_save_vmstate(BlockDriverState *bs, const uint8_t *buf, |
| 1314 | int64_t pos, int size) |
Blue Swirl | 20d9735 | 2010-04-23 20:19:47 +0000 | [diff] [blame] | 1315 | { |
| 1316 | BDRVQcowState *s = bs->opaque; |
| 1317 | int growable = bs->growable; |
| 1318 | int ret; |
| 1319 | |
Kevin Wolf | 66f82ce | 2010-04-14 14:17:38 +0200 | [diff] [blame] | 1320 | BLKDBG_EVENT(bs->file, BLKDBG_VMSTATE_SAVE); |
Blue Swirl | 20d9735 | 2010-04-23 20:19:47 +0000 | [diff] [blame] | 1321 | bs->growable = 1; |
Jes Sorensen | 7c80ab3 | 2010-12-17 16:02:39 +0100 | [diff] [blame] | 1322 | ret = bdrv_pwrite(bs, qcow2_vm_state_offset(s) + pos, buf, size); |
Blue Swirl | 20d9735 | 2010-04-23 20:19:47 +0000 | [diff] [blame] | 1323 | bs->growable = growable; |
| 1324 | |
| 1325 | return ret; |
| 1326 | } |
| 1327 | |
Jes Sorensen | 7c80ab3 | 2010-12-17 16:02:39 +0100 | [diff] [blame] | 1328 | static int qcow2_load_vmstate(BlockDriverState *bs, uint8_t *buf, |
| 1329 | int64_t pos, int size) |
Blue Swirl | 20d9735 | 2010-04-23 20:19:47 +0000 | [diff] [blame] | 1330 | { |
| 1331 | BDRVQcowState *s = bs->opaque; |
| 1332 | int growable = bs->growable; |
| 1333 | int ret; |
| 1334 | |
Kevin Wolf | 66f82ce | 2010-04-14 14:17:38 +0200 | [diff] [blame] | 1335 | BLKDBG_EVENT(bs->file, BLKDBG_VMSTATE_LOAD); |
Blue Swirl | 20d9735 | 2010-04-23 20:19:47 +0000 | [diff] [blame] | 1336 | bs->growable = 1; |
Jes Sorensen | 7c80ab3 | 2010-12-17 16:02:39 +0100 | [diff] [blame] | 1337 | ret = bdrv_pread(bs, qcow2_vm_state_offset(s) + pos, buf, size); |
Blue Swirl | 20d9735 | 2010-04-23 20:19:47 +0000 | [diff] [blame] | 1338 | bs->growable = growable; |
| 1339 | |
| 1340 | return ret; |
| 1341 | } |
| 1342 | |
Jes Sorensen | 7c80ab3 | 2010-12-17 16:02:39 +0100 | [diff] [blame] | 1343 | static QEMUOptionParameter qcow2_create_options[] = { |
Blue Swirl | 20d9735 | 2010-04-23 20:19:47 +0000 | [diff] [blame] | 1344 | { |
| 1345 | .name = BLOCK_OPT_SIZE, |
| 1346 | .type = OPT_SIZE, |
| 1347 | .help = "Virtual disk size" |
| 1348 | }, |
| 1349 | { |
| 1350 | .name = BLOCK_OPT_BACKING_FILE, |
| 1351 | .type = OPT_STRING, |
| 1352 | .help = "File name of a base image" |
| 1353 | }, |
| 1354 | { |
| 1355 | .name = BLOCK_OPT_BACKING_FMT, |
| 1356 | .type = OPT_STRING, |
| 1357 | .help = "Image format of the base image" |
| 1358 | }, |
| 1359 | { |
| 1360 | .name = BLOCK_OPT_ENCRYPT, |
| 1361 | .type = OPT_FLAG, |
| 1362 | .help = "Encrypt the image" |
| 1363 | }, |
| 1364 | { |
| 1365 | .name = BLOCK_OPT_CLUSTER_SIZE, |
| 1366 | .type = OPT_SIZE, |
Kevin Wolf | 99cce9f | 2011-05-31 15:01:46 +0200 | [diff] [blame] | 1367 | .help = "qcow2 cluster size", |
| 1368 | .value = { .n = DEFAULT_CLUSTER_SIZE }, |
Blue Swirl | 20d9735 | 2010-04-23 20:19:47 +0000 | [diff] [blame] | 1369 | }, |
| 1370 | { |
| 1371 | .name = BLOCK_OPT_PREALLOC, |
| 1372 | .type = OPT_STRING, |
| 1373 | .help = "Preallocation mode (allowed values: off, metadata)" |
| 1374 | }, |
| 1375 | { NULL } |
| 1376 | }; |
| 1377 | |
| 1378 | static BlockDriver bdrv_qcow2 = { |
Jes Sorensen | 7c80ab3 | 2010-12-17 16:02:39 +0100 | [diff] [blame] | 1379 | .format_name = "qcow2", |
| 1380 | .instance_size = sizeof(BDRVQcowState), |
| 1381 | .bdrv_probe = qcow2_probe, |
| 1382 | .bdrv_open = qcow2_open, |
| 1383 | .bdrv_close = qcow2_close, |
| 1384 | .bdrv_create = qcow2_create, |
| 1385 | .bdrv_flush = qcow2_flush, |
| 1386 | .bdrv_is_allocated = qcow2_is_allocated, |
| 1387 | .bdrv_set_key = qcow2_set_key, |
| 1388 | .bdrv_make_empty = qcow2_make_empty, |
Blue Swirl | 20d9735 | 2010-04-23 20:19:47 +0000 | [diff] [blame] | 1389 | |
Jes Sorensen | 7c80ab3 | 2010-12-17 16:02:39 +0100 | [diff] [blame] | 1390 | .bdrv_aio_readv = qcow2_aio_readv, |
| 1391 | .bdrv_aio_writev = qcow2_aio_writev, |
| 1392 | .bdrv_aio_flush = qcow2_aio_flush, |
Stefan Hajnoczi | 419b19d | 2010-04-28 11:36:11 +0100 | [diff] [blame] | 1393 | |
Kevin Wolf | 5ea929e | 2011-01-26 16:56:48 +0100 | [diff] [blame] | 1394 | .bdrv_discard = qcow2_discard, |
Stefan Hajnoczi | 419b19d | 2010-04-28 11:36:11 +0100 | [diff] [blame] | 1395 | .bdrv_truncate = qcow2_truncate, |
Jes Sorensen | 7c80ab3 | 2010-12-17 16:02:39 +0100 | [diff] [blame] | 1396 | .bdrv_write_compressed = qcow2_write_compressed, |
Blue Swirl | 20d9735 | 2010-04-23 20:19:47 +0000 | [diff] [blame] | 1397 | |
| 1398 | .bdrv_snapshot_create = qcow2_snapshot_create, |
| 1399 | .bdrv_snapshot_goto = qcow2_snapshot_goto, |
| 1400 | .bdrv_snapshot_delete = qcow2_snapshot_delete, |
| 1401 | .bdrv_snapshot_list = qcow2_snapshot_list, |
edison | 51ef672 | 2010-09-21 19:58:41 -0700 | [diff] [blame] | 1402 | .bdrv_snapshot_load_tmp = qcow2_snapshot_load_tmp, |
Jes Sorensen | 7c80ab3 | 2010-12-17 16:02:39 +0100 | [diff] [blame] | 1403 | .bdrv_get_info = qcow2_get_info, |
Blue Swirl | 20d9735 | 2010-04-23 20:19:47 +0000 | [diff] [blame] | 1404 | |
Jes Sorensen | 7c80ab3 | 2010-12-17 16:02:39 +0100 | [diff] [blame] | 1405 | .bdrv_save_vmstate = qcow2_save_vmstate, |
| 1406 | .bdrv_load_vmstate = qcow2_load_vmstate, |
Blue Swirl | 20d9735 | 2010-04-23 20:19:47 +0000 | [diff] [blame] | 1407 | |
| 1408 | .bdrv_change_backing_file = qcow2_change_backing_file, |
| 1409 | |
Jes Sorensen | 7c80ab3 | 2010-12-17 16:02:39 +0100 | [diff] [blame] | 1410 | .create_options = qcow2_create_options, |
| 1411 | .bdrv_check = qcow2_check, |
Blue Swirl | 20d9735 | 2010-04-23 20:19:47 +0000 | [diff] [blame] | 1412 | }; |
| 1413 | |
Anthony Liguori | 5efa9d5 | 2009-05-09 17:03:42 -0500 | [diff] [blame] | 1414 | static void bdrv_qcow2_init(void) |
| 1415 | { |
| 1416 | bdrv_register(&bdrv_qcow2); |
| 1417 | } |
| 1418 | |
| 1419 | block_init(bdrv_qcow2_init); |