use PVE::Exception qw(raise raise_param_exc);
use PVE::Storage;
use PVE::Tools qw(run_command lock_file file_read_firstline);
+use PVE::JSONSchema qw(get_standard_option);
use PVE::Cluster qw(cfs_register_file cfs_read_file cfs_write_file cfs_lock_file);
use PVE::INotify;
use PVE::ProcFSTools;
use PVE::QMPClient;
+use PVE::RPCEnvironment;
use Time::HiRes qw(gettimeofday);
my $cpuinfo = PVE::ProcFSTools::read_cpuinfo();
# Note about locking: we use flock on the config file protect
# against concurent actions.
# Aditionaly, we have a 'lock' setting in the config file. This
-# can be set to 'migrate' or 'backup'. Most actions are not
+# can be set to 'migrate', 'backup', 'snapshot' or 'rollback'. Most actions are not
# allowed when such lock is set. But you can ignore this kind of
# lock with the --skiplock flag.
optional => 1,
});
+PVE::JSONSchema::register_standard_option('pve-snapshot-name', {
+ description => "The name of the snapshot.",
+ type => 'string', format => 'pve-configid',
+ maxLength => 40,
+});
+
#no warnings 'redefine';
unless(defined(&_VZSYSCALLS_H_)) {
hotplug => {
optional => 1,
type => 'boolean',
- description => "Activate hotplug for disk and network device",
+ description => "Allow hotplug for disk and network device",
default => 0,
},
reboot => {
optional => 1,
type => 'string',
description => "Lock/unlock the VM.",
- enum => [qw(migrate backup)],
+ enum => [qw(migrate backup snapshot rollback)],
},
cpulimit => {
optional => 1,
balloon => {
optional => 1,
type => 'integer',
- description => "Amount of target RAM for the VM in MB.",
- minimum => 16,
+ description => "Amount of target RAM for the VM in MB. Using zero disables the ballon driver.",
+ minimum => 0,
+ },
+ shares => {
+ optional => 1,
+ type => 'integer',
+ description => "Amount of memory shares for auto-ballooning. The larger the number is, the more memory this VM gets. Number is relative to weights of all other running VMs. Using zero disables auto-ballooning",
+ minimum => 0,
+ maximum => 50000,
+ default => 1000,
},
keyboard => {
optional => 1,
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 => {
typetext => '[[order=]\d+] [,up=\d+] [,down=\d+] ',
description => "Startup and shutdown behavior. Order is a non-negative number defining the general startup order. Shutdown in done with reverse ordering. Additionally you can set the 'up' or 'down' delay in seconds, which specifies a delay to wait before the next VM is started or stopped.",
},
+ template => {
+ optional => 1,
+ type => 'boolean',
+ description => "Enable/disable Template.",
+ default => 0,
+ },
args => {
optional => 1,
type => 'string',
},
migrate_downtime => {
optional => 1,
- type => 'integer',
+ type => 'number',
description => "Set maximum tolerated downtime (in seconds) for migrations.",
minimum => 0,
- default => 1,
+ default => 0.1,
},
cdrom => {
optional => 1,
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) ],
- default => 'qemu64',
+ 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 => 'kvm64',
+ },
+ 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.",
},
};
'ne2k_isa', 'i82551', 'i82557b', 'i82559er'];
my $nic_model_list_txt = join(' ', sort @$nic_model_list);
-# fixme:
my $netdesc = {
optional => 1,
type => 'string', format => 'pve-qm-net',
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',
};
} else {
$path = PVE::Storage::path($storecfg, $volid);
}
- if (!$drive->{cache} && ($path =~ m|^/dev/| || $path =~ m|\.raw$|)) {
- $opts .= ",cache=none";
- }
}
+ $opts .= ",cache=none" if !$drive->{cache} && !drive_is_cdrom($drive);
+
my $pathinfo = $path ? "file=$path," : '';
return "${pathinfo}if=none,id=drive-$drive->{interface}$drive->{index}$opts";
if ($kvp =~ m/^(ne2k_pci|e1000|rtl8139|pcnet|virtio|ne2k_isa|i82551|i82557b|i82559er)(=([0-9a-f]{2}(:[0-9a-f]{2}){5}))?$/i) {
my $model = lc($1);
- my $mac = uc($3) || PVE::Tools::random_ether_addr();
+ my $mac = defined($3) ? uc($3) : PVE::Tools::random_ether_addr();
$res->{model} = $model;
$res->{macaddr} = $mac;
} elsif ($kvp =~ m/^bridge=(\S+)$/) {
return $key;
}
-# fixme: remove all thos $noerr parameters?
-
PVE::JSONSchema::register_format('pve-qm-bootdisk', \&verify_bootdisk);
sub verify_bootdisk {
my ($value, $noerr) = @_;
my $prop = shift;
foreach my $opt (keys %$confdesc) {
+ next if $opt eq 'parent' || $opt eq 'snaptime' || $opt eq 'vmstate';
$prop->{$opt} = $confdesc->{$opt};
}
} elsif ($type eq 'integer') {
return int($1) if $value =~ m/^(\d+)$/;
die "type check ('integer') failed - got '$value'\n";
+ } elsif ($type eq 'number') {
+ return $value if $value =~ m/^(\d+)(\.\d+)?$/;
+ die "type check ('number') failed - got '$value'\n";
} elsif ($type eq 'string') {
if (my $fmt = $confdesc->{$key}->{format}) {
if ($fmt eq 'pve-qm-drive') {
return if drive_is_cdrom($drive);
my $volid = $drive->{file};
+
return if !$volid || $volid =~ m|^/|;
my ($path, $owner) = PVE::Storage::path($storecfg, $volid);
my $res = {
digest => Digest::SHA::sha1_hex($raw),
+ snapshots => {},
};
$filename =~ m|/qemu-server/(\d+)\.conf$|
my $vmid = $1;
+ my $conf = $res;
my $descr = '';
- while ($raw && $raw =~ s/^(.*?)(\n|$)//) {
- my $line = $1;
-
+ my @lines = split(/\n/, $raw);
+ foreach my $line (@lines) {
next if $line =~ m/^\s*$/;
+
+ if ($line =~ m/^\[([a-z][a-z0-9_\-]+)\]\s*$/i) {
+ my $snapname = $1;
+ $conf->{description} = $descr if $descr;
+ $descr = '';
+ $conf = $res->{snapshots}->{$snapname} = {};
+ next;
+ }
if ($line =~ m/^\#(.*)\s*$/) {
$descr .= PVE::Tools::decode_text($1) . "\n";
if ($line =~ m/^(description):\s*(.*\S)\s*$/) {
$descr .= PVE::Tools::decode_text($2);
+ } elsif ($line =~ m/snapstate:\s*(prepare|delete)\s*$/) {
+ $conf->{snapstate} = $1;
} elsif ($line =~ m/^(args):\s*(.*\S)\s*$/) {
my $key = $1;
my $value = $2;
- $res->{$key} = $value;
+ $conf->{$key} = $value;
} elsif ($line =~ m/^([a-z][a-z_]*\d*):\s*(\S+)\s*$/) {
my $key = $1;
my $value = $2;
}
if ($key eq 'cdrom') {
- $res->{ide2} = $value;
+ $conf->{ide2} = $value;
} else {
- $res->{$key} = $value;
+ $conf->{$key} = $value;
}
}
}
}
- $res->{description} = $descr if $descr;
+ $conf->{description} = $descr if $descr;
- # convert old smp to sockets
- if ($res->{smp} && !$res->{sockets}) {
- $res->{sockets} = $res->{smp};
- }
- delete $res->{smp};
+ delete $res->{snapstate}; # just to be sure
return $res;
}
sub write_vm_config {
my ($filename, $conf) = @_;
+ delete $conf->{snapstate}; # just to be sure
+
if ($conf->{cdrom}) {
die "option ide2 conflicts with cdrom\n" if $conf->{ide2};
$conf->{ide2} = $conf->{cdrom};
delete $conf->{smp};
}
- my $new_volids = {};
- foreach my $key (keys %$conf) {
- next if $key eq 'digest' || $key eq 'description';
- my $value = $conf->{$key};
- eval { $value = check_type($key, $value); };
- die "unable to parse value of '$key' - $@" if $@;
+ my $used_volids = {};
+
+ 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 = 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) = @_;
- # gererate RAW data
- my $raw = '';
+ my $raw = '';
- # add description as comment to top of file
- my $descr = $conf->{description} || '';
- foreach my $cl (split(/\n/, $descr)) {
- $raw .= '#' . PVE::Tools::encode_text($cl) . "\n";
- }
+ # add description as comment to top of file
+ my $descr = $conf->{description} || '';
+ foreach my $cl (split(/\n/, $descr)) {
+ $raw .= '#' . PVE::Tools::encode_text($cl) . "\n";
+ }
- foreach my $key (sort keys %$conf) {
- next if $key eq 'digest' || $key eq 'description';
- $raw .= "$key: $conf->{$key}\n";
+ foreach my $key (sort keys %$conf) {
+ next if $key eq 'digest' || $key eq 'description' || $key eq 'snapshots';
+ $raw .= "$key: $conf->{$key}\n";
+ }
+ return $raw;
+ };
+
+ my $raw = &$generate_raw_config($conf);
+ foreach my $snapname (sort keys %{$conf->{snapshots}}) {
+ $raw .= "\n[$snapname]\n";
+ $raw .= &$generate_raw_config($conf->{snapshots}->{$snapname});
}
return $raw;
my @param = split(/\0/, $line);
my $cmd = $param[0];
- return if !$cmd || ($cmd !~ m|kvm$|);
+ return if !$cmd || ($cmd !~ m|kvm$| && $cmd !~ m|qemu-system-x86_64$|);
for (my $i = 0; $i < scalar (@param); $i++) {
my $p = $param[$i];
$d->{name} = $conf->{name} || "VM $vmid";
$d->{maxmem} = $conf->{memory} ? $conf->{memory}*(1024*1024) : 0;
+ if ($conf->{balloon}) {
+ $d->{balloon_min} = $conf->{balloon}*(1024*1024);
+ $d->{shares} = defined($conf->{shares}) ? $conf->{shares} : 1000;
+ }
+
$d->{uptime} = 0;
$d->{cpu} = 0;
$d->{mem} = 0;
$d->{diskread} = 0;
$d->{diskwrite} = 0;
+ $d->{template} = is_template($conf);
+
$res->{$vmid} = $d;
}
my $qmpclient = PVE::QMPClient->new();
+ my $ballooncb = sub {
+ my ($vmid, $resp) = @_;
+
+ my $info = $resp->{'return'};
+ return if !$info->{max_mem};
+
+ my $d = $res->{$vmid};
+
+ # use memory assigned to VM
+ $d->{maxmem} = $info->{max_mem};
+ $d->{balloon} = $info->{actual};
+
+ if (defined($info->{total_mem}) && defined($info->{free_mem})) {
+ $d->{mem} = $info->{total_mem} - $info->{free_mem};
+ $d->{freemem} = $info->{free_mem};
+ }
+
+ };
+
my $blockstatscb = sub {
my ($vmid, $resp) = @_;
my $data = $resp->{'return'} || [];
my $statuscb = sub {
my ($vmid, $resp) = @_;
+
$qmpclient->queue_cmd($vmid, $blockstatscb, 'query-blockstats');
+ # this fails if ballon driver is not loaded, so this must be
+ # the last commnand (following command are aborted if this fails).
+ $qmpclient->queue_cmd($vmid, $ballooncb, 'query-balloon');
my $status = 'unknown';
if (!defined($status = $resp->{'return'}->{status})) {
}
}
+sub foreach_volid {
+ my ($conf, $func) = @_;
+
+ my $volhash = {};
+
+ my $test_volid = sub {
+ my ($volid, $is_cdrom) = @_;
+
+ return if !$volid;
+
+ $volhash->{$volid} = $is_cdrom || 0;
+ };
+
+ 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);
+ 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;
+ $pciaddr = print_pci_addr("piix3", $bridges);
+ push @$devices, '-device', "piix3-usb-uhci,id=uhci$pciaddr.0x2";
my $use_usb2 = 0;
for (my $i = 0; $i < $MAX_USB_DEVICES; $i++) {
# enable absolute mouse coordinates (needed by vnc)
my $tablet = defined($conf->{tablet}) ? $conf->{tablet} : $defaults->{tablet};
- if ($tablet) {
- if ($use_usb2) {
- push @$devices, '-device', 'usb-tablet,bus=ehci.0,port=6';
- } else {
- push @$devices, '-usbdevice', 'tablet';
- }
- }
+ push @$devices, '-device', 'usb-tablet,id=tablet,bus=uhci.0,port=1' if $tablet;
# host pci devices
for (my $i = 0; $i < $MAX_HOSTPCI_DEVICES; $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 @$devices, '-device', 'virtserialport,chardev=qga0,name=org.qemu.guest_agent.0';
}
- $pciaddr = print_pci_addr("balloon0", $bridges);
- push @$devices, '-device', "virtio-balloon-pci,id=balloon0$pciaddr" if $conf->{balloon};
+ # enable balloon by default, unless explicitly disabled
+ if (!defined($conf->{balloon}) || $conf->{balloon}) {
+ $pciaddr = print_pci_addr("balloon0", $bridges);
+ push @$devices, '-device', "virtio-balloon-pci,id=balloon0$pciaddr";
+ }
if ($conf->{watchdog}) {
my $wdopts = parse_watchdog($conf->{watchdog});
}
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 vm_deviceplug {
my ($storecfg, $conf, $vmid, $deviceid, $device) = @_;
- return 1 if !check_running($vmid) || !$conf->{hotplug};
+ return 1 if !check_running($vmid);
+
+ if ($deviceid eq 'tablet') {
+ my $devicefull = "usb-tablet,id=tablet,bus=uhci.0,port=1";
+ qemu_deviceadd($vmid, $devicefull);
+ return 1;
+ }
+
+ return 1 if !$conf->{hotplug};
my $devices_list = vm_devices_list($vmid);
return 1 if defined($devices_list->{$deviceid});
sub vm_deviceunplug {
my ($vmid, $conf, $deviceid) = @_;
- return 1 if !check_running ($vmid) || !$conf->{hotplug};
+ return 1 if !check_running ($vmid);
+
+ if ($deviceid eq 'tablet') {
+ qemu_devicedel($vmid, $deviceid);
+ return 1;
+ }
+
+ return 1 if !$conf->{hotplug};
my $devices_list = vm_devices_list($vmid);
return 1 if !defined($devices_list->{$deviceid});
die "can't unplug bootdisk" if $conf->{bootdisk} && $conf->{bootdisk} eq $deviceid;
if ($deviceid =~ m/^(virtio)(\d+)$/) {
- return undef if !qemu_drivedel($vmid, $deviceid);
qemu_devicedel($vmid, $deviceid);
return undef if !qemu_devicedelverify($vmid, $deviceid);
+ return undef if !qemu_drivedel($vmid, $deviceid);
}
if ($deviceid =~ m/^(lsi)(\d+)$/) {
}
if ($deviceid =~ m/^(net)(\d+)$/) {
- return undef if !qemu_netdevdel($vmid, $deviceid);
qemu_devicedel($vmid, $deviceid);
return undef if !qemu_devicedelverify($vmid, $deviceid);
+ return undef if !qemu_netdevdel($vmid, $deviceid);
}
return 1;
sub qemu_deviceadd {
my ($vmid, $devicefull) = @_;
- my $ret = vm_human_monitor_command($vmid, "device_add $devicefull");
- $ret =~ s/^\s+//;
- # Otherwise, if the command succeeds, no output is sent. So any non-empty string shows an error
- return 1 if $ret eq "";
- syslog("err", "error on hotplug device : $ret");
- return undef;
+ $devicefull = "driver=".$devicefull;
+ my %options = split(/[=,]/, $devicefull);
+ vm_mon_cmd($vmid, "device_add" , %options);
+ return 1;
}
sub qemu_devicedel {
my($vmid, $deviceid) = @_;
-
- my $ret = vm_human_monitor_command($vmid, "device_del $deviceid");
- $ret =~ s/^\s+//;
- return 1 if $ret eq "";
- syslog("err", "detaching device $deviceid failed : $ret");
- return undef;
+ my $ret = vm_mon_cmd($vmid, "device_del", id => $deviceid);
+ return 1;
}
sub qemu_driveadd {
my ($vmid, $conf, $device, $deviceid) = @_;
my $netdev = print_netdev_full($vmid, $conf, $device, $deviceid);
- my $ret = vm_human_monitor_command($vmid, "netdev_add $netdev");
- $ret =~ s/^\s+//;
+ my %options = split(/[=,]/, $netdev);
- #if the command succeeds, no output is sent. So any non-empty string shows an error
- return 1 if $ret eq "";
- syslog("err", "adding netdev failed: $ret");
- return undef;
+ vm_mon_cmd($vmid, "netdev_add", %options);
+ return 1;
}
sub qemu_netdevdel {
my ($vmid, $deviceid) = @_;
- my $ret = vm_human_monitor_command($vmid, "netdev_del $deviceid");
- $ret =~ s/^\s+//;
- #if the command succeeds, no output is sent. So any non-empty string shows an error
- return 1 if $ret eq "";
- syslog("err", "deleting netdev failed: $ret");
- return undef;
+ vm_mon_cmd($vmid, "netdev_del", id => $deviceid);
+ return 1;
}
sub qemu_block_set_io_throttle {
sub qemu_block_resize {
my ($vmid, $deviceid, $storecfg, $volid, $size) = @_;
- my $running = PVE::QemuServer::check_running($vmid);
+ my $running = check_running($vmid);
return if !PVE::Storage::volume_resize($storecfg, $volid, $size, $running);
sub qemu_volume_snapshot {
my ($vmid, $deviceid, $storecfg, $volid, $snap) = @_;
- my $running = PVE::QemuServer::check_running($vmid);
+ my $running = check_running($vmid);
return if !PVE::Storage::volume_snapshot($storecfg, $volid, $snap, $running);
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);
+ my $running = 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 {
}
sub vm_start {
- my ($storecfg, $vmid, $statefile, $skiplock, $migratedfrom) = @_;
+ my ($storecfg, $vmid, $statefile, $skiplock, $migratedfrom, $paused) = @_;
lock_config($vmid, sub {
my $conf = load_config($vmid, $migratedfrom);
+ die "you can't start a vm if it's a template\n" if is_template($conf);
+
check_lock($conf) if !$skiplock;
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;
}
+ } elsif ($paused) {
+ push @$cmd, '-S';
}
- 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) {
my $capabilities = {};
$capabilities->{capability} = "xbzrle";
$capabilities->{state} = JSON::true;
- eval { PVE::QemuServer::vm_mon_cmd_nocheck($vmid, "migrate-set-capabilities", capabilities => [$capabilities]); };
+ eval { vm_mon_cmd_nocheck($vmid, "migrate-set-capabilities", capabilities => [$capabilities]); };
+ }
+ else{
+
+ if (!defined($conf->{balloon}) || $conf->{balloon}) {
+ vm_mon_cmd_nocheck($vmid, "balloon", value => $conf->{balloon}*1024*1024)
+ if $conf->{balloon};
+ vm_mon_cmd_nocheck($vmid, 'qom-set',
+ path => "machine/peripheral/balloon0",
+ property => "guest-stats-polling-interval",
+ value => 2);
+ }
}
-
- vm_balloonset($vmid, $conf->{balloon}) if $conf->{balloon};
-
});
}
eval {
die "VM $vmid not running\n" if !check_running($vmid, $nocheck);
- my $sname = PVE::QemuServer::qmp_socket($vmid);
+ my $sname = qmp_socket($vmid);
if (-e $sname) {
my $qmpclient = PVE::QMPClient->new();
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;
});
my $conf = load_config($vmid);
- check_lock($conf) if !$skiplock;
+ check_lock($conf) if !($skiplock || ($conf->{lock} && $conf->{lock} eq 'backup'));
vm_mon_cmd($vmid, "stop");
});
my $conf = load_config($vmid);
- check_lock($conf) if !$skiplock;
+ check_lock($conf) if !($skiplock || ($conf->{lock} && $conf->{lock} eq 'backup'));
vm_mon_cmd($vmid, "cont");
});
my $res = '';
my $devices = {
- #addr1 : ide,parallel,serial (motherboard)
+ piix3 => { bus => 0, addr => 1 },
#addr2 : first videocard
balloon0 => { bus => 0, addr => 3 },
watchdog => { bus => 0, addr => 4 },
}
-sub vm_balloonset {
- my ($vmid, $value) = @_;
-
- vm_mon_cmd($vmid, "balloon", value => $value);
-}
-
# vzdump restore implementaion
-sub archive_read_firstfile {
+sub tar_archive_read_firstfile {
my $archive = shift;
die "ERROR: file '$archive' does not exist\n" if ! -f $archive;
return $firstfile;
}
-sub restore_cleanup {
- my $statfile = shift;
+sub tar_restore_cleanup {
+ my ($storecfg, $statfile) = @_;
print STDERR "starting cleanup\n";
if ($volid =~ m|^/|) {
unlink $volid || die 'unlink failed\n';
} else {
- my $cfg = cfs_read_file('storage.cfg');
- PVE::Storage::vdisk_free($cfg, $volid);
+ PVE::Storage::vdisk_free($storecfg, $volid);
}
print STDERR "temporary volume '$volid' sucessfuly removed\n";
};
sub restore_archive {
my ($archive, $vmid, $user, $opts) = @_;
- if ($archive ne '-') {
- my $firstfile = archive_read_firstfile($archive);
- die "ERROR: file '$archive' dos not lock like a QemuServer vzdump backup\n"
- if $firstfile ne 'qemu-server.conf';
+ my $format = $opts->{format};
+ my $comp;
+
+ if ($archive =~ m/\.tgz$/ || $archive =~ m/\.tar\.gz$/) {
+ $format = 'tar' if !$format;
+ $comp = 'gzip';
+ } elsif ($archive =~ m/\.tar$/) {
+ $format = 'tar' if !$format;
+ } elsif ($archive =~ m/.tar.lzo$/) {
+ $format = 'tar' if !$format;
+ $comp = 'lzop';
+ } elsif ($archive =~ m/\.vma$/) {
+ $format = 'vma' if !$format;
+ } elsif ($archive =~ m/\.vma\.gz$/) {
+ $format = 'vma' if !$format;
+ $comp = 'gzip';
+ } elsif ($archive =~ m/\.vma\.lzo$/) {
+ $format = 'vma' if !$format;
+ $comp = 'lzop';
+ } else {
+ $format = 'vma' if !$format; # default
}
- my $tocmd = "/usr/lib/qemu-server/qmextract";
+ # try to detect archive format
+ if ($format eq 'tar') {
+ return restore_tar_archive($archive, $vmid, $user, $opts);
+ } else {
+ return restore_vma_archive($archive, $vmid, $user, $opts, $comp);
+ }
+}
- $tocmd .= " --storage " . PVE::Tools::shellquote($opts->{storage}) if $opts->{storage};
- $tocmd .= " --pool " . PVE::Tools::shellquote($opts->{pool}) if $opts->{pool};
- $tocmd .= ' --prealloc' if $opts->{prealloc};
- $tocmd .= ' --info' if $opts->{info};
+sub restore_update_config_line {
+ my ($outfd, $cookie, $vmid, $map, $line, $unique) = @_;
+
+ return if $line =~ m/^\#qmdump\#/;
+ return if $line =~ m/^\#vzdump\#/;
+ return if $line =~ m/^lock:/;
+ return if $line =~ m/^unused\d+:/;
+ return if $line =~ m/^parent:/;
+
+ if (($line =~ m/^(vlan(\d+)):\s*(\S+)\s*$/)) {
+ # try to convert old 1.X settings
+ my ($id, $ind, $ethcfg) = ($1, $2, $3);
+ foreach my $devconfig (PVE::Tools::split_list($ethcfg)) {
+ my ($model, $macaddr) = split(/\=/, $devconfig);
+ $macaddr = PVE::Tools::random_ether_addr() if !$macaddr || $unique;
+ my $net = {
+ model => $model,
+ bridge => "vmbr$ind",
+ macaddr => $macaddr,
+ };
+ my $netstr = print_net($net);
- # tar option "xf" does not autodetect compression when read from STDIN,
- # so we pipe to zcat
- my $cmd = "zcat -f|tar xf " . PVE::Tools::shellquote($archive) . " " .
- PVE::Tools::shellquote("--to-command=$tocmd");
+ print $outfd "net$cookie->{netcount}: $netstr\n";
+ $cookie->{netcount}++;
+ }
+ } elsif (($line =~ m/^(net\d+):\s*(\S+)\s*$/) && $unique) {
+ my ($id, $netstr) = ($1, $2);
+ my $net = parse_net($netstr);
+ $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|sata)\d+):\s*(\S+)\s*$/) {
+ my $virtdev = $1;
+ my $value = $3;
+ if ($line =~ m/backup=no/) {
+ print $outfd "#$line";
+ } elsif ($virtdev && $map->{$virtdev}) {
+ my $di = parse_drive($virtdev, $value);
+ $di->{file} = $map->{$virtdev};
+ $value = print_drive($vmid, $di);
+ print $outfd "$virtdev: $value\n";
+ } else {
+ print $outfd $line;
+ }
+ } else {
+ print $outfd $line;
+ }
+}
- my $tmpdir = "/var/tmp/vzdumptmp$$";
- mkpath $tmpdir;
+sub scan_volids {
+ my ($cfg, $vmid) = @_;
- local $ENV{VZDUMP_TMPDIR} = $tmpdir;
- local $ENV{VZDUMP_VMID} = $vmid;
- local $ENV{VZDUMP_USER} = $user;
+ my $info = PVE::Storage::vdisk_list($cfg, undef, $vmid);
- my $conffile = PVE::QemuServer::config_file($vmid);
- my $tmpfn = "$conffile.$$.tmp";
+ my $volid_hash = {};
+ foreach my $storeid (keys %$info) {
+ foreach my $item (@{$info->{$storeid}}) {
+ next if !($item->{volid} && $item->{size});
+ $volid_hash->{$item->{volid}} = $item;
+ }
+ }
- # disable interrupts (always do cleanups)
- local $SIG{INT} = $SIG{TERM} = $SIG{QUIT} = $SIG{HUP} = sub {
- print STDERR "got interrupt - ignored\n";
- };
+ return $volid_hash;
+}
- eval {
- # enable interrupts
- local $SIG{INT} = $SIG{TERM} = $SIG{QUIT} = $SIG{HUP} = $SIG{PIPE} = sub {
- die "interrupted by signal\n";
- };
+sub update_disksize {
+ my ($vmid, $conf, $volid_hash) = @_;
+
+ my $changes;
- if ($archive eq '-') {
- print "extracting archive from STDIN\n";
- run_command($cmd, input => "<&STDIN");
- } else {
- print "extracting archive '$archive'\n";
- run_command($cmd);
- }
+ my $used = {};
- return if $opts->{info};
+ # update size info
+ foreach my $opt (keys %$conf) {
+ if (valid_drivename($opt)) {
+ my $drive = parse_drive($opt, $conf->{$opt});
+ my $volid = $drive->{file};
+ next if !$volid;
- # read new mapping
- my $map = {};
- my $statfile = "$tmpdir/qmrestore.stat";
- if (my $fd = IO::File->new($statfile, "r")) {
- while (defined (my $line = <$fd>)) {
- if ($line =~ m/vzdump:([^\s:]*):(\S+)$/) {
- $map->{$1} = $2 if $1;
- } else {
- print STDERR "unable to parse line in statfile - $line\n";
- }
- }
- $fd->close();
+ $used->{$volid} = 1;
+
+ next if drive_is_cdrom($drive);
+ next if !$volid_hash->{$volid};
+
+ $drive->{size} = $volid_hash->{$volid}->{size};
+ $changes = 1;
+ $conf->{$opt} = print_drive($vmid, $drive);
}
+ }
- my $confsrc = "$tmpdir/qemu-server.conf";
+ foreach my $volid (sort keys %$volid_hash) {
+ next if $volid =~ m/vm-$vmid-state-/;
+ next if $used->{$volid};
+ $changes = 1;
+ add_unused_volume($conf, $volid);
+ }
- my $srcfd = new IO::File($confsrc, "r") ||
- die "unable to open file '$confsrc'\n";
+ return $changes;
+}
- my $outfd = new IO::File ($tmpfn, "w") ||
- die "unable to write config for VM $vmid\n";
+sub rescan {
+ my ($vmid, $nolock) = @_;
- my $netcount = 0;
+ my $cfg = PVE::Cluster::cfs_read_file("storage.cfg");
- while (defined (my $line = <$srcfd>)) {
- next if $line =~ m/^\#vzdump\#/;
- next if $line =~ m/^lock:/;
- next if $line =~ m/^unused\d+:/;
-
- if (($line =~ m/^(vlan(\d+)):\s*(\S+)\s*$/)) {
- # try to convert old 1.X settings
- my ($id, $ind, $ethcfg) = ($1, $2, $3);
- foreach my $devconfig (PVE::Tools::split_list($ethcfg)) {
- my ($model, $macaddr) = split(/\=/, $devconfig);
- $macaddr = PVE::Tools::random_ether_addr() if !$macaddr || $opts->{unique};
- my $net = {
- model => $model,
- bridge => "vmbr$ind",
- macaddr => $macaddr,
- };
- my $netstr = print_net($net);
- print $outfd "net${netcount}: $netstr\n";
- $netcount++;
- }
- } elsif (($line =~ m/^(net\d+):\s*(\S+)\s*$/) && ($opts->{unique})) {
- my ($id, $netstr) = ($1, $2);
- my $net = parse_net($netstr);
- $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*$/) {
- my $virtdev = $1;
- my $value = $2;
- if ($line =~ m/backup=no/) {
- print $outfd "#$line";
- } elsif ($virtdev && $map->{$virtdev}) {
- my $di = PVE::QemuServer::parse_drive($virtdev, $value);
- $di->{file} = $map->{$virtdev};
- $value = PVE::QemuServer::print_drive($vmid, $di);
- print $outfd "$virtdev: $value\n";
- } else {
- print $outfd $line;
- }
- } else {
- print $outfd $line;
- }
+ my $volid_hash = scan_volids($cfg, $vmid);
+
+ my $updatefn = sub {
+ my ($vmid) = @_;
+
+ my $conf = load_config($vmid);
+
+ check_lock($conf);
+
+ my $vm_volids = {};
+ foreach my $volid (keys %$volid_hash) {
+ my $info = $volid_hash->{$volid};
+ $vm_volids->{$volid} = $info if $info->{vmid} && $info->{vmid} == $vmid;
}
- $srcfd->close();
- $outfd->close();
+ my $changes = update_disksize($vmid, $conf, $vm_volids);
+
+ update_config_nolock($vmid, $conf, 1) if $changes;
};
- my $err = $@;
- if ($err) {
+ if (defined($vmid)) {
+ if ($nolock) {
+ &$updatefn($vmid);
+ } else {
+ lock_config($vmid, $updatefn, $vmid);
+ }
+ } else {
+ my $vmlist = config_list();
+ foreach my $vmid (keys %$vmlist) {
+ if ($nolock) {
+ &$updatefn($vmid);
+ } else {
+ lock_config($vmid, $updatefn, $vmid);
+ }
+ }
+ }
+}
- unlink $tmpfn;
+sub restore_vma_archive {
+ my ($archive, $vmid, $user, $opts, $comp) = @_;
- restore_cleanup("$tmpdir/qmrestore.stat") if !$opts->{info};
+ my $input = $archive eq '-' ? "<&STDIN" : undef;
+ my $readfrom = $archive;
+
+ my $uncomp = '';
+ if ($comp) {
+ $readfrom = '-';
+ my $qarchive = PVE::Tools::shellquote($archive);
+ if ($comp eq 'gzip') {
+ $uncomp = "zcat $qarchive|";
+ } elsif ($comp eq 'lzop') {
+ $uncomp = "lzop -d -c $qarchive|";
+ } else {
+ die "unknown compression method '$comp'\n";
+ }
+
+ }
+
+ my $tmpdir = "/var/tmp/vzdumptmp$$";
+ rmtree $tmpdir;
+
+ # disable interrupts (always do cleanups)
+ local $SIG{INT} = $SIG{TERM} = $SIG{QUIT} = $SIG{HUP} = sub {
+ warn "got interrupt - ignored\n";
+ };
+
+ my $mapfifo = "/var/tmp/vzdumptmp$$.fifo";
+ POSIX::mkfifo($mapfifo, 0600);
+ my $fifofh;
+
+ my $openfifo = sub {
+ open($fifofh, '>', $mapfifo) || die $!;
+ };
+
+ my $cmd = "${uncomp}vma extract -v -r $mapfifo $readfrom $tmpdir";
+
+ my $oldtimeout;
+ my $timeout = 5;
+
+ my $devinfo = {};
+
+ my $rpcenv = PVE::RPCEnvironment::get();
+
+ my $conffile = config_file($vmid);
+ my $tmpfn = "$conffile.$$.tmp";
+
+ # Note: $oldconf is undef if VM does not exists
+ my $oldconf = PVE::Cluster::cfs_read_file(cfs_config_path($vmid));
+
+ my $print_devmap = sub {
+ my $virtdev_hash = {};
+
+ my $cfgfn = "$tmpdir/qemu-server.conf";
+
+ # we can read the config - that is already extracted
+ my $fh = IO::File->new($cfgfn, "r") ||
+ "unable to read qemu-server.conf - $!\n";
+
+ while (defined(my $line = <$fh>)) {
+ if ($line =~ m/^\#qmdump\#map:(\S+):(\S+):(\S*):(\S*):$/) {
+ my ($virtdev, $devname, $storeid, $format) = ($1, $2, $3, $4);
+ die "archive does not contain data for drive '$virtdev'\n"
+ if !$devinfo->{$devname};
+ if (defined($opts->{storage})) {
+ $storeid = $opts->{storage} || 'local';
+ } elsif (!$storeid) {
+ $storeid = 'local';
+ }
+ $format = 'raw' if !$format;
+ $devinfo->{$devname}->{devname} = $devname;
+ $devinfo->{$devname}->{virtdev} = $virtdev;
+ $devinfo->{$devname}->{format} = $format;
+ $devinfo->{$devname}->{storeid} = $storeid;
+
+ # check permission on storage
+ my $pool = $opts->{pool}; # todo: do we need that?
+ if ($user ne 'root@pam') {
+ $rpcenv->check($user, "/storage/$storeid", ['Datastore.AllocateSpace']);
+ }
+
+ $virtdev_hash->{$virtdev} = $devinfo->{$devname};
+ }
+ }
+
+ foreach my $devname (keys %$devinfo) {
+ die "found no device mapping information for device '$devname'\n"
+ if !$devinfo->{$devname}->{virtdev};
+ }
+
+ my $cfg = cfs_read_file('storage.cfg');
+
+ # create empty/temp config
+ if ($oldconf) {
+ PVE::Tools::file_set_contents($conffile, "memory: 128\n");
+ foreach_drive($oldconf, sub {
+ my ($ds, $drive) = @_;
+
+ return if drive_is_cdrom($drive);
+
+ my $volid = $drive->{file};
+
+ return if !$volid || $volid =~ m|^/|;
+
+ my ($path, $owner) = PVE::Storage::path($cfg, $volid);
+ return if !$path || !$owner || ($owner != $vmid);
+
+ # Note: only delete disk we want to restore
+ # other volumes will become unused
+ if ($virtdev_hash->{$ds}) {
+ PVE::Storage::vdisk_free($cfg, $volid);
+ }
+ });
+ }
+
+ my $map = {};
+ foreach my $virtdev (sort keys %$virtdev_hash) {
+ my $d = $virtdev_hash->{$virtdev};
+ my $alloc_size = int(($d->{size} + 1024 - 1)/1024);
+ my $scfg = PVE::Storage::storage_config($cfg, $d->{storeid});
+ my $volid = PVE::Storage::vdisk_alloc($cfg, $d->{storeid}, $vmid,
+ $d->{format}, undef, $alloc_size);
+ print STDERR "new volume ID is '$volid'\n";
+ $d->{volid} = $volid;
+ my $path = PVE::Storage::path($cfg, $volid);
+
+ my $write_zeros = 1;
+ # fixme: what other storages types initialize volumes with zero?
+ if ($scfg->{type} eq 'dir' || $scfg->{type} eq 'nfs' ||
+ $scfg->{type} eq 'sheepdog' || $scfg->{type} eq 'rbd') {
+ $write_zeros = 0;
+ }
+
+ print $fifofh "${write_zeros}:$d->{devname}=$path\n";
+
+ print "map '$d->{devname}' to '$path' (write zeros = ${write_zeros})\n";
+ $map->{$virtdev} = $volid;
+ }
+
+ $fh->seek(0, 0) || die "seek failed - $!\n";
+
+ my $outfd = new IO::File ($tmpfn, "w") ||
+ die "unable to write config for VM $vmid\n";
+
+ my $cookie = { netcount => 0 };
+ while (defined(my $line = <$fh>)) {
+ restore_update_config_line($outfd, $cookie, $vmid, $map, $line, $opts->{unique});
+ }
+
+ $fh->close();
+ $outfd->close();
+ };
+
+ eval {
+ # enable interrupts
+ local $SIG{INT} = $SIG{TERM} = $SIG{QUIT} = $SIG{HUP} = $SIG{PIPE} = sub {
+ die "interrupted by signal\n";
+ };
+ local $SIG{ALRM} = sub { die "got timeout\n"; };
+
+ $oldtimeout = alarm($timeout);
+
+ my $parser = sub {
+ my $line = shift;
+
+ print "$line\n";
+
+ if ($line =~ m/^DEV:\sdev_id=(\d+)\ssize:\s(\d+)\sdevname:\s(\S+)$/) {
+ my ($dev_id, $size, $devname) = ($1, $2, $3);
+ $devinfo->{$devname} = { size => $size, dev_id => $dev_id };
+ } elsif ($line =~ m/^CTIME: /) {
+ &$print_devmap();
+ print $fifofh "done\n";
+ my $tmp = $oldtimeout || 0;
+ $oldtimeout = undef;
+ alarm($tmp);
+ close($fifofh);
+ }
+ };
+
+ print "restore vma archive: $cmd\n";
+ run_command($cmd, input => $input, outfunc => $parser, afterfork => $openfifo);
+ };
+ my $err = $@;
+
+ alarm($oldtimeout) if $oldtimeout;
+
+ unlink $mapfifo;
+
+ if ($err) {
+ rmtree $tmpdir;
+ unlink $tmpfn;
+
+ my $cfg = cfs_read_file('storage.cfg');
+ foreach my $devname (keys %$devinfo) {
+ my $volid = $devinfo->{$devname}->{volid};
+ next if !$volid;
+ eval {
+ if ($volid =~ m|^/|) {
+ unlink $volid || die 'unlink failed\n';
+ } else {
+ PVE::Storage::vdisk_free($cfg, $volid);
+ }
+ print STDERR "temporary volume '$volid' sucessfuly removed\n";
+ };
+ print STDERR "unable to cleanup '$volid' - $@" if $@;
+ }
+ die $err;
+ }
+
+ rmtree $tmpdir;
+
+ rename($tmpfn, $conffile) ||
+ die "unable to commit configuration file '$conffile'\n";
+
+ PVE::Cluster::cfs_update(); # make sure we read new file
+
+ eval { rescan($vmid, 1); };
+ warn $@ if $@;
+}
+
+sub restore_tar_archive {
+ my ($archive, $vmid, $user, $opts) = @_;
+
+ if ($archive ne '-') {
+ my $firstfile = tar_archive_read_firstfile($archive);
+ die "ERROR: file '$archive' dos not lock like a QemuServer vzdump backup\n"
+ if $firstfile ne 'qemu-server.conf';
+ }
+
+ my $storecfg = cfs_read_file('storage.cfg');
+
+ # destroy existing data - keep empty config
+ my $vmcfgfn = PVE::QemuServer::config_file($vmid);
+ destroy_vm($storecfg, $vmid, 1) if -f $vmcfgfn;
+
+ my $tocmd = "/usr/lib/qemu-server/qmextract";
+
+ $tocmd .= " --storage " . PVE::Tools::shellquote($opts->{storage}) if $opts->{storage};
+ $tocmd .= " --pool " . PVE::Tools::shellquote($opts->{pool}) if $opts->{pool};
+ $tocmd .= ' --prealloc' if $opts->{prealloc};
+ $tocmd .= ' --info' if $opts->{info};
+
+ # tar option "xf" does not autodetect compression when read from STDIN,
+ # so we pipe to zcat
+ my $cmd = "zcat -f|tar xf " . PVE::Tools::shellquote($archive) . " " .
+ PVE::Tools::shellquote("--to-command=$tocmd");
+
+ my $tmpdir = "/var/tmp/vzdumptmp$$";
+ mkpath $tmpdir;
+
+ local $ENV{VZDUMP_TMPDIR} = $tmpdir;
+ local $ENV{VZDUMP_VMID} = $vmid;
+ local $ENV{VZDUMP_USER} = $user;
+
+ my $conffile = config_file($vmid);
+ my $tmpfn = "$conffile.$$.tmp";
+
+ # disable interrupts (always do cleanups)
+ local $SIG{INT} = $SIG{TERM} = $SIG{QUIT} = $SIG{HUP} = sub {
+ print STDERR "got interrupt - ignored\n";
+ };
+
+ eval {
+ # enable interrupts
+ local $SIG{INT} = $SIG{TERM} = $SIG{QUIT} = $SIG{HUP} = $SIG{PIPE} = sub {
+ die "interrupted by signal\n";
+ };
+
+ if ($archive eq '-') {
+ print "extracting archive from STDIN\n";
+ run_command($cmd, input => "<&STDIN");
+ } else {
+ print "extracting archive '$archive'\n";
+ run_command($cmd);
+ }
+
+ return if $opts->{info};
+
+ # read new mapping
+ my $map = {};
+ my $statfile = "$tmpdir/qmrestore.stat";
+ if (my $fd = IO::File->new($statfile, "r")) {
+ while (defined (my $line = <$fd>)) {
+ if ($line =~ m/vzdump:([^\s:]*):(\S+)$/) {
+ $map->{$1} = $2 if $1;
+ } else {
+ print STDERR "unable to parse line in statfile - $line\n";
+ }
+ }
+ $fd->close();
+ }
+
+ my $confsrc = "$tmpdir/qemu-server.conf";
+
+ my $srcfd = new IO::File($confsrc, "r") ||
+ die "unable to open file '$confsrc'\n";
+
+ my $outfd = new IO::File ($tmpfn, "w") ||
+ die "unable to write config for VM $vmid\n";
+
+ my $cookie = { netcount => 0 };
+ while (defined (my $line = <$srcfd>)) {
+ restore_update_config_line($outfd, $cookie, $vmid, $map, $line, $opts->{unique});
+ }
+
+ $srcfd->close();
+ $outfd->close();
+ };
+ my $err = $@;
+
+ if ($err) {
+
+ unlink $tmpfn;
+
+ tar_restore_cleanup($storecfg, "$tmpdir/qmrestore.stat") if !$opts->{info};
die $err;
}
rename $tmpfn, $conffile ||
die "unable to commit configuration file '$conffile'\n";
+
+ PVE::Cluster::cfs_update(); # make sure we read new file
+
+ eval { rescan($vmid, 1); };
+ warn $@ if $@;
};
+
+# Internal snapshots
+
+# NOTE: Snapshot create/delete involves several non-atomic
+# action, and can take a long time.
+# So we try to avoid locking the file and use 'lock' variable
+# inside the config file instead.
+
+my $snapshot_copy_config = sub {
+ my ($source, $dest) = @_;
+
+ 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};
+ }
+};
+
+my $snapshot_apply_config = sub {
+ my ($conf, $snap) = @_;
+
+ # copy snapshot list
+ my $newconf = {
+ snapshots => $conf->{snapshots},
+ };
+
+ # keep description and list of unused disks
+ foreach my $k (keys %$conf) {
+ next if !($k =~ m/^unused\d+$/ || $k eq 'description');
+ $newconf->{$k} = $conf->{$k};
+ }
+
+ &$snapshot_copy_config($snap, $newconf);
+
+ 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, $save_vmstate, $comment) = @_;
+
+ my $snap;
+
+ my $updatefn = sub {
+
+ my $conf = load_config($vmid);
+
+ die "you can't take a snapshot if it's a template\n"
+ if is_template($conf);
+
+ check_lock($conf);
+
+ $conf->{lock} = 'snapshot';
+
+ die "snapshot name '$snapname' already used\n"
+ if defined($conf->{snapshots}->{$snapname});
+
+ my $storecfg = PVE::Storage::config();
+ die "snapshot feature is not available" if !has_feature('snapshot', $conf, $storecfg);
+
+ $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);
+ };
+
+ lock_config($vmid, $updatefn);
+
+ return $snap;
+};
+
+my $snapshot_commit = sub {
+ my ($vmid, $snapname) = @_;
+
+ my $updatefn = sub {
+
+ my $conf = load_config($vmid);
+
+ die "missing snapshot lock\n"
+ if !($conf->{lock} && $conf->{lock} eq 'snapshot');
+
+ my $snap = $conf->{snapshots}->{$snapname};
+
+ die "snapshot '$snapname' does not exist\n" if !defined($snap);
+
+ die "wrong snapshot state\n"
+ 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);
+ };
+
+ lock_config($vmid, $updatefn);
+};
+
+sub snapshot_rollback {
+ my ($vmid, $snapname) = @_;
+
+ my $snap;
+
+ my $prepare = 1;
+
+ my $storecfg = PVE::Storage::config();
+
+ my $updatefn = sub {
+
+ my $conf = load_config($vmid);
+
+ die "you can't rollback if vm is a template\n" if is_template($conf);
+
+ $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);
+
+ if ($prepare) {
+ $conf->{lock} = 'rollback';
+ } else {
+ die "got wrong lock\n" if !($conf->{lock} && $conf->{lock} eq 'rollback');
+ delete $conf->{lock};
+ }
+
+ if (!$prepare) {
+ # copy snapshot config to current config
+ $conf = &$snapshot_apply_config($conf, $snap);
+ $conf->{parent} = $snapname;
+ }
+
+ update_config_nolock($vmid, $conf, 1);
+
+ if (!$prepare && $snap->{vmstate}) {
+ my $statefile = PVE::Storage::path($storecfg, $snap->{vmstate});
+ vm_start($storecfg, $vmid, $statefile);
+ }
+ };
+
+ lock_config($vmid, $updatefn);
+
+ foreach_drive($snap, sub {
+ my ($ds, $drive) = @_;
+
+ return if drive_is_cdrom($drive);
+
+ my $volid = $drive->{file};
+ my $device = "drive-$ds";
+
+ PVE::Storage::volume_snapshot_rollback($storecfg, $volid, $snapname);
+ });
+
+ $prepare = 0;
+ lock_config($vmid, $updatefn);
+}
+
+my $savevm_wait = sub {
+ my ($vmid) = @_;
+
+ for(;;) {
+ my $stat = 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, $save_vmstate, $freezefs, $comment) = @_;
+
+ my $snap = &$snapshot_prepare($vmid, $snapname, $save_vmstate, $comment);
+
+ $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
+
+ 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) = @_;
+
+ return if drive_is_cdrom($drive);
+
+ my $volid = $drive->{file};
+ my $device = "drive-$ds";
+
+ qemu_volume_snapshot($vmid, $device, $storecfg, $volid, $snapname);
+ $drivehash->{$ds} = 1;
+ });
+ };
+ my $err = $@;
+
+ eval { gqa_unfreezefs($vmid) if $running && $freezefs; };
+ warn $@ if $@;
+
+ 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, 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, $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);
+
+ if (!$drivehash) {
+ check_lock($conf);
+ die "you can't delete a snapshot if vm is a template\n"
+ if is_template($conf);
+ }
+
+ $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;
+ &$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);
+ }
+ }
+
+ if ($prepare) {
+ $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 vmstate file
+
+ my $storecfg = PVE::Storage::config();
+
+ 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";
+
+ 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
+ $prepare = 0;
+ lock_config($vmid, $updatefn);
+}
+
+sub has_feature {
+ my ($feature, $conf, $storecfg, $snapname, $running) = @_;
+
+ my $err = undef;
+ foreach_drive($conf, sub {
+ my ($ds, $drive) = @_;
+
+ return if drive_is_cdrom($drive);
+ my $volid = $drive->{file};
+ $err = 1 if !PVE::Storage::volume_has_feature($storecfg, $feature, $volid, $snapname, $running);
+ });
+
+ return 1 if !$err;
+}
+
+sub template_create {
+ my ($vmid, $conf, $disk) = @_;
+
+ my $running = check_running($vmid);
+ die "you can't convert a vm to template if vm is running vm\n" if $running;
+
+ my $storecfg = PVE::Storage::config();
+
+ foreach_drive($conf, sub {
+ my ($ds, $drive) = @_;
+
+ return if drive_is_cdrom($drive);
+ return if $disk && $ds ne $disk;
+
+ my $volid = $drive->{file};
+ return if !PVE::Storage::volume_has_feature($storecfg, 'template', $volid);
+
+ my $voliddst = PVE::Storage::vdisk_create_base($storecfg, $volid);
+ $drive->{file} = $voliddst;
+ $conf->{$ds} = PVE::QemuServer::print_drive($vmid, $drive);
+ PVE::QemuServer::update_config_nolock($vmid, $conf, 1);
+ });
+}
+
+sub is_template {
+ my ($conf) = @_;
+
+ return 1 if defined $conf->{template} && $conf->{template} == 1;
+}
+
1;