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