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 "qapi/error.h"
27#include "block/block_int.h"
28#include "block/qcow2.h"
29#include "qemu/bswap.h"
30#include "qemu/error-report.h"
31#include "qemu/cutils.h"
32
33void qcow2_free_snapshots(BlockDriverState *bs)
34{
35 BDRVQcow2State *s = bs->opaque;
36 int i;
37
38 for(i = 0; i < s->nb_snapshots; i++) {
39 g_free(s->snapshots[i].name);
40 g_free(s->snapshots[i].id_str);
41 }
42 g_free(s->snapshots);
43 s->snapshots = NULL;
44 s->nb_snapshots = 0;
45}
46
47int qcow2_read_snapshots(BlockDriverState *bs)
48{
49 BDRVQcow2State *s = bs->opaque;
50 QCowSnapshotHeader h;
51 QCowSnapshotExtraData extra;
52 QCowSnapshot *sn;
53 int i, id_str_size, name_size;
54 int64_t offset;
55 uint32_t extra_data_size;
56 int ret;
57
58 if (!s->nb_snapshots) {
59 s->snapshots = NULL;
60 s->snapshots_size = 0;
61 return 0;
62 }
63
64 offset = s->snapshots_offset;
65 s->snapshots = g_new0(QCowSnapshot, s->nb_snapshots);
66
67 for(i = 0; i < s->nb_snapshots; i++) {
68
69 offset = align_offset(offset, 8);
70 ret = bdrv_pread(bs->file, offset, &h, sizeof(h));
71 if (ret < 0) {
72 goto fail;
73 }
74
75 offset += sizeof(h);
76 sn = s->snapshots + i;
77 sn->l1_table_offset = be64_to_cpu(h.l1_table_offset);
78 sn->l1_size = be32_to_cpu(h.l1_size);
79 sn->vm_state_size = be32_to_cpu(h.vm_state_size);
80 sn->date_sec = be32_to_cpu(h.date_sec);
81 sn->date_nsec = be32_to_cpu(h.date_nsec);
82 sn->vm_clock_nsec = be64_to_cpu(h.vm_clock_nsec);
83 extra_data_size = be32_to_cpu(h.extra_data_size);
84
85 id_str_size = be16_to_cpu(h.id_str_size);
86 name_size = be16_to_cpu(h.name_size);
87
88
89 ret = bdrv_pread(bs->file, offset, &extra,
90 MIN(sizeof(extra), extra_data_size));
91 if (ret < 0) {
92 goto fail;
93 }
94 offset += extra_data_size;
95
96 if (extra_data_size >= 8) {
97 sn->vm_state_size = be64_to_cpu(extra.vm_state_size_large);
98 }
99
100 if (extra_data_size >= 16) {
101 sn->disk_size = be64_to_cpu(extra.disk_size);
102 } else {
103 sn->disk_size = bs->total_sectors * BDRV_SECTOR_SIZE;
104 }
105
106
107 sn->id_str = g_malloc(id_str_size + 1);
108 ret = bdrv_pread(bs->file, offset, sn->id_str, id_str_size);
109 if (ret < 0) {
110 goto fail;
111 }
112 offset += id_str_size;
113 sn->id_str[id_str_size] = '\0';
114
115
116 sn->name = g_malloc(name_size + 1);
117 ret = bdrv_pread(bs->file, offset, sn->name, name_size);
118 if (ret < 0) {
119 goto fail;
120 }
121 offset += name_size;
122 sn->name[name_size] = '\0';
123
124 if (offset - s->snapshots_offset > QCOW_MAX_SNAPSHOTS_SIZE) {
125 ret = -EFBIG;
126 goto fail;
127 }
128 }
129
130 assert(offset - s->snapshots_offset <= INT_MAX);
131 s->snapshots_size = offset - s->snapshots_offset;
132 return 0;
133
134fail:
135 qcow2_free_snapshots(bs);
136 return ret;
137}
138
139
140static int qcow2_write_snapshots(BlockDriverState *bs)
141{
142 BDRVQcow2State *s = bs->opaque;
143 QCowSnapshot *sn;
144 QCowSnapshotHeader h;
145 QCowSnapshotExtraData extra;
146 int i, name_size, id_str_size, snapshots_size;
147 struct {
148 uint32_t nb_snapshots;
149 uint64_t snapshots_offset;
150 } QEMU_PACKED header_data;
151 int64_t offset, snapshots_offset = 0;
152 int ret;
153
154
155 offset = 0;
156 for(i = 0; i < s->nb_snapshots; i++) {
157 sn = s->snapshots + i;
158 offset = align_offset(offset, 8);
159 offset += sizeof(h);
160 offset += sizeof(extra);
161 offset += strlen(sn->id_str);
162 offset += strlen(sn->name);
163
164 if (offset > QCOW_MAX_SNAPSHOTS_SIZE) {
165 ret = -EFBIG;
166 goto fail;
167 }
168 }
169
170 assert(offset <= INT_MAX);
171 snapshots_size = offset;
172
173
174 snapshots_offset = qcow2_alloc_clusters(bs, snapshots_size);
175 offset = snapshots_offset;
176 if (offset < 0) {
177 ret = offset;
178 goto fail;
179 }
180 ret = bdrv_flush(bs);
181 if (ret < 0) {
182 goto fail;
183 }
184
185
186
187 ret = qcow2_pre_write_overlap_check(bs, 0, offset, snapshots_size);
188 if (ret < 0) {
189 goto fail;
190 }
191
192
193
194 for(i = 0; i < s->nb_snapshots; i++) {
195 sn = s->snapshots + i;
196 memset(&h, 0, sizeof(h));
197 h.l1_table_offset = cpu_to_be64(sn->l1_table_offset);
198 h.l1_size = cpu_to_be32(sn->l1_size);
199
200
201 if (sn->vm_state_size <= 0xffffffff) {
202 h.vm_state_size = cpu_to_be32(sn->vm_state_size);
203 }
204 h.date_sec = cpu_to_be32(sn->date_sec);
205 h.date_nsec = cpu_to_be32(sn->date_nsec);
206 h.vm_clock_nsec = cpu_to_be64(sn->vm_clock_nsec);
207 h.extra_data_size = cpu_to_be32(sizeof(extra));
208
209 memset(&extra, 0, sizeof(extra));
210 extra.vm_state_size_large = cpu_to_be64(sn->vm_state_size);
211 extra.disk_size = cpu_to_be64(sn->disk_size);
212
213 id_str_size = strlen(sn->id_str);
214 name_size = strlen(sn->name);
215 assert(id_str_size <= UINT16_MAX && name_size <= UINT16_MAX);
216 h.id_str_size = cpu_to_be16(id_str_size);
217 h.name_size = cpu_to_be16(name_size);
218 offset = align_offset(offset, 8);
219
220 ret = bdrv_pwrite(bs->file, offset, &h, sizeof(h));
221 if (ret < 0) {
222 goto fail;
223 }
224 offset += sizeof(h);
225
226 ret = bdrv_pwrite(bs->file, offset, &extra, sizeof(extra));
227 if (ret < 0) {
228 goto fail;
229 }
230 offset += sizeof(extra);
231
232 ret = bdrv_pwrite(bs->file, offset, sn->id_str, id_str_size);
233 if (ret < 0) {
234 goto fail;
235 }
236 offset += id_str_size;
237
238 ret = bdrv_pwrite(bs->file, offset, sn->name, name_size);
239 if (ret < 0) {
240 goto fail;
241 }
242 offset += name_size;
243 }
244
245
246
247
248
249 ret = bdrv_flush(bs);
250 if (ret < 0) {
251 goto fail;
252 }
253
254 QEMU_BUILD_BUG_ON(offsetof(QCowHeader, snapshots_offset) !=
255 offsetof(QCowHeader, nb_snapshots) + sizeof(header_data.nb_snapshots));
256
257 header_data.nb_snapshots = cpu_to_be32(s->nb_snapshots);
258 header_data.snapshots_offset = cpu_to_be64(snapshots_offset);
259
260 ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, nb_snapshots),
261 &header_data, sizeof(header_data));
262 if (ret < 0) {
263 goto fail;
264 }
265
266
267 qcow2_free_clusters(bs, s->snapshots_offset, s->snapshots_size,
268 QCOW2_DISCARD_SNAPSHOT);
269 s->snapshots_offset = snapshots_offset;
270 s->snapshots_size = snapshots_size;
271 return 0;
272
273fail:
274 if (snapshots_offset > 0) {
275 qcow2_free_clusters(bs, snapshots_offset, snapshots_size,
276 QCOW2_DISCARD_ALWAYS);
277 }
278 return ret;
279}
280
281static void find_new_snapshot_id(BlockDriverState *bs,
282 char *id_str, int id_str_size)
283{
284 BDRVQcow2State *s = bs->opaque;
285 QCowSnapshot *sn;
286 int i;
287 unsigned long id, id_max = 0;
288
289 for(i = 0; i < s->nb_snapshots; i++) {
290 sn = s->snapshots + i;
291 id = strtoul(sn->id_str, NULL, 10);
292 if (id > id_max)
293 id_max = id;
294 }
295 snprintf(id_str, id_str_size, "%lu", id_max + 1);
296}
297
298static int find_snapshot_by_id_and_name(BlockDriverState *bs,
299 const char *id,
300 const char *name)
301{
302 BDRVQcow2State *s = bs->opaque;
303 int i;
304
305 if (id && name) {
306 for (i = 0; i < s->nb_snapshots; i++) {
307 if (!strcmp(s->snapshots[i].id_str, id) &&
308 !strcmp(s->snapshots[i].name, name)) {
309 return i;
310 }
311 }
312 } else if (id) {
313 for (i = 0; i < s->nb_snapshots; i++) {
314 if (!strcmp(s->snapshots[i].id_str, id)) {
315 return i;
316 }
317 }
318 } else if (name) {
319 for (i = 0; i < s->nb_snapshots; i++) {
320 if (!strcmp(s->snapshots[i].name, name)) {
321 return i;
322 }
323 }
324 }
325
326 return -1;
327}
328
329static int find_snapshot_by_id_or_name(BlockDriverState *bs,
330 const char *id_or_name)
331{
332 int ret;
333
334 ret = find_snapshot_by_id_and_name(bs, id_or_name, NULL);
335 if (ret >= 0) {
336 return ret;
337 }
338 return find_snapshot_by_id_and_name(bs, NULL, id_or_name);
339}
340
341
342int qcow2_snapshot_create(BlockDriverState *bs, QEMUSnapshotInfo *sn_info)
343{
344 BDRVQcow2State *s = bs->opaque;
345 QCowSnapshot *new_snapshot_list = NULL;
346 QCowSnapshot *old_snapshot_list = NULL;
347 QCowSnapshot sn1, *sn = &sn1;
348 int i, ret;
349 uint64_t *l1_table = NULL;
350 int64_t l1_table_offset;
351
352 if (s->nb_snapshots >= QCOW_MAX_SNAPSHOTS) {
353 return -EFBIG;
354 }
355
356 memset(sn, 0, sizeof(*sn));
357
358
359 find_new_snapshot_id(bs, sn_info->id_str, sizeof(sn_info->id_str));
360
361
362 if (find_snapshot_by_id_and_name(bs, sn_info->id_str, NULL) >= 0) {
363 return -EEXIST;
364 }
365
366
367 sn->id_str = g_strdup(sn_info->id_str);
368 sn->name = g_strdup(sn_info->name);
369
370 sn->disk_size = bs->total_sectors * BDRV_SECTOR_SIZE;
371 sn->vm_state_size = sn_info->vm_state_size;
372 sn->date_sec = sn_info->date_sec;
373 sn->date_nsec = sn_info->date_nsec;
374 sn->vm_clock_nsec = sn_info->vm_clock_nsec;
375
376
377 l1_table_offset = qcow2_alloc_clusters(bs, s->l1_size * sizeof(uint64_t));
378 if (l1_table_offset < 0) {
379 ret = l1_table_offset;
380 goto fail;
381 }
382
383 sn->l1_table_offset = l1_table_offset;
384 sn->l1_size = s->l1_size;
385
386 l1_table = g_try_new(uint64_t, s->l1_size);
387 if (s->l1_size && l1_table == NULL) {
388 ret = -ENOMEM;
389 goto fail;
390 }
391
392 for(i = 0; i < s->l1_size; i++) {
393 l1_table[i] = cpu_to_be64(s->l1_table[i]);
394 }
395
396 ret = qcow2_pre_write_overlap_check(bs, 0, sn->l1_table_offset,
397 s->l1_size * sizeof(uint64_t));
398 if (ret < 0) {
399 goto fail;
400 }
401
402 ret = bdrv_pwrite(bs->file, sn->l1_table_offset, l1_table,
403 s->l1_size * sizeof(uint64_t));
404 if (ret < 0) {
405 goto fail;
406 }
407
408 g_free(l1_table);
409 l1_table = NULL;
410
411
412
413
414
415
416 ret = qcow2_update_snapshot_refcount(bs, s->l1_table_offset, s->l1_size, 1);
417 if (ret < 0) {
418 goto fail;
419 }
420
421
422 new_snapshot_list = g_new(QCowSnapshot, s->nb_snapshots + 1);
423 if (s->snapshots) {
424 memcpy(new_snapshot_list, s->snapshots,
425 s->nb_snapshots * sizeof(QCowSnapshot));
426 old_snapshot_list = s->snapshots;
427 }
428 s->snapshots = new_snapshot_list;
429 s->snapshots[s->nb_snapshots++] = *sn;
430
431 ret = qcow2_write_snapshots(bs);
432 if (ret < 0) {
433 g_free(s->snapshots);
434 s->snapshots = old_snapshot_list;
435 s->nb_snapshots--;
436 goto fail;
437 }
438
439 g_free(old_snapshot_list);
440
441
442
443 qcow2_cluster_discard(bs, qcow2_vm_state_offset(s),
444 align_offset(sn->vm_state_size, s->cluster_size),
445 QCOW2_DISCARD_NEVER, false);
446
447#ifdef DEBUG_ALLOC
448 {
449 BdrvCheckResult result = {0};
450 qcow2_check_refcounts(bs, &result, 0);
451 }
452#endif
453 return 0;
454
455fail:
456 g_free(sn->id_str);
457 g_free(sn->name);
458 g_free(l1_table);
459
460 return ret;
461}
462
463
464int qcow2_snapshot_goto(BlockDriverState *bs, const char *snapshot_id)
465{
466 BDRVQcow2State *s = bs->opaque;
467 QCowSnapshot *sn;
468 int i, snapshot_index;
469 int cur_l1_bytes, sn_l1_bytes;
470 int ret;
471 uint64_t *sn_l1_table = NULL;
472
473
474 snapshot_index = find_snapshot_by_id_or_name(bs, snapshot_id);
475 if (snapshot_index < 0) {
476 return -ENOENT;
477 }
478 sn = &s->snapshots[snapshot_index];
479
480 if (sn->disk_size != bs->total_sectors * BDRV_SECTOR_SIZE) {
481 error_report("qcow2: Loading snapshots with different disk "
482 "size is not implemented");
483 ret = -ENOTSUP;
484 goto fail;
485 }
486
487
488
489
490
491
492 ret = qcow2_grow_l1_table(bs, sn->l1_size, true);
493 if (ret < 0) {
494 goto fail;
495 }
496
497 cur_l1_bytes = s->l1_size * sizeof(uint64_t);
498 sn_l1_bytes = sn->l1_size * sizeof(uint64_t);
499
500
501
502
503
504
505
506
507
508 sn_l1_table = g_try_malloc0(cur_l1_bytes);
509 if (cur_l1_bytes && sn_l1_table == NULL) {
510 ret = -ENOMEM;
511 goto fail;
512 }
513
514 ret = bdrv_pread(bs->file, sn->l1_table_offset,
515 sn_l1_table, sn_l1_bytes);
516 if (ret < 0) {
517 goto fail;
518 }
519
520 ret = qcow2_update_snapshot_refcount(bs, sn->l1_table_offset,
521 sn->l1_size, 1);
522 if (ret < 0) {
523 goto fail;
524 }
525
526 ret = qcow2_pre_write_overlap_check(bs, QCOW2_OL_ACTIVE_L1,
527 s->l1_table_offset, cur_l1_bytes);
528 if (ret < 0) {
529 goto fail;
530 }
531
532 ret = bdrv_pwrite_sync(bs->file, s->l1_table_offset, sn_l1_table,
533 cur_l1_bytes);
534 if (ret < 0) {
535 goto fail;
536 }
537
538
539
540
541
542
543
544
545
546
547
548 ret = qcow2_update_snapshot_refcount(bs, s->l1_table_offset,
549 s->l1_size, -1);
550
551
552
553
554
555 for(i = 0;i < s->l1_size; i++) {
556 s->l1_table[i] = be64_to_cpu(sn_l1_table[i]);
557 }
558
559 if (ret < 0) {
560 goto fail;
561 }
562
563 g_free(sn_l1_table);
564 sn_l1_table = NULL;
565
566
567
568
569
570 ret = qcow2_update_snapshot_refcount(bs, s->l1_table_offset, s->l1_size, 0);
571 if (ret < 0) {
572 goto fail;
573 }
574
575#ifdef DEBUG_ALLOC
576 {
577 BdrvCheckResult result = {0};
578 qcow2_check_refcounts(bs, &result, 0);
579 }
580#endif
581 return 0;
582
583fail:
584 g_free(sn_l1_table);
585 return ret;
586}
587
588int qcow2_snapshot_delete(BlockDriverState *bs,
589 const char *snapshot_id,
590 const char *name,
591 Error **errp)
592{
593 BDRVQcow2State *s = bs->opaque;
594 QCowSnapshot sn;
595 int snapshot_index, ret;
596
597
598 snapshot_index = find_snapshot_by_id_and_name(bs, snapshot_id, name);
599 if (snapshot_index < 0) {
600 error_setg(errp, "Can't find the snapshot");
601 return -ENOENT;
602 }
603 sn = s->snapshots[snapshot_index];
604
605
606 memmove(s->snapshots + snapshot_index,
607 s->snapshots + snapshot_index + 1,
608 (s->nb_snapshots - snapshot_index - 1) * sizeof(sn));
609 s->nb_snapshots--;
610 ret = qcow2_write_snapshots(bs);
611 if (ret < 0) {
612 error_setg_errno(errp, -ret,
613 "Failed to remove snapshot from snapshot list");
614 return ret;
615 }
616
617
618
619
620
621 g_free(sn.id_str);
622 g_free(sn.name);
623
624
625
626
627
628 ret = qcow2_update_snapshot_refcount(bs, sn.l1_table_offset,
629 sn.l1_size, -1);
630 if (ret < 0) {
631 error_setg_errno(errp, -ret, "Failed to free the cluster and L1 table");
632 return ret;
633 }
634 qcow2_free_clusters(bs, sn.l1_table_offset, sn.l1_size * sizeof(uint64_t),
635 QCOW2_DISCARD_SNAPSHOT);
636
637
638 ret = qcow2_update_snapshot_refcount(bs, s->l1_table_offset, s->l1_size, 0);
639 if (ret < 0) {
640 error_setg_errno(errp, -ret,
641 "Failed to update snapshot status in disk");
642 return ret;
643 }
644
645#ifdef DEBUG_ALLOC
646 {
647 BdrvCheckResult result = {0};
648 qcow2_check_refcounts(bs, &result, 0);
649 }
650#endif
651 return 0;
652}
653
654int qcow2_snapshot_list(BlockDriverState *bs, QEMUSnapshotInfo **psn_tab)
655{
656 BDRVQcow2State *s = bs->opaque;
657 QEMUSnapshotInfo *sn_tab, *sn_info;
658 QCowSnapshot *sn;
659 int i;
660
661 if (!s->nb_snapshots) {
662 *psn_tab = NULL;
663 return s->nb_snapshots;
664 }
665
666 sn_tab = g_new0(QEMUSnapshotInfo, s->nb_snapshots);
667 for(i = 0; i < s->nb_snapshots; i++) {
668 sn_info = sn_tab + i;
669 sn = s->snapshots + i;
670 pstrcpy(sn_info->id_str, sizeof(sn_info->id_str),
671 sn->id_str);
672 pstrcpy(sn_info->name, sizeof(sn_info->name),
673 sn->name);
674 sn_info->vm_state_size = sn->vm_state_size;
675 sn_info->date_sec = sn->date_sec;
676 sn_info->date_nsec = sn->date_nsec;
677 sn_info->vm_clock_nsec = sn->vm_clock_nsec;
678 }
679 *psn_tab = sn_tab;
680 return s->nb_snapshots;
681}
682
683int qcow2_snapshot_load_tmp(BlockDriverState *bs,
684 const char *snapshot_id,
685 const char *name,
686 Error **errp)
687{
688 int i, snapshot_index;
689 BDRVQcow2State *s = bs->opaque;
690 QCowSnapshot *sn;
691 uint64_t *new_l1_table;
692 int new_l1_bytes;
693 int ret;
694
695 assert(bs->read_only);
696
697
698 snapshot_index = find_snapshot_by_id_and_name(bs, snapshot_id, name);
699 if (snapshot_index < 0) {
700 error_setg(errp,
701 "Can't find snapshot");
702 return -ENOENT;
703 }
704 sn = &s->snapshots[snapshot_index];
705
706
707 if (sn->l1_size > QCOW_MAX_L1_SIZE / sizeof(uint64_t)) {
708 error_setg(errp, "Snapshot L1 table too large");
709 return -EFBIG;
710 }
711 new_l1_bytes = sn->l1_size * sizeof(uint64_t);
712 new_l1_table = qemu_try_blockalign(bs->file->bs,
713 align_offset(new_l1_bytes, 512));
714 if (new_l1_table == NULL) {
715 return -ENOMEM;
716 }
717
718 ret = bdrv_pread(bs->file, sn->l1_table_offset,
719 new_l1_table, new_l1_bytes);
720 if (ret < 0) {
721 error_setg(errp, "Failed to read l1 table for snapshot");
722 qemu_vfree(new_l1_table);
723 return ret;
724 }
725
726
727 qemu_vfree(s->l1_table);
728
729 s->l1_size = sn->l1_size;
730 s->l1_table_offset = sn->l1_table_offset;
731 s->l1_table = new_l1_table;
732
733 for(i = 0;i < s->l1_size; i++) {
734 be64_to_cpus(&s->l1_table[i]);
735 }
736
737 return 0;
738}
739