Merge remote-tracking branch 'remotes/mst/tags/for_upstream' into staging
[qemu/ar7.git] / block / qcow2-cluster.c
blobbd0597842f320e7bc635fa67a3ed92e9c2c08621
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  */
25 #include "qemu/osdep.h"
26 #include <zlib.h>
28 #include "qapi/error.h"
29 #include "qcow2.h"
30 #include "qemu/bswap.h"
31 #include "trace.h"
33 int qcow2_shrink_l1_table(BlockDriverState *bs, uint64_t exact_size)
35     BDRVQcow2State *s = bs->opaque;
36     int new_l1_size, i, ret;
38     if (exact_size >= s->l1_size) {
39         return 0;
40     }
42     new_l1_size = exact_size;
44 #ifdef DEBUG_ALLOC2
45     fprintf(stderr, "shrink l1_table from %d to %d\n", s->l1_size, new_l1_size);
46 #endif
48     BLKDBG_EVENT(bs->file, BLKDBG_L1_SHRINK_WRITE_TABLE);
49     ret = bdrv_pwrite_zeroes(bs->file, s->l1_table_offset +
50                                        new_l1_size * L1E_SIZE,
51                              (s->l1_size - new_l1_size) * L1E_SIZE, 0);
52     if (ret < 0) {
53         goto fail;
54     }
56     ret = bdrv_flush(bs->file->bs);
57     if (ret < 0) {
58         goto fail;
59     }
61     BLKDBG_EVENT(bs->file, BLKDBG_L1_SHRINK_FREE_L2_CLUSTERS);
62     for (i = s->l1_size - 1; i > new_l1_size - 1; i--) {
63         if ((s->l1_table[i] & L1E_OFFSET_MASK) == 0) {
64             continue;
65         }
66         qcow2_free_clusters(bs, s->l1_table[i] & L1E_OFFSET_MASK,
67                             s->cluster_size, QCOW2_DISCARD_ALWAYS);
68         s->l1_table[i] = 0;
69     }
70     return 0;
72 fail:
73     /*
74      * If the write in the l1_table failed the image may contain a partially
75      * overwritten l1_table. In this case it would be better to clear the
76      * l1_table in memory to avoid possible image corruption.
77      */
78     memset(s->l1_table + new_l1_size, 0,
79            (s->l1_size - new_l1_size) * L1E_SIZE);
80     return ret;
83 int qcow2_grow_l1_table(BlockDriverState *bs, uint64_t min_size,
84                         bool exact_size)
86     BDRVQcow2State *s = bs->opaque;
87     int new_l1_size2, ret, i;
88     uint64_t *new_l1_table;
89     int64_t old_l1_table_offset, old_l1_size;
90     int64_t new_l1_table_offset, new_l1_size;
91     uint8_t data[12];
93     if (min_size <= s->l1_size)
94         return 0;
96     /* Do a sanity check on min_size before trying to calculate new_l1_size
97      * (this prevents overflows during the while loop for the calculation of
98      * new_l1_size) */
99     if (min_size > INT_MAX / L1E_SIZE) {
100         return -EFBIG;
101     }
103     if (exact_size) {
104         new_l1_size = min_size;
105     } else {
106         /* Bump size up to reduce the number of times we have to grow */
107         new_l1_size = s->l1_size;
108         if (new_l1_size == 0) {
109             new_l1_size = 1;
110         }
111         while (min_size > new_l1_size) {
112             new_l1_size = DIV_ROUND_UP(new_l1_size * 3, 2);
113         }
114     }
116     QEMU_BUILD_BUG_ON(QCOW_MAX_L1_SIZE > INT_MAX);
117     if (new_l1_size > QCOW_MAX_L1_SIZE / L1E_SIZE) {
118         return -EFBIG;
119     }
121 #ifdef DEBUG_ALLOC2
122     fprintf(stderr, "grow l1_table from %d to %" PRId64 "\n",
123             s->l1_size, new_l1_size);
124 #endif
126     new_l1_size2 = L1E_SIZE * new_l1_size;
127     new_l1_table = qemu_try_blockalign(bs->file->bs, new_l1_size2);
128     if (new_l1_table == NULL) {
129         return -ENOMEM;
130     }
131     memset(new_l1_table, 0, new_l1_size2);
133     if (s->l1_size) {
134         memcpy(new_l1_table, s->l1_table, s->l1_size * L1E_SIZE);
135     }
137     /* write new table (align to cluster) */
138     BLKDBG_EVENT(bs->file, BLKDBG_L1_GROW_ALLOC_TABLE);
139     new_l1_table_offset = qcow2_alloc_clusters(bs, new_l1_size2);
140     if (new_l1_table_offset < 0) {
141         qemu_vfree(new_l1_table);
142         return new_l1_table_offset;
143     }
145     ret = qcow2_cache_flush(bs, s->refcount_block_cache);
146     if (ret < 0) {
147         goto fail;
148     }
150     /* the L1 position has not yet been updated, so these clusters must
151      * indeed be completely free */
152     ret = qcow2_pre_write_overlap_check(bs, 0, new_l1_table_offset,
153                                         new_l1_size2, false);
154     if (ret < 0) {
155         goto fail;
156     }
158     BLKDBG_EVENT(bs->file, BLKDBG_L1_GROW_WRITE_TABLE);
159     for(i = 0; i < s->l1_size; i++)
160         new_l1_table[i] = cpu_to_be64(new_l1_table[i]);
161     ret = bdrv_pwrite_sync(bs->file, new_l1_table_offset,
162                            new_l1_table, new_l1_size2);
163     if (ret < 0)
164         goto fail;
165     for(i = 0; i < s->l1_size; i++)
166         new_l1_table[i] = be64_to_cpu(new_l1_table[i]);
168     /* set new table */
169     BLKDBG_EVENT(bs->file, BLKDBG_L1_GROW_ACTIVATE_TABLE);
170     stl_be_p(data, new_l1_size);
171     stq_be_p(data + 4, new_l1_table_offset);
172     ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, l1_size),
173                            data, sizeof(data));
174     if (ret < 0) {
175         goto fail;
176     }
177     qemu_vfree(s->l1_table);
178     old_l1_table_offset = s->l1_table_offset;
179     s->l1_table_offset = new_l1_table_offset;
180     s->l1_table = new_l1_table;
181     old_l1_size = s->l1_size;
182     s->l1_size = new_l1_size;
183     qcow2_free_clusters(bs, old_l1_table_offset, old_l1_size * L1E_SIZE,
184                         QCOW2_DISCARD_OTHER);
185     return 0;
186  fail:
187     qemu_vfree(new_l1_table);
188     qcow2_free_clusters(bs, new_l1_table_offset, new_l1_size2,
189                         QCOW2_DISCARD_OTHER);
190     return ret;
194  * l2_load
196  * @bs: The BlockDriverState
197  * @offset: A guest offset, used to calculate what slice of the L2
198  *          table to load.
199  * @l2_offset: Offset to the L2 table in the image file.
200  * @l2_slice: Location to store the pointer to the L2 slice.
202  * Loads a L2 slice into memory (L2 slices are the parts of L2 tables
203  * that are loaded by the qcow2 cache). If the slice is in the cache,
204  * the cache is used; otherwise the L2 slice is loaded from the image
205  * file.
206  */
207 static int l2_load(BlockDriverState *bs, uint64_t offset,
208                    uint64_t l2_offset, uint64_t **l2_slice)
210     BDRVQcow2State *s = bs->opaque;
211     int start_of_slice = l2_entry_size(s) *
212         (offset_to_l2_index(s, offset) - offset_to_l2_slice_index(s, offset));
214     return qcow2_cache_get(bs, s->l2_table_cache, l2_offset + start_of_slice,
215                            (void **)l2_slice);
219  * Writes an L1 entry to disk (note that depending on the alignment
220  * requirements this function may write more that just one entry in
221  * order to prevent bdrv_pwrite from performing a read-modify-write)
222  */
223 int qcow2_write_l1_entry(BlockDriverState *bs, int l1_index)
225     BDRVQcow2State *s = bs->opaque;
226     int l1_start_index;
227     int i, ret;
228     int bufsize = MAX(L1E_SIZE,
229                       MIN(bs->file->bs->bl.request_alignment, s->cluster_size));
230     int nentries = bufsize / L1E_SIZE;
231     g_autofree uint64_t *buf = g_try_new0(uint64_t, nentries);
233     if (buf == NULL) {
234         return -ENOMEM;
235     }
237     l1_start_index = QEMU_ALIGN_DOWN(l1_index, nentries);
238     for (i = 0; i < MIN(nentries, s->l1_size - l1_start_index); i++) {
239         buf[i] = cpu_to_be64(s->l1_table[l1_start_index + i]);
240     }
242     ret = qcow2_pre_write_overlap_check(bs, QCOW2_OL_ACTIVE_L1,
243             s->l1_table_offset + L1E_SIZE * l1_start_index, bufsize, false);
244     if (ret < 0) {
245         return ret;
246     }
248     BLKDBG_EVENT(bs->file, BLKDBG_L1_UPDATE);
249     ret = bdrv_pwrite_sync(bs->file,
250                            s->l1_table_offset + L1E_SIZE * l1_start_index,
251                            buf, bufsize);
252     if (ret < 0) {
253         return ret;
254     }
256     return 0;
260  * l2_allocate
262  * Allocate a new l2 entry in the file. If l1_index points to an already
263  * used entry in the L2 table (i.e. we are doing a copy on write for the L2
264  * table) copy the contents of the old L2 table into the newly allocated one.
265  * Otherwise the new table is initialized with zeros.
267  */
269 static int l2_allocate(BlockDriverState *bs, int l1_index)
271     BDRVQcow2State *s = bs->opaque;
272     uint64_t old_l2_offset;
273     uint64_t *l2_slice = NULL;
274     unsigned slice, slice_size2, n_slices;
275     int64_t l2_offset;
276     int ret;
278     old_l2_offset = s->l1_table[l1_index];
280     trace_qcow2_l2_allocate(bs, l1_index);
282     /* allocate a new l2 entry */
284     l2_offset = qcow2_alloc_clusters(bs, s->l2_size * l2_entry_size(s));
285     if (l2_offset < 0) {
286         ret = l2_offset;
287         goto fail;
288     }
290     /* The offset must fit in the offset field of the L1 table entry */
291     assert((l2_offset & L1E_OFFSET_MASK) == l2_offset);
293     /* If we're allocating the table at offset 0 then something is wrong */
294     if (l2_offset == 0) {
295         qcow2_signal_corruption(bs, true, -1, -1, "Preventing invalid "
296                                 "allocation of L2 table at offset 0");
297         ret = -EIO;
298         goto fail;
299     }
301     ret = qcow2_cache_flush(bs, s->refcount_block_cache);
302     if (ret < 0) {
303         goto fail;
304     }
306     /* allocate a new entry in the l2 cache */
308     slice_size2 = s->l2_slice_size * l2_entry_size(s);
309     n_slices = s->cluster_size / slice_size2;
311     trace_qcow2_l2_allocate_get_empty(bs, l1_index);
312     for (slice = 0; slice < n_slices; slice++) {
313         ret = qcow2_cache_get_empty(bs, s->l2_table_cache,
314                                     l2_offset + slice * slice_size2,
315                                     (void **) &l2_slice);
316         if (ret < 0) {
317             goto fail;
318         }
320         if ((old_l2_offset & L1E_OFFSET_MASK) == 0) {
321             /* if there was no old l2 table, clear the new slice */
322             memset(l2_slice, 0, slice_size2);
323         } else {
324             uint64_t *old_slice;
325             uint64_t old_l2_slice_offset =
326                 (old_l2_offset & L1E_OFFSET_MASK) + slice * slice_size2;
328             /* if there was an old l2 table, read a slice from the disk */
329             BLKDBG_EVENT(bs->file, BLKDBG_L2_ALLOC_COW_READ);
330             ret = qcow2_cache_get(bs, s->l2_table_cache, old_l2_slice_offset,
331                                   (void **) &old_slice);
332             if (ret < 0) {
333                 goto fail;
334             }
336             memcpy(l2_slice, old_slice, slice_size2);
338             qcow2_cache_put(s->l2_table_cache, (void **) &old_slice);
339         }
341         /* write the l2 slice to the file */
342         BLKDBG_EVENT(bs->file, BLKDBG_L2_ALLOC_WRITE);
344         trace_qcow2_l2_allocate_write_l2(bs, l1_index);
345         qcow2_cache_entry_mark_dirty(s->l2_table_cache, l2_slice);
346         qcow2_cache_put(s->l2_table_cache, (void **) &l2_slice);
347     }
349     ret = qcow2_cache_flush(bs, s->l2_table_cache);
350     if (ret < 0) {
351         goto fail;
352     }
354     /* update the L1 entry */
355     trace_qcow2_l2_allocate_write_l1(bs, l1_index);
356     s->l1_table[l1_index] = l2_offset | QCOW_OFLAG_COPIED;
357     ret = qcow2_write_l1_entry(bs, l1_index);
358     if (ret < 0) {
359         goto fail;
360     }
362     trace_qcow2_l2_allocate_done(bs, l1_index, 0);
363     return 0;
365 fail:
366     trace_qcow2_l2_allocate_done(bs, l1_index, ret);
367     if (l2_slice != NULL) {
368         qcow2_cache_put(s->l2_table_cache, (void **) &l2_slice);
369     }
370     s->l1_table[l1_index] = old_l2_offset;
371     if (l2_offset > 0) {
372         qcow2_free_clusters(bs, l2_offset, s->l2_size * l2_entry_size(s),
373                             QCOW2_DISCARD_ALWAYS);
374     }
375     return ret;
379  * For a given L2 entry, count the number of contiguous subclusters of
380  * the same type starting from @sc_from. Compressed clusters are
381  * treated as if they were divided into subclusters of size
382  * s->subcluster_size.
384  * Return the number of contiguous subclusters and set @type to the
385  * subcluster type.
387  * If the L2 entry is invalid return -errno and set @type to
388  * QCOW2_SUBCLUSTER_INVALID.
389  */
390 static int qcow2_get_subcluster_range_type(BlockDriverState *bs,
391                                            uint64_t l2_entry,
392                                            uint64_t l2_bitmap,
393                                            unsigned sc_from,
394                                            QCow2SubclusterType *type)
396     BDRVQcow2State *s = bs->opaque;
397     uint32_t val;
399     *type = qcow2_get_subcluster_type(bs, l2_entry, l2_bitmap, sc_from);
401     if (*type == QCOW2_SUBCLUSTER_INVALID) {
402         return -EINVAL;
403     } else if (!has_subclusters(s) || *type == QCOW2_SUBCLUSTER_COMPRESSED) {
404         return s->subclusters_per_cluster - sc_from;
405     }
407     switch (*type) {
408     case QCOW2_SUBCLUSTER_NORMAL:
409         val = l2_bitmap | QCOW_OFLAG_SUB_ALLOC_RANGE(0, sc_from);
410         return cto32(val) - sc_from;
412     case QCOW2_SUBCLUSTER_ZERO_PLAIN:
413     case QCOW2_SUBCLUSTER_ZERO_ALLOC:
414         val = (l2_bitmap | QCOW_OFLAG_SUB_ZERO_RANGE(0, sc_from)) >> 32;
415         return cto32(val) - sc_from;
417     case QCOW2_SUBCLUSTER_UNALLOCATED_PLAIN:
418     case QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC:
419         val = ((l2_bitmap >> 32) | l2_bitmap)
420             & ~QCOW_OFLAG_SUB_ALLOC_RANGE(0, sc_from);
421         return ctz32(val) - sc_from;
423     default:
424         g_assert_not_reached();
425     }
429  * Return the number of contiguous subclusters of the exact same type
430  * in a given L2 slice, starting from cluster @l2_index, subcluster
431  * @sc_index. Allocated subclusters are required to be contiguous in
432  * the image file.
433  * At most @nb_clusters are checked (note that this means clusters,
434  * not subclusters).
435  * Compressed clusters are always processed one by one but for the
436  * purpose of this count they are treated as if they were divided into
437  * subclusters of size s->subcluster_size.
438  * On failure return -errno and update @l2_index to point to the
439  * invalid entry.
440  */
441 static int count_contiguous_subclusters(BlockDriverState *bs, int nb_clusters,
442                                         unsigned sc_index, uint64_t *l2_slice,
443                                         unsigned *l2_index)
445     BDRVQcow2State *s = bs->opaque;
446     int i, count = 0;
447     bool check_offset = false;
448     uint64_t expected_offset = 0;
449     QCow2SubclusterType expected_type = QCOW2_SUBCLUSTER_NORMAL, type;
451     assert(*l2_index + nb_clusters <= s->l2_slice_size);
453     for (i = 0; i < nb_clusters; i++) {
454         unsigned first_sc = (i == 0) ? sc_index : 0;
455         uint64_t l2_entry = get_l2_entry(s, l2_slice, *l2_index + i);
456         uint64_t l2_bitmap = get_l2_bitmap(s, l2_slice, *l2_index + i);
457         int ret = qcow2_get_subcluster_range_type(bs, l2_entry, l2_bitmap,
458                                                   first_sc, &type);
459         if (ret < 0) {
460             *l2_index += i; /* Point to the invalid entry */
461             return -EIO;
462         }
463         if (i == 0) {
464             if (type == QCOW2_SUBCLUSTER_COMPRESSED) {
465                 /* Compressed clusters are always processed one by one */
466                 return ret;
467             }
468             expected_type = type;
469             expected_offset = l2_entry & L2E_OFFSET_MASK;
470             check_offset = (type == QCOW2_SUBCLUSTER_NORMAL ||
471                             type == QCOW2_SUBCLUSTER_ZERO_ALLOC ||
472                             type == QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC);
473         } else if (type != expected_type) {
474             break;
475         } else if (check_offset) {
476             expected_offset += s->cluster_size;
477             if (expected_offset != (l2_entry & L2E_OFFSET_MASK)) {
478                 break;
479             }
480         }
481         count += ret;
482         /* Stop if there are type changes before the end of the cluster */
483         if (first_sc + ret < s->subclusters_per_cluster) {
484             break;
485         }
486     }
488     return count;
491 static int coroutine_fn do_perform_cow_read(BlockDriverState *bs,
492                                             uint64_t src_cluster_offset,
493                                             unsigned offset_in_cluster,
494                                             QEMUIOVector *qiov)
496     int ret;
498     if (qiov->size == 0) {
499         return 0;
500     }
502     BLKDBG_EVENT(bs->file, BLKDBG_COW_READ);
504     if (!bs->drv) {
505         return -ENOMEDIUM;
506     }
508     /* Call .bdrv_co_readv() directly instead of using the public block-layer
509      * interface.  This avoids double I/O throttling and request tracking,
510      * which can lead to deadlock when block layer copy-on-read is enabled.
511      */
512     ret = bs->drv->bdrv_co_preadv_part(bs,
513                                        src_cluster_offset + offset_in_cluster,
514                                        qiov->size, qiov, 0, 0);
515     if (ret < 0) {
516         return ret;
517     }
519     return 0;
522 static int coroutine_fn do_perform_cow_write(BlockDriverState *bs,
523                                              uint64_t cluster_offset,
524                                              unsigned offset_in_cluster,
525                                              QEMUIOVector *qiov)
527     BDRVQcow2State *s = bs->opaque;
528     int ret;
530     if (qiov->size == 0) {
531         return 0;
532     }
534     ret = qcow2_pre_write_overlap_check(bs, 0,
535             cluster_offset + offset_in_cluster, qiov->size, true);
536     if (ret < 0) {
537         return ret;
538     }
540     BLKDBG_EVENT(bs->file, BLKDBG_COW_WRITE);
541     ret = bdrv_co_pwritev(s->data_file, cluster_offset + offset_in_cluster,
542                           qiov->size, qiov, 0);
543     if (ret < 0) {
544         return ret;
545     }
547     return 0;
552  * get_host_offset
554  * For a given offset of the virtual disk find the equivalent host
555  * offset in the qcow2 file and store it in *host_offset. Neither
556  * offset needs to be aligned to a cluster boundary.
558  * If the cluster is unallocated then *host_offset will be 0.
559  * If the cluster is compressed then *host_offset will contain the
560  * complete compressed cluster descriptor.
562  * On entry, *bytes is the maximum number of contiguous bytes starting at
563  * offset that we are interested in.
565  * On exit, *bytes is the number of bytes starting at offset that have the same
566  * subcluster type and (if applicable) are stored contiguously in the image
567  * file. The subcluster type is stored in *subcluster_type.
568  * Compressed clusters are always processed one by one.
570  * Returns 0 on success, -errno in error cases.
571  */
572 int qcow2_get_host_offset(BlockDriverState *bs, uint64_t offset,
573                           unsigned int *bytes, uint64_t *host_offset,
574                           QCow2SubclusterType *subcluster_type)
576     BDRVQcow2State *s = bs->opaque;
577     unsigned int l2_index, sc_index;
578     uint64_t l1_index, l2_offset, *l2_slice, l2_entry, l2_bitmap;
579     int sc;
580     unsigned int offset_in_cluster;
581     uint64_t bytes_available, bytes_needed, nb_clusters;
582     QCow2SubclusterType type;
583     int ret;
585     offset_in_cluster = offset_into_cluster(s, offset);
586     bytes_needed = (uint64_t) *bytes + offset_in_cluster;
588     /* compute how many bytes there are between the start of the cluster
589      * containing offset and the end of the l2 slice that contains
590      * the entry pointing to it */
591     bytes_available =
592         ((uint64_t) (s->l2_slice_size - offset_to_l2_slice_index(s, offset)))
593         << s->cluster_bits;
595     if (bytes_needed > bytes_available) {
596         bytes_needed = bytes_available;
597     }
599     *host_offset = 0;
601     /* seek to the l2 offset in the l1 table */
603     l1_index = offset_to_l1_index(s, offset);
604     if (l1_index >= s->l1_size) {
605         type = QCOW2_SUBCLUSTER_UNALLOCATED_PLAIN;
606         goto out;
607     }
609     l2_offset = s->l1_table[l1_index] & L1E_OFFSET_MASK;
610     if (!l2_offset) {
611         type = QCOW2_SUBCLUSTER_UNALLOCATED_PLAIN;
612         goto out;
613     }
615     if (offset_into_cluster(s, l2_offset)) {
616         qcow2_signal_corruption(bs, true, -1, -1, "L2 table offset %#" PRIx64
617                                 " unaligned (L1 index: %#" PRIx64 ")",
618                                 l2_offset, l1_index);
619         return -EIO;
620     }
622     /* load the l2 slice in memory */
624     ret = l2_load(bs, offset, l2_offset, &l2_slice);
625     if (ret < 0) {
626         return ret;
627     }
629     /* find the cluster offset for the given disk offset */
631     l2_index = offset_to_l2_slice_index(s, offset);
632     sc_index = offset_to_sc_index(s, offset);
633     l2_entry = get_l2_entry(s, l2_slice, l2_index);
634     l2_bitmap = get_l2_bitmap(s, l2_slice, l2_index);
636     nb_clusters = size_to_clusters(s, bytes_needed);
637     /* bytes_needed <= *bytes + offset_in_cluster, both of which are unsigned
638      * integers; the minimum cluster size is 512, so this assertion is always
639      * true */
640     assert(nb_clusters <= INT_MAX);
642     type = qcow2_get_subcluster_type(bs, l2_entry, l2_bitmap, sc_index);
643     if (s->qcow_version < 3 && (type == QCOW2_SUBCLUSTER_ZERO_PLAIN ||
644                                 type == QCOW2_SUBCLUSTER_ZERO_ALLOC)) {
645         qcow2_signal_corruption(bs, true, -1, -1, "Zero cluster entry found"
646                                 " in pre-v3 image (L2 offset: %#" PRIx64
647                                 ", L2 index: %#x)", l2_offset, l2_index);
648         ret = -EIO;
649         goto fail;
650     }
651     switch (type) {
652     case QCOW2_SUBCLUSTER_INVALID:
653         break; /* This is handled by count_contiguous_subclusters() below */
654     case QCOW2_SUBCLUSTER_COMPRESSED:
655         if (has_data_file(bs)) {
656             qcow2_signal_corruption(bs, true, -1, -1, "Compressed cluster "
657                                     "entry found in image with external data "
658                                     "file (L2 offset: %#" PRIx64 ", L2 index: "
659                                     "%#x)", l2_offset, l2_index);
660             ret = -EIO;
661             goto fail;
662         }
663         *host_offset = l2_entry & L2E_COMPRESSED_OFFSET_SIZE_MASK;
664         break;
665     case QCOW2_SUBCLUSTER_ZERO_PLAIN:
666     case QCOW2_SUBCLUSTER_UNALLOCATED_PLAIN:
667         break;
668     case QCOW2_SUBCLUSTER_ZERO_ALLOC:
669     case QCOW2_SUBCLUSTER_NORMAL:
670     case QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC: {
671         uint64_t host_cluster_offset = l2_entry & L2E_OFFSET_MASK;
672         *host_offset = host_cluster_offset + offset_in_cluster;
673         if (offset_into_cluster(s, host_cluster_offset)) {
674             qcow2_signal_corruption(bs, true, -1, -1,
675                                     "Cluster allocation offset %#"
676                                     PRIx64 " unaligned (L2 offset: %#" PRIx64
677                                     ", L2 index: %#x)", host_cluster_offset,
678                                     l2_offset, l2_index);
679             ret = -EIO;
680             goto fail;
681         }
682         if (has_data_file(bs) && *host_offset != offset) {
683             qcow2_signal_corruption(bs, true, -1, -1,
684                                     "External data file host cluster offset %#"
685                                     PRIx64 " does not match guest cluster "
686                                     "offset: %#" PRIx64
687                                     ", L2 index: %#x)", host_cluster_offset,
688                                     offset - offset_in_cluster, l2_index);
689             ret = -EIO;
690             goto fail;
691         }
692         break;
693     }
694     default:
695         abort();
696     }
698     sc = count_contiguous_subclusters(bs, nb_clusters, sc_index,
699                                       l2_slice, &l2_index);
700     if (sc < 0) {
701         qcow2_signal_corruption(bs, true, -1, -1, "Invalid cluster entry found "
702                                 " (L2 offset: %#" PRIx64 ", L2 index: %#x)",
703                                 l2_offset, l2_index);
704         ret = -EIO;
705         goto fail;
706     }
707     qcow2_cache_put(s->l2_table_cache, (void **) &l2_slice);
709     bytes_available = ((int64_t)sc + sc_index) << s->subcluster_bits;
711 out:
712     if (bytes_available > bytes_needed) {
713         bytes_available = bytes_needed;
714     }
716     /* bytes_available <= bytes_needed <= *bytes + offset_in_cluster;
717      * subtracting offset_in_cluster will therefore definitely yield something
718      * not exceeding UINT_MAX */
719     assert(bytes_available - offset_in_cluster <= UINT_MAX);
720     *bytes = bytes_available - offset_in_cluster;
722     *subcluster_type = type;
724     return 0;
726 fail:
727     qcow2_cache_put(s->l2_table_cache, (void **)&l2_slice);
728     return ret;
732  * get_cluster_table
734  * for a given disk offset, load (and allocate if needed)
735  * the appropriate slice of its l2 table.
737  * the cluster index in the l2 slice is given to the caller.
739  * Returns 0 on success, -errno in failure case
740  */
741 static int get_cluster_table(BlockDriverState *bs, uint64_t offset,
742                              uint64_t **new_l2_slice,
743                              int *new_l2_index)
745     BDRVQcow2State *s = bs->opaque;
746     unsigned int l2_index;
747     uint64_t l1_index, l2_offset;
748     uint64_t *l2_slice = NULL;
749     int ret;
751     /* seek to the l2 offset in the l1 table */
753     l1_index = offset_to_l1_index(s, offset);
754     if (l1_index >= s->l1_size) {
755         ret = qcow2_grow_l1_table(bs, l1_index + 1, false);
756         if (ret < 0) {
757             return ret;
758         }
759     }
761     assert(l1_index < s->l1_size);
762     l2_offset = s->l1_table[l1_index] & L1E_OFFSET_MASK;
763     if (offset_into_cluster(s, l2_offset)) {
764         qcow2_signal_corruption(bs, true, -1, -1, "L2 table offset %#" PRIx64
765                                 " unaligned (L1 index: %#" PRIx64 ")",
766                                 l2_offset, l1_index);
767         return -EIO;
768     }
770     if (!(s->l1_table[l1_index] & QCOW_OFLAG_COPIED)) {
771         /* First allocate a new L2 table (and do COW if needed) */
772         ret = l2_allocate(bs, l1_index);
773         if (ret < 0) {
774             return ret;
775         }
777         /* Then decrease the refcount of the old table */
778         if (l2_offset) {
779             qcow2_free_clusters(bs, l2_offset, s->l2_size * l2_entry_size(s),
780                                 QCOW2_DISCARD_OTHER);
781         }
783         /* Get the offset of the newly-allocated l2 table */
784         l2_offset = s->l1_table[l1_index] & L1E_OFFSET_MASK;
785         assert(offset_into_cluster(s, l2_offset) == 0);
786     }
788     /* load the l2 slice in memory */
789     ret = l2_load(bs, offset, l2_offset, &l2_slice);
790     if (ret < 0) {
791         return ret;
792     }
794     /* find the cluster offset for the given disk offset */
796     l2_index = offset_to_l2_slice_index(s, offset);
798     *new_l2_slice = l2_slice;
799     *new_l2_index = l2_index;
801     return 0;
805  * alloc_compressed_cluster_offset
807  * For a given offset on the virtual disk, allocate a new compressed cluster
808  * and put the host offset of the cluster into *host_offset. If a cluster is
809  * already allocated at the offset, return an error.
811  * Return 0 on success and -errno in error cases
812  */
813 int qcow2_alloc_compressed_cluster_offset(BlockDriverState *bs,
814                                           uint64_t offset,
815                                           int compressed_size,
816                                           uint64_t *host_offset)
818     BDRVQcow2State *s = bs->opaque;
819     int l2_index, ret;
820     uint64_t *l2_slice;
821     int64_t cluster_offset;
822     int nb_csectors;
824     if (has_data_file(bs)) {
825         return 0;
826     }
828     ret = get_cluster_table(bs, offset, &l2_slice, &l2_index);
829     if (ret < 0) {
830         return ret;
831     }
833     /* Compression can't overwrite anything. Fail if the cluster was already
834      * allocated. */
835     cluster_offset = get_l2_entry(s, l2_slice, l2_index);
836     if (cluster_offset & L2E_OFFSET_MASK) {
837         qcow2_cache_put(s->l2_table_cache, (void **) &l2_slice);
838         return -EIO;
839     }
841     cluster_offset = qcow2_alloc_bytes(bs, compressed_size);
842     if (cluster_offset < 0) {
843         qcow2_cache_put(s->l2_table_cache, (void **) &l2_slice);
844         return cluster_offset;
845     }
847     nb_csectors =
848         (cluster_offset + compressed_size - 1) / QCOW2_COMPRESSED_SECTOR_SIZE -
849         (cluster_offset / QCOW2_COMPRESSED_SECTOR_SIZE);
851     /* The offset and size must fit in their fields of the L2 table entry */
852     assert((cluster_offset & s->cluster_offset_mask) == cluster_offset);
853     assert((nb_csectors & s->csize_mask) == nb_csectors);
855     cluster_offset |= QCOW_OFLAG_COMPRESSED |
856                       ((uint64_t)nb_csectors << s->csize_shift);
858     /* update L2 table */
860     /* compressed clusters never have the copied flag */
862     BLKDBG_EVENT(bs->file, BLKDBG_L2_UPDATE_COMPRESSED);
863     qcow2_cache_entry_mark_dirty(s->l2_table_cache, l2_slice);
864     set_l2_entry(s, l2_slice, l2_index, cluster_offset);
865     if (has_subclusters(s)) {
866         set_l2_bitmap(s, l2_slice, l2_index, 0);
867     }
868     qcow2_cache_put(s->l2_table_cache, (void **) &l2_slice);
870     *host_offset = cluster_offset & s->cluster_offset_mask;
871     return 0;
874 static int perform_cow(BlockDriverState *bs, QCowL2Meta *m)
876     BDRVQcow2State *s = bs->opaque;
877     Qcow2COWRegion *start = &m->cow_start;
878     Qcow2COWRegion *end = &m->cow_end;
879     unsigned buffer_size;
880     unsigned data_bytes = end->offset - (start->offset + start->nb_bytes);
881     bool merge_reads;
882     uint8_t *start_buffer, *end_buffer;
883     QEMUIOVector qiov;
884     int ret;
886     assert(start->nb_bytes <= UINT_MAX - end->nb_bytes);
887     assert(start->nb_bytes + end->nb_bytes <= UINT_MAX - data_bytes);
888     assert(start->offset + start->nb_bytes <= end->offset);
890     if ((start->nb_bytes == 0 && end->nb_bytes == 0) || m->skip_cow) {
891         return 0;
892     }
894     /* If we have to read both the start and end COW regions and the
895      * middle region is not too large then perform just one read
896      * operation */
897     merge_reads = start->nb_bytes && end->nb_bytes && data_bytes <= 16384;
898     if (merge_reads) {
899         buffer_size = start->nb_bytes + data_bytes + end->nb_bytes;
900     } else {
901         /* If we have to do two reads, add some padding in the middle
902          * if necessary to make sure that the end region is optimally
903          * aligned. */
904         size_t align = bdrv_opt_mem_align(bs);
905         assert(align > 0 && align <= UINT_MAX);
906         assert(QEMU_ALIGN_UP(start->nb_bytes, align) <=
907                UINT_MAX - end->nb_bytes);
908         buffer_size = QEMU_ALIGN_UP(start->nb_bytes, align) + end->nb_bytes;
909     }
911     /* Reserve a buffer large enough to store all the data that we're
912      * going to read */
913     start_buffer = qemu_try_blockalign(bs, buffer_size);
914     if (start_buffer == NULL) {
915         return -ENOMEM;
916     }
917     /* The part of the buffer where the end region is located */
918     end_buffer = start_buffer + buffer_size - end->nb_bytes;
920     qemu_iovec_init(&qiov, 2 + (m->data_qiov ?
921                                 qemu_iovec_subvec_niov(m->data_qiov,
922                                                        m->data_qiov_offset,
923                                                        data_bytes)
924                                 : 0));
926     qemu_co_mutex_unlock(&s->lock);
927     /* First we read the existing data from both COW regions. We
928      * either read the whole region in one go, or the start and end
929      * regions separately. */
930     if (merge_reads) {
931         qemu_iovec_add(&qiov, start_buffer, buffer_size);
932         ret = do_perform_cow_read(bs, m->offset, start->offset, &qiov);
933     } else {
934         qemu_iovec_add(&qiov, start_buffer, start->nb_bytes);
935         ret = do_perform_cow_read(bs, m->offset, start->offset, &qiov);
936         if (ret < 0) {
937             goto fail;
938         }
940         qemu_iovec_reset(&qiov);
941         qemu_iovec_add(&qiov, end_buffer, end->nb_bytes);
942         ret = do_perform_cow_read(bs, m->offset, end->offset, &qiov);
943     }
944     if (ret < 0) {
945         goto fail;
946     }
948     /* Encrypt the data if necessary before writing it */
949     if (bs->encrypted) {
950         ret = qcow2_co_encrypt(bs,
951                                m->alloc_offset + start->offset,
952                                m->offset + start->offset,
953                                start_buffer, start->nb_bytes);
954         if (ret < 0) {
955             goto fail;
956         }
958         ret = qcow2_co_encrypt(bs,
959                                m->alloc_offset + end->offset,
960                                m->offset + end->offset,
961                                end_buffer, end->nb_bytes);
962         if (ret < 0) {
963             goto fail;
964         }
965     }
967     /* And now we can write everything. If we have the guest data we
968      * can write everything in one single operation */
969     if (m->data_qiov) {
970         qemu_iovec_reset(&qiov);
971         if (start->nb_bytes) {
972             qemu_iovec_add(&qiov, start_buffer, start->nb_bytes);
973         }
974         qemu_iovec_concat(&qiov, m->data_qiov, m->data_qiov_offset, data_bytes);
975         if (end->nb_bytes) {
976             qemu_iovec_add(&qiov, end_buffer, end->nb_bytes);
977         }
978         /* NOTE: we have a write_aio blkdebug event here followed by
979          * a cow_write one in do_perform_cow_write(), but there's only
980          * one single I/O operation */
981         BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);
982         ret = do_perform_cow_write(bs, m->alloc_offset, start->offset, &qiov);
983     } else {
984         /* If there's no guest data then write both COW regions separately */
985         qemu_iovec_reset(&qiov);
986         qemu_iovec_add(&qiov, start_buffer, start->nb_bytes);
987         ret = do_perform_cow_write(bs, m->alloc_offset, start->offset, &qiov);
988         if (ret < 0) {
989             goto fail;
990         }
992         qemu_iovec_reset(&qiov);
993         qemu_iovec_add(&qiov, end_buffer, end->nb_bytes);
994         ret = do_perform_cow_write(bs, m->alloc_offset, end->offset, &qiov);
995     }
997 fail:
998     qemu_co_mutex_lock(&s->lock);
1000     /*
1001      * Before we update the L2 table to actually point to the new cluster, we
1002      * need to be sure that the refcounts have been increased and COW was
1003      * handled.
1004      */
1005     if (ret == 0) {
1006         qcow2_cache_depends_on_flush(s->l2_table_cache);
1007     }
1009     qemu_vfree(start_buffer);
1010     qemu_iovec_destroy(&qiov);
1011     return ret;
1014 int qcow2_alloc_cluster_link_l2(BlockDriverState *bs, QCowL2Meta *m)
1016     BDRVQcow2State *s = bs->opaque;
1017     int i, j = 0, l2_index, ret;
1018     uint64_t *old_cluster, *l2_slice;
1019     uint64_t cluster_offset = m->alloc_offset;
1021     trace_qcow2_cluster_link_l2(qemu_coroutine_self(), m->nb_clusters);
1022     assert(m->nb_clusters > 0);
1024     old_cluster = g_try_new(uint64_t, m->nb_clusters);
1025     if (old_cluster == NULL) {
1026         ret = -ENOMEM;
1027         goto err;
1028     }
1030     /* copy content of unmodified sectors */
1031     ret = perform_cow(bs, m);
1032     if (ret < 0) {
1033         goto err;
1034     }
1036     /* Update L2 table. */
1037     if (s->use_lazy_refcounts) {
1038         qcow2_mark_dirty(bs);
1039     }
1040     if (qcow2_need_accurate_refcounts(s)) {
1041         qcow2_cache_set_dependency(bs, s->l2_table_cache,
1042                                    s->refcount_block_cache);
1043     }
1045     ret = get_cluster_table(bs, m->offset, &l2_slice, &l2_index);
1046     if (ret < 0) {
1047         goto err;
1048     }
1049     qcow2_cache_entry_mark_dirty(s->l2_table_cache, l2_slice);
1051     assert(l2_index + m->nb_clusters <= s->l2_slice_size);
1052     assert(m->cow_end.offset + m->cow_end.nb_bytes <=
1053            m->nb_clusters << s->cluster_bits);
1054     for (i = 0; i < m->nb_clusters; i++) {
1055         uint64_t offset = cluster_offset + ((uint64_t)i << s->cluster_bits);
1056         /* if two concurrent writes happen to the same unallocated cluster
1057          * each write allocates separate cluster and writes data concurrently.
1058          * The first one to complete updates l2 table with pointer to its
1059          * cluster the second one has to do RMW (which is done above by
1060          * perform_cow()), update l2 table with its cluster pointer and free
1061          * old cluster. This is what this loop does */
1062         if (get_l2_entry(s, l2_slice, l2_index + i) != 0) {
1063             old_cluster[j++] = get_l2_entry(s, l2_slice, l2_index + i);
1064         }
1066         /* The offset must fit in the offset field of the L2 table entry */
1067         assert((offset & L2E_OFFSET_MASK) == offset);
1069         set_l2_entry(s, l2_slice, l2_index + i, offset | QCOW_OFLAG_COPIED);
1071         /* Update bitmap with the subclusters that were just written */
1072         if (has_subclusters(s) && !m->prealloc) {
1073             uint64_t l2_bitmap = get_l2_bitmap(s, l2_slice, l2_index + i);
1074             unsigned written_from = m->cow_start.offset;
1075             unsigned written_to = m->cow_end.offset + m->cow_end.nb_bytes;
1076             int first_sc, last_sc;
1077             /* Narrow written_from and written_to down to the current cluster */
1078             written_from = MAX(written_from, i << s->cluster_bits);
1079             written_to   = MIN(written_to, (i + 1) << s->cluster_bits);
1080             assert(written_from < written_to);
1081             first_sc = offset_to_sc_index(s, written_from);
1082             last_sc  = offset_to_sc_index(s, written_to - 1);
1083             l2_bitmap |= QCOW_OFLAG_SUB_ALLOC_RANGE(first_sc, last_sc + 1);
1084             l2_bitmap &= ~QCOW_OFLAG_SUB_ZERO_RANGE(first_sc, last_sc + 1);
1085             set_l2_bitmap(s, l2_slice, l2_index + i, l2_bitmap);
1086         }
1087      }
1090     qcow2_cache_put(s->l2_table_cache, (void **) &l2_slice);
1092     /*
1093      * If this was a COW, we need to decrease the refcount of the old cluster.
1094      *
1095      * Don't discard clusters that reach a refcount of 0 (e.g. compressed
1096      * clusters), the next write will reuse them anyway.
1097      */
1098     if (!m->keep_old_clusters && j != 0) {
1099         for (i = 0; i < j; i++) {
1100             qcow2_free_any_cluster(bs, old_cluster[i], QCOW2_DISCARD_NEVER);
1101         }
1102     }
1104     ret = 0;
1105 err:
1106     g_free(old_cluster);
1107     return ret;
1111  * Frees the allocated clusters because the request failed and they won't
1112  * actually be linked.
1113  */
1114 void qcow2_alloc_cluster_abort(BlockDriverState *bs, QCowL2Meta *m)
1116     BDRVQcow2State *s = bs->opaque;
1117     if (!has_data_file(bs) && !m->keep_old_clusters) {
1118         qcow2_free_clusters(bs, m->alloc_offset,
1119                             m->nb_clusters << s->cluster_bits,
1120                             QCOW2_DISCARD_NEVER);
1121     }
1125  * For a given write request, create a new QCowL2Meta structure, add
1126  * it to @m and the BDRVQcow2State.cluster_allocs list. If the write
1127  * request does not need copy-on-write or changes to the L2 metadata
1128  * then this function does nothing.
1130  * @host_cluster_offset points to the beginning of the first cluster.
1132  * @guest_offset and @bytes indicate the offset and length of the
1133  * request.
1135  * @l2_slice contains the L2 entries of all clusters involved in this
1136  * write request.
1138  * If @keep_old is true it means that the clusters were already
1139  * allocated and will be overwritten. If false then the clusters are
1140  * new and we have to decrease the reference count of the old ones.
1142  * Returns 0 on success, -errno on failure.
1143  */
1144 static int calculate_l2_meta(BlockDriverState *bs, uint64_t host_cluster_offset,
1145                              uint64_t guest_offset, unsigned bytes,
1146                              uint64_t *l2_slice, QCowL2Meta **m, bool keep_old)
1148     BDRVQcow2State *s = bs->opaque;
1149     int sc_index, l2_index = offset_to_l2_slice_index(s, guest_offset);
1150     uint64_t l2_entry, l2_bitmap;
1151     unsigned cow_start_from, cow_end_to;
1152     unsigned cow_start_to = offset_into_cluster(s, guest_offset);
1153     unsigned cow_end_from = cow_start_to + bytes;
1154     unsigned nb_clusters = size_to_clusters(s, cow_end_from);
1155     QCowL2Meta *old_m = *m;
1156     QCow2SubclusterType type;
1157     int i;
1158     bool skip_cow = keep_old;
1160     assert(nb_clusters <= s->l2_slice_size - l2_index);
1162     /* Check the type of all affected subclusters */
1163     for (i = 0; i < nb_clusters; i++) {
1164         l2_entry = get_l2_entry(s, l2_slice, l2_index + i);
1165         l2_bitmap = get_l2_bitmap(s, l2_slice, l2_index + i);
1166         if (skip_cow) {
1167             unsigned write_from = MAX(cow_start_to, i << s->cluster_bits);
1168             unsigned write_to = MIN(cow_end_from, (i + 1) << s->cluster_bits);
1169             int first_sc = offset_to_sc_index(s, write_from);
1170             int last_sc = offset_to_sc_index(s, write_to - 1);
1171             int cnt = qcow2_get_subcluster_range_type(bs, l2_entry, l2_bitmap,
1172                                                       first_sc, &type);
1173             /* Is any of the subclusters of type != QCOW2_SUBCLUSTER_NORMAL ? */
1174             if (type != QCOW2_SUBCLUSTER_NORMAL || first_sc + cnt <= last_sc) {
1175                 skip_cow = false;
1176             }
1177         } else {
1178             /* If we can't skip the cow we can still look for invalid entries */
1179             type = qcow2_get_subcluster_type(bs, l2_entry, l2_bitmap, 0);
1180         }
1181         if (type == QCOW2_SUBCLUSTER_INVALID) {
1182             int l1_index = offset_to_l1_index(s, guest_offset);
1183             uint64_t l2_offset = s->l1_table[l1_index] & L1E_OFFSET_MASK;
1184             qcow2_signal_corruption(bs, true, -1, -1, "Invalid cluster "
1185                                     "entry found (L2 offset: %#" PRIx64
1186                                     ", L2 index: %#x)",
1187                                     l2_offset, l2_index + i);
1188             return -EIO;
1189         }
1190     }
1192     if (skip_cow) {
1193         return 0;
1194     }
1196     /* Get the L2 entry of the first cluster */
1197     l2_entry = get_l2_entry(s, l2_slice, l2_index);
1198     l2_bitmap = get_l2_bitmap(s, l2_slice, l2_index);
1199     sc_index = offset_to_sc_index(s, guest_offset);
1200     type = qcow2_get_subcluster_type(bs, l2_entry, l2_bitmap, sc_index);
1202     if (!keep_old) {
1203         switch (type) {
1204         case QCOW2_SUBCLUSTER_COMPRESSED:
1205             cow_start_from = 0;
1206             break;
1207         case QCOW2_SUBCLUSTER_NORMAL:
1208         case QCOW2_SUBCLUSTER_ZERO_ALLOC:
1209         case QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC:
1210             if (has_subclusters(s)) {
1211                 /* Skip all leading zero and unallocated subclusters */
1212                 uint32_t alloc_bitmap = l2_bitmap & QCOW_L2_BITMAP_ALL_ALLOC;
1213                 cow_start_from =
1214                     MIN(sc_index, ctz32(alloc_bitmap)) << s->subcluster_bits;
1215             } else {
1216                 cow_start_from = 0;
1217             }
1218             break;
1219         case QCOW2_SUBCLUSTER_ZERO_PLAIN:
1220         case QCOW2_SUBCLUSTER_UNALLOCATED_PLAIN:
1221             cow_start_from = sc_index << s->subcluster_bits;
1222             break;
1223         default:
1224             g_assert_not_reached();
1225         }
1226     } else {
1227         switch (type) {
1228         case QCOW2_SUBCLUSTER_NORMAL:
1229             cow_start_from = cow_start_to;
1230             break;
1231         case QCOW2_SUBCLUSTER_ZERO_ALLOC:
1232         case QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC:
1233             cow_start_from = sc_index << s->subcluster_bits;
1234             break;
1235         default:
1236             g_assert_not_reached();
1237         }
1238     }
1240     /* Get the L2 entry of the last cluster */
1241     l2_index += nb_clusters - 1;
1242     l2_entry = get_l2_entry(s, l2_slice, l2_index);
1243     l2_bitmap = get_l2_bitmap(s, l2_slice, l2_index);
1244     sc_index = offset_to_sc_index(s, guest_offset + bytes - 1);
1245     type = qcow2_get_subcluster_type(bs, l2_entry, l2_bitmap, sc_index);
1247     if (!keep_old) {
1248         switch (type) {
1249         case QCOW2_SUBCLUSTER_COMPRESSED:
1250             cow_end_to = ROUND_UP(cow_end_from, s->cluster_size);
1251             break;
1252         case QCOW2_SUBCLUSTER_NORMAL:
1253         case QCOW2_SUBCLUSTER_ZERO_ALLOC:
1254         case QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC:
1255             cow_end_to = ROUND_UP(cow_end_from, s->cluster_size);
1256             if (has_subclusters(s)) {
1257                 /* Skip all trailing zero and unallocated subclusters */
1258                 uint32_t alloc_bitmap = l2_bitmap & QCOW_L2_BITMAP_ALL_ALLOC;
1259                 cow_end_to -=
1260                     MIN(s->subclusters_per_cluster - sc_index - 1,
1261                         clz32(alloc_bitmap)) << s->subcluster_bits;
1262             }
1263             break;
1264         case QCOW2_SUBCLUSTER_ZERO_PLAIN:
1265         case QCOW2_SUBCLUSTER_UNALLOCATED_PLAIN:
1266             cow_end_to = ROUND_UP(cow_end_from, s->subcluster_size);
1267             break;
1268         default:
1269             g_assert_not_reached();
1270         }
1271     } else {
1272         switch (type) {
1273         case QCOW2_SUBCLUSTER_NORMAL:
1274             cow_end_to = cow_end_from;
1275             break;
1276         case QCOW2_SUBCLUSTER_ZERO_ALLOC:
1277         case QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC:
1278             cow_end_to = ROUND_UP(cow_end_from, s->subcluster_size);
1279             break;
1280         default:
1281             g_assert_not_reached();
1282         }
1283     }
1285     *m = g_malloc0(sizeof(**m));
1286     **m = (QCowL2Meta) {
1287         .next           = old_m,
1289         .alloc_offset   = host_cluster_offset,
1290         .offset         = start_of_cluster(s, guest_offset),
1291         .nb_clusters    = nb_clusters,
1293         .keep_old_clusters = keep_old,
1295         .cow_start = {
1296             .offset     = cow_start_from,
1297             .nb_bytes   = cow_start_to - cow_start_from,
1298         },
1299         .cow_end = {
1300             .offset     = cow_end_from,
1301             .nb_bytes   = cow_end_to - cow_end_from,
1302         },
1303     };
1305     qemu_co_queue_init(&(*m)->dependent_requests);
1306     QLIST_INSERT_HEAD(&s->cluster_allocs, *m, next_in_flight);
1308     return 0;
1312  * Returns true if writing to the cluster pointed to by @l2_entry
1313  * requires a new allocation (that is, if the cluster is unallocated
1314  * or has refcount > 1 and therefore cannot be written in-place).
1315  */
1316 static bool cluster_needs_new_alloc(BlockDriverState *bs, uint64_t l2_entry)
1318     switch (qcow2_get_cluster_type(bs, l2_entry)) {
1319     case QCOW2_CLUSTER_NORMAL:
1320     case QCOW2_CLUSTER_ZERO_ALLOC:
1321         if (l2_entry & QCOW_OFLAG_COPIED) {
1322             return false;
1323         }
1324         /* fallthrough */
1325     case QCOW2_CLUSTER_UNALLOCATED:
1326     case QCOW2_CLUSTER_COMPRESSED:
1327     case QCOW2_CLUSTER_ZERO_PLAIN:
1328         return true;
1329     default:
1330         abort();
1331     }
1335  * Returns the number of contiguous clusters that can be written to
1336  * using one single write request, starting from @l2_index.
1337  * At most @nb_clusters are checked.
1339  * If @new_alloc is true this counts clusters that are either
1340  * unallocated, or allocated but with refcount > 1 (so they need to be
1341  * newly allocated and COWed).
1343  * If @new_alloc is false this counts clusters that are already
1344  * allocated and can be overwritten in-place (this includes clusters
1345  * of type QCOW2_CLUSTER_ZERO_ALLOC).
1346  */
1347 static int count_single_write_clusters(BlockDriverState *bs, int nb_clusters,
1348                                        uint64_t *l2_slice, int l2_index,
1349                                        bool new_alloc)
1351     BDRVQcow2State *s = bs->opaque;
1352     uint64_t l2_entry = get_l2_entry(s, l2_slice, l2_index);
1353     uint64_t expected_offset = l2_entry & L2E_OFFSET_MASK;
1354     int i;
1356     for (i = 0; i < nb_clusters; i++) {
1357         l2_entry = get_l2_entry(s, l2_slice, l2_index + i);
1358         if (cluster_needs_new_alloc(bs, l2_entry) != new_alloc) {
1359             break;
1360         }
1361         if (!new_alloc) {
1362             if (expected_offset != (l2_entry & L2E_OFFSET_MASK)) {
1363                 break;
1364             }
1365             expected_offset += s->cluster_size;
1366         }
1367     }
1369     assert(i <= nb_clusters);
1370     return i;
1374  * Check if there already is an AIO write request in flight which allocates
1375  * the same cluster. In this case we need to wait until the previous
1376  * request has completed and updated the L2 table accordingly.
1378  * Returns:
1379  *   0       if there was no dependency. *cur_bytes indicates the number of
1380  *           bytes from guest_offset that can be read before the next
1381  *           dependency must be processed (or the request is complete)
1383  *   -EAGAIN if we had to wait for another request, previously gathered
1384  *           information on cluster allocation may be invalid now. The caller
1385  *           must start over anyway, so consider *cur_bytes undefined.
1386  */
1387 static int handle_dependencies(BlockDriverState *bs, uint64_t guest_offset,
1388     uint64_t *cur_bytes, QCowL2Meta **m)
1390     BDRVQcow2State *s = bs->opaque;
1391     QCowL2Meta *old_alloc;
1392     uint64_t bytes = *cur_bytes;
1394     QLIST_FOREACH(old_alloc, &s->cluster_allocs, next_in_flight) {
1396         uint64_t start = guest_offset;
1397         uint64_t end = start + bytes;
1398         uint64_t old_start = start_of_cluster(s, l2meta_cow_start(old_alloc));
1399         uint64_t old_end = ROUND_UP(l2meta_cow_end(old_alloc), s->cluster_size);
1401         if (end <= old_start || start >= old_end) {
1402             /* No intersection */
1403         } else {
1404             if (start < old_start) {
1405                 /* Stop at the start of a running allocation */
1406                 bytes = old_start - start;
1407             } else {
1408                 bytes = 0;
1409             }
1411             /* Stop if already an l2meta exists. After yielding, it wouldn't
1412              * be valid any more, so we'd have to clean up the old L2Metas
1413              * and deal with requests depending on them before starting to
1414              * gather new ones. Not worth the trouble. */
1415             if (bytes == 0 && *m) {
1416                 *cur_bytes = 0;
1417                 return 0;
1418             }
1420             if (bytes == 0) {
1421                 /* Wait for the dependency to complete. We need to recheck
1422                  * the free/allocated clusters when we continue. */
1423                 qemu_co_queue_wait(&old_alloc->dependent_requests, &s->lock);
1424                 return -EAGAIN;
1425             }
1426         }
1427     }
1429     /* Make sure that existing clusters and new allocations are only used up to
1430      * the next dependency if we shortened the request above */
1431     *cur_bytes = bytes;
1433     return 0;
1437  * Checks how many already allocated clusters that don't require a new
1438  * allocation there are at the given guest_offset (up to *bytes).
1439  * If *host_offset is not INV_OFFSET, only physically contiguous clusters
1440  * beginning at this host offset are counted.
1442  * Note that guest_offset may not be cluster aligned. In this case, the
1443  * returned *host_offset points to exact byte referenced by guest_offset and
1444  * therefore isn't cluster aligned as well.
1446  * Returns:
1447  *   0:     if no allocated clusters are available at the given offset.
1448  *          *bytes is normally unchanged. It is set to 0 if the cluster
1449  *          is allocated and can be overwritten in-place but doesn't have
1450  *          the right physical offset.
1452  *   1:     if allocated clusters that can be overwritten in place are
1453  *          available at the requested offset. *bytes may have decreased
1454  *          and describes the length of the area that can be written to.
1456  *  -errno: in error cases
1457  */
1458 static int handle_copied(BlockDriverState *bs, uint64_t guest_offset,
1459     uint64_t *host_offset, uint64_t *bytes, QCowL2Meta **m)
1461     BDRVQcow2State *s = bs->opaque;
1462     int l2_index;
1463     uint64_t l2_entry, cluster_offset;
1464     uint64_t *l2_slice;
1465     uint64_t nb_clusters;
1466     unsigned int keep_clusters;
1467     int ret;
1469     trace_qcow2_handle_copied(qemu_coroutine_self(), guest_offset, *host_offset,
1470                               *bytes);
1472     assert(*host_offset == INV_OFFSET || offset_into_cluster(s, guest_offset)
1473                                       == offset_into_cluster(s, *host_offset));
1475     /*
1476      * Calculate the number of clusters to look for. We stop at L2 slice
1477      * boundaries to keep things simple.
1478      */
1479     nb_clusters =
1480         size_to_clusters(s, offset_into_cluster(s, guest_offset) + *bytes);
1482     l2_index = offset_to_l2_slice_index(s, guest_offset);
1483     nb_clusters = MIN(nb_clusters, s->l2_slice_size - l2_index);
1484     /* Limit total byte count to BDRV_REQUEST_MAX_BYTES */
1485     nb_clusters = MIN(nb_clusters, BDRV_REQUEST_MAX_BYTES >> s->cluster_bits);
1487     /* Find L2 entry for the first involved cluster */
1488     ret = get_cluster_table(bs, guest_offset, &l2_slice, &l2_index);
1489     if (ret < 0) {
1490         return ret;
1491     }
1493     l2_entry = get_l2_entry(s, l2_slice, l2_index);
1494     cluster_offset = l2_entry & L2E_OFFSET_MASK;
1496     if (!cluster_needs_new_alloc(bs, l2_entry)) {
1497         if (offset_into_cluster(s, cluster_offset)) {
1498             qcow2_signal_corruption(bs, true, -1, -1, "%s cluster offset "
1499                                     "%#" PRIx64 " unaligned (guest offset: %#"
1500                                     PRIx64 ")", l2_entry & QCOW_OFLAG_ZERO ?
1501                                     "Preallocated zero" : "Data",
1502                                     cluster_offset, guest_offset);
1503             ret = -EIO;
1504             goto out;
1505         }
1507         /* If a specific host_offset is required, check it */
1508         if (*host_offset != INV_OFFSET && cluster_offset != *host_offset) {
1509             *bytes = 0;
1510             ret = 0;
1511             goto out;
1512         }
1514         /* We keep all QCOW_OFLAG_COPIED clusters */
1515         keep_clusters = count_single_write_clusters(bs, nb_clusters, l2_slice,
1516                                                     l2_index, false);
1517         assert(keep_clusters <= nb_clusters);
1519         *bytes = MIN(*bytes,
1520                  keep_clusters * s->cluster_size
1521                  - offset_into_cluster(s, guest_offset));
1522         assert(*bytes != 0);
1524         ret = calculate_l2_meta(bs, cluster_offset, guest_offset,
1525                                 *bytes, l2_slice, m, true);
1526         if (ret < 0) {
1527             goto out;
1528         }
1530         ret = 1;
1531     } else {
1532         ret = 0;
1533     }
1535     /* Cleanup */
1536 out:
1537     qcow2_cache_put(s->l2_table_cache, (void **) &l2_slice);
1539     /* Only return a host offset if we actually made progress. Otherwise we
1540      * would make requirements for handle_alloc() that it can't fulfill */
1541     if (ret > 0) {
1542         *host_offset = cluster_offset + offset_into_cluster(s, guest_offset);
1543     }
1545     return ret;
1549  * Allocates new clusters for the given guest_offset.
1551  * At most *nb_clusters are allocated, and on return *nb_clusters is updated to
1552  * contain the number of clusters that have been allocated and are contiguous
1553  * in the image file.
1555  * If *host_offset is not INV_OFFSET, it specifies the offset in the image file
1556  * at which the new clusters must start. *nb_clusters can be 0 on return in
1557  * this case if the cluster at host_offset is already in use. If *host_offset
1558  * is INV_OFFSET, the clusters can be allocated anywhere in the image file.
1560  * *host_offset is updated to contain the offset into the image file at which
1561  * the first allocated cluster starts.
1563  * Return 0 on success and -errno in error cases. -EAGAIN means that the
1564  * function has been waiting for another request and the allocation must be
1565  * restarted, but the whole request should not be failed.
1566  */
1567 static int do_alloc_cluster_offset(BlockDriverState *bs, uint64_t guest_offset,
1568                                    uint64_t *host_offset, uint64_t *nb_clusters)
1570     BDRVQcow2State *s = bs->opaque;
1572     trace_qcow2_do_alloc_clusters_offset(qemu_coroutine_self(), guest_offset,
1573                                          *host_offset, *nb_clusters);
1575     if (has_data_file(bs)) {
1576         assert(*host_offset == INV_OFFSET ||
1577                *host_offset == start_of_cluster(s, guest_offset));
1578         *host_offset = start_of_cluster(s, guest_offset);
1579         return 0;
1580     }
1582     /* Allocate new clusters */
1583     trace_qcow2_cluster_alloc_phys(qemu_coroutine_self());
1584     if (*host_offset == INV_OFFSET) {
1585         int64_t cluster_offset =
1586             qcow2_alloc_clusters(bs, *nb_clusters * s->cluster_size);
1587         if (cluster_offset < 0) {
1588             return cluster_offset;
1589         }
1590         *host_offset = cluster_offset;
1591         return 0;
1592     } else {
1593         int64_t ret = qcow2_alloc_clusters_at(bs, *host_offset, *nb_clusters);
1594         if (ret < 0) {
1595             return ret;
1596         }
1597         *nb_clusters = ret;
1598         return 0;
1599     }
1603  * Allocates new clusters for an area that is either still unallocated or
1604  * cannot be overwritten in-place. If *host_offset is not INV_OFFSET,
1605  * clusters are only allocated if the new allocation can match the specified
1606  * host offset.
1608  * Note that guest_offset may not be cluster aligned. In this case, the
1609  * returned *host_offset points to exact byte referenced by guest_offset and
1610  * therefore isn't cluster aligned as well.
1612  * Returns:
1613  *   0:     if no clusters could be allocated. *bytes is set to 0,
1614  *          *host_offset is left unchanged.
1616  *   1:     if new clusters were allocated. *bytes may be decreased if the
1617  *          new allocation doesn't cover all of the requested area.
1618  *          *host_offset is updated to contain the host offset of the first
1619  *          newly allocated cluster.
1621  *  -errno: in error cases
1622  */
1623 static int handle_alloc(BlockDriverState *bs, uint64_t guest_offset,
1624     uint64_t *host_offset, uint64_t *bytes, QCowL2Meta **m)
1626     BDRVQcow2State *s = bs->opaque;
1627     int l2_index;
1628     uint64_t *l2_slice;
1629     uint64_t nb_clusters;
1630     int ret;
1632     uint64_t alloc_cluster_offset;
1634     trace_qcow2_handle_alloc(qemu_coroutine_self(), guest_offset, *host_offset,
1635                              *bytes);
1636     assert(*bytes > 0);
1638     /*
1639      * Calculate the number of clusters to look for. We stop at L2 slice
1640      * boundaries to keep things simple.
1641      */
1642     nb_clusters =
1643         size_to_clusters(s, offset_into_cluster(s, guest_offset) + *bytes);
1645     l2_index = offset_to_l2_slice_index(s, guest_offset);
1646     nb_clusters = MIN(nb_clusters, s->l2_slice_size - l2_index);
1647     /* Limit total allocation byte count to BDRV_REQUEST_MAX_BYTES */
1648     nb_clusters = MIN(nb_clusters, BDRV_REQUEST_MAX_BYTES >> s->cluster_bits);
1650     /* Find L2 entry for the first involved cluster */
1651     ret = get_cluster_table(bs, guest_offset, &l2_slice, &l2_index);
1652     if (ret < 0) {
1653         return ret;
1654     }
1656     nb_clusters = count_single_write_clusters(bs, nb_clusters,
1657                                               l2_slice, l2_index, true);
1659     /* This function is only called when there were no non-COW clusters, so if
1660      * we can't find any unallocated or COW clusters either, something is
1661      * wrong with our code. */
1662     assert(nb_clusters > 0);
1664     /* Allocate at a given offset in the image file */
1665     alloc_cluster_offset = *host_offset == INV_OFFSET ? INV_OFFSET :
1666         start_of_cluster(s, *host_offset);
1667     ret = do_alloc_cluster_offset(bs, guest_offset, &alloc_cluster_offset,
1668                                   &nb_clusters);
1669     if (ret < 0) {
1670         goto out;
1671     }
1673     /* Can't extend contiguous allocation */
1674     if (nb_clusters == 0) {
1675         *bytes = 0;
1676         ret = 0;
1677         goto out;
1678     }
1680     assert(alloc_cluster_offset != INV_OFFSET);
1682     /*
1683      * Save info needed for meta data update.
1684      *
1685      * requested_bytes: Number of bytes from the start of the first
1686      * newly allocated cluster to the end of the (possibly shortened
1687      * before) write request.
1688      *
1689      * avail_bytes: Number of bytes from the start of the first
1690      * newly allocated to the end of the last newly allocated cluster.
1691      *
1692      * nb_bytes: The number of bytes from the start of the first
1693      * newly allocated cluster to the end of the area that the write
1694      * request actually writes to (excluding COW at the end)
1695      */
1696     uint64_t requested_bytes = *bytes + offset_into_cluster(s, guest_offset);
1697     int avail_bytes = nb_clusters << s->cluster_bits;
1698     int nb_bytes = MIN(requested_bytes, avail_bytes);
1700     *host_offset = alloc_cluster_offset + offset_into_cluster(s, guest_offset);
1701     *bytes = MIN(*bytes, nb_bytes - offset_into_cluster(s, guest_offset));
1702     assert(*bytes != 0);
1704     ret = calculate_l2_meta(bs, alloc_cluster_offset, guest_offset, *bytes,
1705                             l2_slice, m, false);
1706     if (ret < 0) {
1707         goto out;
1708     }
1710     ret = 1;
1712 out:
1713     qcow2_cache_put(s->l2_table_cache, (void **) &l2_slice);
1714     return ret;
1718  * For a given area on the virtual disk defined by @offset and @bytes,
1719  * find the corresponding area on the qcow2 image, allocating new
1720  * clusters (or subclusters) if necessary. The result can span a
1721  * combination of allocated and previously unallocated clusters.
1723  * Note that offset may not be cluster aligned. In this case, the returned
1724  * *host_offset points to exact byte referenced by offset and therefore
1725  * isn't cluster aligned as well.
1727  * On return, @host_offset is set to the beginning of the requested
1728  * area. This area is guaranteed to be contiguous on the qcow2 file
1729  * but it can be smaller than initially requested. In this case @bytes
1730  * is updated with the actual size.
1732  * If any clusters or subclusters were allocated then @m contains a
1733  * list with the information of all the affected regions. Note that
1734  * this can happen regardless of whether this function succeeds or
1735  * not. The caller is responsible for updating the L2 metadata of the
1736  * allocated clusters (on success) or freeing them (on failure), and
1737  * for clearing the contents of @m afterwards in both cases.
1739  * If the request conflicts with another write request in flight, the coroutine
1740  * is queued and will be reentered when the dependency has completed.
1742  * Return 0 on success and -errno in error cases
1743  */
1744 int qcow2_alloc_host_offset(BlockDriverState *bs, uint64_t offset,
1745                             unsigned int *bytes, uint64_t *host_offset,
1746                             QCowL2Meta **m)
1748     BDRVQcow2State *s = bs->opaque;
1749     uint64_t start, remaining;
1750     uint64_t cluster_offset;
1751     uint64_t cur_bytes;
1752     int ret;
1754     trace_qcow2_alloc_clusters_offset(qemu_coroutine_self(), offset, *bytes);
1756 again:
1757     start = offset;
1758     remaining = *bytes;
1759     cluster_offset = INV_OFFSET;
1760     *host_offset = INV_OFFSET;
1761     cur_bytes = 0;
1762     *m = NULL;
1764     while (true) {
1766         if (*host_offset == INV_OFFSET && cluster_offset != INV_OFFSET) {
1767             *host_offset = cluster_offset;
1768         }
1770         assert(remaining >= cur_bytes);
1772         start           += cur_bytes;
1773         remaining       -= cur_bytes;
1775         if (cluster_offset != INV_OFFSET) {
1776             cluster_offset += cur_bytes;
1777         }
1779         if (remaining == 0) {
1780             break;
1781         }
1783         cur_bytes = remaining;
1785         /*
1786          * Now start gathering as many contiguous clusters as possible:
1787          *
1788          * 1. Check for overlaps with in-flight allocations
1789          *
1790          *      a) Overlap not in the first cluster -> shorten this request and
1791          *         let the caller handle the rest in its next loop iteration.
1792          *
1793          *      b) Real overlaps of two requests. Yield and restart the search
1794          *         for contiguous clusters (the situation could have changed
1795          *         while we were sleeping)
1796          *
1797          *      c) TODO: Request starts in the same cluster as the in-flight
1798          *         allocation ends. Shorten the COW of the in-fight allocation,
1799          *         set cluster_offset to write to the same cluster and set up
1800          *         the right synchronisation between the in-flight request and
1801          *         the new one.
1802          */
1803         ret = handle_dependencies(bs, start, &cur_bytes, m);
1804         if (ret == -EAGAIN) {
1805             /* Currently handle_dependencies() doesn't yield if we already had
1806              * an allocation. If it did, we would have to clean up the L2Meta
1807              * structs before starting over. */
1808             assert(*m == NULL);
1809             goto again;
1810         } else if (ret < 0) {
1811             return ret;
1812         } else if (cur_bytes == 0) {
1813             break;
1814         } else {
1815             /* handle_dependencies() may have decreased cur_bytes (shortened
1816              * the allocations below) so that the next dependency is processed
1817              * correctly during the next loop iteration. */
1818         }
1820         /*
1821          * 2. Count contiguous COPIED clusters.
1822          */
1823         ret = handle_copied(bs, start, &cluster_offset, &cur_bytes, m);
1824         if (ret < 0) {
1825             return ret;
1826         } else if (ret) {
1827             continue;
1828         } else if (cur_bytes == 0) {
1829             break;
1830         }
1832         /*
1833          * 3. If the request still hasn't completed, allocate new clusters,
1834          *    considering any cluster_offset of steps 1c or 2.
1835          */
1836         ret = handle_alloc(bs, start, &cluster_offset, &cur_bytes, m);
1837         if (ret < 0) {
1838             return ret;
1839         } else if (ret) {
1840             continue;
1841         } else {
1842             assert(cur_bytes == 0);
1843             break;
1844         }
1845     }
1847     *bytes -= remaining;
1848     assert(*bytes > 0);
1849     assert(*host_offset != INV_OFFSET);
1850     assert(offset_into_cluster(s, *host_offset) ==
1851            offset_into_cluster(s, offset));
1853     return 0;
1857  * This discards as many clusters of nb_clusters as possible at once (i.e.
1858  * all clusters in the same L2 slice) and returns the number of discarded
1859  * clusters.
1860  */
1861 static int discard_in_l2_slice(BlockDriverState *bs, uint64_t offset,
1862                                uint64_t nb_clusters,
1863                                enum qcow2_discard_type type, bool full_discard)
1865     BDRVQcow2State *s = bs->opaque;
1866     uint64_t *l2_slice;
1867     int l2_index;
1868     int ret;
1869     int i;
1871     ret = get_cluster_table(bs, offset, &l2_slice, &l2_index);
1872     if (ret < 0) {
1873         return ret;
1874     }
1876     /* Limit nb_clusters to one L2 slice */
1877     nb_clusters = MIN(nb_clusters, s->l2_slice_size - l2_index);
1878     assert(nb_clusters <= INT_MAX);
1880     for (i = 0; i < nb_clusters; i++) {
1881         uint64_t old_l2_entry = get_l2_entry(s, l2_slice, l2_index + i);
1882         uint64_t old_l2_bitmap = get_l2_bitmap(s, l2_slice, l2_index + i);
1883         uint64_t new_l2_entry = old_l2_entry;
1884         uint64_t new_l2_bitmap = old_l2_bitmap;
1885         QCow2ClusterType cluster_type =
1886             qcow2_get_cluster_type(bs, old_l2_entry);
1888         /*
1889          * If full_discard is true, the cluster should not read back as zeroes,
1890          * but rather fall through to the backing file.
1891          *
1892          * If full_discard is false, make sure that a discarded area reads back
1893          * as zeroes for v3 images (we cannot do it for v2 without actually
1894          * writing a zero-filled buffer). We can skip the operation if the
1895          * cluster is already marked as zero, or if it's unallocated and we
1896          * don't have a backing file.
1897          *
1898          * TODO We might want to use bdrv_block_status(bs) here, but we're
1899          * holding s->lock, so that doesn't work today.
1900          */
1901         if (full_discard) {
1902             new_l2_entry = new_l2_bitmap = 0;
1903         } else if (bs->backing || qcow2_cluster_is_allocated(cluster_type)) {
1904             if (has_subclusters(s)) {
1905                 new_l2_entry = 0;
1906                 new_l2_bitmap = QCOW_L2_BITMAP_ALL_ZEROES;
1907             } else {
1908                 new_l2_entry = s->qcow_version >= 3 ? QCOW_OFLAG_ZERO : 0;
1909             }
1910         }
1912         if (old_l2_entry == new_l2_entry && old_l2_bitmap == new_l2_bitmap) {
1913             continue;
1914         }
1916         /* First remove L2 entries */
1917         qcow2_cache_entry_mark_dirty(s->l2_table_cache, l2_slice);
1918         set_l2_entry(s, l2_slice, l2_index + i, new_l2_entry);
1919         if (has_subclusters(s)) {
1920             set_l2_bitmap(s, l2_slice, l2_index + i, new_l2_bitmap);
1921         }
1922         /* Then decrease the refcount */
1923         qcow2_free_any_cluster(bs, old_l2_entry, type);
1924     }
1926     qcow2_cache_put(s->l2_table_cache, (void **) &l2_slice);
1928     return nb_clusters;
1931 int qcow2_cluster_discard(BlockDriverState *bs, uint64_t offset,
1932                           uint64_t bytes, enum qcow2_discard_type type,
1933                           bool full_discard)
1935     BDRVQcow2State *s = bs->opaque;
1936     uint64_t end_offset = offset + bytes;
1937     uint64_t nb_clusters;
1938     int64_t cleared;
1939     int ret;
1941     /* Caller must pass aligned values, except at image end */
1942     assert(QEMU_IS_ALIGNED(offset, s->cluster_size));
1943     assert(QEMU_IS_ALIGNED(end_offset, s->cluster_size) ||
1944            end_offset == bs->total_sectors << BDRV_SECTOR_BITS);
1946     nb_clusters = size_to_clusters(s, bytes);
1948     s->cache_discards = true;
1950     /* Each L2 slice is handled by its own loop iteration */
1951     while (nb_clusters > 0) {
1952         cleared = discard_in_l2_slice(bs, offset, nb_clusters, type,
1953                                       full_discard);
1954         if (cleared < 0) {
1955             ret = cleared;
1956             goto fail;
1957         }
1959         nb_clusters -= cleared;
1960         offset += (cleared * s->cluster_size);
1961     }
1963     ret = 0;
1964 fail:
1965     s->cache_discards = false;
1966     qcow2_process_discards(bs, ret);
1968     return ret;
1972  * This zeroes as many clusters of nb_clusters as possible at once (i.e.
1973  * all clusters in the same L2 slice) and returns the number of zeroed
1974  * clusters.
1975  */
1976 static int zero_in_l2_slice(BlockDriverState *bs, uint64_t offset,
1977                             uint64_t nb_clusters, int flags)
1979     BDRVQcow2State *s = bs->opaque;
1980     uint64_t *l2_slice;
1981     int l2_index;
1982     int ret;
1983     int i;
1985     ret = get_cluster_table(bs, offset, &l2_slice, &l2_index);
1986     if (ret < 0) {
1987         return ret;
1988     }
1990     /* Limit nb_clusters to one L2 slice */
1991     nb_clusters = MIN(nb_clusters, s->l2_slice_size - l2_index);
1992     assert(nb_clusters <= INT_MAX);
1994     for (i = 0; i < nb_clusters; i++) {
1995         uint64_t old_l2_entry = get_l2_entry(s, l2_slice, l2_index + i);
1996         uint64_t old_l2_bitmap = get_l2_bitmap(s, l2_slice, l2_index + i);
1997         QCow2ClusterType type = qcow2_get_cluster_type(bs, old_l2_entry);
1998         bool unmap = (type == QCOW2_CLUSTER_COMPRESSED) ||
1999             ((flags & BDRV_REQ_MAY_UNMAP) && qcow2_cluster_is_allocated(type));
2000         uint64_t new_l2_entry = unmap ? 0 : old_l2_entry;
2001         uint64_t new_l2_bitmap = old_l2_bitmap;
2003         if (has_subclusters(s)) {
2004             new_l2_bitmap = QCOW_L2_BITMAP_ALL_ZEROES;
2005         } else {
2006             new_l2_entry |= QCOW_OFLAG_ZERO;
2007         }
2009         if (old_l2_entry == new_l2_entry && old_l2_bitmap == new_l2_bitmap) {
2010             continue;
2011         }
2013         /* First update L2 entries */
2014         qcow2_cache_entry_mark_dirty(s->l2_table_cache, l2_slice);
2015         set_l2_entry(s, l2_slice, l2_index + i, new_l2_entry);
2016         if (has_subclusters(s)) {
2017             set_l2_bitmap(s, l2_slice, l2_index + i, new_l2_bitmap);
2018         }
2020         /* Then decrease the refcount */
2021         if (unmap) {
2022             qcow2_free_any_cluster(bs, old_l2_entry, QCOW2_DISCARD_REQUEST);
2023         }
2024     }
2026     qcow2_cache_put(s->l2_table_cache, (void **) &l2_slice);
2028     return nb_clusters;
2031 static int zero_l2_subclusters(BlockDriverState *bs, uint64_t offset,
2032                                unsigned nb_subclusters)
2034     BDRVQcow2State *s = bs->opaque;
2035     uint64_t *l2_slice;
2036     uint64_t old_l2_bitmap, l2_bitmap;
2037     int l2_index, ret, sc = offset_to_sc_index(s, offset);
2039     /* For full clusters use zero_in_l2_slice() instead */
2040     assert(nb_subclusters > 0 && nb_subclusters < s->subclusters_per_cluster);
2041     assert(sc + nb_subclusters <= s->subclusters_per_cluster);
2042     assert(offset_into_subcluster(s, offset) == 0);
2044     ret = get_cluster_table(bs, offset, &l2_slice, &l2_index);
2045     if (ret < 0) {
2046         return ret;
2047     }
2049     switch (qcow2_get_cluster_type(bs, get_l2_entry(s, l2_slice, l2_index))) {
2050     case QCOW2_CLUSTER_COMPRESSED:
2051         ret = -ENOTSUP; /* We cannot partially zeroize compressed clusters */
2052         goto out;
2053     case QCOW2_CLUSTER_NORMAL:
2054     case QCOW2_CLUSTER_UNALLOCATED:
2055         break;
2056     default:
2057         g_assert_not_reached();
2058     }
2060     old_l2_bitmap = l2_bitmap = get_l2_bitmap(s, l2_slice, l2_index);
2062     l2_bitmap |=  QCOW_OFLAG_SUB_ZERO_RANGE(sc, sc + nb_subclusters);
2063     l2_bitmap &= ~QCOW_OFLAG_SUB_ALLOC_RANGE(sc, sc + nb_subclusters);
2065     if (old_l2_bitmap != l2_bitmap) {
2066         set_l2_bitmap(s, l2_slice, l2_index, l2_bitmap);
2067         qcow2_cache_entry_mark_dirty(s->l2_table_cache, l2_slice);
2068     }
2070     ret = 0;
2071 out:
2072     qcow2_cache_put(s->l2_table_cache, (void **) &l2_slice);
2074     return ret;
2077 int qcow2_subcluster_zeroize(BlockDriverState *bs, uint64_t offset,
2078                              uint64_t bytes, int flags)
2080     BDRVQcow2State *s = bs->opaque;
2081     uint64_t end_offset = offset + bytes;
2082     uint64_t nb_clusters;
2083     unsigned head, tail;
2084     int64_t cleared;
2085     int ret;
2087     /* If we have to stay in sync with an external data file, zero out
2088      * s->data_file first. */
2089     if (data_file_is_raw(bs)) {
2090         assert(has_data_file(bs));
2091         ret = bdrv_co_pwrite_zeroes(s->data_file, offset, bytes, flags);
2092         if (ret < 0) {
2093             return ret;
2094         }
2095     }
2097     /* Caller must pass aligned values, except at image end */
2098     assert(offset_into_subcluster(s, offset) == 0);
2099     assert(offset_into_subcluster(s, end_offset) == 0 ||
2100            end_offset >= bs->total_sectors << BDRV_SECTOR_BITS);
2102     /*
2103      * The zero flag is only supported by version 3 and newer. However, if we
2104      * have no backing file, we can resort to discard in version 2.
2105      */
2106     if (s->qcow_version < 3) {
2107         if (!bs->backing) {
2108             return qcow2_cluster_discard(bs, offset, bytes,
2109                                          QCOW2_DISCARD_REQUEST, false);
2110         }
2111         return -ENOTSUP;
2112     }
2114     head = MIN(end_offset, ROUND_UP(offset, s->cluster_size)) - offset;
2115     offset += head;
2117     tail = (end_offset >= bs->total_sectors << BDRV_SECTOR_BITS) ? 0 :
2118         end_offset - MAX(offset, start_of_cluster(s, end_offset));
2119     end_offset -= tail;
2121     s->cache_discards = true;
2123     if (head) {
2124         ret = zero_l2_subclusters(bs, offset - head,
2125                                   size_to_subclusters(s, head));
2126         if (ret < 0) {
2127             goto fail;
2128         }
2129     }
2131     /* Each L2 slice is handled by its own loop iteration */
2132     nb_clusters = size_to_clusters(s, end_offset - offset);
2134     while (nb_clusters > 0) {
2135         cleared = zero_in_l2_slice(bs, offset, nb_clusters, flags);
2136         if (cleared < 0) {
2137             ret = cleared;
2138             goto fail;
2139         }
2141         nb_clusters -= cleared;
2142         offset += (cleared * s->cluster_size);
2143     }
2145     if (tail) {
2146         ret = zero_l2_subclusters(bs, end_offset, size_to_subclusters(s, tail));
2147         if (ret < 0) {
2148             goto fail;
2149         }
2150     }
2152     ret = 0;
2153 fail:
2154     s->cache_discards = false;
2155     qcow2_process_discards(bs, ret);
2157     return ret;
2161  * Expands all zero clusters in a specific L1 table (or deallocates them, for
2162  * non-backed non-pre-allocated zero clusters).
2164  * l1_entries and *visited_l1_entries are used to keep track of progress for
2165  * status_cb(). l1_entries contains the total number of L1 entries and
2166  * *visited_l1_entries counts all visited L1 entries.
2167  */
2168 static int expand_zero_clusters_in_l1(BlockDriverState *bs, uint64_t *l1_table,
2169                                       int l1_size, int64_t *visited_l1_entries,
2170                                       int64_t l1_entries,
2171                                       BlockDriverAmendStatusCB *status_cb,
2172                                       void *cb_opaque)
2174     BDRVQcow2State *s = bs->opaque;
2175     bool is_active_l1 = (l1_table == s->l1_table);
2176     uint64_t *l2_slice = NULL;
2177     unsigned slice, slice_size2, n_slices;
2178     int ret;
2179     int i, j;
2181     /* qcow2_downgrade() is not allowed in images with subclusters */
2182     assert(!has_subclusters(s));
2184     slice_size2 = s->l2_slice_size * l2_entry_size(s);
2185     n_slices = s->cluster_size / slice_size2;
2187     if (!is_active_l1) {
2188         /* inactive L2 tables require a buffer to be stored in when loading
2189          * them from disk */
2190         l2_slice = qemu_try_blockalign(bs->file->bs, slice_size2);
2191         if (l2_slice == NULL) {
2192             return -ENOMEM;
2193         }
2194     }
2196     for (i = 0; i < l1_size; i++) {
2197         uint64_t l2_offset = l1_table[i] & L1E_OFFSET_MASK;
2198         uint64_t l2_refcount;
2200         if (!l2_offset) {
2201             /* unallocated */
2202             (*visited_l1_entries)++;
2203             if (status_cb) {
2204                 status_cb(bs, *visited_l1_entries, l1_entries, cb_opaque);
2205             }
2206             continue;
2207         }
2209         if (offset_into_cluster(s, l2_offset)) {
2210             qcow2_signal_corruption(bs, true, -1, -1, "L2 table offset %#"
2211                                     PRIx64 " unaligned (L1 index: %#x)",
2212                                     l2_offset, i);
2213             ret = -EIO;
2214             goto fail;
2215         }
2217         ret = qcow2_get_refcount(bs, l2_offset >> s->cluster_bits,
2218                                  &l2_refcount);
2219         if (ret < 0) {
2220             goto fail;
2221         }
2223         for (slice = 0; slice < n_slices; slice++) {
2224             uint64_t slice_offset = l2_offset + slice * slice_size2;
2225             bool l2_dirty = false;
2226             if (is_active_l1) {
2227                 /* get active L2 tables from cache */
2228                 ret = qcow2_cache_get(bs, s->l2_table_cache, slice_offset,
2229                                       (void **)&l2_slice);
2230             } else {
2231                 /* load inactive L2 tables from disk */
2232                 ret = bdrv_pread(bs->file, slice_offset, l2_slice, slice_size2);
2233             }
2234             if (ret < 0) {
2235                 goto fail;
2236             }
2238             for (j = 0; j < s->l2_slice_size; j++) {
2239                 uint64_t l2_entry = get_l2_entry(s, l2_slice, j);
2240                 int64_t offset = l2_entry & L2E_OFFSET_MASK;
2241                 QCow2ClusterType cluster_type =
2242                     qcow2_get_cluster_type(bs, l2_entry);
2244                 if (cluster_type != QCOW2_CLUSTER_ZERO_PLAIN &&
2245                     cluster_type != QCOW2_CLUSTER_ZERO_ALLOC) {
2246                     continue;
2247                 }
2249                 if (cluster_type == QCOW2_CLUSTER_ZERO_PLAIN) {
2250                     if (!bs->backing) {
2251                         /*
2252                          * not backed; therefore we can simply deallocate the
2253                          * cluster. No need to call set_l2_bitmap(), this
2254                          * function doesn't support images with subclusters.
2255                          */
2256                         set_l2_entry(s, l2_slice, j, 0);
2257                         l2_dirty = true;
2258                         continue;
2259                     }
2261                     offset = qcow2_alloc_clusters(bs, s->cluster_size);
2262                     if (offset < 0) {
2263                         ret = offset;
2264                         goto fail;
2265                     }
2267                     /* The offset must fit in the offset field */
2268                     assert((offset & L2E_OFFSET_MASK) == offset);
2270                     if (l2_refcount > 1) {
2271                         /* For shared L2 tables, set the refcount accordingly
2272                          * (it is already 1 and needs to be l2_refcount) */
2273                         ret = qcow2_update_cluster_refcount(
2274                             bs, offset >> s->cluster_bits,
2275                             refcount_diff(1, l2_refcount), false,
2276                             QCOW2_DISCARD_OTHER);
2277                         if (ret < 0) {
2278                             qcow2_free_clusters(bs, offset, s->cluster_size,
2279                                                 QCOW2_DISCARD_OTHER);
2280                             goto fail;
2281                         }
2282                     }
2283                 }
2285                 if (offset_into_cluster(s, offset)) {
2286                     int l2_index = slice * s->l2_slice_size + j;
2287                     qcow2_signal_corruption(
2288                         bs, true, -1, -1,
2289                         "Cluster allocation offset "
2290                         "%#" PRIx64 " unaligned (L2 offset: %#"
2291                         PRIx64 ", L2 index: %#x)", offset,
2292                         l2_offset, l2_index);
2293                     if (cluster_type == QCOW2_CLUSTER_ZERO_PLAIN) {
2294                         qcow2_free_clusters(bs, offset, s->cluster_size,
2295                                             QCOW2_DISCARD_ALWAYS);
2296                     }
2297                     ret = -EIO;
2298                     goto fail;
2299                 }
2301                 ret = qcow2_pre_write_overlap_check(bs, 0, offset,
2302                                                     s->cluster_size, true);
2303                 if (ret < 0) {
2304                     if (cluster_type == QCOW2_CLUSTER_ZERO_PLAIN) {
2305                         qcow2_free_clusters(bs, offset, s->cluster_size,
2306                                             QCOW2_DISCARD_ALWAYS);
2307                     }
2308                     goto fail;
2309                 }
2311                 ret = bdrv_pwrite_zeroes(s->data_file, offset,
2312                                          s->cluster_size, 0);
2313                 if (ret < 0) {
2314                     if (cluster_type == QCOW2_CLUSTER_ZERO_PLAIN) {
2315                         qcow2_free_clusters(bs, offset, s->cluster_size,
2316                                             QCOW2_DISCARD_ALWAYS);
2317                     }
2318                     goto fail;
2319                 }
2321                 if (l2_refcount == 1) {
2322                     set_l2_entry(s, l2_slice, j, offset | QCOW_OFLAG_COPIED);
2323                 } else {
2324                     set_l2_entry(s, l2_slice, j, offset);
2325                 }
2326                 /*
2327                  * No need to call set_l2_bitmap() after set_l2_entry() because
2328                  * this function doesn't support images with subclusters.
2329                  */
2330                 l2_dirty = true;
2331             }
2333             if (is_active_l1) {
2334                 if (l2_dirty) {
2335                     qcow2_cache_entry_mark_dirty(s->l2_table_cache, l2_slice);
2336                     qcow2_cache_depends_on_flush(s->l2_table_cache);
2337                 }
2338                 qcow2_cache_put(s->l2_table_cache, (void **) &l2_slice);
2339             } else {
2340                 if (l2_dirty) {
2341                     ret = qcow2_pre_write_overlap_check(
2342                         bs, QCOW2_OL_INACTIVE_L2 | QCOW2_OL_ACTIVE_L2,
2343                         slice_offset, slice_size2, false);
2344                     if (ret < 0) {
2345                         goto fail;
2346                     }
2348                     ret = bdrv_pwrite(bs->file, slice_offset,
2349                                       l2_slice, slice_size2);
2350                     if (ret < 0) {
2351                         goto fail;
2352                     }
2353                 }
2354             }
2355         }
2357         (*visited_l1_entries)++;
2358         if (status_cb) {
2359             status_cb(bs, *visited_l1_entries, l1_entries, cb_opaque);
2360         }
2361     }
2363     ret = 0;
2365 fail:
2366     if (l2_slice) {
2367         if (!is_active_l1) {
2368             qemu_vfree(l2_slice);
2369         } else {
2370             qcow2_cache_put(s->l2_table_cache, (void **) &l2_slice);
2371         }
2372     }
2373     return ret;
2377  * For backed images, expands all zero clusters on the image. For non-backed
2378  * images, deallocates all non-pre-allocated zero clusters (and claims the
2379  * allocation for pre-allocated ones). This is important for downgrading to a
2380  * qcow2 version which doesn't yet support metadata zero clusters.
2381  */
2382 int qcow2_expand_zero_clusters(BlockDriverState *bs,
2383                                BlockDriverAmendStatusCB *status_cb,
2384                                void *cb_opaque)
2386     BDRVQcow2State *s = bs->opaque;
2387     uint64_t *l1_table = NULL;
2388     int64_t l1_entries = 0, visited_l1_entries = 0;
2389     int ret;
2390     int i, j;
2392     if (status_cb) {
2393         l1_entries = s->l1_size;
2394         for (i = 0; i < s->nb_snapshots; i++) {
2395             l1_entries += s->snapshots[i].l1_size;
2396         }
2397     }
2399     ret = expand_zero_clusters_in_l1(bs, s->l1_table, s->l1_size,
2400                                      &visited_l1_entries, l1_entries,
2401                                      status_cb, cb_opaque);
2402     if (ret < 0) {
2403         goto fail;
2404     }
2406     /* Inactive L1 tables may point to active L2 tables - therefore it is
2407      * necessary to flush the L2 table cache before trying to access the L2
2408      * tables pointed to by inactive L1 entries (else we might try to expand
2409      * zero clusters that have already been expanded); furthermore, it is also
2410      * necessary to empty the L2 table cache, since it may contain tables which
2411      * are now going to be modified directly on disk, bypassing the cache.
2412      * qcow2_cache_empty() does both for us. */
2413     ret = qcow2_cache_empty(bs, s->l2_table_cache);
2414     if (ret < 0) {
2415         goto fail;
2416     }
2418     for (i = 0; i < s->nb_snapshots; i++) {
2419         int l1_size2;
2420         uint64_t *new_l1_table;
2421         Error *local_err = NULL;
2423         ret = qcow2_validate_table(bs, s->snapshots[i].l1_table_offset,
2424                                    s->snapshots[i].l1_size, L1E_SIZE,
2425                                    QCOW_MAX_L1_SIZE, "Snapshot L1 table",
2426                                    &local_err);
2427         if (ret < 0) {
2428             error_report_err(local_err);
2429             goto fail;
2430         }
2432         l1_size2 = s->snapshots[i].l1_size * L1E_SIZE;
2433         new_l1_table = g_try_realloc(l1_table, l1_size2);
2435         if (!new_l1_table) {
2436             ret = -ENOMEM;
2437             goto fail;
2438         }
2440         l1_table = new_l1_table;
2442         ret = bdrv_pread(bs->file, s->snapshots[i].l1_table_offset,
2443                          l1_table, l1_size2);
2444         if (ret < 0) {
2445             goto fail;
2446         }
2448         for (j = 0; j < s->snapshots[i].l1_size; j++) {
2449             be64_to_cpus(&l1_table[j]);
2450         }
2452         ret = expand_zero_clusters_in_l1(bs, l1_table, s->snapshots[i].l1_size,
2453                                          &visited_l1_entries, l1_entries,
2454                                          status_cb, cb_opaque);
2455         if (ret < 0) {
2456             goto fail;
2457         }
2458     }
2460     ret = 0;
2462 fail:
2463     g_free(l1_table);
2464     return ret;