2009-05-28 16:07:06 +02:00
|
|
|
/*
|
|
|
|
* 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"
|
2012-12-17 18:19:44 +01:00
|
|
|
#include "block/block_int.h"
|
2009-05-28 16:07:06 +02:00
|
|
|
#include "block/qcow2.h"
|
|
|
|
|
2011-08-31 12:38:01 +02:00
|
|
|
typedef struct QEMU_PACKED QCowSnapshotHeader {
|
2009-05-28 16:07:06 +02:00
|
|
|
/* 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;
|
|
|
|
|
2011-11-16 11:35:54 +01:00
|
|
|
typedef struct QEMU_PACKED QCowSnapshotExtraData {
|
|
|
|
uint64_t vm_state_size_large;
|
2012-04-11 16:33:50 +02:00
|
|
|
uint64_t disk_size;
|
2011-11-16 11:35:54 +01:00
|
|
|
} QCowSnapshotExtraData;
|
|
|
|
|
2009-05-28 16:07:07 +02:00
|
|
|
void qcow2_free_snapshots(BlockDriverState *bs)
|
2009-05-28 16:07:06 +02:00
|
|
|
{
|
|
|
|
BDRVQcowState *s = bs->opaque;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for(i = 0; i < s->nb_snapshots; i++) {
|
2011-08-21 05:09:37 +02:00
|
|
|
g_free(s->snapshots[i].name);
|
|
|
|
g_free(s->snapshots[i].id_str);
|
2009-05-28 16:07:06 +02:00
|
|
|
}
|
2011-08-21 05:09:37 +02:00
|
|
|
g_free(s->snapshots);
|
2009-05-28 16:07:06 +02:00
|
|
|
s->snapshots = NULL;
|
|
|
|
s->nb_snapshots = 0;
|
|
|
|
}
|
|
|
|
|
2009-05-28 16:07:07 +02:00
|
|
|
int qcow2_read_snapshots(BlockDriverState *bs)
|
2009-05-28 16:07:06 +02:00
|
|
|
{
|
|
|
|
BDRVQcowState *s = bs->opaque;
|
|
|
|
QCowSnapshotHeader h;
|
2011-11-16 11:35:54 +01:00
|
|
|
QCowSnapshotExtraData extra;
|
2009-05-28 16:07:06 +02:00
|
|
|
QCowSnapshot *sn;
|
|
|
|
int i, id_str_size, name_size;
|
|
|
|
int64_t offset;
|
|
|
|
uint32_t extra_data_size;
|
2011-11-16 11:43:28 +01:00
|
|
|
int ret;
|
2009-05-28 16:07:06 +02:00
|
|
|
|
|
|
|
if (!s->nb_snapshots) {
|
|
|
|
s->snapshots = NULL;
|
|
|
|
s->snapshots_size = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
offset = s->snapshots_offset;
|
2011-08-21 05:09:37 +02:00
|
|
|
s->snapshots = g_malloc0(s->nb_snapshots * sizeof(QCowSnapshot));
|
2011-11-16 11:43:28 +01:00
|
|
|
|
2009-05-28 16:07:06 +02:00
|
|
|
for(i = 0; i < s->nb_snapshots; i++) {
|
2011-11-16 11:43:28 +01:00
|
|
|
/* Read statically sized part of the snapshot header */
|
2009-05-28 16:07:06 +02:00
|
|
|
offset = align_offset(offset, 8);
|
2011-11-16 11:43:28 +01:00
|
|
|
ret = bdrv_pread(bs->file, offset, &h, sizeof(h));
|
|
|
|
if (ret < 0) {
|
2009-05-28 16:07:06 +02:00
|
|
|
goto fail;
|
2011-11-16 11:43:28 +01:00
|
|
|
}
|
|
|
|
|
2009-05-28 16:07:06 +02:00
|
|
|
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);
|
|
|
|
|
2011-11-16 11:35:54 +01:00
|
|
|
/* Read extra data */
|
|
|
|
ret = bdrv_pread(bs->file, offset, &extra,
|
|
|
|
MIN(sizeof(extra), extra_data_size));
|
|
|
|
if (ret < 0) {
|
|
|
|
goto fail;
|
|
|
|
}
|
2009-05-28 16:07:06 +02:00
|
|
|
offset += extra_data_size;
|
|
|
|
|
2011-11-16 11:35:54 +01:00
|
|
|
if (extra_data_size >= 8) {
|
|
|
|
sn->vm_state_size = be64_to_cpu(extra.vm_state_size_large);
|
|
|
|
}
|
|
|
|
|
2012-04-11 16:33:50 +02:00
|
|
|
if (extra_data_size >= 16) {
|
|
|
|
sn->disk_size = be64_to_cpu(extra.disk_size);
|
|
|
|
} else {
|
|
|
|
sn->disk_size = bs->total_sectors * BDRV_SECTOR_SIZE;
|
|
|
|
}
|
|
|
|
|
2011-11-16 11:43:28 +01:00
|
|
|
/* Read snapshot ID */
|
2011-08-21 05:09:37 +02:00
|
|
|
sn->id_str = g_malloc(id_str_size + 1);
|
2011-11-16 11:43:28 +01:00
|
|
|
ret = bdrv_pread(bs->file, offset, sn->id_str, id_str_size);
|
|
|
|
if (ret < 0) {
|
2009-05-28 16:07:06 +02:00
|
|
|
goto fail;
|
2011-11-16 11:43:28 +01:00
|
|
|
}
|
2009-05-28 16:07:06 +02:00
|
|
|
offset += id_str_size;
|
|
|
|
sn->id_str[id_str_size] = '\0';
|
|
|
|
|
2011-11-16 11:43:28 +01:00
|
|
|
/* Read snapshot name */
|
2011-08-21 05:09:37 +02:00
|
|
|
sn->name = g_malloc(name_size + 1);
|
2011-11-16 11:43:28 +01:00
|
|
|
ret = bdrv_pread(bs->file, offset, sn->name, name_size);
|
|
|
|
if (ret < 0) {
|
2009-05-28 16:07:06 +02:00
|
|
|
goto fail;
|
2011-11-16 11:43:28 +01:00
|
|
|
}
|
2009-05-28 16:07:06 +02:00
|
|
|
offset += name_size;
|
|
|
|
sn->name[name_size] = '\0';
|
|
|
|
}
|
2011-11-16 11:43:28 +01:00
|
|
|
|
2009-05-28 16:07:06 +02:00
|
|
|
s->snapshots_size = offset - s->snapshots_offset;
|
|
|
|
return 0;
|
2011-11-16 11:43:28 +01:00
|
|
|
|
|
|
|
fail:
|
2009-05-28 16:07:07 +02:00
|
|
|
qcow2_free_snapshots(bs);
|
2011-11-16 11:43:28 +01:00
|
|
|
return ret;
|
2009-05-28 16:07:06 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* add at the end of the file a new list of snapshots */
|
2010-12-17 16:02:39 +01:00
|
|
|
static int qcow2_write_snapshots(BlockDriverState *bs)
|
2009-05-28 16:07:06 +02:00
|
|
|
{
|
|
|
|
BDRVQcowState *s = bs->opaque;
|
|
|
|
QCowSnapshot *sn;
|
|
|
|
QCowSnapshotHeader h;
|
2011-11-16 11:35:54 +01:00
|
|
|
QCowSnapshotExtraData extra;
|
2009-05-28 16:07:06 +02:00
|
|
|
int i, name_size, id_str_size, snapshots_size;
|
2011-11-18 18:27:00 +01:00
|
|
|
struct {
|
|
|
|
uint32_t nb_snapshots;
|
|
|
|
uint64_t snapshots_offset;
|
|
|
|
} QEMU_PACKED header_data;
|
2009-05-28 16:07:06 +02:00
|
|
|
int64_t offset, snapshots_offset;
|
2011-11-16 12:00:59 +01:00
|
|
|
int ret;
|
2009-05-28 16:07:06 +02:00
|
|
|
|
|
|
|
/* 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);
|
2011-11-16 11:35:54 +01:00
|
|
|
offset += sizeof(extra);
|
2009-05-28 16:07:06 +02:00
|
|
|
offset += strlen(sn->id_str);
|
|
|
|
offset += strlen(sn->name);
|
|
|
|
}
|
|
|
|
snapshots_size = offset;
|
|
|
|
|
2011-11-16 12:00:59 +01:00
|
|
|
/* Allocate space for the new snapshot list */
|
2009-05-28 16:07:07 +02:00
|
|
|
snapshots_offset = qcow2_alloc_clusters(bs, snapshots_size);
|
2009-05-28 16:07:06 +02:00
|
|
|
offset = snapshots_offset;
|
2010-01-20 15:04:01 +01:00
|
|
|
if (offset < 0) {
|
2013-10-09 10:51:04 +02:00
|
|
|
ret = offset;
|
|
|
|
goto fail;
|
2010-01-20 15:04:01 +01:00
|
|
|
}
|
2013-03-04 15:02:31 +01:00
|
|
|
ret = bdrv_flush(bs);
|
|
|
|
if (ret < 0) {
|
2013-10-09 10:51:04 +02:00
|
|
|
goto fail;
|
2013-03-04 15:02:31 +01:00
|
|
|
}
|
2009-05-28 16:07:06 +02:00
|
|
|
|
2013-08-30 14:34:26 +02:00
|
|
|
/* The snapshot list position has not yet been updated, so these clusters
|
|
|
|
* must indeed be completely free */
|
2013-10-10 11:09:23 +02:00
|
|
|
ret = qcow2_pre_write_overlap_check(bs, 0, offset, snapshots_size);
|
2013-08-30 14:34:26 +02:00
|
|
|
if (ret < 0) {
|
2013-10-09 10:51:04 +02:00
|
|
|
goto fail;
|
2013-08-30 14:34:26 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-11-16 12:00:59 +01:00
|
|
|
/* Write all snapshots to the new list */
|
2009-05-28 16:07:06 +02:00
|
|
|
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);
|
2011-11-16 11:35:54 +01:00
|
|
|
/* If it doesn't fit in 32 bit, older implementations should treat it
|
|
|
|
* as a disk-only snapshot rather than truncate the VM state */
|
|
|
|
if (sn->vm_state_size <= 0xffffffff) {
|
|
|
|
h.vm_state_size = cpu_to_be32(sn->vm_state_size);
|
|
|
|
}
|
2009-05-28 16:07:06 +02:00
|
|
|
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);
|
2011-11-16 11:35:54 +01:00
|
|
|
h.extra_data_size = cpu_to_be32(sizeof(extra));
|
|
|
|
|
|
|
|
memset(&extra, 0, sizeof(extra));
|
|
|
|
extra.vm_state_size_large = cpu_to_be64(sn->vm_state_size);
|
2012-04-11 16:33:50 +02:00
|
|
|
extra.disk_size = cpu_to_be64(sn->disk_size);
|
2009-05-28 16:07:06 +02:00
|
|
|
|
|
|
|
id_str_size = strlen(sn->id_str);
|
|
|
|
name_size = strlen(sn->name);
|
2013-10-09 10:51:06 +02:00
|
|
|
assert(id_str_size <= UINT16_MAX && name_size <= UINT16_MAX);
|
2009-05-28 16:07:06 +02:00
|
|
|
h.id_str_size = cpu_to_be16(id_str_size);
|
|
|
|
h.name_size = cpu_to_be16(name_size);
|
|
|
|
offset = align_offset(offset, 8);
|
2011-11-16 12:00:59 +01:00
|
|
|
|
|
|
|
ret = bdrv_pwrite(bs->file, offset, &h, sizeof(h));
|
|
|
|
if (ret < 0) {
|
2009-05-28 16:07:06 +02:00
|
|
|
goto fail;
|
2011-11-16 12:00:59 +01:00
|
|
|
}
|
2009-05-28 16:07:06 +02:00
|
|
|
offset += sizeof(h);
|
2011-11-16 12:00:59 +01:00
|
|
|
|
2011-11-16 11:35:54 +01:00
|
|
|
ret = bdrv_pwrite(bs->file, offset, &extra, sizeof(extra));
|
|
|
|
if (ret < 0) {
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
offset += sizeof(extra);
|
|
|
|
|
2011-11-16 12:00:59 +01:00
|
|
|
ret = bdrv_pwrite(bs->file, offset, sn->id_str, id_str_size);
|
|
|
|
if (ret < 0) {
|
2009-05-28 16:07:06 +02:00
|
|
|
goto fail;
|
2011-11-16 12:00:59 +01:00
|
|
|
}
|
2009-05-28 16:07:06 +02:00
|
|
|
offset += id_str_size;
|
2011-11-16 12:00:59 +01:00
|
|
|
|
|
|
|
ret = bdrv_pwrite(bs->file, offset, sn->name, name_size);
|
|
|
|
if (ret < 0) {
|
2009-05-28 16:07:06 +02:00
|
|
|
goto fail;
|
2011-11-16 12:00:59 +01:00
|
|
|
}
|
2009-05-28 16:07:06 +02:00
|
|
|
offset += name_size;
|
|
|
|
}
|
|
|
|
|
2011-11-16 12:00:59 +01:00
|
|
|
/*
|
|
|
|
* Update the header to point to the new snapshot table. This requires the
|
|
|
|
* new table and its refcounts to be stable on disk.
|
|
|
|
*/
|
|
|
|
ret = bdrv_flush(bs);
|
|
|
|
if (ret < 0) {
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2011-11-18 18:27:00 +01:00
|
|
|
QEMU_BUILD_BUG_ON(offsetof(QCowHeader, snapshots_offset) !=
|
|
|
|
offsetof(QCowHeader, nb_snapshots) + sizeof(header_data.nb_snapshots));
|
|
|
|
|
|
|
|
header_data.nb_snapshots = cpu_to_be32(s->nb_snapshots);
|
|
|
|
header_data.snapshots_offset = cpu_to_be64(snapshots_offset);
|
2011-11-16 12:00:59 +01:00
|
|
|
|
|
|
|
ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, nb_snapshots),
|
2011-11-18 18:27:00 +01:00
|
|
|
&header_data, sizeof(header_data));
|
2011-11-16 12:00:59 +01:00
|
|
|
if (ret < 0) {
|
2009-05-28 16:07:06 +02:00
|
|
|
goto fail;
|
2011-11-16 12:00:59 +01:00
|
|
|
}
|
2009-05-28 16:07:06 +02:00
|
|
|
|
|
|
|
/* free the old snapshot table */
|
2013-06-19 13:44:18 +02:00
|
|
|
qcow2_free_clusters(bs, s->snapshots_offset, s->snapshots_size,
|
|
|
|
QCOW2_DISCARD_SNAPSHOT);
|
2009-05-28 16:07:06 +02:00
|
|
|
s->snapshots_offset = snapshots_offset;
|
|
|
|
s->snapshots_size = snapshots_size;
|
|
|
|
return 0;
|
2011-11-16 12:00:59 +01:00
|
|
|
|
|
|
|
fail:
|
2013-10-09 10:51:05 +02:00
|
|
|
if (snapshots_offset > 0) {
|
|
|
|
qcow2_free_clusters(bs, snapshots_offset, snapshots_size,
|
|
|
|
QCOW2_DISCARD_ALWAYS);
|
|
|
|
}
|
2011-11-16 12:00:59 +01:00
|
|
|
return ret;
|
2009-05-28 16:07:06 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void find_new_snapshot_id(BlockDriverState *bs,
|
|
|
|
char *id_str, int id_str_size)
|
|
|
|
{
|
|
|
|
BDRVQcowState *s = bs->opaque;
|
|
|
|
QCowSnapshot *sn;
|
2013-10-09 14:42:47 +02:00
|
|
|
int i;
|
|
|
|
unsigned long id, id_max = 0;
|
2009-05-28 16:07:06 +02:00
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
2013-10-09 14:42:47 +02:00
|
|
|
snprintf(id_str, id_str_size, "%lu", id_max + 1);
|
2009-05-28 16:07:06 +02:00
|
|
|
}
|
|
|
|
|
snapshot: distinguish id and name in snapshot delete
Snapshot creation actually already distinguish id and name since it take
a structured parameter *sn, but delete can't. Later an accurate delete
is needed in qmp_transaction abort and blockdev-snapshot-delete-sync,
so change its prototype. Also *errp is added to tip error, but return
value is kepted to let caller check what kind of error happens. Existing
caller for it are savevm, delvm and qemu-img, they are not impacted by
introducing a new function bdrv_snapshot_delete_by_id_or_name(), which
check the return value and do the operation again.
Before this patch:
For qcow2, it search id first then name to find the one to delete.
For rbd, it search name.
For sheepdog, it does nothing.
After this patch:
For qcow2, logic is the same by call it twice in caller.
For rbd, it always fails in delete with id, but still search for name
in second try, no change to user.
Some code for *errp is based on Pavel's patch.
Signed-off-by: Wenchao Xia <xiawenc@linux.vnet.ibm.com>
Signed-off-by: Pavel Hrdina <phrdina@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2013-09-11 08:04:33 +02:00
|
|
|
static int find_snapshot_by_id_and_name(BlockDriverState *bs,
|
|
|
|
const char *id,
|
|
|
|
const char *name)
|
2009-05-28 16:07:06 +02:00
|
|
|
{
|
|
|
|
BDRVQcowState *s = bs->opaque;
|
|
|
|
int i;
|
|
|
|
|
snapshot: distinguish id and name in snapshot delete
Snapshot creation actually already distinguish id and name since it take
a structured parameter *sn, but delete can't. Later an accurate delete
is needed in qmp_transaction abort and blockdev-snapshot-delete-sync,
so change its prototype. Also *errp is added to tip error, but return
value is kepted to let caller check what kind of error happens. Existing
caller for it are savevm, delvm and qemu-img, they are not impacted by
introducing a new function bdrv_snapshot_delete_by_id_or_name(), which
check the return value and do the operation again.
Before this patch:
For qcow2, it search id first then name to find the one to delete.
For rbd, it search name.
For sheepdog, it does nothing.
After this patch:
For qcow2, logic is the same by call it twice in caller.
For rbd, it always fails in delete with id, but still search for name
in second try, no change to user.
Some code for *errp is based on Pavel's patch.
Signed-off-by: Wenchao Xia <xiawenc@linux.vnet.ibm.com>
Signed-off-by: Pavel Hrdina <phrdina@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2013-09-11 08:04:33 +02:00
|
|
|
if (id && name) {
|
|
|
|
for (i = 0; i < s->nb_snapshots; i++) {
|
|
|
|
if (!strcmp(s->snapshots[i].id_str, id) &&
|
|
|
|
!strcmp(s->snapshots[i].name, name)) {
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else if (id) {
|
|
|
|
for (i = 0; i < s->nb_snapshots; i++) {
|
|
|
|
if (!strcmp(s->snapshots[i].id_str, id)) {
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else if (name) {
|
|
|
|
for (i = 0; i < s->nb_snapshots; i++) {
|
|
|
|
if (!strcmp(s->snapshots[i].name, name)) {
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
}
|
2009-05-28 16:07:06 +02:00
|
|
|
}
|
snapshot: distinguish id and name in snapshot delete
Snapshot creation actually already distinguish id and name since it take
a structured parameter *sn, but delete can't. Later an accurate delete
is needed in qmp_transaction abort and blockdev-snapshot-delete-sync,
so change its prototype. Also *errp is added to tip error, but return
value is kepted to let caller check what kind of error happens. Existing
caller for it are savevm, delvm and qemu-img, they are not impacted by
introducing a new function bdrv_snapshot_delete_by_id_or_name(), which
check the return value and do the operation again.
Before this patch:
For qcow2, it search id first then name to find the one to delete.
For rbd, it search name.
For sheepdog, it does nothing.
After this patch:
For qcow2, logic is the same by call it twice in caller.
For rbd, it always fails in delete with id, but still search for name
in second try, no change to user.
Some code for *errp is based on Pavel's patch.
Signed-off-by: Wenchao Xia <xiawenc@linux.vnet.ibm.com>
Signed-off-by: Pavel Hrdina <phrdina@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2013-09-11 08:04:33 +02:00
|
|
|
|
2009-05-28 16:07:06 +02:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
snapshot: distinguish id and name in snapshot delete
Snapshot creation actually already distinguish id and name since it take
a structured parameter *sn, but delete can't. Later an accurate delete
is needed in qmp_transaction abort and blockdev-snapshot-delete-sync,
so change its prototype. Also *errp is added to tip error, but return
value is kepted to let caller check what kind of error happens. Existing
caller for it are savevm, delvm and qemu-img, they are not impacted by
introducing a new function bdrv_snapshot_delete_by_id_or_name(), which
check the return value and do the operation again.
Before this patch:
For qcow2, it search id first then name to find the one to delete.
For rbd, it search name.
For sheepdog, it does nothing.
After this patch:
For qcow2, logic is the same by call it twice in caller.
For rbd, it always fails in delete with id, but still search for name
in second try, no change to user.
Some code for *errp is based on Pavel's patch.
Signed-off-by: Wenchao Xia <xiawenc@linux.vnet.ibm.com>
Signed-off-by: Pavel Hrdina <phrdina@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2013-09-11 08:04:33 +02:00
|
|
|
static int find_snapshot_by_id_or_name(BlockDriverState *bs,
|
|
|
|
const char *id_or_name)
|
2009-05-28 16:07:06 +02:00
|
|
|
{
|
snapshot: distinguish id and name in snapshot delete
Snapshot creation actually already distinguish id and name since it take
a structured parameter *sn, but delete can't. Later an accurate delete
is needed in qmp_transaction abort and blockdev-snapshot-delete-sync,
so change its prototype. Also *errp is added to tip error, but return
value is kepted to let caller check what kind of error happens. Existing
caller for it are savevm, delvm and qemu-img, they are not impacted by
introducing a new function bdrv_snapshot_delete_by_id_or_name(), which
check the return value and do the operation again.
Before this patch:
For qcow2, it search id first then name to find the one to delete.
For rbd, it search name.
For sheepdog, it does nothing.
After this patch:
For qcow2, logic is the same by call it twice in caller.
For rbd, it always fails in delete with id, but still search for name
in second try, no change to user.
Some code for *errp is based on Pavel's patch.
Signed-off-by: Wenchao Xia <xiawenc@linux.vnet.ibm.com>
Signed-off-by: Pavel Hrdina <phrdina@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2013-09-11 08:04:33 +02:00
|
|
|
int ret;
|
2009-05-28 16:07:06 +02:00
|
|
|
|
snapshot: distinguish id and name in snapshot delete
Snapshot creation actually already distinguish id and name since it take
a structured parameter *sn, but delete can't. Later an accurate delete
is needed in qmp_transaction abort and blockdev-snapshot-delete-sync,
so change its prototype. Also *errp is added to tip error, but return
value is kepted to let caller check what kind of error happens. Existing
caller for it are savevm, delvm and qemu-img, they are not impacted by
introducing a new function bdrv_snapshot_delete_by_id_or_name(), which
check the return value and do the operation again.
Before this patch:
For qcow2, it search id first then name to find the one to delete.
For rbd, it search name.
For sheepdog, it does nothing.
After this patch:
For qcow2, logic is the same by call it twice in caller.
For rbd, it always fails in delete with id, but still search for name
in second try, no change to user.
Some code for *errp is based on Pavel's patch.
Signed-off-by: Wenchao Xia <xiawenc@linux.vnet.ibm.com>
Signed-off-by: Pavel Hrdina <phrdina@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2013-09-11 08:04:33 +02:00
|
|
|
ret = find_snapshot_by_id_and_name(bs, id_or_name, NULL);
|
|
|
|
if (ret >= 0) {
|
2009-05-28 16:07:06 +02:00
|
|
|
return ret;
|
|
|
|
}
|
snapshot: distinguish id and name in snapshot delete
Snapshot creation actually already distinguish id and name since it take
a structured parameter *sn, but delete can't. Later an accurate delete
is needed in qmp_transaction abort and blockdev-snapshot-delete-sync,
so change its prototype. Also *errp is added to tip error, but return
value is kepted to let caller check what kind of error happens. Existing
caller for it are savevm, delvm and qemu-img, they are not impacted by
introducing a new function bdrv_snapshot_delete_by_id_or_name(), which
check the return value and do the operation again.
Before this patch:
For qcow2, it search id first then name to find the one to delete.
For rbd, it search name.
For sheepdog, it does nothing.
After this patch:
For qcow2, logic is the same by call it twice in caller.
For rbd, it always fails in delete with id, but still search for name
in second try, no change to user.
Some code for *errp is based on Pavel's patch.
Signed-off-by: Wenchao Xia <xiawenc@linux.vnet.ibm.com>
Signed-off-by: Pavel Hrdina <phrdina@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2013-09-11 08:04:33 +02:00
|
|
|
return find_snapshot_by_id_and_name(bs, NULL, id_or_name);
|
2009-05-28 16:07:06 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* if no id is provided, a new one is constructed */
|
2009-05-28 16:07:07 +02:00
|
|
|
int qcow2_snapshot_create(BlockDriverState *bs, QEMUSnapshotInfo *sn_info)
|
2009-05-28 16:07:06 +02:00
|
|
|
{
|
|
|
|
BDRVQcowState *s = bs->opaque;
|
2011-11-16 12:43:59 +01:00
|
|
|
QCowSnapshot *new_snapshot_list = NULL;
|
|
|
|
QCowSnapshot *old_snapshot_list = NULL;
|
|
|
|
QCowSnapshot sn1, *sn = &sn1;
|
2009-05-28 16:07:06 +02:00
|
|
|
int i, ret;
|
|
|
|
uint64_t *l1_table = NULL;
|
2010-01-20 15:04:01 +01:00
|
|
|
int64_t l1_table_offset;
|
2009-05-28 16:07:06 +02:00
|
|
|
|
|
|
|
memset(sn, 0, sizeof(*sn));
|
|
|
|
|
2011-11-16 17:46:29 +01:00
|
|
|
/* Generate an ID if it wasn't passed */
|
2009-05-28 16:07:06 +02:00
|
|
|
if (sn_info->id_str[0] == '\0') {
|
|
|
|
find_new_snapshot_id(bs, sn_info->id_str, sizeof(sn_info->id_str));
|
|
|
|
}
|
|
|
|
|
2011-11-16 17:46:29 +01:00
|
|
|
/* Check that the ID is unique */
|
snapshot: distinguish id and name in snapshot delete
Snapshot creation actually already distinguish id and name since it take
a structured parameter *sn, but delete can't. Later an accurate delete
is needed in qmp_transaction abort and blockdev-snapshot-delete-sync,
so change its prototype. Also *errp is added to tip error, but return
value is kepted to let caller check what kind of error happens. Existing
caller for it are savevm, delvm and qemu-img, they are not impacted by
introducing a new function bdrv_snapshot_delete_by_id_or_name(), which
check the return value and do the operation again.
Before this patch:
For qcow2, it search id first then name to find the one to delete.
For rbd, it search name.
For sheepdog, it does nothing.
After this patch:
For qcow2, logic is the same by call it twice in caller.
For rbd, it always fails in delete with id, but still search for name
in second try, no change to user.
Some code for *errp is based on Pavel's patch.
Signed-off-by: Wenchao Xia <xiawenc@linux.vnet.ibm.com>
Signed-off-by: Pavel Hrdina <phrdina@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2013-09-11 08:04:33 +02:00
|
|
|
if (find_snapshot_by_id_and_name(bs, sn_info->id_str, NULL) >= 0) {
|
2012-04-26 10:11:37 +02:00
|
|
|
return -EEXIST;
|
2011-11-16 17:46:29 +01:00
|
|
|
}
|
2009-05-28 16:07:06 +02:00
|
|
|
|
2011-11-16 17:46:29 +01:00
|
|
|
/* Populate sn with passed data */
|
2011-08-21 05:09:37 +02:00
|
|
|
sn->id_str = g_strdup(sn_info->id_str);
|
|
|
|
sn->name = g_strdup(sn_info->name);
|
2011-11-16 17:46:29 +01:00
|
|
|
|
2012-04-11 16:33:50 +02:00
|
|
|
sn->disk_size = bs->total_sectors * BDRV_SECTOR_SIZE;
|
2009-05-28 16:07:06 +02:00
|
|
|
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;
|
|
|
|
|
2011-11-16 17:46:29 +01:00
|
|
|
/* Allocate the L1 table of the snapshot and copy the current one there. */
|
2010-01-20 15:04:01 +01:00
|
|
|
l1_table_offset = qcow2_alloc_clusters(bs, s->l1_size * sizeof(uint64_t));
|
|
|
|
if (l1_table_offset < 0) {
|
2011-11-16 12:43:59 +01:00
|
|
|
ret = l1_table_offset;
|
2010-01-20 15:04:01 +01:00
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
sn->l1_table_offset = l1_table_offset;
|
2009-05-28 16:07:06 +02:00
|
|
|
sn->l1_size = s->l1_size;
|
|
|
|
|
2011-11-16 17:46:29 +01:00
|
|
|
l1_table = g_malloc(s->l1_size * sizeof(uint64_t));
|
2009-05-28 16:07:06 +02:00
|
|
|
for(i = 0; i < s->l1_size; i++) {
|
|
|
|
l1_table[i] = cpu_to_be64(s->l1_table[i]);
|
|
|
|
}
|
2011-11-16 12:43:59 +01:00
|
|
|
|
2013-10-10 11:09:23 +02:00
|
|
|
ret = qcow2_pre_write_overlap_check(bs, 0, sn->l1_table_offset,
|
|
|
|
s->l1_size * sizeof(uint64_t));
|
2013-08-30 14:34:26 +02:00
|
|
|
if (ret < 0) {
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2011-11-16 12:43:59 +01:00
|
|
|
ret = bdrv_pwrite(bs->file, sn->l1_table_offset, l1_table,
|
|
|
|
s->l1_size * sizeof(uint64_t));
|
|
|
|
if (ret < 0) {
|
2009-05-28 16:07:06 +02:00
|
|
|
goto fail;
|
2011-11-16 12:43:59 +01:00
|
|
|
}
|
|
|
|
|
2011-08-21 05:09:37 +02:00
|
|
|
g_free(l1_table);
|
2009-05-28 16:07:06 +02:00
|
|
|
l1_table = NULL;
|
|
|
|
|
2011-11-16 12:43:59 +01:00
|
|
|
/*
|
|
|
|
* Increase the refcounts of all clusters and make sure everything is
|
|
|
|
* stable on disk before updating the snapshot table to contain a pointer
|
|
|
|
* to the new L1 table.
|
|
|
|
*/
|
|
|
|
ret = qcow2_update_snapshot_refcount(bs, s->l1_table_offset, s->l1_size, 1);
|
|
|
|
if (ret < 0) {
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Append the new snapshot to the snapshot list */
|
|
|
|
new_snapshot_list = g_malloc((s->nb_snapshots + 1) * sizeof(QCowSnapshot));
|
2009-05-28 16:07:06 +02:00
|
|
|
if (s->snapshots) {
|
2011-11-16 12:43:59 +01:00
|
|
|
memcpy(new_snapshot_list, s->snapshots,
|
|
|
|
s->nb_snapshots * sizeof(QCowSnapshot));
|
|
|
|
old_snapshot_list = s->snapshots;
|
2009-05-28 16:07:06 +02:00
|
|
|
}
|
2011-11-16 12:43:59 +01:00
|
|
|
s->snapshots = new_snapshot_list;
|
2009-05-28 16:07:06 +02:00
|
|
|
s->snapshots[s->nb_snapshots++] = *sn;
|
|
|
|
|
2011-11-16 12:43:59 +01:00
|
|
|
ret = qcow2_write_snapshots(bs);
|
|
|
|
if (ret < 0) {
|
|
|
|
g_free(s->snapshots);
|
|
|
|
s->snapshots = old_snapshot_list;
|
2013-10-09 14:42:00 +02:00
|
|
|
s->nb_snapshots--;
|
2009-05-28 16:07:06 +02:00
|
|
|
goto fail;
|
2011-11-16 12:43:59 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
g_free(old_snapshot_list);
|
|
|
|
|
2013-09-06 12:20:08 +02:00
|
|
|
/* The VM state isn't needed any more in the active L1 table; in fact, it
|
|
|
|
* hurts by causing expensive COW for the next snapshot. */
|
|
|
|
qcow2_discard_clusters(bs, qcow2_vm_state_offset(s),
|
|
|
|
align_offset(sn->vm_state_size, s->cluster_size)
|
|
|
|
>> BDRV_SECTOR_BITS,
|
|
|
|
QCOW2_DISCARD_NEVER);
|
|
|
|
|
2009-05-28 16:07:06 +02:00
|
|
|
#ifdef DEBUG_ALLOC
|
2011-08-04 19:22:10 +02:00
|
|
|
{
|
|
|
|
BdrvCheckResult result = {0};
|
2012-06-15 17:41:07 +02:00
|
|
|
qcow2_check_refcounts(bs, &result, 0);
|
2011-08-04 19:22:10 +02:00
|
|
|
}
|
2009-05-28 16:07:06 +02:00
|
|
|
#endif
|
|
|
|
return 0;
|
2011-11-16 17:46:29 +01:00
|
|
|
|
|
|
|
fail:
|
|
|
|
g_free(sn->id_str);
|
2011-08-21 05:09:37 +02:00
|
|
|
g_free(sn->name);
|
|
|
|
g_free(l1_table);
|
2011-11-16 12:43:59 +01:00
|
|
|
|
|
|
|
return ret;
|
2009-05-28 16:07:06 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* copy the snapshot 'snapshot_name' into the current disk image */
|
2009-05-28 16:07:07 +02:00
|
|
|
int qcow2_snapshot_goto(BlockDriverState *bs, const char *snapshot_id)
|
2009-05-28 16:07:06 +02:00
|
|
|
{
|
|
|
|
BDRVQcowState *s = bs->opaque;
|
|
|
|
QCowSnapshot *sn;
|
2011-08-05 12:06:11 +02:00
|
|
|
int i, snapshot_index;
|
|
|
|
int cur_l1_bytes, sn_l1_bytes;
|
2011-11-16 15:04:11 +01:00
|
|
|
int ret;
|
2011-11-16 15:20:45 +01:00
|
|
|
uint64_t *sn_l1_table = NULL;
|
2009-05-28 16:07:06 +02:00
|
|
|
|
2011-11-16 15:04:11 +01:00
|
|
|
/* Search the snapshot */
|
2009-05-28 16:07:06 +02:00
|
|
|
snapshot_index = find_snapshot_by_id_or_name(bs, snapshot_id);
|
2011-11-16 15:04:11 +01:00
|
|
|
if (snapshot_index < 0) {
|
2009-05-28 16:07:06 +02:00
|
|
|
return -ENOENT;
|
2011-11-16 15:04:11 +01:00
|
|
|
}
|
2009-05-28 16:07:06 +02:00
|
|
|
sn = &s->snapshots[snapshot_index];
|
|
|
|
|
2012-04-11 16:33:50 +02:00
|
|
|
if (sn->disk_size != bs->total_sectors * BDRV_SECTOR_SIZE) {
|
|
|
|
error_report("qcow2: Loading snapshots with different disk "
|
|
|
|
"size is not implemented");
|
|
|
|
ret = -ENOTSUP;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2011-11-16 15:04:11 +01:00
|
|
|
/*
|
|
|
|
* Make sure that the current L1 table is big enough to contain the whole
|
|
|
|
* L1 table of the snapshot. If the snapshot L1 table is smaller, the
|
|
|
|
* current one must be padded with zeros.
|
|
|
|
*/
|
|
|
|
ret = qcow2_grow_l1_table(bs, sn->l1_size, true);
|
|
|
|
if (ret < 0) {
|
2009-05-28 16:07:06 +02:00
|
|
|
goto fail;
|
2011-11-16 15:04:11 +01:00
|
|
|
}
|
2009-05-28 16:07:06 +02:00
|
|
|
|
2011-08-05 12:06:11 +02:00
|
|
|
cur_l1_bytes = s->l1_size * sizeof(uint64_t);
|
|
|
|
sn_l1_bytes = sn->l1_size * sizeof(uint64_t);
|
|
|
|
|
2011-11-16 15:04:11 +01:00
|
|
|
/*
|
|
|
|
* Copy the snapshot L1 table to the current L1 table.
|
|
|
|
*
|
|
|
|
* Before overwriting the old current L1 table on disk, make sure to
|
|
|
|
* increase all refcounts for the clusters referenced by the new one.
|
2011-11-16 15:20:45 +01:00
|
|
|
* Decrease the refcount referenced by the old one only when the L1
|
|
|
|
* table is overwritten.
|
2011-11-16 15:04:11 +01:00
|
|
|
*/
|
2011-11-16 15:20:45 +01:00
|
|
|
sn_l1_table = g_malloc0(cur_l1_bytes);
|
|
|
|
|
|
|
|
ret = bdrv_pread(bs->file, sn->l1_table_offset, sn_l1_table, sn_l1_bytes);
|
|
|
|
if (ret < 0) {
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = qcow2_update_snapshot_refcount(bs, sn->l1_table_offset,
|
|
|
|
sn->l1_size, 1);
|
2011-11-16 15:04:11 +01:00
|
|
|
if (ret < 0) {
|
2009-05-28 16:07:06 +02:00
|
|
|
goto fail;
|
2011-11-16 15:04:11 +01:00
|
|
|
}
|
|
|
|
|
2013-10-10 11:09:23 +02:00
|
|
|
ret = qcow2_pre_write_overlap_check(bs, QCOW2_OL_ACTIVE_L1,
|
|
|
|
s->l1_table_offset, cur_l1_bytes);
|
2013-08-30 14:34:26 +02:00
|
|
|
if (ret < 0) {
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2011-11-16 15:20:45 +01:00
|
|
|
ret = bdrv_pwrite_sync(bs->file, s->l1_table_offset, sn_l1_table,
|
2011-11-16 15:04:11 +01:00
|
|
|
cur_l1_bytes);
|
|
|
|
if (ret < 0) {
|
2009-05-28 16:07:06 +02:00
|
|
|
goto fail;
|
2011-11-16 15:04:11 +01:00
|
|
|
}
|
|
|
|
|
2011-11-16 15:20:45 +01:00
|
|
|
/*
|
|
|
|
* Decrease refcount of clusters of current L1 table.
|
|
|
|
*
|
|
|
|
* At this point, the in-memory s->l1_table points to the old L1 table,
|
|
|
|
* whereas on disk we already have the new one.
|
|
|
|
*
|
|
|
|
* qcow2_update_snapshot_refcount special cases the current L1 table to use
|
|
|
|
* the in-memory data instead of really using the offset to load a new one,
|
|
|
|
* which is why this works.
|
|
|
|
*/
|
|
|
|
ret = qcow2_update_snapshot_refcount(bs, s->l1_table_offset,
|
|
|
|
s->l1_size, -1);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Now update the in-memory L1 table to be in sync with the on-disk one. We
|
|
|
|
* need to do this even if updating refcounts failed.
|
|
|
|
*/
|
2009-05-28 16:07:06 +02:00
|
|
|
for(i = 0;i < s->l1_size; i++) {
|
2011-11-16 15:20:45 +01:00
|
|
|
s->l1_table[i] = be64_to_cpu(sn_l1_table[i]);
|
2009-05-28 16:07:06 +02:00
|
|
|
}
|
|
|
|
|
2011-11-16 15:20:45 +01:00
|
|
|
if (ret < 0) {
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
g_free(sn_l1_table);
|
|
|
|
sn_l1_table = NULL;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Update QCOW_OFLAG_COPIED in the active L1 table (it may have changed
|
|
|
|
* when we decreased the refcount of the old snapshot.
|
|
|
|
*/
|
|
|
|
ret = qcow2_update_snapshot_refcount(bs, s->l1_table_offset, s->l1_size, 0);
|
2011-11-16 15:04:11 +01:00
|
|
|
if (ret < 0) {
|
2009-05-28 16:07:06 +02:00
|
|
|
goto fail;
|
2011-11-16 15:04:11 +01:00
|
|
|
}
|
2009-05-28 16:07:06 +02:00
|
|
|
|
|
|
|
#ifdef DEBUG_ALLOC
|
2011-08-04 19:22:10 +02:00
|
|
|
{
|
|
|
|
BdrvCheckResult result = {0};
|
2012-06-15 17:41:07 +02:00
|
|
|
qcow2_check_refcounts(bs, &result, 0);
|
2011-08-04 19:22:10 +02:00
|
|
|
}
|
2009-05-28 16:07:06 +02:00
|
|
|
#endif
|
|
|
|
return 0;
|
2011-11-16 15:04:11 +01:00
|
|
|
|
|
|
|
fail:
|
2011-11-16 15:20:45 +01:00
|
|
|
g_free(sn_l1_table);
|
2011-11-16 15:04:11 +01:00
|
|
|
return ret;
|
2009-05-28 16:07:06 +02:00
|
|
|
}
|
|
|
|
|
snapshot: distinguish id and name in snapshot delete
Snapshot creation actually already distinguish id and name since it take
a structured parameter *sn, but delete can't. Later an accurate delete
is needed in qmp_transaction abort and blockdev-snapshot-delete-sync,
so change its prototype. Also *errp is added to tip error, but return
value is kepted to let caller check what kind of error happens. Existing
caller for it are savevm, delvm and qemu-img, they are not impacted by
introducing a new function bdrv_snapshot_delete_by_id_or_name(), which
check the return value and do the operation again.
Before this patch:
For qcow2, it search id first then name to find the one to delete.
For rbd, it search name.
For sheepdog, it does nothing.
After this patch:
For qcow2, logic is the same by call it twice in caller.
For rbd, it always fails in delete with id, but still search for name
in second try, no change to user.
Some code for *errp is based on Pavel's patch.
Signed-off-by: Wenchao Xia <xiawenc@linux.vnet.ibm.com>
Signed-off-by: Pavel Hrdina <phrdina@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2013-09-11 08:04:33 +02:00
|
|
|
int qcow2_snapshot_delete(BlockDriverState *bs,
|
|
|
|
const char *snapshot_id,
|
|
|
|
const char *name,
|
|
|
|
Error **errp)
|
2009-05-28 16:07:06 +02:00
|
|
|
{
|
|
|
|
BDRVQcowState *s = bs->opaque;
|
2011-11-16 17:22:10 +01:00
|
|
|
QCowSnapshot sn;
|
2009-05-28 16:07:06 +02:00
|
|
|
int snapshot_index, ret;
|
|
|
|
|
2011-11-16 17:22:10 +01:00
|
|
|
/* Search the snapshot */
|
snapshot: distinguish id and name in snapshot delete
Snapshot creation actually already distinguish id and name since it take
a structured parameter *sn, but delete can't. Later an accurate delete
is needed in qmp_transaction abort and blockdev-snapshot-delete-sync,
so change its prototype. Also *errp is added to tip error, but return
value is kepted to let caller check what kind of error happens. Existing
caller for it are savevm, delvm and qemu-img, they are not impacted by
introducing a new function bdrv_snapshot_delete_by_id_or_name(), which
check the return value and do the operation again.
Before this patch:
For qcow2, it search id first then name to find the one to delete.
For rbd, it search name.
For sheepdog, it does nothing.
After this patch:
For qcow2, logic is the same by call it twice in caller.
For rbd, it always fails in delete with id, but still search for name
in second try, no change to user.
Some code for *errp is based on Pavel's patch.
Signed-off-by: Wenchao Xia <xiawenc@linux.vnet.ibm.com>
Signed-off-by: Pavel Hrdina <phrdina@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2013-09-11 08:04:33 +02:00
|
|
|
snapshot_index = find_snapshot_by_id_and_name(bs, snapshot_id, name);
|
2011-11-16 17:22:10 +01:00
|
|
|
if (snapshot_index < 0) {
|
snapshot: distinguish id and name in snapshot delete
Snapshot creation actually already distinguish id and name since it take
a structured parameter *sn, but delete can't. Later an accurate delete
is needed in qmp_transaction abort and blockdev-snapshot-delete-sync,
so change its prototype. Also *errp is added to tip error, but return
value is kepted to let caller check what kind of error happens. Existing
caller for it are savevm, delvm and qemu-img, they are not impacted by
introducing a new function bdrv_snapshot_delete_by_id_or_name(), which
check the return value and do the operation again.
Before this patch:
For qcow2, it search id first then name to find the one to delete.
For rbd, it search name.
For sheepdog, it does nothing.
After this patch:
For qcow2, logic is the same by call it twice in caller.
For rbd, it always fails in delete with id, but still search for name
in second try, no change to user.
Some code for *errp is based on Pavel's patch.
Signed-off-by: Wenchao Xia <xiawenc@linux.vnet.ibm.com>
Signed-off-by: Pavel Hrdina <phrdina@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2013-09-11 08:04:33 +02:00
|
|
|
error_setg(errp, "Can't find the snapshot");
|
2009-05-28 16:07:06 +02:00
|
|
|
return -ENOENT;
|
2011-11-16 17:22:10 +01:00
|
|
|
}
|
|
|
|
sn = s->snapshots[snapshot_index];
|
2009-05-28 16:07:06 +02:00
|
|
|
|
2011-11-16 17:22:10 +01:00
|
|
|
/* Remove it from the snapshot list */
|
|
|
|
memmove(s->snapshots + snapshot_index,
|
|
|
|
s->snapshots + snapshot_index + 1,
|
|
|
|
(s->nb_snapshots - snapshot_index - 1) * sizeof(sn));
|
|
|
|
s->nb_snapshots--;
|
|
|
|
ret = qcow2_write_snapshots(bs);
|
|
|
|
if (ret < 0) {
|
snapshot: distinguish id and name in snapshot delete
Snapshot creation actually already distinguish id and name since it take
a structured parameter *sn, but delete can't. Later an accurate delete
is needed in qmp_transaction abort and blockdev-snapshot-delete-sync,
so change its prototype. Also *errp is added to tip error, but return
value is kepted to let caller check what kind of error happens. Existing
caller for it are savevm, delvm and qemu-img, they are not impacted by
introducing a new function bdrv_snapshot_delete_by_id_or_name(), which
check the return value and do the operation again.
Before this patch:
For qcow2, it search id first then name to find the one to delete.
For rbd, it search name.
For sheepdog, it does nothing.
After this patch:
For qcow2, logic is the same by call it twice in caller.
For rbd, it always fails in delete with id, but still search for name
in second try, no change to user.
Some code for *errp is based on Pavel's patch.
Signed-off-by: Wenchao Xia <xiawenc@linux.vnet.ibm.com>
Signed-off-by: Pavel Hrdina <phrdina@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2013-09-11 08:04:33 +02:00
|
|
|
error_setg(errp, "Failed to remove snapshot from snapshot list");
|
2009-05-28 16:07:06 +02:00
|
|
|
return ret;
|
2011-11-16 17:22:10 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The snapshot is now unused, clean up. If we fail after this point, we
|
|
|
|
* won't recover but just leak clusters.
|
|
|
|
*/
|
|
|
|
g_free(sn.id_str);
|
|
|
|
g_free(sn.name);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Now decrease the refcounts of clusters referenced by the snapshot and
|
|
|
|
* free the L1 table.
|
|
|
|
*/
|
|
|
|
ret = qcow2_update_snapshot_refcount(bs, sn.l1_table_offset,
|
|
|
|
sn.l1_size, -1);
|
|
|
|
if (ret < 0) {
|
snapshot: distinguish id and name in snapshot delete
Snapshot creation actually already distinguish id and name since it take
a structured parameter *sn, but delete can't. Later an accurate delete
is needed in qmp_transaction abort and blockdev-snapshot-delete-sync,
so change its prototype. Also *errp is added to tip error, but return
value is kepted to let caller check what kind of error happens. Existing
caller for it are savevm, delvm and qemu-img, they are not impacted by
introducing a new function bdrv_snapshot_delete_by_id_or_name(), which
check the return value and do the operation again.
Before this patch:
For qcow2, it search id first then name to find the one to delete.
For rbd, it search name.
For sheepdog, it does nothing.
After this patch:
For qcow2, logic is the same by call it twice in caller.
For rbd, it always fails in delete with id, but still search for name
in second try, no change to user.
Some code for *errp is based on Pavel's patch.
Signed-off-by: Wenchao Xia <xiawenc@linux.vnet.ibm.com>
Signed-off-by: Pavel Hrdina <phrdina@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2013-09-11 08:04:33 +02:00
|
|
|
error_setg(errp, "Failed to free the cluster and L1 table");
|
2009-05-28 16:07:06 +02:00
|
|
|
return ret;
|
2011-11-16 17:22:10 +01:00
|
|
|
}
|
2013-06-19 13:44:18 +02:00
|
|
|
qcow2_free_clusters(bs, sn.l1_table_offset, sn.l1_size * sizeof(uint64_t),
|
|
|
|
QCOW2_DISCARD_SNAPSHOT);
|
2009-05-28 16:07:06 +02:00
|
|
|
|
2011-11-16 17:22:10 +01:00
|
|
|
/* must update the copied flag on the current cluster offsets */
|
|
|
|
ret = qcow2_update_snapshot_refcount(bs, s->l1_table_offset, s->l1_size, 0);
|
2009-05-28 16:07:06 +02:00
|
|
|
if (ret < 0) {
|
snapshot: distinguish id and name in snapshot delete
Snapshot creation actually already distinguish id and name since it take
a structured parameter *sn, but delete can't. Later an accurate delete
is needed in qmp_transaction abort and blockdev-snapshot-delete-sync,
so change its prototype. Also *errp is added to tip error, but return
value is kepted to let caller check what kind of error happens. Existing
caller for it are savevm, delvm and qemu-img, they are not impacted by
introducing a new function bdrv_snapshot_delete_by_id_or_name(), which
check the return value and do the operation again.
Before this patch:
For qcow2, it search id first then name to find the one to delete.
For rbd, it search name.
For sheepdog, it does nothing.
After this patch:
For qcow2, logic is the same by call it twice in caller.
For rbd, it always fails in delete with id, but still search for name
in second try, no change to user.
Some code for *errp is based on Pavel's patch.
Signed-off-by: Wenchao Xia <xiawenc@linux.vnet.ibm.com>
Signed-off-by: Pavel Hrdina <phrdina@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2013-09-11 08:04:33 +02:00
|
|
|
error_setg(errp, "Failed to update snapshot status in disk");
|
2009-05-28 16:07:06 +02:00
|
|
|
return ret;
|
|
|
|
}
|
2011-11-16 17:22:10 +01:00
|
|
|
|
2009-05-28 16:07:06 +02:00
|
|
|
#ifdef DEBUG_ALLOC
|
2011-08-04 19:22:10 +02:00
|
|
|
{
|
|
|
|
BdrvCheckResult result = {0};
|
2012-06-15 17:41:07 +02:00
|
|
|
qcow2_check_refcounts(bs, &result, 0);
|
2011-08-04 19:22:10 +02:00
|
|
|
}
|
2009-05-28 16:07:06 +02:00
|
|
|
#endif
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-05-28 16:07:07 +02:00
|
|
|
int qcow2_snapshot_list(BlockDriverState *bs, QEMUSnapshotInfo **psn_tab)
|
2009-05-28 16:07:06 +02:00
|
|
|
{
|
|
|
|
BDRVQcowState *s = bs->opaque;
|
|
|
|
QEMUSnapshotInfo *sn_tab, *sn_info;
|
|
|
|
QCowSnapshot *sn;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (!s->nb_snapshots) {
|
|
|
|
*psn_tab = NULL;
|
|
|
|
return s->nb_snapshots;
|
|
|
|
}
|
|
|
|
|
2011-08-21 05:09:37 +02:00
|
|
|
sn_tab = g_malloc0(s->nb_snapshots * sizeof(QEMUSnapshotInfo));
|
2009-05-28 16:07:06 +02:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2010-09-22 04:58:41 +02:00
|
|
|
int qcow2_snapshot_load_tmp(BlockDriverState *bs, const char *snapshot_name)
|
|
|
|
{
|
2011-11-16 17:30:33 +01:00
|
|
|
int i, snapshot_index;
|
2010-09-22 04:58:41 +02:00
|
|
|
BDRVQcowState *s = bs->opaque;
|
|
|
|
QCowSnapshot *sn;
|
2011-11-16 17:30:33 +01:00
|
|
|
uint64_t *new_l1_table;
|
|
|
|
int new_l1_bytes;
|
|
|
|
int ret;
|
2010-09-22 04:58:41 +02:00
|
|
|
|
2011-11-16 17:30:33 +01:00
|
|
|
assert(bs->read_only);
|
|
|
|
|
|
|
|
/* Search the snapshot */
|
2010-09-22 04:58:41 +02:00
|
|
|
snapshot_index = find_snapshot_by_id_or_name(bs, snapshot_name);
|
|
|
|
if (snapshot_index < 0) {
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
|
|
|
sn = &s->snapshots[snapshot_index];
|
|
|
|
|
2011-11-16 17:30:33 +01:00
|
|
|
/* Allocate and read in the snapshot's L1 table */
|
|
|
|
new_l1_bytes = s->l1_size * sizeof(uint64_t);
|
|
|
|
new_l1_table = g_malloc0(align_offset(new_l1_bytes, 512));
|
2010-09-22 04:58:41 +02:00
|
|
|
|
2011-11-16 17:30:33 +01:00
|
|
|
ret = bdrv_pread(bs->file, sn->l1_table_offset, new_l1_table, new_l1_bytes);
|
|
|
|
if (ret < 0) {
|
|
|
|
g_free(new_l1_table);
|
|
|
|
return ret;
|
2010-09-22 04:58:41 +02:00
|
|
|
}
|
|
|
|
|
2011-11-16 17:30:33 +01:00
|
|
|
/* Switch the L1 table */
|
|
|
|
g_free(s->l1_table);
|
|
|
|
|
|
|
|
s->l1_size = sn->l1_size;
|
|
|
|
s->l1_table_offset = sn->l1_table_offset;
|
|
|
|
s->l1_table = new_l1_table;
|
|
|
|
|
2010-09-22 04:58:41 +02:00
|
|
|
for(i = 0;i < s->l1_size; i++) {
|
|
|
|
be64_to_cpus(&s->l1_table[i]);
|
|
|
|
}
|
2011-11-16 17:30:33 +01:00
|
|
|
|
2010-09-22 04:58:41 +02:00
|
|
|
return 0;
|
|
|
|
}
|