xref: /qemu/block/qcow2.c (revision c3a8fe331eb4310e2d058f1c15a817d255840323)
1585f8587Sbellard /*
2585f8587Sbellard  * Block driver for the QCOW version 2 format
3585f8587Sbellard  *
4585f8587Sbellard  * Copyright (c) 2004-2006 Fabrice Bellard
5585f8587Sbellard  *
6585f8587Sbellard  * Permission is hereby granted, free of charge, to any person obtaining a copy
7585f8587Sbellard  * of this software and associated documentation files (the "Software"), to deal
8585f8587Sbellard  * in the Software without restriction, including without limitation the rights
9585f8587Sbellard  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10585f8587Sbellard  * copies of the Software, and to permit persons to whom the Software is
11585f8587Sbellard  * furnished to do so, subject to the following conditions:
12585f8587Sbellard  *
13585f8587Sbellard  * The above copyright notice and this permission notice shall be included in
14585f8587Sbellard  * all copies or substantial portions of the Software.
15585f8587Sbellard  *
16585f8587Sbellard  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17585f8587Sbellard  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18585f8587Sbellard  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19585f8587Sbellard  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20585f8587Sbellard  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21585f8587Sbellard  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22585f8587Sbellard  * THE SOFTWARE.
23585f8587Sbellard  */
2480c71a24SPeter Maydell #include "qemu/osdep.h"
25737e150eSPaolo Bonzini #include "block/block_int.h"
2623588797SKevin Wolf #include "sysemu/block-backend.h"
271de7afc9SPaolo Bonzini #include "qemu/module.h"
28585f8587Sbellard #include <zlib.h>
29f7d0fe02SKevin Wolf #include "block/qcow2.h"
301de7afc9SPaolo Bonzini #include "qemu/error-report.h"
317b1b5d19SPaolo Bonzini #include "qapi/qmp/qerror.h"
32acdfb480SKevin Wolf #include "qapi/qmp/qbool.h"
33ffeaac9bSHu Tao #include "qapi/util.h"
3485186ebdSMax Reitz #include "qapi/qmp/types.h"
3585186ebdSMax Reitz #include "qapi-event.h"
363cce16f4SKevin Wolf #include "trace.h"
371bd0e2d1SChunyan Liu #include "qemu/option_int.h"
38f348b6d1SVeronia Bahaa #include "qemu/cutils.h"
3958369e22SPaolo Bonzini #include "qemu/bswap.h"
40b25b387fSDaniel P. Berrange #include "qapi/opts-visitor.h"
41b25b387fSDaniel P. Berrange #include "qapi-visit.h"
42b25b387fSDaniel P. Berrange #include "block/crypto.h"
43585f8587Sbellard 
44585f8587Sbellard /*
45585f8587Sbellard   Differences with QCOW:
46585f8587Sbellard 
47585f8587Sbellard   - Support for multiple incremental snapshots.
48585f8587Sbellard   - Memory management by reference counts.
49585f8587Sbellard   - Clusters which have a reference count of one have the bit
50585f8587Sbellard     QCOW_OFLAG_COPIED to optimize write performance.
51585f8587Sbellard   - Size of compressed clusters is stored in sectors to reduce bit usage
52585f8587Sbellard     in the cluster offsets.
53585f8587Sbellard   - Support for storing additional data (such as the VM state) in the
54585f8587Sbellard     snapshots.
55585f8587Sbellard   - If a backing store is used, the cluster size is not constrained
56585f8587Sbellard     (could be backported to QCOW).
57585f8587Sbellard   - L2 tables have always a size of one cluster.
58585f8587Sbellard */
59585f8587Sbellard 
609b80ddf3Saliguori 
619b80ddf3Saliguori typedef struct {
629b80ddf3Saliguori     uint32_t magic;
639b80ddf3Saliguori     uint32_t len;
64c4217f64SJeff Cody } QEMU_PACKED QCowExtension;
6521d82ac9SJeff Cody 
667c80ab3fSJes Sorensen #define  QCOW2_EXT_MAGIC_END 0
677c80ab3fSJes Sorensen #define  QCOW2_EXT_MAGIC_BACKING_FORMAT 0xE2792ACA
68cfcc4c62SKevin Wolf #define  QCOW2_EXT_MAGIC_FEATURE_TABLE 0x6803f857
694652b8f3SDaniel P. Berrange #define  QCOW2_EXT_MAGIC_CRYPTO_HEADER 0x0537be77
7088ddffaeSVladimir Sementsov-Ogievskiy #define  QCOW2_EXT_MAGIC_BITMAPS 0x23852875
719b80ddf3Saliguori 
727c80ab3fSJes Sorensen static int qcow2_probe(const uint8_t *buf, int buf_size, const char *filename)
73585f8587Sbellard {
74585f8587Sbellard     const QCowHeader *cow_header = (const void *)buf;
75585f8587Sbellard 
76585f8587Sbellard     if (buf_size >= sizeof(QCowHeader) &&
77585f8587Sbellard         be32_to_cpu(cow_header->magic) == QCOW_MAGIC &&
786744cbabSKevin Wolf         be32_to_cpu(cow_header->version) >= 2)
79585f8587Sbellard         return 100;
80585f8587Sbellard     else
81585f8587Sbellard         return 0;
82585f8587Sbellard }
83585f8587Sbellard 
849b80ddf3Saliguori 
854652b8f3SDaniel P. Berrange static ssize_t qcow2_crypto_hdr_read_func(QCryptoBlock *block, size_t offset,
864652b8f3SDaniel P. Berrange                                           uint8_t *buf, size_t buflen,
874652b8f3SDaniel P. Berrange                                           void *opaque, Error **errp)
884652b8f3SDaniel P. Berrange {
894652b8f3SDaniel P. Berrange     BlockDriverState *bs = opaque;
904652b8f3SDaniel P. Berrange     BDRVQcow2State *s = bs->opaque;
914652b8f3SDaniel P. Berrange     ssize_t ret;
924652b8f3SDaniel P. Berrange 
934652b8f3SDaniel P. Berrange     if ((offset + buflen) > s->crypto_header.length) {
944652b8f3SDaniel P. Berrange         error_setg(errp, "Request for data outside of extension header");
954652b8f3SDaniel P. Berrange         return -1;
964652b8f3SDaniel P. Berrange     }
974652b8f3SDaniel P. Berrange 
984652b8f3SDaniel P. Berrange     ret = bdrv_pread(bs->file,
994652b8f3SDaniel P. Berrange                      s->crypto_header.offset + offset, buf, buflen);
1004652b8f3SDaniel P. Berrange     if (ret < 0) {
1014652b8f3SDaniel P. Berrange         error_setg_errno(errp, -ret, "Could not read encryption header");
1024652b8f3SDaniel P. Berrange         return -1;
1034652b8f3SDaniel P. Berrange     }
1044652b8f3SDaniel P. Berrange     return ret;
1054652b8f3SDaniel P. Berrange }
1064652b8f3SDaniel P. Berrange 
1074652b8f3SDaniel P. Berrange 
1084652b8f3SDaniel P. Berrange static ssize_t qcow2_crypto_hdr_init_func(QCryptoBlock *block, size_t headerlen,
1094652b8f3SDaniel P. Berrange                                           void *opaque, Error **errp)
1104652b8f3SDaniel P. Berrange {
1114652b8f3SDaniel P. Berrange     BlockDriverState *bs = opaque;
1124652b8f3SDaniel P. Berrange     BDRVQcow2State *s = bs->opaque;
1134652b8f3SDaniel P. Berrange     int64_t ret;
1144652b8f3SDaniel P. Berrange     int64_t clusterlen;
1154652b8f3SDaniel P. Berrange 
1164652b8f3SDaniel P. Berrange     ret = qcow2_alloc_clusters(bs, headerlen);
1174652b8f3SDaniel P. Berrange     if (ret < 0) {
1184652b8f3SDaniel P. Berrange         error_setg_errno(errp, -ret,
1194652b8f3SDaniel P. Berrange                          "Cannot allocate cluster for LUKS header size %zu",
1204652b8f3SDaniel P. Berrange                          headerlen);
1214652b8f3SDaniel P. Berrange         return -1;
1224652b8f3SDaniel P. Berrange     }
1234652b8f3SDaniel P. Berrange 
1244652b8f3SDaniel P. Berrange     s->crypto_header.length = headerlen;
1254652b8f3SDaniel P. Berrange     s->crypto_header.offset = ret;
1264652b8f3SDaniel P. Berrange 
1274652b8f3SDaniel P. Berrange     /* Zero fill remaining space in cluster so it has predictable
1284652b8f3SDaniel P. Berrange      * content in case of future spec changes */
1294652b8f3SDaniel P. Berrange     clusterlen = size_to_clusters(s, headerlen) * s->cluster_size;
1304652b8f3SDaniel P. Berrange     ret = bdrv_pwrite_zeroes(bs->file,
1314652b8f3SDaniel P. Berrange                              ret + headerlen,
1324652b8f3SDaniel P. Berrange                              clusterlen - headerlen, 0);
1334652b8f3SDaniel P. Berrange     if (ret < 0) {
1344652b8f3SDaniel P. Berrange         error_setg_errno(errp, -ret, "Could not zero fill encryption header");
1354652b8f3SDaniel P. Berrange         return -1;
1364652b8f3SDaniel P. Berrange     }
1374652b8f3SDaniel P. Berrange 
1384652b8f3SDaniel P. Berrange     return ret;
1394652b8f3SDaniel P. Berrange }
1404652b8f3SDaniel P. Berrange 
1414652b8f3SDaniel P. Berrange 
1424652b8f3SDaniel P. Berrange static ssize_t qcow2_crypto_hdr_write_func(QCryptoBlock *block, size_t offset,
1434652b8f3SDaniel P. Berrange                                            const uint8_t *buf, size_t buflen,
1444652b8f3SDaniel P. Berrange                                            void *opaque, Error **errp)
1454652b8f3SDaniel P. Berrange {
1464652b8f3SDaniel P. Berrange     BlockDriverState *bs = opaque;
1474652b8f3SDaniel P. Berrange     BDRVQcow2State *s = bs->opaque;
1484652b8f3SDaniel P. Berrange     ssize_t ret;
1494652b8f3SDaniel P. Berrange 
1504652b8f3SDaniel P. Berrange     if ((offset + buflen) > s->crypto_header.length) {
1514652b8f3SDaniel P. Berrange         error_setg(errp, "Request for data outside of extension header");
1524652b8f3SDaniel P. Berrange         return -1;
1534652b8f3SDaniel P. Berrange     }
1544652b8f3SDaniel P. Berrange 
1554652b8f3SDaniel P. Berrange     ret = bdrv_pwrite(bs->file,
1564652b8f3SDaniel P. Berrange                       s->crypto_header.offset + offset, buf, buflen);
1574652b8f3SDaniel P. Berrange     if (ret < 0) {
1584652b8f3SDaniel P. Berrange         error_setg_errno(errp, -ret, "Could not read encryption header");
1594652b8f3SDaniel P. Berrange         return -1;
1604652b8f3SDaniel P. Berrange     }
1614652b8f3SDaniel P. Berrange     return ret;
1624652b8f3SDaniel P. Berrange }
1634652b8f3SDaniel P. Berrange 
1644652b8f3SDaniel P. Berrange 
1659b80ddf3Saliguori /*
1669b80ddf3Saliguori  * read qcow2 extension and fill bs
1679b80ddf3Saliguori  * start reading from start_offset
1689b80ddf3Saliguori  * finish reading upon magic of value 0 or when end_offset reached
1699b80ddf3Saliguori  * unknown magic is skipped (future extension this version knows nothing about)
1709b80ddf3Saliguori  * return 0 upon success, non-0 otherwise
1719b80ddf3Saliguori  */
1727c80ab3fSJes Sorensen static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
1733ef6c40aSMax Reitz                                  uint64_t end_offset, void **p_feature_table,
17488ddffaeSVladimir Sementsov-Ogievskiy                                  int flags, bool *need_update_header,
17588ddffaeSVladimir Sementsov-Ogievskiy                                  Error **errp)
1769b80ddf3Saliguori {
177ff99129aSKevin Wolf     BDRVQcow2State *s = bs->opaque;
1789b80ddf3Saliguori     QCowExtension ext;
1799b80ddf3Saliguori     uint64_t offset;
18075bab85cSKevin Wolf     int ret;
18188ddffaeSVladimir Sementsov-Ogievskiy     Qcow2BitmapHeaderExt bitmaps_ext;
18288ddffaeSVladimir Sementsov-Ogievskiy 
18388ddffaeSVladimir Sementsov-Ogievskiy     if (need_update_header != NULL) {
18488ddffaeSVladimir Sementsov-Ogievskiy         *need_update_header = false;
18588ddffaeSVladimir Sementsov-Ogievskiy     }
1869b80ddf3Saliguori 
1879b80ddf3Saliguori #ifdef DEBUG_EXT
1887c80ab3fSJes Sorensen     printf("qcow2_read_extensions: start=%ld end=%ld\n", start_offset, end_offset);
1899b80ddf3Saliguori #endif
1909b80ddf3Saliguori     offset = start_offset;
1919b80ddf3Saliguori     while (offset < end_offset) {
1929b80ddf3Saliguori 
1939b80ddf3Saliguori #ifdef DEBUG_EXT
1949b80ddf3Saliguori         /* Sanity check */
1959b80ddf3Saliguori         if (offset > s->cluster_size)
1967c80ab3fSJes Sorensen             printf("qcow2_read_extension: suspicious offset %lu\n", offset);
1979b80ddf3Saliguori 
1989b2260cbSDong Xu Wang         printf("attempting to read extended header in offset %lu\n", offset);
1999b80ddf3Saliguori #endif
2009b80ddf3Saliguori 
201cf2ab8fcSKevin Wolf         ret = bdrv_pread(bs->file, offset, &ext, sizeof(ext));
2023ef6c40aSMax Reitz         if (ret < 0) {
2033ef6c40aSMax Reitz             error_setg_errno(errp, -ret, "qcow2_read_extension: ERROR: "
2043ef6c40aSMax Reitz                              "pread fail from offset %" PRIu64, offset);
2059b80ddf3Saliguori             return 1;
2069b80ddf3Saliguori         }
2079b80ddf3Saliguori         be32_to_cpus(&ext.magic);
2089b80ddf3Saliguori         be32_to_cpus(&ext.len);
2099b80ddf3Saliguori         offset += sizeof(ext);
2109b80ddf3Saliguori #ifdef DEBUG_EXT
2119b80ddf3Saliguori         printf("ext.magic = 0x%x\n", ext.magic);
2129b80ddf3Saliguori #endif
2132ebafc85SKevin Wolf         if (offset > end_offset || ext.len > end_offset - offset) {
2143ef6c40aSMax Reitz             error_setg(errp, "Header extension too large");
21564ca6aeeSKevin Wolf             return -EINVAL;
21664ca6aeeSKevin Wolf         }
21764ca6aeeSKevin Wolf 
2189b80ddf3Saliguori         switch (ext.magic) {
2197c80ab3fSJes Sorensen         case QCOW2_EXT_MAGIC_END:
2209b80ddf3Saliguori             return 0;
221f965509cSaliguori 
2227c80ab3fSJes Sorensen         case QCOW2_EXT_MAGIC_BACKING_FORMAT:
223f965509cSaliguori             if (ext.len >= sizeof(bs->backing_format)) {
224521b2b5dSMax Reitz                 error_setg(errp, "ERROR: ext_backing_format: len=%" PRIu32
225521b2b5dSMax Reitz                            " too large (>=%zu)", ext.len,
226521b2b5dSMax Reitz                            sizeof(bs->backing_format));
227f965509cSaliguori                 return 2;
228f965509cSaliguori             }
229cf2ab8fcSKevin Wolf             ret = bdrv_pread(bs->file, offset, bs->backing_format, ext.len);
2303ef6c40aSMax Reitz             if (ret < 0) {
2313ef6c40aSMax Reitz                 error_setg_errno(errp, -ret, "ERROR: ext_backing_format: "
2323ef6c40aSMax Reitz                                  "Could not read format name");
233f965509cSaliguori                 return 3;
2343ef6c40aSMax Reitz             }
235f965509cSaliguori             bs->backing_format[ext.len] = '\0';
236e4603fe1SKevin Wolf             s->image_backing_format = g_strdup(bs->backing_format);
237f965509cSaliguori #ifdef DEBUG_EXT
238f965509cSaliguori             printf("Qcow2: Got format extension %s\n", bs->backing_format);
239f965509cSaliguori #endif
240f965509cSaliguori             break;
241f965509cSaliguori 
242cfcc4c62SKevin Wolf         case QCOW2_EXT_MAGIC_FEATURE_TABLE:
243cfcc4c62SKevin Wolf             if (p_feature_table != NULL) {
244cfcc4c62SKevin Wolf                 void* feature_table = g_malloc0(ext.len + 2 * sizeof(Qcow2Feature));
245cf2ab8fcSKevin Wolf                 ret = bdrv_pread(bs->file, offset , feature_table, ext.len);
246cfcc4c62SKevin Wolf                 if (ret < 0) {
2473ef6c40aSMax Reitz                     error_setg_errno(errp, -ret, "ERROR: ext_feature_table: "
2483ef6c40aSMax Reitz                                      "Could not read table");
249cfcc4c62SKevin Wolf                     return ret;
250cfcc4c62SKevin Wolf                 }
251cfcc4c62SKevin Wolf 
252cfcc4c62SKevin Wolf                 *p_feature_table = feature_table;
253cfcc4c62SKevin Wolf             }
254cfcc4c62SKevin Wolf             break;
255cfcc4c62SKevin Wolf 
2564652b8f3SDaniel P. Berrange         case QCOW2_EXT_MAGIC_CRYPTO_HEADER: {
2574652b8f3SDaniel P. Berrange             unsigned int cflags = 0;
2584652b8f3SDaniel P. Berrange             if (s->crypt_method_header != QCOW_CRYPT_LUKS) {
2594652b8f3SDaniel P. Berrange                 error_setg(errp, "CRYPTO header extension only "
2604652b8f3SDaniel P. Berrange                            "expected with LUKS encryption method");
2614652b8f3SDaniel P. Berrange                 return -EINVAL;
2624652b8f3SDaniel P. Berrange             }
2634652b8f3SDaniel P. Berrange             if (ext.len != sizeof(Qcow2CryptoHeaderExtension)) {
2644652b8f3SDaniel P. Berrange                 error_setg(errp, "CRYPTO header extension size %u, "
2654652b8f3SDaniel P. Berrange                            "but expected size %zu", ext.len,
2664652b8f3SDaniel P. Berrange                            sizeof(Qcow2CryptoHeaderExtension));
2674652b8f3SDaniel P. Berrange                 return -EINVAL;
2684652b8f3SDaniel P. Berrange             }
2694652b8f3SDaniel P. Berrange 
2704652b8f3SDaniel P. Berrange             ret = bdrv_pread(bs->file, offset, &s->crypto_header, ext.len);
2714652b8f3SDaniel P. Berrange             if (ret < 0) {
2724652b8f3SDaniel P. Berrange                 error_setg_errno(errp, -ret,
2734652b8f3SDaniel P. Berrange                                  "Unable to read CRYPTO header extension");
2744652b8f3SDaniel P. Berrange                 return ret;
2754652b8f3SDaniel P. Berrange             }
2764652b8f3SDaniel P. Berrange             be64_to_cpus(&s->crypto_header.offset);
2774652b8f3SDaniel P. Berrange             be64_to_cpus(&s->crypto_header.length);
2784652b8f3SDaniel P. Berrange 
2794652b8f3SDaniel P. Berrange             if ((s->crypto_header.offset % s->cluster_size) != 0) {
2804652b8f3SDaniel P. Berrange                 error_setg(errp, "Encryption header offset '%" PRIu64 "' is "
2814652b8f3SDaniel P. Berrange                            "not a multiple of cluster size '%u'",
2824652b8f3SDaniel P. Berrange                            s->crypto_header.offset, s->cluster_size);
2834652b8f3SDaniel P. Berrange                 return -EINVAL;
2844652b8f3SDaniel P. Berrange             }
2854652b8f3SDaniel P. Berrange 
2864652b8f3SDaniel P. Berrange             if (flags & BDRV_O_NO_IO) {
2874652b8f3SDaniel P. Berrange                 cflags |= QCRYPTO_BLOCK_OPEN_NO_IO;
2884652b8f3SDaniel P. Berrange             }
2891cd9a787SDaniel P. Berrange             s->crypto = qcrypto_block_open(s->crypto_opts, "encrypt.",
2904652b8f3SDaniel P. Berrange                                            qcow2_crypto_hdr_read_func,
2914652b8f3SDaniel P. Berrange                                            bs, cflags, errp);
2924652b8f3SDaniel P. Berrange             if (!s->crypto) {
2934652b8f3SDaniel P. Berrange                 return -EINVAL;
2944652b8f3SDaniel P. Berrange             }
2954652b8f3SDaniel P. Berrange         }   break;
2964652b8f3SDaniel P. Berrange 
29788ddffaeSVladimir Sementsov-Ogievskiy         case QCOW2_EXT_MAGIC_BITMAPS:
29888ddffaeSVladimir Sementsov-Ogievskiy             if (ext.len != sizeof(bitmaps_ext)) {
29988ddffaeSVladimir Sementsov-Ogievskiy                 error_setg_errno(errp, -ret, "bitmaps_ext: "
30088ddffaeSVladimir Sementsov-Ogievskiy                                  "Invalid extension length");
30188ddffaeSVladimir Sementsov-Ogievskiy                 return -EINVAL;
30288ddffaeSVladimir Sementsov-Ogievskiy             }
30388ddffaeSVladimir Sementsov-Ogievskiy 
30488ddffaeSVladimir Sementsov-Ogievskiy             if (!(s->autoclear_features & QCOW2_AUTOCLEAR_BITMAPS)) {
30588ddffaeSVladimir Sementsov-Ogievskiy                 error_report("WARNING: a program lacking bitmap support "
30688ddffaeSVladimir Sementsov-Ogievskiy                              "modified this file, so all bitmaps are now "
30788ddffaeSVladimir Sementsov-Ogievskiy                              "considered inconsistent. Some clusters may be "
30888ddffaeSVladimir Sementsov-Ogievskiy                              "leaked, run 'qemu-img check -r' on the image "
30988ddffaeSVladimir Sementsov-Ogievskiy                              "file to fix.");
31088ddffaeSVladimir Sementsov-Ogievskiy                 if (need_update_header != NULL) {
31188ddffaeSVladimir Sementsov-Ogievskiy                     /* Updating is needed to drop invalid bitmap extension. */
31288ddffaeSVladimir Sementsov-Ogievskiy                     *need_update_header = true;
31388ddffaeSVladimir Sementsov-Ogievskiy                 }
31488ddffaeSVladimir Sementsov-Ogievskiy                 break;
31588ddffaeSVladimir Sementsov-Ogievskiy             }
31688ddffaeSVladimir Sementsov-Ogievskiy 
31788ddffaeSVladimir Sementsov-Ogievskiy             ret = bdrv_pread(bs->file, offset, &bitmaps_ext, ext.len);
31888ddffaeSVladimir Sementsov-Ogievskiy             if (ret < 0) {
31988ddffaeSVladimir Sementsov-Ogievskiy                 error_setg_errno(errp, -ret, "bitmaps_ext: "
32088ddffaeSVladimir Sementsov-Ogievskiy                                  "Could not read ext header");
32188ddffaeSVladimir Sementsov-Ogievskiy                 return ret;
32288ddffaeSVladimir Sementsov-Ogievskiy             }
32388ddffaeSVladimir Sementsov-Ogievskiy 
32488ddffaeSVladimir Sementsov-Ogievskiy             if (bitmaps_ext.reserved32 != 0) {
32588ddffaeSVladimir Sementsov-Ogievskiy                 error_setg_errno(errp, -ret, "bitmaps_ext: "
32688ddffaeSVladimir Sementsov-Ogievskiy                                  "Reserved field is not zero");
32788ddffaeSVladimir Sementsov-Ogievskiy                 return -EINVAL;
32888ddffaeSVladimir Sementsov-Ogievskiy             }
32988ddffaeSVladimir Sementsov-Ogievskiy 
33088ddffaeSVladimir Sementsov-Ogievskiy             be32_to_cpus(&bitmaps_ext.nb_bitmaps);
33188ddffaeSVladimir Sementsov-Ogievskiy             be64_to_cpus(&bitmaps_ext.bitmap_directory_size);
33288ddffaeSVladimir Sementsov-Ogievskiy             be64_to_cpus(&bitmaps_ext.bitmap_directory_offset);
33388ddffaeSVladimir Sementsov-Ogievskiy 
33488ddffaeSVladimir Sementsov-Ogievskiy             if (bitmaps_ext.nb_bitmaps > QCOW2_MAX_BITMAPS) {
33588ddffaeSVladimir Sementsov-Ogievskiy                 error_setg(errp,
33688ddffaeSVladimir Sementsov-Ogievskiy                            "bitmaps_ext: Image has %" PRIu32 " bitmaps, "
33788ddffaeSVladimir Sementsov-Ogievskiy                            "exceeding the QEMU supported maximum of %d",
33888ddffaeSVladimir Sementsov-Ogievskiy                            bitmaps_ext.nb_bitmaps, QCOW2_MAX_BITMAPS);
33988ddffaeSVladimir Sementsov-Ogievskiy                 return -EINVAL;
34088ddffaeSVladimir Sementsov-Ogievskiy             }
34188ddffaeSVladimir Sementsov-Ogievskiy 
34288ddffaeSVladimir Sementsov-Ogievskiy             if (bitmaps_ext.nb_bitmaps == 0) {
34388ddffaeSVladimir Sementsov-Ogievskiy                 error_setg(errp, "found bitmaps extension with zero bitmaps");
34488ddffaeSVladimir Sementsov-Ogievskiy                 return -EINVAL;
34588ddffaeSVladimir Sementsov-Ogievskiy             }
34688ddffaeSVladimir Sementsov-Ogievskiy 
34788ddffaeSVladimir Sementsov-Ogievskiy             if (bitmaps_ext.bitmap_directory_offset & (s->cluster_size - 1)) {
34888ddffaeSVladimir Sementsov-Ogievskiy                 error_setg(errp, "bitmaps_ext: "
34988ddffaeSVladimir Sementsov-Ogievskiy                                  "invalid bitmap directory offset");
35088ddffaeSVladimir Sementsov-Ogievskiy                 return -EINVAL;
35188ddffaeSVladimir Sementsov-Ogievskiy             }
35288ddffaeSVladimir Sementsov-Ogievskiy 
35388ddffaeSVladimir Sementsov-Ogievskiy             if (bitmaps_ext.bitmap_directory_size >
35488ddffaeSVladimir Sementsov-Ogievskiy                 QCOW2_MAX_BITMAP_DIRECTORY_SIZE) {
35588ddffaeSVladimir Sementsov-Ogievskiy                 error_setg(errp, "bitmaps_ext: "
35688ddffaeSVladimir Sementsov-Ogievskiy                                  "bitmap directory size (%" PRIu64 ") exceeds "
35788ddffaeSVladimir Sementsov-Ogievskiy                                  "the maximum supported size (%d)",
35888ddffaeSVladimir Sementsov-Ogievskiy                                  bitmaps_ext.bitmap_directory_size,
35988ddffaeSVladimir Sementsov-Ogievskiy                                  QCOW2_MAX_BITMAP_DIRECTORY_SIZE);
36088ddffaeSVladimir Sementsov-Ogievskiy                 return -EINVAL;
36188ddffaeSVladimir Sementsov-Ogievskiy             }
36288ddffaeSVladimir Sementsov-Ogievskiy 
36388ddffaeSVladimir Sementsov-Ogievskiy             s->nb_bitmaps = bitmaps_ext.nb_bitmaps;
36488ddffaeSVladimir Sementsov-Ogievskiy             s->bitmap_directory_offset =
36588ddffaeSVladimir Sementsov-Ogievskiy                     bitmaps_ext.bitmap_directory_offset;
36688ddffaeSVladimir Sementsov-Ogievskiy             s->bitmap_directory_size =
36788ddffaeSVladimir Sementsov-Ogievskiy                     bitmaps_ext.bitmap_directory_size;
36888ddffaeSVladimir Sementsov-Ogievskiy 
36988ddffaeSVladimir Sementsov-Ogievskiy #ifdef DEBUG_EXT
37088ddffaeSVladimir Sementsov-Ogievskiy             printf("Qcow2: Got bitmaps extension: "
37188ddffaeSVladimir Sementsov-Ogievskiy                    "offset=%" PRIu64 " nb_bitmaps=%" PRIu32 "\n",
37288ddffaeSVladimir Sementsov-Ogievskiy                    s->bitmap_directory_offset, s->nb_bitmaps);
37388ddffaeSVladimir Sementsov-Ogievskiy #endif
37488ddffaeSVladimir Sementsov-Ogievskiy             break;
37588ddffaeSVladimir Sementsov-Ogievskiy 
3769b80ddf3Saliguori         default:
37775bab85cSKevin Wolf             /* unknown magic - save it in case we need to rewrite the header */
37875bab85cSKevin Wolf             {
37975bab85cSKevin Wolf                 Qcow2UnknownHeaderExtension *uext;
38075bab85cSKevin Wolf 
38175bab85cSKevin Wolf                 uext = g_malloc0(sizeof(*uext)  + ext.len);
38275bab85cSKevin Wolf                 uext->magic = ext.magic;
38375bab85cSKevin Wolf                 uext->len = ext.len;
38475bab85cSKevin Wolf                 QLIST_INSERT_HEAD(&s->unknown_header_ext, uext, next);
38575bab85cSKevin Wolf 
386cf2ab8fcSKevin Wolf                 ret = bdrv_pread(bs->file, offset , uext->data, uext->len);
38775bab85cSKevin Wolf                 if (ret < 0) {
3883ef6c40aSMax Reitz                     error_setg_errno(errp, -ret, "ERROR: unknown extension: "
3893ef6c40aSMax Reitz                                      "Could not read data");
39075bab85cSKevin Wolf                     return ret;
39175bab85cSKevin Wolf                 }
39275bab85cSKevin Wolf             }
3939b80ddf3Saliguori             break;
3949b80ddf3Saliguori         }
395fd29b4bbSKevin Wolf 
396fd29b4bbSKevin Wolf         offset += ((ext.len + 7) & ~7);
3979b80ddf3Saliguori     }
3989b80ddf3Saliguori 
3999b80ddf3Saliguori     return 0;
4009b80ddf3Saliguori }
4019b80ddf3Saliguori 
40275bab85cSKevin Wolf static void cleanup_unknown_header_ext(BlockDriverState *bs)
40375bab85cSKevin Wolf {
404ff99129aSKevin Wolf     BDRVQcow2State *s = bs->opaque;
40575bab85cSKevin Wolf     Qcow2UnknownHeaderExtension *uext, *next;
40675bab85cSKevin Wolf 
40775bab85cSKevin Wolf     QLIST_FOREACH_SAFE(uext, &s->unknown_header_ext, next, next) {
40875bab85cSKevin Wolf         QLIST_REMOVE(uext, next);
40975bab85cSKevin Wolf         g_free(uext);
41075bab85cSKevin Wolf     }
41175bab85cSKevin Wolf }
4129b80ddf3Saliguori 
413a55448b3SMax Reitz static void report_unsupported_feature(Error **errp, Qcow2Feature *table,
414a55448b3SMax Reitz                                        uint64_t mask)
415cfcc4c62SKevin Wolf {
41612ac6d3dSKevin Wolf     char *features = g_strdup("");
41712ac6d3dSKevin Wolf     char *old;
41812ac6d3dSKevin Wolf 
419cfcc4c62SKevin Wolf     while (table && table->name[0] != '\0') {
420cfcc4c62SKevin Wolf         if (table->type == QCOW2_FEAT_TYPE_INCOMPATIBLE) {
42112ac6d3dSKevin Wolf             if (mask & (1ULL << table->bit)) {
42212ac6d3dSKevin Wolf                 old = features;
42312ac6d3dSKevin Wolf                 features = g_strdup_printf("%s%s%.46s", old, *old ? ", " : "",
42412ac6d3dSKevin Wolf                                            table->name);
42512ac6d3dSKevin Wolf                 g_free(old);
42612ac6d3dSKevin Wolf                 mask &= ~(1ULL << table->bit);
427cfcc4c62SKevin Wolf             }
428cfcc4c62SKevin Wolf         }
429cfcc4c62SKevin Wolf         table++;
430cfcc4c62SKevin Wolf     }
431cfcc4c62SKevin Wolf 
432cfcc4c62SKevin Wolf     if (mask) {
43312ac6d3dSKevin Wolf         old = features;
43412ac6d3dSKevin Wolf         features = g_strdup_printf("%s%sUnknown incompatible feature: %" PRIx64,
43512ac6d3dSKevin Wolf                                    old, *old ? ", " : "", mask);
43612ac6d3dSKevin Wolf         g_free(old);
437cfcc4c62SKevin Wolf     }
43812ac6d3dSKevin Wolf 
439a55448b3SMax Reitz     error_setg(errp, "Unsupported qcow2 feature(s): %s", features);
44012ac6d3dSKevin Wolf     g_free(features);
441cfcc4c62SKevin Wolf }
442cfcc4c62SKevin Wolf 
443c61d0004SStefan Hajnoczi /*
444bfe8043eSStefan Hajnoczi  * Sets the dirty bit and flushes afterwards if necessary.
445bfe8043eSStefan Hajnoczi  *
446bfe8043eSStefan Hajnoczi  * The incompatible_features bit is only set if the image file header was
447bfe8043eSStefan Hajnoczi  * updated successfully.  Therefore it is not required to check the return
448bfe8043eSStefan Hajnoczi  * value of this function.
449bfe8043eSStefan Hajnoczi  */
450280d3735SKevin Wolf int qcow2_mark_dirty(BlockDriverState *bs)
451bfe8043eSStefan Hajnoczi {
452ff99129aSKevin Wolf     BDRVQcow2State *s = bs->opaque;
453bfe8043eSStefan Hajnoczi     uint64_t val;
454bfe8043eSStefan Hajnoczi     int ret;
455bfe8043eSStefan Hajnoczi 
456bfe8043eSStefan Hajnoczi     assert(s->qcow_version >= 3);
457bfe8043eSStefan Hajnoczi 
458bfe8043eSStefan Hajnoczi     if (s->incompatible_features & QCOW2_INCOMPAT_DIRTY) {
459bfe8043eSStefan Hajnoczi         return 0; /* already dirty */
460bfe8043eSStefan Hajnoczi     }
461bfe8043eSStefan Hajnoczi 
462bfe8043eSStefan Hajnoczi     val = cpu_to_be64(s->incompatible_features | QCOW2_INCOMPAT_DIRTY);
463d9ca2ea2SKevin Wolf     ret = bdrv_pwrite(bs->file, offsetof(QCowHeader, incompatible_features),
464bfe8043eSStefan Hajnoczi                       &val, sizeof(val));
465bfe8043eSStefan Hajnoczi     if (ret < 0) {
466bfe8043eSStefan Hajnoczi         return ret;
467bfe8043eSStefan Hajnoczi     }
4689a4f4c31SKevin Wolf     ret = bdrv_flush(bs->file->bs);
469bfe8043eSStefan Hajnoczi     if (ret < 0) {
470bfe8043eSStefan Hajnoczi         return ret;
471bfe8043eSStefan Hajnoczi     }
472bfe8043eSStefan Hajnoczi 
473bfe8043eSStefan Hajnoczi     /* Only treat image as dirty if the header was updated successfully */
474bfe8043eSStefan Hajnoczi     s->incompatible_features |= QCOW2_INCOMPAT_DIRTY;
475bfe8043eSStefan Hajnoczi     return 0;
476bfe8043eSStefan Hajnoczi }
477bfe8043eSStefan Hajnoczi 
478bfe8043eSStefan Hajnoczi /*
479c61d0004SStefan Hajnoczi  * Clears the dirty bit and flushes before if necessary.  Only call this
480c61d0004SStefan Hajnoczi  * function when there are no pending requests, it does not guard against
481c61d0004SStefan Hajnoczi  * concurrent requests dirtying the image.
482c61d0004SStefan Hajnoczi  */
483c61d0004SStefan Hajnoczi static int qcow2_mark_clean(BlockDriverState *bs)
484c61d0004SStefan Hajnoczi {
485ff99129aSKevin Wolf     BDRVQcow2State *s = bs->opaque;
486c61d0004SStefan Hajnoczi 
487c61d0004SStefan Hajnoczi     if (s->incompatible_features & QCOW2_INCOMPAT_DIRTY) {
4884c2e5f8fSKevin Wolf         int ret;
4894c2e5f8fSKevin Wolf 
4904c2e5f8fSKevin Wolf         s->incompatible_features &= ~QCOW2_INCOMPAT_DIRTY;
4914c2e5f8fSKevin Wolf 
4924c2e5f8fSKevin Wolf         ret = bdrv_flush(bs);
493c61d0004SStefan Hajnoczi         if (ret < 0) {
494c61d0004SStefan Hajnoczi             return ret;
495c61d0004SStefan Hajnoczi         }
496c61d0004SStefan Hajnoczi 
497c61d0004SStefan Hajnoczi         return qcow2_update_header(bs);
498c61d0004SStefan Hajnoczi     }
499c61d0004SStefan Hajnoczi     return 0;
500c61d0004SStefan Hajnoczi }
501c61d0004SStefan Hajnoczi 
50269c98726SMax Reitz /*
50369c98726SMax Reitz  * Marks the image as corrupt.
50469c98726SMax Reitz  */
50569c98726SMax Reitz int qcow2_mark_corrupt(BlockDriverState *bs)
50669c98726SMax Reitz {
507ff99129aSKevin Wolf     BDRVQcow2State *s = bs->opaque;
50869c98726SMax Reitz 
50969c98726SMax Reitz     s->incompatible_features |= QCOW2_INCOMPAT_CORRUPT;
51069c98726SMax Reitz     return qcow2_update_header(bs);
51169c98726SMax Reitz }
51269c98726SMax Reitz 
51369c98726SMax Reitz /*
51469c98726SMax Reitz  * Marks the image as consistent, i.e., unsets the corrupt bit, and flushes
51569c98726SMax Reitz  * before if necessary.
51669c98726SMax Reitz  */
51769c98726SMax Reitz int qcow2_mark_consistent(BlockDriverState *bs)
51869c98726SMax Reitz {
519ff99129aSKevin Wolf     BDRVQcow2State *s = bs->opaque;
52069c98726SMax Reitz 
52169c98726SMax Reitz     if (s->incompatible_features & QCOW2_INCOMPAT_CORRUPT) {
52269c98726SMax Reitz         int ret = bdrv_flush(bs);
52369c98726SMax Reitz         if (ret < 0) {
52469c98726SMax Reitz             return ret;
52569c98726SMax Reitz         }
52669c98726SMax Reitz 
52769c98726SMax Reitz         s->incompatible_features &= ~QCOW2_INCOMPAT_CORRUPT;
52869c98726SMax Reitz         return qcow2_update_header(bs);
52969c98726SMax Reitz     }
53069c98726SMax Reitz     return 0;
53169c98726SMax Reitz }
53269c98726SMax Reitz 
533acbe5982SStefan Hajnoczi static int qcow2_check(BlockDriverState *bs, BdrvCheckResult *result,
534acbe5982SStefan Hajnoczi                        BdrvCheckMode fix)
535acbe5982SStefan Hajnoczi {
536acbe5982SStefan Hajnoczi     int ret = qcow2_check_refcounts(bs, result, fix);
537acbe5982SStefan Hajnoczi     if (ret < 0) {
538acbe5982SStefan Hajnoczi         return ret;
539acbe5982SStefan Hajnoczi     }
540acbe5982SStefan Hajnoczi 
541acbe5982SStefan Hajnoczi     if (fix && result->check_errors == 0 && result->corruptions == 0) {
54224530f3eSMax Reitz         ret = qcow2_mark_clean(bs);
54324530f3eSMax Reitz         if (ret < 0) {
54424530f3eSMax Reitz             return ret;
54524530f3eSMax Reitz         }
54624530f3eSMax Reitz         return qcow2_mark_consistent(bs);
547acbe5982SStefan Hajnoczi     }
548acbe5982SStefan Hajnoczi     return ret;
549acbe5982SStefan Hajnoczi }
550acbe5982SStefan Hajnoczi 
5518c7de283SKevin Wolf static int validate_table_offset(BlockDriverState *bs, uint64_t offset,
5528c7de283SKevin Wolf                                  uint64_t entries, size_t entry_len)
5538c7de283SKevin Wolf {
554ff99129aSKevin Wolf     BDRVQcow2State *s = bs->opaque;
5558c7de283SKevin Wolf     uint64_t size;
5568c7de283SKevin Wolf 
5578c7de283SKevin Wolf     /* Use signed INT64_MAX as the maximum even for uint64_t header fields,
5588c7de283SKevin Wolf      * because values will be passed to qemu functions taking int64_t. */
5598c7de283SKevin Wolf     if (entries > INT64_MAX / entry_len) {
5608c7de283SKevin Wolf         return -EINVAL;
5618c7de283SKevin Wolf     }
5628c7de283SKevin Wolf 
5638c7de283SKevin Wolf     size = entries * entry_len;
5648c7de283SKevin Wolf 
5658c7de283SKevin Wolf     if (INT64_MAX - size < offset) {
5668c7de283SKevin Wolf         return -EINVAL;
5678c7de283SKevin Wolf     }
5688c7de283SKevin Wolf 
5698c7de283SKevin Wolf     /* Tables must be cluster aligned */
57024990c5bSAlberto Garcia     if (offset_into_cluster(s, offset) != 0) {
5718c7de283SKevin Wolf         return -EINVAL;
5728c7de283SKevin Wolf     }
5738c7de283SKevin Wolf 
5748c7de283SKevin Wolf     return 0;
5758c7de283SKevin Wolf }
5768c7de283SKevin Wolf 
57774c4510aSKevin Wolf static QemuOptsList qcow2_runtime_opts = {
57874c4510aSKevin Wolf     .name = "qcow2",
57974c4510aSKevin Wolf     .head = QTAILQ_HEAD_INITIALIZER(qcow2_runtime_opts.head),
58074c4510aSKevin Wolf     .desc = {
58174c4510aSKevin Wolf         {
58264aa99d3SKevin Wolf             .name = QCOW2_OPT_LAZY_REFCOUNTS,
58374c4510aSKevin Wolf             .type = QEMU_OPT_BOOL,
58474c4510aSKevin Wolf             .help = "Postpone refcount updates",
58574c4510aSKevin Wolf         },
58667af674eSKevin Wolf         {
58767af674eSKevin Wolf             .name = QCOW2_OPT_DISCARD_REQUEST,
58867af674eSKevin Wolf             .type = QEMU_OPT_BOOL,
58967af674eSKevin Wolf             .help = "Pass guest discard requests to the layer below",
59067af674eSKevin Wolf         },
59167af674eSKevin Wolf         {
59267af674eSKevin Wolf             .name = QCOW2_OPT_DISCARD_SNAPSHOT,
59367af674eSKevin Wolf             .type = QEMU_OPT_BOOL,
59467af674eSKevin Wolf             .help = "Generate discard requests when snapshot related space "
59567af674eSKevin Wolf                     "is freed",
59667af674eSKevin Wolf         },
59767af674eSKevin Wolf         {
59867af674eSKevin Wolf             .name = QCOW2_OPT_DISCARD_OTHER,
59967af674eSKevin Wolf             .type = QEMU_OPT_BOOL,
60067af674eSKevin Wolf             .help = "Generate discard requests when other clusters are freed",
60167af674eSKevin Wolf         },
60205de7e86SMax Reitz         {
60305de7e86SMax Reitz             .name = QCOW2_OPT_OVERLAP,
60405de7e86SMax Reitz             .type = QEMU_OPT_STRING,
60505de7e86SMax Reitz             .help = "Selects which overlap checks to perform from a range of "
60605de7e86SMax Reitz                     "templates (none, constant, cached, all)",
60705de7e86SMax Reitz         },
60805de7e86SMax Reitz         {
609ee42b5ceSMax Reitz             .name = QCOW2_OPT_OVERLAP_TEMPLATE,
610ee42b5ceSMax Reitz             .type = QEMU_OPT_STRING,
611ee42b5ceSMax Reitz             .help = "Selects which overlap checks to perform from a range of "
612ee42b5ceSMax Reitz                     "templates (none, constant, cached, all)",
613ee42b5ceSMax Reitz         },
614ee42b5ceSMax Reitz         {
61505de7e86SMax Reitz             .name = QCOW2_OPT_OVERLAP_MAIN_HEADER,
61605de7e86SMax Reitz             .type = QEMU_OPT_BOOL,
61705de7e86SMax Reitz             .help = "Check for unintended writes into the main qcow2 header",
61805de7e86SMax Reitz         },
61905de7e86SMax Reitz         {
62005de7e86SMax Reitz             .name = QCOW2_OPT_OVERLAP_ACTIVE_L1,
62105de7e86SMax Reitz             .type = QEMU_OPT_BOOL,
62205de7e86SMax Reitz             .help = "Check for unintended writes into the active L1 table",
62305de7e86SMax Reitz         },
62405de7e86SMax Reitz         {
62505de7e86SMax Reitz             .name = QCOW2_OPT_OVERLAP_ACTIVE_L2,
62605de7e86SMax Reitz             .type = QEMU_OPT_BOOL,
62705de7e86SMax Reitz             .help = "Check for unintended writes into an active L2 table",
62805de7e86SMax Reitz         },
62905de7e86SMax Reitz         {
63005de7e86SMax Reitz             .name = QCOW2_OPT_OVERLAP_REFCOUNT_TABLE,
63105de7e86SMax Reitz             .type = QEMU_OPT_BOOL,
63205de7e86SMax Reitz             .help = "Check for unintended writes into the refcount table",
63305de7e86SMax Reitz         },
63405de7e86SMax Reitz         {
63505de7e86SMax Reitz             .name = QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK,
63605de7e86SMax Reitz             .type = QEMU_OPT_BOOL,
63705de7e86SMax Reitz             .help = "Check for unintended writes into a refcount block",
63805de7e86SMax Reitz         },
63905de7e86SMax Reitz         {
64005de7e86SMax Reitz             .name = QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE,
64105de7e86SMax Reitz             .type = QEMU_OPT_BOOL,
64205de7e86SMax Reitz             .help = "Check for unintended writes into the snapshot table",
64305de7e86SMax Reitz         },
64405de7e86SMax Reitz         {
64505de7e86SMax Reitz             .name = QCOW2_OPT_OVERLAP_INACTIVE_L1,
64605de7e86SMax Reitz             .type = QEMU_OPT_BOOL,
64705de7e86SMax Reitz             .help = "Check for unintended writes into an inactive L1 table",
64805de7e86SMax Reitz         },
64905de7e86SMax Reitz         {
65005de7e86SMax Reitz             .name = QCOW2_OPT_OVERLAP_INACTIVE_L2,
65105de7e86SMax Reitz             .type = QEMU_OPT_BOOL,
65205de7e86SMax Reitz             .help = "Check for unintended writes into an inactive L2 table",
65305de7e86SMax Reitz         },
6546c1c8d5dSMax Reitz         {
6556c1c8d5dSMax Reitz             .name = QCOW2_OPT_CACHE_SIZE,
6566c1c8d5dSMax Reitz             .type = QEMU_OPT_SIZE,
6576c1c8d5dSMax Reitz             .help = "Maximum combined metadata (L2 tables and refcount blocks) "
6586c1c8d5dSMax Reitz                     "cache size",
6596c1c8d5dSMax Reitz         },
6606c1c8d5dSMax Reitz         {
6616c1c8d5dSMax Reitz             .name = QCOW2_OPT_L2_CACHE_SIZE,
6626c1c8d5dSMax Reitz             .type = QEMU_OPT_SIZE,
6636c1c8d5dSMax Reitz             .help = "Maximum L2 table cache size",
6646c1c8d5dSMax Reitz         },
6656c1c8d5dSMax Reitz         {
6666c1c8d5dSMax Reitz             .name = QCOW2_OPT_REFCOUNT_CACHE_SIZE,
6676c1c8d5dSMax Reitz             .type = QEMU_OPT_SIZE,
6686c1c8d5dSMax Reitz             .help = "Maximum refcount block cache size",
6696c1c8d5dSMax Reitz         },
670279621c0SAlberto Garcia         {
671279621c0SAlberto Garcia             .name = QCOW2_OPT_CACHE_CLEAN_INTERVAL,
672279621c0SAlberto Garcia             .type = QEMU_OPT_NUMBER,
673279621c0SAlberto Garcia             .help = "Clean unused cache entries after this time (in seconds)",
674279621c0SAlberto Garcia         },
6754652b8f3SDaniel P. Berrange         BLOCK_CRYPTO_OPT_DEF_KEY_SECRET("encrypt.",
6764652b8f3SDaniel P. Berrange             "ID of secret providing qcow2 AES key or LUKS passphrase"),
67774c4510aSKevin Wolf         { /* end of list */ }
67874c4510aSKevin Wolf     },
67974c4510aSKevin Wolf };
68074c4510aSKevin Wolf 
6814092e99dSMax Reitz static const char *overlap_bool_option_names[QCOW2_OL_MAX_BITNR] = {
6824092e99dSMax Reitz     [QCOW2_OL_MAIN_HEADER_BITNR]    = QCOW2_OPT_OVERLAP_MAIN_HEADER,
6834092e99dSMax Reitz     [QCOW2_OL_ACTIVE_L1_BITNR]      = QCOW2_OPT_OVERLAP_ACTIVE_L1,
6844092e99dSMax Reitz     [QCOW2_OL_ACTIVE_L2_BITNR]      = QCOW2_OPT_OVERLAP_ACTIVE_L2,
6854092e99dSMax Reitz     [QCOW2_OL_REFCOUNT_TABLE_BITNR] = QCOW2_OPT_OVERLAP_REFCOUNT_TABLE,
6864092e99dSMax Reitz     [QCOW2_OL_REFCOUNT_BLOCK_BITNR] = QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK,
6874092e99dSMax Reitz     [QCOW2_OL_SNAPSHOT_TABLE_BITNR] = QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE,
6884092e99dSMax Reitz     [QCOW2_OL_INACTIVE_L1_BITNR]    = QCOW2_OPT_OVERLAP_INACTIVE_L1,
6894092e99dSMax Reitz     [QCOW2_OL_INACTIVE_L2_BITNR]    = QCOW2_OPT_OVERLAP_INACTIVE_L2,
6904092e99dSMax Reitz };
6914092e99dSMax Reitz 
692279621c0SAlberto Garcia static void cache_clean_timer_cb(void *opaque)
693279621c0SAlberto Garcia {
694279621c0SAlberto Garcia     BlockDriverState *bs = opaque;
695ff99129aSKevin Wolf     BDRVQcow2State *s = bs->opaque;
696279621c0SAlberto Garcia     qcow2_cache_clean_unused(bs, s->l2_table_cache);
697279621c0SAlberto Garcia     qcow2_cache_clean_unused(bs, s->refcount_block_cache);
698279621c0SAlberto Garcia     timer_mod(s->cache_clean_timer, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) +
699279621c0SAlberto Garcia               (int64_t) s->cache_clean_interval * 1000);
700279621c0SAlberto Garcia }
701279621c0SAlberto Garcia 
702279621c0SAlberto Garcia static void cache_clean_timer_init(BlockDriverState *bs, AioContext *context)
703279621c0SAlberto Garcia {
704ff99129aSKevin Wolf     BDRVQcow2State *s = bs->opaque;
705279621c0SAlberto Garcia     if (s->cache_clean_interval > 0) {
706279621c0SAlberto Garcia         s->cache_clean_timer = aio_timer_new(context, QEMU_CLOCK_VIRTUAL,
707279621c0SAlberto Garcia                                              SCALE_MS, cache_clean_timer_cb,
708279621c0SAlberto Garcia                                              bs);
709279621c0SAlberto Garcia         timer_mod(s->cache_clean_timer, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) +
710279621c0SAlberto Garcia                   (int64_t) s->cache_clean_interval * 1000);
711279621c0SAlberto Garcia     }
712279621c0SAlberto Garcia }
713279621c0SAlberto Garcia 
714279621c0SAlberto Garcia static void cache_clean_timer_del(BlockDriverState *bs)
715279621c0SAlberto Garcia {
716ff99129aSKevin Wolf     BDRVQcow2State *s = bs->opaque;
717279621c0SAlberto Garcia     if (s->cache_clean_timer) {
718279621c0SAlberto Garcia         timer_del(s->cache_clean_timer);
719279621c0SAlberto Garcia         timer_free(s->cache_clean_timer);
720279621c0SAlberto Garcia         s->cache_clean_timer = NULL;
721279621c0SAlberto Garcia     }
722279621c0SAlberto Garcia }
723279621c0SAlberto Garcia 
724279621c0SAlberto Garcia static void qcow2_detach_aio_context(BlockDriverState *bs)
725279621c0SAlberto Garcia {
726279621c0SAlberto Garcia     cache_clean_timer_del(bs);
727279621c0SAlberto Garcia }
728279621c0SAlberto Garcia 
729279621c0SAlberto Garcia static void qcow2_attach_aio_context(BlockDriverState *bs,
730279621c0SAlberto Garcia                                      AioContext *new_context)
731279621c0SAlberto Garcia {
732279621c0SAlberto Garcia     cache_clean_timer_init(bs, new_context);
733279621c0SAlberto Garcia }
734279621c0SAlberto Garcia 
735bc85ef26SMax Reitz static void read_cache_sizes(BlockDriverState *bs, QemuOpts *opts,
736bc85ef26SMax Reitz                              uint64_t *l2_cache_size,
7376c1c8d5dSMax Reitz                              uint64_t *refcount_cache_size, Error **errp)
7386c1c8d5dSMax Reitz {
739ff99129aSKevin Wolf     BDRVQcow2State *s = bs->opaque;
7406c1c8d5dSMax Reitz     uint64_t combined_cache_size;
7416c1c8d5dSMax Reitz     bool l2_cache_size_set, refcount_cache_size_set, combined_cache_size_set;
7426c1c8d5dSMax Reitz 
7436c1c8d5dSMax Reitz     combined_cache_size_set = qemu_opt_get(opts, QCOW2_OPT_CACHE_SIZE);
7446c1c8d5dSMax Reitz     l2_cache_size_set = qemu_opt_get(opts, QCOW2_OPT_L2_CACHE_SIZE);
7456c1c8d5dSMax Reitz     refcount_cache_size_set = qemu_opt_get(opts, QCOW2_OPT_REFCOUNT_CACHE_SIZE);
7466c1c8d5dSMax Reitz 
7476c1c8d5dSMax Reitz     combined_cache_size = qemu_opt_get_size(opts, QCOW2_OPT_CACHE_SIZE, 0);
7486c1c8d5dSMax Reitz     *l2_cache_size = qemu_opt_get_size(opts, QCOW2_OPT_L2_CACHE_SIZE, 0);
7496c1c8d5dSMax Reitz     *refcount_cache_size = qemu_opt_get_size(opts,
7506c1c8d5dSMax Reitz                                              QCOW2_OPT_REFCOUNT_CACHE_SIZE, 0);
7516c1c8d5dSMax Reitz 
7526c1c8d5dSMax Reitz     if (combined_cache_size_set) {
7536c1c8d5dSMax Reitz         if (l2_cache_size_set && refcount_cache_size_set) {
7546c1c8d5dSMax Reitz             error_setg(errp, QCOW2_OPT_CACHE_SIZE ", " QCOW2_OPT_L2_CACHE_SIZE
7556c1c8d5dSMax Reitz                        " and " QCOW2_OPT_REFCOUNT_CACHE_SIZE " may not be set "
7566c1c8d5dSMax Reitz                        "the same time");
7576c1c8d5dSMax Reitz             return;
7586c1c8d5dSMax Reitz         } else if (*l2_cache_size > combined_cache_size) {
7596c1c8d5dSMax Reitz             error_setg(errp, QCOW2_OPT_L2_CACHE_SIZE " may not exceed "
7606c1c8d5dSMax Reitz                        QCOW2_OPT_CACHE_SIZE);
7616c1c8d5dSMax Reitz             return;
7626c1c8d5dSMax Reitz         } else if (*refcount_cache_size > combined_cache_size) {
7636c1c8d5dSMax Reitz             error_setg(errp, QCOW2_OPT_REFCOUNT_CACHE_SIZE " may not exceed "
7646c1c8d5dSMax Reitz                        QCOW2_OPT_CACHE_SIZE);
7656c1c8d5dSMax Reitz             return;
7666c1c8d5dSMax Reitz         }
7676c1c8d5dSMax Reitz 
7686c1c8d5dSMax Reitz         if (l2_cache_size_set) {
7696c1c8d5dSMax Reitz             *refcount_cache_size = combined_cache_size - *l2_cache_size;
7706c1c8d5dSMax Reitz         } else if (refcount_cache_size_set) {
7716c1c8d5dSMax Reitz             *l2_cache_size = combined_cache_size - *refcount_cache_size;
7726c1c8d5dSMax Reitz         } else {
7736c1c8d5dSMax Reitz             *refcount_cache_size = combined_cache_size
7746c1c8d5dSMax Reitz                                  / (DEFAULT_L2_REFCOUNT_SIZE_RATIO + 1);
7756c1c8d5dSMax Reitz             *l2_cache_size = combined_cache_size - *refcount_cache_size;
7766c1c8d5dSMax Reitz         }
7776c1c8d5dSMax Reitz     } else {
7786c1c8d5dSMax Reitz         if (!l2_cache_size_set && !refcount_cache_size_set) {
779bc85ef26SMax Reitz             *l2_cache_size = MAX(DEFAULT_L2_CACHE_BYTE_SIZE,
780bc85ef26SMax Reitz                                  (uint64_t)DEFAULT_L2_CACHE_CLUSTERS
781bc85ef26SMax Reitz                                  * s->cluster_size);
7826c1c8d5dSMax Reitz             *refcount_cache_size = *l2_cache_size
7836c1c8d5dSMax Reitz                                  / DEFAULT_L2_REFCOUNT_SIZE_RATIO;
7846c1c8d5dSMax Reitz         } else if (!l2_cache_size_set) {
7856c1c8d5dSMax Reitz             *l2_cache_size = *refcount_cache_size
7866c1c8d5dSMax Reitz                            * DEFAULT_L2_REFCOUNT_SIZE_RATIO;
7876c1c8d5dSMax Reitz         } else if (!refcount_cache_size_set) {
7886c1c8d5dSMax Reitz             *refcount_cache_size = *l2_cache_size
7896c1c8d5dSMax Reitz                                  / DEFAULT_L2_REFCOUNT_SIZE_RATIO;
7906c1c8d5dSMax Reitz         }
7916c1c8d5dSMax Reitz     }
7926c1c8d5dSMax Reitz }
7936c1c8d5dSMax Reitz 
794ee55b173SKevin Wolf typedef struct Qcow2ReopenState {
795ee55b173SKevin Wolf     Qcow2Cache *l2_table_cache;
796ee55b173SKevin Wolf     Qcow2Cache *refcount_block_cache;
797ee55b173SKevin Wolf     bool use_lazy_refcounts;
798ee55b173SKevin Wolf     int overlap_check;
799ee55b173SKevin Wolf     bool discard_passthrough[QCOW2_DISCARD_MAX];
800ee55b173SKevin Wolf     uint64_t cache_clean_interval;
801b25b387fSDaniel P. Berrange     QCryptoBlockOpenOptions *crypto_opts; /* Disk encryption runtime options */
802ee55b173SKevin Wolf } Qcow2ReopenState;
803ee55b173SKevin Wolf 
804ee55b173SKevin Wolf static int qcow2_update_options_prepare(BlockDriverState *bs,
805ee55b173SKevin Wolf                                         Qcow2ReopenState *r,
806ee55b173SKevin Wolf                                         QDict *options, int flags,
807ee55b173SKevin Wolf                                         Error **errp)
8084c75d1a1SKevin Wolf {
8094c75d1a1SKevin Wolf     BDRVQcow2State *s = bs->opaque;
81094edf3fbSKevin Wolf     QemuOpts *opts = NULL;
8114c75d1a1SKevin Wolf     const char *opt_overlap_check, *opt_overlap_check_template;
8124c75d1a1SKevin Wolf     int overlap_check_template = 0;
81394edf3fbSKevin Wolf     uint64_t l2_cache_size, refcount_cache_size;
8144c75d1a1SKevin Wolf     int i;
815b25b387fSDaniel P. Berrange     const char *encryptfmt;
816b25b387fSDaniel P. Berrange     QDict *encryptopts = NULL;
81794edf3fbSKevin Wolf     Error *local_err = NULL;
8184c75d1a1SKevin Wolf     int ret;
8194c75d1a1SKevin Wolf 
820b25b387fSDaniel P. Berrange     qdict_extract_subqdict(options, &encryptopts, "encrypt.");
821b25b387fSDaniel P. Berrange     encryptfmt = qdict_get_try_str(encryptopts, "format");
822b25b387fSDaniel P. Berrange 
82394edf3fbSKevin Wolf     opts = qemu_opts_create(&qcow2_runtime_opts, NULL, 0, &error_abort);
82494edf3fbSKevin Wolf     qemu_opts_absorb_qdict(opts, options, &local_err);
82594edf3fbSKevin Wolf     if (local_err) {
82694edf3fbSKevin Wolf         error_propagate(errp, local_err);
82794edf3fbSKevin Wolf         ret = -EINVAL;
82894edf3fbSKevin Wolf         goto fail;
82994edf3fbSKevin Wolf     }
83094edf3fbSKevin Wolf 
83194edf3fbSKevin Wolf     /* get L2 table/refcount block cache size from command line options */
83294edf3fbSKevin Wolf     read_cache_sizes(bs, opts, &l2_cache_size, &refcount_cache_size,
83394edf3fbSKevin Wolf                      &local_err);
83494edf3fbSKevin Wolf     if (local_err) {
83594edf3fbSKevin Wolf         error_propagate(errp, local_err);
83694edf3fbSKevin Wolf         ret = -EINVAL;
83794edf3fbSKevin Wolf         goto fail;
83894edf3fbSKevin Wolf     }
83994edf3fbSKevin Wolf 
84094edf3fbSKevin Wolf     l2_cache_size /= s->cluster_size;
84194edf3fbSKevin Wolf     if (l2_cache_size < MIN_L2_CACHE_SIZE) {
84294edf3fbSKevin Wolf         l2_cache_size = MIN_L2_CACHE_SIZE;
84394edf3fbSKevin Wolf     }
84494edf3fbSKevin Wolf     if (l2_cache_size > INT_MAX) {
84594edf3fbSKevin Wolf         error_setg(errp, "L2 cache size too big");
84694edf3fbSKevin Wolf         ret = -EINVAL;
84794edf3fbSKevin Wolf         goto fail;
84894edf3fbSKevin Wolf     }
84994edf3fbSKevin Wolf 
85094edf3fbSKevin Wolf     refcount_cache_size /= s->cluster_size;
85194edf3fbSKevin Wolf     if (refcount_cache_size < MIN_REFCOUNT_CACHE_SIZE) {
85294edf3fbSKevin Wolf         refcount_cache_size = MIN_REFCOUNT_CACHE_SIZE;
85394edf3fbSKevin Wolf     }
85494edf3fbSKevin Wolf     if (refcount_cache_size > INT_MAX) {
85594edf3fbSKevin Wolf         error_setg(errp, "Refcount cache size too big");
85694edf3fbSKevin Wolf         ret = -EINVAL;
85794edf3fbSKevin Wolf         goto fail;
85894edf3fbSKevin Wolf     }
85994edf3fbSKevin Wolf 
8605b0959a7SKevin Wolf     /* alloc new L2 table/refcount block cache, flush old one */
8615b0959a7SKevin Wolf     if (s->l2_table_cache) {
8625b0959a7SKevin Wolf         ret = qcow2_cache_flush(bs, s->l2_table_cache);
8635b0959a7SKevin Wolf         if (ret) {
8645b0959a7SKevin Wolf             error_setg_errno(errp, -ret, "Failed to flush the L2 table cache");
8655b0959a7SKevin Wolf             goto fail;
8665b0959a7SKevin Wolf         }
8675b0959a7SKevin Wolf     }
8685b0959a7SKevin Wolf 
8695b0959a7SKevin Wolf     if (s->refcount_block_cache) {
8705b0959a7SKevin Wolf         ret = qcow2_cache_flush(bs, s->refcount_block_cache);
8715b0959a7SKevin Wolf         if (ret) {
8725b0959a7SKevin Wolf             error_setg_errno(errp, -ret,
8735b0959a7SKevin Wolf                              "Failed to flush the refcount block cache");
8745b0959a7SKevin Wolf             goto fail;
8755b0959a7SKevin Wolf         }
8765b0959a7SKevin Wolf     }
8775b0959a7SKevin Wolf 
878ee55b173SKevin Wolf     r->l2_table_cache = qcow2_cache_create(bs, l2_cache_size);
879ee55b173SKevin Wolf     r->refcount_block_cache = qcow2_cache_create(bs, refcount_cache_size);
880ee55b173SKevin Wolf     if (r->l2_table_cache == NULL || r->refcount_block_cache == NULL) {
88194edf3fbSKevin Wolf         error_setg(errp, "Could not allocate metadata caches");
88294edf3fbSKevin Wolf         ret = -ENOMEM;
88394edf3fbSKevin Wolf         goto fail;
88494edf3fbSKevin Wolf     }
88594edf3fbSKevin Wolf 
88694edf3fbSKevin Wolf     /* New interval for cache cleanup timer */
887ee55b173SKevin Wolf     r->cache_clean_interval =
8885b0959a7SKevin Wolf         qemu_opt_get_number(opts, QCOW2_OPT_CACHE_CLEAN_INTERVAL,
8895b0959a7SKevin Wolf                             s->cache_clean_interval);
89091203f08SAlberto Garcia #ifndef CONFIG_LINUX
89191203f08SAlberto Garcia     if (r->cache_clean_interval != 0) {
89291203f08SAlberto Garcia         error_setg(errp, QCOW2_OPT_CACHE_CLEAN_INTERVAL
89391203f08SAlberto Garcia                    " not supported on this host");
89491203f08SAlberto Garcia         ret = -EINVAL;
89591203f08SAlberto Garcia         goto fail;
89691203f08SAlberto Garcia     }
89791203f08SAlberto Garcia #endif
898ee55b173SKevin Wolf     if (r->cache_clean_interval > UINT_MAX) {
89994edf3fbSKevin Wolf         error_setg(errp, "Cache clean interval too big");
90094edf3fbSKevin Wolf         ret = -EINVAL;
90194edf3fbSKevin Wolf         goto fail;
90294edf3fbSKevin Wolf     }
90394edf3fbSKevin Wolf 
9045b0959a7SKevin Wolf     /* lazy-refcounts; flush if going from enabled to disabled */
905ee55b173SKevin Wolf     r->use_lazy_refcounts = qemu_opt_get_bool(opts, QCOW2_OPT_LAZY_REFCOUNTS,
9064c75d1a1SKevin Wolf         (s->compatible_features & QCOW2_COMPAT_LAZY_REFCOUNTS));
907ee55b173SKevin Wolf     if (r->use_lazy_refcounts && s->qcow_version < 3) {
908007dbc39SKevin Wolf         error_setg(errp, "Lazy refcounts require a qcow2 image with at least "
909007dbc39SKevin Wolf                    "qemu 1.1 compatibility level");
910007dbc39SKevin Wolf         ret = -EINVAL;
911007dbc39SKevin Wolf         goto fail;
912007dbc39SKevin Wolf     }
9134c75d1a1SKevin Wolf 
9145b0959a7SKevin Wolf     if (s->use_lazy_refcounts && !r->use_lazy_refcounts) {
9155b0959a7SKevin Wolf         ret = qcow2_mark_clean(bs);
9165b0959a7SKevin Wolf         if (ret < 0) {
9175b0959a7SKevin Wolf             error_setg_errno(errp, -ret, "Failed to disable lazy refcounts");
9185b0959a7SKevin Wolf             goto fail;
9195b0959a7SKevin Wolf         }
9205b0959a7SKevin Wolf     }
9215b0959a7SKevin Wolf 
922007dbc39SKevin Wolf     /* Overlap check options */
9234c75d1a1SKevin Wolf     opt_overlap_check = qemu_opt_get(opts, QCOW2_OPT_OVERLAP);
9244c75d1a1SKevin Wolf     opt_overlap_check_template = qemu_opt_get(opts, QCOW2_OPT_OVERLAP_TEMPLATE);
9254c75d1a1SKevin Wolf     if (opt_overlap_check_template && opt_overlap_check &&
9264c75d1a1SKevin Wolf         strcmp(opt_overlap_check_template, opt_overlap_check))
9274c75d1a1SKevin Wolf     {
9284c75d1a1SKevin Wolf         error_setg(errp, "Conflicting values for qcow2 options '"
9294c75d1a1SKevin Wolf                    QCOW2_OPT_OVERLAP "' ('%s') and '" QCOW2_OPT_OVERLAP_TEMPLATE
9304c75d1a1SKevin Wolf                    "' ('%s')", opt_overlap_check, opt_overlap_check_template);
9314c75d1a1SKevin Wolf         ret = -EINVAL;
9324c75d1a1SKevin Wolf         goto fail;
9334c75d1a1SKevin Wolf     }
9344c75d1a1SKevin Wolf     if (!opt_overlap_check) {
9354c75d1a1SKevin Wolf         opt_overlap_check = opt_overlap_check_template ?: "cached";
9364c75d1a1SKevin Wolf     }
9374c75d1a1SKevin Wolf 
9384c75d1a1SKevin Wolf     if (!strcmp(opt_overlap_check, "none")) {
9394c75d1a1SKevin Wolf         overlap_check_template = 0;
9404c75d1a1SKevin Wolf     } else if (!strcmp(opt_overlap_check, "constant")) {
9414c75d1a1SKevin Wolf         overlap_check_template = QCOW2_OL_CONSTANT;
9424c75d1a1SKevin Wolf     } else if (!strcmp(opt_overlap_check, "cached")) {
9434c75d1a1SKevin Wolf         overlap_check_template = QCOW2_OL_CACHED;
9444c75d1a1SKevin Wolf     } else if (!strcmp(opt_overlap_check, "all")) {
9454c75d1a1SKevin Wolf         overlap_check_template = QCOW2_OL_ALL;
9464c75d1a1SKevin Wolf     } else {
9474c75d1a1SKevin Wolf         error_setg(errp, "Unsupported value '%s' for qcow2 option "
9484c75d1a1SKevin Wolf                    "'overlap-check'. Allowed are any of the following: "
9494c75d1a1SKevin Wolf                    "none, constant, cached, all", opt_overlap_check);
9504c75d1a1SKevin Wolf         ret = -EINVAL;
9514c75d1a1SKevin Wolf         goto fail;
9524c75d1a1SKevin Wolf     }
9534c75d1a1SKevin Wolf 
954ee55b173SKevin Wolf     r->overlap_check = 0;
9554c75d1a1SKevin Wolf     for (i = 0; i < QCOW2_OL_MAX_BITNR; i++) {
9564c75d1a1SKevin Wolf         /* overlap-check defines a template bitmask, but every flag may be
9574c75d1a1SKevin Wolf          * overwritten through the associated boolean option */
958ee55b173SKevin Wolf         r->overlap_check |=
9594c75d1a1SKevin Wolf             qemu_opt_get_bool(opts, overlap_bool_option_names[i],
9604c75d1a1SKevin Wolf                               overlap_check_template & (1 << i)) << i;
9614c75d1a1SKevin Wolf     }
9624c75d1a1SKevin Wolf 
963ee55b173SKevin Wolf     r->discard_passthrough[QCOW2_DISCARD_NEVER] = false;
964ee55b173SKevin Wolf     r->discard_passthrough[QCOW2_DISCARD_ALWAYS] = true;
965ee55b173SKevin Wolf     r->discard_passthrough[QCOW2_DISCARD_REQUEST] =
966007dbc39SKevin Wolf         qemu_opt_get_bool(opts, QCOW2_OPT_DISCARD_REQUEST,
967007dbc39SKevin Wolf                           flags & BDRV_O_UNMAP);
968ee55b173SKevin Wolf     r->discard_passthrough[QCOW2_DISCARD_SNAPSHOT] =
969007dbc39SKevin Wolf         qemu_opt_get_bool(opts, QCOW2_OPT_DISCARD_SNAPSHOT, true);
970ee55b173SKevin Wolf     r->discard_passthrough[QCOW2_DISCARD_OTHER] =
971007dbc39SKevin Wolf         qemu_opt_get_bool(opts, QCOW2_OPT_DISCARD_OTHER, false);
972007dbc39SKevin Wolf 
973b25b387fSDaniel P. Berrange     switch (s->crypt_method_header) {
974b25b387fSDaniel P. Berrange     case QCOW_CRYPT_NONE:
975b25b387fSDaniel P. Berrange         if (encryptfmt) {
976b25b387fSDaniel P. Berrange             error_setg(errp, "No encryption in image header, but options "
977b25b387fSDaniel P. Berrange                        "specified format '%s'", encryptfmt);
978b25b387fSDaniel P. Berrange             ret = -EINVAL;
979b25b387fSDaniel P. Berrange             goto fail;
980b25b387fSDaniel P. Berrange         }
981b25b387fSDaniel P. Berrange         break;
982b25b387fSDaniel P. Berrange 
983b25b387fSDaniel P. Berrange     case QCOW_CRYPT_AES:
984b25b387fSDaniel P. Berrange         if (encryptfmt && !g_str_equal(encryptfmt, "aes")) {
985b25b387fSDaniel P. Berrange             error_setg(errp,
986b25b387fSDaniel P. Berrange                        "Header reported 'aes' encryption format but "
987b25b387fSDaniel P. Berrange                        "options specify '%s'", encryptfmt);
988b25b387fSDaniel P. Berrange             ret = -EINVAL;
989b25b387fSDaniel P. Berrange             goto fail;
990b25b387fSDaniel P. Berrange         }
991b25b387fSDaniel P. Berrange         qdict_del(encryptopts, "format");
992b25b387fSDaniel P. Berrange         r->crypto_opts = block_crypto_open_opts_init(
993b25b387fSDaniel P. Berrange             Q_CRYPTO_BLOCK_FORMAT_QCOW, encryptopts, errp);
994b25b387fSDaniel P. Berrange         break;
995b25b387fSDaniel P. Berrange 
9964652b8f3SDaniel P. Berrange     case QCOW_CRYPT_LUKS:
9974652b8f3SDaniel P. Berrange         if (encryptfmt && !g_str_equal(encryptfmt, "luks")) {
9984652b8f3SDaniel P. Berrange             error_setg(errp,
9994652b8f3SDaniel P. Berrange                        "Header reported 'luks' encryption format but "
10004652b8f3SDaniel P. Berrange                        "options specify '%s'", encryptfmt);
10014652b8f3SDaniel P. Berrange             ret = -EINVAL;
10024652b8f3SDaniel P. Berrange             goto fail;
10034652b8f3SDaniel P. Berrange         }
10044652b8f3SDaniel P. Berrange         qdict_del(encryptopts, "format");
10054652b8f3SDaniel P. Berrange         r->crypto_opts = block_crypto_open_opts_init(
10064652b8f3SDaniel P. Berrange             Q_CRYPTO_BLOCK_FORMAT_LUKS, encryptopts, errp);
10074652b8f3SDaniel P. Berrange         break;
10084652b8f3SDaniel P. Berrange 
1009b25b387fSDaniel P. Berrange     default:
1010b25b387fSDaniel P. Berrange         error_setg(errp, "Unsupported encryption method %d",
1011b25b387fSDaniel P. Berrange                    s->crypt_method_header);
1012b25b387fSDaniel P. Berrange         break;
1013b25b387fSDaniel P. Berrange     }
1014b25b387fSDaniel P. Berrange     if (s->crypt_method_header != QCOW_CRYPT_NONE && !r->crypto_opts) {
1015b25b387fSDaniel P. Berrange         ret = -EINVAL;
1016b25b387fSDaniel P. Berrange         goto fail;
1017b25b387fSDaniel P. Berrange     }
1018b25b387fSDaniel P. Berrange 
10194c75d1a1SKevin Wolf     ret = 0;
10204c75d1a1SKevin Wolf fail:
1021b25b387fSDaniel P. Berrange     QDECREF(encryptopts);
102294edf3fbSKevin Wolf     qemu_opts_del(opts);
102394edf3fbSKevin Wolf     opts = NULL;
1024ee55b173SKevin Wolf     return ret;
1025ee55b173SKevin Wolf }
1026ee55b173SKevin Wolf 
1027ee55b173SKevin Wolf static void qcow2_update_options_commit(BlockDriverState *bs,
1028ee55b173SKevin Wolf                                         Qcow2ReopenState *r)
1029ee55b173SKevin Wolf {
1030ee55b173SKevin Wolf     BDRVQcow2State *s = bs->opaque;
1031ee55b173SKevin Wolf     int i;
1032ee55b173SKevin Wolf 
10335b0959a7SKevin Wolf     if (s->l2_table_cache) {
10345b0959a7SKevin Wolf         qcow2_cache_destroy(bs, s->l2_table_cache);
10355b0959a7SKevin Wolf     }
10365b0959a7SKevin Wolf     if (s->refcount_block_cache) {
10375b0959a7SKevin Wolf         qcow2_cache_destroy(bs, s->refcount_block_cache);
10385b0959a7SKevin Wolf     }
1039ee55b173SKevin Wolf     s->l2_table_cache = r->l2_table_cache;
1040ee55b173SKevin Wolf     s->refcount_block_cache = r->refcount_block_cache;
1041ee55b173SKevin Wolf 
1042ee55b173SKevin Wolf     s->overlap_check = r->overlap_check;
1043ee55b173SKevin Wolf     s->use_lazy_refcounts = r->use_lazy_refcounts;
1044ee55b173SKevin Wolf 
1045ee55b173SKevin Wolf     for (i = 0; i < QCOW2_DISCARD_MAX; i++) {
1046ee55b173SKevin Wolf         s->discard_passthrough[i] = r->discard_passthrough[i];
1047ee55b173SKevin Wolf     }
1048ee55b173SKevin Wolf 
10495b0959a7SKevin Wolf     if (s->cache_clean_interval != r->cache_clean_interval) {
10505b0959a7SKevin Wolf         cache_clean_timer_del(bs);
1051ee55b173SKevin Wolf         s->cache_clean_interval = r->cache_clean_interval;
1052ee55b173SKevin Wolf         cache_clean_timer_init(bs, bdrv_get_aio_context(bs));
1053ee55b173SKevin Wolf     }
1054b25b387fSDaniel P. Berrange 
1055b25b387fSDaniel P. Berrange     qapi_free_QCryptoBlockOpenOptions(s->crypto_opts);
1056b25b387fSDaniel P. Berrange     s->crypto_opts = r->crypto_opts;
10575b0959a7SKevin Wolf }
1058ee55b173SKevin Wolf 
1059ee55b173SKevin Wolf static void qcow2_update_options_abort(BlockDriverState *bs,
1060ee55b173SKevin Wolf                                        Qcow2ReopenState *r)
1061ee55b173SKevin Wolf {
1062ee55b173SKevin Wolf     if (r->l2_table_cache) {
1063ee55b173SKevin Wolf         qcow2_cache_destroy(bs, r->l2_table_cache);
1064ee55b173SKevin Wolf     }
1065ee55b173SKevin Wolf     if (r->refcount_block_cache) {
1066ee55b173SKevin Wolf         qcow2_cache_destroy(bs, r->refcount_block_cache);
1067ee55b173SKevin Wolf     }
1068b25b387fSDaniel P. Berrange     qapi_free_QCryptoBlockOpenOptions(r->crypto_opts);
1069ee55b173SKevin Wolf }
1070ee55b173SKevin Wolf 
1071ee55b173SKevin Wolf static int qcow2_update_options(BlockDriverState *bs, QDict *options,
1072ee55b173SKevin Wolf                                 int flags, Error **errp)
1073ee55b173SKevin Wolf {
1074ee55b173SKevin Wolf     Qcow2ReopenState r = {};
1075ee55b173SKevin Wolf     int ret;
1076ee55b173SKevin Wolf 
1077ee55b173SKevin Wolf     ret = qcow2_update_options_prepare(bs, &r, options, flags, errp);
1078ee55b173SKevin Wolf     if (ret >= 0) {
1079ee55b173SKevin Wolf         qcow2_update_options_commit(bs, &r);
1080ee55b173SKevin Wolf     } else {
1081ee55b173SKevin Wolf         qcow2_update_options_abort(bs, &r);
1082ee55b173SKevin Wolf     }
108394edf3fbSKevin Wolf 
10844c75d1a1SKevin Wolf     return ret;
10854c75d1a1SKevin Wolf }
10864c75d1a1SKevin Wolf 
10874e4bf5c4SKevin Wolf static int qcow2_do_open(BlockDriverState *bs, QDict *options, int flags,
1088015a1036SMax Reitz                          Error **errp)
1089585f8587Sbellard {
1090ff99129aSKevin Wolf     BDRVQcow2State *s = bs->opaque;
10916d33e8e7SKevin Wolf     unsigned int len, i;
10926d33e8e7SKevin Wolf     int ret = 0;
1093585f8587Sbellard     QCowHeader header;
109474c4510aSKevin Wolf     Error *local_err = NULL;
10959b80ddf3Saliguori     uint64_t ext_end;
10962cf7cfa1SKevin Wolf     uint64_t l1_vm_state_index;
109788ddffaeSVladimir Sementsov-Ogievskiy     bool update_header = false;
1098585f8587Sbellard 
1099cf2ab8fcSKevin Wolf     ret = bdrv_pread(bs->file, 0, &header, sizeof(header));
11006d85a57eSJes Sorensen     if (ret < 0) {
11013ef6c40aSMax Reitz         error_setg_errno(errp, -ret, "Could not read qcow2 header");
1102585f8587Sbellard         goto fail;
11036d85a57eSJes Sorensen     }
1104585f8587Sbellard     be32_to_cpus(&header.magic);
1105585f8587Sbellard     be32_to_cpus(&header.version);
1106585f8587Sbellard     be64_to_cpus(&header.backing_file_offset);
1107585f8587Sbellard     be32_to_cpus(&header.backing_file_size);
1108585f8587Sbellard     be64_to_cpus(&header.size);
1109585f8587Sbellard     be32_to_cpus(&header.cluster_bits);
1110585f8587Sbellard     be32_to_cpus(&header.crypt_method);
1111585f8587Sbellard     be64_to_cpus(&header.l1_table_offset);
1112585f8587Sbellard     be32_to_cpus(&header.l1_size);
1113585f8587Sbellard     be64_to_cpus(&header.refcount_table_offset);
1114585f8587Sbellard     be32_to_cpus(&header.refcount_table_clusters);
1115585f8587Sbellard     be64_to_cpus(&header.snapshots_offset);
1116585f8587Sbellard     be32_to_cpus(&header.nb_snapshots);
1117585f8587Sbellard 
1118e8cdcec1SKevin Wolf     if (header.magic != QCOW_MAGIC) {
11193ef6c40aSMax Reitz         error_setg(errp, "Image is not in qcow2 format");
112076abe407SPaolo Bonzini         ret = -EINVAL;
1121585f8587Sbellard         goto fail;
11226d85a57eSJes Sorensen     }
11236744cbabSKevin Wolf     if (header.version < 2 || header.version > 3) {
1124a55448b3SMax Reitz         error_setg(errp, "Unsupported qcow2 version %" PRIu32, header.version);
1125e8cdcec1SKevin Wolf         ret = -ENOTSUP;
1126e8cdcec1SKevin Wolf         goto fail;
1127e8cdcec1SKevin Wolf     }
11286744cbabSKevin Wolf 
11296744cbabSKevin Wolf     s->qcow_version = header.version;
11306744cbabSKevin Wolf 
113124342f2cSKevin Wolf     /* Initialise cluster size */
113224342f2cSKevin Wolf     if (header.cluster_bits < MIN_CLUSTER_BITS ||
113324342f2cSKevin Wolf         header.cluster_bits > MAX_CLUSTER_BITS) {
1134521b2b5dSMax Reitz         error_setg(errp, "Unsupported cluster size: 2^%" PRIu32,
1135521b2b5dSMax Reitz                    header.cluster_bits);
113624342f2cSKevin Wolf         ret = -EINVAL;
113724342f2cSKevin Wolf         goto fail;
113824342f2cSKevin Wolf     }
113924342f2cSKevin Wolf 
114024342f2cSKevin Wolf     s->cluster_bits = header.cluster_bits;
114124342f2cSKevin Wolf     s->cluster_size = 1 << s->cluster_bits;
114224342f2cSKevin Wolf     s->cluster_sectors = 1 << (s->cluster_bits - 9);
114324342f2cSKevin Wolf 
11446744cbabSKevin Wolf     /* Initialise version 3 header fields */
11456744cbabSKevin Wolf     if (header.version == 2) {
11466744cbabSKevin Wolf         header.incompatible_features    = 0;
11476744cbabSKevin Wolf         header.compatible_features      = 0;
11486744cbabSKevin Wolf         header.autoclear_features       = 0;
11496744cbabSKevin Wolf         header.refcount_order           = 4;
11506744cbabSKevin Wolf         header.header_length            = 72;
11516744cbabSKevin Wolf     } else {
11526744cbabSKevin Wolf         be64_to_cpus(&header.incompatible_features);
11536744cbabSKevin Wolf         be64_to_cpus(&header.compatible_features);
11546744cbabSKevin Wolf         be64_to_cpus(&header.autoclear_features);
11556744cbabSKevin Wolf         be32_to_cpus(&header.refcount_order);
11566744cbabSKevin Wolf         be32_to_cpus(&header.header_length);
115724342f2cSKevin Wolf 
115824342f2cSKevin Wolf         if (header.header_length < 104) {
115924342f2cSKevin Wolf             error_setg(errp, "qcow2 header too short");
116024342f2cSKevin Wolf             ret = -EINVAL;
116124342f2cSKevin Wolf             goto fail;
116224342f2cSKevin Wolf         }
116324342f2cSKevin Wolf     }
116424342f2cSKevin Wolf 
116524342f2cSKevin Wolf     if (header.header_length > s->cluster_size) {
116624342f2cSKevin Wolf         error_setg(errp, "qcow2 header exceeds cluster size");
116724342f2cSKevin Wolf         ret = -EINVAL;
116824342f2cSKevin Wolf         goto fail;
11696744cbabSKevin Wolf     }
11706744cbabSKevin Wolf 
11716744cbabSKevin Wolf     if (header.header_length > sizeof(header)) {
11726744cbabSKevin Wolf         s->unknown_header_fields_size = header.header_length - sizeof(header);
11736744cbabSKevin Wolf         s->unknown_header_fields = g_malloc(s->unknown_header_fields_size);
1174cf2ab8fcSKevin Wolf         ret = bdrv_pread(bs->file, sizeof(header), s->unknown_header_fields,
11756744cbabSKevin Wolf                          s->unknown_header_fields_size);
11766744cbabSKevin Wolf         if (ret < 0) {
11773ef6c40aSMax Reitz             error_setg_errno(errp, -ret, "Could not read unknown qcow2 header "
11783ef6c40aSMax Reitz                              "fields");
11796744cbabSKevin Wolf             goto fail;
11806744cbabSKevin Wolf         }
11816744cbabSKevin Wolf     }
11826744cbabSKevin Wolf 
1183a1b3955cSKevin Wolf     if (header.backing_file_offset > s->cluster_size) {
1184a1b3955cSKevin Wolf         error_setg(errp, "Invalid backing file offset");
1185a1b3955cSKevin Wolf         ret = -EINVAL;
1186a1b3955cSKevin Wolf         goto fail;
1187a1b3955cSKevin Wolf     }
1188a1b3955cSKevin Wolf 
1189cfcc4c62SKevin Wolf     if (header.backing_file_offset) {
1190cfcc4c62SKevin Wolf         ext_end = header.backing_file_offset;
1191cfcc4c62SKevin Wolf     } else {
1192cfcc4c62SKevin Wolf         ext_end = 1 << header.cluster_bits;
1193cfcc4c62SKevin Wolf     }
1194cfcc4c62SKevin Wolf 
11956744cbabSKevin Wolf     /* Handle feature bits */
11966744cbabSKevin Wolf     s->incompatible_features    = header.incompatible_features;
11976744cbabSKevin Wolf     s->compatible_features      = header.compatible_features;
11986744cbabSKevin Wolf     s->autoclear_features       = header.autoclear_features;
11996744cbabSKevin Wolf 
1200c61d0004SStefan Hajnoczi     if (s->incompatible_features & ~QCOW2_INCOMPAT_MASK) {
1201cfcc4c62SKevin Wolf         void *feature_table = NULL;
1202cfcc4c62SKevin Wolf         qcow2_read_extensions(bs, header.header_length, ext_end,
120388ddffaeSVladimir Sementsov-Ogievskiy                               &feature_table, flags, NULL, NULL);
1204a55448b3SMax Reitz         report_unsupported_feature(errp, feature_table,
1205c61d0004SStefan Hajnoczi                                    s->incompatible_features &
1206c61d0004SStefan Hajnoczi                                    ~QCOW2_INCOMPAT_MASK);
12076744cbabSKevin Wolf         ret = -ENOTSUP;
1208c5a33ee9SPrasad Joshi         g_free(feature_table);
12096744cbabSKevin Wolf         goto fail;
12106744cbabSKevin Wolf     }
12116744cbabSKevin Wolf 
121269c98726SMax Reitz     if (s->incompatible_features & QCOW2_INCOMPAT_CORRUPT) {
121369c98726SMax Reitz         /* Corrupt images may not be written to unless they are being repaired
121469c98726SMax Reitz          */
121569c98726SMax Reitz         if ((flags & BDRV_O_RDWR) && !(flags & BDRV_O_CHECK)) {
12163ef6c40aSMax Reitz             error_setg(errp, "qcow2: Image is corrupt; cannot be opened "
12173ef6c40aSMax Reitz                        "read/write");
121869c98726SMax Reitz             ret = -EACCES;
121969c98726SMax Reitz             goto fail;
122069c98726SMax Reitz         }
122169c98726SMax Reitz     }
122269c98726SMax Reitz 
12236744cbabSKevin Wolf     /* Check support for various header values */
1224b72faf9fSMax Reitz     if (header.refcount_order > 6) {
1225b72faf9fSMax Reitz         error_setg(errp, "Reference count entry width too large; may not "
1226b72faf9fSMax Reitz                    "exceed 64 bits");
1227b72faf9fSMax Reitz         ret = -EINVAL;
12286744cbabSKevin Wolf         goto fail;
12296744cbabSKevin Wolf     }
1230b6481f37SMax Reitz     s->refcount_order = header.refcount_order;
1231346a53dfSMax Reitz     s->refcount_bits = 1 << s->refcount_order;
1232346a53dfSMax Reitz     s->refcount_max = UINT64_C(1) << (s->refcount_bits - 1);
1233346a53dfSMax Reitz     s->refcount_max += s->refcount_max - 1;
12346744cbabSKevin Wolf 
1235585f8587Sbellard     s->crypt_method_header = header.crypt_method;
12366d85a57eSJes Sorensen     if (s->crypt_method_header) {
1237e6ff69bfSDaniel P. Berrange         if (bdrv_uses_whitelist() &&
1238e6ff69bfSDaniel P. Berrange             s->crypt_method_header == QCOW_CRYPT_AES) {
12398c0dcbc4SDaniel P. Berrange             error_setg(errp,
12408c0dcbc4SDaniel P. Berrange                        "Use of AES-CBC encrypted qcow2 images is no longer "
12418c0dcbc4SDaniel P. Berrange                        "supported in system emulators");
12428c0dcbc4SDaniel P. Berrange             error_append_hint(errp,
12438c0dcbc4SDaniel P. Berrange                               "You can use 'qemu-img convert' to convert your "
12448c0dcbc4SDaniel P. Berrange                               "image to an alternative supported format, such "
12458c0dcbc4SDaniel P. Berrange                               "as unencrypted qcow2, or raw with the LUKS "
12468c0dcbc4SDaniel P. Berrange                               "format instead.\n");
12478c0dcbc4SDaniel P. Berrange             ret = -ENOSYS;
12488c0dcbc4SDaniel P. Berrange             goto fail;
1249e6ff69bfSDaniel P. Berrange         }
1250e6ff69bfSDaniel P. Berrange 
12514652b8f3SDaniel P. Berrange         if (s->crypt_method_header == QCOW_CRYPT_AES) {
12524652b8f3SDaniel P. Berrange             s->crypt_physical_offset = false;
12534652b8f3SDaniel P. Berrange         } else {
12544652b8f3SDaniel P. Berrange             /* Assuming LUKS and any future crypt methods we
12554652b8f3SDaniel P. Berrange              * add will all use physical offsets, due to the
12564652b8f3SDaniel P. Berrange              * fact that the alternative is insecure...  */
12574652b8f3SDaniel P. Berrange             s->crypt_physical_offset = true;
12584652b8f3SDaniel P. Berrange         }
12594652b8f3SDaniel P. Berrange 
126054115412SEric Blake         bs->encrypted = true;
12616d85a57eSJes Sorensen     }
126224342f2cSKevin Wolf 
1263585f8587Sbellard     s->l2_bits = s->cluster_bits - 3; /* L2 is always one cluster */
1264585f8587Sbellard     s->l2_size = 1 << s->l2_bits;
12651d13d654SMax Reitz     /* 2^(s->refcount_order - 3) is the refcount width in bytes */
12661d13d654SMax Reitz     s->refcount_block_bits = s->cluster_bits - (s->refcount_order - 3);
12671d13d654SMax Reitz     s->refcount_block_size = 1 << s->refcount_block_bits;
1268585f8587Sbellard     bs->total_sectors = header.size / 512;
1269585f8587Sbellard     s->csize_shift = (62 - (s->cluster_bits - 8));
1270585f8587Sbellard     s->csize_mask = (1 << (s->cluster_bits - 8)) - 1;
1271585f8587Sbellard     s->cluster_offset_mask = (1LL << s->csize_shift) - 1;
12725dab2fadSKevin Wolf 
1273585f8587Sbellard     s->refcount_table_offset = header.refcount_table_offset;
1274585f8587Sbellard     s->refcount_table_size =
1275585f8587Sbellard         header.refcount_table_clusters << (s->cluster_bits - 3);
1276585f8587Sbellard 
12772b5d5953SKevin Wolf     if (header.refcount_table_clusters > qcow2_max_refcount_clusters(s)) {
12785dab2fadSKevin Wolf         error_setg(errp, "Reference count table too large");
12795dab2fadSKevin Wolf         ret = -EINVAL;
12805dab2fadSKevin Wolf         goto fail;
12815dab2fadSKevin Wolf     }
12825dab2fadSKevin Wolf 
12838c7de283SKevin Wolf     ret = validate_table_offset(bs, s->refcount_table_offset,
12848c7de283SKevin Wolf                                 s->refcount_table_size, sizeof(uint64_t));
12858c7de283SKevin Wolf     if (ret < 0) {
12868c7de283SKevin Wolf         error_setg(errp, "Invalid reference count table offset");
12878c7de283SKevin Wolf         goto fail;
12888c7de283SKevin Wolf     }
12898c7de283SKevin Wolf 
1290ce48f2f4SKevin Wolf     /* Snapshot table offset/length */
1291ce48f2f4SKevin Wolf     if (header.nb_snapshots > QCOW_MAX_SNAPSHOTS) {
1292ce48f2f4SKevin Wolf         error_setg(errp, "Too many snapshots");
1293ce48f2f4SKevin Wolf         ret = -EINVAL;
1294ce48f2f4SKevin Wolf         goto fail;
1295ce48f2f4SKevin Wolf     }
1296ce48f2f4SKevin Wolf 
1297ce48f2f4SKevin Wolf     ret = validate_table_offset(bs, header.snapshots_offset,
1298ce48f2f4SKevin Wolf                                 header.nb_snapshots,
1299ce48f2f4SKevin Wolf                                 sizeof(QCowSnapshotHeader));
1300ce48f2f4SKevin Wolf     if (ret < 0) {
1301ce48f2f4SKevin Wolf         error_setg(errp, "Invalid snapshot table offset");
1302ce48f2f4SKevin Wolf         goto fail;
1303ce48f2f4SKevin Wolf     }
1304ce48f2f4SKevin Wolf 
1305585f8587Sbellard     /* read the level 1 table */
130687b86e7eSWen Congyang     if (header.l1_size > QCOW_MAX_L1_SIZE / sizeof(uint64_t)) {
13072d51c32cSKevin Wolf         error_setg(errp, "Active L1 table too large");
13082d51c32cSKevin Wolf         ret = -EFBIG;
13092d51c32cSKevin Wolf         goto fail;
13102d51c32cSKevin Wolf     }
1311585f8587Sbellard     s->l1_size = header.l1_size;
13122cf7cfa1SKevin Wolf 
13132cf7cfa1SKevin Wolf     l1_vm_state_index = size_to_l1(s, header.size);
13142cf7cfa1SKevin Wolf     if (l1_vm_state_index > INT_MAX) {
13153ef6c40aSMax Reitz         error_setg(errp, "Image is too big");
13162cf7cfa1SKevin Wolf         ret = -EFBIG;
13172cf7cfa1SKevin Wolf         goto fail;
13182cf7cfa1SKevin Wolf     }
13192cf7cfa1SKevin Wolf     s->l1_vm_state_index = l1_vm_state_index;
13202cf7cfa1SKevin Wolf 
1321585f8587Sbellard     /* the L1 table must contain at least enough entries to put
1322585f8587Sbellard        header.size bytes */
13236d85a57eSJes Sorensen     if (s->l1_size < s->l1_vm_state_index) {
13243ef6c40aSMax Reitz         error_setg(errp, "L1 table is too small");
13256d85a57eSJes Sorensen         ret = -EINVAL;
1326585f8587Sbellard         goto fail;
13276d85a57eSJes Sorensen     }
13282d51c32cSKevin Wolf 
13292d51c32cSKevin Wolf     ret = validate_table_offset(bs, header.l1_table_offset,
13302d51c32cSKevin Wolf                                 header.l1_size, sizeof(uint64_t));
13312d51c32cSKevin Wolf     if (ret < 0) {
13322d51c32cSKevin Wolf         error_setg(errp, "Invalid L1 table offset");
13332d51c32cSKevin Wolf         goto fail;
13342d51c32cSKevin Wolf     }
1335585f8587Sbellard     s->l1_table_offset = header.l1_table_offset;
13362d51c32cSKevin Wolf 
13372d51c32cSKevin Wolf 
1338d191d12dSStefan Weil     if (s->l1_size > 0) {
13399a4f4c31SKevin Wolf         s->l1_table = qemu_try_blockalign(bs->file->bs,
13403f6a3ee5SKevin Wolf             align_offset(s->l1_size * sizeof(uint64_t), 512));
1341de82815dSKevin Wolf         if (s->l1_table == NULL) {
1342de82815dSKevin Wolf             error_setg(errp, "Could not allocate L1 table");
1343de82815dSKevin Wolf             ret = -ENOMEM;
1344de82815dSKevin Wolf             goto fail;
1345de82815dSKevin Wolf         }
1346cf2ab8fcSKevin Wolf         ret = bdrv_pread(bs->file, s->l1_table_offset, s->l1_table,
13476d85a57eSJes Sorensen                          s->l1_size * sizeof(uint64_t));
13486d85a57eSJes Sorensen         if (ret < 0) {
13493ef6c40aSMax Reitz             error_setg_errno(errp, -ret, "Could not read L1 table");
1350585f8587Sbellard             goto fail;
13516d85a57eSJes Sorensen         }
1352585f8587Sbellard         for(i = 0;i < s->l1_size; i++) {
1353585f8587Sbellard             be64_to_cpus(&s->l1_table[i]);
1354585f8587Sbellard         }
1355d191d12dSStefan Weil     }
135629c1a730SKevin Wolf 
135794edf3fbSKevin Wolf     /* Parse driver-specific options */
135894edf3fbSKevin Wolf     ret = qcow2_update_options(bs, options, flags, errp);
135990efa0eaSKevin Wolf     if (ret < 0) {
136090efa0eaSKevin Wolf         goto fail;
136190efa0eaSKevin Wolf     }
136290efa0eaSKevin Wolf 
13637267c094SAnthony Liguori     s->cluster_cache = g_malloc(s->cluster_size);
1364585f8587Sbellard     /* one more sector for decompressed data alignment */
13659a4f4c31SKevin Wolf     s->cluster_data = qemu_try_blockalign(bs->file->bs, QCOW_MAX_CRYPT_CLUSTERS
1366de82815dSKevin Wolf                                                     * s->cluster_size + 512);
1367de82815dSKevin Wolf     if (s->cluster_data == NULL) {
1368de82815dSKevin Wolf         error_setg(errp, "Could not allocate temporary cluster buffer");
1369de82815dSKevin Wolf         ret = -ENOMEM;
1370de82815dSKevin Wolf         goto fail;
1371de82815dSKevin Wolf     }
1372de82815dSKevin Wolf 
1373585f8587Sbellard     s->cluster_cache_offset = -1;
137406d9260fSAnthony Liguori     s->flags = flags;
1375585f8587Sbellard 
13766d85a57eSJes Sorensen     ret = qcow2_refcount_init(bs);
13776d85a57eSJes Sorensen     if (ret != 0) {
13783ef6c40aSMax Reitz         error_setg_errno(errp, -ret, "Could not initialize refcount handling");
1379585f8587Sbellard         goto fail;
13806d85a57eSJes Sorensen     }
1381585f8587Sbellard 
138272cf2d4fSBlue Swirl     QLIST_INIT(&s->cluster_allocs);
13830b919faeSKevin Wolf     QTAILQ_INIT(&s->discards);
1384f214978aSKevin Wolf 
13859b80ddf3Saliguori     /* read qcow2 extensions */
13863ef6c40aSMax Reitz     if (qcow2_read_extensions(bs, header.header_length, ext_end, NULL,
138788ddffaeSVladimir Sementsov-Ogievskiy                               flags, &update_header, &local_err)) {
13883ef6c40aSMax Reitz         error_propagate(errp, local_err);
13896d85a57eSJes Sorensen         ret = -EINVAL;
13909b80ddf3Saliguori         goto fail;
13916d85a57eSJes Sorensen     }
13929b80ddf3Saliguori 
13934652b8f3SDaniel P. Berrange     /* qcow2_read_extension may have set up the crypto context
13944652b8f3SDaniel P. Berrange      * if the crypt method needs a header region, some methods
13954652b8f3SDaniel P. Berrange      * don't need header extensions, so must check here
13964652b8f3SDaniel P. Berrange      */
13974652b8f3SDaniel P. Berrange     if (s->crypt_method_header && !s->crypto) {
1398b25b387fSDaniel P. Berrange         if (s->crypt_method_header == QCOW_CRYPT_AES) {
1399b25b387fSDaniel P. Berrange             unsigned int cflags = 0;
1400b25b387fSDaniel P. Berrange             if (flags & BDRV_O_NO_IO) {
1401b25b387fSDaniel P. Berrange                 cflags |= QCRYPTO_BLOCK_OPEN_NO_IO;
1402b25b387fSDaniel P. Berrange             }
14031cd9a787SDaniel P. Berrange             s->crypto = qcrypto_block_open(s->crypto_opts, "encrypt.",
14041cd9a787SDaniel P. Berrange                                            NULL, NULL, cflags, errp);
1405b25b387fSDaniel P. Berrange             if (!s->crypto) {
1406b25b387fSDaniel P. Berrange                 ret = -EINVAL;
1407b25b387fSDaniel P. Berrange                 goto fail;
1408b25b387fSDaniel P. Berrange             }
14094652b8f3SDaniel P. Berrange         } else if (!(flags & BDRV_O_NO_IO)) {
14104652b8f3SDaniel P. Berrange             error_setg(errp, "Missing CRYPTO header for crypt method %d",
14114652b8f3SDaniel P. Berrange                        s->crypt_method_header);
14124652b8f3SDaniel P. Berrange             ret = -EINVAL;
14134652b8f3SDaniel P. Berrange             goto fail;
14144652b8f3SDaniel P. Berrange         }
1415b25b387fSDaniel P. Berrange     }
1416b25b387fSDaniel P. Berrange 
1417585f8587Sbellard     /* read the backing file name */
1418585f8587Sbellard     if (header.backing_file_offset != 0) {
1419585f8587Sbellard         len = header.backing_file_size;
14209a29e18fSJeff Cody         if (len > MIN(1023, s->cluster_size - header.backing_file_offset) ||
1421e729fa6aSJeff Cody             len >= sizeof(bs->backing_file)) {
14226d33e8e7SKevin Wolf             error_setg(errp, "Backing file name too long");
14236d33e8e7SKevin Wolf             ret = -EINVAL;
14246d33e8e7SKevin Wolf             goto fail;
14256d85a57eSJes Sorensen         }
1426cf2ab8fcSKevin Wolf         ret = bdrv_pread(bs->file, header.backing_file_offset,
14276d85a57eSJes Sorensen                          bs->backing_file, len);
14286d85a57eSJes Sorensen         if (ret < 0) {
14293ef6c40aSMax Reitz             error_setg_errno(errp, -ret, "Could not read backing file name");
1430585f8587Sbellard             goto fail;
14316d85a57eSJes Sorensen         }
1432585f8587Sbellard         bs->backing_file[len] = '\0';
1433e4603fe1SKevin Wolf         s->image_backing_file = g_strdup(bs->backing_file);
1434585f8587Sbellard     }
143542deb29fSKevin Wolf 
143611b128f4SKevin Wolf     /* Internal snapshots */
143711b128f4SKevin Wolf     s->snapshots_offset = header.snapshots_offset;
143811b128f4SKevin Wolf     s->nb_snapshots = header.nb_snapshots;
143911b128f4SKevin Wolf 
144042deb29fSKevin Wolf     ret = qcow2_read_snapshots(bs);
144142deb29fSKevin Wolf     if (ret < 0) {
14423ef6c40aSMax Reitz         error_setg_errno(errp, -ret, "Could not read snapshots");
1443585f8587Sbellard         goto fail;
14446d85a57eSJes Sorensen     }
1445585f8587Sbellard 
1446af7b708dSStefan Hajnoczi     /* Clear unknown autoclear feature bits */
144788ddffaeSVladimir Sementsov-Ogievskiy     update_header |= s->autoclear_features & ~QCOW2_AUTOCLEAR_MASK;
1448d1258dd0SVladimir Sementsov-Ogievskiy     update_header =
1449d1258dd0SVladimir Sementsov-Ogievskiy         update_header && !bs->read_only && !(flags & BDRV_O_INACTIVE);
1450d1258dd0SVladimir Sementsov-Ogievskiy     if (update_header) {
145188ddffaeSVladimir Sementsov-Ogievskiy         s->autoclear_features &= QCOW2_AUTOCLEAR_MASK;
1452d1258dd0SVladimir Sementsov-Ogievskiy     }
1453d1258dd0SVladimir Sementsov-Ogievskiy 
1454d1258dd0SVladimir Sementsov-Ogievskiy     if (qcow2_load_autoloading_dirty_bitmaps(bs, &local_err)) {
1455d1258dd0SVladimir Sementsov-Ogievskiy         update_header = false;
1456d1258dd0SVladimir Sementsov-Ogievskiy     }
1457d1258dd0SVladimir Sementsov-Ogievskiy     if (local_err != NULL) {
1458d1258dd0SVladimir Sementsov-Ogievskiy         error_propagate(errp, local_err);
1459d1258dd0SVladimir Sementsov-Ogievskiy         ret = -EINVAL;
1460d1258dd0SVladimir Sementsov-Ogievskiy         goto fail;
1461d1258dd0SVladimir Sementsov-Ogievskiy     }
1462d1258dd0SVladimir Sementsov-Ogievskiy 
1463d1258dd0SVladimir Sementsov-Ogievskiy     if (update_header) {
1464af7b708dSStefan Hajnoczi         ret = qcow2_update_header(bs);
1465af7b708dSStefan Hajnoczi         if (ret < 0) {
14663ef6c40aSMax Reitz             error_setg_errno(errp, -ret, "Could not update qcow2 header");
1467af7b708dSStefan Hajnoczi             goto fail;
1468af7b708dSStefan Hajnoczi         }
1469af7b708dSStefan Hajnoczi     }
1470af7b708dSStefan Hajnoczi 
147168d100e9SKevin Wolf     /* Initialise locks */
147268d100e9SKevin Wolf     qemu_co_mutex_init(&s->lock);
1473170f4b2eSFam Zheng     bs->supported_zero_flags = BDRV_REQ_MAY_UNMAP;
147468d100e9SKevin Wolf 
1475c61d0004SStefan Hajnoczi     /* Repair image if dirty */
147604c01a5cSKevin Wolf     if (!(flags & (BDRV_O_CHECK | BDRV_O_INACTIVE)) && !bs->read_only &&
1477058f8f16SStefan Hajnoczi         (s->incompatible_features & QCOW2_INCOMPAT_DIRTY)) {
1478c61d0004SStefan Hajnoczi         BdrvCheckResult result = {0};
1479c61d0004SStefan Hajnoczi 
14805b84106bSMax Reitz         ret = qcow2_check(bs, &result, BDRV_FIX_ERRORS | BDRV_FIX_LEAKS);
1481c61d0004SStefan Hajnoczi         if (ret < 0) {
14823ef6c40aSMax Reitz             error_setg_errno(errp, -ret, "Could not repair dirty image");
1483c61d0004SStefan Hajnoczi             goto fail;
1484c61d0004SStefan Hajnoczi         }
1485c61d0004SStefan Hajnoczi     }
1486c61d0004SStefan Hajnoczi 
1487585f8587Sbellard #ifdef DEBUG_ALLOC
14886cbc3031SPhilipp Hahn     {
14896cbc3031SPhilipp Hahn         BdrvCheckResult result = {0};
1490b35278f7SStefan Hajnoczi         qcow2_check_refcounts(bs, &result, 0);
14916cbc3031SPhilipp Hahn     }
1492585f8587Sbellard #endif
14936d85a57eSJes Sorensen     return ret;
1494585f8587Sbellard 
1495585f8587Sbellard  fail:
14966744cbabSKevin Wolf     g_free(s->unknown_header_fields);
149775bab85cSKevin Wolf     cleanup_unknown_header_ext(bs);
1498ed6ccf0fSKevin Wolf     qcow2_free_snapshots(bs);
1499ed6ccf0fSKevin Wolf     qcow2_refcount_close(bs);
1500de82815dSKevin Wolf     qemu_vfree(s->l1_table);
1501cf93980eSMax Reitz     /* else pre-write overlap checks in cache_destroy may crash */
1502cf93980eSMax Reitz     s->l1_table = NULL;
1503279621c0SAlberto Garcia     cache_clean_timer_del(bs);
150429c1a730SKevin Wolf     if (s->l2_table_cache) {
150529c1a730SKevin Wolf         qcow2_cache_destroy(bs, s->l2_table_cache);
150629c1a730SKevin Wolf     }
1507c5a33ee9SPrasad Joshi     if (s->refcount_block_cache) {
1508c5a33ee9SPrasad Joshi         qcow2_cache_destroy(bs, s->refcount_block_cache);
1509c5a33ee9SPrasad Joshi     }
15107267c094SAnthony Liguori     g_free(s->cluster_cache);
1511dea43a65SFrediano Ziglio     qemu_vfree(s->cluster_data);
1512b25b387fSDaniel P. Berrange     qcrypto_block_free(s->crypto);
1513b25b387fSDaniel P. Berrange     qapi_free_QCryptoBlockOpenOptions(s->crypto_opts);
15146d85a57eSJes Sorensen     return ret;
1515585f8587Sbellard }
1516585f8587Sbellard 
15174e4bf5c4SKevin Wolf static int qcow2_open(BlockDriverState *bs, QDict *options, int flags,
15184e4bf5c4SKevin Wolf                       Error **errp)
15194e4bf5c4SKevin Wolf {
15204e4bf5c4SKevin Wolf     bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
15214e4bf5c4SKevin Wolf                                false, errp);
15224e4bf5c4SKevin Wolf     if (!bs->file) {
15234e4bf5c4SKevin Wolf         return -EINVAL;
15244e4bf5c4SKevin Wolf     }
15254e4bf5c4SKevin Wolf 
15264e4bf5c4SKevin Wolf     return qcow2_do_open(bs, options, flags, errp);
15274e4bf5c4SKevin Wolf }
15284e4bf5c4SKevin Wolf 
15293baca891SKevin Wolf static void qcow2_refresh_limits(BlockDriverState *bs, Error **errp)
1530d34682cdSKevin Wolf {
1531ff99129aSKevin Wolf     BDRVQcow2State *s = bs->opaque;
1532d34682cdSKevin Wolf 
1533a84178ccSEric Blake     if (bs->encrypted) {
1534a84178ccSEric Blake         /* Encryption works on a sector granularity */
1535a5b8dd2cSEric Blake         bs->bl.request_alignment = BDRV_SECTOR_SIZE;
1536a84178ccSEric Blake     }
1537cf081fcaSEric Blake     bs->bl.pwrite_zeroes_alignment = s->cluster_size;
1538ecdbead6SEric Blake     bs->bl.pdiscard_alignment = s->cluster_size;
1539d34682cdSKevin Wolf }
1540d34682cdSKevin Wolf 
154121d82ac9SJeff Cody static int qcow2_reopen_prepare(BDRVReopenState *state,
154221d82ac9SJeff Cody                                 BlockReopenQueue *queue, Error **errp)
154321d82ac9SJeff Cody {
15445b0959a7SKevin Wolf     Qcow2ReopenState *r;
15454c2e5f8fSKevin Wolf     int ret;
15464c2e5f8fSKevin Wolf 
15475b0959a7SKevin Wolf     r = g_new0(Qcow2ReopenState, 1);
15485b0959a7SKevin Wolf     state->opaque = r;
15495b0959a7SKevin Wolf 
15505b0959a7SKevin Wolf     ret = qcow2_update_options_prepare(state->bs, r, state->options,
15515b0959a7SKevin Wolf                                        state->flags, errp);
15525b0959a7SKevin Wolf     if (ret < 0) {
15535b0959a7SKevin Wolf         goto fail;
15545b0959a7SKevin Wolf     }
15555b0959a7SKevin Wolf 
15565b0959a7SKevin Wolf     /* We need to write out any unwritten data if we reopen read-only. */
15574c2e5f8fSKevin Wolf     if ((state->flags & BDRV_O_RDWR) == 0) {
1558169b8793SVladimir Sementsov-Ogievskiy         ret = qcow2_reopen_bitmaps_ro(state->bs, errp);
1559169b8793SVladimir Sementsov-Ogievskiy         if (ret < 0) {
1560169b8793SVladimir Sementsov-Ogievskiy             goto fail;
1561169b8793SVladimir Sementsov-Ogievskiy         }
1562169b8793SVladimir Sementsov-Ogievskiy 
15634c2e5f8fSKevin Wolf         ret = bdrv_flush(state->bs);
15644c2e5f8fSKevin Wolf         if (ret < 0) {
15655b0959a7SKevin Wolf             goto fail;
15664c2e5f8fSKevin Wolf         }
15674c2e5f8fSKevin Wolf 
15684c2e5f8fSKevin Wolf         ret = qcow2_mark_clean(state->bs);
15694c2e5f8fSKevin Wolf         if (ret < 0) {
15705b0959a7SKevin Wolf             goto fail;
15714c2e5f8fSKevin Wolf         }
15724c2e5f8fSKevin Wolf     }
15734c2e5f8fSKevin Wolf 
157421d82ac9SJeff Cody     return 0;
15755b0959a7SKevin Wolf 
15765b0959a7SKevin Wolf fail:
15775b0959a7SKevin Wolf     qcow2_update_options_abort(state->bs, r);
15785b0959a7SKevin Wolf     g_free(r);
15795b0959a7SKevin Wolf     return ret;
15805b0959a7SKevin Wolf }
15815b0959a7SKevin Wolf 
15825b0959a7SKevin Wolf static void qcow2_reopen_commit(BDRVReopenState *state)
15835b0959a7SKevin Wolf {
15845b0959a7SKevin Wolf     qcow2_update_options_commit(state->bs, state->opaque);
15855b0959a7SKevin Wolf     g_free(state->opaque);
15865b0959a7SKevin Wolf }
15875b0959a7SKevin Wolf 
15885b0959a7SKevin Wolf static void qcow2_reopen_abort(BDRVReopenState *state)
15895b0959a7SKevin Wolf {
15905b0959a7SKevin Wolf     qcow2_update_options_abort(state->bs, state->opaque);
15915b0959a7SKevin Wolf     g_free(state->opaque);
159221d82ac9SJeff Cody }
159321d82ac9SJeff Cody 
15945365f44dSKevin Wolf static void qcow2_join_options(QDict *options, QDict *old_options)
15955365f44dSKevin Wolf {
15965365f44dSKevin Wolf     bool has_new_overlap_template =
15975365f44dSKevin Wolf         qdict_haskey(options, QCOW2_OPT_OVERLAP) ||
15985365f44dSKevin Wolf         qdict_haskey(options, QCOW2_OPT_OVERLAP_TEMPLATE);
15995365f44dSKevin Wolf     bool has_new_total_cache_size =
16005365f44dSKevin Wolf         qdict_haskey(options, QCOW2_OPT_CACHE_SIZE);
16015365f44dSKevin Wolf     bool has_all_cache_options;
16025365f44dSKevin Wolf 
16035365f44dSKevin Wolf     /* New overlap template overrides all old overlap options */
16045365f44dSKevin Wolf     if (has_new_overlap_template) {
16055365f44dSKevin Wolf         qdict_del(old_options, QCOW2_OPT_OVERLAP);
16065365f44dSKevin Wolf         qdict_del(old_options, QCOW2_OPT_OVERLAP_TEMPLATE);
16075365f44dSKevin Wolf         qdict_del(old_options, QCOW2_OPT_OVERLAP_MAIN_HEADER);
16085365f44dSKevin Wolf         qdict_del(old_options, QCOW2_OPT_OVERLAP_ACTIVE_L1);
16095365f44dSKevin Wolf         qdict_del(old_options, QCOW2_OPT_OVERLAP_ACTIVE_L2);
16105365f44dSKevin Wolf         qdict_del(old_options, QCOW2_OPT_OVERLAP_REFCOUNT_TABLE);
16115365f44dSKevin Wolf         qdict_del(old_options, QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK);
16125365f44dSKevin Wolf         qdict_del(old_options, QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE);
16135365f44dSKevin Wolf         qdict_del(old_options, QCOW2_OPT_OVERLAP_INACTIVE_L1);
16145365f44dSKevin Wolf         qdict_del(old_options, QCOW2_OPT_OVERLAP_INACTIVE_L2);
16155365f44dSKevin Wolf     }
16165365f44dSKevin Wolf 
16175365f44dSKevin Wolf     /* New total cache size overrides all old options */
16185365f44dSKevin Wolf     if (qdict_haskey(options, QCOW2_OPT_CACHE_SIZE)) {
16195365f44dSKevin Wolf         qdict_del(old_options, QCOW2_OPT_L2_CACHE_SIZE);
16205365f44dSKevin Wolf         qdict_del(old_options, QCOW2_OPT_REFCOUNT_CACHE_SIZE);
16215365f44dSKevin Wolf     }
16225365f44dSKevin Wolf 
16235365f44dSKevin Wolf     qdict_join(options, old_options, false);
16245365f44dSKevin Wolf 
16255365f44dSKevin Wolf     /*
16265365f44dSKevin Wolf      * If after merging all cache size options are set, an old total size is
16275365f44dSKevin Wolf      * overwritten. Do keep all options, however, if all three are new. The
16285365f44dSKevin Wolf      * resulting error message is what we want to happen.
16295365f44dSKevin Wolf      */
16305365f44dSKevin Wolf     has_all_cache_options =
16315365f44dSKevin Wolf         qdict_haskey(options, QCOW2_OPT_CACHE_SIZE) ||
16325365f44dSKevin Wolf         qdict_haskey(options, QCOW2_OPT_L2_CACHE_SIZE) ||
16335365f44dSKevin Wolf         qdict_haskey(options, QCOW2_OPT_REFCOUNT_CACHE_SIZE);
16345365f44dSKevin Wolf 
16355365f44dSKevin Wolf     if (has_all_cache_options && !has_new_total_cache_size) {
16365365f44dSKevin Wolf         qdict_del(options, QCOW2_OPT_CACHE_SIZE);
16375365f44dSKevin Wolf     }
16385365f44dSKevin Wolf }
16395365f44dSKevin Wolf 
1640b6b8a333SPaolo Bonzini static int64_t coroutine_fn qcow2_co_get_block_status(BlockDriverState *bs,
164167a0fd2aSFam Zheng         int64_t sector_num, int nb_sectors, int *pnum, BlockDriverState **file)
1642585f8587Sbellard {
1643ff99129aSKevin Wolf     BDRVQcow2State *s = bs->opaque;
1644585f8587Sbellard     uint64_t cluster_offset;
16454bc74be9SPaolo Bonzini     int index_in_cluster, ret;
1646ecfe1863SKevin Wolf     unsigned int bytes;
16474bc74be9SPaolo Bonzini     int64_t status = 0;
1648585f8587Sbellard 
1649ecfe1863SKevin Wolf     bytes = MIN(INT_MAX, nb_sectors * BDRV_SECTOR_SIZE);
1650f8a2e5e3SStefan Hajnoczi     qemu_co_mutex_lock(&s->lock);
1651ecfe1863SKevin Wolf     ret = qcow2_get_cluster_offset(bs, sector_num << 9, &bytes,
1652ecfe1863SKevin Wolf                                    &cluster_offset);
1653f8a2e5e3SStefan Hajnoczi     qemu_co_mutex_unlock(&s->lock);
16541c46efaaSKevin Wolf     if (ret < 0) {
1655d663640cSPaolo Bonzini         return ret;
16561c46efaaSKevin Wolf     }
1657095a9c58Saliguori 
1658ecfe1863SKevin Wolf     *pnum = bytes >> BDRV_SECTOR_BITS;
1659ecfe1863SKevin Wolf 
16604bc74be9SPaolo Bonzini     if (cluster_offset != 0 && ret != QCOW2_CLUSTER_COMPRESSED &&
1661b25b387fSDaniel P. Berrange         !s->crypto) {
16624bc74be9SPaolo Bonzini         index_in_cluster = sector_num & (s->cluster_sectors - 1);
16634bc74be9SPaolo Bonzini         cluster_offset |= (index_in_cluster << BDRV_SECTOR_BITS);
1664178b4db7SFam Zheng         *file = bs->file->bs;
16654bc74be9SPaolo Bonzini         status |= BDRV_BLOCK_OFFSET_VALID | cluster_offset;
16664bc74be9SPaolo Bonzini     }
1667fdfab37dSEric Blake     if (ret == QCOW2_CLUSTER_ZERO_PLAIN || ret == QCOW2_CLUSTER_ZERO_ALLOC) {
16684bc74be9SPaolo Bonzini         status |= BDRV_BLOCK_ZERO;
16694bc74be9SPaolo Bonzini     } else if (ret != QCOW2_CLUSTER_UNALLOCATED) {
16704bc74be9SPaolo Bonzini         status |= BDRV_BLOCK_DATA;
16714bc74be9SPaolo Bonzini     }
16724bc74be9SPaolo Bonzini     return status;
1673585f8587Sbellard }
1674585f8587Sbellard 
1675a9465922Sbellard /* handle reading after the end of the backing file */
1676bd28f835SKevin Wolf int qcow2_backing_read1(BlockDriverState *bs, QEMUIOVector *qiov,
1677ecfe1863SKevin Wolf                         int64_t offset, int bytes)
1678a9465922Sbellard {
1679ecfe1863SKevin Wolf     uint64_t bs_size = bs->total_sectors * BDRV_SECTOR_SIZE;
1680a9465922Sbellard     int n1;
1681bd28f835SKevin Wolf 
1682ecfe1863SKevin Wolf     if ((offset + bytes) <= bs_size) {
1683ecfe1863SKevin Wolf         return bytes;
1684ecfe1863SKevin Wolf     }
1685ecfe1863SKevin Wolf 
1686ecfe1863SKevin Wolf     if (offset >= bs_size) {
1687ecfe1863SKevin Wolf         n1 = 0;
1688ecfe1863SKevin Wolf     } else {
1689ecfe1863SKevin Wolf         n1 = bs_size - offset;
1690ecfe1863SKevin Wolf     }
1691ecfe1863SKevin Wolf 
1692ecfe1863SKevin Wolf     qemu_iovec_memset(qiov, n1, 0, bytes - n1);
1693bd28f835SKevin Wolf 
1694a9465922Sbellard     return n1;
1695a9465922Sbellard }
1696a9465922Sbellard 
1697ecfe1863SKevin Wolf static coroutine_fn int qcow2_co_preadv(BlockDriverState *bs, uint64_t offset,
1698ecfe1863SKevin Wolf                                         uint64_t bytes, QEMUIOVector *qiov,
1699ecfe1863SKevin Wolf                                         int flags)
17001490791fSaliguori {
1701ff99129aSKevin Wolf     BDRVQcow2State *s = bs->opaque;
1702ecfe1863SKevin Wolf     int offset_in_cluster, n1;
170368d100e9SKevin Wolf     int ret;
1704ecfe1863SKevin Wolf     unsigned int cur_bytes; /* number of bytes in current iteration */
1705c2bdd990SFrediano Ziglio     uint64_t cluster_offset = 0;
17063fc48d09SFrediano Ziglio     uint64_t bytes_done = 0;
17073fc48d09SFrediano Ziglio     QEMUIOVector hd_qiov;
17083fc48d09SFrediano Ziglio     uint8_t *cluster_data = NULL;
1709585f8587Sbellard 
17103fc48d09SFrediano Ziglio     qemu_iovec_init(&hd_qiov, qiov->niov);
17113fc48d09SFrediano Ziglio 
17123fc48d09SFrediano Ziglio     qemu_co_mutex_lock(&s->lock);
17133fc48d09SFrediano Ziglio 
1714ecfe1863SKevin Wolf     while (bytes != 0) {
1715585f8587Sbellard 
1716faf575c1SFrediano Ziglio         /* prepare next request */
1717ecfe1863SKevin Wolf         cur_bytes = MIN(bytes, INT_MAX);
1718b25b387fSDaniel P. Berrange         if (s->crypto) {
1719ecfe1863SKevin Wolf             cur_bytes = MIN(cur_bytes,
1720ecfe1863SKevin Wolf                             QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size);
1721bd28f835SKevin Wolf         }
1722bd28f835SKevin Wolf 
1723ecfe1863SKevin Wolf         ret = qcow2_get_cluster_offset(bs, offset, &cur_bytes, &cluster_offset);
17241c46efaaSKevin Wolf         if (ret < 0) {
17253fc48d09SFrediano Ziglio             goto fail;
17261c46efaaSKevin Wolf         }
17271c46efaaSKevin Wolf 
1728ecfe1863SKevin Wolf         offset_in_cluster = offset_into_cluster(s, offset);
1729585f8587Sbellard 
17303fc48d09SFrediano Ziglio         qemu_iovec_reset(&hd_qiov);
1731ecfe1863SKevin Wolf         qemu_iovec_concat(&hd_qiov, qiov, bytes_done, cur_bytes);
1732bd28f835SKevin Wolf 
173368d000a3SKevin Wolf         switch (ret) {
173468d000a3SKevin Wolf         case QCOW2_CLUSTER_UNALLOCATED:
1735bd28f835SKevin Wolf 
1736760e0063SKevin Wolf             if (bs->backing) {
1737585f8587Sbellard                 /* read from the base image */
1738760e0063SKevin Wolf                 n1 = qcow2_backing_read1(bs->backing->bs, &hd_qiov,
1739ecfe1863SKevin Wolf                                          offset, cur_bytes);
1740a9465922Sbellard                 if (n1 > 0) {
174144deba5aSKevin Wolf                     QEMUIOVector local_qiov;
174244deba5aSKevin Wolf 
174344deba5aSKevin Wolf                     qemu_iovec_init(&local_qiov, hd_qiov.niov);
1744ecfe1863SKevin Wolf                     qemu_iovec_concat(&local_qiov, &hd_qiov, 0, n1);
174544deba5aSKevin Wolf 
174666f82ceeSKevin Wolf                     BLKDBG_EVENT(bs->file, BLKDBG_READ_BACKING_AIO);
174768d100e9SKevin Wolf                     qemu_co_mutex_unlock(&s->lock);
1748a03ef88fSKevin Wolf                     ret = bdrv_co_preadv(bs->backing, offset, n1,
1749ecfe1863SKevin Wolf                                          &local_qiov, 0);
175068d100e9SKevin Wolf                     qemu_co_mutex_lock(&s->lock);
175144deba5aSKevin Wolf 
175244deba5aSKevin Wolf                     qemu_iovec_destroy(&local_qiov);
175344deba5aSKevin Wolf 
175468d100e9SKevin Wolf                     if (ret < 0) {
17553fc48d09SFrediano Ziglio                         goto fail;
17563ab4c7e9SKevin Wolf                     }
17571490791fSaliguori                 }
1758a9465922Sbellard             } else {
1759585f8587Sbellard                 /* Note: in this case, no need to wait */
1760ecfe1863SKevin Wolf                 qemu_iovec_memset(&hd_qiov, 0, 0, cur_bytes);
17611490791fSaliguori             }
176268d000a3SKevin Wolf             break;
176368d000a3SKevin Wolf 
1764fdfab37dSEric Blake         case QCOW2_CLUSTER_ZERO_PLAIN:
1765fdfab37dSEric Blake         case QCOW2_CLUSTER_ZERO_ALLOC:
1766ecfe1863SKevin Wolf             qemu_iovec_memset(&hd_qiov, 0, 0, cur_bytes);
17676377af48SKevin Wolf             break;
17686377af48SKevin Wolf 
176968d000a3SKevin Wolf         case QCOW2_CLUSTER_COMPRESSED:
1770585f8587Sbellard             /* add AIO support for compressed blocks ? */
1771c2bdd990SFrediano Ziglio             ret = qcow2_decompress_cluster(bs, cluster_offset);
17728af36488SKevin Wolf             if (ret < 0) {
17733fc48d09SFrediano Ziglio                 goto fail;
17748af36488SKevin Wolf             }
1775bd28f835SKevin Wolf 
177603396148SMichael Tokarev             qemu_iovec_from_buf(&hd_qiov, 0,
1777ecfe1863SKevin Wolf                                 s->cluster_cache + offset_in_cluster,
1778ecfe1863SKevin Wolf                                 cur_bytes);
177968d000a3SKevin Wolf             break;
178068d000a3SKevin Wolf 
178168d000a3SKevin Wolf         case QCOW2_CLUSTER_NORMAL:
1782c2bdd990SFrediano Ziglio             if ((cluster_offset & 511) != 0) {
17833fc48d09SFrediano Ziglio                 ret = -EIO;
17843fc48d09SFrediano Ziglio                 goto fail;
1785585f8587Sbellard             }
1786c87c0672Saliguori 
17878336aafaSDaniel P. Berrange             if (bs->encrypted) {
1788b25b387fSDaniel P. Berrange                 assert(s->crypto);
17898336aafaSDaniel P. Berrange 
1790bd28f835SKevin Wolf                 /*
1791bd28f835SKevin Wolf                  * For encrypted images, read everything into a temporary
1792bd28f835SKevin Wolf                  * contiguous buffer on which the AES functions can work.
1793bd28f835SKevin Wolf                  */
17943fc48d09SFrediano Ziglio                 if (!cluster_data) {
17953fc48d09SFrediano Ziglio                     cluster_data =
17969a4f4c31SKevin Wolf                         qemu_try_blockalign(bs->file->bs,
17979a4f4c31SKevin Wolf                                             QCOW_MAX_CRYPT_CLUSTERS
1798de82815dSKevin Wolf                                             * s->cluster_size);
1799de82815dSKevin Wolf                     if (cluster_data == NULL) {
1800de82815dSKevin Wolf                         ret = -ENOMEM;
1801de82815dSKevin Wolf                         goto fail;
1802de82815dSKevin Wolf                     }
1803bd28f835SKevin Wolf                 }
1804bd28f835SKevin Wolf 
1805ecfe1863SKevin Wolf                 assert(cur_bytes <= QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size);
18063fc48d09SFrediano Ziglio                 qemu_iovec_reset(&hd_qiov);
1807ecfe1863SKevin Wolf                 qemu_iovec_add(&hd_qiov, cluster_data, cur_bytes);
1808bd28f835SKevin Wolf             }
1809bd28f835SKevin Wolf 
181066f82ceeSKevin Wolf             BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO);
181168d100e9SKevin Wolf             qemu_co_mutex_unlock(&s->lock);
1812a03ef88fSKevin Wolf             ret = bdrv_co_preadv(bs->file,
1813ecfe1863SKevin Wolf                                  cluster_offset + offset_in_cluster,
1814ecfe1863SKevin Wolf                                  cur_bytes, &hd_qiov, 0);
181568d100e9SKevin Wolf             qemu_co_mutex_lock(&s->lock);
181668d100e9SKevin Wolf             if (ret < 0) {
18173fc48d09SFrediano Ziglio                 goto fail;
1818585f8587Sbellard             }
18198336aafaSDaniel P. Berrange             if (bs->encrypted) {
1820b25b387fSDaniel P. Berrange                 assert(s->crypto);
1821ecfe1863SKevin Wolf                 assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0);
1822ecfe1863SKevin Wolf                 assert((cur_bytes & (BDRV_SECTOR_SIZE - 1)) == 0);
1823b25b387fSDaniel P. Berrange                 if (qcrypto_block_decrypt(s->crypto,
18244652b8f3SDaniel P. Berrange                                           (s->crypt_physical_offset ?
18254652b8f3SDaniel P. Berrange                                            cluster_offset + offset_in_cluster :
18264652b8f3SDaniel P. Berrange                                            offset) >> BDRV_SECTOR_BITS,
1827446d306dSDaniel P. Berrange                                           cluster_data,
1828b25b387fSDaniel P. Berrange                                           cur_bytes,
1829*c3a8fe33SAlberto Garcia                                           NULL) < 0) {
1830f6fa64f6SDaniel P. Berrange                     ret = -EIO;
1831f6fa64f6SDaniel P. Berrange                     goto fail;
1832f6fa64f6SDaniel P. Berrange                 }
1833ecfe1863SKevin Wolf                 qemu_iovec_from_buf(qiov, bytes_done, cluster_data, cur_bytes);
1834171e3d6bSKevin Wolf             }
183568d000a3SKevin Wolf             break;
183668d000a3SKevin Wolf 
183768d000a3SKevin Wolf         default:
183868d000a3SKevin Wolf             g_assert_not_reached();
183968d000a3SKevin Wolf             ret = -EIO;
184068d000a3SKevin Wolf             goto fail;
1841faf575c1SFrediano Ziglio         }
1842faf575c1SFrediano Ziglio 
1843ecfe1863SKevin Wolf         bytes -= cur_bytes;
1844ecfe1863SKevin Wolf         offset += cur_bytes;
1845ecfe1863SKevin Wolf         bytes_done += cur_bytes;
18465ebaa27eSFrediano Ziglio     }
18473fc48d09SFrediano Ziglio     ret = 0;
1848f141eafeSaliguori 
18493fc48d09SFrediano Ziglio fail:
185068d100e9SKevin Wolf     qemu_co_mutex_unlock(&s->lock);
185168d100e9SKevin Wolf 
18523fc48d09SFrediano Ziglio     qemu_iovec_destroy(&hd_qiov);
1853dea43a65SFrediano Ziglio     qemu_vfree(cluster_data);
185468d100e9SKevin Wolf 
185568d100e9SKevin Wolf     return ret;
1856585f8587Sbellard }
1857585f8587Sbellard 
1858ee22a9d8SAlberto Garcia /* Check if it's possible to merge a write request with the writing of
1859ee22a9d8SAlberto Garcia  * the data from the COW regions */
1860ee22a9d8SAlberto Garcia static bool merge_cow(uint64_t offset, unsigned bytes,
1861ee22a9d8SAlberto Garcia                       QEMUIOVector *hd_qiov, QCowL2Meta *l2meta)
1862ee22a9d8SAlberto Garcia {
1863ee22a9d8SAlberto Garcia     QCowL2Meta *m;
1864ee22a9d8SAlberto Garcia 
1865ee22a9d8SAlberto Garcia     for (m = l2meta; m != NULL; m = m->next) {
1866ee22a9d8SAlberto Garcia         /* If both COW regions are empty then there's nothing to merge */
1867ee22a9d8SAlberto Garcia         if (m->cow_start.nb_bytes == 0 && m->cow_end.nb_bytes == 0) {
1868ee22a9d8SAlberto Garcia             continue;
1869ee22a9d8SAlberto Garcia         }
1870ee22a9d8SAlberto Garcia 
1871ee22a9d8SAlberto Garcia         /* The data (middle) region must be immediately after the
1872ee22a9d8SAlberto Garcia          * start region */
1873ee22a9d8SAlberto Garcia         if (l2meta_cow_start(m) + m->cow_start.nb_bytes != offset) {
1874ee22a9d8SAlberto Garcia             continue;
1875ee22a9d8SAlberto Garcia         }
1876ee22a9d8SAlberto Garcia 
1877ee22a9d8SAlberto Garcia         /* The end region must be immediately after the data (middle)
1878ee22a9d8SAlberto Garcia          * region */
1879ee22a9d8SAlberto Garcia         if (m->offset + m->cow_end.offset != offset + bytes) {
1880ee22a9d8SAlberto Garcia             continue;
1881ee22a9d8SAlberto Garcia         }
1882ee22a9d8SAlberto Garcia 
1883ee22a9d8SAlberto Garcia         /* Make sure that adding both COW regions to the QEMUIOVector
1884ee22a9d8SAlberto Garcia          * does not exceed IOV_MAX */
1885ee22a9d8SAlberto Garcia         if (hd_qiov->niov > IOV_MAX - 2) {
1886ee22a9d8SAlberto Garcia             continue;
1887ee22a9d8SAlberto Garcia         }
1888ee22a9d8SAlberto Garcia 
1889ee22a9d8SAlberto Garcia         m->data_qiov = hd_qiov;
1890ee22a9d8SAlberto Garcia         return true;
1891ee22a9d8SAlberto Garcia     }
1892ee22a9d8SAlberto Garcia 
1893ee22a9d8SAlberto Garcia     return false;
1894ee22a9d8SAlberto Garcia }
1895ee22a9d8SAlberto Garcia 
1896d46a0bb2SKevin Wolf static coroutine_fn int qcow2_co_pwritev(BlockDriverState *bs, uint64_t offset,
1897d46a0bb2SKevin Wolf                                          uint64_t bytes, QEMUIOVector *qiov,
1898d46a0bb2SKevin Wolf                                          int flags)
1899585f8587Sbellard {
1900ff99129aSKevin Wolf     BDRVQcow2State *s = bs->opaque;
1901d46a0bb2SKevin Wolf     int offset_in_cluster;
190268d100e9SKevin Wolf     int ret;
1903d46a0bb2SKevin Wolf     unsigned int cur_bytes; /* number of sectors in current iteration */
1904c2bdd990SFrediano Ziglio     uint64_t cluster_offset;
19053fc48d09SFrediano Ziglio     QEMUIOVector hd_qiov;
19063fc48d09SFrediano Ziglio     uint64_t bytes_done = 0;
19073fc48d09SFrediano Ziglio     uint8_t *cluster_data = NULL;
19088d2497c3SKevin Wolf     QCowL2Meta *l2meta = NULL;
1909c2271403SFrediano Ziglio 
1910d46a0bb2SKevin Wolf     trace_qcow2_writev_start_req(qemu_coroutine_self(), offset, bytes);
19113cce16f4SKevin Wolf 
19123fc48d09SFrediano Ziglio     qemu_iovec_init(&hd_qiov, qiov->niov);
1913585f8587Sbellard 
19143fc48d09SFrediano Ziglio     s->cluster_cache_offset = -1; /* disable compressed cache */
19153fc48d09SFrediano Ziglio 
19163fc48d09SFrediano Ziglio     qemu_co_mutex_lock(&s->lock);
19173fc48d09SFrediano Ziglio 
1918d46a0bb2SKevin Wolf     while (bytes != 0) {
19193fc48d09SFrediano Ziglio 
1920f50f88b9SKevin Wolf         l2meta = NULL;
1921cf5c1a23SKevin Wolf 
19223cce16f4SKevin Wolf         trace_qcow2_writev_start_part(qemu_coroutine_self());
1923d46a0bb2SKevin Wolf         offset_in_cluster = offset_into_cluster(s, offset);
1924d46a0bb2SKevin Wolf         cur_bytes = MIN(bytes, INT_MAX);
1925d46a0bb2SKevin Wolf         if (bs->encrypted) {
1926d46a0bb2SKevin Wolf             cur_bytes = MIN(cur_bytes,
1927d46a0bb2SKevin Wolf                             QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size
1928d46a0bb2SKevin Wolf                             - offset_in_cluster);
19295ebaa27eSFrediano Ziglio         }
1930095a9c58Saliguori 
1931d46a0bb2SKevin Wolf         ret = qcow2_alloc_cluster_offset(bs, offset, &cur_bytes,
1932d46a0bb2SKevin Wolf                                          &cluster_offset, &l2meta);
1933148da7eaSKevin Wolf         if (ret < 0) {
19343fc48d09SFrediano Ziglio             goto fail;
1935148da7eaSKevin Wolf         }
1936148da7eaSKevin Wolf 
1937c2bdd990SFrediano Ziglio         assert((cluster_offset & 511) == 0);
1938148da7eaSKevin Wolf 
19393fc48d09SFrediano Ziglio         qemu_iovec_reset(&hd_qiov);
1940d46a0bb2SKevin Wolf         qemu_iovec_concat(&hd_qiov, qiov, bytes_done, cur_bytes);
19416f5f060bSKevin Wolf 
19428336aafaSDaniel P. Berrange         if (bs->encrypted) {
1943b25b387fSDaniel P. Berrange             assert(s->crypto);
19443fc48d09SFrediano Ziglio             if (!cluster_data) {
19459a4f4c31SKevin Wolf                 cluster_data = qemu_try_blockalign(bs->file->bs,
1946de82815dSKevin Wolf                                                    QCOW_MAX_CRYPT_CLUSTERS
1947de82815dSKevin Wolf                                                    * s->cluster_size);
1948de82815dSKevin Wolf                 if (cluster_data == NULL) {
1949de82815dSKevin Wolf                     ret = -ENOMEM;
1950de82815dSKevin Wolf                     goto fail;
1951de82815dSKevin Wolf                 }
1952585f8587Sbellard             }
19536f5f060bSKevin Wolf 
19543fc48d09SFrediano Ziglio             assert(hd_qiov.size <=
19555ebaa27eSFrediano Ziglio                    QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size);
1956d5e6b161SMichael Tokarev             qemu_iovec_to_buf(&hd_qiov, 0, cluster_data, hd_qiov.size);
19576f5f060bSKevin Wolf 
19584652b8f3SDaniel P. Berrange             if (qcrypto_block_encrypt(s->crypto,
19594652b8f3SDaniel P. Berrange                                       (s->crypt_physical_offset ?
19604652b8f3SDaniel P. Berrange                                        cluster_offset + offset_in_cluster :
19614652b8f3SDaniel P. Berrange                                        offset) >> BDRV_SECTOR_BITS,
1962446d306dSDaniel P. Berrange                                       cluster_data,
1963*c3a8fe33SAlberto Garcia                                       cur_bytes, NULL) < 0) {
1964f6fa64f6SDaniel P. Berrange                 ret = -EIO;
1965f6fa64f6SDaniel P. Berrange                 goto fail;
1966f6fa64f6SDaniel P. Berrange             }
19676f5f060bSKevin Wolf 
19683fc48d09SFrediano Ziglio             qemu_iovec_reset(&hd_qiov);
1969d46a0bb2SKevin Wolf             qemu_iovec_add(&hd_qiov, cluster_data, cur_bytes);
1970585f8587Sbellard         }
19716f5f060bSKevin Wolf 
1972231bb267SMax Reitz         ret = qcow2_pre_write_overlap_check(bs, 0,
1973d46a0bb2SKevin Wolf                 cluster_offset + offset_in_cluster, cur_bytes);
1974cf93980eSMax Reitz         if (ret < 0) {
1975cf93980eSMax Reitz             goto fail;
1976cf93980eSMax Reitz         }
1977cf93980eSMax Reitz 
1978ee22a9d8SAlberto Garcia         /* If we need to do COW, check if it's possible to merge the
1979ee22a9d8SAlberto Garcia          * writing of the guest data together with that of the COW regions.
1980ee22a9d8SAlberto Garcia          * If it's not possible (or not necessary) then write the
1981ee22a9d8SAlberto Garcia          * guest data now. */
1982ee22a9d8SAlberto Garcia         if (!merge_cow(offset, cur_bytes, &hd_qiov, l2meta)) {
198368d100e9SKevin Wolf             qemu_co_mutex_unlock(&s->lock);
198467a7a0ebSKevin Wolf             BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);
19853cce16f4SKevin Wolf             trace_qcow2_writev_data(qemu_coroutine_self(),
1986d46a0bb2SKevin Wolf                                     cluster_offset + offset_in_cluster);
1987a03ef88fSKevin Wolf             ret = bdrv_co_pwritev(bs->file,
1988d46a0bb2SKevin Wolf                                   cluster_offset + offset_in_cluster,
1989d46a0bb2SKevin Wolf                                   cur_bytes, &hd_qiov, 0);
199068d100e9SKevin Wolf             qemu_co_mutex_lock(&s->lock);
199168d100e9SKevin Wolf             if (ret < 0) {
19923fc48d09SFrediano Ziglio                 goto fail;
1993171e3d6bSKevin Wolf             }
1994ee22a9d8SAlberto Garcia         }
1995f141eafeSaliguori 
199688c6588cSKevin Wolf         while (l2meta != NULL) {
199788c6588cSKevin Wolf             QCowL2Meta *next;
199888c6588cSKevin Wolf 
1999cf5c1a23SKevin Wolf             ret = qcow2_alloc_cluster_link_l2(bs, l2meta);
2000faf575c1SFrediano Ziglio             if (ret < 0) {
20013fc48d09SFrediano Ziglio                 goto fail;
2002faf575c1SFrediano Ziglio             }
2003faf575c1SFrediano Ziglio 
20044e95314eSKevin Wolf             /* Take the request off the list of running requests */
20054e95314eSKevin Wolf             if (l2meta->nb_clusters != 0) {
20064e95314eSKevin Wolf                 QLIST_REMOVE(l2meta, next_in_flight);
20074e95314eSKevin Wolf             }
20084e95314eSKevin Wolf 
20094e95314eSKevin Wolf             qemu_co_queue_restart_all(&l2meta->dependent_requests);
20104e95314eSKevin Wolf 
201188c6588cSKevin Wolf             next = l2meta->next;
2012cf5c1a23SKevin Wolf             g_free(l2meta);
201388c6588cSKevin Wolf             l2meta = next;
2014f50f88b9SKevin Wolf         }
20150fa9131aSKevin Wolf 
2016d46a0bb2SKevin Wolf         bytes -= cur_bytes;
2017d46a0bb2SKevin Wolf         offset += cur_bytes;
2018d46a0bb2SKevin Wolf         bytes_done += cur_bytes;
2019d46a0bb2SKevin Wolf         trace_qcow2_writev_done_part(qemu_coroutine_self(), cur_bytes);
20205ebaa27eSFrediano Ziglio     }
20213fc48d09SFrediano Ziglio     ret = 0;
2022faf575c1SFrediano Ziglio 
20233fc48d09SFrediano Ziglio fail:
202488c6588cSKevin Wolf     while (l2meta != NULL) {
202588c6588cSKevin Wolf         QCowL2Meta *next;
202688c6588cSKevin Wolf 
20274e95314eSKevin Wolf         if (l2meta->nb_clusters != 0) {
20284e95314eSKevin Wolf             QLIST_REMOVE(l2meta, next_in_flight);
20294e95314eSKevin Wolf         }
20304e95314eSKevin Wolf         qemu_co_queue_restart_all(&l2meta->dependent_requests);
203188c6588cSKevin Wolf 
203288c6588cSKevin Wolf         next = l2meta->next;
2033cf5c1a23SKevin Wolf         g_free(l2meta);
203488c6588cSKevin Wolf         l2meta = next;
2035cf5c1a23SKevin Wolf     }
20360fa9131aSKevin Wolf 
2037a8c57408SPaolo Bonzini     qemu_co_mutex_unlock(&s->lock);
2038a8c57408SPaolo Bonzini 
20393fc48d09SFrediano Ziglio     qemu_iovec_destroy(&hd_qiov);
2040dea43a65SFrediano Ziglio     qemu_vfree(cluster_data);
20413cce16f4SKevin Wolf     trace_qcow2_writev_done_req(qemu_coroutine_self(), ret);
204242496d62SKevin Wolf 
204368d100e9SKevin Wolf     return ret;
2044585f8587Sbellard }
2045585f8587Sbellard 
2046ec6d8912SKevin Wolf static int qcow2_inactivate(BlockDriverState *bs)
2047ec6d8912SKevin Wolf {
2048ec6d8912SKevin Wolf     BDRVQcow2State *s = bs->opaque;
2049ec6d8912SKevin Wolf     int ret, result = 0;
20505f72826eSVladimir Sementsov-Ogievskiy     Error *local_err = NULL;
2051ec6d8912SKevin Wolf 
2052ec6d8912SKevin Wolf     ret = qcow2_cache_flush(bs, s->l2_table_cache);
2053ec6d8912SKevin Wolf     if (ret) {
2054ec6d8912SKevin Wolf         result = ret;
2055ec6d8912SKevin Wolf         error_report("Failed to flush the L2 table cache: %s",
2056ec6d8912SKevin Wolf                      strerror(-ret));
2057ec6d8912SKevin Wolf     }
2058ec6d8912SKevin Wolf 
2059ec6d8912SKevin Wolf     ret = qcow2_cache_flush(bs, s->refcount_block_cache);
2060ec6d8912SKevin Wolf     if (ret) {
2061ec6d8912SKevin Wolf         result = ret;
2062ec6d8912SKevin Wolf         error_report("Failed to flush the refcount block cache: %s",
2063ec6d8912SKevin Wolf                      strerror(-ret));
2064ec6d8912SKevin Wolf     }
2065ec6d8912SKevin Wolf 
20665f72826eSVladimir Sementsov-Ogievskiy     qcow2_store_persistent_dirty_bitmaps(bs, &local_err);
20675f72826eSVladimir Sementsov-Ogievskiy     if (local_err != NULL) {
20685f72826eSVladimir Sementsov-Ogievskiy         result = -EINVAL;
20695f72826eSVladimir Sementsov-Ogievskiy         error_report_err(local_err);
20705f72826eSVladimir Sementsov-Ogievskiy         error_report("Persistent bitmaps are lost for node '%s'",
20715f72826eSVladimir Sementsov-Ogievskiy                      bdrv_get_device_or_node_name(bs));
20725f72826eSVladimir Sementsov-Ogievskiy     }
20735f72826eSVladimir Sementsov-Ogievskiy 
2074ec6d8912SKevin Wolf     if (result == 0) {
2075ec6d8912SKevin Wolf         qcow2_mark_clean(bs);
2076ec6d8912SKevin Wolf     }
2077ec6d8912SKevin Wolf 
2078ec6d8912SKevin Wolf     return result;
2079ec6d8912SKevin Wolf }
2080ec6d8912SKevin Wolf 
20817c80ab3fSJes Sorensen static void qcow2_close(BlockDriverState *bs)
2082585f8587Sbellard {
2083ff99129aSKevin Wolf     BDRVQcow2State *s = bs->opaque;
2084de82815dSKevin Wolf     qemu_vfree(s->l1_table);
2085cf93980eSMax Reitz     /* else pre-write overlap checks in cache_destroy may crash */
2086cf93980eSMax Reitz     s->l1_table = NULL;
208729c1a730SKevin Wolf 
2088140fd5a6SKevin Wolf     if (!(s->flags & BDRV_O_INACTIVE)) {
2089ec6d8912SKevin Wolf         qcow2_inactivate(bs);
20903b5e14c7SMax Reitz     }
2091c61d0004SStefan Hajnoczi 
2092279621c0SAlberto Garcia     cache_clean_timer_del(bs);
209329c1a730SKevin Wolf     qcow2_cache_destroy(bs, s->l2_table_cache);
209429c1a730SKevin Wolf     qcow2_cache_destroy(bs, s->refcount_block_cache);
209529c1a730SKevin Wolf 
2096b25b387fSDaniel P. Berrange     qcrypto_block_free(s->crypto);
2097b25b387fSDaniel P. Berrange     s->crypto = NULL;
2098f6fa64f6SDaniel P. Berrange 
20996744cbabSKevin Wolf     g_free(s->unknown_header_fields);
210075bab85cSKevin Wolf     cleanup_unknown_header_ext(bs);
21016744cbabSKevin Wolf 
2102e4603fe1SKevin Wolf     g_free(s->image_backing_file);
2103e4603fe1SKevin Wolf     g_free(s->image_backing_format);
2104e4603fe1SKevin Wolf 
21057267c094SAnthony Liguori     g_free(s->cluster_cache);
2106dea43a65SFrediano Ziglio     qemu_vfree(s->cluster_data);
2107ed6ccf0fSKevin Wolf     qcow2_refcount_close(bs);
210828c1202bSLi Zhi Hui     qcow2_free_snapshots(bs);
2109585f8587Sbellard }
2110585f8587Sbellard 
21115a8a30dbSKevin Wolf static void qcow2_invalidate_cache(BlockDriverState *bs, Error **errp)
211206d9260fSAnthony Liguori {
2113ff99129aSKevin Wolf     BDRVQcow2State *s = bs->opaque;
211406d9260fSAnthony Liguori     int flags = s->flags;
2115b25b387fSDaniel P. Berrange     QCryptoBlock *crypto = NULL;
2116acdfb480SKevin Wolf     QDict *options;
21175a8a30dbSKevin Wolf     Error *local_err = NULL;
21185a8a30dbSKevin Wolf     int ret;
211906d9260fSAnthony Liguori 
212006d9260fSAnthony Liguori     /*
212106d9260fSAnthony Liguori      * Backing files are read-only which makes all of their metadata immutable,
212206d9260fSAnthony Liguori      * that means we don't have to worry about reopening them here.
212306d9260fSAnthony Liguori      */
212406d9260fSAnthony Liguori 
2125b25b387fSDaniel P. Berrange     crypto = s->crypto;
2126b25b387fSDaniel P. Berrange     s->crypto = NULL;
212706d9260fSAnthony Liguori 
212806d9260fSAnthony Liguori     qcow2_close(bs);
212906d9260fSAnthony Liguori 
2130ff99129aSKevin Wolf     memset(s, 0, sizeof(BDRVQcow2State));
2131d475e5acSKevin Wolf     options = qdict_clone_shallow(bs->options);
21325a8a30dbSKevin Wolf 
2133140fd5a6SKevin Wolf     flags &= ~BDRV_O_INACTIVE;
21344e4bf5c4SKevin Wolf     ret = qcow2_do_open(bs, options, flags, &local_err);
2135a1904e48SMarkus Armbruster     QDECREF(options);
21365a8a30dbSKevin Wolf     if (local_err) {
2137e43bfd9cSMarkus Armbruster         error_propagate(errp, local_err);
2138e43bfd9cSMarkus Armbruster         error_prepend(errp, "Could not reopen qcow2 layer: ");
2139191fb11bSKevin Wolf         bs->drv = NULL;
21405a8a30dbSKevin Wolf         return;
21415a8a30dbSKevin Wolf     } else if (ret < 0) {
21425a8a30dbSKevin Wolf         error_setg_errno(errp, -ret, "Could not reopen qcow2 layer");
2143191fb11bSKevin Wolf         bs->drv = NULL;
21445a8a30dbSKevin Wolf         return;
21455a8a30dbSKevin Wolf     }
2146acdfb480SKevin Wolf 
2147b25b387fSDaniel P. Berrange     s->crypto = crypto;
214806d9260fSAnthony Liguori }
214906d9260fSAnthony Liguori 
2150e24e49e6SKevin Wolf static size_t header_ext_add(char *buf, uint32_t magic, const void *s,
2151e24e49e6SKevin Wolf     size_t len, size_t buflen)
2152756e6736SKevin Wolf {
2153e24e49e6SKevin Wolf     QCowExtension *ext_backing_fmt = (QCowExtension*) buf;
2154e24e49e6SKevin Wolf     size_t ext_len = sizeof(QCowExtension) + ((len + 7) & ~7);
2155756e6736SKevin Wolf 
2156e24e49e6SKevin Wolf     if (buflen < ext_len) {
2157756e6736SKevin Wolf         return -ENOSPC;
2158756e6736SKevin Wolf     }
2159756e6736SKevin Wolf 
2160e24e49e6SKevin Wolf     *ext_backing_fmt = (QCowExtension) {
2161e24e49e6SKevin Wolf         .magic  = cpu_to_be32(magic),
2162e24e49e6SKevin Wolf         .len    = cpu_to_be32(len),
2163e24e49e6SKevin Wolf     };
21640647d47cSStefan Hajnoczi 
21650647d47cSStefan Hajnoczi     if (len) {
2166e24e49e6SKevin Wolf         memcpy(buf + sizeof(QCowExtension), s, len);
21670647d47cSStefan Hajnoczi     }
2168756e6736SKevin Wolf 
2169e24e49e6SKevin Wolf     return ext_len;
2170756e6736SKevin Wolf }
2171756e6736SKevin Wolf 
2172e24e49e6SKevin Wolf /*
2173e24e49e6SKevin Wolf  * Updates the qcow2 header, including the variable length parts of it, i.e.
2174e24e49e6SKevin Wolf  * the backing file name and all extensions. qcow2 was not designed to allow
2175e24e49e6SKevin Wolf  * such changes, so if we run out of space (we can only use the first cluster)
2176e24e49e6SKevin Wolf  * this function may fail.
2177e24e49e6SKevin Wolf  *
2178e24e49e6SKevin Wolf  * Returns 0 on success, -errno in error cases.
2179e24e49e6SKevin Wolf  */
2180e24e49e6SKevin Wolf int qcow2_update_header(BlockDriverState *bs)
2181e24e49e6SKevin Wolf {
2182ff99129aSKevin Wolf     BDRVQcow2State *s = bs->opaque;
2183e24e49e6SKevin Wolf     QCowHeader *header;
2184e24e49e6SKevin Wolf     char *buf;
2185e24e49e6SKevin Wolf     size_t buflen = s->cluster_size;
2186e24e49e6SKevin Wolf     int ret;
2187e24e49e6SKevin Wolf     uint64_t total_size;
2188e24e49e6SKevin Wolf     uint32_t refcount_table_clusters;
21896744cbabSKevin Wolf     size_t header_length;
219075bab85cSKevin Wolf     Qcow2UnknownHeaderExtension *uext;
2191e24e49e6SKevin Wolf 
2192e24e49e6SKevin Wolf     buf = qemu_blockalign(bs, buflen);
2193e24e49e6SKevin Wolf 
2194e24e49e6SKevin Wolf     /* Header structure */
2195e24e49e6SKevin Wolf     header = (QCowHeader*) buf;
2196e24e49e6SKevin Wolf 
2197e24e49e6SKevin Wolf     if (buflen < sizeof(*header)) {
2198e24e49e6SKevin Wolf         ret = -ENOSPC;
2199e24e49e6SKevin Wolf         goto fail;
2200756e6736SKevin Wolf     }
2201756e6736SKevin Wolf 
22026744cbabSKevin Wolf     header_length = sizeof(*header) + s->unknown_header_fields_size;
2203e24e49e6SKevin Wolf     total_size = bs->total_sectors * BDRV_SECTOR_SIZE;
2204e24e49e6SKevin Wolf     refcount_table_clusters = s->refcount_table_size >> (s->cluster_bits - 3);
2205e24e49e6SKevin Wolf 
2206e24e49e6SKevin Wolf     *header = (QCowHeader) {
22076744cbabSKevin Wolf         /* Version 2 fields */
2208e24e49e6SKevin Wolf         .magic                  = cpu_to_be32(QCOW_MAGIC),
22096744cbabSKevin Wolf         .version                = cpu_to_be32(s->qcow_version),
2210e24e49e6SKevin Wolf         .backing_file_offset    = 0,
2211e24e49e6SKevin Wolf         .backing_file_size      = 0,
2212e24e49e6SKevin Wolf         .cluster_bits           = cpu_to_be32(s->cluster_bits),
2213e24e49e6SKevin Wolf         .size                   = cpu_to_be64(total_size),
2214e24e49e6SKevin Wolf         .crypt_method           = cpu_to_be32(s->crypt_method_header),
2215e24e49e6SKevin Wolf         .l1_size                = cpu_to_be32(s->l1_size),
2216e24e49e6SKevin Wolf         .l1_table_offset        = cpu_to_be64(s->l1_table_offset),
2217e24e49e6SKevin Wolf         .refcount_table_offset  = cpu_to_be64(s->refcount_table_offset),
2218e24e49e6SKevin Wolf         .refcount_table_clusters = cpu_to_be32(refcount_table_clusters),
2219e24e49e6SKevin Wolf         .nb_snapshots           = cpu_to_be32(s->nb_snapshots),
2220e24e49e6SKevin Wolf         .snapshots_offset       = cpu_to_be64(s->snapshots_offset),
22216744cbabSKevin Wolf 
22226744cbabSKevin Wolf         /* Version 3 fields */
22236744cbabSKevin Wolf         .incompatible_features  = cpu_to_be64(s->incompatible_features),
22246744cbabSKevin Wolf         .compatible_features    = cpu_to_be64(s->compatible_features),
22256744cbabSKevin Wolf         .autoclear_features     = cpu_to_be64(s->autoclear_features),
2226b6481f37SMax Reitz         .refcount_order         = cpu_to_be32(s->refcount_order),
22276744cbabSKevin Wolf         .header_length          = cpu_to_be32(header_length),
2228e24e49e6SKevin Wolf     };
2229e24e49e6SKevin Wolf 
22306744cbabSKevin Wolf     /* For older versions, write a shorter header */
22316744cbabSKevin Wolf     switch (s->qcow_version) {
22326744cbabSKevin Wolf     case 2:
22336744cbabSKevin Wolf         ret = offsetof(QCowHeader, incompatible_features);
22346744cbabSKevin Wolf         break;
22356744cbabSKevin Wolf     case 3:
22366744cbabSKevin Wolf         ret = sizeof(*header);
22376744cbabSKevin Wolf         break;
22386744cbabSKevin Wolf     default:
2239b6c14762SJim Meyering         ret = -EINVAL;
2240b6c14762SJim Meyering         goto fail;
22416744cbabSKevin Wolf     }
22426744cbabSKevin Wolf 
22436744cbabSKevin Wolf     buf += ret;
22446744cbabSKevin Wolf     buflen -= ret;
22456744cbabSKevin Wolf     memset(buf, 0, buflen);
22466744cbabSKevin Wolf 
22476744cbabSKevin Wolf     /* Preserve any unknown field in the header */
22486744cbabSKevin Wolf     if (s->unknown_header_fields_size) {
22496744cbabSKevin Wolf         if (buflen < s->unknown_header_fields_size) {
22506744cbabSKevin Wolf             ret = -ENOSPC;
22516744cbabSKevin Wolf             goto fail;
22526744cbabSKevin Wolf         }
22536744cbabSKevin Wolf 
22546744cbabSKevin Wolf         memcpy(buf, s->unknown_header_fields, s->unknown_header_fields_size);
22556744cbabSKevin Wolf         buf += s->unknown_header_fields_size;
22566744cbabSKevin Wolf         buflen -= s->unknown_header_fields_size;
22576744cbabSKevin Wolf     }
2258e24e49e6SKevin Wolf 
2259e24e49e6SKevin Wolf     /* Backing file format header extension */
2260e4603fe1SKevin Wolf     if (s->image_backing_format) {
2261e24e49e6SKevin Wolf         ret = header_ext_add(buf, QCOW2_EXT_MAGIC_BACKING_FORMAT,
2262e4603fe1SKevin Wolf                              s->image_backing_format,
2263e4603fe1SKevin Wolf                              strlen(s->image_backing_format),
2264e24e49e6SKevin Wolf                              buflen);
2265756e6736SKevin Wolf         if (ret < 0) {
2266756e6736SKevin Wolf             goto fail;
2267756e6736SKevin Wolf         }
2268756e6736SKevin Wolf 
2269e24e49e6SKevin Wolf         buf += ret;
2270e24e49e6SKevin Wolf         buflen -= ret;
2271e24e49e6SKevin Wolf     }
2272756e6736SKevin Wolf 
22734652b8f3SDaniel P. Berrange     /* Full disk encryption header pointer extension */
22744652b8f3SDaniel P. Berrange     if (s->crypto_header.offset != 0) {
22754652b8f3SDaniel P. Berrange         cpu_to_be64s(&s->crypto_header.offset);
22764652b8f3SDaniel P. Berrange         cpu_to_be64s(&s->crypto_header.length);
22774652b8f3SDaniel P. Berrange         ret = header_ext_add(buf, QCOW2_EXT_MAGIC_CRYPTO_HEADER,
22784652b8f3SDaniel P. Berrange                              &s->crypto_header, sizeof(s->crypto_header),
22794652b8f3SDaniel P. Berrange                              buflen);
22804652b8f3SDaniel P. Berrange         be64_to_cpus(&s->crypto_header.offset);
22814652b8f3SDaniel P. Berrange         be64_to_cpus(&s->crypto_header.length);
22824652b8f3SDaniel P. Berrange         if (ret < 0) {
22834652b8f3SDaniel P. Berrange             goto fail;
22844652b8f3SDaniel P. Berrange         }
22854652b8f3SDaniel P. Berrange         buf += ret;
22864652b8f3SDaniel P. Berrange         buflen -= ret;
22874652b8f3SDaniel P. Berrange     }
22884652b8f3SDaniel P. Berrange 
2289cfcc4c62SKevin Wolf     /* Feature table */
22901a4828c7SKevin Wolf     if (s->qcow_version >= 3) {
2291cfcc4c62SKevin Wolf         Qcow2Feature features[] = {
2292c61d0004SStefan Hajnoczi             {
2293c61d0004SStefan Hajnoczi                 .type = QCOW2_FEAT_TYPE_INCOMPATIBLE,
2294c61d0004SStefan Hajnoczi                 .bit  = QCOW2_INCOMPAT_DIRTY_BITNR,
2295c61d0004SStefan Hajnoczi                 .name = "dirty bit",
2296c61d0004SStefan Hajnoczi             },
2297bfe8043eSStefan Hajnoczi             {
229869c98726SMax Reitz                 .type = QCOW2_FEAT_TYPE_INCOMPATIBLE,
229969c98726SMax Reitz                 .bit  = QCOW2_INCOMPAT_CORRUPT_BITNR,
230069c98726SMax Reitz                 .name = "corrupt bit",
230169c98726SMax Reitz             },
230269c98726SMax Reitz             {
2303bfe8043eSStefan Hajnoczi                 .type = QCOW2_FEAT_TYPE_COMPATIBLE,
2304bfe8043eSStefan Hajnoczi                 .bit  = QCOW2_COMPAT_LAZY_REFCOUNTS_BITNR,
2305bfe8043eSStefan Hajnoczi                 .name = "lazy refcounts",
2306bfe8043eSStefan Hajnoczi             },
2307cfcc4c62SKevin Wolf         };
2308cfcc4c62SKevin Wolf 
2309cfcc4c62SKevin Wolf         ret = header_ext_add(buf, QCOW2_EXT_MAGIC_FEATURE_TABLE,
2310cfcc4c62SKevin Wolf                              features, sizeof(features), buflen);
2311cfcc4c62SKevin Wolf         if (ret < 0) {
2312cfcc4c62SKevin Wolf             goto fail;
2313cfcc4c62SKevin Wolf         }
2314cfcc4c62SKevin Wolf         buf += ret;
2315cfcc4c62SKevin Wolf         buflen -= ret;
23161a4828c7SKevin Wolf     }
2317cfcc4c62SKevin Wolf 
231888ddffaeSVladimir Sementsov-Ogievskiy     /* Bitmap extension */
231988ddffaeSVladimir Sementsov-Ogievskiy     if (s->nb_bitmaps > 0) {
232088ddffaeSVladimir Sementsov-Ogievskiy         Qcow2BitmapHeaderExt bitmaps_header = {
232188ddffaeSVladimir Sementsov-Ogievskiy             .nb_bitmaps = cpu_to_be32(s->nb_bitmaps),
232288ddffaeSVladimir Sementsov-Ogievskiy             .bitmap_directory_size =
232388ddffaeSVladimir Sementsov-Ogievskiy                     cpu_to_be64(s->bitmap_directory_size),
232488ddffaeSVladimir Sementsov-Ogievskiy             .bitmap_directory_offset =
232588ddffaeSVladimir Sementsov-Ogievskiy                     cpu_to_be64(s->bitmap_directory_offset)
232688ddffaeSVladimir Sementsov-Ogievskiy         };
232788ddffaeSVladimir Sementsov-Ogievskiy         ret = header_ext_add(buf, QCOW2_EXT_MAGIC_BITMAPS,
232888ddffaeSVladimir Sementsov-Ogievskiy                              &bitmaps_header, sizeof(bitmaps_header),
232988ddffaeSVladimir Sementsov-Ogievskiy                              buflen);
233088ddffaeSVladimir Sementsov-Ogievskiy         if (ret < 0) {
233188ddffaeSVladimir Sementsov-Ogievskiy             goto fail;
233288ddffaeSVladimir Sementsov-Ogievskiy         }
233388ddffaeSVladimir Sementsov-Ogievskiy         buf += ret;
233488ddffaeSVladimir Sementsov-Ogievskiy         buflen -= ret;
233588ddffaeSVladimir Sementsov-Ogievskiy     }
233688ddffaeSVladimir Sementsov-Ogievskiy 
233775bab85cSKevin Wolf     /* Keep unknown header extensions */
233875bab85cSKevin Wolf     QLIST_FOREACH(uext, &s->unknown_header_ext, next) {
233975bab85cSKevin Wolf         ret = header_ext_add(buf, uext->magic, uext->data, uext->len, buflen);
234075bab85cSKevin Wolf         if (ret < 0) {
234175bab85cSKevin Wolf             goto fail;
234275bab85cSKevin Wolf         }
234375bab85cSKevin Wolf 
234475bab85cSKevin Wolf         buf += ret;
234575bab85cSKevin Wolf         buflen -= ret;
234675bab85cSKevin Wolf     }
234775bab85cSKevin Wolf 
2348e24e49e6SKevin Wolf     /* End of header extensions */
2349e24e49e6SKevin Wolf     ret = header_ext_add(buf, QCOW2_EXT_MAGIC_END, NULL, 0, buflen);
2350756e6736SKevin Wolf     if (ret < 0) {
2351756e6736SKevin Wolf         goto fail;
2352756e6736SKevin Wolf     }
2353756e6736SKevin Wolf 
2354e24e49e6SKevin Wolf     buf += ret;
2355e24e49e6SKevin Wolf     buflen -= ret;
2356e24e49e6SKevin Wolf 
2357e24e49e6SKevin Wolf     /* Backing file name */
2358e4603fe1SKevin Wolf     if (s->image_backing_file) {
2359e4603fe1SKevin Wolf         size_t backing_file_len = strlen(s->image_backing_file);
2360e24e49e6SKevin Wolf 
2361e24e49e6SKevin Wolf         if (buflen < backing_file_len) {
2362e24e49e6SKevin Wolf             ret = -ENOSPC;
2363e24e49e6SKevin Wolf             goto fail;
2364e24e49e6SKevin Wolf         }
2365e24e49e6SKevin Wolf 
236600ea1881SJim Meyering         /* Using strncpy is ok here, since buf is not NUL-terminated. */
2367e4603fe1SKevin Wolf         strncpy(buf, s->image_backing_file, buflen);
2368e24e49e6SKevin Wolf 
2369e24e49e6SKevin Wolf         header->backing_file_offset = cpu_to_be64(buf - ((char*) header));
2370e24e49e6SKevin Wolf         header->backing_file_size   = cpu_to_be32(backing_file_len);
2371e24e49e6SKevin Wolf     }
2372e24e49e6SKevin Wolf 
2373e24e49e6SKevin Wolf     /* Write the new header */
2374d9ca2ea2SKevin Wolf     ret = bdrv_pwrite(bs->file, 0, header, s->cluster_size);
2375756e6736SKevin Wolf     if (ret < 0) {
2376756e6736SKevin Wolf         goto fail;
2377756e6736SKevin Wolf     }
2378756e6736SKevin Wolf 
2379756e6736SKevin Wolf     ret = 0;
2380756e6736SKevin Wolf fail:
2381e24e49e6SKevin Wolf     qemu_vfree(header);
2382756e6736SKevin Wolf     return ret;
2383756e6736SKevin Wolf }
2384756e6736SKevin Wolf 
2385756e6736SKevin Wolf static int qcow2_change_backing_file(BlockDriverState *bs,
2386756e6736SKevin Wolf     const char *backing_file, const char *backing_fmt)
2387756e6736SKevin Wolf {
2388ff99129aSKevin Wolf     BDRVQcow2State *s = bs->opaque;
2389e4603fe1SKevin Wolf 
23904e876bcfSMax Reitz     if (backing_file && strlen(backing_file) > 1023) {
23914e876bcfSMax Reitz         return -EINVAL;
23924e876bcfSMax Reitz     }
23934e876bcfSMax Reitz 
2394e24e49e6SKevin Wolf     pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: "");
2395e24e49e6SKevin Wolf     pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: "");
2396e24e49e6SKevin Wolf 
2397e4603fe1SKevin Wolf     g_free(s->image_backing_file);
2398e4603fe1SKevin Wolf     g_free(s->image_backing_format);
2399e4603fe1SKevin Wolf 
2400e4603fe1SKevin Wolf     s->image_backing_file = backing_file ? g_strdup(bs->backing_file) : NULL;
2401e4603fe1SKevin Wolf     s->image_backing_format = backing_fmt ? g_strdup(bs->backing_format) : NULL;
2402e4603fe1SKevin Wolf 
2403e24e49e6SKevin Wolf     return qcow2_update_header(bs);
2404756e6736SKevin Wolf }
2405756e6736SKevin Wolf 
24064652b8f3SDaniel P. Berrange static int qcow2_crypt_method_from_format(const char *encryptfmt)
24074652b8f3SDaniel P. Berrange {
24084652b8f3SDaniel P. Berrange     if (g_str_equal(encryptfmt, "luks")) {
24094652b8f3SDaniel P. Berrange         return QCOW_CRYPT_LUKS;
24104652b8f3SDaniel P. Berrange     } else if (g_str_equal(encryptfmt, "aes")) {
24114652b8f3SDaniel P. Berrange         return QCOW_CRYPT_AES;
24124652b8f3SDaniel P. Berrange     } else {
24134652b8f3SDaniel P. Berrange         return -EINVAL;
24144652b8f3SDaniel P. Berrange     }
24154652b8f3SDaniel P. Berrange }
2416b25b387fSDaniel P. Berrange 
2417b25b387fSDaniel P. Berrange static int qcow2_set_up_encryption(BlockDriverState *bs, const char *encryptfmt,
2418b25b387fSDaniel P. Berrange                                    QemuOpts *opts, Error **errp)
2419b25b387fSDaniel P. Berrange {
2420b25b387fSDaniel P. Berrange     BDRVQcow2State *s = bs->opaque;
2421b25b387fSDaniel P. Berrange     QCryptoBlockCreateOptions *cryptoopts = NULL;
2422b25b387fSDaniel P. Berrange     QCryptoBlock *crypto = NULL;
2423b25b387fSDaniel P. Berrange     int ret = -EINVAL;
2424b25b387fSDaniel P. Berrange     QDict *options, *encryptopts;
24254652b8f3SDaniel P. Berrange     int fmt;
2426b25b387fSDaniel P. Berrange 
2427b25b387fSDaniel P. Berrange     options = qemu_opts_to_qdict(opts, NULL);
2428b25b387fSDaniel P. Berrange     qdict_extract_subqdict(options, &encryptopts, "encrypt.");
2429b25b387fSDaniel P. Berrange     QDECREF(options);
2430b25b387fSDaniel P. Berrange 
24314652b8f3SDaniel P. Berrange     fmt = qcow2_crypt_method_from_format(encryptfmt);
24324652b8f3SDaniel P. Berrange 
24334652b8f3SDaniel P. Berrange     switch (fmt) {
24344652b8f3SDaniel P. Berrange     case QCOW_CRYPT_LUKS:
24354652b8f3SDaniel P. Berrange         cryptoopts = block_crypto_create_opts_init(
24364652b8f3SDaniel P. Berrange             Q_CRYPTO_BLOCK_FORMAT_LUKS, encryptopts, errp);
24374652b8f3SDaniel P. Berrange         break;
24384652b8f3SDaniel P. Berrange     case QCOW_CRYPT_AES:
2439b25b387fSDaniel P. Berrange         cryptoopts = block_crypto_create_opts_init(
2440b25b387fSDaniel P. Berrange             Q_CRYPTO_BLOCK_FORMAT_QCOW, encryptopts, errp);
24414652b8f3SDaniel P. Berrange         break;
24424652b8f3SDaniel P. Berrange     default:
24434652b8f3SDaniel P. Berrange         error_setg(errp, "Unknown encryption format '%s'", encryptfmt);
24444652b8f3SDaniel P. Berrange         break;
24454652b8f3SDaniel P. Berrange     }
2446b25b387fSDaniel P. Berrange     if (!cryptoopts) {
2447b25b387fSDaniel P. Berrange         ret = -EINVAL;
2448b25b387fSDaniel P. Berrange         goto out;
2449b25b387fSDaniel P. Berrange     }
24504652b8f3SDaniel P. Berrange     s->crypt_method_header = fmt;
2451b25b387fSDaniel P. Berrange 
24521cd9a787SDaniel P. Berrange     crypto = qcrypto_block_create(cryptoopts, "encrypt.",
24534652b8f3SDaniel P. Berrange                                   qcow2_crypto_hdr_init_func,
24544652b8f3SDaniel P. Berrange                                   qcow2_crypto_hdr_write_func,
2455b25b387fSDaniel P. Berrange                                   bs, errp);
2456b25b387fSDaniel P. Berrange     if (!crypto) {
2457b25b387fSDaniel P. Berrange         ret = -EINVAL;
2458b25b387fSDaniel P. Berrange         goto out;
2459b25b387fSDaniel P. Berrange     }
2460b25b387fSDaniel P. Berrange 
2461b25b387fSDaniel P. Berrange     ret = qcow2_update_header(bs);
2462b25b387fSDaniel P. Berrange     if (ret < 0) {
2463b25b387fSDaniel P. Berrange         error_setg_errno(errp, -ret, "Could not write encryption header");
2464b25b387fSDaniel P. Berrange         goto out;
2465b25b387fSDaniel P. Berrange     }
2466b25b387fSDaniel P. Berrange 
2467b25b387fSDaniel P. Berrange  out:
2468b25b387fSDaniel P. Berrange     QDECREF(encryptopts);
2469b25b387fSDaniel P. Berrange     qcrypto_block_free(crypto);
2470b25b387fSDaniel P. Berrange     qapi_free_QCryptoBlockCreateOptions(cryptoopts);
2471b25b387fSDaniel P. Berrange     return ret;
2472b25b387fSDaniel P. Berrange }
2473b25b387fSDaniel P. Berrange 
2474b25b387fSDaniel P. Berrange 
24757bc45dc1SMax Reitz /**
24767bc45dc1SMax Reitz  * Preallocates metadata structures for data clusters between @offset (in the
24777bc45dc1SMax Reitz  * guest disk) and @new_length (which is thus generally the new guest disk
24787bc45dc1SMax Reitz  * size).
24797bc45dc1SMax Reitz  *
24807bc45dc1SMax Reitz  * Returns: 0 on success, -errno on failure.
24817bc45dc1SMax Reitz  */
24827bc45dc1SMax Reitz static int preallocate(BlockDriverState *bs,
24837bc45dc1SMax Reitz                        uint64_t offset, uint64_t new_length)
2484a35e1c17SKevin Wolf {
2485652fecd0SMax Reitz     BDRVQcow2State *s = bs->opaque;
2486d46a0bb2SKevin Wolf     uint64_t bytes;
2487060bee89SKevin Wolf     uint64_t host_offset = 0;
2488d46a0bb2SKevin Wolf     unsigned int cur_bytes;
2489148da7eaSKevin Wolf     int ret;
2490f50f88b9SKevin Wolf     QCowL2Meta *meta;
2491a35e1c17SKevin Wolf 
2492652fecd0SMax Reitz     if (qemu_in_coroutine()) {
2493652fecd0SMax Reitz         qemu_co_mutex_lock(&s->lock);
2494652fecd0SMax Reitz     }
2495652fecd0SMax Reitz 
24967bc45dc1SMax Reitz     assert(offset <= new_length);
24977bc45dc1SMax Reitz     bytes = new_length - offset;
2498a35e1c17SKevin Wolf 
2499d46a0bb2SKevin Wolf     while (bytes) {
2500d46a0bb2SKevin Wolf         cur_bytes = MIN(bytes, INT_MAX);
2501d46a0bb2SKevin Wolf         ret = qcow2_alloc_cluster_offset(bs, offset, &cur_bytes,
2502060bee89SKevin Wolf                                          &host_offset, &meta);
2503148da7eaSKevin Wolf         if (ret < 0) {
2504652fecd0SMax Reitz             goto done;
2505a35e1c17SKevin Wolf         }
2506a35e1c17SKevin Wolf 
2507c792707fSStefan Hajnoczi         while (meta) {
2508c792707fSStefan Hajnoczi             QCowL2Meta *next = meta->next;
2509c792707fSStefan Hajnoczi 
2510f50f88b9SKevin Wolf             ret = qcow2_alloc_cluster_link_l2(bs, meta);
251119dbcbf7SKevin Wolf             if (ret < 0) {
25127c2bbf4aSHu Tao                 qcow2_free_any_clusters(bs, meta->alloc_offset,
25137c2bbf4aSHu Tao                                         meta->nb_clusters, QCOW2_DISCARD_NEVER);
2514652fecd0SMax Reitz                 goto done;
2515a35e1c17SKevin Wolf             }
2516a35e1c17SKevin Wolf 
25177c2bbf4aSHu Tao             /* There are no dependent requests, but we need to remove our
25187c2bbf4aSHu Tao              * request from the list of in-flight requests */
25194e95314eSKevin Wolf             QLIST_REMOVE(meta, next_in_flight);
2520c792707fSStefan Hajnoczi 
2521c792707fSStefan Hajnoczi             g_free(meta);
2522c792707fSStefan Hajnoczi             meta = next;
2523f50f88b9SKevin Wolf         }
2524f214978aSKevin Wolf 
2525a35e1c17SKevin Wolf         /* TODO Preallocate data if requested */
2526a35e1c17SKevin Wolf 
2527d46a0bb2SKevin Wolf         bytes -= cur_bytes;
2528d46a0bb2SKevin Wolf         offset += cur_bytes;
2529a35e1c17SKevin Wolf     }
2530a35e1c17SKevin Wolf 
2531a35e1c17SKevin Wolf     /*
2532a35e1c17SKevin Wolf      * It is expected that the image file is large enough to actually contain
2533a35e1c17SKevin Wolf      * all of the allocated clusters (otherwise we get failing reads after
2534a35e1c17SKevin Wolf      * EOF). Extend the image to the last allocated sector.
2535a35e1c17SKevin Wolf      */
2536060bee89SKevin Wolf     if (host_offset != 0) {
2537d46a0bb2SKevin Wolf         uint8_t data = 0;
2538d9ca2ea2SKevin Wolf         ret = bdrv_pwrite(bs->file, (host_offset + cur_bytes) - 1,
2539d46a0bb2SKevin Wolf                           &data, 1);
254019dbcbf7SKevin Wolf         if (ret < 0) {
2541652fecd0SMax Reitz             goto done;
254219dbcbf7SKevin Wolf         }
2543a35e1c17SKevin Wolf     }
2544a35e1c17SKevin Wolf 
2545652fecd0SMax Reitz     ret = 0;
2546652fecd0SMax Reitz 
2547652fecd0SMax Reitz done:
2548652fecd0SMax Reitz     if (qemu_in_coroutine()) {
2549652fecd0SMax Reitz         qemu_co_mutex_unlock(&s->lock);
2550652fecd0SMax Reitz     }
2551652fecd0SMax Reitz     return ret;
2552a35e1c17SKevin Wolf }
2553a35e1c17SKevin Wolf 
25547c5bcc42SStefan Hajnoczi /* qcow2_refcount_metadata_size:
25557c5bcc42SStefan Hajnoczi  * @clusters: number of clusters to refcount (including data and L1/L2 tables)
25567c5bcc42SStefan Hajnoczi  * @cluster_size: size of a cluster, in bytes
25577c5bcc42SStefan Hajnoczi  * @refcount_order: refcount bits power-of-2 exponent
255812cc30a8SMax Reitz  * @generous_increase: allow for the refcount table to be 1.5x as large as it
255912cc30a8SMax Reitz  *                     needs to be
25607c5bcc42SStefan Hajnoczi  *
25617c5bcc42SStefan Hajnoczi  * Returns: Number of bytes required for refcount blocks and table metadata.
25627c5bcc42SStefan Hajnoczi  */
256312cc30a8SMax Reitz int64_t qcow2_refcount_metadata_size(int64_t clusters, size_t cluster_size,
256412cc30a8SMax Reitz                                      int refcount_order, bool generous_increase,
256512cc30a8SMax Reitz                                      uint64_t *refblock_count)
25667c5bcc42SStefan Hajnoczi {
25677c5bcc42SStefan Hajnoczi     /*
25687c5bcc42SStefan Hajnoczi      * Every host cluster is reference-counted, including metadata (even
25697c5bcc42SStefan Hajnoczi      * refcount metadata is recursively included).
25707c5bcc42SStefan Hajnoczi      *
25717c5bcc42SStefan Hajnoczi      * An accurate formula for the size of refcount metadata size is difficult
25727c5bcc42SStefan Hajnoczi      * to derive.  An easier method of calculation is finding the fixed point
25737c5bcc42SStefan Hajnoczi      * where no further refcount blocks or table clusters are required to
25747c5bcc42SStefan Hajnoczi      * reference count every cluster.
25757c5bcc42SStefan Hajnoczi      */
25767c5bcc42SStefan Hajnoczi     int64_t blocks_per_table_cluster = cluster_size / sizeof(uint64_t);
25777c5bcc42SStefan Hajnoczi     int64_t refcounts_per_block = cluster_size * 8 / (1 << refcount_order);
25787c5bcc42SStefan Hajnoczi     int64_t table = 0;  /* number of refcount table clusters */
25797c5bcc42SStefan Hajnoczi     int64_t blocks = 0; /* number of refcount block clusters */
25807c5bcc42SStefan Hajnoczi     int64_t last;
25817c5bcc42SStefan Hajnoczi     int64_t n = 0;
25827c5bcc42SStefan Hajnoczi 
25837c5bcc42SStefan Hajnoczi     do {
25847c5bcc42SStefan Hajnoczi         last = n;
25857c5bcc42SStefan Hajnoczi         blocks = DIV_ROUND_UP(clusters + table + blocks, refcounts_per_block);
25867c5bcc42SStefan Hajnoczi         table = DIV_ROUND_UP(blocks, blocks_per_table_cluster);
25877c5bcc42SStefan Hajnoczi         n = clusters + blocks + table;
258812cc30a8SMax Reitz 
258912cc30a8SMax Reitz         if (n == last && generous_increase) {
259012cc30a8SMax Reitz             clusters += DIV_ROUND_UP(table, 2);
259112cc30a8SMax Reitz             n = 0; /* force another loop */
259212cc30a8SMax Reitz             generous_increase = false;
259312cc30a8SMax Reitz         }
25947c5bcc42SStefan Hajnoczi     } while (n != last);
25957c5bcc42SStefan Hajnoczi 
259612cc30a8SMax Reitz     if (refblock_count) {
259712cc30a8SMax Reitz         *refblock_count = blocks;
259812cc30a8SMax Reitz     }
259912cc30a8SMax Reitz 
26007c5bcc42SStefan Hajnoczi     return (blocks + table) * cluster_size;
26017c5bcc42SStefan Hajnoczi }
26027c5bcc42SStefan Hajnoczi 
260395c67e3bSStefan Hajnoczi /**
260495c67e3bSStefan Hajnoczi  * qcow2_calc_prealloc_size:
260595c67e3bSStefan Hajnoczi  * @total_size: virtual disk size in bytes
260695c67e3bSStefan Hajnoczi  * @cluster_size: cluster size in bytes
260795c67e3bSStefan Hajnoczi  * @refcount_order: refcount bits power-of-2 exponent
2608a9420734SKevin Wolf  *
260995c67e3bSStefan Hajnoczi  * Returns: Total number of bytes required for the fully allocated image
261095c67e3bSStefan Hajnoczi  * (including metadata).
2611a9420734SKevin Wolf  */
261295c67e3bSStefan Hajnoczi static int64_t qcow2_calc_prealloc_size(int64_t total_size,
261395c67e3bSStefan Hajnoczi                                         size_t cluster_size,
261495c67e3bSStefan Hajnoczi                                         int refcount_order)
261595c67e3bSStefan Hajnoczi {
26160e4271b7SHu Tao     int64_t meta_size = 0;
26177c5bcc42SStefan Hajnoczi     uint64_t nl1e, nl2e;
26180e4271b7SHu Tao     int64_t aligned_total_size = align_offset(total_size, cluster_size);
26190e4271b7SHu Tao 
26200e4271b7SHu Tao     /* header: 1 cluster */
26210e4271b7SHu Tao     meta_size += cluster_size;
26220e4271b7SHu Tao 
26230e4271b7SHu Tao     /* total size of L2 tables */
26240e4271b7SHu Tao     nl2e = aligned_total_size / cluster_size;
26250e4271b7SHu Tao     nl2e = align_offset(nl2e, cluster_size / sizeof(uint64_t));
26260e4271b7SHu Tao     meta_size += nl2e * sizeof(uint64_t);
26270e4271b7SHu Tao 
26280e4271b7SHu Tao     /* total size of L1 tables */
26290e4271b7SHu Tao     nl1e = nl2e * sizeof(uint64_t) / cluster_size;
26300e4271b7SHu Tao     nl1e = align_offset(nl1e, cluster_size / sizeof(uint64_t));
26310e4271b7SHu Tao     meta_size += nl1e * sizeof(uint64_t);
26320e4271b7SHu Tao 
26337c5bcc42SStefan Hajnoczi     /* total size of refcount table and blocks */
26347c5bcc42SStefan Hajnoczi     meta_size += qcow2_refcount_metadata_size(
26357c5bcc42SStefan Hajnoczi             (meta_size + aligned_total_size) / cluster_size,
263612cc30a8SMax Reitz             cluster_size, refcount_order, false, NULL);
26370e4271b7SHu Tao 
263895c67e3bSStefan Hajnoczi     return meta_size + aligned_total_size;
263995c67e3bSStefan Hajnoczi }
264095c67e3bSStefan Hajnoczi 
26410eb4a8c1SStefan Hajnoczi static size_t qcow2_opt_get_cluster_size_del(QemuOpts *opts, Error **errp)
264295c67e3bSStefan Hajnoczi {
26430eb4a8c1SStefan Hajnoczi     size_t cluster_size;
264495c67e3bSStefan Hajnoczi     int cluster_bits;
264595c67e3bSStefan Hajnoczi 
26460eb4a8c1SStefan Hajnoczi     cluster_size = qemu_opt_get_size_del(opts, BLOCK_OPT_CLUSTER_SIZE,
26470eb4a8c1SStefan Hajnoczi                                          DEFAULT_CLUSTER_SIZE);
264895c67e3bSStefan Hajnoczi     cluster_bits = ctz32(cluster_size);
264995c67e3bSStefan Hajnoczi     if (cluster_bits < MIN_CLUSTER_BITS || cluster_bits > MAX_CLUSTER_BITS ||
265095c67e3bSStefan Hajnoczi         (1 << cluster_bits) != cluster_size)
265195c67e3bSStefan Hajnoczi     {
265295c67e3bSStefan Hajnoczi         error_setg(errp, "Cluster size must be a power of two between %d and "
265395c67e3bSStefan Hajnoczi                    "%dk", 1 << MIN_CLUSTER_BITS, 1 << (MAX_CLUSTER_BITS - 10));
26540eb4a8c1SStefan Hajnoczi         return 0;
265595c67e3bSStefan Hajnoczi     }
26560eb4a8c1SStefan Hajnoczi     return cluster_size;
26570eb4a8c1SStefan Hajnoczi }
26580eb4a8c1SStefan Hajnoczi 
26590eb4a8c1SStefan Hajnoczi static int qcow2_opt_get_version_del(QemuOpts *opts, Error **errp)
26600eb4a8c1SStefan Hajnoczi {
26610eb4a8c1SStefan Hajnoczi     char *buf;
26620eb4a8c1SStefan Hajnoczi     int ret;
26630eb4a8c1SStefan Hajnoczi 
26640eb4a8c1SStefan Hajnoczi     buf = qemu_opt_get_del(opts, BLOCK_OPT_COMPAT_LEVEL);
26650eb4a8c1SStefan Hajnoczi     if (!buf) {
26660eb4a8c1SStefan Hajnoczi         ret = 3; /* default */
26670eb4a8c1SStefan Hajnoczi     } else if (!strcmp(buf, "0.10")) {
26680eb4a8c1SStefan Hajnoczi         ret = 2;
26690eb4a8c1SStefan Hajnoczi     } else if (!strcmp(buf, "1.1")) {
26700eb4a8c1SStefan Hajnoczi         ret = 3;
26710eb4a8c1SStefan Hajnoczi     } else {
26720eb4a8c1SStefan Hajnoczi         error_setg(errp, "Invalid compatibility level: '%s'", buf);
26730eb4a8c1SStefan Hajnoczi         ret = -EINVAL;
26740eb4a8c1SStefan Hajnoczi     }
26750eb4a8c1SStefan Hajnoczi     g_free(buf);
26760eb4a8c1SStefan Hajnoczi     return ret;
26770eb4a8c1SStefan Hajnoczi }
26780eb4a8c1SStefan Hajnoczi 
26790eb4a8c1SStefan Hajnoczi static uint64_t qcow2_opt_get_refcount_bits_del(QemuOpts *opts, int version,
26800eb4a8c1SStefan Hajnoczi                                                 Error **errp)
26810eb4a8c1SStefan Hajnoczi {
26820eb4a8c1SStefan Hajnoczi     uint64_t refcount_bits;
26830eb4a8c1SStefan Hajnoczi 
26840eb4a8c1SStefan Hajnoczi     refcount_bits = qemu_opt_get_number_del(opts, BLOCK_OPT_REFCOUNT_BITS, 16);
26850eb4a8c1SStefan Hajnoczi     if (refcount_bits > 64 || !is_power_of_2(refcount_bits)) {
26860eb4a8c1SStefan Hajnoczi         error_setg(errp, "Refcount width must be a power of two and may not "
26870eb4a8c1SStefan Hajnoczi                    "exceed 64 bits");
26880eb4a8c1SStefan Hajnoczi         return 0;
26890eb4a8c1SStefan Hajnoczi     }
26900eb4a8c1SStefan Hajnoczi 
26910eb4a8c1SStefan Hajnoczi     if (version < 3 && refcount_bits != 16) {
26920eb4a8c1SStefan Hajnoczi         error_setg(errp, "Different refcount widths than 16 bits require "
26930eb4a8c1SStefan Hajnoczi                    "compatibility level 1.1 or above (use compat=1.1 or "
26940eb4a8c1SStefan Hajnoczi                    "greater)");
26950eb4a8c1SStefan Hajnoczi         return 0;
26960eb4a8c1SStefan Hajnoczi     }
26970eb4a8c1SStefan Hajnoczi 
26980eb4a8c1SStefan Hajnoczi     return refcount_bits;
26990eb4a8c1SStefan Hajnoczi }
27000eb4a8c1SStefan Hajnoczi 
27010eb4a8c1SStefan Hajnoczi static int qcow2_create2(const char *filename, int64_t total_size,
27020eb4a8c1SStefan Hajnoczi                          const char *backing_file, const char *backing_format,
27030eb4a8c1SStefan Hajnoczi                          int flags, size_t cluster_size, PreallocMode prealloc,
27040eb4a8c1SStefan Hajnoczi                          QemuOpts *opts, int version, int refcount_order,
27050eb4a8c1SStefan Hajnoczi                          const char *encryptfmt, Error **errp)
27060eb4a8c1SStefan Hajnoczi {
27070eb4a8c1SStefan Hajnoczi     QDict *options;
270895c67e3bSStefan Hajnoczi 
270995c67e3bSStefan Hajnoczi     /*
271095c67e3bSStefan Hajnoczi      * Open the image file and write a minimal qcow2 header.
271195c67e3bSStefan Hajnoczi      *
271295c67e3bSStefan Hajnoczi      * We keep things simple and start with a zero-sized image. We also
271395c67e3bSStefan Hajnoczi      * do without refcount blocks or a L1 table for now. We'll fix the
271495c67e3bSStefan Hajnoczi      * inconsistency later.
271595c67e3bSStefan Hajnoczi      *
271695c67e3bSStefan Hajnoczi      * We do need a refcount table because growing the refcount table means
271795c67e3bSStefan Hajnoczi      * allocating two new refcount blocks - the seconds of which would be at
271895c67e3bSStefan Hajnoczi      * 2 GB for 64k clusters, and we don't want to have a 2 GB initial file
271995c67e3bSStefan Hajnoczi      * size for any qcow2 image.
272095c67e3bSStefan Hajnoczi      */
272195c67e3bSStefan Hajnoczi     BlockBackend *blk;
272295c67e3bSStefan Hajnoczi     QCowHeader *header;
272395c67e3bSStefan Hajnoczi     uint64_t* refcount_table;
272495c67e3bSStefan Hajnoczi     Error *local_err = NULL;
272595c67e3bSStefan Hajnoczi     int ret;
272695c67e3bSStefan Hajnoczi 
272795c67e3bSStefan Hajnoczi     if (prealloc == PREALLOC_MODE_FULL || prealloc == PREALLOC_MODE_FALLOC) {
272895c67e3bSStefan Hajnoczi         int64_t prealloc_size =
272995c67e3bSStefan Hajnoczi             qcow2_calc_prealloc_size(total_size, cluster_size, refcount_order);
273095c67e3bSStefan Hajnoczi         qemu_opt_set_number(opts, BLOCK_OPT_SIZE, prealloc_size, &error_abort);
2731f43e47dbSMarkus Armbruster         qemu_opt_set(opts, BLOCK_OPT_PREALLOC, PreallocMode_lookup[prealloc],
2732f43e47dbSMarkus Armbruster                      &error_abort);
27330e4271b7SHu Tao     }
27340e4271b7SHu Tao 
2735c282e1fdSChunyan Liu     ret = bdrv_create_file(filename, opts, &local_err);
2736a9420734SKevin Wolf     if (ret < 0) {
27373ef6c40aSMax Reitz         error_propagate(errp, local_err);
2738a9420734SKevin Wolf         return ret;
2739a9420734SKevin Wolf     }
2740a9420734SKevin Wolf 
2741efaa7c4eSMax Reitz     blk = blk_new_open(filename, NULL, NULL,
274255880601SKevin Wolf                        BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL,
274355880601SKevin Wolf                        &local_err);
274423588797SKevin Wolf     if (blk == NULL) {
27453ef6c40aSMax Reitz         error_propagate(errp, local_err);
274623588797SKevin Wolf         return -EIO;
2747a9420734SKevin Wolf     }
2748a9420734SKevin Wolf 
274923588797SKevin Wolf     blk_set_allow_write_beyond_eof(blk, true);
275023588797SKevin Wolf 
2751a9420734SKevin Wolf     /* Write the header */
2752f8413b3cSKevin Wolf     QEMU_BUILD_BUG_ON((1 << MIN_CLUSTER_BITS) < sizeof(*header));
2753f8413b3cSKevin Wolf     header = g_malloc0(cluster_size);
2754f8413b3cSKevin Wolf     *header = (QCowHeader) {
2755f8413b3cSKevin Wolf         .magic                      = cpu_to_be32(QCOW_MAGIC),
2756f8413b3cSKevin Wolf         .version                    = cpu_to_be32(version),
27570eb4a8c1SStefan Hajnoczi         .cluster_bits               = cpu_to_be32(ctz32(cluster_size)),
2758f8413b3cSKevin Wolf         .size                       = cpu_to_be64(0),
2759f8413b3cSKevin Wolf         .l1_table_offset            = cpu_to_be64(0),
2760f8413b3cSKevin Wolf         .l1_size                    = cpu_to_be32(0),
2761f8413b3cSKevin Wolf         .refcount_table_offset      = cpu_to_be64(cluster_size),
2762f8413b3cSKevin Wolf         .refcount_table_clusters    = cpu_to_be32(1),
2763bd4b167fSMax Reitz         .refcount_order             = cpu_to_be32(refcount_order),
2764f8413b3cSKevin Wolf         .header_length              = cpu_to_be32(sizeof(*header)),
2765f8413b3cSKevin Wolf     };
2766a9420734SKevin Wolf 
2767b25b387fSDaniel P. Berrange     /* We'll update this to correct value later */
2768f8413b3cSKevin Wolf     header->crypt_method = cpu_to_be32(QCOW_CRYPT_NONE);
2769a9420734SKevin Wolf 
2770bfe8043eSStefan Hajnoczi     if (flags & BLOCK_FLAG_LAZY_REFCOUNTS) {
2771f8413b3cSKevin Wolf         header->compatible_features |=
2772bfe8043eSStefan Hajnoczi             cpu_to_be64(QCOW2_COMPAT_LAZY_REFCOUNTS);
2773bfe8043eSStefan Hajnoczi     }
2774bfe8043eSStefan Hajnoczi 
27758341f00dSEric Blake     ret = blk_pwrite(blk, 0, header, cluster_size, 0);
2776f8413b3cSKevin Wolf     g_free(header);
2777a9420734SKevin Wolf     if (ret < 0) {
27783ef6c40aSMax Reitz         error_setg_errno(errp, -ret, "Could not write qcow2 header");
2779a9420734SKevin Wolf         goto out;
2780a9420734SKevin Wolf     }
2781a9420734SKevin Wolf 
2782b106ad91SKevin Wolf     /* Write a refcount table with one refcount block */
2783b106ad91SKevin Wolf     refcount_table = g_malloc0(2 * cluster_size);
2784b106ad91SKevin Wolf     refcount_table[0] = cpu_to_be64(2 * cluster_size);
27858341f00dSEric Blake     ret = blk_pwrite(blk, cluster_size, refcount_table, 2 * cluster_size, 0);
27867267c094SAnthony Liguori     g_free(refcount_table);
2787a9420734SKevin Wolf 
2788a9420734SKevin Wolf     if (ret < 0) {
27893ef6c40aSMax Reitz         error_setg_errno(errp, -ret, "Could not write refcount table");
2790a9420734SKevin Wolf         goto out;
2791a9420734SKevin Wolf     }
2792a9420734SKevin Wolf 
279323588797SKevin Wolf     blk_unref(blk);
279423588797SKevin Wolf     blk = NULL;
2795a9420734SKevin Wolf 
2796a9420734SKevin Wolf     /*
2797a9420734SKevin Wolf      * And now open the image and make it consistent first (i.e. increase the
2798a9420734SKevin Wolf      * refcount of the cluster that is occupied by the header and the refcount
2799a9420734SKevin Wolf      * table)
2800a9420734SKevin Wolf      */
2801e6641719SMax Reitz     options = qdict_new();
280246f5ac20SEric Blake     qdict_put_str(options, "driver", "qcow2");
2803efaa7c4eSMax Reitz     blk = blk_new_open(filename, NULL, options,
280455880601SKevin Wolf                        BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_NO_FLUSH,
280555880601SKevin Wolf                        &local_err);
280623588797SKevin Wolf     if (blk == NULL) {
28073ef6c40aSMax Reitz         error_propagate(errp, local_err);
280823588797SKevin Wolf         ret = -EIO;
2809a9420734SKevin Wolf         goto out;
2810a9420734SKevin Wolf     }
2811a9420734SKevin Wolf 
281223588797SKevin Wolf     ret = qcow2_alloc_clusters(blk_bs(blk), 3 * cluster_size);
2813a9420734SKevin Wolf     if (ret < 0) {
28143ef6c40aSMax Reitz         error_setg_errno(errp, -ret, "Could not allocate clusters for qcow2 "
28153ef6c40aSMax Reitz                          "header and refcount table");
2816a9420734SKevin Wolf         goto out;
2817a9420734SKevin Wolf 
2818a9420734SKevin Wolf     } else if (ret != 0) {
2819a9420734SKevin Wolf         error_report("Huh, first cluster in empty image is already in use?");
2820a9420734SKevin Wolf         abort();
2821a9420734SKevin Wolf     }
2822a9420734SKevin Wolf 
2823b527c9b3SKevin Wolf     /* Create a full header (including things like feature table) */
282423588797SKevin Wolf     ret = qcow2_update_header(blk_bs(blk));
2825b527c9b3SKevin Wolf     if (ret < 0) {
2826b527c9b3SKevin Wolf         error_setg_errno(errp, -ret, "Could not update qcow2 header");
2827b527c9b3SKevin Wolf         goto out;
2828b527c9b3SKevin Wolf     }
2829b527c9b3SKevin Wolf 
2830a9420734SKevin Wolf     /* Okay, now that we have a valid image, let's give it the right size */
28313a691c50SMax Reitz     ret = blk_truncate(blk, total_size, PREALLOC_MODE_OFF, errp);
2832a9420734SKevin Wolf     if (ret < 0) {
2833ed3d2ec9SMax Reitz         error_prepend(errp, "Could not resize image: ");
2834a9420734SKevin Wolf         goto out;
2835a9420734SKevin Wolf     }
2836a9420734SKevin Wolf 
2837a9420734SKevin Wolf     /* Want a backing file? There you go.*/
2838a9420734SKevin Wolf     if (backing_file) {
283923588797SKevin Wolf         ret = bdrv_change_backing_file(blk_bs(blk), backing_file, backing_format);
2840a9420734SKevin Wolf         if (ret < 0) {
28413ef6c40aSMax Reitz             error_setg_errno(errp, -ret, "Could not assign backing file '%s' "
28423ef6c40aSMax Reitz                              "with format '%s'", backing_file, backing_format);
2843a9420734SKevin Wolf             goto out;
2844a9420734SKevin Wolf         }
2845a9420734SKevin Wolf     }
2846a9420734SKevin Wolf 
2847b25b387fSDaniel P. Berrange     /* Want encryption? There you go. */
2848b25b387fSDaniel P. Berrange     if (encryptfmt) {
2849b25b387fSDaniel P. Berrange         ret = qcow2_set_up_encryption(blk_bs(blk), encryptfmt, opts, errp);
2850b25b387fSDaniel P. Berrange         if (ret < 0) {
2851b25b387fSDaniel P. Berrange             goto out;
2852b25b387fSDaniel P. Berrange         }
2853b25b387fSDaniel P. Berrange     }
2854b25b387fSDaniel P. Berrange 
2855a9420734SKevin Wolf     /* And if we're supposed to preallocate metadata, do that now */
28560e4271b7SHu Tao     if (prealloc != PREALLOC_MODE_OFF) {
28577bc45dc1SMax Reitz         ret = preallocate(blk_bs(blk), 0, total_size);
2858a9420734SKevin Wolf         if (ret < 0) {
28593ef6c40aSMax Reitz             error_setg_errno(errp, -ret, "Could not preallocate metadata");
2860a9420734SKevin Wolf             goto out;
2861a9420734SKevin Wolf         }
2862a9420734SKevin Wolf     }
2863a9420734SKevin Wolf 
286423588797SKevin Wolf     blk_unref(blk);
286523588797SKevin Wolf     blk = NULL;
2866ba2ab2f2SMax Reitz 
2867b25b387fSDaniel P. Berrange     /* Reopen the image without BDRV_O_NO_FLUSH to flush it before returning.
2868b25b387fSDaniel P. Berrange      * Using BDRV_O_NO_IO, since encryption is now setup we don't want to
2869b25b387fSDaniel P. Berrange      * have to setup decryption context. We're not doing any I/O on the top
2870b25b387fSDaniel P. Berrange      * level BlockDriverState, only lower layers, where BDRV_O_NO_IO does
2871b25b387fSDaniel P. Berrange      * not have effect.
2872b25b387fSDaniel P. Berrange      */
2873e6641719SMax Reitz     options = qdict_new();
287446f5ac20SEric Blake     qdict_put_str(options, "driver", "qcow2");
2875efaa7c4eSMax Reitz     blk = blk_new_open(filename, NULL, options,
2876b25b387fSDaniel P. Berrange                        BDRV_O_RDWR | BDRV_O_NO_BACKING | BDRV_O_NO_IO,
2877b25b387fSDaniel P. Berrange                        &local_err);
287823588797SKevin Wolf     if (blk == NULL) {
2879ba2ab2f2SMax Reitz         error_propagate(errp, local_err);
288023588797SKevin Wolf         ret = -EIO;
2881ba2ab2f2SMax Reitz         goto out;
2882ba2ab2f2SMax Reitz     }
2883ba2ab2f2SMax Reitz 
2884a9420734SKevin Wolf     ret = 0;
2885a9420734SKevin Wolf out:
288623588797SKevin Wolf     if (blk) {
288723588797SKevin Wolf         blk_unref(blk);
2888f67503e5SMax Reitz     }
2889a9420734SKevin Wolf     return ret;
2890a9420734SKevin Wolf }
2891de5f3f40SKevin Wolf 
28921bd0e2d1SChunyan Liu static int qcow2_create(const char *filename, QemuOpts *opts, Error **errp)
2893de5f3f40SKevin Wolf {
28941bd0e2d1SChunyan Liu     char *backing_file = NULL;
28951bd0e2d1SChunyan Liu     char *backing_fmt = NULL;
28961bd0e2d1SChunyan Liu     char *buf = NULL;
2897180e9526SHu Tao     uint64_t size = 0;
2898de5f3f40SKevin Wolf     int flags = 0;
289999cce9faSKevin Wolf     size_t cluster_size = DEFAULT_CLUSTER_SIZE;
2900ffeaac9bSHu Tao     PreallocMode prealloc;
29010eb4a8c1SStefan Hajnoczi     int version;
29020eb4a8c1SStefan Hajnoczi     uint64_t refcount_bits;
2903bd4b167fSMax Reitz     int refcount_order;
29040696ae2cSDaniel P. Berrange     char *encryptfmt = NULL;
29053ef6c40aSMax Reitz     Error *local_err = NULL;
29063ef6c40aSMax Reitz     int ret;
2907de5f3f40SKevin Wolf 
2908de5f3f40SKevin Wolf     /* Read out options */
2909180e9526SHu Tao     size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
2910c2eb918eSHu Tao                     BDRV_SECTOR_SIZE);
29111bd0e2d1SChunyan Liu     backing_file = qemu_opt_get_del(opts, BLOCK_OPT_BACKING_FILE);
29121bd0e2d1SChunyan Liu     backing_fmt = qemu_opt_get_del(opts, BLOCK_OPT_BACKING_FMT);
29130cb8d47bSDaniel P. Berrange     encryptfmt = qemu_opt_get_del(opts, BLOCK_OPT_ENCRYPT_FORMAT);
29140cb8d47bSDaniel P. Berrange     if (encryptfmt) {
29150696ae2cSDaniel P. Berrange         if (qemu_opt_get(opts, BLOCK_OPT_ENCRYPT)) {
29160cb8d47bSDaniel P. Berrange             error_setg(errp, "Options " BLOCK_OPT_ENCRYPT " and "
29170cb8d47bSDaniel P. Berrange                        BLOCK_OPT_ENCRYPT_FORMAT " are mutually exclusive");
29180cb8d47bSDaniel P. Berrange             ret = -EINVAL;
29190cb8d47bSDaniel P. Berrange             goto finish;
29200cb8d47bSDaniel P. Berrange         }
29210cb8d47bSDaniel P. Berrange     } else if (qemu_opt_get_bool_del(opts, BLOCK_OPT_ENCRYPT, false)) {
29220696ae2cSDaniel P. Berrange         encryptfmt = g_strdup("aes");
2923de5f3f40SKevin Wolf     }
29240eb4a8c1SStefan Hajnoczi     cluster_size = qcow2_opt_get_cluster_size_del(opts, &local_err);
29250eb4a8c1SStefan Hajnoczi     if (local_err) {
29260eb4a8c1SStefan Hajnoczi         error_propagate(errp, local_err);
29270eb4a8c1SStefan Hajnoczi         ret = -EINVAL;
29280eb4a8c1SStefan Hajnoczi         goto finish;
29290eb4a8c1SStefan Hajnoczi     }
29301bd0e2d1SChunyan Liu     buf = qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC);
2931ffeaac9bSHu Tao     prealloc = qapi_enum_parse(PreallocMode_lookup, buf,
29327fb1cf16SEric Blake                                PREALLOC_MODE__MAX, PREALLOC_MODE_OFF,
2933ffeaac9bSHu Tao                                &local_err);
2934ffeaac9bSHu Tao     if (local_err) {
2935ffeaac9bSHu Tao         error_propagate(errp, local_err);
29361bd0e2d1SChunyan Liu         ret = -EINVAL;
29371bd0e2d1SChunyan Liu         goto finish;
2938de5f3f40SKevin Wolf     }
29390eb4a8c1SStefan Hajnoczi 
29400eb4a8c1SStefan Hajnoczi     version = qcow2_opt_get_version_del(opts, &local_err);
29410eb4a8c1SStefan Hajnoczi     if (local_err) {
29420eb4a8c1SStefan Hajnoczi         error_propagate(errp, local_err);
29431bd0e2d1SChunyan Liu         ret = -EINVAL;
29441bd0e2d1SChunyan Liu         goto finish;
29456744cbabSKevin Wolf     }
29461bd0e2d1SChunyan Liu 
29471bd0e2d1SChunyan Liu     if (qemu_opt_get_bool_del(opts, BLOCK_OPT_LAZY_REFCOUNTS, false)) {
29481bd0e2d1SChunyan Liu         flags |= BLOCK_FLAG_LAZY_REFCOUNTS;
2949de5f3f40SKevin Wolf     }
2950de5f3f40SKevin Wolf 
2951ffeaac9bSHu Tao     if (backing_file && prealloc != PREALLOC_MODE_OFF) {
29523ef6c40aSMax Reitz         error_setg(errp, "Backing file and preallocation cannot be used at "
29533ef6c40aSMax Reitz                    "the same time");
29541bd0e2d1SChunyan Liu         ret = -EINVAL;
29551bd0e2d1SChunyan Liu         goto finish;
2956de5f3f40SKevin Wolf     }
2957de5f3f40SKevin Wolf 
2958bfe8043eSStefan Hajnoczi     if (version < 3 && (flags & BLOCK_FLAG_LAZY_REFCOUNTS)) {
29593ef6c40aSMax Reitz         error_setg(errp, "Lazy refcounts only supported with compatibility "
29603ef6c40aSMax Reitz                    "level 1.1 and above (use compat=1.1 or greater)");
29611bd0e2d1SChunyan Liu         ret = -EINVAL;
29621bd0e2d1SChunyan Liu         goto finish;
2963bfe8043eSStefan Hajnoczi     }
2964bfe8043eSStefan Hajnoczi 
29650eb4a8c1SStefan Hajnoczi     refcount_bits = qcow2_opt_get_refcount_bits_del(opts, version, &local_err);
29660eb4a8c1SStefan Hajnoczi     if (local_err) {
29670eb4a8c1SStefan Hajnoczi         error_propagate(errp, local_err);
2968bd4b167fSMax Reitz         ret = -EINVAL;
2969bd4b167fSMax Reitz         goto finish;
2970bd4b167fSMax Reitz     }
2971bd4b167fSMax Reitz 
2972786a4ea8SStefan Hajnoczi     refcount_order = ctz32(refcount_bits);
2973bd4b167fSMax Reitz 
2974180e9526SHu Tao     ret = qcow2_create2(filename, size, backing_file, backing_fmt, flags,
2975bd4b167fSMax Reitz                         cluster_size, prealloc, opts, version, refcount_order,
29760cb8d47bSDaniel P. Berrange                         encryptfmt, &local_err);
29773ef6c40aSMax Reitz     error_propagate(errp, local_err);
29781bd0e2d1SChunyan Liu 
29791bd0e2d1SChunyan Liu finish:
29801bd0e2d1SChunyan Liu     g_free(backing_file);
29811bd0e2d1SChunyan Liu     g_free(backing_fmt);
29820696ae2cSDaniel P. Berrange     g_free(encryptfmt);
29831bd0e2d1SChunyan Liu     g_free(buf);
29843ef6c40aSMax Reitz     return ret;
2985de5f3f40SKevin Wolf }
2986de5f3f40SKevin Wolf 
29872928abceSDenis V. Lunev 
2988ebb718a5SEric Blake static bool is_zero_sectors(BlockDriverState *bs, int64_t start,
2989ebb718a5SEric Blake                             uint32_t count)
29902928abceSDenis V. Lunev {
29912928abceSDenis V. Lunev     int nr;
29922928abceSDenis V. Lunev     BlockDriverState *file;
2993ebb718a5SEric Blake     int64_t res;
2994ebb718a5SEric Blake 
2995fbaa6bb3SEric Blake     if (start + count > bs->total_sectors) {
2996fbaa6bb3SEric Blake         count = bs->total_sectors - start;
2997fbaa6bb3SEric Blake     }
2998fbaa6bb3SEric Blake 
2999ebb718a5SEric Blake     if (!count) {
3000ebb718a5SEric Blake         return true;
30012928abceSDenis V. Lunev     }
3002ebb718a5SEric Blake     res = bdrv_get_block_status_above(bs, NULL, start, count,
3003ebb718a5SEric Blake                                       &nr, &file);
3004ebb718a5SEric Blake     return res >= 0 && (res & BDRV_BLOCK_ZERO) && nr == count;
30052928abceSDenis V. Lunev }
30062928abceSDenis V. Lunev 
30075544b59fSEric Blake static coroutine_fn int qcow2_co_pwrite_zeroes(BlockDriverState *bs,
3008f5a5ca79SManos Pitsidianakis     int64_t offset, int bytes, BdrvRequestFlags flags)
3009621f0589SKevin Wolf {
3010621f0589SKevin Wolf     int ret;
3011ff99129aSKevin Wolf     BDRVQcow2State *s = bs->opaque;
3012621f0589SKevin Wolf 
30135544b59fSEric Blake     uint32_t head = offset % s->cluster_size;
3014f5a5ca79SManos Pitsidianakis     uint32_t tail = (offset + bytes) % s->cluster_size;
30152928abceSDenis V. Lunev 
3016f5a5ca79SManos Pitsidianakis     trace_qcow2_pwrite_zeroes_start_req(qemu_coroutine_self(), offset, bytes);
3017f5a5ca79SManos Pitsidianakis     if (offset + bytes == bs->total_sectors * BDRV_SECTOR_SIZE) {
3018fbaa6bb3SEric Blake         tail = 0;
3019fbaa6bb3SEric Blake     }
30205a64e942SDenis V. Lunev 
3021ebb718a5SEric Blake     if (head || tail) {
30225544b59fSEric Blake         int64_t cl_start = (offset - head) >> BDRV_SECTOR_BITS;
3023ebb718a5SEric Blake         uint64_t off;
3024ecfe1863SKevin Wolf         unsigned int nr;
30252928abceSDenis V. Lunev 
3026f5a5ca79SManos Pitsidianakis         assert(head + bytes <= s->cluster_size);
30272928abceSDenis V. Lunev 
3028ebb718a5SEric Blake         /* check whether remainder of cluster already reads as zero */
30295544b59fSEric Blake         if (!(is_zero_sectors(bs, cl_start,
30305544b59fSEric Blake                               DIV_ROUND_UP(head, BDRV_SECTOR_SIZE)) &&
3031f5a5ca79SManos Pitsidianakis               is_zero_sectors(bs, (offset + bytes) >> BDRV_SECTOR_BITS,
30325544b59fSEric Blake                               DIV_ROUND_UP(-tail & (s->cluster_size - 1),
30335544b59fSEric Blake                                            BDRV_SECTOR_SIZE)))) {
3034621f0589SKevin Wolf             return -ENOTSUP;
3035621f0589SKevin Wolf         }
3036621f0589SKevin Wolf 
3037621f0589SKevin Wolf         qemu_co_mutex_lock(&s->lock);
30382928abceSDenis V. Lunev         /* We can have new write after previous check */
30395544b59fSEric Blake         offset = cl_start << BDRV_SECTOR_BITS;
3040f5a5ca79SManos Pitsidianakis         bytes = s->cluster_size;
3041ecfe1863SKevin Wolf         nr = s->cluster_size;
30425544b59fSEric Blake         ret = qcow2_get_cluster_offset(bs, offset, &nr, &off);
3043fdfab37dSEric Blake         if (ret != QCOW2_CLUSTER_UNALLOCATED &&
3044fdfab37dSEric Blake             ret != QCOW2_CLUSTER_ZERO_PLAIN &&
3045fdfab37dSEric Blake             ret != QCOW2_CLUSTER_ZERO_ALLOC) {
30462928abceSDenis V. Lunev             qemu_co_mutex_unlock(&s->lock);
30472928abceSDenis V. Lunev             return -ENOTSUP;
30482928abceSDenis V. Lunev         }
30492928abceSDenis V. Lunev     } else {
30502928abceSDenis V. Lunev         qemu_co_mutex_lock(&s->lock);
30512928abceSDenis V. Lunev     }
30522928abceSDenis V. Lunev 
3053f5a5ca79SManos Pitsidianakis     trace_qcow2_pwrite_zeroes(qemu_coroutine_self(), offset, bytes);
30545a64e942SDenis V. Lunev 
30552928abceSDenis V. Lunev     /* Whatever is left can use real zero clusters */
3056f5a5ca79SManos Pitsidianakis     ret = qcow2_cluster_zeroize(bs, offset, bytes, flags);
3057621f0589SKevin Wolf     qemu_co_mutex_unlock(&s->lock);
3058621f0589SKevin Wolf 
3059621f0589SKevin Wolf     return ret;
3060621f0589SKevin Wolf }
3061621f0589SKevin Wolf 
306282e8a788SEric Blake static coroutine_fn int qcow2_co_pdiscard(BlockDriverState *bs,
3063f5a5ca79SManos Pitsidianakis                                           int64_t offset, int bytes)
30645ea929e3SKevin Wolf {
30656db39ae2SPaolo Bonzini     int ret;
3066ff99129aSKevin Wolf     BDRVQcow2State *s = bs->opaque;
30676db39ae2SPaolo Bonzini 
3068f5a5ca79SManos Pitsidianakis     if (!QEMU_IS_ALIGNED(offset | bytes, s->cluster_size)) {
3069f5a5ca79SManos Pitsidianakis         assert(bytes < s->cluster_size);
3070048c5fd1SEric Blake         /* Ignore partial clusters, except for the special case of the
3071048c5fd1SEric Blake          * complete partial cluster at the end of an unaligned file */
3072048c5fd1SEric Blake         if (!QEMU_IS_ALIGNED(offset, s->cluster_size) ||
3073f5a5ca79SManos Pitsidianakis             offset + bytes != bs->total_sectors * BDRV_SECTOR_SIZE) {
307449228d1eSEric Blake             return -ENOTSUP;
307549228d1eSEric Blake         }
3076048c5fd1SEric Blake     }
307749228d1eSEric Blake 
30786db39ae2SPaolo Bonzini     qemu_co_mutex_lock(&s->lock);
3079f5a5ca79SManos Pitsidianakis     ret = qcow2_cluster_discard(bs, offset, bytes, QCOW2_DISCARD_REQUEST,
3080d2cb36afSEric Blake                                 false);
30816db39ae2SPaolo Bonzini     qemu_co_mutex_unlock(&s->lock);
30826db39ae2SPaolo Bonzini     return ret;
30835ea929e3SKevin Wolf }
30845ea929e3SKevin Wolf 
30858243ccb7SMax Reitz static int qcow2_truncate(BlockDriverState *bs, int64_t offset,
30868243ccb7SMax Reitz                           PreallocMode prealloc, Error **errp)
3087419b19d9SStefan Hajnoczi {
3088ff99129aSKevin Wolf     BDRVQcow2State *s = bs->opaque;
308995b98f34SMax Reitz     uint64_t old_length;
30902cf7cfa1SKevin Wolf     int64_t new_l1_size;
30912cf7cfa1SKevin Wolf     int ret;
3092419b19d9SStefan Hajnoczi 
3093772d1f97SMax Reitz     if (prealloc != PREALLOC_MODE_OFF && prealloc != PREALLOC_MODE_METADATA &&
3094772d1f97SMax Reitz         prealloc != PREALLOC_MODE_FALLOC && prealloc != PREALLOC_MODE_FULL)
3095772d1f97SMax Reitz     {
30968243ccb7SMax Reitz         error_setg(errp, "Unsupported preallocation mode '%s'",
30978243ccb7SMax Reitz                    PreallocMode_lookup[prealloc]);
30988243ccb7SMax Reitz         return -ENOTSUP;
30998243ccb7SMax Reitz     }
31008243ccb7SMax Reitz 
3101419b19d9SStefan Hajnoczi     if (offset & 511) {
31024bff28b8SMax Reitz         error_setg(errp, "The new size must be a multiple of 512");
3103419b19d9SStefan Hajnoczi         return -EINVAL;
3104419b19d9SStefan Hajnoczi     }
3105419b19d9SStefan Hajnoczi 
3106419b19d9SStefan Hajnoczi     /* cannot proceed if image has snapshots */
3107419b19d9SStefan Hajnoczi     if (s->nb_snapshots) {
31084bff28b8SMax Reitz         error_setg(errp, "Can't resize an image which has snapshots");
3109419b19d9SStefan Hajnoczi         return -ENOTSUP;
3110419b19d9SStefan Hajnoczi     }
3111419b19d9SStefan Hajnoczi 
311288ddffaeSVladimir Sementsov-Ogievskiy     /* cannot proceed if image has bitmaps */
311388ddffaeSVladimir Sementsov-Ogievskiy     if (s->nb_bitmaps) {
311488ddffaeSVladimir Sementsov-Ogievskiy         /* TODO: resize bitmaps in the image */
311588ddffaeSVladimir Sementsov-Ogievskiy         error_setg(errp, "Can't resize an image which has bitmaps");
311688ddffaeSVladimir Sementsov-Ogievskiy         return -ENOTSUP;
311788ddffaeSVladimir Sementsov-Ogievskiy     }
311888ddffaeSVladimir Sementsov-Ogievskiy 
311995b98f34SMax Reitz     old_length = bs->total_sectors * 512;
312095b98f34SMax Reitz 
3121419b19d9SStefan Hajnoczi     /* shrinking is currently not supported */
312295b98f34SMax Reitz     if (offset < old_length) {
31234bff28b8SMax Reitz         error_setg(errp, "qcow2 doesn't support shrinking images yet");
3124419b19d9SStefan Hajnoczi         return -ENOTSUP;
3125419b19d9SStefan Hajnoczi     }
3126419b19d9SStefan Hajnoczi 
3127419b19d9SStefan Hajnoczi     new_l1_size = size_to_l1(s, offset);
312872893756SStefan Hajnoczi     ret = qcow2_grow_l1_table(bs, new_l1_size, true);
3129419b19d9SStefan Hajnoczi     if (ret < 0) {
3130f59adb32SMax Reitz         error_setg_errno(errp, -ret, "Failed to grow the L1 table");
3131419b19d9SStefan Hajnoczi         return ret;
3132419b19d9SStefan Hajnoczi     }
3133419b19d9SStefan Hajnoczi 
313495b98f34SMax Reitz     switch (prealloc) {
313595b98f34SMax Reitz     case PREALLOC_MODE_OFF:
313695b98f34SMax Reitz         break;
313795b98f34SMax Reitz 
313895b98f34SMax Reitz     case PREALLOC_MODE_METADATA:
313995b98f34SMax Reitz         ret = preallocate(bs, old_length, offset);
314095b98f34SMax Reitz         if (ret < 0) {
314195b98f34SMax Reitz             error_setg_errno(errp, -ret, "Preallocation failed");
314295b98f34SMax Reitz             return ret;
314395b98f34SMax Reitz         }
314495b98f34SMax Reitz         break;
314595b98f34SMax Reitz 
3146772d1f97SMax Reitz     case PREALLOC_MODE_FALLOC:
3147772d1f97SMax Reitz     case PREALLOC_MODE_FULL:
3148772d1f97SMax Reitz     {
3149772d1f97SMax Reitz         int64_t allocation_start, host_offset, guest_offset;
3150772d1f97SMax Reitz         int64_t clusters_allocated;
3151772d1f97SMax Reitz         int64_t old_file_size, new_file_size;
3152772d1f97SMax Reitz         uint64_t nb_new_data_clusters, nb_new_l2_tables;
3153772d1f97SMax Reitz 
3154772d1f97SMax Reitz         old_file_size = bdrv_getlength(bs->file->bs);
3155772d1f97SMax Reitz         if (old_file_size < 0) {
3156772d1f97SMax Reitz             error_setg_errno(errp, -old_file_size,
3157772d1f97SMax Reitz                              "Failed to inquire current file length");
3158772d1f97SMax Reitz             return ret;
3159772d1f97SMax Reitz         }
3160772d1f97SMax Reitz 
3161772d1f97SMax Reitz         nb_new_data_clusters = DIV_ROUND_UP(offset - old_length,
3162772d1f97SMax Reitz                                             s->cluster_size);
3163772d1f97SMax Reitz 
3164772d1f97SMax Reitz         /* This is an overestimation; we will not actually allocate space for
3165772d1f97SMax Reitz          * these in the file but just make sure the new refcount structures are
3166772d1f97SMax Reitz          * able to cover them so we will not have to allocate new refblocks
3167772d1f97SMax Reitz          * while entering the data blocks in the potentially new L2 tables.
3168772d1f97SMax Reitz          * (We do not actually care where the L2 tables are placed. Maybe they
3169772d1f97SMax Reitz          *  are already allocated or they can be placed somewhere before
3170772d1f97SMax Reitz          *  @old_file_size. It does not matter because they will be fully
3171772d1f97SMax Reitz          *  allocated automatically, so they do not need to be covered by the
3172772d1f97SMax Reitz          *  preallocation. All that matters is that we will not have to allocate
3173772d1f97SMax Reitz          *  new refcount structures for them.) */
3174772d1f97SMax Reitz         nb_new_l2_tables = DIV_ROUND_UP(nb_new_data_clusters,
3175772d1f97SMax Reitz                                         s->cluster_size / sizeof(uint64_t));
3176772d1f97SMax Reitz         /* The cluster range may not be aligned to L2 boundaries, so add one L2
3177772d1f97SMax Reitz          * table for a potential head/tail */
3178772d1f97SMax Reitz         nb_new_l2_tables++;
3179772d1f97SMax Reitz 
3180772d1f97SMax Reitz         allocation_start = qcow2_refcount_area(bs, old_file_size,
3181772d1f97SMax Reitz                                                nb_new_data_clusters +
3182772d1f97SMax Reitz                                                nb_new_l2_tables,
3183772d1f97SMax Reitz                                                true, 0, 0);
3184772d1f97SMax Reitz         if (allocation_start < 0) {
3185772d1f97SMax Reitz             error_setg_errno(errp, -allocation_start,
3186772d1f97SMax Reitz                              "Failed to resize refcount structures");
3187772d1f97SMax Reitz             return -allocation_start;
3188772d1f97SMax Reitz         }
3189772d1f97SMax Reitz 
3190772d1f97SMax Reitz         clusters_allocated = qcow2_alloc_clusters_at(bs, allocation_start,
3191772d1f97SMax Reitz                                                      nb_new_data_clusters);
3192772d1f97SMax Reitz         if (clusters_allocated < 0) {
3193772d1f97SMax Reitz             error_setg_errno(errp, -clusters_allocated,
3194772d1f97SMax Reitz                              "Failed to allocate data clusters");
3195772d1f97SMax Reitz             return -clusters_allocated;
3196772d1f97SMax Reitz         }
3197772d1f97SMax Reitz 
3198772d1f97SMax Reitz         assert(clusters_allocated == nb_new_data_clusters);
3199772d1f97SMax Reitz 
3200772d1f97SMax Reitz         /* Allocate the data area */
3201772d1f97SMax Reitz         new_file_size = allocation_start +
3202772d1f97SMax Reitz                         nb_new_data_clusters * s->cluster_size;
3203772d1f97SMax Reitz         ret = bdrv_truncate(bs->file, new_file_size, prealloc, errp);
3204772d1f97SMax Reitz         if (ret < 0) {
3205772d1f97SMax Reitz             error_prepend(errp, "Failed to resize underlying file: ");
3206772d1f97SMax Reitz             qcow2_free_clusters(bs, allocation_start,
3207772d1f97SMax Reitz                                 nb_new_data_clusters * s->cluster_size,
3208772d1f97SMax Reitz                                 QCOW2_DISCARD_OTHER);
3209772d1f97SMax Reitz             return ret;
3210772d1f97SMax Reitz         }
3211772d1f97SMax Reitz 
3212772d1f97SMax Reitz         /* Create the necessary L2 entries */
3213772d1f97SMax Reitz         host_offset = allocation_start;
3214772d1f97SMax Reitz         guest_offset = old_length;
3215772d1f97SMax Reitz         while (nb_new_data_clusters) {
3216772d1f97SMax Reitz             int64_t guest_cluster = guest_offset >> s->cluster_bits;
3217772d1f97SMax Reitz             int64_t nb_clusters = MIN(nb_new_data_clusters,
3218772d1f97SMax Reitz                                       s->l2_size - guest_cluster % s->l2_size);
3219772d1f97SMax Reitz             QCowL2Meta allocation = {
3220772d1f97SMax Reitz                 .offset       = guest_offset,
3221772d1f97SMax Reitz                 .alloc_offset = host_offset,
3222772d1f97SMax Reitz                 .nb_clusters  = nb_clusters,
3223772d1f97SMax Reitz             };
3224772d1f97SMax Reitz             qemu_co_queue_init(&allocation.dependent_requests);
3225772d1f97SMax Reitz 
3226772d1f97SMax Reitz             ret = qcow2_alloc_cluster_link_l2(bs, &allocation);
3227772d1f97SMax Reitz             if (ret < 0) {
3228772d1f97SMax Reitz                 error_setg_errno(errp, -ret, "Failed to update L2 tables");
3229772d1f97SMax Reitz                 qcow2_free_clusters(bs, host_offset,
3230772d1f97SMax Reitz                                     nb_new_data_clusters * s->cluster_size,
3231772d1f97SMax Reitz                                     QCOW2_DISCARD_OTHER);
3232772d1f97SMax Reitz                 return ret;
3233772d1f97SMax Reitz             }
3234772d1f97SMax Reitz 
3235772d1f97SMax Reitz             guest_offset += nb_clusters * s->cluster_size;
3236772d1f97SMax Reitz             host_offset += nb_clusters * s->cluster_size;
3237772d1f97SMax Reitz             nb_new_data_clusters -= nb_clusters;
3238772d1f97SMax Reitz         }
3239772d1f97SMax Reitz         break;
3240772d1f97SMax Reitz     }
3241772d1f97SMax Reitz 
324295b98f34SMax Reitz     default:
324395b98f34SMax Reitz         g_assert_not_reached();
324495b98f34SMax Reitz     }
324595b98f34SMax Reitz 
324695b98f34SMax Reitz     if (prealloc != PREALLOC_MODE_OFF) {
324795b98f34SMax Reitz         /* Flush metadata before actually changing the image size */
324895b98f34SMax Reitz         ret = bdrv_flush(bs);
324995b98f34SMax Reitz         if (ret < 0) {
325095b98f34SMax Reitz             error_setg_errno(errp, -ret,
325195b98f34SMax Reitz                              "Failed to flush the preallocated area to disk");
325295b98f34SMax Reitz             return ret;
325395b98f34SMax Reitz         }
325495b98f34SMax Reitz     }
325595b98f34SMax Reitz 
3256419b19d9SStefan Hajnoczi     /* write updated header.size */
3257419b19d9SStefan Hajnoczi     offset = cpu_to_be64(offset);
3258d9ca2ea2SKevin Wolf     ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, size),
3259419b19d9SStefan Hajnoczi                            &offset, sizeof(uint64_t));
3260419b19d9SStefan Hajnoczi     if (ret < 0) {
3261f59adb32SMax Reitz         error_setg_errno(errp, -ret, "Failed to update the image size");
3262419b19d9SStefan Hajnoczi         return ret;
3263419b19d9SStefan Hajnoczi     }
3264419b19d9SStefan Hajnoczi 
3265419b19d9SStefan Hajnoczi     s->l1_vm_state_index = new_l1_size;
3266419b19d9SStefan Hajnoczi     return 0;
3267419b19d9SStefan Hajnoczi }
3268419b19d9SStefan Hajnoczi 
326920d97356SBlue Swirl /* XXX: put compressed sectors first, then all the cluster aligned
327020d97356SBlue Swirl    tables to avoid losing bytes in alignment */
3271fcccefc5SPavel Butsykin static coroutine_fn int
3272fcccefc5SPavel Butsykin qcow2_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset,
3273fcccefc5SPavel Butsykin                             uint64_t bytes, QEMUIOVector *qiov)
327420d97356SBlue Swirl {
3275ff99129aSKevin Wolf     BDRVQcow2State *s = bs->opaque;
3276fcccefc5SPavel Butsykin     QEMUIOVector hd_qiov;
3277fcccefc5SPavel Butsykin     struct iovec iov;
327820d97356SBlue Swirl     z_stream strm;
327920d97356SBlue Swirl     int ret, out_len;
3280fcccefc5SPavel Butsykin     uint8_t *buf, *out_buf;
3281d0d5d0e3SEric Blake     int64_t cluster_offset;
328220d97356SBlue Swirl 
3283fcccefc5SPavel Butsykin     if (bytes == 0) {
328420d97356SBlue Swirl         /* align end of file to a sector boundary to ease reading with
328520d97356SBlue Swirl            sector based I/Os */
32869a4f4c31SKevin Wolf         cluster_offset = bdrv_getlength(bs->file->bs);
3287d0d5d0e3SEric Blake         if (cluster_offset < 0) {
3288d0d5d0e3SEric Blake             return cluster_offset;
3289d0d5d0e3SEric Blake         }
32907ea37c30SMax Reitz         return bdrv_truncate(bs->file, cluster_offset, PREALLOC_MODE_OFF, NULL);
329120d97356SBlue Swirl     }
329220d97356SBlue Swirl 
3293fcccefc5SPavel Butsykin     buf = qemu_blockalign(bs, s->cluster_size);
3294a2c0ca6fSPavel Butsykin     if (bytes != s->cluster_size) {
3295a2c0ca6fSPavel Butsykin         if (bytes > s->cluster_size ||
3296a2c0ca6fSPavel Butsykin             offset + bytes != bs->total_sectors << BDRV_SECTOR_BITS)
3297a2c0ca6fSPavel Butsykin         {
3298a2c0ca6fSPavel Butsykin             qemu_vfree(buf);
3299a2c0ca6fSPavel Butsykin             return -EINVAL;
3300a2c0ca6fSPavel Butsykin         }
3301a2c0ca6fSPavel Butsykin         /* Zero-pad last write if image size is not cluster aligned */
3302a2c0ca6fSPavel Butsykin         memset(buf + bytes, 0, s->cluster_size - bytes);
3303a2c0ca6fSPavel Butsykin     }
33048b2bd093SPavel Butsykin     qemu_iovec_to_buf(qiov, 0, buf, bytes);
330520d97356SBlue Swirl 
3306ebf7bba0SVladimir Sementsov-Ogievskiy     out_buf = g_malloc(s->cluster_size);
330720d97356SBlue Swirl 
330820d97356SBlue Swirl     /* best compression, small window, no zlib header */
330920d97356SBlue Swirl     memset(&strm, 0, sizeof(strm));
331020d97356SBlue Swirl     ret = deflateInit2(&strm, Z_DEFAULT_COMPRESSION,
331120d97356SBlue Swirl                        Z_DEFLATED, -12,
331220d97356SBlue Swirl                        9, Z_DEFAULT_STRATEGY);
331320d97356SBlue Swirl     if (ret != 0) {
33148f1efd00SKevin Wolf         ret = -EINVAL;
33158f1efd00SKevin Wolf         goto fail;
331620d97356SBlue Swirl     }
331720d97356SBlue Swirl 
331820d97356SBlue Swirl     strm.avail_in = s->cluster_size;
331920d97356SBlue Swirl     strm.next_in = (uint8_t *)buf;
332020d97356SBlue Swirl     strm.avail_out = s->cluster_size;
332120d97356SBlue Swirl     strm.next_out = out_buf;
332220d97356SBlue Swirl 
332320d97356SBlue Swirl     ret = deflate(&strm, Z_FINISH);
332420d97356SBlue Swirl     if (ret != Z_STREAM_END && ret != Z_OK) {
332520d97356SBlue Swirl         deflateEnd(&strm);
33268f1efd00SKevin Wolf         ret = -EINVAL;
33278f1efd00SKevin Wolf         goto fail;
332820d97356SBlue Swirl     }
332920d97356SBlue Swirl     out_len = strm.next_out - out_buf;
333020d97356SBlue Swirl 
333120d97356SBlue Swirl     deflateEnd(&strm);
333220d97356SBlue Swirl 
333320d97356SBlue Swirl     if (ret != Z_STREAM_END || out_len >= s->cluster_size) {
333420d97356SBlue Swirl         /* could not compress: write normal cluster */
3335fcccefc5SPavel Butsykin         ret = qcow2_co_pwritev(bs, offset, bytes, qiov, 0);
33368f1efd00SKevin Wolf         if (ret < 0) {
33378f1efd00SKevin Wolf             goto fail;
33388f1efd00SKevin Wolf         }
3339fcccefc5SPavel Butsykin         goto success;
3340fcccefc5SPavel Butsykin     }
3341fcccefc5SPavel Butsykin 
3342fcccefc5SPavel Butsykin     qemu_co_mutex_lock(&s->lock);
3343fcccefc5SPavel Butsykin     cluster_offset =
3344fcccefc5SPavel Butsykin         qcow2_alloc_compressed_cluster_offset(bs, offset, out_len);
33458f1efd00SKevin Wolf     if (!cluster_offset) {
3346fcccefc5SPavel Butsykin         qemu_co_mutex_unlock(&s->lock);
33478f1efd00SKevin Wolf         ret = -EIO;
33488f1efd00SKevin Wolf         goto fail;
33498f1efd00SKevin Wolf     }
335020d97356SBlue Swirl     cluster_offset &= s->cluster_offset_mask;
3351cf93980eSMax Reitz 
3352231bb267SMax Reitz     ret = qcow2_pre_write_overlap_check(bs, 0, cluster_offset, out_len);
3353fcccefc5SPavel Butsykin     qemu_co_mutex_unlock(&s->lock);
3354cf93980eSMax Reitz     if (ret < 0) {
3355cf93980eSMax Reitz         goto fail;
3356cf93980eSMax Reitz     }
3357cf93980eSMax Reitz 
3358fcccefc5SPavel Butsykin     iov = (struct iovec) {
3359fcccefc5SPavel Butsykin         .iov_base   = out_buf,
3360fcccefc5SPavel Butsykin         .iov_len    = out_len,
3361fcccefc5SPavel Butsykin     };
3362fcccefc5SPavel Butsykin     qemu_iovec_init_external(&hd_qiov, &iov, 1);
3363fcccefc5SPavel Butsykin 
336466f82ceeSKevin Wolf     BLKDBG_EVENT(bs->file, BLKDBG_WRITE_COMPRESSED);
3365fcccefc5SPavel Butsykin     ret = bdrv_co_pwritev(bs->file, cluster_offset, out_len, &hd_qiov, 0);
33668f1efd00SKevin Wolf     if (ret < 0) {
33678f1efd00SKevin Wolf         goto fail;
336820d97356SBlue Swirl     }
3369fcccefc5SPavel Butsykin success:
33708f1efd00SKevin Wolf     ret = 0;
33718f1efd00SKevin Wolf fail:
3372fcccefc5SPavel Butsykin     qemu_vfree(buf);
33737267c094SAnthony Liguori     g_free(out_buf);
33748f1efd00SKevin Wolf     return ret;
337520d97356SBlue Swirl }
337620d97356SBlue Swirl 
337794054183SMax Reitz static int make_completely_empty(BlockDriverState *bs)
337894054183SMax Reitz {
3379ff99129aSKevin Wolf     BDRVQcow2State *s = bs->opaque;
3380ed3d2ec9SMax Reitz     Error *local_err = NULL;
338194054183SMax Reitz     int ret, l1_clusters;
338294054183SMax Reitz     int64_t offset;
338394054183SMax Reitz     uint64_t *new_reftable = NULL;
338494054183SMax Reitz     uint64_t rt_entry, l1_size2;
338594054183SMax Reitz     struct {
338694054183SMax Reitz         uint64_t l1_offset;
338794054183SMax Reitz         uint64_t reftable_offset;
338894054183SMax Reitz         uint32_t reftable_clusters;
338994054183SMax Reitz     } QEMU_PACKED l1_ofs_rt_ofs_cls;
339094054183SMax Reitz 
339194054183SMax Reitz     ret = qcow2_cache_empty(bs, s->l2_table_cache);
339294054183SMax Reitz     if (ret < 0) {
339394054183SMax Reitz         goto fail;
339494054183SMax Reitz     }
339594054183SMax Reitz 
339694054183SMax Reitz     ret = qcow2_cache_empty(bs, s->refcount_block_cache);
339794054183SMax Reitz     if (ret < 0) {
339894054183SMax Reitz         goto fail;
339994054183SMax Reitz     }
340094054183SMax Reitz 
340194054183SMax Reitz     /* Refcounts will be broken utterly */
340294054183SMax Reitz     ret = qcow2_mark_dirty(bs);
340394054183SMax Reitz     if (ret < 0) {
340494054183SMax Reitz         goto fail;
340594054183SMax Reitz     }
340694054183SMax Reitz 
340794054183SMax Reitz     BLKDBG_EVENT(bs->file, BLKDBG_L1_UPDATE);
340894054183SMax Reitz 
340994054183SMax Reitz     l1_clusters = DIV_ROUND_UP(s->l1_size, s->cluster_size / sizeof(uint64_t));
341094054183SMax Reitz     l1_size2 = (uint64_t)s->l1_size * sizeof(uint64_t);
341194054183SMax Reitz 
341294054183SMax Reitz     /* After this call, neither the in-memory nor the on-disk refcount
341394054183SMax Reitz      * information accurately describe the actual references */
341494054183SMax Reitz 
3415720ff280SKevin Wolf     ret = bdrv_pwrite_zeroes(bs->file, s->l1_table_offset,
341674021bc4SEric Blake                              l1_clusters * s->cluster_size, 0);
341794054183SMax Reitz     if (ret < 0) {
341894054183SMax Reitz         goto fail_broken_refcounts;
341994054183SMax Reitz     }
342094054183SMax Reitz     memset(s->l1_table, 0, l1_size2);
342194054183SMax Reitz 
342294054183SMax Reitz     BLKDBG_EVENT(bs->file, BLKDBG_EMPTY_IMAGE_PREPARE);
342394054183SMax Reitz 
342494054183SMax Reitz     /* Overwrite enough clusters at the beginning of the sectors to place
342594054183SMax Reitz      * the refcount table, a refcount block and the L1 table in; this may
342694054183SMax Reitz      * overwrite parts of the existing refcount and L1 table, which is not
342794054183SMax Reitz      * an issue because the dirty flag is set, complete data loss is in fact
342894054183SMax Reitz      * desired and partial data loss is consequently fine as well */
3429720ff280SKevin Wolf     ret = bdrv_pwrite_zeroes(bs->file, s->cluster_size,
343074021bc4SEric Blake                              (2 + l1_clusters) * s->cluster_size, 0);
343194054183SMax Reitz     /* This call (even if it failed overall) may have overwritten on-disk
343294054183SMax Reitz      * refcount structures; in that case, the in-memory refcount information
343394054183SMax Reitz      * will probably differ from the on-disk information which makes the BDS
343494054183SMax Reitz      * unusable */
343594054183SMax Reitz     if (ret < 0) {
343694054183SMax Reitz         goto fail_broken_refcounts;
343794054183SMax Reitz     }
343894054183SMax Reitz 
343994054183SMax Reitz     BLKDBG_EVENT(bs->file, BLKDBG_L1_UPDATE);
344094054183SMax Reitz     BLKDBG_EVENT(bs->file, BLKDBG_REFTABLE_UPDATE);
344194054183SMax Reitz 
344294054183SMax Reitz     /* "Create" an empty reftable (one cluster) directly after the image
344394054183SMax Reitz      * header and an empty L1 table three clusters after the image header;
344494054183SMax Reitz      * the cluster between those two will be used as the first refblock */
3445f1f7a1ddSPeter Maydell     l1_ofs_rt_ofs_cls.l1_offset = cpu_to_be64(3 * s->cluster_size);
3446f1f7a1ddSPeter Maydell     l1_ofs_rt_ofs_cls.reftable_offset = cpu_to_be64(s->cluster_size);
3447f1f7a1ddSPeter Maydell     l1_ofs_rt_ofs_cls.reftable_clusters = cpu_to_be32(1);
3448d9ca2ea2SKevin Wolf     ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, l1_table_offset),
344994054183SMax Reitz                            &l1_ofs_rt_ofs_cls, sizeof(l1_ofs_rt_ofs_cls));
345094054183SMax Reitz     if (ret < 0) {
345194054183SMax Reitz         goto fail_broken_refcounts;
345294054183SMax Reitz     }
345394054183SMax Reitz 
345494054183SMax Reitz     s->l1_table_offset = 3 * s->cluster_size;
345594054183SMax Reitz 
345694054183SMax Reitz     new_reftable = g_try_new0(uint64_t, s->cluster_size / sizeof(uint64_t));
345794054183SMax Reitz     if (!new_reftable) {
345894054183SMax Reitz         ret = -ENOMEM;
345994054183SMax Reitz         goto fail_broken_refcounts;
346094054183SMax Reitz     }
346194054183SMax Reitz 
346294054183SMax Reitz     s->refcount_table_offset = s->cluster_size;
346394054183SMax Reitz     s->refcount_table_size   = s->cluster_size / sizeof(uint64_t);
34647061a078SAlberto Garcia     s->max_refcount_table_index = 0;
346594054183SMax Reitz 
346694054183SMax Reitz     g_free(s->refcount_table);
346794054183SMax Reitz     s->refcount_table = new_reftable;
346894054183SMax Reitz     new_reftable = NULL;
346994054183SMax Reitz 
347094054183SMax Reitz     /* Now the in-memory refcount information again corresponds to the on-disk
347194054183SMax Reitz      * information (reftable is empty and no refblocks (the refblock cache is
347294054183SMax Reitz      * empty)); however, this means some clusters (e.g. the image header) are
347394054183SMax Reitz      * referenced, but not refcounted, but the normal qcow2 code assumes that
347494054183SMax Reitz      * the in-memory information is always correct */
347594054183SMax Reitz 
347694054183SMax Reitz     BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC);
347794054183SMax Reitz 
347894054183SMax Reitz     /* Enter the first refblock into the reftable */
347994054183SMax Reitz     rt_entry = cpu_to_be64(2 * s->cluster_size);
3480d9ca2ea2SKevin Wolf     ret = bdrv_pwrite_sync(bs->file, s->cluster_size,
348194054183SMax Reitz                            &rt_entry, sizeof(rt_entry));
348294054183SMax Reitz     if (ret < 0) {
348394054183SMax Reitz         goto fail_broken_refcounts;
348494054183SMax Reitz     }
348594054183SMax Reitz     s->refcount_table[0] = 2 * s->cluster_size;
348694054183SMax Reitz 
348794054183SMax Reitz     s->free_cluster_index = 0;
348894054183SMax Reitz     assert(3 + l1_clusters <= s->refcount_block_size);
348994054183SMax Reitz     offset = qcow2_alloc_clusters(bs, 3 * s->cluster_size + l1_size2);
349094054183SMax Reitz     if (offset < 0) {
349194054183SMax Reitz         ret = offset;
349294054183SMax Reitz         goto fail_broken_refcounts;
349394054183SMax Reitz     } else if (offset > 0) {
349494054183SMax Reitz         error_report("First cluster in emptied image is in use");
349594054183SMax Reitz         abort();
349694054183SMax Reitz     }
349794054183SMax Reitz 
349894054183SMax Reitz     /* Now finally the in-memory information corresponds to the on-disk
349994054183SMax Reitz      * structures and is correct */
350094054183SMax Reitz     ret = qcow2_mark_clean(bs);
350194054183SMax Reitz     if (ret < 0) {
350294054183SMax Reitz         goto fail;
350394054183SMax Reitz     }
350494054183SMax Reitz 
3505ed3d2ec9SMax Reitz     ret = bdrv_truncate(bs->file, (3 + l1_clusters) * s->cluster_size,
35067ea37c30SMax Reitz                         PREALLOC_MODE_OFF, &local_err);
350794054183SMax Reitz     if (ret < 0) {
3508ed3d2ec9SMax Reitz         error_report_err(local_err);
350994054183SMax Reitz         goto fail;
351094054183SMax Reitz     }
351194054183SMax Reitz 
351294054183SMax Reitz     return 0;
351394054183SMax Reitz 
351494054183SMax Reitz fail_broken_refcounts:
351594054183SMax Reitz     /* The BDS is unusable at this point. If we wanted to make it usable, we
351694054183SMax Reitz      * would have to call qcow2_refcount_close(), qcow2_refcount_init(),
351794054183SMax Reitz      * qcow2_check_refcounts(), qcow2_refcount_close() and qcow2_refcount_init()
351894054183SMax Reitz      * again. However, because the functions which could have caused this error
351994054183SMax Reitz      * path to be taken are used by those functions as well, it's very likely
352094054183SMax Reitz      * that that sequence will fail as well. Therefore, just eject the BDS. */
352194054183SMax Reitz     bs->drv = NULL;
352294054183SMax Reitz 
352394054183SMax Reitz fail:
352494054183SMax Reitz     g_free(new_reftable);
352594054183SMax Reitz     return ret;
352694054183SMax Reitz }
352794054183SMax Reitz 
3528491d27e2SMax Reitz static int qcow2_make_empty(BlockDriverState *bs)
3529491d27e2SMax Reitz {
3530ff99129aSKevin Wolf     BDRVQcow2State *s = bs->opaque;
3531d2cb36afSEric Blake     uint64_t offset, end_offset;
3532d2cb36afSEric Blake     int step = QEMU_ALIGN_DOWN(INT_MAX, s->cluster_size);
353394054183SMax Reitz     int l1_clusters, ret = 0;
3534491d27e2SMax Reitz 
353594054183SMax Reitz     l1_clusters = DIV_ROUND_UP(s->l1_size, s->cluster_size / sizeof(uint64_t));
353694054183SMax Reitz 
353794054183SMax Reitz     if (s->qcow_version >= 3 && !s->snapshots &&
353894054183SMax Reitz         3 + l1_clusters <= s->refcount_block_size) {
353994054183SMax Reitz         /* The following function only works for qcow2 v3 images (it requires
354094054183SMax Reitz          * the dirty flag) and only as long as there are no snapshots (because
354194054183SMax Reitz          * it completely empties the image). Furthermore, the L1 table and three
354294054183SMax Reitz          * additional clusters (image header, refcount table, one refcount
354394054183SMax Reitz          * block) have to fit inside one refcount block. */
354494054183SMax Reitz         return make_completely_empty(bs);
354594054183SMax Reitz     }
354694054183SMax Reitz 
354794054183SMax Reitz     /* This fallback code simply discards every active cluster; this is slow,
354894054183SMax Reitz      * but works in all cases */
3549d2cb36afSEric Blake     end_offset = bs->total_sectors * BDRV_SECTOR_SIZE;
3550d2cb36afSEric Blake     for (offset = 0; offset < end_offset; offset += step) {
3551491d27e2SMax Reitz         /* As this function is generally used after committing an external
3552491d27e2SMax Reitz          * snapshot, QCOW2_DISCARD_SNAPSHOT seems appropriate. Also, the
3553491d27e2SMax Reitz          * default action for this kind of discard is to pass the discard,
3554491d27e2SMax Reitz          * which will ideally result in an actually smaller image file, as
3555491d27e2SMax Reitz          * is probably desired. */
3556d2cb36afSEric Blake         ret = qcow2_cluster_discard(bs, offset, MIN(step, end_offset - offset),
3557491d27e2SMax Reitz                                     QCOW2_DISCARD_SNAPSHOT, true);
3558491d27e2SMax Reitz         if (ret < 0) {
3559491d27e2SMax Reitz             break;
3560491d27e2SMax Reitz         }
3561491d27e2SMax Reitz     }
3562491d27e2SMax Reitz 
3563491d27e2SMax Reitz     return ret;
3564491d27e2SMax Reitz }
3565491d27e2SMax Reitz 
3566a968168cSDong Xu Wang static coroutine_fn int qcow2_co_flush_to_os(BlockDriverState *bs)
356720d97356SBlue Swirl {
3568ff99129aSKevin Wolf     BDRVQcow2State *s = bs->opaque;
356929c1a730SKevin Wolf     int ret;
357029c1a730SKevin Wolf 
35718b94ff85SPaolo Bonzini     qemu_co_mutex_lock(&s->lock);
3572f3c3b87dSDenis V. Lunev     ret = qcow2_cache_write(bs, s->l2_table_cache);
357329c1a730SKevin Wolf     if (ret < 0) {
3574c95de7e2SDong Xu Wang         qemu_co_mutex_unlock(&s->lock);
35758b94ff85SPaolo Bonzini         return ret;
357629c1a730SKevin Wolf     }
357729c1a730SKevin Wolf 
3578bfe8043eSStefan Hajnoczi     if (qcow2_need_accurate_refcounts(s)) {
3579f3c3b87dSDenis V. Lunev         ret = qcow2_cache_write(bs, s->refcount_block_cache);
358029c1a730SKevin Wolf         if (ret < 0) {
3581c95de7e2SDong Xu Wang             qemu_co_mutex_unlock(&s->lock);
35828b94ff85SPaolo Bonzini             return ret;
358329c1a730SKevin Wolf         }
3584bfe8043eSStefan Hajnoczi     }
35858b94ff85SPaolo Bonzini     qemu_co_mutex_unlock(&s->lock);
358629c1a730SKevin Wolf 
3587eb489bb1SKevin Wolf     return 0;
3588eb489bb1SKevin Wolf }
3589eb489bb1SKevin Wolf 
3590c501c352SStefan Hajnoczi static BlockMeasureInfo *qcow2_measure(QemuOpts *opts, BlockDriverState *in_bs,
3591c501c352SStefan Hajnoczi                                        Error **errp)
3592c501c352SStefan Hajnoczi {
3593c501c352SStefan Hajnoczi     Error *local_err = NULL;
3594c501c352SStefan Hajnoczi     BlockMeasureInfo *info;
3595c501c352SStefan Hajnoczi     uint64_t required = 0; /* bytes that contribute to required size */
3596c501c352SStefan Hajnoczi     uint64_t virtual_size; /* disk size as seen by guest */
3597c501c352SStefan Hajnoczi     uint64_t refcount_bits;
3598c501c352SStefan Hajnoczi     uint64_t l2_tables;
3599c501c352SStefan Hajnoczi     size_t cluster_size;
3600c501c352SStefan Hajnoczi     int version;
3601c501c352SStefan Hajnoczi     char *optstr;
3602c501c352SStefan Hajnoczi     PreallocMode prealloc;
3603c501c352SStefan Hajnoczi     bool has_backing_file;
3604c501c352SStefan Hajnoczi 
3605c501c352SStefan Hajnoczi     /* Parse image creation options */
3606c501c352SStefan Hajnoczi     cluster_size = qcow2_opt_get_cluster_size_del(opts, &local_err);
3607c501c352SStefan Hajnoczi     if (local_err) {
3608c501c352SStefan Hajnoczi         goto err;
3609c501c352SStefan Hajnoczi     }
3610c501c352SStefan Hajnoczi 
3611c501c352SStefan Hajnoczi     version = qcow2_opt_get_version_del(opts, &local_err);
3612c501c352SStefan Hajnoczi     if (local_err) {
3613c501c352SStefan Hajnoczi         goto err;
3614c501c352SStefan Hajnoczi     }
3615c501c352SStefan Hajnoczi 
3616c501c352SStefan Hajnoczi     refcount_bits = qcow2_opt_get_refcount_bits_del(opts, version, &local_err);
3617c501c352SStefan Hajnoczi     if (local_err) {
3618c501c352SStefan Hajnoczi         goto err;
3619c501c352SStefan Hajnoczi     }
3620c501c352SStefan Hajnoczi 
3621c501c352SStefan Hajnoczi     optstr = qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC);
3622c501c352SStefan Hajnoczi     prealloc = qapi_enum_parse(PreallocMode_lookup, optstr,
3623c501c352SStefan Hajnoczi                                PREALLOC_MODE__MAX, PREALLOC_MODE_OFF,
3624c501c352SStefan Hajnoczi                                &local_err);
3625c501c352SStefan Hajnoczi     g_free(optstr);
3626c501c352SStefan Hajnoczi     if (local_err) {
3627c501c352SStefan Hajnoczi         goto err;
3628c501c352SStefan Hajnoczi     }
3629c501c352SStefan Hajnoczi 
3630c501c352SStefan Hajnoczi     optstr = qemu_opt_get_del(opts, BLOCK_OPT_BACKING_FILE);
3631c501c352SStefan Hajnoczi     has_backing_file = !!optstr;
3632c501c352SStefan Hajnoczi     g_free(optstr);
3633c501c352SStefan Hajnoczi 
3634c501c352SStefan Hajnoczi     virtual_size = align_offset(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
3635c501c352SStefan Hajnoczi                                 cluster_size);
3636c501c352SStefan Hajnoczi 
3637c501c352SStefan Hajnoczi     /* Check that virtual disk size is valid */
3638c501c352SStefan Hajnoczi     l2_tables = DIV_ROUND_UP(virtual_size / cluster_size,
3639c501c352SStefan Hajnoczi                              cluster_size / sizeof(uint64_t));
3640c501c352SStefan Hajnoczi     if (l2_tables * sizeof(uint64_t) > QCOW_MAX_L1_SIZE) {
3641c501c352SStefan Hajnoczi         error_setg(&local_err, "The image size is too large "
3642c501c352SStefan Hajnoczi                                "(try using a larger cluster size)");
3643c501c352SStefan Hajnoczi         goto err;
3644c501c352SStefan Hajnoczi     }
3645c501c352SStefan Hajnoczi 
3646c501c352SStefan Hajnoczi     /* Account for input image */
3647c501c352SStefan Hajnoczi     if (in_bs) {
3648c501c352SStefan Hajnoczi         int64_t ssize = bdrv_getlength(in_bs);
3649c501c352SStefan Hajnoczi         if (ssize < 0) {
3650c501c352SStefan Hajnoczi             error_setg_errno(&local_err, -ssize,
3651c501c352SStefan Hajnoczi                              "Unable to get image virtual_size");
3652c501c352SStefan Hajnoczi             goto err;
3653c501c352SStefan Hajnoczi         }
3654c501c352SStefan Hajnoczi 
3655c501c352SStefan Hajnoczi         virtual_size = align_offset(ssize, cluster_size);
3656c501c352SStefan Hajnoczi 
3657c501c352SStefan Hajnoczi         if (has_backing_file) {
3658c501c352SStefan Hajnoczi             /* We don't how much of the backing chain is shared by the input
3659c501c352SStefan Hajnoczi              * image and the new image file.  In the worst case the new image's
3660c501c352SStefan Hajnoczi              * backing file has nothing in common with the input image.  Be
3661c501c352SStefan Hajnoczi              * conservative and assume all clusters need to be written.
3662c501c352SStefan Hajnoczi              */
3663c501c352SStefan Hajnoczi             required = virtual_size;
3664c501c352SStefan Hajnoczi         } else {
3665c501c352SStefan Hajnoczi             int cluster_sectors = cluster_size / BDRV_SECTOR_SIZE;
3666c501c352SStefan Hajnoczi             int64_t sector_num;
3667c501c352SStefan Hajnoczi             int pnum = 0;
3668c501c352SStefan Hajnoczi 
3669c501c352SStefan Hajnoczi             for (sector_num = 0;
3670c501c352SStefan Hajnoczi                  sector_num < ssize / BDRV_SECTOR_SIZE;
3671c501c352SStefan Hajnoczi                  sector_num += pnum) {
367224bae02bSEric Blake                 int nb_sectors = MIN(ssize / BDRV_SECTOR_SIZE - sector_num,
367324bae02bSEric Blake                                      BDRV_REQUEST_MAX_SECTORS);
3674c501c352SStefan Hajnoczi                 BlockDriverState *file;
3675c501c352SStefan Hajnoczi                 int64_t ret;
3676c501c352SStefan Hajnoczi 
3677c501c352SStefan Hajnoczi                 ret = bdrv_get_block_status_above(in_bs, NULL,
3678c501c352SStefan Hajnoczi                                                   sector_num, nb_sectors,
3679c501c352SStefan Hajnoczi                                                   &pnum, &file);
3680c501c352SStefan Hajnoczi                 if (ret < 0) {
3681c501c352SStefan Hajnoczi                     error_setg_errno(&local_err, -ret,
3682c501c352SStefan Hajnoczi                                      "Unable to get block status");
3683c501c352SStefan Hajnoczi                     goto err;
3684c501c352SStefan Hajnoczi                 }
3685c501c352SStefan Hajnoczi 
3686c501c352SStefan Hajnoczi                 if (ret & BDRV_BLOCK_ZERO) {
3687c501c352SStefan Hajnoczi                     /* Skip zero regions (safe with no backing file) */
3688c501c352SStefan Hajnoczi                 } else if ((ret & (BDRV_BLOCK_DATA | BDRV_BLOCK_ALLOCATED)) ==
3689c501c352SStefan Hajnoczi                            (BDRV_BLOCK_DATA | BDRV_BLOCK_ALLOCATED)) {
3690c501c352SStefan Hajnoczi                     /* Extend pnum to end of cluster for next iteration */
3691c501c352SStefan Hajnoczi                     pnum = ROUND_UP(sector_num + pnum, cluster_sectors) -
3692c501c352SStefan Hajnoczi                            sector_num;
3693c501c352SStefan Hajnoczi 
3694c501c352SStefan Hajnoczi                     /* Count clusters we've seen */
3695c501c352SStefan Hajnoczi                     required += (sector_num % cluster_sectors + pnum) *
3696c501c352SStefan Hajnoczi                                 BDRV_SECTOR_SIZE;
3697c501c352SStefan Hajnoczi                 }
3698c501c352SStefan Hajnoczi             }
3699c501c352SStefan Hajnoczi         }
3700c501c352SStefan Hajnoczi     }
3701c501c352SStefan Hajnoczi 
3702c501c352SStefan Hajnoczi     /* Take into account preallocation.  Nothing special is needed for
3703c501c352SStefan Hajnoczi      * PREALLOC_MODE_METADATA since metadata is always counted.
3704c501c352SStefan Hajnoczi      */
3705c501c352SStefan Hajnoczi     if (prealloc == PREALLOC_MODE_FULL || prealloc == PREALLOC_MODE_FALLOC) {
3706c501c352SStefan Hajnoczi         required = virtual_size;
3707c501c352SStefan Hajnoczi     }
3708c501c352SStefan Hajnoczi 
3709c501c352SStefan Hajnoczi     info = g_new(BlockMeasureInfo, 1);
3710c501c352SStefan Hajnoczi     info->fully_allocated =
3711c501c352SStefan Hajnoczi         qcow2_calc_prealloc_size(virtual_size, cluster_size,
3712c501c352SStefan Hajnoczi                                  ctz32(refcount_bits));
3713c501c352SStefan Hajnoczi 
3714c501c352SStefan Hajnoczi     /* Remove data clusters that are not required.  This overestimates the
3715c501c352SStefan Hajnoczi      * required size because metadata needed for the fully allocated file is
3716c501c352SStefan Hajnoczi      * still counted.
3717c501c352SStefan Hajnoczi      */
3718c501c352SStefan Hajnoczi     info->required = info->fully_allocated - virtual_size + required;
3719c501c352SStefan Hajnoczi     return info;
3720c501c352SStefan Hajnoczi 
3721c501c352SStefan Hajnoczi err:
3722c501c352SStefan Hajnoczi     error_propagate(errp, local_err);
3723c501c352SStefan Hajnoczi     return NULL;
3724c501c352SStefan Hajnoczi }
3725c501c352SStefan Hajnoczi 
37267c80ab3fSJes Sorensen static int qcow2_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
372720d97356SBlue Swirl {
3728ff99129aSKevin Wolf     BDRVQcow2State *s = bs->opaque;
372995de6d70SPaolo Bonzini     bdi->unallocated_blocks_are_zero = true;
373095de6d70SPaolo Bonzini     bdi->can_write_zeroes_with_unmap = (s->qcow_version >= 3);
373120d97356SBlue Swirl     bdi->cluster_size = s->cluster_size;
37327c80ab3fSJes Sorensen     bdi->vm_state_offset = qcow2_vm_state_offset(s);
373320d97356SBlue Swirl     return 0;
373420d97356SBlue Swirl }
373520d97356SBlue Swirl 
373637764dfbSMax Reitz static ImageInfoSpecific *qcow2_get_specific_info(BlockDriverState *bs)
373737764dfbSMax Reitz {
3738ff99129aSKevin Wolf     BDRVQcow2State *s = bs->opaque;
37390a12f6f8SDaniel P. Berrange     ImageInfoSpecific *spec_info;
37400a12f6f8SDaniel P. Berrange     QCryptoBlockInfo *encrypt_info = NULL;
374137764dfbSMax Reitz 
37420a12f6f8SDaniel P. Berrange     if (s->crypto != NULL) {
37430a12f6f8SDaniel P. Berrange         encrypt_info = qcrypto_block_get_info(s->crypto, &error_abort);
37440a12f6f8SDaniel P. Berrange     }
37450a12f6f8SDaniel P. Berrange 
37460a12f6f8SDaniel P. Berrange     spec_info = g_new(ImageInfoSpecific, 1);
374737764dfbSMax Reitz     *spec_info = (ImageInfoSpecific){
37486a8f9661SEric Blake         .type  = IMAGE_INFO_SPECIFIC_KIND_QCOW2,
374932bafa8fSEric Blake         .u.qcow2.data = g_new(ImageInfoSpecificQCow2, 1),
375037764dfbSMax Reitz     };
375137764dfbSMax Reitz     if (s->qcow_version == 2) {
375232bafa8fSEric Blake         *spec_info->u.qcow2.data = (ImageInfoSpecificQCow2){
375337764dfbSMax Reitz             .compat             = g_strdup("0.10"),
37540709c5a1SMax Reitz             .refcount_bits      = s->refcount_bits,
375537764dfbSMax Reitz         };
375637764dfbSMax Reitz     } else if (s->qcow_version == 3) {
375732bafa8fSEric Blake         *spec_info->u.qcow2.data = (ImageInfoSpecificQCow2){
375837764dfbSMax Reitz             .compat             = g_strdup("1.1"),
375937764dfbSMax Reitz             .lazy_refcounts     = s->compatible_features &
376037764dfbSMax Reitz                                   QCOW2_COMPAT_LAZY_REFCOUNTS,
376137764dfbSMax Reitz             .has_lazy_refcounts = true,
37629009b196SMax Reitz             .corrupt            = s->incompatible_features &
37639009b196SMax Reitz                                   QCOW2_INCOMPAT_CORRUPT,
37649009b196SMax Reitz             .has_corrupt        = true,
37650709c5a1SMax Reitz             .refcount_bits      = s->refcount_bits,
376637764dfbSMax Reitz         };
3767b1fc8f93SDenis V. Lunev     } else {
3768b1fc8f93SDenis V. Lunev         /* if this assertion fails, this probably means a new version was
3769b1fc8f93SDenis V. Lunev          * added without having it covered here */
3770b1fc8f93SDenis V. Lunev         assert(false);
377137764dfbSMax Reitz     }
377237764dfbSMax Reitz 
37730a12f6f8SDaniel P. Berrange     if (encrypt_info) {
37740a12f6f8SDaniel P. Berrange         ImageInfoSpecificQCow2Encryption *qencrypt =
37750a12f6f8SDaniel P. Berrange             g_new(ImageInfoSpecificQCow2Encryption, 1);
37760a12f6f8SDaniel P. Berrange         switch (encrypt_info->format) {
37770a12f6f8SDaniel P. Berrange         case Q_CRYPTO_BLOCK_FORMAT_QCOW:
37780a12f6f8SDaniel P. Berrange             qencrypt->format = BLOCKDEV_QCOW2_ENCRYPTION_FORMAT_AES;
37790a12f6f8SDaniel P. Berrange             qencrypt->u.aes = encrypt_info->u.qcow;
37800a12f6f8SDaniel P. Berrange             break;
37810a12f6f8SDaniel P. Berrange         case Q_CRYPTO_BLOCK_FORMAT_LUKS:
37820a12f6f8SDaniel P. Berrange             qencrypt->format = BLOCKDEV_QCOW2_ENCRYPTION_FORMAT_LUKS;
37830a12f6f8SDaniel P. Berrange             qencrypt->u.luks = encrypt_info->u.luks;
37840a12f6f8SDaniel P. Berrange             break;
37850a12f6f8SDaniel P. Berrange         default:
37860a12f6f8SDaniel P. Berrange             abort();
37870a12f6f8SDaniel P. Berrange         }
37880a12f6f8SDaniel P. Berrange         /* Since we did shallow copy above, erase any pointers
37890a12f6f8SDaniel P. Berrange          * in the original info */
37900a12f6f8SDaniel P. Berrange         memset(&encrypt_info->u, 0, sizeof(encrypt_info->u));
37910a12f6f8SDaniel P. Berrange         qapi_free_QCryptoBlockInfo(encrypt_info);
37920a12f6f8SDaniel P. Berrange 
37930a12f6f8SDaniel P. Berrange         spec_info->u.qcow2.data->has_encrypt = true;
37940a12f6f8SDaniel P. Berrange         spec_info->u.qcow2.data->encrypt = qencrypt;
37950a12f6f8SDaniel P. Berrange     }
37960a12f6f8SDaniel P. Berrange 
379737764dfbSMax Reitz     return spec_info;
379837764dfbSMax Reitz }
379937764dfbSMax Reitz 
3800cf8074b3SKevin Wolf static int qcow2_save_vmstate(BlockDriverState *bs, QEMUIOVector *qiov,
3801cf8074b3SKevin Wolf                               int64_t pos)
380220d97356SBlue Swirl {
3803ff99129aSKevin Wolf     BDRVQcow2State *s = bs->opaque;
380420d97356SBlue Swirl 
380566f82ceeSKevin Wolf     BLKDBG_EVENT(bs->file, BLKDBG_VMSTATE_SAVE);
3806734a7758SKevin Wolf     return bs->drv->bdrv_co_pwritev(bs, qcow2_vm_state_offset(s) + pos,
3807734a7758SKevin Wolf                                     qiov->size, qiov, 0);
380820d97356SBlue Swirl }
380920d97356SBlue Swirl 
38105ddda0b8SKevin Wolf static int qcow2_load_vmstate(BlockDriverState *bs, QEMUIOVector *qiov,
38115ddda0b8SKevin Wolf                               int64_t pos)
381220d97356SBlue Swirl {
3813ff99129aSKevin Wolf     BDRVQcow2State *s = bs->opaque;
381420d97356SBlue Swirl 
381566f82ceeSKevin Wolf     BLKDBG_EVENT(bs->file, BLKDBG_VMSTATE_LOAD);
3816734a7758SKevin Wolf     return bs->drv->bdrv_co_preadv(bs, qcow2_vm_state_offset(s) + pos,
3817734a7758SKevin Wolf                                    qiov->size, qiov, 0);
381820d97356SBlue Swirl }
381920d97356SBlue Swirl 
38209296b3edSMax Reitz /*
38219296b3edSMax Reitz  * Downgrades an image's version. To achieve this, any incompatible features
38229296b3edSMax Reitz  * have to be removed.
38239296b3edSMax Reitz  */
38244057a2b2SMax Reitz static int qcow2_downgrade(BlockDriverState *bs, int target_version,
38258b13976dSMax Reitz                            BlockDriverAmendStatusCB *status_cb, void *cb_opaque)
38269296b3edSMax Reitz {
3827ff99129aSKevin Wolf     BDRVQcow2State *s = bs->opaque;
38289296b3edSMax Reitz     int current_version = s->qcow_version;
38299296b3edSMax Reitz     int ret;
38309296b3edSMax Reitz 
38319296b3edSMax Reitz     if (target_version == current_version) {
38329296b3edSMax Reitz         return 0;
38339296b3edSMax Reitz     } else if (target_version > current_version) {
38349296b3edSMax Reitz         return -EINVAL;
38359296b3edSMax Reitz     } else if (target_version != 2) {
38369296b3edSMax Reitz         return -EINVAL;
38379296b3edSMax Reitz     }
38389296b3edSMax Reitz 
38399296b3edSMax Reitz     if (s->refcount_order != 4) {
384061ce55fcSMax Reitz         error_report("compat=0.10 requires refcount_bits=16");
38419296b3edSMax Reitz         return -ENOTSUP;
38429296b3edSMax Reitz     }
38439296b3edSMax Reitz 
38449296b3edSMax Reitz     /* clear incompatible features */
38459296b3edSMax Reitz     if (s->incompatible_features & QCOW2_INCOMPAT_DIRTY) {
38469296b3edSMax Reitz         ret = qcow2_mark_clean(bs);
38479296b3edSMax Reitz         if (ret < 0) {
38489296b3edSMax Reitz             return ret;
38499296b3edSMax Reitz         }
38509296b3edSMax Reitz     }
38519296b3edSMax Reitz 
38529296b3edSMax Reitz     /* with QCOW2_INCOMPAT_CORRUPT, it is pretty much impossible to get here in
38539296b3edSMax Reitz      * the first place; if that happens nonetheless, returning -ENOTSUP is the
38549296b3edSMax Reitz      * best thing to do anyway */
38559296b3edSMax Reitz 
38569296b3edSMax Reitz     if (s->incompatible_features) {
38579296b3edSMax Reitz         return -ENOTSUP;
38589296b3edSMax Reitz     }
38599296b3edSMax Reitz 
38609296b3edSMax Reitz     /* since we can ignore compatible features, we can set them to 0 as well */
38619296b3edSMax Reitz     s->compatible_features = 0;
38629296b3edSMax Reitz     /* if lazy refcounts have been used, they have already been fixed through
38639296b3edSMax Reitz      * clearing the dirty flag */
38649296b3edSMax Reitz 
38659296b3edSMax Reitz     /* clearing autoclear features is trivial */
38669296b3edSMax Reitz     s->autoclear_features = 0;
38679296b3edSMax Reitz 
38688b13976dSMax Reitz     ret = qcow2_expand_zero_clusters(bs, status_cb, cb_opaque);
38699296b3edSMax Reitz     if (ret < 0) {
38709296b3edSMax Reitz         return ret;
38719296b3edSMax Reitz     }
38729296b3edSMax Reitz 
38739296b3edSMax Reitz     s->qcow_version = target_version;
38749296b3edSMax Reitz     ret = qcow2_update_header(bs);
38759296b3edSMax Reitz     if (ret < 0) {
38769296b3edSMax Reitz         s->qcow_version = current_version;
38779296b3edSMax Reitz         return ret;
38789296b3edSMax Reitz     }
38799296b3edSMax Reitz     return 0;
38809296b3edSMax Reitz }
38819296b3edSMax Reitz 
3882c293a809SMax Reitz typedef enum Qcow2AmendOperation {
3883c293a809SMax Reitz     /* This is the value Qcow2AmendHelperCBInfo::last_operation will be
3884c293a809SMax Reitz      * statically initialized to so that the helper CB can discern the first
3885c293a809SMax Reitz      * invocation from an operation change */
3886c293a809SMax Reitz     QCOW2_NO_OPERATION = 0,
3887c293a809SMax Reitz 
388861ce55fcSMax Reitz     QCOW2_CHANGING_REFCOUNT_ORDER,
3889c293a809SMax Reitz     QCOW2_DOWNGRADING,
3890c293a809SMax Reitz } Qcow2AmendOperation;
3891c293a809SMax Reitz 
3892c293a809SMax Reitz typedef struct Qcow2AmendHelperCBInfo {
3893c293a809SMax Reitz     /* The code coordinating the amend operations should only modify
3894c293a809SMax Reitz      * these four fields; the rest will be managed by the CB */
3895c293a809SMax Reitz     BlockDriverAmendStatusCB *original_status_cb;
3896c293a809SMax Reitz     void *original_cb_opaque;
3897c293a809SMax Reitz 
3898c293a809SMax Reitz     Qcow2AmendOperation current_operation;
3899c293a809SMax Reitz 
3900c293a809SMax Reitz     /* Total number of operations to perform (only set once) */
3901c293a809SMax Reitz     int total_operations;
3902c293a809SMax Reitz 
3903c293a809SMax Reitz     /* The following fields are managed by the CB */
3904c293a809SMax Reitz 
3905c293a809SMax Reitz     /* Number of operations completed */
3906c293a809SMax Reitz     int operations_completed;
3907c293a809SMax Reitz 
3908c293a809SMax Reitz     /* Cumulative offset of all completed operations */
3909c293a809SMax Reitz     int64_t offset_completed;
3910c293a809SMax Reitz 
3911c293a809SMax Reitz     Qcow2AmendOperation last_operation;
3912c293a809SMax Reitz     int64_t last_work_size;
3913c293a809SMax Reitz } Qcow2AmendHelperCBInfo;
3914c293a809SMax Reitz 
3915c293a809SMax Reitz static void qcow2_amend_helper_cb(BlockDriverState *bs,
3916c293a809SMax Reitz                                   int64_t operation_offset,
3917c293a809SMax Reitz                                   int64_t operation_work_size, void *opaque)
3918c293a809SMax Reitz {
3919c293a809SMax Reitz     Qcow2AmendHelperCBInfo *info = opaque;
3920c293a809SMax Reitz     int64_t current_work_size;
3921c293a809SMax Reitz     int64_t projected_work_size;
3922c293a809SMax Reitz 
3923c293a809SMax Reitz     if (info->current_operation != info->last_operation) {
3924c293a809SMax Reitz         if (info->last_operation != QCOW2_NO_OPERATION) {
3925c293a809SMax Reitz             info->offset_completed += info->last_work_size;
3926c293a809SMax Reitz             info->operations_completed++;
3927c293a809SMax Reitz         }
3928c293a809SMax Reitz 
3929c293a809SMax Reitz         info->last_operation = info->current_operation;
3930c293a809SMax Reitz     }
3931c293a809SMax Reitz 
3932c293a809SMax Reitz     assert(info->total_operations > 0);
3933c293a809SMax Reitz     assert(info->operations_completed < info->total_operations);
3934c293a809SMax Reitz 
3935c293a809SMax Reitz     info->last_work_size = operation_work_size;
3936c293a809SMax Reitz 
3937c293a809SMax Reitz     current_work_size = info->offset_completed + operation_work_size;
3938c293a809SMax Reitz 
3939c293a809SMax Reitz     /* current_work_size is the total work size for (operations_completed + 1)
3940c293a809SMax Reitz      * operations (which includes this one), so multiply it by the number of
3941c293a809SMax Reitz      * operations not covered and divide it by the number of operations
3942c293a809SMax Reitz      * covered to get a projection for the operations not covered */
3943c293a809SMax Reitz     projected_work_size = current_work_size * (info->total_operations -
3944c293a809SMax Reitz                                                info->operations_completed - 1)
3945c293a809SMax Reitz                                             / (info->operations_completed + 1);
3946c293a809SMax Reitz 
3947c293a809SMax Reitz     info->original_status_cb(bs, info->offset_completed + operation_offset,
3948c293a809SMax Reitz                              current_work_size + projected_work_size,
3949c293a809SMax Reitz                              info->original_cb_opaque);
3950c293a809SMax Reitz }
3951c293a809SMax Reitz 
395277485434SMax Reitz static int qcow2_amend_options(BlockDriverState *bs, QemuOpts *opts,
39538b13976dSMax Reitz                                BlockDriverAmendStatusCB *status_cb,
39548b13976dSMax Reitz                                void *cb_opaque)
39559296b3edSMax Reitz {
3956ff99129aSKevin Wolf     BDRVQcow2State *s = bs->opaque;
39579296b3edSMax Reitz     int old_version = s->qcow_version, new_version = old_version;
39589296b3edSMax Reitz     uint64_t new_size = 0;
39599296b3edSMax Reitz     const char *backing_file = NULL, *backing_format = NULL;
39609296b3edSMax Reitz     bool lazy_refcounts = s->use_lazy_refcounts;
39611bd0e2d1SChunyan Liu     const char *compat = NULL;
39621bd0e2d1SChunyan Liu     uint64_t cluster_size = s->cluster_size;
39631bd0e2d1SChunyan Liu     bool encrypt;
39644652b8f3SDaniel P. Berrange     int encformat;
396561ce55fcSMax Reitz     int refcount_bits = s->refcount_bits;
3966d7086422SKevin Wolf     Error *local_err = NULL;
39679296b3edSMax Reitz     int ret;
39681bd0e2d1SChunyan Liu     QemuOptDesc *desc = opts->list->desc;
3969c293a809SMax Reitz     Qcow2AmendHelperCBInfo helper_cb_info;
39709296b3edSMax Reitz 
39711bd0e2d1SChunyan Liu     while (desc && desc->name) {
39721bd0e2d1SChunyan Liu         if (!qemu_opt_find(opts, desc->name)) {
39739296b3edSMax Reitz             /* only change explicitly defined options */
39741bd0e2d1SChunyan Liu             desc++;
39759296b3edSMax Reitz             continue;
39769296b3edSMax Reitz         }
39779296b3edSMax Reitz 
39788a17b83cSMax Reitz         if (!strcmp(desc->name, BLOCK_OPT_COMPAT_LEVEL)) {
39798a17b83cSMax Reitz             compat = qemu_opt_get(opts, BLOCK_OPT_COMPAT_LEVEL);
39801bd0e2d1SChunyan Liu             if (!compat) {
39819296b3edSMax Reitz                 /* preserve default */
39821bd0e2d1SChunyan Liu             } else if (!strcmp(compat, "0.10")) {
39839296b3edSMax Reitz                 new_version = 2;
39841bd0e2d1SChunyan Liu             } else if (!strcmp(compat, "1.1")) {
39859296b3edSMax Reitz                 new_version = 3;
39869296b3edSMax Reitz             } else {
398729d72431SMax Reitz                 error_report("Unknown compatibility level %s", compat);
39889296b3edSMax Reitz                 return -EINVAL;
39899296b3edSMax Reitz             }
39908a17b83cSMax Reitz         } else if (!strcmp(desc->name, BLOCK_OPT_PREALLOC)) {
399129d72431SMax Reitz             error_report("Cannot change preallocation mode");
39929296b3edSMax Reitz             return -ENOTSUP;
39938a17b83cSMax Reitz         } else if (!strcmp(desc->name, BLOCK_OPT_SIZE)) {
39948a17b83cSMax Reitz             new_size = qemu_opt_get_size(opts, BLOCK_OPT_SIZE, 0);
39958a17b83cSMax Reitz         } else if (!strcmp(desc->name, BLOCK_OPT_BACKING_FILE)) {
39968a17b83cSMax Reitz             backing_file = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
39978a17b83cSMax Reitz         } else if (!strcmp(desc->name, BLOCK_OPT_BACKING_FMT)) {
39988a17b83cSMax Reitz             backing_format = qemu_opt_get(opts, BLOCK_OPT_BACKING_FMT);
39998a17b83cSMax Reitz         } else if (!strcmp(desc->name, BLOCK_OPT_ENCRYPT)) {
40008a17b83cSMax Reitz             encrypt = qemu_opt_get_bool(opts, BLOCK_OPT_ENCRYPT,
4001b25b387fSDaniel P. Berrange                                         !!s->crypto);
4002f6fa64f6SDaniel P. Berrange 
4003b25b387fSDaniel P. Berrange             if (encrypt != !!s->crypto) {
400429d72431SMax Reitz                 error_report("Changing the encryption flag is not supported");
40059296b3edSMax Reitz                 return -ENOTSUP;
40069296b3edSMax Reitz             }
40074652b8f3SDaniel P. Berrange         } else if (!strcmp(desc->name, BLOCK_OPT_ENCRYPT_FORMAT)) {
40084652b8f3SDaniel P. Berrange             encformat = qcow2_crypt_method_from_format(
40094652b8f3SDaniel P. Berrange                 qemu_opt_get(opts, BLOCK_OPT_ENCRYPT_FORMAT));
40104652b8f3SDaniel P. Berrange 
40114652b8f3SDaniel P. Berrange             if (encformat != s->crypt_method_header) {
40124652b8f3SDaniel P. Berrange                 error_report("Changing the encryption format is not supported");
40134652b8f3SDaniel P. Berrange                 return -ENOTSUP;
40144652b8f3SDaniel P. Berrange             }
40158a17b83cSMax Reitz         } else if (!strcmp(desc->name, BLOCK_OPT_CLUSTER_SIZE)) {
40168a17b83cSMax Reitz             cluster_size = qemu_opt_get_size(opts, BLOCK_OPT_CLUSTER_SIZE,
40171bd0e2d1SChunyan Liu                                              cluster_size);
40181bd0e2d1SChunyan Liu             if (cluster_size != s->cluster_size) {
401929d72431SMax Reitz                 error_report("Changing the cluster size is not supported");
40209296b3edSMax Reitz                 return -ENOTSUP;
40219296b3edSMax Reitz             }
40228a17b83cSMax Reitz         } else if (!strcmp(desc->name, BLOCK_OPT_LAZY_REFCOUNTS)) {
40238a17b83cSMax Reitz             lazy_refcounts = qemu_opt_get_bool(opts, BLOCK_OPT_LAZY_REFCOUNTS,
40241bd0e2d1SChunyan Liu                                                lazy_refcounts);
402506d05fa7SMax Reitz         } else if (!strcmp(desc->name, BLOCK_OPT_REFCOUNT_BITS)) {
402661ce55fcSMax Reitz             refcount_bits = qemu_opt_get_number(opts, BLOCK_OPT_REFCOUNT_BITS,
402761ce55fcSMax Reitz                                                 refcount_bits);
402861ce55fcSMax Reitz 
402961ce55fcSMax Reitz             if (refcount_bits <= 0 || refcount_bits > 64 ||
403061ce55fcSMax Reitz                 !is_power_of_2(refcount_bits))
403161ce55fcSMax Reitz             {
403261ce55fcSMax Reitz                 error_report("Refcount width must be a power of two and may "
403361ce55fcSMax Reitz                              "not exceed 64 bits");
403461ce55fcSMax Reitz                 return -EINVAL;
403561ce55fcSMax Reitz             }
40369296b3edSMax Reitz         } else {
4037164e0f89SMax Reitz             /* if this point is reached, this probably means a new option was
40389296b3edSMax Reitz              * added without having it covered here */
4039164e0f89SMax Reitz             abort();
40409296b3edSMax Reitz         }
40411bd0e2d1SChunyan Liu 
40421bd0e2d1SChunyan Liu         desc++;
40439296b3edSMax Reitz     }
40449296b3edSMax Reitz 
4045c293a809SMax Reitz     helper_cb_info = (Qcow2AmendHelperCBInfo){
4046c293a809SMax Reitz         .original_status_cb = status_cb,
4047c293a809SMax Reitz         .original_cb_opaque = cb_opaque,
4048c293a809SMax Reitz         .total_operations = (new_version < old_version)
404961ce55fcSMax Reitz                           + (s->refcount_bits != refcount_bits)
4050c293a809SMax Reitz     };
4051c293a809SMax Reitz 
40521038bbb8SMax Reitz     /* Upgrade first (some features may require compat=1.1) */
40539296b3edSMax Reitz     if (new_version > old_version) {
40549296b3edSMax Reitz         s->qcow_version = new_version;
40559296b3edSMax Reitz         ret = qcow2_update_header(bs);
40569296b3edSMax Reitz         if (ret < 0) {
40579296b3edSMax Reitz             s->qcow_version = old_version;
40589296b3edSMax Reitz             return ret;
40599296b3edSMax Reitz         }
40609296b3edSMax Reitz     }
40619296b3edSMax Reitz 
406261ce55fcSMax Reitz     if (s->refcount_bits != refcount_bits) {
406361ce55fcSMax Reitz         int refcount_order = ctz32(refcount_bits);
406461ce55fcSMax Reitz 
406561ce55fcSMax Reitz         if (new_version < 3 && refcount_bits != 16) {
406661ce55fcSMax Reitz             error_report("Different refcount widths than 16 bits require "
406761ce55fcSMax Reitz                          "compatibility level 1.1 or above (use compat=1.1 or "
406861ce55fcSMax Reitz                          "greater)");
406961ce55fcSMax Reitz             return -EINVAL;
407061ce55fcSMax Reitz         }
407161ce55fcSMax Reitz 
407261ce55fcSMax Reitz         helper_cb_info.current_operation = QCOW2_CHANGING_REFCOUNT_ORDER;
407361ce55fcSMax Reitz         ret = qcow2_change_refcount_order(bs, refcount_order,
407461ce55fcSMax Reitz                                           &qcow2_amend_helper_cb,
4075a7a6a2bfSAlberto Garcia                                           &helper_cb_info, &local_err);
407661ce55fcSMax Reitz         if (ret < 0) {
4077a7a6a2bfSAlberto Garcia             error_report_err(local_err);
407861ce55fcSMax Reitz             return ret;
407961ce55fcSMax Reitz         }
408061ce55fcSMax Reitz     }
408161ce55fcSMax Reitz 
40829296b3edSMax Reitz     if (backing_file || backing_format) {
4083e4603fe1SKevin Wolf         ret = qcow2_change_backing_file(bs,
4084e4603fe1SKevin Wolf                     backing_file ?: s->image_backing_file,
4085e4603fe1SKevin Wolf                     backing_format ?: s->image_backing_format);
40869296b3edSMax Reitz         if (ret < 0) {
40879296b3edSMax Reitz             return ret;
40889296b3edSMax Reitz         }
40899296b3edSMax Reitz     }
40909296b3edSMax Reitz 
40919296b3edSMax Reitz     if (s->use_lazy_refcounts != lazy_refcounts) {
40929296b3edSMax Reitz         if (lazy_refcounts) {
40931038bbb8SMax Reitz             if (new_version < 3) {
409429d72431SMax Reitz                 error_report("Lazy refcounts only supported with compatibility "
409529d72431SMax Reitz                              "level 1.1 and above (use compat=1.1 or greater)");
40969296b3edSMax Reitz                 return -EINVAL;
40979296b3edSMax Reitz             }
40989296b3edSMax Reitz             s->compatible_features |= QCOW2_COMPAT_LAZY_REFCOUNTS;
40999296b3edSMax Reitz             ret = qcow2_update_header(bs);
41009296b3edSMax Reitz             if (ret < 0) {
41019296b3edSMax Reitz                 s->compatible_features &= ~QCOW2_COMPAT_LAZY_REFCOUNTS;
41029296b3edSMax Reitz                 return ret;
41039296b3edSMax Reitz             }
41049296b3edSMax Reitz             s->use_lazy_refcounts = true;
41059296b3edSMax Reitz         } else {
41069296b3edSMax Reitz             /* make image clean first */
41079296b3edSMax Reitz             ret = qcow2_mark_clean(bs);
41089296b3edSMax Reitz             if (ret < 0) {
41099296b3edSMax Reitz                 return ret;
41109296b3edSMax Reitz             }
41119296b3edSMax Reitz             /* now disallow lazy refcounts */
41129296b3edSMax Reitz             s->compatible_features &= ~QCOW2_COMPAT_LAZY_REFCOUNTS;
41139296b3edSMax Reitz             ret = qcow2_update_header(bs);
41149296b3edSMax Reitz             if (ret < 0) {
41159296b3edSMax Reitz                 s->compatible_features |= QCOW2_COMPAT_LAZY_REFCOUNTS;
41169296b3edSMax Reitz                 return ret;
41179296b3edSMax Reitz             }
41189296b3edSMax Reitz             s->use_lazy_refcounts = false;
41199296b3edSMax Reitz         }
41209296b3edSMax Reitz     }
41219296b3edSMax Reitz 
41229296b3edSMax Reitz     if (new_size) {
41236d0eb64dSKevin Wolf         BlockBackend *blk = blk_new(BLK_PERM_RESIZE, BLK_PERM_ALL);
4124d7086422SKevin Wolf         ret = blk_insert_bs(blk, bs, &local_err);
4125d7086422SKevin Wolf         if (ret < 0) {
4126d7086422SKevin Wolf             error_report_err(local_err);
4127d7086422SKevin Wolf             blk_unref(blk);
4128d7086422SKevin Wolf             return ret;
4129d7086422SKevin Wolf         }
4130d7086422SKevin Wolf 
41313a691c50SMax Reitz         ret = blk_truncate(blk, new_size, PREALLOC_MODE_OFF, &local_err);
413270b27f36SKevin Wolf         blk_unref(blk);
41339296b3edSMax Reitz         if (ret < 0) {
4134ed3d2ec9SMax Reitz             error_report_err(local_err);
41359296b3edSMax Reitz             return ret;
41369296b3edSMax Reitz         }
41379296b3edSMax Reitz     }
41389296b3edSMax Reitz 
41391038bbb8SMax Reitz     /* Downgrade last (so unsupported features can be removed before) */
41401038bbb8SMax Reitz     if (new_version < old_version) {
4141c293a809SMax Reitz         helper_cb_info.current_operation = QCOW2_DOWNGRADING;
4142c293a809SMax Reitz         ret = qcow2_downgrade(bs, new_version, &qcow2_amend_helper_cb,
4143c293a809SMax Reitz                               &helper_cb_info);
41441038bbb8SMax Reitz         if (ret < 0) {
41451038bbb8SMax Reitz             return ret;
41461038bbb8SMax Reitz         }
41471038bbb8SMax Reitz     }
41481038bbb8SMax Reitz 
41499296b3edSMax Reitz     return 0;
41509296b3edSMax Reitz }
41519296b3edSMax Reitz 
415285186ebdSMax Reitz /*
415385186ebdSMax Reitz  * If offset or size are negative, respectively, they will not be included in
415485186ebdSMax Reitz  * the BLOCK_IMAGE_CORRUPTED event emitted.
415585186ebdSMax Reitz  * fatal will be ignored for read-only BDS; corruptions found there will always
415685186ebdSMax Reitz  * be considered non-fatal.
415785186ebdSMax Reitz  */
415885186ebdSMax Reitz void qcow2_signal_corruption(BlockDriverState *bs, bool fatal, int64_t offset,
415985186ebdSMax Reitz                              int64_t size, const char *message_format, ...)
416085186ebdSMax Reitz {
4161ff99129aSKevin Wolf     BDRVQcow2State *s = bs->opaque;
4162dc881b44SAlberto Garcia     const char *node_name;
416385186ebdSMax Reitz     char *message;
416485186ebdSMax Reitz     va_list ap;
416585186ebdSMax Reitz 
416685186ebdSMax Reitz     fatal = fatal && !bs->read_only;
416785186ebdSMax Reitz 
416885186ebdSMax Reitz     if (s->signaled_corruption &&
416985186ebdSMax Reitz         (!fatal || (s->incompatible_features & QCOW2_INCOMPAT_CORRUPT)))
417085186ebdSMax Reitz     {
417185186ebdSMax Reitz         return;
417285186ebdSMax Reitz     }
417385186ebdSMax Reitz 
417485186ebdSMax Reitz     va_start(ap, message_format);
417585186ebdSMax Reitz     message = g_strdup_vprintf(message_format, ap);
417685186ebdSMax Reitz     va_end(ap);
417785186ebdSMax Reitz 
417885186ebdSMax Reitz     if (fatal) {
417985186ebdSMax Reitz         fprintf(stderr, "qcow2: Marking image as corrupt: %s; further "
418085186ebdSMax Reitz                 "corruption events will be suppressed\n", message);
418185186ebdSMax Reitz     } else {
418285186ebdSMax Reitz         fprintf(stderr, "qcow2: Image is corrupt: %s; further non-fatal "
418385186ebdSMax Reitz                 "corruption events will be suppressed\n", message);
418485186ebdSMax Reitz     }
418585186ebdSMax Reitz 
4186dc881b44SAlberto Garcia     node_name = bdrv_get_node_name(bs);
4187dc881b44SAlberto Garcia     qapi_event_send_block_image_corrupted(bdrv_get_device_name(bs),
4188dc881b44SAlberto Garcia                                           *node_name != '\0', node_name,
4189dc881b44SAlberto Garcia                                           message, offset >= 0, offset,
4190dc881b44SAlberto Garcia                                           size >= 0, size,
419185186ebdSMax Reitz                                           fatal, &error_abort);
419285186ebdSMax Reitz     g_free(message);
419385186ebdSMax Reitz 
419485186ebdSMax Reitz     if (fatal) {
419585186ebdSMax Reitz         qcow2_mark_corrupt(bs);
419685186ebdSMax Reitz         bs->drv = NULL; /* make BDS unusable */
419785186ebdSMax Reitz     }
419885186ebdSMax Reitz 
419985186ebdSMax Reitz     s->signaled_corruption = true;
420085186ebdSMax Reitz }
420185186ebdSMax Reitz 
42021bd0e2d1SChunyan Liu static QemuOptsList qcow2_create_opts = {
42031bd0e2d1SChunyan Liu     .name = "qcow2-create-opts",
42041bd0e2d1SChunyan Liu     .head = QTAILQ_HEAD_INITIALIZER(qcow2_create_opts.head),
42051bd0e2d1SChunyan Liu     .desc = {
420620d97356SBlue Swirl         {
420720d97356SBlue Swirl             .name = BLOCK_OPT_SIZE,
42081bd0e2d1SChunyan Liu             .type = QEMU_OPT_SIZE,
420920d97356SBlue Swirl             .help = "Virtual disk size"
421020d97356SBlue Swirl         },
421120d97356SBlue Swirl         {
42126744cbabSKevin Wolf             .name = BLOCK_OPT_COMPAT_LEVEL,
42131bd0e2d1SChunyan Liu             .type = QEMU_OPT_STRING,
42146744cbabSKevin Wolf             .help = "Compatibility level (0.10 or 1.1)"
42156744cbabSKevin Wolf         },
42166744cbabSKevin Wolf         {
421720d97356SBlue Swirl             .name = BLOCK_OPT_BACKING_FILE,
42181bd0e2d1SChunyan Liu             .type = QEMU_OPT_STRING,
421920d97356SBlue Swirl             .help = "File name of a base image"
422020d97356SBlue Swirl         },
422120d97356SBlue Swirl         {
422220d97356SBlue Swirl             .name = BLOCK_OPT_BACKING_FMT,
42231bd0e2d1SChunyan Liu             .type = QEMU_OPT_STRING,
422420d97356SBlue Swirl             .help = "Image format of the base image"
422520d97356SBlue Swirl         },
422620d97356SBlue Swirl         {
422720d97356SBlue Swirl             .name = BLOCK_OPT_ENCRYPT,
42281bd0e2d1SChunyan Liu             .type = QEMU_OPT_BOOL,
42290cb8d47bSDaniel P. Berrange             .help = "Encrypt the image with format 'aes'. (Deprecated "
42300cb8d47bSDaniel P. Berrange                     "in favor of " BLOCK_OPT_ENCRYPT_FORMAT "=aes)",
42310cb8d47bSDaniel P. Berrange         },
42320cb8d47bSDaniel P. Berrange         {
42330cb8d47bSDaniel P. Berrange             .name = BLOCK_OPT_ENCRYPT_FORMAT,
42340cb8d47bSDaniel P. Berrange             .type = QEMU_OPT_STRING,
42354652b8f3SDaniel P. Berrange             .help = "Encrypt the image, format choices: 'aes', 'luks'",
423620d97356SBlue Swirl         },
42374652b8f3SDaniel P. Berrange         BLOCK_CRYPTO_OPT_DEF_KEY_SECRET("encrypt.",
42384652b8f3SDaniel P. Berrange             "ID of secret providing qcow AES key or LUKS passphrase"),
42394652b8f3SDaniel P. Berrange         BLOCK_CRYPTO_OPT_DEF_LUKS_CIPHER_ALG("encrypt."),
42404652b8f3SDaniel P. Berrange         BLOCK_CRYPTO_OPT_DEF_LUKS_CIPHER_MODE("encrypt."),
42414652b8f3SDaniel P. Berrange         BLOCK_CRYPTO_OPT_DEF_LUKS_IVGEN_ALG("encrypt."),
42424652b8f3SDaniel P. Berrange         BLOCK_CRYPTO_OPT_DEF_LUKS_IVGEN_HASH_ALG("encrypt."),
42434652b8f3SDaniel P. Berrange         BLOCK_CRYPTO_OPT_DEF_LUKS_HASH_ALG("encrypt."),
42444652b8f3SDaniel P. Berrange         BLOCK_CRYPTO_OPT_DEF_LUKS_ITER_TIME("encrypt."),
424520d97356SBlue Swirl         {
424620d97356SBlue Swirl             .name = BLOCK_OPT_CLUSTER_SIZE,
42471bd0e2d1SChunyan Liu             .type = QEMU_OPT_SIZE,
424899cce9faSKevin Wolf             .help = "qcow2 cluster size",
42491bd0e2d1SChunyan Liu             .def_value_str = stringify(DEFAULT_CLUSTER_SIZE)
425020d97356SBlue Swirl         },
425120d97356SBlue Swirl         {
425220d97356SBlue Swirl             .name = BLOCK_OPT_PREALLOC,
42531bd0e2d1SChunyan Liu             .type = QEMU_OPT_STRING,
42540e4271b7SHu Tao             .help = "Preallocation mode (allowed values: off, metadata, "
42550e4271b7SHu Tao                     "falloc, full)"
425620d97356SBlue Swirl         },
4257bfe8043eSStefan Hajnoczi         {
4258bfe8043eSStefan Hajnoczi             .name = BLOCK_OPT_LAZY_REFCOUNTS,
42591bd0e2d1SChunyan Liu             .type = QEMU_OPT_BOOL,
4260bfe8043eSStefan Hajnoczi             .help = "Postpone refcount updates",
42611bd0e2d1SChunyan Liu             .def_value_str = "off"
4262bfe8043eSStefan Hajnoczi         },
426306d05fa7SMax Reitz         {
426406d05fa7SMax Reitz             .name = BLOCK_OPT_REFCOUNT_BITS,
426506d05fa7SMax Reitz             .type = QEMU_OPT_NUMBER,
426606d05fa7SMax Reitz             .help = "Width of a reference count entry in bits",
426706d05fa7SMax Reitz             .def_value_str = "16"
426806d05fa7SMax Reitz         },
42691bd0e2d1SChunyan Liu         { /* end of list */ }
42701bd0e2d1SChunyan Liu     }
427120d97356SBlue Swirl };
427220d97356SBlue Swirl 
42735f535a94SMax Reitz BlockDriver bdrv_qcow2 = {
427420d97356SBlue Swirl     .format_name        = "qcow2",
4275ff99129aSKevin Wolf     .instance_size      = sizeof(BDRVQcow2State),
42767c80ab3fSJes Sorensen     .bdrv_probe         = qcow2_probe,
42777c80ab3fSJes Sorensen     .bdrv_open          = qcow2_open,
42787c80ab3fSJes Sorensen     .bdrv_close         = qcow2_close,
427921d82ac9SJeff Cody     .bdrv_reopen_prepare  = qcow2_reopen_prepare,
42805b0959a7SKevin Wolf     .bdrv_reopen_commit   = qcow2_reopen_commit,
42815b0959a7SKevin Wolf     .bdrv_reopen_abort    = qcow2_reopen_abort,
42825365f44dSKevin Wolf     .bdrv_join_options    = qcow2_join_options,
4283862f215fSKevin Wolf     .bdrv_child_perm      = bdrv_format_default_perms,
4284c282e1fdSChunyan Liu     .bdrv_create        = qcow2_create,
42853ac21627SPeter Lieven     .bdrv_has_zero_init = bdrv_has_zero_init_1,
4286b6b8a333SPaolo Bonzini     .bdrv_co_get_block_status = qcow2_co_get_block_status,
428720d97356SBlue Swirl 
4288ecfe1863SKevin Wolf     .bdrv_co_preadv         = qcow2_co_preadv,
4289d46a0bb2SKevin Wolf     .bdrv_co_pwritev        = qcow2_co_pwritev,
4290eb489bb1SKevin Wolf     .bdrv_co_flush_to_os    = qcow2_co_flush_to_os,
4291419b19d9SStefan Hajnoczi 
42925544b59fSEric Blake     .bdrv_co_pwrite_zeroes  = qcow2_co_pwrite_zeroes,
429382e8a788SEric Blake     .bdrv_co_pdiscard       = qcow2_co_pdiscard,
4294419b19d9SStefan Hajnoczi     .bdrv_truncate          = qcow2_truncate,
4295fcccefc5SPavel Butsykin     .bdrv_co_pwritev_compressed = qcow2_co_pwritev_compressed,
4296491d27e2SMax Reitz     .bdrv_make_empty        = qcow2_make_empty,
429720d97356SBlue Swirl 
429820d97356SBlue Swirl     .bdrv_snapshot_create   = qcow2_snapshot_create,
429920d97356SBlue Swirl     .bdrv_snapshot_goto     = qcow2_snapshot_goto,
430020d97356SBlue Swirl     .bdrv_snapshot_delete   = qcow2_snapshot_delete,
430120d97356SBlue Swirl     .bdrv_snapshot_list     = qcow2_snapshot_list,
430251ef6727Sedison     .bdrv_snapshot_load_tmp = qcow2_snapshot_load_tmp,
4303c501c352SStefan Hajnoczi     .bdrv_measure           = qcow2_measure,
43047c80ab3fSJes Sorensen     .bdrv_get_info          = qcow2_get_info,
430537764dfbSMax Reitz     .bdrv_get_specific_info = qcow2_get_specific_info,
430620d97356SBlue Swirl 
43077c80ab3fSJes Sorensen     .bdrv_save_vmstate    = qcow2_save_vmstate,
43087c80ab3fSJes Sorensen     .bdrv_load_vmstate    = qcow2_load_vmstate,
430920d97356SBlue Swirl 
43108ee79e70SKevin Wolf     .supports_backing           = true,
431120d97356SBlue Swirl     .bdrv_change_backing_file   = qcow2_change_backing_file,
431220d97356SBlue Swirl 
4313d34682cdSKevin Wolf     .bdrv_refresh_limits        = qcow2_refresh_limits,
431406d9260fSAnthony Liguori     .bdrv_invalidate_cache      = qcow2_invalidate_cache,
4315ec6d8912SKevin Wolf     .bdrv_inactivate            = qcow2_inactivate,
431606d9260fSAnthony Liguori 
43171bd0e2d1SChunyan Liu     .create_opts         = &qcow2_create_opts,
43187c80ab3fSJes Sorensen     .bdrv_check          = qcow2_check,
4319c282e1fdSChunyan Liu     .bdrv_amend_options  = qcow2_amend_options,
4320279621c0SAlberto Garcia 
4321279621c0SAlberto Garcia     .bdrv_detach_aio_context  = qcow2_detach_aio_context,
4322279621c0SAlberto Garcia     .bdrv_attach_aio_context  = qcow2_attach_aio_context,
43231b6b0562SVladimir Sementsov-Ogievskiy 
43241b6b0562SVladimir Sementsov-Ogievskiy     .bdrv_reopen_bitmaps_rw = qcow2_reopen_bitmaps_rw,
4325da0eb242SVladimir Sementsov-Ogievskiy     .bdrv_can_store_new_dirty_bitmap = qcow2_can_store_new_dirty_bitmap,
4326469c71edSVladimir Sementsov-Ogievskiy     .bdrv_remove_persistent_dirty_bitmap = qcow2_remove_persistent_dirty_bitmap,
432720d97356SBlue Swirl };
432820d97356SBlue Swirl 
43295efa9d5aSAnthony Liguori static void bdrv_qcow2_init(void)
43305efa9d5aSAnthony Liguori {
43315efa9d5aSAnthony Liguori     bdrv_register(&bdrv_qcow2);
43325efa9d5aSAnthony Liguori }
43335efa9d5aSAnthony Liguori 
43345efa9d5aSAnthony Liguori block_init(bdrv_qcow2_init);
4335