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