]>
Commit | Line | Data |
---|---|---|
c142442b KW |
1 | /* |
2 | * Block driver for the QCOW version 2 format | |
3 | * | |
4 | * Copyright (c) 2004-2006 Fabrice Bellard | |
5 | * | |
6 | * Permission is hereby granted, free of charge, to any person obtaining a copy | |
7 | * of this software and associated documentation files (the "Software"), to deal | |
8 | * in the Software without restriction, including without limitation the rights | |
9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
10 | * copies of the Software, and to permit persons to whom the Software is | |
11 | * furnished to do so, subject to the following conditions: | |
12 | * | |
13 | * The above copyright notice and this permission notice shall be included in | |
14 | * all copies or substantial portions of the Software. | |
15 | * | |
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | |
19 | * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
22 | * THE SOFTWARE. | |
23 | */ | |
24 | ||
25 | #include "qemu-common.h" | |
26 | #include "block_int.h" | |
27 | #include "block/qcow2.h" | |
28 | ||
541dc0d4 | 29 | typedef struct QEMU_PACKED QCowSnapshotHeader { |
c142442b KW |
30 | /* header is 8 byte aligned */ |
31 | uint64_t l1_table_offset; | |
32 | ||
33 | uint32_t l1_size; | |
34 | uint16_t id_str_size; | |
35 | uint16_t name_size; | |
36 | ||
37 | uint32_t date_sec; | |
38 | uint32_t date_nsec; | |
39 | ||
40 | uint64_t vm_clock_nsec; | |
41 | ||
42 | uint32_t vm_state_size; | |
43 | uint32_t extra_data_size; /* for extension */ | |
44 | /* extra data follows */ | |
45 | /* id_str follows */ | |
46 | /* name follows */ | |
47 | } QCowSnapshotHeader; | |
48 | ||
c2c9a466 KW |
49 | typedef struct QEMU_PACKED QCowSnapshotExtraData { |
50 | uint64_t vm_state_size_large; | |
51 | } QCowSnapshotExtraData; | |
52 | ||
ed6ccf0f | 53 | void qcow2_free_snapshots(BlockDriverState *bs) |
c142442b KW |
54 | { |
55 | BDRVQcowState *s = bs->opaque; | |
56 | int i; | |
57 | ||
58 | for(i = 0; i < s->nb_snapshots; i++) { | |
7267c094 AL |
59 | g_free(s->snapshots[i].name); |
60 | g_free(s->snapshots[i].id_str); | |
c142442b | 61 | } |
7267c094 | 62 | g_free(s->snapshots); |
c142442b KW |
63 | s->snapshots = NULL; |
64 | s->nb_snapshots = 0; | |
65 | } | |
66 | ||
ed6ccf0f | 67 | int qcow2_read_snapshots(BlockDriverState *bs) |
c142442b KW |
68 | { |
69 | BDRVQcowState *s = bs->opaque; | |
70 | QCowSnapshotHeader h; | |
c2c9a466 | 71 | QCowSnapshotExtraData extra; |
c142442b KW |
72 | QCowSnapshot *sn; |
73 | int i, id_str_size, name_size; | |
74 | int64_t offset; | |
75 | uint32_t extra_data_size; | |
42deb29f | 76 | int ret; |
c142442b KW |
77 | |
78 | if (!s->nb_snapshots) { | |
79 | s->snapshots = NULL; | |
80 | s->snapshots_size = 0; | |
81 | return 0; | |
82 | } | |
83 | ||
84 | offset = s->snapshots_offset; | |
7267c094 | 85 | s->snapshots = g_malloc0(s->nb_snapshots * sizeof(QCowSnapshot)); |
42deb29f | 86 | |
c142442b | 87 | for(i = 0; i < s->nb_snapshots; i++) { |
42deb29f | 88 | /* Read statically sized part of the snapshot header */ |
c142442b | 89 | offset = align_offset(offset, 8); |
42deb29f KW |
90 | ret = bdrv_pread(bs->file, offset, &h, sizeof(h)); |
91 | if (ret < 0) { | |
c142442b | 92 | goto fail; |
42deb29f KW |
93 | } |
94 | ||
c142442b KW |
95 | offset += sizeof(h); |
96 | sn = s->snapshots + i; | |
97 | sn->l1_table_offset = be64_to_cpu(h.l1_table_offset); | |
98 | sn->l1_size = be32_to_cpu(h.l1_size); | |
99 | sn->vm_state_size = be32_to_cpu(h.vm_state_size); | |
100 | sn->date_sec = be32_to_cpu(h.date_sec); | |
101 | sn->date_nsec = be32_to_cpu(h.date_nsec); | |
102 | sn->vm_clock_nsec = be64_to_cpu(h.vm_clock_nsec); | |
103 | extra_data_size = be32_to_cpu(h.extra_data_size); | |
104 | ||
105 | id_str_size = be16_to_cpu(h.id_str_size); | |
106 | name_size = be16_to_cpu(h.name_size); | |
107 | ||
c2c9a466 KW |
108 | /* Read extra data */ |
109 | ret = bdrv_pread(bs->file, offset, &extra, | |
110 | MIN(sizeof(extra), extra_data_size)); | |
111 | if (ret < 0) { | |
112 | goto fail; | |
113 | } | |
c142442b KW |
114 | offset += extra_data_size; |
115 | ||
c2c9a466 KW |
116 | if (extra_data_size >= 8) { |
117 | sn->vm_state_size = be64_to_cpu(extra.vm_state_size_large); | |
118 | } | |
119 | ||
42deb29f | 120 | /* Read snapshot ID */ |
7267c094 | 121 | sn->id_str = g_malloc(id_str_size + 1); |
42deb29f KW |
122 | ret = bdrv_pread(bs->file, offset, sn->id_str, id_str_size); |
123 | if (ret < 0) { | |
c142442b | 124 | goto fail; |
42deb29f | 125 | } |
c142442b KW |
126 | offset += id_str_size; |
127 | sn->id_str[id_str_size] = '\0'; | |
128 | ||
42deb29f | 129 | /* Read snapshot name */ |
7267c094 | 130 | sn->name = g_malloc(name_size + 1); |
42deb29f KW |
131 | ret = bdrv_pread(bs->file, offset, sn->name, name_size); |
132 | if (ret < 0) { | |
c142442b | 133 | goto fail; |
42deb29f | 134 | } |
c142442b KW |
135 | offset += name_size; |
136 | sn->name[name_size] = '\0'; | |
137 | } | |
42deb29f | 138 | |
c142442b KW |
139 | s->snapshots_size = offset - s->snapshots_offset; |
140 | return 0; | |
42deb29f KW |
141 | |
142 | fail: | |
ed6ccf0f | 143 | qcow2_free_snapshots(bs); |
42deb29f | 144 | return ret; |
c142442b KW |
145 | } |
146 | ||
147 | /* add at the end of the file a new list of snapshots */ | |
7c80ab3f | 148 | static int qcow2_write_snapshots(BlockDriverState *bs) |
c142442b KW |
149 | { |
150 | BDRVQcowState *s = bs->opaque; | |
151 | QCowSnapshot *sn; | |
152 | QCowSnapshotHeader h; | |
c2c9a466 | 153 | QCowSnapshotExtraData extra; |
c142442b | 154 | int i, name_size, id_str_size, snapshots_size; |
d69969c4 KW |
155 | struct { |
156 | uint32_t nb_snapshots; | |
157 | uint64_t snapshots_offset; | |
158 | } QEMU_PACKED header_data; | |
c142442b | 159 | int64_t offset, snapshots_offset; |
07fd8779 | 160 | int ret; |
c142442b KW |
161 | |
162 | /* compute the size of the snapshots */ | |
163 | offset = 0; | |
164 | for(i = 0; i < s->nb_snapshots; i++) { | |
165 | sn = s->snapshots + i; | |
166 | offset = align_offset(offset, 8); | |
167 | offset += sizeof(h); | |
c2c9a466 | 168 | offset += sizeof(extra); |
c142442b KW |
169 | offset += strlen(sn->id_str); |
170 | offset += strlen(sn->name); | |
171 | } | |
172 | snapshots_size = offset; | |
173 | ||
07fd8779 | 174 | /* Allocate space for the new snapshot list */ |
ed6ccf0f | 175 | snapshots_offset = qcow2_alloc_clusters(bs, snapshots_size); |
29216ed1 | 176 | bdrv_flush(bs->file); |
c142442b | 177 | offset = snapshots_offset; |
5d757b56 KW |
178 | if (offset < 0) { |
179 | return offset; | |
180 | } | |
c142442b | 181 | |
07fd8779 | 182 | /* Write all snapshots to the new list */ |
c142442b KW |
183 | for(i = 0; i < s->nb_snapshots; i++) { |
184 | sn = s->snapshots + i; | |
185 | memset(&h, 0, sizeof(h)); | |
186 | h.l1_table_offset = cpu_to_be64(sn->l1_table_offset); | |
187 | h.l1_size = cpu_to_be32(sn->l1_size); | |
c2c9a466 KW |
188 | /* If it doesn't fit in 32 bit, older implementations should treat it |
189 | * as a disk-only snapshot rather than truncate the VM state */ | |
190 | if (sn->vm_state_size <= 0xffffffff) { | |
191 | h.vm_state_size = cpu_to_be32(sn->vm_state_size); | |
192 | } | |
c142442b KW |
193 | h.date_sec = cpu_to_be32(sn->date_sec); |
194 | h.date_nsec = cpu_to_be32(sn->date_nsec); | |
195 | h.vm_clock_nsec = cpu_to_be64(sn->vm_clock_nsec); | |
c2c9a466 KW |
196 | h.extra_data_size = cpu_to_be32(sizeof(extra)); |
197 | ||
198 | memset(&extra, 0, sizeof(extra)); | |
199 | extra.vm_state_size_large = cpu_to_be64(sn->vm_state_size); | |
c142442b KW |
200 | |
201 | id_str_size = strlen(sn->id_str); | |
202 | name_size = strlen(sn->name); | |
203 | h.id_str_size = cpu_to_be16(id_str_size); | |
204 | h.name_size = cpu_to_be16(name_size); | |
205 | offset = align_offset(offset, 8); | |
07fd8779 KW |
206 | |
207 | ret = bdrv_pwrite(bs->file, offset, &h, sizeof(h)); | |
208 | if (ret < 0) { | |
c142442b | 209 | goto fail; |
07fd8779 | 210 | } |
c142442b | 211 | offset += sizeof(h); |
07fd8779 | 212 | |
c2c9a466 KW |
213 | ret = bdrv_pwrite(bs->file, offset, &extra, sizeof(extra)); |
214 | if (ret < 0) { | |
215 | goto fail; | |
216 | } | |
217 | offset += sizeof(extra); | |
218 | ||
07fd8779 KW |
219 | ret = bdrv_pwrite(bs->file, offset, sn->id_str, id_str_size); |
220 | if (ret < 0) { | |
c142442b | 221 | goto fail; |
07fd8779 | 222 | } |
c142442b | 223 | offset += id_str_size; |
07fd8779 KW |
224 | |
225 | ret = bdrv_pwrite(bs->file, offset, sn->name, name_size); | |
226 | if (ret < 0) { | |
c142442b | 227 | goto fail; |
07fd8779 | 228 | } |
c142442b KW |
229 | offset += name_size; |
230 | } | |
231 | ||
07fd8779 KW |
232 | /* |
233 | * Update the header to point to the new snapshot table. This requires the | |
234 | * new table and its refcounts to be stable on disk. | |
07fd8779 KW |
235 | */ |
236 | ret = bdrv_flush(bs); | |
237 | if (ret < 0) { | |
238 | goto fail; | |
239 | } | |
240 | ||
d69969c4 KW |
241 | QEMU_BUILD_BUG_ON(offsetof(QCowHeader, snapshots_offset) != |
242 | offsetof(QCowHeader, nb_snapshots) + sizeof(header_data.nb_snapshots)); | |
243 | ||
244 | header_data.nb_snapshots = cpu_to_be32(s->nb_snapshots); | |
245 | header_data.snapshots_offset = cpu_to_be64(snapshots_offset); | |
07fd8779 | 246 | |
07fd8779 | 247 | ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, nb_snapshots), |
d69969c4 | 248 | &header_data, sizeof(header_data)); |
07fd8779 | 249 | if (ret < 0) { |
c142442b | 250 | goto fail; |
07fd8779 | 251 | } |
c142442b KW |
252 | |
253 | /* free the old snapshot table */ | |
ed6ccf0f | 254 | qcow2_free_clusters(bs, s->snapshots_offset, s->snapshots_size); |
c142442b KW |
255 | s->snapshots_offset = snapshots_offset; |
256 | s->snapshots_size = snapshots_size; | |
257 | return 0; | |
07fd8779 KW |
258 | |
259 | fail: | |
260 | return ret; | |
c142442b KW |
261 | } |
262 | ||
263 | static void find_new_snapshot_id(BlockDriverState *bs, | |
264 | char *id_str, int id_str_size) | |
265 | { | |
266 | BDRVQcowState *s = bs->opaque; | |
267 | QCowSnapshot *sn; | |
268 | int i, id, id_max = 0; | |
269 | ||
270 | for(i = 0; i < s->nb_snapshots; i++) { | |
271 | sn = s->snapshots + i; | |
272 | id = strtoul(sn->id_str, NULL, 10); | |
273 | if (id > id_max) | |
274 | id_max = id; | |
275 | } | |
276 | snprintf(id_str, id_str_size, "%d", id_max + 1); | |
277 | } | |
278 | ||
279 | static int find_snapshot_by_id(BlockDriverState *bs, const char *id_str) | |
280 | { | |
281 | BDRVQcowState *s = bs->opaque; | |
282 | int i; | |
283 | ||
284 | for(i = 0; i < s->nb_snapshots; i++) { | |
285 | if (!strcmp(s->snapshots[i].id_str, id_str)) | |
286 | return i; | |
287 | } | |
288 | return -1; | |
289 | } | |
290 | ||
291 | static int find_snapshot_by_id_or_name(BlockDriverState *bs, const char *name) | |
292 | { | |
293 | BDRVQcowState *s = bs->opaque; | |
294 | int i, ret; | |
295 | ||
296 | ret = find_snapshot_by_id(bs, name); | |
297 | if (ret >= 0) | |
298 | return ret; | |
299 | for(i = 0; i < s->nb_snapshots; i++) { | |
300 | if (!strcmp(s->snapshots[i].name, name)) | |
301 | return i; | |
302 | } | |
303 | return -1; | |
304 | } | |
305 | ||
306 | /* if no id is provided, a new one is constructed */ | |
ed6ccf0f | 307 | int qcow2_snapshot_create(BlockDriverState *bs, QEMUSnapshotInfo *sn_info) |
c142442b KW |
308 | { |
309 | BDRVQcowState *s = bs->opaque; | |
d1ea98d5 KW |
310 | QCowSnapshot *new_snapshot_list = NULL; |
311 | QCowSnapshot *old_snapshot_list = NULL; | |
312 | QCowSnapshot sn1, *sn = &sn1; | |
c142442b KW |
313 | int i, ret; |
314 | uint64_t *l1_table = NULL; | |
5d757b56 | 315 | int64_t l1_table_offset; |
c142442b KW |
316 | |
317 | memset(sn, 0, sizeof(*sn)); | |
318 | ||
03343166 | 319 | /* Generate an ID if it wasn't passed */ |
c142442b | 320 | if (sn_info->id_str[0] == '\0') { |
c142442b KW |
321 | find_new_snapshot_id(bs, sn_info->id_str, sizeof(sn_info->id_str)); |
322 | } | |
323 | ||
03343166 KW |
324 | /* Check that the ID is unique */ |
325 | if (find_snapshot_by_id(bs, sn_info->id_str) >= 0) { | |
c142442b | 326 | return -ENOENT; |
03343166 | 327 | } |
c142442b | 328 | |
03343166 | 329 | /* Populate sn with passed data */ |
7267c094 | 330 | sn->id_str = g_strdup(sn_info->id_str); |
7267c094 | 331 | sn->name = g_strdup(sn_info->name); |
03343166 | 332 | |
c142442b KW |
333 | sn->vm_state_size = sn_info->vm_state_size; |
334 | sn->date_sec = sn_info->date_sec; | |
335 | sn->date_nsec = sn_info->date_nsec; | |
336 | sn->vm_clock_nsec = sn_info->vm_clock_nsec; | |
337 | ||
03343166 | 338 | /* Allocate the L1 table of the snapshot and copy the current one there. */ |
5d757b56 KW |
339 | l1_table_offset = qcow2_alloc_clusters(bs, s->l1_size * sizeof(uint64_t)); |
340 | if (l1_table_offset < 0) { | |
d1ea98d5 | 341 | ret = l1_table_offset; |
5d757b56 KW |
342 | goto fail; |
343 | } | |
344 | ||
345 | sn->l1_table_offset = l1_table_offset; | |
c142442b KW |
346 | sn->l1_size = s->l1_size; |
347 | ||
03343166 | 348 | l1_table = g_malloc(s->l1_size * sizeof(uint64_t)); |
c142442b KW |
349 | for(i = 0; i < s->l1_size; i++) { |
350 | l1_table[i] = cpu_to_be64(s->l1_table[i]); | |
351 | } | |
d1ea98d5 KW |
352 | |
353 | ret = bdrv_pwrite(bs->file, sn->l1_table_offset, l1_table, | |
354 | s->l1_size * sizeof(uint64_t)); | |
355 | if (ret < 0) { | |
c142442b | 356 | goto fail; |
d1ea98d5 KW |
357 | } |
358 | ||
7267c094 | 359 | g_free(l1_table); |
c142442b KW |
360 | l1_table = NULL; |
361 | ||
d1ea98d5 KW |
362 | /* |
363 | * Increase the refcounts of all clusters and make sure everything is | |
364 | * stable on disk before updating the snapshot table to contain a pointer | |
365 | * to the new L1 table. | |
366 | */ | |
367 | ret = qcow2_update_snapshot_refcount(bs, s->l1_table_offset, s->l1_size, 1); | |
368 | if (ret < 0) { | |
369 | goto fail; | |
370 | } | |
371 | ||
372 | ret = bdrv_flush(bs); | |
373 | if (ret < 0) { | |
374 | goto fail; | |
375 | } | |
376 | ||
377 | /* Append the new snapshot to the snapshot list */ | |
378 | new_snapshot_list = g_malloc((s->nb_snapshots + 1) * sizeof(QCowSnapshot)); | |
c142442b | 379 | if (s->snapshots) { |
d1ea98d5 KW |
380 | memcpy(new_snapshot_list, s->snapshots, |
381 | s->nb_snapshots * sizeof(QCowSnapshot)); | |
382 | old_snapshot_list = s->snapshots; | |
c142442b | 383 | } |
d1ea98d5 | 384 | s->snapshots = new_snapshot_list; |
c142442b KW |
385 | s->snapshots[s->nb_snapshots++] = *sn; |
386 | ||
d1ea98d5 KW |
387 | ret = qcow2_write_snapshots(bs); |
388 | if (ret < 0) { | |
389 | g_free(s->snapshots); | |
390 | s->snapshots = old_snapshot_list; | |
c142442b | 391 | goto fail; |
d1ea98d5 KW |
392 | } |
393 | ||
394 | g_free(old_snapshot_list); | |
395 | ||
c142442b | 396 | #ifdef DEBUG_ALLOC |
6cbc3031 PH |
397 | { |
398 | BdrvCheckResult result = {0}; | |
399 | qcow2_check_refcounts(bs, &result); | |
400 | } | |
c142442b KW |
401 | #endif |
402 | return 0; | |
03343166 KW |
403 | |
404 | fail: | |
405 | g_free(sn->id_str); | |
7267c094 AL |
406 | g_free(sn->name); |
407 | g_free(l1_table); | |
d1ea98d5 KW |
408 | |
409 | return ret; | |
c142442b KW |
410 | } |
411 | ||
412 | /* copy the snapshot 'snapshot_name' into the current disk image */ | |
ed6ccf0f | 413 | int qcow2_snapshot_goto(BlockDriverState *bs, const char *snapshot_id) |
c142442b KW |
414 | { |
415 | BDRVQcowState *s = bs->opaque; | |
416 | QCowSnapshot *sn; | |
35d7ace7 KW |
417 | int i, snapshot_index; |
418 | int cur_l1_bytes, sn_l1_bytes; | |
589f284b | 419 | int ret; |
43a0cac4 | 420 | uint64_t *sn_l1_table = NULL; |
c142442b | 421 | |
589f284b | 422 | /* Search the snapshot */ |
c142442b | 423 | snapshot_index = find_snapshot_by_id_or_name(bs, snapshot_id); |
589f284b | 424 | if (snapshot_index < 0) { |
c142442b | 425 | return -ENOENT; |
589f284b | 426 | } |
c142442b KW |
427 | sn = &s->snapshots[snapshot_index]; |
428 | ||
589f284b KW |
429 | /* |
430 | * Make sure that the current L1 table is big enough to contain the whole | |
431 | * L1 table of the snapshot. If the snapshot L1 table is smaller, the | |
432 | * current one must be padded with zeros. | |
433 | */ | |
434 | ret = qcow2_grow_l1_table(bs, sn->l1_size, true); | |
435 | if (ret < 0) { | |
c142442b | 436 | goto fail; |
589f284b | 437 | } |
c142442b | 438 | |
35d7ace7 KW |
439 | cur_l1_bytes = s->l1_size * sizeof(uint64_t); |
440 | sn_l1_bytes = sn->l1_size * sizeof(uint64_t); | |
441 | ||
589f284b KW |
442 | /* |
443 | * Copy the snapshot L1 table to the current L1 table. | |
444 | * | |
445 | * Before overwriting the old current L1 table on disk, make sure to | |
446 | * increase all refcounts for the clusters referenced by the new one. | |
43a0cac4 KW |
447 | * Decrease the refcount referenced by the old one only when the L1 |
448 | * table is overwritten. | |
589f284b | 449 | */ |
43a0cac4 KW |
450 | sn_l1_table = g_malloc0(cur_l1_bytes); |
451 | ||
452 | ret = bdrv_pread(bs->file, sn->l1_table_offset, sn_l1_table, sn_l1_bytes); | |
453 | if (ret < 0) { | |
454 | goto fail; | |
455 | } | |
456 | ||
457 | ret = qcow2_update_snapshot_refcount(bs, sn->l1_table_offset, | |
458 | sn->l1_size, 1); | |
589f284b | 459 | if (ret < 0) { |
c142442b | 460 | goto fail; |
589f284b KW |
461 | } |
462 | ||
43a0cac4 | 463 | ret = bdrv_pwrite_sync(bs->file, s->l1_table_offset, sn_l1_table, |
589f284b KW |
464 | cur_l1_bytes); |
465 | if (ret < 0) { | |
c142442b | 466 | goto fail; |
589f284b KW |
467 | } |
468 | ||
43a0cac4 KW |
469 | /* |
470 | * Decrease refcount of clusters of current L1 table. | |
471 | * | |
472 | * At this point, the in-memory s->l1_table points to the old L1 table, | |
473 | * whereas on disk we already have the new one. | |
474 | * | |
475 | * qcow2_update_snapshot_refcount special cases the current L1 table to use | |
476 | * the in-memory data instead of really using the offset to load a new one, | |
477 | * which is why this works. | |
478 | */ | |
479 | ret = qcow2_update_snapshot_refcount(bs, s->l1_table_offset, | |
480 | s->l1_size, -1); | |
481 | ||
482 | /* | |
483 | * Now update the in-memory L1 table to be in sync with the on-disk one. We | |
484 | * need to do this even if updating refcounts failed. | |
485 | */ | |
c142442b | 486 | for(i = 0;i < s->l1_size; i++) { |
43a0cac4 | 487 | s->l1_table[i] = be64_to_cpu(sn_l1_table[i]); |
c142442b KW |
488 | } |
489 | ||
43a0cac4 KW |
490 | if (ret < 0) { |
491 | goto fail; | |
492 | } | |
493 | ||
494 | g_free(sn_l1_table); | |
495 | sn_l1_table = NULL; | |
496 | ||
497 | /* | |
498 | * Update QCOW_OFLAG_COPIED in the active L1 table (it may have changed | |
499 | * when we decreased the refcount of the old snapshot. | |
500 | */ | |
501 | ret = qcow2_update_snapshot_refcount(bs, s->l1_table_offset, s->l1_size, 0); | |
589f284b | 502 | if (ret < 0) { |
c142442b | 503 | goto fail; |
589f284b | 504 | } |
c142442b KW |
505 | |
506 | #ifdef DEBUG_ALLOC | |
6cbc3031 PH |
507 | { |
508 | BdrvCheckResult result = {0}; | |
509 | qcow2_check_refcounts(bs, &result); | |
510 | } | |
c142442b KW |
511 | #endif |
512 | return 0; | |
589f284b KW |
513 | |
514 | fail: | |
43a0cac4 | 515 | g_free(sn_l1_table); |
589f284b | 516 | return ret; |
c142442b KW |
517 | } |
518 | ||
ed6ccf0f | 519 | int qcow2_snapshot_delete(BlockDriverState *bs, const char *snapshot_id) |
c142442b KW |
520 | { |
521 | BDRVQcowState *s = bs->opaque; | |
9a476780 | 522 | QCowSnapshot sn; |
c142442b KW |
523 | int snapshot_index, ret; |
524 | ||
9a476780 | 525 | /* Search the snapshot */ |
c142442b | 526 | snapshot_index = find_snapshot_by_id_or_name(bs, snapshot_id); |
9a476780 | 527 | if (snapshot_index < 0) { |
c142442b | 528 | return -ENOENT; |
9a476780 KW |
529 | } |
530 | sn = s->snapshots[snapshot_index]; | |
c142442b | 531 | |
9a476780 KW |
532 | /* Remove it from the snapshot list */ |
533 | memmove(s->snapshots + snapshot_index, | |
534 | s->snapshots + snapshot_index + 1, | |
535 | (s->nb_snapshots - snapshot_index - 1) * sizeof(sn)); | |
536 | s->nb_snapshots--; | |
537 | ret = qcow2_write_snapshots(bs); | |
538 | if (ret < 0) { | |
c142442b | 539 | return ret; |
9a476780 KW |
540 | } |
541 | ||
542 | /* | |
543 | * The snapshot is now unused, clean up. If we fail after this point, we | |
544 | * won't recover but just leak clusters. | |
545 | */ | |
546 | g_free(sn.id_str); | |
547 | g_free(sn.name); | |
548 | ||
549 | /* | |
550 | * Now decrease the refcounts of clusters referenced by the snapshot and | |
551 | * free the L1 table. | |
552 | */ | |
553 | ret = qcow2_update_snapshot_refcount(bs, sn.l1_table_offset, | |
554 | sn.l1_size, -1); | |
555 | if (ret < 0) { | |
c142442b | 556 | return ret; |
9a476780 KW |
557 | } |
558 | qcow2_free_clusters(bs, sn.l1_table_offset, sn.l1_size * sizeof(uint64_t)); | |
c142442b | 559 | |
9a476780 KW |
560 | /* must update the copied flag on the current cluster offsets */ |
561 | ret = qcow2_update_snapshot_refcount(bs, s->l1_table_offset, s->l1_size, 0); | |
c142442b | 562 | if (ret < 0) { |
c142442b KW |
563 | return ret; |
564 | } | |
9a476780 | 565 | |
c142442b | 566 | #ifdef DEBUG_ALLOC |
6cbc3031 PH |
567 | { |
568 | BdrvCheckResult result = {0}; | |
569 | qcow2_check_refcounts(bs, &result); | |
570 | } | |
c142442b KW |
571 | #endif |
572 | return 0; | |
573 | } | |
574 | ||
ed6ccf0f | 575 | int qcow2_snapshot_list(BlockDriverState *bs, QEMUSnapshotInfo **psn_tab) |
c142442b KW |
576 | { |
577 | BDRVQcowState *s = bs->opaque; | |
578 | QEMUSnapshotInfo *sn_tab, *sn_info; | |
579 | QCowSnapshot *sn; | |
580 | int i; | |
581 | ||
582 | if (!s->nb_snapshots) { | |
583 | *psn_tab = NULL; | |
584 | return s->nb_snapshots; | |
585 | } | |
586 | ||
7267c094 | 587 | sn_tab = g_malloc0(s->nb_snapshots * sizeof(QEMUSnapshotInfo)); |
c142442b KW |
588 | for(i = 0; i < s->nb_snapshots; i++) { |
589 | sn_info = sn_tab + i; | |
590 | sn = s->snapshots + i; | |
591 | pstrcpy(sn_info->id_str, sizeof(sn_info->id_str), | |
592 | sn->id_str); | |
593 | pstrcpy(sn_info->name, sizeof(sn_info->name), | |
594 | sn->name); | |
595 | sn_info->vm_state_size = sn->vm_state_size; | |
596 | sn_info->date_sec = sn->date_sec; | |
597 | sn_info->date_nsec = sn->date_nsec; | |
598 | sn_info->vm_clock_nsec = sn->vm_clock_nsec; | |
599 | } | |
600 | *psn_tab = sn_tab; | |
601 | return s->nb_snapshots; | |
602 | } | |
603 | ||
51ef6727 | 604 | int qcow2_snapshot_load_tmp(BlockDriverState *bs, const char *snapshot_name) |
605 | { | |
e3f652b3 | 606 | int i, snapshot_index; |
51ef6727 | 607 | BDRVQcowState *s = bs->opaque; |
608 | QCowSnapshot *sn; | |
e3f652b3 KW |
609 | uint64_t *new_l1_table; |
610 | int new_l1_bytes; | |
611 | int ret; | |
51ef6727 | 612 | |
e3f652b3 KW |
613 | assert(bs->read_only); |
614 | ||
615 | /* Search the snapshot */ | |
51ef6727 | 616 | snapshot_index = find_snapshot_by_id_or_name(bs, snapshot_name); |
617 | if (snapshot_index < 0) { | |
618 | return -ENOENT; | |
619 | } | |
51ef6727 | 620 | sn = &s->snapshots[snapshot_index]; |
51ef6727 | 621 | |
e3f652b3 KW |
622 | /* Allocate and read in the snapshot's L1 table */ |
623 | new_l1_bytes = s->l1_size * sizeof(uint64_t); | |
624 | new_l1_table = g_malloc0(align_offset(new_l1_bytes, 512)); | |
51ef6727 | 625 | |
e3f652b3 KW |
626 | ret = bdrv_pread(bs->file, sn->l1_table_offset, new_l1_table, new_l1_bytes); |
627 | if (ret < 0) { | |
628 | g_free(new_l1_table); | |
629 | return ret; | |
51ef6727 | 630 | } |
631 | ||
e3f652b3 KW |
632 | /* Switch the L1 table */ |
633 | g_free(s->l1_table); | |
634 | ||
635 | s->l1_size = sn->l1_size; | |
636 | s->l1_table_offset = sn->l1_table_offset; | |
637 | s->l1_table = new_l1_table; | |
638 | ||
51ef6727 | 639 | for(i = 0;i < s->l1_size; i++) { |
640 | be64_to_cpus(&s->l1_table[i]); | |
641 | } | |
e3f652b3 | 642 | |
51ef6727 | 643 | return 0; |
644 | } |