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/error-report.h"
30#include "qemu/cutils.h"
31
32void qcow2_free_snapshots(BlockDriverState *bs)
33{
34 BDRVQcow2State *s = bs->opaque;
35 int i;
36
37 for(i = 0; i < s->nb_snapshots; i++) {
38 g_free(s->snapshots[i].name);
39 g_free(s->snapshots[i].id_str);
40 }
41 g_free(s->snapshots);
42 s->snapshots = NULL;
43 s->nb_snapshots = 0;
44}
45
46int qcow2_read_snapshots(BlockDriverState *bs)
47{
48 BDRVQcow2State *s = bs->opaque;
49 QCowSnapshotHeader h;
50 QCowSnapshotExtraData extra;
51 QCowSnapshot *sn;
52 int i, id_str_size, name_size;
53 int64_t offset;
54 uint32_t extra_data_size;
55 int ret;
56
57 if (!s->nb_snapshots) {
58 s->snapshots = NULL;
59 s->snapshots_size = 0;
60 return 0;
61 }
62
63 offset = s->snapshots_offset;
64 s->snapshots = g_new0(QCowSnapshot, s->nb_snapshots);
65
66 for(i = 0; i < s->nb_snapshots; i++) {
67
68 offset = align_offset(offset, 8);
69 ret = bdrv_pread(bs->file->bs, offset, &h, sizeof(h));
70 if (ret < 0) {
71 goto fail;
72 }
73
74 offset += sizeof(h);
75 sn = s->snapshots + i;
76 sn->l1_table_offset = be64_to_cpu(h.l1_table_offset);
77 sn->l1_size = be32_to_cpu(h.l1_size);
78 sn->vm_state_size = be32_to_cpu(h.vm_state_size);
79 sn->date_sec = be32_to_cpu(h.date_sec);
80 sn->date_nsec = be32_to_cpu(h.date_nsec);
81 sn->vm_clock_nsec = be64_to_cpu(h.vm_clock_nsec);
82 extra_data_size = be32_to_cpu(h.extra_data_size);
83
84 id_str_size = be16_to_cpu(h.id_str_size);
85 name_size = be16_to_cpu(h.name_size);
86
87
88 ret = bdrv_pread(bs->file->bs, offset, &extra,
89 MIN(sizeof(extra), extra_data_size));
90 if (ret < 0) {
91 goto fail;
92 }
93 offset += extra_data_size;
94
95 if (extra_data_size >= 8) {
96 sn->vm_state_size = be64_to_cpu(extra.vm_state_size_large);
97 }
98
99 if (extra_data_size >= 16) {
100 sn->disk_size = be64_to_cpu(extra.disk_size);
101 } else {
102 sn->disk_size = bs->total_sectors * BDRV_SECTOR_SIZE;
103 }
104
105
106 sn->id_str = g_malloc(id_str_size + 1);
107 ret = bdrv_pread(bs->file->bs, offset, sn->id_str, id_str_size);
108 if (ret < 0) {
109 goto fail;
110 }
111 offset += id_str_size;
112 sn->id_str[id_str_size] = '\0';
113
114
115 sn->name = g_malloc(name_size + 1);
116 ret = bdrv_pread(bs->file->bs, offset, sn->name, name_size);
117 if (ret < 0) {
118 goto fail;
119 }
120 offset += name_size;
121 sn->name[name_size] = '\0';
122
123 if (offset - s->snapshots_offset > QCOW_MAX_SNAPSHOTS_SIZE) {
124 ret = -EFBIG;
125 goto fail;
126 }
127 }
128
129 assert(offset - s->snapshots_offset <= INT_MAX);
130 s->snapshots_size = offset - s->snapshots_offset;
131 return 0;
132
133fail:
134 qcow2_free_snapshots(bs);
135 return ret;
136}
137
138
139static int qcow2_write_snapshots(BlockDriverState *bs)
140{
141 BDRVQcow2State *s = bs->opaque;
142 QCowSnapshot *sn;
143 QCowSnapshotHeader h;
144 QCowSnapshotExtraData extra;
145 int i, name_size, id_str_size, snapshots_size;
146 struct {
147 uint32_t nb_snapshots;
148 uint64_t snapshots_offset;
149 } QEMU_PACKED header_data;
150 int64_t offset, snapshots_offset = 0;
151 int ret;
152
153
154 offset = 0;
155 for(i = 0; i < s->nb_snapshots; i++) {
156 sn = s->snapshots + i;
157 offset = align_offset(offset, 8);
158 offset += sizeof(h);
159 offset += sizeof(extra);
160 offset += strlen(sn->id_str);
161 offset += strlen(sn->name);
162
163 if (offset > QCOW_MAX_SNAPSHOTS_SIZE) {
164 ret = -EFBIG;
165 goto fail;
166 }
167 }
168
169 assert(offset <= INT_MAX);
170 snapshots_size = offset;
171
172
173 snapshots_offset = qcow2_alloc_clusters(bs, snapshots_size);
174 offset = snapshots_offset;
175 if (offset < 0) {
176 ret = offset;
177 goto fail;
178 }
179 ret = bdrv_flush(bs);
180 if (ret < 0) {
181 goto fail;
182 }
183
184
185
186 ret = qcow2_pre_write_overlap_check(bs, 0, offset, snapshots_size);
187 if (ret < 0) {
188 goto fail;
189 }
190
191
192
193 for(i = 0; i < s->nb_snapshots; i++) {
194 sn = s->snapshots + i;
195 memset(&h, 0, sizeof(h));
196 h.l1_table_offset = cpu_to_be64(sn->l1_table_offset);
197 h.l1_size = cpu_to_be32(sn->l1_size);
198
199
200 if (sn->vm_state_size <= 0xffffffff) {
201 h.vm_state_size = cpu_to_be32(sn->vm_state_size);
202 }
203 h.date_sec = cpu_to_be32(sn->date_sec);
204 h.date_nsec = cpu_to_be32(sn->date_nsec);
205 h.vm_clock_nsec = cpu_to_be64(sn->vm_clock_nsec);
206 h.extra_data_size = cpu_to_be32(sizeof(extra));
207
208 memset(&extra, 0, sizeof(extra));
209 extra.vm_state_size_large = cpu_to_be64(sn->vm_state_size);
210 extra.disk_size = cpu_to_be64(sn->disk_size);
211
212 id_str_size = strlen(sn->id_str);
213 name_size = strlen(sn->name);
214 assert(id_str_size <= UINT16_MAX && name_size <= UINT16_MAX);
215 h.id_str_size = cpu_to_be16(id_str_size);
216 h.name_size = cpu_to_be16(name_size);
217 offset = align_offset(offset, 8);
218
219 ret = bdrv_pwrite(bs->file->bs, offset, &h, sizeof(h));
220 if (ret < 0) {
221 goto fail;
222 }
223 offset += sizeof(h);
224
225 ret = bdrv_pwrite(bs->file->bs, offset, &extra, sizeof(extra));
226 if (ret < 0) {
227 goto fail;
228 }
229 offset += sizeof(extra);
230
231 ret = bdrv_pwrite(bs->file->bs, offset, sn->id_str, id_str_size);
232 if (ret < 0) {
233 goto fail;
234 }
235 offset += id_str_size;
236
237 ret = bdrv_pwrite(bs->file->bs, offset, sn->name, name_size);
238 if (ret < 0) {
239 goto fail;
240 }
241 offset += name_size;
242 }
243
244
245
246
247
248 ret = bdrv_flush(bs);
249 if (ret < 0) {
250 goto fail;
251 }
252
253 QEMU_BUILD_BUG_ON(offsetof(QCowHeader, snapshots_offset) !=
254 offsetof(QCowHeader, nb_snapshots) + sizeof(header_data.nb_snapshots));
255
256 header_data.nb_snapshots = cpu_to_be32(s->nb_snapshots);
257 header_data.snapshots_offset = cpu_to_be64(snapshots_offset);
258
259 ret = bdrv_pwrite_sync(bs->file->bs, offsetof(QCowHeader, nb_snapshots),
260 &header_data, sizeof(header_data));
261 if (ret < 0) {
262 goto fail;
263 }
264
265
266 qcow2_free_clusters(bs, s->snapshots_offset, s->snapshots_size,
267 QCOW2_DISCARD_SNAPSHOT);
268 s->snapshots_offset = snapshots_offset;
269 s->snapshots_size = snapshots_size;
270 return 0;
271
272fail:
273 if (snapshots_offset > 0) {
274 qcow2_free_clusters(bs, snapshots_offset, snapshots_size,
275 QCOW2_DISCARD_ALWAYS);
276 }
277 return ret;
278}
279
280static void find_new_snapshot_id(BlockDriverState *bs,
281 char *id_str, int id_str_size)
282{
283 BDRVQcow2State *s = bs->opaque;
284 QCowSnapshot *sn;
285 int i;
286 unsigned long id, id_max = 0;
287
288 for(i = 0; i < s->nb_snapshots; i++) {
289 sn = s->snapshots + i;
290 id = strtoul(sn->id_str, NULL, 10);
291 if (id > id_max)
292 id_max = id;
293 }
294 snprintf(id_str, id_str_size, "%lu", id_max + 1);
295}
296
297static int find_snapshot_by_id_and_name(BlockDriverState *bs,
298 const char *id,
299 const char *name)
300{
301 BDRVQcow2State *s = bs->opaque;
302 int i;
303
304 if (id && name) {
305 for (i = 0; i < s->nb_snapshots; i++) {
306 if (!strcmp(s->snapshots[i].id_str, id) &&
307 !strcmp(s->snapshots[i].name, name)) {
308 return i;
309 }
310 }
311 } else if (id) {
312 for (i = 0; i < s->nb_snapshots; i++) {
313 if (!strcmp(s->snapshots[i].id_str, id)) {
314 return i;
315 }
316 }
317 } else if (name) {
318 for (i = 0; i < s->nb_snapshots; i++) {
319 if (!strcmp(s->snapshots[i].name, name)) {
320 return i;
321 }
322 }
323 }
324
325 return -1;
326}
327
328static int find_snapshot_by_id_or_name(BlockDriverState *bs,
329 const char *id_or_name)
330{
331 int ret;
332
333 ret = find_snapshot_by_id_and_name(bs, id_or_name, NULL);
334 if (ret >= 0) {
335 return ret;
336 }
337 return find_snapshot_by_id_and_name(bs, NULL, id_or_name);
338}
339
340
341int qcow2_snapshot_create(BlockDriverState *bs, QEMUSnapshotInfo *sn_info)
342{
343 BDRVQcow2State *s = bs->opaque;
344 QCowSnapshot *new_snapshot_list = NULL;
345 QCowSnapshot *old_snapshot_list = NULL;
346 QCowSnapshot sn1, *sn = &sn1;
347 int i, ret;
348 uint64_t *l1_table = NULL;
349 int64_t l1_table_offset;
350
351 if (s->nb_snapshots >= QCOW_MAX_SNAPSHOTS) {
352 return -EFBIG;
353 }
354
355 memset(sn, 0, sizeof(*sn));
356
357
358 find_new_snapshot_id(bs, sn_info->id_str, sizeof(sn_info->id_str));
359
360
361 if (find_snapshot_by_id_and_name(bs, sn_info->id_str, NULL) >= 0) {
362 return -EEXIST;
363 }
364
365
366 sn->id_str = g_strdup(sn_info->id_str);
367 sn->name = g_strdup(sn_info->name);
368
369 sn->disk_size = bs->total_sectors * BDRV_SECTOR_SIZE;
370 sn->vm_state_size = sn_info->vm_state_size;
371 sn->date_sec = sn_info->date_sec;
372 sn->date_nsec = sn_info->date_nsec;
373 sn->vm_clock_nsec = sn_info->vm_clock_nsec;
374
375
376 l1_table_offset = qcow2_alloc_clusters(bs, s->l1_size * sizeof(uint64_t));
377 if (l1_table_offset < 0) {
378 ret = l1_table_offset;
379 goto fail;
380 }
381
382 sn->l1_table_offset = l1_table_offset;
383 sn->l1_size = s->l1_size;
384
385 l1_table = g_try_new(uint64_t, s->l1_size);
386 if (s->l1_size && l1_table == NULL) {
387 ret = -ENOMEM;
388 goto fail;
389 }
390
391 for(i = 0; i < s->l1_size; i++) {
392 l1_table[i] = cpu_to_be64(s->l1_table[i]);
393 }
394
395 ret = qcow2_pre_write_overlap_check(bs, 0, sn->l1_table_offset,
396 s->l1_size * sizeof(uint64_t));
397 if (ret < 0) {
398 goto fail;
399 }
400
401 ret = bdrv_pwrite(bs->file->bs, sn->l1_table_offset, l1_table,
402 s->l1_size * sizeof(uint64_t));
403 if (ret < 0) {
404 goto fail;
405 }
406
407 g_free(l1_table);
408 l1_table = NULL;
409
410
411
412
413
414
415 ret = qcow2_update_snapshot_refcount(bs, s->l1_table_offset, s->l1_size, 1);
416 if (ret < 0) {
417 goto fail;
418 }
419
420
421 new_snapshot_list = g_new(QCowSnapshot, s->nb_snapshots + 1);
422 if (s->snapshots) {
423 memcpy(new_snapshot_list, s->snapshots,
424 s->nb_snapshots * sizeof(QCowSnapshot));
425 old_snapshot_list = s->snapshots;
426 }
427 s->snapshots = new_snapshot_list;
428 s->snapshots[s->nb_snapshots++] = *sn;
429
430 ret = qcow2_write_snapshots(bs);
431 if (ret < 0) {
432 g_free(s->snapshots);
433 s->snapshots = old_snapshot_list;
434 s->nb_snapshots--;
435 goto fail;
436 }
437
438 g_free(old_snapshot_list);
439
440
441
442 qcow2_discard_clusters(bs, qcow2_vm_state_offset(s),
443 align_offset(sn->vm_state_size, s->cluster_size)
444 >> BDRV_SECTOR_BITS,
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->bs, 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->bs, 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->bs, 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