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" 33ffeaac9bSHu Tao #include "qapi/util.h" 3485186ebdSMax Reitz #include "qapi/qmp/types.h" 3585186ebdSMax Reitz #include "qapi-event.h" 363cce16f4SKevin Wolf #include "trace.h" 371bd0e2d1SChunyan Liu #include "qemu/option_int.h" 38f348b6d1SVeronia Bahaa #include "qemu/cutils.h" 3958369e22SPaolo Bonzini #include "qemu/bswap.h" 40b25b387fSDaniel P. Berrange #include "qapi/opts-visitor.h" 41b25b387fSDaniel P. Berrange #include "qapi-visit.h" 42b25b387fSDaniel P. Berrange #include "block/crypto.h" 43585f8587Sbellard 44585f8587Sbellard /* 45585f8587Sbellard Differences with QCOW: 46585f8587Sbellard 47585f8587Sbellard - Support for multiple incremental snapshots. 48585f8587Sbellard - Memory management by reference counts. 49585f8587Sbellard - Clusters which have a reference count of one have the bit 50585f8587Sbellard QCOW_OFLAG_COPIED to optimize write performance. 51585f8587Sbellard - Size of compressed clusters is stored in sectors to reduce bit usage 52585f8587Sbellard in the cluster offsets. 53585f8587Sbellard - Support for storing additional data (such as the VM state) in the 54585f8587Sbellard snapshots. 55585f8587Sbellard - If a backing store is used, the cluster size is not constrained 56585f8587Sbellard (could be backported to QCOW). 57585f8587Sbellard - L2 tables have always a size of one cluster. 58585f8587Sbellard */ 59585f8587Sbellard 609b80ddf3Saliguori 619b80ddf3Saliguori typedef struct { 629b80ddf3Saliguori uint32_t magic; 639b80ddf3Saliguori uint32_t len; 64c4217f64SJeff Cody } QEMU_PACKED QCowExtension; 6521d82ac9SJeff Cody 667c80ab3fSJes Sorensen #define QCOW2_EXT_MAGIC_END 0 677c80ab3fSJes Sorensen #define QCOW2_EXT_MAGIC_BACKING_FORMAT 0xE2792ACA 68cfcc4c62SKevin Wolf #define QCOW2_EXT_MAGIC_FEATURE_TABLE 0x6803f857 694652b8f3SDaniel P. Berrange #define QCOW2_EXT_MAGIC_CRYPTO_HEADER 0x0537be77 7088ddffaeSVladimir Sementsov-Ogievskiy #define QCOW2_EXT_MAGIC_BITMAPS 0x23852875 719b80ddf3Saliguori 727c80ab3fSJes Sorensen static int qcow2_probe(const uint8_t *buf, int buf_size, const char *filename) 73585f8587Sbellard { 74585f8587Sbellard const QCowHeader *cow_header = (const void *)buf; 75585f8587Sbellard 76585f8587Sbellard if (buf_size >= sizeof(QCowHeader) && 77585f8587Sbellard be32_to_cpu(cow_header->magic) == QCOW_MAGIC && 786744cbabSKevin Wolf be32_to_cpu(cow_header->version) >= 2) 79585f8587Sbellard return 100; 80585f8587Sbellard else 81585f8587Sbellard return 0; 82585f8587Sbellard } 83585f8587Sbellard 849b80ddf3Saliguori 854652b8f3SDaniel P. Berrange static ssize_t qcow2_crypto_hdr_read_func(QCryptoBlock *block, size_t offset, 864652b8f3SDaniel P. Berrange uint8_t *buf, size_t buflen, 874652b8f3SDaniel P. Berrange void *opaque, Error **errp) 884652b8f3SDaniel P. Berrange { 894652b8f3SDaniel P. Berrange BlockDriverState *bs = opaque; 904652b8f3SDaniel P. Berrange BDRVQcow2State *s = bs->opaque; 914652b8f3SDaniel P. Berrange ssize_t ret; 924652b8f3SDaniel P. Berrange 934652b8f3SDaniel P. Berrange if ((offset + buflen) > s->crypto_header.length) { 944652b8f3SDaniel P. Berrange error_setg(errp, "Request for data outside of extension header"); 954652b8f3SDaniel P. Berrange return -1; 964652b8f3SDaniel P. Berrange } 974652b8f3SDaniel P. Berrange 984652b8f3SDaniel P. Berrange ret = bdrv_pread(bs->file, 994652b8f3SDaniel P. Berrange s->crypto_header.offset + offset, buf, buflen); 1004652b8f3SDaniel P. Berrange if (ret < 0) { 1014652b8f3SDaniel P. Berrange error_setg_errno(errp, -ret, "Could not read encryption header"); 1024652b8f3SDaniel P. Berrange return -1; 1034652b8f3SDaniel P. Berrange } 1044652b8f3SDaniel P. Berrange return ret; 1054652b8f3SDaniel P. Berrange } 1064652b8f3SDaniel P. Berrange 1074652b8f3SDaniel P. Berrange 1084652b8f3SDaniel P. Berrange static ssize_t qcow2_crypto_hdr_init_func(QCryptoBlock *block, size_t headerlen, 1094652b8f3SDaniel P. Berrange void *opaque, Error **errp) 1104652b8f3SDaniel P. Berrange { 1114652b8f3SDaniel P. Berrange BlockDriverState *bs = opaque; 1124652b8f3SDaniel P. Berrange BDRVQcow2State *s = bs->opaque; 1134652b8f3SDaniel P. Berrange int64_t ret; 1144652b8f3SDaniel P. Berrange int64_t clusterlen; 1154652b8f3SDaniel P. Berrange 1164652b8f3SDaniel P. Berrange ret = qcow2_alloc_clusters(bs, headerlen); 1174652b8f3SDaniel P. Berrange if (ret < 0) { 1184652b8f3SDaniel P. Berrange error_setg_errno(errp, -ret, 1194652b8f3SDaniel P. Berrange "Cannot allocate cluster for LUKS header size %zu", 1204652b8f3SDaniel P. Berrange headerlen); 1214652b8f3SDaniel P. Berrange return -1; 1224652b8f3SDaniel P. Berrange } 1234652b8f3SDaniel P. Berrange 1244652b8f3SDaniel P. Berrange s->crypto_header.length = headerlen; 1254652b8f3SDaniel P. Berrange s->crypto_header.offset = ret; 1264652b8f3SDaniel P. Berrange 1274652b8f3SDaniel P. Berrange /* Zero fill remaining space in cluster so it has predictable 1284652b8f3SDaniel P. Berrange * content in case of future spec changes */ 1294652b8f3SDaniel P. Berrange clusterlen = size_to_clusters(s, headerlen) * s->cluster_size; 1304652b8f3SDaniel P. Berrange ret = bdrv_pwrite_zeroes(bs->file, 1314652b8f3SDaniel P. Berrange ret + headerlen, 1324652b8f3SDaniel P. Berrange clusterlen - headerlen, 0); 1334652b8f3SDaniel P. Berrange if (ret < 0) { 1344652b8f3SDaniel P. Berrange error_setg_errno(errp, -ret, "Could not zero fill encryption header"); 1354652b8f3SDaniel P. Berrange return -1; 1364652b8f3SDaniel P. Berrange } 1374652b8f3SDaniel P. Berrange 1384652b8f3SDaniel P. Berrange return ret; 1394652b8f3SDaniel P. Berrange } 1404652b8f3SDaniel P. Berrange 1414652b8f3SDaniel P. Berrange 1424652b8f3SDaniel P. Berrange static ssize_t qcow2_crypto_hdr_write_func(QCryptoBlock *block, size_t offset, 1434652b8f3SDaniel P. Berrange const uint8_t *buf, size_t buflen, 1444652b8f3SDaniel P. Berrange void *opaque, Error **errp) 1454652b8f3SDaniel P. Berrange { 1464652b8f3SDaniel P. Berrange BlockDriverState *bs = opaque; 1474652b8f3SDaniel P. Berrange BDRVQcow2State *s = bs->opaque; 1484652b8f3SDaniel P. Berrange ssize_t ret; 1494652b8f3SDaniel P. Berrange 1504652b8f3SDaniel P. Berrange if ((offset + buflen) > s->crypto_header.length) { 1514652b8f3SDaniel P. Berrange error_setg(errp, "Request for data outside of extension header"); 1524652b8f3SDaniel P. Berrange return -1; 1534652b8f3SDaniel P. Berrange } 1544652b8f3SDaniel P. Berrange 1554652b8f3SDaniel P. Berrange ret = bdrv_pwrite(bs->file, 1564652b8f3SDaniel P. Berrange s->crypto_header.offset + offset, buf, buflen); 1574652b8f3SDaniel P. Berrange if (ret < 0) { 1584652b8f3SDaniel P. Berrange error_setg_errno(errp, -ret, "Could not read encryption header"); 1594652b8f3SDaniel P. Berrange return -1; 1604652b8f3SDaniel P. Berrange } 1614652b8f3SDaniel P. Berrange return ret; 1624652b8f3SDaniel P. Berrange } 1634652b8f3SDaniel P. Berrange 1644652b8f3SDaniel P. Berrange 1659b80ddf3Saliguori /* 1669b80ddf3Saliguori * read qcow2 extension and fill bs 1679b80ddf3Saliguori * start reading from start_offset 1689b80ddf3Saliguori * finish reading upon magic of value 0 or when end_offset reached 1699b80ddf3Saliguori * unknown magic is skipped (future extension this version knows nothing about) 1709b80ddf3Saliguori * return 0 upon success, non-0 otherwise 1719b80ddf3Saliguori */ 1727c80ab3fSJes Sorensen static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset, 1733ef6c40aSMax Reitz uint64_t end_offset, void **p_feature_table, 17488ddffaeSVladimir Sementsov-Ogievskiy int flags, bool *need_update_header, 17588ddffaeSVladimir Sementsov-Ogievskiy Error **errp) 1769b80ddf3Saliguori { 177ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 1789b80ddf3Saliguori QCowExtension ext; 1799b80ddf3Saliguori uint64_t offset; 18075bab85cSKevin Wolf int ret; 18188ddffaeSVladimir Sementsov-Ogievskiy Qcow2BitmapHeaderExt bitmaps_ext; 18288ddffaeSVladimir Sementsov-Ogievskiy 18388ddffaeSVladimir Sementsov-Ogievskiy if (need_update_header != NULL) { 18488ddffaeSVladimir Sementsov-Ogievskiy *need_update_header = false; 18588ddffaeSVladimir Sementsov-Ogievskiy } 1869b80ddf3Saliguori 1879b80ddf3Saliguori #ifdef DEBUG_EXT 1887c80ab3fSJes Sorensen printf("qcow2_read_extensions: start=%ld end=%ld\n", start_offset, end_offset); 1899b80ddf3Saliguori #endif 1909b80ddf3Saliguori offset = start_offset; 1919b80ddf3Saliguori while (offset < end_offset) { 1929b80ddf3Saliguori 1939b80ddf3Saliguori #ifdef DEBUG_EXT 1949b80ddf3Saliguori /* Sanity check */ 1959b80ddf3Saliguori if (offset > s->cluster_size) 1967c80ab3fSJes Sorensen printf("qcow2_read_extension: suspicious offset %lu\n", offset); 1979b80ddf3Saliguori 1989b2260cbSDong Xu Wang printf("attempting to read extended header in offset %lu\n", offset); 1999b80ddf3Saliguori #endif 2009b80ddf3Saliguori 201cf2ab8fcSKevin Wolf ret = bdrv_pread(bs->file, offset, &ext, sizeof(ext)); 2023ef6c40aSMax Reitz if (ret < 0) { 2033ef6c40aSMax Reitz error_setg_errno(errp, -ret, "qcow2_read_extension: ERROR: " 2043ef6c40aSMax Reitz "pread fail from offset %" PRIu64, offset); 2059b80ddf3Saliguori return 1; 2069b80ddf3Saliguori } 2079b80ddf3Saliguori be32_to_cpus(&ext.magic); 2089b80ddf3Saliguori be32_to_cpus(&ext.len); 2099b80ddf3Saliguori offset += sizeof(ext); 2109b80ddf3Saliguori #ifdef DEBUG_EXT 2119b80ddf3Saliguori printf("ext.magic = 0x%x\n", ext.magic); 2129b80ddf3Saliguori #endif 2132ebafc85SKevin Wolf if (offset > end_offset || ext.len > end_offset - offset) { 2143ef6c40aSMax Reitz error_setg(errp, "Header extension too large"); 21564ca6aeeSKevin Wolf return -EINVAL; 21664ca6aeeSKevin Wolf } 21764ca6aeeSKevin Wolf 2189b80ddf3Saliguori switch (ext.magic) { 2197c80ab3fSJes Sorensen case QCOW2_EXT_MAGIC_END: 2209b80ddf3Saliguori return 0; 221f965509cSaliguori 2227c80ab3fSJes Sorensen case QCOW2_EXT_MAGIC_BACKING_FORMAT: 223f965509cSaliguori if (ext.len >= sizeof(bs->backing_format)) { 224521b2b5dSMax Reitz error_setg(errp, "ERROR: ext_backing_format: len=%" PRIu32 225521b2b5dSMax Reitz " too large (>=%zu)", ext.len, 226521b2b5dSMax Reitz sizeof(bs->backing_format)); 227f965509cSaliguori return 2; 228f965509cSaliguori } 229cf2ab8fcSKevin Wolf ret = bdrv_pread(bs->file, offset, bs->backing_format, ext.len); 2303ef6c40aSMax Reitz if (ret < 0) { 2313ef6c40aSMax Reitz error_setg_errno(errp, -ret, "ERROR: ext_backing_format: " 2323ef6c40aSMax Reitz "Could not read format name"); 233f965509cSaliguori return 3; 2343ef6c40aSMax Reitz } 235f965509cSaliguori bs->backing_format[ext.len] = '\0'; 236e4603fe1SKevin Wolf s->image_backing_format = g_strdup(bs->backing_format); 237f965509cSaliguori #ifdef DEBUG_EXT 238f965509cSaliguori printf("Qcow2: Got format extension %s\n", bs->backing_format); 239f965509cSaliguori #endif 240f965509cSaliguori break; 241f965509cSaliguori 242cfcc4c62SKevin Wolf case QCOW2_EXT_MAGIC_FEATURE_TABLE: 243cfcc4c62SKevin Wolf if (p_feature_table != NULL) { 244cfcc4c62SKevin Wolf void* feature_table = g_malloc0(ext.len + 2 * sizeof(Qcow2Feature)); 245cf2ab8fcSKevin Wolf ret = bdrv_pread(bs->file, offset , feature_table, ext.len); 246cfcc4c62SKevin Wolf if (ret < 0) { 2473ef6c40aSMax Reitz error_setg_errno(errp, -ret, "ERROR: ext_feature_table: " 2483ef6c40aSMax Reitz "Could not read table"); 249cfcc4c62SKevin Wolf return ret; 250cfcc4c62SKevin Wolf } 251cfcc4c62SKevin Wolf 252cfcc4c62SKevin Wolf *p_feature_table = feature_table; 253cfcc4c62SKevin Wolf } 254cfcc4c62SKevin Wolf break; 255cfcc4c62SKevin Wolf 2564652b8f3SDaniel P. Berrange case QCOW2_EXT_MAGIC_CRYPTO_HEADER: { 2574652b8f3SDaniel P. Berrange unsigned int cflags = 0; 2584652b8f3SDaniel P. Berrange if (s->crypt_method_header != QCOW_CRYPT_LUKS) { 2594652b8f3SDaniel P. Berrange error_setg(errp, "CRYPTO header extension only " 2604652b8f3SDaniel P. Berrange "expected with LUKS encryption method"); 2614652b8f3SDaniel P. Berrange return -EINVAL; 2624652b8f3SDaniel P. Berrange } 2634652b8f3SDaniel P. Berrange if (ext.len != sizeof(Qcow2CryptoHeaderExtension)) { 2644652b8f3SDaniel P. Berrange error_setg(errp, "CRYPTO header extension size %u, " 2654652b8f3SDaniel P. Berrange "but expected size %zu", ext.len, 2664652b8f3SDaniel P. Berrange sizeof(Qcow2CryptoHeaderExtension)); 2674652b8f3SDaniel P. Berrange return -EINVAL; 2684652b8f3SDaniel P. Berrange } 2694652b8f3SDaniel P. Berrange 2704652b8f3SDaniel P. Berrange ret = bdrv_pread(bs->file, offset, &s->crypto_header, ext.len); 2714652b8f3SDaniel P. Berrange if (ret < 0) { 2724652b8f3SDaniel P. Berrange error_setg_errno(errp, -ret, 2734652b8f3SDaniel P. Berrange "Unable to read CRYPTO header extension"); 2744652b8f3SDaniel P. Berrange return ret; 2754652b8f3SDaniel P. Berrange } 2764652b8f3SDaniel P. Berrange be64_to_cpus(&s->crypto_header.offset); 2774652b8f3SDaniel P. Berrange be64_to_cpus(&s->crypto_header.length); 2784652b8f3SDaniel P. Berrange 2794652b8f3SDaniel P. Berrange if ((s->crypto_header.offset % s->cluster_size) != 0) { 2804652b8f3SDaniel P. Berrange error_setg(errp, "Encryption header offset '%" PRIu64 "' is " 2814652b8f3SDaniel P. Berrange "not a multiple of cluster size '%u'", 2824652b8f3SDaniel P. Berrange s->crypto_header.offset, s->cluster_size); 2834652b8f3SDaniel P. Berrange return -EINVAL; 2844652b8f3SDaniel P. Berrange } 2854652b8f3SDaniel P. Berrange 2864652b8f3SDaniel P. Berrange if (flags & BDRV_O_NO_IO) { 2874652b8f3SDaniel P. Berrange cflags |= QCRYPTO_BLOCK_OPEN_NO_IO; 2884652b8f3SDaniel P. Berrange } 2891cd9a787SDaniel P. Berrange s->crypto = qcrypto_block_open(s->crypto_opts, "encrypt.", 2904652b8f3SDaniel P. Berrange qcow2_crypto_hdr_read_func, 2914652b8f3SDaniel P. Berrange bs, cflags, errp); 2924652b8f3SDaniel P. Berrange if (!s->crypto) { 2934652b8f3SDaniel P. Berrange return -EINVAL; 2944652b8f3SDaniel P. Berrange } 2954652b8f3SDaniel P. Berrange } break; 2964652b8f3SDaniel P. Berrange 29788ddffaeSVladimir Sementsov-Ogievskiy case QCOW2_EXT_MAGIC_BITMAPS: 29888ddffaeSVladimir Sementsov-Ogievskiy if (ext.len != sizeof(bitmaps_ext)) { 29988ddffaeSVladimir Sementsov-Ogievskiy error_setg_errno(errp, -ret, "bitmaps_ext: " 30088ddffaeSVladimir Sementsov-Ogievskiy "Invalid extension length"); 30188ddffaeSVladimir Sementsov-Ogievskiy return -EINVAL; 30288ddffaeSVladimir Sementsov-Ogievskiy } 30388ddffaeSVladimir Sementsov-Ogievskiy 30488ddffaeSVladimir Sementsov-Ogievskiy if (!(s->autoclear_features & QCOW2_AUTOCLEAR_BITMAPS)) { 30588ddffaeSVladimir Sementsov-Ogievskiy error_report("WARNING: a program lacking bitmap support " 30688ddffaeSVladimir Sementsov-Ogievskiy "modified this file, so all bitmaps are now " 30788ddffaeSVladimir Sementsov-Ogievskiy "considered inconsistent. Some clusters may be " 30888ddffaeSVladimir Sementsov-Ogievskiy "leaked, 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 13637267c094SAnthony Liguori s->cluster_cache = g_malloc(s->cluster_size); 1364585f8587Sbellard /* one more sector for decompressed data alignment */ 13659a4f4c31SKevin Wolf s->cluster_data = qemu_try_blockalign(bs->file->bs, QCOW_MAX_CRYPT_CLUSTERS 1366de82815dSKevin Wolf * s->cluster_size + 512); 1367de82815dSKevin Wolf if (s->cluster_data == NULL) { 1368de82815dSKevin Wolf error_setg(errp, "Could not allocate temporary cluster buffer"); 1369de82815dSKevin Wolf ret = -ENOMEM; 1370de82815dSKevin Wolf goto fail; 1371de82815dSKevin Wolf } 1372de82815dSKevin Wolf 1373585f8587Sbellard s->cluster_cache_offset = -1; 137406d9260fSAnthony Liguori s->flags = flags; 1375585f8587Sbellard 13766d85a57eSJes Sorensen ret = qcow2_refcount_init(bs); 13776d85a57eSJes Sorensen if (ret != 0) { 13783ef6c40aSMax Reitz error_setg_errno(errp, -ret, "Could not initialize refcount handling"); 1379585f8587Sbellard goto fail; 13806d85a57eSJes Sorensen } 1381585f8587Sbellard 138272cf2d4fSBlue Swirl QLIST_INIT(&s->cluster_allocs); 13830b919faeSKevin Wolf QTAILQ_INIT(&s->discards); 1384f214978aSKevin Wolf 13859b80ddf3Saliguori /* read qcow2 extensions */ 13863ef6c40aSMax Reitz if (qcow2_read_extensions(bs, header.header_length, ext_end, NULL, 138788ddffaeSVladimir Sementsov-Ogievskiy flags, &update_header, &local_err)) { 13883ef6c40aSMax Reitz error_propagate(errp, local_err); 13896d85a57eSJes Sorensen ret = -EINVAL; 13909b80ddf3Saliguori goto fail; 13916d85a57eSJes Sorensen } 13929b80ddf3Saliguori 13934652b8f3SDaniel P. Berrange /* qcow2_read_extension may have set up the crypto context 13944652b8f3SDaniel P. Berrange * if the crypt method needs a header region, some methods 13954652b8f3SDaniel P. Berrange * don't need header extensions, so must check here 13964652b8f3SDaniel P. Berrange */ 13974652b8f3SDaniel P. Berrange if (s->crypt_method_header && !s->crypto) { 1398b25b387fSDaniel P. Berrange if (s->crypt_method_header == QCOW_CRYPT_AES) { 1399b25b387fSDaniel P. Berrange unsigned int cflags = 0; 1400b25b387fSDaniel P. Berrange if (flags & BDRV_O_NO_IO) { 1401b25b387fSDaniel P. Berrange cflags |= QCRYPTO_BLOCK_OPEN_NO_IO; 1402b25b387fSDaniel P. Berrange } 14031cd9a787SDaniel P. Berrange s->crypto = qcrypto_block_open(s->crypto_opts, "encrypt.", 14041cd9a787SDaniel P. Berrange NULL, NULL, cflags, errp); 1405b25b387fSDaniel P. Berrange if (!s->crypto) { 1406b25b387fSDaniel P. Berrange ret = -EINVAL; 1407b25b387fSDaniel P. Berrange goto fail; 1408b25b387fSDaniel P. Berrange } 14094652b8f3SDaniel P. Berrange } else if (!(flags & BDRV_O_NO_IO)) { 14104652b8f3SDaniel P. Berrange error_setg(errp, "Missing CRYPTO header for crypt method %d", 14114652b8f3SDaniel P. Berrange s->crypt_method_header); 14124652b8f3SDaniel P. Berrange ret = -EINVAL; 14134652b8f3SDaniel P. Berrange goto fail; 14144652b8f3SDaniel P. Berrange } 1415b25b387fSDaniel P. Berrange } 1416b25b387fSDaniel P. Berrange 1417585f8587Sbellard /* read the backing file name */ 1418585f8587Sbellard if (header.backing_file_offset != 0) { 1419585f8587Sbellard len = header.backing_file_size; 14209a29e18fSJeff Cody if (len > MIN(1023, s->cluster_size - header.backing_file_offset) || 1421e729fa6aSJeff Cody len >= sizeof(bs->backing_file)) { 14226d33e8e7SKevin Wolf error_setg(errp, "Backing file name too long"); 14236d33e8e7SKevin Wolf ret = -EINVAL; 14246d33e8e7SKevin Wolf goto fail; 14256d85a57eSJes Sorensen } 1426cf2ab8fcSKevin Wolf ret = bdrv_pread(bs->file, header.backing_file_offset, 14276d85a57eSJes Sorensen bs->backing_file, len); 14286d85a57eSJes Sorensen if (ret < 0) { 14293ef6c40aSMax Reitz error_setg_errno(errp, -ret, "Could not read backing file name"); 1430585f8587Sbellard goto fail; 14316d85a57eSJes Sorensen } 1432585f8587Sbellard bs->backing_file[len] = '\0'; 1433e4603fe1SKevin Wolf s->image_backing_file = g_strdup(bs->backing_file); 1434585f8587Sbellard } 143542deb29fSKevin Wolf 143611b128f4SKevin Wolf /* Internal snapshots */ 143711b128f4SKevin Wolf s->snapshots_offset = header.snapshots_offset; 143811b128f4SKevin Wolf s->nb_snapshots = header.nb_snapshots; 143911b128f4SKevin Wolf 144042deb29fSKevin Wolf ret = qcow2_read_snapshots(bs); 144142deb29fSKevin Wolf if (ret < 0) { 14423ef6c40aSMax Reitz error_setg_errno(errp, -ret, "Could not read snapshots"); 1443585f8587Sbellard goto fail; 14446d85a57eSJes Sorensen } 1445585f8587Sbellard 1446af7b708dSStefan Hajnoczi /* Clear unknown autoclear feature bits */ 144788ddffaeSVladimir Sementsov-Ogievskiy update_header |= s->autoclear_features & ~QCOW2_AUTOCLEAR_MASK; 1448d1258dd0SVladimir Sementsov-Ogievskiy update_header = 1449d1258dd0SVladimir Sementsov-Ogievskiy update_header && !bs->read_only && !(flags & BDRV_O_INACTIVE); 1450d1258dd0SVladimir Sementsov-Ogievskiy if (update_header) { 145188ddffaeSVladimir Sementsov-Ogievskiy s->autoclear_features &= QCOW2_AUTOCLEAR_MASK; 1452d1258dd0SVladimir Sementsov-Ogievskiy } 1453d1258dd0SVladimir Sementsov-Ogievskiy 1454d1258dd0SVladimir Sementsov-Ogievskiy if (qcow2_load_autoloading_dirty_bitmaps(bs, &local_err)) { 1455d1258dd0SVladimir Sementsov-Ogievskiy update_header = false; 1456d1258dd0SVladimir Sementsov-Ogievskiy } 1457d1258dd0SVladimir Sementsov-Ogievskiy if (local_err != NULL) { 1458d1258dd0SVladimir Sementsov-Ogievskiy error_propagate(errp, local_err); 1459d1258dd0SVladimir Sementsov-Ogievskiy ret = -EINVAL; 1460d1258dd0SVladimir Sementsov-Ogievskiy goto fail; 1461d1258dd0SVladimir Sementsov-Ogievskiy } 1462d1258dd0SVladimir Sementsov-Ogievskiy 1463d1258dd0SVladimir Sementsov-Ogievskiy if (update_header) { 1464af7b708dSStefan Hajnoczi ret = qcow2_update_header(bs); 1465af7b708dSStefan Hajnoczi if (ret < 0) { 14663ef6c40aSMax Reitz error_setg_errno(errp, -ret, "Could not update qcow2 header"); 1467af7b708dSStefan Hajnoczi goto fail; 1468af7b708dSStefan Hajnoczi } 1469af7b708dSStefan Hajnoczi } 1470af7b708dSStefan Hajnoczi 147168d100e9SKevin Wolf /* Initialise locks */ 147268d100e9SKevin Wolf qemu_co_mutex_init(&s->lock); 1473170f4b2eSFam Zheng bs->supported_zero_flags = BDRV_REQ_MAY_UNMAP; 147468d100e9SKevin Wolf 1475c61d0004SStefan Hajnoczi /* Repair image if dirty */ 147604c01a5cSKevin Wolf if (!(flags & (BDRV_O_CHECK | BDRV_O_INACTIVE)) && !bs->read_only && 1477058f8f16SStefan Hajnoczi (s->incompatible_features & QCOW2_INCOMPAT_DIRTY)) { 1478c61d0004SStefan Hajnoczi BdrvCheckResult result = {0}; 1479c61d0004SStefan Hajnoczi 14805b84106bSMax Reitz ret = qcow2_check(bs, &result, BDRV_FIX_ERRORS | BDRV_FIX_LEAKS); 1481c61d0004SStefan Hajnoczi if (ret < 0) { 14823ef6c40aSMax Reitz error_setg_errno(errp, -ret, "Could not repair dirty image"); 1483c61d0004SStefan Hajnoczi goto fail; 1484c61d0004SStefan Hajnoczi } 1485c61d0004SStefan Hajnoczi } 1486c61d0004SStefan Hajnoczi 1487585f8587Sbellard #ifdef DEBUG_ALLOC 14886cbc3031SPhilipp Hahn { 14896cbc3031SPhilipp Hahn BdrvCheckResult result = {0}; 1490b35278f7SStefan Hajnoczi qcow2_check_refcounts(bs, &result, 0); 14916cbc3031SPhilipp Hahn } 1492585f8587Sbellard #endif 14936d85a57eSJes Sorensen return ret; 1494585f8587Sbellard 1495585f8587Sbellard fail: 14966744cbabSKevin Wolf g_free(s->unknown_header_fields); 149775bab85cSKevin Wolf cleanup_unknown_header_ext(bs); 1498ed6ccf0fSKevin Wolf qcow2_free_snapshots(bs); 1499ed6ccf0fSKevin Wolf qcow2_refcount_close(bs); 1500de82815dSKevin Wolf qemu_vfree(s->l1_table); 1501cf93980eSMax Reitz /* else pre-write overlap checks in cache_destroy may crash */ 1502cf93980eSMax Reitz s->l1_table = NULL; 1503279621c0SAlberto Garcia cache_clean_timer_del(bs); 150429c1a730SKevin Wolf if (s->l2_table_cache) { 150529c1a730SKevin Wolf qcow2_cache_destroy(bs, s->l2_table_cache); 150629c1a730SKevin Wolf } 1507c5a33ee9SPrasad Joshi if (s->refcount_block_cache) { 1508c5a33ee9SPrasad Joshi qcow2_cache_destroy(bs, s->refcount_block_cache); 1509c5a33ee9SPrasad Joshi } 15107267c094SAnthony Liguori g_free(s->cluster_cache); 1511dea43a65SFrediano Ziglio qemu_vfree(s->cluster_data); 1512b25b387fSDaniel P. Berrange qcrypto_block_free(s->crypto); 1513b25b387fSDaniel P. Berrange qapi_free_QCryptoBlockOpenOptions(s->crypto_opts); 15146d85a57eSJes Sorensen return ret; 1515585f8587Sbellard } 1516585f8587Sbellard 15174e4bf5c4SKevin Wolf static int qcow2_open(BlockDriverState *bs, QDict *options, int flags, 15184e4bf5c4SKevin Wolf Error **errp) 15194e4bf5c4SKevin Wolf { 15204e4bf5c4SKevin Wolf bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file, 15214e4bf5c4SKevin Wolf false, errp); 15224e4bf5c4SKevin Wolf if (!bs->file) { 15234e4bf5c4SKevin Wolf return -EINVAL; 15244e4bf5c4SKevin Wolf } 15254e4bf5c4SKevin Wolf 15264e4bf5c4SKevin Wolf return qcow2_do_open(bs, options, flags, errp); 15274e4bf5c4SKevin Wolf } 15284e4bf5c4SKevin Wolf 15293baca891SKevin Wolf static void qcow2_refresh_limits(BlockDriverState *bs, Error **errp) 1530d34682cdSKevin Wolf { 1531ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 1532d34682cdSKevin Wolf 1533a84178ccSEric Blake if (bs->encrypted) { 1534a84178ccSEric Blake /* Encryption works on a sector granularity */ 1535a5b8dd2cSEric Blake bs->bl.request_alignment = BDRV_SECTOR_SIZE; 1536a84178ccSEric Blake } 1537cf081fcaSEric Blake bs->bl.pwrite_zeroes_alignment = s->cluster_size; 1538ecdbead6SEric Blake bs->bl.pdiscard_alignment = s->cluster_size; 1539d34682cdSKevin Wolf } 1540d34682cdSKevin Wolf 154121d82ac9SJeff Cody static int qcow2_reopen_prepare(BDRVReopenState *state, 154221d82ac9SJeff Cody BlockReopenQueue *queue, Error **errp) 154321d82ac9SJeff Cody { 15445b0959a7SKevin Wolf Qcow2ReopenState *r; 15454c2e5f8fSKevin Wolf int ret; 15464c2e5f8fSKevin Wolf 15475b0959a7SKevin Wolf r = g_new0(Qcow2ReopenState, 1); 15485b0959a7SKevin Wolf state->opaque = r; 15495b0959a7SKevin Wolf 15505b0959a7SKevin Wolf ret = qcow2_update_options_prepare(state->bs, r, state->options, 15515b0959a7SKevin Wolf state->flags, errp); 15525b0959a7SKevin Wolf if (ret < 0) { 15535b0959a7SKevin Wolf goto fail; 15545b0959a7SKevin Wolf } 15555b0959a7SKevin Wolf 15565b0959a7SKevin Wolf /* We need to write out any unwritten data if we reopen read-only. */ 15574c2e5f8fSKevin Wolf if ((state->flags & BDRV_O_RDWR) == 0) { 1558169b8793SVladimir Sementsov-Ogievskiy ret = qcow2_reopen_bitmaps_ro(state->bs, errp); 1559169b8793SVladimir Sementsov-Ogievskiy if (ret < 0) { 1560169b8793SVladimir Sementsov-Ogievskiy goto fail; 1561169b8793SVladimir Sementsov-Ogievskiy } 1562169b8793SVladimir Sementsov-Ogievskiy 15634c2e5f8fSKevin Wolf ret = bdrv_flush(state->bs); 15644c2e5f8fSKevin Wolf if (ret < 0) { 15655b0959a7SKevin Wolf goto fail; 15664c2e5f8fSKevin Wolf } 15674c2e5f8fSKevin Wolf 15684c2e5f8fSKevin Wolf ret = qcow2_mark_clean(state->bs); 15694c2e5f8fSKevin Wolf if (ret < 0) { 15705b0959a7SKevin Wolf goto fail; 15714c2e5f8fSKevin Wolf } 15724c2e5f8fSKevin Wolf } 15734c2e5f8fSKevin Wolf 157421d82ac9SJeff Cody return 0; 15755b0959a7SKevin Wolf 15765b0959a7SKevin Wolf fail: 15775b0959a7SKevin Wolf qcow2_update_options_abort(state->bs, r); 15785b0959a7SKevin Wolf g_free(r); 15795b0959a7SKevin Wolf return ret; 15805b0959a7SKevin Wolf } 15815b0959a7SKevin Wolf 15825b0959a7SKevin Wolf static void qcow2_reopen_commit(BDRVReopenState *state) 15835b0959a7SKevin Wolf { 15845b0959a7SKevin Wolf qcow2_update_options_commit(state->bs, state->opaque); 15855b0959a7SKevin Wolf g_free(state->opaque); 15865b0959a7SKevin Wolf } 15875b0959a7SKevin Wolf 15885b0959a7SKevin Wolf static void qcow2_reopen_abort(BDRVReopenState *state) 15895b0959a7SKevin Wolf { 15905b0959a7SKevin Wolf qcow2_update_options_abort(state->bs, state->opaque); 15915b0959a7SKevin Wolf g_free(state->opaque); 159221d82ac9SJeff Cody } 159321d82ac9SJeff Cody 15945365f44dSKevin Wolf static void qcow2_join_options(QDict *options, QDict *old_options) 15955365f44dSKevin Wolf { 15965365f44dSKevin Wolf bool has_new_overlap_template = 15975365f44dSKevin Wolf qdict_haskey(options, QCOW2_OPT_OVERLAP) || 15985365f44dSKevin Wolf qdict_haskey(options, QCOW2_OPT_OVERLAP_TEMPLATE); 15995365f44dSKevin Wolf bool has_new_total_cache_size = 16005365f44dSKevin Wolf qdict_haskey(options, QCOW2_OPT_CACHE_SIZE); 16015365f44dSKevin Wolf bool has_all_cache_options; 16025365f44dSKevin Wolf 16035365f44dSKevin Wolf /* New overlap template overrides all old overlap options */ 16045365f44dSKevin Wolf if (has_new_overlap_template) { 16055365f44dSKevin Wolf qdict_del(old_options, QCOW2_OPT_OVERLAP); 16065365f44dSKevin Wolf qdict_del(old_options, QCOW2_OPT_OVERLAP_TEMPLATE); 16075365f44dSKevin Wolf qdict_del(old_options, QCOW2_OPT_OVERLAP_MAIN_HEADER); 16085365f44dSKevin Wolf qdict_del(old_options, QCOW2_OPT_OVERLAP_ACTIVE_L1); 16095365f44dSKevin Wolf qdict_del(old_options, QCOW2_OPT_OVERLAP_ACTIVE_L2); 16105365f44dSKevin Wolf qdict_del(old_options, QCOW2_OPT_OVERLAP_REFCOUNT_TABLE); 16115365f44dSKevin Wolf qdict_del(old_options, QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK); 16125365f44dSKevin Wolf qdict_del(old_options, QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE); 16135365f44dSKevin Wolf qdict_del(old_options, QCOW2_OPT_OVERLAP_INACTIVE_L1); 16145365f44dSKevin Wolf qdict_del(old_options, QCOW2_OPT_OVERLAP_INACTIVE_L2); 16155365f44dSKevin Wolf } 16165365f44dSKevin Wolf 16175365f44dSKevin Wolf /* New total cache size overrides all old options */ 16185365f44dSKevin Wolf if (qdict_haskey(options, QCOW2_OPT_CACHE_SIZE)) { 16195365f44dSKevin Wolf qdict_del(old_options, QCOW2_OPT_L2_CACHE_SIZE); 16205365f44dSKevin Wolf qdict_del(old_options, QCOW2_OPT_REFCOUNT_CACHE_SIZE); 16215365f44dSKevin Wolf } 16225365f44dSKevin Wolf 16235365f44dSKevin Wolf qdict_join(options, old_options, false); 16245365f44dSKevin Wolf 16255365f44dSKevin Wolf /* 16265365f44dSKevin Wolf * If after merging all cache size options are set, an old total size is 16275365f44dSKevin Wolf * overwritten. Do keep all options, however, if all three are new. The 16285365f44dSKevin Wolf * resulting error message is what we want to happen. 16295365f44dSKevin Wolf */ 16305365f44dSKevin Wolf has_all_cache_options = 16315365f44dSKevin Wolf qdict_haskey(options, QCOW2_OPT_CACHE_SIZE) || 16325365f44dSKevin Wolf qdict_haskey(options, QCOW2_OPT_L2_CACHE_SIZE) || 16335365f44dSKevin Wolf qdict_haskey(options, QCOW2_OPT_REFCOUNT_CACHE_SIZE); 16345365f44dSKevin Wolf 16355365f44dSKevin Wolf if (has_all_cache_options && !has_new_total_cache_size) { 16365365f44dSKevin Wolf qdict_del(options, QCOW2_OPT_CACHE_SIZE); 16375365f44dSKevin Wolf } 16385365f44dSKevin Wolf } 16395365f44dSKevin Wolf 1640b6b8a333SPaolo Bonzini static int64_t coroutine_fn qcow2_co_get_block_status(BlockDriverState *bs, 164167a0fd2aSFam Zheng int64_t sector_num, int nb_sectors, int *pnum, BlockDriverState **file) 1642585f8587Sbellard { 1643ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 1644585f8587Sbellard uint64_t cluster_offset; 16454bc74be9SPaolo Bonzini int index_in_cluster, ret; 1646ecfe1863SKevin Wolf unsigned int bytes; 16474bc74be9SPaolo Bonzini int64_t status = 0; 1648585f8587Sbellard 1649ecfe1863SKevin Wolf bytes = MIN(INT_MAX, nb_sectors * BDRV_SECTOR_SIZE); 1650f8a2e5e3SStefan Hajnoczi qemu_co_mutex_lock(&s->lock); 1651ecfe1863SKevin Wolf ret = qcow2_get_cluster_offset(bs, sector_num << 9, &bytes, 1652ecfe1863SKevin Wolf &cluster_offset); 1653f8a2e5e3SStefan Hajnoczi qemu_co_mutex_unlock(&s->lock); 16541c46efaaSKevin Wolf if (ret < 0) { 1655d663640cSPaolo Bonzini return ret; 16561c46efaaSKevin Wolf } 1657095a9c58Saliguori 1658ecfe1863SKevin Wolf *pnum = bytes >> BDRV_SECTOR_BITS; 1659ecfe1863SKevin Wolf 16604bc74be9SPaolo Bonzini if (cluster_offset != 0 && ret != QCOW2_CLUSTER_COMPRESSED && 1661b25b387fSDaniel P. Berrange !s->crypto) { 16624bc74be9SPaolo Bonzini index_in_cluster = sector_num & (s->cluster_sectors - 1); 16634bc74be9SPaolo Bonzini cluster_offset |= (index_in_cluster << BDRV_SECTOR_BITS); 1664178b4db7SFam Zheng *file = bs->file->bs; 16654bc74be9SPaolo Bonzini status |= BDRV_BLOCK_OFFSET_VALID | cluster_offset; 16664bc74be9SPaolo Bonzini } 1667fdfab37dSEric Blake if (ret == QCOW2_CLUSTER_ZERO_PLAIN || ret == QCOW2_CLUSTER_ZERO_ALLOC) { 16684bc74be9SPaolo Bonzini status |= BDRV_BLOCK_ZERO; 16694bc74be9SPaolo Bonzini } else if (ret != QCOW2_CLUSTER_UNALLOCATED) { 16704bc74be9SPaolo Bonzini status |= BDRV_BLOCK_DATA; 16714bc74be9SPaolo Bonzini } 16724bc74be9SPaolo Bonzini return status; 1673585f8587Sbellard } 1674585f8587Sbellard 1675a9465922Sbellard /* handle reading after the end of the backing file */ 1676bd28f835SKevin Wolf int qcow2_backing_read1(BlockDriverState *bs, QEMUIOVector *qiov, 1677ecfe1863SKevin Wolf int64_t offset, int bytes) 1678a9465922Sbellard { 1679ecfe1863SKevin Wolf uint64_t bs_size = bs->total_sectors * BDRV_SECTOR_SIZE; 1680a9465922Sbellard int n1; 1681bd28f835SKevin Wolf 1682ecfe1863SKevin Wolf if ((offset + bytes) <= bs_size) { 1683ecfe1863SKevin Wolf return bytes; 1684ecfe1863SKevin Wolf } 1685ecfe1863SKevin Wolf 1686ecfe1863SKevin Wolf if (offset >= bs_size) { 1687ecfe1863SKevin Wolf n1 = 0; 1688ecfe1863SKevin Wolf } else { 1689ecfe1863SKevin Wolf n1 = bs_size - offset; 1690ecfe1863SKevin Wolf } 1691ecfe1863SKevin Wolf 1692ecfe1863SKevin Wolf qemu_iovec_memset(qiov, n1, 0, bytes - n1); 1693bd28f835SKevin Wolf 1694a9465922Sbellard return n1; 1695a9465922Sbellard } 1696a9465922Sbellard 1697ecfe1863SKevin Wolf static coroutine_fn int qcow2_co_preadv(BlockDriverState *bs, uint64_t offset, 1698ecfe1863SKevin Wolf uint64_t bytes, QEMUIOVector *qiov, 1699ecfe1863SKevin Wolf int flags) 17001490791fSaliguori { 1701ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 1702ecfe1863SKevin Wolf int offset_in_cluster, n1; 170368d100e9SKevin Wolf int ret; 1704ecfe1863SKevin Wolf unsigned int cur_bytes; /* number of bytes in current iteration */ 1705c2bdd990SFrediano Ziglio uint64_t cluster_offset = 0; 17063fc48d09SFrediano Ziglio uint64_t bytes_done = 0; 17073fc48d09SFrediano Ziglio QEMUIOVector hd_qiov; 17083fc48d09SFrediano Ziglio uint8_t *cluster_data = NULL; 1709585f8587Sbellard 17103fc48d09SFrediano Ziglio qemu_iovec_init(&hd_qiov, qiov->niov); 17113fc48d09SFrediano Ziglio 17123fc48d09SFrediano Ziglio qemu_co_mutex_lock(&s->lock); 17133fc48d09SFrediano Ziglio 1714ecfe1863SKevin Wolf while (bytes != 0) { 1715585f8587Sbellard 1716faf575c1SFrediano Ziglio /* prepare next request */ 1717ecfe1863SKevin Wolf cur_bytes = MIN(bytes, INT_MAX); 1718b25b387fSDaniel P. Berrange if (s->crypto) { 1719ecfe1863SKevin Wolf cur_bytes = MIN(cur_bytes, 1720ecfe1863SKevin Wolf QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size); 1721bd28f835SKevin Wolf } 1722bd28f835SKevin Wolf 1723ecfe1863SKevin Wolf ret = qcow2_get_cluster_offset(bs, offset, &cur_bytes, &cluster_offset); 17241c46efaaSKevin Wolf if (ret < 0) { 17253fc48d09SFrediano Ziglio goto fail; 17261c46efaaSKevin Wolf } 17271c46efaaSKevin Wolf 1728ecfe1863SKevin Wolf offset_in_cluster = offset_into_cluster(s, offset); 1729585f8587Sbellard 17303fc48d09SFrediano Ziglio qemu_iovec_reset(&hd_qiov); 1731ecfe1863SKevin Wolf qemu_iovec_concat(&hd_qiov, qiov, bytes_done, cur_bytes); 1732bd28f835SKevin Wolf 173368d000a3SKevin Wolf switch (ret) { 173468d000a3SKevin Wolf case QCOW2_CLUSTER_UNALLOCATED: 1735bd28f835SKevin Wolf 1736760e0063SKevin Wolf if (bs->backing) { 1737585f8587Sbellard /* read from the base image */ 1738760e0063SKevin Wolf n1 = qcow2_backing_read1(bs->backing->bs, &hd_qiov, 1739ecfe1863SKevin Wolf offset, cur_bytes); 1740a9465922Sbellard if (n1 > 0) { 174144deba5aSKevin Wolf QEMUIOVector local_qiov; 174244deba5aSKevin Wolf 174344deba5aSKevin Wolf qemu_iovec_init(&local_qiov, hd_qiov.niov); 1744ecfe1863SKevin Wolf qemu_iovec_concat(&local_qiov, &hd_qiov, 0, n1); 174544deba5aSKevin Wolf 174666f82ceeSKevin Wolf BLKDBG_EVENT(bs->file, BLKDBG_READ_BACKING_AIO); 174768d100e9SKevin Wolf qemu_co_mutex_unlock(&s->lock); 1748a03ef88fSKevin Wolf ret = bdrv_co_preadv(bs->backing, offset, n1, 1749ecfe1863SKevin Wolf &local_qiov, 0); 175068d100e9SKevin Wolf qemu_co_mutex_lock(&s->lock); 175144deba5aSKevin Wolf 175244deba5aSKevin Wolf qemu_iovec_destroy(&local_qiov); 175344deba5aSKevin Wolf 175468d100e9SKevin Wolf if (ret < 0) { 17553fc48d09SFrediano Ziglio goto fail; 17563ab4c7e9SKevin Wolf } 17571490791fSaliguori } 1758a9465922Sbellard } else { 1759585f8587Sbellard /* Note: in this case, no need to wait */ 1760ecfe1863SKevin Wolf qemu_iovec_memset(&hd_qiov, 0, 0, cur_bytes); 17611490791fSaliguori } 176268d000a3SKevin Wolf break; 176368d000a3SKevin Wolf 1764fdfab37dSEric Blake case QCOW2_CLUSTER_ZERO_PLAIN: 1765fdfab37dSEric Blake case QCOW2_CLUSTER_ZERO_ALLOC: 1766ecfe1863SKevin Wolf qemu_iovec_memset(&hd_qiov, 0, 0, cur_bytes); 17676377af48SKevin Wolf break; 17686377af48SKevin Wolf 176968d000a3SKevin Wolf case QCOW2_CLUSTER_COMPRESSED: 1770585f8587Sbellard /* add AIO support for compressed blocks ? */ 1771c2bdd990SFrediano Ziglio ret = qcow2_decompress_cluster(bs, cluster_offset); 17728af36488SKevin Wolf if (ret < 0) { 17733fc48d09SFrediano Ziglio goto fail; 17748af36488SKevin Wolf } 1775bd28f835SKevin Wolf 177603396148SMichael Tokarev qemu_iovec_from_buf(&hd_qiov, 0, 1777ecfe1863SKevin Wolf s->cluster_cache + offset_in_cluster, 1778ecfe1863SKevin Wolf cur_bytes); 177968d000a3SKevin Wolf break; 178068d000a3SKevin Wolf 178168d000a3SKevin Wolf case QCOW2_CLUSTER_NORMAL: 1782c2bdd990SFrediano Ziglio if ((cluster_offset & 511) != 0) { 17833fc48d09SFrediano Ziglio ret = -EIO; 17843fc48d09SFrediano Ziglio goto fail; 1785585f8587Sbellard } 1786c87c0672Saliguori 17878336aafaSDaniel P. Berrange if (bs->encrypted) { 1788b25b387fSDaniel P. Berrange assert(s->crypto); 17898336aafaSDaniel P. Berrange 1790bd28f835SKevin Wolf /* 1791bd28f835SKevin Wolf * For encrypted images, read everything into a temporary 1792bd28f835SKevin Wolf * contiguous buffer on which the AES functions can work. 1793bd28f835SKevin Wolf */ 17943fc48d09SFrediano Ziglio if (!cluster_data) { 17953fc48d09SFrediano Ziglio cluster_data = 17969a4f4c31SKevin Wolf qemu_try_blockalign(bs->file->bs, 17979a4f4c31SKevin Wolf QCOW_MAX_CRYPT_CLUSTERS 1798de82815dSKevin Wolf * s->cluster_size); 1799de82815dSKevin Wolf if (cluster_data == NULL) { 1800de82815dSKevin Wolf ret = -ENOMEM; 1801de82815dSKevin Wolf goto fail; 1802de82815dSKevin Wolf } 1803bd28f835SKevin Wolf } 1804bd28f835SKevin Wolf 1805ecfe1863SKevin Wolf assert(cur_bytes <= QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size); 18063fc48d09SFrediano Ziglio qemu_iovec_reset(&hd_qiov); 1807ecfe1863SKevin Wolf qemu_iovec_add(&hd_qiov, cluster_data, cur_bytes); 1808bd28f835SKevin Wolf } 1809bd28f835SKevin Wolf 181066f82ceeSKevin Wolf BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO); 181168d100e9SKevin Wolf qemu_co_mutex_unlock(&s->lock); 1812a03ef88fSKevin Wolf ret = bdrv_co_preadv(bs->file, 1813ecfe1863SKevin Wolf cluster_offset + offset_in_cluster, 1814ecfe1863SKevin Wolf cur_bytes, &hd_qiov, 0); 181568d100e9SKevin Wolf qemu_co_mutex_lock(&s->lock); 181668d100e9SKevin Wolf if (ret < 0) { 18173fc48d09SFrediano Ziglio goto fail; 1818585f8587Sbellard } 18198336aafaSDaniel P. Berrange if (bs->encrypted) { 1820b25b387fSDaniel P. Berrange assert(s->crypto); 1821ecfe1863SKevin Wolf assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0); 1822ecfe1863SKevin Wolf assert((cur_bytes & (BDRV_SECTOR_SIZE - 1)) == 0); 1823b25b387fSDaniel P. Berrange if (qcrypto_block_decrypt(s->crypto, 18244652b8f3SDaniel P. Berrange (s->crypt_physical_offset ? 18254652b8f3SDaniel P. Berrange cluster_offset + offset_in_cluster : 18264652b8f3SDaniel P. Berrange offset) >> BDRV_SECTOR_BITS, 1827446d306dSDaniel P. Berrange cluster_data, 1828b25b387fSDaniel P. Berrange cur_bytes, 1829*c3a8fe33SAlberto Garcia NULL) < 0) { 1830f6fa64f6SDaniel P. Berrange ret = -EIO; 1831f6fa64f6SDaniel P. Berrange goto fail; 1832f6fa64f6SDaniel P. Berrange } 1833ecfe1863SKevin Wolf qemu_iovec_from_buf(qiov, bytes_done, cluster_data, cur_bytes); 1834171e3d6bSKevin Wolf } 183568d000a3SKevin Wolf break; 183668d000a3SKevin Wolf 183768d000a3SKevin Wolf default: 183868d000a3SKevin Wolf g_assert_not_reached(); 183968d000a3SKevin Wolf ret = -EIO; 184068d000a3SKevin Wolf goto fail; 1841faf575c1SFrediano Ziglio } 1842faf575c1SFrediano Ziglio 1843ecfe1863SKevin Wolf bytes -= cur_bytes; 1844ecfe1863SKevin Wolf offset += cur_bytes; 1845ecfe1863SKevin Wolf bytes_done += cur_bytes; 18465ebaa27eSFrediano Ziglio } 18473fc48d09SFrediano Ziglio ret = 0; 1848f141eafeSaliguori 18493fc48d09SFrediano Ziglio fail: 185068d100e9SKevin Wolf qemu_co_mutex_unlock(&s->lock); 185168d100e9SKevin Wolf 18523fc48d09SFrediano Ziglio qemu_iovec_destroy(&hd_qiov); 1853dea43a65SFrediano Ziglio qemu_vfree(cluster_data); 185468d100e9SKevin Wolf 185568d100e9SKevin Wolf return ret; 1856585f8587Sbellard } 1857585f8587Sbellard 1858ee22a9d8SAlberto Garcia /* Check if it's possible to merge a write request with the writing of 1859ee22a9d8SAlberto Garcia * the data from the COW regions */ 1860ee22a9d8SAlberto Garcia static bool merge_cow(uint64_t offset, unsigned bytes, 1861ee22a9d8SAlberto Garcia QEMUIOVector *hd_qiov, QCowL2Meta *l2meta) 1862ee22a9d8SAlberto Garcia { 1863ee22a9d8SAlberto Garcia QCowL2Meta *m; 1864ee22a9d8SAlberto Garcia 1865ee22a9d8SAlberto Garcia for (m = l2meta; m != NULL; m = m->next) { 1866ee22a9d8SAlberto Garcia /* If both COW regions are empty then there's nothing to merge */ 1867ee22a9d8SAlberto Garcia if (m->cow_start.nb_bytes == 0 && m->cow_end.nb_bytes == 0) { 1868ee22a9d8SAlberto Garcia continue; 1869ee22a9d8SAlberto Garcia } 1870ee22a9d8SAlberto Garcia 1871ee22a9d8SAlberto Garcia /* The data (middle) region must be immediately after the 1872ee22a9d8SAlberto Garcia * start region */ 1873ee22a9d8SAlberto Garcia if (l2meta_cow_start(m) + m->cow_start.nb_bytes != offset) { 1874ee22a9d8SAlberto Garcia continue; 1875ee22a9d8SAlberto Garcia } 1876ee22a9d8SAlberto Garcia 1877ee22a9d8SAlberto Garcia /* The end region must be immediately after the data (middle) 1878ee22a9d8SAlberto Garcia * region */ 1879ee22a9d8SAlberto Garcia if (m->offset + m->cow_end.offset != offset + bytes) { 1880ee22a9d8SAlberto Garcia continue; 1881ee22a9d8SAlberto Garcia } 1882ee22a9d8SAlberto Garcia 1883ee22a9d8SAlberto Garcia /* Make sure that adding both COW regions to the QEMUIOVector 1884ee22a9d8SAlberto Garcia * does not exceed IOV_MAX */ 1885ee22a9d8SAlberto Garcia if (hd_qiov->niov > IOV_MAX - 2) { 1886ee22a9d8SAlberto Garcia continue; 1887ee22a9d8SAlberto Garcia } 1888ee22a9d8SAlberto Garcia 1889ee22a9d8SAlberto Garcia m->data_qiov = hd_qiov; 1890ee22a9d8SAlberto Garcia return true; 1891ee22a9d8SAlberto Garcia } 1892ee22a9d8SAlberto Garcia 1893ee22a9d8SAlberto Garcia return false; 1894ee22a9d8SAlberto Garcia } 1895ee22a9d8SAlberto Garcia 1896d46a0bb2SKevin Wolf static coroutine_fn int qcow2_co_pwritev(BlockDriverState *bs, uint64_t offset, 1897d46a0bb2SKevin Wolf uint64_t bytes, QEMUIOVector *qiov, 1898d46a0bb2SKevin Wolf int flags) 1899585f8587Sbellard { 1900ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 1901d46a0bb2SKevin Wolf int offset_in_cluster; 190268d100e9SKevin Wolf int ret; 1903d46a0bb2SKevin Wolf unsigned int cur_bytes; /* number of sectors in current iteration */ 1904c2bdd990SFrediano Ziglio uint64_t cluster_offset; 19053fc48d09SFrediano Ziglio QEMUIOVector hd_qiov; 19063fc48d09SFrediano Ziglio uint64_t bytes_done = 0; 19073fc48d09SFrediano Ziglio uint8_t *cluster_data = NULL; 19088d2497c3SKevin Wolf QCowL2Meta *l2meta = NULL; 1909c2271403SFrediano Ziglio 1910d46a0bb2SKevin Wolf trace_qcow2_writev_start_req(qemu_coroutine_self(), offset, bytes); 19113cce16f4SKevin Wolf 19123fc48d09SFrediano Ziglio qemu_iovec_init(&hd_qiov, qiov->niov); 1913585f8587Sbellard 19143fc48d09SFrediano Ziglio s->cluster_cache_offset = -1; /* disable compressed cache */ 19153fc48d09SFrediano Ziglio 19163fc48d09SFrediano Ziglio qemu_co_mutex_lock(&s->lock); 19173fc48d09SFrediano Ziglio 1918d46a0bb2SKevin Wolf while (bytes != 0) { 19193fc48d09SFrediano Ziglio 1920f50f88b9SKevin Wolf l2meta = NULL; 1921cf5c1a23SKevin Wolf 19223cce16f4SKevin Wolf trace_qcow2_writev_start_part(qemu_coroutine_self()); 1923d46a0bb2SKevin Wolf offset_in_cluster = offset_into_cluster(s, offset); 1924d46a0bb2SKevin Wolf cur_bytes = MIN(bytes, INT_MAX); 1925d46a0bb2SKevin Wolf if (bs->encrypted) { 1926d46a0bb2SKevin Wolf cur_bytes = MIN(cur_bytes, 1927d46a0bb2SKevin Wolf QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size 1928d46a0bb2SKevin Wolf - offset_in_cluster); 19295ebaa27eSFrediano Ziglio } 1930095a9c58Saliguori 1931d46a0bb2SKevin Wolf ret = qcow2_alloc_cluster_offset(bs, offset, &cur_bytes, 1932d46a0bb2SKevin Wolf &cluster_offset, &l2meta); 1933148da7eaSKevin Wolf if (ret < 0) { 19343fc48d09SFrediano Ziglio goto fail; 1935148da7eaSKevin Wolf } 1936148da7eaSKevin Wolf 1937c2bdd990SFrediano Ziglio assert((cluster_offset & 511) == 0); 1938148da7eaSKevin Wolf 19393fc48d09SFrediano Ziglio qemu_iovec_reset(&hd_qiov); 1940d46a0bb2SKevin Wolf qemu_iovec_concat(&hd_qiov, qiov, bytes_done, cur_bytes); 19416f5f060bSKevin Wolf 19428336aafaSDaniel P. Berrange if (bs->encrypted) { 1943b25b387fSDaniel P. Berrange assert(s->crypto); 19443fc48d09SFrediano Ziglio if (!cluster_data) { 19459a4f4c31SKevin Wolf cluster_data = qemu_try_blockalign(bs->file->bs, 1946de82815dSKevin Wolf QCOW_MAX_CRYPT_CLUSTERS 1947de82815dSKevin Wolf * s->cluster_size); 1948de82815dSKevin Wolf if (cluster_data == NULL) { 1949de82815dSKevin Wolf ret = -ENOMEM; 1950de82815dSKevin Wolf goto fail; 1951de82815dSKevin Wolf } 1952585f8587Sbellard } 19536f5f060bSKevin Wolf 19543fc48d09SFrediano Ziglio assert(hd_qiov.size <= 19555ebaa27eSFrediano Ziglio QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size); 1956d5e6b161SMichael Tokarev qemu_iovec_to_buf(&hd_qiov, 0, cluster_data, hd_qiov.size); 19576f5f060bSKevin Wolf 19584652b8f3SDaniel P. Berrange if (qcrypto_block_encrypt(s->crypto, 19594652b8f3SDaniel P. Berrange (s->crypt_physical_offset ? 19604652b8f3SDaniel P. Berrange cluster_offset + offset_in_cluster : 19614652b8f3SDaniel P. Berrange offset) >> BDRV_SECTOR_BITS, 1962446d306dSDaniel P. Berrange cluster_data, 1963*c3a8fe33SAlberto Garcia cur_bytes, NULL) < 0) { 1964f6fa64f6SDaniel P. Berrange ret = -EIO; 1965f6fa64f6SDaniel P. Berrange goto fail; 1966f6fa64f6SDaniel P. Berrange } 19676f5f060bSKevin Wolf 19683fc48d09SFrediano Ziglio qemu_iovec_reset(&hd_qiov); 1969d46a0bb2SKevin Wolf qemu_iovec_add(&hd_qiov, cluster_data, cur_bytes); 1970585f8587Sbellard } 19716f5f060bSKevin Wolf 1972231bb267SMax Reitz ret = qcow2_pre_write_overlap_check(bs, 0, 1973d46a0bb2SKevin Wolf cluster_offset + offset_in_cluster, cur_bytes); 1974cf93980eSMax Reitz if (ret < 0) { 1975cf93980eSMax Reitz goto fail; 1976cf93980eSMax Reitz } 1977cf93980eSMax Reitz 1978ee22a9d8SAlberto Garcia /* If we need to do COW, check if it's possible to merge the 1979ee22a9d8SAlberto Garcia * writing of the guest data together with that of the COW regions. 1980ee22a9d8SAlberto Garcia * If it's not possible (or not necessary) then write the 1981ee22a9d8SAlberto Garcia * guest data now. */ 1982ee22a9d8SAlberto Garcia if (!merge_cow(offset, cur_bytes, &hd_qiov, l2meta)) { 198368d100e9SKevin Wolf qemu_co_mutex_unlock(&s->lock); 198467a7a0ebSKevin Wolf BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO); 19853cce16f4SKevin Wolf trace_qcow2_writev_data(qemu_coroutine_self(), 1986d46a0bb2SKevin Wolf cluster_offset + offset_in_cluster); 1987a03ef88fSKevin Wolf ret = bdrv_co_pwritev(bs->file, 1988d46a0bb2SKevin Wolf cluster_offset + offset_in_cluster, 1989d46a0bb2SKevin Wolf cur_bytes, &hd_qiov, 0); 199068d100e9SKevin Wolf qemu_co_mutex_lock(&s->lock); 199168d100e9SKevin Wolf if (ret < 0) { 19923fc48d09SFrediano Ziglio goto fail; 1993171e3d6bSKevin Wolf } 1994ee22a9d8SAlberto Garcia } 1995f141eafeSaliguori 199688c6588cSKevin Wolf while (l2meta != NULL) { 199788c6588cSKevin Wolf QCowL2Meta *next; 199888c6588cSKevin Wolf 1999cf5c1a23SKevin Wolf ret = qcow2_alloc_cluster_link_l2(bs, l2meta); 2000faf575c1SFrediano Ziglio if (ret < 0) { 20013fc48d09SFrediano Ziglio goto fail; 2002faf575c1SFrediano Ziglio } 2003faf575c1SFrediano Ziglio 20044e95314eSKevin Wolf /* Take the request off the list of running requests */ 20054e95314eSKevin Wolf if (l2meta->nb_clusters != 0) { 20064e95314eSKevin Wolf QLIST_REMOVE(l2meta, next_in_flight); 20074e95314eSKevin Wolf } 20084e95314eSKevin Wolf 20094e95314eSKevin Wolf qemu_co_queue_restart_all(&l2meta->dependent_requests); 20104e95314eSKevin Wolf 201188c6588cSKevin Wolf next = l2meta->next; 2012cf5c1a23SKevin Wolf g_free(l2meta); 201388c6588cSKevin Wolf l2meta = next; 2014f50f88b9SKevin Wolf } 20150fa9131aSKevin Wolf 2016d46a0bb2SKevin Wolf bytes -= cur_bytes; 2017d46a0bb2SKevin Wolf offset += cur_bytes; 2018d46a0bb2SKevin Wolf bytes_done += cur_bytes; 2019d46a0bb2SKevin Wolf trace_qcow2_writev_done_part(qemu_coroutine_self(), cur_bytes); 20205ebaa27eSFrediano Ziglio } 20213fc48d09SFrediano Ziglio ret = 0; 2022faf575c1SFrediano Ziglio 20233fc48d09SFrediano Ziglio fail: 202488c6588cSKevin Wolf while (l2meta != NULL) { 202588c6588cSKevin Wolf QCowL2Meta *next; 202688c6588cSKevin Wolf 20274e95314eSKevin Wolf if (l2meta->nb_clusters != 0) { 20284e95314eSKevin Wolf QLIST_REMOVE(l2meta, next_in_flight); 20294e95314eSKevin Wolf } 20304e95314eSKevin Wolf qemu_co_queue_restart_all(&l2meta->dependent_requests); 203188c6588cSKevin Wolf 203288c6588cSKevin Wolf next = l2meta->next; 2033cf5c1a23SKevin Wolf g_free(l2meta); 203488c6588cSKevin Wolf l2meta = next; 2035cf5c1a23SKevin Wolf } 20360fa9131aSKevin Wolf 2037a8c57408SPaolo Bonzini qemu_co_mutex_unlock(&s->lock); 2038a8c57408SPaolo Bonzini 20393fc48d09SFrediano Ziglio qemu_iovec_destroy(&hd_qiov); 2040dea43a65SFrediano Ziglio qemu_vfree(cluster_data); 20413cce16f4SKevin Wolf trace_qcow2_writev_done_req(qemu_coroutine_self(), ret); 204242496d62SKevin Wolf 204368d100e9SKevin Wolf return ret; 2044585f8587Sbellard } 2045585f8587Sbellard 2046ec6d8912SKevin Wolf static int qcow2_inactivate(BlockDriverState *bs) 2047ec6d8912SKevin Wolf { 2048ec6d8912SKevin Wolf BDRVQcow2State *s = bs->opaque; 2049ec6d8912SKevin Wolf int ret, result = 0; 20505f72826eSVladimir Sementsov-Ogievskiy Error *local_err = NULL; 2051ec6d8912SKevin Wolf 2052ec6d8912SKevin Wolf ret = qcow2_cache_flush(bs, s->l2_table_cache); 2053ec6d8912SKevin Wolf if (ret) { 2054ec6d8912SKevin Wolf result = ret; 2055ec6d8912SKevin Wolf error_report("Failed to flush the L2 table cache: %s", 2056ec6d8912SKevin Wolf strerror(-ret)); 2057ec6d8912SKevin Wolf } 2058ec6d8912SKevin Wolf 2059ec6d8912SKevin Wolf ret = qcow2_cache_flush(bs, s->refcount_block_cache); 2060ec6d8912SKevin Wolf if (ret) { 2061ec6d8912SKevin Wolf result = ret; 2062ec6d8912SKevin Wolf error_report("Failed to flush the refcount block cache: %s", 2063ec6d8912SKevin Wolf strerror(-ret)); 2064ec6d8912SKevin Wolf } 2065ec6d8912SKevin Wolf 20665f72826eSVladimir Sementsov-Ogievskiy qcow2_store_persistent_dirty_bitmaps(bs, &local_err); 20675f72826eSVladimir Sementsov-Ogievskiy if (local_err != NULL) { 20685f72826eSVladimir Sementsov-Ogievskiy result = -EINVAL; 20695f72826eSVladimir Sementsov-Ogievskiy error_report_err(local_err); 20705f72826eSVladimir Sementsov-Ogievskiy error_report("Persistent bitmaps are lost for node '%s'", 20715f72826eSVladimir Sementsov-Ogievskiy bdrv_get_device_or_node_name(bs)); 20725f72826eSVladimir Sementsov-Ogievskiy } 20735f72826eSVladimir Sementsov-Ogievskiy 2074ec6d8912SKevin Wolf if (result == 0) { 2075ec6d8912SKevin Wolf qcow2_mark_clean(bs); 2076ec6d8912SKevin Wolf } 2077ec6d8912SKevin Wolf 2078ec6d8912SKevin Wolf return result; 2079ec6d8912SKevin Wolf } 2080ec6d8912SKevin Wolf 20817c80ab3fSJes Sorensen static void qcow2_close(BlockDriverState *bs) 2082585f8587Sbellard { 2083ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 2084de82815dSKevin Wolf qemu_vfree(s->l1_table); 2085cf93980eSMax Reitz /* else pre-write overlap checks in cache_destroy may crash */ 2086cf93980eSMax Reitz s->l1_table = NULL; 208729c1a730SKevin Wolf 2088140fd5a6SKevin Wolf if (!(s->flags & BDRV_O_INACTIVE)) { 2089ec6d8912SKevin Wolf qcow2_inactivate(bs); 20903b5e14c7SMax Reitz } 2091c61d0004SStefan Hajnoczi 2092279621c0SAlberto Garcia cache_clean_timer_del(bs); 209329c1a730SKevin Wolf qcow2_cache_destroy(bs, s->l2_table_cache); 209429c1a730SKevin Wolf qcow2_cache_destroy(bs, s->refcount_block_cache); 209529c1a730SKevin Wolf 2096b25b387fSDaniel P. Berrange qcrypto_block_free(s->crypto); 2097b25b387fSDaniel P. Berrange s->crypto = NULL; 2098f6fa64f6SDaniel P. Berrange 20996744cbabSKevin Wolf g_free(s->unknown_header_fields); 210075bab85cSKevin Wolf cleanup_unknown_header_ext(bs); 21016744cbabSKevin Wolf 2102e4603fe1SKevin Wolf g_free(s->image_backing_file); 2103e4603fe1SKevin Wolf g_free(s->image_backing_format); 2104e4603fe1SKevin Wolf 21057267c094SAnthony Liguori g_free(s->cluster_cache); 2106dea43a65SFrediano Ziglio qemu_vfree(s->cluster_data); 2107ed6ccf0fSKevin Wolf qcow2_refcount_close(bs); 210828c1202bSLi Zhi Hui qcow2_free_snapshots(bs); 2109585f8587Sbellard } 2110585f8587Sbellard 21115a8a30dbSKevin Wolf static void qcow2_invalidate_cache(BlockDriverState *bs, Error **errp) 211206d9260fSAnthony Liguori { 2113ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 211406d9260fSAnthony Liguori int flags = s->flags; 2115b25b387fSDaniel P. Berrange QCryptoBlock *crypto = NULL; 2116acdfb480SKevin Wolf QDict *options; 21175a8a30dbSKevin Wolf Error *local_err = NULL; 21185a8a30dbSKevin Wolf int ret; 211906d9260fSAnthony Liguori 212006d9260fSAnthony Liguori /* 212106d9260fSAnthony Liguori * Backing files are read-only which makes all of their metadata immutable, 212206d9260fSAnthony Liguori * that means we don't have to worry about reopening them here. 212306d9260fSAnthony Liguori */ 212406d9260fSAnthony Liguori 2125b25b387fSDaniel P. Berrange crypto = s->crypto; 2126b25b387fSDaniel P. Berrange s->crypto = NULL; 212706d9260fSAnthony Liguori 212806d9260fSAnthony Liguori qcow2_close(bs); 212906d9260fSAnthony Liguori 2130ff99129aSKevin Wolf memset(s, 0, sizeof(BDRVQcow2State)); 2131d475e5acSKevin Wolf options = qdict_clone_shallow(bs->options); 21325a8a30dbSKevin Wolf 2133140fd5a6SKevin Wolf flags &= ~BDRV_O_INACTIVE; 21344e4bf5c4SKevin Wolf ret = qcow2_do_open(bs, options, flags, &local_err); 2135a1904e48SMarkus Armbruster QDECREF(options); 21365a8a30dbSKevin Wolf if (local_err) { 2137e43bfd9cSMarkus Armbruster error_propagate(errp, local_err); 2138e43bfd9cSMarkus Armbruster error_prepend(errp, "Could not reopen qcow2 layer: "); 2139191fb11bSKevin Wolf bs->drv = NULL; 21405a8a30dbSKevin Wolf return; 21415a8a30dbSKevin Wolf } else if (ret < 0) { 21425a8a30dbSKevin Wolf error_setg_errno(errp, -ret, "Could not reopen qcow2 layer"); 2143191fb11bSKevin Wolf bs->drv = NULL; 21445a8a30dbSKevin Wolf return; 21455a8a30dbSKevin Wolf } 2146acdfb480SKevin Wolf 2147b25b387fSDaniel P. Berrange s->crypto = crypto; 214806d9260fSAnthony Liguori } 214906d9260fSAnthony Liguori 2150e24e49e6SKevin Wolf static size_t header_ext_add(char *buf, uint32_t magic, const void *s, 2151e24e49e6SKevin Wolf size_t len, size_t buflen) 2152756e6736SKevin Wolf { 2153e24e49e6SKevin Wolf QCowExtension *ext_backing_fmt = (QCowExtension*) buf; 2154e24e49e6SKevin Wolf size_t ext_len = sizeof(QCowExtension) + ((len + 7) & ~7); 2155756e6736SKevin Wolf 2156e24e49e6SKevin Wolf if (buflen < ext_len) { 2157756e6736SKevin Wolf return -ENOSPC; 2158756e6736SKevin Wolf } 2159756e6736SKevin Wolf 2160e24e49e6SKevin Wolf *ext_backing_fmt = (QCowExtension) { 2161e24e49e6SKevin Wolf .magic = cpu_to_be32(magic), 2162e24e49e6SKevin Wolf .len = cpu_to_be32(len), 2163e24e49e6SKevin Wolf }; 21640647d47cSStefan Hajnoczi 21650647d47cSStefan Hajnoczi if (len) { 2166e24e49e6SKevin Wolf memcpy(buf + sizeof(QCowExtension), s, len); 21670647d47cSStefan Hajnoczi } 2168756e6736SKevin Wolf 2169e24e49e6SKevin Wolf return ext_len; 2170756e6736SKevin Wolf } 2171756e6736SKevin Wolf 2172e24e49e6SKevin Wolf /* 2173e24e49e6SKevin Wolf * Updates the qcow2 header, including the variable length parts of it, i.e. 2174e24e49e6SKevin Wolf * the backing file name and all extensions. qcow2 was not designed to allow 2175e24e49e6SKevin Wolf * such changes, so if we run out of space (we can only use the first cluster) 2176e24e49e6SKevin Wolf * this function may fail. 2177e24e49e6SKevin Wolf * 2178e24e49e6SKevin Wolf * Returns 0 on success, -errno in error cases. 2179e24e49e6SKevin Wolf */ 2180e24e49e6SKevin Wolf int qcow2_update_header(BlockDriverState *bs) 2181e24e49e6SKevin Wolf { 2182ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 2183e24e49e6SKevin Wolf QCowHeader *header; 2184e24e49e6SKevin Wolf char *buf; 2185e24e49e6SKevin Wolf size_t buflen = s->cluster_size; 2186e24e49e6SKevin Wolf int ret; 2187e24e49e6SKevin Wolf uint64_t total_size; 2188e24e49e6SKevin Wolf uint32_t refcount_table_clusters; 21896744cbabSKevin Wolf size_t header_length; 219075bab85cSKevin Wolf Qcow2UnknownHeaderExtension *uext; 2191e24e49e6SKevin Wolf 2192e24e49e6SKevin Wolf buf = qemu_blockalign(bs, buflen); 2193e24e49e6SKevin Wolf 2194e24e49e6SKevin Wolf /* Header structure */ 2195e24e49e6SKevin Wolf header = (QCowHeader*) buf; 2196e24e49e6SKevin Wolf 2197e24e49e6SKevin Wolf if (buflen < sizeof(*header)) { 2198e24e49e6SKevin Wolf ret = -ENOSPC; 2199e24e49e6SKevin Wolf goto fail; 2200756e6736SKevin Wolf } 2201756e6736SKevin Wolf 22026744cbabSKevin Wolf header_length = sizeof(*header) + s->unknown_header_fields_size; 2203e24e49e6SKevin Wolf total_size = bs->total_sectors * BDRV_SECTOR_SIZE; 2204e24e49e6SKevin Wolf refcount_table_clusters = s->refcount_table_size >> (s->cluster_bits - 3); 2205e24e49e6SKevin Wolf 2206e24e49e6SKevin Wolf *header = (QCowHeader) { 22076744cbabSKevin Wolf /* Version 2 fields */ 2208e24e49e6SKevin Wolf .magic = cpu_to_be32(QCOW_MAGIC), 22096744cbabSKevin Wolf .version = cpu_to_be32(s->qcow_version), 2210e24e49e6SKevin Wolf .backing_file_offset = 0, 2211e24e49e6SKevin Wolf .backing_file_size = 0, 2212e24e49e6SKevin Wolf .cluster_bits = cpu_to_be32(s->cluster_bits), 2213e24e49e6SKevin Wolf .size = cpu_to_be64(total_size), 2214e24e49e6SKevin Wolf .crypt_method = cpu_to_be32(s->crypt_method_header), 2215e24e49e6SKevin Wolf .l1_size = cpu_to_be32(s->l1_size), 2216e24e49e6SKevin Wolf .l1_table_offset = cpu_to_be64(s->l1_table_offset), 2217e24e49e6SKevin Wolf .refcount_table_offset = cpu_to_be64(s->refcount_table_offset), 2218e24e49e6SKevin Wolf .refcount_table_clusters = cpu_to_be32(refcount_table_clusters), 2219e24e49e6SKevin Wolf .nb_snapshots = cpu_to_be32(s->nb_snapshots), 2220e24e49e6SKevin Wolf .snapshots_offset = cpu_to_be64(s->snapshots_offset), 22216744cbabSKevin Wolf 22226744cbabSKevin Wolf /* Version 3 fields */ 22236744cbabSKevin Wolf .incompatible_features = cpu_to_be64(s->incompatible_features), 22246744cbabSKevin Wolf .compatible_features = cpu_to_be64(s->compatible_features), 22256744cbabSKevin Wolf .autoclear_features = cpu_to_be64(s->autoclear_features), 2226b6481f37SMax Reitz .refcount_order = cpu_to_be32(s->refcount_order), 22276744cbabSKevin Wolf .header_length = cpu_to_be32(header_length), 2228e24e49e6SKevin Wolf }; 2229e24e49e6SKevin Wolf 22306744cbabSKevin Wolf /* For older versions, write a shorter header */ 22316744cbabSKevin Wolf switch (s->qcow_version) { 22326744cbabSKevin Wolf case 2: 22336744cbabSKevin Wolf ret = offsetof(QCowHeader, incompatible_features); 22346744cbabSKevin Wolf break; 22356744cbabSKevin Wolf case 3: 22366744cbabSKevin Wolf ret = sizeof(*header); 22376744cbabSKevin Wolf break; 22386744cbabSKevin Wolf default: 2239b6c14762SJim Meyering ret = -EINVAL; 2240b6c14762SJim Meyering goto fail; 22416744cbabSKevin Wolf } 22426744cbabSKevin Wolf 22436744cbabSKevin Wolf buf += ret; 22446744cbabSKevin Wolf buflen -= ret; 22456744cbabSKevin Wolf memset(buf, 0, buflen); 22466744cbabSKevin Wolf 22476744cbabSKevin Wolf /* Preserve any unknown field in the header */ 22486744cbabSKevin Wolf if (s->unknown_header_fields_size) { 22496744cbabSKevin Wolf if (buflen < s->unknown_header_fields_size) { 22506744cbabSKevin Wolf ret = -ENOSPC; 22516744cbabSKevin Wolf goto fail; 22526744cbabSKevin Wolf } 22536744cbabSKevin Wolf 22546744cbabSKevin Wolf memcpy(buf, s->unknown_header_fields, s->unknown_header_fields_size); 22556744cbabSKevin Wolf buf += s->unknown_header_fields_size; 22566744cbabSKevin Wolf buflen -= s->unknown_header_fields_size; 22576744cbabSKevin Wolf } 2258e24e49e6SKevin Wolf 2259e24e49e6SKevin Wolf /* Backing file format header extension */ 2260e4603fe1SKevin Wolf if (s->image_backing_format) { 2261e24e49e6SKevin Wolf ret = header_ext_add(buf, QCOW2_EXT_MAGIC_BACKING_FORMAT, 2262e4603fe1SKevin Wolf s->image_backing_format, 2263e4603fe1SKevin Wolf strlen(s->image_backing_format), 2264e24e49e6SKevin Wolf buflen); 2265756e6736SKevin Wolf if (ret < 0) { 2266756e6736SKevin Wolf goto fail; 2267756e6736SKevin Wolf } 2268756e6736SKevin Wolf 2269e24e49e6SKevin Wolf buf += ret; 2270e24e49e6SKevin Wolf buflen -= ret; 2271e24e49e6SKevin Wolf } 2272756e6736SKevin Wolf 22734652b8f3SDaniel P. Berrange /* Full disk encryption header pointer extension */ 22744652b8f3SDaniel P. Berrange if (s->crypto_header.offset != 0) { 22754652b8f3SDaniel P. Berrange cpu_to_be64s(&s->crypto_header.offset); 22764652b8f3SDaniel P. Berrange cpu_to_be64s(&s->crypto_header.length); 22774652b8f3SDaniel P. Berrange ret = header_ext_add(buf, QCOW2_EXT_MAGIC_CRYPTO_HEADER, 22784652b8f3SDaniel P. Berrange &s->crypto_header, sizeof(s->crypto_header), 22794652b8f3SDaniel P. Berrange buflen); 22804652b8f3SDaniel P. Berrange be64_to_cpus(&s->crypto_header.offset); 22814652b8f3SDaniel P. Berrange be64_to_cpus(&s->crypto_header.length); 22824652b8f3SDaniel P. Berrange if (ret < 0) { 22834652b8f3SDaniel P. Berrange goto fail; 22844652b8f3SDaniel P. Berrange } 22854652b8f3SDaniel P. Berrange buf += ret; 22864652b8f3SDaniel P. Berrange buflen -= ret; 22874652b8f3SDaniel P. Berrange } 22884652b8f3SDaniel P. Berrange 2289cfcc4c62SKevin Wolf /* Feature table */ 22901a4828c7SKevin Wolf if (s->qcow_version >= 3) { 2291cfcc4c62SKevin Wolf Qcow2Feature features[] = { 2292c61d0004SStefan Hajnoczi { 2293c61d0004SStefan Hajnoczi .type = QCOW2_FEAT_TYPE_INCOMPATIBLE, 2294c61d0004SStefan Hajnoczi .bit = QCOW2_INCOMPAT_DIRTY_BITNR, 2295c61d0004SStefan Hajnoczi .name = "dirty bit", 2296c61d0004SStefan Hajnoczi }, 2297bfe8043eSStefan Hajnoczi { 229869c98726SMax Reitz .type = QCOW2_FEAT_TYPE_INCOMPATIBLE, 229969c98726SMax Reitz .bit = QCOW2_INCOMPAT_CORRUPT_BITNR, 230069c98726SMax Reitz .name = "corrupt bit", 230169c98726SMax Reitz }, 230269c98726SMax Reitz { 2303bfe8043eSStefan Hajnoczi .type = QCOW2_FEAT_TYPE_COMPATIBLE, 2304bfe8043eSStefan Hajnoczi .bit = QCOW2_COMPAT_LAZY_REFCOUNTS_BITNR, 2305bfe8043eSStefan Hajnoczi .name = "lazy refcounts", 2306bfe8043eSStefan Hajnoczi }, 2307cfcc4c62SKevin Wolf }; 2308cfcc4c62SKevin Wolf 2309cfcc4c62SKevin Wolf ret = header_ext_add(buf, QCOW2_EXT_MAGIC_FEATURE_TABLE, 2310cfcc4c62SKevin Wolf features, sizeof(features), buflen); 2311cfcc4c62SKevin Wolf if (ret < 0) { 2312cfcc4c62SKevin Wolf goto fail; 2313cfcc4c62SKevin Wolf } 2314cfcc4c62SKevin Wolf buf += ret; 2315cfcc4c62SKevin Wolf buflen -= ret; 23161a4828c7SKevin Wolf } 2317cfcc4c62SKevin Wolf 231888ddffaeSVladimir Sementsov-Ogievskiy /* Bitmap extension */ 231988ddffaeSVladimir Sementsov-Ogievskiy if (s->nb_bitmaps > 0) { 232088ddffaeSVladimir Sementsov-Ogievskiy Qcow2BitmapHeaderExt bitmaps_header = { 232188ddffaeSVladimir Sementsov-Ogievskiy .nb_bitmaps = cpu_to_be32(s->nb_bitmaps), 232288ddffaeSVladimir Sementsov-Ogievskiy .bitmap_directory_size = 232388ddffaeSVladimir Sementsov-Ogievskiy cpu_to_be64(s->bitmap_directory_size), 232488ddffaeSVladimir Sementsov-Ogievskiy .bitmap_directory_offset = 232588ddffaeSVladimir Sementsov-Ogievskiy cpu_to_be64(s->bitmap_directory_offset) 232688ddffaeSVladimir Sementsov-Ogievskiy }; 232788ddffaeSVladimir Sementsov-Ogievskiy ret = header_ext_add(buf, QCOW2_EXT_MAGIC_BITMAPS, 232888ddffaeSVladimir Sementsov-Ogievskiy &bitmaps_header, sizeof(bitmaps_header), 232988ddffaeSVladimir Sementsov-Ogievskiy buflen); 233088ddffaeSVladimir Sementsov-Ogievskiy if (ret < 0) { 233188ddffaeSVladimir Sementsov-Ogievskiy goto fail; 233288ddffaeSVladimir Sementsov-Ogievskiy } 233388ddffaeSVladimir Sementsov-Ogievskiy buf += ret; 233488ddffaeSVladimir Sementsov-Ogievskiy buflen -= ret; 233588ddffaeSVladimir Sementsov-Ogievskiy } 233688ddffaeSVladimir Sementsov-Ogievskiy 233775bab85cSKevin Wolf /* Keep unknown header extensions */ 233875bab85cSKevin Wolf QLIST_FOREACH(uext, &s->unknown_header_ext, next) { 233975bab85cSKevin Wolf ret = header_ext_add(buf, uext->magic, uext->data, uext->len, buflen); 234075bab85cSKevin Wolf if (ret < 0) { 234175bab85cSKevin Wolf goto fail; 234275bab85cSKevin Wolf } 234375bab85cSKevin Wolf 234475bab85cSKevin Wolf buf += ret; 234575bab85cSKevin Wolf buflen -= ret; 234675bab85cSKevin Wolf } 234775bab85cSKevin Wolf 2348e24e49e6SKevin Wolf /* End of header extensions */ 2349e24e49e6SKevin Wolf ret = header_ext_add(buf, QCOW2_EXT_MAGIC_END, NULL, 0, buflen); 2350756e6736SKevin Wolf if (ret < 0) { 2351756e6736SKevin Wolf goto fail; 2352756e6736SKevin Wolf } 2353756e6736SKevin Wolf 2354e24e49e6SKevin Wolf buf += ret; 2355e24e49e6SKevin Wolf buflen -= ret; 2356e24e49e6SKevin Wolf 2357e24e49e6SKevin Wolf /* Backing file name */ 2358e4603fe1SKevin Wolf if (s->image_backing_file) { 2359e4603fe1SKevin Wolf size_t backing_file_len = strlen(s->image_backing_file); 2360e24e49e6SKevin Wolf 2361e24e49e6SKevin Wolf if (buflen < backing_file_len) { 2362e24e49e6SKevin Wolf ret = -ENOSPC; 2363e24e49e6SKevin Wolf goto fail; 2364e24e49e6SKevin Wolf } 2365e24e49e6SKevin Wolf 236600ea1881SJim Meyering /* Using strncpy is ok here, since buf is not NUL-terminated. */ 2367e4603fe1SKevin Wolf strncpy(buf, s->image_backing_file, buflen); 2368e24e49e6SKevin Wolf 2369e24e49e6SKevin Wolf header->backing_file_offset = cpu_to_be64(buf - ((char*) header)); 2370e24e49e6SKevin Wolf header->backing_file_size = cpu_to_be32(backing_file_len); 2371e24e49e6SKevin Wolf } 2372e24e49e6SKevin Wolf 2373e24e49e6SKevin Wolf /* Write the new header */ 2374d9ca2ea2SKevin Wolf ret = bdrv_pwrite(bs->file, 0, header, s->cluster_size); 2375756e6736SKevin Wolf if (ret < 0) { 2376756e6736SKevin Wolf goto fail; 2377756e6736SKevin Wolf } 2378756e6736SKevin Wolf 2379756e6736SKevin Wolf ret = 0; 2380756e6736SKevin Wolf fail: 2381e24e49e6SKevin Wolf qemu_vfree(header); 2382756e6736SKevin Wolf return ret; 2383756e6736SKevin Wolf } 2384756e6736SKevin Wolf 2385756e6736SKevin Wolf static int qcow2_change_backing_file(BlockDriverState *bs, 2386756e6736SKevin Wolf const char *backing_file, const char *backing_fmt) 2387756e6736SKevin Wolf { 2388ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 2389e4603fe1SKevin Wolf 23904e876bcfSMax Reitz if (backing_file && strlen(backing_file) > 1023) { 23914e876bcfSMax Reitz return -EINVAL; 23924e876bcfSMax Reitz } 23934e876bcfSMax Reitz 2394e24e49e6SKevin Wolf pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: ""); 2395e24e49e6SKevin Wolf pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: ""); 2396e24e49e6SKevin Wolf 2397e4603fe1SKevin Wolf g_free(s->image_backing_file); 2398e4603fe1SKevin Wolf g_free(s->image_backing_format); 2399e4603fe1SKevin Wolf 2400e4603fe1SKevin Wolf s->image_backing_file = backing_file ? g_strdup(bs->backing_file) : NULL; 2401e4603fe1SKevin Wolf s->image_backing_format = backing_fmt ? g_strdup(bs->backing_format) : NULL; 2402e4603fe1SKevin Wolf 2403e24e49e6SKevin Wolf return qcow2_update_header(bs); 2404756e6736SKevin Wolf } 2405756e6736SKevin Wolf 24064652b8f3SDaniel P. Berrange static int qcow2_crypt_method_from_format(const char *encryptfmt) 24074652b8f3SDaniel P. Berrange { 24084652b8f3SDaniel P. Berrange if (g_str_equal(encryptfmt, "luks")) { 24094652b8f3SDaniel P. Berrange return QCOW_CRYPT_LUKS; 24104652b8f3SDaniel P. Berrange } else if (g_str_equal(encryptfmt, "aes")) { 24114652b8f3SDaniel P. Berrange return QCOW_CRYPT_AES; 24124652b8f3SDaniel P. Berrange } else { 24134652b8f3SDaniel P. Berrange return -EINVAL; 24144652b8f3SDaniel P. Berrange } 24154652b8f3SDaniel P. Berrange } 2416b25b387fSDaniel P. Berrange 2417b25b387fSDaniel P. Berrange static int qcow2_set_up_encryption(BlockDriverState *bs, const char *encryptfmt, 2418b25b387fSDaniel P. Berrange QemuOpts *opts, Error **errp) 2419b25b387fSDaniel P. Berrange { 2420b25b387fSDaniel P. Berrange BDRVQcow2State *s = bs->opaque; 2421b25b387fSDaniel P. Berrange QCryptoBlockCreateOptions *cryptoopts = NULL; 2422b25b387fSDaniel P. Berrange QCryptoBlock *crypto = NULL; 2423b25b387fSDaniel P. Berrange int ret = -EINVAL; 2424b25b387fSDaniel P. Berrange QDict *options, *encryptopts; 24254652b8f3SDaniel P. Berrange int fmt; 2426b25b387fSDaniel P. Berrange 2427b25b387fSDaniel P. Berrange options = qemu_opts_to_qdict(opts, NULL); 2428b25b387fSDaniel P. Berrange qdict_extract_subqdict(options, &encryptopts, "encrypt."); 2429b25b387fSDaniel P. Berrange QDECREF(options); 2430b25b387fSDaniel P. Berrange 24314652b8f3SDaniel P. Berrange fmt = qcow2_crypt_method_from_format(encryptfmt); 24324652b8f3SDaniel P. Berrange 24334652b8f3SDaniel P. Berrange switch (fmt) { 24344652b8f3SDaniel P. Berrange case QCOW_CRYPT_LUKS: 24354652b8f3SDaniel P. Berrange cryptoopts = block_crypto_create_opts_init( 24364652b8f3SDaniel P. Berrange Q_CRYPTO_BLOCK_FORMAT_LUKS, encryptopts, errp); 24374652b8f3SDaniel P. Berrange break; 24384652b8f3SDaniel P. Berrange case QCOW_CRYPT_AES: 2439b25b387fSDaniel P. Berrange cryptoopts = block_crypto_create_opts_init( 2440b25b387fSDaniel P. Berrange Q_CRYPTO_BLOCK_FORMAT_QCOW, encryptopts, errp); 24414652b8f3SDaniel P. Berrange break; 24424652b8f3SDaniel P. Berrange default: 24434652b8f3SDaniel P. Berrange error_setg(errp, "Unknown encryption format '%s'", encryptfmt); 24444652b8f3SDaniel P. Berrange break; 24454652b8f3SDaniel P. Berrange } 2446b25b387fSDaniel P. Berrange if (!cryptoopts) { 2447b25b387fSDaniel P. Berrange ret = -EINVAL; 2448b25b387fSDaniel P. Berrange goto out; 2449b25b387fSDaniel P. Berrange } 24504652b8f3SDaniel P. Berrange s->crypt_method_header = fmt; 2451b25b387fSDaniel P. Berrange 24521cd9a787SDaniel P. Berrange crypto = qcrypto_block_create(cryptoopts, "encrypt.", 24534652b8f3SDaniel P. Berrange qcow2_crypto_hdr_init_func, 24544652b8f3SDaniel P. Berrange qcow2_crypto_hdr_write_func, 2455b25b387fSDaniel P. Berrange bs, errp); 2456b25b387fSDaniel P. Berrange if (!crypto) { 2457b25b387fSDaniel P. Berrange ret = -EINVAL; 2458b25b387fSDaniel P. Berrange goto out; 2459b25b387fSDaniel P. Berrange } 2460b25b387fSDaniel P. Berrange 2461b25b387fSDaniel P. Berrange ret = qcow2_update_header(bs); 2462b25b387fSDaniel P. Berrange if (ret < 0) { 2463b25b387fSDaniel P. Berrange error_setg_errno(errp, -ret, "Could not write encryption header"); 2464b25b387fSDaniel P. Berrange goto out; 2465b25b387fSDaniel P. Berrange } 2466b25b387fSDaniel P. Berrange 2467b25b387fSDaniel P. Berrange out: 2468b25b387fSDaniel P. Berrange QDECREF(encryptopts); 2469b25b387fSDaniel P. Berrange qcrypto_block_free(crypto); 2470b25b387fSDaniel P. Berrange qapi_free_QCryptoBlockCreateOptions(cryptoopts); 2471b25b387fSDaniel P. Berrange return ret; 2472b25b387fSDaniel P. Berrange } 2473b25b387fSDaniel P. Berrange 2474b25b387fSDaniel P. Berrange 24757bc45dc1SMax Reitz /** 24767bc45dc1SMax Reitz * Preallocates metadata structures for data clusters between @offset (in the 24777bc45dc1SMax Reitz * guest disk) and @new_length (which is thus generally the new guest disk 24787bc45dc1SMax Reitz * size). 24797bc45dc1SMax Reitz * 24807bc45dc1SMax Reitz * Returns: 0 on success, -errno on failure. 24817bc45dc1SMax Reitz */ 24827bc45dc1SMax Reitz static int preallocate(BlockDriverState *bs, 24837bc45dc1SMax Reitz uint64_t offset, uint64_t new_length) 2484a35e1c17SKevin Wolf { 2485652fecd0SMax Reitz BDRVQcow2State *s = bs->opaque; 2486d46a0bb2SKevin Wolf uint64_t bytes; 2487060bee89SKevin Wolf uint64_t host_offset = 0; 2488d46a0bb2SKevin Wolf unsigned int cur_bytes; 2489148da7eaSKevin Wolf int ret; 2490f50f88b9SKevin Wolf QCowL2Meta *meta; 2491a35e1c17SKevin Wolf 2492652fecd0SMax Reitz if (qemu_in_coroutine()) { 2493652fecd0SMax Reitz qemu_co_mutex_lock(&s->lock); 2494652fecd0SMax Reitz } 2495652fecd0SMax Reitz 24967bc45dc1SMax Reitz assert(offset <= new_length); 24977bc45dc1SMax Reitz bytes = new_length - offset; 2498a35e1c17SKevin Wolf 2499d46a0bb2SKevin Wolf while (bytes) { 2500d46a0bb2SKevin Wolf cur_bytes = MIN(bytes, INT_MAX); 2501d46a0bb2SKevin Wolf ret = qcow2_alloc_cluster_offset(bs, offset, &cur_bytes, 2502060bee89SKevin Wolf &host_offset, &meta); 2503148da7eaSKevin Wolf if (ret < 0) { 2504652fecd0SMax Reitz goto done; 2505a35e1c17SKevin Wolf } 2506a35e1c17SKevin Wolf 2507c792707fSStefan Hajnoczi while (meta) { 2508c792707fSStefan Hajnoczi QCowL2Meta *next = meta->next; 2509c792707fSStefan Hajnoczi 2510f50f88b9SKevin Wolf ret = qcow2_alloc_cluster_link_l2(bs, meta); 251119dbcbf7SKevin Wolf if (ret < 0) { 25127c2bbf4aSHu Tao qcow2_free_any_clusters(bs, meta->alloc_offset, 25137c2bbf4aSHu Tao meta->nb_clusters, QCOW2_DISCARD_NEVER); 2514652fecd0SMax Reitz goto done; 2515a35e1c17SKevin Wolf } 2516a35e1c17SKevin Wolf 25177c2bbf4aSHu Tao /* There are no dependent requests, but we need to remove our 25187c2bbf4aSHu Tao * request from the list of in-flight requests */ 25194e95314eSKevin Wolf QLIST_REMOVE(meta, next_in_flight); 2520c792707fSStefan Hajnoczi 2521c792707fSStefan Hajnoczi g_free(meta); 2522c792707fSStefan Hajnoczi meta = next; 2523f50f88b9SKevin Wolf } 2524f214978aSKevin Wolf 2525a35e1c17SKevin Wolf /* TODO Preallocate data if requested */ 2526a35e1c17SKevin Wolf 2527d46a0bb2SKevin Wolf bytes -= cur_bytes; 2528d46a0bb2SKevin Wolf offset += cur_bytes; 2529a35e1c17SKevin Wolf } 2530a35e1c17SKevin Wolf 2531a35e1c17SKevin Wolf /* 2532a35e1c17SKevin Wolf * It is expected that the image file is large enough to actually contain 2533a35e1c17SKevin Wolf * all of the allocated clusters (otherwise we get failing reads after 2534a35e1c17SKevin Wolf * EOF). Extend the image to the last allocated sector. 2535a35e1c17SKevin Wolf */ 2536060bee89SKevin Wolf if (host_offset != 0) { 2537d46a0bb2SKevin Wolf uint8_t data = 0; 2538d9ca2ea2SKevin Wolf ret = bdrv_pwrite(bs->file, (host_offset + cur_bytes) - 1, 2539d46a0bb2SKevin Wolf &data, 1); 254019dbcbf7SKevin Wolf if (ret < 0) { 2541652fecd0SMax Reitz goto done; 254219dbcbf7SKevin Wolf } 2543a35e1c17SKevin Wolf } 2544a35e1c17SKevin Wolf 2545652fecd0SMax Reitz ret = 0; 2546652fecd0SMax Reitz 2547652fecd0SMax Reitz done: 2548652fecd0SMax Reitz if (qemu_in_coroutine()) { 2549652fecd0SMax Reitz qemu_co_mutex_unlock(&s->lock); 2550652fecd0SMax Reitz } 2551652fecd0SMax Reitz return ret; 2552a35e1c17SKevin Wolf } 2553a35e1c17SKevin Wolf 25547c5bcc42SStefan Hajnoczi /* qcow2_refcount_metadata_size: 25557c5bcc42SStefan Hajnoczi * @clusters: number of clusters to refcount (including data and L1/L2 tables) 25567c5bcc42SStefan Hajnoczi * @cluster_size: size of a cluster, in bytes 25577c5bcc42SStefan Hajnoczi * @refcount_order: refcount bits power-of-2 exponent 255812cc30a8SMax Reitz * @generous_increase: allow for the refcount table to be 1.5x as large as it 255912cc30a8SMax Reitz * needs to be 25607c5bcc42SStefan Hajnoczi * 25617c5bcc42SStefan Hajnoczi * Returns: Number of bytes required for refcount blocks and table metadata. 25627c5bcc42SStefan Hajnoczi */ 256312cc30a8SMax Reitz int64_t qcow2_refcount_metadata_size(int64_t clusters, size_t cluster_size, 256412cc30a8SMax Reitz int refcount_order, bool generous_increase, 256512cc30a8SMax Reitz uint64_t *refblock_count) 25667c5bcc42SStefan Hajnoczi { 25677c5bcc42SStefan Hajnoczi /* 25687c5bcc42SStefan Hajnoczi * Every host cluster is reference-counted, including metadata (even 25697c5bcc42SStefan Hajnoczi * refcount metadata is recursively included). 25707c5bcc42SStefan Hajnoczi * 25717c5bcc42SStefan Hajnoczi * An accurate formula for the size of refcount metadata size is difficult 25727c5bcc42SStefan Hajnoczi * to derive. An easier method of calculation is finding the fixed point 25737c5bcc42SStefan Hajnoczi * where no further refcount blocks or table clusters are required to 25747c5bcc42SStefan Hajnoczi * reference count every cluster. 25757c5bcc42SStefan Hajnoczi */ 25767c5bcc42SStefan Hajnoczi int64_t blocks_per_table_cluster = cluster_size / sizeof(uint64_t); 25777c5bcc42SStefan Hajnoczi int64_t refcounts_per_block = cluster_size * 8 / (1 << refcount_order); 25787c5bcc42SStefan Hajnoczi int64_t table = 0; /* number of refcount table clusters */ 25797c5bcc42SStefan Hajnoczi int64_t blocks = 0; /* number of refcount block clusters */ 25807c5bcc42SStefan Hajnoczi int64_t last; 25817c5bcc42SStefan Hajnoczi int64_t n = 0; 25827c5bcc42SStefan Hajnoczi 25837c5bcc42SStefan Hajnoczi do { 25847c5bcc42SStefan Hajnoczi last = n; 25857c5bcc42SStefan Hajnoczi blocks = DIV_ROUND_UP(clusters + table + blocks, refcounts_per_block); 25867c5bcc42SStefan Hajnoczi table = DIV_ROUND_UP(blocks, blocks_per_table_cluster); 25877c5bcc42SStefan Hajnoczi n = clusters + blocks + table; 258812cc30a8SMax Reitz 258912cc30a8SMax Reitz if (n == last && generous_increase) { 259012cc30a8SMax Reitz clusters += DIV_ROUND_UP(table, 2); 259112cc30a8SMax Reitz n = 0; /* force another loop */ 259212cc30a8SMax Reitz generous_increase = false; 259312cc30a8SMax Reitz } 25947c5bcc42SStefan Hajnoczi } while (n != last); 25957c5bcc42SStefan Hajnoczi 259612cc30a8SMax Reitz if (refblock_count) { 259712cc30a8SMax Reitz *refblock_count = blocks; 259812cc30a8SMax Reitz } 259912cc30a8SMax Reitz 26007c5bcc42SStefan Hajnoczi return (blocks + table) * cluster_size; 26017c5bcc42SStefan Hajnoczi } 26027c5bcc42SStefan Hajnoczi 260395c67e3bSStefan Hajnoczi /** 260495c67e3bSStefan Hajnoczi * qcow2_calc_prealloc_size: 260595c67e3bSStefan Hajnoczi * @total_size: virtual disk size in bytes 260695c67e3bSStefan Hajnoczi * @cluster_size: cluster size in bytes 260795c67e3bSStefan Hajnoczi * @refcount_order: refcount bits power-of-2 exponent 2608a9420734SKevin Wolf * 260995c67e3bSStefan Hajnoczi * Returns: Total number of bytes required for the fully allocated image 261095c67e3bSStefan Hajnoczi * (including metadata). 2611a9420734SKevin Wolf */ 261295c67e3bSStefan Hajnoczi static int64_t qcow2_calc_prealloc_size(int64_t total_size, 261395c67e3bSStefan Hajnoczi size_t cluster_size, 261495c67e3bSStefan Hajnoczi int refcount_order) 261595c67e3bSStefan Hajnoczi { 26160e4271b7SHu Tao int64_t meta_size = 0; 26177c5bcc42SStefan Hajnoczi uint64_t nl1e, nl2e; 26180e4271b7SHu Tao int64_t aligned_total_size = align_offset(total_size, cluster_size); 26190e4271b7SHu Tao 26200e4271b7SHu Tao /* header: 1 cluster */ 26210e4271b7SHu Tao meta_size += cluster_size; 26220e4271b7SHu Tao 26230e4271b7SHu Tao /* total size of L2 tables */ 26240e4271b7SHu Tao nl2e = aligned_total_size / cluster_size; 26250e4271b7SHu Tao nl2e = align_offset(nl2e, cluster_size / sizeof(uint64_t)); 26260e4271b7SHu Tao meta_size += nl2e * sizeof(uint64_t); 26270e4271b7SHu Tao 26280e4271b7SHu Tao /* total size of L1 tables */ 26290e4271b7SHu Tao nl1e = nl2e * sizeof(uint64_t) / cluster_size; 26300e4271b7SHu Tao nl1e = align_offset(nl1e, cluster_size / sizeof(uint64_t)); 26310e4271b7SHu Tao meta_size += nl1e * sizeof(uint64_t); 26320e4271b7SHu Tao 26337c5bcc42SStefan Hajnoczi /* total size of refcount table and blocks */ 26347c5bcc42SStefan Hajnoczi meta_size += qcow2_refcount_metadata_size( 26357c5bcc42SStefan Hajnoczi (meta_size + aligned_total_size) / cluster_size, 263612cc30a8SMax Reitz cluster_size, refcount_order, false, NULL); 26370e4271b7SHu Tao 263895c67e3bSStefan Hajnoczi return meta_size + aligned_total_size; 263995c67e3bSStefan Hajnoczi } 264095c67e3bSStefan Hajnoczi 26410eb4a8c1SStefan Hajnoczi static size_t qcow2_opt_get_cluster_size_del(QemuOpts *opts, Error **errp) 264295c67e3bSStefan Hajnoczi { 26430eb4a8c1SStefan Hajnoczi size_t cluster_size; 264495c67e3bSStefan Hajnoczi int cluster_bits; 264595c67e3bSStefan Hajnoczi 26460eb4a8c1SStefan Hajnoczi cluster_size = qemu_opt_get_size_del(opts, BLOCK_OPT_CLUSTER_SIZE, 26470eb4a8c1SStefan Hajnoczi DEFAULT_CLUSTER_SIZE); 264895c67e3bSStefan Hajnoczi cluster_bits = ctz32(cluster_size); 264995c67e3bSStefan Hajnoczi if (cluster_bits < MIN_CLUSTER_BITS || cluster_bits > MAX_CLUSTER_BITS || 265095c67e3bSStefan Hajnoczi (1 << cluster_bits) != cluster_size) 265195c67e3bSStefan Hajnoczi { 265295c67e3bSStefan Hajnoczi error_setg(errp, "Cluster size must be a power of two between %d and " 265395c67e3bSStefan Hajnoczi "%dk", 1 << MIN_CLUSTER_BITS, 1 << (MAX_CLUSTER_BITS - 10)); 26540eb4a8c1SStefan Hajnoczi return 0; 265595c67e3bSStefan Hajnoczi } 26560eb4a8c1SStefan Hajnoczi return cluster_size; 26570eb4a8c1SStefan Hajnoczi } 26580eb4a8c1SStefan Hajnoczi 26590eb4a8c1SStefan Hajnoczi static int qcow2_opt_get_version_del(QemuOpts *opts, Error **errp) 26600eb4a8c1SStefan Hajnoczi { 26610eb4a8c1SStefan Hajnoczi char *buf; 26620eb4a8c1SStefan Hajnoczi int ret; 26630eb4a8c1SStefan Hajnoczi 26640eb4a8c1SStefan Hajnoczi buf = qemu_opt_get_del(opts, BLOCK_OPT_COMPAT_LEVEL); 26650eb4a8c1SStefan Hajnoczi if (!buf) { 26660eb4a8c1SStefan Hajnoczi ret = 3; /* default */ 26670eb4a8c1SStefan Hajnoczi } else if (!strcmp(buf, "0.10")) { 26680eb4a8c1SStefan Hajnoczi ret = 2; 26690eb4a8c1SStefan Hajnoczi } else if (!strcmp(buf, "1.1")) { 26700eb4a8c1SStefan Hajnoczi ret = 3; 26710eb4a8c1SStefan Hajnoczi } else { 26720eb4a8c1SStefan Hajnoczi error_setg(errp, "Invalid compatibility level: '%s'", buf); 26730eb4a8c1SStefan Hajnoczi ret = -EINVAL; 26740eb4a8c1SStefan Hajnoczi } 26750eb4a8c1SStefan Hajnoczi g_free(buf); 26760eb4a8c1SStefan Hajnoczi return ret; 26770eb4a8c1SStefan Hajnoczi } 26780eb4a8c1SStefan Hajnoczi 26790eb4a8c1SStefan Hajnoczi static uint64_t qcow2_opt_get_refcount_bits_del(QemuOpts *opts, int version, 26800eb4a8c1SStefan Hajnoczi Error **errp) 26810eb4a8c1SStefan Hajnoczi { 26820eb4a8c1SStefan Hajnoczi uint64_t refcount_bits; 26830eb4a8c1SStefan Hajnoczi 26840eb4a8c1SStefan Hajnoczi refcount_bits = qemu_opt_get_number_del(opts, BLOCK_OPT_REFCOUNT_BITS, 16); 26850eb4a8c1SStefan Hajnoczi if (refcount_bits > 64 || !is_power_of_2(refcount_bits)) { 26860eb4a8c1SStefan Hajnoczi error_setg(errp, "Refcount width must be a power of two and may not " 26870eb4a8c1SStefan Hajnoczi "exceed 64 bits"); 26880eb4a8c1SStefan Hajnoczi return 0; 26890eb4a8c1SStefan Hajnoczi } 26900eb4a8c1SStefan Hajnoczi 26910eb4a8c1SStefan Hajnoczi if (version < 3 && refcount_bits != 16) { 26920eb4a8c1SStefan Hajnoczi error_setg(errp, "Different refcount widths than 16 bits require " 26930eb4a8c1SStefan Hajnoczi "compatibility level 1.1 or above (use compat=1.1 or " 26940eb4a8c1SStefan Hajnoczi "greater)"); 26950eb4a8c1SStefan Hajnoczi return 0; 26960eb4a8c1SStefan Hajnoczi } 26970eb4a8c1SStefan Hajnoczi 26980eb4a8c1SStefan Hajnoczi return refcount_bits; 26990eb4a8c1SStefan Hajnoczi } 27000eb4a8c1SStefan Hajnoczi 27010eb4a8c1SStefan Hajnoczi static int qcow2_create2(const char *filename, int64_t total_size, 27020eb4a8c1SStefan Hajnoczi const char *backing_file, const char *backing_format, 27030eb4a8c1SStefan Hajnoczi int flags, size_t cluster_size, PreallocMode prealloc, 27040eb4a8c1SStefan Hajnoczi QemuOpts *opts, int version, int refcount_order, 27050eb4a8c1SStefan Hajnoczi const char *encryptfmt, Error **errp) 27060eb4a8c1SStefan Hajnoczi { 27070eb4a8c1SStefan Hajnoczi QDict *options; 270895c67e3bSStefan Hajnoczi 270995c67e3bSStefan Hajnoczi /* 271095c67e3bSStefan Hajnoczi * Open the image file and write a minimal qcow2 header. 271195c67e3bSStefan Hajnoczi * 271295c67e3bSStefan Hajnoczi * We keep things simple and start with a zero-sized image. We also 271395c67e3bSStefan Hajnoczi * do without refcount blocks or a L1 table for now. We'll fix the 271495c67e3bSStefan Hajnoczi * inconsistency later. 271595c67e3bSStefan Hajnoczi * 271695c67e3bSStefan Hajnoczi * We do need a refcount table because growing the refcount table means 271795c67e3bSStefan Hajnoczi * allocating two new refcount blocks - the seconds of which would be at 271895c67e3bSStefan Hajnoczi * 2 GB for 64k clusters, and we don't want to have a 2 GB initial file 271995c67e3bSStefan Hajnoczi * size for any qcow2 image. 272095c67e3bSStefan Hajnoczi */ 272195c67e3bSStefan Hajnoczi BlockBackend *blk; 272295c67e3bSStefan Hajnoczi QCowHeader *header; 272395c67e3bSStefan Hajnoczi uint64_t* refcount_table; 272495c67e3bSStefan Hajnoczi Error *local_err = NULL; 272595c67e3bSStefan Hajnoczi int ret; 272695c67e3bSStefan Hajnoczi 272795c67e3bSStefan Hajnoczi if (prealloc == PREALLOC_MODE_FULL || prealloc == PREALLOC_MODE_FALLOC) { 272895c67e3bSStefan Hajnoczi int64_t prealloc_size = 272995c67e3bSStefan Hajnoczi qcow2_calc_prealloc_size(total_size, cluster_size, refcount_order); 273095c67e3bSStefan Hajnoczi qemu_opt_set_number(opts, BLOCK_OPT_SIZE, prealloc_size, &error_abort); 2731f43e47dbSMarkus Armbruster qemu_opt_set(opts, BLOCK_OPT_PREALLOC, PreallocMode_lookup[prealloc], 2732f43e47dbSMarkus Armbruster &error_abort); 27330e4271b7SHu Tao } 27340e4271b7SHu Tao 2735c282e1fdSChunyan Liu ret = bdrv_create_file(filename, opts, &local_err); 2736a9420734SKevin Wolf if (ret < 0) { 27373ef6c40aSMax Reitz error_propagate(errp, local_err); 2738a9420734SKevin Wolf return ret; 2739a9420734SKevin Wolf } 2740a9420734SKevin Wolf 2741efaa7c4eSMax Reitz blk = blk_new_open(filename, NULL, NULL, 274255880601SKevin Wolf BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, 274355880601SKevin Wolf &local_err); 274423588797SKevin Wolf if (blk == NULL) { 27453ef6c40aSMax Reitz error_propagate(errp, local_err); 274623588797SKevin Wolf return -EIO; 2747a9420734SKevin Wolf } 2748a9420734SKevin Wolf 274923588797SKevin Wolf blk_set_allow_write_beyond_eof(blk, true); 275023588797SKevin Wolf 2751a9420734SKevin Wolf /* Write the header */ 2752f8413b3cSKevin Wolf QEMU_BUILD_BUG_ON((1 << MIN_CLUSTER_BITS) < sizeof(*header)); 2753f8413b3cSKevin Wolf header = g_malloc0(cluster_size); 2754f8413b3cSKevin Wolf *header = (QCowHeader) { 2755f8413b3cSKevin Wolf .magic = cpu_to_be32(QCOW_MAGIC), 2756f8413b3cSKevin Wolf .version = cpu_to_be32(version), 27570eb4a8c1SStefan Hajnoczi .cluster_bits = cpu_to_be32(ctz32(cluster_size)), 2758f8413b3cSKevin Wolf .size = cpu_to_be64(0), 2759f8413b3cSKevin Wolf .l1_table_offset = cpu_to_be64(0), 2760f8413b3cSKevin Wolf .l1_size = cpu_to_be32(0), 2761f8413b3cSKevin Wolf .refcount_table_offset = cpu_to_be64(cluster_size), 2762f8413b3cSKevin Wolf .refcount_table_clusters = cpu_to_be32(1), 2763bd4b167fSMax Reitz .refcount_order = cpu_to_be32(refcount_order), 2764f8413b3cSKevin Wolf .header_length = cpu_to_be32(sizeof(*header)), 2765f8413b3cSKevin Wolf }; 2766a9420734SKevin Wolf 2767b25b387fSDaniel P. Berrange /* We'll update this to correct value later */ 2768f8413b3cSKevin Wolf header->crypt_method = cpu_to_be32(QCOW_CRYPT_NONE); 2769a9420734SKevin Wolf 2770bfe8043eSStefan Hajnoczi if (flags & BLOCK_FLAG_LAZY_REFCOUNTS) { 2771f8413b3cSKevin Wolf header->compatible_features |= 2772bfe8043eSStefan Hajnoczi cpu_to_be64(QCOW2_COMPAT_LAZY_REFCOUNTS); 2773bfe8043eSStefan Hajnoczi } 2774bfe8043eSStefan Hajnoczi 27758341f00dSEric Blake ret = blk_pwrite(blk, 0, header, cluster_size, 0); 2776f8413b3cSKevin Wolf g_free(header); 2777a9420734SKevin Wolf if (ret < 0) { 27783ef6c40aSMax Reitz error_setg_errno(errp, -ret, "Could not write qcow2 header"); 2779a9420734SKevin Wolf goto out; 2780a9420734SKevin Wolf } 2781a9420734SKevin Wolf 2782b106ad91SKevin Wolf /* Write a refcount table with one refcount block */ 2783b106ad91SKevin Wolf refcount_table = g_malloc0(2 * cluster_size); 2784b106ad91SKevin Wolf refcount_table[0] = cpu_to_be64(2 * cluster_size); 27858341f00dSEric Blake ret = blk_pwrite(blk, cluster_size, refcount_table, 2 * cluster_size, 0); 27867267c094SAnthony Liguori g_free(refcount_table); 2787a9420734SKevin Wolf 2788a9420734SKevin Wolf if (ret < 0) { 27893ef6c40aSMax Reitz error_setg_errno(errp, -ret, "Could not write refcount table"); 2790a9420734SKevin Wolf goto out; 2791a9420734SKevin Wolf } 2792a9420734SKevin Wolf 279323588797SKevin Wolf blk_unref(blk); 279423588797SKevin Wolf blk = NULL; 2795a9420734SKevin Wolf 2796a9420734SKevin Wolf /* 2797a9420734SKevin Wolf * And now open the image and make it consistent first (i.e. increase the 2798a9420734SKevin Wolf * refcount of the cluster that is occupied by the header and the refcount 2799a9420734SKevin Wolf * table) 2800a9420734SKevin Wolf */ 2801e6641719SMax Reitz options = qdict_new(); 280246f5ac20SEric Blake qdict_put_str(options, "driver", "qcow2"); 2803efaa7c4eSMax Reitz blk = blk_new_open(filename, NULL, options, 280455880601SKevin Wolf BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_NO_FLUSH, 280555880601SKevin Wolf &local_err); 280623588797SKevin Wolf if (blk == NULL) { 28073ef6c40aSMax Reitz error_propagate(errp, local_err); 280823588797SKevin Wolf ret = -EIO; 2809a9420734SKevin Wolf goto out; 2810a9420734SKevin Wolf } 2811a9420734SKevin Wolf 281223588797SKevin Wolf ret = qcow2_alloc_clusters(blk_bs(blk), 3 * cluster_size); 2813a9420734SKevin Wolf if (ret < 0) { 28143ef6c40aSMax Reitz error_setg_errno(errp, -ret, "Could not allocate clusters for qcow2 " 28153ef6c40aSMax Reitz "header and refcount table"); 2816a9420734SKevin Wolf goto out; 2817a9420734SKevin Wolf 2818a9420734SKevin Wolf } else if (ret != 0) { 2819a9420734SKevin Wolf error_report("Huh, first cluster in empty image is already in use?"); 2820a9420734SKevin Wolf abort(); 2821a9420734SKevin Wolf } 2822a9420734SKevin Wolf 2823b527c9b3SKevin Wolf /* Create a full header (including things like feature table) */ 282423588797SKevin Wolf ret = qcow2_update_header(blk_bs(blk)); 2825b527c9b3SKevin Wolf if (ret < 0) { 2826b527c9b3SKevin Wolf error_setg_errno(errp, -ret, "Could not update qcow2 header"); 2827b527c9b3SKevin Wolf goto out; 2828b527c9b3SKevin Wolf } 2829b527c9b3SKevin Wolf 2830a9420734SKevin Wolf /* Okay, now that we have a valid image, let's give it the right size */ 28313a691c50SMax Reitz ret = blk_truncate(blk, total_size, PREALLOC_MODE_OFF, errp); 2832a9420734SKevin Wolf if (ret < 0) { 2833ed3d2ec9SMax Reitz error_prepend(errp, "Could not resize image: "); 2834a9420734SKevin Wolf goto out; 2835a9420734SKevin Wolf } 2836a9420734SKevin Wolf 2837a9420734SKevin Wolf /* Want a backing file? There you go.*/ 2838a9420734SKevin Wolf if (backing_file) { 283923588797SKevin Wolf ret = bdrv_change_backing_file(blk_bs(blk), backing_file, backing_format); 2840a9420734SKevin Wolf if (ret < 0) { 28413ef6c40aSMax Reitz error_setg_errno(errp, -ret, "Could not assign backing file '%s' " 28423ef6c40aSMax Reitz "with format '%s'", backing_file, backing_format); 2843a9420734SKevin Wolf goto out; 2844a9420734SKevin Wolf } 2845a9420734SKevin Wolf } 2846a9420734SKevin Wolf 2847b25b387fSDaniel P. Berrange /* Want encryption? There you go. */ 2848b25b387fSDaniel P. Berrange if (encryptfmt) { 2849b25b387fSDaniel P. Berrange ret = qcow2_set_up_encryption(blk_bs(blk), encryptfmt, opts, errp); 2850b25b387fSDaniel P. Berrange if (ret < 0) { 2851b25b387fSDaniel P. Berrange goto out; 2852b25b387fSDaniel P. Berrange } 2853b25b387fSDaniel P. Berrange } 2854b25b387fSDaniel P. Berrange 2855a9420734SKevin Wolf /* And if we're supposed to preallocate metadata, do that now */ 28560e4271b7SHu Tao if (prealloc != PREALLOC_MODE_OFF) { 28577bc45dc1SMax Reitz ret = preallocate(blk_bs(blk), 0, total_size); 2858a9420734SKevin Wolf if (ret < 0) { 28593ef6c40aSMax Reitz error_setg_errno(errp, -ret, "Could not preallocate metadata"); 2860a9420734SKevin Wolf goto out; 2861a9420734SKevin Wolf } 2862a9420734SKevin Wolf } 2863a9420734SKevin Wolf 286423588797SKevin Wolf blk_unref(blk); 286523588797SKevin Wolf blk = NULL; 2866ba2ab2f2SMax Reitz 2867b25b387fSDaniel P. Berrange /* Reopen the image without BDRV_O_NO_FLUSH to flush it before returning. 2868b25b387fSDaniel P. Berrange * Using BDRV_O_NO_IO, since encryption is now setup we don't want to 2869b25b387fSDaniel P. Berrange * have to setup decryption context. We're not doing any I/O on the top 2870b25b387fSDaniel P. Berrange * level BlockDriverState, only lower layers, where BDRV_O_NO_IO does 2871b25b387fSDaniel P. Berrange * not have effect. 2872b25b387fSDaniel P. Berrange */ 2873e6641719SMax Reitz options = qdict_new(); 287446f5ac20SEric Blake qdict_put_str(options, "driver", "qcow2"); 2875efaa7c4eSMax Reitz blk = blk_new_open(filename, NULL, options, 2876b25b387fSDaniel P. Berrange BDRV_O_RDWR | BDRV_O_NO_BACKING | BDRV_O_NO_IO, 2877b25b387fSDaniel P. Berrange &local_err); 287823588797SKevin Wolf if (blk == NULL) { 2879ba2ab2f2SMax Reitz error_propagate(errp, local_err); 288023588797SKevin Wolf ret = -EIO; 2881ba2ab2f2SMax Reitz goto out; 2882ba2ab2f2SMax Reitz } 2883ba2ab2f2SMax Reitz 2884a9420734SKevin Wolf ret = 0; 2885a9420734SKevin Wolf out: 288623588797SKevin Wolf if (blk) { 288723588797SKevin Wolf blk_unref(blk); 2888f67503e5SMax Reitz } 2889a9420734SKevin Wolf return ret; 2890a9420734SKevin Wolf } 2891de5f3f40SKevin Wolf 28921bd0e2d1SChunyan Liu static int qcow2_create(const char *filename, QemuOpts *opts, Error **errp) 2893de5f3f40SKevin Wolf { 28941bd0e2d1SChunyan Liu char *backing_file = NULL; 28951bd0e2d1SChunyan Liu char *backing_fmt = NULL; 28961bd0e2d1SChunyan Liu char *buf = NULL; 2897180e9526SHu Tao uint64_t size = 0; 2898de5f3f40SKevin Wolf int flags = 0; 289999cce9faSKevin Wolf size_t cluster_size = DEFAULT_CLUSTER_SIZE; 2900ffeaac9bSHu Tao PreallocMode prealloc; 29010eb4a8c1SStefan Hajnoczi int version; 29020eb4a8c1SStefan Hajnoczi uint64_t refcount_bits; 2903bd4b167fSMax Reitz int refcount_order; 29040696ae2cSDaniel P. Berrange char *encryptfmt = NULL; 29053ef6c40aSMax Reitz Error *local_err = NULL; 29063ef6c40aSMax Reitz int ret; 2907de5f3f40SKevin Wolf 2908de5f3f40SKevin Wolf /* Read out options */ 2909180e9526SHu Tao size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0), 2910c2eb918eSHu Tao BDRV_SECTOR_SIZE); 29111bd0e2d1SChunyan Liu backing_file = qemu_opt_get_del(opts, BLOCK_OPT_BACKING_FILE); 29121bd0e2d1SChunyan Liu backing_fmt = qemu_opt_get_del(opts, BLOCK_OPT_BACKING_FMT); 29130cb8d47bSDaniel P. Berrange encryptfmt = qemu_opt_get_del(opts, BLOCK_OPT_ENCRYPT_FORMAT); 29140cb8d47bSDaniel P. Berrange if (encryptfmt) { 29150696ae2cSDaniel P. Berrange if (qemu_opt_get(opts, BLOCK_OPT_ENCRYPT)) { 29160cb8d47bSDaniel P. Berrange error_setg(errp, "Options " BLOCK_OPT_ENCRYPT " and " 29170cb8d47bSDaniel P. Berrange BLOCK_OPT_ENCRYPT_FORMAT " are mutually exclusive"); 29180cb8d47bSDaniel P. Berrange ret = -EINVAL; 29190cb8d47bSDaniel P. Berrange goto finish; 29200cb8d47bSDaniel P. Berrange } 29210cb8d47bSDaniel P. Berrange } else if (qemu_opt_get_bool_del(opts, BLOCK_OPT_ENCRYPT, false)) { 29220696ae2cSDaniel P. Berrange encryptfmt = g_strdup("aes"); 2923de5f3f40SKevin Wolf } 29240eb4a8c1SStefan Hajnoczi cluster_size = qcow2_opt_get_cluster_size_del(opts, &local_err); 29250eb4a8c1SStefan Hajnoczi if (local_err) { 29260eb4a8c1SStefan Hajnoczi error_propagate(errp, local_err); 29270eb4a8c1SStefan Hajnoczi ret = -EINVAL; 29280eb4a8c1SStefan Hajnoczi goto finish; 29290eb4a8c1SStefan Hajnoczi } 29301bd0e2d1SChunyan Liu buf = qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC); 2931ffeaac9bSHu Tao prealloc = qapi_enum_parse(PreallocMode_lookup, buf, 29327fb1cf16SEric Blake PREALLOC_MODE__MAX, PREALLOC_MODE_OFF, 2933ffeaac9bSHu Tao &local_err); 2934ffeaac9bSHu Tao if (local_err) { 2935ffeaac9bSHu Tao error_propagate(errp, local_err); 29361bd0e2d1SChunyan Liu ret = -EINVAL; 29371bd0e2d1SChunyan Liu goto finish; 2938de5f3f40SKevin Wolf } 29390eb4a8c1SStefan Hajnoczi 29400eb4a8c1SStefan Hajnoczi version = qcow2_opt_get_version_del(opts, &local_err); 29410eb4a8c1SStefan Hajnoczi if (local_err) { 29420eb4a8c1SStefan Hajnoczi error_propagate(errp, local_err); 29431bd0e2d1SChunyan Liu ret = -EINVAL; 29441bd0e2d1SChunyan Liu goto finish; 29456744cbabSKevin Wolf } 29461bd0e2d1SChunyan Liu 29471bd0e2d1SChunyan Liu if (qemu_opt_get_bool_del(opts, BLOCK_OPT_LAZY_REFCOUNTS, false)) { 29481bd0e2d1SChunyan Liu flags |= BLOCK_FLAG_LAZY_REFCOUNTS; 2949de5f3f40SKevin Wolf } 2950de5f3f40SKevin Wolf 2951ffeaac9bSHu Tao if (backing_file && prealloc != PREALLOC_MODE_OFF) { 29523ef6c40aSMax Reitz error_setg(errp, "Backing file and preallocation cannot be used at " 29533ef6c40aSMax Reitz "the same time"); 29541bd0e2d1SChunyan Liu ret = -EINVAL; 29551bd0e2d1SChunyan Liu goto finish; 2956de5f3f40SKevin Wolf } 2957de5f3f40SKevin Wolf 2958bfe8043eSStefan Hajnoczi if (version < 3 && (flags & BLOCK_FLAG_LAZY_REFCOUNTS)) { 29593ef6c40aSMax Reitz error_setg(errp, "Lazy refcounts only supported with compatibility " 29603ef6c40aSMax Reitz "level 1.1 and above (use compat=1.1 or greater)"); 29611bd0e2d1SChunyan Liu ret = -EINVAL; 29621bd0e2d1SChunyan Liu goto finish; 2963bfe8043eSStefan Hajnoczi } 2964bfe8043eSStefan Hajnoczi 29650eb4a8c1SStefan Hajnoczi refcount_bits = qcow2_opt_get_refcount_bits_del(opts, version, &local_err); 29660eb4a8c1SStefan Hajnoczi if (local_err) { 29670eb4a8c1SStefan Hajnoczi error_propagate(errp, local_err); 2968bd4b167fSMax Reitz ret = -EINVAL; 2969bd4b167fSMax Reitz goto finish; 2970bd4b167fSMax Reitz } 2971bd4b167fSMax Reitz 2972786a4ea8SStefan Hajnoczi refcount_order = ctz32(refcount_bits); 2973bd4b167fSMax Reitz 2974180e9526SHu Tao ret = qcow2_create2(filename, size, backing_file, backing_fmt, flags, 2975bd4b167fSMax Reitz cluster_size, prealloc, opts, version, refcount_order, 29760cb8d47bSDaniel P. Berrange encryptfmt, &local_err); 29773ef6c40aSMax Reitz error_propagate(errp, local_err); 29781bd0e2d1SChunyan Liu 29791bd0e2d1SChunyan Liu finish: 29801bd0e2d1SChunyan Liu g_free(backing_file); 29811bd0e2d1SChunyan Liu g_free(backing_fmt); 29820696ae2cSDaniel P. Berrange g_free(encryptfmt); 29831bd0e2d1SChunyan Liu g_free(buf); 29843ef6c40aSMax Reitz return ret; 2985de5f3f40SKevin Wolf } 2986de5f3f40SKevin Wolf 29872928abceSDenis V. Lunev 2988ebb718a5SEric Blake static bool is_zero_sectors(BlockDriverState *bs, int64_t start, 2989ebb718a5SEric Blake uint32_t count) 29902928abceSDenis V. Lunev { 29912928abceSDenis V. Lunev int nr; 29922928abceSDenis V. Lunev BlockDriverState *file; 2993ebb718a5SEric Blake int64_t res; 2994ebb718a5SEric Blake 2995fbaa6bb3SEric Blake if (start + count > bs->total_sectors) { 2996fbaa6bb3SEric Blake count = bs->total_sectors - start; 2997fbaa6bb3SEric Blake } 2998fbaa6bb3SEric Blake 2999ebb718a5SEric Blake if (!count) { 3000ebb718a5SEric Blake return true; 30012928abceSDenis V. Lunev } 3002ebb718a5SEric Blake res = bdrv_get_block_status_above(bs, NULL, start, count, 3003ebb718a5SEric Blake &nr, &file); 3004ebb718a5SEric Blake return res >= 0 && (res & BDRV_BLOCK_ZERO) && nr == count; 30052928abceSDenis V. Lunev } 30062928abceSDenis V. Lunev 30075544b59fSEric Blake static coroutine_fn int qcow2_co_pwrite_zeroes(BlockDriverState *bs, 3008f5a5ca79SManos Pitsidianakis int64_t offset, int bytes, BdrvRequestFlags flags) 3009621f0589SKevin Wolf { 3010621f0589SKevin Wolf int ret; 3011ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 3012621f0589SKevin Wolf 30135544b59fSEric Blake uint32_t head = offset % s->cluster_size; 3014f5a5ca79SManos Pitsidianakis uint32_t tail = (offset + bytes) % s->cluster_size; 30152928abceSDenis V. Lunev 3016f5a5ca79SManos Pitsidianakis trace_qcow2_pwrite_zeroes_start_req(qemu_coroutine_self(), offset, bytes); 3017f5a5ca79SManos Pitsidianakis if (offset + bytes == bs->total_sectors * BDRV_SECTOR_SIZE) { 3018fbaa6bb3SEric Blake tail = 0; 3019fbaa6bb3SEric Blake } 30205a64e942SDenis V. Lunev 3021ebb718a5SEric Blake if (head || tail) { 30225544b59fSEric Blake int64_t cl_start = (offset - head) >> BDRV_SECTOR_BITS; 3023ebb718a5SEric Blake uint64_t off; 3024ecfe1863SKevin Wolf unsigned int nr; 30252928abceSDenis V. Lunev 3026f5a5ca79SManos Pitsidianakis assert(head + bytes <= s->cluster_size); 30272928abceSDenis V. Lunev 3028ebb718a5SEric Blake /* check whether remainder of cluster already reads as zero */ 30295544b59fSEric Blake if (!(is_zero_sectors(bs, cl_start, 30305544b59fSEric Blake DIV_ROUND_UP(head, BDRV_SECTOR_SIZE)) && 3031f5a5ca79SManos Pitsidianakis is_zero_sectors(bs, (offset + bytes) >> BDRV_SECTOR_BITS, 30325544b59fSEric Blake DIV_ROUND_UP(-tail & (s->cluster_size - 1), 30335544b59fSEric Blake BDRV_SECTOR_SIZE)))) { 3034621f0589SKevin Wolf return -ENOTSUP; 3035621f0589SKevin Wolf } 3036621f0589SKevin Wolf 3037621f0589SKevin Wolf qemu_co_mutex_lock(&s->lock); 30382928abceSDenis V. Lunev /* We can have new write after previous check */ 30395544b59fSEric Blake offset = cl_start << BDRV_SECTOR_BITS; 3040f5a5ca79SManos Pitsidianakis bytes = s->cluster_size; 3041ecfe1863SKevin Wolf nr = s->cluster_size; 30425544b59fSEric Blake ret = qcow2_get_cluster_offset(bs, offset, &nr, &off); 3043fdfab37dSEric Blake if (ret != QCOW2_CLUSTER_UNALLOCATED && 3044fdfab37dSEric Blake ret != QCOW2_CLUSTER_ZERO_PLAIN && 3045fdfab37dSEric Blake ret != QCOW2_CLUSTER_ZERO_ALLOC) { 30462928abceSDenis V. Lunev qemu_co_mutex_unlock(&s->lock); 30472928abceSDenis V. Lunev return -ENOTSUP; 30482928abceSDenis V. Lunev } 30492928abceSDenis V. Lunev } else { 30502928abceSDenis V. Lunev qemu_co_mutex_lock(&s->lock); 30512928abceSDenis V. Lunev } 30522928abceSDenis V. Lunev 3053f5a5ca79SManos Pitsidianakis trace_qcow2_pwrite_zeroes(qemu_coroutine_self(), offset, bytes); 30545a64e942SDenis V. Lunev 30552928abceSDenis V. Lunev /* Whatever is left can use real zero clusters */ 3056f5a5ca79SManos Pitsidianakis ret = qcow2_cluster_zeroize(bs, offset, bytes, flags); 3057621f0589SKevin Wolf qemu_co_mutex_unlock(&s->lock); 3058621f0589SKevin Wolf 3059621f0589SKevin Wolf return ret; 3060621f0589SKevin Wolf } 3061621f0589SKevin Wolf 306282e8a788SEric Blake static coroutine_fn int qcow2_co_pdiscard(BlockDriverState *bs, 3063f5a5ca79SManos Pitsidianakis int64_t offset, int bytes) 30645ea929e3SKevin Wolf { 30656db39ae2SPaolo Bonzini int ret; 3066ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 30676db39ae2SPaolo Bonzini 3068f5a5ca79SManos Pitsidianakis if (!QEMU_IS_ALIGNED(offset | bytes, s->cluster_size)) { 3069f5a5ca79SManos Pitsidianakis assert(bytes < s->cluster_size); 3070048c5fd1SEric Blake /* Ignore partial clusters, except for the special case of the 3071048c5fd1SEric Blake * complete partial cluster at the end of an unaligned file */ 3072048c5fd1SEric Blake if (!QEMU_IS_ALIGNED(offset, s->cluster_size) || 3073f5a5ca79SManos Pitsidianakis offset + bytes != bs->total_sectors * BDRV_SECTOR_SIZE) { 307449228d1eSEric Blake return -ENOTSUP; 307549228d1eSEric Blake } 3076048c5fd1SEric Blake } 307749228d1eSEric Blake 30786db39ae2SPaolo Bonzini qemu_co_mutex_lock(&s->lock); 3079f5a5ca79SManos Pitsidianakis ret = qcow2_cluster_discard(bs, offset, bytes, QCOW2_DISCARD_REQUEST, 3080d2cb36afSEric Blake false); 30816db39ae2SPaolo Bonzini qemu_co_mutex_unlock(&s->lock); 30826db39ae2SPaolo Bonzini return ret; 30835ea929e3SKevin Wolf } 30845ea929e3SKevin Wolf 30858243ccb7SMax Reitz static int qcow2_truncate(BlockDriverState *bs, int64_t offset, 30868243ccb7SMax Reitz PreallocMode prealloc, Error **errp) 3087419b19d9SStefan Hajnoczi { 3088ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 308995b98f34SMax Reitz uint64_t old_length; 30902cf7cfa1SKevin Wolf int64_t new_l1_size; 30912cf7cfa1SKevin Wolf int ret; 3092419b19d9SStefan Hajnoczi 3093772d1f97SMax Reitz if (prealloc != PREALLOC_MODE_OFF && prealloc != PREALLOC_MODE_METADATA && 3094772d1f97SMax Reitz prealloc != PREALLOC_MODE_FALLOC && prealloc != PREALLOC_MODE_FULL) 3095772d1f97SMax Reitz { 30968243ccb7SMax Reitz error_setg(errp, "Unsupported preallocation mode '%s'", 30978243ccb7SMax Reitz PreallocMode_lookup[prealloc]); 30988243ccb7SMax Reitz return -ENOTSUP; 30998243ccb7SMax Reitz } 31008243ccb7SMax Reitz 3101419b19d9SStefan Hajnoczi if (offset & 511) { 31024bff28b8SMax Reitz error_setg(errp, "The new size must be a multiple of 512"); 3103419b19d9SStefan Hajnoczi return -EINVAL; 3104419b19d9SStefan Hajnoczi } 3105419b19d9SStefan Hajnoczi 3106419b19d9SStefan Hajnoczi /* cannot proceed if image has snapshots */ 3107419b19d9SStefan Hajnoczi if (s->nb_snapshots) { 31084bff28b8SMax Reitz error_setg(errp, "Can't resize an image which has snapshots"); 3109419b19d9SStefan Hajnoczi return -ENOTSUP; 3110419b19d9SStefan Hajnoczi } 3111419b19d9SStefan Hajnoczi 311288ddffaeSVladimir Sementsov-Ogievskiy /* cannot proceed if image has bitmaps */ 311388ddffaeSVladimir Sementsov-Ogievskiy if (s->nb_bitmaps) { 311488ddffaeSVladimir Sementsov-Ogievskiy /* TODO: resize bitmaps in the image */ 311588ddffaeSVladimir Sementsov-Ogievskiy error_setg(errp, "Can't resize an image which has bitmaps"); 311688ddffaeSVladimir Sementsov-Ogievskiy return -ENOTSUP; 311788ddffaeSVladimir Sementsov-Ogievskiy } 311888ddffaeSVladimir Sementsov-Ogievskiy 311995b98f34SMax Reitz old_length = bs->total_sectors * 512; 312095b98f34SMax Reitz 3121419b19d9SStefan Hajnoczi /* shrinking is currently not supported */ 312295b98f34SMax Reitz if (offset < old_length) { 31234bff28b8SMax Reitz error_setg(errp, "qcow2 doesn't support shrinking images yet"); 3124419b19d9SStefan Hajnoczi return -ENOTSUP; 3125419b19d9SStefan Hajnoczi } 3126419b19d9SStefan Hajnoczi 3127419b19d9SStefan Hajnoczi new_l1_size = size_to_l1(s, offset); 312872893756SStefan Hajnoczi ret = qcow2_grow_l1_table(bs, new_l1_size, true); 3129419b19d9SStefan Hajnoczi if (ret < 0) { 3130f59adb32SMax Reitz error_setg_errno(errp, -ret, "Failed to grow the L1 table"); 3131419b19d9SStefan Hajnoczi return ret; 3132419b19d9SStefan Hajnoczi } 3133419b19d9SStefan Hajnoczi 313495b98f34SMax Reitz switch (prealloc) { 313595b98f34SMax Reitz case PREALLOC_MODE_OFF: 313695b98f34SMax Reitz break; 313795b98f34SMax Reitz 313895b98f34SMax Reitz case PREALLOC_MODE_METADATA: 313995b98f34SMax Reitz ret = preallocate(bs, old_length, offset); 314095b98f34SMax Reitz if (ret < 0) { 314195b98f34SMax Reitz error_setg_errno(errp, -ret, "Preallocation failed"); 314295b98f34SMax Reitz return ret; 314395b98f34SMax Reitz } 314495b98f34SMax Reitz break; 314595b98f34SMax Reitz 3146772d1f97SMax Reitz case PREALLOC_MODE_FALLOC: 3147772d1f97SMax Reitz case PREALLOC_MODE_FULL: 3148772d1f97SMax Reitz { 3149772d1f97SMax Reitz int64_t allocation_start, host_offset, guest_offset; 3150772d1f97SMax Reitz int64_t clusters_allocated; 3151772d1f97SMax Reitz int64_t old_file_size, new_file_size; 3152772d1f97SMax Reitz uint64_t nb_new_data_clusters, nb_new_l2_tables; 3153772d1f97SMax Reitz 3154772d1f97SMax Reitz old_file_size = bdrv_getlength(bs->file->bs); 3155772d1f97SMax Reitz if (old_file_size < 0) { 3156772d1f97SMax Reitz error_setg_errno(errp, -old_file_size, 3157772d1f97SMax Reitz "Failed to inquire current file length"); 3158772d1f97SMax Reitz return ret; 3159772d1f97SMax Reitz } 3160772d1f97SMax Reitz 3161772d1f97SMax Reitz nb_new_data_clusters = DIV_ROUND_UP(offset - old_length, 3162772d1f97SMax Reitz s->cluster_size); 3163772d1f97SMax Reitz 3164772d1f97SMax Reitz /* This is an overestimation; we will not actually allocate space for 3165772d1f97SMax Reitz * these in the file but just make sure the new refcount structures are 3166772d1f97SMax Reitz * able to cover them so we will not have to allocate new refblocks 3167772d1f97SMax Reitz * while entering the data blocks in the potentially new L2 tables. 3168772d1f97SMax Reitz * (We do not actually care where the L2 tables are placed. Maybe they 3169772d1f97SMax Reitz * are already allocated or they can be placed somewhere before 3170772d1f97SMax Reitz * @old_file_size. It does not matter because they will be fully 3171772d1f97SMax Reitz * allocated automatically, so they do not need to be covered by the 3172772d1f97SMax Reitz * preallocation. All that matters is that we will not have to allocate 3173772d1f97SMax Reitz * new refcount structures for them.) */ 3174772d1f97SMax Reitz nb_new_l2_tables = DIV_ROUND_UP(nb_new_data_clusters, 3175772d1f97SMax Reitz s->cluster_size / sizeof(uint64_t)); 3176772d1f97SMax Reitz /* The cluster range may not be aligned to L2 boundaries, so add one L2 3177772d1f97SMax Reitz * table for a potential head/tail */ 3178772d1f97SMax Reitz nb_new_l2_tables++; 3179772d1f97SMax Reitz 3180772d1f97SMax Reitz allocation_start = qcow2_refcount_area(bs, old_file_size, 3181772d1f97SMax Reitz nb_new_data_clusters + 3182772d1f97SMax Reitz nb_new_l2_tables, 3183772d1f97SMax Reitz true, 0, 0); 3184772d1f97SMax Reitz if (allocation_start < 0) { 3185772d1f97SMax Reitz error_setg_errno(errp, -allocation_start, 3186772d1f97SMax Reitz "Failed to resize refcount structures"); 3187772d1f97SMax Reitz return -allocation_start; 3188772d1f97SMax Reitz } 3189772d1f97SMax Reitz 3190772d1f97SMax Reitz clusters_allocated = qcow2_alloc_clusters_at(bs, allocation_start, 3191772d1f97SMax Reitz nb_new_data_clusters); 3192772d1f97SMax Reitz if (clusters_allocated < 0) { 3193772d1f97SMax Reitz error_setg_errno(errp, -clusters_allocated, 3194772d1f97SMax Reitz "Failed to allocate data clusters"); 3195772d1f97SMax Reitz return -clusters_allocated; 3196772d1f97SMax Reitz } 3197772d1f97SMax Reitz 3198772d1f97SMax Reitz assert(clusters_allocated == nb_new_data_clusters); 3199772d1f97SMax Reitz 3200772d1f97SMax Reitz /* Allocate the data area */ 3201772d1f97SMax Reitz new_file_size = allocation_start + 3202772d1f97SMax Reitz nb_new_data_clusters * s->cluster_size; 3203772d1f97SMax Reitz ret = bdrv_truncate(bs->file, new_file_size, prealloc, errp); 3204772d1f97SMax Reitz if (ret < 0) { 3205772d1f97SMax Reitz error_prepend(errp, "Failed to resize underlying file: "); 3206772d1f97SMax Reitz qcow2_free_clusters(bs, allocation_start, 3207772d1f97SMax Reitz nb_new_data_clusters * s->cluster_size, 3208772d1f97SMax Reitz QCOW2_DISCARD_OTHER); 3209772d1f97SMax Reitz return ret; 3210772d1f97SMax Reitz } 3211772d1f97SMax Reitz 3212772d1f97SMax Reitz /* Create the necessary L2 entries */ 3213772d1f97SMax Reitz host_offset = allocation_start; 3214772d1f97SMax Reitz guest_offset = old_length; 3215772d1f97SMax Reitz while (nb_new_data_clusters) { 3216772d1f97SMax Reitz int64_t guest_cluster = guest_offset >> s->cluster_bits; 3217772d1f97SMax Reitz int64_t nb_clusters = MIN(nb_new_data_clusters, 3218772d1f97SMax Reitz s->l2_size - guest_cluster % s->l2_size); 3219772d1f97SMax Reitz QCowL2Meta allocation = { 3220772d1f97SMax Reitz .offset = guest_offset, 3221772d1f97SMax Reitz .alloc_offset = host_offset, 3222772d1f97SMax Reitz .nb_clusters = nb_clusters, 3223772d1f97SMax Reitz }; 3224772d1f97SMax Reitz qemu_co_queue_init(&allocation.dependent_requests); 3225772d1f97SMax Reitz 3226772d1f97SMax Reitz ret = qcow2_alloc_cluster_link_l2(bs, &allocation); 3227772d1f97SMax Reitz if (ret < 0) { 3228772d1f97SMax Reitz error_setg_errno(errp, -ret, "Failed to update L2 tables"); 3229772d1f97SMax Reitz qcow2_free_clusters(bs, host_offset, 3230772d1f97SMax Reitz nb_new_data_clusters * s->cluster_size, 3231772d1f97SMax Reitz QCOW2_DISCARD_OTHER); 3232772d1f97SMax Reitz return ret; 3233772d1f97SMax Reitz } 3234772d1f97SMax Reitz 3235772d1f97SMax Reitz guest_offset += nb_clusters * s->cluster_size; 3236772d1f97SMax Reitz host_offset += nb_clusters * s->cluster_size; 3237772d1f97SMax Reitz nb_new_data_clusters -= nb_clusters; 3238772d1f97SMax Reitz } 3239772d1f97SMax Reitz break; 3240772d1f97SMax Reitz } 3241772d1f97SMax Reitz 324295b98f34SMax Reitz default: 324395b98f34SMax Reitz g_assert_not_reached(); 324495b98f34SMax Reitz } 324595b98f34SMax Reitz 324695b98f34SMax Reitz if (prealloc != PREALLOC_MODE_OFF) { 324795b98f34SMax Reitz /* Flush metadata before actually changing the image size */ 324895b98f34SMax Reitz ret = bdrv_flush(bs); 324995b98f34SMax Reitz if (ret < 0) { 325095b98f34SMax Reitz error_setg_errno(errp, -ret, 325195b98f34SMax Reitz "Failed to flush the preallocated area to disk"); 325295b98f34SMax Reitz return ret; 325395b98f34SMax Reitz } 325495b98f34SMax Reitz } 325595b98f34SMax Reitz 3256419b19d9SStefan Hajnoczi /* write updated header.size */ 3257419b19d9SStefan Hajnoczi offset = cpu_to_be64(offset); 3258d9ca2ea2SKevin Wolf ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, size), 3259419b19d9SStefan Hajnoczi &offset, sizeof(uint64_t)); 3260419b19d9SStefan Hajnoczi if (ret < 0) { 3261f59adb32SMax Reitz error_setg_errno(errp, -ret, "Failed to update the image size"); 3262419b19d9SStefan Hajnoczi return ret; 3263419b19d9SStefan Hajnoczi } 3264419b19d9SStefan Hajnoczi 3265419b19d9SStefan Hajnoczi s->l1_vm_state_index = new_l1_size; 3266419b19d9SStefan Hajnoczi return 0; 3267419b19d9SStefan Hajnoczi } 3268419b19d9SStefan Hajnoczi 326920d97356SBlue Swirl /* XXX: put compressed sectors first, then all the cluster aligned 327020d97356SBlue Swirl tables to avoid losing bytes in alignment */ 3271fcccefc5SPavel Butsykin static coroutine_fn int 3272fcccefc5SPavel Butsykin qcow2_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset, 3273fcccefc5SPavel Butsykin uint64_t bytes, QEMUIOVector *qiov) 327420d97356SBlue Swirl { 3275ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 3276fcccefc5SPavel Butsykin QEMUIOVector hd_qiov; 3277fcccefc5SPavel Butsykin struct iovec iov; 327820d97356SBlue Swirl z_stream strm; 327920d97356SBlue Swirl int ret, out_len; 3280fcccefc5SPavel Butsykin uint8_t *buf, *out_buf; 3281d0d5d0e3SEric Blake int64_t cluster_offset; 328220d97356SBlue Swirl 3283fcccefc5SPavel Butsykin if (bytes == 0) { 328420d97356SBlue Swirl /* align end of file to a sector boundary to ease reading with 328520d97356SBlue Swirl sector based I/Os */ 32869a4f4c31SKevin Wolf cluster_offset = bdrv_getlength(bs->file->bs); 3287d0d5d0e3SEric Blake if (cluster_offset < 0) { 3288d0d5d0e3SEric Blake return cluster_offset; 3289d0d5d0e3SEric Blake } 32907ea37c30SMax Reitz return bdrv_truncate(bs->file, cluster_offset, PREALLOC_MODE_OFF, NULL); 329120d97356SBlue Swirl } 329220d97356SBlue Swirl 3293fcccefc5SPavel Butsykin buf = qemu_blockalign(bs, s->cluster_size); 3294a2c0ca6fSPavel Butsykin if (bytes != s->cluster_size) { 3295a2c0ca6fSPavel Butsykin if (bytes > s->cluster_size || 3296a2c0ca6fSPavel Butsykin offset + bytes != bs->total_sectors << BDRV_SECTOR_BITS) 3297a2c0ca6fSPavel Butsykin { 3298a2c0ca6fSPavel Butsykin qemu_vfree(buf); 3299a2c0ca6fSPavel Butsykin return -EINVAL; 3300a2c0ca6fSPavel Butsykin } 3301a2c0ca6fSPavel Butsykin /* Zero-pad last write if image size is not cluster aligned */ 3302a2c0ca6fSPavel Butsykin memset(buf + bytes, 0, s->cluster_size - bytes); 3303a2c0ca6fSPavel Butsykin } 33048b2bd093SPavel Butsykin qemu_iovec_to_buf(qiov, 0, buf, bytes); 330520d97356SBlue Swirl 3306ebf7bba0SVladimir Sementsov-Ogievskiy out_buf = g_malloc(s->cluster_size); 330720d97356SBlue Swirl 330820d97356SBlue Swirl /* best compression, small window, no zlib header */ 330920d97356SBlue Swirl memset(&strm, 0, sizeof(strm)); 331020d97356SBlue Swirl ret = deflateInit2(&strm, Z_DEFAULT_COMPRESSION, 331120d97356SBlue Swirl Z_DEFLATED, -12, 331220d97356SBlue Swirl 9, Z_DEFAULT_STRATEGY); 331320d97356SBlue Swirl if (ret != 0) { 33148f1efd00SKevin Wolf ret = -EINVAL; 33158f1efd00SKevin Wolf goto fail; 331620d97356SBlue Swirl } 331720d97356SBlue Swirl 331820d97356SBlue Swirl strm.avail_in = s->cluster_size; 331920d97356SBlue Swirl strm.next_in = (uint8_t *)buf; 332020d97356SBlue Swirl strm.avail_out = s->cluster_size; 332120d97356SBlue Swirl strm.next_out = out_buf; 332220d97356SBlue Swirl 332320d97356SBlue Swirl ret = deflate(&strm, Z_FINISH); 332420d97356SBlue Swirl if (ret != Z_STREAM_END && ret != Z_OK) { 332520d97356SBlue Swirl deflateEnd(&strm); 33268f1efd00SKevin Wolf ret = -EINVAL; 33278f1efd00SKevin Wolf goto fail; 332820d97356SBlue Swirl } 332920d97356SBlue Swirl out_len = strm.next_out - out_buf; 333020d97356SBlue Swirl 333120d97356SBlue Swirl deflateEnd(&strm); 333220d97356SBlue Swirl 333320d97356SBlue Swirl if (ret != Z_STREAM_END || out_len >= s->cluster_size) { 333420d97356SBlue Swirl /* could not compress: write normal cluster */ 3335fcccefc5SPavel Butsykin ret = qcow2_co_pwritev(bs, offset, bytes, qiov, 0); 33368f1efd00SKevin Wolf if (ret < 0) { 33378f1efd00SKevin Wolf goto fail; 33388f1efd00SKevin Wolf } 3339fcccefc5SPavel Butsykin goto success; 3340fcccefc5SPavel Butsykin } 3341fcccefc5SPavel Butsykin 3342fcccefc5SPavel Butsykin qemu_co_mutex_lock(&s->lock); 3343fcccefc5SPavel Butsykin cluster_offset = 3344fcccefc5SPavel Butsykin qcow2_alloc_compressed_cluster_offset(bs, offset, out_len); 33458f1efd00SKevin Wolf if (!cluster_offset) { 3346fcccefc5SPavel Butsykin qemu_co_mutex_unlock(&s->lock); 33478f1efd00SKevin Wolf ret = -EIO; 33488f1efd00SKevin Wolf goto fail; 33498f1efd00SKevin Wolf } 335020d97356SBlue Swirl cluster_offset &= s->cluster_offset_mask; 3351cf93980eSMax Reitz 3352231bb267SMax Reitz ret = qcow2_pre_write_overlap_check(bs, 0, cluster_offset, out_len); 3353fcccefc5SPavel Butsykin qemu_co_mutex_unlock(&s->lock); 3354cf93980eSMax Reitz if (ret < 0) { 3355cf93980eSMax Reitz goto fail; 3356cf93980eSMax Reitz } 3357cf93980eSMax Reitz 3358fcccefc5SPavel Butsykin iov = (struct iovec) { 3359fcccefc5SPavel Butsykin .iov_base = out_buf, 3360fcccefc5SPavel Butsykin .iov_len = out_len, 3361fcccefc5SPavel Butsykin }; 3362fcccefc5SPavel Butsykin qemu_iovec_init_external(&hd_qiov, &iov, 1); 3363fcccefc5SPavel Butsykin 336466f82ceeSKevin Wolf BLKDBG_EVENT(bs->file, BLKDBG_WRITE_COMPRESSED); 3365fcccefc5SPavel Butsykin ret = bdrv_co_pwritev(bs->file, cluster_offset, out_len, &hd_qiov, 0); 33668f1efd00SKevin Wolf if (ret < 0) { 33678f1efd00SKevin Wolf goto fail; 336820d97356SBlue Swirl } 3369fcccefc5SPavel Butsykin success: 33708f1efd00SKevin Wolf ret = 0; 33718f1efd00SKevin Wolf fail: 3372fcccefc5SPavel Butsykin qemu_vfree(buf); 33737267c094SAnthony Liguori g_free(out_buf); 33748f1efd00SKevin Wolf return ret; 337520d97356SBlue Swirl } 337620d97356SBlue Swirl 337794054183SMax Reitz static int make_completely_empty(BlockDriverState *bs) 337894054183SMax Reitz { 3379ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 3380ed3d2ec9SMax Reitz Error *local_err = NULL; 338194054183SMax Reitz int ret, l1_clusters; 338294054183SMax Reitz int64_t offset; 338394054183SMax Reitz uint64_t *new_reftable = NULL; 338494054183SMax Reitz uint64_t rt_entry, l1_size2; 338594054183SMax Reitz struct { 338694054183SMax Reitz uint64_t l1_offset; 338794054183SMax Reitz uint64_t reftable_offset; 338894054183SMax Reitz uint32_t reftable_clusters; 338994054183SMax Reitz } QEMU_PACKED l1_ofs_rt_ofs_cls; 339094054183SMax Reitz 339194054183SMax Reitz ret = qcow2_cache_empty(bs, s->l2_table_cache); 339294054183SMax Reitz if (ret < 0) { 339394054183SMax Reitz goto fail; 339494054183SMax Reitz } 339594054183SMax Reitz 339694054183SMax Reitz ret = qcow2_cache_empty(bs, s->refcount_block_cache); 339794054183SMax Reitz if (ret < 0) { 339894054183SMax Reitz goto fail; 339994054183SMax Reitz } 340094054183SMax Reitz 340194054183SMax Reitz /* Refcounts will be broken utterly */ 340294054183SMax Reitz ret = qcow2_mark_dirty(bs); 340394054183SMax Reitz if (ret < 0) { 340494054183SMax Reitz goto fail; 340594054183SMax Reitz } 340694054183SMax Reitz 340794054183SMax Reitz BLKDBG_EVENT(bs->file, BLKDBG_L1_UPDATE); 340894054183SMax Reitz 340994054183SMax Reitz l1_clusters = DIV_ROUND_UP(s->l1_size, s->cluster_size / sizeof(uint64_t)); 341094054183SMax Reitz l1_size2 = (uint64_t)s->l1_size * sizeof(uint64_t); 341194054183SMax Reitz 341294054183SMax Reitz /* After this call, neither the in-memory nor the on-disk refcount 341394054183SMax Reitz * information accurately describe the actual references */ 341494054183SMax Reitz 3415720ff280SKevin Wolf ret = bdrv_pwrite_zeroes(bs->file, s->l1_table_offset, 341674021bc4SEric Blake l1_clusters * s->cluster_size, 0); 341794054183SMax Reitz if (ret < 0) { 341894054183SMax Reitz goto fail_broken_refcounts; 341994054183SMax Reitz } 342094054183SMax Reitz memset(s->l1_table, 0, l1_size2); 342194054183SMax Reitz 342294054183SMax Reitz BLKDBG_EVENT(bs->file, BLKDBG_EMPTY_IMAGE_PREPARE); 342394054183SMax Reitz 342494054183SMax Reitz /* Overwrite enough clusters at the beginning of the sectors to place 342594054183SMax Reitz * the refcount table, a refcount block and the L1 table in; this may 342694054183SMax Reitz * overwrite parts of the existing refcount and L1 table, which is not 342794054183SMax Reitz * an issue because the dirty flag is set, complete data loss is in fact 342894054183SMax Reitz * desired and partial data loss is consequently fine as well */ 3429720ff280SKevin Wolf ret = bdrv_pwrite_zeroes(bs->file, s->cluster_size, 343074021bc4SEric Blake (2 + l1_clusters) * s->cluster_size, 0); 343194054183SMax Reitz /* This call (even if it failed overall) may have overwritten on-disk 343294054183SMax Reitz * refcount structures; in that case, the in-memory refcount information 343394054183SMax Reitz * will probably differ from the on-disk information which makes the BDS 343494054183SMax Reitz * unusable */ 343594054183SMax Reitz if (ret < 0) { 343694054183SMax Reitz goto fail_broken_refcounts; 343794054183SMax Reitz } 343894054183SMax Reitz 343994054183SMax Reitz BLKDBG_EVENT(bs->file, BLKDBG_L1_UPDATE); 344094054183SMax Reitz BLKDBG_EVENT(bs->file, BLKDBG_REFTABLE_UPDATE); 344194054183SMax Reitz 344294054183SMax Reitz /* "Create" an empty reftable (one cluster) directly after the image 344394054183SMax Reitz * header and an empty L1 table three clusters after the image header; 344494054183SMax Reitz * the cluster between those two will be used as the first refblock */ 3445f1f7a1ddSPeter Maydell l1_ofs_rt_ofs_cls.l1_offset = cpu_to_be64(3 * s->cluster_size); 3446f1f7a1ddSPeter Maydell l1_ofs_rt_ofs_cls.reftable_offset = cpu_to_be64(s->cluster_size); 3447f1f7a1ddSPeter Maydell l1_ofs_rt_ofs_cls.reftable_clusters = cpu_to_be32(1); 3448d9ca2ea2SKevin Wolf ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, l1_table_offset), 344994054183SMax Reitz &l1_ofs_rt_ofs_cls, sizeof(l1_ofs_rt_ofs_cls)); 345094054183SMax Reitz if (ret < 0) { 345194054183SMax Reitz goto fail_broken_refcounts; 345294054183SMax Reitz } 345394054183SMax Reitz 345494054183SMax Reitz s->l1_table_offset = 3 * s->cluster_size; 345594054183SMax Reitz 345694054183SMax Reitz new_reftable = g_try_new0(uint64_t, s->cluster_size / sizeof(uint64_t)); 345794054183SMax Reitz if (!new_reftable) { 345894054183SMax Reitz ret = -ENOMEM; 345994054183SMax Reitz goto fail_broken_refcounts; 346094054183SMax Reitz } 346194054183SMax Reitz 346294054183SMax Reitz s->refcount_table_offset = s->cluster_size; 346394054183SMax Reitz s->refcount_table_size = s->cluster_size / sizeof(uint64_t); 34647061a078SAlberto Garcia s->max_refcount_table_index = 0; 346594054183SMax Reitz 346694054183SMax Reitz g_free(s->refcount_table); 346794054183SMax Reitz s->refcount_table = new_reftable; 346894054183SMax Reitz new_reftable = NULL; 346994054183SMax Reitz 347094054183SMax Reitz /* Now the in-memory refcount information again corresponds to the on-disk 347194054183SMax Reitz * information (reftable is empty and no refblocks (the refblock cache is 347294054183SMax Reitz * empty)); however, this means some clusters (e.g. the image header) are 347394054183SMax Reitz * referenced, but not refcounted, but the normal qcow2 code assumes that 347494054183SMax Reitz * the in-memory information is always correct */ 347594054183SMax Reitz 347694054183SMax Reitz BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC); 347794054183SMax Reitz 347894054183SMax Reitz /* Enter the first refblock into the reftable */ 347994054183SMax Reitz rt_entry = cpu_to_be64(2 * s->cluster_size); 3480d9ca2ea2SKevin Wolf ret = bdrv_pwrite_sync(bs->file, s->cluster_size, 348194054183SMax Reitz &rt_entry, sizeof(rt_entry)); 348294054183SMax Reitz if (ret < 0) { 348394054183SMax Reitz goto fail_broken_refcounts; 348494054183SMax Reitz } 348594054183SMax Reitz s->refcount_table[0] = 2 * s->cluster_size; 348694054183SMax Reitz 348794054183SMax Reitz s->free_cluster_index = 0; 348894054183SMax Reitz assert(3 + l1_clusters <= s->refcount_block_size); 348994054183SMax Reitz offset = qcow2_alloc_clusters(bs, 3 * s->cluster_size + l1_size2); 349094054183SMax Reitz if (offset < 0) { 349194054183SMax Reitz ret = offset; 349294054183SMax Reitz goto fail_broken_refcounts; 349394054183SMax Reitz } else if (offset > 0) { 349494054183SMax Reitz error_report("First cluster in emptied image is in use"); 349594054183SMax Reitz abort(); 349694054183SMax Reitz } 349794054183SMax Reitz 349894054183SMax Reitz /* Now finally the in-memory information corresponds to the on-disk 349994054183SMax Reitz * structures and is correct */ 350094054183SMax Reitz ret = qcow2_mark_clean(bs); 350194054183SMax Reitz if (ret < 0) { 350294054183SMax Reitz goto fail; 350394054183SMax Reitz } 350494054183SMax Reitz 3505ed3d2ec9SMax Reitz ret = bdrv_truncate(bs->file, (3 + l1_clusters) * s->cluster_size, 35067ea37c30SMax Reitz PREALLOC_MODE_OFF, &local_err); 350794054183SMax Reitz if (ret < 0) { 3508ed3d2ec9SMax Reitz error_report_err(local_err); 350994054183SMax Reitz goto fail; 351094054183SMax Reitz } 351194054183SMax Reitz 351294054183SMax Reitz return 0; 351394054183SMax Reitz 351494054183SMax Reitz fail_broken_refcounts: 351594054183SMax Reitz /* The BDS is unusable at this point. If we wanted to make it usable, we 351694054183SMax Reitz * would have to call qcow2_refcount_close(), qcow2_refcount_init(), 351794054183SMax Reitz * qcow2_check_refcounts(), qcow2_refcount_close() and qcow2_refcount_init() 351894054183SMax Reitz * again. However, because the functions which could have caused this error 351994054183SMax Reitz * path to be taken are used by those functions as well, it's very likely 352094054183SMax Reitz * that that sequence will fail as well. Therefore, just eject the BDS. */ 352194054183SMax Reitz bs->drv = NULL; 352294054183SMax Reitz 352394054183SMax Reitz fail: 352494054183SMax Reitz g_free(new_reftable); 352594054183SMax Reitz return ret; 352694054183SMax Reitz } 352794054183SMax Reitz 3528491d27e2SMax Reitz static int qcow2_make_empty(BlockDriverState *bs) 3529491d27e2SMax Reitz { 3530ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 3531d2cb36afSEric Blake uint64_t offset, end_offset; 3532d2cb36afSEric Blake int step = QEMU_ALIGN_DOWN(INT_MAX, s->cluster_size); 353394054183SMax Reitz int l1_clusters, ret = 0; 3534491d27e2SMax Reitz 353594054183SMax Reitz l1_clusters = DIV_ROUND_UP(s->l1_size, s->cluster_size / sizeof(uint64_t)); 353694054183SMax Reitz 353794054183SMax Reitz if (s->qcow_version >= 3 && !s->snapshots && 353894054183SMax Reitz 3 + l1_clusters <= s->refcount_block_size) { 353994054183SMax Reitz /* The following function only works for qcow2 v3 images (it requires 354094054183SMax Reitz * the dirty flag) and only as long as there are no snapshots (because 354194054183SMax Reitz * it completely empties the image). Furthermore, the L1 table and three 354294054183SMax Reitz * additional clusters (image header, refcount table, one refcount 354394054183SMax Reitz * block) have to fit inside one refcount block. */ 354494054183SMax Reitz return make_completely_empty(bs); 354594054183SMax Reitz } 354694054183SMax Reitz 354794054183SMax Reitz /* This fallback code simply discards every active cluster; this is slow, 354894054183SMax Reitz * but works in all cases */ 3549d2cb36afSEric Blake end_offset = bs->total_sectors * BDRV_SECTOR_SIZE; 3550d2cb36afSEric Blake for (offset = 0; offset < end_offset; offset += step) { 3551491d27e2SMax Reitz /* As this function is generally used after committing an external 3552491d27e2SMax Reitz * snapshot, QCOW2_DISCARD_SNAPSHOT seems appropriate. Also, the 3553491d27e2SMax Reitz * default action for this kind of discard is to pass the discard, 3554491d27e2SMax Reitz * which will ideally result in an actually smaller image file, as 3555491d27e2SMax Reitz * is probably desired. */ 3556d2cb36afSEric Blake ret = qcow2_cluster_discard(bs, offset, MIN(step, end_offset - offset), 3557491d27e2SMax Reitz QCOW2_DISCARD_SNAPSHOT, true); 3558491d27e2SMax Reitz if (ret < 0) { 3559491d27e2SMax Reitz break; 3560491d27e2SMax Reitz } 3561491d27e2SMax Reitz } 3562491d27e2SMax Reitz 3563491d27e2SMax Reitz return ret; 3564491d27e2SMax Reitz } 3565491d27e2SMax Reitz 3566a968168cSDong Xu Wang static coroutine_fn int qcow2_co_flush_to_os(BlockDriverState *bs) 356720d97356SBlue Swirl { 3568ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 356929c1a730SKevin Wolf int ret; 357029c1a730SKevin Wolf 35718b94ff85SPaolo Bonzini qemu_co_mutex_lock(&s->lock); 3572f3c3b87dSDenis V. Lunev ret = qcow2_cache_write(bs, s->l2_table_cache); 357329c1a730SKevin Wolf if (ret < 0) { 3574c95de7e2SDong Xu Wang qemu_co_mutex_unlock(&s->lock); 35758b94ff85SPaolo Bonzini return ret; 357629c1a730SKevin Wolf } 357729c1a730SKevin Wolf 3578bfe8043eSStefan Hajnoczi if (qcow2_need_accurate_refcounts(s)) { 3579f3c3b87dSDenis V. Lunev ret = qcow2_cache_write(bs, s->refcount_block_cache); 358029c1a730SKevin Wolf if (ret < 0) { 3581c95de7e2SDong Xu Wang qemu_co_mutex_unlock(&s->lock); 35828b94ff85SPaolo Bonzini return ret; 358329c1a730SKevin Wolf } 3584bfe8043eSStefan Hajnoczi } 35858b94ff85SPaolo Bonzini qemu_co_mutex_unlock(&s->lock); 358629c1a730SKevin Wolf 3587eb489bb1SKevin Wolf return 0; 3588eb489bb1SKevin Wolf } 3589eb489bb1SKevin Wolf 3590c501c352SStefan Hajnoczi static BlockMeasureInfo *qcow2_measure(QemuOpts *opts, BlockDriverState *in_bs, 3591c501c352SStefan Hajnoczi Error **errp) 3592c501c352SStefan Hajnoczi { 3593c501c352SStefan Hajnoczi Error *local_err = NULL; 3594c501c352SStefan Hajnoczi BlockMeasureInfo *info; 3595c501c352SStefan Hajnoczi uint64_t required = 0; /* bytes that contribute to required size */ 3596c501c352SStefan Hajnoczi uint64_t virtual_size; /* disk size as seen by guest */ 3597c501c352SStefan Hajnoczi uint64_t refcount_bits; 3598c501c352SStefan Hajnoczi uint64_t l2_tables; 3599c501c352SStefan Hajnoczi size_t cluster_size; 3600c501c352SStefan Hajnoczi int version; 3601c501c352SStefan Hajnoczi char *optstr; 3602c501c352SStefan Hajnoczi PreallocMode prealloc; 3603c501c352SStefan Hajnoczi bool has_backing_file; 3604c501c352SStefan Hajnoczi 3605c501c352SStefan Hajnoczi /* Parse image creation options */ 3606c501c352SStefan Hajnoczi cluster_size = qcow2_opt_get_cluster_size_del(opts, &local_err); 3607c501c352SStefan Hajnoczi if (local_err) { 3608c501c352SStefan Hajnoczi goto err; 3609c501c352SStefan Hajnoczi } 3610c501c352SStefan Hajnoczi 3611c501c352SStefan Hajnoczi version = qcow2_opt_get_version_del(opts, &local_err); 3612c501c352SStefan Hajnoczi if (local_err) { 3613c501c352SStefan Hajnoczi goto err; 3614c501c352SStefan Hajnoczi } 3615c501c352SStefan Hajnoczi 3616c501c352SStefan Hajnoczi refcount_bits = qcow2_opt_get_refcount_bits_del(opts, version, &local_err); 3617c501c352SStefan Hajnoczi if (local_err) { 3618c501c352SStefan Hajnoczi goto err; 3619c501c352SStefan Hajnoczi } 3620c501c352SStefan Hajnoczi 3621c501c352SStefan Hajnoczi optstr = qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC); 3622c501c352SStefan Hajnoczi prealloc = qapi_enum_parse(PreallocMode_lookup, optstr, 3623c501c352SStefan Hajnoczi PREALLOC_MODE__MAX, PREALLOC_MODE_OFF, 3624c501c352SStefan Hajnoczi &local_err); 3625c501c352SStefan Hajnoczi g_free(optstr); 3626c501c352SStefan Hajnoczi if (local_err) { 3627c501c352SStefan Hajnoczi goto err; 3628c501c352SStefan Hajnoczi } 3629c501c352SStefan Hajnoczi 3630c501c352SStefan Hajnoczi optstr = qemu_opt_get_del(opts, BLOCK_OPT_BACKING_FILE); 3631c501c352SStefan Hajnoczi has_backing_file = !!optstr; 3632c501c352SStefan Hajnoczi g_free(optstr); 3633c501c352SStefan Hajnoczi 3634c501c352SStefan Hajnoczi virtual_size = align_offset(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0), 3635c501c352SStefan Hajnoczi cluster_size); 3636c501c352SStefan Hajnoczi 3637c501c352SStefan Hajnoczi /* Check that virtual disk size is valid */ 3638c501c352SStefan Hajnoczi l2_tables = DIV_ROUND_UP(virtual_size / cluster_size, 3639c501c352SStefan Hajnoczi cluster_size / sizeof(uint64_t)); 3640c501c352SStefan Hajnoczi if (l2_tables * sizeof(uint64_t) > QCOW_MAX_L1_SIZE) { 3641c501c352SStefan Hajnoczi error_setg(&local_err, "The image size is too large " 3642c501c352SStefan Hajnoczi "(try using a larger cluster size)"); 3643c501c352SStefan Hajnoczi goto err; 3644c501c352SStefan Hajnoczi } 3645c501c352SStefan Hajnoczi 3646c501c352SStefan Hajnoczi /* Account for input image */ 3647c501c352SStefan Hajnoczi if (in_bs) { 3648c501c352SStefan Hajnoczi int64_t ssize = bdrv_getlength(in_bs); 3649c501c352SStefan Hajnoczi if (ssize < 0) { 3650c501c352SStefan Hajnoczi error_setg_errno(&local_err, -ssize, 3651c501c352SStefan Hajnoczi "Unable to get image virtual_size"); 3652c501c352SStefan Hajnoczi goto err; 3653c501c352SStefan Hajnoczi } 3654c501c352SStefan Hajnoczi 3655c501c352SStefan Hajnoczi virtual_size = align_offset(ssize, cluster_size); 3656c501c352SStefan Hajnoczi 3657c501c352SStefan Hajnoczi if (has_backing_file) { 3658c501c352SStefan Hajnoczi /* We don't how much of the backing chain is shared by the input 3659c501c352SStefan Hajnoczi * image and the new image file. In the worst case the new image's 3660c501c352SStefan Hajnoczi * backing file has nothing in common with the input image. Be 3661c501c352SStefan Hajnoczi * conservative and assume all clusters need to be written. 3662c501c352SStefan Hajnoczi */ 3663c501c352SStefan Hajnoczi required = virtual_size; 3664c501c352SStefan Hajnoczi } else { 3665c501c352SStefan Hajnoczi int cluster_sectors = cluster_size / BDRV_SECTOR_SIZE; 3666c501c352SStefan Hajnoczi int64_t sector_num; 3667c501c352SStefan Hajnoczi int pnum = 0; 3668c501c352SStefan Hajnoczi 3669c501c352SStefan Hajnoczi for (sector_num = 0; 3670c501c352SStefan Hajnoczi sector_num < ssize / BDRV_SECTOR_SIZE; 3671c501c352SStefan Hajnoczi sector_num += pnum) { 367224bae02bSEric Blake int nb_sectors = MIN(ssize / BDRV_SECTOR_SIZE - sector_num, 367324bae02bSEric Blake BDRV_REQUEST_MAX_SECTORS); 3674c501c352SStefan Hajnoczi BlockDriverState *file; 3675c501c352SStefan Hajnoczi int64_t ret; 3676c501c352SStefan Hajnoczi 3677c501c352SStefan Hajnoczi ret = bdrv_get_block_status_above(in_bs, NULL, 3678c501c352SStefan Hajnoczi sector_num, nb_sectors, 3679c501c352SStefan Hajnoczi &pnum, &file); 3680c501c352SStefan Hajnoczi if (ret < 0) { 3681c501c352SStefan Hajnoczi error_setg_errno(&local_err, -ret, 3682c501c352SStefan Hajnoczi "Unable to get block status"); 3683c501c352SStefan Hajnoczi goto err; 3684c501c352SStefan Hajnoczi } 3685c501c352SStefan Hajnoczi 3686c501c352SStefan Hajnoczi if (ret & BDRV_BLOCK_ZERO) { 3687c501c352SStefan Hajnoczi /* Skip zero regions (safe with no backing file) */ 3688c501c352SStefan Hajnoczi } else if ((ret & (BDRV_BLOCK_DATA | BDRV_BLOCK_ALLOCATED)) == 3689c501c352SStefan Hajnoczi (BDRV_BLOCK_DATA | BDRV_BLOCK_ALLOCATED)) { 3690c501c352SStefan Hajnoczi /* Extend pnum to end of cluster for next iteration */ 3691c501c352SStefan Hajnoczi pnum = ROUND_UP(sector_num + pnum, cluster_sectors) - 3692c501c352SStefan Hajnoczi sector_num; 3693c501c352SStefan Hajnoczi 3694c501c352SStefan Hajnoczi /* Count clusters we've seen */ 3695c501c352SStefan Hajnoczi required += (sector_num % cluster_sectors + pnum) * 3696c501c352SStefan Hajnoczi BDRV_SECTOR_SIZE; 3697c501c352SStefan Hajnoczi } 3698c501c352SStefan Hajnoczi } 3699c501c352SStefan Hajnoczi } 3700c501c352SStefan Hajnoczi } 3701c501c352SStefan Hajnoczi 3702c501c352SStefan Hajnoczi /* Take into account preallocation. Nothing special is needed for 3703c501c352SStefan Hajnoczi * PREALLOC_MODE_METADATA since metadata is always counted. 3704c501c352SStefan Hajnoczi */ 3705c501c352SStefan Hajnoczi if (prealloc == PREALLOC_MODE_FULL || prealloc == PREALLOC_MODE_FALLOC) { 3706c501c352SStefan Hajnoczi required = virtual_size; 3707c501c352SStefan Hajnoczi } 3708c501c352SStefan Hajnoczi 3709c501c352SStefan Hajnoczi info = g_new(BlockMeasureInfo, 1); 3710c501c352SStefan Hajnoczi info->fully_allocated = 3711c501c352SStefan Hajnoczi qcow2_calc_prealloc_size(virtual_size, cluster_size, 3712c501c352SStefan Hajnoczi ctz32(refcount_bits)); 3713c501c352SStefan Hajnoczi 3714c501c352SStefan Hajnoczi /* Remove data clusters that are not required. This overestimates the 3715c501c352SStefan Hajnoczi * required size because metadata needed for the fully allocated file is 3716c501c352SStefan Hajnoczi * still counted. 3717c501c352SStefan Hajnoczi */ 3718c501c352SStefan Hajnoczi info->required = info->fully_allocated - virtual_size + required; 3719c501c352SStefan Hajnoczi return info; 3720c501c352SStefan Hajnoczi 3721c501c352SStefan Hajnoczi err: 3722c501c352SStefan Hajnoczi error_propagate(errp, local_err); 3723c501c352SStefan Hajnoczi return NULL; 3724c501c352SStefan Hajnoczi } 3725c501c352SStefan Hajnoczi 37267c80ab3fSJes Sorensen static int qcow2_get_info(BlockDriverState *bs, BlockDriverInfo *bdi) 372720d97356SBlue Swirl { 3728ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 372995de6d70SPaolo Bonzini bdi->unallocated_blocks_are_zero = true; 373095de6d70SPaolo Bonzini bdi->can_write_zeroes_with_unmap = (s->qcow_version >= 3); 373120d97356SBlue Swirl bdi->cluster_size = s->cluster_size; 37327c80ab3fSJes Sorensen bdi->vm_state_offset = qcow2_vm_state_offset(s); 373320d97356SBlue Swirl return 0; 373420d97356SBlue Swirl } 373520d97356SBlue Swirl 373637764dfbSMax Reitz static ImageInfoSpecific *qcow2_get_specific_info(BlockDriverState *bs) 373737764dfbSMax Reitz { 3738ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 37390a12f6f8SDaniel P. Berrange ImageInfoSpecific *spec_info; 37400a12f6f8SDaniel P. Berrange QCryptoBlockInfo *encrypt_info = NULL; 374137764dfbSMax Reitz 37420a12f6f8SDaniel P. Berrange if (s->crypto != NULL) { 37430a12f6f8SDaniel P. Berrange encrypt_info = qcrypto_block_get_info(s->crypto, &error_abort); 37440a12f6f8SDaniel P. Berrange } 37450a12f6f8SDaniel P. Berrange 37460a12f6f8SDaniel P. Berrange spec_info = g_new(ImageInfoSpecific, 1); 374737764dfbSMax Reitz *spec_info = (ImageInfoSpecific){ 37486a8f9661SEric Blake .type = IMAGE_INFO_SPECIFIC_KIND_QCOW2, 374932bafa8fSEric Blake .u.qcow2.data = g_new(ImageInfoSpecificQCow2, 1), 375037764dfbSMax Reitz }; 375137764dfbSMax Reitz if (s->qcow_version == 2) { 375232bafa8fSEric Blake *spec_info->u.qcow2.data = (ImageInfoSpecificQCow2){ 375337764dfbSMax Reitz .compat = g_strdup("0.10"), 37540709c5a1SMax Reitz .refcount_bits = s->refcount_bits, 375537764dfbSMax Reitz }; 375637764dfbSMax Reitz } else if (s->qcow_version == 3) { 375732bafa8fSEric Blake *spec_info->u.qcow2.data = (ImageInfoSpecificQCow2){ 375837764dfbSMax Reitz .compat = g_strdup("1.1"), 375937764dfbSMax Reitz .lazy_refcounts = s->compatible_features & 376037764dfbSMax Reitz QCOW2_COMPAT_LAZY_REFCOUNTS, 376137764dfbSMax Reitz .has_lazy_refcounts = true, 37629009b196SMax Reitz .corrupt = s->incompatible_features & 37639009b196SMax Reitz QCOW2_INCOMPAT_CORRUPT, 37649009b196SMax Reitz .has_corrupt = true, 37650709c5a1SMax Reitz .refcount_bits = s->refcount_bits, 376637764dfbSMax Reitz }; 3767b1fc8f93SDenis V. Lunev } else { 3768b1fc8f93SDenis V. Lunev /* if this assertion fails, this probably means a new version was 3769b1fc8f93SDenis V. Lunev * added without having it covered here */ 3770b1fc8f93SDenis V. Lunev assert(false); 377137764dfbSMax Reitz } 377237764dfbSMax Reitz 37730a12f6f8SDaniel P. Berrange if (encrypt_info) { 37740a12f6f8SDaniel P. Berrange ImageInfoSpecificQCow2Encryption *qencrypt = 37750a12f6f8SDaniel P. Berrange g_new(ImageInfoSpecificQCow2Encryption, 1); 37760a12f6f8SDaniel P. Berrange switch (encrypt_info->format) { 37770a12f6f8SDaniel P. Berrange case Q_CRYPTO_BLOCK_FORMAT_QCOW: 37780a12f6f8SDaniel P. Berrange qencrypt->format = BLOCKDEV_QCOW2_ENCRYPTION_FORMAT_AES; 37790a12f6f8SDaniel P. Berrange qencrypt->u.aes = encrypt_info->u.qcow; 37800a12f6f8SDaniel P. Berrange break; 37810a12f6f8SDaniel P. Berrange case Q_CRYPTO_BLOCK_FORMAT_LUKS: 37820a12f6f8SDaniel P. Berrange qencrypt->format = BLOCKDEV_QCOW2_ENCRYPTION_FORMAT_LUKS; 37830a12f6f8SDaniel P. Berrange qencrypt->u.luks = encrypt_info->u.luks; 37840a12f6f8SDaniel P. Berrange break; 37850a12f6f8SDaniel P. Berrange default: 37860a12f6f8SDaniel P. Berrange abort(); 37870a12f6f8SDaniel P. Berrange } 37880a12f6f8SDaniel P. Berrange /* Since we did shallow copy above, erase any pointers 37890a12f6f8SDaniel P. Berrange * in the original info */ 37900a12f6f8SDaniel P. Berrange memset(&encrypt_info->u, 0, sizeof(encrypt_info->u)); 37910a12f6f8SDaniel P. Berrange qapi_free_QCryptoBlockInfo(encrypt_info); 37920a12f6f8SDaniel P. Berrange 37930a12f6f8SDaniel P. Berrange spec_info->u.qcow2.data->has_encrypt = true; 37940a12f6f8SDaniel P. Berrange spec_info->u.qcow2.data->encrypt = qencrypt; 37950a12f6f8SDaniel P. Berrange } 37960a12f6f8SDaniel P. Berrange 379737764dfbSMax Reitz return spec_info; 379837764dfbSMax Reitz } 379937764dfbSMax Reitz 3800cf8074b3SKevin Wolf static int qcow2_save_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, 3801cf8074b3SKevin Wolf int64_t pos) 380220d97356SBlue Swirl { 3803ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 380420d97356SBlue Swirl 380566f82ceeSKevin Wolf BLKDBG_EVENT(bs->file, BLKDBG_VMSTATE_SAVE); 3806734a7758SKevin Wolf return bs->drv->bdrv_co_pwritev(bs, qcow2_vm_state_offset(s) + pos, 3807734a7758SKevin Wolf qiov->size, qiov, 0); 380820d97356SBlue Swirl } 380920d97356SBlue Swirl 38105ddda0b8SKevin Wolf static int qcow2_load_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, 38115ddda0b8SKevin Wolf int64_t pos) 381220d97356SBlue Swirl { 3813ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 381420d97356SBlue Swirl 381566f82ceeSKevin Wolf BLKDBG_EVENT(bs->file, BLKDBG_VMSTATE_LOAD); 3816734a7758SKevin Wolf return bs->drv->bdrv_co_preadv(bs, qcow2_vm_state_offset(s) + pos, 3817734a7758SKevin Wolf qiov->size, qiov, 0); 381820d97356SBlue Swirl } 381920d97356SBlue Swirl 38209296b3edSMax Reitz /* 38219296b3edSMax Reitz * Downgrades an image's version. To achieve this, any incompatible features 38229296b3edSMax Reitz * have to be removed. 38239296b3edSMax Reitz */ 38244057a2b2SMax Reitz static int qcow2_downgrade(BlockDriverState *bs, int target_version, 38258b13976dSMax Reitz BlockDriverAmendStatusCB *status_cb, void *cb_opaque) 38269296b3edSMax Reitz { 3827ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 38289296b3edSMax Reitz int current_version = s->qcow_version; 38299296b3edSMax Reitz int ret; 38309296b3edSMax Reitz 38319296b3edSMax Reitz if (target_version == current_version) { 38329296b3edSMax Reitz return 0; 38339296b3edSMax Reitz } else if (target_version > current_version) { 38349296b3edSMax Reitz return -EINVAL; 38359296b3edSMax Reitz } else if (target_version != 2) { 38369296b3edSMax Reitz return -EINVAL; 38379296b3edSMax Reitz } 38389296b3edSMax Reitz 38399296b3edSMax Reitz if (s->refcount_order != 4) { 384061ce55fcSMax Reitz error_report("compat=0.10 requires refcount_bits=16"); 38419296b3edSMax Reitz return -ENOTSUP; 38429296b3edSMax Reitz } 38439296b3edSMax Reitz 38449296b3edSMax Reitz /* clear incompatible features */ 38459296b3edSMax Reitz if (s->incompatible_features & QCOW2_INCOMPAT_DIRTY) { 38469296b3edSMax Reitz ret = qcow2_mark_clean(bs); 38479296b3edSMax Reitz if (ret < 0) { 38489296b3edSMax Reitz return ret; 38499296b3edSMax Reitz } 38509296b3edSMax Reitz } 38519296b3edSMax Reitz 38529296b3edSMax Reitz /* with QCOW2_INCOMPAT_CORRUPT, it is pretty much impossible to get here in 38539296b3edSMax Reitz * the first place; if that happens nonetheless, returning -ENOTSUP is the 38549296b3edSMax Reitz * best thing to do anyway */ 38559296b3edSMax Reitz 38569296b3edSMax Reitz if (s->incompatible_features) { 38579296b3edSMax Reitz return -ENOTSUP; 38589296b3edSMax Reitz } 38599296b3edSMax Reitz 38609296b3edSMax Reitz /* since we can ignore compatible features, we can set them to 0 as well */ 38619296b3edSMax Reitz s->compatible_features = 0; 38629296b3edSMax Reitz /* if lazy refcounts have been used, they have already been fixed through 38639296b3edSMax Reitz * clearing the dirty flag */ 38649296b3edSMax Reitz 38659296b3edSMax Reitz /* clearing autoclear features is trivial */ 38669296b3edSMax Reitz s->autoclear_features = 0; 38679296b3edSMax Reitz 38688b13976dSMax Reitz ret = qcow2_expand_zero_clusters(bs, status_cb, cb_opaque); 38699296b3edSMax Reitz if (ret < 0) { 38709296b3edSMax Reitz return ret; 38719296b3edSMax Reitz } 38729296b3edSMax Reitz 38739296b3edSMax Reitz s->qcow_version = target_version; 38749296b3edSMax Reitz ret = qcow2_update_header(bs); 38759296b3edSMax Reitz if (ret < 0) { 38769296b3edSMax Reitz s->qcow_version = current_version; 38779296b3edSMax Reitz return ret; 38789296b3edSMax Reitz } 38799296b3edSMax Reitz return 0; 38809296b3edSMax Reitz } 38819296b3edSMax Reitz 3882c293a809SMax Reitz typedef enum Qcow2AmendOperation { 3883c293a809SMax Reitz /* This is the value Qcow2AmendHelperCBInfo::last_operation will be 3884c293a809SMax Reitz * statically initialized to so that the helper CB can discern the first 3885c293a809SMax Reitz * invocation from an operation change */ 3886c293a809SMax Reitz QCOW2_NO_OPERATION = 0, 3887c293a809SMax Reitz 388861ce55fcSMax Reitz QCOW2_CHANGING_REFCOUNT_ORDER, 3889c293a809SMax Reitz QCOW2_DOWNGRADING, 3890c293a809SMax Reitz } Qcow2AmendOperation; 3891c293a809SMax Reitz 3892c293a809SMax Reitz typedef struct Qcow2AmendHelperCBInfo { 3893c293a809SMax Reitz /* The code coordinating the amend operations should only modify 3894c293a809SMax Reitz * these four fields; the rest will be managed by the CB */ 3895c293a809SMax Reitz BlockDriverAmendStatusCB *original_status_cb; 3896c293a809SMax Reitz void *original_cb_opaque; 3897c293a809SMax Reitz 3898c293a809SMax Reitz Qcow2AmendOperation current_operation; 3899c293a809SMax Reitz 3900c293a809SMax Reitz /* Total number of operations to perform (only set once) */ 3901c293a809SMax Reitz int total_operations; 3902c293a809SMax Reitz 3903c293a809SMax Reitz /* The following fields are managed by the CB */ 3904c293a809SMax Reitz 3905c293a809SMax Reitz /* Number of operations completed */ 3906c293a809SMax Reitz int operations_completed; 3907c293a809SMax Reitz 3908c293a809SMax Reitz /* Cumulative offset of all completed operations */ 3909c293a809SMax Reitz int64_t offset_completed; 3910c293a809SMax Reitz 3911c293a809SMax Reitz Qcow2AmendOperation last_operation; 3912c293a809SMax Reitz int64_t last_work_size; 3913c293a809SMax Reitz } Qcow2AmendHelperCBInfo; 3914c293a809SMax Reitz 3915c293a809SMax Reitz static void qcow2_amend_helper_cb(BlockDriverState *bs, 3916c293a809SMax Reitz int64_t operation_offset, 3917c293a809SMax Reitz int64_t operation_work_size, void *opaque) 3918c293a809SMax Reitz { 3919c293a809SMax Reitz Qcow2AmendHelperCBInfo *info = opaque; 3920c293a809SMax Reitz int64_t current_work_size; 3921c293a809SMax Reitz int64_t projected_work_size; 3922c293a809SMax Reitz 3923c293a809SMax Reitz if (info->current_operation != info->last_operation) { 3924c293a809SMax Reitz if (info->last_operation != QCOW2_NO_OPERATION) { 3925c293a809SMax Reitz info->offset_completed += info->last_work_size; 3926c293a809SMax Reitz info->operations_completed++; 3927c293a809SMax Reitz } 3928c293a809SMax Reitz 3929c293a809SMax Reitz info->last_operation = info->current_operation; 3930c293a809SMax Reitz } 3931c293a809SMax Reitz 3932c293a809SMax Reitz assert(info->total_operations > 0); 3933c293a809SMax Reitz assert(info->operations_completed < info->total_operations); 3934c293a809SMax Reitz 3935c293a809SMax Reitz info->last_work_size = operation_work_size; 3936c293a809SMax Reitz 3937c293a809SMax Reitz current_work_size = info->offset_completed + operation_work_size; 3938c293a809SMax Reitz 3939c293a809SMax Reitz /* current_work_size is the total work size for (operations_completed + 1) 3940c293a809SMax Reitz * operations (which includes this one), so multiply it by the number of 3941c293a809SMax Reitz * operations not covered and divide it by the number of operations 3942c293a809SMax Reitz * covered to get a projection for the operations not covered */ 3943c293a809SMax Reitz projected_work_size = current_work_size * (info->total_operations - 3944c293a809SMax Reitz info->operations_completed - 1) 3945c293a809SMax Reitz / (info->operations_completed + 1); 3946c293a809SMax Reitz 3947c293a809SMax Reitz info->original_status_cb(bs, info->offset_completed + operation_offset, 3948c293a809SMax Reitz current_work_size + projected_work_size, 3949c293a809SMax Reitz info->original_cb_opaque); 3950c293a809SMax Reitz } 3951c293a809SMax Reitz 395277485434SMax Reitz static int qcow2_amend_options(BlockDriverState *bs, QemuOpts *opts, 39538b13976dSMax Reitz BlockDriverAmendStatusCB *status_cb, 39548b13976dSMax Reitz void *cb_opaque) 39559296b3edSMax Reitz { 3956ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 39579296b3edSMax Reitz int old_version = s->qcow_version, new_version = old_version; 39589296b3edSMax Reitz uint64_t new_size = 0; 39599296b3edSMax Reitz const char *backing_file = NULL, *backing_format = NULL; 39609296b3edSMax Reitz bool lazy_refcounts = s->use_lazy_refcounts; 39611bd0e2d1SChunyan Liu const char *compat = NULL; 39621bd0e2d1SChunyan Liu uint64_t cluster_size = s->cluster_size; 39631bd0e2d1SChunyan Liu bool encrypt; 39644652b8f3SDaniel P. Berrange int encformat; 396561ce55fcSMax Reitz int refcount_bits = s->refcount_bits; 3966d7086422SKevin Wolf Error *local_err = NULL; 39679296b3edSMax Reitz int ret; 39681bd0e2d1SChunyan Liu QemuOptDesc *desc = opts->list->desc; 3969c293a809SMax Reitz Qcow2AmendHelperCBInfo helper_cb_info; 39709296b3edSMax Reitz 39711bd0e2d1SChunyan Liu while (desc && desc->name) { 39721bd0e2d1SChunyan Liu if (!qemu_opt_find(opts, desc->name)) { 39739296b3edSMax Reitz /* only change explicitly defined options */ 39741bd0e2d1SChunyan Liu desc++; 39759296b3edSMax Reitz continue; 39769296b3edSMax Reitz } 39779296b3edSMax Reitz 39788a17b83cSMax Reitz if (!strcmp(desc->name, BLOCK_OPT_COMPAT_LEVEL)) { 39798a17b83cSMax Reitz compat = qemu_opt_get(opts, BLOCK_OPT_COMPAT_LEVEL); 39801bd0e2d1SChunyan Liu if (!compat) { 39819296b3edSMax Reitz /* preserve default */ 39821bd0e2d1SChunyan Liu } else if (!strcmp(compat, "0.10")) { 39839296b3edSMax Reitz new_version = 2; 39841bd0e2d1SChunyan Liu } else if (!strcmp(compat, "1.1")) { 39859296b3edSMax Reitz new_version = 3; 39869296b3edSMax Reitz } else { 398729d72431SMax Reitz error_report("Unknown compatibility level %s", compat); 39889296b3edSMax Reitz return -EINVAL; 39899296b3edSMax Reitz } 39908a17b83cSMax Reitz } else if (!strcmp(desc->name, BLOCK_OPT_PREALLOC)) { 399129d72431SMax Reitz error_report("Cannot change preallocation mode"); 39929296b3edSMax Reitz return -ENOTSUP; 39938a17b83cSMax Reitz } else if (!strcmp(desc->name, BLOCK_OPT_SIZE)) { 39948a17b83cSMax Reitz new_size = qemu_opt_get_size(opts, BLOCK_OPT_SIZE, 0); 39958a17b83cSMax Reitz } else if (!strcmp(desc->name, BLOCK_OPT_BACKING_FILE)) { 39968a17b83cSMax Reitz backing_file = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE); 39978a17b83cSMax Reitz } else if (!strcmp(desc->name, BLOCK_OPT_BACKING_FMT)) { 39988a17b83cSMax Reitz backing_format = qemu_opt_get(opts, BLOCK_OPT_BACKING_FMT); 39998a17b83cSMax Reitz } else if (!strcmp(desc->name, BLOCK_OPT_ENCRYPT)) { 40008a17b83cSMax Reitz encrypt = qemu_opt_get_bool(opts, BLOCK_OPT_ENCRYPT, 4001b25b387fSDaniel P. Berrange !!s->crypto); 4002f6fa64f6SDaniel P. Berrange 4003b25b387fSDaniel P. Berrange if (encrypt != !!s->crypto) { 400429d72431SMax Reitz error_report("Changing the encryption flag is not supported"); 40059296b3edSMax Reitz return -ENOTSUP; 40069296b3edSMax Reitz } 40074652b8f3SDaniel P. Berrange } else if (!strcmp(desc->name, BLOCK_OPT_ENCRYPT_FORMAT)) { 40084652b8f3SDaniel P. Berrange encformat = qcow2_crypt_method_from_format( 40094652b8f3SDaniel P. Berrange qemu_opt_get(opts, BLOCK_OPT_ENCRYPT_FORMAT)); 40104652b8f3SDaniel P. Berrange 40114652b8f3SDaniel P. Berrange if (encformat != s->crypt_method_header) { 40124652b8f3SDaniel P. Berrange error_report("Changing the encryption format is not supported"); 40134652b8f3SDaniel P. Berrange return -ENOTSUP; 40144652b8f3SDaniel P. Berrange } 40158a17b83cSMax Reitz } else if (!strcmp(desc->name, BLOCK_OPT_CLUSTER_SIZE)) { 40168a17b83cSMax Reitz cluster_size = qemu_opt_get_size(opts, BLOCK_OPT_CLUSTER_SIZE, 40171bd0e2d1SChunyan Liu cluster_size); 40181bd0e2d1SChunyan Liu if (cluster_size != s->cluster_size) { 401929d72431SMax Reitz error_report("Changing the cluster size is not supported"); 40209296b3edSMax Reitz return -ENOTSUP; 40219296b3edSMax Reitz } 40228a17b83cSMax Reitz } else if (!strcmp(desc->name, BLOCK_OPT_LAZY_REFCOUNTS)) { 40238a17b83cSMax Reitz lazy_refcounts = qemu_opt_get_bool(opts, BLOCK_OPT_LAZY_REFCOUNTS, 40241bd0e2d1SChunyan Liu lazy_refcounts); 402506d05fa7SMax Reitz } else if (!strcmp(desc->name, BLOCK_OPT_REFCOUNT_BITS)) { 402661ce55fcSMax Reitz refcount_bits = qemu_opt_get_number(opts, BLOCK_OPT_REFCOUNT_BITS, 402761ce55fcSMax Reitz refcount_bits); 402861ce55fcSMax Reitz 402961ce55fcSMax Reitz if (refcount_bits <= 0 || refcount_bits > 64 || 403061ce55fcSMax Reitz !is_power_of_2(refcount_bits)) 403161ce55fcSMax Reitz { 403261ce55fcSMax Reitz error_report("Refcount width must be a power of two and may " 403361ce55fcSMax Reitz "not exceed 64 bits"); 403461ce55fcSMax Reitz return -EINVAL; 403561ce55fcSMax Reitz } 40369296b3edSMax Reitz } else { 4037164e0f89SMax Reitz /* if this point is reached, this probably means a new option was 40389296b3edSMax Reitz * added without having it covered here */ 4039164e0f89SMax Reitz abort(); 40409296b3edSMax Reitz } 40411bd0e2d1SChunyan Liu 40421bd0e2d1SChunyan Liu desc++; 40439296b3edSMax Reitz } 40449296b3edSMax Reitz 4045c293a809SMax Reitz helper_cb_info = (Qcow2AmendHelperCBInfo){ 4046c293a809SMax Reitz .original_status_cb = status_cb, 4047c293a809SMax Reitz .original_cb_opaque = cb_opaque, 4048c293a809SMax Reitz .total_operations = (new_version < old_version) 404961ce55fcSMax Reitz + (s->refcount_bits != refcount_bits) 4050c293a809SMax Reitz }; 4051c293a809SMax Reitz 40521038bbb8SMax Reitz /* Upgrade first (some features may require compat=1.1) */ 40539296b3edSMax Reitz if (new_version > old_version) { 40549296b3edSMax Reitz s->qcow_version = new_version; 40559296b3edSMax Reitz ret = qcow2_update_header(bs); 40569296b3edSMax Reitz if (ret < 0) { 40579296b3edSMax Reitz s->qcow_version = old_version; 40589296b3edSMax Reitz return ret; 40599296b3edSMax Reitz } 40609296b3edSMax Reitz } 40619296b3edSMax Reitz 406261ce55fcSMax Reitz if (s->refcount_bits != refcount_bits) { 406361ce55fcSMax Reitz int refcount_order = ctz32(refcount_bits); 406461ce55fcSMax Reitz 406561ce55fcSMax Reitz if (new_version < 3 && refcount_bits != 16) { 406661ce55fcSMax Reitz error_report("Different refcount widths than 16 bits require " 406761ce55fcSMax Reitz "compatibility level 1.1 or above (use compat=1.1 or " 406861ce55fcSMax Reitz "greater)"); 406961ce55fcSMax Reitz return -EINVAL; 407061ce55fcSMax Reitz } 407161ce55fcSMax Reitz 407261ce55fcSMax Reitz helper_cb_info.current_operation = QCOW2_CHANGING_REFCOUNT_ORDER; 407361ce55fcSMax Reitz ret = qcow2_change_refcount_order(bs, refcount_order, 407461ce55fcSMax Reitz &qcow2_amend_helper_cb, 4075a7a6a2bfSAlberto Garcia &helper_cb_info, &local_err); 407661ce55fcSMax Reitz if (ret < 0) { 4077a7a6a2bfSAlberto Garcia error_report_err(local_err); 407861ce55fcSMax Reitz return ret; 407961ce55fcSMax Reitz } 408061ce55fcSMax Reitz } 408161ce55fcSMax Reitz 40829296b3edSMax Reitz if (backing_file || backing_format) { 4083e4603fe1SKevin Wolf ret = qcow2_change_backing_file(bs, 4084e4603fe1SKevin Wolf backing_file ?: s->image_backing_file, 4085e4603fe1SKevin Wolf backing_format ?: s->image_backing_format); 40869296b3edSMax Reitz if (ret < 0) { 40879296b3edSMax Reitz return ret; 40889296b3edSMax Reitz } 40899296b3edSMax Reitz } 40909296b3edSMax Reitz 40919296b3edSMax Reitz if (s->use_lazy_refcounts != lazy_refcounts) { 40929296b3edSMax Reitz if (lazy_refcounts) { 40931038bbb8SMax Reitz if (new_version < 3) { 409429d72431SMax Reitz error_report("Lazy refcounts only supported with compatibility " 409529d72431SMax Reitz "level 1.1 and above (use compat=1.1 or greater)"); 40969296b3edSMax Reitz return -EINVAL; 40979296b3edSMax Reitz } 40989296b3edSMax Reitz s->compatible_features |= QCOW2_COMPAT_LAZY_REFCOUNTS; 40999296b3edSMax Reitz ret = qcow2_update_header(bs); 41009296b3edSMax Reitz if (ret < 0) { 41019296b3edSMax Reitz s->compatible_features &= ~QCOW2_COMPAT_LAZY_REFCOUNTS; 41029296b3edSMax Reitz return ret; 41039296b3edSMax Reitz } 41049296b3edSMax Reitz s->use_lazy_refcounts = true; 41059296b3edSMax Reitz } else { 41069296b3edSMax Reitz /* make image clean first */ 41079296b3edSMax Reitz ret = qcow2_mark_clean(bs); 41089296b3edSMax Reitz if (ret < 0) { 41099296b3edSMax Reitz return ret; 41109296b3edSMax Reitz } 41119296b3edSMax Reitz /* now disallow lazy refcounts */ 41129296b3edSMax Reitz s->compatible_features &= ~QCOW2_COMPAT_LAZY_REFCOUNTS; 41139296b3edSMax Reitz ret = qcow2_update_header(bs); 41149296b3edSMax Reitz if (ret < 0) { 41159296b3edSMax Reitz s->compatible_features |= QCOW2_COMPAT_LAZY_REFCOUNTS; 41169296b3edSMax Reitz return ret; 41179296b3edSMax Reitz } 41189296b3edSMax Reitz s->use_lazy_refcounts = false; 41199296b3edSMax Reitz } 41209296b3edSMax Reitz } 41219296b3edSMax Reitz 41229296b3edSMax Reitz if (new_size) { 41236d0eb64dSKevin Wolf BlockBackend *blk = blk_new(BLK_PERM_RESIZE, BLK_PERM_ALL); 4124d7086422SKevin Wolf ret = blk_insert_bs(blk, bs, &local_err); 4125d7086422SKevin Wolf if (ret < 0) { 4126d7086422SKevin Wolf error_report_err(local_err); 4127d7086422SKevin Wolf blk_unref(blk); 4128d7086422SKevin Wolf return ret; 4129d7086422SKevin Wolf } 4130d7086422SKevin Wolf 41313a691c50SMax Reitz ret = blk_truncate(blk, new_size, PREALLOC_MODE_OFF, &local_err); 413270b27f36SKevin Wolf blk_unref(blk); 41339296b3edSMax Reitz if (ret < 0) { 4134ed3d2ec9SMax Reitz error_report_err(local_err); 41359296b3edSMax Reitz return ret; 41369296b3edSMax Reitz } 41379296b3edSMax Reitz } 41389296b3edSMax Reitz 41391038bbb8SMax Reitz /* Downgrade last (so unsupported features can be removed before) */ 41401038bbb8SMax Reitz if (new_version < old_version) { 4141c293a809SMax Reitz helper_cb_info.current_operation = QCOW2_DOWNGRADING; 4142c293a809SMax Reitz ret = qcow2_downgrade(bs, new_version, &qcow2_amend_helper_cb, 4143c293a809SMax Reitz &helper_cb_info); 41441038bbb8SMax Reitz if (ret < 0) { 41451038bbb8SMax Reitz return ret; 41461038bbb8SMax Reitz } 41471038bbb8SMax Reitz } 41481038bbb8SMax Reitz 41499296b3edSMax Reitz return 0; 41509296b3edSMax Reitz } 41519296b3edSMax Reitz 415285186ebdSMax Reitz /* 415385186ebdSMax Reitz * If offset or size are negative, respectively, they will not be included in 415485186ebdSMax Reitz * the BLOCK_IMAGE_CORRUPTED event emitted. 415585186ebdSMax Reitz * fatal will be ignored for read-only BDS; corruptions found there will always 415685186ebdSMax Reitz * be considered non-fatal. 415785186ebdSMax Reitz */ 415885186ebdSMax Reitz void qcow2_signal_corruption(BlockDriverState *bs, bool fatal, int64_t offset, 415985186ebdSMax Reitz int64_t size, const char *message_format, ...) 416085186ebdSMax Reitz { 4161ff99129aSKevin Wolf BDRVQcow2State *s = bs->opaque; 4162dc881b44SAlberto Garcia const char *node_name; 416385186ebdSMax Reitz char *message; 416485186ebdSMax Reitz va_list ap; 416585186ebdSMax Reitz 416685186ebdSMax Reitz fatal = fatal && !bs->read_only; 416785186ebdSMax Reitz 416885186ebdSMax Reitz if (s->signaled_corruption && 416985186ebdSMax Reitz (!fatal || (s->incompatible_features & QCOW2_INCOMPAT_CORRUPT))) 417085186ebdSMax Reitz { 417185186ebdSMax Reitz return; 417285186ebdSMax Reitz } 417385186ebdSMax Reitz 417485186ebdSMax Reitz va_start(ap, message_format); 417585186ebdSMax Reitz message = g_strdup_vprintf(message_format, ap); 417685186ebdSMax Reitz va_end(ap); 417785186ebdSMax Reitz 417885186ebdSMax Reitz if (fatal) { 417985186ebdSMax Reitz fprintf(stderr, "qcow2: Marking image as corrupt: %s; further " 418085186ebdSMax Reitz "corruption events will be suppressed\n", message); 418185186ebdSMax Reitz } else { 418285186ebdSMax Reitz fprintf(stderr, "qcow2: Image is corrupt: %s; further non-fatal " 418385186ebdSMax Reitz "corruption events will be suppressed\n", message); 418485186ebdSMax Reitz } 418585186ebdSMax Reitz 4186dc881b44SAlberto Garcia node_name = bdrv_get_node_name(bs); 4187dc881b44SAlberto Garcia qapi_event_send_block_image_corrupted(bdrv_get_device_name(bs), 4188dc881b44SAlberto Garcia *node_name != '\0', node_name, 4189dc881b44SAlberto Garcia message, offset >= 0, offset, 4190dc881b44SAlberto Garcia size >= 0, size, 419185186ebdSMax Reitz fatal, &error_abort); 419285186ebdSMax Reitz g_free(message); 419385186ebdSMax Reitz 419485186ebdSMax Reitz if (fatal) { 419585186ebdSMax Reitz qcow2_mark_corrupt(bs); 419685186ebdSMax Reitz bs->drv = NULL; /* make BDS unusable */ 419785186ebdSMax Reitz } 419885186ebdSMax Reitz 419985186ebdSMax Reitz s->signaled_corruption = true; 420085186ebdSMax Reitz } 420185186ebdSMax Reitz 42021bd0e2d1SChunyan Liu static QemuOptsList qcow2_create_opts = { 42031bd0e2d1SChunyan Liu .name = "qcow2-create-opts", 42041bd0e2d1SChunyan Liu .head = QTAILQ_HEAD_INITIALIZER(qcow2_create_opts.head), 42051bd0e2d1SChunyan Liu .desc = { 420620d97356SBlue Swirl { 420720d97356SBlue Swirl .name = BLOCK_OPT_SIZE, 42081bd0e2d1SChunyan Liu .type = QEMU_OPT_SIZE, 420920d97356SBlue Swirl .help = "Virtual disk size" 421020d97356SBlue Swirl }, 421120d97356SBlue Swirl { 42126744cbabSKevin Wolf .name = BLOCK_OPT_COMPAT_LEVEL, 42131bd0e2d1SChunyan Liu .type = QEMU_OPT_STRING, 42146744cbabSKevin Wolf .help = "Compatibility level (0.10 or 1.1)" 42156744cbabSKevin Wolf }, 42166744cbabSKevin Wolf { 421720d97356SBlue Swirl .name = BLOCK_OPT_BACKING_FILE, 42181bd0e2d1SChunyan Liu .type = QEMU_OPT_STRING, 421920d97356SBlue Swirl .help = "File name of a base image" 422020d97356SBlue Swirl }, 422120d97356SBlue Swirl { 422220d97356SBlue Swirl .name = BLOCK_OPT_BACKING_FMT, 42231bd0e2d1SChunyan Liu .type = QEMU_OPT_STRING, 422420d97356SBlue Swirl .help = "Image format of the base image" 422520d97356SBlue Swirl }, 422620d97356SBlue Swirl { 422720d97356SBlue Swirl .name = BLOCK_OPT_ENCRYPT, 42281bd0e2d1SChunyan Liu .type = QEMU_OPT_BOOL, 42290cb8d47bSDaniel P. Berrange .help = "Encrypt the image with format 'aes'. (Deprecated " 42300cb8d47bSDaniel P. Berrange "in favor of " BLOCK_OPT_ENCRYPT_FORMAT "=aes)", 42310cb8d47bSDaniel P. Berrange }, 42320cb8d47bSDaniel P. Berrange { 42330cb8d47bSDaniel P. Berrange .name = BLOCK_OPT_ENCRYPT_FORMAT, 42340cb8d47bSDaniel P. Berrange .type = QEMU_OPT_STRING, 42354652b8f3SDaniel P. Berrange .help = "Encrypt the image, format choices: 'aes', 'luks'", 423620d97356SBlue Swirl }, 42374652b8f3SDaniel P. Berrange BLOCK_CRYPTO_OPT_DEF_KEY_SECRET("encrypt.", 42384652b8f3SDaniel P. Berrange "ID of secret providing qcow AES key or LUKS passphrase"), 42394652b8f3SDaniel P. Berrange BLOCK_CRYPTO_OPT_DEF_LUKS_CIPHER_ALG("encrypt."), 42404652b8f3SDaniel P. Berrange BLOCK_CRYPTO_OPT_DEF_LUKS_CIPHER_MODE("encrypt."), 42414652b8f3SDaniel P. Berrange BLOCK_CRYPTO_OPT_DEF_LUKS_IVGEN_ALG("encrypt."), 42424652b8f3SDaniel P. Berrange BLOCK_CRYPTO_OPT_DEF_LUKS_IVGEN_HASH_ALG("encrypt."), 42434652b8f3SDaniel P. Berrange BLOCK_CRYPTO_OPT_DEF_LUKS_HASH_ALG("encrypt."), 42444652b8f3SDaniel P. Berrange BLOCK_CRYPTO_OPT_DEF_LUKS_ITER_TIME("encrypt."), 424520d97356SBlue Swirl { 424620d97356SBlue Swirl .name = BLOCK_OPT_CLUSTER_SIZE, 42471bd0e2d1SChunyan Liu .type = QEMU_OPT_SIZE, 424899cce9faSKevin Wolf .help = "qcow2 cluster size", 42491bd0e2d1SChunyan Liu .def_value_str = stringify(DEFAULT_CLUSTER_SIZE) 425020d97356SBlue Swirl }, 425120d97356SBlue Swirl { 425220d97356SBlue Swirl .name = BLOCK_OPT_PREALLOC, 42531bd0e2d1SChunyan Liu .type = QEMU_OPT_STRING, 42540e4271b7SHu Tao .help = "Preallocation mode (allowed values: off, metadata, " 42550e4271b7SHu Tao "falloc, full)" 425620d97356SBlue Swirl }, 4257bfe8043eSStefan Hajnoczi { 4258bfe8043eSStefan Hajnoczi .name = BLOCK_OPT_LAZY_REFCOUNTS, 42591bd0e2d1SChunyan Liu .type = QEMU_OPT_BOOL, 4260bfe8043eSStefan Hajnoczi .help = "Postpone refcount updates", 42611bd0e2d1SChunyan Liu .def_value_str = "off" 4262bfe8043eSStefan Hajnoczi }, 426306d05fa7SMax Reitz { 426406d05fa7SMax Reitz .name = BLOCK_OPT_REFCOUNT_BITS, 426506d05fa7SMax Reitz .type = QEMU_OPT_NUMBER, 426606d05fa7SMax Reitz .help = "Width of a reference count entry in bits", 426706d05fa7SMax Reitz .def_value_str = "16" 426806d05fa7SMax Reitz }, 42691bd0e2d1SChunyan Liu { /* end of list */ } 42701bd0e2d1SChunyan Liu } 427120d97356SBlue Swirl }; 427220d97356SBlue Swirl 42735f535a94SMax Reitz BlockDriver bdrv_qcow2 = { 427420d97356SBlue Swirl .format_name = "qcow2", 4275ff99129aSKevin Wolf .instance_size = sizeof(BDRVQcow2State), 42767c80ab3fSJes Sorensen .bdrv_probe = qcow2_probe, 42777c80ab3fSJes Sorensen .bdrv_open = qcow2_open, 42787c80ab3fSJes Sorensen .bdrv_close = qcow2_close, 427921d82ac9SJeff Cody .bdrv_reopen_prepare = qcow2_reopen_prepare, 42805b0959a7SKevin Wolf .bdrv_reopen_commit = qcow2_reopen_commit, 42815b0959a7SKevin Wolf .bdrv_reopen_abort = qcow2_reopen_abort, 42825365f44dSKevin Wolf .bdrv_join_options = qcow2_join_options, 4283862f215fSKevin Wolf .bdrv_child_perm = bdrv_format_default_perms, 4284c282e1fdSChunyan Liu .bdrv_create = qcow2_create, 42853ac21627SPeter Lieven .bdrv_has_zero_init = bdrv_has_zero_init_1, 4286b6b8a333SPaolo Bonzini .bdrv_co_get_block_status = qcow2_co_get_block_status, 428720d97356SBlue Swirl 4288ecfe1863SKevin Wolf .bdrv_co_preadv = qcow2_co_preadv, 4289d46a0bb2SKevin Wolf .bdrv_co_pwritev = qcow2_co_pwritev, 4290eb489bb1SKevin Wolf .bdrv_co_flush_to_os = qcow2_co_flush_to_os, 4291419b19d9SStefan Hajnoczi 42925544b59fSEric Blake .bdrv_co_pwrite_zeroes = qcow2_co_pwrite_zeroes, 429382e8a788SEric Blake .bdrv_co_pdiscard = qcow2_co_pdiscard, 4294419b19d9SStefan Hajnoczi .bdrv_truncate = qcow2_truncate, 4295fcccefc5SPavel Butsykin .bdrv_co_pwritev_compressed = qcow2_co_pwritev_compressed, 4296491d27e2SMax Reitz .bdrv_make_empty = qcow2_make_empty, 429720d97356SBlue Swirl 429820d97356SBlue Swirl .bdrv_snapshot_create = qcow2_snapshot_create, 429920d97356SBlue Swirl .bdrv_snapshot_goto = qcow2_snapshot_goto, 430020d97356SBlue Swirl .bdrv_snapshot_delete = qcow2_snapshot_delete, 430120d97356SBlue Swirl .bdrv_snapshot_list = qcow2_snapshot_list, 430251ef6727Sedison .bdrv_snapshot_load_tmp = qcow2_snapshot_load_tmp, 4303c501c352SStefan Hajnoczi .bdrv_measure = qcow2_measure, 43047c80ab3fSJes Sorensen .bdrv_get_info = qcow2_get_info, 430537764dfbSMax Reitz .bdrv_get_specific_info = qcow2_get_specific_info, 430620d97356SBlue Swirl 43077c80ab3fSJes Sorensen .bdrv_save_vmstate = qcow2_save_vmstate, 43087c80ab3fSJes Sorensen .bdrv_load_vmstate = qcow2_load_vmstate, 430920d97356SBlue Swirl 43108ee79e70SKevin Wolf .supports_backing = true, 431120d97356SBlue Swirl .bdrv_change_backing_file = qcow2_change_backing_file, 431220d97356SBlue Swirl 4313d34682cdSKevin Wolf .bdrv_refresh_limits = qcow2_refresh_limits, 431406d9260fSAnthony Liguori .bdrv_invalidate_cache = qcow2_invalidate_cache, 4315ec6d8912SKevin Wolf .bdrv_inactivate = qcow2_inactivate, 431606d9260fSAnthony Liguori 43171bd0e2d1SChunyan Liu .create_opts = &qcow2_create_opts, 43187c80ab3fSJes Sorensen .bdrv_check = qcow2_check, 4319c282e1fdSChunyan Liu .bdrv_amend_options = qcow2_amend_options, 4320279621c0SAlberto Garcia 4321279621c0SAlberto Garcia .bdrv_detach_aio_context = qcow2_detach_aio_context, 4322279621c0SAlberto Garcia .bdrv_attach_aio_context = qcow2_attach_aio_context, 43231b6b0562SVladimir Sementsov-Ogievskiy 43241b6b0562SVladimir Sementsov-Ogievskiy .bdrv_reopen_bitmaps_rw = qcow2_reopen_bitmaps_rw, 4325da0eb242SVladimir Sementsov-Ogievskiy .bdrv_can_store_new_dirty_bitmap = qcow2_can_store_new_dirty_bitmap, 4326469c71edSVladimir Sementsov-Ogievskiy .bdrv_remove_persistent_dirty_bitmap = qcow2_remove_persistent_dirty_bitmap, 432720d97356SBlue Swirl }; 432820d97356SBlue Swirl 43295efa9d5aSAnthony Liguori static void bdrv_qcow2_init(void) 43305efa9d5aSAnthony Liguori { 43315efa9d5aSAnthony Liguori bdrv_register(&bdrv_qcow2); 43325efa9d5aSAnthony Liguori } 43335efa9d5aSAnthony Liguori 43345efa9d5aSAnthony Liguori block_init(bdrv_qcow2_init); 4335