ostype => {
optional => 1,
type => 'string',
- enum => [qw(other wxp w2k w2k3 w2k8 wvista win7 l24 l26)],
+ enum => [qw(other wxp w2k w2k3 w2k8 wvista win7 win8 l24 l26)],
description => <<EODESC,
Used to enable special optimization/features for specific
operating systems:
w2k8 => Microsoft Windows 2008
wvista => Microsoft Windows Vista
win7 => Microsoft Windows 7
+win8 => Microsoft Windows 8/2012
l24 => Linux 2.4 Kernel
l26 => Linux 2.6/3.X Kernel
-other|l24|l26 ... no special behaviour
-wxp|w2k|w2k3|w2k8|wvista|win7 ... use --localtime switch
+other|l24|l26 ... no special behaviour
+wxp|w2k|w2k3|w2k8|wvista|win7|win8 ... use --localtime switch
EODESC
},
boot => {
tdf => {
optional => 1,
type => 'boolean',
- description => "Enable/disable time drift fix. This is ignored for kvm versions newer that 1.0 (not needed anymore).",
- default => 1,
+ description => "Enable/disable time drift fix.",
+ default => 0,
},
localtime => {
optional => 1,
vga => {
optional => 1,
type => 'string',
- description => "Select VGA type. If you want to use high resolution modes (>= 1280x1024x16) then you should use option 'std' or 'vmware'. Default is 'std' for win7/w2k8, and 'cirrur' for other OS types",
+ description => "Select VGA type. If you want to use high resolution modes (>= 1280x1024x16) then you should use option 'std' or 'vmware'. Default is 'std' for win8/win7/w2k8, and 'cirrur' for other OS types",
enum => [qw(std cirrus vmware)],
},
watchdog => {
optional => 1,
description => "Emulated CPU type.",
type => 'string',
- enum => [ qw(486 athlon pentium pentium2 pentium3 coreduo core2duo kvm32 kvm64 qemu32 qemu64 phenom cpu64-rhel6 cpu64-rhel5 Conroe Penryn Nehalem Westmere Opteron_G1 Opteron_G2 Opteron_G3 host) ],
+ enum => [ qw(486 athlon pentium pentium2 pentium3 coreduo core2duo kvm32 kvm64 qemu32 qemu64 phenom Conroe Penryn Nehalem Westmere SandyBridge Haswell Opteron_G1 Opteron_G2 Opteron_G3 Opteron_G4 Opteron_G5 host) ],
default => 'qemu64',
},
parent => get_standard_option('pve-snapshot-name', {
optional => 1,
description => "Parent snapshot name. This is used internally, and should not be modified.",
}),
+ snaptime => {
+ optional => 1,
+ description => "Timestamp for snapshots.",
+ type => 'integer',
+ minimum => 0,
+ },
+ vmstate => {
+ optional => 1,
+ type => 'string', format => 'pve-volume-id',
+ description => "Reference to a volume which stores the VM state. This is used internally for snapshots.",
+ },
};
# what about other qemu settings ?
my $tmp = `kvm -help 2>/dev/null`;
- if ($tmp =~ m/^QEMU( PC)? emulator version (\d+\.\d+(\.\d+)?) /) {
+ if ($tmp =~ m/^QEMU( PC)? emulator version (\d+\.\d+(\.\d+)?)[,\s]/) {
$kvm_user_version = $2;
}
w2k8 => 'Windows 2008',
wvista => 'Windows Vista',
win7 => 'Windows 7',
+ win8 => 'Windows 8/2012',
l24 => 'Linux 2.4',
l26 => 'Linux 2.6',
};
my $prop = shift;
foreach my $opt (keys %$confdesc) {
+ next if $opt eq 'parent' || $opt eq 'snaptime' || $opt eq 'vmstate';
$prop->{$opt} = $confdesc->{$opt};
}
if ($line =~ m/^\[([a-z][a-z0-9_\-]+)\]\s*$/i) {
my $snapname = $1;
$conf->{description} = $descr if $descr;
- my $descr = '';
+ $descr = '';
$conf = $res->{snapshots}->{$snapname} = {};
next;
}
delete $conf->{smp};
}
- # fixme: unused drives and snapshots??!!
+ my $used_volids = {};
- my $new_volids = {};
- foreach my $key (keys %$conf) {
- next if $key eq 'digest' || $key eq 'description' || $key eq 'snapshots';
- my $value = $conf->{$key};
- eval { $value = check_type($key, $value); };
- die "unable to parse value of '$key' - $@" if $@;
+ my $cleanup_config = sub {
+ my ($cref) = @_;
- $conf->{$key} = $value;
+ foreach my $key (keys %$cref) {
+ next if $key eq 'digest' || $key eq 'description' || $key eq 'snapshots' ||
+ $key eq 'snapstate';
+ my $value = $cref->{$key};
+ eval { $value = check_type($key, $value); };
+ die "unable to parse value of '$key' - $@" if $@;
+
+ $cref->{$key} = $value;
- if (valid_drivename($key)) {
- my $drive = PVE::QemuServer::parse_drive($key, $value);
- $new_volids->{$drive->{file}} = 1 if $drive && $drive->{file};
+ if (valid_drivename($key)) {
+ my $drive = PVE::QemuServer::parse_drive($key, $value);
+ $used_volids->{$drive->{file}} = 1 if $drive && $drive->{file};
+ }
}
+ };
+
+ &$cleanup_config($conf);
+ foreach my $snapname (keys %{$conf->{snapshots}}) {
+ &$cleanup_config($conf->{snapshots}->{$snapname});
}
# remove 'unusedX' settings if we re-add a volume
foreach my $key (keys %$conf) {
my $value = $conf->{$key};
- if ($key =~ m/^unused/ && $new_volids->{$value}) {
+ if ($key =~ m/^unused/ && $used_volids->{$value}) {
delete $conf->{$key};
}
}
-
+
my $generate_raw_config = sub {
my ($conf) = @_;
}
}
+sub foreach_volid {
+ my ($conf, $func) = @_;
+
+ my $volhash = {};
+
+ my $test_volid = sub {
+ my ($volid, $is_cdrom) = @_;
+
+ return if !$volid;
+
+ $volhash->{$volid} = $is_cdrom || 0;
+ };
+
+ PVE::QemuServer::foreach_drive($conf, sub {
+ my ($ds, $drive) = @_;
+ &$test_volid($drive->{file}, drive_is_cdrom($drive));
+ });
+
+ foreach my $snapname (keys %{$conf->{snapshots}}) {
+ my $snap = $conf->{snapshots}->{$snapname};
+ &$test_volid($snap->{vmstate}, 0);
+ PVE::QemuServer::foreach_drive($snap, sub {
+ my ($ds, $drive) = @_;
+ &$test_volid($drive->{file}, drive_is_cdrom($drive));
+ });
+ }
+
+ foreach my $volid (keys %$volhash) {
+ &$func($volid, $volhash->{$volid});
+ }
+}
+
sub config_to_command {
- my ($storecfg, $vmid, $conf, $defaults, $migrate_uri) = @_;
+ my ($storecfg, $vmid, $conf, $defaults) = @_;
my $cmd = [];
+ my $globalFlags = [];
+ my $machineFlags = [];
+ my $rtcFlags = [];
my $devices = [];
my $pciaddr = '';
my $bridges = {};
push @$cmd, '-daemonize';
- push @$cmd, '-incoming', $migrate_uri if $migrate_uri;
-
- push @$cmd, '-S' if $migrate_uri;
-
my $use_usb2 = 0;
for (my $i = 0; $i < $MAX_USB_DEVICES; $i++) {
next if !$conf->{"usb$i"};
my $vga = $conf->{vga};
if (!$vga) {
- if ($conf->{ostype} && ($conf->{ostype} eq 'win7' || $conf->{ostype} eq 'w2k8')) {
+ if ($conf->{ostype} && ($conf->{ostype} eq 'win8' || $conf->{ostype} eq 'win7' || $conf->{ostype} eq 'w2k8')) {
$vga = 'std';
} else {
$vga = 'cirrus';
# time drift fix
my $tdf = defined($conf->{tdf}) ? $conf->{tdf} : $defaults->{tdf};
- # ignore - no longer supported by newer kvm
- # push @$cmd, '-tdf' if $tdf;
my $nokvm = defined($conf->{kvm}) && $conf->{kvm} == 0 ? 1 : 0;
+ my $useLocaltime = $conf->{localtime};
if (my $ost = $conf->{ostype}) {
- # other, wxp, w2k, w2k3, w2k8, wvista, win7, l24, l26
+ # other, wxp, w2k, w2k3, w2k8, wvista, win7, win8, l24, l26
if ($ost =~ m/^w/) { # windows
- push @$cmd, '-localtime' if !defined($conf->{localtime});
+ $useLocaltime = 1 if !defined($conf->{localtime});
- # use rtc-td-hack when acpi is enabled
+ # use time drift fix when acpi is enabled
if (!(defined($conf->{acpi}) && $conf->{acpi} == 0)) {
- push @$cmd, '-rtc-td-hack';
+ $tdf = 1 if !defined($conf->{tdf});
}
}
- if ($ost eq 'win7' || $ost eq 'w2k8' || $ost eq 'wvista') {
- push @$cmd, '-no-kvm-pit-reinjection';
+ if ($ost eq 'win7' || $ost eq 'win8' || $ost eq 'w2k8' ||
+ $ost eq 'wvista') {
+ push @$globalFlags, 'kvm-pit.lost_tick_policy=discard';
push @$cmd, '-no-hpet';
}
-
- # -tdf ?
- # -no-acpi
- # -no-kvm
- # -win2k-hack ?
}
+ push @$rtcFlags, 'driftfix=slew' if $tdf;
+
if ($nokvm) {
- push @$cmd, '-no-kvm';
+ push @$machineFlags, 'accel=tcg';
} else {
die "No accelerator found!\n" if !$cpuinfo->{hvm};
}
- push @$cmd, '-localtime' if $conf->{localtime};
-
- push @$cmd, '-startdate', $conf->{startdate} if $conf->{startdate};
+ if ($conf->{startdate}) {
+ push @$rtcFlags, "base=$conf->{startdate}";
+ } elsif ($useLocaltime) {
+ push @$rtcFlags, 'base=localtime';
+ }
push @$cmd, '-S' if $conf->{freeze};
}
push @$cmd, @$devices;
+ push @$cmd, '-rtc', join(',', @$rtcFlags)
+ if scalar(@$rtcFlags);
+ push @$cmd, '-machine', join(',', @$machineFlags)
+ if scalar(@$machineFlags);
+ push @$cmd, '-global', join(',', @$globalFlags)
+ if scalar(@$globalFlags);
+
return wantarray ? ($cmd, $vollist) : $cmd;
}
sub qemu_volume_snapshot_delete {
my ($vmid, $deviceid, $storecfg, $volid, $snap) = @_;
- #need to implement statefile location
- my $statefile="/tmp/$vmid-$snap";
-
- unlink $statefile if -e $statefile;
-
my $running = PVE::QemuServer::check_running($vmid);
return if !PVE::Storage::volume_snapshot_delete($storecfg, $volid, $snap, $running);
return if !$running;
- #need to split delvm monitor command like savevm
-
-}
-
-sub qemu_snapshot_start {
- my ($vmid, $snap) = @_;
-
- #need to implement statefile location
- my $statefile="/tmp/$vmid-$snap";
-
- vm_mon_cmd($vmid, "snapshot-start", statefile => $statefile);
-
-}
-
-sub qemu_snapshot_end {
- my ($vmid) = @_;
-
- vm_mon_cmd($vmid, "snapshot-end");
-
+ vm_mon_cmd($vmid, "delete-drive-snapshot", device => $deviceid, name => $snap);
}
sub qga_freezefs {
die "VM $vmid already running\n" if check_running($vmid, undef, $migratedfrom);
- my $migrate_uri;
+ my $defaults = load_defaults();
+
+ # set environment variable useful inside network script
+ $ENV{PVE_MIGRATED_FROM} = $migratedfrom if $migratedfrom;
+
+ my ($cmd, $vollist) = config_to_command($storecfg, $vmid, $conf, $defaults);
+
my $migrate_port = 0;
if ($statefile) {
if ($statefile eq 'tcp') {
$migrate_port = next_migrate_port();
- $migrate_uri = "tcp:localhost:${migrate_port}";
+ my $migrate_uri = "tcp:localhost:${migrate_port}";
+ push @$cmd, '-incoming', $migrate_uri;
+ push @$cmd, '-S';
} else {
- if (-f $statefile) {
- $migrate_uri = "exec:cat $statefile";
- } else {
- warn "state file '$statefile' does not exist - doing normal startup\n";
- }
+ push @$cmd, '-loadstate', $statefile;
}
}
- my $defaults = load_defaults();
-
- # set environment variable useful inside network script
- $ENV{PVE_MIGRATED_FROM} = $migratedfrom if $migratedfrom;
-
- my ($cmd, $vollist) = config_to_command($storecfg, $vmid, $conf, $defaults, $migrate_uri);
# host pci devices
for (my $i = 0; $i < $MAX_HOSTPCI_DEVICES; $i++) {
my $d = parse_hostpci($conf->{"hostpci$i"});
PVE::Storage::activate_volumes($storecfg, $vollist);
- eval { run_command($cmd, timeout => $migrate_uri ? undef : 30); };
+ eval { run_command($cmd, timeout => $statefile ? undef : 30,
+ umask => 0077); };
my $err = $@;
die "start failed: $err" if $err;
- if ($statefile) {
-
- if ($statefile eq 'tcp') {
- print "migration listens on port $migrate_port\n";
- } else {
- unlink $statefile;
- # fixme: send resume - is that necessary ?
- eval { vm_mon_cmd($vmid, "cont"); };
- }
- }
-
- # always set migrate speed (overwrite kvm default of 32m)
- # we set a very hight default of 8192m which is basically unlimited
- my $migrate_speed = $defaults->{migrate_speed} || 8192;
- $migrate_speed = $conf->{migrate_speed} || $migrate_speed;
- $migrate_speed = $migrate_speed * 1048576;
- eval {
- vm_mon_cmd($vmid, "migrate_set_speed", value => $migrate_speed);
- };
+ print "migration listens on port $migrate_port\n" if $migrate_port;
- my $migrate_downtime = $defaults->{migrate_downtime};
- $migrate_downtime = $conf->{migrate_downtime} if defined($conf->{migrate_downtime});
- if (defined($migrate_downtime)) {
- eval { vm_mon_cmd($vmid, "migrate_set_downtime", value => $migrate_downtime); };
+ if ($statefile && $statefile ne 'tcp') {
+ eval { vm_mon_cmd_nocheck($vmid, "cont"); };
+ warn $@ if $@;
}
if($migratedfrom) {
eval { PVE::QemuServer::vm_mon_cmd_nocheck($vmid, "migrate-set-capabilities", capabilities => [$capabilities]); };
}
- vm_balloonset($vmid, $conf->{balloon}) if $conf->{balloon};
-
+ vm_mon_cmd_nocheck($vmid, "balloon", value => $conf->{balloon}*1024*1024)
+ if $conf->{balloon};
});
}
my ($conf) = @_;
my $vollist = [];
- foreach_drive($conf, sub {
- my ($ds, $drive) = @_;
+ foreach_volid($conf, sub {
+ my ($volid, $is_cdrom) = @_;
- my ($sid, $volname) = PVE::Storage::parse_volume_id($drive->{file}, 1);
- return if !$sid;
+ return if $volid =~ m|^/|;
- my $volid = $drive->{file};
- return if !$volid || $volid =~ m|^/|;
+ my ($sid, $volname) = PVE::Storage::parse_volume_id($volid, 1);
+ return if !$sid;
push @$vollist, $volid;
});
sub vm_balloonset {
my ($vmid, $value) = @_;
- vm_mon_cmd($vmid, "balloon", value => $value);
+ vm_mon_cmd($vmid, "balloon", value => $value*1024*1024);
}
# vzdump restore implementaion
$net->{macaddr} = PVE::Tools::random_ether_addr() if $net->{macaddr};
$netstr = print_net($net);
print $outfd "$id: $netstr\n";
- } elsif ($line =~ m/^((ide|scsi|virtio)\d+):\s*(\S+)\s*$/) {
+ } elsif ($line =~ m/^((ide|scsi|virtio|sata)\d+):\s*(\S+)\s*$/) {
my $virtdev = $1;
my $value = $2;
if ($line =~ m/backup=no/) {
foreach my $k (keys %$source) {
next if $k eq 'snapshots';
+ next if $k eq 'snapstate';
+ next if $k eq 'snaptime';
+ next if $k eq 'vmstate';
next if $k eq 'lock';
next if $k eq 'digest';
+ next if $k eq 'description';
next if $k =~ m/^unused\d+$/;
$dest->{$k} = $source->{$k};
snapshots => $conf->{snapshots},
};
- # keep list of unused disks
+ # keep description and list of unused disks
foreach my $k (keys %$conf) {
- next if $k !~ m/^unused\d+$/;
+ next if !($k =~ m/^unused\d+$/ || $k eq 'description');
$newconf->{$k} = $conf->{$k};
}
return $newconf;
};
+sub foreach_writable_storage {
+ my ($conf, $func) = @_;
+
+ my $sidhash = {};
+
+ foreach my $ds (keys %$conf) {
+ next if !valid_drivename($ds);
+
+ my $drive = parse_drive($ds, $conf->{$ds});
+ next if !$drive;
+ next if drive_is_cdrom($drive);
+
+ my $volid = $drive->{file};
+
+ my ($sid, $volname) = PVE::Storage::parse_volume_id($volid, 1);
+ $sidhash->{$sid} = $sid if $sid;
+ }
+
+ foreach my $sid (sort keys %$sidhash) {
+ &$func($sid);
+ }
+}
+
+my $alloc_vmstate_volid = sub {
+ my ($storecfg, $vmid, $conf, $snapname) = @_;
+
+ # Note: we try to be smart when selecting a $target storage
+
+ my $target;
+
+ # search shared storage first
+ foreach_writable_storage($conf, sub {
+ my ($sid) = @_;
+ my $scfg = PVE::Storage::storage_config($storecfg, $sid);
+ return if !$scfg->{shared};
+
+ $target = $sid if !$target || $scfg->{path}; # prefer file based storage
+ });
+
+ if (!$target) {
+ # now search local storage
+ foreach_writable_storage($conf, sub {
+ my ($sid) = @_;
+ my $scfg = PVE::Storage::storage_config($storecfg, $sid);
+ return if $scfg->{shared};
+
+ $target = $sid if !$target || $scfg->{path}; # prefer file based storage;
+ });
+ }
+
+ $target = 'local' if !$target;
+
+ my $driver_state_size = 500; # assume 32MB is enough to safe all driver state;
+ # we abort live save after $conf->{memory}, so we need at max twice that space
+ my $size = $conf->{memory}*2 + $driver_state_size;
+
+ my $name = "vm-$vmid-state-$snapname";
+ my $scfg = PVE::Storage::storage_config($storecfg, $target);
+ $name .= ".raw" if $scfg->{path}; # add filename extension for file base storage
+ my $volid = PVE::Storage::vdisk_alloc($storecfg, $target, $vmid, 'raw', $name, $size*1024);
+
+ return $volid;
+};
+
my $snapshot_prepare = sub {
- my ($vmid, $snapname) = @_;
+ my ($vmid, $snapname, $save_vmstate, $comment) = @_;
my $snap;
die "snapshot name '$snapname' already used\n"
if defined($conf->{snapshots}->{$snapname});
- # fixme: need to implement a check to see if all storages
- # support snapshots
+ my $storecfg = PVE::Storage::config();
- $snap = $conf->{snapshots}->{$snapname} = {
- snapstate => "prepare",
- };
+ foreach_drive($conf, sub {
+ my ($ds, $drive) = @_;
+
+ return if drive_is_cdrom($drive);
+ my $volid = $drive->{file};
+
+ my ($storeid, $volname) = PVE::Storage::parse_volume_id($volid, 1);
+ if ($storeid) {
+ my $scfg = PVE::Storage::storage_config($storecfg, $storeid);
+ die "can't snapshot volume '$volid'\n"
+ if !(($scfg->{path} && $volname =~ m/\.qcow2$/) ||
+ ($scfg->{type} eq 'nexenta') ||
+ ($scfg->{type} eq 'rbd') ||
+ ($scfg->{type} eq 'sheepdog'));
+ } elsif ($volid =~ m|^(/.+)$| && -e $volid) {
+ die "snapshot device '$volid' is not possible\n";
+ } else {
+ die "can't snapshot volume '$volid'\n";
+ }
+ });
+
+
+ $snap = $conf->{snapshots}->{$snapname} = {};
+
+ if ($save_vmstate && check_running($vmid)) {
+ $snap->{vmstate} = &$alloc_vmstate_volid($storecfg, $vmid, $conf, $snapname);
+ }
&$snapshot_copy_config($conf, $snap);
+ $snap->{snapstate} = "prepare";
+ $snap->{snaptime} = time();
+ $snap->{description} = $comment if $comment;
+
update_config_nolock($vmid, $conf, 1);
};
if !($snap->{snapstate} && $snap->{snapstate} eq "prepare");
delete $snap->{snapstate};
+ delete $conf->{lock};
my $newconf = &$snapshot_apply_config($conf, $snap);
+ $newconf->{parent} = $snapname;
+
update_config_nolock($vmid, $newconf, 1);
};
my $prepare = 1;
+ my $storecfg = PVE::Storage::config();
+
my $updatefn = sub {
my $conf = load_config($vmid);
- check_lock($conf) if $prepare;
+ $snap = $conf->{snapshots}->{$snapname};
+
+ die "snapshot '$snapname' does not exist\n" if !defined($snap);
+
+ die "unable to rollback to incomplete snapshot (snapstate = $snap->{snapstate})\n"
+ if $snap->{snapstate};
+
+ if ($prepare) {
+ check_lock($conf);
+ vm_stop($storecfg, $vmid, undef, undef, 5, undef, undef);
+ }
die "unable to rollback vm $vmid: vm is running\n"
if check_running($vmid);
delete $conf->{lock};
}
- $snap = $conf->{snapshots}->{$snapname};
-
- die "snapshot '$snapname' does not exist\n" if !defined($snap);
-
- die "unable to rollback to incomplete snapshot (snapstate = $snap->{snapstate})\n"
- if $snap->{snapstate};
-
if (!$prepare) {
# copy snapshot config to current config
$conf = &$snapshot_apply_config($conf, $snap);
}
update_config_nolock($vmid, $conf, 1);
+
+ if (!$prepare && $snap->{vmstate}) {
+ my $statefile = PVE::Storage::path($storecfg, $snap->{vmstate});
+ # fixme: this only forws for files currently
+ vm_start($storecfg, $vmid, $statefile);
+ }
+
};
lock_config($vmid, $updatefn);
-
- my $storecfg = PVE::Storage::config();
foreach_drive($snap, sub {
my ($ds, $drive) = @_;
lock_config($vmid, $updatefn);
}
+my $savevm_wait = sub {
+ my ($vmid) = @_;
+
+ for(;;) {
+ my $stat = PVE::QemuServer::vm_mon_cmd_nocheck($vmid, "query-savevm");
+ if (!$stat->{status}) {
+ die "savevm not active\n";
+ } elsif ($stat->{status} eq 'active') {
+ sleep(1);
+ next;
+ } elsif ($stat->{status} eq 'completed') {
+ last;
+ } else {
+ die "query-savevm returned status '$stat->{status}'\n";
+ }
+ }
+};
+
sub snapshot_create {
- my ($vmid, $snapname, $vmstate, $freezefs) = @_;
+ my ($vmid, $snapname, $save_vmstate, $freezefs, $comment) = @_;
+
+ my $snap = &$snapshot_prepare($vmid, $snapname, $save_vmstate, $comment);
- my $snap = &$snapshot_prepare($vmid, $snapname);
+ $freezefs = $save_vmstate = 0 if !$snap->{vmstate}; # vm is not running
+
+ my $drivehash = {};
+
+ my $running = check_running($vmid);
eval {
# create internal snapshots of all drives
-
- qemu_snapshot_start($vmid, $snapname) if $vmstate;
-
- qga_freezefs($vmid) if $freezefs;
my $storecfg = PVE::Storage::config();
+
+ if ($running) {
+ if ($snap->{vmstate}) {
+ my $path = PVE::Storage::path($storecfg, $snap->{vmstate});
+ vm_mon_cmd($vmid, "savevm-start", statefile => $path);
+ &$savevm_wait($vmid);
+ } else {
+ vm_mon_cmd($vmid, "savevm-start");
+ }
+ };
+
+ qga_freezefs($vmid) if $running && $freezefs;
foreach_drive($snap, sub {
my ($ds, $drive) = @_;
my $device = "drive-$ds";
qemu_volume_snapshot($vmid, $device, $storecfg, $volid, $snapname);
+ $drivehash->{$ds} = 1;
});
};
my $err = $@;
- eval { gqa_unfreezefs($vmid) if $freezefs; };
+ eval { gqa_unfreezefs($vmid) if $running && $freezefs; };
warn $@ if $@;
- eval { qemu_snapshot_end($vmid) if $vmstate; };
+ eval { vm_mon_cmd($vmid, "savevm-end") if $running; };
warn $@ if $@;
if ($err) {
warn "snapshot create failed: starting cleanup\n";
- eval { snapshot_delete($vmid, $snapname); };
+ eval { snapshot_delete($vmid, $snapname, 0, $drivehash); };
warn $@ if $@;
die $err;
}
&$snapshot_commit($vmid, $snapname);
}
+# Note: $drivehash is only set when called from snapshot_create.
sub snapshot_delete {
- my ($vmid, $snapname, $force) = @_;
+ my ($vmid, $snapname, $force, $drivehash) = @_;
my $prepare = 1;
my $snap;
+ my $unused = [];
+
+ my $unlink_parent = sub {
+ my ($confref, $new_parent) = @_;
+ if ($confref->{parent} && $confref->{parent} eq $snapname) {
+ if ($new_parent) {
+ $confref->{parent} = $new_parent;
+ } else {
+ delete $confref->{parent};
+ }
+ }
+ };
+
my $updatefn = sub {
+ my ($remove_drive) = @_;
my $conf = load_config($vmid);
- check_lock($conf) if !$force;
+ check_lock($conf) if !$drivehash;
$snap = $conf->{snapshots}->{$snapname};
die "snapshot '$snapname' does not exist\n" if !defined($snap);
# remove parent refs
+ &$unlink_parent($conf, $snap->{parent});
foreach my $sn (keys %{$conf->{snapshots}}) {
next if $sn eq $snapname;
- my $snapref = $conf->{snapshots}->{$sn};
- if ($snapref->{parent} && $snapref->{parent} eq $snapname) {
- if ($snap->{parent}) {
- $snapref->{parent} = $snap->{parent};
- } else {
- delete $snapref->{parent};
- }
+ &$unlink_parent($conf->{snapshots}->{$sn}, $snap->{parent});
+ }
+
+ if ($remove_drive) {
+ if ($remove_drive eq 'vmstate') {
+ delete $snap->{$remove_drive};
+ } else {
+ my $drive = parse_drive($remove_drive, $snap->{$remove_drive});
+ my $volid = $drive->{file};
+ delete $snap->{$remove_drive};
+ add_unused_volume($conf, $volid);
}
}
$snap->{snapstate} = 'delete';
} else {
delete $conf->{snapshots}->{$snapname};
+ delete $conf->{lock} if $drivehash;
+ foreach my $volid (@$unused) {
+ add_unused_volume($conf, $volid);
+ }
}
update_config_nolock($vmid, $conf, 1);
lock_config($vmid, $updatefn);
- # now remove all internal snapshots
+ # now remove vmstate file
my $storecfg = PVE::Storage::config();
- PVE::QemuServer::foreach_drive($snap, sub {
+ if ($snap->{vmstate}) {
+ eval { PVE::Storage::vdisk_free($storecfg, $snap->{vmstate}); };
+ if (my $err = $@) {
+ die $err if !$force;
+ warn $err;
+ }
+ # save changes (remove vmstate from snapshot)
+ lock_config($vmid, $updatefn, 'vmstate') if !$force;
+ };
+
+ # now remove all internal snapshots
+ foreach_drive($snap, sub {
my ($ds, $drive) = @_;
return if drive_is_cdrom($drive);
+
my $volid = $drive->{file};
my $device = "drive-$ds";
- qemu_volume_snapshot_delete($vmid, $device, $storecfg, $volid, $snapname);
+ if (!$drivehash || $drivehash->{$ds}) {
+ eval { qemu_volume_snapshot_delete($vmid, $device, $storecfg, $volid, $snapname); };
+ if (my $err = $@) {
+ die $err if !$force;
+ warn $err;
+ }
+ }
+
+ # save changes (remove drive fron snapshot)
+ lock_config($vmid, $updatefn, $ds) if !$force;
+ push @$unused, $volid;
});
# now cleanup config