[qemu.git] / block / qcow2-snapshot.c

/*
 * Block driver for the QCOW version 2 format
 *
 * Copyright (c) 2004-2006 Fabrice Bellard
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

#include "qemu-common.h"
#include "block_int.h"
#include "block/qcow2.h"

typedef struct __attribute__((packed)) QCowSnapshotHeader {
    /* header is 8 byte aligned */
    uint64_t l1_table_offset;

    uint32_t l1_size;
    uint16_t id_str_size;
    uint16_t name_size;

    uint32_t date_sec;
    uint32_t date_nsec;

    uint64_t vm_clock_nsec;

    uint32_t vm_state_size;
    uint32_t extra_data_size; /* for extension */
    /* extra data follows */
    /* id_str follows */
    /* name follows  */
} QCowSnapshotHeader;

void qcow2_free_snapshots(BlockDriverState *bs)
{
    BDRVQcowState *s = bs->opaque;
    int i;

    for(i = 0; i < s->nb_snapshots; i++) {
        qemu_free(s->snapshots[i].name);
        qemu_free(s->snapshots[i].id_str);
    }
    qemu_free(s->snapshots);
    s->snapshots = NULL;
    s->nb_snapshots = 0;
}

int qcow2_read_snapshots(BlockDriverState *bs)
{
    BDRVQcowState *s = bs->opaque;
    QCowSnapshotHeader h;
    QCowSnapshot *sn;
    int i, id_str_size, name_size;
    int64_t offset;
    uint32_t extra_data_size;

    if (!s->nb_snapshots) {
        s->snapshots = NULL;
        s->snapshots_size = 0;
        return 0;
    }

    offset = s->snapshots_offset;
    s->snapshots = qemu_mallocz(s->nb_snapshots * sizeof(QCowSnapshot));
    for(i = 0; i < s->nb_snapshots; i++) {
        offset = align_offset(offset, 8);
        if (bdrv_pread(bs->file, offset, &h, sizeof(h)) != sizeof(h))
            goto fail;
        offset += sizeof(h);
        sn = s->snapshots + i;
        sn->l1_table_offset = be64_to_cpu(h.l1_table_offset);
        sn->l1_size = be32_to_cpu(h.l1_size);
        sn->vm_state_size = be32_to_cpu(h.vm_state_size);
        sn->date_sec = be32_to_cpu(h.date_sec);
        sn->date_nsec = be32_to_cpu(h.date_nsec);
        sn->vm_clock_nsec = be64_to_cpu(h.vm_clock_nsec);
        extra_data_size = be32_to_cpu(h.extra_data_size);

        id_str_size = be16_to_cpu(h.id_str_size);
        name_size = be16_to_cpu(h.name_size);

        offset += extra_data_size;

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

        sn->name = qemu_malloc(name_size + 1);
        if (bdrv_pread(bs->file, offset, sn->name, name_size) != name_size)
            goto fail;
        offset += name_size;
        sn->name[name_size] = '\0';
    }
    s->snapshots_size = offset - s->snapshots_offset;
    return 0;
 fail:
    qcow2_free_snapshots(bs);
    return -1;
}

