Statistics
| Branch: | Revision:

root / block / qcow2-snapshot.c @ 72893756

History | View | Annotate | Download (12.5 kB)

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

    
29
typedef struct __attribute__((packed)) QCowSnapshotHeader {
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

    
49
void qcow2_free_snapshots(BlockDriverState *bs)
50
{
51
    BDRVQcowState *s = bs->opaque;
52
    int i;
53

    
54
    for(i = 0; i < s->nb_snapshots; i++) {
55
        qemu_free(s->snapshots[i].name);
56
        qemu_free(s->snapshots[i].id_str);
57
    }
58
    qemu_free(s->snapshots);
59
    s->snapshots = NULL;
60
    s->nb_snapshots = 0;
61
}
62

    
63
int qcow2_read_snapshots(BlockDriverState *bs)
64
{
65
    BDRVQcowState *s = bs->opaque;
66
    QCowSnapshotHeader h;
67
    QCowSnapshot *sn;
68
    int i, id_str_size, name_size;
69
    int64_t offset;
70
    uint32_t extra_data_size;
71

    
72
    if (!s->nb_snapshots) {
73
        s->snapshots = NULL;
74
        s->snapshots_size = 0;
75
        return 0;
76
    }
77

    
78
    offset = s->snapshots_offset;
79
    s->snapshots = qemu_mallocz(s->nb_snapshots * sizeof(QCowSnapshot));
80
    for(i = 0; i < s->nb_snapshots; i++) {
81
        offset = align_offset(offset, 8);
82
        if (bdrv_pread(bs->file, offset, &h, sizeof(h)) != sizeof(h))
83
            goto fail;
84
        offset += sizeof(h);
85
        sn = s->snapshots + i;
86
        sn->l1_table_offset = be64_to_cpu(h.l1_table_offset);
87
        sn->l1_size = be32_to_cpu(h.l1_size);
88
        sn->vm_state_size = be32_to_cpu(h.vm_state_size);
89
        sn->date_sec = be32_to_cpu(h.date_sec);
90
        sn->date_nsec = be32_to_cpu(h.date_nsec);
91
        sn->vm_clock_nsec = be64_to_cpu(h.vm_clock_nsec);
92
        extra_data_size = be32_to_cpu(h.extra_data_size);
93

    
94
        id_str_size = be16_to_cpu(h.id_str_size);
95
        name_size = be16_to_cpu(h.name_size);
96

    
97
        offset += extra_data_size;
98

    
99
        sn->id_str = qemu_malloc(id_str_size + 1);
100
        if (bdrv_pread(bs->file, offset, sn->id_str, id_str_size) != id_str_size)
101
            goto fail;
102
        offset += id_str_size;
103
        sn->id_str[id_str_size] = '\0';
104

    
105
        sn->name = qemu_malloc(name_size + 1);
106
        if (bdrv_pread(bs->file, offset, sn->name, name_size) != name_size)
107
            goto fail;
108
        offset += name_size;
109
        sn->name[name_size] = '\0';
110
    }
111
    s->snapshots_size = offset - s->snapshots_offset;
112
    return 0;
113
 fail:
114
    qcow2_free_snapshots(bs);
115
    return -1;
116
}
117

    
118
/* add at the end of the file a new list of snapshots */
119
static int qcow_write_snapshots(BlockDriverState *bs)
120
{
121
    BDRVQcowState *s = bs->opaque;
122
    QCowSnapshot *sn;
123
    QCowSnapshotHeader h;
124
    int i, name_size, id_str_size, snapshots_size;
125
    uint64_t data64;
126
    uint32_t data32;
127
    int64_t offset, snapshots_offset;
128

    
129
    /* compute the size of the snapshots */
130
    offset = 0;
131
    for(i = 0; i < s->nb_snapshots; i++) {
132
        sn = s->snapshots + i;
133
        offset = align_offset(offset, 8);
134
        offset += sizeof(h);
135
        offset += strlen(sn->id_str);
136
        offset += strlen(sn->name);
137
    }
138
    snapshots_size = offset;
139

    
140
    snapshots_offset = qcow2_alloc_clusters(bs, snapshots_size);
141
    bdrv_flush(bs->file);
142
    offset = snapshots_offset;
143
    if (offset < 0) {
144
        return offset;
145
    }
146

    
147
    for(i = 0; i < s->nb_snapshots; i++) {
148
        sn = s->snapshots + i;
149
        memset(&h, 0, sizeof(h));
150
        h.l1_table_offset = cpu_to_be64(sn->l1_table_offset);
151
        h.l1_size = cpu_to_be32(sn->l1_size);
152
        h.vm_state_size = cpu_to_be32(sn->vm_state_size);
153
        h.date_sec = cpu_to_be32(sn->date_sec);
154
        h.date_nsec = cpu_to_be32(sn->date_nsec);
155
        h.vm_clock_nsec = cpu_to_be64(sn->vm_clock_nsec);
156

    
157
        id_str_size = strlen(sn->id_str);
158
        name_size = strlen(sn->name);
159
        h.id_str_size = cpu_to_be16(id_str_size);
160
        h.name_size = cpu_to_be16(name_size);
161
        offset = align_offset(offset, 8);
162
        if (bdrv_pwrite_sync(bs->file, offset, &h, sizeof(h)) < 0)
163
            goto fail;
164
        offset += sizeof(h);
165
        if (bdrv_pwrite_sync(bs->file, offset, sn->id_str, id_str_size) < 0)
166
            goto fail;
167
        offset += id_str_size;
168
        if (bdrv_pwrite_sync(bs->file, offset, sn->name, name_size) < 0)
169
            goto fail;
170
        offset += name_size;
171
    }
172

    
173
    /* update the various header fields */
174
    data64 = cpu_to_be64(snapshots_offset);
175
    if (bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, snapshots_offset),
176
                    &data64, sizeof(data64)) < 0)
