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