/* add at the end of the file a new list of snapshots */
static int qcow2_write_snapshots(BlockDriverState *bs)
{
    BDRVQcowState *s = bs->opaque;
    QCowSnapshot *sn;
    QCowSnapshotHeader h;
    int i, name_size, id_str_size, snapshots_size;
    uint64_t data64;
    uint32_t data32;
    int64_t offset, snapshots_offset;

    /* compute the size of the snapshots */
    offset = 0;
    for(i = 0; i < s->nb_snapshots; i++) {
        sn = s->snapshots + i;
        offset = align_offset(offset, 8);
        offset += sizeof(h);
        offset += strlen(sn->id_str);
        offset += strlen(sn->name);
    }
    snapshots_size = offset;

    snapshots_offset = qcow2_alloc_clusters(bs, snapshots_size);
    bdrv_flush(bs->file);
    offset = snapshots_offset;
    if (offset < 0) {
        return offset;
    }

    for(i = 0; i < s->nb_snapshots; i++) {
        sn = s->snapshots + i;
        memset(&h, 0, sizeof(h));
        h.l1_table_offset = cpu_to_be64(sn->l1_table_offset);
        h.l1_size = cpu_to_be32(sn->l1_size);
        h.vm_state_size = cpu_to_be32(sn->vm_state_size);
        h.date_sec = cpu_to_be32(sn->date_sec);
        h.date_nsec = cpu_to_be32(sn->date_nsec);
        h.vm_clock_nsec = cpu_to_be64(sn->vm_clock_nsec);

        id_str_size = strlen(sn->id_str);
        name_size = strlen(sn->name);
        h.id_str_size = cpu_to_be16(id_str_size);
        h.name_size = cpu_to_be16(name_size);
        offset = align_offset(offset, 8);
        if (bdrv_pwrite_sync(bs->file, offset, &h, sizeof(h)) < 0)
            goto fail;
        offset += sizeof(h);
        if (bdrv_pwrite_sync(bs->file, offset, sn->id_str, id_str_size) < 0)
            goto fail;
        offset += id_str_size;
        if (bdrv_pwrite_sync(bs->file, offset, sn->name, name_size) < 0)
            goto fail;
        offset += name_size;
    }

    /* update the various header fields */
    data64 = cpu_to_be64(snapshots_offset);
    if (bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, snapshots_offset),
                    &data64, sizeof(data64)) < 0)
        goto fail;
    data32 = cpu_to_be32(s->nb_snapshots);
    if (bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, nb_snapshots),
                    &data32, sizeof(data32)) < 0)
        goto fail;

    /* free the old snapshot table */
    qcow2_free_clusters(bs, s->snapshots_offset, s->snapshots_size);
    s->snapshots_offset = snapshots_offset;
    s->snapshots_size = snapshots_size;
    return 0;
 fail:
    return -1;
}

static void find_new_snapshot_id(BlockDriverState *bs,
                                 char *id_str, int id_str_size)
{
    BDRVQcowState *s = bs->opaque;
    QCowSnapshot *sn;
    int i, id, id_max = 0;

    for(i = 0; i < s->nb_snapshots; i++) {
        sn = s->snapshots + i;
        id = strtoul(sn->id_str, NULL, 10);
        if (id > id_max)
            id_max = id;
    }
    snprintf(id_str, id_str_size, "%d", id_max + 1);
}

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

    for(i = 0; i < s->nb_snapshots; i++) {
        if (!strcmp(s->snapshots[i].id_str, id_str))
            return i;
    }
    return -1;
}

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

    ret = find_snapshot_by_id(bs, name);
    if (ret >= 0)
        return ret;
    for(i = 0; i < s->nb_snapshots; i++) {
        if (!strcmp(s->snapshots[i].name, name))
            return i;
    }
    return -1;
}

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

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

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

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

    sn->id_str = qemu_strdup(sn_info->id_str);
    if (!sn->id_str)
        goto fail;
    sn->name = qemu_strdup(sn_info->name);
    if (!sn->name)
        goto fail;
    sn->vm_state_size = sn_info->vm_state_size;
    sn->date_sec = sn_info->date_sec;
    sn->date_nsec = sn_info->date_nsec;
    sn->vm_clock_nsec = sn_info->vm_clock_nsec;

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

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

    sn->l1_table_offset = l1_table_offset;
    sn->l1_size = s->l1_size;

    if (s->l1_size != 0) {
        l1_table = qemu_malloc(s->l1_size * sizeof(uint64_t));
    } else {
        l1_table = NULL;
    }

    for(i = 0; i < s->l1_size; i++) {
        l1_table[i] = cpu_to_be64(s->l1_table[i]);
    }
    if (bdrv_pwrite_sync(bs->file, sn->l1_table_offset,
                    l1_table, s->l1_size * sizeof(uint64_t)) < 0)
        goto fail;
    qemu_free(l1_table);
    l1_table = NULL;

    snapshots1 = qemu_malloc((s->nb_snapshots + 1) * sizeof(QCowSnapshot));
    if (s->snapshots) {
        memcpy(snapshots1, s->snapshots, s->nb_snapshots * sizeof(QCowSnapshot));
        qemu_free(s->snapshots);
    }
    s->snapshots = snapshots1;
    s->snapshots[s->nb_snapshots++] = *sn;

    if (qcow2_write_snapshots(bs) < 0)
        goto fail;