177
        goto fail;
178
    data32 = cpu_to_be32(s->nb_snapshots);
179
    if (bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, nb_snapshots),
180
                    &data32, sizeof(data32)) < 0)
181
        goto fail;
182

    
183
    /* free the old snapshot table */
184
    qcow2_free_clusters(bs, s->snapshots_offset, s->snapshots_size);
185
    s->snapshots_offset = snapshots_offset;
186
    s->snapshots_size = snapshots_size;
187
    return 0;
188
 fail:
189
    return -1;
190
}
191

    
192
static void find_new_snapshot_id(BlockDriverState *bs,
193
                                 char *id_str, int id_str_size)
194
{
195
    BDRVQcowState *s = bs->opaque;
196
    QCowSnapshot *sn;
197
    int i, id, id_max = 0;
198

    
199
    for(i = 0; i < s->nb_snapshots; i++) {
200
        sn = s->snapshots + i;
201
        id = strtoul(sn->id_str, NULL, 10);
202
        if (id > id_max)
203
            id_max = id;
204
    }
205
    snprintf(id_str, id_str_size, "%d", id_max + 1);
206
}
207

    
208
static int find_snapshot_by_id(BlockDriverState *bs, const char *id_str)
209
{
210
    BDRVQcowState *s = bs->opaque;
211
    int i;
212

    
213
    for(i = 0; i < s->nb_snapshots; i++) {
214
        if (!strcmp(s->snapshots[i].id_str, id_str))
215
            return i;
216
    }
217
    return -1;
218
}
219

    
220
static int find_snapshot_by_id_or_name(BlockDriverState *bs, const char *name)
221
{
222
    BDRVQcowState *s = bs->opaque;
223
    int i, ret;
224

    
225
    ret = find_snapshot_by_id(bs, name);
226
    if (ret >= 0)
227
        return ret;
228
    for(i = 0; i < s->nb_snapshots; i++) {
229
        if (!strcmp(s->snapshots[i].name, name))
230
            return i;
231
    }
232
    return -1;
233
}
234

    
235
/* if no id is provided, a new one is constructed */
236
int qcow2_snapshot_create(BlockDriverState *bs, QEMUSnapshotInfo *sn_info)
237
{
238
    BDRVQcowState *s = bs->opaque;
239
    QCowSnapshot *snapshots1, sn1, *sn = &sn1;
240
    int i, ret;
241
    uint64_t *l1_table = NULL;
242
    int64_t l1_table_offset;
243

    
244
    memset(sn, 0, sizeof(*sn));
245

    
246
    if (sn_info->id_str[0] == '\0') {
247
        /* compute a new id */
248
        find_new_snapshot_id(bs, sn_info->id_str, sizeof(sn_info->id_str));
249
    }
250

    
251
    /* check that the ID is unique */
252
    if (find_snapshot_by_id(bs, sn_info->id_str) >= 0)
253
        return -ENOENT;
254

    
255
    sn->id_str = qemu_strdup(sn_info->id_str);
256
    if (!sn->id_str)
257
        goto fail;
258
    sn->name = qemu_strdup(sn_info->name);
259
    if (!sn->name)
260
        goto fail;
261
    sn->vm_state_size = sn_info->vm_state_size;
262
    sn->date_sec = sn_info->date_sec;
263
    sn->date_nsec = sn_info->date_nsec;
264
    sn->vm_clock_nsec = sn_info->vm_clock_nsec;
265

    
266
    ret = qcow2_update_snapshot_refcount(bs, s->l1_table_offset, s->l1_size, 1);
267
    if (ret < 0)
268
        goto fail;
269

    
270
    /* create the L1 table of the snapshot */
271
    l1_table_offset = qcow2_alloc_clusters(bs, s->l1_size * sizeof(uint64_t));
272
    if (l1_table_offset < 0) {
273
        goto fail;
274
    }
275
    bdrv_flush(bs->file);
276

    
277
    sn->l1_table_offset = l1_table_offset;
278
    sn->l1_size = s->l1_size;
279

    
280
    if (s->l1_size != 0) {
281
        l1_table = qemu_malloc(s->l1_size * sizeof(uint64_t));
282
    } else {
283
        l1_table = NULL;
284
    }
285

    
286
    for(i = 0; i < s->l1_size; i++) {
287
        l1_table[i] = cpu_to_be64(s->l1_table[i]);
288
    }
289
    if (bdrv_pwrite_sync(bs->file, sn->l1_table_offset,
290
                    l1_table, s->l1_size * sizeof(uint64_t)) < 0)
291
        goto fail;
292
    qemu_free(l1_table);
293
    l1_table = NULL;
294

    
295
    snapshots1 = qemu_malloc((s->nb_snapshots + 1) * sizeof(QCowSnapshot));
296
    if (s->snapshots) {
297
        memcpy(snapshots1, s->snapshots, s->nb_snapshots * sizeof(QCowSnapshot));
298
        qemu_free(s->snapshots);
299
    }
300
    s->snapshots = snapshots1;
301
    s->snapshots[s->nb_snapshots++] = *sn;
302

    
303
    if (qcow_write_snapshots(bs) < 0)
304
        goto fail;
305
#ifdef DEBUG_ALLOC
306
    qcow2_check_refcounts(bs);
307
#endif
308
    return 0;
309
 fail:
310
    qemu_free(sn->name);
311
    qemu_free(l1_table);
312
    return -1;
313
}
314

    
315
/* copy the snapshot 'snapshot_name' into the current disk image */
316
int qcow2_snapshot_goto(BlockDriverState *bs, const char *snapshot_id)
317
{
318
    BDRVQcowState *s = bs->opaque;
319
    QCowSnapshot *sn;
320
    int i, snapshot_index, l1_size2;
321

    
322
    snapshot_index = find_snapshot_by_id_or_name(bs, snapshot_id);
323
    if (snapshot_index < 0)
324
        return -ENOENT;
325
    sn = &s->snapshots[snapshot_index];
326

    
327
    if (qcow2_update_snapshot_refcount(bs, s->l1_table_offset, s->l1_size, -1) < 0)
328
        goto fail;
329

    
330
    if (qcow2_grow_l1_table(bs, sn->l1_size, true) < 0)
331
        goto fail;
332

    
333
    s->l1_size = sn->l1_size;
334
    l1_size2 = s->l1_size * sizeof(uint64_t);
335
    /* copy the snapshot l1 table to the current l1 table */
336
    if (bdrv_pread(bs->file, sn->l1_table_offset,
337
                   s->l1_table, l1_size2) != l1_size2)
338
        goto fail;
339
    if (bdrv_pwrite_sync(bs->file, s->l1_table_offset,
340
                    s->l1_table, l1_size2) < 0)
341
        goto fail;
342
    for(i = 0;i < s->l1_size; i++) {
343
        be64_to_cpus(&s->l1_table[i]);
344
    }
345

    
346
    if (qcow2_update_snapshot_refcount(bs, s->l1_table_offset, s->l1_size, 1) < 0)
347
        goto fail;
348

    
349
#ifdef DEBUG_ALLOC
350
    qcow2_check_refcounts(bs);
351
#endif
352
    return 0;
353
 fail:
354
    return -EIO;
355
}
356

    
357
int qcow2_snapshot_delete(BlockDriverState *bs, const char *snapshot_id)
358
{
359
    BDRVQcowState *s = bs->opaque;
360
    QCowSnapshot *sn;
361
    int snapshot_index, ret;
362

    
363
    snapshot_index = find_snapshot_by_id_or_name(bs, snapshot_id);
364
    if (snapshot_index < 0)
365
        return -ENOENT;
366
    sn = &s->snapshots[snapshot_index];
367

    
368
    ret = qcow2_update_snapshot_refcount(bs, sn->l1_table_offset, sn->l1_size, -1);
369
    if (ret < 0)
370
        return ret;
371
    /* must update the copied flag on the current cluster offsets */
372
    ret = qcow2_update_snapshot_refcount(bs, s->l1_table_offset, s->l1_size, 0);
373
    if (ret < 0)
374
        return ret;
375
    qcow2_free_clusters(bs, sn->l1_table_offset, sn->l1_size * sizeof(uint64_t));
376

    
377
    qemu_free(sn->id_str);
378
    qemu_free(sn->name);
379
    memmove(sn, sn + 1, (s->nb_snapshots - snapshot_index - 1) * sizeof(*sn));
380
    s->nb_snapshots--;
381
    ret = qcow_write_snapshots(bs);
382
    if (ret < 0) {
383
        /* XXX: restore snapshot if error ? */
384
        return ret;
385
    }
386
#ifdef DEBUG_ALLOC
387
    qcow2_check_refcounts(bs);
388
#endif
389
    return 0;
390
}
391

    
392
int qcow2_snapshot_list(BlockDriverState *bs, QEMUSnapshotInfo **psn_tab)
393
{
394
    BDRVQcowState *s = bs->opaque;
395
    QEMUSnapshotInfo *sn_tab, *sn_info;
396
    QCowSnapshot *sn;
397
    int i;
398

    
399
    if (!s->nb_snapshots) {
400
        *psn_tab = NULL;
401
        return s->nb_snapshots;
402
    }
403

    
404
    sn_tab = qemu_mallocz(s->nb_snapshots * sizeof(QEMUSnapshotInfo));
405
    for(i = 0; i < s->nb_snapshots; i++) {
406
        sn_info = sn_tab + i;
407
        sn = s->snapshots + i;
408
        pstrcpy(sn_info->id_str, sizeof(sn_info->id_str),
409
                sn->id_str);
410
        pstrcpy(sn_info->name, sizeof(sn_info->name),
411
                sn->name);
412
        sn_info->vm_state_size = sn->vm_state_size;
413
        sn_info->date_sec = sn->date_sec;
414
        sn_info->date_nsec = sn->date_nsec;
415
        sn_info->vm_clock_nsec = sn->vm_clock_nsec;
416
    }
417
    *psn_tab = sn_tab;
418
    return s->nb_snapshots;
419
}
420