1585f8587Sbellard /* 2585f8587Sbellard * Block driver for the QCOW version 2 format 3585f8587Sbellard * 4585f8587Sbellard * Copyright (c) 2004-2006 Fabrice Bellard 5585f8587Sbellard * 6585f8587Sbellard * Permission is hereby granted, free of charge, to any person obtaining a copy 7585f8587Sbellard * of this software and associated documentation files (the "Software"), to deal 8585f8587Sbellard * in the Software without restriction, including without limitation the rights 9585f8587Sbellard * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 10585f8587Sbellard * copies of the Software, and to permit persons to whom the Software is 11585f8587Sbellard * furnished to do so, subject to the following conditions: 12585f8587Sbellard * 13585f8587Sbellard * The above copyright notice and this permission notice shall be included in 14585f8587Sbellard * all copies or substantial portions of the Software. 15585f8587Sbellard * 16585f8587Sbellard * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17585f8587Sbellard * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18585f8587Sbellard * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 19585f8587Sbellard * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 20585f8587Sbellard * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 21585f8587Sbellard * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 22585f8587Sbellard * THE SOFTWARE. 23585f8587Sbellard */ 24faf07963Spbrook #include "qemu-common.h" 25585f8587Sbellard #include "block_int.h" 265efa9d5aSAnthony Liguori #include "module.h" 27585f8587Sbellard #include <zlib.h> 28585f8587Sbellard #include "aes.h" 29f7d0fe02SKevin Wolf #include "block/qcow2.h" 30585f8587Sbellard 31585f8587Sbellard /* 32585f8587Sbellard Differences with QCOW: 33585f8587Sbellard 34585f8587Sbellard - Support for multiple incremental snapshots. 35585f8587Sbellard - Memory management by reference counts. 36585f8587Sbellard - Clusters which have a reference count of one have the bit 37585f8587Sbellard QCOW_OFLAG_COPIED to optimize write performance. 38585f8587Sbellard - Size of compressed clusters is stored in sectors to reduce bit usage 39585f8587Sbellard in the cluster offsets. 40585f8587Sbellard - Support for storing additional data (such as the VM state) in the 41585f8587Sbellard snapshots. 42585f8587Sbellard - If a backing store is used, the cluster size is not constrained 43585f8587Sbellard (could be backported to QCOW). 44585f8587Sbellard - L2 tables have always a size of one cluster. 45585f8587Sbellard */ 46585f8587Sbellard 479b80ddf3Saliguori 489b80ddf3Saliguori typedef struct { 499b80ddf3Saliguori uint32_t magic; 509b80ddf3Saliguori uint32_t len; 519b80ddf3Saliguori } QCowExtension; 529b80ddf3Saliguori #define QCOW_EXT_MAGIC_END 0 53f965509cSaliguori #define QCOW_EXT_MAGIC_BACKING_FORMAT 0xE2792ACA 549b80ddf3Saliguori 55585f8587Sbellard static int qcow_probe(const uint8_t *buf, int buf_size, const char *filename) 56585f8587Sbellard { 57585f8587Sbellard const QCowHeader *cow_header = (const void *)buf; 58585f8587Sbellard 59585f8587Sbellard if (buf_size >= sizeof(QCowHeader) && 60585f8587Sbellard be32_to_cpu(cow_header->magic) == QCOW_MAGIC && 61585f8587Sbellard be32_to_cpu(cow_header->version) == QCOW_VERSION) 62585f8587Sbellard return 100; 63585f8587Sbellard else 64585f8587Sbellard return 0; 65585f8587Sbellard } 66585f8587Sbellard 679b80ddf3Saliguori 689b80ddf3Saliguori /* 699b80ddf3Saliguori * read qcow2 extension and fill bs 709b80ddf3Saliguori * start reading from start_offset 719b80ddf3Saliguori * finish reading upon magic of value 0 or when end_offset reached 729b80ddf3Saliguori * unknown magic is skipped (future extension this version knows nothing about) 739b80ddf3Saliguori * return 0 upon success, non-0 otherwise 749b80ddf3Saliguori */ 759b80ddf3Saliguori static int qcow_read_extensions(BlockDriverState *bs, uint64_t start_offset, 769b80ddf3Saliguori uint64_t end_offset) 779b80ddf3Saliguori { 789b80ddf3Saliguori QCowExtension ext; 799b80ddf3Saliguori uint64_t offset; 809b80ddf3Saliguori 819b80ddf3Saliguori #ifdef DEBUG_EXT 829b80ddf3Saliguori printf("qcow_read_extensions: start=%ld end=%ld\n", start_offset, end_offset); 839b80ddf3Saliguori #endif 849b80ddf3Saliguori offset = start_offset; 859b80ddf3Saliguori while (offset < end_offset) { 869b80ddf3Saliguori 879b80ddf3Saliguori #ifdef DEBUG_EXT 889b80ddf3Saliguori /* Sanity check */ 899b80ddf3Saliguori if (offset > s->cluster_size) 909b80ddf3Saliguori printf("qcow_handle_extension: suspicious offset %lu\n", offset); 919b80ddf3Saliguori 929b80ddf3Saliguori printf("attemting to read extended header in offset %lu\n", offset); 939b80ddf3Saliguori #endif 949b80ddf3Saliguori 9566f82ceeSKevin Wolf if (bdrv_pread(bs->file, offset, &ext, sizeof(ext)) != sizeof(ext)) { 960bfcd599SBlue Swirl fprintf(stderr, "qcow_handle_extension: ERROR: " 970bfcd599SBlue Swirl "pread fail from offset %" PRIu64 "\n", 980bfcd599SBlue Swirl offset); 999b80ddf3Saliguori return 1; 1009b80ddf3Saliguori } 1019b80ddf3Saliguori be32_to_cpus(&ext.magic); 1029b80ddf3Saliguori be32_to_cpus(&ext.len); 1039b80ddf3Saliguori offset += sizeof(ext); 1049b80ddf3Saliguori #ifdef DEBUG_EXT 1059b80ddf3Saliguori printf("ext.magic = 0x%x\n", ext.magic); 1069b80ddf3Saliguori #endif 1079b80ddf3Saliguori switch (ext.magic) { 1089b80ddf3Saliguori case QCOW_EXT_MAGIC_END: 1099b80ddf3Saliguori return 0; 110f965509cSaliguori 111f965509cSaliguori case QCOW_EXT_MAGIC_BACKING_FORMAT: 112f965509cSaliguori if (ext.len >= sizeof(bs->backing_format)) { 113f965509cSaliguori fprintf(stderr, "ERROR: ext_backing_format: len=%u too large" 1144c978075Saliguori " (>=%zu)\n", 115f965509cSaliguori ext.len, sizeof(bs->backing_format)); 116f965509cSaliguori return 2; 117f965509cSaliguori } 11866f82ceeSKevin Wolf if (bdrv_pread(bs->file, offset , bs->backing_format, 119f965509cSaliguori ext.len) != ext.len) 120f965509cSaliguori return 3; 121f965509cSaliguori bs->backing_format[ext.len] = '\0'; 122f965509cSaliguori #ifdef DEBUG_EXT 123f965509cSaliguori printf("Qcow2: Got format extension %s\n", bs->backing_format); 124f965509cSaliguori #endif 125e1c7f0e3SKevin Wolf offset = ((offset + ext.len + 7) & ~7); 126f965509cSaliguori break; 127f965509cSaliguori 1289b80ddf3Saliguori default: 1299b80ddf3Saliguori /* unknown magic -- just skip it */ 130e1c7f0e3SKevin Wolf offset = ((offset + ext.len + 7) & ~7); 1319b80ddf3Saliguori break; 1329b80ddf3Saliguori } 1339b80ddf3Saliguori } 1349b80ddf3Saliguori 1359b80ddf3Saliguori return 0; 1369b80ddf3Saliguori } 1379b80ddf3Saliguori 1389b80ddf3Saliguori 13966f82ceeSKevin Wolf static int qcow_open(BlockDriverState *bs, int flags) 140585f8587Sbellard { 141585f8587Sbellard BDRVQcowState *s = bs->opaque; 142419b19d9SStefan Hajnoczi int len, i; 143585f8587Sbellard QCowHeader header; 1449b80ddf3Saliguori uint64_t ext_end; 145585f8587Sbellard 14666f82ceeSKevin Wolf if (bdrv_pread(bs->file, 0, &header, sizeof(header)) != sizeof(header)) 147585f8587Sbellard goto fail; 148585f8587Sbellard be32_to_cpus(&header.magic); 149585f8587Sbellard be32_to_cpus(&header.version); 150585f8587Sbellard be64_to_cpus(&header.backing_file_offset); 151585f8587Sbellard be32_to_cpus(&header.backing_file_size); 152585f8587Sbellard be64_to_cpus(&header.size); 153585f8587Sbellard be32_to_cpus(&header.cluster_bits); 154585f8587Sbellard be32_to_cpus(&header.crypt_method); 155585f8587Sbellard be64_to_cpus(&header.l1_table_offset); 156585f8587Sbellard be32_to_cpus(&header.l1_size); 157585f8587Sbellard be64_to_cpus(&header.refcount_table_offset); 158585f8587Sbellard be32_to_cpus(&header.refcount_table_clusters); 159585f8587Sbellard be64_to_cpus(&header.snapshots_offset); 160585f8587Sbellard be32_to_cpus(&header.nb_snapshots); 161585f8587Sbellard 162585f8587Sbellard if (header.magic != QCOW_MAGIC || header.version != QCOW_VERSION) 163585f8587Sbellard goto fail; 164d191d12dSStefan Weil if (header.cluster_bits < MIN_CLUSTER_BITS || 16573c632edSKevin Wolf header.cluster_bits > MAX_CLUSTER_BITS) 166585f8587Sbellard goto fail; 167585f8587Sbellard if (header.crypt_method > QCOW_CRYPT_AES) 168585f8587Sbellard goto fail; 169585f8587Sbellard s->crypt_method_header = header.crypt_method; 170585f8587Sbellard if (s->crypt_method_header) 171585f8587Sbellard bs->encrypted = 1; 172585f8587Sbellard s->cluster_bits = header.cluster_bits; 173585f8587Sbellard s->cluster_size = 1 << s->cluster_bits; 174585f8587Sbellard s->cluster_sectors = 1 << (s->cluster_bits - 9); 175585f8587Sbellard s->l2_bits = s->cluster_bits - 3; /* L2 is always one cluster */ 176585f8587Sbellard s->l2_size = 1 << s->l2_bits; 177585f8587Sbellard bs->total_sectors = header.size / 512; 178585f8587Sbellard s->csize_shift = (62 - (s->cluster_bits - 8)); 179585f8587Sbellard s->csize_mask = (1 << (s->cluster_bits - 8)) - 1; 180585f8587Sbellard s->cluster_offset_mask = (1LL << s->csize_shift) - 1; 181585f8587Sbellard s->refcount_table_offset = header.refcount_table_offset; 182585f8587Sbellard s->refcount_table_size = 183585f8587Sbellard header.refcount_table_clusters << (s->cluster_bits - 3); 184585f8587Sbellard 185585f8587Sbellard s->snapshots_offset = header.snapshots_offset; 186585f8587Sbellard s->nb_snapshots = header.nb_snapshots; 187585f8587Sbellard 188585f8587Sbellard /* read the level 1 table */ 189585f8587Sbellard s->l1_size = header.l1_size; 190419b19d9SStefan Hajnoczi s->l1_vm_state_index = size_to_l1(s, header.size); 191585f8587Sbellard /* the L1 table must contain at least enough entries to put 192585f8587Sbellard header.size bytes */ 193585f8587Sbellard if (s->l1_size < s->l1_vm_state_index) 194585f8587Sbellard goto fail; 195585f8587Sbellard s->l1_table_offset = header.l1_table_offset; 196d191d12dSStefan Weil if (s->l1_size > 0) { 1973f6a3ee5SKevin Wolf s->l1_table = qemu_mallocz( 1983f6a3ee5SKevin Wolf align_offset(s->l1_size * sizeof(uint64_t), 512)); 19966f82ceeSKevin Wolf if (bdrv_pread(bs->file, s->l1_table_offset, s->l1_table, s->l1_size * sizeof(uint64_t)) != 200585f8587Sbellard s->l1_size * sizeof(uint64_t)) 201585f8587Sbellard goto fail; 202585f8587Sbellard for(i = 0;i < s->l1_size; i++) { 203585f8587Sbellard be64_to_cpus(&s->l1_table[i]); 204585f8587Sbellard } 205d191d12dSStefan Weil } 206585f8587Sbellard /* alloc L2 cache */ 207585f8587Sbellard s->l2_cache = qemu_malloc(s->l2_size * L2_CACHE_SIZE * sizeof(uint64_t)); 208585f8587Sbellard s->cluster_cache = qemu_malloc(s->cluster_size); 209585f8587Sbellard /* one more sector for decompressed data alignment */ 210095a9c58Saliguori s->cluster_data = qemu_malloc(QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size 211095a9c58Saliguori + 512); 212585f8587Sbellard s->cluster_cache_offset = -1; 213585f8587Sbellard 214ed6ccf0fSKevin Wolf if (qcow2_refcount_init(bs) < 0) 215585f8587Sbellard goto fail; 216585f8587Sbellard 21772cf2d4fSBlue Swirl QLIST_INIT(&s->cluster_allocs); 218f214978aSKevin Wolf 2199b80ddf3Saliguori /* read qcow2 extensions */ 2209b80ddf3Saliguori if (header.backing_file_offset) 2219b80ddf3Saliguori ext_end = header.backing_file_offset; 2229b80ddf3Saliguori else 2239b80ddf3Saliguori ext_end = s->cluster_size; 2249b80ddf3Saliguori if (qcow_read_extensions(bs, sizeof(header), ext_end)) 2259b80ddf3Saliguori goto fail; 2269b80ddf3Saliguori 227585f8587Sbellard /* read the backing file name */ 228585f8587Sbellard if (header.backing_file_offset != 0) { 229585f8587Sbellard len = header.backing_file_size; 230585f8587Sbellard if (len > 1023) 231585f8587Sbellard len = 1023; 23266f82ceeSKevin Wolf if (bdrv_pread(bs->file, header.backing_file_offset, bs->backing_file, len) != len) 233585f8587Sbellard goto fail; 234585f8587Sbellard bs->backing_file[len] = '\0'; 235585f8587Sbellard } 236ed6ccf0fSKevin Wolf if (qcow2_read_snapshots(bs) < 0) 237585f8587Sbellard goto fail; 238585f8587Sbellard 239585f8587Sbellard #ifdef DEBUG_ALLOC 24014899cdfSFilip Navara qcow2_check_refcounts(bs); 241585f8587Sbellard #endif 242585f8587Sbellard return 0; 243585f8587Sbellard 244585f8587Sbellard fail: 245ed6ccf0fSKevin Wolf qcow2_free_snapshots(bs); 246ed6ccf0fSKevin Wolf qcow2_refcount_close(bs); 247585f8587Sbellard qemu_free(s->l1_table); 248585f8587Sbellard qemu_free(s->l2_cache); 249585f8587Sbellard qemu_free(s->cluster_cache); 250585f8587Sbellard qemu_free(s->cluster_data); 251585f8587Sbellard return -1; 252585f8587Sbellard } 253585f8587Sbellard 254585f8587Sbellard static int qcow_set_key(BlockDriverState *bs, const char *key) 255585f8587Sbellard { 256585f8587Sbellard BDRVQcowState *s = bs->opaque; 257585f8587Sbellard uint8_t keybuf[16]; 258585f8587Sbellard int len, i; 259585f8587Sbellard 260585f8587Sbellard memset(keybuf, 0, 16); 261585f8587Sbellard len = strlen(key); 262585f8587Sbellard if (len > 16) 263585f8587Sbellard len = 16; 264585f8587Sbellard /* XXX: we could compress the chars to 7 bits to increase 265585f8587Sbellard entropy */ 266585f8587Sbellard for(i = 0;i < len;i++) { 267585f8587Sbellard keybuf[i] = key[i]; 268585f8587Sbellard } 269585f8587Sbellard s->crypt_method = s->crypt_method_header; 270585f8587Sbellard 271585f8587Sbellard if (AES_set_encrypt_key(keybuf, 128, &s->aes_encrypt_key) != 0) 272585f8587Sbellard return -1; 273585f8587Sbellard if (AES_set_decrypt_key(keybuf, 128, &s->aes_decrypt_key) != 0) 274585f8587Sbellard return -1; 275585f8587Sbellard #if 0 276585f8587Sbellard /* test */ 277585f8587Sbellard { 278585f8587Sbellard uint8_t in[16]; 279585f8587Sbellard uint8_t out[16]; 280585f8587Sbellard uint8_t tmp[16]; 281585f8587Sbellard for(i=0;i<16;i++) 282585f8587Sbellard in[i] = i; 283585f8587Sbellard AES_encrypt(in, tmp, &s->aes_encrypt_key); 284585f8587Sbellard AES_decrypt(tmp, out, &s->aes_decrypt_key); 285585f8587Sbellard for(i = 0; i < 16; i++) 286585f8587Sbellard printf(" %02x", tmp[i]); 287585f8587Sbellard printf("\n"); 288585f8587Sbellard for(i = 0; i < 16; i++) 289585f8587Sbellard printf(" %02x", out[i]); 290585f8587Sbellard printf("\n"); 291585f8587Sbellard } 292585f8587Sbellard #endif 293585f8587Sbellard return 0; 294585f8587Sbellard } 295585f8587Sbellard 296585f8587Sbellard static int qcow_is_allocated(BlockDriverState *bs, int64_t sector_num, 297585f8587Sbellard int nb_sectors, int *pnum) 298585f8587Sbellard { 299585f8587Sbellard uint64_t cluster_offset; 300*1c46efaaSKevin Wolf int ret; 301585f8587Sbellard 302095a9c58Saliguori *pnum = nb_sectors; 303*1c46efaaSKevin Wolf /* FIXME We can get errors here, but the bdrv_is_allocated interface can't 304*1c46efaaSKevin Wolf * pass them on today */ 305*1c46efaaSKevin Wolf ret = qcow2_get_cluster_offset(bs, sector_num << 9, pnum, &cluster_offset); 306*1c46efaaSKevin Wolf if (ret < 0) { 307*1c46efaaSKevin Wolf *pnum = 0; 308*1c46efaaSKevin Wolf } 309095a9c58Saliguori 310585f8587Sbellard return (cluster_offset != 0); 311585f8587Sbellard } 312585f8587Sbellard 313a9465922Sbellard /* handle reading after the end of the backing file */ 314ed6ccf0fSKevin Wolf int qcow2_backing_read1(BlockDriverState *bs, 315a9465922Sbellard int64_t sector_num, uint8_t *buf, int nb_sectors) 316a9465922Sbellard { 317a9465922Sbellard int n1; 318a9465922Sbellard if ((sector_num + nb_sectors) <= bs->total_sectors) 319a9465922Sbellard return nb_sectors; 320a9465922Sbellard if (sector_num >= bs->total_sectors) 321a9465922Sbellard n1 = 0; 322a9465922Sbellard else 323a9465922Sbellard n1 = bs->total_sectors - sector_num; 324a9465922Sbellard memset(buf + n1 * 512, 0, 512 * (nb_sectors - n1)); 325a9465922Sbellard return n1; 326a9465922Sbellard } 327a9465922Sbellard 328ce1a14dcSpbrook typedef struct QCowAIOCB { 329ce1a14dcSpbrook BlockDriverAIOCB common; 330585f8587Sbellard int64_t sector_num; 331f141eafeSaliguori QEMUIOVector *qiov; 332585f8587Sbellard uint8_t *buf; 333f141eafeSaliguori void *orig_buf; 3347b88e48bSChristoph Hellwig int remaining_sectors; 3357b88e48bSChristoph Hellwig int cur_nr_sectors; /* number of sectors in current iteration */ 336585f8587Sbellard uint64_t cluster_offset; 337585f8587Sbellard uint8_t *cluster_data; 338585f8587Sbellard BlockDriverAIOCB *hd_aiocb; 339c87c0672Saliguori struct iovec hd_iov; 340c87c0672Saliguori QEMUIOVector hd_qiov; 3411490791fSaliguori QEMUBH *bh; 342e976c6a1Saliguori QCowL2Meta l2meta; 34372cf2d4fSBlue Swirl QLIST_ENTRY(QCowAIOCB) next_depend; 344585f8587Sbellard } QCowAIOCB; 345585f8587Sbellard 346c16b5a2cSChristoph Hellwig static void qcow_aio_cancel(BlockDriverAIOCB *blockacb) 347c16b5a2cSChristoph Hellwig { 348b666d239SKevin Wolf QCowAIOCB *acb = container_of(blockacb, QCowAIOCB, common); 349c16b5a2cSChristoph Hellwig if (acb->hd_aiocb) 350c16b5a2cSChristoph Hellwig bdrv_aio_cancel(acb->hd_aiocb); 351c16b5a2cSChristoph Hellwig qemu_aio_release(acb); 352c16b5a2cSChristoph Hellwig } 353c16b5a2cSChristoph Hellwig 354c16b5a2cSChristoph Hellwig static AIOPool qcow_aio_pool = { 355c16b5a2cSChristoph Hellwig .aiocb_size = sizeof(QCowAIOCB), 356c16b5a2cSChristoph Hellwig .cancel = qcow_aio_cancel, 357c16b5a2cSChristoph Hellwig }; 358c16b5a2cSChristoph Hellwig 3591490791fSaliguori static void qcow_aio_read_cb(void *opaque, int ret); 3601490791fSaliguori static void qcow_aio_read_bh(void *opaque) 3611490791fSaliguori { 3621490791fSaliguori QCowAIOCB *acb = opaque; 3631490791fSaliguori qemu_bh_delete(acb->bh); 3641490791fSaliguori acb->bh = NULL; 3651490791fSaliguori qcow_aio_read_cb(opaque, 0); 3661490791fSaliguori } 3671490791fSaliguori 368a32ef786Saliguori static int qcow_schedule_bh(QEMUBHFunc *cb, QCowAIOCB *acb) 369a32ef786Saliguori { 370a32ef786Saliguori if (acb->bh) 371a32ef786Saliguori return -EIO; 372a32ef786Saliguori 373a32ef786Saliguori acb->bh = qemu_bh_new(cb, acb); 374a32ef786Saliguori if (!acb->bh) 375a32ef786Saliguori return -EIO; 376a32ef786Saliguori 377a32ef786Saliguori qemu_bh_schedule(acb->bh); 378a32ef786Saliguori 379a32ef786Saliguori return 0; 380a32ef786Saliguori } 381a32ef786Saliguori 382585f8587Sbellard static void qcow_aio_read_cb(void *opaque, int ret) 383585f8587Sbellard { 384ce1a14dcSpbrook QCowAIOCB *acb = opaque; 385ce1a14dcSpbrook BlockDriverState *bs = acb->common.bs; 386585f8587Sbellard BDRVQcowState *s = bs->opaque; 387a9465922Sbellard int index_in_cluster, n1; 388585f8587Sbellard 389ce1a14dcSpbrook acb->hd_aiocb = NULL; 390f141eafeSaliguori if (ret < 0) 391f141eafeSaliguori goto done; 392585f8587Sbellard 393585f8587Sbellard /* post process the read buffer */ 394ce1a14dcSpbrook if (!acb->cluster_offset) { 395585f8587Sbellard /* nothing to do */ 396ce1a14dcSpbrook } else if (acb->cluster_offset & QCOW_OFLAG_COMPRESSED) { 397585f8587Sbellard /* nothing to do */ 398585f8587Sbellard } else { 399585f8587Sbellard if (s->crypt_method) { 400ed6ccf0fSKevin Wolf qcow2_encrypt_sectors(s, acb->sector_num, acb->buf, acb->buf, 4017b88e48bSChristoph Hellwig acb->cur_nr_sectors, 0, 402585f8587Sbellard &s->aes_decrypt_key); 403585f8587Sbellard } 404585f8587Sbellard } 405585f8587Sbellard 4067b88e48bSChristoph Hellwig acb->remaining_sectors -= acb->cur_nr_sectors; 4077b88e48bSChristoph Hellwig acb->sector_num += acb->cur_nr_sectors; 4087b88e48bSChristoph Hellwig acb->buf += acb->cur_nr_sectors * 512; 409585f8587Sbellard 4107b88e48bSChristoph Hellwig if (acb->remaining_sectors == 0) { 411585f8587Sbellard /* request completed */ 412f141eafeSaliguori ret = 0; 413f141eafeSaliguori goto done; 414585f8587Sbellard } 415585f8587Sbellard 416585f8587Sbellard /* prepare next AIO request */ 4177b88e48bSChristoph Hellwig acb->cur_nr_sectors = acb->remaining_sectors; 418*1c46efaaSKevin Wolf ret = qcow2_get_cluster_offset(bs, acb->sector_num << 9, 419*1c46efaaSKevin Wolf &acb->cur_nr_sectors, &acb->cluster_offset); 420*1c46efaaSKevin Wolf if (ret < 0) { 421*1c46efaaSKevin Wolf goto done; 422*1c46efaaSKevin Wolf } 423*1c46efaaSKevin Wolf 424095a9c58Saliguori index_in_cluster = acb->sector_num & (s->cluster_sectors - 1); 425585f8587Sbellard 426ce1a14dcSpbrook if (!acb->cluster_offset) { 427585f8587Sbellard if (bs->backing_hd) { 428585f8587Sbellard /* read from the base image */ 429ed6ccf0fSKevin Wolf n1 = qcow2_backing_read1(bs->backing_hd, acb->sector_num, 4307b88e48bSChristoph Hellwig acb->buf, acb->cur_nr_sectors); 431a9465922Sbellard if (n1 > 0) { 4323f4cb3d3Sblueswir1 acb->hd_iov.iov_base = (void *)acb->buf; 4337b88e48bSChristoph Hellwig acb->hd_iov.iov_len = acb->cur_nr_sectors * 512; 434c87c0672Saliguori qemu_iovec_init_external(&acb->hd_qiov, &acb->hd_iov, 1); 43566f82ceeSKevin Wolf BLKDBG_EVENT(bs->file, BLKDBG_READ_BACKING_AIO); 436c87c0672Saliguori acb->hd_aiocb = bdrv_aio_readv(bs->backing_hd, acb->sector_num, 4377b88e48bSChristoph Hellwig &acb->hd_qiov, acb->cur_nr_sectors, 438c87c0672Saliguori qcow_aio_read_cb, acb); 439ce1a14dcSpbrook if (acb->hd_aiocb == NULL) 440f141eafeSaliguori goto done; 441585f8587Sbellard } else { 442a32ef786Saliguori ret = qcow_schedule_bh(qcow_aio_read_bh, acb); 443a32ef786Saliguori if (ret < 0) 444f141eafeSaliguori goto done; 4451490791fSaliguori } 446a9465922Sbellard } else { 447585f8587Sbellard /* Note: in this case, no need to wait */ 4487b88e48bSChristoph Hellwig memset(acb->buf, 0, 512 * acb->cur_nr_sectors); 449a32ef786Saliguori ret = qcow_schedule_bh(qcow_aio_read_bh, acb); 450a32ef786Saliguori if (ret < 0) 451f141eafeSaliguori goto done; 4521490791fSaliguori } 453ce1a14dcSpbrook } else if (acb->cluster_offset & QCOW_OFLAG_COMPRESSED) { 454585f8587Sbellard /* add AIO support for compressed blocks ? */ 45566f82ceeSKevin Wolf if (qcow2_decompress_cluster(bs, acb->cluster_offset) < 0) 456f141eafeSaliguori goto done; 4577b88e48bSChristoph Hellwig memcpy(acb->buf, s->cluster_cache + index_in_cluster * 512, 4587b88e48bSChristoph Hellwig 512 * acb->cur_nr_sectors); 459a32ef786Saliguori ret = qcow_schedule_bh(qcow_aio_read_bh, acb); 460a32ef786Saliguori if (ret < 0) 461f141eafeSaliguori goto done; 462585f8587Sbellard } else { 463ce1a14dcSpbrook if ((acb->cluster_offset & 511) != 0) { 464585f8587Sbellard ret = -EIO; 465f141eafeSaliguori goto done; 466585f8587Sbellard } 467c87c0672Saliguori 4683f4cb3d3Sblueswir1 acb->hd_iov.iov_base = (void *)acb->buf; 4697b88e48bSChristoph Hellwig acb->hd_iov.iov_len = acb->cur_nr_sectors * 512; 470c87c0672Saliguori qemu_iovec_init_external(&acb->hd_qiov, &acb->hd_iov, 1); 47166f82ceeSKevin Wolf BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO); 47266f82ceeSKevin Wolf acb->hd_aiocb = bdrv_aio_readv(bs->file, 473ce1a14dcSpbrook (acb->cluster_offset >> 9) + index_in_cluster, 4747b88e48bSChristoph Hellwig &acb->hd_qiov, acb->cur_nr_sectors, 4757b88e48bSChristoph Hellwig qcow_aio_read_cb, acb); 476171e3d6bSKevin Wolf if (acb->hd_aiocb == NULL) { 477171e3d6bSKevin Wolf ret = -EIO; 478f141eafeSaliguori goto done; 479585f8587Sbellard } 480171e3d6bSKevin Wolf } 481f141eafeSaliguori 482f141eafeSaliguori return; 483f141eafeSaliguori done: 484f141eafeSaliguori if (acb->qiov->niov > 1) { 485f141eafeSaliguori qemu_iovec_from_buffer(acb->qiov, acb->orig_buf, acb->qiov->size); 486f141eafeSaliguori qemu_vfree(acb->orig_buf); 487f141eafeSaliguori } 488f141eafeSaliguori acb->common.cb(acb->common.opaque, ret); 489f141eafeSaliguori qemu_aio_release(acb); 490585f8587Sbellard } 491585f8587Sbellard 492ce1a14dcSpbrook static QCowAIOCB *qcow_aio_setup(BlockDriverState *bs, 493f141eafeSaliguori int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, 494f141eafeSaliguori BlockDriverCompletionFunc *cb, void *opaque, int is_write) 495585f8587Sbellard { 496ce1a14dcSpbrook QCowAIOCB *acb; 497585f8587Sbellard 498c16b5a2cSChristoph Hellwig acb = qemu_aio_get(&qcow_aio_pool, bs, cb, opaque); 499ce1a14dcSpbrook if (!acb) 500ce1a14dcSpbrook return NULL; 501ce1a14dcSpbrook acb->hd_aiocb = NULL; 502ce1a14dcSpbrook acb->sector_num = sector_num; 503f141eafeSaliguori acb->qiov = qiov; 504f141eafeSaliguori if (qiov->niov > 1) { 505e268ca52Saliguori acb->buf = acb->orig_buf = qemu_blockalign(bs, qiov->size); 506f141eafeSaliguori if (is_write) 507f141eafeSaliguori qemu_iovec_to_buffer(qiov, acb->buf); 5083f4cb3d3Sblueswir1 } else { 5093f4cb3d3Sblueswir1 acb->buf = (uint8_t *)qiov->iov->iov_base; 5103f4cb3d3Sblueswir1 } 5117b88e48bSChristoph Hellwig acb->remaining_sectors = nb_sectors; 5127b88e48bSChristoph Hellwig acb->cur_nr_sectors = 0; 513ce1a14dcSpbrook acb->cluster_offset = 0; 514e976c6a1Saliguori acb->l2meta.nb_clusters = 0; 51572cf2d4fSBlue Swirl QLIST_INIT(&acb->l2meta.dependent_requests); 516ce1a14dcSpbrook return acb; 517ce1a14dcSpbrook } 518ce1a14dcSpbrook 519f141eafeSaliguori static BlockDriverAIOCB *qcow_aio_readv(BlockDriverState *bs, 520f141eafeSaliguori int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, 521ce1a14dcSpbrook BlockDriverCompletionFunc *cb, void *opaque) 522ce1a14dcSpbrook { 523ce1a14dcSpbrook QCowAIOCB *acb; 524ce1a14dcSpbrook 525f141eafeSaliguori acb = qcow_aio_setup(bs, sector_num, qiov, nb_sectors, cb, opaque, 0); 526ce1a14dcSpbrook if (!acb) 527ce1a14dcSpbrook return NULL; 528585f8587Sbellard 529585f8587Sbellard qcow_aio_read_cb(acb, 0); 530ce1a14dcSpbrook return &acb->common; 531585f8587Sbellard } 532585f8587Sbellard 533f214978aSKevin Wolf static void qcow_aio_write_cb(void *opaque, int ret); 534f214978aSKevin Wolf 535f214978aSKevin Wolf static void run_dependent_requests(QCowL2Meta *m) 536f214978aSKevin Wolf { 537f214978aSKevin Wolf QCowAIOCB *req; 538f214978aSKevin Wolf QCowAIOCB *next; 539f214978aSKevin Wolf 540f214978aSKevin Wolf /* Take the request off the list of running requests */ 541f214978aSKevin Wolf if (m->nb_clusters != 0) { 54272cf2d4fSBlue Swirl QLIST_REMOVE(m, next_in_flight); 543f214978aSKevin Wolf } 544f214978aSKevin Wolf 545d4c146f0SStefan Hajnoczi /* Restart all dependent requests */ 546d4c146f0SStefan Hajnoczi QLIST_FOREACH_SAFE(req, &m->dependent_requests, next_depend, next) { 547f214978aSKevin Wolf qcow_aio_write_cb(req, 0); 548f214978aSKevin Wolf } 549f214978aSKevin Wolf 550f214978aSKevin Wolf /* Empty the list for the next part of the request */ 55172cf2d4fSBlue Swirl QLIST_INIT(&m->dependent_requests); 552f214978aSKevin Wolf } 553f214978aSKevin Wolf 554585f8587Sbellard static void qcow_aio_write_cb(void *opaque, int ret) 555585f8587Sbellard { 556ce1a14dcSpbrook QCowAIOCB *acb = opaque; 557ce1a14dcSpbrook BlockDriverState *bs = acb->common.bs; 558585f8587Sbellard BDRVQcowState *s = bs->opaque; 559585f8587Sbellard int index_in_cluster; 560585f8587Sbellard const uint8_t *src_buf; 561095a9c58Saliguori int n_end; 562585f8587Sbellard 563ce1a14dcSpbrook acb->hd_aiocb = NULL; 564ce1a14dcSpbrook 565f214978aSKevin Wolf if (ret >= 0) { 566148da7eaSKevin Wolf ret = qcow2_alloc_cluster_link_l2(bs, &acb->l2meta); 567f214978aSKevin Wolf } 568f214978aSKevin Wolf 569f214978aSKevin Wolf run_dependent_requests(&acb->l2meta); 570f214978aSKevin Wolf 571f141eafeSaliguori if (ret < 0) 572f141eafeSaliguori goto done; 573585f8587Sbellard 5747b88e48bSChristoph Hellwig acb->remaining_sectors -= acb->cur_nr_sectors; 5757b88e48bSChristoph Hellwig acb->sector_num += acb->cur_nr_sectors; 5767b88e48bSChristoph Hellwig acb->buf += acb->cur_nr_sectors * 512; 577585f8587Sbellard 5787b88e48bSChristoph Hellwig if (acb->remaining_sectors == 0) { 579585f8587Sbellard /* request completed */ 580f141eafeSaliguori ret = 0; 581f141eafeSaliguori goto done; 582585f8587Sbellard } 583585f8587Sbellard 584ce1a14dcSpbrook index_in_cluster = acb->sector_num & (s->cluster_sectors - 1); 5857b88e48bSChristoph Hellwig n_end = index_in_cluster + acb->remaining_sectors; 586095a9c58Saliguori if (s->crypt_method && 587095a9c58Saliguori n_end > QCOW_MAX_CRYPT_CLUSTERS * s->cluster_sectors) 588095a9c58Saliguori n_end = QCOW_MAX_CRYPT_CLUSTERS * s->cluster_sectors; 589095a9c58Saliguori 590148da7eaSKevin Wolf ret = qcow2_alloc_cluster_offset(bs, acb->sector_num << 9, 5917b88e48bSChristoph Hellwig index_in_cluster, n_end, &acb->cur_nr_sectors, &acb->l2meta); 592148da7eaSKevin Wolf if (ret < 0) { 593148da7eaSKevin Wolf goto done; 594148da7eaSKevin Wolf } 595148da7eaSKevin Wolf 596148da7eaSKevin Wolf acb->cluster_offset = acb->l2meta.cluster_offset; 597f214978aSKevin Wolf 598f214978aSKevin Wolf /* Need to wait for another request? If so, we are done for now. */ 599148da7eaSKevin Wolf if (acb->l2meta.nb_clusters == 0 && acb->l2meta.depends_on != NULL) { 60072cf2d4fSBlue Swirl QLIST_INSERT_HEAD(&acb->l2meta.depends_on->dependent_requests, 601f214978aSKevin Wolf acb, next_depend); 602f214978aSKevin Wolf return; 603f214978aSKevin Wolf } 604f214978aSKevin Wolf 605148da7eaSKevin Wolf assert((acb->cluster_offset & 511) == 0); 606148da7eaSKevin Wolf 607585f8587Sbellard if (s->crypt_method) { 608ce1a14dcSpbrook if (!acb->cluster_data) { 609095a9c58Saliguori acb->cluster_data = qemu_mallocz(QCOW_MAX_CRYPT_CLUSTERS * 610095a9c58Saliguori s->cluster_size); 611585f8587Sbellard } 612ed6ccf0fSKevin Wolf qcow2_encrypt_sectors(s, acb->sector_num, acb->cluster_data, acb->buf, 6137b88e48bSChristoph Hellwig acb->cur_nr_sectors, 1, &s->aes_encrypt_key); 614ce1a14dcSpbrook src_buf = acb->cluster_data; 615585f8587Sbellard } else { 616ce1a14dcSpbrook src_buf = acb->buf; 617585f8587Sbellard } 618c87c0672Saliguori acb->hd_iov.iov_base = (void *)src_buf; 6197b88e48bSChristoph Hellwig acb->hd_iov.iov_len = acb->cur_nr_sectors * 512; 620c87c0672Saliguori qemu_iovec_init_external(&acb->hd_qiov, &acb->hd_iov, 1); 62166f82ceeSKevin Wolf BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO); 62266f82ceeSKevin Wolf acb->hd_aiocb = bdrv_aio_writev(bs->file, 623e976c6a1Saliguori (acb->cluster_offset >> 9) + index_in_cluster, 6247b88e48bSChristoph Hellwig &acb->hd_qiov, acb->cur_nr_sectors, 625585f8587Sbellard qcow_aio_write_cb, acb); 626171e3d6bSKevin Wolf if (acb->hd_aiocb == NULL) { 627171e3d6bSKevin Wolf ret = -EIO; 628c644db3dSKevin Wolf goto fail; 629171e3d6bSKevin Wolf } 630f141eafeSaliguori 631f141eafeSaliguori return; 632f141eafeSaliguori 633c644db3dSKevin Wolf fail: 634c644db3dSKevin Wolf if (acb->l2meta.nb_clusters != 0) { 635c644db3dSKevin Wolf QLIST_REMOVE(&acb->l2meta, next_in_flight); 636c644db3dSKevin Wolf } 637f141eafeSaliguori done: 638f141eafeSaliguori if (acb->qiov->niov > 1) 639f141eafeSaliguori qemu_vfree(acb->orig_buf); 640f141eafeSaliguori acb->common.cb(acb->common.opaque, ret); 641f141eafeSaliguori qemu_aio_release(acb); 642585f8587Sbellard } 643585f8587Sbellard 644f141eafeSaliguori static BlockDriverAIOCB *qcow_aio_writev(BlockDriverState *bs, 645f141eafeSaliguori int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, 646ce1a14dcSpbrook BlockDriverCompletionFunc *cb, void *opaque) 647585f8587Sbellard { 648585f8587Sbellard BDRVQcowState *s = bs->opaque; 649ce1a14dcSpbrook QCowAIOCB *acb; 650585f8587Sbellard 651585f8587Sbellard s->cluster_cache_offset = -1; /* disable compressed cache */ 652585f8587Sbellard 653f141eafeSaliguori acb = qcow_aio_setup(bs, sector_num, qiov, nb_sectors, cb, opaque, 1); 654ce1a14dcSpbrook if (!acb) 655ce1a14dcSpbrook return NULL; 656585f8587Sbellard 657585f8587Sbellard qcow_aio_write_cb(acb, 0); 658ce1a14dcSpbrook return &acb->common; 659585f8587Sbellard } 660585f8587Sbellard 661585f8587Sbellard static void qcow_close(BlockDriverState *bs) 662585f8587Sbellard { 663585f8587Sbellard BDRVQcowState *s = bs->opaque; 664585f8587Sbellard qemu_free(s->l1_table); 665585f8587Sbellard qemu_free(s->l2_cache); 666585f8587Sbellard qemu_free(s->cluster_cache); 667585f8587Sbellard qemu_free(s->cluster_data); 668ed6ccf0fSKevin Wolf qcow2_refcount_close(bs); 669585f8587Sbellard } 670585f8587Sbellard 671756e6736SKevin Wolf /* 672756e6736SKevin Wolf * Updates the variable length parts of the qcow2 header, i.e. the backing file 673756e6736SKevin Wolf * name and all extensions. qcow2 was not designed to allow such changes, so if 674756e6736SKevin Wolf * we run out of space (we can only use the first cluster) this function may 675756e6736SKevin Wolf * fail. 676756e6736SKevin Wolf * 677756e6736SKevin Wolf * Returns 0 on success, -errno in error cases. 678756e6736SKevin Wolf */ 679756e6736SKevin Wolf static int qcow2_update_ext_header(BlockDriverState *bs, 680756e6736SKevin Wolf const char *backing_file, const char *backing_fmt) 681756e6736SKevin Wolf { 682756e6736SKevin Wolf size_t backing_file_len = 0; 683756e6736SKevin Wolf size_t backing_fmt_len = 0; 684756e6736SKevin Wolf BDRVQcowState *s = bs->opaque; 685756e6736SKevin Wolf QCowExtension ext_backing_fmt = {0, 0}; 686756e6736SKevin Wolf int ret; 687756e6736SKevin Wolf 688756e6736SKevin Wolf /* Backing file format doesn't make sense without a backing file */ 689756e6736SKevin Wolf if (backing_fmt && !backing_file) { 690756e6736SKevin Wolf return -EINVAL; 691756e6736SKevin Wolf } 692756e6736SKevin Wolf 693756e6736SKevin Wolf /* Prepare the backing file format extension if needed */ 694756e6736SKevin Wolf if (backing_fmt) { 695756e6736SKevin Wolf ext_backing_fmt.len = cpu_to_be32(strlen(backing_fmt)); 696756e6736SKevin Wolf ext_backing_fmt.magic = cpu_to_be32(QCOW_EXT_MAGIC_BACKING_FORMAT); 697756e6736SKevin Wolf backing_fmt_len = ((sizeof(ext_backing_fmt) 698756e6736SKevin Wolf + strlen(backing_fmt) + 7) & ~7); 699756e6736SKevin Wolf } 700756e6736SKevin Wolf 701756e6736SKevin Wolf /* Check if we can fit the new header into the first cluster */ 702756e6736SKevin Wolf if (backing_file) { 703756e6736SKevin Wolf backing_file_len = strlen(backing_file); 704756e6736SKevin Wolf } 705756e6736SKevin Wolf 706756e6736SKevin Wolf size_t header_size = sizeof(QCowHeader) + backing_file_len 707756e6736SKevin Wolf + backing_fmt_len; 708756e6736SKevin Wolf 709756e6736SKevin Wolf if (header_size > s->cluster_size) { 710756e6736SKevin Wolf return -ENOSPC; 711756e6736SKevin Wolf } 712756e6736SKevin Wolf 713756e6736SKevin Wolf /* Rewrite backing file name and qcow2 extensions */ 714756e6736SKevin Wolf size_t ext_size = header_size - sizeof(QCowHeader); 715756e6736SKevin Wolf uint8_t buf[ext_size]; 716756e6736SKevin Wolf size_t offset = 0; 717756e6736SKevin Wolf size_t backing_file_offset = 0; 718756e6736SKevin Wolf 719756e6736SKevin Wolf if (backing_file) { 720756e6736SKevin Wolf if (backing_fmt) { 721756e6736SKevin Wolf int padding = backing_fmt_len - 722756e6736SKevin Wolf (sizeof(ext_backing_fmt) + strlen(backing_fmt)); 723756e6736SKevin Wolf 724756e6736SKevin Wolf memcpy(buf + offset, &ext_backing_fmt, sizeof(ext_backing_fmt)); 725756e6736SKevin Wolf offset += sizeof(ext_backing_fmt); 726756e6736SKevin Wolf 727756e6736SKevin Wolf memcpy(buf + offset, backing_fmt, strlen(backing_fmt)); 728756e6736SKevin Wolf offset += strlen(backing_fmt); 729756e6736SKevin Wolf 730756e6736SKevin Wolf memset(buf + offset, 0, padding); 731756e6736SKevin Wolf offset += padding; 732756e6736SKevin Wolf } 733756e6736SKevin Wolf 734756e6736SKevin Wolf memcpy(buf + offset, backing_file, backing_file_len); 735756e6736SKevin Wolf backing_file_offset = sizeof(QCowHeader) + offset; 736756e6736SKevin Wolf } 737756e6736SKevin Wolf 73866f82ceeSKevin Wolf ret = bdrv_pwrite(bs->file, sizeof(QCowHeader), buf, ext_size); 739756e6736SKevin Wolf if (ret < 0) { 740756e6736SKevin Wolf goto fail; 741756e6736SKevin Wolf } 742756e6736SKevin Wolf 743756e6736SKevin Wolf /* Update header fields */ 744756e6736SKevin Wolf uint64_t be_backing_file_offset = cpu_to_be64(backing_file_offset); 745756e6736SKevin Wolf uint32_t be_backing_file_size = cpu_to_be32(backing_file_len); 746756e6736SKevin Wolf 74766f82ceeSKevin Wolf ret = bdrv_pwrite(bs->file, offsetof(QCowHeader, backing_file_offset), 748756e6736SKevin Wolf &be_backing_file_offset, sizeof(uint64_t)); 749756e6736SKevin Wolf if (ret < 0) { 750756e6736SKevin Wolf goto fail; 751756e6736SKevin Wolf } 752756e6736SKevin Wolf 75366f82ceeSKevin Wolf ret = bdrv_pwrite(bs->file, offsetof(QCowHeader, backing_file_size), 754756e6736SKevin Wolf &be_backing_file_size, sizeof(uint32_t)); 755756e6736SKevin Wolf if (ret < 0) { 756756e6736SKevin Wolf goto fail; 757756e6736SKevin Wolf } 758756e6736SKevin Wolf 759756e6736SKevin Wolf ret = 0; 760756e6736SKevin Wolf fail: 761756e6736SKevin Wolf return ret; 762756e6736SKevin Wolf } 763756e6736SKevin Wolf 764756e6736SKevin Wolf static int qcow2_change_backing_file(BlockDriverState *bs, 765756e6736SKevin Wolf const char *backing_file, const char *backing_fmt) 766756e6736SKevin Wolf { 767756e6736SKevin Wolf return qcow2_update_ext_header(bs, backing_file, backing_fmt); 768756e6736SKevin Wolf } 769756e6736SKevin Wolf 77073c632edSKevin Wolf static int get_bits_from_size(size_t size) 77173c632edSKevin Wolf { 77273c632edSKevin Wolf int res = 0; 77373c632edSKevin Wolf 77473c632edSKevin Wolf if (size == 0) { 77573c632edSKevin Wolf return -1; 77673c632edSKevin Wolf } 77773c632edSKevin Wolf 77873c632edSKevin Wolf while (size != 1) { 77973c632edSKevin Wolf /* Not a power of two */ 78073c632edSKevin Wolf if (size & 1) { 78173c632edSKevin Wolf return -1; 78273c632edSKevin Wolf } 78373c632edSKevin Wolf 78473c632edSKevin Wolf size >>= 1; 78573c632edSKevin Wolf res++; 78673c632edSKevin Wolf } 78773c632edSKevin Wolf 78873c632edSKevin Wolf return res; 78973c632edSKevin Wolf } 79073c632edSKevin Wolf 791a35e1c17SKevin Wolf 792a35e1c17SKevin Wolf static int preallocate(BlockDriverState *bs) 793a35e1c17SKevin Wolf { 794a35e1c17SKevin Wolf uint64_t nb_sectors; 795a35e1c17SKevin Wolf uint64_t offset; 796a35e1c17SKevin Wolf int num; 797148da7eaSKevin Wolf int ret; 798a35e1c17SKevin Wolf QCowL2Meta meta; 799a35e1c17SKevin Wolf 800a35e1c17SKevin Wolf nb_sectors = bdrv_getlength(bs) >> 9; 801a35e1c17SKevin Wolf offset = 0; 80272cf2d4fSBlue Swirl QLIST_INIT(&meta.dependent_requests); 803148da7eaSKevin Wolf meta.cluster_offset = 0; 804a35e1c17SKevin Wolf 805a35e1c17SKevin Wolf while (nb_sectors) { 806a35e1c17SKevin Wolf num = MIN(nb_sectors, INT_MAX >> 9); 807148da7eaSKevin Wolf ret = qcow2_alloc_cluster_offset(bs, offset, 0, num, &num, &meta); 808a35e1c17SKevin Wolf 809148da7eaSKevin Wolf if (ret < 0) { 810a35e1c17SKevin Wolf return -1; 811a35e1c17SKevin Wolf } 812a35e1c17SKevin Wolf 813148da7eaSKevin Wolf if (qcow2_alloc_cluster_link_l2(bs, &meta) < 0) { 814148da7eaSKevin Wolf qcow2_free_any_clusters(bs, meta.cluster_offset, meta.nb_clusters); 815a35e1c17SKevin Wolf return -1; 816a35e1c17SKevin Wolf } 817a35e1c17SKevin Wolf 818f214978aSKevin Wolf /* There are no dependent requests, but we need to remove our request 819f214978aSKevin Wolf * from the list of in-flight requests */ 820f214978aSKevin Wolf run_dependent_requests(&meta); 821f214978aSKevin Wolf 822a35e1c17SKevin Wolf /* TODO Preallocate data if requested */ 823a35e1c17SKevin Wolf 824a35e1c17SKevin Wolf nb_sectors -= num; 825a35e1c17SKevin Wolf offset += num << 9; 826a35e1c17SKevin Wolf } 827a35e1c17SKevin Wolf 828a35e1c17SKevin Wolf /* 829a35e1c17SKevin Wolf * It is expected that the image file is large enough to actually contain 830a35e1c17SKevin Wolf * all of the allocated clusters (otherwise we get failing reads after 831a35e1c17SKevin Wolf * EOF). Extend the image to the last allocated sector. 832a35e1c17SKevin Wolf */ 833148da7eaSKevin Wolf if (meta.cluster_offset != 0) { 834ea80b906SKevin Wolf uint8_t buf[512]; 835ea80b906SKevin Wolf memset(buf, 0, 512); 83666f82ceeSKevin Wolf bdrv_write(bs->file, (meta.cluster_offset >> 9) + num - 1, buf, 1); 837a35e1c17SKevin Wolf } 838a35e1c17SKevin Wolf 839a35e1c17SKevin Wolf return 0; 840a35e1c17SKevin Wolf } 841a35e1c17SKevin Wolf 842de5f3f40SKevin Wolf static int qcow_create2(const char *filename, int64_t total_size, 843de5f3f40SKevin Wolf const char *backing_file, const char *backing_format, 844de5f3f40SKevin Wolf int flags, size_t cluster_size, int prealloc) 845de5f3f40SKevin Wolf { 846de5f3f40SKevin Wolf 847de5f3f40SKevin Wolf int fd, header_size, backing_filename_len, l1_size, i, shift, l2_bits; 848de5f3f40SKevin Wolf int ref_clusters, reftable_clusters, backing_format_len = 0; 849de5f3f40SKevin Wolf int rounded_ext_bf_len = 0; 850de5f3f40SKevin Wolf QCowHeader header; 851de5f3f40SKevin Wolf uint64_t tmp, offset; 852de5f3f40SKevin Wolf uint64_t old_ref_clusters; 853de5f3f40SKevin Wolf QCowCreateState s1, *s = &s1; 854de5f3f40SKevin Wolf QCowExtension ext_bf = {0, 0}; 855de5f3f40SKevin Wolf int ret; 856de5f3f40SKevin Wolf 857de5f3f40SKevin Wolf memset(s, 0, sizeof(*s)); 858de5f3f40SKevin Wolf 859de5f3f40SKevin Wolf fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0644); 860de5f3f40SKevin Wolf if (fd < 0) 861de5f3f40SKevin Wolf return -errno; 862de5f3f40SKevin Wolf memset(&header, 0, sizeof(header)); 863de5f3f40SKevin Wolf header.magic = cpu_to_be32(QCOW_MAGIC); 864de5f3f40SKevin Wolf header.version = cpu_to_be32(QCOW_VERSION); 865de5f3f40SKevin Wolf header.size = cpu_to_be64(total_size * 512); 866de5f3f40SKevin Wolf header_size = sizeof(header); 867de5f3f40SKevin Wolf backing_filename_len = 0; 868de5f3f40SKevin Wolf if (backing_file) { 869de5f3f40SKevin Wolf if (backing_format) { 870de5f3f40SKevin Wolf ext_bf.magic = QCOW_EXT_MAGIC_BACKING_FORMAT; 871de5f3f40SKevin Wolf backing_format_len = strlen(backing_format); 872de5f3f40SKevin Wolf ext_bf.len = backing_format_len; 873de5f3f40SKevin Wolf rounded_ext_bf_len = (sizeof(ext_bf) + ext_bf.len + 7) & ~7; 874de5f3f40SKevin Wolf header_size += rounded_ext_bf_len; 875de5f3f40SKevin Wolf } 876de5f3f40SKevin Wolf header.backing_file_offset = cpu_to_be64(header_size); 877de5f3f40SKevin Wolf backing_filename_len = strlen(backing_file); 878de5f3f40SKevin Wolf header.backing_file_size = cpu_to_be32(backing_filename_len); 879de5f3f40SKevin Wolf header_size += backing_filename_len; 880de5f3f40SKevin Wolf } 881de5f3f40SKevin Wolf 882de5f3f40SKevin Wolf /* Cluster size */ 883de5f3f40SKevin Wolf s->cluster_bits = get_bits_from_size(cluster_size); 884de5f3f40SKevin Wolf if (s->cluster_bits < MIN_CLUSTER_BITS || 885de5f3f40SKevin Wolf s->cluster_bits > MAX_CLUSTER_BITS) 886de5f3f40SKevin Wolf { 887de5f3f40SKevin Wolf fprintf(stderr, "Cluster size must be a power of two between " 888de5f3f40SKevin Wolf "%d and %dk\n", 889de5f3f40SKevin Wolf 1 << MIN_CLUSTER_BITS, 890de5f3f40SKevin Wolf 1 << (MAX_CLUSTER_BITS - 10)); 891de5f3f40SKevin Wolf return -EINVAL; 892de5f3f40SKevin Wolf } 893de5f3f40SKevin Wolf s->cluster_size = 1 << s->cluster_bits; 894de5f3f40SKevin Wolf 895de5f3f40SKevin Wolf header.cluster_bits = cpu_to_be32(s->cluster_bits); 896de5f3f40SKevin Wolf header_size = (header_size + 7) & ~7; 897de5f3f40SKevin Wolf if (flags & BLOCK_FLAG_ENCRYPT) { 898de5f3f40SKevin Wolf header.crypt_method = cpu_to_be32(QCOW_CRYPT_AES); 899de5f3f40SKevin Wolf } else { 900de5f3f40SKevin Wolf header.crypt_method = cpu_to_be32(QCOW_CRYPT_NONE); 901de5f3f40SKevin Wolf } 902de5f3f40SKevin Wolf l2_bits = s->cluster_bits - 3; 903de5f3f40SKevin Wolf shift = s->cluster_bits + l2_bits; 904de5f3f40SKevin Wolf l1_size = (((total_size * 512) + (1LL << shift) - 1) >> shift); 905de5f3f40SKevin Wolf offset = align_offset(header_size, s->cluster_size); 906de5f3f40SKevin Wolf s->l1_table_offset = offset; 907de5f3f40SKevin Wolf header.l1_table_offset = cpu_to_be64(s->l1_table_offset); 908de5f3f40SKevin Wolf header.l1_size = cpu_to_be32(l1_size); 909de5f3f40SKevin Wolf offset += align_offset(l1_size * sizeof(uint64_t), s->cluster_size); 910de5f3f40SKevin Wolf 911de5f3f40SKevin Wolf /* count how many refcount blocks needed */ 912de5f3f40SKevin Wolf 913de5f3f40SKevin Wolf #define NUM_CLUSTERS(bytes) \ 914de5f3f40SKevin Wolf (((bytes) + (s->cluster_size) - 1) / (s->cluster_size)) 915de5f3f40SKevin Wolf 916de5f3f40SKevin Wolf ref_clusters = NUM_CLUSTERS(NUM_CLUSTERS(offset) * sizeof(uint16_t)); 917de5f3f40SKevin Wolf 918de5f3f40SKevin Wolf do { 919de5f3f40SKevin Wolf uint64_t image_clusters; 920de5f3f40SKevin Wolf old_ref_clusters = ref_clusters; 921de5f3f40SKevin Wolf 922de5f3f40SKevin Wolf /* Number of clusters used for the refcount table */ 923de5f3f40SKevin Wolf reftable_clusters = NUM_CLUSTERS(ref_clusters * sizeof(uint64_t)); 924de5f3f40SKevin Wolf 925de5f3f40SKevin Wolf /* Number of clusters that the whole image will have */ 926de5f3f40SKevin Wolf image_clusters = NUM_CLUSTERS(offset) + ref_clusters 927de5f3f40SKevin Wolf + reftable_clusters; 928de5f3f40SKevin Wolf 929de5f3f40SKevin Wolf /* Number of refcount blocks needed for the image */ 930de5f3f40SKevin Wolf ref_clusters = NUM_CLUSTERS(image_clusters * sizeof(uint16_t)); 931de5f3f40SKevin Wolf 932de5f3f40SKevin Wolf } while (ref_clusters != old_ref_clusters); 933de5f3f40SKevin Wolf 934de5f3f40SKevin Wolf s->refcount_table = qemu_mallocz(reftable_clusters * s->cluster_size); 935de5f3f40SKevin Wolf 936de5f3f40SKevin Wolf s->refcount_table_offset = offset; 937de5f3f40SKevin Wolf header.refcount_table_offset = cpu_to_be64(offset); 938de5f3f40SKevin Wolf header.refcount_table_clusters = cpu_to_be32(reftable_clusters); 939de5f3f40SKevin Wolf offset += (reftable_clusters * s->cluster_size); 940de5f3f40SKevin Wolf s->refcount_block_offset = offset; 941de5f3f40SKevin Wolf 942de5f3f40SKevin Wolf for (i=0; i < ref_clusters; i++) { 943de5f3f40SKevin Wolf s->refcount_table[i] = cpu_to_be64(offset); 944de5f3f40SKevin Wolf offset += s->cluster_size; 945de5f3f40SKevin Wolf } 946de5f3f40SKevin Wolf 947de5f3f40SKevin Wolf s->refcount_block = qemu_mallocz(ref_clusters * s->cluster_size); 948de5f3f40SKevin Wolf 949de5f3f40SKevin Wolf /* update refcounts */ 950de5f3f40SKevin Wolf qcow2_create_refcount_update(s, 0, header_size); 951de5f3f40SKevin Wolf qcow2_create_refcount_update(s, s->l1_table_offset, 952de5f3f40SKevin Wolf l1_size * sizeof(uint64_t)); 953de5f3f40SKevin Wolf qcow2_create_refcount_update(s, s->refcount_table_offset, 954de5f3f40SKevin Wolf reftable_clusters * s->cluster_size); 955de5f3f40SKevin Wolf qcow2_create_refcount_update(s, s->refcount_block_offset, 956de5f3f40SKevin Wolf ref_clusters * s->cluster_size); 957de5f3f40SKevin Wolf 958de5f3f40SKevin Wolf /* write all the data */ 959de5f3f40SKevin Wolf ret = qemu_write_full(fd, &header, sizeof(header)); 960de5f3f40SKevin Wolf if (ret != sizeof(header)) { 961de5f3f40SKevin Wolf ret = -errno; 962de5f3f40SKevin Wolf goto exit; 963de5f3f40SKevin Wolf } 964de5f3f40SKevin Wolf if (backing_file) { 965de5f3f40SKevin Wolf if (backing_format_len) { 966de5f3f40SKevin Wolf char zero[16]; 967de5f3f40SKevin Wolf int padding = rounded_ext_bf_len - (ext_bf.len + sizeof(ext_bf)); 968de5f3f40SKevin Wolf 969de5f3f40SKevin Wolf memset(zero, 0, sizeof(zero)); 970de5f3f40SKevin Wolf cpu_to_be32s(&ext_bf.magic); 971de5f3f40SKevin Wolf cpu_to_be32s(&ext_bf.len); 972de5f3f40SKevin Wolf ret = qemu_write_full(fd, &ext_bf, sizeof(ext_bf)); 973de5f3f40SKevin Wolf if (ret != sizeof(ext_bf)) { 974de5f3f40SKevin Wolf ret = -errno; 975de5f3f40SKevin Wolf goto exit; 976de5f3f40SKevin Wolf } 977de5f3f40SKevin Wolf ret = qemu_write_full(fd, backing_format, backing_format_len); 978de5f3f40SKevin Wolf if (ret != backing_format_len) { 979de5f3f40SKevin Wolf ret = -errno; 980de5f3f40SKevin Wolf goto exit; 981de5f3f40SKevin Wolf } 982de5f3f40SKevin Wolf if (padding > 0) { 983de5f3f40SKevin Wolf ret = qemu_write_full(fd, zero, padding); 984de5f3f40SKevin Wolf if (ret != padding) { 985de5f3f40SKevin Wolf ret = -errno; 986de5f3f40SKevin Wolf goto exit; 987de5f3f40SKevin Wolf } 988de5f3f40SKevin Wolf } 989de5f3f40SKevin Wolf } 990de5f3f40SKevin Wolf ret = qemu_write_full(fd, backing_file, backing_filename_len); 991de5f3f40SKevin Wolf if (ret != backing_filename_len) { 992de5f3f40SKevin Wolf ret = -errno; 993de5f3f40SKevin Wolf goto exit; 994de5f3f40SKevin Wolf } 995de5f3f40SKevin Wolf } 996de5f3f40SKevin Wolf lseek(fd, s->l1_table_offset, SEEK_SET); 997de5f3f40SKevin Wolf tmp = 0; 998de5f3f40SKevin Wolf for(i = 0;i < l1_size; i++) { 999de5f3f40SKevin Wolf ret = qemu_write_full(fd, &tmp, sizeof(tmp)); 1000de5f3f40SKevin Wolf if (ret != sizeof(tmp)) { 1001de5f3f40SKevin Wolf ret = -errno; 1002de5f3f40SKevin Wolf goto exit; 1003de5f3f40SKevin Wolf } 1004de5f3f40SKevin Wolf } 1005de5f3f40SKevin Wolf lseek(fd, s->refcount_table_offset, SEEK_SET); 1006de5f3f40SKevin Wolf ret = qemu_write_full(fd, s->refcount_table, 1007de5f3f40SKevin Wolf reftable_clusters * s->cluster_size); 1008de5f3f40SKevin Wolf if (ret != reftable_clusters * s->cluster_size) { 1009de5f3f40SKevin Wolf ret = -errno; 1010de5f3f40SKevin Wolf goto exit; 1011de5f3f40SKevin Wolf } 1012de5f3f40SKevin Wolf 1013de5f3f40SKevin Wolf lseek(fd, s->refcount_block_offset, SEEK_SET); 1014de5f3f40SKevin Wolf ret = qemu_write_full(fd, s->refcount_block, 1015de5f3f40SKevin Wolf ref_clusters * s->cluster_size); 1016de5f3f40SKevin Wolf if (ret != ref_clusters * s->cluster_size) { 1017de5f3f40SKevin Wolf ret = -errno; 1018de5f3f40SKevin Wolf goto exit; 1019de5f3f40SKevin Wolf } 1020de5f3f40SKevin Wolf 1021de5f3f40SKevin Wolf ret = 0; 1022de5f3f40SKevin Wolf exit: 1023de5f3f40SKevin Wolf qemu_free(s->refcount_table); 1024de5f3f40SKevin Wolf qemu_free(s->refcount_block); 1025de5f3f40SKevin Wolf close(fd); 1026de5f3f40SKevin Wolf 1027de5f3f40SKevin Wolf /* Preallocate metadata */ 1028de5f3f40SKevin Wolf if (ret == 0 && prealloc) { 1029de5f3f40SKevin Wolf BlockDriverState *bs; 103092b30744SKevin Wolf BlockDriver *drv = bdrv_find_format("qcow2"); 1031de5f3f40SKevin Wolf bs = bdrv_new(""); 103292b30744SKevin Wolf bdrv_open(bs, filename, BDRV_O_CACHE_WB | BDRV_O_RDWR, drv); 1033de5f3f40SKevin Wolf preallocate(bs); 1034de5f3f40SKevin Wolf bdrv_close(bs); 1035de5f3f40SKevin Wolf } 1036de5f3f40SKevin Wolf 1037de5f3f40SKevin Wolf return ret; 1038de5f3f40SKevin Wolf } 1039de5f3f40SKevin Wolf 1040de5f3f40SKevin Wolf static int qcow_create(const char *filename, QEMUOptionParameter *options) 1041de5f3f40SKevin Wolf { 1042de5f3f40SKevin Wolf const char *backing_file = NULL; 1043de5f3f40SKevin Wolf const char *backing_fmt = NULL; 1044de5f3f40SKevin Wolf uint64_t sectors = 0; 1045de5f3f40SKevin Wolf int flags = 0; 1046de5f3f40SKevin Wolf size_t cluster_size = 65536; 1047de5f3f40SKevin Wolf int prealloc = 0; 1048de5f3f40SKevin Wolf 1049de5f3f40SKevin Wolf /* Read out options */ 1050de5f3f40SKevin Wolf while (options && options->name) { 1051de5f3f40SKevin Wolf if (!strcmp(options->name, BLOCK_OPT_SIZE)) { 1052de5f3f40SKevin Wolf sectors = options->value.n / 512; 1053de5f3f40SKevin Wolf } else if (!strcmp(options->name, BLOCK_OPT_BACKING_FILE)) { 1054de5f3f40SKevin Wolf backing_file = options->value.s; 1055de5f3f40SKevin Wolf } else if (!strcmp(options->name, BLOCK_OPT_BACKING_FMT)) { 1056de5f3f40SKevin Wolf backing_fmt = options->value.s; 1057de5f3f40SKevin Wolf } else if (!strcmp(options->name, BLOCK_OPT_ENCRYPT)) { 1058de5f3f40SKevin Wolf flags |= options->value.n ? BLOCK_FLAG_ENCRYPT : 0; 1059de5f3f40SKevin Wolf } else if (!strcmp(options->name, BLOCK_OPT_CLUSTER_SIZE)) { 1060de5f3f40SKevin Wolf if (options->value.n) { 1061de5f3f40SKevin Wolf cluster_size = options->value.n; 1062de5f3f40SKevin Wolf } 1063de5f3f40SKevin Wolf } else if (!strcmp(options->name, BLOCK_OPT_PREALLOC)) { 1064de5f3f40SKevin Wolf if (!options->value.s || !strcmp(options->value.s, "off")) { 1065de5f3f40SKevin Wolf prealloc = 0; 1066de5f3f40SKevin Wolf } else if (!strcmp(options->value.s, "metadata")) { 1067de5f3f40SKevin Wolf prealloc = 1; 1068de5f3f40SKevin Wolf } else { 1069de5f3f40SKevin Wolf fprintf(stderr, "Invalid preallocation mode: '%s'\n", 1070de5f3f40SKevin Wolf options->value.s); 1071de5f3f40SKevin Wolf return -EINVAL; 1072de5f3f40SKevin Wolf } 1073de5f3f40SKevin Wolf } 1074de5f3f40SKevin Wolf options++; 1075de5f3f40SKevin Wolf } 1076de5f3f40SKevin Wolf 1077de5f3f40SKevin Wolf if (backing_file && prealloc) { 1078de5f3f40SKevin Wolf fprintf(stderr, "Backing file and preallocation cannot be used at " 1079de5f3f40SKevin Wolf "the same time\n"); 1080de5f3f40SKevin Wolf return -EINVAL; 1081de5f3f40SKevin Wolf } 1082de5f3f40SKevin Wolf 1083de5f3f40SKevin Wolf return qcow_create2(filename, sectors, backing_file, backing_fmt, flags, 1084de5f3f40SKevin Wolf cluster_size, prealloc); 1085de5f3f40SKevin Wolf } 1086de5f3f40SKevin Wolf 108720d97356SBlue Swirl static int qcow_make_empty(BlockDriverState *bs) 108820d97356SBlue Swirl { 108920d97356SBlue Swirl #if 0 109020d97356SBlue Swirl /* XXX: not correct */ 109120d97356SBlue Swirl BDRVQcowState *s = bs->opaque; 109220d97356SBlue Swirl uint32_t l1_length = s->l1_size * sizeof(uint64_t); 109320d97356SBlue Swirl int ret; 109420d97356SBlue Swirl 109520d97356SBlue Swirl memset(s->l1_table, 0, l1_length); 109666f82ceeSKevin Wolf if (bdrv_pwrite(bs->file, s->l1_table_offset, s->l1_table, l1_length) < 0) 109720d97356SBlue Swirl return -1; 109866f82ceeSKevin Wolf ret = bdrv_truncate(bs->file, s->l1_table_offset + l1_length); 109920d97356SBlue Swirl if (ret < 0) 110020d97356SBlue Swirl return ret; 110120d97356SBlue Swirl 110220d97356SBlue Swirl l2_cache_reset(bs); 110320d97356SBlue Swirl #endif 110420d97356SBlue Swirl return 0; 110520d97356SBlue Swirl } 110620d97356SBlue Swirl 1107419b19d9SStefan Hajnoczi static int qcow2_truncate(BlockDriverState *bs, int64_t offset) 1108419b19d9SStefan Hajnoczi { 1109419b19d9SStefan Hajnoczi BDRVQcowState *s = bs->opaque; 1110419b19d9SStefan Hajnoczi int ret, new_l1_size; 1111419b19d9SStefan Hajnoczi 1112419b19d9SStefan Hajnoczi if (offset & 511) { 1113419b19d9SStefan Hajnoczi return -EINVAL; 1114419b19d9SStefan Hajnoczi } 1115419b19d9SStefan Hajnoczi 1116419b19d9SStefan Hajnoczi /* cannot proceed if image has snapshots */ 1117419b19d9SStefan Hajnoczi if (s->nb_snapshots) { 1118419b19d9SStefan Hajnoczi return -ENOTSUP; 1119419b19d9SStefan Hajnoczi } 1120419b19d9SStefan Hajnoczi 1121419b19d9SStefan Hajnoczi /* shrinking is currently not supported */ 1122419b19d9SStefan Hajnoczi if (offset < bs->total_sectors * 512) { 1123419b19d9SStefan Hajnoczi return -ENOTSUP; 1124419b19d9SStefan Hajnoczi } 1125419b19d9SStefan Hajnoczi 1126419b19d9SStefan Hajnoczi new_l1_size = size_to_l1(s, offset); 1127419b19d9SStefan Hajnoczi ret = qcow2_grow_l1_table(bs, new_l1_size); 1128419b19d9SStefan Hajnoczi if (ret < 0) { 1129419b19d9SStefan Hajnoczi return ret; 1130419b19d9SStefan Hajnoczi } 1131419b19d9SStefan Hajnoczi 1132419b19d9SStefan Hajnoczi /* write updated header.size */ 1133419b19d9SStefan Hajnoczi offset = cpu_to_be64(offset); 1134419b19d9SStefan Hajnoczi ret = bdrv_pwrite(bs->file, offsetof(QCowHeader, size), 1135419b19d9SStefan Hajnoczi &offset, sizeof(uint64_t)); 1136419b19d9SStefan Hajnoczi if (ret < 0) { 1137419b19d9SStefan Hajnoczi return ret; 1138419b19d9SStefan Hajnoczi } 1139419b19d9SStefan Hajnoczi 1140419b19d9SStefan Hajnoczi s->l1_vm_state_index = new_l1_size; 1141419b19d9SStefan Hajnoczi return 0; 1142419b19d9SStefan Hajnoczi } 1143419b19d9SStefan Hajnoczi 114420d97356SBlue Swirl /* XXX: put compressed sectors first, then all the cluster aligned 114520d97356SBlue Swirl tables to avoid losing bytes in alignment */ 114620d97356SBlue Swirl static int qcow_write_compressed(BlockDriverState *bs, int64_t sector_num, 114720d97356SBlue Swirl const uint8_t *buf, int nb_sectors) 114820d97356SBlue Swirl { 114920d97356SBlue Swirl BDRVQcowState *s = bs->opaque; 115020d97356SBlue Swirl z_stream strm; 115120d97356SBlue Swirl int ret, out_len; 115220d97356SBlue Swirl uint8_t *out_buf; 115320d97356SBlue Swirl uint64_t cluster_offset; 115420d97356SBlue Swirl 115520d97356SBlue Swirl if (nb_sectors == 0) { 115620d97356SBlue Swirl /* align end of file to a sector boundary to ease reading with 115720d97356SBlue Swirl sector based I/Os */ 115866f82ceeSKevin Wolf cluster_offset = bdrv_getlength(bs->file); 115920d97356SBlue Swirl cluster_offset = (cluster_offset + 511) & ~511; 116066f82ceeSKevin Wolf bdrv_truncate(bs->file, cluster_offset); 116120d97356SBlue Swirl return 0; 116220d97356SBlue Swirl } 116320d97356SBlue Swirl 116420d97356SBlue Swirl if (nb_sectors != s->cluster_sectors) 116520d97356SBlue Swirl return -EINVAL; 116620d97356SBlue Swirl 116720d97356SBlue Swirl out_buf = qemu_malloc(s->cluster_size + (s->cluster_size / 1000) + 128); 116820d97356SBlue Swirl 116920d97356SBlue Swirl /* best compression, small window, no zlib header */ 117020d97356SBlue Swirl memset(&strm, 0, sizeof(strm)); 117120d97356SBlue Swirl ret = deflateInit2(&strm, Z_DEFAULT_COMPRESSION, 117220d97356SBlue Swirl Z_DEFLATED, -12, 117320d97356SBlue Swirl 9, Z_DEFAULT_STRATEGY); 117420d97356SBlue Swirl if (ret != 0) { 117520d97356SBlue Swirl qemu_free(out_buf); 117620d97356SBlue Swirl return -1; 117720d97356SBlue Swirl } 117820d97356SBlue Swirl 117920d97356SBlue Swirl strm.avail_in = s->cluster_size; 118020d97356SBlue Swirl strm.next_in = (uint8_t *)buf; 118120d97356SBlue Swirl strm.avail_out = s->cluster_size; 118220d97356SBlue Swirl strm.next_out = out_buf; 118320d97356SBlue Swirl 118420d97356SBlue Swirl ret = deflate(&strm, Z_FINISH); 118520d97356SBlue Swirl if (ret != Z_STREAM_END && ret != Z_OK) { 118620d97356SBlue Swirl qemu_free(out_buf); 118720d97356SBlue Swirl deflateEnd(&strm); 118820d97356SBlue Swirl return -1; 118920d97356SBlue Swirl } 119020d97356SBlue Swirl out_len = strm.next_out - out_buf; 119120d97356SBlue Swirl 119220d97356SBlue Swirl deflateEnd(&strm); 119320d97356SBlue Swirl 119420d97356SBlue Swirl if (ret != Z_STREAM_END || out_len >= s->cluster_size) { 119520d97356SBlue Swirl /* could not compress: write normal cluster */ 119620d97356SBlue Swirl bdrv_write(bs, sector_num, buf, s->cluster_sectors); 119720d97356SBlue Swirl } else { 119820d97356SBlue Swirl cluster_offset = qcow2_alloc_compressed_cluster_offset(bs, 119920d97356SBlue Swirl sector_num << 9, out_len); 120020d97356SBlue Swirl if (!cluster_offset) 120120d97356SBlue Swirl return -1; 120220d97356SBlue Swirl cluster_offset &= s->cluster_offset_mask; 120366f82ceeSKevin Wolf BLKDBG_EVENT(bs->file, BLKDBG_WRITE_COMPRESSED); 120466f82ceeSKevin Wolf if (bdrv_pwrite(bs->file, cluster_offset, out_buf, out_len) != out_len) { 120520d97356SBlue Swirl qemu_free(out_buf); 120620d97356SBlue Swirl return -1; 120720d97356SBlue Swirl } 120820d97356SBlue Swirl } 120920d97356SBlue Swirl 121020d97356SBlue Swirl qemu_free(out_buf); 121120d97356SBlue Swirl return 0; 121220d97356SBlue Swirl } 121320d97356SBlue Swirl 121420d97356SBlue Swirl static void qcow_flush(BlockDriverState *bs) 121520d97356SBlue Swirl { 121666f82ceeSKevin Wolf bdrv_flush(bs->file); 121720d97356SBlue Swirl } 121820d97356SBlue Swirl 121920d97356SBlue Swirl static BlockDriverAIOCB *qcow_aio_flush(BlockDriverState *bs, 122020d97356SBlue Swirl BlockDriverCompletionFunc *cb, void *opaque) 122120d97356SBlue Swirl { 122266f82ceeSKevin Wolf return bdrv_aio_flush(bs->file, cb, opaque); 122320d97356SBlue Swirl } 122420d97356SBlue Swirl 122520d97356SBlue Swirl static int64_t qcow_vm_state_offset(BDRVQcowState *s) 122620d97356SBlue Swirl { 122720d97356SBlue Swirl return (int64_t)s->l1_vm_state_index << (s->cluster_bits + s->l2_bits); 122820d97356SBlue Swirl } 122920d97356SBlue Swirl 123020d97356SBlue Swirl static int qcow_get_info(BlockDriverState *bs, BlockDriverInfo *bdi) 123120d97356SBlue Swirl { 123220d97356SBlue Swirl BDRVQcowState *s = bs->opaque; 123320d97356SBlue Swirl bdi->cluster_size = s->cluster_size; 123420d97356SBlue Swirl bdi->vm_state_offset = qcow_vm_state_offset(s); 123520d97356SBlue Swirl return 0; 123620d97356SBlue Swirl } 123720d97356SBlue Swirl 123820d97356SBlue Swirl 123920d97356SBlue Swirl static int qcow_check(BlockDriverState *bs) 124020d97356SBlue Swirl { 124120d97356SBlue Swirl return qcow2_check_refcounts(bs); 124220d97356SBlue Swirl } 124320d97356SBlue Swirl 124420d97356SBlue Swirl #if 0 124520d97356SBlue Swirl static void dump_refcounts(BlockDriverState *bs) 124620d97356SBlue Swirl { 124720d97356SBlue Swirl BDRVQcowState *s = bs->opaque; 124820d97356SBlue Swirl int64_t nb_clusters, k, k1, size; 124920d97356SBlue Swirl int refcount; 125020d97356SBlue Swirl 125166f82ceeSKevin Wolf size = bdrv_getlength(bs->file); 125220d97356SBlue Swirl nb_clusters = size_to_clusters(s, size); 125320d97356SBlue Swirl for(k = 0; k < nb_clusters;) { 125420d97356SBlue Swirl k1 = k; 125520d97356SBlue Swirl refcount = get_refcount(bs, k); 125620d97356SBlue Swirl k++; 125720d97356SBlue Swirl while (k < nb_clusters && get_refcount(bs, k) == refcount) 125820d97356SBlue Swirl k++; 12590bfcd599SBlue Swirl printf("%" PRId64 ": refcount=%d nb=%" PRId64 "\n", k, refcount, 12600bfcd599SBlue Swirl k - k1); 126120d97356SBlue Swirl } 126220d97356SBlue Swirl } 126320d97356SBlue Swirl #endif 126420d97356SBlue Swirl 126520d97356SBlue Swirl static int qcow_save_vmstate(BlockDriverState *bs, const uint8_t *buf, 126620d97356SBlue Swirl int64_t pos, int size) 126720d97356SBlue Swirl { 126820d97356SBlue Swirl BDRVQcowState *s = bs->opaque; 126920d97356SBlue Swirl int growable = bs->growable; 127020d97356SBlue Swirl int ret; 127120d97356SBlue Swirl 127266f82ceeSKevin Wolf BLKDBG_EVENT(bs->file, BLKDBG_VMSTATE_SAVE); 127320d97356SBlue Swirl bs->growable = 1; 127420d97356SBlue Swirl ret = bdrv_pwrite(bs, qcow_vm_state_offset(s) + pos, buf, size); 127520d97356SBlue Swirl bs->growable = growable; 127620d97356SBlue Swirl 127720d97356SBlue Swirl return ret; 127820d97356SBlue Swirl } 127920d97356SBlue Swirl 128020d97356SBlue Swirl static int qcow_load_vmstate(BlockDriverState *bs, uint8_t *buf, 128120d97356SBlue Swirl int64_t pos, int size) 128220d97356SBlue Swirl { 128320d97356SBlue Swirl BDRVQcowState *s = bs->opaque; 128420d97356SBlue Swirl int growable = bs->growable; 128520d97356SBlue Swirl int ret; 128620d97356SBlue Swirl 128766f82ceeSKevin Wolf BLKDBG_EVENT(bs->file, BLKDBG_VMSTATE_LOAD); 128820d97356SBlue Swirl bs->growable = 1; 128920d97356SBlue Swirl ret = bdrv_pread(bs, qcow_vm_state_offset(s) + pos, buf, size); 129020d97356SBlue Swirl bs->growable = growable; 129120d97356SBlue Swirl 129220d97356SBlue Swirl return ret; 129320d97356SBlue Swirl } 129420d97356SBlue Swirl 129520d97356SBlue Swirl static QEMUOptionParameter qcow_create_options[] = { 129620d97356SBlue Swirl { 129720d97356SBlue Swirl .name = BLOCK_OPT_SIZE, 129820d97356SBlue Swirl .type = OPT_SIZE, 129920d97356SBlue Swirl .help = "Virtual disk size" 130020d97356SBlue Swirl }, 130120d97356SBlue Swirl { 130220d97356SBlue Swirl .name = BLOCK_OPT_BACKING_FILE, 130320d97356SBlue Swirl .type = OPT_STRING, 130420d97356SBlue Swirl .help = "File name of a base image" 130520d97356SBlue Swirl }, 130620d97356SBlue Swirl { 130720d97356SBlue Swirl .name = BLOCK_OPT_BACKING_FMT, 130820d97356SBlue Swirl .type = OPT_STRING, 130920d97356SBlue Swirl .help = "Image format of the base image" 131020d97356SBlue Swirl }, 131120d97356SBlue Swirl { 131220d97356SBlue Swirl .name = BLOCK_OPT_ENCRYPT, 131320d97356SBlue Swirl .type = OPT_FLAG, 131420d97356SBlue Swirl .help = "Encrypt the image" 131520d97356SBlue Swirl }, 131620d97356SBlue Swirl { 131720d97356SBlue Swirl .name = BLOCK_OPT_CLUSTER_SIZE, 131820d97356SBlue Swirl .type = OPT_SIZE, 131920d97356SBlue Swirl .help = "qcow2 cluster size" 132020d97356SBlue Swirl }, 132120d97356SBlue Swirl { 132220d97356SBlue Swirl .name = BLOCK_OPT_PREALLOC, 132320d97356SBlue Swirl .type = OPT_STRING, 132420d97356SBlue Swirl .help = "Preallocation mode (allowed values: off, metadata)" 132520d97356SBlue Swirl }, 132620d97356SBlue Swirl { NULL } 132720d97356SBlue Swirl }; 132820d97356SBlue Swirl 132920d97356SBlue Swirl static BlockDriver bdrv_qcow2 = { 133020d97356SBlue Swirl .format_name = "qcow2", 133120d97356SBlue Swirl .instance_size = sizeof(BDRVQcowState), 133220d97356SBlue Swirl .bdrv_probe = qcow_probe, 133320d97356SBlue Swirl .bdrv_open = qcow_open, 133420d97356SBlue Swirl .bdrv_close = qcow_close, 133520d97356SBlue Swirl .bdrv_create = qcow_create, 133620d97356SBlue Swirl .bdrv_flush = qcow_flush, 133720d97356SBlue Swirl .bdrv_is_allocated = qcow_is_allocated, 133820d97356SBlue Swirl .bdrv_set_key = qcow_set_key, 133920d97356SBlue Swirl .bdrv_make_empty = qcow_make_empty, 134020d97356SBlue Swirl 134120d97356SBlue Swirl .bdrv_aio_readv = qcow_aio_readv, 134220d97356SBlue Swirl .bdrv_aio_writev = qcow_aio_writev, 134320d97356SBlue Swirl .bdrv_aio_flush = qcow_aio_flush, 1344419b19d9SStefan Hajnoczi 1345419b19d9SStefan Hajnoczi .bdrv_truncate = qcow2_truncate, 134620d97356SBlue Swirl .bdrv_write_compressed = qcow_write_compressed, 134720d97356SBlue Swirl 134820d97356SBlue Swirl .bdrv_snapshot_create = qcow2_snapshot_create, 134920d97356SBlue Swirl .bdrv_snapshot_goto = qcow2_snapshot_goto, 135020d97356SBlue Swirl .bdrv_snapshot_delete = qcow2_snapshot_delete, 135120d97356SBlue Swirl .bdrv_snapshot_list = qcow2_snapshot_list, 135220d97356SBlue Swirl .bdrv_get_info = qcow_get_info, 135320d97356SBlue Swirl 135420d97356SBlue Swirl .bdrv_save_vmstate = qcow_save_vmstate, 135520d97356SBlue Swirl .bdrv_load_vmstate = qcow_load_vmstate, 135620d97356SBlue Swirl 135720d97356SBlue Swirl .bdrv_change_backing_file = qcow2_change_backing_file, 135820d97356SBlue Swirl 135920d97356SBlue Swirl .create_options = qcow_create_options, 136020d97356SBlue Swirl .bdrv_check = qcow_check, 136120d97356SBlue Swirl }; 136220d97356SBlue Swirl 13635efa9d5aSAnthony Liguori static void bdrv_qcow2_init(void) 13645efa9d5aSAnthony Liguori { 13655efa9d5aSAnthony Liguori bdrv_register(&bdrv_qcow2); 13665efa9d5aSAnthony Liguori } 13675efa9d5aSAnthony Liguori 13685efa9d5aSAnthony Liguori block_init(bdrv_qcow2_init); 1369