#ifdef DEBUG_ALLOC
    qcow2_check_refcounts(bs);
#endif
    return 0;
 fail:
    qemu_free(sn->name);
    qemu_free(l1_table);
    return -1;
}

/* copy the snapshot 'snapshot_name' into the current disk image */
int qcow2_snapshot_goto(BlockDriverState *bs, const char *snapshot_id)
{
    BDRVQcowState *s = bs->opaque;
    QCowSnapshot *sn;
    int i, snapshot_index;
    int cur_l1_bytes, sn_l1_bytes;

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

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

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

    cur_l1_bytes = s->l1_size * sizeof(uint64_t);
    sn_l1_bytes = sn->l1_size * sizeof(uint64_t);

    if (cur_l1_bytes > sn_l1_bytes) {
        memset(s->l1_table + sn->l1_size, 0, cur_l1_bytes - sn_l1_bytes);
    }

    /* copy the snapshot l1 table to the current l1 table */
    if (bdrv_pread(bs->file, sn->l1_table_offset,
                   s->l1_table, sn_l1_bytes) < 0)
        goto fail;
    if (bdrv_pwrite_sync(bs->file, s->l1_table_offset,
                    s->l1_table, cur_l1_bytes) < 0)
        goto fail;
    for(i = 0;i < s->l1_size; i++) {
        be64_to_cpus(&s->l1_table[i]);
    }

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

#ifdef DEBUG_ALLOC
    qcow2_check_refcounts(bs);
#endif
    return 0;
 fail:
    return -EIO;
}

int qcow2_snapshot_delete(BlockDriverState *bs, const char *snapshot_id)
{
    BDRVQcowState *s = bs->opaque;
    QCowSnapshot *sn;
    int snapshot_index, ret;

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

    ret = qcow2_update_snapshot_refcount(bs, sn->l1_table_offset, sn->l1_size, -1);
    if (ret < 0)
        return ret;
    /* must update the copied flag on the current cluster offsets */
    ret = qcow2_update_snapshot_refcount(bs, s->l1_table_offset, s->l1_size, 0);
    if (ret < 0)
        return ret;
    qcow2_free_clusters(bs, sn->l1_table_offset, sn->l1_size * sizeof(uint64_t));

    qemu_free(sn->id_str);
    qemu_free(sn->name);
    memmove(sn, sn + 1, (s->nb_snapshots - snapshot_index - 1) * sizeof(*sn));
    s->nb_snapshots--;
    ret = qcow2_write_snapshots(bs);
    if (ret < 0) {
        /* XXX: restore snapshot if error ? */
        return ret;
    }
#ifdef DEBUG_ALLOC
    qcow2_check_refcounts(bs);
#endif
    return 0;
}

int qcow2_snapshot_list(BlockDriverState *bs, QEMUSnapshotInfo **psn_tab)
{
    BDRVQcowState *s = bs->opaque;
    QEMUSnapshotInfo *sn_tab, *sn_info;
    QCowSnapshot *sn;
    int i;

    if (!s->nb_snapshots) {
        *psn_tab = NULL;
        return s->nb_snapshots;
    }

    sn_tab = qemu_mallocz(s->nb_snapshots * sizeof(QEMUSnapshotInfo));
    for(i = 0; i < s->nb_snapshots; i++) {
        sn_info = sn_tab + i;
        sn = s->snapshots + i;
        pstrcpy(sn_info->id_str, sizeof(sn_info->id_str),
                sn->id_str);
        pstrcpy(sn_info->name, sizeof(sn_info->name),
                sn->name);
        sn_info->vm_state_size = sn->vm_state_size;
        sn_info->date_sec = sn->date_sec;
        sn_info->date_nsec = sn->date_nsec;
        sn_info->vm_clock_nsec = sn->vm_clock_nsec;
    }
    *psn_tab = sn_tab;
    return s->nb_snapshots;
}

