1 /*
2  * Block driver for the QCOW version 2 format
3  *
4  * Copyright (c) 2004-2006 Fabrice Bellard
5  *
6  * Permission is hereby granted, free of charge, to any person obtaining a copy
7  * of this software and associated documentation files (the "Software"), to deal
8  * in the Software without restriction, including without limitation the rights
9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10  * copies of the Software, and to permit persons to whom the Software is
11  * furnished to do so, subject to the following conditions:
12  *
13  * The above copyright notice and this permission notice shall be included in
14  * all copies or substantial portions of the Software.
15  *
16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22  * THE SOFTWARE.
23  */
24 
25 #include "qemu/osdep.h"
26 
27 #include "block/qdict.h"
28 #include "sysemu/block-backend.h"
29 #include "qemu/main-loop.h"
30 #include "qemu/module.h"
31 #include "qcow2.h"
32 #include "qemu/error-report.h"
33 #include "qapi/error.h"
34 #include "qapi/qapi-events-block-core.h"
35 #include "qapi/qmp/qdict.h"
36 #include "qapi/qmp/qstring.h"
37 #include "trace.h"
38 #include "qemu/option_int.h"
39 #include "qemu/cutils.h"
40 #include "qemu/bswap.h"
41 #include "qapi/qobject-input-visitor.h"
42 #include "qapi/qapi-visit-block-core.h"
43 #include "crypto.h"
44 #include "block/aio_task.h"
45 
46 /*
47   Differences with QCOW:
48 
49   - Support for multiple incremental snapshots.
50   - Memory management by reference counts.
51   - Clusters which have a reference count of one have the bit
52     QCOW_OFLAG_COPIED to optimize write performance.
53   - Size of compressed clusters is stored in sectors to reduce bit usage
54     in the cluster offsets.
55   - Support for storing additional data (such as the VM state) in the
56     snapshots.
57   - If a backing store is used, the cluster size is not constrained
58     (could be backported to QCOW).
59   - L2 tables have always a size of one cluster.
60 */
61 
62 
63 typedef struct {
64     uint32_t magic;
65     uint32_t len;
66 } QEMU_PACKED QCowExtension;
67 
68 #define  QCOW2_EXT_MAGIC_END 0
69 #define  QCOW2_EXT_MAGIC_BACKING_FORMAT 0xe2792aca
70 #define  QCOW2_EXT_MAGIC_FEATURE_TABLE 0x6803f857
71 #define  QCOW2_EXT_MAGIC_CRYPTO_HEADER 0x0537be77
72 #define  QCOW2_EXT_MAGIC_BITMAPS 0x23852875
73 #define  QCOW2_EXT_MAGIC_DATA_FILE 0x44415441
74 
75 static int coroutine_fn
76 qcow2_co_preadv_compressed(BlockDriverState *bs,
77                            uint64_t l2_entry,
78                            uint64_t offset,
79                            uint64_t bytes,
80                            QEMUIOVector *qiov,
81                            size_t qiov_offset);
82 
qcow2_probe(const uint8_t * buf,int buf_size,const char * filename)83 static int qcow2_probe(const uint8_t *buf, int buf_size, const char *filename)
84 {
85     const QCowHeader *cow_header = (const void *)buf;
86 
87     if (buf_size >= sizeof(QCowHeader) &&
88         be32_to_cpu(cow_header->magic) == QCOW_MAGIC &&
89         be32_to_cpu(cow_header->version) >= 2)
90         return 100;
91     else
92         return 0;
93 }
94 
95 
qcow2_crypto_hdr_read_func(QCryptoBlock * block,size_t offset,uint8_t * buf,size_t buflen,void * opaque,Error ** errp)96 static ssize_t qcow2_crypto_hdr_read_func(QCryptoBlock *block, size_t offset,
97                                           uint8_t *buf, size_t buflen,
98                                           void *opaque, Error **errp)
99 {
100     BlockDriverState *bs = opaque;
101     BDRVQcow2State *s = bs->opaque;
102     ssize_t ret;
103 
104     if ((offset + buflen) > s->crypto_header.length) {
105         error_setg(errp, "Request for data outside of extension header");
106         return -1;
107     }
108 
109     ret = bdrv_pread(bs->file,
110                      s->crypto_header.offset + offset, buf, buflen);
111     if (ret < 0) {
112         error_setg_errno(errp, -ret, "Could not read encryption header");
113         return -1;
114     }
115     return ret;
116 }
117 
118 
qcow2_crypto_hdr_init_func(QCryptoBlock * block,size_t headerlen,void * opaque,Error ** errp)119 static ssize_t qcow2_crypto_hdr_init_func(QCryptoBlock *block, size_t headerlen,
120                                           void *opaque, Error **errp)
121 {
122     BlockDriverState *bs = opaque;
123     BDRVQcow2State *s = bs->opaque;
124     int64_t ret;
125     int64_t clusterlen;
126 
127     ret = qcow2_alloc_clusters(bs, headerlen);
128     if (ret < 0) {
129         error_setg_errno(errp, -ret,
130                          "Cannot allocate cluster for LUKS header size %zu",
131                          headerlen);
132         return -1;
133     }
134 
135     s->crypto_header.length = headerlen;
136     s->crypto_header.offset = ret;
137 
138     /*
139      * Zero fill all space in cluster so it has predictable
140      * content, as we may not initialize some regions of the
141      * header (eg only 1 out of 8 key slots will be initialized)
142      */
143     clusterlen = size_to_clusters(s, headerlen) * s->cluster_size;
144     assert(qcow2_pre_write_overlap_check(bs, 0, ret, clusterlen, false) == 0);
145     ret = bdrv_pwrite_zeroes(bs->file,
146                              ret,
147                              clusterlen, 0);
148     if (ret < 0) {
149         error_setg_errno(errp, -ret, "Could not zero fill encryption header");
150         return -1;
151     }
152 
153     return ret;
154 }
155 
156 
qcow2_crypto_hdr_write_func(QCryptoBlock * block,size_t offset,const uint8_t * buf,size_t buflen,void * opaque,Error ** errp)157 static ssize_t qcow2_crypto_hdr_write_func(QCryptoBlock *block, size_t offset,
158                                            const uint8_t *buf, size_t buflen,
159                                            void *opaque, Error **errp)
160 {
161     BlockDriverState *bs = opaque;
162     BDRVQcow2State *s = bs->opaque;
163     ssize_t ret;
164 
165     if ((offset + buflen) > s->crypto_header.length) {
166         error_setg(errp, "Request for data outside of extension header");
167         return -1;
168     }
169 
170     ret = bdrv_pwrite(bs->file,
171                       s->crypto_header.offset + offset, buf, buflen);
172     if (ret < 0) {
173         error_setg_errno(errp, -ret, "Could not read encryption header");
174         return -1;
175     }
176     return ret;
177 }
178 
179 static QDict*
qcow2_extract_crypto_opts(QemuOpts * opts,const char * fmt,Error ** errp)180 qcow2_extract_crypto_opts(QemuOpts *opts, const char *fmt, Error **errp)
181 {
182     QDict *cryptoopts_qdict;
183     QDict *opts_qdict;
184 
185     /* Extract "encrypt." options into a qdict */
186     opts_qdict = qemu_opts_to_qdict(opts, NULL);
187     qdict_extract_subqdict(opts_qdict, &cryptoopts_qdict, "encrypt.");
188     qobject_unref(opts_qdict);
189     qdict_put_str(cryptoopts_qdict, "format", fmt);
190     return cryptoopts_qdict;
191 }
192 
193 /*
194  * read qcow2 extension and fill bs
195  * start reading from start_offset
196  * finish reading upon magic of value 0 or when end_offset reached
197  * unknown magic is skipped (future extension this version knows nothing about)
198  * return 0 upon success, non-0 otherwise
199  */
qcow2_read_extensions(BlockDriverState * bs,uint64_t start_offset,uint64_t end_offset,void ** p_feature_table,int flags,bool * need_update_header,Error ** errp)200 static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
201                                  uint64_t end_offset, void **p_feature_table,
202                                  int flags, bool *need_update_header,
203                                  Error **errp)
204 {
205     BDRVQcow2State *s = bs->opaque;
206     QCowExtension ext;
207     uint64_t offset;
208     int ret;
209     Qcow2BitmapHeaderExt bitmaps_ext;
210 
211     if (need_update_header != NULL) {
212         *need_update_header = false;
213     }
214 
215 #ifdef DEBUG_EXT
216     printf("qcow2_read_extensions: start=%ld end=%ld\n", start_offset, end_offset);
217 #endif
218     offset = start_offset;
219     while (offset < end_offset) {
220 
221 #ifdef DEBUG_EXT
222         /* Sanity check */
223         if (offset > s->cluster_size)
224             printf("qcow2_read_extension: suspicious offset %lu\n", offset);
225 
226         printf("attempting to read extended header in offset %lu\n", offset);
227 #endif
228 
229         ret = bdrv_pread(bs->file, offset, &ext, sizeof(ext));
230         if (ret < 0) {
231             error_setg_errno(errp, -ret, "qcow2_read_extension: ERROR: "
232                              "pread fail from offset %" PRIu64, offset);
233             return 1;
234         }
235         ext.magic = be32_to_cpu(ext.magic);
236         ext.len = be32_to_cpu(ext.len);
237         offset += sizeof(ext);
238 #ifdef DEBUG_EXT
239         printf("ext.magic = 0x%x\n", ext.magic);
240 #endif
241         if (offset > end_offset || ext.len > end_offset - offset) {
242             error_setg(errp, "Header extension too large");
243             return -EINVAL;
244         }
245 
246         switch (ext.magic) {
247         case QCOW2_EXT_MAGIC_END:
248             return 0;
249 
250         case QCOW2_EXT_MAGIC_BACKING_FORMAT:
251             if (ext.len >= sizeof(bs->backing_format)) {
252                 error_setg(errp, "ERROR: ext_backing_format: len=%" PRIu32
253                            " too large (>=%zu)", ext.len,
254                            sizeof(bs->backing_format));
255                 return 2;
256             }
257             ret = bdrv_pread(bs->file, offset, bs->backing_format, ext.len);
258             if (ret < 0) {
259                 error_setg_errno(errp, -ret, "ERROR: ext_backing_format: "
260                                  "Could not read format name");
261                 return 3;
262             }
263             bs->backing_format[ext.len] = '\0';
264             s->image_backing_format = g_strdup(bs->backing_format);
265 #ifdef DEBUG_EXT
266             printf("Qcow2: Got format extension %s\n", bs->backing_format);
267 #endif
268             break;
269 
270         case QCOW2_EXT_MAGIC_FEATURE_TABLE:
271             if (p_feature_table != NULL) {
272                 void *feature_table = g_malloc0(ext.len + 2 * sizeof(Qcow2Feature));
273                 ret = bdrv_pread(bs->file, offset , feature_table, ext.len);
274                 if (ret < 0) {
275                     error_setg_errno(errp, -ret, "ERROR: ext_feature_table: "
276                                      "Could not read table");
277                     return ret;
278                 }
279 
280                 *p_feature_table = feature_table;
281             }
282             break;
283 
284         case QCOW2_EXT_MAGIC_CRYPTO_HEADER: {
285             unsigned int cflags = 0;
286             if (s->crypt_method_header != QCOW_CRYPT_LUKS) {
287                 error_setg(errp, "CRYPTO header extension only "
288                            "expected with LUKS encryption method");
289                 return -EINVAL;
290             }
291             if (ext.len != sizeof(Qcow2CryptoHeaderExtension)) {
292                 error_setg(errp, "CRYPTO header extension size %u, "
293                            "but expected size %zu", ext.len,
294                            sizeof(Qcow2CryptoHeaderExtension));
295                 return -EINVAL;
296             }
297 
298             ret = bdrv_pread(bs->file, offset, &s->crypto_header, ext.len);
299             if (ret < 0) {
300                 error_setg_errno(errp, -ret,
301                                  "Unable to read CRYPTO header extension");
302                 return ret;
303             }
304             s->crypto_header.offset = be64_to_cpu(s->crypto_header.offset);
305             s->crypto_header.length = be64_to_cpu(s->crypto_header.length);
306 
307             if ((s->crypto_header.offset % s->cluster_size) != 0) {
308                 error_setg(errp, "Encryption header offset '%" PRIu64 "' is "
309                            "not a multiple of cluster size '%u'",
310                            s->crypto_header.offset, s->cluster_size);
311                 return -EINVAL;
312             }
313 
314             if (flags & BDRV_O_NO_IO) {
315                 cflags |= QCRYPTO_BLOCK_OPEN_NO_IO;
316             }
317             s->crypto = qcrypto_block_open(s->crypto_opts, "encrypt.",
318                                            qcow2_crypto_hdr_read_func,
319                                            bs, cflags, QCOW2_MAX_THREADS, errp);
320             if (!s->crypto) {
321                 return -EINVAL;
322             }
323         }   break;
324 
325         case QCOW2_EXT_MAGIC_BITMAPS:
326             if (ext.len != sizeof(bitmaps_ext)) {
327                 error_setg_errno(errp, -ret, "bitmaps_ext: "
328                                  "Invalid extension length");
329                 return -EINVAL;
330             }
331 
332             if (!(s->autoclear_features & QCOW2_AUTOCLEAR_BITMAPS)) {
333                 if (s->qcow_version < 3) {
334                     /* Let's be a bit more specific */
335                     warn_report("This qcow2 v2 image contains bitmaps, but "
336                                 "they may have been modified by a program "
337                                 "without persistent bitmap support; so now "
338                                 "they must all be considered inconsistent");
339                 } else {
340                     warn_report("a program lacking bitmap support "
341                                 "modified this file, so all bitmaps are now "
342                                 "considered inconsistent");
343                 }
344                 error_printf("Some clusters may be leaked, "
345                              "run 'qemu-img check -r' on the image "
346                              "file to fix.");
347                 if (need_update_header != NULL) {
348                     /* Updating is needed to drop invalid bitmap extension. */
349                     *need_update_header = true;
350                 }
351                 break;
352             }
353 
354             ret = bdrv_pread(bs->file, offset, &bitmaps_ext, ext.len);
355             if (ret < 0) {
356                 error_setg_errno(errp, -ret, "bitmaps_ext: "
357                                  "Could not read ext header");
358                 return ret;
359             }
360 
361             if (bitmaps_ext.reserved32 != 0) {
362                 error_setg_errno(errp, -ret, "bitmaps_ext: "
363                                  "Reserved field is not zero");
364                 return -EINVAL;
365             }
366 
367             bitmaps_ext.nb_bitmaps = be32_to_cpu(bitmaps_ext.nb_bitmaps);
368             bitmaps_ext.bitmap_directory_size =
369                 be64_to_cpu(bitmaps_ext.bitmap_directory_size);
370             bitmaps_ext.bitmap_directory_offset =
371                 be64_to_cpu(bitmaps_ext.bitmap_directory_offset);
372 
373             if (bitmaps_ext.nb_bitmaps > QCOW2_MAX_BITMAPS) {
374                 error_setg(errp,
375                            "bitmaps_ext: Image has %" PRIu32 " bitmaps, "
376                            "exceeding the QEMU supported maximum of %d",
377                            bitmaps_ext.nb_bitmaps, QCOW2_MAX_BITMAPS);
378                 return -EINVAL;
379             }
380 
381             if (bitmaps_ext.nb_bitmaps == 0) {
382                 error_setg(errp, "found bitmaps extension with zero bitmaps");
383                 return -EINVAL;
384             }
385 
386             if (offset_into_cluster(s, bitmaps_ext.bitmap_directory_offset)) {
387                 error_setg(errp, "bitmaps_ext: "
388                                  "invalid bitmap directory offset");
389                 return -EINVAL;
390             }
391 
392             if (bitmaps_ext.bitmap_directory_size >
393                 QCOW2_MAX_BITMAP_DIRECTORY_SIZE) {
394                 error_setg(errp, "bitmaps_ext: "
395                                  "bitmap directory size (%" PRIu64 ") exceeds "
396                                  "the maximum supported size (%d)",
397                                  bitmaps_ext.bitmap_directory_size,
398                                  QCOW2_MAX_BITMAP_DIRECTORY_SIZE);
399                 return -EINVAL;
400             }
401 
402             s->nb_bitmaps = bitmaps_ext.nb_bitmaps;
403             s->bitmap_directory_offset =
404                     bitmaps_ext.bitmap_directory_offset;
405             s->bitmap_directory_size =
406                     bitmaps_ext.bitmap_directory_size;
407 
408 #ifdef DEBUG_EXT
409             printf("Qcow2: Got bitmaps extension: "
410                    "offset=%" PRIu64 " nb_bitmaps=%" PRIu32 "\n",
411                    s->bitmap_directory_offset, s->nb_bitmaps);
412 #endif
413             break;
414 
415         case QCOW2_EXT_MAGIC_DATA_FILE:
416         {
417             s->image_data_file = g_malloc0(ext.len + 1);
418             ret = bdrv_pread(bs->file, offset, s->image_data_file, ext.len);
419             if (ret < 0) {
420                 error_setg_errno(errp, -ret,
421                                  "ERROR: Could not read data file name");
422                 return ret;
423             }
424 #ifdef DEBUG_EXT
425             printf("Qcow2: Got external data file %s\n", s->image_data_file);
426 #endif
427             break;
428         }
429 
430         default:
431             /* unknown magic - save it in case we need to rewrite the header */
432             /* If you add a new feature, make sure to also update the fast
433              * path of qcow2_make_empty() to deal with it. */
434             {
435                 Qcow2UnknownHeaderExtension *uext;
436 
437                 uext = g_malloc0(sizeof(*uext)  + ext.len);
438                 uext->magic = ext.magic;
439                 uext->len = ext.len;
440                 QLIST_INSERT_HEAD(&s->unknown_header_ext, uext, next);
441 
442                 ret = bdrv_pread(bs->file, offset , uext->data, uext->len);
443                 if (ret < 0) {
444                     error_setg_errno(errp, -ret, "ERROR: unknown extension: "
445                                      "Could not read data");
446                     return ret;
447                 }
448             }
449             break;
450         }
451 
452         offset += ((ext.len + 7) & ~7);
453     }
454 
455     return 0;
456 }
457 
cleanup_unknown_header_ext(BlockDriverState * bs)458 static void cleanup_unknown_header_ext(BlockDriverState *bs)
459 {
460     BDRVQcow2State *s = bs->opaque;
461     Qcow2UnknownHeaderExtension *uext, *next;
462 
463     QLIST_FOREACH_SAFE(uext, &s->unknown_header_ext, next, next) {
464         QLIST_REMOVE(uext, next);
465         g_free(uext);
466     }
467 }
468 
report_unsupported_feature(Error ** errp,Qcow2Feature * table,uint64_t mask)469 static void report_unsupported_feature(Error **errp, Qcow2Feature *table,
470                                        uint64_t mask)
471 {
472     g_autoptr(GString) features = g_string_sized_new(60);
473 
474     while (table && table->name[0] != '\0') {
475         if (table->type == QCOW2_FEAT_TYPE_INCOMPATIBLE) {
476             if (mask & (1ULL << table->bit)) {
477                 if (features->len > 0) {
478                     g_string_append(features, ", ");
479                 }
480                 g_string_append_printf(features, "%.46s", table->name);
481                 mask &= ~(1ULL << table->bit);
482             }
483         }
484         table++;
485     }
486 
487     if (mask) {
488         if (features->len > 0) {
489             g_string_append(features, ", ");
490         }
491         g_string_append_printf(features,
492                                "Unknown incompatible feature: %" PRIx64, mask);
493     }
494 
495     error_setg(errp, "Unsupported qcow2 feature(s): %s", features->str);
496 }
497 
498 /*
499  * Sets the dirty bit and flushes afterwards if necessary.
500  *
501  * The incompatible_features bit is only set if the image file header was
502  * updated successfully.  Therefore it is not required to check the return
503  * value of this function.
504  */
qcow2_mark_dirty(BlockDriverState * bs)505 int qcow2_mark_dirty(BlockDriverState *bs)
506 {
507     BDRVQcow2State *s = bs->opaque;
508     uint64_t val;
509     int ret;
510 
511     assert(s->qcow_version >= 3);
512 
513     if (s->incompatible_features & QCOW2_INCOMPAT_DIRTY) {
514         return 0; /* already dirty */
515     }
516 
517     val = cpu_to_be64(s->incompatible_features | QCOW2_INCOMPAT_DIRTY);
518     ret = bdrv_pwrite(bs->file, offsetof(QCowHeader, incompatible_features),
519                       &val, sizeof(val));
520     if (ret < 0) {
521         return ret;
522     }
523     ret = bdrv_flush(bs->file->bs);
524     if (ret < 0) {
525         return ret;
526     }
527 
528     /* Only treat image as dirty if the header was updated successfully */
529     s->incompatible_features |= QCOW2_INCOMPAT_DIRTY;
530     return 0;
531 }
532 
533 /*
534  * Clears the dirty bit and flushes before if necessary.  Only call this
535  * function when there are no pending requests, it does not guard against
536  * concurrent requests dirtying the image.
537  */
qcow2_mark_clean(BlockDriverState * bs)538 static int qcow2_mark_clean(BlockDriverState *bs)
539 {
540     BDRVQcow2State *s = bs->opaque;
541 
542     if (s->incompatible_features & QCOW2_INCOMPAT_DIRTY) {
543         int ret;
544 
545         s->incompatible_features &= ~QCOW2_INCOMPAT_DIRTY;
546 
547         ret = qcow2_flush_caches(bs);
548         if (ret < 0) {
549             return ret;
550         }
551 
552         return qcow2_update_header(bs);
553     }
554     return 0;
555 }
556 
557 /*
558  * Marks the image as corrupt.
559  */
qcow2_mark_corrupt(BlockDriverState * bs)560 int qcow2_mark_corrupt(BlockDriverState *bs)
561 {
562     BDRVQcow2State *s = bs->opaque;
563 
564     s->incompatible_features |= QCOW2_INCOMPAT_CORRUPT;
565     return qcow2_update_header(bs);
566 }
567 
568 /*
569  * Marks the image as consistent, i.e., unsets the corrupt bit, and flushes
570  * before if necessary.
571  */
qcow2_mark_consistent(BlockDriverState * bs)572 int qcow2_mark_consistent(BlockDriverState *bs)
573 {
574     BDRVQcow2State *s = bs->opaque;
575 
576     if (s->incompatible_features & QCOW2_INCOMPAT_CORRUPT) {
577         int ret = qcow2_flush_caches(bs);
578         if (ret < 0) {
579             return ret;
580         }
581 
582         s->incompatible_features &= ~QCOW2_INCOMPAT_CORRUPT;
583         return qcow2_update_header(bs);
584     }
585     return 0;
586 }
587 
qcow2_add_check_result(BdrvCheckResult * out,const BdrvCheckResult * src,bool set_allocation_info)588 static void qcow2_add_check_result(BdrvCheckResult *out,
589                                    const BdrvCheckResult *src,
590                                    bool set_allocation_info)
591 {
592     out->corruptions += src->corruptions;
593     out->leaks += src->leaks;
594     out->check_errors += src->check_errors;
595     out->corruptions_fixed += src->corruptions_fixed;
596     out->leaks_fixed += src->leaks_fixed;
597 
598     if (set_allocation_info) {
599         out->image_end_offset = src->image_end_offset;
600         out->bfi = src->bfi;
601     }
602 }
603 
qcow2_co_check_locked(BlockDriverState * bs,BdrvCheckResult * result,BdrvCheckMode fix)604 static int coroutine_fn qcow2_co_check_locked(BlockDriverState *bs,
605                                               BdrvCheckResult *result,
606                                               BdrvCheckMode fix)
607 {
608     BdrvCheckResult snapshot_res = {};
609     BdrvCheckResult refcount_res = {};
610     int ret;
611 
612     memset(result, 0, sizeof(*result));
613 
614     ret = qcow2_check_read_snapshot_table(bs, &snapshot_res, fix);
615     if (ret < 0) {
616         qcow2_add_check_result(result, &snapshot_res, false);
617         return ret;
618     }
619 
620     ret = qcow2_check_refcounts(bs, &refcount_res, fix);
621     qcow2_add_check_result(result, &refcount_res, true);
622     if (ret < 0) {
623         qcow2_add_check_result(result, &snapshot_res, false);
624         return ret;
625     }
626 
627     ret = qcow2_check_fix_snapshot_table(bs, &snapshot_res, fix);
628     qcow2_add_check_result(result, &snapshot_res, false);
629     if (ret < 0) {
630         return ret;
631     }
632 
633     if (fix && result->check_errors == 0 && result->corruptions == 0) {
634         ret = qcow2_mark_clean(bs);
635         if (ret < 0) {
636             return ret;
637         }
638         return qcow2_mark_consistent(bs);
639     }
640     return ret;
641 }
642 
qcow2_co_check(BlockDriverState * bs,BdrvCheckResult * result,BdrvCheckMode fix)643 static int coroutine_fn qcow2_co_check(BlockDriverState *bs,
644                                        BdrvCheckResult *result,
645                                        BdrvCheckMode fix)
646 {
647     BDRVQcow2State *s = bs->opaque;
648     int ret;
649 
650     qemu_co_mutex_lock(&s->lock);
651     ret = qcow2_co_check_locked(bs, result, fix);
652     qemu_co_mutex_unlock(&s->lock);
653     return ret;
654 }
655 
qcow2_validate_table(BlockDriverState * bs,uint64_t offset,uint64_t entries,size_t entry_len,int64_t max_size_bytes,const char * table_name,Error ** errp)656 int qcow2_validate_table(BlockDriverState *bs, uint64_t offset,
657                          uint64_t entries, size_t entry_len,
658                          int64_t max_size_bytes, const char *table_name,
659                          Error **errp)
660 {
661     BDRVQcow2State *s = bs->opaque;
662 
663     if (entries > max_size_bytes / entry_len) {
664         error_setg(errp, "%s too large", table_name);
665         return -EFBIG;
666     }
667 
668     /* Use signed INT64_MAX as the maximum even for uint64_t header fields,
669      * because values will be passed to qemu functions taking int64_t. */
670     if ((INT64_MAX - entries * entry_len < offset) ||
671         (offset_into_cluster(s, offset) != 0)) {
672         error_setg(errp, "%s offset invalid", table_name);
673         return -EINVAL;
674     }
675 
676     return 0;
677 }
678 
679 static const char *const mutable_opts[] = {
680     QCOW2_OPT_LAZY_REFCOUNTS,
681     QCOW2_OPT_DISCARD_REQUEST,
682     QCOW2_OPT_DISCARD_SNAPSHOT,
683     QCOW2_OPT_DISCARD_OTHER,
684     QCOW2_OPT_OVERLAP,
685     QCOW2_OPT_OVERLAP_TEMPLATE,
686     QCOW2_OPT_OVERLAP_MAIN_HEADER,
687     QCOW2_OPT_OVERLAP_ACTIVE_L1,
688     QCOW2_OPT_OVERLAP_ACTIVE_L2,
689     QCOW2_OPT_OVERLAP_REFCOUNT_TABLE,
690     QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK,
691     QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE,
692     QCOW2_OPT_OVERLAP_INACTIVE_L1,
693     QCOW2_OPT_OVERLAP_INACTIVE_L2,
694     QCOW2_OPT_OVERLAP_BITMAP_DIRECTORY,
695     QCOW2_OPT_CACHE_SIZE,
696     QCOW2_OPT_L2_CACHE_SIZE,
697     QCOW2_OPT_L2_CACHE_ENTRY_SIZE,
698     QCOW2_OPT_REFCOUNT_CACHE_SIZE,
699     QCOW2_OPT_CACHE_CLEAN_INTERVAL,
700     NULL
701 };
702 
703 static QemuOptsList qcow2_runtime_opts = {
704     .name = "qcow2",
705     .head = QTAILQ_HEAD_INITIALIZER(qcow2_runtime_opts.head),
706     .desc = {
707         {
708             .name = QCOW2_OPT_LAZY_REFCOUNTS,
709             .type = QEMU_OPT_BOOL,
710             .help = "Postpone refcount updates",
711         },
712         {
713             .name = QCOW2_OPT_DISCARD_REQUEST,
714             .type = QEMU_OPT_BOOL,
715             .help = "Pass guest discard requests to the layer below",
716         },
717         {
718             .name = QCOW2_OPT_DISCARD_SNAPSHOT,
719             .type = QEMU_OPT_BOOL,
720             .help = "Generate discard requests when snapshot related space "
721                     "is freed",
722         },
723         {
724             .name = QCOW2_OPT_DISCARD_OTHER,
725             .type = QEMU_OPT_BOOL,
726             .help = "Generate discard requests when other clusters are freed",
727         },
728         {
729             .name = QCOW2_OPT_OVERLAP,
730             .type = QEMU_OPT_STRING,
731             .help = "Selects which overlap checks to perform from a range of "
732                     "templates (none, constant, cached, all)",
733         },
734         {
735             .name = QCOW2_OPT_OVERLAP_TEMPLATE,
736             .type = QEMU_OPT_STRING,
737             .help = "Selects which overlap checks to perform from a range of "
738                     "templates (none, constant, cached, all)",
739         },
740         {
741             .name = QCOW2_OPT_OVERLAP_MAIN_HEADER,
742             .type = QEMU_OPT_BOOL,
743             .help = "Check for unintended writes into the main qcow2 header",
744         },
745         {
746             .name = QCOW2_OPT_OVERLAP_ACTIVE_L1,
747             .type = QEMU_OPT_BOOL,
748             .help = "Check for unintended writes into the active L1 table",
749         },
750         {
751             .name = QCOW2_OPT_OVERLAP_ACTIVE_L2,
752             .type = QEMU_OPT_BOOL,
753             .help = "Check for unintended writes into an active L2 table",
754         },
755         {
756             .name = QCOW2_OPT_OVERLAP_REFCOUNT_TABLE,
757             .type = QEMU_OPT_BOOL,
758             .help = "Check for unintended writes into the refcount table",
759         },
760         {
761             .name = QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK,
762             .type = QEMU_OPT_BOOL,
763             .help = "Check for unintended writes into a refcount block",
764         },
765         {
766             .name = QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE,
767             .type = QEMU_OPT_BOOL,
768             .help = "Check for unintended writes into the snapshot table",
769         },
770         {
771             .name = QCOW2_OPT_OVERLAP_INACTIVE_L1,
772             .type = QEMU_OPT_BOOL,
773             .help = "Check for unintended writes into an inactive L1 table",
774         },
775         {
776             .name = QCOW2_OPT_OVERLAP_INACTIVE_L2,
777             .type = QEMU_OPT_BOOL,
778             .help = "Check for unintended writes into an inactive L2 table",
779         },
780         {
781             .name = QCOW2_OPT_OVERLAP_BITMAP_DIRECTORY,
782             .type = QEMU_OPT_BOOL,
783             .help = "Check for unintended writes into the bitmap directory",
784         },
785         {
786             .name = QCOW2_OPT_CACHE_SIZE,
787             .type = QEMU_OPT_SIZE,
788             .help = "Maximum combined metadata (L2 tables and refcount blocks) "
789                     "cache size",
790         },
791         {
792             .name = QCOW2_OPT_L2_CACHE_SIZE,
793             .type = QEMU_OPT_SIZE,
794             .help = "Maximum L2 table cache size",
795         },
796         {
797             .name = QCOW2_OPT_L2_CACHE_ENTRY_SIZE,
798             .type = QEMU_OPT_SIZE,
799             .help = "Size of each entry in the L2 cache",
800         },
801         {
802             .name = QCOW2_OPT_REFCOUNT_CACHE_SIZE,
803             .type = QEMU_OPT_SIZE,
804             .help = "Maximum refcount block cache size",
805         },
806         {
807             .name = QCOW2_OPT_CACHE_CLEAN_INTERVAL,
808             .type = QEMU_OPT_NUMBER,
809             .help = "Clean unused cache entries after this time (in seconds)",
810         },
811         BLOCK_CRYPTO_OPT_DEF_KEY_SECRET("encrypt.",
812             "ID of secret providing qcow2 AES key or LUKS passphrase"),
813         { /* end of list */ }
814     },
815 };
816 
817 static const char *overlap_bool_option_names[QCOW2_OL_MAX_BITNR] = {
818     [QCOW2_OL_MAIN_HEADER_BITNR]      = QCOW2_OPT_OVERLAP_MAIN_HEADER,
819     [QCOW2_OL_ACTIVE_L1_BITNR]        = QCOW2_OPT_OVERLAP_ACTIVE_L1,
820     [QCOW2_OL_ACTIVE_L2_BITNR]        = QCOW2_OPT_OVERLAP_ACTIVE_L2,
821     [QCOW2_OL_REFCOUNT_TABLE_BITNR]   = QCOW2_OPT_OVERLAP_REFCOUNT_TABLE,
822     [QCOW2_OL_REFCOUNT_BLOCK_BITNR]   = QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK,
823     [QCOW2_OL_SNAPSHOT_TABLE_BITNR]   = QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE,
824     [QCOW2_OL_INACTIVE_L1_BITNR]      = QCOW2_OPT_OVERLAP_INACTIVE_L1,
825     [QCOW2_OL_INACTIVE_L2_BITNR]      = QCOW2_OPT_OVERLAP_INACTIVE_L2,
826     [QCOW2_OL_BITMAP_DIRECTORY_BITNR] = QCOW2_OPT_OVERLAP_BITMAP_DIRECTORY,
827 };
828 
cache_clean_timer_cb(void * opaque)829 static void cache_clean_timer_cb(void *opaque)
830 {
831     BlockDriverState *bs = opaque;
832     BDRVQcow2State *s = bs->opaque;
833     qcow2_cache_clean_unused(s->l2_table_cache);
834     qcow2_cache_clean_unused(s->refcount_block_cache);
835     timer_mod(s->cache_clean_timer, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) +
836               (int64_t) s->cache_clean_interval * 1000);
837 }
838 
cache_clean_timer_init(BlockDriverState * bs,AioContext * context)839 static void cache_clean_timer_init(BlockDriverState *bs, AioContext *context)
840 {
841     BDRVQcow2State *s = bs->opaque;
842     if (s->cache_clean_interval > 0) {
843         s->cache_clean_timer =
844             aio_timer_new_with_attrs(context, QEMU_CLOCK_VIRTUAL,
845                                      SCALE_MS, QEMU_TIMER_ATTR_EXTERNAL,
846                                      cache_clean_timer_cb, bs);
847         timer_mod(s->cache_clean_timer, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) +
848                   (int64_t) s->cache_clean_interval * 1000);
849     }
850 }
851 
cache_clean_timer_del(BlockDriverState * bs)852 static void cache_clean_timer_del(BlockDriverState *bs)
853 {
854     BDRVQcow2State *s = bs->opaque;
855     if (s->cache_clean_timer) {
856         timer_free(s->cache_clean_timer);
857         s->cache_clean_timer = NULL;
858     }
859 }
860 
qcow2_detach_aio_context(BlockDriverState * bs)861 static void qcow2_detach_aio_context(BlockDriverState *bs)
862 {
863     cache_clean_timer_del(bs);
864 }
865 
qcow2_attach_aio_context(BlockDriverState * bs,AioContext * new_context)866 static void qcow2_attach_aio_context(BlockDriverState *bs,
867                                      AioContext *new_context)
868 {
869     cache_clean_timer_init(bs, new_context);
870 }
871 
read_cache_sizes(BlockDriverState * bs,QemuOpts * opts,uint64_t * l2_cache_size,uint64_t * l2_cache_entry_size,uint64_t * refcount_cache_size,Error ** errp)872 static bool read_cache_sizes(BlockDriverState *bs, QemuOpts *opts,
873                              uint64_t *l2_cache_size,
874                              uint64_t *l2_cache_entry_size,
875                              uint64_t *refcount_cache_size, Error **errp)
876 {
877     BDRVQcow2State *s = bs->opaque;
878     uint64_t combined_cache_size, l2_cache_max_setting;
879     bool l2_cache_size_set, refcount_cache_size_set, combined_cache_size_set;
880     bool l2_cache_entry_size_set;
881     int min_refcount_cache = MIN_REFCOUNT_CACHE_SIZE * s->cluster_size;
882     uint64_t virtual_disk_size = bs->total_sectors * BDRV_SECTOR_SIZE;
883     uint64_t max_l2_entries = DIV_ROUND_UP(virtual_disk_size, s->cluster_size);
884     /* An L2 table is always one cluster in size so the max cache size
885      * should be a multiple of the cluster size. */
886     uint64_t max_l2_cache = ROUND_UP(max_l2_entries * l2_entry_size(s),
887                                      s->cluster_size);
888 
889     combined_cache_size_set = qemu_opt_get(opts, QCOW2_OPT_CACHE_SIZE);
890     l2_cache_size_set = qemu_opt_get(opts, QCOW2_OPT_L2_CACHE_SIZE);
891     refcount_cache_size_set = qemu_opt_get(opts, QCOW2_OPT_REFCOUNT_CACHE_SIZE);
892     l2_cache_entry_size_set = qemu_opt_get(opts, QCOW2_OPT_L2_CACHE_ENTRY_SIZE);
893 
894     combined_cache_size = qemu_opt_get_size(opts, QCOW2_OPT_CACHE_SIZE, 0);
895     l2_cache_max_setting = qemu_opt_get_size(opts, QCOW2_OPT_L2_CACHE_SIZE,
896                                              DEFAULT_L2_CACHE_MAX_SIZE);
897     *refcount_cache_size = qemu_opt_get_size(opts,
898                                              QCOW2_OPT_REFCOUNT_CACHE_SIZE, 0);
899 
900     *l2_cache_entry_size = qemu_opt_get_size(
901         opts, QCOW2_OPT_L2_CACHE_ENTRY_SIZE, s->cluster_size);
902 
903     *l2_cache_size = MIN(max_l2_cache, l2_cache_max_setting);
904 
905     if (combined_cache_size_set) {
906         if (l2_cache_size_set && refcount_cache_size_set) {
907             error_setg(errp, QCOW2_OPT_CACHE_SIZE ", " QCOW2_OPT_L2_CACHE_SIZE
908                        " and " QCOW2_OPT_REFCOUNT_CACHE_SIZE " may not be set "
909                        "at the same time");
910             return false;
911         } else if (l2_cache_size_set &&
912                    (l2_cache_max_setting > combined_cache_size)) {
913             error_setg(errp, QCOW2_OPT_L2_CACHE_SIZE " may not exceed "
914                        QCOW2_OPT_CACHE_SIZE);
915             return false;
916         } else if (*refcount_cache_size > combined_cache_size) {
917             error_setg(errp, QCOW2_OPT_REFCOUNT_CACHE_SIZE " may not exceed "
918                        QCOW2_OPT_CACHE_SIZE);
919             return false;
920         }
921 
922         if (l2_cache_size_set) {
923             *refcount_cache_size = combined_cache_size - *l2_cache_size;
924         } else if (refcount_cache_size_set) {
925             *l2_cache_size = combined_cache_size - *refcount_cache_size;
926         } else {
927             /* Assign as much memory as possible to the L2 cache, and
928              * use the remainder for the refcount cache */
929             if (combined_cache_size >= max_l2_cache + min_refcount_cache) {
930                 *l2_cache_size = max_l2_cache;
931                 *refcount_cache_size = combined_cache_size - *l2_cache_size;
932             } else {
933                 *refcount_cache_size =
934                     MIN(combined_cache_size, min_refcount_cache);
935                 *l2_cache_size = combined_cache_size - *refcount_cache_size;
936             }
937         }
938     }
939 
940     /*
941      * If the L2 cache is not enough to cover the whole disk then
942      * default to 4KB entries. Smaller entries reduce the cost of
943      * loads and evictions and increase I/O performance.
944      */
945     if (*l2_cache_size < max_l2_cache && !l2_cache_entry_size_set) {
946         *l2_cache_entry_size = MIN(s->cluster_size, 4096);
947     }
948 
949     /* l2_cache_size and refcount_cache_size are ensured to have at least
950      * their minimum values in qcow2_update_options_prepare() */
951 
952     if (*l2_cache_entry_size < (1 << MIN_CLUSTER_BITS) ||
953         *l2_cache_entry_size > s->cluster_size ||
954         !is_power_of_2(*l2_cache_entry_size)) {
955         error_setg(errp, "L2 cache entry size must be a power of two "
956                    "between %d and the cluster size (%d)",
957                    1 << MIN_CLUSTER_BITS, s->cluster_size);
958         return false;
959     }
960 
961     return true;
962 }
963 
964 typedef struct Qcow2ReopenState {
965     Qcow2Cache *l2_table_cache;
966     Qcow2Cache *refcount_block_cache;
967     int l2_slice_size; /* Number of entries in a slice of the L2 table */
968     bool use_lazy_refcounts;
969     int overlap_check;
970     bool discard_passthrough[QCOW2_DISCARD_MAX];
971     uint64_t cache_clean_interval;
972     QCryptoBlockOpenOptions *crypto_opts; /* Disk encryption runtime options */
973 } Qcow2ReopenState;
974 
qcow2_update_options_prepare(BlockDriverState * bs,Qcow2ReopenState * r,QDict * options,int flags,Error ** errp)975 static int qcow2_update_options_prepare(BlockDriverState *bs,
976                                         Qcow2ReopenState *r,
977                                         QDict *options, int flags,
978                                         Error **errp)
979 {
980     BDRVQcow2State *s = bs->opaque;
981     QemuOpts *opts = NULL;
982     const char *opt_overlap_check, *opt_overlap_check_template;
983     int overlap_check_template = 0;
984     uint64_t l2_cache_size, l2_cache_entry_size, refcount_cache_size;
985     int i;
986     const char *encryptfmt;
987     QDict *encryptopts = NULL;
988     int ret;
989 
990     qdict_extract_subqdict(options, &encryptopts, "encrypt.");
991     encryptfmt = qdict_get_try_str(encryptopts, "format");
992 
993     opts = qemu_opts_create(&qcow2_runtime_opts, NULL, 0, &error_abort);
994     if (!qemu_opts_absorb_qdict(opts, options, errp)) {
995         ret = -EINVAL;
996         goto fail;
997     }
998 
999     /* get L2 table/refcount block cache size from command line options */
1000     if (!read_cache_sizes(bs, opts, &l2_cache_size, &l2_cache_entry_size,
1001                           &refcount_cache_size, errp)) {
1002         ret = -EINVAL;
1003         goto fail;
1004     }
1005 
1006     l2_cache_size /= l2_cache_entry_size;
1007     if (l2_cache_size < MIN_L2_CACHE_SIZE) {
1008         l2_cache_size = MIN_L2_CACHE_SIZE;
1009     }
1010     if (l2_cache_size > INT_MAX) {
1011         error_setg(errp, "L2 cache size too big");
1012         ret = -EINVAL;
1013         goto fail;
1014     }
1015 
1016     refcount_cache_size /= s->cluster_size;
1017     if (refcount_cache_size < MIN_REFCOUNT_CACHE_SIZE) {
1018         refcount_cache_size = MIN_REFCOUNT_CACHE_SIZE;
1019     }
1020     if (refcount_cache_size > INT_MAX) {
1021         error_setg(errp, "Refcount cache size too big");
1022         ret = -EINVAL;
1023         goto fail;
1024     }
1025 
1026     /* alloc new L2 table/refcount block cache, flush old one */
1027     if (s->l2_table_cache) {
1028         ret = qcow2_cache_flush(bs, s->l2_table_cache);
1029         if (ret) {
1030             error_setg_errno(errp, -ret, "Failed to flush the L2 table cache");
1031             goto fail;
1032         }
1033     }
1034 
1035     if (s->refcount_block_cache) {
1036         ret = qcow2_cache_flush(bs, s->refcount_block_cache);
1037         if (ret) {
1038             error_setg_errno(errp, -ret,
1039                              "Failed to flush the refcount block cache");
1040             goto fail;
1041         }
1042     }
1043 
1044     r->l2_slice_size = l2_cache_entry_size / l2_entry_size(s);
1045     r->l2_table_cache = qcow2_cache_create(bs, l2_cache_size,
1046                                            l2_cache_entry_size);
1047     r->refcount_block_cache = qcow2_cache_create(bs, refcount_cache_size,
1048                                                  s->cluster_size);
1049     if (r->l2_table_cache == NULL || r->refcount_block_cache == NULL) {
1050         error_setg(errp, "Could not allocate metadata caches");
1051         ret = -ENOMEM;
1052         goto fail;
1053     }
1054 
1055     /* New interval for cache cleanup timer */
1056     r->cache_clean_interval =
1057         qemu_opt_get_number(opts, QCOW2_OPT_CACHE_CLEAN_INTERVAL,
1058                             DEFAULT_CACHE_CLEAN_INTERVAL);
1059 #ifndef CONFIG_LINUX
1060     if (r->cache_clean_interval != 0) {
1061         error_setg(errp, QCOW2_OPT_CACHE_CLEAN_INTERVAL
1062                    " not supported on this host");
1063         ret = -EINVAL;
1064         goto fail;
1065     }
1066 #endif
1067     if (r->cache_clean_interval > UINT_MAX) {
1068         error_setg(errp, "Cache clean interval too big");
1069         ret = -EINVAL;
1070         goto fail;
1071     }
1072 
1073     /* lazy-refcounts; flush if going from enabled to disabled */
1074     r->use_lazy_refcounts = qemu_opt_get_bool(opts, QCOW2_OPT_LAZY_REFCOUNTS,
1075         (s->compatible_features & QCOW2_COMPAT_LAZY_REFCOUNTS));
1076     if (r->use_lazy_refcounts && s->qcow_version < 3) {
1077         error_setg(errp, "Lazy refcounts require a qcow2 image with at least "
1078                    "qemu 1.1 compatibility level");
1079         ret = -EINVAL;
1080         goto fail;
1081     }
1082 
1083     if (s->use_lazy_refcounts && !r->use_lazy_refcounts) {
1084         ret = qcow2_mark_clean(bs);
1085         if (ret < 0) {
1086             error_setg_errno(errp, -ret, "Failed to disable lazy refcounts");
1087             goto fail;
1088         }
1089     }
1090 
1091     /* Overlap check options */
1092     opt_overlap_check = qemu_opt_get(opts, QCOW2_OPT_OVERLAP);
1093     opt_overlap_check_template = qemu_opt_get(opts, QCOW2_OPT_OVERLAP_TEMPLATE);
1094     if (opt_overlap_check_template && opt_overlap_check &&
1095         strcmp(opt_overlap_check_template, opt_overlap_check))
1096     {
1097         error_setg(errp, "Conflicting values for qcow2 options '"
1098                    QCOW2_OPT_OVERLAP "' ('%s') and '" QCOW2_OPT_OVERLAP_TEMPLATE
1099                    "' ('%s')", opt_overlap_check, opt_overlap_check_template);
1100         ret = -EINVAL;
1101         goto fail;
1102     }
1103     if (!opt_overlap_check) {
1104         opt_overlap_check = opt_overlap_check_template ?: "cached";
1105     }
1106 
1107     if (!strcmp(opt_overlap_check, "none")) {
1108         overlap_check_template = 0;
1109     } else if (!strcmp(opt_overlap_check, "constant")) {
1110         overlap_check_template = QCOW2_OL_CONSTANT;
1111     } else if (!strcmp(opt_overlap_check, "cached")) {
1112         overlap_check_template = QCOW2_OL_CACHED;
1113     } else if (!strcmp(opt_overlap_check, "all")) {
1114         overlap_check_template = QCOW2_OL_ALL;
1115     } else {
1116         error_setg(errp, "Unsupported value '%s' for qcow2 option "
1117                    "'overlap-check'. Allowed are any of the following: "
1118                    "none, constant, cached, all", opt_overlap_check);
1119         ret = -EINVAL;
1120         goto fail;
1121     }
1122 
1123     r->overlap_check = 0;
1124     for (i = 0; i < QCOW2_OL_MAX_BITNR; i++) {
1125         /* overlap-check defines a template bitmask, but every flag may be
1126          * overwritten through the associated boolean option */
1127         r->overlap_check |=
1128             qemu_opt_get_bool(opts, overlap_bool_option_names[i],
1129                               overlap_check_template & (1 << i)) << i;
1130     }
1131 
1132     r->discard_passthrough[QCOW2_DISCARD_NEVER] = false;
1133     r->discard_passthrough[QCOW2_DISCARD_ALWAYS] = true;
1134     r->discard_passthrough[QCOW2_DISCARD_REQUEST] =
1135         qemu_opt_get_bool(opts, QCOW2_OPT_DISCARD_REQUEST,
1136                           flags & BDRV_O_UNMAP);
1137     r->discard_passthrough[QCOW2_DISCARD_SNAPSHOT] =
1138         qemu_opt_get_bool(opts, QCOW2_OPT_DISCARD_SNAPSHOT, true);
1139     r->discard_passthrough[QCOW2_DISCARD_OTHER] =
1140         qemu_opt_get_bool(opts, QCOW2_OPT_DISCARD_OTHER, false);
1141 
1142     switch (s->crypt_method_header) {
1143     case QCOW_CRYPT_NONE:
1144         if (encryptfmt) {
1145             error_setg(errp, "No encryption in image header, but options "
1146                        "specified format '%s'", encryptfmt);
1147             ret = -EINVAL;
1148             goto fail;
1149         }
1150         break;
1151 
1152     case QCOW_CRYPT_AES:
1153         if (encryptfmt && !g_str_equal(encryptfmt, "aes")) {
1154             error_setg(errp,
1155                        "Header reported 'aes' encryption format but "
1156                        "options specify '%s'", encryptfmt);
1157             ret = -EINVAL;
1158             goto fail;
1159         }
1160         qdict_put_str(encryptopts, "format", "qcow");
1161         r->crypto_opts = block_crypto_open_opts_init(encryptopts, errp);
1162         if (!r->crypto_opts) {
1163             ret = -EINVAL;
1164             goto fail;
1165         }
1166         break;
1167 
1168     case QCOW_CRYPT_LUKS:
1169         if (encryptfmt && !g_str_equal(encryptfmt, "luks")) {
1170             error_setg(errp,
1171                        "Header reported 'luks' encryption format but "
1172                        "options specify '%s'", encryptfmt);
1173             ret = -EINVAL;
1174             goto fail;
1175         }
1176         qdict_put_str(encryptopts, "format", "luks");
1177         r->crypto_opts = block_crypto_open_opts_init(encryptopts, errp);
1178         if (!r->crypto_opts) {
1179             ret = -EINVAL;
1180             goto fail;
1181         }
1182         break;
1183 
1184     default:
1185         error_setg(errp, "Unsupported encryption method %d",
1186                    s->crypt_method_header);
1187         ret = -EINVAL;
1188         goto fail;
1189     }
1190 
1191     ret = 0;
1192 fail:
1193     qobject_unref(encryptopts);
1194     qemu_opts_del(opts);
1195     opts = NULL;
1196     return ret;
1197 }
1198 
qcow2_update_options_commit(BlockDriverState * bs,Qcow2ReopenState * r)1199 static void qcow2_update_options_commit(BlockDriverState *bs,
1200                                         Qcow2ReopenState *r)
1201 {
1202     BDRVQcow2State *s = bs->opaque;
1203     int i;
1204 
1205     if (s->l2_table_cache) {
1206         qcow2_cache_destroy(s->l2_table_cache);
1207     }
1208     if (s->refcount_block_cache) {
1209         qcow2_cache_destroy(s->refcount_block_cache);
1210     }
1211     s->l2_table_cache = r->l2_table_cache;
1212     s->refcount_block_cache = r->refcount_block_cache;
1213     s->l2_slice_size = r->l2_slice_size;
1214 
1215     s->overlap_check = r->overlap_check;
1216     s->use_lazy_refcounts = r->use_lazy_refcounts;
1217 
1218     for (i = 0; i < QCOW2_DISCARD_MAX; i++) {
1219         s->discard_passthrough[i] = r->discard_passthrough[i];
1220     }
1221 
1222     if (s->cache_clean_interval != r->cache_clean_interval) {
1223         cache_clean_timer_del(bs);
1224         s->cache_clean_interval = r->cache_clean_interval;
1225         cache_clean_timer_init(bs, bdrv_get_aio_context(bs));
1226     }
1227 
1228     qapi_free_QCryptoBlockOpenOptions(s->crypto_opts);
1229     s->crypto_opts = r->crypto_opts;
1230 }
1231 
qcow2_update_options_abort(BlockDriverState * bs,Qcow2ReopenState * r)1232 static void qcow2_update_options_abort(BlockDriverState *bs,
1233                                        Qcow2ReopenState *r)
1234 {
1235     if (r->l2_table_cache) {
1236         qcow2_cache_destroy(r->l2_table_cache);
1237     }
1238     if (r->refcount_block_cache) {
1239         qcow2_cache_destroy(r->refcount_block_cache);
1240     }
1241     qapi_free_QCryptoBlockOpenOptions(r->crypto_opts);
1242 }
1243 
qcow2_update_options(BlockDriverState * bs,QDict * options,int flags,Error ** errp)1244 static int qcow2_update_options(BlockDriverState *bs, QDict *options,
1245                                 int flags, Error **errp)
1246 {
1247     Qcow2ReopenState r = {};
1248     int ret;
1249 
1250     ret = qcow2_update_options_prepare(bs, &r, options, flags, errp);
1251     if (ret >= 0) {
1252         qcow2_update_options_commit(bs, &r);
1253     } else {
1254         qcow2_update_options_abort(bs, &r);
1255     }
1256 
1257     return ret;
1258 }
1259 
validate_compression_type(BDRVQcow2State * s,Error ** errp)1260 static int validate_compression_type(BDRVQcow2State *s, Error **errp)
1261 {
1262     switch (s->compression_type) {
1263     case QCOW2_COMPRESSION_TYPE_ZLIB:
1264 #ifdef CONFIG_ZSTD
1265     case QCOW2_COMPRESSION_TYPE_ZSTD:
1266 #endif
1267         break;
1268 
1269     default:
1270         error_setg(errp, "qcow2: unknown compression type: %u",
1271                    s->compression_type);
1272         return -ENOTSUP;
1273     }
1274 
1275     /*
1276      * if the compression type differs from QCOW2_COMPRESSION_TYPE_ZLIB
1277      * the incompatible feature flag must be set
1278      */
1279     if (s->compression_type == QCOW2_COMPRESSION_TYPE_ZLIB) {
1280         if (s->incompatible_features & QCOW2_INCOMPAT_COMPRESSION) {
1281             error_setg(errp, "qcow2: Compression type incompatible feature "
1282                              "bit must not be set");
1283             return -EINVAL;
1284         }
1285     } else {
1286         if (!(s->incompatible_features & QCOW2_INCOMPAT_COMPRESSION)) {
1287             error_setg(errp, "qcow2: Compression type incompatible feature "
1288                              "bit must be set");
1289             return -EINVAL;
1290         }
1291     }
1292 
1293     return 0;
1294 }
1295 
1296 /* Called with s->lock held.  */
qcow2_do_open(BlockDriverState * bs,QDict * options,int flags,Error ** errp)1297 static int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options,
1298                                       int flags, Error **errp)
1299 {
1300     ERRP_GUARD();
1301     BDRVQcow2State *s = bs->opaque;
1302     unsigned int len, i;
1303     int ret = 0;
1304     QCowHeader header;
1305     uint64_t ext_end;
1306     uint64_t l1_vm_state_index;
1307     bool update_header = false;
1308 
1309     ret = bdrv_pread(bs->file, 0, &header, sizeof(header));
1310     if (ret < 0) {
1311         error_setg_errno(errp, -ret, "Could not read qcow2 header");
1312         goto fail;
1313     }
1314     header.magic = be32_to_cpu(header.magic);
1315     header.version = be32_to_cpu(header.version);
1316     header.backing_file_offset = be64_to_cpu(header.backing_file_offset);
1317     header.backing_file_size = be32_to_cpu(header.backing_file_size);
1318     header.size = be64_to_cpu(header.size);
1319     header.cluster_bits = be32_to_cpu(header.cluster_bits);
1320     header.crypt_method = be32_to_cpu(header.crypt_method);
1321     header.l1_table_offset = be64_to_cpu(header.l1_table_offset);
1322     header.l1_size = be32_to_cpu(header.l1_size);
1323     header.refcount_table_offset = be64_to_cpu(header.refcount_table_offset);
1324     header.refcount_table_clusters =
1325         be32_to_cpu(header.refcount_table_clusters);
1326     header.snapshots_offset = be64_to_cpu(header.snapshots_offset);
1327     header.nb_snapshots = be32_to_cpu(header.nb_snapshots);
1328 
1329     if (header.magic != QCOW_MAGIC) {
1330         error_setg(errp, "Image is not in qcow2 format");
1331         ret = -EINVAL;
1332         goto fail;
1333     }
1334     if (header.version < 2 || header.version > 3) {
1335         error_setg(errp, "Unsupported qcow2 version %" PRIu32, header.version);
1336         ret = -ENOTSUP;
1337         goto fail;
1338     }
1339 
1340     s->qcow_version = header.version;
1341 
1342     /* Initialise cluster size */
1343     if (header.cluster_bits < MIN_CLUSTER_BITS ||
1344         header.cluster_bits > MAX_CLUSTER_BITS) {
1345         error_setg(errp, "Unsupported cluster size: 2^%" PRIu32,
1346                    header.cluster_bits);
1347         ret = -EINVAL;
1348         goto fail;
1349     }
1350 
1351     s->cluster_bits = header.cluster_bits;
1352     s->cluster_size = 1 << s->cluster_bits;
1353 
1354     /* Initialise version 3 header fields */
1355     if (header.version == 2) {
1356         header.incompatible_features    = 0;
1357         header.compatible_features      = 0;
1358         header.autoclear_features       = 0;
1359         header.refcount_order           = 4;
1360         header.header_length            = 72;
1361     } else {
1362         header.incompatible_features =
1363             be64_to_cpu(header.incompatible_features);
1364         header.compatible_features = be64_to_cpu(header.compatible_features);
1365         header.autoclear_features = be64_to_cpu(header.autoclear_features);
1366         header.refcount_order = be32_to_cpu(header.refcount_order);
1367         header.header_length = be32_to_cpu(header.header_length);
1368 
1369         if (header.header_length < 104) {
1370             error_setg(errp, "qcow2 header too short");
1371             ret = -EINVAL;
1372             goto fail;
1373         }
1374     }
1375 
1376     if (header.header_length > s->cluster_size) {
1377         error_setg(errp, "qcow2 header exceeds cluster size");
1378         ret = -EINVAL;
1379         goto fail;
1380     }
1381 
1382     if (header.header_length > sizeof(header)) {
1383         s->unknown_header_fields_size = header.header_length - sizeof(header);
1384         s->unknown_header_fields = g_malloc(s->unknown_header_fields_size);
1385         ret = bdrv_pread(bs->file, sizeof(header), s->unknown_header_fields,
1386                          s->unknown_header_fields_size);
1387         if (ret < 0) {
1388             error_setg_errno(errp, -ret, "Could not read unknown qcow2 header "
1389                              "fields");
1390             goto fail;
1391         }
1392     }
1393 
1394     if (header.backing_file_offset > s->cluster_size) {
1395         error_setg(errp, "Invalid backing file offset");
1396         ret = -EINVAL;
1397         goto fail;
1398     }
1399 
1400     if (header.backing_file_offset) {
1401         ext_end = header.backing_file_offset;
1402     } else {
1403         ext_end = 1 << header.cluster_bits;
1404     }
1405 
1406     /* Handle feature bits */
1407     s->incompatible_features    = header.incompatible_features;
1408     s->compatible_features      = header.compatible_features;
1409     s->autoclear_features       = header.autoclear_features;
1410 
1411     /*
1412      * Handle compression type
1413      * Older qcow2 images don't contain the compression type header.
1414      * Distinguish them by the header length and use
1415      * the only valid (default) compression type in that case
1416      */
1417     if (header.header_length > offsetof(QCowHeader, compression_type)) {
1418         s->compression_type = header.compression_type;
1419     } else {
1420         s->compression_type = QCOW2_COMPRESSION_TYPE_ZLIB;
1421     }
1422 
1423     ret = validate_compression_type(s, errp);
1424     if (ret) {
1425         goto fail;
1426     }
1427 
1428     if (s->incompatible_features & ~QCOW2_INCOMPAT_MASK) {
1429         void *feature_table = NULL;
1430         qcow2_read_extensions(bs, header.header_length, ext_end,
1431                               &feature_table, flags, NULL, NULL);
1432         report_unsupported_feature(errp, feature_table,
1433                                    s->incompatible_features &
1434                                    ~QCOW2_INCOMPAT_MASK);
1435         ret = -ENOTSUP;
1436         g_free(feature_table);
1437         goto fail;
1438     }
1439 
1440     if (s->incompatible_features & QCOW2_INCOMPAT_CORRUPT) {
1441         /* Corrupt images may not be written to unless they are being repaired
1442          */
1443         if ((flags & BDRV_O_RDWR) && !(flags & BDRV_O_CHECK)) {
1444             error_setg(errp, "qcow2: Image is corrupt; cannot be opened "
1445                        "read/write");
1446             ret = -EACCES;
1447             goto fail;
1448         }
1449     }
1450 
1451     s->subclusters_per_cluster =
1452         has_subclusters(s) ? QCOW_EXTL2_SUBCLUSTERS_PER_CLUSTER : 1;
1453     s->subcluster_size = s->cluster_size / s->subclusters_per_cluster;
1454     s->subcluster_bits = ctz32(s->subcluster_size);
1455 
1456     if (s->subcluster_size < (1 << MIN_CLUSTER_BITS)) {
1457         error_setg(errp, "Unsupported subcluster size: %d", s->subcluster_size);
1458         ret = -EINVAL;
1459         goto fail;
1460     }
1461 
1462     /* Check support for various header values */
1463     if (header.refcount_order > 6) {
1464         error_setg(errp, "Reference count entry width too large; may not "
1465                    "exceed 64 bits");
1466         ret = -EINVAL;
1467         goto fail;
1468     }
1469     s->refcount_order = header.refcount_order;
1470     s->refcount_bits = 1 << s->refcount_order;
1471     s->refcount_max = UINT64_C(1) << (s->refcount_bits - 1);
1472     s->refcount_max += s->refcount_max - 1;
1473 
1474     s->crypt_method_header = header.crypt_method;
1475     if (s->crypt_method_header) {
1476         if (bdrv_uses_whitelist() &&
1477             s->crypt_method_header == QCOW_CRYPT_AES) {
1478             error_setg(errp,
1479                        "Use of AES-CBC encrypted qcow2 images is no longer "
1480                        "supported in system emulators");
1481             error_append_hint(errp,
1482                               "You can use 'qemu-img convert' to convert your "
1483                               "image to an alternative supported format, such "
1484                               "as unencrypted qcow2, or raw with the LUKS "
1485                               "format instead.\n");
1486             ret = -ENOSYS;
1487             goto fail;
1488         }
1489 
1490         if (s->crypt_method_header == QCOW_CRYPT_AES) {
1491             s->crypt_physical_offset = false;
1492         } else {
1493             /* Assuming LUKS and any future crypt methods we
1494              * add will all use physical offsets, due to the
1495              * fact that the alternative is insecure...  */
1496             s->crypt_physical_offset = true;
1497         }
1498 
1499         bs->encrypted = true;
1500     }
1501 
1502     s->l2_bits = s->cluster_bits - ctz32(l2_entry_size(s));
1503     s->l2_size = 1 << s->l2_bits;
1504     /* 2^(s->refcount_order - 3) is the refcount width in bytes */
1505     s->refcount_block_bits = s->cluster_bits - (s->refcount_order - 3);
1506     s->refcount_block_size = 1 << s->refcount_block_bits;
1507     bs->total_sectors = header.size / BDRV_SECTOR_SIZE;
1508     s->csize_shift = (62 - (s->cluster_bits - 8));
1509     s->csize_mask = (1 << (s->cluster_bits - 8)) - 1;
1510     s->cluster_offset_mask = (1LL << s->csize_shift) - 1;
1511 
1512     s->refcount_table_offset = header.refcount_table_offset;
1513     s->refcount_table_size =
1514         header.refcount_table_clusters << (s->cluster_bits - 3);
1515 
1516     if (header.refcount_table_clusters == 0 && !(flags & BDRV_O_CHECK)) {
1517         error_setg(errp, "Image does not contain a reference count table");
1518         ret = -EINVAL;
1519         goto fail;
1520     }
1521 
1522     ret = qcow2_validate_table(bs, s->refcount_table_offset,
1523                                header.refcount_table_clusters,
1524                                s->cluster_size, QCOW_MAX_REFTABLE_SIZE,
1525                                "Reference count table", errp);
1526     if (ret < 0) {
1527         goto fail;
1528     }
1529 
1530     if (!(flags & BDRV_O_CHECK)) {
1531         /*
1532          * The total size in bytes of the snapshot table is checked in
1533          * qcow2_read_snapshots() because the size of each snapshot is
1534          * variable and we don't know it yet.
1535          * Here we only check the offset and number of snapshots.
1536          */
1537         ret = qcow2_validate_table(bs, header.snapshots_offset,
1538                                    header.nb_snapshots,
1539                                    sizeof(QCowSnapshotHeader),
1540                                    sizeof(QCowSnapshotHeader) *
1541                                        QCOW_MAX_SNAPSHOTS,
1542                                    "Snapshot table", errp);
1543         if (ret < 0) {
1544             goto fail;
1545         }
1546     }
1547 
1548     /* read the level 1 table */
1549     ret = qcow2_validate_table(bs, header.l1_table_offset,
1550                                header.l1_size, L1E_SIZE,
1551                                QCOW_MAX_L1_SIZE, "Active L1 table", errp);
1552     if (ret < 0) {
1553         goto fail;
1554     }
1555     s->l1_size = header.l1_size;
1556     s->l1_table_offset = header.l1_table_offset;
1557 
1558     l1_vm_state_index = size_to_l1(s, header.size);
1559     if (l1_vm_state_index > INT_MAX) {
1560         error_setg(errp, "Image is too big");
1561         ret = -EFBIG;
1562         goto fail;
1563     }
1564     s->l1_vm_state_index = l1_vm_state_index;
1565 
1566     /* the L1 table must contain at least enough entries to put
1567        header.size bytes */
1568     if (s->l1_size < s->l1_vm_state_index) {
1569         error_setg(errp, "L1 table is too small");
1570         ret = -EINVAL;
1571         goto fail;
1572     }
1573 
1574     if (s->l1_size > 0) {
1575         s->l1_table = qemu_try_blockalign(bs->file->bs, s->l1_size * L1E_SIZE);
1576         if (s->l1_table == NULL) {
1577             error_setg(errp, "Could not allocate L1 table");
1578             ret = -ENOMEM;
1579             goto fail;
1580         }
1581         ret = bdrv_pread(bs->file, s->l1_table_offset, s->l1_table,
1582                          s->l1_size * L1E_SIZE);
1583         if (ret < 0) {
1584             error_setg_errno(errp, -ret, "Could not read L1 table");
1585             goto fail;
1586         }
1587         for(i = 0;i < s->l1_size; i++) {
1588             s->l1_table[i] = be64_to_cpu(s->l1_table[i]);
1589         }
1590     }
1591 
1592     /* Parse driver-specific options */
1593     ret = qcow2_update_options(bs, options, flags, errp);
1594     if (ret < 0) {
1595         goto fail;
1596     }
1597 
1598     s->flags = flags;
1599 
1600     ret = qcow2_refcount_init(bs);
1601     if (ret != 0) {
1602         error_setg_errno(errp, -ret, "Could not initialize refcount handling");
1603         goto fail;
1604     }
1605 
1606     QLIST_INIT(&s->cluster_allocs);
1607     QTAILQ_INIT(&s->discards);
1608 
1609     /* read qcow2 extensions */
1610     if (qcow2_read_extensions(bs, header.header_length, ext_end, NULL,
1611                               flags, &update_header, errp)) {
1612         ret = -EINVAL;
1613         goto fail;
1614     }
1615 
1616     /* Open external data file */
1617     s->data_file = bdrv_open_child(NULL, options, "data-file", bs,
1618                                    &child_of_bds, BDRV_CHILD_DATA,
1619                                    true, errp);
1620     if (*errp) {
1621         ret = -EINVAL;
1622         goto fail;
1623     }
1624 
1625     if (s->incompatible_features & QCOW2_INCOMPAT_DATA_FILE) {
1626         if (!s->data_file && s->image_data_file) {
1627             s->data_file = bdrv_open_child(s->image_data_file, options,
1628                                            "data-file", bs, &child_of_bds,
1629                                            BDRV_CHILD_DATA, false, errp);
1630             if (!s->data_file) {
1631                 ret = -EINVAL;
1632                 goto fail;
1633             }
1634         }
1635         if (!s->data_file) {
1636             error_setg(errp, "'data-file' is required for this image");
1637             ret = -EINVAL;
1638             goto fail;
1639         }
1640 
1641         /* No data here */
1642         bs->file->role &= ~BDRV_CHILD_DATA;
1643 
1644         /* Must succeed because we have given up permissions if anything */
1645         bdrv_child_refresh_perms(bs, bs->file, &error_abort);
1646     } else {
1647         if (s->data_file) {
1648             error_setg(errp, "'data-file' can only be set for images with an "
1649                              "external data file");
1650             ret = -EINVAL;
1651             goto fail;
1652         }
1653 
1654         s->data_file = bs->file;
1655 
1656         if (data_file_is_raw(bs)) {
1657             error_setg(errp, "data-file-raw requires a data file");
1658             ret = -EINVAL;
1659             goto fail;
1660         }
1661     }
1662 
1663     /* qcow2_read_extension may have set up the crypto context
1664      * if the crypt method needs a header region, some methods
1665      * don't need header extensions, so must check here
1666      */
1667     if (s->crypt_method_header && !s->crypto) {
1668         if (s->crypt_method_header == QCOW_CRYPT_AES) {
1669             unsigned int cflags = 0;
1670             if (flags & BDRV_O_NO_IO) {
1671                 cflags |= QCRYPTO_BLOCK_OPEN_NO_IO;
1672             }
1673             s->crypto = qcrypto_block_open(s->crypto_opts, "encrypt.",
1674                                            NULL, NULL, cflags,
1675                                            QCOW2_MAX_THREADS, errp);
1676             if (!s->crypto) {
1677                 ret = -EINVAL;
1678                 goto fail;
1679             }
1680         } else if (!(flags & BDRV_O_NO_IO)) {
1681             error_setg(errp, "Missing CRYPTO header for crypt method %d",
1682                        s->crypt_method_header);
1683             ret = -EINVAL;
1684             goto fail;
1685         }
1686     }
1687 
1688     /* read the backing file name */
1689     if (header.backing_file_offset != 0) {
1690         len = header.backing_file_size;
1691         if (len > MIN(1023, s->cluster_size - header.backing_file_offset) ||
1692             len >= sizeof(bs->backing_file)) {
1693             error_setg(errp, "Backing file name too long");
1694             ret = -EINVAL;
1695             goto fail;
1696         }
1697         ret = bdrv_pread(bs->file, header.backing_file_offset,
1698                          bs->auto_backing_file, len);
1699         if (ret < 0) {
1700             error_setg_errno(errp, -ret, "Could not read backing file name");
1701             goto fail;
1702         }
1703         bs->auto_backing_file[len] = '\0';
1704         pstrcpy(bs->backing_file, sizeof(bs->backing_file),
1705                 bs->auto_backing_file);
1706         s->image_backing_file = g_strdup(bs->auto_backing_file);
1707     }
1708 
1709     /*
1710      * Internal snapshots; skip reading them in check mode, because
1711      * we do not need them then, and we do not want to abort because
1712      * of a broken table.
1713      */
1714     if (!(flags & BDRV_O_CHECK)) {
1715         s->snapshots_offset = header.snapshots_offset;
1716         s->nb_snapshots = header.nb_snapshots;
1717 
1718         ret = qcow2_read_snapshots(bs, errp);
1719         if (ret < 0) {
1720             goto fail;
1721         }
1722     }
1723 
1724     /* Clear unknown autoclear feature bits */
1725     update_header |= s->autoclear_features & ~QCOW2_AUTOCLEAR_MASK;
1726     update_header = update_header && bdrv_is_writable(bs);
1727     if (update_header) {
1728         s->autoclear_features &= QCOW2_AUTOCLEAR_MASK;
1729     }
1730 
1731     /* == Handle persistent dirty bitmaps ==
1732      *
1733      * We want load dirty bitmaps in three cases:
1734      *
1735      * 1. Normal open of the disk in active mode, not related to invalidation
1736      *    after migration.
1737      *
1738      * 2. Invalidation of the target vm after pre-copy phase of migration, if
1739      *    bitmaps are _not_ migrating through migration channel, i.e.
1740      *    'dirty-bitmaps' capability is disabled.
1741      *
1742      * 3. Invalidation of source vm after failed or canceled migration.
1743      *    This is a very interesting case. There are two possible types of
1744      *    bitmaps:
1745      *
1746      *    A. Stored on inactivation and removed. They should be loaded from the
1747      *       image.
1748      *
1749      *    B. Not stored: not-persistent bitmaps and bitmaps, migrated through
1750      *       the migration channel (with dirty-bitmaps capability).
1751      *
1752      *    On the other hand, there are two possible sub-cases:
1753      *
1754      *    3.1 disk was changed by somebody else while were inactive. In this
1755      *        case all in-RAM dirty bitmaps (both persistent and not) are
1756      *        definitely invalid. And we don't have any method to determine
1757      *        this.
1758      *
1759      *        Simple and safe thing is to just drop all the bitmaps of type B on
1760      *        inactivation. But in this case we lose bitmaps in valid 4.2 case.
1761      *
1762      *        On the other hand, resuming source vm, if disk was already changed
1763      *        is a bad thing anyway: not only bitmaps, the whole vm state is
1764      *        out of sync with disk.
1765      *
1766      *        This means, that user or management tool, who for some reason
1767      *        decided to resume source vm, after disk was already changed by
1768      *        target vm, should at least drop all dirty bitmaps by hand.
1769      *
1770      *        So, we can ignore this case for now, but TODO: "generation"
1771      *        extension for qcow2, to determine, that image was changed after
1772      *        last inactivation. And if it is changed, we will drop (or at least
1773      *        mark as 'invalid' all the bitmaps of type B, both persistent
1774      *        and not).
1775      *
1776      *    3.2 disk was _not_ changed while were inactive. Bitmaps may be saved
1777      *        to disk ('dirty-bitmaps' capability disabled), or not saved
1778      *        ('dirty-bitmaps' capability enabled), but we don't need to care
1779      *        of: let's load bitmaps as always: stored bitmaps will be loaded,
1780      *        and not stored has flag IN_USE=1 in the image and will be skipped
1781      *        on loading.
1782      *
1783      * One remaining possible case when we don't want load bitmaps:
1784      *
1785      * 4. Open disk in inactive mode in target vm (bitmaps are migrating or
1786      *    will be loaded on invalidation, no needs try loading them before)
1787      */
1788 
1789     if (!(bdrv_get_flags(bs) & BDRV_O_INACTIVE)) {
1790         /* It's case 1, 2 or 3.2. Or 3.1 which is BUG in management layer. */
1791         bool header_updated;
1792         if (!qcow2_load_dirty_bitmaps(bs, &header_updated, errp)) {
1793             ret = -EINVAL;
1794             goto fail;
1795         }
1796 
1797         update_header = update_header && !header_updated;
1798     }
1799 
1800     if (update_header) {
1801         ret = qcow2_update_header(bs);
1802         if (ret < 0) {
1803             error_setg_errno(errp, -ret, "Could not update qcow2 header");
1804             goto fail;
1805         }
1806     }
1807 
1808     bs->supported_zero_flags = header.version >= 3 ?
1809                                BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK : 0;
1810     bs->supported_truncate_flags = BDRV_REQ_ZERO_WRITE;
1811 
1812     /* Repair image if dirty */
1813     if (!(flags & BDRV_O_CHECK) && bdrv_is_writable(bs) &&
1814         (s->incompatible_features & QCOW2_INCOMPAT_DIRTY)) {
1815         BdrvCheckResult result = {0};
1816 
1817         ret = qcow2_co_check_locked(bs, &result,
1818                                     BDRV_FIX_ERRORS | BDRV_FIX_LEAKS);
1819         if (ret < 0 || result.check_errors) {
1820             if (ret >= 0) {
1821                 ret = -EIO;
1822             }
1823             error_setg_errno(errp, -ret, "Could not repair dirty image");
1824             goto fail;
1825         }
1826     }
1827 
1828 #ifdef DEBUG_ALLOC
1829     {
1830         BdrvCheckResult result = {0};
1831         qcow2_check_refcounts(bs, &result, 0);
1832     }
1833 #endif
1834 
1835     qemu_co_queue_init(&s->thread_task_queue);
1836 
1837     return ret;
1838 
1839  fail:
1840     g_free(s->image_data_file);
1841     if (has_data_file(bs)) {
1842         bdrv_unref_child(bs, s->data_file);
1843         s->data_file = NULL;
1844     }
1845     g_free(s->unknown_header_fields);
1846     cleanup_unknown_header_ext(bs);
1847     qcow2_free_snapshots(bs);
1848     qcow2_refcount_close(bs);
1849     qemu_vfree(s->l1_table);
1850     /* else pre-write overlap checks in cache_destroy may crash */
1851     s->l1_table = NULL;
1852     cache_clean_timer_del(bs);
1853     if (s->l2_table_cache) {
1854         qcow2_cache_destroy(s->l2_table_cache);
1855     }
1856     if (s->refcount_block_cache) {
1857         qcow2_cache_destroy(s->refcount_block_cache);
1858     }
1859     qcrypto_block_free(s->crypto);
1860     qapi_free_QCryptoBlockOpenOptions(s->crypto_opts);
1861     return ret;
1862 }
1863 
1864 typedef struct QCow2OpenCo {
1865     BlockDriverState *bs;
1866     QDict *options;
1867     int flags;
1868     Error **errp;
1869     int ret;
1870 } QCow2OpenCo;
1871 
qcow2_open_entry(void * opaque)1872 static void coroutine_fn qcow2_open_entry(void *opaque)
1873 {
1874     QCow2OpenCo *qoc = opaque;
1875     BDRVQcow2State *s = qoc->bs->opaque;
1876 
1877     qemu_co_mutex_lock(&s->lock);
1878     qoc->ret = qcow2_do_open(qoc->bs, qoc->options, qoc->flags, qoc->errp);
1879     qemu_co_mutex_unlock(&s->lock);
1880 }
1881 
qcow2_open(BlockDriverState * bs,QDict * options,int flags,Error ** errp)1882 static int qcow2_open(BlockDriverState *bs, QDict *options, int flags,
1883                       Error **errp)
1884 {
1885     BDRVQcow2State *s = bs->opaque;
1886     QCow2OpenCo qoc = {
1887         .bs = bs,
1888         .options = options,
1889         .flags = flags,
1890         .errp = errp,
1891         .ret = -EINPROGRESS
1892     };
1893 
1894     bs->file = bdrv_open_child(NULL, options, "file", bs, &child_of_bds,
1895                                BDRV_CHILD_IMAGE, false, errp);
1896     if (!bs->file) {
1897         return -EINVAL;
1898     }
1899 
1900     /* Initialise locks */
1901     qemu_co_mutex_init(&s->lock);
1902 
1903     if (qemu_in_coroutine()) {
1904         /* From bdrv_co_create.  */
1905         qcow2_open_entry(&qoc);
1906     } else {
1907         assert(qemu_get_current_aio_context() == qemu_get_aio_context());
1908         qemu_coroutine_enter(qemu_coroutine_create(qcow2_open_entry, &qoc));
1909         BDRV_POLL_WHILE(bs, qoc.ret == -EINPROGRESS);
1910     }
1911     return qoc.ret;
1912 }
1913 
qcow2_refresh_limits(BlockDriverState * bs,Error ** errp)1914 static void qcow2_refresh_limits(BlockDriverState *bs, Error **errp)
1915 {
1916     BDRVQcow2State *s = bs->opaque;
1917 
1918     if (bs->encrypted) {
1919         /* Encryption works on a sector granularity */
1920         bs->bl.request_alignment = qcrypto_block_get_sector_size(s->crypto);
1921     }
1922     bs->bl.pwrite_zeroes_alignment = s->subcluster_size;
1923     bs->bl.pdiscard_alignment = s->cluster_size;
1924 }
1925 
qcow2_reopen_prepare(BDRVReopenState * state,BlockReopenQueue * queue,Error ** errp)1926 static int qcow2_reopen_prepare(BDRVReopenState *state,
1927                                 BlockReopenQueue *queue, Error **errp)
1928 {
1929     BDRVQcow2State *s = state->bs->opaque;
1930     Qcow2ReopenState *r;
1931     int ret;
1932 
1933     r = g_new0(Qcow2ReopenState, 1);
1934     state->opaque = r;
1935 
1936     ret = qcow2_update_options_prepare(state->bs, r, state->options,
1937                                        state->flags, errp);
1938     if (ret < 0) {
1939         goto fail;
1940     }
1941 
1942     /* We need to write out any unwritten data if we reopen read-only. */
1943     if ((state->flags & BDRV_O_RDWR) == 0) {
1944         ret = qcow2_reopen_bitmaps_ro(state->bs, errp);
1945         if (ret < 0) {
1946             goto fail;
1947         }
1948 
1949         ret = bdrv_flush(state->bs);
1950         if (ret < 0) {
1951             goto fail;
1952         }
1953 
1954         ret = qcow2_mark_clean(state->bs);
1955         if (ret < 0) {
1956             goto fail;
1957         }
1958     }
1959 
1960     /*
1961      * Without an external data file, s->data_file points to the same BdrvChild
1962      * as bs->file. It needs to be resynced after reopen because bs->file may
1963      * be changed. We can't use it in the meantime.
1964      */
1965     if (!has_data_file(state->bs)) {
1966         assert(s->data_file == state->bs->file);
1967         s->data_file = NULL;
1968     }
1969 
1970     return 0;
1971 
1972 fail:
1973     qcow2_update_options_abort(state->bs, r);
1974     g_free(r);
1975     return ret;
1976 }
1977 
qcow2_reopen_commit(BDRVReopenState * state)1978 static void qcow2_reopen_commit(BDRVReopenState *state)
1979 {
1980     BDRVQcow2State *s = state->bs->opaque;
1981 
1982     qcow2_update_options_commit(state->bs, state->opaque);
1983     if (!s->data_file) {
1984         /*
1985          * If we don't have an external data file, s->data_file was cleared by
1986          * qcow2_reopen_prepare() and needs to be updated.
1987          */
1988         s->data_file = state->bs->file;
1989     }
1990     g_free(state->opaque);
1991 }
1992 
qcow2_reopen_commit_post(BDRVReopenState * state)1993 static void qcow2_reopen_commit_post(BDRVReopenState *state)
1994 {
1995     if (state->flags & BDRV_O_RDWR) {
1996         Error *local_err = NULL;
1997 
1998         if (qcow2_reopen_bitmaps_rw(state->bs, &local_err) < 0) {
1999             /*
2000              * This is not fatal, bitmaps just left read-only, so all following
2001              * writes will fail. User can remove read-only bitmaps to unblock
2002              * writes or retry reopen.
2003              */
2004             error_reportf_err(local_err,
2005                               "%s: Failed to make dirty bitmaps writable: ",
2006                               bdrv_get_node_name(state->bs));
2007         }
2008     }
2009 }
2010 
qcow2_reopen_abort(BDRVReopenState * state)2011 static void qcow2_reopen_abort(BDRVReopenState *state)
2012 {
2013     BDRVQcow2State *s = state->bs->opaque;
2014 
2015     if (!s->data_file) {
2016         /*
2017          * If we don't have an external data file, s->data_file was cleared by
2018          * qcow2_reopen_prepare() and needs to be restored.
2019          */
2020         s->data_file = state->bs->file;
2021     }
2022     qcow2_update_options_abort(state->bs, state->opaque);
2023     g_free(state->opaque);
2024 }
2025 
qcow2_join_options(QDict * options,QDict * old_options)2026 static void qcow2_join_options(QDict *options, QDict *old_options)
2027 {
2028     bool has_new_overlap_template =
2029         qdict_haskey(options, QCOW2_OPT_OVERLAP) ||
2030         qdict_haskey(options, QCOW2_OPT_OVERLAP_TEMPLATE);
2031     bool has_new_total_cache_size =
2032         qdict_haskey(options, QCOW2_OPT_CACHE_SIZE);
2033     bool has_all_cache_options;
2034 
2035     /* New overlap template overrides all old overlap options */
2036     if (has_new_overlap_template) {
2037         qdict_del(old_options, QCOW2_OPT_OVERLAP);
2038         qdict_del(old_options, QCOW2_OPT_OVERLAP_TEMPLATE);
2039         qdict_del(old_options, QCOW2_OPT_OVERLAP_MAIN_HEADER);
2040         qdict_del(old_options, QCOW2_OPT_OVERLAP_ACTIVE_L1);
2041         qdict_del(old_options, QCOW2_OPT_OVERLAP_ACTIVE_L2);
2042         qdict_del(old_options, QCOW2_OPT_OVERLAP_REFCOUNT_TABLE);
2043         qdict_del(old_options, QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK);
2044         qdict_del(old_options, QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE);
2045         qdict_del(old_options, QCOW2_OPT_OVERLAP_INACTIVE_L1);
2046         qdict_del(old_options, QCOW2_OPT_OVERLAP_INACTIVE_L2);
2047     }
2048 
2049     /* New total cache size overrides all old options */
2050     if (qdict_haskey(options, QCOW2_OPT_CACHE_SIZE)) {
2051         qdict_del(old_options, QCOW2_OPT_L2_CACHE_SIZE);
2052         qdict_del(old_options, QCOW2_OPT_REFCOUNT_CACHE_SIZE);
2053     }
2054 
2055     qdict_join(options, old_options, false);
2056 
2057     /*
2058      * If after merging all cache size options are set, an old total size is
2059      * overwritten. Do keep all options, however, if all three are new. The
2060      * resulting error message is what we want to happen.
2061      */
2062     has_all_cache_options =
2063         qdict_haskey(options, QCOW2_OPT_CACHE_SIZE) ||
2064         qdict_haskey(options, QCOW2_OPT_L2_CACHE_SIZE) ||
2065         qdict_haskey(options, QCOW2_OPT_REFCOUNT_CACHE_SIZE);
2066 
2067     if (has_all_cache_options && !has_new_total_cache_size) {
2068         qdict_del(options, QCOW2_OPT_CACHE_SIZE);
2069     }
2070 }
2071 
qcow2_co_block_status(BlockDriverState * bs,bool want_zero,int64_t offset,int64_t count,int64_t * pnum,int64_t * map,BlockDriverState ** file)2072 static int coroutine_fn qcow2_co_block_status(BlockDriverState *bs,
2073                                               bool want_zero,
2074                                               int64_t offset, int64_t count,
2075                                               int64_t *pnum, int64_t *map,
2076                                               BlockDriverState **file)
2077 {
2078     BDRVQcow2State *s = bs->opaque;
2079     uint64_t host_offset;
2080     unsigned int bytes;
2081     QCow2SubclusterType type;
2082     int ret, status = 0;
2083 
2084     qemu_co_mutex_lock(&s->lock);
2085 
2086     if (!s->metadata_preallocation_checked) {
2087         ret = qcow2_detect_metadata_preallocation(bs);
2088         s->metadata_preallocation = (ret == 1);
2089         s->metadata_preallocation_checked = true;
2090     }
2091 
2092     bytes = MIN(INT_MAX, count);
2093     ret = qcow2_get_host_offset(bs, offset, &bytes, &host_offset, &type);
2094     qemu_co_mutex_unlock(&s->lock);
2095     if (ret < 0) {
2096         return ret;
2097     }
2098 
2099     *pnum = bytes;
2100 
2101     if ((type == QCOW2_SUBCLUSTER_NORMAL ||
2102          type == QCOW2_SUBCLUSTER_ZERO_ALLOC ||
2103          type == QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC) && !s->crypto) {
2104         *map = host_offset;
2105         *file = s->data_file->bs;
2106         status |= BDRV_BLOCK_OFFSET_VALID;
2107     }
2108     if (type == QCOW2_SUBCLUSTER_ZERO_PLAIN ||
2109         type == QCOW2_SUBCLUSTER_ZERO_ALLOC) {
2110         status |= BDRV_BLOCK_ZERO;
2111     } else if (type != QCOW2_SUBCLUSTER_UNALLOCATED_PLAIN &&
2112                type != QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC) {
2113         status |= BDRV_BLOCK_DATA;
2114     }
2115     if (s->metadata_preallocation && (status & BDRV_BLOCK_DATA) &&
2116         (status & BDRV_BLOCK_OFFSET_VALID))
2117     {
2118         status |= BDRV_BLOCK_RECURSE;
2119     }
2120     return status;
2121 }
2122 
qcow2_handle_l2meta(BlockDriverState * bs,QCowL2Meta ** pl2meta,bool link_l2)2123 static coroutine_fn int qcow2_handle_l2meta(BlockDriverState *bs,
2124                                             QCowL2Meta **pl2meta,
2125                                             bool link_l2)
2126 {
2127     int ret = 0;
2128     QCowL2Meta *l2meta = *pl2meta;
2129 
2130     while (l2meta != NULL) {
2131         QCowL2Meta *next;
2132 
2133         if (link_l2) {
2134             ret = qcow2_alloc_cluster_link_l2(bs, l2meta);
2135             if (ret) {
2136                 goto out;
2137             }
2138         } else {
2139             qcow2_alloc_cluster_abort(bs, l2meta);
2140         }
2141 
2142         /* Take the request off the list of running requests */
2143         QLIST_REMOVE(l2meta, next_in_flight);
2144 
2145         qemu_co_queue_restart_all(&l2meta->dependent_requests);
2146 
2147         next = l2meta->next;
2148         g_free(l2meta);
2149         l2meta = next;
2150     }
2151 out:
2152     *pl2meta = l2meta;
2153     return ret;
2154 }
2155 
2156 static coroutine_fn int
qcow2_co_preadv_encrypted(BlockDriverState * bs,uint64_t host_offset,uint64_t offset,uint64_t bytes,QEMUIOVector * qiov,uint64_t qiov_offset)2157 qcow2_co_preadv_encrypted(BlockDriverState *bs,
2158                            uint64_t host_offset,
2159                            uint64_t offset,
2160                            uint64_t bytes,
2161                            QEMUIOVector *qiov,
2162                            uint64_t qiov_offset)
2163 {
2164     int ret;
2165     BDRVQcow2State *s = bs->opaque;
2166     uint8_t *buf;
2167 
2168     assert(bs->encrypted && s->crypto);
2169     assert(bytes <= QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size);
2170 
2171     /*
2172      * For encrypted images, read everything into a temporary
2173      * contiguous buffer on which the AES functions can work.
2174      * Also, decryption in a separate buffer is better as it
2175      * prevents the guest from learning information about the
2176      * encrypted nature of the virtual disk.
2177      */
2178 
2179     buf = qemu_try_blockalign(s->data_file->bs, bytes);
2180     if (buf == NULL) {
2181         return -ENOMEM;
2182     }
2183 
2184     BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO);
2185     ret = bdrv_co_pread(s->data_file, host_offset, bytes, buf, 0);
2186     if (ret < 0) {
2187         goto fail;
2188     }
2189 
2190     if (qcow2_co_decrypt(bs, host_offset, offset, buf, bytes) < 0)
2191     {
2192         ret = -EIO;
2193         goto fail;
2194     }
2195     qemu_iovec_from_buf(qiov, qiov_offset, buf, bytes);
2196 
2197 fail:
2198     qemu_vfree(buf);
2199 
2200     return ret;
2201 }
2202 
2203 typedef struct Qcow2AioTask {
2204     AioTask task;
2205 
2206     BlockDriverState *bs;
2207     QCow2SubclusterType subcluster_type; /* only for read */
2208     uint64_t host_offset; /* or l2_entry for compressed read */
2209     uint64_t offset;
2210     uint64_t bytes;
2211     QEMUIOVector *qiov;
2212     uint64_t qiov_offset;
2213     QCowL2Meta *l2meta; /* only for write */
2214 } Qcow2AioTask;
2215 
2216 static coroutine_fn int qcow2_co_preadv_task_entry(AioTask *task);
qcow2_add_task(BlockDriverState * bs,AioTaskPool * pool,AioTaskFunc func,QCow2SubclusterType subcluster_type,uint64_t host_offset,uint64_t offset,uint64_t bytes,QEMUIOVector * qiov,size_t qiov_offset,QCowL2Meta * l2meta)2217 static coroutine_fn int qcow2_add_task(BlockDriverState *bs,
2218                                        AioTaskPool *pool,
2219                                        AioTaskFunc func,
2220                                        QCow2SubclusterType subcluster_type,
2221                                        uint64_t host_offset,
2222                                        uint64_t offset,
2223                                        uint64_t bytes,
2224                                        QEMUIOVector *qiov,
2225                                        size_t qiov_offset,
2226                                        QCowL2Meta *l2meta)
2227 {
2228     Qcow2AioTask local_task;
2229     Qcow2AioTask *task = pool ? g_new(Qcow2AioTask, 1) : &local_task;
2230 
2231     *task = (Qcow2AioTask) {
2232         .task.func = func,
2233         .bs = bs,
2234         .subcluster_type = subcluster_type,
2235         .qiov = qiov,
2236         .host_offset = host_offset,
2237         .offset = offset,
2238         .bytes = bytes,
2239         .qiov_offset = qiov_offset,
2240         .l2meta = l2meta,
2241     };
2242 
2243     trace_qcow2_add_task(qemu_coroutine_self(), bs, pool,
2244                          func == qcow2_co_preadv_task_entry ? "read" : "write",
2245                          subcluster_type, host_offset, offset, bytes,
2246                          qiov, qiov_offset);
2247 
2248     if (!pool) {
2249         return func(&task->task);
2250     }
2251 
2252     aio_task_pool_start_task(pool, &task->task);
2253 
2254     return 0;
2255 }
2256 
qcow2_co_preadv_task(BlockDriverState * bs,QCow2SubclusterType subc_type,uint64_t host_offset,uint64_t offset,uint64_t bytes,QEMUIOVector * qiov,size_t qiov_offset)2257 static coroutine_fn int qcow2_co_preadv_task(BlockDriverState *bs,
2258                                              QCow2SubclusterType subc_type,
2259                                              uint64_t host_offset,
2260                                              uint64_t offset, uint64_t bytes,
2261                                              QEMUIOVector *qiov,
2262                                              size_t qiov_offset)
2263 {
2264     BDRVQcow2State *s = bs->opaque;
2265 
2266     switch (subc_type) {
2267     case QCOW2_SUBCLUSTER_ZERO_PLAIN:
2268     case QCOW2_SUBCLUSTER_ZERO_ALLOC:
2269         /* Both zero types are handled in qcow2_co_preadv_part */
2270         g_assert_not_reached();
2271 
2272     case QCOW2_SUBCLUSTER_UNALLOCATED_PLAIN:
2273     case QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC:
2274         assert(bs->backing); /* otherwise handled in qcow2_co_preadv_part */
2275 
2276         BLKDBG_EVENT(bs->file, BLKDBG_READ_BACKING_AIO);
2277         return bdrv_co_preadv_part(bs->backing, offset, bytes,
2278                                    qiov, qiov_offset, 0);
2279 
2280     case QCOW2_SUBCLUSTER_COMPRESSED:
2281         return qcow2_co_preadv_compressed(bs, host_offset,
2282                                           offset, bytes, qiov, qiov_offset);
2283 
2284     case QCOW2_SUBCLUSTER_NORMAL:
2285         if (bs->encrypted) {
2286             return qcow2_co_preadv_encrypted(bs, host_offset,
2287                                              offset, bytes, qiov, qiov_offset);
2288         }
2289 
2290         BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO);
2291         return bdrv_co_preadv_part(s->data_file, host_offset,
2292                                    bytes, qiov, qiov_offset, 0);
2293 
2294     default:
2295         g_assert_not_reached();
2296     }
2297 
2298     g_assert_not_reached();
2299 }
2300 
qcow2_co_preadv_task_entry(AioTask * task)2301 static coroutine_fn int qcow2_co_preadv_task_entry(AioTask *task)
2302 {
2303     Qcow2AioTask *t = container_of(task, Qcow2AioTask, task);
2304 
2305     assert(!t->l2meta);
2306 
2307     return qcow2_co_preadv_task(t->bs, t->subcluster_type,
2308                                 t->host_offset, t->offset, t->bytes,
2309                                 t->qiov, t->qiov_offset);
2310 }
2311 
qcow2_co_preadv_part(BlockDriverState * bs,int64_t offset,int64_t bytes,QEMUIOVector * qiov,size_t qiov_offset,BdrvRequestFlags flags)2312 static coroutine_fn int qcow2_co_preadv_part(BlockDriverState *bs,
2313                                              int64_t offset, int64_t bytes,
2314                                              QEMUIOVector *qiov,
2315                                              size_t qiov_offset,
2316                                              BdrvRequestFlags flags)
2317 {
2318     BDRVQcow2State *s = bs->opaque;
2319     int ret = 0;
2320     unsigned int cur_bytes; /* number of bytes in current iteration */
2321     uint64_t host_offset = 0;
2322     QCow2SubclusterType type;
2323     AioTaskPool *aio = NULL;
2324 
2325     while (bytes != 0 && aio_task_pool_status(aio) == 0) {
2326         /* prepare next request */
2327         cur_bytes = MIN(bytes, INT_MAX);
2328         if (s->crypto) {
2329             cur_bytes = MIN(cur_bytes,
2330                             QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size);
2331         }
2332 
2333         qemu_co_mutex_lock(&s->lock);
2334         ret = qcow2_get_host_offset(bs, offset, &cur_bytes,
2335                                     &host_offset, &type);
2336         qemu_co_mutex_unlock(&s->lock);
2337         if (ret < 0) {
2338             goto out;
2339         }
2340 
2341         if (type == QCOW2_SUBCLUSTER_ZERO_PLAIN ||
2342             type == QCOW2_SUBCLUSTER_ZERO_ALLOC ||
2343             (type == QCOW2_SUBCLUSTER_UNALLOCATED_PLAIN && !bs->backing) ||
2344             (type == QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC && !bs->backing))
2345         {
2346             qemu_iovec_memset(qiov, qiov_offset, 0, cur_bytes);
2347         } else {
2348             if (!aio && cur_bytes != bytes) {
2349                 aio = aio_task_pool_new(QCOW2_MAX_WORKERS);
2350             }
2351             ret = qcow2_add_task(bs, aio, qcow2_co_preadv_task_entry, type,
2352                                  host_offset, offset, cur_bytes,
2353                                  qiov, qiov_offset, NULL);
2354             if (ret < 0) {
2355                 goto out;
2356             }
2357         }
2358 
2359         bytes -= cur_bytes;
2360         offset += cur_bytes;
2361         qiov_offset += cur_bytes;
2362     }
2363 
2364 out:
2365     if (aio) {
2366         aio_task_pool_wait_all(aio);
2367         if (ret == 0) {
2368             ret = aio_task_pool_status(aio);
2369         }
2370         g_free(aio);
2371     }
2372 
2373     return ret;
2374 }
2375 
2376 /* Check if it's possible to merge a write request with the writing of
2377  * the data from the COW regions */
merge_cow(uint64_t offset,unsigned bytes,QEMUIOVector * qiov,size_t qiov_offset,QCowL2Meta * l2meta)2378 static bool merge_cow(uint64_t offset, unsigned bytes,
2379                       QEMUIOVector *qiov, size_t qiov_offset,
2380                       QCowL2Meta *l2meta)
2381 {
2382     QCowL2Meta *m;
2383 
2384     for (m = l2meta; m != NULL; m = m->next) {
2385         /* If both COW regions are empty then there's nothing to merge */
2386         if (m->cow_start.nb_bytes == 0 && m->cow_end.nb_bytes == 0) {
2387             continue;
2388         }
2389 
2390         /* If COW regions are handled already, skip this too */
2391         if (m->skip_cow) {
2392             continue;
2393         }
2394 
2395         /*
2396          * The write request should start immediately after the first
2397          * COW region. This does not always happen because the area
2398          * touched by the request can be larger than the one defined
2399          * by @m (a single request can span an area consisting of a
2400          * mix of previously unallocated and allocated clusters, that
2401          * is why @l2meta is a list).
2402          */
2403         if (l2meta_cow_start(m) + m->cow_start.nb_bytes != offset) {
2404             /* In this case the request starts before this region */
2405             assert(offset < l2meta_cow_start(m));
2406             assert(m->cow_start.nb_bytes == 0);
2407             continue;
2408         }
2409 
2410         /* The write request should end immediately before the second
2411          * COW region (see above for why it does not always happen) */
2412         if (m->offset + m->cow_end.offset != offset + bytes) {
2413             assert(offset + bytes > m->offset + m->cow_end.offset);
2414             assert(m->cow_end.nb_bytes == 0);
2415             continue;
2416         }
2417 
2418         /* Make sure that adding both COW regions to the QEMUIOVector
2419          * does not exceed IOV_MAX */
2420         if (qemu_iovec_subvec_niov(qiov, qiov_offset, bytes) > IOV_MAX - 2) {
2421             continue;
2422         }
2423 
2424         m->data_qiov = qiov;
2425         m->data_qiov_offset = qiov_offset;
2426         return true;
2427     }
2428 
2429     return false;
2430 }
2431 
2432 /*
2433  * Return 1 if the COW regions read as zeroes, 0 if not, < 0 on error.
2434  * Note that returning 0 does not guarantee non-zero data.
2435  */
is_zero_cow(BlockDriverState * bs,QCowL2Meta * m)2436 static int is_zero_cow(BlockDriverState *bs, QCowL2Meta *m)
2437 {
2438     /*
2439      * This check is designed for optimization shortcut so it must be
2440      * efficient.
2441      * Instead of is_zero(), use bdrv_co_is_zero_fast() as it is
2442      * faster (but not as accurate and can result in false negatives).
2443      */
2444     int ret = bdrv_co_is_zero_fast(bs, m->offset + m->cow_start.offset,
2445                                    m->cow_start.nb_bytes);
2446     if (ret <= 0) {
2447         return ret;
2448     }
2449 
2450     return bdrv_co_is_zero_fast(bs, m->offset + m->cow_end.offset,
2451                                 m->cow_end.nb_bytes);
2452 }
2453 
handle_alloc_space(BlockDriverState * bs,QCowL2Meta * l2meta)2454 static int handle_alloc_space(BlockDriverState *bs, QCowL2Meta *l2meta)
2455 {
2456     BDRVQcow2State *s = bs->opaque;
2457     QCowL2Meta *m;
2458 
2459     if (!(s->data_file->bs->supported_zero_flags & BDRV_REQ_NO_FALLBACK)) {
2460         return 0;
2461     }
2462 
2463     if (bs->encrypted) {
2464         return 0;
2465     }
2466 
2467     for (m = l2meta; m != NULL; m = m->next) {
2468         int ret;
2469         uint64_t start_offset = m->alloc_offset + m->cow_start.offset;
2470         unsigned nb_bytes = m->cow_end.offset + m->cow_end.nb_bytes -
2471             m->cow_start.offset;
2472 
2473         if (!m->cow_start.nb_bytes && !m->cow_end.nb_bytes) {
2474             continue;
2475         }
2476 
2477         ret = is_zero_cow(bs, m);
2478         if (ret < 0) {
2479             return ret;
2480         } else if (ret == 0) {
2481             continue;
2482         }
2483 
2484         /*
2485          * instead of writing zero COW buffers,
2486          * efficiently zero out the whole clusters
2487          */
2488 
2489         ret = qcow2_pre_write_overlap_check(bs, 0, start_offset, nb_bytes,
2490                                             true);
2491         if (ret < 0) {
2492             return ret;
2493         }
2494 
2495         BLKDBG_EVENT(bs->file, BLKDBG_CLUSTER_ALLOC_SPACE);
2496         ret = bdrv_co_pwrite_zeroes(s->data_file, start_offset, nb_bytes,
2497                                     BDRV_REQ_NO_FALLBACK);
2498         if (ret < 0) {
2499             if (ret != -ENOTSUP && ret != -EAGAIN) {
2500                 return ret;
2501             }
2502             continue;
2503         }
2504 
2505         trace_qcow2_skip_cow(qemu_coroutine_self(), m->offset, m->nb_clusters);
2506         m->skip_cow = true;
2507     }
2508     return 0;
2509 }
2510 
2511 /*
2512  * qcow2_co_pwritev_task
2513  * Called with s->lock unlocked
2514  * l2meta  - if not NULL, qcow2_co_pwritev_task() will consume it. Caller must
2515  *           not use it somehow after qcow2_co_pwritev_task() call
2516  */
qcow2_co_pwritev_task(BlockDriverState * bs,uint64_t host_offset,uint64_t offset,uint64_t bytes,QEMUIOVector * qiov,uint64_t qiov_offset,QCowL2Meta * l2meta)2517 static coroutine_fn int qcow2_co_pwritev_task(BlockDriverState *bs,
2518                                               uint64_t host_offset,
2519                                               uint64_t offset, uint64_t bytes,
2520                                               QEMUIOVector *qiov,
2521                                               uint64_t qiov_offset,
2522                                               QCowL2Meta *l2meta)
2523 {
2524     int ret;
2525     BDRVQcow2State *s = bs->opaque;
2526     void *crypt_buf = NULL;
2527     QEMUIOVector encrypted_qiov;
2528 
2529     if (bs->encrypted) {
2530         assert(s->crypto);
2531         assert(bytes <= QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size);
2532         crypt_buf = qemu_try_blockalign(bs->file->bs, bytes);
2533         if (crypt_buf == NULL) {
2534             ret = -ENOMEM;
2535             goto out_unlocked;
2536         }
2537         qemu_iovec_to_buf(qiov, qiov_offset, crypt_buf, bytes);
2538 
2539         if (qcow2_co_encrypt(bs, host_offset, offset, crypt_buf, bytes) < 0) {
2540             ret = -EIO;
2541             goto out_unlocked;
2542         }
2543 
2544         qemu_iovec_init_buf(&encrypted_qiov, crypt_buf, bytes);
2545         qiov = &encrypted_qiov;
2546         qiov_offset = 0;
2547     }
2548 
2549     /* Try to efficiently initialize the physical space with zeroes */
2550     ret = handle_alloc_space(bs, l2meta);
2551     if (ret < 0) {
2552         goto out_unlocked;
2553     }
2554 
2555     /*
2556      * If we need to do COW, check if it's possible to merge the
2557      * writing of the guest data together with that of the COW regions.
2558      * If it's not possible (or not necessary) then write the
2559      * guest data now.
2560      */
2561     if (!merge_cow(offset, bytes, qiov, qiov_offset, l2meta)) {
2562         BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);
2563         trace_qcow2_writev_data(qemu_coroutine_self(), host_offset);
2564         ret = bdrv_co_pwritev_part(s->data_file, host_offset,
2565                                    bytes, qiov, qiov_offset, 0);
2566         if (ret < 0) {
2567             goto out_unlocked;
2568         }
2569     }
2570 
2571     qemu_co_mutex_lock(&s->lock);
2572 
2573     ret = qcow2_handle_l2meta(bs, &l2meta, true);
2574     goto out_locked;
2575 
2576 out_unlocked:
2577     qemu_co_mutex_lock(&s->lock);
2578 
2579 out_locked:
2580     qcow2_handle_l2meta(bs, &l2meta, false);
2581     qemu_co_mutex_unlock(&s->lock);
2582 
2583     qemu_vfree(crypt_buf);
2584 
2585     return ret;
2586 }
2587 
qcow2_co_pwritev_task_entry(AioTask * task)2588 static coroutine_fn int qcow2_co_pwritev_task_entry(AioTask *task)
2589 {
2590     Qcow2AioTask *t = container_of(task, Qcow2AioTask, task);
2591 
2592     assert(!t->subcluster_type);
2593 
2594     return qcow2_co_pwritev_task(t->bs, t->host_offset,
2595                                  t->offset, t->bytes, t->qiov, t->qiov_offset,
2596                                  t->l2meta);
2597 }
2598 
qcow2_co_pwritev_part(BlockDriverState * bs,int64_t offset,int64_t bytes,QEMUIOVector * qiov,size_t qiov_offset,BdrvRequestFlags flags)2599 static coroutine_fn int qcow2_co_pwritev_part(
2600         BlockDriverState *bs, int64_t offset, int64_t bytes,
2601         QEMUIOVector *qiov, size_t qiov_offset, BdrvRequestFlags flags)
2602 {
2603     BDRVQcow2State *s = bs->opaque;
2604     int offset_in_cluster;
2605     int ret;
2606     unsigned int cur_bytes; /* number of sectors in current iteration */
2607     uint64_t host_offset;
2608     QCowL2Meta *l2meta = NULL;
2609     AioTaskPool *aio = NULL;
2610 
2611     trace_qcow2_writev_start_req(qemu_coroutine_self(), offset, bytes);
2612 
2613     while (bytes != 0 && aio_task_pool_status(aio) == 0) {
2614 
2615         l2meta = NULL;
2616 
2617         trace_qcow2_writev_start_part(qemu_coroutine_self());
2618         offset_in_cluster = offset_into_cluster(s, offset);
2619         cur_bytes = MIN(bytes, INT_MAX);
2620         if (bs->encrypted) {
2621             cur_bytes = MIN(cur_bytes,
2622                             QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size
2623                             - offset_in_cluster);
2624         }
2625 
2626         qemu_co_mutex_lock(&s->lock);
2627 
2628         ret = qcow2_alloc_host_offset(bs, offset, &cur_bytes,
2629                                       &host_offset, &l2meta);
2630         if (ret < 0) {
2631             goto out_locked;
2632         }
2633 
2634         ret = qcow2_pre_write_overlap_check(bs, 0, host_offset,
2635                                             cur_bytes, true);
2636         if (ret < 0) {
2637             goto out_locked;
2638         }
2639 
2640         qemu_co_mutex_unlock(&s->lock);
2641 
2642         if (!aio && cur_bytes != bytes) {
2643             aio = aio_task_pool_new(QCOW2_MAX_WORKERS);
2644         }
2645         ret = qcow2_add_task(bs, aio, qcow2_co_pwritev_task_entry, 0,
2646                              host_offset, offset,
2647                              cur_bytes, qiov, qiov_offset, l2meta);
2648         l2meta = NULL; /* l2meta is consumed by qcow2_co_pwritev_task() */
2649         if (ret < 0) {
2650             goto fail_nometa;
2651         }
2652 
2653         bytes -= cur_bytes;
2654         offset += cur_bytes;
2655         qiov_offset += cur_bytes;
2656         trace_qcow2_writev_done_part(qemu_coroutine_self(), cur_bytes);
2657     }
2658     ret = 0;
2659 
2660     qemu_co_mutex_lock(&s->lock);
2661 
2662 out_locked:
2663     qcow2_handle_l2meta(bs, &l2meta, false);
2664 
2665     qemu_co_mutex_unlock(&s->lock);
2666 
2667 fail_nometa:
2668     if (aio) {
2669         aio_task_pool_wait_all(aio);
2670         if (ret == 0) {
2671             ret = aio_task_pool_status(aio);
2672         }
2673         g_free(aio);
2674     }
2675 
2676     trace_qcow2_writev_done_req(qemu_coroutine_self(), ret);
2677 
2678     return ret;
2679 }
2680 
qcow2_inactivate(BlockDriverState * bs)2681 static int qcow2_inactivate(BlockDriverState *bs)
2682 {
2683     BDRVQcow2State *s = bs->opaque;
2684     int ret, result = 0;
2685     Error *local_err = NULL;
2686 
2687     qcow2_store_persistent_dirty_bitmaps(bs, true, &local_err);
2688     if (local_err != NULL) {
2689         result = -EINVAL;
2690         error_reportf_err(local_err, "Lost persistent bitmaps during "
2691                           "inactivation of node '%s': ",
2692                           bdrv_get_device_or_node_name(bs));
2693     }
2694 
2695     ret = qcow2_cache_flush(bs, s->l2_table_cache);
2696     if (ret) {
2697         result = ret;
2698         error_report("Failed to flush the L2 table cache: %s",
2699                      strerror(-ret));
2700     }
2701 
2702     ret = qcow2_cache_flush(bs, s->refcount_block_cache);
2703     if (ret) {
2704         result = ret;
2705         error_report("Failed to flush the refcount block cache: %s",
2706                      strerror(-ret));
2707     }
2708 
2709     if (result == 0) {
2710         qcow2_mark_clean(bs);
2711     }
2712 
2713     return result;
2714 }
2715 
qcow2_close(BlockDriverState * bs)2716 static void qcow2_close(BlockDriverState *bs)
2717 {
2718     BDRVQcow2State *s = bs->opaque;
2719     qemu_vfree(s->l1_table);
2720     /* else pre-write overlap checks in cache_destroy may crash */
2721     s->l1_table = NULL;
2722 
2723     if (!(s->flags & BDRV_O_INACTIVE)) {
2724         qcow2_inactivate(bs);
2725     }
2726 
2727     cache_clean_timer_del(bs);
2728     qcow2_cache_destroy(s->l2_table_cache);
2729     qcow2_cache_destroy(s->refcount_block_cache);
2730 
2731     qcrypto_block_free(s->crypto);
2732     s->crypto = NULL;
2733     qapi_free_QCryptoBlockOpenOptions(s->crypto_opts);
2734 
2735     g_free(s->unknown_header_fields);
2736     cleanup_unknown_header_ext(bs);
2737 
2738     g_free(s->image_data_file);
2739     g_free(s->image_backing_file);
2740     g_free(s->image_backing_format);
2741 
2742     if (has_data_file(bs)) {
2743         bdrv_unref_child(bs, s->data_file);
2744         s->data_file = NULL;
2745     }
2746 
2747     qcow2_refcount_close(bs);
2748     qcow2_free_snapshots(bs);
2749 }
2750 
qcow2_co_invalidate_cache(BlockDriverState * bs,Error ** errp)2751 static void coroutine_fn qcow2_co_invalidate_cache(BlockDriverState *bs,
2752                                                    Error **errp)
2753 {
2754     ERRP_GUARD();
2755     BDRVQcow2State *s = bs->opaque;
2756     int flags = s->flags;
2757     QCryptoBlock *crypto = NULL;
2758     QDict *options;
2759     int ret;
2760 
2761     /*
2762      * Backing files are read-only which makes all of their metadata immutable,
2763      * that means we don't have to worry about reopening them here.
2764      */
2765 
2766     crypto = s->crypto;
2767     s->crypto = NULL;
2768 
2769     qcow2_close(bs);
2770 
2771     memset(s, 0, sizeof(BDRVQcow2State));
2772     options = qdict_clone_shallow(bs->options);
2773 
2774     flags &= ~BDRV_O_INACTIVE;
2775     qemu_co_mutex_lock(&s->lock);
2776     ret = qcow2_do_open(bs, options, flags, errp);
2777     qemu_co_mutex_unlock(&s->lock);
2778     qobject_unref(options);
2779     if (ret < 0) {
2780         error_prepend(errp, "Could not reopen qcow2 layer: ");
2781         bs->drv = NULL;
2782         return;
2783     }
2784 
2785     s->crypto = crypto;
2786 }
2787 
header_ext_add(char * buf,uint32_t magic,const void * s,size_t len,size_t buflen)2788 static size_t header_ext_add(char *buf, uint32_t magic, const void *s,
2789     size_t len, size_t buflen)
2790 {
2791     QCowExtension *ext_backing_fmt = (QCowExtension*) buf;
2792     size_t ext_len = sizeof(QCowExtension) + ((len + 7) & ~7);
2793 
2794     if (buflen < ext_len) {
2795         return -ENOSPC;
2796     }
2797 
2798     *ext_backing_fmt = (QCowExtension) {
2799         .magic  = cpu_to_be32(magic),
2800         .len    = cpu_to_be32(len),
2801     };
2802 
2803     if (len) {
2804         memcpy(buf + sizeof(QCowExtension), s, len);
2805     }
2806 
2807     return ext_len;
2808 }
2809 
2810 /*
2811  * Updates the qcow2 header, including the variable length parts of it, i.e.
2812  * the backing file name and all extensions. qcow2 was not designed to allow
2813  * such changes, so if we run out of space (we can only use the first cluster)
2814  * this function may fail.
2815  *
2816  * Returns 0 on success, -errno in error cases.
2817  */
qcow2_update_header(BlockDriverState * bs)2818 int qcow2_update_header(BlockDriverState *bs)
2819 {
2820     BDRVQcow2State *s = bs->opaque;
2821     QCowHeader *header;
2822     char *buf;
2823     size_t buflen = s->cluster_size;
2824     int ret;
2825     uint64_t total_size;
2826     uint32_t refcount_table_clusters;
2827     size_t header_length;
2828     Qcow2UnknownHeaderExtension *uext;
2829 
2830     buf = qemu_blockalign(bs, buflen);
2831 
2832     /* Header structure */
2833     header = (QCowHeader*) buf;
2834 
2835     if (buflen < sizeof(*header)) {
2836         ret = -ENOSPC;
2837         goto fail;
2838     }
2839 
2840     header_length = sizeof(*header) + s->unknown_header_fields_size;
2841     total_size = bs->total_sectors * BDRV_SECTOR_SIZE;
2842     refcount_table_clusters = s->refcount_table_size >> (s->cluster_bits - 3);
2843 
2844     ret = validate_compression_type(s, NULL);
2845     if (ret) {
2846         goto fail;
2847     }
2848 
2849     *header = (QCowHeader) {
2850         /* Version 2 fields */
2851         .magic                  = cpu_to_be32(QCOW_MAGIC),
2852         .version                = cpu_to_be32(s->qcow_version),
2853         .backing_file_offset    = 0,
2854         .backing_file_size      = 0,
2855         .cluster_bits           = cpu_to_be32(s->cluster_bits),
2856         .size                   = cpu_to_be64(total_size),
2857         .crypt_method           = cpu_to_be32(s->crypt_method_header),
2858         .l1_size                = cpu_to_be32(s->l1_size),
2859         .l1_table_offset        = cpu_to_be64(s->l1_table_offset),
2860         .refcount_table_offset  = cpu_to_be64(s->refcount_table_offset),
2861         .refcount_table_clusters = cpu_to_be32(refcount_table_clusters),
2862         .nb_snapshots           = cpu_to_be32(s->nb_snapshots),
2863         .snapshots_offset       = cpu_to_be64(s->snapshots_offset),
2864 
2865         /* Version 3 fields */
2866         .incompatible_features  = cpu_to_be64(s->incompatible_features),
2867         .compatible_features    = cpu_to_be64(s->compatible_features),
2868         .autoclear_features     = cpu_to_be64(s->autoclear_features),
2869         .refcount_order         = cpu_to_be32(s->refcount_order),
2870         .header_length          = cpu_to_be32(header_length),
2871         .compression_type       = s->compression_type,
2872     };
2873 
2874     /* For older versions, write a shorter header */
2875     switch (s->qcow_version) {
2876     case 2:
2877         ret = offsetof(QCowHeader, incompatible_features);
2878         break;
2879     case 3:
2880         ret = sizeof(*header);
2881         break;
2882     default:
2883         ret = -EINVAL;
2884         goto fail;
2885     }
2886 
2887     buf += ret;
2888     buflen -= ret;
2889     memset(buf, 0, buflen);
2890 
2891     /* Preserve any unknown field in the header */
2892     if (s->unknown_header_fields_size) {
2893         if (buflen < s->unknown_header_fields_size) {
2894             ret = -ENOSPC;
2895             goto fail;
2896         }
2897 
2898         memcpy(buf, s->unknown_header_fields, s->unknown_header_fields_size);
2899         buf += s->unknown_header_fields_size;
2900         buflen -= s->unknown_header_fields_size;
2901     }
2902 
2903     /* Backing file format header extension */
2904     if (s->image_backing_format) {
2905         ret = header_ext_add(buf, QCOW2_EXT_MAGIC_BACKING_FORMAT,
2906                              s->image_backing_format,
2907                              strlen(s->image_backing_format),
2908                              buflen);
2909         if (ret < 0) {
2910             goto fail;
2911         }
2912 
2913         buf += ret;
2914         buflen -= ret;
2915     }
2916 
2917     /* External data file header extension */
2918     if (has_data_file(bs) && s->image_data_file) {
2919         ret = header_ext_add(buf, QCOW2_EXT_MAGIC_DATA_FILE,
2920                              s->image_data_file, strlen(s->image_data_file),
2921                              buflen);
2922         if (ret < 0) {
2923             goto fail;
2924         }
2925 
2926         buf += ret;
2927         buflen -= ret;
2928     }
2929 
2930     /* Full disk encryption header pointer extension */
2931     if (s->crypto_header.offset != 0) {
2932         s->crypto_header.offset = cpu_to_be64(s->crypto_header.offset);
2933         s->crypto_header.length = cpu_to_be64(s->crypto_header.length);
2934         ret = header_ext_add(buf, QCOW2_EXT_MAGIC_CRYPTO_HEADER,
2935                              &s->crypto_header, sizeof(s->crypto_header),
2936                              buflen);
2937         s->crypto_header.offset = be64_to_cpu(s->crypto_header.offset);
2938         s->crypto_header.length = be64_to_cpu(s->crypto_header.length);
2939         if (ret < 0) {
2940             goto fail;
2941         }
2942         buf += ret;
2943         buflen -= ret;
2944     }
2945 
2946     /*
2947      * Feature table.  A mere 8 feature names occupies 392 bytes, and
2948      * when coupled with the v3 minimum header of 104 bytes plus the
2949      * 8-byte end-of-extension marker, that would leave only 8 bytes
2950      * for a backing file name in an image with 512-byte clusters.
2951      * Thus, we choose to omit this header for cluster sizes 4k and
2952      * smaller.
2953      */
2954     if (s->qcow_version >= 3 && s->cluster_size > 4096) {
2955         static const Qcow2Feature features[] = {
2956             {
2957                 .type = QCOW2_FEAT_TYPE_INCOMPATIBLE,
2958                 .bit  = QCOW2_INCOMPAT_DIRTY_BITNR,
2959                 .name = "dirty bit",
2960             },
2961             {
2962                 .type = QCOW2_FEAT_TYPE_INCOMPATIBLE,
2963                 .bit  = QCOW2_INCOMPAT_CORRUPT_BITNR,
2964                 .name = "corrupt bit",
2965             },
2966             {
2967                 .type = QCOW2_FEAT_TYPE_INCOMPATIBLE,
2968                 .bit  = QCOW2_INCOMPAT_DATA_FILE_BITNR,
2969                 .name = "external data file",
2970             },
2971             {
2972                 .type = QCOW2_FEAT_TYPE_INCOMPATIBLE,
2973                 .bit  = QCOW2_INCOMPAT_COMPRESSION_BITNR,
2974                 .name = "compression type",
2975             },
2976             {
2977                 .type = QCOW2_FEAT_TYPE_INCOMPATIBLE,
2978                 .bit  = QCOW2_INCOMPAT_EXTL2_BITNR,
2979                 .name = "extended L2 entries",
2980             },
2981             {
2982                 .type = QCOW2_FEAT_TYPE_COMPATIBLE,
2983                 .bit  = QCOW2_COMPAT_LAZY_REFCOUNTS_BITNR,
2984                 .name = "lazy refcounts",
2985             },
2986             {
2987                 .type = QCOW2_FEAT_TYPE_AUTOCLEAR,
2988                 .bit  = QCOW2_AUTOCLEAR_BITMAPS_BITNR,
2989                 .name = "bitmaps",
2990             },
2991             {
2992                 .type = QCOW2_FEAT_TYPE_AUTOCLEAR,
2993                 .bit  = QCOW2_AUTOCLEAR_DATA_FILE_RAW_BITNR,
2994                 .name = "raw external data",
2995             },
2996         };
2997 
2998         ret = header_ext_add(buf, QCOW2_EXT_MAGIC_FEATURE_TABLE,
2999                              features, sizeof(features), buflen);
3000         if (ret < 0) {
3001             goto fail;
3002         }
3003         buf += ret;
3004         buflen -= ret;
3005     }
3006 
3007     /* Bitmap extension */
3008     if (s->nb_bitmaps > 0) {
3009         Qcow2BitmapHeaderExt bitmaps_header = {
3010             .nb_bitmaps = cpu_to_be32(s->nb_bitmaps),
3011             .bitmap_directory_size =
3012                     cpu_to_be64(s->bitmap_directory_size),
3013             .bitmap_directory_offset =
3014                     cpu_to_be64(s->bitmap_directory_offset)
3015         };
3016         ret = header_ext_add(buf, QCOW2_EXT_MAGIC_BITMAPS,
3017                              &bitmaps_header, sizeof(bitmaps_header),
3018                              buflen);
3019         if (ret < 0) {
3020             goto fail;
3021         }
3022         buf += ret;
3023         buflen -= ret;
3024     }
3025 
3026     /* Keep unknown header extensions */
3027     QLIST_FOREACH(uext, &s->unknown_header_ext, next) {
3028         ret = header_ext_add(buf, uext->magic, uext->data, uext->len, buflen);
3029         if (ret < 0) {
3030             goto fail;
3031         }
3032 
3033         buf += ret;
3034         buflen -= ret;
3035     }
3036 
3037     /* End of header extensions */
3038     ret = header_ext_add(buf, QCOW2_EXT_MAGIC_END, NULL, 0, buflen);
3039     if (ret < 0) {
3040         goto fail;
3041     }
3042 
3043     buf += ret;
3044     buflen -= ret;
3045 
3046     /* Backing file name */
3047     if (s->image_backing_file) {
3048         size_t backing_file_len = strlen(s->image_backing_file);
3049 
3050         if (buflen < backing_file_len) {
3051             ret = -ENOSPC;
3052             goto fail;
3053         }
3054 
3055         /* Using strncpy is ok here, since buf is not NUL-terminated. */
3056         strncpy(buf, s->image_backing_file, buflen);
3057 
3058         header->backing_file_offset = cpu_to_be64(buf - ((char*) header));
3059         header->backing_file_size   = cpu_to_be32(backing_file_len);
3060     }
3061 
3062     /* Write the new header */
3063     ret = bdrv_pwrite(bs->file, 0, header, s->cluster_size);
3064     if (ret < 0) {
3065         goto fail;
3066     }
3067 
3068     ret = 0;
3069 fail:
3070     qemu_vfree(header);
3071     return ret;
3072 }
3073 
qcow2_change_backing_file(BlockDriverState * bs,const char * backing_file,const char * backing_fmt)3074 static int qcow2_change_backing_file(BlockDriverState *bs,
3075     const char *backing_file, const char *backing_fmt)
3076 {
3077     BDRVQcow2State *s = bs->opaque;
3078 
3079     /* Adding a backing file means that the external data file alone won't be
3080      * enough to make sense of the content */
3081     if (backing_file && data_file_is_raw(bs)) {
3082         return -EINVAL;
3083     }
3084 
3085     if (backing_file && strlen(backing_file) > 1023) {
3086         return -EINVAL;
3087     }
3088 
3089     pstrcpy(bs->auto_backing_file, sizeof(bs->auto_backing_file),
3090             backing_file ?: "");
3091     pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: "");
3092     pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: "");
3093 
3094     g_free(s->image_backing_file);
3095     g_free(s->image_backing_format);
3096 
3097     s->image_backing_file = backing_file ? g_strdup(bs->backing_file) : NULL;
3098     s->image_backing_format = backing_fmt ? g_strdup(bs->backing_format) : NULL;
3099 
3100     return qcow2_update_header(bs);
3101 }
3102 
qcow2_set_up_encryption(BlockDriverState * bs,QCryptoBlockCreateOptions * cryptoopts,Error ** errp)3103 static int qcow2_set_up_encryption(BlockDriverState *bs,
3104                                    QCryptoBlockCreateOptions *cryptoopts,
3105                                    Error **errp)
3106 {
3107     BDRVQcow2State *s = bs->opaque;
3108     QCryptoBlock *crypto = NULL;
3109     int fmt, ret;
3110 
3111     switch (cryptoopts->format) {
3112     case Q_CRYPTO_BLOCK_FORMAT_LUKS:
3113         fmt = QCOW_CRYPT_LUKS;
3114         break;
3115     case Q_CRYPTO_BLOCK_FORMAT_QCOW:
3116         fmt = QCOW_CRYPT_AES;
3117         break;
3118     default:
3119         error_setg(errp, "Crypto format not supported in qcow2");
3120         return -EINVAL;
3121     }
3122 
3123     s->crypt_method_header = fmt;
3124 
3125     crypto = qcrypto_block_create(cryptoopts, "encrypt.",
3126                                   qcow2_crypto_hdr_init_func,
3127                                   qcow2_crypto_hdr_write_func,
3128                                   bs, errp);
3129     if (!crypto) {
3130         return -EINVAL;
3131     }
3132 
3133     ret = qcow2_update_header(bs);
3134     if (ret < 0) {
3135         error_setg_errno(errp, -ret, "Could not write encryption header");
3136         goto out;
3137     }
3138 
3139     ret = 0;
3140  out:
3141     qcrypto_block_free(crypto);
3142     return ret;
3143 }
3144 
3145 /**
3146  * Preallocates metadata structures for data clusters between @offset (in the
3147  * guest disk) and @new_length (which is thus generally the new guest disk
3148  * size).
3149  *
3150  * Returns: 0 on success, -errno on failure.
3151  */
preallocate_co(BlockDriverState * bs,uint64_t offset,uint64_t new_length,PreallocMode mode,Error ** errp)3152 static int coroutine_fn preallocate_co(BlockDriverState *bs, uint64_t offset,
3153                                        uint64_t new_length, PreallocMode mode,
3154                                        Error **errp)
3155 {
3156     BDRVQcow2State *s = bs->opaque;
3157     uint64_t bytes;
3158     uint64_t host_offset = 0;
3159     int64_t file_length;
3160     unsigned int cur_bytes;
3161     int ret;
3162     QCowL2Meta *meta = NULL, *m;
3163 
3164     assert(offset <= new_length);
3165     bytes = new_length - offset;
3166 
3167     while (bytes) {
3168         cur_bytes = MIN(bytes, QEMU_ALIGN_DOWN(INT_MAX, s->cluster_size));
3169         ret = qcow2_alloc_host_offset(bs, offset, &cur_bytes,
3170                                       &host_offset, &meta);
3171         if (ret < 0) {
3172             error_setg_errno(errp, -ret, "Allocating clusters failed");
3173             goto out;
3174         }
3175 
3176         for (m = meta; m != NULL; m = m->next) {
3177             m->prealloc = true;
3178         }
3179 
3180         ret = qcow2_handle_l2meta(bs, &meta, true);
3181         if (ret < 0) {
3182             error_setg_errno(errp, -ret, "Mapping clusters failed");
3183             goto out;
3184         }
3185 
3186         /* TODO Preallocate data if requested */
3187 
3188         bytes -= cur_bytes;
3189         offset += cur_bytes;
3190     }
3191 
3192     /*
3193      * It is expected that the image file is large enough to actually contain
3194      * all of the allocated clusters (otherwise we get failing reads after
3195      * EOF). Extend the image to the last allocated sector.
3196      */
3197     file_length = bdrv_getlength(s->data_file->bs);
3198     if (file_length < 0) {
3199         error_setg_errno(errp, -file_length, "Could not get file size");
3200         ret = file_length;
3201         goto out;
3202     }
3203 
3204     if (host_offset + cur_bytes > file_length) {
3205         if (mode == PREALLOC_MODE_METADATA) {
3206             mode = PREALLOC_MODE_OFF;
3207         }
3208         ret = bdrv_co_truncate(s->data_file, host_offset + cur_bytes, false,
3209                                mode, 0, errp);
3210         if (ret < 0) {
3211             goto out;
3212         }
3213     }
3214 
3215     ret = 0;
3216 
3217 out:
3218     qcow2_handle_l2meta(bs, &meta, false);
3219     return ret;
3220 }
3221 
3222 /* qcow2_refcount_metadata_size:
3223  * @clusters: number of clusters to refcount (including data and L1/L2 tables)
3224  * @cluster_size: size of a cluster, in bytes
3225  * @refcount_order: refcount bits power-of-2 exponent
3226  * @generous_increase: allow for the refcount table to be 1.5x as large as it
3227  *                     needs to be
3228  *
3229  * Returns: Number of bytes required for refcount blocks and table metadata.
3230  */
qcow2_refcount_metadata_size(int64_t clusters,size_t cluster_size,int refcount_order,bool generous_increase,uint64_t * refblock_count)3231 int64_t qcow2_refcount_metadata_size(int64_t clusters, size_t cluster_size,
3232                                      int refcount_order, bool generous_increase,
3233                                      uint64_t *refblock_count)
3234 {
3235     /*
3236      * Every host cluster is reference-counted, including metadata (even
3237      * refcount metadata is recursively included).
3238      *
3239      * An accurate formula for the size of refcount metadata size is difficult
3240      * to derive.  An easier method of calculation is finding the fixed point
3241      * where no further refcount blocks or table clusters are required to
3242      * reference count every cluster.
3243      */
3244     int64_t blocks_per_table_cluster = cluster_size / REFTABLE_ENTRY_SIZE;
3245     int64_t refcounts_per_block = cluster_size * 8 / (1 << refcount_order);
3246     int64_t table = 0;  /* number of refcount table clusters */
3247     int64_t blocks = 0; /* number of refcount block clusters */
3248     int64_t last;
3249     int64_t n = 0;
3250 
3251     do {
3252         last = n;
3253         blocks = DIV_ROUND_UP(clusters + table + blocks, refcounts_per_block);
3254         table = DIV_ROUND_UP(blocks, blocks_per_table_cluster);
3255         n = clusters + blocks + table;
3256 
3257         if (n == last && generous_increase) {
3258             clusters += DIV_ROUND_UP(table, 2);
3259             n = 0; /* force another loop */
3260             generous_increase = false;
3261         }
3262     } while (n != last);
3263 
3264     if (refblock_count) {
3265         *refblock_count = blocks;
3266     }
3267 
3268     return (blocks + table) * cluster_size;
3269 }
3270 
3271 /**
3272  * qcow2_calc_prealloc_size:
3273  * @total_size: virtual disk size in bytes
3274  * @cluster_size: cluster size in bytes
3275  * @refcount_order: refcount bits power-of-2 exponent
3276  * @extended_l2: true if the image has extended L2 entries
3277  *
3278  * Returns: Total number of bytes required for the fully allocated image
3279  * (including metadata).
3280  */
qcow2_calc_prealloc_size(int64_t total_size,size_t cluster_size,int refcount_order,bool extended_l2)3281 static int64_t qcow2_calc_prealloc_size(int64_t total_size,
3282                                         size_t cluster_size,
3283                                         int refcount_order,
3284                                         bool extended_l2)
3285 {
3286     int64_t meta_size = 0;
3287     uint64_t nl1e, nl2e;
3288     int64_t aligned_total_size = ROUND_UP(total_size, cluster_size);
3289     size_t l2e_size = extended_l2 ? L2E_SIZE_EXTENDED : L2E_SIZE_NORMAL;
3290 
3291     /* header: 1 cluster */
3292     meta_size += cluster_size;
3293 
3294     /* total size of L2 tables */
3295     nl2e = aligned_total_size / cluster_size;
3296     nl2e = ROUND_UP(nl2e, cluster_size / l2e_size);
3297     meta_size += nl2e * l2e_size;
3298 
3299     /* total size of L1 tables */
3300     nl1e = nl2e * l2e_size / cluster_size;
3301     nl1e = ROUND_UP(nl1e, cluster_size / L1E_SIZE);
3302     meta_size += nl1e * L1E_SIZE;
3303 
3304     /* total size of refcount table and blocks */
3305     meta_size += qcow2_refcount_metadata_size(
3306             (meta_size + aligned_total_size) / cluster_size,
3307             cluster_size, refcount_order, false, NULL);
3308 
3309     return meta_size + aligned_total_size;
3310 }
3311 
validate_cluster_size(size_t cluster_size,bool extended_l2,Error ** errp)3312 static bool validate_cluster_size(size_t cluster_size, bool extended_l2,
3313                                   Error **errp)
3314 {
3315     int cluster_bits = ctz32(cluster_size);
3316     if (cluster_bits < MIN_CLUSTER_BITS || cluster_bits > MAX_CLUSTER_BITS ||
3317         (1 << cluster_bits) != cluster_size)
3318     {
3319         error_setg(errp, "Cluster size must be a power of two between %d and "
3320                    "%dk", 1 << MIN_CLUSTER_BITS, 1 << (MAX_CLUSTER_BITS - 10));
3321         return false;
3322     }
3323 
3324     if (extended_l2) {
3325         unsigned min_cluster_size =
3326             (1 << MIN_CLUSTER_BITS) * QCOW_EXTL2_SUBCLUSTERS_PER_CLUSTER;
3327         if (cluster_size < min_cluster_size) {
3328             error_setg(errp, "Extended L2 entries are only supported with "
3329                        "cluster sizes of at least %u bytes", min_cluster_size);
3330             return false;
3331         }
3332     }
3333 
3334     return true;
3335 }
3336 
qcow2_opt_get_cluster_size_del(QemuOpts * opts,bool extended_l2,Error ** errp)3337 static size_t qcow2_opt_get_cluster_size_del(QemuOpts *opts, bool extended_l2,
3338                                              Error **errp)
3339 {
3340     size_t cluster_size;
3341 
3342     cluster_size = qemu_opt_get_size_del(opts, BLOCK_OPT_CLUSTER_SIZE,
3343                                          DEFAULT_CLUSTER_SIZE);
3344     if (!validate_cluster_size(cluster_size, extended_l2, errp)) {
3345         return 0;
3346     }
3347     return cluster_size;
3348 }
3349 
qcow2_opt_get_version_del(QemuOpts * opts,Error ** errp)3350 static int qcow2_opt_get_version_del(QemuOpts *opts, Error **errp)
3351 {
3352     char *buf;
3353     int ret;
3354 
3355     buf = qemu_opt_get_del(opts, BLOCK_OPT_COMPAT_LEVEL);
3356     if (!buf) {
3357         ret = 3; /* default */
3358     } else if (!strcmp(buf, "0.10")) {
3359         ret = 2;
3360     } else if (!strcmp(buf, "1.1")) {
3361         ret = 3;
3362     } else {
3363         error_setg(errp, "Invalid compatibility level: '%s'", buf);
3364         ret = -EINVAL;
3365     }
3366     g_free(buf);
3367     return ret;
3368 }
3369 
qcow2_opt_get_refcount_bits_del(QemuOpts * opts,int version,Error ** errp)3370 static uint64_t qcow2_opt_get_refcount_bits_del(QemuOpts *opts, int version,
3371                                                 Error **errp)
3372 {
3373     uint64_t refcount_bits;
3374 
3375     refcount_bits = qemu_opt_get_number_del(opts, BLOCK_OPT_REFCOUNT_BITS, 16);
3376     if (refcount_bits > 64 || !is_power_of_2(refcount_bits)) {
3377         error_setg(errp, "Refcount width must be a power of two and may not "
3378                    "exceed 64 bits");
3379         return 0;
3380     }
3381 
3382     if (version < 3 && refcount_bits != 16) {
3383         error_setg(errp, "Different refcount widths than 16 bits require "
3384                    "compatibility level 1.1 or above (use compat=1.1 or "
3385                    "greater)");
3386         return 0;
3387     }
3388 
3389     return refcount_bits;
3390 }
3391 
3392 static int coroutine_fn
qcow2_co_create(BlockdevCreateOptions * create_options,Error ** errp)3393 qcow2_co_create(BlockdevCreateOptions *create_options, Error **errp)
3394 {
3395     BlockdevCreateOptionsQcow2 *qcow2_opts;
3396     QDict *options;
3397 
3398     /*
3399      * Open the image file and write a minimal qcow2 header.
3400      *
3401      * We keep things simple and start with a zero-sized image. We also
3402      * do without refcount blocks or a L1 table for now. We'll fix the
3403      * inconsistency later.
3404      *
3405      * We do need a refcount table because growing the refcount table means
3406      * allocating two new refcount blocks - the second of which would be at
3407      * 2 GB for 64k clusters, and we don't want to have a 2 GB initial file
3408      * size for any qcow2 image.
3409      */
3410     BlockBackend *blk = NULL;
3411     BlockDriverState *bs = NULL;
3412     BlockDriverState *data_bs = NULL;
3413     QCowHeader *header;
3414     size_t cluster_size;
3415     int version;
3416     int refcount_order;
3417     uint64_t *refcount_table;
3418     int ret;
3419     uint8_t compression_type = QCOW2_COMPRESSION_TYPE_ZLIB;
3420 
3421     assert(create_options->driver == BLOCKDEV_DRIVER_QCOW2);
3422     qcow2_opts = &create_options->u.qcow2;
3423 
3424     bs = bdrv_open_blockdev_ref(qcow2_opts->file, errp);
3425     if (bs == NULL) {
3426         return -EIO;
3427     }
3428 
3429     /* Validate options and set default values */
3430     if (!QEMU_IS_ALIGNED(qcow2_opts->size, BDRV_SECTOR_SIZE)) {
3431         error_setg(errp, "Image size must be a multiple of %u bytes",
3432                    (unsigned) BDRV_SECTOR_SIZE);
3433         ret = -EINVAL;
3434         goto out;
3435     }
3436 
3437     if (qcow2_opts->has_version) {
3438         switch (qcow2_opts->version) {
3439         case BLOCKDEV_QCOW2_VERSION_V2:
3440             version = 2;
3441             break;
3442         case BLOCKDEV_QCOW2_VERSION_V3:
3443             version = 3;
3444             break;
3445         default:
3446             g_assert_not_reached();
3447         }
3448     } else {
3449         version = 3;
3450     }
3451 
3452     if (qcow2_opts->has_cluster_size) {
3453         cluster_size = qcow2_opts->cluster_size;
3454     } else {
3455         cluster_size = DEFAULT_CLUSTER_SIZE;
3456     }
3457 
3458     if (!qcow2_opts->has_extended_l2) {
3459         qcow2_opts->extended_l2 = false;
3460     }
3461     if (qcow2_opts->extended_l2) {
3462         if (version < 3) {
3463             error_setg(errp, "Extended L2 entries are only supported with "
3464                        "compatibility level 1.1 and above (use version=v3 or "
3465                        "greater)");
3466             ret = -EINVAL;
3467             goto out;
3468         }
3469     }
3470 
3471     if (!validate_cluster_size(cluster_size, qcow2_opts->extended_l2, errp)) {
3472         ret = -EINVAL;
3473         goto out;
3474     }
3475 
3476     if (!qcow2_opts->has_preallocation) {
3477         qcow2_opts->preallocation = PREALLOC_MODE_OFF;
3478     }
3479     if (qcow2_opts->has_backing_file &&
3480         qcow2_opts->preallocation != PREALLOC_MODE_OFF &&
3481         !qcow2_opts->extended_l2)
3482     {
3483         error_setg(errp, "Backing file and preallocation can only be used at "
3484                    "the same time if extended_l2 is on");
3485         ret = -EINVAL;
3486         goto out;
3487     }
3488     if (qcow2_opts->has_backing_fmt && !qcow2_opts->has_backing_file) {
3489         error_setg(errp, "Backing format cannot be used without backing file");
3490         ret = -EINVAL;
3491         goto out;
3492     }
3493 
3494     if (!qcow2_opts->has_lazy_refcounts) {
3495         qcow2_opts->lazy_refcounts = false;
3496     }
3497     if (version < 3 && qcow2_opts->lazy_refcounts) {
3498         error_setg(errp, "Lazy refcounts only supported with compatibility "
3499                    "level 1.1 and above (use version=v3 or greater)");
3500         ret = -EINVAL;
3501         goto out;
3502     }
3503 
3504     if (!qcow2_opts->has_refcount_bits) {
3505         qcow2_opts->refcount_bits = 16;
3506     }
3507     if (qcow2_opts->refcount_bits > 64 ||
3508         !is_power_of_2(qcow2_opts->refcount_bits))
3509     {
3510         error_setg(errp, "Refcount width must be a power of two and may not "
3511                    "exceed 64 bits");
3512         ret = -EINVAL;
3513         goto out;
3514     }
3515     if (version < 3 && qcow2_opts->refcount_bits != 16) {
3516         error_setg(errp, "Different refcount widths than 16 bits require "
3517                    "compatibility level 1.1 or above (use version=v3 or "
3518                    "greater)");
3519         ret = -EINVAL;
3520         goto out;
3521     }
3522     refcount_order = ctz32(qcow2_opts->refcount_bits);
3523 
3524     if (qcow2_opts->data_file_raw && !qcow2_opts->data_file) {
3525         error_setg(errp, "data-file-raw requires data-file");
3526         ret = -EINVAL;
3527         goto out;
3528     }
3529     if (qcow2_opts->data_file_raw && qcow2_opts->has_backing_file) {
3530         error_setg(errp, "Backing file and data-file-raw cannot be used at "
3531                    "the same time");
3532         ret = -EINVAL;
3533         goto out;
3534     }
3535     if (qcow2_opts->data_file_raw &&
3536         qcow2_opts->preallocation == PREALLOC_MODE_OFF)
3537     {
3538         /*
3539          * data-file-raw means that "the external data file can be
3540          * read as a consistent standalone raw image without looking
3541          * at the qcow2 metadata."  It does not say that the metadata
3542          * must be ignored, though (and the qcow2 driver in fact does
3543          * not ignore it), so the L1/L2 tables must be present and
3544          * give a 1:1 mapping, so you get the same result regardless
3545          * of whether you look at the metadata or whether you ignore
3546          * it.
3547          */
3548         qcow2_opts->preallocation = PREALLOC_MODE_METADATA;
3549 
3550         /*
3551          * Cannot use preallocation with backing files, but giving a
3552          * backing file when specifying data_file_raw is an error
3553          * anyway.
3554          */
3555         assert(!qcow2_opts->has_backing_file);
3556     }
3557 
3558     if (qcow2_opts->data_file) {
3559         if (version < 3) {
3560             error_setg(errp, "External data files are only supported with "
3561                        "compatibility level 1.1 and above (use version=v3 or "
3562                        "greater)");
3563             ret = -EINVAL;
3564             goto out;
3565         }
3566         data_bs = bdrv_open_blockdev_ref(qcow2_opts->data_file, errp);
3567         if (data_bs == NULL) {
3568             ret = -EIO;
3569             goto out;
3570         }
3571     }
3572 
3573     if (qcow2_opts->has_compression_type &&
3574         qcow2_opts->compression_type != QCOW2_COMPRESSION_TYPE_ZLIB) {
3575 
3576         ret = -EINVAL;
3577 
3578         if (version < 3) {
3579             error_setg(errp, "Non-zlib compression type is only supported with "
3580                        "compatibility level 1.1 and above (use version=v3 or "
3581                        "greater)");
3582             goto out;
3583         }
3584 
3585         switch (qcow2_opts->compression_type) {
3586 #ifdef CONFIG_ZSTD
3587         case QCOW2_COMPRESSION_TYPE_ZSTD:
3588             break;
3589 #endif
3590         default:
3591             error_setg(errp, "Unknown compression type");
3592             goto out;
3593         }
3594 
3595         compression_type = qcow2_opts->compression_type;
3596     }
3597 
3598     /* Create BlockBackend to write to the image */
3599     blk = blk_new_with_bs(bs, BLK_PERM_WRITE | BLK_PERM_RESIZE, BLK_PERM_ALL,
3600                           errp);
3601     if (!blk) {
3602         ret = -EPERM;
3603         goto out;
3604     }
3605     blk_set_allow_write_beyond_eof(blk, true);
3606 
3607     /* Write the header */
3608     QEMU_BUILD_BUG_ON((1 << MIN_CLUSTER_BITS) < sizeof(*header));
3609     header = g_malloc0(cluster_size);
3610     *header = (QCowHeader) {
3611         .magic                      = cpu_to_be32(QCOW_MAGIC),
3612         .version                    = cpu_to_be32(version),
3613         .cluster_bits               = cpu_to_be32(ctz32(cluster_size)),
3614         .size                       = cpu_to_be64(0),
3615         .l1_table_offset            = cpu_to_be64(0),
3616         .l1_size                    = cpu_to_be32(0),
3617         .refcount_table_offset      = cpu_to_be64(cluster_size),
3618         .refcount_table_clusters    = cpu_to_be32(1),
3619         .refcount_order             = cpu_to_be32(refcount_order),
3620         /* don't deal with endianness since compression_type is 1 byte long */
3621         .compression_type           = compression_type,
3622         .header_length              = cpu_to_be32(sizeof(*header)),
3623     };
3624 
3625     /* We'll update this to correct value later */
3626     header->crypt_method = cpu_to_be32(QCOW_CRYPT_NONE);
3627 
3628     if (qcow2_opts->lazy_refcounts) {
3629         header->compatible_features |=
3630             cpu_to_be64(QCOW2_COMPAT_LAZY_REFCOUNTS);
3631     }
3632     if (data_bs) {
3633         header->incompatible_features |=
3634             cpu_to_be64(QCOW2_INCOMPAT_DATA_FILE);
3635     }
3636     if (qcow2_opts->data_file_raw) {
3637         header->autoclear_features |=
3638             cpu_to_be64(QCOW2_AUTOCLEAR_DATA_FILE_RAW);
3639     }
3640     if (compression_type != QCOW2_COMPRESSION_TYPE_ZLIB) {
3641         header->incompatible_features |=
3642             cpu_to_be64(QCOW2_INCOMPAT_COMPRESSION);
3643     }
3644 
3645     if (qcow2_opts->extended_l2) {
3646         header->incompatible_features |=
3647             cpu_to_be64(QCOW2_INCOMPAT_EXTL2);
3648     }
3649 
3650     ret = blk_pwrite(blk, 0, header, cluster_size, 0);
3651     g_free(header);
3652     if (ret < 0) {
3653         error_setg_errno(errp, -ret, "Could not write qcow2 header");
3654         goto out;
3655     }
3656 
3657     /* Write a refcount table with one refcount block */
3658     refcount_table = g_malloc0(2 * cluster_size);
3659     refcount_table[0] = cpu_to_be64(2 * cluster_size);
3660     ret = blk_pwrite(blk, cluster_size, refcount_table, 2 * cluster_size, 0);
3661     g_free(refcount_table);
3662 
3663     if (ret < 0) {
3664         error_setg_errno(errp, -ret, "Could not write refcount table");
3665         goto out;
3666     }
3667 
3668     blk_unref(blk);
3669     blk = NULL;
3670 
3671     /*
3672      * And now open the image and make it consistent first (i.e. increase the
3673      * refcount of the cluster that is occupied by the header and the refcount
3674      * table)
3675      */
3676     options = qdict_new();
3677     qdict_put_str(options, "driver", "qcow2");
3678     qdict_put_str(options, "file", bs->node_name);
3679     if (data_bs) {
3680         qdict_put_str(options, "data-file", data_bs->node_name);
3681     }
3682     blk = blk_new_open(NULL, NULL, options,
3683                        BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_NO_FLUSH,
3684                        errp);
3685     if (blk == NULL) {
3686         ret = -EIO;
3687         goto out;
3688     }
3689 
3690     ret = qcow2_alloc_clusters(blk_bs(blk), 3 * cluster_size);
3691     if (ret < 0) {
3692         error_setg_errno(errp, -ret, "Could not allocate clusters for qcow2 "
3693                          "header and refcount table");
3694         goto out;
3695 
3696     } else if (ret != 0) {
3697         error_report("Huh, first cluster in empty image is already in use?");
3698         abort();
3699     }
3700 
3701     /* Set the external data file if necessary */
3702     if (data_bs) {
3703         BDRVQcow2State *s = blk_bs(blk)->opaque;
3704         s->image_data_file = g_strdup(data_bs->filename);
3705     }
3706 
3707     /* Create a full header (including things like feature table) */
3708     ret = qcow2_update_header(blk_bs(blk));
3709     if (ret < 0) {
3710         error_setg_errno(errp, -ret, "Could not update qcow2 header");
3711         goto out;
3712     }
3713 
3714     /* Okay, now that we have a valid image, let's give it the right size */
3715     ret = blk_truncate(blk, qcow2_opts->size, false, qcow2_opts->preallocation,
3716                        0, errp);
3717     if (ret < 0) {
3718         error_prepend(errp, "Could not resize image: ");
3719         goto out;
3720     }
3721 
3722     /* Want a backing file? There you go. */
3723     if (qcow2_opts->has_backing_file) {
3724         const char *backing_format = NULL;
3725 
3726         if (qcow2_opts->has_backing_fmt) {
3727             backing_format = BlockdevDriver_str(qcow2_opts->backing_fmt);
3728         }
3729 
3730         ret = bdrv_change_backing_file(blk_bs(blk), qcow2_opts->backing_file,
3731                                        backing_format, false);
3732         if (ret < 0) {
3733             error_setg_errno(errp, -ret, "Could not assign backing file '%s' "
3734                              "with format '%s'", qcow2_opts->backing_file,
3735                              backing_format);
3736             goto out;
3737         }
3738     }
3739 
3740     /* Want encryption? There you go. */
3741     if (qcow2_opts->has_encrypt) {
3742         ret = qcow2_set_up_encryption(blk_bs(blk), qcow2_opts->encrypt, errp);
3743         if (ret < 0) {
3744             goto out;
3745         }
3746     }
3747 
3748     blk_unref(blk);
3749     blk = NULL;
3750 
3751     /* Reopen the image without BDRV_O_NO_FLUSH to flush it before returning.
3752      * Using BDRV_O_NO_IO, since encryption is now setup we don't want to
3753      * have to setup decryption context. We're not doing any I/O on the top
3754      * level BlockDriverState, only lower layers, where BDRV_O_NO_IO does
3755      * not have effect.
3756      */
3757     options = qdict_new();
3758     qdict_put_str(options, "driver", "qcow2");
3759     qdict_put_str(options, "file", bs->node_name);
3760     if (data_bs) {
3761         qdict_put_str(options, "data-file", data_bs->node_name);
3762     }
3763     blk = blk_new_open(NULL, NULL, options,
3764                        BDRV_O_RDWR | BDRV_O_NO_BACKING | BDRV_O_NO_IO,
3765                        errp);
3766     if (blk == NULL) {
3767         ret = -EIO;
3768         goto out;
3769     }
3770 
3771     ret = 0;
3772 out:
3773     blk_unref(blk);
3774     bdrv_unref(bs);
3775     bdrv_unref(data_bs);
3776     return ret;
3777 }
3778 
qcow2_co_create_opts(BlockDriver * drv,const char * filename,QemuOpts * opts,Error ** errp)3779 static int coroutine_fn qcow2_co_create_opts(BlockDriver *drv,
3780                                              const char *filename,
3781                                              QemuOpts *opts,
3782                                              Error **errp)
3783 {
3784     BlockdevCreateOptions *create_options = NULL;
3785     QDict *qdict;
3786     Visitor *v;
3787     BlockDriverState *bs = NULL;
3788     BlockDriverState *data_bs = NULL;
3789     const char *val;
3790     int ret;
3791 
3792     /* Only the keyval visitor supports the dotted syntax needed for
3793      * encryption, so go through a QDict before getting a QAPI type. Ignore
3794      * options meant for the protocol layer so that the visitor doesn't
3795      * complain. */
3796     qdict = qemu_opts_to_qdict_filtered(opts, NULL, bdrv_qcow2.create_opts,
3797                                         true);
3798 
3799     /* Handle encryption options */
3800     val = qdict_get_try_str(qdict, BLOCK_OPT_ENCRYPT);
3801     if (val && !strcmp(val, "on")) {
3802         qdict_put_str(qdict, BLOCK_OPT_ENCRYPT, "qcow");
3803     } else if (val && !strcmp(val, "off")) {
3804         qdict_del(qdict, BLOCK_OPT_ENCRYPT);
3805     }
3806 
3807     val = qdict_get_try_str(qdict, BLOCK_OPT_ENCRYPT_FORMAT);
3808     if (val && !strcmp(val, "aes")) {
3809         qdict_put_str(qdict, BLOCK_OPT_ENCRYPT_FORMAT, "qcow");
3810     }
3811 
3812     /* Convert compat=0.10/1.1 into compat=v2/v3, to be renamed into
3813      * version=v2/v3 below. */
3814     val = qdict_get_try_str(qdict, BLOCK_OPT_COMPAT_LEVEL);
3815     if (val && !strcmp(val, "0.10")) {
3816         qdict_put_str(qdict, BLOCK_OPT_COMPAT_LEVEL, "v2");
3817     } else if (val && !strcmp(val, "1.1")) {
3818         qdict_put_str(qdict, BLOCK_OPT_COMPAT_LEVEL, "v3");
3819     }
3820 
3821     /* Change legacy command line options into QMP ones */
3822     static const QDictRenames opt_renames[] = {
3823         { BLOCK_OPT_BACKING_FILE,       "backing-file" },
3824         { BLOCK_OPT_BACKING_FMT,        "backing-fmt" },
3825         { BLOCK_OPT_CLUSTER_SIZE,       "cluster-size" },
3826         { BLOCK_OPT_LAZY_REFCOUNTS,     "lazy-refcounts" },
3827         { BLOCK_OPT_EXTL2,              "extended-l2" },
3828         { BLOCK_OPT_REFCOUNT_BITS,      "refcount-bits" },
3829         { BLOCK_OPT_ENCRYPT,            BLOCK_OPT_ENCRYPT_FORMAT },
3830         { BLOCK_OPT_COMPAT_LEVEL,       "version" },
3831         { BLOCK_OPT_DATA_FILE_RAW,      "data-file-raw" },
3832         { BLOCK_OPT_COMPRESSION_TYPE,   "compression-type" },
3833         { NULL, NULL },
3834     };
3835 
3836     if (!qdict_rename_keys(qdict, opt_renames, errp)) {
3837         ret = -EINVAL;
3838         goto finish;
3839     }
3840 
3841     /* Create and open the file (protocol layer) */
3842     ret = bdrv_create_file(filename, opts, errp);
3843     if (ret < 0) {
3844         goto finish;
3845     }
3846 
3847     bs = bdrv_open(filename, NULL, NULL,
3848                    BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, errp);
3849     if (bs == NULL) {
3850         ret = -EIO;
3851         goto finish;
3852     }
3853 
3854     /* Create and open an external data file (protocol layer) */
3855     val = qdict_get_try_str(qdict, BLOCK_OPT_DATA_FILE);
3856     if (val) {
3857         ret = bdrv_create_file(val, opts, errp);
3858         if (ret < 0) {
3859             goto finish;
3860         }
3861 
3862         data_bs = bdrv_open(val, NULL, NULL,
3863                             BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL,
3864                             errp);
3865         if (data_bs == NULL) {
3866             ret = -EIO;
3867             goto finish;
3868         }
3869 
3870         qdict_del(qdict, BLOCK_OPT_DATA_FILE);
3871         qdict_put_str(qdict, "data-file", data_bs->node_name);
3872     }
3873 
3874     /* Set 'driver' and 'node' options */
3875     qdict_put_str(qdict, "driver", "qcow2");
3876     qdict_put_str(qdict, "file", bs->node_name);
3877 
3878     /* Now get the QAPI type BlockdevCreateOptions */
3879     v = qobject_input_visitor_new_flat_confused(qdict, errp);
3880     if (!v) {
3881         ret = -EINVAL;
3882         goto finish;
3883     }
3884 
3885     visit_type_BlockdevCreateOptions(v, NULL, &create_options, errp);
3886     visit_free(v);
3887     if (!create_options) {
3888         ret = -EINVAL;
3889         goto finish;
3890     }
3891 
3892     /* Silently round up size */
3893     create_options->u.qcow2.size = ROUND_UP(create_options->u.qcow2.size,
3894                                             BDRV_SECTOR_SIZE);
3895 
3896     /* Create the qcow2 image (format layer) */
3897     ret = qcow2_co_create(create_options, errp);
3898 finish:
3899     if (ret < 0) {
3900         bdrv_co_delete_file_noerr(bs);
3901         bdrv_co_delete_file_noerr(data_bs);
3902     } else {
3903         ret = 0;
3904     }
3905 
3906     qobject_unref(qdict);
3907     bdrv_unref(bs);
3908     bdrv_unref(data_bs);
3909     qapi_free_BlockdevCreateOptions(create_options);
3910     return ret;
3911 }
3912 
3913 
is_zero(BlockDriverState * bs,int64_t offset,int64_t bytes)3914 static bool is_zero(BlockDriverState *bs, int64_t offset, int64_t bytes)
3915 {
3916     int64_t nr;
3917     int res;
3918 
3919     /* Clamp to image length, before checking status of underlying sectors */
3920     if (offset + bytes > bs->total_sectors * BDRV_SECTOR_SIZE) {
3921         bytes = bs->total_sectors * BDRV_SECTOR_SIZE - offset;
3922     }
3923 
3924     if (!bytes) {
3925         return true;
3926     }
3927 
3928     /*
3929      * bdrv_block_status_above doesn't merge different types of zeros, for
3930      * example, zeros which come from the region which is unallocated in
3931      * the whole backing chain, and zeros which come because of a short
3932      * backing file. So, we need a loop.
3933      */
3934     do {
3935         res = bdrv_block_status_above(bs, NULL, offset, bytes, &nr, NULL, NULL);
3936         offset += nr;
3937         bytes -= nr;
3938     } while (res >= 0 && (res & BDRV_BLOCK_ZERO) && nr && bytes);
3939 
3940     return res >= 0 && (res & BDRV_BLOCK_ZERO) && bytes == 0;
3941 }
3942 
qcow2_co_pwrite_zeroes(BlockDriverState * bs,int64_t offset,int64_t bytes,BdrvRequestFlags flags)3943 static coroutine_fn int qcow2_co_pwrite_zeroes(BlockDriverState *bs,
3944     int64_t offset, int64_t bytes, BdrvRequestFlags flags)
3945 {
3946     int ret;
3947     BDRVQcow2State *s = bs->opaque;
3948 
3949     uint32_t head = offset_into_subcluster(s, offset);
3950     uint32_t tail = ROUND_UP(offset + bytes, s->subcluster_size) -
3951         (offset + bytes);
3952 
3953     trace_qcow2_pwrite_zeroes_start_req(qemu_coroutine_self(), offset, bytes);
3954     if (offset + bytes == bs->total_sectors * BDRV_SECTOR_SIZE) {
3955         tail = 0;
3956     }
3957 
3958     if (head || tail) {
3959         uint64_t off;
3960         unsigned int nr;
3961         QCow2SubclusterType type;
3962 
3963         assert(head + bytes + tail <= s->subcluster_size);
3964 
3965         /* check whether remainder of cluster already reads as zero */
3966         if (!(is_zero(bs, offset - head, head) &&
3967               is_zero(bs, offset + bytes, tail))) {
3968             return -ENOTSUP;
3969         }
3970 
3971         qemu_co_mutex_lock(&s->lock);
3972         /* We can have new write after previous check */
3973         offset -= head;
3974         bytes = s->subcluster_size;
3975         nr = s->subcluster_size;
3976         ret = qcow2_get_host_offset(bs, offset, &nr, &off, &type);
3977         if (ret < 0 ||
3978             (type != QCOW2_SUBCLUSTER_UNALLOCATED_PLAIN &&
3979              type != QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC &&
3980              type != QCOW2_SUBCLUSTER_ZERO_PLAIN &&
3981              type != QCOW2_SUBCLUSTER_ZERO_ALLOC)) {
3982             qemu_co_mutex_unlock(&s->lock);
3983             return ret < 0 ? ret : -ENOTSUP;
3984         }
3985     } else {
3986         qemu_co_mutex_lock(&s->lock);
3987     }
3988 
3989     trace_qcow2_pwrite_zeroes(qemu_coroutine_self(), offset, bytes);
3990 
3991     /* Whatever is left can use real zero subclusters */
3992     ret = qcow2_subcluster_zeroize(bs, offset, bytes, flags);
3993     qemu_co_mutex_unlock(&s->lock);
3994 
3995     return ret;
3996 }
3997 
qcow2_co_pdiscard(BlockDriverState * bs,int64_t offset,int64_t bytes)3998 static coroutine_fn int qcow2_co_pdiscard(BlockDriverState *bs,
3999                                           int64_t offset, int64_t bytes)
4000 {
4001     int ret;
4002     BDRVQcow2State *s = bs->opaque;
4003 
4004     /* If the image does not support QCOW_OFLAG_ZERO then discarding
4005      * clusters could expose stale data from the backing file. */
4006     if (s->qcow_version < 3 && bs->backing) {
4007         return -ENOTSUP;
4008     }
4009 
4010     if (!QEMU_IS_ALIGNED(offset | bytes, s->cluster_size)) {
4011         assert(bytes < s->cluster_size);
4012         /* Ignore partial clusters, except for the special case of the
4013          * complete partial cluster at the end of an unaligned file */
4014         if (!QEMU_IS_ALIGNED(offset, s->cluster_size) ||
4015             offset + bytes != bs->total_sectors * BDRV_SECTOR_SIZE) {
4016             return -ENOTSUP;
4017         }
4018     }
4019 
4020     qemu_co_mutex_lock(&s->lock);
4021     ret = qcow2_cluster_discard(bs, offset, bytes, QCOW2_DISCARD_REQUEST,
4022                                 false);
4023     qemu_co_mutex_unlock(&s->lock);
4024     return ret;
4025 }
4026 
4027 static int coroutine_fn
qcow2_co_copy_range_from(BlockDriverState * bs,BdrvChild * src,int64_t src_offset,BdrvChild * dst,int64_t dst_offset,int64_t bytes,BdrvRequestFlags read_flags,BdrvRequestFlags write_flags)4028 qcow2_co_copy_range_from(BlockDriverState *bs,
4029                          BdrvChild *src, int64_t src_offset,
4030                          BdrvChild *dst, int64_t dst_offset,
4031                          int64_t bytes, BdrvRequestFlags read_flags,
4032                          BdrvRequestFlags write_flags)
4033 {
4034     BDRVQcow2State *s = bs->opaque;
4035     int ret;
4036     unsigned int cur_bytes; /* number of bytes in current iteration */
4037     BdrvChild *child = NULL;
4038     BdrvRequestFlags cur_write_flags;
4039 
4040     assert(!bs->encrypted);
4041     qemu_co_mutex_lock(&s->lock);
4042 
4043     while (bytes != 0) {
4044         uint64_t copy_offset = 0;
4045         QCow2SubclusterType type;
4046         /* prepare next request */
4047         cur_bytes = MIN(bytes, INT_MAX);
4048         cur_write_flags = write_flags;
4049 
4050         ret = qcow2_get_host_offset(bs, src_offset, &cur_bytes,
4051                                     &copy_offset, &type);
4052         if (ret < 0) {
4053             goto out;
4054         }
4055 
4056         switch (type) {
4057         case QCOW2_SUBCLUSTER_UNALLOCATED_PLAIN:
4058         case QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC:
4059             if (bs->backing && bs->backing->bs) {
4060                 int64_t backing_length = bdrv_getlength(bs->backing->bs);
4061                 if (src_offset >= backing_length) {
4062                     cur_write_flags |= BDRV_REQ_ZERO_WRITE;
4063                 } else {
4064                     child = bs->backing;
4065                     cur_bytes = MIN(cur_bytes, backing_length - src_offset);
4066                     copy_offset = src_offset;
4067                 }
4068             } else {
4069                 cur_write_flags |= BDRV_REQ_ZERO_WRITE;
4070             }
4071             break;
4072 
4073         case QCOW2_SUBCLUSTER_ZERO_PLAIN:
4074         case QCOW2_SUBCLUSTER_ZERO_ALLOC:
4075             cur_write_flags |= BDRV_REQ_ZERO_WRITE;
4076             break;
4077 
4078         case QCOW2_SUBCLUSTER_COMPRESSED:
4079             ret = -ENOTSUP;
4080             goto out;
4081 
4082         case QCOW2_SUBCLUSTER_NORMAL:
4083             child = s->data_file;
4084             break;
4085 
4086         default:
4087             abort();
4088         }
4089         qemu_co_mutex_unlock(&s->lock);
4090         ret = bdrv_co_copy_range_from(child,
4091                                       copy_offset,
4092                                       dst, dst_offset,
4093                                       cur_bytes, read_flags, cur_write_flags);
4094         qemu_co_mutex_lock(&s->lock);
4095         if (ret < 0) {
4096             goto out;
4097         }
4098 
4099         bytes -= cur_bytes;
4100         src_offset += cur_bytes;
4101         dst_offset += cur_bytes;
4102     }
4103     ret = 0;
4104 
4105 out:
4106     qemu_co_mutex_unlock(&s->lock);
4107     return ret;
4108 }
4109 
4110 static int coroutine_fn
qcow2_co_copy_range_to(BlockDriverState * bs,BdrvChild * src,int64_t src_offset,BdrvChild * dst,int64_t dst_offset,int64_t bytes,BdrvRequestFlags read_flags,BdrvRequestFlags write_flags)4111 qcow2_co_copy_range_to(BlockDriverState *bs,
4112                        BdrvChild *src, int64_t src_offset,
4113                        BdrvChild *dst, int64_t dst_offset,
4114                        int64_t bytes, BdrvRequestFlags read_flags,
4115                        BdrvRequestFlags write_flags)
4116 {
4117     BDRVQcow2State *s = bs->opaque;
4118     int ret;
4119     unsigned int cur_bytes; /* number of sectors in current iteration */
4120     uint64_t host_offset;
4121     QCowL2Meta *l2meta = NULL;
4122 
4123     assert(!bs->encrypted);
4124 
4125     qemu_co_mutex_lock(&s->lock);
4126 
4127     while (bytes != 0) {
4128 
4129         l2meta = NULL;
4130 
4131         cur_bytes = MIN(bytes, INT_MAX);
4132 
4133         /* TODO:
4134          * If src->bs == dst->bs, we could simply copy by incrementing
4135          * the refcnt, without copying user data.
4136          * Or if src->bs == dst->bs->backing->bs, we could copy by discarding. */
4137         ret = qcow2_alloc_host_offset(bs, dst_offset, &cur_bytes,
4138                                       &host_offset, &l2meta);
4139         if (ret < 0) {
4140             goto fail;
4141         }
4142 
4143         ret = qcow2_pre_write_overlap_check(bs, 0, host_offset, cur_bytes,
4144                                             true);
4145         if (ret < 0) {
4146             goto fail;
4147         }
4148 
4149         qemu_co_mutex_unlock(&s->lock);
4150         ret = bdrv_co_copy_range_to(src, src_offset, s->data_file, host_offset,
4151                                     cur_bytes, read_flags, write_flags);
4152         qemu_co_mutex_lock(&s->lock);
4153         if (ret < 0) {
4154             goto fail;
4155         }
4156 
4157         ret = qcow2_handle_l2meta(bs, &l2meta, true);
4158         if (ret) {
4159             goto fail;
4160         }
4161 
4162         bytes -= cur_bytes;
4163         src_offset += cur_bytes;
4164         dst_offset += cur_bytes;
4165     }
4166     ret = 0;
4167 
4168 fail:
4169     qcow2_handle_l2meta(bs, &l2meta, false);
4170 
4171     qemu_co_mutex_unlock(&s->lock);
4172 
4173     trace_qcow2_writev_done_req(qemu_coroutine_self(), ret);
4174 
4175     return ret;
4176 }
4177 
qcow2_co_truncate(BlockDriverState * bs,int64_t offset,bool exact,PreallocMode prealloc,BdrvRequestFlags flags,Error ** errp)4178 static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
4179                                           bool exact, PreallocMode prealloc,
4180                                           BdrvRequestFlags flags, Error **errp)
4181 {
4182     BDRVQcow2State *s = bs->opaque;
4183     uint64_t old_length;
4184     int64_t new_l1_size;
4185     int ret;
4186     QDict *options;
4187 
4188     if (prealloc != PREALLOC_MODE_OFF && prealloc != PREALLOC_MODE_METADATA &&
4189         prealloc != PREALLOC_MODE_FALLOC && prealloc != PREALLOC_MODE_FULL)
4190     {
4191         error_setg(errp, "Unsupported preallocation mode '%s'",
4192                    PreallocMode_str(prealloc));
4193         return -ENOTSUP;
4194     }
4195 
4196     if (!QEMU_IS_ALIGNED(offset, BDRV_SECTOR_SIZE)) {
4197         error_setg(errp, "The new size must be a multiple of %u",
4198                    (unsigned) BDRV_SECTOR_SIZE);
4199         return -EINVAL;
4200     }
4201 
4202     qemu_co_mutex_lock(&s->lock);
4203 
4204     /*
4205      * Even though we store snapshot size for all images, it was not
4206      * required until v3, so it is not safe to proceed for v2.
4207      */
4208     if (s->nb_snapshots && s->qcow_version < 3) {
4209         error_setg(errp, "Can't resize a v2 image which has snapshots");
4210         ret = -ENOTSUP;
4211         goto fail;
4212     }
4213 
4214     /* See qcow2-bitmap.c for which bitmap scenarios prevent a resize. */
4215     if (qcow2_truncate_bitmaps_check(bs, errp)) {
4216         ret = -ENOTSUP;
4217         goto fail;
4218     }
4219 
4220     old_length = bs->total_sectors * BDRV_SECTOR_SIZE;
4221     new_l1_size = size_to_l1(s, offset);
4222 
4223     if (offset < old_length) {
4224         int64_t last_cluster, old_file_size;
4225         if (prealloc != PREALLOC_MODE_OFF) {
4226             error_setg(errp,
4227                        "Preallocation can't be used for shrinking an image");
4228             ret = -EINVAL;
4229             goto fail;
4230         }
4231 
4232         ret = qcow2_cluster_discard(bs, ROUND_UP(offset, s->cluster_size),
4233                                     old_length - ROUND_UP(offset,
4234                                                           s->cluster_size),
4235                                     QCOW2_DISCARD_ALWAYS, true);
4236         if (ret < 0) {
4237             error_setg_errno(errp, -ret, "Failed to discard cropped clusters");
4238             goto fail;
4239         }
4240 
4241         ret = qcow2_shrink_l1_table(bs, new_l1_size);
4242         if (ret < 0) {
4243             error_setg_errno(errp, -ret,
4244                              "Failed to reduce the number of L2 tables");
4245             goto fail;
4246         }
4247 
4248         ret = qcow2_shrink_reftable(bs);
4249         if (ret < 0) {
4250             error_setg_errno(errp, -ret,
4251                              "Failed to discard unused refblocks");
4252             goto fail;
4253         }
4254 
4255         old_file_size = bdrv_getlength(bs->file->bs);
4256         if (old_file_size < 0) {
4257             error_setg_errno(errp, -old_file_size,
4258                              "Failed to inquire current file length");
4259             ret = old_file_size;
4260             goto fail;
4261         }
4262         last_cluster = qcow2_get_last_cluster(bs, old_file_size);
4263         if (last_cluster < 0) {
4264             error_setg_errno(errp, -last_cluster,
4265                              "Failed to find the last cluster");
4266             ret = last_cluster;
4267             goto fail;
4268         }
4269         if ((last_cluster + 1) * s->cluster_size < old_file_size) {
4270             Error *local_err = NULL;
4271 
4272             /*
4273              * Do not pass @exact here: It will not help the user if
4274              * we get an error here just because they wanted to shrink
4275              * their qcow2 image (on a block device) with qemu-img.
4276              * (And on the qcow2 layer, the @exact requirement is
4277              * always fulfilled, so there is no need to pass it on.)
4278              */
4279             bdrv_co_truncate(bs->file, (last_cluster + 1) * s->cluster_size,
4280                              false, PREALLOC_MODE_OFF, 0, &local_err);
4281             if (local_err) {
4282                 warn_reportf_err(local_err,
4283                                  "Failed to truncate the tail of the image: ");
4284             }
4285         }
4286     } else {
4287         ret = qcow2_grow_l1_table(bs, new_l1_size, true);
4288         if (ret < 0) {
4289             error_setg_errno(errp, -ret, "Failed to grow the L1 table");
4290             goto fail;
4291         }
4292 
4293         if (data_file_is_raw(bs) && prealloc == PREALLOC_MODE_OFF) {
4294             /*
4295              * When creating a qcow2 image with data-file-raw, we enforce
4296              * at least prealloc=metadata, so that the L1/L2 tables are
4297              * fully allocated and reading from the data file will return
4298              * the same data as reading from the qcow2 image.  When the
4299              * image is grown, we must consequently preallocate the
4300              * metadata structures to cover the added area.
4301              */
4302             prealloc = PREALLOC_MODE_METADATA;
4303         }
4304     }
4305 
4306     switch (prealloc) {
4307     case PREALLOC_MODE_OFF:
4308         if (has_data_file(bs)) {
4309             /*
4310              * If the caller wants an exact resize, the external data
4311              * file should be resized to the exact target size, too,
4312              * so we pass @exact here.
4313              */
4314             ret = bdrv_co_truncate(s->data_file, offset, exact, prealloc, 0,
4315                                    errp);
4316             if (ret < 0) {
4317                 goto fail;
4318             }
4319         }
4320         break;
4321 
4322     case PREALLOC_MODE_METADATA:
4323         ret = preallocate_co(bs, old_length, offset, prealloc, errp);
4324         if (ret < 0) {
4325             goto fail;
4326         }
4327         break;
4328 
4329     case PREALLOC_MODE_FALLOC:
4330     case PREALLOC_MODE_FULL:
4331     {
4332         int64_t allocation_start, host_offset, guest_offset;
4333         int64_t clusters_allocated;
4334         int64_t old_file_size, last_cluster, new_file_size;
4335         uint64_t nb_new_data_clusters, nb_new_l2_tables;
4336         bool subclusters_need_allocation = false;
4337 
4338         /* With a data file, preallocation means just allocating the metadata
4339          * and forwarding the truncate request to the data file */
4340         if (has_data_file(bs)) {
4341             ret = preallocate_co(bs, old_length, offset, prealloc, errp);
4342             if (ret < 0) {
4343                 goto fail;
4344             }
4345             break;
4346         }
4347 
4348         old_file_size = bdrv_getlength(bs->file->bs);
4349         if (old_file_size < 0) {
4350             error_setg_errno(errp, -old_file_size,
4351                              "Failed to inquire current file length");
4352             ret = old_file_size;
4353             goto fail;
4354         }
4355 
4356         last_cluster = qcow2_get_last_cluster(bs, old_file_size);
4357         if (last_cluster >= 0) {
4358             old_file_size = (last_cluster + 1) * s->cluster_size;
4359         } else {
4360             old_file_size = ROUND_UP(old_file_size, s->cluster_size);
4361         }
4362 
4363         nb_new_data_clusters = (ROUND_UP(offset, s->cluster_size) -
4364             start_of_cluster(s, old_length)) >> s->cluster_bits;
4365 
4366         /* This is an overestimation; we will not actually allocate space for
4367          * these in the file but just make sure the new refcount structures are
4368          * able to cover them so we will not have to allocate new refblocks
4369          * while entering the data blocks in the potentially new L2 tables.
4370          * (We do not actually care where the L2 tables are placed. Maybe they
4371          *  are already allocated or they can be placed somewhere before
4372          *  @old_file_size. It does not matter because they will be fully
4373          *  allocated automatically, so they do not need to be covered by the
4374          *  preallocation. All that matters is that we will not have to allocate
4375          *  new refcount structures for them.) */
4376         nb_new_l2_tables = DIV_ROUND_UP(nb_new_data_clusters,
4377                                         s->cluster_size / l2_entry_size(s));
4378         /* The cluster range may not be aligned to L2 boundaries, so add one L2
4379          * table for a potential head/tail */
4380         nb_new_l2_tables++;
4381 
4382         allocation_start = qcow2_refcount_area(bs, old_file_size,
4383                                                nb_new_data_clusters +
4384                                                nb_new_l2_tables,
4385                                                true, 0, 0);
4386         if (allocation_start < 0) {
4387             error_setg_errno(errp, -allocation_start,
4388                              "Failed to resize refcount structures");
4389             ret = allocation_start;
4390             goto fail;
4391         }
4392 
4393         clusters_allocated = qcow2_alloc_clusters_at(bs, allocation_start,
4394                                                      nb_new_data_clusters);
4395         if (clusters_allocated < 0) {
4396             error_setg_errno(errp, -clusters_allocated,
4397                              "Failed to allocate data clusters");
4398             ret = clusters_allocated;
4399             goto fail;
4400         }
4401 
4402         assert(clusters_allocated == nb_new_data_clusters);
4403 
4404         /* Allocate the data area */
4405         new_file_size = allocation_start +
4406                         nb_new_data_clusters * s->cluster_size;
4407         /*
4408          * Image file grows, so @exact does not matter.
4409          *
4410          * If we need to zero out the new area, try first whether the protocol
4411          * driver can already take care of this.
4412          */
4413         if (flags & BDRV_REQ_ZERO_WRITE) {
4414             ret = bdrv_co_truncate(bs->file, new_file_size, false, prealloc,
4415                                    BDRV_REQ_ZERO_WRITE, NULL);
4416             if (ret >= 0) {
4417                 flags &= ~BDRV_REQ_ZERO_WRITE;
4418                 /* Ensure that we read zeroes and not backing file data */
4419                 subclusters_need_allocation = true;
4420             }
4421         } else {
4422             ret = -1;
4423         }
4424         if (ret < 0) {
4425             ret = bdrv_co_truncate(bs->file, new_file_size, false, prealloc, 0,
4426                                    errp);
4427         }
4428         if (ret < 0) {
4429             error_prepend(errp, "Failed to resize underlying file: ");
4430             qcow2_free_clusters(bs, allocation_start,
4431                                 nb_new_data_clusters * s->cluster_size,
4432                                 QCOW2_DISCARD_OTHER);
4433             goto fail;
4434         }
4435 
4436         /* Create the necessary L2 entries */
4437         host_offset = allocation_start;
4438         guest_offset = old_length;
4439         while (nb_new_data_clusters) {
4440             int64_t nb_clusters = MIN(
4441                 nb_new_data_clusters,
4442                 s->l2_slice_size - offset_to_l2_slice_index(s, guest_offset));
4443             unsigned cow_start_length = offset_into_cluster(s, guest_offset);
4444             QCowL2Meta allocation;
4445             guest_offset = start_of_cluster(s, guest_offset);
4446             allocation = (QCowL2Meta) {
4447                 .offset       = guest_offset,
4448                 .alloc_offset = host_offset,
4449                 .nb_clusters  = nb_clusters,
4450                 .cow_start    = {
4451                     .offset       = 0,
4452                     .nb_bytes     = cow_start_length,
4453                 },
4454                 .cow_end      = {
4455                     .offset       = nb_clusters << s->cluster_bits,
4456                     .nb_bytes     = 0,
4457                 },
4458                 .prealloc     = !subclusters_need_allocation,
4459             };
4460             qemu_co_queue_init(&allocation.dependent_requests);
4461 
4462             ret = qcow2_alloc_cluster_link_l2(bs, &allocation);
4463             if (ret < 0) {
4464                 error_setg_errno(errp, -ret, "Failed to update L2 tables");
4465                 qcow2_free_clusters(bs, host_offset,
4466                                     nb_new_data_clusters * s->cluster_size,
4467                                     QCOW2_DISCARD_OTHER);
4468                 goto fail;
4469             }
4470 
4471             guest_offset += nb_clusters * s->cluster_size;
4472             host_offset += nb_clusters * s->cluster_size;
4473             nb_new_data_clusters -= nb_clusters;
4474         }
4475         break;
4476     }
4477 
4478     default:
4479         g_assert_not_reached();
4480     }
4481 
4482     if ((flags & BDRV_REQ_ZERO_WRITE) && offset > old_length) {
4483         uint64_t zero_start = QEMU_ALIGN_UP(old_length, s->subcluster_size);
4484 
4485         /*
4486          * Use zero clusters as much as we can. qcow2_subcluster_zeroize()
4487          * requires a subcluster-aligned start. The end may be unaligned if
4488          * it is at the end of the image (which it is here).
4489          */
4490         if (offset > zero_start) {
4491             ret = qcow2_subcluster_zeroize(bs, zero_start, offset - zero_start,
4492                                            0);
4493             if (ret < 0) {
4494                 error_setg_errno(errp, -ret, "Failed to zero out new clusters");
4495                 goto fail;
4496             }
4497         }
4498 
4499         /* Write explicit zeros for the unaligned head */
4500         if (zero_start > old_length) {
4501             uint64_t len = MIN(zero_start, offset) - old_length;
4502             uint8_t *buf = qemu_blockalign0(bs, len);
4503             QEMUIOVector qiov;
4504             qemu_iovec_init_buf(&qiov, buf, len);
4505 
4506             qemu_co_mutex_unlock(&s->lock);
4507             ret = qcow2_co_pwritev_part(bs, old_length, len, &qiov, 0, 0);
4508             qemu_co_mutex_lock(&s->lock);
4509 
4510             qemu_vfree(buf);
4511             if (ret < 0) {
4512                 error_setg_errno(errp, -ret, "Failed to zero out the new area");
4513                 goto fail;
4514             }
4515         }
4516     }
4517 
4518     if (prealloc != PREALLOC_MODE_OFF) {
4519         /* Flush metadata before actually changing the image size */
4520         ret = qcow2_write_caches(bs);
4521         if (ret < 0) {
4522             error_setg_errno(errp, -ret,
4523                              "Failed to flush the preallocated area to disk");
4524             goto fail;
4525         }
4526     }
4527 
4528     bs->total_sectors = offset / BDRV_SECTOR_SIZE;
4529 
4530     /* write updated header.size */
4531     offset = cpu_to_be64(offset);
4532     ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, size),
4533                            &offset, sizeof(offset));
4534     if (ret < 0) {
4535         error_setg_errno(errp, -ret, "Failed to update the image size");
4536         goto fail;
4537     }
4538 
4539     s->l1_vm_state_index = new_l1_size;
4540 
4541     /* Update cache sizes */
4542     options = qdict_clone_shallow(bs->options);
4543     ret = qcow2_update_options(bs, options, s->flags, errp);
4544     qobject_unref(options);
4545     if (ret < 0) {
4546         goto fail;
4547     }
4548     ret = 0;
4549 fail:
4550     qemu_co_mutex_unlock(&s->lock);
4551     return ret;
4552 }
4553 
4554 static coroutine_fn int
qcow2_co_pwritev_compressed_task(BlockDriverState * bs,uint64_t offset,uint64_t bytes,QEMUIOVector * qiov,size_t qiov_offset)4555 qcow2_co_pwritev_compressed_task(BlockDriverState *bs,
4556                                  uint64_t offset, uint64_t bytes,
4557                                  QEMUIOVector *qiov, size_t qiov_offset)
4558 {
4559     BDRVQcow2State *s = bs->opaque;
4560     int ret;
4561     ssize_t out_len;
4562     uint8_t *buf, *out_buf;
4563     uint64_t cluster_offset;
4564 
4565     assert(bytes == s->cluster_size || (bytes < s->cluster_size &&
4566            (offset + bytes == bs->total_sectors << BDRV_SECTOR_BITS)));
4567 
4568     buf = qemu_blockalign(bs, s->cluster_size);
4569     if (bytes < s->cluster_size) {
4570         /* Zero-pad last write if image size is not cluster aligned */
4571         memset(buf + bytes, 0, s->cluster_size - bytes);
4572     }
4573     qemu_iovec_to_buf(qiov, qiov_offset, buf, bytes);
4574 
4575     out_buf = g_malloc(s->cluster_size);
4576 
4577     out_len = qcow2_co_compress(bs, out_buf, s->cluster_size - 1,
4578                                 buf, s->cluster_size);
4579     if (out_len == -ENOMEM) {
4580         /* could not compress: write normal cluster */
4581         ret = qcow2_co_pwritev_part(bs, offset, bytes, qiov, qiov_offset, 0);
4582         if (ret < 0) {
4583             goto fail;
4584         }
4585         goto success;
4586     } else if (out_len < 0) {
4587         ret = -EINVAL;
4588         goto fail;
4589     }
4590 
4591     qemu_co_mutex_lock(&s->lock);
4592     ret = qcow2_alloc_compressed_cluster_offset(bs, offset, out_len,
4593                                                 &cluster_offset);
4594     if (ret < 0) {
4595         qemu_co_mutex_unlock(&s->lock);
4596         goto fail;
4597     }
4598 
4599     ret = qcow2_pre_write_overlap_check(bs, 0, cluster_offset, out_len, true);
4600     qemu_co_mutex_unlock(&s->lock);
4601     if (ret < 0) {
4602         goto fail;
4603     }
4604 
4605     BLKDBG_EVENT(s->data_file, BLKDBG_WRITE_COMPRESSED);
4606     ret = bdrv_co_pwrite(s->data_file, cluster_offset, out_len, out_buf, 0);
4607     if (ret < 0) {
4608         goto fail;
4609     }
4610 success:
4611     ret = 0;
4612 fail:
4613     qemu_vfree(buf);
4614     g_free(out_buf);
4615     return ret;
4616 }
4617 
qcow2_co_pwritev_compressed_task_entry(AioTask * task)4618 static coroutine_fn int qcow2_co_pwritev_compressed_task_entry(AioTask *task)
4619 {
4620     Qcow2AioTask *t = container_of(task, Qcow2AioTask, task);
4621 
4622     assert(!t->subcluster_type && !t->l2meta);
4623 
4624     return qcow2_co_pwritev_compressed_task(t->bs, t->offset, t->bytes, t->qiov,
4625                                             t->qiov_offset);
4626 }
4627 
4628 /*
4629  * XXX: put compressed sectors first, then all the cluster aligned
4630  * tables to avoid losing bytes in alignment
4631  */
4632 static coroutine_fn int
qcow2_co_pwritev_compressed_part(BlockDriverState * bs,int64_t offset,int64_t bytes,QEMUIOVector * qiov,size_t qiov_offset)4633 qcow2_co_pwritev_compressed_part(BlockDriverState *bs,
4634                                  int64_t offset, int64_t bytes,
4635                                  QEMUIOVector *qiov, size_t qiov_offset)
4636 {
4637     BDRVQcow2State *s = bs->opaque;
4638     AioTaskPool *aio = NULL;
4639     int ret = 0;
4640 
4641     if (has_data_file(bs)) {
4642         return -ENOTSUP;
4643     }
4644 
4645     if (bytes == 0) {
4646         /*
4647          * align end of file to a sector boundary to ease reading with
4648          * sector based I/Os
4649          */
4650         int64_t len = bdrv_getlength(bs->file->bs);
4651         if (len < 0) {
4652             return len;
4653         }
4654         return bdrv_co_truncate(bs->file, len, false, PREALLOC_MODE_OFF, 0,
4655                                 NULL);
4656     }
4657 
4658     if (offset_into_cluster(s, offset)) {
4659         return -EINVAL;
4660     }
4661 
4662     if (offset_into_cluster(s, bytes) &&
4663         (offset + bytes) != (bs->total_sectors << BDRV_SECTOR_BITS)) {
4664         return -EINVAL;
4665     }
4666 
4667     while (bytes && aio_task_pool_status(aio) == 0) {
4668         uint64_t chunk_size = MIN(bytes, s->cluster_size);
4669 
4670         if (!aio && chunk_size != bytes) {
4671             aio = aio_task_pool_new(QCOW2_MAX_WORKERS);
4672         }
4673 
4674         ret = qcow2_add_task(bs, aio, qcow2_co_pwritev_compressed_task_entry,
4675                              0, 0, offset, chunk_size, qiov, qiov_offset, NULL);
4676         if (ret < 0) {
4677             break;
4678         }
4679         qiov_offset += chunk_size;
4680         offset += chunk_size;
4681         bytes -= chunk_size;
4682     }
4683 
4684     if (aio) {
4685         aio_task_pool_wait_all(aio);
4686         if (ret == 0) {
4687             ret = aio_task_pool_status(aio);
4688         }
4689         g_free(aio);
4690     }
4691 
4692     return ret;
4693 }
4694 
4695 static int coroutine_fn
qcow2_co_preadv_compressed(BlockDriverState * bs,uint64_t l2_entry,uint64_t offset,uint64_t bytes,QEMUIOVector * qiov,size_t qiov_offset)4696 qcow2_co_preadv_compressed(BlockDriverState *bs,
4697                            uint64_t l2_entry,
4698                            uint64_t offset,
4699                            uint64_t bytes,
4700                            QEMUIOVector *qiov,
4701                            size_t qiov_offset)
4702 {
4703     BDRVQcow2State *s = bs->opaque;
4704     int ret = 0, csize;
4705     uint64_t coffset;
4706     uint8_t *buf, *out_buf;
4707     int offset_in_cluster = offset_into_cluster(s, offset);
4708 
4709     qcow2_parse_compressed_l2_entry(bs, l2_entry, &coffset, &csize);
4710 
4711     buf = g_try_malloc(csize);
4712     if (!buf) {
4713         return -ENOMEM;
4714     }
4715 
4716     out_buf = qemu_blockalign(bs, s->cluster_size);
4717 
4718     BLKDBG_EVENT(bs->file, BLKDBG_READ_COMPRESSED);
4719     ret = bdrv_co_pread(bs->file, coffset, csize, buf, 0);
4720     if (ret < 0) {
4721         goto fail;
4722     }
4723 
4724     if (qcow2_co_decompress(bs, out_buf, s->cluster_size, buf, csize) < 0) {
4725         ret = -EIO;
4726         goto fail;
4727     }
4728 
4729     qemu_iovec_from_buf(qiov, qiov_offset, out_buf + offset_in_cluster, bytes);
4730 
4731 fail:
4732     qemu_vfree(out_buf);
4733     g_free(buf);
4734 
4735     return ret;
4736 }
4737 
make_completely_empty(BlockDriverState * bs)4738 static int make_completely_empty(BlockDriverState *bs)
4739 {
4740     BDRVQcow2State *s = bs->opaque;
4741     Error *local_err = NULL;
4742     int ret, l1_clusters;
4743     int64_t offset;
4744     uint64_t *new_reftable = NULL;
4745     uint64_t rt_entry, l1_size2;
4746     struct {
4747         uint64_t l1_offset;
4748         uint64_t reftable_offset;
4749         uint32_t reftable_clusters;
4750     } QEMU_PACKED l1_ofs_rt_ofs_cls;
4751 
4752     ret = qcow2_cache_empty(bs, s->l2_table_cache);
4753     if (ret < 0) {
4754         goto fail;
4755     }
4756 
4757     ret = qcow2_cache_empty(bs, s->refcount_block_cache);
4758     if (ret < 0) {
4759         goto fail;
4760     }
4761 
4762     /* Refcounts will be broken utterly */
4763     ret = qcow2_mark_dirty(bs);
4764     if (ret < 0) {
4765         goto fail;
4766     }
4767 
4768     BLKDBG_EVENT(bs->file, BLKDBG_L1_UPDATE);
4769 
4770     l1_clusters = DIV_ROUND_UP(s->l1_size, s->cluster_size / L1E_SIZE);
4771     l1_size2 = (uint64_t)s->l1_size * L1E_SIZE;
4772 
4773     /* After this call, neither the in-memory nor the on-disk refcount
4774      * information accurately describe the actual references */
4775 
4776     ret = bdrv_pwrite_zeroes(bs->file, s->l1_table_offset,
4777                              l1_clusters * s->cluster_size, 0);
4778     if (ret < 0) {
4779         goto fail_broken_refcounts;
4780     }
4781     memset(s->l1_table, 0, l1_size2);
4782 
4783     BLKDBG_EVENT(bs->file, BLKDBG_EMPTY_IMAGE_PREPARE);
4784 
4785     /* Overwrite enough clusters at the beginning of the sectors to place
4786      * the refcount table, a refcount block and the L1 table in; this may
4787      * overwrite parts of the existing refcount and L1 table, which is not
4788      * an issue because the dirty flag is set, complete data loss is in fact
4789      * desired and partial data loss is consequently fine as well */
4790     ret = bdrv_pwrite_zeroes(bs->file, s->cluster_size,
4791                              (2 + l1_clusters) * s->cluster_size, 0);
4792     /* This call (even if it failed overall) may have overwritten on-disk
4793      * refcount structures; in that case, the in-memory refcount information
4794      * will probably differ from the on-disk information which makes the BDS
4795      * unusable */
4796     if (ret < 0) {
4797         goto fail_broken_refcounts;
4798     }
4799 
4800     BLKDBG_EVENT(bs->file, BLKDBG_L1_UPDATE);
4801     BLKDBG_EVENT(bs->file, BLKDBG_REFTABLE_UPDATE);
4802 
4803     /* "Create" an empty reftable (one cluster) directly after the image
4804      * header and an empty L1 table three clusters after the image header;
4805      * the cluster between those two will be used as the first refblock */
4806     l1_ofs_rt_ofs_cls.l1_offset = cpu_to_be64(3 * s->cluster_size);
4807     l1_ofs_rt_ofs_cls.reftable_offset = cpu_to_be64(s->cluster_size);
4808     l1_ofs_rt_ofs_cls.reftable_clusters = cpu_to_be32(1);
4809     ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, l1_table_offset),
4810                            &l1_ofs_rt_ofs_cls, sizeof(l1_ofs_rt_ofs_cls));
4811     if (ret < 0) {
4812         goto fail_broken_refcounts;
4813     }
4814 
4815     s->l1_table_offset = 3 * s->cluster_size;
4816 
4817     new_reftable = g_try_new0(uint64_t, s->cluster_size / REFTABLE_ENTRY_SIZE);
4818     if (!new_reftable) {
4819         ret = -ENOMEM;
4820         goto fail_broken_refcounts;
4821     }
4822 
4823     s->refcount_table_offset = s->cluster_size;
4824     s->refcount_table_size   = s->cluster_size / REFTABLE_ENTRY_SIZE;
4825     s->max_refcount_table_index = 0;
4826 
4827     g_free(s->refcount_table);
4828     s->refcount_table = new_reftable;
4829     new_reftable = NULL;
4830 
4831     /* Now the in-memory refcount information again corresponds to the on-disk
4832      * information (reftable is empty and no refblocks (the refblock cache is
4833      * empty)); however, this means some clusters (e.g. the image header) are
4834      * referenced, but not refcounted, but the normal qcow2 code assumes that
4835      * the in-memory information is always correct */
4836 
4837     BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC);
4838 
4839     /* Enter the first refblock into the reftable */
4840     rt_entry = cpu_to_be64(2 * s->cluster_size);
4841     ret = bdrv_pwrite_sync(bs->file, s->cluster_size,
4842                            &rt_entry, sizeof(rt_entry));
4843     if (ret < 0) {
4844         goto fail_broken_refcounts;
4845     }
4846     s->refcount_table[0] = 2 * s->cluster_size;
4847 
4848     s->free_cluster_index = 0;
4849     assert(3 + l1_clusters <= s->refcount_block_size);
4850     offset = qcow2_alloc_clusters(bs, 3 * s->cluster_size + l1_size2);
4851     if (offset < 0) {
4852         ret = offset;
4853         goto fail_broken_refcounts;
4854     } else if (offset > 0) {
4855         error_report("First cluster in emptied image is in use");
4856         abort();
4857     }
4858 
4859     /* Now finally the in-memory information corresponds to the on-disk
4860      * structures and is correct */
4861     ret = qcow2_mark_clean(bs);
4862     if (ret < 0) {
4863         goto fail;
4864     }
4865 
4866     ret = bdrv_truncate(bs->file, (3 + l1_clusters) * s->cluster_size, false,
4867                         PREALLOC_MODE_OFF, 0, &local_err);
4868     if (ret < 0) {
4869         error_report_err(local_err);
4870         goto fail;
4871     }
4872 
4873     return 0;
4874 
4875 fail_broken_refcounts:
4876     /* The BDS is unusable at this point. If we wanted to make it usable, we
4877      * would have to call qcow2_refcount_close(), qcow2_refcount_init(),
4878      * qcow2_check_refcounts(), qcow2_refcount_close() and qcow2_refcount_init()
4879      * again. However, because the functions which could have caused this error
4880      * path to be taken are used by those functions as well, it's very likely
4881      * that that sequence will fail as well. Therefore, just eject the BDS. */
4882     bs->drv = NULL;
4883 
4884 fail:
4885     g_free(new_reftable);
4886     return ret;
4887 }
4888 
qcow2_make_empty(BlockDriverState * bs)4889 static int qcow2_make_empty(BlockDriverState *bs)
4890 {
4891     BDRVQcow2State *s = bs->opaque;
4892     uint64_t offset, end_offset;
4893     int step = QEMU_ALIGN_DOWN(INT_MAX, s->cluster_size);
4894     int l1_clusters, ret = 0;
4895 
4896     l1_clusters = DIV_ROUND_UP(s->l1_size, s->cluster_size / L1E_SIZE);
4897 
4898     if (s->qcow_version >= 3 && !s->snapshots && !s->nb_bitmaps &&
4899         3 + l1_clusters <= s->refcount_block_size &&
4900         s->crypt_method_header != QCOW_CRYPT_LUKS &&
4901         !has_data_file(bs)) {
4902         /* The following function only works for qcow2 v3 images (it
4903          * requires the dirty flag) and only as long as there are no
4904          * features that reserve extra clusters (such as snapshots,
4905          * LUKS header, or persistent bitmaps), because it completely
4906          * empties the image.  Furthermore, the L1 table and three
4907          * additional clusters (image header, refcount table, one
4908          * refcount block) have to fit inside one refcount block. It
4909          * only resets the image file, i.e. does not work with an
4910          * external data file. */
4911         return make_completely_empty(bs);
4912     }
4913 
4914     /* This fallback code simply discards every active cluster; this is slow,
4915      * but works in all cases */
4916     end_offset = bs->total_sectors * BDRV_SECTOR_SIZE;
4917     for (offset = 0; offset < end_offset; offset += step) {
4918         /* As this function is generally used after committing an external
4919          * snapshot, QCOW2_DISCARD_SNAPSHOT seems appropriate. Also, the
4920          * default action for this kind of discard is to pass the discard,
4921          * which will ideally result in an actually smaller image file, as
4922          * is probably desired. */
4923         ret = qcow2_cluster_discard(bs, offset, MIN(step, end_offset - offset),
4924                                     QCOW2_DISCARD_SNAPSHOT, true);
4925         if (ret < 0) {
4926             break;
4927         }
4928     }
4929 
4930     return ret;
4931 }
4932 
qcow2_co_flush_to_os(BlockDriverState * bs)4933 static coroutine_fn int qcow2_co_flush_to_os(BlockDriverState *bs)
4934 {
4935     BDRVQcow2State *s = bs->opaque;
4936     int ret;
4937 
4938     qemu_co_mutex_lock(&s->lock);
4939     ret = qcow2_write_caches(bs);
4940     qemu_co_mutex_unlock(&s->lock);
4941 
4942     return ret;
4943 }
4944 
qcow2_measure(QemuOpts * opts,BlockDriverState * in_bs,Error ** errp)4945 static BlockMeasureInfo *qcow2_measure(QemuOpts *opts, BlockDriverState *in_bs,
4946                                        Error **errp)
4947 {
4948     Error *local_err = NULL;
4949     BlockMeasureInfo *info;
4950     uint64_t required = 0; /* bytes that contribute to required size */
4951     uint64_t virtual_size; /* disk size as seen by guest */
4952     uint64_t refcount_bits;
4953     uint64_t l2_tables;
4954     uint64_t luks_payload_size = 0;
4955     size_t cluster_size;
4956     int version;
4957     char *optstr;
4958     PreallocMode prealloc;
4959     bool has_backing_file;
4960     bool has_luks;
4961     bool extended_l2;
4962     size_t l2e_size;
4963 
4964     /* Parse image creation options */
4965     extended_l2 = qemu_opt_get_bool_del(opts, BLOCK_OPT_EXTL2, false);
4966 
4967     cluster_size = qcow2_opt_get_cluster_size_del(opts, extended_l2,
4968                                                   &local_err);
4969     if (local_err) {
4970         goto err;
4971     }
4972 
4973     version = qcow2_opt_get_version_del(opts, &local_err);
4974     if (local_err) {
4975         goto err;
4976     }
4977 
4978     refcount_bits = qcow2_opt_get_refcount_bits_del(opts, version, &local_err);
4979     if (local_err) {
4980         goto err;
4981     }
4982 
4983     optstr = qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC);
4984     prealloc = qapi_enum_parse(&PreallocMode_lookup, optstr,
4985                                PREALLOC_MODE_OFF, &local_err);
4986     g_free(optstr);
4987     if (local_err) {
4988         goto err;
4989     }
4990 
4991     optstr = qemu_opt_get_del(opts, BLOCK_OPT_BACKING_FILE);
4992     has_backing_file = !!optstr;
4993     g_free(optstr);
4994 
4995     optstr = qemu_opt_get_del(opts, BLOCK_OPT_ENCRYPT_FORMAT);
4996     has_luks = optstr && strcmp(optstr, "luks") == 0;
4997     g_free(optstr);
4998 
4999     if (has_luks) {
5000         g_autoptr(QCryptoBlockCreateOptions) create_opts = NULL;
5001         QDict *cryptoopts = qcow2_extract_crypto_opts(opts, "luks", errp);
5002         size_t headerlen;
5003 
5004         create_opts = block_crypto_create_opts_init(cryptoopts, errp);
5005         qobject_unref(cryptoopts);
5006         if (!create_opts) {
5007             goto err;
5008         }
5009 
5010         if (!qcrypto_block_calculate_payload_offset(create_opts,
5011                                                     "encrypt.",
5012                                                     &headerlen,
5013                                                     &local_err)) {
5014             goto err;
5015         }
5016 
5017         luks_payload_size = ROUND_UP(headerlen, cluster_size);
5018     }
5019 
5020     virtual_size = qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0);
5021     virtual_size = ROUND_UP(virtual_size, cluster_size);
5022 
5023     /* Check that virtual disk size is valid */
5024     l2e_size = extended_l2 ? L2E_SIZE_EXTENDED : L2E_SIZE_NORMAL;
5025     l2_tables = DIV_ROUND_UP(virtual_size / cluster_size,
5026                              cluster_size / l2e_size);
5027     if (l2_tables * L1E_SIZE > QCOW_MAX_L1_SIZE) {
5028         error_setg(&local_err, "The image size is too large "
5029                                "(try using a larger cluster size)");
5030         goto err;
5031     }
5032 
5033     /* Account for input image */
5034     if (in_bs) {
5035         int64_t ssize = bdrv_getlength(in_bs);
5036         if (ssize < 0) {
5037             error_setg_errno(&local_err, -ssize,
5038                              "Unable to get image virtual_size");
5039             goto err;
5040         }
5041 
5042         virtual_size = ROUND_UP(ssize, cluster_size);
5043 
5044         if (has_backing_file) {
5045             /* We don't how much of the backing chain is shared by the input
5046              * image and the new image file.  In the worst case the new image's
5047              * backing file has nothing in common with the input image.  Be
5048              * conservative and assume all clusters need to be written.
5049              */
5050             required = virtual_size;
5051         } else {
5052             int64_t offset;
5053             int64_t pnum = 0;
5054 
5055             for (offset = 0; offset < ssize; offset += pnum) {
5056                 int ret;
5057 
5058                 ret = bdrv_block_status_above(in_bs, NULL, offset,
5059                                               ssize - offset, &pnum, NULL,
5060                                               NULL);
5061                 if (ret < 0) {
5062                     error_setg_errno(&local_err, -ret,
5063                                      "Unable to get block status");
5064                     goto err;
5065                 }
5066 
5067                 if (ret & BDRV_BLOCK_ZERO) {
5068                     /* Skip zero regions (safe with no backing file) */
5069                 } else if ((ret & (BDRV_BLOCK_DATA | BDRV_BLOCK_ALLOCATED)) ==
5070                            (BDRV_BLOCK_DATA | BDRV_BLOCK_ALLOCATED)) {
5071                     /* Extend pnum to end of cluster for next iteration */
5072                     pnum = ROUND_UP(offset + pnum, cluster_size) - offset;
5073 
5074                     /* Count clusters we've seen */
5075                     required += offset % cluster_size + pnum;
5076                 }
5077             }
5078         }
5079     }
5080 
5081     /* Take into account preallocation.  Nothing special is needed for
5082      * PREALLOC_MODE_METADATA since metadata is always counted.
5083      */
5084     if (prealloc == PREALLOC_MODE_FULL || prealloc == PREALLOC_MODE_FALLOC) {
5085         required = virtual_size;
5086     }
5087 
5088     info = g_new0(BlockMeasureInfo, 1);
5089     info->fully_allocated = luks_payload_size +
5090         qcow2_calc_prealloc_size(virtual_size, cluster_size,
5091                                  ctz32(refcount_bits), extended_l2);
5092 
5093     /*
5094      * Remove data clusters that are not required.  This overestimates the
5095      * required size because metadata needed for the fully allocated file is
5096      * still counted.  Show bitmaps only if both source and destination
5097      * would support them.
5098      */
5099     info->required = info->fully_allocated - virtual_size + required;
5100     info->has_bitmaps = version >= 3 && in_bs &&
5101         bdrv_supports_persistent_dirty_bitmap(in_bs);
5102     if (info->has_bitmaps) {
5103         info->bitmaps = qcow2_get_persistent_dirty_bitmap_size(in_bs,
5104                                                                cluster_size);
5105     }
5106     return info;
5107 
5108 err:
5109     error_propagate(errp, local_err);
5110     return NULL;
5111 }
5112 
qcow2_get_info(BlockDriverState * bs,BlockDriverInfo * bdi)5113 static int qcow2_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
5114 {
5115     BDRVQcow2State *s = bs->opaque;
5116     bdi->cluster_size = s->cluster_size;
5117     bdi->vm_state_offset = qcow2_vm_state_offset(s);
5118     bdi->is_dirty = s->incompatible_features & QCOW2_INCOMPAT_DIRTY;
5119     return 0;
5120 }
5121 
qcow2_get_specific_info(BlockDriverState * bs,Error ** errp)5122 static ImageInfoSpecific *qcow2_get_specific_info(BlockDriverState *bs,
5123                                                   Error **errp)
5124 {
5125     BDRVQcow2State *s = bs->opaque;
5126     ImageInfoSpecific *spec_info;
5127     QCryptoBlockInfo *encrypt_info = NULL;
5128 
5129     if (s->crypto != NULL) {
5130         encrypt_info = qcrypto_block_get_info(s->crypto, errp);
5131         if (!encrypt_info) {
5132             return NULL;
5133         }
5134     }
5135 
5136     spec_info = g_new(ImageInfoSpecific, 1);
5137     *spec_info = (ImageInfoSpecific){
5138         .type  = IMAGE_INFO_SPECIFIC_KIND_QCOW2,
5139         .u.qcow2.data = g_new0(ImageInfoSpecificQCow2, 1),
5140     };
5141     if (s->qcow_version == 2) {
5142         *spec_info->u.qcow2.data = (ImageInfoSpecificQCow2){
5143             .compat             = g_strdup("0.10"),
5144             .refcount_bits      = s->refcount_bits,
5145         };
5146     } else if (s->qcow_version == 3) {
5147         Qcow2BitmapInfoList *bitmaps;
5148         if (!qcow2_get_bitmap_info_list(bs, &bitmaps, errp)) {
5149             qapi_free_ImageInfoSpecific(spec_info);
5150             qapi_free_QCryptoBlockInfo(encrypt_info);
5151             return NULL;
5152         }
5153         *spec_info->u.qcow2.data = (ImageInfoSpecificQCow2){
5154             .compat             = g_strdup("1.1"),
5155             .lazy_refcounts     = s->compatible_features &
5156                                   QCOW2_COMPAT_LAZY_REFCOUNTS,
5157             .has_lazy_refcounts = true,
5158             .corrupt            = s->incompatible_features &
5159                                   QCOW2_INCOMPAT_CORRUPT,
5160             .has_corrupt        = true,
5161             .has_extended_l2    = true,
5162             .extended_l2        = has_subclusters(s),
5163             .refcount_bits      = s->refcount_bits,
5164             .has_bitmaps        = !!bitmaps,
5165             .bitmaps            = bitmaps,
5166             .has_data_file      = !!s->image_data_file,
5167             .data_file          = g_strdup(s->image_data_file),
5168             .has_data_file_raw  = has_data_file(bs),
5169             .data_file_raw      = data_file_is_raw(bs),
5170             .compression_type   = s->compression_type,
5171         };
5172     } else {
5173         /* if this assertion fails, this probably means a new version was
5174          * added without having it covered here */
5175         assert(false);
5176     }
5177 
5178     if (encrypt_info) {
5179         ImageInfoSpecificQCow2Encryption *qencrypt =
5180             g_new(ImageInfoSpecificQCow2Encryption, 1);
5181         switch (encrypt_info->format) {
5182         case Q_CRYPTO_BLOCK_FORMAT_QCOW:
5183             qencrypt->format = BLOCKDEV_QCOW2_ENCRYPTION_FORMAT_AES;
5184             break;
5185         case Q_CRYPTO_BLOCK_FORMAT_LUKS:
5186             qencrypt->format = BLOCKDEV_QCOW2_ENCRYPTION_FORMAT_LUKS;
5187             qencrypt->u.luks = encrypt_info->u.luks;
5188             break;
5189         default:
5190             abort();
5191         }
5192         /* Since we did shallow copy above, erase any pointers
5193          * in the original info */
5194         memset(&encrypt_info->u, 0, sizeof(encrypt_info->u));
5195         qapi_free_QCryptoBlockInfo(encrypt_info);
5196 
5197         spec_info->u.qcow2.data->has_encrypt = true;
5198         spec_info->u.qcow2.data->encrypt = qencrypt;
5199     }
5200 
5201     return spec_info;
5202 }
5203 
qcow2_has_zero_init(BlockDriverState * bs)5204 static int qcow2_has_zero_init(BlockDriverState *bs)
5205 {
5206     BDRVQcow2State *s = bs->opaque;
5207     bool preallocated;
5208 
5209     if (qemu_in_coroutine()) {
5210         qemu_co_mutex_lock(&s->lock);
5211     }
5212     /*
5213      * Check preallocation status: Preallocated images have all L2
5214      * tables allocated, nonpreallocated images have none.  It is
5215      * therefore enough to check the first one.
5216      */
5217     preallocated = s->l1_size > 0 && s->l1_table[0] != 0;
5218     if (qemu_in_coroutine()) {
5219         qemu_co_mutex_unlock(&s->lock);
5220     }
5221 
5222     if (!preallocated) {
5223         return 1;
5224     } else if (bs->encrypted) {
5225         return 0;
5226     } else {
5227         return bdrv_has_zero_init(s->data_file->bs);
5228     }
5229 }
5230 
5231 /*
5232  * Check the request to vmstate. On success return
5233  *      qcow2_vm_state_offset(bs) + @pos
5234  */
qcow2_check_vmstate_request(BlockDriverState * bs,QEMUIOVector * qiov,int64_t pos)5235 static int64_t qcow2_check_vmstate_request(BlockDriverState *bs,
5236                                            QEMUIOVector *qiov, int64_t pos)
5237 {
5238     BDRVQcow2State *s = bs->opaque;
5239     int64_t vmstate_offset = qcow2_vm_state_offset(s);
5240     int ret;
5241 
5242     /* Incoming requests must be OK */
5243     bdrv_check_qiov_request(pos, qiov->size, qiov, 0, &error_abort);
5244 
5245     if (INT64_MAX - pos < vmstate_offset) {
5246         return -EIO;
5247     }
5248 
5249     pos += vmstate_offset;
5250     ret = bdrv_check_qiov_request(pos, qiov->size, qiov, 0, NULL);
5251     if (ret < 0) {
5252         return ret;
5253     }
5254 
5255     return pos;
5256 }
5257 
qcow2_save_vmstate(BlockDriverState * bs,QEMUIOVector * qiov,int64_t pos)5258 static int qcow2_save_vmstate(BlockDriverState *bs, QEMUIOVector *qiov,
5259                               int64_t pos)
5260 {
5261     int64_t offset = qcow2_check_vmstate_request(bs, qiov, pos);
5262     if (offset < 0) {
5263         return offset;
5264     }
5265 
5266     BLKDBG_EVENT(bs->file, BLKDBG_VMSTATE_SAVE);
5267     return bs->drv->bdrv_co_pwritev_part(bs, offset, qiov->size, qiov, 0, 0);
5268 }
5269 
qcow2_load_vmstate(BlockDriverState * bs,QEMUIOVector * qiov,int64_t pos)5270 static int qcow2_load_vmstate(BlockDriverState *bs, QEMUIOVector *qiov,
5271                               int64_t pos)
5272 {
5273     int64_t offset = qcow2_check_vmstate_request(bs, qiov, pos);
5274     if (offset < 0) {
5275         return offset;
5276     }
5277 
5278     BLKDBG_EVENT(bs->file, BLKDBG_VMSTATE_LOAD);
5279     return bs->drv->bdrv_co_preadv_part(bs, offset, qiov->size, qiov, 0, 0);
5280 }
5281 
5282 /*
5283  * Downgrades an image's version. To achieve this, any incompatible features
5284  * have to be removed.
5285  */
qcow2_downgrade(BlockDriverState * bs,int target_version,BlockDriverAmendStatusCB * status_cb,void * cb_opaque,Error ** errp)5286 static int qcow2_downgrade(BlockDriverState *bs, int target_version,
5287                            BlockDriverAmendStatusCB *status_cb, void *cb_opaque,
5288                            Error **errp)
5289 {
5290     BDRVQcow2State *s = bs->opaque;
5291     int current_version = s->qcow_version;
5292     int ret;
5293     int i;
5294 
5295     /* This is qcow2_downgrade(), not qcow2_upgrade() */
5296     assert(target_version < current_version);
5297 
5298     /* There are no other versions (now) that you can downgrade to */
5299     assert(target_version == 2);
5300 
5301     if (s->refcount_order != 4) {
5302         error_setg(errp, "compat=0.10 requires refcount_bits=16");
5303         return -ENOTSUP;
5304     }
5305 
5306     if (has_data_file(bs)) {
5307         error_setg(errp, "Cannot downgrade an image with a data file");
5308         return -ENOTSUP;
5309     }
5310 
5311     /*
5312      * If any internal snapshot has a different size than the current
5313      * image size, or VM state size that exceeds 32 bits, downgrading
5314      * is unsafe.  Even though we would still use v3-compliant output
5315      * to preserve that data, other v2 programs might not realize
5316      * those optional fields are important.
5317      */
5318     for (i = 0; i < s->nb_snapshots; i++) {
5319         if (s->snapshots[i].vm_state_size > UINT32_MAX ||
5320             s->snapshots[i].disk_size != bs->total_sectors * BDRV_SECTOR_SIZE) {
5321             error_setg(errp, "Internal snapshots prevent downgrade of image");
5322             return -ENOTSUP;
5323         }
5324     }
5325 
5326     /* clear incompatible features */
5327     if (s->incompatible_features & QCOW2_INCOMPAT_DIRTY) {
5328         ret = qcow2_mark_clean(bs);
5329         if (ret < 0) {
5330             error_setg_errno(errp, -ret, "Failed to make the image clean");
5331             return ret;
5332         }
5333     }
5334 
5335     /* with QCOW2_INCOMPAT_CORRUPT, it is pretty much impossible to get here in
5336      * the first place; if that happens nonetheless, returning -ENOTSUP is the
5337      * best thing to do anyway */
5338 
5339     if (s->incompatible_features) {
5340         error_setg(errp, "Cannot downgrade an image with incompatible features "
5341                    "%#" PRIx64 " set", s->incompatible_features);
5342         return -ENOTSUP;
5343     }
5344 
5345     /* since we can ignore compatible features, we can set them to 0 as well */
5346     s->compatible_features = 0;
5347     /* if lazy refcounts have been used, they have already been fixed through
5348      * clearing the dirty flag */
5349 
5350     /* clearing autoclear features is trivial */
5351     s->autoclear_features = 0;
5352 
5353     ret = qcow2_expand_zero_clusters(bs, status_cb, cb_opaque);
5354     if (ret < 0) {
5355         error_setg_errno(errp, -ret, "Failed to turn zero into data clusters");
5356         return ret;
5357     }
5358 
5359     s->qcow_version = target_version;
5360     ret = qcow2_update_header(bs);
5361     if (ret < 0) {
5362         s->qcow_version = current_version;
5363         error_setg_errno(errp, -ret, "Failed to update the image header");
5364         return ret;
5365     }
5366     return 0;
5367 }
5368 
5369 /*
5370  * Upgrades an image's version.  While newer versions encompass all
5371  * features of older versions, some things may have to be presented
5372  * differently.
5373  */
qcow2_upgrade(BlockDriverState * bs,int target_version,BlockDriverAmendStatusCB * status_cb,void * cb_opaque,Error ** errp)5374 static int qcow2_upgrade(BlockDriverState *bs, int target_version,
5375                          BlockDriverAmendStatusCB *status_cb, void *cb_opaque,
5376                          Error **errp)
5377 {
5378     BDRVQcow2State *s = bs->opaque;
5379     bool need_snapshot_update;
5380     int current_version = s->qcow_version;
5381     int i;
5382     int ret;
5383 
5384     /* This is qcow2_upgrade(), not qcow2_downgrade() */
5385     assert(target_version > current_version);
5386 
5387     /* There are no other versions (yet) that you can upgrade to */
5388     assert(target_version == 3);
5389 
5390     status_cb(bs, 0, 2, cb_opaque);
5391 
5392     /*
5393      * In v2, snapshots do not need to have extra data.  v3 requires
5394      * the 64-bit VM state size and the virtual disk size to be
5395      * present.
5396      * qcow2_write_snapshots() will always write the list in the
5397      * v3-compliant format.
5398      */
5399     need_snapshot_update = false;
5400     for (i = 0; i < s->nb_snapshots; i++) {
5401         if (s->snapshots[i].extra_data_size <
5402             sizeof_field(QCowSnapshotExtraData, vm_state_size_large) +
5403             sizeof_field(QCowSnapshotExtraData, disk_size))
5404         {
5405             need_snapshot_update = true;
5406             break;
5407         }
5408     }
5409     if (need_snapshot_update) {
5410         ret = qcow2_write_snapshots(bs);
5411         if (ret < 0) {
5412             error_setg_errno(errp, -ret, "Failed to update the snapshot table");
5413             return ret;
5414         }
5415     }
5416     status_cb(bs, 1, 2, cb_opaque);
5417 
5418     s->qcow_version = target_version;
5419     ret = qcow2_update_header(bs);
5420     if (ret < 0) {
5421         s->qcow_version = current_version;
5422         error_setg_errno(errp, -ret, "Failed to update the image header");
5423         return ret;
5424     }
5425     status_cb(bs, 2, 2, cb_opaque);
5426 
5427     return 0;
5428 }
5429 
5430 typedef enum Qcow2AmendOperation {
5431     /* This is the value Qcow2AmendHelperCBInfo::last_operation will be
5432      * statically initialized to so that the helper CB can discern the first
5433      * invocation from an operation change */
5434     QCOW2_NO_OPERATION = 0,
5435 
5436     QCOW2_UPGRADING,
5437     QCOW2_UPDATING_ENCRYPTION,
5438     QCOW2_CHANGING_REFCOUNT_ORDER,
5439     QCOW2_DOWNGRADING,
5440 } Qcow2AmendOperation;
5441 
5442 typedef struct Qcow2AmendHelperCBInfo {
5443     /* The code coordinating the amend operations should only modify
5444      * these four fields; the rest will be managed by the CB */
5445     BlockDriverAmendStatusCB *original_status_cb;
5446     void *original_cb_opaque;
5447 
5448     Qcow2AmendOperation current_operation;
5449 
5450     /* Total number of operations to perform (only set once) */
5451     int total_operations;
5452 
5453     /* The following fields are managed by the CB */
5454 
5455     /* Number of operations completed */
5456     int operations_completed;
5457 
5458     /* Cumulative offset of all completed operations */
5459     int64_t offset_completed;
5460 
5461     Qcow2AmendOperation last_operation;
5462     int64_t last_work_size;
5463 } Qcow2AmendHelperCBInfo;
5464 
qcow2_amend_helper_cb(BlockDriverState * bs,int64_t operation_offset,int64_t operation_work_size,void * opaque)5465 static void qcow2_amend_helper_cb(BlockDriverState *bs,
5466                                   int64_t operation_offset,
5467                                   int64_t operation_work_size, void *opaque)
5468 {
5469     Qcow2AmendHelperCBInfo *info = opaque;
5470     int64_t current_work_size;
5471     int64_t projected_work_size;
5472 
5473     if (info->current_operation != info->last_operation) {
5474         if (info->last_operation != QCOW2_NO_OPERATION) {
5475             info->offset_completed += info->last_work_size;
5476             info->operations_completed++;
5477         }
5478 
5479         info->last_operation = info->current_operation;
5480     }
5481 
5482     assert(info->total_operations > 0);
5483     assert(info->operations_completed < info->total_operations);
5484 
5485     info->last_work_size = operation_work_size;
5486 
5487     current_work_size = info->offset_completed + operation_work_size;
5488 
5489     /* current_work_size is the total work size for (operations_completed + 1)
5490      * operations (which includes this one), so multiply it by the number of
5491      * operations not covered and divide it by the number of operations
5492      * covered to get a projection for the operations not covered */
5493     projected_work_size = current_work_size * (info->total_operations -
5494                                                info->operations_completed - 1)
5495                                             / (info->operations_completed + 1);
5496 
5497     info->original_status_cb(bs, info->offset_completed + operation_offset,
5498                              current_work_size + projected_work_size,
5499                              info->original_cb_opaque);
5500 }
5501 
qcow2_amend_options(BlockDriverState * bs,QemuOpts * opts,BlockDriverAmendStatusCB * status_cb,void * cb_opaque,bool force,Error ** errp)5502 static int qcow2_amend_options(BlockDriverState *bs, QemuOpts *opts,
5503                                BlockDriverAmendStatusCB *status_cb,
5504                                void *cb_opaque,
5505                                bool force,
5506                                Error **errp)
5507 {
5508     BDRVQcow2State *s = bs->opaque;
5509     int old_version = s->qcow_version, new_version = old_version;
5510     uint64_t new_size = 0;
5511     const char *backing_file = NULL, *backing_format = NULL, *data_file = NULL;
5512     bool lazy_refcounts = s->use_lazy_refcounts;
5513     bool data_file_raw = data_file_is_raw(bs);
5514     const char *compat = NULL;
5515     int refcount_bits = s->refcount_bits;
5516     int ret;
5517     QemuOptDesc *desc = opts->list->desc;
5518     Qcow2AmendHelperCBInfo helper_cb_info;
5519     bool encryption_update = false;
5520 
5521     while (desc && desc->name) {
5522         if (!qemu_opt_find(opts, desc->name)) {
5523             /* only change explicitly defined options */
5524             desc++;
5525             continue;
5526         }
5527 
5528         if (!strcmp(desc->name, BLOCK_OPT_COMPAT_LEVEL)) {
5529             compat = qemu_opt_get(opts, BLOCK_OPT_COMPAT_LEVEL);
5530             if (!compat) {
5531                 /* preserve default */
5532             } else if (!strcmp(compat, "0.10") || !strcmp(compat, "v2")) {
5533                 new_version = 2;
5534             } else if (!strcmp(compat, "1.1") || !strcmp(compat, "v3")) {
5535                 new_version = 3;
5536             } else {
5537                 error_setg(errp, "Unknown compatibility level %s", compat);
5538                 return -EINVAL;
5539             }
5540         } else if (!strcmp(desc->name, BLOCK_OPT_SIZE)) {
5541             new_size = qemu_opt_get_size(opts, BLOCK_OPT_SIZE, 0);
5542         } else if (!strcmp(desc->name, BLOCK_OPT_BACKING_FILE)) {
5543             backing_file = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
5544         } else if (!strcmp(desc->name, BLOCK_OPT_BACKING_FMT)) {
5545             backing_format = qemu_opt_get(opts, BLOCK_OPT_BACKING_FMT);
5546         } else if (g_str_has_prefix(desc->name, "encrypt.")) {
5547             if (!s->crypto) {
5548                 error_setg(errp,
5549                            "Can't amend encryption options - encryption not present");
5550                 return -EINVAL;
5551             }
5552             if (s->crypt_method_header != QCOW_CRYPT_LUKS) {
5553                 error_setg(errp,
5554                            "Only LUKS encryption options can be amended");
5555                 return -ENOTSUP;
5556             }
5557             encryption_update = true;
5558         } else if (!strcmp(desc->name, BLOCK_OPT_LAZY_REFCOUNTS)) {
5559             lazy_refcounts = qemu_opt_get_bool(opts, BLOCK_OPT_LAZY_REFCOUNTS,
5560                                                lazy_refcounts);
5561         } else if (!strcmp(desc->name, BLOCK_OPT_REFCOUNT_BITS)) {
5562             refcount_bits = qemu_opt_get_number(opts, BLOCK_OPT_REFCOUNT_BITS,
5563                                                 refcount_bits);
5564 
5565             if (refcount_bits <= 0 || refcount_bits > 64 ||
5566                 !is_power_of_2(refcount_bits))
5567             {
5568                 error_setg(errp, "Refcount width must be a power of two and "
5569                            "may not exceed 64 bits");
5570                 return -EINVAL;
5571             }
5572         } else if (!strcmp(desc->name, BLOCK_OPT_DATA_FILE)) {
5573             data_file = qemu_opt_get(opts, BLOCK_OPT_DATA_FILE);
5574             if (data_file && !has_data_file(bs)) {
5575                 error_setg(errp, "data-file can only be set for images that "
5576                                  "use an external data file");
5577                 return -EINVAL;
5578             }
5579         } else if (!strcmp(desc->name, BLOCK_OPT_DATA_FILE_RAW)) {
5580             data_file_raw = qemu_opt_get_bool(opts, BLOCK_OPT_DATA_FILE_RAW,
5581                                               data_file_raw);
5582             if (data_file_raw && !data_file_is_raw(bs)) {
5583                 error_setg(errp, "data-file-raw cannot be set on existing "
5584                                  "images");
5585                 return -EINVAL;
5586             }
5587         } else {
5588             /* if this point is reached, this probably means a new option was
5589              * added without having it covered here */
5590             abort();
5591         }
5592 
5593         desc++;
5594     }
5595 
5596     helper_cb_info = (Qcow2AmendHelperCBInfo){
5597         .original_status_cb = status_cb,
5598         .original_cb_opaque = cb_opaque,
5599         .total_operations = (new_version != old_version)
5600                           + (s->refcount_bits != refcount_bits) +
5601                             (encryption_update == true)
5602     };
5603 
5604     /* Upgrade first (some features may require compat=1.1) */
5605     if (new_version > old_version) {
5606         helper_cb_info.current_operation = QCOW2_UPGRADING;
5607         ret = qcow2_upgrade(bs, new_version, &qcow2_amend_helper_cb,
5608                             &helper_cb_info, errp);
5609         if (ret < 0) {
5610             return ret;
5611         }
5612     }
5613 
5614     if (encryption_update) {
5615         QDict *amend_opts_dict;
5616         QCryptoBlockAmendOptions *amend_opts;
5617 
5618         helper_cb_info.current_operation = QCOW2_UPDATING_ENCRYPTION;
5619         amend_opts_dict = qcow2_extract_crypto_opts(opts, "luks", errp);
5620         if (!amend_opts_dict) {
5621             return -EINVAL;
5622         }
5623         amend_opts = block_crypto_amend_opts_init(amend_opts_dict, errp);
5624         qobject_unref(amend_opts_dict);
5625         if (!amend_opts) {
5626             return -EINVAL;
5627         }
5628         ret = qcrypto_block_amend_options(s->crypto,
5629                                           qcow2_crypto_hdr_read_func,
5630                                           qcow2_crypto_hdr_write_func,
5631                                           bs,
5632                                           amend_opts,
5633                                           force,
5634                                           errp);
5635         qapi_free_QCryptoBlockAmendOptions(amend_opts);
5636         if (ret < 0) {
5637             return ret;
5638         }
5639     }
5640 
5641     if (s->refcount_bits != refcount_bits) {
5642         int refcount_order = ctz32(refcount_bits);
5643 
5644         if (new_version < 3 && refcount_bits != 16) {
5645             error_setg(errp, "Refcount widths other than 16 bits require "
5646                        "compatibility level 1.1 or above (use compat=1.1 or "
5647                        "greater)");
5648             return -EINVAL;
5649         }
5650 
5651         helper_cb_info.current_operation = QCOW2_CHANGING_REFCOUNT_ORDER;
5652         ret = qcow2_change_refcount_order(bs, refcount_order,
5653                                           &qcow2_amend_helper_cb,
5654                                           &helper_cb_info, errp);
5655         if (ret < 0) {
5656             return ret;
5657         }
5658     }
5659 
5660     /* data-file-raw blocks backing files, so clear it first if requested */
5661     if (data_file_raw) {
5662         s->autoclear_features |= QCOW2_AUTOCLEAR_DATA_FILE_RAW;
5663     } else {
5664         s->autoclear_features &= ~QCOW2_AUTOCLEAR_DATA_FILE_RAW;
5665     }
5666 
5667     if (data_file) {
5668         g_free(s->image_data_file);
5669         s->image_data_file = *data_file ? g_strdup(data_file) : NULL;
5670     }
5671 
5672     ret = qcow2_update_header(bs);
5673     if (ret < 0) {
5674         error_setg_errno(errp, -ret, "Failed to update the image header");
5675         return ret;
5676     }
5677 
5678     if (backing_file || backing_format) {
5679         if (g_strcmp0(backing_file, s->image_backing_file) ||
5680             g_strcmp0(backing_format, s->image_backing_format)) {
5681             error_setg(errp, "Cannot amend the backing file");
5682             error_append_hint(errp,
5683                               "You can use 'qemu-img rebase' instead.\n");
5684             return -EINVAL;
5685         }
5686     }
5687 
5688     if (s->use_lazy_refcounts != lazy_refcounts) {
5689         if (lazy_refcounts) {
5690             if (new_version < 3) {
5691                 error_setg(errp, "Lazy refcounts only supported with "
5692                            "compatibility level 1.1 and above (use compat=1.1 "
5693                            "or greater)");
5694                 return -EINVAL;
5695             }
5696             s->compatible_features |= QCOW2_COMPAT_LAZY_REFCOUNTS;
5697             ret = qcow2_update_header(bs);
5698             if (ret < 0) {
5699                 s->compatible_features &= ~QCOW2_COMPAT_LAZY_REFCOUNTS;
5700                 error_setg_errno(errp, -ret, "Failed to update the image header");
5701                 return ret;
5702             }
5703             s->use_lazy_refcounts = true;
5704         } else {
5705             /* make image clean first */
5706             ret = qcow2_mark_clean(bs);
5707             if (ret < 0) {
5708                 error_setg_errno(errp, -ret, "Failed to make the image clean");
5709                 return ret;
5710             }
5711             /* now disallow lazy refcounts */
5712             s->compatible_features &= ~QCOW2_COMPAT_LAZY_REFCOUNTS;
5713             ret = qcow2_update_header(bs);
5714             if (ret < 0) {
5715                 s->compatible_features |= QCOW2_COMPAT_LAZY_REFCOUNTS;
5716                 error_setg_errno(errp, -ret, "Failed to update the image header");
5717                 return ret;
5718             }
5719             s->use_lazy_refcounts = false;
5720         }
5721     }
5722 
5723     if (new_size) {
5724         BlockBackend *blk = blk_new_with_bs(bs, BLK_PERM_RESIZE, BLK_PERM_ALL,
5725                                             errp);
5726         if (!blk) {
5727             return -EPERM;
5728         }
5729 
5730         /*
5731          * Amending image options should ensure that the image has
5732          * exactly the given new values, so pass exact=true here.
5733          */
5734         ret = blk_truncate(blk, new_size, true, PREALLOC_MODE_OFF, 0, errp);
5735         blk_unref(blk);
5736         if (ret < 0) {
5737             return ret;
5738         }
5739     }
5740 
5741     /* Downgrade last (so unsupported features can be removed before) */
5742     if (new_version < old_version) {
5743         helper_cb_info.current_operation = QCOW2_DOWNGRADING;
5744         ret = qcow2_downgrade(bs, new_version, &qcow2_amend_helper_cb,
5745                               &helper_cb_info, errp);
5746         if (ret < 0) {
5747             return ret;
5748         }
5749     }
5750 
5751     return 0;
5752 }
5753 
qcow2_co_amend(BlockDriverState * bs,BlockdevAmendOptions * opts,bool force,Error ** errp)5754 static int coroutine_fn qcow2_co_amend(BlockDriverState *bs,
5755                                        BlockdevAmendOptions *opts,
5756                                        bool force,
5757                                        Error **errp)
5758 {
5759     BlockdevAmendOptionsQcow2 *qopts = &opts->u.qcow2;
5760     BDRVQcow2State *s = bs->opaque;
5761     int ret = 0;
5762 
5763     if (qopts->has_encrypt) {
5764         if (!s->crypto) {
5765             error_setg(errp, "image is not encrypted, can't amend");
5766             return -EOPNOTSUPP;
5767         }
5768 
5769         if (qopts->encrypt->format != Q_CRYPTO_BLOCK_FORMAT_LUKS) {
5770             error_setg(errp,
5771                        "Amend can't be used to change the qcow2 encryption format");
5772             return -EOPNOTSUPP;
5773         }
5774 
5775         if (s->crypt_method_header != QCOW_CRYPT_LUKS) {
5776             error_setg(errp,
5777                        "Only LUKS encryption options can be amended for qcow2 with blockdev-amend");
5778             return -EOPNOTSUPP;
5779         }
5780 
5781         ret = qcrypto_block_amend_options(s->crypto,
5782                                           qcow2_crypto_hdr_read_func,
5783                                           qcow2_crypto_hdr_write_func,
5784                                           bs,
5785                                           qopts->encrypt,
5786                                           force,
5787                                           errp);
5788     }
5789     return ret;
5790 }
5791 
5792 /*
5793  * If offset or size are negative, respectively, they will not be included in
5794  * the BLOCK_IMAGE_CORRUPTED event emitted.
5795  * fatal will be ignored for read-only BDS; corruptions found there will always
5796  * be considered non-fatal.
5797  */
qcow2_signal_corruption(BlockDriverState * bs,bool fatal,int64_t offset,int64_t size,const char * message_format,...)5798 void qcow2_signal_corruption(BlockDriverState *bs, bool fatal, int64_t offset,
5799                              int64_t size, const char *message_format, ...)
5800 {
5801     BDRVQcow2State *s = bs->opaque;
5802     const char *node_name;
5803     char *message;
5804     va_list ap;
5805 
5806     fatal = fatal && bdrv_is_writable(bs);
5807 
5808     if (s->signaled_corruption &&
5809         (!fatal || (s->incompatible_features & QCOW2_INCOMPAT_CORRUPT)))
5810     {
5811         return;
5812     }
5813 
5814     va_start(ap, message_format);
5815     message = g_strdup_vprintf(message_format, ap);
5816     va_end(ap);
5817 
5818     if (fatal) {
5819         fprintf(stderr, "qcow2: Marking image as corrupt: %s; further "
5820                 "corruption events will be suppressed\n", message);
5821     } else {
5822         fprintf(stderr, "qcow2: Image is corrupt: %s; further non-fatal "
5823                 "corruption events will be suppressed\n", message);
5824     }
5825 
5826     node_name = bdrv_get_node_name(bs);
5827     qapi_event_send_block_image_corrupted(bdrv_get_device_name(bs),
5828                                           *node_name != '\0', node_name,
5829                                           message, offset >= 0, offset,
5830                                           size >= 0, size,
5831                                           fatal);
5832     g_free(message);
5833 
5834     if (fatal) {
5835         qcow2_mark_corrupt(bs);
5836         bs->drv = NULL; /* make BDS unusable */
5837     }
5838 
5839     s->signaled_corruption = true;
5840 }
5841 
5842 #define QCOW_COMMON_OPTIONS                                         \
5843     {                                                               \
5844         .name = BLOCK_OPT_SIZE,                                     \
5845         .type = QEMU_OPT_SIZE,                                      \
5846         .help = "Virtual disk size"                                 \
5847     },                                                              \
5848     {                                                               \
5849         .name = BLOCK_OPT_COMPAT_LEVEL,                             \
5850         .type = QEMU_OPT_STRING,                                    \
5851         .help = "Compatibility level (v2 [0.10] or v3 [1.1])"       \
5852     },                                                              \
5853     {                                                               \
5854         .name = BLOCK_OPT_BACKING_FILE,                             \
5855         .type = QEMU_OPT_STRING,                                    \
5856         .help = "File name of a base image"                         \
5857     },                                                              \
5858     {                                                               \
5859         .name = BLOCK_OPT_BACKING_FMT,                              \
5860         .type = QEMU_OPT_STRING,                                    \
5861         .help = "Image format of the base image"                    \
5862     },                                                              \
5863     {                                                               \
5864         .name = BLOCK_OPT_DATA_FILE,                                \
5865         .type = QEMU_OPT_STRING,                                    \
5866         .help = "File name of an external data file"                \
5867     },                                                              \
5868     {                                                               \
5869         .name = BLOCK_OPT_DATA_FILE_RAW,                            \
5870         .type = QEMU_OPT_BOOL,                                      \
5871         .help = "The external data file must stay valid "           \
5872                 "as a raw image"                                    \
5873     },                                                              \
5874     {                                                               \
5875         .name = BLOCK_OPT_LAZY_REFCOUNTS,                           \
5876         .type = QEMU_OPT_BOOL,                                      \
5877         .help = "Postpone refcount updates",                        \
5878         .def_value_str = "off"                                      \
5879     },                                                              \
5880     {                                                               \
5881         .name = BLOCK_OPT_REFCOUNT_BITS,                            \
5882         .type = QEMU_OPT_NUMBER,                                    \
5883         .help = "Width of a reference count entry in bits",         \
5884         .def_value_str = "16"                                       \
5885     }
5886 
5887 static QemuOptsList qcow2_create_opts = {
5888     .name = "qcow2-create-opts",
5889     .head = QTAILQ_HEAD_INITIALIZER(qcow2_create_opts.head),
5890     .desc = {
5891         {                                                               \
5892             .name = BLOCK_OPT_ENCRYPT,                                  \
5893             .type = QEMU_OPT_BOOL,                                      \
5894             .help = "Encrypt the image with format 'aes'. (Deprecated " \
5895                     "in favor of " BLOCK_OPT_ENCRYPT_FORMAT "=aes)",    \
5896         },                                                              \
5897         {                                                               \
5898             .name = BLOCK_OPT_ENCRYPT_FORMAT,                           \
5899             .type = QEMU_OPT_STRING,                                    \
5900             .help = "Encrypt the image, format choices: 'aes', 'luks'", \
5901         },                                                              \
5902         BLOCK_CRYPTO_OPT_DEF_KEY_SECRET("encrypt.",                     \
5903             "ID of secret providing qcow AES key or LUKS passphrase"),  \
5904         BLOCK_CRYPTO_OPT_DEF_LUKS_CIPHER_ALG("encrypt."),               \
5905         BLOCK_CRYPTO_OPT_DEF_LUKS_CIPHER_MODE("encrypt."),              \
5906         BLOCK_CRYPTO_OPT_DEF_LUKS_IVGEN_ALG("encrypt."),                \
5907         BLOCK_CRYPTO_OPT_DEF_LUKS_IVGEN_HASH_ALG("encrypt."),           \
5908         BLOCK_CRYPTO_OPT_DEF_LUKS_HASH_ALG("encrypt."),                 \
5909         BLOCK_CRYPTO_OPT_DEF_LUKS_ITER_TIME("encrypt."),                \
5910         {                                                               \
5911             .name = BLOCK_OPT_CLUSTER_SIZE,                             \
5912             .type = QEMU_OPT_SIZE,                                      \
5913             .help = "qcow2 cluster size",                               \
5914             .def_value_str = stringify(DEFAULT_CLUSTER_SIZE)            \
5915         },                                                              \
5916         {                                                               \
5917             .name = BLOCK_OPT_EXTL2,                                    \
5918             .type = QEMU_OPT_BOOL,                                      \
5919             .help = "Extended L2 tables",                               \
5920             .def_value_str = "off"                                      \
5921         },                                                              \
5922         {                                                               \
5923             .name = BLOCK_OPT_PREALLOC,                                 \
5924             .type = QEMU_OPT_STRING,                                    \
5925             .help = "Preallocation mode (allowed values: off, "         \
5926                     "metadata, falloc, full)"                           \
5927         },                                                              \
5928         {                                                               \
5929             .name = BLOCK_OPT_COMPRESSION_TYPE,                         \
5930             .type = QEMU_OPT_STRING,                                    \
5931             .help = "Compression method used for image cluster "        \
5932                     "compression",                                      \
5933             .def_value_str = "zlib"                                     \
5934         },
5935         QCOW_COMMON_OPTIONS,
5936         { /* end of list */ }
5937     }
5938 };
5939 
5940 static QemuOptsList qcow2_amend_opts = {
5941     .name = "qcow2-amend-opts",
5942     .head = QTAILQ_HEAD_INITIALIZER(qcow2_amend_opts.head),
5943     .desc = {
5944         BLOCK_CRYPTO_OPT_DEF_LUKS_STATE("encrypt."),
5945         BLOCK_CRYPTO_OPT_DEF_LUKS_KEYSLOT("encrypt."),
5946         BLOCK_CRYPTO_OPT_DEF_LUKS_OLD_SECRET("encrypt."),
5947         BLOCK_CRYPTO_OPT_DEF_LUKS_NEW_SECRET("encrypt."),
5948         BLOCK_CRYPTO_OPT_DEF_LUKS_ITER_TIME("encrypt."),
5949         QCOW_COMMON_OPTIONS,
5950         { /* end of list */ }
5951     }
5952 };
5953 
5954 static const char *const qcow2_strong_runtime_opts[] = {
5955     "encrypt." BLOCK_CRYPTO_OPT_QCOW_KEY_SECRET,
5956 
5957     NULL
5958 };
5959 
5960 BlockDriver bdrv_qcow2 = {
5961     .format_name        = "qcow2",
5962     .instance_size      = sizeof(BDRVQcow2State),
5963     .bdrv_probe         = qcow2_probe,
5964     .bdrv_open          = qcow2_open,
5965     .bdrv_close         = qcow2_close,
5966     .bdrv_reopen_prepare  = qcow2_reopen_prepare,
5967     .bdrv_reopen_commit   = qcow2_reopen_commit,
5968     .bdrv_reopen_commit_post = qcow2_reopen_commit_post,
5969     .bdrv_reopen_abort    = qcow2_reopen_abort,
5970     .bdrv_join_options    = qcow2_join_options,
5971     .bdrv_child_perm      = bdrv_default_perms,
5972     .bdrv_co_create_opts  = qcow2_co_create_opts,
5973     .bdrv_co_create       = qcow2_co_create,
5974     .bdrv_has_zero_init   = qcow2_has_zero_init,
5975     .bdrv_co_block_status = qcow2_co_block_status,
5976 
5977     .bdrv_co_preadv_part    = qcow2_co_preadv_part,
5978     .bdrv_co_pwritev_part   = qcow2_co_pwritev_part,
5979     .bdrv_co_flush_to_os    = qcow2_co_flush_to_os,
5980 
5981     .bdrv_co_pwrite_zeroes  = qcow2_co_pwrite_zeroes,
5982     .bdrv_co_pdiscard       = qcow2_co_pdiscard,
5983     .bdrv_co_copy_range_from = qcow2_co_copy_range_from,
5984     .bdrv_co_copy_range_to  = qcow2_co_copy_range_to,
5985     .bdrv_co_truncate       = qcow2_co_truncate,
5986     .bdrv_co_pwritev_compressed_part = qcow2_co_pwritev_compressed_part,
5987     .bdrv_make_empty        = qcow2_make_empty,
5988 
5989     .bdrv_snapshot_create   = qcow2_snapshot_create,
5990     .bdrv_snapshot_goto     = qcow2_snapshot_goto,
5991     .bdrv_snapshot_delete   = qcow2_snapshot_delete,
5992     .bdrv_snapshot_list     = qcow2_snapshot_list,
5993     .bdrv_snapshot_load_tmp = qcow2_snapshot_load_tmp,
5994     .bdrv_measure           = qcow2_measure,
5995     .bdrv_get_info          = qcow2_get_info,
5996     .bdrv_get_specific_info = qcow2_get_specific_info,
5997 
5998     .bdrv_save_vmstate    = qcow2_save_vmstate,
5999     .bdrv_load_vmstate    = qcow2_load_vmstate,
6000 
6001     .is_format                  = true,
6002     .supports_backing           = true,
6003     .bdrv_change_backing_file   = qcow2_change_backing_file,
6004 
6005     .bdrv_refresh_limits        = qcow2_refresh_limits,
6006     .bdrv_co_invalidate_cache   = qcow2_co_invalidate_cache,
6007     .bdrv_inactivate            = qcow2_inactivate,
6008 
6009     .create_opts         = &qcow2_create_opts,
6010     .amend_opts          = &qcow2_amend_opts,
6011     .strong_runtime_opts = qcow2_strong_runtime_opts,
6012     .mutable_opts        = mutable_opts,
6013     .bdrv_co_check       = qcow2_co_check,
6014     .bdrv_amend_options  = qcow2_amend_options,
6015     .bdrv_co_amend       = qcow2_co_amend,
6016 
6017     .bdrv_detach_aio_context  = qcow2_detach_aio_context,
6018     .bdrv_attach_aio_context  = qcow2_attach_aio_context,
6019 
6020     .bdrv_supports_persistent_dirty_bitmap =
6021             qcow2_supports_persistent_dirty_bitmap,
6022     .bdrv_co_can_store_new_dirty_bitmap = qcow2_co_can_store_new_dirty_bitmap,
6023     .bdrv_co_remove_persistent_dirty_bitmap =
6024             qcow2_co_remove_persistent_dirty_bitmap,
6025 };
6026 
bdrv_qcow2_init(void)6027 static void bdrv_qcow2_init(void)
6028 {
6029     bdrv_register(&bdrv_qcow2);
6030 }
6031 
6032 block_init(bdrv_qcow2_init);
6033