1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25#include "qemu/osdep.h"
26#include <zlib.h>
27
28#include "qapi/error.h"
29#include "qemu-common.h"
30#include "block/block_int.h"
31#include "block/qcow2.h"
32#include "qemu/bswap.h"
33#include "trace.h"
34
35int qcow2_grow_l1_table(BlockDriverState *bs, uint64_t min_size,
36 bool exact_size)
37{
38 BDRVQcow2State *s = bs->opaque;
39 int new_l1_size2, ret, i;
40 uint64_t *new_l1_table;
41 int64_t old_l1_table_offset, old_l1_size;
42 int64_t new_l1_table_offset, new_l1_size;
43 uint8_t data[12];
44
45 if (min_size <= s->l1_size)
46 return 0;
47
48
49
50
51 if (min_size > INT_MAX / sizeof(uint64_t)) {
52 return -EFBIG;
53 }
54
55 if (exact_size) {
56 new_l1_size = min_size;
57 } else {
58
59 new_l1_size = s->l1_size;
60 if (new_l1_size == 0) {
61 new_l1_size = 1;
62 }
63 while (min_size > new_l1_size) {
64 new_l1_size = (new_l1_size * 3 + 1) / 2;
65 }
66 }
67
68 QEMU_BUILD_BUG_ON(QCOW_MAX_L1_SIZE > INT_MAX);
69 if (new_l1_size > QCOW_MAX_L1_SIZE / sizeof(uint64_t)) {
70 return -EFBIG;
71 }
72
73#ifdef DEBUG_ALLOC2
74 fprintf(stderr, "grow l1_table from %d to %" PRId64 "\n",
75 s->l1_size, new_l1_size);
76#endif
77
78 new_l1_size2 = sizeof(uint64_t) * new_l1_size;
79 new_l1_table = qemu_try_blockalign(bs->file->bs,
80 align_offset(new_l1_size2, 512));
81 if (new_l1_table == NULL) {
82 return -ENOMEM;
83 }
84 memset(new_l1_table, 0, align_offset(new_l1_size2, 512));
85
86 if (s->l1_size) {
87 memcpy(new_l1_table, s->l1_table, s->l1_size * sizeof(uint64_t));
88 }
89
90
91 BLKDBG_EVENT(bs->file, BLKDBG_L1_GROW_ALLOC_TABLE);
92 new_l1_table_offset = qcow2_alloc_clusters(bs, new_l1_size2);
93 if (new_l1_table_offset < 0) {
94 qemu_vfree(new_l1_table);
95 return new_l1_table_offset;
96 }
97
98 ret = qcow2_cache_flush(bs, s->refcount_block_cache);
99 if (ret < 0) {
100 goto fail;
101 }
102
103
104
105 ret = qcow2_pre_write_overlap_check(bs, 0, new_l1_table_offset,
106 new_l1_size2);
107 if (ret < 0) {
108 goto fail;
109 }
110
111 BLKDBG_EVENT(bs->file, BLKDBG_L1_GROW_WRITE_TABLE);
112 for(i = 0; i < s->l1_size; i++)
113 new_l1_table[i] = cpu_to_be64(new_l1_table[i]);
114 ret = bdrv_pwrite_sync(bs->file, new_l1_table_offset,
115 new_l1_table, new_l1_size2);
116 if (ret < 0)
117 goto fail;
118 for(i = 0; i < s->l1_size; i++)
119 new_l1_table[i] = be64_to_cpu(new_l1_table[i]);
120
121
122 BLKDBG_EVENT(bs->file, BLKDBG_L1_GROW_ACTIVATE_TABLE);
123 stl_be_p(data, new_l1_size);
124 stq_be_p(data + 4, new_l1_table_offset);
125 ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, l1_size),
126 data, sizeof(data));
127 if (ret < 0) {
128 goto fail;
129 }
130 qemu_vfree(s->l1_table);
131 old_l1_table_offset = s->l1_table_offset;
132 s->l1_table_offset = new_l1_table_offset;
133 s->l1_table = new_l1_table;
134 old_l1_size = s->l1_size;
135 s->l1_size = new_l1_size;
136 qcow2_free_clusters(bs, old_l1_table_offset, old_l1_size * sizeof(uint64_t),
137 QCOW2_DISCARD_OTHER);
138 return 0;
139 fail:
140 qemu_vfree(new_l1_table);
141 qcow2_free_clusters(bs, new_l1_table_offset, new_l1_size2,
142 QCOW2_DISCARD_OTHER);
143 return ret;
144}
145
146
147
148
149
150
151
152
153
154
155
156static int l2_load(BlockDriverState *bs, uint64_t l2_offset,
157 uint64_t **l2_table)
158{
159 BDRVQcow2State *s = bs->opaque;
160
161 return qcow2_cache_get(bs, s->l2_table_cache, l2_offset,
162 (void **)l2_table);
163}
164
165
166
167
168
169#define L1_ENTRIES_PER_SECTOR (512 / 8)
170int qcow2_write_l1_entry(BlockDriverState *bs, int l1_index)
171{
172 BDRVQcow2State *s = bs->opaque;
173 uint64_t buf[L1_ENTRIES_PER_SECTOR] = { 0 };
174 int l1_start_index;
175 int i, ret;
176
177 l1_start_index = l1_index & ~(L1_ENTRIES_PER_SECTOR - 1);
178 for (i = 0; i < L1_ENTRIES_PER_SECTOR && l1_start_index + i < s->l1_size;
179 i++)
180 {
181 buf[i] = cpu_to_be64(s->l1_table[l1_start_index + i]);
182 }
183
184 ret = qcow2_pre_write_overlap_check(bs, QCOW2_OL_ACTIVE_L1,
185 s->l1_table_offset + 8 * l1_start_index, sizeof(buf));
186 if (ret < 0) {
187 return ret;
188 }
189
190 BLKDBG_EVENT(bs->file, BLKDBG_L1_UPDATE);
191 ret = bdrv_pwrite_sync(bs->file,
192 s->l1_table_offset + 8 * l1_start_index,
193 buf, sizeof(buf));
194 if (ret < 0) {
195 return ret;
196 }
197
198 return 0;
199}
200
201
202
203
204
205
206
207
208
209
210
211static int l2_allocate(BlockDriverState *bs, int l1_index, uint64_t **table)
212{
213 BDRVQcow2State *s = bs->opaque;
214 uint64_t old_l2_offset;
215 uint64_t *l2_table = NULL;
216 int64_t l2_offset;
217 int ret;
218
219 old_l2_offset = s->l1_table[l1_index];
220
221 trace_qcow2_l2_allocate(bs, l1_index);
222
223
224
225 l2_offset = qcow2_alloc_clusters(bs, s->l2_size * sizeof(uint64_t));
226 if (l2_offset < 0) {
227 ret = l2_offset;
228 goto fail;
229 }
230
231 ret = qcow2_cache_flush(bs, s->refcount_block_cache);
232 if (ret < 0) {
233 goto fail;
234 }
235
236
237
238 trace_qcow2_l2_allocate_get_empty(bs, l1_index);
239 ret = qcow2_cache_get_empty(bs, s->l2_table_cache, l2_offset, (void**) table);
240 if (ret < 0) {
241 goto fail;
242 }
243
244 l2_table = *table;
245
246 if ((old_l2_offset & L1E_OFFSET_MASK) == 0) {
247
248 memset(l2_table, 0, s->l2_size * sizeof(uint64_t));
249 } else {
250 uint64_t* old_table;
251
252
253 BLKDBG_EVENT(bs->file, BLKDBG_L2_ALLOC_COW_READ);
254 ret = qcow2_cache_get(bs, s->l2_table_cache,
255 old_l2_offset & L1E_OFFSET_MASK,
256 (void**) &old_table);
257 if (ret < 0) {
258 goto fail;
259 }
260
261 memcpy(l2_table, old_table, s->cluster_size);
262
263 qcow2_cache_put(bs, s->l2_table_cache, (void **) &old_table);
264 }
265
266
267 BLKDBG_EVENT(bs->file, BLKDBG_L2_ALLOC_WRITE);
268
269 trace_qcow2_l2_allocate_write_l2(bs, l1_index);
270 qcow2_cache_entry_mark_dirty(bs, s->l2_table_cache, l2_table);
271 ret = qcow2_cache_flush(bs, s->l2_table_cache);
272 if (ret < 0) {
273 goto fail;
274 }
275
276
277 trace_qcow2_l2_allocate_write_l1(bs, l1_index);
278 s->l1_table[l1_index] = l2_offset | QCOW_OFLAG_COPIED;
279 ret = qcow2_write_l1_entry(bs, l1_index);
280 if (ret < 0) {
281 goto fail;
282 }
283
284 *table = l2_table;
285 trace_qcow2_l2_allocate_done(bs, l1_index, 0);
286 return 0;
287
288fail:
289 trace_qcow2_l2_allocate_done(bs, l1_index, ret);
290 if (l2_table != NULL) {
291 qcow2_cache_put(bs, s->l2_table_cache, (void**) table);
292 }
293 s->l1_table[l1_index] = old_l2_offset;
294 if (l2_offset > 0) {
295 qcow2_free_clusters(bs, l2_offset, s->l2_size * sizeof(uint64_t),
296 QCOW2_DISCARD_ALWAYS);
297 }
298 return ret;
299}
300
301
302
303
304
305
306
307
308static int count_contiguous_clusters(int nb_clusters, int cluster_size,
309 uint64_t *l2_table, uint64_t stop_flags)
310{
311 int i;
312 QCow2ClusterType first_cluster_type;
313 uint64_t mask = stop_flags | L2E_OFFSET_MASK | QCOW_OFLAG_COMPRESSED;
314 uint64_t first_entry = be64_to_cpu(l2_table[0]);
315 uint64_t offset = first_entry & mask;
316
317 if (!offset) {
318 return 0;
319 }
320
321
322 first_cluster_type = qcow2_get_cluster_type(first_entry);
323 assert(first_cluster_type == QCOW2_CLUSTER_NORMAL ||
324 first_cluster_type == QCOW2_CLUSTER_ZERO_ALLOC);
325
326 for (i = 0; i < nb_clusters; i++) {
327 uint64_t l2_entry = be64_to_cpu(l2_table[i]) & mask;
328 if (offset + (uint64_t) i * cluster_size != l2_entry) {
329 break;
330 }
331 }
332
333 return i;
334}
335
336
337
338
339
340static int count_contiguous_clusters_unallocated(int nb_clusters,
341 uint64_t *l2_table,
342 QCow2ClusterType wanted_type)
343{
344 int i;
345
346 assert(wanted_type == QCOW2_CLUSTER_ZERO_PLAIN ||
347 wanted_type == QCOW2_CLUSTER_UNALLOCATED);
348 for (i = 0; i < nb_clusters; i++) {
349 uint64_t entry = be64_to_cpu(l2_table[i]);
350 QCow2ClusterType type = qcow2_get_cluster_type(entry);
351
352 if (type != wanted_type) {
353 break;
354 }
355 }
356
357 return i;
358}
359
360static int coroutine_fn do_perform_cow_read(BlockDriverState *bs,
361 uint64_t src_cluster_offset,
362 unsigned offset_in_cluster,
363 QEMUIOVector *qiov)
364{
365 int ret;
366
367 if (qiov->size == 0) {
368 return 0;
369 }
370
371 BLKDBG_EVENT(bs->file, BLKDBG_COW_READ);
372
373 if (!bs->drv) {
374 return -ENOMEDIUM;
375 }
376
377
378
379
380
381 ret = bs->drv->bdrv_co_preadv(bs, src_cluster_offset + offset_in_cluster,
382 qiov->size, qiov, 0);
383 if (ret < 0) {
384 return ret;
385 }
386
387 return 0;
388}
389
390static bool coroutine_fn do_perform_cow_encrypt(BlockDriverState *bs,
391 uint64_t src_cluster_offset,
392 uint64_t cluster_offset,
393 unsigned offset_in_cluster,
394 uint8_t *buffer,
395 unsigned bytes)
396{
397 if (bytes && bs->encrypted) {
398 BDRVQcow2State *s = bs->opaque;
399 int64_t sector = (s->crypt_physical_offset ?
400 (cluster_offset + offset_in_cluster) :
401 (src_cluster_offset + offset_in_cluster))
402 >> BDRV_SECTOR_BITS;
403 assert((offset_in_cluster & ~BDRV_SECTOR_MASK) == 0);
404 assert((bytes & ~BDRV_SECTOR_MASK) == 0);
405 assert(s->crypto);
406 if (qcrypto_block_encrypt(s->crypto, sector, buffer,
407 bytes, NULL) < 0) {
408 return false;
409 }
410 }
411 return true;
412}
413
414static int coroutine_fn do_perform_cow_write(BlockDriverState *bs,
415 uint64_t cluster_offset,
416 unsigned offset_in_cluster,
417 QEMUIOVector *qiov)
418{
419 int ret;
420
421 if (qiov->size == 0) {
422 return 0;
423 }
424
425 ret = qcow2_pre_write_overlap_check(bs, 0,
426 cluster_offset + offset_in_cluster, qiov->size);
427 if (ret < 0) {
428 return ret;
429 }
430
431 BLKDBG_EVENT(bs->file, BLKDBG_COW_WRITE);
432 ret = bdrv_co_pwritev(bs->file, cluster_offset + offset_in_cluster,
433 qiov->size, qiov, 0);
434 if (ret < 0) {
435 return ret;
436 }
437
438 return 0;
439}
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458int qcow2_get_cluster_offset(BlockDriverState *bs, uint64_t offset,
459 unsigned int *bytes, uint64_t *cluster_offset)
460{
461 BDRVQcow2State *s = bs->opaque;
462 unsigned int l2_index;
463 uint64_t l1_index, l2_offset, *l2_table;
464 int l1_bits, c;
465 unsigned int offset_in_cluster;
466 uint64_t bytes_available, bytes_needed, nb_clusters;
467 QCow2ClusterType type;
468 int ret;
469
470 offset_in_cluster = offset_into_cluster(s, offset);
471 bytes_needed = (uint64_t) *bytes + offset_in_cluster;
472
473 l1_bits = s->l2_bits + s->cluster_bits;
474
475
476
477 bytes_available = (1ULL << l1_bits) - (offset & ((1ULL << l1_bits) - 1))
478 + offset_in_cluster;
479
480 if (bytes_needed > bytes_available) {
481 bytes_needed = bytes_available;
482 }
483
484 *cluster_offset = 0;
485
486
487
488 l1_index = offset >> l1_bits;
489 if (l1_index >= s->l1_size) {
490 type = QCOW2_CLUSTER_UNALLOCATED;
491 goto out;
492 }
493
494 l2_offset = s->l1_table[l1_index] & L1E_OFFSET_MASK;
495 if (!l2_offset) {
496 type = QCOW2_CLUSTER_UNALLOCATED;
497 goto out;
498 }
499
500 if (offset_into_cluster(s, l2_offset)) {
501 qcow2_signal_corruption(bs, true, -1, -1, "L2 table offset %#" PRIx64
502 " unaligned (L1 index: %#" PRIx64 ")",
503 l2_offset, l1_index);
504 return -EIO;
505 }
506
507
508
509 ret = l2_load(bs, l2_offset, &l2_table);
510 if (ret < 0) {
511 return ret;
512 }
513
514
515
516 l2_index = offset_to_l2_index(s, offset);
517 *cluster_offset = be64_to_cpu(l2_table[l2_index]);
518
519 nb_clusters = size_to_clusters(s, bytes_needed);
520
521
522
523 assert(nb_clusters <= INT_MAX);
524
525 type = qcow2_get_cluster_type(*cluster_offset);
526 if (s->qcow_version < 3 && (type == QCOW2_CLUSTER_ZERO_PLAIN ||
527 type == QCOW2_CLUSTER_ZERO_ALLOC)) {
528 qcow2_signal_corruption(bs, true, -1, -1, "Zero cluster entry found"
529 " in pre-v3 image (L2 offset: %#" PRIx64
530 ", L2 index: %#x)", l2_offset, l2_index);
531 ret = -EIO;
532 goto fail;
533 }
534 switch (type) {
535 case QCOW2_CLUSTER_COMPRESSED:
536
537 c = 1;
538 *cluster_offset &= L2E_COMPRESSED_OFFSET_SIZE_MASK;
539 break;
540 case QCOW2_CLUSTER_ZERO_PLAIN:
541 case QCOW2_CLUSTER_UNALLOCATED:
542
543 c = count_contiguous_clusters_unallocated(nb_clusters,
544 &l2_table[l2_index], type);
545 *cluster_offset = 0;
546 break;
547 case QCOW2_CLUSTER_ZERO_ALLOC:
548 case QCOW2_CLUSTER_NORMAL:
549
550 c = count_contiguous_clusters(nb_clusters, s->cluster_size,
551 &l2_table[l2_index], QCOW_OFLAG_ZERO);
552 *cluster_offset &= L2E_OFFSET_MASK;
553 if (offset_into_cluster(s, *cluster_offset)) {
554 qcow2_signal_corruption(bs, true, -1, -1,
555 "Cluster allocation offset %#"
556 PRIx64 " unaligned (L2 offset: %#" PRIx64
557 ", L2 index: %#x)", *cluster_offset,
558 l2_offset, l2_index);
559 ret = -EIO;
560 goto fail;
561 }
562 break;
563 default:
564 abort();
565 }
566
567 qcow2_cache_put(bs, s->l2_table_cache, (void**) &l2_table);
568
569 bytes_available = (int64_t)c * s->cluster_size;
570
571out:
572 if (bytes_available > bytes_needed) {
573 bytes_available = bytes_needed;
574 }
575
576
577
578
579 assert(bytes_available - offset_in_cluster <= UINT_MAX);
580 *bytes = bytes_available - offset_in_cluster;
581
582 return type;
583
584fail:
585 qcow2_cache_put(bs, s->l2_table_cache, (void **)&l2_table);
586 return ret;
587}
588
589
590
591
592
593
594
595
596
597
598
599
600static int get_cluster_table(BlockDriverState *bs, uint64_t offset,
601 uint64_t **new_l2_table,
602 int *new_l2_index)
603{
604 BDRVQcow2State *s = bs->opaque;
605 unsigned int l2_index;
606 uint64_t l1_index, l2_offset;
607 uint64_t *l2_table = NULL;
608 int ret;
609
610
611
612 l1_index = offset >> (s->l2_bits + s->cluster_bits);
613 if (l1_index >= s->l1_size) {
614 ret = qcow2_grow_l1_table(bs, l1_index + 1, false);
615 if (ret < 0) {
616 return ret;
617 }
618 }
619
620 assert(l1_index < s->l1_size);
621 l2_offset = s->l1_table[l1_index] & L1E_OFFSET_MASK;
622 if (offset_into_cluster(s, l2_offset)) {
623 qcow2_signal_corruption(bs, true, -1, -1, "L2 table offset %#" PRIx64
624 " unaligned (L1 index: %#" PRIx64 ")",
625 l2_offset, l1_index);
626 return -EIO;
627 }
628
629
630
631 if (s->l1_table[l1_index] & QCOW_OFLAG_COPIED) {
632
633 ret = l2_load(bs, l2_offset, &l2_table);
634 if (ret < 0) {
635 return ret;
636 }
637 } else {
638
639 ret = l2_allocate(bs, l1_index, &l2_table);
640 if (ret < 0) {
641 return ret;
642 }
643
644
645 if (l2_offset) {
646 qcow2_free_clusters(bs, l2_offset, s->l2_size * sizeof(uint64_t),
647 QCOW2_DISCARD_OTHER);
648 }
649 }
650
651
652
653 l2_index = offset_to_l2_index(s, offset);
654
655 *new_l2_table = l2_table;
656 *new_l2_index = l2_index;
657
658 return 0;
659}
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674uint64_t qcow2_alloc_compressed_cluster_offset(BlockDriverState *bs,
675 uint64_t offset,
676 int compressed_size)
677{
678 BDRVQcow2State *s = bs->opaque;
679 int l2_index, ret;
680 uint64_t *l2_table;
681 int64_t cluster_offset;
682 int nb_csectors;
683
684 ret = get_cluster_table(bs, offset, &l2_table, &l2_index);
685 if (ret < 0) {
686 return 0;
687 }
688
689
690
691 cluster_offset = be64_to_cpu(l2_table[l2_index]);
692 if (cluster_offset & L2E_OFFSET_MASK) {
693 qcow2_cache_put(bs, s->l2_table_cache, (void**) &l2_table);
694 return 0;
695 }
696
697 cluster_offset = qcow2_alloc_bytes(bs, compressed_size);
698 if (cluster_offset < 0) {
699 qcow2_cache_put(bs, s->l2_table_cache, (void**) &l2_table);
700 return 0;
701 }
702
703 nb_csectors = ((cluster_offset + compressed_size - 1) >> 9) -
704 (cluster_offset >> 9);
705
706 cluster_offset |= QCOW_OFLAG_COMPRESSED |
707 ((uint64_t)nb_csectors << s->csize_shift);
708
709
710
711
712
713 BLKDBG_EVENT(bs->file, BLKDBG_L2_UPDATE_COMPRESSED);
714 qcow2_cache_entry_mark_dirty(bs, s->l2_table_cache, l2_table);
715 l2_table[l2_index] = cpu_to_be64(cluster_offset);
716 qcow2_cache_put(bs, s->l2_table_cache, (void **) &l2_table);
717
718 return cluster_offset;
719}
720
721static int perform_cow(BlockDriverState *bs, QCowL2Meta *m)
722{
723 BDRVQcow2State *s = bs->opaque;
724 Qcow2COWRegion *start = &m->cow_start;
725 Qcow2COWRegion *end = &m->cow_end;
726 unsigned buffer_size;
727 unsigned data_bytes = end->offset - (start->offset + start->nb_bytes);
728 bool merge_reads;
729 uint8_t *start_buffer, *end_buffer;
730 QEMUIOVector qiov;
731 int ret;
732
733 assert(start->nb_bytes <= UINT_MAX - end->nb_bytes);
734 assert(start->nb_bytes + end->nb_bytes <= UINT_MAX - data_bytes);
735 assert(start->offset + start->nb_bytes <= end->offset);
736 assert(!m->data_qiov || m->data_qiov->size == data_bytes);
737
738 if (start->nb_bytes == 0 && end->nb_bytes == 0) {
739 return 0;
740 }
741
742
743
744
745 merge_reads = start->nb_bytes && end->nb_bytes && data_bytes <= 16384;
746 if (merge_reads) {
747 buffer_size = start->nb_bytes + data_bytes + end->nb_bytes;
748 } else {
749
750
751
752 size_t align = bdrv_opt_mem_align(bs);
753 assert(align > 0 && align <= UINT_MAX);
754 assert(QEMU_ALIGN_UP(start->nb_bytes, align) <=
755 UINT_MAX - end->nb_bytes);
756 buffer_size = QEMU_ALIGN_UP(start->nb_bytes, align) + end->nb_bytes;
757 }
758
759
760
761 start_buffer = qemu_try_blockalign(bs, buffer_size);
762 if (start_buffer == NULL) {
763 return -ENOMEM;
764 }
765
766 end_buffer = start_buffer + buffer_size - end->nb_bytes;
767
768 qemu_iovec_init(&qiov, 2 + (m->data_qiov ? m->data_qiov->niov : 0));
769
770 qemu_co_mutex_unlock(&s->lock);
771
772
773
774 if (merge_reads) {
775 qemu_iovec_add(&qiov, start_buffer, buffer_size);
776 ret = do_perform_cow_read(bs, m->offset, start->offset, &qiov);
777 } else {
778 qemu_iovec_add(&qiov, start_buffer, start->nb_bytes);
779 ret = do_perform_cow_read(bs, m->offset, start->offset, &qiov);
780 if (ret < 0) {
781 goto fail;
782 }
783
784 qemu_iovec_reset(&qiov);
785 qemu_iovec_add(&qiov, end_buffer, end->nb_bytes);
786 ret = do_perform_cow_read(bs, m->offset, end->offset, &qiov);
787 }
788 if (ret < 0) {
789 goto fail;
790 }
791
792
793 if (bs->encrypted) {
794 if (!do_perform_cow_encrypt(bs, m->offset, m->alloc_offset,
795 start->offset, start_buffer,
796 start->nb_bytes) ||
797 !do_perform_cow_encrypt(bs, m->offset, m->alloc_offset,
798 end->offset, end_buffer, end->nb_bytes)) {
799 ret = -EIO;
800 goto fail;
801 }
802 }
803
804
805
806 if (m->data_qiov) {
807 qemu_iovec_reset(&qiov);
808 if (start->nb_bytes) {
809 qemu_iovec_add(&qiov, start_buffer, start->nb_bytes);
810 }
811 qemu_iovec_concat(&qiov, m->data_qiov, 0, data_bytes);
812 if (end->nb_bytes) {
813 qemu_iovec_add(&qiov, end_buffer, end->nb_bytes);
814 }
815
816
817
818 BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);
819 ret = do_perform_cow_write(bs, m->alloc_offset, start->offset, &qiov);
820 } else {
821
822 qemu_iovec_reset(&qiov);
823 qemu_iovec_add(&qiov, start_buffer, start->nb_bytes);
824 ret = do_perform_cow_write(bs, m->alloc_offset, start->offset, &qiov);
825 if (ret < 0) {
826 goto fail;
827 }
828
829 qemu_iovec_reset(&qiov);
830 qemu_iovec_add(&qiov, end_buffer, end->nb_bytes);
831 ret = do_perform_cow_write(bs, m->alloc_offset, end->offset, &qiov);
832 }
833
834fail:
835 qemu_co_mutex_lock(&s->lock);
836
837
838
839
840
841
842 if (ret == 0) {
843 qcow2_cache_depends_on_flush(s->l2_table_cache);
844 }
845
846 qemu_vfree(start_buffer);
847 qemu_iovec_destroy(&qiov);
848 return ret;
849}
850
851int qcow2_alloc_cluster_link_l2(BlockDriverState *bs, QCowL2Meta *m)
852{
853 BDRVQcow2State *s = bs->opaque;
854 int i, j = 0, l2_index, ret;
855 uint64_t *old_cluster, *l2_table;
856 uint64_t cluster_offset = m->alloc_offset;
857
858 trace_qcow2_cluster_link_l2(qemu_coroutine_self(), m->nb_clusters);
859 assert(m->nb_clusters > 0);
860
861 old_cluster = g_try_new(uint64_t, m->nb_clusters);
862 if (old_cluster == NULL) {
863 ret = -ENOMEM;
864 goto err;
865 }
866
867
868 ret = perform_cow(bs, m);
869 if (ret < 0) {
870 goto err;
871 }
872
873
874 if (s->use_lazy_refcounts) {
875 qcow2_mark_dirty(bs);
876 }
877 if (qcow2_need_accurate_refcounts(s)) {
878 qcow2_cache_set_dependency(bs, s->l2_table_cache,
879 s->refcount_block_cache);
880 }
881
882 ret = get_cluster_table(bs, m->offset, &l2_table, &l2_index);
883 if (ret < 0) {
884 goto err;
885 }
886 qcow2_cache_entry_mark_dirty(bs, s->l2_table_cache, l2_table);
887
888 assert(l2_index + m->nb_clusters <= s->l2_size);
889 for (i = 0; i < m->nb_clusters; i++) {
890
891
892
893
894
895
896 if (l2_table[l2_index + i] != 0) {
897 old_cluster[j++] = l2_table[l2_index + i];
898 }
899
900 l2_table[l2_index + i] = cpu_to_be64((cluster_offset +
901 (i << s->cluster_bits)) | QCOW_OFLAG_COPIED);
902 }
903
904
905 qcow2_cache_put(bs, s->l2_table_cache, (void **) &l2_table);
906
907
908
909
910
911
912
913 if (!m->keep_old_clusters && j != 0) {
914 for (i = 0; i < j; i++) {
915 qcow2_free_any_clusters(bs, be64_to_cpu(old_cluster[i]), 1,
916 QCOW2_DISCARD_NEVER);
917 }
918 }
919
920 ret = 0;
921err:
922 g_free(old_cluster);
923 return ret;
924 }
925
926
927
928
929
930
931static int count_cow_clusters(BDRVQcow2State *s, int nb_clusters,
932 uint64_t *l2_table, int l2_index)
933{
934 int i;
935
936 for (i = 0; i < nb_clusters; i++) {
937 uint64_t l2_entry = be64_to_cpu(l2_table[l2_index + i]);
938 QCow2ClusterType cluster_type = qcow2_get_cluster_type(l2_entry);
939
940 switch(cluster_type) {
941 case QCOW2_CLUSTER_NORMAL:
942 if (l2_entry & QCOW_OFLAG_COPIED) {
943 goto out;
944 }
945 break;
946 case QCOW2_CLUSTER_UNALLOCATED:
947 case QCOW2_CLUSTER_COMPRESSED:
948 case QCOW2_CLUSTER_ZERO_PLAIN:
949 case QCOW2_CLUSTER_ZERO_ALLOC:
950 break;
951 default:
952 abort();
953 }
954 }
955
956out:
957 assert(i <= nb_clusters);
958 return i;
959}
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975static int handle_dependencies(BlockDriverState *bs, uint64_t guest_offset,
976 uint64_t *cur_bytes, QCowL2Meta **m)
977{
978 BDRVQcow2State *s = bs->opaque;
979 QCowL2Meta *old_alloc;
980 uint64_t bytes = *cur_bytes;
981
982 QLIST_FOREACH(old_alloc, &s->cluster_allocs, next_in_flight) {
983
984 uint64_t start = guest_offset;
985 uint64_t end = start + bytes;
986 uint64_t old_start = l2meta_cow_start(old_alloc);
987 uint64_t old_end = l2meta_cow_end(old_alloc);
988
989 if (end <= old_start || start >= old_end) {
990
991 } else {
992 if (start < old_start) {
993
994 bytes = old_start - start;
995 } else {
996 bytes = 0;
997 }
998
999
1000
1001
1002
1003 if (bytes == 0 && *m) {
1004 *cur_bytes = 0;
1005 return 0;
1006 }
1007
1008 if (bytes == 0) {
1009
1010
1011 qemu_co_queue_wait(&old_alloc->dependent_requests, &s->lock);
1012 return -EAGAIN;
1013 }
1014 }
1015 }
1016
1017
1018
1019 *cur_bytes = bytes;
1020
1021 return 0;
1022}
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046static int handle_copied(BlockDriverState *bs, uint64_t guest_offset,
1047 uint64_t *host_offset, uint64_t *bytes, QCowL2Meta **m)
1048{
1049 BDRVQcow2State *s = bs->opaque;
1050 int l2_index;
1051 uint64_t cluster_offset;
1052 uint64_t *l2_table;
1053 uint64_t nb_clusters;
1054 unsigned int keep_clusters;
1055 int ret;
1056
1057 trace_qcow2_handle_copied(qemu_coroutine_self(), guest_offset, *host_offset,
1058 *bytes);
1059
1060 assert(*host_offset == 0 || offset_into_cluster(s, guest_offset)
1061 == offset_into_cluster(s, *host_offset));
1062
1063
1064
1065
1066
1067 nb_clusters =
1068 size_to_clusters(s, offset_into_cluster(s, guest_offset) + *bytes);
1069
1070 l2_index = offset_to_l2_index(s, guest_offset);
1071 nb_clusters = MIN(nb_clusters, s->l2_size - l2_index);
1072 assert(nb_clusters <= INT_MAX);
1073
1074
1075 ret = get_cluster_table(bs, guest_offset, &l2_table, &l2_index);
1076 if (ret < 0) {
1077 return ret;
1078 }
1079
1080 cluster_offset = be64_to_cpu(l2_table[l2_index]);
1081
1082
1083 if (qcow2_get_cluster_type(cluster_offset) == QCOW2_CLUSTER_NORMAL
1084 && (cluster_offset & QCOW_OFLAG_COPIED))
1085 {
1086
1087 bool offset_matches =
1088 (cluster_offset & L2E_OFFSET_MASK) == *host_offset;
1089
1090 if (offset_into_cluster(s, cluster_offset & L2E_OFFSET_MASK)) {
1091 qcow2_signal_corruption(bs, true, -1, -1, "Data cluster offset "
1092 "%#llx unaligned (guest offset: %#" PRIx64
1093 ")", cluster_offset & L2E_OFFSET_MASK,
1094 guest_offset);
1095 ret = -EIO;
1096 goto out;
1097 }
1098
1099 if (*host_offset != 0 && !offset_matches) {
1100 *bytes = 0;
1101 ret = 0;
1102 goto out;
1103 }
1104
1105
1106 keep_clusters =
1107 count_contiguous_clusters(nb_clusters, s->cluster_size,
1108 &l2_table[l2_index],
1109 QCOW_OFLAG_COPIED | QCOW_OFLAG_ZERO);
1110 assert(keep_clusters <= nb_clusters);
1111
1112 *bytes = MIN(*bytes,
1113 keep_clusters * s->cluster_size
1114 - offset_into_cluster(s, guest_offset));
1115
1116 ret = 1;
1117 } else {
1118 ret = 0;
1119 }
1120
1121
1122out:
1123 qcow2_cache_put(bs, s->l2_table_cache, (void **) &l2_table);
1124
1125
1126
1127 if (ret > 0) {
1128 *host_offset = (cluster_offset & L2E_OFFSET_MASK)
1129 + offset_into_cluster(s, guest_offset);
1130 }
1131
1132 return ret;
1133}
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154static int do_alloc_cluster_offset(BlockDriverState *bs, uint64_t guest_offset,
1155 uint64_t *host_offset, uint64_t *nb_clusters)
1156{
1157 BDRVQcow2State *s = bs->opaque;
1158
1159 trace_qcow2_do_alloc_clusters_offset(qemu_coroutine_self(), guest_offset,
1160 *host_offset, *nb_clusters);
1161
1162
1163 trace_qcow2_cluster_alloc_phys(qemu_coroutine_self());
1164 if (*host_offset == 0) {
1165 int64_t cluster_offset =
1166 qcow2_alloc_clusters(bs, *nb_clusters * s->cluster_size);
1167 if (cluster_offset < 0) {
1168 return cluster_offset;
1169 }
1170 *host_offset = cluster_offset;
1171 return 0;
1172 } else {
1173 int64_t ret = qcow2_alloc_clusters_at(bs, *host_offset, *nb_clusters);
1174 if (ret < 0) {
1175 return ret;
1176 }
1177 *nb_clusters = ret;
1178 return 0;
1179 }
1180}
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202static int handle_alloc(BlockDriverState *bs, uint64_t guest_offset,
1203 uint64_t *host_offset, uint64_t *bytes, QCowL2Meta **m)
1204{
1205 BDRVQcow2State *s = bs->opaque;
1206 int l2_index;
1207 uint64_t *l2_table;
1208 uint64_t entry;
1209 uint64_t nb_clusters;
1210 int ret;
1211 bool keep_old_clusters = false;
1212
1213 uint64_t alloc_cluster_offset = 0;
1214
1215 trace_qcow2_handle_alloc(qemu_coroutine_self(), guest_offset, *host_offset,
1216 *bytes);
1217 assert(*bytes > 0);
1218
1219
1220
1221
1222
1223 nb_clusters =
1224 size_to_clusters(s, offset_into_cluster(s, guest_offset) + *bytes);
1225
1226 l2_index = offset_to_l2_index(s, guest_offset);
1227 nb_clusters = MIN(nb_clusters, s->l2_size - l2_index);
1228 assert(nb_clusters <= INT_MAX);
1229
1230
1231 ret = get_cluster_table(bs, guest_offset, &l2_table, &l2_index);
1232 if (ret < 0) {
1233 return ret;
1234 }
1235
1236 entry = be64_to_cpu(l2_table[l2_index]);
1237
1238
1239 if (entry & QCOW_OFLAG_COMPRESSED) {
1240 nb_clusters = 1;
1241 } else {
1242 nb_clusters = count_cow_clusters(s, nb_clusters, l2_table, l2_index);
1243 }
1244
1245
1246
1247
1248 assert(nb_clusters > 0);
1249
1250 if (qcow2_get_cluster_type(entry) == QCOW2_CLUSTER_ZERO_ALLOC &&
1251 (entry & QCOW_OFLAG_COPIED) &&
1252 (!*host_offset ||
1253 start_of_cluster(s, *host_offset) == (entry & L2E_OFFSET_MASK)))
1254 {
1255
1256
1257
1258 int preallocated_nb_clusters =
1259 count_contiguous_clusters(nb_clusters, s->cluster_size,
1260 &l2_table[l2_index], QCOW_OFLAG_COPIED);
1261 assert(preallocated_nb_clusters > 0);
1262
1263 nb_clusters = preallocated_nb_clusters;
1264 alloc_cluster_offset = entry & L2E_OFFSET_MASK;
1265
1266
1267
1268 keep_old_clusters = true;
1269 }
1270
1271 qcow2_cache_put(bs, s->l2_table_cache, (void **) &l2_table);
1272
1273 if (!alloc_cluster_offset) {
1274
1275 alloc_cluster_offset = start_of_cluster(s, *host_offset);
1276 ret = do_alloc_cluster_offset(bs, guest_offset, &alloc_cluster_offset,
1277 &nb_clusters);
1278 if (ret < 0) {
1279 goto fail;
1280 }
1281
1282
1283 if (nb_clusters == 0) {
1284 *bytes = 0;
1285 return 0;
1286 }
1287
1288
1289
1290
1291
1292 if (!alloc_cluster_offset) {
1293 ret = qcow2_pre_write_overlap_check(bs, 0, alloc_cluster_offset,
1294 nb_clusters * s->cluster_size);
1295 assert(ret < 0);
1296 goto fail;
1297 }
1298 }
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314 uint64_t requested_bytes = *bytes + offset_into_cluster(s, guest_offset);
1315 int avail_bytes = MIN(INT_MAX, nb_clusters << s->cluster_bits);
1316 int nb_bytes = MIN(requested_bytes, avail_bytes);
1317 QCowL2Meta *old_m = *m;
1318
1319 *m = g_malloc0(sizeof(**m));
1320
1321 **m = (QCowL2Meta) {
1322 .next = old_m,
1323
1324 .alloc_offset = alloc_cluster_offset,
1325 .offset = start_of_cluster(s, guest_offset),
1326 .nb_clusters = nb_clusters,
1327
1328 .keep_old_clusters = keep_old_clusters,
1329
1330 .cow_start = {
1331 .offset = 0,
1332 .nb_bytes = offset_into_cluster(s, guest_offset),
1333 },
1334 .cow_end = {
1335 .offset = nb_bytes,
1336 .nb_bytes = avail_bytes - nb_bytes,
1337 },
1338 };
1339 qemu_co_queue_init(&(*m)->dependent_requests);
1340 QLIST_INSERT_HEAD(&s->cluster_allocs, *m, next_in_flight);
1341
1342 *host_offset = alloc_cluster_offset + offset_into_cluster(s, guest_offset);
1343 *bytes = MIN(*bytes, nb_bytes - offset_into_cluster(s, guest_offset));
1344 assert(*bytes != 0);
1345
1346 return 1;
1347
1348fail:
1349 if (*m && (*m)->nb_clusters > 0) {
1350 QLIST_REMOVE(*m, next_in_flight);
1351 }
1352 return ret;
1353}
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374int qcow2_alloc_cluster_offset(BlockDriverState *bs, uint64_t offset,
1375 unsigned int *bytes, uint64_t *host_offset,
1376 QCowL2Meta **m)
1377{
1378 BDRVQcow2State *s = bs->opaque;
1379 uint64_t start, remaining;
1380 uint64_t cluster_offset;
1381 uint64_t cur_bytes;
1382 int ret;
1383
1384 trace_qcow2_alloc_clusters_offset(qemu_coroutine_self(), offset, *bytes);
1385
1386again:
1387 start = offset;
1388 remaining = *bytes;
1389 cluster_offset = 0;
1390 *host_offset = 0;
1391 cur_bytes = 0;
1392 *m = NULL;
1393
1394 while (true) {
1395
1396 if (!*host_offset) {
1397 *host_offset = start_of_cluster(s, cluster_offset);
1398 }
1399
1400 assert(remaining >= cur_bytes);
1401
1402 start += cur_bytes;
1403 remaining -= cur_bytes;
1404 cluster_offset += cur_bytes;
1405
1406 if (remaining == 0) {
1407 break;
1408 }
1409
1410 cur_bytes = remaining;
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430 ret = handle_dependencies(bs, start, &cur_bytes, m);
1431 if (ret == -EAGAIN) {
1432
1433
1434
1435 assert(*m == NULL);
1436 goto again;
1437 } else if (ret < 0) {
1438 return ret;
1439 } else if (cur_bytes == 0) {
1440 break;
1441 } else {
1442
1443
1444
1445 }
1446
1447
1448
1449
1450 ret = handle_copied(bs, start, &cluster_offset, &cur_bytes, m);
1451 if (ret < 0) {
1452 return ret;
1453 } else if (ret) {
1454 continue;
1455 } else if (cur_bytes == 0) {
1456 break;
1457 }
1458
1459
1460
1461
1462
1463 ret = handle_alloc(bs, start, &cluster_offset, &cur_bytes, m);
1464 if (ret < 0) {
1465 return ret;
1466 } else if (ret) {
1467 continue;
1468 } else {
1469 assert(cur_bytes == 0);
1470 break;
1471 }
1472 }
1473
1474 *bytes -= remaining;
1475 assert(*bytes > 0);
1476 assert(*host_offset != 0);
1477
1478 return 0;
1479}
1480
1481static int decompress_buffer(uint8_t *out_buf, int out_buf_size,
1482 const uint8_t *buf, int buf_size)
1483{
1484 z_stream strm1, *strm = &strm1;
1485 int ret, out_len;
1486
1487 memset(strm, 0, sizeof(*strm));
1488
1489 strm->next_in = (uint8_t *)buf;
1490 strm->avail_in = buf_size;
1491 strm->next_out = out_buf;
1492 strm->avail_out = out_buf_size;
1493
1494 ret = inflateInit2(strm, -12);
1495 if (ret != Z_OK)
1496 return -1;
1497 ret = inflate(strm, Z_FINISH);
1498 out_len = strm->next_out - out_buf;
1499 if ((ret != Z_STREAM_END && ret != Z_BUF_ERROR) ||
1500 out_len != out_buf_size) {
1501 inflateEnd(strm);
1502 return -1;
1503 }
1504 inflateEnd(strm);
1505 return 0;
1506}
1507
1508int qcow2_decompress_cluster(BlockDriverState *bs, uint64_t cluster_offset)
1509{
1510 BDRVQcow2State *s = bs->opaque;
1511 int ret, csize, nb_csectors, sector_offset;
1512 uint64_t coffset;
1513
1514 coffset = cluster_offset & s->cluster_offset_mask;
1515 if (s->cluster_cache_offset != coffset) {
1516 nb_csectors = ((cluster_offset >> s->csize_shift) & s->csize_mask) + 1;
1517 sector_offset = coffset & 511;
1518 csize = nb_csectors * 512 - sector_offset;
1519 BLKDBG_EVENT(bs->file, BLKDBG_READ_COMPRESSED);
1520 ret = bdrv_read(bs->file, coffset >> 9, s->cluster_data,
1521 nb_csectors);
1522 if (ret < 0) {
1523 return ret;
1524 }
1525 if (decompress_buffer(s->cluster_cache, s->cluster_size,
1526 s->cluster_data + sector_offset, csize) < 0) {
1527 return -EIO;
1528 }
1529 s->cluster_cache_offset = coffset;
1530 }
1531 return 0;
1532}
1533
1534
1535
1536
1537
1538
1539static int discard_single_l2(BlockDriverState *bs, uint64_t offset,
1540 uint64_t nb_clusters, enum qcow2_discard_type type,
1541 bool full_discard)
1542{
1543 BDRVQcow2State *s = bs->opaque;
1544 uint64_t *l2_table;
1545 int l2_index;
1546 int ret;
1547 int i;
1548
1549 ret = get_cluster_table(bs, offset, &l2_table, &l2_index);
1550 if (ret < 0) {
1551 return ret;
1552 }
1553
1554
1555 nb_clusters = MIN(nb_clusters, s->l2_size - l2_index);
1556 assert(nb_clusters <= INT_MAX);
1557
1558 for (i = 0; i < nb_clusters; i++) {
1559 uint64_t old_l2_entry;
1560
1561 old_l2_entry = be64_to_cpu(l2_table[l2_index + i]);
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576 switch (qcow2_get_cluster_type(old_l2_entry)) {
1577 case QCOW2_CLUSTER_UNALLOCATED:
1578 if (full_discard || !bs->backing) {
1579 continue;
1580 }
1581 break;
1582
1583 case QCOW2_CLUSTER_ZERO_PLAIN:
1584 if (!full_discard) {
1585 continue;
1586 }
1587 break;
1588
1589 case QCOW2_CLUSTER_ZERO_ALLOC:
1590 case QCOW2_CLUSTER_NORMAL:
1591 case QCOW2_CLUSTER_COMPRESSED:
1592 break;
1593
1594 default:
1595 abort();
1596 }
1597
1598
1599 qcow2_cache_entry_mark_dirty(bs, s->l2_table_cache, l2_table);
1600 if (!full_discard && s->qcow_version >= 3) {
1601 l2_table[l2_index + i] = cpu_to_be64(QCOW_OFLAG_ZERO);
1602 } else {
1603 l2_table[l2_index + i] = cpu_to_be64(0);
1604 }
1605
1606
1607 qcow2_free_any_clusters(bs, old_l2_entry, 1, type);
1608 }
1609
1610 qcow2_cache_put(bs, s->l2_table_cache, (void **) &l2_table);
1611
1612 return nb_clusters;
1613}
1614
1615int qcow2_cluster_discard(BlockDriverState *bs, uint64_t offset,
1616 uint64_t bytes, enum qcow2_discard_type type,
1617 bool full_discard)
1618{
1619 BDRVQcow2State *s = bs->opaque;
1620 uint64_t end_offset = offset + bytes;
1621 uint64_t nb_clusters;
1622 int64_t cleared;
1623 int ret;
1624
1625
1626 assert(QEMU_IS_ALIGNED(offset, s->cluster_size));
1627 assert(QEMU_IS_ALIGNED(end_offset, s->cluster_size) ||
1628 end_offset == bs->total_sectors << BDRV_SECTOR_BITS);
1629
1630 nb_clusters = size_to_clusters(s, bytes);
1631
1632 s->cache_discards = true;
1633
1634
1635 while (nb_clusters > 0) {
1636 cleared = discard_single_l2(bs, offset, nb_clusters, type,
1637 full_discard);
1638 if (cleared < 0) {
1639 ret = cleared;
1640 goto fail;
1641 }
1642
1643 nb_clusters -= cleared;
1644 offset += (cleared * s->cluster_size);
1645 }
1646
1647 ret = 0;
1648fail:
1649 s->cache_discards = false;
1650 qcow2_process_discards(bs, ret);
1651
1652 return ret;
1653}
1654
1655
1656
1657
1658
1659
1660static int zero_single_l2(BlockDriverState *bs, uint64_t offset,
1661 uint64_t nb_clusters, int flags)
1662{
1663 BDRVQcow2State *s = bs->opaque;
1664 uint64_t *l2_table;
1665 int l2_index;
1666 int ret;
1667 int i;
1668 bool unmap = !!(flags & BDRV_REQ_MAY_UNMAP);
1669
1670 ret = get_cluster_table(bs, offset, &l2_table, &l2_index);
1671 if (ret < 0) {
1672 return ret;
1673 }
1674
1675
1676 nb_clusters = MIN(nb_clusters, s->l2_size - l2_index);
1677 assert(nb_clusters <= INT_MAX);
1678
1679 for (i = 0; i < nb_clusters; i++) {
1680 uint64_t old_offset;
1681 QCow2ClusterType cluster_type;
1682
1683 old_offset = be64_to_cpu(l2_table[l2_index + i]);
1684
1685
1686
1687
1688
1689 cluster_type = qcow2_get_cluster_type(old_offset);
1690 if (cluster_type == QCOW2_CLUSTER_ZERO_PLAIN ||
1691 (cluster_type == QCOW2_CLUSTER_ZERO_ALLOC && !unmap)) {
1692 continue;
1693 }
1694
1695 qcow2_cache_entry_mark_dirty(bs, s->l2_table_cache, l2_table);
1696 if (cluster_type == QCOW2_CLUSTER_COMPRESSED || unmap) {
1697 l2_table[l2_index + i] = cpu_to_be64(QCOW_OFLAG_ZERO);
1698 qcow2_free_any_clusters(bs, old_offset, 1, QCOW2_DISCARD_REQUEST);
1699 } else {
1700 l2_table[l2_index + i] |= cpu_to_be64(QCOW_OFLAG_ZERO);
1701 }
1702 }
1703
1704 qcow2_cache_put(bs, s->l2_table_cache, (void **) &l2_table);
1705
1706 return nb_clusters;
1707}
1708
1709int qcow2_cluster_zeroize(BlockDriverState *bs, uint64_t offset,
1710 uint64_t bytes, int flags)
1711{
1712 BDRVQcow2State *s = bs->opaque;
1713 uint64_t end_offset = offset + bytes;
1714 uint64_t nb_clusters;
1715 int64_t cleared;
1716 int ret;
1717
1718
1719 assert(QEMU_IS_ALIGNED(offset, s->cluster_size));
1720 assert(QEMU_IS_ALIGNED(end_offset, s->cluster_size) ||
1721 end_offset == bs->total_sectors << BDRV_SECTOR_BITS);
1722
1723
1724 if (s->qcow_version < 3) {
1725 return -ENOTSUP;
1726 }
1727
1728
1729 nb_clusters = size_to_clusters(s, bytes);
1730
1731 s->cache_discards = true;
1732
1733 while (nb_clusters > 0) {
1734 cleared = zero_single_l2(bs, offset, nb_clusters, flags);
1735 if (cleared < 0) {
1736 ret = cleared;
1737 goto fail;
1738 }
1739
1740 nb_clusters -= cleared;
1741 offset += (cleared * s->cluster_size);
1742 }
1743
1744 ret = 0;
1745fail:
1746 s->cache_discards = false;
1747 qcow2_process_discards(bs, ret);
1748
1749 return ret;
1750}
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760static int expand_zero_clusters_in_l1(BlockDriverState *bs, uint64_t *l1_table,
1761 int l1_size, int64_t *visited_l1_entries,
1762 int64_t l1_entries,
1763 BlockDriverAmendStatusCB *status_cb,
1764 void *cb_opaque)
1765{
1766 BDRVQcow2State *s = bs->opaque;
1767 bool is_active_l1 = (l1_table == s->l1_table);
1768 uint64_t *l2_table = NULL;
1769 int ret;
1770 int i, j;
1771
1772 if (!is_active_l1) {
1773
1774
1775 l2_table = qemu_try_blockalign(bs->file->bs, s->cluster_size);
1776 if (l2_table == NULL) {
1777 return -ENOMEM;
1778 }
1779 }
1780
1781 for (i = 0; i < l1_size; i++) {
1782 uint64_t l2_offset = l1_table[i] & L1E_OFFSET_MASK;
1783 bool l2_dirty = false;
1784 uint64_t l2_refcount;
1785
1786 if (!l2_offset) {
1787
1788 (*visited_l1_entries)++;
1789 if (status_cb) {
1790 status_cb(bs, *visited_l1_entries, l1_entries, cb_opaque);
1791 }
1792 continue;
1793 }
1794
1795 if (offset_into_cluster(s, l2_offset)) {
1796 qcow2_signal_corruption(bs, true, -1, -1, "L2 table offset %#"
1797 PRIx64 " unaligned (L1 index: %#x)",
1798 l2_offset, i);
1799 ret = -EIO;
1800 goto fail;
1801 }
1802
1803 if (is_active_l1) {
1804
1805 ret = qcow2_cache_get(bs, s->l2_table_cache, l2_offset,
1806 (void **)&l2_table);
1807 } else {
1808
1809 ret = bdrv_read(bs->file, l2_offset / BDRV_SECTOR_SIZE,
1810 (void *)l2_table, s->cluster_sectors);
1811 }
1812 if (ret < 0) {
1813 goto fail;
1814 }
1815
1816 ret = qcow2_get_refcount(bs, l2_offset >> s->cluster_bits,
1817 &l2_refcount);
1818 if (ret < 0) {
1819 goto fail;
1820 }
1821
1822 for (j = 0; j < s->l2_size; j++) {
1823 uint64_t l2_entry = be64_to_cpu(l2_table[j]);
1824 int64_t offset = l2_entry & L2E_OFFSET_MASK;
1825 QCow2ClusterType cluster_type = qcow2_get_cluster_type(l2_entry);
1826
1827 if (cluster_type != QCOW2_CLUSTER_ZERO_PLAIN &&
1828 cluster_type != QCOW2_CLUSTER_ZERO_ALLOC) {
1829 continue;
1830 }
1831
1832 if (cluster_type == QCOW2_CLUSTER_ZERO_PLAIN) {
1833 if (!bs->backing) {
1834
1835
1836 l2_table[j] = 0;
1837 l2_dirty = true;
1838 continue;
1839 }
1840
1841 offset = qcow2_alloc_clusters(bs, s->cluster_size);
1842 if (offset < 0) {
1843 ret = offset;
1844 goto fail;
1845 }
1846
1847 if (l2_refcount > 1) {
1848
1849
1850 ret = qcow2_update_cluster_refcount(bs,
1851 offset >> s->cluster_bits,
1852 refcount_diff(1, l2_refcount), false,
1853 QCOW2_DISCARD_OTHER);
1854 if (ret < 0) {
1855 qcow2_free_clusters(bs, offset, s->cluster_size,
1856 QCOW2_DISCARD_OTHER);
1857 goto fail;
1858 }
1859 }
1860 }
1861
1862 if (offset_into_cluster(s, offset)) {
1863 qcow2_signal_corruption(bs, true, -1, -1,
1864 "Cluster allocation offset "
1865 "%#" PRIx64 " unaligned (L2 offset: %#"
1866 PRIx64 ", L2 index: %#x)", offset,
1867 l2_offset, j);
1868 if (cluster_type == QCOW2_CLUSTER_ZERO_PLAIN) {
1869 qcow2_free_clusters(bs, offset, s->cluster_size,
1870 QCOW2_DISCARD_ALWAYS);
1871 }
1872 ret = -EIO;
1873 goto fail;
1874 }
1875
1876 ret = qcow2_pre_write_overlap_check(bs, 0, offset, s->cluster_size);
1877 if (ret < 0) {
1878 if (cluster_type == QCOW2_CLUSTER_ZERO_PLAIN) {
1879 qcow2_free_clusters(bs, offset, s->cluster_size,
1880 QCOW2_DISCARD_ALWAYS);
1881 }
1882 goto fail;
1883 }
1884
1885 ret = bdrv_pwrite_zeroes(bs->file, offset, s->cluster_size, 0);
1886 if (ret < 0) {
1887 if (cluster_type == QCOW2_CLUSTER_ZERO_PLAIN) {
1888 qcow2_free_clusters(bs, offset, s->cluster_size,
1889 QCOW2_DISCARD_ALWAYS);
1890 }
1891 goto fail;
1892 }
1893
1894 if (l2_refcount == 1) {
1895 l2_table[j] = cpu_to_be64(offset | QCOW_OFLAG_COPIED);
1896 } else {
1897 l2_table[j] = cpu_to_be64(offset);
1898 }
1899 l2_dirty = true;
1900 }
1901
1902 if (is_active_l1) {
1903 if (l2_dirty) {
1904 qcow2_cache_entry_mark_dirty(bs, s->l2_table_cache, l2_table);
1905 qcow2_cache_depends_on_flush(s->l2_table_cache);
1906 }
1907 qcow2_cache_put(bs, s->l2_table_cache, (void **) &l2_table);
1908 } else {
1909 if (l2_dirty) {
1910 ret = qcow2_pre_write_overlap_check(bs,
1911 QCOW2_OL_INACTIVE_L2 | QCOW2_OL_ACTIVE_L2, l2_offset,
1912 s->cluster_size);
1913 if (ret < 0) {
1914 goto fail;
1915 }
1916
1917 ret = bdrv_write(bs->file, l2_offset / BDRV_SECTOR_SIZE,
1918 (void *)l2_table, s->cluster_sectors);
1919 if (ret < 0) {
1920 goto fail;
1921 }
1922 }
1923 }
1924
1925 (*visited_l1_entries)++;
1926 if (status_cb) {
1927 status_cb(bs, *visited_l1_entries, l1_entries, cb_opaque);
1928 }
1929 }
1930
1931 ret = 0;
1932
1933fail:
1934 if (l2_table) {
1935 if (!is_active_l1) {
1936 qemu_vfree(l2_table);
1937 } else {
1938 qcow2_cache_put(bs, s->l2_table_cache, (void **) &l2_table);
1939 }
1940 }
1941 return ret;
1942}
1943
1944
1945
1946
1947
1948
1949
1950int qcow2_expand_zero_clusters(BlockDriverState *bs,
1951 BlockDriverAmendStatusCB *status_cb,
1952 void *cb_opaque)
1953{
1954 BDRVQcow2State *s = bs->opaque;
1955 uint64_t *l1_table = NULL;
1956 int64_t l1_entries = 0, visited_l1_entries = 0;
1957 int ret;
1958 int i, j;
1959
1960 if (status_cb) {
1961 l1_entries = s->l1_size;
1962 for (i = 0; i < s->nb_snapshots; i++) {
1963 l1_entries += s->snapshots[i].l1_size;
1964 }
1965 }
1966
1967 ret = expand_zero_clusters_in_l1(bs, s->l1_table, s->l1_size,
1968 &visited_l1_entries, l1_entries,
1969 status_cb, cb_opaque);
1970 if (ret < 0) {
1971 goto fail;
1972 }
1973
1974
1975
1976
1977
1978
1979
1980
1981 ret = qcow2_cache_empty(bs, s->l2_table_cache);
1982 if (ret < 0) {
1983 goto fail;
1984 }
1985
1986 for (i = 0; i < s->nb_snapshots; i++) {
1987 int l1_sectors = DIV_ROUND_UP(s->snapshots[i].l1_size *
1988 sizeof(uint64_t), BDRV_SECTOR_SIZE);
1989
1990 l1_table = g_realloc(l1_table, l1_sectors * BDRV_SECTOR_SIZE);
1991
1992 ret = bdrv_read(bs->file,
1993 s->snapshots[i].l1_table_offset / BDRV_SECTOR_SIZE,
1994 (void *)l1_table, l1_sectors);
1995 if (ret < 0) {
1996 goto fail;
1997 }
1998
1999 for (j = 0; j < s->snapshots[i].l1_size; j++) {
2000 be64_to_cpus(&l1_table[j]);
2001 }
2002
2003 ret = expand_zero_clusters_in_l1(bs, l1_table, s->snapshots[i].l1_size,
2004 &visited_l1_entries, l1_entries,
2005 status_cb, cb_opaque);
2006 if (ret < 0) {
2007 goto fail;
2008 }
2009 }
2010
2011 ret = 0;
2012
2013fail:
2014 g_free(l1_table);
2015 return ret;
2016}
2017