int qcow2_snapshot_load_tmp(BlockDriverState *bs, const char *snapshot_name)
{
    int i, snapshot_index, l1_size2;
    BDRVQcowState *s = bs->opaque;
    QCowSnapshot *sn;

    snapshot_index = find_snapshot_by_id_or_name(bs, snapshot_name);
    if (snapshot_index < 0) {
        return -ENOENT;
    }

    sn = &s->snapshots[snapshot_index];
    s->l1_size = sn->l1_size;
    l1_size2 = s->l1_size * sizeof(uint64_t);
    if (s->l1_table != NULL) {
        qemu_free(s->l1_table);
    }

    s->l1_table_offset = sn->l1_table_offset;
    s->l1_table = qemu_mallocz(align_offset(l1_size2, 512));

    if (bdrv_pread(bs->file, sn->l1_table_offset,
                   s->l1_table, l1_size2) != l1_size2) {
        return -1;
    }

    for(i = 0;i < s->l1_size; i++) {
        be64_to_cpus(&s->l1_table[i]);
    }
    return 0;
}
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
	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
ed6ccf0f	49	void qcow2_free_snapshots(BlockDriverState *bs)
c142442b KW	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
ed6ccf0f	63	int qcow2_read_snapshots(BlockDriverState *bs)
c142442b KW	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);
66f82cee	82	if (bdrv_pread(bs->file, offset, &h, sizeof(h)) != sizeof(h))
c142442b KW	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);
66f82cee	100	if (bdrv_pread(bs->file, offset, sn->id_str, id_str_size) != id_str_size)
c142442b KW	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);
66f82cee	106	if (bdrv_pread(bs->file, offset, sn->name, name_size) != name_size)
c142442b KW	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:
ed6ccf0f	114	qcow2_free_snapshots(bs);
c142442b KW	115	return -1;
	116	}
	117
	118	/* add at the end of the file a new list of snapshots */
7c80ab3f	119	static int qcow2_write_snapshots(BlockDriverState *bs)
c142442b KW	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
ed6ccf0f	140	snapshots_offset = qcow2_alloc_clusters(bs, snapshots_size);
29216ed1	141	bdrv_flush(bs->file);
c142442b	142	offset = snapshots_offset;
5d757b56 KW	143	if (offset < 0) {
	144	return offset;
	145	}
c142442b KW	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);
8b3b7206	162	if (bdrv_pwrite_sync(bs->file, offset, &h, sizeof(h)) < 0)
c142442b KW	163	goto fail;
c142442b KW	164	offset += sizeof(h);
8b3b7206	165	if (bdrv_pwrite_sync(bs->file, offset, sn->id_str, id_str_size) < 0)
c142442b KW	166	goto fail;
c142442b KW	167	offset += id_str_size;
8b3b7206	168	if (bdrv_pwrite_sync(bs->file, offset, sn->name, name_size) < 0)
c142442b KW	169	goto fail;
	170	offset += name_size;
	171	}
	172
	173	/* update the various header fields */
	174	data64 = cpu_to_be64(snapshots_offset);
8b3b7206 KW	175	if (bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, snapshots_offset),
8b3b7206 KW	176	&data64, sizeof(data64)) < 0)
c142442b KW	177	goto fail;
c142442b KW	178	data32 = cpu_to_be32(s->nb_snapshots);
8b3b7206 KW	179	if (bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, nb_snapshots),
8b3b7206 KW	180	&data32, sizeof(data32)) < 0)
c142442b KW	181	goto fail;
	182
	183	/* free the old snapshot table */
