![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to qcow.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / block|
Return to qcow.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / block |
1.1 root 1: /*
2: * Block driver for the QCOW format
3: *
4: * Copyright (c) 2004-2006 Fabrice Bellard
5: *
6: * Permission is hereby granted, free of charge, to any person obtaining a copy
7: * of this software and associated documentation files (the "Software"), to deal
8: * in the Software without restriction, including without limitation the rights
9: * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10: * copies of the Software, and to permit persons to whom the Software is
11: * furnished to do so, subject to the following conditions:
12: *
13: * The above copyright notice and this permission notice shall be included in
14: * all copies or substantial portions of the Software.
15: *
16: * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17: * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19: * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20: * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21: * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22: * THE SOFTWARE.
23: */
24: #include "qemu-common.h"
25: #include "block_int.h"
26: #include "module.h"
27: #include <zlib.h>
28: #include "aes.h"
1.1.1.6 root 29: #include "migration.h"
1.1 root 30:
31: /**************************************************************/
32: /* QEMU COW block driver with compression and encryption support */
33:
34: #define QCOW_MAGIC (('Q' << 24) | ('F' << 16) | ('I' << 8) | 0xfb)
35: #define QCOW_VERSION 1
36:
37: #define QCOW_CRYPT_NONE 0
38: #define QCOW_CRYPT_AES 1
39:
40: #define QCOW_OFLAG_COMPRESSED (1LL << 63)
41:
42: typedef struct QCowHeader {
43: uint32_t magic;
44: uint32_t version;
45: uint64_t backing_file_offset;
46: uint32_t backing_file_size;
47: uint32_t mtime;
48: uint64_t size; /* in bytes */
49: uint8_t cluster_bits;
50: uint8_t l2_bits;
51: uint32_t crypt_method;
52: uint64_t l1_table_offset;
53: } QCowHeader;
54:
55: #define L2_CACHE_SIZE 16
56:
57: typedef struct BDRVQcowState {
58: int cluster_bits;
59: int cluster_size;
60: int cluster_sectors;
61: int l2_bits;
62: int l2_size;
63: int l1_size;
64: uint64_t cluster_offset_mask;
65: uint64_t l1_table_offset;
66: uint64_t *l1_table;
67: uint64_t *l2_cache;
68: uint64_t l2_cache_offsets[L2_CACHE_SIZE];
69: uint32_t l2_cache_counts[L2_CACHE_SIZE];
70: uint8_t *cluster_cache;
71: uint8_t *cluster_data;
72: uint64_t cluster_cache_offset;
73: uint32_t crypt_method; /* current crypt method, 0 if no key yet */
74: uint32_t crypt_method_header;
75: AES_KEY aes_encrypt_key;
76: AES_KEY aes_decrypt_key;
1.1.1.6 root 77: CoMutex lock;
78: Error *migration_blocker;
1.1 root 79: } BDRVQcowState;
80:
1.1.1.3 root 81: static int decompress_cluster(BlockDriverState *bs, uint64_t cluster_offset);
1.1 root 82:
83: static int qcow_probe(const uint8_t *buf, int buf_size, const char *filename)
84: {
85: const QCowHeader *cow_header = (const void *)buf;
86:
87: if (buf_size >= sizeof(QCowHeader) &&
88: be32_to_cpu(cow_header->magic) == QCOW_MAGIC &&
89: be32_to_cpu(cow_header->version) == QCOW_VERSION)
90: return 100;
91: else
92: return 0;
93: }
94:
1.1.1.3 root 95: static int qcow_open(BlockDriverState *bs, int flags)
1.1 root 96: {
97: BDRVQcowState *s = bs->opaque;
1.1.1.7 ! root 98: int len, i, shift, ret;
1.1 root 99: QCowHeader header;
100:
1.1.1.7 ! root 101: ret = bdrv_pread(bs->file, 0, &header, sizeof(header));
! 102: if (ret < 0) {
1.1 root 103: goto fail;
1.1.1.7 ! root 104: }
1.1 root 105: be32_to_cpus(&header.magic);
106: be32_to_cpus(&header.version);
107: be64_to_cpus(&header.backing_file_offset);
108: be32_to_cpus(&header.backing_file_size);
109: be32_to_cpus(&header.mtime);
110: be64_to_cpus(&header.size);
111: be32_to_cpus(&header.crypt_method);
112: be64_to_cpus(&header.l1_table_offset);
113:
1.1.1.7 ! root 114: if (header.magic != QCOW_MAGIC) {
! 115: ret = -EINVAL;
1.1 root 116: goto fail;
1.1.1.7 ! root 117: }
! 118: if (header.version != QCOW_VERSION) {
! 119: char version[64];
! 120: snprintf(version, sizeof(version), "QCOW version %d", header.version);
! 121: qerror_report(QERR_UNKNOWN_BLOCK_FORMAT_FEATURE,
! 122: bs->device_name, "qcow", version);
! 123: ret = -ENOTSUP;
! 124: goto fail;
! 125: }
! 126:
! 127: if (header.size <= 1 || header.cluster_bits < 9) {
! 128: ret = -EINVAL;
1.1 root 129: goto fail;
1.1.1.7 ! root 130: }
! 131: if (header.crypt_method > QCOW_CRYPT_AES) {
! 132: ret = -EINVAL;
1.1 root 133: goto fail;
1.1.1.7 ! root 134: }
1.1 root 135: s->crypt_method_header = header.crypt_method;
1.1.1.7 ! root 136: if (s->crypt_method_header) {
1.1 root 137: bs->encrypted = 1;
1.1.1.7 ! root 138: }
1.1 root 139: s->cluster_bits = header.cluster_bits;
140: s->cluster_size = 1 << s->cluster_bits;
141: s->cluster_sectors = 1 << (s->cluster_bits - 9);
142: s->l2_bits = header.l2_bits;
143: s->l2_size = 1 << s->l2_bits;
144: bs->total_sectors = header.size / 512;
145: s->cluster_offset_mask = (1LL << (63 - s->cluster_bits)) - 1;
146:
147: /* read the level 1 table */
148: shift = s->cluster_bits + s->l2_bits;
149: s->l1_size = (header.size + (1LL << shift) - 1) >> shift;
150:
151: s->l1_table_offset = header.l1_table_offset;
1.1.1.6 root 152: s->l1_table = g_malloc(s->l1_size * sizeof(uint64_t));
1.1.1.7 ! root 153:
! 154: ret = bdrv_pread(bs->file, s->l1_table_offset, s->l1_table,
! 155: s->l1_size * sizeof(uint64_t));
! 156: if (ret < 0) {
1.1 root 157: goto fail;
1.1.1.7 ! root 158: }
! 159:
1.1 root 160: for(i = 0;i < s->l1_size; i++) {
161: be64_to_cpus(&s->l1_table[i]);
162: }
163: /* alloc L2 cache */
1.1.1.6 root 164: s->l2_cache = g_malloc(s->l2_size * L2_CACHE_SIZE * sizeof(uint64_t));
165: s->cluster_cache = g_malloc(s->cluster_size);
166: s->cluster_data = g_malloc(s->cluster_size);
1.1 root 167: s->cluster_cache_offset = -1;
168:
169: /* read the backing file name */
170: if (header.backing_file_offset != 0) {
171: len = header.backing_file_size;
1.1.1.7 ! root 172: if (len > 1023) {
1.1 root 173: len = 1023;
1.1.1.7 ! root 174: }
! 175: ret = bdrv_pread(bs->file, header.backing_file_offset,
! 176: bs->backing_file, len);
! 177: if (ret < 0) {
1.1 root 178: goto fail;
1.1.1.7 ! root 179: }
1.1 root 180: bs->backing_file[len] = '\0';
181: }
1.1.1.6 root 182:
183: /* Disable migration when qcow images are used */
184: error_set(&s->migration_blocker,
185: QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED,
186: "qcow", bs->device_name, "live migration");
187: migrate_add_blocker(s->migration_blocker);
188:
189: qemu_co_mutex_init(&s->lock);
1.1 root 190: return 0;
191:
192: fail:
1.1.1.6 root 193: g_free(s->l1_table);
194: g_free(s->l2_cache);
195: g_free(s->cluster_cache);
196: g_free(s->cluster_data);
1.1.1.7 ! root 197: return ret;
1.1 root 198: }
199:
200: static int qcow_set_key(BlockDriverState *bs, const char *key)
201: {
202: BDRVQcowState *s = bs->opaque;
203: uint8_t keybuf[16];
204: int len, i;
205:
206: memset(keybuf, 0, 16);
207: len = strlen(key);
208: if (len > 16)
209: len = 16;
210: /* XXX: we could compress the chars to 7 bits to increase
211: entropy */
212: for(i = 0;i < len;i++) {
213: keybuf[i] = key[i];
214: }
215: s->crypt_method = s->crypt_method_header;
216:
217: if (AES_set_encrypt_key(keybuf, 128, &s->aes_encrypt_key) != 0)
218: return -1;
219: if (AES_set_decrypt_key(keybuf, 128, &s->aes_decrypt_key) != 0)
220: return -1;
221: return 0;
222: }
223:
224: /* The crypt function is compatible with the linux cryptoloop
225: algorithm for < 4 GB images. NOTE: out_buf == in_buf is
226: supported */
227: static void encrypt_sectors(BDRVQcowState *s, int64_t sector_num,
228: uint8_t *out_buf, const uint8_t *in_buf,
229: int nb_sectors, int enc,
230: const AES_KEY *key)
231: {
232: union {
233: uint64_t ll[2];
234: uint8_t b[16];
235: } ivec;
236: int i;
237:
238: for(i = 0; i < nb_sectors; i++) {
239: ivec.ll[0] = cpu_to_le64(sector_num);
240: ivec.ll[1] = 0;
241: AES_cbc_encrypt(in_buf, out_buf, 512, key,
242: ivec.b, enc);
243: sector_num++;
244: in_buf += 512;
245: out_buf += 512;
246: }
247: }
248:
249: /* 'allocate' is:
250: *
251: * 0 to not allocate.
252: *
253: * 1 to allocate a normal cluster (for sector indexes 'n_start' to
254: * 'n_end')
255: *
256: * 2 to allocate a compressed cluster of size
257: * 'compressed_size'. 'compressed_size' must be > 0 and <
258: * cluster_size
259: *
260: * return 0 if not allocated.
261: */
262: static uint64_t get_cluster_offset(BlockDriverState *bs,
263: uint64_t offset, int allocate,
264: int compressed_size,
265: int n_start, int n_end)
266: {
267: BDRVQcowState *s = bs->opaque;
268: int min_index, i, j, l1_index, l2_index;
269: uint64_t l2_offset, *l2_table, cluster_offset, tmp;
270: uint32_t min_count;
271: int new_l2_table;
272:
273: l1_index = offset >> (s->l2_bits + s->cluster_bits);
274: l2_offset = s->l1_table[l1_index];
275: new_l2_table = 0;
276: if (!l2_offset) {
277: if (!allocate)
278: return 0;
279: /* allocate a new l2 entry */
1.1.1.3 root 280: l2_offset = bdrv_getlength(bs->file);
1.1 root 281: /* round to cluster size */
282: l2_offset = (l2_offset + s->cluster_size - 1) & ~(s->cluster_size - 1);
283: /* update the L1 entry */
284: s->l1_table[l1_index] = l2_offset;
285: tmp = cpu_to_be64(l2_offset);
1.1.1.3 root 286: if (bdrv_pwrite_sync(bs->file,
1.1.1.2 root 287: s->l1_table_offset + l1_index * sizeof(tmp),
288: &tmp, sizeof(tmp)) < 0)
1.1 root 289: return 0;
290: new_l2_table = 1;
291: }
292: for(i = 0; i < L2_CACHE_SIZE; i++) {
293: if (l2_offset == s->l2_cache_offsets[i]) {
294: /* increment the hit count */
295: if (++s->l2_cache_counts[i] == 0xffffffff) {
296: for(j = 0; j < L2_CACHE_SIZE; j++) {
297: s->l2_cache_counts[j] >>= 1;
298: }
299: }
300: l2_table = s->l2_cache + (i << s->l2_bits);
301: goto found;
302: }
303: }
304: /* not found: load a new entry in the least used one */
305: min_index = 0;
306: min_count = 0xffffffff;
307: for(i = 0; i < L2_CACHE_SIZE; i++) {
308: if (s->l2_cache_counts[i] < min_count) {
309: min_count = s->l2_cache_counts[i];
310: min_index = i;
311: }
312: }
313: l2_table = s->l2_cache + (min_index << s->l2_bits);
314: if (new_l2_table) {
315: memset(l2_table, 0, s->l2_size * sizeof(uint64_t));
1.1.1.3 root 316: if (bdrv_pwrite_sync(bs->file, l2_offset, l2_table,
1.1.1.2 root 317: s->l2_size * sizeof(uint64_t)) < 0)
1.1 root 318: return 0;
319: } else {
1.1.1.3 root 320: if (bdrv_pread(bs->file, l2_offset, l2_table, s->l2_size * sizeof(uint64_t)) !=
1.1 root 321: s->l2_size * sizeof(uint64_t))
322: return 0;
323: }
324: s->l2_cache_offsets[min_index] = l2_offset;
325: s->l2_cache_counts[min_index] = 1;
326: found:
327: l2_index = (offset >> s->cluster_bits) & (s->l2_size - 1);
328: cluster_offset = be64_to_cpu(l2_table[l2_index]);
329: if (!cluster_offset ||
330: ((cluster_offset & QCOW_OFLAG_COMPRESSED) && allocate == 1)) {
331: if (!allocate)
332: return 0;
333: /* allocate a new cluster */
334: if ((cluster_offset & QCOW_OFLAG_COMPRESSED) &&
335: (n_end - n_start) < s->cluster_sectors) {
336: /* if the cluster is already compressed, we must
337: decompress it in the case it is not completely
338: overwritten */
1.1.1.3 root 339: if (decompress_cluster(bs, cluster_offset) < 0)
1.1 root 340: return 0;
1.1.1.3 root 341: cluster_offset = bdrv_getlength(bs->file);
1.1 root 342: cluster_offset = (cluster_offset + s->cluster_size - 1) &
343: ~(s->cluster_size - 1);
344: /* write the cluster content */
1.1.1.3 root 345: if (bdrv_pwrite(bs->file, cluster_offset, s->cluster_cache, s->cluster_size) !=
1.1 root 346: s->cluster_size)
347: return -1;
348: } else {
1.1.1.3 root 349: cluster_offset = bdrv_getlength(bs->file);
1.1 root 350: if (allocate == 1) {
351: /* round to cluster size */
352: cluster_offset = (cluster_offset + s->cluster_size - 1) &
353: ~(s->cluster_size - 1);
1.1.1.3 root 354: bdrv_truncate(bs->file, cluster_offset + s->cluster_size);
1.1 root 355: /* if encrypted, we must initialize the cluster
356: content which won't be written */
357: if (s->crypt_method &&
358: (n_end - n_start) < s->cluster_sectors) {
359: uint64_t start_sect;
360: start_sect = (offset & ~(s->cluster_size - 1)) >> 9;
361: memset(s->cluster_data + 512, 0x00, 512);
362: for(i = 0; i < s->cluster_sectors; i++) {
363: if (i < n_start || i >= n_end) {
364: encrypt_sectors(s, start_sect + i,
365: s->cluster_data,
366: s->cluster_data + 512, 1, 1,
367: &s->aes_encrypt_key);
1.1.1.3 root 368: if (bdrv_pwrite(bs->file, cluster_offset + i * 512,
1.1 root 369: s->cluster_data, 512) != 512)
370: return -1;
371: }
372: }
373: }
374: } else if (allocate == 2) {
375: cluster_offset |= QCOW_OFLAG_COMPRESSED |
376: (uint64_t)compressed_size << (63 - s->cluster_bits);
377: }
378: }
379: /* update L2 table */
380: tmp = cpu_to_be64(cluster_offset);
381: l2_table[l2_index] = tmp;
1.1.1.3 root 382: if (bdrv_pwrite_sync(bs->file, l2_offset + l2_index * sizeof(tmp),
1.1.1.2 root 383: &tmp, sizeof(tmp)) < 0)
1.1 root 384: return 0;
385: }
386: return cluster_offset;
387: }
388:
1.1.1.7 ! root 389: static int coroutine_fn qcow_co_is_allocated(BlockDriverState *bs,
! 390: int64_t sector_num, int nb_sectors, int *pnum)
1.1 root 391: {
392: BDRVQcowState *s = bs->opaque;
393: int index_in_cluster, n;
394: uint64_t cluster_offset;
395:
1.1.1.7 ! root 396: qemu_co_mutex_lock(&s->lock);
1.1 root 397: cluster_offset = get_cluster_offset(bs, sector_num << 9, 0, 0, 0, 0);
1.1.1.7 ! root 398: qemu_co_mutex_unlock(&s->lock);
1.1 root 399: index_in_cluster = sector_num & (s->cluster_sectors - 1);
400: n = s->cluster_sectors - index_in_cluster;
401: if (n > nb_sectors)
402: n = nb_sectors;
403: *pnum = n;
404: return (cluster_offset != 0);
405: }
406:
407: static int decompress_buffer(uint8_t *out_buf, int out_buf_size,
408: const uint8_t *buf, int buf_size)
409: {
410: z_stream strm1, *strm = &strm1;
411: int ret, out_len;
412:
413: memset(strm, 0, sizeof(*strm));
414:
415: strm->next_in = (uint8_t *)buf;
416: strm->avail_in = buf_size;
417: strm->next_out = out_buf;
418: strm->avail_out = out_buf_size;
419:
420: ret = inflateInit2(strm, -12);
421: if (ret != Z_OK)
422: return -1;
423: ret = inflate(strm, Z_FINISH);
424: out_len = strm->next_out - out_buf;
425: if ((ret != Z_STREAM_END && ret != Z_BUF_ERROR) ||
426: out_len != out_buf_size) {
427: inflateEnd(strm);
428: return -1;
429: }
430: inflateEnd(strm);
431: return 0;
432: }
433:
1.1.1.3 root 434: static int decompress_cluster(BlockDriverState *bs, uint64_t cluster_offset)
1.1 root 435: {
1.1.1.3 root 436: BDRVQcowState *s = bs->opaque;
1.1 root 437: int ret, csize;
438: uint64_t coffset;
439:
440: coffset = cluster_offset & s->cluster_offset_mask;
441: if (s->cluster_cache_offset != coffset) {
442: csize = cluster_offset >> (63 - s->cluster_bits);
443: csize &= (s->cluster_size - 1);
1.1.1.3 root 444: ret = bdrv_pread(bs->file, coffset, s->cluster_data, csize);
1.1 root 445: if (ret != csize)
446: return -1;
447: if (decompress_buffer(s->cluster_cache, s->cluster_size,
448: s->cluster_data, csize) < 0) {
449: return -1;
450: }
451: s->cluster_cache_offset = coffset;
452: }
453: return 0;
454: }
455:
1.1.1.7 ! root 456: static coroutine_fn int qcow_co_readv(BlockDriverState *bs, int64_t sector_num,
1.1.1.6 root 457: int nb_sectors, QEMUIOVector *qiov)
1.1 root 458: {
459: BDRVQcowState *s = bs->opaque;
1.1.1.6 root 460: int index_in_cluster;
461: int ret = 0, n;
1.1 root 462: uint64_t cluster_offset;
1.1.1.6 root 463: struct iovec hd_iov;
464: QEMUIOVector hd_qiov;
465: uint8_t *buf;
466: void *orig_buf;
1.1 root 467:
1.1.1.6 root 468: if (qiov->niov > 1) {
469: buf = orig_buf = qemu_blockalign(bs, qiov->size);
470: } else {
471: orig_buf = NULL;
472: buf = (uint8_t *)qiov->iov->iov_base;
473: }
474:
475: qemu_co_mutex_lock(&s->lock);
476:
477: while (nb_sectors != 0) {
478: /* prepare next request */
479: cluster_offset = get_cluster_offset(bs, sector_num << 9,
480: 0, 0, 0, 0);
1.1 root 481: index_in_cluster = sector_num & (s->cluster_sectors - 1);
482: n = s->cluster_sectors - index_in_cluster;
1.1.1.6 root 483: if (n > nb_sectors) {
1.1 root 484: n = nb_sectors;
1.1.1.6 root 485: }
486:
1.1 root 487: if (!cluster_offset) {
488: if (bs->backing_hd) {
489: /* read from the base image */
1.1.1.6 root 490: hd_iov.iov_base = (void *)buf;
491: hd_iov.iov_len = n * 512;
492: qemu_iovec_init_external(&hd_qiov, &hd_iov, 1);
493: qemu_co_mutex_unlock(&s->lock);
494: ret = bdrv_co_readv(bs->backing_hd, sector_num,
495: n, &hd_qiov);
496: qemu_co_mutex_lock(&s->lock);
497: if (ret < 0) {
498: goto fail;
499: }
1.1 root 500: } else {
1.1.1.6 root 501: /* Note: in this case, no need to wait */
1.1 root 502: memset(buf, 0, 512 * n);
503: }
504: } else if (cluster_offset & QCOW_OFLAG_COMPRESSED) {
1.1.1.6 root 505: /* add AIO support for compressed blocks ? */
506: if (decompress_cluster(bs, cluster_offset) < 0) {
507: goto fail;
508: }
509: memcpy(buf,
510: s->cluster_cache + index_in_cluster * 512, 512 * n);
1.1 root 511: } else {
1.1.1.6 root 512: if ((cluster_offset & 511) != 0) {
513: goto fail;
514: }
515: hd_iov.iov_base = (void *)buf;
516: hd_iov.iov_len = n * 512;
517: qemu_iovec_init_external(&hd_qiov, &hd_iov, 1);
518: qemu_co_mutex_unlock(&s->lock);
519: ret = bdrv_co_readv(bs->file,
520: (cluster_offset >> 9) + index_in_cluster,
521: n, &hd_qiov);
522: qemu_co_mutex_lock(&s->lock);
523: if (ret < 0) {
524: break;
525: }
1.1 root 526: if (s->crypt_method) {
1.1.1.6 root 527: encrypt_sectors(s, sector_num, buf, buf,
528: n, 0,
1.1 root 529: &s->aes_decrypt_key);
530: }
531: }
1.1.1.6 root 532: ret = 0;
533:
1.1 root 534: nb_sectors -= n;
535: sector_num += n;
536: buf += n * 512;
537: }
538:
1.1.1.6 root 539: done:
540: qemu_co_mutex_unlock(&s->lock);
1.1.1.5 root 541:
1.1 root 542: if (qiov->niov > 1) {
1.1.1.6 root 543: qemu_iovec_from_buffer(qiov, orig_buf, qiov->size);
544: qemu_vfree(orig_buf);
1.1 root 545: }
1.1.1.5 root 546:
1.1.1.6 root 547: return ret;
1.1.1.5 root 548:
1.1.1.6 root 549: fail:
550: ret = -EIO;
551: goto done;
1.1.1.5 root 552: }
553:
1.1.1.7 ! root 554: static coroutine_fn int qcow_co_writev(BlockDriverState *bs, int64_t sector_num,
1.1.1.6 root 555: int nb_sectors, QEMUIOVector *qiov)
1.1.1.5 root 556: {
1.1 root 557: BDRVQcowState *s = bs->opaque;
558: int index_in_cluster;
1.1.1.6 root 559: uint64_t cluster_offset;
560: const uint8_t *src_buf;
561: int ret = 0, n;
562: uint8_t *cluster_data = NULL;
563: struct iovec hd_iov;
564: QEMUIOVector hd_qiov;
565: uint8_t *buf;
566: void *orig_buf;
1.1 root 567:
1.1.1.6 root 568: s->cluster_cache_offset = -1; /* disable compressed cache */
1.1 root 569:
1.1.1.6 root 570: if (qiov->niov > 1) {
571: buf = orig_buf = qemu_blockalign(bs, qiov->size);
572: qemu_iovec_to_buffer(qiov, buf);
1.1 root 573: } else {
1.1.1.6 root 574: orig_buf = NULL;
575: buf = (uint8_t *)qiov->iov->iov_base;
1.1 root 576: }
577:
1.1.1.6 root 578: qemu_co_mutex_lock(&s->lock);
1.1 root 579:
1.1.1.6 root 580: while (nb_sectors != 0) {
1.1 root 581:
1.1.1.6 root 582: index_in_cluster = sector_num & (s->cluster_sectors - 1);
583: n = s->cluster_sectors - index_in_cluster;
584: if (n > nb_sectors) {
585: n = nb_sectors;
1.1.1.5 root 586: }
1.1.1.6 root 587: cluster_offset = get_cluster_offset(bs, sector_num << 9, 1, 0,
588: index_in_cluster,
589: index_in_cluster + n);
590: if (!cluster_offset || (cluster_offset & 511) != 0) {
1.1 root 591: ret = -EIO;
1.1.1.6 root 592: break;
1.1 root 593: }
1.1.1.6 root 594: if (s->crypt_method) {
595: if (!cluster_data) {
596: cluster_data = g_malloc0(s->cluster_size);
597: }
598: encrypt_sectors(s, sector_num, cluster_data, buf,
599: n, 1, &s->aes_encrypt_key);
600: src_buf = cluster_data;
601: } else {
602: src_buf = buf;
1.1.1.5 root 603: }
1.1 root 604:
1.1.1.6 root 605: hd_iov.iov_base = (void *)src_buf;
606: hd_iov.iov_len = n * 512;
607: qemu_iovec_init_external(&hd_qiov, &hd_iov, 1);
608: qemu_co_mutex_unlock(&s->lock);
609: ret = bdrv_co_writev(bs->file,
610: (cluster_offset >> 9) + index_in_cluster,
611: n, &hd_qiov);
612: qemu_co_mutex_lock(&s->lock);
613: if (ret < 0) {
614: break;
1.1.1.5 root 615: }
1.1 root 616: ret = 0;
617:
1.1.1.6 root 618: nb_sectors -= n;
619: sector_num += n;
620: buf += n * 512;
1.1 root 621: }
1.1.1.6 root 622: qemu_co_mutex_unlock(&s->lock);
1.1 root 623:
1.1.1.6 root 624: if (qiov->niov > 1) {
625: qemu_vfree(orig_buf);
1.1.1.5 root 626: }
1.1.1.6 root 627: g_free(cluster_data);
1.1 root 628:
1.1.1.6 root 629: return ret;
1.1 root 630: }
631:
1.1.1.6 root 632: static void qcow_close(BlockDriverState *bs)
1.1 root 633: {
634: BDRVQcowState *s = bs->opaque;
635:
1.1.1.6 root 636: g_free(s->l1_table);
637: g_free(s->l2_cache);
638: g_free(s->cluster_cache);
639: g_free(s->cluster_data);
1.1 root 640:
1.1.1.6 root 641: migrate_del_blocker(s->migration_blocker);
642: error_free(s->migration_blocker);
1.1 root 643: }
644:
645: static int qcow_create(const char *filename, QEMUOptionParameter *options)
646: {
1.1.1.7 ! root 647: int header_size, backing_filename_len, l1_size, shift, i;
1.1 root 648: QCowHeader header;
1.1.1.7 ! root 649: uint8_t *tmp;
1.1 root 650: int64_t total_size = 0;
651: const char *backing_file = NULL;
652: int flags = 0;
1.1.1.3 root 653: int ret;
1.1.1.7 ! root 654: BlockDriverState *qcow_bs;
1.1 root 655:
656: /* Read out options */
657: while (options && options->name) {
658: if (!strcmp(options->name, BLOCK_OPT_SIZE)) {
659: total_size = options->value.n / 512;
660: } else if (!strcmp(options->name, BLOCK_OPT_BACKING_FILE)) {
661: backing_file = options->value.s;
662: } else if (!strcmp(options->name, BLOCK_OPT_ENCRYPT)) {
663: flags |= options->value.n ? BLOCK_FLAG_ENCRYPT : 0;
664: }
665: options++;
666: }
667:
1.1.1.7 ! root 668: ret = bdrv_create_file(filename, options);
! 669: if (ret < 0) {
! 670: return ret;
! 671: }
! 672:
! 673: ret = bdrv_file_open(&qcow_bs, filename, BDRV_O_RDWR);
! 674: if (ret < 0) {
! 675: return ret;
! 676: }
! 677:
! 678: ret = bdrv_truncate(qcow_bs, 0);
! 679: if (ret < 0) {
! 680: goto exit;
! 681: }
! 682:
1.1 root 683: memset(&header, 0, sizeof(header));
684: header.magic = cpu_to_be32(QCOW_MAGIC);
685: header.version = cpu_to_be32(QCOW_VERSION);
686: header.size = cpu_to_be64(total_size * 512);
687: header_size = sizeof(header);
688: backing_filename_len = 0;
689: if (backing_file) {
690: if (strcmp(backing_file, "fat:")) {
691: header.backing_file_offset = cpu_to_be64(header_size);
692: backing_filename_len = strlen(backing_file);
693: header.backing_file_size = cpu_to_be32(backing_filename_len);
694: header_size += backing_filename_len;
695: } else {
696: /* special backing file for vvfat */
697: backing_file = NULL;
698: }
699: header.cluster_bits = 9; /* 512 byte cluster to avoid copying
700: unmodifyed sectors */
701: header.l2_bits = 12; /* 32 KB L2 tables */
702: } else {
703: header.cluster_bits = 12; /* 4 KB clusters */
704: header.l2_bits = 9; /* 4 KB L2 tables */
705: }
706: header_size = (header_size + 7) & ~7;
707: shift = header.cluster_bits + header.l2_bits;
708: l1_size = ((total_size * 512) + (1LL << shift) - 1) >> shift;
709:
710: header.l1_table_offset = cpu_to_be64(header_size);
711: if (flags & BLOCK_FLAG_ENCRYPT) {
712: header.crypt_method = cpu_to_be32(QCOW_CRYPT_AES);
713: } else {
714: header.crypt_method = cpu_to_be32(QCOW_CRYPT_NONE);
715: }
716:
717: /* write all the data */
1.1.1.7 ! root 718: ret = bdrv_pwrite(qcow_bs, 0, &header, sizeof(header));
1.1.1.3 root 719: if (ret != sizeof(header)) {
720: goto exit;
721: }
722:
1.1 root 723: if (backing_file) {
1.1.1.7 ! root 724: ret = bdrv_pwrite(qcow_bs, sizeof(header),
! 725: backing_file, backing_filename_len);
1.1.1.3 root 726: if (ret != backing_filename_len) {
727: goto exit;
728: }
1.1 root 729: }
1.1.1.7 ! root 730:
! 731: tmp = g_malloc0(BDRV_SECTOR_SIZE);
! 732: for (i = 0; i < ((sizeof(uint64_t)*l1_size + BDRV_SECTOR_SIZE - 1)/
! 733: BDRV_SECTOR_SIZE); i++) {
! 734: ret = bdrv_pwrite(qcow_bs, header_size +
! 735: BDRV_SECTOR_SIZE*i, tmp, BDRV_SECTOR_SIZE);
! 736: if (ret != BDRV_SECTOR_SIZE) {
! 737: g_free(tmp);
1.1.1.3 root 738: goto exit;
739: }
1.1 root 740: }
1.1.1.3 root 741:
1.1.1.7 ! root 742: g_free(tmp);
1.1.1.3 root 743: ret = 0;
744: exit:
1.1.1.7 ! root 745: bdrv_delete(qcow_bs);
1.1.1.3 root 746: return ret;
1.1 root 747: }
748:
749: static int qcow_make_empty(BlockDriverState *bs)
750: {
751: BDRVQcowState *s = bs->opaque;
752: uint32_t l1_length = s->l1_size * sizeof(uint64_t);
753: int ret;
754:
755: memset(s->l1_table, 0, l1_length);
1.1.1.3 root 756: if (bdrv_pwrite_sync(bs->file, s->l1_table_offset, s->l1_table,
1.1.1.2 root 757: l1_length) < 0)
758: return -1;
1.1.1.3 root 759: ret = bdrv_truncate(bs->file, s->l1_table_offset + l1_length);
1.1 root 760: if (ret < 0)
761: return ret;
762:
763: memset(s->l2_cache, 0, s->l2_size * L2_CACHE_SIZE * sizeof(uint64_t));
764: memset(s->l2_cache_offsets, 0, L2_CACHE_SIZE * sizeof(uint64_t));
765: memset(s->l2_cache_counts, 0, L2_CACHE_SIZE * sizeof(uint32_t));
766:
767: return 0;
768: }
769:
770: /* XXX: put compressed sectors first, then all the cluster aligned
771: tables to avoid losing bytes in alignment */
772: static int qcow_write_compressed(BlockDriverState *bs, int64_t sector_num,
773: const uint8_t *buf, int nb_sectors)
774: {
775: BDRVQcowState *s = bs->opaque;
776: z_stream strm;
777: int ret, out_len;
778: uint8_t *out_buf;
779: uint64_t cluster_offset;
780:
781: if (nb_sectors != s->cluster_sectors)
782: return -EINVAL;
783:
1.1.1.6 root 784: out_buf = g_malloc(s->cluster_size + (s->cluster_size / 1000) + 128);
1.1 root 785:
786: /* best compression, small window, no zlib header */
787: memset(&strm, 0, sizeof(strm));
788: ret = deflateInit2(&strm, Z_DEFAULT_COMPRESSION,
789: Z_DEFLATED, -12,
790: 9, Z_DEFAULT_STRATEGY);
791: if (ret != 0) {
1.1.1.6 root 792: ret = -EINVAL;
793: goto fail;
1.1 root 794: }
795:
796: strm.avail_in = s->cluster_size;
797: strm.next_in = (uint8_t *)buf;
798: strm.avail_out = s->cluster_size;
799: strm.next_out = out_buf;
800:
801: ret = deflate(&strm, Z_FINISH);
802: if (ret != Z_STREAM_END && ret != Z_OK) {
803: deflateEnd(&strm);
1.1.1.6 root 804: ret = -EINVAL;
805: goto fail;
1.1 root 806: }
807: out_len = strm.next_out - out_buf;
808:
809: deflateEnd(&strm);
810:
811: if (ret != Z_STREAM_END || out_len >= s->cluster_size) {
812: /* could not compress: write normal cluster */
1.1.1.6 root 813: ret = bdrv_write(bs, sector_num, buf, s->cluster_sectors);
814: if (ret < 0) {
815: goto fail;
816: }
1.1 root 817: } else {
818: cluster_offset = get_cluster_offset(bs, sector_num << 9, 2,
819: out_len, 0, 0);
1.1.1.6 root 820: if (cluster_offset == 0) {
821: ret = -EIO;
822: goto fail;
823: }
824:
1.1 root 825: cluster_offset &= s->cluster_offset_mask;
1.1.1.6 root 826: ret = bdrv_pwrite(bs->file, cluster_offset, out_buf, out_len);
827: if (ret < 0) {
828: goto fail;
1.1 root 829: }
830: }
831:
1.1.1.6 root 832: ret = 0;
833: fail:
834: g_free(out_buf);
835: return ret;
1.1.1.3 root 836: }
837:
1.1 root 838: static int qcow_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
839: {
840: BDRVQcowState *s = bs->opaque;
841: bdi->cluster_size = s->cluster_size;
842: return 0;
843: }
844:
845:
846: static QEMUOptionParameter qcow_create_options[] = {
847: {
848: .name = BLOCK_OPT_SIZE,
849: .type = OPT_SIZE,
850: .help = "Virtual disk size"
851: },
852: {
853: .name = BLOCK_OPT_BACKING_FILE,
854: .type = OPT_STRING,
855: .help = "File name of a base image"
856: },
857: {
858: .name = BLOCK_OPT_ENCRYPT,
859: .type = OPT_FLAG,
860: .help = "Encrypt the image"
861: },
862: { NULL }
863: };
864:
865: static BlockDriver bdrv_qcow = {
866: .format_name = "qcow",
867: .instance_size = sizeof(BDRVQcowState),
868: .bdrv_probe = qcow_probe,
869: .bdrv_open = qcow_open,
870: .bdrv_close = qcow_close,
871: .bdrv_create = qcow_create,
1.1.1.6 root 872:
873: .bdrv_co_readv = qcow_co_readv,
874: .bdrv_co_writev = qcow_co_writev,
1.1.1.7 ! root 875: .bdrv_co_is_allocated = qcow_co_is_allocated,
1.1.1.6 root 876:
877: .bdrv_set_key = qcow_set_key,
878: .bdrv_make_empty = qcow_make_empty,
879: .bdrv_write_compressed = qcow_write_compressed,
880: .bdrv_get_info = qcow_get_info,
1.1 root 881:
882: .create_options = qcow_create_options,
883: };
884:
885: static void bdrv_qcow_init(void)
886: {
887: bdrv_register(&bdrv_qcow);
888: }
889:
890: block_init(bdrv_qcow_init);
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.