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 */ 2480c71a24SPeter Maydell #include "qemu/osdep.h" 25737e150eSPaolo Bonzini #include "block/block_int.h" 2623588797SKevin Wolf #include "sysemu/block-backend.h" 271de7afc9SPaolo Bonzini #include "qemu/module.h" 28585f8587Sbellard #include <zlib.h> 29f7d0fe02SKevin Wolf #include "block/qcow2.h" 301de7afc9SPaolo Bonzini #include "qemu/error-report.h" 317b1b5d19SPaolo Bonzini #include "qapi/qmp/qerror.h" 32acdfb480SKevin Wolf #include "qapi/qmp/qbool.h" 3385186ebdSMax Reitz #include "qapi/qmp/types.h" 3485186ebdSMax Reitz #include "qapi-event.h" 353cce16f4SKevin Wolf #include "trace.h" 361bd0e2d1SChunyan Liu #include "qemu/option_int.h" 37f348b6d1SVeronia Bahaa #include "qemu/cutils.h" 3858369e22SPaolo Bonzini #include "qemu/bswap.h" 39b25b387fSDaniel P. Berrange #include "qapi/opts-visitor.h" 40b25b387fSDaniel P. Berrange #include "qapi-visit.h" 41b25b387fSDaniel P. Berrange #include "block/crypto.h" 42585f8587Sbellard 43585f8587Sbellard /* 44585f8587Sbellard Differences with QCOW: 45585f8587Sbellard 46585f8587Sbellard - Support for multiple incremental snapshots. 47585f8587Sbellard - Memory management by reference counts. 48585f8587Sbellard - Clusters which have a reference count of one have the bit 49585f8587Sbellard QCOW_OFLAG_COPIED to optimize write performance. 50585f8587Sbellard - Size of compressed clusters is stored in sectors to reduce bit usage 51585f8587Sbellard in the cluster offsets. 52585f8587Sbellard - Support for storing additional data (such as the VM state) in the 53585f8587Sbellard snapshots. 54585f8587Sbellard - If a backing store is used, the cluster size is not constrained 55585f8587Sbellard (could be backported to QCOW). 56585f8587Sbellard - L2 tables have always a size of one cluster. 57585f8587Sbellard */ 58585f8587Sbellard 599b80ddf3Saliguori 609b80ddf3Saliguori typedef struct { 619b80ddf3Saliguori uint32_t magic; 629b80ddf3Saliguori uint32_t len; 63c4217f64SJeff Cody } QEMU_PACKED QCowExtension; 6421d82ac9SJeff Cody 657c80ab3fSJes Sorensen #define QCOW2_EXT_MAGIC_END 0 667c80ab3fSJes Sorensen #define QCOW2_EXT_MAGIC_BACKING_FORMAT 0xE2792ACA 67cfcc4c62SKevin Wolf #define QCOW2_EXT_MAGIC_FEATURE_TABLE 0x6803f857 684652b8f3SDaniel P. Berrange #define QCOW2_EXT_MAGIC_CRYPTO_HEADER 0x0537be77 6988ddffaeSVladimir Sementsov-Ogievskiy #define QCOW2_EXT_MAGIC_BITMAPS 0x23852875 709b80ddf3Saliguori 717c80ab3fSJes Sorensen static int qcow2_probe(const uint8_t *buf, int buf_size, const char *filename) 72585f8587Sbellard { 73585f8587Sbellard const QCowHeader *cow_header = (const void *)buf; 74585f8587Sbellard 75585f8587Sbellard if (buf_size >= sizeof(QCowHeader) && 76585f8587Sbellard be32_to_cpu(cow_header->magic) == QCOW_MAGIC && 776744cbabSKevin Wolf be32_to_cpu(cow_header->version) >= 2) 78585f8587Sbellard return 100; 79585f8587Sbellard else 80585f8587Sbellard return 0; 81585f8587Sbellard } 82585f8587Sbellard 839b80ddf3Saliguori 844652b8f3SDaniel P. Berrange static ssize_t qcow2_crypto_hdr_read_func(QCryptoBlock *block, size_t offset, 854652b8f3SDaniel P. Berrange uint8_t *buf, size_t buflen, 864652b8f3SDaniel P. Berrange void *opaque, Error **errp) 874652b8f3SDaniel P. Berrange { 884652b8f3SDaniel P. Berrange BlockDriverState *bs = opaque; 894652b8f3SDaniel P. Berrange BDRVQcow2State *s = bs->opaque; 904652b8f3SDaniel P. Berrange ssize_t ret; 914652b8f3SDaniel P. Berrange 924652b8f3SDaniel P. Berrange if ((offset + buflen) > s->crypto_header.length) { 934652b8f3SDaniel P. Berrange error_setg(errp, "Request for data outside of extension header"); 944652b8f3SDaniel P. Berrange return -1; 954652b8f3SDaniel P. Berrange } 964652b8f3SDaniel P. Berrange 974652b8f3SDaniel P. Berrange ret = bdrv_pread(bs->file, 984652b8f3SDaniel P. Berrange s->crypto_header.offset + offset, buf, buflen); 994652b8f3SDaniel P. Berrange if (ret < 0) { 1004652b8f3SDaniel P. Berrange error_setg_errno(errp, -ret, "Could not read encryption header"); 1014652b8f3SDaniel P. Berrange return -1; 1024652b8f3SDaniel P. Berrange } 1034652b8f3SDaniel P. Berrange return ret; 1044652b8f3SDaniel P. Berrange } 1054652b8f3SDaniel P. Berrange 1064652b8f3SDaniel P. Berrange 1074652b8f3SDaniel P. Berrange static ssize_t qcow2_crypto_hdr_init_func(QCryptoBlock *block, size_t headerlen, 1084652b8f3SDaniel P. Berrange void *opaque, Error **errp) 1094652b8f3SDaniel P. Berrange { 1104652b8f3SDaniel P. Berrange BlockDriverState *bs = opaque; 1114652b8f3SDaniel P. Berrange BDRVQcow2State *s = bs->opaque; 1124652b8f3SDaniel P. Berrange int64_t ret; 1134652b8f3SDaniel P. Berrange int64_t clusterlen; 1144652b8f3SDaniel P. Berrange 1154652b8f3SDaniel P. Berrange ret = qcow2_alloc_clusters(bs, headerlen); 1164652b8f3SDaniel P. Berrange if (ret < 0) { 1174652b8f3SDaniel P. Berrange error_setg_errno(errp, -ret, 1184652b8f3SDaniel P. Berrange "Cannot allocate cluster for LUKS header size %zu", 1194652b8f3SDaniel P. Berrange headerlen); 1204652b8f3SDaniel P. Berrange return -1; 1214652b8f3SDaniel P. Berrange } 1224652b8f3SDaniel P. Berrange 1234652b8f3SDaniel P. Berrange s->crypto_header.length = headerlen; 1244652b8f3SDaniel P. Berrange s->crypto_header.offset = ret; 1254652b8f3SDaniel P. Berrange 1264652b8f3SDaniel P. Berrange /* Zero fill remaining space in cluster so it has predictable 1274652b8f3SDaniel P. Berrange * content in case of future spec changes */ 1284652b8f3SDaniel P. Berrange clusterlen = size_to_clusters(s, headerlen) * s->cluster_size; 1294652b8f3SDaniel P. Berrange ret = bdrv_pwrite_zeroes(bs->file, 1304652b8f3SDaniel P. Berrange ret + headerlen, 1314652b8f3SDaniel P. Berrange clusterlen - headerlen, 0); 1324652b8f3SDaniel P. Berrange if (ret < 0) { 1334652b8f3SDaniel P. Berrange error_setg_errno(errp, -ret, "Could not zero fill encryption header"); 1344652b8f3SDaniel P. Berrange return -1; 1354652b8f3SDaniel P. Berrange } 1364652b8f3SDaniel P. Berrange 1374652b8f3SDaniel P. Berrange return ret; 1384652b8f3SDaniel P. Berrange } 1394652b8f3SDaniel P. Berrange 1404652b8f3SDaniel P. Berrange 1414652b8f3SDaniel P. Berrange static ssize_t qcow2_crypto_hdr_write_func(QCryptoBlock *block, size_t offset, 1424652b8f3SDaniel P. Berrange const uint8_t *buf, size_t buflen, 1434652b8f3SDaniel P. Berrange void *opaque, Error **errp) 1444652b8f3SDaniel P. Berrange { 1454652b8f3SDaniel P. Berrange BlockDriverState *bs = opaque; 1464652b8f3SDaniel P. Berrange BDRVQcow2State *s = bs->opaque; 1474652b8f3SDaniel P. Berrange ssize_t ret; 1484652b8f3SDaniel P. Berrange 1494652b8f3SDaniel P. Berrange if ((offset + buflen) > s->crypto_header.length) { 1504652b8f3SDaniel P. Berrange error_setg(errp, "Request for data outside of extension header"); 1514652b8f3SDaniel P. Berrange return -1; 1524652b8f3SDaniel P. Berrange } 1534652b8f3SDaniel P. Berrange 1544652b8f3SDaniel P. Berrange ret = bdrv_pwrite(bs->file, 1554652b8f3SDaniel P. Berrange s->crypto_header.offset + offset, buf, buflen); 1564652b8f3SDaniel P. Berrange if (ret < 0) { 1574652b8f3SDaniel P. Berrange error_setg_errno(errp, -ret, "Could not read encryption header"); 1584652b8f3SDaniel P. Berrange return -1; 1594652b8f3SDaniel P. Berrange } 1604652b8f3SDaniel P. Berrange return ret; 1614652b8f3SDaniel P. Berrange } 1624652b8f3SDaniel P. Berrange 1634652b8f3SDaniel P. Berrange 1649b80ddf3Saliguori /* 1659b80ddf3Saliguori * read qcow2 extension and fill bs 1669b80ddf3Saliguori * start reading from start_offset 1679b80ddf3Saliguori * finish reading upon magic of value 0 or when end_offset reached 1689b80ddf3Saliguori * unknown magic is skipped (future extension this version knows nothing about) 1699b80ddf3Saliguori * return 0 upon success, non-0 otherwise 1709b80ddf3Saliguori */ 1717c80ab3fSJes Sorensen static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset, 1723ef6c40aSMax Reitz uint64_t end_offset, void **p_feature_table, 17388ddffaeSVladimir Sementsov-Ogievskiy int flags, bool *need_update_header, 17488ddffaeSVladimir Sementsov-Ogievskiy Error **errp) 1759b80ddf3Saliguori { 176ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 1779b80ddf3Saliguori QCowExtension ext; 1789b80ddf3Saliguori uint64_t offset; 17975bab85cSKevin Wolf int ret; 18088ddffaeSVladimir Sementsov-Ogievskiy Qcow2BitmapHeaderExt bitmaps_ext; 18188ddffaeSVladimir Sementsov-Ogievskiy 18288ddffaeSVladimir Sementsov-Ogievskiy if (need_update_header != NULL) { 18388ddffaeSVladimir Sementsov-Ogievskiy *need_update_header = false; 18488ddffaeSVladimir Sementsov-Ogievskiy } 1859b80ddf3Saliguori 1869b80ddf3Saliguori #ifdef DEBUG_EXT 1877c80ab3fSJes Sorensen printf("qcow2_read_extensions: start=%ld end=%ld\n", start_offset, end_offset); 1889b80ddf3Saliguori #endif 1899b80ddf3Saliguori offset = start_offset; 1909b80ddf3Saliguori while (offset < end_offset) { 1919b80ddf3Saliguori 1929b80ddf3Saliguori #ifdef DEBUG_EXT 1939b80ddf3Saliguori /* Sanity check */ 1949b80ddf3Saliguori if (offset > s->cluster_size) 1957c80ab3fSJes Sorensen printf("qcow2_read_extension: suspicious offset %lu\n", offset); 1969b80ddf3Saliguori 1979b2260cbSDong Xu Wang printf("attempting to read extended header in offset %lu\n", offset); 1989b80ddf3Saliguori #endif 1999b80ddf3Saliguori 200cf2ab8fcSKevin Wolf ret = bdrv_pread(bs->file, offset, &ext, sizeof(ext)); 2013ef6c40aSMax Reitz if (ret < 0) { 2023ef6c40aSMax Reitz error_setg_errno(errp, -ret, "qcow2_read_extension: ERROR: " 2033ef6c40aSMax Reitz "pread fail from offset %" PRIu64, offset); 2049b80ddf3Saliguori return 1; 2059b80ddf3Saliguori } 2069b80ddf3Saliguori be32_to_cpus(&ext.magic); 2079b80ddf3Saliguori be32_to_cpus(&ext.len); 2089b80ddf3Saliguori offset += sizeof(ext); 2099b80ddf3Saliguori #ifdef DEBUG_EXT 2109b80ddf3Saliguori printf("ext.magic = 0x%x\n", ext.magic); 2119b80ddf3Saliguori #endif 2122ebafc85SKevin Wolf if (offset > end_offset || ext.len > end_offset - offset) { 2133ef6c40aSMax Reitz error_setg(errp, "Header extension too large"); 21464ca6aeeSKevin Wolf return -EINVAL; 21564ca6aeeSKevin Wolf } 21664ca6aeeSKevin Wolf 2179b80ddf3Saliguori switch (ext.magic) { 2187c80ab3fSJes Sorensen case QCOW2_EXT_MAGIC_END: 2199b80ddf3Saliguori return 0; 220f965509cSaliguori 2217c80ab3fSJes Sorensen case QCOW2_EXT_MAGIC_BACKING_FORMAT: 222f965509cSaliguori if (ext.len >= sizeof(bs->backing_format)) { 223521b2b5dSMax Reitz error_setg(errp, "ERROR: ext_backing_format: len=%" PRIu32 224521b2b5dSMax Reitz " too large (>=%zu)", ext.len, 225521b2b5dSMax Reitz sizeof(bs->backing_format)); 226f965509cSaliguori return 2; 227f965509cSaliguori } 228cf2ab8fcSKevin Wolf ret = bdrv_pread(bs->file, offset, bs->backing_format, ext.len); 2293ef6c40aSMax Reitz if (ret < 0) { 2303ef6c40aSMax Reitz error_setg_errno(errp, -ret, "ERROR: ext_backing_format: " 2313ef6c40aSMax Reitz "Could not read format name"); 232f965509cSaliguori return 3; 2333ef6c40aSMax Reitz } 234f965509cSaliguori bs->backing_format[ext.len] = '\0'; 235e4603fe1SKevin Wolf s->image_backing_format = g_strdup(bs->backing_format); 236f965509cSaliguori #ifdef DEBUG_EXT 237f965509cSaliguori printf("Qcow2: Got format extension %s\n", bs->backing_format); 238f965509cSaliguori #endif 239f965509cSaliguori break; 240f965509cSaliguori 241cfcc4c62SKevin Wolf case QCOW2_EXT_MAGIC_FEATURE_TABLE: 242cfcc4c62SKevin Wolf if (p_feature_table != NULL) { 243cfcc4c62SKevin Wolf void* feature_table = g_malloc0(ext.len + 2 * sizeof(Qcow2Feature)); 244cf2ab8fcSKevin Wolf ret = bdrv_pread(bs->file, offset , feature_table, ext.len); 245cfcc4c62SKevin Wolf if (ret < 0) { 2463ef6c40aSMax Reitz error_setg_errno(errp, -ret, "ERROR: ext_feature_table: " 2473ef6c40aSMax Reitz "Could not read table"); 248cfcc4c62SKevin Wolf return ret; 249cfcc4c62SKevin Wolf } 250cfcc4c62SKevin Wolf 251cfcc4c62SKevin Wolf *p_feature_table = feature_table; 252cfcc4c62SKevin Wolf } 253cfcc4c62SKevin Wolf break; 254cfcc4c62SKevin Wolf 2554652b8f3SDaniel P. Berrange case QCOW2_EXT_MAGIC_CRYPTO_HEADER: { 2564652b8f3SDaniel P. Berrange unsigned int cflags = 0; 2574652b8f3SDaniel P. Berrange if (s->crypt_method_header != QCOW_CRYPT_LUKS) { 2584652b8f3SDaniel P. Berrange error_setg(errp, "CRYPTO header extension only " 2594652b8f3SDaniel P. Berrange "expected with LUKS encryption method"); 2604652b8f3SDaniel P. Berrange return -EINVAL; 2614652b8f3SDaniel P. Berrange } 2624652b8f3SDaniel P. Berrange if (ext.len != sizeof(Qcow2CryptoHeaderExtension)) { 2634652b8f3SDaniel P. Berrange error_setg(errp, "CRYPTO header extension size %u, " 2644652b8f3SDaniel P. Berrange "but expected size %zu", ext.len, 2654652b8f3SDaniel P. Berrange sizeof(Qcow2CryptoHeaderExtension)); 2664652b8f3SDaniel P. Berrange return -EINVAL; 2674652b8f3SDaniel P. Berrange } 2684652b8f3SDaniel P. Berrange 2694652b8f3SDaniel P. Berrange ret = bdrv_pread(bs->file, offset, &s->crypto_header, ext.len); 2704652b8f3SDaniel P. Berrange if (ret < 0) { 2714652b8f3SDaniel P. Berrange error_setg_errno(errp, -ret, 2724652b8f3SDaniel P. Berrange "Unable to read CRYPTO header extension"); 2734652b8f3SDaniel P. Berrange return ret; 2744652b8f3SDaniel P. Berrange } 2754652b8f3SDaniel P. Berrange be64_to_cpus(&s->crypto_header.offset); 2764652b8f3SDaniel P. Berrange be64_to_cpus(&s->crypto_header.length); 2774652b8f3SDaniel P. Berrange 2784652b8f3SDaniel P. Berrange if ((s->crypto_header.offset % s->cluster_size) != 0) { 2794652b8f3SDaniel P. Berrange error_setg(errp, "Encryption header offset '%" PRIu64 "' is " 2804652b8f3SDaniel P. Berrange "not a multiple of cluster size '%u'", 2814652b8f3SDaniel P. Berrange s->crypto_header.offset, s->cluster_size); 2824652b8f3SDaniel P. Berrange return -EINVAL; 2834652b8f3SDaniel P. Berrange } 2844652b8f3SDaniel P. Berrange 2854652b8f3SDaniel P. Berrange if (flags & BDRV_O_NO_IO) { 2864652b8f3SDaniel P. Berrange cflags |= QCRYPTO_BLOCK_OPEN_NO_IO; 2874652b8f3SDaniel P. Berrange } 2881cd9a787SDaniel P. Berrange s->crypto = qcrypto_block_open(s->crypto_opts, "encrypt.", 2894652b8f3SDaniel P. Berrange qcow2_crypto_hdr_read_func, 2904652b8f3SDaniel P. Berrange bs, cflags, errp); 2914652b8f3SDaniel P. Berrange if (!s->crypto) { 2924652b8f3SDaniel P. Berrange return -EINVAL; 2934652b8f3SDaniel P. Berrange } 2944652b8f3SDaniel P. Berrange } break; 2954652b8f3SDaniel P. Berrange 29688ddffaeSVladimir Sementsov-Ogievskiy case QCOW2_EXT_MAGIC_BITMAPS: 29788ddffaeSVladimir Sementsov-Ogievskiy if (ext.len != sizeof(bitmaps_ext)) { 29888ddffaeSVladimir Sementsov-Ogievskiy error_setg_errno(errp, -ret, "bitmaps_ext: " 29988ddffaeSVladimir Sementsov-Ogievskiy "Invalid extension length"); 30088ddffaeSVladimir Sementsov-Ogievskiy return -EINVAL; 30188ddffaeSVladimir Sementsov-Ogievskiy } 30288ddffaeSVladimir Sementsov-Ogievskiy 30388ddffaeSVladimir Sementsov-Ogievskiy if (!(s->autoclear_features & QCOW2_AUTOCLEAR_BITMAPS)) { 30455d527a9SAlistair Francis warn_report("a program lacking bitmap support " 30588ddffaeSVladimir Sementsov-Ogievskiy "modified this file, so all bitmaps are now " 30655d527a9SAlistair Francis "considered inconsistent"); 30755d527a9SAlistair Francis error_printf("Some clusters may be leaked, " 30855d527a9SAlistair Francis "run 'qemu-img check -r' on the image " 30988ddffaeSVladimir Sementsov-Ogievskiy "file to fix."); 31088ddffaeSVladimir Sementsov-Ogievskiy if (need_update_header != NULL) { 31188ddffaeSVladimir Sementsov-Ogievskiy /* Updating is needed to drop invalid bitmap extension. */ 31288ddffaeSVladimir Sementsov-Ogievskiy *need_update_header = true; 31388ddffaeSVladimir Sementsov-Ogievskiy } 31488ddffaeSVladimir Sementsov-Ogievskiy break; 31588ddffaeSVladimir Sementsov-Ogievskiy } 31688ddffaeSVladimir Sementsov-Ogievskiy 31788ddffaeSVladimir Sementsov-Ogievskiy ret = bdrv_pread(bs->file, offset, &bitmaps_ext, ext.len); 31888ddffaeSVladimir Sementsov-Ogievskiy if (ret < 0) { 31988ddffaeSVladimir Sementsov-Ogievskiy error_setg_errno(errp, -ret, "bitmaps_ext: " 32088ddffaeSVladimir Sementsov-Ogievskiy "Could not read ext header"); 32188ddffaeSVladimir Sementsov-Ogievskiy return ret; 32288ddffaeSVladimir Sementsov-Ogievskiy } 32388ddffaeSVladimir Sementsov-Ogievskiy 32488ddffaeSVladimir Sementsov-Ogievskiy if (bitmaps_ext.reserved32 != 0) { 32588ddffaeSVladimir Sementsov-Ogievskiy error_setg_errno(errp, -ret, "bitmaps_ext: " 32688ddffaeSVladimir Sementsov-Ogievskiy "Reserved field is not zero"); 32788ddffaeSVladimir Sementsov-Ogievskiy return -EINVAL; 32888ddffaeSVladimir Sementsov-Ogievskiy } 32988ddffaeSVladimir Sementsov-Ogievskiy 33088ddffaeSVladimir Sementsov-Ogievskiy be32_to_cpus(&bitmaps_ext.nb_bitmaps); 33188ddffaeSVladimir Sementsov-Ogievskiy be64_to_cpus(&bitmaps_ext.bitmap_directory_size); 33288ddffaeSVladimir Sementsov-Ogievskiy be64_to_cpus(&bitmaps_ext.bitmap_directory_offset); 33388ddffaeSVladimir Sementsov-Ogievskiy 33488ddffaeSVladimir Sementsov-Ogievskiy if (bitmaps_ext.nb_bitmaps > QCOW2_MAX_BITMAPS) { 33588ddffaeSVladimir Sementsov-Ogievskiy error_setg(errp, 33688ddffaeSVladimir Sementsov-Ogievskiy "bitmaps_ext: Image has %" PRIu32 " bitmaps, " 33788ddffaeSVladimir Sementsov-Ogievskiy "exceeding the QEMU supported maximum of %d", 33888ddffaeSVladimir Sementsov-Ogievskiy bitmaps_ext.nb_bitmaps, QCOW2_MAX_BITMAPS); 33988ddffaeSVladimir Sementsov-Ogievskiy return -EINVAL; 34088ddffaeSVladimir Sementsov-Ogievskiy } 34188ddffaeSVladimir Sementsov-Ogievskiy 34288ddffaeSVladimir Sementsov-Ogievskiy if (bitmaps_ext.nb_bitmaps == 0) { 34388ddffaeSVladimir Sementsov-Ogievskiy error_setg(errp, "found bitmaps extension with zero bitmaps"); 34488ddffaeSVladimir Sementsov-Ogievskiy return -EINVAL; 34588ddffaeSVladimir Sementsov-Ogievskiy } 34688ddffaeSVladimir Sementsov-Ogievskiy 34788ddffaeSVladimir Sementsov-Ogievskiy if (bitmaps_ext.bitmap_directory_offset & (s->cluster_size - 1)) { 34888ddffaeSVladimir Sementsov-Ogievskiy error_setg(errp, "bitmaps_ext: " 34988ddffaeSVladimir Sementsov-Ogievskiy "invalid bitmap directory offset"); 35088ddffaeSVladimir Sementsov-Ogievskiy return -EINVAL; 35188ddffaeSVladimir Sementsov-Ogievskiy } 35288ddffaeSVladimir Sementsov-Ogievskiy 35388ddffaeSVladimir Sementsov-Ogievskiy if (bitmaps_ext.bitmap_directory_size > 35488ddffaeSVladimir Sementsov-Ogievskiy QCOW2_MAX_BITMAP_DIRECTORY_SIZE) { 35588ddffaeSVladimir Sementsov-Ogievskiy error_setg(errp, "bitmaps_ext: " 35688ddffaeSVladimir Sementsov-Ogievskiy "bitmap directory size (%" PRIu64 ") exceeds " 35788ddffaeSVladimir Sementsov-Ogievskiy "the maximum supported size (%d)", 35888ddffaeSVladimir Sementsov-Ogievskiy bitmaps_ext.bitmap_directory_size, 35988ddffaeSVladimir Sementsov-Ogievskiy QCOW2_MAX_BITMAP_DIRECTORY_SIZE); 36088ddffaeSVladimir Sementsov-Ogievskiy return -EINVAL; 36188ddffaeSVladimir Sementsov-Ogievskiy } 36288ddffaeSVladimir Sementsov-Ogievskiy 36388ddffaeSVladimir Sementsov-Ogievskiy s->nb_bitmaps = bitmaps_ext.nb_bitmaps; 36488ddffaeSVladimir Sementsov-Ogievskiy s->bitmap_directory_offset = 36588ddffaeSVladimir Sementsov-Ogievskiy bitmaps_ext.bitmap_directory_offset; 36688ddffaeSVladimir Sementsov-Ogievskiy s->bitmap_directory_size = 36788ddffaeSVladimir Sementsov-Ogievskiy bitmaps_ext.bitmap_directory_size; 36888ddffaeSVladimir Sementsov-Ogievskiy 36988ddffaeSVladimir Sementsov-Ogievskiy #ifdef DEBUG_EXT 37088ddffaeSVladimir Sementsov-Ogievskiy printf("Qcow2: Got bitmaps extension: " 37188ddffaeSVladimir Sementsov-Ogievskiy "offset=%" PRIu64 " nb_bitmaps=%" PRIu32 "\n", 37288ddffaeSVladimir Sementsov-Ogievskiy s->bitmap_directory_offset, s->nb_bitmaps); 37388ddffaeSVladimir Sementsov-Ogievskiy #endif 37488ddffaeSVladimir Sementsov-Ogievskiy break; 37588ddffaeSVladimir Sementsov-Ogievskiy 3769b80ddf3Saliguori default: 37775bab85cSKevin Wolf /* unknown magic - save it in case we need to rewrite the header */ 37875bab85cSKevin Wolf { 37975bab85cSKevin Wolf Qcow2UnknownHeaderExtension *uext; 38075bab85cSKevin Wolf 38175bab85cSKevin Wolf uext = g_malloc0(sizeof(*uext) + ext.len); 38275bab85cSKevin Wolf uext->magic = ext.magic; 38375bab85cSKevin Wolf uext->len = ext.len; 38475bab85cSKevin Wolf QLIST_INSERT_HEAD(&s->unknown_header_ext, uext, next); 38575bab85cSKevin Wolf 386cf2ab8fcSKevin Wolf ret = bdrv_pread(bs->file, offset , uext->data, uext->len); 38775bab85cSKevin Wolf if (ret < 0) { 3883ef6c40aSMax Reitz error_setg_errno(errp, -ret, "ERROR: unknown extension: " 3893ef6c40aSMax Reitz "Could not read data"); 39075bab85cSKevin Wolf return ret; 39175bab85cSKevin Wolf } 39275bab85cSKevin Wolf } 3939b80ddf3Saliguori break; 3949b80ddf3Saliguori } 395fd29b4bbSKevin Wolf 396fd29b4bbSKevin Wolf offset += ((ext.len + 7) & ~7); 3979b80ddf3Saliguori } 3989b80ddf3Saliguori 3999b80ddf3Saliguori return 0; 4009b80ddf3Saliguori } 4019b80ddf3Saliguori 40275bab85cSKevin Wolf static void cleanup_unknown_header_ext(BlockDriverState *bs) 40375bab85cSKevin Wolf { 404ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 40575bab85cSKevin Wolf Qcow2UnknownHeaderExtension *uext, *next; 40675bab85cSKevin Wolf 40775bab85cSKevin Wolf QLIST_FOREACH_SAFE(uext, &s->unknown_header_ext, next, next) { 40875bab85cSKevin Wolf QLIST_REMOVE(uext, next); 40975bab85cSKevin Wolf g_free(uext); 41075bab85cSKevin Wolf } 41175bab85cSKevin Wolf } 4129b80ddf3Saliguori 413a55448b3SMax Reitz static void report_unsupported_feature(Error **errp, Qcow2Feature *table, 414a55448b3SMax Reitz uint64_t mask) 415cfcc4c62SKevin Wolf { 41612ac6d3dSKevin Wolf char *features = g_strdup(""); 41712ac6d3dSKevin Wolf char *old; 41812ac6d3dSKevin Wolf 419cfcc4c62SKevin Wolf while (table && table->name[0] != '\0') { 420cfcc4c62SKevin Wolf if (table->type == QCOW2_FEAT_TYPE_INCOMPATIBLE) { 42112ac6d3dSKevin Wolf if (mask & (1ULL << table->bit)) { 42212ac6d3dSKevin Wolf old = features; 42312ac6d3dSKevin Wolf features = g_strdup_printf("%s%s%.46s", old, *old ? ", " : "", 42412ac6d3dSKevin Wolf table->name); 42512ac6d3dSKevin Wolf g_free(old); 42612ac6d3dSKevin Wolf mask &= ~(1ULL << table->bit); 427cfcc4c62SKevin Wolf } 428cfcc4c62SKevin Wolf } 429cfcc4c62SKevin Wolf table++; 430cfcc4c62SKevin Wolf } 431cfcc4c62SKevin Wolf 432cfcc4c62SKevin Wolf if (mask) { 43312ac6d3dSKevin Wolf old = features; 43412ac6d3dSKevin Wolf features = g_strdup_printf("%s%sUnknown incompatible feature: %" PRIx64, 43512ac6d3dSKevin Wolf old, *old ? ", " : "", mask); 43612ac6d3dSKevin Wolf g_free(old); 437cfcc4c62SKevin Wolf } 43812ac6d3dSKevin Wolf 439a55448b3SMax Reitz error_setg(errp, "Unsupported qcow2 feature(s): %s", features); 44012ac6d3dSKevin Wolf g_free(features); 441cfcc4c62SKevin Wolf } 442cfcc4c62SKevin Wolf 443c61d0004SStefan Hajnoczi /* 444bfe8043eSStefan Hajnoczi * Sets the dirty bit and flushes afterwards if necessary. 445bfe8043eSStefan Hajnoczi * 446bfe8043eSStefan Hajnoczi * The incompatible_features bit is only set if the image file header was 447bfe8043eSStefan Hajnoczi * updated successfully. Therefore it is not required to check the return 448bfe8043eSStefan Hajnoczi * value of this function. 449bfe8043eSStefan Hajnoczi */ 450280d3735SKevin Wolf int qcow2_mark_dirty(BlockDriverState *bs) 451bfe8043eSStefan Hajnoczi { 452ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 453bfe8043eSStefan Hajnoczi uint64_t val; 454bfe8043eSStefan Hajnoczi int ret; 455bfe8043eSStefan Hajnoczi 456bfe8043eSStefan Hajnoczi assert(s->qcow_version >= 3); 457bfe8043eSStefan Hajnoczi 458bfe8043eSStefan Hajnoczi if (s->incompatible_features & QCOW2_INCOMPAT_DIRTY) { 459bfe8043eSStefan Hajnoczi return 0; /* already dirty */ 460bfe8043eSStefan Hajnoczi } 461bfe8043eSStefan Hajnoczi 462bfe8043eSStefan Hajnoczi val = cpu_to_be64(s->incompatible_features | QCOW2_INCOMPAT_DIRTY); 463d9ca2ea2SKevin Wolf ret = bdrv_pwrite(bs->file, offsetof(QCowHeader, incompatible_features), 464bfe8043eSStefan Hajnoczi &val, sizeof(val)); 465bfe8043eSStefan Hajnoczi if (ret < 0) { 466bfe8043eSStefan Hajnoczi return ret; 467bfe8043eSStefan Hajnoczi } 4689a4f4c31SKevin Wolf ret = bdrv_flush(bs->file->bs); 469bfe8043eSStefan Hajnoczi if (ret < 0) { 470bfe8043eSStefan Hajnoczi return ret; 471bfe8043eSStefan Hajnoczi } 472bfe8043eSStefan Hajnoczi 473bfe8043eSStefan Hajnoczi /* Only treat image as dirty if the header was updated successfully */ 474bfe8043eSStefan Hajnoczi s->incompatible_features |= QCOW2_INCOMPAT_DIRTY; 475bfe8043eSStefan Hajnoczi return 0; 476bfe8043eSStefan Hajnoczi } 477bfe8043eSStefan Hajnoczi 478bfe8043eSStefan Hajnoczi /* 479c61d0004SStefan Hajnoczi * Clears the dirty bit and flushes before if necessary. Only call this 480c61d0004SStefan Hajnoczi * function when there are no pending requests, it does not guard against 481c61d0004SStefan Hajnoczi * concurrent requests dirtying the image. 482c61d0004SStefan Hajnoczi */ 483c61d0004SStefan Hajnoczi static int qcow2_mark_clean(BlockDriverState *bs) 484c61d0004SStefan Hajnoczi { 485ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 486c61d0004SStefan Hajnoczi 487c61d0004SStefan Hajnoczi if (s->incompatible_features & QCOW2_INCOMPAT_DIRTY) { 4884c2e5f8fSKevin Wolf int ret; 4894c2e5f8fSKevin Wolf 4904c2e5f8fSKevin Wolf s->incompatible_features &= ~QCOW2_INCOMPAT_DIRTY; 4914c2e5f8fSKevin Wolf 4924c2e5f8fSKevin Wolf ret = bdrv_flush(bs); 493c61d0004SStefan Hajnoczi if (ret < 0) { 494c61d0004SStefan Hajnoczi return ret; 495c61d0004SStefan Hajnoczi } 496c61d0004SStefan Hajnoczi 497c61d0004SStefan Hajnoczi return qcow2_update_header(bs); 498c61d0004SStefan Hajnoczi } 499c61d0004SStefan Hajnoczi return 0; 500c61d0004SStefan Hajnoczi } 501c61d0004SStefan Hajnoczi 50269c98726SMax Reitz /* 50369c98726SMax Reitz * Marks the image as corrupt. 50469c98726SMax Reitz */ 50569c98726SMax Reitz int qcow2_mark_corrupt(BlockDriverState *bs) 50669c98726SMax Reitz { 507ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 50869c98726SMax Reitz 50969c98726SMax Reitz s->incompatible_features |= QCOW2_INCOMPAT_CORRUPT; 51069c98726SMax Reitz return qcow2_update_header(bs); 51169c98726SMax Reitz } 51269c98726SMax Reitz 51369c98726SMax Reitz /* 51469c98726SMax Reitz * Marks the image as consistent, i.e., unsets the corrupt bit, and flushes 51569c98726SMax Reitz * before if necessary. 51669c98726SMax Reitz */ 51769c98726SMax Reitz int qcow2_mark_consistent(BlockDriverState *bs) 51869c98726SMax Reitz { 519ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 52069c98726SMax Reitz 52169c98726SMax Reitz if (s->incompatible_features & QCOW2_INCOMPAT_CORRUPT) { 52269c98726SMax Reitz int ret = bdrv_flush(bs); 52369c98726SMax Reitz if (ret < 0) { 52469c98726SMax Reitz return ret; 52569c98726SMax Reitz } 52669c98726SMax Reitz 52769c98726SMax Reitz s->incompatible_features &= ~QCOW2_INCOMPAT_CORRUPT; 52869c98726SMax Reitz return qcow2_update_header(bs); 52969c98726SMax Reitz } 53069c98726SMax Reitz return 0; 53169c98726SMax Reitz } 53269c98726SMax Reitz 533acbe5982SStefan Hajnoczi static int qcow2_check(BlockDriverState *bs, BdrvCheckResult *result, 534acbe5982SStefan Hajnoczi BdrvCheckMode fix) 535acbe5982SStefan Hajnoczi { 536acbe5982SStefan Hajnoczi int ret = qcow2_check_refcounts(bs, result, fix); 537acbe5982SStefan Hajnoczi if (ret < 0) { 538acbe5982SStefan Hajnoczi return ret; 539acbe5982SStefan Hajnoczi } 540acbe5982SStefan Hajnoczi 541acbe5982SStefan Hajnoczi if (fix && result->check_errors == 0 && result->corruptions == 0) { 54224530f3eSMax Reitz ret = qcow2_mark_clean(bs); 54324530f3eSMax Reitz if (ret < 0) { 54424530f3eSMax Reitz return ret; 54524530f3eSMax Reitz } 54624530f3eSMax Reitz return qcow2_mark_consistent(bs); 547acbe5982SStefan Hajnoczi } 548acbe5982SStefan Hajnoczi return ret; 549acbe5982SStefan Hajnoczi } 550acbe5982SStefan Hajnoczi 5518c7de283SKevin Wolf static int validate_table_offset(BlockDriverState *bs, uint64_t offset, 5528c7de283SKevin Wolf uint64_t entries, size_t entry_len) 5538c7de283SKevin Wolf { 554ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 5558c7de283SKevin Wolf uint64_t size; 5568c7de283SKevin Wolf 5578c7de283SKevin Wolf /* Use signed INT64_MAX as the maximum even for uint64_t header fields, 5588c7de283SKevin Wolf * because values will be passed to qemu functions taking int64_t. */ 5598c7de283SKevin Wolf if (entries > INT64_MAX / entry_len) { 5608c7de283SKevin Wolf return -EINVAL; 5618c7de283SKevin Wolf } 5628c7de283SKevin Wolf 5638c7de283SKevin Wolf size = entries * entry_len; 5648c7de283SKevin Wolf 5658c7de283SKevin Wolf if (INT64_MAX - size < offset) { 5668c7de283SKevin Wolf return -EINVAL; 5678c7de283SKevin Wolf } 5688c7de283SKevin Wolf 5698c7de283SKevin Wolf /* Tables must be cluster aligned */ 57024990c5bSAlberto Garcia if (offset_into_cluster(s, offset) != 0) { 5718c7de283SKevin Wolf return -EINVAL; 5728c7de283SKevin Wolf } 5738c7de283SKevin Wolf 5748c7de283SKevin Wolf return 0; 5758c7de283SKevin Wolf } 5768c7de283SKevin Wolf 57774c4510aSKevin Wolf static QemuOptsList qcow2_runtime_opts = { 57874c4510aSKevin Wolf .name = "qcow2", 57974c4510aSKevin Wolf .head = QTAILQ_HEAD_INITIALIZER(qcow2_runtime_opts.head), 58074c4510aSKevin Wolf .desc = { 58174c4510aSKevin Wolf { 58264aa99d3SKevin Wolf .name = QCOW2_OPT_LAZY_REFCOUNTS, 58374c4510aSKevin Wolf .type = QEMU_OPT_BOOL, 58474c4510aSKevin Wolf .help = "Postpone refcount updates", 58574c4510aSKevin Wolf }, 58667af674eSKevin Wolf { 58767af674eSKevin Wolf .name = QCOW2_OPT_DISCARD_REQUEST, 58867af674eSKevin Wolf .type = QEMU_OPT_BOOL, 58967af674eSKevin Wolf .help = "Pass guest discard requests to the layer below", 59067af674eSKevin Wolf }, 59167af674eSKevin Wolf { 59267af674eSKevin Wolf .name = QCOW2_OPT_DISCARD_SNAPSHOT, 59367af674eSKevin Wolf .type = QEMU_OPT_BOOL, 59467af674eSKevin Wolf .help = "Generate discard requests when snapshot related space " 59567af674eSKevin Wolf "is freed", 59667af674eSKevin Wolf }, 59767af674eSKevin Wolf { 59867af674eSKevin Wolf .name = QCOW2_OPT_DISCARD_OTHER, 59967af674eSKevin Wolf .type = QEMU_OPT_BOOL, 60067af674eSKevin Wolf .help = "Generate discard requests when other clusters are freed", 60167af674eSKevin Wolf }, 60205de7e86SMax Reitz { 60305de7e86SMax Reitz .name = QCOW2_OPT_OVERLAP, 60405de7e86SMax Reitz .type = QEMU_OPT_STRING, 60505de7e86SMax Reitz .help = "Selects which overlap checks to perform from a range of " 60605de7e86SMax Reitz "templates (none, constant, cached, all)", 60705de7e86SMax Reitz }, 60805de7e86SMax Reitz { 609ee42b5ceSMax Reitz .name = QCOW2_OPT_OVERLAP_TEMPLATE, 610ee42b5ceSMax Reitz .type = QEMU_OPT_STRING, 611ee42b5ceSMax Reitz .help = "Selects which overlap checks to perform from a range of " 612ee42b5ceSMax Reitz "templates (none, constant, cached, all)", 613ee42b5ceSMax Reitz }, 614ee42b5ceSMax Reitz { 61505de7e86SMax Reitz .name = QCOW2_OPT_OVERLAP_MAIN_HEADER, 61605de7e86SMax Reitz .type = QEMU_OPT_BOOL, 61705de7e86SMax Reitz .help = "Check for unintended writes into the main qcow2 header", 61805de7e86SMax Reitz }, 61905de7e86SMax Reitz { 62005de7e86SMax Reitz .name = QCOW2_OPT_OVERLAP_ACTIVE_L1, 62105de7e86SMax Reitz .type = QEMU_OPT_BOOL, 62205de7e86SMax Reitz .help = "Check for unintended writes into the active L1 table", 62305de7e86SMax Reitz }, 62405de7e86SMax Reitz { 62505de7e86SMax Reitz .name = QCOW2_OPT_OVERLAP_ACTIVE_L2, 62605de7e86SMax Reitz .type = QEMU_OPT_BOOL, 62705de7e86SMax Reitz .help = "Check for unintended writes into an active L2 table", 62805de7e86SMax Reitz }, 62905de7e86SMax Reitz { 63005de7e86SMax Reitz .name = QCOW2_OPT_OVERLAP_REFCOUNT_TABLE, 63105de7e86SMax Reitz .type = QEMU_OPT_BOOL, 63205de7e86SMax Reitz .help = "Check for unintended writes into the refcount table", 63305de7e86SMax Reitz }, 63405de7e86SMax Reitz { 63505de7e86SMax Reitz .name = QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK, 63605de7e86SMax Reitz .type = QEMU_OPT_BOOL, 63705de7e86SMax Reitz .help = "Check for unintended writes into a refcount block", 63805de7e86SMax Reitz }, 63905de7e86SMax Reitz { 64005de7e86SMax Reitz .name = QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE, 64105de7e86SMax Reitz .type = QEMU_OPT_BOOL, 64205de7e86SMax Reitz .help = "Check for unintended writes into the snapshot table", 64305de7e86SMax Reitz }, 64405de7e86SMax Reitz { 64505de7e86SMax Reitz .name = QCOW2_OPT_OVERLAP_INACTIVE_L1, 64605de7e86SMax Reitz .type = QEMU_OPT_BOOL, 64705de7e86SMax Reitz .help = "Check for unintended writes into an inactive L1 table", 64805de7e86SMax Reitz }, 64905de7e86SMax Reitz { 65005de7e86SMax Reitz .name = QCOW2_OPT_OVERLAP_INACTIVE_L2, 65105de7e86SMax Reitz .type = QEMU_OPT_BOOL, 65205de7e86SMax Reitz .help = "Check for unintended writes into an inactive L2 table", 65305de7e86SMax Reitz }, 6546c1c8d5dSMax Reitz { 6556c1c8d5dSMax Reitz .name = QCOW2_OPT_CACHE_SIZE, 6566c1c8d5dSMax Reitz .type = QEMU_OPT_SIZE, 6576c1c8d5dSMax Reitz .help = "Maximum combined metadata (L2 tables and refcount blocks) " 6586c1c8d5dSMax Reitz "cache size", 6596c1c8d5dSMax Reitz }, 6606c1c8d5dSMax Reitz { 6616c1c8d5dSMax Reitz .name = QCOW2_OPT_L2_CACHE_SIZE, 6626c1c8d5dSMax Reitz .type = QEMU_OPT_SIZE, 6636c1c8d5dSMax Reitz .help = "Maximum L2 table cache size", 6646c1c8d5dSMax Reitz }, 6656c1c8d5dSMax Reitz { 6666c1c8d5dSMax Reitz .name = QCOW2_OPT_REFCOUNT_CACHE_SIZE, 6676c1c8d5dSMax Reitz .type = QEMU_OPT_SIZE, 6686c1c8d5dSMax Reitz .help = "Maximum refcount block cache size", 6696c1c8d5dSMax Reitz }, 670279621c0SAlberto Garcia { 671279621c0SAlberto Garcia .name = QCOW2_OPT_CACHE_CLEAN_INTERVAL, 672279621c0SAlberto Garcia .type = QEMU_OPT_NUMBER, 673279621c0SAlberto Garcia .help = "Clean unused cache entries after this time (in seconds)", 674279621c0SAlberto Garcia }, 6754652b8f3SDaniel P. Berrange BLOCK_CRYPTO_OPT_DEF_KEY_SECRET("encrypt.", 6764652b8f3SDaniel P. Berrange "ID of secret providing qcow2 AES key or LUKS passphrase"), 67774c4510aSKevin Wolf { /* end of list */ } 67874c4510aSKevin Wolf }, 67974c4510aSKevin Wolf }; 68074c4510aSKevin Wolf 6814092e99dSMax Reitz static const char *overlap_bool_option_names[QCOW2_OL_MAX_BITNR] = { 6824092e99dSMax Reitz [QCOW2_OL_MAIN_HEADER_BITNR] = QCOW2_OPT_OVERLAP_MAIN_HEADER, 6834092e99dSMax Reitz [QCOW2_OL_ACTIVE_L1_BITNR] = QCOW2_OPT_OVERLAP_ACTIVE_L1, 6844092e99dSMax Reitz [QCOW2_OL_ACTIVE_L2_BITNR] = QCOW2_OPT_OVERLAP_ACTIVE_L2, 6854092e99dSMax Reitz [QCOW2_OL_REFCOUNT_TABLE_BITNR] = QCOW2_OPT_OVERLAP_REFCOUNT_TABLE, 6864092e99dSMax Reitz [QCOW2_OL_REFCOUNT_BLOCK_BITNR] = QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK, 6874092e99dSMax Reitz [QCOW2_OL_SNAPSHOT_TABLE_BITNR] = QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE, 6884092e99dSMax Reitz [QCOW2_OL_INACTIVE_L1_BITNR] = QCOW2_OPT_OVERLAP_INACTIVE_L1, 6894092e99dSMax Reitz [QCOW2_OL_INACTIVE_L2_BITNR] = QCOW2_OPT_OVERLAP_INACTIVE_L2, 6904092e99dSMax Reitz }; 6914092e99dSMax Reitz 692279621c0SAlberto Garcia static void cache_clean_timer_cb(void *opaque) 693279621c0SAlberto Garcia { 694279621c0SAlberto Garcia BlockDriverState *bs = opaque; 695ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 696279621c0SAlberto Garcia qcow2_cache_clean_unused(bs, s->l2_table_cache); 697279621c0SAlberto Garcia qcow2_cache_clean_unused(bs, s->refcount_block_cache); 698279621c0SAlberto Garcia timer_mod(s->cache_clean_timer, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) + 699279621c0SAlberto Garcia (int64_t) s->cache_clean_interval * 1000); 700279621c0SAlberto Garcia } 701279621c0SAlberto Garcia 702279621c0SAlberto Garcia static void cache_clean_timer_init(BlockDriverState *bs, AioContext *context) 703279621c0SAlberto Garcia { 704ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 705279621c0SAlberto Garcia if (s->cache_clean_interval > 0) { 706279621c0SAlberto Garcia s->cache_clean_timer = aio_timer_new(context, QEMU_CLOCK_VIRTUAL, 707279621c0SAlberto Garcia SCALE_MS, cache_clean_timer_cb, 708279621c0SAlberto Garcia bs); 709279621c0SAlberto Garcia timer_mod(s->cache_clean_timer, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) + 710279621c0SAlberto Garcia (int64_t) s->cache_clean_interval * 1000); 711279621c0SAlberto Garcia } 712279621c0SAlberto Garcia } 713279621c0SAlberto Garcia 714279621c0SAlberto Garcia static void cache_clean_timer_del(BlockDriverState *bs) 715279621c0SAlberto Garcia { 716ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 717279621c0SAlberto Garcia if (s->cache_clean_timer) { 718279621c0SAlberto Garcia timer_del(s->cache_clean_timer); 719279621c0SAlberto Garcia timer_free(s->cache_clean_timer); 720279621c0SAlberto Garcia s->cache_clean_timer = NULL; 721279621c0SAlberto Garcia } 722279621c0SAlberto Garcia } 723279621c0SAlberto Garcia 724279621c0SAlberto Garcia static void qcow2_detach_aio_context(BlockDriverState *bs) 725279621c0SAlberto Garcia { 726279621c0SAlberto Garcia cache_clean_timer_del(bs); 727279621c0SAlberto Garcia } 728279621c0SAlberto Garcia 729279621c0SAlberto Garcia static void qcow2_attach_aio_context(BlockDriverState *bs, 730279621c0SAlberto Garcia AioContext *new_context) 731279621c0SAlberto Garcia { 732279621c0SAlberto Garcia cache_clean_timer_init(bs, new_context); 733279621c0SAlberto Garcia } 734279621c0SAlberto Garcia 735bc85ef26SMax Reitz static void read_cache_sizes(BlockDriverState *bs, QemuOpts *opts, 736bc85ef26SMax Reitz uint64_t *l2_cache_size, 7376c1c8d5dSMax Reitz uint64_t *refcount_cache_size, Error **errp) 7386c1c8d5dSMax Reitz { 739ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 7406c1c8d5dSMax Reitz uint64_t combined_cache_size; 7416c1c8d5dSMax Reitz bool l2_cache_size_set, refcount_cache_size_set, combined_cache_size_set; 7426c1c8d5dSMax Reitz 7436c1c8d5dSMax Reitz combined_cache_size_set = qemu_opt_get(opts, QCOW2_OPT_CACHE_SIZE); 7446c1c8d5dSMax Reitz l2_cache_size_set = qemu_opt_get(opts, QCOW2_OPT_L2_CACHE_SIZE); 7456c1c8d5dSMax Reitz refcount_cache_size_set = qemu_opt_get(opts, QCOW2_OPT_REFCOUNT_CACHE_SIZE); 7466c1c8d5dSMax Reitz 7476c1c8d5dSMax Reitz combined_cache_size = qemu_opt_get_size(opts, QCOW2_OPT_CACHE_SIZE, 0); 7486c1c8d5dSMax Reitz *l2_cache_size = qemu_opt_get_size(opts, QCOW2_OPT_L2_CACHE_SIZE, 0); 7496c1c8d5dSMax Reitz *refcount_cache_size = qemu_opt_get_size(opts, 7506c1c8d5dSMax Reitz QCOW2_OPT_REFCOUNT_CACHE_SIZE, 0); 7516c1c8d5dSMax Reitz 7526c1c8d5dSMax Reitz if (combined_cache_size_set) { 7536c1c8d5dSMax Reitz if (l2_cache_size_set && refcount_cache_size_set) { 7546c1c8d5dSMax Reitz error_setg(errp, QCOW2_OPT_CACHE_SIZE ", " QCOW2_OPT_L2_CACHE_SIZE 7556c1c8d5dSMax Reitz " and " QCOW2_OPT_REFCOUNT_CACHE_SIZE " may not be set " 7566c1c8d5dSMax Reitz "the same time"); 7576c1c8d5dSMax Reitz return; 7586c1c8d5dSMax Reitz } else if (*l2_cache_size > combined_cache_size) { 7596c1c8d5dSMax Reitz error_setg(errp, QCOW2_OPT_L2_CACHE_SIZE " may not exceed " 7606c1c8d5dSMax Reitz QCOW2_OPT_CACHE_SIZE); 7616c1c8d5dSMax Reitz return; 7626c1c8d5dSMax Reitz } else if (*refcount_cache_size > combined_cache_size) { 7636c1c8d5dSMax Reitz error_setg(errp, QCOW2_OPT_REFCOUNT_CACHE_SIZE " may not exceed " 7646c1c8d5dSMax Reitz QCOW2_OPT_CACHE_SIZE); 7656c1c8d5dSMax Reitz return; 7666c1c8d5dSMax Reitz } 7676c1c8d5dSMax Reitz 7686c1c8d5dSMax Reitz if (l2_cache_size_set) { 7696c1c8d5dSMax Reitz *refcount_cache_size = combined_cache_size - *l2_cache_size; 7706c1c8d5dSMax Reitz } else if (refcount_cache_size_set) { 7716c1c8d5dSMax Reitz *l2_cache_size = combined_cache_size - *refcount_cache_size; 7726c1c8d5dSMax Reitz } else { 7736c1c8d5dSMax Reitz *refcount_cache_size = combined_cache_size 7746c1c8d5dSMax Reitz / (DEFAULT_L2_REFCOUNT_SIZE_RATIO + 1); 7756c1c8d5dSMax Reitz *l2_cache_size = combined_cache_size - *refcount_cache_size; 7766c1c8d5dSMax Reitz } 7776c1c8d5dSMax Reitz } else { 7786c1c8d5dSMax Reitz if (!l2_cache_size_set && !refcount_cache_size_set) { 779bc85ef26SMax Reitz *l2_cache_size = MAX(DEFAULT_L2_CACHE_BYTE_SIZE, 780bc85ef26SMax Reitz (uint64_t)DEFAULT_L2_CACHE_CLUSTERS 781bc85ef26SMax Reitz * s->cluster_size); 7826c1c8d5dSMax Reitz *refcount_cache_size = *l2_cache_size 7836c1c8d5dSMax Reitz / DEFAULT_L2_REFCOUNT_SIZE_RATIO; 7846c1c8d5dSMax Reitz } else if (!l2_cache_size_set) { 7856c1c8d5dSMax Reitz *l2_cache_size = *refcount_cache_size 7866c1c8d5dSMax Reitz * DEFAULT_L2_REFCOUNT_SIZE_RATIO; 7876c1c8d5dSMax Reitz } else if (!refcount_cache_size_set) { 7886c1c8d5dSMax Reitz *refcount_cache_size = *l2_cache_size 7896c1c8d5dSMax Reitz / DEFAULT_L2_REFCOUNT_SIZE_RATIO; 7906c1c8d5dSMax Reitz } 7916c1c8d5dSMax Reitz } 7926c1c8d5dSMax Reitz } 7936c1c8d5dSMax Reitz 794ee55b173SKevin Wolf typedef struct Qcow2ReopenState { 795ee55b173SKevin Wolf Qcow2Cache *l2_table_cache; 796ee55b173SKevin Wolf Qcow2Cache *refcount_block_cache; 797ee55b173SKevin Wolf bool use_lazy_refcounts; 798ee55b173SKevin Wolf int overlap_check; 799ee55b173SKevin Wolf bool discard_passthrough[QCOW2_DISCARD_MAX]; 800ee55b173SKevin Wolf uint64_t cache_clean_interval; 801b25b387fSDaniel P. Berrange QCryptoBlockOpenOptions *crypto_opts; /* Disk encryption runtime options */ 802ee55b173SKevin Wolf } Qcow2ReopenState; 803ee55b173SKevin Wolf 804ee55b173SKevin Wolf static int qcow2_update_options_prepare(BlockDriverState *bs, 805ee55b173SKevin Wolf Qcow2ReopenState *r, 806ee55b173SKevin Wolf QDict *options, int flags, 807ee55b173SKevin Wolf Error **errp) 8084c75d1a1SKevin Wolf { 8094c75d1a1SKevin Wolf BDRVQcow2State *s = bs->opaque; 81094edf3fbSKevin Wolf QemuOpts *opts = NULL; 8114c75d1a1SKevin Wolf const char *opt_overlap_check, *opt_overlap_check_template; 8124c75d1a1SKevin Wolf int overlap_check_template = 0; 81394edf3fbSKevin Wolf uint64_t l2_cache_size, refcount_cache_size; 8144c75d1a1SKevin Wolf int i; 815b25b387fSDaniel P. Berrange const char *encryptfmt; 816b25b387fSDaniel P. Berrange QDict *encryptopts = NULL; 81794edf3fbSKevin Wolf Error *local_err = NULL; 8184c75d1a1SKevin Wolf int ret; 8194c75d1a1SKevin Wolf 820b25b387fSDaniel P. Berrange qdict_extract_subqdict(options, &encryptopts, "encrypt."); 821b25b387fSDaniel P. Berrange encryptfmt = qdict_get_try_str(encryptopts, "format"); 822b25b387fSDaniel P. Berrange 82394edf3fbSKevin Wolf opts = qemu_opts_create(&qcow2_runtime_opts, NULL, 0, &error_abort); 82494edf3fbSKevin Wolf qemu_opts_absorb_qdict(opts, options, &local_err); 82594edf3fbSKevin Wolf if (local_err) { 82694edf3fbSKevin Wolf error_propagate(errp, local_err); 82794edf3fbSKevin Wolf ret = -EINVAL; 82894edf3fbSKevin Wolf goto fail; 82994edf3fbSKevin Wolf } 83094edf3fbSKevin Wolf 83194edf3fbSKevin Wolf /* get L2 table/refcount block cache size from command line options */ 83294edf3fbSKevin Wolf read_cache_sizes(bs, opts, &l2_cache_size, &refcount_cache_size, 83394edf3fbSKevin Wolf &local_err); 83494edf3fbSKevin Wolf if (local_err) { 83594edf3fbSKevin Wolf error_propagate(errp, local_err); 83694edf3fbSKevin Wolf ret = -EINVAL; 83794edf3fbSKevin Wolf goto fail; 83894edf3fbSKevin Wolf } 83994edf3fbSKevin Wolf 84094edf3fbSKevin Wolf l2_cache_size /= s->cluster_size; 84194edf3fbSKevin Wolf if (l2_cache_size < MIN_L2_CACHE_SIZE) { 84294edf3fbSKevin Wolf l2_cache_size = MIN_L2_CACHE_SIZE; 84394edf3fbSKevin Wolf } 84494edf3fbSKevin Wolf if (l2_cache_size > INT_MAX) { 84594edf3fbSKevin Wolf error_setg(errp, "L2 cache size too big"); 84694edf3fbSKevin Wolf ret = -EINVAL; 84794edf3fbSKevin Wolf goto fail; 84894edf3fbSKevin Wolf } 84994edf3fbSKevin Wolf 85094edf3fbSKevin Wolf refcount_cache_size /= s->cluster_size; 85194edf3fbSKevin Wolf if (refcount_cache_size < MIN_REFCOUNT_CACHE_SIZE) { 85294edf3fbSKevin Wolf refcount_cache_size = MIN_REFCOUNT_CACHE_SIZE; 85394edf3fbSKevin Wolf } 85494edf3fbSKevin Wolf if (refcount_cache_size > INT_MAX) { 85594edf3fbSKevin Wolf error_setg(errp, "Refcount cache size too big"); 85694edf3fbSKevin Wolf ret = -EINVAL; 85794edf3fbSKevin Wolf goto fail; 85894edf3fbSKevin Wolf } 85994edf3fbSKevin Wolf 8605b0959a7SKevin Wolf /* alloc new L2 table/refcount block cache, flush old one */ 8615b0959a7SKevin Wolf if (s->l2_table_cache) { 8625b0959a7SKevin Wolf ret = qcow2_cache_flush(bs, s->l2_table_cache); 8635b0959a7SKevin Wolf if (ret) { 8645b0959a7SKevin Wolf error_setg_errno(errp, -ret, "Failed to flush the L2 table cache"); 8655b0959a7SKevin Wolf goto fail; 8665b0959a7SKevin Wolf } 8675b0959a7SKevin Wolf } 8685b0959a7SKevin Wolf 8695b0959a7SKevin Wolf if (s->refcount_block_cache) { 8705b0959a7SKevin Wolf ret = qcow2_cache_flush(bs, s->refcount_block_cache); 8715b0959a7SKevin Wolf if (ret) { 8725b0959a7SKevin Wolf error_setg_errno(errp, -ret, 8735b0959a7SKevin Wolf "Failed to flush the refcount block cache"); 8745b0959a7SKevin Wolf goto fail; 8755b0959a7SKevin Wolf } 8765b0959a7SKevin Wolf } 8775b0959a7SKevin Wolf 878ee55b173SKevin Wolf r->l2_table_cache = qcow2_cache_create(bs, l2_cache_size); 879ee55b173SKevin Wolf r->refcount_block_cache = qcow2_cache_create(bs, refcount_cache_size); 880ee55b173SKevin Wolf if (r->l2_table_cache == NULL || r->refcount_block_cache == NULL) { 88194edf3fbSKevin Wolf error_setg(errp, "Could not allocate metadata caches"); 88294edf3fbSKevin Wolf ret = -ENOMEM; 88394edf3fbSKevin Wolf goto fail; 88494edf3fbSKevin Wolf } 88594edf3fbSKevin Wolf 88694edf3fbSKevin Wolf /* New interval for cache cleanup timer */ 887ee55b173SKevin Wolf r->cache_clean_interval = 8885b0959a7SKevin Wolf qemu_opt_get_number(opts, QCOW2_OPT_CACHE_CLEAN_INTERVAL, 8895b0959a7SKevin Wolf s->cache_clean_interval); 89091203f08SAlberto Garcia #ifndef CONFIG_LINUX 89191203f08SAlberto Garcia if (r->cache_clean_interval != 0) { 89291203f08SAlberto Garcia error_setg(errp, QCOW2_OPT_CACHE_CLEAN_INTERVAL 89391203f08SAlberto Garcia " not supported on this host"); 89491203f08SAlberto Garcia ret = -EINVAL; 89591203f08SAlberto Garcia goto fail; 89691203f08SAlberto Garcia } 89791203f08SAlberto Garcia #endif 898ee55b173SKevin Wolf if (r->cache_clean_interval > UINT_MAX) { 89994edf3fbSKevin Wolf error_setg(errp, "Cache clean interval too big"); 90094edf3fbSKevin Wolf ret = -EINVAL; 90194edf3fbSKevin Wolf goto fail; 90294edf3fbSKevin Wolf } 90394edf3fbSKevin Wolf 9045b0959a7SKevin Wolf /* lazy-refcounts; flush if going from enabled to disabled */ 905ee55b173SKevin Wolf r->use_lazy_refcounts = qemu_opt_get_bool(opts, QCOW2_OPT_LAZY_REFCOUNTS, 9064c75d1a1SKevin Wolf (s->compatible_features & QCOW2_COMPAT_LAZY_REFCOUNTS)); 907ee55b173SKevin Wolf if (r->use_lazy_refcounts && s->qcow_version < 3) { 908007dbc39SKevin Wolf error_setg(errp, "Lazy refcounts require a qcow2 image with at least " 909007dbc39SKevin Wolf "qemu 1.1 compatibility level"); 910007dbc39SKevin Wolf ret = -EINVAL; 911007dbc39SKevin Wolf goto fail; 912007dbc39SKevin Wolf } 9134c75d1a1SKevin Wolf 9145b0959a7SKevin Wolf if (s->use_lazy_refcounts && !r->use_lazy_refcounts) { 9155b0959a7SKevin Wolf ret = qcow2_mark_clean(bs); 9165b0959a7SKevin Wolf if (ret < 0) { 9175b0959a7SKevin Wolf error_setg_errno(errp, -ret, "Failed to disable lazy refcounts"); 9185b0959a7SKevin Wolf goto fail; 9195b0959a7SKevin Wolf } 9205b0959a7SKevin Wolf } 9215b0959a7SKevin Wolf 922007dbc39SKevin Wolf /* Overlap check options */ 9234c75d1a1SKevin Wolf opt_overlap_check = qemu_opt_get(opts, QCOW2_OPT_OVERLAP); 9244c75d1a1SKevin Wolf opt_overlap_check_template = qemu_opt_get(opts, QCOW2_OPT_OVERLAP_TEMPLATE); 9254c75d1a1SKevin Wolf if (opt_overlap_check_template && opt_overlap_check && 9264c75d1a1SKevin Wolf strcmp(opt_overlap_check_template, opt_overlap_check)) 9274c75d1a1SKevin Wolf { 9284c75d1a1SKevin Wolf error_setg(errp, "Conflicting values for qcow2 options '" 9294c75d1a1SKevin Wolf QCOW2_OPT_OVERLAP "' ('%s') and '" QCOW2_OPT_OVERLAP_TEMPLATE 9304c75d1a1SKevin Wolf "' ('%s')", opt_overlap_check, opt_overlap_check_template); 9314c75d1a1SKevin Wolf ret = -EINVAL; 9324c75d1a1SKevin Wolf goto fail; 9334c75d1a1SKevin Wolf } 9344c75d1a1SKevin Wolf if (!opt_overlap_check) { 9354c75d1a1SKevin Wolf opt_overlap_check = opt_overlap_check_template ?: "cached"; 9364c75d1a1SKevin Wolf } 9374c75d1a1SKevin Wolf 9384c75d1a1SKevin Wolf if (!strcmp(opt_overlap_check, "none")) { 9394c75d1a1SKevin Wolf overlap_check_template = 0; 9404c75d1a1SKevin Wolf } else if (!strcmp(opt_overlap_check, "constant")) { 9414c75d1a1SKevin Wolf overlap_check_template = QCOW2_OL_CONSTANT; 9424c75d1a1SKevin Wolf } else if (!strcmp(opt_overlap_check, "cached")) { 9434c75d1a1SKevin Wolf overlap_check_template = QCOW2_OL_CACHED; 9444c75d1a1SKevin Wolf } else if (!strcmp(opt_overlap_check, "all")) { 9454c75d1a1SKevin Wolf overlap_check_template = QCOW2_OL_ALL; 9464c75d1a1SKevin Wolf } else { 9474c75d1a1SKevin Wolf error_setg(errp, "Unsupported value '%s' for qcow2 option " 9484c75d1a1SKevin Wolf "'overlap-check'. Allowed are any of the following: " 9494c75d1a1SKevin Wolf "none, constant, cached, all", opt_overlap_check); 9504c75d1a1SKevin Wolf ret = -EINVAL; 9514c75d1a1SKevin Wolf goto fail; 9524c75d1a1SKevin Wolf } 9534c75d1a1SKevin Wolf 954ee55b173SKevin Wolf r->overlap_check = 0; 9554c75d1a1SKevin Wolf for (i = 0; i < QCOW2_OL_MAX_BITNR; i++) { 9564c75d1a1SKevin Wolf /* overlap-check defines a template bitmask, but every flag may be 9574c75d1a1SKevin Wolf * overwritten through the associated boolean option */ 958ee55b173SKevin Wolf r->overlap_check |= 9594c75d1a1SKevin Wolf qemu_opt_get_bool(opts, overlap_bool_option_names[i], 9604c75d1a1SKevin Wolf overlap_check_template & (1 << i)) << i; 9614c75d1a1SKevin Wolf } 9624c75d1a1SKevin Wolf 963ee55b173SKevin Wolf r->discard_passthrough[QCOW2_DISCARD_NEVER] = false; 964ee55b173SKevin Wolf r->discard_passthrough[QCOW2_DISCARD_ALWAYS] = true; 965ee55b173SKevin Wolf r->discard_passthrough[QCOW2_DISCARD_REQUEST] = 966007dbc39SKevin Wolf qemu_opt_get_bool(opts, QCOW2_OPT_DISCARD_REQUEST, 967007dbc39SKevin Wolf flags & BDRV_O_UNMAP); 968ee55b173SKevin Wolf r->discard_passthrough[QCOW2_DISCARD_SNAPSHOT] = 969007dbc39SKevin Wolf qemu_opt_get_bool(opts, QCOW2_OPT_DISCARD_SNAPSHOT, true); 970ee55b173SKevin Wolf r->discard_passthrough[QCOW2_DISCARD_OTHER] = 971007dbc39SKevin Wolf qemu_opt_get_bool(opts, QCOW2_OPT_DISCARD_OTHER, false); 972007dbc39SKevin Wolf 973b25b387fSDaniel P. Berrange switch (s->crypt_method_header) { 974b25b387fSDaniel P. Berrange case QCOW_CRYPT_NONE: 975b25b387fSDaniel P. Berrange if (encryptfmt) { 976b25b387fSDaniel P. Berrange error_setg(errp, "No encryption in image header, but options " 977b25b387fSDaniel P. Berrange "specified format '%s'", encryptfmt); 978b25b387fSDaniel P. Berrange ret = -EINVAL; 979b25b387fSDaniel P. Berrange goto fail; 980b25b387fSDaniel P. Berrange } 981b25b387fSDaniel P. Berrange break; 982b25b387fSDaniel P. Berrange 983b25b387fSDaniel P. Berrange case QCOW_CRYPT_AES: 984b25b387fSDaniel P. Berrange if (encryptfmt && !g_str_equal(encryptfmt, "aes")) { 985b25b387fSDaniel P. Berrange error_setg(errp, 986b25b387fSDaniel P. Berrange "Header reported 'aes' encryption format but " 987b25b387fSDaniel P. Berrange "options specify '%s'", encryptfmt); 988b25b387fSDaniel P. Berrange ret = -EINVAL; 989b25b387fSDaniel P. Berrange goto fail; 990b25b387fSDaniel P. Berrange } 991b25b387fSDaniel P. Berrange qdict_del(encryptopts, "format"); 992b25b387fSDaniel P. Berrange r->crypto_opts = block_crypto_open_opts_init( 993b25b387fSDaniel P. Berrange Q_CRYPTO_BLOCK_FORMAT_QCOW, encryptopts, errp); 994b25b387fSDaniel P. Berrange break; 995b25b387fSDaniel P. Berrange 9964652b8f3SDaniel P. Berrange case QCOW_CRYPT_LUKS: 9974652b8f3SDaniel P. Berrange if (encryptfmt && !g_str_equal(encryptfmt, "luks")) { 9984652b8f3SDaniel P. Berrange error_setg(errp, 9994652b8f3SDaniel P. Berrange "Header reported 'luks' encryption format but " 10004652b8f3SDaniel P. Berrange "options specify '%s'", encryptfmt); 10014652b8f3SDaniel P. Berrange ret = -EINVAL; 10024652b8f3SDaniel P. Berrange goto fail; 10034652b8f3SDaniel P. Berrange } 10044652b8f3SDaniel P. Berrange qdict_del(encryptopts, "format"); 10054652b8f3SDaniel P. Berrange r->crypto_opts = block_crypto_open_opts_init( 10064652b8f3SDaniel P. Berrange Q_CRYPTO_BLOCK_FORMAT_LUKS, encryptopts, errp); 10074652b8f3SDaniel P. Berrange break; 10084652b8f3SDaniel P. Berrange 1009b25b387fSDaniel P. Berrange default: 1010b25b387fSDaniel P. Berrange error_setg(errp, "Unsupported encryption method %d", 1011b25b387fSDaniel P. Berrange s->crypt_method_header); 1012b25b387fSDaniel P. Berrange break; 1013b25b387fSDaniel P. Berrange } 1014b25b387fSDaniel P. Berrange if (s->crypt_method_header != QCOW_CRYPT_NONE && !r->crypto_opts) { 1015b25b387fSDaniel P. Berrange ret = -EINVAL; 1016b25b387fSDaniel P. Berrange goto fail; 1017b25b387fSDaniel P. Berrange } 1018b25b387fSDaniel P. Berrange 10194c75d1a1SKevin Wolf ret = 0; 10204c75d1a1SKevin Wolf fail: 1021b25b387fSDaniel P. Berrange QDECREF(encryptopts); 102294edf3fbSKevin Wolf qemu_opts_del(opts); 102394edf3fbSKevin Wolf opts = NULL; 1024ee55b173SKevin Wolf return ret; 1025ee55b173SKevin Wolf } 1026ee55b173SKevin Wolf 1027ee55b173SKevin Wolf static void qcow2_update_options_commit(BlockDriverState *bs, 1028ee55b173SKevin Wolf Qcow2ReopenState *r) 1029ee55b173SKevin Wolf { 1030ee55b173SKevin Wolf BDRVQcow2State *s = bs->opaque; 1031ee55b173SKevin Wolf int i; 1032ee55b173SKevin Wolf 10335b0959a7SKevin Wolf if (s->l2_table_cache) { 10345b0959a7SKevin Wolf qcow2_cache_destroy(bs, s->l2_table_cache); 10355b0959a7SKevin Wolf } 10365b0959a7SKevin Wolf if (s->refcount_block_cache) { 10375b0959a7SKevin Wolf qcow2_cache_destroy(bs, s->refcount_block_cache); 10385b0959a7SKevin Wolf } 1039ee55b173SKevin Wolf s->l2_table_cache = r->l2_table_cache; 1040ee55b173SKevin Wolf s->refcount_block_cache = r->refcount_block_cache; 1041ee55b173SKevin Wolf 1042ee55b173SKevin Wolf s->overlap_check = r->overlap_check; 1043ee55b173SKevin Wolf s->use_lazy_refcounts = r->use_lazy_refcounts; 1044ee55b173SKevin Wolf 1045ee55b173SKevin Wolf for (i = 0; i < QCOW2_DISCARD_MAX; i++) { 1046ee55b173SKevin Wolf s->discard_passthrough[i] = r->discard_passthrough[i]; 1047ee55b173SKevin Wolf } 1048ee55b173SKevin Wolf 10495b0959a7SKevin Wolf if (s->cache_clean_interval != r->cache_clean_interval) { 10505b0959a7SKevin Wolf cache_clean_timer_del(bs); 1051ee55b173SKevin Wolf s->cache_clean_interval = r->cache_clean_interval; 1052ee55b173SKevin Wolf cache_clean_timer_init(bs, bdrv_get_aio_context(bs)); 1053ee55b173SKevin Wolf } 1054b25b387fSDaniel P. Berrange 1055b25b387fSDaniel P. Berrange qapi_free_QCryptoBlockOpenOptions(s->crypto_opts); 1056b25b387fSDaniel P. Berrange s->crypto_opts = r->crypto_opts; 10575b0959a7SKevin Wolf } 1058ee55b173SKevin Wolf 1059ee55b173SKevin Wolf static void qcow2_update_options_abort(BlockDriverState *bs, 1060ee55b173SKevin Wolf Qcow2ReopenState *r) 1061ee55b173SKevin Wolf { 1062ee55b173SKevin Wolf if (r->l2_table_cache) { 1063ee55b173SKevin Wolf qcow2_cache_destroy(bs, r->l2_table_cache); 1064ee55b173SKevin Wolf } 1065ee55b173SKevin Wolf if (r->refcount_block_cache) { 1066ee55b173SKevin Wolf qcow2_cache_destroy(bs, r->refcount_block_cache); 1067ee55b173SKevin Wolf } 1068b25b387fSDaniel P. Berrange qapi_free_QCryptoBlockOpenOptions(r->crypto_opts); 1069ee55b173SKevin Wolf } 1070ee55b173SKevin Wolf 1071ee55b173SKevin Wolf static int qcow2_update_options(BlockDriverState *bs, QDict *options, 1072ee55b173SKevin Wolf int flags, Error **errp) 1073ee55b173SKevin Wolf { 1074ee55b173SKevin Wolf Qcow2ReopenState r = {}; 1075ee55b173SKevin Wolf int ret; 1076ee55b173SKevin Wolf 1077ee55b173SKevin Wolf ret = qcow2_update_options_prepare(bs, &r, options, flags, errp); 1078ee55b173SKevin Wolf if (ret >= 0) { 1079ee55b173SKevin Wolf qcow2_update_options_commit(bs, &r); 1080ee55b173SKevin Wolf } else { 1081ee55b173SKevin Wolf qcow2_update_options_abort(bs, &r); 1082ee55b173SKevin Wolf } 108394edf3fbSKevin Wolf 10844c75d1a1SKevin Wolf return ret; 10854c75d1a1SKevin Wolf } 10864c75d1a1SKevin Wolf 10874e4bf5c4SKevin Wolf static int qcow2_do_open(BlockDriverState *bs, QDict *options, int flags, 1088015a1036SMax Reitz Error **errp) 1089585f8587Sbellard { 1090ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 10916d33e8e7SKevin Wolf unsigned int len, i; 10926d33e8e7SKevin Wolf int ret = 0; 1093585f8587Sbellard QCowHeader header; 109474c4510aSKevin Wolf Error *local_err = NULL; 10959b80ddf3Saliguori uint64_t ext_end; 10962cf7cfa1SKevin Wolf uint64_t l1_vm_state_index; 109788ddffaeSVladimir Sementsov-Ogievskiy bool update_header = false; 1098585f8587Sbellard 1099cf2ab8fcSKevin Wolf ret = bdrv_pread(bs->file, 0, &header, sizeof(header)); 11006d85a57eSJes Sorensen if (ret < 0) { 11013ef6c40aSMax Reitz error_setg_errno(errp, -ret, "Could not read qcow2 header"); 1102585f8587Sbellard goto fail; 11036d85a57eSJes Sorensen } 1104585f8587Sbellard be32_to_cpus(&header.magic); 1105585f8587Sbellard be32_to_cpus(&header.version); 1106585f8587Sbellard be64_to_cpus(&header.backing_file_offset); 1107585f8587Sbellard be32_to_cpus(&header.backing_file_size); 1108585f8587Sbellard be64_to_cpus(&header.size); 1109585f8587Sbellard be32_to_cpus(&header.cluster_bits); 1110585f8587Sbellard be32_to_cpus(&header.crypt_method); 1111585f8587Sbellard be64_to_cpus(&header.l1_table_offset); 1112585f8587Sbellard be32_to_cpus(&header.l1_size); 1113585f8587Sbellard be64_to_cpus(&header.refcount_table_offset); 1114585f8587Sbellard be32_to_cpus(&header.refcount_table_clusters); 1115585f8587Sbellard be64_to_cpus(&header.snapshots_offset); 1116585f8587Sbellard be32_to_cpus(&header.nb_snapshots); 1117585f8587Sbellard 1118e8cdcec1SKevin Wolf if (header.magic != QCOW_MAGIC) { 11193ef6c40aSMax Reitz error_setg(errp, "Image is not in qcow2 format"); 112076abe407SPaolo Bonzini ret = -EINVAL; 1121585f8587Sbellard goto fail; 11226d85a57eSJes Sorensen } 11236744cbabSKevin Wolf if (header.version < 2 || header.version > 3) { 1124a55448b3SMax Reitz error_setg(errp, "Unsupported qcow2 version %" PRIu32, header.version); 1125e8cdcec1SKevin Wolf ret = -ENOTSUP; 1126e8cdcec1SKevin Wolf goto fail; 1127e8cdcec1SKevin Wolf } 11286744cbabSKevin Wolf 11296744cbabSKevin Wolf s->qcow_version = header.version; 11306744cbabSKevin Wolf 113124342f2cSKevin Wolf /* Initialise cluster size */ 113224342f2cSKevin Wolf if (header.cluster_bits < MIN_CLUSTER_BITS || 113324342f2cSKevin Wolf header.cluster_bits > MAX_CLUSTER_BITS) { 1134521b2b5dSMax Reitz error_setg(errp, "Unsupported cluster size: 2^%" PRIu32, 1135521b2b5dSMax Reitz header.cluster_bits); 113624342f2cSKevin Wolf ret = -EINVAL; 113724342f2cSKevin Wolf goto fail; 113824342f2cSKevin Wolf } 113924342f2cSKevin Wolf 114024342f2cSKevin Wolf s->cluster_bits = header.cluster_bits; 114124342f2cSKevin Wolf s->cluster_size = 1 << s->cluster_bits; 114224342f2cSKevin Wolf s->cluster_sectors = 1 << (s->cluster_bits - 9); 114324342f2cSKevin Wolf 11446744cbabSKevin Wolf /* Initialise version 3 header fields */ 11456744cbabSKevin Wolf if (header.version == 2) { 11466744cbabSKevin Wolf header.incompatible_features = 0; 11476744cbabSKevin Wolf header.compatible_features = 0; 11486744cbabSKevin Wolf header.autoclear_features = 0; 11496744cbabSKevin Wolf header.refcount_order = 4; 11506744cbabSKevin Wolf header.header_length = 72; 11516744cbabSKevin Wolf } else { 11526744cbabSKevin Wolf be64_to_cpus(&header.incompatible_features); 11536744cbabSKevin Wolf be64_to_cpus(&header.compatible_features); 11546744cbabSKevin Wolf be64_to_cpus(&header.autoclear_features); 11556744cbabSKevin Wolf be32_to_cpus(&header.refcount_order); 11566744cbabSKevin Wolf be32_to_cpus(&header.header_length); 115724342f2cSKevin Wolf 115824342f2cSKevin Wolf if (header.header_length < 104) { 115924342f2cSKevin Wolf error_setg(errp, "qcow2 header too short"); 116024342f2cSKevin Wolf ret = -EINVAL; 116124342f2cSKevin Wolf goto fail; 116224342f2cSKevin Wolf } 116324342f2cSKevin Wolf } 116424342f2cSKevin Wolf 116524342f2cSKevin Wolf if (header.header_length > s->cluster_size) { 116624342f2cSKevin Wolf error_setg(errp, "qcow2 header exceeds cluster size"); 116724342f2cSKevin Wolf ret = -EINVAL; 116824342f2cSKevin Wolf goto fail; 11696744cbabSKevin Wolf } 11706744cbabSKevin Wolf 11716744cbabSKevin Wolf if (header.header_length > sizeof(header)) { 11726744cbabSKevin Wolf s->unknown_header_fields_size = header.header_length - sizeof(header); 11736744cbabSKevin Wolf s->unknown_header_fields = g_malloc(s->unknown_header_fields_size); 1174cf2ab8fcSKevin Wolf ret = bdrv_pread(bs->file, sizeof(header), s->unknown_header_fields, 11756744cbabSKevin Wolf s->unknown_header_fields_size); 11766744cbabSKevin Wolf if (ret < 0) { 11773ef6c40aSMax Reitz error_setg_errno(errp, -ret, "Could not read unknown qcow2 header " 11783ef6c40aSMax Reitz "fields"); 11796744cbabSKevin Wolf goto fail; 11806744cbabSKevin Wolf } 11816744cbabSKevin Wolf } 11826744cbabSKevin Wolf 1183a1b3955cSKevin Wolf if (header.backing_file_offset > s->cluster_size) { 1184a1b3955cSKevin Wolf error_setg(errp, "Invalid backing file offset"); 1185a1b3955cSKevin Wolf ret = -EINVAL; 1186a1b3955cSKevin Wolf goto fail; 1187a1b3955cSKevin Wolf } 1188a1b3955cSKevin Wolf 1189cfcc4c62SKevin Wolf if (header.backing_file_offset) { 1190cfcc4c62SKevin Wolf ext_end = header.backing_file_offset; 1191cfcc4c62SKevin Wolf } else { 1192cfcc4c62SKevin Wolf ext_end = 1 << header.cluster_bits; 1193cfcc4c62SKevin Wolf } 1194cfcc4c62SKevin Wolf 11956744cbabSKevin Wolf /* Handle feature bits */ 11966744cbabSKevin Wolf s->incompatible_features = header.incompatible_features; 11976744cbabSKevin Wolf s->compatible_features = header.compatible_features; 11986744cbabSKevin Wolf s->autoclear_features = header.autoclear_features; 11996744cbabSKevin Wolf 1200c61d0004SStefan Hajnoczi if (s->incompatible_features & ~QCOW2_INCOMPAT_MASK) { 1201cfcc4c62SKevin Wolf void *feature_table = NULL; 1202cfcc4c62SKevin Wolf qcow2_read_extensions(bs, header.header_length, ext_end, 120388ddffaeSVladimir Sementsov-Ogievskiy &feature_table, flags, NULL, NULL); 1204a55448b3SMax Reitz report_unsupported_feature(errp, feature_table, 1205c61d0004SStefan Hajnoczi s->incompatible_features & 1206c61d0004SStefan Hajnoczi ~QCOW2_INCOMPAT_MASK); 12076744cbabSKevin Wolf ret = -ENOTSUP; 1208c5a33ee9SPrasad Joshi g_free(feature_table); 12096744cbabSKevin Wolf goto fail; 12106744cbabSKevin Wolf } 12116744cbabSKevin Wolf 121269c98726SMax Reitz if (s->incompatible_features & QCOW2_INCOMPAT_CORRUPT) { 121369c98726SMax Reitz /* Corrupt images may not be written to unless they are being repaired 121469c98726SMax Reitz */ 121569c98726SMax Reitz if ((flags & BDRV_O_RDWR) && !(flags & BDRV_O_CHECK)) { 12163ef6c40aSMax Reitz error_setg(errp, "qcow2: Image is corrupt; cannot be opened " 12173ef6c40aSMax Reitz "read/write"); 121869c98726SMax Reitz ret = -EACCES; 121969c98726SMax Reitz goto fail; 122069c98726SMax Reitz } 122169c98726SMax Reitz } 122269c98726SMax Reitz 12236744cbabSKevin Wolf /* Check support for various header values */ 1224b72faf9fSMax Reitz if (header.refcount_order > 6) { 1225b72faf9fSMax Reitz error_setg(errp, "Reference count entry width too large; may not " 1226b72faf9fSMax Reitz "exceed 64 bits"); 1227b72faf9fSMax Reitz ret = -EINVAL; 12286744cbabSKevin Wolf goto fail; 12296744cbabSKevin Wolf } 1230b6481f37SMax Reitz s->refcount_order = header.refcount_order; 1231346a53dfSMax Reitz s->refcount_bits = 1 << s->refcount_order; 1232346a53dfSMax Reitz s->refcount_max = UINT64_C(1) << (s->refcount_bits - 1); 1233346a53dfSMax Reitz s->refcount_max += s->refcount_max - 1; 12346744cbabSKevin Wolf 1235585f8587Sbellard s->crypt_method_header = header.crypt_method; 12366d85a57eSJes Sorensen if (s->crypt_method_header) { 1237e6ff69bfSDaniel P. Berrange if (bdrv_uses_whitelist() && 1238e6ff69bfSDaniel P. Berrange s->crypt_method_header == QCOW_CRYPT_AES) { 12398c0dcbc4SDaniel P. Berrange error_setg(errp, 12408c0dcbc4SDaniel P. Berrange "Use of AES-CBC encrypted qcow2 images is no longer " 12418c0dcbc4SDaniel P. Berrange "supported in system emulators"); 12428c0dcbc4SDaniel P. Berrange error_append_hint(errp, 12438c0dcbc4SDaniel P. Berrange "You can use 'qemu-img convert' to convert your " 12448c0dcbc4SDaniel P. Berrange "image to an alternative supported format, such " 12458c0dcbc4SDaniel P. Berrange "as unencrypted qcow2, or raw with the LUKS " 12468c0dcbc4SDaniel P. Berrange "format instead.\n"); 12478c0dcbc4SDaniel P. Berrange ret = -ENOSYS; 12488c0dcbc4SDaniel P. Berrange goto fail; 1249e6ff69bfSDaniel P. Berrange } 1250e6ff69bfSDaniel P. Berrange 12514652b8f3SDaniel P. Berrange if (s->crypt_method_header == QCOW_CRYPT_AES) { 12524652b8f3SDaniel P. Berrange s->crypt_physical_offset = false; 12534652b8f3SDaniel P. Berrange } else { 12544652b8f3SDaniel P. Berrange /* Assuming LUKS and any future crypt methods we 12554652b8f3SDaniel P. Berrange * add will all use physical offsets, due to the 12564652b8f3SDaniel P. Berrange * fact that the alternative is insecure... */ 12574652b8f3SDaniel P. Berrange s->crypt_physical_offset = true; 12584652b8f3SDaniel P. Berrange } 12594652b8f3SDaniel P. Berrange 126054115412SEric Blake bs->encrypted = true; 12616d85a57eSJes Sorensen } 126224342f2cSKevin Wolf 1263585f8587Sbellard s->l2_bits = s->cluster_bits - 3; /* L2 is always one cluster */ 1264585f8587Sbellard s->l2_size = 1 << s->l2_bits; 12651d13d654SMax Reitz /* 2^(s->refcount_order - 3) is the refcount width in bytes */ 12661d13d654SMax Reitz s->refcount_block_bits = s->cluster_bits - (s->refcount_order - 3); 12671d13d654SMax Reitz s->refcount_block_size = 1 << s->refcount_block_bits; 1268585f8587Sbellard bs->total_sectors = header.size / 512; 1269585f8587Sbellard s->csize_shift = (62 - (s->cluster_bits - 8)); 1270585f8587Sbellard s->csize_mask = (1 << (s->cluster_bits - 8)) - 1; 1271585f8587Sbellard s->cluster_offset_mask = (1LL << s->csize_shift) - 1; 12725dab2fadSKevin Wolf 1273585f8587Sbellard s->refcount_table_offset = header.refcount_table_offset; 1274585f8587Sbellard s->refcount_table_size = 1275585f8587Sbellard header.refcount_table_clusters << (s->cluster_bits - 3); 1276585f8587Sbellard 12772b5d5953SKevin Wolf if (header.refcount_table_clusters > qcow2_max_refcount_clusters(s)) { 12785dab2fadSKevin Wolf error_setg(errp, "Reference count table too large"); 12795dab2fadSKevin Wolf ret = -EINVAL; 12805dab2fadSKevin Wolf goto fail; 12815dab2fadSKevin Wolf } 12825dab2fadSKevin Wolf 12838c7de283SKevin Wolf ret = validate_table_offset(bs, s->refcount_table_offset, 12848c7de283SKevin Wolf s->refcount_table_size, sizeof(uint64_t)); 12858c7de283SKevin Wolf if (ret < 0) { 12868c7de283SKevin Wolf error_setg(errp, "Invalid reference count table offset"); 12878c7de283SKevin Wolf goto fail; 12888c7de283SKevin Wolf } 12898c7de283SKevin Wolf 1290ce48f2f4SKevin Wolf /* Snapshot table offset/length */ 1291ce48f2f4SKevin Wolf if (header.nb_snapshots > QCOW_MAX_SNAPSHOTS) { 1292ce48f2f4SKevin Wolf error_setg(errp, "Too many snapshots"); 1293ce48f2f4SKevin Wolf ret = -EINVAL; 1294ce48f2f4SKevin Wolf goto fail; 1295ce48f2f4SKevin Wolf } 1296ce48f2f4SKevin Wolf 1297ce48f2f4SKevin Wolf ret = validate_table_offset(bs, header.snapshots_offset, 1298ce48f2f4SKevin Wolf header.nb_snapshots, 1299ce48f2f4SKevin Wolf sizeof(QCowSnapshotHeader)); 1300ce48f2f4SKevin Wolf if (ret < 0) { 1301ce48f2f4SKevin Wolf error_setg(errp, "Invalid snapshot table offset"); 1302ce48f2f4SKevin Wolf goto fail; 1303ce48f2f4SKevin Wolf } 1304ce48f2f4SKevin Wolf 1305585f8587Sbellard /* read the level 1 table */ 130687b86e7eSWen Congyang if (header.l1_size > QCOW_MAX_L1_SIZE / sizeof(uint64_t)) { 13072d51c32cSKevin Wolf error_setg(errp, "Active L1 table too large"); 13082d51c32cSKevin Wolf ret = -EFBIG; 13092d51c32cSKevin Wolf goto fail; 13102d51c32cSKevin Wolf } 1311585f8587Sbellard s->l1_size = header.l1_size; 13122cf7cfa1SKevin Wolf 13132cf7cfa1SKevin Wolf l1_vm_state_index = size_to_l1(s, header.size); 13142cf7cfa1SKevin Wolf if (l1_vm_state_index > INT_MAX) { 13153ef6c40aSMax Reitz error_setg(errp, "Image is too big"); 13162cf7cfa1SKevin Wolf ret = -EFBIG; 13172cf7cfa1SKevin Wolf goto fail; 13182cf7cfa1SKevin Wolf } 13192cf7cfa1SKevin Wolf s->l1_vm_state_index = l1_vm_state_index; 13202cf7cfa1SKevin Wolf 1321585f8587Sbellard /* the L1 table must contain at least enough entries to put 1322585f8587Sbellard header.size bytes */ 13236d85a57eSJes Sorensen if (s->l1_size < s->l1_vm_state_index) { 13243ef6c40aSMax Reitz error_setg(errp, "L1 table is too small"); 13256d85a57eSJes Sorensen ret = -EINVAL; 1326585f8587Sbellard goto fail; 13276d85a57eSJes Sorensen } 13282d51c32cSKevin Wolf 13292d51c32cSKevin Wolf ret = validate_table_offset(bs, header.l1_table_offset, 13302d51c32cSKevin Wolf header.l1_size, sizeof(uint64_t)); 13312d51c32cSKevin Wolf if (ret < 0) { 13322d51c32cSKevin Wolf error_setg(errp, "Invalid L1 table offset"); 13332d51c32cSKevin Wolf goto fail; 13342d51c32cSKevin Wolf } 1335585f8587Sbellard s->l1_table_offset = header.l1_table_offset; 13362d51c32cSKevin Wolf 13372d51c32cSKevin Wolf 1338d191d12dSStefan Weil if (s->l1_size > 0) { 13399a4f4c31SKevin Wolf s->l1_table = qemu_try_blockalign(bs->file->bs, 13403f6a3ee5SKevin Wolf align_offset(s->l1_size * sizeof(uint64_t), 512)); 1341de82815dSKevin Wolf if (s->l1_table == NULL) { 1342de82815dSKevin Wolf error_setg(errp, "Could not allocate L1 table"); 1343de82815dSKevin Wolf ret = -ENOMEM; 1344de82815dSKevin Wolf goto fail; 1345de82815dSKevin Wolf } 1346cf2ab8fcSKevin Wolf ret = bdrv_pread(bs->file, s->l1_table_offset, s->l1_table, 13476d85a57eSJes Sorensen s->l1_size * sizeof(uint64_t)); 13486d85a57eSJes Sorensen if (ret < 0) { 13493ef6c40aSMax Reitz error_setg_errno(errp, -ret, "Could not read L1 table"); 1350585f8587Sbellard goto fail; 13516d85a57eSJes Sorensen } 1352585f8587Sbellard for(i = 0;i < s->l1_size; i++) { 1353585f8587Sbellard be64_to_cpus(&s->l1_table[i]); 1354585f8587Sbellard } 1355d191d12dSStefan Weil } 135629c1a730SKevin Wolf 135794edf3fbSKevin Wolf /* Parse driver-specific options */ 135894edf3fbSKevin Wolf ret = qcow2_update_options(bs, options, flags, errp); 135990efa0eaSKevin Wolf if (ret < 0) { 136090efa0eaSKevin Wolf goto fail; 136190efa0eaSKevin Wolf } 136290efa0eaSKevin Wolf 1363585f8587Sbellard s->cluster_cache_offset = -1; 136406d9260fSAnthony Liguori s->flags = flags; 1365585f8587Sbellard 13666d85a57eSJes Sorensen ret = qcow2_refcount_init(bs); 13676d85a57eSJes Sorensen if (ret != 0) { 13683ef6c40aSMax Reitz error_setg_errno(errp, -ret, "Could not initialize refcount handling"); 1369585f8587Sbellard goto fail; 13706d85a57eSJes Sorensen } 1371585f8587Sbellard 137272cf2d4fSBlue Swirl QLIST_INIT(&s->cluster_allocs); 13730b919faeSKevin Wolf QTAILQ_INIT(&s->discards); 1374f214978aSKevin Wolf 13759b80ddf3Saliguori /* read qcow2 extensions */ 13763ef6c40aSMax Reitz if (qcow2_read_extensions(bs, header.header_length, ext_end, NULL, 137788ddffaeSVladimir Sementsov-Ogievskiy flags, &update_header, &local_err)) { 13783ef6c40aSMax Reitz error_propagate(errp, local_err); 13796d85a57eSJes Sorensen ret = -EINVAL; 13809b80ddf3Saliguori goto fail; 13816d85a57eSJes Sorensen } 13829b80ddf3Saliguori 13834652b8f3SDaniel P. Berrange /* qcow2_read_extension may have set up the crypto context 13844652b8f3SDaniel P. Berrange * if the crypt method needs a header region, some methods 13854652b8f3SDaniel P. Berrange * don't need header extensions, so must check here 13864652b8f3SDaniel P. Berrange */ 13874652b8f3SDaniel P. Berrange if (s->crypt_method_header && !s->crypto) { 1388b25b387fSDaniel P. Berrange if (s->crypt_method_header == QCOW_CRYPT_AES) { 1389b25b387fSDaniel P. Berrange unsigned int cflags = 0; 1390b25b387fSDaniel P. Berrange if (flags & BDRV_O_NO_IO) { 1391b25b387fSDaniel P. Berrange cflags |= QCRYPTO_BLOCK_OPEN_NO_IO; 1392b25b387fSDaniel P. Berrange } 13931cd9a787SDaniel P. Berrange s->crypto = qcrypto_block_open(s->crypto_opts, "encrypt.", 13941cd9a787SDaniel P. Berrange NULL, NULL, cflags, errp); 1395b25b387fSDaniel P. Berrange if (!s->crypto) { 1396b25b387fSDaniel P. Berrange ret = -EINVAL; 1397b25b387fSDaniel P. Berrange goto fail; 1398b25b387fSDaniel P. Berrange } 13994652b8f3SDaniel P. Berrange } else if (!(flags & BDRV_O_NO_IO)) { 14004652b8f3SDaniel P. Berrange error_setg(errp, "Missing CRYPTO header for crypt method %d", 14014652b8f3SDaniel P. Berrange s->crypt_method_header); 14024652b8f3SDaniel P. Berrange ret = -EINVAL; 14034652b8f3SDaniel P. Berrange goto fail; 14044652b8f3SDaniel P. Berrange } 1405b25b387fSDaniel P. Berrange } 1406b25b387fSDaniel P. Berrange 1407585f8587Sbellard /* read the backing file name */ 1408585f8587Sbellard if (header.backing_file_offset != 0) { 1409585f8587Sbellard len = header.backing_file_size; 14109a29e18fSJeff Cody if (len > MIN(1023, s->cluster_size - header.backing_file_offset) || 1411e729fa6aSJeff Cody len >= sizeof(bs->backing_file)) { 14126d33e8e7SKevin Wolf error_setg(errp, "Backing file name too long"); 14136d33e8e7SKevin Wolf ret = -EINVAL; 14146d33e8e7SKevin Wolf goto fail; 14156d85a57eSJes Sorensen } 1416cf2ab8fcSKevin Wolf ret = bdrv_pread(bs->file, header.backing_file_offset, 14176d85a57eSJes Sorensen bs->backing_file, len); 14186d85a57eSJes Sorensen if (ret < 0) { 14193ef6c40aSMax Reitz error_setg_errno(errp, -ret, "Could not read backing file name"); 1420585f8587Sbellard goto fail; 14216d85a57eSJes Sorensen } 1422585f8587Sbellard bs->backing_file[len] = '\0'; 1423e4603fe1SKevin Wolf s->image_backing_file = g_strdup(bs->backing_file); 1424585f8587Sbellard } 142542deb29fSKevin Wolf 142611b128f4SKevin Wolf /* Internal snapshots */ 142711b128f4SKevin Wolf s->snapshots_offset = header.snapshots_offset; 142811b128f4SKevin Wolf s->nb_snapshots = header.nb_snapshots; 142911b128f4SKevin Wolf 143042deb29fSKevin Wolf ret = qcow2_read_snapshots(bs); 143142deb29fSKevin Wolf if (ret < 0) { 14323ef6c40aSMax Reitz error_setg_errno(errp, -ret, "Could not read snapshots"); 1433585f8587Sbellard goto fail; 14346d85a57eSJes Sorensen } 1435585f8587Sbellard 1436af7b708dSStefan Hajnoczi /* Clear unknown autoclear feature bits */ 143788ddffaeSVladimir Sementsov-Ogievskiy update_header |= s->autoclear_features & ~QCOW2_AUTOCLEAR_MASK; 1438d1258dd0SVladimir Sementsov-Ogievskiy update_header = 1439d1258dd0SVladimir Sementsov-Ogievskiy update_header && !bs->read_only && !(flags & BDRV_O_INACTIVE); 1440d1258dd0SVladimir Sementsov-Ogievskiy if (update_header) { 144188ddffaeSVladimir Sementsov-Ogievskiy s->autoclear_features &= QCOW2_AUTOCLEAR_MASK; 1442d1258dd0SVladimir Sementsov-Ogievskiy } 1443d1258dd0SVladimir Sementsov-Ogievskiy 1444d1258dd0SVladimir Sementsov-Ogievskiy if (qcow2_load_autoloading_dirty_bitmaps(bs, &local_err)) { 1445d1258dd0SVladimir Sementsov-Ogievskiy update_header = false; 1446d1258dd0SVladimir Sementsov-Ogievskiy } 1447d1258dd0SVladimir Sementsov-Ogievskiy if (local_err != NULL) { 1448d1258dd0SVladimir Sementsov-Ogievskiy error_propagate(errp, local_err); 1449d1258dd0SVladimir Sementsov-Ogievskiy ret = -EINVAL; 1450d1258dd0SVladimir Sementsov-Ogievskiy goto fail; 1451d1258dd0SVladimir Sementsov-Ogievskiy } 1452d1258dd0SVladimir Sementsov-Ogievskiy 1453d1258dd0SVladimir Sementsov-Ogievskiy if (update_header) { 1454af7b708dSStefan Hajnoczi ret = qcow2_update_header(bs); 1455af7b708dSStefan Hajnoczi if (ret < 0) { 14563ef6c40aSMax Reitz error_setg_errno(errp, -ret, "Could not update qcow2 header"); 1457af7b708dSStefan Hajnoczi goto fail; 1458af7b708dSStefan Hajnoczi } 1459af7b708dSStefan Hajnoczi } 1460af7b708dSStefan Hajnoczi 146168d100e9SKevin Wolf /* Initialise locks */ 146268d100e9SKevin Wolf qemu_co_mutex_init(&s->lock); 1463170f4b2eSFam Zheng bs->supported_zero_flags = BDRV_REQ_MAY_UNMAP; 146468d100e9SKevin Wolf 1465c61d0004SStefan Hajnoczi /* Repair image if dirty */ 146604c01a5cSKevin Wolf if (!(flags & (BDRV_O_CHECK | BDRV_O_INACTIVE)) && !bs->read_only && 1467058f8f16SStefan Hajnoczi (s->incompatible_features & QCOW2_INCOMPAT_DIRTY)) { 1468c61d0004SStefan Hajnoczi BdrvCheckResult result = {0}; 1469c61d0004SStefan Hajnoczi 14705b84106bSMax Reitz ret = qcow2_check(bs, &result, BDRV_FIX_ERRORS | BDRV_FIX_LEAKS); 1471c61d0004SStefan Hajnoczi if (ret < 0) { 14723ef6c40aSMax Reitz error_setg_errno(errp, -ret, "Could not repair dirty image"); 1473c61d0004SStefan Hajnoczi goto fail; 1474c61d0004SStefan Hajnoczi } 1475c61d0004SStefan Hajnoczi } 1476c61d0004SStefan Hajnoczi 1477585f8587Sbellard #ifdef DEBUG_ALLOC 14786cbc3031SPhilipp Hahn { 14796cbc3031SPhilipp Hahn BdrvCheckResult result = {0}; 1480b35278f7SStefan Hajnoczi qcow2_check_refcounts(bs, &result, 0); 14816cbc3031SPhilipp Hahn } 1482585f8587Sbellard #endif 14836d85a57eSJes Sorensen return ret; 1484585f8587Sbellard 1485585f8587Sbellard fail: 14866744cbabSKevin Wolf g_free(s->unknown_header_fields); 148775bab85cSKevin Wolf cleanup_unknown_header_ext(bs); 1488ed6ccf0fSKevin Wolf qcow2_free_snapshots(bs); 1489ed6ccf0fSKevin Wolf qcow2_refcount_close(bs); 1490de82815dSKevin Wolf qemu_vfree(s->l1_table); 1491cf93980eSMax Reitz /* else pre-write overlap checks in cache_destroy may crash */ 1492cf93980eSMax Reitz s->l1_table = NULL; 1493279621c0SAlberto Garcia cache_clean_timer_del(bs); 149429c1a730SKevin Wolf if (s->l2_table_cache) { 149529c1a730SKevin Wolf qcow2_cache_destroy(bs, s->l2_table_cache); 149629c1a730SKevin Wolf } 1497c5a33ee9SPrasad Joshi if (s->refcount_block_cache) { 1498c5a33ee9SPrasad Joshi qcow2_cache_destroy(bs, s->refcount_block_cache); 1499c5a33ee9SPrasad Joshi } 1500b25b387fSDaniel P. Berrange qcrypto_block_free(s->crypto); 1501b25b387fSDaniel P. Berrange qapi_free_QCryptoBlockOpenOptions(s->crypto_opts); 15026d85a57eSJes Sorensen return ret; 1503585f8587Sbellard } 1504585f8587Sbellard 15054e4bf5c4SKevin Wolf static int qcow2_open(BlockDriverState *bs, QDict *options, int flags, 15064e4bf5c4SKevin Wolf Error **errp) 15074e4bf5c4SKevin Wolf { 15084e4bf5c4SKevin Wolf bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file, 15094e4bf5c4SKevin Wolf false, errp); 15104e4bf5c4SKevin Wolf if (!bs->file) { 15114e4bf5c4SKevin Wolf return -EINVAL; 15124e4bf5c4SKevin Wolf } 15134e4bf5c4SKevin Wolf 15144e4bf5c4SKevin Wolf return qcow2_do_open(bs, options, flags, errp); 15154e4bf5c4SKevin Wolf } 15164e4bf5c4SKevin Wolf 15173baca891SKevin Wolf static void qcow2_refresh_limits(BlockDriverState *bs, Error **errp) 1518d34682cdSKevin Wolf { 1519ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 1520d34682cdSKevin Wolf 1521a84178ccSEric Blake if (bs->encrypted) { 1522a84178ccSEric Blake /* Encryption works on a sector granularity */ 1523a5b8dd2cSEric Blake bs->bl.request_alignment = BDRV_SECTOR_SIZE; 1524a84178ccSEric Blake } 1525cf081fcaSEric Blake bs->bl.pwrite_zeroes_alignment = s->cluster_size; 1526ecdbead6SEric Blake bs->bl.pdiscard_alignment = s->cluster_size; 1527d34682cdSKevin Wolf } 1528d34682cdSKevin Wolf 152921d82ac9SJeff Cody static int qcow2_reopen_prepare(BDRVReopenState *state, 153021d82ac9SJeff Cody BlockReopenQueue *queue, Error **errp) 153121d82ac9SJeff Cody { 15325b0959a7SKevin Wolf Qcow2ReopenState *r; 15334c2e5f8fSKevin Wolf int ret; 15344c2e5f8fSKevin Wolf 15355b0959a7SKevin Wolf r = g_new0(Qcow2ReopenState, 1); 15365b0959a7SKevin Wolf state->opaque = r; 15375b0959a7SKevin Wolf 15385b0959a7SKevin Wolf ret = qcow2_update_options_prepare(state->bs, r, state->options, 15395b0959a7SKevin Wolf state->flags, errp); 15405b0959a7SKevin Wolf if (ret < 0) { 15415b0959a7SKevin Wolf goto fail; 15425b0959a7SKevin Wolf } 15435b0959a7SKevin Wolf 15445b0959a7SKevin Wolf /* We need to write out any unwritten data if we reopen read-only. */ 15454c2e5f8fSKevin Wolf if ((state->flags & BDRV_O_RDWR) == 0) { 1546169b8793SVladimir Sementsov-Ogievskiy ret = qcow2_reopen_bitmaps_ro(state->bs, errp); 1547169b8793SVladimir Sementsov-Ogievskiy if (ret < 0) { 1548169b8793SVladimir Sementsov-Ogievskiy goto fail; 1549169b8793SVladimir Sementsov-Ogievskiy } 1550169b8793SVladimir Sementsov-Ogievskiy 15514c2e5f8fSKevin Wolf ret = bdrv_flush(state->bs); 15524c2e5f8fSKevin Wolf if (ret < 0) { 15535b0959a7SKevin Wolf goto fail; 15544c2e5f8fSKevin Wolf } 15554c2e5f8fSKevin Wolf 15564c2e5f8fSKevin Wolf ret = qcow2_mark_clean(state->bs); 15574c2e5f8fSKevin Wolf if (ret < 0) { 15585b0959a7SKevin Wolf goto fail; 15594c2e5f8fSKevin Wolf } 15604c2e5f8fSKevin Wolf } 15614c2e5f8fSKevin Wolf 156221d82ac9SJeff Cody return 0; 15635b0959a7SKevin Wolf 15645b0959a7SKevin Wolf fail: 15655b0959a7SKevin Wolf qcow2_update_options_abort(state->bs, r); 15665b0959a7SKevin Wolf g_free(r); 15675b0959a7SKevin Wolf return ret; 15685b0959a7SKevin Wolf } 15695b0959a7SKevin Wolf 15705b0959a7SKevin Wolf static void qcow2_reopen_commit(BDRVReopenState *state) 15715b0959a7SKevin Wolf { 15725b0959a7SKevin Wolf qcow2_update_options_commit(state->bs, state->opaque); 15735b0959a7SKevin Wolf g_free(state->opaque); 15745b0959a7SKevin Wolf } 15755b0959a7SKevin Wolf 15765b0959a7SKevin Wolf static void qcow2_reopen_abort(BDRVReopenState *state) 15775b0959a7SKevin Wolf { 15785b0959a7SKevin Wolf qcow2_update_options_abort(state->bs, state->opaque); 15795b0959a7SKevin Wolf g_free(state->opaque); 158021d82ac9SJeff Cody } 158121d82ac9SJeff Cody 15825365f44dSKevin Wolf static void qcow2_join_options(QDict *options, QDict *old_options) 15835365f44dSKevin Wolf { 15845365f44dSKevin Wolf bool has_new_overlap_template = 15855365f44dSKevin Wolf qdict_haskey(options, QCOW2_OPT_OVERLAP) || 15865365f44dSKevin Wolf qdict_haskey(options, QCOW2_OPT_OVERLAP_TEMPLATE); 15875365f44dSKevin Wolf bool has_new_total_cache_size = 15885365f44dSKevin Wolf qdict_haskey(options, QCOW2_OPT_CACHE_SIZE); 15895365f44dSKevin Wolf bool has_all_cache_options; 15905365f44dSKevin Wolf 15915365f44dSKevin Wolf /* New overlap template overrides all old overlap options */ 15925365f44dSKevin Wolf if (has_new_overlap_template) { 15935365f44dSKevin Wolf qdict_del(old_options, QCOW2_OPT_OVERLAP); 15945365f44dSKevin Wolf qdict_del(old_options, QCOW2_OPT_OVERLAP_TEMPLATE); 15955365f44dSKevin Wolf qdict_del(old_options, QCOW2_OPT_OVERLAP_MAIN_HEADER); 15965365f44dSKevin Wolf qdict_del(old_options, QCOW2_OPT_OVERLAP_ACTIVE_L1); 15975365f44dSKevin Wolf qdict_del(old_options, QCOW2_OPT_OVERLAP_ACTIVE_L2); 15985365f44dSKevin Wolf qdict_del(old_options, QCOW2_OPT_OVERLAP_REFCOUNT_TABLE); 15995365f44dSKevin Wolf qdict_del(old_options, QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK); 16005365f44dSKevin Wolf qdict_del(old_options, QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE); 16015365f44dSKevin Wolf qdict_del(old_options, QCOW2_OPT_OVERLAP_INACTIVE_L1); 16025365f44dSKevin Wolf qdict_del(old_options, QCOW2_OPT_OVERLAP_INACTIVE_L2); 16035365f44dSKevin Wolf } 16045365f44dSKevin Wolf 16055365f44dSKevin Wolf /* New total cache size overrides all old options */ 16065365f44dSKevin Wolf if (qdict_haskey(options, QCOW2_OPT_CACHE_SIZE)) { 16075365f44dSKevin Wolf qdict_del(old_options, QCOW2_OPT_L2_CACHE_SIZE); 16085365f44dSKevin Wolf qdict_del(old_options, QCOW2_OPT_REFCOUNT_CACHE_SIZE); 16095365f44dSKevin Wolf } 16105365f44dSKevin Wolf 16115365f44dSKevin Wolf qdict_join(options, old_options, false); 16125365f44dSKevin Wolf 16135365f44dSKevin Wolf /* 16145365f44dSKevin Wolf * If after merging all cache size options are set, an old total size is 16155365f44dSKevin Wolf * overwritten. Do keep all options, however, if all three are new. The 16165365f44dSKevin Wolf * resulting error message is what we want to happen. 16175365f44dSKevin Wolf */ 16185365f44dSKevin Wolf has_all_cache_options = 16195365f44dSKevin Wolf qdict_haskey(options, QCOW2_OPT_CACHE_SIZE) || 16205365f44dSKevin Wolf qdict_haskey(options, QCOW2_OPT_L2_CACHE_SIZE) || 16215365f44dSKevin Wolf qdict_haskey(options, QCOW2_OPT_REFCOUNT_CACHE_SIZE); 16225365f44dSKevin Wolf 16235365f44dSKevin Wolf if (has_all_cache_options && !has_new_total_cache_size) { 16245365f44dSKevin Wolf qdict_del(options, QCOW2_OPT_CACHE_SIZE); 16255365f44dSKevin Wolf } 16265365f44dSKevin Wolf } 16275365f44dSKevin Wolf 1628b6b8a333SPaolo Bonzini static int64_t coroutine_fn qcow2_co_get_block_status(BlockDriverState *bs, 162967a0fd2aSFam Zheng int64_t sector_num, int nb_sectors, int *pnum, BlockDriverState **file) 1630585f8587Sbellard { 1631ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 1632585f8587Sbellard uint64_t cluster_offset; 16334bc74be9SPaolo Bonzini int index_in_cluster, ret; 1634ecfe1863SKevin Wolf unsigned int bytes; 16354bc74be9SPaolo Bonzini int64_t status = 0; 1636585f8587Sbellard 1637ecfe1863SKevin Wolf bytes = MIN(INT_MAX, nb_sectors * BDRV_SECTOR_SIZE); 1638f8a2e5e3SStefan Hajnoczi qemu_co_mutex_lock(&s->lock); 1639ecfe1863SKevin Wolf ret = qcow2_get_cluster_offset(bs, sector_num << 9, &bytes, 1640ecfe1863SKevin Wolf &cluster_offset); 1641f8a2e5e3SStefan Hajnoczi qemu_co_mutex_unlock(&s->lock); 16421c46efaaSKevin Wolf if (ret < 0) { 1643d663640cSPaolo Bonzini return ret; 16441c46efaaSKevin Wolf } 1645095a9c58Saliguori 1646ecfe1863SKevin Wolf *pnum = bytes >> BDRV_SECTOR_BITS; 1647ecfe1863SKevin Wolf 16484bc74be9SPaolo Bonzini if (cluster_offset != 0 && ret != QCOW2_CLUSTER_COMPRESSED && 1649b25b387fSDaniel P. Berrange !s->crypto) { 16504bc74be9SPaolo Bonzini index_in_cluster = sector_num & (s->cluster_sectors - 1); 16514bc74be9SPaolo Bonzini cluster_offset |= (index_in_cluster << BDRV_SECTOR_BITS); 1652178b4db7SFam Zheng *file = bs->file->bs; 16534bc74be9SPaolo Bonzini status |= BDRV_BLOCK_OFFSET_VALID | cluster_offset; 16544bc74be9SPaolo Bonzini } 1655fdfab37dSEric Blake if (ret == QCOW2_CLUSTER_ZERO_PLAIN || ret == QCOW2_CLUSTER_ZERO_ALLOC) { 16564bc74be9SPaolo Bonzini status |= BDRV_BLOCK_ZERO; 16574bc74be9SPaolo Bonzini } else if (ret != QCOW2_CLUSTER_UNALLOCATED) { 16584bc74be9SPaolo Bonzini status |= BDRV_BLOCK_DATA; 16594bc74be9SPaolo Bonzini } 16604bc74be9SPaolo Bonzini return status; 1661585f8587Sbellard } 1662585f8587Sbellard 1663a9465922Sbellard /* handle reading after the end of the backing file */ 1664bd28f835SKevin Wolf int qcow2_backing_read1(BlockDriverState *bs, QEMUIOVector *qiov, 1665ecfe1863SKevin Wolf int64_t offset, int bytes) 1666a9465922Sbellard { 1667ecfe1863SKevin Wolf uint64_t bs_size = bs->total_sectors * BDRV_SECTOR_SIZE; 1668a9465922Sbellard int n1; 1669bd28f835SKevin Wolf 1670ecfe1863SKevin Wolf if ((offset + bytes) <= bs_size) { 1671ecfe1863SKevin Wolf return bytes; 1672ecfe1863SKevin Wolf } 1673ecfe1863SKevin Wolf 1674ecfe1863SKevin Wolf if (offset >= bs_size) { 1675ecfe1863SKevin Wolf n1 = 0; 1676ecfe1863SKevin Wolf } else { 1677ecfe1863SKevin Wolf n1 = bs_size - offset; 1678ecfe1863SKevin Wolf } 1679ecfe1863SKevin Wolf 1680ecfe1863SKevin Wolf qemu_iovec_memset(qiov, n1, 0, bytes - n1); 1681bd28f835SKevin Wolf 1682a9465922Sbellard return n1; 1683a9465922Sbellard } 1684a9465922Sbellard 1685ecfe1863SKevin Wolf static coroutine_fn int qcow2_co_preadv(BlockDriverState *bs, uint64_t offset, 1686ecfe1863SKevin Wolf uint64_t bytes, QEMUIOVector *qiov, 1687ecfe1863SKevin Wolf int flags) 16881490791fSaliguori { 1689ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 1690ecfe1863SKevin Wolf int offset_in_cluster, n1; 169168d100e9SKevin Wolf int ret; 1692ecfe1863SKevin Wolf unsigned int cur_bytes; /* number of bytes in current iteration */ 1693c2bdd990SFrediano Ziglio uint64_t cluster_offset = 0; 16943fc48d09SFrediano Ziglio uint64_t bytes_done = 0; 16953fc48d09SFrediano Ziglio QEMUIOVector hd_qiov; 16963fc48d09SFrediano Ziglio uint8_t *cluster_data = NULL; 1697585f8587Sbellard 16983fc48d09SFrediano Ziglio qemu_iovec_init(&hd_qiov, qiov->niov); 16993fc48d09SFrediano Ziglio 17003fc48d09SFrediano Ziglio qemu_co_mutex_lock(&s->lock); 17013fc48d09SFrediano Ziglio 1702ecfe1863SKevin Wolf while (bytes != 0) { 1703585f8587Sbellard 1704faf575c1SFrediano Ziglio /* prepare next request */ 1705ecfe1863SKevin Wolf cur_bytes = MIN(bytes, INT_MAX); 1706b25b387fSDaniel P. Berrange if (s->crypto) { 1707ecfe1863SKevin Wolf cur_bytes = MIN(cur_bytes, 1708ecfe1863SKevin Wolf QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size); 1709bd28f835SKevin Wolf } 1710bd28f835SKevin Wolf 1711ecfe1863SKevin Wolf ret = qcow2_get_cluster_offset(bs, offset, &cur_bytes, &cluster_offset); 17121c46efaaSKevin Wolf if (ret < 0) { 17133fc48d09SFrediano Ziglio goto fail; 17141c46efaaSKevin Wolf } 17151c46efaaSKevin Wolf 1716ecfe1863SKevin Wolf offset_in_cluster = offset_into_cluster(s, offset); 1717585f8587Sbellard 17183fc48d09SFrediano Ziglio qemu_iovec_reset(&hd_qiov); 1719ecfe1863SKevin Wolf qemu_iovec_concat(&hd_qiov, qiov, bytes_done, cur_bytes); 1720bd28f835SKevin Wolf 172168d000a3SKevin Wolf switch (ret) { 172268d000a3SKevin Wolf case QCOW2_CLUSTER_UNALLOCATED: 1723bd28f835SKevin Wolf 1724760e0063SKevin Wolf if (bs->backing) { 1725585f8587Sbellard /* read from the base image */ 1726760e0063SKevin Wolf n1 = qcow2_backing_read1(bs->backing->bs, &hd_qiov, 1727ecfe1863SKevin Wolf offset, cur_bytes); 1728a9465922Sbellard if (n1 > 0) { 172944deba5aSKevin Wolf QEMUIOVector local_qiov; 173044deba5aSKevin Wolf 173144deba5aSKevin Wolf qemu_iovec_init(&local_qiov, hd_qiov.niov); 1732ecfe1863SKevin Wolf qemu_iovec_concat(&local_qiov, &hd_qiov, 0, n1); 173344deba5aSKevin Wolf 173466f82ceeSKevin Wolf BLKDBG_EVENT(bs->file, BLKDBG_READ_BACKING_AIO); 173568d100e9SKevin Wolf qemu_co_mutex_unlock(&s->lock); 1736a03ef88fSKevin Wolf ret = bdrv_co_preadv(bs->backing, offset, n1, 1737ecfe1863SKevin Wolf &local_qiov, 0); 173868d100e9SKevin Wolf qemu_co_mutex_lock(&s->lock); 173944deba5aSKevin Wolf 174044deba5aSKevin Wolf qemu_iovec_destroy(&local_qiov); 174144deba5aSKevin Wolf 174268d100e9SKevin Wolf if (ret < 0) { 17433fc48d09SFrediano Ziglio goto fail; 17443ab4c7e9SKevin Wolf } 17451490791fSaliguori } 1746a9465922Sbellard } else { 1747585f8587Sbellard /* Note: in this case, no need to wait */ 1748ecfe1863SKevin Wolf qemu_iovec_memset(&hd_qiov, 0, 0, cur_bytes); 17491490791fSaliguori } 175068d000a3SKevin Wolf break; 175168d000a3SKevin Wolf 1752fdfab37dSEric Blake case QCOW2_CLUSTER_ZERO_PLAIN: 1753fdfab37dSEric Blake case QCOW2_CLUSTER_ZERO_ALLOC: 1754ecfe1863SKevin Wolf qemu_iovec_memset(&hd_qiov, 0, 0, cur_bytes); 17556377af48SKevin Wolf break; 17566377af48SKevin Wolf 175768d000a3SKevin Wolf case QCOW2_CLUSTER_COMPRESSED: 1758585f8587Sbellard /* add AIO support for compressed blocks ? */ 1759c2bdd990SFrediano Ziglio ret = qcow2_decompress_cluster(bs, cluster_offset); 17608af36488SKevin Wolf if (ret < 0) { 17613fc48d09SFrediano Ziglio goto fail; 17628af36488SKevin Wolf } 1763bd28f835SKevin Wolf 176403396148SMichael Tokarev qemu_iovec_from_buf(&hd_qiov, 0, 1765ecfe1863SKevin Wolf s->cluster_cache + offset_in_cluster, 1766ecfe1863SKevin Wolf cur_bytes); 176768d000a3SKevin Wolf break; 176868d000a3SKevin Wolf 176968d000a3SKevin Wolf case QCOW2_CLUSTER_NORMAL: 1770c2bdd990SFrediano Ziglio if ((cluster_offset & 511) != 0) { 17713fc48d09SFrediano Ziglio ret = -EIO; 17723fc48d09SFrediano Ziglio goto fail; 1773585f8587Sbellard } 1774c87c0672Saliguori 17758336aafaSDaniel P. Berrange if (bs->encrypted) { 1776b25b387fSDaniel P. Berrange assert(s->crypto); 17778336aafaSDaniel P. Berrange 1778bd28f835SKevin Wolf /* 1779bd28f835SKevin Wolf * For encrypted images, read everything into a temporary 1780bd28f835SKevin Wolf * contiguous buffer on which the AES functions can work. 1781bd28f835SKevin Wolf */ 17823fc48d09SFrediano Ziglio if (!cluster_data) { 17833fc48d09SFrediano Ziglio cluster_data = 17849a4f4c31SKevin Wolf qemu_try_blockalign(bs->file->bs, 17859a4f4c31SKevin Wolf QCOW_MAX_CRYPT_CLUSTERS 1786de82815dSKevin Wolf * s->cluster_size); 1787de82815dSKevin Wolf if (cluster_data == NULL) { 1788de82815dSKevin Wolf ret = -ENOMEM; 1789de82815dSKevin Wolf goto fail; 1790de82815dSKevin Wolf } 1791bd28f835SKevin Wolf } 1792bd28f835SKevin Wolf 1793ecfe1863SKevin Wolf assert(cur_bytes <= QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size); 17943fc48d09SFrediano Ziglio qemu_iovec_reset(&hd_qiov); 1795ecfe1863SKevin Wolf qemu_iovec_add(&hd_qiov, cluster_data, cur_bytes); 1796bd28f835SKevin Wolf } 1797bd28f835SKevin Wolf 179866f82ceeSKevin Wolf BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO); 179968d100e9SKevin Wolf qemu_co_mutex_unlock(&s->lock); 1800a03ef88fSKevin Wolf ret = bdrv_co_preadv(bs->file, 1801ecfe1863SKevin Wolf cluster_offset + offset_in_cluster, 1802ecfe1863SKevin Wolf cur_bytes, &hd_qiov, 0); 180368d100e9SKevin Wolf qemu_co_mutex_lock(&s->lock); 180468d100e9SKevin Wolf if (ret < 0) { 18053fc48d09SFrediano Ziglio goto fail; 1806585f8587Sbellard } 18078336aafaSDaniel P. Berrange if (bs->encrypted) { 1808b25b387fSDaniel P. Berrange assert(s->crypto); 1809ecfe1863SKevin Wolf assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0); 1810ecfe1863SKevin Wolf assert((cur_bytes & (BDRV_SECTOR_SIZE - 1)) == 0); 1811b25b387fSDaniel P. Berrange if (qcrypto_block_decrypt(s->crypto, 18124652b8f3SDaniel P. Berrange (s->crypt_physical_offset ? 18134652b8f3SDaniel P. Berrange cluster_offset + offset_in_cluster : 18144609742aSDaniel P. Berrange offset), 1815446d306dSDaniel P. Berrange cluster_data, 1816b25b387fSDaniel P. Berrange cur_bytes, 1817c3a8fe33SAlberto Garcia NULL) < 0) { 1818f6fa64f6SDaniel P. Berrange ret = -EIO; 1819f6fa64f6SDaniel P. Berrange goto fail; 1820f6fa64f6SDaniel P. Berrange } 1821ecfe1863SKevin Wolf qemu_iovec_from_buf(qiov, bytes_done, cluster_data, cur_bytes); 1822171e3d6bSKevin Wolf } 182368d000a3SKevin Wolf break; 182468d000a3SKevin Wolf 182568d000a3SKevin Wolf default: 182668d000a3SKevin Wolf g_assert_not_reached(); 182768d000a3SKevin Wolf ret = -EIO; 182868d000a3SKevin Wolf goto fail; 1829faf575c1SFrediano Ziglio } 1830faf575c1SFrediano Ziglio 1831ecfe1863SKevin Wolf bytes -= cur_bytes; 1832ecfe1863SKevin Wolf offset += cur_bytes; 1833ecfe1863SKevin Wolf bytes_done += cur_bytes; 18345ebaa27eSFrediano Ziglio } 18353fc48d09SFrediano Ziglio ret = 0; 1836f141eafeSaliguori 18373fc48d09SFrediano Ziglio fail: 183868d100e9SKevin Wolf qemu_co_mutex_unlock(&s->lock); 183968d100e9SKevin Wolf 18403fc48d09SFrediano Ziglio qemu_iovec_destroy(&hd_qiov); 1841dea43a65SFrediano Ziglio qemu_vfree(cluster_data); 184268d100e9SKevin Wolf 184368d100e9SKevin Wolf return ret; 1844585f8587Sbellard } 1845585f8587Sbellard 1846ee22a9d8SAlberto Garcia /* Check if it's possible to merge a write request with the writing of 1847ee22a9d8SAlberto Garcia * the data from the COW regions */ 1848ee22a9d8SAlberto Garcia static bool merge_cow(uint64_t offset, unsigned bytes, 1849ee22a9d8SAlberto Garcia QEMUIOVector *hd_qiov, QCowL2Meta *l2meta) 1850ee22a9d8SAlberto Garcia { 1851ee22a9d8SAlberto Garcia QCowL2Meta *m; 1852ee22a9d8SAlberto Garcia 1853ee22a9d8SAlberto Garcia for (m = l2meta; m != NULL; m = m->next) { 1854ee22a9d8SAlberto Garcia /* If both COW regions are empty then there's nothing to merge */ 1855ee22a9d8SAlberto Garcia if (m->cow_start.nb_bytes == 0 && m->cow_end.nb_bytes == 0) { 1856ee22a9d8SAlberto Garcia continue; 1857ee22a9d8SAlberto Garcia } 1858ee22a9d8SAlberto Garcia 1859ee22a9d8SAlberto Garcia /* The data (middle) region must be immediately after the 1860ee22a9d8SAlberto Garcia * start region */ 1861ee22a9d8SAlberto Garcia if (l2meta_cow_start(m) + m->cow_start.nb_bytes != offset) { 1862ee22a9d8SAlberto Garcia continue; 1863ee22a9d8SAlberto Garcia } 1864ee22a9d8SAlberto Garcia 1865ee22a9d8SAlberto Garcia /* The end region must be immediately after the data (middle) 1866ee22a9d8SAlberto Garcia * region */ 1867ee22a9d8SAlberto Garcia if (m->offset + m->cow_end.offset != offset + bytes) { 1868ee22a9d8SAlberto Garcia continue; 1869ee22a9d8SAlberto Garcia } 1870ee22a9d8SAlberto Garcia 1871ee22a9d8SAlberto Garcia /* Make sure that adding both COW regions to the QEMUIOVector 1872ee22a9d8SAlberto Garcia * does not exceed IOV_MAX */ 1873ee22a9d8SAlberto Garcia if (hd_qiov->niov > IOV_MAX - 2) { 1874ee22a9d8SAlberto Garcia continue; 1875ee22a9d8SAlberto Garcia } 1876ee22a9d8SAlberto Garcia 1877ee22a9d8SAlberto Garcia m->data_qiov = hd_qiov; 1878ee22a9d8SAlberto Garcia return true; 1879ee22a9d8SAlberto Garcia } 1880ee22a9d8SAlberto Garcia 1881ee22a9d8SAlberto Garcia return false; 1882ee22a9d8SAlberto Garcia } 1883ee22a9d8SAlberto Garcia 1884d46a0bb2SKevin Wolf static coroutine_fn int qcow2_co_pwritev(BlockDriverState *bs, uint64_t offset, 1885d46a0bb2SKevin Wolf uint64_t bytes, QEMUIOVector *qiov, 1886d46a0bb2SKevin Wolf int flags) 1887585f8587Sbellard { 1888ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 1889d46a0bb2SKevin Wolf int offset_in_cluster; 189068d100e9SKevin Wolf int ret; 1891d46a0bb2SKevin Wolf unsigned int cur_bytes; /* number of sectors in current iteration */ 1892c2bdd990SFrediano Ziglio uint64_t cluster_offset; 18933fc48d09SFrediano Ziglio QEMUIOVector hd_qiov; 18943fc48d09SFrediano Ziglio uint64_t bytes_done = 0; 18953fc48d09SFrediano Ziglio uint8_t *cluster_data = NULL; 18968d2497c3SKevin Wolf QCowL2Meta *l2meta = NULL; 1897c2271403SFrediano Ziglio 1898d46a0bb2SKevin Wolf trace_qcow2_writev_start_req(qemu_coroutine_self(), offset, bytes); 18993cce16f4SKevin Wolf 19003fc48d09SFrediano Ziglio qemu_iovec_init(&hd_qiov, qiov->niov); 1901585f8587Sbellard 19023fc48d09SFrediano Ziglio s->cluster_cache_offset = -1; /* disable compressed cache */ 19033fc48d09SFrediano Ziglio 19043fc48d09SFrediano Ziglio qemu_co_mutex_lock(&s->lock); 19053fc48d09SFrediano Ziglio 1906d46a0bb2SKevin Wolf while (bytes != 0) { 19073fc48d09SFrediano Ziglio 1908f50f88b9SKevin Wolf l2meta = NULL; 1909cf5c1a23SKevin Wolf 19103cce16f4SKevin Wolf trace_qcow2_writev_start_part(qemu_coroutine_self()); 1911d46a0bb2SKevin Wolf offset_in_cluster = offset_into_cluster(s, offset); 1912d46a0bb2SKevin Wolf cur_bytes = MIN(bytes, INT_MAX); 1913d46a0bb2SKevin Wolf if (bs->encrypted) { 1914d46a0bb2SKevin Wolf cur_bytes = MIN(cur_bytes, 1915d46a0bb2SKevin Wolf QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size 1916d46a0bb2SKevin Wolf - offset_in_cluster); 19175ebaa27eSFrediano Ziglio } 1918095a9c58Saliguori 1919d46a0bb2SKevin Wolf ret = qcow2_alloc_cluster_offset(bs, offset, &cur_bytes, 1920d46a0bb2SKevin Wolf &cluster_offset, &l2meta); 1921148da7eaSKevin Wolf if (ret < 0) { 19223fc48d09SFrediano Ziglio goto fail; 1923148da7eaSKevin Wolf } 1924148da7eaSKevin Wolf 1925c2bdd990SFrediano Ziglio assert((cluster_offset & 511) == 0); 1926148da7eaSKevin Wolf 19273fc48d09SFrediano Ziglio qemu_iovec_reset(&hd_qiov); 1928d46a0bb2SKevin Wolf qemu_iovec_concat(&hd_qiov, qiov, bytes_done, cur_bytes); 19296f5f060bSKevin Wolf 19308336aafaSDaniel P. Berrange if (bs->encrypted) { 1931b25b387fSDaniel P. Berrange assert(s->crypto); 19323fc48d09SFrediano Ziglio if (!cluster_data) { 19339a4f4c31SKevin Wolf cluster_data = qemu_try_blockalign(bs->file->bs, 1934de82815dSKevin Wolf QCOW_MAX_CRYPT_CLUSTERS 1935de82815dSKevin Wolf * s->cluster_size); 1936de82815dSKevin Wolf if (cluster_data == NULL) { 1937de82815dSKevin Wolf ret = -ENOMEM; 1938de82815dSKevin Wolf goto fail; 1939de82815dSKevin Wolf } 1940585f8587Sbellard } 19416f5f060bSKevin Wolf 19423fc48d09SFrediano Ziglio assert(hd_qiov.size <= 19435ebaa27eSFrediano Ziglio QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size); 1944d5e6b161SMichael Tokarev qemu_iovec_to_buf(&hd_qiov, 0, cluster_data, hd_qiov.size); 19456f5f060bSKevin Wolf 19464652b8f3SDaniel P. Berrange if (qcrypto_block_encrypt(s->crypto, 19474652b8f3SDaniel P. Berrange (s->crypt_physical_offset ? 19484652b8f3SDaniel P. Berrange cluster_offset + offset_in_cluster : 19494609742aSDaniel P. Berrange offset), 1950446d306dSDaniel P. Berrange cluster_data, 1951c3a8fe33SAlberto Garcia cur_bytes, NULL) < 0) { 1952f6fa64f6SDaniel P. Berrange ret = -EIO; 1953f6fa64f6SDaniel P. Berrange goto fail; 1954f6fa64f6SDaniel P. Berrange } 19556f5f060bSKevin Wolf 19563fc48d09SFrediano Ziglio qemu_iovec_reset(&hd_qiov); 1957d46a0bb2SKevin Wolf qemu_iovec_add(&hd_qiov, cluster_data, cur_bytes); 1958585f8587Sbellard } 19596f5f060bSKevin Wolf 1960231bb267SMax Reitz ret = qcow2_pre_write_overlap_check(bs, 0, 1961d46a0bb2SKevin Wolf cluster_offset + offset_in_cluster, cur_bytes); 1962cf93980eSMax Reitz if (ret < 0) { 1963cf93980eSMax Reitz goto fail; 1964cf93980eSMax Reitz } 1965cf93980eSMax Reitz 1966ee22a9d8SAlberto Garcia /* If we need to do COW, check if it's possible to merge the 1967ee22a9d8SAlberto Garcia * writing of the guest data together with that of the COW regions. 1968ee22a9d8SAlberto Garcia * If it's not possible (or not necessary) then write the 1969ee22a9d8SAlberto Garcia * guest data now. */ 1970ee22a9d8SAlberto Garcia if (!merge_cow(offset, cur_bytes, &hd_qiov, l2meta)) { 197168d100e9SKevin Wolf qemu_co_mutex_unlock(&s->lock); 197267a7a0ebSKevin Wolf BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO); 19733cce16f4SKevin Wolf trace_qcow2_writev_data(qemu_coroutine_self(), 1974d46a0bb2SKevin Wolf cluster_offset + offset_in_cluster); 1975a03ef88fSKevin Wolf ret = bdrv_co_pwritev(bs->file, 1976d46a0bb2SKevin Wolf cluster_offset + offset_in_cluster, 1977d46a0bb2SKevin Wolf cur_bytes, &hd_qiov, 0); 197868d100e9SKevin Wolf qemu_co_mutex_lock(&s->lock); 197968d100e9SKevin Wolf if (ret < 0) { 19803fc48d09SFrediano Ziglio goto fail; 1981171e3d6bSKevin Wolf } 1982ee22a9d8SAlberto Garcia } 1983f141eafeSaliguori 198488c6588cSKevin Wolf while (l2meta != NULL) { 198588c6588cSKevin Wolf QCowL2Meta *next; 198688c6588cSKevin Wolf 1987cf5c1a23SKevin Wolf ret = qcow2_alloc_cluster_link_l2(bs, l2meta); 1988faf575c1SFrediano Ziglio if (ret < 0) { 19893fc48d09SFrediano Ziglio goto fail; 1990faf575c1SFrediano Ziglio } 1991faf575c1SFrediano Ziglio 19924e95314eSKevin Wolf /* Take the request off the list of running requests */ 19934e95314eSKevin Wolf if (l2meta->nb_clusters != 0) { 19944e95314eSKevin Wolf QLIST_REMOVE(l2meta, next_in_flight); 19954e95314eSKevin Wolf } 19964e95314eSKevin Wolf 19974e95314eSKevin Wolf qemu_co_queue_restart_all(&l2meta->dependent_requests); 19984e95314eSKevin Wolf 199988c6588cSKevin Wolf next = l2meta->next; 2000cf5c1a23SKevin Wolf g_free(l2meta); 200188c6588cSKevin Wolf l2meta = next; 2002f50f88b9SKevin Wolf } 20030fa9131aSKevin Wolf 2004d46a0bb2SKevin Wolf bytes -= cur_bytes; 2005d46a0bb2SKevin Wolf offset += cur_bytes; 2006d46a0bb2SKevin Wolf bytes_done += cur_bytes; 2007d46a0bb2SKevin Wolf trace_qcow2_writev_done_part(qemu_coroutine_self(), cur_bytes); 20085ebaa27eSFrediano Ziglio } 20093fc48d09SFrediano Ziglio ret = 0; 2010faf575c1SFrediano Ziglio 20113fc48d09SFrediano Ziglio fail: 201288c6588cSKevin Wolf while (l2meta != NULL) { 201388c6588cSKevin Wolf QCowL2Meta *next; 201488c6588cSKevin Wolf 20154e95314eSKevin Wolf if (l2meta->nb_clusters != 0) { 20164e95314eSKevin Wolf QLIST_REMOVE(l2meta, next_in_flight); 20174e95314eSKevin Wolf } 20184e95314eSKevin Wolf qemu_co_queue_restart_all(&l2meta->dependent_requests); 201988c6588cSKevin Wolf 202088c6588cSKevin Wolf next = l2meta->next; 2021cf5c1a23SKevin Wolf g_free(l2meta); 202288c6588cSKevin Wolf l2meta = next; 2023cf5c1a23SKevin Wolf } 20240fa9131aSKevin Wolf 2025a8c57408SPaolo Bonzini qemu_co_mutex_unlock(&s->lock); 2026a8c57408SPaolo Bonzini 20273fc48d09SFrediano Ziglio qemu_iovec_destroy(&hd_qiov); 2028dea43a65SFrediano Ziglio qemu_vfree(cluster_data); 20293cce16f4SKevin Wolf trace_qcow2_writev_done_req(qemu_coroutine_self(), ret); 203042496d62SKevin Wolf 203168d100e9SKevin Wolf return ret; 2032585f8587Sbellard } 2033585f8587Sbellard 2034ec6d8912SKevin Wolf static int qcow2_inactivate(BlockDriverState *bs) 2035ec6d8912SKevin Wolf { 2036ec6d8912SKevin Wolf BDRVQcow2State *s = bs->opaque; 2037ec6d8912SKevin Wolf int ret, result = 0; 20385f72826eSVladimir Sementsov-Ogievskiy Error *local_err = NULL; 2039ec6d8912SKevin Wolf 204083a8c775SPavel Butsykin qcow2_store_persistent_dirty_bitmaps(bs, &local_err); 204183a8c775SPavel Butsykin if (local_err != NULL) { 204283a8c775SPavel Butsykin result = -EINVAL; 204383a8c775SPavel Butsykin error_report_err(local_err); 204483a8c775SPavel Butsykin error_report("Persistent bitmaps are lost for node '%s'", 204583a8c775SPavel Butsykin bdrv_get_device_or_node_name(bs)); 204683a8c775SPavel Butsykin } 204783a8c775SPavel Butsykin 2048ec6d8912SKevin Wolf ret = qcow2_cache_flush(bs, s->l2_table_cache); 2049ec6d8912SKevin Wolf if (ret) { 2050ec6d8912SKevin Wolf result = ret; 2051ec6d8912SKevin Wolf error_report("Failed to flush the L2 table cache: %s", 2052ec6d8912SKevin Wolf strerror(-ret)); 2053ec6d8912SKevin Wolf } 2054ec6d8912SKevin Wolf 2055ec6d8912SKevin Wolf ret = qcow2_cache_flush(bs, s->refcount_block_cache); 2056ec6d8912SKevin Wolf if (ret) { 2057ec6d8912SKevin Wolf result = ret; 2058ec6d8912SKevin Wolf error_report("Failed to flush the refcount block cache: %s", 2059ec6d8912SKevin Wolf strerror(-ret)); 2060ec6d8912SKevin Wolf } 2061ec6d8912SKevin Wolf 2062ec6d8912SKevin Wolf if (result == 0) { 2063ec6d8912SKevin Wolf qcow2_mark_clean(bs); 2064ec6d8912SKevin Wolf } 2065ec6d8912SKevin Wolf 2066ec6d8912SKevin Wolf return result; 2067ec6d8912SKevin Wolf } 2068ec6d8912SKevin Wolf 20697c80ab3fSJes Sorensen static void qcow2_close(BlockDriverState *bs) 2070585f8587Sbellard { 2071ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 2072de82815dSKevin Wolf qemu_vfree(s->l1_table); 2073cf93980eSMax Reitz /* else pre-write overlap checks in cache_destroy may crash */ 2074cf93980eSMax Reitz s->l1_table = NULL; 207529c1a730SKevin Wolf 2076140fd5a6SKevin Wolf if (!(s->flags & BDRV_O_INACTIVE)) { 2077ec6d8912SKevin Wolf qcow2_inactivate(bs); 20783b5e14c7SMax Reitz } 2079c61d0004SStefan Hajnoczi 2080279621c0SAlberto Garcia cache_clean_timer_del(bs); 208129c1a730SKevin Wolf qcow2_cache_destroy(bs, s->l2_table_cache); 208229c1a730SKevin Wolf qcow2_cache_destroy(bs, s->refcount_block_cache); 208329c1a730SKevin Wolf 2084b25b387fSDaniel P. Berrange qcrypto_block_free(s->crypto); 2085b25b387fSDaniel P. Berrange s->crypto = NULL; 2086f6fa64f6SDaniel P. Berrange 20876744cbabSKevin Wolf g_free(s->unknown_header_fields); 208875bab85cSKevin Wolf cleanup_unknown_header_ext(bs); 20896744cbabSKevin Wolf 2090e4603fe1SKevin Wolf g_free(s->image_backing_file); 2091e4603fe1SKevin Wolf g_free(s->image_backing_format); 2092e4603fe1SKevin Wolf 20937267c094SAnthony Liguori g_free(s->cluster_cache); 2094dea43a65SFrediano Ziglio qemu_vfree(s->cluster_data); 2095ed6ccf0fSKevin Wolf qcow2_refcount_close(bs); 209628c1202bSLi Zhi Hui qcow2_free_snapshots(bs); 2097585f8587Sbellard } 2098585f8587Sbellard 20995a8a30dbSKevin Wolf static void qcow2_invalidate_cache(BlockDriverState *bs, Error **errp) 210006d9260fSAnthony Liguori { 2101ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 210206d9260fSAnthony Liguori int flags = s->flags; 2103b25b387fSDaniel P. Berrange QCryptoBlock *crypto = NULL; 2104acdfb480SKevin Wolf QDict *options; 21055a8a30dbSKevin Wolf Error *local_err = NULL; 21065a8a30dbSKevin Wolf int ret; 210706d9260fSAnthony Liguori 210806d9260fSAnthony Liguori /* 210906d9260fSAnthony Liguori * Backing files are read-only which makes all of their metadata immutable, 211006d9260fSAnthony Liguori * that means we don't have to worry about reopening them here. 211106d9260fSAnthony Liguori */ 211206d9260fSAnthony Liguori 2113b25b387fSDaniel P. Berrange crypto = s->crypto; 2114b25b387fSDaniel P. Berrange s->crypto = NULL; 211506d9260fSAnthony Liguori 211606d9260fSAnthony Liguori qcow2_close(bs); 211706d9260fSAnthony Liguori 2118ff99129aSKevin Wolf memset(s, 0, sizeof(BDRVQcow2State)); 2119d475e5acSKevin Wolf options = qdict_clone_shallow(bs->options); 21205a8a30dbSKevin Wolf 2121140fd5a6SKevin Wolf flags &= ~BDRV_O_INACTIVE; 21224e4bf5c4SKevin Wolf ret = qcow2_do_open(bs, options, flags, &local_err); 2123a1904e48SMarkus Armbruster QDECREF(options); 21245a8a30dbSKevin Wolf if (local_err) { 2125e43bfd9cSMarkus Armbruster error_propagate(errp, local_err); 2126e43bfd9cSMarkus Armbruster error_prepend(errp, "Could not reopen qcow2 layer: "); 2127191fb11bSKevin Wolf bs->drv = NULL; 21285a8a30dbSKevin Wolf return; 21295a8a30dbSKevin Wolf } else if (ret < 0) { 21305a8a30dbSKevin Wolf error_setg_errno(errp, -ret, "Could not reopen qcow2 layer"); 2131191fb11bSKevin Wolf bs->drv = NULL; 21325a8a30dbSKevin Wolf return; 21335a8a30dbSKevin Wolf } 2134acdfb480SKevin Wolf 2135b25b387fSDaniel P. Berrange s->crypto = crypto; 213606d9260fSAnthony Liguori } 213706d9260fSAnthony Liguori 2138e24e49e6SKevin Wolf static size_t header_ext_add(char *buf, uint32_t magic, const void *s, 2139e24e49e6SKevin Wolf size_t len, size_t buflen) 2140756e6736SKevin Wolf { 2141e24e49e6SKevin Wolf QCowExtension *ext_backing_fmt = (QCowExtension*) buf; 2142e24e49e6SKevin Wolf size_t ext_len = sizeof(QCowExtension) + ((len + 7) & ~7); 2143756e6736SKevin Wolf 2144e24e49e6SKevin Wolf if (buflen < ext_len) { 2145756e6736SKevin Wolf return -ENOSPC; 2146756e6736SKevin Wolf } 2147756e6736SKevin Wolf 2148e24e49e6SKevin Wolf *ext_backing_fmt = (QCowExtension) { 2149e24e49e6SKevin Wolf .magic = cpu_to_be32(magic), 2150e24e49e6SKevin Wolf .len = cpu_to_be32(len), 2151e24e49e6SKevin Wolf }; 21520647d47cSStefan Hajnoczi 21530647d47cSStefan Hajnoczi if (len) { 2154e24e49e6SKevin Wolf memcpy(buf + sizeof(QCowExtension), s, len); 21550647d47cSStefan Hajnoczi } 2156756e6736SKevin Wolf 2157e24e49e6SKevin Wolf return ext_len; 2158756e6736SKevin Wolf } 2159756e6736SKevin Wolf 2160e24e49e6SKevin Wolf /* 2161e24e49e6SKevin Wolf * Updates the qcow2 header, including the variable length parts of it, i.e. 2162e24e49e6SKevin Wolf * the backing file name and all extensions. qcow2 was not designed to allow 2163e24e49e6SKevin Wolf * such changes, so if we run out of space (we can only use the first cluster) 2164e24e49e6SKevin Wolf * this function may fail. 2165e24e49e6SKevin Wolf * 2166e24e49e6SKevin Wolf * Returns 0 on success, -errno in error cases. 2167e24e49e6SKevin Wolf */ 2168e24e49e6SKevin Wolf int qcow2_update_header(BlockDriverState *bs) 2169e24e49e6SKevin Wolf { 2170ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 2171e24e49e6SKevin Wolf QCowHeader *header; 2172e24e49e6SKevin Wolf char *buf; 2173e24e49e6SKevin Wolf size_t buflen = s->cluster_size; 2174e24e49e6SKevin Wolf int ret; 2175e24e49e6SKevin Wolf uint64_t total_size; 2176e24e49e6SKevin Wolf uint32_t refcount_table_clusters; 21776744cbabSKevin Wolf size_t header_length; 217875bab85cSKevin Wolf Qcow2UnknownHeaderExtension *uext; 2179e24e49e6SKevin Wolf 2180e24e49e6SKevin Wolf buf = qemu_blockalign(bs, buflen); 2181e24e49e6SKevin Wolf 2182e24e49e6SKevin Wolf /* Header structure */ 2183e24e49e6SKevin Wolf header = (QCowHeader*) buf; 2184e24e49e6SKevin Wolf 2185e24e49e6SKevin Wolf if (buflen < sizeof(*header)) { 2186e24e49e6SKevin Wolf ret = -ENOSPC; 2187e24e49e6SKevin Wolf goto fail; 2188756e6736SKevin Wolf } 2189756e6736SKevin Wolf 21906744cbabSKevin Wolf header_length = sizeof(*header) + s->unknown_header_fields_size; 2191e24e49e6SKevin Wolf total_size = bs->total_sectors * BDRV_SECTOR_SIZE; 2192e24e49e6SKevin Wolf refcount_table_clusters = s->refcount_table_size >> (s->cluster_bits - 3); 2193e24e49e6SKevin Wolf 2194e24e49e6SKevin Wolf *header = (QCowHeader) { 21956744cbabSKevin Wolf /* Version 2 fields */ 2196e24e49e6SKevin Wolf .magic = cpu_to_be32(QCOW_MAGIC), 21976744cbabSKevin Wolf .version = cpu_to_be32(s->qcow_version), 2198e24e49e6SKevin Wolf .backing_file_offset = 0, 2199e24e49e6SKevin Wolf .backing_file_size = 0, 2200e24e49e6SKevin Wolf .cluster_bits = cpu_to_be32(s->cluster_bits), 2201e24e49e6SKevin Wolf .size = cpu_to_be64(total_size), 2202e24e49e6SKevin Wolf .crypt_method = cpu_to_be32(s->crypt_method_header), 2203e24e49e6SKevin Wolf .l1_size = cpu_to_be32(s->l1_size), 2204e24e49e6SKevin Wolf .l1_table_offset = cpu_to_be64(s->l1_table_offset), 2205e24e49e6SKevin Wolf .refcount_table_offset = cpu_to_be64(s->refcount_table_offset), 2206e24e49e6SKevin Wolf .refcount_table_clusters = cpu_to_be32(refcount_table_clusters), 2207e24e49e6SKevin Wolf .nb_snapshots = cpu_to_be32(s->nb_snapshots), 2208e24e49e6SKevin Wolf .snapshots_offset = cpu_to_be64(s->snapshots_offset), 22096744cbabSKevin Wolf 22106744cbabSKevin Wolf /* Version 3 fields */ 22116744cbabSKevin Wolf .incompatible_features = cpu_to_be64(s->incompatible_features), 22126744cbabSKevin Wolf .compatible_features = cpu_to_be64(s->compatible_features), 22136744cbabSKevin Wolf .autoclear_features = cpu_to_be64(s->autoclear_features), 2214b6481f37SMax Reitz .refcount_order = cpu_to_be32(s->refcount_order), 22156744cbabSKevin Wolf .header_length = cpu_to_be32(header_length), 2216e24e49e6SKevin Wolf }; 2217e24e49e6SKevin Wolf 22186744cbabSKevin Wolf /* For older versions, write a shorter header */ 22196744cbabSKevin Wolf switch (s->qcow_version) { 22206744cbabSKevin Wolf case 2: 22216744cbabSKevin Wolf ret = offsetof(QCowHeader, incompatible_features); 22226744cbabSKevin Wolf break; 22236744cbabSKevin Wolf case 3: 22246744cbabSKevin Wolf ret = sizeof(*header); 22256744cbabSKevin Wolf break; 22266744cbabSKevin Wolf default: 2227b6c14762SJim Meyering ret = -EINVAL; 2228b6c14762SJim Meyering goto fail; 22296744cbabSKevin Wolf } 22306744cbabSKevin Wolf 22316744cbabSKevin Wolf buf += ret; 22326744cbabSKevin Wolf buflen -= ret; 22336744cbabSKevin Wolf memset(buf, 0, buflen); 22346744cbabSKevin Wolf 22356744cbabSKevin Wolf /* Preserve any unknown field in the header */ 22366744cbabSKevin Wolf if (s->unknown_header_fields_size) { 22376744cbabSKevin Wolf if (buflen < s->unknown_header_fields_size) { 22386744cbabSKevin Wolf ret = -ENOSPC; 22396744cbabSKevin Wolf goto fail; 22406744cbabSKevin Wolf } 22416744cbabSKevin Wolf 22426744cbabSKevin Wolf memcpy(buf, s->unknown_header_fields, s->unknown_header_fields_size); 22436744cbabSKevin Wolf buf += s->unknown_header_fields_size; 22446744cbabSKevin Wolf buflen -= s->unknown_header_fields_size; 22456744cbabSKevin Wolf } 2246e24e49e6SKevin Wolf 2247e24e49e6SKevin Wolf /* Backing file format header extension */ 2248e4603fe1SKevin Wolf if (s->image_backing_format) { 2249e24e49e6SKevin Wolf ret = header_ext_add(buf, QCOW2_EXT_MAGIC_BACKING_FORMAT, 2250e4603fe1SKevin Wolf s->image_backing_format, 2251e4603fe1SKevin Wolf strlen(s->image_backing_format), 2252e24e49e6SKevin Wolf buflen); 2253756e6736SKevin Wolf if (ret < 0) { 2254756e6736SKevin Wolf goto fail; 2255756e6736SKevin Wolf } 2256756e6736SKevin Wolf 2257e24e49e6SKevin Wolf buf += ret; 2258e24e49e6SKevin Wolf buflen -= ret; 2259e24e49e6SKevin Wolf } 2260756e6736SKevin Wolf 22614652b8f3SDaniel P. Berrange /* Full disk encryption header pointer extension */ 22624652b8f3SDaniel P. Berrange if (s->crypto_header.offset != 0) { 22634652b8f3SDaniel P. Berrange cpu_to_be64s(&s->crypto_header.offset); 22644652b8f3SDaniel P. Berrange cpu_to_be64s(&s->crypto_header.length); 22654652b8f3SDaniel P. Berrange ret = header_ext_add(buf, QCOW2_EXT_MAGIC_CRYPTO_HEADER, 22664652b8f3SDaniel P. Berrange &s->crypto_header, sizeof(s->crypto_header), 22674652b8f3SDaniel P. Berrange buflen); 22684652b8f3SDaniel P. Berrange be64_to_cpus(&s->crypto_header.offset); 22694652b8f3SDaniel P. Berrange be64_to_cpus(&s->crypto_header.length); 22704652b8f3SDaniel P. Berrange if (ret < 0) { 22714652b8f3SDaniel P. Berrange goto fail; 22724652b8f3SDaniel P. Berrange } 22734652b8f3SDaniel P. Berrange buf += ret; 22744652b8f3SDaniel P. Berrange buflen -= ret; 22754652b8f3SDaniel P. Berrange } 22764652b8f3SDaniel P. Berrange 2277cfcc4c62SKevin Wolf /* Feature table */ 22781a4828c7SKevin Wolf if (s->qcow_version >= 3) { 2279cfcc4c62SKevin Wolf Qcow2Feature features[] = { 2280c61d0004SStefan Hajnoczi { 2281c61d0004SStefan Hajnoczi .type = QCOW2_FEAT_TYPE_INCOMPATIBLE, 2282c61d0004SStefan Hajnoczi .bit = QCOW2_INCOMPAT_DIRTY_BITNR, 2283c61d0004SStefan Hajnoczi .name = "dirty bit", 2284c61d0004SStefan Hajnoczi }, 2285bfe8043eSStefan Hajnoczi { 228669c98726SMax Reitz .type = QCOW2_FEAT_TYPE_INCOMPATIBLE, 228769c98726SMax Reitz .bit = QCOW2_INCOMPAT_CORRUPT_BITNR, 228869c98726SMax Reitz .name = "corrupt bit", 228969c98726SMax Reitz }, 229069c98726SMax Reitz { 2291bfe8043eSStefan Hajnoczi .type = QCOW2_FEAT_TYPE_COMPATIBLE, 2292bfe8043eSStefan Hajnoczi .bit = QCOW2_COMPAT_LAZY_REFCOUNTS_BITNR, 2293bfe8043eSStefan Hajnoczi .name = "lazy refcounts", 2294bfe8043eSStefan Hajnoczi }, 2295cfcc4c62SKevin Wolf }; 2296cfcc4c62SKevin Wolf 2297cfcc4c62SKevin Wolf ret = header_ext_add(buf, QCOW2_EXT_MAGIC_FEATURE_TABLE, 2298cfcc4c62SKevin Wolf features, sizeof(features), buflen); 2299cfcc4c62SKevin Wolf if (ret < 0) { 2300cfcc4c62SKevin Wolf goto fail; 2301cfcc4c62SKevin Wolf } 2302cfcc4c62SKevin Wolf buf += ret; 2303cfcc4c62SKevin Wolf buflen -= ret; 23041a4828c7SKevin Wolf } 2305cfcc4c62SKevin Wolf 230688ddffaeSVladimir Sementsov-Ogievskiy /* Bitmap extension */ 230788ddffaeSVladimir Sementsov-Ogievskiy if (s->nb_bitmaps > 0) { 230888ddffaeSVladimir Sementsov-Ogievskiy Qcow2BitmapHeaderExt bitmaps_header = { 230988ddffaeSVladimir Sementsov-Ogievskiy .nb_bitmaps = cpu_to_be32(s->nb_bitmaps), 231088ddffaeSVladimir Sementsov-Ogievskiy .bitmap_directory_size = 231188ddffaeSVladimir Sementsov-Ogievskiy cpu_to_be64(s->bitmap_directory_size), 231288ddffaeSVladimir Sementsov-Ogievskiy .bitmap_directory_offset = 231388ddffaeSVladimir Sementsov-Ogievskiy cpu_to_be64(s->bitmap_directory_offset) 231488ddffaeSVladimir Sementsov-Ogievskiy }; 231588ddffaeSVladimir Sementsov-Ogievskiy ret = header_ext_add(buf, QCOW2_EXT_MAGIC_BITMAPS, 231688ddffaeSVladimir Sementsov-Ogievskiy &bitmaps_header, sizeof(bitmaps_header), 231788ddffaeSVladimir Sementsov-Ogievskiy buflen); 231888ddffaeSVladimir Sementsov-Ogievskiy if (ret < 0) { 231988ddffaeSVladimir Sementsov-Ogievskiy goto fail; 232088ddffaeSVladimir Sementsov-Ogievskiy } 232188ddffaeSVladimir Sementsov-Ogievskiy buf += ret; 232288ddffaeSVladimir Sementsov-Ogievskiy buflen -= ret; 232388ddffaeSVladimir Sementsov-Ogievskiy } 232488ddffaeSVladimir Sementsov-Ogievskiy 232575bab85cSKevin Wolf /* Keep unknown header extensions */ 232675bab85cSKevin Wolf QLIST_FOREACH(uext, &s->unknown_header_ext, next) { 232775bab85cSKevin Wolf ret = header_ext_add(buf, uext->magic, uext->data, uext->len, buflen); 232875bab85cSKevin Wolf if (ret < 0) { 232975bab85cSKevin Wolf goto fail; 233075bab85cSKevin Wolf } 233175bab85cSKevin Wolf 233275bab85cSKevin Wolf buf += ret; 233375bab85cSKevin Wolf buflen -= ret; 233475bab85cSKevin Wolf } 233575bab85cSKevin Wolf 2336e24e49e6SKevin Wolf /* End of header extensions */ 2337e24e49e6SKevin Wolf ret = header_ext_add(buf, QCOW2_EXT_MAGIC_END, NULL, 0, buflen); 2338756e6736SKevin Wolf if (ret < 0) { 2339756e6736SKevin Wolf goto fail; 2340756e6736SKevin Wolf } 2341756e6736SKevin Wolf 2342e24e49e6SKevin Wolf buf += ret; 2343e24e49e6SKevin Wolf buflen -= ret; 2344e24e49e6SKevin Wolf 2345e24e49e6SKevin Wolf /* Backing file name */ 2346e4603fe1SKevin Wolf if (s->image_backing_file) { 2347e4603fe1SKevin Wolf size_t backing_file_len = strlen(s->image_backing_file); 2348e24e49e6SKevin Wolf 2349e24e49e6SKevin Wolf if (buflen < backing_file_len) { 2350e24e49e6SKevin Wolf ret = -ENOSPC; 2351e24e49e6SKevin Wolf goto fail; 2352e24e49e6SKevin Wolf } 2353e24e49e6SKevin Wolf 235400ea1881SJim Meyering /* Using strncpy is ok here, since buf is not NUL-terminated. */ 2355e4603fe1SKevin Wolf strncpy(buf, s->image_backing_file, buflen); 2356e24e49e6SKevin Wolf 2357e24e49e6SKevin Wolf header->backing_file_offset = cpu_to_be64(buf - ((char*) header)); 2358e24e49e6SKevin Wolf header->backing_file_size = cpu_to_be32(backing_file_len); 2359e24e49e6SKevin Wolf } 2360e24e49e6SKevin Wolf 2361e24e49e6SKevin Wolf /* Write the new header */ 2362d9ca2ea2SKevin Wolf ret = bdrv_pwrite(bs->file, 0, header, s->cluster_size); 2363756e6736SKevin Wolf if (ret < 0) { 2364756e6736SKevin Wolf goto fail; 2365756e6736SKevin Wolf } 2366756e6736SKevin Wolf 2367756e6736SKevin Wolf ret = 0; 2368756e6736SKevin Wolf fail: 2369e24e49e6SKevin Wolf qemu_vfree(header); 2370756e6736SKevin Wolf return ret; 2371756e6736SKevin Wolf } 2372756e6736SKevin Wolf 2373756e6736SKevin Wolf static int qcow2_change_backing_file(BlockDriverState *bs, 2374756e6736SKevin Wolf const char *backing_file, const char *backing_fmt) 2375756e6736SKevin Wolf { 2376ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 2377e4603fe1SKevin Wolf 23784e876bcfSMax Reitz if (backing_file && strlen(backing_file) > 1023) { 23794e876bcfSMax Reitz return -EINVAL; 23804e876bcfSMax Reitz } 23814e876bcfSMax Reitz 2382e24e49e6SKevin Wolf pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: ""); 2383e24e49e6SKevin Wolf pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: ""); 2384e24e49e6SKevin Wolf 2385e4603fe1SKevin Wolf g_free(s->image_backing_file); 2386e4603fe1SKevin Wolf g_free(s->image_backing_format); 2387e4603fe1SKevin Wolf 2388e4603fe1SKevin Wolf s->image_backing_file = backing_file ? g_strdup(bs->backing_file) : NULL; 2389e4603fe1SKevin Wolf s->image_backing_format = backing_fmt ? g_strdup(bs->backing_format) : NULL; 2390e4603fe1SKevin Wolf 2391e24e49e6SKevin Wolf return qcow2_update_header(bs); 2392756e6736SKevin Wolf } 2393756e6736SKevin Wolf 23944652b8f3SDaniel P. Berrange static int qcow2_crypt_method_from_format(const char *encryptfmt) 23954652b8f3SDaniel P. Berrange { 23964652b8f3SDaniel P. Berrange if (g_str_equal(encryptfmt, "luks")) { 23974652b8f3SDaniel P. Berrange return QCOW_CRYPT_LUKS; 23984652b8f3SDaniel P. Berrange } else if (g_str_equal(encryptfmt, "aes")) { 23994652b8f3SDaniel P. Berrange return QCOW_CRYPT_AES; 24004652b8f3SDaniel P. Berrange } else { 24014652b8f3SDaniel P. Berrange return -EINVAL; 24024652b8f3SDaniel P. Berrange } 24034652b8f3SDaniel P. Berrange } 2404b25b387fSDaniel P. Berrange 2405b25b387fSDaniel P. Berrange static int qcow2_set_up_encryption(BlockDriverState *bs, const char *encryptfmt, 2406b25b387fSDaniel P. Berrange QemuOpts *opts, Error **errp) 2407b25b387fSDaniel P. Berrange { 2408b25b387fSDaniel P. Berrange BDRVQcow2State *s = bs->opaque; 2409b25b387fSDaniel P. Berrange QCryptoBlockCreateOptions *cryptoopts = NULL; 2410b25b387fSDaniel P. Berrange QCryptoBlock *crypto = NULL; 2411b25b387fSDaniel P. Berrange int ret = -EINVAL; 2412b25b387fSDaniel P. Berrange QDict *options, *encryptopts; 24134652b8f3SDaniel P. Berrange int fmt; 2414b25b387fSDaniel P. Berrange 2415b25b387fSDaniel P. Berrange options = qemu_opts_to_qdict(opts, NULL); 2416b25b387fSDaniel P. Berrange qdict_extract_subqdict(options, &encryptopts, "encrypt."); 2417b25b387fSDaniel P. Berrange QDECREF(options); 2418b25b387fSDaniel P. Berrange 24194652b8f3SDaniel P. Berrange fmt = qcow2_crypt_method_from_format(encryptfmt); 24204652b8f3SDaniel P. Berrange 24214652b8f3SDaniel P. Berrange switch (fmt) { 24224652b8f3SDaniel P. Berrange case QCOW_CRYPT_LUKS: 24234652b8f3SDaniel P. Berrange cryptoopts = block_crypto_create_opts_init( 24244652b8f3SDaniel P. Berrange Q_CRYPTO_BLOCK_FORMAT_LUKS, encryptopts, errp); 24254652b8f3SDaniel P. Berrange break; 24264652b8f3SDaniel P. Berrange case QCOW_CRYPT_AES: 2427b25b387fSDaniel P. Berrange cryptoopts = block_crypto_create_opts_init( 2428b25b387fSDaniel P. Berrange Q_CRYPTO_BLOCK_FORMAT_QCOW, encryptopts, errp); 24294652b8f3SDaniel P. Berrange break; 24304652b8f3SDaniel P. Berrange default: 24314652b8f3SDaniel P. Berrange error_setg(errp, "Unknown encryption format '%s'", encryptfmt); 24324652b8f3SDaniel P. Berrange break; 24334652b8f3SDaniel P. Berrange } 2434b25b387fSDaniel P. Berrange if (!cryptoopts) { 2435b25b387fSDaniel P. Berrange ret = -EINVAL; 2436b25b387fSDaniel P. Berrange goto out; 2437b25b387fSDaniel P. Berrange } 24384652b8f3SDaniel P. Berrange s->crypt_method_header = fmt; 2439b25b387fSDaniel P. Berrange 24401cd9a787SDaniel P. Berrange crypto = qcrypto_block_create(cryptoopts, "encrypt.", 24414652b8f3SDaniel P. Berrange qcow2_crypto_hdr_init_func, 24424652b8f3SDaniel P. Berrange qcow2_crypto_hdr_write_func, 2443b25b387fSDaniel P. Berrange bs, errp); 2444b25b387fSDaniel P. Berrange if (!crypto) { 2445b25b387fSDaniel P. Berrange ret = -EINVAL; 2446b25b387fSDaniel P. Berrange goto out; 2447b25b387fSDaniel P. Berrange } 2448b25b387fSDaniel P. Berrange 2449b25b387fSDaniel P. Berrange ret = qcow2_update_header(bs); 2450b25b387fSDaniel P. Berrange if (ret < 0) { 2451b25b387fSDaniel P. Berrange error_setg_errno(errp, -ret, "Could not write encryption header"); 2452b25b387fSDaniel P. Berrange goto out; 2453b25b387fSDaniel P. Berrange } 2454b25b387fSDaniel P. Berrange 2455b25b387fSDaniel P. Berrange out: 2456b25b387fSDaniel P. Berrange QDECREF(encryptopts); 2457b25b387fSDaniel P. Berrange qcrypto_block_free(crypto); 2458b25b387fSDaniel P. Berrange qapi_free_QCryptoBlockCreateOptions(cryptoopts); 2459b25b387fSDaniel P. Berrange return ret; 2460b25b387fSDaniel P. Berrange } 2461b25b387fSDaniel P. Berrange 2462b25b387fSDaniel P. Berrange 24637bc45dc1SMax Reitz /** 24647bc45dc1SMax Reitz * Preallocates metadata structures for data clusters between @offset (in the 24657bc45dc1SMax Reitz * guest disk) and @new_length (which is thus generally the new guest disk 24667bc45dc1SMax Reitz * size). 24677bc45dc1SMax Reitz * 24687bc45dc1SMax Reitz * Returns: 0 on success, -errno on failure. 24697bc45dc1SMax Reitz */ 24707bc45dc1SMax Reitz static int preallocate(BlockDriverState *bs, 24717bc45dc1SMax Reitz uint64_t offset, uint64_t new_length) 2472a35e1c17SKevin Wolf { 2473652fecd0SMax Reitz BDRVQcow2State *s = bs->opaque; 2474d46a0bb2SKevin Wolf uint64_t bytes; 2475060bee89SKevin Wolf uint64_t host_offset = 0; 2476d46a0bb2SKevin Wolf unsigned int cur_bytes; 2477148da7eaSKevin Wolf int ret; 2478f50f88b9SKevin Wolf QCowL2Meta *meta; 2479a35e1c17SKevin Wolf 2480652fecd0SMax Reitz if (qemu_in_coroutine()) { 2481652fecd0SMax Reitz qemu_co_mutex_lock(&s->lock); 2482652fecd0SMax Reitz } 2483652fecd0SMax Reitz 24847bc45dc1SMax Reitz assert(offset <= new_length); 24857bc45dc1SMax Reitz bytes = new_length - offset; 2486a35e1c17SKevin Wolf 2487d46a0bb2SKevin Wolf while (bytes) { 2488d46a0bb2SKevin Wolf cur_bytes = MIN(bytes, INT_MAX); 2489d46a0bb2SKevin Wolf ret = qcow2_alloc_cluster_offset(bs, offset, &cur_bytes, 2490060bee89SKevin Wolf &host_offset, &meta); 2491148da7eaSKevin Wolf if (ret < 0) { 2492652fecd0SMax Reitz goto done; 2493a35e1c17SKevin Wolf } 2494a35e1c17SKevin Wolf 2495c792707fSStefan Hajnoczi while (meta) { 2496c792707fSStefan Hajnoczi QCowL2Meta *next = meta->next; 2497c792707fSStefan Hajnoczi 2498f50f88b9SKevin Wolf ret = qcow2_alloc_cluster_link_l2(bs, meta); 249919dbcbf7SKevin Wolf if (ret < 0) { 25007c2bbf4aSHu Tao qcow2_free_any_clusters(bs, meta->alloc_offset, 25017c2bbf4aSHu Tao meta->nb_clusters, QCOW2_DISCARD_NEVER); 2502652fecd0SMax Reitz goto done; 2503a35e1c17SKevin Wolf } 2504a35e1c17SKevin Wolf 25057c2bbf4aSHu Tao /* There are no dependent requests, but we need to remove our 25067c2bbf4aSHu Tao * request from the list of in-flight requests */ 25074e95314eSKevin Wolf QLIST_REMOVE(meta, next_in_flight); 2508c792707fSStefan Hajnoczi 2509c792707fSStefan Hajnoczi g_free(meta); 2510c792707fSStefan Hajnoczi meta = next; 2511f50f88b9SKevin Wolf } 2512f214978aSKevin Wolf 2513a35e1c17SKevin Wolf /* TODO Preallocate data if requested */ 2514a35e1c17SKevin Wolf 2515d46a0bb2SKevin Wolf bytes -= cur_bytes; 2516d46a0bb2SKevin Wolf offset += cur_bytes; 2517a35e1c17SKevin Wolf } 2518a35e1c17SKevin Wolf 2519a35e1c17SKevin Wolf /* 2520a35e1c17SKevin Wolf * It is expected that the image file is large enough to actually contain 2521a35e1c17SKevin Wolf * all of the allocated clusters (otherwise we get failing reads after 2522a35e1c17SKevin Wolf * EOF). Extend the image to the last allocated sector. 2523a35e1c17SKevin Wolf */ 2524060bee89SKevin Wolf if (host_offset != 0) { 2525d46a0bb2SKevin Wolf uint8_t data = 0; 2526d9ca2ea2SKevin Wolf ret = bdrv_pwrite(bs->file, (host_offset + cur_bytes) - 1, 2527d46a0bb2SKevin Wolf &data, 1); 252819dbcbf7SKevin Wolf if (ret < 0) { 2529652fecd0SMax Reitz goto done; 253019dbcbf7SKevin Wolf } 2531a35e1c17SKevin Wolf } 2532a35e1c17SKevin Wolf 2533652fecd0SMax Reitz ret = 0; 2534652fecd0SMax Reitz 2535652fecd0SMax Reitz done: 2536652fecd0SMax Reitz if (qemu_in_coroutine()) { 2537652fecd0SMax Reitz qemu_co_mutex_unlock(&s->lock); 2538652fecd0SMax Reitz } 2539652fecd0SMax Reitz return ret; 2540a35e1c17SKevin Wolf } 2541a35e1c17SKevin Wolf 25427c5bcc42SStefan Hajnoczi /* qcow2_refcount_metadata_size: 25437c5bcc42SStefan Hajnoczi * @clusters: number of clusters to refcount (including data and L1/L2 tables) 25447c5bcc42SStefan Hajnoczi * @cluster_size: size of a cluster, in bytes 25457c5bcc42SStefan Hajnoczi * @refcount_order: refcount bits power-of-2 exponent 254612cc30a8SMax Reitz * @generous_increase: allow for the refcount table to be 1.5x as large as it 254712cc30a8SMax Reitz * needs to be 25487c5bcc42SStefan Hajnoczi * 25497c5bcc42SStefan Hajnoczi * Returns: Number of bytes required for refcount blocks and table metadata. 25507c5bcc42SStefan Hajnoczi */ 255112cc30a8SMax Reitz int64_t qcow2_refcount_metadata_size(int64_t clusters, size_t cluster_size, 255212cc30a8SMax Reitz int refcount_order, bool generous_increase, 255312cc30a8SMax Reitz uint64_t *refblock_count) 25547c5bcc42SStefan Hajnoczi { 25557c5bcc42SStefan Hajnoczi /* 25567c5bcc42SStefan Hajnoczi * Every host cluster is reference-counted, including metadata (even 25577c5bcc42SStefan Hajnoczi * refcount metadata is recursively included). 25587c5bcc42SStefan Hajnoczi * 25597c5bcc42SStefan Hajnoczi * An accurate formula for the size of refcount metadata size is difficult 25607c5bcc42SStefan Hajnoczi * to derive. An easier method of calculation is finding the fixed point 25617c5bcc42SStefan Hajnoczi * where no further refcount blocks or table clusters are required to 25627c5bcc42SStefan Hajnoczi * reference count every cluster. 25637c5bcc42SStefan Hajnoczi */ 25647c5bcc42SStefan Hajnoczi int64_t blocks_per_table_cluster = cluster_size / sizeof(uint64_t); 25657c5bcc42SStefan Hajnoczi int64_t refcounts_per_block = cluster_size * 8 / (1 << refcount_order); 25667c5bcc42SStefan Hajnoczi int64_t table = 0; /* number of refcount table clusters */ 25677c5bcc42SStefan Hajnoczi int64_t blocks = 0; /* number of refcount block clusters */ 25687c5bcc42SStefan Hajnoczi int64_t last; 25697c5bcc42SStefan Hajnoczi int64_t n = 0; 25707c5bcc42SStefan Hajnoczi 25717c5bcc42SStefan Hajnoczi do { 25727c5bcc42SStefan Hajnoczi last = n; 25737c5bcc42SStefan Hajnoczi blocks = DIV_ROUND_UP(clusters + table + blocks, refcounts_per_block); 25747c5bcc42SStefan Hajnoczi table = DIV_ROUND_UP(blocks, blocks_per_table_cluster); 25757c5bcc42SStefan Hajnoczi n = clusters + blocks + table; 257612cc30a8SMax Reitz 257712cc30a8SMax Reitz if (n == last && generous_increase) { 257812cc30a8SMax Reitz clusters += DIV_ROUND_UP(table, 2); 257912cc30a8SMax Reitz n = 0; /* force another loop */ 258012cc30a8SMax Reitz generous_increase = false; 258112cc30a8SMax Reitz } 25827c5bcc42SStefan Hajnoczi } while (n != last); 25837c5bcc42SStefan Hajnoczi 258412cc30a8SMax Reitz if (refblock_count) { 258512cc30a8SMax Reitz *refblock_count = blocks; 258612cc30a8SMax Reitz } 258712cc30a8SMax Reitz 25887c5bcc42SStefan Hajnoczi return (blocks + table) * cluster_size; 25897c5bcc42SStefan Hajnoczi } 25907c5bcc42SStefan Hajnoczi 259195c67e3bSStefan Hajnoczi /** 259295c67e3bSStefan Hajnoczi * qcow2_calc_prealloc_size: 259395c67e3bSStefan Hajnoczi * @total_size: virtual disk size in bytes 259495c67e3bSStefan Hajnoczi * @cluster_size: cluster size in bytes 259595c67e3bSStefan Hajnoczi * @refcount_order: refcount bits power-of-2 exponent 2596a9420734SKevin Wolf * 259795c67e3bSStefan Hajnoczi * Returns: Total number of bytes required for the fully allocated image 259895c67e3bSStefan Hajnoczi * (including metadata). 2599a9420734SKevin Wolf */ 260095c67e3bSStefan Hajnoczi static int64_t qcow2_calc_prealloc_size(int64_t total_size, 260195c67e3bSStefan Hajnoczi size_t cluster_size, 260295c67e3bSStefan Hajnoczi int refcount_order) 260395c67e3bSStefan Hajnoczi { 26040e4271b7SHu Tao int64_t meta_size = 0; 26057c5bcc42SStefan Hajnoczi uint64_t nl1e, nl2e; 26060e4271b7SHu Tao int64_t aligned_total_size = align_offset(total_size, cluster_size); 26070e4271b7SHu Tao 26080e4271b7SHu Tao /* header: 1 cluster */ 26090e4271b7SHu Tao meta_size += cluster_size; 26100e4271b7SHu Tao 26110e4271b7SHu Tao /* total size of L2 tables */ 26120e4271b7SHu Tao nl2e = aligned_total_size / cluster_size; 26130e4271b7SHu Tao nl2e = align_offset(nl2e, cluster_size / sizeof(uint64_t)); 26140e4271b7SHu Tao meta_size += nl2e * sizeof(uint64_t); 26150e4271b7SHu Tao 26160e4271b7SHu Tao /* total size of L1 tables */ 26170e4271b7SHu Tao nl1e = nl2e * sizeof(uint64_t) / cluster_size; 26180e4271b7SHu Tao nl1e = align_offset(nl1e, cluster_size / sizeof(uint64_t)); 26190e4271b7SHu Tao meta_size += nl1e * sizeof(uint64_t); 26200e4271b7SHu Tao 26217c5bcc42SStefan Hajnoczi /* total size of refcount table and blocks */ 26227c5bcc42SStefan Hajnoczi meta_size += qcow2_refcount_metadata_size( 26237c5bcc42SStefan Hajnoczi (meta_size + aligned_total_size) / cluster_size, 262412cc30a8SMax Reitz cluster_size, refcount_order, false, NULL); 26250e4271b7SHu Tao 262695c67e3bSStefan Hajnoczi return meta_size + aligned_total_size; 262795c67e3bSStefan Hajnoczi } 262895c67e3bSStefan Hajnoczi 26290eb4a8c1SStefan Hajnoczi static size_t qcow2_opt_get_cluster_size_del(QemuOpts *opts, Error **errp) 263095c67e3bSStefan Hajnoczi { 26310eb4a8c1SStefan Hajnoczi size_t cluster_size; 263295c67e3bSStefan Hajnoczi int cluster_bits; 263395c67e3bSStefan Hajnoczi 26340eb4a8c1SStefan Hajnoczi cluster_size = qemu_opt_get_size_del(opts, BLOCK_OPT_CLUSTER_SIZE, 26350eb4a8c1SStefan Hajnoczi DEFAULT_CLUSTER_SIZE); 263695c67e3bSStefan Hajnoczi cluster_bits = ctz32(cluster_size); 263795c67e3bSStefan Hajnoczi if (cluster_bits < MIN_CLUSTER_BITS || cluster_bits > MAX_CLUSTER_BITS || 263895c67e3bSStefan Hajnoczi (1 << cluster_bits) != cluster_size) 263995c67e3bSStefan Hajnoczi { 264095c67e3bSStefan Hajnoczi error_setg(errp, "Cluster size must be a power of two between %d and " 264195c67e3bSStefan Hajnoczi "%dk", 1 << MIN_CLUSTER_BITS, 1 << (MAX_CLUSTER_BITS - 10)); 26420eb4a8c1SStefan Hajnoczi return 0; 264395c67e3bSStefan Hajnoczi } 26440eb4a8c1SStefan Hajnoczi return cluster_size; 26450eb4a8c1SStefan Hajnoczi } 26460eb4a8c1SStefan Hajnoczi 26470eb4a8c1SStefan Hajnoczi static int qcow2_opt_get_version_del(QemuOpts *opts, Error **errp) 26480eb4a8c1SStefan Hajnoczi { 26490eb4a8c1SStefan Hajnoczi char *buf; 26500eb4a8c1SStefan Hajnoczi int ret; 26510eb4a8c1SStefan Hajnoczi 26520eb4a8c1SStefan Hajnoczi buf = qemu_opt_get_del(opts, BLOCK_OPT_COMPAT_LEVEL); 26530eb4a8c1SStefan Hajnoczi if (!buf) { 26540eb4a8c1SStefan Hajnoczi ret = 3; /* default */ 26550eb4a8c1SStefan Hajnoczi } else if (!strcmp(buf, "0.10")) { 26560eb4a8c1SStefan Hajnoczi ret = 2; 26570eb4a8c1SStefan Hajnoczi } else if (!strcmp(buf, "1.1")) { 26580eb4a8c1SStefan Hajnoczi ret = 3; 26590eb4a8c1SStefan Hajnoczi } else { 26600eb4a8c1SStefan Hajnoczi error_setg(errp, "Invalid compatibility level: '%s'", buf); 26610eb4a8c1SStefan Hajnoczi ret = -EINVAL; 26620eb4a8c1SStefan Hajnoczi } 26630eb4a8c1SStefan Hajnoczi g_free(buf); 26640eb4a8c1SStefan Hajnoczi return ret; 26650eb4a8c1SStefan Hajnoczi } 26660eb4a8c1SStefan Hajnoczi 26670eb4a8c1SStefan Hajnoczi static uint64_t qcow2_opt_get_refcount_bits_del(QemuOpts *opts, int version, 26680eb4a8c1SStefan Hajnoczi Error **errp) 26690eb4a8c1SStefan Hajnoczi { 26700eb4a8c1SStefan Hajnoczi uint64_t refcount_bits; 26710eb4a8c1SStefan Hajnoczi 26720eb4a8c1SStefan Hajnoczi refcount_bits = qemu_opt_get_number_del(opts, BLOCK_OPT_REFCOUNT_BITS, 16); 26730eb4a8c1SStefan Hajnoczi if (refcount_bits > 64 || !is_power_of_2(refcount_bits)) { 26740eb4a8c1SStefan Hajnoczi error_setg(errp, "Refcount width must be a power of two and may not " 26750eb4a8c1SStefan Hajnoczi "exceed 64 bits"); 26760eb4a8c1SStefan Hajnoczi return 0; 26770eb4a8c1SStefan Hajnoczi } 26780eb4a8c1SStefan Hajnoczi 26790eb4a8c1SStefan Hajnoczi if (version < 3 && refcount_bits != 16) { 26800eb4a8c1SStefan Hajnoczi error_setg(errp, "Different refcount widths than 16 bits require " 26810eb4a8c1SStefan Hajnoczi "compatibility level 1.1 or above (use compat=1.1 or " 26820eb4a8c1SStefan Hajnoczi "greater)"); 26830eb4a8c1SStefan Hajnoczi return 0; 26840eb4a8c1SStefan Hajnoczi } 26850eb4a8c1SStefan Hajnoczi 26860eb4a8c1SStefan Hajnoczi return refcount_bits; 26870eb4a8c1SStefan Hajnoczi } 26880eb4a8c1SStefan Hajnoczi 26890eb4a8c1SStefan Hajnoczi static int qcow2_create2(const char *filename, int64_t total_size, 26900eb4a8c1SStefan Hajnoczi const char *backing_file, const char *backing_format, 26910eb4a8c1SStefan Hajnoczi int flags, size_t cluster_size, PreallocMode prealloc, 26920eb4a8c1SStefan Hajnoczi QemuOpts *opts, int version, int refcount_order, 26930eb4a8c1SStefan Hajnoczi const char *encryptfmt, Error **errp) 26940eb4a8c1SStefan Hajnoczi { 26950eb4a8c1SStefan Hajnoczi QDict *options; 269695c67e3bSStefan Hajnoczi 269795c67e3bSStefan Hajnoczi /* 269895c67e3bSStefan Hajnoczi * Open the image file and write a minimal qcow2 header. 269995c67e3bSStefan Hajnoczi * 270095c67e3bSStefan Hajnoczi * We keep things simple and start with a zero-sized image. We also 270195c67e3bSStefan Hajnoczi * do without refcount blocks or a L1 table for now. We'll fix the 270295c67e3bSStefan Hajnoczi * inconsistency later. 270395c67e3bSStefan Hajnoczi * 270495c67e3bSStefan Hajnoczi * We do need a refcount table because growing the refcount table means 270595c67e3bSStefan Hajnoczi * allocating two new refcount blocks - the seconds of which would be at 270695c67e3bSStefan Hajnoczi * 2 GB for 64k clusters, and we don't want to have a 2 GB initial file 270795c67e3bSStefan Hajnoczi * size for any qcow2 image. 270895c67e3bSStefan Hajnoczi */ 270995c67e3bSStefan Hajnoczi BlockBackend *blk; 271095c67e3bSStefan Hajnoczi QCowHeader *header; 271195c67e3bSStefan Hajnoczi uint64_t* refcount_table; 271295c67e3bSStefan Hajnoczi Error *local_err = NULL; 271395c67e3bSStefan Hajnoczi int ret; 271495c67e3bSStefan Hajnoczi 271595c67e3bSStefan Hajnoczi if (prealloc == PREALLOC_MODE_FULL || prealloc == PREALLOC_MODE_FALLOC) { 271695c67e3bSStefan Hajnoczi int64_t prealloc_size = 271795c67e3bSStefan Hajnoczi qcow2_calc_prealloc_size(total_size, cluster_size, refcount_order); 271895c67e3bSStefan Hajnoczi qemu_opt_set_number(opts, BLOCK_OPT_SIZE, prealloc_size, &error_abort); 2719977c736fSMarkus Armbruster qemu_opt_set(opts, BLOCK_OPT_PREALLOC, PreallocMode_str(prealloc), 2720f43e47dbSMarkus Armbruster &error_abort); 27210e4271b7SHu Tao } 27220e4271b7SHu Tao 2723c282e1fdSChunyan Liu ret = bdrv_create_file(filename, opts, &local_err); 2724a9420734SKevin Wolf if (ret < 0) { 27253ef6c40aSMax Reitz error_propagate(errp, local_err); 2726a9420734SKevin Wolf return ret; 2727a9420734SKevin Wolf } 2728a9420734SKevin Wolf 2729efaa7c4eSMax Reitz blk = blk_new_open(filename, NULL, NULL, 273055880601SKevin Wolf BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, 273155880601SKevin Wolf &local_err); 273223588797SKevin Wolf if (blk == NULL) { 27333ef6c40aSMax Reitz error_propagate(errp, local_err); 273423588797SKevin Wolf return -EIO; 2735a9420734SKevin Wolf } 2736a9420734SKevin Wolf 273723588797SKevin Wolf blk_set_allow_write_beyond_eof(blk, true); 273823588797SKevin Wolf 2739a9420734SKevin Wolf /* Write the header */ 2740f8413b3cSKevin Wolf QEMU_BUILD_BUG_ON((1 << MIN_CLUSTER_BITS) < sizeof(*header)); 2741f8413b3cSKevin Wolf header = g_malloc0(cluster_size); 2742f8413b3cSKevin Wolf *header = (QCowHeader) { 2743f8413b3cSKevin Wolf .magic = cpu_to_be32(QCOW_MAGIC), 2744f8413b3cSKevin Wolf .version = cpu_to_be32(version), 27450eb4a8c1SStefan Hajnoczi .cluster_bits = cpu_to_be32(ctz32(cluster_size)), 2746f8413b3cSKevin Wolf .size = cpu_to_be64(0), 2747f8413b3cSKevin Wolf .l1_table_offset = cpu_to_be64(0), 2748f8413b3cSKevin Wolf .l1_size = cpu_to_be32(0), 2749f8413b3cSKevin Wolf .refcount_table_offset = cpu_to_be64(cluster_size), 2750f8413b3cSKevin Wolf .refcount_table_clusters = cpu_to_be32(1), 2751bd4b167fSMax Reitz .refcount_order = cpu_to_be32(refcount_order), 2752f8413b3cSKevin Wolf .header_length = cpu_to_be32(sizeof(*header)), 2753f8413b3cSKevin Wolf }; 2754a9420734SKevin Wolf 2755b25b387fSDaniel P. Berrange /* We'll update this to correct value later */ 2756f8413b3cSKevin Wolf header->crypt_method = cpu_to_be32(QCOW_CRYPT_NONE); 2757a9420734SKevin Wolf 2758bfe8043eSStefan Hajnoczi if (flags & BLOCK_FLAG_LAZY_REFCOUNTS) { 2759f8413b3cSKevin Wolf header->compatible_features |= 2760bfe8043eSStefan Hajnoczi cpu_to_be64(QCOW2_COMPAT_LAZY_REFCOUNTS); 2761bfe8043eSStefan Hajnoczi } 2762bfe8043eSStefan Hajnoczi 27638341f00dSEric Blake ret = blk_pwrite(blk, 0, header, cluster_size, 0); 2764f8413b3cSKevin Wolf g_free(header); 2765a9420734SKevin Wolf if (ret < 0) { 27663ef6c40aSMax Reitz error_setg_errno(errp, -ret, "Could not write qcow2 header"); 2767a9420734SKevin Wolf goto out; 2768a9420734SKevin Wolf } 2769a9420734SKevin Wolf 2770b106ad91SKevin Wolf /* Write a refcount table with one refcount block */ 2771b106ad91SKevin Wolf refcount_table = g_malloc0(2 * cluster_size); 2772b106ad91SKevin Wolf refcount_table[0] = cpu_to_be64(2 * cluster_size); 27738341f00dSEric Blake ret = blk_pwrite(blk, cluster_size, refcount_table, 2 * cluster_size, 0); 27747267c094SAnthony Liguori g_free(refcount_table); 2775a9420734SKevin Wolf 2776a9420734SKevin Wolf if (ret < 0) { 27773ef6c40aSMax Reitz error_setg_errno(errp, -ret, "Could not write refcount table"); 2778a9420734SKevin Wolf goto out; 2779a9420734SKevin Wolf } 2780a9420734SKevin Wolf 278123588797SKevin Wolf blk_unref(blk); 278223588797SKevin Wolf blk = NULL; 2783a9420734SKevin Wolf 2784a9420734SKevin Wolf /* 2785a9420734SKevin Wolf * And now open the image and make it consistent first (i.e. increase the 2786a9420734SKevin Wolf * refcount of the cluster that is occupied by the header and the refcount 2787a9420734SKevin Wolf * table) 2788a9420734SKevin Wolf */ 2789e6641719SMax Reitz options = qdict_new(); 279046f5ac20SEric Blake qdict_put_str(options, "driver", "qcow2"); 2791efaa7c4eSMax Reitz blk = blk_new_open(filename, NULL, options, 279255880601SKevin Wolf BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_NO_FLUSH, 279355880601SKevin Wolf &local_err); 279423588797SKevin Wolf if (blk == NULL) { 27953ef6c40aSMax Reitz error_propagate(errp, local_err); 279623588797SKevin Wolf ret = -EIO; 2797a9420734SKevin Wolf goto out; 2798a9420734SKevin Wolf } 2799a9420734SKevin Wolf 280023588797SKevin Wolf ret = qcow2_alloc_clusters(blk_bs(blk), 3 * cluster_size); 2801a9420734SKevin Wolf if (ret < 0) { 28023ef6c40aSMax Reitz error_setg_errno(errp, -ret, "Could not allocate clusters for qcow2 " 28033ef6c40aSMax Reitz "header and refcount table"); 2804a9420734SKevin Wolf goto out; 2805a9420734SKevin Wolf 2806a9420734SKevin Wolf } else if (ret != 0) { 2807a9420734SKevin Wolf error_report("Huh, first cluster in empty image is already in use?"); 2808a9420734SKevin Wolf abort(); 2809a9420734SKevin Wolf } 2810a9420734SKevin Wolf 2811b527c9b3SKevin Wolf /* Create a full header (including things like feature table) */ 281223588797SKevin Wolf ret = qcow2_update_header(blk_bs(blk)); 2813b527c9b3SKevin Wolf if (ret < 0) { 2814b527c9b3SKevin Wolf error_setg_errno(errp, -ret, "Could not update qcow2 header"); 2815b527c9b3SKevin Wolf goto out; 2816b527c9b3SKevin Wolf } 2817b527c9b3SKevin Wolf 2818a9420734SKevin Wolf /* Okay, now that we have a valid image, let's give it the right size */ 28193a691c50SMax Reitz ret = blk_truncate(blk, total_size, PREALLOC_MODE_OFF, errp); 2820a9420734SKevin Wolf if (ret < 0) { 2821ed3d2ec9SMax Reitz error_prepend(errp, "Could not resize image: "); 2822a9420734SKevin Wolf goto out; 2823a9420734SKevin Wolf } 2824a9420734SKevin Wolf 2825a9420734SKevin Wolf /* Want a backing file? There you go.*/ 2826a9420734SKevin Wolf if (backing_file) { 282723588797SKevin Wolf ret = bdrv_change_backing_file(blk_bs(blk), backing_file, backing_format); 2828a9420734SKevin Wolf if (ret < 0) { 28293ef6c40aSMax Reitz error_setg_errno(errp, -ret, "Could not assign backing file '%s' " 28303ef6c40aSMax Reitz "with format '%s'", backing_file, backing_format); 2831a9420734SKevin Wolf goto out; 2832a9420734SKevin Wolf } 2833a9420734SKevin Wolf } 2834a9420734SKevin Wolf 2835b25b387fSDaniel P. Berrange /* Want encryption? There you go. */ 2836b25b387fSDaniel P. Berrange if (encryptfmt) { 2837b25b387fSDaniel P. Berrange ret = qcow2_set_up_encryption(blk_bs(blk), encryptfmt, opts, errp); 2838b25b387fSDaniel P. Berrange if (ret < 0) { 2839b25b387fSDaniel P. Berrange goto out; 2840b25b387fSDaniel P. Berrange } 2841b25b387fSDaniel P. Berrange } 2842b25b387fSDaniel P. Berrange 2843a9420734SKevin Wolf /* And if we're supposed to preallocate metadata, do that now */ 28440e4271b7SHu Tao if (prealloc != PREALLOC_MODE_OFF) { 28457bc45dc1SMax Reitz ret = preallocate(blk_bs(blk), 0, total_size); 2846a9420734SKevin Wolf if (ret < 0) { 28473ef6c40aSMax Reitz error_setg_errno(errp, -ret, "Could not preallocate metadata"); 2848a9420734SKevin Wolf goto out; 2849a9420734SKevin Wolf } 2850a9420734SKevin Wolf } 2851a9420734SKevin Wolf 285223588797SKevin Wolf blk_unref(blk); 285323588797SKevin Wolf blk = NULL; 2854ba2ab2f2SMax Reitz 2855b25b387fSDaniel P. Berrange /* Reopen the image without BDRV_O_NO_FLUSH to flush it before returning. 2856b25b387fSDaniel P. Berrange * Using BDRV_O_NO_IO, since encryption is now setup we don't want to 2857b25b387fSDaniel P. Berrange * have to setup decryption context. We're not doing any I/O on the top 2858b25b387fSDaniel P. Berrange * level BlockDriverState, only lower layers, where BDRV_O_NO_IO does 2859b25b387fSDaniel P. Berrange * not have effect. 2860b25b387fSDaniel P. Berrange */ 2861e6641719SMax Reitz options = qdict_new(); 286246f5ac20SEric Blake qdict_put_str(options, "driver", "qcow2"); 2863efaa7c4eSMax Reitz blk = blk_new_open(filename, NULL, options, 2864b25b387fSDaniel P. Berrange BDRV_O_RDWR | BDRV_O_NO_BACKING | BDRV_O_NO_IO, 2865b25b387fSDaniel P. Berrange &local_err); 286623588797SKevin Wolf if (blk == NULL) { 2867ba2ab2f2SMax Reitz error_propagate(errp, local_err); 286823588797SKevin Wolf ret = -EIO; 2869ba2ab2f2SMax Reitz goto out; 2870ba2ab2f2SMax Reitz } 2871ba2ab2f2SMax Reitz 2872a9420734SKevin Wolf ret = 0; 2873a9420734SKevin Wolf out: 287423588797SKevin Wolf if (blk) { 287523588797SKevin Wolf blk_unref(blk); 2876f67503e5SMax Reitz } 2877a9420734SKevin Wolf return ret; 2878a9420734SKevin Wolf } 2879de5f3f40SKevin Wolf 28801bd0e2d1SChunyan Liu static int qcow2_create(const char *filename, QemuOpts *opts, Error **errp) 2881de5f3f40SKevin Wolf { 28821bd0e2d1SChunyan Liu char *backing_file = NULL; 28831bd0e2d1SChunyan Liu char *backing_fmt = NULL; 28841bd0e2d1SChunyan Liu char *buf = NULL; 2885180e9526SHu Tao uint64_t size = 0; 2886de5f3f40SKevin Wolf int flags = 0; 288799cce9faSKevin Wolf size_t cluster_size = DEFAULT_CLUSTER_SIZE; 2888ffeaac9bSHu Tao PreallocMode prealloc; 28890eb4a8c1SStefan Hajnoczi int version; 28900eb4a8c1SStefan Hajnoczi uint64_t refcount_bits; 2891bd4b167fSMax Reitz int refcount_order; 28920696ae2cSDaniel P. Berrange char *encryptfmt = NULL; 28933ef6c40aSMax Reitz Error *local_err = NULL; 28943ef6c40aSMax Reitz int ret; 2895de5f3f40SKevin Wolf 2896de5f3f40SKevin Wolf /* Read out options */ 2897180e9526SHu Tao size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0), 2898c2eb918eSHu Tao BDRV_SECTOR_SIZE); 28991bd0e2d1SChunyan Liu backing_file = qemu_opt_get_del(opts, BLOCK_OPT_BACKING_FILE); 29001bd0e2d1SChunyan Liu backing_fmt = qemu_opt_get_del(opts, BLOCK_OPT_BACKING_FMT); 29010cb8d47bSDaniel P. Berrange encryptfmt = qemu_opt_get_del(opts, BLOCK_OPT_ENCRYPT_FORMAT); 29020cb8d47bSDaniel P. Berrange if (encryptfmt) { 29030696ae2cSDaniel P. Berrange if (qemu_opt_get(opts, BLOCK_OPT_ENCRYPT)) { 29040cb8d47bSDaniel P. Berrange error_setg(errp, "Options " BLOCK_OPT_ENCRYPT " and " 29050cb8d47bSDaniel P. Berrange BLOCK_OPT_ENCRYPT_FORMAT " are mutually exclusive"); 29060cb8d47bSDaniel P. Berrange ret = -EINVAL; 29070cb8d47bSDaniel P. Berrange goto finish; 29080cb8d47bSDaniel P. Berrange } 29090cb8d47bSDaniel P. Berrange } else if (qemu_opt_get_bool_del(opts, BLOCK_OPT_ENCRYPT, false)) { 29100696ae2cSDaniel P. Berrange encryptfmt = g_strdup("aes"); 2911de5f3f40SKevin Wolf } 29120eb4a8c1SStefan Hajnoczi cluster_size = qcow2_opt_get_cluster_size_del(opts, &local_err); 29130eb4a8c1SStefan Hajnoczi if (local_err) { 29140eb4a8c1SStefan Hajnoczi error_propagate(errp, local_err); 29150eb4a8c1SStefan Hajnoczi ret = -EINVAL; 29160eb4a8c1SStefan Hajnoczi goto finish; 29170eb4a8c1SStefan Hajnoczi } 29181bd0e2d1SChunyan Liu buf = qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC); 2919f7abe0ecSMarc-André Lureau prealloc = qapi_enum_parse(&PreallocMode_lookup, buf, 292006c60b6cSMarkus Armbruster PREALLOC_MODE_OFF, &local_err); 2921ffeaac9bSHu Tao if (local_err) { 2922ffeaac9bSHu Tao error_propagate(errp, local_err); 29231bd0e2d1SChunyan Liu ret = -EINVAL; 29241bd0e2d1SChunyan Liu goto finish; 2925de5f3f40SKevin Wolf } 29260eb4a8c1SStefan Hajnoczi 29270eb4a8c1SStefan Hajnoczi version = qcow2_opt_get_version_del(opts, &local_err); 29280eb4a8c1SStefan Hajnoczi if (local_err) { 29290eb4a8c1SStefan Hajnoczi error_propagate(errp, local_err); 29301bd0e2d1SChunyan Liu ret = -EINVAL; 29311bd0e2d1SChunyan Liu goto finish; 29326744cbabSKevin Wolf } 29331bd0e2d1SChunyan Liu 29341bd0e2d1SChunyan Liu if (qemu_opt_get_bool_del(opts, BLOCK_OPT_LAZY_REFCOUNTS, false)) { 29351bd0e2d1SChunyan Liu flags |= BLOCK_FLAG_LAZY_REFCOUNTS; 2936de5f3f40SKevin Wolf } 2937de5f3f40SKevin Wolf 2938ffeaac9bSHu Tao if (backing_file && prealloc != PREALLOC_MODE_OFF) { 29393ef6c40aSMax Reitz error_setg(errp, "Backing file and preallocation cannot be used at " 29403ef6c40aSMax Reitz "the same time"); 29411bd0e2d1SChunyan Liu ret = -EINVAL; 29421bd0e2d1SChunyan Liu goto finish; 2943de5f3f40SKevin Wolf } 2944de5f3f40SKevin Wolf 2945bfe8043eSStefan Hajnoczi if (version < 3 && (flags & BLOCK_FLAG_LAZY_REFCOUNTS)) { 29463ef6c40aSMax Reitz error_setg(errp, "Lazy refcounts only supported with compatibility " 29473ef6c40aSMax Reitz "level 1.1 and above (use compat=1.1 or greater)"); 29481bd0e2d1SChunyan Liu ret = -EINVAL; 29491bd0e2d1SChunyan Liu goto finish; 2950bfe8043eSStefan Hajnoczi } 2951bfe8043eSStefan Hajnoczi 29520eb4a8c1SStefan Hajnoczi refcount_bits = qcow2_opt_get_refcount_bits_del(opts, version, &local_err); 29530eb4a8c1SStefan Hajnoczi if (local_err) { 29540eb4a8c1SStefan Hajnoczi error_propagate(errp, local_err); 2955bd4b167fSMax Reitz ret = -EINVAL; 2956bd4b167fSMax Reitz goto finish; 2957bd4b167fSMax Reitz } 2958bd4b167fSMax Reitz 2959786a4ea8SStefan Hajnoczi refcount_order = ctz32(refcount_bits); 2960bd4b167fSMax Reitz 2961180e9526SHu Tao ret = qcow2_create2(filename, size, backing_file, backing_fmt, flags, 2962bd4b167fSMax Reitz cluster_size, prealloc, opts, version, refcount_order, 29630cb8d47bSDaniel P. Berrange encryptfmt, &local_err); 29643ef6c40aSMax Reitz error_propagate(errp, local_err); 29651bd0e2d1SChunyan Liu 29661bd0e2d1SChunyan Liu finish: 29671bd0e2d1SChunyan Liu g_free(backing_file); 29681bd0e2d1SChunyan Liu g_free(backing_fmt); 29690696ae2cSDaniel P. Berrange g_free(encryptfmt); 29701bd0e2d1SChunyan Liu g_free(buf); 29713ef6c40aSMax Reitz return ret; 2972de5f3f40SKevin Wolf } 2973de5f3f40SKevin Wolf 29742928abceSDenis V. Lunev 2975ebb718a5SEric Blake static bool is_zero_sectors(BlockDriverState *bs, int64_t start, 2976ebb718a5SEric Blake uint32_t count) 29772928abceSDenis V. Lunev { 29782928abceSDenis V. Lunev int nr; 29792928abceSDenis V. Lunev BlockDriverState *file; 2980ebb718a5SEric Blake int64_t res; 2981ebb718a5SEric Blake 2982fbaa6bb3SEric Blake if (start + count > bs->total_sectors) { 2983fbaa6bb3SEric Blake count = bs->total_sectors - start; 2984fbaa6bb3SEric Blake } 2985fbaa6bb3SEric Blake 2986ebb718a5SEric Blake if (!count) { 2987ebb718a5SEric Blake return true; 29882928abceSDenis V. Lunev } 2989ebb718a5SEric Blake res = bdrv_get_block_status_above(bs, NULL, start, count, 2990ebb718a5SEric Blake &nr, &file); 2991ebb718a5SEric Blake return res >= 0 && (res & BDRV_BLOCK_ZERO) && nr == count; 29922928abceSDenis V. Lunev } 29932928abceSDenis V. Lunev 29945544b59fSEric Blake static coroutine_fn int qcow2_co_pwrite_zeroes(BlockDriverState *bs, 2995f5a5ca79SManos Pitsidianakis int64_t offset, int bytes, BdrvRequestFlags flags) 2996621f0589SKevin Wolf { 2997621f0589SKevin Wolf int ret; 2998ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 2999621f0589SKevin Wolf 30005544b59fSEric Blake uint32_t head = offset % s->cluster_size; 3001f5a5ca79SManos Pitsidianakis uint32_t tail = (offset + bytes) % s->cluster_size; 30022928abceSDenis V. Lunev 3003f5a5ca79SManos Pitsidianakis trace_qcow2_pwrite_zeroes_start_req(qemu_coroutine_self(), offset, bytes); 3004f5a5ca79SManos Pitsidianakis if (offset + bytes == bs->total_sectors * BDRV_SECTOR_SIZE) { 3005fbaa6bb3SEric Blake tail = 0; 3006fbaa6bb3SEric Blake } 30075a64e942SDenis V. Lunev 3008ebb718a5SEric Blake if (head || tail) { 30095544b59fSEric Blake int64_t cl_start = (offset - head) >> BDRV_SECTOR_BITS; 3010ebb718a5SEric Blake uint64_t off; 3011ecfe1863SKevin Wolf unsigned int nr; 30122928abceSDenis V. Lunev 3013f5a5ca79SManos Pitsidianakis assert(head + bytes <= s->cluster_size); 30142928abceSDenis V. Lunev 3015ebb718a5SEric Blake /* check whether remainder of cluster already reads as zero */ 30165544b59fSEric Blake if (!(is_zero_sectors(bs, cl_start, 30175544b59fSEric Blake DIV_ROUND_UP(head, BDRV_SECTOR_SIZE)) && 3018f5a5ca79SManos Pitsidianakis is_zero_sectors(bs, (offset + bytes) >> BDRV_SECTOR_BITS, 30195544b59fSEric Blake DIV_ROUND_UP(-tail & (s->cluster_size - 1), 30205544b59fSEric Blake BDRV_SECTOR_SIZE)))) { 3021621f0589SKevin Wolf return -ENOTSUP; 3022621f0589SKevin Wolf } 3023621f0589SKevin Wolf 3024621f0589SKevin Wolf qemu_co_mutex_lock(&s->lock); 30252928abceSDenis V. Lunev /* We can have new write after previous check */ 30265544b59fSEric Blake offset = cl_start << BDRV_SECTOR_BITS; 3027f5a5ca79SManos Pitsidianakis bytes = s->cluster_size; 3028ecfe1863SKevin Wolf nr = s->cluster_size; 30295544b59fSEric Blake ret = qcow2_get_cluster_offset(bs, offset, &nr, &off); 3030fdfab37dSEric Blake if (ret != QCOW2_CLUSTER_UNALLOCATED && 3031fdfab37dSEric Blake ret != QCOW2_CLUSTER_ZERO_PLAIN && 3032fdfab37dSEric Blake ret != QCOW2_CLUSTER_ZERO_ALLOC) { 30332928abceSDenis V. Lunev qemu_co_mutex_unlock(&s->lock); 30342928abceSDenis V. Lunev return -ENOTSUP; 30352928abceSDenis V. Lunev } 30362928abceSDenis V. Lunev } else { 30372928abceSDenis V. Lunev qemu_co_mutex_lock(&s->lock); 30382928abceSDenis V. Lunev } 30392928abceSDenis V. Lunev 3040f5a5ca79SManos Pitsidianakis trace_qcow2_pwrite_zeroes(qemu_coroutine_self(), offset, bytes); 30415a64e942SDenis V. Lunev 30422928abceSDenis V. Lunev /* Whatever is left can use real zero clusters */ 3043f5a5ca79SManos Pitsidianakis ret = qcow2_cluster_zeroize(bs, offset, bytes, flags); 3044621f0589SKevin Wolf qemu_co_mutex_unlock(&s->lock); 3045621f0589SKevin Wolf 3046621f0589SKevin Wolf return ret; 3047621f0589SKevin Wolf } 3048621f0589SKevin Wolf 304982e8a788SEric Blake static coroutine_fn int qcow2_co_pdiscard(BlockDriverState *bs, 3050f5a5ca79SManos Pitsidianakis int64_t offset, int bytes) 30515ea929e3SKevin Wolf { 30526db39ae2SPaolo Bonzini int ret; 3053ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 30546db39ae2SPaolo Bonzini 3055f5a5ca79SManos Pitsidianakis if (!QEMU_IS_ALIGNED(offset | bytes, s->cluster_size)) { 3056f5a5ca79SManos Pitsidianakis assert(bytes < s->cluster_size); 3057048c5fd1SEric Blake /* Ignore partial clusters, except for the special case of the 3058048c5fd1SEric Blake * complete partial cluster at the end of an unaligned file */ 3059048c5fd1SEric Blake if (!QEMU_IS_ALIGNED(offset, s->cluster_size) || 3060f5a5ca79SManos Pitsidianakis offset + bytes != bs->total_sectors * BDRV_SECTOR_SIZE) { 306149228d1eSEric Blake return -ENOTSUP; 306249228d1eSEric Blake } 3063048c5fd1SEric Blake } 306449228d1eSEric Blake 30656db39ae2SPaolo Bonzini qemu_co_mutex_lock(&s->lock); 3066f5a5ca79SManos Pitsidianakis ret = qcow2_cluster_discard(bs, offset, bytes, QCOW2_DISCARD_REQUEST, 3067d2cb36afSEric Blake false); 30686db39ae2SPaolo Bonzini qemu_co_mutex_unlock(&s->lock); 30696db39ae2SPaolo Bonzini return ret; 30705ea929e3SKevin Wolf } 30715ea929e3SKevin Wolf 30728243ccb7SMax Reitz static int qcow2_truncate(BlockDriverState *bs, int64_t offset, 30738243ccb7SMax Reitz PreallocMode prealloc, Error **errp) 3074419b19d9SStefan Hajnoczi { 3075ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 307695b98f34SMax Reitz uint64_t old_length; 30772cf7cfa1SKevin Wolf int64_t new_l1_size; 30782cf7cfa1SKevin Wolf int ret; 3079419b19d9SStefan Hajnoczi 3080772d1f97SMax Reitz if (prealloc != PREALLOC_MODE_OFF && prealloc != PREALLOC_MODE_METADATA && 3081772d1f97SMax Reitz prealloc != PREALLOC_MODE_FALLOC && prealloc != PREALLOC_MODE_FULL) 3082772d1f97SMax Reitz { 30838243ccb7SMax Reitz error_setg(errp, "Unsupported preallocation mode '%s'", 3084977c736fSMarkus Armbruster PreallocMode_str(prealloc)); 30858243ccb7SMax Reitz return -ENOTSUP; 30868243ccb7SMax Reitz } 30878243ccb7SMax Reitz 3088419b19d9SStefan Hajnoczi if (offset & 511) { 30894bff28b8SMax Reitz error_setg(errp, "The new size must be a multiple of 512"); 3090419b19d9SStefan Hajnoczi return -EINVAL; 3091419b19d9SStefan Hajnoczi } 3092419b19d9SStefan Hajnoczi 3093419b19d9SStefan Hajnoczi /* cannot proceed if image has snapshots */ 3094419b19d9SStefan Hajnoczi if (s->nb_snapshots) { 30954bff28b8SMax Reitz error_setg(errp, "Can't resize an image which has snapshots"); 3096419b19d9SStefan Hajnoczi return -ENOTSUP; 3097419b19d9SStefan Hajnoczi } 3098419b19d9SStefan Hajnoczi 309988ddffaeSVladimir Sementsov-Ogievskiy /* cannot proceed if image has bitmaps */ 310088ddffaeSVladimir Sementsov-Ogievskiy if (s->nb_bitmaps) { 310188ddffaeSVladimir Sementsov-Ogievskiy /* TODO: resize bitmaps in the image */ 310288ddffaeSVladimir Sementsov-Ogievskiy error_setg(errp, "Can't resize an image which has bitmaps"); 310388ddffaeSVladimir Sementsov-Ogievskiy return -ENOTSUP; 310488ddffaeSVladimir Sementsov-Ogievskiy } 310588ddffaeSVladimir Sementsov-Ogievskiy 310695b98f34SMax Reitz old_length = bs->total_sectors * 512; 310746b732cdSPavel Butsykin new_l1_size = size_to_l1(s, offset); 310895b98f34SMax Reitz 310995b98f34SMax Reitz if (offset < old_length) { 3110*163bc39dSPavel Butsykin int64_t last_cluster, old_file_size; 311146b732cdSPavel Butsykin if (prealloc != PREALLOC_MODE_OFF) { 311246b732cdSPavel Butsykin error_setg(errp, 311346b732cdSPavel Butsykin "Preallocation can't be used for shrinking an image"); 311446b732cdSPavel Butsykin return -EINVAL; 3115419b19d9SStefan Hajnoczi } 3116419b19d9SStefan Hajnoczi 311746b732cdSPavel Butsykin ret = qcow2_cluster_discard(bs, ROUND_UP(offset, s->cluster_size), 311846b732cdSPavel Butsykin old_length - ROUND_UP(offset, 311946b732cdSPavel Butsykin s->cluster_size), 312046b732cdSPavel Butsykin QCOW2_DISCARD_ALWAYS, true); 312146b732cdSPavel Butsykin if (ret < 0) { 312246b732cdSPavel Butsykin error_setg_errno(errp, -ret, "Failed to discard cropped clusters"); 312346b732cdSPavel Butsykin return ret; 312446b732cdSPavel Butsykin } 312546b732cdSPavel Butsykin 312646b732cdSPavel Butsykin ret = qcow2_shrink_l1_table(bs, new_l1_size); 312746b732cdSPavel Butsykin if (ret < 0) { 312846b732cdSPavel Butsykin error_setg_errno(errp, -ret, 312946b732cdSPavel Butsykin "Failed to reduce the number of L2 tables"); 313046b732cdSPavel Butsykin return ret; 313146b732cdSPavel Butsykin } 313246b732cdSPavel Butsykin 313346b732cdSPavel Butsykin ret = qcow2_shrink_reftable(bs); 313446b732cdSPavel Butsykin if (ret < 0) { 313546b732cdSPavel Butsykin error_setg_errno(errp, -ret, 313646b732cdSPavel Butsykin "Failed to discard unused refblocks"); 313746b732cdSPavel Butsykin return ret; 313846b732cdSPavel Butsykin } 3139*163bc39dSPavel Butsykin 3140*163bc39dSPavel Butsykin old_file_size = bdrv_getlength(bs->file->bs); 3141*163bc39dSPavel Butsykin if (old_file_size < 0) { 3142*163bc39dSPavel Butsykin error_setg_errno(errp, -old_file_size, 3143*163bc39dSPavel Butsykin "Failed to inquire current file length"); 3144*163bc39dSPavel Butsykin return old_file_size; 3145*163bc39dSPavel Butsykin } 3146*163bc39dSPavel Butsykin last_cluster = qcow2_get_last_cluster(bs, old_file_size); 3147*163bc39dSPavel Butsykin if (last_cluster < 0) { 3148*163bc39dSPavel Butsykin error_setg_errno(errp, -last_cluster, 3149*163bc39dSPavel Butsykin "Failed to find the last cluster"); 3150*163bc39dSPavel Butsykin return last_cluster; 3151*163bc39dSPavel Butsykin } 3152*163bc39dSPavel Butsykin if ((last_cluster + 1) * s->cluster_size < old_file_size) { 3153*163bc39dSPavel Butsykin ret = bdrv_truncate(bs->file, (last_cluster + 1) * s->cluster_size, 3154*163bc39dSPavel Butsykin PREALLOC_MODE_OFF, NULL); 3155*163bc39dSPavel Butsykin if (ret < 0) { 3156*163bc39dSPavel Butsykin warn_report("Failed to truncate the tail of the image: %s", 3157*163bc39dSPavel Butsykin strerror(-ret)); 3158*163bc39dSPavel Butsykin ret = 0; 3159*163bc39dSPavel Butsykin } 3160*163bc39dSPavel Butsykin } 316146b732cdSPavel Butsykin } else { 316272893756SStefan Hajnoczi ret = qcow2_grow_l1_table(bs, new_l1_size, true); 3163419b19d9SStefan Hajnoczi if (ret < 0) { 3164f59adb32SMax Reitz error_setg_errno(errp, -ret, "Failed to grow the L1 table"); 3165419b19d9SStefan Hajnoczi return ret; 3166419b19d9SStefan Hajnoczi } 316746b732cdSPavel Butsykin } 3168419b19d9SStefan Hajnoczi 316995b98f34SMax Reitz switch (prealloc) { 317095b98f34SMax Reitz case PREALLOC_MODE_OFF: 317195b98f34SMax Reitz break; 317295b98f34SMax Reitz 317395b98f34SMax Reitz case PREALLOC_MODE_METADATA: 317495b98f34SMax Reitz ret = preallocate(bs, old_length, offset); 317595b98f34SMax Reitz if (ret < 0) { 317695b98f34SMax Reitz error_setg_errno(errp, -ret, "Preallocation failed"); 317795b98f34SMax Reitz return ret; 317895b98f34SMax Reitz } 317995b98f34SMax Reitz break; 318095b98f34SMax Reitz 3181772d1f97SMax Reitz case PREALLOC_MODE_FALLOC: 3182772d1f97SMax Reitz case PREALLOC_MODE_FULL: 3183772d1f97SMax Reitz { 3184772d1f97SMax Reitz int64_t allocation_start, host_offset, guest_offset; 3185772d1f97SMax Reitz int64_t clusters_allocated; 3186772d1f97SMax Reitz int64_t old_file_size, new_file_size; 3187772d1f97SMax Reitz uint64_t nb_new_data_clusters, nb_new_l2_tables; 3188772d1f97SMax Reitz 3189772d1f97SMax Reitz old_file_size = bdrv_getlength(bs->file->bs); 3190772d1f97SMax Reitz if (old_file_size < 0) { 3191772d1f97SMax Reitz error_setg_errno(errp, -old_file_size, 3192772d1f97SMax Reitz "Failed to inquire current file length"); 319376a2a30aSPavel Butsykin return old_file_size; 3194772d1f97SMax Reitz } 3195772d1f97SMax Reitz 3196772d1f97SMax Reitz nb_new_data_clusters = DIV_ROUND_UP(offset - old_length, 3197772d1f97SMax Reitz s->cluster_size); 3198772d1f97SMax Reitz 3199772d1f97SMax Reitz /* This is an overestimation; we will not actually allocate space for 3200772d1f97SMax Reitz * these in the file but just make sure the new refcount structures are 3201772d1f97SMax Reitz * able to cover them so we will not have to allocate new refblocks 3202772d1f97SMax Reitz * while entering the data blocks in the potentially new L2 tables. 3203772d1f97SMax Reitz * (We do not actually care where the L2 tables are placed. Maybe they 3204772d1f97SMax Reitz * are already allocated or they can be placed somewhere before 3205772d1f97SMax Reitz * @old_file_size. It does not matter because they will be fully 3206772d1f97SMax Reitz * allocated automatically, so they do not need to be covered by the 3207772d1f97SMax Reitz * preallocation. All that matters is that we will not have to allocate 3208772d1f97SMax Reitz * new refcount structures for them.) */ 3209772d1f97SMax Reitz nb_new_l2_tables = DIV_ROUND_UP(nb_new_data_clusters, 3210772d1f97SMax Reitz s->cluster_size / sizeof(uint64_t)); 3211772d1f97SMax Reitz /* The cluster range may not be aligned to L2 boundaries, so add one L2 3212772d1f97SMax Reitz * table for a potential head/tail */ 3213772d1f97SMax Reitz nb_new_l2_tables++; 3214772d1f97SMax Reitz 3215772d1f97SMax Reitz allocation_start = qcow2_refcount_area(bs, old_file_size, 3216772d1f97SMax Reitz nb_new_data_clusters + 3217772d1f97SMax Reitz nb_new_l2_tables, 3218772d1f97SMax Reitz true, 0, 0); 3219772d1f97SMax Reitz if (allocation_start < 0) { 3220772d1f97SMax Reitz error_setg_errno(errp, -allocation_start, 3221772d1f97SMax Reitz "Failed to resize refcount structures"); 322276a2a30aSPavel Butsykin return allocation_start; 3223772d1f97SMax Reitz } 3224772d1f97SMax Reitz 3225772d1f97SMax Reitz clusters_allocated = qcow2_alloc_clusters_at(bs, allocation_start, 3226772d1f97SMax Reitz nb_new_data_clusters); 3227772d1f97SMax Reitz if (clusters_allocated < 0) { 3228772d1f97SMax Reitz error_setg_errno(errp, -clusters_allocated, 3229772d1f97SMax Reitz "Failed to allocate data clusters"); 3230772d1f97SMax Reitz return -clusters_allocated; 3231772d1f97SMax Reitz } 3232772d1f97SMax Reitz 3233772d1f97SMax Reitz assert(clusters_allocated == nb_new_data_clusters); 3234772d1f97SMax Reitz 3235772d1f97SMax Reitz /* Allocate the data area */ 3236772d1f97SMax Reitz new_file_size = allocation_start + 3237772d1f97SMax Reitz nb_new_data_clusters * s->cluster_size; 3238772d1f97SMax Reitz ret = bdrv_truncate(bs->file, new_file_size, prealloc, errp); 3239772d1f97SMax Reitz if (ret < 0) { 3240772d1f97SMax Reitz error_prepend(errp, "Failed to resize underlying file: "); 3241772d1f97SMax Reitz qcow2_free_clusters(bs, allocation_start, 3242772d1f97SMax Reitz nb_new_data_clusters * s->cluster_size, 3243772d1f97SMax Reitz QCOW2_DISCARD_OTHER); 3244772d1f97SMax Reitz return ret; 3245772d1f97SMax Reitz } 3246772d1f97SMax Reitz 3247772d1f97SMax Reitz /* Create the necessary L2 entries */ 3248772d1f97SMax Reitz host_offset = allocation_start; 3249772d1f97SMax Reitz guest_offset = old_length; 3250772d1f97SMax Reitz while (nb_new_data_clusters) { 3251772d1f97SMax Reitz int64_t guest_cluster = guest_offset >> s->cluster_bits; 3252772d1f97SMax Reitz int64_t nb_clusters = MIN(nb_new_data_clusters, 3253772d1f97SMax Reitz s->l2_size - guest_cluster % s->l2_size); 3254772d1f97SMax Reitz QCowL2Meta allocation = { 3255772d1f97SMax Reitz .offset = guest_offset, 3256772d1f97SMax Reitz .alloc_offset = host_offset, 3257772d1f97SMax Reitz .nb_clusters = nb_clusters, 3258772d1f97SMax Reitz }; 3259772d1f97SMax Reitz qemu_co_queue_init(&allocation.dependent_requests); 3260772d1f97SMax Reitz 3261772d1f97SMax Reitz ret = qcow2_alloc_cluster_link_l2(bs, &allocation); 3262772d1f97SMax Reitz if (ret < 0) { 3263772d1f97SMax Reitz error_setg_errno(errp, -ret, "Failed to update L2 tables"); 3264772d1f97SMax Reitz qcow2_free_clusters(bs, host_offset, 3265772d1f97SMax Reitz nb_new_data_clusters * s->cluster_size, 3266772d1f97SMax Reitz QCOW2_DISCARD_OTHER); 3267772d1f97SMax Reitz return ret; 3268772d1f97SMax Reitz } 3269772d1f97SMax Reitz 3270772d1f97SMax Reitz guest_offset += nb_clusters * s->cluster_size; 3271772d1f97SMax Reitz host_offset += nb_clusters * s->cluster_size; 3272772d1f97SMax Reitz nb_new_data_clusters -= nb_clusters; 3273772d1f97SMax Reitz } 3274772d1f97SMax Reitz break; 3275772d1f97SMax Reitz } 3276772d1f97SMax Reitz 327795b98f34SMax Reitz default: 327895b98f34SMax Reitz g_assert_not_reached(); 327995b98f34SMax Reitz } 328095b98f34SMax Reitz 328195b98f34SMax Reitz if (prealloc != PREALLOC_MODE_OFF) { 328295b98f34SMax Reitz /* Flush metadata before actually changing the image size */ 328395b98f34SMax Reitz ret = bdrv_flush(bs); 328495b98f34SMax Reitz if (ret < 0) { 328595b98f34SMax Reitz error_setg_errno(errp, -ret, 328695b98f34SMax Reitz "Failed to flush the preallocated area to disk"); 328795b98f34SMax Reitz return ret; 328895b98f34SMax Reitz } 328995b98f34SMax Reitz } 329095b98f34SMax Reitz 3291419b19d9SStefan Hajnoczi /* write updated header.size */ 3292419b19d9SStefan Hajnoczi offset = cpu_to_be64(offset); 3293d9ca2ea2SKevin Wolf ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, size), 3294419b19d9SStefan Hajnoczi &offset, sizeof(uint64_t)); 3295419b19d9SStefan Hajnoczi if (ret < 0) { 3296f59adb32SMax Reitz error_setg_errno(errp, -ret, "Failed to update the image size"); 3297419b19d9SStefan Hajnoczi return ret; 3298419b19d9SStefan Hajnoczi } 3299419b19d9SStefan Hajnoczi 3300419b19d9SStefan Hajnoczi s->l1_vm_state_index = new_l1_size; 3301419b19d9SStefan Hajnoczi return 0; 3302419b19d9SStefan Hajnoczi } 3303419b19d9SStefan Hajnoczi 330420d97356SBlue Swirl /* XXX: put compressed sectors first, then all the cluster aligned 330520d97356SBlue Swirl tables to avoid losing bytes in alignment */ 3306fcccefc5SPavel Butsykin static coroutine_fn int 3307fcccefc5SPavel Butsykin qcow2_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset, 3308fcccefc5SPavel Butsykin uint64_t bytes, QEMUIOVector *qiov) 330920d97356SBlue Swirl { 3310ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 3311fcccefc5SPavel Butsykin QEMUIOVector hd_qiov; 3312fcccefc5SPavel Butsykin struct iovec iov; 331320d97356SBlue Swirl z_stream strm; 331420d97356SBlue Swirl int ret, out_len; 3315fcccefc5SPavel Butsykin uint8_t *buf, *out_buf; 3316d0d5d0e3SEric Blake int64_t cluster_offset; 331720d97356SBlue Swirl 3318fcccefc5SPavel Butsykin if (bytes == 0) { 331920d97356SBlue Swirl /* align end of file to a sector boundary to ease reading with 332020d97356SBlue Swirl sector based I/Os */ 33219a4f4c31SKevin Wolf cluster_offset = bdrv_getlength(bs->file->bs); 3322d0d5d0e3SEric Blake if (cluster_offset < 0) { 3323d0d5d0e3SEric Blake return cluster_offset; 3324d0d5d0e3SEric Blake } 33257ea37c30SMax Reitz return bdrv_truncate(bs->file, cluster_offset, PREALLOC_MODE_OFF, NULL); 332620d97356SBlue Swirl } 332720d97356SBlue Swirl 3328fcccefc5SPavel Butsykin buf = qemu_blockalign(bs, s->cluster_size); 3329a2c0ca6fSPavel Butsykin if (bytes != s->cluster_size) { 3330a2c0ca6fSPavel Butsykin if (bytes > s->cluster_size || 3331a2c0ca6fSPavel Butsykin offset + bytes != bs->total_sectors << BDRV_SECTOR_BITS) 3332a2c0ca6fSPavel Butsykin { 3333a2c0ca6fSPavel Butsykin qemu_vfree(buf); 3334a2c0ca6fSPavel Butsykin return -EINVAL; 3335a2c0ca6fSPavel Butsykin } 3336a2c0ca6fSPavel Butsykin /* Zero-pad last write if image size is not cluster aligned */ 3337a2c0ca6fSPavel Butsykin memset(buf + bytes, 0, s->cluster_size - bytes); 3338a2c0ca6fSPavel Butsykin } 33398b2bd093SPavel Butsykin qemu_iovec_to_buf(qiov, 0, buf, bytes); 334020d97356SBlue Swirl 3341ebf7bba0SVladimir Sementsov-Ogievskiy out_buf = g_malloc(s->cluster_size); 334220d97356SBlue Swirl 334320d97356SBlue Swirl /* best compression, small window, no zlib header */ 334420d97356SBlue Swirl memset(&strm, 0, sizeof(strm)); 334520d97356SBlue Swirl ret = deflateInit2(&strm, Z_DEFAULT_COMPRESSION, 334620d97356SBlue Swirl Z_DEFLATED, -12, 334720d97356SBlue Swirl 9, Z_DEFAULT_STRATEGY); 334820d97356SBlue Swirl if (ret != 0) { 33498f1efd00SKevin Wolf ret = -EINVAL; 33508f1efd00SKevin Wolf goto fail; 335120d97356SBlue Swirl } 335220d97356SBlue Swirl 335320d97356SBlue Swirl strm.avail_in = s->cluster_size; 335420d97356SBlue Swirl strm.next_in = (uint8_t *)buf; 335520d97356SBlue Swirl strm.avail_out = s->cluster_size; 335620d97356SBlue Swirl strm.next_out = out_buf; 335720d97356SBlue Swirl 335820d97356SBlue Swirl ret = deflate(&strm, Z_FINISH); 335920d97356SBlue Swirl if (ret != Z_STREAM_END && ret != Z_OK) { 336020d97356SBlue Swirl deflateEnd(&strm); 33618f1efd00SKevin Wolf ret = -EINVAL; 33628f1efd00SKevin Wolf goto fail; 336320d97356SBlue Swirl } 336420d97356SBlue Swirl out_len = strm.next_out - out_buf; 336520d97356SBlue Swirl 336620d97356SBlue Swirl deflateEnd(&strm); 336720d97356SBlue Swirl 336820d97356SBlue Swirl if (ret != Z_STREAM_END || out_len >= s->cluster_size) { 336920d97356SBlue Swirl /* could not compress: write normal cluster */ 3370fcccefc5SPavel Butsykin ret = qcow2_co_pwritev(bs, offset, bytes, qiov, 0); 33718f1efd00SKevin Wolf if (ret < 0) { 33728f1efd00SKevin Wolf goto fail; 33738f1efd00SKevin Wolf } 3374fcccefc5SPavel Butsykin goto success; 3375fcccefc5SPavel Butsykin } 3376fcccefc5SPavel Butsykin 3377fcccefc5SPavel Butsykin qemu_co_mutex_lock(&s->lock); 3378fcccefc5SPavel Butsykin cluster_offset = 3379fcccefc5SPavel Butsykin qcow2_alloc_compressed_cluster_offset(bs, offset, out_len); 33808f1efd00SKevin Wolf if (!cluster_offset) { 3381fcccefc5SPavel Butsykin qemu_co_mutex_unlock(&s->lock); 33828f1efd00SKevin Wolf ret = -EIO; 33838f1efd00SKevin Wolf goto fail; 33848f1efd00SKevin Wolf } 338520d97356SBlue Swirl cluster_offset &= s->cluster_offset_mask; 3386cf93980eSMax Reitz 3387231bb267SMax Reitz ret = qcow2_pre_write_overlap_check(bs, 0, cluster_offset, out_len); 3388fcccefc5SPavel Butsykin qemu_co_mutex_unlock(&s->lock); 3389cf93980eSMax Reitz if (ret < 0) { 3390cf93980eSMax Reitz goto fail; 3391cf93980eSMax Reitz } 3392cf93980eSMax Reitz 3393fcccefc5SPavel Butsykin iov = (struct iovec) { 3394fcccefc5SPavel Butsykin .iov_base = out_buf, 3395fcccefc5SPavel Butsykin .iov_len = out_len, 3396fcccefc5SPavel Butsykin }; 3397fcccefc5SPavel Butsykin qemu_iovec_init_external(&hd_qiov, &iov, 1); 3398fcccefc5SPavel Butsykin 339966f82ceeSKevin Wolf BLKDBG_EVENT(bs->file, BLKDBG_WRITE_COMPRESSED); 3400fcccefc5SPavel Butsykin ret = bdrv_co_pwritev(bs->file, cluster_offset, out_len, &hd_qiov, 0); 34018f1efd00SKevin Wolf if (ret < 0) { 34028f1efd00SKevin Wolf goto fail; 340320d97356SBlue Swirl } 3404fcccefc5SPavel Butsykin success: 34058f1efd00SKevin Wolf ret = 0; 34068f1efd00SKevin Wolf fail: 3407fcccefc5SPavel Butsykin qemu_vfree(buf); 34087267c094SAnthony Liguori g_free(out_buf); 34098f1efd00SKevin Wolf return ret; 341020d97356SBlue Swirl } 341120d97356SBlue Swirl 341294054183SMax Reitz static int make_completely_empty(BlockDriverState *bs) 341394054183SMax Reitz { 3414ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 3415ed3d2ec9SMax Reitz Error *local_err = NULL; 341694054183SMax Reitz int ret, l1_clusters; 341794054183SMax Reitz int64_t offset; 341894054183SMax Reitz uint64_t *new_reftable = NULL; 341994054183SMax Reitz uint64_t rt_entry, l1_size2; 342094054183SMax Reitz struct { 342194054183SMax Reitz uint64_t l1_offset; 342294054183SMax Reitz uint64_t reftable_offset; 342394054183SMax Reitz uint32_t reftable_clusters; 342494054183SMax Reitz } QEMU_PACKED l1_ofs_rt_ofs_cls; 342594054183SMax Reitz 342694054183SMax Reitz ret = qcow2_cache_empty(bs, s->l2_table_cache); 342794054183SMax Reitz if (ret < 0) { 342894054183SMax Reitz goto fail; 342994054183SMax Reitz } 343094054183SMax Reitz 343194054183SMax Reitz ret = qcow2_cache_empty(bs, s->refcount_block_cache); 343294054183SMax Reitz if (ret < 0) { 343394054183SMax Reitz goto fail; 343494054183SMax Reitz } 343594054183SMax Reitz 343694054183SMax Reitz /* Refcounts will be broken utterly */ 343794054183SMax Reitz ret = qcow2_mark_dirty(bs); 343894054183SMax Reitz if (ret < 0) { 343994054183SMax Reitz goto fail; 344094054183SMax Reitz } 344194054183SMax Reitz 344294054183SMax Reitz BLKDBG_EVENT(bs->file, BLKDBG_L1_UPDATE); 344394054183SMax Reitz 344494054183SMax Reitz l1_clusters = DIV_ROUND_UP(s->l1_size, s->cluster_size / sizeof(uint64_t)); 344594054183SMax Reitz l1_size2 = (uint64_t)s->l1_size * sizeof(uint64_t); 344694054183SMax Reitz 344794054183SMax Reitz /* After this call, neither the in-memory nor the on-disk refcount 344894054183SMax Reitz * information accurately describe the actual references */ 344994054183SMax Reitz 3450720ff280SKevin Wolf ret = bdrv_pwrite_zeroes(bs->file, s->l1_table_offset, 345174021bc4SEric Blake l1_clusters * s->cluster_size, 0); 345294054183SMax Reitz if (ret < 0) { 345394054183SMax Reitz goto fail_broken_refcounts; 345494054183SMax Reitz } 345594054183SMax Reitz memset(s->l1_table, 0, l1_size2); 345694054183SMax Reitz 345794054183SMax Reitz BLKDBG_EVENT(bs->file, BLKDBG_EMPTY_IMAGE_PREPARE); 345894054183SMax Reitz 345994054183SMax Reitz /* Overwrite enough clusters at the beginning of the sectors to place 346094054183SMax Reitz * the refcount table, a refcount block and the L1 table in; this may 346194054183SMax Reitz * overwrite parts of the existing refcount and L1 table, which is not 346294054183SMax Reitz * an issue because the dirty flag is set, complete data loss is in fact 346394054183SMax Reitz * desired and partial data loss is consequently fine as well */ 3464720ff280SKevin Wolf ret = bdrv_pwrite_zeroes(bs->file, s->cluster_size, 346574021bc4SEric Blake (2 + l1_clusters) * s->cluster_size, 0); 346694054183SMax Reitz /* This call (even if it failed overall) may have overwritten on-disk 346794054183SMax Reitz * refcount structures; in that case, the in-memory refcount information 346894054183SMax Reitz * will probably differ from the on-disk information which makes the BDS 346994054183SMax Reitz * unusable */ 347094054183SMax Reitz if (ret < 0) { 347194054183SMax Reitz goto fail_broken_refcounts; 347294054183SMax Reitz } 347394054183SMax Reitz 347494054183SMax Reitz BLKDBG_EVENT(bs->file, BLKDBG_L1_UPDATE); 347594054183SMax Reitz BLKDBG_EVENT(bs->file, BLKDBG_REFTABLE_UPDATE); 347694054183SMax Reitz 347794054183SMax Reitz /* "Create" an empty reftable (one cluster) directly after the image 347894054183SMax Reitz * header and an empty L1 table three clusters after the image header; 347994054183SMax Reitz * the cluster between those two will be used as the first refblock */ 3480f1f7a1ddSPeter Maydell l1_ofs_rt_ofs_cls.l1_offset = cpu_to_be64(3 * s->cluster_size); 3481f1f7a1ddSPeter Maydell l1_ofs_rt_ofs_cls.reftable_offset = cpu_to_be64(s->cluster_size); 3482f1f7a1ddSPeter Maydell l1_ofs_rt_ofs_cls.reftable_clusters = cpu_to_be32(1); 3483d9ca2ea2SKevin Wolf ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, l1_table_offset), 348494054183SMax Reitz &l1_ofs_rt_ofs_cls, sizeof(l1_ofs_rt_ofs_cls)); 348594054183SMax Reitz if (ret < 0) { 348694054183SMax Reitz goto fail_broken_refcounts; 348794054183SMax Reitz } 348894054183SMax Reitz 348994054183SMax Reitz s->l1_table_offset = 3 * s->cluster_size; 349094054183SMax Reitz 349194054183SMax Reitz new_reftable = g_try_new0(uint64_t, s->cluster_size / sizeof(uint64_t)); 349294054183SMax Reitz if (!new_reftable) { 349394054183SMax Reitz ret = -ENOMEM; 349494054183SMax Reitz goto fail_broken_refcounts; 349594054183SMax Reitz } 349694054183SMax Reitz 349794054183SMax Reitz s->refcount_table_offset = s->cluster_size; 349894054183SMax Reitz s->refcount_table_size = s->cluster_size / sizeof(uint64_t); 34997061a078SAlberto Garcia s->max_refcount_table_index = 0; 350094054183SMax Reitz 350194054183SMax Reitz g_free(s->refcount_table); 350294054183SMax Reitz s->refcount_table = new_reftable; 350394054183SMax Reitz new_reftable = NULL; 350494054183SMax Reitz 350594054183SMax Reitz /* Now the in-memory refcount information again corresponds to the on-disk 350694054183SMax Reitz * information (reftable is empty and no refblocks (the refblock cache is 350794054183SMax Reitz * empty)); however, this means some clusters (e.g. the image header) are 350894054183SMax Reitz * referenced, but not refcounted, but the normal qcow2 code assumes that 350994054183SMax Reitz * the in-memory information is always correct */ 351094054183SMax Reitz 351194054183SMax Reitz BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC); 351294054183SMax Reitz 351394054183SMax Reitz /* Enter the first refblock into the reftable */ 351494054183SMax Reitz rt_entry = cpu_to_be64(2 * s->cluster_size); 3515d9ca2ea2SKevin Wolf ret = bdrv_pwrite_sync(bs->file, s->cluster_size, 351694054183SMax Reitz &rt_entry, sizeof(rt_entry)); 351794054183SMax Reitz if (ret < 0) { 351894054183SMax Reitz goto fail_broken_refcounts; 351994054183SMax Reitz } 352094054183SMax Reitz s->refcount_table[0] = 2 * s->cluster_size; 352194054183SMax Reitz 352294054183SMax Reitz s->free_cluster_index = 0; 352394054183SMax Reitz assert(3 + l1_clusters <= s->refcount_block_size); 352494054183SMax Reitz offset = qcow2_alloc_clusters(bs, 3 * s->cluster_size + l1_size2); 352594054183SMax Reitz if (offset < 0) { 352694054183SMax Reitz ret = offset; 352794054183SMax Reitz goto fail_broken_refcounts; 352894054183SMax Reitz } else if (offset > 0) { 352994054183SMax Reitz error_report("First cluster in emptied image is in use"); 353094054183SMax Reitz abort(); 353194054183SMax Reitz } 353294054183SMax Reitz 353394054183SMax Reitz /* Now finally the in-memory information corresponds to the on-disk 353494054183SMax Reitz * structures and is correct */ 353594054183SMax Reitz ret = qcow2_mark_clean(bs); 353694054183SMax Reitz if (ret < 0) { 353794054183SMax Reitz goto fail; 353894054183SMax Reitz } 353994054183SMax Reitz 3540ed3d2ec9SMax Reitz ret = bdrv_truncate(bs->file, (3 + l1_clusters) * s->cluster_size, 35417ea37c30SMax Reitz PREALLOC_MODE_OFF, &local_err); 354294054183SMax Reitz if (ret < 0) { 3543ed3d2ec9SMax Reitz error_report_err(local_err); 354494054183SMax Reitz goto fail; 354594054183SMax Reitz } 354694054183SMax Reitz 354794054183SMax Reitz return 0; 354894054183SMax Reitz 354994054183SMax Reitz fail_broken_refcounts: 355094054183SMax Reitz /* The BDS is unusable at this point. If we wanted to make it usable, we 355194054183SMax Reitz * would have to call qcow2_refcount_close(), qcow2_refcount_init(), 355294054183SMax Reitz * qcow2_check_refcounts(), qcow2_refcount_close() and qcow2_refcount_init() 355394054183SMax Reitz * again. However, because the functions which could have caused this error 355494054183SMax Reitz * path to be taken are used by those functions as well, it's very likely 355594054183SMax Reitz * that that sequence will fail as well. Therefore, just eject the BDS. */ 355694054183SMax Reitz bs->drv = NULL; 355794054183SMax Reitz 355894054183SMax Reitz fail: 355994054183SMax Reitz g_free(new_reftable); 356094054183SMax Reitz return ret; 356194054183SMax Reitz } 356294054183SMax Reitz 3563491d27e2SMax Reitz static int qcow2_make_empty(BlockDriverState *bs) 3564491d27e2SMax Reitz { 3565ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 3566d2cb36afSEric Blake uint64_t offset, end_offset; 3567d2cb36afSEric Blake int step = QEMU_ALIGN_DOWN(INT_MAX, s->cluster_size); 356894054183SMax Reitz int l1_clusters, ret = 0; 3569491d27e2SMax Reitz 357094054183SMax Reitz l1_clusters = DIV_ROUND_UP(s->l1_size, s->cluster_size / sizeof(uint64_t)); 357194054183SMax Reitz 357294054183SMax Reitz if (s->qcow_version >= 3 && !s->snapshots && 357394054183SMax Reitz 3 + l1_clusters <= s->refcount_block_size) { 357494054183SMax Reitz /* The following function only works for qcow2 v3 images (it requires 357594054183SMax Reitz * the dirty flag) and only as long as there are no snapshots (because 357694054183SMax Reitz * it completely empties the image). Furthermore, the L1 table and three 357794054183SMax Reitz * additional clusters (image header, refcount table, one refcount 357894054183SMax Reitz * block) have to fit inside one refcount block. */ 357994054183SMax Reitz return make_completely_empty(bs); 358094054183SMax Reitz } 358194054183SMax Reitz 358294054183SMax Reitz /* This fallback code simply discards every active cluster; this is slow, 358394054183SMax Reitz * but works in all cases */ 3584d2cb36afSEric Blake end_offset = bs->total_sectors * BDRV_SECTOR_SIZE; 3585d2cb36afSEric Blake for (offset = 0; offset < end_offset; offset += step) { 3586491d27e2SMax Reitz /* As this function is generally used after committing an external 3587491d27e2SMax Reitz * snapshot, QCOW2_DISCARD_SNAPSHOT seems appropriate. Also, the 3588491d27e2SMax Reitz * default action for this kind of discard is to pass the discard, 3589491d27e2SMax Reitz * which will ideally result in an actually smaller image file, as 3590491d27e2SMax Reitz * is probably desired. */ 3591d2cb36afSEric Blake ret = qcow2_cluster_discard(bs, offset, MIN(step, end_offset - offset), 3592491d27e2SMax Reitz QCOW2_DISCARD_SNAPSHOT, true); 3593491d27e2SMax Reitz if (ret < 0) { 3594491d27e2SMax Reitz break; 3595491d27e2SMax Reitz } 3596491d27e2SMax Reitz } 3597491d27e2SMax Reitz 3598491d27e2SMax Reitz return ret; 3599491d27e2SMax Reitz } 3600491d27e2SMax Reitz 3601a968168cSDong Xu Wang static coroutine_fn int qcow2_co_flush_to_os(BlockDriverState *bs) 360220d97356SBlue Swirl { 3603ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 360429c1a730SKevin Wolf int ret; 360529c1a730SKevin Wolf 36068b94ff85SPaolo Bonzini qemu_co_mutex_lock(&s->lock); 3607f3c3b87dSDenis V. Lunev ret = qcow2_cache_write(bs, s->l2_table_cache); 360829c1a730SKevin Wolf if (ret < 0) { 3609c95de7e2SDong Xu Wang qemu_co_mutex_unlock(&s->lock); 36108b94ff85SPaolo Bonzini return ret; 361129c1a730SKevin Wolf } 361229c1a730SKevin Wolf 3613bfe8043eSStefan Hajnoczi if (qcow2_need_accurate_refcounts(s)) { 3614f3c3b87dSDenis V. Lunev ret = qcow2_cache_write(bs, s->refcount_block_cache); 361529c1a730SKevin Wolf if (ret < 0) { 3616c95de7e2SDong Xu Wang qemu_co_mutex_unlock(&s->lock); 36178b94ff85SPaolo Bonzini return ret; 361829c1a730SKevin Wolf } 3619bfe8043eSStefan Hajnoczi } 36208b94ff85SPaolo Bonzini qemu_co_mutex_unlock(&s->lock); 362129c1a730SKevin Wolf 3622eb489bb1SKevin Wolf return 0; 3623eb489bb1SKevin Wolf } 3624eb489bb1SKevin Wolf 3625c501c352SStefan Hajnoczi static BlockMeasureInfo *qcow2_measure(QemuOpts *opts, BlockDriverState *in_bs, 3626c501c352SStefan Hajnoczi Error **errp) 3627c501c352SStefan Hajnoczi { 3628c501c352SStefan Hajnoczi Error *local_err = NULL; 3629c501c352SStefan Hajnoczi BlockMeasureInfo *info; 3630c501c352SStefan Hajnoczi uint64_t required = 0; /* bytes that contribute to required size */ 3631c501c352SStefan Hajnoczi uint64_t virtual_size; /* disk size as seen by guest */ 3632c501c352SStefan Hajnoczi uint64_t refcount_bits; 3633c501c352SStefan Hajnoczi uint64_t l2_tables; 3634c501c352SStefan Hajnoczi size_t cluster_size; 3635c501c352SStefan Hajnoczi int version; 3636c501c352SStefan Hajnoczi char *optstr; 3637c501c352SStefan Hajnoczi PreallocMode prealloc; 3638c501c352SStefan Hajnoczi bool has_backing_file; 3639c501c352SStefan Hajnoczi 3640c501c352SStefan Hajnoczi /* Parse image creation options */ 3641c501c352SStefan Hajnoczi cluster_size = qcow2_opt_get_cluster_size_del(opts, &local_err); 3642c501c352SStefan Hajnoczi if (local_err) { 3643c501c352SStefan Hajnoczi goto err; 3644c501c352SStefan Hajnoczi } 3645c501c352SStefan Hajnoczi 3646c501c352SStefan Hajnoczi version = qcow2_opt_get_version_del(opts, &local_err); 3647c501c352SStefan Hajnoczi if (local_err) { 3648c501c352SStefan Hajnoczi goto err; 3649c501c352SStefan Hajnoczi } 3650c501c352SStefan Hajnoczi 3651c501c352SStefan Hajnoczi refcount_bits = qcow2_opt_get_refcount_bits_del(opts, version, &local_err); 3652c501c352SStefan Hajnoczi if (local_err) { 3653c501c352SStefan Hajnoczi goto err; 3654c501c352SStefan Hajnoczi } 3655c501c352SStefan Hajnoczi 3656c501c352SStefan Hajnoczi optstr = qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC); 3657f7abe0ecSMarc-André Lureau prealloc = qapi_enum_parse(&PreallocMode_lookup, optstr, 365806c60b6cSMarkus Armbruster PREALLOC_MODE_OFF, &local_err); 3659c501c352SStefan Hajnoczi g_free(optstr); 3660c501c352SStefan Hajnoczi if (local_err) { 3661c501c352SStefan Hajnoczi goto err; 3662c501c352SStefan Hajnoczi } 3663c501c352SStefan Hajnoczi 3664c501c352SStefan Hajnoczi optstr = qemu_opt_get_del(opts, BLOCK_OPT_BACKING_FILE); 3665c501c352SStefan Hajnoczi has_backing_file = !!optstr; 3666c501c352SStefan Hajnoczi g_free(optstr); 3667c501c352SStefan Hajnoczi 3668c501c352SStefan Hajnoczi virtual_size = align_offset(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0), 3669c501c352SStefan Hajnoczi cluster_size); 3670c501c352SStefan Hajnoczi 3671c501c352SStefan Hajnoczi /* Check that virtual disk size is valid */ 3672c501c352SStefan Hajnoczi l2_tables = DIV_ROUND_UP(virtual_size / cluster_size, 3673c501c352SStefan Hajnoczi cluster_size / sizeof(uint64_t)); 3674c501c352SStefan Hajnoczi if (l2_tables * sizeof(uint64_t) > QCOW_MAX_L1_SIZE) { 3675c501c352SStefan Hajnoczi error_setg(&local_err, "The image size is too large " 3676c501c352SStefan Hajnoczi "(try using a larger cluster size)"); 3677c501c352SStefan Hajnoczi goto err; 3678c501c352SStefan Hajnoczi } 3679c501c352SStefan Hajnoczi 3680c501c352SStefan Hajnoczi /* Account for input image */ 3681c501c352SStefan Hajnoczi if (in_bs) { 3682c501c352SStefan Hajnoczi int64_t ssize = bdrv_getlength(in_bs); 3683c501c352SStefan Hajnoczi if (ssize < 0) { 3684c501c352SStefan Hajnoczi error_setg_errno(&local_err, -ssize, 3685c501c352SStefan Hajnoczi "Unable to get image virtual_size"); 3686c501c352SStefan Hajnoczi goto err; 3687c501c352SStefan Hajnoczi } 3688c501c352SStefan Hajnoczi 3689c501c352SStefan Hajnoczi virtual_size = align_offset(ssize, cluster_size); 3690c501c352SStefan Hajnoczi 3691c501c352SStefan Hajnoczi if (has_backing_file) { 3692c501c352SStefan Hajnoczi /* We don't how much of the backing chain is shared by the input 3693c501c352SStefan Hajnoczi * image and the new image file. In the worst case the new image's 3694c501c352SStefan Hajnoczi * backing file has nothing in common with the input image. Be 3695c501c352SStefan Hajnoczi * conservative and assume all clusters need to be written. 3696c501c352SStefan Hajnoczi */ 3697c501c352SStefan Hajnoczi required = virtual_size; 3698c501c352SStefan Hajnoczi } else { 3699b85ee453SEric Blake int64_t offset; 3700c501c352SStefan Hajnoczi int pnum = 0; 3701c501c352SStefan Hajnoczi 3702b85ee453SEric Blake for (offset = 0; offset < ssize; 3703b85ee453SEric Blake offset += pnum * BDRV_SECTOR_SIZE) { 3704b85ee453SEric Blake int nb_sectors = MIN(ssize - offset, 3705b85ee453SEric Blake BDRV_REQUEST_MAX_BYTES) / BDRV_SECTOR_SIZE; 3706c501c352SStefan Hajnoczi BlockDriverState *file; 3707c501c352SStefan Hajnoczi int64_t ret; 3708c501c352SStefan Hajnoczi 3709c501c352SStefan Hajnoczi ret = bdrv_get_block_status_above(in_bs, NULL, 3710b85ee453SEric Blake offset >> BDRV_SECTOR_BITS, 3711b85ee453SEric Blake nb_sectors, 3712c501c352SStefan Hajnoczi &pnum, &file); 3713c501c352SStefan Hajnoczi if (ret < 0) { 3714c501c352SStefan Hajnoczi error_setg_errno(&local_err, -ret, 3715c501c352SStefan Hajnoczi "Unable to get block status"); 3716c501c352SStefan Hajnoczi goto err; 3717c501c352SStefan Hajnoczi } 3718c501c352SStefan Hajnoczi 3719c501c352SStefan Hajnoczi if (ret & BDRV_BLOCK_ZERO) { 3720c501c352SStefan Hajnoczi /* Skip zero regions (safe with no backing file) */ 3721c501c352SStefan Hajnoczi } else if ((ret & (BDRV_BLOCK_DATA | BDRV_BLOCK_ALLOCATED)) == 3722c501c352SStefan Hajnoczi (BDRV_BLOCK_DATA | BDRV_BLOCK_ALLOCATED)) { 3723c501c352SStefan Hajnoczi /* Extend pnum to end of cluster for next iteration */ 3724b85ee453SEric Blake pnum = (ROUND_UP(offset + pnum * BDRV_SECTOR_SIZE, 3725b85ee453SEric Blake cluster_size) - offset) >> BDRV_SECTOR_BITS; 3726c501c352SStefan Hajnoczi 3727c501c352SStefan Hajnoczi /* Count clusters we've seen */ 3728b85ee453SEric Blake required += offset % cluster_size + pnum * BDRV_SECTOR_SIZE; 3729c501c352SStefan Hajnoczi } 3730c501c352SStefan Hajnoczi } 3731c501c352SStefan Hajnoczi } 3732c501c352SStefan Hajnoczi } 3733c501c352SStefan Hajnoczi 3734c501c352SStefan Hajnoczi /* Take into account preallocation. Nothing special is needed for 3735c501c352SStefan Hajnoczi * PREALLOC_MODE_METADATA since metadata is always counted. 3736c501c352SStefan Hajnoczi */ 3737c501c352SStefan Hajnoczi if (prealloc == PREALLOC_MODE_FULL || prealloc == PREALLOC_MODE_FALLOC) { 3738c501c352SStefan Hajnoczi required = virtual_size; 3739c501c352SStefan Hajnoczi } 3740c501c352SStefan Hajnoczi 3741c501c352SStefan Hajnoczi info = g_new(BlockMeasureInfo, 1); 3742c501c352SStefan Hajnoczi info->fully_allocated = 3743c501c352SStefan Hajnoczi qcow2_calc_prealloc_size(virtual_size, cluster_size, 3744c501c352SStefan Hajnoczi ctz32(refcount_bits)); 3745c501c352SStefan Hajnoczi 3746c501c352SStefan Hajnoczi /* Remove data clusters that are not required. This overestimates the 3747c501c352SStefan Hajnoczi * required size because metadata needed for the fully allocated file is 3748c501c352SStefan Hajnoczi * still counted. 3749c501c352SStefan Hajnoczi */ 3750c501c352SStefan Hajnoczi info->required = info->fully_allocated - virtual_size + required; 3751c501c352SStefan Hajnoczi return info; 3752c501c352SStefan Hajnoczi 3753c501c352SStefan Hajnoczi err: 3754c501c352SStefan Hajnoczi error_propagate(errp, local_err); 3755c501c352SStefan Hajnoczi return NULL; 3756c501c352SStefan Hajnoczi } 3757c501c352SStefan Hajnoczi 37587c80ab3fSJes Sorensen static int qcow2_get_info(BlockDriverState *bs, BlockDriverInfo *bdi) 375920d97356SBlue Swirl { 3760ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 376195de6d70SPaolo Bonzini bdi->unallocated_blocks_are_zero = true; 376295de6d70SPaolo Bonzini bdi->can_write_zeroes_with_unmap = (s->qcow_version >= 3); 376320d97356SBlue Swirl bdi->cluster_size = s->cluster_size; 37647c80ab3fSJes Sorensen bdi->vm_state_offset = qcow2_vm_state_offset(s); 376520d97356SBlue Swirl return 0; 376620d97356SBlue Swirl } 376720d97356SBlue Swirl 376837764dfbSMax Reitz static ImageInfoSpecific *qcow2_get_specific_info(BlockDriverState *bs) 376937764dfbSMax Reitz { 3770ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 37710a12f6f8SDaniel P. Berrange ImageInfoSpecific *spec_info; 37720a12f6f8SDaniel P. Berrange QCryptoBlockInfo *encrypt_info = NULL; 377337764dfbSMax Reitz 37740a12f6f8SDaniel P. Berrange if (s->crypto != NULL) { 37750a12f6f8SDaniel P. Berrange encrypt_info = qcrypto_block_get_info(s->crypto, &error_abort); 37760a12f6f8SDaniel P. Berrange } 37770a12f6f8SDaniel P. Berrange 37780a12f6f8SDaniel P. Berrange spec_info = g_new(ImageInfoSpecific, 1); 377937764dfbSMax Reitz *spec_info = (ImageInfoSpecific){ 37806a8f9661SEric Blake .type = IMAGE_INFO_SPECIFIC_KIND_QCOW2, 378132bafa8fSEric Blake .u.qcow2.data = g_new(ImageInfoSpecificQCow2, 1), 378237764dfbSMax Reitz }; 378337764dfbSMax Reitz if (s->qcow_version == 2) { 378432bafa8fSEric Blake *spec_info->u.qcow2.data = (ImageInfoSpecificQCow2){ 378537764dfbSMax Reitz .compat = g_strdup("0.10"), 37860709c5a1SMax Reitz .refcount_bits = s->refcount_bits, 378737764dfbSMax Reitz }; 378837764dfbSMax Reitz } else if (s->qcow_version == 3) { 378932bafa8fSEric Blake *spec_info->u.qcow2.data = (ImageInfoSpecificQCow2){ 379037764dfbSMax Reitz .compat = g_strdup("1.1"), 379137764dfbSMax Reitz .lazy_refcounts = s->compatible_features & 379237764dfbSMax Reitz QCOW2_COMPAT_LAZY_REFCOUNTS, 379337764dfbSMax Reitz .has_lazy_refcounts = true, 37949009b196SMax Reitz .corrupt = s->incompatible_features & 37959009b196SMax Reitz QCOW2_INCOMPAT_CORRUPT, 37969009b196SMax Reitz .has_corrupt = true, 37970709c5a1SMax Reitz .refcount_bits = s->refcount_bits, 379837764dfbSMax Reitz }; 3799b1fc8f93SDenis V. Lunev } else { 3800b1fc8f93SDenis V. Lunev /* if this assertion fails, this probably means a new version was 3801b1fc8f93SDenis V. Lunev * added without having it covered here */ 3802b1fc8f93SDenis V. Lunev assert(false); 380337764dfbSMax Reitz } 380437764dfbSMax Reitz 38050a12f6f8SDaniel P. Berrange if (encrypt_info) { 38060a12f6f8SDaniel P. Berrange ImageInfoSpecificQCow2Encryption *qencrypt = 38070a12f6f8SDaniel P. Berrange g_new(ImageInfoSpecificQCow2Encryption, 1); 38080a12f6f8SDaniel P. Berrange switch (encrypt_info->format) { 38090a12f6f8SDaniel P. Berrange case Q_CRYPTO_BLOCK_FORMAT_QCOW: 38100a12f6f8SDaniel P. Berrange qencrypt->format = BLOCKDEV_QCOW2_ENCRYPTION_FORMAT_AES; 38110a12f6f8SDaniel P. Berrange qencrypt->u.aes = encrypt_info->u.qcow; 38120a12f6f8SDaniel P. Berrange break; 38130a12f6f8SDaniel P. Berrange case Q_CRYPTO_BLOCK_FORMAT_LUKS: 38140a12f6f8SDaniel P. Berrange qencrypt->format = BLOCKDEV_QCOW2_ENCRYPTION_FORMAT_LUKS; 38150a12f6f8SDaniel P. Berrange qencrypt->u.luks = encrypt_info->u.luks; 38160a12f6f8SDaniel P. Berrange break; 38170a12f6f8SDaniel P. Berrange default: 38180a12f6f8SDaniel P. Berrange abort(); 38190a12f6f8SDaniel P. Berrange } 38200a12f6f8SDaniel P. Berrange /* Since we did shallow copy above, erase any pointers 38210a12f6f8SDaniel P. Berrange * in the original info */ 38220a12f6f8SDaniel P. Berrange memset(&encrypt_info->u, 0, sizeof(encrypt_info->u)); 38230a12f6f8SDaniel P. Berrange qapi_free_QCryptoBlockInfo(encrypt_info); 38240a12f6f8SDaniel P. Berrange 38250a12f6f8SDaniel P. Berrange spec_info->u.qcow2.data->has_encrypt = true; 38260a12f6f8SDaniel P. Berrange spec_info->u.qcow2.data->encrypt = qencrypt; 38270a12f6f8SDaniel P. Berrange } 38280a12f6f8SDaniel P. Berrange 382937764dfbSMax Reitz return spec_info; 383037764dfbSMax Reitz } 383137764dfbSMax Reitz 3832cf8074b3SKevin Wolf static int qcow2_save_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, 3833cf8074b3SKevin Wolf int64_t pos) 383420d97356SBlue Swirl { 3835ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 383620d97356SBlue Swirl 383766f82ceeSKevin Wolf BLKDBG_EVENT(bs->file, BLKDBG_VMSTATE_SAVE); 3838734a7758SKevin Wolf return bs->drv->bdrv_co_pwritev(bs, qcow2_vm_state_offset(s) + pos, 3839734a7758SKevin Wolf qiov->size, qiov, 0); 384020d97356SBlue Swirl } 384120d97356SBlue Swirl 38425ddda0b8SKevin Wolf static int qcow2_load_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, 38435ddda0b8SKevin Wolf int64_t pos) 384420d97356SBlue Swirl { 3845ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 384620d97356SBlue Swirl 384766f82ceeSKevin Wolf BLKDBG_EVENT(bs->file, BLKDBG_VMSTATE_LOAD); 3848734a7758SKevin Wolf return bs->drv->bdrv_co_preadv(bs, qcow2_vm_state_offset(s) + pos, 3849734a7758SKevin Wolf qiov->size, qiov, 0); 385020d97356SBlue Swirl } 385120d97356SBlue Swirl 38529296b3edSMax Reitz /* 38539296b3edSMax Reitz * Downgrades an image's version. To achieve this, any incompatible features 38549296b3edSMax Reitz * have to be removed. 38559296b3edSMax Reitz */ 38564057a2b2SMax Reitz static int qcow2_downgrade(BlockDriverState *bs, int target_version, 38578b13976dSMax Reitz BlockDriverAmendStatusCB *status_cb, void *cb_opaque) 38589296b3edSMax Reitz { 3859ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 38609296b3edSMax Reitz int current_version = s->qcow_version; 38619296b3edSMax Reitz int ret; 38629296b3edSMax Reitz 38639296b3edSMax Reitz if (target_version == current_version) { 38649296b3edSMax Reitz return 0; 38659296b3edSMax Reitz } else if (target_version > current_version) { 38669296b3edSMax Reitz return -EINVAL; 38679296b3edSMax Reitz } else if (target_version != 2) { 38689296b3edSMax Reitz return -EINVAL; 38699296b3edSMax Reitz } 38709296b3edSMax Reitz 38719296b3edSMax Reitz if (s->refcount_order != 4) { 387261ce55fcSMax Reitz error_report("compat=0.10 requires refcount_bits=16"); 38739296b3edSMax Reitz return -ENOTSUP; 38749296b3edSMax Reitz } 38759296b3edSMax Reitz 38769296b3edSMax Reitz /* clear incompatible features */ 38779296b3edSMax Reitz if (s->incompatible_features & QCOW2_INCOMPAT_DIRTY) { 38789296b3edSMax Reitz ret = qcow2_mark_clean(bs); 38799296b3edSMax Reitz if (ret < 0) { 38809296b3edSMax Reitz return ret; 38819296b3edSMax Reitz } 38829296b3edSMax Reitz } 38839296b3edSMax Reitz 38849296b3edSMax Reitz /* with QCOW2_INCOMPAT_CORRUPT, it is pretty much impossible to get here in 38859296b3edSMax Reitz * the first place; if that happens nonetheless, returning -ENOTSUP is the 38869296b3edSMax Reitz * best thing to do anyway */ 38879296b3edSMax Reitz 38889296b3edSMax Reitz if (s->incompatible_features) { 38899296b3edSMax Reitz return -ENOTSUP; 38909296b3edSMax Reitz } 38919296b3edSMax Reitz 38929296b3edSMax Reitz /* since we can ignore compatible features, we can set them to 0 as well */ 38939296b3edSMax Reitz s->compatible_features = 0; 38949296b3edSMax Reitz /* if lazy refcounts have been used, they have already been fixed through 38959296b3edSMax Reitz * clearing the dirty flag */ 38969296b3edSMax Reitz 38979296b3edSMax Reitz /* clearing autoclear features is trivial */ 38989296b3edSMax Reitz s->autoclear_features = 0; 38999296b3edSMax Reitz 39008b13976dSMax Reitz ret = qcow2_expand_zero_clusters(bs, status_cb, cb_opaque); 39019296b3edSMax Reitz if (ret < 0) { 39029296b3edSMax Reitz return ret; 39039296b3edSMax Reitz } 39049296b3edSMax Reitz 39059296b3edSMax Reitz s->qcow_version = target_version; 39069296b3edSMax Reitz ret = qcow2_update_header(bs); 39079296b3edSMax Reitz if (ret < 0) { 39089296b3edSMax Reitz s->qcow_version = current_version; 39099296b3edSMax Reitz return ret; 39109296b3edSMax Reitz } 39119296b3edSMax Reitz return 0; 39129296b3edSMax Reitz } 39139296b3edSMax Reitz 3914c293a809SMax Reitz typedef enum Qcow2AmendOperation { 3915c293a809SMax Reitz /* This is the value Qcow2AmendHelperCBInfo::last_operation will be 3916c293a809SMax Reitz * statically initialized to so that the helper CB can discern the first 3917c293a809SMax Reitz * invocation from an operation change */ 3918c293a809SMax Reitz QCOW2_NO_OPERATION = 0, 3919c293a809SMax Reitz 392061ce55fcSMax Reitz QCOW2_CHANGING_REFCOUNT_ORDER, 3921c293a809SMax Reitz QCOW2_DOWNGRADING, 3922c293a809SMax Reitz } Qcow2AmendOperation; 3923c293a809SMax Reitz 3924c293a809SMax Reitz typedef struct Qcow2AmendHelperCBInfo { 3925c293a809SMax Reitz /* The code coordinating the amend operations should only modify 3926c293a809SMax Reitz * these four fields; the rest will be managed by the CB */ 3927c293a809SMax Reitz BlockDriverAmendStatusCB *original_status_cb; 3928c293a809SMax Reitz void *original_cb_opaque; 3929c293a809SMax Reitz 3930c293a809SMax Reitz Qcow2AmendOperation current_operation; 3931c293a809SMax Reitz 3932c293a809SMax Reitz /* Total number of operations to perform (only set once) */ 3933c293a809SMax Reitz int total_operations; 3934c293a809SMax Reitz 3935c293a809SMax Reitz /* The following fields are managed by the CB */ 3936c293a809SMax Reitz 3937c293a809SMax Reitz /* Number of operations completed */ 3938c293a809SMax Reitz int operations_completed; 3939c293a809SMax Reitz 3940c293a809SMax Reitz /* Cumulative offset of all completed operations */ 3941c293a809SMax Reitz int64_t offset_completed; 3942c293a809SMax Reitz 3943c293a809SMax Reitz Qcow2AmendOperation last_operation; 3944c293a809SMax Reitz int64_t last_work_size; 3945c293a809SMax Reitz } Qcow2AmendHelperCBInfo; 3946c293a809SMax Reitz 3947c293a809SMax Reitz static void qcow2_amend_helper_cb(BlockDriverState *bs, 3948c293a809SMax Reitz int64_t operation_offset, 3949c293a809SMax Reitz int64_t operation_work_size, void *opaque) 3950c293a809SMax Reitz { 3951c293a809SMax Reitz Qcow2AmendHelperCBInfo *info = opaque; 3952c293a809SMax Reitz int64_t current_work_size; 3953c293a809SMax Reitz int64_t projected_work_size; 3954c293a809SMax Reitz 3955c293a809SMax Reitz if (info->current_operation != info->last_operation) { 3956c293a809SMax Reitz if (info->last_operation != QCOW2_NO_OPERATION) { 3957c293a809SMax Reitz info->offset_completed += info->last_work_size; 3958c293a809SMax Reitz info->operations_completed++; 3959c293a809SMax Reitz } 3960c293a809SMax Reitz 3961c293a809SMax Reitz info->last_operation = info->current_operation; 3962c293a809SMax Reitz } 3963c293a809SMax Reitz 3964c293a809SMax Reitz assert(info->total_operations > 0); 3965c293a809SMax Reitz assert(info->operations_completed < info->total_operations); 3966c293a809SMax Reitz 3967c293a809SMax Reitz info->last_work_size = operation_work_size; 3968c293a809SMax Reitz 3969c293a809SMax Reitz current_work_size = info->offset_completed + operation_work_size; 3970c293a809SMax Reitz 3971c293a809SMax Reitz /* current_work_size is the total work size for (operations_completed + 1) 3972c293a809SMax Reitz * operations (which includes this one), so multiply it by the number of 3973c293a809SMax Reitz * operations not covered and divide it by the number of operations 3974c293a809SMax Reitz * covered to get a projection for the operations not covered */ 3975c293a809SMax Reitz projected_work_size = current_work_size * (info->total_operations - 3976c293a809SMax Reitz info->operations_completed - 1) 3977c293a809SMax Reitz / (info->operations_completed + 1); 3978c293a809SMax Reitz 3979c293a809SMax Reitz info->original_status_cb(bs, info->offset_completed + operation_offset, 3980c293a809SMax Reitz current_work_size + projected_work_size, 3981c293a809SMax Reitz info->original_cb_opaque); 3982c293a809SMax Reitz } 3983c293a809SMax Reitz 398477485434SMax Reitz static int qcow2_amend_options(BlockDriverState *bs, QemuOpts *opts, 39858b13976dSMax Reitz BlockDriverAmendStatusCB *status_cb, 39868b13976dSMax Reitz void *cb_opaque) 39879296b3edSMax Reitz { 3988ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 39899296b3edSMax Reitz int old_version = s->qcow_version, new_version = old_version; 39909296b3edSMax Reitz uint64_t new_size = 0; 39919296b3edSMax Reitz const char *backing_file = NULL, *backing_format = NULL; 39929296b3edSMax Reitz bool lazy_refcounts = s->use_lazy_refcounts; 39931bd0e2d1SChunyan Liu const char *compat = NULL; 39941bd0e2d1SChunyan Liu uint64_t cluster_size = s->cluster_size; 39951bd0e2d1SChunyan Liu bool encrypt; 39964652b8f3SDaniel P. Berrange int encformat; 399761ce55fcSMax Reitz int refcount_bits = s->refcount_bits; 3998d7086422SKevin Wolf Error *local_err = NULL; 39999296b3edSMax Reitz int ret; 40001bd0e2d1SChunyan Liu QemuOptDesc *desc = opts->list->desc; 4001c293a809SMax Reitz Qcow2AmendHelperCBInfo helper_cb_info; 40029296b3edSMax Reitz 40031bd0e2d1SChunyan Liu while (desc && desc->name) { 40041bd0e2d1SChunyan Liu if (!qemu_opt_find(opts, desc->name)) { 40059296b3edSMax Reitz /* only change explicitly defined options */ 40061bd0e2d1SChunyan Liu desc++; 40079296b3edSMax Reitz continue; 40089296b3edSMax Reitz } 40099296b3edSMax Reitz 40108a17b83cSMax Reitz if (!strcmp(desc->name, BLOCK_OPT_COMPAT_LEVEL)) { 40118a17b83cSMax Reitz compat = qemu_opt_get(opts, BLOCK_OPT_COMPAT_LEVEL); 40121bd0e2d1SChunyan Liu if (!compat) { 40139296b3edSMax Reitz /* preserve default */ 40141bd0e2d1SChunyan Liu } else if (!strcmp(compat, "0.10")) { 40159296b3edSMax Reitz new_version = 2; 40161bd0e2d1SChunyan Liu } else if (!strcmp(compat, "1.1")) { 40179296b3edSMax Reitz new_version = 3; 40189296b3edSMax Reitz } else { 401929d72431SMax Reitz error_report("Unknown compatibility level %s", compat); 40209296b3edSMax Reitz return -EINVAL; 40219296b3edSMax Reitz } 40228a17b83cSMax Reitz } else if (!strcmp(desc->name, BLOCK_OPT_PREALLOC)) { 402329d72431SMax Reitz error_report("Cannot change preallocation mode"); 40249296b3edSMax Reitz return -ENOTSUP; 40258a17b83cSMax Reitz } else if (!strcmp(desc->name, BLOCK_OPT_SIZE)) { 40268a17b83cSMax Reitz new_size = qemu_opt_get_size(opts, BLOCK_OPT_SIZE, 0); 40278a17b83cSMax Reitz } else if (!strcmp(desc->name, BLOCK_OPT_BACKING_FILE)) { 40288a17b83cSMax Reitz backing_file = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE); 40298a17b83cSMax Reitz } else if (!strcmp(desc->name, BLOCK_OPT_BACKING_FMT)) { 40308a17b83cSMax Reitz backing_format = qemu_opt_get(opts, BLOCK_OPT_BACKING_FMT); 40318a17b83cSMax Reitz } else if (!strcmp(desc->name, BLOCK_OPT_ENCRYPT)) { 40328a17b83cSMax Reitz encrypt = qemu_opt_get_bool(opts, BLOCK_OPT_ENCRYPT, 4033b25b387fSDaniel P. Berrange !!s->crypto); 4034f6fa64f6SDaniel P. Berrange 4035b25b387fSDaniel P. Berrange if (encrypt != !!s->crypto) { 403629d72431SMax Reitz error_report("Changing the encryption flag is not supported"); 40379296b3edSMax Reitz return -ENOTSUP; 40389296b3edSMax Reitz } 40394652b8f3SDaniel P. Berrange } else if (!strcmp(desc->name, BLOCK_OPT_ENCRYPT_FORMAT)) { 40404652b8f3SDaniel P. Berrange encformat = qcow2_crypt_method_from_format( 40414652b8f3SDaniel P. Berrange qemu_opt_get(opts, BLOCK_OPT_ENCRYPT_FORMAT)); 40424652b8f3SDaniel P. Berrange 40434652b8f3SDaniel P. Berrange if (encformat != s->crypt_method_header) { 40444652b8f3SDaniel P. Berrange error_report("Changing the encryption format is not supported"); 40454652b8f3SDaniel P. Berrange return -ENOTSUP; 40464652b8f3SDaniel P. Berrange } 40478a17b83cSMax Reitz } else if (!strcmp(desc->name, BLOCK_OPT_CLUSTER_SIZE)) { 40488a17b83cSMax Reitz cluster_size = qemu_opt_get_size(opts, BLOCK_OPT_CLUSTER_SIZE, 40491bd0e2d1SChunyan Liu cluster_size); 40501bd0e2d1SChunyan Liu if (cluster_size != s->cluster_size) { 405129d72431SMax Reitz error_report("Changing the cluster size is not supported"); 40529296b3edSMax Reitz return -ENOTSUP; 40539296b3edSMax Reitz } 40548a17b83cSMax Reitz } else if (!strcmp(desc->name, BLOCK_OPT_LAZY_REFCOUNTS)) { 40558a17b83cSMax Reitz lazy_refcounts = qemu_opt_get_bool(opts, BLOCK_OPT_LAZY_REFCOUNTS, 40561bd0e2d1SChunyan Liu lazy_refcounts); 405706d05fa7SMax Reitz } else if (!strcmp(desc->name, BLOCK_OPT_REFCOUNT_BITS)) { 405861ce55fcSMax Reitz refcount_bits = qemu_opt_get_number(opts, BLOCK_OPT_REFCOUNT_BITS, 405961ce55fcSMax Reitz refcount_bits); 406061ce55fcSMax Reitz 406161ce55fcSMax Reitz if (refcount_bits <= 0 || refcount_bits > 64 || 406261ce55fcSMax Reitz !is_power_of_2(refcount_bits)) 406361ce55fcSMax Reitz { 406461ce55fcSMax Reitz error_report("Refcount width must be a power of two and may " 406561ce55fcSMax Reitz "not exceed 64 bits"); 406661ce55fcSMax Reitz return -EINVAL; 406761ce55fcSMax Reitz } 40689296b3edSMax Reitz } else { 4069164e0f89SMax Reitz /* if this point is reached, this probably means a new option was 40709296b3edSMax Reitz * added without having it covered here */ 4071164e0f89SMax Reitz abort(); 40729296b3edSMax Reitz } 40731bd0e2d1SChunyan Liu 40741bd0e2d1SChunyan Liu desc++; 40759296b3edSMax Reitz } 40769296b3edSMax Reitz 4077c293a809SMax Reitz helper_cb_info = (Qcow2AmendHelperCBInfo){ 4078c293a809SMax Reitz .original_status_cb = status_cb, 4079c293a809SMax Reitz .original_cb_opaque = cb_opaque, 4080c293a809SMax Reitz .total_operations = (new_version < old_version) 408161ce55fcSMax Reitz + (s->refcount_bits != refcount_bits) 4082c293a809SMax Reitz }; 4083c293a809SMax Reitz 40841038bbb8SMax Reitz /* Upgrade first (some features may require compat=1.1) */ 40859296b3edSMax Reitz if (new_version > old_version) { 40869296b3edSMax Reitz s->qcow_version = new_version; 40879296b3edSMax Reitz ret = qcow2_update_header(bs); 40889296b3edSMax Reitz if (ret < 0) { 40899296b3edSMax Reitz s->qcow_version = old_version; 40909296b3edSMax Reitz return ret; 40919296b3edSMax Reitz } 40929296b3edSMax Reitz } 40939296b3edSMax Reitz 409461ce55fcSMax Reitz if (s->refcount_bits != refcount_bits) { 409561ce55fcSMax Reitz int refcount_order = ctz32(refcount_bits); 409661ce55fcSMax Reitz 409761ce55fcSMax Reitz if (new_version < 3 && refcount_bits != 16) { 409861ce55fcSMax Reitz error_report("Different refcount widths than 16 bits require " 409961ce55fcSMax Reitz "compatibility level 1.1 or above (use compat=1.1 or " 410061ce55fcSMax Reitz "greater)"); 410161ce55fcSMax Reitz return -EINVAL; 410261ce55fcSMax Reitz } 410361ce55fcSMax Reitz 410461ce55fcSMax Reitz helper_cb_info.current_operation = QCOW2_CHANGING_REFCOUNT_ORDER; 410561ce55fcSMax Reitz ret = qcow2_change_refcount_order(bs, refcount_order, 410661ce55fcSMax Reitz &qcow2_amend_helper_cb, 4107a7a6a2bfSAlberto Garcia &helper_cb_info, &local_err); 410861ce55fcSMax Reitz if (ret < 0) { 4109a7a6a2bfSAlberto Garcia error_report_err(local_err); 411061ce55fcSMax Reitz return ret; 411161ce55fcSMax Reitz } 411261ce55fcSMax Reitz } 411361ce55fcSMax Reitz 41149296b3edSMax Reitz if (backing_file || backing_format) { 4115e4603fe1SKevin Wolf ret = qcow2_change_backing_file(bs, 4116e4603fe1SKevin Wolf backing_file ?: s->image_backing_file, 4117e4603fe1SKevin Wolf backing_format ?: s->image_backing_format); 41189296b3edSMax Reitz if (ret < 0) { 41199296b3edSMax Reitz return ret; 41209296b3edSMax Reitz } 41219296b3edSMax Reitz } 41229296b3edSMax Reitz 41239296b3edSMax Reitz if (s->use_lazy_refcounts != lazy_refcounts) { 41249296b3edSMax Reitz if (lazy_refcounts) { 41251038bbb8SMax Reitz if (new_version < 3) { 412629d72431SMax Reitz error_report("Lazy refcounts only supported with compatibility " 412729d72431SMax Reitz "level 1.1 and above (use compat=1.1 or greater)"); 41289296b3edSMax Reitz return -EINVAL; 41299296b3edSMax Reitz } 41309296b3edSMax Reitz s->compatible_features |= QCOW2_COMPAT_LAZY_REFCOUNTS; 41319296b3edSMax Reitz ret = qcow2_update_header(bs); 41329296b3edSMax Reitz if (ret < 0) { 41339296b3edSMax Reitz s->compatible_features &= ~QCOW2_COMPAT_LAZY_REFCOUNTS; 41349296b3edSMax Reitz return ret; 41359296b3edSMax Reitz } 41369296b3edSMax Reitz s->use_lazy_refcounts = true; 41379296b3edSMax Reitz } else { 41389296b3edSMax Reitz /* make image clean first */ 41399296b3edSMax Reitz ret = qcow2_mark_clean(bs); 41409296b3edSMax Reitz if (ret < 0) { 41419296b3edSMax Reitz return ret; 41429296b3edSMax Reitz } 41439296b3edSMax Reitz /* now disallow lazy refcounts */ 41449296b3edSMax Reitz s->compatible_features &= ~QCOW2_COMPAT_LAZY_REFCOUNTS; 41459296b3edSMax Reitz ret = qcow2_update_header(bs); 41469296b3edSMax Reitz if (ret < 0) { 41479296b3edSMax Reitz s->compatible_features |= QCOW2_COMPAT_LAZY_REFCOUNTS; 41489296b3edSMax Reitz return ret; 41499296b3edSMax Reitz } 41509296b3edSMax Reitz s->use_lazy_refcounts = false; 41519296b3edSMax Reitz } 41529296b3edSMax Reitz } 41539296b3edSMax Reitz 41549296b3edSMax Reitz if (new_size) { 41556d0eb64dSKevin Wolf BlockBackend *blk = blk_new(BLK_PERM_RESIZE, BLK_PERM_ALL); 4156d7086422SKevin Wolf ret = blk_insert_bs(blk, bs, &local_err); 4157d7086422SKevin Wolf if (ret < 0) { 4158d7086422SKevin Wolf error_report_err(local_err); 4159d7086422SKevin Wolf blk_unref(blk); 4160d7086422SKevin Wolf return ret; 4161d7086422SKevin Wolf } 4162d7086422SKevin Wolf 41633a691c50SMax Reitz ret = blk_truncate(blk, new_size, PREALLOC_MODE_OFF, &local_err); 416470b27f36SKevin Wolf blk_unref(blk); 41659296b3edSMax Reitz if (ret < 0) { 4166ed3d2ec9SMax Reitz error_report_err(local_err); 41679296b3edSMax Reitz return ret; 41689296b3edSMax Reitz } 41699296b3edSMax Reitz } 41709296b3edSMax Reitz 41711038bbb8SMax Reitz /* Downgrade last (so unsupported features can be removed before) */ 41721038bbb8SMax Reitz if (new_version < old_version) { 4173c293a809SMax Reitz helper_cb_info.current_operation = QCOW2_DOWNGRADING; 4174c293a809SMax Reitz ret = qcow2_downgrade(bs, new_version, &qcow2_amend_helper_cb, 4175c293a809SMax Reitz &helper_cb_info); 41761038bbb8SMax Reitz if (ret < 0) { 41771038bbb8SMax Reitz return ret; 41781038bbb8SMax Reitz } 41791038bbb8SMax Reitz } 41801038bbb8SMax Reitz 41819296b3edSMax Reitz return 0; 41829296b3edSMax Reitz } 41839296b3edSMax Reitz 418485186ebdSMax Reitz /* 418585186ebdSMax Reitz * If offset or size are negative, respectively, they will not be included in 418685186ebdSMax Reitz * the BLOCK_IMAGE_CORRUPTED event emitted. 418785186ebdSMax Reitz * fatal will be ignored for read-only BDS; corruptions found there will always 418885186ebdSMax Reitz * be considered non-fatal. 418985186ebdSMax Reitz */ 419085186ebdSMax Reitz void qcow2_signal_corruption(BlockDriverState *bs, bool fatal, int64_t offset, 419185186ebdSMax Reitz int64_t size, const char *message_format, ...) 419285186ebdSMax Reitz { 4193ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 4194dc881b44SAlberto Garcia const char *node_name; 419585186ebdSMax Reitz char *message; 419685186ebdSMax Reitz va_list ap; 419785186ebdSMax Reitz 419885186ebdSMax Reitz fatal = fatal && !bs->read_only; 419985186ebdSMax Reitz 420085186ebdSMax Reitz if (s->signaled_corruption && 420185186ebdSMax Reitz (!fatal || (s->incompatible_features & QCOW2_INCOMPAT_CORRUPT))) 420285186ebdSMax Reitz { 420385186ebdSMax Reitz return; 420485186ebdSMax Reitz } 420585186ebdSMax Reitz 420685186ebdSMax Reitz va_start(ap, message_format); 420785186ebdSMax Reitz message = g_strdup_vprintf(message_format, ap); 420885186ebdSMax Reitz va_end(ap); 420985186ebdSMax Reitz 421085186ebdSMax Reitz if (fatal) { 421185186ebdSMax Reitz fprintf(stderr, "qcow2: Marking image as corrupt: %s; further " 421285186ebdSMax Reitz "corruption events will be suppressed\n", message); 421385186ebdSMax Reitz } else { 421485186ebdSMax Reitz fprintf(stderr, "qcow2: Image is corrupt: %s; further non-fatal " 421585186ebdSMax Reitz "corruption events will be suppressed\n", message); 421685186ebdSMax Reitz } 421785186ebdSMax Reitz 4218dc881b44SAlberto Garcia node_name = bdrv_get_node_name(bs); 4219dc881b44SAlberto Garcia qapi_event_send_block_image_corrupted(bdrv_get_device_name(bs), 4220dc881b44SAlberto Garcia *node_name != '\0', node_name, 4221dc881b44SAlberto Garcia message, offset >= 0, offset, 4222dc881b44SAlberto Garcia size >= 0, size, 422385186ebdSMax Reitz fatal, &error_abort); 422485186ebdSMax Reitz g_free(message); 422585186ebdSMax Reitz 422685186ebdSMax Reitz if (fatal) { 422785186ebdSMax Reitz qcow2_mark_corrupt(bs); 422885186ebdSMax Reitz bs->drv = NULL; /* make BDS unusable */ 422985186ebdSMax Reitz } 423085186ebdSMax Reitz 423185186ebdSMax Reitz s->signaled_corruption = true; 423285186ebdSMax Reitz } 423385186ebdSMax Reitz 42341bd0e2d1SChunyan Liu static QemuOptsList qcow2_create_opts = { 42351bd0e2d1SChunyan Liu .name = "qcow2-create-opts", 42361bd0e2d1SChunyan Liu .head = QTAILQ_HEAD_INITIALIZER(qcow2_create_opts.head), 42371bd0e2d1SChunyan Liu .desc = { 423820d97356SBlue Swirl { 423920d97356SBlue Swirl .name = BLOCK_OPT_SIZE, 42401bd0e2d1SChunyan Liu .type = QEMU_OPT_SIZE, 424120d97356SBlue Swirl .help = "Virtual disk size" 424220d97356SBlue Swirl }, 424320d97356SBlue Swirl { 42446744cbabSKevin Wolf .name = BLOCK_OPT_COMPAT_LEVEL, 42451bd0e2d1SChunyan Liu .type = QEMU_OPT_STRING, 42466744cbabSKevin Wolf .help = "Compatibility level (0.10 or 1.1)" 42476744cbabSKevin Wolf }, 42486744cbabSKevin Wolf { 424920d97356SBlue Swirl .name = BLOCK_OPT_BACKING_FILE, 42501bd0e2d1SChunyan Liu .type = QEMU_OPT_STRING, 425120d97356SBlue Swirl .help = "File name of a base image" 425220d97356SBlue Swirl }, 425320d97356SBlue Swirl { 425420d97356SBlue Swirl .name = BLOCK_OPT_BACKING_FMT, 42551bd0e2d1SChunyan Liu .type = QEMU_OPT_STRING, 425620d97356SBlue Swirl .help = "Image format of the base image" 425720d97356SBlue Swirl }, 425820d97356SBlue Swirl { 425920d97356SBlue Swirl .name = BLOCK_OPT_ENCRYPT, 42601bd0e2d1SChunyan Liu .type = QEMU_OPT_BOOL, 42610cb8d47bSDaniel P. Berrange .help = "Encrypt the image with format 'aes'. (Deprecated " 42620cb8d47bSDaniel P. Berrange "in favor of " BLOCK_OPT_ENCRYPT_FORMAT "=aes)", 42630cb8d47bSDaniel P. Berrange }, 42640cb8d47bSDaniel P. Berrange { 42650cb8d47bSDaniel P. Berrange .name = BLOCK_OPT_ENCRYPT_FORMAT, 42660cb8d47bSDaniel P. Berrange .type = QEMU_OPT_STRING, 42674652b8f3SDaniel P. Berrange .help = "Encrypt the image, format choices: 'aes', 'luks'", 426820d97356SBlue Swirl }, 42694652b8f3SDaniel P. Berrange BLOCK_CRYPTO_OPT_DEF_KEY_SECRET("encrypt.", 42704652b8f3SDaniel P. Berrange "ID of secret providing qcow AES key or LUKS passphrase"), 42714652b8f3SDaniel P. Berrange BLOCK_CRYPTO_OPT_DEF_LUKS_CIPHER_ALG("encrypt."), 42724652b8f3SDaniel P. Berrange BLOCK_CRYPTO_OPT_DEF_LUKS_CIPHER_MODE("encrypt."), 42734652b8f3SDaniel P. Berrange BLOCK_CRYPTO_OPT_DEF_LUKS_IVGEN_ALG("encrypt."), 42744652b8f3SDaniel P. Berrange BLOCK_CRYPTO_OPT_DEF_LUKS_IVGEN_HASH_ALG("encrypt."), 42754652b8f3SDaniel P. Berrange BLOCK_CRYPTO_OPT_DEF_LUKS_HASH_ALG("encrypt."), 42764652b8f3SDaniel P. Berrange BLOCK_CRYPTO_OPT_DEF_LUKS_ITER_TIME("encrypt."), 427720d97356SBlue Swirl { 427820d97356SBlue Swirl .name = BLOCK_OPT_CLUSTER_SIZE, 42791bd0e2d1SChunyan Liu .type = QEMU_OPT_SIZE, 428099cce9faSKevin Wolf .help = "qcow2 cluster size", 42811bd0e2d1SChunyan Liu .def_value_str = stringify(DEFAULT_CLUSTER_SIZE) 428220d97356SBlue Swirl }, 428320d97356SBlue Swirl { 428420d97356SBlue Swirl .name = BLOCK_OPT_PREALLOC, 42851bd0e2d1SChunyan Liu .type = QEMU_OPT_STRING, 42860e4271b7SHu Tao .help = "Preallocation mode (allowed values: off, metadata, " 42870e4271b7SHu Tao "falloc, full)" 428820d97356SBlue Swirl }, 4289bfe8043eSStefan Hajnoczi { 4290bfe8043eSStefan Hajnoczi .name = BLOCK_OPT_LAZY_REFCOUNTS, 42911bd0e2d1SChunyan Liu .type = QEMU_OPT_BOOL, 4292bfe8043eSStefan Hajnoczi .help = "Postpone refcount updates", 42931bd0e2d1SChunyan Liu .def_value_str = "off" 4294bfe8043eSStefan Hajnoczi }, 429506d05fa7SMax Reitz { 429606d05fa7SMax Reitz .name = BLOCK_OPT_REFCOUNT_BITS, 429706d05fa7SMax Reitz .type = QEMU_OPT_NUMBER, 429806d05fa7SMax Reitz .help = "Width of a reference count entry in bits", 429906d05fa7SMax Reitz .def_value_str = "16" 430006d05fa7SMax Reitz }, 43011bd0e2d1SChunyan Liu { /* end of list */ } 43021bd0e2d1SChunyan Liu } 430320d97356SBlue Swirl }; 430420d97356SBlue Swirl 43055f535a94SMax Reitz BlockDriver bdrv_qcow2 = { 430620d97356SBlue Swirl .format_name = "qcow2", 4307ff99129aSKevin Wolf .instance_size = sizeof(BDRVQcow2State), 43087c80ab3fSJes Sorensen .bdrv_probe = qcow2_probe, 43097c80ab3fSJes Sorensen .bdrv_open = qcow2_open, 43107c80ab3fSJes Sorensen .bdrv_close = qcow2_close, 431121d82ac9SJeff Cody .bdrv_reopen_prepare = qcow2_reopen_prepare, 43125b0959a7SKevin Wolf .bdrv_reopen_commit = qcow2_reopen_commit, 43135b0959a7SKevin Wolf .bdrv_reopen_abort = qcow2_reopen_abort, 43145365f44dSKevin Wolf .bdrv_join_options = qcow2_join_options, 4315862f215fSKevin Wolf .bdrv_child_perm = bdrv_format_default_perms, 4316c282e1fdSChunyan Liu .bdrv_create = qcow2_create, 43173ac21627SPeter Lieven .bdrv_has_zero_init = bdrv_has_zero_init_1, 4318b6b8a333SPaolo Bonzini .bdrv_co_get_block_status = qcow2_co_get_block_status, 431920d97356SBlue Swirl 4320ecfe1863SKevin Wolf .bdrv_co_preadv = qcow2_co_preadv, 4321d46a0bb2SKevin Wolf .bdrv_co_pwritev = qcow2_co_pwritev, 4322eb489bb1SKevin Wolf .bdrv_co_flush_to_os = qcow2_co_flush_to_os, 4323419b19d9SStefan Hajnoczi 43245544b59fSEric Blake .bdrv_co_pwrite_zeroes = qcow2_co_pwrite_zeroes, 432582e8a788SEric Blake .bdrv_co_pdiscard = qcow2_co_pdiscard, 4326419b19d9SStefan Hajnoczi .bdrv_truncate = qcow2_truncate, 4327fcccefc5SPavel Butsykin .bdrv_co_pwritev_compressed = qcow2_co_pwritev_compressed, 4328491d27e2SMax Reitz .bdrv_make_empty = qcow2_make_empty, 432920d97356SBlue Swirl 433020d97356SBlue Swirl .bdrv_snapshot_create = qcow2_snapshot_create, 433120d97356SBlue Swirl .bdrv_snapshot_goto = qcow2_snapshot_goto, 433220d97356SBlue Swirl .bdrv_snapshot_delete = qcow2_snapshot_delete, 433320d97356SBlue Swirl .bdrv_snapshot_list = qcow2_snapshot_list, 433451ef6727Sedison .bdrv_snapshot_load_tmp = qcow2_snapshot_load_tmp, 4335c501c352SStefan Hajnoczi .bdrv_measure = qcow2_measure, 43367c80ab3fSJes Sorensen .bdrv_get_info = qcow2_get_info, 433737764dfbSMax Reitz .bdrv_get_specific_info = qcow2_get_specific_info, 433820d97356SBlue Swirl 43397c80ab3fSJes Sorensen .bdrv_save_vmstate = qcow2_save_vmstate, 43407c80ab3fSJes Sorensen .bdrv_load_vmstate = qcow2_load_vmstate, 434120d97356SBlue Swirl 43428ee79e70SKevin Wolf .supports_backing = true, 434320d97356SBlue Swirl .bdrv_change_backing_file = qcow2_change_backing_file, 434420d97356SBlue Swirl 4345d34682cdSKevin Wolf .bdrv_refresh_limits = qcow2_refresh_limits, 434606d9260fSAnthony Liguori .bdrv_invalidate_cache = qcow2_invalidate_cache, 4347ec6d8912SKevin Wolf .bdrv_inactivate = qcow2_inactivate, 434806d9260fSAnthony Liguori 43491bd0e2d1SChunyan Liu .create_opts = &qcow2_create_opts, 43507c80ab3fSJes Sorensen .bdrv_check = qcow2_check, 4351c282e1fdSChunyan Liu .bdrv_amend_options = qcow2_amend_options, 4352279621c0SAlberto Garcia 4353279621c0SAlberto Garcia .bdrv_detach_aio_context = qcow2_detach_aio_context, 4354279621c0SAlberto Garcia .bdrv_attach_aio_context = qcow2_attach_aio_context, 43551b6b0562SVladimir Sementsov-Ogievskiy 43561b6b0562SVladimir Sementsov-Ogievskiy .bdrv_reopen_bitmaps_rw = qcow2_reopen_bitmaps_rw, 4357da0eb242SVladimir Sementsov-Ogievskiy .bdrv_can_store_new_dirty_bitmap = qcow2_can_store_new_dirty_bitmap, 4358469c71edSVladimir Sementsov-Ogievskiy .bdrv_remove_persistent_dirty_bitmap = qcow2_remove_persistent_dirty_bitmap, 435920d97356SBlue Swirl }; 436020d97356SBlue Swirl 43615efa9d5aSAnthony Liguori static void bdrv_qcow2_init(void) 43625efa9d5aSAnthony Liguori { 43635efa9d5aSAnthony Liguori bdrv_register(&bdrv_qcow2); 43645efa9d5aSAnthony Liguori } 43655efa9d5aSAnthony Liguori 43665efa9d5aSAnthony Liguori block_init(bdrv_qcow2_init); 4367