2 * Block driver for the QCOW version 2 format
4 * Copyright (c) 2004-2006 Fabrice Bellard
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:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
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
25 #include "qemu/osdep.h"
26 #include "qapi/error.h"
28 #include "qemu/bswap.h"
29 #include "qemu/error-report.h"
30 #include "qemu/cutils.h"
32 static void qcow2_free_single_snapshot(BlockDriverState
*bs
, int i
)
34 BDRVQcow2State
*s
= bs
->opaque
;
36 assert(i
>= 0 && i
< s
->nb_snapshots
);
37 g_free(s
->snapshots
[i
].name
);
38 g_free(s
->snapshots
[i
].id_str
);
39 g_free(s
->snapshots
[i
].unknown_extra_data
);
40 memset(&s
->snapshots
[i
], 0, sizeof(s
->snapshots
[i
]));
43 void qcow2_free_snapshots(BlockDriverState
*bs
)
45 BDRVQcow2State
*s
= bs
->opaque
;
48 for(i
= 0; i
< s
->nb_snapshots
; i
++) {
49 qcow2_free_single_snapshot(bs
, i
);
57 * If @repair is true, try to repair a broken snapshot table instead
58 * of just returning an error:
60 * - If the snapshot table was too long, set *nb_clusters_reduced to
61 * the number of snapshots removed off the end.
62 * The caller will update the on-disk nb_snapshots accordingly;
63 * this leaks clusters, but is safe.
64 * (The on-disk information must be updated before
65 * qcow2_check_refcounts(), because that function relies on
66 * s->nb_snapshots to reflect the on-disk value.)
68 * - If there were snapshots with too much extra metadata, increment
69 * *extra_data_dropped for each.
70 * This requires the caller to eventually rewrite the whole snapshot
71 * table, which requires cluster allocation. Therefore, this should
72 * be done only after qcow2_check_refcounts() made sure the refcount
73 * structures are valid.
74 * (In the meantime, the image is still valid because
75 * qcow2_check_refcounts() does not do anything with snapshots'
78 static int qcow2_do_read_snapshots(BlockDriverState
*bs
, bool repair
,
79 int *nb_clusters_reduced
,
80 int *extra_data_dropped
,
83 BDRVQcow2State
*s
= bs
->opaque
;
85 QCowSnapshotExtraData extra
;
87 int i
, id_str_size
, name_size
;
88 int64_t offset
, pre_sn_offset
;
89 uint64_t table_length
= 0;
92 if (!s
->nb_snapshots
) {
94 s
->snapshots_size
= 0;
98 offset
= s
->snapshots_offset
;
99 s
->snapshots
= g_new0(QCowSnapshot
, s
->nb_snapshots
);
101 for(i
= 0; i
< s
->nb_snapshots
; i
++) {
102 bool truncate_unknown_extra_data
= false;
104 pre_sn_offset
= offset
;
105 table_length
= ROUND_UP(table_length
, 8);
107 /* Read statically sized part of the snapshot header */
108 offset
= ROUND_UP(offset
, 8);
109 ret
= bdrv_pread(bs
->file
, offset
, &h
, sizeof(h
));
111 error_setg_errno(errp
, -ret
, "Failed to read snapshot table");
116 sn
= s
->snapshots
+ i
;
117 sn
->l1_table_offset
= be64_to_cpu(h
.l1_table_offset
);
118 sn
->l1_size
= be32_to_cpu(h
.l1_size
);
119 sn
->vm_state_size
= be32_to_cpu(h
.vm_state_size
);
120 sn
->date_sec
= be32_to_cpu(h
.date_sec
);
121 sn
->date_nsec
= be32_to_cpu(h
.date_nsec
);
122 sn
->vm_clock_nsec
= be64_to_cpu(h
.vm_clock_nsec
);
123 sn
->extra_data_size
= be32_to_cpu(h
.extra_data_size
);
125 id_str_size
= be16_to_cpu(h
.id_str_size
);
126 name_size
= be16_to_cpu(h
.name_size
);
128 if (sn
->extra_data_size
> QCOW_MAX_SNAPSHOT_EXTRA_DATA
) {
131 error_setg(errp
, "Too much extra metadata in snapshot table "
133 error_append_hint(errp
, "You can force-remove this extra "
134 "metadata with qemu-img check -r all\n");
138 fprintf(stderr
, "Discarding too much extra metadata in snapshot "
139 "table entry %i (%" PRIu32
" > %u)\n",
140 i
, sn
->extra_data_size
, QCOW_MAX_SNAPSHOT_EXTRA_DATA
);
142 (*extra_data_dropped
)++;
143 truncate_unknown_extra_data
= true;
146 /* Read known extra data */
147 ret
= bdrv_pread(bs
->file
, offset
, &extra
,
148 MIN(sizeof(extra
), sn
->extra_data_size
));
150 error_setg_errno(errp
, -ret
, "Failed to read snapshot table");
153 offset
+= MIN(sizeof(extra
), sn
->extra_data_size
);
155 if (sn
->extra_data_size
>= endof(QCowSnapshotExtraData
,
156 vm_state_size_large
)) {
157 sn
->vm_state_size
= be64_to_cpu(extra
.vm_state_size_large
);
160 if (sn
->extra_data_size
>= endof(QCowSnapshotExtraData
, disk_size
)) {
161 sn
->disk_size
= be64_to_cpu(extra
.disk_size
);
163 sn
->disk_size
= bs
->total_sectors
* BDRV_SECTOR_SIZE
;
166 if (sn
->extra_data_size
> sizeof(extra
)) {
167 uint64_t extra_data_end
;
168 size_t unknown_extra_data_size
;
170 extra_data_end
= offset
+ sn
->extra_data_size
- sizeof(extra
);
172 if (truncate_unknown_extra_data
) {
173 sn
->extra_data_size
= QCOW_MAX_SNAPSHOT_EXTRA_DATA
;
176 /* Store unknown extra data */
177 unknown_extra_data_size
= sn
->extra_data_size
- sizeof(extra
);
178 sn
->unknown_extra_data
= g_malloc(unknown_extra_data_size
);
179 ret
= bdrv_pread(bs
->file
, offset
, sn
->unknown_extra_data
,
180 unknown_extra_data_size
);
182 error_setg_errno(errp
, -ret
,
183 "Failed to read snapshot table");
186 offset
= extra_data_end
;
189 /* Read snapshot ID */
190 sn
->id_str
= g_malloc(id_str_size
+ 1);
191 ret
= bdrv_pread(bs
->file
, offset
, sn
->id_str
, id_str_size
);
193 error_setg_errno(errp
, -ret
, "Failed to read snapshot table");
196 offset
+= id_str_size
;
197 sn
->id_str
[id_str_size
] = '\0';
199 /* Read snapshot name */
200 sn
->name
= g_malloc(name_size
+ 1);
201 ret
= bdrv_pread(bs
->file
, offset
, sn
->name
, name_size
);
203 error_setg_errno(errp
, -ret
, "Failed to read snapshot table");
207 sn
->name
[name_size
] = '\0';
209 /* Note that the extra data may have been truncated */
210 table_length
+= sizeof(h
) + sn
->extra_data_size
+ id_str_size
+
213 assert(table_length
== offset
- s
->snapshots_offset
);
216 if (table_length
> QCOW_MAX_SNAPSHOTS_SIZE
||
217 offset
- s
->snapshots_offset
> INT_MAX
)
221 error_setg(errp
, "Snapshot table is too big");
222 error_append_hint(errp
, "You can force-remove all %u "
223 "overhanging snapshots with qemu-img check "
224 "-r all\n", s
->nb_snapshots
- i
);
228 fprintf(stderr
, "Discarding %u overhanging snapshots (snapshot "
229 "table is too big)\n", s
->nb_snapshots
- i
);
231 *nb_clusters_reduced
+= (s
->nb_snapshots
- i
);
233 /* Discard current snapshot also */
234 qcow2_free_single_snapshot(bs
, i
);
237 * This leaks all the rest of the snapshot table and the
238 * snapshots' clusters, but we run in check -r all mode,
239 * so qcow2_check_refcounts() will take care of it.
242 offset
= pre_sn_offset
;
247 assert(offset
- s
->snapshots_offset
<= INT_MAX
);
248 s
->snapshots_size
= offset
- s
->snapshots_offset
;
252 qcow2_free_snapshots(bs
);
256 int qcow2_read_snapshots(BlockDriverState
*bs
, Error
**errp
)
258 return qcow2_do_read_snapshots(bs
, false, NULL
, NULL
, errp
);
261 /* add at the end of the file a new list of snapshots */
262 int qcow2_write_snapshots(BlockDriverState
*bs
)
264 BDRVQcow2State
*s
= bs
->opaque
;
266 QCowSnapshotHeader h
;
267 QCowSnapshotExtraData extra
;
268 int i
, name_size
, id_str_size
, snapshots_size
;
270 uint32_t nb_snapshots
;
271 uint64_t snapshots_offset
;
272 } QEMU_PACKED header_data
;
273 int64_t offset
, snapshots_offset
= 0;
276 /* compute the size of the snapshots */
278 for(i
= 0; i
< s
->nb_snapshots
; i
++) {
279 sn
= s
->snapshots
+ i
;
280 offset
= ROUND_UP(offset
, 8);
282 offset
+= MAX(sizeof(extra
), sn
->extra_data_size
);
283 offset
+= strlen(sn
->id_str
);
284 offset
+= strlen(sn
->name
);
286 if (offset
> QCOW_MAX_SNAPSHOTS_SIZE
) {
292 assert(offset
<= INT_MAX
);
293 snapshots_size
= offset
;
295 /* Allocate space for the new snapshot list */
296 snapshots_offset
= qcow2_alloc_clusters(bs
, snapshots_size
);
297 offset
= snapshots_offset
;
302 ret
= bdrv_flush(bs
);
307 /* The snapshot list position has not yet been updated, so these clusters
308 * must indeed be completely free */
309 ret
= qcow2_pre_write_overlap_check(bs
, 0, offset
, snapshots_size
, false);
315 /* Write all snapshots to the new list */
316 for(i
= 0; i
< s
->nb_snapshots
; i
++) {
317 sn
= s
->snapshots
+ i
;
318 memset(&h
, 0, sizeof(h
));
319 h
.l1_table_offset
= cpu_to_be64(sn
->l1_table_offset
);
320 h
.l1_size
= cpu_to_be32(sn
->l1_size
);
321 /* If it doesn't fit in 32 bit, older implementations should treat it
322 * as a disk-only snapshot rather than truncate the VM state */
323 if (sn
->vm_state_size
<= 0xffffffff) {
324 h
.vm_state_size
= cpu_to_be32(sn
->vm_state_size
);
326 h
.date_sec
= cpu_to_be32(sn
->date_sec
);
327 h
.date_nsec
= cpu_to_be32(sn
->date_nsec
);
328 h
.vm_clock_nsec
= cpu_to_be64(sn
->vm_clock_nsec
);
329 h
.extra_data_size
= cpu_to_be32(MAX(sizeof(extra
),
330 sn
->extra_data_size
));
332 memset(&extra
, 0, sizeof(extra
));
333 extra
.vm_state_size_large
= cpu_to_be64(sn
->vm_state_size
);
334 extra
.disk_size
= cpu_to_be64(sn
->disk_size
);
336 id_str_size
= strlen(sn
->id_str
);
337 name_size
= strlen(sn
->name
);
338 assert(id_str_size
<= UINT16_MAX
&& name_size
<= UINT16_MAX
);
339 h
.id_str_size
= cpu_to_be16(id_str_size
);
340 h
.name_size
= cpu_to_be16(name_size
);
341 offset
= ROUND_UP(offset
, 8);
343 ret
= bdrv_pwrite(bs
->file
, offset
, &h
, sizeof(h
));
349 ret
= bdrv_pwrite(bs
->file
, offset
, &extra
, sizeof(extra
));
353 offset
+= sizeof(extra
);
355 if (sn
->extra_data_size
> sizeof(extra
)) {
356 size_t unknown_extra_data_size
=
357 sn
->extra_data_size
- sizeof(extra
);
359 /* qcow2_read_snapshots() ensures no unbounded allocation */
360 assert(unknown_extra_data_size
<= BDRV_REQUEST_MAX_BYTES
);
361 assert(sn
->unknown_extra_data
);
363 ret
= bdrv_pwrite(bs
->file
, offset
, sn
->unknown_extra_data
,
364 unknown_extra_data_size
);
368 offset
+= unknown_extra_data_size
;
371 ret
= bdrv_pwrite(bs
->file
, offset
, sn
->id_str
, id_str_size
);
375 offset
+= id_str_size
;
377 ret
= bdrv_pwrite(bs
->file
, offset
, sn
->name
, name_size
);
385 * Update the header to point to the new snapshot table. This requires the
386 * new table and its refcounts to be stable on disk.
388 ret
= bdrv_flush(bs
);
393 QEMU_BUILD_BUG_ON(offsetof(QCowHeader
, snapshots_offset
) !=
394 endof(QCowHeader
, nb_snapshots
));
396 header_data
.nb_snapshots
= cpu_to_be32(s
->nb_snapshots
);
397 header_data
.snapshots_offset
= cpu_to_be64(snapshots_offset
);
399 ret
= bdrv_pwrite_sync(bs
->file
, offsetof(QCowHeader
, nb_snapshots
),
400 &header_data
, sizeof(header_data
));
405 /* free the old snapshot table */
406 qcow2_free_clusters(bs
, s
->snapshots_offset
, s
->snapshots_size
,
407 QCOW2_DISCARD_SNAPSHOT
);
408 s
->snapshots_offset
= snapshots_offset
;
409 s
->snapshots_size
= snapshots_size
;
413 if (snapshots_offset
> 0) {
414 qcow2_free_clusters(bs
, snapshots_offset
, snapshots_size
,
415 QCOW2_DISCARD_ALWAYS
);
420 int coroutine_fn
qcow2_check_read_snapshot_table(BlockDriverState
*bs
,
421 BdrvCheckResult
*result
,
424 BDRVQcow2State
*s
= bs
->opaque
;
425 Error
*local_err
= NULL
;
426 int nb_clusters_reduced
= 0;
427 int extra_data_dropped
= 0;
430 uint32_t nb_snapshots
;
431 uint64_t snapshots_offset
;
432 } QEMU_PACKED snapshot_table_pointer
;
434 /* qcow2_do_open() discards this information in check mode */
435 ret
= bdrv_pread(bs
->file
, offsetof(QCowHeader
, nb_snapshots
),
436 &snapshot_table_pointer
, sizeof(snapshot_table_pointer
));
438 result
->check_errors
++;
439 fprintf(stderr
, "ERROR failed to read the snapshot table pointer from "
440 "the image header: %s\n", strerror(-ret
));
444 s
->snapshots_offset
= be64_to_cpu(snapshot_table_pointer
.snapshots_offset
);
445 s
->nb_snapshots
= be32_to_cpu(snapshot_table_pointer
.nb_snapshots
);
447 if (s
->nb_snapshots
> QCOW_MAX_SNAPSHOTS
&& (fix
& BDRV_FIX_ERRORS
)) {
448 fprintf(stderr
, "Discarding %u overhanging snapshots\n",
449 s
->nb_snapshots
- QCOW_MAX_SNAPSHOTS
);
451 nb_clusters_reduced
+= s
->nb_snapshots
- QCOW_MAX_SNAPSHOTS
;
452 s
->nb_snapshots
= QCOW_MAX_SNAPSHOTS
;
455 ret
= qcow2_validate_table(bs
, s
->snapshots_offset
, s
->nb_snapshots
,
456 sizeof(QCowSnapshotHeader
),
457 sizeof(QCowSnapshotHeader
) * QCOW_MAX_SNAPSHOTS
,
458 "snapshot table", &local_err
);
460 result
->check_errors
++;
461 error_reportf_err(local_err
, "ERROR ");
463 if (s
->nb_snapshots
> QCOW_MAX_SNAPSHOTS
) {
464 fprintf(stderr
, "You can force-remove all %u overhanging snapshots "
465 "with qemu-img check -r all\n",
466 s
->nb_snapshots
- QCOW_MAX_SNAPSHOTS
);
469 /* We did not read the snapshot table, so invalidate this information */
470 s
->snapshots_offset
= 0;
476 qemu_co_mutex_unlock(&s
->lock
);
477 ret
= qcow2_do_read_snapshots(bs
, fix
& BDRV_FIX_ERRORS
,
478 &nb_clusters_reduced
, &extra_data_dropped
,
480 qemu_co_mutex_lock(&s
->lock
);
482 result
->check_errors
++;
483 error_reportf_err(local_err
,
484 "ERROR failed to read the snapshot table: ");
486 /* We did not read the snapshot table, so invalidate this information */
487 s
->snapshots_offset
= 0;
492 result
->corruptions
+= nb_clusters_reduced
+ extra_data_dropped
;
494 if (nb_clusters_reduced
) {
496 * Update image header now, because:
497 * (1) qcow2_check_refcounts() relies on s->nb_snapshots to be
498 * the same as what the image header says,
499 * (2) this leaks clusters, but qcow2_check_refcounts() will
502 assert(fix
& BDRV_FIX_ERRORS
);
504 snapshot_table_pointer
.nb_snapshots
= cpu_to_be32(s
->nb_snapshots
);
505 ret
= bdrv_pwrite_sync(bs
->file
, offsetof(QCowHeader
, nb_snapshots
),
506 &snapshot_table_pointer
.nb_snapshots
,
507 sizeof(snapshot_table_pointer
.nb_snapshots
));
509 result
->check_errors
++;
510 fprintf(stderr
, "ERROR failed to update the snapshot count in the "
511 "image header: %s\n", strerror(-ret
));
515 result
->corruptions_fixed
+= nb_clusters_reduced
;
516 result
->corruptions
-= nb_clusters_reduced
;
522 int coroutine_fn
qcow2_check_fix_snapshot_table(BlockDriverState
*bs
,
523 BdrvCheckResult
*result
,
526 BDRVQcow2State
*s
= bs
->opaque
;
529 if (result
->corruptions
&& (fix
& BDRV_FIX_ERRORS
)) {
530 qemu_co_mutex_unlock(&s
->lock
);
531 ret
= qcow2_write_snapshots(bs
);
532 qemu_co_mutex_lock(&s
->lock
);
534 result
->check_errors
++;
535 fprintf(stderr
, "ERROR failed to update snapshot table: %s\n",
540 result
->corruptions_fixed
+= result
->corruptions
;
541 result
->corruptions
= 0;
547 static void find_new_snapshot_id(BlockDriverState
*bs
,
548 char *id_str
, int id_str_size
)
550 BDRVQcow2State
*s
= bs
->opaque
;
553 unsigned long id
, id_max
= 0;
555 for(i
= 0; i
< s
->nb_snapshots
; i
++) {
556 sn
= s
->snapshots
+ i
;
557 id
= strtoul(sn
->id_str
, NULL
, 10);
561 snprintf(id_str
, id_str_size
, "%lu", id_max
+ 1);
564 static int find_snapshot_by_id_and_name(BlockDriverState
*bs
,
568 BDRVQcow2State
*s
= bs
->opaque
;
572 for (i
= 0; i
< s
->nb_snapshots
; i
++) {
573 if (!strcmp(s
->snapshots
[i
].id_str
, id
) &&
574 !strcmp(s
->snapshots
[i
].name
, name
)) {
579 for (i
= 0; i
< s
->nb_snapshots
; i
++) {
580 if (!strcmp(s
->snapshots
[i
].id_str
, id
)) {
585 for (i
= 0; i
< s
->nb_snapshots
; i
++) {
586 if (!strcmp(s
->snapshots
[i
].name
, name
)) {
595 static int find_snapshot_by_id_or_name(BlockDriverState
*bs
,
596 const char *id_or_name
)
600 ret
= find_snapshot_by_id_and_name(bs
, id_or_name
, NULL
);
604 return find_snapshot_by_id_and_name(bs
, NULL
, id_or_name
);
607 /* if no id is provided, a new one is constructed */
608 int qcow2_snapshot_create(BlockDriverState
*bs
, QEMUSnapshotInfo
*sn_info
)
610 BDRVQcow2State
*s
= bs
->opaque
;
611 QCowSnapshot
*new_snapshot_list
= NULL
;
612 QCowSnapshot
*old_snapshot_list
= NULL
;
613 QCowSnapshot sn1
, *sn
= &sn1
;
615 uint64_t *l1_table
= NULL
;
616 int64_t l1_table_offset
;
618 if (s
->nb_snapshots
>= QCOW_MAX_SNAPSHOTS
) {
622 if (has_data_file(bs
)) {
626 memset(sn
, 0, sizeof(*sn
));
629 find_new_snapshot_id(bs
, sn_info
->id_str
, sizeof(sn_info
->id_str
));
631 /* Populate sn with passed data */
632 sn
->id_str
= g_strdup(sn_info
->id_str
);
633 sn
->name
= g_strdup(sn_info
->name
);
635 sn
->disk_size
= bs
->total_sectors
* BDRV_SECTOR_SIZE
;
636 sn
->vm_state_size
= sn_info
->vm_state_size
;
637 sn
->date_sec
= sn_info
->date_sec
;
638 sn
->date_nsec
= sn_info
->date_nsec
;
639 sn
->vm_clock_nsec
= sn_info
->vm_clock_nsec
;
640 sn
->extra_data_size
= sizeof(QCowSnapshotExtraData
);
642 /* Allocate the L1 table of the snapshot and copy the current one there. */
643 l1_table_offset
= qcow2_alloc_clusters(bs
, s
->l1_size
* sizeof(uint64_t));
644 if (l1_table_offset
< 0) {
645 ret
= l1_table_offset
;
649 sn
->l1_table_offset
= l1_table_offset
;
650 sn
->l1_size
= s
->l1_size
;
652 l1_table
= g_try_new(uint64_t, s
->l1_size
);
653 if (s
->l1_size
&& l1_table
== NULL
) {
658 for(i
= 0; i
< s
->l1_size
; i
++) {
659 l1_table
[i
] = cpu_to_be64(s
->l1_table
[i
]);
662 ret
= qcow2_pre_write_overlap_check(bs
, 0, sn
->l1_table_offset
,
663 s
->l1_size
* sizeof(uint64_t), false);
668 ret
= bdrv_pwrite(bs
->file
, sn
->l1_table_offset
, l1_table
,
669 s
->l1_size
* sizeof(uint64_t));
678 * Increase the refcounts of all clusters and make sure everything is
679 * stable on disk before updating the snapshot table to contain a pointer
680 * to the new L1 table.
682 ret
= qcow2_update_snapshot_refcount(bs
, s
->l1_table_offset
, s
->l1_size
, 1);
687 /* Append the new snapshot to the snapshot list */
688 new_snapshot_list
= g_new(QCowSnapshot
, s
->nb_snapshots
+ 1);
690 memcpy(new_snapshot_list
, s
->snapshots
,
691 s
->nb_snapshots
* sizeof(QCowSnapshot
));
692 old_snapshot_list
= s
->snapshots
;
694 s
->snapshots
= new_snapshot_list
;
695 s
->snapshots
[s
->nb_snapshots
++] = *sn
;
697 ret
= qcow2_write_snapshots(bs
);
699 g_free(s
->snapshots
);
700 s
->snapshots
= old_snapshot_list
;
705 g_free(old_snapshot_list
);
707 /* The VM state isn't needed any more in the active L1 table; in fact, it
708 * hurts by causing expensive COW for the next snapshot. */
709 qcow2_cluster_discard(bs
, qcow2_vm_state_offset(s
),
710 ROUND_UP(sn
->vm_state_size
, s
->cluster_size
),
711 QCOW2_DISCARD_NEVER
, false);
715 BdrvCheckResult result
= {0};
716 qcow2_check_refcounts(bs
, &result
, 0);
729 /* copy the snapshot 'snapshot_name' into the current disk image */
730 int qcow2_snapshot_goto(BlockDriverState
*bs
, const char *snapshot_id
)
732 BDRVQcow2State
*s
= bs
->opaque
;
734 Error
*local_err
= NULL
;
735 int i
, snapshot_index
;
736 int cur_l1_bytes
, sn_l1_bytes
;
738 uint64_t *sn_l1_table
= NULL
;
740 if (has_data_file(bs
)) {
744 /* Search the snapshot */
745 snapshot_index
= find_snapshot_by_id_or_name(bs
, snapshot_id
);
746 if (snapshot_index
< 0) {
749 sn
= &s
->snapshots
[snapshot_index
];
751 ret
= qcow2_validate_table(bs
, sn
->l1_table_offset
, sn
->l1_size
,
752 sizeof(uint64_t), QCOW_MAX_L1_SIZE
,
753 "Snapshot L1 table", &local_err
);
755 error_report_err(local_err
);
759 if (sn
->disk_size
!= bs
->total_sectors
* BDRV_SECTOR_SIZE
) {
760 error_report("qcow2: Loading snapshots with different disk "
761 "size is not implemented");
767 * Make sure that the current L1 table is big enough to contain the whole
768 * L1 table of the snapshot. If the snapshot L1 table is smaller, the
769 * current one must be padded with zeros.
771 ret
= qcow2_grow_l1_table(bs
, sn
->l1_size
, true);
776 cur_l1_bytes
= s
->l1_size
* sizeof(uint64_t);
777 sn_l1_bytes
= sn
->l1_size
* sizeof(uint64_t);
780 * Copy the snapshot L1 table to the current L1 table.
782 * Before overwriting the old current L1 table on disk, make sure to
783 * increase all refcounts for the clusters referenced by the new one.
784 * Decrease the refcount referenced by the old one only when the L1
785 * table is overwritten.
787 sn_l1_table
= g_try_malloc0(cur_l1_bytes
);
788 if (cur_l1_bytes
&& sn_l1_table
== NULL
) {
793 ret
= bdrv_pread(bs
->file
, sn
->l1_table_offset
,
794 sn_l1_table
, sn_l1_bytes
);
799 ret
= qcow2_update_snapshot_refcount(bs
, sn
->l1_table_offset
,
805 ret
= qcow2_pre_write_overlap_check(bs
, QCOW2_OL_ACTIVE_L1
,
806 s
->l1_table_offset
, cur_l1_bytes
,
812 ret
= bdrv_pwrite_sync(bs
->file
, s
->l1_table_offset
, sn_l1_table
,
819 * Decrease refcount of clusters of current L1 table.
821 * At this point, the in-memory s->l1_table points to the old L1 table,
822 * whereas on disk we already have the new one.
824 * qcow2_update_snapshot_refcount special cases the current L1 table to use
825 * the in-memory data instead of really using the offset to load a new one,
826 * which is why this works.
828 ret
= qcow2_update_snapshot_refcount(bs
, s
->l1_table_offset
,
832 * Now update the in-memory L1 table to be in sync with the on-disk one. We
833 * need to do this even if updating refcounts failed.
835 for(i
= 0;i
< s
->l1_size
; i
++) {
836 s
->l1_table
[i
] = be64_to_cpu(sn_l1_table
[i
]);
847 * Update QCOW_OFLAG_COPIED in the active L1 table (it may have changed
848 * when we decreased the refcount of the old snapshot.
850 ret
= qcow2_update_snapshot_refcount(bs
, s
->l1_table_offset
, s
->l1_size
, 0);
857 BdrvCheckResult result
= {0};
858 qcow2_check_refcounts(bs
, &result
, 0);
868 int qcow2_snapshot_delete(BlockDriverState
*bs
,
869 const char *snapshot_id
,
873 BDRVQcow2State
*s
= bs
->opaque
;
875 int snapshot_index
, ret
;
877 if (has_data_file(bs
)) {
881 /* Search the snapshot */
882 snapshot_index
= find_snapshot_by_id_and_name(bs
, snapshot_id
, name
);
883 if (snapshot_index
< 0) {
884 error_setg(errp
, "Can't find the snapshot");
887 sn
= s
->snapshots
[snapshot_index
];
889 ret
= qcow2_validate_table(bs
, sn
.l1_table_offset
, sn
.l1_size
,
890 sizeof(uint64_t), QCOW_MAX_L1_SIZE
,
891 "Snapshot L1 table", errp
);
896 /* Remove it from the snapshot list */
897 memmove(s
->snapshots
+ snapshot_index
,
898 s
->snapshots
+ snapshot_index
+ 1,
899 (s
->nb_snapshots
- snapshot_index
- 1) * sizeof(sn
));
901 ret
= qcow2_write_snapshots(bs
);
903 error_setg_errno(errp
, -ret
,
904 "Failed to remove snapshot from snapshot list");
909 * The snapshot is now unused, clean up. If we fail after this point, we
910 * won't recover but just leak clusters.
912 g_free(sn
.unknown_extra_data
);
917 * Now decrease the refcounts of clusters referenced by the snapshot and
920 ret
= qcow2_update_snapshot_refcount(bs
, sn
.l1_table_offset
,
923 error_setg_errno(errp
, -ret
, "Failed to free the cluster and L1 table");
926 qcow2_free_clusters(bs
, sn
.l1_table_offset
, sn
.l1_size
* sizeof(uint64_t),
927 QCOW2_DISCARD_SNAPSHOT
);
929 /* must update the copied flag on the current cluster offsets */
930 ret
= qcow2_update_snapshot_refcount(bs
, s
->l1_table_offset
, s
->l1_size
, 0);
932 error_setg_errno(errp
, -ret
,
933 "Failed to update snapshot status in disk");
939 BdrvCheckResult result
= {0};
940 qcow2_check_refcounts(bs
, &result
, 0);
946 int qcow2_snapshot_list(BlockDriverState
*bs
, QEMUSnapshotInfo
**psn_tab
)
948 BDRVQcow2State
*s
= bs
->opaque
;
949 QEMUSnapshotInfo
*sn_tab
, *sn_info
;
953 if (has_data_file(bs
)) {
956 if (!s
->nb_snapshots
) {
958 return s
->nb_snapshots
;
961 sn_tab
= g_new0(QEMUSnapshotInfo
, s
->nb_snapshots
);
962 for(i
= 0; i
< s
->nb_snapshots
; i
++) {
963 sn_info
= sn_tab
+ i
;
964 sn
= s
->snapshots
+ i
;
965 pstrcpy(sn_info
->id_str
, sizeof(sn_info
->id_str
),
967 pstrcpy(sn_info
->name
, sizeof(sn_info
->name
),
969 sn_info
->vm_state_size
= sn
->vm_state_size
;
970 sn_info
->date_sec
= sn
->date_sec
;
971 sn_info
->date_nsec
= sn
->date_nsec
;
972 sn_info
->vm_clock_nsec
= sn
->vm_clock_nsec
;
975 return s
->nb_snapshots
;
978 int qcow2_snapshot_load_tmp(BlockDriverState
*bs
,
979 const char *snapshot_id
,
983 int i
, snapshot_index
;
984 BDRVQcow2State
*s
= bs
->opaque
;
986 uint64_t *new_l1_table
;
990 assert(bs
->read_only
);
992 /* Search the snapshot */
993 snapshot_index
= find_snapshot_by_id_and_name(bs
, snapshot_id
, name
);
994 if (snapshot_index
< 0) {
996 "Can't find snapshot");
999 sn
= &s
->snapshots
[snapshot_index
];
1001 /* Allocate and read in the snapshot's L1 table */
1002 ret
= qcow2_validate_table(bs
, sn
->l1_table_offset
, sn
->l1_size
,
1003 sizeof(uint64_t), QCOW_MAX_L1_SIZE
,
1004 "Snapshot L1 table", errp
);
1008 new_l1_bytes
= sn
->l1_size
* sizeof(uint64_t);
1009 new_l1_table
= qemu_try_blockalign(bs
->file
->bs
,
1010 ROUND_UP(new_l1_bytes
, 512));
1011 if (new_l1_table
== NULL
) {
1015 ret
= bdrv_pread(bs
->file
, sn
->l1_table_offset
,
1016 new_l1_table
, new_l1_bytes
);
1018 error_setg(errp
, "Failed to read l1 table for snapshot");
1019 qemu_vfree(new_l1_table
);
1023 /* Switch the L1 table */
1024 qemu_vfree(s
->l1_table
);
1026 s
->l1_size
= sn
->l1_size
;
1027 s
->l1_table_offset
= sn
->l1_table_offset
;
1028 s
->l1_table
= new_l1_table
;
1030 for(i
= 0;i
< s
->l1_size
; i
++) {
1031 be64_to_cpus(&s
->l1_table
[i
]);