ed6ccf0f	184	qcow2_free_clusters(bs, s->snapshots_offset, s->snapshots_size);
c142442b KW	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 */
ed6ccf0f	236	int qcow2_snapshot_create(BlockDriverState bs, QEMUSnapshotInfo sn_info)
c142442b KW	237	{
	238	BDRVQcowState *s = bs->opaque;
	239	QCowSnapshot snapshots1, sn1, sn = &sn1;
	240	int i, ret;
	241	uint64_t *l1_table = NULL;
5d757b56	242	int64_t l1_table_offset;
c142442b KW	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
ed6ccf0f	266	ret = qcow2_update_snapshot_refcount(bs, s->l1_table_offset, s->l1_size, 1);
c142442b KW	267	if (ret < 0)
	268	goto fail;
	269
	270	/* create the L1 table of the snapshot */
5d757b56 KW	271	l1_table_offset = qcow2_alloc_clusters(bs, s->l1_size * sizeof(uint64_t));
	272	if (l1_table_offset < 0) {
	273	goto fail;
	274	}
29216ed1	275	bdrv_flush(bs->file);
5d757b56 KW	276
5d757b56 KW	277	sn->l1_table_offset = l1_table_offset;
c142442b KW	278	sn->l1_size = s->l1_size;
c142442b KW	279
702ef63f KW	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
c142442b KW	286	for(i = 0; i < s->l1_size; i++) {
	287	l1_table[i] = cpu_to_be64(s->l1_table[i]);
	288	}
8b3b7206 KW	289	if (bdrv_pwrite_sync(bs->file, sn->l1_table_offset,
8b3b7206 KW	290	l1_table, s->l1_size * sizeof(uint64_t)) < 0)
c142442b KW	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
7c80ab3f	303	if (qcow2_write_snapshots(bs) < 0)
c142442b KW	304	goto fail;
c142442b KW	305	#ifdef DEBUG_ALLOC
14899cdf	306	qcow2_check_refcounts(bs);
c142442b KW	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 */
ed6ccf0f	316	int qcow2_snapshot_goto(BlockDriverState bs, const char snapshot_id)
c142442b KW	317	{
	318	BDRVQcowState *s = bs->opaque;
	319	QCowSnapshot *sn;
4fbe5233 KW	320	int i, snapshot_index;
4fbe5233 KW	321	int cur_l1_bytes, sn_l1_bytes;
c142442b KW	322
	323	snapshot_index = find_snapshot_by_id_or_name(bs, snapshot_id);
	324	if (snapshot_index < 0)
	325	return -ENOENT;
	326	sn = &s->snapshots[snapshot_index];
	327
ed6ccf0f	328	if (qcow2_update_snapshot_refcount(bs, s->l1_table_offset, s->l1_size, -1) < 0)
c142442b KW	329	goto fail;
c142442b KW	330
72893756	331	if (qcow2_grow_l1_table(bs, sn->l1_size, true) < 0)
c142442b KW	332	goto fail;
c142442b KW	333
4fbe5233 KW	334	cur_l1_bytes = s->l1_size * sizeof(uint64_t);
	335	sn_l1_bytes = sn->l1_size * sizeof(uint64_t);
	336
	337	if (cur_l1_bytes > sn_l1_bytes) {
	338	memset(s->l1_table + sn->l1_size, 0, cur_l1_bytes - sn_l1_bytes);
	339	}
	340
c142442b	341	/* copy the snapshot l1 table to the current l1 table */
66f82cee	342	if (bdrv_pread(bs->file, sn->l1_table_offset,
4fbe5233	343	s->l1_table, sn_l1_bytes) < 0)
c142442b	344	goto fail;
8b3b7206	345	if (bdrv_pwrite_sync(bs->file, s->l1_table_offset,
4fbe5233	346	s->l1_table, cur_l1_bytes) < 0)
c142442b KW	347	goto fail;
	348	for(i = 0;i < s->l1_size; i++) {
	349	be64_to_cpus(&s->l1_table[i]);
	350	}
	351
ed6ccf0f	352	if (qcow2_update_snapshot_refcount(bs, s->l1_table_offset, s->l1_size, 1) < 0)
c142442b KW	353	goto fail;
	354
	355	#ifdef DEBUG_ALLOC
14899cdf	356	qcow2_check_refcounts(bs);
c142442b KW	357	#endif
	358	return 0;
	359	fail:
	360	return -EIO;
	361	}
	362
ed6ccf0f	363	int qcow2_snapshot_delete(BlockDriverState bs, const char snapshot_id)
c142442b KW	364	{
	365	BDRVQcowState *s = bs->opaque;
	366	QCowSnapshot *sn;
	367	int snapshot_index, ret;
	368
	369	snapshot_index = find_snapshot_by_id_or_name(bs, snapshot_id);
	370	if (snapshot_index < 0)
	371	return -ENOENT;
	372	sn = &s->snapshots[snapshot_index];
	373
ed6ccf0f	374	ret = qcow2_update_snapshot_refcount(bs, sn->l1_table_offset, sn->l1_size, -1);
c142442b KW	375	if (ret < 0)
	376	return ret;
	377	/* must update the copied flag on the current cluster offsets */
ed6ccf0f	378	ret = qcow2_update_snapshot_refcount(bs, s->l1_table_offset, s->l1_size, 0);
c142442b KW	379	if (ret < 0)
c142442b KW	380	return ret;
ed6ccf0f	381	qcow2_free_clusters(bs, sn->l1_table_offset, sn->l1_size * sizeof(uint64_t));
c142442b KW	382
	383	qemu_free(sn->id_str);
	384	qemu_free(sn->name);
	385	memmove(sn, sn + 1, (s->nb_snapshots - snapshot_index - 1) * sizeof(*sn));
	386	s->nb_snapshots--;
7c80ab3f	387	ret = qcow2_write_snapshots(bs);
c142442b KW	388	if (ret < 0) {
	389	/* XXX: restore snapshot if error ? */
	390	return ret;
	391	}
	392	#ifdef DEBUG_ALLOC
14899cdf	393	qcow2_check_refcounts(bs);
c142442b KW	394	#endif
	395	return 0;
	396	}
	397
ed6ccf0f	398	int qcow2_snapshot_list(BlockDriverState bs, QEMUSnapshotInfo *psn_tab)
c142442b KW	399	{
	400	BDRVQcowState *s = bs->opaque;
	401	QEMUSnapshotInfo sn_tab, sn_info;
	402	QCowSnapshot *sn;
	403	int i;
	404
	405	if (!s->nb_snapshots) {
	406	*psn_tab = NULL;
	407	return s->nb_snapshots;
	408	}
	409
	410	sn_tab = qemu_mallocz(s->nb_snapshots * sizeof(QEMUSnapshotInfo));
	411	for(i = 0; i < s->nb_snapshots; i++) {
	412	sn_info = sn_tab + i;
	413	sn = s->snapshots + i;
	414	pstrcpy(sn_info->id_str, sizeof(sn_info->id_str),
	415	sn->id_str);
	416	pstrcpy(sn_info->name, sizeof(sn_info->name),
	417	sn->name);
	418	sn_info->vm_state_size = sn->vm_state_size;
	419	sn_info->date_sec = sn->date_sec;
	420	sn_info->date_nsec = sn->date_nsec;
	421	sn_info->vm_clock_nsec = sn->vm_clock_nsec;
	422	}
	423	*psn_tab = sn_tab;
	424	return s->nb_snapshots;
	425	}
	426
51ef6727	427	int qcow2_snapshot_load_tmp(BlockDriverState bs, const char snapshot_name)
	428	{
	429	int i, snapshot_index, l1_size2;
	430	BDRVQcowState *s = bs->opaque;
	431	QCowSnapshot *sn;
	432
	433	snapshot_index = find_snapshot_by_id_or_name(bs, snapshot_name);
	434	if (snapshot_index < 0) {
	435	return -ENOENT;
	436	}
	437
	438	sn = &s->snapshots[snapshot_index];
	439	s->l1_size = sn->l1_size;
	440	l1_size2 = s->l1_size * sizeof(uint64_t);
	441	if (s->l1_table != NULL) {
	442	qemu_free(s->l1_table);
	443	}
	444
	445	s->l1_table_offset = sn->l1_table_offset;
	446	s->l1_table = qemu_mallocz(align_offset(l1_size2, 512));
	447
	448	if (bdrv_pread(bs->file, sn->l1_table_offset,
	449	s->l1_table, l1_size2) != l1_size2) {
	450	return -1;
	451	}
	452
	453	for(i = 0;i < s->l1_size; i++) {
	454	be64_to_cpus(&s->l1_table[i]);
	455	}
	456	return 0;
	457	}